Complex Yapı

Tanım

Ad Alanı:

System.Numerics

Bütünleştirilmiş Kodlar:

netstandard.dll, System.Runtime.Numerics.dll

Kaynak:

Complex.cs

Karmaşık bir sayıyı temsil eder.

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)

Devralma

Object

ValueType

Complex

Uygulamalar

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>

Açıklamalar

Karmaşık sayı, gerçek sayı bölümünü ve sanal sayı bölümünü içeren bir sayıdır. Karmaşık bir z sayısı genellikle biçiminde z = x + yiyazılır; burada x ve y gerçek sayılardır ve i, i^{2 = -1 özelliğine} sahip sanal birimdir. Karmaşık sayının gerçek kısmı x, karmaşık sayının sanal kısmı ise y ile temsil edilir.

Türü, Complex karmaşık sayıların örneğini oluştururken ve düzenlerken Kartezyen koordinat sistemini (gerçek, sanal) kullanır. Karmaşık bir sayı, karmaşık düzlem olarak bilinen iki boyutlu koordinat sisteminde bir nokta olarak temsil edilebilir. Karmaşık sayının gerçek kısmı x eksenine (yatay eksen) ve sanal bölüm y eksenine (dikey eksen) konumlandırılır.

Karmaşık düzlemdeki herhangi bir nokta, kutup koordinat sistemi kullanılarak mutlak değerine göre de ifade edilebilir. Kutupsal koordinatlarda bir nokta iki sayı ile karakterize edilir:

• Noktanın çıkış noktasından uzaklığı olan büyüklüğü (0,0 veya x ekseni ile y ekseninin kesiştiği nokta).
• Gerçek eksen ile çıkış noktasından noktaya doğru çekilen çizgi arasındaki açı olan fazı.

Karmaşık bir sayıyı örneklemek

Karmaşık bir sayıya aşağıdaki yollardan biriyle değer atayabilirsiniz:

• Oluşturucusna iki Double değer geçirerek. İlk değer karmaşık sayının gerçek kısmını, ikinci değer ise sanal kısmını temsil eder. Bu değerler, iki boyutlu Kartezyen koordinat sistemindeki karmaşık sayının konumunu temsil eder.

• Statik (Shared Visual Basic'te) Complex.FromPolarCoordinates yöntemini çağırarak kutupsal koordinatlarından karmaşık bir sayı oluşturun.

• Bir Bytenesneye , SByte, Int16, UInt16, , Int32, UInt32, Int64, UInt64, Singleveya Double değeri Complex atayarak. Değer, karmaşık sayının gerçek parçası olur ve sanal kısmı 0'a eşittir.

• Bir Decimal veya BigInteger değerini C# dilinde bir Complex nesnesine dönüştürmek için dönüştürme yapmak (casting) veya Visual Basic'te dönüştürme yapmak (converting). Değer, karmaşık sayının gerçek parçası olur ve sanal kısmı 0'a eşittir.

• Bir yöntem veya işleç tarafından döndürülen karmaşık sayıyı bir Complex nesneye atayarak. Örneğin, Complex.Add iki karmaşık sayının toplamı olan karmaşık bir sayı döndüren ve Complex.Addition işleç iki karmaşık sayı ekleyip sonucu döndüren statik bir yöntemdir.

Aşağıdaki örnekte, karmaşık bir sayıya değer atamanın bu beş yolunun her biri gösterilmektedir.

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)

Karmaşık sayılarla işlemler

Complex.NET'teki yapı, aşağıdaki işlevleri sağlayan üyeleri içerir:

• Eşit olup olmadıklarını belirlemek için iki karmaşık sayıyı karşılaştırma yöntemleri.
• Karmaşık sayılarda aritmetik işlemler gerçekleştirmek için işleçler. Complex işleçleri karmaşık sayılarla toplama, çıkarma, çarpma, bölme ve tekli olumsuzlama gerçekleştirmenizi sağlar.
• Karmaşık sayılarda diğer sayısal işlemleri gerçekleştirme yöntemleri. Dört temel aritmetik işlemine ek olarak, karmaşık bir sayıyı belirtilen bir güce yükseltebilir, karmaşık bir sayının karekökünü bulabilir ve karmaşık bir sayının mutlak değerini alabilirsiniz.
• Karmaşık sayılarda trigonometrik işlemler gerçekleştirme yöntemleri. Örneğin, karmaşık bir sayının temsil ettiği açının tanjantını hesaplayabilirsiniz.

