Standard library header <cmath>

From cppreference.net

< cpp ‎ | header

Этот заголовочный файл изначально находился в стандартной библиотеке C как <math.h> .

Этот заголовок является частью numeric библиотеки.

Содержание

Типы

float_t

(C++11)

наиболее эффективный тип с плавающей точкой, как минимум такой же ширины, как float
(typedef)

double_t

(C++11)

наиболее эффективный тип с плавающей точкой, как минимум такой же ширины, как double
(typedef)

Макросы

HUGE_VALF HUGE_VAL HUGE_VALL

(C++11) (C++11)

указывает значение переполнения для float , double и long double соответственно
(макрос-константа)

INFINITY

(C++11)

вычисляется в положительную бесконечность или значение, гарантированно вызывающее переполнение float
(макроконстанта)

NAN

(C++11)

возвращает тихий NaN типа float
(макроконстанта)

math_errhandling MATH_ERRNO MATH_ERREXCEPT

(C++11) (C++11) (C++11)

определяет механизм обработки ошибок, используемый общими математическими функциями
(макроконстанта)

Классификация

FP_NORMAL FP_SUBNORMAL FP_ZERO FP_INFINITE FP_NAN

(C++11) (C++11) (C++11) (C++11) (C++11)

указывает категорию чисел с плавающей запятой
(макроконстанта)

Функции

Основные операции

abs (float) fabs fabsf fabsl

(C++11) (C++11)

абсолютное значение числа с плавающей точкой (

|x|

)
(функция)

fmod fmodf fmodl

(C++11) (C++11)

остаток от операции деления чисел с плавающей запятой
(функция)

remainder remainderf remainderl

(C++11) (C++11) (C++11)

знаковый остаток от операции деления
(функция)

remquo remquof remquol

(C++11) (C++11) (C++11)

знаковый остаток, а также три последних бита операции деления
(функция)

fma fmaf fmal

(C++11) (C++11) (C++11)

операция умножения-сложения с объединением
(функция)

fmax fmaxf fmaxl

(C++11) (C++11) (C++11)

большее из двух значений с плавающей точкой
(функция)

fmin fminf fminl

(C++11) (C++11) (C++11)

меньшее из двух значений с плавающей точкой
(функция)

fdim fdimf fdiml

(C++11) (C++11) (C++11)

положительная разность двух значений с плавающей точкой (

max(0, x-y)

)
(функция)

nan nanf nanl

(C++11) (C++11) (C++11)

не-число (NaN)
(функция)

Линейная интерполяция

lerp

(C++20)

функция линейной интерполяции
(функция)

Экспоненциальные функции

exp expf expl

(C++11) (C++11)

возвращает

e

в указанной степени (

e x

)
(функция)

exp2 exp2f exp2l

(C++11) (C++11) (C++11)

возвращает

2

в заданной степени (

2 x

)
(функция)

expm1 expm1f expm1l

(C++11) (C++11) (C++11)

возвращает число

e

, возведённое в заданную степень, минус

1

(

e x -1

)
(функция)

log logf logl

(C++11) (C++11)

вычисляет натуральный (по основанию

e

) логарифм (

ln(x)

)
(функция)

log10 log10f log10l

(C++11) (C++11)

вычисляет десятичный логарифм (основание

10

) (

log 10 (x)

)
(функция)

log2 log2f log2l

(C++11) (C++11) (C++11)

логарифм по основанию

2

от заданного числа (

log 2 (x)

)
(функция)

log1p log1pf log1pl

(C++11) (C++11) (C++11)

натуральный логарифм (по основанию

e

) от

1

плюс заданное число (

ln(1+x)

)
(функция)

Степенные функции

pow powf powl

(C++11) (C++11)

возводит число в заданную степень (

x y

)
(функция)

sqrt sqrtf sqrtl

(C++11) (C++11)

вычисляет квадратный корень (

\sqrt x

)
(функция)

cbrt cbrtf cbrtl

(C++11) (C++11) (C++11)

вычисляет кубический корень (

3 \sqrt x

)
(функция)

hypot hypotf hypotl

(C++11) (C++11) (C++11)

вычисляет гипотенузу

