# `math` — Mathematical functions

This module provides access to common mathematical functions and constants, including those defined by the C standard.

Ці функції не можна використовувати з комплексними числами; використовуйте однойменні функції з модуля `cmath`, якщо вам потрібна підтримка комплексних чисел. Розрізнення між функціями, які підтримують комплексні числа, і тими, які не підтримують, зроблено, оскільки більшість користувачів не хочуть вивчати стільки математики, скільки потрібно для розуміння комплексних чисел. Отримання винятку замість комплексного результату дозволяє раніше виявити неочікуване комплексне число, яке використовується як параметр, щоб програміст міг визначити, як і чому воно взагалі було згенероване.

Цей модуль забезпечує такі функції. За винятком випадків, коли явно зазначено інше, усі повернуті значення є числами з плаваючою точкою.

Floating point arithmetic
`ceil(x)` | Ceiling of x, the smallest integer greater than or equal to x
`fabs(x)` | Absolute value of x
`floor(x)` | Floor of x, the largest integer less than or equal to x
`fma(x, y, z)` | Fused multiply-add operation: `(x * y) + z`
`fmax(x, y)` | Maximum of two floating-point values
`fmin(x, y)` | Minimum of two floating-point values
`fmod(x, y)` | Remainder of division `x / y`
`modf(x)` | Fractional and integer parts of x
`remainder(x, y)` | Remainder of x with respect to y
`trunc(x)` | Integer part of x
Floating point manipulation functions
`copysign(x, y)` | Magnitude (absolute value) of x with the sign of y
`frexp(x)` | Mantissa and exponent of x
`isclose(a, b, rel_tol, abs_tol)` | Check if the values a and b are close to each other
`isfinite(x)` | Check if x is neither an infinity nor a NaN
`isnormal(x)` | Check if x is a normal number
`issubnormal(x)` | Check if x is a subnormal number
`isinf(x)` | Check if x is a positive or negative infinity
`isnan(x)` | Check if x is a NaN (not a number)
`ldexp(x, i)` | `x * (2**i)`, inverse of function `frexp()`
`nextafter(x, y, steps)` | Floating-point value steps steps after x towards y
`signbit(x)` | Check if x is a negative number
`ulp(x)` | Value of the least significant bit of x
Power, exponential and logarithmic functions
`cbrt(x)` | Cube root of x
`exp(x)` | e raised to the power x
`exp2(x)` | 2 raised to the power x
`expm1(x)` | e raised to the power x, minus 1
`log(x, base)` | Logarithm of x to the given base (e by default)
`log1p(x)` | Natural logarithm of 1+x (base e)
`log2(x)` | Base-2 logarithm of x
`log10(x)` | Base-10 logarithm of x
`pow(x, y)` | x raised to the power y
`sqrt(x)` | Square root of x
Summation and product functions
`dist(p, q)` | Euclidean distance between two points p and q given as an iterable of coordinates
`fsum(iterable)` | Sum of values in the input iterable
`hypot(*coordinates)` | Euclidean norm of an iterable of coordinates
`prod(iterable, start)` | Product of elements in the input iterable with a start value
`sumprod(p, q)` | Sum of products from two iterables p and q
Angular conversion
`degrees(x)` | Convert angle x from radians to degrees
`radians(x)` | Convert angle x from degrees to radians
Trigonometric functions
`acos(x)` | Arc cosine of x
`asin(x)` | Arc sine of x
`atan(x)` | Arc tangent of x
`atan2(y, x)` | `atan(y / x)`
`cos(x)` | Cosine of x
`sin(x)` | Sine of x
`tan(x)` | Tangent of x
Hyperbolic functions
`acosh(x)` | Inverse hyperbolic cosine of x
`asinh(x)` | Inverse hyperbolic sine of x
`atanh(x)` | Inverse hyperbolic tangent of x
`cosh(x)` | Hyperbolic cosine of x
`sinh(x)` | Hyperbolic sine of x
`tanh(x)` | Hyperbolic tangent of x
Special functions
`erf(x)` | Error function at x
`erfc(x)` | Complementary error function at x
`gamma(x)` | Gamma function at x
`lgamma(x)` | Natural logarithm of the absolute value of the Gamma function at x
Constants
`pi` | π = 3.141592…
`e` | e = 2.718281…
`tau` | τ = 2π = 6.283185…
`inf` | Positive infinity
`nan` | «Not a number» (NaN)

