Benchmark: JavaScript number type benchmark

Script Preparation code:

var bigInt32 = 2n ** 24n;
var bigInt64 = 2n ** 40n;
var bigInt128 = 2n ** 80n;
var bigIntNum = 2n;

var int32 = 2 ** 10;
var int64 = 2 ** 40;
var float = Math.fround(2 ** 20);
var double = 2 ** 80;
var intNum = 2;

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; c_mod = a % b; c_mul = a * b; c_add = a + b;
BigInt (64)
let a = bigInt64; let b = bigIntNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b; c_mod = a % b; c_mul = a * b; c_add = a + b;
BigInt (128)
let a = bigInt128; let b = bigIntNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b; c_mod = a % b; c_mul = a * b; c_add = a + b;
Number (Int32)
let a = int32; let b = intNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b; c_mod = a % b; c_mul = a * b; c_add = a + b;
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) | 0; c_mod = (a % b) | 0; c_mul = imul(a, b); c_add = (a + b) | 0;
Number (maybe Int64)
let a = int64; let b = intNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b; c_mod = a % b; c_mul = a * b; c_add = a + b;
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); c_mod = fround(a % b); c_mul = fround(a * b); c_add = fround(a + b);
Number (Double)
let a = double; let b = intNum; let c_sub, c_mod, c_mul, c_add; c_sub = a - b; c_mod = a % b; c_mul = a * b; c_add = a + b;

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 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36

Browser/OS: Chrome 133 on Windows

View result in a separate tab

Test name	Executions per second
BigInt (32)	169096288.0 Ops/sec
BigInt (64)	177226400.0 Ops/sec
BigInt (128)	183639712.0 Ops/sec
Number (Int32)	185756720.0 Ops/sec
Number (Int32 asm.js)	172968016.0 Ops/sec
Number (maybe Int64)	181406160.0 Ops/sec
Number (Float asm.js)	193061312.0 Ops/sec
Number (Double)	181440800.0 Ops/sec

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

LLMs can make mistakes. Check important info.

The benchmark represented in the provided JSON tests the performance of various numerical operations using different types of number representations in JavaScript. It particularly focuses on two categories: **BigInt** and **Number**, comparing their performance across different bit-widths and methodologies. Let’s break down the test cases, options compared, as well as their pros and cons:

### Test Cases Overview

1. **BigInt Tests**: 
   - `BigInt (32)`: Tests operations using a 32-bit BigInt.
   - `BigInt (64)`: Tests operations using a 64-bit BigInt.
   - `BigInt (128)`: Tests operations using a 128-bit BigInt.

These cases perform basic arithmetic operations: subtraction, modulus, multiplication, and addition between big number types and standard integers.

2. **Number Tests**:
   - `Number (Int32)`: Tests operations using a 32-bit integer (which is a regular JavaScript number).
   - `Number (Int32 asm.js)`: Uses asm.js to optimize performance for 32-bit integers explicitly, leveraging bitwise operations.
   - `Number (maybe Int64)`: Examines operations potentially using a 64-bit integer. JavaScript’s `Number` type can safely represent 53 bits of precision.
   - `Number (Float asm.js)`: Similar to `Int32 asm.js`, but optimized for floating-point numbers using the `Math.fround` method.
   - `Number (Double)`: Tests operations using a double-precision floating point.

### Pros and Cons of Each Approach

#### BigInt
**Pros**:
- Can represent integers larger than `2^53 - 1`, which is JavaScript's maximum safe integer for standard numbers.
- Not affected by precision limitations of floating-point representation because it's integer-only.

**Cons**:
- Generally slower than operations on `Number` types due to extra handling for large integers.
- Limited operations compared to standard `Number`; for example, they cannot participate in mathematical functions without converting to regular `Number`.

#### Number (Int32 and Int64)
**Pros**:
- Highly optimized for performance and natively supported by JavaScript engines.
- Much simpler syntax and operations compared to BigInt.

**Cons**:
- Cannot accurately represent integers beyond `2^53 - 1`, which can lead to data loss for large integer calculations.
- May introduce precision issues when dealing with very small or very large numbers in floating-point operations.

#### asm.js
- **Pros**: 
  - A JavaScript subset that allows for higher performance optimizations. Using `asm.js`, the performance can be closer to C/C++.
  - Encourages the use of strict types and promotes safe arithmetic via bitwise operators.

- **Cons**:
  - Can be more cumbersome to write because of the required strict typing and bitwise manipulation.
  - Not widely adopted outside of performance-critical applications.

### Special JavaScript Features
1. **BigInt**: Introduced as a native way of working with large integers that exceed the `Number` range.
2. **asm.js**: A subset of JavaScript that allows for significant performance gains by forcing strict typing and enabling optimizations similar to compiled languages. The `"use asm"` directive indicates that the code is intended to be optimized for speed.

### Alternatives
Other numerical handling options include:
- Using libraries like **Big.js**, **Decimal.js**, or **bignumber.js**: These libraries provide methods to perform arithmetic on big numbers while giving more straightforward interfaces and additional features compared to built-in `BigInt`.
- For typical calculations, sticking with **Number** types unless the range or precision constraints are an issue is advisable.
- WebAssembly (Wasm) can be considered for performance-sensitive tasks, especially for heavy calculations, as it offers near-native performance and is another alternative to asm.js.

### Conclusion
In summary, this benchmark examines the performance of operations using different numerical representations in JavaScript, providing insights into the pros and cons of BigInt vs. Number types, and leveraging special features like asm.js for optimized performance. Ultimately, the choice between these approaches depends largely on the specific application's needs—especially regarding precision and performance.

Related benchmarks:

JavaScript number type benchmark (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):