System.Numerics.Complex-Struktur
Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.
Eine komplexe Zahl ist eine Zahl, die einen reellen Zahlenteil und einen imaginären Zahlenteil umfasst. Eine komplexe Zahl z wird in der Regel in der Form z = x + yigeschrieben, wobei x und y reelle 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) 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 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 schneiden).
- Die Phase, bei der es sich um den Winkel zwischen der realen Achse und der Linie handelt, die vom Ursprung zum Punkt gezeichnet wird.
Instanziieren einer komplexen Zahl
Sie können einer komplexen Zahl auf eine der folgenden Arten einen Wert zuweisen:
Durch Übergeben von zwei Double Werten an den Konstruktor. Der erste Wert stellt den tatsächlichen 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.
Durch Aufrufen der statischen (
Sharedin Visual Basic) Complex.FromPolarCoordinates -Methode zum Erstellen einer komplexen Zahl aus den Polarkoordinaten.Durch Zuweisen eines Byte, SByte, Int16, Int64UInt16UInt64Int32UInt32, , , oder SingleDouble Werts zu einem Complex Objekt. Der Wert wird der reale Teil der komplexen Zahl, und sein imaginärer Teil entspricht 0.
Durch Umwandeln (in C#) oder Konvertieren (in Visual Basic) wird ein oder BigInteger ein Decimal Wert in ein Complex Objekt konvertiert. Der Wert wird der reale Teil der komplexen Zahl, und sein imaginärer Teil entspricht 0.
Durch Zuweisen der komplexen Zahl, die von einer Methode oder einem Operator einem Complex Objekt zurückgegeben wird. Ist beispielsweise eine statische Methode, die eine komplexe Zahl zurückgibt, Complex.Add die die Summe von zwei komplexen Zahlen darstellt, und der Complex.Addition Operator addiert zwei komplexe Zahlen 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 CreateEx
{
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 .NET 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 von arithmetischen Vorgängen 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 Vorgänge für komplexe Zahlen. Zusätzlich zu den vier grundlegenden arithmetischen Operationen können Sie eine komplexe Zahl auf eine angegebene Potenz erhöhen, die Quadratwurzel einer komplexen Zahl suchen und den Absolutenwert einer komplexen Zahl abrufen.
- Methoden zum Ausführen von trigonometrischen Vorgängen für komplexe Zahlen. Sie können beispielsweise den Tangens 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 Eigenschaften Imaginary schreibgeschützt sind. Alle Methoden, die einen Vorgang für eine Complex Zahl ausführen, wenn ihr Rückgabewert vom Typ Complexist, geben 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 wie 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.
Beispielsweise sollte beim Ausführen der Exponentiation auf dem Logarithmus einer Zahl die ursprüngliche Zahl zurückgegeben werden. In einigen Fällen kann der Verlust der Genauigkeit von Gleitkommawerten jedoch geringfügige Unterschiede zwischen den beiden Werten verursachen, wie im folgenden Beispiel dargestellt.
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 andere Ergebnisse für die 32-Bit- und IA64-Versionen von .NET.
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.
Infinity und NaN
Die realen und imaginären Teile einer komplexen Zahl werden durch Double Werte dargestellt. Neben dem Bereich von Double.MinValue bis zu Double.MaxValue, kann der reale oder imaginäre Teil einer komplexen Zahl einen Wert von Double.PositiveInfinity, , Double.NegativeInfinityoder Double.NaN. Double.PositiveInfinity, Double.NegativeInfinityund Double.NaN alle werden in arithmetischen oder trigonometrischen Vorgängen verteilt.
Im folgenden Beispiel erzeugt die Division durch Zero eine 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. Die anschließende Division mit dieser komplexen Zahl gibt 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 NaNEx
{
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 Example4
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 den Bereich des Double Datentyps überlaufen, lösen keine Ausnahme aus. Stattdessen geben sie ein Double.PositiveInfinity, Double.NegativeInfinityoder Double.NaN unter den folgenden Bedingungen zurück:
- Die Division einer positiven Zahl durch Null gibt zurück Double.PositiveInfinity.
- Jeder Vorgang, der die obere Grenze des Double Datentyps überläuft, gibt Double.PositiveInfinityzurück.
- Die Division einer negativen Zahl durch Null gibt zurück Double.NegativeInfinity.
- Jeder Vorgang, der die untere Grenze des Double Datentyps überläuft, gibt zurück Double.NegativeInfinity.
- Die Division einer Null durch Null gibt zurück Double.NaN.
- Jeder Vorgang, der für Operanden ausgeführt wird, deren Werte abhängig vom jeweiligen Vorgang sindDouble.PositiveInfinity, Double.NegativeInfinityoder Double.NegativeInfinityDouble.NaN Double.PositiveInfinitygibt , oder gibt , oder Double.NaNzurück.
Beachten Sie, dass dies für alle Zwischenberechnungen gilt, die von einer Methode ausgeführt werden. Beispielsweise verwendet die Multiplikation der new Complex(9e308, 9e308) and new Complex(2.5, 3.5) Formel (ac - bd) + (ad + bc)i. Die Berechnung der realen Komponente, die aus der Multiplikation resultiert, wertet den Ausdruck 9e308 2,5 - 9e308 3,5 aus. Jede Zwischenmultiplikation in diesem Ausdruck gibt zurückDouble.PositiveInfinity, und der Versuch, von Double.PositiveInfinity Rückgaben Double.PositiveInfinity Double.NaNsubtrahieren.
Formatieren einer komplexen Zahl
Standardmäßig wird die Zeichenfolgendarstellung einer komplexen Zahl als (reale, Imaginär) verwendet, wobei reale und imaginäre Zeichenfolgendarstellungen der Double Werte sind, die die realen und imaginären Komponenten der komplexen Zahl bilden. Einige Überladungen der ToString Methode ermöglichen das Anpassen der Zeichenfolgendarstellungen dieser Double Werte, um die Formatierungskonventionen einer bestimmten Kultur widerzuspiegeln oder in einem bestimmten Format zu erscheinen, das durch eine standard- oder benutzerdefinierte zahlenformatierte Zeichenfolge definiert ist. (Weitere Informationen finden Sie unter Zeichenfolgen im numerischen Standardformat und benutzerdefinierte Zahlenformatzeichenfolgen.)
Eine der gängigeren Methoden zum Ausdrücken der Zeichenfolgendarstellung einer komplexen Zahl ist die Form "+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 Formen zurückgeben. Definieren Sie dazu einen benutzerdefinierten Formatanbieter, indem Sie die ICustomFormatter Methode implementieren und IFormatProvider schnittstellen implementieren und dann die String.Format(IFormatProvider, String, Object[]) Methode aufrufen.
Im folgenden Beispiel wird eine ComplexFormatter Klasse definiert, die eine komplexe Zahl als Zeichenfolge in Form von +bi oder +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 CustomFormatEx
{
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 Example2
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