## Floating point arithmetic

math.ceil(x)

  Повертає максимальне значення x, найменше ціле число, більше або рівне x. Якщо x не є числом з плаваючою точкою, делегує `x.__ceil__`, який має повернути значення `Integral`.

math.fabs(x)

  Повертає абсолютне значення x.

math.floor(x)

  Повертає нижню частину x, найбільше ціле число, менше або дорівнює x. Якщо x не є числом з плаваючою точкою, делегує `x.__floor__`, який має повернути значення `Integral`.

math.fma(x, y, z)

  Fused multiply-add operation. Return `(x * y) + z`, computed as though with infinite precision and range followed by a single round to the `float` format. This operation often provides better accuracy than the direct expression `(x * y) + z`.

  This function follows the specification of the fusedMultiplyAdd operation described in the IEEE 754 standard. The standard leaves one case implementation-defined, namely the result of `fma(0, inf, nan)` and `fma(inf, 0, nan)`. In these cases, `math.fma` returns a NaN, and does not raise any exception.

  Added in version 3.13.

math.fmax(x, y)

  Get the larger of two floating-point values, treating NaNs as missing data.

  When both operands are (signed) NaNs or zeroes, return `nan` and `0` respectively and the sign of the result is implementation-defined, that is, `fmax()` is not required to be sensitive to the sign of such operands (see Annex F of the C11 standard, §F.10.0.3 and §F.10.9.2).

  Added in version 3.15.

math.fmin(x, y)

  Get the smaller of two floating-point values, treating NaNs as missing data.

  When both operands are (signed) NaNs or zeroes, return `nan` and `0` respectively and the sign of the result is implementation-defined, that is, `fmin()` is not required to be sensitive to the sign of such operands (see Annex F of the C11 standard, §F.10.0.3 and §F.10.9.3).

  Added in version 3.15.

