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

Latest run results:

Run details: (Test run date: 2 months ago)

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

Browser/OS: Chrome 132 on Linux

View result in a separate tab

Test name	Executions per second
float multiply	22758360.0 Ops/sec
bigInt multiply	16612362.0 Ops/sec
float compare	29027774.0 Ops/sec
bigInt compare	29923526.0 Ops/sec
string compare	32229388.0 Ops/sec
float greater	29297920.0 Ops/sec
bigint greater	30106392.0 Ops/sec
string greater	27017206.0 Ops/sec
toString bigInt	1924079.6 Ops/sec
toString float	20295042.0 Ops/sec
toFloat bigInt	10762998.0 Ops/sec
toFloat string	4522710.0 Ops/sec

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

LLMs can make mistakes. Check important info.

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 6 months ago):