HybridGaussianConditional.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/DiscreteConditional.h>
#include <gtsam/discrete/DiscreteKey.h>
#include <gtsam/hybrid/HybridFactor.h>
#include <gtsam/hybrid/HybridGaussianFactor.h>
#include <gtsam/inference/Conditional.h>
#include <gtsam/linear/GaussianConditional.h>
 
namespace gtsam {
 
class HybridValues;

class GTSAM_EXPORT HybridGaussianConditional
    : public HybridGaussianFactor,
      public Conditional<HybridGaussianFactor, HybridGaussianConditional> {
 public:
  using This = HybridGaussianConditional;
  using shared_ptr = std::shared_ptr<This>;
  using BaseFactor = HybridGaussianFactor;
  using BaseConditional = Conditional<BaseFactor, HybridGaussianConditional>;

  using Conditionals = DecisionTree<Key, GaussianConditional::shared_ptr>;
 
 private:
  double negLogConstant_;

  bool pruned_ = false;
 
 public:

  HybridGaussianConditional() = default;

  HybridGaussianConditional(
      const DiscreteKey &discreteParent,
      const std::vector<GaussianConditional::shared_ptr> &conditionals);

  HybridGaussianConditional(
      const DiscreteKey &discreteParent, Key key,
      const std::vector<std::pair<Vector, double>> &parameters);

  HybridGaussianConditional(
      const DiscreteKey &discreteParent, Key key, const Matrix &A, Key parent,
      const std::vector<std::pair<Vector, double>> &parameters);

  HybridGaussianConditional(
      const DiscreteKey &discreteParent, Key key,  //
      const Matrix &A1, Key parent1, const Matrix &A2, Key parent2,
      const std::vector<std::pair<Vector, double>> &parameters);

  HybridGaussianConditional(const DiscreteKeys &discreteParents,
                            const Conditionals &conditionals);

  HybridGaussianConditional(const DiscreteKeys &discreteParents,
                            const FactorValuePairs &pairs, bool pruned = false);


  bool equals(const HybridFactor &lf, double tol = 1e-9) const override;

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


  GaussianConditional::shared_ptr choose(
      const DiscreteValues &discreteValues) const;

  GaussianConditional::shared_ptr operator()(
      const DiscreteValues &discreteValues) const {
    return choose(discreteValues);
  }

  size_t nrComponents() const;

  KeyVector continuousParents() const;

  inline double negLogConstant() const override { return negLogConstant_; }

  std::shared_ptr<HybridGaussianFactor> likelihood(
      const VectorValues &given) const;

  const Conditionals conditionals() const;

  double logProbability(const HybridValues &values) const override;

  double evaluate(const HybridValues &values) const override;

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

  HybridGaussianConditional::shared_ptr prune(
      const DiscreteConditional &discreteProbs) const;

  bool pruned() const { return pruned_; }

  std::shared_ptr<Factor> restrict(
      const DiscreteValues &discreteValues) const override;

 
 private:
  struct Helper;

  HybridGaussianConditional(const DiscreteKeys &discreteParents,
                            Helper &&helper, bool pruned = false);

  bool allFrontalsGiven(const VectorValues &given) const;
 
#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(BaseFactor);
    ar &BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseConditional);
  }
#endif
};

std::set<DiscreteKey> DiscreteKeysAsSet(const DiscreteKeys &discreteKeys);
 
// traits
template <>
struct traits<HybridGaussianConditional>
    : public Testable<HybridGaussianConditional> {};
 
}  // namespace gtsam