Benchmark: Round vs Others2

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
Round
Math.round(num)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
trunc
floor
parseInt
bitwise invert2
bitwise or
Round

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
trunc	476706592.0 Ops/sec
floor	528718944.0 Ops/sec
parseInt	510750848.0 Ops/sec
bitwise invert2	508538688.0 Ops/sec
bitwise or	496610592.0 Ops/sec
Round	475278464.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark defined by the provided JSON tests the performance of various JavaScript methods or operations that manipulate numeric values. It focuses specifically on different techniques for rounding or truncating a number generated randomly, assessing how quickly each technique can be executed.

### Benchmark Overview

**Benchmark Name**: Round vs Others2  
**Script Preparation**: A random number between 0 and 100 is generated.

### Individual Test Cases

Here are the methods tested, along with their purposes:

1. **Math.trunc(num)** 
   - **Test Name**: trunc
   - **Purpose**: This method returns the integer part of the number, effectively removing any fractional digits.
   - **Pros**: It directly removes the fractional part, which is clear in intention and easy to read.
   - **Cons**: This method is relatively less performant compared to bitwise operations due to its function call overhead.

2. **Math.floor(num)**
   - **Test Name**: floor
   - **Purpose**: This function rounds the number down to the nearest integer.
   - **Pros**: It handles negative numbers correctly by always rounding down.
   - **Cons**: Slightly slower than bitwise operations due to being a function call.

3. **parseInt(num)**
   - **Test Name**: parseInt
   - **Purpose**: This function converts a string representation of a number into an integer, effectively truncating any decimal part.
   - **Pros**: Versatile for parsing numbers from strings.
   - **Cons**: It has type conversion overhead and may not be as performant for simple numeric truncation.

4. **~~(num)**
   - **Test Name**: bitwise invert2
   - **Purpose**: Double bitwise NOT operation coerces the number to an integer by truncating any decimal components.
   - **Pros**: Very fast due to being a bitwise operation without any function call overhead.
   - **Cons**: May be less clear in intent for code readability; requires understanding of bitwise operations.

5. **num | 0**
   - **Test Name**: bitwise or
   - **Purpose**: This bitwise OR operation with zero converts the floating-point number to a 32-bit integer, effectively truncating it.
   - **Pros**: Also very fast, leverages bitwise operations for truncation.
   - **Cons**: Similar readability issues as the double NOT operator.

6. **Math.round(num)**
   - **Test Name**: Round
   - **Purpose**: This function rounds the number to the nearest integer.
   - **Pros**: Expected behavior that is intuitive for most users.
   - **Cons**: More performance overhead than bitwise operations.

### Benchmark Results

According to the latest benchmark results on Firefox Mobile 135, the execution speed (in executions per second) varies across methods:

- **Best Performer**: `num | 0` (bitwise OR) at 487,164,896 executions/second.
- **Second Best**: `~~(num)` (double bitwise NOT) at 481,794,496 executions/second.
- **Others**: Methods such as `Math.floor`, `parseInt`, `Math.round`, and `Math.trunc` came in slower than both bitwise methods, with varying performance rates indicating that they introduce more overhead due to function calls and different processing.

### Other Considerations

When choosing which method to use for numeric truncation or rounding, several factors should be taken into account:

- **Performance**: If the highest performance is necessary, especially in performance-critical code paths or loops, bitwise operations (`num | 0` and `~~(num)`) are preferable.
- **Readability**: For code maintainability and clarity, using built-in methods like `Math.floor` or `Math.trunc` can be more understandable to developers unfamiliar with bitwise operations.
- **Functionality**: The choice might also depend on the specific needs (e.g., handling of negative numbers, need for rounding versus truncating).

### Alternatives

While this benchmark focuses on JavaScript methods, other languages have their own performance characteristics and methods for handling numeric conversion and rounding:

- **Python**: `math.floor`, `math.trunc`, and `int()` for truncation.
- **C/C++**: Casting to integer types or using functions like `floor` or `round` from `<math.h>`.
- **Java**: Use `Math.floor`, `Math.round`, or casting.

Developers should weigh the pros and cons of these alternatives based on their specific use cases and performance requirements.

Related benchmarks:

Round vs Others2 (version: 1)

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

Created: 2 months ago by: Guest

Jump to the latest result

trunc

floor

parseInt

bitwise invert2

bitwise or

Round

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):