Benchmark: bignumber.js vs. big.js vs. decimal.js (without native)

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

Tests:

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
decimal.js
big.js
bignumber.js

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's dive into the world of JavaScript microbenchmarks and explore what's being tested.

**What is being tested?**

The provided JSON represents three individual test cases, each testing a different library for performing arithmetic operations with decimal numbers:

1. `decimal.js`
2. `big.js`
3. `bignumber.js`

Each test case involves creating instances of the respective libraries with initial values, performing basic arithmetic operations (addition and multiplication), and then converting the result to a string.

**Options compared**

The three libraries are being compared for their performance in executing these simple arithmetic operations:

1. `decimal.js`: A library specifically designed for decimal arithmetic.
2. `big.js`: A library that provides large integer arithmetic, but also supports decimal numbers.
3. `bignumber.js`: A library that provides arbitrary-precision arithmetic, including support for decimal numbers.

**Pros and Cons of each approach**

1. **decimal.js**: Designed specifically for decimal arithmetic, this library is optimized for precision and accuracy. However, it might be less efficient than other libraries due to its focus on precision over speed.
2. **big.js**: Provides large integer arithmetic, but also supports decimal numbers through a `Decimal` class. This approach offers flexibility, but might introduce additional overhead due to the need to handle both integers and decimals separately.
3. **bignumber.js**: Offers arbitrary-precision arithmetic, which is useful for very large numbers. However, this library may not be as efficient for small-scale decimal arithmetic compared to `decimal.js`.

**Library descriptions**

1. **decimal.js**: A JavaScript library specifically designed for decimal arithmetic. It provides a `Decimal` class that allows creating instances with initial values, performing arithmetic operations, and converting results to strings.
2. **big.js**: A JavaScript library that provides large integer arithmetic, as well as support for decimal numbers through the `Decimal` class. The `Big` constructor can be used to create instances with initial values.
3. **bignumber.js**: A JavaScript library that offers arbitrary-precision arithmetic, including support for decimal numbers. Instances are created using the `BigNumber` constructor.

**Special JavaScript features**

None of these libraries require special JavaScript features or syntax beyond standard ECMAScript. They all use a straightforward and familiar syntax to create instances and perform operations.

**Alternative approaches**

Other alternatives for performing decimal arithmetic in JavaScript include:

1. **Fraction.js**: A library that provides rational numbers and decimal arithmetic.
2. **numjs**: A lightweight library that provides numerical computations, including support for decimal numbers.

Keep in mind that these libraries may not offer the same level of precision or flexibility as `decimal.js`, but can still provide useful alternatives depending on the specific use case.

**Benchmarking context**

The provided benchmarking results indicate that:

* `big.js` performs relatively well, with a high executions per second (EPS) value.
* `bignumber.js` is slightly slower than `big.js`, despite its support for arbitrary-precision arithmetic.
* `decimal.js` has the lowest EPS value, indicating it may be less efficient due to its focus on precision over speed.

These results provide valuable insights into the performance characteristics of each library and can help developers make informed decisions about which one to use for their specific application.

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/109.0.0.0 Safari/537.36

Browser/OS: Chrome 109 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
decimal.js	1025055.8 Ops/sec
big.js	1920202.9 Ops/sec
bignumber.js	1102274.0 Ops/sec

Related benchmarks:

bignumber.js vs. big.js vs. decimal.js (without native) (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: decimal.js vs big.js vs bignumber.js

Created: one year ago by: Guest

Jump to the latest result

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 one month ago):