math.h

Go to the documentation of this file.

#include <limits.h>
#include <float.h>
#include "errno.h"
#include "fenv.h"

#ifndef MATH_H
#define MATH_H

#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 FP_INFINITE     0
#define FP_NAN          1
#define FP_ZERO         2
#define FP_SUBNORMAL    3
#define FP_NORMAL       4
#define FP_WTF          5

#define FP_ILOGB0       -2147483648
#define FP_ILOGBNAN     -2147483648

#define MATH_ERRNO      1
#define MATH_ERREXCEPT  2
extern int _math_errhandling;

#define math_errhandling _math_errhandling

#if FLT_EVAL_METHOD == 0

    typedef float float_t;

    typedef double double_t;
#elif FLT_EVAL_METHOD == 1

    typedef double float_t;

    typedef double double_t;
#elif FLT_EVAL_METHOD == 2

    typedef long double float_t;

    typedef long double double_t;
#else

    typedef float float_t;

    typedef double double_t;
#endif

// Comparison macro


#define isgreater(x,y) ((isnan(x) || isnan(y)) ? 0 : ( (x) > (y) ? 1 : 0 ))


#define isgreaterequal(x,y) ((isnan(x) || isnan(y)) ? 0 : ( (x) >= (y) ? 1 : 0 ))


#define isless(x,y) ((isnan(x) || isnan(y)) ? 0 : ( (x) < (y) ? 1 : 0 ))


#define islessequal(x,y) ((isnan(x) || isnan(y)) ? 0 : ( (x) <= (y) ? 1 : 0 ))


#define islessgreater(x,y) ((isnan(x) || isnan(y)) ? 0 : ( (x) < (y) || (x) > (y) ? 1 : 0 ))


#define isunordered(x,y) ((isnan(x) || isnan(y)) ? 1 : 0 ))

#ifdef __cplusplus
extern "C" {
#endif

// Trigonometric functions


double cos(double x);


float cosf(float x);


long double cosl(long double x);


double sin(double x);


float sinf(float x);


long double sinl(long double x);


double tan(double x);


float tanf(float x);


long double tanl(long double x);


double acos(double x);


float acosf(float x);


long double acosl(long double x);


double asin(double x);


float asinf(float x);


long double asinl(long double x);


double atan(double x);


float atanf(float x);


long double atanl(long double x);


double atan2(double x, double y);


float atan2f(float x, float y);


long double atan2l(long double x, long double y);

// Hyperbolic functions


double cosh(double x);


float coshf(float x);


long double coshl(long double x);


double sinh(double x);


float sinhf(float x);


long double sinhl(long double x);


double tanh(double x);


float tanhf(float x);


long double tanhl(long double x);


double acosh(double x);


float acoshf(float x);


long double acoshl(long double x);


double asinh(double x);


float asinhf(float x);


long double asinhl(long double x);


double atanh(double x);


float atanhf(float x);


long double atanhl(long double x);

// Exponential and logarithmic functions


double exp(double x);


float expf(float x);


long double expl(long double x);


double frexp(double x, int* exp);


float frexpf(float x, int* exp);


long double frexpl(long double x, int* exp);


double ldexp(double x, int exp);


float ldexpf(float x, int exp);


long double ldexpl(long double x, int exp);


double log(double x);


float logf(float x);


long double logl(long double x);


double log10(double x);


float log10f(float x);


long double log10l(long double x);


double modf(double x, double* iptr);


float modff(float x, float* iptr);


long double modfl(long double x, long double* iptr);


double exp2(double x);


float exp2f(float x);


long double exp2l(long double x);


double expm1(double x);


float expm1f(float x);


long double expm1l(long double x);


int ilogb(double x);


int ilogbf(float x);


int ilogbl(long double x);


double log1p(double x);


float log1pf(float x);


long double log1pl(long double x);


double log2(double x);


float log2f(float x);


long double log2l(long double x);


double logb(double x);


float logbf(float x);


long double logbl(long double x);


double scalbn(double x, int n);


float scalbnf(float x, int n);


long double scalbnl(long double x, int n);


double scalbln(double x, long int n);


float scalblnf(float x, long int n);


long double scalblnl(long double x, long int n);

// Power functions 


double pow(double base, double exponent);


float powf(float base, float exponent);


long double powl(long double base, long double exponent);


double sqrt(double x);


float sqrtf(float x);


long double sqrtl(long double x);


double cbrt(double x);


float cbrtf(float x);


long double cbrtl(long double x);


double hypot(double x, double y);


float hypotf(float x, float y);


long double hypotl(long double x, long double y);

// Error and gamma functions


double erf(double x);


float erff(float x);


long double erfl(long double x);


double erfc(double x);


float erfcf(float x);


long double erfcl(long double x);


double tgamma(double x);


float tgammaf(float x);


long double tgammal(long double x);


double lgamma(double x);


float lgammaf(float x);


long double lgammal(long double x);

// Nearest integer floating-point operations


double ceil(double x);


float ceilf(float x);


long double ceill(long double x);


double floor(double x);


float floorf(float x);


long double floorl(long double x);


double fmod(double numer, double denom);


float fmodf(float numer, float denom);


long double fmodl(long double numer, long double denom);


double trunc(double x);


float truncf(float x);


long double truncl(long double x);


double round(double x);


float roundf(float x);


long double roundl(long double x);


long int lround(double x);


long int lroundf(float x);


long int lroundl(long double x);


long long int llround(double x);


long long int llroundf(float x);


long long int llroundl(long double x);


double rint(double x);


float rintf(float x);


long double rintl(long double x);


long int lrint(double x);


long int lrintf(float x);


long int lrintl(long double x);


long long int llrint(double x);


long long int llrintf(float x);


long long int llrintl(long double x);


double nearbyint(double x);


float nearbyintf(float x);


long double nearbyintl(long double x);


double remainder(double x, double y);


float remainderf(float x, float y);


long double remainderl(long double x, long double y);


double remquo(double numer, double denom, int* quot);


float remquof(float numer, float denom, int* quot);


long double remquol(long double numer, long double denom, int* quot);

// Floating-point manipulation functions


double copysign(double x, double y);


float copysignf(float x, float y);


long double copysignl(long double x, long double y);


double nan(const char* arg);


float nanf(const char* arg);


long double nanl(const char* arg);


double nextafter(double x, double y);


float nextafterf(float x, float y);


long double nextafterl(long double x, long double y);


double nexttoward(double x, long double y);


float nexttowardf(float x, long double y);


long double nexttowardl(long double x, long double y);

// Minimum, maximum, difference functions


double fdim(double x, double y);


float fdimf(float x, float y);


long double fdiml(long double x, long double y);


double fmax(double x, double y);


float fmaxf(float x, float y);


long double fmaxl(long double x, long double y);


double fmin(double x, double y);


float fminf(float x, float y);


long double fminl(long double x, long double y);

// Other functions


double fabs(double x);


float fabsf(float x);


long double fabsl(long double x);


double fma(double x, double y, double z);


float fmaf(float x, float y, float z);


long double fmal(long double x, long double y, long double z);

#ifdef __cplusplus
}
#endif

