Benchmark: bignumber.js vs. big.js vs. decimal.js 20250401

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

Latest run results:

Run details: (Test run date: 25 days ago)

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

Browser/OS: Chrome 134 on Windows

View result in a separate tab

Test name	Executions per second
Native	119576208.0 Ops/sec
Native + toFixed	16621146.0 Ops/sec
decimal.js	1457221.4 Ops/sec
big.js	2704174.0 Ops/sec
bignumber.js	1340979.6 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 28 days ago):

LLMs can make mistakes. Check important info.

The benchmark JSON provided compares the performance of three popular JavaScript libraries for arbitrary-precision arithmetic or decimal calculations: `bignumber.js`, `big.js`, and `decimal.js`. These libraries are designed to handle calculations involving decimal numbers without the precision issues inherent to floating-point arithmetic in JavaScript.

### Benchmarked Libraries

1. **bignumber.js**: 
   - **Purpose**: This library allows for the representation and manipulation of large numbers with arbitrarily precise arithmetic, which is critical for applications requiring high precision in calculations, such as financial applications.
   - **Usage**: Instances of `BigNumber` are created to represent decimal values. The arithmetic is performed via methods like `plus` and `multipliedBy`.

2. **big.js**:
   - **Purpose**: Similar to bignumber.js, big.js is designed for arbitrary-precision arithmetic. It offers a simple API and aims to be lightweight while still providing accurate results for decimal numbers.
   - **Usage**: This library uses an instance of `Big` to handle decimal values and methods like `plus` and `mul`.

3. **decimal.js**:
   - **Purpose**: Decimal.js is another library for precise decimal arithmetic, focusing on providing an extensive set of mathematical operations and features beyond simple arithmetic.
   - **Usage**: Objects are created using `new Decimal(value)` to represent numbers, and calculations are performed using methods like `plus` and `times`.

### Benchmark Test Cases

The benchmark consists of five test cases, which can be categorized as follows:

1. **Native**: This uses JavaScript's built-in number handling. The expression `(a + b) * b` is calculated directly, leading to potential precision issues due to JavaScript's use of IEEE 754 floating-point representation.
   
2. **Native + toFixed**: This variation applies the `toFixed(9)` method to format the result to nine decimal places. While it may appear to handle precision better, it only affects the string representation of the number and does not change the floating-point arithmetic's inherent inaccuracies.

3. **decimal.js**: This case uses `decimal.js` to perform the same arithmetic. It helps evaluate how well this library handles the arithmetic operations compared to native JavaScript.

4. **big.js**: Similar to the decimal.js case but using the `big.js` library, this evaluates how this alternative library performs the same arithmetic operations.

5. **bignumber.js**: Finally, this case evaluates the performance of the `bignumber.js` library with identical logic to the prior cases.

### Performance Results

The benchmark results show the number of executions per second for each method, indicating which approach is fastest:

- **Native**: Achieved the highest performance at approximately **49,208,560 executions per second**, reflecting the efficiency of built-in arithmetic.
  
- **Native + toFixed**: Dropped significantly to around **8,202,975.5 executions per second**. The additional formatting overhead of `toFixed` contributes to the slower performance.

- **big.js**: Performed at **1,610,227.625** executions per second, demonstrating a relatively high efficiency for an external library.

- **bignumber.js**: Had a performance of **812,960.75 executions per second**, showing it is slower than big.js but still more efficient than decimal.js.

- **decimal.js**: The slowest performer at **811,578.0 executions per second**, indicating it might have more overhead or additional features that impact performance.

### Pros/Cons

- **Native Arithmetic**:
  - **Pros**: Fastest execution; no external dependencies; leverages built-in functionality.
  - **Cons**: Prone to precision issues with floating-point representation.

- **toFixed Method**:
  - **Pros**: Useful for formatting output.
  - **Cons**: Does not fix underlying precision issues; adds computational overhead.

- **big.js**:
  - **Pros**: Lightweight, performant for arbitrary precision.
  - **Cons**: Lacks some features available in other libraries.

- **bignumber.js**:
  - **Pros**: Richer feature set for arithmetic operations.
  - **Cons**: Slower than both native and big.js.

- **decimal.js**:
  - **Pros**: Extremely capable, with extensive mathematical functionality.
  - **Cons**: Performance hit compared to other libraries.

### Alternatives

Other popular libraries for arbitrary precision arithmetic include:

- **Fraction.js**: Focuses on representing fractions precisely.
- **math.js**: A comprehensive math library that supports a wide range of calculations with arbitrary precision.
- **decimal.js-light**: A lighter version of decimal.js for performance-focused tasks.

These libraries can be more suited based on specific use cases such as simple arithmetic, complex mathematical calculations, or when working with fractions. Each library may have distinct trade-offs in terms of performance, precision, and ease of use. Choosing the right option depends on the specific requirements of your application, such as the need for speed versus the importance of precision in calculations.

Related benchmarks:

bignumber.js vs. big.js vs. decimal.js 20250401 (version: 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

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

Created: 28 days 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 gpt-4o-mini, generated 28 days ago):