Run results for: bigint-vs-string

Run details:

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

Browser: Chrome 68

Operating system: Windows

Device Platform: Other

Date tested: 6 years ago

Test name	Executions per second
float multiply	2576947.0 Ops/sec
bigInt multiply	1406982.0 Ops/sec
float compare	2683737.0 Ops/sec
bigInt compare	2187131.0 Ops/sec
string compare	2094893.0 Ops/sec
float greater	2484218.0 Ops/sec
bigint greater	1796237.0 Ops/sec
string greater	1931389.0 Ops/sec
toString bigInt	1535081.0 Ops/sec
toString float	4136287.0 Ops/sec
toFloat bigInt	1835411.0 Ops/sec
toFloat string	1466544.0 Ops/sec

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);

Run results for: bigint-vs-string

float multiply

bigInt multiply

float compare

bigInt compare

string compare

float greater

bigint greater

string greater

toString bigInt

toString float

toFloat bigInt

toFloat string