Complex.Explicit Opérateur

Définition

Espace de noms:

System.Numerics

Assemblys:

netstandard.dll, System.Runtime.Numerics.dll

Définit une conversion explicite entre un Complex objet et un autre type.

Surcharges

Nom	Description
Explicit(UInt128 to Complex)	Convertit explicitement une UInt128 valeur en nombre complexe double précision.
Explicit(BigInteger to Complex)	Définit une conversion explicite d’une BigInteger valeur en nombre complexe.
Explicit(Decimal to Complex)	Définit une conversion explicite d’une Decimal valeur en nombre complexe.
Explicit(Int128 to Complex)	Convertit explicitement une Int128 valeur en nombre complexe double précision.

Explicit(UInt128 to Complex)

Source:

Complex.cs

Important

Cette API n’est pas conforme CLS.

Convertit explicitement une UInt128 valeur en nombre complexe double précision.

public:
 static explicit operator System::Numerics::Complex(UInt128 value);

[System.CLSCompliant(false)]
public static explicit operator System.Numerics.Complex(UInt128 value);

[<System.CLSCompliant(false)>]
static member op_Explicit : UInt128 -> System.Numerics.Complex

Public Shared Narrowing Operator CType (value As UInt128) As Complex

Paramètres

value

UInt128

Valeur à convertir.

Retours

Complex

value converti en nombre complexe double précision.

Attributs

CLSCompliantAttribute

Explicit(BigInteger to Complex)

Source:

Complex.cs

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

public:
 static explicit operator System::Numerics::Complex(System::Numerics::BigInteger value);

public static explicit operator System.Numerics.Complex(System.Numerics.BigInteger value);

static member op_Explicit : System.Numerics.BigInteger -> System.Numerics.Complex

Public Shared Narrowing Operator CType (value As BigInteger) As Complex

Paramètres

value

BigInteger

Valeur à convertir en nombre complexe.

Retours

Complex

Nombre complexe qui a un composant réel égal à value et un composant imaginaire égal à zéro.

Exemples

L’exemple suivant illustre la conversion explicite de BigInteger valeurs en Complex valeurs.

BigInteger[] numbers= {
                 ((BigInteger) Double.MaxValue) * 2,
                 BigInteger.Parse("901345277852317852466891423"),
                 BigInteger.One };
foreach (BigInteger number in numbers)
{
  Complex c1 = (Complex) number;
   Console.WriteLine(c1);
}
// The example displays the following output:
//       (Infinity, 0)
//       (9.01345277852318E+26, 0)
//       (1, 0)

    let numbers =
        [ (bigint Double.MaxValue) * 2I
          BigInteger.Parse "901345277852317852466891423"
          BigInteger.One ]

    for number in numbers do
        let c1 = Complex(float number, 0.)
        printfn $"{number, 30}  -->  {c1}"
// The example displays the following output:
//       (Infinity, 0)
//       (9.01345277852318E+26, 0)
//       (1, 0)

Dim numbers() As BigInteger = {
                 CType(Double.MaxValue, BigInteger) * 2, 
                 BigInteger.Parse("901345277852317852466891423"), 
                 BigInteger.One } 
For Each number In numbers
  Dim c1 As System.Numerics.Complex = CType(number, 
                                    System.Numerics.Complex)
   Console.WriteLine(c1)
Next        
' The example displays the following output:
'       (Infinity, 0)
'       (9.01345277852318E+26, 0)
'       (1, 0)

Remarques