ve Real özellikleri salt okunur olduğundanImaginary, var olan Complex bir nesnenin değerini değiştiremeyeceğinizi unutmayın. Bir sayı üzerinde Complex işlem gerçekleştiren tüm yöntemler, dönüş değerleri türündeyse Complexyeni Complex bir sayı döndürür.

Kesinlik ve karmaşık sayılar

Karmaşık bir sayının gerçek ve sanal bölümleri iki çift duyarlıklı kayan nokta değeriyle temsil edilir. Bu, çift duyarlıklı kayan Complex nokta değerleri gibi değerlerin sayısal işlemler sonucunda duyarlığı kaybedebileceği anlamına gelir. Bu, iki değer arasındaki fark duyarlık kaybından kaynaklanıyor olsa bile iki Complex değerin eşitliği için katı karşılaştırmaların başarısız olabileceği anlamına gelir. Daha fazla bilgi için bkz. Double.

Örneğin, bir sayının logaritmasında üstelleştirme gerçekleştirmek özgün sayıyı döndürmelidir. Ancak, bazı durumlarda kayan nokta değerlerinin duyarlık kaybı, aşağıdaki örnekte gösterildiği gibi iki değer arasında küçük farklılıklara neden olabilir.

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

Benzer şekilde, bir Complex sayının karekökünü hesaplayan aşağıdaki örnek, .NET'in 32 bit ve IA64 sürümlerinde biraz farklı sonuçlar üretir.

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.

Sonsuzluk ve NaN

Karmaşık bir sayının gerçek ve sanal bölümleri değerlerle Double temsil edilir. ile arasında değişenlere Double.MinValueDouble.MaxValueek olarak, karmaşık bir sayının gerçek veya sanal kısmı , Double.PositiveInfinityveya Double.NegativeInfinitydeğerine Double.NaNsahip olabilir. Double.PositiveInfinity, Double.NegativeInfinityve Double.NaN tümü herhangi bir aritmetik veya trigonometrik işlemde yayılır.

Aşağıdaki örnekte, bölme ölçütü Zero gerçek ve sanal parçaları her ikisi de Double.NaNolan karmaşık bir sayı üretir. Sonuç olarak, bu değerle çarpma gerçekleştirmek, gerçek ve sanal parçaları Double.NaNolan karmaşık bir sayı da üretir. Benzer şekilde, türün aralığını Double aşan bir çarpma gerçekleştirmek, gerçek bölümü Double.NaN olan ve hayali bölümü Double.PositiveInfinity olan karmaşık bir sayı ortaya çıkarır. Daha sonra bu karmaşık sayı ile bölme işlemi gerçek bölümü ve hayali bölümü Double.NaNDouble.PositiveInfinityolan karmaşık bir sayı döndürür.

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)

Geçersiz olan veya veri türü aralığını Double aşan karmaşık sayılarla matematik işlemleri özel durum oluşturmaz. Bunun yerine, aşağıdaki koşullar altında bir Double.PositiveInfinity, Double.NegativeInfinityveya Double.NaN döndürürler:

• Pozitif bir sayının sıfıra bölünmesi döndürür Double.PositiveInfinity.
• Veri türünün üst sınırını aşan herhangi bir işlem Double döndürür.
• Negatif bir sayının sıfıra bölünmesi döndürür Double.NegativeInfinity.
• Veri türünün alt sınırını aşan tüm işlemler Double döndürür.
• Sıfırın sıfıra bölünmesi Double.NaN döndürür.
• Operatörlerin değerlerinin Double.PositiveInfinity, Double.NegativeInfinity veya Double.NaN olduğu her işlem, belirli işleme bağlı olarak Double.PositiveInfinity, Double.NegativeInfinity veya Double.NaN döndürür.

Bunun bir yöntem tarafından gerçekleştirilen ara hesaplamalar için geçerli olduğunu unutmayın. Örneğin, çarpımı new Complex(9e308, 9e308) and new Complex(2.5, 3.5) için (ac - bd) + (ad + bc)i formülünü kullanır. Gerçek bileşenin çarpma sonucu olarak hesaplanması, 9e308 2.5 - 9e308 3.5 ifadesini inceler. Bu ifadedeki her ara çarpma Double.PositiveInfinity döndürür ve Double.PositiveInfinity ile Double.PositiveInfinity çıkarma girişimi Double.NaN döndürür.

Karmaşık bir sayıyı biçimlendirme

