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-->

Tests:

Native
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);
decimal.js
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();
bignumber.js
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

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: 2 days ago)

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

Browser/OS: Chrome 149 on Windows

View result in a separate tab

Test name	Executions per second
Native	90396400.0 Ops/sec
Native + toFixed	10441943.0 Ops/sec
decimal.js	703008.4 Ops/sec
big.js	389455.6 Ops/sec
bignumber.js	647192.4 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

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: 3 years ago by: Guest

Jump to the latest result

Native

Native + toFixed

decimal.js

big.js

bignumber.js

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):