C как подключить библиотеку math

На экране после запуска программы, появится текст с сообщением: «log10 =2.

• delitme 0.90
• 21 декабря 2013, 11:22
• 0
• 34858

C как подключить библиотеку math

Альтернативные объявления математическик функций, позволяющие эффективнее использовать возможности машины, - но, как правило, хуже отслеживающие ошибки и могущие вызывать дополнительные трудности на некоторых машинах, - доступны при подключении 'fastmath.h' вместо 'math.h'.

Существуют четыре различных версии программ математических библиотек: IEEE, POSIX, X/Open, и SVID. Версия может быть выбрана Вами в период прогона программы заданием глобальной переменной _LIB_VERSION, определенной в 'math.h'. Она может принимать значение одной из следующих констант, определенных в 'math.h': _IEEE_, _POSIX_, _XOPEN_, или _SVID_. Переменная _LIB_VERSION не является специальной для каждой части программы, и изменение ее сказывается на всех частях.

Версии библиотеки различаются только по принципу обработки ошибок.

В режиме IEEE функция matherr не вызывается, не печатается сообщение об ошибке, и не задается значение переменной errno.

В режиме POSIX переменной errno присваивается необходимое значение, но функция matherr не вызывается, и не выводится сообщение об ошибке.

В режиме X/Open переменная errno принимает соответствующее значение, вызывается функция matherr, но сообщение об ошибке не выводится.

В режиме SVID функции, в случае переполнения, не принимают значение бесконечности, а становятся равными 3.40282346638528860e+38, максимально возможному одноразрядному числу с плавающей точкой. Также переменной errno присваивается правильное значение, вызывается функция matherr, и, если matherr обращается в 0, то для некоторых ошибок выводится соответствующее сообщение. Например, в ответ на 'log(-1.0)' печатается сообщение об ошибке в стандартном виде вывода: log: DOMAIN error. По умолчанию реализуется режим X/Open.

#include double acos(double x); float acosf(float x);

acos вычисляет арккосинус (arccos) от заданного аргумента. Аргумент для acos должен находиться в отрезке [-1,1].

acosf идентичен acos, различие состоит в типах (double и floats), с которыми проводятся вычисления.

acos и acosf возвращают значения в радианах на промежутке от 0 до pi.

Если х не в промежутке [-1,1], то возвращаемое значение есть NaN (not a number), глобальная переменная errno принимает значение EDOM, и в стандартном выводе выносится сообщение DOMAIN error.

Вы можете изменить обработку ошибок для этих функций, используя matherr.

#include double acosh(double x); float acoshf(float x);

acosh вычисляет обратный гиперболический косинус, который определяется как ln(x + sqrt(sqr(x) - 1))

x должен быть больше либо равен 1.

acoshf аналогичен acosh с точностью до типов.

acosh и acoshf принимают вычисленные значения. Если х меньше 1, возвращается NaN, при этом errno получает значение EDOM.

Вы можете изменить поведение обработчика ошибок с помощью функции matherr, которая не является стандартной ANSI C - функцией.

Ни acosh, ни acoshf не удовлетворяют стандарту ANSI C. Не рекомендуется использовать их в программах, которые могут быть перенесены на другие машины.

#include double asin(double x); float asinf(float x);

asin вычисляет арксинус (arcsin) от заданного аргумента. Аргумент для asin должен находиться в отрезке [-1,1].

asinf идентичен asin, различие состоит в типах (double и float), с которыми проводятся вычисления.

Вы можете изменить обработку ошибок для этих функций, используя matherr.

asin и asinf возвращают значения в радианах в промежутке от -pi/2 до pi/2.

Если х не в промежутке [-1,1], то возвращаемое значение есть NaN (not a number), глобальная переменная errno принимает значение EDOM, и в стандартном выводе выносится сообщение DOMAIN error.

Вы можете изменить обработчик ошибок для этих функций, используя matherr.

#include double asinh(double x); float asinhf(float x);

asinh вычисляет обратный гиперболический синус, который определяется как sign(x)*ln(ЁxЁ + sqrt(sqr(x) + 1))

asinhf аналогичен с точностью до типов.

asinh и asinhf возвращают вычисленные значения.

Ни asinh, ни asinhf не являются ANSI C - функциями.

#include double atan(double x); float atanf(float x);

atan вычисляет арктангенс (arctg) от заданного аргумента.

atanf аналогичен с точностью до типов.

atan и atanf возвращают значения в радианах на промежутке от -pi/2 до pi/2.

atan удовлетворяет стандарту ANSI C. atanf является расширением.

#include double atan2(double y, double x); float atan2f(float y, float x);

atan2 вычисляет арктангенс (arctg) от y/x. atan2 получает верный результат даже при углах, близких к pi/2 и -pi/2 (т. е. когда х близок к 0).

atan2f идентичен atan, различие состоит в типах (double и float), с которыми проводятся вычисления.

atan2 и atan2f возвращают значения в радианах на промежутке от -pi/2 до pi/2.

В случае, когда и х и y оба равны нулю, возникает ошибка DOMAIN error.

Вы можете изменить обработку ошибок для этих функций, используя matherr.

atan2 удовлетворяет стандарту ANSI C. atan2f является расширением.

#include double atanh(double x); float atanhf(float x);

atanf аналогичен с точностью до типов.

atanh и atanhf возвращают вычисленное значение.

Если ЁхЁ превосходит 1, то возвращаемое значение есть NaN, errno принимает значение EDOM, и выводится сообщение DOMAIN error.

Если ЁхЁ равно 1, то возвращаемое значение есть бесконечность (infinity) со знаком аргумента, errno принимает значение EDOM, и выводится сообщение SIGN error.

Вы можете изменить обработку ошибок для этих программ, используя matherr.

Ни atanh, ни atanhf не являются ANSI C - функциями.

#include double j0(double x); float j0f(float x); double j1(double x); float j1f(float x); double jn(int n, double x); float jnf(int n, float x); double y0(double x); float y0f(float x); double y1(double x); float y1f(float x); double yn(int n, double x); float ynf(int n, float x);

Функции Бесселя - это семейство функций - решений дифференциального уравнения:

2 2 d y dy 2 2 x * --- + x* -- + (x - p )*y = 0 2 dx dx

Эти функции имеют широкое применение в инженерии и физике.

jn вычисляет функцию Бесселя первого рода порядка n. j0 и j1 представляют собой частные случаи с порядками 0 и 1 соответственно.

Подобно этому, yn вычисляет функцию Бесселя второго рода порядка n, а y0 и y1 - частные случаи с порядками 0 и 1 соответственно.

jnf, j0f, j1f, ynf, y0f, y1f проводят те же самые вычисления, но с переменными типа float.

Каждая функция Бесселя возвращает свое значение в заданной точке х.

Ни одна из этих функций не входит в ANSI C.

#include double cbrt(double x); float cbrtf(float x);

cbrt вычисляет кубический корень из аргумента.

Возвращается кубический корень.

сbrt принадлежит System V release 4. cbrtf является расширением.

#include double copysign(double x, double y); float copysignf(float x, float y);

copysign образует число с абсолютным значением своего первого аргумента х и со знаком своего второго аргумента y.

copysignf производит те же операции, но работает с переменными типа float.

copysign возвращает число типа double с модулем х и знаком y, copysignf возвращает число типа float с модулем х и знаком y.

copysign не входит ни в ANSI C ни в System V Interface Definition, Издание 2.

#include double cosh(double x); float coshf(float x);

cosh вычисляет гиперболический косинус от аргумента х, cosh(x) определяется как (exp(x)+exp(-x))/2

Углы определены в радианах. coshf аналогичен с точностью до типов.

cosh и coshf возвращают вычисленное значение. Когда происходит переполнение, cosh возвращает значение HUGE_VAL с соответствующим знаком, глобальная переменная errno принимает значение ERANGE.

Вы можете изменить обработку ошибок для этих программ, используя matherr.

cosh coответствует стандарту ANSI. coshf является расширением.

#include double erf(double x); float erff(float x); double erfc(double x); float erfcf(float x);

erf вычисляет приближение к "функции ошибки" , которая оценивает вероятность того, что некое наблюдение окажется внутри рамок отклонения х от среднего значения на числовой оси (подразумевается нормальное вероятностное распределение). Функция ошибки определяется как

x_ 2 2 Ё (-t ) ------- * Ё e dt sqrt(x) _Ё 0

erfc вычисляет дополнительную вероятность, т. е. erfc(x) = 1 - erf(x). функция erfc вычисляется непосредственно, поэтому используется для избежания потери точности, которая возникла бы при вычитании больших вероятностей (когда x велик) из 1.

erff и erfcf отличаются только типами входных данных и результатов.

Для положительных аргументов erf и все ее разновидности возвращают вероятность - число между 0 и 1.

Ни один из этих вариантов не в ANSI C.

#include double exp(double x); float expf(float x);

х exp и expf вычисляют значение экспоненты от х, e (где e - основание натуральной системы логарифмов, приблизительно равное 2.71828).

Вы можете использовать функцию matherr (не-ANSI) для выбора обработчика ошибок для этих функций.

В случае успеха exp и expf возвращают вычисленное значение. Если результат слишком мал, возвращается значение 0. Если результат слишком велик, возвращается значение HUGE_VAL. В обоих случаях errno принимает значение ERANGE.

exp coответствует стандарту ANSI. expf является расширением.

#include double expm1(double x); float expm1f(float x);

expm1 и expm1f вычисляют значение экспоненты от х и вычитают 1, т. е. е в степени х, минус 1. (где e - основание натуральной системы логарифмов, приблизительно равное 2.71828). Результат остается точным даже для малых значениях х, в то время как использование exp(x)-1 вызвало бы потерю многих значащих цифр.

Ни expм1, ни expm1f не соответствуют стандарту ANSI и System V Interface Definition.

#include double fabs(double x); float fabsf(float x);

fabs и fabsf вычисляют ЁxЁ, абсолютное значение (модуль) от аргумента х. непосредственным обращением к битовому представлению аргумента.

Возвращается вычисленное значение. Никаких ошибок не возникает.

fabs coответствует стандарту ANSI. fabsf является расширением.

#include double floor(double x); float floorf(float x); double ceil(double x); float ceilf(float x);

floor и floorf вычисляют ближайшее целое значение, не превосходящее х. ceil и ceilf вычисляют ближайшее целое значение, не меньшее х.

floor и ceil возвращают вычисленное значение типа double. floorf и ceilf возвращают вычисленное значение типа float.

floor и ceil coответствуют стандарту ANSI. floorf и ceilf являются расширениями.

#include double fmod(double x, double y); float fmodf(float x, float y);

fmod и fmodf вычисляют остаток от деления х/у в формате плавающей точки (х ( mod y)).

Функция fmod возвращает значение x-i*y, для наибольшего такого i, что если y отличен от 0, результат имеет тот же знак, что и х, а по модулю не превосходит модуля y.

fmod(x,0) возвращает NaN, errno присваивается значение EDOM.

Вы можете изменить обработчик ошибок для этих функций, используя matherr.

fmod coответствует стандарту ANSI. fmodf является расширением.

#include double frexp(double val, int *exp); float frexpf(float val, int *exp);

Все ненулевые нормализованные числа можно представить в виде m*(2**p) . frexp разбивает переменную типа double val на мантиссу m и степень двойки р. В результате мантисса всегда будет больше 0.5 и меньше чем 1.0 (поскольку val не ноль). Степень двойки хранится в переменной *exp.

m и р вычисляются так что

р val = m*2 .

Функция frexpf идентична с точностью до типов.

frexp возвращает мантиссу m. Если val = 0 или NaN, frexp присваивает *exp значение 0, и возвращает val.

frexp coответствует стандарту ANSI. frexpf является расширением.

#include double gamma(double x); float gammaf(float x); double lgamma(double x); float lgammaf(float x); double gamma_r(double x, int *signgamp); float gammaf_r(float x, int *signgamp); double lgamma_r(double x, int *signgamp); float lgammaf_r(float x, int *signgamp);

