smoother.hpp

 
#ifndef QLIBS_SMOOTHER
#define QLIBS_SMOOTHER
 
#include <include/qlibs_types.hpp>
#include <include/tdl.hpp>

namespace qlibs {

    class smoother {
        protected:
            bool init{ true };
            bool isSetup{ false };
            static void windowSet( real_t *w,
                                   const size_t wsize,
                                   const real_t x );
        public:
            virtual ~smoother() {}

            bool isInitialized( void ) const
            {
                return isSetup;
            }

            explicit operator bool() const noexcept
            {
                return isInitialized();
            }

            virtual real_t smooth( const real_t x ) = 0;

            inline bool reset( void )
            {
                init = true;
                return true;
            }
    };

    class smootherLPF1 : public smoother {
        protected:
            real_t alpha{ 0.9_re };
            real_t y1{ 0.0_re };
        public:
            virtual ~smootherLPF1() {}

            bool setup( const real_t a = 0.9_re );

            real_t smooth( const real_t x ) override;
    };

    class smootherLPF2 : public smoother {
        protected:
            real_t y1{ 0.0_re };
            real_t y2{ 0.0_re };
            real_t x1{ 0.0_re };
            real_t x2{ 0.0_re };
            real_t k{ 0.0_re };
            real_t a1{ 0.0_re };
            real_t a2{ 0.0_re };
            real_t b1{ 0.0_re };
        public:
            virtual ~smootherLPF2() {}

            bool setup( const real_t a = 0.9_re );

            real_t smooth( const real_t x ) override;
    };

    class smootherMWM1 : public smoother, private nonCopyable {
        protected:
            real_t *w{ nullptr };
            size_t wsize{ 0U };
        public:
            virtual ~smootherMWM1() {}

            bool setup( real_t *window,
                        const size_t w_size );

            template <size_t windowSize>
            bool setup( real_t (&window)[ windowSize ] )
            {
                return setup( window, windowSize );
            }

            real_t smooth( const real_t x ) override;
    };

    class smootherMWM2 : public smoother, public tdl {
        protected:
            real_t sum{ 0.0_re };
        public:
            virtual ~smootherMWM2() {}

            bool setup( real_t *window,
                        const size_t w_size );

            template <size_t windowSize>
            bool setup( real_t (&window)[ windowSize ] )
            {
                return setup( window, windowSize );
            }

            real_t smooth( const real_t x ) override;
    };

    class smootherMOR1 : public smoother, private nonCopyable {
        protected:
            real_t *w{ nullptr };
            real_t m{ 0.0_re };
            real_t alpha{ 0.8_re };
            size_t wsize{ 0U };
        public:
            virtual ~smootherMOR1() {}

            bool setup( real_t *window,
                        const size_t w_size,
                        const real_t a = 0.9_re );

            template <size_t windowSize>
            bool setup( real_t (&window)[ windowSize ],
                        const real_t a = 0.9_re )
            {
                return setup( window, windowSize, a );
            }

            real_t smooth( const real_t x ) override;
    };

    class smootherMOR2 : public smoother, public tdl {
        protected:
            real_t sum{ 0.0_re };
            real_t m{ 0.0_re };
            real_t alpha{ 0.8_re };
        public:
            virtual ~smootherMOR2() {}

            bool setup( real_t *window,
                        const size_t w_size,
                        const real_t a = 0.9_re );

            template <size_t windowSize>
            bool setup( real_t (&window)[ windowSize ],
                        const real_t a = 0.9_re )
            {
                return setup( window, windowSize, a );
            }

            real_t smooth( const real_t x ) override;
    };

    class smootherGMWF : public smoother, private nonCopyable {
        protected:
            real_t *w{ nullptr };
            real_t *k{ nullptr };
            size_t wsize;
        public:
            virtual ~smootherGMWF() {}

            bool setup( const real_t sg,
                        const real_t c,
                        real_t *window,
                        real_t *kernel,
                        const size_t wk_size );

            template <size_t windowAndKernelSize>
            bool setup( const real_t sg,
                        const real_t c,
                        real_t (&window)[ windowAndKernelSize ],
                        real_t (&kernel)[ windowAndKernelSize ] )
            {
                return setup( sg, c, window, kernel, windowAndKernelSize );
            }

            real_t smooth( const real_t x ) override;
    };

    class smootherEXPW : public smoother {
        protected:
            real_t lambda{ 0.8_re };
            real_t m{ 0_re };
            real_t w{ 1.0_re };
        public:
            virtual ~smootherEXPW() {}

            bool setup( const real_t lam = 0.8_re );

            real_t smooth( const real_t x ) override;
    };

    class smootherKLMN : public smoother {
        protected:
            real_t xS{ 0.0_re };  /* state */
            real_t A{ 1.0_re };  /* x(n)=A*x(n-1)+u(n),u(n)~N(0,q) */
            real_t H{ 1.0_re };  /* z(n)=H*x(n)+w(n),w(n)~N(0,r) */
            real_t q{ 100.0_re };  /* process(predict) noise covariance */
            real_t r{ 0.9_re };  /* measure noise covariance */
            real_t p{ 100.0_re };  /* estimated error covariance */
            real_t gain;
        public:
            virtual ~smootherKLMN() {}

            bool setup( const real_t processNoiseCov,
                        const real_t measureNoiseCov,
                        const real_t estErrorCov );

            real_t smooth( const real_t x ) override;
    };

    class smootherDESF : public smoother {
        protected:
            real_t alpha;
            real_t beta;
            real_t lt;
            real_t bt;
            real_t n;
        public:
            virtual ~smootherDESF() {}

            bool setup( const real_t a,
                        const real_t b,
                        const size_t nS );

            real_t smooth( const real_t x ) override;
    };

    class smootherALNF : public smoother, private nonCopyable {
        protected:
            real_t alpha;
            real_t mu;
            real_t *w{ nullptr };
            real_t *w_1{ nullptr };
            real_t *xx{ nullptr };
            size_t n{ 0U };
        public:
            virtual ~smootherALNF() {}

            bool setup( const real_t a,
                        const real_t m,
                        const size_t wsize,
                        real_t *window,
                        real_t *weights,
                        real_t *w1 = nullptr );

            template <size_t windowSize>
            bool setup( const real_t a,
                        const real_t m,
                        real_t (&window)[ windowSize ],
                        real_t (&weights)[ windowSize ],
                        real_t (&w1)[ windowSize ] )
            {
                return setup( a, m, windowSize, window, weights, w1 );
            }

            template <size_t windowSize>
            bool setup( const real_t a,
                        real_t (&window)[ windowSize ],
                        real_t (&weights)[ windowSize ] )
            {
                return setup( a, 0.0F, windowSize, window, weights, nullptr);
            }

            real_t smooth( const real_t x ) override;
    };

}
 
 
#endif /*QLIBS_SMOOTHER*/