What arbitrary-precision arithmetic actually is
Every ordinary calculator, spreadsheet cell and plain JavaScript number stores a value as a 64-bit float, a format built to hold a huge range of numbers in a fixed amount of space by keeping only so many significant digits and tracking the rest with an exponent, much like scientific notation does. That works well for measurements and everyday sums, but it has a hard ceiling for whole numbers: a float can represent every integer up to 253 exactly, and no further. Arbitrary-precision arithmetic, the kind this calculator runs on, drops the fixed-size format entirely and stores a whole number as its actual string of digits, however many there are, so there is no ceiling to hit and nothing gets rounded off. In plain terms: it does sums the way you would on paper, one digit column at a time, rather than borrowing a fixed-size box built for a different job.
Where an ordinary calculator starts guessing: the 253 ceiling
The number 253 is 9,007,199,254,740,992. A 64-bit float can represent that value, and every whole number below it, exactly. One step further and the format runs out of room: 253 + 1 needs 54 bits to store precisely, and a float only has 53 to spend on its digits, so it rounds the result back down to the nearest number it can represent, which is 253 itself. Ask a spreadsheet or a plain JavaScript sum for 9007199254740992 + 1 and, depending on how it is displayed, it can quietly hand back 9007199254740992 again, the +1 simply absorbed. This calculator works from the digit string itself rather than a float, so 253 and 253 + 1 stay two different, exact numbers, as the demonstration above shows working live. This is also why JavaScript defines Number.MAX_SAFE_INTEGER as 253 − 1: the largest whole number below which ordinary addition and subtraction are still guaranteed to behave.
Where genuinely big numbers turn up
Public-key cryptography is the clearest everyday example: an RSA-2048 key is built from a number 2,048 bits long, which works out to a 617-digit decimal figure, a size chosen specifically because factorising it back into its two secret prime numbers is currently far beyond any computer's reach. Combinatorics is another: the number of ways to shuffle a standard deck of 52 playing cards is 52!, which comes out to roughly 8.0658×1067, a number so far past the count of atoms in the solar system that no shuffle in history has plausibly repeated. Astronomy and long-run financial modelling brush up against the same wall from the other side: compounding a small rounding error over trillions of steps, or tracking distances in kilometres across a galaxy, is exactly the kind of arithmetic where a float's rounding quietly compounds into a real error, and exact integer arithmetic (or at least knowing where the float ceiling sits) matters.
Why division gives a quotient and a remainder
Whole numbers are a closed system under addition, subtraction and multiplication: add, subtract or multiply two integers and the answer is always another integer. Division breaks that pattern the moment it does not divide evenly, so working purely in integers means splitting the answer into two integers instead of one decimal: the quotient, how many whole times B fits into A, and the remainder, whatever is left over afterwards. The two are tied together by one identity that always holds exactly, which this calculator checks and shows on every division:
13 divided by 4 is a quotient of 3 and a remainder of 1, since 3 × 4 + 1 = 13. This calculator's quotient truncates toward zero and its remainder takes the same sign as A, the same convention most programming languages use; the separate Mod operation instead always returns a value from 0 up to one less than B, whichever sign A had to begin with, the convention usually meant by "clock arithmetic".
Finding the GCD with Euclid's algorithm
The greatest common factor (or divisor) of two whole numbers is the largest number that divides both exactly. Euclid's algorithm finds it without ever listing a single factor: divide the larger number by the smaller, keep the remainder, then repeat with the smaller number and that remainder, over and over, until the remainder reaches zero. Whatever was divided by last is the GCD.
It converges remarkably fast even for enormous numbers, typically in well under a hundred steps for hundred-digit inputs, which is exactly why it is still the standard method more than two thousand years after it was first written down. GCD(123456789012345678901234567890, 987654321098765432109876543210), for instance, resolves to 9000000000900000000090 in a handful of steps, not by ever testing a single candidate factor.
Raising a big number to a power, and the factorial mini-tool
The Power operation raises A to the whole-number exponent typed into B, exactly, up to a 10,000-digit result before the calculator switches to an accurate logarithmic estimate rather than trying to build an unusably long integer. For negative or fractional exponents, or for roots, the Exponent Calculator on this site covers that ground instead. Factorial is the classic way a small number turns into a big one fast: n! multiplies every whole number from 1 up to n together, so it grows far quicker than a power of a fixed base does. 100! runs to 158 digits, starting 9.33262×10157; 5,000!, the cap used here to keep the result instant, runs past 16,000 digits.
Reading digit count and scientific notation
Every result here comes with its exact value in full (grouped every three digits with a thin space and kept in a scrolling, copyable box once it runs long), its digit count, and a scientific-notation approximation built from the first six significant digits of that same digit string, so it stays accurate even once a number is far too long for ordinary scientific notation on a calculator to represent precisely. The Scientific Notation Calculator covers converting and operating on numbers already written that way in more depth.
Questions people ask
How many digits can this calculator handle?
Up to 10,000 significant digits for each of A and B, and up to a 10,000-figure exponent for Power (with the exact result itself computed up to 20,000 digits before switching to an accurate estimate). The factorial mini-tool covers n up to 5,000.
Why does a normal calculator get big sums wrong?
Because it stores numbers as 64-bit floats, which can only hold a whole number exactly up to 253 (9,007,199,254,740,992). One step further, at 253 + 1, there is no room left to store the extra 1 precisely, so it gets rounded away. This calculator reads and computes on the actual digit string instead, so that ceiling never applies.
What is the difference between the divide operation and mod?
Divide shows both the quotient and the remainder from ordinary division, with the remainder taking the same sign as A. Mod shows only the remainder, but always adjusted to sit between 0 and one less than B, regardless of either number's sign, the convention usually meant by "clock arithmetic".
How does Euclid's algorithm find the GCD so quickly?
By repeatedly replacing the larger number with the remainder of dividing it by the smaller one, instead of testing candidate factors one by one. Each step shrinks the numbers fast, so even hundred-digit inputs typically resolve in well under a hundred steps, a method first written down over two thousand years ago and still the standard approach.
Can this calculator raise a number to a negative or fractional power?
No, the Power operation here is whole numbers only, base and exponent both, since that is what keeps arbitrary-precision integer arithmetic exact. For negative or fractional exponents, or for roots, use the Exponent Calculator.
Where do numbers this big actually come up in real life?
Cryptography is the clearest case: an RSA-2048 encryption key is a 617-digit number. Combinatorics is another, such as the roughly 8.0658×1067 ways to shuffle a deck of 52 cards. Long-running scientific and financial calculations also rely on knowing exactly where ordinary floating-point rounding starts to matter.
Why is the result sometimes shown as an estimate instead of the exact value?
Only for the Power operation, and only once the true result would run past 20,000 digits. Rather than trying to build an integer that long, the calculator works out an accurate scientific-notation estimate from logarithms of the leading digits instead, and says plainly that it has done so.
Every result here is exact integer arithmetic computed with JavaScript's built-in BigInt type, never a floating-point approximation, except for the one stated case (a Power result above the 20,000-digit cap), which is clearly marked as an estimate. For powers, negative exponents or roots, try the Exponent Calculator; for numbers already written in scientific form, try the Scientific Notation Calculator on this site.