Complex.Equals Metod

Definition

Namnområde:: System.Numerics

Sammansättningar:: System.Numerics.dll, System.Runtime.Numerics.dll

Sammansättningar:: netstandard.dll, System.Runtime.Numerics.dll

Sammansättning:: System.Runtime.Numerics.dll

Sammansättning:: System.Numerics.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Returnerar ett värde som anger om två komplexa tal är lika med.

Överlagringar

Name	Description
Equals(Object)	Returnerar ett värde som anger om den aktuella instansen och ett angivet objekt har samma värde.
Equals(Complex)	Returnerar ett värde som anger om den aktuella instansen och ett angivet komplext tal har samma värde.

Equals(Object)

Källa:: Complex.cs

Källa:: Complex.cs

Källa:: Complex.cs

Källa:: Complex.cs

Källa:: Complex.cs

Returnerar ett värde som anger om den aktuella instansen och ett angivet objekt har samma värde.

public:
 override bool Equals(System::Object ^ obj);

public override bool Equals(object obj);

public override bool Equals(object? obj);

override this.Equals : obj -> bool

Public Overrides Function Equals (obj As Object) As Boolean

Parametrar

obj: Object

Det objekt som ska jämföras.

Returer

Boolean

trueom parametern obj är ett Complex objekt eller en typ som kan implicit konvertera till ett Complex objekt och dess värde är lika med det aktuella Complex objektet, annars . false

Kommentarer

Två komplexa tal är lika om deras verkliga delar är lika och deras imaginära delar är lika. Metoden Equals(Object) motsvarar följande uttryck:

return this.Real.Equals(((Complex) value).Real) &&
       this.Imaginary.Equals(((Complex) value).Imaginary);

this.Real.Equals((value :?> Complex).Real)
&& this.Imaginary.Equals((value :?> Complex).Imaginary)

Return Me.Real.Equals(CType(value, Complex).Real) AndAlso 
       Me.Imaginary.Equals(CType(value, Complex).Imaginary)

Om parametern obj inte är ett Complex objekt, men det är en datatyp som en implicit konvertering definieras för, Equals(Object) konverterar obj metoden till ett Complex objekt vars verkliga del är lika med värdet obj för och vars imaginära del är lika med noll innan jämförelsen utförs. Följande exempel illustrerar detta genom att konstatera att ett komplext tal och ett flyttalsvärde med dubbel precision är lika med.

double n1 = 16.33;
System.Numerics.Complex c1 =
       new System.Numerics.Complex(16.33, 0);
Console.WriteLine(c1.Equals(n1));               // Returns true.

let n1 = 16.33;
let c1 = System.Numerics.Complex(16.33, 0)
printfn $"{c1.Equals n1}" // Returns true.

Dim n1 As Double = 16.33
Dim c1 As New System.Numerics.Complex(16.33, 0)
Console.WriteLine(c1.Equals(n1))                ' Returns True.

Anteckningar till anropare

Equals(Complex) Använd metoden med försiktighet, eftersom två värden som uppenbarligen är likvärdiga kan anses vara ojämlika på grund av den olika precisionen hos deras verkliga och imaginära komponenter. Problemet kan accentueras om obj det måste konverteras till en Double innan jämförelsen utförs. I följande exempel jämförs ett komplext tal vars verkliga komponent verkar vara lika med ett Single värde med det Single värdet. Som utdata visar returnerar Falsejämförelsen för likhet .

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      float n1 = 1.430718e-12f;
      Complex c1 = new Complex(1.430718e-12, 0);
      Console.WriteLine("{0} = {1}: {2}", c1, n1, c1.Equals(n1));
   }
}
// The example displays the following output:
//       (1.430718E-12, 0) = 1.430718E-12: False

open System.Numerics

let n1 = 1.430718e-12f
let c1 = Complex(1.430718e-12, 0);
printfn $"{c1} = {n1}: {c1.Equals n1}"
// The example displays the following output:
//       (1.430718E-12, 0) = 1.430718E-12: False

Imports System.Numerics

Module Example
   Public Sub Main()
      Dim n1 As Single = 1.430718e-12
      Dim c1 As New Complex(1.430718e-12, 0)
      Console.WriteLine("{0} = {1}: {2}", c1, n1, c1.Equals(n1))
   End Sub
End Module
' The example displays the following output:
'       (1.430718E-12, 0) = 1.430718E-12: False

En rekommenderad teknik är att definiera en acceptabel skillnadsmarginal mellan de två värdena (till exempel .01% av ett av värdenas verkliga och imaginära komponenter) i stället för att jämföra värdena för likhet. Om det absoluta värdet för skillnaden mellan de två värdena är mindre än eller lika med den marginalen beror skillnaden sannolikt på en skillnad i precision och därför är värdena sannolikt lika. I följande exempel används den här tekniken för att jämföra de två värden som det tidigare kodexemplet visade sig vara ojämlika. Nu finner den att de är lika.

using System.Numerics;

public class Example
{
   public static void Main()
   {
      float n1 = 1.430718e-12f;
      Complex c1 = new Complex(1.430718e-12, 0);
      double difference = .0001;

      // Compare the values
      bool result = (Math.Abs(c1.Real - n1) <= c1.Real * difference) &
                    c1.Imaginary == 0;
      Console.WriteLine("{0} = {1}: {2}", c1, n1, result);
   }
}
// The example displays the following output:
//       (1.430718E-12, 0) = 1.430718E-12: True

open System.Numerics

let n1 = 1.430718e-12f
let c1 = Complex(1.430718e-12, 0);
let difference = 0.0001f;

