Complex.Equals Metodo

Origine:

Complex.cs

Origine:

Complex.cs

Origine:

Complex.cs

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

Parametri

Restituisce

true se il parametro obj è un oggetto Complex o un tipo in grado di eseguire la conversione implicita in un oggetto Complex e il relativo valore è uguale all'oggetto Complex corrente. In caso contrario, false.

Commenti

Due numeri complessi sono uguali se le loro parti reali sono uguali e le loro parti immaginarie sono uguali. Il Equals(Object) metodo equivale all'espressione seguente:

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)

Se il obj parametro non è un Complex oggetto , ma è un tipo di dati per il quale viene definita una conversione implicita, il Equals(Object) metodo converte obj in un Complex oggetto la cui parte reale è uguale al valore di obj e la cui parte immaginaria è uguale a zero prima di eseguire il confronto. L'esempio seguente illustra questo aspetto individuando che un numero complesso e un valore a virgola mobile a precisione doppia sono uguali.

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.

Note per i chiamanti

Usare il Equals(Complex) metodo con cautela, perché due valori apparentemente equivalenti possono essere considerati diversi a causa della precisione diversa dei relativi componenti reali e immaginari. Il problema può essere accentuato se obj deve essere convertito in un Double oggetto prima di eseguire il confronto. Nell'esempio seguente viene confrontato un numero complesso il cui componente reale sembra essere uguale a un Single valore con tale Single valore. Come illustrato nell'output, il confronto per l'uguaglianza restituisce 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

Una tecnica consigliata consiste nel definire un margine di differenza accettabile tra i due valori (ad esempio ,01% di uno dei componenti reali e immaginari dei valori) anziché confrontare i valori per l'uguaglianza. Se il valore assoluto della differenza tra i due valori è minore o uguale a tale margine, è probabile che la differenza sia dovuta a una differenza di precisione e, pertanto, è probabile che i valori siano uguali. Nell'esempio seguente viene usata questa tecnica per confrontare i due valori rilevati dall'esempio di codice precedente. Ora li trova per essere uguali.

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

Origine:

Complex.cs

Origine:

Complex.cs

Origine:

Complex.cs

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

Parametri

Restituisce

true se questo numero complesso e value presentano lo stesso valore. In caso contrario, false.

Implementazioni

Commenti

Il Equals(Complex) metodo fornisce l'implementazione IEquatable<T> per la Complex struttura. Offre prestazioni leggermente migliori rispetto Equals(Object) al metodo perché non è necessario convertirne il parametro in un numero complesso.

Due numeri complessi sono uguali se le loro parti reali sono uguali e le loro parti immaginarie sono uguali. Il Equals(Complex) metodo equivale all'espressione seguente:

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)

Note per i chiamanti

Usare il Equals(Complex) metodo con cautela, perché due valori apparentemente equivalenti possono essere considerati diversi a causa della precisione diversa dei relativi componenti reali e immaginari. Nell'esempio seguente viene segnalato che (3.33333, 0.142857) e (10/3, 1/7) non sono uguali.

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

Una tecnica consigliata consiste nel definire un margine di differenza accettabile tra i due valori (ad esempio ,01% di uno dei componenti reali e immaginari dei valori) anziché confrontare i valori per l'uguaglianza. Se il valore assoluto della differenza tra i due valori è minore o uguale a tale margine, è probabile che la differenza sia dovuta a una differenza di precisione e, pertanto, è probabile che i valori siano uguali. Nell'esempio seguente viene usata questa tecnica per confrontare i due valori complessi rilevati dall'esempio di codice precedente diversi. Trova i due numeri complessi in modo che siano uguali.

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

Vedi anche

• Double