Complex Struktur

Definition

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>, IUtf8SpanParsable<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, bool>, 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 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, bool>, 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>, IParsable<System.Numerics.Complex>, ISpanParsable<System.Numerics.Complex>, IUtf8SpanParsable<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,bool>, 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 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,bool>, 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, bool>
    interface IIncrementOperators<Complex>
    interface IMultiplicativeIdentity<Complex, Complex>
    interface IMultiplyOperators<Complex, Complex, Complex>
    interface INumberBase<Complex>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<Complex>
    interface ISubtractionOperators<Complex, Complex, Complex>
    interface IUnaryNegationOperators<Complex, Complex>
    interface IUnaryPlusOperators<Complex, Complex>
    interface ISignedNumber<Complex>

type Complex = struct
    interface IFormattable
    interface IParsable<Complex>
    interface ISpanFormattable
    interface ISpanParsable<Complex>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<Complex>
    interface IAdditionOperators<Complex, Complex, Complex>
    interface IAdditiveIdentity<Complex, Complex>
    interface IDecrementOperators<Complex>
    interface IDivisionOperators<Complex, Complex, Complex>
    interface IEqualityOperators<Complex, Complex, bool>
    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>

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, bool>
    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>

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, bool>
    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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<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, Boolean), 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), IUtf8SpanParsable(Of Complex)

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, Boolean), 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

Object

ValueType

Complex

Attribute

SerializableAttribute

Implementiert

IEquatable<Complex> IFormattable IEquatable<TSelf> IParsable<Complex> IParsable<TSelf> ISpanFormattable ISpanParsable<Complex> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Complex> IUtf8SpanParsable<TSelf> IAdditionOperators<Complex,Complex,Complex> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Complex,Complex> IAdditiveIdentity<TSelf,TSelf> IDecrementOperators<Complex> IDecrementOperators<TSelf> IDivisionOperators<Complex,Complex,Complex> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Complex,Complex,Boolean> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<Complex> IIncrementOperators<TSelf> IMultiplicativeIdentity<Complex,Complex> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Complex,Complex,Complex> IMultiplyOperators<TSelf,TSelf,TSelf> INumberBase<Complex> INumberBase<TSelf> ISignedNumber<Complex> ISubtractionOperators<Complex,Complex,Complex> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Complex,Complex> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Complex,Complex> IUnaryPlusOperators<TSelf,TSelf>

Hinweise

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 i² = -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 (Shared in Visual Basic) Complex.FromPolarCoordinates -Methode zum Erstellen einer komplexen Zahl aus den Polarkoordinaten.

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

• Durch Casten (in C#) oder Konvertieren (in Visual Basic) wird ein Decimal- oder BigInteger-Wert in ein Complex-Objekt umgewandelt. 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 Run()
    {
        // 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 Run()
      ' 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 Sie den Wert eines vorhandenen Real-Objekts nicht ändern können, da die Imaginary- und Complex-Eigenschaften 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($"{value} \n{value2} \nEqual: {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 Double.MaxValue kann der reale oder imaginäre Teil einer komplexen Zahl einen Wert von Double.PositiveInfinity, Double.NegativeInfinity oder Double.NaN haben. 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 Run()
    {
        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 Run()
        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 mit den Werten Double.PositiveInfinity, Double.NegativeInfinity oder Double.NaN ausgeführt wird, gibt in Abhängigkeit vom jeweiligen Vorgang Double.PositiveInfinity, Double.NegativeInfinity oder Double.NaN zurü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 Double.PositiveInfinity zurück, und der Versuch, Double.PositiveInfinity von Double.PositiveInfinity zu subtrahieren, gibt Double.NaN zurück.

Formatieren einer komplexen Zahl

Standardmäßig wird die Zeichenfolgendarstellung einer komplexen Zahl als <reale; verwendet, wobei > und imaginäre Zeichenfolgendarstellungen der 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 a + bi, wobei a es sich um die reale Komponente der komplexen Zahl handelt und b die imaginäre Komponente der komplexen Zahl ist. In der Elektrotechnik wird eine komplexe Zahl am häufigsten als ausgedrückt.a + bj 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 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 entweder in der Form von a + bi oder a + 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 c1)
        {
            // Check if the format string has a precision specifier.
            int precision;
            string fmtString = string.Empty;
            if (format.Length > 1)
            {
                try
                {
                    precision = int.Parse(format.Substring(1));
                }
                catch (FormatException)
                {
                    precision = 0;
                }
                fmtString = "N" + precision.ToString();
            }
            if (format.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase))
            {
                // Determine the sign to display.
                char sign = c1.Imaginary < 0 ? '-' : '+';
                // Display the determined sign and the absolute value of the imaginary part.
                return c1.Real.ToString(fmtString) + " " + sign + " " + Math.Abs(c1.Imaginary).ToString(fmtString) + "i";
            }
            else if (format.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase))
            {
                // Determine the sign to display.
                char sign = c1.Imaginary < 0 ? '-' : '+';
                // Display the determined sign and the absolute value of the imaginary part.
                return c1.Real.ToString(fmtString) + " " + sign + " " + Math.Abs(c1.Imaginary).ToString(fmtString) + "j";
            }
            else
                return c1.ToString(format, provider);
        }
        else
        {
            if (arg is IFormattable formattable)
                return formattable.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 = Integer.Parse(fmt.Substring(1))
                Catch e As FormatException
                    precision = 0
                End Try
                fmtString = "N" + precision.ToString()
            End If
            ' Determine the sign to display.
            Dim sign As Char = If(c1.Imaginary < 0.0, "-"c, "+"c)
            ' Display the determined sign and the absolute value of the imaginary part.
            If fmt.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase) Then
                Return c1.Real.ToString(fmtString) + " " + sign + " " + Math.Abs(c1.Imaginary).ToString(fmtString) + "i"
            ElseIf fmt.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase) Then
                Return c1.Real.ToString(fmtString) + " " + sign + " " + Math.Abs(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 Run()
    {
        Complex c1 = new(12.1, 15.4);
        Console.WriteLine($"Formatting with ToString:         {c1}");
        Console.WriteLine($"Formatting with ToString(format): {c1:N2}");
        Console.WriteLine($"Custom formatting with I0:\t" +
            $"  {string.Format(new ComplexFormatter(), "{0:I0}", c1)}");
        Console.WriteLine($"Custom formatting with J3:\t" +
            $"  {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 Run()
        Dim c1 As New Complex(12.1, 15.4)
        Console.WriteLine($"Formatting with ToString():       {c1}")
        Console.WriteLine($"Formatting with ToString(format): {c1: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