Big Number Calculator

A large number calculator, also called a big integer calculator or arbitrary precision calculator, is useful whenever the digits themselves matter: checking a 30-digit product, writing out 100! in full, testing where a program's 64-bit integers overflow, or carrying a division to 200 decimal places. This page explains why ordinary tools fall short and how exact arbitrary-precision arithmetic avoids the problem.

Why ordinary calculators lose digits

Almost every calculator app, spreadsheet and programming language stores numbers in the IEEE 754 double-precision format, the format the ECMAScript standard prescribes for JavaScript's Number type. A double holds 53 bits of significand, which is about 15 to 17 significant decimal digits. Everything beyond that is rounded away without a warning:

For a monthly budget those errors are harmless. For cryptography, combinatorics, ID numbers longer than 15 digits, or any result you want to quote to the last digit, they are not. The calculator above shows the floating-point answer next to the exact one so you can see where the two part ways.

How exact big-number arithmetic works

In whole-number mode every value is a BigInt, which the ECMAScript specification describes as an integer that "may be any size and is not limited to a particular bit-width". Addition, subtraction and multiplication are exact by definition; division returns the quotient truncated toward zero plus the remainder, so nothing is lost. Factorials use a binary-splitting product, multiplying 1 × 2 × … × n as a balanced tree of partial products, which computes 20,000! in a fraction of a second.

In decimal mode the page works as a high precision calculator. It stores each number as an integer plus a count of decimal places: 3.14159 becomes 314159 with 5 places. Sums and products of such numbers are again exact integers with a known number of places. Only division, negative powers and square roots can produce endless digits, and those are carried to the number of places you choose and rounded half away from zero, so 2 ÷ 3 at 20 places ends in 7.

Worked example 1: 2¹⁰⁰ and 2¹⁰⁰⁰

Enter A = 2, B = 100 and choose A^B:

The result has 31 digits and a digit sum of 115, and its scientific form is 1.2676506 × 10³⁰. A standard calculator shows 1.2676506002282294e+30, and tools that write the number out in full pad it with zeros after the 17th digit: 1,267,650,600,228,229,400,000,000,000,000. Raise the exponent to 1,000 and the exact answer grows to 302 digits, 1.071508607 × 10³⁰¹, with a digit sum of 1,366, a classic programming exercise. You can predict the length before computing: digits = ⌊B × log₁₀ A⌋ + 1 = ⌊1,000 × 0.30103⌋ + 1 = 302.

Worked example 2: 100! with every digit

Enter A = 100 and choose A!. The calculator returns all 158 digits:

