Benchmark: bignumber.js vs. big.js vs. decimal.js vs. Fraction.js (v2, with script links corrected fork without "toString")

bignumber.js vs. big.js vs. decimal.js vs. Fraction.js (v2, with script links corrected fork without "toString") (version: 0) Benchmark.js

- https://github.com/iriscouch/bigdecimal.js/tree/v0.6.1 - 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 - https://github.com/infusion/Fraction.js/tree/v4.0.12

Comparing performance of: `Native vs Native + toFixed vs decimal.js vs big.js vs bignumber.js vs bigdecimal.js vs Fraction.js`

Created: 3 years ago by: Guest

Go to the latest result

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/bigdecimal@0.6.1/lib/bigdecimal.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/bignumber.js@9.0.1/bignumber.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/big.js@6.0.3/big.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/decimal.js@10.2.1/decimal.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/fraction.js@4.0.13/fraction.min.js"></script>

Tests:

Native
var a = 0.1; var b = 0.2; ((a + b) * b);
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);
big.js
var a = new Big("0.1"); var b = new Big("0.2"); a.plus(b).mul(b);
bignumber.js
var a = new BigNumber("0.1"); var b = new BigNumber("0.2"); a.plus(b).multipliedBy(b);
bigdecimal.js
var a = new BigDecimal("0.1"); var b = new BigDecimal("0.2"); a.add(b).multiply(b);
Fraction.js
var a = new Fraction("0.1"); var b = new Fraction("0.2"); a.add(b).mul(b);

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
bigdecimal.js
Fraction.js

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 132 on Android

View result in a separate tab

Native

122.3M/s

Native + toFixed

6.3M/s

big.js

2.5M/s

Fraction.js

2.4M/s

decimal.js

1.2M/s

bignumber.js

1.1M/s

bigdecimal.js

195K/s

View exact numbers

Test name	Executions per second
✓ Native	122,349,816 Ops/sec
Native + toFixed	6,274,216 Ops/sec
big.js	2,501,694 Ops/sec
Fraction.js	2,412,598 Ops/sec
decimal.js	1,182,777 Ops/sec
bignumber.js	1,127,887 Ops/sec
bigdecimal.js	194,744 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the provided benchmark information into understandable sections.

**Overview**

The provided JSON represents a set of JavaScript microbenchmarks comparing different libraries for precise decimal arithmetic: `bignumber.js`, `big.js`, `decimal.js`, and `Fraction.js`. The benchmarks are designed to test various performance aspects, including native execution, method usage (e.g., `toFixed`), and library-specific features.

**Options Compared**

The following options are compared:

1. **Native**: Native arithmetic using built-in JavaScript functionality.
2. **Native + toFixed**: Native arithmetic with the addition of the `toFixed` method for precision control.
3. **decimal.js**: Using the `Decimal.js` library, which provides a robust decimal arithmetic system.
4. **big.js**: Using the `Big.js` library, which offers arbitrary-precision integer and floating-point arithmetic.
5. **bignumber.js**: Using the `Bignumber.js` library, which is similar to `Big.js` but with some differences in implementation and feature set.
6. **Fraction.js**: Using the `Fraction.js` library, which provides a decimal arithmetic system for fractions.

**Pros and Cons**

Here's a brief overview of the pros and cons for each option:

1. **Native**:
	* Pros: Native performance, lightweight, no additional dependencies required.
	* Cons: Limited precision control, may not be suitable for all use cases (e.g., financial calculations).
2. **Native + toFixed**:
	* Pros: Provides a balance between native performance and precision control through the `toFixed` method.
	* Cons: Requires the addition of the `toFixed` method, which may introduce overhead.
3. **decimal.js**:
	* Pros: Robust decimal arithmetic system with high precision control, supports various methods (e.g., `add`, `multiply`).
	* Cons: Additional dependency required, may be heavier than native or other libraries.
4. **big.js** and **bignumber.js**:
	* Both offer arbitrary-precision integer and floating-point arithmetic, but differ in implementation and feature set.
	* **big.js**: More lightweight and flexible, with a focus on basic operations (e.g., addition, multiplication).
	* **bignumber.js**: Similar to `Big.js` but with additional features, such as support for more advanced mathematical functions (e.g., exponentiation).
5. **Fraction.js**:
	* Pros: Provides a decimal arithmetic system specifically designed for fractions, which can be useful in certain applications.
	* Cons: May not be suitable for general-purpose decimal arithmetic, and has limited features compared to other libraries.

**Conclusion**

The choice of library ultimately depends on the specific requirements of your application. If you need precise decimal arithmetic with high precision control, `decimal.js` or `Fraction.js` might be a good choice. For more lightweight options with basic operations, `big.js` or `bignumber.js` could be suitable. Native arithmetic with `toFixed` can provide a balance between performance and precision control.