Benchmark: number / bignumber.js / big.js / decimal.js

number / bignumber.js / big.js / decimal.js (version: 0)

- https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Global_Objects/Number - 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 decimal.js vs big.js vs bignumber.js

Created: one year 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://raw.githubusercontent.com/infusion/Fraction.js/v4.0.12/fraction.min.js"></script-->

​x
 
<!--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-->
​

Tests:

native

const a = parseFloat('123.456');
const b = parseFloat('123.456');
//const c = isNan(a) && isNan(b);
const d = a > b || a < b;
const e = (a + b) * b;

 
const a = parseFloat('123.456');const b = parseFloat('123.456');//const c = isNan(a) && isNan(b);const d = a > b || a < b;const e = (a + b) * b;

decimal.js

const a = new Decimal('123.456');
const b = new Decimal('123.456');
//const c = a.isNan() && b.isNan();
const d = a.greaterThan(b) || a.lessThan(b);
const e = a.plus(b).times(b);

 
const a = new Decimal('123.456');const b = new Decimal('123.456');//const c = a.isNan() && b.isNan();const d = a.greaterThan(b) || a.lessThan(b);const e = a.plus(b).times(b);

big.js

const a = new Big('123.456');
const b = new Big('123.456');
//const c = a.isNan() && b.isNan();
const d = a.gt(b) || a.lt(b);
const e = a.plus(b).mul(b);

 
const a = new Big('123.456');const b = new Big('123.456');//const c = a.isNan() && b.isNan();const d = a.gt(b) || a.lt(b);const e = a.plus(b).mul(b);

bignumber.js

var a = new BigNumber('123.456');
var b = new BigNumber('123.456');
//const c = a.isNan() && b.isNan();
const d = a.gt(b) || a.lt(b);
const e = a.plus(b).multipliedBy(b);

 
var a = new BigNumber('123.456');var b = new BigNumber('123.456');//const c = a.isNan() && b.isNan();const d = a.gt(b) || a.lt(b);const e = a.plus(b).multipliedBy(b);

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
decimal.js
big.js
bignumber.js

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 4 months ago)

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

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
native	4462833.5 Ops/sec
decimal.js	683490.8 Ops/sec
big.js	1042611.1 Ops/sec
bignumber.js	653750.8 Ops/sec

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

Measuring the performance of numerical calculations in JavaScript is an interesting task.

What's being tested?

The provided benchmark tests four different approaches to perform numerical calculations:

Native: The native JavaScript implementation, which uses floating-point numbers (64-bit IEEE 754).
Big.js: A library that provides support for arbitrary-precision arithmetic, using a custom binary format.
Decimal.js: Another library that provides support for decimal arithmetic, with a focus on precision and accuracy.
Bignumber.js: A library that provides support for arbitrary-precision arithmetic, similar to Big.js.

Options compared

Each test case compares the performance of different numerical libraries or approaches:

decimal.js vs big.js: Both libraries provide support for decimal arithmetic, but with slightly different implementations and optimizations.
bignumber.js vs big.js: Both libraries provide support for arbitrary-precision arithmetic, but with different binary formats and optimization strategies.
Native JavaScript vs other libraries: The native implementation is compared to the performance of three third-party libraries.

Pros and cons

Here's a brief summary of the pros and cons of each approach:

Native JavaScript:
- Pros: Fast and lightweight, as it's implemented in C++ and optimized for performance.
- Cons: Limited precision (64-bit IEEE 754) and may exhibit numerical instability issues.
Big.js:
- Pros: Provides a fast and efficient implementation of arbitrary-precision arithmetic, with good support for decimal arithmetic.
- Cons: May have some overhead due to its custom binary format and optimization strategy.
Decimal.js:
- Pros: Focuses on precision and accuracy, making it suitable for applications where high precision is required.
- Cons: May be slower than Big.js or native JavaScript due to its additional checks and verification mechanisms.
Bignumber.js:
- Pros: Similar to Big.js, providing a fast and efficient implementation of arbitrary-precision arithmetic.
- Cons: May have some differences in binary format and optimization strategy compared to Big.js.

Other considerations

When choosing a numerical library or approach, consider the following factors:

Precision requirements: If you need high precision, Decimal.js might be a better choice. For general-purpose numerical calculations, native JavaScript or Big.js/Bignumber.js might be sufficient.
Performance: Native JavaScript is generally the fastest, followed by Bignumber.js and Big.js.
Developer experience: All three libraries are designed to be easy to use and provide good documentation.

Alternatives

If you're looking for alternative libraries or approaches, consider:

Fraction.js: A library that provides support for rational arithmetic and decimal arithmetic, with a focus on simplicity and performance.
Arbitrary-precision arithmetic in Node.js: Some Node.js implementations, like arbitrary-precision, provide built-in support for arbitrary-precision arithmetic.

Note: The choice of numerical library or approach ultimately depends on your specific use case, performance requirements, and developer preferences.

LLMs can make mistakes. Check important info.

Measuring the performance of numerical calculations in JavaScript is an interesting task.

**What's being tested?**

The provided benchmark tests four different approaches to perform numerical calculations:

1. **Native**: The native JavaScript implementation, which uses floating-point numbers (64-bit IEEE 754).
2. **Big.js**: A library that provides support for arbitrary-precision arithmetic, using a custom binary format.
3. **Decimal.js**: Another library that provides support for decimal arithmetic, with a focus on precision and accuracy.
4. **Bignumber.js**: A library that provides support for arbitrary-precision arithmetic, similar to Big.js.

**Options compared**

Each test case compares the performance of different numerical libraries or approaches:

* `decimal.js` vs `big.js`: Both libraries provide support for decimal arithmetic, but with slightly different implementations and optimizations.
* `bignumber.js` vs `big.js`: Both libraries provide support for arbitrary-precision arithmetic, but with different binary formats and optimization strategies.
* Native JavaScript vs other libraries: The native implementation is compared to the performance of three third-party libraries.

**Pros and cons**

Here's a brief summary of the pros and cons of each approach:

1. **Native JavaScript**:
	* Pros: Fast and lightweight, as it's implemented in C++ and optimized for performance.
	* Cons: Limited precision (64-bit IEEE 754) and may exhibit numerical instability issues.
2. **Big.js**:
	* Pros: Provides a fast and efficient implementation of arbitrary-precision arithmetic, with good support for decimal arithmetic.
	* Cons: May have some overhead due to its custom binary format and optimization strategy.
3. **Decimal.js**:
	* Pros: Focuses on precision and accuracy, making it suitable for applications where high precision is required.
	* Cons: May be slower than Big.js or native JavaScript due to its additional checks and verification mechanisms.
4. **Bignumber.js**:
	* Pros: Similar to Big.js, providing a fast and efficient implementation of arbitrary-precision arithmetic.
	* Cons: May have some differences in binary format and optimization strategy compared to Big.js.

**Other considerations**

When choosing a numerical library or approach, consider the following factors:

* Precision requirements: If you need high precision, Decimal.js might be a better choice. For general-purpose numerical calculations, native JavaScript or Big.js/Bignumber.js might be sufficient.
* Performance: Native JavaScript is generally the fastest, followed by Bignumber.js and Big.js.
* Developer experience: All three libraries are designed to be easy to use and provide good documentation.

**Alternatives**

If you're looking for alternative libraries or approaches, consider:

1. **Fraction.js**: A library that provides support for rational arithmetic and decimal arithmetic, with a focus on simplicity and performance.
2. **Arbitrary-precision arithmetic in Node.js**: Some Node.js implementations, like `arbitrary-precision`, provide built-in support for arbitrary-precision arithmetic.

Note: The choice of numerical library or approach ultimately depends on your specific use case, performance requirements, and developer preferences.

Related benchmarks: