重复递增浮点数

Question

I'm looking at some legacy code that defines some grid points along the axis f .

int main(){
    double f[9];
    int i = 0;
    for (double a = 0; a <= 1; a += 0.125){
        f[i++] = a;
    }
}

I'm worried about the repeated addition of 1 / 8 to a , and the loop not running correctly. This is because I don't think you can add floating point values like this and rely on it being exactly 1 when i is 8.

Or is this code OK and I should stop worrying? (The code is at least 20 years old apparently and has never caused trouble - although in the original version, double a was declared outside the loop, I'm reading up on why that is.).

Answer 1

The code is fine when compiled with a C compiler that provides either exactly IEEE 754 semantics or a close approximation of them (say, FLT_EVAL_METHOD>0, or even arbitrary excess precision for sub-expressions and arbitrary roundings to the nominal precision).

The problems you fear are:

1. representation error, where 0.125 is not exactly 1/8, and
2. operation error, where + is not exactly mathematical addition. None of these happen for this particular program.

0.125 requires 1 bit of precision to be represented exactly in base 2. This means that the floating-point number used by the program in these conditions is exactly the intended 1/8. Furthermore, it can be added to itself 2 ⁵³ times before there is any approximation in the addition.

---

This reasoning is not correct for other increment steps. For instance, the variation of your program below leaves one index of the array, f[100] , uninitialized with at least my compiler (which implements strict IEEE 754 semantics):

int main(){
    double f[101];
    int i = 0;
    for (double a = 0; a <= 1; a += 0.01){
        printf("%.16e %d\n", a, i);
        f[i++] = a;
    }
}

When I run it I get at the last lines:

...
9.8000000000000065e-01 98
9.9000000000000066e-01 99

f[100] is never written to because of both representation error and operation error that occur when trying to add 0.01 repeatedly to itself in binary floating-point.

Answer 2

C standard leaves floating number implemented behavior , a lot of compiler use IEEE 754 standard. Your code is not Ok because:

1. Your code must be compile with IEEE 754 standard or similar standard with the same behavior.
2. It's hard to read. When you read the code the exact behavior is not obvious.
3. This is not the right way to iterate over array in C.

Imagine, someone doesn't know that requirement, and don't compile with IEEE 754 standard. The behavior could be something completely different. For example, your code could produce a out of bounds, and this is undefined behavior, your program could crash.

---

That said, an example of code that have the same behavior of your code when compiled with IEEE 754 standard:

#include <stddef.h>

int main(void) {
  double f[9];
  size_t const size_f = sizeof f / sizeof *f;

  double a = 0;
  for (size_t i = 0; i < size_f; i++) {
    f[i] = a;
    a += 0.125;
  }
}