Complex Struktur

Definisi

Ruang nama:

System.Numerics

Rakitan:

netstandard.dll, System.Runtime.Numerics.dll

Sumber:

Complex.cs

Mewakili bilangan kompleks.

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)

Warisan

Object

ValueType

Complex

Penerapan

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>

Keterangan

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

Konstruktor

Nama	Deskripsi
Complex(Double, Double)	Menginisialisasi instans Complex baru struktur menggunakan nilai nyata dan imajiner yang ditentukan.

Bidang

Nama	Deskripsi
ImaginaryOne	Mengembalikan instans baru Complex dengan angka riil yang sama dengan nol dan angka imajiner yang sama dengan satu.
Infinity	Mewakili tak terbatas sebagai bilangan kompleks.
NaN	Mewakili instans kompleks yang bukan angka (NaN).
One	Mengembalikan instans baru Complex dengan angka riil yang sama dengan satu dan angka imajiner yang sama dengan nol.
Zero	Mengembalikan instans baru Complex dengan angka riil yang sama dengan nol dan angka imajiner sama dengan nol.

Properti

Nama	Deskripsi
Imaginary	Mendapatkan komponen imajiner dari objek saat ini Complex .
Magnitude	Mendapatkan besaran (atau nilai absolut) dari bilangan kompleks.
Phase	Mendapatkan fase bilangan kompleks.
Real	Mendapatkan komponen nyata dari objek saat ini Complex .

Metode

