GaussianBayesNet.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
 
 * -------------------------------------------------------------------------- */
 
// \callgraph
 
#pragma once
 
#include <gtsam/linear/GaussianConditional.h>
#include <gtsam/inference/BayesNet.h>
#include <gtsam/inference/FactorGraph.h>
#include <gtsam/global_includes.h>
 
#include <utility>
namespace gtsam {
 
  class GTSAM_EXPORT GaussianBayesNet: public BayesNet<GaussianConditional>
  {
  public:
 
    typedef BayesNet<GaussianConditional> Base;
    typedef GaussianBayesNet This;
    typedef GaussianConditional ConditionalType;
    typedef std::shared_ptr<This> shared_ptr;
    typedef std::shared_ptr<ConditionalType> sharedConditional;
 
 
    GaussianBayesNet() {}
 
    template <typename ITERATOR>
    GaussianBayesNet(ITERATOR firstConditional, ITERATOR lastConditional)
        : Base(firstConditional, lastConditional) {}
 
    template <class CONTAINER>
    explicit GaussianBayesNet(const CONTAINER& conditionals) {
      push_back(conditionals);
    }
 
    template <class DERIVEDCONDITIONAL>
    explicit GaussianBayesNet(const FactorGraph<DERIVEDCONDITIONAL>& graph)
        : Base(graph) {}
 
    template <class DERIVEDCONDITIONAL>
    GaussianBayesNet(
        std::initializer_list<std::shared_ptr<DERIVEDCONDITIONAL> > conditionals)
        : Base(conditionals) {}
 
 
 
    bool equals(const This& bn, double tol = 1e-9) const;
 
    friend bool operator==(const GaussianBayesNet& lhs,
                           const GaussianBayesNet& rhs) {
      return lhs.isEqual(rhs);
    }
 
    void print(
        const std::string& s = "",
        const KeyFormatter& formatter = DefaultKeyFormatter) const override {
      Base::print(s, formatter);
    }
 
 
 
    double error(const VectorValues& x) const;
 
    double logProbability(const VectorValues& x) const;
 
    double evaluate(const VectorValues& x) const;
 
    double operator()(const VectorValues& x) const {
      return evaluate(x);
    }
 
    VectorValues optimize() const;
 
    VectorValues optimize(const VectorValues& given) const;
 
    VectorValues sample(std::mt19937_64* rng) const;
 
    VectorValues sample(const VectorValues& given, std::mt19937_64* rng) const;
 
    VectorValues sample() const;
 
    VectorValues sample(const VectorValues& given) const;
 
    Ordering ordering() const;
 
 
 
    std::pair<Matrix, Vector> matrix(const Ordering& ordering) const;
 
    std::pair<Matrix, Vector> matrix() const;
 
    VectorValues optimizeGradientSearch() const;
 
    VectorValues gradient(const VectorValues& x0) const;
 
    VectorValues gradientAtZero() const;
 
    double determinant() const;
 
    double logDeterminant() const;
 
    double negLogConstant() const;
 
    VectorValues backSubstitute(const VectorValues& gx) const;
 
    VectorValues backSubstituteTranspose(const VectorValues& gx) const;
 
 
    using Base::evaluate; // Expose evaluate(const HybridValues&) method..
    using Base::logProbability; // Expose logProbability(const HybridValues&) method..
    using Base::error; // Expose error(const HybridValues&) method..
 
 
  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<GaussianBayesNet> : public Testable<GaussianBayesNet> {
  };
 
} //\ namespace gtsam