# Math.round vs hack

## JavaScript performance comparison

Revision 37 of this test case created by Hao Wu

## Info

Math.round() has a function call overhead, so using the ~~ hack (truncate towards 0) and adding 0.5 works quicker, but if you want to handle negative numbers too then you have to check whether to add or subtract 0.5 .... and this wipes out the speed advantage. So ~~(0.5+num) is only worth it if you know your numbers always have the same sign...

## Preparation code

``<script>var somenum = -500 + (Math.random() * 1000);var rounded;var MyMath = {        round: function( a ) {                return (a + (a > 0 ? .5 : -.5)) << 0;        }};round = MyMath.round;</script>``

## Test runner

Warning! For accurate results, please disable Firebug before running the tests. (Why?)

Java applet disabled.

Testing in unknown unknown
Test Ops/sec
"proper" rounding in function call
``rounded = Math.round(somenum);``
pending…
Hack rounding
``rounded = ~~ (0.5 + somenum);``
pending…
Proper hack rounding
``rounded = ~~ (somenum + (somenum > 0 ? .5 : -.5));``
pending…
Hack with bitwise OR
``rounded = (0.5 + somenum) | 0;``
pending…
Hack with bitwise shift
``rounded = (0.5 + somenum) << 0;``
pending…
proper in function call
``rounded = round(somenum);``
pending…
Proper hack wrapped in function call
``rounded = MyMath.round(somenum);``
pending…
Proprer hack with bitwise
``rounded = (somenum + (somenum > 0 ? .5 : -.5)) | 0;``
pending…
Proprer hack with bitwise <<
``rounded = (somenum + (somenum > 0 ? .5 : -.5)) << 0;``
pending…
Proprer hack with bitwise REVERSED
``rounded = 0 | (somenum + (somenum > 0 ? .5 : -.5));``
pending…
-~(num-0.5)
``rounded = -~(somenum -0.5)``
pending…

## Revisions

You can edit these tests or add even more tests to this page by appending `/edit` to the URL. Here’s a list of current revisions for this page:

# 0 comments

Comment form temporarily disabled.