Benchmark: JavaScript all number type benchmark v2

Script Preparation code:

var bigInt32 = 2n ** 24n;
var bigInt64 = 2n ** 40n;
var bigInt128 = 2n ** 80n;
var bigIntNum = 2n ** 10n;

var int32 = 2 ** 10;
var int64 = 2 ** 40;
var float = Math.fround(2 ** 20);
var double = 2 ** 80;
var intNum = 2 ** 10;

const imul = Math.imul
const fround = Math.fround

Tests:

BigInt (32)
let a = bigInt32; let b = bigIntNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b > a; c_mod = a % b < a; c_mul = a * b === a; c_add = a + b !== a;
BigInt (64)
let a = bigInt64; let b = bigIntNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b > a; c_mod = a % b < a; c_mul = a * b === a; c_add = a + b !== a;
BigInt (128)
let a = bigInt128; let b = bigIntNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b > a; c_mod = a % b < a; c_mul = a * b === a; c_add = a + b !== a;
Number (Int32)
let a = int32; let b = intNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b > a; c_mod = a % b < a; c_mul = a * b === a; c_add = a + b !== a;
Number (Int32 asm.js)
"use asm"; let a = int32 | 0; let b = intNum | 0; let c_sub, c_mod, c_mul, c_add; c_sub = a - b > a; c_mod = a % b < a; c_mul = imul(a, b); c_add = a + b;
Number (maybe Int64)
let a = int64; let b = intNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b > a; c_mod = a % b < a; c_mul = a * b === a; c_add = a + b !== a;
Number (Float asm.js)
"use asm"; let a = float; let b = fround(intNum); let c_sub, c_mod, c_mul, c_add; c_sub = fround(a - b) > a; c_mod = fround(a % b) < a; c_mul = fround(a * b) === a; c_add = fround(a + b) !== a;
Number (Double)
let a = double; let b = intNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b > a; c_mod = a % b < a; c_mul = a * b === a; c_add = a + b !== a;

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
BigInt (32)
BigInt (64)
BigInt (128)
Number (Int32)
Number (Int32 asm.js)
Number (maybe Int64)
Number (Float asm.js)
Number (Double)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 19 days ago)

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

Browser/OS: Chrome 135 on Mac OS X 10.15.7

View result in a separate tab

Test name	Executions per second
BigInt (32)	175127632.0 Ops/sec
BigInt (64)	171538304.0 Ops/sec
BigInt (128)	166239408.0 Ops/sec
Number (Int32)	158601920.0 Ops/sec
Number (Int32 asm.js)	162291344.0 Ops/sec
Number (maybe Int64)	169008352.0 Ops/sec
Number (Float asm.js)	166076432.0 Ops/sec
Number (Double)	162630832.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 19 days ago):

LLMs can make mistakes. Check important info.

This benchmark tests the performance of various numeric data types in JavaScript, particularly comparing JavaScript's native `Number` type (which represents double-precision floating point numbers) and the `BigInt` type (for handling large integers) under different scenarios. Each test case examines basic arithmetic operations (subtraction, modulo, multiplication, and addition) using these data types and various strategies, including standard operations and operations optimized through `asm.js`.

### Benchmarked Options and Their Pros/Cons

1. **BigInt (32, 64, 128)**:
   - **Description**: These tests assess the performance of various sizes of `BigInt` (32-bit, 64-bit, and 128-bit). BigInts can represent integers larger than the maximum safe integer value for regular Numbers.
   - **Code Example**: 
     ```javascript
     let a = bigInt32; // Examples using BigInt (32)
     let b = bigIntNum; // Another BigInt
     ```
   - **Pros**: 
     - Can handle very large integers without precision loss. 
     - Useful for applications involving cryptography, large computations, or precise financial calculations.
   - **Cons**: 
     - Operations can be slower than traditional Number operations, especially for smaller integers.
     - Overhead associated with using an object wrapper.

2. **Number (Int32)**:
   - **Description**: Here, normal integer values are being used, specifically the 32-bit signed integers.
   - **Code Example**:
     ```javascript
     let a = int32; // Standard Integer
     let b = intNum; // Another Integer
     ```
   - **Pros**: 
     - Operations are generally faster because they operate on the fundamental numeric types directly supported by the hardware.
   - **Cons**: 
     - Precision issues occur for very large integers (greater than 2^53-1), beyond which it can lead to inaccurate results.

3. **Number (Int32 asm.js)**:
   - **Description**: This code segment uses `"use asm"` which is a directive in JavaScript that allows the performance optimizations of asm.js, a subset of JavaScript that can be optimized by proper JIT compilers.
   - **Code Example**:
     ```javascript
     "use asm";
     let a = int32 | 0; // operations treated as integers
     ```
   - **Pros**: 
     - Can yield much better performance in numerical computations as it hints to the JavaScript engine about the types being used.
   - **Cons**: 
     - Limited to number computations only and doesn’t support all JavaScript features, restricting flexibility.

4. **Number (maybe Int64)**:
   - **Description**: Although JavaScript does not natively support 64-bit integers, this test implies the use of larger integers which may not always be precise.
   - **Pros**: Similar to 32-bit numbers, but with potentially larger valid ranges.
   - **Cons**: Same precision issues as standard Numbers after exceeding safe limits.

5. **Number (Float asm.js)**:
   - **Description**: A floating-point operation optimized with asm.js.
   - **Code Example**:
     ```javascript
     "use asm";
     let a = float; // Float representations
     ```
   - **Pros**: 
     - Fast execution for computations should provide efficient numerical processing when using floating point arithmetic.
   - **Cons**: 
     - Complexity of using `asm.js` reduces versatility for other JavaScript features.

6. **Number (Double)**:
   - **Description**: This test looks at the use of standard double-precision floats, typical in JavaScript.
   - **Pros**: 
     - Provides precision for a larger range of decimal numbers.
   - **Cons**: 
     - Again, less performance for very high iteration tasks compared to optimized integer operations.

### Considerations
- **Performance**: The benchmark observes execution times across different setups to identify which data type/approach provides better performance for arithmetic operations.
- **Use Case**: The appropriate choice between these options largely depends on the use case: for high-precision arithmetic, `BigInt` is better; for speed, native integers (with potential `asm.js` optimization) might be more suitable.

### Alternatives
Other alternatives could include using more advanced libraries that manage number precision and performance more effectively, such as:
- **Decimal.js**: For arbitrary-precision decimal arithmetic.
- **Big.js**: A smaller library specifically for big number arithmetic that might also be a performance-conscious choice.
- **bignumber.js**: Another library focused on arbitrary-precision arithmetic.

### Conclusion 
This benchmark is significant in demonstrating how JavaScript’s handling of various numeric types impacts performance. It allows developers to make informed decisions on which numerical approach to adopt based on the requirements of their specific applications. Understanding these differences is crucial for optimizing performance in JavaScript applications that require significant numeric computations.

Related benchmarks:

JavaScript all number type benchmark v2 (version: 1)

Comparing performance of: BigInt (32) vs BigInt (64) vs BigInt (128) vs Number (Int32) vs Number (Int32 asm.js) vs Number (maybe Int64) vs Number (Float asm.js) vs Number (Double)

Created: 19 days ago by: Guest

Jump to the latest result

BigInt (32)

BigInt (64)

BigInt (128)

Number (Int32)

Number (Int32 asm.js)

Number (maybe Int64)

Number (Float asm.js)

Number (Double)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 19 days ago):