# Java Quick Guide

This guide contains useful Java information.

## Java float type.

Information
A Java float number (4 bytes) adheres to the IEEE-754 1985 floating point standard.
A floating point has 4 parts:

or

31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

where:
• signbit (bitnumber 31, total 1 bit)
The sign is 1 (positive number) or -1 (negative number).
The sign can also be written as sign=(-1)signbit
The signbit is 0 (positive number) and 1 (negative number)

For a Java float or double the radix is always 2

• exponent (bitnumber 23-30, total 8 bits)

In this tutorial this binary representation is called the exponent field and its unsigned value exponent_field_val.

The exponent indicates the positive or negative power of the radix that the mantissa and sign should be multiplied by.
The exponent field contains the binary numbers which represents only positive numbers (= unsigned numbers).
However the exponent needs to represent both positive and negative numbers (= signed numbers).
To get signed numbers you must subtract the exponent_field_val by an expbias value.
The expbias = (2n-1)-1 = 127 (n is the number of bits used for the exponent field, which is 8)
Thus: exponent = exponent_field_val - 127

The minimum and maximum allowed exponent values are:
exponentmin = -126
exponentmax = 127

IEEE reserves exponent field values of all 0s (exponentmin - 1 = -127) and all 1s (exponentmax + 1 = 128) to denote special values in the floating-point scheme. This will be discussed in Table A.

Example 1a:

The exponent_field_val represent unsigned value 3
exponent = exponent_field_val - 127 = 3-127 = -124

Example 1b:

The exponent_field represent unsigned value 224
exponent = exponent_field_val - 127 = 224-127 = 97

• mantissa (bitnumber 0-22, total 23 bits)
The mantissa is composed of the fraction (1.02267) and an implicit leading digit (1.02267).

22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

The fraction is represented as a binary decimal.
In a binary decimal the highest order bit (bitnumber 22) corresponds to a value of 2-1 = 0.5
In a binary decimal the lowest order bit (bitnumber 0) corresponds to a value of 2-23 = 0.000000119...

As displayed above the mantissa of a float has only 23 bits, however there is one hidden bit (bitnumber 23). This hidden bit determines what the "implicit leading digit" will be as mentioned earlier. This hidden bit is predictable and is therefore not included, because the exponent value determines what the hidden bit value will be.

If the exponent is all zeros,

the hidden bit (bitnumber 23) = 0 in all other cases the hidden bit = 1.

Example 2a:
The exponent is:

Because the exponent is all zeros, the hidden bit is 0.

22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

mantissa = hidden bit value + fraction
mantissa = 0 + 2-1 + 2-2 + 2-3 = 0 + 0.875 = 0.875

Example 2b:
The exponent is:

Because the exponent in not all zeros, the hidden bit is 1.

22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

mantissa = hidden bit value + fraction
mantissa = 1 + 2-3 + 2-4 + 2-6 + 2-9 = 1 + 0.205078125 = 1.205078125

Note:
A floating point number is normalized if the mantissa is within the range 1/radix <= mantissa <1, else it is called denormalized.
As mentioned earlier if the exponent field contains all 0s or 1s it denote special values in the floating-point scheme.

Table A: Special values
 exponent field exponent fraction represents 00000000bin exponentmin-1 fraction==0 ±0 00000000bin exponentmin-1 fraction != 0 (-1)signbit * 0.fraction * 2exponentmin 11111111bin exponentmax+1 fraction == 0 ±infinity 11111111bin exponentmax+1 fraction != 0 Not a Number not all 0s or 1s exponentmin<=exponent<=exponentmax any (-1)signbit * 1.fraction * 2exponent

The sign, mantissa, radix and exponent are now explained. You should now be able to calculate the float value, given the binary representation.

Example 3:
Binary representation of a float
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

signbit = 0
exponent_field_val = 10001001bin = 137dec
exponent = exponent - 127 = 137 - 127 = 10
mantissa = hidden bit value + fraction
mantissa = 1 + 2-3 + 2-4 + 2-6 + 2-9 = 1.205078125
float = (-1)signbit * mantissa * radixexponent
float = (-1)0 * 1.205078125 * 210 = 1234.0

Example 4:
Binary representation of a float
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

signbit = 1
exponent_field_val = 00001001bin = 9dec
exponent = exponent_field_val - 127 = 9 - 127 = -118
mantissa = hidden bit value + fraction
mantissa = 1 + 2-1 + 2-23 = 1.50000011920928955078125
float = (-1)signbit * mantissa * radixexponent
float = (-1)1 * 1.50000011920928955078125 * 2-118 = -4.5138986658899908977531184594082e-36

Example 5:
Binary representation of a float
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

signbit = 1
exponent_field_val = 00000000bin (special case)
exponent = exponentmin = -126
mantissa = hidden bit value + fraction
mantissa = 0 + 2-1 + 2-2 = 0.75
float = (-1)signbit * mantissa * radixexponent
float = (-1)1 * 0.75 * 2-126 = -8.8162076311671563097655240291668e-39

Example 6:
Binary representation of a float
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

signbit = 1
exponent_field_val = 00000000bin (special case)
fraction = 0
float = -0

Example 7:
Binary representation of a float
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

signbit = 0
exponent_field_val = 11111111bin (special case)
fraction = 0
float = +infinity

Example 8:
Binary representation of a float
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

signbit = 1
exponent_field_val = 11111111bin (special case)
fraction != 0
float = NaN

Example 9 (largest positive float, Float.MAX_VALUE):
Binary representation of a float
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

signbit = 0
exponent_field_val = 11111110bin = 254dec
exponent = exponent - 127 = 254 - 127 = 127
mantissa = hidden bit value + fraction
mantissa = 1 + 2-1 + 2-2 + ... +2-23 = 2 - 2-23 = 1.99999988079071044921875
float = (-1)signbit * mantissa * radixexponent
float = (-1)0 * (2 - 2-23) * 2127 = 3.40282346638528860e+38

Example 10 (lowest positive value, Float.MIN_VALUE):
Binary representation of a float
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
<bitnumber

10
11
12
13
14
15
16
17
18
19
20
21
22
23

signbit = 0
exponent_field_val = 00000000bin (special case)
exponent = exponentmin = -126
mantissa = hidden bit value + fraction
mantissa = 0 + 2-23 = 2-23
float = (-1)signbit * mantissa * radixexponent
float = (-1)0 * 2-23 * 2-126 = 2-149 = 1.40129846432481707e-45