// Compare the values
let result = (abs (c1.Real - float n1) <= c1.Real * float difference) && c1.Imaginary = 0;
printfn $"{c1} = {n1}: {result}"
// The example displays the following output:
//       (1.430718E-12, 0) = 1.430718E-12: True

Imports System.Numerics

Module Example
   Public Sub Main()
      Dim n1 As Single = 1.430718e-12
      Dim c1 As New Complex(1.430718e-12, 0)
      Dim difference As Double = .0001
      
      ' Compare the values
      Dim result As Boolean = (Math.Abs(c1.Real - n1) <= c1.Real * difference) And
                              c1.Imaginary = 0
      Console.WriteLine("{0} = {1}: {2}", c1, n1, result)       
   End Sub
End Module
' The example displays the following output:
'       (1.430718E-12, 0) = 1.430718E-12: True

Gäller för

Equals(Complex)

Källa:: Complex.cs

Källa:: Complex.cs

Källa:: Complex.cs

Källa:: Complex.cs

Källa:: Complex.cs

Returnerar ett värde som anger om den aktuella instansen och ett angivet komplext tal har samma värde.

public:
 virtual bool Equals(System::Numerics::Complex value);

public bool Equals(System.Numerics.Complex value);

override this.Equals : System.Numerics.Complex -> bool

Public Function Equals (value As Complex) As Boolean

Parametrar

value: Complex

Det komplexa tal som ska jämföras.

Returer

Boolean

trueom det här komplexa talet och value har samma värde, annars . false

Implementeringar

Equals(T)

Kommentarer

Metoden Equals(Complex) tillhandahåller implementeringen IEquatable<T> för Complex strukturen. Den presterar något bättre än Equals(Object) metoden eftersom den inte behöver konvertera parametern till ett komplext tal.

Två komplexa tal är lika om deras verkliga delar är lika och deras imaginära delar är lika. Metoden Equals(Complex) motsvarar följande uttryck:

return this.Real.Equals(value) && this.Imaginary.Equals(value);

this.Real.Equals value && this.Imaginary.Equals value

Return Me.Real.Equals(value.Real) AndAlso Me.Imaginary.Equals(value.Imaginary)

Anteckningar till anropare

System.Numerics.Complex c1 = new System.Numerics.Complex(3.33333, .142857);
System.Numerics.Complex c2 = new System.Numerics.Complex(10/3.0, 1.0/7);
Console.WriteLine("{0} = {1}: {2}", c1, c2, c1.Equals(c2));
// The example displays the following output:
//    (3.33333, 0.142857) = (3.33333333333333, 0.142857142857143): False

    let c1 = System.Numerics.Complex(3.33333, 0.142857)
    let c2 = System.Numerics.Complex(10. / 3., 1. / 7.)
    printfn $"{c1} = {c2}: {c1.Equals c2}"
// The example displays the following output:
//    (3.33333, 0.142857) = (3.33333333333333, 0.142857142857143): False

Dim c1 As New System.Numerics.Complex(3.33333, .142857)
Dim c2 As New System.Numerics.Complex(10/3, 1/7)
Console.WriteLine("{0} = {1}: {2}", c1, c2, c1.Equals(c2))       
' The example displays the following output:
'    (3.33333, 0.142857) = (3.33333333333333, 0.142857142857143): False

En rekommenderad teknik är att definiera en acceptabel skillnadsmarginal mellan de två värdena (till exempel .01% av ett av värdenas verkliga och imaginära komponenter) i stället för att jämföra värdena för likhet. Om det absoluta värdet för skillnaden mellan de två värdena är mindre än eller lika med den marginalen beror skillnaden sannolikt på en skillnad i precision, och därför är värdena sannolikt lika. I följande exempel används den här tekniken för att jämföra de två komplexa värden som det tidigare kodexemplet visade sig vara ojämlika. Den finner att de två komplexa talen är lika med.

System.Numerics.Complex c1 = new System.Numerics.Complex(3.33333, .142857);
System.Numerics.Complex c2 = new System.Numerics.Complex(10/3.0, 1.0/7);
double difference = .0001;

// Compare the values
bool result = (Math.Abs(c1.Real - c2.Real) <= c1.Real * difference) &
              (Math.Abs(c1.Imaginary - c2.Imaginary) <= c1.Imaginary * difference);
Console.WriteLine("{0} = {1}: {2}", c1, c2, result);
// The example displays the following output:
//    (3.33333, 0.142857) = (3.33333333333333, 0.142857142857143): True

    let c1 = System.Numerics.Complex(3.33333, 0.142857)
    let c2 = System.Numerics.Complex(10. / 3., 1. / 7.)
    let difference = 0.0001

    // Compare the values
    let result =
        (Math.Abs(c1.Real - c2.Real) <= c1.Real * difference)
        && (Math.Abs(c1.Imaginary - c2.Imaginary) <= c1.Imaginary * difference)

    printfn $"{c1} = {c2}: {result}"
// The example displays the following output:
//    (3.33333, 0.142857) = (3.33333333333333, 0.142857142857143): True

Dim c1 As New System.Numerics.Complex(3.33333, .142857)
Dim c2 As New System.Numerics.Complex(10/3.0, 1.0/7)
Dim difference As Double = .0001

' Compare the values
Dim result As Boolean = (Math.Abs(c1.Real - c2.Real) <= c1.Real * difference) And
                        (Math.Abs(c1.Imaginary - c2.Imaginary) <= c1.Imaginary * difference)
Console.WriteLine("{0} = {1}: {2}", c1, c2, result)       
' The example displays the following output:
'    (3.33333, 0.142857) = (3.33333333333333, 0.142857142857143): True

Se även

Double

Gäller för

Feedback

Var den här sidan till hjälp?