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

Detailed Description

DiscreteLookupTable table for max-product.

Inherits from discrete conditional for convenience, but is not normalized. Is used in the max-product algorithm.

Inheritance diagram for gtsam::DiscreteLookupTable:

Public Member Functions

 DiscreteLookupTable (size_t nFrontals, const DiscreteKeys &keys, const ADT &potentials)
 Construct a new Discrete Lookup Table object.
 DiscreteLookupTable (size_t nFrontals, const DiscreteKeys &keys, const TableFactor &potentials)
 Construct a new Discrete Lookup Table object.
void print (const std::string &s="Discrete Lookup Table: ", const KeyFormatter &formatter=DefaultKeyFormatter) const override
 GTSAM-style print.
size_t argmax (const DiscreteValues &parentsValues) const
 return assignment for single frontal variable that maximizes value.
void argmaxInPlace (DiscreteValues *parentsValues) const
 Calculate assignment for frontal variables that maximizes value.
Public Member Functions inherited from gtsam::DiscreteConditional
 DiscreteConditional ()
 Default constructor needed for serialization.
 DiscreteConditional (size_t nFrontals, const DiscreteFactor &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::vector< double > &table)
 Construct from key, parents, and a vector<double> 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.
DiscreteFactor::shared_ptr operator* (double s) const override
 multiply with a scalar
DecisionTreeFactor operator* (const DecisionTreeFactor &f) const override
 multiply two factors
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
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.
virtual size_t sample (const DiscreteValues &parentsValues, std::mt19937_64 *rng=nullptr) const
 Sample from conditional, given missing variables Example: std::mt19937_64 rng(42); DiscreteValues given = ...; size_t sample = dc.sample(given, &rng);.
size_t sample (size_t parent_value, std::mt19937_64 *rng=nullptr) const
 Single parent version.
size_t sample (std::mt19937_64 *rng=nullptr) const
 Sample from conditional, zero parent version Example: std::mt19937_64 rng(42); auto sample = dc.sample(&rng);.
size_t argmax (const DiscreteValues &parentsValues=DiscreteValues()) const
 Return assignment for single frontal variable that maximizes value.
virtual DiscreteFactor::shared_ptr max (const Ordering &keys) const override
 Create new factor by maximizing over all values with the same separator.
double error (const DiscreteValues &values) const override
 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.
virtual double evaluate (const Assignment< Key > &values) const override
 < DiscreteValues version
double operator() (const DiscreteValues &values) const
 < DiscreteValues version
void sampleInPlace (DiscreteValues *parentsValues, std::mt19937_64 *rng=nullptr) const
 Sample in place with optional PRNG, 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 negLogConstant () const override
 negLogConstant is just zero, such that -logProbability(x) = -log(evaluate(x)) = error(x) and hence error(x) > 0 for all x.
virtual void prune (size_t maxNrAssignments)
 Prune the conditional.
void removeDiscreteModes (const DiscreteValues &given)
 Remove the discrete modes whose assignments are given to us.
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 (Unary op) const
 Apply unary operator (*this) "op" f.
DecisionTreeFactor apply (UnaryAssignment op) const
 Apply unary operator (*this) "op" f.
DecisionTreeFactor apply (const DecisionTreeFactor &f, Binary op) const
 Apply binary operator (*this) "op" f.
shared_ptr combine (size_t nrFrontals, Binary op) const
 Combine frontal variables using binary operator "op".
