Complex Структура

Определение

Пространство имен:

System.Numerics

Сборки:

netstandard.dll, System.Runtime.Numerics.dll

Исходный код:

Complex.cs

Представляет комплексное число.

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)

Наследование

Object

ValueType

Complex

Реализации

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>

Комментарии

Комплексное число — это число, которое состоит из реальной части числа и мнимой части числа. Комплексное число z обычно записывается в форме z = x + yi, где x и y являются реальными числами, и я мнимая единица, которая имеет свойство i² = -1. Реальная часть сложного числа представлена x, и мнимая часть сложного числа представлена y.

Тип Complex использует декартову систему координат (реальную, мнимую) при создании и управлении с экземплярами сложных чисел. Комплексное число может быть представлено как точка в двухмерной системе координат, которая называется сложной плоскости. Реальная часть сложного числа расположена на оси x (горизонтальной оси), а мнимая часть расположена на оси Y (вертикальная ось).

Любая точка в сложной плоскости также может быть выражена на основе его абсолютного значения, используя полярную систему координат. В полярных координатах точка характеризуется двумя числами:

• Его величина, которая является расстоянием точки от источника (т. е. 0,0 или точкой, в которой пересекается ось x и y).
• Его фаза, которая является углом между реальной осью и линией, проведенной от начала координат до точки.

Создать экземпляр сложного числа

Можно назначить значение сложному числу одним из следующих способов:

• Передав два значения Double конструктору. Первое значение представляет реальную часть сложного числа, а второе — мнимую часть. Эти значения представляют позицию комплексного числа в двухмерной системе координат Декартиана.

• Вызывая статический метод (Shared в Visual Basic) Complex.FromPolarCoordinates, чтобы создать комплексное число по его полярным координатам.

• Присваивая объекту Byte значение SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double или Complex. Значение становится реальной частью сложного числа, а его мнимая часть равна 0.

• Путем приведения (в C#) или преобразования (в Visual Basic) значения Decimal или BigInteger в объект Complex. Значение становится реальной частью сложного числа, а его мнимая часть равна 0.

• Назначая сложное число, возвращаемое методом или оператором объекту Complex . Например, Complex.Add является статическим методом, который возвращает комплексное число, которое является суммой двух сложных чисел, и Complex.Addition оператор добавляет два сложных числа и возвращает результат.

В следующем примере демонстрируется каждый из этих пяти способов назначения значения сложному числу.

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)

Операции со сложными числами

Структура Complex в .NET включает элементы, предоставляющие следующие функции:

• Методы сравнения двух сложных чисел, чтобы определить, равны ли они.
• Операторы для выполнения арифметических операций со сложными числами. Complex операторы позволяют выполнять добавление, вычитание, умножение, деление и унарное отрицание со сложными числами.
• Методы для выполнения других числовых операций с сложными числами. Помимо четырех основных арифметических операций, можно увеличить комплексное число до указанной мощности, найти квадратный корень сложного числа и получить абсолютное значение сложного числа.
• Методы для выполнения тригонометрических операций с сложными числами. Например, можно вычислить тангенс угла, представленного сложным числом.

Обратите внимание, что, поскольку RealImaginary свойства доступны только для чтения, нельзя изменить значение существующего Complex объекта. Все методы, выполняющие операцию с Complex числом, если их возвращаемое значение имеет тип Complex, возвращает новое Complex число.

Точность и сложные числа

Реальные и мнимые части сложного числа представлены двумя значениями с плавающей запятой двойной точности. Это означает, что Complex значения, как и значения двойной точности с плавающей запятой, могут потерять точность в результате числовых операций. Это означает, что строгие сравнения для равенства двух Complex значений могут завершиться ошибкой, даже если разница между двумя значениями обусловлена потерей точности. Дополнительные сведения см. в разделе Double.

Например, выполнение экспонентации в логарифме числа должно возвращать исходное число. Однако в некоторых случаях потеря точности значений с плавающей запятой может привести к незначительным различиям между двумя значениями, как показано в следующем примере.

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

Аналогичным образом, следующий пример, который вычисляет квадратный корень Complex числа, создает несколько разные результаты на 32-разрядных и IA64 версиях .NET.

Complex minusOne = new Complex(-1, 0);
Console.WriteLine(Complex.Sqrt(minusOne));
// The example displays the following output:
//    (6.12303176911189E-17, 1) on 32-bit systems.
//    (6.12323399573677E-17,1) on IA64 systems.

