Python math.acosh(): Inverse Hyperbolic Cosine

Syntax & Parameters 🔝

The math.acosh() function is part of Python's standard math module and requires no external third-party installations:

import math

math.acosh(x)

Basic Examples 🔝

At the minimum boundary x = 1.0, the output is exactly 0.0 because cosh(0) = 1.0. As x increases, acosh(x) grows smoothly and monotonically:

import math

print("acosh(1.0): ", math.acosh(1.0))
print("acosh(1.5): ", round(math.acosh(1.5), 6))
print("acosh(2.0): ", round(math.acosh(2.0), 6))
print("acosh(5.0): ", round(math.acosh(5.0), 6))
print("acosh(10):  ", round(math.acosh(10), 6))

Output:

acosh(1.0):  0.0
acosh(1.5):  0.962424
acosh(2.0):  1.316958
acosh(5.0):  2.292432
acosh(10):   2.993223

Logarithmic Definition & Equivalence 🔝

Mathematically, all inverse hyperbolic functions can be expressed explicitly using the natural logarithm. For any real number x ≥ 1.0, the principal branch of inverse hyperbolic cosine is defined as:

We can verify that Python's math.acosh(x) produces outputs identical to this formula using math.log(), math.sqrt(), and math.isclose():

import math

def formula_acosh(x):
    return math.log(x + math.sqrt(x**2 - 1))

sample_inputs = [1.0, 1.25, 2.0, 7.5, 25.0, 100.0]
print(f"{'x':>7} | {'math.acosh(x)':>15} | {'formula_acosh(x)':>16} | Match?")
print("-" * 52)

for val in sample_inputs:
    built_in = math.acosh(val)
    calc = formula_acosh(val)
    is_match = math.isclose(built_in, calc, rel_tol=1e-12)
    print(f"{val:7.2f} | {built_in:15.8f} | {calc:16.8f} | {is_match}")

Output:

      x |   math.acosh(x) | formula_acosh(x) | Match?
----------------------------------------------------
   1.00 |      0.00000000 |       0.00000000 | True
   1.25 |      0.69314718 |       0.69314718 | True
   2.00 |      1.31695790 |       1.31695790 | True
   7.50 |      2.70119853 |       2.70119853 | True
  25.00 |      3.91182391 |       3.91182391 | True
 100.00 |      5.29829237 |       5.29829237 | True

Domain Boundary & ValueError Handling (x ≥ 1.0) 🔝

Because the real hyperbolic cosine curve has a global minimum at cosh(0) = 1.0, there is no real number whose hyperbolic cosine is less than 1.0. Consequently, passing any argument strictly less than 1.0 (including 0.999, 0, or negative numbers) raises a ValueError:

import math

invalid_inputs = [0.99, 0.0, -1.5]

for val in invalid_inputs:
    try:
        result = math.acosh(val)
    except ValueError as err:
        print(f"Input {val:5.2f} -> ValueError: {err}")

Output:

Input  0.99 -> ValueError: math domain error
Input  0.00 -> ValueError: math domain error
Input -1.50 -> ValueError: math domain error

In robust production applications, always guard input values by validating the lower boundary before calling math.acosh():

def safe_acosh(x, fallback=0.0):
    if x < 1.0:
        return fallback
    return math.acosh(x)

print("Safe acosh(0.85):", safe_acosh(0.85))  # 0.0
print("Safe acosh(1.85):", safe_acosh(1.85))  # 1.22359...

Real vs. Complex: math.acosh() vs. cmath.acosh() 🔝

While the real-valued math module enforces the domain x ≥ 1.0, in complex analysis the inverse hyperbolic cosine is defined across all complex numbers. Python provides the companion cmath module for complex number evaluations:

import math
import cmath

val = 0.5

# math module raises ValueError
try:
    math.acosh(val)
except ValueError as e:
    print("math.acosh(0.5): ", e)

# cmath module returns a complex number: 0 + 1.0471975511965976j (pi / 3 radians imaginary)
c_result = cmath.acosh(val)
print("cmath.acosh(0.5):", c_result)
print("Imaginary part equals pi / 3?", math.isclose(c_result.imag, math.pi / 3))

