Complex, structure

Vous pouvez assigner une valeur à un nombre complexe de l'une des manières suivantes :

• En passant deux valeurs Double à son constructeur. La première valeur représente la vraie partie du nombre complexe, et la deuxième valeur représente sa partie imaginaire. Ces valeurs représentent la position du nombre complexe dans le système de coordonnées cartésien à deux dimensions.

• En appelant la méthode Complex.FromPolarCoordinates statique (Shared en Visual Basic) pour créer un nombre complexe à partir de ses coordonnées polaires.

• En assignant une valeur Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single ou Double à un objet Complex. La valeur devient la vraie partie du nombre complexe, et sa partie imaginaire est égale à 0.

• En castant (en C#) ou convertissant (en Visual Basic) une valeur Decimal ou BigInteger en un objet Complex. La valeur devient la vraie partie du nombre complexe, et sa partie imaginaire est égale à 0.

• En assignant le nombre complexe retourné par une méthode ou un opérateur à un objet Complex. Par exemple, Complex.Add est une méthode statique qui retourne un nombre complexe qui est la somme de deux nombres complexes, et l'opérateur Complex.Addition ajoute deux nombres complexes et retourne le résultat.

L'exemple suivant montre chacune de ces cinq façons d'assigner une valeur à un nombre complexe.

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)

La structure Complex dans le .NET Framework inclut des membres qui fournissent les fonctionnalités suivantes :

• Méthodes pour comparer deux nombres complexes et déterminer s'ils sont égaux.

• Opérateurs pour exécuter des opérations arithmétiques sur les nombres complexes. Les opérateurs Complex vous permettent d'effectuer des additions, soustractions, multiplications, divisions et opérations NON unaires avec des nombres complexes.

• Méthodes pour exécuter d'autres opérations numériques sur les nombres complexes. En plus de quatre opérations arithmétiques fondamentales, vous pouvez élever un nombre complexe à une puissance spécifiée, rechercher la racine carrée d'un nombre complexe et obtenir la valeur absolue d'un nombre complexe.

• Méthodes pour exécuter des opérations trigonométriques sur les nombres complexes. Par exemple, vous pouvez calculer la tangente d'un angle représentée par un nombre complexe.

Les parties imaginaire et réelle d'un nombre complexe sont représentées par deux valeurs à virgule flottante double précision. Cela signifie que les valeurs Complex, comme les valeurs à virgule flottante double précision, peuvent perdre la précision à la suite d'opérations numériques. Cela signifie que les comparaisons strictes pour l'égalité de deux valeurs Complex peuvent échouer, même si la différence entre les deux valeurs est due à une perte de précision. Pour plus d'informations, consultez Double.

Par exemple, l'exécution de l'élévation à la puissance du logarithme d'un nombre doit retourner le nombre d'origine. Toutefois, la perte de précision de valeurs à virgule flottante peut provoquer dans certains cas de légères différences entre les deux valeurs, comme le montre l'exemple suivant.

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 la même façon, l'exemple suivant, qui calcule la racine carrée d'un nombre Complex, produit des résultats légèrement différents sur les versions 32 bits et IA64 du .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.

Les parties imaginaire et réelle d'un nombre complexe sont représentées par les valeurs Double. En plus de s'étendre de Double.MinValue à Double.MaxValue, la partie réelle ou imaginaire d'un nombre complexe peut avoir la valeur Double.PositiveInfinity, Double.NegativeInfinity ou Double.NaN. Double.PositiveInfinity , Double.NegativeInfinity et Double.NaN propagent tous dans toutes les opérations arithmétiques ou trigonométriques.

Dans l'exemple suivant, la division par Zero produit un nombre complexe dont les parties réelles et imaginaires sont toutes deux Double.NaN. Par conséquent, l'exécution de la multiplication avec cette valeur produit également un nombre complexe dont les parties réelles et imaginaires sont Double.NaN. De la même façon, l'exécution d'une multiplication qui dépasse la plage du type Double produit un nombre complexe dont la partie réelle est Double.NaN et la partie imaginaire Double.PositiveInfinity. Par la suite, le fait d'effectuer une division avec ce nombre complexe retourne un nombre complexe dont la partie réelle est Double.NaN et dont la partie imaginaire est 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)

Les opérations mathématiques avec des nombres complexes qui ne sont pas valides ou qui dépassent la plage du type de données Double ne lèvent pas d'exception. À la place, elles retournent un Double.PositiveInfinity, Double.NegativeInfinity ou Double.NaN sous les conditions suivantes :

• La division d'un nombre positif par zéro retourne Double.PositiveInfinity.

• Toute opération qui dépasse la limite supérieure du type de données Double retourne Double.PositiveInfinity.

• La division d'un nombre négatif par zéro retourne Double.NegativeInfinity.

• Toute opération qui dépasse la limite inférieure du type de données Double retourne Double.NegativeInfinity.

• La division d'un zéro par zéro retourne Double.NaN.

• Toute opération exécutée sur les opérandes dont les valeurs sont Double.PositiveInfinity, Double.NegativeInfinity ou Double.NaN retourne Double.PositiveInfinity, Double.NegativeInfinity ou Double.NaN, selon l'opération.

Notez que cela s'applique à tous les calculs intermédiaires exécutés par une méthode. Par exemple, la multiplication de new Complex(9e308, 9e308) and new Complex(2.5, 3.5) utilise la formule (ac - bd) + (ad + bc)i. Le calcul du vrai composant qui résulte de la multiplication évalue l'expression 9e308 * 2.5 - 9e308 * 3.5. Chaque multiplication intermédiaire dans cette expression retourne Double.PositiveInfinity, et la tentative de soustraction Double.PositiveInfinity de Double.PositiveInfinity retourne Double.NaN.

Par défaut, la représentation sous forme de chaîne d'un nombre complexe prend la forme (réel, imaginaire), où réel et imaginaire sont les représentations sous forme de chaînes des valeurs Double qui forment les composants réels et imaginaires du nombre complexe. Certaines surcharges de la méthode ToString permettent à la personnalisation des représentations sous forme de chaîne de ces valeurs Double de refléter les conventions de mise en forme d'une culture particulière ou de s'afficher dans un format particulier défini par une chaîne de format numérique standard ou personnalisée. (Pour plus d'informations, consultez Chaînes de format numériques standard et Chaînes de format numériques personnalisées).

L'une des façons les plus courantes d'exprimer la représentation sous forme de chaîne d'un nombre complexe prend la forme a + bi, où a est le composant réel du nombre complexe et b le composant imaginaire du nombre complexe. En génie électrique, un nombre complexe est le plus souvent exprimé sous la forme a + bj. Vous pouvez retourner la représentation sous forme de chaîne d'un nombre complexe dans l'une ou l'autre de ces formes. Pour cela, définissez un fournisseur de format personnalisé en implémentant les interfaces ICustomFormatter et IFormatProvider, puis appelez la méthode String.Format(IFormatProvider, String, Object[]).

L'exemple suivant définit une classe ComplexFormatter qui représente un nombre complexe comme une chaîne sous la forme a + bi ou 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;
      }                        
   }
}

L'exemple suivant utilise ensuite ce formateur personnalisé pour afficher la représentation sous forme de chaîne d'un nombre complexe.

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