Complex.Equals Méthode

Référence

Définition

Espace de noms:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Retourne une valeur qui indique si deux nombres complexes sont égaux.

Surcharges

Equals(Object)	Retourne une valeur qui indique si l'instance actuelle et un objet spécifié ont la même valeur.
Equals(Complex)	Retourne une valeur qui indique si l'instance actuelle et un nombre complexe spécifié ont la même valeur.

Equals(Object)

Source:: Complex.cs

Source:: Complex.cs

Source:: Complex.cs

Retourne une valeur qui indique si l'instance actuelle et un objet spécifié ont la même valeur.

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

Paramètres

obj: Object

Objet à comparer.

Retours

Boolean

true si le paramètre obj est un objet Complex ou un type capable d'effectuer une conversion implicite en objet Complex et que sa valeur est égale à l'objet Complex actuel ; sinon, false.

Remarques

Deux nombres complexes sont égaux si leurs parties réelles sont égales et si leurs parties imaginaires sont égales. La Equals(Object) méthode est équivalente à l’expression suivante :

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)

Si le obj paramètre n’est pas un Complex objet, mais qu’il s’agit d’un type de données pour lequel une conversion implicite est définie, la méthode convertit obj en un Complex objet dont la Equals(Object) partie réelle est égale à la valeur de obj et dont la partie imaginaire est égale à zéro avant d’effectuer la comparaison. L’exemple suivant illustre cela en constatant qu’un nombre complexe et une valeur à virgule flottante double précision sont égaux.

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.

Notes pour les appelants

Utilisez la Equals(Complex) méthode avec précaution, car deux valeurs apparemment équivalentes peuvent être considérées comme inégales en raison de la précision différente de leurs composants réels et imaginaires. Le problème peut être accentué si obj doit être converti en un Double avant d’effectuer la comparaison. L’exemple suivant compare un nombre complexe dont le composant réel semble être égal à une Single valeur avec cette Single valeur. Comme le montre la sortie, la comparaison d’égalité retourne 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

Une technique recommandée consiste à définir une marge de différence acceptable entre les deux valeurs (par exemple, 0,01 % de l’une des composantes réelles et imaginaires de l’une des valeurs) au lieu de comparer les valeurs pour l’égalité. Si la valeur absolue de la différence entre les deux valeurs est inférieure ou égale à cette marge, la différence est probablement due à une différence de précision et, par conséquent, les valeurs sont susceptibles d’être égales. L’exemple suivant utilise cette technique pour comparer les deux valeurs que l’exemple de code précédent a jugées inégales. Il trouve maintenant qu’ils sont égaux.

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

S’applique à

Equals(Complex)

Source:: Complex.cs

Source:: Complex.cs

Source:: Complex.cs

Retourne une valeur qui indique si l'instance actuelle et un nombre complexe spécifié ont la même valeur.

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ètres

value: Complex

Nombre complexe à comparer.

Retours

Boolean

true si ce nombre complexe et value ont la même valeur ; sinon, false.

Implémente

Equals(T)

Remarques

La Equals(Complex) méthode fournit l’implémentation IEquatable<T> de la Complex structure. Il fonctionne légèrement mieux que Equals(Object) la méthode, car il n’a pas besoin de convertir son paramètre en nombre complexe.

Deux nombres complexes sont égaux si leurs parties réelles sont égales et si leurs parties imaginaires sont égales. La Equals(Complex) méthode est équivalente à l’expression suivante :

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)

Notes pour les appelants

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

Une technique recommandée consiste à définir une marge de différence acceptable entre les deux valeurs (par exemple, 0,01 % de l’une des composantes réelles et imaginaires de l’une des valeurs) au lieu de comparer les valeurs pour l’égalité. Si la valeur absolue de la différence entre les deux valeurs est inférieure ou égale à cette marge, la différence est probablement due à une différence de précision et, par conséquent, les valeurs sont susceptibles d’être égales. L’exemple suivant utilise cette technique pour comparer les deux valeurs complexes que l’exemple de code précédent a jugées inégales. Il trouve que les deux nombres complexes sont égaux.

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

Voir aussi

Double

S’applique à

Partager via

Complex.Equals Méthode

Définition

Surcharges

Equals(Object)

Paramètres

Retours

Remarques

Notes pour les appelants

S’applique à

Equals(Complex)

Paramètres

Retours

Implémente

Remarques

Notes pour les appelants

Voir aussi

S’applique à

Ressources supplémentaires