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 de z est généralement écrites sous la forme z = x + yi, où x et y sont des nombres réels, et je est l’unité imaginaire qui possède la propriété i 2 = -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 x, et 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ésiennes (réel, imaginaire) lors de l’instanciation et la manipulation des 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é comme un point dans un système de coordonnées à deux dimensions, ce qui est appelé le 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 abscisses (l’axe horizontal), et la partie imaginaire est positionnée sur l’axe des ordonnées (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).

N’importe quel point dans le plan complexe peut également être exprimée en fonction de sa valeur absolue, en utilisant le 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 se caractérise par deux nombres :In polar coordinates, a point is characterized by two numbers:

  • Sa grandeur, qui est la distance entre le point à partir de l’origine (autrement dit, 0,0, ou au point auquel l’axe des abscisses et 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 des réels et le trait dessiné depuis l’origine 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 dans 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 la 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ésiennes à deux dimensions.These values represent the position of the complex number in the two-dimensional Cartesian coordinate system.

  • En appelant la méthode statique (Shared en Visual Basic) Complex.FromPolarCoordinates méthode 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 attribuant un Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, ou Double valeur un Complex objet.By 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 égal à 0.The value becomes the real part of the complex number, and its imaginary part equals 0.

  • En castant (en c#) ou en convertissant (en Visual Basic) un Decimal ou BigInteger valeur un Complex 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 égal à 0.The value becomes the real part of the complex number, and its imaginary part equals 0.

  • En assignant le nombre complexe qui est 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 des deux nombres complexes, et le 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’affecter 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 des nombres complexesOperations with Complex Numbers

Le Complex structure dans le .NET Framework inclut des membres qui fournissent les fonctionnalités suivantes :The Complex structure in the .NET Framework includes members that provide the following functionality:

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

  • Opérateurs pour effectuer des opérations arithmétiques sur les nombres complexes.Operators to perform arithmetic operations on complex numbers. Complex opérateurs permettent d’effectuer une addition, soustraction, multiplication, division et la négation unaire 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 les nombres complexes.Methods to perform other numerical operations on complex numbers. Outre les quatre opérations arithmétiques base, vous pouvez déclencher un nombre complexe à une puissance spécifiée, recherche 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 pour effectuer des opérations trigonométriques sur les nombres complexes.Methods to perform trigonometric operations on complex numbers. Par exemple, vous pouvez calculer la tangente d’un angle représentée par un nombre complexe.For example, you can calculate the tangent of an angle represented by a complex number.

Notez que, étant donné que le Real et Imaginary propriétés sont en lecture seule, vous ne pouvez pas modifier la valeur d’un existant Complex objet.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 sur un Complex number, si leur valeur de retour est de type Complex, retournent un nouvel Complex 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 imaginaires et réelles 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 valeurs, telles que des valeurs à virgule flottante double précision, peuvent perdre en précision à la suite d’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 stricte les comparaisons d’égalité de deux Complex valeurs peuvent échouer, même si la différence entre les deux valeurs est en raison d’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 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 de valeurs à virgule flottante peut entraîner 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’un Complex number, produit des résultats légèrement différents sur les 32 bits et IA64 des versions 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, l’infini et NaNComplex Numbers, Infinity, and NaN

Les parties imaginaires et réelles d’un nombre complexe sont représentées par Double valeurs.The real and imaginary parts of a complex number are represented by Double values. En plus d’allant Double.MinValue à Double.MaxValue, la partie réelle ou imaginaire d’un nombre complexe peut avoir une valeur de Double.PositiveInfinity, Double.NegativeInfinity, ou 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, et Double.NaN tous les propagent dans toutes les opérations arithmétiques ou trigonométriques.Double.PositiveInfinity, Double.NegativeInfinity, and Double.NaN all propagate in any arithmetic or trigonometric operation.

Dans l’exemple suivant, la division par Zero produit un nombre complexe dont les parties réelles et imaginaires sont tous deux Double.NaN.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, exécution d’une multiplication qui dépasse la plage de la Double type génère 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 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.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 dépassent la plage de la Double 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, elles retournent un Double.PositiveInfinity, Double.NegativeInfinity, 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ées 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) je.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 vrai composant 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 dans cette expression retourne Double.PositiveInfinityet la tentative de soustraire Double.PositiveInfinity de Double.PositiveInfinity retourne Double.NaN.Each 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éel , imaginaire), où réel et imaginaire sont les représentations sous forme de chaîne de la Double valeurs qui forment les composants réelle et imaginaire 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 permettent de personnaliser les représentations sous forme de chaîne de ces Double valeurs afin 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 valeur numérique standard ou personnalisée 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 Standard Numeric Format Strings et les chaînes de Format numériques personnalisées.)(For more information, see Standard Numeric Format Strings and Custom Numeric Format Strings.)

Une des façons 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.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. En génie électrique, un nombre complexe est plus souvent exprimé comme un + 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 un 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 le ICustomFormatter et IFormatProvider interfaces, puis appelez le String.Format(IFormatProvider, String, Object[]) (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 un ComplexFormatter classe qui représente un nombre complexe en tant que chaîne sous la forme d’un + bi ou un + 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 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
NaN NaN NaN 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)
Add(Complex, Double) Add(Complex, Double) Add(Complex, Double) Add(Complex, Double)
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)
Divide(Complex, Double) Divide(Complex, Double) Divide(Complex, Double) Divide(Complex, Double)
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)
IsInfinity(Complex) IsInfinity(Complex) IsInfinity(Complex) IsInfinity(Complex)
IsNaN(Complex) IsNaN(Complex) IsNaN(Complex) IsNaN(Complex)
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)
Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double)
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)
Subtract(Complex, Double) Subtract(Complex, Double) Subtract(Complex, Double) Subtract(Complex, Double)
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)
Addition(Complex, Double) Addition(Complex, Double) Addition(Complex, Double) Addition(Complex, Double)
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)
Division(Double, Complex) Division(Double, Complex) Division(Double, Complex) Division(Double, Complex)
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)
Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double) Multiply(Complex, Double)
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)
Subtraction(Double, Complex) Subtraction(Double, Complex) Subtraction(Double, Complex) Subtraction(Double, Complex)
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 à