Dim minusOne As New Complex(-1, 0)
Console.WriteLine(Complex.Sqrt(minusOne))
' The example displays the following output:
'    (6.12303176911189E-17, 1) on 32-bit systems.
'    (6.12323399573677E-17,1) on IA64 systems.

Бесконечность и NaN

Реальные и мнимые части сложного числа представлены значениями Double . В дополнение к диапазону от Double.MinValueDouble.MaxValue, реальная или мнимая часть сложного числа может иметь значение Double.PositiveInfinity, Double.NegativeInfinityили Double.NaN. Double.PositiveInfinity, Double.NegativeInfinity и Double.NaN все распространяются в любых арифметических или тригонометрических операциях.

В следующем примере деление Zero производит комплексное число, реальные и мнимые части которых являются обоими Double.NaN. В результате выполнение умножения с этим значением также создает комплексное число, реальные и мнимые части которых являются Double.NaN. Аналогичным образом, выполнение умножения, которое выходит за пределы диапазона Double типа, создает комплексное число, реальная часть которого равна Double.NaN, а мнимая часть равна Double.PositiveInfinity. Впоследствии выполнение деления с этим сложным числом возвращает комплексное число, реальная часть которого есть Double.NaN, а мнимая часть — 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)

Математические операции со сложными числами, которые являются недопустимыми или которые переполнены диапазоном Double типа данных, не вызывают исключения. Вместо этого они возвращают Double.PositiveInfinity, Double.NegativeInfinity или Double.NaN при следующих условиях:

• Деление положительного числа на ноль даёт Double.PositiveInfinity.
• Любая операция, которая переполняет верхнюю границу Double типа данных, возвращается Double.PositiveInfinity.
• Деление отрицательного числа на ноль дает Double.NegativeInfinity.
• Любая операция, которая переполняет нижнюю границу Double типа данных, возвращается Double.NegativeInfinity.
• Деление нуля на ноль возвращает Double.NaN.
• Любая операция, выполняемая на операндах, значения которых имеют Double.PositiveInfinityзначение , Double.NegativeInfinityили Double.NaN возвращает Double.PositiveInfinity, Double.NegativeInfinityили Double.NaNв зависимости от конкретной операции.

Обратите внимание, что это относится к любым промежуточным вычислениям, выполняемым методом. Например, умножение new Complex(9e308, 9e308) and new Complex(2.5, 3.5) использует формулу (ac - bd) + (ad + bc)i. Вычисление реального компонента, результатом которого является умножение, вычисляет выражение 9e308 2.5 – 9e308 3.5. Каждое промежуточное умножение в этом выражении возвращает Double.PositiveInfinity, и что попытка вычесть Double.PositiveInfinity из Double.PositiveInfinity возвращает Double.NaN.

Форматирование сложного числа

По умолчанию строковое представление комплексного числа принимает форму <реальная часть; + мнимая часть>, где реальная часть и мнимая часть — это строковые представления значений, которые составляют реальные и мнимые компоненты комплексного числа. Некоторые перегрузки ToString метода позволяют изменять строковые представления этих Double значений, чтобы они отражали форматы, принятые в конкретной культуре, или отображались в заданном формате, задаваемом стандартной или пользовательской строкой числового формата. (Дополнительные сведения см. в разделе Стандартные числовые строки формата и настраиваемые строки числовых форматов.)

Один из наиболее распространенных способов выражения строкового представления сложного числа принимает форму a + bi, где a является реальным компонентом сложного числа и b является мнимым компонентом сложного числа. В электротехнике комплексное число чаще всего выражается как a + bj. Можно вернуть строковое представление сложного числа в любой из этих двух форм. Для этого определите поставщика пользовательского формата, реализуя ICustomFormatter и IFormatProvider интерфейсы, а затем вызовите String.Format(IFormatProvider, String, Object[]) метод.

В следующем примере определяется класс ComplexFormatter, который представляет комплексное число в виде строки в формате a + bi или 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

В следующем примере этот настраиваемый форматировщик используется для отображения строкового представления сложного числа.

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

Конструкторы

Имя	Описание
Complex(Double, Double)	Инициализирует новый экземпляр Complex структуры с помощью указанных реальных и мнимых значений.

Поля