typedef union float_byte
{
    float f;
    unsigned char bytes[sizeof(float)];
} float_byte;

typedef union double_byte
{
    double f;
    unsigned char bytes[sizeof(double)];
} double_byte;

typedef union long_double_byte
{
    long double f;
    unsigned char bytes[sizeof(long double)];
} long_double_byte;

#ifdef __cplusplus
extern "C" {
#endif

// Additional content


int __math_fpclasify(double x);


int __math_fpclasifyf(float x);


int __math_fpclasifyl(long double x);


int __math_signbit(double x);


int __math_signbitf(float x);


int __math_signbitl(long double x);


float __math_NANf();


double __math_INF();


float __math_INFf();


long double __math_INFl();

#ifdef __cplusplus
}
#endif


#define fpclasify(x) (sizeof(x) == sizeof(double) ? __math_fpclasify(x) : (sizeof(x) == sizeof(float) ? __math_fpclasifyf(x) : __math_fpclasifyl(x)))


#define isfinite(x) ((fpclasify(x) == FP_NORMAL || fpclasify(x) == FP_ZERO ))


#define isinf(x) (fpclasify(x) == FP_INFINITE)


#define isnan(x) (fpclasify(x) == FP_NAN)


#define isnormal(x) (fpclasify(x) == FP_NORMAL)


#define signbit(arg) (sizeof(arg) == sizeof(double) ? __math_signbit(arg) : (sizeof(arg) == sizeof(float) ? __math_signbitf(arg) : __math_signbitl(arg)))


#define FP_FAST_FMA(x, y, z) (fma(x, y, z))


#define FP_FAST_FMAF(x, y, z) (fmaf(x, y, z))


#define FP_FAST_FMAL(x, y, z) (fmal(x, y, z))


#define NAN (__math_NANf())


#define INFINITY (__math_INFf())


#define HUGE_VAL (__math_INF())


#define HUGE_VALF (__math_INFf())


#define HUGE_VALL (__math_INFl())

#endif //MATH_H