Loading...
Searching...
No Matches
gtsam::DiscreteDistribution Class Reference
Discrete

## Detailed Description

A prior probability on a set of discrete variables.

Derives from DiscreteConditional

Inheritance diagram for gtsam::DiscreteDistribution:

## Public Member Functions

Standard Constructors
| DiscreteDistribution ()
| Default constructor needed for serialization.
| DiscreteDistribution (const DecisionTreeFactor &f)
| Constructor from factor.
| DiscreteDistribution (const Signature &s)
| Construct from a Signature.
| DiscreteDistribution (const DiscreteKey &key, const std::vector< double > &spec)
| Construct from key and a vector of floats specifying the probability mass function (PMF).
| DiscreteDistribution (const DiscreteKey &key, const std::string &spec)
| Construct from key and a string specifying the probability mass function (PMF).
Testable
void | print (const std::string &s="Discrete Prior: ", const KeyFormatter &formatter=DefaultKeyFormatter) const override
| GTSAM-style print.
Standard interface
double | operator() (size_t value) const
| Evaluate given a single value.
std::vector< double > | pmf () const
| We also want to keep the Base version, taking DiscreteValues:
Public Member Functions inherited from gtsam::DiscreteConditional
| DiscreteConditional ()
| Default constructor needed for serialization.
| DiscreteConditional (size_t nFrontals, const DecisionTreeFactor &f)
| Construct from factor, taking the first nFrontals keys as frontals.
| DiscreteConditional (size_t nFrontals, const DiscreteKeys &keys, const ADT &potentials)
| Construct from DiscreteKeys and AlgebraicDecisionTree, taking the first nFrontals keys as frontals, in the order given.
| DiscreteConditional (const Signature &signature)
| Construct from signature.
| 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) in 00 01 10 11 order.
| 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 10 11 order.
| DiscreteConditional (const DiscreteKey &key, const std::string &spec)
| No-parent specialization; can also use DiscreteDistribution.
| DiscreteConditional (const DecisionTreeFactor &joint, const DecisionTreeFactor &marginal)
| construct P(X|Y) = f(X,Y)/f(Y) from f(X,Y) and f(Y) Assumes but does not check that f(Y)=sum_X f(X,Y).
| DiscreteConditional (const DecisionTreeFactor &joint, const DecisionTreeFactor &marginal, const Ordering &orderedKeys)
| construct P(X|Y) = f(X,Y)/f(Y) from f(X,Y) and f(Y) Assumes but does not check that f(Y)=sum_X f(X,Y).
DiscreteConditional | operator* (const DiscreteConditional &other) const
| Combine two conditionals, yielding a new conditional with the union of the frontal keys, ordered by gtsam::Key.
DiscreteConditional | marginal (Key key) const
| Calculate marginal on given key, no parent case.
bool | equals (const DiscreteFactor &other, double tol=1e-9) const override
| GTSAM-style equals.
double | logProbability (const DiscreteValues &x) const
| Log-probability is just -error(x).
void | printSignature (const std::string &s="Discrete Conditional: ", const KeyFormatter &formatter=DefaultKeyFormatter) const
| print index signature only
double | evaluate (const DiscreteValues &values) const
| Evaluate, just look up in AlgebraicDecisonTree.
shared_ptr | choose (const DiscreteValues &given) const
| < DiscreteValues version
DecisionTreeFactor::shared_ptr | likelihood (const DiscreteValues &frontalValues) const
| Convert to a likelihood factor by providing value before bar.
DecisionTreeFactor::shared_ptr | likelihood (size_t frontal) const
| Single variable version of likelihood.
size_t | sample (const DiscreteValues &parentsValues) const
| sample
size_t | sample (size_t parent_value) const
| Single parent version.
size_t | sample () const
| Zero parent version.
size_t | argmax () const
| Return assignment that maximizes distribution.
double | error (const DiscreteValues &values) const
| Calculate error for DiscreteValues x, is -log(probability).
double | error (const HybridValues &values) const override
| Calculate error for HybridValues x, is -log(probability) Simply dispatches to DiscreteValues version.
double | operator() (const DiscreteValues &values) const override
| < DiscreteValues version
void | sampleInPlace (DiscreteValues *parentsValues) const
| sample in place, stores result in partial solution
std::vector< DiscreteValues > | frontalAssignments () const
| Return all assignments for frontal variables.
std::vector< DiscreteValues > | allAssignments () const
| Return all assignments for frontal and parent variables.
std::string | markdown (const KeyFormatter &keyFormatter=DefaultKeyFormatter, const Names &names={}) const override
| Render as markdown table.
std::string | html (const KeyFormatter &keyFormatter=DefaultKeyFormatter, const Names &names={}) const override
| Render as html table.
double | evaluate (const HybridValues &x) const override
| Calculate probability for HybridValues x.
double | logProbability (const HybridValues &x) const override
| < HybridValues version
double | logNormalizationConstant () const override
| logNormalizationConstant K is just zero, such that logProbability(x) = log(evaluate(x)) = - error(x) and hence error(x) = - log(evaluate(x)) > 0 for all x.
double | operator() (const HybridValues &x) const
| Evaluate probability density, sugar.
Public Member Functions inherited from gtsam::DecisionTreeFactor
| DecisionTreeFactor ()
| Default constructor for I/O.
| DecisionTreeFactor (const DiscreteKeys &keys, const ADT &potentials)
| Constructor from DiscreteKeys and AlgebraicDecisionTree.
| DecisionTreeFactor (const DiscreteKeys &keys, const std::vector< double > &table)
| Constructor from doubles.
| DecisionTreeFactor (const DiscreteKeys &keys, const std::string &table)
| Constructor from string.
template<class SOURCE>
| DecisionTreeFactor (const DiscreteKey &key, SOURCE table)
| Single-key specialization.
| DecisionTreeFactor (const DiscreteKey &key, const std::vector< double > &row)
| Single-key specialization, with vector of doubles.
| DecisionTreeFactor (const DiscreteConditional &c)
| Construct from a DiscreteConditional type.
DecisionTreeFactor | apply (const DecisionTreeFactor &f, ADT::Binary op) const
| Apply binary operator (*this) "op" f.
shared_ptr | combine (size_t nrFrontals, ADT::Binary op) const
| Combine frontal variables using binary operator "op".
shared_ptr | combine (const Ordering &keys, ADT::Binary op) const
| Combine frontal variables in an Ordering using binary operator "op".
std::vector< std::pair< DiscreteValues, double > > | enumerate () const
| Enumerate all values into a map from values to double.
DiscreteKeys | discreteKeys () const
| Return all the discrete keys associated with this factor.
DecisionTreeFactor | prune (size_t maxNrAssignments) const
| Prune the decision tree of discrete variables.
void | dot (std::ostream &os, const KeyFormatter &keyFormatter=DefaultKeyFormatter, bool showZero=true) const
| output to graphviz format, stream version
void | dot (const std::string &name, const KeyFormatter &keyFormatter=DefaultKeyFormatter, bool showZero=true) const
| output to graphviz format, open a file
std::string | dot (const KeyFormatter &keyFormatter=DefaultKeyFormatter, bool showZero=true) const
| output to graphviz format string
double | evaluate (const DiscreteValues &values) const
| Calculate probability for given values x, is just look up in AlgebraicDecisionTree.
double | error (const DiscreteValues &values) const
| Calculate error for DiscreteValues x, is -log(probability).
DecisionTreeFactor | operator* (const DecisionTreeFactor &f) const override
| multiply two factors
size_t | cardinality (Key j) const
DecisionTreeFactor | operator/ (const DecisionTreeFactor &f) const
| divide by factor f (safely)
DecisionTreeFactor | toDecisionTreeFactor () const override
| Convert into a decisiontree.
shared_ptr | sum (size_t nrFrontals) const
| Create new factor by summing all values with the same separator values.
shared_ptr | sum (const Ordering &keys) const
| Create new factor by summing all values with the same separator values.
shared_ptr | max (size_t nrFrontals) const
| Create new factor by maximizing over all values with the same separator.
shared_ptr | max (const Ordering &keys) const
| Create new factor by maximizing over all values with the same separator.
Public Member Functions inherited from gtsam::DiscreteFactor
| DiscreteFactor ()
| Default constructor creates empty factor.
template<typename CONTAINER>
| DiscreteFactor (const CONTAINER &keys)
| Construct from container of keys.
virtual | ~DiscreteFactor ()
| Virtual destructor.
void | print (const std::string &s="DiscreteFactor\n", const KeyFormatter &formatter=DefaultKeyFormatter) const override
| print
double | error (const DiscreteValues &values) const
| Error is just -log(value).
double | error (const HybridValues &c) const override
| All factor types need to implement an error function.
Public Member Functions inherited from gtsam::Factor
virtual | ~Factor ()=default
| Default destructor.
bool | empty () const
| Whether the factor is empty (involves zero variables).
Key | front () const
| First key.
Key | back () const
| Last key.
const_iterator | find (Key key) const
| find
const KeyVector & | keys () const
| Access the factor's involved variable keys.
const_iterator | begin () const
| Iterator at beginning of involved variable keys.
const_iterator | end () const
| Iterator at end of involved variable keys.
size_t | size () const
virtual void | printKeys (const std::string &s="Factor", const KeyFormatter &formatter=DefaultKeyFormatter) const
| print only keys
bool | equals (const This &other, double tol=1e-9) const
| check equality
KeyVector & | keys ()
iterator | begin ()
| Iterator at beginning of involved variable keys.
iterator | end ()
| Iterator at end of involved variable keys.
Public Member Functions inherited from gtsam::AlgebraicDecisionTree< Key >
| AlgebraicDecisionTree (double leaf=1.0)
| AlgebraicDecisionTree (const Base &add)
| AlgebraicDecisionTree (const Key &label, double y1, double y2)
| Create a new leaf function splitting on a variable.
| AlgebraicDecisionTree (const typename Base::LabelC &labelC, double y1, double y2)
| Create a new leaf function splitting on a variable.
| AlgebraicDecisionTree (const std::vector< typename Base::LabelC > &labelCs, const std::vector< double > &ys)
| Create from keys with cardinalities and a vector table.
| AlgebraicDecisionTree (const std::vector< typename Base::LabelC > &labelCs, const std::string &table)
| Create from keys and string table.
| AlgebraicDecisionTree (Iterator begin, Iterator end, const Key &label)
| Create a range of decision trees, splitting on a single variable.
| AlgebraicDecisionTree (const AlgebraicDecisionTree< M > &other, const std::map< M, Key > &map)
| Convert labels from type M to type L.
AlgebraicDecisionTree | operator+ (const AlgebraicDecisionTree &g) const
| sum
AlgebraicDecisionTree | operator* (const AlgebraicDecisionTree &g) const
| product
AlgebraicDecisionTree | operator/ (const AlgebraicDecisionTree &g) const
| division
AlgebraicDecisionTree | sum (const Key &label, size_t cardinality) const
| sum out variable
AlgebraicDecisionTree | sum (const typename Base::LabelC &labelC) const
| sum out variable
void | print (const std::string &s="", const typename Base::LabelFormatter &labelFormatter=&DefaultFormatter) const
| print method customized to value type double.
bool | equals (const AlgebraicDecisionTree &other, double tol=1e-9) const
| Equality method customized to value type double.
Public Member Functions inherited from gtsam::DecisionTree< L, Y >
| DecisionTree ()
| Default constructor (for serialization).
| DecisionTree (const Y &y)
| Create a constant.
| DecisionTree (const L &label, const Y &y1, const Y &y2)
| Create tree with 2 assignments y1, y2, splitting on variable label.
| DecisionTree (const LabelC &label, const Y &y1, const Y &y2)
| Allow Label+Cardinality for convenience.
| DecisionTree (const std::vector< LabelC > &labelCs, const std::vector< Y > &ys)
| Create from keys and a corresponding vector of values.
| DecisionTree (const std::vector< LabelC > &labelCs, const std::string &table)
| Create from keys and string table.
template<typename Iterator>
| DecisionTree (Iterator begin, Iterator end, const L &label)
| Create DecisionTree from others.
| DecisionTree (const L &label, const DecisionTree &f0, const DecisionTree &f1)
| Create DecisionTree from two others.
template<typename X, typename Func>
| DecisionTree (const DecisionTree< L, X > &other, Func Y_of_X)
| Convert from a different value type.
template<typename M, typename X, typename Func>
| DecisionTree (const DecisionTree< M, X > &other, const std::map< M, L > &map, Func Y_of_X)
| Convert from a different value type X to value type Y, also transate labels via map from type M to L.
void | print (const std::string &s, const LabelFormatter &labelFormatter, const ValueFormatter &valueFormatter) const
| GTSAM-style print.
bool | equals (const DecisionTree &other, const CompareFunc &compare=&DefaultCompare) const
virtual | ~DecisionTree ()=default
| Make virtual.
bool | empty () const
| Check if tree is empty.
bool | operator== (const DecisionTree &q) const
| equality
const Y & | operator() (const Assignment< L > &x) const
| evaluate
template<typename Func>
void | visit (Func f) const
| Visit all leaves in depth-first fashion.
template<typename Func>
void | visitLeaf (Func f) const
| Visit all leaves in depth-first fashion.
template<typename Func>
void | visitWith (Func f) const
| Visit all leaves in depth-first fashion.
size_t | nrLeaves () const
| Return the number of leaves in the tree.
template<typename Func, typename X>
X | fold (Func f, X x0) const
| Fold a binary function over the tree, returning accumulator.
std::set< L > | labels () const
| Retrieve all unique labels as a set.
DecisionTree | apply (const Unary &op) const
| apply Unary operation "op" to f
DecisionTree | apply (const UnaryAssignment &op) const
| Apply Unary operation "op" to f while also providing the corresponding assignment.
DecisionTree | apply (const DecisionTree &g, const Binary &op) const
| apply binary operation "op" to f and g
DecisionTree | choose (const L &label, size_t index) const
| create a new function where value(label)==index It's like "restrict" in Darwiche09book pg329, 330?
DecisionTree | combine (const L &label, size_t cardinality, const Binary &op) const
| combine subtrees on key with binary operation "op"
DecisionTree | combine (const LabelC &labelC, const Binary &op) const
| combine with LabelC for convenience
void | dot (std::ostream &os, const LabelFormatter &labelFormatter, const ValueFormatter &valueFormatter, bool showZero=true) const
| output to graphviz format, stream version
void | dot (const std::string &name, const LabelFormatter &labelFormatter, const ValueFormatter &valueFormatter, bool showZero=true) const
| output to graphviz format, open a file
std::string | dot (const LabelFormatter &labelFormatter, const ValueFormatter &valueFormatter, bool showZero=true) const
| output to graphviz format string
| DecisionTree (const NodePtr &root)
template<typename Iterator>
NodePtr | compose (Iterator begin, Iterator end, const L &label) const
Public Member Functions inherited from gtsam::Conditional< DecisionTreeFactor, DiscreteConditional >
void | print (const std::string &s="Conditional", const KeyFormatter &formatter=DefaultKeyFormatter) const
| print with optional formatter
bool | equals (const This &c, double tol=1e-9) const
| check equality
size_t | nrFrontals () const
| return the number of frontals
size_t | nrParents () const
| return the number of parents
Key | firstFrontalKey () const
| Convenience function to get the first frontal key.
Frontals | frontals () const
| return a view of the frontal keys
Parents | parents () const
| return a view of the parent keys
double | operator() (const HybridValues &x) const
| Evaluate probability density, sugar.
double | normalizationConstant () const
| Non-virtual, exponentiate logNormalizationConstant.
DecisionTreeFactor::const_iterator | beginFrontals () const
| Iterator pointing to first frontal key.
DecisionTreeFactor::const_iterator | endFrontals () const
| Iterator pointing past the last frontal key.
DecisionTreeFactor::const_iterator | beginParents () const
| Iterator pointing to the first parent key.
DecisionTreeFactor::const_iterator | endParents () const
| Iterator pointing past the last parent key.

