Benchmark: floor() vs trunc() vs bitwise hacks (~~, >> 0, etc)

Script Preparation code:

var x = Math.random() * 100000000;
var y;

Tests:

floor
y = Math.floor(x);
~~
y = ~~x;
>> 0
y = x >> 0;
| 0
y = x | 0;
<< 0
y = x << 0;
& 0xFFFFFFFFFFFF
y = x & 0xFFFFFFFFFFFF;
^ 0x000000000000
y = x ^ 0x000000000000;
Math.trunc()
y = Math.trunc(x);
x - (x % 1)
y = x - (x % 1);
parseInt()
y = parseInt(x)

Historical Performance Data aggregated from 156 community runs

Desktop Results:

Chrome 124 runs

| 0

8.8M/s

8.7M/s

^ 0x000000000000

8.7M/s

>> 0

8.7M/s

& 0xFFFFFFFFFFFF

8.7M/s

<< 0

8.6M/s

Math.trunc()

6.3M/s

x - (x % 1)

6.3M/s

floor

6.3M/s

parseInt()

5.8M/s

Fastest: | 0 (1.5x faster)

View exact numbers

✓ | 0: 8,765,090 ops/sec
• ~~: 8,714,262 ops/sec
• ^ 0x000000000000: 8,692,112 ops/sec
• >> 0: 8,659,290 ops/sec
• & 0xFFFFFFFFFFFF: 8,651,871 ops/sec
• << 0: 8,642,471 ops/sec
• Math.trunc(): 6,334,424 ops/sec
• x - (x % 1): 6,270,535 ops/sec
• floor: 6,267,598 ops/sec
• parseInt(): 5,757,061 ops/sec

Firefox 16 runs

x - (x % 1)

749.7M/s

& 0xFFFFFFFFFFFF

302.4M/s

<< 0

302.3M/s

>> 0

302.2M/s

parseInt()

301.9M/s

| 0

301.8M/s

^ 0x000000000000

301.3M/s

Math.trunc()

301.1M/s

300.8M/s

floor

299.8M/s

Fastest: x - (x % 1) (2.5x faster)

View exact numbers

✓ x - (x % 1): 749,732,032 ops/sec
• & 0xFFFFFFFFFFFF: 302,376,032 ops/sec
• << 0: 302,283,008 ops/sec
• >> 0: 302,231,360 ops/sec
• parseInt(): 301,916,128 ops/sec
• | 0: 301,779,584 ops/sec
• ^ 0x000000000000: 301,321,184 ops/sec
• Math.trunc(): 301,061,056 ops/sec
• ~~: 300,842,848 ops/sec
• floor: 299,751,392 ops/sec

Safari 11 runs

| 0

13.5M/s

^ 0x000000000000

13.5M/s

13.4M/s

>> 0

13.4M/s

<< 0

13.4M/s

& 0xFFFFFFFFFFFF

13.4M/s

Math.trunc()

8.3M/s

parseInt()

8.2M/s

floor

8.1M/s

x - (x % 1)

7.2M/s

Fastest: | 0 (1.9x faster)

View exact numbers

✓ | 0: 13,472,366 ops/sec
• ^ 0x000000000000: 13,460,454 ops/sec
• ~~: 13,430,561 ops/sec
• >> 0: 13,415,003 ops/sec
• << 0: 13,385,108 ops/sec
• & 0xFFFFFFFFFFFF: 13,374,893 ops/sec
• Math.trunc(): 8,296,560 ops/sec
• parseInt(): 8,197,898 ops/sec
• floor: 8,088,722 ops/sec
• x - (x % 1): 7,196,082 ops/sec

Mobile Results:

Chrome 5 runs

4.5M/s

>> 0

4.5M/s

<< 0

4.5M/s

| 0

4.4M/s

& 0xFFFFFFFFFFFF

4.4M/s

^ 0x000000000000

4.4M/s

floor

3.2M/s

Math.trunc()

3.1M/s

parseInt()

2.7M/s

x - (x % 1)

2.5M/s

Fastest: ~~ (1.8x faster)

View exact numbers

✓ ~~: 4,485,141 ops/sec
• >> 0: 4,461,920 ops/sec
• << 0: 4,457,368 ops/sec
• | 0: 4,445,438 ops/sec
• & 0xFFFFFFFFFFFF: 4,423,438 ops/sec
• ^ 0x000000000000: 4,422,493 ops/sec
• floor: 3,179,312 ops/sec
• Math.trunc(): 3,119,708 ops/sec
• parseInt(): 2,728,166 ops/sec
• x - (x % 1): 2,532,486 ops/sec

Results show median performance across all community submissions. Run this benchmark yourself to verify on your device.

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
floor
~~
>> 0
\| 0
<< 0
& 0xFFFFFFFFFFFF
^ 0x000000000000
Math.trunc()
x - (x % 1)
parseInt()

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 hours ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.6 Safari/605.1.15

Browser/OS: Safari 26 on Mac OS X 10.15.7

View result in a separate tab

20.2M/s

<< 0

19.4M/s

| 0

19.3M/s

^ 0x000000000000

19.3M/s

>> 0

19.2M/s

& 0xFFFFFFFFFFFF

18.9M/s

parseInt()

17.8M/s

x - (x % 1)

