Complex Struktura

Definice

Obor názvů:

System.Numerics

Sestavení:

netstandard.dll, System.Runtime.Numerics.dll

Zdroj:

Complex.cs

Představuje komplexní číslo.

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)

Dědičnost

Object

ValueType

Complex

Implementuje

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>

Poznámky

Komplexní číslo je číslo, které zahrnuje reálnou číselnou část a imaginární číselnou část. Komplexní číslo z je obvykle zapsáno ve formě z = x + yi, kde x a y jsou reálná čísla, a i je imaginární jednotka, která má vlastnost i² = -1. Reálnou část komplexního čísla představuje x a imaginární část komplexního čísla je reprezentována y.

Typ Complex používá kartézský souřadnicový systém (skutečný, imaginární) při vytváření instancí a manipulaci se složitými čísly. Komplexní číslo může být reprezentováno jako bod v dvojrozměrném souřadnicovém systému, který se označuje jako komplexní rovina. Skutečná část komplexního čísla je umístěná na ose x (vodorovná osa) a imaginární část je umístěná na ose y (svislá osa).

Libovolný bod v komplexní rovině lze také vyjádřit na základě své absolutní hodnoty pomocí polárního souřadnicového systému. V polárních souřadnicích je bod charakterizován dvěma čísly:

• Jeho velikost, což je vzdálenost bodu od počátku (to znamená 0,0 nebo bod, ve kterém se protíná osa x a osa y).
• Jeho fáze, což je úhel mezi skutečnou osou a přímkou nakreslenou z počátku do bodu.

Vytvoření instance komplexního čísla

Hodnotu ke komplexnímu číslu můžete přiřadit jedním z následujících způsobů:

• Předáním dvou Double hodnot do konstruktoru První hodnota představuje skutečnou část komplexního čísla a druhá hodnota představuje její imaginární část. Tyto hodnoty představují pozici komplexního čísla v dvojrozměrném kartézském souřadnicovém systému.

• Voláním statické metody (Shared v jazyce Visual Basic) Complex.FromPolarCoordinates vytvoříte komplexní číslo z jeho polárních souřadnic.

• Přiřazením hodnoty Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single nebo Double k objektu Complex. Hodnota se stane skutečnou částí komplexního čísla a její imaginární část se rovná 0.

• Přetypováním (v jazyce C#) nebo převodem (v jazyce Visual Basic) hodnoty Decimal nebo BigInteger na objekt Complex. Hodnota se stane skutečnou částí komplexního čísla a její imaginární část se rovná 0.

• Přiřazením komplexního čísla vráceného metodou nebo operátorem k objektu Complex . Je to například Complex.Add statická metoda, která vrátí komplexní číslo, které je součtem dvou komplexních čísel, a Complex.Addition operátor sčítá dvě komplexní čísla a vrátí výsledek.

Následující příklad ukazuje každý z těchto pěti způsobů přiřazení hodnoty ke komplexnímu číslu.

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)

Operace se složitými čísly

Struktura Complex v .NET zahrnuje členy, které poskytují následující funkce:

• Metody porovnání dvou komplexních čísel k určení, zda jsou rovny.
• Operátory pro provádění aritmetických operací s komplexními čísly Complex Operátory umožňují provádět sčítání, odčítání, násobení, dělení a unární negaci se složitými čísly.
• Metody pro provádění dalších numerických operací se složitými čísly Kromě čtyř základních aritmetických operací můžete zvýšit komplexní číslo na zadanou mocninu, najít druhou odmocninu komplexního čísla a získat absolutní hodnotu komplexního čísla.
• Metody provádění trigonometrických operací se složitými čísly Můžete například vypočítat tangens úhlu reprezentované komplexním číslem.

Všimněte si, že vlastnosti Real a Imaginary jsou určeny pouze pro čtení, takže není možné upravit hodnotu existujícího objektu Complex. Všechny metody, které provádějí operaci s číslem Complex , pokud je jejich návratová hodnota typu Complex, vrátí nové Complex číslo.

Přesnost a komplexní čísla

Skutečné a imaginární části komplexního čísla jsou reprezentovány dvěma hodnotami s plovoucí desetinnou čárkou s dvojitou přesností. To znamená, že Complex hodnoty, jako jsou dvojitě přesné hodnoty s plovoucí desetinnou čárkou, mohou v důsledku číselných operací ztratit přesnost. To znamená, že přísné porovnání rovnosti dvou Complex hodnot může selhat, i když je rozdíl mezi těmito dvěma hodnotami způsobený ztrátou přesnosti. Další informace najdete na webu Double.

Například při exponentaci logaritmu čísla by se mělo vrátit původní číslo. V některých případech však může ztráta přesnosti čísla s plovoucí desetinnou čárkou způsobit mírné rozdíly mezi těmito dvěma hodnotami, jak ukazuje následující příklad.

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

Podobně následující příklad, který vypočítá druhou odmocninu Complex čísla, produkuje mírně odlišné výsledky na 32bitové a IA64 verze .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.

Nekonečno a NaN

Skutečné a imaginární části komplexního čísla jsou reprezentovány Double hodnotami. Kromě rozsahu od Double.MinValue do Double.MaxValue, reálná nebo imaginární část komplexního čísla může mít hodnotu Double.PositiveInfinity, Double.NegativeInfinitynebo Double.NaN. Double.PositiveInfinity, Double.NegativeInfinity a Double.NaN se všechny šíří v jakékoli aritmetické nebo trigonometrické operaci.

V následujícím příkladu dělení Zero vytvoří komplexní číslo, jehož reálná a imaginární část jsou obě Double.NaN. Výsledkem je, že provádění násobení s touto hodnotou také vytvoří komplexní číslo, jehož skutečné a imaginární části jsou Double.NaN. Podobně, pokud násobení přeteče do rozsahu typu Double, vytvoří se komplexní číslo, jehož reálná část je Double.NaN a imaginární část je Double.PositiveInfinity. Následné dělení s tímto komplexním číslem vrátí komplexní číslo, jehož reálnou částí je Double.NaN a jehož imaginární částí je 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)

Matematické operace se složitými čísly, které jsou neplatné nebo které přetékají oblast datového Double typu, nevyvolají výjimku. Místo toho vrátí Double.PositiveInfinity, Double.NegativeInfinity nebo Double.NaN za následujících podmínek:

• Dělení kladného čísla nulou vrátí Double.PositiveInfinity.
• Jakákoli operace, která přeteče horní mez datového Double typu, vrátí Double.PositiveInfinity.
• Dělení záporného čísla nulou vrátí Double.NegativeInfinity.
• Jakákoli operace, která přeteče dolní mez datového Double typu, vrátí Double.NegativeInfinity.
• Dělení nuly o nulu vrátí Double.NaN.
• Jakákoli operace prováděná na operandech, jejichž hodnoty jsou Double.PositiveInfinity, Double.NegativeInfinitynebo Double.NaN vrací Double.PositiveInfinity, Double.NegativeInfinitynebo Double.NaNv závislosti na konkrétní operaci.

Všimněte si, že to platí pro všechny přechodné výpočty prováděné metodou. Například násobení new Complex(9e308, 9e308) and new Complex(2.5, 3.5) používá vzorec (ac - bd) + (ad + bc)i. Výpočet skutečné komponenty, která je výsledkem násobení, vyhodnotí výraz 9e308 2,5 - 9e308 3,5. Každé mezivýpočtové násobení v tomto výrazu vrátí Double.PositiveInfinity, a pokus o odečtení Double.PositiveInfinity od Double.PositiveInfinity vrátí Double.NaN.

Formátování komplexního čísla

