Benchmark: Add using Decimal.js vs native vs Number() vs parseFloat()

HTML Preparation code:

<script src='https://cdn.jsdelivr.net/npm/decimal.js-light@2.5.0/decimal.min.js'></script>

Script Preparation code:

var x = 5.236;

Tests:

Multiply using Decimal.js
for (var i = 0; i < 1000; i++) { Decimal('0.00253452345').plus(Decimal('0.042234')) }
Multiply using native numbers
for (var i = 0; i < 1000; i++) { 0.00253452345 + 0.042234 }
Multiply using numerical strings parsed with Number
for (var i = 0; i < 1000; i++) { Number("0.00253452345") + Number("0.042234") }
Multiply using numerical strings parsed with parseFloat
for (var i = 0; i < 1000; i++) { parseFloat("0.00253452345") + parseFloat("0.042234") }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Multiply using Decimal.js
Multiply using native numbers
Multiply using numerical strings parsed with Number
Multiply using numerical strings parsed with parseFloat

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36

Browser/OS: Chrome 137 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
Multiply using Decimal.js	2869.3 Ops/sec
Multiply using native numbers	3840663.5 Ops/sec
Multiply using numerical strings parsed with Number	734994.4 Ops/sec
Multiply using numerical strings parsed with parseFloat	33677.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 provided benchmark and explain what's being tested, compared, and their pros and cons.

**What's being tested?**

MeasureThat.net is running JavaScript microbenchmarks to compare the performance of different approaches for performing arithmetic operations on decimal numbers. Specifically, it's testing four scenarios:

1. **Decimal.js**: A library for precise floating-point arithmetic.
2. **Native numbers**: Using built-in JavaScript number types (Number()).
3. **Numerical strings parsed with Number**: Converting string representations to numbers using the Number() function.
4. **Numerical strings parsed with parseFloat**: Converting string representations to numbers using the parseFloat() function.

**Options compared**

The benchmark compares the performance of each approach in three test cases:

* "Multiply using Decimal.js"
* "Multiply using native numbers"
* "Multiply using numerical strings parsed with Number"
* "Multiply using numerical strings parsed with parseFloat"

These tests are similar, but use slightly different approaches to convert string representations to numbers.

**Pros and cons**

Here's a brief summary of the pros and cons for each approach:

1. **Decimal.js**
	* Pros:
		+ Provides precise arithmetic operations.
		+ Reduces rounding errors.
	* Cons:
		+ Adds an extra library dependency.
		+ Might introduce performance overhead due to parsing.
2. **Native numbers**
	* Pros:
		+ Fast and efficient, as it leverages built-in JavaScript functionality.
		+ No additional dependencies or overhead.
	* Cons:
		+ Prone to rounding errors, especially for small decimal values.
3. **Numerical strings parsed with Number()**
	* Pros:
		+ Simple and easy to use.
	* Cons:
		+ Can lead to rounding errors, as the Number() function may not always convert correctly.
4. **Numerical strings parsed with parseFloat()**
	* Pros:
		+ Similar to using Number(), but might be more forgiving due to its tolerance for error.
	* Cons:
		+ May still lead to unexpected results if the string is malformed or represents a non-numeric value.

**Library: Decimal.js**

Decimal.js is a library that provides precise floating-point arithmetic, allowing developers to perform calculations with decimal numbers without worrying about rounding errors. It's useful in applications where accuracy is crucial, such as financial transactions, scientific simulations, or data analysis.

**Other considerations**

When choosing an approach for decimal arithmetic, consider the following factors:

* **Precision requirements**: If you need high precision, Decimal.js might be the best choice.
* **Performance**: For fast and efficient calculations, using native numbers (Number()) is usually a good option.
* **Error tolerance**: If you're working with user-provided input or data that may contain errors, consider using parseFloat() to reduce the impact of rounding errors.

**Alternatives**

Other alternatives for decimal arithmetic in JavaScript include:

1. **BigInt**: Introduced in ECMAScript 2020, BigInt provides support for arbitrary-precision integers and decimal numbers.
2. **WebAssembly (WASM)**: Some libraries, like Decimal.js, can be compiled to WASM, allowing for performance-critical applications on the web.

Keep in mind that these alternatives might have different requirements, dependencies, or trade-offs compared to using a dedicated library like Decimal.js or relying on native numbers and parseFloat().

Related benchmarks:

Add using Decimal.js vs native vs Number() vs parseFloat() (version: 0)

Comparing performance of: Multiply using Decimal.js vs Multiply using native numbers vs Multiply using numerical strings parsed with Number vs Multiply using numerical strings parsed with parseFloat

Created: 5 years ago by: Guest

Jump to the latest result

Multiply using Decimal.js

Multiply using native numbers

Multiply using numerical strings parsed with Number

Multiply using numerical strings parsed with parseFloat

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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