Complex Struktúra

Definíció

Névtér:

System.Numerics

Szerelvények:

netstandard.dll, System.Runtime.Numerics.dll

Forrás:

Complex.cs

Komplex számot jelöl.

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

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>

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)

Öröklődés

Object

ValueType

Complex

Megvalósítás

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>

Megjegyzések

Az összetett szám egy valós számrészből és egy képzeletbeli számrészből álló szám. Egy komplex számot z általában a z = x + yi alakban írunk, ahol x és y valós számok, és az i a képzeletbeli egység, amelynek az a tulajdonsága, hogy i^² = -1. Az összetett szám valós részét x, a komplex szám képzeletbeli részét pedig y jelöli.

A Complex típus a Cartesian koordinátarendszert (valós, képzeletbeli) használja összetett számok példányosítása és módosításakor. Egy összetett szám pontként jelölhető egy kétdimenziós koordinátarendszerben, amelyet összetett síknak nevezünk. Az összetett szám valós része az x tengelyen (a vízszintes tengelyen) van elhelyezve, a képzeletbeli rész pedig az y tengelyen (a függőleges tengelyen) van elhelyezve.

Az összetett sík bármely pontja az abszolút értéke alapján is kifejezhető a poláris koordinátarendszer használatával. Polárkoordinátákban egy pontot két szám jellemez:

• A mérete, amely a pont távolsága a forrástól (azaz 0,0, vagy az a pont, ahol az x tengely és az y tengely metszi egymást).
• Fázisa, amely a valós tengely és a forrástól a pontig rajzolt vonal közötti szög.

Összetett szám példányosítása

Az alábbi módokon rendelhet hozzá értéket egy összetett számhoz:

• Két Double érték átadásával a konstruktornak. Az első érték az összetett szám valós részét, a második pedig a képzeletbeli részét jelöli. Ezek az értékek a kétdimenziós Cartesian koordinátarendszer komplex számának pozícióját jelölik.

• A statikus (Shared Visual Basic) Complex.FromPolarCoordinates -metódus meghívásával összetett számot hozhat létre a polárkoordinátáiból.

• Egy Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, vagy Double érték hozzárendelése egy Complex objektumhoz. Az érték a komplex szám valódi részévé válik, a képzeletbeli része pedig 0.

• A (C#-ban) vagy a (Visual Basicben) a Decimal vagy BigInteger érték objektummá Complex alakításával. Az érték a komplex szám valódi részévé válik, a képzeletbeli része pedig 0.

• A metódus vagy operátor által visszaadott komplex szám objektumhoz Complex rendelésével. Egy statikus módszer például egy olyan komplex számot ad vissza, Complex.Add amely két összetett szám összege, az Complex.Addition operátor pedig két összetett számot ad hozzá, és visszaadja az eredményt.

Az alábbi példa az érték komplex számhoz rendelésének öt módját mutatja be.

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)

Összetett számokat tartalmazó műveletek

A Complex .NET-ben a struktúra olyan tagokat tartalmaz, amelyek a következő funkciókat biztosítják:

• Két összetett szám összehasonlítására használható módszerek annak meghatározására, hogy egyenlőek-e.
• Operátorok összetett számok számtani műveleteihez. Complex az operátorok lehetővé teszik az összeadást, kivonást, szorzást, osztást és egyváltozós negációt összetett számokkal.
• Más numerikus műveletek összetett számokon történő végrehajtásának módszerei. A négy alapszintű aritmetikai művelet mellett egy összetett számot egy adott teljesítményre is fel lehet emelni, megkeresheti egy komplex szám négyzetgyökét, és lekérheti egy összetett szám abszolút értékét.
• Trigonometriai műveletek összetett számokon történő végrehajtásának módszerei. Kiszámíthatja például egy komplex számmal ábrázolt szög tangensét.

Vegye figyelembe, hogy mivel a Real és Imaginary tulajdonságok írásvédettek, egy meglévő Complex objektum értékét nem módosíthatja. Minden metódus, amely műveletet hajt végre egy Complex számon, ha a visszatérési értéke típus Complex, új Complex számot ad vissza.

Pontosság és összetett számok

Egy komplex szám valós és képzeletbeli részeit két két pontosságú lebegőpontos érték képviseli. Ez azt jelenti, hogy Complex az értékek, például a kettős pontosságú lebegőpontos értékek, a numerikus műveletek eredményeként elveszítik a pontosságot. Ez azt jelenti, hogy a két Complex érték egyenlőségének szigorú összehasonlítása akkor is meghiúsulhat, ha a két érték közötti különbség a pontosság elvesztéséből következik be. További információért lásd Double.

Például, ha elvégezzük egy szám logaritmusán az exponenciálást, az eredeti számot kapjuk vissza. Bizonyos esetekben azonban a lebegőpontos értékek pontosságának elvesztése a két érték között enyhe különbségeket okozhat, amint azt az alábbi példa szemlélteti.

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

Hasonlóképpen, az alábbi példa, amely kiszámítja egy Complex szám négyzetgyökét, némileg eltérő eredményeket hoz létre a .NET 32 bites és IA64-verzióiban.

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 és NaN

Egy összetett szám valós és képzeletbeli részeit értékek jelölik Double . A komplex szám valós vagy képzeletbeli része a Double.MinValue és Double.MaxValue közötti skálára terjedhet, valamint lehet Double.PositiveInfinity, Double.NegativeInfinity vagy Double.NaN értéke is. Double.PositiveInfinity, Double.NegativeInfinity, és Double.NaN mind propagálódnak bármely aritmetikai vagy trigonometriai művelet során.

Az alábbi példában a osztás egy Zero összetett számot eredményez, amelynek valós és képzeletbeli részei egyaránt Double.NaN. Ennek eredményeképpen a szorzás ezzel az értékkel olyan összetett számot is eredményez, amelynek valós és képzeletbeli részei .Double.NaN Hasonlóképpen, a típus tartományát Double túlcsordító szorzás olyan összetett számot hoz létre, amelynek valós része Double.NaN és képzetes része .Double.PositiveInfinity Ezt követően az osztás ezzel az összetett számmal egy összetett számot ad vissza, amelynek a valós része Double.NaN és képzetes része .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)

Az érvénytelen vagy az adattípus tartományát Double túlcsorduló összetett számokat tartalmazó matematikai műveletek nem jelentenek kivételt. Ehelyett Double.PositiveInfinity, Double.NegativeInfinity, vagy Double.NaN-t adnak vissza az alábbi feltételek mellett:

• A pozitív szám nullával való osztása Double.PositiveInfinityeredménye.
• Bármilyen művelet, amely túlcsordul az Double adattípus felső határán, Double.PositiveInfinity-t ad vissza.
• A negatív szám nullával való osztása Double.NegativeInfinityeredménye.
• Minden olyan művelet, amely túlcsordul az adattípus alsó határán, visszaadja a Double-t.
• A nulla nullával való osztása Double.NaN ad eredményt.
• Minden olyan művelet, amelyet operandusokon hajtanak végre, amelyek értékei Double.PositiveInfinity, Double.NegativeInfinity, vagy Double.NaN, az adott művelettől függően Double.PositiveInfinity, Double.NegativeInfinity vagy Double.NaN értéket adnak vissza.

Vegye figyelembe, hogy ez a módszer által végrehajtott köztes számításokra vonatkozik. Például a new Complex(9e308, 9e308) and new Complex(2.5, 3.5) szorzáshoz a (ac - bd) + (ad + bc)i képletet használják. A szorzásból származó valós összetevő kiszámítása kiértékeli a 9e308 2.5 – 9e308 3.5 kifejezést. Ebben a kifejezésben minden köztes szorzás Double.PositiveInfinity-t ad vissza, és a Double.PositiveInfinity-ból való Double.PositiveInfinity-ból való kivonás megkísérlése Double.NaN-t ad vissza.

Összetett szám formázása

Alapértelmezés szerint egy összetett szám sztring-ábrázolása <valós;képzetes> formát ölt, ahol a valós és a képzetes az összetett szám valós és képzetes összetevőit alkotó értékek sztring-ábrázolása. A metódus egyes túlterhelései ToString lehetővé teszik ezen Double értékek sztring-ábrázolásának testreszabását, hogy tükrözzék egy adott kultúra formázási konvencióit, vagy hogy egy szabványos vagy egyéni numerikus formátumú sztring által meghatározott formátumban jelenjenek meg. (További információ: Standard numerikus formázási sztringek és Egyéni numerikus formázási sztringek.)

