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)

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 days ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36 Edg/134.0.0.0

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
floor	9781432.0 Ops/sec
~~	9938128.0 Ops/sec
>> 0	9802965.0 Ops/sec
\| 0	9892869.0 Ops/sec
<< 0	9964213.0 Ops/sec
& 0xFFFFFFFFFFFF	9484497.0 Ops/sec
^ 0x000000000000	9776536.0 Ops/sec
Math.trunc()	9704145.0 Ops/sec
x - (x % 1)	9746644.0 Ops/sec
parseInt()	9214333.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months 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.

Related benchmarks:

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: 8 years ago by: Guest

Jump to the latest result

floor

~~

>> 0

| 0

<< 0

& 0xFFFFFFFFFFFF

^ 0x000000000000

Math.trunc()

x - (x % 1)

parseInt()

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):