gtsam 4.2.0
gtsam
Loading...
Searching...
No Matches
gtsam::DiscreteConditional Class Reference

Detailed Description

Discrete Conditional Density Derives from DecisionTreeFactor.

represent a discrete conditional distribution over discrete variables.

  • Hybrid conditional densities, such as
+ Inheritance diagram for gtsam::DiscreteConditional:

Public Member Functions

Standard Constructors
 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.
 
Testable
void print (const std::string &s="Discrete Conditional: ", const KeyFormatter &formatter=DefaultKeyFormatter) const override
 GTSAM-style print.
 
bool equals (const DiscreteFactor &other, double tol=1e-9) const override
 GTSAM-style equals.
 
Standard Interface
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.
 
Advanced Interface
void sampleInPlace (DiscreteValues *parentsValues) const
 sample in place, stores result in partial solution
 
std::vector< DiscreteValuesfrontalAssignments () const
 Return all assignments for frontal variables.
 
std::vector< DiscreteValuesallAssignments () const
 Return all assignments for frontal and parent variables.
 
Wrapper support
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.
 
HybridValues methods.
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.
 
- 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 operator() (const DiscreteValues &values) const override
 Evaluate probability density, sugar.
 
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 KeyVectorkeys () 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
 
KeyVectorkeys ()
 
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 and 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 new function splitting on a 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 >
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.
 
size_t & nrFrontals ()
 Mutable version of nrFrontals.
 
FACTOR::const_iterator beginFrontals () const
 Iterator pointing to first frontal key.
 
FACTOR::iterator beginFrontals ()
 Mutable iterator pointing to first frontal key.
 
FACTOR::const_iterator endFrontals () const
 Iterator pointing past the last frontal key.
 
FACTOR::iterator endFrontals ()
 Mutable iterator pointing past the last frontal key.
 
FACTOR::const_iterator beginParents () const
 Iterator pointing to the first parent key.
 
FACTOR::iterator beginParents ()
 Mutable iterator pointing to the first parent key.
 
FACTOR::const_iterator endParents () const
 Iterator pointing past the last parent key.
 
FACTOR::iterator endParents ()
 Mutable iterator pointing past the last parent key.
 

Public Types

typedef DiscreteConditional This
 Typedef to this class.
 
typedef boost::shared_ptr< Thisshared_ptr
 shared_ptr to this class
 
typedef DecisionTreeFactor BaseFactor
 Typedef to our factor base class.
 
typedef Conditional< BaseFactor, ThisBaseConditional
 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< DecisionTreeFactorshared_ptr
 
typedef AlgebraicDecisionTree< KeyADT
 
- Public Types inherited from gtsam::DiscreteFactor
typedef DiscreteFactor This
 This class.
 
typedef boost::shared_ptr< DiscreteFactorshared_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 = DecisionTree< Key, double >
 
- 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 FACTOR::const_iterator > Frontals
 View of the frontal keys (call frontals())
 
typedef boost::iterator_range< typename FACTOR::const_iterator > Parents
 View of the separator keys (call parents())
 

Protected Member Functions

DiscreteConditional::ADT choose (const DiscreteValues &given, bool forceComplete) const
 Internal version of choose.
 
- Protected Member Functions inherited from gtsam::Factor
 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.
 
 Conditional (size_t nrFrontals)
 Constructor.
 

Friends

class boost::serialization::access
 Serialization function.
 

Additional Inherited Members

- Static Public Member Functions inherited from gtsam::DecisionTreeFactor
static double safe_div (const double &a, const double &b)
 
- Static Public Member Functions inherited from gtsam::Conditional< DecisionTreeFactor, DiscreteConditional >
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.
 
- Static Protected Member Functions inherited from gtsam::Factor
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

◆ DiscreteConditional() [1/3]

gtsam::DiscreteConditional::DiscreteConditional ( const DiscreteKey key,
const DiscreteKeys parents,
const Signature::Table &  table 
)
inline

Construct from key, parents, and a Signature::Table specifying the conditional probability table (CPT) in 00 01 10 11 order.

For three-valued, it would be 00 01 02 10 11 12 20 21 22, etc....

Example: DiscreteConditional P(D, {B,E}, table);

◆ DiscreteConditional() [2/3]

gtsam::DiscreteConditional::DiscreteConditional ( const DiscreteKey key,
const DiscreteKeys parents,
const std::string &  spec 
)
inline

