Benchmark: Add using Decimal.js vs native JS vs Number() vs parseFloat()

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/npm/decimal.js-light@2.5.0/decimal.min.js'></script>

Script Preparation code:

var x = 5.236;

Tests:

Add using Decimal.js
for (var i = 0; i < 1000; i++) { Decimal('0.00253452345').plus(Decimal('0.042234')) }
Add using native numbers
for (var i = 0; i < 1000; i++) { 0.00253452345 + 0.042234 }
Add using numerical strings parsed with Number
for (var i = 0; i < 1000; i++) { Number("0.00253452345") + Number("0.042234") }
Add using numerical strings parsed with parseFloat
for (var i = 0; i < 1000; i++) { parseFloat("0.00253452345") + parseFloat("0.042234") }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Add using Decimal.js
Add using native numbers
Add using numerical strings parsed with Number
Add using numerical strings parsed with parseFloat

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 world of JavaScript microbenchmarks.

The provided benchmark compares the performance of four approaches for adding decimal numbers:

1. **Decimal.js**: A library that provides support for arbitrary-precision decimal arithmetic.
2. **Native JS** (JavaScript): The built-in number type in JavaScript, which is a 64-bit floating-point number.
3. **Number()**: A function that parses a string as a number using the `Number()` constructor.
4. **parseFloat**: A function that parses a string as a float.

Let's analyze each approach:

**Decimal.js**

Pros:

* Provides support for arbitrary-precision decimal arithmetic, which is essential for financial and scientific applications where high precision is required.
* Can handle very large numbers without losing accuracy.

Cons:

* Adds an external dependency (the Decimal.js library), which may slow down the benchmark due to loading times.
* May introduce additional overhead compared to native JavaScript operations.

**Native JS**

Pros:

* No external dependencies, as it uses built-in JavaScript functionality.
* Fast execution, as it leverages the CPU's floating-point capabilities.

Cons:

* Limited precision (64-bit floating-point number), which may not be sufficient for high-precision applications.
* May lose accuracy when dealing with very large numbers due to rounding errors.

**Number()**

Pros:

* Simple and lightweight, as it only requires a single function call.
* Can handle decimal strings, although it's limited to a fixed precision (usually 16 or 32 decimal digits).

Cons:

* Limited precision and accuracy, especially for large numbers.
* May throw errors if the input string is not in a valid format.

**parseFloat**

Pros:

* Similar to `Number()`, but with the added benefit of being able to handle strings that represent floating-point numbers (e.g., `42.234`).
* Still has limited precision and accuracy, especially for large numbers.

Cons:

* Also has limited precision and accuracy, similar to `Number()`.
* May throw errors if the input string is not in a valid format.

The benchmark compares these approaches by measuring the execution time of each addition operation (with different decimal strings) using four different browsers. The results show that:

* Decimal.js outperforms native JavaScript and the parsing-based approaches for larger numbers.
* Native JS is the fastest but also has limited precision.
* `Number()` and `parseFloat` have similar performance, but with limited precision.

Other alternatives to consider:

* **Big.js**: Another library for arbitrary-precision decimal arithmetic in JavaScript. It's designed to be more efficient than Decimal.js and provides additional features like rounding and formatting.
* **BigInt**: A built-in JavaScript feature (introduced in ECMAScript 2020) that supports arbitrarily large integers, which can also be used for decimal arithmetic with some modifications.
* **BC Math functions**: Many programming languages, including JavaScript, provide BC Math functions (e.g., `bcadd`, `bcmul`) that support arbitrary-precision arithmetic. These functions are often more efficient than libraries like Decimal.js and Big.js.

When choosing an approach, consider the specific requirements of your application, such as precision, performance, and simplicity. If you need high precision, use a library like Decimal.js or Big.js. For fast execution without high precision, use native JavaScript operations.

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/105.0.0.0 Safari/537.36

Browser/OS: Chrome 105 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Add using Decimal.js	1242.9 Ops/sec
Add using native numbers	3002465.0 Ops/sec
Add using numerical strings parsed with Number	7665.2 Ops/sec
Add using numerical strings parsed with parseFloat	5149.1 Ops/sec

Related benchmarks:

Add using Decimal.js vs native JS vs Number() vs parseFloat() (version: 0)

Comparing performance of: Add using Decimal.js vs Add using native numbers vs Add using numerical strings parsed with Number vs Add using numerical strings parsed with parseFloat

Created: 4 years ago by: Guest

Jump to the latest result

Add using Decimal.js

Add using native numbers

Add using numerical strings parsed with Number

Add using numerical strings parsed with parseFloat

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