## Public Types

using | Base = DiscreteConditional
Public Types inherited from gtsam::DiscreteConditional
typedef DiscreteConditional | This
| Typedef to this class.
typedef boost::shared_ptr< This > | shared_ptr
| shared_ptr to this class
typedef DecisionTreeFactor | BaseFactor
| Typedef to our factor base class.
typedef Conditional< BaseFactor, This > | BaseConditional
| Typedef to our conditional base class.
using | Values = DiscreteValues
| backwards compatibility
Public Types inherited from gtsam::DecisionTreeFactor
typedef DecisionTreeFactor | This
typedef DiscreteFactor | Base
| Typedef to base class.
typedef boost::shared_ptr< DecisionTreeFactor > | shared_ptr
typedef AlgebraicDecisionTree< Key > | ADT
Public Types inherited from gtsam::DiscreteFactor
typedef DiscreteFactor | This
| This class.
typedef boost::shared_ptr< DiscreteFactor > | shared_ptr
| shared_ptr to this class
typedef Factor | Base
| Our base class.
using | Values = DiscreteValues
| backwards compatibility
using | Names = DiscreteValues::Names
| Translation table from values to strings.
Public Types inherited from gtsam::Factor
typedef KeyVector::iterator | iterator
| Iterator over keys.
typedef KeyVector::const_iterator | const_iterator
| Const iterator over keys.
Public Types inherited from gtsam::AlgebraicDecisionTree< Key >
using | Base
Public Types inherited from gtsam::DecisionTree< L, Y >
using | LabelFormatter = std::function<std::string(L)>
using | ValueFormatter = std::function<std::string(Y)>
using | CompareFunc = std::function<bool(const Y&, const Y&)>
using | Unary = std::function<Y(const Y&)>
| Handy typedefs for unary and binary function types.
using | UnaryAssignment = std::function<Y(const Assignment<L>&, const Y&)>
using | Binary = std::function<Y(const Y&, const Y&)>
using | LabelC = std::pair<L, size_t>
| A label annotated with cardinality.
using | NodePtr = typename Node::Ptr
| ---------------------— Node base class ------------------------—
Public Types inherited from gtsam::Conditional< DecisionTreeFactor, DiscreteConditional >
typedef boost::iterator_range< typename DecisionTreeFactor::const_iterator > | Frontals
| View of the frontal keys (call frontals()).
typedef boost::iterator_range< typename DecisionTreeFactor::const_iterator > | Parents
| View of the separator keys (call parents()).

## Additional Inherited Members

static double | safe_div (const double &a, const double &b)
static bool | CheckInvariants (const DiscreteConditional &conditional, const VALUES &x)
| Check invariants of this conditional, given the values x.
Public Attributes inherited from gtsam::DecisionTree< L, Y >
NodePtr | root_
| A DecisionTree just contains the root. TODO(dellaert): make protected.
Protected Member Functions inherited from gtsam::DiscreteConditional
DiscreteConditional::ADT | choose (const DiscreteValues &given, bool forceComplete) const
| Internal version of choose.
| Factor ()
| Default constructor for I/O.
template<typename CONTAINER>
| Factor (const CONTAINER &keys)
| Construct factor from container of keys.
template<typename ITERATOR>
| Factor (ITERATOR first, ITERATOR last)
| Construct factor from iterator keys.
Protected Member Functions inherited from gtsam::DecisionTree< L, Y >
template<typename It, typename ValueIt>
NodePtr | create (It begin, It end, ValueIt beginY, ValueIt endY) const
| Internal recursive function to create from keys, cardinalities, and Y values.
template<typename M, typename X>
NodePtr | convertFrom (const typename DecisionTree< M, X >::NodePtr &f, std::function< L(const M &)> L_of_M, std::function< Y(const X &)> Y_of_X) const
| Convert from a DecisionTree<M, X> to DecisionTree<L, Y>.
Protected Member Functions inherited from gtsam::Conditional< DecisionTreeFactor, DiscreteConditional >
| Conditional ()
| Empty Constructor to make serialization possible.
template<typename CONTAINER>
static Factor | FromKeys (const CONTAINER &keys)
| Construct factor from container of keys.
template<typename ITERATOR>
static Factor | FromIterators (ITERATOR first, ITERATOR last)
| Construct factor from iterator keys.
Static Protected Member Functions inherited from gtsam::DecisionTree< L, Y >
static bool | DefaultCompare (const Y &a, const Y &b)
| Default method for comparison of two objects of type Y.
Protected Attributes inherited from gtsam::DecisionTreeFactor
std::map< Key, size_t > | cardinalities_
Protected Attributes inherited from gtsam::Factor
KeyVector | keys_
| The keys involved in this factor.
Protected Attributes inherited from gtsam::Conditional< DecisionTreeFactor, DiscreteConditional >
size_t | nrFrontals_
| The first nrFrontal variables are frontal and the rest are parents.

