MeasureThat.net

 toFixed vs toPrecision vs Math.round() vs bitwise, also trunc, floor (version: 1)

Compares built in and bitwise operators. Specifically, toFixed(), toPrecision(), and Math.round(), and then bit shifting >> 0. In some cases, to places, so *100 and /100. Also tested floor() and trunc() versus the bit mask of |0 (bitwise or). The bitwise tests that are "signed" have the needed ternary statement, whereas the "UNsigned" versions do not.

Comparing performance of: myFloat.toFixed(2) vs myFloat.toPrecision(2) vs Math.round(myFloat*100.0)/100.0 vs Bitwise: signed round ± to 2 places vs Bitwise: UNsigned round ± to 2 places vs myFloat.toFixed(0) vs Math.round() vs Bitwise: signed round ± to int vs Bitwise: UNsigned round ± to int vs Math.floor() round down vs Math.trunc() round toward zero vs Bitwise: round toward zero

Created: one year ago by: Registered User
Jump to the latest result
Script Preparation code:
AخA
 
var myFloat = 210.758375837345;
var negFloat = -15.8674937593462;
var pos = 0.0, neg = 0.0, posi = 0, negi = 0;
Tests:

  • myFloat.toFixed(2)

     
    pos = myFloat.toFixed(2);
    neg = negFloat.toFixed(2);

  • myFloat.toPrecision(2)

     
    pos = myFloat.toPrecision(2);
    neg = negFloat.toPrecision(2);

  • Math.round(myFloat*100.0)/100.0

     
    pos = Math.round(myFloat*100.0)/100.0;
    neg = Math.round(negFloat*100.0)/100.0;

  • Bitwise: signed round ± to 2 places

     
    pos = (100.0*(myFloat < 0.0 ? myFloat - 0.005 : myFloat + 0.005) >> 0)/100.0;
    neg = (100.0*(negFloat < 0.0 ? negFloat - 0.005 : negFloat + 0.005) >> 0)/100.0;

  • Bitwise: UNsigned round ± to 2 places

     
    pos = (100.0*myFloat+0.5 >> 0)/100.0;
    neg = (100.0*negFloat-0.5 >> 0)/100.0;

  • myFloat.toFixed(0)

     
    posi = myFloat.toFixed(0);
    negi = negFloat.toFixed(0);

  • Math.round()

     
    posi = Math.round(myFloat);
    negi = Math.round(negFloat);

  • Bitwise: signed round ± to int

     
    posi = (myFloat < 0.0 ? myFloat - 0.5 : myFloat + 0.5) >> 0;
    negi = (negFloat < 0.0 ? negFloat - 0.5 : negFloat + 0.5) >> 0;

  • Bitwise: UNsigned round ± to int

     
    posi = myFloat+0.5 >> 0;
    negi = negFloat-0.5 >> 0;

  • Math.floor() round down

     
    posi = Math.floor(myFloat);
    negi = Math.floor(negFloat);

  • Math.trunc() round toward zero

     
    posi = Math.trunc(myFloat);
    negi = Math.trunc(negFloat);

  • Bitwise: round toward zero

     
    posi = myFloat | 0;
    negi = negFloat | 0;
Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

  • Test case name Result
    myFloat.toFixed(2)
    myFloat.toPrecision(2)
    Math.round(myFloat*100.0)/100.0
    Bitwise: signed round ± to 2 places
    Bitwise: UNsigned round ± to 2 places
    myFloat.toFixed(0)
    Math.round()
    Bitwise: signed round ± to int
    Bitwise: UNsigned round ± to int
    Math.floor() round down
    Math.trunc() round toward zero
    Bitwise: round toward zero

    Fastest: N/A

    Slowest: N/A

Latest run results:
Run details: (Test run date: one year ago)
Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Mobile Safari/537.36
Chrome Mobile 117 on Android
View result in a separate tab
Test name Executions per second
myFloat.toFixed(2) 976976.4 Ops/sec
myFloat.toPrecision(2) 1106340.1 Ops/sec
Math.round(myFloat*100.0)/100.0 939800.3 Ops/sec
Bitwise: signed round ± to 2 places 1197993.5 Ops/sec
Bitwise: UNsigned round ± to 2 places 1665880.1 Ops/sec
myFloat.toFixed(0) 1019422.8 Ops/sec
Math.round() 1025757.7 Ops/sec
Bitwise: signed round ± to int 1320582.8 Ops/sec
Bitwise: UNsigned round ± to int 1879278.6 Ops/sec
Math.floor() round down 1026371.3 Ops/sec
Math.trunc() round toward zero 1025808.0 Ops/sec
Bitwise: round toward zero 1884406.0 Ops/sec
LLMs can make mistakes. Check important info.
Related benchmarks: