It turns out (outer a bit of thought it's more obvious but whatever) that BigInt recently introduced to javascript has a limit:
My question would be - is there a constant similar to Number.MAX_SAFE_INTEGER but for BigInt?
This snippet of code:
let a = 2n, step = 1;
try{while(true) {
console.log(step);
a=a**2n; step++
}} catch(e){ console.log(e)}
Shows that the limit is about (step = 32) - at least in Chrome. But I wonder what it this value as per spec.
It seems like there is no maximum limit to a BigInt as per spec, which makes sense considering BigInts are supposed to be arbitrary-precision integers, whose "digits of precision are limited only by the available memory of the host system".
As for v8 specifically, according to this article on the v8 blog, the precision of BigInts are "arbitrary up to an implementation-defined limit". Unfortunately, I couldn't find any further information on how the limit is determined. Maybe someone else would be able to shed light on this based on these v8 BigInt implementation notes?
That said, based on the aforementioned articles, there doesn't seem to be a specific maximum value/size for a BigInt. Rather, it is likely determined based on the available memory on the system in some way.
The maximum size of a BigInt in webkit is defined as such
// The maximum length that the current implementation supports would be
// maxInt / digitBits. However, we use a lower limit for now, because
// raising it later is easier than lowering it.
// Support up to 1 million bits.
static constexpr unsigned maxLength = 1024 * 1024 / (sizeof(void*) * bitsPerByte);
The size of void* is platform dependent, 8 on 64 bit systems.
So there's your answer right? Should be 16384 bits.... (-1 for the sign). But I can't create anywhere near that large a number in console.
The size has arbitrary precision, per 4.3.25BigInt value, though, oddly not mentioned in the 20.2 BigInt Objects section.
Here is a quick test program:
/* global BigInt */
let b = BigInt(10)
let exp = 1;
while (true) {
console.log(`BigInt of 10^${exp} `);
b = b * b;
exp *= 2;
}
output with Node v13.2:
BigInt of 10^1
BigInt of 10^2
BigInt of 10^4
...
BigInt of 10^4194304
BigInt of 10^8388608
BigInt of 10^16777216
Performance really drags after about 10 to the millionth.
While there may be a platform specific maximum in a specific browser, the size requirement to show it would be large. Even 10^10^6 takes over 300K to store. You could extend the spec to add a limit with Tetration, e.g., "limit is about 10^10^10^... 8 times", but, seriously, that would be silly.
It turns out it's 2^30 - 1 bits, or 2^(2^30) - 1. Any more bits and it wouldn't work. (I was unable to get the actual value, since bit shifts can't do that) To put that in comparison, there are more digits in that number than the population in the US (almost 2x)!
(Wolfram Alpha link for the number of digits)
Tested on a modern Chrome browser.
So, running the following script in the console:
let n = 1n;
let p = 1;
while(p<10001) {
n *= 1267650600228229401496703205376n // 2^100
console.log({p: p++})
console.log(n)
}
does not "error" even though I'm multiplying by 1267650600228229401496703205376n on each iteration, I easily got up to the equivalent of: 10000*100 bits (1,000,000 bits)
... however, the resulting value logged to the console is:
78102406353244117148310442417059631533061780115528…123691650081257805509908275407049892733047013376n, and I can't seem to retrieve any of the internal parts of the number (in the ...), so not sure how much use it is to me. In theory, it's still calculating fine. I'm sure I could have kept going. It took about 5 minutes or so to calculated all that up on my 2019 macbook pro.
(NOTE: I did not put in the while(true), because it really started to lock up chrome after a while. I could not stop the algorithm and I could only shut down chrome by force, I decided to put in a max value that seemed relatively high and definitely good enough for anything most of us would want to deal with in the foreseeable future).
Point is, it looks like you can handle pretty big numbers this way.
