Complex Estructura

Definición

Representa un número complejo.

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)
Herencia
Complex
Atributos
Implementaciones

Comentarios

Un número complejo es un número que consta de una parte de número real y una parte de número imaginario. Un número complejo z se escribe normalmente en la forma z = x + yi, donde x e y son números reales, y i es la unidad imaginaria que tiene la propiedad i2 = -1. La parte real del número complejo se representa mediante x y la parte imaginaria del número complejo se representa mediante y.

El Complex tipo usa el sistema de coordenadas cartesiano (real, imaginario) al crear instancias y manipular números complejos. Un número complejo se puede representar como un punto en un sistema de coordenadas bidimensional, que se conoce como plano complejo. La parte real del número complejo se coloca en el eje X (eje horizontal) y la parte imaginaria se coloca en el eje Y (el eje vertical).

Cualquier punto del plano complejo también se puede expresar en función de su valor absoluto, mediante el sistema de coordenadas polares. En coordenadas polares, un punto se caracteriza por dos números:

  • Su magnitud, que es la distancia del punto desde el origen (es decir, 0,0, o el punto en el que el eje X y el eje Y se intersecan).

  • Su fase, que es el ángulo entre el eje real y la línea dibujada desde el origen hasta el punto.

Creación de instancias de un número complejo

Puede asignar un valor a un número complejo de una de las maneras siguientes:

  • Al pasar dos Double valores a su constructor. El primer valor representa la parte real del número complejo y el segundo valor representa su parte imaginaria. Estos valores representan la posición del número complejo en el sistema de coordenadas cartesiano bidimensional.

  • Llamando al método estático (Shared en Visual Basic) Complex.FromPolarCoordinates para crear un número complejo a partir de sus coordenadas polares.

  • Asignando un Bytevalor , SByteUInt32Int64Int32Int16UInt16UInt64, Singleo Double a un Complex objeto . El valor se convierte en la parte real del número complejo y su parte imaginaria es igual a 0.

  • Al convertir (en C#) o convertir (en Visual Basic) un Decimal valor o BigInteger en un Complex objeto . El valor se convierte en la parte real del número complejo y su parte imaginaria es igual a 0.

  • Asignando el número complejo devuelto por un método o operador a un Complex objeto . Por ejemplo, Complex.Add es un método estático que devuelve un número complejo que es la suma de dos números complejos, y el Complex.Addition operador agrega dos números complejos y devuelve el resultado.

En el ejemplo siguiente se muestra cada una de estas cinco formas de asignar un valor a un número complejo.

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)

Operaciones con números complejos

La Complex estructura de .NET Framework incluye miembros que proporcionan la siguiente funcionalidad:

  • Métodos para comparar dos números complejos para determinar si son iguales.

  • Operadores para realizar operaciones aritméticas en números complejos. Complex Los operadores permiten realizar sumas, restas, multiplicación, división y negación unaria con números complejos.

  • Métodos para realizar otras operaciones numéricas en números complejos. Además de las cuatro operaciones aritméticas básicas, puede elevar un número complejo a una potencia especificada, buscar la raíz cuadrada de un número complejo y obtener el valor absoluto de un número complejo.

  • Métodos para realizar operaciones trigonométricas en números complejos. Por ejemplo, puede calcular la tangente de un ángulo representado por un número complejo.

Tenga en cuenta que, dado que las Real propiedades y Imaginary son de solo lectura, no se puede modificar el valor de un objeto existente Complex . Todos los métodos que realizan una operación en un Complex número, si su valor devuelto es de tipo Complex, devuelve un nuevo Complex número.

Precisión y números complejos

Las partes reales e imaginarias de un número complejo se representan mediante dos valores de punto flotante de precisión doble. Esto significa que Complex los valores, como los valores de punto flotante de precisión doble, pueden perder precisión como resultado de operaciones numéricas. Esto significa que se pueden producir errores en las comparaciones estrictas de igualdad de dos Complex valores, incluso si la diferencia entre los dos valores se debe a una pérdida de precisión. Para obtener más información, vea Double.

Por ejemplo, la realización de la exponenciación en el logaritmo de un número debe devolver el número original. Sin embargo, en algunos casos, la pérdida de precisión de los valores de punto flotante puede provocar pequeñas diferencias entre los dos valores, como se muestra en el ejemplo siguiente.

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

Del mismo modo, el ejemplo siguiente, que calcula la raíz cuadrada de un Complex número, genera resultados ligeramente diferentes en las versiones de 32 bits e IA64 de .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 complejos, Infinito y NaN

