cluster/f02.hh

Go to the documentation of this file.

/* Far field matrix F02
 */

#ifndef clusterF02_hh
#define clusterF02_hh

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

namespace cluster {

  // ******************************************************************* F02 **

  template<class NodeX, class NodeY>
  class F02 : 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_;
      const NodeX* clstX_;
      const NodeY* clstY_;
      uint m_;
      FColExp* val_;

    public:
      inline Ffld(const NodeX* clstX, const NodeY* clstY,
      uint m, Ffld* lnk = 0)
  : lnk_(lnk), clstX_(clstX), clstY_(clstY), m_(m), val_(0) {}
      inline ~Ffld() {delete val_;}

      inline Ffld* link() const {return lnk_;}
      inline uint sigma() const {return TraitsX::index(clstX_);}
      inline uint tau() const {return TraitsY::index(clstY_);}
      inline concepts::Real3d z() const {
  return TraitsY::center(clstY_) - TraitsX::center(clstX_);
      }
      inline uint m() const {return m_;}
      inline FColExp* val(uint blksz, const ExpansionF<FX>& exp) {
  delete val_; val_ = blksz ? exp.getCol(blksz) : 0; return val_;
      }
      inline FColExp* val() const {return val_;}
    };

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

    const ExpansionF<FX>& exp_;

    uint m_;
    concepts::Real eps_;
    concepts::Real s_;
    uint minsz_;

    Ffld*  ffld_;
    uint nffld_;
    uint nffldval_;
    concepts::Joiner<NfldNodes, 1>* nfld_;
    uint nnfld_;

    void constructor_(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:
    F02(const Tree<NodeX>& treeX, const Tree<NodeY>& treeY,
  const ExpansionF<FX>& exp, concepts::Real eps,
  concepts::Real s, uint minsz);
    ~F02();

    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 F02<NodeX, NodeY>::memory() const {
    return sizeof(F02<NodeX, NodeY>)
      + (float)nffld_ * sizeof(typename F02<NodeX, NodeY>::Ffld)
      + nffldval_ * (ffld_->val() ? ffld_->val()->memory(1)
         : ffld_->val(1, exp_)->memory(1))
      + (float)nnfld_ * sizeof(concepts::Joiner<NfldNodes, 1>);
  }

} // namespace cluster

#endif // clusterF02_hh