Complex Estrutura

Definição

Representa um número complexo.

public value class Complex : IEquatable<System::Numerics::Complex>, IFormattable
public value class Complex : IEquatable<System::Numerics::Complex>, IParsable<System::Numerics::Complex>, ISpanParsable<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>, 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 struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
public readonly struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
public readonly struct Complex : IEquatable<System.Numerics.Complex>, IParsable<System.Numerics.Complex>, ISpanParsable<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>, 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>
[System.Serializable]
public struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
type Complex = struct
    interface IFormattable
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>
    interface IIncrementOperators<Complex>
    interface IMultiplicativeIdentity<Complex, Complex>
    interface IMultiplyOperators<Complex, Complex, Complex>
    interface INumberBase<Complex>
    interface ISubtractionOperators<Complex, Complex, Complex>
    interface IUnaryNegationOperators<Complex, Complex>
    interface IUnaryPlusOperators<Complex, Complex>
    interface ISignedNumber<Complex>
[<System.Serializable>]
type Complex = struct
    interface IFormattable
Public Structure Complex
Implements IEquatable(Of Complex), IFormattable
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), 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)
Herança
Complex
Atributos
Implementações

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 no formulário z = x + yi, onde x e y são números reais, e eu é a unidade imaginária que tem a propriedade i2 = -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 cartesiano (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, que é conhecido como o 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. Em 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 no qual o eixo x e o eixo y se cruzam).

  • Sua fase, que é o ângulo entre o eixo real e a linha desenhada da origem até o ponto.

