Complex.Equals Methode

Definitie

Naamruimte:: System.Numerics

Assembly's:: System.Numerics.dll, System.Runtime.Numerics.dll

Assembly's:: netstandard.dll, System.Runtime.Numerics.dll

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Retourneert een waarde die aangeeft of twee complexe getallen gelijk zijn.

Overloads

Name	Description
Equals(Object)	Retourneert een waarde die aangeeft of het huidige exemplaar en een opgegeven object dezelfde waarde hebben.
Equals(Complex)	Retourneert een waarde die aangeeft of het huidige exemplaar en een opgegeven complex getal dezelfde waarde hebben.

Equals(Object)

Bron:: Complex.cs

Bron:: Complex.cs

Bron:: Complex.cs

Bron:: Complex.cs

Bron:: Complex.cs

Retourneert een waarde die aangeeft of het huidige exemplaar en een opgegeven object dezelfde waarde hebben.

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

Parameters

obj: Object

Het object dat moet worden vergeleken.

Retouren

Boolean

trueals de obj parameter een Complex object of een type is dat in staat is impliciete conversie naar een Complex object en de waarde ervan gelijk is aan het huidige Complex object; anders. false

Opmerkingen

Twee complexe getallen zijn gelijk als hun werkelijke delen gelijk zijn en hun imaginaire delen gelijk zijn. De Equals(Object) methode is gelijk aan de volgende expressie:

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)

Als de obj parameter geen Complex object is, maar het een gegevenstype is waarvoor een impliciete conversie is gedefinieerd, wordt de Equals(Object) methode geconverteerd obj naar een Complex object waarvan het werkelijke deel gelijk is aan de waarde en obj waarvan het imaginaire deel gelijk is aan nul voordat de vergelijking wordt uitgevoerd. In het volgende voorbeeld ziet u dit door te bepalen dat een complex getal en een drijvendekommawaarde met dubbele precisie gelijk zijn.

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.

Notities voor bellers

Gebruik de Equals(Complex) methode met voorzichtigheid, omdat twee waarden die schijnbaar gelijkwaardig zijn, als ongelijk kunnen worden beschouwd vanwege de verschillende precisie van hun werkelijke en imaginaire componenten. Het probleem kan worden benadrukt als obj het moet worden geconverteerd naar een Double voordat de vergelijking wordt uitgevoerd. In het volgende voorbeeld wordt een complex getal vergeleken waarvan het reële onderdeel gelijk lijkt te zijn aan een Single waarde met die Single waarde. Zoals in de uitvoer wordt weergegeven, wordt de vergelijking voor gelijkheid geretourneerd 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

Een aanbevolen techniek is het definiëren van een acceptabele marge van verschil tussen de twee waarden (zoals .01% van een van de werkelijke en imaginaire componenten van de waarden) in plaats van de waarden voor gelijkheid te vergelijken. Als de absolute waarde van het verschil tussen de twee waarden kleiner is dan of gelijk is aan die marge, is het verschil waarschijnlijk te wijten aan een verschil in precisie en zijn de waarden waarschijnlijk gelijk. In het volgende voorbeeld wordt deze techniek gebruikt om de twee waarden te vergelijken die in het vorige codevoorbeeld ongelijk zijn bevonden. Het vindt nu dat ze gelijk zijn.

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

Van toepassing op

Equals(Complex)

Bron:: Complex.cs

Bron:: Complex.cs

Bron:: Complex.cs

Bron:: Complex.cs

Bron:: Complex.cs

Retourneert een waarde die aangeeft of het huidige exemplaar en een opgegeven complex getal dezelfde waarde hebben.

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

Parameters

value: Complex

Het complexe getal dat moet worden vergeleken.

Retouren

Boolean

trueals dit complexe getal en value dezelfde waarde hebben; anders. false

Implementeringen

Equals(T)

Opmerkingen

De Equals(Complex) methode biedt de IEquatable<T> implementatie voor de Complex structuur. Het presteert iets beter dan Equals(Object) de methode omdat deze de parameter niet hoeft te converteren naar een complex getal.

Twee complexe getallen zijn gelijk als hun werkelijke delen gelijk zijn en hun imaginaire delen gelijk zijn. De Equals(Complex) methode is gelijk aan de volgende expressie:

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)

Notities voor bellers

Gebruik de Equals(Complex) methode met voorzichtigheid, omdat twee waarden die schijnbaar gelijkwaardig zijn, als ongelijk kunnen worden beschouwd vanwege de verschillende precisie van hun werkelijke en imaginaire componenten. In het volgende voorbeeld wordt aangegeven dat (3.33333, 0.142857) en (10/3, 1/7) niet gelijk zijn.

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

Een aanbevolen techniek is het definiëren van een acceptabele marge van verschil tussen de twee waarden (zoals .01% van een van de werkelijke en imaginaire componenten van de waarden) in plaats van de waarden voor gelijkheid te vergelijken. Als de absolute waarde van het verschil tussen de twee waarden kleiner is dan of gelijk is aan die marge, is het verschil waarschijnlijk te wijten aan een verschil in precisie en zijn de waarden waarschijnlijk gelijk. In het volgende voorbeeld wordt deze techniek gebruikt om de twee complexe waarden te vergelijken die in het vorige codevoorbeeld ongelijk zijn bevonden. Hiermee worden de twee complexe getallen gevonden die gelijk moeten zijn.

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

Zie ook

Double

Van toepassing op

Feedback

Is deze pagina nuttig?