Number Representations & States

"how numbers are stored and used in computers""how numbers are stored and used in computers"

Floating point numbers

Floating point numbers represent numeric values in a form of scientific notation (). Each number is actually three numbers stored within a certain bit length.

Let's try to first understand this intuitively. The exponent is really just an interval between two successive powers of 2, like , , and so on. The mantissa (also called the significand) is the relative offset within this interval, and the sign bit controls the presence of a negative sign (-).

Try moving the slider along the number line below to see how the sign, exponent, and mantissa change for numbers in the interval .

Just as binary integers can be incremented to the next binary integer, adding one to a floating-point number's binary representation produces the next floating point number, which is not necessarily the number plus one.

As a floating point number gets larger, it "floats" to the next interval, and as it gets smaller, it "floats" to the previous interval. Intervals closer to zero are "more dense", in the sense that the mantissa can provide a more precise number along that interval. Intervals farther from zero are "more sparse", where it becomes increasingly likely that the mantissa will not provide enough resolution to precisely represent a particular number.

Floating point formats

The floating point format shown here is named E4M3, because it allocates 4 bits for an exponent and 3 bits for a mantissa. This format is usually only found in highly specialized machine learning applications, but is conceptually similar to the floating point formats that software developers typically interact with (32 bit and 64 bit).

Since there are only 256 possible values for any E4M3 number, it is easy to visualize the distribution of representable values in a table.

Notice how the representable values for a floating point number are "denser" around 0, and exponentially less dense in higher intervals. This observation is equally applicable to larger floating point formats.

Since the best achievable precision depends on the magnitude of the number, the accuracy of floating point computations is often expressed in terms of ulps - an error metric which accounts for the density of representable numbers around a computed result. For example, if you were to compute with E4M3 floating point numbers, there is no possible binary sequence to provide the exact answer , but how would you express the accuracy of the nearest approximations in this case ( or )?

This particular format also allows two possible representations of zero (00000000 and 10000000) and two possible representations of NaN (not a number). Some floating point formats also define special values to represent positive and negative Infinity. One criteria for considering a floating point format to be IEEE 754 compliant is whether it can represent NaN, +Infinity, and -Infinity.

There are certain small integer values like 17 that cannot be represented by this floating point format. We can represent 16 as 01011000, but the next binary digit 01011001 has a floating point approximation of 18. Even if you use a larger floating point format, like the 64 bit format in your web browser, you will eventually reach a maximum safe integer.

code.js
1console.log(2 ** 53)       // 9007199254740992
2console.log(2 ** 53 + 1)   // 9007199254740992 - same!

Notice that is the maximum safe integer for a floating point format which allocate 52 bits for the mantissa. This lends to the intuition that is an approximate threshold beyond which a floating point format will lose integer precision.

code.js
1// For compatibility with older JavaScript runtimes which use 32 bit numbers
2console.log(Number.MAX_SAFE_INTEGER)
3console.log(Number.MIN_SAFE_INTEGER)
4
5// Maximum and minimum representable values are many orders of magnitude higher
6console.log(Number.MAX_VALUE)
7console.log(Number.MIN_VALUE)

Depending on the application, a machine learning developer might choose a more specialized 8 bit floating point format like E5M2FNUZ, which uses 5 bits for the exponent, 2 bits for the mantissa, and defines itself as finite (FN) with unsigned zeroes (UZ).

Mathematical notation

It is helpful to understand how to express floating point numbers in mathematical notation if you plan to formally reason about floating point computations.

• The sign () is a single bit which indicates whether the number is positive or negative, where 0 is positive and 1 is negative. This is usually expressed as , since and .

TODO: number line intuition for sign bit

• The exponent () - determines the scale of the number (how big or small it is). When the exponent is 0, the value is referred to as a subnormal number, and is computed in a slightly different way.

TODO: number line intuition for exponent

• The mantissa () determines the precision of the number (the actual digits), and is often referred to as the significand. In numerical analysis, it is often expressed as the sequence of binary digits after the decimal point.

  For subnormal numbers (), the mantissa represents the fractional part of , which lies somewhere in the interval . For all other exponents , the mantissa represents the fractional part of , which lies in the interval . One reason for this is a hidden bit trick that will be elaborated on later.

• The bias (written as ) is subtracted from the exponent, so positive and negative exponents can both be stored with an unsigned integer.

For this particular format, where , the represented value might be formally expressed as

The widely-used 64 bit floating point format allocates 11 bits for the exponent and 52 bits for the mantissa, with . The represented value is calculated as:

In numerical analysis of floating point numbers, the base (written as ) usually refers to , but IEEE 854 also allows for base 10 to be used. There is also a special constant which refers to machine epsilon - a worst case relative error for a single rounding operation.

Relative error

You can edit the bits, exponent, and mantissa of a 64 bit floating point number below to get a sense of how much precision this actually provides.

This is often referred to as a double precision floating point number. The single precision floating point format allocates 8 bits for the exponent and 23 bits for the mantissa, which still provides fairly high precision with half the memory usage.

Floating point boundaries

The significand is being displayed as a number, but formal mathematical proofs often reason about the significand as a sequence of binary digits of a normalized value which takes the form , or for subnormal values. When we know the first digit is always a 1, we can actually get an extra bit of precision for free - this is called the hidden bit trick.

You will often see floating point numbers written in scientific notation (), but as you can see, this does not indicate a standard multiplication operation.

Floating point proofs

In floating point arithmetic and associated proofs, a floating point number is typically written as , where represents digits of the significand, is the base, and is the exponent.

For engineers

Understanding the nuances of floating point numbers is especially helpful when designing machine learning systems.