A komplex szám sztring ábrázolásának egyik leggyakoribb módja a + bi formában jelenik meg, ahol a a komplex szám valós komponenense, és b a komplex szám képzeletbeli komponenense. A villamosmérnökségben a komplex számot leggyakrabban a következőképpen fejezik ki a + bj: . A két formátum bármelyikében visszaadhatja egy összetett szám szöveges ábrázolását. Ehhez definiáljon egy egyéni formátumszolgáltatót a ICustomFormatter és IFormatProvider felületek implementálásával, majd hívja meg a String.Format(IFormatProvider, String, Object[]) metódust.

Az alábbi példa meghatároz egy ComplexFormatter osztályt, amely egy összetett számot sztringként ábrázol, akár a + bi vagy a + bj formában.

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

Az alábbi példa ezt az egyedi formázót használja egy komplex szám karakterláncának megjelenítéséhez.

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

Konstruktorok

Name	Description
Complex(Double, Double)	Inicializálja a Complex struktúra új példányát a megadott valós és képzeletbeli értékekkel.

Mezők

Name	Description
ImaginaryOne	Egy új Complex példányt ad vissza nullával egyenlő valós számmal és egy képzeletbeli számmal.
Infinity	A végtelent komplex számként jelöli.
NaN	Olyan összetett példányt jelöl, amely nem szám (NaN).
One	Egy új Complex példányt ad vissza, amelynek valós száma egy, a képzeletbeli szám pedig nulla.
Zero	Egy új Complex példányt ad vissza nullával egyenlő valós számmal és egy nulla értékű képzeletbeli számmal.

Tulajdonságok

Name	Description
Imaginary	Lekéri az aktuális Complex objektum képzeletbeli összetevőjét.
Magnitude	Egy összetett szám nagyságát (vagy abszolút értékét) adja meg.
Phase	Egy összetett szám fázisát kapja meg.
Real	Lekéri az aktuális Complex objektum valódi összetevőjét.

Metódusok

