Benchmark: Add using Decimal.js vs Add using native numbers

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:

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

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

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

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one month ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.3.1 Safari/605.1.15

Browser/OS: Safari 18 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Multiply using Decimal.js	2039.9 Ops/sec
Multiply using native numbers	2267919.0 Ops/sec
Multiply using numerical strings parsed with Number	30166.0 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):

LLMs can make mistakes. Check important info.

Let's break down the provided JSON data and explain what each section represents.

**Benchmark Definition**

The `Benchmark Definition` is a JSON object that defines the benchmark being tested. In this case, it's comparing three different approaches for adding numbers:

* Using Decimal.js (a library for precise decimal arithmetic)
* Using native numbers (which are floating-point numbers represented in binary format by the CPU)
* Using numerical strings parsed with `Number` (converting strings to numbers using the `Number()` function)

**Options Compared**

The options being compared are:

1. **Decimal.js**: A JavaScript library that provides a precise way of performing arithmetic operations on decimal numbers.
2. **Native Numbers**: The built-in floating-point numbers represented in binary format by the CPU. These numbers have limited precision and can suffer from rounding errors.
3. **Numerical Strings with Number**: Converting strings to numbers using `Number()` function, which can lead to precision issues due to the limitations of JavaScript's `Number` conversion.

**Pros and Cons**

Here are some pros and cons for each approach:

* **Decimal.js**:
	+ Pros: Precise control over decimal arithmetic, easy to use.
	+ Cons: Can be slower than native numbers, may require more memory usage.
* **Native Numbers**:
	+ Pros: Fast, efficient, widely supported.
	+ Cons: Limited precision, can suffer from rounding errors, may not work as expected in all situations.
* **Numerical Strings with Number**:
	+ Pros: Simple to implement, no additional dependencies required.
	+ Cons: Can lead to precision issues, may not be suitable for critical applications.

**Library and Syntax**

The `Decimal.js` library is used to perform decimal arithmetic. It provides a range of features, including:

* Support for arbitrary-precision decimal numbers
* Fast and efficient arithmetic operations
* Easy-to-use API

When using `Decimal.js`, the syntax is similar to regular JavaScript arithmetic, but with a few notable differences:

* Decimal literals are prefixed with a dot (e.g., `0.00253452345`).
* Arithmetic operators (`+`, `-`, `*`, `/`) work as expected.
* Methods like `add()`, `subtract()`, `multiply()`, and `divide()` can be used to perform operations.

The use of `Number()` with numerical strings is not a recommended approach, as it can lead to precision issues. Instead, consider using the built-in numeric literals or a dedicated decimal library like Decimal.js.

**Other Considerations**

When choosing between these approaches, consider the following factors:

* Performance requirements: If speed is critical, native numbers might be a better choice.
* Precision requirements: If precise decimal arithmetic is essential, Decimal.js or numerical strings with a dedicated library might be a better fit.
* Complexity and maintenance: Decimal.js provides an easy-to-use API, while numerical strings with Number require more manual handling.

**Alternatives**

Other alternatives for performing decimal arithmetic in JavaScript include:

* `Big.js`: A popular library for arbitrary-precision integer and decimal arithmetic.
* `BigInt.js`: A built-in support for arbitrary-precision integers in modern JavaScript engines (starting from ECMAScript 2020).
* Other libraries, such as `js-bigint` or `decimal.js`, which provide similar functionality to Decimal.js.

Related benchmarks:

Add using Decimal.js vs Add using native numbers (version: 0)

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

Created: 4 years ago by: Guest

Jump to the latest result

Multiply using Decimal.js

Multiply using native numbers

Multiply using numerical strings parsed with Number

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 6 months ago):