Partager via

Complex.Explicit Opérateur

  • Référence

Définition

Espace de noms:
System.Numerics
Assembly:
System.Runtime.Numerics.dll
Assembly:
System.Numerics.dll
Assembly:
netstandard.dll

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

Surcharges

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 valeur BigInteger en nombre complexe.
Explicit(Decimal to Complex)

Définit une conversion explicite d'une valeur Decimal 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
Source:
Complex.cs
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

S’applique à

Explicit(BigInteger to Complex)

Source:
Complex.cs
Source:
Complex.cs
Source:
Complex.cs

Définit une conversion explicite d'une valeur BigInteger 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 ayant 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 explicites définissent des types qui peuvent être convertis en objet Complex . Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut entraîner une perte de données. Au lieu de cela, ils effectuent la conversion uniquement si un opérateur de casting (en C#) ou une fonction de conversion (comme CType dans Visual Basic) est utilisé. Sinon, ils affichent une erreur du compilateur.

La conversion d’une BigInteger valeur en la 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 de OverflowException. Au lieu de cela, si value est inférieur MinValueà , le résultat est un nombre complexe qui a une Real valeur de propriété égale à NegativeInfinity. Si value est supérieur MaxValueà , le résultat est un nombre complexe qui a une Real valeur de propriété égale à PositiveInfinity.

S’applique à

Explicit(Decimal to Complex)

Source:
Complex.cs
Source:
Complex.cs
Source:
Complex.cs

Définit une conversion explicite d'une valeur Decimal 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 ayant 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 explicites définissent des types qui peuvent être convertis en objet Complex . Les compilateurs de langage n’effectuent pas cette conversion automatiquement, car cela peut entraîner une perte de données. Au lieu de cela, ils effectuent la conversion uniquement si un opérateur de casting (en C#) ou une fonction de conversion (comme CType dans Visual Basic) est utilisé. Sinon, ils affichent une erreur du compilateur.

La conversion d’une Decimal valeur en la 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.

S’applique à

Explicit(Int128 to Complex)

Source:
Complex.cs
Source:
Complex.cs
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

La valeur à convertir.

Retours

Complex

value converti en nombre complexe double précision.

S’applique à