Complex Estrutura

Definição

Namespace:

System.Numerics

Assemblies:

netstandard.dll, System.Runtime.Numerics.dll

Origem:

Complex.cs

Representa um número complexo.

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)

Herança

Object

ValueType

Complex

Implementações

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>

Comentários

Um número complexo é um número que compreende uma parte numérica real e uma parte numérica imaginária. Um número complexo z é geralmente escrito na forma z = x + yi, onde x e y são números reais, e i é a unidade imaginária que tem a propriedade i² = -1. A parte real do número complexo é representada por x, e a parte imaginária do número complexo é representada por y.

O Complex tipo usa o sistema de coordenadas cartesianas (real, imaginário) ao instanciar e manipular números complexos. Um número complexo pode ser representado como um ponto em um sistema de coordenadas bidimensional, conhecido como plano complexo. A parte real do número complexo é posicionada no eixo x (o eixo horizontal) e a parte imaginária é posicionada no eixo y (o eixo vertical).

Qualquer ponto no plano complexo também pode ser expresso com base em seu valor absoluto, usando o sistema de coordenadas polares. Nas coordenadas polares, um ponto é caracterizado por dois números:

• Sua magnitude, que é a distância do ponto da origem (ou seja, 0,0, ou o ponto em que o eixo x e o eixo y se cruzam).
• Sua fase, que é o ângulo entre o eixo real e a linha traçada da origem ao ponto.

Instanciar um número complexo

Você pode atribuir um valor a um número complexo de uma das seguintes maneiras:

• Passando dois Double valores para seu construtor. O primeiro valor representa a parte real do número complexo e o segundo valor representa sua parte imaginária. Esses valores representam a posição do número complexo no sistema de coordenadas cartesianas bidimensionais.

• Chamando o método estático (Shared no Visual Basic) Complex.FromPolarCoordinates para criar um número complexo a partir de suas coordenadas polares.

• Atribuindo um valor Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single ou Double a um objeto Complex. O valor se torna a parte real do número complexo e sua parte imaginária é igual a 0.

• Ao realizar uma conversão de tipo (em C#) ou converter (em Visual Basic) um valor Decimal ou BigInteger em um objeto Complex. O valor se torna a parte real do número complexo e sua parte imaginária é igual a 0.

• Atribuindo o número complexo que é retornado por um método ou operador a um Complex objeto. Por exemplo, Complex.Add é um método estático que retorna um número complexo que é a soma de dois números complexos, e o Complex.Addition operador adiciona dois números complexos e retorna o resultado.

O exemplo a seguir demonstra cada uma dessas cinco maneiras de atribuir um valor a um número complexo.

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)

Operações com números complexos

A Complex estrutura no .NET inclui membros que fornecem a seguinte funcionalidade:

• Métodos para comparar dois números complexos para determinar se eles são iguais.
• Operadores para realizar operações aritméticas em números complexos. Complex operadores possibilitam a execução de adição, subtração, multiplicação, divisão e negação unária com números complexos.
• Métodos para realizar outras operações numéricas em números complexos. Além das quatro operações aritméticas básicas, você pode elevar um número complexo a uma potência especificada, encontrar a raiz quadrada de um número complexo e obter o valor absoluto de um número complexo.
• Métodos para realizar operações trigonométricas em números complexos. Por exemplo, você pode calcular a tangente de um ângulo representado por um número complexo.

Observe que, como as Real propriedades e Imaginary são somente leitura, você não pode modificar o valor de um objeto existente Complex . Todos os métodos que executam uma operação em um Complex número, se seu valor retornado for do tipo Complex, retornam um novo Complex número.

Precisão e números complexos

As partes reais e imaginárias de um número complexo são representadas por dois valores de ponto flutuante de precisão dupla. Isso significa que Complex valores, como valores de ponto flutuante de precisão dupla, podem perder precisão como resultado de operações numéricas. Isso significa que comparações estritas para igualdade de dois Complex valores podem falhar, mesmo que a diferença entre os dois valores seja devido a uma perda de precisão. Para obter mais informações, consulte Double.

Por exemplo, realizar a exponenciação no logaritmo de um número deve retornar o número original. No entanto, em alguns casos, a perda de precisão dos valores de ponto flutuante pode causar pequenas diferenças entre os dois valores, como ilustra o exemplo a seguir.

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

Da mesma forma, o exemplo a seguir, que calcula a raiz quadrada de um Complex número, produz resultados ligeiramente diferentes nas versões de 32 bits e IA64 do .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.

