Run results for: toFixed vs toPrecision vs Math.round() vs bitwise, also trunc, floor

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.

Run details:

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.141 Safari/537.36 OPR/73.0.3856.344

Browser: Opera 73

Operating system: Mac OS X 10.15.7

Device Platform: Desktop

Date tested: one year ago

Test name	Executions per second
myFloat.toFixed(2)	686650.6 Ops/sec
myFloat.toPrecision(2)	916620.9 Ops/sec
Math.round(myFloat*100.0)/100.0	888427.9 Ops/sec
Bitwise: signed round ± to 2 places	1010021.7 Ops/sec
Bitwise: UNsigned round ± to 2 places	1385122.8 Ops/sec
myFloat.toFixed(0)	668558.1 Ops/sec
Math.round()	954068.8 Ops/sec
Bitwise: signed round ± to int	952099.2 Ops/sec
Bitwise: UNsigned round ± to int	1354401.0 Ops/sec
Math.floor() round down	856373.4 Ops/sec
Math.trunc() round toward zero	876845.7 Ops/sec
Bitwise: round toward zero	1442250.2 Ops/sec

Script Preparation code:

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;

Run results for: toFixed vs toPrecision vs Math.round() vs bitwise, also trunc, floor

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