BitConverter.DoubleToInt64Bits(Double) Método

Referência

Definição

Namespace:: System

Assembly:: System.Runtime.Extensions.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: BitConverter.cs

Origem:: BitConverter.cs

Origem:: BitConverter.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Converte o número de ponto flutuante de precisão dupla especificado em um inteiro com sinal de 64 bits.

public:
 static long DoubleToInt64Bits(double value);

public static long DoubleToInt64Bits (double value);

static member DoubleToInt64Bits : double -> int64

Public Shared Function DoubleToInt64Bits (value As Double) As Long

Parâmetros

value: Double

O número a ser convertido.

Retornos

Int64

Um inteiro com sinal de 64 bits cujo valor é equivalente a value.

Exemplos

O exemplo de código a seguir converte os padrões de bits de vários Double valores em Int64 valores com o DoubleToInt64Bits método .

// Example of the BitConverter::DoubleToInt64Bits method.
using namespace System;

// Reinterpret the double argument as an __int64.
void DoubleToLongBits( double argument )
{
   __int64 longValue;
   longValue = BitConverter::DoubleToInt64Bits( argument );
   
   // Display the resulting __int64 in hexadecimal.
   Console::WriteLine( "{0,25:E16}{1,23:X16}", argument, longValue );
}

int main()
{
   Console::WriteLine( "This example of the BitConverter::DoubleToInt64Bits( "
   "double ) \nmethod generates the following output.\n" );
   Console::WriteLine( "{0,25:E16}{1,23:X16}", "double argument", "hexadecimal value" );
   Console::WriteLine( "{0,25:E16}{1,23:X16}", "---------------", "-----------------" );
   
   // Convert double values and display the results.
   DoubleToLongBits( 1.0 );
   DoubleToLongBits( 15.0 );
   DoubleToLongBits( 255.0 );
   DoubleToLongBits( 4294967295.0 );
   DoubleToLongBits( 0.00390625 );
   DoubleToLongBits( 0.00000000023283064365386962890625 );
   DoubleToLongBits( 1.234567890123E-300 );
   DoubleToLongBits( 1.23456789012345E-150 );
   DoubleToLongBits( 1.2345678901234565 );
   DoubleToLongBits( 1.2345678901234567 );
   DoubleToLongBits( 1.2345678901234569 );
   DoubleToLongBits( 1.23456789012345678E+150 );
   DoubleToLongBits( 1.234567890123456789E+300 );
   DoubleToLongBits( Double::MinValue );
   DoubleToLongBits( Double::MaxValue );
   DoubleToLongBits( Double::Epsilon );
   DoubleToLongBits( Double::NaN );
   DoubleToLongBits( Double::NegativeInfinity );
   DoubleToLongBits( Double::PositiveInfinity );
}

/*
This example of the BitConverter::DoubleToInt64Bits( double )
method generates the following output.

          double argument      hexadecimal value
          ---------------      -----------------
  1.0000000000000000E+000       3FF0000000000000
  1.5000000000000000E+001       402E000000000000
  2.5500000000000000E+002       406FE00000000000
  4.2949672950000000E+009       41EFFFFFFFE00000
  3.9062500000000000E-003       3F70000000000000
  2.3283064365386963E-010       3DF0000000000000
  1.2345678901230000E-300       01AA74FE1C1E7E45
  1.2345678901234500E-150       20D02A36586DB4BB
  1.2345678901234565E+000       3FF3C0CA428C59FA
  1.2345678901234567E+000       3FF3C0CA428C59FB
  1.2345678901234569E+000       3FF3C0CA428C59FC
  1.2345678901234569E+150       5F182344CD3CDF9F
  1.2345678901234569E+300       7E3D7EE8BCBBD352
 -1.7976931348623157E+308       FFEFFFFFFFFFFFFF
  1.7976931348623157E+308       7FEFFFFFFFFFFFFF
  4.9406564584124654E-324       0000000000000001
                      NaN       FFF8000000000000
                -Infinity       FFF0000000000000
                 Infinity       7FF0000000000000
*/

// Example of the BitConverter.DoubleToInt64Bits method.
using System;

class DoubleToInt64BitsDemo
{
    const string formatter = "{0,25:E16}{1,23:X16}";

    // Reinterpret the double argument as a long.
    public static void DoubleToLongBits( double argument )
    {
        long longValue;
        longValue = BitConverter.DoubleToInt64Bits( argument );

        // Display the resulting long in hexadecimal.
        Console.WriteLine( formatter, argument, longValue );
    }

