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

number vs bignumber.js vs big.js vs 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 d = a > b || a < b;

 
const a = parseFloat('123.456');const b = parseFloat('123.456');const d = a > b || a < b;

decimal.js

const a = new Decimal('123.456');
const b = new Decimal('123.456');
const d = a.greaterThan(b) || a.lessThan(b);

 
const a = new Decimal('123.456');const b = new Decimal('123.456');const d = a.greaterThan(b) || a.lessThan(b);

big.js

const a = new Big('123.456');
const b = new Big('123.456');
const d = a.gt(b) || a.lt(b);

 
const a = new Big('123.456');const b = new Big('123.456');const d = a.gt(b) || a.lt(b);

bignumber.js
var a = new BigNumber('123.456'); var b = new BigNumber('123.456'); const d = a.gt(b) || a.lt(b);
var a = new BigNumber('123.456');
var b = new BigNumber('123.456');
const d = a.gt(b) || a.lt(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: one year ago)

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

Browser/OS: Firefox 118 on Windows

View result in a separate tab

Test name	Executions per second
native	10257499.0 Ops/sec
decimal.js	1075698.5 Ops/sec
big.js	1544318.5 Ops/sec
bignumber.js	903064.9 Ops/sec

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

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

What is being tested?

The benchmark measures the performance of different libraries for working with numbers in JavaScript:

Number (native JavaScript type)
Big.js
Bignumber.js
Decimal.js

Specifically, the tests compare the performance of these libraries when performing arithmetic operations on floating-point numbers.

Options compared:

The benchmark compares four options:

Native Number type
Big.js
Bignumber.js
Decimal.js

Each library has its own strengths and weaknesses, which we'll discuss next.

Pros and Cons of each approach:

Native Number type:
- Pros: Fastest performance, widely supported.
- Cons: May exhibit behavior that's not predictable due to floating-point precision issues.
Big.js:
- Pros: High-performance, accurate calculations, and good support for various operations (e.g., addition, subtraction, multiplication, division).
- Cons: May require more memory usage compared to native Number type.
Bignumber.js:
- Pros: Fast performance, high precision, and good support for various operations.
- Cons: May be less suitable for very large numbers due to performance overhead.
Decimal.js:
- Pros: High-performance, accurate calculations, and good support for various operations (e.g., addition, subtraction, multiplication, division).
- Cons: May require more memory usage compared to native Number type.

Libraries used in the tests:

Big.js: A library for fast and precise arithmetic with large numbers.
Bignumber.js: A library for performing mathematical operations on very large and very small numbers.
Decimal.js: A library for performing accurate calculations with decimal numbers.

Special JS features or syntax:

None mentioned in the benchmark definition. The tests use standard JavaScript syntax for arithmetic operations.

Other considerations:

When choosing a library, consider factors such as:

Performance requirements
Precision needs
Support for various operations (e.g., addition, subtraction, multiplication, division)
Memory usage and potential impact on performance

Alternative approaches:

If none of these libraries suit your specific use case, you may want to explore other options, such as:

Fraction.js: A library for performing arithmetic with fractions.
Other custom implementations or specialized libraries (e.g., for financial calculations).

Keep in mind that the choice of library ultimately depends on your specific requirements and constraints.

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks on MeasureThat.net.

**What is being tested?**

The benchmark measures the performance of different libraries for working with numbers in JavaScript:

1. `Number` (native JavaScript type)
2. `Big.js`
3. `Bignumber.js`
4. `Decimal.js`

Specifically, the tests compare the performance of these libraries when performing arithmetic operations on floating-point numbers.

**Options compared:**

The benchmark compares four options:

* Native `Number` type
* `Big.js`
* `Bignumber.js`
* `Decimal.js`

Each library has its own strengths and weaknesses, which we'll discuss next.

**Pros and Cons of each approach:**

1. **Native `Number` type:**
	* Pros: Fastest performance, widely supported.
	* Cons: May exhibit behavior that's not predictable due to floating-point precision issues.
2. **Big.js:**
	* Pros: High-performance, accurate calculations, and good support for various operations (e.g., addition, subtraction, multiplication, division).
	* Cons: May require more memory usage compared to native `Number` type.
3. **Bignumber.js:**
	* Pros: Fast performance, high precision, and good support for various operations.
	* Cons: May be less suitable for very large numbers due to performance overhead.
4. **Decimal.js:**
	* Pros: High-performance, accurate calculations, and good support for various operations (e.g., addition, subtraction, multiplication, division).
	* Cons: May require more memory usage compared to native `Number` type.

**Libraries used in the tests:**

1. `Big.js`: A library for fast and precise arithmetic with large numbers.
2. `Bignumber.js`: A library for performing mathematical operations on very large and very small numbers.
3. `Decimal.js`: A library for performing accurate calculations with decimal numbers.

**Special JS features or syntax:**

None mentioned in the benchmark definition. The tests use standard JavaScript syntax for arithmetic operations.

**Other considerations:**

When choosing a library, consider factors such as:

* Performance requirements
* Precision needs
* Support for various operations (e.g., addition, subtraction, multiplication, division)
* Memory usage and potential impact on performance

**Alternative approaches:**

If none of these libraries suit your specific use case, you may want to explore other options, such as:

1. `Fraction.js`: A library for performing arithmetic with fractions.
2. Other custom implementations or specialized libraries (e.g., for financial calculations).

Keep in mind that the choice of library ultimately depends on your specific requirements and constraints.

Related benchmarks: