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/inference/Conditional-inst.h>
#include <gtsam/discrete/DecisionTreeFactor.h>
#include <gtsam/discrete/Signature.h>
 
#include <memory>
#include <string>
#include <vector>
 
namespace gtsam {
 
class GTSAM_EXPORT DiscreteConditional
    : public DecisionTreeFactor,
      public Conditional<DecisionTreeFactor, DiscreteConditional> {
 public:
  // typedefs needed to play nice with gtsam
  typedef DiscreteConditional This;            
  typedef std::shared_ptr<This> shared_ptr;  
  typedef DecisionTreeFactor BaseFactor;  
  typedef Conditional<BaseFactor, This>
      BaseConditional;  
 
  using Values = DiscreteValues;  
 
 
  DiscreteConditional() {}
 
  DiscreteConditional(size_t nFrontals, const DecisionTreeFactor& f);
 
  DiscreteConditional(size_t nFrontals, const DiscreteKeys& keys,
                      const ADT& potentials);
 
  explicit DiscreteConditional(const Signature& signature);
 
  DiscreteConditional(const DiscreteKey& key, const DiscreteKeys& parents,
                      const Signature::Table& table)
      : DiscreteConditional(Signature(key, parents, table)) {}
 
  DiscreteConditional(const DiscreteKey& key, const DiscreteKeys& parents,
                      const std::vector<double>& table)
      : DiscreteConditional(1, DiscreteKeys{key} & parents,
                            ADT(DiscreteKeys{key} & parents, table)) {}
 
  DiscreteConditional(const DiscreteKey& key, const DiscreteKeys& parents,
                      const std::string& spec)
      : DiscreteConditional(Signature(key, parents, spec)) {}
 
  DiscreteConditional(const DiscreteKey& key, const std::string& spec)
      : DiscreteConditional(Signature(key, {}, spec)) {}
 
  DiscreteConditional(const DecisionTreeFactor& joint,
                      const DecisionTreeFactor& marginal);
 
  DiscreteConditional(const DecisionTreeFactor& joint,
                      const DecisionTreeFactor& marginal,
                      const Ordering& orderedKeys);
 
  DiscreteConditional operator*(const DiscreteConditional& other) const;
 
  DiscreteConditional marginal(Key key) const;
 
 
  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;
 
 
  double logProbability(const DiscreteValues& x) const  {
    return -error(x);
  }
 
  void printSignature(
      const std::string& s = "Discrete Conditional: ",
      const KeyFormatter& formatter = DefaultKeyFormatter) const {
    static_cast<const BaseConditional*>(this)->print(s, formatter);
  }
 
  double evaluate(const DiscreteValues& values) const {
    return ADT::operator()(values);
  }
 
  using DecisionTreeFactor::error;       
  using DecisionTreeFactor::operator();  
 
  shared_ptr choose(const DiscreteValues& given) const;
 
  DecisionTreeFactor::shared_ptr likelihood(
      const DiscreteValues& frontalValues) const;
 
  DecisionTreeFactor::shared_ptr likelihood(size_t frontal) const;
 
  size_t sample(const DiscreteValues& parentsValues) const;
 
  size_t sample(size_t parent_value) const;
 
  size_t sample() const;
 
  size_t argmax() const;
 
 
  void sampleInPlace(DiscreteValues* parentsValues) const;
 
  std::vector<DiscreteValues> frontalAssignments() const;
 
  std::vector<DiscreteValues> allAssignments() const;
 
 
  std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                       const Names& names = {}) const override;
 
  std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                   const Names& names = {}) const override;
 
 
 
  double evaluate(const HybridValues& x) const override;
 
  using BaseConditional::operator();  
 
  double logProbability(const HybridValues& x) const override {
    return -error(x);
  }
 
  double logNormalizationConstant() const override { return 0.0; }
 
 
 protected:
  DiscreteConditional::ADT choose(const DiscreteValues& given,
                                  bool forceComplete) const;
 
 private:
#ifdef GTSAM_ENABLE_BOOST_SERIALIZATION
 
  friend class boost::serialization::access;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int /*version*/) {
    ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseFactor);
    ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseConditional);
  }
#endif
};
// DiscreteConditional
 
// traits
template <>
struct traits<DiscreteConditional> : public Testable<DiscreteConditional> {};
 
}  // namespace gtsam