Benchmark: floor vs trunc vs bit shift

Script Preparation code:

var x = 23.45

Tests:

floor
var r = Math.floor(x)
trunc
var r = Math.trunc(x)
bitshift
var r = x >> 0

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
floor
trunc
bitshift

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 104 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
floor	9810760.0 Ops/sec
trunc	9763966.0 Ops/sec
bitshift	27447978.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**Benchmark Definition**

The benchmark is designed to measure the fastest way to get an integer from a float. The script preparation code sets `x` to a floating-point value (23.45). The benchmark definition specifies three different approaches:

1. **Floor**: Using `Math.floor(x)` to round down to the nearest integer.
2. **Trunc**: Using `Math.trunc(x)` to truncate the decimal part and return an integer.
3. **Bit shift**: Using the bitwise right shift operator (`>>`) to shift the bits of `x` to the right, effectively rounding down to the nearest integer.

**Options Comparison**

Let's examine each approach:

*   **Floor (Math.floor)**: This method is straightforward but may introduce precision issues due to floating-point arithmetic limitations. Modern JavaScript engines often use a variant called "round-to-even" for `Math.floor`, which can lead to different results depending on the input value.
*   **Trunc (Math.trunc)**: This method provides a more accurate result than `floor` because it uses a simpler rounding algorithm that doesn't introduce precision issues. However, its performance may vary depending on the browser and platform.
*   **Bit shift**: The bitwise right shift operator is generally the fastest way to perform this operation, especially for larger integers. However, its usage can make the code harder to read and understand.

**Pros and Cons**

Here's a summary of each approach:

*   **Floor (Math.floor)**:
    *   Pros: Simple to implement.
    *   Cons: May introduce precision issues due to floating-point arithmetic limitations.
*   **Trunc (Math.trunc)**:
    *   Pros: Provides accurate results with less precision issues than `floor`.
    *   Cons: Performance may vary depending on the browser and platform.
*   **Bit shift**: 
    *   Pros: Generally fastest performance for integer operations.
    *   Cons: Code readability and maintainability may suffer due to its unconventional usage.

**Library Usage**

The benchmark definition doesn't explicitly mention any libraries. However, `Math` is a built-in JavaScript library that provides mathematical functions like `floor`, `trunc`, and bitwise operators.

**Special JS Features or Syntax**

None of the approaches in this benchmark require special JavaScript features or syntax beyond basic arithmetic operations. The use of `>>` for bit shifting does introduce some unusual behavior, but it's a widely supported feature in most browsers.

**Other Alternatives**

Some alternative methods to achieve integer rounding from floating-point numbers include:

*   Using `Math.round(x)` (which rounds to the nearest even integer)
*   Implementing your own custom rounding algorithm
*   Using libraries like Decimal.js or High precision arithmetic

Please note that each of these alternatives may have trade-offs in terms of performance, readability, and compatibility with different browsers and platforms.

Related benchmarks:

floor vs trunc vs bit shift (version: 0)

the fastest way to get an integer from a float

Comparing performance of: floor vs trunc vs bitshift

Created: 2 years ago by: Guest

Jump to the latest result

floor

trunc

bitshift

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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