aglowav/space.hh

Go to the documentation of this file.

/* Spaces for the agglomerated wavelets.
 */

#ifndef aglowavSpace_hh
#define aglowavSpace_hh

#ifdef __GUNG__
  #pragma interface
#endif

#include "toolbox/scannerConnectors.hh"
#include "space/space.hh"
#include "aglowav/element.hh"
#include "aglowav/tree.hh"

namespace aglowav {

  // ********************************************************* Haar3dDFSScan **

  template<class F = concepts::Real>
  class Haar3dDFSScan : public concepts::Scan<concepts::Element<F> > {
  public:
    virtual Haar3dXXX<F>& operator++(int) = 0;
  };


  // ********************************************************* Haar3dBFSScan **

  template<class F = concepts::Real>
  class Haar3dBFSScan : public concepts::Scan<concepts::Element<F> > {
  public:
    virtual Haar3dXXX<F>& operator++(int) = 0;
    virtual void skip(uint lvl) = 0;
  };

  // **************************************************************** Haar3d **

  template<class F = concepts::Real>
  class Haar3d : public concepts::Space<F> {
  public:
    virtual ~Haar3d() {}

    virtual uint nlvl() const = 0;
    virtual Haar3dDFSScan<F>* dfsscan() const = 0;
    virtual Haar3dBFSScan<F>* bfsscan() const = 0;
  };

  // ******************************************************* BiHaar3dDFSScan **

  template<class F = concepts::Real>
  class BiHaar3dDFSScan : public Haar3dDFSScan<F> {
  public:
    BiHaar3dDFSScan(Haar3d000<F>* elm, uint ht);
    BiHaar3dDFSScan(const BiHaar3dDFSScan<F>& sc);
    inline ~BiHaar3dDFSScan() {delete[] stk_;}

    Haar3d000<F>& operator++(int);
    inline BiHaar3dDFSScan<F>* clone() const {
      return new BiHaar3dDFSScan<F>(*this);
    }
    inline bool eos() const {return sptr_[0] ? 0 : 1;}

  private:
    uint ht_;
    Haar3d000<F>** stk_;
    Haar3d000<F>** sptr_;
  };

  // ******************************************************* BiHaar3dBFSScan **

  template<class F = concepts::Real>
  class BiHaar3dBFSScan : public Haar3dBFSScan<F> {
  public:
    BiHaar3dBFSScan(Haar3d000<F>* elm, uint ht);
    BiHaar3dBFSScan(const BiHaar3dBFSScan<F>& sc);
    inline ~BiHaar3dBFSScan() {delete[] stk_;}

    Haar3d000<F>& operator++(int);
    inline BiHaar3dBFSScan* clone() const {
      return new BiHaar3dBFSScan<F>(*this);
    }
    inline bool eos() const {return sptr_[0] ? 0 : 1;}
    void skip(uint lvl);

  private:
    uint ht_;
    Haar3d000<F>** stk_;
    Haar3d000<F>** sptr_;
  };

  // ************************************************************** BiHaar3d **

  template<class F = concepts::Real>
  class BiHaar3d : public Haar3d<F> {
  public:
    BiHaar3d(BiTree<BiClNode00<F> >& tree);
    inline ~BiHaar3d() {destructor_(elm_);}

    inline uint dim() const {return dim_;}
    inline uint nelm() const {return nelm_;}
    inline uint nlvl() const {return nlvl_;}
    inline BiHaar3dDFSScan<F>* dfsscan() const;
    inline BiHaar3dBFSScan<F>* bfsscan() const;
    inline BiHaar3dBFSScan<F>* scan() const;

  protected:
    std::ostream& info(std::ostream& os) const;

  private:
    Haar3d000<F>* constructor_(BiClNode00<F>* nd, concepts::Real* m,
             typename Haar3dXXX<F, 2>::Key& key);

    void destructor_(Haar3d000<F>* elm);

    uint dim_;
    uint nelm_;
    uint nlvl_;
    Haar3d000<F>* elm_;
  };

  template<class F>
  inline BiHaar3dDFSScan<F>* BiHaar3d<F>::dfsscan() const {
    return new BiHaar3dDFSScan<F>(elm_, nlvl_);
  }

  template<class F>
  inline BiHaar3dBFSScan<F>* BiHaar3d<F>::bfsscan() const {
    return new BiHaar3dBFSScan<F>(elm_, nlvl_);
  }

  template<class F>
  inline BiHaar3dBFSScan<F>* BiHaar3d<F>::scan() const {
    return new BiHaar3dBFSScan<F>(elm_, nlvl_);
  }

  template<class F>
  std::ostream& BiHaar3d<F>::info(std::ostream& os) const {
    os << "aglowav::BiHaar3d(dim = " << dim_ << ", nlevel = " << nlvl_;
    return os << ", nElement = " << nelm_ << ')';
  }

} // namespace aglowav

#endif // aglowavSpace_hh