The default triangulation algorithm used by aGrUM. More...

#include <defaultTriangulation.h>

Inheritance diagram for gum::DefaultTriangulation:

Collaboration diagram for gum::DefaultTriangulation:

Public Member Functions
Constructors / Destructors
	DefaultTriangulation (const UndiGraph graph, const NodeProperty< Size > dom_sizes, bool minimality=false, double theRatio=GUM_QUASI_RATIO, double theThreshold=GUM_WEIGHT_THRESHOLD)
	basic constructor. initialize the triangulation More...

	DefaultTriangulation (bool minimality=false, double theRatio=GUM_QUASI_RATIO, double theThreshold=GUM_WEIGHT_THRESHOLD)
	default constructor: initialize the triangulation for an empty graph More...

	DefaultTriangulation (const DefaultTriangulation &from)
	copy constructor More...

	DefaultTriangulation (DefaultTriangulation &&from)
	move constructor More...

	~DefaultTriangulation ()
	destructor More...

virtual DefaultTriangulation *	newFactory () const
	virtual clone constructor More...

virtual DefaultTriangulation *	copyFactory () const
	virtual copy constructor More...

Accessors / Modifiers
double	maxLog10CliqueDomainSize ()
	returns the max of log10DomainSize of the cliques in the junction tree. More...

const NodeProperty< Size > *	domainSizes () const
	returns the domain sizes of the variables of the graph to be triangulated More...

Protected Attributes
EliminationSequenceStrategy *	_elimination_sequence_strategy {nullptr}
	the elimination sequence strategy used by the triangulation More...

JunctionTreeStrategy *	_junction_tree_strategy {nullptr}
	the junction tree strategy used by the triangulation More...

const NodeProperty< Size > *	_domain_sizes {nullptr}
	the domain sizes of the variables/nodes of the graph More...

Accessors / Modifiers
virtual void	setGraph (const UndiGraph graph, const NodeProperty< Size > domsizes)
	initialize the triangulation data structures for a new graph More...

const EdgeSet &	fillIns ()
	returns the fill-ins added by the triangulation algorithm More...

const std::vector< NodeId > &	eliminationOrder ()
	returns an elimination ordering compatible with the triangulated graph More...

Idx	eliminationOrder (const NodeId)
	returns the index of a given node in the elimination order (0 = first node eliminated) More...

const NodeProperty< NodeId > &	reverseEliminationOrder ()
	returns a table indicating, for each node, at which step it was deleted by the triangulation process More...

const UndiGraph &	triangulatedGraph ()
	returns the triangulated graph More...

const CliqueGraph &	eliminationTree ()
	returns the elimination tree of a compatible ordering More...

const CliqueGraph &	junctionTree ()
	returns a compatible junction tree More...

NodeId	createdJunctionTreeClique (const NodeId id)
	returns the Id of the clique of the junction tree created by the elimination of a given node during the triangulation process More...

const NodeProperty< NodeId > &	createdJunctionTreeCliques ()
	returns the Ids of the cliques of the junction tree created by the elimination of the nodes More...

const CliqueGraph &	maxPrimeSubgraphTree ()
	returns a junction tree of maximal prime subgraphs More...

NodeId	createdMaxPrimeSubgraph (const NodeId id)
	returns the Id of the maximal prime subgraph created by the elimination of a given node during the triangulation process More...

void	clear ()
	reinitialize the graph to be triangulated to an empty graph More...

void	setMinimalRequirement (bool)
	sets/unset the minimality requirement More...

virtual bool	isMinimalityRequired () const final
	indicates wether minimality is required More...

void	setFillIns (bool)
	sets/unsets the record of the fill-ins in the standard triangulation procedure More...

const UndiGraph *	originalGraph () const
	returns the graph to be triangulated More...

EliminationSequenceStrategy &	eliminationSequenceStrategy () const
	returns the elimination sequence strategy used by the triangulation More...

JunctionTreeStrategy &	junctionTreeStrategy () const
	returns the junction tree strategy used by the triangulation More...

virtual void	_initTriangulation (UndiGraph &graph)
	the function called to initialize the triangulation process More...

Detailed Description

The default triangulation algorithm used by aGrUM.

