| Каталог документации / Раздел "Программирование, языки" / Оглавление документа |
| |
|
В этой части собрано множество разнообразных математических функций. Соответствующие им определения и объявления содержатся в 'math.h'. Обратим внимание на два определения из 'math.h', которые представляют собой определенный интерес.
Альтернативные объявления математическик функций, позволяющие эффективнее использовать возможности машины, - но, как правило, хуже отслеживающие ошибки и могущие вызывать дополнительные трудности на некоторых машинах, - доступны при подключении '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 <math.h>
double acos(double x);
float acosf(float x);
acosf идентичен acos, различие состоит в типах (double и floats), с которыми проводятся вычисления.
acos и acosf возвращают значения в радианах на промежутке от 0 до pi.
Если х не в промежутке [-1,1], то возвращаемое значение есть NaN (not a number), глобальная переменная errno принимает значение EDOM, и в стандартном выводе выносится сообщение DOMAIN error.
Вы можете изменить обработку ошибок для этих функций, используя matherr.
#include <math.h>
double acosh(double x);
float acoshf(float x);
x должен быть больше либо равен 1.
acoshf аналогичен acosh с точностью до типов.
acosh и acoshf принимают вычисленные значения. Если х меньше 1, возвращается NaN, при этом errno получает значение EDOM.
Вы можете изменить поведение обработчика ошибок с помощью функции matherr, которая не является стандартной ANSI C - функцией.
Ни acosh, ни acoshf не удовлетворяют стандарту ANSI C. Не рекомендуется использовать их в программах, которые могут быть перенесены на другие машины.
#include <math.h>
double asin(double x);
float asinf(float x);
asinf идентичен asin, различие состоит в типах (double и float), с которыми проводятся вычисления.
Вы можете изменить обработку ошибок для этих функций, используя matherr.
asin и asinf возвращают значения в радианах в промежутке от -pi/2 до pi/2.
Если х не в промежутке [-1,1], то возвращаемое значение есть NaN (not a number), глобальная переменная errno принимает значение EDOM, и в стандартном выводе выносится сообщение DOMAIN error.
Вы можете изменить обработчик ошибок для этих функций, используя matherr.
#include <math.h>
double asinh(double x);
float asinhf(float x);
asinhf аналогичен с точностью до типов.
asinh и asinhf возвращают вычисленные значения.
Ни asinh, ни asinhf не являются ANSI C - функциями.
#include <math.h>
double atan(double x);
float atanf(float x);
atanf аналогичен с точностью до типов.
atan и atanf возвращают значения в радианах на промежутке от -pi/2 до pi/2.
atan удовлетворяет стандарту ANSI C. atanf является расширением.
#include <math.h>
double atan2(double y, double x);
float atan2f(float y, float x);
atan2f идентичен atan, различие состоит в типах (double и float), с которыми проводятся вычисления.
atan2 и atan2f возвращают значения в радианах на промежутке от -pi/2 до pi/2.
В случае, когда и х и y оба равны нулю, возникает ошибка DOMAIN error.
Вы можете изменить обработку ошибок для этих функций, используя matherr.
atan2 удовлетворяет стандарту ANSI C. atan2f является расширением.
#include <math.h>
double atanh(double x);
float atanhf(float x);
atanh и atanhf возвращают вычисленное значение.
Если ЁхЁ превосходит 1, то возвращаемое значение есть NaN, errno принимает значение EDOM, и выводится сообщение DOMAIN error.
Если ЁхЁ равно 1, то возвращаемое значение есть бесконечность (infinity) со знаком аргумента, errno принимает значение EDOM, и выводится сообщение SIGN error.
Вы можете изменить обработку ошибок для этих программ, используя matherr.
Ни atanh, ни atanhf не являются ANSI C - функциями.
#include <math.h>
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 <math.h>
double cbrt(double x);
float cbrtf(float x);
Возвращается кубический корень.
сbrt принадлежит System V release 4. cbrtf является расширением.
знаком y
#include <math.h>
double copysign(double x, double y);
float copysignf(float x, float y);
copysignf производит те же операции, но работает с переменными типа float.
copysign возвращает число типа double с модулем х и знаком y, copysignf возвращает число типа float с модулем х и знаком y.
copysign не входит ни в ANSI C ни в System V Interface Definition, Издание 2.
#include <math.h>
double cosh(double x);
float coshf(float x);
Углы определены в радианах. coshf аналогичен с точностью до типов.
cosh и coshf возвращают вычисленное значение. Когда происходит переполнение, cosh возвращает значение HUGE_VAL с соответствующим знаком, глобальная переменная errno принимает значение ERANGE.
Вы можете изменить обработку ошибок для этих программ, используя matherr.
cosh coответствует стандарту ANSI. coshf является расширением.
#include <math.h>
double erf(double x);
float erff(float x);
double erfc(double x);
float erfcf(float x);
x_ 2
2 Ё (-t )
------- * Ё e dt
sqrt(x) _Ё
0
erff и erfcf отличаются только типами входных данных и результатов.
Для положительных аргументов erf и все ее разновидности возвращают вероятность - число между 0 и 1.
Ни один из этих вариантов не в ANSI C.
#include <math.h>
double exp(double x);
float expf(float x);
Вы можете использовать функцию matherr (не-ANSI) для выбора обработчика ошибок для этих функций.
В случае успеха exp и expf возвращают вычисленное значение. Если результат слишком мал, возвращается значение 0. Если результат слишком велик, возвращается значение HUGE_VAL. В обоих случаях errno принимает значение ERANGE.
exp coответствует стандарту ANSI. expf является расширением.
#include <math.h>
double expm1(double x);
float expm1f(float x);
Ни expм1, ни expm1f не соответствуют стандарту ANSI и System V Interface Definition.
#include <math.h>
double fabs(double x);
float fabsf(float x);
Возвращается вычисленное значение. Никаких ошибок не возникает.
fabs coответствует стандарту ANSI. fabsf является расширением.
#include <math.h>
double floor(double x);
float floorf(float x);
double ceil(double x);
float ceilf(float x);
floor и ceil возвращают вычисленное значение типа double. floorf и ceilf возвращают вычисленное значение типа float.
floor и ceil coответствуют стандарту ANSI. floorf и ceilf являются расширениями.
#include <math.h>
double fmod(double x, double y);
float fmodf(float x, float y);
Функция fmod возвращает значение x-i*y, для наибольшего такого i, что если y отличен от 0, результат имеет тот же знак, что и х, а по модулю не превосходит модуля y.
fmod(x,0) возвращает NaN, errno присваивается значение EDOM.
Вы можете изменить обработчик ошибок для этих функций, используя matherr.
fmod coответствует стандарту ANSI. fmodf является расширением.
#include <math.h>
double frexp(double val, int *exp);
float frexpf(float val, int *exp);
m и р вычисляются так что
р
val = m*2 .
frexp возвращает мантиссу m. Если val = 0 или NaN, frexp присваивает *exp значение 0, и возвращает val.
frexp coответствует стандарту ANSI. frexpf является расширением.
#include <math.h>
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);
Знак результата сохраняется в глобальной переменной 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 <math.h>
double hypot(double x, double y);
float hypotf(float x, float y);
В случае успеха возвращается расстояние. При переполнении hypot возвращает HUGE_VAL и присваивает переменной errno значение ERANGE.
Эта обработка ошибок может быть изменена с помощью функции matherr.
Ни hypot, ни hypotf не являются ANSI C - функциями.
#include <math.h>
int ilogb(double val);
int ilogbf(float val);
ilogb и ilogbf возвращают степень двойки, которая используется для образования числа с плавающей точкой. Если аргумент равен 0, они возвращают -INT_MAX (INT_MAX определен в limits.h). Если val равен бесконечности или NaN, они возвращают INT_MAX.
Ни ilogb, ни ilogbf не входят в ANSI C и System V Interface Definition.
#include <math.h>
double infinity(void);
float infinityf(void);
#include <ieeefp.h>
int isnan(double arg);
int isinf(double arg);
int finite(double arg);
int isnanf(float arg);
int isinff(float arg);
int finitef(float arg);
Существует пять основных форматов чисел:
число, все биты которого - нули.
используется для представления чисел с нулевым показателем, но ненулевой дробью.
Число с показателем степени и с дробной частью.
Число с показателем, состоящим из одних единиц (в битовом представлении) и нулевой дробью.
Число с показателем, состоящим из одних единиц, и ненулевой дробью.
isnan возвращает 1, если аргумент равен nan. isinf возвращает 1, если аргумент равен infinity. finite возвращает 1, если аргумент равен zero, subnormal или normal. isnanf, isinff и finitef производят те же действия, что и их аналоги isnan, isinf и finite, но с одноразрядными числами с плавающей точкой.
#include <math.h>
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 <math.h>
double log(double x);
float logf(float x);
Вы можете изменить обработку ошибок для этих функций, используя matherr.
В случае успеха возвращается вычисленное значение. Если х равен нулю, получаемое значение функции будет -HUGE_VAL а переменная errno станет равной EDOM. Переиначить поведение обработчика ошибок можно использованием matherr.
log удовлетворяет стандарту ANSI C. logf является расширением.
#include <math.h>
double log10(double x);
float log10f(float x);
logf идентичен с точностью до входных и выходных типов.
Обе функции возвращают вычисленные значения.
Для получения справки об ошибках, обратитесь к разделу, описывающему log.
log удовлетворяет стандарту ANSI C. logf является расширением.
#include <math.h>
double log1p(double x);
float log1pf(float x);
log1pf идентичен с точностью до входных и выходных типов.
Обе функции возвращают вычисленные значения, - каждый соответствующего типа.
Ни log1p, ни log1pf не входят в ANSI C и System V Interface Definition.
#include <math.h>
int matherr(struct exception *e);
Когда matherr принимает ненулевое значение, сообщение об ошибке не выводится, и значение errno не изменяется. Вы можете подстроить под себя одно или оба этих обстоятельства в своей версии matherr, используя ту информацию, что содержится в структуре *e.
Ниже представлена структура exception (определенная в 'math.h'):
struct exception {
int type;
char *name;
double arj1, arj2, retval;
int err;
};
Тип произошедшей ошибки. Множество закодированных типов ошибок также находится в 'math.h'.
Указатель на строку, заканчивающуюся нулем, содержащую имя той функции из математической библиотеки, в которой произошла ошибка.
Аргументы, вызвавшие ошибку.
Возвращаемое значение ошибки (то значение, которое будет иметь вызываемая функция).
Если не ноль, то это новое значение, присвоенное errno.
Аргумент не в области определения функции; например log(-1.0).
Предполагаемые вычисления привели бы к появлению особой точки, например pow(0.0, -2.0).
Вычисления привели бы к результату слишком большому для представления, например exp(1000.0).
Вычисления привели бы к результату слишком маленькому для представления, например exp(-1000.0).
Полная потеря разрядности. Результат не имел бы значащих цифр, например sin(10e70).
Частичная потеря разрядности.
Вы можете изменить результат вызываемой функции совершив в matherr изменение e->retval; этот результат передается к источнику вызова.
Если функций matherr возвращает 0 (что означает неспособность разрешить ошибку), источник вызова присваивает errno необходимоеое значение и выводит сообщение об ошибке.
matherr - не ANSI-функция.
#include <math.h>
double modf(double val, double *ipart);
float modff(float val, float *ipart);
modff идентичен с точностью до типов.
Возвращается дробная часть. Знак результата совпадает со знаком исходного аргумента val.
modf удовлетворяет стандарту ANSI C. modff является расширением.
#include <math.h>
double nan(void);
float nanf(void);
#include <math.h>
double nextafter(double val, double dir);
float nextafterf(float val, float dir);
возвращает число ближайшее к val в направлении к dir число.
Ни nextafter, ни nextafterf не входят в ANSI C и System V Interface Definition.
#include <math.h>
double pow(double x, double y);
float powf(float x, float y);
В случае успеха возвращается вычисленное значение.
Когда происходит переполнение, pow возвращает HUGE_VAL а errno получает значение ERANGE. Ecли входной х отрицателен, а y - не целое число, тогда errno принимает значение EDOM. Если оба аргумента равны 0, pow и powf возвращают 1.
Вы можете изменить обработку ошибок для этих функций, используя matherr.
pow отвечает стандарту ANSI C. powf является расширением.
#include <math.h>
double rint(double x);
float rintf(float x);
double remainder(double x, double y);
float remainderf(float x, float y);
rint и remainder возвращают целое значение в виде double.
rint и remainder входят в System V release. rintf и remainderf являются расширениями.
#include <math.h>
double scalbn(double x, int n);
float scalbnf(float x, int n);
n
x * 2
#include <math.h>
double sqrt(double x);
float sqrtf(float x);
Вы можете изменить обработку ошибок для этих функций, используя matherr.
В случае успеха возвращается вычисленное значение квадратного корня. Если х веществененный и неотрицательный, результат неотрицателен. Если х вещественный и отрицательный, переменной errno присваивается значение EDOM (ошибка DOMAIN error).
sqrt удовлетворяет стандарту ANSI C. sqrtf является расширением.
#include <math.h>
double sin(double x);
float sinf(float x);
double cos(double x);
float cosf(float x);
sinf и cosf аналогичны с точностью до типов.
Возвращается значение синуса или косинуса.
sin и cos отвечают стандарту ANSI C. sinf и cosf являются расширением.
#include <math.h>
double sinh(double x);
float sinhf(float x);
sinh(x) определяется как (exp(x)-exp(-x))/2
sinhf аналогичен с точностью до типов.
sinh и sinhf возвращают вычисленное значение.
Когда происходит переполнение (результат слишком велик), sinh возвращает значение HUGE_VAL с соответствующим знаком, глобальная переменная errno принимает значение ERANGE.
Вы можете изменить обработку ошибок для этих программ, используя matherr.
sinh coответствует стандарту ANSI. sinhf является расширением.
#include <math.h>
double tan(double x);
float tanf(float x);
tanf идентичен с точностью до типов.
Возвращается значение тангенса от х.
tan отвечает стандарту ANSI C. tanf является расширением.
#include <math.h>
double tanh(double x);
float tanhf(float x);
tanh(x) определяется как sinh(x)/cos(x)
tanh и tanhf возвращают вычисленное значение гиперболического тангенса.
tanh coответствует стандарту ANSI. tanhf является расширением.
|
Закладки на сайте Проследить за страницей |
Created 1996-2024 by Maxim Chirkov Добавить, Поддержать, Вебмастеру |