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/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;


  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);
  }

  template <class Conditional>
  void emplace_back(Conditional *conditional) {
    factors_.push_back(std::make_shared<HybridConditional>(
        std::shared_ptr<Conditional>(conditional)));
  }

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

  GaussianBayesNet choose(const DiscreteValues &assignment) const;

  double evaluate(const HybridValues &values) const;

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

  HybridValues optimize() const;

  VectorValues optimize(const DiscreteValues &assignment) const;

  DecisionTreeFactor::shared_ptr discreteConditionals() const;

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

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

  HybridValues sample(const HybridValues &given) const;

  HybridValues sample() const;

  HybridBayesNet prune(size_t maxNrLeaves);

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

  using BayesNet::logProbability;  // expose HybridValues version

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

  HybridGaussianFactorGraph toFactorGraph(
      const VectorValues &measurements) const;

 private:
  void updateDiscreteConditionals(const DecisionTreeFactor &prunedDecisionTree);

#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(Base);
  }
#endif
};

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

}  // namespace gtsam