11.8M/s

floor

11.6M/s

Math.trunc()

11.6M/s

View exact numbers

Test name	Executions per second
✓ ~~	20,249,666 Ops/sec
<< 0	19,379,608 Ops/sec
\| 0	19,292,848 Ops/sec
^ 0x000000000000	19,289,234 Ops/sec
>> 0	19,151,622 Ops/sec
& 0xFFFFFFFFFFFF	18,857,014 Ops/sec
parseInt()	17,844,722 Ops/sec
x - (x % 1)	11,761,358 Ops/sec
floor	11,634,712 Ops/sec
Math.trunc()	11,594,682 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and explain what's being tested.

**Benchmark Overview**

The benchmark is designed to compare the performance of various methods for rounding or truncating floating-point numbers in JavaScript.

**Methods Being Compared**

1. `floor()`: The built-in `Math.floor()` function, which returns the largest integer less than or equal to the input value.
2. `~~` (Bitwise Not): A bitwise hack that uses the `~` operator to invert the bits of the input value and then subtracts 1 to get the largest integer less than or equal to the original value.
3. `>> 0`: The right shift operator (`>>`) with a bit mask of 0, which effectively performs an integer division and returns the largest integer less than or equal to the input value.
4. `| 0` (Bitwise OR with 0): A bitwise hack that uses the `|` operator to perform a binary operation on the input value and then discards any fractional part by taking the result modulo 1.
5. `<< 0`: The left shift operator (`<<`) with a bit mask of 0, which effectively performs an integer division and returns the largest integer less than or equal to the input value.
6. `& 0xFFFFFFFFFFFF`: A bitwise hack that uses the `&` operator with a large bit mask to perform a binary operation on the input value and then discards any fractional part by taking the result modulo this mask.
7. `^ 0x000000000000`: A bitwise hack that uses the `^` operator with a small bit mask to perform a binary operation on the input value and then discards any fractional part by taking the result modulo this mask.
8. `Math.trunc()`: The built-in `Math.trunc()` function, which returns the largest integer less than or equal to the input value using a more optimized algorithm.
9. `x - (x % 1)`: A manual implementation that subtracts the fractional part of the input value from the original value.
10. `parseInt()`: The built-in `parseInt()` function, which attempts to parse a string as an integer.

**Pros and Cons**

Each method has its own trade-offs:

* `floor()` and `Math.trunc()` are straightforward and efficient but may not be suitable for all use cases (e.g., due to potential NaN propagation).
* `~~` and `>> 0` are bitwise hacks that can be fast but also fragile and prone to unexpected behavior.
* `| 0` and `<< 0` are simple but inefficient methods that discard fractional parts without preserving any information.
* `& 0xFFFFFFFFFFFF` and `^ 0x000000000000` are more complex bitwise hacks that may not be suitable for all use cases (e.g., due to potential overflows).
* `Math.trunc()` is optimized for performance but may not be as flexible as other methods.
* `x - (x % 1)` and `parseInt()` are manual implementations that can be slower and less efficient than other methods.

**Benchmark Results**

The benchmark results show the execution times for each method, with the fastest time being approximately 0.01-0.1 milliseconds for most of the methods.

**Conclusion**

This benchmark highlights the importance of choosing the right method for a specific use case when dealing with floating-point numbers in JavaScript. While `floor()` and `Math.trunc()` are efficient and straightforward, other methods like `~~` and `>> 0` may be faster but more fragile. Understanding the trade-offs and potential pitfalls of each method can help developers make informed decisions about which approach to use in their code.

floor() vs trunc() vs bitwise hacks (~~, >> 0, etc) (version: 0)

Comparing performance of: `floor vs ~~ vs >> 0 vs | 0 vs << 0 vs & 0xFFFFFFFFFFFF vs ^ 0x000000000000 vs Math.trunc() vs x - (x % 1) vs parseInt()`

Created: 9 years ago by: Guest

Go to the latest result

floor

~~

>> 0

| 0

<< 0

& 0xFFFFFFFFFFFF

^ 0x000000000000

Math.trunc()

x - (x % 1)

parseInt()

Historical Performance Data aggregated from 156 community runs

Desktop Results:

Chrome 124 runs

Firefox 16 runs

Safari 11 runs

Mobile Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

floor() vs trunc() vs bitwise hacks (~~, >> 0, etc) (version: 0)

Comparing performance of: floor vs ~~ vs >> 0 vs | 0 vs << 0 vs & 0xFFFFFFFFFFFF vs ^ 0x000000000000 vs Math.trunc() vs x - (x % 1) vs parseInt()

Created: 9 years ago by: Guest

Go to the latest result

floor

~~

>> 0

| 0

<< 0

& 0xFFFFFFFFFFFF

^ 0x000000000000

Math.trunc()

x - (x % 1)

parseInt()

Historical Performance Data aggregated from 156 community runs

Desktop Results:

Chrome 124 runs

Firefox 16 runs

Safari 11 runs

Mobile Results:

Chrome 5 runs

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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

Related benchmarks

Comparing performance of: `floor vs ~~ vs >> 0 vs | 0 vs << 0 vs & 0xFFFFFFFFFFFF vs ^ 0x000000000000 vs Math.trunc() vs x - (x % 1) vs parseInt()`