cluster/f01.hh

Go to the documentation of this file.

/* Far field matrix F01
 */

#ifndef clusterF01_hh
#define clusterF01_hh

#include "toolbox/scannerConnectors.hh"
#include "toolbox/hashMap.hh"
#include "cluster/expansion.hh"
#include "cluster/f.hh"

namespace cluster {

  // ******************************************************************* F01 **

  template<class NodeX, class NodeY>
  class F01 : public ClstF<NodeX, NodeY> {
  public:
    typedef typename ClstF<NodeX, NodeY>::TraitsX  TraitsX;
    typedef typename ClstF<NodeX, NodeY>::TraitsY  TraitsY;
    typedef typename ClstF<NodeX, NodeY>::FX       FX;
    typedef typename ClstF<NodeX, NodeY>::FY       FY;
    typedef typename ClstF<NodeX, NodeY>::NfldNodes NfldNodes;
    typedef typename ClstF<NodeX, NodeY>::NfldScan NfldScan;
  private:
    class Ffld {
      Ffld* lnk_;
      uint  sigma_, tau_;
      FColExp* val_;

    public:
      inline Ffld(uint blksz, const ExpansionF<FX>& exp, uint sigma,
      uint tau, Ffld* lnk)
  : lnk_(lnk), sigma_(sigma), tau_(tau) {
  val_ = exp.getCol(blksz);
      }
      inline ~Ffld() {delete val_;}

      inline Ffld* link() const {return lnk_;}
      inline uint sigma() const {return sigma_;}
      inline uint tau() const {return tau_;}
      inline FColExp* val() const {return val_;}
    };

    const Tree<NodeX>& treeX_;
    const Tree<NodeY>& treeY_;

    const ExpansionF<FX>&  exp_;

    uint m_;
    concepts::Real eta_;
    uint minsz_;
    Ffld* ffld_;
    uint nffld_;
    concepts::Joiner<NfldNodes, 1>* nfld_;
    uint nnfld_;

    void constructor_(const NodeX* clstX, const NodeY* clstY);
    void constructorSym_(const NodeX* clstX, const NodeY* clstY);
    template<class Trts, class Nd>
    uint info_(uint idx, const Nd* clst,
         __gnu_cxx::hash_map<uint, uint>& nlf) const;

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

  public:
    F01(const Tree<NodeX>& treeX, const Tree<NodeY>& treeY,
  const ExpansionF<FX>& exp, concepts::Real eta, uint minsz);
    F01(const Tree<NodeX>& tree, const ExpansionF<FX>& exp,
  concepts::Real eta, uint minsz);

    ~F01();

    void operator()(const ClstY<NodeY>& vecY, ClstX<NodeX>& vecX) const;
    inline NfldScan* scan() const {
      return new concepts::ListScan<NfldNodes>(*nfld_);
    }
    inline float memory() const;
    std::ostream& info(std::ostream& os, uint idxX, uint idxY) const;
  };

  template<class NodeX, class NodeY>
  inline float F01<NodeX,NodeY>::memory() const {
    return sizeof(F01<NodeX,NodeY>)
      + (float)nffld_ *
      (sizeof(typename F01<NodeX,NodeY>::Ffld)
       + (ffld_ ? ffld_->val()->memory(exp_.blksz(m_)) : 0))
      + (float)nnfld_ * sizeof(concepts::Joiner<NfldNodes, 1>);
  }

} // namespace cluster

#endif // clusterF01_hh