# exactnumber

1.0.1 • Public • Published

# ExactNumber

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

## Features

• 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)
• Includes approximation algorithms for irrational numbers like PI, sin(1).
• 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

## Comparision with built-in numbers

import { ExactNumber as N } from 'exactnumber';

1 + 0.36 // 1.3599999999999999

(1 / 49) * 49 // 0.9999999999999999
N(1).div(49).mul(49).toString() // 1

10e16 + 5 // 100000000000000000

1 / 3 // 0.3333333333333333
N(1).div(3).toString() // 0.(3)

2**32 >> 32 // 0
N(2).pow(32).shiftRight(32).toString() // 1

## Installation

npm i exactnumber

It can also be used directly from HTML (via jsDelivr):

<!-- loads the full, minified library into the global exactnumber variable -->
<script src="https://cdn.jsdelivr.net/npm/exactnumber"></script>

<!-- or loads the non-minified library -->
<script src="https://cdn.jsdelivr.net/npm/exactnumber/dist/index.umd.js"></script>

## Usage

import { ExactNumber as N } from 'exactnumber';

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('0b1100').bitwiseAnd('0b1010').toString(2); // 1000

N.max('1/1', '10/2', 3).toString(); // 5
N.fromBase('123', 4).toString(); // 27

// approximations

import { PI, sin, pow } from 'exactnumber';
PI(10).toString(); // 3.1415926535

const PI_OVER_2 = PI(10).div(2);
sin(PI_OVER_2, 5).toString(); // 1.00000

// 0.1232323 raised to the power of 2.193333, approximated with 10 decimals
pow('0.1(23)', '2.19(3)', 10).toString(); // 0.0101310867

## Functions

• Multiplication / division: mul(), div(), divToInt()
• Exponentiation: pow()
• Modular arithmetic: mod(), powm()
• Getting the sign / absolute value: sign(), abs()
• Negation / inversion: neg(), inv()
• Integer and fractional parts: intPart(), fracPart()
• Comparisons: cmp(), eq(), lt(), lte(), gt(), gte()
• Special comparisons: isZero(), isOne()
• Type testing: isInteger()
• Rounding: round(), roundToDigits(), floor(), ceil(), trunc()
• Bitwise operators: bitwiseAnd(), bitwiseOr(), bitwiseXor(), shiftLeft(), shiftRight()
• Clamping: clamp()
• Fraction helper: getFractionParts()
• Normalization / simplifying fractions: normalize()
• String output: toFixed(), toExponential(), toPrecision(), toString(), toFraction()
• Number output: toNumber()
• GCD, LCM: ExactNumber.gcd(), ExactNumber.lcm()
• Minimum, maximum: ExactNumber.min(), ExactNumber.max()
• Parsing numbers in different bases: ExactNumber.fromBase()
• Range generator: ExactNumber.range()

## Rounding modes

• 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

• TRUNCATED
• FLOORED
• EUCLIDEAN

## Approximation algorithms

These functions approximate irrational numbers with arbitrary number of decimals. The last parameter is always used to specify the number of correct decimals in the result.

• Roots: sqrt(), cbrt(), nthroot()
• Exponentials: pow(), exp()
• Logarithms: log(), logn(), log10(), log2(),
• Constants: PI()
• Trigonometric functions: sin(), cos(), tan()
• Inverse trigonometric functions: asin(), acos(), atan()
• Hyperbolic functions: sinh(), cosh(), tanh()
• Inverse hyperbolic functions: asinh(), acosh(), atanh()

## Package Sidebar

### Install

npm i exactnumber

### Repository

github.com/Daninet/exactnumber

618

1.0.1

MIT

411 kB

78