Complex Complex Complex Complex Struct

Définition

Représente un nombre complexe.Represents a complex number.

public value class Complex : IEquatable<System::Numerics::Complex>, IFormattable
[System.Serializable]
public struct Complex : IEquatable<System.Numerics.Complex>, IFormattable
type Complex = struct
    interface IFormattable
Public Structure Complex
Implements IEquatable(Of Complex), IFormattable
Héritage
Attributs
Implémente

Remarques

Un nombre complexe est un nombre qui comprend une partie réelle et une partie imaginaire.A complex number is a number that comprises a real number part and an imaginary number part. 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.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. La partie réelle du nombre complexe est représentée par xet la partie imaginaire du nombre complexe est représentée par y.The real part of the complex number is represented by x, and the imaginary part of the complex number is represented by y.

Le Complex type utilise le système de coordonnées cartésien (réel, imaginaire) lors de l’instanciation et de la manipulation de nombres complexes.The Complex type uses the Cartesian coordinate system (real, imaginary) when instantiating and manipulating complex numbers. Un nombre complexe peut être représenté sous la forme d’un point dans un système de coordonnées à deux dimensions, appelé plan complexe.A complex number can be represented as a point in a two-dimensional coordinate system, which is known as the complex plane. La partie réelle du nombre complexe est positionnée sur l’axe des x (axe horizontal) et la partie imaginaire est positionnée sur l’axe des y (axe vertical).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).

Tout point dans le plan complexe peut également être exprimé en fonction de sa valeur absolue, à l’aide du système de coordonnées polaires.Any point in the complex plane can also be expressed based on its absolute value, by using the polar coordinate system. Dans les coordonnées polaires, un point est caractérisé par deux nombres:In polar coordinates, a point is characterized by two numbers:

  • Amplitude, qui est la distance entre le point et l’origine (autrement dit, 0, 0, ou le point d’intersection de l’axe des x et de l’axe des y).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).

  • Sa phase, qui est l’angle entre l’axe réel et la ligne dessinée de l’origine jusqu’au point.Its phase, which is the angle between the real axis and the line drawn from the origin to the point.

Instanciation d’un nombre complexeInstantiating a Complex Number

Vous pouvez affecter une valeur à un nombre complexe de l’une des manières suivantes:You can assign a value to a complex number in one of the following ways:

  • En passant deux Double valeurs à son constructeur.By passing two Double values to its constructor. La première valeur représente la partie réelle du nombre complexe, et la deuxième valeur représente sa partie imaginaire.The first value represents the real part of the complex number, and the second value represents its imaginary part. Ces valeurs représentent la position du nombre complexe dans le système de coordonnées cartésien à deux dimensions.These values represent the position of the complex number in the two-dimensional Cartesian coordinate system.

  • En appelant la méthode statiqueShared (en Visual Basic Complex.FromPolarCoordinates ) pour créer un nombre complexe à partir de ses coordonnées polaires.By calling the static (Shared in Visual Basic) Complex.FromPolarCoordinates method to create a complex number from its polar coordinates.

  • En assignant Byteune SBytevaleur Int16, UInt16, Int32, UInt32,, ,UInt64,, ouDoubleà un objetComplex . Int64 SingleBy assigning a Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, or Double value to a Complex object. La valeur devient la partie réelle du nombre complexe et sa partie imaginaire est égale à 0.The value becomes the real part of the complex number, and its imaginary part equals 0.

  • En castant ( C#en) ou en convertissant (en Visual Basic Decimal ) BigInteger une valeur Complex ou en objet.By casting (in C#) or converting (in Visual Basic) a Decimal or BigInteger value to a Complex object. La valeur devient la partie réelle du nombre complexe et sa partie imaginaire est égale à 0.The value becomes the real part of the complex number, and its imaginary part equals 0.

  • En assignant le nombre complexe retourné par une méthode ou un opérateur à un Complex objet.By assigning the complex number that is returned by a method or operator to a Complex object. Par exemple, Complex.Add est une méthode statique qui retourne un nombre complexe qui est la somme de deux nombres complexes, et l' Complex.Addition opérateur ajoute deux nombres complexes et retourne le résultat.For example, Complex.Add is a static method that returns a complex number that is the sum of two complex numbers, and the Complex.Addition operator adds two complex numbers and returns the result.

L’exemple suivant illustre chacune de ces cinq façons d’assigner une valeur à un nombre complexe.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)
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 nombres complexesOperations with Complex Numbers

