avr-libc  2.1.0
Standard C library for AVR-GCC

AVR Libc Home Page

AVRs

AVR Libc Development Pages

Main Page

User Manual

Library Reference

FAQ

Example Projects

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
138 extern "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 
168 static 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 */
static float copysignf(float __x, float __y)
Definition: math.h:389
float fdimf(float __x, float __y)
double hypot(double __x, double __y) __ASM_ALIAS(hypotf)
float expf(float __x)
double cbrt(double __x) __ASM_ALIAS(cbrtf)
double asin(double __x) __ASM_ALIAS(asinf)
float fminf(float __x, float __y)
double acos(double __x) __ASM_ALIAS(acosf)
double fmax(double __x, double __y) __ASM_ALIAS(fmaxf)
double round(double __x) __ASM_ALIAS(roundf)
float ceilf(float __x)
double ldexp(double __x, int __exp) __ASM_ALIAS(ldexpf)
float cbrtf(float __x)
int isnan(double __x) __ASM_ALIAS(isnanf)
float sinhf(float __x)
int signbit(double __x) __ASM_ALIAS(signbitf)
double log10(double __x) __ASM_ALIAS(log10f)
float sinf(float __x)
float coshf(float __x)
float sqrtf(float __x)
static int isfinitef(float __x)
Definition: math.h:365
int isinff(float __x)
float fmodf(float __x, float __y)
static float fabsf(float __x)
Definition: math.h:163
double cosh(double __x) __ASM_ALIAS(coshf)
float tanhf(float __x)
float atan2f(float __y, float __x)
float roundf(float __x)
float asinf(float __x)
float fmaxf(float __x, float __y)
int isnanf(float __x)
float floorf(float __x)
double fdim(double __x, double __y) __ASM_ALIAS(fdimf)
double atan2(double __y, double __x) __ASM_ALIAS(atan2f)
double pow(double __x, double __y) __ASM_ALIAS(powf)
float acosf(float __x)
double fmin(double __x, double __y) __ASM_ALIAS(fminf)
float modff(float __x, float *__iptr)
static int isfinite(double __x)
Definition: math.h:379
double log(double __x) __ASM_ALIAS(logf)
double floor(double __x) __ASM_ALIAS(floorf)
double tanh(double __x) __ASM_ALIAS(tanhf)
int isinf(double __x) __ASM_ALIAS(isinff)
float truncf(float __x)
int signbitf(float __x)
long lrintf(float __x)
double trunc(double __x) __ASM_ALIAS(truncf)
float fmaf(float __x, float __y, float __z)
float tanf(float __x)
double modf(double __x, double *__iptr) __ASM_ALIAS(modff)
double frexp(double __x, int *__pexp) __ASM_ALIAS(frexpf)
double sin(double __x) __ASM_ALIAS(sinf)
double tan(double __x) __ASM_ALIAS(tanf)
float logf(float __x)
double square(double __x) __ASM_ALIAS(squaref)
float cosf(float __x)
long lrint(double __x) __ASM_ALIAS(lrintf)
long lroundf(float __x)
double cos(double __x) __ASM_ALIAS(cosf)
double fma(double __x, double __y, double __z) __ASM_ALIAS(fmaf)
float ldexpf(float __x, int __exp)
float frexpf(float __x, int *__pexp)
double exp(double __x) __ASM_ALIAS(expf)
double fmod(double __x, double __y) __ASM_ALIAS(fmodf)
float log10f(float __x)
double sinh(double __x) __ASM_ALIAS(sinhf)
long lround(double __x) __ASM_ALIAS(lroundf)
float powf(float __x, float __y)
double sqrt(double __x) __ASM_ALIAS(sqrtf)
float atanf(float __x)
float squaref(float __x)
float hypotf(float __x, float __y)
double atan(double __x) __ASM_ALIAS(atanf)
double ceil(double __x) __ASM_ALIAS(ceilf)