Struct System.Numerics.Complex
Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.
Un nombre complexe est un nombre qui comprend une partie numérique réelle et une partie de nombre imaginaire. Un nombre complexe z est généralement écrit sous la forme z = x + yi, où x et y sont des nombres réels, et i est l’unité imaginaire qui a la propriété i2 = -1. La partie réelle du nombre complexe est représentée par x, et la partie imaginaire du nombre complexe est représentée par y.
Le Complex type utilise le système de coordonnées cartesiens (réel, imaginaire) lors de l’instanciation et de la manipulation de nombres complexes. Un nombre complexe peut être représenté comme un point dans un système de coordonnées à deux dimensions, appelé plan complexe. La partie réelle du nombre complexe est positionnée sur l’axe x (l’axe horizontal) et la partie imaginaire est positionnée sur l’axe y (l’axe vertical).
Tout point du plan complexe peut également être exprimé en fonction de sa valeur absolue, à l’aide du système de coordonnées polaires. En coordonnées polaires, un point est caractérisé par deux nombres :
- Sa magnitude, qui est la distance du point de l’origine (autrement dit, 0,0, ou le point auquel l’axe x et l’axe y se croisent).
- Sa phase, qui est l’angle entre l’axe réel et la ligne dessinée de l’origine jusqu’au point.
Instancier un nombre complexe
Vous pouvez affecter une valeur à un nombre complexe de l’une des manières suivantes :
En passant deux Double valeurs à son constructeur. La première valeur représente la partie réelle du nombre complexe, et la seconde 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 statique (
Shareden Visual Basic) Complex.FromPolarCoordinates pour créer un nombre complexe à partir de ses coordonnées polaires.En affectant un Byte, SByteInt16UInt16, Int64Int32UInt64SingleUInt32ou Double valeur à un Complex objet. La valeur devient la partie réelle du nombre complexe, et sa partie imaginaire est égale à 0.
En cas de conversion (en C#) ou de conversion (en Visual Basic) d’une Decimal ou BigInteger d’une valeur en objet Complex . La valeur devient la partie réelle du nombre complexe, et sa partie imaginaire est égale à 0.
En affectant le nombre complexe retourné par une méthode ou un opérateur à un Complex objet. Par exemple, Complex.Add est une méthode statique qui retourne un nombre complexe qui correspond à la somme de deux nombres complexes, et l’opérateur Complex.Addition ajoute deux nombres complexes et retourne le résultat.
L’exemple suivant illustre chacune de ces cinq façons d’affecter une valeur à un nombre complexe.
using System;
using System.Numerics;
public class CreateEx
{
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)
Opérations avec des nombres complexes
La Complex structure dans .NET inclut des membres qui fournissent les fonctionnalités suivantes :
- Méthodes de comparaison de deux nombres complexes pour déterminer s’ils sont égaux.
- Opérateurs pour effectuer des opérations arithmétiques sur des nombres complexes. Complex les opérateurs vous permettent d’effectuer l’addition, la soustraction, la multiplication, la division et la négation unaire avec des nombres complexes.
- Méthodes permettant d’effectuer d’autres opérations numériques sur des nombres complexes. En plus des quatre opérations arithmétiques de base, vous pouvez élever un nombre complexe à une puissance spécifiée, trouver la racine carrée d’un nombre complexe et obtenir la valeur absolue d’un nombre complexe.
- Méthodes pour effectuer des opérations trigonométriques sur des nombres complexes. Par exemple, vous pouvez calculer la tangente d’un angle représenté par un nombre complexe.
Notez que, étant donné que les propriétés et Imaginary les Real propriétés sont en lecture seule, vous ne pouvez pas modifier la valeur d’un objet existantComplex. Toutes les méthodes qui effectuent une opération sur un Complex nombre, si leur valeur de retour est de type Complex, retournent un nouveau Complex nombre.
Nombres de précision et complexes
Les parties réelles et imaginaires d’un nombre complexe sont représentées par deux valeurs à virgule flottante double précision. Cela signifie que les Complex valeurs, comme les valeurs à virgule flottante double précision, peuvent perdre de la précision en raison d’opérations numériques. Cela signifie que les comparaisons strictes pour l’égalité de deux Complex valeurs 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’exponentiation sur le logarithme d’un nombre doit retourner le nombre d’origine. Toutefois, dans certains cas, la perte de précision des valeurs à virgule flottante peut entraîner de légères différences entre les deux valeurs, comme l’illustre 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
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
De même, l’exemple suivant, qui calcule la racine carrée d’un Complex nombre, produit des résultats légèrement différents sur les versions 32 bits et IA64 de .NET.
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.
Infini et NaN
Les parties réelles et imaginaires d’un nombre complexe sont représentées par Double des valeurs. En plus de passer de Double.MinValue à Double.MaxValue, la partie réelle ou imaginaire d’un nombre complexe peut avoir une valeur , Double.PositiveInfinityDouble.NegativeInfinityou Double.NaN. Double.PositiveInfinity, Double.NegativeInfinityet Double.NaN tous se propagent dans n’importe quelle opération arithmétique ou trigonométrique.
Dans l’exemple suivant, la division produit Zero un nombre complexe dont les parties réelles et imaginaires sont à la fois Double.NaN. Par conséquent, l’exécution d’une multiplication avec cette valeur produit également un nombre complexe dont les parties réelles et imaginaires sont Double.NaN. De même, l’exécution d’une multiplication qui dépasse la plage du type produit un nombre complexe dont la Double partie réelle est Double.NaN et dont la partie imaginaire est Double.PositiveInfinity. Par la suite, l’exécution d’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 NaNEx
{
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 Example4
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)
Les opérations mathématiques avec des nombres complexes non valides ou qui dépassent la plage du Double type de données ne lèvent pas d’exception. Au lieu de cela, ils retournent un Double.PositiveInfinity, Double.NegativeInfinityou Double.NaN dans 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 Double type de données 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 Double type de données 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.NegativeInfinityou Double.NaN retourne Double.PositiveInfinity, ou retourne , Double.NegativeInfinityou Double.NaN, en fonction de l’opération spécifique.
Notez que cela s’applique aux calculs intermédiaires effectués par une méthode. Par exemple, la multiplication des utilisations de new Complex(9e308, 9e308) and new Complex(2.5, 3.5) la formule (ac - bd) + (ad + bc)i. Le calcul du composant réel 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 des Double.PositiveInfinity retours Double.NaN.
Mettre en forme un nombre complexe
Par défaut, la représentation sous forme de chaîne d’un nombre complexe prend la forme (imaginaire réelle, où les représentations réelles ),et imaginaires sont les représentations sous forme de chaînes des Double valeurs qui forment les composants réels et imaginaires du nombre complexe. Certaines surcharges de la ToString méthode permettent de personnaliser les représentations sous forme de chaînes de ces Double valeurs afin de refléter les conventions de mise en forme d’une culture particulière ou d’apparaître 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érique standard et chaînes de format numérique 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ù un est le composant réel du nombre complexe, et b est le composant imaginaire du nombre complexe. Dans l’ingénierie électrique, un nombre complexe est le plus souvent exprimé sous la forme d’un + bj. Vous pouvez retourner la représentation sous forme de chaîne d’un nombre complexe dans l’une de ces deux formes. Pour ce faire, définissez un fournisseur de format personnalisé en implémentant les interfaces et IFormatProvider les ICustomFormatter interfaces, puis appelez la String.Format(IFormatProvider, String, Object[]) méthode.
L’exemple suivant définit une ComplexFormatter classe qui représente un nombre complexe sous la forme d’une chaîne sous la forme d’un + bi ou d’un + 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
L’exemple suivant utilise ensuite ce formateur personnalisé pour afficher la représentation sous forme de chaîne d’un nombre complexe.
public class CustomFormatEx
{
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 Example2
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
