Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Complex structure

 

Date de publication : novembre 2016

Représente un nombre complexe.

Espace de noms:   System.Numerics
Assembly:  System.Numerics (dans System.Numerics.dll)

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

NomDescription
System_CAPS_pubmethodComplex(Double, Double)

Initialise une nouvelle instance de la Complex de la structure à l’aide des valeurs réelles et imaginaires spécifiées.

NomDescription
System_CAPS_pubpropertyImaginary

Obtient le composant imaginaire de l’utilisateur actuel Complex objet.

System_CAPS_pubpropertyMagnitude

Obtient l'ordre de grandeur (ou valeur absolue) d'un nombre complexe.

System_CAPS_pubpropertyPhase

Obtient la phase d'un nombre complexe.

System_CAPS_pubpropertyReal

Obtient le composant réel de l’utilisateur actuel Complex objet.

NomDescription
System_CAPS_pubmethodSystem_CAPS_staticAbs(Complex)

Obtient la valeur absolue (ou ordre de grandeur) d'un nombre complexe.

System_CAPS_pubmethodSystem_CAPS_staticAcos(Complex)

Retourne l'angle qui correspond au cosinus d'arc du nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticAdd(Complex, Complex)

Ajoute deux nombres complexes et retourne le résultat.

System_CAPS_pubmethodSystem_CAPS_staticAsin(Complex)

Retourne l'angle qui correspond au sinus d'arc du nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticAtan(Complex)

Retourne l'angle qui correspond à la tangente d'arc du nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticConjugate(Complex)

Calcule le conjugué d'un nombre complexe et retourne le résultat.

System_CAPS_pubmethodSystem_CAPS_staticCos(Complex)

Retourne le cosinus du nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticCosh(Complex)

Retourne le cosinus hyperbolique du nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticDivide(Complex, Complex)

Divise un nombre complexe par un autre et retourne le résultat.

System_CAPS_pubmethodEquals(Complex)

Retourne une valeur qui indique si l'instance actuelle et un nombre complexe spécifié ont la même valeur.

System_CAPS_pubmethodEquals(Object)

Retourne une valeur qui indique si l'instance actuelle et un objet spécifié ont la même valeur.(Remplace ValueType.Equals(Object).)

System_CAPS_pubmethodSystem_CAPS_staticExp(Complex)

Retourne e à la puissance spécifiée par un nombre complexe.

System_CAPS_pubmethodSystem_CAPS_staticFromPolarCoordinates(Double, Double)

Crée un nombre complexe à partir des coordonnées polaires d'un point.

System_CAPS_pubmethodGetHashCode()