Criando uma instância de 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 cartesiano bidimensional.

  • 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 Byte, , SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Singleou Double valor a um Complex objeto. O valor se torna a parte real do número complexo e sua parte imaginária é igual a 0.

  • Convertendo (em C#) ou convertendo (no Visual Basic) um Decimal ou BigInteger valor em um Complex objeto. O valor se torna a parte real do número complexo e sua parte imaginária é igual a 0.

  • Atribuindo o número complexo 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 Example
{
   public static void Main()
   {
      // 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 Main()
      ' 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 Framework inclui membros que fornecem a seguinte funcionalidade:

  • Métodos para comparar dois números complexos para determinar se eles são iguais.

  • Operadores para executar operações aritméticas em números complexos. Complex os operadores permitem que você execute adição, subtração, multiplicação, divisão e negação unária com números complexos.

  • Métodos para executar 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 para uma potência especificada, localizar a raiz quadrada de um número complexo e obter o valor absoluto de um número complexo.

  • Métodos para executar 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 propriedades e Imaginary as Real propriedades são somente leitura, você não pode modificar o valor de um objeto existenteComplex. Todos os métodos que executam uma operação em um Complex número, se o valor retornado for do tipo Complex, retornarão 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 a precisão como resultado de operações numéricas. Isso significa que comparações estritas para a 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, a execução da exponencialidade no logaritmo de um número deve retornar o número original. No entanto, em alguns casos, a perda de precisão de 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("{0} \n{1} \nEqual: {2}", value, value2,
                                            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 Framework.

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.

Números complexos, 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 até Double.MaxValue, a parte real ou imaginária de um número complexo pode ter um valor de Double.PositiveInfinity, Double.NegativeInfinityou Double.NaN. Double.PositiveInfinity, Double.NegativeInfinitye Double.NaN todos propagam em qualquer operação aritmética ou trigonométrica.

No exemplo a seguir, a divisão produz Zero um número complexo cujas partes reais e imaginárias são ambas Double.NaN. Como resultado, executar 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, executar uma multiplicação que transborda o intervalo do Double tipo produz um número complexo cuja parte real é Double.NaN e cuja parte imaginária é Double.PositiveInfinity. Posteriormente, executar a divisão com esse 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 Example
{
   public static void Main()
   {
      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 Example
   Public Sub Main()
      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 inválidos ou que transbordam o intervalo do tipo de Double dados não geram uma exceção. Em vez disso, eles retornam um Double.PositiveInfinity, Double.NegativeInfinityou Double.NaN sob as seguintes condições:

Observe que isso se aplica a todos os cálculos intermediários executados 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 resultante da multiplicação avalia a expressão 9e308 * 2,5 - 9e308 * 3,5. Cada multiplicação intermediária nessa expressão retorna Double.PositiveInfinitye a tentativa de subtrair Double.PositiveInfinity retorna Double.PositiveInfinity Double.NaN.

Formatando um número complexo

Por padrão, a representação de cadeia de caracteres de um número complexo assume a forma (real, imaginária), onde real e imaginário são as representações de cadeia de caracteres dos Double valores que formam os componentes reais e imaginários do número complexo. Algumas sobrecargas do ToString método permitem a personalização das representações de cadeia de caracteres desses Double valores 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 de formato numérico padrão ou personalizado. (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 usa o formulário a + bi, onde um é 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 um + 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 o e as ICustomFormatter interfaces e IFormatProvider , em seguida, chame o String.Format(IFormatProvider, String, Object[]) método.

O exemplo a seguir define uma ComplexFormatter classe que representa um número complexo como uma cadeia de caracteres na forma de um + bi ou um + 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)
      {
         Complex c1 = (Complex) arg;
         // Check if the format string has a precision specifier.
         int precision;
         string fmtString = String.Empty;
         if (format.Length > 1) {
            try {
               precision = Int32.Parse(format.Substring(1));
            }
            catch (FormatException) {
               precision = 0;
            }
            fmtString = "N" + precision.ToString();
         }
         if (format.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase))
            return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "i";
         else if (format.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase))
            return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "j";
         else
            return c1.ToString(format, provider);
      }
      else
      {
         if (arg is IFormattable)
            return ((IFormattable) arg).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 = Int32.Parse(fmt.Substring(1))
            Catch e As FormatException
               precision = 0
            End Try
            fmtString = "N" + precision.ToString()
         End If
         If fmt.Substring(0, 1).Equals("I", StringComparison.OrdinalIgnoreCase) Then
            Return c1.Real.ToString(fmtString) + " + " + c1.Imaginary.ToString(fmtString) + "i"
         ElseIf fmt.Substring(0, 1).Equals("J", StringComparison.OrdinalIgnoreCase) Then
            Return c1.Real.ToString(fmtString) + " + " + 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 Example
{
   public static void Main()
   {
      Complex c1 = new Complex(12.1, 15.4);
      Console.WriteLine("Formatting with ToString():       " +
                        c1.ToString());
      Console.WriteLine("Formatting with ToString(format): " +
                        c1.ToString("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));
   }
}
// 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 Example
   Public Sub Main()
      Dim c1 As Complex = New Complex(12.1, 15.4)
      Console.WriteLine("Formatting with ToString():       " + 
                        c1.ToString())
      Console.WriteLine("Formatting with ToString(format): " + 
                        c1.ToString("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

Complex(Double, Double)

Inicializa uma nova instância da estrutura Complex usando os valores reais e imaginários especificados.

Campos

ImaginaryOne

Retorna uma nova instância do Complex 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 é NaN (não é um número).

One

Retorna uma nova instância do Complex com um número real igual a um e um número imaginário igual a zero.

Zero

Retorna uma nova instância do Complex com um número real igual a zero e um número imaginário igual a zero.

Propriedades

Imaginary

Obtém o componente imaginário do objeto Complex atual.

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 Complex atual.

Métodos

Abs(Complex)

Obtém o valor absoluto (ou magnitude) de um número complexo.

Acos(Complex)

Retorna o ângulo que é o arco cosseno 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 arco seno do número complexo especificado.

Atan(Complex)

Retorna o ângulo que é o arco tangente 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.

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 elevado à potência especificada por um número complexo.

FromPolarCoordinates(Double, Double)

Cria um número complexo de coordenadas polares de um ponto.

GetHashCode()

Retorna o código hash para o objeto Complex atual.

IsComplexNumber(Complex)

Determina se um valor representa um valor complexo.

IsEvenInteger(Complex)

Determina se um valor representa um número integral uniforme.

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 é NaN (não é um número).

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)

Retorna o logaritmo natural (de base e) de um número complexo especificado.

Log(Complex, Double)

Retorna o logaritmo de um número complexo especificado em uma base especificada.

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ólico do número complexo especificado.

ToString()

Converte o valor do número complexo atual em sua representação de cadeia de caracteres equivalente usando o formato cartesiano.

ToString(IFormatProvider)

Converte o valor do número complexo atual na representação de cadeia de caracteres equivalente em formato cartesiano usando as informações especificadas de formatação específica à cultura.

ToString(String)

Converte o valor do número complexo atual na representação de cadeia de caracteres equivalente em formato cartesiano, usando o formato especificado para suas partes reais e imaginárias.

ToString(String, IFormatProvider)

Converte o valor do número complexo atual na representação de cadeia de caracteres equivalente em formato cartesiano, usando o formato especificado e as informações de formato específicas à cultura para suas partes reais e imaginárias.

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

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)

Diminui 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 valor BigInteger para um número complexo.

Explicit(Decimal to Complex)

Define uma conversão explícita de um valor Decimal para 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 sem sinal 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 explícita de um número de ponto flutuante de precisão dupla como 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 com sinal em um número complexo.

Esta API não compatível com CLS.

Implicit(Single to Complex)

Define uma conversão explícita de um número de ponto flutuante de precisão simples como 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 compatível 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 compatível 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 compatível 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.

Aplica-se a