\sqrt x 2 +y 2

\sqrt x 2 +y 2 +z 2

(начиная с C++17)
(функция)

Тригонометрические функции

sin sinf sinl

(C++11) (C++11)

вычисляет синус (

sin(x)

)
(функция)

cos cosf cosl

(C++11) (C++11)

вычисляет косинус (

cos(x)

)
(функция)

tan tanf tanl

(C++11) (C++11)

вычисляет тангенс (

tan(x)

)
(функция)

asin asinf asinl

(C++11) (C++11)

вычисляет арксинус (

arcsin(x)

)
(функция)

acos acosf acosl

(C++11) (C++11)

вычисляет арккосинус (

arccos(x)

)
(функция)

atan atanf atanl

(C++11) (C++11)

вычисляет арктангенс (

arctan(x)

)
(функция)

atan2 atan2f atan2l

(C++11) (C++11)

арктангенс, использующий знаки для определения квадрантов
(функция)

Гиперболические функции

sinh sinhf sinhl

(C++11) (C++11)

вычисляет гиперболический синус (

sinh(x)

)
(функция)

cosh coshf coshl

(C++11) (C++11)

вычисляет гиперболический косинус (

cosh(x)

)
(функция)

tanh tanhf tanhl

(C++11) (C++11)

вычисляет гиперболический тангенс (

tanh(x)

)
(функция)

asinh asinhf asinhl

(C++11) (C++11) (C++11)

вычисляет обратный гиперболический синус (

arsinh(x)

)
(функция)

acosh acoshf acoshl

(C++11) (C++11) (C++11)

вычисляет обратный гиперболический косинус (

arcosh(x)

)
(функция)

atanh atanhf atanhl

(C++11) (C++11) (C++11)

вычисляет обратный гиперболический тангенс (

artanh(x)

)
(функция)

Функции ошибок и гамма-функции

erf erff erfl

(C++11) (C++11) (C++11)

функция ошибок
(функция)

erfc erfcf erfcl

(C++11) (C++11) (C++11)

дополнительная функция ошибок
(функция)

tgamma tgammaf tgammal

(C++11) (C++11) (C++11)

гамма-функция
(функция)

lgamma lgammaf lgammal

(C++11) (C++11) (C++11)

натуральный логарифм гамма-функции
(функция)

Операции с плавающей запятой для округления до ближайшего целого

ceil ceilf ceill

(C++11) (C++11)

ближайшее целое число, не меньшее заданного значения
(функция)

floor floorf floorl

(C++11) (C++11)

ближайшее целое число, не превышающее заданное значение
(функция)

trunc truncf truncl

(C++11) (C++11) (C++11)

ближайшее целое число, не превышающее по модулю заданное значение
(функция)

round roundf roundl lround lroundf lroundl llround llroundf llroundl

(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)

ближайшее целое число, округление от нуля в пограничных случаях
(функция)

nearbyint nearbyintf nearbyintl

(C++11) (C++11) (C++11)

ближайшее целое число с использованием текущего режима округления
(функция)

rint rintf rintl lrint lrintf lrintl llrint llrintf llrintl

(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)

ближайшее целое число с использованием текущего режима округления с
исключением, если результат отличается
(функция)

Функции манипуляции с плавающей запятой

frexp frexpf frexpl

(C++11) (C++11)

разлагает число на мантиссу и показатель степени по основанию

2

(функция)

ldexp ldexpf ldexpl

(C++11) (C++11)

умножает число на

2

в целочисленной степени
(функция)

modf modff modfl

(C++11) (C++11)

разлагает число на целую и дробную части
(функция)

scalbn scalbnf scalbnl scalbln scalblnf scalblnl

(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)

умножает число на FLT_RADIX возведённое в степень
(функция)

ilogb ilogbf ilogbl

(C++11) (C++11) (C++11)

извлекает экспоненту числа
(функция)

logb logbf logbl

(C++11) (C++11) (C++11)

извлекает экспоненту числа
(функция)

nextafter nextafterf nextafterl nexttoward nexttowardf nexttowardl

(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)

следующее представимое значение с плавающей точкой в направлении заданного значения
(функция)

copysign copysignf copysignl

