Benchmark: bignumber.js vs. big.js vs. decimal.js vs bn.js

bignumber.js vs. big.js vs. decimal.js vs bn.js (version: 1)

- 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 - https://github.com/indutny/bn.js

Comparing performance of: Native vs Native + toFixed vs decimal.js vs big.js vs bignumber.js vs bn.js vs bn.js in-place

Created: one month ago by: Guest

Jump 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://unpkg.com/bn.js@5.2.1/lib/bn.js"></script>
<!--script src="https://raw.githubusercontent.com/infusion/Fraction.js/v4.0.12/fraction.min.js"></script-->

Tests:

Native
var a = 57005; var b = 42; var c = 1.55; ((((a + b) * b) / 5) * c).toString(); // "742751.9400000001"
Native + toFixed
var a = 57005; var b = 42; var c = 1.55; ((((a + b) * b) / 5) * c).toFixed(9); // "742751.940000000"
decimal.js
var a = new Decimal("57005"); var b = new Decimal("42"); var c = 1.55; a.plus(b).times(b).dividedBy(5).times(c).toString(); // "742751.94"
big.js
var a = new Big("57005"); var b = new Big("42"); var c = 1.55; a.plus(b).mul(b).div(5).mul(c).toString(); // "742751.94"
bignumber.js
var a = new BigNumber("57005"); var b = new BigNumber("42"); var c = 1.55; a.plus(b).multipliedBy(b).dividedBy(5).multipliedBy(c).toString(); // "742751.94"
bn.js
var a = new BN("57005"); var b = new BN("42"); var c = 1.55; a.add(b).mul(b).divn(5).muln(c).toString(); // "742750" the divn(5) affects the precision
bn.js in-place
var a = new BN("57005"); var b = new BN("42"); var c = 1.55; a.iadd(b).imul(b).idivn(5).imuln(c).toString(); // "742750" the idivn(5) affects the precision

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
bn.js
bn.js in-place

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:136.0) Gecko/20100101 Firefox/136.0

Browser/OS: Firefox 136 on Windows

View result in a separate tab

Test name	Executions per second
Native	1370193920.0 Ops/sec
Native + toFixed	13581755.0 Ops/sec
decimal.js	615282.1 Ops/sec
big.js	326783.9 Ops/sec
bignumber.js	338425.5 Ops/sec
bn.js	1029262.7 Ops/sec
bn.js in-place	1087712.1 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):

LLMs can make mistakes. Check important info.

The benchmark in question compares the performance of various JavaScript libraries for handling arbitrary-precision arithmetic against native JavaScript number handling. Specifically, it evaluates how well four libraries—`bignumber.js`, `big.js`, `decimal.js`, and `bn.js`—perform alongside two native approaches.

### Benchmark Options Compared

1. **Native JS Arithmetic:**
   - **Test Name:** `Native`
   - **Benchmark Definition:** Uses standard JavaScript arithmetic operations to perform the calculation.
   - **Pros:** Extremely fast, as it directly utilizes the JavaScript engine's native capabilities.
   - **Cons:** Limited precision and potential floating-point inaccuracies, especially for very large or small numbers.

2. **Native with `toFixed`:**
   - **Test Name:** `Native + toFixed`
   - **Benchmark Definition:** Similar to the native approach but adds a formatting step with `toFixed(9)` to control the number of decimal places.
   - **Pros:** Provides control over precision in the display of numbers.
   - **Cons:** The precision limitation still exists; thus, inaccuracies may arise, and there’s an overhead in function calls.

3. **decimal.js:**
   - **Test Name:** `decimal.js`
   - **Benchmark Definition:** Utilizes the Decimal class from the `decimal.js` library to handle the calculation.
   - **Library Purpose:** `decimal.js` is designed to enable users to work with decimal numbers accurately without binary floating-point inaccuracies.
   - **Pros:** High precision and reliable handling of decimal numbers, minimizing rounding errors.
   - **Cons:** Introduces some overhead due to object creation and method calls compared to native operations.

4. **big.js:**
   - **Test Name:** `big.js`
   - **Benchmark Definition:** Uses the Big class of the `big.js` library.
   - **Library Purpose:** Similar to `decimal.js`, it handles arbitrary-precision arithmetic, particularly focusing on large numbers.
   - **Pros:** Effective for ensuring precision in large numeric calculations while being fairly lightweight.
   - **Cons:** Like `decimal.js`, it incurs some performance penalty due to the overhead of library functions.

5. **bignumber.js:**
   - **Test Name:** `bignumber.js`
   - **Benchmark Definition:** Uses the BigNumber class from the `bignumber.js` library.
   - **Library Purpose:** Provides a way to represent and operate on large numbers accurately.
   - **Pros:** Offers good precision and is widely used in financial applications.
   - **Cons:** Also introduces overhead due to object manipulations and function calls.

6. **bn.js:**
   - **Test Names:** `bn.js` and `bn.js in-place`
   - **Benchmark Definition:** 
     - The standard version uses the BN class for calculations using addition, multiplication, and division methods.
     - The in-place version optimizes performance by modifying the existing BN instances directly (using `iadd`, `imul`, `idivn`, etc.).
   - **Library Purpose:** Used predominantly in cryptographic applications, `bn.js` is optimized for working with large integers in a performant manner.
   - **Pros:** Provides performance benefits in the in-place version, reducing the number of object mutations.
   - **Cons:** While `bn.js` is optimized for integer arithmetic, it may not handle decimal points as accurately as decimal-focused libraries.

### Benchmark Results Analysis

The execution results indicate significant differences in performance between these various methods. The native approach (`Native`) outperformed all library-based solutions by a considerable margin, achieving around 1.37 billion executions per second. In contrast, the other approaches, particularly the library-based methods, operated in the hundreds of thousands to low millions of executions per second.

- `Native + toFixed` added some overhead but was still relatively fast compared to libraries.
- The `bn.js` library showed strong performance, especially in its in-place variant, indicating some efficiency in utilizing existing instances.
- Libraries like `decimal.js` and `big.js` offered lower performance than `bn.js` but are more suitable for applications needing high-precision decimal calculations.

### Other Alternatives

- **Native Numbers:** Directly using JavaScript's `Number` type for calculations, straightforward but limited concerning precision.
- **BigInt:** JavaScript's built-in `BigInt` type allows for arbitrary-precision integers but does not handle decimal points, making it suitable only for precise integer arithmetic.
- **Fraction.js or other libraries:** Such libraries could also be benchmarks but were not included in this test; they could offer a different approach, particularly for fractional arithmetic.

### Conclusion

This benchmark serves to highlight the trade-offs between performance and precision when using native JavaScript operations versus various libraries designed for higher accuracy. The results underscore the importance of selecting the right approach based on the specific requirements of the application regarding precision, performance, and overhead.

Related benchmarks:

bignumber.js vs. big.js vs. decimal.js vs bn.js (version: 1)

- 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 - https://github.com/indutny/bn.js

Comparing performance of: Native vs Native + toFixed vs decimal.js vs big.js vs bignumber.js vs bn.js vs bn.js in-place

Created: one month ago by: Guest

Jump to the latest result

Native

Native + toFixed

decimal.js

big.js

bignumber.js

bn.js

bn.js in-place

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated one month ago):