Arbitrary-precision decimals. Enables making math calculations with rational numbers, without precision loss.
npm install exactnumber



Arbitrary-precision decimals. Enables making math calculations with rational numbers, without precision loss.
- Works with arbitrary large numbers without precision loss
- All fractions can be represented as repeating decimals like 1.23(45)
- This repeating decimal format (1.23(45)) can also be parsed back
- Works with all number bases between 2 and 16
- No special values like NaN, Infinity or -0.
- No silent errors: it throws errors immediatelly when a confusing parameter is received (e.g. 0/0)
- Supports bitwise operators (and, or, xor, shiftLeft, shiftRight)
- Supports all modern browsers, web workers, Node.js and Deno
- Includes TypeScript type definitions: documentation
- Zero external dependencies
- Under the hood, it relies on the BigInt type. It automatically switches back and forth between fixed-precision and fractional representations.
- Tries to deliver the best possible performance
- 100% open source + MIT license
``js
import { ExactNumber as N } from 'exactnumber';
1 + 0.36 // 1.3599999999999999
N(1).add('0.36').toString() // 1.36
(1 / 49) * 49 // 0.9999999999999999
N(1).div(49).mul(49).toString() // 1
10e16 + 5 // 100000000000000000
N('10e16').add(5).toString() // 100000000000000005
1 / 3 // 0.3333333333333333
N(1).div(3).toString() // 0.(3)
2**32 >> 32 // 0
N(2).pow(32).shiftRight(32).toString() // 1
`
``
npm i exactnumber
It can also be used directly from HTML (via jsDelivr):
`html
`
`js
import { ExactNumber as N } from 'exactnumber';
N(1).add('3').toString(); // 4
N('1/7').add('1/10').toFraction(); // 17/70
N('1/7').toString(); // 0.(142857)
N('1/7').toString(6); // 0.(05)
N('1/7').toFixed(3); // 0.142
N('1/7').trunc(3).toString(); // 0.142
N('0.(3)').add('0.(6)').toString(); // 1
N('0b1100').bitwiseAnd('0b1010').toString(2); // 1000
N.max('1/1', '10/2', 3).toString(); // 5
N.fromBase('123', 4).toString(); // 27
`
- Addition / subtraction: add(), sub()mul()
- Multiplication / division: , div(), divToInt()pow()
- Exponentiation: mod()
- Modular arithmetic: , powm()sign()
- Getting the sign / absolute value: , abs()neg()
- Negation / inversion: , inv()intPart()
- Integer and fractional parts: , fracPart()cmp()
- Comparisons: , eq(), lt(), lte(), gt(), gte()isZero()
- Special comparisons: , isOne()isInteger()
- Type testing: round()
- Rounding: , roundToDigits(), floor(), ceil(), trunc()bitwiseAnd()
- Bitwise operators: , bitwiseOr(), bitwiseXor(), shiftLeft(), shiftRight()clamp()
- Clamping: getFractionParts()
- Fraction helper: normalize()
- Normalization / simplifying fractions: toFixed()
- String output: , toExponential(), toPrecision(), toString(), toFraction()toNumber()
- Number output: ExactNumber.gcd()
- GCD, LCM: , ExactNumber.lcm()ExactNumber.min()
- Minimum, maximum: , ExactNumber.max()ExactNumber.fromBase()
- Parsing numbers in different bases: ExactNumber.range()
- Range generator:
- NEAREST_TO_POSITIVE - Rounds to nearest number, with ties rounded towards +Infinity. Similar to Math.round().NEAREST_TO_NEGATIVE
- - Rounds to nearest number, with ties rounded towards -Infinity.NEAREST_TO_EVEN
- - Rounds to nearest number, with ties rounded towards the nearest even number.NEAREST_TO_ZERO
- - Rounds to nearest number, with ties rounded towards zero.NEAREST_AWAY_FROM_ZERO
- - Rounds to nearest number, with ties rounded away from zero.
- TO_POSITIVE - Rounds towards +Infinity. Similar to Math.ceil().TO_NEGATIVE
- - Rounds towards -Infinity. Similar to Math.floor().TO_ZERO
- - Rounds towards zero. Similar to Math.trunc().AWAY_FROM_ZERO
- - Rounds away from zero
- TRUNCATEDFLOORED
- EUCLIDEAN`
-
Read more about them here.
License: MIT
Copyright © 2025 Dani Biró