(C++11) (C++11) (C++11)

копирует знак значения с плавающей точкой
(функция)

Классификация и сравнение

fpclassify

(C++11)

категоризирует заданное значение с плавающей точкой
(функция)

isfinite

(C++11)

проверяет, имеет ли данное число конечное значение
(функция)

isinf

(C++11)

проверяет, является ли данное число бесконечным
(функция)

isnan

(C++11)

проверяет, является ли данное число NaN
(функция)

isnormal

(C++11)

проверяет, является ли данное число нормальным
(функция)

signbit

(C++11)

проверяет, является ли данное число отрицательным
(функция)

isgreater

(C++11)

проверяет, является ли первый аргумент с плавающей запятой больше второго
(функция)

isgreaterequal

(C++11)

проверяет, является ли первый аргумент с плавающей запятой больше или равным второму
(функция)

isless

(C++11)

проверяет, является ли первый аргумент с плавающей точкой меньше второго
(функция)

islessequal

(C++11)

проверяет, является ли первый аргумент с плавающей точкой меньше или равным второму
(функция)

islessgreater

(C++11)

проверяет, является ли первый аргумент с плавающей точкой меньше или больше второго
(функция)

isunordered

(C++11)

проверяет, являются ли два значения с плавающей запятой неупорядоченными
(функция)

Математические специальные функции

assoc_laguerre assoc_laguerref assoc_laguerrel

(C++17) (C++17) (C++17)

ассоциированные полиномы Лагерра
(функция)

assoc_legendre assoc_legendref assoc_legendrel

(C++17) (C++17) (C++17)

присоединённые полиномы Лежандра
(функция)

beta betaf betal

(C++17) (C++17) (C++17)

бета-функция
(функция)

comp_ellint_1 comp_ellint_1f comp_ellint_1l

(C++17) (C++17) (C++17)

(полный) эллиптический интеграл первого рода
(функция)

comp_ellint_2 comp_ellint_2f comp_ellint_2l

(C++17) (C++17) (C++17)

(полный) эллиптический интеграл второго рода
(функция)

comp_ellint_3 comp_ellint_3f comp_ellint_3l

(C++17) (C++17) (C++17)

(полный) эллиптический интеграл третьего рода
(функция)

cyl_bessel_i cyl_bessel_if cyl_bessel_il

(C++17) (C++17) (C++17)

регулярные модифицированные цилиндрические функции Бесселя
(функция)

cyl_bessel_j cyl_bessel_jf cyl_bessel_jl

(C++17) (C++17) (C++17)

цилиндрические функции Бесселя (первого рода)
(функция)

cyl_bessel_k cyl_bessel_kf cyl_bessel_kl

(C++17) (C++17) (C++17)

нерегулярные модифицированные цилиндрические функции Бесселя
(функция)

cyl_neumann cyl_neumannf cyl_neumannl

(C++17) (C++17) (C++17)

цилиндрические функции Неймана
(функция)

ellint_1 ellint_1f ellint_1l

(C++17) (C++17) (C++17)

(неполный) эллиптический интеграл первого рода
(функция)

ellint_2 ellint_2f ellint_2l

(C++17) (C++17) (C++17)

(неполный) эллиптический интеграл второго рода
(функция)

ellint_3 ellint_3f ellint_3l

(C++17) (C++17) (C++17)

(неполный) эллиптический интеграл третьего рода
(функция)

expint expintf expintl

(C++17) (C++17) (C++17)

экспоненциальный интеграл
(функция)

hermite hermitef hermitel

(C++17) (C++17) (C++17)

Полиномы Эрмита
(функция)

legendre legendref legendrel

(C++17) (C++17) (C++17)

Полиномы Лежандра
(функция)

laguerre laguerref laguerrel

(C++17) (C++17) (C++17)

Полиномы Лагерра
(функция)

riemann_zeta riemann_zetaf riemann_zetal

(C++17) (C++17) (C++17)

Функция Римана дзета
(функция)

sph_bessel sph_besself sph_bessell

(C++17) (C++17) (C++17)

сферические функции Бесселя (первого рода)
(функция)

sph_legendre sph_legendref sph_legendrel

