Complex Estructura
Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Complex (Estructura)

 

Representa un número complejo.

Espacio de nombres:   System.Numerics
Ensamblado:  System.Numerics (en System.Numerics.dll)

[SerializableAttribute]
public struct Complex : IEquatable<Complex>, IFormattable

NombreDescripción
System_CAPS_pubmethodComplex(Double, Double)

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

NombreDescripción
System_CAPS_pubpropertyImaginary

Obtiene el componente imaginario del objeto Complex actual.

System_CAPS_pubpropertyMagnitude

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

System_CAPS_pubpropertyPhase

Obtiene la fase de un número complejo.

System_CAPS_pubpropertyReal

Obtiene el componente real del objeto Complex actual.

NombreDescripción
System_CAPS_pubmethodSystem_CAPS_staticAbs(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticAcos(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticAdd(Complex, Complex)

Suma dos valores complejos y devuelve el resultado.

System_CAPS_pubmethodSystem_CAPS_staticAsin(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticAtan(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticConjugate(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticCos(Complex)

Devuelve el coseno del número complejo especificado.

System_CAPS_pubmethodSystem_CAPS_staticCosh(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticDivide(Complex, Complex)

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

System_CAPS_pubmethodEquals(Complex)

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

System_CAPS_pubmethodEquals(Object)

Devuelve un valor que indica si la instancia actual y un objeto especificado tienen el mismo valor.(Reemplaza a ValueType.Equals(Object)).

System_CAPS_pubmethodSystem_CAPS_staticExp(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticFromPolarCoordinates(Double, Double)

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

System_CAPS_pubmethodGetHashCode()

Devuelve el código hash del objeto Complex actual.(Reemplaza a ValueType.GetHashCode()).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object.)

System_CAPS_pubmethodSystem_CAPS_staticLog(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticLog(Complex, Double)

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

System_CAPS_pubmethodSystem_CAPS_staticLog10(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticMultiply(Complex, Complex)

Devuelve el producto de dos números complejos.

System_CAPS_pubmethodSystem_CAPS_staticNegate(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticPow(Complex, Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticPow(Complex, Double)

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

System_CAPS_pubmethodSystem_CAPS_staticReciprocal(Complex)

Devuelve el inverso multiplicativo de un número complejo.

System_CAPS_pubmethodSystem_CAPS_staticSin(Complex)

Devuelve el seno del número complejo especificado.

System_CAPS_pubmethodSystem_CAPS_staticSinh(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticSqrt(Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticSubtract(Complex, Complex)

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

System_CAPS_pubmethodSystem_CAPS_staticTan(Complex)

Devuelve la tangente del número complejo especificado.

System_CAPS_pubmethodSystem_CAPS_staticTanh(Complex)

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

System_CAPS_pubmethodToString()

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

System_CAPS_pubmethodToString(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.

System_CAPS_pubmethodToString(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.

System_CAPS_pubmethodToString(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.

NombreDescripción
System_CAPS_pubfieldSystem_CAPS_staticImaginaryOne

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

System_CAPS_pubfieldSystem_CAPS_staticOne

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

System_CAPS_pubfieldSystem_CAPS_staticZero

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

NombreDescripción
System_CAPS_puboperatorSystem_CAPS_staticAddition(Complex, Complex)

Suma dos números complejos.

System_CAPS_puboperatorSystem_CAPS_staticDivision(Complex, Complex)

Divide el número complejo especificado por otro.

System_CAPS_puboperatorSystem_CAPS_staticEquality(Complex, Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Decimal to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Byte to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticImplicit(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.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int16 to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int32 to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int64 to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticImplicit(SByte to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticImplicit(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.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt16 to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt32 to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt64 to Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticInequality(Complex, Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticMultiply(Complex, Complex)

Multiplica los dos números complejos especificados.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(Complex, Complex)

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

System_CAPS_puboperatorSystem_CAPS_staticUnaryNegation(Complex)

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

Un número complejo es un número que consta de un número real y un número imaginario. Un número complejo z se escriben normalmente en forma z = x + yi, donde x y y son números reales, y es la unidad imaginaria que tiene la propiedad 2 = -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 utiliza 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 el plano complejo. La parte real del número complejo se coloca en el eje x (el eje horizontal) y la parte imaginaria se coloca en el eje y (el eje vertical).

También puede expresar en cualquier punto en el plano complejo según su valor absoluto, usando el polar sistema de coordenadas., 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 se cruzan el eje x y el eje y).

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

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

  • Pasando 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 a estático (Shared en Visual Basic) Complex.FromPolarCoordinates método para crear un número complejo a partir de sus coordenadas polares.

  • Asignando un Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, o Double valor a un Complex objeto. El valor se convierte en la parte real del número complejo y su parte imaginaria es igual a 0.

  • Conversión (en C#) o convirtiendo (en Visual Basic) un Decimal o BigInteger valor a 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 que es devuelto por un método u 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 de suma dos números complejos y devuelve el resultado.

En el ejemplo siguiente se muestra cada una de estas cinco maneras 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)

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

  • 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 suma, resta, 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 la Real y Imaginary propiedades son de sólo lectura, no se puede modificar el valor de un miembro de Complex objeto. Todos los métodos que realizan una operación en un Complex número, si su valor devuelto es de tipo Complex, devolver un nuevo Complex número.

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 valores, como valores de punto flotante de precisión doble, pueden perder precisión como resultado de operaciones numéricas. Esto significa que estricta comparaciones de igualdad de dos Complex valores pueden fallar, incluso si la diferencia entre los dos valores es debido a una pérdida de precisión. Para obtener más información, consulta Double.

Por ejemplo, al realizar 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 valores de punto flotante puede producir ligeras 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

De forma similar, el ejemplo siguiente, que calcula la raíz cuadrada de un Complex número, genera resultados ligeramente diferentes en las versiones de IA64 de .NET Framework y de 32 bits.

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.

Se representan las partes reales e imaginarias de un número complejo por Double valores. Además de que van desde Double.MinValue a Double.MaxValue, la parte real o imaginaria de un número complejo puede tener un valor de Double.PositiveInfinity, Double.NegativeInfinity, o Double.NaN. Double.PositiveInfinity, Double.NegativeInfinity, y Double.NaN todos se propagan en cualquier operación aritmética o trigonométrica.

En el ejemplo siguiente, la división por Zero genera un número complejo cuyas partes reales e imaginarias son Double.NaN. Como resultado, realizar la multiplicación con este valor también genera un número complejo cuyas partes reales e imaginarias son Double.NaN. De forma similar, realizar una multiplicación que desborda el intervalo de la Double tipo genera un número complejo cuya parte real es Double.NaN y cuya parte imaginaria es Double.PositiveInfinity. Al realizar 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)

Operaciones matemáticas con números complejos que no son válidos o que desbordan el intervalo de la Double tipo de datos no producen una excepción. En su lugar, devuelven un Double.PositiveInfinity, Double.NegativeInfinity, o Double.NaN en las siguientes condiciones:

Tenga en cuenta que esto se aplica a cualquier cálculo intermedio realizado por un método. Por ejemplo, la multiplicación de new Complex(9e308, 9e308) and new Complex(2.5, 3.5) utiliza la fórmula de (ac - bd) + (ad + bc)i. El cálculo del componente real que es el resultado de la multiplicación evalúa la expresión 9e308 * 2.5 - 9e308 * 3.5. Cada multiplicación intermedia en esta expresión devuelve Double.PositiveInfinity, y el intento para restar Double.PositiveInfinity de Double.PositiveInfinity devuelve Double.NaN.

De forma predeterminada, la representación de cadena de un número complejo toma la forma (real, imaginario), donde real y imaginario son las representaciones de cadena de la Double valores que forman los componentes reales e imaginarios del número complejo. Algunas sobrecargas de los ToString método permite la personalización de las representaciones de cadena de estos Double valores para reflejar las convenciones de formato de una referencia cultural determinada o en un formato concreto que se define mediante una cadena de formato numérico estándar o personalizado. (Para obtener más información, consulta Cadenas con formato numérico estándar y Cadenas con formato numérico personalizado).

Una de las maneras más comunes de expresar la representación de cadena de un número complejo toma la forma a + bi, donde a 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 a + bj. Puede devolver la representación de cadena de un número complejo en cualquiera de estas dos formas. Para ello, defina un proveedor de formato personalizado implementando la ICustomFormatter y IFormatProvider interfaces y, a continuación, llame el String.Format(IFormatProvider, String, Object[]) método.

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

El ejemplo siguiente utiliza a 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

Universal Windows Platform
Disponible desde 8
.NET Framework
Disponible desde 4.0
Portable Class Library
Compatible con: portable .NET platforms
Silverlight
Disponible desde 4.0
Windows Phone
Disponible desde 8.1

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Volver al principio
Mostrar:
© 2016 Microsoft