# Python math

Python `math` module consists of important constants like pi, tau, etc. and most of commonly used mathematical functions. We can use all these functions in our programming while solving the poblems.

## python math constants¶

### math.pi¶

• It represents the mathematical constant `π = 3.14159`
• Let's write a simple program to calculate the area of a circle
``````import math

area = math.pi * radius ** 2
return area
``````

### math.e¶

• It represents the mathematical constant `e = 2.718281`
• It's also called the Euler’s number.
``````import math

print(math.e)
# output: 2.718281828459045
``````

### math.tau¶

• It represents the mathematical constant `τ = 6.28318`
``````import math
print(math.tau)
# output: 6.283185307179586
``````

### math.inf¶

• It represents the value of floating-point infinity
``````import math
print(math.inf)
# output: inf
``````

### math.nan¶

• It represents floating-point `NaN` value which means `Not a Number`
``````import math
print(math.nan)
# output: nan
``````

## python math functions¶

• The numeric functions in the math module take real numbers/integers as arguments and after doing the specified mathematical calculations, it returns a number or a boolean value.

### math.ceil(x)¶

• Rounds a number up to the nearest integer
``````import math

print(math.ceil(1.4))
# output: 2
print(math.ceil(-5.3))
# output: -5
``````

### math.floor(x)¶

• Rounds a number down to the nearest integer
``````import math

print(math.floor(0.6))
# output: 0
print(math.floor(1.4))
# output: 1
``````

### math.fabs(x)¶

``````import math

print(math.fabs(7.5))
# output: 7.5
print(math.fabs(-7.5))
# output: 7.5
``````

### math.copysign(x,y)¶

• Returns a float consisting of the value of the first parameter and the sign of the second parameter
``````import math

print(math.copysign(7.5, -1))
# output: -7.5
print(math.copysign(-120, 100))
# output: 120.0
``````

### math.factorial(x)¶

• Returns the factorial of a given number
``````import math

print(math.factorial(5))
# output: 120
print(math.factorial(16))
# output: 20922789888000
``````

### math.fmod(x,y)¶

• Returns the remainder of x/y
``````import math

print(math.fmod(23, 6))
# output: 5.0
``````

### math.gcd(x,y)¶

• Returns the greatest common divisor of two integers
``````import math

print(math.gcd(23, 6))
# output: 1
``````

### math.comb(n,r)¶

• Returns the number of ways to choose k items from n items without repetition and order
``````import math

print(math.comb(5, 3))
# output: 10
``````

### 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), otherwise 0.5 <= abs(m) < 1. This is used to “pick apart” the internal representation of a float in a portable way.
``````import math

print(math.frexp(5))
# output: (0.625, 3)
``````

### math.fsum(iterable)¶

• Returns the sum of all items in any iterable (tuples, arrays, lists, etc.)
``````import math

print(math.fsum([5, 3, 7]))
# output: 15.0
``````

### math.isclose(x, y, rel_tol = 1e-09, abs_tol = 0.0)¶

• Checks whether two values are close to each other, or not
``````import math

print(math.isclose(1.233, 1.233))
# output: True
print(math.isclose(1.233, 1.24))
# output: False
``````

### math.isfinite(x)¶

• Check whether a value is finite or not
``````import math

print(math.isfinite(100))
# output: True
print(math.isfinite(float("-inf")))
# output: False
print(math.isfinite(math.inf))
# output: False
print(math.isfinite(0))
# output: True
``````

### math.isinf(x)¶

• Checks whether a number is infinite or not
``````import math

print(math.isinf(math.inf))
# output: True
print(math.isinf(0))
# output: False
``````

### math.isnan(x)¶

• Checks whether a value is NaN (not a number) or not
``````import math

print(math.isnan(math.nan))
# output: True
print(math.isnan(10))
# output: False
``````

### math.sqrt(x)¶

• Return the square root of x.
``````import math

print(math.sqrt(100))
# output: 10.0
print(math.sqrt(10))
# output: 3.1622776601683795
``````

### math.isqrt(x)¶

• Rounds a square root number downwards to the nearest integer
``````import math

print(math.isqrt(100))
# output: 10.0
print(math.isqrt(10))
# output: 3
``````

### math.lcm(x,y,z….)¶

• Return the least common multiple of the specified integer arguments.
``````import math

print(math.lcm(10, 15, 21, 8))
# output: 840
``````

Note: only available after 3.9

### math.ldexp(x,i)¶

• Return x * (2**i). This is essentially the inverse of function frexp().
``````import math

print(math.ldexp(9, 3))
# output: 72.0
print(math.ldexp(-5, 2))
# output: -20
``````

### math.modf(x)¶

• Return the fractional and integer parts of x. Both results carry the sign of x and are floats.
``````import math

print(math.modf(9))
# output: (0.0, 9.0)
print(math.modf(12.5))
# output: (0.5, 12.0)
``````

### math.nextafter(x,y)¶

• Return the next floating-point value after x towards y.
``````import math

print(math.nextafter(-5, math.inf))
# output: -4.999999999999999
print(math.nextafter(10, -math.inf))
# output: 9.999999999999998
print(math.nextafter(16, 0.0))
# output: 15.999999999999998
``````

### 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.
``````import math

print(math.prod([1,2,3,4,5,6]))
# output: 720
print(math.prod([]))
# output: 1
``````

### math.remainder(x,y)¶

• Returns the closest value that can make numerator completely divisible by the denominator
``````import math

print(math.remainder(17, 2))
# output: 1
print(math.remainder(2, 17))
# output: 2
``````

### math.trunc(x)¶

• Returns the truncated integer parts of a number
``````import math

print(math.trunc(2.77))
# output: 2
print(math.trunc(-3.77))
# output: -3
``````

### math.pow(x, y)¶

• Returns the value of x to the power of y
``````import math

print(math.pow(2, 4))
# output: 16.0
``````

### math.exp(x)¶

• Return e raised to the power x, where e = 2.718281… is the base of natural logarithms.
``````import math

print(math.exp(4))
# output: 54.598150033144236
print(math.exp(-6.89))
# output: 0.0010179138409954387
``````

### math.expm1(x)¶

• Return e raised to the power x, minus 1. Here e is the base of natural logarithms.
``````import math

print(math.expm1(4))
# output: 53.598150033144236
``````

### math.log(x, [b])¶

• return the logarithm of x to the given base, calculated as log(x)/log(base).
``````import math

print(math.log(10, 2))
# output: 3.3219280948873626
``````

### math.log1p(x)¶

• Return the natural logarithm of 1+x (base e). The result is calculated in a way which is accurate for x near zero.
``````import math

print(math.log1p(10))
# output: 2.3978952727983707
``````

### math.log2(x)¶

• Return the base-2 logarithm of x. This is usually more accurate than log(x, 2).
``````import math

print(math.log2(10))
# output: 3.321928094887362
``````
• Math module also provides trignometric calculations also.

Note: If you want more advanced maths then look at python packages like Numpy, SciPy, Statsmodel, Scikit-learn, etc.