math.h

Go to the documentation of this file.

 
#ifndef __MATH_H__
#define __MATH_H__
 
#include <_xeneva.h>
#include <stdint.h>
#include <string.h>
 
#ifdef __cplusplus
XE_EXTERN{
#endif
 
 
#define M_E         2.7182818284590452354  // e
#define M_LOG2E     1.4426950408889634074  // log_2 e
#define M_LOG10E    0.43429448190325182765 // log_10 e
#define M_LN2       0.69314718055994530942 // log_e 2
#define M_LN10      2.30258509299404568402 // log_e 10
#define M_PI        3.14159265358979323846 // pi
#define M_PI_2      1.57079632679489661923 // pi/2
#define M_PI_4      0.78539816339744830962 // pi/4
#define M_1_PI      0.31830988618379067154 // 1/pi
#define M_2_PI      0.63661977236758134308 // 2/pi
#define M_2_SQRTPI  1.12837916709551257390 // 2/sqrt(pi)
#define M_SQRT2     1.41421356237309504880 // sqrt(2)
#define M_SQRT1_2   0.70710678118654752440 // 1/sqrt(2)
 
typedef union {
    float f;
    uint32_t i;
}float_bits_t;
 
typedef union {
    double d;
    uint64_t i;
}double_bits_t;
 
//#define asuint(f) ((union{float _f; uint32_t _i;}){f})._i
static INLINE uint32_t asuint(float f) {
    float_bits_t u;
    memset(&u, 0, sizeof(float_bits_t));
    u.f = f;
    return u.i;
}
 
static INLINE float asfloat(uint32_t u) {
    float_bits_t fb;
    memset(&fb, 0, sizeof(float_bits_t));
    fb.i = u;
    return fb.f;
}
 
static INLINE uint64_t asuint64(double d) {
    double_bits_t db;
    memset(&db, 0, sizeof(double_bits_t));
    db.d = d;
    return db.i;
}
 
static INLINE double asdouble(uint64_t u) {
    double_bits_t db;
    memset(&db, 0, sizeof(double_bits_t));
    db.i = u;
    return db.d;
}
 
 
#define EXTRACT_WORDS(hi,lo,d)                    \
do {                                              \
  uint64_t __u = asuint64(d);                     \
  (hi) = __u >> 32;                               \
  (lo) = (uint32_t)__u;                           \
} while (0)
 
#define GET_HIGH_WORD(hi,d)                       \
do {                                              \
  (hi) = asuint64(d) >> 32;                       \
} while (0)
 
#define GET_LOW_WORD(lo,d)                        \
do {                                              \
  (lo) = (uint32_t)asuint64(d);                   \
} while (0)
 
#define INSERT_WORDS(d,hi,lo)                     \
do {                                              \
  (d) = asdouble(((uint64_t)(hi)<<32) | (uint32_t)(lo)); \
} while (0)
 
#define SET_HIGH_WORD(d,hi)                       \
  INSERT_WORDS(d, hi, (uint32_t)asuint64(d))
 
#define SET_LOW_WORD(d,lo)                        \
  INSERT_WORDS(d, asuint64(d)>>32, lo)
 
#define GET_FLOAT_WORD(w,d)                       \
do {                                              \
  (w) = asuint(d);                                \
} while (0)
 
#define SET_FLOAT_WORD(d,w)                       \
do {                                              \
  (d) = asfloat(w);                               \
} while (0)
 
enum {
    FP_NAN,
    FP_INFINITE,
    FP_ZERO,
    FP_SUBNORMAL,
    FP_NORMAL
};
 
 
static INLINE void fp_force_evalf(float x) {
    volatile float y;
    y = x;
}
 
static INLINE void fp_force_eval(double x) {
    volatile double y;
    y = x;
}
 
static INLINE void fp_force_evall(long double x) {
    volatile long double y;
    y = x;
}
XE_LIB int fpclassify(double x);
 
#define isfinite(x) ((fpclassify(x) != FP_NAN && fpclassify(x) != FP_INFINITE))
#define isnormal(x) (fpclassify(x) == FP_NORMAL)
#define isnan(x) (fpclassify(x) == FP_NAN)
#define isinf(x) (fpclassify(x) == FP_INFINITE)
 
#define FORCE_EVAL(x) do { \
 if (sizeof(x) == sizeof(float)){ \
     _KePrint("Evaluating float \r\n"); \
     fp_force_evalf(x); \
 }else if (sizeof(x) == sizeof(double)) { \
     _KePrint("FORCE EVAL double \r\n"); \
     fp_force_eval(x);    \
 } else {    \
     _KePrint("Force eval long \r\n"); \
     fp_force_evall(x); \
 }   \
}while(0)
 
    XE_LIB double ceil(double);
    XE_LIB float ceilf(float x);
    XE_LIB double cos(double);
    XE_LIB float acosf(float x);
    XE_LIB float cosf(float);
    XE_LIB double fabs(double);
    XE_LIB float fabsf(float);
    XE_LIB double floor(double);
    XE_LIB float floorf(float);
    XE_LIB double fmod(double, double);
    XE_LIB double modf(double, double *);
    XE_LIB float fmodf(float x, float y);
    XE_LIB double pow(double, double);
    XE_LIB double sin(double);
    XE_LIB float sinf(float);
    XE_LIB double sqrt(double);
    XE_LIB float sqrtf(float x);
    XE_LIB double tan(double);
    XE_LIB float tanf(float);
    XE_LIB float atanf(float x);
    XE_LIB float atan2f(float y, float x);
    XE_LIB double frexp(double x, int *exp);
    XE_LIB float roundf(float x);
 
#ifdef __cplusplus
}
#endif
 
#endif