Benchmark: Round vs Others - MeasureThat.net

Script Preparation code:

var num = Math.random() * 100;

Tests:

trunc
Math.trunc(num);
floor
Math.floor(num);
parseInt
parseInt(num);
bitwise invert2
~~(num);
bitwise or
num | 0

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
trunc
floor
parseInt
bitwise invert2
bitwise or

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
trunc	193958032.0 Ops/sec
floor	223372624.0 Ops/sec
parseInt	146112960.0 Ops/sec
bitwise invert2	219538912.0 Ops/sec
bitwise or	203104176.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

### Benchmark Overview

The benchmark named **"Round vs Others"** compares different methods of truncating or rounding a random floating-point number generated in JavaScript. The value used for testing is a random number between 0 and 100, generated using `Math.random() * 100;`. The primary focus is to evaluate how various mathematical functions perform in this context.

### Test Cases and Their Functions

1. **`Math.trunc(num)`**
   - **Description:** This function returns the integer part of a number by removing any fractional digits. For example, `Math.trunc(5.7)` returns `5`.
   - **Pros:** It is straightforward and directly conveys the intent of truncation.
   - **Cons:** Typically slower than bitwise operations in certain environments.

2. **`Math.floor(num)`**
   - **Description:** This method rounds a number down to the nearest integer. For example, `Math.floor(5.7)` returns `5`, while `Math.floor(-5.7)` returns `-6`.
   - **Pros:** Useful when you need consistent behavior with negative numbers; however, still relatively simple.
   - **Cons:** Slightly more overhead compared to bitwise operations.

3. **`parseInt(num)`**
   - **Description:** Parses a string and returns an integer. For example, `parseInt("5.7")` will return `5`.
   - **Pros:** Offers flexibility with string parsing.
   - **Cons:** Can lead to unexpected results with non-numeric input and has more overhead as it involves type coercion.

4. **`~~(num)` (Bitwise NOT twice)**
   - **Description:** This is a shorthand way of truncating decimals. Applying the bitwise NOT operator twice effectively converts a floating-point number into an integer by discarding the decimal part.
   - **Pros:** Fastest approach because bitwise operations are generally optimized in JavaScript. 
   - **Cons:** It's not always clear to readers who are unfamiliar with it that this is intended for truncation, which could cause maintainability issues.

5. **`num | 0` (Bitwise OR with zero)**
   - **Description:** This performs a bitwise OR operation, which also converts the number to an integer by dropping the fractional part.
   - **Pros:** Similar performance benefits to `~~(num)`, also very fast.
   - **Cons:** Like `~~(num)`, it may not be as intuitive as clearer numerical methods.

### Benchmark Results

The benchmark results are measured in **executions per second**, indicating how many times each method could execute within a second.

- **Highest Performance:**
  - `Math.floor(num)` performed the best in this set with an impressive **223372624** executions per second. 
  - Close behind was the bitwise inversion method (`~~(num)`) with **219538912** executions per second.

- **Lowest Performance:**
  - `parseInt(num)` was the slowest, with **146112960** executions per second. This is likely due to the overhead of parsing, especially since it handles strings.

### Other Considerations

While the benchmark highlights the relative performance of truncation methods in JavaScript, consider these alternative approaches when dealing with rounding or truncating numbers:

1. **Using Libraries:** Libraries like **Lodash** may provide utility functions for rounding or truncating but will generally incur additional overhead due to their complexity and size.

2. **Typed Arrays:** If performance is critical, utilizing typed arrays (like `Float32Array` or `Int32Array`) in heavy computations can enable more efficient memory management and performance.

3. **Custom Implementations:** Developers might create specialized functions to handle very particular cases able to outperform generic methods on specific datasets, but that often requires extensive testing and validation.

In making decisions about which method to use, it's vital to weigh the importance of performance against maintainability, readability, and the specific needs of the application.

Related benchmarks:

Round vs Others (version: 1)

Comparing performance of: trunc vs floor vs parseInt vs bitwise invert2 vs bitwise or

Created: 2 months ago by: Guest

Jump to the latest result

trunc

floor

parseInt

bitwise invert2

bitwise or

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):