=== Converting from decimal representation to binary32 format===
In general refer to the IEEE 754 standard itself for the strict conversion (including the rounding behaviour)
of a real number into its equivalent binary32 format.
Here we can show how to convert a base 10 real number into an IEEE 754 binary32 format
using the following outline:
* consider a real number with an integer and a fraction part such as 12.375
* convert and [[normalized number|normalize]] the integer part into [[binary numeral system|binary]]
* convert the fraction part using the following technique as shown here
* add the two results and adjust them to produce a proper final conversion
'''Conversion of the fractional part:'''
consider 0.375, the fractional part of 12.375. To convert it into a binary fraction, multiply the fraction by 2, take the integer part and re-multiply new fraction by 2 until a fraction of zero is found or until the precision limit is reached which is 23 fraction digits for IEEE 754 binary32 format.
0.375 x 2 = 0.750 = 0 + 0.750 => b<sub>1</sub> = 0, the integer part represents the binary fraction digit. Re-multiply 0.750 by 2 to proceed
0.750 x 2 = 1.500 = 1 + 0.500 => b<sub>2</sub> = 1
0.500 x 2 = 1.000 = 1 + 0.000 => b<sub>3</sub> = 1, fraction = 0.000, terminate
We see that (0.375)<sub>10</sub> can be exactly represented in binary as (0.011)<sub>2</sub>. Not all decimal fractions can be represented in a finite digit binary fraction. For example decimal 0.1 cannot be represented in binary exactly. So it is only approximated.
Therefore (12.375)<sub>10</sub> = (12)<sub>10</sub> + (0.375)<sub>10</sub> = (1100)<sub>2</sub> + (0.011)<sub>2</sub> = (1100.011)<sub>2</sub>
Also IEEE 754 binary32 format requires that you represent real values in <math> (1.x_1x_2...x_{23})_2 \times 2^{e}</math> format, (see `Normalized number`, `Denormalized number`) so that 1100.011 is shifted to the right by 3 digits to become <math> (1.100011)_2 \times 2^{3} </math>
Finally we can see that: <math> (12.375)_{10} =(1.100011)_2 \times 2^{3} </math>
From which we deduce:
* The exponent is 3 (and in the biased form it is therefore 130 = 1000 0010)
* The fraction is 100011 (looking to the right of the binary point)
From these we can form the resulting 32 bit IEEE 754 binary32 format representation of
12.375 as: 0-10000010-10001100000000000000000 = 41460000<sub>H</sub>
'''Note:''' consider converting 68.123 into IEEE 754 binary32 format:
Using the above procedure you expect to get 42883EF9<sub>H</sub> with the last 4 bits being 1001
However due to the default rounding behaviour of IEEE 754 format what you get is 42883EFA<sub>H</sub> whose last 4 bits are 1010 .
'''Ex 1:'''
Consider decimal 1
We can see that: <math> (1)_{10} =(1.0)_2 \times 2^{0} </math>
From which we deduce:
* The exponent is 0 (and in the biased form it is therefore 127 = 0111 1111 )
* The fraction is 0 (looking to the right of the binary point in 1.0 is all 0 = 000...0)
From these we can form the resulting 32 bit IEEE 754 binary32 format representation of
real number 1 as: 0-01111111-00000000000000000000000 = 3f800000<sub>H</sub>
'''Ex 2:'''
Consider a value 0.25 .
We can see that: <math> (0.25)_{10} =(1.0)_2 \times 2^{-2} </math>
From which we deduce:
* The exponent is 2 (and in the biased form it is 127+(2)= 125 = 0111 1101 )
* The fraction is 0 (looking to the right of binary point in 1.0 is all zeros)
From these we can form the resulting 32 bit IEEE 754 binary32 format representation of
real number 0.25 as: 0-01111101-00000000000000000000000 = 3e800000<sub>H</sub>
'''Ex 3:'''
Consider a value of 0.375 . We saw that <math> 0.375 = {(1.1)_2}\times 2^{-2} </math>
Hence after determining a representation of 0.375 as <math>{(1.1)_2}\times 2^{-2} </math>
we can proceed as above:
* The exponent is 2 (and in the biased form it is 127+(2)= 125 = 0111 1101 )
* The fraction is 1 (looking to the right of binary point in 1.1 is a single 1 = x<sub>1</sub>)
From these we can form the resulting 32 bit IEEE 754 binary32 format representation of
real number 0.375 as: 0-01111101-10000000000000000000000 = 3ec00000<sub>H</sub>
Java代码实现如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
|
public
class
I3E745_100p2 {
public
static
void
main(String[] args) {
float
value =
100
.2f;
//12.375f;
int
integral = (
int
) value;
float
fraction = value - integral;
//小数部分 0.2
float
temp = fraction;
int
[] bits =
new
int
[
32
];
for
(
int
i =
0
; i <
31
; i++){
if
(Float.compare(temp,
1
.0f) ==
0
){
bits[i] =
1
;
break
;
}
else
{
temp *=
2
;
if
(Float.compare(temp,
1
.0f) ==
0
){
bits[i] =
1
;
break
;
}
if
(temp -
1
>
0
){
bits[i] =
1
;
temp = temp -
1
;
}
else
{
bits[i] =
0
;
}
}
}
String integralPart = toBinaryString8(Math.abs(integral));
//符号位单独判断。此处传入integal的绝对值
//Therefore (12.375)10 = (12)10 + (0.375)10 = (1100)2 + (0.011)2 = (1100.011)2
StringBuffer fractionPartbuf =
new
StringBuffer();
for
(
int
i =
0
; i <
31
; i++){
fractionPartbuf.append(bits[i]);
}
String binaryStr = integralPart +
"."
+ fractionPartbuf.toString();
int
first = binaryStr.indexOf(
"1"
);
int
last = binaryStr.lastIndexOf(
"1"
);
String binary = binaryStr.substring(first, last +
1
);
// (1.x_1x_2...x_{23})_2 \times 2^{e} format
String [] integralLength = binary.split(
"\\."
);
int
exponent = integralLength[
0
].length() -
1
;
// Finally we can see that: (12.375)_{10} =(1.100011)_2 \times 2^{3}
String exponentBinary = toBinaryString8(exponent +
127
);
// 符号位
String s =
""
;
if
(value >
0
){
s =
"0"
;
}
else
{
s =
"1"
;
}
// 指数
String e = exponentBinary;
// 尾数
StringBuffer m =
new
StringBuffer();
m.append(integralPart.substring(integralPart.indexOf(
"1"
) +
1
));
m.append(fractionPartbuf.substring(
0
, fractionPartbuf.lastIndexOf(
"1"
) +
1
));
int
length =
23
- m.toString().length();
for
(
int
i =
0
; i < length; i++){
m.append(
"0"
);
}
System.out.println(s +
"-"
+ e +
"-"
+ m);
}
private
static
String toBinaryString8(
int
t){
int
value = t;
StringBuffer binary =
new
StringBuffer();
for
(
int
i =
0
; i <
8
; i++){
int
tmp = (value &
0x80
>>>i)>>>(
7
-i);
binary.append(tmp);
}
return
binary.toString();
}
}
|