The last 24 digits are zeros. Each trailing zero needs a factor of 10, that is a 5 paired with a 2, and fives are the scarcer factor: 100 ÷ 5 = 20 multiples of 5, plus 100 ÷ 25 = 4 numbers that contribute a second five, gives 24 (Legendre's formula). The digit sum is 648 and the scientific form is 9.332621544 × 10¹⁵⁷. A double shows 9.33262154439441e+157, and from 171! on it overflows to Infinity, while this calculator continues to 20,000!.

Famous big numbers, computed exactly

Every value in this table was computed with the same exact arithmetic the calculator uses, so you can reproduce each row:

2⁶⁴ is one more than the largest unsigned 64-bit integer, the ceiling of many databases and file systems. A googol has only one nonzero digit, while 10000! needs 35,660 digits, more than 350 googols' worth of length.

Division, remainders, modulo, GCD and LCM

Long division of big integers returns two exact results. For example:

The calculator checks itself by showing B × quotient + remainder, which must give back A; a double would print the quotient as 124999998873437500000. With negative numbers the conventions split. Truncated division, used by JavaScript, C and Java, gives −7 ÷ 2 = −3 remainder −1; floor division gives −4 remainder 1. The modulo operation always returns a value from 0 to |B| − 1, so −7 mod 3 = 2, and modular arithmetic on huge powers works too: 2¹⁰⁰ mod 1,000,000,007 = 976,371,285.

The greatest common divisor uses Euclid's algorithm on the exact integers. GCD(2⁶⁴ − 1, 2⁴⁸ − 1) = 65,535, which is 2¹⁶ − 1 (16 is the GCD of the exponents), and the least common multiple is 79,229,371,458,530,696,292,133,175,295.

Worked example 3: decimals that floating point gets wrong

Switch to Decimals and the same numbers behave the way you learned in school:

• 0.1 + 0.2 = 0.3 exactly (a double gives 0.30000000000000004).
• 1.1 × 1.1 = 1.21 exactly (a double gives 1.2100000000000002).
• 1 − 0.9 = 0.1 exactly (a double gives 0.09999999999999998).
• 1 ÷ 7 at 60 places = 0.142857 repeated ten times, flagged as rounded because the true expansion never ends.

Powers show the difference most clearly. At 40 places, 1.0001¹⁰⁰⁰⁰ = 2.7181459268252248640376646749131465361138, while a double returns 2.7181459268249255, wrong from the 13th significant digit because the tiny storage error in 1.0001 is multiplied ten thousand times. The value is close to e = 2.71828…, since (1 + 1/n)ⁿ approaches e as n grows.

Worked example 4: the square root of 2 to 50 places

To compute √2 to 50 places, the calculator finds the integer square root of 2 × 10¹⁰⁰ with Newton's method:

The digits after the 50th place begin with 8, so the last digit is rounded up from 4 to 5. Each Newton step roughly doubles the number of correct digits, which is why 1,000 places take milliseconds; the 1,000-place result matches the published decimal expansion of √2 (OEIS A002193) digit for digit. A double stops at 1.4142135623730951.

How to use this calculator

Pick Whole numbers for exact integer work or Decimals for numbers with a fractional part. Type or paste A and B; spaces and underscores are ignored, commas may group thousands (1,234,567), and e-notation such as 1e50 or 2.5e-8 works. Choose the operation; factorial and square root use only A. In decimal mode, set the number of decimal places (0 to 1,000) or tap a preset. The result card shows the full result with optional digit grouping, the digit count, the scientific notation and, for integers, the digit sum and trailing zeros. A copy button puts the plain digits on your clipboard, and the details card adds remainders, the LCM and the floating-point comparison.

Who this calculator is for

Programmers use it to check overflow boundaries such as 2⁶³ − 1 and to verify big-integer code. Students of number theory and cryptography work with modular arithmetic on numbers far beyond a phone calculator's range, and puzzle solvers compute digit sums of huge powers and factorials. Teachers demonstrate floating-point rounding with 0.1 + 0.2, and anyone handling long identifiers can multiply or compare them without losing digits.

Key terms

• Arbitrary precision: arithmetic whose number length grows as needed instead of being fixed in advance.
• BigInt: JavaScript's built-in integer type of unlimited size.
• Floating point (double): the 64-bit format with about 15 to 17 significant digits used by ordinary calculators.
• Significant digits: the digits from the first nonzero digit onward.
• Remainder and modulo: what is left after integer division; modulo is never negative for a positive divisor.
• Digit sum: the sum of all decimal digits of a number.

Accuracy, limits and tips

Whole-number results are always exact. Decimal results are exact for addition, subtraction, multiplication and positive powers, and otherwise correctly rounded at the last place you asked for, so the precision setting is what changes a decimal answer. To keep the page responsive, inputs are capped at 20,000 digits, results at 100,000 digits, factorials at 20,000! and GCD inputs at 10,000 digits; a power is checked with the digit formula before it runs, so 2^1,000,000 (301,030 digits) is refused with a clear message instead of freezing the tab. Use e-notation to type long round numbers, and remember that in the U.S. format a comma separates thousands, never decimals.

Related calculators

• To convert results to and from powers of ten, use the Scientific Notation Calculator.
• For factorials with step-by-step products, use the Factorial Calculator.
• For exponent rules, negative and fractional powers, use the Exponent Calculator.
• For remainders of everyday-sized numbers, use the Modulo Calculator.

Sources

• Ecma International, ECMAScript Language Specification (ECMA-262), §6.1.6.1 The Number Type: Number values are IEEE 754-2019 binary64 doubles.
• Ecma International, ECMA-262, §6.1.6.2 The BigInt Type: integers of any size, with division truncated toward zero.
• OEIS Foundation, A002193, decimal expansion of the square root of 2, used to verify the 1,000-place square root.
• NIST, Digital Library of Mathematical Functions, §4.4: the limit (1 + 1/n)ⁿ → e (eq. 4.4.18).