Exact arithmetic on arbitrarily large integers — plus factorial up to 1000! and Fibonacci up to F(10000), with full precision.
Results update live as you type. Every digit is exact.
Exact result
Digits
—
total digit count
Scientific
—
approximate e-notation
Sign
—
positive / negative
| Quantity | Digits | Notable |
|---|---|---|
| 2⁶⁴ | 20 | limit of unsigned 64-bit integer |
| 10⁵³ | 54 | ≈ Number.MAX_SAFE_INTEGER as power of 10 |
| 100! | 158 | ends in 24 zeros (trailing twos) |
| 1000! | 2,568 | computable in milliseconds via BigInt |
| F(1000) | 209 | Fibonacci Fn ≈ φⁿ/√5 |
| RSA-2048 | 617 | typical RSA modulus length |
The Method
Ordinary floating-point numbers (IEEE 754 doubles) have only 15-17 significant digits. For anything larger, every extra digit you write down is lost to rounding. BigInt stores numbers as arbitrary-length digit sequences and implements addition, multiplication and powers digit by digit, so the answer is exact regardless of size. The cost is speed: multiplying two thousand-digit numbers takes longer than multiplying two doubles — but with modern hardware it still completes in milliseconds.
Working for selected operation
About This Tool
A big number calculator performs exact arithmetic on integers of arbitrary size — far beyond the 15-17 significant digits available in standard floating-point arithmetic. Enter two numbers, choose an operation, and the calculator returns the exact result no matter how many thousands of digits long.
Big-number arithmetic is the foundation of public-key cryptography (RSA, ECC, Diffie-Hellman), blockchains and cryptocurrency (transaction signatures, hash chains), scientific computation, combinatorics (factorials and binomial coefficients quickly exceed double precision), and any application that needs guaranteed precision for very large integers. Without big-number support, RSA-2048 would be impossible — its modulus is roughly 617 digits long.
This calculator uses JavaScript's BigInt primitive (ES2020), which represents integers as arbitrary-length digit sequences. Addition, subtraction, multiplication, division, modulo, exponentiation, and GCD all run as exact operations. The factorial mode computes n! up to n = 1000 (a 2,568-digit number), and the Fibonacci mode computes F(n) up to n = 10,000 (around 2,090 digits) by iterative addition.
Use this free big number calculator for cryptography study, combinatorics homework, exploring number theory, or just to see what 500! actually looks like. Every calculation runs locally — no sign-up, no tracking.
Exact Arithmetic
Add, subtract, multiply, divide, mod, power and GCD — every digit is correct.
Factorial up to 1000!
Compute n! exactly — 1000! has 2,568 digits and runs in milliseconds.
Fibonacci up to F(10000)
Exact F(n) by iterative BigInt addition — no floating-point drift.
GCD (Euclidean)
Greatest common divisor by the Euclidean algorithm on BigInts.
100% Free & Private
No account, no tracking — every calculation runs locally in your browser.
Digit Count & Scientific
See the total digit count and an approximate scientific-notation value.
From arithmetic to factorial to Fibonacci — six clear steps.
Use the tabs to switch between Arithmetic, Factorial, and Fibonacci. Inputs update to match the chosen mode.
In Arithmetic mode, type or paste two integers — they can be hundreds of digits long. For factorial and Fibonacci, enter n.
In Arithmetic mode, choose + − × ÷ mod ^ GCD. Division is integer (floor) division — fractional parts are discarded.
The full exact answer appears in the result box. For very large numbers you may need to scroll — the value is complete to the last digit.
Stat tiles show the number of digits, a scientific-notation approximation, and the sign — quick context for very large results.
In Factorial and Fibonacci modes, a chart shows the digit-count growth for nearby values of n — useful for spotting where double-precision breaks down.
Everything you need to know about exact arithmetic on arbitrarily large integers.
A big number calculator performs exact arithmetic on integers of arbitrary size. Ordinary floating-point numbers in computers are limited to about 15-17 significant digits — anything beyond that gets rounded. A big-number tool uses arbitrary-precision arithmetic to keep every digit accurate, no matter how many hundreds (or thousands) of digits the number is.
BigInt is a JavaScript primitive type (introduced in ES2020) for arbitrary-precision integers. Unlike the regular Number type — which uses IEEE 754 doubles and is only exact up to 2⁵³ − 1 — BigInt can represent any integer no matter how many digits, with full precision for every arithmetic operation.
IEEE 754 double-precision floats have 53 bits of mantissa — that's about 15-17 significant decimal digits and a maximum exact integer of 2⁵³ − 1 = 9,007,199,254,740,991. Anything beyond rounds to the nearest representable value. For exact integer arithmetic on numbers with 20+ digits — including cryptography, combinatorics, and number theory — you need arbitrary precision.
100! is the product 1 × 2 × 3 × … × 100. The exact value is 93,326,215,443,944,152,681,699,238,856,266,700,490,715,968,264,381,621,468,592,963,895,217,599,993,229,915,608,941,463,976,156,518,286,253,697,920,827,223,758,251,185,210,916,864 × 10²⁴ — a 158-digit number ending in 24 zeros (because 100! has 24 factors of 5 from 5, 10, 15, …).
Big-number arithmetic powers public-key cryptography (RSA uses 2048-bit primes ≈ 617 decimal digits), digital signatures, blockchains and cryptocurrency, combinatorics (n! quickly overflows), scientific computation, and any code that needs exact integer answers beyond double-precision range.
Integer (or floor) division discards the fractional part and returns the largest integer ≤ the true quotient. For example, 17 ÷ 5 = 3 (not 3.4) and −17 ÷ 5 = −4 (rounding toward negative infinity). The remainder is captured by the mod operation: 17 mod 5 = 2. BigInt only supports integer division — fractions are not representable.
The greatest common divisor of two integers is the largest positive integer that divides both. GCD is computed efficiently by the Euclidean algorithm: GCD(a, b) = GCD(b, a mod b), repeated until b = 0. The remaining a is the GCD. This algorithm works in O(log(min(a,b))) steps even for thousand-digit BigInts.
The Fibonacci mode supports n up to 10,000. F(10,000) has about 2,090 digits. Computation uses iterative BigInt addition (a + b → b, b → a) so it stays exact and is computed in just a few milliseconds.
BigInt's ** operator raises A to the power B for non-negative integer B. Internally it uses fast exponentiation by repeated squaring: O(log B) multiplications instead of O(B). So 2¹⁰⁰⁰ takes just 10 multiplications of growing BigInts — still finishing in milliseconds.
Yes — BigInt supports any sign. Just prefix the input with a minus sign: −1234. All arithmetic operations (including mod) follow the usual mathematical rules for signed integers. The power operation, however, only accepts a non-negative exponent for BigInt — negative exponents would produce a fraction.
BigInt is significantly slower than Number for small values — perhaps 10× to 50×. But for large values it scales much better: multiplying two thousand-digit BigInts takes milliseconds, while doing the same with Number is simply impossible (it would silently lose precision). For everyday cryptography and combinatorics, BigInt is fast enough by far.
Yes — click the Copy button at the top right of the result card. The full numeric string (every digit) is copied to your clipboard, ready to paste into a programming environment, spreadsheet, or another calculator. The text is plain ASCII digits, so it can be parsed by any tool that handles arbitrary-length integers.