Benchmark: JS BigInt vs two numbers bitwise performance

Script Preparation code:

var bigInt1 = 4294967123295n
var bigInt2 = 4294967423295n
var number1_1 = 1
var number1_2 = 5
var number2_1 = 6
var number2_1 = 555

Tests:

BigInt
c = bigInt1 & bigInt2
Number
c = (number1_1 & number2_1) || (number1_2 & number2_2)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
BigInt
Number

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 13 hours ago)

User agent: Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Mobile Safari/537.36

Browser/OS: Chrome Mobile 147 on Android

View result in a separate tab

Test name	Executions per second
BigInt	1908079.0 Ops/sec
Number	2105582.0 Ops/sec

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

LLMs can make mistakes. Check important info.

Let's dive into the explanation.

**What is being tested?**

The benchmark is designed to compare the performance of two approaches for performing bitwise operations on large numbers:

1. **Number**: This approach uses JavaScript's built-in `number` type, which represents 64-bit signed integers. When dealing with very large numbers, this type can be limited by its integer size.
2. **BigInt**: This approach uses the new `BigInt` type introduced in ECMAScript 2020 (ES10). `BigInt` is a dedicated type for representing arbitrarily large integers, which avoids the limitations of JavaScript's built-in `number` type.

**Options compared**

The benchmark compares two specific operations:

1. **Bitwise AND (&)**: This operation takes two numbers as input and returns the result of performing a bitwise AND operation between them.
2. **OR (||)**: This operation takes two numbers as input and returns the result of performing a logical OR operation between them.

**Pros and Cons**

**Number approach**

* Pros:
	+ Easy to implement, as it uses standard JavaScript syntax.
	+ Well-supported by most browsers.
* Cons:
	+ Limited by JavaScript's built-in `number` type size (64 bits), which can lead to performance issues for very large numbers.
	+ May not be suitable for applications requiring arbitrary-precision arithmetic.

**BigInt approach**

* Pros:
	+ Provides arbitrary-precision arithmetic, avoiding the limitations of JavaScript's built-in `number` type.
	+ Can handle extremely large numbers without sacrificing performance.
* Cons:
	+ Requires support for the new `BigInt` type, which may not be universally supported (although it is gaining widespread adoption).
	+ May require additional setup or configuration in certain environments.

**Other considerations**

* The benchmark uses a simple script preparation code to define the input values (`bigInt1`, `bigInt2`, etc.). This code should be similar for both test cases, as the operations being compared are identical.
* The benchmark does not consider any special JavaScript features or syntax that might affect performance. However, it's worth noting that some browsers may optimize certain operations or use different algorithms when dealing with very large numbers.

**Alternatives**

Other alternatives for performing bitwise operations on large numbers in JavaScript include:

1. **BigInteger libraries**: Third-party libraries like [big-integer](https://github.com/bc-pm/big-integer) can provide a more robust and flexible way to work with arbitrary-precision integers.
2. **Native modules or extensions**: Some browsers offer native modules or extensions that provide optimized implementations for specific arithmetic operations, such as WebAssembly (WASM).
3. **Custom implementation**: In some cases, developers may choose to implement their own custom algorithms or optimizations for performing bitwise operations on large numbers.

In summary, the benchmark compares two approaches for performing bitwise operations on large numbers: the standard `number` type and the new `BigInt` type. While the `Number` approach is easy to implement and widely supported, it has limitations due to JavaScript's built-in integer size. The `BigInt` approach provides arbitrary-precision arithmetic but requires support for the new `BigInt` type and may not be universally supported.

Related benchmarks:

JS BigInt vs two numbers bitwise performance (version: 0)

Compare Number vs BigInt for big numbers

Comparing performance of: BigInt vs Number

Created: one year ago by: Guest

Jump to the latest result

BigInt

Number

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

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