Les opérateurs de conversion explicite définissent des types qui peuvent être convertis en objet Complex . Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car ils peuvent impliquer une perte de données. Au lieu de cela, ils effectuent la conversion uniquement si un opérateur de cast (en C#) ou une fonction de conversion (par CType exemple, en Visual Basic) est utilisé. Sinon, ils affichent une erreur du compilateur.

La conversion d’une BigInteger valeur en partie réelle d’un nombre complexe peut entraîner une perte de précision, car un Double, qui est le type de la propriété du Real nombre complexe, a moins de chiffres significatifs qu’un BigInteger.

Si la conversion échoue, car la BigInteger valeur est hors de la plage du Double type, l’opération ne lève pas .OverflowException Au lieu de cela, si value elle MinValueest inférieure à , le résultat est un nombre complexe dont la valeur de propriété est Real égale à NegativeInfinity. S’il value est supérieur MaxValueà , le résultat est un nombre complexe dont la Real valeur de propriété est égale à PositiveInfinity.

Explicit(Decimal to Complex)

Source:

Complex.cs

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

public:
 static explicit operator System::Numerics::Complex(System::Decimal value);

public static explicit operator System.Numerics.Complex(decimal value);

static member op_Explicit : decimal -> System.Numerics.Complex

Public Shared Narrowing Operator CType (value As Decimal) As Complex

Paramètres

value

Decimal

Valeur à convertir en nombre complexe.

Retours

Complex

Nombre complexe qui a un composant réel égal à value et un composant imaginaire égal à zéro.

Exemples

L’exemple suivant illustre la conversion explicite de Decimal valeurs en Complex valeurs.

decimal[] numbers = { Decimal.MinValue, -18.35m, 0m, 1893.019m,
                      Decimal.MaxValue };
foreach (decimal number in numbers)
{
   System.Numerics.Complex c1 = (System.Numerics.Complex) number;
   Console.WriteLine("{0,30}  -->  {1}", number, c1);
}
// The example displays the following output:
//    -79228162514264337593543950335  -->  (-7.92281625142643E+28, 0)
//                            -18.35  -->  (-18.35, 0)
//                                 0  -->  (0, 0)
//                          1893.019  -->  (1893.019, 0)
//     79228162514264337593543950335  -->  (7.92281625142643E+28, 0)

    let numbers = [ Decimal.MinValue; -18.35m; 0m; 1893.019m; Decimal.MaxValue ]

    for number in numbers do
        let c1 = Complex(float number, 0.)
        printfn $"{number, 30}  -->  {c1}"

// The example displays the following output:
//    -79228162514264337593543950335  -->  (-7.92281625142643E+28, 0)
//                            -18.35  -->  (-18.35, 0)
//                                 0  -->  (0, 0)
//                          1893.019  -->  (1893.019, 0)
//     79228162514264337593543950335  -->  (7.92281625142643E+28, 0)

Dim numbers() As Decimal = { Decimal.MinValue, -18.35d, 0d, 1893.019d, 
                             Decimal.MaxValue }
For Each number In numbers
   Dim c1 As System.Numerics.Complex = CType(number, 
                                             System.Numerics.Complex)
   Console.WriteLine("{0,30}  -->  {1}", number, c1)
Next   
' The example displays the following output:
'    -79228162514264337593543950335  -->  (-7.92281625142643E+28, 0)
'                            -18.35  -->  (-18.3500003814697, 0)
'                                 0  -->  (0, 0)
'                          1893.019  -->  (1893.01904296875, 0)
'     79228162514264337593543950335  -->  (7.92281625142643E+28, 0)

Remarques

Les opérateurs de conversion explicite définissent des types qui peuvent être convertis en objet Complex . Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car ils peuvent impliquer une perte de données. Au lieu de cela, ils effectuent la conversion uniquement si un opérateur de cast (en C#) ou une fonction de conversion (par CType exemple, en Visual Basic) est utilisé. Sinon, ils affichent une erreur du compilateur.

La conversion d’une Decimal valeur en partie réelle d’un nombre complexe peut entraîner une perte de précision, car un Double, qui est le type de la propriété du Real nombre complexe, a moins de chiffres significatifs qu’un Decimal.

Explicit(Int128 to Complex)

Source:

Complex.cs

Convertit explicitement une Int128 valeur en nombre complexe double précision.

public:
 static explicit operator System::Numerics::Complex(Int128 value);

public static explicit operator System.Numerics.Complex(Int128 value);

static member op_Explicit : Int128 -> System.Numerics.Complex

Public Shared Narrowing Operator CType (value As Int128) As Complex

Paramètres

value

Int128

Valeur à convertir.

Retours

Complex

value converti en nombre complexe double précision.