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::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