TSAFunctors2.h

/*  ================================================================================
*
*   Copyright (c) 2014, Fredrik Backheimer
*   All rights reserved.
*
*   Redistribution and use in source and binary forms, with or without
*   modification, are permitted provided that the following conditions are met:
*
*   1. Redistributions of source code must retain the above copyright notice, this
*      list of conditions and the following disclaimer.
*   2. Redistributions in binary form must reproduce the above copyright notice,
*      this list of conditions and the following disclaimer in the documentation
*      and/or other materials provided with the distribution.
*
*   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
*   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
*   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
*   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
*   ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
*   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
*   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
*   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
*   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
*   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*   The views and conclusions contained in the software and documentation are those
*   of the authors and should not be interpreted as representing official policies,
*   either expressed or implied, of the FreeBSD Project.
*
*  =================================================================================
*/

#ifndef TSA_FUNCTORS2__INCLUDED
#define TSA_FUNCTORS2__INCLUDED

#include "TSAFunctors.h"

#include <vector>
#include <memory>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <cfloat>

namespace tsa {
    namespace functor {

        class KalmanMA : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;

            bool m_first_avg_completed;
            double m_gain;
            double m_sq_gain;
            double m_vel;
            double m_dif;
            double m_avg;
            double m_kalman;
          public:
            KalmanMA(void);
            parent<double>& operator()(series<double>& _ser, size_t _period);
            double value() { return parent::value(0); }
        };

        typedef KalmanMA average_kalman2;