Имя	Описание
ImaginaryOne	Возвращает новый Complex экземпляр с реальным числом, равным нулю, и мнимое число, равное одному.
Infinity	Представляет бесконечность в виде сложного числа.
NaN	Представляет сложный экземпляр, который не является числом (NaN).
One	Возвращает новый Complex экземпляр с реальным числом, равным одному, и мнимое число равно нулю.
Zero	Возвращает новый Complex экземпляр с реальным числом, равным нулю, и мнимое число равно нулю.

Свойства

Имя	Описание
Imaginary	Возвращает мнимый компонент текущего Complex объекта.
Magnitude	Получает величину (или абсолютное значение) сложного числа.
Phase	Возвращает этап сложного числа.
Real	Возвращает реальный компонент текущего Complex объекта.

Методы

Имя	Описание
Abs(Complex)	Получает абсолютное значение (или величину) сложного числа.
Acos(Complex)	Возвращает угол, представляющий собой дуговой косинус указанного сложного числа.
Add(Complex, Complex)	Добавляет два сложных числа и возвращает результат.
Add(Complex, Double)	Добавляет комплексное число в реальное число двойной точности и возвращает результат.
Add(Double, Complex)	Добавляет реальное число двойной точности в комплексное число и возвращает результат.
Asin(Complex)	Возвращает угол, который является синусом дуги указанного сложного числа.
Atan(Complex)	Возвращает угол, который является тангенсом дуги указанного сложного числа.
Conjugate(Complex)	Вычисляет сопряжение сложного числа и возвращает результат.
Cos(Complex)	Возвращает косинус указанного комплексного числа.
Cosh(Complex)	Возвращает гиперболический косинус указанного комплексного числа.
CreateChecked<TOther>(TOther)	Создает экземпляр текущего типа из значения, вызывая исключение переполнения для всех значений, которые выходят за пределы представляющего диапазона текущего типа.
CreateSaturating<TOther>(TOther)	Создает экземпляр текущего типа из значения, насыщая все значения, которые выходят за пределы представляющего диапазона текущего типа.
CreateTruncating<TOther>(TOther)	Создает экземпляр текущего типа из значения, усечение всех значений, которые выходят за пределы представляющего диапазона текущего типа.
Divide(Complex, Complex)	Делит одно сложное число на другое и возвращает результат.
Divide(Complex, Double)	Делит одно комплексное число на реальное число двойной точности и возвращает результат.
Divide(Double, Complex)	Деление одного реального числа двойной точности на комплексное число и возвращает результат.
Equals(Complex)	Возвращает значение, указывающее, имеет ли текущий экземпляр и указанное комплексное число одинаковые значения.
Equals(Object)	Возвращает значение, указывающее, имеет ли текущий экземпляр и указанный объект одно и то же значение.
Exp(Complex)	Возвращает значение e , заданное сложным числом.
FromPolarCoordinates(Double, Double)	Создает комплексное число из полярных координат точки.
GetHashCode()	Возвращает хэш-код для текущего Complex объекта.
IsComplexNumber(Complex)	Определяет, представляет ли значение сложное значение.
IsEvenInteger(Complex)	Определяет, представляет ли значение даже целочисленное число.
IsFinite(Complex)	Определяет, является ли указанное комплексное число конечным.
IsImaginaryNumber(Complex)	Определяет, представляет ли значение мнимое число.
IsInfinity(Complex)	Возвращает значение, указывающее, вычисляется ли указанное комплексное число до бесконечности.
IsInteger(Complex)	Определяет, представляет ли значение целочисленное значение.
IsNaN(Complex)	Возвращает значение, указывающее, не является ли указанный сложный экземпляр числом (NaN).
IsNegative(Complex)	Определяет, является ли значение отрицательным.
IsNegativeInfinity(Complex)	Определяет, является ли значение отрицательным бесконечностью.
IsNormal(Complex)	Определяет, является ли значение нормальным.
IsOddInteger(Complex)	Определяет, представляет ли значение нечетное целочисленное число.
IsPositive(Complex)	Определяет, является ли значение положительным.
IsPositiveInfinity(Complex)	Определяет, является ли значение положительным бесконечностью.
IsRealNumber(Complex)	Определяет, представляет ли значение реальное число.
IsSubnormal(Complex)	Определяет, является ли значение ненормальным.
Log(Complex, Double)	Возвращает логарифм указанного сложного числа в указанной базе.
Log(Complex)	Возвращает естественный (базовый e) логарифм указанного сложного числа.
Log10(Complex)	Возвращает логарифм базового-10 указанного сложного числа.
MaxMagnitude(Complex, Complex)	Сравнивает два значения с вычислениями, которые больше.
MinMagnitude(Complex, Complex)	Сравнивает два значения с вычислениями, которые меньше.
Multiply(Complex, Complex)	Возвращает произведение двух сложных чисел.
Multiply(Complex, Double)	Возвращает произведение сложного числа и реального числа двойной точности.
Multiply(Double, Complex)	Возвращает произведение реального числа двойной точности и комплексного числа.
Negate(Complex)	Возвращает аддитивное обратное указанное комплексное число.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Анализирует диапазон символов в значение.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Анализирует диапазон символов в значение.
Parse(String, IFormatProvider)	Анализирует строку в значение.
Parse(String, NumberStyles, IFormatProvider)	Анализирует строку в значение.
Pow(Complex, Complex)	Возвращает указанное комплексное число, возвращаемое на мощность, указанную сложным числом.
Pow(Complex, Double)	Возвращает указанное комплексное число, созданное до мощности, указанной числом с плавающей запятой двойной точности.
Reciprocal(Complex)	Возвращает умножение, обратное сложному числу.
Sin(Complex)	Возвращает синус указанного сложного числа.
Sinh(Complex)	Возвращает гиперболический синус указанного сложного числа.
Sqrt(Complex)	Возвращает квадратный корень указанного сложного числа.
Subtract(Complex, Complex)	Вычитает одно сложное число из другого и возвращает результат.
Subtract(Complex, Double)	Вычитает одно реальное число двойной точности из сложного числа и возвращает результат.
Subtract(Double, Complex)	Вычитает одно комплексное число из реального числа двойной точности и возвращает результат.
Tan(Complex)	Возвращает тангенс указанного сложного числа.
Tanh(Complex)	Возвращает гиперболический тангенс указанного сложного числа.
ToString()	Преобразует значение текущего сложного числа в эквивалентное строковое представление в декартовой форме.
ToString(IFormatProvider)	Преобразует значение текущего сложного числа в эквивалентное строковое представление в декартовой форме с помощью указанной информации о форматировании, зависящее от языка и региональных параметров.
ToString(String, IFormatProvider)	Преобразует значение текущего сложного числа в эквивалентное строковое представление в декартовской форме с помощью указанного формата и сведений о формате, зависящее от языка и региональных параметров, для его реальных и мнимых частей.
ToString(String)	Преобразует значение текущего сложного числа в эквивалентное строковое представление в декартовской форме с помощью указанного формата для его реальных и мнимых частей.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается отформатировать значение текущего экземпляра как UTF-8 в предоставленный диапазон байтов.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается отформатировать значение текущего экземпляра в предоставленный диапазон символов.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)	Пытается проанализировать диапазон символов в значение.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)	Пытается проанализировать диапазон символов в значение.
TryParse(String, IFormatProvider, Complex)	Пытается проанализировать строку в значение.
TryParse(String, NumberStyles, IFormatProvider, Complex)	Пытается проанализировать строку в значение.

