HybridBayesNet.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/DiscreteBayesNet.h>
#include <gtsam/global_includes.h>
#include <gtsam/hybrid/HybridConditional.h>
#include <gtsam/hybrid/HybridValues.h>
#include <gtsam/inference/BayesNet.h>
#include <gtsam/linear/GaussianBayesNet.h>
 
namespace gtsam {

class GTSAM_EXPORT HybridBayesNet : public BayesNet<HybridConditional> {
 public:
  using Base = BayesNet<HybridConditional>;
  using This = HybridBayesNet;
  using ConditionalType = HybridConditional;
  using shared_ptr = std::shared_ptr<HybridBayesNet>;
  using sharedConditional = std::shared_ptr<ConditionalType>;


  HybridBayesNet() = default;

  HybridBayesNet(
      std::initializer_list<HybridConditional::shared_ptr> conditionals)
      : Base(conditionals) {}


  void print(const std::string &s = "", const KeyFormatter &formatter =
                                            DefaultKeyFormatter) const override;

  bool equals(const This &fg, double tol = 1e-9) const;


  void push_back(std::shared_ptr<HybridConditional> conditional) {
    factors_.push_back(conditional);
  }

  void push_back(HybridConditional &&conditional) {
    factors_.push_back(
        std::make_shared<HybridConditional>(std::move(conditional)));
  }

  template <class CONDITIONAL>
  void push_back(const std::shared_ptr<CONDITIONAL> &conditional) {
    factors_.push_back(std::make_shared<HybridConditional>(conditional));
  }

  template <class CONDITIONAL, class... Args>
  void emplace_shared(Args &&...args) {
    auto cond = std::allocate_shared<CONDITIONAL>(
        Eigen::aligned_allocator<CONDITIONAL>(), std::forward<Args>(args)...);
    factors_.push_back(std::make_shared<HybridConditional>(std::move(cond)));
  }

  DiscreteBayesNet discreteMarginal() const;

  GaussianBayesNet choose(const DiscreteValues &assignment) const;

  double evaluate(const HybridValues &values) const;

  double operator()(const HybridValues &values) const {
    return evaluate(values);
  }

  DiscreteValues mpe() const;

  HybridValues optimize() const;

  VectorValues optimize(const DiscreteValues &assignment) const;

  HybridValues sample(const HybridValues &given,
                      std::mt19937_64 *rng = nullptr) const;

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

  HybridBayesNet prune(size_t maxNrLeaves,
                       const std::optional<double> &marginalThreshold = {},
                       DiscreteValues *fixedValues = nullptr) const;

  using Base::error;

  AlgebraicDecisionTree<Key> errorTree(
      const VectorValues &continuousValues) const;
 
  using BayesNet::logProbability;  // expose HybridValues version

  double negLogConstant(const std::optional<DiscreteValues>& discrete = {}) const;

  AlgebraicDecisionTree<Key> discretePosterior(
      const VectorValues &continuousValues) const;

  HybridGaussianFactorGraph toFactorGraph(
      const VectorValues &measurements) 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(Base);
  }
#endif
};

template <>
struct traits<HybridBayesNet> : public Testable<HybridBayesNet> {};
 
}  // namespace gtsam