Complex.Equals Methode

Definition

Namespace:: System.Numerics

Assemblys:: System.Numerics.dll, System.Runtime.Numerics.dll

Assemblys:: netstandard.dll, System.Runtime.Numerics.dll

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Gibt einen Wert zurück, der angibt, ob zwei komplexe Zahlen gleich sind.

Überlädt

Name	Beschreibung
Equals(Object)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes Objekt denselben Wert aufweisen.
Equals(Complex)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine angegebene komplexe Zahl denselben Wert aufweisen.

Equals(Object)

Quelle:: Complex.cs

Quelle:: Complex.cs

Quelle:: Complex.cs

Quelle:: Complex.cs

Quelle:: Complex.cs

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes Objekt denselben Wert aufweisen.

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

Parameter

obj: Object

Das zu vergleichende Objekt.

Gibt zurück

Boolean

true wenn es sich bei dem obj Parameter um ein Complex Objekt oder einen Typ handelt, der implizit in ein Complex Objekt konvertiert werden kann und sein Wert dem aktuellen Complex Objekt entspricht; andernfalls false.

Hinweise

Zwei komplexe Zahlen sind gleich, wenn ihre realen Teile gleich sind und ihre imaginären Teile gleich sind. Die Equals(Object) Methode entspricht dem folgenden Ausdruck:

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)

Wenn der obj Parameter kein Complex Objekt ist, sondern ein Datentyp ist, für den eine implizite Konvertierung definiert ist, wird die Equals(Object) Methode in ein obj Objekt konvertiertComplex, dessen realer Teil dem Wert obj entspricht und dessen imaginärer Teil gleich Null ist, bevor der Vergleich ausgeführt wird. Im folgenden Beispiel wird dies veranschaulicht, indem festgestellt wird, dass eine komplexe Zahl und ein Gleitkommawert mit doppelter Genauigkeit gleich sind.

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.

Hinweise für Aufrufer

Verwenden Sie die Equals(Complex) Methode mit Vorsicht, da zwei Scheinbar gleichwertige Werte aufgrund der unterschiedlichen Genauigkeit ihrer realen und imaginären Komponenten ungleich betrachtet werden können. Das Problem kann akzentuiert werden, wenn obj vor dem Durchführen des Vergleichs in einen Double konvertiert werden muss. Im folgenden Beispiel wird eine komplexe Zahl verglichen, deren reale Komponente einem Wert mit diesem Single Wert entsprichtSingle. Wie die Ausgabe zeigt, wird der Vergleich für Gleichheit zurückgegeben 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

Eine empfohlene Methode besteht darin, einen akzeptablen Differenzrand zwischen den beiden Werten (z. B. 01% einer der realen und imaginären Komponenten) zu definieren, anstatt die Werte für die Gleichheit zu vergleichen. Wenn der absolute Wert der Differenz zwischen den beiden Werten kleiner oder gleich diesem Rand ist, ist die Differenz wahrscheinlich auf einen Unterschied in der Genauigkeit zurückzuführen und daher sind die Werte wahrscheinlich gleich. Im folgenden Beispiel wird diese Technik verwendet, um die beiden Werte zu vergleichen, die im vorherigen Codebeispiel ungleich dargestellt wurden. Es findet jetzt, dass sie gleich sind.

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

Gilt für:

Equals(Complex)

Quelle:: Complex.cs

Quelle:: Complex.cs

Quelle:: Complex.cs

Quelle:: Complex.cs

Quelle:: Complex.cs

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine angegebene komplexe Zahl denselben Wert aufweisen.

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

Parameter

value: Complex

Die komplexe Zahl, die verglichen werden soll.

Gibt zurück

Boolean

truewenn diese komplexe Zahl und value denselben Wert aufweisen; andernfalls . false

Implementiert

Equals(T)

Hinweise

Die Equals(Complex) Methode stellt die IEquatable<T> Implementierung für die Complex Struktur bereit. Sie führt etwas besser aus als Equals(Object) die Methode, da der Parameter nicht in eine komplexe Zahl konvertiert werden muss.

Zwei komplexe Zahlen sind gleich, wenn ihre realen Teile gleich sind und ihre imaginären Teile gleich sind. Die Equals(Complex) Methode entspricht dem folgenden Ausdruck:

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)

Hinweise für Aufrufer

Verwenden Sie die Equals(Complex) Methode mit Vorsicht, da zwei Scheinbar gleichwertige Werte aufgrund der unterschiedlichen Genauigkeit ihrer realen und imaginären Komponenten ungleich betrachtet werden können. Im folgenden Beispiel wird berichtet, dass (3.33333, 0.142857) und (10/3, 1/7) nicht gleich sind.

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

Eine empfohlene Methode besteht darin, einen akzeptablen Differenzrand zwischen den beiden Werten (z. B. 01% einer der realen und imaginären Komponenten) zu definieren, anstatt die Werte für die Gleichheit zu vergleichen. Wenn der absolute Wert der Differenz zwischen den beiden Werten kleiner oder gleich diesem Rand ist, ist die Differenz wahrscheinlich auf einen Unterschied in der Genauigkeit zurückzuführen, und daher sind die Werte wahrscheinlich gleich. Im folgenden Beispiel wird diese Technik verwendet, um die beiden komplexen Werte zu vergleichen, die im vorherigen Codebeispiel ungleich sind. Sie findet die beiden komplexen Zahlen, die gleich sein sollen.

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

Weitere Informationen

Double

Gilt für:

Feedback

War diese Seite hilfreich?