La Complex structure du .NET Framework comprend des membres qui fournissent les fonctionnalités suivantes:The Complex structure in the .NET Framework includes members that provide the following functionality:

  • Méthodes pour comparer deux nombres complexes afin de déterminer s’ils sont égaux.Methods to compare two complex numbers to determine whether they are equal.

  • Opérateurs permettant d’effectuer des opérations arithmétiques sur des nombres complexes.Operators to perform arithmetic operations on complex numbers. Complexles opérateurs vous permettent d’effectuer des additions, des soustractions, des multiplications, des divisions et des négations unaires avec des nombres complexes.Complex operators enable you to perform addition, subtraction, multiplication, division, and unary negation with complex numbers.

  • Méthodes pour effectuer d’autres opérations numériques sur des nombres complexes.Methods to perform other numerical operations on complex numbers. En plus des quatre opérations arithmétiques de base, 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.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.

  • Méthodes permettant d’effectuer des opérations trigonométriques sur des nombres complexes.Methods to perform trigonometric operations on complex numbers. Par exemple, vous pouvez calculer la tangente d’un angle représenté par un nombre complexe.For example, you can calculate the tangent of an angle represented by a complex number.

Notez que, étant donné Real que Imaginary les propriétés et sont en lecture seule, vous ne pouvez pas modifier la Complex valeur d’un objet existant.Note that, because the Real and Imaginary properties are read-only, you cannot modify the value of an existing Complex object. Toutes les méthodes qui effectuent une opération Complex sur un nombre, si leur valeur de retour Complexest de type, Complex retournent un nouveau nombre.All methods that perform an operation on a Complex number, if their return value is of type Complex, return a new Complex number.

Précision et nombres complexesPrecision and Complex Numbers

Les parties imaginaire et réelle d’un nombre complexe sont représentées par deux valeurs à virgule flottante double précision.The real and imaginary parts of a complex number are represented by two double-precision floating-point values. Cela signifie que Complex les valeurs, comme les valeurs à virgule flottante double précision, peuvent perdre la précision suite à des opérations numériques.This means that Complex values, like double-precision floating-point values, can lose precision as a result of numerical operations. Cela signifie que les comparaisons strictes de l' Complex égalité de deux valeurs peuvent échouer, même si la différence entre les deux valeurs est due à une perte de précision.This means that strict comparisons for equality of two Complex values may fail, even if the difference between the two values is due to a loss of precision. Pour plus d'informations, consultez Double.For more information, see Double.

Par exemple, l’exécution de l’élévation à la puissance sur le logarithme d’un nombre doit retourner le nombre d’origine.For example, performing exponentiation on the logarithm of a number should return the original number. 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.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
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' Complex un nombre, produit des résultats légèrement différents sur les versions 32 bits et ia64 du .NET Framework.Similarly, the following example, which calculates the square root of a 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.
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.

Nombres complexes, infini et NaNComplex Numbers, Infinity, and NaN

Les parties réelles et imaginaires d’un nombre complexe sont représentées par Double des valeurs.The real and imaginary parts of a complex number are represented by Double values. En plus de la plage Double.MinValue allant Double.MaxValuede à, la partie réelle ou imaginaire d’un nombre complexe Double.PositiveInfinitypeut avoir la valeur, Double.NegativeInfinityou Double.NaN.In addition to ranging from Double.MinValue to Double.MaxValue, the real or imaginary part of a complex number can have a value of Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN. Double.PositiveInfinity, Double.NegativeInfinity etDouble.NaN se propagent toutes dans toute opération arithmétique ou trigonométrique.Double.PositiveInfinity, Double.NegativeInfinity, and Double.NaN all propagate in any arithmetic or trigonometric operation.

Dans l’exemple suivant, la Division Zero par produit un nombre complexe dont les parties réelles et imaginaires Double.NaNsont toutes les deux.In the following example, division by Zero produces a complex number whose real and imaginary parts are both 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.As a result, performing multiplication with this value also produces a complex number whose real and imaginary parts are Double.NaN. De même, l’exécution d’une multiplication qui dépasse la plage du Double type produit un nombre complexe dont la partie réelle est Double.NaN et dont la partie imaginaire est Double.PositiveInfinity.Similarly, performing a multiplication that overflows the range of the Double type produces a complex number whose real part is Double.NaN and whose imaginary part is Double.PositiveInfinity. Par la suite, l’exécution de la division avec ce nombre complexe retourne un Double.NaN nombre complexe dont la partie réelle Double.PositiveInfinityest et dont la partie imaginaire est.Subsequently performing division with this complex number returns a complex number whose real part is Double.NaN and whose imaginary part is 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)

Les opérations mathématiques avec des nombres complexes qui ne sont pas valides ou qui Double dépassent la plage du type de données ne lèvent pas d’exception.Mathematical operations with complex numbers that are invalid or that overflow the range of the Double data type do not throw an exception. Au lieu de cela, Double.PositiveInfinityils Double.NegativeInfinityretournent un, un ou Double.NaN dans les conditions suivantes:Instead, they return a Double.PositiveInfinity, Double.NegativeInfinity, or Double.NaN under the following conditions:

Notez que cela s’applique à tous les calculs intermédiaires effectués par une méthode.Note that this applies to any intermediate calculations performed by a method. Par exemple, la multiplication de new Complex(9e308, 9e308) and new Complex(2.5, 3.5) utilise la formule (AC-BD) + (AD + BC) i.For example, the multiplication of new Complex(9e308, 9e308) and new Complex(2.5, 3.5) uses the formula (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.The calculation of the real component that results from the multiplication evaluates the expression 9e308 * 2.5 - 9e308 * 3.5. Chaque multiplication intermédiaire Double.PositiveInfinityde cette expression retourne, et la tentative de soustraire Double.PositiveInfinity de Double.PositiveInfinity retourne. Double.NaNEach intermediate multiplication in this expression returns Double.PositiveInfinity, and the attempt to subtract Double.PositiveInfinity from Double.PositiveInfinity returns Double.NaN.

Mise en forme d’un nombre complexeFormatting a Complex Number

Par défaut, la représentation sous forme de chaîne d’un nombre complexe (prend la forme) réelle , imaginaire, où réel et imaginaire sont les représentations sous forme Double de chaîne de la valeurs qui forment les composants réels et imaginaires du nombre complexe.By default, the string representation of a complex number takes the form (real, imaginary), where real and imaginary are the string representations of the Double values that form the complex number's real and imaginary components. Certaines surcharges de la ToString méthode autorisent la personnalisation des représentations sous forme de Double chaîne de ces valeurs pour refléter les conventions de mise en forme d’une culture particulière ou pour s’afficher dans un format particulier défini par un type numérique standard ou personnalisé. chaîne de format.Some overloads of the ToString method allow customization of the string representations of these 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. (Pour plus d’informations, consultez chaînes de format numériques standard et chaînes de format numériques personnalisées.)(For more information, see Standard Numeric Format Strings and Custom Numeric Format Strings.)

L’une des méthodes les plus courantes pour exprimer la représentation sous forme de chaîne d’un nombre complexe est la forme a + bi, où a est le composant réel du nombre complexe et b est le composant imaginaire du nombre complexe.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. Dans l’ingénierie électrique, un nombre complexe est généralement exprimé sous la forme d’une valeur + BJ.In electrical engineering, a complex number is most commonly expressed as 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 deux formes.You can return the string representation of a complex number in either of these two forms. Pour ce faire, définissez un fournisseur de format personnalisé en implémentant IFormatProvider les ICustomFormatter interfaces et, puis appelez String.Format(IFormatProvider, String, Object[]) la méthode.To do this, define a custom format provider by implementing the ICustomFormatter and IFormatProvider interfaces, and then call the String.Format(IFormatProvider, String, Object[]) method.

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

Constructeurs

Complex(Double, Double) Complex(Double, Double) Complex(Double, Double) Complex(Double, Double)

Initialise une nouvelle instance de la structure Complex à l'aide des valeurs réelles et imaginaires spécifiées.Initializes a new instance of the Complex structure using the specified real and imaginary values.

Champs

ImaginaryOne ImaginaryOne ImaginaryOne ImaginaryOne

Retourne une nouvelle instance Complex avec un nombre réel égal à zéro et un nombre imaginaire égal à un.Returns a new Complex instance with a real number equal to zero and an imaginary number equal to one.

Infinity Infinity Infinity Infinity

Représente l’infini sous la forme d’un nombre complexe.Represents infinity as a complex number.

NaN NaN NaN NaN

Représente une instance complexe qui n’est pas un nombre (NaN).Represents a complex instance that is not a number (NaN).

One One One One

Retourne une nouvelle instance Complex avec un nombre réel égal à un et un nombre imaginaire égal à zéro.Returns a new Complex instance with a real number equal to one and an imaginary number equal to zero.

Zero Zero Zero Zero

Retourne une nouvelle instance Complex avec un nombre réel égal à zéro et un nombre imaginaire égal à zéro.Returns a new Complex instance with a real number equal to zero and an imaginary number equal to zero.

Propriétés

Imaginary Imaginary Imaginary Imaginary

Obtient le composant imaginaire de l'objet Complex actuel.Gets the imaginary component of the current Complex object.

Magnitude Magnitude Magnitude Magnitude

Obtient l'ordre de grandeur (ou valeur absolue) d'un nombre complexe.Gets the magnitude (or absolute value) of a complex number.

Phase Phase Phase Phase

Obtient la phase d'un nombre complexe.Gets the phase of a complex number.

Real Real Real Real

Obtient le composant réel de l'objet Complex actuel.Gets the real component of the current Complex object.

Méthodes

Abs(Complex) Abs(Complex) Abs(Complex) Abs(Complex)

Obtient la valeur absolue (ou ordre de grandeur) d'un nombre complexe.Gets the absolute value (or magnitude) of a complex number.

Acos(Complex) Acos(Complex) Acos(Complex) Acos(Complex)

Retourne l'angle qui correspond au cosinus d'arc du nombre complexe spécifié.Returns the angle that is the arc cosine of the specified complex number.

Add(Double, Complex) Add(Double, Complex) Add(Double, Complex) Add(Double, Complex)

Ajoute un nombre réel à double précision à un nombre complexe et retourne le résultat.Adds a double-precision real number to a complex number and returns the result.

Add(Complex, Double) Add(Complex, Double) Add(Complex, Double) Add(Complex, Double)

Ajoute un nombre complexe à un nombre réel à double précision et retourne le résultat.Adds a complex number to a double-precision real number and returns the result.

Add(Complex, Complex) Add(Complex, Complex) Add(Complex, Complex) Add(Complex, Complex)

Ajoute deux nombres complexes et retourne le résultat.Adds two complex numbers and returns the result.

Asin(Complex) Asin(Complex) Asin(Complex) Asin(Complex)

Retourne l'angle qui correspond au sinus d'arc du nombre complexe spécifié.Returns the angle that is the arc sine of the specified complex number.

Atan(Complex) Atan(Complex) Atan(Complex) Atan(Complex)

Retourne l'angle qui correspond à la tangente d'arc du nombre complexe spécifié.Returns the angle that is the arc tangent of the specified complex number.

Conjugate(Complex) Conjugate(Complex) Conjugate(Complex) Conjugate(Complex)

Calcule le conjugué d'un nombre complexe et retourne le résultat.Computes the conjugate of a complex number and returns the result.

Cos(Complex) Cos(Complex) Cos(Complex) Cos(Complex)

Retourne le cosinus du nombre complexe spécifié.Returns the cosine of the specified complex number.

Cosh(Complex) Cosh(Complex) Cosh(Complex) Cosh(Complex)

Retourne le cosinus hyperbolique du nombre complexe spécifié.Returns the hyperbolic cosine of the specified complex number.

Divide(Double, Complex) Divide(Double, Complex) Divide(Double, Complex) Divide(Double, Complex)

Divise un nombre réel à double précision par un nombre complexe et retourne le résultat.Divides one double-precision real number by a complex number and returns the result.

Divide(Complex, Double) Divide(Complex, Double) Divide(Complex, Double) Divide(Complex, Double)

Divise un nombre complexe par un nombre réel à double précision et retourne le résultat.Divides one complex number by a double-precision real number and returns the result.

Divide(Complex, Complex) Divide(Complex, Complex) Divide(Complex, Complex) Divide(Complex, Complex)

Divise un nombre complexe par un autre et retourne le résultat.Divides one complex number by another and returns the result.

Equals(Complex) Equals(Complex) Equals(Complex) Equals(Complex)

Retourne une valeur qui indique si l'instance actuelle et un nombre complexe spécifié ont la même valeur.Returns a value that indicates whether the current instance and a specified complex number have the same value.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Retourne une valeur qui indique si l'instance actuelle et un objet spécifié ont la même valeur.Returns a value that indicates whether the current instance and a specified object have the same value.

Exp(Complex) Exp(Complex) Exp(Complex) Exp(Complex)

Retourne e élevé à la puissance spécifiée par un nombre complexe.Returns e raised to the power specified by a complex number.

FromPolarCoordinates(Double, Double) FromPolarCoordinates(Double, Double) FromPolarCoordinates(Double, Double) FromPolarCoordinates(Double, Double)

Crée un nombre complexe à partir des coordonnées polaires d'un point.Creates a complex number from a point's polar coordinates.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retourne le code de hachage pour l'objet Complex actuel.Returns the hash code for the current Complex object.

IsFinite(Complex) IsFinite(Complex) IsFinite(Complex) IsFinite(Complex)

Détermine si le nombre complexe spécifié est infini.Determines whether the specified complex number is finite.

IsInfinity(Complex) IsInfinity(Complex) IsInfinity(Complex) IsInfinity(Complex)

Retourne une valeur indiquant si le nombre complexe spécifié est évalué comme infini.Returns a value indicating whether the specified complex number evaluates to infinity.

IsNaN(Complex) IsNaN(Complex) IsNaN(Complex) IsNaN(Complex)

Retourne une valeur qui indique si l’instance complexe spécifiée n'est pas un nombre (NaN).Returns a value that indicates whether the specified complex instance is not a number (NaN).

Log(Complex) Log(Complex) Log(Complex) Log(Complex)

Retourne le logarithme naturel (base e) d'un nombre complexe spécifié.Returns the natural (base e) logarithm of a specified complex number.

Log(Complex, Double) Log(Complex, Double) Log(Complex, Double) Log(Complex, Double)

Retourne le logarithme d'un nombre complexe spécifié dans une base spécifiée.Returns the logarithm of a specified complex number in a specified base.

Log10(Complex) Log10(Complex) Log10(Complex) Log10(Complex)

Retourne le logarithme de base 10 d'un nombre complexe spécifié.Returns the base-10 logarithm of a specified complex number.

Multiply(Complex, Complex) Multiply(Complex, Complex) Multiply(Complex, Complex) Multiply(Complex, Complex)

Retourne le produit de deux nombres complexes.Returns the product of two complex numbers.

Multiply(Double, Complex) Multiply(Double, Complex) Multiply(Double, Complex) Multiply(Double, Complex)

Retourne le produit d’un nombre réel à double précision et d’un nombre complexe.Returns the product of a double-precision real number and a complex number.

Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double)

