avr-libc: math.h Source File

avr-libc 2.1.0 Standard C library for AVR-GCC |

## AVR Libc Home Page |  | ## AVR Libc Development Pages
## Main Page | ## User Manual | ## Library Reference | ## FAQ | ## Example Projects

Loading...
Searching...
No Matches
math.h
Go to the documentation of this file.
1/* Copyright (c) 2002,2007-2009 Michael Stumpf
2
3 Portions of documentation Copyright (c) 1990 - 1994
4 The Regents of the University of California.
5
6 All rights reserved.
7
8 Redistribution and use in source and binary forms, with or without
9 modification, are permitted provided that the following conditions are met:
10
11 * Redistributions of source code must retain the above copyright
12 notice, this list of conditions and the following disclaimer.
13
14 * Redistributions in binary form must reproduce the above copyright
15 notice, this list of conditions and the following disclaimer in
16 the documentation and/or other materials provided with the
17 distribution.
18
19 * Neither the name of the copyright holders nor the names of
20 contributors may be used to endorse or promote products derived
21 from this software without specific prior written permission.
22
23 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
24 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
27 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
30 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
31 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
32 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
33 POSSIBILITY OF SUCH DAMAGE. */
34
35/* $Id: math.h 2554 2021-05-20 22:22:24Z joerg_wunsch $ */
36
37/*
38 math.h - mathematical functions
39
40 Author : Michael Stumpf
41 Michael.Stumpf@t-online.de
42
43 __ATTR_CONST__ added by marekm@linux.org.pl for functions
44 that "do not examine any values except their arguments, and have
45 no effects except the return value", for better optimization by gcc.
46 */
47
48#ifndef __MATH_H
49#define __MATH_H
50
51/** \file */
52/** \defgroup avr_math <math.h>: Mathematics
53 \code #include <math.h> \endcode
54
55 This header file declares basic mathematics constants and
56 functions.
57
58 \par Notes:
59 - In order to access the functions declared herein, it is usually
60 also required to additionally link against the library \c libm.a.
61 See also the related \ref faq_libm "FAQ entry".
62 - Math functions do not raise exceptions and do not change the
63 \c errno variable. Therefore the majority of them are declared
64 with const attribute, for better optimization by GCC. */
65
66
67/** \ingroup avr_math */
68/*@{*/
69
70/** The constant \a e. */
71#define M_E 2.7182818284590452354
72
73/** The logarithm of the \a e to base 2. */
74#define M_LOG2E 1.4426950408889634074 /* log_2 e */
75
76/** The logarithm of the \a e to base 10. */
77#define M_LOG10E 0.43429448190325182765 /* log_10 e */
78
79/** The natural logarithm of the 2. */
80#define M_LN2 0.69314718055994530942 /* log_e 2 */
81
82/** The natural logarithm of the 10. */
83#define M_LN10 2.30258509299404568402 /* log_e 10 */
84
85/** The constant \a pi. */
86#define M_PI 3.14159265358979323846 /* pi */
87
88/** The constant \a pi/2. */
89#define M_PI_2 1.57079632679489661923 /* pi/2 */
90
91/** The constant \a pi/4. */
92#define M_PI_4 0.78539816339744830962 /* pi/4 */
93
94/** The constant \a 1/pi. */
95#define M_1_PI 0.31830988618379067154 /* 1/pi */
96
97/** The constant \a 2/pi. */
98#define M_2_PI 0.63661977236758134308 /* 2/pi */
99
100/** The constant \a 2/sqrt(pi). */
101#define M_2_SQRTPI 1.12837916709551257390 /* 2/sqrt(pi) */
102
103/** The square root of 2. */
104#define M_SQRT2 1.41421356237309504880 /* sqrt(2) */
105
106/** The constant \a 1/sqrt(2). */
107#define M_SQRT1_2 0.70710678118654752440 /* 1/sqrt(2) */
108
109/** NAN constant. */
110#define NAN __builtin_nan("")
111
112/** INFINITY constant. */
113#define INFINITY __builtin_inf()
114
115
116#ifndef __ATTR_CONST__
117# define __ATTR_CONST__ __attribute__((__const__))
118#endif
119
120#if __SIZEOF_DOUBLE__ == __SIZEOF_FLOAT__
121/* In order to provide aliases for double functions in the case where
122 double = float, use declarations with according assembler name.
123 That way:
124 1) We do *NOT* use macros like
125 #define sin sinf
126 because that would interfere with C++. For example, if some class
127 would implement a method 'sin', or if there was polymorthism for
128 a function 'sin', then we would silently rename these to 'sinf'.
129 2) We have proper prototypes, both for 'sin' and for 'sinf'.
130 3) It is zero-overhead. */
131#define __ASM_ALIAS(x) __asm(#x)
132#else
133/* double != float: Provide double prototypes. */
134#define __ASM_ALIAS(x) /* empty */
135#endif
136
137#ifdef __cplusplus
138extern "C" {
139#endif
140
141/**
142 The cosf() function returns the cosine of \a __x, measured in radians.
143 */
144__ATTR_CONST__ extern float cosf (float __x);
145__ATTR_CONST__ extern double cos (double __x) __ASM_ALIAS(cosf); /**< The alias for cosf(). */
146
147/**
148 The sinf() function returns the sine of \a __x, measured in radians.
149 */
150__ATTR_CONST__ extern float sinf (float __x);
151__ATTR_CONST__ extern double sin (double __x) __ASM_ALIAS(sinf); /**< The alias for sinf(). */
152
153/**
154 The tanf() function returns the tangent of \a __x, measured in radians.
155 */
156__ATTR_CONST__ extern float tanf (float __x);
157__ATTR_CONST__ extern double tan (double __x) __ASM_ALIAS(tanf); /**< The alias for tanf(). */
158
159/**
160 The fabsf() function computes the absolute value of a floating-point
161 number \a __x.
162 */
163 static inline float fabsf (float __x)
164{
165 return __builtin_fabsf (__x);
166}
167
168static inline double fabs (double __x)
169{
170 return __builtin_fabs (__x);
171}
172
173/**
174 The function fmodf() returns the floating-point remainder of <em>__x /
175 __y</em>.
176 */
177__ATTR_CONST__ extern float fmodf (float __x, float __y);
178__ATTR_CONST__ extern double fmod (double __x, double __y) __ASM_ALIAS(fmodf); /**< The alias for fmodf(). */
179
180/**
181 The modff() function breaks the argument \a __x into integral and
182 fractional parts, each of which has the same sign as the argument.
183 It stores the integral part as a double in the object pointed to by
184 \a __iptr.
185
186 The modff() function returns the signed fractional part of \a __x.
187
188 \note This implementation skips writing by zero pointer. However,
189 the GCC 4.3 can replace this function with inline code that does not
190 permit to use NULL address for the avoiding of storing.
191 */
192 extern float modff (float __x, float *__iptr);
193
194/** An alias for modff(). */
195 extern double modf (double __x, double *__iptr) __ASM_ALIAS(modff);
196
197/**
198 The sqrtf() function returns the non-negative square root of \a __x.
199 */
200__ATTR_CONST__ extern float sqrtf (float __x);
201
202/** An alias for sqrtf(). */
203__ATTR_CONST__ extern double sqrt (double __x) __ASM_ALIAS(sqrtf);
204
205/**
206 The cbrt() function returns the cube root of \a __x.
207 */
208__ATTR_CONST__ extern float cbrtf (float __x);
209__ATTR_CONST__ extern double cbrt (double __x) __ASM_ALIAS(cbrtf); /**< The alias for cbrtf(). */
210
211/**
212 The hypotf() function returns <em>sqrtf(__x*__x + __y*__y)</em>. This
213 is the length of the hypotenuse of a right triangle with sides of
214 length \a __x and \a __y, or the distance of the point (\a __x, \a
215 __y) from the origin. Using this function instead of the direct
216 formula is wise, since the error is much smaller. No underflow with
217 small \a __x and \a __y. No overflow if result is in range.
218 */
219__ATTR_CONST__ extern float hypotf (float __x, float __y);
220__ATTR_CONST__ extern double hypot (double __x, double __y) __ASM_ALIAS(hypotf); /**< The alias for hypotf(). */
221
222/**
223 The function squaref() returns <em>__x * __x</em>.
224
225 \note This function does not belong to the C standard definition.
226 */
227__ATTR_CONST__ extern float squaref (float __x);
228__ATTR_CONST__ extern double square (double __x) __ASM_ALIAS(squaref); /**< The alias for squaref(). */
229
230/**
231 The floorf() function returns the largest integral value less than or
232 equal to \a __x, expressed as a floating-point number.
233 */
234__ATTR_CONST__ extern float floorf (float __x);
235__ATTR_CONST__ extern double floor (double __x) __ASM_ALIAS(floorf); /**< The alias for floorf(). */
236
237/**
238 The ceilf() function returns the smallest integral value greater than
239 or equal to \a __x, expressed as a floating-point number.
240 */
241__ATTR_CONST__ extern float ceilf (float __x);
242__ATTR_CONST__ extern double ceil (double __x) __ASM_ALIAS(ceilf); /**< The alias for ceilf(). */
243
244/**
245 The frexpf() function breaks a floating-point number into a normalized
246 fraction and an integral power of 2. It stores the integer in the \c
247 int object pointed to by \a __pexp.
248
249 If \a __x is a normal float point number, the frexpf() function
250 returns the value \c v, such that \c v has a magnitude in the
251 interval [1/2, 1) or zero, and \a __x equals \c v times 2 raised to
252 the power \a __pexp. If \a __x is zero, both parts of the result are
253 zero. If \a __x is not a finite number, the frexpf() returns \a __x as
254 is and stores 0 by \a __pexp.
255
256 \note This implementation permits a zero pointer as a directive to
257 skip a storing the exponent.
258 */
259__ATTR_CONST__ extern float frexpf (float __x, int *__pexp);
260__ATTR_CONST__ extern double frexp (double __x, int *__pexp) __ASM_ALIAS(frexpf); /**< The alias for frexpf(). */
261
262/**
263 The ldexpf() function multiplies a floating-point number by an integral
264 power of 2. It returns the value of \a __x times 2 raised to the power
265 \a __exp.
266 */
267__ATTR_CONST__ extern float ldexpf (float __x, int __exp);
268__ATTR_CONST__ extern double ldexp (double __x, int __exp) __ASM_ALIAS(ldexpf); /**< The alias for ldexpf(). */
269
270/**
271 The expf() function returns the exponential value of \a __x.
272 */
273__ATTR_CONST__ extern float expf (float __x);
274__ATTR_CONST__ extern double exp (double __x) __ASM_ALIAS(expf); /**< The alias for expf(). */
275
276/**
277 The coshf() function returns the hyperbolic cosine of \a __x.
278 */
279__ATTR_CONST__ extern float coshf (float __x);
280__ATTR_CONST__ extern double cosh (double __x) __ASM_ALIAS(coshf); /**< The alias for coshf(). */
281
282/**
283 The sinhf() function returns the hyperbolic sine of \a __x.
284 */
285__ATTR_CONST__ extern float sinhf (float __x);
286__ATTR_CONST__ extern double sinh (double __x) __ASM_ALIAS(sinhf); /**< The alias for sinhf(). */
287
288/**
289 The tanhf() function returns the hyperbolic tangent of \a __x.
290 */
291__ATTR_CONST__ extern float tanhf (float __x);
292__ATTR_CONST__ extern double tanh (double __x) __ASM_ALIAS(tanhf); /**< The alias for tanhf(). */
293
294/**
295 The acosf() function computes the principal value of the arc cosine of
296 \a __x. The returned value is in the range [0, pi] radians. A domain
297 error occurs for arguments not in the range [-1, +1].
298 */
299__ATTR_CONST__ extern float acosf (float __x);
300__ATTR_CONST__ extern double acos (double __x) __ASM_ALIAS(acosf); /**< The alias for acosf(). */
301
302/**
303 The asinf() function computes the principal value of the arc sine of
304 \a __x. The returned value is in the range [-pi/2, pi/2] radians. A
305 domain error occurs for arguments not in the range [-1, +1].
306 */
307__ATTR_CONST__ extern float asinf (float __x);
308__ATTR_CONST__ extern double asin (double __x) __ASM_ALIAS(asinf); /**< The alias for asinf(). */
309
310/**
311 The atanf() function computes the principal value of the arc tangent
312 of \a __x. The returned value is in the range [-pi/2, pi/2] radians.
313 */
314__ATTR_CONST__ extern float atanf (float __x);
315__ATTR_CONST__ extern double atan (double __x) __ASM_ALIAS(atanf); /**< The alias for atanf(). */
316
317/**
318 The atan2f() function computes the principal value of the arc tangent
319 of <em>__y / __x</em>, using the signs of both arguments to determine
320 the quadrant of the return value. The returned value is in the range
321 [-pi, +pi] radians.
322 */
323__ATTR_CONST__ extern float atan2f (float __y, float __x);
324__ATTR_CONST__ extern double atan2 (double __y, double __x) __ASM_ALIAS(atan2f); /**< The alias for atan2f(). */
325
326/**
327 The logf() function returns the natural logarithm of argument \a __x.
328 */
329__ATTR_CONST__ extern float logf (float __x);
330__ATTR_CONST__ extern double log (double __x) __ASM_ALIAS(logf); /**< The alias for logf(). */
331
332/**
333 The log10f() function returns the logarithm of argument \a __x to base 10.
334 */
335__ATTR_CONST__ extern float log10f (float __x);
336__ATTR_CONST__ extern double log10 (double __x) __ASM_ALIAS(log10f); /**< The alias for log10f(). */
337
338/**
339 The function powf() returns the value of \a __x to the exponent \a __y.
340 */
341__ATTR_CONST__ extern float powf (float __x, float __y);
342__ATTR_CONST__ extern double pow (double __x, double __y) __ASM_ALIAS(powf); /**< The alias for powf(). */
343
344/**
345 The function isnanf() returns 1 if the argument \a __x represents a
346 "not-a-number" (NaN) object, otherwise 0.
347 */
348__ATTR_CONST__ extern int isnanf (float __x);
349__ATTR_CONST__ extern int isnan (double __x) __ASM_ALIAS(isnanf); /**< The alias for isnanf(). */
350
351/**
352 The function isinff() returns 1 if the argument \a __x is positive
353 infinity, -1 if \a __x is negative infinity, and 0 otherwise.
354
355 \note The GCC 4.3 can replace this function with inline code that
356 returns the 1 value for both infinities (gcc bug #35509).
357 */
358__ATTR_CONST__ extern int isinff (float __x);
359__ATTR_CONST__ extern int isinf (double __x) __ASM_ALIAS(isinff); /**< The alias for isinff(). */
360
361/**
362 The isfinitef() function returns a nonzero value if \a __x is finite:
363 not plus or minus infinity, and not NaN.
364 */
365__ATTR_CONST__ static inline int isfinitef (float __x)
366{
367 unsigned char __exp;
368 __asm__ (
369 "mov %0, %C1 \n\t"
370 "lsl %0 \n\t"
371 "mov %0, %D1 \n\t"
372 "rol %0 "
373 : "=r" (__exp)
374 : "r" (__x) );
375 return __exp != 0xff;
376}
377
378#if __SIZEOF_DOUBLE__ == __SIZEOF_FLOAT__
379 static inline int isfinite (double __x) /**< The alias for isfinitef(). */
380{
381 return isfinitef (__x);
382}
383#endif /* double = float */
384
385/**
386 The copysignf() function returns \a __x but with the sign of \a __y.
387 They work even if \a __x or \a __y are NaN or zero.
388*/
389__ATTR_CONST__ static inline float copysignf (float __x, float __y)
390{
391 __asm__ (
392 "bst %D2, 7 \n\t"
393 "bld %D0, 7 "
394 : "=r" (__x)
395 : "0" (__x), "r" (__y) );
396 return __x;
397}
398
399__ATTR_CONST__ static inline double copysign (double __x, double __y)
400{
401 __asm__ (
402 "bst %r1+%2-1, 7" "\n\t"
403 "bld %r0+%2-1, 7"
404 : "+r" (__x)
405 : "r" (__y), "n" (__SIZEOF_DOUBLE__));
406 return __x;
407}
408
409/**
410 The signbitf() function returns a nonzero value if the value of \a __x
411 has its sign bit set. This is not the same as `\a __x < 0.0',
412 because IEEE 754 floating point allows zero to be signed. The
413 comparison `-0.0 < 0.0' is false, but `signbit (-0.0)' will return a
414 nonzero value.
415 */
416__ATTR_CONST__ extern int signbitf (float __x);
417__ATTR_CONST__ extern int signbit (double __x) __ASM_ALIAS(signbitf); /**< The alias for signbitf(). */
418
419/**
420 The fdimf() function returns <em>maxf(__x - __y, 0)</em>. If \a __x or
421 \a __y or both are NaN, NaN is returned.
422 */
423__ATTR_CONST__ extern float fdimf (float __x, float __y);
424__ATTR_CONST__ extern double fdim (double __x, double __y) __ASM_ALIAS(fdimf); /**< The alias for fdimf(). */
425
426/**
427 The fmaf() function performs floating-point multiply-add. This is the
428 operation <em>(__x * __y) + __z</em>, but the intermediate result is
429 not rounded to the destination type. This can sometimes improve the
430 precision of a calculation.
431 */
432__ATTR_CONST__ extern float fmaf (float __x, float __y, float __z);
433__ATTR_CONST__ extern double fma (double __x, double __y, double __z) __ASM_ALIAS(fmaf); /**< The alias for fmaf(). */
434
435/**
436 The fmaxf() function returns the greater of the two values \a __x and
437 \a __y. If an argument is NaN, the other argument is returned. If
438 both arguments are NaN, NaN is returned.
439 */
440__ATTR_CONST__ extern float fmaxf (float __x, float __y);
441__ATTR_CONST__ extern double fmax (double __x, double __y) __ASM_ALIAS(fmaxf); /**< The alias for fmaxf(). */
442
443/**
444 The fminf() function returns the lesser of the two values \a __x and
445 \a __y. If an argument is NaN, the other argument is returned. If
446 both arguments are NaN, NaN is returned.
447 */
448__ATTR_CONST__ extern float fminf (float __x, float __y);
449__ATTR_CONST__ extern double fmin (double __x, double __y) __ASM_ALIAS(fminf); /**< The alias for fminf(). */
450
451/**
452 The truncf() function rounds \a __x to the nearest integer not larger
453 in absolute value.
454 */
455__ATTR_CONST__ extern float truncf (float __x);
456__ATTR_CONST__ extern double trunc (double __x) __ASM_ALIAS(truncf); /**< The alias for truncf(). */
457
458/**
459 The roundf() function rounds \a __x to the nearest integer, but rounds
460 halfway cases away from zero (instead of to the nearest even integer).
461 Overflow is impossible.
462
463 \return The rounded value. If \a __x is an integral or infinite, \a
464 __x itself is returned. If \a __x is \c NaN, then \c NaN is returned.
465 */
466__ATTR_CONST__ extern float roundf (float __x);
467__ATTR_CONST__ extern double round (double __x) __ASM_ALIAS(roundf); /**< The alias for roundf(). */
468
469/**
470 The lroundf() function rounds \a __x to the nearest integer, but rounds
471 halfway cases away from zero (instead of to the nearest even integer).
472 This function is similar to roundf() function, but it differs in type of
473 return value and in that an overflow is possible.
474
475 \return The rounded long integer value. If \a __x is not a finite number
476 or an overflow was, this realization returns the \c LONG_MIN value
477 (0x80000000).
478 */
479__ATTR_CONST__ extern long lroundf (float __x);
480__ATTR_CONST__ extern long lround (double __x) __ASM_ALIAS(lroundf); /**< The alias for lroundf(). */
481
482/**
483 The lrintf() function rounds \a __x to the nearest integer, rounding the
484 halfway cases to the even integer direction. (That is both 1.5 and 2.5
485 values are rounded to 2). This function is similar to rintf() function,
486 but it differs in type of return value and in that an overflow is
487 possible.
488
489 \return The rounded long integer value. If \a __x is not a finite
490 number or an overflow was, this realization returns the \c LONG_MIN
491 value (0x80000000).
492 */
493__ATTR_CONST__ extern long lrintf (float __x);
494__ATTR_CONST__ extern long lrint (double __x) __ASM_ALIAS(lrintf); /**< The alias for lrintf(). */
495
496#ifdef __cplusplus
497}
498#endif
499
500/*@}*/
501#endif /* !__MATH_H */
ceil
double ceil(double __x) __ASM_ALIAS(ceilf)
fma
double fma(double __x, double __y, double __z) __ASM_ALIAS(fmaf)
log10
double log10(double __x) __ASM_ALIAS(log10f)
asin
double asin(double __x) __ASM_ALIAS(asinf)
acos
double acos(double __x) __ASM_ALIAS(acosf)
round
double round(double __x) __ASM_ALIAS(roundf)
fminf
float fminf(float __x, float __y)
isinff
int isinff(float __x)
sin
double sin(double __x) __ASM_ALIAS(sinf)
fmod
double fmod(double __x, double __y) __ASM_ALIAS(fmodf)
trunc
double trunc(double __x) __ASM_ALIAS(truncf)
expf
float expf(float __x)
logf
float logf(float __x)
hypot
double hypot(double __x, double __y) __ASM_ALIAS(hypotf)
lrintf
long lrintf(float __x)
cosf
float cosf(float __x)
isfinitef
static int isfinitef(float __x)
Definition: math.h:365
frexpf
float frexpf(float __x, int *__pexp)
tanh
double tanh(double __x) __ASM_ALIAS(tanhf)
sinh
double sinh(double __x) __ASM_ALIAS(sinhf)
fdimf
float fdimf(float __x, float __y)
frexp
double frexp(double __x, int *__pexp) __ASM_ALIAS(frexpf)
roundf
float roundf(float __x)
fmax
double fmax(double __x, double __y) __ASM_ALIAS(fmaxf)
squaref
float squaref(float __x)
signbit
int signbit(double __x) __ASM_ALIAS(signbitf)
lroundf
long lroundf(float __x)
cbrt
double cbrt(double __x) __ASM_ALIAS(cbrtf)
pow
double pow(double __x, double __y) __ASM_ALIAS(powf)
asinf
float asinf(float __x)
ldexpf
float ldexpf(float __x, int __exp)
fabsf
static float fabsf(float __x)
Definition: math.h:163
exp
double exp(double __x) __ASM_ALIAS(expf)
cbrtf
float cbrtf(float __x)
powf
float powf(float __x, float __y)
fmaf
float fmaf(float __x, float __y, float __z)
log
double log(double __x) __ASM_ALIAS(logf)
fmin
double fmin(double __x, double __y) __ASM_ALIAS(fminf)
isinf
int isinf(double __x) __ASM_ALIAS(isinff)
floorf
float floorf(float __x)
floor
double floor(double __x) __ASM_ALIAS(floorf)
fmodf
float fmodf(float __x, float __y)
sinhf
float sinhf(float __x)
hypotf
float hypotf(float __x, float __y)
modf
double modf(double __x, double *__iptr) __ASM_ALIAS(modff)
ceilf
float ceilf(float __x)
coshf
float coshf(float __x)
atan2f
float atan2f(float __y, float __x)
sqrt
double sqrt(double __x) __ASM_ALIAS(sqrtf)
fmaxf
float fmaxf(float __x, float __y)
tanhf
float tanhf(float __x)
ldexp
double ldexp(double __x, int __exp) __ASM_ALIAS(ldexpf)
sinf
float sinf(float __x)
sqrtf
float sqrtf(float __x)
cosh
double cosh(double __x) __ASM_ALIAS(coshf)
cos
double cos(double __x) __ASM_ALIAS(cosf)
isnanf
int isnanf(float __x)
isnan
int isnan(double __x) __ASM_ALIAS(isnanf)
truncf
float truncf(float __x)
copysignf
static float copysignf(float __x, float __y)
Definition: math.h:389
modff
float modff(float __x, float *__iptr)
lrint
long lrint(double __x) __ASM_ALIAS(lrintf)
fdim
double fdim(double __x, double __y) __ASM_ALIAS(fdimf)
tanf
float tanf(float __x)
signbitf
int signbitf(float __x)
log10f
float log10f(float __x)
lround
long lround(double __x) __ASM_ALIAS(lroundf)
square
double square(double __x) __ASM_ALIAS(squaref)
atan2
double atan2(double __y, double __x) __ASM_ALIAS(atan2f)
tan
double tan(double __x) __ASM_ALIAS(tanf)
atan
double atan(double __x) __ASM_ALIAS(atanf)
acosf
float acosf(float __x)
atanf
float atanf(float __x)
isfinite
static int isfinite(double __x)
Definition: math.h:379