Las partes reales e imaginarias de un número complejo se representan mediante Double valores. Además de ir desde Double.MinValue hasta Double.MaxValue, la parte real o imaginaria de un número complejo puede tener un valor de Double.PositiveInfinity, Double.NegativeInfinityo Double.NaN. Double.PositiveInfinity, Double.NegativeInfinityy Double.NaN se propagan en cualquier operación aritmética o trigonométrica.

En el ejemplo siguiente, la división por Zero produce un número complejo cuyas partes reales e imaginarias son Double.NaN. Como resultado, la realización de la multiplicación con este valor también produce un número complejo cuyas partes reales e imaginarias son Double.NaN. Del mismo modo, la realización de una multiplicación que desborda el intervalo del Double tipo produce un número complejo cuya parte real es Double.NaN y cuya parte imaginaria es Double.PositiveInfinity. Posteriormente, la división con este número complejo devuelve un número complejo cuya parte real es Double.NaN y cuya parte imaginaria es 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)

Las operaciones matemáticas con números complejos que no son válidos o que desbordan el intervalo del tipo de Double datos no inician una excepción. En su lugar, devuelven , Double.PositiveInfinityDouble.NegativeInfinityo Double.NaN en las condiciones siguientes:

Tenga en cuenta que esto se aplica a los cálculos intermedios realizados por un método. Por ejemplo, la multiplicación de new Complex(9e308, 9e308) and new Complex(2.5, 3.5) usa la fórmula (ac - bd) + (ad + bc)i. El cálculo del componente real que resulta de la multiplicación evalúa la expresión 9e308 * 2,5 - 9e308 * 3,5. Cada multiplicación intermedia de esta expresión devuelve Double.PositiveInfinityy el intento de restar Double.PositiveInfinity de Double.PositiveInfinity devuelve Double.NaN.

Aplicar formato a un número complejo

De forma predeterminada, la representación de cadena de un número complejo toma la forma (de imaginaria) real,, donde real e imaginaria son las representaciones de cadena de los Double valores que forman los componentes reales e imaginarios del número complejo. Algunas sobrecargas del ToString método permiten personalizar las representaciones de cadena de estos Double valores para reflejar las convenciones de formato de una referencia cultural determinada o aparecer en un formato determinado definido por una cadena de formato numérico estándar o personalizado. (Para obtener más información, vea Cadenas de formato numérico estándar y cadenas de formato numérico personalizado).

Una de las formas más comunes de expresar la representación de cadena de un número complejo toma la forma + bi, donde un es el componente real del número complejo, y b es el componente imaginario del número complejo. En ingeniería eléctrica, un número complejo se expresa normalmente como + bj. Puede devolver la representación de cadena de un número complejo en cualquiera de estos dos formularios. Para ello, defina un proveedor de formato personalizado mediante la implementación de las ICustomFormatter interfaces y IFormatProvider y, a continuación, llame al String.Format(IFormatProvider, String, Object[]) método .

En el ejemplo siguiente se define una ComplexFormatter clase que representa un número complejo como una cadena en forma de + bi o + 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

A continuación, en el ejemplo siguiente se usa este formateador personalizado para mostrar la representación de cadena de un número complejo.

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

Constructores

Complex(Double, Double)

Inicializa una nueva instancia de la estructura Complex utilizando el valor real y el valor imaginario especificados.

Campos

ImaginaryOne

Devuelve una nueva instancia de Complex con un número real igual a cero y un número imaginario igual a uno.

Infinity

Representa un valor infinito como un número complejo.

NaN

Representa una instancia compleja que no es un número (NaN).

One

Devuelve una nueva instancia de Complex con un número real igual a uno y un número imaginario igual a cero.

Zero

Devuelve una nueva instancia de Complex con un número real igual a cero y un número imaginario igual a cero.

Propiedades

Imaginary

Obtiene el componente imaginario del objeto Complex actual.

Magnitude

Obtiene la magnitud (o valor absoluto) de un número complejo.

Phase

Obtiene la fase de un número complejo.

Real

Obtiene el componente real del objeto Complex actual.

Métodos

Abs(Complex)

Obtiene el valor absoluto (o magnitud) de un número complejo.

Acos(Complex)

Devuelve el ángulo que es el arco coseno del número complejo especificado.

Add(Complex, Complex)

Suma dos valores complejos y devuelve el resultado.

Add(Complex, Double)

Agrega un número complejo a un número real de doble precisión y devuelve el resultado.

Add(Double, Complex)

Agrega un número real de doble precisión a un número complejo y devuelve el resultado.

Asin(Complex)

Devuelve el ángulo que es el arco seno del número complejo especificado.

