Complex Struktur

Definition

Stellt eine komplexe Zahl dar.

public value class Complex : IEquatable<System::Numerics::Complex>, IFormattable
public value class Complex : IEquatable<System::Numerics::Complex>, IParsable<System::Numerics::Complex>, ISpanParsable<System::Numerics::Complex>, System::Numerics::IAdditionOperators<System::Numerics::Complex, System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IAdditiveIdentity<System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IDecrementOperators<System::Numerics::Complex>, System::Numerics::IDivisionOperators<System::Numerics::Complex, System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IEqualityOperators<System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IIncrementOperators<System::Numerics::Complex>, System::Numerics::IMultiplicativeIdentity<System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IMultiplyOperators<System::Numerics::Complex, System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::INumberBase<System::Numerics::Complex>, System::Numerics::ISignedNumber<System::Numerics::Complex>, System::Numerics::ISubtractionOperators<System::Numerics::Complex, System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IUnaryNegationOperators<System::Numerics::Complex, System::Numerics::Complex>, System::Numerics::IUnaryPlusOperators<System::Numerics::Complex, System::Numerics::Complex>
public struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
public readonly struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
public readonly struct Complex : IEquatable<System.Numerics.Complex>, IParsable<System.Numerics.Complex>, ISpanParsable<System.Numerics.Complex>, System.Numerics.IAdditionOperators<System.Numerics.Complex,System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IAdditiveIdentity<System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IDecrementOperators<System.Numerics.Complex>, System.Numerics.IDivisionOperators<System.Numerics.Complex,System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IEqualityOperators<System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IIncrementOperators<System.Numerics.Complex>, System.Numerics.IMultiplicativeIdentity<System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IMultiplyOperators<System.Numerics.Complex,System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.INumberBase<System.Numerics.Complex>, System.Numerics.ISignedNumber<System.Numerics.Complex>, System.Numerics.ISubtractionOperators<System.Numerics.Complex,System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IUnaryNegationOperators<System.Numerics.Complex,System.Numerics.Complex>, System.Numerics.IUnaryPlusOperators<System.Numerics.Complex,System.Numerics.Complex>
[System.Serializable]
public struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
type Complex = struct
    interface IFormattable
type Complex = struct
    interface IFormattable
    interface IParsable<Complex>
    interface ISpanFormattable
    interface ISpanParsable<Complex>
    interface IAdditionOperators<Complex, Complex, Complex>
    interface IAdditiveIdentity<Complex, Complex>
    interface IDecrementOperators<Complex>
    interface IDivisionOperators<Complex, Complex, Complex>
    interface IEqualityOperators<Complex, Complex>
    interface IIncrementOperators<Complex>
    interface IMultiplicativeIdentity<Complex, Complex>
    interface IMultiplyOperators<Complex, Complex, Complex>
    interface INumberBase<Complex>
    interface ISubtractionOperators<Complex, Complex, Complex>
    interface IUnaryNegationOperators<Complex, Complex>
    interface IUnaryPlusOperators<Complex, Complex>
    interface ISignedNumber<Complex>
[<System.Serializable>]
type Complex = struct
    interface IFormattable
Public Structure Complex
Implements IEquatable(Of Complex), IFormattable
Public Structure Complex
Implements IAdditionOperators(Of Complex, Complex, Complex), IAdditiveIdentity(Of Complex, Complex), IDecrementOperators(Of Complex), IDivisionOperators(Of Complex, Complex, Complex), IEqualityOperators(Of Complex, Complex), IEquatable(Of Complex), IIncrementOperators(Of Complex), IMultiplicativeIdentity(Of Complex, Complex), IMultiplyOperators(Of Complex, Complex, Complex), INumberBase(Of Complex), IParsable(Of Complex), ISignedNumber(Of Complex), ISpanParsable(Of Complex), ISubtractionOperators(Of Complex, Complex, Complex), IUnaryNegationOperators(Of Complex, Complex), IUnaryPlusOperators(Of Complex, Complex)
Vererbung
Complex
Attribute
Implementiert

Hinweise

Eine komplexe Zahl ist eine Zahl, die einen realen Zahlenteil und einen imaginären Zahlenteil umfasst. Eine komplexe Zahl z wird in der Regel in form z = x + yi geschrieben, wobei x und y reale Zahlen sind, und i ist die imaginäre Einheit, die die Eigenschaft i2 = -1 aufweist. Der reale Teil der komplexen Zahl wird durch x dargestellt, und der imaginäre Teil der komplexen Zahl wird durch y dargestellt.

