SymbolicFactorGraph.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/symbolic/SymbolicFactor.h>
#include <gtsam/inference/FactorGraph.h>
#include <gtsam/inference/EliminateableFactorGraph.h>
#include <gtsam/base/types.h>
 
namespace gtsam {
 
  class SymbolicFactorGraph;
  class SymbolicConditional;
  class SymbolicBayesNet;
  class SymbolicEliminationTree;
  class SymbolicBayesTree;
  class SymbolicJunctionTree;
 
  /* ************************************************************************* */
  template<> struct EliminationTraits<SymbolicFactorGraph>
  {
    typedef SymbolicFactor FactorType;                   
    typedef SymbolicFactorGraph FactorGraphType;         
    typedef SymbolicConditional ConditionalType;         
    typedef SymbolicBayesNet BayesNetType;               
    typedef SymbolicEliminationTree EliminationTreeType; 
    typedef SymbolicBayesTree BayesTreeType;             
    typedef SymbolicJunctionTree JunctionTreeType;       
    static std::pair<std::shared_ptr<ConditionalType>, std::shared_ptr<FactorType> >
      DefaultEliminate(const FactorGraphType& factors, const Ordering& keys) {
        return EliminateSymbolic(factors, keys); }
    static Ordering DefaultOrderingFunc(
        const FactorGraphType& graph,
        std::optional<std::reference_wrapper<const VariableIndex>> variableIndex) {
      return Ordering::Colamd((*variableIndex).get());
    }
  };
 
  /* ************************************************************************* */
  class GTSAM_EXPORT SymbolicFactorGraph :
    public FactorGraph<SymbolicFactor>,
    public EliminateableFactorGraph<SymbolicFactorGraph>
  {
  public:
 
    typedef SymbolicFactorGraph This; 
    typedef FactorGraph<SymbolicFactor> Base; 
    typedef EliminateableFactorGraph<This> BaseEliminateable; 
    typedef std::shared_ptr<This> shared_ptr; 
 
 
    SymbolicFactorGraph() {}
 
    template<typename ITERATOR>
    SymbolicFactorGraph(ITERATOR firstFactor, ITERATOR lastFactor) : Base(firstFactor, lastFactor) {}
 
    template<class CONTAINER>
    explicit SymbolicFactorGraph(const CONTAINER& factors) : Base(factors) {}
 
    template<class DERIVEDFACTOR>
    SymbolicFactorGraph(const FactorGraph<DERIVEDFACTOR>& graph) : Base(graph) {}
 
    SymbolicFactorGraph(
        std::initializer_list<std::shared_ptr<SymbolicFactor>> sharedFactors)
        : Base(sharedFactors) {}
 
    SymbolicFactorGraph(SymbolicFactor&& c) {
        emplace_shared<SymbolicFactor>(c);
    }
 
    SymbolicFactorGraph& operator()(SymbolicFactor&& c) {
        emplace_shared<SymbolicFactor>(c);
        return *this;
    }
 
 
 
    bool equals(const This& fg, double tol = 1e-9) const;
 
    void print(
        const std::string& s = "SymbolicFactorGraph",
        const KeyFormatter& formatter = DefaultKeyFormatter) const override {
      Base::print(s, formatter);
    }
 
 
 
    void push_factor(Key key);
 
    void push_factor(Key key1, Key key2);
 
    void push_factor(Key key1, Key key2, Key key3);
 
    void push_factor(Key key1, Key key2, Key key3, Key key4);
 
 
  private:
#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<SymbolicFactorGraph> : public Testable<SymbolicFactorGraph> {
};
 
} //\ namespace gtsam