Decimal.GetBits Method
Definition
Important
Some information relates to prerelease product that may be substantially modified before it’s released. Microsoft makes no warranties, express or implied, with respect to the information provided here.
Overloads
| GetBits(Decimal) |
Converts the value of a specified instance of Decimal to its equivalent binary representation. |
| GetBits(Decimal, Span<Int32>) |
Converts the value of a specified instance of Decimal to its equivalent binary representation. |
GetBits(Decimal)
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Converts the value of a specified instance of Decimal to its equivalent binary representation.
public:
static cli::array <int> ^ GetBits(System::Decimal d);public static int[] GetBits (decimal d);static member GetBits : decimal -> int[]Public Shared Function GetBits (d As Decimal) As Integer()Parameters
- d
- Decimal
The value to convert.
Returns
A 32-bit signed integer array with four elements that contain the binary representation of d.
Examples
The following example uses the GetBits method to convert several Decimal values to their equivalent binary representations. It then displays the decimal values and the hexadecimal value of the elements in the array returned by the GetBits method.
using namespace System;
int main()
{
// Define an array of Decimal values.
array<Decimal>^ values = gcnew array<Decimal> { Decimal::One,
Decimal::Parse("100000000000000"),
Decimal::Parse("10000000000000000000000000000"),
Decimal::Parse("100000000000000.00000000000000"),
Decimal::Parse("1.0000000000000000000000000000"),
Decimal::Parse("123456789"),
Decimal::Parse("0.123456789"),
Decimal::Parse("0.000000000123456789"),
Decimal::Parse("0.000000000000000000123456789"),
Decimal::Parse("4294967295.0"),
Decimal::Parse("18446744073709551615.0"),
Decimal::MaxValue, Decimal::MinValue,
Decimal::Parse("-7.9228162514264337593543950335") };
Console::WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"Argument", "Bits[3]", "Bits[2]", "Bits[1]", "Bits[0]" );
Console::WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"--------", "-------", "-------", "-------", "-------" );
for each (Decimal value in values)
{
array<int>^ bits = Decimal::GetBits(value);
Console::WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
value, bits[3], bits[2], bits[1], bits[0] );
}
}
/*
This example of the Decimal::GetBits( Decimal ) method
generates the following output. It displays the argument
as a Decimal and the result array in hexadecimal.
Argument Bits[3] Bits[2] Bits[1] Bits[0]
-------- ------- ------- ------- -------
1 00000000 00000000 00000000 00000001
100000000000000 00000000 00000000 00005AF3 107A4000
10000000000000000000000000000 00000000 204FCE5E 3E250261 10000000
100000000000000.00000000000000 000E0000 204FCE5E 3E250261 10000000
1.0000000000000000000000000000 001C0000 204FCE5E 3E250261 10000000
123456789 00000000 00000000 00000000 075BCD15
0.123456789 00090000 00000000 00000000 075BCD15
0.000000000123456789 00120000 00000000 00000000 075BCD15
0.000000000000000000123456789 001B0000 00000000 00000000 075BCD15
4294967295 00000000 00000000 00000000 FFFFFFFF
18446744073709551615 00000000 00000000 FFFFFFFF FFFFFFFF
79228162514264337593543950335 00000000 FFFFFFFF FFFFFFFF FFFFFFFF
-79228162514264337593543950335 80000000 FFFFFFFF FFFFFFFF FFFFFFFF
-7.9228162514264337593543950335 801C0000 FFFFFFFF FFFFFFFF FFFFFFFF
*/
using System;
class Example
{
public static void Main()
{
// Define an array of Decimal values.
Decimal[] values = { 1M, 100000000000000M, 10000000000000000000000000000M,
100000000000000.00000000000000M, 1.0000000000000000000000000000M,
123456789M, 0.123456789M, 0.000000000123456789M,
0.000000000000000000123456789M, 4294967295M,
18446744073709551615M, Decimal.MaxValue,
Decimal.MinValue, -7.9228162514264337593543950335M };
Console.WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"Argument", "Bits[3]", "Bits[2]", "Bits[1]",
"Bits[0]" );
Console.WriteLine( "{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"--------", "-------", "-------", "-------",
"-------" );
// Iterate each element and display its binary representation
foreach (var value in values) {
int[] bits = decimal.GetBits(value);
Console.WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
value, bits[3], bits[2], bits[1], bits[0]);
}
}
}
// The example displays the following output:
// Argument Bits[3] Bits[2] Bits[1] Bits[0]
// -------- ------- ------- ------- -------
// 1 00000000 00000000 00000000 00000001
// 100000000000000 00000000 00000000 00005AF3 107A4000
// 10000000000000000000000000000 00000000 204FCE5E 3E250261 10000000
// 100000000000000.00000000000000 000E0000 204FCE5E 3E250261 10000000
// 1.0000000000000000000000000000 001C0000 204FCE5E 3E250261 10000000
// 123456789 00000000 00000000 00000000 075BCD15
// 0.123456789 00090000 00000000 00000000 075BCD15
// 0.000000000123456789 00120000 00000000 00000000 075BCD15
// 0.000000000000000000123456789 001B0000 00000000 00000000 075BCD15
// 4294967295 00000000 00000000 00000000 FFFFFFFF
// 18446744073709551615 00000000 00000000 FFFFFFFF FFFFFFFF
// 79228162514264337593543950335 00000000 FFFFFFFF FFFFFFFF FFFFFFFF
// -79228162514264337593543950335 80000000 FFFFFFFF FFFFFFFF FFFFFFFF
// -7.9228162514264337593543950335 801C0000 FFFFFFFF FFFFFFFF FFFFFFFF
open System
// Define an list of Decimal values.
let values =
[ 1M; 100000000000000M; 10000000000000000000000000000M
100000000000000.00000000000000M; 1.0000000000000000000000000000M
123456789M; 0.123456789M; 0.000000000123456789M
0.000000000000000000123456789M; 4294967295M
18446744073709551615M; Decimal.MaxValue
Decimal.MinValue; -7.9228162514264337593543950335M ]
printfn $"""{"Argument",31} {"Bits[3]",10:X8}{"Bits[2]",10:X8}{"Bits[1]",10:X8}{"Bits[0]",10:X8}"""
printfn $"""{"--------",31} {"-------",10:X8}{"-------",10:X8}{"-------",10:X8}{"-------",10:X8}"""
// Iterate each element and display its binary representation
for value in values do
let bits = Decimal.GetBits value
printfn $"{value,31} {bits[3],10:X8}{bits[2],10:X8}{bits[1],10:X8}{bits[0],10:X8}"
// The example displays the following output:
// Argument Bits[3] Bits[2] Bits[1] Bits[0]
// -------- ------- ------- ------- -------
// 1 00000000 00000000 00000000 00000001
// 100000000000000 00000000 00000000 00005AF3 107A4000
// 10000000000000000000000000000 00000000 204FCE5E 3E250261 10000000
// 100000000000000.00000000000000 000E0000 204FCE5E 3E250261 10000000
// 1.0000000000000000000000000000 001C0000 204FCE5E 3E250261 10000000
// 123456789 00000000 00000000 00000000 075BCD15
// 0.123456789 00090000 00000000 00000000 075BCD15
// 0.000000000123456789 00120000 00000000 00000000 075BCD15
// 0.000000000000000000123456789 001B0000 00000000 00000000 075BCD15
// 4294967295 00000000 00000000 00000000 FFFFFFFF
// 18446744073709551615 00000000 00000000 FFFFFFFF FFFFFFFF
// 79228162514264337593543950335 00000000 FFFFFFFF FFFFFFFF FFFFFFFF
// -79228162514264337593543950335 80000000 FFFFFFFF FFFFFFFF FFFFFFFF
// -7.9228162514264337593543950335 801C0000 FFFFFFFF FFFFFFFF FFFFFFFF
Module Example
Public Sub Main()
' Define an array of decimal values.
Dim values() As Decimal = { 1d, 100000000000000d,
10000000000000000000000000000d,
100000000000000.00000000000000d,
1.0000000000000000000000000000d,
123456789d, 0.123456789d,
0.000000000123456789d,
0.000000000000000000123456789d,
4294967295d,
18446744073709551615d,
Decimal.MaxValue, Decimal.MinValue,
-7.9228162514264337593543950335d }
Console.WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"Argument", "Bits[3]", "Bits[2]", "Bits[1]",
"Bits[0]" )
Console.WriteLine( "{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
"--------", "-------", "-------", "-------",
"-------" )
' Iterate each element and display its binary representation
For Each value In values
Dim bits() As Integer = Decimal.GetBits(value)
Console.WriteLine("{0,31} {1,10:X8}{2,10:X8}{3,10:X8}{4,10:X8}",
value, bits(3), bits(2), bits(1), bits(0))
Next
End Sub
End Module
' The example displays the following output:
'
' Argument Bits(3) Bits(2) Bits(1) Bits(0)
' -------- ------- ------- ------- -------
' 1 00000000 00000000 00000000 00000001
' 100000000000000 00000000 00000000 00005AF3 107A4000
' 10000000000000000000000000000 00000000 204FCE5E 3E250261 10000000
' 100000000000000.00000000000000 000E0000 204FCE5E 3E250261 10000000
' 1.0000000000000000000000000000 001C0000 204FCE5E 3E250261 10000000
' 123456789 00000000 00000000 00000000 075BCD15
' 0.123456789 00090000 00000000 00000000 075BCD15
' 0.000000000123456789 00120000 00000000 00000000 075BCD15
' 0.000000000000000000123456789 001B0000 00000000 00000000 075BCD15
' 4294967295 00000000 00000000 00000000 FFFFFFFF
' 18446744073709551615 00000000 00000000 FFFFFFFF FFFFFFFF
' 79228162514264337593543950335 00000000 FFFFFFFF FFFFFFFF FFFFFFFF
' -79228162514264337593543950335 80000000 FFFFFFFF FFFFFFFF FFFFFFFF
' -7.9228162514264337593543950335 801C0000 FFFFFFFF FFFFFFFF FFFFFFFF
The following example uses the GetBits method to retrieve the component parts of an array. It then uses this array in the call to the Decimal(Int32, Int32, Int32, Boolean, Byte) constructor to instantiate a new Decimal value.
using System;
public class Example
{
public static void Main()
{
Decimal[] values = { 1234.96m, -1234.96m };
foreach (var value in values) {
int[] parts = Decimal.GetBits(value);
bool sign = (parts[3] & 0x80000000) != 0;
byte scale = (byte) ((parts[3] >> 16) & 0x7F);
Decimal newValue = new Decimal(parts[0], parts[1], parts[2], sign, scale);
Console.WriteLine("{0} --> {1}", value, newValue);
}
}
}
// The example displays the following output:
// 1234.96 --> 1234.96
// -1234.96 --> -1234.96
open System
let values = [ 1234.96m; -1234.96m ]
for value in values do
let parts = Decimal.GetBits value
let sign = (parts[3] &&& 0x80000000) <> 0
let scale = (parts[3] >>> 16) &&& 0x7F |> byte
let newValue = Decimal(parts[0], parts[1], parts[2], sign, scale)
printfn $"{value} --> {newValue}"
// The example displays the following output:
// 1234.96 --> 1234.96
// -1234.96 --> -1234.96
Module Example
Public Sub Main()
Dim values() As Decimal = { 1234.96d, -1234.96d }
For Each value In values
Dim parts() = Decimal.GetBits(value)
Dim sign As Boolean = (parts(3) And &h80000000) <> 0
Dim scale As Byte = CByte((parts(3) >> 16) And &H7F)
Dim newValue As New Decimal(parts(0), parts(1), parts(2), sign, scale)
Console.WriteLine("{0} --> {1}", value, newValue)
Next
End Sub
End Module
' The example displays the following output:
' 1234.96 --> 1234.96
' -1234.96 --> -1234.96
Remarks
The binary representation of a Decimal number consists of a 1-bit sign, a 96-bit integer number, and a scaling factor used to divide the integer number and specify what portion of it is a decimal fraction. The scaling factor is implicitly the number 10, raised to an exponent ranging from 0 to 28.
The return value is a four-element array of 32-bit signed integers.
The first, second, and third elements of the returned array contain the low, middle, and high 32 bits of the 96-bit integer number.
The fourth element of the returned array contains the scale factor and sign. It consists of the following parts:
Bits 0 to 15, the lower word, are unused and must be zero.
Bits 16 to 23 must contain an exponent between 0 and 28, which indicates the power of 10 to divide the integer number.
Bits 24 to 30 are unused and must be zero.
Bit 31 contains the sign: 0 mean positive, and 1 means negative.
Note that the bit representation differentiates between negative and positive zero. These values are treated as being equal in all operations.
See also
Applies to
GetBits(Decimal, Span<Int32>)
- Source:
- Decimal.cs
- Source:
- Decimal.cs
- Source:
- Decimal.cs
Converts the value of a specified instance of Decimal to its equivalent binary representation.
public:
static int GetBits(System::Decimal d, Span<int> destination);public static int GetBits (decimal d, Span<int> destination);static member GetBits : decimal * Span<int> -> intPublic Shared Function GetBits (d As Decimal, destination As Span(Of Integer)) As IntegerParameters
- d
- Decimal
The value to convert.
Returns
4, which is the number of integers in the binary representation.
Exceptions
The destination span was not long enough to store the binary representation.
Applies to
Feedback
Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback.
Submit and view feedback for