Benchmark: Rounding methods

Script Preparation code:

function round2(num, places) {
  return +(Math.round(num + "e+" + places)  + "e-" + places);
}

function round3(num, places) {
  if (places === 2) { 
    return Math.round( Math.round( num * 1000 ) / 10 ) / 100
  } else {
    const multiplier = Math.pow(10, places)
  	return Math.round(num * multiplier) / multiplier
  }
}

function round4(num, places) {
  +(num.toLocaleString(
    'en', 
    { maximumFractionDigits: places, useGrouping: false }
  ))
}

Tests:

Simple rounding
Math.round(12.345 * 100) / 100
Rounding with epsilon and string conversion
round2(12.345, 2)
Rounding with "if" statement
round3(12.345, 2)
Rounding by toLocaleString
round4(12.345, 2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Simple rounding
Rounding with epsilon and string conversion
Rounding with "if" statement
Rounding by toLocaleString

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the provided benchmark.

**Benchmark Definition**

The benchmark measures the performance of different rounding methods in JavaScript. The `Script Preparation Code` section defines three custom rounding functions: `round2`, `round3`, and `round4`. These functions are used to round numbers with a specified number of decimal places.

**Options Compared**

The benchmark compares the performance of these three custom rounding functions (`round2`, `round3`, and `round4`) against each other. The options being compared are:

1. **Round with epsilon and string conversion (round2)**: This function uses the `Math.round` function to round a number, adding and subtracting a small value (epsilon) to handle non-integer values.
2. **Rounding with "if" statement (round3)**: This function uses an if statement to determine how to round the number based on the specified number of decimal places.
3. **Rounding by toLocaleString (round4)**: This function uses the `toLocaleString` method to format a number as a string, which effectively rounds it.

**Pros and Cons of Each Approach**

1. **Round with epsilon and string conversion (round2)**
	* Pros:
		+ Simple and easy to implement.
		+ Handles non-integer values accurately.
	* Cons:
		+ May be slower due to the use of `Math.round` and string manipulation.
		+ Requires adding and subtracting epsilon, which may not always produce accurate results.
2. **Rounding with "if" statement (round3)**
	* Pros:
		+ Can be faster than using `Math.round` or `toLocaleString`.
		+ Allows for more control over rounding logic.
	* Cons:
		+ More complex and harder to implement than the first approach.
		+ May not handle all edge cases correctly.
3. **Rounding by toLocaleString (round4)**
	* Pros:
		+ Fastest of the three approaches, as it uses a built-in method.
		+ Handles many edge cases correctly, including non-integer values.
	* Cons:
		+ Less flexible than the other two approaches, as it relies on `toLocaleString`.
		+ May not work as expected for all input types (e.g., numbers with decimal points).

**Library and Purpose**

The `toLocaleString` method is a built-in JavaScript method that formats a number as a string according to the locale's conventions. In this benchmark, it is used to round numbers by formatting them as strings.

**Special JS Feature or Syntax**

None of the provided benchmark code uses any special JavaScript features or syntax beyond what is standard in JavaScript (e.g., functions, loops, conditional statements). However, the use of `Math.round` and `toLocaleString` methods implies that the benchmark is running on a platform that supports these built-in methods.

**Alternatives**

If you were to rewrite this benchmark using alternative approaches, some options might include:

1. Using a dedicated rounding library (e.g., `decimal.js`) instead of implementing custom rounding functions.
2. Using a different method for comparing performance, such as measuring the time it takes to perform a large number of rounding operations.
3. Adding more test cases or variations to the benchmark to make it more comprehensive.

Keep in mind that the choice of alternative approaches would depend on the specific requirements and goals of the benchmark.

Latest run results:

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

User agent: Mozilla/5.0 (Android 4.4.2; Tablet; rv:68.0) Gecko/68.0 Firefox/68.0

Browser/OS: Android 4 on Android 4.4.2

View result in a separate tab

Test name	Executions per second
Simple rounding	10991604.0 Ops/sec
Rounding with epsilon and string conversion	184544.5 Ops/sec
Rounding with "if" statement	5203109.5 Ops/sec
Rounding by toLocaleString	954.4 Ops/sec

Related benchmarks:

Rounding methods (version: 3)

First test is incorrect but needed to evaluate the performance penalty

Comparing performance of: Simple rounding vs Rounding with epsilon and string conversion vs Rounding with "if" statement vs Rounding by toLocaleString

Created: 5 years ago by: Registered User

Jump to the latest result

Simple rounding

Rounding with epsilon and string conversion

Rounding with "if" statement

Rounding by toLocaleString

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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