Операторы

Имя	Описание
Addition(Complex, Complex)	Добавляет два сложных числа.
Addition(Complex, Double)	Добавляет комплексное число в реальное число двойной точности.
Addition(Double, Complex)	Добавляет реальное число двойной точности к сложному числу.
Decrement(Complex)	Уменьшает значение.
Division(Complex, Complex)	Делит указанное комплексное число на другое указанное комплексное число.
Division(Complex, Double)	Делит указанное комплексное число на указанное реальное число двойной точности.
Division(Double, Complex)	Делит указанное число с двойной точностью на указанное комплексное число.
Equality(Complex, Complex)	Возвращает значение, указывающее, равны ли два сложных числа.
Explicit(BigInteger to Complex)	Определяет явное преобразование BigInteger значения в комплексное число.
Explicit(Decimal to Complex)	Определяет явное преобразование Decimal значения в комплексное число.
Explicit(Int128 to Complex)	Явно преобразует Int128 значение в комплексное число двойной точности.
Explicit(UInt128 to Complex)	Явно преобразует UInt128 значение в комплексное число двойной точности.
Implicit(Byte to Complex)	Определяет неявное преобразование без знака байта в комплексное число.
Implicit(Char to Complex)	Неявно преобразует Char значение в комплексное число двойной точности.
Implicit(Double to Complex)	Определяет неявное преобразование числа с плавающей запятой двойной точности в комплексное число.
Implicit(Half to Complex)	Неявно преобразует Half значение в комплексное число двойной точности.
Implicit(Int16 to Complex)	Определяет неявное преобразование 16-разрядного целого числа со знаком в комплексное число.
Implicit(Int32 to Complex)	Определяет неявное преобразование 32-разрядного целого числа со знаком в комплексное число.
Implicit(Int64 to Complex)	Определяет неявное преобразование 64-разрядного целого числа со знаком в комплексное число.
Implicit(IntPtr to Complex)	Неявно преобразует IntPtr значение в комплексное число двойной точности.
Implicit(SByte to Complex)	Определяет неявное преобразование подписанного байта в комплексное число. Этот API несовместим с CLS.
Implicit(Single to Complex)	Определяет неявное преобразование числа с плавающей запятой с одной точностью в комплексное число.
Implicit(UInt16 to Complex)	Определяет неявное преобразование 16-разрядного целого числа без знака в комплексное число. Этот API несовместим с CLS.
Implicit(UInt32 to Complex)	Определяет неявное преобразование 32-разрядного целого числа без знака в комплексное число. Этот API несовместим с CLS.
Implicit(UInt64 to Complex)	Определяет неявное преобразование 64-разрядного целого числа без знака в комплексное число. Этот API несовместим с CLS.
Implicit(UIntPtr to Complex)	Неявно преобразует UIntPtr значение в комплексное число двойной точности.
Increment(Complex)	Увеличивает значение.
Inequality(Complex, Complex)	Возвращает значение, указывающее, равны ли два сложных числа.
Multiply(Complex, Complex)	Умножает два указанных сложных числа.
Multiply(Complex, Double)	Умножает указанное комплексное число на указанное реальное число двойной точности.
Multiply(Double, Complex)	Умножает указанное реальное число двойной точности на указанное комплексное число.
Subtraction(Complex, Complex)	Вычитает комплексное число из другого сложного числа.
Subtraction(Complex, Double)	Вычитает реальное число двойной точности из сложного числа.
Subtraction(Double, Complex)	Вычитает комплексное число из реального числа двойной точности.
UnaryNegation(Complex)	Возвращает аддитивное обратное указанное комплексное число.
UnaryPlus(Complex)	Вычисляет унарный плюс значения.

