Benchmark: math.round vs alternatives (floating point fix)

Script Preparation code:

var factor = 10 ** 8
var fp = (1.1*1.1) // 1.2100000000000002

Tests:

math.round
Math.round(fp * 10e8) / 10e8
math.round2
Math.round(fp * factor) / factor;
decimal round
const fpFix = Number.EPSILON * (fp < 0 ? -1 : 1); Math.round((fp + fpFix) * factor) / factor;
round (php)
let d = 8; let n = +(d ? fp * factor : fp).toFixed(8); let r = Math.round(n) d ? r / factor : r;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
math.round
math.round2
decimal round
round (php)

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks!

The provided benchmark tests four different approaches to mitigate floating-point precision issues when using `Math.round` in JavaScript.

**Approach 1: Using `Math.round` with a multiplier**

```javascript
Benchmark Definition: Math.round(fp * factor) / factor;
```

This approach multiplies the input value by a large number (`factor`) before passing it to `Math.round`. This is done to reduce the effect of floating-point precision issues.

Pros:

* Simple and easy to implement.
* Reduces the impact of floating-point errors.

Cons:

* May not be as efficient as other approaches, especially for larger inputs.
* Can lead to unnecessary calculations if the input value is very large or small.

**Approach 2: Using `Number.EPSILON`**

```javascript
Benchmark Definition: const fpFix = Number.EPSILON * (fp < 0 ? -1 : 1); Math.round((fp + fpFix) * factor) / factor;
```

This approach uses the `Number.EPSILON` constant, which represents the smallest difference between 1 and any non-zero number in JavaScript. It adds a small value to the input (`fp`) to help mitigate floating-point precision issues.

Pros:

* More efficient than Approach 1, especially for larger inputs.
* Works well for both positive and negative input values.

Cons:

* Requires knowledge of `Number.EPSILON` to implement correctly.

**Approach 3: Using string formatting**

```javascript
Benchmark Definition: let n = +(d ? fp * factor : fp).toFixed(8); let r = Math.round(n); d ? r / factor : r;
```

This approach uses string formatting (`toFixed`) to convert the input value to a string with a fixed number of decimal places. The resulting string is then passed to `Math.round`.

Pros:

* Works well for both positive and negative input values.
* Can be more efficient than Approach 1 or 2.

Cons:

* May not work correctly for very large or small input values.
* Requires knowledge of string formatting to implement correctly.

**Library: `Number.EPSILON`**

The `Number.EPSILON` constant is a built-in JavaScript property that represents the smallest difference between 1 and any non-zero number in JavaScript. It is used to mitigate floating-point precision issues by adding a small value to the input value.

**Special JS feature: none**

There are no special JavaScript features or syntax used in this benchmark.

The other alternatives to these approaches include:

* Using `BigInt` arithmetic, which can provide more accurate results for large integers.
* Using specialized libraries like `big-integer` or `decimal.js`, which can provide more accurate results for floating-point operations.
* Using compiler optimizations, such as `-ffast-math` in GCC, which can help mitigate floating-point precision issues.

Overall, the choice of approach depends on the specific use case and performance requirements. Approach 2 (using `Number.EPSILON`) is often considered a good balance between efficiency and accuracy.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36

Browser/OS: Chrome 86 on Linux

View result in a separate tab

Test name	Executions per second
math.round	5064755.5 Ops/sec
math.round2	2931345.5 Ops/sec
decimal round	1803232.1 Ops/sec
round (php)	1433298.2 Ops/sec

Related benchmarks:

math.round vs alternatives (floating point fix) (version: 0)

Various fixes for floating point issues

Comparing performance of: math.round vs math.round2 vs decimal round vs round (php)

Created: 4 years ago by: Registered User

Jump to the latest result

math.round

math.round2

decimal round

round (php)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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