HomeCalculatorsMathPowers, Roots & LogarithmsAntilog Calculator
Math calculator

Antilog Calculator

Calculate the antilogarithm: raise base b to power y. Fast local calculation with shareable, machine-readable results.

Instant result
Result

Enter values to calculate.

Inputs
Mode
Formula
Trust summary CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance
Input interpretation
Enter values to calculate.
Result
Assurance
Core
Declared partition coverage
PASS · 2/2 declared partitions (antilog, invalid-domain) · Matrix
Known limitations
  • b > 0, b ≠ 1
  • Core CVP does not include live graph, viewport, or pointer interaction.
Model
The antilogarithm x = bʸ for common (base 10), natural (base e), base 2, or a custom base.
Scope
Real arithmetic; base b > 0 and b ≠ 1.
Verification
Engine tested · Source checked · v1.0.5 · CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance· View Manifest · CVP overview · Specification
Versions
Calculation 1.0.5 · CVP protocol 1.0.0-proposed
CVP identity
5/5 property · digest 20709baf8978
Legacy regression
33/33 tests · Production surface contract 3/3
Trust layers
Verification VERIFIED · Production CURRENT · overall VERIFIED
Reference
O1 model · O3 expected_values · O3 numerical_behavior · O2 expected_values · O2 numerical_behavior
Interfaces
PASS · UI (SSR) / REST / MCP / URL→result→graph — Success 1/1. Error-path engine·REST·MCP 19/19 (status, code, calculation_version). SSR compared on URL-canonical requested calculations; empty query is idle (not an error) and JSON-typed object/array inputs are REST/MCP-only. Integration: URL → SSR result → Live graph current point (4/4). Hydration/slider/history are URL-canonical contracts, not a live browser session.
Supplemental domain review
Not performed
Named expert review
Not performed
CVP suite
3/3 golden · 19/19 CVP boundary · 19/19 invalid · 5/5 property · 4/4 metamorphic · 5/5 round-trip · 15/15 O3 · 20/20 cross-interface · 4/4 URL→result→graph · 3/3 CVP contract · Manifest
Sources
Sources
Evidence
14 legacy golden · 19 legacy boundary · legacy regression suite · 3/3 oracle-backed golden · 19/19 invalid · Artifact integrity PASS
This calculator CURRENT · Public schema 1.0.5 matches · Semantic contract ✓ · Production attested · Public/cache ✓ · Origin ✓
Semantic contract
PASS
Full verification

Manifest identity, reference classes, interfaces, suite, and production records.

Formulas

Core equations used by this calculator.

Antilogx = antilog_b(y) = bʸ
Commonx = 10ʸ
Naturalx = eʸ
iIf no base is stated, base 10 is conventional. Base must be positive and not equal to 1. Antilog of 0 is 1 for every valid base.

How to use

1

Choose the base

Use 10 for common antilog, e for natural antilog, 2 for binary, or Custom for any positive base ≠ 1.

2

Enter the log value y

This is the exponent — the output of a previous log_b(x) calculation.

3

Read x = bʸ

The result is the original positive number whose logarithm was y.

Example calculations

Common configurations with formula and result.

ϟ

Common antilog of 3

Base 10

10³
1000
ϟ

Natural antilog of 3

Base e

≈ 20.0855
ϟ

Base 2

antilog₂(3)

8
ϟ

Custom base

Base 8, y = 3

512
ϟ

Negative log value

Common antilog of −2

10⁻²
0.01
ϟ

Base between 0 and 1

b = 0.5, y = 2

0.5²
0.25

Common antilog₁₀ values

Common values at a glance.

y (log value)ExpressionAntilog
010⁰1
110¹10
210²100
310³1000
410⁴10000
−110⁻¹0.1
−210⁻²0.01
0.510⁰·⁵≈ 3.162
1.510¹·⁵≈ 31.62
i Other bases: antilog₂(3) = 8, antilog₂(4) = 16, antilog₅(2) = 25. Natural: e³ ≈ 20.086.

Antilog calculator specification

Version 1.0.5 · Engine tested

Calculation status

Review policy · Evidence

Definition
The antilogarithm (antilog) is the inverse of a logarithm. If log_b(x) = y, then antilog_b(y) = b^y = x. Computing an antilog is the same as exponentiation.
What it calculates
The antilogarithm x = bʸ for common (base 10), natural (base e), base 2, or a custom base.
Inputs
  • Base b (10, e, 2, or custom)
  • Log value y (real number)
Outputs
  • Antilog x = bʸ
Formula
x = antilog_b(y) = bʸ
Assumptions
  • Real arithmetic; base b > 0 and b ≠ 1.
  • Result x is positive for real y when b > 0.
Units
  • Dimensionless numeric result. In physical applications, logarithms are normally applied to dimensionless ratios or normalized quantities.
Boundary conditions
  • Invalid base (≤ 0 or 1) returns INVALID_BASE.
  • 0 < b < 1 is valid (for example 0.5² = 0.25).
  • y = 0 returns 1 for every valid base.
  • Extreme |y| may overflow (RESULT_OVERFLOW) or underflow (RESULT_UNDERFLOW).
Numerical precision
  • Computation uses IEEE-754 binary64 (JavaScript Number): x = b^y, or Math.exp(y) for base e.
  • REST and SSR return that engine number. The on-page result may round for display (up to 12 significant digits; scientific notation when |x| ≥ 1e12 or 0 < |x| < 1e-6).
  • Values exact in binary64 (for example 10³) display as 1000. Irrational results such as e³ are rounded on the page; the API returns the raw engine numeric value serialized as a JSON number.
  • IEEE-754 overflow (non-finite x) is RESULT_OVERFLOW, not Infinity. A positive result that collapses to 0 is RESULT_UNDERFLOW, not a silent 0. Underflow is a finite-zero collapse, not a non-finite value.
  • Interactive evaluation runs in the browser. Shared URLs and REST use the same engine server-side.
  • The Result Card inverse check restates log_b(x) against input y with display-rounded values. It is an inverse consistency check, not expert verification, and is never labelled Verified.
  • Advanced Display (Auto / 4 / 6 / 10 significant digits) changes on-page rounding only. REST, SSR JSON, and #calculatorx-result keep the raw engine numeric value serialized as a JSON number. Share URLs may include digits=4|6|10.
  • Optional Compare 2 / e / 10 is a same-y visualization (share URL compare=1). It does not change x = b^y and is not a second calculator mode.
  • The Result Card includes an engine-linked Live graph of x = b^y versus input y, using the same Overview / Focus template as Log (canonical exponent window −2 ≤ y ≤ 2; current point is (y, x) = (y, b^y)).
Example
antilog₁₀(3) = 1000
Validation cases

16 published on this page · 33/33 tests · Production surface contract 3/3 · View evidence

  • base 10, y=3 → 1000
  • base e, y=3 → ≈20.0855
  • base 2, y=3 → 8
  • base 10, y=-2 → 0.01
  • base 8, y=3 → 512
  • base 10, y=0 → 1
  • base 10, y=0.5 → ≈3.16227766
  • base 0.5, y=2 → 0.25
  • base 0.5, y=-2 → 4
  • base 1.5, y=2 → 2.25
  • base 1 → error INVALID_BASE
  • base 0 → error INVALID_BASE
  • base −2 → error INVALID_BASE
  • empty y → error MISSING_REQUIRED_INPUT
  • base 10, y=400 → error RESULT_OVERFLOW
  • base 10, y=−400 → error RESULT_UNDERFLOW
Sources
  • NIST Digital Library of Mathematical Functions, Chapter 4 — Logarithm, Exponential, Powers
    Supports: Logarithm and exponential as inverse operations; antilog is exponentiation x = b^y
  • NIST DLMF §4.2 — Logarithm: definitions and inverse of the exponential
    Supports: b^(log_b x) = x and log_b(b^y) = y for valid real b and x
  • CalculatorX mathematical conventions — Common (base 10), natural (base e), and real bases b > 0, b ≠ 1
    Supports: Unspecified antilog is common (base 10); custom bases may be in (0, 1)
Calculation version
1.0.5

Background

Interpretation and common distinctions.

What antilog means

A logarithm answers: “to what power must base b be raised to get x?”

y = log_b x

An antilogarithm undoes that step: raise the same base to y to recover x.

x = antilog_b(y) = b^y

So antilog is simply exponentiation — the inverse of log. Calculators rarely label a key “antilog”; they use 10^x, e^x, or y^x.