By default, this is the very class used by aGrUM for performing triangulations. The algorithm used is the following:

the graph passed in argument is completed by fill-ins until it becomes

triangulated

then an elimination tree is computed from this triangulated graph

finally, a junction tree is derived from the elimination tree

The triangulation step first tries to remove simplicial nodes, that is, nodes that belong to only one clique. Then almost simplicial nodes of low width are removed (almost simplicial nodes are nodes such that all but one of their neighbors form a clique). Then quasi simplicial nodes are removed, that is, nodes such that the ratio of the number of fill-ins to add to form a clique by the number of edges in a clique is small. Then nodes that create cliques of small weight are removed.

The transformation from the elimination tree to the join tree is performed bottom-up. Each time a node of the elimination tree is identified to be a sub-clique, it is removed and all of its parents but one are linked to the latter. The identification of sub-cliques is very fast (comparison of 2 ints).

Definition at line 59 of file defaultTriangulation.h.

Constructor & Destructor Documentation

◆ DefaultTriangulation() [1/4]

gum::DefaultTriangulation::DefaultTriangulation	(	const UndiGraph *	graph,
		const NodeProperty< Size > *	dom_sizes,
		bool	minimality = `false`,
		double	theRatio = `GUM_QUASI_RATIO`,
		double	theThreshold = `GUM_WEIGHT_THRESHOLD`
	)

explicit

basic constructor. initialize the triangulation

◆ DefaultTriangulation() [2/4]

gum::DefaultTriangulation::DefaultTriangulation	(	bool	minimality = `false`,
		double	theRatio = `GUM_QUASI_RATIO`,
		double	theThreshold = `GUM_WEIGHT_THRESHOLD`
	)

explicit

default constructor: initialize the triangulation for an empty graph

◆ DefaultTriangulation() [3/4]

gum::DefaultTriangulation::DefaultTriangulation ( const DefaultTriangulation & from )

copy constructor

◆ DefaultTriangulation() [4/4]

gum::DefaultTriangulation::DefaultTriangulation ( DefaultTriangulation && from )

move constructor

◆ ~DefaultTriangulation()

gum::DefaultTriangulation::~DefaultTriangulation ( )

destructor

Member Function Documentation

◆ _initTriangulation()

void gum::StaticTriangulation::_initTriangulation ( UndiGraph & graph )

protectedvirtualinherited

the function called to initialize the triangulation process

This function is called when the triangulation process starts and is used to initialize the elimination sequence strategy. Actually, the graph that is modified by the triangulation algorithm is a copy of the original graph, and this copy needs be known by the elimination sequence strategy. _initTriangulation is used to transmit this knowledge to the elimination sequence (through method setGraph of the elimination sequence class).

Parameters

graph the very graph that is triangulated (this is a copy of __original_graph)

Reimplemented in gum::PartialOrderedTriangulation, and gum::OrderedTriangulation.

Definition at line 730 of file staticTriangulation.cpp.

References gum::Triangulation::_domain_sizes, gum::StaticTriangulation::_elimination_sequence_strategy, and gum::EliminationSequenceStrategy::setGraph().

Referenced by gum::StaticTriangulation::__triangulate().

                                                                {
     _elimination_sequence_strategy->setGraph(&graph, _domain_sizes);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ clear()

void gum::StaticTriangulation::clear ( )

virtualinherited

reinitialize the graph to be triangulated to an empty graph

Implements gum::Triangulation.

Definition at line 162 of file staticTriangulation.cpp.

Referenced by gum::StaticTriangulation::setGraph().

                                   {
     // clear the factories
     _elimination_sequence_strategy->clear();
     _junction_tree_strategy->clear();
 
     // remove the current graphs
     __original_graph = nullptr;
     __junction_tree = nullptr;
     __triangulated_graph.clear();
     __elim_tree.clear();
     __max_prime_junction_tree.clear();
     __elim_cliques.clear();
     __node_2_max_prime_clique.clear();
 
     // remove all fill-ins and orderings
     __fill_ins.clear();
     __added_fill_ins.clear();
     __elim_order.clear();
     __reverse_elim_order.clear();
 
     // indicates that the junction tree, the max prime tree, etc, are updated
     __has_triangulation = true;
     __has_triangulated_graph = true;
     __has_elimination_tree = true;
     __has_junction_tree = true;
     __has_max_prime_junction_tree = true;
     __has_fill_ins = true;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ copyFactory()

virtual DefaultTriangulation* gum::DefaultTriangulation::copyFactory ( ) const

virtual

virtual copy constructor

Implements gum::UnconstrainedTriangulation.

◆ createdJunctionTreeClique()

NodeId gum::StaticTriangulation::createdJunctionTreeClique ( const NodeId id )

virtualinherited

returns the Id of the clique of the junction tree created by the elimination of a given node during the triangulation process

Implements gum::Triangulation.

◆ createdJunctionTreeCliques()

const NodeProperty< NodeId >& gum::StaticTriangulation::createdJunctionTreeCliques ( )

virtualinherited

returns the Ids of the cliques of the junction tree created by the elimination of the nodes

Implements gum::Triangulation.

◆ createdMaxPrimeSubgraph()

NodeId gum::StaticTriangulation::createdMaxPrimeSubgraph ( const NodeId id )

virtualinherited

returns the Id of the maximal prime subgraph created by the elimination of a given node during the triangulation process

Implements gum::Triangulation.

◆ domainSizes()

const NodeProperty< Size >* gum::Triangulation::domainSizes ( ) const

inherited

returns the domain sizes of the variables of the graph to be triangulated

◆ eliminationOrder() [1/2]

const std::vector< NodeId >& gum::StaticTriangulation::eliminationOrder ( )

virtualinherited

returns an elimination ordering compatible with the triangulated graph

Implements gum::Triangulation.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), gum::DefaultJunctionTreeStrategy::__computeJunctionTree(), gum::prm::SVED< GUM_SCALAR >::__eliminateNodes(), gum::prm::SVE< GUM_SCALAR >::__eliminateNodes(), gum::prm::SVED< GUM_SCALAR >::__eliminateNodesWithEvidence(), gum::prm::SVE< GUM_SCALAR >::__eliminateNodesWithEvidence(), gum::prm::gspan::StrictSearch< GUM_SCALAR >::__elimination_cost(), gum::prm::SVE< GUM_SCALAR >::__initLiftedNodes(), gum::prm::StructuredInference< GUM_SCALAR >::__reduceAloneInstances(), and gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern().

Here is the caller graph for this function:

◆ eliminationOrder() [2/2]

Idx gum::StaticTriangulation::eliminationOrder ( const NodeId )

virtualinherited

returns the index of a given node in the elimination order (0 = first node eliminated)

Implements gum::Triangulation.

◆ eliminationSequenceStrategy()

EliminationSequenceStrategy& gum::StaticTriangulation::eliminationSequenceStrategy ( ) const

inherited

returns the elimination sequence strategy used by the triangulation

◆ eliminationTree()

const CliqueGraph& gum::StaticTriangulation::eliminationTree ( )

virtualinherited

returns the elimination tree of a compatible ordering

Implements gum::Triangulation.

Referenced by gum::DefaultJunctionTreeStrategy::__computeJunctionTree().

Here is the caller graph for this function:

◆ fillIns()

const EdgeSet & gum::StaticTriangulation::fillIns ( )

virtualinherited

returns the fill-ins added by the triangulation algorithm

Implements gum::Triangulation.

Definition at line 676 of file staticTriangulation.cpp.

                                               {
     // if we did not compute the triangulation yet, do it and commpute
     // the fill-ins at the same time
     if (!__has_triangulation) {
       bool want_fill_ins = __we_want_fill_ins;
       __we_want_fill_ins = true;
       __triangulate();
       __we_want_fill_ins = want_fill_ins;
       __has_fill_ins = true;
     }
 
     // here, we already computed a triangulation and we already computed
     // the fill-ins, so return them
     if (__has_fill_ins) {
       if (_elimination_sequence_strategy->providesFillIns())
         return _elimination_sequence_strategy->fillIns();
       else
         return __fill_ins;
     } else {
       // ok, here, we shall compute the fill-ins as they were not precomputed
       if (!__original_graph) return __fill_ins;
 
       // just in case, be sure that the junction tree has been constructed
       if (!__has_junction_tree) junctionTree();
 
       for (const auto clik_id : __junction_tree->nodes()) {
         // for each clique, add the edges necessary to make it complete
         const NodeSet&        clique = __junction_tree->clique(clik_id);
         std::vector< NodeId > clique_nodes(clique.size());
         unsigned int          i = 0;
 
         for (const auto node : clique) {
           clique_nodes[i] = node;
           i += 1;
         }
 
         for (i = 0; i < clique_nodes.size(); ++i) {
           for (unsigned int j = i + 1; j < clique_nodes.size(); ++j) {
             Edge edge(clique_nodes[i], clique_nodes[j]);
 
             if (!__original_graph->existsEdge(edge)) {
               try {
                 __fill_ins.insert(edge);
               } catch (DuplicateElement&) {}
             }
           }
         }
       }
 
       return __fill_ins;
     }
   }

Here is the call graph for this function:

◆ isMinimalityRequired()

virtual bool gum::StaticTriangulation::isMinimalityRequired ( ) const

finalvirtualinherited

indicates wether minimality is required

◆ junctionTree()

const CliqueGraph& gum::StaticTriangulation::junctionTree ( )

virtualinherited

returns a compatible junction tree

Implements gum::Triangulation.

Referenced by gum::StaticTriangulation::__computeMaxPrimeJunctionTree(), gum::StaticTriangulation::fillIns(), and gum::StaticTriangulation::triangulatedGraph().

Here is the caller graph for this function:

◆ junctionTreeStrategy()

JunctionTreeStrategy& gum::StaticTriangulation::junctionTreeStrategy ( ) const

inherited

returns the junction tree strategy used by the triangulation

◆ maxLog10CliqueDomainSize()

double gum::Triangulation::maxLog10CliqueDomainSize ( )

inherited

returns the max of log10DomainSize of the cliques in the junction tree.

This is usefull for instance to estimate the complexity (both in space and in time) of the inference that will use the junction tree.

This method is not 'const' since it can be called before building any junction tree and hence it needs to build it...

Definition at line 67 of file triangulation.cpp.

References gum::Triangulation::_domain_sizes, and gum::Triangulation::junctionTree().

Referenced by gum::MaxInducedWidthMCBayesNetGenerator< GUM_SCALAR, ICPTGenerator, ICPTDisturber >::__checkConditions().

                                                  {
     double              res = 0.0;
     double              dSize;
     const JunctionTree& jt = junctionTree();   // here, the fact that we get
     // a junction tree ensures that _domain_sizes is different from nullptr
 
     for (const NodeId cl : jt) {
       dSize = 0.0;
 
       for (const auto node : jt.clique(cl))
         dSize += std::log10((*_domain_sizes)[node]);
 
       if (res < dSize) res = dSize;
     }
 
     return res;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ maxPrimeSubgraphTree()

const CliqueGraph& gum::StaticTriangulation::maxPrimeSubgraphTree ( )

virtualinherited

returns a junction tree of maximal prime subgraphs

Warning: Actually, the cliques of the junction tree are guarranteed to be maximal prime subgraph of the original graph that was triangulated only if the triangulation performed is minimal (in the sense that removing any edge in the triangulated graph results in a nontriangulated graph). This can be ensured by requiring minimality of the triangulation.

Implements gum::Triangulation.

◆ newFactory()

virtual DefaultTriangulation* gum::DefaultTriangulation::newFactory ( ) const

virtual

virtual clone constructor

returns a fresh triangulation (over an empty graph) of the same type as the current object

note that we return a pointer as it enables subclasses to return pointers to their types, not Triangulation pointers. See item 25 of the more effective C++.

Implements gum::UnconstrainedTriangulation.

◆ operator=()

DefaultTriangulation& gum::DefaultTriangulation::operator= ( const DefaultTriangulation & )

private

forbid copy operator

◆ originalGraph()

const UndiGraph* gum::StaticTriangulation::originalGraph ( ) const

inherited

returns the graph to be triangulated

Warning: if we have not set yet a graph, then originalGraph () will return a nullptr.

Referenced by gum::DefaultJunctionTreeStrategy::copyFactory().

Here is the caller graph for this function:

◆ reverseEliminationOrder()

const NodeProperty< NodeId >& gum::StaticTriangulation::reverseEliminationOrder ( )

inherited

returns a table indicating, for each node, at which step it was deleted by the triangulation process

◆ setFillIns()

void gum::StaticTriangulation::setFillIns ( bool )

inherited

sets/unsets the record of the fill-ins in the standard triangulation procedure

◆ setGraph()

void gum::StaticTriangulation::setGraph	(	const UndiGraph *	graph,
		const NodeProperty< Size > *	domsizes
	)

virtualinherited

initialize the triangulation data structures for a new graph

Parameters

graph	the graph to be triangulated, i.e., the nodes of which will be eliminated
domsizes	the domain sizes of the nodes to be eliminated

Warning: Note that we allow domsizes to be defined over nodes/variables that do not belong to graph. These sizes will simply be ignored. However, it is compulsory that all the nodes of graph belong to dom_sizes; the graph is not copied but only referenced by the elimination sequence algorithm.

Implements gum::Triangulation.

Reimplemented in gum::PartialOrderedTriangulation, and gum::OrderedTriangulation.

Definition at line 523 of file staticTriangulation.cpp.

Referenced by gum::OrderedTriangulation::setGraph(), and gum::PartialOrderedTriangulation::setGraph().

                                                                            {
     // remove the old graph
     clear();
 
     if (graph != nullptr) {
       // prepare the size of the data for the new graph
       __elim_order.resize(graph->size());
       __reverse_elim_order.resize(graph->size());
       __elim_cliques.resize(graph->size());
       __added_fill_ins.resize(graph->size());
       __node_2_max_prime_clique.resize(graph->size());
     }
 
     // keep track of the variables passed in argument
     __original_graph = graph;
     _domain_sizes = domsizes;
 
     // indicate that no triangulation was performed for this graph
     __has_triangulation = false;
     __has_triangulated_graph = false;
     __has_elimination_tree = false;
     __has_junction_tree = false;
     __has_max_prime_junction_tree = false;
     __has_fill_ins = false;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setMinimalRequirement()

void gum::StaticTriangulation::setMinimalRequirement ( bool )

inherited

sets/unset the minimality requirement

◆ triangulatedGraph()

const UndiGraph & gum::StaticTriangulation::triangulatedGraph ( )

virtualinherited

returns the triangulated graph

Implements gum::Triangulation.

Definition at line 484 of file staticTriangulation.cpp.

References gum::StaticTriangulation::__has_junction_tree, gum::StaticTriangulation::__has_triangulated_graph, gum::StaticTriangulation::__has_triangulation, gum::StaticTriangulation::__junction_tree, gum::StaticTriangulation::__original_graph, gum::StaticTriangulation::__triangulate(), gum::StaticTriangulation::__triangulated_graph, gum::UndiGraph::addEdge(), gum::StaticTriangulation::junctionTree(), and gum::Set< Key, Alloc >::size().

                                                           {
     if (!__has_triangulation) __triangulate();
 
     // if we did not construct the triangulated graph during the triangulation,
     // that is, we just constructed the junction tree, we shall construct it now
     if (!__has_triangulated_graph) {
       // just in case, be sure that the junction tree has been constructed
       if (!__has_junction_tree) junctionTree();
 
       // copy the original graph
       __triangulated_graph = *__original_graph;
 
       for (const auto clik_id : *__junction_tree) {
         // for each clique, add the edges necessary to make it complete
         const NodeSet&        clique = __junction_tree->clique(clik_id);
         std::vector< NodeId > clique_nodes(clique.size());
         unsigned int          i = 0;
 
         for (const auto node : clique) {
           clique_nodes[i] = node;
           i += 1;
         }
 
         for (i = 0; i < clique_nodes.size(); ++i) {
           for (unsigned int j = i + 1; j < clique_nodes.size(); ++j) {
             try {
               __triangulated_graph.addEdge(clique_nodes[i], clique_nodes[j]);
             } catch (DuplicateElement&) {}
           }
         }
       }
 
       __has_triangulated_graph = true;
     }
 
     return __triangulated_graph;
   }

Here is the call graph for this function:

Member Data Documentation

◆ __quasi_ratio

double gum::DefaultTriangulation::__quasi_ratio

private

the ratio above which we consider nodes to be quasi simplicial

Definition at line 104 of file defaultTriangulation.h.

◆ __threshold

double gum::DefaultTriangulation::__threshold

private

threshold under which almost and quasi simplicial nodes can be chosen to be eliminated

Definition at line 108 of file defaultTriangulation.h.

◆ _domain_sizes

const NodeProperty< Size >* gum::Triangulation::_domain_sizes {nullptr}

protectedinherited

the domain sizes of the variables/nodes of the graph

Definition at line 149 of file triangulation.h.

Referenced by gum::OrderedTriangulation::_initTriangulation(), gum::PartialOrderedTriangulation::_initTriangulation(), gum::StaticTriangulation::_initTriangulation(), gum::Triangulation::maxLog10CliqueDomainSize(), and gum::StaticTriangulation::setGraph().

◆ _elimination_sequence_strategy

EliminationSequenceStrategy* gum::StaticTriangulation::_elimination_sequence_strategy {nullptr}

protectedinherited

the elimination sequence strategy used by the triangulation

Definition at line 228 of file staticTriangulation.h.

Referenced by gum::StaticTriangulation::__triangulate(), gum::OrderedTriangulation::_initTriangulation(), gum::PartialOrderedTriangulation::_initTriangulation(), gum::StaticTriangulation::_initTriangulation(), gum::StaticTriangulation::clear(), gum::StaticTriangulation::fillIns(), gum::OrderedTriangulation::newFactory(), gum::PartialOrderedTriangulation::newFactory(), gum::OrderedTriangulation::OrderedTriangulation(), gum::PartialOrderedTriangulation::PartialOrderedTriangulation(), gum::OrderedTriangulation::setGraph(), gum::PartialOrderedTriangulation::setGraph(), gum::OrderedTriangulation::setOrder(), gum::PartialOrderedTriangulation::setPartialOrder(), gum::StaticTriangulation::StaticTriangulation(), and gum::StaticTriangulation::~StaticTriangulation().

◆ _junction_tree_strategy

JunctionTreeStrategy* gum::StaticTriangulation::_junction_tree_strategy {nullptr}

protectedinherited

the junction tree strategy used by the triangulation

Definition at line 231 of file staticTriangulation.h.

Referenced by gum::StaticTriangulation::__computeMaxPrimeJunctionTree(), gum::StaticTriangulation::clear(), gum::OrderedTriangulation::newFactory(), gum::PartialOrderedTriangulation::newFactory(), gum::StaticTriangulation::StaticTriangulation(), and gum::StaticTriangulation::~StaticTriangulation().

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

agrum/graphs/algorithms/triangulations/defaultTriangulation.h

Public Member Functions

Protected Attributes

Accessors / Modifiers

Detailed Description

the graph passed in argument is completed by fill-ins until it becomes

then an elimination tree is computed from this triangulated graph

finally, a junction tree is derived from the elimination tree

Constructor & Destructor Documentation

◆ DefaultTriangulation() [1/4]

◆ DefaultTriangulation() [2/4]

◆ DefaultTriangulation() [3/4]

◆ DefaultTriangulation() [4/4]

◆ ~DefaultTriangulation()

Member Function Documentation

◆ _initTriangulation()

◆ clear()

◆ copyFactory()

◆ createdJunctionTreeClique()

◆ createdJunctionTreeCliques()

◆ createdMaxPrimeSubgraph()

◆ domainSizes()

◆ eliminationOrder() [1/2]

◆ eliminationOrder() [2/2]

◆ eliminationSequenceStrategy()

◆ eliminationTree()

◆ fillIns()

◆ isMinimalityRequired()

◆ junctionTree()

◆ junctionTreeStrategy()

◆ maxLog10CliqueDomainSize()

◆ maxPrimeSubgraphTree()

◆ newFactory()

◆ operator=()

◆ originalGraph()

◆ reverseEliminationOrder()

◆ setFillIns()

◆ setGraph()

◆ setMinimalRequirement()

◆ triangulatedGraph()

Member Data Documentation

◆ __quasi_ratio

◆ __threshold

◆ _domain_sizes

◆ _elimination_sequence_strategy

◆ _junction_tree_strategy