Der Complex Typ verwendet das Kartesische Koordinatensystem (real, imaginär), wenn komplexe Zahlen instanziiert und manipuliert werden. Eine komplexe Zahl kann als Punkt in einem zweidimensionalen Koordinatensystem dargestellt werden, das als komplexe Ebene bezeichnet wird. Der reale Teil der komplexen Zahl wird auf der x-Achse (der horizontalen Achse) positioniert, und der imaginäre Teil wird auf der y-Achse (der vertikalen Achse) positioniert.

Jeder Punkt in der komplexen Ebene kann auch anhand seines absoluten Werts ausgedrückt werden, indem das Polarkoordinatensystem verwendet wird. In polaren Koordinaten zeichnet sich ein Punkt durch zwei Zahlen aus:

  • Seine Größe, die der Abstand des Punkts vom Ursprung ist (d. h. 0,0 oder der Punkt, an dem sich die x-Achse und die Y-Achse überschneiden).

  • Seine Phase, die der Winkel zwischen der realen Achse und der Linie ist, die vom Ursprung bis zum Punkt gezeichnet wird.

Instanziieren einer komplexen Zahl

Sie können einer komplexen Zahl auf eine der folgenden Arten einen Wert zuweisen:

  • Indem Sie zwei Double Werte an den Konstruktor übergeben. Der erste Wert stellt den realen Teil der komplexen Zahl dar, und der zweite Wert stellt seinen imaginären Teil dar. Diese Werte stellen die Position der komplexen Zahl im zweidimensionalen Kartesischen Koordinatensystem dar.

  • Indem Sie die statische (Shared in Visual Basic) Complex.FromPolarCoordinates -Methode aufrufen, um eine komplexe Zahl aus ihren Polarkoordinaten zu erstellen.

  • Durch Zuweisen eines Byte, SByte, UInt32Int32UInt16Int16UInt64SingleInt64oder Double Werts zu einem Complex Objekt. Der Wert wird zum realen Teil der komplexen Zahl, und sein imaginärer Teil entspricht 0.

  • Durch Umwandlung (in C#) oder Konvertieren (in Visual Basic) wird ein oder BigInteger ein Decimal Wert in ein Complex Objekt konvertiert. Der Wert wird zum realen Teil der komplexen Zahl, und sein imaginärer Teil entspricht 0.

  • Durch Zuweisen der komplexen Zahl, die von einer Methode oder einem Operator zurückgegeben wird, einem Complex Objekt. Ist beispielsweise Complex.Add eine statische Methode, die eine komplexe Zahl zurückgibt, die die Summe von zwei komplexen Zahlen ist, und der Complex.Addition Operator fügt zwei komplexe Zahlen hinzu und gibt das Ergebnis zurück.

Das folgende Beispiel veranschaulicht jede dieser fünf Methoden zum Zuweisen eines Werts zu einer komplexen Zahl.

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      // Create a complex number by calling its class constructor.
      Complex c1 = new Complex(12, 6);
      Console.WriteLine(c1);

      // Assign a Double to a complex number.
      Complex c2 = 3.14;
      Console.WriteLine(c2);

      // Cast a Decimal to a complex number.
      Complex c3 = (Complex) 12.3m;
      Console.WriteLine(c3);

      // Assign the return value of a method to a Complex variable.
      Complex c4 = Complex.Pow(Complex.One, -1);
      Console.WriteLine(c4);

      // Assign the value returned by an operator to a Complex variable.
      Complex c5 = Complex.One + Complex.One;
      Console.WriteLine(c5);

      // Instantiate a complex number from its polar coordinates.
      Complex c6 = Complex.FromPolarCoordinates(10, .524);
      Console.WriteLine(c6);
   }
}
// The example displays the following output:
//       (12, 6)
//       (3.14, 0)
//       (12.3, 0)
//       (1, 0)
//       (2, 0)
//       (8.65824721882145, 5.00347430269914)
Imports System.Numerics

Module Example
   Public Sub Main()
      ' Create a complex number by calling its class constructor.
      Dim c1 As New Complex(12, 6)
      Console.WriteLine(c1)
      
      ' Assign a Double to a complex number.
      Dim c2 As Complex = 3.14
      Console.WriteLine(c2)
      
      ' Cast a Decimal to a complex number.
      Dim c3 As Complex = CType(12.3d, Complex)
      Console.WriteLine(c3)
      
      ' Assign the return value of a method to a Complex variable.
      Dim c4 As Complex = Complex.Pow(Complex.One, -1)
      Console.WriteLine(c4)
      
      ' Assign the value returned by an operator to a Complex variable.
      Dim c5 As Complex = Complex.One + Complex.One
      Console.WriteLine(c5)

      ' Instantiate a complex number from its polar coordinates.
      Dim c6 As Complex = Complex.FromPolarCoordinates(10, .524)
      Console.WriteLine(c6)
   End Sub
