math — Mathematical functions

This module provides access to the mathematical functions defined by the C standar
d.

These functions cannot be used with complex numbers; use the functions of the sam
e name from the cmath module if you require support for complex numbers. The disti
nction between functions which support complex numbers and those which don’t is
made since most users do not want to learn quite as much mathematics as required
to understand complex numbers. Receiving an exception instead of a complex result
allows earlier detection of the unexpected complex number used as a parameter, so
that the programmer can determine how and why it was generated in the first place.

The following functions are provided by this module. Except when explicitly noted oth
erwise, all return values are floats.

Number-theoretic and representation functions

math.ceil(x)
Return the ceiling of x, the smallest integer greater than or equal to x. If x is n
ot a float, delegates to x.__ceil__(), which should return an Integral value.

math.comb(n, k)
Return the number of ways to choose k items from n items without repetition a
nd without order.

Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates to zero when k

> n.

Also called the binomial coefficient because it is equivalent to the coefficient o

f k-th term in polynomial expansion of the expression (1 + x) ** n.

Raises TypeError if either of the arguments are not integers. Raises ValueError
if either of the arguments are negative.

New in version 3.8.

math.copysign(x, y)
Return a float with the magnitude (absolute value) of x but the sign of y. On pl
atforms that support signed zeros, copysign(1.0, -0.0) returns -1.0.
 math.fabs(x)
Return the absolute value of x.

math.factorial(x)
Return x factorial as an integer. Raises ValueError if x is not integral or is negat
ive.

Deprecated since version 3.9: Accepting floats with integral values (like 5.0) i
s deprecated.

math.floor(x)
Return the floor of x, the largest integer less than or equal to x. If x is not a flo
at, delegates to x.__floor__(), which should return an Integral value.

math.fmod(x, y)
Return fmod(x, y), as defined by the platform C library. Note that the Python e
xpression x % y may not return the same result. The intent of the C standard
is that fmod(x, y) be exactly (mathematically; to infinite precision) equal to x -
n*y for some integer n such that the result has the same sign as x and magnit
ude less than abs(y). Python’s x % y returns a result with the sign of y instead
, and may not be exactly computable for float arguments. For example, fmod(-
1e-100, 1e100) is -1e-100, but the result of Python’s -1e-100 % 1e100 is 1e100-
1e-100, which cannot be represented exactly as a float, and rounds to the surp
rising 1e100. For this reason, function fmod() is generally preferred when worki
ng with floats, while Python’s x % y is preferred when working with integers.

math.frexp(x)
Return the mantissa and exponent of x as the pair (m, e). m is a float and e is
an integer such that x == m * 2**e exactly. If x is zero, returns (0.0, 0), other
wise 0.5 <= abs(m) < 1. This is used to “pick apart” the internal representatio
n of a float in a portable way.

math.fsum(iterable)
Return an accurate floating point sum of values in the iterable. Avoids loss of
precision by tracking multiple intermediate partial sums:

>>>
>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
0.9999999999999999
>>> fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
1.0
The algorithm’s accuracy depends on IEEE-754 arithmetic guarantees and th
e typical case where the rounding mode is half-even. On some non-Windows
builds, the underlying C library uses extended precision addition and may occ
asionally double-round an intermediate sum causing it to be off in its least sig
nificant bit.

For further discussion and two alternative approaches, see the ASPN cookbo
ok recipes for accurate floating point summation.

math.gcd(*integers)
Return the greatest common divisor of the specified integer arguments. If any
of the arguments is nonzero, then the returned value is the largest positive int
eger that is a divisor af all arguments. If all arguments are zero, then the retur
ned value is 0. gcd() without arguments returns 0.

New in version 3.5.

Changed in version 3.9: Added support for an arbitrary number of arguments.

Formerly, only two arguments were supported.

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

Return True if the values a and b are close to each other and False otherwise.

Whether or not two values are considered close is determined according to gi

ven absolute and relative tolerances.

rel_tol is the relative tolerance – it is the maximum allowed difference between

a and b, relative to the larger absolute value of a or b. For example, to set a to
lerance of 5%, pass rel_tol=0.05. The default tolerance is 1e-09, which assures
that the two values are the same within about 9 decimal digits. rel_tol must be
greater than zero.

