DiscreteFactorGraph.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 <gtsam/discrete/DecisionTreeFactor.h>
#include <gtsam/discrete/DiscreteLookupDAG.h>
#include <gtsam/inference/EliminateableFactorGraph.h>
#include <gtsam/inference/FactorGraph.h>
#include <gtsam/inference/Ordering.h>
#include <gtsam/base/FastSet.h>
 
#include <string>
#include <utility>
#include <vector>
 
namespace gtsam {
 
// Forward declarations
class DiscreteFactorGraph;
class DiscreteConditional;
class DiscreteBayesNet;
class DiscreteEliminationTree;
class DiscreteBayesTree;
class DiscreteJunctionTree;
 
GTSAM_EXPORT
std::pair<DiscreteConditional::shared_ptr, DiscreteFactor::shared_ptr>
EliminateDiscrete(const DiscreteFactorGraph& factors,
                  const Ordering& frontalKeys);
 
GTSAM_EXPORT
std::pair<DiscreteConditional::shared_ptr, DiscreteFactor::shared_ptr>
EliminateForMPE(const DiscreteFactorGraph& factors,
                const Ordering& frontalKeys);
 
template<> struct EliminationTraits<DiscreteFactorGraph>
{
  typedef DiscreteFactor FactorType;                   
  typedef DiscreteFactorGraph FactorGraphType;         
  typedef DiscreteConditional ConditionalType;         
  typedef DiscreteBayesNet BayesNetType;               
  typedef DiscreteEliminationTree EliminationTreeType; 
  typedef DiscreteBayesTree BayesTreeType;             
  typedef DiscreteJunctionTree JunctionTreeType;       
  
  static std::pair<std::shared_ptr<ConditionalType>,
                   std::shared_ptr<FactorType> >
  DefaultEliminate(const FactorGraphType& factors, const Ordering& keys) {
    return EliminateDiscrete(factors, keys);
  }
  
  static Ordering DefaultOrderingFunc(
      const FactorGraphType& graph,
      std::optional<std::reference_wrapper<const VariableIndex>> variableIndex) {
    return Ordering::Colamd((*variableIndex).get());
  }
};
 
class GTSAM_EXPORT DiscreteFactorGraph
    : public FactorGraph<DiscreteFactor>,
      public EliminateableFactorGraph<DiscreteFactorGraph> {
 public:
  using This = DiscreteFactorGraph;          
  using Base = FactorGraph<DiscreteFactor>;  
  using BaseEliminateable =
      EliminateableFactorGraph<This>;          
  using shared_ptr = std::shared_ptr<This>;  
 
  using Values = DiscreteValues;  
 
  using Indices = KeyVector;  
 
  DiscreteFactorGraph() {}
 
  template <typename ITERATOR>
  DiscreteFactorGraph(ITERATOR firstFactor, ITERATOR lastFactor)
      : Base(firstFactor, lastFactor) {}
 
  template <class CONTAINER>
  explicit DiscreteFactorGraph(const CONTAINER& factors) : Base(factors) {}
 
  template <class DERIVED_FACTOR>
  DiscreteFactorGraph(const FactorGraph<DERIVED_FACTOR>& graph) : Base(graph) {}
 
 
  bool equals(const This& fg, double tol = 1e-9) const;
 
 
  template <typename... Args>
  void add(Args&&... args) {
    emplace_shared<DecisionTreeFactor>(std::forward<Args>(args)...);
  }
 
  KeySet keys() const;
 
  DiscreteKeys discreteKeys() const;
 
  DecisionTreeFactor product() const;
 
  double operator()(const DiscreteValues& values) const;
 
  void print(
      const std::string& s = "DiscreteFactorGraph",
      const KeyFormatter& formatter = DefaultKeyFormatter) const override;
 
  DiscreteBayesNet sumProduct(
      OptionalOrderingType orderingType = {}) const;
 
  DiscreteBayesNet sumProduct(const Ordering& ordering) const;
 
  DiscreteLookupDAG maxProduct(
      OptionalOrderingType orderingType = {}) const;
 
  DiscreteLookupDAG maxProduct(const Ordering& ordering) const;
 
  DiscreteValues optimize(
      OptionalOrderingType orderingType = {}) const;
 
  DiscreteValues optimize(const Ordering& ordering) const;
 
 
  std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                       const DiscreteFactor::Names& names = {}) const;
 
  std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                   const DiscreteFactor::Names& names = {}) const;
 
 
  using Base::error;  // Expose error(const HybridValues&) method..
 
};  // \ DiscreteFactorGraph
 
template <>
struct traits<DiscreteFactorGraph> : public Testable<DiscreteFactorGraph> {};
 
}  // namespace gtsam