Include cmath c что это

Include cmath c что это

Обратная связь

Включает заголовок стандартной библиотеки C и добавляет связанные имена в std пространство имен.

Синтаксис

#include

Константы и типы

namespace std < using float_t = see below ; using double_t = see below ; >#define HUGE_VAL see below #define HUGE_VALF see below #define HUGE_VALL see below #define INFINITY see below #define NAN see below #define FP_INFINITE see below #define FP_NAN see below #define FP_NORMAL see below #define FP_SUBNORMAL see below #define FP_ZERO see below #define FP_FAST_FMA see below #define FP_FAST_FMAF see below #define FP_FAST_FMAL see below #define FP_ILOGB0 see below #define FP_ILOGBNAN see below #define MATH_ERRNO see below #define MATH_ERREXCEPT see below #define math_errhandling see below 

Функции

float acos(float x); double acos(double x); long double acos(long double x); float acosf(float x); long double acosl(long double x); float asin(float x); double asin(double x); long double asin(long double x); float asinf(float x); long double asinl(long double x); float atan(float x); double atan(double x); long double atan(long double x); float atanf(float x); long double atanl(long double x); float atan2(float y, float x); double atan2(double y, double x); long double atan2(long double y, long double x); float atan2f(float y, float x); long double atan2l(long double y, long double x); float cos(float x); double cos(double x); long double cos(long double x); float cosf(float x); long double cosl(long double x); float sin(float x); double sin(double x); long double sin(long double x); float sinf(float x); long double sinl(long double x); float tan(float x); double tan(double x); long double tan(long double x); float tanf(float x); long double tanl(long double x); float acosh(float x); double acosh(double x); long double acosh(long double x); float acoshf(float x); long double acoshl(long double x); float asinh(float x); double asinh(double x); long double asinh(long double x); float asinhf(float x); long double asinhl(long double x); float atanh(float x); double atanh(double x); long double atanh(long double x); float atanhf(float x); long double atanhl(long double x); float cosh(float x); double cosh(double x); long double cosh(long double x); float coshf(float x); long double coshl(long double x); float sinh(float x); double sinh(double x); long double sinh(long double x); float sinhf(float x); long double sinhl(long double x); float tanh(float x); double tanh(double x); long double tanh(long double x); float tanhf(float x); long double tanhl(long double x); float exp(float x); double exp(double x); long double exp(long double x); float expf(float x); long double expl(long double x); float exp2(float x); double exp2(double x); long double exp2(long double x); float exp2f(float x); long double exp2l(long double x); float expm1(float x); double expm1(double x); long double expm1(long double x); float expm1f(float x); long double expm1l(long double x); float frexp(float value, int* exp); double frexp(double value, int* exp); long double frexp(long double value, int* exp); float frexpf(float value, int* exp); long double frexpl(long double value, int* exp); int ilogb(float x); int ilogb(double x); int ilogb(long double x); int ilogbf(float x); int ilogbl(long double x); float ldexp(float x, int exp); double ldexp(double x, int exp); long double ldexp(long double x, int exp); float ldexpf(float x, int exp); long double ldexpl(long double x, int exp); float log(float x); double log(double x); long double log(long double x); float logf(float x); long double logl(long double x); float log10(float x); double log10(double x); long double log10(long double x); float log10f(float x); long double log10l(long double x); float log1p(float x); double log1p(double x); long double log1p(long double x); float log1pf(float x); long double log1pl(long double x); float log2(float x); double log2(double x); long double log2(long double x); float log2f(float x); long double log2l(long double x); float logb(float x); double logb(double x); long double logb(long double x); float logbf(float x); long double logbl(long double x); float modf(float value, float* iptr); double modf(double value, double* iptr); long double modf(long double value, long double* iptr); float modff(float value, float* iptr); long double modfl(long double value, long double* iptr); float scalbn(float x, int n); double scalbn(double x, int n); long double scalbn(long double x, int n); float scalbnf(float x, int n); long double scalbnl(long double x, int n); float scalbln(float x, long int n); double scalbln(double x, long int n); long double scalbln(long double x, long int n); float scalblnf(float x, long int n); long double scalblnl(long double x, long int n); float cbrt(float x); double cbrt(double x); long double cbrt(long double x); float cbrtf(float x); long double cbrtl(long double x); 

Абсолютные значения

