Benchmark: Decimal Rounding - Exponential notation vs Number.EPSILON vs Double rounding vs Double rounding v2

Decimal Rounding - Exponential notation vs Number.EPSILON vs Double rounding vs Double rounding v2 (version: 0) Benchmark.js

A benchmark for solutions that provide accurate decimal rounding, flooring, and ceiling to a specific number of decimal places. These solutions treat floats more like decimals by fixing the binary rounding issues to avoid unexpected results. Solution 1: converting the number to a string in the exponential notation (e.g., num + "e" + decimalPlaces). Solution 2: purely mathematical (Number.EPSILON) Solution 3: double rounding. This solution uses the Number.prototype.toPrecision() method to strip the floating-point round-off errors. Solution 4: double rounding v2. This solution is just like Solution 3, however it uses a custom toPrecision() function.

Comparing performance of: `Solution 1 (Exponential notation) vs Solution 2 (Number.EPSILON) vs Solution 3 (Double rounding) vs Solution 4 (Double rounding v2)`

Created: 3 years ago by: Guest

Go to the latest result

Script Preparation code:

// Solution 1
var DecimalPrecision = (function() {
    if (Math.trunc === undefined) {
        Math.trunc = function(v) {
            return v < 0 ? Math.ceil(v) : Math.floor(v);
        };
    }
    var decimalAdjust = function myself(type, num, decimalPlaces) {
        if (type === 'round' && num < 0)
            return -myself(type, -num, decimalPlaces);
        var shift = function(value, exponent) {
            value = (value + 'e').split('e');
            return +(value[0] + 'e' + (+value[1] + (exponent || 0)));
        };
        var n = shift(num, +decimalPlaces);
        return shift(Math[type](n), -decimalPlaces);
    };
    return {
        // Decimal round (half away from zero)
        round: function(num, decimalPlaces) {
            return decimalAdjust('round', num, decimalPlaces);
        },
        // Decimal ceil
        ceil: function(num, decimalPlaces) {
            return decimalAdjust('ceil', num, decimalPlaces);
        },
        // Decimal floor
        floor: function(num, decimalPlaces) {
            return decimalAdjust('floor', num, decimalPlaces);
        },
        // Decimal trunc
        trunc: function(num, decimalPlaces) {
            return decimalAdjust('trunc', num, decimalPlaces);
        },
        // Format using fixed-point notation
        toFixed: function(num, decimalPlaces) {
            return decimalAdjust('round', num, decimalPlaces).toFixed(decimalPlaces);
        }
    };
})();

// Solution 2
var DecimalPrecision2 = (function() {
    if (Number.EPSILON === undefined) {
        Number.EPSILON = Math.pow(2, -52);
    }
    if (Math.sign === undefined) {
        Math.sign = function(x) {
            return ((x > 0) - (x < 0)) || +x;
        };
    }
    return {
        // Decimal round (half away from zero)
        round: function(num, decimalPlaces) {
            var p = Math.pow(10, decimalPlaces || 0);
            var n = (num * p) * (1 + Number.EPSILON);
            return Math.round(n) / p;
        },
        // Decimal ceil
        ceil: function(num, decimalPlaces) {
            var p = Math.pow(10, decimalPlaces || 0);
            var n = (num * p) * (1 - Math.sign(num) * Number.EPSILON);
            return Math.ceil(n) / p;
        },
        // Decimal floor
        floor: function(num, decimalPlaces) {
            var p = Math.pow(10, decimalPlaces || 0);
            var n = (num * p) * (1 + Math.sign(num) * Number.EPSILON);
            return Math.floor(n) / p;
        },
        // Decimal trunc
        trunc: function(num, decimalPlaces) {
            return (num < 0 ? this.ceil : this.floor)(num, decimalPlaces);
        },
        // Format using fixed-point notation
        toFixed: function(num, decimalPlaces) {
            return this.round(num, decimalPlaces).toFixed(decimalPlaces);
        }
    };
})();

