Decimal to Floating-Point Conversions

Floating-Point Conversion Examples

Binary/Boolean Main Index

[Decimal to Floating-Point Conversions] [Float to Decimal Conversion]

The Conversion Procedure

The rules for converting a decimal number into floating point are as follows:

Convert the absolute value of the number to binary, perhaps with a fractional part after the binary point. This can be done by converting the integral and fractional parts separately. The integral part is converted with the techniques examined previously. The fractional part can be converted by multiplication. This is basically the inverse of the division method: we repeatedly multiply by 2, and harvest each one bit as it appears left of the decimal.
Append × 20 to the end of the binary number (which does not change its value).
Normalize the number. Move the binary point so that it is one bit from the left. Adjust the exponent of two so that the value does not change.
Place the mantissa into the mantissa field of the number. Omit the leading one, and fill with zeros on the right.
Add the bias to the exponent of two, and place it in the exponent field. The bias is 2k−1 − 1, where k is the number of bits in the exponent field. For the eight-bit format, k = 3, so the bias is 23−1 − 1 = 3. For IEEE 32-bit, k = 8, so the bias is 28−1 − 1 = 127.
Set the sign bit, 1 for negative, 0 for positive, according to the sign of the original number.

Using The Conversion Procedure

Convert 2.625 to our 8-bit floating point format.
1. The integral part is easy, 2₁₀ = 10₂. For the fractional part:
  
  0.625 × 2 = 1.25 1 Generate 1 and continue with the rest.
  
  0.25 × 2 = 0.5 0 Generate 0 and continue.
  
  0.5 × 2 = 1.0 1 Generate 1 and nothing remains.
  
  So 0.625₁₀ = 0.101₂, and 2.625₁₀ = 10.101₂.
2. Add an exponent part: 10.101₂ = 10.101₂ × 2⁰.
3. Normalize: 10.101₂ × 2⁰ = 1.0101₂ × 2¹.
4. Mantissa: 0101
5. Exponent: 1 + 3 = 4 = 100₂.
6. Sign bit is 0.
The result is 01000101. Represented as hex, that is 45₁₆.
Convert -4.75 to our 8-bit floating point format.
1. The integral part is 4₁₀ = 100₂. The fractional:
  
  0.75 × 2 = 1.5 1 Generate 1 and continue with the rest.
  
  0.5 × 2 = 1.0 1 Generate 1 and nothing remains.
  
  So 4.75₁₀ = 100.11₂.
2. Normalize: 100.11₂ = 1.0011₂ × 2².
3. Mantissa is 0011, exponent is 2 + 3 = 5 = 101₂, sign bit is 1.
So -4.75 is 11010011 = d3₁₆

Convert 0.40625 to our 8-bit floating point format.

Converting:

0.40625	× 2 =	0.8125	0	Generate 0 and continue.
0.8125	× 2 =	1.625	1	Generate 1 and continue with the rest.
0.625	× 2 =	1.25	1	Generate 1 and continue with the rest.
0.25	× 2 =	0.5	0	Generate 0 and continue.
0.5	× 2 =	1.0	1	Generate 1 and nothing remains.

So 0.40625₁₀ = 0.01101₂.

Normalize: 0.01101₂ = 1.101₂ × 2^-2.
Mantissa is 1010, exponent is -2 + 3 = 1 = 001₂, sign bit is 0.

So 0.40625 is 00011010 = 1a₁₆

Convert -12.0 to our 8-bit floating point format.
1. 12₁₀ = 1100₂.
2. Normalize: 1100.0₂ = 1.1₂ × 2³.
3. Mantissa is 1000, exponent is 3 + 3 = 6 = 110₂, sign bit is 1.
So -12.0 is 11101000 = e8₁₆

Convert decimal 1.7 to our 8-bit floating point format.

The integral part is easy, 1₁₀ = 1₂. For the fractional part:

0.7	× 2 =	1.4	1	Generate 1 and continue with the rest.
0.4	× 2 =	0.8	0	Generate 0 and continue.
0.8	× 2 =	1.6	1	Generate 1 and continue with the rest.
0.6	× 2 =	1.2	1	Generate 1 and continue with the rest.
0.2	× 2 =	0.4	0	Generate 0 and continue.
0.4	× 2 =	0.8	0	Generate 0 and continue.
0.8	× 2 =	1.6	1	Generate 1 and continue with the rest.
0.6	× 2 =	1.2	1	Generate 1 and continue with the rest.
…