Varsayılan olarak, karmaşık bir sayının dize gösterimi <gerçek;sanal> şeklini alır; burada gerçek ve sanal, karmaşık sayının gerçek ve sanal bileşenlerini oluşturan değerlerin dize gösterimleridir. yönteminin ToString bazı aşırı yüklemeleri, belirli bir kültürün biçimlendirme kurallarını yansıtmak veya standart veya özel bir sayısal biçim dizesi tarafından tanımlanan belirli bir biçimde görünmesi için bu Double değerlerin dize gösterimlerinin özelleştirilmesine olanak tanır. (Daha fazla bilgi için bkz. Standart Sayısal Biçim Dizeleri ve Özel Sayısal Biçim Dizeleri.)

Karmaşık bir sayının dize gösterimini ifade etmenin en yaygın yollarından biri, a + bi karmaşık sayının gerçek bileşeni ve karmaşık sayının sanal bileşeni a olan biçimindedirb. Elektrik mühendisliğinde karmaşık bir sayı en yaygın olarak olarak a + bjifade edilir. Bu iki biçimden birinde karmaşık bir sayının dize gösterimini döndürebilirsiniz. Bunu yapmak için, ICustomFormatter ve IFormatProvider arabirimlerini uygulayarak özel bir biçim sağlayıcı tanımlayın ve ardından String.Format(IFormatProvider, String, Object[]) yöntemini çağırın.

Aşağıdaki örnek, karmaşık bir ComplexFormatter sayıyı veya a + bibiçiminde a + bj bir dize olarak temsil eden bir sınıfı tanımlar.

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

Aşağıdaki örnek daha sonra karmaşık bir sayının dize gösterimini görüntülemek için bu özel biçimlendiriciyi kullanır.

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

Oluşturucular

Name	Description
Complex(Double, Double)	Belirtilen gerçek ve sanal değerleri kullanarak yapının yeni bir örneğini Complex başlatır.

Alanlar

Name	Description
ImaginaryOne	Sıfıra eşit gerçek sayıya ve bire eşit sanal sayıya sahip yeni Complex bir örnek döndürür.
Infinity	Sonsuzluğu karmaşık bir sayı olarak temsil eder.
NaN	Sayı (NaN) olmayan karmaşık bir örneği temsil eder.
One	Bire eşit gerçek sayıya ve sıfıra eşit bir sanal sayıya sahip yeni Complex bir örnek döndürür.
Zero	Sıfıra eşit gerçek sayıya ve sıfıra eşit sanal bir sayıya sahip yeni Complex bir örnek döndürür.

Özellikler

Name	Description
Imaginary	Geçerli Complex nesnenin sanal bileşenini alır.
Magnitude	Karmaşık bir sayının büyüklüğünü (veya mutlak değerini) alır.
Phase	Karmaşık bir sayının aşamasını alır.
Real	Geçerli Complex nesnenin gerçek bileşenini alır.

Yöntemler

Name	Description
Abs(Complex)	Karmaşık bir sayının mutlak değerini (veya büyüklüğünü) alır.
Acos(Complex)	Belirtilen karmaşık sayının ark kosinüsü olan açıyı döndürür.
Add(Complex, Complex)	İki karmaşık sayı ekler ve sonucu döndürür.
Add(Complex, Double)	Çift duyarlıklı bir gerçek sayıya karmaşık bir sayı ekler ve sonucu döndürür.
Add(Double, Complex)	Karmaşık bir sayıya çift duyarlıklı bir gerçek sayı ekler ve sonucu döndürür.
Asin(Complex)	Belirtilen karmaşık sayının ark sinüsü olan açıyı döndürür.
Atan(Complex)	Belirtilen karmaşık sayının ark tanjantını gösteren açıyı döndürür.
Conjugate(Complex)	Karmaşık bir sayının eşlemini hesaplar ve sonucu döndürür.
Cos(Complex)	Belirtilen karmaşık sayının kosinüsünü döndürür.
Cosh(Complex)	Belirtilen karmaşık sayının hiperbolik kosinüsünü döndürür.
CreateChecked<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için taşma özel durumu oluşturur.
CreateSaturating<TOther>(TOther)	Bir değerden geçerli türün bir örneğini oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri doygun hale getirir.
CreateTruncating<TOther>(TOther)	Geçerli türün bir örneğini bir değerden oluşturur ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri kesebilir.
Divide(Complex, Complex)	Karmaşık bir sayıyı diğerine böler ve sonucu döndürür.
Divide(Complex, Double)	Karmaşık bir sayıyı çift duyarlıklı bir gerçek sayıya böler ve sonucu döndürür.
Divide(Double, Complex)	Bir çift duyarlıklı gerçek sayıyı karmaşık bir sayıya böler ve sonucu döndürür.
Equals(Complex)	Geçerli örneğin ve belirtilen karmaşık sayının aynı değere sahip olup olmadığını gösteren bir değer döndürür.
Equals(Object)	Geçerli örneğin ve belirtilen nesnenin aynı değere sahip olup olmadığını gösteren bir değer döndürür.
Exp(Complex)	Karmaşık bir sayı tarafından belirtilen güce yükseltilmiş döndürür e .
FromPolarCoordinates(Double, Double)	Bir noktanın kutup koordinatlarından karmaşık bir sayı oluşturur.
GetHashCode()	Geçerli Complex nesnenin karma kodunu döndürür.
IsComplexNumber(Complex)	Bir değerin karmaşık bir değeri temsil ediyor olup olmadığını belirler.
IsEvenInteger(Complex)	Bir değerin çift tamsayı sayıyı temsil eder olup olmadığını belirler.
IsFinite(Complex)	Belirtilen karmaşık sayının sonlu olup olmadığını belirler.
IsImaginaryNumber(Complex)	Bir değerin sanal bir sayıyı temsil ediyor olup olmadığını belirler.
IsInfinity(Complex)	Belirtilen karmaşık sayının sonsuz olarak değerlendirilip değerlendirilmediğini belirten bir değer döndürür.
IsInteger(Complex)	Bir değerin bir tamser değeri temsil eder olup olmadığını belirler.
IsNaN(Complex)	Belirtilen karmaşık örneğin sayı (NaN) olup olmadığını gösteren bir değer döndürür.
IsNegative(Complex)	Bir değerin negatif olup olmadığını belirler.
IsNegativeInfinity(Complex)	Bir değerin negatif sonsuz olup olmadığını belirler.
IsNormal(Complex)	Bir değerin normal olup olmadığını belirler.
IsOddInteger(Complex)	Bir değerin tek bir tamsayı sayısını temsil ediyor olup olmadığını belirler.
IsPositive(Complex)	Bir değerin pozitif olup olmadığını belirler.
IsPositiveInfinity(Complex)	Bir değerin pozitif sonsuz olup olmadığını belirler.
IsRealNumber(Complex)	Bir değerin gerçek bir sayıyı temsil ediyor olup olmadığını belirler.
IsSubnormal(Complex)	Bir değerin normalin altında olup olmadığını belirler.
Log(Complex, Double)	Belirtilen bir tabandaki belirtilen karmaşık sayının logaritması döndürür.
Log(Complex)	Belirtilen karmaşık sayının doğal (temel e) logaritması döndürür.
Log10(Complex)	Belirtilen karmaşık sayının 10 tabanında logaritması döndürür.
MaxMagnitude(Complex, Complex)	daha büyük olan iki değeri işlemle karşılaştırır.
MinMagnitude(Complex, Complex)	daha az olan iki değeri işlemle karşılaştırır.
Multiply(Complex, Complex)	İki karmaşık sayının çarpımını döndürür.
Multiply(Complex, Double)	Karmaşık bir sayının ve çift duyarlıklı gerçek sayının çarpımını döndürür.
Multiply(Double, Complex)	Çift duyarlıklı bir gerçek sayının ve karmaşık bir sayının çarpımını döndürür.
Negate(Complex)	Belirtilen karmaşık sayının ek tersini döndürür.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Bir karakter aralığını bir değere ayrıştırıyor.
Parse(String, IFormatProvider)	Bir dizeyi bir değere ayrıştırıyor.
Parse(String, NumberStyles, IFormatProvider)	Bir dizeyi bir değere ayrıştırıyor.
Pow(Complex, Complex)	Karmaşık bir sayı tarafından belirtilen bir güce yükseltilmiş belirtilen karmaşık bir sayı döndürür.
Pow(Complex, Double)	Çift duyarlıklı kayan noktalı sayı tarafından belirtilen bir güce yükseltilmiş belirtilen karmaşık bir sayı döndürür.
Reciprocal(Complex)	Karmaşık bir sayının çarpımlı tersini döndürür.
Sin(Complex)	Belirtilen karmaşık sayının sinüsünü döndürür.
Sinh(Complex)	Belirtilen karmaşık sayının hiperbolik sinüsünü döndürür.
Sqrt(Complex)	Belirtilen karmaşık sayının karekökünü döndürür.
Subtract(Complex, Complex)	Bir karmaşık sayıyı diğerinden çıkarır ve sonucu döndürür.
Subtract(Complex, Double)	Karmaşık bir sayıdan bir çift duyarlıklı gerçek sayıyı çıkarır ve sonucu döndürür.
Subtract(Double, Complex)	Bir karmaşık sayıyı çift duyarlıklı bir gerçek sayıdan çıkarır ve sonucu döndürür.
Tan(Complex)	Belirtilen karmaşık sayının tanjantını döndürür.
Tanh(Complex)	Belirtilen karmaşık sayının hiperbolik tanjantını döndürür.
ToString()	Geçerli karmaşık sayının değerini Kartezyen biçiminde eşdeğer dize gösterimine dönüştürür.
ToString(IFormatProvider)	Belirtilen kültüre özgü biçimlendirme bilgilerini kullanarak geçerli karmaşık sayının değerini Kartezyen biçiminde eşdeğer dize gösterimine dönüştürür.
ToString(String, IFormatProvider)	Geçerli karmaşık sayının değerini, gerçek ve hayali bölümleri için belirtilen biçim ve kültüre özgü biçim bilgilerini kullanarak Kartezyen biçiminde eşdeğer dize gösterimine dönüştürür.
ToString(String)	Geçerli karmaşık sayının değerini, gerçek ve hayali parçaları için belirtilen biçimi kullanarak Kartezyen biçiminde eşdeğer dize gösterimine dönüştürür.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini UTF-8 olarak sağlanan bayt aralığına biçimlendirmeye çalışır.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Geçerli örneğin değerini sağlanan karakter aralığına biçimlendirmeye çalışır.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)	Bir karakter aralığını bir değere ayrıştırmaya çalışır.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)	Bir karakter aralığını bir değere ayrıştırmaya çalışır.
TryParse(String, IFormatProvider, Complex)	Bir dizeyi bir değere ayrıştırmaya çalışır.
TryParse(String, NumberStyles, IFormatProvider, Complex)	Bir dizeyi bir değere ayrıştırmaya çalışır.

