System.Numerics.Complex szerkezet

Megjegyzés:

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

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

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
  • Last updated on