The reason why the process seems to continue endlessly is that it does. The number 7/10, which makes a perfectly reasonable decimal fraction, is a repeating fraction in binary, just as the faction 1/3 is a repeating fraction in decimal. (It repeats in binary as well.) We cannot represent this exactly as a floating point number. The closest we can come in four bits is .1011. Since we already have a leading 1, the best eight-bit number we can make is 1.1011.

Already normalized: 1.1011₂ = 1.1011₂ × 2⁰.
Mantissa is 1011, exponent is 0 + 3 = 3 = 011₂, sign bit is 0.

The result is 00111011 = 3b₁₆. This is not exact, of course. If you convert it back to decimal, you get 1.6875.

Convert -1313.3125 to IEEE 32-bit floating point format.
1. The integral part is 1313₁₀ = 10100100001₂. The fractional:
  
  0.3125 × 2 = 0.625 0 Generate 0 and continue.
  
  0.625 × 2 = 1.25 1 Generate 1 and continue with the rest.
  
  0.25 × 2 = 0.5 0 Generate 0 and continue.
  
  0.5 × 2 = 1.0 1 Generate 1 and nothing remains.
  
  So 1313.3125₁₀ = 10100100001.0101₂.
2. Normalize: 10100100001.0101₂ = 1.01001000010101₂ × 2¹⁰.
3. Mantissa is 01001000010101000000000, exponent is 10 + 127 = 137 = 10001001₂, sign bit is 1.
So -1313.3125 is 11000100101001000010101000000000 = c4a42a00₁₆

Convert 0.1015625 to IEEE 32-bit floating point format.

Converting:

0.1015625	× 2 =	0.203125	0	Generate 0 and continue.
0.203125	× 2 =	0.40625	0	Generate 0 and continue.
0.40625	× 2 =	0.8125	0	Generate 0 and continue.
0.8125	× 2 =	1.625	1	Generate 1 and continue with the rest.
0.625	× 2 =	1.25	1	Generate 1 and continue with the rest.
0.25	× 2 =	0.5	0	Generate 0 and continue.
0.5	× 2 =	1.0	1	Generate 1 and nothing remains.

So 0.1015625₁₀ = 0.0001101₂.

Normalize: 0.0001101₂ = 1.101₂ × 2^-4.
Mantissa is 10100000000000000000000, exponent is -4 + 127 = 123 = 01111011₂, sign bit is 0.

So 0.1015625 is 00111101110100000000000000000000 = 3dd00000₁₆

Convert 39887.5625 to IEEE 32-bit floating point format.
1. The integral part is 39887₁₀ = 1001101111001111₂. The fractional:
  
  0.5625 × 2 = 1.125 1 Generate 1 and continue with the rest.
  
  0.125 × 2 = 0.25 0 Generate 0 and continue.
  
  0.25 × 2 = 0.5 0 Generate 0 and continue.
  
  0.5 × 2 = 1.0 1 Generate 1 and nothing remains.
  
  So 39887.5625₁₀ = 1001101111001111.1001₂.
2. Normalize: 1001101111001111.1001₂ = 1.0011011110011111001₂ × 2¹⁵.
3. Mantissa is 00110111100111110010000, exponent is 15 + 127 = 142 = 10001110₂, sign bit is 0.
So 39887.5625 is 01000111000110111100111110010000 = 471bcf90₁₆

PITTSBURGH SUPERCOMPUTING CENTER

The IEEE standard for floating point arithmetic

The IEEE (Institute of Electrical and Electronics Engineers) has produced a standard for floating point arithmetic. This standard specifies how single precision (32 bit) and double precision (64 bit) floating point numbers are to be represented, as well as how arithmetic should be carried out on them.

Because many of our users may have occasion to transfer unformatted or "binary" data between an IEEE machine and the Cray or the VAX/VMS, it is worth noting the details of this format for comparison with the Cray and VAX representations. The differences in the formats also affect the accuracy of floating point computations.

Summary:

Single Precision

The IEEE single precision floating point standard representation requires a 32 bit word, which may be represented as numbered from 0 to 31, left to right. The first bit is the sign bit, S, the next eight bits are the exponent bits, 'E', and the final 23 bits are the fraction 'F':

  S EEEEEEEE FFFFFFFFFFFFFFFFFFFFFFF
  0 1      8 9                    31

The value V represented by the word may be determined as follows:

If E=255 and F is nonzero, then V=NaN ("Not a number")
If E=255 and F is zero and S is 1, then V=-Infinity
If E=255 and F is zero and S is 0, then V=Infinity
If 0<E<255 then V=(-1)**S * 2 ** (E-127) * (1.F) where "1.F" is intended to represent the binary number created by prefixing F with an implicit leading 1 and a binary point.
If E=0 and F is nonzero, then V=(-1)**S * 2 ** (-126) * (0.F) These are "unnormalized" values.
If E=0 and F is zero and S is 1, then V=-0
If E=0 and F is zero and S is 0, then V=0

In particular,

  0 00000000 00000000000000000000000 = 0
  1 00000000 00000000000000000000000 = -0

  0 11111111 00000000000000000000000 = Infinity
  1 11111111 00000000000000000000000 = -Infinity

  0 11111111 00000100000000000000000 = NaN
  1 11111111 00100010001001010101010 = NaN

  0 10000000 00000000000000000000000 = +1 * 2**(128-127) * 1.0 = 2
  0 10000001 10100000000000000000000 = +1 * 2**(129-127) * 1.101 = 6.5
  1 10000001 10100000000000000000000 = -1 * 2**(129-127) * 1.101 = -6.5

  0 00000001 00000000000000000000000 = +1 * 2**(1-127) * 1.0 = 2**(-126)
  0 00000000 10000000000000000000000 = +1 * 2**(-126) * 0.1 = 2**(-127) 
  0 00000000 00000000000000000000001 = +1 * 2**(-126) * 
                                       0.00000000000000000000001 = 
                                       2**(-149)  (Smallest positive value)

Double Precision

The IEEE double precision floating point standard representation requires a 64 bit word, which may be represented as numbered from 0 to 63, left to right. The first bit is the sign bit, S, the next eleven bits are the exponent bits, 'E', and the final 52 bits are the fraction 'F':

  S EEEEEEEEEEE FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
  0 1        11 12                                                63

The value V represented by the word may be determined as follows:

If E=2047 and F is nonzero, then V=NaN ("Not a number")
If E=2047 and F is zero and S is 1, then V=-Infinity
If E=2047 and F is zero and S is 0, then V=Infinity
If 0<E<2047 then V=(-1)**S * 2 ** (E-1023) * (1.F) where "1.F" is intended to represent the binary number created by prefixing F with an implicit leading 1 and a binary point.
If E=0 and F is nonzero, then V=(-1)**S * 2 ** (-1022) * (0.F) These are "unnormalized" values.
If E=0 and F is zero and S is 1, then V=-0
If E=0 and F is zero and S is 0, then V=0

Reference:

ANSI/IEEE Standard 754-1985,
Standard for Binary Floating Point Arithmetic

IEEE Standard 754 Floating Point Numbers

Steve Hollasch / Last update 2005-Feb-24

IEEE Standard 754 floating point is the most common representation today for real numbers on computers, including Intel-based PC's, Macintoshes, and most Unix platforms. This article gives a brief overview of IEEE floating point and its representation. Discussion of arithmetic implementation may be found in the book mentioned at the bottom of this article.

What Are Floating Point Numbers?

There are several ways to represent real numbers on computers. Fixed point places a radix point somewhere in the middle of the digits, and is equivalent to using integers that represent portions of some unit. For example, one might represent 1/100ths of a unit; if you have four decimal digits, you could represent 10.82, or 00.01. Another approach is to use rationals, and represent every number as the ratio of two integers.

Floating-point representation - the most common solution - basically represents reals in scientific notation. Scientific notation represents numbers as a base number and an exponent. For example, 123.456 could be represented as 1.23456 × 10². In hexadecimal, the number 123.abc might be represented as 1.23abc × 16².

Floating-point solves a number of representation problems. Fixed-point has a fixed window of representation, which limits it from representing very large or very small numbers. Also, fixed-point is prone to a loss of precision when two large numbers are divided.

Floating-point, on the other hand, employs a sort of "sliding window" of precision appropriate to the scale of the number. This allows it to represent numbers from 1,000,000,000,000 to 0.0000000000000001 with ease.

Storage Layout

IEEE floating point numbers have three basic components: the sign, the exponent, and the mantissa. The mantissa is composed of the fraction and an implicit leading digit (explained below). The exponent base (2) is implicit and need not be stored.

The following figure shows the layout for single (32-bit) and double (64-bit) precision floating-point values. The number of bits for each field are shown (bit ranges are in square brackets):

	Sign	Exponent	Fraction	Bias
Single Precision	1 [31]	8 [30-23]	23 [22-00]	127
Double Precision	1 [63]	11 [62-52]	52 [51-00]	1023

The Sign Bit

The sign bit is as simple as it gets. 0 denotes a positive number; 1 denotes a negative number. Flipping the value of this bit flips the sign of the number.

The Exponent

The exponent field needs to represent both positive and negative exponents. To do this, a bias is added to the actual exponent in order to get the stored exponent. For IEEE single-precision floats, this value is 127. Thus, an exponent of zero means that 127 is stored in the exponent field. A stored value of 200 indicates an exponent of (200-127), or 73. For reasons discussed later, exponents of -127 (all 0s) and +128 (all 1s) are reserved for special numbers.

For double precision, the exponent field is 11 bits, and has a bias of 1023.

The Mantissa

The mantissa, also known as the significand, represents the precision bits of the number. It is composed of an implicit leading bit and the fraction bits.

To find out the value of the implicit leading bit, consider that any number can be expressed in scientific notation in many different ways. For example, the number five can be represented as any of these:

        5.00 × 10⁰
        0.05 × 10²
        5000 × 10^-3

In order to maximize the quantity of representable numbers, floating-point numbers are typically stored in normalized form. This basically puts the radix point after the first non-zero digit. In normalized form, five is represented as 5.0 × 10⁰.

A nice little optimization is available to us in base two, since the only possible non-zero digit is 1. Thus, we can just assume a leading digit of 1, and don't need to represent it explicitly. As a result, the mantissa has effectively 24 bits of resolution, by way of 23 fraction bits.

Putting it All Together

So, to sum up:

The sign bit is 0 for positive, 1 for negative.
The exponent's base is two.
The exponent field contains 127 plus the true exponent for single-precision, or 1023 plus the true exponent for double precision.
The first bit of the mantissa is typically assumed to be 1.f, where f is the field of fraction bits.

Ranges of Floating-Point Numbers

Let's consider single-precision floats for a second. Note that we're taking essentially a 32-bit number and re-jiggering the fields to cover a much broader range. Something has to give, and it's precision. For example, regular 32-bit integers, with all precision centered around zero, can precisely store integers with 32-bits of resolution. Single-precision floating-point, on the other hand, is unable to match this resolution with its 24 bits. It does, however, approximate this value by effectively truncating from the lower end. For example:

      11110000 11001100 10101010 00001111  // 32-bit integer
  = +1.1110000 11001100 10101010 x 2³¹     // Single-Precision Float
  =   11110000 11001100 10101010 00000000  // Corresponding Value

This approximates the 32-bit value, but doesn't yield an exact representation. On the other hand, besides the ability to represent fractional components (which integers lack completely), the floating-point value can represent numbers around 2¹²⁷, compared to 32-bit integers maximum value around 2³².

The range of positive floating point numbers can be split into normalized numbers (which preserve the full precision of the mantissa), and denormalized numbers (discussed later) which use only a portion of the fractions's precision.

	Denormalized	Normalized	Approximate Decimal
Single Precision	± 2^-149 to (1-2^-23)×2^-126	± 2^-126 to (2-2^-23)×2¹²⁷	± ~10^-44.85 to ~10^38.53
Double Precision	± 2^-1074 to (1-2^-52)×2^-1022	± 2^-1022 to (2-2^-52)×2¹⁰²³	± ~10^-323.3 to ~10^308.3

Since the sign of floating point numbers is given by a special leading bit, the range for negative numbers is given by the negation of the above values.

There are five distinct numerical ranges that single-precision floating-point numbers are not able to represent:

Negative numbers less than -(2-2^-23) × 2¹²⁷ (negative overflow)
Negative numbers greater than -2^-149 (negative underflow)
Zero
Positive numbers less than 2^-149 (positive underflow)
Positive numbers greater than (2-2^-23) × 2¹²⁷ (positive overflow)

Overflow means that values have grown too large for the representation, much in the same way that you can overflow integers. Underflow is a less serious problem because is just denotes a loss of precision, which is guaranteed to be closely approximated by zero.

