Complex Complex Complex Complex Struct

Definição

Representa um número complexo.Represents a complex number.

public value class Complex : IEquatable<System::Numerics::Complex>, IFormattable
[System.Serializable]
public struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
type Complex = struct
    interface IFormattable
Public Structure Complex
Implements IEquatable(Of Complex), IFormattable
Herança
Atributos
Implementações

Comentários

Um número complexo é um número que consiste em uma parte de número real e uma parte de número imaginário.A complex number is a number that comprises a real number part and an imaginary number part. Um número complexo z geralmente é gravado no formato z = x + yi, onde x e y são números reais, e eu é a unidade imaginária que tem a propriedade i 2 = -1.A complex number z is usually written in the form z = x + yi, where x and y are real numbers, and i is the imaginary unit that has the property i2 = -1. A parte real do número complexo é representada por x, e a parte imaginária do número complexo é representada pela y.The real part of the complex number is represented by x, and the imaginary part of the complex number is represented by y.

O Complex tipo usa o sistema de coordenadas cartesianas (real, imaginário) ao criar uma instância e manipular números complexos.The Complex type uses the Cartesian coordinate system (real, imaginary) when instantiating and manipulating complex numbers. Um número complexo pode ser representado como um ponto em um sistema de coordenadas bidimensional, que é conhecido como plano complexo.A complex number can be represented as a point in a two-dimensional coordinate system, which is known as the complex plane. 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).The real part of the complex number is positioned on the x-axis (the horizontal axis), and the imaginary part is positioned on the y-axis (the vertical axis).

Qualquer ponto no plano complexo também pode ser expressas com base em seu valor absoluto, usando o sistema de coordenadas polares.Any point in the complex plane can also be expressed based on its absolute value, by using the polar coordinate system. Em coordenadas polares, um ponto é caracterizado por dois números:In polar coordinates, a point is characterized by two numbers:

  • Sua magnitude, que é a distância do ponto da origem (ou seja, 0,0, ou o ponto no qual o eixo x e y interseccionam).Its magnitude, which is the distance of the point from the origin (that is, 0,0, or the point at which the x-axis and the y-axis intersect).

  • Sua fase, que é o ângulo entre o eixo real e a linha desenhada de origem para o ponto.Its phase, which is the angle between the real axis and the line drawn from the origin to the point.

Criando uma instância de um número complexoInstantiating a Complex Number

