Benchmark: bignumber library benchmark

bignumber library benchmark (version: 0)

- 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: 5 years ago by: Registered User

Jump to the latest result

HTML Preparation code:

<script src="https://rawgit.com/iriscouch/bigdecimal.js/v0.6.1/lib/bigdecimal.js"></script>
<script src="https://rawgit.com/MikeMcl/bignumber.js/v9.0.0/bignumber.min.js"></script>
<script src="https://rawgit.com/MikeMcl/big.js/v5.2.2/big.min.js"></script>
<script src="https://rawgit.com/MikeMcl/decimal.js/v10.2.0/decimal.min.js"></script>
<script src="https://rawgit.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();
bigdecimal.js
var a = new BigDecimal("0.1"); var b = new BigDecimal("0.2"); a.add(b).multiply(b).toString();
Fraction.js
var a = new Fraction("0.1"); var b = new Fraction("0.2"); a.add(b).mul(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
bigdecimal.js
Fraction.js

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0

Browser/OS: Firefox 128 on Linux

View result in a separate tab

Test name	Executions per second
Native	2242623744.0 Ops/sec
Native + toFixed	22226310.0 Ops/sec
decimal.js	1034420.1 Ops/sec
big.js	1379889.1 Ops/sec
bignumber.js	908802.2 Ops/sec
bigdecimal.js	60953.9 Ops/sec
Fraction.js	1494584.5 Ops/sec

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

LLMs can make mistakes. Check important info.

Measuring the performance of arithmetic operations in different libraries can be helpful for developers to choose the most suitable library for their use case.

In this benchmark, six different libraries are compared:

1. **Native**: This is the built-in JavaScript implementation for arithmetic operations. It doesn't rely on any external library.
2. **Native + toFixed**: This option uses the native JavaScript implementation but with `toFixed()` method, which adds an additional overhead due to string conversion.
3. **decimal.js**: This library provides a decimal arithmetic system that can be used for precise calculations.
4. **big.js**: Similar to decimal.js, big.js is another decimal arithmetic library.
5. **bignumber.js**: This library allows for exact integer arithmetic and is particularly useful for financial or monetary calculations.
6. **Fraction.js**: This library provides a way to represent rational numbers (fractions) exactly.

Here are some pros and cons of each approach:

*   **Native**:
    *   Pros: Fast execution, no additional overhead.
    *   Cons: May not provide precise results due to floating-point arithmetic limitations.
*   **Native + toFixed**:
    *   Pros: Precise results can be achieved by using the `toFixed()` method.
    *   Cons: Adds an extra overhead due to string conversion.
*   **decimal.js**, **big.js**, and **Fraction.js**:
    *   Pros: Provides precise arithmetic operations, which is suitable for financial or monetary calculations.
    *   Cons: May be slower than native arithmetic operations due to the overhead of additional libraries.
*   **bignumber.js**:
    *   Pros: Exact integer arithmetic, particularly useful for financial or monetary calculations.
    *   Cons: May not be as widely supported as other libraries.

In general, if you need precise results and don't care about speed, using a library like decimal.js, big.js, or Fraction.js might be the best choice. However, if speed is crucial and you're working with financial or monetary calculations where precision is less critical, native arithmetic operations (or Native + toFixed) might be sufficient.

Other alternatives to these libraries include:

*   **BigDecimal**: A Java library for precise arithmetic operations.
*   **GMP.js**: A JavaScript implementation of the GNU Multiple Precision Arithmetic Library (GMP), which provides exact arithmetic operations.
*   **MathJS**: A library that allows for symbolic and numerical mathematics, including precise arithmetic operations.

Keep in mind that each library has its strengths and weaknesses, and the choice ultimately depends on your specific use case and requirements.

Related benchmarks: