// file: $isip/class/algo/Calculus/Calculus.h// version: $Id: Calculus.h,v 1.42 2002/05/31 21:57:22 picone Exp $//// make sure definitions are only made once//#ifndef ISIP_CALCULUS#define ISIP_CALCULUS#ifndef ISIP_ALGORITHM_BASE#include <AlgorithmBase.h>#endif// Calculus: a class that performs basic calculus operations such as// differentiation (typically implemented via regression) and integration.// this class operates on elements of vectors or time series data delivered// as sequences of vectors.//class Calculus : public AlgorithmBase {    //---------------------------------------------------------------------------  //  // public constants  //  //---------------------------------------------------------------------------public:    // define the class name  //  static const String CLASS_NAME;  //----------------------------------------  //  // other important constants  //  //----------------------------------------    // define algorithm choices  //  enum ALGORITHM { DIFFERENTIATION = 0, INTEGRATION,		   DEF_ALGORITHM = DIFFERENTIATION };    // define implementation choices  //  enum IMPLEMENTATION { REGRESSION = 0, CENTRAL_DIFFERENCE,			BACKWARD_DIFFERENCE, DEF_IMPLEMENTATION = REGRESSION };    // define the static NameMap objects  //  static const NameMap ALGO_MAP;  static const NameMap IMPL_MAP;    //----------------------------------------  //  // i/o related constants  //  //----------------------------------------      static const String DEF_PARAM;  static const String PARAM_ALGORITHM;  static const String PARAM_IMPLEMENTATION;  static const String PARAM_CMODE;  static const String PARAM_ORDER;  static const String PARAM_DELTAWIN;    //----------------------------------------  //  // default values and arguments  //  //----------------------------------------      // define the default value(s) of the class data  //  static const long DEF_ORDER = 1;  static const long DEF_DELTAWIN = 2;  // define default argument(s)  //  static const AlgorithmData::COEF_TYPE DEF_COEF_TYPE = AlgorithmData::GENERIC;  //----------------------------------------  //  // error codes  //  //----------------------------------------      static const long ERR = 70200;  static const long ERR_ZERODENOM = 70201;    //---------------------------------------------------------------------------  //  // protected data  //  //---------------------------------------------------------------------------protected:  // algorithm name  //  ALGORITHM algorithm_d;    // implementation name  //  IMPLEMENTATION implementation_d;  // specify an order for the operation (for example, a 1st-order derivative)  //  Long order_d;  // static memory manager  //  static MemoryManager mgr_d;    // this section contains data for a specific algorithm  //  // algorithm: differentiation  // implementation: regression/central difference/backward difference  // description: window length in frames  // notes: these implementations interpret this differently.  //  Long delta_win_d;  // algorithm: differentiation  // implementation: regression, central difference, or regression  // description: precomputed scaling factor  //  double denom_d;  //---------------------------------------------------------------------------  //  // required public methods  //  //---------------------------------------------------------------------------public:  // method: name  //  static const String& name() {    return CLASS_NAME;  }    // other static methods  //  static boolean diagnose(Integral::DEBUG debug_level);    // method: setDebug  //  this method is inherited from the AlgorithmBase class  // other debug methods  //  boolean debug(const unichar* msg) const;    // method: destructor  //  ~Calculus() {}  // method: default constructor  //  note that we can't include all arguments because that would create  //  ambiguous default values.  //  Calculus(ALGORITHM algorithm = DEF_ALGORITHM,	   IMPLEMENTATION implementation = DEF_IMPLEMENTATION,	   long order = DEF_ORDER, long delta_win = DEF_DELTAWIN) {    algorithm_d = algorithm;    implementation_d = implementation;    order_d = order;    delta_win_d = DEF_DELTAWIN;    denom_d = 0;    is_valid_d = false;  }  // method: copy constructor  //  Calculus(const Calculus& arg) {    assign(arg);  }    // assign methods  //  boolean assign(const Calculus& arg);    // method: operator=  //  Calculus& operator= (const Calculus& arg) {    assign(arg);    return *this;  }    // i/o methods  //  long sofSize() const;    boolean read(Sof& sof, long tag, const String& name = CLASS_NAME);  boolean write(Sof& sof, long tag, const String& name = CLASS_NAME) const;    boolean readData(Sof& sof, const String& pname = DEF_PARAM,		   long size = SofParser::FULL_OBJECT,                   boolean param = true, boolean nested = false);  boolean writeData(Sof& sof, const String& pname = DEF_PARAM) const;    // equality methods  //  boolean eq(const Calculus& arg) const;    // method: new  //  static void* operator new(size_t size) {    return mgr_d.get();  }  // method: new[]  //  static void* operator new[](size_t size) {    return mgr_d.getBlock(size);  }  // method: delete  //  static void operator delete(void* ptr) {    mgr_d.release(ptr);  }  // method: delete[]  //  static void operator delete[](void* ptr) {    mgr_d.releaseBlock(ptr);  }  // method: setGrowSize  //  static boolean setGrowSize(long grow_size) {    return mgr_d.setGrow(grow_size);  }  // other memory management methods  //  boolean clear(Integral::CMODE ctype = Integral::DEF_CMODE);    //---------------------------------------------------------------------------  //  // class-specific public methods  //  set methods  //  //---------------------------------------------------------------------------    // method: setAlgorithm  //  boolean setAlgorithm(ALGORITHM algorithm) {    algorithm_d = algorithm;    is_valid_d = false;    return true;    }  // method: setImplementation  //  boolean setImplementation(IMPLEMENTATION implementation) {    implementation_d = implementation;    is_valid_d = false;    return true;    }  // method: setOrder  //  boolean setOrder(long order) {    order_d = order;    is_valid_d = false;    return true;  }  // method: setDeltaWindow  //  boolean setDeltaWindow(long delta_win) {    delta_win_d = delta_win;    is_valid_d = false;    return true;  }  // method: set  //  boolean set(ALGORITHM algorithm = DEF_ALGORITHM,	      IMPLEMENTATION implementation = DEF_IMPLEMENTATION,	      long order = DEF_ORDER, long delta_win = DEF_DELTAWIN) {    algorithm_d = algorithm;    implementation_d = implementation;    order_d = order;    delta_win_d = delta_win;    denom_d = 0;    is_valid_d = false;    return true;  }  //---------------------------------------------------------------------------  //  // class-specific public methods:  //  get methods  //  //---------------------------------------------------------------------------  // method: getAlgorithm  //  ALGORITHM getAlgorithm() const {    return algorithm_d;  }  // method: getImplementation  //  IMPLEMENTATION getImplementation() const {    return implementation_d;  }  // method: getOrder  //  long getOrder() const {    return order_d;  }  // method: getDeltaWindow  //  long getDeltaWindow() const {    return delta_win_d;  }  // method: get  //  boolean get(ALGORITHM& algorithm,	      IMPLEMENTATION& implementation,	      long& order, long& delta_win) const {    algorithm = algorithm_d;    implementation = implementation_d;    order = order_d;    delta_win = delta_win_d;    return true;  }  //---------------------------------------------------------------------------  //  // class-specific public methods:  //  computational methods  //  //---------------------------------------------------------------------------  boolean compute(VectorFloat& output, const VectorFloat& input,		  AlgorithmData::COEF_TYPE coef_type = DEF_COEF_TYPE,		  long index = DEF_CHANNEL_INDEX);  boolean compute(VectorComplexFloat& output, const VectorComplexFloat& input,		  AlgorithmData::COEF_TYPE coef_type = DEF_COEF_TYPE,		  long index = DEF_CHANNEL_INDEX);  //---------------------------------------------------------------------------  //  // class-specific public methods:  //  public methods required by the AlgorithmBase interface contract  //  //---------------------------------------------------------------------------  // assign method  //  boolean assign(const AlgorithmBase& arg);  // equality method  //  boolean eq(const AlgorithmBase& arg) const;  // method: className  //  const String& className() const {    return CLASS_NAME;  }  // initialization method  //  boolean init();  // apply method  //  boolean apply(Vector<AlgorithmData>& output,		const Vector< CircularBuffer<AlgorithmData> >& input);  // method: getLeadingPad  //  long getLeadingPad() const {    return delta_win_d;  }  // method: getTrailingPad  //  long getTrailingPad() const {    return delta_win_d;  }    // method to set the parser  //  boolean setParser(SofParser* parser);  //---------------------------------------------------------------------------  //  // private methods  //  //---------------------------------------------------------------------------private:    // common i/o methods  //  boolean readDataCommon(Sof& sof, const String& pname,			 long size = SofParser::FULL_OBJECT,			 boolean param = true, boolean nested = false);  boolean writeDataCommon(Sof& sof, const String& pname) const;  // general compute methods:  //  The compute method in this class is different with most of other  //  classes, it is easier to operate directly on the circular buffer  //  of data. hence, we provide two additional compute methods for  //  FRAME_INTERNAL and CROSS_FRAME mode to use.  //  boolean computeInternal(VectorFloat& output,			  const CircularBuffer<AlgorithmData>& input,			  AlgorithmData::COEF_TYPE input_coef_type			  = DEF_COEF_TYPE,			  long channel_index = DEF_CHANNEL_INDEX);  boolean computeCross(VectorFloat& output,		       const CircularBuffer<AlgorithmData>& input,		       AlgorithmData::COEF_TYPE input_coef_type		       = DEF_COEF_TYPE,		       long channel_index = DEF_CHANNEL_INDEX);    // algorithm-specific compute methods: Differentiation  //  boolean computeDifRegression(VectorFloat& output, const VectorFloat& input);  boolean computeDifCentral(VectorFloat& output, const VectorFloat& input);  boolean computeDifBackward(VectorFloat& output, const VectorFloat& input);};// end of include file//#endif