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;
  };

}