Construct from key, parents, and a string specifying the conditional probability table (CPT) in 00 01 10 11 order.

For three-valued, it would be 00 01 02 10 11 12 20 21 22, etc....

The string is parsed into a Signature::Table.

Example: DiscreteConditional P(D, {B,E}, "9/1 2/8 3/7 1/9");

◆ DiscreteConditional() [3/3]

gtsam::DiscreteConditional::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).

Makes sure the keys are ordered as given. Does not check orderedKeys.

Member Function Documentation

◆ argmax()

size_t gtsam::DiscreteConditional::argmax ( ) const

Return assignment that maximizes distribution.

Returns
Optimal assignment (1 frontal variable).

◆ choose()

DiscreteConditional::shared_ptr gtsam::DiscreteConditional::choose ( const DiscreteValues given) const

< DiscreteValues version

restrict to given parent values.

Note: does not need be complete set. Examples:

P(C|D,E) + . -> P(C|D,E) P(C|D,E) + E -> P(C|D) P(C|D,E) + D -> P(C|E) P(C|D,E) + D,E -> P(C) P(C|D,E) + C -> error!

Returns
a shared_ptr to a new DiscreteConditional

◆ equals()

bool gtsam::DiscreteConditional::equals ( const DiscreteFactor other,
double  tol = 1e-9 
) const
overridevirtual

GTSAM-style equals.

Reimplemented from gtsam::DecisionTreeFactor.

◆ error()

double gtsam::DecisionTreeFactor::error ( const HybridValues values) const
overridevirtual

Calculate error for HybridValues x, is -log(probability) Simply dispatches to DiscreteValues version.

Reimplemented from gtsam::DecisionTreeFactor.

◆ evaluate()

double gtsam::DiscreteConditional::evaluate ( const HybridValues x) const
overridevirtual

Calculate probability for HybridValues x.

Dispatches to DiscreteValues version.

Reimplemented from gtsam::Conditional< DecisionTreeFactor, DiscreteConditional >.

◆ html()

string gtsam::DiscreteConditional::html ( const KeyFormatter keyFormatter = DefaultKeyFormatter,
const Names names = {} 
) const
overridevirtual

Render as html table.

Reimplemented from gtsam::DecisionTreeFactor.

◆ logNormalizationConstant()

double gtsam::DiscreteConditional::logNormalizationConstant ( ) const
inlineoverridevirtual

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.

Reimplemented from gtsam::Conditional< DecisionTreeFactor, DiscreteConditional >.

◆ logProbability()

double gtsam::DiscreteConditional::logProbability ( const HybridValues x) const
inlineoverridevirtual

< HybridValues version

Calculate log-probability log(evaluate(x)) for HybridValues x. This is actually just -error(x).

Reimplemented from gtsam::Conditional< DecisionTreeFactor, DiscreteConditional >.

◆ markdown()

std::string gtsam::DiscreteConditional::markdown ( const KeyFormatter keyFormatter = DefaultKeyFormatter,
const Names names = {} 
) const
overridevirtual

Render as markdown table.

Reimplemented from gtsam::DecisionTreeFactor.

◆ operator*()

DiscreteConditional gtsam::DiscreteConditional::operator* ( const DiscreteConditional other) const

Combine two conditionals, yielding a new conditional with the union of the frontal keys, ordered by gtsam::Key.

The two conditionals must make a valid Bayes net fragment, i.e., the frontal variables cannot overlap, and must be acyclic: Example of correct use: P(A,B) = P(A|B) * P(B) P(A,B|C) = P(A|B) * P(B|C) P(A,B,C) = P(A,B|C) * P(C) Example of incorrect use: P(A|B) * P(A|C) = ? P(A|B) * P(B|A) = ? We check for overlapping frontals, but do not check for cyclic.

◆ print()

void gtsam::DiscreteConditional::print ( const std::string &  s = "Discrete Conditional: ",
const KeyFormatter formatter = DefaultKeyFormatter 
) const
overridevirtual

GTSAM-style print.

Reimplemented from gtsam::DecisionTreeFactor.

Reimplemented in gtsam::DiscreteLookupTable, and gtsam::DiscreteDistribution.

◆ sample()

size_t gtsam::DiscreteConditional::sample ( const DiscreteValues parentsValues) const

sample

Parameters
parentsValuesKnown values of the parents
Returns
sample from conditional

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