SymbolicFactor.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/inference/Factor.h>
#include <gtsam/inference/Key.h>
#include <gtsam/base/Testable.h>
 
#include <boost/shared_ptr.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/make_shared.hpp>
 
#include <utility>
 
namespace gtsam {
 
  // Forward declarations
  class SymbolicConditional;
  class Ordering;
 
  class GTSAM_EXPORT SymbolicFactor : public Factor {
 
  public:
 
    typedef SymbolicFactor This;
    typedef Factor Base;
    typedef SymbolicConditional ConditionalType;
 
    typedef boost::shared_ptr<This> shared_ptr;
 
 
    SymbolicFactor() {}
 
    explicit SymbolicFactor(Key j) :
      Base(boost::assign::cref_list_of<1>(j)) {}
 
    SymbolicFactor(Key j1, Key j2) :
      Base(boost::assign::cref_list_of<2>(j1)(j2)) {}
 
    SymbolicFactor(Key j1, Key j2, Key j3) :
      Base(boost::assign::cref_list_of<3>(j1)(j2)(j3)) {}
 
    SymbolicFactor(Key j1, Key j2, Key j3, Key j4) :
      Base(boost::assign::cref_list_of<4>(j1)(j2)(j3)(j4)) {}
 
    SymbolicFactor(Key j1, Key j2, Key j3, Key j4, Key j5) :
      Base(boost::assign::cref_list_of<5>(j1)(j2)(j3)(j4)(j5)) {}
 
    SymbolicFactor(Key j1, Key j2, Key j3, Key j4, Key j5, Key j6) :
      Base(boost::assign::cref_list_of<6>(j1)(j2)(j3)(j4)(j5)(j6)) {}
 
    explicit SymbolicFactor(const Factor& factor) : Base(factor.keys()) {}
 
    virtual ~SymbolicFactor() {}
 
    SymbolicFactor::shared_ptr clone() const { return boost::make_shared<This>(*this); }
 
 
 
    bool equals(const This& other, double tol = 1e-9) const;
 
    void print(
        const std::string& s = "SymbolicFactor",
        const KeyFormatter& formatter = DefaultKeyFormatter) const override {
      Base::print(s, formatter);
    }
 
    void printKeys(
        const std::string& s = "SymbolicFactor",
        const KeyFormatter& formatter = DefaultKeyFormatter) const override {
      Base::printKeys(s, formatter);
    }
 
 
  public:
    template<typename KEYITERATOR>
    static SymbolicFactor FromIterators(KEYITERATOR beginKey, KEYITERATOR endKey) {
      return SymbolicFactor(Base::FromIterators(beginKey, endKey));
    }
 
    template<typename KEYITERATOR>
    static SymbolicFactor::shared_ptr FromIteratorsShared(KEYITERATOR beginKey, KEYITERATOR endKey) {
      SymbolicFactor::shared_ptr result = boost::make_shared<SymbolicFactor>();
      result->keys_.assign(beginKey, endKey);
      return result;
    }
 
    template<class CONTAINER>
    static SymbolicFactor FromKeys(const CONTAINER& keys) {
      return SymbolicFactor(Base::FromKeys(keys));
    }
 
    template<class CONTAINER>
    static SymbolicFactor::shared_ptr FromKeysShared(const CONTAINER& keys) {
      return FromIteratorsShared(keys.begin(), keys.end());
    }
 
 
 
    bool empty() const { return keys_.empty(); }
 
    std::pair<boost::shared_ptr<SymbolicConditional>, boost::shared_ptr<SymbolicFactor> >
      eliminate(const Ordering& keys) const;
 
 
  private:
    friend class boost::serialization::access;
    template<class ARCHIVE>
    void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
      ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
    }
  }; // IndexFactor
 
  // Forward declarations
  class SymbolicFactorGraph;
  class Ordering;
 
  GTSAM_EXPORT std::pair<boost::shared_ptr<SymbolicConditional>, boost::shared_ptr<SymbolicFactor> >
    EliminateSymbolic(const SymbolicFactorGraph& factors, const Ordering& keys);
 
  template<>
  struct traits<SymbolicFactor> : public Testable<SymbolicFactor> {
  };
 
} //\ namespace gtsam