Compute huge powers exactly — raise any base to a large exponent with full-precision BigInt arithmetic, digit counts, and scientific notation. Free, fast, and mobile-friendly.
Home » Math Calculators » Large Exponents Calculator
What is 2 raised to the 100th power? Your phone calculator will either show an error or a rounded approximation like 1.2676506e+30 — close, but not exact, and useless if you need every digit. Our free Large Exponents Calculator computes huge powers with exact integer arithmetic, delivering all 31 digits of 2^100 (1,267,650,600,228,229,401,496,703,205,376) with zero rounding error.
Large exponents appear in surprising places. Cryptography builds keys from numbers with hundreds of digits; combinatorics counts possibilities like chess positions (≈ 10^120) or password combinations; computer science measures memory in powers of 2 (a 64-bit address space holds 2^64 values); and puzzles like the wheat-and-chessboard legend turn on exactly this kind of explosive growth. Ordinary calculators give up around 10^308, but exact integer math has no such ceiling.
The tool accepts any whole-number base and exponents up to 100,000, using binary exponentiation under the hood for speed. Results show the exact value for manageable sizes, switch to scientific notation with a digit count for giants, and explain the method — so you get both the answer and the understanding.
Most calculators and programming languages store numbers as 64-bit floating-point values (doubles), which carry about 15–16 significant decimal digits and max out near 1.8 × 10^308. Ask for 2^1000 and you get 1.071509e+301 — the magnitude is right, but the last 285 digits are simply gone, replaced by an exponent. For cryptography, exact combinatorics, or Project-Euler-style puzzles, those missing digits are the entire point.
BigInt arithmetic solves this by storing integers as arbitrary-length sequences of machine words instead of fixed-size floats. There is no rounding because there is no approximation: 2^100 computed with BigInts is the exact 31-digit integer, digit for digit. The only limit is memory and time — and with an efficient algorithm, even 2^100000 (30,103 digits) computes in a blink.
That efficient algorithm is binary exponentiation (exponentiation by squaring). Instead of multiplying by the base e times, it squares repeatedly: to compute b^100, write 100 in binary (1100100), and combine the squares b^1, b^4, b^32, b^64. This needs only about log₂(e) multiplications instead of e — for e = 100,000, that is 17 multiplications instead of 100,000. The calculator implements exactly this loop.
There is a beautiful side result worth knowing: the number of digits of b^e is ⌊e · log₁₀(b)⌋ + 1. So 2^100 has ⌊100 × 0.30103⌋ + 1 = 31 digits, and 7^1000 has ⌊1000 × 0.8451⌋ + 1 = 846 digits. The calculator reports the digit count for every result, which is often the most useful single fact about a giant power.
b^e = b × b × … × b (e times) | b^m × b^n = b^(m+n) | (b^m)^n = b^(m×n) | digits(b^e) = ⌊e·log₁₀(b)⌋ + 1
Binary exponentiation computes b^e in about log₂(e) multiplications by squaring: b^100 = b^64 × b^32 × b^4, since 100 = 64 + 32 + 4.
Repeated doubling 100 times gives 1,267,650,600,228,229,401,496,703,205,376 — exactly 31 digits, matching ⌊100 × log₁₀(2)⌋ + 1 = ⌊30.103⌋ + 1 = 31. A double-precision calculator shows 1.2676506002282294e+30, correct to 16 digits; the BigInt result is correct to all 31.
10^50 = 100,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000,000 — a 1 followed by 50 zeros, 51 digits total. Powers of 10 are the one case where the digit count is obvious, and they calibrate intuition: every additional factor of 10 appends one digit.
7^7 = 823,543 (6 digits) — small enough to verify by hand with patience. But 7^70 explodes to 59 digits: 143,503,601,609,868,041,428,468,899,332,536,698,356,356,263,104,007. The exponent grew 10× while the digits grew roughly 10× too — exponential growth is relentless, which is why the digit-count formula is so handy.
2^1000 has 302 digits, beginning 10715086071862673209… and ending …548864000. No pocket calculator can show this exactly — doubles run out of precision at 2^53 for integers. The calculator’s BigInt engine returns every one of the 302 digits correctly.
Password security is pure exponentiation. An 8-character password drawn from 94 keyboard symbols has 94^8 ≈ 6.1 × 10^15 possibilities — about 6 quadrillion. At a billion guesses per second, brute-forcing it takes ~70 days. Add just 4 more characters (94^12 ≈ 4.75 × 10^23) and the same attack needs 15 million years. The calculator lets you feel this cliff directly: bump the exponent by a few and watch the digit count jump.
The wheat-and-chessboard legend asks for 1 grain on the first square, 2 on the second, 4 on the third, doubling to the 64th: the total is 2^64 − 1 = 18,446,744,073,709,551,615 grains — about 18.4 quintillion, more wheat than humanity has ever grown. Computing 2^64 exactly is the punchline the legend needs, and it is the kind of result floating-point arithmetic mangles.
In computing, address spaces are powers of 2: IPv4’s 2^32 ≈ 4.29 billion addresses ran out (hence IPv6’s 2^128 ≈ 3.4 × 10^38), and a 256-bit encryption key offers 2^256 ≈ 1.16 × 10^77 possibilities — more than the atoms in the observable universe squared. Whenever someone quotes these astronomical figures, a large-exponent calculator is how you verify them.
The naive way to compute b^e multiplies b by itself e times — 100,000 multiplications for b^100000. Binary exponentiation instead reads the exponent’s binary digits. Write e in binary, then scan the bits from most significant to least, maintaining a running result r: for each bit, square r, and if the bit is 1, multiply r by b. Each bit costs at most two multiplications, so e = 100,000 (17 bits) needs at most 34 multiplications of big integers.
Concretely, 2^13: 13 in binary is 1101. Start r = 1. Bit 1: r = 1² × 2 = 2. Bit 1: r = 2² × 2 = 8. Bit 0: r = 8² = 64. Bit 1: r = 64² × 2 = 8192 = 2^13. Four bits, seven multiplications, versus twelve by the naive route. The savings grow with the exponent: for cryptographic 2048-bit exponents, binary exponentiation needs ~3000 multiplications instead of 10^616.
This algorithm is also the engine inside RSA encryption, Diffie-Hellman key exchange, and primality testing — everywhere a computer raises huge numbers to huge powers modulo something. The calculator runs the same loop (without the modulo step), so playing with it is a genuine glimpse into how internet security does arithmetic.
3^50 = 717,897,987,691,852,588,770,249 — 24 digits. Check with the formula: ⌊50 × log₁₀(3)⌋ + 1 = ⌊50 × 0.4771⌋ + 1 = ⌊23.856⌋ + 1 = 24. The digit formula never lies, and it is instant mental math with log₁₀(3) ≈ 0.477 memorized.
99^99 has ⌊99 × log₁₀(99)⌋ + 1 = ⌊99 × 1.9956⌋ + 1 = 198 digits, beginning 36972963764972677265… A double can only hint at it (3.697296376497268e+197); the exact integer is what combinatorics problems demand.
One more gem: for base 2, the digit count grows by exactly 1 every time the exponent passes a multiple pattern — 2^10 ≈ 10^3 (1024 ≈ 1000), so 2^100 ≈ 10^30, and the true count 31 follows. Computer scientists memorize “2^10 ≈ 10^3” because it converts bits to decimals instantly: a 64-bit number holds about 19 decimal digits (64/10 × 3 ≈ 19.2), which is why 2^64 − 1 = 18,446,744,073,709,551,615 has 20 digits.
How many digits does 5^200 have? (Hint: use ⌊e·log₁₀(b)⌋ + 1 with log₁₀(5) ≈ 0.6990, then verify with the calculator.)
A 12-character password uses 62 symbols (a–z, A–Z, 0–9). How many possibilities is that, and how long would a trillion-guesses-per-second attack take?
The legend promises the inventor of chess one grain of wheat on the first square, two on the second, four on the third, doubling across all 64 squares. The total is 2^1 + 2^2 + … + 2^64 = 2^65 − 2 grains — wait, careful: starting at 2^0 = 1 on square one, the last square holds 2^63 and the total is 2^64 − 1 = 18,446,744,073,709,551,615.
At ~25 mg per grain, that is roughly 461 billion metric tons of wheat — over a thousand years of current global production. The emperor’s “modest” reward bankrupts the kingdom, and the exact integer (not a rounded 1.8e19) is what makes the story’s arithmetic airtight. Type 2^64 into the calculator and see every digit.
Teachers love this legend because it weaponizes intuition against itself: each individual doubling feels small, but 64 of them shatter every estimate. It is the same shock behind compound interest, viral spread, and Moore’s law — exponential growth always outruns linear imagination.
The Large Exponents Calculator raises a base to a non-negative integer exponent (up to 100,000) using exact BigInt binary exponentiation, showing the full exact value for shorter results and scientific notation with a total digit count for huge ones, plus the method and digit-count formula ⌊e·log₁₀(b)⌋+1.
2^100 = 1,267,650,600,228,229,401,496,703,205,376 — exactly 31 digits. Ordinary calculators show the rounded 1.2676506e+30; this calculator returns every digit via exact integer arithmetic.
Phones store numbers as 64-bit floats with ~16 significant digits, so they display large results in scientific notation and discard the rest. Exact integer (BigInt) arithmetic keeps all digits.
302 digits. Use the formula ⌊e·log₁₀(b)⌋ + 1: ⌊1000 × 0.30103⌋ + 1 = 302. The calculator reports the digit count for every result.
A fast algorithm that computes b^e in about log₂(e) multiplications by squaring: it reads the exponent’s binary digits and squares/multiplies accordingly, instead of multiplying b by itself e times.
Not directly — it computes b^e for e ≥ 0. For a negative exponent, compute 1 ÷ b^|e| yourself: e.g. 2^(−3) = 1/8 = 0.125.
100,000. Beyond that the result would have tens of thousands of digits and the page would struggle to display it. 2^100000 alone has 30,103 digits.
No — bases like 1.5 use floating-point math (about 15–16 correct significant digits) because fractional powers are rarely whole numbers. Whole-number bases always get exact BigInt results.
This calculator follows the computing convention 0^0 = 1. In calculus, 0^0 is an indeterminate form whose limit depends on context — but for discrete math and programming, 1 is the standard value.
Cite this page as: Large Exponents Calculator. Sigma Calculator. Retrieved October 9, 2026, from https://sigmacalculator.net/math-calculators/large-exponents-calculator/
Last updated: October 9, 2026