For my book, *How JavaScript Works*,
I created a module, `big_integer.js`

, that makes and performs operations on integers of any size.
Since then, the ECMAScript standard has acquired a `BigInt`

type, which, being native,
can run faster and consume less memory.
I have revised `big_integer.js`

to use `BigInt`

as its underlying implementation.

I also created two other modules, `big_float.js`

and `big_rational.js`

.
The `big_float.js`

module uses `big_integer.js`

to implement decimal floating point,
similar to DEC64
but with virtually unlimited range and resolution.
It benefits significantly from the `big_integer.js`

speed up.
Decimal floating point is much better than the binary floating point that JavaScript provides because it can exactly
represent decimal fractions, including money.
The `big_float.js`

module can exactly represent every value that binary floating point can,
but binary floating point can not exactly represent `0.01`

.
The world should stop using binary floating point.

The `big_rational.js`

module can exactly represent everything that `big_float.js`

can,
and can also exactly represent virtually all rational fractions, starting with `1/3`

.
Rational arithmetic is truly awesome, but there is a potential problem: The numerators and denominators
can grow quickly in some computations, creating a big performance problem. So for most purposes,
decimal floating point suffices. But if you want to make the world's best, most accurate calculator,
nothing is better than big rationals.

I am also releasing the tests for those modules. The tests demonstrate the use of JSCheck.