Как подключить реализацию библиотеки math.h в языке си используя cmake?
Использую стандарт с11, компилятор Gcc. Подключил заголовочный файл,запустил программу, и компилятор выдал ошибку «неопредленная ссылка на функцию из math.h». Что мне нужно прописать в cmake, чтоб math.h заработала ? Видел такой вариант как target_link_libraries(project_name m) Но он не работает. Вот мой cmake файл
cmake_minimum_required(VERSION 3.17) project(tf_idf_metric_nonthread C) set(CMAKE_C_STANDARD 11) include_directories(inc) add_executable(tf_idf_metric_nonthread src/main.c inc/str.h src/str.c inc/str_mab.h src/str_map.c inc/file_metric.h src/file_metric.c) Отслеживать
задан 21 окт 2020 в 18:34
Denver Toha Denver Toha
2,595 1 1 золотой знак 12 12 серебряных знаков 32 32 бронзовых знака
а если вот так написать target_link_libraries(tf_idf_metric_nonthread m) ?
21 окт 2020 в 21:47
Ну само собой я изменял на реальное название проекта
22 окт 2020 в 10:17
я у себя протестировал и оно отработало правильно. Показывайте полный файл CMakeLists.txt и содержимое файла build/CMakeFiles/<ваш проект>.dir/link.txt там как раз будет видно команду линковки.
Стандартные математические функции в языке Си
Математические вычисления не ограничиваются лишь арифметическими действиями. Кроме них, можно ещё встретить корни, модули, логарифмы, тригонометрические функции и пр. Научимся же использовать подобные функции в своих программах.
Для использования математических функций нужно подключить заголовочный файл math.h . В ней определено много различных функций, но мы пока рассмотрим следующие:
Некоторые математические функции
fabs(x) модуль числа x
sqrt(x) квадратный корень из числа x
sin(x) синус числа x (х в радианах)
cos(x) косинус числа x (х в радианах)
pow(x, y) вычисление x y
exp(x) вычисление e x
log(x) натуральный логарифм числа x
log10(x) десятичный логарифм числа x
- Все функции возвращают значение типа double .
- Параметры функций – вещественные числа( double ), но можно передавать и целые числа. При этом произойдёт неявное преобразование типа . Компилятор из целого числа, например 3, сделает вещественное 3.0.
#include #include // подключаем math.h int main (void)
Вычислить синус угла ввёденного с клавиатуры. Угол вводится в градусах.
#include #include // подключаем math.h int main (void) < double alpha, sin_a, pi = 3.1415926; scanf("%lf",&alpha); alpha = alpha*pi/180; sin_a = sin(alpha); printf("%.2f\n", sin_a); return 0; >
В этой программе есть о чём поговорить. Тригонометрические функции, которые определены в math.h работают с радианной мерой угла. Людям же привычнее работать с градусами. Поэтому в данной программе мы предварительно перевели значение из градусов в радианы. Если этого не сделать, результат получится неправильным. Проверьте это самостоятельно.
Неявное преобразование типов
При явном преобразовании типа мы в скобках перед значением указывали тип, к которому нужно привести данное значение. В неявном преобразовании этого делать не нужно. Компилятор автоматически подберёт необходимый тип. Неявное преобразование типов осуществляется в следующих случаях:
- перед передачей аргументов в функцию (как в нашем примере с корнем. Листинг 1.)
- выполнение арифметических операций с разными типами аргументов
- перед выполнением присваивания
- если выполняются арифметические операции с разными типами аргументов. Оба аргумента приводятся к большему типу.
Порядок типов: int < float < double - при присваивании. Значение справа от оператора присваивания приводится к типу переменной слева от оператора присваивания. При этом, если больший тип присваивается меньшему, то может произойти потеря точности.
Примеры: int+float будет автоматически преобразовано к float+float
float/int будет автоматически преобразовано к float/float
double*float будет преобразовано к double*double
int = double double будет преобразовано к int с потерей дробной части
float = int int будет преобразовано к float
Сохрани в закладки или поддержи проект.
Практика
Решите предложенные задачи: Для удобства работы сразу переходите в полноэкранный режим
Дополнительные материалы
- пока нет
Math Класс
Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Предоставляет константы и статические методы для тригонометрических, логарифмических и иных общих математических функций.
public ref class Math abstract sealedpublic ref class Math sealedpublic static class Mathpublic sealed class Mathtype Math = classPublic Class MathPublic NotInheritable Class MathНаследование
Примеры
В следующем примере используется несколько математических и тригонометрических функций из Math класса для вычисления внутренних углов трапеции.
/// /// The following class represents simple functionality of the trapezoid. /// using namespace System; public ref class MathTrapezoidSample < private: double m_longBase; double m_shortBase; double m_leftLeg; double m_rightLeg; public: MathTrapezoidSample( double longbase, double shortbase, double leftLeg, double rightLeg ) < m_longBase = Math::Abs( longbase ); m_shortBase = Math::Abs( shortbase ); m_leftLeg = Math::Abs( leftLeg ); m_rightLeg = Math::Abs( rightLeg ); >private: double GetRightSmallBase() < return (Math::Pow( m_rightLeg, 2.0 ) - Math::Pow( m_leftLeg, 2.0 ) + Math::Pow( m_longBase, 2.0 ) + Math::Pow( m_shortBase, 2.0 ) - 2 * m_shortBase * m_longBase) / (2 * (m_longBase - m_shortBase)); >public: double GetHeight() < double x = GetRightSmallBase(); return Math::Sqrt( Math::Pow( m_rightLeg, 2.0 ) - Math::Pow( x, 2.0 ) ); >double GetSquare() < return GetHeight() * m_longBase / 2.0; >double GetLeftBaseRadianAngle() < double sinX = GetHeight() / m_leftLeg; return Math::Round( Math::Asin( sinX ), 2 ); >double GetRightBaseRadianAngle() < double x = GetRightSmallBase(); double cosX = (Math::Pow( m_rightLeg, 2.0 ) + Math::Pow( x, 2.0 ) - Math::Pow( GetHeight(), 2.0 )) / (2 * x * m_rightLeg); return Math::Round( Math::Acos( cosX ), 2 ); >double GetLeftBaseDegreeAngle() < double x = GetLeftBaseRadianAngle() * 180 / Math::PI; return Math::Round( x, 2 ); >double GetRightBaseDegreeAngle() < double x = GetRightBaseRadianAngle() * 180 / Math::PI; return Math::Round( x, 2 ); >>; int main() < MathTrapezoidSample^ trpz = gcnew MathTrapezoidSample( 20.0,10.0,8.0,6.0 ); Console::WriteLine( "The trapezoid's bases are 20.0 and 10.0, the trapezoid's legs are 8.0 and 6.0" ); double h = trpz->GetHeight(); Console::WriteLine( "Trapezoid height is: ", h.ToString() ); double dxR = trpz->GetLeftBaseRadianAngle(); Console::WriteLine( "Trapezoid left base angle is: Radians", dxR.ToString() ); double dyR = trpz->GetRightBaseRadianAngle(); Console::WriteLine( "Trapezoid right base angle is: Radians", dyR.ToString() ); double dxD = trpz->GetLeftBaseDegreeAngle(); Console::WriteLine( "Trapezoid left base angle is: Degrees", dxD.ToString() ); double dyD = trpz->GetRightBaseDegreeAngle(); Console::WriteLine( "Trapezoid left base angle is: Degrees", dyD.ToString() ); > /// /// The following class represents simple functionality of the trapezoid. /// using System; namespace MathClassCS < class MathTrapezoidSample < private double m_longBase; private double m_shortBase; private double m_leftLeg; private double m_rightLeg; public MathTrapezoidSample(double longbase, double shortbase, double leftLeg, double rightLeg) < m_longBase = Math.Abs(longbase); m_shortBase = Math.Abs(shortbase); m_leftLeg = Math.Abs(leftLeg); m_rightLeg = Math.Abs(rightLeg); >private double GetRightSmallBase() < return (Math.Pow(m_rightLeg,2.0) - Math.Pow(m_leftLeg,2.0) + Math.Pow(m_longBase,2.0) + Math.Pow(m_shortBase,2.0) - 2* m_shortBase * m_longBase)/ (2*(m_longBase - m_shortBase)); >public double GetHeight() < double x = GetRightSmallBase(); return Math.Sqrt(Math.Pow(m_rightLeg,2.0) - Math.Pow(x,2.0)); >public double GetSquare() < return GetHeight() * m_longBase / 2.0; >public double GetLeftBaseRadianAngle() < double sinX = GetHeight()/m_leftLeg; return Math.Round(Math.Asin(sinX),2); >public double GetRightBaseRadianAngle() < double x = GetRightSmallBase(); double cosX = (Math.Pow(m_rightLeg,2.0) + Math.Pow(x,2.0) - Math.Pow(GetHeight(),2.0))/(2*x*m_rightLeg); return Math.Round(Math.Acos(cosX),2); >public double GetLeftBaseDegreeAngle() < double x = GetLeftBaseRadianAngle() * 180/ Math.PI; return Math.Round(x,2); >public double GetRightBaseDegreeAngle() < double x = GetRightBaseRadianAngle() * 180/ Math.PI; return Math.Round(x,2); >static void Main(string[] args) < MathTrapezoidSample trpz = new MathTrapezoidSample(20.0, 10.0, 8.0, 6.0); Console.WriteLine("The trapezoid's bases are 20.0 and 10.0, the trapezoid's legs are 8.0 and 6.0"); double h = trpz.GetHeight(); Console.WriteLine("Trapezoid height is: " + h.ToString()); double dxR = trpz.GetLeftBaseRadianAngle(); Console.WriteLine("Trapezoid left base angle is: " + dxR.ToString() + " Radians"); double dyR = trpz.GetRightBaseRadianAngle(); Console.WriteLine("Trapezoid right base angle is: " + dyR.ToString() + " Radians"); double dxD = trpz.GetLeftBaseDegreeAngle(); Console.WriteLine("Trapezoid left base angle is: " + dxD.ToString() + " Degrees"); double dyD = trpz.GetRightBaseDegreeAngle(); Console.WriteLine("Trapezoid left base angle is: " + dyD.ToString() + " Degrees"); >> > open System /// The following class represents simple functionality of the trapezoid. type MathTrapezoidSample(longbase, shortbase, leftLeg, rightLeg) = member _.GetRightSmallBase() = (Math.Pow(rightLeg, 2.) - Math.Pow(leftLeg, 2.) + Math.Pow(longbase, 2.) + Math.Pow(shortbase, 2.) - 2. * shortbase * longbase) / (2. * (longbase - shortbase)) member this.GetHeight() = let x = this.GetRightSmallBase() Math.Sqrt(Math.Pow(rightLeg, 2.) - Math.Pow(x, 2.)) member this.GetSquare() = this.GetHeight() * longbase / 2. member this.GetLeftBaseRadianAngle() = let sinX = this.GetHeight() / leftLeg Math.Round(Math.Asin sinX,2) member this.GetRightBaseRadianAngle() = let x = this.GetRightSmallBase() let cosX = (Math.Pow(rightLeg, 2.) + Math.Pow(x, 2.) - Math.Pow(this.GetHeight(), 2.))/(2. * x * rightLeg) Math.Round(Math.Acos cosX, 2) member this.GetLeftBaseDegreeAngle() = let x = this.GetLeftBaseRadianAngle() * 180. / Math.PI Math.Round(x, 2) member this.GetRightBaseDegreeAngle() = let x = this.GetRightBaseRadianAngle() * 180. / Math.PI Math.Round(x, 2) let trpz = MathTrapezoidSample(20., 10., 8., 6.) printfn "The trapezoid's bases are 20.0 and 10.0, the trapezoid's legs are 8.0 and 6.0" let h = trpz.GetHeight() printfn $"Trapezoid height is: " let dxR = trpz.GetLeftBaseRadianAngle() printfn $"Trapezoid left base angle is: Radians" let dyR = trpz.GetRightBaseRadianAngle() printfn $"Trapezoid right base angle is: Radians" let dxD = trpz.GetLeftBaseDegreeAngle() printfn $"Trapezoid left base angle is: Degrees" let dyD = trpz.GetRightBaseDegreeAngle() printfn $"Trapezoid left base angle is: Degrees" 'The following class represents simple functionality of the trapezoid. Class MathTrapezoidSample Private m_longBase As Double Private m_shortBase As Double Private m_leftLeg As Double Private m_rightLeg As Double Public Sub New(ByVal longbase As Double, ByVal shortbase As Double, ByVal leftLeg As Double, ByVal rightLeg As Double) m_longBase = Math.Abs(longbase) m_shortBase = Math.Abs(shortbase) m_leftLeg = Math.Abs(leftLeg) m_rightLeg = Math.Abs(rightLeg) End Sub Private Function GetRightSmallBase() As Double GetRightSmallBase = (Math.Pow(m_rightLeg, 2) - Math.Pow(m_leftLeg, 2) + Math.Pow(m_longBase, 2) + Math.Pow(m_shortBase, 2) - 2 * m_shortBase * m_longBase) / (2 * (m_longBase - m_shortBase)) End Function Public Function GetHeight() As Double Dim x As Double = GetRightSmallBase() GetHeight = Math.Sqrt(Math.Pow(m_rightLeg, 2) - Math.Pow(x, 2)) End Function Public Function GetSquare() As Double GetSquare = GetHeight() * m_longBase / 2 End Function Public Function GetLeftBaseRadianAngle() As Double Dim sinX As Double = GetHeight() / m_leftLeg GetLeftBaseRadianAngle = Math.Round(Math.Asin(sinX), 2) End Function Public Function GetRightBaseRadianAngle() As Double Dim x As Double = GetRightSmallBase() Dim cosX As Double = (Math.Pow(m_rightLeg, 2) + Math.Pow(x, 2) - Math.Pow(GetHeight(), 2)) / (2 * x * m_rightLeg) GetRightBaseRadianAngle = Math.Round(Math.Acos(cosX), 2) End Function Public Function GetLeftBaseDegreeAngle() As Double Dim x As Double = GetLeftBaseRadianAngle() * 180 / Math.PI GetLeftBaseDegreeAngle = Math.Round(x, 2) End Function Public Function GetRightBaseDegreeAngle() As Double Dim x As Double = GetRightBaseRadianAngle() * 180 / Math.PI GetRightBaseDegreeAngle = Math.Round(x, 2) End Function Public Shared Sub Main() Dim trpz As MathTrapezoidSample = New MathTrapezoidSample(20, 10, 8, 6) Console.WriteLine("The trapezoid's bases are 20.0 and 10.0, the trapezoid's legs are 8.0 and 6.0") Dim h As Double = trpz.GetHeight() Console.WriteLine("Trapezoid height is: " + h.ToString()) Dim dxR As Double = trpz.GetLeftBaseRadianAngle() Console.WriteLine("Trapezoid left base angle is: " + dxR.ToString() + " Radians") Dim dyR As Double = trpz.GetRightBaseRadianAngle() Console.WriteLine("Trapezoid right base angle is: " + dyR.ToString() + " Radians") Dim dxD As Double = trpz.GetLeftBaseDegreeAngle() Console.WriteLine("Trapezoid left base angle is: " + dxD.ToString() + " Degrees") Dim dyD As Double = trpz.GetRightBaseDegreeAngle() Console.WriteLine("Trapezoid left base angle is: " + dyD.ToString() + " Degrees") End Sub End Class Поля
Представляет основание натурального логарифма, определяемое константой e .
Представляет отношение длины окружности к ее диаметру, определяемое константой π.
Представляет число радианов в полном обороте, заданное константой τ.
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 является расширением.