// Solution 3
var DecimalPrecision3 = (function() {
    if (Math.trunc === undefined) {
        Math.trunc = function(v) {
            return v < 0 ? Math.ceil(v) : Math.floor(v);
        };
    }
    var powers = [
        1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,
        1e8,  1e9,  1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
        1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
    ];
    var intpow10 = function(power) {
        /* Not in lookup table */
        if (power < 0 || power > 22) {
            return Math.pow(10, power);
        }
        return powers[power];
    };
    // Eliminate binary floating-point inaccuracies.
    var stripError = function(num) {
        if (Number.isInteger(num))
            return num;
        return parseFloat(num.toPrecision(15));
    };
    var decimalAdjust = function myself(type, num, decimalPlaces) {
        if (type === 'round' && num < 0)
            return -myself(type, -num, decimalPlaces);
        var p = intpow10(decimalPlaces || 0);
        var n = stripError(num * p);
        return Math[type](n) / p;
    };
    return {
        // Decimal round (half away from zero)
        round: function(num, decimalPlaces) {
            return decimalAdjust('round', num, decimalPlaces);
        },
        // Decimal ceil
        ceil: function(num, decimalPlaces) {
            return decimalAdjust('ceil', num, decimalPlaces);
        },
        // Decimal floor
        floor: function(num, decimalPlaces) {
            return decimalAdjust('floor', num, decimalPlaces);
        },
        // Decimal trunc
        trunc: function(num, decimalPlaces) {
            return decimalAdjust('trunc', num, decimalPlaces);
        },
        // Format using fixed-point notation
        toFixed: function(num, decimalPlaces) {
            return decimalAdjust('round', num, decimalPlaces).toFixed(decimalPlaces);
        }
    };
})();

// Solution 4
var DecimalPrecision4 = (function() {
    if (Math.trunc === undefined) {
        Math.trunc = function(v) {
            return v < 0 ? Math.ceil(v) : Math.floor(v);
        };
    }
    var powers = [
        1e0,  1e1,  1e2,  1e3,  1e4,  1e5,  1e6,  1e7,
        1e8,  1e9,  1e10, 1e11, 1e12, 1e13, 1e14, 1e15,
        1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22
    ];
    var intpow10 = function(power) {
        /* Not in lookup table */
        if (power < 0 || power > 22) {
            return Math.pow(10, power);
        }
        return powers[power];
    };
    var toPrecision = function(num, significantDigits) {
        // Return early for ±0, NaN and Infinity.
        if (!num || !Number.isFinite(num))
            return num;
        // Compute shift of the decimal point (sf - leftSidedDigits).
        var shift = significantDigits - 1 - Math.floor(Math.log10(Math.abs(num)));
        // Return if rounding to the same or higher precision.
        var decimalPlaces = 0;
        for (var p = 1; num != Math.round(num * p) / p; p *= 10) decimalPlaces++;
        if (shift >= decimalPlaces)
            return num;
        // Round to "shift" fractional digits
        var scale = intpow10(Math.abs(shift));
        return shift > 0 ?
            Math.round(num * scale) / scale :
            Math.round(num / scale) * scale;
    };
    // Eliminate binary floating-point inaccuracies.
    var stripError = function(num) {
        if (Number.isInteger(num))
            return num;
        return toPrecision(num, 15);
    };
    var decimalAdjust = function myself(type, num, decimalPlaces) {
        if (type === 'round' && num < 0)
            return -myself(type, -num, decimalPlaces);
        var p = intpow10(decimalPlaces || 0);
        var n = stripError(num * p);
        return Math[type](n) / p;
    };
    return {
        // Decimal round (half away from zero)
        round: function(num, decimalPlaces) {
            return decimalAdjust('round', num, decimalPlaces);
        },
        // Decimal ceil
        ceil: function(num, decimalPlaces) {
            return decimalAdjust('ceil', num, decimalPlaces);
        },
        // Decimal floor
        floor: function(num, decimalPlaces) {
            return decimalAdjust('floor', num, decimalPlaces);
        },
        // Decimal trunc
        trunc: function(num, decimalPlaces) {
            return decimalAdjust('trunc', num, decimalPlaces);
        },
        // Format using fixed-point notation
        toFixed: function(num, decimalPlaces) {
            return decimalAdjust('round', num, decimalPlaces).toFixed(decimalPlaces);
        }
    };
})();

Tests:

