Logarithm Calculator

Calculate common logarithm (log10), natural log (ln), binary log (log2), and arbitrary custom base logarithms with change-of-base rules.

4.9 / 5· 148 verified ratings
•
100% Client-Side Privacy
•
Verified 2026 Engine
Instant Computation • 100% Client-Side Privacy • Exact Mathematical Precision
Loading tool engine...
Frequently Used With:Scientific Calculator →Percentage Calculator →Smart Basic Calculator with Audit Tape →Fraction & Mixed Number Calculator →
Institutional-Grade Accuracy & Client-Side Privacy Guarantee

Unlike conventional calculator sites that send your financial numbers, payload data, or code snippets across remote web servers, Affi-Chain processes all mathematical derivations, algorithms, and data parsing 100% locally within your browser sandbox. No tracking cookies, no server-side retention, and zero transmission lag.

Mathematical Foundations & Functional Inverses

A Logarithm Calculator computes the exact exponent to which a specified mathematical base must be raised to produce a target number. Formally introduced in 1614 by Scottish mathematician John Napier (and adapted to base 10 by Henry Briggs), logarithms serve as the fundamental inverse operation of exponentiation:

$$\log_b(x) = y \iff b^y = x$$

Where:

  • $b$ is the base, subject to strict domain constraints: $b > 0$ and $b \neq 1$.
  • $x$ is the argument (power result), which must be strictly positive: $x > 0$.
  • $y$ is the logarithm (the exponent), which spans the entire real number line: $y \in (-\infty, +\infty)$.
+---------------------------------------------------------------------------------------------------+
|                                     LOGARITHMIC INVERSE DUALITY                                   |
+---------------------------------------------------------------------------------------------------+
|  EXPONENTIAL DOMAIN                                          LOGARITHMIC DOMAIN                   |
|  Base raised to power: 2^8 = 256                    <-->     Inverse logarithm: log_2(256) = 8    |
|  Continuous growth: e^2.30258 ≈ 10                  <-->     Natural logarithm: ln(10) ≈ 2.302585 |
|  Orders of magnitude: 10^3 = 1,000                  <-->     Common logarithm:  log_10(1000) = 3  |
+---------------------------------------------------------------------------------------------------+

Compressing the Exponential Universe into Linear Scale

In science, engineering, and data science, physical quantities frequently span dozens of orders of magnitude—from subatomic Planck scales ($10^{-35} \text{ m}$) to astronomical galaxies ($10^{26} \text{ m}$). Plotting these phenomena on a linear arithmetic scale renders small values completely invisible and crushes comparative visual insights.

Logarithms map exponential relationships onto manageable linear progressions:

  • Every unit addition on a base-10 logarithmic scale represents a $10\times$ multiplication in physical reality.
  • An earthquake measuring $7.0$ on the Richter scale releases $31.6\times$ more energy than a $6.0$ magnitude earthquake, and $1,000\times$ more energy than a $5.0$ magnitude event.

Fundamental Algebraic Laws & Change-of-Base Matrix

Logarithms transform computationally difficult multiplicative operations into simple addition and subtraction:

                      LOGARITHMIC ALGEBRAIC IDENTITIES
                      
   PRODUCT LAW:               log_b(M · N) = log_b(M) + log_b(N)
   
   QUOTIENT LAW:              log_b(M / N) = log_b(M) - log_b(N)
   
   POWER LAW:                 log_b(M^k)   = k · log_b(M)
   
   INVERSE POWER OF BASE:     log_(b^k)(M) = (1 / k) · log_b(M)
   
   CHANGE-OF-BASE THEOREM:    log_b(x)     = ln(x) / ln(b) = log_10(x) / log_10(b)
   
   BASE RECIPROCAL:           log_b(a)     = 1 / log_a(b)
+---------------------------------------------------------------------------------------------------+
|                                  STANDARD LOGARITHMIC BASES IN SCIENCE                            |
+---------------------------------------------------------------------------------------------------+
|  Base Type                      Notation          Numerical Base    Primary Field of Deployment   |
|  -----------------------------  ----------------  ----------------  ----------------------------  |
|  Natural Logarithm              ln(x)             e ≈ 2.718281828   Calculus, ML Loss, Physics    |
|  Common Logarithm (Briggsian)   log10(x) or lg(x) 10                Acoustics (dB), Chemistry (pH)|
|  Binary Logarithm               log2(x) or lb(x)  2                 Computer Science, Info Entropy|
+---------------------------------------------------------------------------------------------------+

