Big Number Calculator

Add, subtract, multiply, divide and more with very large or very precise numbers, keeping every digit exact and choosing how many decimal places to show.

Check your inputs—Complete valid inputs to calculate a current result.

Up to 2,000 digits, including decimals or e notation. Do not use comma separators.

Round to nearest; ties away from zero. Trailing zeros are removed.

Result

9007199254740994

    Powers require integer Y from −1,000 to 1,000. Factorials accept integers from 0 to 2,000. Modulo returns a nonnegative residue using |Y|. GCD(0,0) and LCM with a zero operand return 0. Working values are limited to 10,000 digits; operations exceeding that limit show an error. Share links include these numeric inputs.

    How this was calculated

    1. Read each number exactly, digit by digit, using whole-number arithmetic. Every digit you typed is kept, so nothing is rounded off along the way. A normal calculator keeps only about 15 to 17 digits.
    2. Apply the selected operation, then round to at most 30 decimal places. A number exactly halfway rounds away from zero.X + YPut in your numbers: 9007199254740993 + 1Answer: 9007199254740994

    Big numbers in simple words

    A normal calculator keeps only about 15 to 17 digits. If a number is longer, the last digits get rounded off, so the answer can be slightly wrong.

    This calculator works on the digits themselves, the way you would with pencil and paper. It keeps every digit, so even very long numbers stay exact.

    Example: 9,007,199,254,740,993 + 1. A typical computer number cannot hold the first number exactly and turns it into 9,007,199,254,740,992. Here the answer is exactly 9,007,199,254,740,994.

    It can also find powers like 2¹⁰⁰, a 31-digit number, and factorials like 50! (1 × 2 × 3 × … × 50), which has 65 digits.

    Preserve significant digits

    Inputs are parsed as decimal strings and processed with integer arithmetic, preserving digits beyond JavaScript’s ordinary safe-integer range. For example, 9007199254740993 + 1 returns 9007199254740994.

    Enter decimals or scientific notation such as 2.5e20. Each input allows up to 2,000 digits, with a scientific-notation exponent from −1,000 to 1,000. Comma separators and nondecimal bases are not accepted.

    Precision and supported operations

    Choose 0 to 100 maximum decimal places. Results round to nearest with exact ties away from zero, and unnecessary trailing zeros are removed. For example, 1 ÷ 8 at two decimal places returns 0.13; −1 ÷ 8 returns −0.13.

    Addition, subtraction, multiplication, division and squares accept decimals. Powers require an integer exponent from −1,000 to 1,000, including reciprocal powers. Square roots return real nonnegative results. Factorials accept integers from 0 to 2,000; 0! equals 1.

    Integer conventions and practical limits

    Modulo, GCD and LCM require integers. Modulo uses the absolute divisor and returns a nonnegative residue: −7 modulo 3 is 2. GCD(0,0) returns 0 by this tool’s convention; an LCM with a zero operand is 0. Division and modulo by zero show errors, as do 0⁰ and negative real square roots.

    Working values are limited to 10,000 digits. Powers that exceed that limit show an error instead of freezing the page or silently approximating. This is not an unlimited symbolic algebra system: fractional powers and complex roots are outside its scope. Numeric inputs are included in shared calculation links.

    Modulo with negative numbers

    Every modulo result satisfies x = q × y + r. The conventions differ in how q is rounded when an input is negative. This calculator returns the Euclidean residue, 0 ≤ r < |y|: −7 mod 3 = 2, since −7 = (−3) × 3 + 2.

    Truncated division (the % operator in JavaScript, C and Java) rounds q toward zero, so −7 % 3 = −1 because −7 = (−2) × 3 + (−1). Floored division (Python’s %, spreadsheet MOD) rounds q down, giving r the sign of the divisor: 7 mod −3 = −2. Modulo mode shows all three identities.

    Large powers: repeated squaring, digit count and scientific notation

    Power mode computes x^y by repeated squaring. Write y in binary, square x repeatedly to get x¹, x², x⁴, x⁸ …, then multiply the squares whose binary digit is 1. For 2¹⁰⁰, 100 = 64 + 32 + 4 = 1100100₂, so 2¹⁰⁰ = 2⁶⁴ × 2³² × 2⁴: six squarings and two multiplications instead of 99.

    The result panel also gives the digit count of the integer part and scientific notation to 15 significant figures, both computed from the exact value. 2¹⁰⁰ = 1,267,650,600,228,229,401,496,703,205,376 has 31 digits, about 1.26765060022823 × 10³⁰. A negative exponent is the reciprocal: 2⁻¹⁰ = 1 ÷ 1,024 = 0.0009765625, which terminates after exactly 10 decimal places.

    Frequently asked questions

    Are decimals converted to binary floating point?

    The significant digits are not. The engine stores an integer coefficient and decimal scale, and performs rounding with integer arithmetic.

    Can I calculate a fractional power?

    Power mode requires an integer exponent. Use the square-root mode for a real square root.

    Why are trailing zeros removed?

    The precision field sets a maximum number of decimal places, not a fixed-width display. An exact whole-number result remains a whole number.

    References

    Last updated . Results are estimates for informational purposes only.