Benchmark: round vs trunc vs floor (2)

Tests:

trunc
Math.trunc(13.37123123 * 1_000_000) / 1_000_000 Math.trunc(13.67123123 * 1_000_000) / 1_000_000
round
Math.round(13.37123123, 6) Math.round(13.67123123, 6)
floor
Math.floor(13.37123123, 6) Math.floor(13.67123123, 6)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
trunc
round
floor

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

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
trunc	241060112.0 Ops/sec
round	258677504.0 Ops/sec
floor	243322448.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark titled "round vs trunc vs floor (2)" is designed to measure and compare the performance of three different JavaScript functions that are used to manipulate numerical values: `Math.round()`, `Math.trunc()`, and `Math.floor()`. Each of these functions has its specific behavior when handling decimal numbers, which influences both their performance and output.

### Options Being Compared

1. **Math.round()**:
   - **Definition**: Rounds a number to the nearest integer. If the fractional part is .5 or greater, it rounds up; otherwise, it rounds down.
   - **Use Case**: Use when you need to round a number to the nearest integer.
   - **Benchmark Definition**: `Math.round(13.37123123, 6)` rounds the number to six decimal places. However, in JavaScript, the second parameter is ignored, lending a possible performance aspect to consider.

2. **Math.trunc()**:
   - **Definition**: Truncates the decimal part of a number, effectively removing it and returning only the integer part.
   - **Use Case**: Use when you want to discard the decimal portion without rounding up or down.
   - **Benchmark Definition**: `Math.trunc(13.37123123 * 1_000_000) / 1_000_000` shifts the decimal six places, truncates, and shifts back.

3. **Math.floor()**:
   - **Definition**: Rounds down to the nearest integer, regardless of the decimal part.
   - **Use Case**: Use when you want to ensure the result is not greater than the original number.
   - **Benchmark Definition**: `Math.floor(13.37123123, 6)` behaves similarly to round, but given JavaScript's handling of additional parameters, the second parameter is ignored.

### Performance Results

The benchmarking results show the number of executions per second for each of the three methods in a specific browser context:

1. **round**: 258,677,504 executions per second
2. **floor**: 243,322,448 executions per second
3. **trunc**: 241,060,112 executions per second

### Pros and Cons of Each Approach

- **Math.round()**:
  - **Pros**: Very useful for typical rounding scenarios and has intuitive behavior for users.
  - **Cons**: Performance may be slower compared to truncation and flooring, especially if misapplied (e.g., ignoring additional parameters).

- **Math.trunc()**:
  - **Pros**: Fast execution and straightforward for cases where rounding is not desired.
  - **Cons**: May be counterintuitive if the user expects rounding behavior instead of simple truncation.

- **Math.floor()**:
  - **Pros**: Useful in scenarios where you want to guarantee the result is less than or equal to the input number.
  - **Cons**: Slightly less performant than rounding in this test; however, performance impacts may vary depending on context.

### Other Considerations and Alternatives

- **Alternatives**: If needing to round numbers to specific decimal places, one could use custom functions or libraries that provide more granularity than the basic Math functions. Libraries such as **Lodash** can provide additional options for manipulating numbers more effectively than the basic Math API.

- **Library Use**: No external libraries are needed for these basic arithmetic operations, as they are provided natively by JavaScript. However, when more complex numerical manipulation is necessary, developers might consider using libraries.

### Conclusion

This benchmark provides insight into how performance varies between different numerical manipulation techniques in JavaScript. Based on execution speed, `Math.round()` performs the best among the options tested, with `Math.floor()` and `Math.trunc()` following closely. Understanding the implications of each method is essential for selecting the right approach depending on the specific scenario in software development.

Related benchmarks:

round vs trunc vs floor (2) (version: 1)

Comparing performance of: trunc vs round vs floor

Created: 2 months ago by: Guest

Jump to the latest result

trunc

round

floor

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