89 lines
3.3 KiB
C++
89 lines
3.3 KiB
C++
/* ----------------------------------------------------------------------------
|
|
|
|
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
|
|
* Atlanta, Georgia 30332-0415
|
|
* All Rights Reserved
|
|
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
|
|
|
|
* See LICENSE for the license information
|
|
|
|
* -------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @file SymbolicSequentialSolver.h
|
|
* @author Richard Roberts
|
|
* @date Oct 21, 2010
|
|
*/
|
|
#pragma once
|
|
|
|
#include <gtsam/inference/GenericSequentialSolver.h>
|
|
#include <gtsam/inference/SymbolicFactorGraph.h>
|
|
|
|
namespace gtsam {
|
|
|
|
class SymbolicSequentialSolver : GenericSequentialSolver<IndexFactor> {
|
|
|
|
protected:
|
|
typedef GenericSequentialSolver<IndexFactor> Base;
|
|
|
|
public:
|
|
/**
|
|
* Construct the solver for a factor graph. This builds the junction
|
|
* tree, which does the symbolic elimination, identifies the cliques,
|
|
* and distributes all the factors to the right cliques.
|
|
*/
|
|
SymbolicSequentialSolver(const SymbolicFactorGraph& factorGraph) : Base(factorGraph) {};
|
|
|
|
/**
|
|
* Construct the solver with a shared pointer to a factor graph and to a
|
|
* VariableIndex. The solver will store these pointers, so this constructor
|
|
* is the fastest.
|
|
*/
|
|
SymbolicSequentialSolver(const SymbolicFactorGraph::shared_ptr& factorGraph,
|
|
const VariableIndex::shared_ptr& variableIndex) : Base(factorGraph, variableIndex) {};
|
|
|
|
/** Print to cout */
|
|
void print(const std::string& name = "SymbolicSequentialSolver: ") const { Base::print(name); };
|
|
|
|
/** Test whether is equal to another */
|
|
bool equals(const SymbolicSequentialSolver& other, double tol = 1e-9) const { return Base::equals(other, tol); };
|
|
|
|
/**
|
|
* Eliminate the factor graph sequentially. Uses a column elimination tree
|
|
* to recursively eliminate.
|
|
*/
|
|
SymbolicBayesNet::shared_ptr eliminate() const
|
|
{ return Base::eliminate(&EliminateSymbolic); };
|
|
|
|
/**
|
|
* Compute a conditional density P(F|S) while marginalizing out variables J
|
|
* P(F|S) is obtained by P(J,F,S)=P(J|F,S)P(F|S)P(S) and dropping P(S)
|
|
* Returns the result as a Bayes net.
|
|
*/
|
|
SymbolicBayesNet::shared_ptr conditionalBayesNet(const std::vector<Index>& js, size_t nrFrontals) const
|
|
{ return Base::conditionalBayesNet(js, nrFrontals, &EliminateSymbolic); };
|
|
|
|
/**
|
|
* Compute the marginal joint over a set of variables, by integrating out
|
|
* all of the other variables. Returns the result as a Bayes net.
|
|
*/
|
|
SymbolicBayesNet::shared_ptr jointBayesNet(const std::vector<Index>& js) const
|
|
{ return Base::jointBayesNet(js, &EliminateSymbolic); };
|
|
|
|
/**
|
|
* Compute the marginal joint over a set of variables, by integrating out
|
|
* all of the other variables. Returns the result as a factor graph.
|
|
*/
|
|
SymbolicFactorGraph::shared_ptr jointFactorGraph(const std::vector<Index>& js) const
|
|
{ return Base::jointFactorGraph(js, &EliminateSymbolic); };
|
|
|
|
/**
|
|
* Compute the marginal Gaussian density over a variable, by integrating out
|
|
* all of the other variables. This function returns the result as a factor.
|
|
*/
|
|
IndexFactor::shared_ptr marginalFactor(Index j) const { return Base::marginalFactor(j, &EliminateSymbolic); };
|
|
};
|
|
|
|
}
|
|
|