math.fmod(x, y)

  Return the floating-point remainder of `x / y`, as defined by the platform C library function `fmod(x, y)`. Note that the Python expression `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 magnitude 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 surprising `1e100`. For this reason, function `fmod()` is generally preferred when working with floats, while Python’s `x % y` is preferred when working with integers.

math.modf(x)

  Повертає дробову та цілу частини x. Обидва результати мають знак x і є числами з плаваючою точкою.

  Note that `modf()` has a different call/return pattern than its C equivalents: it takes a single argument and return a pair of values, rather than returning its second return value through an „output parameter“ (there is no such thing in Python).

math.remainder(x, y)

  Повертає залишок x у стилі IEEE 754 відносно y. Для кінцевого x і кінцевого ненульового y це різниця `x - n*y`, де `n` є найближчим цілим числом до точного значення частки `x / y` . Якщо `x / y` знаходиться точно посередині між двома послідовними цілими числами, для `n` використовується найближче парне ціле число. Таким чином, залишок `r = залишок(x, y)` завжди задовольняє `abs(r) <= 0,5 * abs(y)`.

  Спеціальні випадки відповідають стандарту IEEE 754: зокрема, `remainder(x, math.inf)` є x для будь-якого кінцевого x, а `remainder(x, 0)` і `remainder(math.inf). inf, x)` підняти `ValueError` для будь-якого не-NaN x. Якщо результатом операції залишку є нуль, цей нуль матиме той самий знак, що й x.

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

  Added in version 3.7.

math.trunc(x)

  Поверніть x із видаленням дробової частини, залишаючи цілу частину. Це округляє до 0: `trunc()` еквівалентно `floor()` для додатного x та еквівалентно `ceil()` для від’ємного x. Якщо x не є числом з плаваючою точкою, делегує `x.__trunc__`, який має повернути значення `Integral`.

Для функцій `ceil()`, `floor()` і `modf()` зауважте, що всі числа з плаваючою комою досить великої величини є точними цілими числами. Python зазвичай містить не більше 53 бітів точності (так само, як і подвійний тип платформи C), у цьому випадку будь-яке число з плаваючою речовиною x із `abs(x) >= 2**52` обов’язково не має дробових бітів. .

## Floating point manipulation functions

math.copysign(x, y)

  Повертає число з плаваючою точкою з величиною (абсолютним значенням) x, але зі знаком y. На платформах, які підтримують нулі зі знаком, `copysign(1.0, -0.0)` повертає -1.0.

math.frexp(x)

  Повертає мантису та експонент x як пару `(m, e)`. m є числом з плаваючою точкою, а e є цілим числом таким чином, що `x == m * 2**e` точно. Якщо x дорівнює нулю, повертає `(0,0, 0)`, інакше `0,5 <= abs(m) < 1`. Це використовується, щоб «розібрати» внутрішнє представлення float переносним способом.

  Note that `frexp()` has a different call/return pattern than its C equivalents: it takes a single argument and return a pair of values, rather than returning its second return value through an „output parameter“ (there is no such thing in Python).

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

  Повертає `True`, якщо значення a і b близькі одне до одного, і `False` в іншому випадку.

  Whether or not two values are considered close is determined according to given absolute and relative tolerances. If no errors occur, the result will be: `abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)`.

  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 tolerance 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 nonnegative and less than `1.0`.

  abs_tol is the absolute tolerance; it defaults to `0.0` and it must be nonnegative. When comparing `x` to `0.0`, `isclose(x, 0)` is computed as `abs(x) <= rel_tol * abs(x)`, which is `False` for any nonzero `x` and rel_tol less than `1.0`. So add an appropriate positive abs_tol argument to the call.

  Спеціальні значення IEEE 754 `NaN`, `inf` і `-inf` оброблятимуться відповідно до правил IEEE. Зокрема, `NaN` не вважається близьким до будь-якого іншого значення, включаючи `NaN`. `inf` і `-inf` вважаються лише близькими до самих себе.

  Added in version 3.5.

  Дивись також

  PEP 485 – Функція для перевірки приблизної рівності

math.isfinite(x)

  Повертає `True`, якщо x не є ні нескінченністю, ні NaN, і `False` в іншому випадку. (Зверніть увагу, що `0.0` вважається кінцевим.)

  Added in version 3.2.

math.isnormal(x)

  Return `True` if x is a normal number, that is a finite nonzero number that is not a subnormal (see `issubnormal()`). Return `False` otherwise.

  Added in version 3.15.

math.issubnormal(x)

  Return `True` if x is a subnormal number, that is a finite nonzero number with a magnitude smaller than `sys.float_info.min`. Return `False` otherwise.

  Added in version 3.15.

math.isinf(x)

  Повертає `True`, якщо x є додатною або від’ємною нескінченністю, і `False` в іншому випадку.

math.isnan(x)

  Повертає `True`, якщо x є NaN (а не число), і `False` в іншому випадку.

math.ldexp(x, i)

  Повернути `x * (2**i)`. По суті, це зворотна функція `frexp()`.

math.nextafter(x, y, steps=1)

  Return the floating-point value steps steps after x towards y.

  If x is equal to y, return y, unless steps is zero.

  приклади:

  - `math.nextafter(x, math.inf)` йде вгору: до позитивної нескінченності.

  - `math.nextafter(x, -math.inf)` йде вниз: до мінус нескінченності.

  - `math.nextafter(x, 0.0)` рухається до нуля.

  - `math.nextafter(x, math.copysign(math.inf, x))` відходить від нуля.

  Дивіться також `math.ulp()`.

  Added in version 3.9.

  Змінено в версії 3.12: Added the steps argument.

math.signbit(x)

  Return `True` if the sign of x is negative and `False` otherwise.

  This is useful to detect the sign bit of zeroes, infinities and NaNs.

  Added in version 3.15.

math.ulp(x)

  Повертає значення молодшого біта числа з плаваючою точкою x:

  - Якщо x є NaN (а не числом), поверніть x.

  - Якщо x від’ємне, поверніть `ulp(-x)`.

  - Якщо x є позитивною нескінченністю, поверніть x.

  - Якщо x дорівнює нулю, поверніть найменше додатне деноралізоване число з плаваючою точкою (менше ніж мінімальне позитивне нормалізоване число з плаваючою точкою, `sys.float_info.min`).

  - Якщо x дорівнює найбільшому додатному репрезентативному float, поверніть значення молодшого значущого біта x, щоб перше число з плаваючою точкою, менше за x, було `x - ulp(x)`.

  - В іншому випадку (x — додатне скінченне число) поверніть значення молодшого біта x, щоб перше число з плаваючою речовиною, більше за x, було `x + ulp(x)`.

  ULP розшифровується як «Unit in the Last Place».

  Дивіться також `math.nextafter()` і `sys.float_info.epsilon`.

  Added in version 3.9.

## Power, exponential and logarithmic functions

math.cbrt(x)

  Return the cube root of x.

  Added in version 3.11.

math.exp(x)

  Поверніть e у степені x, де e = 2,718281… є основою натуральних логарифмів. Зазвичай це точніше, ніж `math.e ** x` або `pow(math.e, x)`.

math.exp2(x)

  Return 2 raised to the power x.

  Added in version 3.11.

math.expm1(x)

  Return e raised to the power x, minus 1. Here e is the base of natural logarithms. For small floats x, the subtraction in `exp(x) - 1` can result in a significant loss of precision; the `expm1()` function provides a way to compute this quantity to full precision:

      >>> from math import exp, expm1
      >>> exp(1e-5) - 1  # gives result accurate to 11 places
      1.0000050000069649e-05
      >>> expm1(1e-5)    # result accurate to full precision
      1.0000050000166668e-05

  Added in version 3.2.

math.log(x[, base])

  З одним аргументом повертає натуральний логарифм x (за основою e).

  З двома аргументами повертає логарифм від x до заданої основи, обчислений як `log(x)/log(основа)`.

math.log1p(x)

  Повертає натуральний логарифм 1+x (за основою e). Результат обчислюється таким чином, що є точним для x біля нуля.

math.log2(x)

  Повертає логарифм x за основою 2. Зазвичай це точніше, ніж `log(x, 2)`.

  Added in version 3.3.

  Дивись також

  `int.bit_length()` повертає кількість бітів, необхідну для представлення цілого числа в двійковій формі, за винятком знака та нулів на початку.

math.log10(x)

  Повертає логарифм x за основою 10. Зазвичай це точніше, ніж `log(x, 10)`.

math.pow(x, y)

  Return x raised to the power y. Exceptional cases follow the IEEE 754 standard as far as possible. In particular, `pow(1.0, x)` and `pow(x, 0.0)` always return `1.0`, even when x is a zero or a NaN. If both x and y are finite, x is negative, and y is not an integer then `pow(x, y)` is undefined, and raises `ValueError`.

  На відміну від вбудованого оператора `**`, `math.pow()` перетворює обидва свої аргументи на тип `float`. Використовуйте `**` або вбудовану функцію `pow()` для обчислення точних цілих степенів.

  Змінено в версії 3.11: The special cases `pow(0.0, -inf)` and `pow(-0.0, -inf)` were changed to return `inf` instead of raising `ValueError`, for consistency with IEEE 754.

math.sqrt(x)

  Повертає квадратний корінь з x.

## Summation and product functions

math.dist(p, q)

  Повертає евклідову відстань між двома точками p і q, кожна з яких задана як послідовність (або повторювана) координат. Дві точки повинні мати однаковий розмір.

  Приблизно еквівалентно:

      sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q, strict=True)))

  Added in version 3.8.

math.fsum(iterable)

  Return an accurate floating-point sum of values in the iterable. Avoids loss of precision by tracking multiple intermediate partial sums.

  Точність алгоритму залежить від арифметичних гарантій IEEE-754 і типового випадку, коли режим округлення є напівпарним. У деяких збірках, відмінних від Windows, базова бібліотека C використовує розширену точність додавання та іноді може подвоїти округлення проміжної суми, спричиняючи її вимкнення у своєму молодшому розряді.

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

math.hypot(*coordinates)

  Повертає евклідову норму, `sqrt(sum(x**2 для x у координатах))`. Це довжина вектора від початку координат до точки, заданої координатами.

  Для двовимірної точки `(x, y)` це еквівалентно обчисленню гіпотенузи прямокутного трикутника за допомогою теореми Піфагора `sqrt(x*x + y*y)`.

  Змінено в версії 3.8: Додано підтримку n-вимірних точок. Раніше підтримувався лише двовимірний випадок.

  Змінено в версії 3.10: Покращено точність алгоритму, щоб максимальна помилка була менше 1 ulp (одиниця на останньому місці). Як правило, результат майже завжди правильно округлюється з точністю до 1/2 ulp.

math.prod(iterable, *, start=1)

  Обчислити добуток усіх елементів у вхідному iterable. Типовим початковим значенням для продукту є «1».

  Коли iterable порожній, поверніть початкове значення. Ця функція призначена спеціально для використання з числовими значеннями та може відхиляти нечислові типи.

  Added in version 3.8.

math.sumprod(p, q)

  Return the sum of products of values from two iterables p and q.

  Raises `ValueError` if the inputs do not have the same length.

  Приблизно еквівалентно:

      sum(map(operator.mul, p, q, strict=True))

  For float and mixed int/float inputs, the intermediate products and sums are computed with extended precision.

  Added in version 3.12.

## Кутове перетворення

math.degrees(x)

  Перетворіть кут x з радіан на градуси.

math.radians(x)

  Переведіть кут x із градусів у радіани.

## Тригонометричні функції

math.acos(x)

  Повертає арккосинус x у радіанах. Результат між `0` і `pi`.

math.asin(x)

  Повертає арксинус x у радіанах. Результат знаходиться між `-pi/2` і `pi/2`.

math.atan(x)

  Повертає арктангенс x у радіанах. Результат знаходиться між `-pi/2` і `pi/2`.

math.atan2(y, x)

  Повертає `atan(y / x)`, у радіанах. Результат знаходиться між `-pi` і `pi`. Вектор у площині від початку координат до точки «(x, y)» утворює цей кут із додатною віссю X. Суть `atan2()` полягає в тому, що йому відомі знаки обох вхідних даних, тому він може обчислити правильний квадрант для кута. Наприклад, `atan(1)` і `atan2(1, 1)` обидва є `pi/4`, але `atan2(-1, -1)` є `-3*pi/4`.

math.cos(x)

  Повертає косинус x радіан.

math.sin(x)

  Повернути синус x радіан.

math.tan(x)

  Повертає тангенс x радіан.

## Гіперболічні функції

Hyperbolic functions are analogs of trigonometric functions that are based on hyperbolas instead of circles.

math.acosh(x)

  Повертає арккосинус x.

math.asinh(x)

  Повертає гіперболічний арксинус x.

math.atanh(x)

  Повертає гіперболічний обернений тангенс x.

math.cosh(x)

  Повертає гіперболічний косинус x.

math.sinh(x)

  Повернути гіперболічний синус x.

math.tanh(x)

  Поверніть гіперболічний тангенс x.

## Спеціальні функції

math.erf(x)

  Повертає функцію помилки у x.

  The `erf()` function can be used to compute traditional statistical functions such as the cumulative standard normal distribution:

      def phi(x):
          'Cumulative distribution function for the standard normal distribution'
          return (1.0 + erf(x / sqrt(2.0))) / 2.0

  Added in version 3.2.

math.erfc(x)

  Повертає функцію додаткової помилки в x. Додаткова функція помилок визначається як `1.0 - erf(x)`. Він використовується для великих значень x, де віднімання від одиниці спричинило б втрату значущості.

  Added in version 3.2.

math.gamma(x)

  Повертає Гамма-функцію у x.

  Added in version 3.2.

math.lgamma(x)

  Повертає натуральний логарифм абсолютного значення гамма-функції при x.

  Added in version 3.2.

## Number-theoretic functions

For backward compatibility, the `math` module provides also aliases of the following functions from the `math.integer` module:

`comb(n, k)` | Number of ways to choose k items from n items without repetition and without order
`factorial(n)` | n factorial
`gcd(*integers)` | Greatest common divisor of the integer arguments
`isqrt(n)` | Integer square root of a nonnegative integer n
`lcm(*integers)` | Least common multiple of the integer arguments
`perm(n, k)` | Number of ways to choose k items from n items without repetition and with order

Added in version 3.5: The `gcd()` function.

Added in version 3.8: The `comb()`, `perm()` and `isqrt()` functions.

Added in version 3.9: The `lcm()` function.

Змінено в версії 3.9: Added support for an arbitrary number of arguments in the `gcd()` function. Formerly, only two arguments were supported.

Змінено в версії 3.10: Floats with integral values (like `5.0`) are no longer accepted in the `factorial()` function.

Soft deprecated since version 3.15: Use the `math.integer` functions instead of these aliases.

## Константи

math.pi

  Математична константа π = 3,141592… з доступною точністю.

math.e

  Математична константа e = 2,718281… з доступною точністю.

math.tau

  The mathematical constant τ = 6.283185…, to available precision. Tau is a circle constant equal to 2π, the ratio of a circle’s circumference to its radius. To learn more about Tau, check out Vi Hart’s video Pi is (still) Wrong, and start celebrating Tau day by eating twice as much pie!

  Added in version 3.6.

math.inf

  Додатна нескінченність із плаваючою комою. (Для негативної нескінченності використовуйте `-math.inf`.) Еквівалент виведення `float('inf')`.

  Added in version 3.5.

math.nan

  A floating-point «not a number» (NaN) value. Equivalent to the output of `float('nan')`. Due to the requirements of the IEEE-754 standard, `math.nan` and `float('nan')` are not considered to equal to any other numeric value, including themselves. To check whether a number is a NaN, use the `isnan()` function to test for NaNs instead of `is` or `==`. Example:

      >>> import math
      >>> math.nan == math.nan
      False
      >>> float('nan') == float('nan')
      False
      >>> math.isnan(math.nan)
      True
      >>> math.isnan(float('nan'))
      True

  Added in version 3.5.

  Змінено в версії 3.11: It is now always available.

Деталі реалізації CPython: The `math` module consists mostly of thin wrappers around the platform C math library functions. Behavior in exceptional cases follows Annex F of the C99 standard where appropriate. The current implementation will raise `ValueError` for invalid operations like `sqrt(-1.0)` or `log(0.0)` (where C99 Annex F recommends signaling invalid operation or divide-by-zero), and `OverflowError` for results that overflow (for example, `exp(1000.0)`). A NaN will not be returned from any of the functions above unless one or more of the input arguments was a NaN; in that case, most functions will return a NaN, but (again following C99 Annex F) there are some exceptions to this rule, for example `pow(float('nan'), 0.0)` or `hypot(float('nan'), float('inf'))`.

Зауважте, що Python не робить жодних зусиль, щоб відрізнити сигнальні NaN від тихих NaN, і поведінка для сигнальних NaN залишається невизначеною. Типовою поведінкою є ставлення до всіх NaN так, ніби вони тихі.

Дивись також

Модуль `cmath`

  Версії комплексних чисел багатьох із цих функцій.

Module `math.integer`

  Integer-specific mathematics functions.