Retourne le code de hachage pour l’actuel Complex objet.(Remplace ValueType.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodSystem_CAPS_staticLog(Complex)

Retourne le naturel (base e) logarithme d’un nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticLog(Complex, Double)

Retourne le logarithme d'un nombre complexe spécifié dans une base spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticLog10(Complex)

Retourne le logarithme de base 10 d'un nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticMultiply(Complex, Complex)

Retourne le produit de deux nombres complexes.

System_CAPS_pubmethodSystem_CAPS_staticNegate(Complex)

Retourne l'inverse additif d'un nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticPow(Complex, Complex)

Retourne un nombre complexe spécifié élevé à une puissance spécifiée par un nombre complexe.

System_CAPS_pubmethodSystem_CAPS_staticPow(Complex, Double)

Retourne un nombre complexe spécifié élevé à une puissance spécifiée par un nombre à virgule flottante double précision.

System_CAPS_pubmethodSystem_CAPS_staticReciprocal(Complex)

Retourne l'inverse multiplicatif d'un nombre complexe.

System_CAPS_pubmethodSystem_CAPS_staticSin(Complex)

Retourne le sinus du nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticSinh(Complex)

Retourne le sinus hyperbolique du nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticSqrt(Complex)

Retourne la racine carrée d'un nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticSubtract(Complex, Complex)

Soustrait un nombre complexe d'un autre et retourne le résultat.

System_CAPS_pubmethodSystem_CAPS_staticTan(Complex)

Retourne la tangente du nombre complexe spécifié.

System_CAPS_pubmethodSystem_CAPS_staticTanh(Complex)

Retourne la tangente hyperbolique du nombre complexe spécifié.

System_CAPS_pubmethodToString()

Convertit la valeur du nombre complexe actuel en sa représentation sous forme de chaîne équivalente au format cartésien.(Remplace ValueType.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Convertit la valeur du nombre complexe actuel en sa représentation sous forme de chaîne équivalente au format cartésien à l'aide des informations de mise en forme propres à la culture spécifiées.

System_CAPS_pubmethodToString(String)

Convertit la valeur du nombre complexe actuel en sa représentation sous forme de chaîne équivalente au format cartésien en utilisant le format spécifié pour ses parties imaginaire et réelle.

System_CAPS_pubmethodToString(String, IFormatProvider)

Convertit la valeur du nombre complexe actuel en sa représentation sous forme de chaîne équivalente au format cartésien en utilisant le format et les informations de mise en forme spécifiques à la culture spécifiés pour ses parties imaginaire et réelle.

NomDescription
System_CAPS_pubfieldSystem_CAPS_staticImaginaryOne

Retourne un nouveau Complex instance avec un nombre réel égal à zéro et un nombre imaginaire égal à un.

System_CAPS_pubfieldSystem_CAPS_staticOne

Retourne un nouveau Complex instance avec un nombre réel égal à un et un nombre imaginaire égal à zéro.

System_CAPS_pubfieldSystem_CAPS_staticZero

Retourne un nouveau Complex instance avec un nombre réel égal à zéro et un nombre imaginaire égal à zéro.

NomDescription
System_CAPS_puboperatorSystem_CAPS_staticAddition(Complex, Complex)

Ajoute deux nombres complexes.

System_CAPS_puboperatorSystem_CAPS_staticDivision(Complex, Complex)

Divise un nombre complexe spécifié par un autre nombre complexe spécifié.

System_CAPS_puboperatorSystem_CAPS_staticEquality(Complex, Complex)

Retourne une valeur qui indique si deux nombres complexes sont égaux.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(BigInteger to Complex)

Définit une conversion explicite d’un BigInteger valeur en un nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticExplicit(Decimal to Complex)

Définit une conversion explicite d’un Decimal valeur en un nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Byte to Complex)

Définit une conversion implicite d'un octet non signé en nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Double to Complex)

Définit une conversion implicite d'un nombre à virgule flottante double précision en un nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int16 to Complex)

Définit une conversion implicite d'un entier 16 bits signé en nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int32 to Complex)

Définit une conversion implicite d'un entier 32 bits signé en nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Int64 to Complex)

Définit une conversion implicite d'un entier 64 bits signé en nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(SByte to Complex)

Définit une conversion implicite d'un octet signé en nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(Single to Complex)

Définit une conversion implicite d'un nombre à virgule flottante simple précision en un nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt16 to Complex)

Définit une conversion implicite d'un entier 16 bits non signé en nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt32 to Complex)

Définit une conversion implicite d'un entier 32 bits non signé en nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticImplicit(UInt64 to Complex)

Définit une conversion implicite d'un entier 64 bits non signé en nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticInequality(Complex, Complex)

Retourne une valeur qui indique si deux nombres complexes sont différents.

System_CAPS_puboperatorSystem_CAPS_staticMultiply(Complex, Complex)

Multiplie deux nombres complexes spécifiés.

System_CAPS_puboperatorSystem_CAPS_staticSubtraction(Complex, Complex)

Soustrait un nombre complexe d'un autre nombre complexe.

System_CAPS_puboperatorSystem_CAPS_staticUnaryNegation(Complex)

Retourne l'inverse additif d'un nombre complexe spécifié.

A complex number is a number that comprises a real number part and an imaginary number part. 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. The real part of the complex number is represented by x, and the imaginary part of the complex number is represented by y.

The T:System.Numerics.Complex type uses the Cartesian coordinate system (real, imaginary) when instantiating and manipulating complex numbers. A complex number can be represented as a point in a two-dimensional coordinate system, which is known as the complex plane. 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).

Any point in the complex plane can also be expressed based on its absolute value, by using the polar coordinate system., In polar coordinates, a point is characterized by two numbers:

  • 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).

  • Its phase, which is the angle between the real axis and the line drawn from the origin to the point.

You can assign a value to a complex number in one of the following ways:

  • By passing two T:System.Double values to its constructor. The first value represents the real part of the complex number, and the second value represents its imaginary part. These values represent the position of the complex number in the two-dimensional Cartesian coordinate system.

  • By calling the static (Shared in Visual Basic) M:System.Numerics.Complex.FromPolarCoordinates(System.Double,System.Double) method to create a complex number from its polar coordinates.

  • By assigning a T:System.Byte, T:System.SByte, T:System.Int16, T:System.UInt16, T:System.Int32, T:System.UInt32, T:System.Int64, T:System.UInt64, T:System.Single, or T:System.Double value to a T:System.Numerics.Complex object. The value becomes the real part of the complex number, and its imaginary part equals 0.

  • By casting (in C#) or converting (in Visual Basic) a T:System.Decimal or T:System.Numerics.BigInteger value to a T:System.Numerics.Complex object. The value becomes the real part of the complex number, and its imaginary part equals 0.

  • By assigning the complex number that is returned by a method or operator to a T:System.Numerics.Complex object. For example, M:System.Numerics.Complex.Add(System.Numerics.Complex,System.Numerics.Complex) is a static method that returns a complex number that is the sum of two complex numbers, and the M:System.Numerics.Complex.op_Addition(System.Numerics.Complex,System.Numerics.Complex) operator adds two complex numbers and returns the result.

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)

