Struktur System.Numerics.Complex

Artikel ini menyediakan keterangan tambahan untuk dokumentasi referensi untuk API ini.

Bilangan kompleks adalah angka yang terdiri dari bagian bilangan riil dan bagian angka imajiner. Bilangan kompleks z biasanya ditulis dalam bentuk z = x + yi, di mana x dan y adalah angka riil, dan i adalah unit imajiner yang memiliki properti i² = -1. Bagian nyata dari bilangan kompleks diwakili oleh x, dan bagian imajiner dari bilangan kompleks diwakili oleh y.

Complex menggunakan sistem koordinat Kartesius (nyata, imajiner) saat menginstansiasi dan memanipulasi bilangan kompleks. Bilangan kompleks dapat direpresentasikan sebagai titik dalam sistem koordinat dua dimensi, yang dikenal sebagai bidang kompleks. Bagian nyata dari bilangan kompleks diposisikan pada sumbu x (sumbu horizontal), dan bagian imajiner diposisikan pada sumbu y (sumbu vertikal).

Setiap titik dalam bidang kompleks juga dapat diekspresikan berdasarkan nilai absolutnya, dengan menggunakan sistem koordinat kutub. Dalam koordinat kutub, titik ditandai dengan dua angka:

• Besarnya, yang merupakan jarak titik dari asal (yaitu, 0,0, atau titik di mana sumbu x dan sumbu y bersinggungan).
• Fasenya adalah sudut antara sumbu riil dan garis yang digambar dari titik asal ke titik tersebut.

Menginisialisasi bilangan kompleks

Anda bisa menetapkan nilai ke bilangan kompleks dengan salah satu cara berikut:

• Dengan meneruskan dua Double nilai ke konstruktornya. Nilai pertama mewakili bagian nyata dari bilangan kompleks, dan nilai kedua mewakili bagian imajinernya. Nilai-nilai ini mewakili posisi bilangan kompleks dalam sistem koordinat Kartesius dua dimensi.

• Dengan memanggil metode statis (Shared dalam Visual Basic) Complex.FromPolarCoordinates untuk membuat bilangan kompleks dari koordinat kutubnya.

• Dengan menetapkan nilai Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, atau Double ke objek Complex. Nilai menjadi bagian nyata dari bilangan kompleks, dan bagian imajinernya sama dengan 0.

• Dengan melakukan cast (dalam C#) atau mengonversi (dalam Visual Basic) nilai Decimal atau BigInteger menjadi objek Complex. Nilai menjadi bagian nyata dari bilangan kompleks, dan bagian imajinernya sama dengan 0.

• Dengan menetapkan bilangan kompleks yang dikembalikan oleh metode atau operator ke Complex objek. Misalnya, Complex.Add adalah metode statis yang mengembalikan bilangan kompleks yang merupakan jumlah dari dua bilangan kompleks, dan Complex.Addition operator menambahkan dua bilangan kompleks dan mengembalikan hasilnya.

Contoh berikut menunjukkan masing-masing dari lima cara menetapkan nilai ke bilangan kompleks.

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)

Operasi dengan bilangan kompleks

Struktur Complex dalam .NET mencakup anggota yang menyediakan fungsionalitas berikut:

• Metode untuk membandingkan dua angka kompleks untuk menentukan apakah angka tersebut sama.
• Operator untuk melakukan operasi aritmatika pada bilangan kompleks. Complex operator memungkinkan Anda melakukan penambahan, pengurangan, perkalian, pembagian, dan negasi unary dengan angka kompleks.
• Metode untuk melakukan operasi numerik lainnya pada bilangan kompleks. Selain empat operasi aritmatika dasar, Anda dapat menaikkan bilangan kompleks ke daya tertentu, menemukan akar kuadrat dari bilangan kompleks, dan mendapatkan nilai absolut dari bilangan kompleks.
• Metode untuk melakukan operasi trigonometri pada bilangan kompleks. Misalnya, Anda dapat menghitung tangen sudut yang diwakili oleh bilangan kompleks.

Perhatikan bahwa, karena Real dan Imaginary properti bersifat hanya baca, Anda tidak dapat mengubah nilai dari objek Complex yang sudah ada. Semua metode yang melakukan operasi pada Complex angka, jika nilai pengembaliannya berjenis Complex, mengembalikan angka baru Complex .

Angka presisi dan kompleks

Bagian nyata dan imajiner dari bilangan kompleks diwakili oleh dua nilai floating-point presisi ganda. Ini berarti bahwa nilai Complex, seperti nilai floating-point presisi ganda, dapat kehilangan presisi sebagai akibat dari operasi numerik. Ini berarti bahwa perbandingan langsung untuk kesamaan dua nilai Complex mungkin gagal, bahkan jika perbedaan antara kedua nilai disebabkan oleh hilangnya presisi. Untuk informasi selengkapnya, lihat Double .