İşleçler

Name	Description
Addition(Complex, Complex)	İki karmaşık sayı ekler.
Addition(Complex, Double)	Çift duyarlıklı bir gerçek sayıya karmaşık bir sayı ekler.
Addition(Double, Complex)	Karmaşık bir sayıya çift duyarlıklı bir gerçek sayı ekler.
Decrement(Complex)	Bir değeri azaltma.
Division(Complex, Complex)	Belirtilen karmaşık sayıyı belirtilen başka bir karmaşık sayıya böler.
Division(Complex, Double)	Belirtilen karmaşık sayıyı belirtilen çift duyarlıklı gerçek sayıya böler.
Division(Double, Complex)	Belirtilen çift duyarlıklı gerçek sayıyı belirtilen karmaşık sayıya böler.
Equality(Complex, Complex)	İki karmaşık sayının eşit olup olmadığını gösteren bir değer döndürür.
Explicit(BigInteger to Complex)	Bir değerin karmaşık bir BigInteger sayıya açık dönüştürmesini tanımlar.
Explicit(Decimal to Complex)	Bir değerin karmaşık bir Decimal sayıya açık dönüştürmesini tanımlar.
Explicit(Int128 to Complex)	Bir değeri açıkça çift duyarlıklı karmaşık bir sayıya dönüştürür Int128 .
Explicit(UInt128 to Complex)	Bir değeri açıkça çift duyarlıklı karmaşık bir sayıya dönüştürür UInt128 .
Implicit(Byte to Complex)	İmzalanmamış bir bayta karmaşık bir sayıya örtük bir dönüştürme tanımlar.
Implicit(Char to Complex)	Bir değeri örtük olarak çift duyarlıklı karmaşık bir sayıya dönüştürür Char .
Implicit(Double to Complex)	Çift duyarlıklı kayan noktalı sayının karmaşık bir sayıya örtük dönüştürmesini tanımlar.
Implicit(Half to Complex)	Bir değeri örtük olarak çift duyarlıklı karmaşık bir sayıya dönüştürür Half .
Implicit(Int16 to Complex)	16 bit imzalı tamsayının karmaşık bir sayıya örtük dönüştürmesini tanımlar.
Implicit(Int32 to Complex)	32 bit imzalı tamsayının karmaşık bir sayıya örtük dönüştürmesini tanımlar.
Implicit(Int64 to Complex)	64 bit imzalı tamsayının karmaşık bir sayıya örtük dönüştürmesini tanımlar.
Implicit(IntPtr to Complex)	Bir değeri örtük olarak çift duyarlıklı karmaşık bir sayıya dönüştürür IntPtr .
Implicit(SByte to Complex)	İmzalı baytların karmaşık bir sayıya örtük bir dönüştürmesini tanımlar. Bu API, CLS uyumlu değildir.
Implicit(Single to Complex)	Tek duyarlıklı kayan noktalı bir sayının karmaşık bir sayıya örtük dönüştürmesini tanımlar.
Implicit(UInt16 to Complex)	16 bit işaretsiz tamsayının karmaşık bir sayıya örtük dönüştürmesini tanımlar. Bu API, CLS uyumlu değildir.
Implicit(UInt32 to Complex)	32 bit işaretsiz tamsayının karmaşık bir sayıya örtük dönüştürmesini tanımlar. Bu API, CLS uyumlu değildir.
Implicit(UInt64 to Complex)	64 bit işaretsiz tamsayının karmaşık bir sayıya örtük dönüştürmesini tanımlar. Bu API, CLS uyumlu değildir.
Implicit(UIntPtr to Complex)	Bir değeri örtük olarak çift duyarlıklı karmaşık bir sayıya dönüştürür UIntPtr .
Increment(Complex)	Bir değeri artırır.
Inequality(Complex, Complex)	İki karmaşık sayının eşit olup olmadığını gösteren bir değer döndürür.
Multiply(Complex, Complex)	Belirtilen iki karmaşık sayıyı çarpar.
Multiply(Complex, Double)	Belirtilen karmaşık sayıyı belirtilen çift duyarlıklı gerçek sayıyla çarpar.
Multiply(Double, Complex)	Belirtilen çift duyarlıklı gerçek sayıyı belirtilen karmaşık bir sayıyla çarpar.
Subtraction(Complex, Complex)	Karmaşık bir sayıyı başka bir karmaşık sayıdan çıkarır.
Subtraction(Complex, Double)	Karmaşık bir sayıdan çift duyarlıklı bir gerçek sayıyı çıkarır.
Subtraction(Double, Complex)	Karmaşık bir sayıyı çift duyarlıklı bir gerçek sayıdan çıkarır.
UnaryNegation(Complex)	Belirtilen karmaşık sayının ek tersini döndürür.
UnaryPlus(Complex)	Bir değerin birli artısını hesaplar.

