Question

I want a function that creates an array of increasing floats. I run into problems when the incremenent cannot be represented precisely in binary. An example in an increment of 0.1, whose binary representation is infinitely repeating.

var incrementalArray = function(start, end, step) {
    var arr = [];
    for (var i = start; i <= end; i += step) {
        // 0.1 cannot be represented precisely in binary
        // not rounding i will cause weird numbers like 0.99999999
        if (step === 0.1) {
            arr.push(i.toFixed(1));
        } else {
            arr.push(i);
        }
    }
    return arr;
};

There are two problems with this implementation. A) It only covers the case of having an increment of 0.1. Aren’t there numerous other magic numbers that have repeating binary representation? B) The returned array does not include the end value when the increment is 0.1. However, it does include the end value when the increment is otherwise, making this function unpredictable.

incrementalArray(0.0, 3.0, 0.1);
// [0.0, 0.1, 0.2, .... 2.8, 2.9]

incrementalArray(2,10,2);
// [2, 4, 6, 8, 10]

How can this function work for all special increments and be predictable?

Answer 1

I think this might work:

var incrementalArray = function(start, end, step) {
    var arr = [];
    // convert count to an integer to avoid rounding errors
    var count = +((end - start) / step).toFixed();
    for (var j = 0; j <= count; j++) {
        var i = start + j * step;
        arr.push(i);
    }
    return arr;
};

Output: 0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9, 1, 1.1, 1.2000000000000001, 1.3, 1.4000000000000001, 1.5, 1.6, 1.7000000000000001, 1.8, 1.9000000000000001, 2, 2.1, 2.2, 2.3000000000000002, 2.4000000000000003, 2.5, 2.6, 2.7, 2.8000000000000002, 2.9000000000000003, 3

If you want the output truncated to the same number of decimals as the input, you can use this:

var incrementalArray = function(start, end, step) {
    var prec = ("" + step).length - ("" + step).indexOf(".") - 1;
    var arr = [];
    // convert count to an integer to avoid rounding errors
    var count = +((end - start) / step).toFixed();
    for (var j = 0; j <= count; j++) {
        var i = start + +(j * step).toFixed(prec);
        arr.push(i);
    }
    return arr;
};

Output: 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0