Benchmark: bignumber.js vs. big.js vs. decimal.js (I) V20

bignumber.js vs. big.js vs. decimal.js (I) V20 (version: 0) Benchmark.js

- https://github.com/MikeMcl/bignumber.js/tree/v9.0.0 - https://github.com/MikeMcl/big.js/tree/v5.2.2 - https://github.com/MikeMcl/decimal.js/tree/v10.2.0

Comparing performance of: `Native vs Native + toFixed vs decimal.js vs big.js vs bignumber.js vs Option 1`

Created: 3 years ago by: Guest

Go to the latest result

HTML Preparation code:

<!--script src="https://raw.githubusercontent.com/iriscouch/bigdecimal.js/v0.6.1/lib/bigdecimal.js"></script-->
<script src="https://cdnjs.cloudflare.com/ajax/libs/bignumber.js/9.0.1/bignumber.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/big.js/6.0.3/big.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/decimal.js/10.2.1/decimal.min.js"></script>
<!--script src="https://raw.githubusercontent.com/infusion/Fraction.js/v4.0.12/fraction.min.js"></script-->

Script Preparation code:

const decimalPlaces = 14;

function toFixed(n) {
    return Math.round(n * Math.pow(10, decimalPlaces)) / Math.pow(10, decimalPlaces);
}

function add(a, b) {
    return toFixed(a + b);
}

function subtract(a, b) {
    return toFixed(a - b);
}

Tests:

Native
var a = 0.1; var b = 0.2; ((a + b) * b).toString();
Native + toFixed
var a = 0.1; var b = 0.2; ((a + b) * b).toFixed(9);
decimal.js
var a = new Decimal("0.1"); var b = new Decimal("0.2"); a.plus(b).times(b).toString();
big.js
var a = new Big("0.1"); var b = new Big("0.2"); a.plus(b).mul(b).toString();
bignumber.js
var a = new BigNumber("0.1"); var b = new BigNumber("0.2"); a.plus(b).multipliedBy(b).toString();
Option 1
var a = 0.1; var b = 0.2; toFixed(toFixed(a + b) * b).toString();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native
Native + toFixed
decimal.js
big.js
bignumber.js
Option 1

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36

Browser/OS: Chrome 122 on Windows

View result in a separate tab

Native

77.0M/s

Native + toFixed

7.3M/s

Option 1

1.4M/s

big.js

1.1M/s

decimal.js

707K/s

bignumber.js

657K/s

View exact numbers

Test name	Executions per second
✓ Native	76,995,328 Ops/sec
Native + toFixed	7,343,505 Ops/sec
Option 1	1,382,981 Ops/sec
big.js	1,127,240 Ops/sec
decimal.js	707,426 Ops/sec
bignumber.js	656,893 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript microbenchmarking test case that compares the performance of four different libraries: bignumber.js, big.js, decimal.js, and their native counterparts (JavaScript's built-in arithmetic operations). The benchmark tests various scenarios to measure which library performs best.

**Tested Options**

1. **Native**: Uses JavaScript's built-in arithmetic operations without any library modifications.
2. **Native + toFixed**: Extends the Native approach by using the `toFixed()` method, which rounds numbers to a specified decimal place.
3. **decimal.js**: Utilizes the Decimal.js library for precise arithmetic.
4. **big.js**: Employs the Big.js library for large integer calculations.
5. **bignumber.js**: Leverages the Bignumber.js library for arbitrary-precision arithmetic.
6. **Option 1**: A custom approach that uses `toFixed()` to round intermediate results, similar to the Native + toFixed scenario.

**Pros and Cons of Each Approach**

1. **Native**:
	* Pros: Built-in operations are typically faster and more efficient.
	* Cons: Limited precision and may not handle large numbers well.
2. **Native + toFixed**:
	* Pros: Combines the benefits of built-in operations with a precise rounding method.
	* Cons: May incur additional overhead due to `toFixed()` calls.
3. **decimal.js**:
	* Pros: Provides high precision and accurate results for arithmetic operations.
	* Cons: May have slower performance compared to native operations or optimized libraries like Big.js.
4. **big.js**:
	* Pros: Designed for large integer calculations, offering good performance and accuracy.
	* Cons: May not be suitable for general-purpose arithmetic operations.
5. **bignumber.js**:
	* Pros: Offers arbitrary-precision arithmetic with good performance and flexibility.
	* Cons: May have higher memory usage compared to optimized libraries like Big.js.
6. **Option 1**:
	* Pros: Uses a custom approach that balances precision and performance.
	* Cons: May not be as efficient as optimized libraries, and its effectiveness depends on the specific use case.

**Library Descriptions**

1. **Decimal.js**: A library for precise arithmetic operations, providing high accuracy and control over decimal representations.
2. **Big.js**: A library designed for large integer calculations, offering good performance and flexibility.
3. **Bignumber.js**: A library for arbitrary-precision arithmetic, providing a balance between precision and performance.

**Special JS Feature or Syntax**

The benchmark uses JavaScript's built-in arithmetic operations (e.g., `+`, `*`) without any modifications. No specific features like `let` or `const` are utilized beyond their standard functionality.

In conclusion, the benchmark helps developers understand the trade-offs between different libraries and approaches for arithmetic operations in JavaScript. By comparing these options, you can choose the best library or approach for your specific use case, considering factors such as precision, performance, and memory usage.