(C++17) (C++17) (C++17)

сферические присоединённые функции Лежандра
(функция)

sph_neumann sph_neumannf sph_neumannl

(C++17) (C++17) (C++17)

сферические функции Неймана
(функция)

Синопсис

Для каждой функции, имеющей хотя бы один параметр типа /* floating-point-type */ , предоставляется перегрузка для каждого cv-неквалифицированного типа с плавающей точкой, где все использования /* floating-point-type */ в сигнатуре функции заменяются на этот тип с плавающей точкой.

Для каждой функции, имеющей хотя бы один параметр типа /* floating-point-type */ кроме std::abs , предоставляются дополнительные перегрузки, гарантирующие, что если каждый аргумент, соответствующий параметру /* floating-point-type */ , имеет арифметический тип, то каждый такой аргумент неявно преобразуется к типу с плавающей точкой, имеющему наибольший ранг преобразования с плавающей точкой и наибольший подранг преобразования с плавающей точкой среди типов всех таких аргументов, при этом аргументы целочисленного типа считаются имеющими тот же ранг преобразования с плавающей точкой, что и double . Если не существует такого типа с плавающей точкой с наибольшим рангом и подрангом, то разрешение перегрузки не приводит к пригодному кандидату из предоставленных перегрузок.

namespace std {
  using float_t = /* см. описание */;
  using double_t = /* см. описание */;
}
#define HUGE_VAL /* см. описание */
#define HUGE_VALF /* см. описание */
#define HUGE_VALL /* см. описание */
#define INFINITY /* см. описание */
#define NAN /* см. описание */
#define FP_INFINITE /* см. описание */
#define FP_NAN /* см. описание */
#define FP_NORMAL /* см. описание */
#define FP_SUBNORMAL /* см. описание */
#define FP_ZERO /* см. описание */
#define FP_FAST_FMA /* см. описание */
#define FP_FAST_FMAF /* см. описание */
#define FP_FAST_FMAL /* см. описание */
#define FP_ILOGB0 /* см. описание */
#define FP_ILOGBNAN /* см. описание */
#define MATH_ERRNO /* см. описание */
#define MATH_ERREXCEPT /* см. описание */
#define math_errhandling /* см. описание */
namespace std {
  /* тип с плавающей точкой */ acos(/* тип с плавающей точкой */ x);
  float acosf(float x);
  long double acosl(long double x);
  /* тип с плавающей точкой */ asin(/* тип с плавающей точкой */ x);
  float asinf(float x);
  long double asinl(long double x);
  /* тип с плавающей точкой */ atan(/* тип с плавающей точкой */ x);
  float atanf(float x);
  long double atanl(long double x);
  /* тип с плавающей точкой */ atan2(/* тип с плавающей точкой */ y,
                                  /* тип с плавающей точкой */ x);
  float atan2f(float y, float x);
  long double atan2l(long double y, long double x);
  /* тип с плавающей точкой */ cos(/* тип с плавающей запятой */e x);
  float cosf(float x);
  long double cosl(long double x);
  /* тип с плавающей точкой */ sin(/* тип с плавающей точкой */ x);
  float sinf(float x);
  long double sinl(long double x);
  /* тип с плавающей запятой */ tan(/* тип с плавающей точкой */ x);
  float tanf(float x);
  long double tanl(long double x);
  /* тип с плавающей запятой */ acosh(/* тип с плавающей точкой */ x);
  float acoshf(float x);
  long double acoshl(long double x);
  /* тип с плавающей точкой */ asinh(/* тип с плавающей точкой */ x);
  float asinhf(float x);
  long double asinhl(long double x);
  /* тип с плавающей точкой */ atanh(/* тип с плавающей запятой */ x);
  float atanhf(float x);
  long double atanhl(long double x);
  /* тип с плавающей точкой */ cosh(/* тип с плавающей точкой */ x);
  float coshf(float x);
  long double coshl(long double x);
  /* тип с плавающей запятой */ sinh(/* тип с плавающей запятой */ x);
  float sinhf(float x);
  long double sinhl(long double x);
  /* тип с плавающей точкой */ tanh(/* тип с плавающей запятой */ x);
  float tanhf(float x);
  long double tanhl(long double x);
  /* тип с плавающей точкой */ exp(/* тип с плавающей запятой */ x);
  float expf(float x);
  long double expl(long double x);
  /* тип с плавающей точкой */ exp2(/* тип с плавающей точкой */ x);
  float exp2f(float x);
  long double exp2l(long double x);
  /* тип с плавающей точкой */ expm1(/* тип с плавающей точкой */ x);
  float expm1f(float x);
  long double expm1l(long double x);
  constexpr /* тип с плавающей точкой */ frexp(/* тип с плавающей точкой */ value, int* exp);
  constexpr float frexpf(float value, int* exp);
  constexpr long double frexpl(long double value, int* exp);
  constexpr int ilogb(/* тип с плавающей точкой */ x);
  constexpr int ilogbf(float x);
  constexpr int ilogbl(long double x);
  constexpr /* тип с плавающей точкой */ ldexp(/* тип с плавающей точкой */ x, int exp);
  constexpr float ldexpf(float x, int exp);
  constexpr long double ldexpl(long double x, int exp);
  /* тип с плавающей точкой */ log(/* тип с плавающей точкой */ x);
  float logf(float x);
  long double logl(long double x);
  /* тип с плавающей точкой */ log10(/* тип с плавающей точкой */ x);
  float log10f(float x);
  long double log10l(long double x);
  /* тип с плавающей точкой */ log1p(/* тип с плавающей точкой */ x);
  float log1pf(float x);
  long double log1pl(long double x);
  /* тип с плавающей точкой */ log2(/* тип с плавающей точкой */ x);
  float log2f(float x);
  long double log2l(long double x);
  constexpr /* тип с плавающей точкой */ logb(/* тип с плавающей точкой */ x);
  constexpr float logbf(float x);
  constexpr long double logbl(long double x);
  constexpr /* тип с плавающей точкой */ modf(/* тип с плавающей точкой */ value,
                                           /* тип с плавающей точкой */* iptr);
  constexpr float modff(float value, float* iptr);
  constexpr long double modfl(long double value, long double* iptr);
  constexpr /* тип с плавающей точкой */ scalbn(/* тип с плавающей точкой */ x, int n);
  constexpr float scalbnf(float x, int n);
  constexpr long double scalbnl(long double x, int n);
  constexpr /* тип с плавающей запятой */ scalbln(/* тип с плавающей точкой */ x, long int n);
  constexpr float scalblnf(float x, long int n);
  constexpr long double scalblnl(long double x, long int n);
  /* тип с плавающей точкой */ cbrt(/* тип с плавающей точкой */ x);
  float cbrtf(float x);
  long double cbrtl(long double x);
  // абсолютные значения
  constexpr int abs(int j);                     // freestanding
  constexpr long int abs(long int j);           // freestanding
  constexpr long long int abs(long long int j); // freestanding
  constexpr /* тип с плавающей точкой */
    abs(/* тип с плавающей точкой */ j);           // freestanding-deleted
  constexpr /* тип с плавающей точкой */ fabs(/* тип с плавающей запятой */ x);
  constexpr float fabsf(float x);
  constexpr long double fabsl(long double x);
  /* тип с плавающей точкой */ hypot(/* тип с плавающей точкой */ x,
                                  /* тип с плавающей точкой */ y);
  float hypotf(float x, float y);
  long double hypotl(long double x, long double y);
  // трёхмерная гипотенуза
  float hypot(/* тип с плавающей запятой */ x,
              /* тип с плавающей точкой */ y,
              /* тип с плавающей точкой */ z);
  /* тип с плавающей точкой */ pow(/* тип с плавающей точкой */ x,
                                /* тип с плавающей точкой */ y);
  float powf(float x, float y);
  long double powl(long double x, long double y);
  /* тип с плавающей точкой */ sqrt(/* тип с плавающей точкой */ x);
  float sqrtf(float x);
  long double sqrtl(long double x);
  /* тип с плавающей точкой */ erf(/* тип с плавающей точкой */ x);
  float erff(float x);
  long double erfl(long double x);
  /* тип с плавающей точкой */ erfc(/* тип с плавающей точкой */ x);
  float erfcf(float x);
  long double erfcl(long double x);
  /* тип с плавающей точкой */ lgamma(/* тип с плавающей запятой */ x);
  float lgammaf(float x);
  long double lgammal(long double x);
  /* тип с плавающей точкой */ tgamma(/* тип с плавающей точкой */ x);
  float tgammaf(float x);
  long double tgammal(long double x);
  constexpr /* тип с плавающей точкой */ ceil(/* тип с плавающей точкой */ x);
  constexpr float ceilf(float x);
  constexpr long double ceill(long double x);
  constexpr /* тип с плавающей точкой */ floor(/* тип с плавающей запятой */ x);
  constexpr float floorf(float x);
  constexpr long double floorl(long double x);
  /* тип с плавающей точкой */ nearbyint(/* тип с плавающей точкой */ x);
  float nearbyintf(float x);
  long double nearbyintl(long double x);
  /* тип с плавающей точкой */ rint(/* тип с плавающей точкой */ x);
  float rintf(float x);
  long double rintl(long double x);
  long int lrint(/* тип с плавающей точкой */ x);
  long int lrintf(float x);
  long int lrintl(long double x);
  long long int llrint(/* тип с плавающей точкой */ x);
  long long int llrintf(float x);
  long long int llrintl(long double x);
  constexpr /* тип с плавающей запятой */ round(/* тип с плавающей точкой */ x);
  constexpr float roundf(float x);
  constexpr long double roundl(long double x);
  constexpr long int lround(/* тип с плавающей точкой */ x);
  constexpr long int lroundf(float x);
  constexpr long int lroundl(long double x);
  constexpr long long int llround(/* тип с плавающей точкой */ x);
  constexpr long long int llroundf(float x);
  constexpr long long int llroundl(long double x);
  constexpr /* тип с плавающей точкой */ trunc(/* тип с плавающей запятой */ x);
  constexpr float truncf(float x);
  constexpr long double truncl(long double x);
  constexpr /* тип с плавающей запятой */ fmod(/* тип с плавающей точкой */ x,
                                           /* тип с плавающей точкой */ y);
  constexpr float fmodf(float x, float y);
  constexpr long double fmodl(long double x, long double y);
  constexpr /* тип с плавающей точкой */ remainder(/* тип с плавающей точкой */ x,
                                                /* тип с плавающей точкой */ y);
  constexpr float remainderf(float x, float y);
  constexpr long double remainderl(long double x, long double y);
  constexpr /* тип с плавающей точкой */ remquo(/* тип с плавающей точкой */ x,
                                             /* тип с плавающей точкой */ y, int* quo);
  constexpr float remquof(float x, float y, int* quo);
  constexpr long double remquol(long double x, long double y, int* quo);
  constexpr /* тип с плавающей точкой */ copysign(/* тип с плавающей точкой */ x,
                                               /* тип с плавающей точкой */ y);
  constexpr float copysignf(float x, float y);
  constexpr long double copysignl(long double x, long double y);
  double nan(const char* tagp);
  float nanf(const char* tagp);
  long double nanl(const char* tagp);
  constexpr /* тип с плавающей точкой */ nextafter(/* тип с плавающей точкой */ x,
                                                /* тип с плавающей запятой */ y);
  constexpr float nextafterf(float x, float y);
  constexpr long double nextafterl(long double x, long double y);
  constexpr /* тип с плавающей точкой */ nexttoward(/* тип с плавающей точкой */ x,
                                                 long double y);
  constexpr float nexttowardf(float x, long double y);
  constexpr long double nexttowardl(long double x, long double y);
  constexpr /* тип с плавающей точкой */ fdim(/* тип с плавающей точкой */ x,
                                           /* тип с плавающей точкой */ y);
  constexpr float fdimf(float x, float y);
  constexpr long double fdiml(long double x, long double y);
  constexpr /* тип с плавающей точкой */ fmax(/* тип с плавающей точкой */ x,
                                           /* тип с плавающей точкой */ y);
  constexpr float fmaxf(float x, float y);
  constexpr long double fmaxl(long double x, long double y);
  constexpr /* тип с плавающей точкой */ fmin(/* тип с плавающей запятой */ x,
                                           /* тип с плавающей точкой */ y);
  constexpr float fminf(float x, float y);
  constexpr long double fminl(long double x, long double y);
  constexpr /* тип с плавающей точкой */ fma(/* тип с плавающей точкой */ x,
                                          /* тип с плавающей запятой */ y,
                                          /* тип с плавающей запятой */ z);
  constexpr float fmaf(float x, float y, float z);
  constexpr long double fmal(long double x, long double y, long double z);
  // линейная интерполяция
  constexpr /* тип с плавающей точкой */ lerp(/* тип с плавающей точкой */ a,
                                           /* тип с плавающей точкой */ b,
                                           /* тип с плавающей точкой */ t) noexcept;
  // функции классификации / сравнения
  constexpr int fpclassify(/* тип с плавающей точкой */ x);
  constexpr bool isfinite(/* тип с плавающей точкой */ x);
  constexpr bool isinf(/* тип с плавающей точкой */ x);
  constexpr bool isnan(/* тип с плавающей запятой */ x);
  constexpr bool isnormal(/* тип с плавающей запятой */ x);
  constexpr bool signbit(/* тип с плавающей запятой */ x);
  constexpr bool isgreater(/* тип с плавающей точкой */ x,
                           /* тип с плавающей точкой */ y);
  constexpr bool isgreaterequal(/* тип с плавающей точкой */ x,
                                /* тип с плавающей точкой */ y);
  constexpr bool isless(/* тип с плавающей точкой */ x,
                        /* тип с плавающей точкой */ y);
  constexpr bool islessequal(/* тип с плавающей точкой */ x,
                             /* тип с плавающей точкой */ y);
  constexpr bool islessgreater(/* тип с плавающей точкой */ x,
                               /* тип с плавающей точкой */ y);
  constexpr bool isunordered(/* тип с плавающей точкой */ x,
                             /* тип с плавающей точкой */ y);
  // математические специальные функции
  // присоединённые полиномы Лагерра
  /* тип с плавающей точкой */ assoc_laguerre(unsigned n, unsigned m,
                                           /* тип с плавающей запятой */ x);
  float assoc_laguerref(unsigned n, unsigned m, float x);
  long double assoc_laguerrel(unsigned n, unsigned m, long double x);
  // присоединённые функции Лежандра
  /* тип с плавающей точкой */ assoc_legendre(unsigned l, unsigned m,
                                           /* тип с плавающей точкой */ x);
  float assoc_legendref(unsigned l, unsigned m, float x);
  long double assoc_legendrel(unsigned l, unsigned m, long double x);
  // бета-функция
  /* тип с плавающей запятой */ beta(/* тип с плавающей точкой */ x,
                                 /* тип с плавающей точкой */ y);
  float betaf(float x, float y);
  long double betal(long double x, long double y);
  // полный эллиптический интеграл первого рода
  /* тип с плавающей запятой */ comp_ellint_1(/* тип с плавающей точкой */ k);
  float comp_ellint_1f(float k);
  long double comp_ellint_1l(long double k);
  // полный эллиптический интеграл второго рода
  /* тип с плавающей точкой */ comp_ellint_2(/* тип с плавающей точкой */ k);
  float comp_ellint_2f(float k);
  long double comp_ellint_2l(long double k);
  // полный эллиптический интеграл третьего рода
  /* тип с плавающей запятой */ comp_ellint_3(/* тип с плавающей запятой */ k,
                                          /* тип с плавающей точкой */ nu);
  float comp_ellint_3f(float k, float nu);
  long double comp_ellint_3l(long double k, long double nu);
  // регулярные модифицированные цилиндрические функции Бесселя
  /* тип с плавающей точкой */ cyl_bessel_i(/* тип с плавающей точкой */ nu,
                                         /* тип с плавающей запятой */ x);
  float cyl_bessel_if(float nu, float x);
  long double cyl_bessel_il(long double nu, long double x);
  // цилиндрические функции Бесселя первого рода
  /* тип с плавающей точкой */ cyl_bessel_j(/* тип с плавающей точкой */ nu,
                                         /* тип с плавающей точкой */ x);
  float cyl_bessel_jf(float nu, float x);
  long double cyl_bessel_jl(long double nu, long double x);
  // нерегулярные модифицированные цилиндрические функции Бесселя
  /* тип с плавающей точкой */ cyl_bessel_k(/* тип с плавающей точкой */ nu,
                                         /* тип с плавающей точкой */ x);
  float cyl_bessel_kf(float nu, float x);
  long double cyl_bessel_kl(long double nu, long double x);
  // цилиндрические функции Неймана;
  // цилиндрические функции Бесселя второго рода
  /* тип с плавающей точкой */ cyl_neumann(/* тип с плавающей точкой */ nu,
                                        /* тип с плавающей точкой */ x);
  float cyl_neumannf(float nu, float x);
  long double cyl_neumannl(long double nu, long double x);
  // неполный эллиптический интеграл первого рода
  /* тип с плавающей точкой */ ellint_1(/* тип с плавающей точкой */ k,
                                     /* тип с плавающей точкой */ phi);
  float ellint_1f(float k, float phi);
  long double ellint_1l(long double k, long double phi);
  // неполный эллиптический интеграл второго рода
  /* тип с плавающей точкой */ ellint_2(/* тип с плавающей точкой */ k,
                                     /* тип с плавающей запятой */ phi);
  float ellint_2f(float k, float phi);
  long double ellint_2l(long double k, long double phi);
  // неполный эллиптический интеграл третьего рода
  /* тип с плавающей точкой */ ellint_3(/* тип с плавающей точкой */ k,
                                     /* тип с плавающей точкой */ nu,
                                     /* тип с плавающей точкой */ phi);
  float ellint_3f(float k, float nu, float phi);
  long double ellint_3l(long double k, long double nu, long double phi);
  // экспоненциальный интеграл
  /* тип с плавающей точкой */ expint(/* тип с плавающей точкой */ x);
  float expintf(float x);
  long double expintl(long double x);
  // Полиномы Эрмита
  /* тип с плавающей точкой */ hermite(unsigned n, /* тип с плавающей точкой */ x);
  float hermitef(unsigned n, float x);
  long double hermitel(unsigned n, long double x);
  // Полиномы Лагерра
  /* тип с плавающей точкой */ laguerre(unsigned n, /* тип с плавающей точкой */ x);
  float laguerref(unsigned n, float x);
  long double laguerrel(unsigned n, long double x);
  // Полиномы Лежандра
  /* тип с плавающей точкой */ legendre(unsigned l, /* тип с плавающей точкой */ x);
  float legendref(unsigned l, float x);
  long double legendrel(unsigned l, long double x);
  // Дзета-функция Римана
  /* тип с плавающей точкой */ riemann_zeta(/* тип с плавающей точкой */ x);
  float riemann_zetaf(float x);
  long double riemann_zetal(long double x);
  // сферические функции Бесселя первого рода
  /* тип с плавающей точкой */ sph_bessel(unsigned n, /* тип с плавающей точкой */ x);
  float sph_besself(unsigned n, float x);
  long double sph_bessell(unsigned n, long double x);
  // сферические присоединённые функции Лежандра
  /* тип с плавающей точкой */ sph_legendre(unsigned l, unsigned m,
                                         /* тип с плавающей запятой */ theta);
  float sph_legendref(unsigned l, unsigned m, float theta);
  long double  sph_legendrel(unsigned l, unsigned m, long double theta);
  // сферические функции Неймана;
  // сферические функции Бесселя второго рода
  /* тип с плавающей точкой */ sph_neumann(unsigned n, /* тип с плавающей точкой */ x);
  float sph_neumannf(unsigned n, float x);
  long double sph_neumannl(unsigned n, long double x);
}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Standard library header <cmath>

Содержание

Типы

Макросы

Классификация

Функции

Основные операции

Линейная интерполяция

Экспоненциальные функции

Степенные функции

Тригонометрические функции

Гиперболические функции

Функции ошибок и гамма-функции

Операции с плавающей запятой для округления до ближайшего целого

Функции манипуляции с плавающей запятой

Классификация и сравнение

Математические специальные функции

Синопсис