Complex.Equals Metoda

Definice

Obor názvů:

System.Numerics

Sestavení:

System.Runtime.Numerics.dll

Vrátí hodnotu, která označuje, zda jsou dvě komplexní čísla rovna.

Přetížení

Equals(Object)	Vrátí hodnotu, která označuje, zda aktuální instance a zadaný objekt mají stejnou hodnotu.
Equals(Complex)	Vrátí hodnotu, která označuje, zda aktuální instance a zadané komplexní číslo mají stejnou hodnotu.

Equals(Object)

Zdroj:

Complex.cs

Vrátí hodnotu, která označuje, zda aktuální instance a zadaný objekt mají stejnou hodnotu.

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

public override bool Equals (object? obj);

override this.Equals : obj -> bool

Public Overrides Function Equals (obj As Object) As Boolean

Parametry

obj

Object

Objekt k porovnání

Návraty

Boolean

trueobj pokud je Complex parametr objektem nebo typem schopným implicitního převodu Complex na objekt a jeho hodnota se rovná aktuálnímu Complex objektu, v opačném případě false.

Poznámky

Dvě komplexní čísla jsou rovna, pokud jsou jejich skutečné části stejné a jejich imaginární části jsou rovny. Metoda Equals(Object) odpovídá následujícímu výrazu:

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

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

obj Pokud parametr není Complex objekt, ale jedná se o datový typ, pro který je definován implicitní převod, převede obj metoda na Complex objekt, Equals(Object) jehož skutečná část je rovna obj hodnotě a jehož imaginární část je rovna nule před provedením porovnání. Následující příklad to ilustruje zjištěním, že komplexní číslo a hodnota s plovoucí desetinou čárkou s dvojitou přesností jsou stejné.

double n1 = 16.33;
System.Numerics.Complex c1 =
       new System.Numerics.Complex(16.33, 0);
Console.WriteLine(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.

Poznámky pro volající

Metodu Equals(Complex) používejte opatrně, protože dvě hodnoty, které jsou zdánlivě ekvivalentní, mohou být považovány za nerovné kvůli odlišné přesnosti jejich skutečných a imaginárních komponent. Problém může být zvýrazněn, pokud obj je nutné před provedením Double porovnání převést na hodnotu. Následující příklad porovnává komplexní číslo, jehož reálná komponenta se zdá být rovna hodnotě s danou SingleSingle hodnotou. Jak ukazuje výstup, porovnání rovnosti vrátí Falsehodnotu .

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

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

Jednou z doporučených technik je definovat přijatelnou mez rozdílu mezi dvěma hodnotami (například 0,01 % jedné z reálných a imaginárních složek hodnot) místo porovnání hodnot rovnosti. Pokud je absolutní hodnota rozdílu mezi těmito dvěma hodnotami menší nebo rovna okraji, je pravděpodobné, že rozdíl bude způsobený rozdílem v přesnosti, a proto jsou hodnoty pravděpodobně stejné. Následující příklad používá tuto techniku k porovnání dvou hodnot, které předchozí příklad kódu zjistil, že jsou nerovné. Teď zjistí, že jsou si rovny.

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

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

Equals(Complex)

Zdroj:

Complex.cs

Vrátí hodnotu, která označuje, zda aktuální instance a zadané komplexní číslo mají stejnou hodnotu.

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

Parametry

value

Complex

Komplexní číslo, které se má porovnat.

Návraty

Boolean

truepokud toto komplexní číslo a value má stejnou hodnotu, v opačném případě . false

Implementuje

Equals(T)

Poznámky

Metoda Equals(Complex) poskytuje implementaci IEquatable<T>Complex pro strukturu. Funguje o něco lépe než Equals(Object) metoda, protože nemusí převést parametr na komplexní číslo.

Dvě komplexní čísla jsou rovna, pokud jsou jejich skutečné části stejné a jejich imaginární části jsou rovny. Metoda Equals(Complex) odpovídá následujícímu výrazu:

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

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

Poznámky pro volající

Metodu Equals(Complex) používejte opatrně, protože dvě hodnoty, které jsou zdánlivě ekvivalentní, mohou být považovány za nerovné kvůli odlišné přesnosti jejich skutečných a imaginárních komponent. Následující příklad hlásí, že (3.33333, 0.142857) a (10/3, 1/7) nejsou si rovny.

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

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

Jednou z doporučených technik je definovat přijatelnou mez rozdílu mezi dvěma hodnotami (například 0,01 % jedné z reálných a imaginárních složek hodnot) místo porovnání hodnot rovnosti. Pokud je absolutní hodnota rozdílu mezi těmito dvěma hodnotami menší nebo rovna okraji, je pravděpodobné, že rozdíl bude způsobený rozdílem v přesnosti, a proto jsou hodnoty pravděpodobně rovny. Následující příklad používá tuto techniku k porovnání dvou komplexních hodnot, které předchozí příklad kódu zjistil, že jsou nerovné. Zjistí, že jsou dvě komplexní čísla rovna.

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

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

Viz také

• Double