Big Number Calculator - Exact Integer Arithmetic

A big number calculator (also called an arbitrary-precision integer calculator or BigInt calculator) performs addition, subtraction, multiplication, integer division, exponentiation, and modulo on whole numbers that ordinary pocket calculators and JavaScript Number values cannot store exactly. Every digit of the answer is kept. There is no floating-point rounding and no silent conversion to scientific notation.

JavaScript’s IEEE-754 double can represent every integer from −2⁵³ + 1 through 2⁵³ − 1, which is 9,007,199,254,740,991 (Number.MAX_SAFE_INTEGER). One step past that bound, 9007199254740993 is stored as 9007199254740992. Spreadsheets, JSON parsers, and many “scientific calculator” widgets share the same ceiling. If you add two 20-digit account IDs, multiply two 40-digit combinatorial counts, or raise 2 to a few hundred, you need a type that stores digits, not a 53-bit mantissa.

This free online big integer tool uses the browser’s native BigInt. Nothing is uploaded. Commas and spaces are stripped so you can paste numbers copied from a textbook. Decimals are rejected on purpose: mixing a binary floating-point fraction with an 8000-digit integer would pretend to be exact while quietly rounding. If you only need a compact display of magnitude, use the scientific notation calculator instead - that page rewrites scale as a × 10ⁿ; this page keeps every digit of the integer.

Using this arbitrary-precision integer calculator is straightforward:

1. Enter integer A in the first field. You may include a leading minus. Commas such as 1,000,000 and internal spaces are removed before parsing.
2. Choose the operation: add, subtract, multiply, divide (integer quotient plus remainder), power (A raised to B), or modulo.
3. Enter integer B. For power, B is the exponent and must be a non-negative integer. For divide and modulo, B must not be zero.
4. The result updates as you type. You can also press Calculate. Copy the full digit string, or use Clear All to start over. The last inputs are stored in this browser for up to 30 days.

Note: each operand and the printed result are limited to about 8000 digits. Power is refused when a length estimate shows the expansion would exceed that cap (for example 99⁹⁹⁹⁹). Negative exponents are not accepted because the output would be a fraction.

Each operation below is the schoolbook integer rule, implemented with JavaScript BigInt. The calculator does not round, and it does not switch to floating point in the middle of a product.

Example - add: 999999999999999999 + 1

• A pocket calculator or Number cannot hold 10¹⁸ − 1 as an exact integer past the 16th digit.
• BigInt addition carries through every place: the sum is 1000000000000000000 (19 digits, a 1 followed by 18 zeros).

Example - multiply: 123456789 × 987654321

• Digit length of a product is roughly the sum of the lengths of the factors (minus at most 1).
• Exact product: 121932631112635269. No scientific-notation rounding of the middle digits.

Example - divide: −17 ÷ 5

• JavaScript BigInt division truncates toward zero: quotient −3, remainder −2, because −17 = (−3) × 5 + (−2).
• The Euclidean remainder (always ≥ 0) is 3, because −17 = (−4) × 5 + 3. Both values are shown so you can match either convention.

Example - power: 2¹⁰ = 1024

• Exponentiation uses binary exponentiation (square and multiply), checking digit length after each multiply so a runaway power cannot freeze the tab.
• 2¹⁰⁰ is 31 digits: 1267650600228229401496703205376. 99⁹⁹⁹⁹ is refused because the result would be thousands of digits past the display cap.

Example - modulo: 17 mod 5 = 2

Modulo uses the same remainder as JavaScript A % B: the sign follows A, and B = 0 is an error. For a non-negative residue when A is negative, read the Euclidean remainder from a divide of the same pair.

6.02 × 10²³ is a useful way to write Avogadro’s number, but it is not the exact integer 602,214,076,000,000,000,000,000. If a homework problem asks for the exact product of two hundred-digit integers, scientific notation would hide most of the digits. Use this calculator when the full integer is the answer. Use the scientific notation calculator when the assignment wants a × 10ⁿ. If you need the prime-power shape of a (much smaller) integer, factor it with the prime factorization calculator.

For positive A and B, schoolbook division is unambiguous: 17 = 3 × 5 + 2. Once a sign appears, programming languages disagree. JavaScript, C, and C# truncate the quotient toward zero. Python’s // floors toward −∞, so -17 // 5 is −4 and -17 % 5 is 3. Number-theory texts usually want the Euclidean remainder in {0, 1, …, |B| − 1}.

This page follows JavaScript for the primary quotient and remainder because the implementation is JavaScript BigInt. It also prints the Euclidean remainder so you can copy the residue that matches a discrete-math textbook. The identity A = quotient × B + remainder always holds for the JS pair. The Euclidean pair uses a possibly different quotient (not printed) that floors instead of truncating.

Modulo on this page is the JS remainder, not a guaranteed non-negative residue. If you need a residue in 0 … |B|−1 for a negative A, run divide instead of modulo and copy the Euclidean line.

JavaScript BigInt can theoretically grow until memory runs out. Printing a million-digit integer into a web page, or multiplying two 100,000-digit operands, will stall the tab. The cap of about 8000 digits is a practical limit so the UI stays usable: that is still far past any 64-bit integer (20 digits) and past typical homework RSA moduli.

Multiplication of two already-huge operands is estimated before it runs: if the sum of digit lengths minus one exceeds 8000, the product is refused rather than computed and then thrown away. Power uses a similar estimate: roughly exponent × (digit length of |base|). That overestimates for bases such as 2 (because log₁₀ 2 is 0.30, not 1), so some powers that would actually fit are still rejected. That is intentional. Expanding 2²⁰⁰⁰⁰ is cheap; expanding 99⁴⁰⁰⁰ is not. The exponent itself is also refused above 100,000 when |base| > 1.

0⁰ is treated as 1, matching JavaScript 0n ** 0n. 0ⁿ for n > 0 is 0. Negative bases are allowed for integer exponents; the sign of a negative base to an odd power stays negative.