## Constructor & Destructor Documentation

## DiscreteDistribution() [1/3]

gtsam::DiscreteDistribution::DiscreteDistribution | ( | const Signature & | s | ) |

inline explicit

Construct from a Signature.

Example: DiscreteDistribution P(D % "3/2");

## DiscreteDistribution() [2/3]

gtsam::DiscreteDistribution::DiscreteDistribution | ( | const DiscreteKey & | key,
|  | const std::vector< double > & | spec )

inline

Construct from key and a vector of floats specifying the probability mass function (PMF).

Example: DiscreteDistribution P(D, {0.4, 0.6});

## DiscreteDistribution() [3/3]

gtsam::DiscreteDistribution::DiscreteDistribution | ( | const DiscreteKey & | key,
|  | const std::string & | spec )

inline

Construct from key and a string specifying the probability mass function (PMF).

Example: DiscreteDistribution P(D, "9/1 2/8 3/7 1/9");

## Member Function Documentation

## pmf()

std::vector< double > gtsam::DiscreteDistribution::pmf | ( |  | ) | const

We also want to keep the Base version, taking DiscreteValues:

Return entire probability mass function.

## print()

void gtsam::DiscreteDistribution::print | ( | const std::string & | s = "Discrete Prior: ",
|  | const KeyFormatter & | formatter = DefaultKeyFormatter ) const

override virtual

GTSAM-style print.

Reimplemented from gtsam::DiscreteConditional.

The documentation for this class was generated from the following files:

- /build/gtsam-Xg031d/gtsam-4.2.0+dfsg/gtsam/discrete/DiscreteDistribution.h
- /build/gtsam-Xg031d/gtsam-4.2.0+dfsg/gtsam/discrete/DiscreteDistribution.cpp