EliminationTree.h

Go to the documentation of this file.

/* ----------------------------------------------------------------------------
 
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
* Atlanta, Georgia 30332-0415
* All Rights Reserved
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
 
* See LICENSE for the license information
 
* -------------------------------------------------------------------------- */
 
#pragma once
 
#include <utility>
#include <memory>
 
#include <gtsam/base/Testable.h>
#include <gtsam/base/FastVector.h>
 
class EliminationTreeTester; // for unit tests, see testEliminationTree
 
namespace gtsam {
 
  class VariableIndex;
  class Ordering;
 
  template<class BAYESNET, class GRAPH>
  class EliminationTree
  {
  protected:
    typedef EliminationTree<BAYESNET, GRAPH> This; 
    typedef std::shared_ptr<This> shared_ptr; 
 
  public:
    typedef GRAPH FactorGraphType; 
    typedef typename GRAPH::FactorType FactorType; 
    typedef typename std::shared_ptr<FactorType> sharedFactor;  
    typedef BAYESNET BayesNetType; 
    typedef typename BayesNetType::ConditionalType ConditionalType; 
    typedef typename std::shared_ptr<ConditionalType> sharedConditional; 
    typedef typename GRAPH::Eliminate Eliminate;
 
    struct Node {
      typedef FastVector<sharedFactor> Factors;
      typedef FastVector<std::shared_ptr<Node> > Children;
 
      Key key; 
      Factors factors; 
      Children children; 
 
      sharedFactor eliminate(const std::shared_ptr<BayesNetType>& output,
        const Eliminate& function, const FastVector<sharedFactor>& childrenFactors) const;
 
      void print(const std::string& str, const KeyFormatter& keyFormatter) const;
    };
 
    typedef std::shared_ptr<Node> sharedNode; 
 
  protected:
    GTSAM_CONCEPT_TESTABLE_TYPE(FactorType)
 
    FastVector<sharedNode> roots_;
    FastVector<sharedFactor> remainingFactors_;
 
 
    EliminationTree(const FactorGraphType& factorGraph,
      const VariableIndex& structure, const Ordering& order);
 
    EliminationTree(const FactorGraphType& factorGraph, const Ordering& order);
 
    EliminationTree(const This& other) { *this = other; }
 
    This& operator=(const This& other);
 
 
  public:
    ~EliminationTree(); 
 
    std::pair<std::shared_ptr<BayesNetType>, std::shared_ptr<FactorGraphType> >
      eliminate(Eliminate function) const;
 
 
    void print(const std::string& name = "EliminationTree: ",
      const KeyFormatter& formatter = DefaultKeyFormatter) const;
 
  protected:
    bool equals(const This& other, double tol = 1e-9) const;
 
 
  public:
 
    const FastVector<sharedNode>& roots() const { return roots_; }
 
    const FastVector<sharedFactor>& remainingFactors() const { return remainingFactors_; }
 
    void swap(This& other);
 
  protected:
    EliminationTree() {}
 
  private:
    friend class ::EliminationTreeTester;
  };
 
}