Ve výchozím nastavení má řetězcová reprezentace komplexního čísla tvar <skutečného;, kde > a imaginární jsou řetězcové reprezentace hodnot, které tvoří reálné a imaginární komponenty komplexního čísla. Některá přetížení ToString metody umožňují přizpůsobení řetězcových reprezentací těchto Double hodnot tak, aby odrážely konvence formátování konkrétní jazykové verze nebo se zobrazovaly v určitém formátu definovaném standardním nebo vlastním řetězcem číselného formátu. (Další informace najdete v tématu Standardní řetězce číselného formátu a vlastní řetězce číselného formátu.)

Jeden z nejběžnějších způsobů vyjádření řetězcové reprezentace komplexního čísla má podobu a + bi, kde a je reálná komponenta komplexního čísla a b je imaginární komponenta komplexního čísla. V elektrotechnikě je komplexní číslo nejčastěji vyjádřeno jako a + bj. Řetězcové vyjádření komplexního čísla můžete vrátit v některé z těchto dvou forem. Chcete-li to provést, definujte vlastního zprostředkovatele formátu implementací ICustomFormatter a IFormatProvider rozhraní a pak zavolejte metodu String.Format(IFormatProvider, String, Object[]) .

Následující příklad definuje ComplexFormatter třídu, která představuje komplexní číslo jako řetězec ve formě buď a + bi nebo a + bj.

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

Následující příklad pak použije tento vlastní formátovací modul k zobrazení řetězcové reprezentace komplexního čísla.

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

Konstruktory

Name	Description
Complex(Double, Double)	Inicializuje novou instanci Complex struktury pomocí zadaných skutečných a imaginárních hodnot.

Pole

Name	Description
ImaginaryOne	Vrátí novou Complex instanci se skutečným číslem rovnou nule a imaginárním číslem, které se rovná jedné.
Infinity	Představuje nekonečno jako komplexní číslo.
NaN	Představuje komplexní instanci, která není číslo (NaN).
One	Vrátí novou Complex instanci se skutečným číslem, které se rovná jednomu a imaginárnímu číslu rovnou nule.
Zero	Vrátí novou Complex instanci se skutečným číslem rovnou nule a imaginárním číslem, které se rovná nule.

Vlastnosti

Name	Description
Imaginary	Získá imaginární komponentu aktuálního Complex objektu.
Magnitude	Získá velikost (nebo absolutní hodnotu) komplexního čísla.
Phase	Získá fázi komplexního čísla.
Real	Získá skutečnou komponentu aktuálního Complex objektu.

Metody