Você pode atribuir um valor em um número complexo em uma das seguintes maneiras:You can assign a value to a complex number in one of the following ways:

  • Passando dois Double valores para seu construtor.By passing two Double values to its constructor. O primeiro valor representa a parte real do número complexo e o segundo valor representa sua parte imaginária.The first value represents the real part of the complex number, and the second value represents its imaginary part. Esses valores representam a posição do número complexo no sistema de coordenadas cartesianas bidimensional.These values represent the position of the complex number in the two-dimensional Cartesian coordinate system.

  • Chamando estático (Shared no Visual Basic) Complex.FromPolarCoordinates método para criar um número complexo de suas coordenadas polares.By calling the static (Shared in Visual Basic) Complex.FromPolarCoordinates method to create a complex number from its polar coordinates.

  • Atribuindo uma Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, ou Double de valor para um Complex objeto.By assigning a Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, or Double value to a Complex object. O valor se tornará a parte real do número complexo e sua parte imaginária é igual a 0.The value becomes the real part of the complex number, and its imaginary part equals 0.

  • Conversão (em C#) ou convertendo (no Visual Basic) um Decimal ou BigInteger valor para um Complex objeto.By casting (in C#) or converting (in Visual Basic) a Decimal or BigInteger value to a Complex object. O valor se tornará a parte real do número complexo e sua parte imaginária é igual a 0.The value becomes the real part of the complex number, and its imaginary part equals 0.

  • Ao atribuir o número complexo que é retornado por um método ou operador para um Complex objeto.By assigning the complex number that is returned by a method or operator to a Complex object. Por exemplo, Complex.Add é um método estático que retorna um número complexo que é a soma dos dois números complexos, e o Complex.Addition operador adiciona dois números complexos e retorna o resultado.For example, Complex.Add is a static method that returns a complex number that is the sum of two complex numbers, and the Complex.Addition operator adds two complex numbers and returns the result.

O exemplo a seguir demonstra que cada uma dessas cinco maneiras de atribuir um valor em um número complexo.The following example demonstrates each of these five ways of assigning a value to a complex number.

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 complexosOperations with Complex Numbers

O Complex estrutura no .NET Framework inclui os membros que fornecem a seguinte funcionalidade:The Complex structure in the .NET Framework includes members that provide the following functionality:

  • Métodos para comparar dois números complexos para determinar se eles são iguais.Methods to compare two complex numbers to determine whether they are equal.

  • Operadores para executar operações aritméticas em números complexos.Operators to perform arithmetic operations on complex numbers. Complex operadores permitem executar adição, subtração, multiplicação, divisão e negação unária com números complexos.Complex operators enable you to perform addition, subtraction, multiplication, division, and unary negation with complex numbers.

  • Métodos para executar outras operações numéricas em números complexos.Methods to perform other numerical operations on complex numbers. As quatro operações aritméticas básicas, além de gerar um número complexo a uma potência especificada, localize a raiz quadrada de um número complexo e obter o valor absoluto de um número complexo.In addition to the four basic arithmetic operations, you can raise a complex number to a specified power, find the square root of a complex number, and get the absolute value of a complex number.

  • Métodos para executar operações trigonométricas em números complexos.Methods to perform trigonometric operations on complex numbers. Por exemplo, você pode calcular a tangente de um ângulo representado por um número complexo.For example, you can calculate the tangent of an angle represented by a complex number.

Observe que, como o Real e Imaginary as propriedades são somente leitura, você não pode modificar o valor de uma existente Complex objeto.Note that, because the Real and Imaginary properties are read-only, you cannot modify the value of an existing Complex object. Todos os métodos que executam uma operação em um Complex número, se o valor retornado é do tipo Complex, retornam um novo Complex número.All methods that perform an operation on a Complex number, if their return value is of type Complex, return a new Complex number.

Precisão e números complexosPrecision and Complex Numbers

As partes reais e imaginárias de um número complexo são representadas por dois valores de ponto flutuantes de precisão dupla.The real and imaginary parts of a complex number are represented by two double-precision floating-point values. 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.This means that Complex values, like double-precision floating-point values, can lose precision as a result of numerical operations. Isso significa que estrito comparações de igualdade de dois Complex valores podem falhar, mesmo se a diferença entre os dois valores é devido à perda de precisão.This means that strict comparisons for equality of two Complex values may fail, even if the difference between the two values is due to a loss of precision. Para obter mais informações, consulte Double.For more information, see Double.

Por exemplo, a execução de exponenciação no logaritmo de um número deverá retornar o número original.For example, performing exponentiation on the logarithm of a number should return the original number. 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 mostra o exemplo a seguir.However, in some cases, the loss of precision of floating-point values can cause slight differences between the two values, as the following example illustrates.

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, gera resultados ligeiramente diferentes de 32 bits e IA64 versões do .NET Framework.Similarly, the following example, which calculates the square root of a Complex number, produces slightly different results on the 32-bit and IA64 versions of the .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 NaNComplex Numbers, Infinity, and NaN

As partes reais e imaginárias de um número complexo são representadas por Double valores.The real and imaginary parts of a complex number are represented by Double values. Além de desde Double.MinValue à 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.In addition to ranging from Double.MinValue to Double.MaxValue, the real or imaginary part of a complex number can have a value of Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN. Double.PositiveInfinity, Double.NegativeInfinity, e Double.NaN todos propagam em qualquer operação aritmética ou trigonométrica.Double.PositiveInfinity, Double.NegativeInfinity, and Double.NaN all propagate in any arithmetic or trigonometric operation.

No exemplo a seguir, a divisão por Zero produz um número complexo cujas partes reais e imaginárias são ambos Double.NaN.In the following example, division by Zero produces a complex number whose real and imaginary parts are both 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.As a result, performing multiplication with this value also produces a complex number whose real and imaginary parts are Double.NaN. Da mesma forma, executar uma multiplicação que ultrapassar o intervalo da Double tipo produz um número complexo cuja parte real Double.NaN e cuja parte imaginária é Double.PositiveInfinity.Similarly, performing a multiplication that overflows the range of the Double type produces a complex number whose real part is Double.NaN and whose imaginary part is Double.PositiveInfinity. Executar a divisão com este número complexo, subsequentemente, retorna um número complexo cuja parte real Double.NaN e cuja parte imaginária é Double.PositiveInfinity.Subsequently performing division with this complex number returns a complex number whose real part is Double.NaN and whose imaginary part is 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 que são inválidos ou que estourasse o intervalo da Double tipo de dados não lance uma exceção.Mathematical operations with complex numbers that are invalid or that overflow the range of the Double data type do not throw an exception. Em vez disso, eles retornam um Double.PositiveInfinity, Double.NegativeInfinity, ou Double.NaN sob as seguintes condições:Instead, they return a Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN under the following conditions:

Observe que isso se aplica a qualquer cálculos intermediários executados por um método.Note that this applies to any intermediate calculations performed by a method. 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) eu.For example, the multiplication of new Complex(9e308, 9e308) and new Complex(2.5, 3.5) uses the formula (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.The calculation of the real component that results from the multiplication evaluates the expression 9e308 * 2.5 - 9e308 * 3.5. Cada multiplicação intermediária nesta expressão retorna Double.PositiveInfinitye a tentativa para subtrair Double.PositiveInfinity de Double.PositiveInfinity retorna Double.NaN.Each intermediate multiplication in this expression returns Double.PositiveInfinity, and the attempt to subtract Double.PositiveInfinity from Double.PositiveInfinity returns Double.NaN.

Formatando um número complexoFormatting a Complex Number

Por padrão, a representação de cadeia de caracteres de um número complexo assume a forma ( reais , imaginário), em que real e imaginário são as representações de cadeia de caracteres da Double valores que formam os componentes de reais e imaginárias do número complexo.By default, the string representation of a complex number takes the form (real, imaginary), where real and imaginary are the string representations of the Double values that form the complex number's real and imaginary components. 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 um numérico padrão ou personalizado cadeia de caracteres de formato.Some overloads of the ToString method allow customization of the string representations of these Double values to reflect the formatting conventions of a particular culture or to appear in a particular format defined by a standard or custom numeric format string. (Para obter mais informações, consulte cadeias de caracteres de formato numérico padrão e às cadeias de caracteres de formato numérico personalizado.)(For more information, see Standard Numeric Format Strings and Custom Numeric Format Strings.)

Uma das maneiras mais comuns de expressar a representação de cadeia de caracteres de um número complexo assume a forma a + bi, onde um é o componente de real do número complexo e b é o componente imaginário do número complexo.One of the more common ways of expressing the string representation of a complex number takes the form a + bi, where a is the complex number's real component, and b is the complex number's imaginary component. Em engenharia elétrica, um número complexo é geralmente expresso como um + bj.In electrical engineering, a complex number is most commonly expressed as a + bj. Você pode retornar a representação de cadeia de caracteres de um número complexo em qualquer uma destas duas formas.You can return the string representation of a complex number in either of these two forms. Para fazer isso, definir um provedor de formato personalizado implementando a ICustomFormatter e IFormatProvider interfaces e, em seguida, chame o String.Format(IFormatProvider, String, Object[]) método.To do this, define a custom format provider by implementing the ICustomFormatter and IFormatProvider interfaces, and then call the String.Format(IFormatProvider, String, Object[]) method.

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.The following example defines a ComplexFormatter class that represents a complex number as a string in the form of either a + bi or 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)
      {
         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, em seguida, usa esse formatador personalizado para exibir a representação de cadeia de caracteres de um número complexo.The following example then uses this custom formatter to display the string representation of a complex number.

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) Complex(Double, Double) Complex(Double, Double) Complex(Double, Double)