The T:System.Numerics.Complex structure in the .NET Framework includes members that provide the following functionality:

  • Methods to compare two complex numbers to determine whether they are equal.

  • Operators to perform arithmetic operations on complex numbers. T:System.Numerics.Complex operators enable you to perform addition, subtraction, multiplication, division, and unary negation with complex numbers.

  • Methods to perform other numerical operations on complex numbers. 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.

  • Methods to perform trigonometric operations on complex numbers. For example, you can calculate the tangent of an angle represented by a complex number.

Note that, because the P:System.Numerics.Complex.Real and P:System.Numerics.Complex.Imaginary properties are read-only, you cannot modify the value of an existing T:System.Numerics.Complex object. All methods that perform an operation on a T:System.Numerics.Complex number, if their return value is of type T:System.Numerics.Complex, return a new T:System.Numerics.Complex number.

The real and imaginary parts of a complex number are represented by two double-precision floating-point values. This means that T:System.Numerics.Complex values, like double-precision floating-point values, can lose precision as a result of numerical operations. This means that strict comparisons for equality of two T:System.Numerics.Complex values may fail, even if the difference between the two values is due to a loss of precision. For more information, see T:System.Double.

For example, performing exponentiation on the logarithm of a number should return the original number. 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

Similarly, the following example, which calculates the square root of a T:System.Numerics.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.

The real and imaginary parts of a complex number are represented by T:System.Double values. In addition to ranging from F:System.Double.MinValue to F:System.Double.MaxValue, the real or imaginary part of a complex number can have a value of F:System.Double.PositiveInfinity, F:System.Double.NegativeInfinity, or F:System.Double.NaN. F:System.Double.PositiveInfinity, F:System.Double.NegativeInfinity, and F:System.Double.NaN all propagate in any arithmetic or trigonometric operation.

In the following example, division by F:System.Numerics.Complex.Zero produces a complex number whose real and imaginary parts are both F:System.Double.NaN. As a result, performing multiplication with this value also produces a complex number whose real and imaginary parts are F:System.Double.NaN. Similarly, performing a multiplication that overflows the range of the T:System.Double type produces a complex number whose real part is F:System.Double.NaN and whose imaginary part is F:System.Double.PositiveInfinity. Subsequently performing division with this complex number returns a complex number whose real part is F:System.Double.NaN and whose imaginary part is F:System.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)

Mathematical operations with complex numbers that are invalid or that overflow the range of the T:System.Double data type do not throw an exception. Instead, they return a F:System.Double.PositiveInfinity, F:System.Double.NegativeInfinity, or F:System.Double.NaN under the following conditions:

  • The division of a positive number by zero returns F:System.Double.PositiveInfinity.

  • Any operation that overflows the upper bound of the T:System.Double data type returns F:System.Double.PositiveInfinity.

  • The division of a negative number by zero returns F:System.Double.NegativeInfinity.

  • Any operation that overflows the lower bound of the T:System.Double data type returns F:System.Double.NegativeInfinity.

  • The division of a zero by zero returns F:System.Double.NaN.

  • Any operation that is performed on operands whose values are F:System.Double.PositiveInfinity, F:System.Double.NegativeInfinity, or F:System.Double.NaN returns F:System.Double.PositiveInfinity, F:System.Double.NegativeInfinity, or F:System.Double.NaN, depending on the specific operation.

Note that this applies to any intermediate calculations performed by a method. For example, the multiplication of new Complex(9e308, 9e308) and new Complex(2.5, 3.5) uses the formula (ac - bd) + (ad + bc)i. The calculation of the real component that results from the multiplication evaluates the expression 9e308 * 2.5 - 9e308 * 3.5. Each intermediate multiplication in this expression returns F:System.Double.PositiveInfinity, and the attempt to subtract F:System.Double.PositiveInfinity from F:System.Double.PositiveInfinity returns F:System.Double.NaN.

By default, the string representation of a complex number takes the form (real, imaginary), where real and imaginary are the string representations of the T:System.Double values that form the complex number's real and imaginary components. Some overloads of the Overload:System.Numerics.Complex.ToString method allow customization of the string representations of these T:System.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. (For more information, see Standard Numeric Format Strings and Custom Numeric Format Strings.)

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. In electrical engineering, a complex number is most commonly expressed as a + bj. You can return the string representation of a complex number in either of these two forms. To do this, define a custom format provider by implementing the T:System.ICustomFormatter and T:System.IFormatProvider interfaces, and then call the M:System.String.Format(System.IFormatProvider,System.String,System.Object[]) method.

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;
      }                        
   }
}

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

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 4.0
Windows Phone
Disponible depuis 8.1

Tous les membres statiques publics ( Shared en Visual Basic) de ce type sont thread-safe. Les membres d’instance n’ont pas la garantie d’être thread-safe.

Retour au début
Afficher: