Complex Struktur

Definition

Stellt eine komplexe Zahl dar.

public value class Complex : IEquatable<System::Numerics::Complex>, IFormattable
public struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
[System.Serializable]
public struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
type Complex = struct
    interface IFormattable
[<System.Serializable>]
type Complex = struct
    interface IFormattable
Public Structure Complex
Implements IEquatable(Of Complex), IFormattable
Vererbung
Complex
Attribute
Implementiert

Hinweise

Eine komplexe Zahl ist eine Zahl, die einen echten Zahlenteil und einen imaginären Zahlenteil umfasst. Eine komplexe Zahl z wird in der Regel in der Form z = x + 1 geschrieben, wobei x und y echte Zahlen sind, und i ist die imaginäre Einheit mit der Eigenschaft i2 = -1. Der tatsächliche 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) beim Instanziieren und Bearbeiten komplexer Zahlen. Eine komplexe Zahl kann als Punkt in einem zweidimensionalen Koordinatensystem dargestellt werden, das als komplexe Ebene bezeichnet wird. Der echte Teil der komplexen Zahl wird auf der x-Achse (der horizontalen Achse) und der imaginäre Teil 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 Polarkoordinaten wird ein Punkt durch zwei Zahlen gekennzeichnet:

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

  • Die Phase, bei der es sich um den Winkel zwischen der echten Achse und der Vom Ursprung bis zum Punkt gezeichneten Linie handelt.

