Benchmark: bignumber.js vs. big.js apr

HTML Preparation code:

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

Tests:

Native
const val = 1 / ( 500724 * ( 1000002/3000000*0.93 ) * 100 ).toString(); console.log(val);
Native + toFixed
const val = 1 / ( 500724 * ( 1000002/3000000*0.93 ) * 100 ).toFixed(2); console.log(val);
big.js
const one = new Big(1); const totalStake = new Big(500724); const block = new Big(1000002).div(30000000).mul(0.93); const val = one.div((totalStake).mul(block).mul(31536000)).mul(100).toFixed(2); console.log(val);
bignumber.js
const one = new BigNumber(1); const totalStake = new BigNumber(500724); const block = new BigNumber(1000002).div(30000000).times(0.93); const val = one.div((totalStake).times(block).times(31536000)).times(100).toFormat(2); console.log(val);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native
Native + toFixed
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 dive into the world of JavaScript benchmarks.

**Overview**

MeasureThat.net is a website that allows users to create and run JavaScript microbenchmarks. The provided JSON represents a benchmark comparison between three libraries: bignumber.js, big.js, and decimal.js. The test cases measure the performance of various arithmetic operations with large numbers.

**Benchmark Definition**

The benchmark definition specifies the script preparation code, which includes the loading of the required libraries (bignumber.js, big.js) and their versions. The HTML preparation code is also provided, which loads the bignumber.js library version 9.0.1 and big.js library version 6.0.3.

**Options Compared**

The benchmark compares four options:

1. **Native**: This option tests the native JavaScript arithmetic operations without using any libraries.
2. **Native + toFixed**: This option tests the native JavaScript arithmetic operations with the addition of the `toFixed()` method, which formats a number as a string with a specified number of decimals.
3. **big.js**: This option uses the big.js library to perform large-number arithmetic operations.
4. **bignumber.js**: This option uses the bignumber.js library to perform large-number arithmetic operations.

**Pros and Cons**

Here's a brief overview of each option:

1. **Native + toFixed**:
	* Pros: Native performance, easy to implement, and widely supported.
	* Cons: May be slower than using libraries for very large numbers or complex calculations.
2. **big.js**: This library provides a simple and efficient way to perform large-number arithmetic operations. However, it may not be suitable for very large numbers (up to 10^100) due to performance limitations.
3. **bignumber.js**:
	* Pros: Provides support for very large numbers (up to 10^100), decimal arithmetic, and more advanced features like rounding and formatting.
	* Cons: May have performance overhead compared to native or big.js.

**Library Descriptions**

1. **big.js**: The Big.js library is designed for fast, safe, and simple arithmetic with integers and floating-point numbers, using arbitrary-precision arithmetic. It provides a simple API and supports various operations like addition, subtraction, multiplication, division, etc.
2. **bignumber.js**: The Bignumber.js library is a popular alternative to big.js, providing support for very large numbers (up to 10^100) and decimal arithmetic. It also offers advanced features like rounding, formatting, and error handling.

**Special JS Features**

The test cases use the following special JavaScript features:

* `toString()` and `toFixed(2)` methods are used in the native options to format numbers as strings with a specified number of decimals.
* The `div` and `mul` methods are used in big.js and bignumber.js to perform division and multiplication operations, respectively.

**Other Considerations**

When choosing between these libraries or using native arithmetic operations, consider the following factors:

* Performance: Native operations may be faster for small numbers, while libraries like big.js and bignumber.js offer performance benefits for large numbers.
* Complexity: If you need to perform complex calculations or work with very large numbers, a library like bignumber.js might be more suitable.
* Support: Big.js is widely supported, but bignumber.js has a larger community and more features.

**Alternatives**

Other alternatives to big.js and bignumber.js include:

* Decimal.js: A library for decimal arithmetic and rounding.
* JS-Bigint: A lightweight library for arbitrary-precision arithmetic with integers and floating-point numbers.
* Mathjs: A library for mathematical operations, including support for large numbers.

Keep in mind that the choice of library or native arithmetic operation depends on your specific use case and requirements.

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:107.0) Gecko/20100101 Firefox/107.0

Browser/OS: Firefox 107 on Windows

View result in a separate tab

Test name	Executions per second
Native	46998.3 Ops/sec
Native + toFixed	49406.7 Ops/sec
big.js	18554.0 Ops/sec
bignumber.js	22980.8 Ops/sec

Related benchmarks:

bignumber.js vs. big.js apr (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 big.js vs bignumber.js

Created: 2 years ago by: Guest

Jump to the latest result

Native

Native + toFixed

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