gamma вычисляет ln(Г(х)), натуральный логарифм от гамма-функции от х. Гамма-функция (exp(gamma(x)) eсть обобщение факториала и использует то свойство, что Г(N) = N*Г(N-1). В соответствии с этим, значения гамма-функции растут очень быстро. gamma определяется как ln(Г(х)) а не как просто Г(х) для того чтобы расширить полезное поле представляемых результатов.

Знак результата сохраняется в глобальной переменной signgam, которая объявлена в math.h.

gammaf производит те же вычисления, что и gamma, но оперирует с переменными типа float.

lgamma и lgammaf - это альтернативные названия для gamma и gammaf. Они существуют в качестве напоминания о том, что вычисляется не сама гамма-функцию, а логарифм от нее.

Функции gamma_r, gammaf_r, lgamma_r и lgammaf_r подобны функциям gamma, gammaf, lgamma, lgammaf соответственно, но требуют лишний аргумент. Этот аргумент - указатель на целое число. Он используется для получения знака результата, и глобальная переменная signgam не используется. Эти функции могут быть использованы для входных заявок (но они, тем не менее, будут задавать значение глобальной переменной errno в случае возникновения ошибки).

Не путайте функцию gamma_r, которая запрашивает дополнительный аргумент, являющийся указателем на целое, с функцией _gamma_r, которая запрашивает дополнительный аргумент, являющийся указателем на структуру повторной входимости.

В случае успеха возвращается вычисленное значение.

Когда х - неположительное число, gamma возвращает HUGE_VAL, а errno принимает значение EDOM. Если происходит переполнение, gamma возвращает HUGE_VAL, а errno принимает значение ERANGE.

Вы можете изменить обработчик ошибок для этих функций, используя matherr.

Ни gamma, ни gammaf не являются ANSI C - функциями.

#include double hypot(double x, double y); float hypotf(float x, float y);

hypot вычисляет евклидово расстояние sqrt( x**2 + y**2 ) между началом координат и точкой, представленной декартовыми координатами (х, y). hypotf отличается только типом аргументов и результата.

В случае успеха возвращается расстояние. При переполнении hypot возвращает HUGE_VAL и присваивает переменной errno значение ERANGE.

Эта обработка ошибок может быть изменена с помощью функции matherr.

Ни hypot, ни hypotf не являются ANSI C - функциями.

#include int ilogb(double val); int ilogbf(float val);

Все ненулевые нормальные числа могут быть представлены в р виде m*2 . ilogb и ilogbf запрашивают аргумент val и возвращают число p. Функции frexp и frexpf подобны функциям ilogb и ilogbf, но помимо этого возвращают m.

ilogb и ilogbf возвращают степень двойки, которая используется для образования числа с плавающей точкой. Если аргумент равен 0, они возвращают -INT_MAX (INT_MAX определен в limits.h). Если val равен бесконечности или NaN, они возвращают INT_MAX.

Ни ilogb, ни ilogbf не входят в ANSI C и System V Interface Definition.

#include double infinity(void); float infinityf(void);

infinity и infinityf возвращают специальное значение, объявленное в IEEE двойной и единичнойной точности соответственно.

#include int isnan(double arg); int isinf(double arg); int finite(double arg); int isnanf(float arg); int isinff(float arg); int finitef(float arg);

Эти функции выдают информацию о заданном аргументе - числе с плавающей точкой.

Существует пять основных форматов чисел: zero

число, все биты которого - нули.

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

Число с показателем степени и с дробной частью.

Число с показателем, состоящим из одних единиц (в битовом представлении) и нулевой дробью.

Число с показателем, состоящим из одних единиц, и ненулевой дробью.

isnan возвращает 1, если аргумент равен nan. isinf возвращает 1, если аргумент равен infinity. finite возвращает 1, если аргумент равен zero, subnormal или normal. isnanf, isinff и finitef производят те же действия, что и их аналоги isnan, isinf и finite, но с одноразрядными числами с плавающей точкой.

#include double ldexp(double val, int exp); float ldexpf(float val, int exp);

ldexp вычисляет величину val*(p**exp). ldexpf аналогична с точностью до типов.

ldexp и ldexpf возвращают вычисленные значения.

При переполнении в обе стороны переменной errno присваивается значение ERANGE. При переполнении в отрицательную сторону ldexp и ldexpf приобретают значение 0.0. При переполнении в положительную сторону ldexp становится равной HUGE_VAL со знаком плюс или минус.

ldexp удовлетворяет стандарту ANSI C. ldexpf является расширением.

#include double log(double x); float logf(float x);

Возвращают значение натурального логарифма от х, то есть логарифм по основанию e ( где e - основание натуральной системы логарифмов, 2.71828. ). log и logf идентичны с точностью до типов входных и выходных данных.

Вы можете изменить обработку ошибок для этих функций, используя matherr.

В случае успеха возвращается вычисленное значение. Если х равен нулю, получаемое значение функции будет -HUGE_VAL а переменная errno станет равной EDOM. Переиначить поведение обработчика ошибок можно использованием matherr.

log удовлетворяет стандарту ANSI C. logf является расширением.

#include double log10(double x); float log10f(float x);

log10 возвращает значение логарифма по основанию 10 от х. Он определяется как ln(х)/ln(10).

logf идентичен с точностью до входных и выходных типов.

Обе функции возвращают вычисленные значения.

Для получения справки об ошибках, обратитесь к разделу, описывающему log.

log удовлетворяет стандарту ANSI C. logf является расширением.

#include double log1p(double x); float log1pf(float x);

log1p возвращает значение ln(1+x), натурального логарифма от 1+х. Предпочтительнее использовать именно log1p а не log(1+x) для большей точности вычислений при достаточно малых x.

log1pf идентичен с точностью до входных и выходных типов.

Обе функции возвращают вычисленные значения, - каждый соответствующего типа.

Ни log1p, ни log1pf не входят в ANSI C и System V Interface Definition.

#include int matherr(struct exception *e);

matherr вызывается всегда, когда функция из математической библиотеки генерирует ошибку. Вы можете видоизменить matherr своей собственной подпрограммой для того, чтобы выбрать необходимое обращение с ошибками. Выбранный matherr должен выдавать 0, если ему не удается распознать ошибку, и число, отличное от нуля в противном случае.

Когда matherr принимает ненулевое значение, сообщение об ошибке не выводится, и значение errno не изменяется. Вы можете подстроить под себя одно или оба этих обстоятельства в своей версии matherr, используя ту информацию, что содержится в структуре *e.

Ниже представлена структура exception (определенная в 'math.h'):

struct exception < int type; char *name; double arj1, arj2, retval; int err; >;

Поля структуры exception имеют следующие значения: type

Тип произошедшей ошибки. Множество закодированных типов ошибок также находится в 'math.h'.

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

Аргументы, вызвавшие ошибку.

Возвращаемое значение ошибки (то значение, которое будет иметь вызываемая функция).

Если не ноль, то это новое значение, присвоенное errno. Типы ошибок, определенные в 'math.h' представлают собой возможные математические ошибки типа: DOMAIN

Аргумент не в области определения функции; например log(-1.0).

Предполагаемые вычисления привели бы к появлению особой точки, например pow(0.0, -2.0).

Вычисления привели бы к результату слишком большому для представления, например exp(1000.0).

Вычисления привели бы к результату слишком маленькому для представления, например exp(-1000.0).

Полная потеря разрядности. Результат не имел бы значащих цифр, например sin(10e70).

Частичная потеря разрядности. Библиотечное определение matherr возвращает 0 во всех случаях.

Вы можете изменить результат вызываемой функции совершив в matherr изменение e->retval; этот результат передается к источнику вызова.

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

matherr - не ANSI-функция.

#include double modf(double val, double *ipart); float modff(float val, float *ipart);

modf разделяет переменную val типа double на целую и дробную части, возвращая дробную часть и сохраняя целую в *ipart. Не происходит никакого округления, сумма дробной и целой частей гарантированно составит val. То есть, если realpart = mod(val, &intpart); тогда 'realpart + intpart' в точности будет равняться val.

modff идентичен с точностью до типов.

Возвращается дробная часть. Знак результата совпадает со знаком исходного аргумента val.

modf удовлетворяет стандарту ANSI C. modff является расширением.

#include double nan(void); float nanf(void);

nan и nanf возвращают NaN, определенный в IEEE, двойной и одинарной точности соответственно.

#include double nextafter(double val, double dir); float nextafterf(float val, float dir);

nextafter возвращает число с плавающей точкой двойной точности ближайшее к val в направлении к числу dir. nextafterf производит те же действия с одинарной точостью. Например, nextafter(0.0,1.0) возвращает наименьшее положительное число двойной точности.

возвращает число ближайшее к val в направлении к dir число.

Ни nextafter, ни nextafterf не входят в ANSI C и System V Interface Definition.

#include double pow(double x, double y); float powf(float x, float y);

pow и powf вычисляют x в степени y.

В случае успеха возвращается вычисленное значение.

Когда происходит переполнение, pow возвращает HUGE_VAL а errno получает значение ERANGE. Ecли входной х отрицателен, а y - не целое число, тогда errno принимает значение EDOM. Если оба аргумента равны 0, pow и powf возвращают 1.

Вы можете изменить обработку ошибок для этих функций, используя matherr.

pow отвечает стандарту ANSI C. powf является расширением.

#include double rint(double x); float rintf(float x); double remainder(double x, double y); float remainderf(float x, float y);

rint и rintf возвращают свой аргумент, округленный до ближайшего целого. remainder и remainderf находят остаток от деления x/y; это будет число между -y/2 и y/2.

rint и remainder возвращают целое значение в виде double.

rint и remainder входят в System V release. rintf и remainderf являются расширениями.

#include double scalbn(double x, int n); float scalbnf(float x, int n);

scalbn и scalbnf производят операцию масштабирования, возвращая двойку в степени n, взятую х раз. Результат высчитываетсся посредством манипуляций с экспонентой, а не через стандартные возведения в степень и перемножение.

n x * 2

Ни scale, ни scalef не входят в ANSI C и System V Interface Definition.

#include double sqrt(double x); float sqrtf(float x);

sqrt вычисляет арифметический (неотрицательный) квадратный корень из аргумента.

Вы можете изменить обработку ошибок для этих функций, используя matherr.

В случае успеха возвращается вычисленное значение квадратного корня. Если х веществененный и неотрицательный, результат неотрицателен. Если х вещественный и отрицательный, переменной errno присваивается значение EDOM (ошибка DOMAIN error).

sqrt удовлетворяет стандарту ANSI C. sqrtf является расширением.

#include double sin(double x); float sinf(float x); double cos(double x); float cosf(float x);

sin и cos вычисляют (соответственно) синус и косинус от аргумента х. Углы определены в радианах.

sinf и cosf аналогичны с точностью до типов.

Возвращается значение синуса или косинуса.

sin и cos отвечают стандарту ANSI C. sinf и cosf являются расширением.

#include double sinh(double x); float sinhf(float x);

sinh вычисляет гиперболический синус от аргумента х. Углы определены в радианах.

sinh(x) определяется как (exp(x)-exp(-x))/2

sinhf аналогичен с точностью до типов.

sinh и sinhf возвращают вычисленное значение.

Когда происходит переполнение (результат слишком велик), sinh возвращает значение HUGE_VAL с соответствующим знаком, глобальная переменная errno принимает значение ERANGE.

Вы можете изменить обработку ошибок для этих программ, используя matherr.

sinh coответствует стандарту ANSI. sinhf является расширением.

#include double tan(double x); float tanf(float x);

tan вычисляет тангенс аргумента х. Углы определены в радианах.

tanf идентичен с точностью до типов.

Возвращается значение тангенса от х.

tan отвечает стандарту ANSI C. tanf является расширением.

#include double tanh(double x); float tanhf(float x);

tanh вычисляет гиперболический тангенс от аргумента х. Углы определены в радианах.

tanh(x) определяется как sinh(x)/cos(x)

tanh и tanhf возвращают вычисленное значение гиперболического тангенса.

tanh coответствует стандарту ANSI. tanhf является расширением.