GaussianMixture.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/DecisionTree-inl.h>
#include <gtsam/discrete/DecisionTree.h>
#include <gtsam/discrete/DecisionTreeFactor.h>
#include <gtsam/discrete/DiscreteKey.h>
#include <gtsam/hybrid/GaussianMixtureFactor.h>
#include <gtsam/hybrid/HybridFactor.h>
#include <gtsam/inference/Conditional.h>
#include <gtsam/linear/GaussianConditional.h>
 
namespace gtsam {
 
class HybridValues;
 
class GTSAM_EXPORT GaussianMixture
    : public HybridFactor,
      public Conditional<HybridFactor, GaussianMixture> {
 public:
  using This = GaussianMixture;
  using shared_ptr = std::shared_ptr<GaussianMixture>;
  using BaseFactor = HybridFactor;
  using BaseConditional = Conditional<HybridFactor, GaussianMixture>;
 
  using Conditionals = DecisionTree<Key, GaussianConditional::shared_ptr>;
 
 private:
  Conditionals conditionals_;  
  double logConstant_;         
 
  GaussianFactorGraphTree asGaussianFactorGraphTree() const;
 
  std::function<GaussianConditional::shared_ptr(
      const Assignment<Key> &, const GaussianConditional::shared_ptr &)>
  prunerFunc(const DecisionTreeFactor &discreteProbs);
 
 public:
 
  GaussianMixture() = default;
 
  GaussianMixture(const KeyVector &continuousFrontals,
                  const KeyVector &continuousParents,
                  const DiscreteKeys &discreteParents,
                  const Conditionals &conditionals);
 
  GaussianMixture(KeyVector &&continuousFrontals, KeyVector &&continuousParents,
                  DiscreteKeys &&discreteParents,
                  std::vector<GaussianConditional::shared_ptr> &&conditionals);
 
  GaussianMixture(
      const KeyVector &continuousFrontals, const KeyVector &continuousParents,
      const DiscreteKeys &discreteParents,
      const std::vector<GaussianConditional::shared_ptr> &conditionals);
 
 
  bool equals(const HybridFactor &lf, double tol = 1e-9) const override;
 
  void print(
      const std::string &s = "GaussianMixture\n",
      const KeyFormatter &formatter = DefaultKeyFormatter) const override;
 
 
  GaussianConditional::shared_ptr operator()(
      const DiscreteValues &discreteValues) const;
 
  size_t nrComponents() const;
 
  KeyVector continuousParents() const;
 
  double logNormalizationConstant() const override { return logConstant_; }
 
  std::shared_ptr<GaussianMixtureFactor> likelihood(
      const VectorValues &given) const;
 
  const Conditionals &conditionals() const;
 
  AlgebraicDecisionTree<Key> logProbability(
      const VectorValues &continuousValues) const;
 
  double error(const HybridValues &values) const override;
 
  AlgebraicDecisionTree<Key> errorTree(const VectorValues &continuousValues) const;
 
  double logProbability(const HybridValues &values) const override;
 
  double evaluate(const HybridValues &values) const override;
 
  double operator()(const HybridValues &values) const {
    return evaluate(values);
  }
 
  void prune(const DecisionTreeFactor &discreteProbs);
 
  GaussianFactorGraphTree add(const GaussianFactorGraphTree &sum) const;
 
 private:
  bool allFrontalsGiven(const VectorValues &given) const;
 
#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);
    ar &BOOST_SERIALIZATION_NVP(conditionals_);
  }
#endif
};
 
std::set<DiscreteKey> DiscreteKeysAsSet(const DiscreteKeys &discreteKeys);
 
// traits
template <>
struct traits<GaussianMixture> : public Testable<GaussianMixture> {};
 
}  // namespace gtsam