expansion.hh

Go to the documentation of this file.

 
#ifndef expansion_hh
#define expansion_hh
 
#include "basics/vectorsMatricesForward.hh"
#include "space/element.hh"
 
namespace cluster {
 
  // *********************************************************** XYColExpPtr **
 
  class XYColExpPtr {
  public:
    virtual void operator+=(uint i) = 0;
    virtual void operator-=(uint i) = 0;
  };
 
  // ************************************************************* XYColFPtr **
 
  template <class F = concepts::Real>
  class XYColFPtr : public XYColExpPtr {
  public:
    XYColFPtr() : val_(0) {}
    XYColFPtr(F* val) : val_(val) {}
 
    void operator+=(uint i) {val_ += i;}
    void operator-=(uint i) {val_ -= i;}
 
    inline F* value() const {return val_;}
 
  protected:
    F* val_;
  };
 
  // ************************************************************** XYColExp **
 
  class XYColExp : public XYColExpPtr {
  public:
    virtual ~XYColExp() {}
 
    virtual XYColExpPtr* operator[](uint i) const = 0;
    virtual uint memory() const = 0;
  };
 
  // **************************************************************** XYColF **
 
  template <class F = concepts::Real>
  class XYColF : public XYColExp, public XYColFPtr<F> {
  public:
    typedef XYColFPtr<F> ColPtr;
 
    inline XYColF(uint blksz, uint n) : blksz_(blksz), n_(n) {
      this->val_ = new F[blksz_*n_];
      std::memset(this->val_, 0, blksz_ * n_ * sizeof(F));
    }
    inline ~XYColF() {delete[] this->val_;}
 
    XYColFPtr<F>* operator[](uint i) const {
      return new XYColFPtr<F>(&this->val_[i*blksz_]);
    }
    uint memory() const {return sizeof(XYColF<F>) + blksz_ * n_ * sizeof(F);}
    void operator+=(uint i) {
      throw conceptsException(concepts::ExceptionBase());
    }
    void operator-=(uint i) {
      throw conceptsException(concepts::ExceptionBase());
    }
 
  private:
    uint blksz_;
    uint n_;
  };
 
  // ************************************************************** typedefs **
 
  typedef XYColFPtr<concepts::Real> XYColRealPtr;
  typedef XYColF<concepts::Real>    XYColReal;
 
  // *********************************************************** ExpansionXY **
 
  template <class F = concepts::Real>
  class ExpansionXY {
  public:
    virtual ~ExpansionXY() {}
 
    virtual uint blksz() const = 0;
    virtual uint m() const = 0;
    virtual XYColExp* getCol(uint blksz, uint n) const = 0;
    virtual void evaluate(const concepts::Element<F>& elm,
        const concepts::Real3d& c,
        XYColExpPtr* XY[]) const = 0;
    virtual void shift(const concepts::Real3d& z, const concepts::Real src[],
           concepts::Real dst[]) const = 0;
    virtual void shift(const concepts::Real3d& z, const concepts::Cmplx src[],
           concepts::Cmplx dst[]) const = 0;
    virtual void apply(const XYColExpPtr* XY, const F src[],
                       F dst[]) const = 0;
  };
 
  // *************************************************************** FColExp **
 
  class FColExp {
    friend std::ostream& operator<<(std::ostream& os, const FColExp& f);
  public:
    virtual ~FColExp() {}
    virtual uint memory(uint blksz) const = 0;
    virtual void info(std::ostream& os, uint) const { os << "FColExp()"; }
  };
 
  // ***************************************************************** FColF **
 
  template <class F = concepts::Real>
  class FColF : public FColExp {
  public:
    inline FColF(uint blksz) {this->val_ = new F[blksz];}
    inline ~FColF() {delete[] this->val_;}
 
    inline F* value() const {return this->val_;}
    uint memory(uint blksz) const {
      return sizeof(FColF<F>) + blksz * sizeof(F);
    }
    void info(std::ostream& os, uint blksz) const {
      for(uint i = 0; i < blksz-1; i++)  os << this->val_[i] << ", ";
      os << this->val_[blksz-1];
    }
 
  private:
    F* val_;
  };
 
  // ************************************************************** typedefs **
 
  typedef FColF<concepts::Real> FColReal;
 
  // ************************************************************ ExpansionF **
 
  template <class Fspc = concepts::Real>
  class ExpansionF {
  public:
    virtual ~ExpansionF() {}
 
    virtual uint blksz(uint m) const = 0;
    virtual uint m() const = 0;
    virtual FColExp* getCol(uint blksz) const = 0;
    virtual void evaluate(uint m, const concepts::Real3d& z,
        FColExp* Fexp) const = 0;
    virtual void apply(uint m, const FColExp* Fexp, const Fspc src[],
           Fspc dst[]) const = 0;
  };
 
} // namespace cluster
 
#endif // expansion_hh