End Module
' The example displays the following output:
'       (12, 6)
'       (3.14, 0)
'       (12.3000001907349, 0)
'       (1, 0)
'       (2, 0)
'       (8.65824721882145, 5.00347430269914)

Vorgänge mit komplexen Zahlen

Die Complex Struktur in der .NET Framework enthält Elemente, die die folgenden Funktionen bereitstellen:

  • Methoden zum Vergleichen von zwei komplexen Zahlen, um zu bestimmen, ob sie gleich sind.

  • Operatoren zum Ausführen arithmetischer Vorgänge auf komplexen Zahlen. Complex Operatoren ermöglichen es Ihnen, Ergänzung, Subtraktion, Multiplikation, Division und unäre Negation mit komplexen Zahlen auszuführen.

  • Methoden zum Ausführen anderer numerischer Vorgänge auf komplexen Zahlen. Zusätzlich zu den vier grundlegenden arithmetischen Vorgängen können Sie eine komplexe Zahl auf eine angegebene Macht auslösen, die Quadratwurzel einer komplexen Zahl finden und den absoluten Wert einer komplexen Zahl abrufen.

  • Methoden zum Ausführen von trigonometrischen Vorgängen auf komplexen Zahlen. Sie können z. B. die Tangente eines Winkels berechnen, der durch eine komplexe Zahl dargestellt wird.

Beachten Sie, dass der Wert eines vorhandenen Complex Objekts nicht geändert werden kann, da die Real Imaginary Eigenschaften schreibgeschützt sind. Alle Methoden, die einen Vorgang für eine Complex Zahl ausführen, wenn der Rückgabewert vom Typ Complexist, geben Sie eine neue Complex Zahl zurück.

Genauigkeit und komplexe Zahlen

Die realen und imaginären Teile einer komplexen Zahl werden durch zwei Gleitkommawerte mit doppelter Genauigkeit dargestellt. Dies bedeutet, dass Complex Werte, z. B. Gleitkommawerte mit doppelter Genauigkeit, aufgrund numerischer Vorgänge die Genauigkeit verlieren können. Dies bedeutet, dass strenge Vergleiche für die Gleichheit von zwei Complex Werten fehlschlagen können, auch wenn der Unterschied zwischen den beiden Werten auf einen Genauigkeitsverlust zurückzuführen ist. Weitere Informationen finden Sie unter Double.

Wenn Sie beispielsweise die Exponentiation auf dem Logarithmus einer Zahl ausführen, sollte die ursprüngliche Zahl zurückgegeben werden. In einigen Fällen kann jedoch der Verlust der Genauigkeit von Gleitkommawerten geringfügige Unterschiede zwischen den beiden Werten verursachen, wie das folgende Beispiel veranschaulicht.

Complex value = new Complex(Double.MinValue/2, Double.MinValue/2);
Complex value2 = Complex.Exp(Complex.Log(value));
Console.WriteLine("{0} \n{1} \nEqual: {2}", value, value2,
                                            value == value2);
// The example displays the following output:
//    (-8.98846567431158E+307, -8.98846567431158E+307)
//    (-8.98846567431161E+307, -8.98846567431161E+307)
//    Equal: False
Dim value As New Complex(Double.MinValue/2, Double.MinValue/2)
Dim value2 As Complex = Complex.Exp(Complex.Log(value))
Console.WriteLine("{0} {3}{1} {3}Equal: {2}", value, value2, 
                                              value = value2,
                                              vbCrLf)
' The example displays the following output:
'    (-8.98846567431158E+307, -8.98846567431158E+307)
'    (-8.98846567431161E+307, -8.98846567431161E+307)
'    Equal: False

Ebenso erzeugt das folgende Beispiel, das die Quadratwurzel einer Complex Zahl berechnet, geringfügig unterschiedliche Ergebnisse für die 32-Bit- und IA64-Versionen der .NET Framework.

Complex minusOne = new Complex(-1, 0);
Console.WriteLine(Complex.Sqrt(minusOne));
// The example displays the following output:
//    (6.12303176911189E-17, 1) on 32-bit systems.
//    (6.12323399573677E-17,1) on IA64 systems.
Dim minusOne As New Complex(-1, 0)
Console.WriteLine(Complex.Sqrt(minusOne))
' The example displays the following output:
'    (6.12303176911189E-17, 1) on 32-bit systems.
'    (6.12323399573677E-17,1) on IA64 systems.

Komplexe Zahlen, Unendlichkeit und NaN