Явные реализации интерфейса

Имя	Описание
IAdditiveIdentity<Complex,Complex>.AdditiveIdentity	Возвращает аддитивное удостоверение текущего типа.
IMultiplicativeIdentity<Complex,Complex>.MultiplicativeIdentity	Возвращает умножающее удостоверение текущего типа.
INumberBase<Complex>.Abs(Complex)	Вычисляет абсолютное значение.
INumberBase<Complex>.IsCanonical(Complex)	Определяет, находится ли значение в его каноническом представлении.
INumberBase<Complex>.IsZero(Complex)	Определяет, равно ли значение нулю.
INumberBase<Complex>.MaxMagnitudeNumber(Complex, Complex)	Сравнивает два значения с вычислениями, которые имеют большую величину и возвращают другое значение, если входные данные.NaN
INumberBase<Complex>.MinMagnitudeNumber(Complex, Complex)	Сравнивает два значения с вычислениями, которые имеют меньшую величину и возвращают другое значение, если входные данные.NaN
INumberBase<Complex>.MultiplyAddEstimate(Complex, Complex, Complex)	Вычисляет оценку (left * right) + . addend
INumberBase<Complex>.One	Возвращает значение 1 типа.
INumberBase<Complex>.Radix	Возвращает радикс или базу для типа.
INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther, Complex)	Представляет комплексное число.
INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther, Complex)	Представляет комплексное число.
INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther, Complex)	Представляет комплексное число.
INumberBase<Complex>.TryConvertToChecked<TOther>(Complex, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, вызывая исключение переполнения для любых значений, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, насыщая все значения, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, усечение любых значений, которые выходят за пределы представляющего диапазона текущего типа.
INumberBase<Complex>.Zero	Возвращает значение 0 типа.
ISignedNumber<Complex>.NegativeOne	Возвращает значение -1 типа.