Retourne le produit d’un nombre complexe et d’un nombre réel à double précision.Returns the product of a complex number and a double-precision real number.

Negate(Complex) Negate(Complex) Negate(Complex) Negate(Complex)

Retourne l'inverse additif d'un nombre complexe spécifié.Returns the additive inverse of a specified complex number.

Pow(Complex, Double) Pow(Complex, Double) Pow(Complex, Double) Pow(Complex, Double)

Retourne un nombre complexe spécifié élevé à une puissance spécifiée par un nombre à virgule flottante double précision.Returns a specified complex number raised to a power specified by a double-precision floating-point number.

Pow(Complex, Complex) Pow(Complex, Complex) Pow(Complex, Complex) Pow(Complex, Complex)

Retourne un nombre complexe spécifié élevé à une puissance spécifiée par un nombre complexe.Returns a specified complex number raised to a power specified by a complex number.

Reciprocal(Complex) Reciprocal(Complex) Reciprocal(Complex) Reciprocal(Complex)

Retourne l'inverse multiplicatif d'un nombre complexe.Returns the multiplicative inverse of a complex number.

Sin(Complex) Sin(Complex) Sin(Complex) Sin(Complex)

Retourne le sinus du nombre complexe spécifié.Returns the sine of the specified complex number.

Sinh(Complex) Sinh(Complex) Sinh(Complex) Sinh(Complex)