Die realen und imaginären Teile einer komplexen Zahl werden durch Double Werte dargestellt. Zusätzlich zum Bereich von Double.MinValue Double.MaxValuebis hin zum realen oder imaginären Teil einer komplexen Zahl kann ein Wert von Double.PositiveInfinity, Double.NegativeInfinityoder Double.NaN. Double.PositiveInfinity, Double.NegativeInfinityund Double.NaN alle verteilt in allen arithmetischen oder trigonometrischen Vorgängen.

Im folgenden Beispiel erzeugt die Division eine Zero komplexe Zahl, deren reale und imaginäre Teile beide Double.NaNsind. Dadurch erzeugt die Multiplikation mit diesem Wert auch eine komplexe Zahl, deren reale und imaginäre Teile sind Double.NaN. Ebenso erzeugt das Ausführen einer Multiplikation, die den Bereich des Double Typs überläuft, eine komplexe Zahl, deren realer Teil ist Double.NaN und dessen imaginärer Teil ist Double.PositiveInfinity. Anschließend gibt die Division mit dieser komplexen Zahl eine komplexe Zahl zurück, deren realer Teil ist Double.NaN und dessen imaginärer Teil ist Double.PositiveInfinity.

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      Complex c1 = new Complex(Double.MaxValue / 2, Double.MaxValue /2);

      Complex c2 = c1 / Complex.Zero;
      Console.WriteLine(c2.ToString());
      c2 = c2 * new Complex(1.5, 1.5);
      Console.WriteLine(c2.ToString());
      Console.WriteLine();

      Complex c3 = c1 * new Complex(2.5, 3.5);
      Console.WriteLine(c3.ToString());
      c3 = c3 + new Complex(Double.MinValue / 2, Double.MaxValue / 2);
      Console.WriteLine(c3);
   }
}
// The example displays the following output:
//       (NaN, NaN)
//       (NaN, NaN)
//       (NaN, Infinity)
//       (NaN, Infinity)
Imports System.Numerics

Module Example
   Public Sub Main()
      Dim c1 As Complex = New Complex(Double.MaxValue / 2, Double.MaxValue /2)

      Dim c2 As Complex = c1 / Complex.Zero
      Console.WriteLine(c2.ToString())
      c2 = c2 * New Complex(1.5, 1.5)
      Console.WriteLine(c2.ToString())
      Console.WriteLine()
      
      Dim c3 As Complex = c1 * New Complex(2.5, 3.5)
      Console.WriteLine(c3.ToString())
      c3 = c3 + New Complex(Double.MinValue / 2, Double.MaxValue / 2) 
      Console.WriteLine(c3)     
   End Sub
End Module
' The example displays the following output:
'       (NaN, NaN)
'       (NaN, NaN)
'
'       (NaN, Infinity)
'       (NaN, Infinity)

Mathematische Vorgänge mit komplexen Zahlen, die ungültig sind oder der den Bereich des Double Datentyps überläuft, löst keine Ausnahme aus. Stattdessen geben sie ein Double.PositiveInfinity, Double.NegativeInfinityoder Double.NaN unter den folgenden Bedingungen zurück:

Beachten Sie, dass dies für alle von einer Methode durchgeführten Zwischenberechnungen gilt. Beispielsweise wird die Multiplikation new Complex(9e308, 9e308) and new Complex(2.5, 3.5) der Formel (ac - bd) + (ad + bc)i verwendet. Die Berechnung der realen Komponente, die aus der Multiplikation resultiert, wertet den Ausdruck 9e308 * 2,5 - 9e308 * 3,5 aus. Jede zwischene Multiplikation in diesem Ausdruck gibt zurückDouble.PositiveInfinity, und der Versuch, von Double.PositiveInfinity Rückgaben Double.NaNsubtrahieren Double.PositiveInfinity zu können.

Formatieren einer komplexen Zahl

Standardmäßig übernimmt die Zeichenfolgendarstellung einer komplexen Zahl die form (reale, imaginäre) Form, wobei real und imaginär die Zeichenfolgendarstellungen der Werte sind, die Double die realen und imaginären Komponenten der komplexen Zahl bilden. Einige Überladungen der ToString Methode ermöglichen die Anpassung der Zeichenfolgendarstellungen dieser Double Werte, um die Formatierungskonventionen einer bestimmten Kultur widerzuspiegeln oder in einem bestimmten Format anzuzeigen, das durch eine Standard- oder benutzerdefinierte numerische Formatzeichenfolge definiert wird. (Weitere Informationen finden Sie unter Standard numerische Formatzeichenfolgen und benutzerdefinierte numerische Formatzeichenfolgen.)