shared_ptr combine (const Ordering &keys, 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.
std::vector< double > probabilities () const
 Get all the probabilities in order of assignment values.
double computeThreshold (const size_t N) const
 Compute the probability value which is the threshold above which only N leaves are present.
DecisionTreeFactor prune (size_t maxNrAssignments) const
 Prune the decision tree of discrete variables.
uint64_t nrValues () const override
 Get the number of non-zero values contained in this factor.
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
virtual DiscreteFactor::shared_ptr multiply (const DiscreteFactor::shared_ptr &f) const override
 Multiply factors, DiscreteFactor::shared_ptr edition.
DecisionTreeFactor operator/ (const DecisionTreeFactor &f) const
 Divide by factor f (safely).
DiscreteFactor::shared_ptr operator/ (const DiscreteFactor::shared_ptr &f) const override
 divide by DiscreteFactor::shared_ptr f (safely)
DecisionTreeFactor toDecisionTreeFactor () const override
 Convert into a decision tree.
TableFactor toTableFactor () const override
 Convert directly into a sparse table.
DiscreteFactor::shared_ptr sum (size_t nrFrontals) const override
 Create new factor by summing all values with the same separator values.
DiscreteFactor::shared_ptr sum (const Ordering &keys) const override
 Create new factor by summing all values with the same separator values.
double max () const override
 Find the maximum value in the factor.
DiscreteFactor::shared_ptr max (size_t nrFrontals) const override
 Create new factor by maximizing over all values with the same separator.
DiscreteFactor::shared_ptr restrict (const DiscreteValues &assignment) const override
 Restrict the factor to the given assignment.
double operator() (const DiscreteValues &values) const
 Disambiguate to use DiscreteFactor version. Mainly for wrapper.
double sum () const
 Use sum() from AlgebraicDecisionTree.
AlgebraicDecisionTree sum (const Key &label, size_t cardinality) const
 Use sum() from AlgebraicDecisionTree.
AlgebraicDecisionTree sum (const typename Base::LabelC &labelC) const
 Use sum() from AlgebraicDecisionTree.
Public Member Functions inherited from gtsam::DiscreteFactor
 DiscreteFactor ()
 Default constructor creates empty factor.
template<typename CONTAINER>
 DiscreteFactor (const CONTAINER &keys, const std::map< Key, size_t > cardinalities={})
 Construct from container of keys and map of cardinalities.
DiscreteKeys discreteKeys () const
 Return all the discrete keys associated with this factor.
std::map< Key, size_t > cardinalities () const
size_t cardinality (Key j) const
double operator() (const DiscreteValues &values) const
 Find value for given assignment of values to variables.
double error (const HybridValues &c) const override
 All factor types need to implement an error function.
virtual AlgebraicDecisionTree< Key > errorTree () const
 Compute error for each assignment and return as a tree.
DiscreteFactor::shared_ptr scale () const
 Scale the factor values by the maximum to prevent underflow/overflow.
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 typename Base::NodePtr root)
 Constructor which accepts root pointer.
 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 (const DecisionTree< Key, X > &other, Func f)
 Create from an arbitrary DecisionTree<L, X> by operating on it with a functional f.
AlgebraicDecisionTree operator+ (const AlgebraicDecisionTree &g) const
 sum
AlgebraicDecisionTree operator- () const
 negation
AlgebraicDecisionTree operator- (const AlgebraicDecisionTree &g) const
 subtract
AlgebraicDecisionTree operator* (const AlgebraicDecisionTree &g) const
 product
AlgebraicDecisionTree operator/ (const AlgebraicDecisionTree &g) const
 division
double sum () const
 Compute sum of all values.
AlgebraicDecisionTree normalize () const
 Helper method to perform normalization such that all leaves in the tree sum to 1.
double min () const
 Find the minimum values amongst all leaves.
double max () const
 Find the maximum values amongst all leaves.
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.
 DecisionTree (const Unary &op, DecisionTree &&other) noexcept
 Move constructor for DecisionTree.
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 translate 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 restrict (const Assignment< L > &assignment) const
 Choose multiple values.
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
template<typename A, typename B>
std::pair< DecisionTree< L, A >, DecisionTree< L, B > > split (std::function< std::pair< A, B >(const Y &)> AB_of_Y) const
 Convert into two trees with value types A and B.
 DecisionTree (const NodePtr &root)
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.
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 This = DiscreteLookupTable
using shared_ptr = std::shared_ptr<This>
using BaseConditional = Conditional<DecisionTreeFactor, This>
Public Types inherited from gtsam::DiscreteConditional
typedef DiscreteConditional This
 Typedef to this class.
