Benchmark: bignumber.js vs. big.js vs. decimal.js 2022 ver. (random) (no toFixed)

bignumber.js vs. big.js vs. decimal.js 2022 ver. (random) (no toFixed) (version: 0)

Compare newer version of bignumer libraries.

Comparing performance of: Native toString() vs Native toFixed(9) vs bignumber.js toString() vs bignumber.js toFixed(18) vs big.js toString() vs big.js toFixed(18) vs decimal.js toString() vs decimal.js toFixed(18)

Created: one year ago by: Guest

Jump to the latest result

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/bignumber.js/9.1.0/bignumber.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/big.js/6.2.1/big.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/decimal.js/10.3.1/decimal.min.js"></script>
<!--<script src="https://cdn.jsdelivr.net/npm/decimal.js-light@2.5.1/decimal.min.js"></script>-->

AخA
 
<script src="https://cdnjs.cloudflare.com/ajax/libs/bignumber.js/9.1.0/bignumber.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/big.js/6.2.1/big.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/decimal.js/10.3.1/decimal.min.js"></script>
<!--<script src="https://cdn.jsdelivr.net/npm/decimal.js-light@2.5.1/decimal.min.js"></script>-->

Script Preparation code:

BigNumber.set({
    EXPONENTIAL_AT: 999,
    DECIMAL_PLACES: 18
});
Decimal.set({
    toExpNeg: -999,
    toExpPos: 999,
    precision: 18
});
Big.DP = 18;
Big.NE = -999;
Big.PE = 999;

 
BigNumber.set({    EXPONENTIAL_AT: 999,    DECIMAL_PLACES: 18});Decimal.set({    toExpNeg: -999,    toExpPos: 999,    precision: 18});Big.DP = 18;Big.NE = -999;Big.PE = 999;

Tests:

Native toString()

{
  const a = Math.random();
  const b = Math.random();
  const c = Math.random();
  const d = Math.random();
  ((a + b) * (c - d));
}

 
{  const a = Math.random();  const b = Math.random();  const c = Math.random();  const d = Math.random();  ((a + b) * (c - d));}

Native toFixed(9)

{
  const a = Math.random();
  const b = Math.random();
  const c = Math.random();
  const d = Math.random();
  ((a + b) * (c - d));
}

 
{  const a = Math.random();  const b = Math.random();  const c = Math.random();  const d = Math.random();  ((a + b) * (c - d));}

bignumber.js toString()
{ const a = BigNumber(Math.random()); const b = BigNumber(Math.random()); const c = BigNumber(Math.random()); const d = BigNumber(Math.random()); a.plus(b).times(c.minus(d)); }
{
const a = BigNumber(Math.random());
const b = BigNumber(Math.random());
const c = BigNumber(Math.random());
const d = BigNumber(Math.random());
a.plus(b).times(c.minus(d));
}
bignumber.js toFixed(18)
{ const a = BigNumber(Math.random()); const b = BigNumber(Math.random()); const c = BigNumber(Math.random()); const d = BigNumber(Math.random()); a.plus(b).times(c.minus(d)); }
{
const a = BigNumber(Math.random());
const b = BigNumber(Math.random());
const c = BigNumber(Math.random());
const d = BigNumber(Math.random());
a.plus(b).times(c.minus(d));
}
big.js toString()
{ const a = Big(Math.random()); const b = Big(Math.random()); const c = Big(Math.random()); const d = Big(Math.random()); a.plus(b).times(c.minus(d)); }
{
const a = Big(Math.random());
const b = Big(Math.random());
const c = Big(Math.random());
const d = Big(Math.random());
a.plus(b).times(c.minus(d));
}
big.js toFixed(18)
{ const a = Big(Math.random()); const b = Big(Math.random()); const c = Big(Math.random()); const d = Big(Math.random()); a.plus(b).times(c.minus(d)).toFixed(18); }
{
const a = Big(Math.random());
const b = Big(Math.random());
const c = Big(Math.random());
const d = Big(Math.random());
a.plus(b).times(c.minus(d)).toFixed(18);
}
decimal.js toString()
{ const a = Decimal(Math.random()); const b = Decimal(Math.random()); const c = Decimal(Math.random()); const d = Decimal(Math.random()); a.plus(b).times(c.minus(d)).toString(); }
{
const a = Decimal(Math.random());
const b = Decimal(Math.random());
const c = Decimal(Math.random());
const d = Decimal(Math.random());
a.plus(b).times(c.minus(d)).toString();
}
decimal.js toFixed(18)
{ const a = Decimal(Math.random()); const b = Decimal(Math.random()); const c = Decimal(Math.random()); const d = Decimal(Math.random()); a.plus(b).times(c.minus(d)).toFixed(18); }
{
const a = Decimal(Math.random());
const b = Decimal(Math.random());
const c = Decimal(Math.random());
const d = Decimal(Math.random());
a.plus(b).times(c.minus(d)).toFixed(18);
}

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Experimental features:

Memory measurements supported only in Chrome.
For precise memory measurements Chrome must be launched with --enable-precise-memory-info flag.
More information: Monitoring JavaScript Memory

Test case name	Result
Native toString()
Native toFixed(9)
bignumber.js toString()
bignumber.js toFixed(18)
big.js toString()
big.js toFixed(18)
decimal.js toString()
decimal.js toFixed(18)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 11 days ago)

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

Browser/OS: Chrome 133 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Native toString()	40250180.0 Ops/sec
Native toFixed(9)	40400780.0 Ops/sec
bignumber.js toString()	435840.2 Ops/sec
bignumber.js toFixed(18)	438181.8 Ops/sec
big.js toString()	434633.8 Ops/sec
big.js toFixed(18)	379201.7 Ops/sec
decimal.js toString()	353112.1 Ops/sec
decimal.js toFixed(18)	328715.6 Ops/sec

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

Overview of the Benchmark

The benchmark compares the performance of four libraries: big.js, bignumber.js, and two implementations of arbitrary-precision arithmetic (native and decimal.js). The test is executed on a mobile device running Chrome 126.

Arbitrary-Precision Arithmetic Implementations

There are three implementations:

Native: Uses the built-in support for arbitrary-precision arithmetic in JavaScript.
big.js: A dedicated library for working with large integers.
bignumber.js: Another popular library for handling large numbers.
decimal.js: An implementation of decimal arithmetic, which is a different concept from arbitrary-precision integer arithmetic.

Key Insights

The native implementation provides the fastest performance, but this comes at the cost of accuracy and portability (as it relies on JavaScript's built-in support).
big.js and bignumber.js perform similarly, with slightly slower execution times than the native implementation.
decimal.js is significantly slower than the other implementations.

Performance Comparison

The benchmark results show that:

Implementation	Execution Rate
Native	1050730.25 executions/second
big.js	100165.9453125 executions/second
bignumber.js	100165.9453125 executions/second
decimal.js	79191.1015625 executions/second

The native implementation outperforms the other libraries, but its accuracy and portability are limited.

Recommendations

Based on these results, if you need to perform arbitrary-precision integer arithmetic in a performance-critical application, using the native JavaScript implementation might be the best choice. However, if you need accurate results across multiple platforms or want a dedicated library for this purpose, big.js or bignumber.js could be suitable alternatives.

For decimal arithmetic, decimal.js is not recommended due to its slow performance.

Keep in mind that these results are specific to the mobile device and Chrome 126 browser. The performance differences may vary on other platforms or browsers.

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The benchmark compares the performance of four libraries: `big.js`, `bignumber.js`, and two implementations of arbitrary-precision arithmetic (`native` and `decimal.js`). The test is executed on a mobile device running Chrome 126.

**Arbitrary-Precision Arithmetic Implementations**

There are three implementations:

1. **Native**: Uses the built-in support for arbitrary-precision arithmetic in JavaScript.
2. **big.js**: A dedicated library for working with large integers.
3. **bignumber.js**: Another popular library for handling large numbers.
4. **decimal.js**: An implementation of decimal arithmetic, which is a different concept from arbitrary-precision integer arithmetic.

**Key Insights**

* The native implementation provides the fastest performance, but this comes at the cost of accuracy and portability (as it relies on JavaScript's built-in support).
* `big.js` and `bignumber.js` perform similarly, with slightly slower execution times than the native implementation.
* `decimal.js` is significantly slower than the other implementations.

**Performance Comparison**

The benchmark results show that:

| Implementation | Execution Rate |
| --- | --- |
| Native | 1050730.25 executions/second |
| big.js | 100165.9453125 executions/second |
| bignumber.js | 100165.9453125 executions/second |
| decimal.js | 79191.1015625 executions/second |

The native implementation outperforms the other libraries, but its accuracy and portability are limited.

**Recommendations**

Based on these results, if you need to perform arbitrary-precision integer arithmetic in a performance-critical application, using the native JavaScript implementation might be the best choice. However, if you need accurate results across multiple platforms or want a dedicated library for this purpose, `big.js` or `bignumber.js` could be suitable alternatives.

For decimal arithmetic, `decimal.js` is not recommended due to its slow performance.

Keep in mind that these results are specific to the mobile device and Chrome 126 browser. The performance differences may vary on other platforms or browsers.

Related benchmarks: