simulate.h

Go to the documentation of this file.

/***************************************************************************/
#ifndef AURESERVOIR_SIMULATE_H__
#define AURESERVOIR_SIMULATE_H__

#include "utilities.h"
#include "filter.h"
#include "delaysum.h"
#include <vector>

namespace aureservoir
{

enum SimAlgorithm
{
  SIM_STD,       
  SIM_SQUARE,    
  SIM_LI,        
  SIM_BP,        
  SIM_FILTER,    
  SIM_FILTER2,   
  SIM_FILTER_DS  
};

template <typename T> class ESN;

template <typename T>
class SimBase
{
 public:

  SimBase(ESN<T> *esn);

  virtual ~SimBase() {}

  virtual SimBase<T> *clone(ESN<T> *esn) const = 0;

  virtual void simulate(const typename ESN<T>::DEMatrix &in,
                        typename ESN<T>::DEMatrix &out) = 0;

  virtual void reallocate();


  virtual void setBPCutoffConst(T f1, T f2) throw(AUExcept);
  virtual void setBPCutoff(const typename ESN<T>::DEVector &f1,
                           const typename ESN<T>::DEVector &f2)
                           throw(AUExcept);
  virtual void setIIRCoeff(const typename DEMatrix<T>::Type &B,
                           const typename DEMatrix<T>::Type &A,
                           int series = 1) throw(AUExcept);
  virtual void initDelayLine(int index, const typename DEVector<T>::Type &initbuf)
                             throw(AUExcept);
  virtual typename DEMatrix<T>::Type getDelays() throw(AUExcept);
  virtual typename DEVector<T>::Type &getDelayBuffer(int output, int nr)
    throw(AUExcept);

  typename ESN<T>::DEMatrix last_out_;

  typename ESN<T>::DEVector t_;

 protected:

  ESN<T> *esn_;
};

template <typename T>
class SimStd : public SimBase<T>
{
  using SimBase<T>::esn_;
  using SimBase<T>::last_out_;
  using SimBase<T>::t_;

 public:
  SimStd(ESN<T> *esn) : SimBase<T>(esn) {}
  virtual ~SimStd() {}

  virtual SimStd<T> *clone(ESN<T> *esn) const
  {
    SimStd<T> *new_obj = new SimStd<T>(esn);
    new_obj->t_ = t_; new_obj->last_out_ = last_out_;
    return new_obj;
  }

  virtual void simulate(const typename ESN<T>::DEMatrix &in,
                        typename ESN<T>::DEMatrix &out);
};

template <typename T>
class SimLI : public SimBase<T>
{
  using SimBase<T>::esn_;
  using SimBase<T>::last_out_;
  using SimBase<T>::t_;

 public:
  SimLI(ESN<T> *esn) : SimBase<T>(esn) {}
  virtual ~SimLI() {}

  virtual SimLI<T> *clone(ESN<T> *esn) const
  {
    SimLI<T> *new_obj = new SimLI<T>(esn);
    new_obj->t_ = t_; new_obj->last_out_ = last_out_;
    return new_obj;
  }

  virtual void simulate(const typename ESN<T>::DEMatrix &in,
                        typename ESN<T>::DEMatrix &out);
};

template <typename T>
class SimBP : public SimBase<T>
{
  using SimBase<T>::esn_;
  using SimBase<T>::last_out_;
  using SimBase<T>::t_;

 public:
  SimBP(ESN<T> *esn) : SimBase<T>(esn) {}
  virtual ~SimBP() {}

  virtual SimBP<T> *clone(ESN<T> *esn) const
  {
    SimBP<T> *new_obj = new SimBP<T>(esn);
    new_obj->t_ = t_; new_obj->last_out_ = last_out_;
    new_obj->filter_ = filter_;
    return new_obj;
  }

  virtual void setBPCutoffConst(T f1, T f2) throw(AUExcept);

  virtual void setBPCutoff(const typename ESN<T>::DEVector &f1,
                           const typename ESN<T>::DEVector &f2)
                           throw(AUExcept);

  virtual void simulate(const typename ESN<T>::DEMatrix &in,
                        typename ESN<T>::DEMatrix &out);

  BPFilter<T> filter_;
};

template <typename T>
class SimFilter : public SimBase<T>
{
  using SimBase<T>::esn_;
  using SimBase<T>::last_out_;
  using SimBase<T>::t_;

 public:
  SimFilter(ESN<T> *esn) : SimBase<T>(esn) {}
  virtual ~SimFilter() {}

  virtual SimFilter<T> *clone(ESN<T> *esn) const
  {
    SimFilter<T> *new_obj = new SimFilter<T>(esn);
    new_obj->t_ = t_; new_obj->last_out_ = last_out_;
    new_obj->filter_ = filter_;
    return new_obj;
  }

  virtual void setIIRCoeff(const typename DEMatrix<T>::Type &B,
                   const typename DEMatrix<T>::Type &A,
                   int series=1) throw(AUExcept);

  virtual void simulate(const typename ESN<T>::DEMatrix &in,
                        typename ESN<T>::DEMatrix &out);

  SerialIIRFilter<T> filter_;
};

template <typename T>
class SimFilter2 : public SimFilter<T>
{
  using SimBase<T>::esn_;
  using SimBase<T>::last_out_;
  using SimBase<T>::t_;
  using SimFilter<T>::filter_;

 public:
  SimFilter2(ESN<T> *esn) : SimFilter<T>(esn) {}
  virtual ~SimFilter2() {}

  virtual SimFilter2<T> *clone(ESN<T> *esn) const
  {
    SimFilter2<T> *new_obj = new SimFilter2<T>(esn);
    new_obj->t_ = t_; new_obj->last_out_ = last_out_;
    new_obj->filter_ = filter_;
    return new_obj;
  }

  virtual void simulate(const typename ESN<T>::DEMatrix &in,
                        typename ESN<T>::DEMatrix &out);
};

template <typename T>
class SimFilterDS : public SimFilter<T>
{
  using SimBase<T>::esn_;
  using SimBase<T>::last_out_;
  using SimBase<T>::t_;
  using SimFilter<T>::filter_;

 public:
  SimFilterDS(ESN<T> *esn) : SimFilter<T>(esn) {}
  virtual ~SimFilterDS() {}

  virtual SimFilterDS<T> *clone(ESN<T> *esn) const
  {
    SimFilterDS<T> *new_obj = new SimFilterDS<T>(esn);
    new_obj->t_ = t_; new_obj->last_out_ = last_out_;
    new_obj->filter_ = filter_; new_obj->dellines_ = dellines_;
    new_obj->intmp_ = intmp_;
    return new_obj;
  }

  virtual void reallocate();

  virtual void initDelayLine(int index,
                             const typename DEVector<T>::Type &initbuf)
                             throw(AUExcept);

  virtual typename DEMatrix<T>::Type getDelays() throw(AUExcept);

  virtual typename DEVector<T>::Type &getDelayBuffer(int output, int nr)
    throw(AUExcept);

  virtual void simulate(const typename ESN<T>::DEMatrix &in,
                        typename ESN<T>::DEMatrix &out);

 protected:

  std::vector< DelayLine<T> > dellines_;

  typename ESN<T>::DEMatrix intmp_;
};

template <typename T>
class SimSquare : public SimFilterDS<T>
{
  using SimBase<T>::esn_;
  using SimBase<T>::last_out_;
  using SimBase<T>::t_;
  using SimFilter<T>::filter_;
  using SimFilterDS<T>::dellines_;
  using SimFilterDS<T>::intmp_;

 public:
  SimSquare(ESN<T> *esn) : SimFilterDS<T>(esn) {}
  virtual ~SimSquare() {}

  virtual SimSquare<T> *clone(ESN<T> *esn) const
  {
    SimSquare<T> *new_obj = new SimSquare<T>(esn);
    new_obj->t_ = t_; new_obj->last_out_ = last_out_;
    new_obj->filter_ = filter_; new_obj->dellines_ = dellines_;
    new_obj->intmp_ = intmp_; new_obj->t2_ = t2_;
    new_obj->insq_ = insq_;
    return new_obj;
  }

  virtual void reallocate();

  virtual void simulate(const typename ESN<T>::DEMatrix &in,
                        typename ESN<T>::DEMatrix &out);
 protected:
  typename ESN<T>::DEVector t2_;
  typename ESN<T>::DEVector insq_;
};

} // end of namespace aureservoir

#endif // AURESERVOIR_SIMULATE_H__

---