abs_tol is the minimum absolute tolerance – useful for comparisons near zero
. abs_tol must be at least zero.

If no errors occur, the result will be: abs(a-b) <= max(rel_tol * max(abs(a), abs(b
)), abs_tol).

The IEEE 754 special values of NaN, inf, and -inf will be handled according to
IEEE rules. Specifically, NaN is not considered close to any other value, includ
ing NaN. inf and -inf are only considered close to themselves.

New in version 3.5.

See also

PEP 485 – A function for testing approximate equality

math.isfinite(x)
Return True if x is neither an infinity nor a NaN, and False otherwise. (Note that
0.0 is considered finite.)

New in version 3.2.

math.isinf(x)
Return True if x is a positive or negative infinity, and False otherwise.

math.isnan(x)
Return True if x is a NaN (not a number), and False otherwise.

math.isqrt(n)
Return the integer square root of the nonnegative integer n. This is the floor of
the exact square root of n, or equivalently the greatest integer a such that a² ≤
n.

For some applications, it may be more convenient to have the least integer a
such that n ≤ a², or in other words the ceiling of the exact square root of n. For
positive n, this can be computed using a = 1 + isqrt(n - 1).

New in version 3.8.

math.lcm(*integers)
Return the least common multiple of the specified integer arguments. If all arg
uments are nonzero, then the returned value is the smallest positive integer th
at is a multiple of all arguments. If any of the arguments is zero, then the retur
ned value is 0. lcm() without arguments returns 1.

New in version 3.9.

math.ldexp(x, i)
Return x * (2**i). This is essentially the inverse of function frexp().

math.modf(x)
Return the fractional and integer parts of x. Both results carry the sign of x an
d are floats.

math.nextafter(x, y)
Return the next floating-point value after x towards y.

If x is equal to y, return y.

Examples:

 math.nextafter(x, math.inf) goes up: towards positive infinity.

 math.nextafter(x, -math.inf) goes down: towards minus infinity.
 math.nextafter(x, 0.0) goes towards zero.
 math.nextafter(x, math.copysign(math.inf, x)) goes away from zero.

See also math.ulp().

New in version 3.9.

math.perm(n, k=None)
Return the number of ways to choose k items from n items without repetition a
nd with order.

Evaluates to n! / (n - k)! when k <= n and evaluates to zero when k > n.

If k is not specified or is None, then k defaults to n and the function returns n!.

Raises TypeError if either of the arguments are not integers. Raises ValueError
if either of the arguments are negative.

New in version 3.8.

math.prod(iterable, *, start=1)
Calculate the product of all the elements in the input iterable. The default start
value for the product is 1.

When the iterable is empty, return the start value. This function is intended sp
ecifically for use with numeric values and may reject non-numeric types.

New in version 3.8.

math.remainder(x, y)
Return the IEEE 754-style remainder of x with respect to y. For finite x and fini
te nonzero y, this is the difference x - n*y, where n is the closest integer to th
e exact value of the quotient x / y. If x / y is exactly halfway between two co
nsecutive integers, the nearest even integer is used for n. The remainder r =
remainder(x, y) thus always satisfies abs(r) <= 0.5 * abs(y).

Special cases follow IEEE 754: in particular, remainder(x, math.inf) is x for any f
inite x, and remainder(x, 0) and remainder(math.inf, x) raise ValueError for any no
n-NaN x. If the result of the remainder operation is zero, that zero will have th
e same sign as x.

On platforms using IEEE 754 binary floating-point, the result of this operation i
s always exactly representable: no rounding error is introduced.

New in version 3.7.

math.trunc(x)
Return the Real value x truncated to an Integral (usually an integer). Delegates
to x.__trunc__().

math.ulp(x)
Return the value of the least significant bit of the float x:

 If x is a NaN (not a number), return x.

 If x is negative, return ulp(-x).
 If x is a positive infinity, return x.
 If x is equal to zero, return the smallest positive denormalized represen
table float (smaller than the minimum positive normalized float, sys.float
_info.min).
 If x is equal to the largest positive representable float, return the value
of the least significant bit of x, such that the first float smaller than x is x
- ulp(x).
 Otherwise (x is a positive finite number), return the value of the least si
gnificant bit of x, such that the first float bigger than x is x + ulp(x).

ULP stands for “Unit in the Last Place”.