The OpenNET Project / Index page

[ новости /+++ | форум | wiki | теги | ]

Каталог документации / Раздел "Программирование, языки" / Оглавление документа
Вперед Назад Содержание

2. МАТЕМАТИЧЕСКИЕ ФУНКЦИИ

2.1 МАТЕМАТИЧЕСКИЕ ФУНКЦИИ('math.h')

В этой части собрано множество разнообразных математических функций. Соответствующие им определения и объявления содержатся в 'math.h'. Обратим внимание на два определения из 'math.h', которые представляют собой определенный интерес.

  1. Бесконечность в типе double определяется как HUGE_VAL; многие функции возвращают это значение при переполнении.
  2. Структура exception используется при написании определенных Вами обработчиков ошибок для математических функций. Вы можете определить свой способ обработки ошибок для большинства этих функций, выбрав собственную версию matherr; см. описание функции matherr для выяснения подробностей.
Поскольку обработчик ошибок вызывает fputs, математические подпрограммы требуют заглушек (фиктивных модулей) или минимальных реализаций (имплементаций) для списка подпрограмм ОС, из fputs: close, fstat, isatty, lseek, read, sbrk, write. Cм. раздел "System Calls" в The Cygnum C Support Library, для получения помощи и примеров таких реализаций программ поддержки.

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

2.2 Версия библиотеки

Существуют четыре различных версии программ математических библиотек: 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.

2.3 acos,acosf - арккосинус

 #include <math.h>
 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.

2.4 acosh, acoshf - обратный гиперболический косинус

 #include <math.h>
 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. Не рекомендуется использовать их в программах, которые могут быть перенесены на другие машины.

2.5 asin, asinf - арксинус

 #include <math.h>
 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.

2.6 asinh, asinhf - обратный гиперболический синус

 #include <math.h>
 double asinh(double x);
 float asinhf(float x);
asinh вычисляет обратный гиперболический синус, который определяется как sign(x)*ln(ЁxЁ + sqrt(sqr(x) + 1))

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

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

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

2.7 atan, atanf - арктангенс

 #include <math.h>
 double atan(double x);
 float atanf(float x);
atan вычисляет арктангенс (arctg) от заданного аргумента.

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

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

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

2.8 atan2, atan2f - арктангенс от y/x

 #include <math.h>
 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 является расширением.

2.9 atanh, atanhf - обратный гиперболический тангенс

 #include <math.h>
 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 - функциями.

2.10 jN,jNf,yN,yNf - функции Бесселя

 #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.

2.11 сbrt,cbrtf - кубический корень

 #include <math.h>
 double cbrt(double x);
 float cbrtf(float x);
cbrt вычисляет кубический корень из аргумента.

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

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

2.12 copysign, copysignf - число с абсолютным значением х и со

знаком y

 #include <math.h>
 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.

2.13 cosh, coshf - гиперболический косинус

 #include <math.h>
 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 является расширением.

2.14 erf, erff, erfc, erfcf - функции ошибки

 #include <math.h>
 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.

2.15 exp, expf - экспонента

 #include <math.h>
 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 является расширением.

2.16 expm1, expm1f - экспонента минус 1

 #include <math.h>
 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.

2.17 fabs, fabsf - абсолютное значение (модуль)

 #include <math.h>
 double fabs(double x);
 float fabsf(float x);
fabs и fabsf вычисляют ЁxЁ, абсолютное значение (модуль) от аргумента х. непосредственным обращением к битовому представлению аргумента.

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

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

2.18 floor, floorf, ceil, ceilf - наименьшее и наибольшее ближайшие целые

 #include <math.h>
 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 являются расширениями.

2.19 fmod, fmodf - остаток от деления в виде числа с плавающей точкой

 #include <math.h>
 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 является расширением.

2.20 frexp,frexpf - разбиение числа с плавающей точкой

 #include <math.h>
 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 является расширением.

2.21 gamma, gammaf, lgamma, lgammaf, gamma_r, gammaf_r, lgamma_r, lgammaf_r

 #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);
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 - функциями.

2.22 hypot, hypotf - расстояние от начала координат

 #include <math.h>
 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 - функциями.

2.23 ilogb, ilogbf - получение показателя степени в представлении числа с плавающей точкой

 #include <math.h>
 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.

2.24 infinity, infinityf - представление бесконечности

 #include <math.h>
 double infinity(void);
 float infinityf(void);
infinity и infinityf возвращают специальное значение, объявленное в IEEE двойной и единичнойной точности соответственно.

2.25 isnan, isnanf, isinf, isinff, finite, finitef - тест для чисел структуры exception

 #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);
Эти функции выдают информацию о заданном аргументе - числе с плавающей точкой.

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

zero

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

subnormal

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

normal

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

infinity

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

NAN

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

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

2.26 ldexp, ldexpf - задание показателя

 #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 является расширением.

2.27 log, logf - натуральные логарифмы

 #include <math.h>
 double log(double x);
 float logf(float x);
Возвращают значение натурального логарифма от х, то есть логарифм по основанию e ( где e - основание натуральной системы логарифмов, 2.71828...). log и logf идентичны с точностью до типов входных и выходных данных.

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

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

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

2.28 log10, log10f - логарифмы по основанию 10

 #include <math.h>
 double log10(double x);
 float log10f(float x);
log10 возвращает значение логарифма по основанию 10 от х. Он определяется как ln(х)/ln(10).

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

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

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

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

2.29 log1p, log1pf - натуральные логарифмы oт (1+x)

 #include <math.h>
 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.

2.30 matherr - изменяемый обработчик математических ошибок

 #include <math.h>
 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'.

name

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

arj1, arj2

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

retval

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

err

Если не ноль, то это новое значение, присвоенное errno.

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

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

SING

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

OVERFLOW

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

UNDERFLOW

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

TLOSS

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

PLOSS

Частичная потеря разрядности.

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

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

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

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

2.31 modf, modff - разбиение на дробную и целую части

 #include <math.h>
 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 является расширением.

2.32 nan, nanf - представление бесконечности

 #include <math.h>
 double nan(void);
 float nanf(void);
nan и nanf возвращают NaN, определенный в IEEE, двойной и одинарной точности соответственно.

2.33 nextafter, nextafterf - получение ближайшего числа

 #include <math.h>
 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.

2.34 pow, powf - x в степени y

 #include <math.h>
 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 является расширением.

2.35 rint, rintf, remainder, remainderf - округление и остаток

 #include <math.h>
 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 являются расширениями.

2.36 scalbn, scalbnf - масштабирование

 #include <math.h>
 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.

2.37 sqrt, sqrt - арифметический квадратный корень

 #include <math.h>
 double sqrt(double x);
 float sqrtf(float x);
sqrt вычисляет арифметический (неотрицательный) квадратный корень из аргумента.

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

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

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

2.38 sin, sinf, cos, cosf - синус и косинус

 #include <math.h>
 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 являются расширением.

2.39 sinh, sinhf - гиперболический синус

 #include <math.h>
 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 является расширением.

2.40 tan, tanf - тангенс

 #include <math.h>
 double tan(double x);
 float tanf(float x);
tan вычисляет тангенс аргумента х. Углы определены в радианах.

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

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

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

2.41 tanh, tanhf - гиперболический тангенс

 #include <math.h>
 double tanh(double x);
 float tanhf(float x);
tanh вычисляет гиперболический тангенс от аргумента х. Углы определены в радианах.

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

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

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


Вперед Назад Содержание

Закладки на сайте
Проследить за страницей
Created 1996-2019 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру
Hosting by Ihor