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-inst.h>
 
#include <memory>
#include <random>  // for std::mt19937_64
#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 DiscreteFactor& 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);
 
  using DecisionTreeFactor::operator*;

  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);
  }
 
  using BaseFactor::error;       
  using BaseFactor::evaluate;    
  using BaseFactor::operator();  

  shared_ptr choose(const DiscreteValues& given) const;

  DecisionTreeFactor::shared_ptr likelihood(
      const DiscreteValues& frontalValues) const;

  DecisionTreeFactor::shared_ptr likelihood(size_t frontal) const;

  virtual size_t sample(const DiscreteValues& parentsValues,
                        std::mt19937_64* rng = nullptr) const;

  size_t sample(size_t parent_value, std::mt19937_64* rng = nullptr) const;

  size_t sample(std::mt19937_64* rng = nullptr) const;

  size_t argmax(const DiscreteValues& parentsValues = DiscreteValues()) const;

  virtual DiscreteFactor::shared_ptr max(const Ordering& keys) const override;


  void sampleInPlace(DiscreteValues* parentsValues,
                     std::mt19937_64* rng = nullptr) 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 negLogConstant() const override;

  virtual void prune(size_t maxNrAssignments);

  void removeDiscreteModes(const DiscreteValues& given);

 
 protected:
  DiscreteConditional::ADT choose(const DiscreteValues& given,
                                  bool forceComplete) const;
 
 private:
#if 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