Name	Description
Abs(Complex)	Získá absolutní hodnotu (nebo velikost) komplexního čísla.
Acos(Complex)	Vrátí úhel, který je kosinus oblouku zadaného komplexního čísla.
Add(Complex, Complex)	Sečte dvě komplexní čísla a vrátí výsledek.
Add(Complex, Double)	Přidá komplexní číslo do reálného čísla s dvojitou přesností a vrátí výsledek.
Add(Double, Complex)	Přidá k komplexnímu číslu dvojité přesnosti reálné číslo a vrátí výsledek.
Asin(Complex)	Vrátí úhel, který je arkus sinus zadaného komplexního čísla.
Atan(Complex)	Vrátí úhel, který je arkus tangens zadaného komplexního čísla.
Conjugate(Complex)	Vypočítá konjugování komplexního čísla a vrátí výsledek.
Cos(Complex)	Vrátí kosinus zadaného komplexního čísla.
Cosh(Complex)	Vrátí hyperbolický kosinus zadaného komplexního čísla.
CreateChecked<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty, která vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
CreateSaturating<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty, která saturuje všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
CreateTruncating<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
Divide(Complex, Complex)	Vydělí jedno komplexní číslo jiným číslem a vrátí výsledek.
Divide(Complex, Double)	Vydělí jedno komplexní číslo dvojitou přesností reálné číslo a vrátí výsledek.
Divide(Double, Complex)	Vydělí jedno reálné číslo s dvojitou přesností komplexním číslem a vrátí výsledek.
Equals(Complex)	Vrátí hodnotu, která určuje, zda aktuální instance a zadané komplexní číslo mají stejnou hodnotu.
Equals(Object)	Vrátí hodnotu, která určuje, zda aktuální instance a zadaný objekt mají stejnou hodnotu.
Exp(Complex)	Vrátí e umocněné na mocninu určenou komplexním číslem.
FromPolarCoordinates(Double, Double)	Vytvoří komplexní číslo z polárních souřadnic bodu.
GetHashCode()	Vrátí kód hash pro aktuální Complex objekt.
IsComplexNumber(Complex)	Určuje, zda hodnota představuje komplexní hodnotu.
IsEvenInteger(Complex)	Určuje, zda hodnota představuje sudé celočíselné číslo.
IsFinite(Complex)	Určuje, zda je zadané komplexní číslo konečné.
IsImaginaryNumber(Complex)	Určuje, zda hodnota představuje imaginární číslo.
IsInfinity(Complex)	Vrátí hodnotu určující, zda se zadané komplexní číslo vyhodnotí na nekonečno.
IsInteger(Complex)	Určuje, zda hodnota představuje celočíselnou hodnotu.
IsNaN(Complex)	Vrátí hodnotu, která určuje, jestli zadaná komplexní instance není číslo (NaN).
IsNegative(Complex)	Určuje, zda je hodnota záporná.
IsNegativeInfinity(Complex)	Určuje, zda je hodnota záporná nekonečno.
IsNormal(Complex)	Určuje, zda je hodnota normální.
IsOddInteger(Complex)	Určuje, zda hodnota představuje liché celočíselné číslo.
IsPositive(Complex)	Určuje, jestli je hodnota kladná.
IsPositiveInfinity(Complex)	Určuje, jestli je hodnota kladná nekonečno.
IsRealNumber(Complex)	Určuje, zda hodnota představuje reálné číslo.
IsSubnormal(Complex)	Určuje, jestli je hodnota podnormální.
Log(Complex, Double)	Vrátí logaritmus zadaného komplexního čísla v zadaném základu.
Log(Complex)	Vrátí přirozený (základní e) logaritmus zadaného komplexního čísla.
Log10(Complex)	Vrátí logaritmus zadaného komplexního čísla o základu 10.
MaxMagnitude(Complex, Complex)	Porovná dvě hodnoty s výpočty, které jsou větší.
MinMagnitude(Complex, Complex)	Porovná dvě hodnoty s výpočetními prostředky, které jsou menší.
Multiply(Complex, Complex)	Vrátí součin dvou komplexních čísel.
Multiply(Complex, Double)	Vrátí součin komplexního čísla a reálné číslo s dvojitou přesností.
Multiply(Double, Complex)	Vrátí součin reálného čísla s dvojitou přesností a komplexního čísla.
Negate(Complex)	Vrátí inverzní funkci k zadanému komplexnímu číslu.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
Parse(String, IFormatProvider)	Parsuje řetězec do hodnoty.
Parse(String, NumberStyles, IFormatProvider)	Parsuje řetězec do hodnoty.
Pow(Complex, Complex)	Vrátí zadané komplexní číslo umocněné na mocninu určenou komplexním číslem.
Pow(Complex, Double)	Vrátí zadané komplexní číslo umocněné na mocninu určenou dvojitou přesností s plovoucí desetinnou čárkou.
Reciprocal(Complex)	Vrátí multiplikativní inverzní funkci komplexního čísla.
Sin(Complex)	Vrátí sinus zadaného komplexního čísla.
Sinh(Complex)	Vrátí hyperbolický sinus zadaného komplexního čísla.
Sqrt(Complex)	Vrátí druhou odmocninu zadaného komplexního čísla.
Subtract(Complex, Complex)	Odečte jedno komplexní číslo od druhého a vrátí výsledek.
Subtract(Complex, Double)	Odečte jedno reálné číslo s dvojitou přesností od komplexního čísla a vrátí výsledek.
Subtract(Double, Complex)	Odečte jedno komplexní číslo od reálného čísla s dvojitou přesností a vrátí výsledek.
Tan(Complex)	Vrátí tangens zadaného komplexního čísla.
Tanh(Complex)	Vrátí hyperbolický tangens zadaného komplexního čísla.
ToString()	Převede hodnotu aktuálního komplexního čísla na ekvivalentní řetězcové vyjádření v kartézské podobě.
ToString(IFormatProvider)	Převede hodnotu aktuálního komplexního čísla na ekvivalentní řetězcové vyjádření v kartézské podobě pomocí zadaných informací o formátování specifické pro jazykovou verzi.
ToString(String, IFormatProvider)	Převede hodnotu aktuálního komplexního čísla na ekvivalentní řetězcové vyjádření v kartézské podobě pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi pro své skutečné a imaginární části.
ToString(String)	Převede hodnotu aktuálního komplexního čísla na ekvivalentní řetězcové vyjádření v kartézské podobě pomocí zadaného formátu pro jeho skutečné a imaginární části.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance jako UTF-8 do poskytnutého rozsahu bajtů.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance do zadaného rozsahu znaků.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)	Pokusí se analyzovat rozsah znaků do hodnoty.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)	Pokusí se analyzovat rozsah znaků do hodnoty.
TryParse(String, IFormatProvider, Complex)	Pokusí se analyzovat řetězec do hodnoty.
TryParse(String, NumberStyles, IFormatProvider, Complex)	Pokusí se analyzovat řetězec do hodnoty.

