Log Calculator — Any Base, ln, log10 & log2

How this log calculator works

Everything on this page comes from one identity: log_b(x) = y ⇔ b^y = x Read left to right it is a logarithm; read right to left it is a power. The four modes above are the same equation solved for its three different unknowns, plus a parser for whole expressions — so switching modes never changes the mathematics, only which letter you are looking for.

The value itself is computed by change of base, log_b(x) = ln(x) ÷ ln(b), which works for every valid base. Nothing is rounded until the moment a number is printed: the display-precision control changes the printed digits and nothing else. Everything runs in your browser — see the methodology section below for the numerical details and the verification.

What is a logarithm?

A logarithm answers one question: what exponent turns the base into this number? If 10³ = 1000, then log₁₀(1000) = 3. The logarithm is the exponent, nothing more exotic than that.

Because it is an exponent, a logarithm can be negative (when the argument is on the other side of 1 from the base), zero (only when the argument is 1) or fractional (most of the time — log₂(20) is not a whole number). The argument must be greater than 0, and the base must be greater than 0 and different from 1. Within those limits every real logarithm is defined, including the ones with a base between 0 and 1 that many calculators refuse.

Logarithms turn multiplication into addition and powers into products, which is why they show up wherever quantities are compared across many orders of magnitude rather than added up.

Log base 10: the common logarithm

The common logarithm has base 10 and is written log₁₀(x), or simply log(x) on most scientific calculators and in most engineering work. It answers “how many powers of 10 is this?”, which makes it the natural language for orders of magnitude: log₁₀(100) = 2, log₁₀(1000) = 3, log₁₀(0.001) = −3.

A useful reading: the whole-number part of a common logarithm tells you the size of the number, and the fractional part tells you where it sits between two powers of ten. log₁₀(400) ≈ 2.602 means 400 is between 10² and 10³, closer to the upper end. Select 10 in the base selector above to compute any of these; the base-10 column of the common-values table below answers the direct questions (log 2, log 5, log 6, …) at a glance.

Natural log (ln)

The natural logarithm has base e ≈ 2.718281828459045 and is written ln(x) — the same thing as log_e(x). It is the logarithm that calculus produces on its own: the derivative of ln(x) is 1/x, and e is the base for which continuous growth compounds at exactly 100% per unit of time. That is why ln appears in half-lives, interest, cooling, and every differential equation with proportional change.

ln(e) = 1 exactly, ln(1) = 0 exactly, and ln(x) is negative for 0 < x < 1. To compute a natural logarithm here, pick e (natural log) in the base selector, or type ln(7) in the expression mode. If you have a common log and want the natural log of the same number, multiply by ln(10) ≈ 2.302585 — the “log to ln” conversion is just change of base in disguise.

Log base 2: the binary logarithm

The binary logarithm, log₂(x), counts doublings: log₂(1024) = 10 because 2¹⁰ = 1024. It is the logarithm of computer science — bits needed to encode a value, depth of a balanced tree, comparisons in a binary search, entropy in bits.

Whole-number cases are worth memorising: log₂(1) = 0, log₂(2) = 1, log₂(4) = 2, log₂(8) = 3, log₂(16) = 4. Everything between them is fractional: log₂(3) ≈ 1.585, log₂(5) ≈ 2.322, log₂(6) ≈ 2.585, log₂(10) ≈ 3.322. This calculator marks the whole-number cases as exact and the others as approximate, and shows which two powers of 2 the answer falls between.

Calculate a logarithm in any base

Choose Custom in the base selector and type any base greater than 0 other than 1 — 3, 7, 1.5, 0.5, e, or a fraction such as 2/3. The mathematics does not privilege 10, e or 2; those are just the bases with dedicated buttons on physical calculators.

Two behaviours change with the base, and the calculator reports both. When b > 1 the logarithm increases: bigger arguments give bigger results, and arguments below 1 give negative results. When 0 < b < 1 the logarithm decreases: bigger arguments give smaller results, so log₀.₅(8) = −3 while log₀.₅(0.125) = +3. A fractional base is not an error — it is a perfectly ordinary logarithm running backwards.