The Change-of-Base Theorem Derivation

Standard mathematical hardware libraries (such as x86 FPU instructions FYL2X) natively evaluate only natural logarithms ($\ln$) or binary logarithms ($\log_2$). To compute a logarithm for an arbitrary arbitrary base $b$:

Let $y = \log_b(x)$. By definition: $$b^y = x$$

Take the natural logarithm ($\ln$) of both sides: $$\ln(b^y) = \ln(x)$$

Apply the Power Law: $$y \cdot \ln(b) = \ln(x) \implies y = \frac{\ln(x)}{\ln(b)}$$

Thus, arbitrary base evaluation is universally computed via: $$\log_b(x) = \frac{\ln(x)}{\ln(b)} = \frac{\log_{10}(x)}{\log_{10}(b)} = \frac{\log_2(x)}{\log_2(b)}$$


Production Code Implementation

Python: High-Precision Arbitrary-Base Logarithmic Engine

#!/usr/bin/env python3
"""
Production Logarithm Computation Engine.
Calculates Arbitrary-Base Logarithms, Natural Logs, Log1p for Numerical Stability,
and evaluates Asymptotic Computational Complexity bounds.
"""

import math
from typing import Dict, Union


class LogarithmEngine:
    @staticmethod
    def calculate_log(argument: float, base: float = math.e) -> Dict[str, Union[float, str]]:
        """
        Computes log_b(x) using the change-of-base formula with rigorous domain verification.
        """
        if argument <= 0.0:
            raise ValueError(f"Domain Error: Argument x must be strictly positive (got x={argument}).")
        if base <= 0.0:
            raise ValueError(f"Domain Error: Base b must be strictly positive (got b={base}).")
        if math.isclose(base, 1.0):
            raise ValueError("Singularity Error: Logarithmic base cannot equal 1.0 (division by zero).")

        # Native math.log(x, base) internally evaluates change of base: log(x) / log(base)
        result = math.log(argument, base)
        ln_val = math.log(argument)
        log10_val = math.log10(argument)
        log2_val = math.log2(argument)

        return {
            "argument_x": argument,
            "base_b": base,
            "log_b_x": round(result, 8),
            "natural_ln_x": round(ln_val, 8),
            "common_log10_x": round(log10_val, 8),
            "binary_log2_x": round(log2_val, 8),
        }

    @staticmethod
    def stable_log1p(delta: float) -> float:
        """
        Calculates ln(1 + delta) accurately for very small values of delta (|delta| < 1e-4).
        Prevents catastrophic floating-point cancellation in IEEE 754 arithmetic.
        """
        return math.log1p(delta)

    @staticmethod
    def solve_exponential_equation(base: float, target_power: float) -> float:
        """
        Solves for exponent y in: base^y = target_power
        Formula: y = log_base(target_power)
        """
        return math.log(target_power, base)


# Demonstration
if __name__ == "__main__":
    engine = LogarithmEngine()

    # 1. Custom Base Test: What is log_3(243)? -> 3^5 = 243
    res1 = engine.calculate_log(243.0, base=3.0)
    print("--- CUSTOM BASE LOGARITHMIC EVALUATION ---")
    print(f"Equation: log_3(243) = {res1['log_b_x']}")
    print(f"Natural ln(243):       {res1['natural_ln_x']}")
    print(f"Common log10(243):     {res1['common_log10_x']}")
    print(f"Binary log2(243):      {res1['binary_log2_x']}")

    # 2. Catastrophic Cancellation Mitigation Test
    small_x = 1e-15
    naive_ln = math.log(1.0 + small_x)  # May lose bits of precision
    stable_ln = engine.stable_log1p(small_x)  # Retains full 53-bit mantissa precision
    print("\n--- FLOATING-POINT STABILITY COMPARISON (x = 1e-15) ---")
    print(f"Naive ln(1 + x):  {naive_ln}")
    print(f"Stable log1p(x):  {stable_ln}")

TypeScript: Microservice Arbitrary-Base Math Module

export interface LogarithmResult {
  argument: number;
  base: number;
  result: number;
  naturalLog: number;
  log10: number;
  log2: number;
}

