cluster/xy01.hh

Go to the documentation of this file.

/* Far field matrices X01, Y01
 */

#ifndef clusterXY01_hh
#define clusterXY01_hh

#include "cluster/expansion.hh"
#include "cluster/xy.hh"

namespace cluster {

  // ****************************************************************** XY01 **

  template<class Node>
  class XY01 {
    typedef TreeTraits<Node>   Traits;
    typedef typename Traits::F F;
  
    const Tree<Node>& tree_;
    F*                fncval_;

    void constructor_(const Node* chld, const Node* prnt);
    bool info_(std::ostream& os, uint idx, const Node* nd) const;

  protected:
    struct XYFnc { 
      concepts::Real3d z;
      F*     pval;
      F*     val;
    };

    struct XYCol {
      XYCol*    lnk;
      uint      idx;
      F*        fncval;
      XYColExp* val;

      XYCol(XYColExp* value) : val(value) {}
      ~XYCol() {delete val;}
    };

    const ExpansionXY<F>& exp_;
    const uint            blksz_;

    XYFnc*     fnc_;
    const uint nfnc_;
    XYCol*     col_;
    uint       ncol_;

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

  public:
    XY01(const Tree<Node>& tree, const ExpansionXY<F>& exp);
    ~XY01();

    inline F* operator[](uint i) const {return fnc_[i].val;}
    inline float memory() const;
    inline const concepts::Space<F>& space() const {return tree_.space();}
    inline const Tree<Node>& tree() const {return tree_;}
    void zero();
    std::ostream& info(std::ostream& os, uint idx) const;
  };

  template<class Node>
  inline float XY01<Node>::memory() const {
    return sizeof(XY01<Node>)
      + (float)ncol_ * (sizeof(XYCol) + (col_ ? col_->val->memory() : 0))
      + (float)nfnc_ * (sizeof(XYFnc) + blksz_ * sizeof(F));
  }

  // ******************************************************************* X01 **

  template<class Node>
  class X01 : public ClstX<Node>, private XY01<Node> {
  public:
    typedef typename ClstX<Node>::Traits Traits;
    typedef typename ClstX<Node>::F      F;

    inline X01(const Tree<Node>& tree, const ExpansionXY<F>& exp);

    inline F* operator[](uint i) const;
    void gather(concepts::Vector<F>& fnc);
    inline float memory() const;
    inline const concepts::Space<F>& space() const;
    inline const Tree<Node>& tree() const;
    inline void zero() {XY01<Node>::zero();}

  protected:
    typedef typename XY01<Node>::XYFnc XYFnc;
    typedef typename XY01<Node>::XYCol XYCol;

    inline std::ostream& info(std::ostream& os) const;
  };

  template<class Node>
  inline X01<Node>::X01(const Tree<Node>& tree, const ExpansionXY<F>& exp)
    : XY01<Node>(tree, exp) {
  }

  template<class Node>
  inline typename X01<Node>::F* X01<Node>::operator[](uint i) const {
    return XY01<Node>::operator[](i);
  }

  template<class Node>
  inline const Tree<Node>& X01<Node>::tree() const {
    return XY01<Node>::tree();
  }

  template<class Node>
  inline const concepts::Space<typename X01<Node>::F>&
  X01<Node>::space() const {
    return XY01<Node>::space();
  }

  template<class Node>
  inline std::ostream& X01<Node>::info(std::ostream& os) const {
    os << "X01("; XY01<Node>::info(os);
    os << ", mem = " << memory() / 1024.0 << "KB)";
    return os;
  }

  template<class Node>
  inline float X01<Node>::memory() const {
    return sizeof(X01<Node>) + XY01<Node>::memory() - sizeof(XY01<Node>);
  }

  // ******************************************************************* Y01 **

  template<class Node>
  class Y01 : public ClstY<Node>, private XY01<Node> {
  public:
    typedef typename ClstY<Node>::Traits Traits;
    typedef typename ClstY<Node>::F      F;

    inline Y01(const Tree<Node>& tree, const ExpansionXY<F>& exp);

    inline F* operator[](uint i) const;
    void scatter(const concepts::Vector<F>& fnc);
    inline float memory() const;
    inline const concepts::Space<F>& space() const;
    inline const Tree<Node>& tree() const;
    inline void zero() {XY01<Node>::zero();}

  protected:
    typedef typename XY01<Node>::XYFnc XYFnc;
    typedef typename XY01<Node>::XYCol XYCol;

    inline std::ostream& info(std::ostream& os) const;
  };

  template<class Node>
  inline Y01<Node>::Y01(const Tree<Node>& tree, const ExpansionXY<F>& exp)
    : XY01<Node>(tree, exp) {
  }

  template<class Node>
  inline typename Y01<Node>::F* Y01<Node>::operator[](uint i) const {
    return XY01<Node>::operator[](i);
  }

  template<class Node>
  inline const Tree<Node>& Y01<Node>::tree() const {
    return XY01<Node>::tree();
  }

  template<class Node>
  inline const concepts::Space<typename Y01<Node>::F>&
  Y01<Node>::space() const {
    return XY01<Node>::space();
  }

  template<class Node>
  inline std::ostream& Y01<Node>::info(std::ostream& os) const {
    os << "Y01("; XY01<Node>::info(os);
    os << ", mem = " << memory() / 1024.0 << "KB)";
    return os;
  }

  template<class Node>
  inline float Y01<Node>::memory() const {
    return sizeof(Y01<Node>) + XY01<Node>::memory() - sizeof(XY01<Node>);
  }

} // namespace cluster

#endif // clusterXY01_hh