Output:

math.acosh(0.5):  math domain error
cmath.acosh(0.5): 1.0471975511965976j
Imaginary part equals pi / 3? True

math.acos() vs. math.acosh(): Circular vs. Hyperbolic 🔝

Learners often confuse circular inverse cosine (math.acos) with hyperbolic inverse cosine (math.acosh). The two functions serve completely different mathematical and physical purposes:

Plotting the Inverse Hyperbolic Curve with Matplotlib 🔝

We can visualize the inverse hyperbolic cosine curve starting at (1.0, 0.0) and rising steadily as x increases using Matplotlib:

import math
import matplotlib.pyplot as plt

x_vals = [1.0 + i * 0.2 for i in range(0, 96)]  # 1.0 to 20.0
y_vals = [math.acosh(x) for x in x_vals]

plt.plot(x_vals, y_vals, label="y = acosh(x)", color="#1a73e8", linewidth=2)
plt.axvline(1.0, color="red", linestyle="--", label="Domain Boundary (x = 1.0)")
plt.title("Inverse Hyperbolic Cosine: y = acosh(x)")
plt.xlabel("x (Domain: [1.0, +inf))")
plt.ylabel("acosh(x)")
plt.grid(True, linestyle=":", alpha=0.6)
plt.legend()
plt.show()

Hands-on Exercise: Catenary Curve Parameter Solver with Assertions 🔝

In structural engineering and overhead power line design, a flexible cable suspended between two pylons hangs under its own weight in a curve known as a catenary. The height profile is governed by:

Where a is the catenary scaling parameter (ratio of horizontal tension to cable weight per unit length), and y is the vertical coordinate of the cable at horizontal distance x from the vertex. Because y / a ≥ 1.0, we use math.acosh() to calculate the horizontal position x given the height y and scaling parameter a.

import math

def catenary_horizontal_distance(cable_height, catenary_param_a):
    """
    Calculates horizontal distance x from vertex of a catenary cable:
    x = a * acosh(y / a)
    """
    if catenary_param_a <= 0:
        raise ValueError("Catenary parameter 'a' must be strictly positive.")
    ratio = cable_height / catenary_param_a
    if ratio < 1.0:
        raise ValueError("Cable height cannot be less than catenary vertex parameter 'a'.")
    return round(catenary_param_a * math.acosh(ratio), 4)

# Unit Assertions
assert catenary_horizontal_distance(50.0, 50.0) == 0.0  # Vertex (x = 0)
assert catenary_horizontal_distance(75.0, 50.0) == 48.1212
assert catenary_horizontal_distance(100.0, 50.0) == 65.8479

# Boundary error handling check
try:
    catenary_horizontal_distance(40.0, 50.0)  # ratio 0.8 < 1.0
    assert False, "Should raise ValueError"
except ValueError:
    pass

cable_h = 85.0
param_a = 60.0
dist_x = catenary_horizontal_distance(cable_h, param_a)
print(f"Cable at height {cable_h}m (a={param_a}m): x = {dist_x}m from center")
print("All catenary parameter assertions passed successfully!")

Practice in Google Colab & GitHub 🔝

Open in Google Colab View on GitHub

Run all math.acosh() examples interactively, test domain boundary conditions, verify logarithmic equivalence, and execute catenary curve physics calculations in Google Colab.

More Details & Related Guides 🔝

• Python Math Module Overview — Master arithmetic, trigonometry, and numeric constants in Python.
• math.cosh() Function — Forward hyperbolic cosine function.
• math.asinh() Function — Inverse hyperbolic sine for unrestricted real numbers.
• math.atanh() Function — Inverse hyperbolic tangent strictly in (-1.0, 1.0).
• math.cos() Function — Circular trigonometric cosine function.
• math.acos() Function — Circular inverse arc cosine returning radians in [0, π].
• math.log() Function — Natural logarithm and mathematical foundation of hyperbolic inverses.
• Matplotlib Python Guide — Visualizing mathematical curves and distributions.

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author   Watch on YouTube

Connect: