Partage via

Complex.Implicit 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 implicite entre un objet Complex et un autre type.

Surcharges

Implicit(SByte to Complex)

Définit une conversion implicite d'un octet signé en nombre complexe.

Cette API n'est pas conforme CLS.
Implicit(UIntPtr to Complex)

Convertit implicitement une UIntPtr valeur en nombre complexe à double précision.
Implicit(UInt64 to Complex)

Définit une conversion implicite d'un entier 64 bits non signé en nombre complexe.

Cette API n'est pas conforme CLS.
Implicit(UInt32 to Complex)

Définit une conversion implicite d'un entier 32 bits non signé en nombre complexe.

Cette API n'est pas conforme CLS.
Implicit(UInt16 to Complex)

Définit une conversion implicite d'un entier 16 bits non signé en nombre complexe.

Cette API n'est pas conforme CLS.
Implicit(Single to Complex)

Définit une conversion implicite d'un nombre à virgule flottante simple précision en un nombre complexe.
Implicit(IntPtr to Complex)

Convertit implicitement une IntPtr valeur en nombre complexe à double précision.
Implicit(Double to Complex)

Définit une conversion implicite d'un nombre à virgule flottante double précision en un nombre complexe.
Implicit(Int32 to Complex)

Définit une conversion implicite d'un entier 32 bits signé en nombre complexe.
Implicit(Int16 to Complex)

Définit une conversion implicite d'un entier 16 bits signé en nombre complexe.
Implicit(Half to Complex)

Convertit implicitement une Half valeur en nombre complexe à double précision.
Implicit(Int64 to Complex)

Définit une conversion implicite d'un entier 64 bits signé en nombre complexe.
Implicit(Char to Complex)

Convertit implicitement une Char valeur en nombre complexe à double précision.
Implicit(Byte to Complex)

Définit une conversion implicite d'un octet non signé en nombre complexe.

Implicit(SByte to Complex)

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

Important

Cette API n’est pas conforme CLS.

Définit une conversion implicite d'un octet signé en nombre complexe.

Cette API n'est pas conforme CLS.

public:
 static operator System::Numerics::Complex(System::SByte value);
