Complex.Explicit Operador

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

Devoluções

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

Exemplos

O exemplo seguinte 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)

Observações

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

A conversão de um Decimal valor para a parte real de um número complexo pode resultar numa 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.

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

Devoluções

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

Exemplos

O exemplo seguinte 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)

Observações

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

A conversão de um BigInteger valor para a parte real de um número complexo pode resultar numa 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 lança um OverflowException. Em vez disso, se value for menor que MinValue, o resultado é um número complexo cujo Real valor de propriedade é igual a NegativeInfinity. Se value for maior que MaxValue, o resultado é um número complexo cujo Real valor de propriedade é igual a PositiveInfinity.