        class Momentum : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            double m_mom;
          public:
            Momentum(void);
            parent<double>& operator()(series<double>& _ser, size_t _period);
            double value() { return parent::value(0); }
        };

        typedef Momentum MOM;


        class ROC : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            double m_roc;
          public:
            ROC(void);
            parent<double>& operator()(series<double>& _ser, size_t _period);
            double value() { return m_roc; }
        };

        typedef ROC rate_of_change;



        class ROCP : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            double m_rocp;
          public:
            ROCP(void);
            parent<double>& operator()(series<double>& _ser, size_t _period);
            double value() { return m_rocp; }
        };

        typedef ROCP rate_of_change_percent;


        class ROCR : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            double m_rocr;
          public:
            ROCR(void);
            parent<double>& operator()(series<double>& _ser, size_t _period);
            double value() { return m_rocr; }
        };

        typedef ROCR rate_of_change_ratio;


        class XMA : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            double m_factor;
            double m_sum1;
            double m_sum2;
            double m_xma;
          public:
            XMA(void);
            parent<double>& operator()(series<double>& _ser, size_t _period);
            double value() { return m_xma; }
        };

        typedef XMA xaverage;


        class WilderMA : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_xma;
            double m_factor;
            double m_efactor;
            double m_xma;
            double m_avg;
          public:
            WilderMA(void);
            parent<double>& operator()(series<double>& _ser, size_t _period);
            double value() { return m_avg; }
        };


        //class bollinger_bandwidth : public functor::parent<double> {
        //    functor::bollinger_bands BB;
        //    bool m_init = false;
        //    size_t m_period;
        //    double m_bw;
        //  public:
        //    /// @brief
        //    bollinger_bandwidth(void);
        //    /// @brief .
        //    parent<double>&  operator()(
        //        series<double>& hi,  ///< series of highs
        //        series<double>& lo,  ///< series of lows
        //        series<double>& cl,  ///< series of closes
        //        size_t _period,             ///< Center line (average) period
        //        double _stdev_mult = 2.0
        //    );
        //    //double value() { return m_bbb; }
        //};

        //typedef bollinger_bandwidth BollBW;


        class DynMI : public functor::parent<double> {
            bool m_init = false;
            size_t m_std_period;
            size_t m_ma_period;
            size_t m_dmi_period;
            functor::stdev f_stdev;
            functor::SMA f_sma;
            functor::WilderMA f_wma0;
            functor::WilderMA f_wma1;
            series<double> s_stdev;
            series<double> s_avg_stdev;
            series<double> s_mom;
            series<double> s_mom_abs;
            double m_stdev;
            double m_avg_stdev;
            double m_vi;
            int m_td;
            double m_mom;
            double m_mom_abs;
            double m_rs0;
            double m_rs1;
            double m_rs;
            double m_dmi;
          public:
            DynMI(void);
            parent<double>& operator()(series<double>& _ser, size_t _std_period, size_t _ma_period,
                                       size_t _dmi_period);
            double value() { return m_dmi; }
        };

        typedef DynMI dynamic_momentum_index;


        class CMO : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            functor::sum f_sumup;
            functor::sum f_sumdn;
            double m_upday;
            double m_dnday;
            series<double> s_upday;
            series<double> s_dnday;
            double m_sumup;
            double m_sumdn;
            double m_cmo;
          public:
            CMO(void);
            parent<double>& operator()(series<double>& _ser, size_t _period);
            double value() { return m_cmo; }
        };

        typedef CMO chande_momentum_oscillator;


        class QStick : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            functor::SMA f_sma;
            double m_codiff;
            series<double> s_codiff;
            double m_cqs;
          public:
            QStick(void);
            parent<double>& operator()(series<double>& _op, series<double>& _cl, size_t _period);
            double value() { return m_cqs; }
        };

        typedef QStick chande_qstick;


        class RAVI : public functor::parent<double> {
            bool m_init = false;
            size_t m_lperiod;
            size_t m_speriod;
            functor::SMA f_lsma;
            functor::SMA f_ssma;
            double m_shortma;
            double m_longma;
            double m_ravi;
          public:
            RAVI(void);
            parent<double>& operator()(series<double>& _ser, size_t _short_period, size_t _long_period);
            double value() { return m_ravi; }
        };

        typedef RAVI range_action_verification_index;


        class TrendScore : public functor::parent<double> {
            bool m_init = false;
            double m_tscore;
          public:
            TrendScore(void);
            parent<double>& operator()(series<double>& _ser);
            double value() { return m_tscore; }
        };


        class VIDYA : public functor::parent<double> {
            bool m_init = false;
            size_t m_cmoperiod;
            size_t m_maperiod;
            functor::CMO f_cmo;
            double m_cmo;
            double m_vidya;
          public:
            VIDYA(void);
            parent<double>& operator()(series<double>& _ser, size_t _cmo_period, size_t _ma_period);
            double value() { return m_vidya; }
        };


        class ChaosAcc : public functor::parent<double> {
            bool m_init = false;
            size_t m_lperiod;
            size_t m_speriod;
            series<double> s_lsma;
            series<double> s_ssma;
            series<double> s_madiff;
            functor::SMA f_lsma;
            functor::SMA f_ssma;
            functor::SMA f_madiff;
            double m_shortma;
            double m_longma;
            double m_madiff;
            double m_diff;
            double m_cacc;
          public:
            ChaosAcc(void);
            parent<double>& operator()(series<double>& _ser, size_t _short_period, size_t _long_period);
            double value() { return m_cacc; }
        };

        typedef ChaosAcc chaos_accelerator;


        class ChaosAO : public functor::parent<double> {
            bool m_init = false;
            size_t m_lperiod;
            size_t m_speriod;
            functor::SMA f_lsma;
            functor::SMA f_ssma;
            double m_shortma;
            double m_longma;
            double m_cao;
          public:
            ChaosAO(void);
            parent<double>& operator()(series<double>& _ser, size_t _short_period, size_t _long_period);
            double value() { return m_cao; }
        };

        typedef ChaosAO chaos_awesome_oscillator;


        class ChopIndex : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_tr;
            functor::sum f_sumtr;
            functor::max f_max;
            functor::min f_min;
            double m_tr;
            double m_sumtr;
            double m_min;
            double m_max;
            double m_chop;
          public:
            ChopIndex(void);
            parent<double>& operator()(series<double>&  high, series<double>&  low,
                                       series<double>& close, size_t period);
            double value() { return m_chop; }
        };

        typedef ChopIndex choppiness_index;


        class DeMarker : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_sumhi;
            series<double> s_sumlo;
            functor::sum f_sumhi;
            functor::sum f_sumlo;
            double m_himom;
            double m_lomom;
            double m_sumhi;
            double m_sumlo;
            double m_demark;
          public:
            DeMarker(void);
            parent<double>& operator()(series<double>&  _high, series<double>&  _low,
                                       size_t _period);
            double value() { return m_demark; }
        };


        class REI : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_sumtd6;
            series<double> s_sumtd7;
            functor::sum f_sumtd6;
            functor::sum f_sumtd7;
            double m_himom;
            double m_lomom;
            double m_td6;
            double m_td7;
            double m_sumtd6;
            double m_sumtd7;
            double m_rei;
          public:
            REI(void);
            parent<double>& operator()(series<double>&  high, series<double>&  low,
                                       series<double>&  close, size_t period);
            double value() { return m_rei; }
        };

        typedef REI range_expansion_index;


        class DPO : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_sma;
            functor::SMA f_sma;
            double m_sma;
            double m_dpo;
          public:
            DPO(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_dpo; }
        };

        typedef DPO detrended_price_oscillator;


        class DispIndex : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            functor::XMA f_xma;
            double m_xma;
            double m_dispi;
          public:
            DispIndex(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_dispi; }
        };

        typedef DispIndex disparity_index;


        class DEMA : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_xma;
            functor::XMA f_xma1;
            functor::XMA f_xma2;
            double m_xma1;
            double m_xma2;
            double m_dema;
          public:
            DEMA(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_dema; }
        };

        typedef DEMA average_double_exp;


        class DStoch : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            size_t m_ma_period;
            series<double> s_stoch;
            series<double> s_stochs;
            series<double> s_stochds;
            functor::min f_mins;
            functor::max f_maxs;
            functor::min f_minds;
            functor::max f_maxds;
            functor::SMA f_smas;
            functor::SMA f_smads;
            double m_stoch;
            double m_stochs;
            double m_stochd;
            double m_stochds;
            double m_dstoch;
          public:
            DStoch(void);
            parent<double>& operator()(series<double>&  _high, series<double>&  _low,
                                       series<double>&  _close,
                                       size_t _period, size_t _ma_period);
            double value() { return m_dstoch; }
        };

        typedef DStoch double_stochastic;


        class Fisher : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            functor::min f_min;
            functor::max f_max;
            double m_val1;
            double m_val2;
            double m_fish;
          public:
            Fisher(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_fish; }
        };

        typedef Fisher fisher_transform;


        class LRSI : public functor::parent<double> {
            bool m_init = false;
            series<double> s_l0;
            series<double> s_l1;
            series<double> s_l2;
            double m_df;
            double m_l0;
            double m_l1;
            double m_l2;
            double m_l3;
            double m_cu;
            double m_cd;
            double m_lrsi;
          public:
            LRSI(void);
            parent<double>& operator()(series<double>&  _ser, double _damping);
            double value() { return m_lrsi; }
        };

        typedef LRSI laguerre_rsi;


        class RVI : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_v1;
            series<double> s_v2;
            functor::sum f_sumv1;
            functor::sum f_sumv2;
            double m_v1;
            double m_v2;
            double m_sumv1;
            double m_sumv2;
            double m_rvi;
          public:
            RVI(void);
            parent<double>& operator()(series<double>&  open, series<double>&  high,
                                       series<double>&  low, series<double>&  close, size_t period);
            double value() { return m_rvi; }
        };

        typedef RVI relative_vigor_index;


        class Elliot : public functor::parent<double> {
            bool m_init = false;
            size_t m_long_period;
            size_t m_short_period;
            functor::SMA f_longsma;
            functor::SMA f_shortsma;
            double m_longsma;
            double m_shortsma;
            double m_ell;
          public:
            Elliot(void);
            parent<double>& operator()(series<double>&  ser, size_t short_period, size_t long_period);
            double value() { return m_ell; }
        };

        typedef Elliot elliot_oscillator;


        class WMA : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_per;
            functor::sum f_sump;
            functor::sum f_sumsp;
            int m_per;
            double m_sump;
            double m_sumsp;
            double m_wma;
          public:
            WMA(void);
            parent<double>& operator()(series<double>&  ser, size_t period);
            double value() { return m_wma; }
        };

        typedef WMA average_weighted;


        class HullMA : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            size_t m_half_period;
            size_t m_sqrt_period;
            series<double> s_wmadiff;
            functor::WMA f_wma1;
            functor::WMA f_wma2;
            functor::WMA f_wma3;
            double m_wma1;
            double m_wma2;
            double m_wmadiff;
            double m_hma;
          public:
            HullMA(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_hma; }
        };

        typedef HullMA average_hull;


        class Inertia : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            functor::stdev f_stdevh;
            functor::stdev f_stdevl;
            functor::XMA f_xma1;
            functor::XMA f_xma2;
            functor::XMA f_xma3;
            functor::XMA f_xma4;
            functor::SMA f_sma;
            series<double> s_val1;
            series<double> s_val2;
            series<double> s_val3;
            series<double> s_val4;
            series<double> s_val5;
            double m_stdevh;
            double m_stdevl;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_val5;
            double m_xma1;
            double m_xma2;
            double m_xma3;
            double m_xma4;
            double m_inrt;
          public:
            Inertia(void);
            parent<double>& operator()(series<double>&  _high, series<double>&  _low,
                                       size_t _period);
            double value() { return m_inrt; }
        };

        typedef Inertia inertia_oscillator;


        class KAMA : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            size_t m_fast_const;
            size_t m_slow_const;
            series<double> s_vol;
            functor::sum f_sum;
            double m_dir;
            double m_vol;
            double m_er;
            double m_fastsc;
            double m_slowsc;
            double m_ssc;
            double m_const;
            double m_kama;
          public:
            KAMA(void);
            parent<double>& operator()(series<double>&  ser, size_t period, size_t fast_const,
                                       size_t slow_const);
            double value() { return m_kama; }
        };

        typedef KAMA average_kaufman;


        class EffRatio : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_vol;
            functor::sum f_sum;
            double m_dir;
            double m_vol;
            double m_eratio;
          public:
            EffRatio(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_eratio; }
        };

        typedef EffRatio efficiency_ratio;


        class LinReg : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_vol;
            functor::sum f_sum;
            double m_dir;
            double m_vol;
            double m_linreg;
          public:
            LinReg(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_linreg; }
        };

        typedef LinReg linear_regression;


        class LinRegSlope : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_vol;
            functor::sum f_sum;
            double m_dir;
            double m_vol;
            double m_lrslope;
          public:
            LinRegSlope(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_lrslope; }
        };

        typedef LinRegSlope linear_regression_slope;


        class MDMA : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            double m_mdma;
          public:
            MDMA(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_mdma; }
        };

        typedef MDMA average_mcginley;


        class PPO : public functor::parent<double> {
            bool m_init = false;
            size_t m_fast_period;
            size_t m_slow_period;
            functor::XMA f_xmas;
            functor::XMA f_xmaf;
            double m_fastma;
            double m_slowma;
            double m_ppo;
          public:
            PPO(void);
            parent<double>& operator()(series<double>&  _ser, size_t _fast_period, size_t _slow_period);
            double value() { return m_ppo; }
        };

        typedef PPO percentage_price_oscillator;


        class PFE : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            size_t m_ma_period;
            series<double> s_pf;
            series<double> s_sqrt1;
            functor::XMA f_xma;
            functor::sum f_sum;
            double m_sqrt1;
            double m_pf;
            double m_pfe;
          public:
            PFE(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period, size_t _ma_period);
            double value() { return m_pfe; }
        };

        typedef PFE polarized_fractal_efficiency;


        class RMTA : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_bot;
            double m_alpha;
            double m_bot;
            double m_rmta;
          public:
            RMTA(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_rmta; }
        };

        typedef RMTA average_recursive_moving_trend;


        class TOSC : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            series<double> s_bot;
            functor::XMA f_xma;
            functor::RMTA f_rmta;
            double m_diff;
            double m_bot;
            double m_tosc;
          public:
            TOSC(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_tosc; }
        };

        typedef TOSC trend_oscillator;


        class RMI : public functor::parent<double> {
            bool m_init = false;
            size_t m_ma_period;
            size_t m_mom_period;
            series<double> s_mom;
            series<double> s_amom;
            functor::WilderMA f_wma1;
            functor::WilderMA f_wma2;
            double m_mom;
            double m_amom;
            double m_rms;
            double m_rmi;
          public:
            RMI(void);
            parent<double>& operator()(series<double>&  _ser, size_t _ma_period, size_t _mom_period);
            double value() { return m_rmi; }
        };

        typedef RMI relative_momentum_index;


        class RVX : public functor::parent<double> {
            bool m_init = false;
            size_t m_ma_period;
            size_t m_sd_period;
            series<double> s_rs;
            series<double> s_ars;
            functor::WilderMA f_wma1;
            functor::WilderMA f_wma2;
            functor::stdev f_stdev1;
            functor::stdev f_stdev2;
            double m_sd;
            double m_rs;
            double m_ars;
            double m_rms;
            double m_rvx;
          public:
            RVX(void);
            parent<double>& operator()(series<double>&  _ser, size_t _sd_period, size_t _ma_period);
            double value() { return m_rvx; }
        };

        typedef RVX relative_volatility_index;


        class R2 : public functor::parent<double> {
            bool m_init = false;
            size_t m_period;
            double m_r2;
          public:
            R2(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period);
            double value() { return m_r2; }
        };

        typedef R2 r_squared;


        class STC : public functor::parent<double> {
            bool m_init = false;
            size_t m_longma_period;
            size_t m_shortma_period;
            size_t m_cycle_period;
            series<double> s_mcd;
            series<double> s_st;
            functor::WilderMA f_wma1;
            functor::WilderMA f_wma2;
            functor::WilderMA f_wma3;
            functor::min f_min;
            functor::max f_max;
            double m_mcd;
            double m_st;
            double m_stc;
          public:
            STC(void);
            parent<double>& operator()(series<double>&  _ser, size_t _shortma_period,
                                       size_t _longma_period,
                                       size_t _cycle_period);
            double value() { return m_stc; }
        };

        typedef STC schaff_trend_cycle;


        class SMI : public functor::parent<double> {
            bool m_init = false;
            size_t m_ma_period;
            size_t m_dma_period;
            size_t m_period;
            series<double> s_val1;
            series<double> s_val2;
            series<double> s_val3;
            series<double> s_val4;
            functor::XMA f_xma1;
            functor::XMA f_xma2;
            functor::XMA f_xma3;
            functor::XMA f_xma4;
            functor::min f_min;
            functor::max f_max;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_val5;
            double m_val6;
            double m_smi;
          public:
            SMI(void);
            parent<double>& operator()(series<double>&  _hi, series<double>&  _lo,
                                       series<double>&  _cl,
                                       size_t _period = 13, size_t _ma_period = 25, size_t _dma_period = 2);
            double value() { return m_smi; }
        };

        typedef SMI stochastic_momemtum_index;


        class StochRSI : public functor::parent<double> {
            bool m_init = false;
            size_t m_rsi_period;
            size_t m_period;
            series<double> s_val1;
            functor::RSI f_rsi;
            functor::min f_min;
            functor::max f_max;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_srsi;
          public:
            StochRSI(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period = 14,
                                       size_t _rsi_period = 14);
            double value() { return m_srsi; }
        };

        typedef StochRSI stochastic_rsi;


        class T3MA : public functor::parent<double> {
            bool m_init = false;
            double m_factor;
            size_t m_period;
            series<double> s_val1;
            series<double> s_val2;
            series<double> s_val3;
            series<double> s_val4;
            series<double> s_val5;
            series<double> s_val6;
            functor::XMA f_xma1;
            functor::XMA f_xma2;
            functor::XMA f_xma3;
            functor::XMA f_xma4;
            functor::XMA f_xma5;
            functor::XMA f_xma6;
            double m_c1;
            double m_c2;
            double m_c3;
            double m_c4;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_val5;
            double m_val6;
            double m_t3;
          public:
            T3MA(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period = 8, double _factor = 0.7);
            double value() { return m_t3; }
        };

        typedef T3MA average_t3;


        class KeltnerChannel : public functor::parent<double> {

            bool m_init = false;
            size_t m_period;
            series<double> s_val1;
            series<double> s_val2;
            series<double> s_val3;
            functor::SMA f_sma1;
            functor::SMA f_sma2;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_kcm;
            double m_kcu;
            double m_kcl;
          public:
            KeltnerChannel(void);
            parent<double>& operator()(series<double>&  _hi, series<double>&  _lo,
                                       series<double>&  _cl,
                                       size_t _period = 10);
            double MidChannel()const { return parent::value(0); }
            double UpChannel(void)const { return parent::value(1); }
            double LoChannel()const { return parent::value(2); }
        };

        typedef KeltnerChannel keltner_channel;


        class KeltnerBands : public functor::parent<double> {

            bool m_init = false;
            size_t m_period;
            double m_mult;
            series<double> s_val1;
            series<double> s_val2;
            series<double> s_val3;
            functor::XMA f_xma1;
            functor::SMA f_sma2;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_kbm;
            double m_kbu;
            double m_kbl;
          public:
            KeltnerBands(void);
            parent<double>& operator()(series<double>&  _hi, series<double>&  _lo,
                                       series<double>&  _cl,
                                       size_t _period = 10, double _multiplier = 2.0);
            double MidChannel()const { return parent::value(0); }
            double UpChannel(void)const { return parent::value(1); }
            double LoChannel()const { return parent::value(2); }
        };

        typedef KeltnerBands keltner_bands;



        class TCF : public functor::parent<double> {

            bool m_init = false;
            double m_factor;
            size_t m_period;
            series<double> s_val2;
            series<double> s_val3;
            series<double> s_val4;
            series<double> s_val5;
            functor::sum f_sum1;
            functor::sum f_sum2;
            functor::sum f_sum3;
            functor::sum f_sum4;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_val5;
            double m_val6;
            double m_val7;
            double m_val8;
            double m_val9;
            double m_ptcf;
            double m_mtcf;
          public:
            TCF(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period = 10);
            double Positive()const { return parent::value(0); }
            double Negative(void)const { return parent::value(1); }
        };

        typedef TCF trend_continuation_factor;


        class TTI : public functor::parent<double> {

            bool m_init = false;
            double m_factor;
            size_t m_period;
            series<double> s_val2;
            series<double> s_val3;
            series<double> s_val4;
            series<double> s_val5;
            functor::SMA f_sma1;
            functor::sum f_sum2;
            functor::sum f_sum3;
            functor::sum f_sum4;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_val5;
            double m_val6;
            double m_tti;
          public:
            TTI(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period = 30);
            double value() { return m_tti; }
        };

        typedef TTI trend_intensity_index;


        class TTF : public functor::parent<double> {

            bool m_init = false;
            double m_factor;
            size_t m_period;
            series<double> s_val1;
            series<double> s_val2;
            series<double> s_val3;
            series<double> s_val4;
            series<double> s_val5;
            functor::SMA f_sma1;
            functor::max f_max;
            functor::min f_min;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_val5;
            double m_val6;
            double m_ttf;
          public:
            TTF(void);
            parent<double>& operator()(series<double>&  _hi, series<double>&  _lo,
                                       size_t _period = 15);
            double value() { return m_ttf; }
        };

        typedef TTF trend_trigger_factor;


        class TEMA : public functor::parent<double> {

            bool m_init = false;
            double m_factor;
            size_t m_period;
            series<double> s_val1;
            series<double> s_val2;
            series<double> s_val3;
            series<double> s_val4;
            series<double> s_val5;
            functor::XMA f_xma1;
            functor::XMA f_xma2;
            functor::XMA f_xma3;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_val5;
            double m_val6;
            double m_tema;
          public:
            TEMA(void);
            parent<double>& operator()(series<double>&  _ser, size_t _period = 15);
            double value() { return m_tema; }
        };

        typedef TEMA average_texp;


        class VQI : public functor::parent<double> {
            bool m_init = false;
            size_t m_shortma_period;
            size_t m_longma_period;
            series<double> s_val1;
            series<double> s_val2;
            series<double> s_val3;
            series<double> s_val4;
            functor::SMA f_sma1;
            functor::SMA f_sma2;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_vqi;
            double m_svqi;
            double m_lvqi;
          public:
            VQI(void);
            parent<double>& operator()(series<double>&  _op, series<double>&  _hi,
                                       series<double>&  _lo,
                                       series<double>&  _cl, size_t _shortma_period = 9, size_t _longma_period = 200);
            double VQIndex()const { return parent::value(0); }
            double LongVQI(void)const { return parent::value(1); }
            double ShortVQI(void)const { return parent::value(2); }
        };

        typedef VQI volatility_quality_index;


        class TrailStop : public functor::parent<double> {

            bool m_init = false;
            double m_factor;
            size_t m_period;
            size_t m_atr_period;
            double m_mult;
            series<double> s_val1;
            series<double> s_val2;
            series<double> s_val3;
            series<double> s_val4;
            series<double> s_val5;
            series<double> s_val6;
            functor::SMA f_sma1;
            functor::max f_max1;
            functor::max f_max2;
            functor::min f_min1;
            functor::min f_min2;
            double m_val1;
            double m_val2;
            double m_val3;
            double m_val4;
            double m_val5;
            double m_val6;
            double m_longTS;
            double m_shortTS;
          public:
            TrailStop(void);
            parent<double>& operator()(series<double>&  _hi, series<double>&  _lo,
                                       series<double>&  _cl, size_t _period = 10, size_t _atr_period = 20,
                                       double _atr_multiplier = 2.0);
            double LongTrailStop()const { return parent::value(0); }
            double ShortTrailStop(void)const { return parent::value(1); }
        };

        typedef TrailStop trailing_stop;

    }
}

#endif