Misalnya, melakukan eksponensiasi pada logaritma angka harus mengembalikan angka asli. Namun, dalam beberapa kasus, hilangnya presisi nilai floating-point dapat menyebabkan sedikit perbedaan antara dua nilai, seperti yang diilustrasikan contoh berikut.

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

Demikian pula, contoh berikut, yang menghitung akar kuadrat dari angka, menghasilkan hasil yang Complex sedikit berbeda pada versi .NET 32-bit dan IA64.

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

Bagian nyata dan imajiner dari bilangan kompleks diwakili oleh Double nilai. Selain berkisar dari Double.MinValue hingga Double.MaxValue, bagian nyata atau imajiner dari bilangan kompleks dapat memiliki nilai Double.PositiveInfinity, Double.NegativeInfinity, atau Double.NaN. Double.PositiveInfinity, Double.NegativeInfinity, dan Double.NaN semua menyebar dalam operasi aritmetika atau trigonometri apa pun.

Dalam contoh berikut, pembagian dengan Zero menghasilkan bilangan kompleks yang bagian nyata dan imajinernya adalah Double.NaN. Akibatnya, melakukan perkalian dengan nilai ini juga menghasilkan bilangan kompleks yang bagian nyata dan imajinernya adalah Double.NaN. Demikian pula, melakukan perkalian yang melewati rentang tipe Double menghasilkan bilangan kompleks yang bagian realnya adalah Double.NaN dan bagian imajinernya adalah Double.PositiveInfinity. Kemudian melakukan pembagian dengan bilangan kompleks ini mengembalikan bilangan kompleks yang bagian aslinya adalah Double.NaN dan yang bagian imajinernya adalah 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)

Operasi matematika dengan bilangan kompleks yang tidak valid atau yang melampaui rentang jenis data Double tidak menimbulkan pengecualian. Sebaliknya, mereka mengembalikan Double.PositiveInfinity, , Double.NegativeInfinityatau Double.NaN dalam kondisi berikut:

• Pembagian angka positif dengan nol mengembalikan Double.PositiveInfinity.
• Setiap operasi yang meluap ke batas atas Double jenis data mengembalikan Double.PositiveInfinity.
• Pembagian angka negatif dengan nol mengembalikan Double.NegativeInfinity.
• Setiap operasi yang melampaui batas bawah jenis data Double mengembalikan Double.NegativeInfinity.
• Pembagian nol dengan nol mengembalikan Double.NaN.
• Setiap operasi yang dilakukan pada operand yang nilainya adalah Double.PositiveInfinity, , Double.NegativeInfinityatau Double.NaN mengembalikan Double.PositiveInfinity, , Double.NegativeInfinityatau Double.NaN, tergantung pada operasi tertentu.

Perhatikan bahwa ini berlaku untuk perhitungan menengah apa pun yang dilakukan oleh metode . Misalnya, perkalian new Complex(9e308, 9e308) and new Complex(2.5, 3.5) menggunakan rumus (ac - bd) + (ad + bc)i. Perhitungan komponen nyata yang dihasilkan dari perkalian mengevaluasi ekspresi 9e308 2,5 - 9e308 3,5. Setiap perkalian menengah dalam ekspresi ini mengembalikan Double.PositiveInfinity, dan upaya untuk mengurangi Double.PositiveInfinity dari Double.PositiveInfinity mengembalikan Double.NaN.

Memformat bilangan kompleks

Secara default, representasi string dari bilangan kompleks mengambil bentuk <real;imajiner>, di mana real dan imajiner adalah representasi string dari Double nilai yang membentuk komponen real dan imajiner bilangan kompleks. Beberapa overload dari metode ToString memungkinkan penyesuaian representasi string dari nilai-nilai Double ini untuk mencerminkan konvensi pemformatan budaya yang spesifik atau muncul dalam format tertentu yang ditentukan oleh string format numerik standar atau kustom. (Untuk informasi selengkapnya, lihat String Format Numerik Standar dan String Format Numerik Kustom.)

Salah satu cara yang lebih umum untuk mengekspresikan representasi string dari bilangan kompleks mengambil formulir a + bi, di mana a merupakan komponen riil bilangan kompleks, dan b merupakan komponen imajiner bilangan kompleks. Dalam rekayasa listrik, jumlah kompleks paling umum dinyatakan sebagai a + bj. Anda dapat mengembalikan representasi string dari bilangan kompleks di salah satu dari dua formulir ini. Untuk melakukan ini, tentukan penyedia format kustom dengan menerapkan ICustomFormatter antarmuka dan IFormatProvider , lalu panggil String.Format(IFormatProvider, String, Object[]) metode .

Contoh berikut mendefinisikan kelas ComplexFormatter yang mewakili bilangan kompleks sebagai string dalam bentuk a + bi atau 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

Contoh berikut kemudian menggunakan formatter kustom ini untuk menampilkan representasi string dari bilangan kompleks.

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