DiscreteConditional.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/Signature.h>
#include <gtsam/inference/Conditional.h>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
 
#include <string>
 
namespace gtsam {
 
class GTSAM_EXPORT DiscreteConditional: public DecisionTreeFactor,
    public Conditional<DecisionTreeFactor, DiscreteConditional> {
 
public:
  // typedefs needed to play nice with gtsam
  typedef DiscreteConditional This; 
  typedef boost::shared_ptr<This> shared_ptr; 
  typedef DecisionTreeFactor BaseFactor; 
  typedef Conditional<BaseFactor, This> BaseConditional; 
 
  typedef Assignment<Key> Values;
  typedef boost::shared_ptr<Values> sharedValues;
 
 
  DiscreteConditional() {
  }
 
  DiscreteConditional(size_t nFrontals, const DecisionTreeFactor& f);
 
  DiscreteConditional(const Signature& signature);
 
  DiscreteConditional(const DecisionTreeFactor& joint,
      const DecisionTreeFactor& marginal);
 
  DiscreteConditional(const DecisionTreeFactor& joint,
      const DecisionTreeFactor& marginal, const Ordering& orderedKeys);
 
  template<typename ITERATOR>
  static shared_ptr Combine(ITERATOR firstConditional,
      ITERATOR lastConditional);
 
 
  void print(const std::string& s = "Discrete Conditional: ",
      const KeyFormatter& formatter = DefaultKeyFormatter) const override;
 
  bool equals(const DiscreteFactor& other, double tol = 1e-9) const override;
 
 
  void printSignature(
      const std::string& s = "Discrete Conditional: ",
      const KeyFormatter& formatter = DefaultKeyFormatter) const {
    static_cast<const BaseConditional*>(this)->print(s, formatter);
  }
 
  double operator()(const Values& values) const override {
    return Potentials::operator()(values);
  }
 
  DecisionTreeFactor::shared_ptr toFactor() const {
    return DecisionTreeFactor::shared_ptr(new DecisionTreeFactor(*this));
  }
 
  ADT choose(const Assignment<Key>& parentsValues) const;
 
  size_t solve(const Values& parentsValues) const;
 
  size_t sample(const Values& parentsValues) const;
 
 
  void solveInPlace(Values& parentsValues) const;
 
  void sampleInPlace(Values& parentsValues) const;
 
 
};
// DiscreteConditional
 
// traits
template<> struct traits<DiscreteConditional> : public Testable<DiscreteConditional> {};
 
/* ************************************************************************* */
template<typename ITERATOR>
DiscreteConditional::shared_ptr DiscreteConditional::Combine(
    ITERATOR firstConditional, ITERATOR lastConditional) {
  // TODO:  check for being a clique
 
  // multiply all the potentials of the given conditionals
  size_t nrFrontals = 0;
  DecisionTreeFactor product;
  for (ITERATOR it = firstConditional; it != lastConditional;
      ++it, ++nrFrontals) {
    DiscreteConditional::shared_ptr c = *it;
    DecisionTreeFactor::shared_ptr factor = c->toFactor();
    product = (*factor) * product;
  }
  // and then create a new multi-frontal conditional
  return boost::make_shared<DiscreteConditional>(nrFrontals, product);
}
 
} // gtsam