Complex.Equals Metódus

Definíció

Névtér:

System.Numerics

Szerelvények:

netstandard.dll, System.Runtime.Numerics.dll

Olyan értéket ad vissza, amely jelzi, hogy két komplex szám egyenlő-e.

Túlterhelések

Name	Description
Equals(Object)	Olyan értéket ad vissza, amely jelzi, hogy az aktuális példány és egy adott objektum azonos értékkel rendelkezik-e.
Equals(Complex)	Olyan értéket ad vissza, amely jelzi, hogy az aktuális példány és egy megadott összetett szám azonos értékkel rendelkezik-e.

Equals(Object)

Forrás:

Complex.cs

Olyan értéket ad vissza, amely jelzi, hogy az aktuális példány és egy adott objektum azonos értékkel rendelkezik-e.

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

Paraméterek

obj

Object

Az összehasonlítandó objektum.

Válaszok

Boolean

true ha a obj paraméter objektum Complex vagy objektum implicit Complex átalakítására alkalmas típus, és értéke megegyezik az aktuális Complex objektummal, falseellenkező esetben.

Megjegyzések

Két összetett szám egyenlő, ha a valós részük egyenlő, a képzeletbeli részük pedig egyenlő. A Equals(Object) metódus egyenértékű a következő kifejezéssel:

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)

Ha a obj paraméter nem Complex objektum, de olyan adattípus, amelyhez implicit átalakítás van definiálva, akkor a Equals(Object) metódus olyan obj objektummá alakul átComplex, amelynek valós része egyenlő az értékévelobj, és amelynek képzeletbeli része nullával egyenlő, mielőtt végrehajtja az összehasonlítást. Az alábbi példa ezt azzal szemlélteti, hogy egy összetett szám és egy dupla pontosságú lebegőpontos érték egyenlő.

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.

Megjegyzések a hívókhoz

Óvatosan használja a Equals(Complex) módszert, mert két látszólag egyenértékű érték egyenlőtlennek tekinthető a valós és a képzeletbeli összetevők eltérő pontossága miatt. A probléma kiemelhető, ha obj az összehasonlítás végrehajtása előtt át kell alakítani egy Double problémára. Az alábbi példa egy olyan összetett számot hasonlít össze, amelynek valós összetevője úgy tűnik, hogy Single egy értékkel Single egyenlő. Ahogy a kimenet is mutatja, az egyenlőség összehasonlítása ad vissza False.

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

Az egyik ajánlott módszer a két érték (például az értékek egyikének valós és képzeletbeli összetevőinek .01%) közötti elfogadható különbséghatár meghatározása az egyenlőség értékeinek összehasonlítása helyett. Ha a két érték közötti különbség abszolút értéke kisebb vagy egyenlő az adott margónál, a különbség valószínűleg a pontossági különbségnek köszönhető, ezért az értékek valószínűleg egyenlőek lesznek. Az alábbi példa ezzel a technikával hasonlítja össze az előző példakód két, egyenlőtlennek talált értékét. Most már egyenlőnek találja őket.

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

Equals(Complex)

Forrás:

Complex.cs

Olyan értéket ad vissza, amely jelzi, hogy az aktuális példány és egy megadott összetett szám azonos értékkel rendelkezik-e.

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

Paraméterek

value

Complex

Az összehasonlítandó összetett szám.

Válaszok

Boolean

trueha ez az összetett szám ugyanazzal value az értékkel rendelkezik; ellenkező esetben. false

Megvalósítás

Equals(T)

Megjegyzések

A Equals(Complex) módszer biztosítja a IEquatable<T> struktúra implementálását Complex . Valamivel jobban teljesít, mint Equals(Object) a metódus, mert nem kell a paraméterét összetett számmá alakítania.

Két összetett szám egyenlő, ha a valós részük egyenlő, a képzeletbeli részük pedig egyenlő. A Equals(Complex) metódus egyenértékű a következő kifejezéssel:

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)

Megjegyzések a hívókhoz

Óvatosan használja a Equals(Complex) módszert, mert két látszólag egyenértékű érték egyenlőtlennek tekinthető a valós és a képzeletbeli összetevők eltérő pontossága miatt. Az alábbi példa azt jelenti, hogy a jelentés nem (3.33333, 0.142857) egyenlő, és (10/3, 1/7) nem egyenlő.

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

Az egyik ajánlott módszer a két érték (például az értékek egyikének valós és képzeletbeli összetevőinek .01%) közötti elfogadható különbséghatár meghatározása az egyenlőség értékeinek összehasonlítása helyett. Ha a két érték közötti különbség abszolút értéke kisebb vagy egyenlő az adott margónál, a különbség valószínűleg a pontossági különbségnek köszönhető, ezért az értékek valószínűleg egyenlőek lesznek. Az alábbi példa ezzel a technikával hasonlítja össze az előző példakód két összetett értékét, amelyek egyenlőtlennek bizonyultak. Úgy találja, hogy a két összetett szám egyenlő.

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

Lásd még

• Double