Name	Description
Abs(Complex)	Egy összetett szám abszolút értékét (vagy nagyságát) adja meg.
Acos(Complex)	Azt a szöget adja vissza, amely a megadott komplex szám arkusz koszinusza.
Add(Complex, Complex)	Két összetett számot ad hozzá, és visszaadja az eredményt.
Add(Complex, Double)	Komplex számot ad hozzá egy dupla pontosságú valós számhoz, és visszaadja az eredményt.
Add(Double, Complex)	Dupla pontosságú valós számot ad hozzá egy összetett számhoz, és visszaadja az eredményt.
Asin(Complex)	A megadott komplex szám arc szinuszának szögét adja vissza.
Atan(Complex)	Azt a szöget adja vissza, amely a megadott komplex szám ív-tangense.
Conjugate(Complex)	Kiszámítja egy összetett szám konjugálását, és visszaadja az eredményt.
Cos(Complex)	A megadott komplex szám koszinuszát adja vissza.
Cosh(Complex)	A megadott komplex szám hiperbolikus koszinuszát adja vissza.
CreateChecked<TOther>(TOther)	Létrehozza az aktuális típus egy példányát egy értékből, amely túlcsordulási kivételt eredményez az aktuális típus ábrázolható tartományán kívül eső értékek esetében.
CreateSaturating<TOther>(TOther)	Egy értékből hozza létre az aktuális típus egy példányát, amely az aktuális típus reprezentáló tartományán kívül eső értékeket telít át.
CreateTruncating<TOther>(TOther)	Az aktuális típus egy példányát hozza létre egy értékből, és csonkolja az aktuális típus ábrázolható tartományán kívül eső értékeket.
Divide(Complex, Complex)	Egy összetett számot eloszt egy másikkal, és visszaadja az eredményt.
Divide(Complex, Double)	Egy összetett számot két pontosságú valós számmal oszt el, és visszaadja az eredményt.
Divide(Double, Complex)	Egy dupla pontosságú valós számot oszt el egy összetett számmal, és visszaadja az eredményt.
Equals(Complex)	Olyan értéket ad vissza, amely jelzi, hogy az aktuális példány és egy megadott összetett szám azonos értékkel rendelkezik-e.
Equals(Object)	Olyan értéket ad vissza, amely jelzi, hogy az aktuális példány és egy adott objektum azonos értékkel rendelkezik-e.
Exp(Complex)	e Komplex szám által megadott teljesítményre emelt értéket ad vissza.
FromPolarCoordinates(Double, Double)	Komplex számot hoz létre egy pont polárkoordinátáiból.
GetHashCode()	Az aktuális Complex objektum kivonatkódját adja vissza.
IsComplexNumber(Complex)	Meghatározza, hogy egy érték összetett értéket jelöl-e.
IsEvenInteger(Complex)	Meghatározza, hogy egy érték páros integrál számot jelöl-e.
IsFinite(Complex)	Meghatározza, hogy a megadott komplex szám véges-e.
IsImaginaryNumber(Complex)	Meghatározza, hogy egy érték egy képzeletbeli számot jelöl-e.
IsInfinity(Complex)	Egy értéket ad vissza, amely azt jelzi, hogy a megadott komplex szám a végtelenre értékel-e.
IsInteger(Complex)	Meghatározza, hogy egy érték egy integrál értéket jelöl-e.
IsNaN(Complex)	Olyan értéket ad vissza, amely azt jelzi, hogy a megadott összetett példány nem szám-e (NaN).
IsNegative(Complex)	Meghatározza, hogy egy érték negatív-e.
IsNegativeInfinity(Complex)	Meghatározza, hogy egy érték negatív végtelen-e.
IsNormal(Complex)	Meghatározza, hogy egy érték normális-e.
IsOddInteger(Complex)	Meghatározza, hogy egy érték páratlan integrál számot jelöl-e.
IsPositive(Complex)	Meghatározza, hogy egy érték pozitív-e.
IsPositiveInfinity(Complex)	Meghatározza, hogy egy érték pozitív végtelen-e.
IsRealNumber(Complex)	Meghatározza, hogy egy érték valós számot jelöl-e.
IsSubnormal(Complex)	Meghatározza, hogy egy érték szubnormális-e.
Log(Complex, Double)	Egy megadott összetett szám logaritmusát adja vissza egy megadott alapban.
Log(Complex)	Egy megadott komplex szám természetes (alap e) logaritmusát adja vissza.
Log10(Complex)	Egy megadott komplex szám 10-es alapú logaritmusát adja vissza.
MaxMagnitude(Complex, Complex)	Két értéket hasonlít össze a nagyobb számítási értékekkel.
MinMagnitude(Complex, Complex)	Két értéket hasonlít össze a kisebb számítási értékkel.
Multiply(Complex, Complex)	Két összetett szám szorzatát adja vissza.
Multiply(Complex, Double)	Egy összetett szám és egy dupla pontosságú valós szám szorzatát adja vissza.
Multiply(Double, Complex)	Egy dupla pontosságú valós szám és egy összetett szám szorzatát adja vissza.
Negate(Complex)	Egy megadott komplex szám additív inverzét adja vissza.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Több karakterből álló elemet elemez egy értékben.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Több karakterből álló elemet elemez egy értékben.
Parse(String, IFormatProvider)	Egy sztringet egy értékbe elemez.
Parse(String, NumberStyles, IFormatProvider)	Egy sztringet egy értékbe elemez.
Pow(Complex, Complex)	Egy összetett szám által megadott teljesítményre emelt megadott komplex számot ad vissza.
Pow(Complex, Double)	Egy dupla pontosságú lebegőpontos szám által megadott teljesítményre emelt megadott komplex számot ad vissza.
Reciprocal(Complex)	Egy összetett szám szorzós inverzét adja vissza.
Sin(Complex)	A megadott komplex szám szinuszát adja vissza.
Sinh(Complex)	A megadott komplex szám szinusz hiperbolikuszát adja vissza.
Sqrt(Complex)	Egy megadott komplex szám négyzetgyökét adja vissza.
Subtract(Complex, Complex)	Kivon egy összetett számot a másikból, és visszaadja az eredményt.
Subtract(Complex, Double)	Kivon egy dupla pontosságú valós számot egy összetett számból, és visszaadja az eredményt.
Subtract(Double, Complex)	Kivon egy komplex számot egy dupla pontosságú valós számból, és visszaadja az eredményt.
Tan(Complex)	A megadott komplex szám tangensét adja vissza.
Tanh(Complex)	A megadott komplex szám hiperbolikus tangensét adja vissza.
ToString()	Az aktuális komplex szám értékét átalakítja annak megfelelő sztring-ábrázolására Cartesian formában.
ToString(IFormatProvider)	Az aktuális komplex szám értékét a megadott kultúraspecifikus formázási információk használatával átalakítja annak megfelelő sztring-ábrázolására Cartesian formában.
ToString(String, IFormatProvider)	Az aktuális komplex szám értékét a megadott formátum- és kultúraspecifikus formátuminformációk használatával, valós és képzeletbeli részeinek megfelelő sztring-ábrázolásává alakítja.
ToString(String)	Az aktuális komplex szám értékét a valós és a képzeletbeli részek megadott formátumának használatával a megfelelő sztringre konvertálja Cartesian formában.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Az aktuális példány értékét UTF-8 formátumban próbálja formázni a megadott bájttartományba.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Megpróbálja formázni az aktuális példány értékét a megadott karaktertartományba.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)	Egy karaktertartományt próbál elemezni egy értékben.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)	Egy karaktertartományt próbál elemezni egy értékben.
TryParse(String, IFormatProvider, Complex)	Megpróbál egy sztringet egy értékbe elemezni.
TryParse(String, NumberStyles, IFormatProvider, Complex)	Megpróbál egy sztringet egy értékbe elemezni.

