Benchmark: JS BigInt big number performance vx

Script Preparation code:

var bigInt1          = 50n 
var bigInt2          = 9007199254740992n //MaxSafe +1
var number1          = 9007199254740990 //MaxSafe -1
var number2          = 50 //MaxSafe -1

var pgMaxBigInt      = 9223372036854775807n // 2^63-1
var pgDiv = 50n
var pgDecimal = 92233720368547758070000000000n              // max digits before decimal point: 131072

Tests:

BigInt
a = bigInt1 b = bigInt2 c = a - b c = a % b c = a * b c = a + b c = a ** b
Number
a = number1 b = number2 c = a - b c = a % b c = a * b c = a + b c = a ** b
pgBigInt
a = pgMaxBigInt b = pgDiv c = a - b c = a % b c = a * b c = a + b c = a ** b
pgDecimal
a = pgDecimal b = pgDiv c = a - b c = a % b c = a * b c = a + b c = a ** b

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
BigInt
Number
pgBigInt
pgDecimal

Fastest: N/A

Slowest: N/A

Latest run results:

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

User agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

Browser/OS: Chrome 131 on Linux

View result in a separate tab

Test name	Executions per second
BigInt	0.0 Ops/sec
Number	299015.9 Ops/sec
pgBigInt	140967.0 Ops/sec
pgDecimal	99774.0 Ops/sec

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

LLMs can make mistakes. Check important info.

**Overview of the Benchmark**

The provided JSON represents a JavaScript benchmarking test case on MeasureThat.net. The test compares the performance of three different approaches to handle large numbers: `Number`, `BigInt`, and two custom implementations (`pgBigInt` and `pgDecimal`). Each test case involves arithmetic operations (addition, subtraction, multiplication, division, and exponentiation) between a large number and another smaller number.

**Options Compared**

The benchmark compares the following options:

1. **Number**: The built-in JavaScript number type, which uses 64-bit floating-point representation.
2. **BigInt**: A relatively new JavaScript feature introduced in ECMAScript 2020, designed for handling arbitrarily-precision integers.
3. **pgBigInt**: A custom implementation that likely mimics the behavior of `BigInt` but may have different optimizations or implementation details.
4. **pgDecimal**: Another custom implementation that might use a different numerical representation (likely decimal arithmetic) to handle large numbers.

**Pros and Cons**

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

1. **Number**:
	* Pros: Simple, widely supported, and fast for most use cases.
	* Cons: Limited precision, may cause rounding errors for very large numbers, and can lead to performance issues when dealing with very large values.
2. **BigInt**:
	* Pros: Arbitrarily-precision integers, robust support in modern browsers, and better suited for cryptographic applications.
	* Cons: Newer feature, might not be supported in older browsers or environments, and may require additional setup (e.g., enabling the `--expose-globals` flag).
3. **pgBigInt**:
	* Pros: Custom implementation might optimize performance for specific use cases or provide better handling of certain edge cases.
	* Cons: Unknown implementation details, potential compatibility issues with other libraries or codebases.
4. **pgDecimal**:
	* Pros: Could potentially offer better support for decimal arithmetic and precise calculations.
	* Cons: Unknown implementation details, potential trade-offs in performance or complexity.

**Library Used**

The benchmark doesn't explicitly mention any additional libraries beyond the built-in JavaScript features. However, it's possible that some of these custom implementations (`pgBigInt` and `pgDecimal`) rely on external libraries or frameworks to achieve their numerical representations.

**Special JS Features**

None mentioned, but it's worth noting that this benchmark doesn't appear to utilize any experimental or feature flags specific to modern browsers.

**Other Considerations**

1. **Precision vs. Performance**: The benchmark prioritizes performance over precision in some cases (e.g., `Number` for arithmetic operations). This trade-off is common in numerical computations, where a balance between speed and accuracy must be struck.
2. **Arithmetic Operations**: The benchmark focuses on basic arithmetic operations (addition, subtraction, multiplication, division, exponentiation). More complex mathematical functions or algorithms might require different approaches to optimization.
3. **Device Platforms**: The benchmark results are only reported for desktop browsers running Chrome 109. Future tests should consider additional platforms and devices to ensure broader compatibility.

**Alternatives**

If you're looking for alternatives to the `Number` type, you could explore:

1. **Decimal.js**: A library specifically designed for decimal arithmetic.
2. **Big.js**: Another library that provides support for arbitrarily-precision integers (similar to `BigInt`).
3. **Custom implementations**: Depending on your specific requirements, you might consider implementing a custom numerical representation using a library like `mathjs` or creating your own.

Keep in mind that each alternative has its pros and cons, which should be carefully evaluated based on your project's needs and constraints.

Related benchmarks:

JS BigInt big number performance vx (version: 0)

Compare Number vs BigInt for big numbers

Comparing performance of: BigInt vs Number vs pgBigInt vs pgDecimal

Created: one year ago by: Guest

Jump to the latest result

BigInt

Number

pgBigInt

pgDecimal

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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