Benchmark: Round Numbers to 2 digits

Script Preparation code:

var number = 12324242/432432432;
var result;

function round(value, decimals) {
    value = value * Math.pow(10, decimals);
    value = Math.round(value);
    value = value / Math.pow(10, decimals);
    return value;
}

function MathRound(number) {
    return  Math.round((100 - (number) * 100) * 100) / 100;
}

Tests:

toFixed
result = +(number.toFixed(2));
Math.round
result = Math.round((100 - (number) * 100) * 100) / 100;
Round function with correction
result = round(number, 2);
Math.roundv2
result = MathRound(number);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
toFixed
Math.round
Round function with correction
Math.roundv2

Fastest: N/A

Slowest: N/A

Latest run results:

No previous run results

This benchmark does not have any results yet. Be the first one to run it!

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

LLMs can make mistakes. Check important info.

Let's dive into explaining the benchmark.

**Benchmark Definition**

The benchmark is designed to test the performance of three different rounding functions: `Math.round`, `round` (with correction), and `toFixed`. The script preparation code includes two custom rounding functions: `round` and `MathRound`.

*   `round(value, decimals)`: This function multiplies the input value by 10 raised to the power of the specified number of decimal places, rounds the result using `Math.round`, and then divides by 10 raised to the power of the original number of decimal places.
*   `MathRound(number)`: This function uses a trick where it subtracts the product of the number and 100 from 100, multiplies the result by 100, takes the absolute value, rounds using `Math.round`, and then divides by 100.

**Options Compared**

The benchmark compares three options:

*   **`toFixed(2)`**: This is a built-in JavaScript method that rounds a number to two decimal places.
*   **`round(number, 2)`**: The custom rounding function with correction (as described above).
*   **`MathRound(number)`**: Another custom rounding function that uses a trick to round the number.

**Pros and Cons of Different Approaches**

1.  `toFixed(2)`:
    *   Pros: Simple, widely supported, and fast.
    *   Cons: May not be suitable for all use cases (e.g., financial calculations), as it rounds to two decimal places instead of the specified number of decimal places.

2.  `round(number, 2)`:
    *   Pros: Customizable rounding behavior, which can be beneficial in certain applications.
    *   Cons: May have performance overhead due to the custom function call.

3.  `MathRound(number)`:
    *   Pros: Also customizable rounding behavior and potentially faster than `round(number, 2)`.
    *   Cons: Uses a trick that might not be immediately understandable or maintainable by all developers.

**Library and Special JS Feature**

There are no external libraries used in this benchmark. However, note that the use of `toFixed(2)` relies on the fact that JavaScript has built-in support for rounding numbers.

**Test Case Considerations**

Each test case focuses on a specific rounding function or method:

*   `toFixed`
*   `round(number, 2)`
*   `MathRound(number)`

The benchmark measures the performance of each option across multiple executions per second, which provides insight into their relative speeds.

Related benchmarks:

Round Numbers to 2 digits (version: 0)

Comparing performance of: toFixed vs Math.round vs Round function with correction vs Math.roundv2

Created: 8 years ago by: Guest

Jump to the latest result

toFixed

Math.round

Round function with correction

Math.roundv2

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

No previous run results

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