Question

I want to create an array containing values from 0 to 1 with interval of 0.1. I can use:

float[] myArray = new float[10];
float increment = 0.1;
for(i = 0; i < 10; i++)
{
   myArray[i] = increment;
   increment += 0.1;
}

I was wondering whether there is a function like Enumerable.Range that permits to specify also the increment interval.

Answer 1

An interesting fact is that every answer posted so far has fixed the bug in your proposed code, but only one has called out that they’ve done so.

Binary floating point numbers have representation error when dealing with any quantity that is not a fraction of an exact power of two. (“3.0/4.0” is a representable fraction because the bottom is a power of two; “1.0/10.0” is not.)

Therefore, when you say:

for(i = 0; i < 10; i++) 
{
    myArray[i] = increment;    
    increment += 0.1; 
} 

You are not actually incrementing “increment” by 1.0/10.0. You are incrementing it by the closest representable fraction that has an exact power of two on the bottom. So in fact this is equivalent to:

for(i = 0; i < 10; i++) 
{
    myArray[i] = increment;    
    increment += (exactly_one_tenth + small_representation_error);
} 

So, what is the value of the tenth increment? Clearly it is 10 * (exactly_one_tenth + small_representation_error) which is obviously equal to exactly_one + 10 * small_representation_error. You have multiplied the size of the representation error by ten.

Any time you repeatedly add together two floating point numbers, each subsequent addition increases the total representation error of the sum slightly and that adds up, literally, to a potentially large error. In some cases where you are summing thousands or millions of small numbers the error can become far larger than the actual total.

The far better solution is to do what everyone else has done. Recompute the fraction from integers every time. That way each result gets its own small representation error; it does not accumulate the representation errors of previously computed results.