--- name: "exp" section: "3avr" platform: "linux" package: "avr-libc" version: "1:2.2.1-1" release: "Debian 13 (Trixie)" platforms: ["linux"] url: "https://new.carta.tech/avr_math" --- # exp(3avr) \: Mathematics Part of [avr\_math(3avr)](/avr_math/3avr.md). ## NAME avr\_math - \: Mathematics ## SYNOPSIS ### Macros \#define **M\_E** 2.7182818284590452354\ \#define **M\_LOG2E** 1.4426950408889634074\ \#define **M\_LOG10E** 0.43429448190325182765\ \#define **M\_LN2** 0.69314718055994530942\ \#define **M\_LN10** 2.30258509299404568402\ \#define **M\_PI** 3.14159265358979323846\ \#define **M\_PI\_2** 1.57079632679489661923\ \#define **M\_PI\_4** 0.78539816339744830962\ \#define **M\_1\_PI** 0.31830988618379067154\ \#define **M\_2\_PI** 0.63661977236758134308\ \#define **M\_2\_SQRTPI** 1.12837916709551257390\ \#define **M\_SQRT2** 1.41421356237309504880\ \#define **M\_SQRT1\_2** 0.70710678118654752440\ \#define **NAN** \_\_builtin\_nan('')\ \#define **nanf**(\_\_tagp) \_\_builtin\_nanf(\_\_tag)\ \#define **nan**(\_\_tag) \_\_builtin\_nan(\_\_tag)\ \#define **nanl**(\_\_tag) \_\_builtin\_nanl(\_\_tag)\ \#define **INFINITY** \_\_builtin\_inf()\ \#define **HUGE\_VALF** \_\_builtin\_huge\_valf()\ \#define **HUGE\_VAL** \_\_builtin\_huge\_val()\ \#define **HUGE\_VALL** \_\_builtin\_huge\_vall()\ ### Functions float **cosf** (float x)\ double **cos** (double x)\ long double **cosl** (long double x)\ float **sinf** (float x)\ double **sin** (double x)\ long double **sinl** (long double x)\ float **tanf** (float x)\ double **tan** (double x)\ long double **tanl** (long double x)\ static float **fabsf** (float \_\_x)\ static double **fabs** (double \_\_x)\ static long double **fabsl** (long double \_\_x)\ float **fmodf** (float x, float y)\ double **fmod** (double x, double y)\ long double **fmodl** (long double x, long double y)\ float **modff** (float x, float \*iptr)\ double **modf** (double x, double \*iptr)\ long double **modfl** (long double x, long double \*iptr)\ float **sqrtf** (float x)\ double **sqrt** (double x)\ long double **sqrtl** (long double x)\ float **cbrtf** (float x)\ double **cbrt** (double x)\ long double **cbrtl** (long double x)\ float **hypotf** (float x, float y)\ double **hypot** (double x, double y)\ long double **hypotl** (long double x, long double y)\ float **floorf** (float x)\ double **floor** (double x)\ long double **floorl** (long double x)\ float **ceilf** (float x)\ double **ceil** (double x)\ long double **ceill** (long double x)\ float **frexpf** (float x, int \*pexp)\ double **frexp** (double x, int \*pexp)\ long double **frexpl** (long double x, int \*pexp)\ float **ldexpf** (float x, int iexp)\ double **ldexp** (double x, int iexp)\ long double **ldexpl** (long double x, int iexp)\ float **expf** (float x)\ double **exp** (double x)\ long double **expl** (long double x)\ float **coshf** (float x)\ double **cosh** (double x)\ long double **coshl** (long double x)\ float **sinhf** (float x)\ double **sinh** (double x)\ long double **sinhl** (long double x)\ float **tanhf** (float x)\ double **tanh** (double x)\ long double **tanhl** (long double x)\ float **acosf** (float x)\ double **acos** (double x)\ long double **acosl** (long double x)\ float **asinf** (float x)\ double **asin** (double x)\ long double **asinl** (long double x)\ float **atanf** (float x)\ double **atan** (double x)\ long double **atanl** (long double x)\ float **atan2f** (float y, float x)\ double **atan2** (double y, double x)\ long double **atan2l** (long double y, long double x)\ float **logf** (float x)\ double **log** (double x)\ long double **logl** (long double x)\ float **log10f** (float x)\ double **log10** (double x)\ long double **log10l** (long double x)\ float **powf** (float x, float y)\ double **pow** (double x, double y)\ long double **powl** (long double x, long double y)\ int **isnanf** (float x)\ int **isnan** (double x)\ int **isnanl** (long double x)\ int **isinff** (float x)\ int **isinf** (double x)\ int **isinfl** (long double x)\ static int **isfinitef** (float \_\_x)\ static int **isfinite** (double \_\_x)\ static int **isfinitel** (long double \_\_x)\ static float **copysignf** (float \_\_x, float \_\_y)\ static double **copysign** (double \_\_x, double \_\_y)\ static long double **copysignl** (long double \_\_x, long double \_\_y)\ int **signbitf** (float x)\ int **signbit** (double x)\ int **signbitl** (long double x)\ float **fdimf** (float x, float y)\ double **fdim** (double x, double y)\ long double **fdiml** (long double x, long double y)\ float **fmaf** (float x, float y, float z)\ double **fma** (double x, double y, double z)\ long double **fmal** (long double x, long double y, long double z)\ float **fmaxf** (float x, float y)\ double **fmax** (double x, double y)\ long double **fmaxl** (long double x, long double y)\ float **fminf** (float x, float y)\ double **fmin** (double x, double y)\ long double **fminl** (long double x, long double y)\ float **truncf** (float x)\ double **trunc** (double x)\ long double **truncl** (long double x)\ float **roundf** (float x)\ double **round** (double x)\ long double **roundl** (long double x)\ long **lroundf** (float x)\ long **lround** (double x)\ long **lroundl** (long double x)\ long **lrintf** (float x)\ long **lrint** (double x)\ long **lrintl** (long double x)\ ### Non-Standard Math Functions float **squaref** (float x)\ double **square** (double x)\ long double **squarel** (long double x)\ ## Detailed Description ``` #include ``` This header file declares basic mathematics constants and functions. **Notes:** - • Math functions do not raise exceptions and do not change the `errno` variable. Therefore the majority of them are declared with `const` attribute, for better optimization by GCC. - • 64-bit floating-point arithmetic is only available in `avr-gcc v10` and up. The size of the `double` and `long` `double` type can be selected at compile-time with options like `-mdouble=64` and `-mlong-double=32`. Whether such options are available, and their default values, depend on how the compiler has been configured. - • The implementation of 64-bit floating-point arithmetic has some shortcomings and limitations, see the `avr-gcc Wiki` for details. - • In order to access the `float` functions, in avr-gcc v4.6 and older it is usually also required to link with `-lm`. In avr-gcc v4.7 and up, `-lm` is added automatically to all linker invocations. ## Macro Definition Documentation ### #define HUGE\_VAL \_\_builtin\_huge\_val() `double` infinity constant. ### #define HUGE\_VALF \_\_builtin\_huge\_valf() `float` infinity constant. ### #define HUGE\_VALL \_\_builtin\_huge\_vall() `long` `double` infinity constant. ### #define INFINITY \_\_builtin\_inf() `double` infinity constant. ### #define M\_1\_PI 0.31830988618379067154 The constant *1/pi*. ### #define M\_2\_PI 0.63661977236758134308 The constant *2/pi*. ### #define M\_2\_SQRTPI 1.12837916709551257390 The constant *2/sqrt*(pi). ### #define M\_E 2.7182818284590452354 The constant Euler's number *e*. ### #define M\_LN10 2.30258509299404568402 The constant natural logarithm of 10. ### #define M\_LN2 0.69314718055994530942 The constant natural logarithm of 2. ### #define M\_LOG10E 0.43429448190325182765 The constant logarithm of Euler's number *e* to base 10. ### #define M\_LOG2E 1.4426950408889634074 The constant logarithm of Euler's number *e* to base 2. ### #define M\_PI 3.14159265358979323846 The constant *pi*. ### #define M\_PI\_2 1.57079632679489661923 The constant *pi/2*. ### #define M\_PI\_4 0.78539816339744830962 The constant *pi/4*. ### #define M\_SQRT1\_2 0.70710678118654752440 The constant *1/sqrt*(2). ### #define M\_SQRT2 1.41421356237309504880 The square root of 2. ### #define NAN \_\_builtin\_nan('') The `double` representation of a constant quiet NaN. ### #define nan(\_\_tag) \_\_builtin\_nan(\_\_tag) The `double` representation of a constant quiet NaN. `__tag` is a string constant like `''` or `'123'`. ### #define nanf(\_\_tagp) \_\_builtin\_nanf(\_\_tag) The `float` representation of a constant quiet NaN. `__tag` is a string constant like `''` or `'123'`. ### #define nanl(\_\_tag) \_\_builtin\_nanl(\_\_tag) The `long` `double` representation of a constant quiet NaN. `__tag` is a string constant like `''` or `'123'`. ## Function Documentation ### double acos (double x)` [extern]` The **acos()** function computes the principal value of the arc cosine of *x*. The returned value is in the range \[0, pi\] radians or NaN. ### float acosf (float x)` [extern]` The **acosf()** function computes the principal value of the arc cosine of *x*. The returned value is in the range \[0, pi\] radians. A domain error occurs for arguments not in the range \[1, +1\]. ### long double acosl (long double x)` [extern]` The **acosl()** function computes the principal value of the arc cosine of *x*. The returned value is in the range \[0, pi\] radians or NaN. ### double asin (double x)` [extern]` The **asin()** function computes the principal value of the arc sine of *x*. The returned value is in the range \[pi/2, pi/2\] radians or NaN. ### float asinf (float x)` [extern]` The **asinf()** function computes the principal value of the arc sine of *x*. The returned value is in the range \[pi/2, pi/2\] radians. A domain error occurs for arguments not in the range \[1, +1\]. ### long double asinl (long double x)` [extern]` The **asinl()** function computes the principal value of the arc sine of *x*. The returned value is in the range \[pi/2, pi/2\] radians or NaN. ### double atan (double x)` [extern]` The **atan()** function computes the principal value of the arc tangent of *x*. The returned value is in the range \[pi/2, pi/2\] radians. ### double atan2 (double y, double x)` [extern]` The **atan2()** function computes the principal value of the arc tangent of *y / x*, using the signs of both arguments to determine the quadrant of the return value. The returned value is in the range \[pi, +pi\] radians. ### float atan2f (float y, float x)` [extern]` The **atan2f()** function computes the principal value of the arc tangent of *y / x*, using the signs of both arguments to determine the quadrant of the return value. The returned value is in the range \[pi, +pi\] radians. ### long double atan2l (long double y, long double x)` [extern]` The **atan2l()** function computes the principal value of the arc tangent of *y / x*, using the signs of both arguments to determine the quadrant of the return value. The returned value is in the range \[pi, +pi\] radians. ### float atanf (float x)` [extern]` The **atanf()** function computes the principal value of the arc tangent of *x*. The returned value is in the range \[pi/2, pi/2\] radians. ### long double atanl (long double x)` [extern]` The **atanl()** function computes the principal value of the arc tangent of *x*. The returned value is in the range \[pi/2, pi/2\] radians. ### double cbrt (double x)` [extern]` The **cbrt()** function returns the cube root of *x*. ### float cbrtf (float x)` [extern]` The **cbrtf()** function returns the cube root of *x*. ### long double cbrtl (long double x)` [extern]` The **cbrtl()** function returns the cube root of *x*. ### double ceil (double x)` [extern]` The **ceil()** function returns the smallest integral value greater than or equal to *x*, expressed as a floating-point number. ### float ceilf (float x)` [extern]` The **ceilf()** function returns the smallest integral value greater than or equal to *x*, expressed as a floating-point number. ### long double ceill (long double x)` [extern]` The **ceill()** function returns the smallest integral value greater than or equal to *x*, expressed as a floating-point number. ### static double copysign (double \_\_x, double \_\_y)` [inline]`, ` [static]` The **copysign()** function returns *\_\_x* but with the sign of *\_\_y*. They work even if *\_\_x* or *\_\_y* are NaN or zero. ### static float copysignf (float \_\_x, float \_\_y)` [inline]`, ` [static]` The **copysignf()** function returns *\_\_x* but with the sign of *\_\_y*. They work even if *\_\_x* or *\_\_y* are NaN or zero. ### static long double copysignl (long double \_\_x, long double \_\_y)` [inline]`, ` [static]` The **copysignl()** function returns *\_\_x* but with the sign of *\_\_y*. They work even if *\_\_x* or *\_\_y* are NaN or zero. ### double cos (double x)` [extern]` The **cos()** function returns the cosine of *x*, measured in radians. ### float cosf (float x)` [extern]` The **cosf()** function returns the cosine of *x*, measured in radians. ### double cosh (double x)` [extern]` The **cosh()** function returns the hyperbolic cosine of *x*. ### float coshf (float x)` [extern]` The **coshf()** function returns the hyperbolic cosine of *x*. ### long double coshl (long double x)` [extern]` The **coshl()** function returns the hyperbolic cosine of *x*. ### long double cosl (long double x)` [extern]` The **cosl()** function returns the cosine of *x*, measured in radians. ### double exp (double x)` [extern]` The **exp()** function returns the exponential value of *x*. ### float expf (float x)` [extern]` The **expf()** function returns the exponential value of *x*. ### long double expl (long double x)` [extern]` The **expl()** function returns the exponential value of *x*. ### static double fabs (double \_\_x)` [inline]`, ` [static]` The **fabs()** function computes the absolute value of a floating-point number *x*. ### static float fabsf (float \_\_x)` [inline]`, ` [static]` The **fabsf()** function computes the absolute value of a floating-point number *x*. ### static long double fabsl (long double \_\_x)` [inline]`, ` [static]` The **fabsl()** function computes the absolute value of a floating-point number *x*. ### double fdim (double x, double y)` [extern]` The **fdim()** function returns *max(x y, 0)*. If *x* or *y* or both are NaN, NaN is returned. ### float fdimf (float x, float y)` [extern]` The **fdimf()** function returns *max(x y, 0)*. If *x* or *y* or both are NaN, NaN is returned. ### long double fdiml (long double x, long double y)` [extern]` The **fdiml()** function returns *max(x y, 0)*. If *x* or *y* or both are NaN, NaN is returned. ### double floor (double x)` [extern]` The **floor()** function returns the largest integral value less than or equal to *x*, expressed as a floating-point number. ### float floorf (float x)` [extern]` The **floorf()** function returns the largest integral value less than or equal to *x*, expressed as a floating-point number. ### long double floorl (long double x)` [extern]` The **floorl()** function returns the largest integral value less than or equal to *x*, expressed as a floating-point number. ### double fma (double x, double y, double z)` [extern]` The **fma()** function performs floating-point multiply-add. This is the operation *(x \* y) + z*, but the intermediate result is not rounded to the destination type. This can sometimes improve the precision of a calculation. ### float fmaf (float x, float y, float z)` [extern]` The **fmaf()** function performs floating-point multiply-add. This is the operation *(x \* y) + z*, but the intermediate result is not rounded to the destination type. This can sometimes improve the precision of a calculation. ### long double fmal (long double x, long double y, long double z)` [extern]` The **fmal()** function performs floating-point multiply-add. This is the operation *(x \* y) + z*, but the intermediate result is not rounded to the destination type. This can sometimes improve the precision of a calculation. ### double fmax (double x, double y)` [extern]` The **fmax()** function returns the greater of the two values *x* and *y*. If an argument is NaN, the other argument is returned. If both arguments are NaN, NaN is returned. ### float fmaxf (float x, float y)` [extern]` The **fmaxf()** function returns the greater of the two values *x* and *y*. If an argument is NaN, the other argument is returned. If both arguments are NaN, NaN is returned. ### long double fmaxl (long double x, long double y)` [extern]` The **fmaxl()** function returns the greater of the two values *x* and *y*. If an argument is NaN, the other argument is returned. If both arguments are NaN, NaN is returned. ### double fmin (double x, double y)` [extern]` The **fmin()** function returns the lesser of the two values *x* and *y*. If an argument is NaN, the other argument is returned. If both arguments are NaN, NaN is returned. ### float fminf (float x, float y)` [extern]` The **fminf()** function returns the lesser of the two values *x* and *y*. If an argument is NaN, the other argument is returned. If both arguments are NaN, NaN is returned. ### long double fminl (long double x, long double y)` [extern]` The **fminl()** function returns the lesser of the two values *x* and *y*. If an argument is NaN, the other argument is returned. If both arguments are NaN, NaN is returned. ### double fmod (double x, double y)` [extern]` The function **fmod()** returns the floating-point remainder of *x / y*. ### float fmodf (float x, float y)` [extern]` The function **fmodf()** returns the floating-point remainder of *x / y*. ### long double fmodl (long double x, long double y)` [extern]` The function **fmodl()** returns the floating-point remainder of *x / y*. ### double frexp (double x, int \* pexp)` [extern]` The **frexp()** function breaks a floating-point number into a normalized fraction and an integral power of 2. It stores the integer in the `int` object pointed to by *pexp*. If *x* is a normal float point number, the **frexp()** function returns the value `v`, such that `v` has a magnitude in the interval \[1/2, 1) or zero, and *x* equals `v` times 2 raised to the power *pexp*. If *x* is zero, both parts of the result are zero. If *x* is not a finite number, the **frexp()** returns *x* as is and stores 0 by *pexp*. ### float frexpf (float x, int \* pexp)` [extern]` The **frexpf()** function breaks a floating-point number into a normalized fraction and an integral power of 2. It stores the integer in the `int` object pointed to by *pexp*. If *x* is a normal float point number, the **frexpf()** function returns the value `v`, such that `v` has a magnitude in the interval \[1/2, 1) or zero, and *x* equals `v` times 2 raised to the power *pexp*. If *x* is zero, both parts of the result are zero. If *x* is not a finite number, the **frexpf()** returns *x* as is and stores 0 by *pexp*. **Note** This implementation permits a zero pointer as a directive to skip a storing the exponent. ### long double frexpl (long double x, int \* pexp)` [extern]` The **frexpl()** function breaks a floating-point number into a normalized fraction and an integral power of 2. It stores the integer in the `int` object pointed to by *pexp*. If *x* is a normal float point number, the **frexpl()** function returns the value `v`, such that `v` has a magnitude in the interval \[1/2, 1) or zero, and *x* equals `v` times 2 raised to the power *pexp*. If *x* is zero, both parts of the result are zero. If *x* is not a finite number, the **frexpl()** returns *x* as is and stores 0 by *pexp*. ### double hypot (double x, double y)` [extern]` The **hypot()** function returns *sqrt(x\*x + y\*y)*. This is the length of the hypotenuse of a right triangle with sides of length *x* and *y*, or the distance of the point (*x*, *y*) from the origin. Using this function instead of the direct formula is wise, since the error is much smaller. No underflow with small *x* and *y*. No overflow if result is in range. ### float hypotf (float x, float y)` [extern]` The **hypotf()** function returns *sqrtf(x\*x + y\*y)*. This is the length of the hypotenuse of a right triangle with sides of length *x* and *y*, or the distance of the point (*x*, *y*) from the origin. Using this function instead of the direct formula is wise, since the error is much smaller. No underflow with small *x* and *y*. No overflow if result is in range. ### long double hypotl (long double x, long double y)` [extern]` The **hypotl()** function returns *sqrtl(x\*x + y\*y)*. This is the length of the hypotenuse of a right triangle with sides of length *x* and *y*, or the distance of the point (*x*, *y*) from the origin. Using this function instead of the direct formula is wise, since the error is much smaller. No underflow with small *x* and *y*. No overflow if result is in range. ### static int isfinite (double \_\_x)` [inline]`, ` [static]` The **isfinite()** function returns a nonzero value if *\_\_x* is finite: not plus or minus infinity, and not NaN. ### static int isfinitef (float \_\_x)` [inline]`, ` [static]` The **isfinitef()** function returns a nonzero value if *\_\_x* is finite: not plus or minus infinity, and not NaN. ### static int isfinitel (long double \_\_x)` [inline]`, ` [static]` The **isfinite()** function returns a nonzero value if *\_\_x* is finite: not plus or minus infinity, and not NaN. ### int isinf (double x)` [extern]` The function **isinf()** returns 1 if the argument *x* is positive infinity, 1 if *x* is negative infinity, and 0 otherwise. ### int isinff (float x)` [extern]` The function **isinff()** returns 1 if the argument *x* is positive infinity, 1 if *x* is negative infinity, and 0 otherwise. ### int isinfl (long double x)` [extern]` The function **isinfl()** returns 1 if the argument *x* is positive infinity, 1 if *x* is negative infinity, and 0 otherwise. ### int isnan (double x)` [extern]` The function **isnan()** returns 1 if the argument *x* represents a 'not-a-number' (NaN) object, otherwise 0. ### int isnanf (float x)` [extern]` The function **isnanf()** returns 1 if the argument *x* represents a 'not-a-number' (NaN) object, otherwise 0. ### int isnanl (long double x)` [extern]` The function **isnanl()** returns 1 if the argument *x* represents a 'not-a-number' (NaN) object, otherwise 0. ### double ldexp (double x, int iexp)` [extern]` The **ldexp()** function multiplies a floating-point number by an integral power of 2. It returns the value of *x* times 2 raised to the power *iexp*. ### float ldexpf (float x, int iexp)` [extern]` The **ldexpf()** function multiplies a floating-point number by an integral power of 2. It returns the value of *x* times 2 raised to the power *iexp*. ### long double ldexpl (long double x, int iexp)` [extern]` The **ldexpl()** function multiplies a floating-point number by an integral power of 2. It returns the value of *x* times 2 raised to the power *iexp*. ### double log (double x)` [extern]` The **log()** function returns the natural logarithm of argument *x*. ### double log10 (double x)` [extern]` The **log10()** function returns the logarithm of argument *x* to base 10. ### float log10f (float x)` [extern]` The **log10f()** function returns the logarithm of argument *x* to base 10. ### long double log10l (long double x)` [extern]` The **log10l()** function returns the logarithm of argument *x* to base 10. ### float logf (float x)` [extern]` The **logf()** function returns the natural logarithm of argument *x*. ### long double logl (long double x)` [extern]` The **logl()** function returns the natural logarithm of argument *x*. ### long lrint (double x)` [extern]` The **lrint()** function rounds *x* to the nearest integer, rounding the halfway cases to the even integer direction. (That is both 1.5 and 2.5 values are rounded to 2). This function is similar to rint() function, but it differs in type of return value and in that an overflow is possible. **Returns** The rounded long integer value. If *x* is not a finite number or an overflow was, this realization returns the `LONG_MIN` value (0x80000000). ### long lrintf (float x)` [extern]` The **lrintf()** function rounds *x* to the nearest integer, rounding the halfway cases to the even integer direction. (That is both 1.5 and 2.5 values are rounded to 2). This function is similar to rintf() function, but it differs in type of return value and in that an overflow is possible. **Returns** The rounded long integer value. If *x* is not a finite number or an overflow was, this realization returns the `LONG_MIN` value (0x80000000). ### long lrintl (long double x)` [extern]` The **lrintl()** function rounds *x* to the nearest integer, rounding the halfway cases to the even integer direction. (That is both 1.5 and 2.5 values are rounded to 2). This function is similar to rintl() function, but it differs in type of return value and in that an overflow is possible. **Returns** The rounded long integer value. If *x* is not a finite number or an overflow was, this realization returns the `LONG_MIN` value (0x80000000). ### long lround (double x)` [extern]` The **lround()** function rounds *x* to the nearest integer, but rounds halfway cases away from zero (instead of to the nearest even integer). This function is similar to **round()** function, but it differs in type of return value and in that an overflow is possible. **Returns** The rounded long integer value. If *x* is not a finite number or an overflow was, this realization returns the `LONG_MIN` value (0x80000000). ### long lroundf (float x)` [extern]` The **lroundf()** function rounds *x* to the nearest integer, but rounds halfway cases away from zero (instead of to the nearest even integer). This function is similar to **round()** function, but it differs in type of return value and in that an overflow is possible. **Returns** The rounded long integer value. If *x* is not a finite number or an overflow was, this realization returns the `LONG_MIN` value (0x80000000). ### long lroundl (long double x)` [extern]` The **lroundl()** function rounds *x* to the nearest integer, but rounds halfway cases away from zero (instead of to the nearest even integer). This function is similar to **round()** function, but it differs in type of return value and in that an overflow is possible. **Returns** The rounded long integer value. If *x* is not a finite number or an overflow was, this realization returns the `LONG_MIN` value (0x80000000). ### double modf (double x, double \* iptr)` [extern]` The **modf()** function breaks the argument *x* into integral and fractional parts, each of which has the same sign as the argument. It stores the integral part as a `double` in the object pointed to by *iptr*. The **modf()** function returns the signed fractional part of *x*. ### float modff (float x, float \* iptr)` [extern]` The **modff()** function breaks the argument *x* into integral and fractional parts, each of which has the same sign as the argument. It stores the integral part as a `float` in the object pointed to by *iptr*. The **modff()** function returns the signed fractional part of *x*. **Note** This implementation skips writing by zero pointer. However, the GCC 4.3 can replace this function with inline code that does not permit to use NULL address for the avoiding of storing. ### long double modfl (long double x, long double \* iptr)` [extern]` The **modfl()** function breaks the argument *x* into integral and fractional parts, each of which has the same sign as the argument. It stores the integral part as a `long` `double` in the object pointed to by *iptr*. The **modf()** function returns the signed fractional part of *x*. ### double pow (double x, double y)` [extern]` The function **pow()** returns the value of *x* to the exponent *y*. \ \ Notice that for integer exponents, there is the more efficient `double __builtin_powi(double x, int y)`. ### float powf (float x, float y)` [extern]` The function **powf()** returns the value of *x* to the exponent *y*. \ \ Notice that for integer exponents, there is the more efficient `float __builtin_powif(float x, int y)`. ### long double powl (long double x, long double y)` [extern]` The function **powl()** returns the value of *x* to the exponent *y*. \ \ Notice that for integer exponents, there is the more efficient `long double __builtin_powil(long double x, int y)`. ### double round (double x)` [extern]` The **round()** function rounds *x* to the nearest integer, but rounds halfway cases away from zero (instead of to the nearest even integer). Overflow is impossible. **Returns** The rounded value. If *x* is an integral or infinite, *x* itself is returned. If *x* is `NaN`, then `NaN` is returned. ### float roundf (float x)` [extern]` The **roundf()** function rounds *x* to the nearest integer, but rounds halfway cases away from zero (instead of to the nearest even integer). Overflow is impossible. **Returns** The rounded value. If *x* is an integral or infinite, *x* itself is returned. If *x* is `NaN`, then `NaN` is returned. ### long double roundl (long double x)` [extern]` The **roundl()** function rounds *x* to the nearest integer, but rounds halfway cases away from zero (instead of to the nearest even integer). Overflow is impossible. **Returns** The rounded value. If *x* is an integral or infinite, *x* itself is returned. If *x* is `NaN`, then `NaN` is returned. ### int signbit (double x)` [extern]` The **signbit()** function returns a nonzero value if the value of *x* has its sign bit set. This is not the same as \`*x* \< 0.0', because IEEE 754 floating point allows zero to be signed. The comparison '0.0 \< 0.0' is false, but \`signbit (0.0)' will return a nonzero value. ### int signbitf (float x)` [extern]` The **signbitf()** function returns a nonzero value if the value of *x* has its sign bit set. This is not the same as \`*x* \< 0.0', because IEEE 754 floating point allows zero to be signed. The comparison '0.0 \< 0.0' is false, but \`signbit (0.0)' will return a nonzero value. ### int signbitl (long double x)` [extern]` The **signbitl()** function returns a nonzero value if the value of *x* has its sign bit set. This is not the same as \`*x* \< 0.0', because IEEE 754 floating point allows zero to be signed. The comparison '0.0 \< 0.0' is false, but \`signbit (0.0)' will return a nonzero value. ### double sin (double x)` [extern]` The **sin()** function returns the sine of *x*, measured in radians. ### float sinf (float x)` [extern]` The **sinf()** function returns the sine of *x*, measured in radians. ### double sinh (double x)` [extern]` The **sinh()** function returns the hyperbolic sine of *x*. ### float sinhf (float x)` [extern]` The **sinhf()** function returns the hyperbolic sine of *x*. ### long double sinhl (long double x)` [extern]` The **sinhl()** function returns the hyperbolic sine of *x*. ### long double sinl (long double x)` [extern]` The **sinl()** function returns the sine of *x*, measured in radians. ### double sqrt (double x)` [extern]` The **sqrt()** function returns the non-negative square root of *x*. ### float sqrtf (float x)` [extern]` The **sqrtf()** function returns the non-negative square root of *x*. ### long double sqrtl (long double x)` [extern]` The **sqrtl()** function returns the non-negative square root of *x*. ### double square (double x)` [extern]` The function **square()** returns *x \* x*. **Note** This function does not belong to the C standard definition. ### float squaref (float x)` [extern]` The function **squaref()** returns *x \* x*. **Note** This function does not belong to the C standard definition. ### long double squarel (long double x)` [extern]` The function **squarel()** returns *x \* x*. **Note** This function does not belong to the C standard definition. ### double tan (double x)` [extern]` The **tan()** function returns the tangent of *x*, measured in radians. ### float tanf (float x)` [extern]` The **tanf()** function returns the tangent of *x*, measured in radians. ### double tanh (double x)` [extern]` The **tanh()** function returns the hyperbolic tangent of *x*. ### float tanhf (float x)` [extern]` The **tanhf()** function returns the hyperbolic tangent of *x*. ### long double tanhl (long double x)` [extern]` The **tanhl()** function returns the hyperbolic tangent of *x*. ### long double tanl (long double x)` [extern]` The **tanl()** function returns the tangent of *x*, measured in radians. ### double trunc (double x)` [extern]` The **trunc()** function rounds *x* to the nearest integer not larger in absolute value. ### float truncf (float x)` [extern]` The **truncf()** function rounds *x* to the nearest integer not larger in absolute value. ### long double truncl (long double x)` [extern]` The **truncl()** function rounds *x* to the nearest integer not larger in absolute value. ## Author Generated automatically by Doxygen for AVR-LibC from the source code.