smath.h

来自「这是整套横扫千军3D版游戏的源码」· C头文件 代码 · 共 702 行 · 第 1/3 页

    inline Simple sinh(Simple x) {return streflop_libm::__ieee754_sinhf(x);}
    inline Simple tanh(Simple x) {return streflop_libm::__tanhf(x);}
    inline Simple acosh(Simple x) {return streflop_libm::__ieee754_acoshf(x);}
    inline Simple asinh(Simple x) {return streflop_libm::__asinhf(x);}
    inline Simple atanh(Simple x) {return streflop_libm::__ieee754_atanhf(x);}

    inline Simple fabs(Simple x) {return streflop_libm::__fabsf(x);}
    inline Simple floor(Simple x) {return streflop_libm::__floorf(x);}
    inline Simple ceil(Simple x) {return streflop_libm::__ceilf(x);}
    inline Simple trunc(Simple x) {return streflop_libm::__truncf(x);}
    inline Simple fmod(Simple x, Simple y) {return streflop_libm::__ieee754_fmodf(x,y);}
    inline Simple remainder(Simple x, Simple y) {return streflop_libm::__ieee754_remainderf(x,y);}
    inline Simple remquo(Simple x, Simple y, int *quo) {return streflop_libm::__remquof(x,y,quo);}
    inline Simple rint(Simple x) {return streflop_libm::__rintf(x);}
    inline long int lrint(Simple x) {return streflop_libm::__lrintf(x);}
    inline long long int llrint(Simple x) {return streflop_libm::__llrintf(x);}
    inline Simple round(Simple x) {return streflop_libm::__roundf(x);}
    inline long int lround(Simple x) {return streflop_libm::__lroundf(x);}
    inline long long int llround(Simple x) {return streflop_libm::__llroundf(x);}
    inline Simple nearbyint(Simple x) {return streflop_libm::__nearbyintf(x);}

    inline Simple frexp(Simple x, int *exp) {return streflop_libm::__frexpf(x,exp);}
    inline Simple ldexp(Simple value, int exp) {return streflop_libm::__ldexpf(value,exp);}
    inline Simple logb(Simple x) {return streflop_libm::__logbf(x);}
    inline int ilogb(Simple x) {return streflop_libm::__ilogbf(x);}
    inline Simple copysign(Simple x) {return streflop_libm::__copysignf(x);}
#undef signbit
    inline int signbit (Simple x) {return streflop_libm::__signbitf(x);}
    inline Simple nextafter(Simple x, Simple y) {return streflop_libm::__nextafterf(x,y);}

    inline Simple expm1(Simple x) {return streflop_libm::__expm1f(x);}
    inline Simple log1p(Simple x) {return streflop_libm::__log1pf(x);}
    inline Simple erf(Simple x) {return streflop_libm::__erff(x);}
    inline Simple j0(Simple x) {return streflop_libm::__ieee754_j0f(x);}
    inline Simple j1(Simple x) {return streflop_libm::__ieee754_j1f(x);}
    inline Simple jn(int n, Simple x) {return streflop_libm::__ieee754_jnf(n,x);}
    inline Simple y0(Simple x) {return streflop_libm::__ieee754_y0f(x);}
    inline Simple y1(Simple x) {return streflop_libm::__ieee754_y1f(x);}
    inline Simple yn(int n, Simple x) {return streflop_libm::__ieee754_ynf(n,x);}
    inline Simple scalbn(Simple x, int n) {return streflop_libm::__scalbnf(x,n);}
    inline Simple scalbln(Simple x, long int n) {return streflop_libm::__scalblnf(x,n);}

#undef fpclassify
    inline int fpclassify(Simple x) {return streflop_libm::__fpclassifyf(x);}
#undef isnan
    inline int isnan(Simple x) {return streflop_libm::__isnanf(x);}
#undef isinf
    inline int isinf(Simple x) {return streflop_libm::__isinff(x);}
#undef isfinite
    inline int isfinite(Simple x) {return !(isnan(x) || isinf(x));}

    // Stolen from math.h and inlined instead of macroized.
    // Return nonzero value if X is neither zero, subnormal, Inf, nor NaN.  */
#undef isnormal
    inline int isnormal(Simple x) {return fpclassify(x) == STREFLOP_FP_NORMAL;}

    // Constants user may set
    extern const Simple SimplePositiveInfinity;
    extern const Simple SimpleNegativeInfinity;
    // Non-signaling NaN used for returning such results
    // Standard lets a large room for implementing different kinds of NaN
    // These NaN can be used for custom purposes
    // Threated as an integer, the bit pattern here may be incremented to get at least 2^20 different NaN custom numbers!
    // Note that when switching the left-most bit to 1, you can get another bunch of negative NaNs, whatever this mean.
    extern const Simple SimpleNaN;

    /** Generic C99 "macros" for unordered comparison
        Defined as inlined for each type, thanks to C++ overloading
    */
    inline bool isunordered(Simple x, Simple y) {
        return (fpclassify(x) == STREFLOP_FP_NAN) || (fpclassify (y) == STREFLOP_FP_NAN);
    }
    inline bool isgreater(Simple x, Simple y) {
        return (!isunordered(x,y)) && (x > y);
    }
    inline bool isgreaterequal(Simple x, Simple y) {
        return (!isunordered(x,y)) && (x >= y);
    }
    inline bool isless(Simple x, Simple y) {
        return (!isunordered(x,y)) && (x < y);
    }
    inline bool islessequal(Simple x, Simple y) {
        return (!isunordered(x,y)) && (x <= y);
    }
    inline bool islessgreater(Simple x, Simple y) {
        return (!isunordered(x,y)) && ((x < y) || (x > y));
    }


// Add xxxf alias to ease porting existing code to streflop
// Additionally, using xxxf(number) avoids potential confusion

    inline Simple sqrtf(Simple x) {return sqrt(x);}
    inline Simple cbrtf(Simple x) {return cbrt(x);}
    inline Simple hypotf(Simple x, Simple y) {return hypot(x, y);}

    inline Simple expf(Simple x) {return exp(x);}
    inline Simple logf(Simple x) {return log(x);}
    inline Simple log2f(Simple x) {return log2(x);}
    inline Simple exp2f(Simple x) {return exp2(x);}
    inline Simple log10f(Simple x) {return log10(x);}
    inline Simple powf(Simple x, Simple y) {return pow(x, y);}

    inline Simple sinf(Simple x) {return sin(x);}
    inline Simple cosf(Simple x) {return cos(x);}
    inline Simple tanf(Simple x) {return tan(x);}
    inline Simple acosf(Simple x) {return acos(x);}
    inline Simple asinf(Simple x) {return asin(x);}
    inline Simple atanf(Simple x) {return atan(x);}
    inline Simple atan2f(Simple x, Simple y) {return atan2(x, y);}

    inline Simple coshf(Simple x) {return cosh(x);}
    inline Simple sinhf(Simple x) {return sinh(x);}
    inline Simple tanhf(Simple x) {return tanh(x);}
    inline Simple acoshf(Simple x) {return acosh(x);}
    inline Simple asinhf(Simple x) {return asinh(x);}
    inline Simple atanhf(Simple x) {return atanh(x);}

    inline Simple fabsf(Simple x) {return fabs(x);}
    inline Simple floorf(Simple x) {return floor(x);}
    inline Simple ceilf(Simple x) {return ceil(x);}
    inline Simple truncf(Simple x) {return trunc(x);}
    inline Simple fmodf(Simple x, Simple y) {return fmod(x,y);}
    inline Simple remainderf(Simple x, Simple y) {return remainder(x,y);}
    inline Simple remquof(Simple x, Simple y, int *quo) {return remquo(x, y, quo);}
    inline Simple rintf(Simple x) {return rint(x);}
    inline long int lrintf(Simple x) {return lrint(x);}
    inline long long int llrintf(Simple x) {return llrint(x);}
    inline Simple roundf(Simple x) {return round(x);}
    inline long int lroundf(Simple x) {return lround(x);}
    inline long long int llroundf(Simple x) {return llround(x);}
    inline Simple nearbyintf(Simple x) {return nearbyint(x);}

    inline Simple frexpf(Simple x, int *exp) {return frexp(x, exp);}
    inline Simple ldexpf(Simple value, int exp) {return ldexp(value,exp);}
    inline Simple logbf(Simple x) {return logb(x);}
    inline int ilogbf(Simple x) {return ilogb(x);}
    inline Simple copysignf(Simple x) {return copysign(x);}
    inline int signbitf(Simple x) {return signbit(x);}
    inline Simple nextafterf(Simple x, Simple y) {return nextafter(x, y);}

    inline Simple expm1f(Simple x) {return expm1(x);}
    inline Simple log1pf(Simple x) {return log1p(x);}
    inline Simple erff(Simple x) {return erf(x);}
    inline Simple j0f(Simple x) {return j0(x);}
    inline Simple j1f(Simple x) {return j1(x);}
    inline Simple jnf(int n, Simple x) {return jn(n, x);}
    inline Simple y0f(Simple x) {return y0(x);}
    inline Simple y1f(Simple x) {return y1(x);}
    inline Simple ynf(int n, Simple x) {return yn(n, x);}
    inline Simple scalbnf(Simple x, int n) {return scalbn(x, n);}
    inline Simple scalblnf(Simple x, long int n) {return scalbln(x, n);}

    inline int fpclassifyf(Simple x) {return fpclassify(x);}
    inline int isnanf(Simple x) {return isnan(x);}
    inline int isinff(Simple x) {return isinf(x);}
    inline int isfinitef(Simple x) {return isfinite(x);}
    inline int isnormalf(Simple x) {return isnormal(x);}

    inline bool isunorderedf(Simple x, Simple y) {return isunordered(x, y);}
    inline bool isgreaterf(Simple x, Simple y) {return isgreater(x, y);}
    inline bool isgreaterequalf(Simple x, Simple y) {return isgreaterequalf(x, y);}
    inline bool islessf(Simple x, Simple y) {return isless(x, y);}
    inline bool islessequalf(Simple x, Simple y) {return islessequal(x, y);}
    inline bool islessgreaterf(Simple x, Simple y) {return islessgreater(x, y);}


// Declare Double functions
// Simple and double are present in all configurations

    inline Double sqrt(Double x) {return streflop_libm::__ieee754_sqrt(x);}
    inline Double cbrt(Double x) {return streflop_libm::__cbrt(x);}
    inline Double hypot(Double x, Double y) {return streflop_libm::__ieee754_hypot(x,y);}

    inline Double exp(Double x) {return streflop_libm::__ieee754_exp(x);}
    inline Double log(Double x) {return streflop_libm::__ieee754_log(x);}
    inline Double log2(Double x) {return streflop_libm::__ieee754_log2(x);}
    inline Double exp2(Double x) {return streflop_libm::__ieee754_exp2(x);}
    inline Double log10(Double x) {return streflop_libm::__ieee754_log10(x);}
    inline Double pow(Double x, Double y) {return streflop_libm::__ieee754_pow(x,y);}

    inline Double sin(Double x) {return streflop_libm::__sin(x);}
    inline Double cos(Double x) {return streflop_libm::__cos(x);}
    inline Double tan(Double x) {return streflop_libm::tan(x);}
    inline Double acos(Double x) {return streflop_libm::__ieee754_acos(x);}
    inline Double asin(Double x) {return streflop_libm::__ieee754_asin(x);}
    inline Double atan(Double x) {return streflop_libm::atan(x);}
    inline Double atan2(Double x, Double y) {return streflop_libm::__ieee754_atan2(x,y);}

    inline Double cosh(Double x) {return streflop_libm::__ieee754_cosh(x);}
    inline Double sinh(Double x) {return streflop_libm::__ieee754_sinh(x);}
    inline Double tanh(Double x) {return streflop_libm::__tanh(x);}
    inline Double acosh(Double x) {return streflop_libm::__ieee754_acosh(x);}
    inline Double asinh(Double x) {return streflop_libm::__asinh(x);}
    inline Double atanh(Double x) {return streflop_libm::__ieee754_atanh(x);}

    inline Double fabs(Double x) {return streflop_libm::__fabs(x);}
    inline Double floor(Double x) {return streflop_libm::__floor(x);}
    inline Double ceil(Double x) {return streflop_libm::__ceil(x);}
    inline Double trunc(Double x) {return streflop_libm::__trunc(x);}
    inline Double fmod(Double x, Double y) {return streflop_libm::__ieee754_fmod(x,y);}
    inline Double remainder(Double x, Double y) {return streflop_libm::__ieee754_remainder(x,y);}
    inline Double remquo(Double x, Double y, int *quo) {return streflop_libm::__remquo(x,y,quo);}
    inline Double rint(Double x) {return streflop_libm::__rint(x);}
    inline long int lrint(Double x) {return streflop_libm::__lrint(x);}
    inline long long int llrint(Double x) {return streflop_libm::__llrint(x);}
    inline Double round(Double x) {return streflop_libm::__round(x);}
    inline long int lround(Double x) {return streflop_libm::__lround(x);}
    inline long long int llround(Double x) {return streflop_libm::__llround(x);}
    inline Double nearbyint(Double x) {return streflop_libm::__nearbyint(x);}

    inline Double frexp(Double x, int *exp) {return streflop_libm::__frexp(x, exp);}
    inline Double ldexp(Double value, int exp) {return streflop_libm::__ldexp(value,exp);}
    inline Double logb(Double x) {return streflop_libm::__logb(x);}
    inline int ilogb(Double x) {return streflop_libm::__ilogb(x);}
    inline Double copysign(Double x) {return streflop_libm::__copysign(x);}
    inline int signbit(Double x) {return streflop_libm::__signbit(x);}
    inline Double nextafter(Double x, Double y) {return streflop_libm::__nextafter(x,y);}

    inline Double expm1(Double x) {return streflop_libm::__expm1(x);}
    inline Double log1p(Double x) {return streflop_libm::__log1p(x);}
    inline Double erf(Double x) {return streflop_libm::__erf(x);}
    inline Double j0(Double x) {return streflop_libm::__ieee754_j0(x);}
    inline Double j1(Double x) {return streflop_libm::__ieee754_j1(x);}
    inline Double jn(int n, Double x) {return streflop_libm::__ieee754_jn(n,x);}
    inline Double y0(Double x) {return streflop_libm::__ieee754_y0(x);}
    inline Double y1(Double x) {return streflop_libm::__ieee754_y1(x);}
    inline Double yn(int n, Double x) {return streflop_libm::__ieee754_yn(n,x);}
    inline Double scalbn(Double x, int n) {return streflop_libm::__scalbn(x,n);}
    inline Double scalbln(Double x, long int n) {return streflop_libm::__scalbln(x,n);}

    inline int fpclassify(Double x) {return streflop_libm::__fpclassify(x);}
    inline int isnan(Double x) {return streflop_libm::__isnanl(x);}
    inline int isinf(Double x) {return streflop_libm::__isinf(x);}