Solution 1 (Exponential notation)
/** Solution 1 (Exponential notation) **/ DecimalPrecision.round(0.5, 0); DecimalPrecision.round(-0.5, 0); DecimalPrecision.ceil(1e-8, 2); DecimalPrecision.floor(1e-8, 2); DecimalPrecision.round(5.12, 1); DecimalPrecision.round(-5.12, 1); DecimalPrecision.ceil(5.12, 1); DecimalPrecision.ceil(-5.12, 1); DecimalPrecision.floor(5.12, 1); DecimalPrecision.floor(-5.12, 1); DecimalPrecision.trunc(5.12, 1); DecimalPrecision.trunc(-5.12, 1); DecimalPrecision.round(1.005, 2); DecimalPrecision.round(39.425, 2); DecimalPrecision.round(-1.005, 2); DecimalPrecision.round(-39.425, 2); DecimalPrecision.ceil(9.130, 2); DecimalPrecision.ceil(65.180, 2); DecimalPrecision.ceil(-2.260, 2); DecimalPrecision.ceil(-18.150, 2); DecimalPrecision.floor(2.260, 2); DecimalPrecision.floor(18.150, 2); DecimalPrecision.floor(-9.130, 2); DecimalPrecision.floor(-65.180, 2); DecimalPrecision.trunc(2.260, 2); DecimalPrecision.trunc(18.150, 2); DecimalPrecision.trunc(-2.260, 2); DecimalPrecision.trunc(-18.150, 2); DecimalPrecision.round(1262.48, -1); DecimalPrecision.round(1262.48, -2);
Solution 2 (Number.EPSILON)
/** Solution 2 (Number.EPSILON) **/ DecimalPrecision2.round(0.5, 0); DecimalPrecision2.round(-0.5, 0); DecimalPrecision2.ceil(1e-8, 2); DecimalPrecision2.floor(1e-8, 2); DecimalPrecision2.round(5.12, 1); DecimalPrecision2.round(-5.12, 1); DecimalPrecision2.ceil(5.12, 1); DecimalPrecision2.ceil(-5.12, 1); DecimalPrecision2.floor(5.12, 1); DecimalPrecision2.floor(-5.12, 1); DecimalPrecision2.trunc(5.12, 1); DecimalPrecision2.trunc(-5.12, 1); DecimalPrecision2.round(1.005, 2); DecimalPrecision2.round(39.425, 2); DecimalPrecision2.round(-1.005, 2); DecimalPrecision2.round(-39.425, 2); DecimalPrecision2.ceil(9.130, 2); DecimalPrecision2.ceil(65.180, 2); DecimalPrecision2.ceil(-2.260, 2); DecimalPrecision2.ceil(-18.150, 2); DecimalPrecision2.floor(2.260, 2); DecimalPrecision2.floor(18.150, 2); DecimalPrecision2.floor(-9.130, 2); DecimalPrecision2.floor(-65.180, 2); DecimalPrecision2.trunc(2.260, 2); DecimalPrecision2.trunc(18.150, 2); DecimalPrecision2.trunc(-2.260, 2); DecimalPrecision2.trunc(-18.150, 2); DecimalPrecision2.round(1262.48, -1); DecimalPrecision2.round(1262.48, -2);
Solution 3 (Double rounding)
/** Solution 3 (Double rounding) **/ DecimalPrecision3.round(0.5, 0); DecimalPrecision3.round(-0.5, 0); DecimalPrecision3.ceil(1e-8, 2); DecimalPrecision3.floor(1e-8, 2); DecimalPrecision3.round(5.12, 1); DecimalPrecision3.round(-5.12, 1); DecimalPrecision3.ceil(5.12, 1); DecimalPrecision3.ceil(-5.12, 1); DecimalPrecision3.floor(5.12, 1); DecimalPrecision3.floor(-5.12, 1); DecimalPrecision3.trunc(5.12, 1); DecimalPrecision3.trunc(-5.12, 1); DecimalPrecision3.round(1.005, 2); DecimalPrecision3.round(39.425, 2); DecimalPrecision3.round(-1.005, 2); DecimalPrecision3.round(-39.425, 2); DecimalPrecision3.ceil(9.130, 2); DecimalPrecision3.ceil(65.180, 2); DecimalPrecision3.ceil(-2.260, 2); DecimalPrecision3.ceil(-18.150, 2); DecimalPrecision3.floor(2.260, 2); DecimalPrecision3.floor(18.150, 2); DecimalPrecision3.floor(-9.130, 2); DecimalPrecision3.floor(-65.180, 2); DecimalPrecision3.trunc(2.260, 2); DecimalPrecision3.trunc(18.150, 2); DecimalPrecision3.trunc(-2.260, 2); DecimalPrecision3.trunc(-18.150, 2); DecimalPrecision3.round(1262.48, -1); DecimalPrecision3.round(1262.48, -2);
Solution 4 (Double rounding v2)
/** Solution 4 (Double rounding v2) **/ DecimalPrecision4.round(0.5, 0); DecimalPrecision4.round(-0.5, 0); DecimalPrecision4.ceil(1e-8, 2); DecimalPrecision4.floor(1e-8, 2); DecimalPrecision4.round(5.12, 1); DecimalPrecision4.round(-5.12, 1); DecimalPrecision4.ceil(5.12, 1); DecimalPrecision4.ceil(-5.12, 1); DecimalPrecision4.floor(5.12, 1); DecimalPrecision4.floor(-5.12, 1); DecimalPrecision4.trunc(5.12, 1); DecimalPrecision4.trunc(-5.12, 1); DecimalPrecision4.round(1.005, 2); DecimalPrecision4.round(39.425, 2); DecimalPrecision4.round(-1.005, 2); DecimalPrecision4.round(-39.425, 2); DecimalPrecision4.ceil(9.130, 2); DecimalPrecision4.ceil(65.180, 2); DecimalPrecision4.ceil(-2.260, 2); DecimalPrecision4.ceil(-18.150, 2); DecimalPrecision4.floor(2.260, 2); DecimalPrecision4.floor(18.150, 2); DecimalPrecision4.floor(-9.130, 2); DecimalPrecision4.floor(-65.180, 2); DecimalPrecision4.trunc(2.260, 2); DecimalPrecision4.trunc(18.150, 2); DecimalPrecision4.trunc(-2.260, 2); DecimalPrecision4.trunc(-18.150, 2); DecimalPrecision4.round(1262.48, -1); DecimalPrecision4.round(1262.48, -2);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Solution 1 (Exponential notation)
Solution 2 (Number.EPSILON)
Solution 3 (Double rounding)
Solution 4 (Double rounding v2)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:140.0) Gecko/20100101 Firefox/140.0

Browser/OS: Firefox 140 on Windows

View result in a separate tab

Solution 2 (Number.EPSILON)

6.1M/s

Solution 3 (Double rounding)

86K/s

Solution 4 (Double rounding v2)

70K/s

Solution 1 (Exponential notation)

70K/s

View exact numbers

Test name	Executions per second
✓ Solution 2 (Number.EPSILON)	6,144,224 Ops/sec
Solution 3 (Double rounding)	86,166 Ops/sec
Solution 4 (Double rounding v2)	70,302 Ops/sec
Solution 1 (Exponential notation)	69,566 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

It appears that there are four benchmark results:

1. **Solution 2 (Number.EPSILON)**:
	* Firefox 130 on Windows, Desktop, with a high execution rate of 9018292 executions per second.
2. **Solution 4 (Double rounding v2)**:
	* Firefox 130 on Windows, Desktop, with an execution rate of approximately 280590 executions per second.
3. **Solution 3 (Double rounding)**:
	* Firefox 130 on Windows, Desktop, with an execution rate of approximately 260522 executions per second.
4. **Solution 1 (Exponential notation)**:
	* Firefox 130 on Windows, Desktop, with a relatively low execution rate of 130126 executions per second.

Based on these results, Solution 2 (Number.EPSILON) appears to be the fastest, followed closely by Solution 3 (Double rounding), while Solution 4 (Double rounding v2) and Solution 1 (Exponential notation) are slower. However, without knowing more about the specific use case or requirements of the benchmark, it's difficult to make a definitive conclusion.

Could you please provide more context or clarify what aspect of these benchmarks is most relevant to your question?