Eine der gängigeren Methoden zum Ausdrücken der Zeichenfolgendarstellung einer komplexen Zahl verwendet die Form a + bi, wobei es sich um die reale Komponente der komplexen Zahl handelt, und b ist die imaginäre Komponente der komplexen Zahl. In der Elektrotechnik wird eine komplexe Zahl am häufigsten als +bj ausgedrückt. Sie können die Zeichenfolgendarstellung einer komplexen Zahl in einer dieser beiden Formulare zurückgeben. Definieren Sie dazu einen benutzerdefinierten Formatanbieter, indem Sie die ICustomFormatter IFormatProvider Und-Schnittstellen implementieren und dann die String.Format(IFormatProvider, String, Object[]) Methode aufrufen.

Im folgenden Beispiel wird eine Klasse definiert, die eine ComplexFormatter komplexe Zahl als Zeichenfolge in Form einer +bi oder einer +bj darstellt.

using System;
using System.Numerics;

public class ComplexFormatter :IFormatProvider, ICustomFormatter
{
   public object GetFormat(Type formatType)
   {
      if (formatType == typeof(ICustomFormatter))
         return this;
      else
         return null;
   }

   public string Format(string format, object arg,
                        IFormatProvider provider)
   {
      if (arg is Complex)
      {
         Complex c1 = (Complex) arg;
         // Check if the format string has a precision specifier.
         int precision;
         string fmtString = String.Empty;
         if (format.Length > 1) {
            try {
               precision = Int32.Parse(format.Substring(1));
            }
            catch (FormatException) {
               precision = 0;
            }
            fmtString = "N" + precision.ToString();
         }
         if (format.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase))
            return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "i";
         else if (format.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase))
            return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "j";
         else
            return c1.ToString(format, provider);
      }
      else
      {
         if (arg is IFormattable)
            return ((IFormattable) arg).ToString(format, provider);
         else if (arg != null)
            return arg.ToString();
         else
            return String.Empty;
      }
   }
}
Imports System.Numerics

Public Class ComplexFormatter 
             Implements IFormatProvider, ICustomFormatter
   
   Public Function GetFormat(formatType As Type) As Object _
                   Implements IFormatProvider.GetFormat
      If formatType Is GetType(ICustomFormatter) Then
         Return Me
      Else
         Return Nothing
      End If
   End Function
   
   Public Function Format(fmt As String, arg As Object, 
                          provider As IFormatProvider) As String _
                   Implements ICustomFormatter.Format
      If TypeOf arg Is Complex Then
         Dim c1 As Complex = DirectCast(arg, Complex)
         ' Check if the format string has a precision specifier.
         Dim precision As Integer
         Dim fmtString As String = String.Empty
         If fmt.Length > 1 Then
            Try
               precision = Int32.Parse(fmt.Substring(1))
            Catch e As FormatException
               precision = 0
            End Try
            fmtString = "N" + precision.ToString()
         End If
         If fmt.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase) Then
            Return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "i"
         ElseIf fmt.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase) Then
            Return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "j"
         Else
            Return c1.ToString(fmt, provider)
         End If
      Else
         If Typeof arg Is IFormattable Then
            Return DirectCast(arg, IFormattable).ToString(fmt, provider)
         ElseIf arg IsNot Nothing Then
            Return arg.ToString()
         Else
            Return String.Empty
         End If   
      End If                        
   End Function
End Class

Im folgenden Beispiel wird dann dieser benutzerdefinierte Formatierer verwendet, um die Zeichenfolgendarstellung einer komplexen Zahl anzuzeigen.

public class Example
{
   public static void Main()
   {
      Complex c1 = new Complex(12.1, 15.4);
      Console.WriteLine("Formatting with ToString():       " +
                        c1.ToString());
      Console.WriteLine("Formatting with ToString(format): " +
                        c1.ToString("N2"));
      Console.WriteLine("Custom formatting with I0:        " +
                        String.Format(new ComplexFormatter(), "{0:I0}", c1));
      Console.WriteLine("Custom formatting with J3:        " +
                        String.Format(new ComplexFormatter(), "{0:J3}", c1));
   }
}
// The example displays the following output:
//    Formatting with ToString():       (12.1, 15.4)
//    Formatting with ToString(format): (12.10, 15.40)
//    Custom formatting with I0:        12 + 15i
//    Custom formatting with J3:        12.100 + 15.400j
Module Example
   Public Sub Main()
      Dim c1 As Complex = New Complex(12.1, 15.4)
      Console.WriteLine("Formatting with ToString():       " + 
                        c1.ToString())
      Console.WriteLine("Formatting with ToString(format): " + 
                        c1.ToString("N2"))
      Console.WriteLine("Custom formatting with I0:        " + 
                        String.Format(New ComplexFormatter(), "{0:I0}", c1))
      Console.WriteLine("Custom formatting with J3:        " + 
                        String.Format(New ComplexFormatter(), "{0:J3}", c1))
   End Sub
