How are floating point numbers stored in memory?

by

To understand how they are stored, you must first understand what they are and what kind of values they are intended to handle.

Unlike integers, a floating-point value is intended to represent extremely small values as well as extremely large. For normal 32-bit floating-point values, this corresponds to values in the range from 1.175494351 * 10^-38 to 3.40282347 * 10^+38.

Clearly, using only 32 bits, it’s not possible to store every digit in such numbers.

When it comes to the representation, you can see all normal floating-point numbers as a value in the range 1.0 to (almost) 2.0, scaled with a power of two. So:

  • 1.0 is simply 1.0 * 2^0,
  • 2.0 is 1.0 * 2^1, and
  • -5.0 is -1.25 * 2^2.

So, what is needed to encode this, as efficiently as possible? What do we really need?

  • The sign of the expression.
  • The exponent
  • The value in the range 1.0 to (almost) 2.0. This is known as the “mantissa” or the significand.

This is encoded as follows, according to the IEEE-754 floating-point standard.

  • The sign is a single bit.
  • The exponent is stored as an unsigned integer, for 32-bits floating-point values, this field is 8 bits. 1 represents the smallest exponent and “all ones – 1” the largest. (0 and “all ones” are used to encode special values, see below.) A value in the middle (127, in the 32-bit case) represents zero, this is also known as the bias.
  • When looking at the mantissa (the value between 1.0 and (almost) 2.0), one sees that all possible values start with a “1” (both in the decimal and binary representation). This means that it’s no point in storing it. The rest of the binary digits are stored in an integer field, in the 32-bit case this field is 23 bits.

In addition to the normal floating-point values, there are a number of special values:

  • Zero is encoded with both exponent and mantissa as zero. The sign bit is used to represent “plus zero” and “minus zero”. A minus zero is useful when the result of an operation is extremely small, but it’s still important to know from which direction the operation came from.
  • plus and minus infinity — represented using an “all ones” exponent and a zero mantissa field.
  • Not a Number (NaN) — represented using an “all ones” exponent and a non-zero mantissa.
  • Denormalized numbers — numbers smaller than the smallest normal number. Represented using a zero exponent field and a non-zero mantissa. The special thing with these numbers is that the precision (i.e. the number of digits a value can contain) will drop the smaller the value becomes, simply because there is not room for them in the mantissa.

Finally, the following is a handful of concrete examples (all values are in hex):

  • 1.0 : 3f800000
  • -1234.0 : c49a4000
  • 100000000000000000000000.0: 65a96816

More Related Contents:

  1. Printf width specifier to maintain precision of floating-point value
  2. ‘float’ vs. ‘double’ precision
  3. How to get the sign, mantissa and exponent of a floating point number
  4. How to generate random float number in C
  5. When does appending an ‘f’ change the value of a floating constant when assigned to a `float`?
  6. What’s the use of suffix `f` on float value
  7. Simd matmul program gives different numerical results
  8. How to convert string to float?
  9. How do you print the EXACT value of a floating point number?
  10. How to extract the decimal part from a floating point number in C?
  11. C- Floating point precision
  12. Why doesn’t C have unsigned floats?
  13. C: printf a float value
  14. C: Casting minimum 32-bit integer (-2147483648) to float gives positive number (2147483648.0)
  15. Convert double/float to string
  16. pow() seems to be out by one here
  17. Ranges of floating point datatype in C?
  18. Precision in C floats
  19. How to enable linking floating point library in TurboC?
  20. My floating point number has extra digits when I print it
  21. Is there a function to round a float in C or do I need to write my own?
  22. Is my fma() broken?
  23. C – Serialization of the floating point numbers (floats, doubles)
  24. C: How to wrap a float to the interval [-pi, pi)
  25. sin, cos, tan and rounding error
  26. What precisely does the %g printf specifier mean?
  27. C Function to Convert float to byte array
  28. pow() cast to integer, unexpected result
  29. C dynamically printf double, no loss of precision and no trailing zeroes
  30. How can floating point calculations be made deterministic?

Leave a Comment