    public static void Main( )
    {
        Console.WriteLine(
            "This example of the BitConverter.DoubleToInt64Bits( " +
            "double ) \nmethod generates the following output.\n" );
        Console.WriteLine( formatter, "double argument",
            "hexadecimal value" );
        Console.WriteLine( formatter, "---------------",
            "-----------------" );

        // Convert double values and display the results.
        DoubleToLongBits( 1.0 );
        DoubleToLongBits( 15.0 );
        DoubleToLongBits( 255.0 );
        DoubleToLongBits( 4294967295.0 );
        DoubleToLongBits( 0.00390625 );
        DoubleToLongBits( 0.00000000023283064365386962890625 );
        DoubleToLongBits( 1.234567890123E-300 );
        DoubleToLongBits( 1.23456789012345E-150 );
        DoubleToLongBits( 1.2345678901234565 );
        DoubleToLongBits( 1.2345678901234567 );
        DoubleToLongBits( 1.2345678901234569 );
        DoubleToLongBits( 1.23456789012345678E+150 );
        DoubleToLongBits( 1.234567890123456789E+300 );
        DoubleToLongBits( double.MinValue );
        DoubleToLongBits( double.MaxValue );
        DoubleToLongBits( double.Epsilon );
        DoubleToLongBits( double.NaN );
        DoubleToLongBits( double.NegativeInfinity );
        DoubleToLongBits( double.PositiveInfinity );
    }
}

/*
This example of the BitConverter.DoubleToInt64Bits( double )
method generates the following output.

          double argument      hexadecimal value
          ---------------      -----------------
  1.0000000000000000E+000       3FF0000000000000
  1.5000000000000000E+001       402E000000000000
  2.5500000000000000E+002       406FE00000000000
  4.2949672950000000E+009       41EFFFFFFFE00000
  3.9062500000000000E-003       3F70000000000000
  2.3283064365386963E-010       3DF0000000000000
  1.2345678901230000E-300       01AA74FE1C1E7E45
  1.2345678901234500E-150       20D02A36586DB4BB
  1.2345678901234565E+000       3FF3C0CA428C59FA
  1.2345678901234567E+000       3FF3C0CA428C59FB
  1.2345678901234569E+000       3FF3C0CA428C59FC
  1.2345678901234569E+150       5F182344CD3CDF9F
  1.2345678901234569E+300       7E3D7EE8BCBBD352
 -1.7976931348623157E+308       FFEFFFFFFFFFFFFF
  1.7976931348623157E+308       7FEFFFFFFFFFFFFF
  4.9406564584124654E-324       0000000000000001
                      NaN       FFF8000000000000
                -Infinity       FFF0000000000000
                 Infinity       7FF0000000000000
*/

open System

let print obj1 obj2 = 
    printfn $"{obj1,25:E16}{obj2,23:X16}"

// Reinterpret the double argument as a long.
let doubleToLongBits argument =
    let longValue = BitConverter.DoubleToInt64Bits argument

    // Display the resulting long in hexadecimal.
    print argument longValue

printfn "This example of the BitConverter.DoubleToInt64Bits(Double) \nmethod generates the following output.\n"
print "double argument" "hexadecimal value"
print "---------------" "-----------------"

// Convert double values and display the results.
doubleToLongBits 1.0
doubleToLongBits 15.0
doubleToLongBits 255.0
doubleToLongBits 4294967295.0
doubleToLongBits 0.00390625
doubleToLongBits 0.00000000023283064365386962890625
doubleToLongBits 1.234567890123E-300
doubleToLongBits 1.23456789012345E-150
doubleToLongBits 1.2345678901234565
doubleToLongBits 1.2345678901234567
doubleToLongBits 1.2345678901234569
doubleToLongBits 1.23456789012345678E+150
doubleToLongBits 1.234567890123456789E+300
doubleToLongBits Double.MinValue
doubleToLongBits Double.MaxValue
doubleToLongBits Double.Epsilon
doubleToLongBits Double.NaN
doubleToLongBits Double.NegativeInfinity
doubleToLongBits Double.PositiveInfinity


// This example of the BitConverter.DoubleToInt64Bits( double )
// method generates the following output.

//           double argument      hexadecimal value
//           ---------------      -----------------
//   1.0000000000000000E+000       3FF0000000000000
//   1.5000000000000000E+001       402E000000000000
//   2.5500000000000000E+002       406FE00000000000
//   4.2949672950000000E+009       41EFFFFFFFE00000
//   3.9062500000000000E-003       3F70000000000000
//   2.3283064365386963E-010       3DF0000000000000
//   1.2345678901230000E-300       01AA74FE1C1E7E45
//   1.2345678901234500E-150       20D02A36586DB4BB
//   1.2345678901234565E+000       3FF3C0CA428C59FA
//   1.2345678901234567E+000       3FF3C0CA428C59FB
//   1.2345678901234569E+000       3FF3C0CA428C59FC
//   1.2345678901234569E+150       5F182344CD3CDF9F
//   1.2345678901234569E+300       7E3D7EE8BCBBD352
//  -1.7976931348623157E+308       FFEFFFFFFFFFFFFF
//   1.7976931348623157E+308       7FEFFFFFFFFFFFFF
//   4.9406564584124654E-324       0000000000000001
//                       NaN       FFF8000000000000
//                        -∞       FFF0000000000000
//                         ∞       7FF0000000000000

' Example of the BitConverter.DoubleToInt64Bits method.
Module DoubleToInt64BitsDemo

    Const formatter As String = "{0,25:E16}{1,23:X16}"
 
    ' Reinterpret the Double argument as a Long.
    Sub DoubleToLongBits( argument As Double )

        Dim longValue    As Long
        longValue = BitConverter.DoubleToInt64Bits( argument )

        ' Display the resulting Long in hexadecimal.
        Console.WriteLine( formatter, argument, longValue )
    End Sub 
       
    Sub Main( )

        Console.WriteLine( _
            "This example of the BitConverter.DoubleToInt64Bits( " & _
            "Double ) " & vbCrLf & "method generates the " & _
            "following output." & vbCrLf )
        Console.WriteLine( formatter, "Double argument", _
            "hexadecimal value" )
        Console.WriteLine( formatter, "---------------", _
            "-----------------" )
          
        ' Convert Double values and display the results.
        DoubleToLongBits( 1.0 )
        DoubleToLongBits( 15.0 )
        DoubleToLongBits( 255.0 )
        DoubleToLongBits( 4294967295.0 )
        DoubleToLongBits( 0.00390625 )
        DoubleToLongBits( 0.00000000023283064365386962890625 )
        DoubleToLongBits( 1.234567890123E-300 )
        DoubleToLongBits( 1.23456789012345E-150 )
        DoubleToLongBits( 1.2345678901234565 )
        DoubleToLongBits( 1.2345678901234567 )
        DoubleToLongBits( 1.2345678901234569 )
        DoubleToLongBits( 1.23456789012345678E+150 )
        DoubleToLongBits( 1.234567890123456789E+300 )
        DoubleToLongBits( Double.MinValue )
        DoubleToLongBits( Double.MaxValue )
        DoubleToLongBits( Double.Epsilon )
        DoubleToLongBits( Double.NaN )
        DoubleToLongBits( Double.NegativeInfinity )
        DoubleToLongBits( Double.PositiveInfinity )
    End Sub 
End Module

' This example of the BitConverter.DoubleToInt64Bits( Double )
' method generates the following output.
' 
'           Double argument      hexadecimal value
'           ---------------      -----------------
'   1.0000000000000000E+000       3FF0000000000000
'   1.5000000000000000E+001       402E000000000000
'   2.5500000000000000E+002       406FE00000000000
'   4.2949672950000000E+009       41EFFFFFFFE00000
'   3.9062500000000000E-003       3F70000000000000
'   2.3283064365386963E-010       3DF0000000000000
'   1.2345678901230000E-300       01AA74FE1C1E7E45
'   1.2345678901234500E-150       20D02A36586DB4BB
'   1.2345678901234565E+000       3FF3C0CA428C59FA
'   1.2345678901234567E+000       3FF3C0CA428C59FB
'   1.2345678901234569E+000       3FF3C0CA428C59FC
'   1.2345678901234569E+150       5F182344CD3CDF9F
'   1.2345678901234569E+300       7E3D7EE8BCBBD352
'  -1.7976931348623157E+308       FFEFFFFFFFFFFFFF
'   1.7976931348623157E+308       7FEFFFFFFFFFFFFF
'   4.9406564584124654E-324       0000000000000001
'                       NaN       FFF8000000000000
'                 -Infinity       FFF0000000000000
'                  Infinity       7FF0000000000000

Comentários

A ordem dos bits no inteiro retornado pelo DoubleToInt64Bits método depende se a arquitetura do computador é little-endian ou big-endian.

Aplica-se a

Confira também

Int64BitsToDouble(Int64)

Partilhar via