Retourne le sinus hyperbolique du nombre complexe spécifié.Returns the hyperbolic sine of the specified complex number.

Sqrt(Complex) Sqrt(Complex) Sqrt(Complex) Sqrt(Complex)

Retourne la racine carrée d'un nombre complexe spécifié.Returns the square root of a specified complex number.

Subtract(Double, Complex) Subtract(Double, Complex) Subtract(Double, Complex) Subtract(Double, Complex)

Soustrait un nombre complexe d’un nombre réel à double précision et retourne le résultat.Subtracts one complex number from a double-precision real number and returns the result.

Subtract(Complex, Double) Subtract(Complex, Double) Subtract(Complex, Double) Subtract(Complex, Double)

Soustrait un nombre réel à double précision d’un nombre complexe et retourne le résultat.Subtracts one double-precision real number from a complex number and returns the result.

Subtract(Complex, Complex) Subtract(Complex, Complex) Subtract(Complex, Complex) Subtract(Complex, Complex)

Soustrait un nombre complexe d'un autre et retourne le résultat.Subtracts one complex number from another and returns the result.

Tan(Complex) Tan(Complex) Tan(Complex) Tan(Complex)

Retourne la tangente du nombre complexe spécifié.Returns the tangent of the specified complex number.

Tanh(Complex) Tanh(Complex) Tanh(Complex) Tanh(Complex)

