tessl/pypi-mpmath
Python library for arbitrary-precision floating-point arithmetic
—
Pending
elementary-functions.mddocs/
Elementary Functions
Standard mathematical functions including exponentials, logarithms, trigonometric functions, hyperbolic functions, and basic operations on complex numbers. All functions support both real and complex arguments where mathematically meaningful.
Capabilities
Powers and Roots
Basic power and root functions with arbitrary precision.
def sqrt(x):
"""
Square root of x.
Args:
x: Input number
Returns:
Square root of x
"""
def cbrt(x):
"""
Cube root of x.
Args:
x: Input number
Returns:
Cube root of x
"""
def root(x, n):
"""
nth root of x.
Args:
x: Input number
n: Root index
Returns:
nth root of x
"""
def nthroot(x, n):
"""
nth root of x (alias for root).
Args:
x: Input number
n: Root index
Returns:
nth root of x
"""
def power(x, y):
"""
Power function x^y.
Args:
x: Base
y: Exponent
Returns:
x raised to power y
"""
def hypot(x, y):
"""
Euclidean distance sqrt(x^2 + y^2).
Args:
x, y: Input numbers
Returns:
Euclidean distance
"""Exponential Functions
Exponential functions and variants.
def exp(x):
"""
Exponential function e^x.
Args:
x: Input number
Returns:
e raised to power x
"""
def expm1(x):
"""
exp(x) - 1, computed accurately for small x.
Args:
x: Input number
Returns:
exp(x) - 1
"""
def expj(x):
"""
exp(j*x) where j is the imaginary unit.
Args:
x: Input number
Returns:
exp(j*x) = cos(x) + j*sin(x)
"""
def expjpi(x):
"""
exp(j*π*x) where j is the imaginary unit.
Args:
x: Input number
Returns:
exp(j*π*x)
"""
def powm1(x, y):
"""
x^y - 1, computed accurately when x^y is close to 1.
Args:
x: Base
y: Exponent
Returns:
x^y - 1
"""Logarithmic Functions
Logarithmic functions with various bases.
def ln(x):
"""
Natural logarithm (base e).
Args:
x: Input number (x > 0 for real result)
Returns:
Natural logarithm of x
"""
def log(x, b=None):
"""
Logarithm with specified base (default: natural log).
Args:
x: Input number
b: Base (optional, default is e)
Returns:
Logarithm of x to base b
"""
def log10(x):
"""
Base-10 logarithm.
Args:
x: Input number
Returns:
Base-10 logarithm of x
"""
def log1p(x):
"""
ln(1 + x), computed accurately for small x.
Args:
x: Input number
Returns:
ln(1 + x)
"""
def ldexp(x, n):
"""
Compute x * 2^n efficiently.
Args:
x: Input number
n: Integer exponent
Returns:
x * 2^n
"""
def frexp(x):
"""
Extract mantissa and exponent: x = mantissa * 2^exponent.
Args:
x: Input number
Returns:
tuple: (mantissa, exponent) where 0.5 <= |mantissa| < 1
"""Trigonometric Functions
Standard trigonometric functions with high precision.
def sin(x):
"""
Sine function.
Args:
x: Angle in radians
Returns:
sin(x)
"""
def cos(x):
"""
Cosine function.
Args:
x: Angle in radians
Returns:
cos(x)
"""
def tan(x):
"""
Tangent function.
Args:
x: Angle in radians
Returns:
tan(x)
"""
def sec(x):
"""
Secant function (1/cos(x)).
Args:
x: Angle in radians
Returns:
sec(x) = 1/cos(x)
"""
def csc(x):
"""
Cosecant function (1/sin(x)).
Args:
x: Angle in radians
Returns:
csc(x) = 1/sin(x)
"""
def cot(x):
"""
Cotangent function (1/tan(x)).
Args:
x: Angle in radians
Returns:
cot(x) = 1/tan(x)
"""
def sinpi(x):
"""
sin(π*x), computed accurately.
Args:
x: Input number
Returns:
sin(π*x)
"""
def cospi(x):
"""
cos(π*x), computed accurately.
Args:
x: Input number
Returns:
cos(π*x)
"""
def cos_sin(x):
"""
Compute cos(x) and sin(x) simultaneously.
Args:
x: Angle in radians
Returns:
tuple: (cos(x), sin(x))
"""
def cospi_sinpi(x):
"""
Compute cos(π*x) and sin(π*x) simultaneously.
Args:
x: Input number
Returns:
tuple: (cos(π*x), sin(π*x))
"""Inverse Trigonometric Functions
Inverse trigonometric functions.
def asin(x):
"""
Inverse sine (arcsine).
Args:
x: Input number (-1 <= x <= 1 for real result)
Returns:
arcsin(x) in radians
"""
def acos(x):
"""
Inverse cosine (arccosine).
Args:
x: Input number (-1 <= x <= 1 for real result)
Returns:
arccos(x) in radians
"""
def atan(x):
"""
Inverse tangent (arctangent).
Args:
x: Input number
Returns:
arctan(x) in radians
"""
def asec(x):
"""
Inverse secant.
Args:
x: Input number (|x| >= 1 for real result)
Returns:
arcsec(x) in radians
"""
def acsc(x):
"""
Inverse cosecant.
Args:
x: Input number (|x| >= 1 for real result)
Returns:
arccsc(x) in radians
"""
def acot(x):
"""
Inverse cotangent.
Args:
x: Input number
Returns:
arccot(x) in radians
"""
def atan2(y, x):
"""
Two-argument inverse tangent.
Args:
y: y-coordinate
x: x-coordinate
Returns:
Angle in radians from positive x-axis to point (x, y)
"""Hyperbolic Functions
Hyperbolic functions and their inverses.
def sinh(x):
"""
Hyperbolic sine.
Args:
x: Input number
Returns:
sinh(x) = (e^x - e^(-x)) / 2
"""
def cosh(x):
"""
Hyperbolic cosine.
Args:
x: Input number
Returns:
cosh(x) = (e^x + e^(-x)) / 2
"""
def tanh(x):
"""
Hyperbolic tangent.
Args:
x: Input number
Returns:
tanh(x) = sinh(x) / cosh(x)
"""
def sech(x):
"""
Hyperbolic secant.
Args:
x: Input number
Returns:
sech(x) = 1 / cosh(x)
"""
def csch(x):
"""
Hyperbolic cosecant.
Args:
x: Input number
Returns:
csch(x) = 1 / sinh(x)
"""
def coth(x):
"""
Hyperbolic cotangent.
Args:
x: Input number
Returns:
coth(x) = cosh(x) / sinh(x)
"""Inverse Hyperbolic Functions
Inverse hyperbolic functions.
def asinh(x):
"""
Inverse hyperbolic sine.
Args:
x: Input number
Returns:
arcsinh(x)
"""
def acosh(x):
"""
Inverse hyperbolic cosine.
Args:
x: Input number (x >= 1 for real result)
Returns:
arccosh(x)
"""
def atanh(x):
"""
Inverse hyperbolic tangent.
Args:
x: Input number (|x| < 1 for real result)
Returns:
arctanh(x)
"""
def asech(x):
"""
Inverse hyperbolic secant.
Args:
x: Input number (0 < x <= 1 for real result)
Returns:
arcsech(x)
"""
def acsch(x):
"""
Inverse hyperbolic cosecant.
Args:
x: Input number (x != 0)
Returns:
arccsch(x)
"""
def acoth(x):
"""
Inverse hyperbolic cotangent.
Args:
x: Input number (|x| > 1 for real result)
Returns:
arccoth(x)
"""Rounding and Integer Functions
Functions for rounding and integer operations.
def floor(x):
"""
Floor function (round down to integer).
Args:
x: Input number
Returns:
Largest integer <= x
"""
def ceil(x):
"""
Ceiling function (round up to integer).
Args:
x: Input number
Returns:
Smallest integer >= x
"""
def nint(x):
"""
Round to nearest integer.
Args:
x: Input number
Returns:
Nearest integer to x
"""
def frac(x):
"""
Fractional part of x.
Args:
x: Input number
Returns:
x - floor(x)
"""
def fmod(x, y):
"""
Floating-point remainder of x/y.
Args:
x: Dividend
y: Divisor
Returns:
Remainder of x/y
"""Absolute Value and Sign Functions
Functions for absolute values and signs.
def fabs(x):
"""
Absolute value.
Args:
x: Input number
Returns:
|x|
"""
def sign(x):
"""
Sign function.
Args:
x: Input number
Returns:
-1 if x < 0, 0 if x = 0, 1 if x > 0
"""Angle Conversion
Functions for converting between degrees and radians.
def degrees(x):
"""
Convert radians to degrees.
Args:
x: Angle in radians
Returns:
Angle in degrees
"""
def radians(x):
"""
Convert degrees to radians.
Args:
x: Angle in degrees
Returns:
Angle in radians
"""Sinc Functions
Sinc functions and variants.
def sinc(x):
"""
Sinc function sin(x)/x.
Args:
x: Input number
Returns:
sin(x)/x with proper limit at x=0
"""
def sincpi(x):
"""
Sinc function sin(π*x)/(π*x).
Args:
x: Input number
Returns:
sin(π*x)/(π*x) with proper limit at x=0
"""Usage Examples
import mpmath
from mpmath import mp
# Set precision
mp.dps = 25
# Basic functions
x = mp.mpf('1.5')
print(f"sqrt({x}) = {mp.sqrt(x)}")
print(f"exp({x}) = {mp.exp(x)}")
print(f"ln({x}) = {mp.ln(x)}")
# Trigonometric functions
angle = mp.pi / 4 # 45 degrees
print(f"sin(π/4) = {mp.sin(angle)}")
print(f"cos(π/4) = {mp.cos(angle)}")
print(f"tan(π/4) = {mp.tan(angle)}")
# Complex arguments work too
z = mp.mpc(1, 1) # 1 + j
print(f"exp(1+j) = {mp.exp(z)}")
print(f"sin(1+j) = {mp.sin(z)}")
# High precision constants
print(f"π = {mp.pi}")
print(f"e = {mp.e}")
# Inverse functions
print(f"asin(1) = {mp.asin(1)}") # Should be π/2
print(f"atan(1) = {mp.atan(1)}") # Should be π/4
# Hyperbolic functions
print(f"sinh(1) = {mp.sinh(1)}")
print(f"cosh(1) = {mp.cosh(1)}")
print(f"tanh(1) = {mp.tanh(1)}")
# Special accuracy functions
small_x = mp.mpf('1e-10')
print(f"expm1({small_x}) = {mp.expm1(small_x)}") # More accurate than exp(x)-1
print(f"log1p({small_x}) = {mp.log1p(small_x)}") # More accurate than ln(1+x)