If you try 9n**9n**9n in Chrome's console, Chrome breaks (it resembles an infinite loop). Why does this happen?

Question

If you try 9n**9n**9n in Chrome\'s console, Chrome breaks (it resembles an infinite loop).

• Does the V8 engine lack the implementation for this case?

Answer 1

As was said already, 9n is the BigInt representation of 9.

The ** (power) operator works from right to left, causing quick escalation of results:

2n**2n**2n === 2n ** 4n === 16n
3n**3n**3n === 3n ** 27n === 7625597484987n
4n**4n**4n === 4n ** 256n === 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096n

On my system this becomes quite laggy from 7n**7n**7n, which takes about 32 seconds to calculate print. The result is 695976 digits, the first 5000 of which are printed in the console.

I haven't tried it any further, but I'd say it is just chewing away on the result. This could well take hours or days to calculate print (or perhaps even an Out Of Memory situation might occur at some point).

Update:

I just tried var x = 7n**7n**7n in the Chrome console, so just assigning it to a variable, and this finished in almost no time. It turns out that converting the bigint to a string is what takes up time; printing x.toString().length takes a similar amount of time as printing x or 7n**7n**7n.

Further experimenting revealed other interesting behaviour, see these results:

// Pure calculation time increases significantly when the exponent grows:
var x = 7n**7n**7n; // ~   1200 ms
var x = 7n**8n**7n; // ~   7000 ms
var x = 7n**7n**8n; // ~  62000 ms
var x = 7n**8n**8n; // ~ 470000 ms

// But it's a different story when the base number is 'simple' in binary terms, e.g. 8n:
var x = 8n**7n**7n; // ~      1 ms
var x = 8n**8n**7n; // ~      1 ms
var x = 8n**7n**8n; // ~      7 ms
var x = 8n**8n**8n; // ~     17 ms

And yes, there is an end to it all:

var x = 32n**16n**8n;

gives:

VM436:1 Uncaught RangeError: Maximum BigInt size exceeded
at <anonymous>:1:28

The upper limit in Chrome appears to be 1 billion bits (1e9 bits), or about 125 MB - Reference: https://github.com/tc39/proposal-bigint/issues/174#issuecomment-437471065

Answer 2

Background information:

In JavaScript you can use n suffix for making the number as bigint (simpy big numbers). Big numbers have different ways of computations. Usually they are more "expensive" to compute. It does not use the processors built-in methods for calculations. Instead bigints use soft computations.

Description of the issue:

9n**9n means 9^9 (9*9*9*9*9*9*9*9*9). It is 387420489. Even if you multiply 387420489 by itself it is really big number. But **9n means you want to compute 387420489^9 which is really really very big number. It seems for chrome it takes too long to calculate it or some unknown issue happens.

Basically it must be a bug which needs to be reported. Freezing the browser in weird way is not good user experience.

Answer 3

The answer as to why 9**9**9 returns Infinity is because it doesn't take very long to overflow the maximum value (around 2^1024). It might even shortcut it with the ** as see if the first number >= 2 and the second number > 1024, then it will be Infinity.

With BigInt, it can represent much, much larger numbers, so that's what it tries to do. It takes a long time to reach "Infinity" with BigInt (EDIT: which would actually be a RangeError exception). Finding 387420489 can be done pretty quick, but 9n**387420489n, where it is multiplying BigInts almost 400 Million times...that takes a while.

A BigInt operation is much slower than a regular int operation. I expect you might get a result (or a RangeError exception) if you wait 20-30 minutes, but could be much longer.