Belirtik Arabirim Kullanımları

Name	Description
IAdditiveIdentity<Complex,Complex>.AdditiveIdentity	Geçerli türün ek kimliğini alır.
IMultiplicativeIdentity<Complex,Complex>.MultiplicativeIdentity	Geçerli türün çarpımlı kimliğini alır.
INumberBase<Complex>.Abs(Complex)	Bir değerin mutlak değerini hesaplar.
INumberBase<Complex>.IsCanonical(Complex)	Bir değerin kurallı gösteriminde olup olmadığını belirler.
INumberBase<Complex>.IsZero(Complex)	Değerin sıfır olup olmadığını belirler.
INumberBase<Complex>.MaxMagnitudeNumber(Complex, Complex)	İki değeri, daha büyük bir büyüklüğe sahip olan ve giriş ise diğer değeri döndüren işlemle karşılaştırır NaN.
INumberBase<Complex>.MinMagnitudeNumber(Complex, Complex)	daha az büyüklüğe sahip olan ve giriş ise diğer değeri döndüren iki değeri işlemle karşılaştırır NaN.
INumberBase<Complex>.MultiplyAddEstimate(Complex, Complex, Complex)	(left * right) + addendtahminini hesaplar.
INumberBase<Complex>.One	Türün değerini 1 alır.
INumberBase<Complex>.Radix	Türün radiksini veya tabanını alır.
INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther, Complex)	Karmaşık bir sayıyı temsil eder.
INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther, Complex)	Karmaşık bir sayıyı temsil eder.
INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther, Complex)	Karmaşık bir sayıyı temsil eder.
INumberBase<Complex>.TryConvertToChecked<TOther>(Complex, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerler için bir taşma özel durumu oluşturur.
INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeyi dener ve geçerli türün temsil edilebilir aralığının dışında kalan değerleri doygunluğa getirir.
INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex, TOther)	Geçerli türün bir örneğini başka bir türe dönüştürmeye çalışır ve geçerli türün temsil edilebilir aralığının dışında kalan tüm değerleri kısaltır.
INumberBase<Complex>.Zero	Türün değerini 0 alır.
ISignedNumber<Complex>.NegativeOne	Türün değerini -1 alır.