Change-of-base formula

The change-of-base formula converts a logarithm in one base into a ratio of logarithms in another. The choice of the intermediate base k is free, which is exactly why a calculator with only LOG and LN keys can still produce a logarithm in any base: pick k = 10 and divide two common logs, or pick k = e and divide two natural logs. This page uses k = e.

So log₂(20) = ln(20) ÷ ln(2) = log₁₀(20) ÷ log₁₀(2) ≈ 4.321928094887 — the same answer either way. The formula also explains a shortcut worth knowing: log_b(x) = 1 ÷ log_x(b), because dividing by a logarithm is the same as inverting the roles of base and argument.

Antilog / inverse logarithm

The antilogarithm undoes a logarithm. If log_b(x) = y, then the antilog of y in base b is x = b^y. “Inverse log base 10” means 10^y; “inverse ln” means e^y. That is all the word antilog means — there is no separate function hiding behind it.

Use the Find argument (antilog) mode: choose the base, enter y, and the calculator returns x = b^y with the same steps and verification. Negative exponents give reciprocals (10⁻³ = 0.001), a zero exponent always gives 1, and a base between 0 and 1 flips the direction (0.5⁻³ = 8). When b^y falls outside the range a double-precision number can hold, the calculator says so explicitly with an overflow or underflow code rather than silently printing 0 or ∞.

Convert logarithmic form to exponential form

The two forms are the same statement written two ways, and converting between them is a matter of moving three symbols:

The base of the logarithm becomes the base of the power; the result of the logarithm becomes the exponent; the argument stays the argument. Every result on this page prints both forms, and the “Copy logarithmic form” and “Copy exponential form” buttons give you either one directly. Going the other way — exponential form to logarithmic form — is the same move in reverse: 2⁵ = 32 becomes log₂(32) = 5.

Solve for the base, argument or exponent

A logarithmic equation has three slots, and any one of them can be the unknown:

• Unknown exponent — log_b(x) = ? Use Find log.
• Unknown argument — log_b(?) = y. Use Find argument (antilog): the answer is b^y.
• Unknown base — log_?(x) = y. Use Find base: raise both sides to the power 1/y to get b = x^(1/y). For example log_b(81) = 4 gives b = 81^(1/4) = 3.

Solving for the base is the one that needs care, because b = x^(1/y) is not always valid. If x = 1 and y = 0 the equation is true for every valid base — infinitely many solutions, not one. If x = 1 and y ≠ 0 there is no solution at all, and the same is true when y = 0 with x ≠ 1. This calculator names each of those cases with its own code (NON_UNIQUE_SOLUTION, NO_SOLUTION) instead of quietly returning a number.

How to use log on a scientific calculator

Most scientific calculators give you two logarithm keys and expect you to derive the rest.

1. Common log (base 10) — the LOG key. Press LOG, enter the number, close the bracket if your model opens one, then press equals. LOG 1000 gives 3.
2. Natural log (base e) — the LN key, used the same way. LN 7 gives about 1.9459.
3. Any other base — use change of base. To get log₂(20), compute LN 20 ÷ LN 2 (or LOG 20 ÷ LOG 2). Both give ≈ 4.3219. Some newer models have a dedicated log_b(x) or “logab” entry that takes the base first; if yours does not, the division always works.
4. Check the answer by converting to exponential form: raise the base to the result and confirm you get the argument back. 2^4.3219 ≈ 20 ✓. This is the single most reliable way to catch a mis-keyed entry.

Two habits prevent most errors: enter the whole expression before pressing equals rather than rounding the two logs separately, and check whether your model's unqualified LOG means base 10 (nearly all of them) before trusting a result.

Common logarithm values

The values people look up most, in all three common bases at once. Every row is computed by the same engine that powers the calculator above, so nothing here is a transcribed table.