Atan(Complex)

Devuelve el ángulo que es el arco tangente del número complejo especificado.

Conjugate(Complex)

Calcula el conjugado de un número complejo y devuelve el resultado.

Cos(Complex)

Devuelve el coseno del número complejo especificado.

Cosh(Complex)

Devuelve el coseno hiperbólico del número complejo especificado.

Divide(Complex, Complex)

Divide un número complejo por otro y devuelve el resultado.

Divide(Complex, Double)

Divide un número complejo por un número real de doble precisión y devuelve el resultado.

Divide(Double, Complex)

Divide un número real de doble precisión por un número complejo y devuelve el resultado.

Equals(Complex)

Devuelve un valor que indica si la instancia actual y el número complejo especificado tienen el mismo valor.

Equals(Object)

Devuelve un valor que indica si la instancia actual y un objeto especificado tienen el mismo valor.

Exp(Complex)

Devuelve un e elevado a la potencia especificada por un número complejo.

FromPolarCoordinates(Double, Double)

Crea un número complejo a partir de las coordenadas polares de un punto.

GetHashCode()

Devuelve el código hash del objeto Complex actual.

IsComplexNumber(Complex)

Determina si un valor representa un valor complejo.

IsEvenInteger(Complex)

Determina si un valor representa un número entero par.

IsFinite(Complex)

Determina si el número complejo especificado es limitado.

IsImaginaryNumber(Complex)

Determina si un valor representa un número imaginario.

IsInfinity(Complex)

Devuelve un valor que indica si el número complejo especificado se evalúa como infinito.

IsInteger(Complex)

Determina si un valor representa un valor entero.

IsNaN(Complex)

Devuelve un valor que indica si la instancia compleja especificada no es un número (NaN).

IsNegative(Complex)

Determina si un valor es negativo.

IsNegativeInfinity(Complex)

Determina si un valor es infinito negativo.

IsNormal(Complex)

Determina si un valor es normal.

IsOddInteger(Complex)

Determina si un valor representa un número entero impar.

IsPositive(Complex)

Determina si un valor es positivo.

IsPositiveInfinity(Complex)

Determina si un valor es infinito positivo.

IsRealNumber(Complex)

Determina si un valor representa un número real.

IsSubnormal(Complex)

Determina si un valor es subnormal.

Log(Complex)

Devuelve el logaritmo natural (en la base e) del número complejo especificado.

Log(Complex, Double)

Devuelve el logaritmo del número complejo especificado en la base especificada.

Log10(Complex)

Devuelve el logaritmo en la base 10 del número complejo especificado.

MaxMagnitude(Complex, Complex)

Compara dos valores con el proceso, que es mayor.

MinMagnitude(Complex, Complex)

Compara dos valores con el proceso, que es menor.

Multiply(Complex, Complex)

Devuelve el producto de dos números complejos.

Multiply(Complex, Double)

Devuelve el producto de un número complejo y un número real de doble precisión.

Multiply(Double, Complex)

Devuelve el producto de un número real de doble precisión y un número complejo.

Negate(Complex)

Devuelve el inverso aditivo de un número complejo especificado.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Analiza un intervalo de caracteres en un valor.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Analiza un intervalo de caracteres en un valor.

Parse(String, IFormatProvider)

Analiza una cadena en un valor.

Parse(String, NumberStyles, IFormatProvider)

Analiza una cadena en un valor.

Pow(Complex, Complex)

Devuelve el número complejo especificado elevado a la potencia indicada por un número complejo.

Pow(Complex, Double)

Devuelve un número complejo especificado elevado a la potencia indicada por un número de punto flotante de precisión doble.

Reciprocal(Complex)

Devuelve el inverso multiplicativo de un número complejo.

Sin(Complex)

Devuelve el seno del número complejo especificado.

Sinh(Complex)

Devuelve el seno hiperbólico del número complejo especificado.

Sqrt(Complex)

Devuelve la raíz cuadrada del número complejo especificado.

Subtract(Complex, Complex)

Resta un número complejo de otro y devuelve el resultado.

Subtract(Complex, Double)

Resta un número real de doble precisión a un número complejo y devuelve el resultado.

Subtract(Double, Complex)

Resta un número complejo a un número real de doble precisión y devuelve el resultado.

Tan(Complex)

Devuelve la tangente del número complejo especificado.

Tanh(Complex)

Devuelve la tangente hiperbólica del número complejo especificado.

ToString()

Convierte el valor del actual número complejo a su representación de cadena equivalente en formato cartesiano.

ToString(IFormatProvider)