Retourne la tangente hyperbolique du nombre complexe spécifié.Returns the hyperbolic tangent of the specified complex number.

ToString() ToString() ToString() ToString()

Convertit la valeur du nombre complexe actuel en sa représentation sous forme de chaîne équivalente au format cartésien.Converts the value of the current complex number to its equivalent string representation in Cartesian form.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(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.Converts the value of the current complex number to its equivalent string representation in Cartesian form by using the specified culture-specific formatting information.

ToString(String) ToString(String) ToString(String) ToString(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.Converts the value of the current complex number to its equivalent string representation in Cartesian form by using the specified format for its real and imaginary parts.

ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(String, IFormatProvider) ToString(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.Converts the value of the current complex number to its equivalent string representation in Cartesian form by using the specified format and culture-specific format information for its real and imaginary parts.

Opérateurs

Addition(Complex, Complex) Addition(Complex, Complex) Addition(Complex, Complex) Addition(Complex, Complex)

Ajoute deux nombres complexes.Adds two complex numbers.

Addition(Double, Complex) Addition(Double, Complex) Addition(Double, Complex) Addition(Double, Complex)

Ajoute un nombre réel à double précision à un nombre complexe.Adds a double-precision real number to a complex number.

Addition(Complex, Double) Addition(Complex, Double) Addition(Complex, Double) Addition(Complex, Double)

Ajoute un nombre complexe à un nombre réel à double précision.Adds a complex number to a double-precision real number.

Division(Complex, Complex) Division(Complex, Complex) Division(Complex, Complex) Division(Complex, Complex)

Divise un nombre complexe spécifié par un autre nombre complexe spécifié.Divides a specified complex number by another specified complex number.

Division(Complex, Double) Division(Complex, Double) Division(Complex, Double) Division(Complex, Double)

Divise un nombre complexe spécifié par un nombre réel à double précision spécifié.Divides a specified complex number by a specified double-precision real number.

Division(Double, Complex) Division(Double, Complex) Division(Double, Complex) Division(Double, Complex)

Divise un nombre réel à double précision spécifié par un nombre complexe spécifié.Divides a specified double-precision real number by a specified complex number.

Equality(Complex, Complex) Equality(Complex, Complex) Equality(Complex, Complex) Equality(Complex, Complex)

Retourne une valeur qui indique si deux nombres complexes sont égaux.Returns a value that indicates whether two complex numbers are equal.

Explicit(Decimal to Complex) Explicit(Decimal to Complex) Explicit(Decimal to Complex) Explicit(Decimal to Complex)

Définit une conversion explicite d'une valeur Decimal en nombre complexe.Defines an explicit conversion of a Decimal value to a complex number.

Explicit(BigInteger to Complex) Explicit(BigInteger to Complex) Explicit(BigInteger to Complex) Explicit(BigInteger to Complex)

Définit une conversion explicite d'une valeur BigInteger en nombre complexe.Defines an explicit conversion of a BigInteger value to a complex number.

Implicit(UInt64 to Complex) Implicit(UInt64 to Complex) Implicit(UInt64 to Complex) Implicit(UInt64 to Complex)

Définit une conversion implicite d'un entier 64 bits non signé en nombre complexe.Defines an implicit conversion of a 64-bit unsigned integer to a complex number.

Cette API n'est pas conforme CLS.This API is not CLS-compliant.

Implicit(UInt32 to Complex) Implicit(UInt32 to Complex) Implicit(UInt32 to Complex) Implicit(UInt32 to Complex)

Définit une conversion implicite d'un entier 32 bits non signé en nombre complexe.Defines an implicit conversion of a 32-bit unsigned integer to a complex number.

Cette API n'est pas conforme CLS.This API is not CLS-compliant.

Implicit(UInt16 to Complex) Implicit(UInt16 to Complex) Implicit(UInt16 to Complex) Implicit(UInt16 to Complex)

Définit une conversion implicite d'un entier 16 bits non signé en nombre complexe.Defines an implicit conversion of a 16-bit unsigned integer to a complex number.

Cette API n'est pas conforme CLS.This API is not CLS-compliant.

Implicit(Single to Complex) Implicit(Single to Complex) Implicit(Single to Complex) Implicit(Single to Complex)

Définit une conversion implicite d'un nombre à virgule flottante simple précision en un nombre complexe.Defines an implicit conversion of a single-precision floating-point number to a complex number.

Implicit(SByte to Complex) Implicit(SByte to Complex) Implicit(SByte to Complex) Implicit(SByte to Complex)

Définit une conversion implicite d'un octet signé en nombre complexe.Defines an implicit conversion of a signed byte to a complex number.

Cette API n'est pas conforme CLS.This API is not CLS-compliant.

Implicit(Int32 to Complex) Implicit(Int32 to Complex) Implicit(Int32 to Complex) Implicit(Int32 to Complex)

Définit une conversion implicite d'un entier 32 bits signé en nombre complexe.Defines an implicit conversion of a 32-bit signed integer to a complex number.

Implicit(Int16 to Complex) Implicit(Int16 to Complex) Implicit(Int16 to Complex) Implicit(Int16 to Complex)

Définit une conversion implicite d'un entier 16 bits signé en nombre complexe.Defines an implicit conversion of a 16-bit signed integer to a complex number.

Implicit(Double to Complex) Implicit(Double to Complex) Implicit(Double to Complex) Implicit(Double to Complex)

Définit une conversion implicite d'un nombre à virgule flottante double précision en un nombre complexe.Defines an implicit conversion of a double-precision floating-point number to a complex number.

Implicit(Byte to Complex) Implicit(Byte to Complex) Implicit(Byte to Complex) Implicit(Byte to Complex)

Définit une conversion implicite d'un octet non signé en nombre complexe.Defines an implicit conversion of an unsigned byte to a complex number.

Implicit(Int64 to Complex) Implicit(Int64 to Complex) Implicit(Int64 to Complex) Implicit(Int64 to Complex)

Définit une conversion implicite d'un entier 64 bits signé en nombre complexe.Defines an implicit conversion of a 64-bit signed integer to a complex number.

Inequality(Complex, Complex) Inequality(Complex, Complex) Inequality(Complex, Complex) Inequality(Complex, Complex)

Retourne une valeur qui indique si deux nombres complexes sont différents.Returns a value that indicates whether two complex numbers are not equal.

Multiply(Complex, Complex) Multiply(Complex, Complex) Multiply(Complex, Complex) Multiply(Complex, Complex)

Multiplie deux nombres complexes spécifiés.Multiplies two specified complex numbers.

Multiply(Double, Complex) Multiply(Double, Complex) Multiply(Double, Complex) Multiply(Double, Complex)

Multiplie un nombre réel à double précision spécifié par un nombre complexe spécifié.Multiplies a specified double-precision real number by a specified complex number.

Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double)

Multiplie le nombre complexe spécifié par un nombre réel à double précision spécifié.Multiplies the specified complex number by a specified double-precision real number.

Subtraction(Complex, Complex) Subtraction(Complex, Complex) Subtraction(Complex, Complex) Subtraction(Complex, Complex)

Soustrait un nombre complexe d'un autre nombre complexe.Subtracts a complex number from another complex number.

Subtraction(Complex, Double) Subtraction(Complex, Double) Subtraction(Complex, Double) Subtraction(Complex, Double)

Soustrait un nombre réel à double précision d’un nombre complexe.Subtracts a double-precision real number from a complex number.

Subtraction(Double, Complex) Subtraction(Double, Complex) Subtraction(Double, Complex) Subtraction(Double, Complex)

Soustrait un nombre complexe d’un nombre réel à double précision.Subtracts a complex number from a double-precision real number.

UnaryNegation(Complex) UnaryNegation(Complex) UnaryNegation(Complex) UnaryNegation(Complex)

Retourne l'inverse additif d'un nombre complexe spécifié.Returns the additive inverse of a specified complex number.

S’applique à