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