typedef std::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 std::shared_ptr< DecisionTreeFactor > shared_ptr
typedef AlgebraicDecisionTree< Key > ADT
using Binary
using Unary
using UnaryAssignment
Public Types inherited from gtsam::DiscreteFactor
typedef DiscreteFactor This
 This class.
typedef std::shared_ptr< DiscreteFactor > shared_ptr
 shared_ptr to this class
typedef Factor Base
 Our base class.
using Values = DiscreteValues
 backwards compatibility
using Unary = std::function<double(const double&)>
using UnaryAssignment
using Binary = std::function<double(const double, const double)>
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 std::pair< typename DecisionTreeFactor::const_iterator, typename DecisionTreeFactor::const_iterator > ConstFactorRange
 A mini implementation of an iterator range, to share const views of frontals and parents.
typedef ConstFactorRangeIterator Frontals
 View of the frontal keys (call frontals()).
typedef ConstFactorRangeIterator Parents
 View of the separator keys (call parents()).

Additional Inherited Members

static double safe_div (const double &a, const double &b)
template<typename Iterator>
static NodePtr compose (Iterator begin, Iterator end, const L &label)
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::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.
template<typename It, typename ValueIt>
static NodePtr build (It begin, It end, ValueIt beginY, ValueIt endY)
 Internal recursive function to create from keys, cardinalities, and Y values.
template<typename It, typename ValueIt>
static NodePtr create (It begin, It end, ValueIt beginY, ValueIt endY)
 Internal helper function to create a tree from keys, cardinalities, and Y values.
template<typename X>
static NodePtr convertFrom (const typename DecisionTree< L, X >::NodePtr &f, std::function< Y(const X &)> Y_of_X)
 Convert from a DecisionTree<L, X> to DecisionTree<L, Y>.
template<typename M, typename X>
static 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)
 Convert from a DecisionTree<M, X> to DecisionTree<L, Y>.
Protected Attributes inherited from gtsam::DiscreteFactor
std::map< Key, size_t > cardinalities_
 Map of Keys and their 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

◆ DiscreteLookupTable() [1/2]

gtsam::DiscreteLookupTable::DiscreteLookupTable ( size_t nFrontals,
const DiscreteKeys & keys,
const ADT & potentials )
inline

Construct a new Discrete Lookup Table object.

Parameters
nFrontalsnumber of frontal variables
keysa sorted list of gtsam::Keys
potentialsthe algebraic decision tree with lookup values

◆ DiscreteLookupTable() [2/2]

gtsam::DiscreteLookupTable::DiscreteLookupTable ( size_t nFrontals,
const DiscreteKeys & keys,
const TableFactor & potentials )
inline

Construct a new Discrete Lookup Table object.

Parameters
nFrontalsnumber of frontal variables
keysa sorted list of gtsam::Keys
potentialsDiscrete potentials as a TableFactor.

Member Function Documentation

◆ argmax()

size_t gtsam::DiscreteLookupTable::argmax ( const DiscreteValues & parentsValues) const

return assignment for single frontal variable that maximizes value.

Parameters
parentsValuesKnown assignments for the parents.
Returns
maximizing assignment for the frontal variable.

◆ argmaxInPlace()

void gtsam::DiscreteLookupTable::argmaxInPlace ( DiscreteValues * parentsValues) const

Calculate assignment for frontal variables that maximizes value.

Parameters
(in/out)parentsValues Known assignments for the parents.

◆ print()

void gtsam::DiscreteLookupTable::print ( const std::string & s = "Discrete Lookup Table: ",
const KeyFormatter & formatter = DefaultKeyFormatter ) const
overridevirtual

GTSAM-style print.

Reimplemented from gtsam::DiscreteConditional.

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