Benchmark: bignumber.js vs. big.js vs break_infinity.js

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://cdn.jsdelivr.net/npm/break_infinity.js@2"></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);
break_infinity.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
break_infinity.js
big.js
bignumber.js

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Let's break down the provided benchmark test cases and explain what is being tested, compared, and their pros and cons.

**Benchmarked Libraries and Features:**

1. **Native:** This refers to JavaScript's built-in number type, which is not explicitly represented as a decimal or fraction in most browsers.
2. **Big.js:** A library for precise arithmetic operations on large numbers. It provides a `Decimal` class that can handle exact calculations without floating-point precision issues.
3. **bignumber.js:** Another library for large number arithmetic, providing a `BigNumber` class with similar features to Big.js.
4. **break_infinity.js:** A library that allows for arbitrary-precision arithmetic, inspired by the Python "Arbitrary Precision Arithmetic" module. It provides a `Fraction` class and supports various operations.

**Comparison:**

The benchmark tests the performance of each library in performing arithmetic operations on large numbers. Specifically:

* Native vs. Native + toFixed: Tests the performance of JavaScript's built-in number type with and without using the `toFixed()` method, which can introduce precision issues.
* Big.js vs. bignumber.js: Compares the performance of two libraries that provide precise arithmetic operations for large numbers.
* break_infinity.js: Tests the performance of a library that supports arbitrary-precision arithmetic.

**Pros and Cons:**

1. **Native + toFixed:**
	* Pros: Minimal overhead, widely supported.
	* Cons: Can introduce precision issues due to `toFixed()` rounding.
2. **Big.js and bignumber.js:**
	* Pros: Precise arithmetic operations, easy to use.
	* Cons: Add additional library dependencies, might be slower than native or another library.
3. **break_infinity.js:**
	* Pros: Arbitrary-precision arithmetic support, flexible operations.
	* Cons: More complex API, might require more resources than other libraries.

**Other Considerations:**

1. **Performance:** The benchmark tests the performance of each library, which is essential for applications that require fast calculations on large numbers.
2. **Precision:** Libraries like Big.js and bignumber.js ensure precise arithmetic operations, while Native or Native + toFixed might introduce precision issues.
3. **Library Complexity:** break_infinity.js has a more complex API than other libraries, but provides arbitrary-precision arithmetic support.

**Alternatives:**

1. **Fraction.js:** Another library for large number arithmetic, similar to Big.js and bignumber.js.
2. **Decimal.js:** A library that provides precise arithmetic operations on decimal numbers.
3. **Mathjs:** A math library that includes a `Dec` class for precise arithmetic operations.

In conclusion, the benchmark tests the performance of different libraries for large number arithmetic, considering their precision and complexity. The choice of library depends on the specific requirements of the application, such as performance, precision, and ease of use.

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36

Browser/OS: Chrome 126 on Linux

View result in a separate tab

Test name	Executions per second
Native	59363932.0 Ops/sec
Native + toFixed	6465296.5 Ops/sec
break_infinity.js	1694861.6 Ops/sec
big.js	1062537.9 Ops/sec
bignumber.js	611844.9 Ops/sec

Related benchmarks:

bignumber.js vs. big.js vs break_infinity.js (version: 0)

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

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

Created: one year ago by: Guest

Jump to the latest result

Native

Native + toFixed

break_infinity.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 26 days ago):