Convierte el valor del actual número complejo a su representación de cadena equivalente en formato cartesiano utilizando la información de formato específica de la referencia cultural indicada.

ToString(String)

Convierte el valor del actual número complejo a su representación de cadena equivalente en formato cartesiano utilizando el formato especificado para la parte real y la parte imaginaria.

ToString(String, IFormatProvider)

Convierte el valor del actual número complejo a su representación de cadena equivalente en formato cartesiano utilizando el formato especificado y la información de formato específica de la referencia cultural indicada para la parte real y la parte imaginaria.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Intenta dar formato al valor de la instancia actual en el intervalo de caracteres proporcionado.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Complex)

Intenta analizar un intervalo de caracteres en un valor.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Complex)

Intenta analizar un intervalo de caracteres en un valor.

TryParse(String, IFormatProvider, Complex)

Intenta analizar una cadena en un valor.

TryParse(String, NumberStyles, IFormatProvider, Complex)

Intenta analizar una cadena en un valor.

Operadores

Addition(Complex, Complex)

Suma dos números complejos.

Addition(Complex, Double)

Agrega un número complejo a un número real de doble precisión.

Addition(Double, Complex)

Agrega un número real de doble precisión a un número complejo.

Decrement(Complex)

Disminuye un valor.

Division(Complex, Complex)

Divide el número complejo especificado por otro.

Division(Complex, Double)

Divide un número complejo especificado por un número real de doble precisión especificado.

Division(Double, Complex)

Divide un número real de doble precisión especificado por un número complejo especificado.

Equality(Complex, Complex)

Devuelve un valor que indica si dos números complejos son iguales.

Explicit(BigInteger to Complex)

Define una conversión explícita de un valor BigInteger a un número complejo.

Explicit(Decimal to Complex)

Define una conversión explícita de un valor Decimal a un número complejo.

Explicit(Int128 to Complex)

Convierte explícitamente un Int128 valor en un número complejo de precisión doble.

Explicit(UInt128 to Complex)

Convierte explícitamente un UInt128 valor en un número complejo de precisión doble.

Implicit(Byte to Complex)

Define una conversión implícita de un byte sin signo en un número complejo.

Implicit(Char to Complex)

Convierte implícitamente un Char valor en un número complejo de precisión doble.

Implicit(Double to Complex)

Define una conversión implícita de un número de punto flotante de precisión doble en un número complejo.

Implicit(Half to Complex)

Convierte implícitamente un Half valor en un número complejo de precisión doble.

Implicit(Int16 to Complex)

Define una conversión implícita de un entero de 16 bits con signo en un número complejo.

Implicit(Int32 to Complex)

Define una conversión implícita de un entero de 32 bits con signo en un número complejo.

Implicit(Int64 to Complex)

Define una conversión implícita de un entero de 64 bits con signo en un número complejo.

Implicit(IntPtr to Complex)

Convierte implícitamente un IntPtr valor en un número complejo de precisión doble.

Implicit(SByte to Complex)

Define una conversión implícita de un byte con signo en un número complejo.

Esta API no es conforme a CLS.

Implicit(Single to Complex)

Define una conversión implícita de un número de punto flotante de precisión sencilla en un número complejo.

Implicit(UInt16 to Complex)

Define una conversión implícita de un entero de 16 bits sin signo en un número complejo.

Esta API no es conforme a CLS.

Implicit(UInt32 to Complex)

Define una conversión implícita de un entero de 32 bits sin signo en un número complejo.

Esta API no es conforme a CLS.

Implicit(UInt64 to Complex)

Define una conversión implícita de un entero de 64 bits sin signo en un número complejo.

Esta API no es conforme a CLS.

Implicit(UIntPtr to Complex)

Convierte implícitamente un UIntPtr valor en un número complejo de precisión doble.

Increment(Complex)

Incrementa un valor.

Inequality(Complex, Complex)

Devuelve un valor que indica si dos números complejos no son iguales.

Multiply(Complex, Complex)

Multiplica los dos números complejos especificados.

Multiply(Complex, Double)

Multiplica el número complejo especificado por un número real de doble precisión especificado.

Multiply(Double, Complex)

Multiplica un número real de doble precisión especificado por un número complejo especificado.

Subtraction(Complex, Complex)

Resta un número complejo de otro número complejo.

Subtraction(Complex, Double)

Resta un número real de doble precisión a un número complejo.

Subtraction(Double, Complex)

Resta un número complejo a un número real de doble precisión.

UnaryNegation(Complex)

Devuelve el inverso aditivo de un número complejo especificado.

UnaryPlus(Complex)

Calcula la unaria más de un valor.

Se aplica a