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/inference/FactorGraph.h>
#include <gtsam/inference/EliminateableFactorGraph.h>
#include <gtsam/inference/Ordering.h>
#include <gtsam/discrete/DecisionTreeFactor.h>
#include <gtsam/discrete/DiscreteBayesNet.h>
#include <gtsam/base/FastSet.h>
#include <boost/make_shared.hpp>
 
namespace gtsam {
 
// Forward declarations
class DiscreteFactorGraph;
class DiscreteFactor;
class DiscreteConditional;
class DiscreteBayesNet;
class DiscreteEliminationTree;
class DiscreteBayesTree;
class DiscreteJunctionTree;
 
GTSAM_EXPORT std::pair<boost::shared_ptr<DiscreteConditional>, DecisionTreeFactor::shared_ptr>
EliminateDiscrete(const DiscreteFactorGraph& factors, const Ordering& keys);
 
/* ************************************************************************* */
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<boost::shared_ptr<ConditionalType>, boost::shared_ptr<FactorType> >
  DefaultEliminate(const FactorGraphType& factors, const Ordering& keys) {
    return EliminateDiscrete(factors, keys); }
};
 
/* ************************************************************************* */
class GTSAM_EXPORT DiscreteFactorGraph: public FactorGraph<DiscreteFactor>,
public EliminateableFactorGraph<DiscreteFactorGraph> {
public:
 
  typedef DiscreteFactorGraph This; 
  typedef FactorGraph<DiscreteFactor> Base; 
  typedef EliminateableFactorGraph<This> BaseEliminateable; 
  typedef boost::shared_ptr<This> shared_ptr; 
 
  typedef KeyVector Indices;
  typedef Assignment<Key> Values;
  typedef boost::shared_ptr<Values> sharedValues;
 
  DiscreteFactorGraph() {}
 
  template<typename ITERATOR>
  DiscreteFactorGraph(ITERATOR firstFactor, ITERATOR lastFactor) : Base(firstFactor, lastFactor) {}
 
  template<class CONTAINER>
  explicit DiscreteFactorGraph(const CONTAINER& factors) : Base(factors) {}
 
  template<class DERIVEDFACTOR>
  DiscreteFactorGraph(const FactorGraph<DERIVEDFACTOR>& graph) : Base(graph) {}
 
  virtual ~DiscreteFactorGraph() {}
 
 
  bool equals(const This& fg, double tol = 1e-9) const;
 
 
  template<class SOURCE>
  void add(const DiscreteKey& j, SOURCE table) {
    DiscreteKeys keys;
    keys.push_back(j);
    push_back(boost::make_shared<DecisionTreeFactor>(keys, table));
  }
 
  template<class SOURCE>
  void add(const DiscreteKey& j1, const DiscreteKey& j2, SOURCE table) {
    DiscreteKeys keys;
    keys.push_back(j1);
    keys.push_back(j2);
    push_back(boost::make_shared<DecisionTreeFactor>(keys, table));
  }
 
  template<class SOURCE>
  void add(const DiscreteKeys& keys, SOURCE table) {
    push_back(boost::make_shared<DecisionTreeFactor>(keys, table));
  }
 
  KeySet keys() const;
 
  DecisionTreeFactor product() const;
 
  double operator()(const DiscreteFactor::Values & values) const;
 
  void print(
      const std::string& s = "DiscreteFactorGraph",
      const KeyFormatter& formatter = DefaultKeyFormatter) const override;
 
  DiscreteFactor::sharedValues optimize() const;
 
 
//  /** Permute the variables in the factors */
//  GTSAM_EXPORT void permuteWithInverse(const Permutation& inversePermutation);
//
//  /** Apply a reduction, which is a remapping of variable indices. */
//  GTSAM_EXPORT void reduceWithInverse(const internal::Reduction& inverseReduction);
 
}; // \ DiscreteFactorGraph
 
template<> struct traits<DiscreteFactorGraph> : public Testable<DiscreteFactorGraph> {};
 
} // \ namespace gtsam