Infinito e NaN

As partes reais e imaginárias de um número complexo são representadas por Double valores. Além de variar de Double.MinValue a Double.MaxValue, a parte real ou imaginária de um número complexo pode ter um valor de Double.PositiveInfinity, Double.NegativeInfinity, ou Double.NaN. Double.PositiveInfinity, Double.NegativeInfinity, e Double.NaN todos se propagam em qualquer operação aritmética ou trigonométrica.

No exemplo a seguir, a divisão por Zero produz um número complexo cujas partes reais e imaginárias são ambas Double.NaN. Como resultado, realizar a multiplicação com esse valor também produz um número complexo cujas partes reais e imaginárias são Double.NaN. Da mesma forma, realizar uma multiplicação que ultrapassa o intervalo do Double tipo produz um número complexo cuja parte real é Double.NaN e cuja parte imaginária é Double.PositiveInfinity. Posteriormente, realizar a divisão com este número complexo retorna um número complexo cuja parte real é Double.NaN e cuja parte imaginária é 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)

Operações matemáticas com números complexos que são inválidos ou que excedem o Double intervalo do tipo de dados não geram uma exceção. Em vez disso, eles retornam um Double.PositiveInfinity, Double.NegativeInfinity, ou Double.NaN nas seguintes condições:

• A divisão de um número positivo por zero retorna Double.PositiveInfinity.
• Qualquer operação que ultrapasse o limite superior do Double tipo de dados retorna Double.PositiveInfinity.
• A divisão de um número negativo por zero retorna Double.NegativeInfinity.
• Qualquer operação que ultrapasse o limite inferior do Double tipo de dados retorna Double.NegativeInfinity.
• A divisão de um zero por zero retorna Double.NaN.
• Qualquer operação executada em operandos cujos valores são Double.PositiveInfinity, Double.NegativeInfinity, ou Double.NaN retorna Double.PositiveInfinity, Double.NegativeInfinity, ou Double.NaN, dependendo da operação específica.

Observe que isso se aplica a quaisquer cálculos intermediários realizados por um método. Por exemplo, a multiplicação de new Complex(9e308, 9e308) and new Complex(2.5, 3.5) usa a fórmula (ac - bd) + (ad + bc)i. O cálculo do componente real que resulta da multiplicação avalia a expressão 9e308 2,5 - 9e308 3,5. Cada multiplicação intermediária nesta expressão retorna Double.PositiveInfinity, e a tentativa de subtrair Double.PositiveInfinity de Double.PositiveInfinity retorna Double.NaN.

Formatar um número complexo

Por padrão, a representação de string de um número complexo assume a forma <real; imaginária>, onde real e imaginário são as representações de string dos Double valores que formam os componentes reais e imaginários do número complexo. Algumas sobrecargas do método ToString permitem a personalização das representações em cadeia de caracteres desses valores Double para refletir as convenções de formatação de uma cultura específica ou para aparecer em um formato específico definido por uma cadeia de caracteres numérica padrão ou personalizada. (Para obter mais informações, consulte Cadeias de caracteres de formato numérico padrão e cadeias de caracteres de formato numérico personalizado.)

Uma das maneiras mais comuns de expressar a representação de cadeia de caracteres de um número complexo assume o formulário a + bi, onde a está o componente real do número complexo e b é o componente imaginário do número complexo. Na engenharia elétrica, um número complexo é mais comumente expresso como a + bj. Você pode retornar a representação de cadeia de caracteres de um número complexo em qualquer uma dessas duas formas. Para fazer isso, defina um provedor de formato personalizado implementando as interfaces ICustomFormatter e IFormatProvider e, em seguida, chame o método String.Format(IFormatProvider, String, Object[]).

O exemplo a seguir define uma ComplexFormatter classe que representa um número complexo como uma cadeia de caracteres na forma de um a + bi ou 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

O exemplo a seguir usa esse formatador personalizado para exibir a representação de cadeia de caracteres de um número complexo.

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

Construtores

Nome	Description
Complex(Double, Double)	Inicializa uma nova instância da Complex estrutura usando os valores reais e imaginários especificados.

Campos

Nome	Description
ImaginaryOne	Retorna uma nova Complex instância com um número real igual a zero e um número imaginário igual a um.
Infinity	Representa infinito como um número complexo.
NaN	Representa uma instância complexa que não é um número (NaN).
One	Retorna uma nova Complex instância com um número real igual a um e um número imaginário igual a zero.
Zero	Retorna uma nova Complex instância com um número real igual a zero e um número imaginário igual a zero.

