gtsam  4.1.0
gtsam
SymbolicFactor.h
Go to the documentation of this file.
1 /* ----------------------------------------------------------------------------
2 
3  * GTSAM Copyright 2010, Georgia Tech Research Corporation,
4  * Atlanta, Georgia 30332-0415
5  * All Rights Reserved
6  * Authors: Frank Dellaert, et al. (see THANKS for the full author list)
7 
8  * See LICENSE for the license information
9 
10  * -------------------------------------------------------------------------- */
11 
18 #pragma once
19 
20 #include <gtsam/inference/Factor.h>
21 #include <gtsam/inference/Key.h>
22 #include <gtsam/base/Testable.h>
23 
24 #include <boost/shared_ptr.hpp>
25 #include <boost/assign/list_of.hpp>
26 #include <boost/make_shared.hpp>
27 
28 #include <utility>
29 
30 namespace gtsam {
31 
32  // Forward declarations
33  class SymbolicConditional;
34  class Ordering;
35 
39  class GTSAM_EXPORT SymbolicFactor : public Factor {
40 
41  public:
42 
43  typedef SymbolicFactor This;
44  typedef Factor Base;
46 
48  typedef boost::shared_ptr<This> shared_ptr;
49 
52 
55 
57  explicit SymbolicFactor(Key j) :
58  Base(boost::assign::cref_list_of<1>(j)) {}
59 
62  Base(boost::assign::cref_list_of<2>(j1)(j2)) {}
63 
65  SymbolicFactor(Key j1, Key j2, Key j3) :
66  Base(boost::assign::cref_list_of<3>(j1)(j2)(j3)) {}
67 
69  SymbolicFactor(Key j1, Key j2, Key j3, Key j4) :
70  Base(boost::assign::cref_list_of<4>(j1)(j2)(j3)(j4)) {}
71 
73  SymbolicFactor(Key j1, Key j2, Key j3, Key j4, Key j5) :
74  Base(boost::assign::cref_list_of<5>(j1)(j2)(j3)(j4)(j5)) {}
75 
77  SymbolicFactor(Key j1, Key j2, Key j3, Key j4, Key j5, Key j6) :
78  Base(boost::assign::cref_list_of<6>(j1)(j2)(j3)(j4)(j5)(j6)) {}
79 
81  explicit SymbolicFactor(const Factor& factor) : Base(factor.keys()) {}
82 
83  virtual ~SymbolicFactor() {}
84 
86  SymbolicFactor::shared_ptr clone() const { return boost::make_shared<This>(*this); }
87 
89 
92 
93  bool equals(const This& other, double tol = 1e-9) const;
94 
96 
99  public:
101  template<typename KEYITERATOR>
102  static SymbolicFactor FromIterators(KEYITERATOR beginKey, KEYITERATOR endKey) {
103  return SymbolicFactor(Base::FromIterators(beginKey, endKey));
104  }
105 
107  template<typename KEYITERATOR>
108  static SymbolicFactor::shared_ptr FromIteratorsShared(KEYITERATOR beginKey, KEYITERATOR endKey) {
109  SymbolicFactor::shared_ptr result = boost::make_shared<SymbolicFactor>();
110  result->keys_.assign(beginKey, endKey);
111  return result;
112  }
113 
116  template<class CONTAINER>
117  static SymbolicFactor FromKeys(const CONTAINER& keys) {
118  return SymbolicFactor(Base::FromKeys(keys));
119  }
120 
123  template<class CONTAINER>
124  static SymbolicFactor::shared_ptr FromKeysShared(const CONTAINER& keys) {
125  return FromIteratorsShared(keys.begin(), keys.end());
126  }
127 
129 
132 
134  bool empty() const { return keys_.empty(); }
135 
138  std::pair<boost::shared_ptr<SymbolicConditional>, boost::shared_ptr<SymbolicFactor> >
139  eliminate(const Ordering& keys) const;
140 
142 
143  private:
145  friend class boost::serialization::access;
146  template<class ARCHIVE>
147  void serialize(ARCHIVE & ar, const unsigned int /*version*/) {
148  ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Base);
149  }
150  }; // IndexFactor
151 
152  // Forward declarations
153  class SymbolicFactorGraph;
154  class Ordering;
155 
160  GTSAM_EXPORT std::pair<boost::shared_ptr<SymbolicConditional>, boost::shared_ptr<SymbolicFactor> >
161  EliminateSymbolic(const SymbolicFactorGraph& factors, const Ordering& keys);
162 
164  template<>
165  struct traits<SymbolicFactor> : public Testable<SymbolicFactor> {
166  };
167 
168 } //\ namespace gtsam
169 
Testable.h
Concept check for values that can be used in unit tests.
gtsam::equals
Template to create a binary predicate.
Definition: Testable.h:110
gtsam::Ordering
Definition: Ordering.h:34
gtsam::SymbolicFactor::SymbolicFactor
SymbolicFactor()
Default constructor for I/O.
Definition: SymbolicFactor.h:54
gtsam::traits
A manifold defines a space in which there is a notion of a linear tangent space that can be centered ...
Definition: concepts.h:30
gtsam::SymbolicConditional
SymbolicConditional is a conditional with keys but no probability data, produced by symbolic eliminat...
Definition: SymbolicConditional.h:38
gtsam::Key
std::uint64_t Key
Integer nonlinear key type.
Definition: types.h:61
gtsam::SymbolicFactor::empty
bool empty() const
Whether the factor is empty (involves zero variables).
Definition: SymbolicFactor.h:134
gtsam::EliminateSymbolic
std::pair< boost::shared_ptr< SymbolicConditional >, boost::shared_ptr< SymbolicFactor > > EliminateSymbolic(const SymbolicFactorGraph &factors, const Ordering &keys)
Dense elimination function for symbolic factors.
Definition: SymbolicFactor.cpp:31
gtsam::SymbolicFactor::SymbolicFactor
SymbolicFactor(Key j1, Key j2, Key j3, Key j4)
Construct 4-way factor.
Definition: SymbolicFactor.h:69
gtsam::SymbolicFactor::SymbolicFactor
SymbolicFactor(const Factor &factor)
Create symbolic version of any factor.
Definition: SymbolicFactor.h:81
gtsam::SymbolicFactor::clone
SymbolicFactor::shared_ptr clone() const
Copy this object as its actual derived type.
Definition: SymbolicFactor.h:86
gtsam::SymbolicFactor::SymbolicFactor
SymbolicFactor(Key j1, Key j2, Key j3, Key j4, Key j5, Key j6)
Construct 6-way factor.
Definition: SymbolicFactor.h:77
gtsam::serialize
std::string serialize(const T &input)
serializes to a string
Definition: serialization.h:100
gtsam::SymbolicFactor::FromKeysShared
static SymbolicFactor::shared_ptr FromKeysShared(const CONTAINER &keys)
Constructor from a collection of keys - compatible with boost::assign::list_of and boost::assign::cre...
Definition: SymbolicFactor.h:124
gtsam::SymbolicFactor::FromKeys
static SymbolicFactor FromKeys(const CONTAINER &keys)
Constructor from a collection of keys - compatible with boost::assign::list_of and boost::assign::cre...
Definition: SymbolicFactor.h:117
gtsam::SymbolicFactor::SymbolicFactor
SymbolicFactor(Key j1, Key j2, Key j3)
Construct ternary factor.
Definition: SymbolicFactor.h:65
gtsam
Global functions in a separate testing namespace.
Definition: chartTesting.h:28
gtsam::Testable
A helper that implements the traits interface for GTSAM types.
Definition: Testable.h:150
Factor.h
The base class for all factors.
gtsam::SymbolicFactor
SymbolicFactor represents a symbolic factor that specifies graph topology but is not associated with ...
Definition: SymbolicFactor.h:39
Key.h
gtsam::SymbolicFactor::FromIteratorsShared
static SymbolicFactor::shared_ptr FromIteratorsShared(KEYITERATOR beginKey, KEYITERATOR endKey)
Constructor from a collection of keys.
Definition: SymbolicFactor.h:108
gtsam::Factor
This is the base class for all factor types.
Definition: Factor.h:55
gtsam::SymbolicFactor::SymbolicFactor
SymbolicFactor(Key j1, Key j2, Key j3, Key j4, Key j5)
Construct 5-way factor.
Definition: SymbolicFactor.h:73
gtsam::SymbolicFactor::SymbolicFactor
SymbolicFactor(Key j)
Construct unary factor.
Definition: SymbolicFactor.h:57
gtsam::SymbolicFactor::shared_ptr
boost::shared_ptr< This > shared_ptr
Overriding the shared_ptr typedef.
Definition: SymbolicFactor.h:48
gtsam::SymbolicFactor::SymbolicFactor
SymbolicFactor(Key j1, Key j2)
Construct binary factor.
Definition: SymbolicFactor.h:61
gtsam::SymbolicFactor::FromIterators
static SymbolicFactor FromIterators(KEYITERATOR beginKey, KEYITERATOR endKey)
Constructor from a collection of keys.
Definition: SymbolicFactor.h:102