Nama	Deskripsi
Abs(Complex)	Mendapatkan nilai absolut (atau besaran) dari bilangan kompleks.
Acos(Complex)	Mengembalikan sudut yang merupakan kosinus busur dari bilangan kompleks yang ditentukan.
Add(Complex, Complex)	Menambahkan dua bilangan kompleks dan mengembalikan hasilnya.
Add(Complex, Double)	Menambahkan bilangan kompleks ke bilangan riil presisi ganda dan mengembalikan hasilnya.
Add(Double, Complex)	Menambahkan bilangan riil presisi ganda ke bilangan kompleks dan mengembalikan hasilnya.
Asin(Complex)	Mengembalikan sudut yang merupakan sinus busur dari bilangan kompleks yang ditentukan.
Atan(Complex)	Mengembalikan sudut yang merupakan tangen busur dari bilangan kompleks yang ditentukan.
Conjugate(Complex)	Menghitung konjugasi bilangan kompleks dan mengembalikan hasilnya.
Cos(Complex)	Mengembalikan kosinus dari bilangan kompleks yang ditentukan.
Cosh(Complex)	Mengembalikan kosinus hiperbolik dari bilangan kompleks yang ditentukan.
CreateChecked<TOther>(TOther)	Membuat instans jenis saat ini dari nilai, melemparkan pengecualian luapan untuk nilai apa pun yang berada di luar rentang yang dapat diwakili dari jenis saat ini.
CreateSaturating<TOther>(TOther)	Membuat instans jenis saat ini dari nilai, menjenuhkan nilai apa pun yang berada di luar rentang yang dapat diwakili dari jenis saat ini.
CreateTruncating<TOther>(TOther)	Membuat instans jenis saat ini dari nilai, memotong nilai apa pun yang berada di luar rentang yang dapat diwakili dari jenis saat ini.
Divide(Complex, Complex)	Membagi satu bilangan kompleks dengan angka lain dan mengembalikan hasilnya.
Divide(Complex, Double)	Membagi satu bilangan kompleks dengan bilangan riil presisi ganda dan mengembalikan hasilnya.
Divide(Double, Complex)	Membagi satu bilangan riil presisi ganda dengan bilangan kompleks dan mengembalikan hasilnya.
Equals(Complex)	Mengembalikan nilai yang menunjukkan apakah instans saat ini dan bilangan kompleks tertentu memiliki nilai yang sama.
Equals(Object)	Mengembalikan nilai yang menunjukkan apakah instans saat ini dan objek tertentu memiliki nilai yang sama.
Exp(Complex)	Mengembalikan yang e dinaikkan ke daya yang ditentukan oleh bilangan kompleks.
FromPolarCoordinates(Double, Double)	Membuat bilangan kompleks dari koordinat kutub titik.
GetHashCode()	Mengembalikan kode hash untuk objek saat ini Complex .
IsComplexNumber(Complex)	Menentukan apakah nilai mewakili nilai kompleks.
IsEvenInteger(Complex)	Menentukan apakah nilai mewakili angka integral genap.
IsFinite(Complex)	Menentukan apakah bilangan kompleks yang ditentukan terbatas.
IsImaginaryNumber(Complex)	Menentukan apakah nilai mewakili angka imajiner.
IsInfinity(Complex)	Mengembalikan nilai yang menunjukkan apakah bilangan kompleks yang ditentukan mengevaluasi ke tak terbatas.
IsInteger(Complex)	Menentukan apakah nilai mewakili nilai integral.
IsNaN(Complex)	Mengembalikan nilai yang menunjukkan apakah instans kompleks yang ditentukan bukan angka (NaN).
IsNegative(Complex)	Menentukan apakah nilai negatif.
IsNegativeInfinity(Complex)	Menentukan apakah nilai adalah tak terbatas negatif.
IsNormal(Complex)	Menentukan apakah nilai normal.
IsOddInteger(Complex)	Menentukan apakah nilai mewakili angka integral ganjil.
IsPositive(Complex)	Menentukan apakah nilai positif.
IsPositiveInfinity(Complex)	Menentukan apakah nilai adalah tak terbatas positif.
IsRealNumber(Complex)	Menentukan apakah nilai mewakili angka riil.
IsSubnormal(Complex)	Menentukan apakah nilai adalah subnormal.
Log(Complex, Double)	Mengembalikan logaritma dari bilangan kompleks tertentu dalam basis tertentu.
Log(Complex)	Mengembalikan logaritma alami (dasar e) dari bilangan kompleks tertentu.
Log10(Complex)	Mengembalikan logaritma base-10 dari bilangan kompleks tertentu.
MaxMagnitude(Complex, Complex)	Membandingkan dua nilai dengan komputasi yang lebih besar.
MinMagnitude(Complex, Complex)	Membandingkan dua nilai dengan komputasi yang lebih rendah.
Multiply(Complex, Complex)	Mengembalikan produk dari dua bilangan kompleks.
Multiply(Complex, Double)	Mengembalikan produk bilangan kompleks dan bilangan riil presisi ganda.
Multiply(Double, Complex)	Mengembalikan produk dari bilangan riil presisi ganda dan bilangan kompleks.
Negate(Complex)	Mengembalikan inversi aditif dari bilangan kompleks tertentu.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Mengurai rentang karakter menjadi nilai.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Mengurai rentang karakter menjadi nilai.
Parse(String, IFormatProvider)	Mengurai string menjadi nilai.
Parse(String, NumberStyles, IFormatProvider)	Mengurai string menjadi nilai.
Pow(Complex, Complex)	Mengembalikan bilangan kompleks tertentu yang dinaikkan ke daya yang ditentukan oleh bilangan kompleks.
Pow(Complex, Double)	Mengembalikan bilangan kompleks tertentu yang dinaikkan ke daya yang ditentukan oleh angka floating-point presisi ganda.
Reciprocal(Complex)	Mengembalikan inversi multiplikatif dari bilangan kompleks.
Sin(Complex)	Mengembalikan sinus dari bilangan kompleks yang ditentukan.
Sinh(Complex)	Mengembalikan sinus hiperbolik dari bilangan kompleks yang ditentukan.
Sqrt(Complex)	Mengembalikan akar kuadrat dari bilangan kompleks tertentu.
Subtract(Complex, Complex)	Mengurangi satu bilangan kompleks dari angka lain dan mengembalikan hasilnya.
Subtract(Complex, Double)	Mengurangi satu bilangan riil presisi ganda dari bilangan kompleks dan mengembalikan hasilnya.
Subtract(Double, Complex)	Mengurangi satu bilangan kompleks dari bilangan riil presisi ganda dan mengembalikan hasilnya.
Tan(Complex)	Mengembalikan tangen dari bilangan kompleks yang ditentukan.
Tanh(Complex)	Mengembalikan tangen hiperbolik dari bilangan kompleks yang ditentukan.
ToString()	Mengonversi nilai bilangan kompleks saat ini ke representasi string yang setara dalam bentuk Kartesius.
ToString(IFormatProvider)	Mengonversi nilai bilangan kompleks saat ini ke representasi string yang setara dalam bentuk Kartesius dengan menggunakan informasi pemformatan khusus budaya yang ditentukan.
ToString(String, IFormatProvider)	Mengonversi nilai bilangan kompleks saat ini ke representasi string yang setara dalam bentuk Kartesius dengan menggunakan format yang ditentukan dan informasi format khusus budaya untuk bagian nyata dan imajinernya.
ToString(String)	Mengonversi nilai bilangan kompleks saat ini ke representasi string yang setara dalam bentuk Kartesius dengan menggunakan format yang ditentukan untuk bagian nyata dan imajinernya.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Mencoba memformat nilai instans saat ini sebagai UTF-8 ke dalam rentang byte yang disediakan.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Mencoba memformat nilai instans saat ini ke dalam rentang karakter yang disediakan.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)	Mencoba mengurai rentang karakter menjadi nilai.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)	Mencoba mengurai rentang karakter menjadi nilai.
TryParse(String, IFormatProvider, Complex)	Mencoba mengurai string ke dalam nilai.
TryParse(String, NumberStyles, IFormatProvider, Complex)	Mencoba mengurai string ke dalam nilai.