End Module
' The example displays the following output:
'    Formatting with ToString():       (12.1, 15.4)
'    Formatting with ToString(format): (12.10, 15.40)
'    Custom formatting with I0:        12 + 15i
'    Custom formatting with J3:        12.100 + 15.400j

Konstruktoren

Complex(Double, Double)

Initialisiert eine neue Instanz der Complex-Struktur mit den angegebenen reellen und imaginären Werten.

Felder

ImaginaryOne

Gibt eine neue Complex-Instanz mit einer reellen Zahl gleich 0 und einer imaginären Zahl gleich 1 zurück.

Infinity

Stellt Unendlichkeit als komplexe Zahl dar.

NaN

Stellt eine komplexe Instanz dar, die keine Zahl ist (NaN).

One

Gibt eine neue Complex-Instanz mit einer reellen Zahl gleich 1 und einer imaginären Zahl gleich 0 zurück.

Zero

Gibt eine neue Complex-Instanz mit einer reellen Zahl gleich 0 und einer imaginären Zahl gleich 0 zurück.

Eigenschaften

Imaginary

Ruft die imaginäre Komponente des aktuellen Complex-Objekts ab.

Magnitude

Ruft die Größenordnung (oder den absoluten Wert) einer komplexen Zahl ab.

Phase

Ruft die Phase einer komplexen Zahl ab.

Real

Ruft die reelle Komponente des aktuellen Complex-Objekts ab.

Methoden

Abs(Complex)

Ruft den absoluten Wert (oder die Größenordnung) einer komplexen Zahl ab.

Acos(Complex)

Gibt den Winkel zurück, der der Arkuskosinus der angegebenen komplexen Zahl ist.

Add(Complex, Complex)

Addiert zwei komplexe Zahlen und gibt das Ergebnis zurück.

Add(Complex, Double)

Fügt einer reellen Zahl mit doppelter Genauigkeit eine komplexe Zahl hinzu und gibt das Ergebnis zurück.

Add(Double, Complex)

Fügt einer komplexen Zahl eine reelle Zahl mit doppelter Genauigkeit hinzu und gibt das Ergebnis zurück.

Asin(Complex)

Gibt den Winkel zurück, der der Arkussinus der angegebenen komplexen Zahl ist.

Atan(Complex)

Gibt den Winkel zurück, der der Arkustangens der angegebenen komplexen Zahl ist.

Conjugate(Complex)

Berechnet die konjugierte Zahl einer komplexen Zahl und gibt das Ergebnis zurück.

Cos(Complex)

Gibt den Kosinus der angegebenen komplexen Zahl zurück.

Cosh(Complex)

Gibt den Hyperbelkosinus der angegebenen komplexen Zahl zurück.

Divide(Complex, Complex)

Dividiert eine komplexe Zahl durch eine andere komplexe Zahl und gibt das Ergebnis zurück.

Divide(Complex, Double)

Dividiert eine komplexe Zahl durch eine reelle Zahl mit doppelter Genauigkeit und gibt das Ergebnis zurück.

Divide(Double, Complex)

Dividiert eine reelle Zahl mit doppelter Genauigkeit durch eine komplexe Zahl und gibt das Ergebnis zurück.

Equals(Complex)

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine angegebene komplexe Zahl den gleichen Wert haben.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes Objekt über den gleichen Wert verfügen.

Exp(Complex)

Gibt e potenziert mit einer angegebenen komplexen Zahl zurück.

FromPolarCoordinates(Double, Double)

Erstellt eine komplexe Zahl aus den Polarkoordinaten eines Punkts.

GetHashCode()

Gibt den Hashcode für das aktuelle Complex-Objekt zurück.

IsComplexNumber(Complex)

Bestimmt, ob ein Wert einen komplexen Wert darstellt.

IsEvenInteger(Complex)

Bestimmt, ob ein Wert eine sogar integrale Zahl darstellt.

IsFinite(Complex)

Bestimmt, ob die angegebene komplexe Zahl endlich ist.

IsImaginaryNumber(Complex)

Bestimmt, ob ein Wert eine imaginäre Zahl darstellt.

IsInfinity(Complex)

Gibt einen Wert zurück, der angibt, ob die angegebene komplexe Zahl als unendlich ausgewertet wird.

IsInteger(Complex)

Bestimmt, ob ein Wert einen integralen Wert darstellt.

IsNaN(Complex)

Gibt einen Wert zurück, der angibt, ob die angegebene komplexe Instanz keine Zahl ist (NaN).

IsNegative(Complex)

Bestimmt, ob ein Wert negativ ist.