Propriedades

Nome	Description
Imaginary	Obtém o componente imaginário do objeto atual Complex .
Magnitude	Obtém a magnitude (ou valor absoluto) de um número complexo.
Phase	Obtém a fase de um número complexo.
Real	Obtém o componente real do objeto atual Complex .

Métodos

Nome	Description
Abs(Complex)	Obtém o valor absoluto (ou magnitude) de um número complexo.
Acos(Complex)	Retorna o ângulo que é o cosseno de arco do número complexo especificado.
Add(Complex, Complex)	Adiciona dois números complexos e retorna o resultado.
Add(Complex, Double)	Adiciona um número complexo a um número real de precisão dupla e retorna o resultado.
Add(Double, Complex)	Adiciona um número real de precisão dupla a um número complexo e retorna o resultado.
Asin(Complex)	Retorna o ângulo que é o seno do arco do número complexo especificado.
Atan(Complex)	Retorna o ângulo que é a tangente do arco do número complexo especificado.
Conjugate(Complex)	Calcula o conjugado de um número complexo e retorna o resultado.
Cos(Complex)	Retorna o cosseno do número complexo especificado.
Cosh(Complex)	Retorna o cosseno hiperbólico do número complexo especificado.
CreateChecked<TOther>(TOther)	Cria uma instância do tipo atual de um valor, gerando uma exceção de estouro para quaisquer valores que fiquem fora do intervalo representável do tipo atual.
CreateSaturating<TOther>(TOther)	Cria uma instância do tipo atual de um valor, saturando todos os valores que estão fora do intervalo representável do tipo atual.
CreateTruncating<TOther>(TOther)	Cria uma instância do tipo atual de um valor, truncando todos os valores que estão fora do intervalo representável do tipo atual.
Divide(Complex, Complex)	Divide um número complexo por outro e retorna o resultado.
Divide(Complex, Double)	Divide um número complexo por um número real de precisão dupla e retorna o resultado.
Divide(Double, Complex)	Divide um número real de precisão dupla por um número complexo e retorna o resultado.
Equals(Complex)	Retorna um valor que indica se a instância atual e um número complexo especificado têm o mesmo valor.
Equals(Object)	Retorna um valor que indica se a instância atual e um objeto especificado têm o mesmo valor.
Exp(Complex)	Retorna e gerado para a energia especificada por um número complexo.
FromPolarCoordinates(Double, Double)	Cria um número complexo com base nas coordenadas polares de um ponto.
GetHashCode()	Retorna o código hash do objeto atual Complex .
IsComplexNumber(Complex)	Determina se um valor representa um valor complexo.
IsEvenInteger(Complex)	Determina se um valor representa um número integral par.
IsFinite(Complex)	Determina se o número complexo especificado é finito.
IsImaginaryNumber(Complex)	Determina se um valor representa um número imaginário.
IsInfinity(Complex)	Retorna um valor que indica se o número complexo especificado é avaliado como infinito.
IsInteger(Complex)	Determina se um valor representa um valor integral.
IsNaN(Complex)	Retorna um valor que indica se a instância complexa especificada não é um número (NaN).
IsNegative(Complex)	Determina se um valor é negativo.
IsNegativeInfinity(Complex)	Determina se um valor é infinito negativo.
IsNormal(Complex)	Determina se um valor é normal.
IsOddInteger(Complex)	Determina se um valor representa um número integral ímpar.
IsPositive(Complex)	Determina se um valor é positivo.
IsPositiveInfinity(Complex)	Determina se um valor é infinito positivo.
IsRealNumber(Complex)	Determina se um valor representa um número real.
IsSubnormal(Complex)	Determina se um valor é subnormal.
Log(Complex, Double)	Retorna o logaritmo de um número complexo especificado em uma base especificada.
Log(Complex)	Retorna o logaritmo natural (base e) de um número complexo especificado.
Log10(Complex)	Retorna o logaritmo de base 10 de um número complexo especificado.
MaxMagnitude(Complex, Complex)	Compara dois valores com a computação que é maior.
MinMagnitude(Complex, Complex)	Compara dois valores com a computação menor.
Multiply(Complex, Complex)	Retorna o produto de dois números complexos.
Multiply(Complex, Double)	Retorna o produto de um número complexo e um número real de precisão dupla.
Multiply(Double, Complex)	Retorna o produto de um número real de precisão dupla e um número complexo.
Negate(Complex)	Retorna o inverso aditivo de um número complexo especificado.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analisa um intervalo de caracteres em um valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Analisa um intervalo de caracteres em um valor.
Parse(String, IFormatProvider)	Analisa uma cadeia de caracteres em um valor.
Parse(String, NumberStyles, IFormatProvider)	Analisa uma cadeia de caracteres em um valor.
Pow(Complex, Complex)	Retorna um número complexo especificado elevado a uma potência especificada por um número complexo.
Pow(Complex, Double)	Retorna um número complexo especificado elevado a uma potência especificada por um número de ponto flutuante de precisão dupla.
Reciprocal(Complex)	Retorna o inverso multiplicativo de um número complexo.
Sin(Complex)	Retorna o seno do número complexo especificado.
Sinh(Complex)	Retorna o seno hiperbólico do número complexo especificado.
Sqrt(Complex)	Retorna a raiz quadrada de um número complexo especificado.
Subtract(Complex, Complex)	Subtrai um número complexo de outro e retorna o resultado.
Subtract(Complex, Double)	Subtrai um número real de precisão dupla de um número complexo e retorna o resultado.
Subtract(Double, Complex)	Subtrai um número complexo de um número real de precisão dupla e retorna o resultado.
Tan(Complex)	Retorna a tangente do número complexo especificado.
Tanh(Complex)	Retorna a tangente hiperbólica do número complexo especificado.
ToString()	Converte o valor do número complexo atual em sua representação de cadeia de caracteres equivalente no formulário Cartesiano.
ToString(IFormatProvider)	Converte o valor do número complexo atual em sua representação de cadeia de caracteres equivalente no formulário Cartesiano usando as informações de formatação específicas da cultura especificadas.
ToString(String, IFormatProvider)	Converte o valor do número complexo atual em sua representação de cadeia de caracteres equivalente no formato Cartesiano usando o formato especificado e as informações de formato específicas da cultura para suas partes reais e imaginárias.
ToString(String)	Converte o valor do número complexo atual em sua representação de cadeia de caracteres equivalente no formato Cartesiano usando o formato especificado para suas partes reais e imaginárias.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual como UTF-8 no intervalo de bytes fornecido.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual no intervalo de caracteres fornecido.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)	Tenta analisar um intervalo de caracteres em um valor.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)	Tenta analisar um intervalo de caracteres em um valor.
TryParse(String, IFormatProvider, Complex)	Tenta analisar uma cadeia de caracteres em um valor.
TryParse(String, NumberStyles, IFormatProvider, Complex)	Tenta analisar uma cadeia de caracteres em um valor.

Operadores

Nome	Description
Addition(Complex, Complex)	Adiciona dois números complexos.
Addition(Complex, Double)	Adiciona um número complexo a um número real de precisão dupla.
Addition(Double, Complex)	Adiciona um número real de precisão dupla a um número complexo.
Decrement(Complex)	Decrementa um valor.
Division(Complex, Complex)	Divide um número complexo especificado por outro número complexo especificado.
Division(Complex, Double)	Divide um número complexo especificado por um número real de precisão dupla especificado.
Division(Double, Complex)	Divide um número real de precisão dupla especificado por um número complexo especificado.
Equality(Complex, Complex)	Retorna um valor que indica se dois números complexos são iguais.
Explicit(BigInteger to Complex)	Define uma conversão explícita de um BigInteger valor em um número complexo.
Explicit(Decimal to Complex)	Define uma conversão explícita de um Decimal valor em um número complexo.
Explicit(Int128 to Complex)	Converte explicitamente um Int128 valor em um número complexo de precisão dupla.
Explicit(UInt128 to Complex)	Converte explicitamente um UInt128 valor em um número complexo de precisão dupla.
Implicit(Byte to Complex)	Define uma conversão implícita de um byte não assinado em um número complexo.
Implicit(Char to Complex)	Converte implicitamente um Char valor em um número complexo de precisão dupla.
Implicit(Double to Complex)	Define uma conversão implícita de um número de ponto flutuante de precisão dupla em um número complexo.
Implicit(Half to Complex)	Converte implicitamente um Half valor em um número complexo de precisão dupla.
Implicit(Int16 to Complex)	Define uma conversão implícita de um inteiro com sinal de 16 bits em um número complexo.
Implicit(Int32 to Complex)	Define uma conversão implícita de um inteiro com sinal de 32 bits em um número complexo.
Implicit(Int64 to Complex)	Define uma conversão implícita de um inteiro com sinal de 64 bits em um número complexo.
Implicit(IntPtr to Complex)	Converte implicitamente um IntPtr valor em um número complexo de precisão dupla.
Implicit(SByte to Complex)	Define uma conversão implícita de um byte assinado em um número complexo. Esta API não está em conformidade com CLS.
Implicit(Single to Complex)	Define uma conversão implícita de um número de ponto flutuante de precisão única para um número complexo.
Implicit(UInt16 to Complex)	Define uma conversão implícita de um inteiro sem sinal de 16 bits em um número complexo. Esta API não está em conformidade com CLS.
Implicit(UInt32 to Complex)	Define uma conversão implícita de um inteiro sem sinal de 32 bits em um número complexo. Esta API não está em conformidade com CLS.
Implicit(UInt64 to Complex)	Define uma conversão implícita de um inteiro sem sinal de 64 bits em um número complexo. Esta API não está em conformidade com CLS.
Implicit(UIntPtr to Complex)	Converte implicitamente um UIntPtr valor em um número complexo de precisão dupla.
Increment(Complex)	Incrementa um valor.
Inequality(Complex, Complex)	Retorna um valor que indica se dois números complexos não são iguais.
Multiply(Complex, Complex)	Multiplica dois números complexos especificados.
Multiply(Complex, Double)	Multiplica o número complexo especificado por um número real de precisão dupla especificado.
Multiply(Double, Complex)	Multiplica um número real de precisão dupla especificado por um número complexo especificado.
Subtraction(Complex, Complex)	Subtrai um número complexo de outro número complexo.
Subtraction(Complex, Double)	Subtrai um número real de precisão dupla de um número complexo.
Subtraction(Double, Complex)	Subtrai um número complexo de um número real de precisão dupla.
UnaryNegation(Complex)	Retorna o inverso aditivo de um número complexo especificado.
UnaryPlus(Complex)	Calcula a adição unária de um valor.

