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 ];
    }
}
 
#endif /*QLIBS_NUMA*/