parsedFormula.hh

Go to the documentation of this file.

 
#ifndef parsedformula_hh
#define parsedformula_hh
 
#include "toolbox/sequence.hh"
#include "formula.hh"
 
 
namespace concepts {
 
  // **************************************************** FormulaSyntaxError **
 
  class FormulaSyntaxError : public MissingFeature {
  public:
    FormulaSyntaxError(const std::string& errMsg) throw();
  protected:
    virtual std::ostream& info(std::ostream& os) const throw();
  };
 
  // ********************************************************* ParsedFormula **
 
  template<uint dim>
  class ParsedFormulaBase {
  public:
    typedef concepts::Sequence<std::pair<std::string,std::string> > RepSeq;
 
    ParsedFormulaBase() {
      for(uint i = 0; i < dim; ++i) {
        formula_[i] = "";
        len_[i] = 0;
      }
    }
    ParsedFormulaBase(const ParsedFormulaBase<dim>& frm) {
      for(uint i = 0; i < dim; ++i) {
        formula_[i] = frm.formula_[i];
        pgm_[i] = frm.pgm_[i];  // copy the data
        len_[i] = frm.len_[i];
      }
    }
    void set(const std::string formula, uint i = 0,
             RepSeq rep = RepSeq());
  protected:
    Real process_(const Real3d& p, const Real t=0.0, uint i=0) const;
    std::string formula_[dim];
  private:
    Array<uchar> pgm_[dim];
    uint len_[dim];
  };
 
  template<class F = Real>
  class ParsedFormula {};
 
  template<>
  class ParsedFormula<Real> : public Formula<Real>, public ParsedFormulaBase<1> {
  public:
    ParsedFormula(const std::string formula);
    virtual ~ParsedFormula();
    virtual ParsedFormula<Real>* clone() const;
    
    virtual Real operator() (const Real p, const Real t = 0.0) const;
    virtual Real operator() (const Real2d& p, const Real t = 0.0) const;
    virtual Real operator() (const Real3d& p, const Real t = 0.0) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  template<>
  class ParsedFormula<Cmplx> : public Formula<Cmplx>, public ParsedFormulaBase<2>
  {
  public:
    ParsedFormula(const std::string formulaR, const std::string formulaI);
    virtual ~ParsedFormula();
    virtual ParsedFormula<Cmplx>* clone() const;
    
    virtual Cmplx operator() (const Real p, const Real t = 0.0) const;
    virtual Cmplx operator() (const Real2d& p, const Real t = 0.0) const;
    virtual Cmplx operator() (const Real3d& p, const Real t = 0.0) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
  template<>
  class ParsedFormula<Real2d> : public Formula<Real2d>,
                                public ParsedFormulaBase<2>
  {
  public:
    ParsedFormula(const std::string formula1, const std::string formula2);
    virtual ~ParsedFormula();
    virtual ParsedFormula<Real2d>* clone() const;
    
    virtual Real2d operator() (const Real p, const Real t = 0.0) const;
    virtual Real2d operator() (const Real2d& p, const Real t = 0.0) const;
    virtual Real2d operator() (const Real3d& p, const Real t = 0.0) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
 
 
} // namespace concepts
 
#endif // parsedformula_hh