Operátorok

Name	Description
Addition(Complex, Complex)	Két összetett számot ad hozzá.
Addition(Complex, Double)	Komplex számot ad hozzá egy dupla pontosságú valós számhoz.
Addition(Double, Complex)	Dupla pontosságú valós számot ad hozzá egy összetett számhoz.
Decrement(Complex)	Érték decresítése.
Division(Complex, Complex)	Egy megadott komplex számot egy másik megadott komplex számmal osztja el.
Division(Complex, Double)	Egy megadott komplex számot egy megadott dupla pontosságú valós számmal osztja el.
Division(Double, Complex)	Egy megadott dupla pontosságú valós számot egy megadott komplex számmal osztja el.
Equality(Complex, Complex)	Olyan értéket ad vissza, amely jelzi, hogy két komplex szám egyenlő-e.
Explicit(BigInteger to Complex)	Egy érték explicit konvertálását BigInteger határozza meg összetett számra.
Explicit(Decimal to Complex)	Egy érték explicit konvertálását Decimal határozza meg összetett számra.
Explicit(Int128 to Complex)	Explicit módon konvertál egy Int128 értéket dupla pontosságú összetett számmá.
Explicit(UInt128 to Complex)	Explicit módon konvertál egy UInt128 értéket dupla pontosságú összetett számmá.
Implicit(Byte to Complex)	Az aláíratlan bájtok összetett számra történő implicit konvertálását határozza meg.
Implicit(Char to Complex)	Implicit módon kettős pontosságú komplex számmá konvertálja Char az értéket.
Implicit(Double to Complex)	A kettős pontosságú lebegőpontos szám implicit konvertálását határozza meg összetett számként.
Implicit(Half to Complex)	Implicit módon kettős pontosságú komplex számmá konvertálja Half az értéket.
Implicit(Int16 to Complex)	Egy 16 bites aláírt egész szám implicit konvertálását határozza meg összetett számmá.
Implicit(Int32 to Complex)	Egy 32 bites aláírt egész szám implicit konvertálását határozza meg összetett számmá.
Implicit(Int64 to Complex)	Egy 64 bites aláírt egész szám implicit konvertálását határozza meg összetett számmá.
Implicit(IntPtr to Complex)	Implicit módon kettős pontosságú komplex számmá konvertálja IntPtr az értéket.
Implicit(SByte to Complex)	Az aláírt bájtok összetett számra történő implicit konvertálását határozza meg. Ez az API nem CLS-kompatibilis.
Implicit(Single to Complex)	Egy egy pontosságú lebegőpontos szám implicit konvertálását definiálja összetett számra.
Implicit(UInt16 to Complex)	Egy 16 bites aláíratlan egész szám implicit konvertálását határozza meg összetett számmá. Ez az API nem CLS-kompatibilis.
Implicit(UInt32 to Complex)	Egy 32 bites aláíratlan egész szám implicit konvertálását határozza meg összetett számmá. Ez az API nem CLS-kompatibilis.
Implicit(UInt64 to Complex)	Egy 64 bites aláíratlan egész szám implicit konvertálását határozza meg összetett számmá. Ez az API nem CLS-kompatibilis.
Implicit(UIntPtr to Complex)	Implicit módon kettős pontosságú komplex számmá konvertálja UIntPtr az értéket.
Increment(Complex)	Növekményes érték.
Inequality(Complex, Complex)	Olyan értéket ad vissza, amely jelzi, hogy két összetett szám nem egyenlő-e.
Multiply(Complex, Complex)	Két megadott komplex szám szorzata.
Multiply(Complex, Double)	Megszorozza a megadott komplex számot egy megadott dupla pontosságú valós számmal.
Multiply(Double, Complex)	Megszorozza a megadott dupla pontosságú valós számot egy megadott komplex számmal.
Subtraction(Complex, Complex)	Egy összetett szám kivonása egy másik komplex számból.
Subtraction(Complex, Double)	Dupla pontosságú valós számot von ki egy összetett számból.
Subtraction(Double, Complex)	Komplex szám kivonása dupla pontosságú valós számból.
UnaryNegation(Complex)	Egy megadott komplex szám additív inverzét adja vissza.
UnaryPlus(Complex)	Kiszámítja egy érték unáris pluszát.

