Benchmark: Truncating a number to an integer

Truncating a number to an integer (version: 0)

~~, bitwise << and Math.trunc. Math.floor will always round down to the nearest integer, which means that for negative numbers it's going to be one less than all the other ones. You shouldn't use the others for rounding down for the same reason - the answer will be wrong for negative numbers.

Comparing performance of: Bitwise vs ~~ vs Math.trunc

Created: 4 years ago by: Registered User

Jump to the latest result

Script Preparation code:

var x = 9876.54321

Tests:

Bitwise
x = x << 0;
~~
x = ~~(x)
Math.trunc
x = Math.trunc(x)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Bitwise
~~
Math.trunc

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 years ago)

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

Browser/OS: Chrome 85 on Windows

View result in a separate tab

Test name	Executions per second
Bitwise	4694159.5 Ops/sec
~~	4699844.0 Ops/sec
Math.trunc	2651746.2 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll do my best to explain the provided benchmarking setup.

**Benchmark Definition**

The benchmark measures how quickly three different methods can truncate a decimal number to an integer:

1. **Bitwise Left Shift**: This method uses the bitwise left shift operator (`<<`) to create a binary representation of the number, effectively moving the decimal point to zero.
2. **Integer Arithmetic (~~)**: This method uses the `~~` operator, which is the unary minus operator followed by the integer division operator `/`. This operator returns the largest integer less than or equal to the input value.
3. **Mathematical Truncation (Math.trunc)**: This method uses the `Math.trunc()` function from the JavaScript Math library, which returns the largest integer less than or equal to the input value.

The benchmark notes that `Math.floor` should not be used for truncating negative numbers, as it rounds down instead of rounding towards zero.

**Test Cases**

The individual test cases are:

1. **Bitwise**: This test case uses the bitwise left shift operator (`<<`) to truncate a decimal number.
2. **~~ (Integer Arithmetic)**: This test case uses the `~~` operator to truncate a decimal number.
3. **Math.trunc**: This test case uses the `Math.trunc()` function from the JavaScript Math library to truncate a decimal number.

**Library Usage**

In this benchmark, no libraries are explicitly mentioned as being used by the tests. However, it's worth noting that the `Math` library is being used in the `Math.trunc()` function.

**Special JS Features/Syntax**

There is no special JS feature or syntax being tested in this benchmark. The operators and functions used are standard JavaScript syntax.

**Other Alternatives**

If you were to write a similar benchmark, you might consider using alternative methods for truncating decimal numbers, such as:

* Floating-point arithmetic with rounding modes (e.g., `Number.EPSILON` for relative error)
* Custom implementation of the truncation algorithm
* Using other libraries or frameworks that provide similar functionality

**Pros and Cons**

Here are some pros and cons of each method:

1. **Bitwise Left Shift**:
	* Pros: Simple, fast, and efficient.
	* Cons: May not be as readable or intuitive for developers familiar with decimal arithmetic.
2. **Integer Arithmetic (~~)**:
	* Pros: Fast and efficient, but may be less readable than other methods.
	* Cons: May cause unexpected behavior if used incorrectly or with certain input values.
3. **Mathematical Truncation (Math.trunc)**:
	* Pros: More readable and intuitive for developers familiar with the Math library.
	* Cons: May be slower than bitwise left shift or integer arithmetic due to overhead of function calls.

**Benchmark Considerations**

When creating a benchmark like this, consider factors such as:

* Input value distribution (e.g., random vs. sequential numbers)
* Browser and platform variations
* Compiler optimizations and caching effects
* Code readability and maintainability

Keep in mind that benchmarks should aim to accurately measure performance under representative usage scenarios.

Related benchmarks: