numa.hpp

 
#ifndef QLIBS_NUMA
#define QLIBS_NUMA
 
#include <include/qlibs_types.hpp>

namespace qlibs {


    enum integrationMethod {
        INTEGRATION_RECTANGULAR,    
        INTEGRATION_TRAPEZOIDAL,    
        INTEGRATION_SIMPSON,        
        INTEGRATION_QUADRATIC,      
    };

    enum derivationMethod {
        DERIVATION_2POINTS,         
        DERIVATION_BACKWARD,        
        DERIVATION_FORWARD,         
    };

    class nState {
        private:
            real_t x[ 3 ] = { 0.0_re, 0.0_re, 0.0_re };
            void inline update( const real_t &s )
            {
                x[ 2 ] = x[ 1 ];
                x[ 1 ] = s;
            }
            integrationMethod iMethod{ INTEGRATION_TRAPEZOIDAL };
            derivationMethod dMethod{ DERIVATION_2POINTS };
        public:
            virtual ~nState() {}

            nState( const real_t x0 = 0.0_re,
                    const real_t sn_1 = 0.0_re,
                    const real_t sn_2 = 0.0_re ) noexcept
            {
                init( x0, sn_1, sn_2 );
            }

            void init( const real_t x0 = 0.0_re,
                       const real_t sn_1 = 0.0_re,
                       const real_t sn_2 = 0.0_re ) noexcept;

            real_t integrate( const real_t s,
                              const real_t dt,
                              const bool bUpdate = true ) noexcept;

            real_t derive( const real_t s,
                           const real_t dt,
                           const bool bUpdate = true ) noexcept;

            inline void setIntegrationMethod( integrationMethod m ) noexcept
            {
                iMethod = m;
            }

            inline void setDerivationMethod( derivationMethod m ) noexcept
            {
                dMethod = m;
            }

            real_t operator()( void ) const noexcept
            {
                return x[ 0 ];
            }

            real_t operator*( real_t rValue) const noexcept
            {
                return x[ 0 ]*rValue;
            }
            real_t operator/( real_t rValue) const noexcept
            {
                return x[ 0 ]/rValue;
            }
            real_t operator+( real_t rValue) const noexcept
            {
                return x[ 0 ] + rValue;
            }
            real_t operator-( real_t rValue) const noexcept
            {
                return x[ 0 ] - rValue;
            }
            friend real_t operator*( real_t rValue,
                                     const nState& s ) noexcept;
            friend real_t operator/( real_t rValue,
                                     const nState& s ) noexcept;
            friend real_t operator+( real_t rValue,
                                     const nState& s ) noexcept;
            friend real_t operator-( real_t rValue,
                                     const nState& s ) noexcept;
    };

    inline real_t operator*( real_t rValue,
                             const nState& s ) noexcept
    {
        return rValue*s.x[ 0 ];
    }
    inline real_t operator/( real_t rValue,
                             const nState& s ) noexcept
    {
        return rValue/s.x[ 0 ];
    }
    inline real_t operator+( real_t rValue,
                             const nState& s ) noexcept
    {
        return rValue + s.x[ 0 ];
    }
    inline real_t operator-( real_t rValue,
                             const nState& s ) noexcept
    {
        return rValue - s.x[ 0 ];
    }

    class integrator : public nState, private nonCopyable {
        private:
            real_t dt;
            real_t min{ -REAL_MAX };
            real_t max{ +REAL_MAX };
        public:
            virtual ~integrator() {}

            integrator( const real_t timeStep,
                        const real_t initialCondition = 0.0_re );

            bool setSaturation( const real_t minV, const real_t maxV ) noexcept;

            real_t operator()( const real_t xDot );
    };

    class derivative : public nState, private nonCopyable {
        private:
            real_t dt;
        public:
            virtual ~derivative() {}

            derivative( const real_t timeStep,
                        const real_t initialCondition = 0.0_re );

            real_t operator()( const real_t xt );
    };

}
 
#endif /*QLIBS_NUMA*/