The notation log on its own is convention-dependent — on this page and on most scientific calculators it means base 10, but pure mathematics often means base e and computer science often means base 2. When it matters, write the base explicitly.

Logarithm rules and notation

The product rule is the reason logarithms exist historically: they convert multiplication into addition. The power rule follows from it, and the change-of-base rule is what makes any base computable from any other.

There is no rule for the logarithm of a sum or a difference. log(a + b) cannot be split into log(a) + log(b), and log(a − b) is not log(a) − log(b). Those two are the most common mistakes in the subject, and they are worth stating as a negative rule:

Read carefully, the correct rules say the opposite of the mistake: a sum of logs is the log of a product, not the log of a sum. If you need log(a + b), you must add first and take the logarithm of the total — there is no way to break it apart.

Domain, limits and edge cases

The real logarithm is defined for x > 0 with a base b > 0, b ≠ 1. Outside that, the calculator returns a named error rather than a number.

The limiting behaviour depends on which side of 1 the base sits, and generalising from base 10 to every base is a real mistake:

In both cases the vertical line x = 0 is an asymptote the curve approaches but never reaches, which is why log(0) is undefined rather than infinite: infinity is not a value the function takes.

Separately from the mathematics, binary floating point has a finite range. Numbers beyond roughly 1.8 × 10³⁰⁸ overflow and numbers below roughly 5 × 10⁻³²⁴ underflow to zero. This calculator reports those as NUMERIC_OVERFLOW and NUMERIC_UNDERFLOW — deliberately distinct from a domain error, because the value exists mathematically and it is only the representation that has run out. A base extremely close to 1 is valid too, but ln(b) is then tiny and the division is ill-conditioned; the calculator computes the result and attaches an explicit precision warning rather than refusing or pretending.

Worked examples

1. log₁₀(100000) = 5. 10⁵ = 100000, so the exponent is 5 — exact, no rounding involved.
2. ln(7) ≈ 1.945910149055. No power of e expressible as a simple fraction hits 7, so this is irrational and approximate. Check: e^1.945910149055 ≈ 7.
3. log₂(20) ≈ 4.321928094887. ln(20) ÷ ln(2) = 2.995732273554 ÷ 0.693147180560. It falls between 2⁴ = 16 and 2⁵ = 32, so the answer must lie between 4 and 5.
4. log₀.₅(8) = −3. A base below 1 decreases, so an argument above 1 needs a negative exponent: 0.5⁻³ = 1 ÷ 0.5³ = 1 ÷ 0.125 = 8.
5. log₃(1/27) = −3. 3³ = 27, so 3⁻³ = 1/27. Reciprocal arguments simply negate the logarithm.
6. Solve log₁₀(x) = −4 → x = 0.0001. Convert to exponential form: x = 10⁻⁴. This is the antilog mode.
7. Solve log_b(81) = 4 → b = 3. Raise both sides to the power ¼: b = 81^(1/4) = 3, and 3⁴ = 81 confirms it. This is the find-base mode.

Real applications

• Decibels. Sound and signal levels are defined logarithmically: dB = 10 · log₁₀(P/P₀) for power. A 10× increase in power is +10 dB.
• pH. Acidity is defined as pH = −log₁₀[H⁺], so each whole pH step is a tenfold change in hydrogen-ion concentration.
• Information theory. Entropy and code length are measured in bits with base 2: encoding one of n equally likely outcomes needs log₂(n) bits.
• Exponential growth and decay. Solving A = A₀·e^(kt) for time gives t = ln(A/A₀) ÷ k — half-lives and doubling times are logarithms.
• Orders of magnitude. Log scales compress data that spans many powers of ten, which is why they are the default axis for earthquake energy, star brightness and long-run growth charts.

Common mistakes

• Taking the log of zero or a negative number. Fix: check the argument is > 0 — below that you have left the real numbers.
• Using a base of 0 or a negative base. Fix: the base must be > 0.
• Using base 1. Every power of 1 is 1, so no exponent can be singled out. Fix: use any other positive base.
• Rejecting bases between 0 and 1. log₀.₅(8) = −3 is valid. Fix: expect the sign to flip, not the calculation to fail.
• Mixing up logarithmic and exponential form. log_b(x) = y means b^y = x, not x^y = b. Fix: the base of the log is always the base of the power.
• Confusing e with ln(e). e ≈ 2.718 is the base; ln(e) = 1 is its logarithm. Fix: read which of the two is being asked for.
• Rounding the intermediate logs. ln(20) ≈ 3.00 divided by ln(2) ≈ 0.69 gives 4.348 instead of 4.3219. Fix: divide at full precision and round only the final answer.
• Assuming log always means the same base. Fix: write the base explicitly whenever ambiguity would matter.
• Splitting the log of a sum. log(a + b) is not log(a) + log(b). Fix: the product rule applies to products only; add first, then take the log.
• Reading a floating-point limit as “undefined”. 10⁴⁰⁰ overflows a double, but log₁₀(10⁴⁰⁰) = 400 is an ordinary logarithm. Fix: treat overflow and underflow as representation limits — which is why they have their own error codes here.

Methodology & verification

Logarithms are computed from the identity log_b(x) = y ⇔ b^y = x. The value uses change of base, log_b(x) = ln(x) ÷ ln(b), with ln evaluated as log1p(z − 1) below a centrally defined near-1 threshold. The real domain is enforced fail-closed (x > 0, b > 0, b ≠ 1, with 0 < b < 1 explicitly accepted) and every degenerate solve-for-base case is named rather than answered numerically. Internal precision is never reduced by the display-precision control. A result is called exact only when exactness is provable by a defining identity or by exact rational arithmetic. Every result is checked independently with the log-space residual r = y·ln(b) − ln(x) against a scale-aware tolerance built from machine epsilon, plus the inverse operation b^y where it is representable.

• Primary formula. log_b(x) = ln(x) ÷ ln(b); the antilog mode evaluates b^y directly and the find-base mode solves b = exp(ln(x) ÷ y).
• Real-number domain. x > 0, b > 0, b ≠ 1. Bases between 0 and 1 are accepted. Anything outside the domain returns a named error code, never a number.
• Treatment near 1. Below a centrally defined threshold of 0.0001 on |z − 1|, ln(z) is evaluated as log1p(z − 1). A base within 0.001 of 1 is computed and flagged with an explicit conditioning warning — it is never confused with the invalid base 1.
• Computation versus display. The engine keeps full internal precision throughout; the display-precision control changes formatting only and never feeds back into the calculation, the classification, the verification or the shareable URL state.
• Exact versus approximate. A result is labelled exact only when exactness is provable — by a defining identity (log_b(1) = 0, log_b(b) = 1) or by exact rational arithmetic showing that the base raised to a rational exponent equals the argument. Being numerically close to a whole number is explicitly not treated as evidence of exactness.
• Inverse verification. Where representable, b^y is computed and compared with x.
• Log-space residual. The primary check is r = y·ln(b) − ln(x), compared with a scale-aware tolerance built from machine epsilon and the magnitude of the terms being differenced. It stays valid where the direct inverse would overflow or underflow.
• Local only. Every calculation runs in your browser. No input, result or receipt is transmitted to a server, no external mathematics API is called, and nothing you type is executed as code.
• Engine version. logarithm-engine v1.0.0.
• Automated frozen reference vectors. The engine's test suite checks its output against high-precision constants that were not generated by the JavaScript formula under test (log₂(20), ln(7), log₃(7), log₁₀(0.4), log₂(10), log₃(2), log₉(3)), with a declared tolerance of a few units in the last place.

Author: Ugo Candido · Last updated: August 8, 2026 · Results are computed in double-precision floating point: correct to the precision that representation allows, and reported with the residual so you can see how close that is. Browse more tools on the Math page.