[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex (sbyte value);
[<System.CLSCompliant(false)>]
static member op_Implicit : sbyte -> System.Numerics.Complex
Public Shared Widening Operator CType (value As SByte) As Complex

Paramètres

value
SByte

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Attributs
CLSCompliantAttribute

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’un octet signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’octet signé et dont la partie imaginaire est égale à zéro.

sbyte sbyteValue = -12;
System.Numerics.Complex c1 = sbyteValue;
Console.WriteLine(c1);
// The example displays the following output:
//       (-12, 0)

let sbyteValue = -12
let c1: System.Numerics.Complex = sbyteValue
printfn $"{c1}"
// The example displays the following output:
//       (-12, 0)

Dim sbyteValue As SByte = -12
Dim c1 As System.Numerics.Complex = sbyteValue
Console.WriteLine(c1)
' The example displays the following output:
'       (-12, 0)

S’applique à

Implicit(UIntPtr to Complex)

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

Important

Cette API n’est pas conforme CLS.

Convertit implicitement une UIntPtr valeur en nombre complexe à double précision.

public:
 static operator System::Numerics::Complex(UIntPtr value);
[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex (UIntPtr value);
[<System.CLSCompliant(false)>]
static member op_Implicit : unativeint -> System.Numerics.Complex
Public Shared Widening Operator CType (value As UIntPtr) As Complex

Paramètres

value
UIntPtr

unativeint

La valeur à convertir.

Retours

Complex

value converti en nombre complexe double précision.

Attributs
CLSCompliantAttribute

S’applique à

Implicit(UInt64 to Complex)

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

Important

Cette API n’est pas conforme CLS.

Définit une conversion implicite d'un entier 64 bits non signé en nombre complexe.

Cette API n'est pas conforme CLS.

public:
 static operator System::Numerics::Complex(System::UInt64 value);
[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex (ulong value);
[<System.CLSCompliant(false)>]
static member op_Implicit : uint64 -> System.Numerics.Complex
Public Shared Widening Operator CType (value As ULong) As Complex

Paramètres

value
UInt64

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Attributs
CLSCompliantAttribute

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’un entier 64 bits non signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 64 bits non signé et dont la partie imaginaire est égale à zéro.

ulong longValue = 951034217;
System.Numerics.Complex c1 = longValue;
Console.WriteLine(c1);
// The example displays the following output:
//       (951034217, 0)

let longValue = 951034217
let c1: System.Numerics.Complex = longValue
printfn $"{c1}"
// The example displays the following output:
//       (951034217, 0)

Dim longValue As ULong = 951034217
Dim c1 As System.Numerics.Complex = longValue
Console.WriteLine(c1)
' The example displays the following output:
'       (951034217, 0)

S’applique à

Implicit(UInt32 to Complex)

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

Important

Cette API n’est pas conforme CLS.

Définit une conversion implicite d'un entier 32 bits non signé en nombre complexe.

Cette API n'est pas conforme CLS.

public:
 static operator System::Numerics::Complex(System::UInt32 value);
[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex (uint value);
[<System.CLSCompliant(false)>]
static member op_Implicit : uint32 -> System.Numerics.Complex
Public Shared Widening Operator CType (value As UInteger) As Complex

Paramètres

value
UInt32

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Attributs
CLSCompliantAttribute

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’un entier 32 bits non signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 32 bits non signé et dont la partie imaginaire est égale à zéro.

uint value = 197461;
System.Numerics.Complex c1 = value;
Console.WriteLine(c1);
// The example displays the following output:
//       (197461, 0)

let value = 197461
let c1: System.Numerics.Complex = value
printfn $"{c1}"
// The example displays the following output:
//       (197461, 0)

Dim intValue As UInteger = 197461
Dim c1 As System.Numerics.Complex = intValue
Console.WriteLine(c1)
' The example displays the following output:
'       (197461, 0)

S’applique à

Implicit(UInt16 to Complex)

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

Important

Cette API n’est pas conforme CLS.

Définit une conversion implicite d'un entier 16 bits non signé en nombre complexe.

Cette API n'est pas conforme CLS.

public:
 static operator System::Numerics::Complex(System::UInt16 value);
[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex (ushort value);
[<System.CLSCompliant(false)>]
static member op_Implicit : uint16 -> System.Numerics.Complex
Public Shared Widening Operator CType (value As UShort) As Complex

Paramètres

value
UInt16

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Attributs
CLSCompliantAttribute

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’un entier 16 bits non signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 16 bits non signé et dont la partie imaginaire est égale à zéro.

ushort shortValue = 421;
System.Numerics.Complex c1 = shortValue;
Console.WriteLine(c1);
// The example displays the following output:
//       (421, 0)

let shortValue = 421
let c1: System.Numerics.Complex = shortValue
printfn $"{c1}"
// The example displays the following output:
//       (421, 0)

Dim shortValue As UShort = 421
Dim c1 As System.Numerics.Complex = shortValue
Console.WriteLine(c1)
' The example displays the following output:
'       (421, 0)

S’applique à

Implicit(Single to Complex)

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

Définit une conversion implicite d'un nombre à virgule flottante simple précision en un nombre complexe.

public:
 static operator System::Numerics::Complex(float value);
public static implicit operator System.Numerics.Complex (float value);
static member op_Implicit : single -> System.Numerics.Complex
Public Shared Widening Operator CType (value As Single) As Complex

Paramètres

value
Single

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’une Single valeur en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à la valeur et dont la Single partie imaginaire est égale à zéro.

float singleValue = 1.032e-08f;
System.Numerics.Complex c1 = singleValue;
Console.WriteLine(c1);
// The example displays the following output:
//       (1.03199999657022E-08, 0)

let singleValue = 1.032e-08f
let c1: System.Numerics.Complex = singleValue
printfn $"{c1}"
// The example displays the following output:
//       (1.03199999657022E-08, 0)

Dim singleValue As Single = 1.032e-08
Dim c1 As System.Numerics.Complex = singleValue
Console.WriteLine(c1)
' The example displays the following output:
'       (1.03199999657022E-08, 0)

S’applique à

Implicit(IntPtr to Complex)

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

Convertit implicitement une IntPtr valeur en nombre complexe à double précision.

public:
 static operator System::Numerics::Complex(IntPtr value);
public static implicit operator System.Numerics.Complex (IntPtr value);
static member op_Implicit : nativeint -> System.Numerics.Complex
Public Shared Widening Operator CType (value As IntPtr) As Complex

Paramètres

value
IntPtr

nativeint

La valeur à convertir.

Retours

Complex

value converti en nombre complexe double précision.

S’applique à

Implicit(Double to Complex)

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

Définit une conversion implicite d'un nombre à virgule flottante double précision en un nombre complexe.

public:
 static operator System::Numerics::Complex(double value);
public static implicit operator System.Numerics.Complex (double value);
static member op_Implicit : double -> System.Numerics.Complex
Public Shared Widening Operator CType (value As Double) As Complex

Paramètres

value
Double

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’une Double valeur en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à la valeur et dont la Double partie imaginaire est égale à zéro.

double doubleValue = 1.032e-16;
System.Numerics.Complex c1 = doubleValue;
Console.WriteLine(c1);
// The example displays the following output:
//       (1.032E-16, 0)

let doubleValue = 1.032e-16
let c1: System.Numerics.Complex = doubleValue
printfn $"{c1}"
// The example displays the following output:
//       (1.032E-16, 0)

Dim doubleValue As Double = 1.032e-16
Dim c1 As System.Numerics.Complex = doubleValue
Console.WriteLine(c1)
' The example displays the following output:
'       (1.032E-16, 0)

S’applique à

Implicit(Int32 to Complex)

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

Définit une conversion implicite d'un entier 32 bits signé en nombre complexe.

public:
 static operator System::Numerics::Complex(int value);
public static implicit operator System.Numerics.Complex (int value);
static member op_Implicit : int -> System.Numerics.Complex
Public Shared Widening Operator CType (value As Integer) As Complex

Paramètres

value
Int32

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de casting explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’un entier 32 bits signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 32 bits signé et dont la partie imaginaire est égale à zéro.

int intValue = 1034217;
System.Numerics.Complex c1 = intValue;
Console.WriteLine(c1);
// The example displays the following output:
//       (1034217, 0)

let intValue = 1034217
let c1: System.Numerics.Complex = intValue
printfn $"{c1}"
// The example displays the following output:
//       (1034217, 0)

Dim intValue As Integer = 1034217
Dim c1 As System.Numerics.Complex = intValue
Console.WriteLine(c1)
' The example displays the following output:
'       (1034217, 0)

S’applique à

Implicit(Int16 to Complex)

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

Définit une conversion implicite d'un entier 16 bits signé en nombre complexe.

public:
 static operator System::Numerics::Complex(short value);
public static implicit operator System.Numerics.Complex (short value);
static member op_Implicit : int16 -> System.Numerics.Complex
Public Shared Widening Operator CType (value As Short) As Complex

Paramètres

value
Int16

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’un entier 16 bits signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 16 bits signé et dont la partie imaginaire est égale à zéro.

short shortValue = 16024;
System.Numerics.Complex c1 = shortValue;
Console.WriteLine(c1);
// The example displays the following output:
//       (16024, 0)

let shortValue = 16024
let c1: System.Numerics.Complex = shortValue
printfn $"{c1}"
// The example displays the following output:
//       (16024, 0)

Dim shortValue As Short = 16024
Dim c1 As System.Numerics.Complex = shortValue
Console.WriteLine(c1)
' The example displays the following output:
'       (16024, 0)

S’applique à

Implicit(Half to Complex)

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

Convertit implicitement une Half valeur en nombre complexe double précision.

public:
 static operator System::Numerics::Complex(Half value);
public static implicit operator System.Numerics.Complex (Half value);
static member op_Implicit : Half -> System.Numerics.Complex
Public Shared Widening Operator CType (value As Half) As Complex

Paramètres

value
Half

La valeur à convertir.

Retours

Complex

value converti en nombre complexe double précision.

S’applique à

Implicit(Int64 to Complex)

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

Définit une conversion implicite d'un entier 64 bits signé en nombre complexe.

public:
 static operator System::Numerics::Complex(long value);
public static implicit operator System.Numerics.Complex (long value);
static member op_Implicit : int64 -> System.Numerics.Complex
Public Shared Widening Operator CType (value As Long) As Complex

Paramètres

value
Int64

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’un entier 64 bits signé en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à l’entier 64 bits signé et dont la partie imaginaire est égale à zéro.

long longValue = 951034217;
System.Numerics.Complex c1 = longValue;
Console.WriteLine(c1);
// The example displays the following output:
//       (951034217, 0)

let longValue = 951034217
let c1: System.Numerics.Complex = longValue
printfn $"{c1}"
// The example displays the following output:
//       (951034217, 0)

Dim longValue As Long = 951034217
Dim c1 As System.Numerics.Complex = longValue
Console.WriteLine(c1)
' The example displays the following output:
'       (951034217, 0)

S’applique à

Implicit(Char to Complex)

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

Convertit implicitement une Char valeur en nombre complexe double précision.

public:
 static operator System::Numerics::Complex(char value);
public static implicit operator System.Numerics.Complex (char value);
static member op_Implicit : char -> System.Numerics.Complex
Public Shared Widening Operator CType (value As Char) As Complex

Paramètres

value
Char

La valeur à convertir.

Retours

Complex

value converti en nombre complexe double précision.

S’applique à

Implicit(Byte to Complex)

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

Définit une conversion implicite d'un octet non signé en nombre complexe.

public:
 static operator System::Numerics::Complex(System::Byte value);
public static implicit operator System.Numerics.Complex (byte value);
static member op_Implicit : byte -> System.Numerics.Complex
Public Shared Widening Operator CType (value As Byte) As Complex

Paramètres

value
Byte

Valeur à convertir en nombre complexe.

Retours

Complex

Objet qui contient la valeur du paramètre value comme partie réelle et zéro comme partie imaginaire.

Remarques

Les surcharges de l’opérateur Implicit définissent les types à partir desquels un compilateur peut convertir automatiquement un Complex objet sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Il s’agit de conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas de OverflowException.

Cette surcharge permet au compilateur de gérer les conversions d’une Byte valeur en nombre complexe, comme le montre l’exemple suivant. Notez que le résultat de la conversion est un nombre complexe dont la partie réelle est égale à la valeur et dont la Byte partie imaginaire est égale à zéro.

byte byteValue = 122;
System.Numerics.Complex c1 = byteValue;
Console.WriteLine(c1);
// The example displays the following output:
//       (122, 0)

let byteValue = 122
let c1: System.Numerics.Complex = byteValue
printfn $"{c1}"
// The example displays the following output:
//       (122, 0)

Dim byteValue As Byte = 122
Dim c1 As System.Numerics.Complex = byteValue
Console.WriteLine(c1)
' The example displays the following output:
'       (122, 0)

S’applique à