gtsam 4.2.0
gtsam
Loading...
Searching...
No Matches
HybridConditional.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
25#include <gtsam/inference/Key.h>
27
28#include <boost/make_shared.hpp>
29#include <boost/shared_ptr.hpp>
30#include <stdexcept>
31#include <string>
32#include <typeinfo>
33#include <vector>
34
35namespace gtsam {
36
60class GTSAM_EXPORT HybridConditional
61 : public HybridFactor,
62 public Conditional<HybridFactor, HybridConditional> {
63 public:
64 // typedefs needed to play nice with gtsam
66 typedef boost::shared_ptr<This> shared_ptr;
70
71 protected:
73 boost::shared_ptr<Factor> inner_;
74
75 public:
78
80 HybridConditional() = default;
81
89 HybridConditional(const KeyVector& continuousKeys,
90 const DiscreteKeys& discreteKeys, size_t nFrontals)
91 : BaseFactor(continuousKeys, discreteKeys), BaseConditional(nFrontals) {}
92
102 HybridConditional(const KeyVector& continuousFrontals,
103 const DiscreteKeys& discreteFrontals,
104 const KeyVector& continuousParents,
105 const DiscreteKeys& discreteParents);
106
114 const boost::shared_ptr<GaussianConditional>& continuousConditional);
115
123 const boost::shared_ptr<DiscreteConditional>& discreteConditional);
124
131 HybridConditional(const boost::shared_ptr<GaussianMixture>& gaussianMixture);
132
136
138 void print(
139 const std::string& s = "Hybrid Conditional: ",
140 const KeyFormatter& formatter = DefaultKeyFormatter) const override;
141
143 bool equals(const HybridFactor& other, double tol = 1e-9) const override;
144
148
154 GaussianMixture::shared_ptr asMixture() const {
155 return boost::dynamic_pointer_cast<GaussianMixture>(inner_);
156 }
157
164 return boost::dynamic_pointer_cast<GaussianConditional>(inner_);
165 }
166
173 return boost::dynamic_pointer_cast<DiscreteConditional>(inner_);
174 }
175
177 boost::shared_ptr<Factor> inner() const { return inner_; }
178
180 double error(const HybridValues& values) const override;
181
183 double logProbability(const HybridValues& values) const override;
184
190 double logNormalizationConstant() const override;
191
193 double evaluate(const HybridValues& values) const override;
194
196 bool frontalsIn(const VectorValues& measurements) const {
197 for (Key key : frontals()) {
198 if (!measurements.exists(key)) {
199 return false;
200 }
201 }
202 return true;
203 }
204
206
207 private:
209 friend class boost::serialization::access;
210 template <class Archive>
211 void serialize(Archive& ar, const unsigned int /*version*/) {
212 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseFactor);
213 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseConditional);
214 ar& BOOST_SERIALIZATION_NVP(inner_);
215
216 // register the various casts based on the type of inner_
217 // https://www.boost.org/doc/libs/1_80_0/libs/serialization/doc/serialization.html#runtimecasting
218 if (isDiscrete()) {
219 boost::serialization::void_cast_register<DiscreteConditional, Factor>(
220 static_cast<DiscreteConditional*>(NULL), static_cast<Factor*>(NULL));
221 } else if (isContinuous()) {
222 boost::serialization::void_cast_register<GaussianConditional, Factor>(
223 static_cast<GaussianConditional*>(NULL), static_cast<Factor*>(NULL));
224 } else {
225 boost::serialization::void_cast_register<GaussianMixture, Factor>(
226 static_cast<GaussianMixture*>(NULL), static_cast<Factor*>(NULL));
227 }
228 }
229
230}; // HybridConditional
231
232// traits
233template <>
234struct traits<HybridConditional> : public Testable<HybridConditional> {};
235
236} // namespace gtsam
A hybrid conditional in the Conditional Linear Gaussian scheme.
Linearized Hybrid factor graph that uses type erasure.
Base class for conditional densities.
Conditional Gaussian Base class.
Global functions in a separate testing namespace.
Definition chartTesting.h:28
FastVector< Key > KeyVector
Define collection type once and for all - also used in wrappers.
Definition Key.h:86
void print(const Matrix &A, const string &s, ostream &stream)
print without optional string, must specify cout yourself
Definition Matrix.cpp:156
std::uint64_t Key
Integer nonlinear key type.
Definition types.h:100
std::function< std::string(Key)> KeyFormatter
Typedef for a function to format a key, i.e. to convert it to a string.
Definition Key.h:35
A manifold defines a space in which there is a notion of a linear tangent space that can be centered ...
Definition concepts.h:30
Template to create a binary predicate.
Definition Testable.h:111
A helper that implements the traits interface for GTSAM types.
Definition Testable.h:151
Discrete Conditional Density Derives from DecisionTreeFactor.
Definition DiscreteConditional.h:40
boost::shared_ptr< This > shared_ptr
shared_ptr to this class
Definition DiscreteConditional.h:44
DiscreteKeys is a set of keys that can be assembled using the & operator.
Definition DiscreteKey.h:39
Hybrid Conditional Density.
Definition HybridConditional.h:62
Conditional< BaseFactor, This > BaseConditional
Typedef to our conditional base class.
Definition HybridConditional.h:69
HybridFactor BaseFactor
Typedef to our factor base class.
Definition HybridConditional.h:67
boost::shared_ptr< Factor > inner_
Type-erased pointer to the inner type.
Definition HybridConditional.h:73
DiscreteConditional::shared_ptr asDiscrete() const
Return conditional as a DiscreteConditional.
Definition HybridConditional.h:172
GaussianMixture::shared_ptr asMixture() const
Return HybridConditional as a GaussianMixture.
Definition HybridConditional.h:154
boost::shared_ptr< Factor > inner() const
Get the type-erased pointer to the inner type.
Definition HybridConditional.h:177
bool frontalsIn(const VectorValues &measurements) const
Check if VectorValues measurements contains all frontal keys.
Definition HybridConditional.h:196
HybridConditional(const KeyVector &continuousKeys, const DiscreteKeys &discreteKeys, size_t nFrontals)
Construct a new Hybrid Conditional object.
Definition HybridConditional.h:89
boost::shared_ptr< This > shared_ptr
shared_ptr to this class
Definition HybridConditional.h:66
GaussianConditional::shared_ptr asGaussian() const
Return HybridConditional as a GaussianConditional.
Definition HybridConditional.h:163
HybridConditional This
Typedef to this class.
Definition HybridConditional.h:65
HybridConditional()=default
Default constructor needed for serialization.
Base class for truly hybrid probabilistic factors.
Definition HybridFactor.h:52
HybridValues represents a collection of DiscreteValues and VectorValues.
Definition HybridValues.h:38
Definition Conditional.h:64
Definition Factor.h:68
A GaussianConditional functions as the node in a Bayes network.
Definition GaussianConditional.h:43
boost::shared_ptr< This > shared_ptr
shared_ptr to this class
Definition GaussianConditional.h:46
VectorValues represents a collection of vector-valued variables associated each with a unique integer...
Definition VectorValues.h:74
bool exists(Key j) const
Check whether a variable with key j exists.
Definition VectorValues.h:133