filter.h

Go to the documentation of this file.

// include guard
#ifndef TF_FILTER_H_VERSION

#define TF_FILTER_H_VERSION \
  "TF_FILTER_H   V1.9"

#include<tsxx/filterbase.h>
#include<tsxx/error.h>

namespace ts {

  namespace filter {

    class SetByIndex: public ts::filter::BasicFilter {
      public:
        SetByIndex(const int& n1, const int& n2, const double& v): 
          Mn1(n1), Mn2(n2), Mv(v) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        int Mn1, Mn2;
        double Mv;
    }; // class SetByIndex

    /*----------------------------------------------------------------------*/

    class RemoveTrend: public ts::filter::BasicFilter {
      public:
        RemoveTrend(const int& n): Mn(n) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        int Mn;
    }; // class RemoveTrend

    /*----------------------------------------------------------------------*/

    class RemoveAverage: public ts::filter::BasicFilter {
      public:
        RemoveAverage(const int& n): Mn(n) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        int Mn;
    }; // class RemoveAverage

    /*----------------------------------------------------------------------*/

    class HanningTaper: public ts::filter::BasicFilter {
      public:
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
    }; // class HanningTaper

    /*----------------------------------------------------------------------*/

    class Scale: public ts::filter::BasicFilter {
      public:
        Scale(const double& v): Mv(v) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mv;
    }; // class Scale

    /*----------------------------------------------------------------------*/

    class Add: public ts::filter::BasicFilter {
      public:
        Add(const double& v): Mv(v) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mv;
    }; // class Add

    /*----------------------------------------------------------------------*/

    class ForceToBase: public ts::filter::BasicFilter {
      public:
        ForceToBase(const int& n1, const int& n2, const int& ne): 
          Mn1(n1), Mn2(n2), Mne(ne) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        int Mn1, Mn2, Mne;
    }; // class ForceToBase

    /*----------------------------------------------------------------------*/

    class Reverse: public ts::filter::BasicFilter {
      public:
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
    }; // class Reverse

    /*----------------------------------------------------------------------*/

    class Normalize: public ts::filter::BasicFilter {
      public:
        Normalize(const double& v): Mv(v) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mv;
    }; // class Normalize

    /*----------------------------------------------------------------------*/

    class Delay: public ts::filter::BasicFilter {
      public:
        Delay(const double& v): Mv(v) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mv;
    }; // class Delay

    /*----------------------------------------------------------------------*/

    class Square: public ts::filter::BasicFilter {
      public:
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
    }; // class Square

    /*----------------------------------------------------------------------*/

    class SquareRoot: public ts::filter::BasicFilter {
      public:
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
    }; // class SquareRoot

    /*----------------------------------------------------------------------*/

    class Rectifier: public ts::filter::BasicFilter {
      public:
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
    }; // class Rectifier

    /*----------------------------------------------------------------------*/

    class CumSum: public ts::filter::BasicFilter {
      public:
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
    }; // class CumSum

    /*----------------------------------------------------------------------*/

    class Powerof: public ts::filter::BasicFilter {
      public:
        Powerof(const double& v): Mv(v) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Mv;
    }; // class Powerof

    /*----------------------------------------------------------------------*/

    class GaussianNoise: public ts::filter::BasicFilter {
      public:
        GaussianNoise(const double& a): Ma(a) { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        double Ma;
    }; // class GaussianNoise

    /*----------------------------------------------------------------------*/

    class RemoveFirst: public ts::filter::BasicFilter {
      friend class RestoreFirst;
      public:
        RemoveFirst() { RemoveFirst::Mf=0.; }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        static double Mf;
    }; // class RemoveFirst

    /*----------------------------------------------------------------------*/

    class RestoreFirst: public ts::filter::BasicFilter {
      public:
        RestoreFirst() { }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
    }; // class RestoreFirst

    /*----------------------------------------------------------------------*/

    class Pad: public ts::filter::BasicFilter {
      public:
        Pad(const int& n): Mn(static_cast<unsigned int>(n)) 
        { 
          TSXX_assert(n>=0, 
                      "number of samples to be appended must be positive");
        }
        Ttimeseries operator()(const Ttimeseries& s,
                               const bool& debug=false) const;
      private:
        unsigned int Mn;
    }; // class Pad

    /*----------------------------------------------------------------------*/

    ts::filter::Tfilterhandle make_filter(std::string s,
                                          const bool& debug=false);

    void print_help(std::ostream& os);

  } // namespace filter

} // namespace ts

#endif // TF_FILTER_H_VERSION (includeguard)

/* ----- END OF filter.h ----- */