qffmath.h

 
#ifndef QFFMATH_H
#define QFFMATH_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
    #include <stdint.h>
    #include <stdlib.h>
    #include <stdbool.h>
 
#ifdef QLIBS_USE_STD_MATH
    #include <math.h>
    #define QLIB_ABS        fabsf
    #define QLIB_COS        cosf
    #define QLIB_POW        powf
    #define QLIB_EXP        expf
    #define QLIB_LOG        logf
    #define QLIB_SQRT       sqrtf
    #define QLIB_ISNAN      isnan
    #define QLIB_ISINF      isinf
    #define QLIB_MAX        fmaxf
    #define QLIB_MIN        fminf
    #define QLIB_NAN        NAN
    #define QLIB_MOD        fmodf
    #define QLIB_ROUND      roundf
#else
    #define QLIB_ABS        qFFMath_Abs
    #define QLIB_COS        qFFMath_Cos
    #define QLIB_POW        qFFMath_Pow
    #define QLIB_EXP        qFFMath_Exp
    #define QLIB_LOG        qFFMath_Log
    #define QLIB_SQRT       qFFMath_Sqrt
    #define QLIB_ISNAN      qFFMath_IsNaN
    #define QLIB_ISINF      qFFMath_IsInf
    #define QLIB_MAX        qFFMath_Max
    #define QLIB_MIN        qFFMath_Min
    #define QLIB_NAN        ( qFFMath_NotANumber[ 0 ] )
    #define QLIB_FMOD       qFFMath_Mod
    #define QLIB_ROUND      qFFMath_Round


    #define QFFM_E          ( 2.7182818284590452354F )
    #define QFFM_LOG2E      ( 1.4426950408889634074F )
    #define QFFM_LOG10E     ( 0.43429448190325182765F )
    #define QFFM_LN2        ( 0.69314718055994530942F )
    #define QFFM_LN10       ( 2.30258509299404568402F )
    #define QFFM_PI         ( 3.14159265358979323846F )
    #define QFFM_PI_2       ( 1.57079632679489661923F )
    #define QFFM_PI_4       ( 0.78539816339744830962F )
    #define QFFM_1_PI       ( 0.31830988618379067154F )
    #define QFFM_2_PI       ( 0.63661977236758134308F )
    #define QFFM_2_SQRTPI   ( 1.12837916709551257390F )
    #define QFFM_SQRT2      ( 1.41421356237309504880F )
    #define QFFM_SQRT1_2    ( 0.70710678118654752440F )
    #define QFFM_LN_SQRT_2PI ( 0.918938533204672669540968854562379419F )

    #define QFFM_GAMMA_E     ( 0.577215664901532860606512090082402431F )
    #define QFFM_2PI         ( 6.283185307179586231995926937088370323F )
    #define QFFM_LN_PI       ( 1.144729885849400163877476188645232468F )

    #define QFFM_MAXFLOAT   ( 3.40282347e+38F )
    #define QFFM_INFINITY   ( qFFMath_Infinity[ 0 ] )
    #define QFFM_NAN        ( qFFMath_NotANumber[ 0 ] )

    #define QFFM_FP_ZERO        ( 0 )

    #define QFFM_FP_SUBNORMAL   ( 1 )

    #define QFFM_FP_NORMAL      ( 2 )

    #define QFFM_FP_INFINITE    ( 3 )

    #define QFFM_FP_NAN         ( 4 )

    int qFFMath_FPClassify( const float f );

    bool qFFMath_IsNaN( const float x );

    bool qFFMath_IsInf( const float x );

    bool qFFMath_IsFinite( const float x );

    bool qFFMath_IsNormal( const float x );

    bool qFFMath_IsEqual( const float a,
                          const float b );
 
    bool qFFMath_IsAlmostEqual( const float a,
                                const float b,
                                const float tol );

    float qFFMath_Abs( float x );

    float qFFMath_Recip( float x );

    float qFFMath_Sqrt( float x );

    float qFFMath_RSqrt( float x );

    float qFFMath_Cbrt( float x );

    float qFFMath_RCbrt( float x );

    float qFFMath_Round( float x );

    float qFFMath_Floor( float x );

    float qFFMath_Ceil( float x );

    float qFFMath_Trunc( float x );

    float qFFMath_Frac( float x );

    float qFFMath_Remainder( float x,
                             float y );

    float qFFMath_Mod( float x,
                       float y );

    float qFFMath_Sin( float x );

    float qFFMath_Cos( float x );

    float qFFMath_Tan( float x );

    float qFFMath_ASin( float x );

    float qFFMath_ACos( float x );

    float qFFMath_ATan( float x );

    float qFFMath_ATan2( float y,
                         float x );

    float qFFMath_Exp2( float x );

    float qFFMath_Log2( float x );

    float qFFMath_Exp( float x );

    float qFFMath_Exp10( float x );

    float qFFMath_Log( float x );

    float qFFMath_Log10( float x );

    float qFFMath_Pow( float b,
                       float e );

    float qFFMath_Sinh( float x );

    float qFFMath_Cosh( float x );

    float qFFMath_Tanh( float x );

    float qFFMath_ASinh( float x );

    float qFFMath_ACosh( float x );

    float qFFMath_ATanh( float x );

    float qFFMath_WrapToPi( float x );

    float qFFMath_WrapTo2Pi( float x );

    float qFFMath_WrapTo180( float x );

    float qFFMath_WrapTo360( float x );

    float qFFMath_Erf( float x );

    float qFFMath_Erfc( float x );

    float qFFMath_Max( float x,
                       float y );

    float qFFMath_Min( float x,
                       float y );

    float qFFMath_RExp( float x,
                        int32_t *pw2 );

    float qFFMath_LDExp( float x,
                         int32_t pw2 );

    float qFFMath_Hypot( float x,
                         float y );

    float qFFMath_NextAfter( float x,
                             float y );

    float qFFMath_Midpoint( float a,
                            float b );

    float qFFMath_Lerp( float a,
                        float b,
                        float t );

    float qFFMath_Normalize( const float x,
                             const float xMin,
                             const float xMax );

    float qFFMath_Map( const float x,
                       const float xMin,
                       const float xMax,
                       const float yMin,
                       const float yMax );

    bool qFFMath_InRangeCoerce( float * const x,
                                const float lowerL,
                                const float upperL );

    bool qFFMath_InPolygon( const float x,
                            const float y,
                            const float * const px,
                            const float * const py,
                            const size_t p );

    bool qFFMath_InCircle( const float x,
                           const float y,
                           const float cx,
                           const float cy,
                           const float r );

    float qFFMath_TGamma( float x );

    float qFFMath_LGamma( float x );

    float qFFMath_Factorial( float x );

    float qFFMath_Assoc_laguerre( size_t n,
                                size_t m,
                                float x );

    float qFFMath_Assoc_legendre( size_t n,
                                size_t m,
                                float x );

    float qFFMath_Beta( float x,
                        float y );

    float qFFMath_Comp_ellint_1( float k );

    float qFFMath_Comp_ellint_2( float k );

    float qFFMath_Comp_ellint_3( float k,
                                float nu );

    float qFFMath_Ellint_1( float k,
                            float phi );

    float qFFMath_Ellint_2( float k,
                            float phi );

    float qFFMath_Ellint_3( float k,
                            float nu,
                            float phi );

    float qFFMath_Expint( float num );

    float qFFMath_Hermite( size_t n,
                           float x );

    float qFFMath_Laguerre( size_t n,
                            float x );

    float qFFMath_Legendre( size_t n,
                            float x );

    float qFFMath_Riemann_zeta( float s );

    float qFFMath_Sph_bessel( size_t n,
                              float x );

    float qFFMath_Sph_neumann( size_t n,
                               float x );

    float qFFMath_Cyl_bessel_i( float nu,
                            float x );

    float qFFMath_Cyl_bessel_j( float nu,
                                float x );

    float qFFMath_Cyl_bessel_k( float nu,
                                float x );

    float qFFMath_Cyl_neumann( float nu,
                               float x );

    float qFFMath_Sph_legendre( size_t l,
                                size_t m,
                                float theta );

    extern const float * const qFFMath_Infinity;
    extern const float * const qFFMath_NotANumber;
 
#endif /*#ifdef QLIBS_USE_STD_MATH*/

 
#ifdef __cplusplus
}
#endif
 
#endif