IsNegativeInfinity(Complex)

Bestimmt, ob ein Wert negative Unendlichkeit ist.

IsNormal(Complex)

Bestimmt, ob ein Wert normal ist.

IsOddInteger(Complex)

Bestimmt, ob ein Wert eine ungerade integrale Zahl darstellt.

IsPositive(Complex)

Bestimmt, ob ein Wert positiv ist.

IsPositiveInfinity(Complex)

Bestimmt, ob ein Wert positive Unendlichkeit ist.

IsRealNumber(Complex)

Bestimmt, ob ein Wert eine echte Zahl darstellt.

IsSubnormal(Complex)

Bestimmt, ob ein Wert unternormal ist.

Log(Complex)

Gibt den natürlichen Logarithmus (zur Basis e) einer komplexen Zahl zurück.

Log(Complex, Double)

Gibt den Logarithmus einer angegebenen komplexen Zahl zu einer angegebenen Basis zurück.

Log10(Complex)

Gibt den Logarithmus einer angegebenen komplexen Zahl zur Basis 10 zurück.

MaxMagnitude(Complex, Complex)

Vergleicht zwei Werte mit der Berechnung, die größer ist.

MinMagnitude(Complex, Complex)

Vergleicht zwei Werte mit der Berechnung, die kleiner ist.

Multiply(Complex, Complex)

Gibt das Produkt zweier komplexer Zahlen zurück.

Multiply(Complex, Double)

Gibt das Produkt einer komplexen Zahl und einer reellen Zahl mit doppelter Genauigkeit zurück.

Multiply(Double, Complex)

Gibt das Produkt einer reellen Zahl mit doppelter Genauigkeit und einer komplexen Zahl zurück.

Negate(Complex)

Gibt die additive Inverse einer angegebenen komplexen Zahl zurück.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analysiert einen Bereich von Zeichen in einen Wert.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Analysiert einen Bereich von Zeichen in einen Wert.

Parse(String, IFormatProvider)

Analysiert eine Zeichenfolge in einen Wert.

Parse(String, NumberStyles, IFormatProvider)

Analysiert eine Zeichenfolge in einen Wert.

Pow(Complex, Complex)

Gibt eine komplexe Zahl potenziert mit einem durch eine komplexe Zahl angegebenen Exponenten zurück.

Pow(Complex, Double)

Gibt eine angegebene komplexe Zahl potenziert mit einem als Gleitkommazahl mit doppelter Genauigkeit angegebenen Exponenten zurück.

Reciprocal(Complex)

Gibt den Kehrwert einer komplexen Zahl zurück.

Sin(Complex)

Gibt den Sinus der angegebenen komplexen Zahl zurück.

Sinh(Complex)

Gibt den Hyperbelsinus der angegebenen komplexen Zahl zurück.

Sqrt(Complex)

Gibt die Quadratwurzel einer angegebenen komplexen Zahl zurück.

Subtract(Complex, Complex)

Subtrahiert eine komplexe Zahl von einer anderen komplexen Zahl und gibt das Ergebnis zurück.

Subtract(Complex, Double)

Subtrahiert eine reelle Zahl mit doppelter Genauigkeit von einer komplexen Zahl und gibt das Ergebnis zurück.

Subtract(Double, Complex)

Subtrahiert eine komplexe Zahl von einer reellen Zahl mit doppelter Genauigkeit und gibt das Ergebnis zurück.

Tan(Complex)

Gibt den Tangens der angegebenen komplexen Zahl zurück.

Tanh(Complex)

Gibt den Hyperbeltangens der angegebenen komplexen Zahl zurück.

ToString()

Konvertiert den Wert der aktuellen komplexen Zahl in die entsprechende Zeichenfolgendarstellung in kartesischer Form.

ToString(IFormatProvider)

Konvertiert den Wert der aktuellen komplexen Zahl unter Verwendung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung in kartesischer Form.

ToString(String)

Konvertiert den Wert der aktuellen komplexen Zahl unter Verwendung des angegebenen Formats für die reellen und imaginären Teile in die entsprechende Zeichenfolgendarstellung in kartesischer Form.

ToString(String, IFormatProvider)

Konvertiert den Wert der aktuellen komplexen Zahl unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen für die reellen und imaginären Teile in die entsprechende Zeichenfolgendarstellung in kartesischer Form.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert der aktuellen Instanz in den angegebenen Bereich von Zeichen zu formatieren.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)

Versucht, einen Bereich von Zeichen in einen Wert zu analysieren.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)

Versucht, einen Bereich von Zeichen in einen Wert zu analysieren.

TryParse(String, IFormatProvider, Complex)

