cluster/expansion.hh

Go to the documentation of this file.

/* Basic expansion class
 */

#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