Benchmark: bigint-vs-string

Script Preparation code:

/**
 * Gets a random number between 2 bigInts
 * @param {BigInt} max
 * @param {BigInt} [min=0n]
 * @returns {BigInt}
 */
function randomBetween(max, min = 0n) {
  max = BigInt(max);
  min = BigInt(min);
  if (max < min) {
    [max, min] = [min, max]
  }
  const range = max - min;
  const count = calculatePrecision(range);
  let random = new Array(Number(count))
    .fill(0)
    .map(() => BigInt(Math.floor(Math.random() * (2 ** 32))))
    .map((int, index) => int << (BigInt(index) * 32n))
    .reduce((acc, int) => acc + int, 0n);


  let bitCount = countBits(range);
  let minRandom = random >> ((32n * count) - bitCount);
  if (minRandom > range) return randomBetween(max, min);
  else return minRandom + min;
}

function calculatePrecision(range) {
  const result = range >> 32n;
  if (result >= 1n) {
    return calculatePrecision(result) + 1n;
  }
  return 1n;
}

function countBits(range) {
  const result = range >> 1n;
  if (result >= 1n) {
    return countBits(result) + 1n;
  }
  return 1n;
}

const a = randomBetween(10n ** 20n, 10n ** 19n)
const b = randomBetween(10n ** 20n, 10n ** 19n)
aBigInt = a;
bBigInt = b;
aString = a.toString();
bString = b.toString();
aFloat = Number(a);
bFloat = Number(b);

Tests:

float multiply
return aFloat * bFloat;
bigInt multiply
return aBigInt * bBigInt;
float compare
return aFloat === bFloat;
bigInt compare
return aBigInt === bBigInt
string compare
return aString === bString
float greater
return aFloat > bFloat;
bigint greater
return aBigInt > bBigInt;
string greater
return aString > bString
toString bigInt
return aBigInt.toString();
toString float
return aFloat.toString();
toFloat bigInt
return Number(aBigInt);
toFloat string
return parseInt(aString, 10);

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
float multiply
bigInt multiply
float compare
bigInt compare
string compare
float greater
bigint greater
string greater
toString bigInt
toString float
toFloat bigInt
toFloat string

Fastest: N/A

Slowest: N/A

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

LLMs can make mistakes. Check important info.

Latest run results:

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

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36

Browser/OS: Chrome 130 on Windows

View result in a separate tab

Test name	Executions per second
float multiply	4931273.5 Ops/sec
bigInt multiply	5030014.5 Ops/sec
float compare	4949152.5 Ops/sec
bigInt compare	5175788.0 Ops/sec
string compare	4968843.5 Ops/sec
float greater	4963045.5 Ops/sec
bigint greater	4982839.0 Ops/sec
string greater	4710759.5 Ops/sec
toString bigInt	4013036.0 Ops/sec
toString float	8130573.0 Ops/sec
toFloat bigInt	4547554.0 Ops/sec
toFloat string	3240164.2 Ops/sec

Related benchmarks:

bigint-vs-string (version: 0)

Comparing performance of: float multiply vs bigInt multiply vs float compare vs bigInt compare vs string compare vs float greater vs bigint greater vs string greater vs toString bigInt vs toString float vs toFloat bigInt vs toFloat string

Created: 6 years ago by: Registered User

Jump to the latest result

float multiply

bigInt multiply

float compare

bigInt compare

string compare

float greater

bigint greater

string greater

toString bigInt

toString float

toFloat bigInt

toFloat string

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

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