Versucht, eine Zeichenfolge in einen Wert zu analysieren.

TryParse(String, NumberStyles, IFormatProvider, Complex)

Versucht, eine Zeichenfolge in einen Wert zu analysieren.

Operatoren

Addition(Complex, Complex)

Addiert zwei komplexe Zahlen.

Addition(Complex, Double)

Fügt einer reellen Zahl mit doppelter Genauigkeit eine komplexe Zahl hinzu.

Addition(Double, Complex)

Fügt einer komplexen Zahl eine reelle Zahl mit doppelter Genauigkeit hinzu.

Decrement(Complex)

Erhöht einen Wert.

Division(Complex, Complex)

Dividiert eine angegebene komplexe Zahl durch eine andere angegebene komplexe Zahl.

Division(Complex, Double)

Dividiert eine angegebene komplexe Zahl durch eine reelle Zahl mit doppelter Genauigkeit.

Division(Double, Complex)

Dividiert eine angegebene reelle Zahl mit doppelter Genauigkeit durch eine angegebene komplexe Zahl.

Equality(Complex, Complex)

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

Explicit(BigInteger to Complex)

Definiert eine explizite Konvertierung eines BigInteger-Werts in eine komplexe Zahl.

Explicit(Decimal to Complex)

Definiert eine explizite Konvertierung eines Decimal-Werts in eine komplexe Zahl.

Explicit(Int128 to Complex)

Wandelt einen Int128 Wert explizit in eine doppelgenaue komplexe Zahl um.

Explicit(UInt128 to Complex)

Wandelt einen UInt128 Wert explizit in eine doppelgenaue komplexe Zahl um.

Implicit(Byte to Complex)

Definiert eine implizite Konvertierung eines Bytewerts ohne Vorzeichen in eine komplexe Zahl.

Implicit(Char to Complex)

Konvertiert implizit einen Wert in eine Char doppelgenaue komplexe Zahl.

Implicit(Double to Complex)

Definiert eine implizite Konvertierung einer Gleitkommazahl mit doppelter Genauigkeit in eine komplexe Zahl.

Implicit(Half to Complex)

Konvertiert implizit einen Wert in eine Half doppelgenaue komplexe Zahl.

Implicit(Int16 to Complex)

Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl mit Vorzeichen in eine komplexe Zahl.

Implicit(Int32 to Complex)

Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl mit Vorzeichen in eine komplexe Zahl.

Implicit(Int64 to Complex)

Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl mit Vorzeichen in eine komplexe Zahl.

Implicit(IntPtr to Complex)

Konvertiert implizit einen Wert in eine IntPtr doppelgenaue komplexe Zahl.

Implicit(SByte to Complex)

Definiert eine implizite Konvertierung eines Bytewerts mit Vorzeichen in eine komplexe Zahl.

Diese API ist nicht CLS-kompatibel.

Implicit(Single to Complex)

Definiert eine implizite Konvertierung einer Gleitkommazahl mit einfacher Genauigkeit in eine komplexe Zahl.

Implicit(UInt16 to Complex)

Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl ohne Vorzeichen in eine komplexe Zahl.

Diese API ist nicht CLS-kompatibel.

Implicit(UInt32 to Complex)

Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl ohne Vorzeichen in eine komplexe Zahl.

Diese API ist nicht CLS-kompatibel.

Implicit(UInt64 to Complex)

Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl ohne Vorzeichen in eine komplexe Zahl.

Diese API ist nicht CLS-kompatibel.

Implicit(UIntPtr to Complex)

Konvertiert implizit einen Wert in eine UIntPtr doppelgenaue komplexe Zahl.

Increment(Complex)

Erhöht einen Wert.

Inequality(Complex, Complex)

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

Multiply(Complex, Complex)

Multipliziert zwei angegebene komplexe Zahlen.

Multiply(Complex, Double)

Multipliziert die angegebene komplexe Zahl durch eine angegebene reelle Zahl mit doppelter Genauigkeit.

Multiply(Double, Complex)

Multipliziert eine angegebene reelle Zahl mit doppelter Genauigkeit durch eine angegebene komplexe Zahl.

Subtraction(Complex, Complex)

Subtrahiert eine komplexe Zahl von einer anderen komplexen Zahl.

Subtraction(Complex, Double)

Subtrahiert eine reelle Zahl mit doppelter Genauigkeit von einer komplexen Zahl.

Subtraction(Double, Complex)

Subtrahiert eine komplexe Zahl von einer reellen Zahl mit doppelter Genauigkeit.

UnaryNegation(Complex)

Gibt die additive Inverse einer angegebenen komplexen Zahl zurück.

UnaryPlus(Complex)

Berechnet das unäre Plus eines Werts.

Gilt für