aglowav/operator.hh

Go to the documentation of this file.

/* Operators for the agglomerated wavelets.
 */

#ifndef aglowavOperator_hh
#define aglowavOperator_hh

#ifdef __GUNG__
  #pragma interface
#endif

#include <vector>

#include "basics/exceptions.hh"
#include "basics/memory.hh"
#include "operator/compositions.hh"
#include "aglowav/space.hh"

namespace aglowav {

  // ******************************************************************* C2W **

  template<class F = concepts::Real>
  class C2W : public concepts::Operator<F> {
  public:
    C2W(const concepts::Space<F>& cnst, const Haar3d<F>& wav);

    void operator()(const concepts::Function<F>& fncC,
                    concepts::Function<F>& fncW);
    void operator()(const concepts::Vector<F>& fncC,
                    concepts::Vector<F>& fncW);
    const Haar3d<F>& spaceX() const {return wav_;}
    const concepts::Space<F>&  spaceY() const {return cnst_;}

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

  private:
    const Haar3d<F>&          wav_;
    const concepts::Space<F>& cnst_;
  };

  template<class F>
  C2W<F>::C2W(const concepts::Space<F>& cnst, const Haar3d<F>& wav)
    : concepts::Operator<F>(wav.dim(), cnst.dim()), wav_(wav), cnst_(cnst)
  {
    conceptsAssert(wav_.dim() == cnst_.dim(), concepts::Assertion());
  }

  // ******************************************************************* W2C **

  template<class F = concepts::Real>
  class W2C : public concepts::Operator<F> {
  public:
    W2C(const Haar3d<F>& wav, const concepts::Space<F>& cnst);

    /* Transformation from fncW to fncC
       @throw MissingFeature
    */
    void operator()(const concepts::Function<F>& fncW,
        concepts::Function<F>& fncC);
    void operator()(const concepts::Vector<F>& fncW,
        concepts::Vector<F>& fncC);
    const concepts::Space<F>& spaceX() const {return cnst_;}
    //const AdaptConst3d<IK>& spaceX() const;
    const Haar3d<F>& spaceY() const {return wav_;}

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

  private:
    const concepts::Space<F>& cnst_;
    const Haar3d<F>&          wav_;
  };

  template<class F>
  W2C<F>::W2C(const Haar3d<F>& wav, const concepts::Space<F>& cnst)
    : concepts::Operator<F>(wav.dim(), cnst.dim()), cnst_(cnst), wav_(wav)
  {
    conceptsAssert(wav_.dim() == cnst_.dim(), concepts::Assertion());
  }

  // **************************************************************** C2_tl2 **

  template<class F = concepts::Real>
  class C2_tl2 : public concepts::Operator<F> {
  public:
    C2_tl2(const BiHaar3d<F>& spc, concepts::Real t);
    ~C2_tl2() {delete[] val_; delete[] idx_;}

    void operator()(const concepts::Function<F>& fncY,
        concepts::Function<F>& fncX);
    void operator()(const concepts::Vector<F>& fncY,
        concepts::Vector<F>& fncX);
    const BiHaar3d<F>& spaceX() const {return spc_;}
    const BiHaar3d<F>& spaceY() const {return spc_;}

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

  private:
    const BiHaar3d<F>& spc_;
    concepts::Real t_;
    concepts::Real* val_;
    concepts::Real** idx_;
  };

  // ***************************************************************** C2tl2 **

  template<class F = concepts::Real>
  class C2tl2 : public concepts::Operator<F> {
  public:
    C2tl2(const BiHaar3d<F>& spc, concepts::Real t);
    ~C2tl2() {delete[] val_; delete[] idx_;}

    void operator()(const concepts::Function<F>& fncY,
                    concepts::Function<F>& fncX);
    void operator()(const concepts::Vector<F>& fncY,
                    concepts::Vector<F>& fncX);
    const BiHaar3d<F>& spaceX() const {return spc_;}
    const BiHaar3d<F>& spaceY() const {return spc_;}

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

  private:
    const BiHaar3d<F>& spc_;
    concepts::Real t_;
    concepts::Real* val_;
    concepts::Real** idx_;
  };

  // ****************************************************************** CGt2 **

  template<class F = concepts::Real>
  class CGt2 : public concepts::Operator<F> {
  public:
    CGt2(const Haar3d<F>& spc, concepts::Real t);

    void operator()(const concepts::Function<F>& fncY,
        concepts::Function<F>& fncX);
    void operator()(const concepts::Vector<F>& fncY,
        concepts::Vector<F>& fncX);
    const Haar3d<F>& spaceX() const {return spc_;}
    const Haar3d<F>& spaceY() const {return spc_;}

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

  private:
    const Haar3d<F>& spc_;
    concepts::Real t_;
    std::vector<concepts::Real> val_;
  };

  // ************************************************************** ComposeN **

  template<class F = concepts::Real>
  class ComposeN : public concepts::Operator<F> {
    uint                    n_;
    concepts::Operator<F>** ops_;
    concepts::Vector<F>**   f_;

  public:
    ComposeN(concepts::Operator<F>** ops, uint n);
    ~ComposeN();

    void operator()(const concepts::Function<F>& fncY,
                    concepts::Function<F>& fncX);
  protected:
    std::ostream& info(std::ostream& os) const;
  };

  template<class F>
  inline ComposeN<F>::ComposeN(concepts::Operator<F>** ops, uint n) 
    : concepts::Operator<F>(ops[0]->dimX(), ops[n-1]->dimY()), n_(n)
  {
    conceptsAssert(n > 1, concepts::Assertion());
    ops_ = concepts::newField<concepts::Operator<F>*>(n_);
    for(uint i = 0; i < n_; i++)  ops_[i] = ops[i];
    f_ = concepts::newField<concepts::Vector<F>*>(n_-1);
    for(uint j = 0; j < n_-1; j++)
      f_[j] = new concepts::Vector<F>(ops_[j]->dimY());
  }

  template<class F>
  inline ComposeN<F>::~ComposeN() {
    for(uint i = 0; i < n_-1; i++)  delete f_[i];
    delete[] f_;
    delete[] ops_;
  }

  template<class F>
  inline void ComposeN<F>::operator()(const concepts::Function<F>& fncY,
                                      concepts::Function<F>& fncX) {

    conceptsAssert((fncY.dim() == this->dimY()) &&
                   (fncX.dim() == this->dimX()), concepts::Assertion());

    ops_[n_-1]->operator()(fncY, *f_[n_-2]);
    for(uint i = n_-1; --i;)  ops_[i]->operator()(*f_[i], *f_[i-1]);
    ops_[0]->operator()(*f_[0], fncX);
  }

  template<class F>
  std::ostream& ComposeN<F>::info(std::ostream& os) const {
    return os << "aglowav::ComposeN -- (op1 * ... * op" << n_ << ")";
  }

} // namespace aglowav

#endif // aglowavOperator_hh