Explicit interfész-implementációk

Name	Description
IAdditiveIdentity<Complex,Complex>.AdditiveIdentity	Lekéri az aktuális típus additív identitását.
IMultiplicativeIdentity<Complex,Complex>.MultiplicativeIdentity	Lekéri az aktuális típus többszörös identitását.
INumberBase<Complex>.Abs(Complex)	Kiszámítja egy érték abszolút értékét.
INumberBase<Complex>.IsCanonical(Complex)	Meghatározza, hogy egy érték a vesszővel ábrázolt érték-e.
INumberBase<Complex>.IsZero(Complex)	Meghatározza, hogy egy érték nulla-e.
INumberBase<Complex>.MaxMagnitudeNumber(Complex, Complex)	Két értéket hasonlít össze a számítással, amelynek nagyobb a nagysága, és a másik értéket adja vissza, ha egy bemenet .NaN
INumberBase<Complex>.MinMagnitudeNumber(Complex, Complex)	Két értéket hasonlít össze a számítással, amelynek kisebb a nagysága, és a másik értéket adja vissza, ha egy bemenet .NaN
INumberBase<Complex>.MultiplyAddEstimate(Complex, Complex, Complex)	Kiszámítja a (left * right) + addendbecslést.
INumberBase<Complex>.One	Lekéri a típus értékét 1 .
INumberBase<Complex>.Radix	Lekéri a típus radixát vagy bázist.
INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther, Complex)	Komplex számot jelöl.
INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther, Complex)	Komplex számot jelöl.
INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther, Complex)	Komplex számot jelöl.
INumberBase<Complex>.TryConvertToChecked<TOther>(Complex, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és túlcsordulási kivételt okoz az aktuális típus ábrázolható tartományán kívül eső értékek esetében.
INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és az aktuális típus reprezentáló tartományán kívül eső értékeket telít.
INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex, TOther)	Megpróbálja átalakítani az aktuális típus egy példányát egy másik típusra, és csonkolja az aktuális típus ábrázolható tartományán kívül eső értékeket.
INumberBase<Complex>.Zero	Lekéri a típus értékét 0 .
ISignedNumber<Complex>.NegativeOne	Lekéri a típus értékét -1 .