How to calculate antilog

  1. Choose base b (default 10 if unspecified).
  2. Enter the log value y.
  3. Compute x = b^y.

Worked examples

Goal Setup Result
Common antilog of 4 10^4 10000
Natural antilog of 3 e^3 ≈ 20.0855
Base 2 2^9 512
Custom base 8 8^3 512
Negative exponent 10⁻² 0.01
Base in (0, 1) 0.5² 0.25
Zero log value 10^0 1

Log vs antilog

Logarithm Antilogarithm
Role Find the exponent Raise the base to an exponent
Typical form y = log_b x x = b^y
Input domain (real) x > 0 any real y
Output (real, b>0) any real y always x > 0

Because they are inverses:

b^(log_b x) = x

log_b(b^y) = y

(for valid b and x).

Common, natural, and other bases

  • Common antilog — base 10: x = 10^y. Inverse of the common logarithm, log₁₀(x), often written log(x).
  • Natural antilog — base e ≈ 2.71828: x = e^y. Inverse of ln.
  • Binary — base 2: useful in CS and information theory.
  • Custom — any b > 0, b ≠ 1, including bases in (0, 1).

Characteristic and mantissa (optional background)

In traditional common-log tables, a logarithm is represented as an integer characteristic plus a non-negative fractional mantissa. For a positive example such as 2.6452, characteristic = 2 and mantissa = 0.6452. Tables looked up the mantissa to recover digits; magnitude came from the characteristic. Negative logarithms use a more involved table convention and are not expanded here. This tool skips tables and evaluates b^y directly.

Graph sketch (base 10)

Plotting this calculator’s input y against result x:

x = 10^y

  • As y → −∞, x → 0⁺ (approaches the axis but never reaches it)
  • As y → +∞, x grows exponentially
  • At y = 0, x = 1

The same qualitative shape holds for any base b > 1. For 0 < b < 1, x = b^y decays as y increases.

Tips

  • To remove a log from an equation, raise both sides to the log’s base (apply antilog).
  • To remove an antilog, take log_b of both sides.
  • Antilog of 0 is always 1 (b^0 = 1).
  • Prefer the Log calculator or ln calculator when you need the forward transform; use Exponent for a general a^b pad.

CVP (Calculator Verification Protocol)

Math graph pilot under CVP 1.0 Proposed. Profile: core (unitless antilogarithm, not an engineering model).

  • Evidence Manifest: /evidence/math.antilog/1.0.5.cvp.json
  • Independent reference: O1 (model) + O3 mpmath/MPFR expected values and numerical behavior + O2 live identities
  • Numerical policy: IEEE-754 binary64; ≤2 ULP vs O3; declared_before_evaluation=true
  • Interfaces: UI (SSR), REST, and MCP must agree. A separate integration check covers URL → result → Live graph. ui-ssr is not a live browser session.
  • Expert review is optional and is not required for CVP Verified.
}

Frequently asked questions

Key distinctions behind the calculation.

What is an antilogarithm?

It is the inverse of a logarithm. If log_b(x) = y, then antilog_b(y) = x, which equals b raised to y.

How do you find the antilog of a number?

Pick the base b, take the log value y, and compute bʸ. For everyday common logs, that is 10ʸ.

What is the antilog of 3?

It depends on the base: 10³ = 1000, 2³ = 8, e³ ≈ 20.09.

Is ln an antilog?

No. ln is the natural logarithm (base e). The natural antilog is eʸ, the inverse of ln.

Can y be negative?

Yes. A negative log value still has an antilog; for base 10, 10⁻² = 0.01. The result is always positive for real bases > 0.

What if no base is given?

Conventionally use base 10 (common antilog).

What is a mantissa?

In a logarithm written as characteristic + fraction, the mantissa is the fractional part (e.g. in 2.6452 the mantissa is 0.6452). Old antilog tables looked up the mantissa; this calculator uses direct exponentiation instead.

How do you remove a log from an equation?

Raise both sides to the log’s base (apply antilog). To undo an antilog, take the log of both sides with the same base.

What bases are invalid?

Real antilog requires b > 0 and b ≠ 1. Base 1, 0, and negative bases are rejected. Bases between 0 and 1 are valid: 0.5² = 0.25.