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 <memory>
 
#include <utility>
 
namespace gtsam {
 
  // Forward declarations
  class SymbolicConditional;
  class HybridValues;
  class Ordering;

  class GTSAM_EXPORT SymbolicFactor : public Factor {
 
  public:
 
    typedef SymbolicFactor This;
    typedef Factor Base;
    typedef SymbolicConditional ConditionalType;

    typedef std::shared_ptr<This> shared_ptr;


    SymbolicFactor() {}

    explicit SymbolicFactor(Key j) :
      Base(KeyVector{j}) {}

    SymbolicFactor(Key j1, Key j2) :
      Base(KeyVector{j1, j2}) {}

    SymbolicFactor(Key j1, Key j2, Key j3) :
      Base(KeyVector{j1, j2, j3}) {}

    SymbolicFactor(Key j1, Key j2, Key j3, Key j4) :
      Base(KeyVector{j1, j2, j3, j4}) {}

    SymbolicFactor(Key j1, Key j2, Key j3, Key j4, Key j5) :
      Base(KeyVector{j1, j2, j3, j4, j5}) {}

    SymbolicFactor(Key j1, Key j2, Key j3, Key j4, Key j5, Key j6) :
      Base(KeyVector{j1, j2, j3, j4, j5, j6}) {}

    explicit SymbolicFactor(const Factor& factor) : Base(factor.keys()) {}

    SymbolicFactor::shared_ptr clone() const { return std::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);
    }

  
    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 = std::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());
    }



    double error(const HybridValues& c) const override;

    std::pair<std::shared_ptr<SymbolicConditional>, std::shared_ptr<SymbolicFactor> >
      eliminate(const Ordering& keys) const;

 
  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
  }; // IndexFactor
 
  // Forward declarations
  class SymbolicFactorGraph;
  class Ordering;

  GTSAM_EXPORT std::pair<std::shared_ptr<SymbolicConditional>, std::shared_ptr<SymbolicFactor> >
    EliminateSymbolic(const SymbolicFactorGraph& factors, const Ordering& keys);

  template<>
  struct traits<SymbolicFactor> : public Testable<SymbolicFactor> {
  };
 
} //\ namespace gtsam