Skip to content

Addition and numerical errors

In this chapter, we will be working with signed floating point numbers, so I add the last bit we need to get a Float8 class. If you have read previous two chapters, you know that this class has integer e and m members (standing for exponent and mantissa). Here I add s member that can take either 1 or -1 value.

This triplet represents the real number that can be computed as s * m * 2**(e-4) (line 17 of the following listing):

float8.py 
 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
class Float8:
    def __init__(self, s, e, m):
        self.s, self.e, self.m = s, e, m

    @classmethod
    def from_uint8(cls, uint8):
        s = 1 if uint8<128 else -1
        e = (uint8 % 128) // 16 - 4
        m = (uint8 % 128) %  16
        if e == -4:
            e += 1  # if subnormal, increment the exponent, the hidden bit = 0
        else:
            m += 16 # if normal, recover the hidden bit = 1
        return cls(s, e, m)

    def __float__(self):
        return self.s * self.m * 2**(self.e-4)

    @classmethod
    def from_float(cls, f):
        dist = [ abs(float(Float8.from_uint8(i)) - abs(f)) for i in range(128) ] # distance from |f| to all non-negative Float8
        i = min(range(128), key=lambda j : dist[j])                              # take the (first) closest
        if i < 127 and dist[i] == dist[i+1]:                                     # if tie
            i += i % 2                                                           # round to even
        return Float8.from_uint8(i + (0 if f>=0 else 128))                       # do not forget to recover the sign

    def copy(self):
        return Float8(**self.__dict__)

Rounding

The IEEE754 standard defines a number of rounding modes but the default rounding mode is the round-to-nearest-even-on-ties (RNE) mode. Here is an illustration of RNE rounding mode with our 8-bit floating point representation:

The real number 4.65 is rounded to its only nearest Float8 neighbor 4.75, however there are two nearest Float8 values (4.75 and 5.0) equidistant to the real number 4.875. In this case, RNE mode specifies that 4.875 should round to 5.0 because the bit representation of 5.0 (0b01100100) is an even number when interpreted as an integer. Similarly, the real number 5.125 rounds to 5.0 and 5.375 rounds to 5.5.

Addition

Numerical errors

The result of arithmetic operations in floating point experiences rounding error when it cannot be exactly represented. While modern hardware and libraries produce correctly rounded results for arithmetic operations, this rounding error can get amplified with a series of operations because the intermediate result must be rounded. When working with finite precision, numerical errors should be carefully addressed.

Catastrophic cancellation

Summation

Comments