Benchmark: integer vs decimal

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/decimal.js/10.2.1/decimal.min.js"></script>

Tests:

Integer
var a = 100000; var b = 213231423; (a/b).toString();
decimal
var a = 0.0001; var b = 213.231423; (a/b).toString();

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Integer
decimal

Fastest: N/A

Slowest: N/A

Latest run results:

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

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

Browser/OS: Firefox 135 on Windows

View result in a separate tab

Test name	Executions per second
Integer	2778611200.0 Ops/sec
decimal	2786341632.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):

LLMs can make mistakes. Check important info.

The benchmark defined in the provided JSON compares the performance of handling numerical calculations using basic integer arithmetic versus decimal arithmetic through the use of various libraries. This benchmark aims to illustrate the differences in execution speed between these two numerical types when introduced into JavaScript.

### Options Compared

1. **Integer Arithmetic**:
   - **Test Case**: `var a = 100000; var b = 213231423; (a/b).toString();`
   - **Description**: This test performs a division operation using two integers. The result of dividing `a` by `b` is then converted to a string.
   - This approach represents a straightforward division operation without any additional libraries, relying only on JavaScript's native number capabilities.

2. **Decimal Arithmetic**:
   - **Test Case**: `var a = 0.0001; var b = 213.231423; (a/b).toString();`
   - **Description**: In this case, the test involves division between a decimal (floating-point) number and a regular number. Again, the result is converted to a string.
   - This test demonstrates how JavaScript manages decimal values, which can sometimes lead to precision issues due to the inherent characteristics of floating-point arithmetic.

### Libraries Used
The benchmark reference mentions three libraries from the same author, Mike Mcl:
- **bignumber.js** (version 9.0.0)
- **big.js** (version 5.2.2)
- **decimal.js** (version 10.2.0)

**Purpose of the Libraries**:
These libraries are designed to handle arbitrary-precision decimal arithmetic. They help address issues with standard JavaScript floating-point calculations, which can result in imprecise results for very small or very large numbers due to the limitations of the number representation in JavaScript. Specifically:
- **BigNumber.js**: Handles big numbers and provides methods for accurate arithmetic operations.
- **Big.js**: A smaller footprint library for big number arithmetic with a simplified API.
- **Decimal.js**: Provides a comprehensive and flexible solution for decimal computations in arbitrary precision.

### Performance Results
From the benchmark results:
- **Decimal Test** had an execution rate of approximately **2,786,341,632 executions per second**.
- **Integer Test** had an execution rate of approximately **2,778,611,200 executions per second**.

This shows that both approaches are very close in execution speed, albeit the decimal calculations are slightly faster in this instance.

### Pros and Cons

1. **Integer Arithmetic**:
   - **Pros**: 
     - Generally faster due to the simplicity of operations.
     - No additional libraries are needed; utilizes built-in JavaScript capabilities.
   - **Cons**:
     - Limited to whole numbers which can lead to loss of precision when dealing with decimal values or fractions.

2. **Decimal Arithmetic**:
   - **Pros**: 
     - Better suited for financial calculations or cases where precision is important (e.g., currency).
     - Libraries can manage very small and very large numbers without losing accuracy.
   - **Cons**:
     - May introduce additional overhead and complexity, depending on the library used.
     - Not as fast as native integer calculations in general.

### Other Considerations

- **Precision**: In scenarios where precision is critical (like financial calculations), using libraries such as `decimal.js` is recommended even if there may be a slight performance penalty.
- **Platform Compatibility**: Executing different libraries may vary in performance across different browsers and devices, necessitating benchmarking in the target environment.
- **Alternatives**: Other alternatives for handling decimal arithmetic or high-precision calculations could include using native `BigInt` for very large integers or exploring libraries like `math.js`, which combines general numerical operations with special functions.

In conclusion, selecting between integer and decimal arithmetic should be based on the specific needs of the application—balancing performance against the need for precision, especially in critical applications like financial systems.

Related benchmarks:

integer vs decimal (version: 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

Comparing performance of: Integer vs decimal

Created: 2 months ago by: Registered User

Jump to the latest result

Integer

decimal

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 2 months ago):