Inicializa uma nova instância da estrutura Complex usando os valores reais e imaginários especificados.Initializes a new instance of the Complex structure using the specified real and imaginary values.

Campos

ImaginaryOne ImaginaryOne ImaginaryOne 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.Returns a new Complex instance with a real number equal to zero and an imaginary number equal to one.

Infinity Infinity Infinity Infinity
NaN NaN NaN NaN
One One One 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.Returns a new Complex instance with a real number equal to one and an imaginary number equal to zero.

Zero Zero 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.Returns a new Complex instance with a real number equal to zero and an imaginary number equal to zero.

Propriedades

Imaginary Imaginary Imaginary Imaginary

Obtém o componente imaginário do objeto Complex atual.Gets the imaginary component of the current Complex object.

Magnitude Magnitude Magnitude Magnitude

Obtém a magnitude (ou valor absoluto) de um número complexo.Gets the magnitude (or absolute value) of a complex number.

Phase Phase Phase Phase

Obtém a fase de um número complexo.Gets the phase of a complex number.

Real Real Real Real

Obtém o componente real do objeto Complex atual.Gets the real component of the current Complex object.

Métodos

Abs(Complex) Abs(Complex) Abs(Complex) Abs(Complex)

Obtém o valor absoluto (ou magnitude) de um número complexo.Gets the absolute value (or magnitude) of a complex number.

Acos(Complex) Acos(Complex) Acos(Complex) Acos(Complex)

Retorna o ângulo que é o arco cosseno do número complexo especificado.Returns the angle that is the arc cosine of the specified complex number.

Add(Double, Complex) Add(Double, Complex) Add(Double, Complex) Add(Double, Complex)
Add(Complex, Double) Add(Complex, Double) Add(Complex, Double) Add(Complex, Double)
Add(Complex, Complex) Add(Complex, Complex) Add(Complex, Complex) Add(Complex, Complex)

Adiciona dois números complexos e retorna o resultado.Adds two complex numbers and returns the result.

Asin(Complex) Asin(Complex) Asin(Complex) Asin(Complex)

Retorna o ângulo que é o arco seno do número complexo especificado.Returns the angle that is the arc sine of the specified complex number.

Atan(Complex) Atan(Complex) Atan(Complex) Atan(Complex)

Retorna o ângulo que é o arco tangente do número complexo especificado.Returns the angle that is the arc tangent of the specified complex number.

Conjugate(Complex) Conjugate(Complex) Conjugate(Complex) Conjugate(Complex)

Calcula o conjugado de um número complexo e retorna o resultado.Computes the conjugate of a complex number and returns the result.

Cos(Complex) Cos(Complex) Cos(Complex) Cos(Complex)

Retorna o cosseno do número complexo especificado.Returns the cosine of the specified complex number.

Cosh(Complex) Cosh(Complex) Cosh(Complex) Cosh(Complex)

Retorna o cosseno hiperbólico do número complexo especificado.Returns the hyperbolic cosine of the specified complex number.

Divide(Double, Complex) Divide(Double, Complex) Divide(Double, Complex) Divide(Double, Complex)
Divide(Complex, Double) Divide(Complex, Double) Divide(Complex, Double) Divide(Complex, Double)
Divide(Complex, Complex) Divide(Complex, Complex) Divide(Complex, Complex) Divide(Complex, Complex)

Divide um número complexo por outro e retorna o resultado.Divides one complex number by another and returns the result.

Equals(Complex) Equals(Complex) Equals(Complex) Equals(Complex)

Retorna um valor que indica se a instância atual e um número complexo especificado têm o mesmo valor.Returns a value that indicates whether the current instance and a specified complex number have the same value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Retorna um valor que indica se a instância atual e um objeto especificado têm o mesmo valor.Returns a value that indicates whether the current instance and a specified object have the same value.

Exp(Complex) Exp(Complex) Exp(Complex) Exp(Complex)

Retorna e elevado à potência especificada por um número complexo.Returns e raised to the power specified by a complex number.

FromPolarCoordinates(Double, Double) FromPolarCoordinates(Double, Double) FromPolarCoordinates(Double, Double) FromPolarCoordinates(Double, Double)

Cria um número complexo de coordenadas polares de um ponto.Creates a complex number from a point's polar coordinates.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retorna o código hash para o objeto Complex atual.Returns the hash code for the current Complex object.

IsFinite(Complex) IsFinite(Complex) IsFinite(Complex) IsFinite(Complex)
IsInfinity(Complex) IsInfinity(Complex) IsInfinity(Complex) IsInfinity(Complex)
IsNaN(Complex) IsNaN(Complex) IsNaN(Complex) IsNaN(Complex)
Log(Complex) Log(Complex) Log(Complex) Log(Complex)

Retorna o logaritmo natural (de base e) de um número complexo especificado.Returns the natural (base e) logarithm of a specified complex number.

Log(Complex, Double) Log(Complex, Double) Log(Complex, Double) Log(Complex, Double)

Retorna o logaritmo de um número complexo especificado em uma base especificada.Returns the logarithm of a specified complex number in a specified base.

Log10(Complex) Log10(Complex) Log10(Complex) Log10(Complex)

Retorna o logaritmo de base 10 de um número complexo especificado.Returns the base-10 logarithm of a specified complex number.

Multiply(Complex, Complex) Multiply(Complex, Complex) Multiply(Complex, Complex) Multiply(Complex, Complex)

Retorna o produto de dois números complexos.Returns the product of two complex numbers.

Multiply(Double, Complex) Multiply(Double, Complex) Multiply(Double, Complex) Multiply(Double, Complex)
Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double)
Negate(Complex) Negate(Complex) Negate(Complex) Negate(Complex)

Retorna o inverso aditivo de um número complexo especificado.Returns the additive inverse of a specified complex number.

Pow(Complex, Double) Pow(Complex, Double) Pow(Complex, Double) 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.Returns a specified complex number raised to a power specified by a double-precision floating-point number.

Pow(Complex, Complex) Pow(Complex, Complex) Pow(Complex, Complex) Pow(Complex, Complex)

Retorna um número complexo especificado elevado a uma potência especificada por um número complexo.Returns a specified complex number raised to a power specified by a complex number.

Reciprocal(Complex) Reciprocal(Complex) Reciprocal(Complex) Reciprocal(Complex)

Retorna o inverso multiplicativo de um número complexo.Returns the multiplicative inverse of a complex number.

Sin(Complex) Sin(Complex) Sin(Complex) Sin(Complex)

Retorna o seno do número complexo especificado.Returns the sine of the specified complex number.

Sinh(Complex) Sinh(Complex) Sinh(Complex) Sinh(Complex)

Retorna o seno hiperbólico do número complexo especificado.Returns the hyperbolic sine of the specified complex number.

Sqrt(Complex) Sqrt(Complex) Sqrt(Complex) Sqrt(Complex)

Retorna a raiz quadrada de um número complexo especificado.Returns the square root of a specified complex number.

Subtract(Double, Complex) Subtract(Double, Complex) Subtract(Double, Complex) Subtract(Double, Complex)
Subtract(Complex, Double) Subtract(Complex, Double) Subtract(Complex, Double) Subtract(Complex, Double)
Subtract(Complex, Complex) Subtract(Complex, Complex) Subtract(Complex, Complex) Subtract(Complex, Complex)

Subtrai um número complexo de outro e retorna o resultado.Subtracts one complex number from another and returns the result.

Tan(Complex) Tan(Complex) Tan(Complex) Tan(Complex)

Retorna a tangente do número complexo especificado.Returns the tangent of the specified complex number.

Tanh(Complex) Tanh(Complex) Tanh(Complex) Tanh(Complex)

Retorna a tangente hiperbólico do número complexo especificado.Returns the hyperbolic tangent of the specified complex number.

ToString() ToString() ToString() ToString()

Converte o valor do número complexo atual em sua representação de cadeia de caracteres equivalente usando o formato cartesiano.Converts the value of the current complex number to its equivalent string representation in Cartesian form.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) 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.Converts the value of the current complex number to its equivalent string representation in Cartesian form by using the specified culture-specific formatting information.

ToString(String) ToString(String) ToString(String) 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.Converts the value of the current complex number to its equivalent string representation in Cartesian form by using the specified format for its real and imaginary parts.

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) 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.Converts the value of the current complex number to its equivalent string representation in Cartesian form by using the specified format and culture-specific format information for its real and imaginary parts.

Operadores

Addition(Complex, Complex) Addition(Complex, Complex) Addition(Complex, Complex) Addition(Complex, Complex)

Adiciona dois números complexos.Adds two complex numbers.

Addition(Double, Complex) Addition(Double, Complex) Addition(Double, Complex) Addition(Double, Complex)
Addition(Complex, Double) Addition(Complex, Double) Addition(Complex, Double) Addition(Complex, Double)
Division(Complex, Complex) Division(Complex, Complex) Division(Complex, Complex) Division(Complex, Complex)

Divide um número complexo especificado por outro número complexo especificado.Divides a specified complex number by another specified complex number.

Division(Complex, Double) Division(Complex, Double) Division(Complex, Double) Division(Complex, Double)
Division(Double, Complex) Division(Double, Complex) Division(Double, Complex) Division(Double, Complex)
Equality(Complex, Complex) Equality(Complex, Complex) Equality(Complex, Complex) Equality(Complex, Complex)

Retorna um valor que indica se dois números complexos são iguais.Returns a value that indicates whether two complex numbers are equal.

Explicit(Decimal to Complex) Explicit(Decimal to Complex) Explicit(Decimal to Complex) Explicit(Decimal to Complex)

Define uma conversão explícita de um valor Decimal para um número complexo.Defines an explicit conversion of a Decimal value to a complex number.

Explicit(BigInteger to Complex) Explicit(BigInteger to Complex) Explicit(BigInteger to Complex) Explicit(BigInteger to Complex)

Define uma conversão explícita de um valor BigInteger para um número complexo.Defines an explicit conversion of a BigInteger value to a complex number.

Implicit(UInt64 to Complex) Implicit(UInt64 to Complex) Implicit(UInt64 to Complex) Implicit(UInt64 to Complex)

Define uma conversão implícita de um inteiro sem sinal de 64 bits em um número complexo.Defines an implicit conversion of a 64-bit unsigned integer to a complex number.

Esta API não compatível com CLS.This API is not CLS-compliant.

Implicit(UInt32 to Complex) Implicit(UInt32 to Complex) Implicit(UInt32 to Complex) Implicit(UInt32 to Complex)

Define uma conversão implícita de um inteiro sem sinal de 32 bits em um número complexo.Defines an implicit conversion of a 32-bit unsigned integer to a complex number.

Esta API não compatível com CLS.This API is not CLS-compliant.

Implicit(UInt16 to Complex) Implicit(UInt16 to Complex) Implicit(UInt16 to Complex) Implicit(UInt16 to Complex)

Define uma conversão implícita de um inteiro sem sinal de 16 bits em um número complexo.Defines an implicit conversion of a 16-bit unsigned integer to a complex number.

Esta API não compatível com CLS.This API is not CLS-compliant.

Implicit(Single to Complex) Implicit(Single to Complex) Implicit(Single to Complex) 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.Defines an implicit conversion of a single-precision floating-point number to a complex number.

Implicit(SByte to Complex) Implicit(SByte to Complex) Implicit(SByte to Complex) Implicit(SByte to Complex)

Define uma conversão implícita de um byte com sinal em um número complexo.Defines an implicit conversion of a signed byte to a complex number.

Esta API não compatível com CLS.This API is not CLS-compliant.

Implicit(Int32 to Complex) Implicit(Int32 to Complex) Implicit(Int32 to Complex) Implicit(Int32 to Complex)

Define uma conversão implícita de um inteiro com sinal de 32 bits em um número complexo.Defines an implicit conversion of a 32-bit signed integer to a complex number.

Implicit(Int16 to Complex) Implicit(Int16 to Complex) Implicit(Int16 to Complex) Implicit(Int16 to Complex)

Define uma conversão implícita de um inteiro com sinal de 16 bits em um número complexo.Defines an implicit conversion of a 16-bit signed integer to a complex number.

Implicit(Double to Complex) Implicit(Double to Complex) Implicit(Double to Complex) 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.Defines an implicit conversion of a double-precision floating-point number to a complex number.

Implicit(Byte to Complex) Implicit(Byte to Complex) Implicit(Byte to Complex) Implicit(Byte to Complex)

Define uma conversão implícita de um byte sem sinal em um número complexo.Defines an implicit conversion of an unsigned byte to a complex number.

Implicit(Int64 to Complex) Implicit(Int64 to Complex) Implicit(Int64 to Complex) Implicit(Int64 to Complex)

Define uma conversão implícita de um inteiro com sinal de 64 bits em um número complexo.Defines an implicit conversion of a 64-bit signed integer to a complex number.

Inequality(Complex, Complex) Inequality(Complex, Complex) Inequality(Complex, Complex) Inequality(Complex, Complex)

Retorna um valor que indica se dois números complexos não são iguais.Returns a value that indicates whether two complex numbers are not equal.

Multiply(Complex, Complex) Multiply(Complex, Complex) Multiply(Complex, Complex) Multiply(Complex, Complex)

Multiplica dois números complexos especificados.Multiplies two specified complex numbers.

Multiply(Double, Complex) Multiply(Double, Complex) Multiply(Double, Complex) Multiply(Double, Complex)
Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double)
Subtraction(Complex, Complex) Subtraction(Complex, Complex) Subtraction(Complex, Complex) Subtraction(Complex, Complex)

Subtrai um número complexo de outro número complexo.Subtracts a complex number from another complex number.

Subtraction(Complex, Double) Subtraction(Complex, Double) Subtraction(Complex, Double) Subtraction(Complex, Double)
Subtraction(Double, Complex) Subtraction(Double, Complex) Subtraction(Double, Complex) Subtraction(Double, Complex)
UnaryNegation(Complex) UnaryNegation(Complex) UnaryNegation(Complex) UnaryNegation(Complex)

Retorna o inverso aditivo de um número complexo especificado.Returns the additive inverse of a specified complex number.

Aplica-se a