export class ScientificLogService {
  /**
   * Computes log_b(x) with domain bounds verification
   */
  public static evaluate(argument: number, base: number = Math.E): LogarithmResult {
    if (argument <= 0) {
      throw new Error("Invalid Argument: Argument x must be greater than zero.");
    }
    if (base <= 0 || Math.abs(base - 1) < 1e-12) {
      throw new Error("Invalid Base: Base must be strictly positive and not equal to 1.");
    }

    const naturalLog = Math.log(argument);
    const result = naturalLog / Math.log(base);

    return {
      argument,
      base,
      result: Math.round(result * 1e8) / 1e8,
      naturalLog: Math.round(naturalLog * 1e8) / 1e8,
      log10: Math.round(Math.log10(argument) * 1e8) / 1e8,
      log2: Math.round(Math.log2(argument) * 1e8) / 1e8,
    };
  }

  /**
   * Safe ln(1 + x) for tiny floating-point values
   */
  public static safeLog1p(x: number): number {
    return Math.log1p(x);
  }
}

Logarithmic Scales in Nature & Engineering Comparison Matrix

Scientific ScaleBase UsedUnderlying FormulaPhysical DomainPractical Significance of Unit Increase ($+1.0$)
Decibel (dB Sound)Base 10$L = 10 \cdot \log_{10}(P / P_0)$Acoustics / Audio Engineering$10\times$ increase in sound power (~$2\times$ perceived loudness)
pH ScaleBase 10$\text{pH} = -\log_{10}[\text{H}^+]$Chemistry / Biology$10\times$ decrease in hydrogen ion concentration (Less acidic)
Richter / Moment Mag.Base 10 / 32$M_w = \frac{2}{3}\log_{10}(M_0) - 10.7$Seismology (Earthquakes)$31.6\times$ increase in total seismic energy released
Shannon EntropyBase 2$H = -\sum p(x) \log_2 p(x)$Information Theory & CryptographyDoubles the total binary search permutations
Musical OctavesBase 2$f_n = f_0 \cdot 2^n$Musical AcousticsDoubles the sound wave frequency ($440\text{ Hz} \to 880\text{ Hz}$)
Astronomical MagnitudeBase $\sqrt[5]{100}$$m_1 - m_2 = -2.5 \log_{10}(F_1 / F_2)$Stellar Astronomy$2.512\times$ decrease in apparent celestial brightness

Numerical Pitfalls & Computational Traps

1. Catastrophic Floating-Point Cancellation for Small Arguments ($\ln(1 + x)$)

In financial interest compounding, calculus limits, and machine learning activations, software frequently evaluates expressions of the form $\ln(1 + x)$ where $|x| \ll 1$ (e.g., $x = 10^{-14}$):

  • In IEEE 754 double-precision arithmetic, evaluating 1.0 + x adds a tiny number to 1.0, truncating the least significant bits of $x$.
  • Taking Math.log(1.0 + x) then returns 0.0 or introduces massive relative error.
  • Remediation: Always use the specialized standard library function log1p(x) (in Python math.log1p(x), in JavaScript Math.log1p(x), in C log1p()), which evaluates the Taylor series expansion directly without performing the lossy intermediate 1.0 + x addition:

$$\ln(1 + x) = x - \frac{x^2}{2} + \frac{x^3}{3} - \frac{x^4}{4} + \cdots$$

2. The Base 1.0 Singularity

When designing general-purpose calculation interfaces, users occasionally input base $b = 1.0$:

  • By definition, $1^y = 1$ for all real numbers $y$. There is no exponent that can produce any number other than 1.
  • In the change-of-base equation $\log_1(x) = \frac{\ln(x)}{\ln(1)} = \frac{\ln(x)}{0}$, evaluation produces an immediate division-by-zero exception or floating-point Infinity/NaN.
  • The interface must validate $b \neq 1.0$ upfront and return an explicit domain error.

3. Logarithms of Negative Numbers and the Complex Domain

The real logarithm function $\log_b(x)$ is strictly undefined for $x \le 0$:

  • For $x = 0$, the function approaches negative infinity: $\lim_{x \to 0^+} \ln(x) = -\infty$.
  • In complex analysis, negative numbers possess valid complex logarithms via Euler's identity ($e^{i\pi} = -1$):

$$\ln(-x) = \ln(x) + i\pi \quad (x > 0)$$

Standard real-number calculators must reject negative arguments unless operating in explicit complex-plane mode.

Frequently Asked Questions

What is the change-of-base formula?
The change-of-base formula states that log_b(x) = ln(x) / ln(b) = log10(x) / log10(b), enabling computation on any calculator.

Explore Related Utilities