Implantações explícitas de interface

Nome	Description
IAdditiveIdentity<Complex,Complex>.AdditiveIdentity	Obtém a identidade aditiva do tipo atual.
IMultiplicativeIdentity<Complex,Complex>.MultiplicativeIdentity	Obtém a identidade multiplicativa do tipo atual.
INumberBase<Complex>.Abs(Complex)	Calcula o absoluto de um valor.
INumberBase<Complex>.IsCanonical(Complex)	Determina se um valor está em sua representação canônica.
INumberBase<Complex>.IsZero(Complex)	Determina se um valor é zero.
INumberBase<Complex>.MaxMagnitudeNumber(Complex, Complex)	Compara dois valores com a computação que tem maior magnitude e retorna o outro valor se uma entrada for NaN.
INumberBase<Complex>.MinMagnitudeNumber(Complex, Complex)	Compara dois valores com a computação que tem a menor magnitude e retorna o outro valor se uma entrada for NaN.
INumberBase<Complex>.MultiplyAddEstimate(Complex, Complex, Complex)	Calcula uma estimativa de (left * right) + . addend
INumberBase<Complex>.One	Obtém o valor 1 do tipo.
INumberBase<Complex>.Radix	Obtém a base para o tipo.
INumberBase<Complex>.TryConvertFromChecked<TOther>(TOther, Complex)	Representa um número complexo.
INumberBase<Complex>.TryConvertFromSaturating<TOther>(TOther, Complex)	Representa um número complexo.
INumberBase<Complex>.TryConvertFromTruncating<TOther>(TOther, Complex)	Representa um número complexo.
INumberBase<Complex>.TryConvertToChecked<TOther>(Complex, TOther)	Tenta converter uma instância do tipo atual em outro tipo, gerando uma exceção de estouro para quaisquer valores que fiquem fora do intervalo representável do tipo atual.
INumberBase<Complex>.TryConvertToSaturating<TOther>(Complex, TOther)	Tenta converter uma instância do tipo atual em outro tipo, saturando todos os valores que estão fora do intervalo representável do tipo atual.
INumberBase<Complex>.TryConvertToTruncating<TOther>(Complex, TOther)	Tenta converter uma instância do tipo atual em outro tipo, truncando todos os valores que estejam fora do intervalo representável do tipo atual.
INumberBase<Complex>.Zero	Obtém o valor 0 do tipo.
ISignedNumber<Complex>.NegativeOne	Obtém o valor -1 do tipo.