cluster/f03.hh

Go to the documentation of this file.

/* Far field matrix F03
 */

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

namespace cluster {

  // ******************************************************************* F03 **

  template<class NodeX, class NodeY>
  class F03 : 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_;
    int maxnffldval_;

    Ffld* ffld_;
    uint nffld_;
    FColExp* ffldval_;
    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:
    F03(const Tree<NodeX>& treeX, const Tree<NodeY>& treeY,
  const ExpansionF<FX>& exp, concepts::Real eps, concepts::Real s,
  uint minsz, int maxnffldval);
    ~F03();

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

} // namespace cluster

#endif // clusterF03_hh