EliminateableFactorGraph.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 <memory>
#include <functional>
#include <optional>
#include <unordered_set>
 
#include <gtsam/inference/Ordering.h>
#include <gtsam/inference/VariableIndex.h>
 
namespace gtsam {
  // Forward declaration
  class IndexedJunctionTree;

  template<class GRAPH>
  struct EliminationTraits
  {
    // Template for deriving:
    // typedef MyFactor FactorType;                   ///< Type of factors in factor graph (e.g. GaussianFactor)
    // typedef MyFactorGraphType FactorGraphType;     ///< Type of the factor graph (e.g. GaussianFactorGraph)
    // typedef MyConditional ConditionalType;         ///< Type of conditionals from elimination (e.g. GaussianConditional)
    // typedef MyBayesNet BayesNetType;               ///< Type of Bayes net from sequential elimination (e.g. GaussianBayesNet)
    // typedef MyEliminationTree EliminationTreeType; ///< Type of elimination tree (e.g. GaussianEliminationTree)
    // typedef MyBayesTree BayesTreeType;             ///< Type of Bayes tree (e.g. GaussianBayesTree)
    // typedef MyJunctionTree JunctionTreeType;       ///< Type of Junction tree (e.g. GaussianJunctionTree)
    // static pair<shared_ptr<ConditionalType>, shared_ptr<FactorType>
    //   DefaultEliminate(
    //   const MyFactorGraph& factors, const Ordering& keys); ///< The default dense elimination function
  };
 

  template<class FACTOR_GRAPH>
  class EliminateableFactorGraph
  {
  private:
    typedef EliminateableFactorGraph<FACTOR_GRAPH> This; 
    typedef FACTOR_GRAPH FactorGraphType; 
    // Base factor type stored in this graph (private because derived classes will get this from
    // their FactorGraph base class)
    typedef typename EliminationTraits<FactorGraphType>::FactorType _FactorType;
 
  public:
    typedef EliminationTraits<FactorGraphType> EliminationTraitsType;

    typedef typename EliminationTraitsType::ConditionalType ConditionalType;

    typedef typename EliminationTraitsType::BayesNetType BayesNetType;

    typedef typename EliminationTraitsType::EliminationTreeType EliminationTreeType;

    typedef typename EliminationTraitsType::BayesTreeType BayesTreeType;

    typedef typename EliminationTraitsType::JunctionTreeType JunctionTreeType;

    typedef std::pair<std::shared_ptr<ConditionalType>, std::shared_ptr<_FactorType> > EliminationResult;

    typedef std::function<EliminationResult(const FactorGraphType&, const Ordering&)> Eliminate;

    typedef std::optional<std::reference_wrapper<const VariableIndex>> OptionalVariableIndex;

    typedef std::optional<Ordering::OrderingType> OptionalOrderingType;

    IndexedJunctionTree buildIndexedJunctionTree(
        const Ordering& ordering,
        const std::unordered_set<Key>& fixedKeys = {}) const;

    std::shared_ptr<BayesNetType> eliminateSequential(
      OptionalOrderingType orderingType = {},
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesNetType> eliminateSequential(
      const Ordering& ordering,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesTreeType> eliminateMultifrontal(
      OptionalOrderingType orderingType = {},
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesTreeType> eliminateMultifrontal(
      const Ordering& ordering,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesTreeType> eliminateMultifrontal(
        const IndexedJunctionTree& indexedJunctionTree,
        const Eliminate& function = EliminationTraitsType::DefaultEliminate) const;

    std::pair<std::shared_ptr<BayesNetType>, std::shared_ptr<FactorGraphType> >
      eliminatePartialSequential(
      const Ordering& ordering,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::pair<std::shared_ptr<BayesNetType>, std::shared_ptr<FactorGraphType> >
      eliminatePartialSequential(
      const KeyVector& variables,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::pair<std::shared_ptr<BayesTreeType>, std::shared_ptr<FactorGraphType> >
      eliminatePartialMultifrontal(
      const Ordering& ordering,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::pair<std::shared_ptr<BayesTreeType>, std::shared_ptr<FactorGraphType> >
      eliminatePartialMultifrontal(
      const KeyVector& variables,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesNetType> marginalMultifrontalBayesNet(
      const Ordering& variables,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesNetType> marginalMultifrontalBayesNet(
      const KeyVector& variables,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesNetType> marginalMultifrontalBayesNet(
      const Ordering& variables,
      const Ordering& marginalizedVariableOrdering,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesNetType> marginalMultifrontalBayesNet(
      const KeyVector& variables,
      const Ordering& marginalizedVariableOrdering,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesTreeType> marginalMultifrontalBayesTree(
      const Ordering& variables,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesTreeType> marginalMultifrontalBayesTree(
      const KeyVector& variables,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesTreeType> marginalMultifrontalBayesTree(
      const Ordering& variables,
      const Ordering& marginalizedVariableOrdering,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<BayesTreeType> marginalMultifrontalBayesTree(
      const KeyVector& variables,
      const Ordering& marginalizedVariableOrdering,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;

    std::shared_ptr<FactorGraphType> marginal(
      const KeyVector& variables,
      const Eliminate& function = EliminationTraitsType::DefaultEliminate,
      OptionalVariableIndex variableIndex = {}) const;
 
  private:
 
    // Access the derived factor graph class
    const FactorGraphType& asDerived() const { return static_cast<const FactorGraphType&>(*this); }
 
    // Access the derived factor graph class
    FactorGraphType& asDerived() { return static_cast<FactorGraphType&>(*this); }
  };
 
}