Instanziieren einer komplexen Zahl

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

  • Durch Übergeben von Double zwei Werten an den Konstruktor. Der erste Wert stellt den realen Teil der komplexen Zahl dar, und der zweite Wert stellt den imaginären Teil dar. Diese Werte stellen die Position der komplexen Zahl im zweidimensionalen kartesischen Koordinatensystem dar.

  • Durch Aufrufen der statischen Methode ( Shared in Visual Basic), Complex.FromPolarCoordinates um eine komplexe Zahl aus ihren Polarkoordinaten zu erstellen.

  • Durch Zuweisen eines Byte SByte -, Int16 -, UInt16 -, Int32 -, -, UInt32 -, Int64 -, UInt64 Single -, -, - oder Double -Werts zu einem Complex -Objekt. Der Wert wird zum echten Teil der komplexen Zahl, und sein imaginärer Teil ist gleich 0.

  • Durch Umwandeln (in C#) oder Konvertieren (in Visual Basic) eines - oder Decimal BigInteger -Werts in ein Complex -Objekt. Der Wert wird zum echten Teil der komplexen Zahl, und sein imaginärer Teil ist gleich 0.

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

Im folgenden Beispiel wird jede dieser fünf Methoden zum Zuweisen eines Werts zu einer komplexen Zahl veranschaulicht.

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 im .NET Framework enthält Member, die die folgenden Funktionen bereitstellen:

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

  • Operatoren zum Ausführen arithmetischer Operationen für komplexe Zahlen. Complex -Operatoren ermöglichen es Ihnen, Addition, Subtraktion, Multiplikation, Division und unäre Negation mit komplexen Zahlen durchzuführen.

  • Methoden zum Ausführen anderer numerischer Operationen für komplexe Zahlen. Zusätzlich zu den vier grundlegenden arithmetischen Operationen können Sie eine komplexe Zahl auf eine angegebene Leistung erhöhen, die Quadratwurzel einer komplexen Zahl suchen und den absoluten Wert einer komplexen Zahl erhalten.

  • Methoden zum Ausführen von trigonometrischen Vorgängen für komplexe Zahlen. Beispielsweise können Sie den Tangens eines Winkels berechnen, der durch eine komplexe Zahl dargestellt wird.

Beachten Sie, dass Sie den Wert eines vorhandenen -Objekts nicht ändern können, da die Eigenschaften und schreibgeschützt Real Imaginary Complex sind. Alle Methoden, die einen Vorgang für eine Zahl ausführen, geben eine neue Zahl zurück, wenn ihr Rückgabewert vom Complex Complex Typ Complex ist.

Genauigkeit und komplexe Zahlen

Die realen und imaginären Teile einer komplexen Zahl werden durch zwei Gleitkommawerte mit doppelter Genauigkeit dargestellt. Dies bedeutet, dass Werte wie Gleitkommawerte mit doppelter Genauigkeit durch numerische Operationen an Genauigkeit Complex verlieren können. Dies bedeutet, dass strenge Vergleiche auf Gleichheit von zwei Werten fehlschlagen können, auch wenn die Differenz zwischen den beiden Werten auf einen Complex Genauigkeitsverlust zurückfällt. Weitere Informationen finden Sie unter Double.

Wenn Sie z. B. eine Exponentierung für den Logarithmus einer Zahl durchführen, sollte die ursprüngliche Zahl zurückgeben. In einigen Fällen kann der Verlust der Genauigkeit von Gleitkommawerten jedoch geringfügige Unterschiede zwischen den beiden Werten verursachen, wie im folgenden 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

Entsprechend erzeugt das folgende Beispiel, das die Quadratwurzel einer Zahl berechnet, geringfügig unterschiedliche Ergebnisse für die Complex 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 tatsächlichen und imaginären Teile einer komplexen Zahl werden durch Werte Double dargestellt. Zusätzlich zum Bereich von bis kann der reale oder imaginäre Teil einer komplexen Zahl den Wert Double.MinValue Double.MaxValue , oder Double.PositiveInfinity Double.NegativeInfinity Double.NaN haben. Double.PositiveInfinity, und werden alle in arithmetischen oder Double.NegativeInfinity Double.NaN trigonometrischen Operationen weiterproagiert.

Im folgenden Beispiel erzeugt division by eine komplexe Zahl, deren realer und Zero imaginärer Teil beide Double.NaN sind. Daher erzeugt die Multiplikation mit diesem Wert auch eine komplexe Zahl, deren realer und imaginärer Teil Double.NaN ist. Analog dazu wird durch ausführen einer Multiplikation, die den Bereich des Typs überläuft, eine komplexe Zahl erzeugt, deren realer Teil ist und dessen Double Double.NaN Imaginärteil Double.PositiveInfinity ist. Anschließend gibt die Division mit dieser komplexen Zahl eine komplexe Zahl zurück, deren realer Teil ist und Double.NaN dessen imaginärer Teil Double.PositiveInfinity ist.

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 Operationen mit komplexen Zahlen, die ungültig sind oder den Bereich des Datentyps überlaufen, lösen Double keine Ausnahme aus. Stattdessen geben sie unter den folgenden Bedingungen Double.PositiveInfinity Double.NegativeInfinity ein -, - oder Double.NaN -Paar zurück:

Beachten Sie, dass dies für alle Zwischenberechnungen gilt, die von einer Methode ausgeführt werden. Beispielsweise verwendet die Multiplikation von new Complex(9e308, 9e308) and new Complex(2.5, 3.5) die Formel (ac - bd) + (ad + bc)i. Die Berechnung der echten Komponente, die sich aus der Multiplikation ergibt, wertet den Ausdruck 9e308 * 2,5 - 9e308 * 3,5 aus. Jede zwischengeschaltete Multiplikation in diesem Ausdruck gibt zurück, und der Double.PositiveInfinity Versuch, von zu subtrahieren, gibt Double.PositiveInfinity Double.PositiveInfinity Double.NaN zurück.

Formatieren einer komplexen Zahl

Standardmäßig hat die Zeichenfolgendarstellung einer komplexen Zahl die Form real imaginärer , wobei real und imaginär die Zeichenfolgendarstellungen der Werte sind, die die realen und imaginären Komponenten der komplexen Zahl ( , ) Double bilden. Einige Überladungen der -Methode ermöglichen die Anpassung der Zeichenfolgendarstellungen dieser Werte, um die Formatierungskonventionen einer bestimmten Kultur zu widerspiegeln oder in einem bestimmten Format zu erscheinen, das durch eine standardmäßige oder benutzerdefinierte numerische Formatzeichenfolge definiert ToString Double ist. (Weitere Informationen finden Sie unter Numerische Standardformatzeichenfolgen und benutzerdefinierte numerische Formatzeichenfolgen.)

Eine der gängigeren Methoden zum Ausdrücken der Zeichenfolgendarstellung einer komplexen Zahl hat die Form +BI, wobei ein die echte Komponente der komplexen Zahl und b die imaginäre Komponente der komplexen Zahl ist. In der Elektrischen Technik wird eine komplexe Zahl am häufigsten als + bj ausgedrückt. Sie können die Zeichenfolgendarstellung einer komplexen Zahl in einer dieser beiden Formen zurückgeben. Definieren Sie hierzu einen benutzerdefinierten Formatanbieter, indem Sie die Schnittstellen und ICustomFormatter IFormatProvider implementieren, und rufen Sie dann die String.Format(IFormatProvider, String, Object[]) -Methode auf.

Im folgenden Beispiel wird eine Klasse definiert, die eine komplexe Zahl als Zeichenfolge in Form von + bi oder ComplexFormatter + 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 Formatierungser 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.

IsFinite(Complex)

Bestimmt, ob die angegebene komplexe Zahl endlich ist.

IsInfinity(Complex)

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

IsNaN(Complex)

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

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.

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.

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.

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.

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.

Implicit(Byte to Complex)

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

Implicit(Double to Complex)

Definiert eine implizite Konvertierung einer Gleitkommazahl mit doppelter Genauigkeit in eine 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(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.

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.

Gilt für