Operator

Nama	Deskripsi
Addition(Complex, Complex)	Menambahkan dua bilangan kompleks.
Addition(Complex, Double)	Menambahkan bilangan kompleks ke bilangan riil presisi ganda.
Addition(Double, Complex)	Menambahkan bilangan riil presisi ganda ke bilangan kompleks.
Decrement(Complex)	Mengurangi nilai.
Division(Complex, Complex)	Membagi bilangan kompleks tertentu dengan bilangan kompleks lain yang ditentukan.
Division(Complex, Double)	Membagi bilangan kompleks tertentu dengan bilangan riil presisi ganda tertentu.
Division(Double, Complex)	Membagi bilangan riil presisi ganda tertentu dengan bilangan kompleks tertentu.
Equality(Complex, Complex)	Mengembalikan nilai yang menunjukkan apakah dua bilangan kompleks sama.
Explicit(BigInteger to Complex)	Menentukan konversi BigInteger eksplisit nilai ke bilangan kompleks.
Explicit(Decimal to Complex)	Menentukan konversi Decimal eksplisit nilai ke bilangan kompleks.
Explicit(Int128 to Complex)	Secara eksplisit mengonversi nilai menjadi Int128 bilangan kompleks presisi ganda.
Explicit(UInt128 to Complex)	Secara eksplisit mengonversi nilai menjadi UInt128 bilangan kompleks presisi ganda.
Implicit(Byte to Complex)	Menentukan konversi implisit byte yang tidak ditandatangani ke bilangan kompleks.
Implicit(Char to Complex)	Secara implisit mengonversi nilai menjadi Char bilangan kompleks presisi ganda.
Implicit(Double to Complex)	Menentukan konversi implisit dari angka floating-point presisi ganda ke bilangan kompleks.
Implicit(Half to Complex)	Secara implisit mengonversi nilai menjadi Half bilangan kompleks presisi ganda.
Implicit(Int16 to Complex)	Menentukan konversi implisit bilangan bulat bertanda tangan 16-bit ke bilangan kompleks.
Implicit(Int32 to Complex)	Menentukan konversi implisit bilangan bulat bertanda tangan 32-bit ke bilangan kompleks.
Implicit(Int64 to Complex)	Menentukan konversi implisit bilangan bulat bertanda tangan 64-bit ke bilangan kompleks.
Implicit(IntPtr to Complex)	Secara implisit mengonversi nilai menjadi IntPtr bilangan kompleks presisi ganda.
Implicit(SByte to Complex)	Menentukan konversi implisit byte yang ditandatangani ke bilangan kompleks. API ini bukan kompatibel CLS.
Implicit(Single to Complex)	Menentukan konversi implisit dari angka floating-point presisi tunggal ke bilangan kompleks.
Implicit(UInt16 to Complex)	Menentukan konversi implisit bilangan bulat yang tidak ditandatangani 16-bit ke bilangan kompleks. API ini bukan kompatibel CLS.
Implicit(UInt32 to Complex)	Menentukan konversi implisit bilangan bulat yang tidak ditandatangani 32-bit ke bilangan kompleks. API ini bukan kompatibel CLS.
Implicit(UInt64 to Complex)	Menentukan konversi implisit bilangan bulat yang tidak ditandatangani 64-bit ke bilangan kompleks. API ini bukan kompatibel CLS.
Implicit(UIntPtr to Complex)	Secara implisit mengonversi nilai menjadi UIntPtr bilangan kompleks presisi ganda.
Increment(Complex)	Menaikkan nilai.
Inequality(Complex, Complex)	Mengembalikan nilai yang menunjukkan apakah dua bilangan kompleks tidak sama.
Multiply(Complex, Complex)	Mengalikan dua bilangan kompleks yang ditentukan.
Multiply(Complex, Double)	Mengalikan bilangan kompleks yang ditentukan dengan bilangan riil presisi ganda yang ditentukan.
Multiply(Double, Complex)	Mengalikan bilangan riil presisi ganda tertentu dengan bilangan kompleks tertentu.
Subtraction(Complex, Complex)	Mengurangi bilangan kompleks dari bilangan kompleks lainnya.
Subtraction(Complex, Double)	Mengurangi bilangan riil presisi ganda dari bilangan kompleks.
Subtraction(Double, Complex)	Mengurangi bilangan kompleks dari bilangan riil presisi ganda.
UnaryNegation(Complex)	Mengembalikan inversi aditif dari bilangan kompleks tertentu.
UnaryPlus(Complex)	Menghitung nilai plus unary.

Implementasi Antarmuka Eksplisit

Nama	Deskripsi
IAdditiveIdentity<Complex,Complex>.AdditiveIdentity	Mendapatkan identitas aditif dari jenis saat ini.
IMultiplicativeIdentity<Complex,Complex>.MultiplicativeIdentity	Mendapatkan identitas multiplikatif dari jenis saat ini.
INumberBase<Complex>.Abs(Complex)	Menghitung absolut nilai.
INumberBase<Complex>.IsCanonical(Complex)	Menentukan apakah nilai berada dalam representasi kanonisnya.
INumberBase<Complex>.IsZero(Complex)	Menentukan apakah nilai adalah nol.
INumberBase<Complex>.MaxMagnitudeNumber(Complex, Complex)	Membandingkan dua nilai dengan komputasi yang memiliki besaran lebih besar dan mengembalikan nilai lain jika input adalah NaN.
INumberBase<Complex>.MinMagnitudeNumber(Complex, Complex)	Membandingkan dua nilai dengan komputasi yang memiliki besaran lebih kecil dan mengembalikan nilai lain jika input adalah NaN.
INumberBase<Complex>.MultiplyAddEstimate(Complex, Complex, Complex)	Menghitung perkiraan (left * right) + . addend
INumberBase<Complex>.One	Mendapatkan nilai 1 untuk jenis tersebut.
INumberBase<Complex>.Radix	Mendapatkan radix, atau basis, untuk tipe tersebut.
INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther, Complex)	Mewakili bilangan kompleks.
INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther, Complex)	Mewakili bilangan kompleks.
INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther, Complex)	Mewakili bilangan kompleks.
INumberBase<Complex>.TryConvertToChecked<TOther>(Complex, TOther)	Mencoba mengonversi instans jenis saat ini ke jenis lain, melemparkan pengecualian luapan untuk nilai apa pun yang berada di luar rentang yang dapat diwakili dari jenis saat ini.
INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex, TOther)	Mencoba mengonversi instans jenis saat ini ke jenis lain, menjenuhkan nilai apa pun yang berada di luar rentang yang dapat diwakili dari jenis saat ini.
INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex, TOther)	Mencoba mengonversi instans jenis saat ini ke jenis lain, memotong nilai apa pun yang berada di luar rentang yang dapat diwakili dari jenis saat ini.
INumberBase<Complex>.Zero	Mendapatkan nilai 0 untuk jenis tersebut.
ISignedNumber<Complex>.NegativeOne	Mendapatkan nilai -1 untuk jenis tersebut.