int abs(int j); long int abs(long int j); long long int abs(long long int j); float abs(float j); double abs(double j); long double abs(long double j); float fabs(float x); double fabs(double x); long double fabs(long double x); float fabsf(float x); long double fabsl(long double x); float hypot(float x, float y); double hypot(double x, double y); long double hypot(double x, double y); float hypotf(float x, float y); long double hypotl(long double x, long double y); 

Трехмерная гипотенуза

float hypot(float x, float y, float z); double hypot(double x, double y, double z); long double hypot(long double x, long double y, long double z); float pow(float x, float y); double pow(double x, double y); long double pow(long double x, long double y); float powf(float x, float y); long double powl(long double x, long double y); float sqrt(float x); double sqrt(double x); long double sqrt(long double x); float sqrtf(float x); long double sqrtl(long double x); float erf(float x); double erf(double x); long double erf(long double x); float erff(float x); long double erfl(long double x); float erfc(float x); double erfc(double x); long double erfc(long double x); float erfcf(float x); long double erfcl(long double x); float lgamma(float x); double lgamma(double x); long double lgamma(long double x); float lgammaf(float x); long double lgammal(long double x); float tgamma(float x); double tgamma(double x); long double tgamma(long double x); float tgammaf(float x); long double tgammal(long double x); float ceil(float x); double ceil(double x); long double ceil(long double x); float ceilf(float x); long double ceill(long double x); float floor(float x); double floor(double x); long double floor(long double x); float floorf(float x); long double floorl(long double x); float nearbyint(float x); double nearbyint(double x); long double nearbyint(long double x); float nearbyintf(float x); long double nearbyintl(long double x); float rint(float x); double rint(double x); long double rint(long double x); float rintf(float x); long double rintl(long double x); long int lrint(float x); long int lrint(double x); long int lrint(long double x); long int lrintf(float x); long int lrintl(long double x); long long int llrint(float x); long long int llrint(double x); long long int llrint(long double x); long long int llrintf(float x); long long int llrintl(long double x); float round(float x); double round(double x); long double round(long double x); float roundf(float x); long double roundl(long double x); long int lround(float x); long int lround(double x); long int lround(long double x); long int lroundf(float x); long int lroundl(long double x); long long int llround(float x); long long int llround(double x); long long int llround(long double x); long long int llroundf(float x); long long int llroundl(long double x); float trunc(float x); double trunc(double x); long double trunc(long double x); float truncf(float x); long double truncl(long double x); float fmod(float x, float y); double fmod(double x, double y); long double fmod(long double x, long double y); float fmodf(float x, float y); long double fmodl(long double x, long double y); float remainder(float x, float y); double remainder(double x, double y); long double remainder(long double x, long double y); float remainderf(float x, float y); long double remainderl(long double x, long double y); float remquo(float x, float y, int* quo); double remquo(double x, double y, int* quo); long double remquo(long double x, long double y, int* quo); float remquof(float x, float y, int* quo); long double remquol(long double x, long double y, int* quo); float copysign(float x, float y); double copysign(double x, double y); long double copysign(long double x, long double y); float copysignf(float x, float y); 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); float nextafter(float x, float y); double nextafter(double x, double y); long double nextafter(long double x, long double y); float nextafterf(float x, float y); long double nextafterl(long double x, long double y); float nexttoward(float x, long double y); double nexttoward(double x, long double y); long double nexttoward(long double x, long double y); float nexttowardf(float x, long double y); long double nexttowardl(long double x, long double y); float fdim(float x, float y); double fdim(double x, double y); long double fdim(long double x, long double y); float fdimf(float x, float y); long double fdiml(long double x, long double y); float fmax(float x, float y); double fmax(double x, double y); long double fmax(long double x, long double y); float fmaxf(float x, float y); long double fmaxl(long double x, long double y); float fmin(float x, float y); double fmin(double x, double y); long double fmin(long double x, long double y); float fminf(float x, float y); long double fminl(long double x, long double y); float fma(float x, float y, float z); double fma(double x, double y, double z); long double fma(long double x, long double y, long double z); float fmaf(float x, float y, float z); long double fmal(long double x, long double y, long double z); 

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

int fpclassify(float x); int fpclassify(double x); int fpclassify(long double x); int isfinite(float x); int isfinite(double x); int isfinite(long double x); int isinf(float x); int isinf(double x); int isinf(long double x); int isnan(float x); int isnan(double x); int isnan(long double x); int isnormal(float x); int isnormal(double x); int isnormal(long double x); int signbit(float x); int signbit(double x); int signbit(long double x); int isgreater(float x, float y); int isgreater(double x, double y); int isgreater(long double x, long double y); int isgreaterequal(float x, float y); int isgreaterequal(double x, double y); int isgreaterequal(long double x, long double y); int isless(float x, float y); int isless(double x, double y); int isless(long double x, long double y); int islessequal(float x, float y); int islessequal(double x, double y); int islessequal(long double x, long double y); int islessgreater(float x, float y); int islessgreater(double x, double y); int islessgreater(long double x, long double y); int isunordered(float x, float y); int isunordered(double x, double y); int isunordered(long double x, long double y); 

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

Связанные полиномиалы Laguerre

double assoc_laguerre(unsigned n, unsigned m, double x); float assoc_laguerref(unsigned n, unsigned m, float x); long double assoc_laguerrel(unsigned n, unsigned m, long double x); 

Связанные функции Legendre

double assoc_legendre(unsigned l, unsigned m, double x); float assoc_legendref(unsigned l, unsigned m, float x); long double assoc_legendrel(unsigned l, unsigned m, long double x); 

Бета-функция

double beta(double x, double y); float betaf(float x, float y); long double betal(long double x, long double y); 

Полный многоточие первого вида

double comp_ellint_1(double k); float comp_ellint_1f(float k); long double comp_ellint_1l(long double k); 

Полный многоточие второго вида

double comp_ellint_2(double k); float comp_ellint_2f(float k); long double comp_ellint_2l(long double k); 

Полный многоточие третьего вида

double comp_ellint_3(double k, double nu); float comp_ellint_3f(float k, float nu); long double comp_ellint_3l(long double k, long double nu); 

Регулярные измененные цилиндрические функции Bessel

double cyl_bessel_i(double nu, double x); float cyl_bessel_if(float nu, float x); long double cyl_bessel_il(long double nu, long double x); 

Cylindrical Bessel функции первого типа

double cyl_bessel_j(double nu, double x); float cyl_bessel_jf(float nu, float x); long double cyl_bessel_jl(long double nu, long double x); 

Нерегулярные измененные цилиндрические функции Bessel

double cyl_bessel_k(double nu, double x); float cyl_bessel_kf(float nu, float x); long double cyl_bessel_kl(long double nu, long double x); 

Cylindrical Neumann функции

double cyl_neumann(double nu, double x); float cyl_neumannf(float nu, float x); long double cyl_neumannl(long double nu, long double x); 

Неполный многоточие первого типа

double ellint_1(double k, double phi); float ellint_1f(float k, float phi); long double ellint_1l(long double k, long double phi); 

Неполный многоточие второго вида

double ellint_2(double k, double phi); float ellint_2f(float k, float phi); long double ellint_2l(long double k, long double phi); 

Неполный многоточие третьего вида

double ellint_3(double k, double nu, double phi); float ellint_3f(float k, float nu, float phi); long double ellint_3l(long double k, long double nu, long double phi); 

Экспоненциальный целочисленный

double expint(double x); float expintf(float x); long double expintl(long double x); 

Эрмит полиномиалы

double hermite(unsigned n, double x); float hermitef(unsigned n, float x); long double hermitel(unsigned n, long double x); 

Полиномиалы Laguerre

double laguerre(unsigned n, double x); float laguerref(unsigned n, float x); long double laguerrel(unsigned n, long double x); 

Условные обозначения полиномиал

double legendre(unsigned l, double x); float legendref(unsigned l, float x); long double legendrel(unsigned l, long double x); 

Функция Riemann zeta

double riemann_zeta(double x); float riemann_zetaf(float x); long double riemann_zetal(long double x); 

Сферические функции Bessel первого типа

double sph_bessel(unsigned n, double x); float sph_besself(unsigned n, float x); long double sph_bessell(unsigned n, long double x); 

Функции Spherical associated Legendre

double sph_legendre(unsigned l, unsigned m, double theta); float sph_legendref(unsigned l, unsigned m, float theta); long double sph_legendrel(unsigned l, unsigned m, long double theta); 

Сферические функции Нойманна

double sph_neumann(unsigned n, double x); float sph_neumannf(unsigned n, float x); long double sph_neumannl(unsigned n, long double x); 

Замечания

Включение этого заголовка гарантирует, что имена, объявленные с помощью внешней компоновки в заголовке стандартной библиотеки C, объявляются в пространстве имен std .

Что и почему лучше подключить в C++? math.h или cmath? stdio.h или cstdio?

Что и почему лучше подключить в C++? math.h или cmath? stdio.h или cstdio?
И так, и так вроде работает. В чём отличие?

• Вопрос задан 13 нояб. 2023
• 886 просмотров

1 комментарий

Средний 1 комментарий

Сначала в C++ не было никаких cmath. А потом появились. Но обратную совместимость мало кто ломает.
Решения вопроса 2
Developer, ex-admin

В С++ используют вариант где не указывают расширение .h в include. С расширением это для исходников на Си.
Впрочем, как вы верно заметили, в плюсах это то же работает. Обычно внутри просто делается #include

Ответ написан 13 нояб. 2023
Комментировать
Нравится 2 Комментировать
Программист на «си с крестами» и не только

math.h — это для кода, который должен быть одновременно Си и Си++. Также разглючка в некоторых версиях Embarcadero.
cmath — рекомендуется в Си++.

Ответ написан 13 нояб. 2023
Комментировать
Нравится 1 Комментировать
Ответы на вопрос 0
Ваш ответ на вопрос

Войдите, чтобы написать ответ

• Android
• +3 ещё

Какие есть доки по сборке APK/AAB с использованием Android NDK?

• 1 подписчик
• 30 дек. 2023
• 65 просмотров

Include cmath c что это

Минимальная программа на С++ состоит из одной функции main, именно с нее начинается работа программы. Однако, мы можно (и нужно) пользоваться другими функциями. В языке С++ существует большое количество функций стандартной библиотеки STL ( глава 2), а также можно определять свои собственные функции.

1.9.1 Использование функций библиотеки STL (пример 11)

Стандартная библиотека C++ предлагает широкий набор функций для выполнения математических вычислений, операций со строками и символами, ввода-вывода, обработки ошибок и многих других полезных операций. Это облегчает работу программистов, поскольку эти функции реализуют многое из того, что им обычно требуется. Прототипы функций размещаются в заголовочных файлах, так что они могут использоваться любыми программами, включающими соответствующий заголовочный файл.

Например, в языке С++ не существует оператора возведения в степень, но зато есть функция возведения в степень, которой можно воспользоваться. Для этого нужно подключить заголовочный файл и в обратиться к функции pow() в теле программы.

///////////////////////////////////////////////////////////////////////////// // Прикладное программирование // Пример 11. Обращение к фукнции возведения числа в степень // // Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru // Университет ИТМО ///////////////////////////////////////////////////////////////////////////// // подключение библиотеки ввода-вывода #include // подключение математической библиотеки #include // подключение стандартного пространства имен для использования библиотек using namespace std; ///////////////////////////////////////////////////////////////////////////// // функция main начинает исполнение программы void main() < double pi=3.14; // возведение числа в степень // обращение к функции - пример 1 double power = pow(3.14, 2); // обращение к функции - пример 1 power = pow(pi, 2); // обращение к функции - пример 3 cout <///////////////////////////////////////////////////////////////////////////// 

Функция pow() возводит число 3.14 в квадрат и присваивает полученный результат переменной power, где pow — имя функции; числа 3.14 и 2 — аргументы функции. В качестве аргументов функции может быть число или переменная соответствующего типа.

Аргументы перечисляются в скобках после имени функции, если аргументов несколько, то они отделяются друг от друга запятыми.

1.9.2 Определение новых функций

Определение (реализация) функции

Определение функции осуществляется следующим образом:

в общем виде

пример

тип имя(список аргументов с типами) < инструкции return возвращ.знач.; >

double plus(double x, double y) < return x+y; >

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

void print_value(double res) < cout"result is: "

Во время выполнения какой-либо функции управление возвращается в вызывающую программу, когда программа достигает закрывающей фигурной скобки или при исполнении оператора return. Если функция не возвращает никакого значения, оператор return должен быть «пустым», а если возвращает – после оператора return указывается возвращаемое значение. Для функции, не возвращающей никакого значения, наличие оператора return не является обязательным.

Описание функции (прототип)

Обычно функции снабжаются прототипами, которые помещаются в отдельный заголовочный (header) файл или в начале файла. Прототипом называется объявление функции:

в общем виде

пример

возвращ.тип имя (список аргументов с типами);

double plus(double x, double y)

Компилятор сверяется с прототипом функции, чтобы проверить, содержат ли вызовы функции правильное число аргументов нужных типов и перечислены ли типы аргументов в правильном порядке. Кроме того, прототип функции необходим компилятору для того, чтобы убедиться, что возвращаемое функцией значение корректно используется в вызвавшем функцию выражении (например, вызов функции, возвращающий void, не может входить в правую часть оператора присваивания). Каждый аргумент должен быть совместим с типом соответствующего параметра. Например, параметр типа double может принимать значения 7.35, 22 или -0.03456, но не строку вроде «hello». Если передаваемые функции аргументы не совпадают по типу с параметрами, указанными в прототипе функции, компилятор пытается преобразовать аргументы к соответствующему типу.

Обращение к функции (вызов функции)

Каждому параметру в определении функции (формальный параметр функции) должен соответствовать один аргумент в вызове функции. В данном примере, когда функция вызывается, параметр функции х инициализируется значением аргумента b, параметр у инициализируется значением аргумента c, а возвращаемое значение присваивается переменной a.

имя (список аргументов);

double a, b, c; a=plus(b, c);

1.9.3 Пример функции (пример 12)

В примере используются две функции – функция сложения двух чисел и функция печати числа на экран. Значение функции plus можно присвоить какой-то переменной, или использовать прямо при вызове другой функции или при использовании оператора cout.

///////////////////////////////////////////////////////////////////////////// // Прикладное программирование // Пример 12. Функция сложения двух чисел // // Кафедра Прикладной и компьютерной оптики, http://aco.ifmo.ru // Университет ИТМО ///////////////////////////////////////////////////////////////////////////// // подключение библиотеки ввода-вывода #include // подключение стандартного пространства имен для использования библиотек using namespace std; // объявление функции (прототип функции) // функция складывает два числа double plus(double x, double y); // функция печати результата void print_value(double res); ///////////////////////////////////////////////////////////////////////////// // функция main начинает исполнение программы void main() < // объявление и инициализация двух переменных double x1=1, x2=2; // обращение к функции - пример 1 double res = plus(x1, x2); // обращение к функции - пример 2 res = plus(55.5, res); print_value(res); // обращение к функции - пример 3 cout<// обращение к функции - пример 4 print_value(plus(res, x2)); > ///////////////////////////////////////////////////////////////////////////// // Определение (реализация) функции сложения двух чисел double plus(double x, double y) < return x+y; > ///////////////////////////////////////////////////////////////////////////// // Определение (реализация) функции печати результата void print_value(double res) < cout"result is: " ///////////////////////////////////////////////////////////////////////////// 

отличие библиотек и и вопросы точности

вопрос 1: Подскажите, отличаются ли C++ библиотеки и чем-то принципиально (кроме новых функций)? вопрос 2: Иногда возникают задачи вычисления над близкими значениями, например exp(-(log(x) — a)*(log(x) — a)) , в результате даже long double перестаёт помогать и приходится вводить какие-то масштабирующие коэффициенты, чтобы повысить точность, что не очень хорошо. Может дело в том, что функции exp, log программно-написанные, а не из ALU? Как вообще люди решают такие проблемы?

Отслеживать
задан 9 авг 2018 в 7:28
37.4k 4 4 золотых знака 28 28 серебряных знаков 72 72 бронзовых знака

для чисел с плавающей точкой можете использовать готовые библиотеки. boost::multiprecision::cpp_float к примеру.

9 авг 2018 в 7:47

2 ответа 2

Сортировка: Сброс на вариант по умолчанию

— это по большому счету , только завернутая в пространство имен std . Или — вытащенные из std функции .

Проблемы с точностью вычислений связаны с ограниченной точностью представлений чисел с плавающей точкой. Библиотечные функции использовали свои «программно-написанные» функции разве что во времена 80386, когда еще было математический сопроцессор — было удовольствие не на каждой машине. Дело не в этом, а в том, что как ни старайтесь, но законы математики не перепрыгнуть, и действительно надо прибегать к математическим преобразованиям для таких вычислений — вплоть до того, что часто изменение последовательности суммирований существенно меняет результат.

Кстати, некоторые компиляторы при long double все равно используют обычный double — например, Visual C++. Проверьте, что там у вас.