Here's a table of the effective range (excluding infinite values) of IEEE floating-point numbers:

	Binary	Decimal
Single	± (2-2^-23) × 2¹²⁷	~ ± 10^38.53
Double	± (2-2^-52) × 2¹⁰²³	~ ± 10^308.25

Note that the extreme values occur (regardless of sign) when the exponent is at the maximum value for finite numbers (2¹²⁷ for single-precision, 2¹⁰²³ for double), and the mantissa is filled with 1s (including the normalizing 1 bit).

Special Values

IEEE reserves exponent field values of all 0s and all 1s to denote special values in the floating-point scheme.

Zero

As mentioned above, zero is not directly representable in the straight format, due to the assumption of a leading 1 (we'd need to specify a true zero mantissa to yield a value of zero). Zero is a special value denoted with an exponent field of zero and a fraction field of zero. Note that -0 and +0 are distinct values, though they both compare as equal.

Denormalized

If the exponent is all 0s, but the fraction is non-zero (else it would be interpreted as zero), then the value is a denormalized number, which does not have an assumed leading 1 before the binary point. Thus, this represents a number (-1)^s × 0.f × 2^-126, where s is the sign bit and f is the fraction. For double precision, denormalized numbers are of the form (-1)^s × 0.f × 2^-1022. From this you can interpret zero as a special type of denormalized number.

Infinity

The values +infinity and -infinity are denoted with an exponent of all 1s and a fraction of all 0s. The sign bit distinguishes between negative infinity and positive infinity. Being able to denote infinity as a specific value is useful because it allows operations to continue past overflow situations. Operations with infinite values are well defined in IEEE floating point.

Not A Number

The value NaN (Not a Number) is used to represent a value that does not represent a real number. NaN's are represented by a bit pattern with an exponent of all 1s and a non-zero fraction. There are two categories of NaN: QNaN (Quiet NaN) and SNaN (Signalling NaN).

A QNaN is a NaN with the most significant fraction bit set. QNaN's propagate freely through most arithmetic operations. These values pop out of an operation when the result is not mathematically defined.

An SNaN is a NaN with the most significant fraction bit clear. It is used to signal an exception when used in operations. SNaN's can be handy to assign to uninitialized variables to trap premature usage.

Semantically, QNaN's denote indeterminate operations, while SNaN's denote invalid operations.

Special Operations

Operations on special numbers are well-defined by IEEE. In the simplest case, any operation with a NaN yields a NaN result. Other operations are as follows:

Operation	Result
n ÷ ±Infinity	0
±Infinity × ±Infinity	±Infinity
±nonzero ÷ 0	±Infinity
Infinity + Infinity	Infinity
±0 ÷ ±0	NaN
Infinity - Infinity	NaN
±Infinity ÷ ±Infinity	NaN
±Infinity × 0	NaN

Summary

To sum up, the following are the corresponding values for a given representation:

Float Values (b = bias)
Sign	Exponent (e)	Fraction (f)	Value
0	00..00	00..00	+0
0	00..00	00..01 : 11..11	Positive Denormalized Real 0.f × 2^(-b+1)
0	00..01 : 11..10	XX..XX	Positive Normalized Real 1.f × 2^(e-b)
0	11..11	00..00	+Infinity
0	11..11	00..01 : 01..11	SNaN
0	11..11	10..00 : 11..11	QNaN
1	00..00	00..00	-0
1	00..00	00..01 : 11..11	Negative Denormalized Real -0.f × 2^(-b+1)
1	00..01 : 11..10	XX..XX	Negative Normalized Real -1.f × 2^(e-b)
1	11..11	00..00	-Infinity
1	11..11	00..01 : 01..11	SNaN
1	11..11	10..00 : 11.11	QNaN

References

A lot of this stuff was observed from small programs I wrote to go back and forth between hex and floating point (printf-style), and to examine the results of various operations. The bulk of this material, however, was lifted from Stallings' book.

Computer Organization and Architecture, William Stallings, pp. 222-234 Macmillan Publishing Company, ISBN 0-02-415480-6
IEEE Computer Society (1985), IEEE Standard for Binary Floating-Point Arithmetic, IEEE Std 754-1985.
Intel Architecture Software Developer's Manual, Volume 1: Basic Architecture , (a PDF document downloaded from intel.com.)

MY WORLD

Friday, December 2, 2011

Floating-Point Representation