ffmath.hpp

 
#ifndef QLIBS_FFMATH
#define QLIBS_FFMATH
 
#include <include/qlibs_types.hpp>
 
namespace qlibs {
 
    namespace ffmath {
 
 
        enum class classification {
            FFP_ZERO = 0,   
            FFP_SUBNORMAL,  
            FFP_NORMAL,     
            FFP_INFINITE,   
            FFP_NAN,        
        };
 
 
        bool isEqual( const float a,
                      const float b,
                      const float tol = 1.175494351e-38F ) noexcept;
 
        float getInf( void );
 
        float getNan( void );
 
        classification classify( const float f );
 
        template<typename T>
        T Max(const T& first) {
            return first;
        }
        template<typename T, typename... Args>
        T Max( const T& first, const Args&... args ) {
            const T& restMax = Max( args... );
            return ( first > restMax ) ? first : restMax;
        }
 
        template<typename T>
        T Min( const T& first ) {
            return first;
        }
        template<typename T, typename... Args>
        T Min( const T& first, const Args&... args ) {
            const T& restMin = Min( args... );
            return ( first < restMin ) ? first : restMin;
        }
 
        inline bool isNan( const float x )
        {
            return ( classification::FFP_NAN == classify( x ) );
        }
 
        inline bool isInf( const float x )
        {
            return ( classification::FFP_INFINITE == classify( x ) );
        }
 
        inline bool isFinite( const float x )
        {
            return ( classify( x ) < classification::FFP_INFINITE );
        }
 
        inline bool isNormal( const float x )
        {
            return ( classification::FFP_NORMAL == classify( x ) );
        }
 
        float copysign( float mag,
                        float sgn );
 
        float sign( float x );
 
        float absf( float x );
 
        float recip( float x );
 
        float sqrt( float x );
 
        float rSqrt( float x );
 
        float cbrt( float x );
 
        float rCbrt( float x );
 
        float rounding( float x );
 
        float floor( float x );
 
        float ceil( float x );
 
        float trunc( float x );
 
        float frac( float x );
 
        float rem( float x,
                   float y );
 
        float mod( float x,
                   float y );
 
        float sin( float x );
 
        float cos( float x );
 
        float tan( float x );
 
        float asin( float x );
 
        float acos( float x );
 
        float atan( float x );
 
        float atan2( float y,
                     float x );
 
        float exp2( float x );
 
        float log2( float x );
 
        float exp( float x );
 
        float expm1( float x );
 
        float exp10( float x );
 
        float log( float x );
 
        float log1p( float x );
 
        float log10( float x );
 
        float pow( float b,
                   float e );
 
        float sinh( float x );
 
        float cosh( float x );
 
        float tanh( float x );
 
        float asinh( float x );
 
        float acosh( float x );
 
        float atanh( float x );
 
        float wrapToPi( float x );
 
        float wrapTo2Pi( float x );
 
        float wrapTo180( float x );
 
        float wrapTo360( float x );
 
        float midpoint( float a,
                        float b );
 
        float lerp( float a,
                    float b,
                    float t );
 
        float map( const float x,
                   const float xMin,
                   const float xMax,
                   const float yMin,
                   const float yMax ) noexcept;
        real_t normalize( const float x,
                          const float xMin,
                          const float xMax ) noexcept;
        bool inRangeCoerce( float &x,
                            const float lowerL,
                            const float upperL ) noexcept;
 
        bool inPolygon( const float x,
                        const float y,
                        const float * const px,
                        const float * const py,
                        const size_t p ) noexcept;
 
        bool inCircle( const float x,
                       const float y,
                       const float cx,
                       const float cy,
                       const float r ) noexcept;
 
        float erf( float x );
 
        float erfc( float x );
 
        float rexp( float x,
                    int32_t *pw2 );
 
        float ldexp( float x,
                     int32_t pw2 );
 
        float hypot( float x,
                     float y );
 
        float nextAfter( float x,
                         float y );
 
        float tgamma( float x );
 
        float lgamma( float x );
 
        float factorial( float x );
 
        float assoc_laguerre( size_t n,
                              size_t m,
                              float x );
 
        float assoc_legendre( size_t n,
                              size_t m,
                              float x );
 
        float beta( float x,
                    float y );
 
        float comp_ellint_1( float k );
 
        float comp_ellint_2( float k );
 
        float comp_ellint_3( float k,
                             float nu );
 
        float ellint_1( float k,
                        float phi );
 
        float ellint_2( float k,
                        float phi );
 
        float ellint_3( float k,
                        float nu,
                        float phi );
 
        float expint( float num );
 
        float hermite( size_t n,
                       float x );
 
        float laguerre( size_t n,
                        float x );
 
        float legendre( size_t n,
                        float x );
 
        float riemann_zeta( float s );
 
        float sph_bessel( size_t n,
                          float x );
 
        float sph_neumann( size_t n,
                           float x );
 
        float cyl_bessel_i( float nu,
                            float x );
 
        float cyl_bessel_j( float nu,
                            float x );
 
        float cyl_bessel_k( float nu,
                            float x );
 
        float cyl_neumann( float nu,
                           float x );
 
        float sph_legendre( size_t l,
                            size_t m,
                            float theta );
 
        /*cstat -MISRAC++2008-0-1-4_b*/
 
        constexpr float FFP_E               = ( 2.718281828459045235360287471352662498F );
        constexpr float FFP_LOG2E           = ( 1.442695040888963407359924681001892137F );
        constexpr float FFP_LOG10E          = ( 0.434294481903251827651128918916605082F );
        constexpr float FFP_LN2             = ( 0.693147180559945309417232121458176568F );
        constexpr float FFP_LN10            = ( 2.302585092994045684017991454684364208F );
        constexpr float FFP_PI              = ( 3.141592653589793238462643383279502884F );
        constexpr float FFP_2PI             = ( 6.283185307179586231995926937088370323F );
        constexpr float FFP_PI_2            = ( 1.570796326794896557998981734272092580F );
        constexpr float FFP_PI_4            = ( 0.785398163397448278999490867136046290F );
        constexpr float FFP_1_PI            = ( 0.318309886183790671537767526745028724F );
        constexpr float FFP_2_PI            = ( 0.636619772367581382432888403855031356F );
        constexpr float FFP_1_SQRTPI        = ( 0.564189583547756286948079451560772586F );
        constexpr float FFP_2_SQRTPI        = ( 1.128379167095512558560699289955664426F );
        constexpr float FFP_SQRT2           = ( 1.414213562373095048801688724209698079F );
        constexpr float FFP_SQRT3           = ( 1.732050807568877293527446341505872367F );
        constexpr float FFP_SQRT1_2         = ( 0.707106781186547461715008466853760182F );
        constexpr float FFP_SQRT1_3         = ( 0.577350269189625764509148780501957456F );
        constexpr float FFP_LN_SQRT_2PI     = ( 0.918938533204672669540968854562379419F );
        constexpr float FFP_GAMMA_E         = ( 0.577215664901532860606512090082402431F );
        constexpr float FFP_PHI             = ( 1.618033988749894848204586834365638118F );
        constexpr float FFP_RADIAN          = ( 57.29577951308232286464772187173366546F );
        constexpr float FFP_LOG10_2         = ( 0.301029995663981198017467022509663366F );
        constexpr float FFP_LN_PI           = ( 1.144729885849400163877476188645232468F );
        /*cstat +MISRAC++2008-0-1-4_b*/
 
        struct numbers {
            static constexpr float e()              { return FFP_E; }
            static constexpr float log2e()          { return FFP_LOG2E; }
            static constexpr float log10e()         { return FFP_LOG10E; }
            static constexpr float ln2()            { return FFP_LN2; }
            static constexpr float ln10()           { return FFP_LN10; }
            static constexpr float pi()             { return FFP_PI; }
            static constexpr float inv_pi()         { return FFP_1_PI; }
            static constexpr float inv_sqrtpi()     { return FFP_1_SQRTPI; }
            static constexpr float sqrt2()          { return FFP_SQRT2; }
            static constexpr float sqrt3()          { return FFP_SQRT3; }
            static constexpr float inv_sqrt2()      { return FFP_SQRT1_2; }
            static constexpr float inv_sqrt3()      { return FFP_SQRT1_3; }
            static constexpr float egamma()         { return FFP_GAMMA_E; }
            static constexpr float phi()            { return FFP_PHI; }
            static constexpr float twice_pi()       { return FFP_2PI; }
            static constexpr float half_pi()        { return FFP_PI_2; }
            static constexpr float quarter_pi()     { return FFP_PI_4; }
            static constexpr float radian()         { return FFP_RADIAN; }
            static constexpr float lnpi()           { return FFP_LN_PI; }
            static constexpr float ln_sqrt_2pi()    { return FFP_LN_SQRT_2PI; }
        };
 
    }
}
 
 
#endif /*QLIBS_FFMATH*/