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

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.2/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.2/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

var a = 0.110000000000000000001;
var b = 0.210000000000000000001;
((a + b) * b).toString();

 
var a = 0.110000000000000000001;var b = 0.210000000000000000001;((a + b) * b).toString();​

Native + toFixed
var a = 0.110000000000000000001; var b = 0.210000000000000000001; ((a + b) * b).toFixed(9);
var a = 0.110000000000000000001;
var b = 0.210000000000000000001;
((a + b) * b).toFixed(9);
decimal.js
var a = new Decimal("0.110000000000000000001"); var b = new Decimal("0.210000000000000000001"); a.plus(b).times(b).toString();
var a = new Decimal("0.110000000000000000001");
var b = new Decimal("0.210000000000000000001");
a.plus(b).times(b).toString();

big.js

var a = new Big("0.110000000000000000001");
var b = new Big("0.210000000000000000001");
a.plus(b).mul(b).toString();

 
var a = new Big("0.110000000000000000001");var b = new Big("0.210000000000000000001");a.plus(b).mul(b).toString();​

bignumber.js
var a = new BigNumber("0.110000000000000000001"); var b = new BigNumber("0.210000000000000000001"); a.plus(b).multipliedBy(b).toString();
var a = new BigNumber("0.110000000000000000001");
var b = new BigNumber("0.210000000000000000001");
a.plus(b).multipliedBy(b).toString();

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
Native + toFixed
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 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36

Browser/OS: Chrome 114 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Native	96244864.0 Ops/sec
Native + toFixed	6800097.5 Ops/sec
decimal.js	431013.8 Ops/sec
big.js	183435.1 Ops/sec
bignumber.js	426145.9 Ops/sec

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

Let's dive into the world of JavaScript microbenchmarks.

Overview

The provided benchmark is designed to compare the performance of different libraries for working with large numbers: bignumber.js, big.js, and decimal.js. The benchmark consists of multiple test cases that aim to measure the speed of various operations, such as addition, multiplication, and string conversion.

Libraries and their purpose

decimal.js: A library for precise decimal arithmetic. It provides a Decimal class that allows you to work with numbers with high precision (up to 29 digits).
big.js: A library for large integers and decimals. It provides a Big class that allows you to work with arbitrary-precision integers.
bignumber.js: A library for big number arithmetic. It provides a BigNumber class that allows you to work with arbitrarily large numbers.

Options compared

The benchmark compares the performance of each library when performing different operations:

Native: Uses JavaScript's built-in types (e.g., number) instead of a dedicated library.
Native + toFixed: Uses JavaScript's built-in types and adds the toFixed() method for string conversion.
Each library-specific test case uses the respective library's class (e.g., Decimal, Big, BigNumber) for arithmetic operations.

Pros and Cons

bignumber.js: Pros:
- Well-maintained and widely adopted.
- Supports advanced features like exponentiation and modular arithmetic. Cons:
- Can be slower than native JavaScript for simple arithmetic operations.
big.js: Pros:
- Fast and efficient for large integers. Cons:
- Limited support for decimal arithmetic compared to decimal.js.
decimal.js: Pros:
- Suitable for applications that require high precision (e.g., financial calculations). Cons:
- May be slower than native JavaScript or other libraries for simple arithmetic operations.

Other considerations

Performance overhead: Each library introduces a performance overhead due to the additional functionality and checks required to ensure accurate results.
Code complexity: The choice of library may impact code complexity, as some libraries require more complex setup or usage patterns than others.
Platform compatibility: Different browsers and environments may exhibit varying levels of support for each library.

Alternatives

If you're looking for alternatives, consider:

Fraction.js: A library for rational numbers (fractions) that might be suitable for specific use cases.
jsbn: A small, lightweight library for arbitrary-precision integers.
BigInt: JavaScript's built-in support for arbitrary-precision integers in ECMAScript 2020 and later versions.

Keep in mind that the choice of library depends on your specific requirements, performance constraints, and code complexity considerations.

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks.

**Overview**

The provided benchmark is designed to compare the performance of different libraries for working with large numbers: `bignumber.js`, `big.js`, and `decimal.js`. The benchmark consists of multiple test cases that aim to measure the speed of various operations, such as addition, multiplication, and string conversion.

**Libraries and their purpose**

1. **`decimal.js`**: A library for precise decimal arithmetic. It provides a `Decimal` class that allows you to work with numbers with high precision (up to 29 digits).
2. **`big.js`**: A library for large integers and decimals. It provides a `Big` class that allows you to work with arbitrary-precision integers.
3. **`bignumber.js`**: A library for big number arithmetic. It provides a `BigNumber` class that allows you to work with arbitrarily large numbers.

**Options compared**

The benchmark compares the performance of each library when performing different operations:

* `Native`: Uses JavaScript's built-in types (e.g., `number`) instead of a dedicated library.
* `Native + toFixed`: Uses JavaScript's built-in types and adds the `toFixed()` method for string conversion.
* Each library-specific test case uses the respective library's class (e.g., `Decimal`, `Big`, `BigNumber`) for arithmetic operations.

**Pros and Cons**

1. **`bignumber.js`**: Pros:
	* Well-maintained and widely adopted.
	* Supports advanced features like exponentiation and modular arithmetic.
Cons:
	* Can be slower than native JavaScript for simple arithmetic operations.
2. **`big.js`**: Pros:
	* Fast and efficient for large integers.
Cons:
	* Limited support for decimal arithmetic compared to `decimal.js`.
3. **`decimal.js`**: Pros:
	* Suitable for applications that require high precision (e.g., financial calculations).
Cons:
	* May be slower than native JavaScript or other libraries for simple arithmetic operations.

**Other considerations**

1. **Performance overhead**: Each library introduces a performance overhead due to the additional functionality and checks required to ensure accurate results.
2. **Code complexity**: The choice of library may impact code complexity, as some libraries require more complex setup or usage patterns than others.
3. **Platform compatibility**: Different browsers and environments may exhibit varying levels of support for each library.

**Alternatives**

If you're looking for alternatives, consider:

1. **`Fraction.js`**: A library for rational numbers (fractions) that might be suitable for specific use cases.
2. **`jsbn`**: A small, lightweight library for arbitrary-precision integers.
3. **`BigInt`**: JavaScript's built-in support for arbitrary-precision integers in ECMAScript 2020 and later versions.

Keep in mind that the choice of library depends on your specific requirements, performance constraints, and code complexity considerations.

Related benchmarks:

bignumber.js vs. big.js vs. decimal.js big num (version: 0)

- https://github.com/MikeMcl/bignumber.js/tree/v9.0.2 - 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

Created: 2 years ago by: Guest

Jump to the latest result