Benchmark: bignumber.js vs. big.js vs. decimal.js in 2024-05-03

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/bignumber.js/9.1.2/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.4.3/decimal.min.js"></script>

Tests:

Native
var a = 0.1; var b = 0.2; ((a + b) * b).toString();
Native + toFixed
var a = 0.1; var b = 0.2; ((a + b) * b).toFixed(9);
decimal.js
var a = new Decimal("0.1"); var b = new Decimal("0.2"); a.plus(b).times(b).toString();
big.js
var a = new Big("0.1"); var b = new Big("0.2"); a.plus(b).mul(b).toString();
bignumber.js
var a = new BigNumber("0.1"); var b = new BigNumber("0.2"); 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: 6 months ago)

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

Browser/OS: Chrome 125 on Windows

View result in a separate tab

Test name	Executions per second
Native	45233408.0 Ops/sec
Native + toFixed	5253445.0 Ops/sec
decimal.js	466908.6 Ops/sec
big.js	776975.4 Ops/sec
bignumber.js	403772.2 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested.

**What is being tested?**

The benchmark is testing the performance of different libraries for decimal arithmetic: `big.js`, `decimal.js`, and `bignumber.js`. The specific test cases are:

1. Basic decimal arithmetic with addition, multiplication, and exponentiation.
2. Rounding a result to a fixed number of digits using `toFixed()`.

**Options being compared**

The benchmark is comparing the performance of each library in two different modes:

* **Native**: Using built-in JavaScript features for decimal arithmetic (i.e., not relying on any external libraries).
* **Native + toFixed**: Using built-in JavaScript features with `toFixed()` rounding.

**Pros and Cons of each approach**

1. **Native**:
	* Pros: Fastest execution time, as it leverages the browser's optimized C++ engine.
	* Cons: May not be suitable for all applications that require precise decimal arithmetic, as it uses approximations.
2. **Native + toFixed**:
	* Pros: Provides more accurate results than `Native`, but may still suffer from some precision issues due to floating-point arithmetic limitations.
	* Cons: Slightly slower execution time compared to `Native`.

**Libraries and their purposes**

1. **Big.js**: A JavaScript library for arbitrary-precision arithmetic, designed to replace or supplement the built-in `Number` type. It's useful for applications that require precise decimal arithmetic, such as financial calculations.
2. **Decimal.js**: A JavaScript library for decimal arithmetic, providing a more precise alternative to built-in floating-point types. It's ideal for applications where accuracy is crucial, like scientific computing or high-stakes finance.
3. **Bignumber.js**: A JavaScript library for arbitrary-precision arithmetic, designed to work seamlessly with the `Number` type. It's useful for applications that require both precision and ease of use.

**Special features**

Some test cases use special features or syntax:

* `new Decimal("0.1")` in decimal.js: Creates a new Decimal instance with the specified value.
* `new Big("0.1")` in big.js: Creates a new Big instance with the specified value.
* `a.plus(b).times(b).toString()` in decimal.js and bignumber.js: Performs addition, multiplication, and exponentiation operations on Decimal instances.
* `(a + b) * b` in native tests: Demonstrates basic arithmetic operations using built-in JavaScript features.

**Other alternatives**

If you're looking for alternative libraries or approaches:

* **Float32.js**: A lightweight library for fast, platform-agnostic decimal arithmetic.
* **jsbn**: A small JavaScript library for arbitrary-precision arithmetic, designed to work with the `Number` type.
* **IEEE 754**: The standard for floating-point representation in computers, which can be used to implement precise decimal arithmetic.

These alternatives may offer different trade-offs between performance, accuracy, and complexity. It's essential to evaluate your specific use case and requirements before choosing a library or approach.

Related benchmarks:

bignumber.js vs. big.js vs. decimal.js in 2024-05-03 (version: 0)

- 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 Native + toFixed vs decimal.js vs big.js vs bignumber.js

Created: 7 months ago by: Guest

Jump to the latest result

Native

Native + toFixed

decimal.js

big.js

bignumber.js

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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