avr_math(3avr)

📦

version 2.2.1 · 4 versions

2.2.1 · ubuntu resolute, ubuntu stonking (latest)
2.0.0+Atmel3.6.2 · debian bookworm, ubuntu jammy
2.0.0+Atmel3.7.0 · ubuntu noble
2.2.1 · debian trixie, ubuntu questing

✨ NAME ✨

avr_math — bestie, this is the <math.h> manual page: Mathematics. It lives in the avr_math(3avr) manual, and it's literally your whole math toolbox for AVR. 💅

🌈 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)
#define nan(__tag)
#define 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 <math.h>

This header file declares basic mathematics constants and functions. That's it, that's the whole vibe — constants and math, all in one header, no cap. 🎀

Notes:

Math functions do not raise exceptions and do not change the errno variable. Because of that, the majority of them are declared with const attribute, so GCC can optimize them better. ✨
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 even 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. So like, if you're on ancient avr-gcc and your floats won't link, that's why bestie. 💀

🎀 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.43429418190325182765`

Hmm, no wait — say it right. 💅

`#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. 🥧 iconic, the main character of constants.

`#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)`

Value:

__builtin_nan(__tag)

The double representation of a constant quiet NaN. __tag is a string constant like "" or "123".

`#define nanf( __tagp)`

Value:

__builtin_nanf(__tag)

The float representation of a constant quiet NaN. __tag is a string constant like "" or "123".

`#define nanl( __tag)`

Value:

__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] — ceill() hands you the smallest integral value that's still ≥ x, and gives it back as a floating-point number (not an int, we're fancy here 💅).
double copysign (double __x, double __y) [inline], [static] — copysign() gives you back __x, but wearing __y's sign — a whole outfit change 🌈. It works even when __x or __y is NaN or zero.
float copysignf (float __x, float __y) [inline], [static] — same deal as copysign(): returns __x with the sign of __y, and it still works if either one is NaN or zero ✨.
long double copysignl (long double __x, long double __y) [inline], [static] — returns __x carrying __y's sign, works even when __x or __y is NaN or zero. The long double girlies stay winning 👑.
double cos (double x) [extern] — cos() returns the cosine of x, and x is measured in radians, bestie, not degrees, don't embarrass us 🫶.
float cosf (float x) [extern] — the cosine of x, measured in radians. Same math, float-sized 🌸.
double cosh (double x) [extern] — cosh() returns the hyperbolic cosine of x. Not the regular one, the hyperbolic one, she's different 💅.
float coshf (float x) [extern] — the hyperbolic cosine of x. Float edition ✨.
long double coshl (long double x) [extern] — the hyperbolic cosine of x, long double flavored 💜.
long double cosl (long double x) [extern] — the cosine of x, measured in radians. Maximum precision, maximum drama 🌈.
double exp (double x) [extern] — exp() returns the exponential value of x. e did that 🔥.
float expf (float x) [extern] — the exponential value of x. Float-sized ✨.
long double expl (long double x) [extern] — the exponential value of x, long double precision 🎀.
double fabs (double __x) [inline], [static] — fabs() computes the absolute value of a floating-point number x. Negativity? Not on her watch 💅.
float fabsf (float __x) [inline], [static] — absolute value of a floating-point number x. Float run 🦋.
long double fabsl (long double __x) [inline], [static] — absolute value of a floating-point number x, long double style 💜.
double fdim (double x, double y) [extern] — fdim() returns max(x - y, 0). If x or y or both are NaN, you get NaN back 😭.
float fdimf (float x, float y) [extern] — returns max(x - y, 0). If x or y or both are NaN, the answer is NaN 🌸.
long double fdiml (long double x, long double y) [extern] — returns max(x - y, 0), and if x or y or both are NaN, it hands you NaN 👑.
double floor (double x) [extern] — floor() returns the largest integral value that's less than or equal to x, expressed as a floating-point number. She stays on the ground floor, no cap 💅.
float floorf (float x) [extern] — the largest integral value ≤ x, as a floating-point number ✨.
long double floorl (long double x) [extern] — the largest integral value ≤ x, expressed as a floating-point number, long double energy 🎀.
double fma (double x, double y, double z) [extern] — fma() does floating-point multiply-add: the operation (x * y) + z, except the intermediate result is not rounded to the destination type. That's the whole point — it can sometimes improve the precision of a calculation 🔥. ICONIC.
float fmaf (float x, float y, float z) [extern] — floating-point multiply-add of (x * y) + z, with the intermediate result not rounded to the destination type. Sometimes that means better precision ✨.
long double fmal (long double x, long double y, long double z) [extern] — floating-point multiply-add of (x * y) + z, intermediate result not rounded to the destination type, and yeah, this can sometimes improve precision 💜.
double fmax (double x, double y) [extern] — fmax() returns the greater of the two values x and y. If one argument is NaN, the other argument is returned. If both are NaN, then NaN is returned 🌈.
float fmaxf (float x, float y) [extern] — the greater of x and y. One NaN argument? You get the other one back. Both NaN? NaN it is 🦋.
long double fmaxl (long double x, long double y) [extern] — the greater of the two values. If an argument is NaN, the other argument is returned; if both are NaN, NaN comes home 👑.
double fmin (double x, double y) [extern] — fmin() 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, then NaN is returned 🌸.
float fminf (float x, float y) [extern] — the lesser of x and y. One NaN? Other one wins. Both NaN? NaN 💜.
long double fminl (long double x, long double y) [extern] — the lesser of the two values. NaN in one slot means the other argument is returned, and NaN in both slots means NaN is returned 🎀.
double fmod (double x, double y) [extern] — fmod() returns the floating-point remainder of x / y. Leftovers, but make it math 💅.
float fmodf (float x, float y) [extern] — the floating-point remainder of x / y ✨.
long double fmodl (long double x, long double y) [extern] — the floating-point remainder of x / y, long double precision 🌈.
double frexp (double x, int * pexp) [extern] — frexp() breaks a floating-point number into a normalized fraction and an integral power of 2, and stores that integer in the int object pointed to by pexp 🫶.

