DiscreteBayesNet.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/DiscreteConditional.h>
#include <gtsam/discrete/DiscreteDistribution.h>
#include <gtsam/inference/BayesNet.h>
#include <gtsam/inference/FactorGraph.h>
 
#include <memory>
#include <map>
#include <string>
#include <utility>
#include <vector>
 
namespace gtsam {
 
class GTSAM_EXPORT DiscreteBayesNet: public BayesNet<DiscreteConditional> {
 public:
    typedef BayesNet<DiscreteConditional> Base;
    typedef DiscreteBayesNet This;
    typedef DiscreteConditional ConditionalType;
    typedef std::shared_ptr<This> shared_ptr;
    typedef std::shared_ptr<ConditionalType> sharedConditional;
 
 
    DiscreteBayesNet() {}
 
    template <typename ITERATOR>
    DiscreteBayesNet(ITERATOR firstConditional, ITERATOR lastConditional)
        : Base(firstConditional, lastConditional) {}
 
    template <class CONTAINER>
    explicit DiscreteBayesNet(const CONTAINER& conditionals)
        : Base(conditionals) {}
 
    template <class DERIVEDCONDITIONAL>
    DiscreteBayesNet(const FactorGraph<DERIVEDCONDITIONAL>& graph)
        : Base(graph) {}
 
 
 
    bool equals(const This& bn, double tol = 1e-9) const;
 
 
 
    // Add inherited versions of add.
    using Base::add;
 
    void add(const DiscreteKey& key, const std::string& spec) {
      emplace_shared<DiscreteDistribution>(key, spec);
    }
 
    template <typename... Args>
    void add(Args&&... args) {
      emplace_shared<DiscreteConditional>(std::forward<Args>(args)...);
    }
        
    //** evaluate for given DiscreteValues */
    double evaluate(const DiscreteValues & values) const;
 
    //** (Preferred) sugar for the above for given DiscreteValues */
    double operator()(const DiscreteValues & values) const {
      return evaluate(values);
    }
 
    //** log(evaluate(values)) for given DiscreteValues */
    double logProbability(const DiscreteValues & values) const;
 
    DiscreteValues sample(std::mt19937_64* rng = nullptr) const;
 
    DiscreteValues sample(DiscreteValues given,
                          std::mt19937_64* rng = nullptr) const;
 
    DiscreteBayesNet prune(size_t maxNrLeaves,
                           const std::optional<double>& marginalThreshold = {},
                           DiscreteValues* fixedValues = nullptr) const;
 
    DiscreteConditional joint() const;
 
 
    std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                         const DiscreteFactor::Names& names = {}) const;
 
    std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
                     const DiscreteFactor::Names& names = {}) const;
 
 
    using Base::error;     // Expose error(const HybridValues&) method..
    using Base::evaluate;  // Expose evaluate(const HybridValues&) method..
    using Base::logProbability;  // Expose logProbability(const HybridValues&)
 
 
 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(Base);
    }
#endif
  };
 
// traits
template<> struct traits<DiscreteBayesNet> : public Testable<DiscreteBayesNet> {};
 
} // \ namespace gtsam