Benchmark: number-precision.js vs. big.js

HTML Preparation code:

<script src="https://cdn.jsdelivr.net/npm/number-precision@1.6.0/build/index.iife.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/big.js/6.0.3/big.min.js"></script>

Tests:

Native
var a = 0.1; var b = 0.2; ((a + b) * b).toString();
number-precision
var a = 0.1; var b = 0.2; const c = NP.plus(a, b) const d = NP.times(c, b) c.toString()
big.js
var a = new Big("0.1"); var b = new Big("0.2"); a.plus(b).mul(b).toString();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Native
number-precision
big.js

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Chrome 131 on Windows

View result in a separate tab

Test name	Executions per second
Native	98074424.0 Ops/sec
number-precision	656444.9 Ops/sec
big.js	3559847.0 Ops/sec

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

LLMs can make mistakes. Check important info.

I'll break down the benchmark and its options for you.

**Benchmark Overview**

The benchmark compares the performance of three different approaches to calculate the product of two decimal numbers:

1. **Native**: uses built-in JavaScript arithmetic
2. **number-precision**: uses the `NP.plus` and `NP.times` functions from the [Number Precision](https://github.com/feross/number-precision) library, which provides high-precision arithmetic for floating-point numbers.
3. **big.js**: uses the [Big.js](https://github.com/MikeMilesca/Big-JS) library, a popular implementation of arbitrary-precision arithmetic.

**Library and Syntax**

* **Number Precision Library**: A JavaScript library that extends the built-in `Number` type to support high-precision arithmetic. It provides functions like `NP.plus`, `NP.times`, etc. for performing arithmetic operations.
* **Big.js Library**: A lightweight JavaScript implementation of arbitrary-precision arithmetic, providing functions like `a.plus(b)`, `a.mul(b)`, etc.

**Options Compared**

The benchmark compares the performance of each approach:

1. **Native**: uses built-in JavaScript arithmetic (which may not provide high precision for large decimal numbers).
2. **number-precision**: uses the Number Precision library, which provides high-precision arithmetic but might be slower than native arithmetic.
3. **big.js**: uses the Big.js library, which provides arbitrary-precision arithmetic but might be slower than native arithmetic due to its overhead.

**Pros and Cons**

* **Native**: Fastest, but may not provide sufficient precision for large decimal numbers.
	+ Pros: Extremely fast
	+ Cons: May lose precision or cause overflow for large decimal numbers
* **number-precision**: Provides high precision, but might be slower than native arithmetic.
	+ Pros: High precision, can handle large decimal numbers
	+ Cons: Might be slower than native arithmetic
* **big.js**: Provides arbitrary-precision arithmetic, which may slow down performance.
	+ Pros: Can handle very large decimal numbers with high precision
	+ Cons: May be slower than native and number-precision arithmetic

**Other Considerations**

When choosing an approach, consider the trade-off between speed and precision:

* If you need to perform calculations with small to moderate-sized decimal numbers, **Native** might be sufficient.
* If you need to handle large decimal numbers or require high precision, either **number-precision** or **big.js** might be a better choice.

Keep in mind that these libraries are designed for specific use cases, and using the wrong approach can lead to performance issues or unexpected results. Always consider the requirements of your project when choosing an arithmetic library.

Related benchmarks:

number-precision.js vs. big.js (version: 0)

number-precision.js vs. big.js

Comparing performance of: Native vs number-precision vs big.js

Created: 2 years ago by: Guest

Jump to the latest result

Native

number-precision

big.js

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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