gtsam 4.2.0
gtsam
DiscreteConditional.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
19#pragma once
20
21#include <gtsam/inference/Conditional-inst.h>
24
25#include <boost/make_shared.hpp>
26#include <boost/shared_ptr.hpp>
27#include <string>
28#include <vector>
29
30namespace gtsam {
31
38class GTSAM_EXPORT DiscreteConditional
39 : public DecisionTreeFactor,
40 public Conditional<DecisionTreeFactor, DiscreteConditional> {
41 public:
42 // typedefs needed to play nice with gtsam
44 typedef boost::shared_ptr<This> shared_ptr;
48
50
53
56
58 DiscreteConditional(size_t nFrontals, const DecisionTreeFactor& f);
59
64 DiscreteConditional(size_t nFrontals, const DiscreteKeys& keys,
65 const ADT& potentials);
66
68 explicit DiscreteConditional(const Signature& signature);
69
77 DiscreteConditional(const DiscreteKey& key, const DiscreteKeys& parents,
78 const Signature::Table& table)
79 : DiscreteConditional(Signature(key, parents, table)) {}
80
90 DiscreteConditional(const DiscreteKey& key, const DiscreteKeys& parents,
91 const std::string& spec)
92 : DiscreteConditional(Signature(key, parents, spec)) {}
93
95 DiscreteConditional(const DiscreteKey& key, const std::string& spec)
96 : DiscreteConditional(Signature(key, {}, spec)) {}
97
102 DiscreteConditional(const DecisionTreeFactor& joint,
103 const DecisionTreeFactor& marginal);
104
110 DiscreteConditional(const DecisionTreeFactor& joint,
111 const DecisionTreeFactor& marginal,
112 const Ordering& orderedKeys);
113
129 DiscreteConditional operator*(const DiscreteConditional& other) const;
130
132 DiscreteConditional marginal(Key key) const;
133
137
139 void print(
140 const std::string& s = "Discrete Conditional: ",
141 const KeyFormatter& formatter = DefaultKeyFormatter) const override;
142
144 bool equals(const DiscreteFactor& other, double tol = 1e-9) const override;
145
149
151 double logProbability(const DiscreteValues& x) const {
152 return -error(x);
153 }
154
157 const std::string& s = "Discrete Conditional: ",
158 const KeyFormatter& formatter = DefaultKeyFormatter) const {
159 static_cast<const BaseConditional*>(this)->print(s, formatter);
160 }
161
163 double evaluate(const DiscreteValues& values) const {
164 return ADT::operator()(values);
165 }
166
168 using DecisionTreeFactor::operator();
169
183 shared_ptr choose(const DiscreteValues& given) const;
184
186 DecisionTreeFactor::shared_ptr likelihood(
187 const DiscreteValues& frontalValues) const;
188
190 DecisionTreeFactor::shared_ptr likelihood(size_t frontal) const;
191
197 size_t sample(const DiscreteValues& parentsValues) const;
198
200 size_t sample(size_t parent_value) const;
201
203 size_t sample() const;
204
209 size_t argmax() const;
210
214
216 void sampleInPlace(DiscreteValues* parentsValues) const;
217
219 std::vector<DiscreteValues> frontalAssignments() const;
220
222 std::vector<DiscreteValues> allAssignments() const;
223
227
229 std::string markdown(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
230 const Names& names = {}) const override;
231
233 std::string html(const KeyFormatter& keyFormatter = DefaultKeyFormatter,
234 const Names& names = {}) const override;
235
236
240
245 double evaluate(const HybridValues& x) const override;
246
247 using BaseConditional::operator();
248
253 double logProbability(const HybridValues& x) const override {
254 return -error(x);
255 }
256
262 double logNormalizationConstant() const override { return 0.0; }
263
265
266#ifdef GTSAM_ALLOW_DEPRECATED_SINCE_V42
269 size_t GTSAM_DEPRECATED solve(const DiscreteValues& parentsValues) const;
270 void GTSAM_DEPRECATED solveInPlace(DiscreteValues* parentsValues) const;
272#endif
273
274 protected:
276 DiscreteConditional::ADT choose(const DiscreteValues& given,
277 bool forceComplete) const;
278
279 private:
281 friend class boost::serialization::access;
282 template <class Archive>
283 void serialize(Archive& ar, const unsigned int /*version*/) {
284 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseFactor);
285 ar& BOOST_SERIALIZATION_BASE_OBJECT_NVP(BaseConditional);
286 }
287};
288// DiscreteConditional
289
290// traits
291template <>
292struct traits<DiscreteConditional> : public Testable<DiscreteConditional> {};
293
294} // namespace gtsam
signatures for conditional densities
std::pair< Key, size_t > DiscreteKey
Key type for discrete variables.
Definition: DiscreteKey.h:36
Global functions in a separate testing namespace.
Definition: chartTesting.h:28
string html(const DiscreteValues &values, const KeyFormatter &keyFormatter, const DiscreteValues::Names &names)
Free version of html.
Definition: DiscreteValues.cpp:134
string markdown(const DiscreteValues &values, const KeyFormatter &keyFormatter, const DiscreteValues::Names &names)
Free version of markdown.
Definition: DiscreteValues.cpp:129
std::string serialize(const T &input)
serializes to a string
Definition: serialization.h:113
void print(const Matrix &A, const string &s, ostream &stream)
print without optional string, must specify cout yourself
Definition: Matrix.cpp:156
Point2 operator*(double s, const Point2 &p)
multiply with scalar
Definition: Point2.h:47
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
A helper that implements the traits interface for GTSAM types.
Definition: Testable.h:151
A discrete probabilistic factor.
Definition: DecisionTreeFactor.h:45
double error(const DiscreteValues &values) const
Calculate error for DiscreteValues x, is -log(probability).
Definition: DecisionTreeFactor.cpp:61
Discrete Conditional Density Derives from DecisionTreeFactor.
Definition: DiscreteConditional.h:40
DiscreteConditional(const DiscreteKey &key, const std::string &spec)
No-parent specialization; can also use DiscreteDistribution.
Definition: DiscreteConditional.h:95
DiscreteConditional(const DiscreteKey &key, const DiscreteKeys &parents, const std::string &spec)
Construct from key, parents, and a string specifying the conditional probability table (CPT) in 00 01...
Definition: DiscreteConditional.h:90
double evaluate(const DiscreteValues &values) const
Evaluate, just look up in AlgebraicDecisonTree.
Definition: DiscreteConditional.h:163
boost::shared_ptr< This > shared_ptr
shared_ptr to this class
Definition: DiscreteConditional.h:44
DiscreteConditional(const DiscreteKey &key, const DiscreteKeys &parents, const Signature::Table &table)
Construct from key, parents, and a Signature::Table specifying the conditional probability table (CPT...
Definition: DiscreteConditional.h:77
Conditional< BaseFactor, This > BaseConditional
Typedef to our conditional base class.
Definition: DiscreteConditional.h:47
double logProbability(const HybridValues &x) const override
< HybridValues version
Definition: DiscreteConditional.h:253
DiscreteConditional This
Typedef to this class.
Definition: DiscreteConditional.h:43
DecisionTreeFactor BaseFactor
Typedef to our factor base class.
Definition: DiscreteConditional.h:45
DiscreteConditional()
Default constructor needed for serialization.
Definition: DiscreteConditional.h:55
double logProbability(const DiscreteValues &x) const
Log-probability is just -error(x).
Definition: DiscreteConditional.h:151
void printSignature(const std::string &s="Discrete Conditional: ", const KeyFormatter &formatter=DefaultKeyFormatter) const
print index signature only
Definition: DiscreteConditional.h:156
double logNormalizationConstant() const override
logNormalizationConstant K is just zero, such that logProbability(x) = log(evaluate(x)) = - error(x) ...
Definition: DiscreteConditional.h:262
DiscreteKeys is a set of keys that can be assembled using the & operator.
Definition: DiscreteKey.h:39
A map from keys to values.
Definition: DiscreteValues.h:34
Signature for a discrete conditional density, used to construct conditionals.
Definition: Signature.h:54
HybridValues represents a collection of DiscreteValues and VectorValues.
Definition: HybridValues.h:38
Definition: Conditional.h:64
the error.