Benchmark: bignumber.js vs. big.js vs. decimal.js@10.4.3 (I)

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

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

LLMs can make mistakes. Check important info.

Let's dive into the details of this benchmark.

**What is being tested?**

The provided JSON represents a benchmark that compares the performance of three different libraries: `big.js`, `decimal.js`, and `bignumber.js`. Each library provides arithmetic operations for dealing with large numbers, which are essential in various applications such as finance, science, and engineering.

**Options compared:**

The benchmark compares the performance of each library when performing two types of arithmetic operations:

1. **Native**: This option tests the native JavaScript implementation (i.e., without using any additional libraries).
2. **Native + toFixed**: This option adds an extra layer of complexity by applying the `toFixed` method, which can introduce overhead due to string conversion.
3. **Library-specific implementations**:
	* `decimal.js`: This library provides a `Decimal` class for precise arithmetic operations.
	* `big.js`: This library provides a `Big` class for arbitrary-precision arithmetic operations.
	* `bignumber.js`: This library provides a `BigNumber` class for decimal arithmetic operations.

**Pros and Cons:**

1. **Native**:
	* Pros: No additional overhead, familiar syntax.
	* Cons: Limited precision, potential rounding errors.
2. **Native + toFixed**:
	* Pros: Adds precision, but may introduce string conversion overhead.
	* Cons: Can be slower due to the added complexity.
3. **Library-specific implementations**:
	* `decimal.js`:
		+ Pros: High precision, robust implementation.
		+ Cons: May have higher overhead than native or big.js.
	* `big.js`:
		+ Pros: Efficient implementation, suitable for most use cases.
		+ Cons: Limited decimal arithmetic capabilities compared to bignumber.js.
	* `bignumber.js`:
		+ Pros: Decent performance, suitable for decimal arithmetic operations.
		+ Cons: Not as efficient as big.js for arbitrary-precision arithmetic.

**Library descriptions and purposes:**

1. **decimal.js**: Provides a robust implementation of decimal arithmetic operations with high precision. Its purpose is to ensure accurate calculations in financial and scientific applications.
2. **big.js**: Offers an efficient implementation of arbitrary-precision arithmetic operations, making it suitable for large-scale numerical computations.
3. **bignumber.js**: Designed specifically for decimal arithmetic operations, providing a balance between performance and accuracy.

**Special JS features or syntax:**

The benchmark uses special JavaScript features like `toFixed` (which converts numbers to strings) and the `BigNumber`/`Decimal` classes provided by each library. These features are not specific to the libraries themselves but rather part of the broader JavaScript ecosystem.

**Alternatives:**

Other alternatives for dealing with large numbers in JavaScript include:

1. **Internationalization API**: Provides support for internationalized arithmetic operations, including decimal separators and rounding modes.
2. **Arbitrary-precision arithmetic libraries**: Such as `arbitrary-precision.js` or `mathjs`, which provide more extensive arithmetic capabilities than the libraries used in this benchmark.

In summary, the provided benchmark compares the performance of three different libraries for dealing with large numbers in JavaScript, highlighting their pros and cons, library-specific implementations, and potential use cases.

Latest run results:

Run details: (Test run date: 5 months ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36

Browser/OS: Chrome 125 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Native	132380776.0 Ops/sec
Native + toFixed	17051034.0 Ops/sec
decimal.js	1659304.4 Ops/sec
big.js	2974698.5 Ops/sec
bignumber.js	1591284.9 Ops/sec

Related benchmarks:

bignumber.js vs. big.js vs. [email protected] (I) (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: 5 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 one month ago):