Operátory

Name	Description
Addition(Complex, Complex)	Sečte dvě komplexní čísla.
Addition(Complex, Double)	Přidá komplexní číslo do reálného čísla s dvojitou přesností.
Addition(Double, Complex)	Přidá ke komplexnímu číslu dvojité přesnosti reálné číslo.
Decrement(Complex)	Dekrementuje hodnotu.
Division(Complex, Complex)	Vydělí zadané komplexní číslo jiným zadaným komplexním číslem.
Division(Complex, Double)	Vydělí zadané komplexní číslo zadaným skutečným číslem s dvojitou přesností.
Division(Double, Complex)	Vydělí zadané reálné číslo s dvojitou přesností zadaným komplexním číslem.
Equality(Complex, Complex)	Vrátí hodnotu, která určuje, zda jsou dvě komplexní čísla rovna.
Explicit(BigInteger to Complex)	Definuje explicitní převod BigInteger hodnoty na komplexní číslo.
Explicit(Decimal to Complex)	Definuje explicitní převod Decimal hodnoty na komplexní číslo.
Explicit(Int128 to Complex)	Explicitně převede Int128 hodnotu na komplexní číslo s dvojitou přesností.
Explicit(UInt128 to Complex)	Explicitně převede UInt128 hodnotu na komplexní číslo s dvojitou přesností.
Implicit(Byte to Complex)	Definuje implicitní převod nepodepsaného bajtu na komplexní číslo.
Implicit(Char to Complex)	Implicitně převede Char hodnotu na komplexní číslo s dvojitou přesností.
Implicit(Double to Complex)	Definuje implicitní převod čísla s plovoucí desetinnou čárkou s dvojitou přesností na komplexní číslo.
Implicit(Half to Complex)	Implicitně převede Half hodnotu na komplexní číslo s dvojitou přesností.
Implicit(Int16 to Complex)	Definuje implicitní převod 16bitového signtegeru na komplexní číslo.
Implicit(Int32 to Complex)	Definuje implicitní převod 32bitového celého čísla se signedem na komplexní číslo.
Implicit(Int64 to Complex)	Definuje implicitní převod 64bitového celého čísla se signedem na komplexní číslo.
Implicit(IntPtr to Complex)	Implicitně převede IntPtr hodnotu na komplexní číslo s dvojitou přesností.
Implicit(SByte to Complex)	Definuje implicitní převod podepsaného bajtu na komplexní číslo. Toto rozhraní API neodpovídá specifikaci CLS.
Implicit(Single to Complex)	Definuje implicitní převod čísla s plovoucí desetinnou čárkou s jednoduchou přesností na komplexní číslo.
Implicit(UInt16 to Complex)	Definuje implicitní převod 16bitového celého čísla bez znaménka na komplexní číslo. Toto rozhraní API neodpovídá specifikaci CLS.
Implicit(UInt32 to Complex)	Definuje implicitní převod 32bitového celého čísla bez znaménka na komplexní číslo. Toto rozhraní API neodpovídá specifikaci CLS.
Implicit(UInt64 to Complex)	Definuje implicitní převod 64bitového celého čísla bez znaménka na komplexní číslo. Toto rozhraní API neodpovídá specifikaci CLS.
Implicit(UIntPtr to Complex)	Implicitně převede UIntPtr hodnotu na komplexní číslo s dvojitou přesností.
Increment(Complex)	Zvýší hodnotu.
Inequality(Complex, Complex)	Vrátí hodnotu, která určuje, jestli se dvě komplexní čísla nerovnají.
Multiply(Complex, Complex)	Vynásobí dvě zadaná komplexní čísla.
Multiply(Complex, Double)	Vynásobí zadané komplexní číslo zadaným skutečným číslem s dvojitou přesností.
Multiply(Double, Complex)	Vynásobí zadané reálné číslo s dvojitou přesností zadaným komplexním číslem.
Subtraction(Complex, Complex)	Odečte komplexní číslo od jiného komplexního čísla.
Subtraction(Complex, Double)	Odečte reálné číslo s dvojitou přesností od komplexního čísla.
Subtraction(Double, Complex)	Odečte komplexní číslo od reálného čísla s dvojitou přesností.
UnaryNegation(Complex)	Vrátí inverzní funkci k zadanému komplexnímu číslu.
UnaryPlus(Complex)	Vypočítá unární plus hodnoty.

Explicitní implementace rozhraní

Name	Description
IAdditiveIdentity<Complex,Complex>.AdditiveIdentity	Získá přídatnou identitu aktuálního typu.
IMultiplicativeIdentity<Complex,Complex>.MultiplicativeIdentity	Získá multiplikativní identitu aktuálního typu.
INumberBase<Complex>.Abs(Complex)	Vypočítá absolutní hodnotu.
INumberBase<Complex>.IsCanonical(Complex)	Určuje, zda je hodnota v kanonickém vyjádření.
INumberBase<Complex>.IsZero(Complex)	Určuje, jestli je hodnota nula.
INumberBase<Complex>.MaxMagnitudeNumber(Complex, Complex)	Porovná dvě hodnoty k výpočtu, které mají větší velikost a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Complex>.MinMagnitudeNumber(Complex, Complex)	Porovná dvě hodnoty k výpočtu, které mají menší velikost a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Complex>.MultiplyAddEstimate(Complex, Complex, Complex)	Vypočítá odhad (left * right) + . addend
INumberBase<Complex>.One	Získá hodnotu 1 pro typ.
INumberBase<Complex>.Radix	Získá radix (základ číselné soustavy) pro typ.
INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther, Complex)	Představuje komplexní číslo.
INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther, Complex)	Představuje komplexní číslo.
INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther, Complex)	Představuje komplexní číslo.
INumberBase<Complex>.TryConvertToChecked<TOther>(Complex, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a nasytí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<Complex>.Zero	Získá hodnotu 0 pro typ.
ISignedNumber<Complex>.NegativeOne	Získá hodnotu -1 pro typ.