If x is a normal float point number, frexp() 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, frexp() returns x as is and stores 0 by pexp.

float frexpf (float x, int * pexp) [extern] — breaks a floating-point number into a normalized fraction and an integral power of 2, storing the integer in the int object pointed to by pexp ✨.

If x is a normal float point number, frexpf() 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, 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 🙈. Yes bestie, you can pass a null pointer and vibe.

long double frexpl (long double x, int * pexp) [extern] — breaks a floating-point number into a normalized fraction and an integral power of 2, storing the integer in the int object pointed to by pexp 💜.

If x is a normal float point number, frexpl() 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, frexpl() returns x as is and stores 0 by pexp.

double hypot (double x, double y) [extern] — hypot() returns sqrt(x*x + y*y). That's the length of the hypotenuse of a right triangle with sides of length x and y, aka the distance of the point (x, y) from the origin 🔥. Using this function instead of the direct formula is wise, because the error is much smaller. No underflow with small x and y. No overflow if the result is in range 👑.
float hypotf (float x, float y) [extern] — returns sqrtf(x*x + y*y), the hypotenuse length for a right triangle with sides x and y, or the distance of the point (x, y) from the origin. Use this instead of the direct formula and the error is much smaller — no underflow with small x and y, no overflow if the result is in range ✨.
long double hypotl (long double x, long double y) [extern] — returns sqrtl(x*x + y*y), 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. Direct formula could never 💅. Much smaller error, no underflow with small x and y, and no overflow if the result is in range 🌈.
int isfinite (double __x) [inline], [static] — isfinite() returns a nonzero value if __x is finite: not plus or minus infinity, and not NaN. Bounded queen 🎀.
int isfinitef (float __x) [inline], [static] — returns a nonzero value if __x is finite, meaning not plus or minus infinity and not NaN 🦋.
int isfinitel (long double __x) [inline], [static] — isfinite() returns a nonzero value if __x is finite: not plus or minus infinity, and not NaN 💜.
int isinf (double x) [extern] — isinf() returns 1 if the argument x is positive infinity, -1 if x is negative infinity, and 0 otherwise. A true/false/which-flavor check 🌈.
int isinff (float x) [extern] — returns 1 when x is positive infinity, -1 when x is negative infinity, and 0 otherwise ✨.
int isinfl (long double x) [extern] — 1 for positive infinity, -1 for negative infinity, 0 for everything else 💅.
int isnan (double x) [extern] — isnan() returns 1 if the argument x represents a "not-a-number" (NaN) object, otherwise 0. The vibe check for numbers 🫶.
int isnanf (float x) [extern] — 1 if x is a "not-a-number" (NaN) object, otherwise 0 🌸.
int isnanl (long double x) [extern] — 1 if x represents a "not-a-number" (NaN) object, otherwise 0 👑.
double ldexp (double x, int iexp) [extern] — ldexp() 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] — multiplies a floating-point number by an integral power of 2, returning x times 2 raised to the power iexp 🦋.
long double ldexpl (long double x, int iexp) [extern] — multiplies a floating-point number by an integral power of 2 and returns x times 2 raised to the power iexp 💜.
double log (double x) [extern] — log() returns the natural logarithm of argument x 🌿.
double log10 (double x) [extern] — log10() returns the logarithm of argument x to base 10. Yes, base 10, she's the one you learned in school 💅.
float log10f (float x) [extern] — the logarithm of argument x to base 10, float edition ✨.
long double log10l (long double x) [extern] — the logarithm of argument x to base 10, long double precision 🎀.
float logf (float x) [extern] — the natural logarithm of argument x 🌸.
long double logl (long double x) [extern] — the natural logarithm of argument x, long double flavored 🌈.

`long lrint (double x) [extern]`

Okay bestie, lrint() rounds x to the nearest integer, and when it’s exactly halfway it rounds to the even integer direction. So both 1.5 and 2.5 values are rounded to 2. This function is similar to the rint() function, but it differs in the type of return value and in that an overflow is possible.