Complex.Explicit Operador

Definição

Namespace:

System.Numerics

Assembly:

System.Runtime.Numerics.dll

Define uma conversão explícita entre um objeto Complex e outro tipo.

Sobrecargas

Explicit(UInt128 to Complex)	Converte explicitamente um UInt128 valor em um número complexo de precisão dupla.
Explicit(BigInteger to Complex)	Define uma conversão explícita de um valor BigInteger para um número complexo.
Explicit(Decimal to Complex)	Define uma conversão explícita de um valor Decimal para um número complexo.
Explicit(Int128 to Complex)	Converte explicitamente um Int128 valor em um número complexo de precisão dupla.

Explicit(UInt128 to Complex)

Origem:

Complex.cs

Importante

Esta API não está em conformidade com CLS.

Converte explicitamente um UInt128 valor em um número complexo de precisão dupla.

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

Parâmetros

value

UInt128

O valor a ser convertido.

Retornos

Complex

value convertido em um número complexo de precisão dupla.

Atributos

CLSCompliantAttribute

Explicit(BigInteger to Complex)

Origem:

Complex.cs

Define uma conversão explícita de um valor BigInteger para um número complexo.

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

Parâmetros

value

BigInteger

O valor a ser convertido em um número complexo.

Retornos

Complex

Um número complexo que tem um componente real igual a value e um componente imaginário igual a zero.

Exemplos

O exemplo a seguir ilustra a conversão explícita de BigInteger valores em Complex valores.

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)

Comentários

Operadores de conversão explícitos definem tipos que podem ser convertidos em um Complex objeto . Os compiladores de linguagem não executam essa conversão automaticamente porque ela pode envolver perda de dados. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType no Visual Basic) for usado. Caso contrário, eles exibem um erro do compilador.

A conversão de um BigInteger valor para a parte real de um número complexo pode resultar em uma perda de precisão porque um Double, que é o tipo da propriedade do Real número complexo, tem menos dígitos significativos do que um BigInteger.

Se a conversão não for bem-sucedida porque o BigInteger valor está fora do intervalo do Double tipo, a operação não gerará um OverflowException. Em vez disso, se value for menor que MinValue, o resultado será um número complexo que tem um Real valor de propriedade igual a NegativeInfinity. Se value for maior que MaxValue, o resultado será um número complexo que tem um Real valor de propriedade igual a PositiveInfinity.

Explicit(Decimal to Complex)

Origem:

Complex.cs

Define uma conversão explícita de um valor Decimal para um número complexo.

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

Parâmetros

value

Decimal

O valor a ser convertido em um número complexo.

Retornos

Complex

Um número complexo que tem um componente real igual a value e um componente imaginário igual a zero.

Exemplos

O exemplo a seguir ilustra a conversão explícita de Decimal valores em Complex valores.

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)

Comentários

Operadores de conversão explícitos definem tipos que podem ser convertidos em um Complex objeto . Os compiladores de linguagem não executam essa conversão automaticamente porque ela pode envolver perda de dados. Em vez disso, eles executam a conversão somente se um operador de conversão (em C#) ou uma função de conversão (como CType no Visual Basic) for usado. Caso contrário, eles exibem um erro do compilador.

A conversão de um Decimal valor para a parte real de um número complexo pode resultar em uma perda de precisão porque um Double, que é o tipo da propriedade do Real número complexo, tem menos dígitos significativos do que um Decimal.

Explicit(Int128 to Complex)

Origem:

Complex.cs

Converte explicitamente um Int128 valor em um número complexo de precisão dupla.

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

Parâmetros

value

Int128

O valor a ser convertido.

Retornos

Complex

value convertido em um número complexo de precisão dupla.