Complex.Implicit Operator

Definiuje niejawną konwersję 64-bitowej liczby całkowitej bez znaku na liczbę zespoloną.Defines an implicit conversion of a 64-bit unsigned integer to a complex number.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant.

public:
 static operator System::Numerics::Complex(System::UInt64 value);

[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex (ulong value);

static member op_Implicit : uint64 -> System.Numerics.Complex

Public Shared Widening Operator CType (value As ULong) As Complex

Parametry

Zwraca

Atrybuty

CLSCompliantAttribute

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

Dzięki temu przeciążeniu kompilator obsługuje konwersje z niepodpisanej 64-bitowej liczby całkowitej do liczby zespolonej, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from an unsigned 64-bit integer to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa niepodpisanej 64-bitowej liczbie całkowitej i której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the unsigned 64-bit integer and whose imaginary part is equal to zero.

ulong longValue = 951034217;
System.Numerics.Complex c1 = longValue;
Console.WriteLine(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)

Definiuje niejawną konwersję 32-bitowej liczby całkowitej bez znaku na liczbę zespoloną.Defines an implicit conversion of a 32-bit unsigned integer to a complex number.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant.

public:
 static operator System::Numerics::Complex(System::UInt32 value);

[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex (uint value);

static member op_Implicit : uint32 -> System.Numerics.Complex

Public Shared Widening Operator CType (value As UInteger) As Complex

Parametry

Zwraca

Atrybuty

CLSCompliantAttribute

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

Dzięki temu przeciążeniu kompilator obsługuje konwersje z niepodpisanej 32-bitowej liczby całkowitej do liczby zespolonej, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from an unsigned 32-bit integer to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa niepodpisanej 32-bitowej liczbie całkowitej i której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the unsigned 32-bit integer and whose imaginary part is equal to zero.

uint value = 197461;
System.Numerics.Complex c1 = value;
Console.WriteLine(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)

Definiuje niejawną konwersję 16-bitowej liczby całkowitej bez znaku na liczbę zespoloną.Defines an implicit conversion of a 16-bit unsigned integer to a complex number.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant.

public:
 static operator System::Numerics::Complex(System::UInt16 value);

[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex (ushort value);

static member op_Implicit : uint16 -> System.Numerics.Complex

Public Shared Widening Operator CType (value As UShort) As Complex

Parametry

Zwraca

Atrybuty

CLSCompliantAttribute

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

Dzięki temu przeciążeniu można przeprowadzić konwersje z niepodpisanej 16-bitową liczbą całkowitą do liczby zespolonej, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from an unsigned 16-bit integer to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa 16-bitowej liczbie całkowitej bez znaku i której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the unsigned 16-bit integer and whose imaginary part is equal to zero.

ushort shortValue = 421;
System.Numerics.Complex c1 = shortValue;
Console.WriteLine(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)

Definiuje niejawną konwersję liczby zmiennoprzecinkowej o pojedynczej precyzji na liczbę zespoloną.Defines an implicit conversion of a single-precision floating-point number to a complex number.

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

Parametry

Zwraca

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

To przeciążenie umożliwia kompilatorowi obsługę konwersji z Single wartości na liczbę zespoloną, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from a Single value to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa Single wartości i której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the Single value and whose imaginary part is equal to zero.

float singleValue = 1.032e-08f;
System.Numerics.Complex c1 = singleValue;
Console.WriteLine(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) 

Definiuje niejawną konwersję podpisanego bajtu na liczbę zespoloną.Defines an implicit conversion of a signed byte to a complex number.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant.

public:
 static operator System::Numerics::Complex(System::SByte value);

[System.CLSCompliant(false)]
public static implicit operator System.Numerics.Complex (sbyte value);

static member op_Implicit : sbyte -> System.Numerics.Complex

Public Shared Widening Operator CType (value As SByte) As Complex

Parametry

Zwraca

Atrybuty

CLSCompliantAttribute

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

To przeciążenie umożliwia kompilatorowi obsługę konwersji z podpisanego bajtu na liczbę zespoloną, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from a signed byte to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa bajtowi podpisanemu i której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the signed byte and whose imaginary part is equal to zero.

sbyte sbyteValue = -12;
System.Numerics.Complex c1 = sbyteValue;
Console.WriteLine(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)

Definiuje niejawną konwersję 32-bitowej podpisanej liczby całkowitej na liczbę zespoloną.Defines an implicit conversion of a 32-bit signed integer to a complex number.

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

Parametry

Zwraca

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

Dzięki temu przeciążeniu można przeprowadzić konwersję dojścia kompilatora ze podpisanej 32-bitowej liczby całkowitej do liczby zespolonej, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from a signed 32-bit integer to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa podpisanej 32-bitowej liczbie całkowitej i której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the signed 32-bit integer and whose imaginary part is equal to zero.

int intValue = 1034217;
System.Numerics.Complex c1 = intValue;
Console.WriteLine(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)

Definiuje niejawną konwersję 16-bitowej podpisanej liczby całkowitej na liczbę zespoloną.Defines an implicit conversion of a 16-bit signed integer to a complex number.

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

Parametry

Zwraca

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

Dzięki temu przeciążeniu można przeprowadzić konwersję na podstawie 16-bitowej liczby całkowitej ze znakiem na liczbę zespoloną, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from a signed 16-bit integer to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa podpisanej 16-bitowej liczbie całkowitej, a której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the signed 16-bit integer and whose imaginary part is equal to zero.

short shortValue = 16024;
System.Numerics.Complex c1 = shortValue;
Console.WriteLine(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)

Definiuje niejawną konwersję liczby zmiennoprzecinkowej o podwójnej precyzji na liczbę zespoloną.Defines an implicit conversion of a double-precision floating-point number to a complex number.

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

Parametry

Zwraca

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

To przeciążenie umożliwia kompilatorowi obsługę konwersji z Double wartości na liczbę zespoloną, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from a Double value to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa Double wartości i której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the Double value and whose imaginary part is equal to zero.

double doubleValue = 1.032e-16;
System.Numerics.Complex c1 = doubleValue;
Console.WriteLine(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) 

Definiuje niejawną konwersję niepodpisanego bajtu na liczbę zespoloną.Defines an implicit conversion of an unsigned byte to a complex number.

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

Parametry

Zwraca

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

To przeciążenie umożliwia kompilatorowi obsługę konwersji z Byte wartości na liczbę zespoloną, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from a Byte value to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa Byte wartości i której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the Byte value and whose imaginary part is equal to zero.

byte byteValue = 122;
System.Numerics.Complex c1 = byteValue;
Console.WriteLine(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) 

Definiuje niejawną konwersję 64-bitowej podpisanej liczby całkowitej na liczbę zespoloną.Defines an implicit conversion of a 64-bit signed integer to a complex number.

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

Parametry

Zwraca

Uwagi

Przeciążenia Implicit operatora definiują typy, z których kompilator może automatycznie Complex skonwertować obiekt bez jawnego operatora rzutowania (in C#) lub wywołania funkcji konwersji (w Visual Basic).The overloads of the Implicit operator define the types from which a compiler can automatically convert a Complex object without an explicit casting operator (in C#) or a call to a conversion function (in Visual Basic). Są to rozszerzające konwersje, które nie obejmują utraty danych i nie generują OverflowException.They are widening conversions that do not involve data loss and do not throw an OverflowException.

Dzięki temu przeciążeniu można przeprowadzić konwersję dojścia kompilatora ze podpisanej 64-bitowej liczby całkowitej do liczby zespolonej, jak pokazano w poniższym przykładzie.This overload lets the compiler handle conversions from a signed 64-bit integer to a complex number, as the following example shows. Należy zauważyć, że wynik konwersji jest liczbą zespoloną, której część rzeczywista jest równa podpisanej 64-bitowej liczbie całkowitej i której część urojona jest równa zero.Note that the result of the conversion is a complex number whose real part is equal to the signed 64-bit integer and whose imaginary part is equal to zero.

long longValue = 951034217;
System.Numerics.Complex c1 = longValue;
Console.WriteLine(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)