libDAI-0.2.7/0000755000263000017630000000000011433222327011457 5ustar jorismkyblibDAI-0.2.7/swig/0000755000263000017630000000000011433220720012423 5ustar jorismkyblibDAI-0.2.7/swig/example_sprinkler.m0000644000263000017630000000573011433220720016332 0ustar jorismkyb% This file is part of libDAI - http://www.libdai.org/ % % libDAI is licensed under the terms of the GNU General Public License version % 2, or (at your option) any later version. libDAI is distributed without any % warranty. See the file COPYING for more details. % % Copyright (C) 2009 Joris Mooij [joris dot mooij at libdai dot org] % This example program illustrates how to construct a factorgraph % by means of the sprinkler network example discussed at % http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html % using the SWIG octave wrapper of libDAI dai C = dai.Var(0, 2); % Define binary variable Cloudy (with label 0) S = dai.Var(1, 2); % Define binary variable Sprinkler (with label 1) R = dai.Var(2, 2); % Define binary variable Rain (with label 2) W = dai.Var(3, 2); % Define binary variable Wetgrass (with label 3) % Define probability distribution for C P_C = dai.Factor(C); P_C(0) = 0.5; % C = 0 P_C(1) = 0.5; % C = 1 % Define conditional probability of S given C P_S_given_C = dai.Factor(dai.VarSet(S,C)); P_S_given_C(0) = 0.5; % C = 0, S = 0 P_S_given_C(1) = 0.9; % C = 1, S = 0 P_S_given_C(2) = 0.5; % C = 0, S = 1 P_S_given_C(3) = 0.1; % C = 1, S = 1 % Define conditional probability of R given C P_R_given_C = dai.Factor(dai.VarSet(R,C)); P_R_given_C(0) = 0.8; % C = 0, R = 0 P_R_given_C(1) = 0.2; % C = 1, R = 0 P_R_given_C(2) = 0.2; % C = 0, R = 1 P_R_given_C(3) = 0.8; % C = 1, R = 1 % Define conditional probability of W given S and R SRW = dai.VarSet(S,R); SRW.append(W); P_W_given_S_R = dai.Factor(SRW); P_W_given_S_R(0) = 1.0; % S = 0, R = 0, W = 0 P_W_given_S_R(1) = 0.1; % S = 1, R = 0, W = 0 P_W_given_S_R(2) = 0.1; % S = 0, R = 1, W = 0 P_W_given_S_R(3) = 0.01; % S = 1, R = 1, W = 0 P_W_given_S_R(4) = 0.0; % S = 0, R = 0, W = 1 P_W_given_S_R(5) = 0.9; % S = 1, R = 0, W = 1 P_W_given_S_R(6) = 0.9; % S = 0, R = 1, W = 1 P_W_given_S_R(7) = 0.99; % S = 1, R = 1, W = 1 % Build factor graph consisting of those four factors SprinklerFactors = dai.VecFactor(); SprinklerFactors.append(P_C); SprinklerFactors.append(P_R_given_C); SprinklerFactors.append(P_S_given_C); SprinklerFactors.append(P_W_given_S_R); SprinklerNetwork = dai.FactorGraph(SprinklerFactors); % Write factorgraph to a file SprinklerNetwork.WriteToFile('sprinkler.fg'); fprintf('Sprinkler network written to sprinkler.fg\n'); % Output some information about the factorgraph fprintf('%d variables\n', SprinklerNetwork.nrVars()); fprintf('%d factors\n', SprinklerNetwork.nrFactors()); % Calculate joint probability of all four variables P = dai.Factor(); for I = 0:(SprinklerNetwork.nrFactors()-1) P *= SprinklerNetwork.factor(I); end P.normalize(); % Not necessary: a Bayesian network is already normalized by definition % Calculate some probabilities denom = P.marginal(dai.VarSet(W))(1); fprintf('P(W=1) = %f\n', denom); fprintf('P(S=1 | W=1) = %f\n', P.marginal(dai.VarSet(S,W))(3) / denom); fprintf('P(R=1 | W=1) = %f\n', P.marginal(dai.VarSet(R,W))(3) / denom); libDAI-0.2.7/swig/README0000644000263000017630000000026311433220720013304 0ustar jorismkybThis directory contains preliminary experimental SWIG wrappers for libDAI written by Patrick Pletscher. They enable usage of libDAI functionality directly from python and octave. libDAI-0.2.7/swig/Makefile0000644000263000017630000000161111433220720014062 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009 Patrick Pletscher [pletscher at inf dot ethz dot ch] include ../Makefile.conf .PHONY: all all: _dai.so dai.oct _dai.so: ../lib/libdai.a dai.i $(SWIG) -python -classic -c++ dai.i g++ -Wall -c -O3 -g -fPIC dai_wrap.cxx -I$(INCLUDE_PYTHON) -I$(INCLUDE_BOOST) -I../include g++ -shared dai_wrap.o -o _dai.so ../lib/libdai.a dai.oct: ../lib/libdai.a dai.i $(SWIG) -octave -c++ -o dai_wrap.cpp dai.i mkoctfile -I$(INCLUDE_BOOST) -I../include -o dai.oct dai_wrap.cpp ../lib/libdai.a .PHONY: clean clean: rm -f dai_wrap.cxx dai_wrap.cpp dai_wrap.o _dai.so dai.oct dai.py dai.pyc sprinkler.fg libDAI-0.2.7/swig/dai.i0000644000263000017630000000531611433220720013337 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Patrick Pletscher [pletscher at inf dot ethz dot ch] * 2009 Joris Mooij [joris dot mooij at libdai dot org] */ %module dai %{ #include "../include/dai/var.h" #include "../include/dai/smallset.h" #include "../include/dai/varset.h" #include "../include/dai/prob.h" #include "../include/dai/factor.h" #include "../include/dai/graph.h" #include "../include/dai/bipgraph.h" #include "../include/dai/factorgraph.h" #include "../include/dai/util.h" %} %ignore dai::TProb::operator[]; %ignore dai::TFactor::operator[]; %ignore dai::Var::label() const; %ignore dai::Var::states() const; %include "../include/dai/util.h" %include "../include/dai/var.h" %include "../include/dai/smallset.h" %template(SmallSetVar) dai::SmallSet< dai::Var >; %include "../include/dai/varset.h" %extend dai::VarSet { inline void append(const dai::Var &v) { (*self) |= v; } /* for python, octave */ }; %include "../include/dai/prob.h" %template(Prob) dai::TProb; %extend dai::TProb { inline dai::Real __getitem__(int i) const {return (*self).get(i);} /* for python */ inline void __setitem__(int i,dai::Real d) {(*self).set(i,d);} /* for python */ inline dai::Real __paren(int i) const {return (*self).get(i);} /* for octave */ inline void __paren_asgn(int i,dai::Real d) {(*self).set(i,d);} /* for octave */ }; %include "../include/dai/factor.h" %extend dai::TFactor { inline dai::Real __getitem__(int i) const {return (*self).get(i);} /* for python */ inline void __setitem__(int i,dai::Real d) {(*self).set(i,d);} /* for python */ inline dai::Real __paren__(int i) const {return (*self).get(i);} /* for octave */ inline void __paren_asgn__(int i,dai::Real d) {(*self).set(i,d);} /* for octave */ }; %template(Factor) dai::TFactor; %include "../include/dai/graph.h" %include "../include/dai/bipgraph.h" %include "../include/dai/factorgraph.h" %include "std_vector.i" // TODO: typemaps for the vectors (input/output python arrays) %inline{ typedef std::vector VecFactor; typedef std::vector< VecFactor > VecVecFactor; } %template(VecFactor) std::vector< dai::Factor >; %template(VecVecFactor) std::vector< VecFactor >; %include "../include/dai/index.h" %extend dai::multifor { inline size_t __getitem__(int i) const { return (*self)[i]; } inline void next() { return (*self)++; } }; libDAI-0.2.7/swig/example_sprinkler.py0000644000263000017630000000560611433220720016530 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009 Joris Mooij [joris dot mooij at libdai dot org] # This example program illustrates how to construct a factorgraph # by means of the sprinkler network example discussed at # http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html # using the SWIG python wrapper of libDAI import dai C = dai.Var(0, 2) # Define binary variable Cloudy (with label 0) S = dai.Var(1, 2) # Define binary variable Sprinkler (with label 1) R = dai.Var(2, 2) # Define binary variable Rain (with label 2) W = dai.Var(3, 2) # Define binary variable Wetgrass (with label 3) # Define probability distribution for C P_C = dai.Factor(C) P_C[0] = 0.5 # C = 0 P_C[1] = 0.5 # C = 1 # Define conditional probability of S given C P_S_given_C = dai.Factor(dai.VarSet(S,C)) P_S_given_C[0] = 0.5 # C = 0, S = 0 P_S_given_C[1] = 0.9 # C = 1, S = 0 P_S_given_C[2] = 0.5 # C = 0, S = 1 P_S_given_C[3] = 0.1 # C = 1, S = 1 # Define conditional probability of R given C P_R_given_C = dai.Factor(dai.VarSet(R,C)) P_R_given_C[0] = 0.8 # C = 0, R = 0 P_R_given_C[1] = 0.2 # C = 1, R = 0 P_R_given_C[2] = 0.2 # C = 0, R = 1 P_R_given_C[3] = 0.8 # C = 1, R = 1 # Define conditional probability of W given S and R SRW = dai.VarSet(S,R) SRW.append(W) P_W_given_S_R = dai.Factor(SRW) P_W_given_S_R[0] = 1.0 # S = 0, R = 0, W = 0 P_W_given_S_R[1] = 0.1 # S = 1, R = 0, W = 0 P_W_given_S_R[2] = 0.1 # S = 0, R = 1, W = 0 P_W_given_S_R[3] = 0.01 # S = 1, R = 1, W = 0 P_W_given_S_R[4] = 0.0 # S = 0, R = 0, W = 1 P_W_given_S_R[5] = 0.9 # S = 1, R = 0, W = 1 P_W_given_S_R[6] = 0.9 # S = 0, R = 1, W = 1 P_W_given_S_R[7] = 0.99 # S = 1, R = 1, W = 1 # Build factor graph consisting of those four factors SprinklerFactors = dai.VecFactor() SprinklerFactors.append(P_C) SprinklerFactors.append(P_R_given_C) SprinklerFactors.append(P_S_given_C) SprinklerFactors.append(P_W_given_S_R) SprinklerNetwork = dai.FactorGraph(SprinklerFactors) # Write factorgraph to a file SprinklerNetwork.WriteToFile('sprinkler.fg') print 'Sprinkler network written to sprinkler.fg' # Output some information about the factorgraph print SprinklerNetwork.nrVars(), 'variables' print SprinklerNetwork.nrFactors(), 'factors' # Calculate joint probability of all four variables P = dai.Factor() for I in range(SprinklerNetwork.nrFactors()): P *= SprinklerNetwork.factor(I) P.normalize() # Not necessary: a Bayesian network is already normalized by definition # Calculate some probabilities denom = P.marginal(dai.VarSet(W))[1] print 'P(W=1) =', denom print 'P(S=1 | W=1) =', P.marginal(dai.VarSet(S,W))[3] / denom print 'P(R=1 | W=1) =', P.marginal(dai.VarSet(R,W))[3] / denom libDAI-0.2.7/ChangeLog0000644000263000017630000012777311433220720013245 0ustar jorismkyblibDAI-0.2.7 (2010-08-19) ------------------------- * Removed interfaces deprecated in 0.2.6. * Fixed a bug in JTree::findMaximum() (reported by zhengyun84 and Dhruv Batra): if one or more variables had a MAP belief with more than one maximum, an incorrect MAP state could result. libDAI-0.2.6 (2010-08-05) ------------------------- New features: * Added decimation algorithm DecMAP for MAP inference (decmap.h/cpp). * Added source code for one of the winning solvers of the UAI 2010 Approximate Inference Challenge (examples/uai2010-aie-solver.cpp). * Added support for reading files in the UAI Approximate Inference Challenge format, supporting both the 2006/2008 evidence file format and the 2010 evidence file format (io.h/cpp). Miscellaneous improvements: * 'maxtime' property added to various algorithms (BP, Gibbs, HAK, TreeEP) for setting an upper limit on execution time. * 'maxmem' property added to JTree for setting an upper limit on memory usage. * SmallSet: - Added SmallSet::erase( const T& t ). * VarSet: - nrStates() now returns a long double instead of a size_t. * Permute: - Added ranges() accessor. - Added inverse() method. - Added optional reverse argument to Permute( const std::vector& ) constructor. * Factor: - Added createFactorDelta( const VarSet& vs, size_t state ). * ClusterGraph: - Added ClusterGraph(const FactorGraph& fg, bool onlyMaximal) constructor. - Added findCluster( const VarSet& cl ). - Added elimVar( size_t i ). - Added 'maxStates' argument to VarElim( EliminationChoice f, size_t maxStates=0 ). * FactorGraph: - Added isMaximal(size_t). - Added maximalFactor(size_t). - Added FactorGraph::logScore( const std::vector& statevec ). * Gibbs: - Added 'restart' property. - Added Gibbs::findMaximum() for MAP inference. * HAK: - Optimized region graph construction for HAK/GBP with clusters=BETHE. * examples/examples_imagesegmentation.cpp: - [Peter Rockett] Improved Makefiles for image segmentation example. - Added build flag to specify the CImg version. * util.h/cpp: - Added fromString<>( const std::string& x ). Interface changes (the old interface is marked obsolete and will be removed in the next release): * Added InfAlg::setMaxIter(size_t) for setting the maximum number of iterations. * Deprecated Graph::Neighbor, BipartiteGraph::Neighbor and DAG::Neighbor and replaced them by a globally defined Neighbor structure * Deprecated Graph::Neighbors, BipartiteGraph::Neighbors and DAG::Neighbors and replaced them by a globally defined Neighbors type * Deprecated Graph::Edge, BipartiteGraph::Edge and DAG::Edge and replaced them by a globally defined Edge type * Renamed 'iters' property of Gibbs algorithm into 'maxiter'. * ClusterGraph::findVar( const Var& n ) no longer throws an exception if the variable is not found. * Deprecated 'void tokenizeString( const string&, vector&, const string& )' and replaced it with an improved version 'vector tokenizeString( const string&, bool, const string& )' * Removed interfaces deprecated in 0.2.5. Bug fixes: * Fixed a problem with isnan() on FreeBSD; it is now in the dai namespace. * Workaround for older g++ compilers (e.g. version 4.0.0 on Darwin 9.8.0) which have problems when comparing const_reverse_iterator with reverse_iterator. * [Matt Dunham] Fixed a bug in Factors2mx in src/matlab/matlab.cpp (segfault if factors depending on 0 variables were passed to MatLab) libDAI-0.2.5 (2010-05-09) ------------------------- New features: * Added unit tests for var, smallset, varset, graph, dag, bipgraph, weightedgraph, enum, util, exceptions, properties, index, prob, factor, factorgraph, clustergraph, regiongraph, daialg, alldai * [Ofer Meshi] Added a script for converting from FastInf to libDAI format * Added utils/uai2fg, a utility to convert the UAI inference competition file formats to the libDAI factor graph file format * Added dag.h/cpp, an implementation of Directed Acyclic Graphs * Added examples/example_imagesegmentation Miscellaneous improvements: * TRWBP: - Added initialization of TRWBP weights by sampling spanning trees * MF: - Added an "init" option that allows to initialize randomly - Added an "updates" option that allows to choose between standard mean field and "hard-spin" mean field * MR: - rewrote response propagation implementation with help of BBP - now uses GraphAL to represent the Markov graph - miscellaneous smaller cleanups * TreeEP: - Now also supports disconnected factor graphs * JTree: - Now also supports disconnected factor graphs * ExactInf: - Added findMaximum() * RegionGraph: - Added error checking code - Changed the way a RegionGraph is streamed to an std::ostream. * ClusterGraph: - Added nrVars() method - Added var( size_t ) method - Added cluster( size_t ) method * FactorGraph: - clamped() now contains a delta factor for the clamped variable - Added MarkovGraph() * TFactor: - Added takeAbs() - Added takeExp() - Added takeLog( bool ) - Added operator-() const - Added sumAbs() const - Added operator==( const TFactor &y ) - Added get(size_t), set(size_t,T) * TProb: - Added operator==( const TProb &q ) - accumulate() now also applies op2 to init - operator/= (T x) now yields 0 when dividing by 0 - Added resize(size_t) - Added get(size_t) and set(size_t,T) - Changed format of TProb when streamed to an ostream * multifor: - Added reset() * PropertySet: - Added size() - Added clear() - Added erase() * util.h/cpp: - Added std::string toString( const T& x ) * weightedgraph.h/cpp: - Added option to MaxSpanningTree and MinSpanningTree for choosing between Prim's algorithm and Kruskal's algorithm - Better error checking in RootedTree constructor - Added GraphEL::GraphEL( const GraphAL& G ) constructor * BipartiteGraph: - Added hasEdge() - Added findNb1() - Added findNb2() - Added nb1Set() - Added nb2Set() - Added operator==( const BipartiteGraph& ) - Added BipartiteGraph( size_t nr1, size_t nr2 ) constructor - Added operator<<( std::ostream&, const BipartiteGraph& ) * GraphAL: - Added hasEdge(size_t,size_t) - Added nbSet(size_t) - Added operator==( const GraphAL& ) - Added operator<<( std::ostream&, const GraphAL& ) * SmallSet: - Added insert( const T& t ) method * Improved regression test * Made all "verbose" properties optional * utils/createfg now has a new factor type ('ISINGUNIFORM') and the old 'ISING' factor type has been renamed to 'ISINGGAUSS' * tests/testdai option "marginals" now has five possible values: NONE outputs no marginals, VAR only variable marginals, FAC only factor marginals, VARFAC both types of marginals, and ALL outputs all marginals calculated by the algorithm. * Compressed Makefile Interface changes (the old interface is marked obsolete and will be removed in the next release): * Removed RandomDRegularGraph(), please use createGraphRegular() instead * TreeEP: - Changed construct( const RootedTree& ) into construct( const FactorGraph&, const RootedTree& ) * JTree: - Changed construct( const std::vector&, bool ) into construct( const FactorGraph&, const std::vector&, bool ) - Changed GenerateJT( const std::vector & ) into GenerateJT( const FactorGraph &, const std::vector & ) * RegionGraph: - Made (previously public) members G, ORs, IRs and fac2OR protected and added DAG() accessor which returns a reference to the region graph DAG structure (currently implemented as a BipartiteGraph). - Renamed calcCountingNumbers() into calcCVMCountingNumbers() and made it protected, because exposing it to the world serves no purpose. - Removed partial constructor RegionGraph( const FactorGraph& fg ) - Made RecomputeORs(), RecomputeORs( const VarSet& ) and RecomputeOR( size_t ) protected and renamed them by changing the "Recompute" into "recompute", because exposing them to the world serves no purpose. * ClusterGraph: - Made (previously public) members G, vars and clusters private and added bipGraph(), vars() and clusters() methods which offer read-only access to these members. - Deprecated toVector() - Renamed size() into nrClusters() * FactorGraph: - Renamed Cliques() into maximalFactorDomains() and made it faster - findVars( const VarSet& ) now returns a SmallSet and its argument now has a const-qualifier (which fixes a small bug). - Made (previously public) member G private and added the bipGraph() method, which offers read-only access to it. - Deprecated the iterator interface: o FactorGraph::iterator typedef o FactorGraph::const_iterator typedef o FactorGraph::begin() members o FactorGraph::end() members - Deprecated factor(size_t) which offered write access to a factor because using this functionality in the descendant RegionGraph is dangerous, as the outer regions are not automatically recomputed. * TFactor: - Renamed states() into nrStates() - Added get(size_t) and set(size_t,T) operators; get() is equivalent to "operator[](size_t) const" and set() should be used instead of the non-const operator[], which has been deprecated * TProb: - Deprecated TProb( TIterator begin, TIterator end, size_t sizeHint=0 ) constructor: the sizeHint argument no longer defaults to 0 - Deprecated accumulate( T init, binOp op1, unOp op2 ); instead, accumulateSum( T init, unOp op ) and accumulateMax( T init, unOp op, bool minimize ) should be used. - Deprecated TProb::NormType and TProb::DistType; ProbNormType and ProbDistType should be used instead. - Fixed bug by renaming operator<=() to operator<() - Added get(size_t) and set(size_t,T) operators; get() is equivalent to "operator[](size_t) const" and set() should be used instead of the non-const operator[], which has been deprecated * PropertySet: - Renamed Set() -> set() - Renamed Get() -> get() - Renamed GetAs() -> getAs() - Renamed ConvertTo() -> convertTo() * util.h/cpp: - Removed max( const std::vector &v ) * weightedgraph.h/cpp: - Renamed MaxSpanningTreePrims into MaxSpanningTree - Renamed MinSpanningTreePrims into MinSpanningTree - The vertices in DEdge and UEdge are now named "first" and "second" for compatibility with a std::pair * BipartiteGraph: - delta1() and delta2() now return a SmallSet instead of a vector * SmallSet: - The sizeHint argument of the iterator constructor SmallSet::SmallSet( TIterator begin, TIterator end, size_t sizeHint=0 ) no longer has a default value in order to avoid confusion with the SmallSet::SmallSet( const T &t1, const T &t2 ) constructor. Bug fixes: * [Stefano Pellegrini] Fixed bug in JTree::findMaximum() * [Stefano Pellegrini] Fixed bug in BP[logdomain=1,inference=MAXPROD] * Fixed some bugs in the MatLab interface build system * Fixed a bug in utils/fginfo.cpp * Fixed a bug in JTree::findMaximum() and simplified the code * Fixed bug in BBPCostFunction::operator=() which prevented the desired assignment from happening * RegionGraph::WriteToFile( const char* ), RegionGraph::ReadFromFile( const char * ) and RegionGraph::printDot( std::ostream& ) incorrectly called their respective FactorGraph ancestor methods; this has been corrected by letting them throw a NOT_IMPLEMENTED exception. * Fixed bug in FactorGraph::clone() * Fixed bug in min( const TFactor &, const TFactor & ) * Fixed bug in max( const TFactor &, const TFactor & ) * Fixed bug by renaming TProb::operator<=() to TProb::operator<() * Fixed bug in PropertySet::setAsString() * Fixed a bug in rnd_seed() * BipartiteGraph: - Fixed bug in eraseNode1() - Fixed bug in eraseNode2() - Fixed bug in isTree() * GraphAL: - Fixed bug in nrEdges() - Fixed bug in addEdge() - Fixed bug in isTree() - Fixed bug in eraseNode() - Fixed bug in printDot() * Fixed bug in createGraphGrid3D() * Fixed bug in createGraphRegular() libDAI-0.2.4 (2010-02-11) ------------------------- New features: * Implemented Tree-Reweighted BP * [Frederik Eaton] Implemented Fractional Belief Propagation Miscellaneous improvements: * Improved documentation * [Frederik Eaton] Added constructors for BBPCostFunction * [Frederik Eaton] Added accessor/mutator for the elements of a SmallSet<> * [Frederik Eaton] Added unary minus to TProb<> * [Frederik Eaton] Added Hellinger distance to TProb<>::DistType * [Frederik Eaton] Two small patches for src/jtree.cpp and utils/createfg.cpp * tests/testdai option "marginals" now has three possible values: NONE outputs no marginals, VAR only variable marginals, and ALL outputs all marginals calculated by the algorithm. * Strengthened convergence criteria of various algorithms * Added GraphAL, an adjacency list implementation for graphs, similar to (but simpler than) BipartiteGraph * Added some functionality to create various standard factors (the functions whose names start with "createFactor") * Added examples example_sprinkler_gibbs and example_sprinkler_em * Implemented various heuristics for choosing a variable elimination sequence in JTree * Added BETHE method for GBP/HAK cluster choice * Made alias support official part of the library Build system: * Moved platform independent build options into Makefile.ALL * Windows platform now needs Boost 1.37 or higher Code cleanup: * Cleaned up utils/createfg and tests/testdai * Cleanup of some duplicate code in BP, FBP, TRWBP Interface changes (the old interface is marked obsolete and will be removed in the next release): * Removed obsolete/deprecated stuff * Renamed Graph into GraphEL (for Graph, implemented as Edge List) * Renamed some functions of BipartiteGraph: add1() -> addNode1() erase1() -> eraseNode1() nr1() -> nrNodes1() add2() -> addNode2() erase2() -> eraseNode2() nr2() -> nrNodes2() * Renamed some functions in ClusterGraph: ClusterGraph::eliminationCost() -> ::eliminationCost_MinFill() ClusterGraph::VarElim() -> ClusterGraph::VarElim( sequentialVariableElimination( ElimSeq ) ) ClusterGraph::VarElim_MinFill() -> ClusterGraph::VarElim( greedyVariableElimination( eliminationCost_MinFill ) ) * Changed interface of one RegionGraph constructor * Renamed "Clamped BP" into "Conditioned BP" Bug fixes: * Fixed regression in scripts/regenerate-properties (now all errors are gathered before throwing the exception, as used to be the case) * Fixed FTBFS errors on MACOSX (thanks to Sebastian Riedel for reporting this bug) * [Alexander Schwing] Fixed error in BP that occured with damping and using log-domain updates * Fixed bug in HAK for trivial region graphs (with only one outer region and no inner regions), reported by Alejandro Lage. * Fixed long-standing bug in TreeEP (now, within-loop propagation optimization works) libDAI-0.2.3 (2009-11-16) ------------------------- New features: * Complete doxygen documentation (although more detailed documentation still has to be written) * [Charles Vaske] Added parameter learning for conditional probabilities by Expectation Maximization * [Patrick Pletscher] Added SWIG wrapper code for experimental python and octave interfaces * Added Max-Product functionality to JTree * [Frederik Eaton] Added Back-Belief-Propagation * [Frederik Eaton] Added approximate inference method "Clamped Belief Propagation" * [Frederik Eaton] Added approximate inference method "Gibbs sampling" Code cleanup: * Updated copyright headers * Cleaned up error handling by introducing the DAI_THROWE macro * Introduced DAI_DEBASSERT macro to abbreviate a common pattern * Replaced the standard assert() macro by DAI_ASSERT, which throws a dai::Exception and is even active if NDEBUG is defined * Removed all the virtual default constructors *::create(), as they are not used * [Frederik Eaton] Removed unnecessary copy constructors and assignment operators * [Frederik Eaton] Change cout to cerr in warnings and error messages Miscellaneous improvements: * BipartiteGraph: - Added eraseEdge( size_t n1, size_t n2 ) - [Frederik Eaton] Improved documentation of Neighbor * TProb: - Added divided_by(const TProb&) const - Added constructor TProb( const std::vector &v ) - Added size_t draw(), which draws a random index - [Frederik Eaton] Added setUniform() - [Frederik Eaton] Added sumAbs() - [Frederik Eaton] Added argmax() - [Giuseppe Passino] Added begin(), end() * TFactor: - [Giuseppe Passino] Added begin(), end() - [Charles Vaske] Added TFactor( const std::vector &vars, const std::vector &p ), which reorders variables to canonical ordering before storing the table - Added constructor TFactor( const VarSet &vars, const std::vector &v ) - Extended functionality of TFactor::operators +,-,+=,-= to handle different VarSets - Added TFactor::maxMarginal (similar to marginal but with max instead of sum) * State: - [Giuseppe Passino] Added prefix ++ operator * Permute: - [Charles Vaske] Added constructor in Permute for canonical variable ordering * FactorGraph: - [Frederik Eaton] Added clampVar() - [Frederik Eaton] Added clampFactor() - [Giuseppe Passino] Added begin(), end() * PropertySet: - Added keys(), for getting all keys - [Frederik Eaton] Added default constructor - [Frederik Eaton] Added constructor from string * InfAlg: - Added setProperties(), getProperties() and printProperties() - [Frederik Eaton] Added beliefV(), beliefF() * ExactInf: - Added calcMarginal(const VarSet &) * HAK: - Added "init" parameter to allow for random initialization * BP: - [Giuseppe Passino] Added findMaximum(), which can be used after running max-product BP to construct a global state with maximum probability * JTree: - Added findMaximum(), which can be used after running max-product JTree to construct a global state with maximum probability * MatLab interface: - MEX file dai now also returns variable and factor beliefs - [Sebastian Nowozin] MEX file dai now also optionally returns the MAP state (only for BP and JTree) * README is now created automatically from doxygen documentation * [Frederik Eaton] Added script for automatically generating properties code (used by CBP and BBP) * [Frederik Eaton] Added newInfAlgFromString to alldai.h/cpp * [Frederik Eaton] Added some utility macros (DAI_PV, DAI_DMSG, DAI_IFVERB) and functions (concat(),rnd()) to util.h * Changed output stream operator<< for Var and VarSet * [Frederik Eaton] Improved parsing code in tests/testdai to allow recursive alias substitutions * [Frederik Eaton] Added useful aliases to aliases.conf * [Giuseppe Passino] Optimised maximum-residual BP by using a reversed ordered set instead of the linear search (which can yield enormous speedups - a factor 500 has been measured on a binary Ising grid with 128x128 variables!) * Added debug assertions to Var which check for inconsistent dimensions of variables with the same labels * toc() now returns POSIX system time with maximum accuracy of microseconds * Exception objects now remember their error code * Examples: - Moved example.cpp to examples/ - Added examples/example_bipgraph.cpp - Added examples/example_varset.cpp - Added examples/example_sprinkler.cpp - Added examples/example_permute.cpp - Added python and octave ports for examples/example_sprinkler.cpp Build system: * Improved Makefile: - Merged Makefile.win and Makefile.shared into Makefile - Macros DAI_VERSION and DAI_DATE have been introduced, in order to store this information in a central place - Introduced CCNODEBUGFLAGS in Makefile - Switched Makefile.win to GNU Make syntax - [Frederik Eaton] Added TAGS, lib targets to Makefile * Compatibility: - [Peter Gober] libDAI can now be built on Cygwin - [Dan Preston] libDAI can now be built on Mac OS X - Changed regression test so that it also works under Windows Interface changes (the old interface is marked obsolete and will be removed in the next release): * Var: - Variable labels are now nonnegative (of type size_t) * VarSet: - Replaced calcState() by non-member calcLinearState() - Replaced calcStates() by non-member calcState() * Permute: - Renamed convert_linear_index into convertLinearIndex * TProb<>: - Replaced log0() by log(true) - Replaced takeLog0() by takeLog(true) - Removed hasNonPositives() - Renamed minVal() to min() - Renamed maxVal() to max() - Renamed totalSum() to sum() * TFactor<>: - Replaced log0() by TFactor::log(true) - Removed divided_by, use operator/ instead - Removed divide, use operator/= instead - Removed partSum(const VarSet&), use marginal(const VarSet&,false) instead - Renamed minVal() to min() - Renamed maxVal() to max() - Renamed totalSum() to sum() * FactorGraph: - Changed clamp and clamp interfaces (the variable to be clamped is now indicated by its index, not as a Var) * RegionGraph: - Renamed Check_Counting_Numbers into checkCountingNumbers - Renamed Calc_Counting_Numbers into calcCountingNumbers * Miscellaneous: - Renamed Treewidth(const FactorGraph &) into boundTreewidth(const FactorGraph &) - Replaced UEdgeVec by Graph - Replaced DEdgeVec by new RootedTree class - Moved functionality of GrowRootedTree() into constructor of RootedTree - Merged calcPairBeliefsNew() into calcPairBeliefs() - Removed calcMarginal2ndO() - Renamed smallSet to SmallSet - Removed class Diffs - [Frederik Eaton] Added backwards compatibility layer for edge interface to BipartiteGraph and FactorGraph (which will be obsoleted soon) Bug fixes: * Fixed reversal of min and max in TFactor min( const TFactor &, const TFactor & ) TFactor max( const TFactor &, const TFactor & ) * [Sebastian Nowozin] Fixed memory leak in MEX file dai * [Frederik Eaton] In PropertySet::getStringAs(), check for typeid(ValueType) before typeid(std::string) (this fixes a strange bug for empty string property) * Added work-around for bug in Boost Graph Library * Fixed bug in MaxSpanningTree (it wrongly assumed that the tree was not empty). * Fixed bug in calcMarginal and calcPairBeliefs where states with zero probability mass were clamped, leading to NaNs or assertion errors (thanks to Dan Preston for reporting this) libDAI-0.2.2 (2008-09-30) ------------------------- New features: * Approximate inference methods now report the number of iterations needed. * Added damping to various algorithms to improve convergence properties. * Added more features to utils/createfg for creating factor graphs. * Added ExactInf class for brute force exact inference. * [Giuseppe Pasino] Added "logdomain" property to BP, a boolean that controls whether calculations are done in the log-domain or in the linear domain; doing calculations in the log-domain may help if the numerical range of a double is too small. * [Claudio Lima] Added Max-Product functionality to BP. * Improved documentation. Improved architecture: * Added Exceptions framework. * Pervasive change of BipartiteGraph implementation (based on an idea by Giuseppe Passino). BipartiteGraph no longer stores the node properties (former _V1 and _V2), nor does it store a dense adjacency matrix anymore, nor an edge list. Instead, it stores the graph structure as lists of neighboring nodes. This yields a significant memory/speed improvement for large factor graphs, and is more elegant as well. Iterating over neighbors is made easy by using boost::foreach. * Added conditional compilation of inference methods. * VarSet is now implemented using a std::vector instead of a std::set, which yields a significant speed improvement. Furthermore, the implementation has been generalized, resulting in the small_set class which can be used to represent sets of small cardinality; VarSet is the specialization with T = Var. * Improved ClusterGraph implementation, yielding significant speedups for the JunctionTree algorithm on large factorgraphs. Code cleanup: * Moved everything into namespace "dai". * Renamed DEBUG to DAI_DEBUG to avoid conflicts. * Replaced ENUM2,ENUM3,ENUM4,ENUM5,ENUM6 by single DAI_ENUM macro. * Removed utils/remove_short_loops and matlab/remove_short_loops. * Replaced sub_nb class in mr.h by boost::dynamic_bitset. * Improved index.h: - Renamed Index -> IndexFor - Added some .reserve()'s to IndexFor methods which yields a 25% speedup of testregression - Replaced multind by Permute - Added MultiFor - Added State * New funcstionality of factor.h. * Moved Properties and MaxDiff frameworks from InfAlg to each individual inference algorithm, because the Properties framework was not as convenient as I hoped, and not every inference algorithm needs a maxdiff variable. Also, replaced some FactorGraph functionality in InfAlg by a function that returns the FactorGraph. The result is cleaner (less entangled) code. * Removed x2x. * Replaced Complex with real numbers (negative potentials are just too rare to warrant the additional "complexity" :)). Miscellaneous improvements: * Now compiles also with MS Visual C++ (thanks to Jiuxiang Hu) and with GCC under Cygwin. * Contributions by Peter Gober: - Renamed variable _N in mr.* for compatibility with g++ under Cygwin. * Misc contributions by Giuseppe Passino: - removed "using namespace std;" from header files - bad practice; - moved header files in include/dai and sources in src; - changed #ifndefs to GNU style; - added extra warning checks (-W -Wextra) and fixed resulting warnings; - dai::TProb: o removed copy constructor and assignment operators (redundant); o implementation of some methods via STL algorithms; o added methods takeExp, takeLog, takeLog0 for transformation in-place; o explicit constructor (prevents implicit conversion from size_t to TProb); o added operator+,+=,-,-=, with argument T (for calculations in log-scale); * Misc contributions by Christian Wojek: - New FactorGraph constructor that constructs from given ranges of factors and variables; - Optimization of FactorGraph constructors using tr1::unordered_map. * FactorGraph constructors no longer check for short loops (huge speed increase for large factor graphs), nor for negative entries. Also, the normtype is now Prob::NORMPROB by default. * Improved MaxSpanningTreePrims algorithm (uses boost::graph). Interface changes: * VarSet:: - VarSet::stateSpace() -> nrStates(const VarSet &) - VarSet( const std::set ) -> VarSet( begin, end, sizeHint=0 ) - VarSet( const std::vector ) -> VarSet( begin, end, sizeHint=0 ) - removed bool operator|| - operator&&(const VarSet&) -> intersects(const VarSet&) - operator&&(const Var&) -> contains(const Var&) * FactorGraph:: - delta(const Var &) -> delta(size_t) - Delta(const Var &) -> Delta(size_t) - makeCavity(const Var &) -> makeCavity(size_t) - vars() -> vars - factors() -> factors - removed MakeFactorCavity(size_t) - removed ExactMarginal(const VarSet &) - removed ExactlogZ() - removed updatedFactor(size_t) - removed _normtype and NormType() - removed hasShortLoops(...) and removeShortLoops(...) - WriteToDotFile(const char *filename) -> printDot( std::ostream& os ) - undoProb(size_t) -> restoreFactor(size_t) - saveProb(size_t) -> backupFactor(size_t) - undoProbs(const VarSet &) -> restoreFactors(const VarSet &) - saveProbs(const VarSet &) -> backupFactors(const VarSet &) - ReadFromFile(const char*) returns void (throws on error) - WriteToFile(const char*) returns void (throws on error) - removed hasNegatives() * RegionGraph:: - nr_ORs() -> nrORs() - nr_IRs() -> nrIRs() - ORs() -> ORs - IRs() -> IRs * *::Regenerate() -> *::construct() * Renamed Index -> IndexFor * Diffs: - max() -> maxDiff() - max_size() -> maxSize() * Prob::max() -> Prob::maxVal() * Factor:: - max() -> maxVal() - part_sum() -> partSum() * toc() in util.h now returns seconds as a double * VarSet::operator&& * Properties -> PropertySet libDAI-0.2.1 (2008-05-26) ------------------------- Bugfix release. * added missing cstdio header in util.h * fixed Properties in MR_CLAMPING_* and MR_EXACT_* * added description of the factor graph fileformat * improved Makefile libDAI-0.2.0 (2006-11-30) ------------------------- First public release. 0.1.5 (2006-11-30) ------------------ Regressions - tests/testlcbp and tests/testlcbp are broken. - EXACT method does not work anymore. - The Properties framework gives a speed penalty because of the lookup costs involved; inner loops should be optimized. General framework - DAIAlg is now a template class; typedefs for DAIAlg and for DAIAlg are provided. In this way, we do not have to write "wrapper" functions to forward functionality from either FactorGraph or RegionGraph to DAIAlg. Functionality like clamping can be implemented in FactorGraph and in RegionGraph and no explicit interface is needed in descendants. - New abstract base class InfAlg added, representing an inference algorithm, from which DAIAlg inherits. This solves the incompatibility problems of DAIAlg for different T (e.g. DAIAlg was incompatible with DAIAlg). More work is required to reduce code duplication (make FactorGraph part of InfAlg). - Added generic interface (nrVars(), Vars(), nrFactors(), factor(size_t), beliefs(), belief(VarSet &), ...) to InfAlg and descendants. - Added a saveProbs/undoProbs interface to InfAlg and descendants that enables one to save a few factors, modify them (e.g. clamp them), and then restore them to their old values. Undo should also init the corresponding messages / beliefs. This can be used if a given factor graph repeatedly needs to be clamped in different ways and an approximation method is run for each clamping; using the saveProbs/undoProbs can give a significant speed increase. - Switched to a general Properties framework that handles the parameters of all inference methods in a uniform manner. The Properties class is a map of several properties in boost::any objects, indexed by their names (strings). It can read from a stream and write to a stream. It is recursive, in the sense that a Properties object can hold a variable of type Properties as well. - Added a generic way of constructing inference algorithms from a factor graph, name and properties object. Added the newInfAlg function which constructs the requested object. This is used by LCBP, the Matlab interface and the command line (test) interface. - Added a generic enum framework for enum parameters. Although implemented as a hack, it is quite useful in that it drastically simplifies and reduces the amount of code for handling enum parameters. - Provided generic functions for calculating marginals in different ways that work for all approximate inference methods. Bugfixes - Fixed GBP free energy. - Fixed bug in junctiontree (it didn't init the _vars variable). - Corrected two bugs in operator&& and operator|| in VarSet (they returned the logical NOT of what they should return). - Fixed bug in RegionGraph::RecomputeOR(s). - Fixed bug in utils/create_dreg_fg: graph structure was not random for given parameters (forgot to call srand()). - TreeEP bug workaround: use the complete junction tree instead of a subtree. - Fixed bug in JTree::HUGIN() and JTree:ShaferShenoy() in case of junction tree that consists of one outer region only. - Fixed INIT bug in LCBP2::UpdatePancake(). - Fixed MaxDiffs flow (except for MR). New functionality - HAK supports several default cluster choices: minimal (only factors) delta (Markov blankets) loop (all loops consisting of loops consisting of or less variables) Only the maximal clusters are used as outer clusters. - Implemented TreeEP. It generalizes the heuristic method described in the Minka & Qi paper for obtaining a tree with the most relevant interactions to higher order interactions. Almost all optimizations described in the Minka & Qi paper are used, except that evidence is passed over the whole tree instead of relevant subsets (the latter is almost implemented but buggy). Also added alternative (worst-case) algorithm that uses a maximum spanning tree on the weighted graph where the weight between neighbours i and j is given by N(psi,i,j), where psi is the product of all the factors involving both i and j (which is an upper bound on the effective interaction between i and j). - Implemented MR (MontanariRizzo) based on Bastian's code, but extended it to be able to handle connectivities larger than 3 (in principle, up to 32). It supports different initialization methods (the original RESPPROP, the CLAMPING method and EXACT which uses JTree) and different update methods (FULL and LINEAR). - Implemented LCBP2, an analogon of LCBP which represents pancakes as little networks and uses some approximate inference method on them for calculating marginals. - Now there are several LCBP variants (LCBP, LCBPI, LCBPJ, LCBPK, LCBPL); LCBPJ works only for pairwise, LCBPK is LCBP improved for higher order interactions and LCBPL is LCBPI improved for higher-order interactions. - Wrote one single program utils/createfg for creating various types of random factor graphs. - Wrote utility to visualize factor graphs using graphviz. (it uses the BOOST Program Options library) - Added fginfo utility that displays some info about a .fg file. - Implemented Factor::strength function that calculates the potential strength N(psi,i,j) between variables i and j as described in cs.IT:0504030 - Wrote a general MatLab interface matlab/dai (similar to tests/test); this unified the matlab functions dai, dai_bp, dai_mf, dai_jt, dai_tep, dai_cvm. - Added MATLAB routine that returns contraction matrix A for BP convergence analysis. - Implemented a MATLAB interface ai_potstrength for Factor::strength - Added Martijn's x2x Improvements of existing code - Reimplemented RegionGraph and descendants: a RegionGraph ISA FactorGraph and also a BipartiteGraph. It now also keeps a map that associates outer region indices to factor indices (no powers yet, this is deemed superfluous) and provides functions to recompute (some of) the outer regions from the factors. - InfAlg descendants run() methods now stop immediately and return NAN in case they detect NANs. Only BP does not do NAN checking for performance reasons. - LCBP now works with factors containing zeroes (by defining x/0 = 0). - HAK, GBP and DoubleLoop now conform to the standards for verbose reporting, timing and convergence criteria. - Implemented logZ() for JTree. It does the calculation during message-passing. - Marginal2ndO now optionally divides by the single node beliefs (to the power n-2); hopefully this will give more accurate approximations. - Marginal and Marginal2ndO (optionally) use the new saveProbs/undoProbs functionality for a faster way of calculating marginals, which does not require a call to init() nor cloning the whole object for each clamping. This leads to a significant speedup. - LCBP (and LCBP2) now have complete flexibility in the specification of the inner method, i.e. the method used to generate the initial cavity approximations. One can pass two strings, a name and a properties string, and LCBP simply invokes newInfAlg to construct the corresponding inference algorithm and uses the generic marginal functions to approximate cavity marginals. - Replaced the global "method" variable by local properties and removed ai.h - Added some methods to Factor (operators *, *=, /, /= with doubles as second argument, operators -, +=, -= with other Factors as second arguments, randomize(), RemoveFirstOrderInteractions) and similar operations to Prob - Moving towards boost::program_options for handling command line arguments (tests/test is done). - Renamed some FactorGraph methods: nr_vars -> nrVars nr_factors -> nrFactors varind -> findVar factorind -> findFactor makeFacCavity -> makeFactorCavity - LCBP_SEQMAXRES has been removed because it did strange things. - Implemented RandomDRegularGraph - Implemented JTree::calcMarginal for marginals that are not confined within one cluster (using cut-set conditioning). - Added isConnected() method to FactorGraph (some methods do not work with disconnected factor graphs). - Pair beliefs are now calculated in a symmetrical way by calcPairBeliefs - Removed single node interaction "correction" code from clamping methods - Removed calcCavityDist and calcCavityDist2ndO - No longer depends on GSL. - Increased portability by combining platform dependant utility functions in util.{h,cpp}. - Wrote *.m files providing help Testing framework - Made a new and significantly improved testing framework that provides most functionality from the command line. - The basis is provided by tests/test, which uses the newInfAlg functionality and enables the user to easily compare from the command line different inference methods on a given factorgraph. All parameters can be specified. Output consists of CPU time, average and maximum single variable marginal errors, relative logZ error and MaxDiff(). - tests/aliases.conf contains aliases for standard combinations of methods and their options (which can be used in tests/test). - tests/large contains several bash/python scripts that create random factor graphs, compare several approximate inference algorithms (using tests/test) and allow for easy visualization of the results using PyX. - Added several .fg files for test purposes to /tests (e.g. two ALARM versions alarm.fg and alarm_bnt.fg; testfast.fg, a 4x4 periodic Ising grid for regression testing). - Added a regression test to the Makefile which is included in the standard target. It compares all inference methods on tests/testfast.fg with the results stored in tests/testfast.out Miscellaneous - Expanded all tabs to spaces (":set tabstop 4\n:set expandtab\n:retab" in vim) - Experimental MATLAB code added for StarEP approximation on cavity - Renamed project to libDAI and changed directory name accordingly. - Renamed JunctionTree to JTree. - Fixed licensing (now it's officially GPL). - Improved README revision 252 ------------ Functionality - Added RegionGraph, GBP, CVM and HAK (double-loop). - Added JunctionTree (with two update algorithms, HUGIN and Shafer-Shenoy), which is a RegionGraph. - NormType is now chosen automatically (in case of negative factors, Prob::NORMLINF is used, otherwise the default Prob::NORMPROB is used). Also, in case of negative factors, the RegionGraph constructors assign each Factor to a unique outer region instead of dividing it over all subsuming outer regions. See README for when negative factors are known to work and when not. - FactorGraph::FactorGraph(const vector) only gives a warning in case of short loops, it does not automatically merge factors anymore. - Removed BP_SEQMAXRESNOCLEAR (all cavity initialization methods now are implicitly NOCLEAR) - Added MATLAB interface functions ai_readfg, ai_removeshortloops and ai_bp - Added LCBP-III type that should be equivalent to LCBP-II, but can handle zeroes in potentials. Note that it is significantly slower than LCBP-II (and has to be reimplemented such that it does not store the complete pancakes, but represents them as little factor graphs). Implementation / code - Made a seperate type WeightedGraph, which until now only implements Prim's maximal spanning tree algorithm and is only used by the junction tree code. It might be good to make it a class somewhere in the future and extend it's interface. - Made a seperate class ClusterGraph, which is only used by the junction tree code. It's main purpose is a graph-theoretical variable elimination algorithm. - Implemented the heuristic "minimum-new-edges-in-clique-graph" for variable elimination. - Massive code cleanup, moving towards "generic" programming style, using multiple inheritance and polymorphism. o BP, LCBP, MF, HAK and JunctionTree now inherit from a common DAIAlg class o Made generic functions Marginal, Marginal2ndO, calcCavityDist, calcCavityDist2ndO, clamp that can be used by FactorGraph-based DAIAlgs. o Created TProb class, which stores a probability vector (without the accompanying indexing and VarSet) and provides functionality for it (which is used by TFactor). o Rewrote the VarSet class. It now caches its statespace(). It now privately inherits from set. I had to overload the insert methods of set so that they calculate the new statespace. o Rewrote the TFactor class. The TFactor class now HAS a TProb and HAS a VarSet. - Rewrote BP to use the new TProb interface. Performance of BP improved up to a factor 6 by: o using Prob's instead of Factor's; o splitting the multiplication of the messages into two parts (thanks to Vicenc!); o optimizing the calculation of the beliefs (only the message calculations were optimized till now). o replacing FactorGraph::_nb1 and _nb2 (which were set) by vector - LCBP now seperately stores cavitydists and pancakes. Added InitPancakes() method that takes the cavitydists and multiplies them with the relevant factors. This resulted in an API change in AI which now accepts and returns initial cavitydists instead of initial pancakes. Minor changes - Started writing DoxyGen documentation - Renamed lcptab2fg.m matlab/ai_writefg.m - Moved all matlab stuff to matlab/ - More detailed reporting (also reports clocks used). - Marginal and Marginal2ndO now use *differences* in logZ to avoid NaNs. - Improved testing suite. - Removed logreal support. - FactorGraph now also supports input streams and ignores comment lines in .fg files. - Added tests/create_full_fg.cpp and tests/create_ising_fg.cpp which create full and periodic 2D Ising networks according to some command line parameters. - Now logZ really returns logZ instead of -logZ. - Added FactorGraph::WriteToDotFile 0.1.4 (2006-04-13) ------------------ - Added file IO routines to read and write factorgraphs. - Added L-infinity normalization for use with (partially) negative factors. - Renamed BetheF, MFF to logZ, which now use complex numbers to be able to handle (partially) negative factors. - Added test suite. - All probabilities are now represented using double instead of LogReal. - Combined Alg and Alg3 into LCBP. Several update schemes possible. - Combined several variants of BP into doBP. Several update schemes possible. Now uses precalculated indices for optimization. - Renamed Node -> Var and Potential -> Factor. - Extensive code cleanup. More use of OO techniques. Changed API. - MaxIter now means maximum number of passes (corresponding to number of _parallel_ updates). - MaxDiff now means the maximum L-infinity distance between the updated and original single variable beliefs, for all AI methods. - Implemented RBP which converges faster than BP for difficult problems. - Now uses method parameter which is a bitmask combining outmethod and inmethod (see ai.h). 0.1.3 (2006-03-22) -------------------- - All AI methods now return maxdiff - ai.cpp: o Now returns maxdiffinner and maxdiffouter o New BP2ndO innermethod (estimate only 2nd order cavity interactions) o New InitCav outermethod (only create initial cavity distributions) - bp.cpp: o New CavityDist2ndO which estimates 2nd order cavity interactions - Makefile: o Bugfix: removed dependencies on algwim.* 0.1.2 (2006-02-28) -------------------- - Cleaned up alg.cpp (removed Alg2 and its corresponding data structures). - Added the possibility to provide initial cavity distributions as an input argument to ai (not much error checking is done, so be careful). - Potentials2mx now correctly sets the dimensions of the P field (i.e. for the output arguments Q, Q0 of ai). - Removed algwim.* since it does not work. 0.1.1 (2006-02-28) -------------------- - The constructors of (Log)FactorGraph and LogFactorGraph from a vector<(Log)Potential> now merge potentials to prevent short loops (of length 4) in the factor graph. These are used in ai to construct the factor graphs from the psi argument. If compiled with DEBUG defined, the method calc_nb() of BipGraph checks for the existence of short loops. - Changed calling syntax of ai (now the actual syntax *does* correspond to its description in the help). - ai does not hook cout anymore (which caused weird segfaults). - Fixed a bug in an assert statement in the matlab interface code in ai.cpp. - Removed network.* since it is not useful. 0.1.0 (2006-02-28) -------------------- First version worthy of a version number. libDAI-0.2.7/Makefile.WINDOWS0000644000263000017630000000552711433220720014254 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This template contains configurations for compiling libDAI with Visual C++ # under Windows (and GNU Make) # # It has been tested with Windows XP, Visual Studio 2008, MatLab R2008b and # Boost 1.42.0 # # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf' # to your local setup # OPERATING SYSTEM # Choose OS from {LINUX, WINDOWS, CYGWIN, MACOSX} OS=WINDOWS # FILE EXTENSIONS # Static library LE=.lib # Object file OE=.obj # Binary executable EE=.exe # MatLab compiled MEX file ME=.mexw32 # COMPILER # Compile using Visual C++ Compiler CC=cl # Output filename option of the compiler CCO=/Fe # Flags for the C++ compiler CCFLAGS=/EHac /GR /W3 /DWINDOWS /DNOMINMAX /MD # For MatLab R2008b, the following flag seems to be necessary: /D_SECURE_SCL=0 # but it generates exceptions in normal executables... therefore, the MatLab # interface is now built from source completely using mex # Flags to add in debugging mode (if DEBUG=true) CCDEBUGFLAGS=/Ox /Zi /DDAI_DEBUG # Flags to add in non-debugging mode (if DEBUG=false) CCNODEBUGFLAGS=/Ox # Standard include directories CCINC=-Iinclude -IE:\windows\boost_1_42_0 # LINKER # Standard libraries to include LIBS=/link $(LIB)/libdai$(LE) # For linking with BOOST libraries BOOSTLIBS_PO=/LIBPATH:E:\windows\boost_1_42_0\stage\lib BOOSTLIBS_UTF=/LIBPATH:E:\windows\boost_1_42_0\stage\lib # Additional library search paths for linker # (For some reason, we have to add the VC library path, although it is in the environment) CCLIB=/LIBPATH:"C:\Program Files\Microsoft Visual Studio 9.0\VC\ATLMFC\LIB" /LIBPATH:"C:\Program Files\Microsoft Visual Studio 9.0\VC\LIB" /LIBPATH:"C:\Program Files\Microsoft SDKs\Windows\v6.0A\lib" # MATLAB # MatLab version 7.3 (R2006b) or newer? NEW_MATLAB=true # Replace the following by the directory where MatLab has been installed MATLABDIR=c:\matlab\R2008b # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)\bin\mex # Flags for MEX MEXFLAGS:=-DWINDOWS -DNOMINMAX # Standard include directories for MEX MEXINC:=$(CCINC) # Additional library search paths for MEX MEXLIB= # SWIG PYTHON INTERFACE # The following should resolve to the SWIG command SWIG=swig # Location of Python header files INCLUDE_PYTHON=C:\python2.5 # Location of Boost C++ library header files INCLUDE_BOOST=E:\windows\boost_1_42_0 # CIMG # CImg version 1.3.0 or newer? NEW_CIMG=true # Include directory for image segmentation example CIMGINC=-IE:\windows\CImg-1.3.9 # Libraries for image segmentation example CIMGLIBS=gdi32.lib user32.lib shell32.lib libDAI-0.2.7/customdoxygen.css0000644000263000017630000002000711433220720015073 0ustar jorismkybBODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV { font-family: Geneva, Arial, Helvetica, sans-serif; } EM { color: #602020; } BODY,TD { font-size: 90%; } H1 { text-align: center; font-size: 160%; } H2 { font-size: 120%; } H3 { font-size: 100%; } CAPTION { font-weight: bold } DIV.qindex { width: 100%; background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.navpath { width: 100%; background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.navtab { background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } TD.navtab { font-size: 70%; } A.qindex { text-decoration: none; font-weight: bold; color: #1A419D; } A.qindex:visited { text-decoration: none; font-weight: bold; color: #1A419D } A.qindex:hover { text-decoration: none; background-color: #ddddff; } A.qindexHL { text-decoration: none; font-weight: bold; background-color: #6666cc; color: #ffffff; border: 1px double #9295C2; } A.qindexHL:hover { text-decoration: none; background-color: #6666cc; color: #ffffff; } A.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff } A.el { text-decoration: none; font-weight: bold } A.elRef { font-weight: bold } A.code:link { text-decoration: none; font-weight: normal; color: #0000FF } A.code:visited { text-decoration: none; font-weight: normal; color: #0000FF } A.codeRef:link { font-weight: normal; color: #0000FF } A.codeRef:visited { font-weight: normal; color: #0000FF } A:hover { text-decoration: none; background-color: #f2f2ff } DL.el { margin-left: -1cm } .fragment { font-family: monospace, fixed; font-size: 95%; } PRE.fragment { border: 1px solid #CCCCCC; background-color: #f5f5f5; margin-top: 4px; margin-bottom: 4px; margin-left: 2px; margin-right: 8px; padding-left: 6px; padding-right: 6px; padding-top: 4px; padding-bottom: 4px; } DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px } DIV.groupHeader { margin-left: 16px; margin-top: 12px; margin-bottom: 6px; font-weight: bold; } DIV.groupText { margin-left: 16px; font-style: italic; font-size: 90% } BODY { background: white; color: black; margin-right: 20px; margin-left: 20px; } TD.indexkey { background-color: #e8eef2; font-weight: bold; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TD.indexvalue { background-color: #e8eef2; font-style: italic; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TR.memlist { background-color: #f0f0f0; } P.formulaDsp { text-align: center; } IMG.formulaDsp { } IMG.formulaInl { vertical-align: middle; } SPAN.keyword { color: #008000 } SPAN.keywordtype { color: #604020 } SPAN.keywordflow { color: #e08000 } SPAN.comment { color: #800000 } SPAN.preprocessor { color: #806020 } SPAN.stringliteral { color: #002080 } SPAN.charliteral { color: #008080 } SPAN.vhdldigit { color: #ff00ff } SPAN.vhdlchar { color: #000000 } SPAN.vhdlkeyword { color: #700070 } SPAN.vhdllogic { color: #ff0000 } .mdescLeft { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .mdescRight { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .memItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplParams { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; color: #606060; background-color: #FAFAFA; font-size: 80%; } .search { color: #003399; font-weight: bold; } FORM.search { margin-bottom: 0px; margin-top: 0px; } INPUT.search { font-size: 75%; color: #000080; font-weight: normal; background-color: #e8eef2; } TD.tiny { font-size: 75%; } a { color: #1A41A8; } a:visited { color: #2A3798; } .dirtab { padding: 4px; border-collapse: collapse; border: 1px solid #84b0c7; } TH.dirtab { background: #e8eef2; font-weight: bold; } HR { height: 1px; border: none; border-top: 1px solid black; } /* Style for detailed member documentation */ .memtemplate { font-size: 80%; color: #606060; font-weight: normal; margin-left: 3px; } .memnav { background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } .memitem { padding: 4px; background-color: #eef3f5; border-width: 1px; border-style: solid; border-color: #dedeee; -moz-border-radius: 8px 8px 8px 8px; } .memname { white-space: nowrap; font-weight: bold; } .memdoc{ padding-left: 10px; } .memproto { background-color: #d5e1e8; width: 100%; border-width: 1px; border-style: solid; border-color: #84b0c7; font-weight: bold; -moz-border-radius: 8px 8px 8px 8px; } .paramkey { text-align: right; } .paramtype { white-space: nowrap; } .paramname { color: #602020; font-style: italic; white-space: nowrap; } /* End Styling for detailed member documentation */ /* for the tree view */ .ftvtree { font-family: sans-serif; margin:0.5em; } .directory { font-size: 9pt; font-weight: bold; } .directory h3 { margin: 0px; margin-top: 1em; font-size: 11pt; } .directory > h3 { margin-top: 0; } .directory p { margin: 0px; white-space: nowrap; } .directory div { display: none; margin: 0px; } .directory img { vertical-align: -30%; } libDAI-0.2.7/scripts/0000755000263000017630000000000011433220720013141 5ustar jorismkyblibDAI-0.2.7/scripts/convert-fastInf-DAI.pl0000644000263000017630000000640611433220720017147 0ustar jorismkyb#! /usr/local/bin/perl # # This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2010 Ofer Meshi use strict; use warnings; my $HOME = $ENV{HOME} ; if ($#ARGV == 0) { push (@ARGV,"$ARGV[0].fg") ; } my $expectedArgc = 2 ; if ($#ARGV != $expectedArgc-1) { die ("Usage: $0 \n") ; } my ($inModelFile,$outModelFile) = @ARGV ; # First we read the model: my (@variables,@cliques,@measures,%cliq2meas,$truePartition) ; &readModel ($inModelFile,\@variables,\@cliques,\@measures,\%cliq2meas,\$truePartition) ; open (OUT, ">$outModelFile") or die ("[ERROR] Cannot open output file $outModelFile\n") ; print OUT "# Converted $inModelFile from fastInf format into DAI format\n" ; print OUT scalar(@cliques), "\n\n" ; for (my $i=0 ; $i)) { if ($line =~ m/^\@Variables/) { &readLines (*MOD_IN , $variables) ; } elsif ($line =~ m/^\@Cliques/) { &readLines (*MOD_IN , $cliques) ; } elsif ($line =~ m/^\@Measures/) { &readLines (*MOD_IN , $measures) ; } elsif ($line =~ m/^\@CliqueToMeasure/) { &readCliq2Meas (*MOD_IN , $cliq2meas) ; } elsif ($line =~ m/^# Exact Partitition function:/) { my $partLine ; if (not defined ($partLine = )) { die ("[ERROR] Cannot read exact partition function."); } if ($partLine =~ m/^# (\S+)/) { $$truePartition = $1 ; } } # else do nothing } # while read line from model file close MOD_IN ; } sub readLines { my ($IN,$variables) = @_ ; my $endReached = 0 ; while (defined (my $line = <$IN>)) { if ($line =~ m/^\@End/) { $endReached = 1 ; last ; } else { push (@$variables,$line) ; } } if (not $endReached) { die ("[ERROR] Could not find \@End statement.\n") ; } } sub readCliq2Meas { my ($IN,$cliq2meas) = @_ ; my $endReached = 0 ; while (defined (my $line = <$IN>)) { if ($line =~ m/^\@End/) { $endReached = 1 ; last ; } else { my @splitLine = split(/\t/,$line) ; my $cliq = $splitLine[0] ; my $meas = $splitLine[1] ; $cliq2meas->{$cliq} = $meas ; } } if (not $endReached) { die ("[ERROR] Could not find \@End statement.\n") ; } } libDAI-0.2.7/scripts/makeREADME0000755000263000017630000000264711433220720014673 0ustar jorismkyb#!/bin/bash echo "libDAI - A free/open source C++ library for Discrete Approximate Inference" > README echo >> README echo "â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”" >> README echo >> README echo "Version: $DAI_VERSION" >> README echo "Date: $DAI_DATE" >> README echo "See also: http://www.libdai.org" >> README echo >> README w3m -dump doc/html/license.html | awk 'BEGIN {start=0}; $1 ~ /â”/ {start=start+1; if (start<2) print $0}; $1 !~ /â”/ {if (start>0 && start<2) print $0}' >> README echo "You should have received a copy of the GNU General Public License" >> README echo "along with libDAI in the file COPYING. If not, see http://www.gnu.org/licenses/" >> README echo >> README w3m -dump doc/html/citations.html | awk 'BEGIN {start=0}; $1 ~ /â”/ {start=start+1; if (start<2) print $0}; $1 !~ /â”/ {if (start>0 && start<2) print $0}' >> README w3m -dump doc/html/index.html | awk 'BEGIN {start=0}; $1 ~ /â”/ {start=start+1; if (start<2) print $0}; $1 !~ /â”/ {if (start>0 && start<2) print $0}' >> README w3m -dump doc/html/build.html | awk 'BEGIN {start=0}; $1 ~ /â”/ {start=start+1; if (start>0 && start<5) print $0}; $1 !~ /â”/ {if (start>0 && start<5) print $0}' >> README sed -i 's/â”/-/g' README sed -i 's/•/*/g' README libDAI-0.2.7/scripts/regenerate-properties0000755000263000017630000002206511433220720017407 0ustar jorismkyb#!/usr/bin/perl # # This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] use warnings; use strict; use Cwd 'abs_path'; @ARGV == 2 or die "Need 2 arguments"; my ($header_file,$source_file) = @ARGV; @ARGV=(); # Regular expressions for nested brackets (uses perl 5.10 features) my ($nested_angle_brackets) = qr/(<(?:[^<>]++|(?1))*>)/; my ($nested_curly_brackets) = qr/({(?:[^{}]++|(?1))*})/; my ($nested_parentheses) = qr/(\((?:[^()]++|(?1))*\))/; # Patterns to match generated code blocks my ($gen_code_start_pat, $gen_code_end_pat, $props_start_pat) = (qr(/\*.*GENERATED CODE: DO NOT EDIT.*), qr(/\*.*END OF GENERATED CODE.*\*/), qr(/\*.*PROPERTIES)); # Actual delimiters to use for generated code blocks my ($gen_code_start, $gen_code_end) = ("/* {{{ GENERATED CODE: DO NOT EDIT. Created by\n". " $0 $header_file $source_file\n*/\n", "/* }}} END OF GENERATED CODE */\n"); # Strings to hold text of files my $header_buffer=""; my $source_buffer=""; # ---------------------------------------------------------------- # Useful routines # remove leading and trailing whitespace sub stripws ($) { my ($s) = @_; $s =~ s/^\s*//s; $s =~ s/\s*$//s; return $s; } # split comments and non-comments, returning 2-element array # of (uncommented part, comments) my $comment_pat = qr#(/\*[^*]*\*+(?:[^/*][^*]*\*+)*/|//[^\n]*)|("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|.[^/"'\\]*)#; sub sepcomment ($) { my ($c) = @_; my ($u) = $c; $u =~ s#$comment_pat#defined $2 ? $2 : ""#gse; $c =~ s#$comment_pat#defined $1 ? $1 : ""#gse; return ($u, $c); } # Run diff, return output sub getdiff ($$) { my ($a,$b) = @_; my $diff=""; open DIFF, "diff -u \Q$a\E \Q$b\E |" or die "Couldn't run diff"; while() { $diff .= $_; } close DIFF; return $diff; } sub myrename ($$) { my ($a,$b) = @_; $b = abs_path $b; rename($a, $b) or die "Couldn't rename $a to $b"; } sub writefile ($$) { my ($buf, $f) = @_; open OUT, ">", $f or die "Couldn't open $f for writing"; print OUT $buf; close OUT; } our ($buffer); # Step through file, appending lines to buffer # - Lines which match generated code blocks are omitted # - Other lines are passed to the subroutine. They are added to buffer # unless the subroutine returns 1 (e.g. if it has already added them) sub process_file (&$) { my ($sub, $file) = @_; local ($buffer) = ""; # step through lines of file, appending each one to buffer open IN, "<", $file or die "Couldn't open $file for reading"; while () { # delete anything between GENERATED CODE etc. if (/$gen_code_end_pat/) { die "Unmatched generated code block end at $file line $."; } elsif (/$gen_code_start_pat/) { my $s = $.; my $found=0; while () { chomp; if (/$gen_code_end_pat/) { $found=1; last; } } die "Unterminated generated code block at $file line $s" unless $found; next; } else { my ($res) = &$sub; next if $res; } $buffer .= $_; } close IN; return $buffer; } # Parse a PROPERTIES() block sub process_properties ($$$) { my ($file, $start_line, $props_text) = @_; my ($errline)="$file:$start_line"; $props_text =~ s/^.*PROPERTIES\s*($nested_parentheses)//s or die "Malformed PROPERTIES, $errline: expected PROPERTIES(args)"; my ($args) = $1; $args =~ s/^\(//g; $args =~ s/\)$//g; my (@args) = split /,/, $args; @args == 2 or die "PROPERTIES needs two arguments at $errline"; my ($struct_name, $class) = @args; $props_text =~ m/^\s*($nested_curly_brackets)\s*$/s or die "Malformed PROPERTIES, $errline: expected {} after PROPERTIES"; my ($body) = $1; $body =~ s/^{(.*)}$/$1/s; # get rid of curly brackets my (@stmts) = split /;\s*\n/s, $body; # split on ";" my (@typedecls) = (); my (@vars) = (); foreach my $s (@stmts) { my ($s, $cmt) = sepcomment $s; $cmt = stripws $cmt; if($s =~ /^\s*$/s) { # extra ";" next; } elsif($s =~ /DAI_ENUM|typedef/) { push @typedecls, [stripws $s, $cmt]; } else { $s =~ /^\s*[a-zA-Z_][\w:]+\s*$nested_angle_brackets?/ or die "Couldn't match statement $s in PROPERTIES at $errline"; my $type = stripws $&; my $name = stripws $'; my $default = undef; if($name =~ /^(.*)=(.*)$/) { $name = stripws $1; $default = stripws $2; } push @vars, [$type, $name, $default, $cmt]; } } my ($stext) = ""; my ($text) = < &keys = opts.keys(); std::string errormsg; for( std::set::const_iterator i = keys.begin(); i != keys.end(); i++ ) { EOF for my $v (@vars) { my ($type,$name,$default,$cmt) = @$v; $stext .= <("$name"); } else { $name = $default; } EOF } else { $stext .= <("$name"); EOF } } $stext .= <) { last if(m(\*/)); $props_text .= $_; } $buffer .= $props_text; $buffer .= $_; my ($htext, $stext) = process_properties($header_file, $start_line, $props_text); $buffer .= $htext; $source_buffer .= "\n\n\n".$stext; return 1; } return 0; } $header_file; # Write new contents of files to temporary locations my $header_tmp = "$header_file.new"; my $source_tmp = "$source_file.new"; writefile ($header_buffer, $header_tmp); writefile ($source_buffer, $source_tmp); # Get a diff of changes, show it to the user, and ask for confirmation my ($diff); $diff = getdiff ($header_file, $header_tmp); $diff .= getdiff ($source_file, $source_tmp); if($diff eq '') { warn "No differences\n"; } else { my $pager = $ENV{PAGER} || "less"; open PAGER, "|$pager"; print PAGER $diff; close PAGER; print STDERR "Replace old with new version? (y|N) "; $_=<>; if (/^y/i) { myrename($header_tmp, $header_file); myrename($source_tmp, $source_file); } else { warn "Aborted\n"; } } libDAI-0.2.7/matlab/0000755000263000017630000000000011433220721012713 5ustar jorismkyblibDAI-0.2.7/matlab/dai_potstrength.m0000644000263000017630000000045211433220721016270 0ustar jorismkyb% N = dai_potstrength (psi, i, j) % % INPUT: psi = structure with a Member field and a P field, like a CPTAB. % i = label of a variable in psi. % j = label of another variable in psi. % % OUTPUT: N = strength of psi in direction i->j. libDAI-0.2.7/matlab/dai_readfg.m0000644000263000017630000000042511433220721015137 0ustar jorismkyb% [psi] = dai_readfg (filename) % % INPUT: filename = filename of a .fg file % % OUTPUT: psi = linear cell array containing the factors % (psi{i} is a structure with a Member field % and a P field, like a CPTAB). libDAI-0.2.7/matlab/dai_writefg.m0000644000263000017630000000042611433220721015357 0ustar jorismkyb% dai_writefg(psi,filename) % % INPUT: psi = linear cell array containing the factors % (psi{i} should be a structure with a Member field % and a P field, like a CPTAB). % filename = filename of a .fg file libDAI-0.2.7/matlab/dai.m0000644000263000017630000000141311433220721013625 0ustar jorismkyb% [logZ,q,md,qv,qf,qmap] = dai(psi,method,opts) % % INPUT: psi = linear cell array containing the factors % (psi{i} should be a structure with a Member field % and a P field). % method = name of the method. % opts = string of options. % % OUTPUT: logZ = approximation of the logarithm of the partition sum. % q = linear cell array containing all final beliefs. % md = maxdiff (final linf-dist between new and old single node beliefs). % qv = linear cell array containing all variable beliefs. % qf = linear cell array containing all factor beliefs. % qmap = linear array containing the MAP state (only for BP,JTree). libDAI-0.2.7/doc/0000755000263000017630000000000011433220721012220 5ustar jorismkyblibDAI-0.2.7/doc/html/0000755000263000017630000000000011433220722013165 5ustar jorismkyblibDAI-0.2.7/doc/html/classdai_1_1EMAlg-members.html0000644000263000017630000001731011433220721020575 0ustar jorismkyb libDAI: Member List

dai::EMAlg Member List

This is the complete list of members for dai::EMAlg, including all inherited members.

_estepdai::EMAlg [private]
_evidencedai::EMAlg [private]
_itersdai::EMAlg [private]
_lastLogZdai::EMAlg [private]
_log_z_toldai::EMAlg [private]
_max_itersdai::EMAlg [private]
_mstepsdai::EMAlg [private]
const_s_iterator typedefdai::EMAlg
EMAlg(const Evidence &evidence, InfAlg &estep, std::vector< MaximizationStep > &msteps, const PropertySet &termconditions)dai::EMAlg [inline]
EMAlg(const Evidence &evidence, InfAlg &estep, std::istream &mstep_file)dai::EMAlg
eStep() const dai::EMAlg [inline]
hasSatisfiedTermConditions() const dai::EMAlg
iterate()dai::EMAlg
iterate(MaximizationStep &mstep)dai::EMAlg
Iterations() const dai::EMAlg [inline]
LOG_Z_TOL_DEFAULTdai::EMAlg [static]
LOG_Z_TOL_KEYdai::EMAlg [static]
logZ() const dai::EMAlg [inline]
MAX_ITERS_DEFAULTdai::EMAlg [static]
MAX_ITERS_KEYdai::EMAlg [static]
run()dai::EMAlg
s_begin()dai::EMAlg [inline]
s_begin() const dai::EMAlg [inline]
s_end()dai::EMAlg [inline]
s_end() const dai::EMAlg [inline]
s_iterator typedefdai::EMAlg
setTermConditions(const PropertySet &p)dai::EMAlg

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/varset_8h-source.html0000644000263000017630000003135611433220721017263 0ustar jorismkyb libDAI: include/dai/varset.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/namespacedai.html0000644000263000017630000060267411433220721016503 0ustar jorismkyb libDAI: dai Namespace Reference

dai Namespace Reference

Namespace for libDAI. More...


Classes

class  BBPCostFunction
 Predefined cost functions that can be used with BBP. More...
class  BBP
 Implements BBP (Back-Belief-Propagation) [EaG09]. More...
class  BipartiteGraph
 Represents the neighborhood structure of nodes in an undirected, bipartite graph. More...
class  BP
 Approximate inference algorithm "(Loopy) Belief Propagation". More...
class  BP_dual
 Calculates both types of BP messages and their normalizers from an InfAlg. More...
class  CBP
 Class for CBP (Conditioned Belief Propagation) [EaG09]. More...
class  ClusterGraph
 A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges. More...
class  sequentialVariableElimination
 Helper object for dai::ClusterGraph::VarElim(). More...
class  greedyVariableElimination
 Helper object for dai::ClusterGraph::VarElim(). More...
class  DAG
 Represents the neighborhood structure of nodes in a directed cyclic graph. More...
class  InfAlg
 InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI. More...
class  DAIAlg
 Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph). More...
class  DecMAP
 Approximate inference algorithm DecMAP, which constructs a MAP state by decimation. More...
class  ParameterEstimation
 Base class for parameter estimation methods. More...
class  CondProbEstimation
 Estimates the parameters of a conditional probability table, using pseudocounts. More...
class  SharedParameters
 Represents a single factor or set of factors whose parameters should be estimated. More...
class  MaximizationStep
 A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. More...
class  EMAlg
 EMAlg performs Expectation Maximization to learn factor parameters. More...
class  Evidence
 Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables. More...
class  ExactInf
 Exact inference algorithm using brute force enumeration (mainly useful for testing purposes). More...
class  Exception
 Error handling in libDAI is done by throwing an instance of the Exception class. More...
class  TFactor
 Represents a (probability) factor. More...
class  FactorGraph
 Represents a factor graph. More...
class  FBP
 Approximate inference algorithm "Fractional Belief Propagation" [WiH03]. More...
class  Gibbs
 Approximate inference algorithm "Gibbs sampling". More...
struct  Neighbor
 Describes the neighbor relationship of two nodes in a graph. More...
class  GraphAL
 Represents the neighborhood structure of nodes in an undirected graph. More...
class  HAK
 Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]. More...
class  IndexFor
 Tool for looping over the states of several variables. More...
class  Permute
 Tool for calculating permutations of linear indices of multi-dimensional arrays. More...
class  multifor
 multifor makes it easy to perform a dynamic number of nested for loops. More...
class  State
 Makes it easy to iterate over all possible joint states of variables within a VarSet. More...
class  JTree
 Exact inference algorithm using junction tree. More...
class  LC
 Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]. More...
class  MF
 Approximate inference algorithm "Mean Field". More...
class  MR
 Approximate inference algorithm by Montanari and Rizzo [MoR05]. More...
struct  fo_id
 Function object that returns the value itself. More...
struct  fo_abs
 Function object that takes the absolute value. More...
struct  fo_exp
 Function object that takes the exponent. More...
struct  fo_log
 Function object that takes the logarithm. More...
struct  fo_log0
 Function object that takes the logarithm, except that log(0) is defined to be 0. More...
struct  fo_inv
 Function object that takes the inverse. More...
struct  fo_inv0
 Function object that takes the inverse, except that 1/0 is defined to be 0. More...
struct  fo_plog0p
 Function object that returns p*log0(p). More...
struct  fo_divides0
 Function object similar to std::divides(), but different in that dividing by zero results in zero. More...
struct  fo_KL
 Function object useful for calculating the KL distance. More...
struct  fo_Hellinger
 Function object useful for calculating the Hellinger distance. More...
struct  fo_pow
 Function object that returns x to the power y. More...
struct  fo_max
 Function object that returns the maximum of two values. More...
struct  fo_min
 Function object that returns the minimum of two values. More...
struct  fo_absdiff
 Function object that returns the absolute difference of x and y. More...
class  TProb
 Represents a vector with entries of type T. More...
class  PropertySet
 Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue). More...
class  Region
 A Region is a set of variables with a counting number. More...
class  FRegion
 An FRegion is a factor with a counting number. More...
class  RegionGraph
 A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph. More...
class  SmallSet
 Represents a set; the implementation is optimized for a small number of elements. More...
class  TreeEP
 Approximate inference algorithm "Tree Expectation Propagation" [MiQ04]. More...
class  TRWBP
 Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]. More...
class  hash_map
 hash_map is an alias for std::tr1::unordered_map. More...
class  Var
 Represents a discrete random variable. More...
class  VarSet
 Represents a set of variables. More...
class  DEdge
 Represents a directed edge. More...
class  UEdge
 Represents an undirected edge. More...
class  GraphEL
 Represents an undirected graph, implemented as a std::set of undirected edges. More...
class  WeightedGraph
 Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights. More...
class  RootedTree
 Represents a rooted tree, implemented as a vector of directed edges. More...

Typedefs

typedef boost::minstd_rand _rnd_gen_type
 Type of global random number generator.
typedef DAIAlg< FactorGraph > DAIAlgFG
 Base class for inference algorithms that operate on a FactorGraph.
typedef DAIAlg< RegionGraph > DAIAlgRG
 Base class for inference algorithms that operate on a RegionGraph.
typedef TFactor< Real > Factor
 Represents a factor with values of type dai::Real.
typedef std::vector< Neighbor > Neighbors
 Describes the set of neighbors of some node in a graph.
typedef std::pair< size_t, size_t > Edge
 Represents an edge in a graph: an Edge(i,j) corresponds to the edge between node i and node j.
typedef TProb< Real > Prob
 Represents a vector with entries of type dai::Real.
typedef std::string PropertyKey
 Type of the key of a Property.
typedef boost::any PropertyValue
 Type of the value of a Property.
typedef std::pair< PropertyKey,
PropertyValue > 		Property
 A Property is a pair of a key and a corresponding value.
typedef double Real
 Real number (alias for double, which could be changed to long double if necessary).

Enumerations

enum  ProbNormType { NORMPROB, NORMLINF }
 Enumerates different ways of normalizing a probability measure. More...
enum  ProbDistType {
  DISTL1, DISTLINF, DISTTV, DISTKL,
  DISTHEL
}
 Enumerates different distance measures between probability measures. More...

Functions

InfAlg * newInfAlg (const std::string &name, const FactorGraph &fg, const PropertySet &opts)
 Constructs a new inference algorithm.
InfAlg * newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg)
 Constructs a new inference algorithm.
InfAlg * newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg, const std::map< std::string, std::string > &aliases)
 Constructs a new inference algorithm.
std::pair< std::string,
PropertySet > 		parseNameProperties (const std::string &s)
 Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name".
std::pair< std::string,
PropertySet > 		parseNameProperties (const std::string &s, const std::map< std::string, std::string > &aliases)
 Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name", performing alias substitution.
std::map< std::string,
std::string > 		readAliasesFile (const std::string &filename)
 Reads aliases from file named filename.
size_t getFactorEntryForState (const FactorGraph &fg, size_t I, const vector< size_t > &state)
 Returns the entry of the I'th factor corresponding to a global state.
Real numericBBPTest (const InfAlg &bp, const std::vector< size_t > *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h)
vector< size_t > complement (vector< size_t > &xis, size_t n_states)
 Given a sorted vector of states xis and total state count n_states, return a vector of states not in xis.
Real unSoftMax (Real a, Real b)
 Computes $\frac{\exp(a)}{\exp(a)+\exp(b)}$.
Real logSumExp (Real a, Real b)
 Computes log of sum of exponents, i.e., $\log\left(\exp(a) + \exp(b)\right)$.
Real dist (const vector< Factor > &b1, const vector< Factor > &b2, size_t nv)
 Compute sum of pairwise L-infinity distances of the first nv factors in each vector.
static vector< Factor > mixBeliefs (Real p, const vector< Factor > &b, const vector< Factor > &c)
 Calculates a vector of mixtures p * b + (1-p) * c.
std::pair< size_t, size_t > BBPFindClampVar (const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut)
size_t eliminationCost_MinNeighbors (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinNeighbors" criterion.
size_t eliminationCost_MinWeight (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinWeight" criterion.
size_t eliminationCost_MinFill (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinFill" criterion.
size_t eliminationCost_WeightedMinFill (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "WeightedMinFill" criterion.
Factor calcMarginal (const InfAlg &obj, const VarSet &vs, bool reInit)
 Calculates the marginal probability distribution for vs using inference algorithm obj.
vector< Factor > calcPairBeliefs (const InfAlg &obj, const VarSet &vs, bool reInit, bool accurate=false)
 Calculates beliefs for all pairs of variables in vs using inference algorithm obj.
std::vector< size_t > findMaximum (const InfAlg &obj)
 Calculates the joint state of all variables that has maximum probability, according to the inference algorithm obj.
Factor createFactorIsing (const Var &x, Real h)
 Returns a binary unnormalized single-variable factor $ \exp(hx) $ where $ x = \pm 1 $.
Factor createFactorIsing (const Var &x1, const Var &x2, Real J)
 Returns a binary unnormalized pairwise factor $ \exp(J x_1 x_2) $ where $ x_1, x_2 = \pm 1 $.
Factor createFactorExpGauss (const VarSet &vs, Real beta)
 Returns a random factor on the variables vs with strength beta.
Factor createFactorPotts (const Var &x1, const Var &x2, Real J)
 Returns a pairwise Potts factor $ \exp( J \delta_{x_1, x_2} ) $.
Factor createFactorDelta (const Var &v, size_t state)
 Returns a Kronecker delta point mass.
Factor createFactorDelta (const VarSet &vs, size_t state)
 Returns a Kronecker delta point mass.
std::ostream & operator<< (std::ostream &os, const FactorGraph &fg)
 Writes a FactorGraph to an output stream.
std::istream & operator>> (std::istream &is, FactorGraph &fg)
 Reads a FactorGraph from an input stream.
std::vector< size_t > getGibbsState (const FactorGraph &fg, size_t maxiter)
GraphAL createGraphFull (size_t N)
 Creates a fully-connected graph with N nodes.
GraphAL createGraphGrid (size_t N1, size_t N2, bool periodic)
 Creates a two-dimensional rectangular grid of N1 by N2 nodes, which can be periodic.
GraphAL createGraphGrid3D (size_t N1, size_t N2, size_t N3, bool periodic)
 Creates a three-dimensional rectangular grid of N1 by N2 by N3 nodes, which can be periodic.
GraphAL createGraphLoop (size_t N)
 Creates a graph consisting of a single loop of N nodes.
GraphAL createGraphTree (size_t N)
 Creates a random tree-structured graph of N nodes.
GraphAL createGraphRegular (size_t N, size_t d)
 Creates a random regular graph of N nodes with uniform connectivity d.
template<class T>
TFactor< T > & makePositive (TFactor< T > &f, T epsilon)
 Sets factor entries that lie between 0 and epsilon to epsilon.
template<class T>
TFactor< T > & makeZero (TFactor< T > &f, T epsilon)
 Sets factor entries that are smaller (in absolute value) than epsilon to 0.
void ReadUaiAieFactorGraphFile (const char *filename, size_t verbose, std::vector< Var > &vars, std::vector< Factor > &factors, std::vector< Permute > &permutations)
 Reads factor graph (as a pair of a variable vector and factor vector) from a file in the UAI approximate inference challenge format.
std::vector< std::map< size_t,
size_t > > 		ReadUaiAieEvidenceFile (const char *filename, size_t verbose)
 Reads evidence (a mapping from observed variable labels to the observed values) from a file in the UAI approximate inference challenge format.
std::pair< size_t, long double > boundTreewidth (const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates)
std::ostream & operator<< (std::ostream &os, const Property &p)
 Writes a Property object (key-value pair) to an output stream.
std::ostream & operator<< (std::ostream &os, const PropertySet &ps)
 Writes a PropertySet object to an output stream.
std::istream & operator>> (std::istream &is, PropertySet &ps)
 Reads a PropertySet object from an input stream, storing values as strings.
ostream & operator<< (ostream &os, const RegionGraph &rg)
 Send RegionGraph to output stream.
bool isnan (Real x)
 Returns true if argument is NAN (Not A Number).
double toc ()
 Returns wall clock time in seconds.
_rnd_gen_type _rnd_gen (42U)
 Global random number generator.
boost::uniform_real< Real > _uni_dist (0, 1)
 Uniform distribution with values between 0 and 1 (0 inclusive, 1 exclusive).
boost::variate_generator
< _rnd_gen_type
&, boost::uniform_real< Real > > 		_uni_rnd (_rnd_gen, _uni_dist)
 Global uniform random random number.
boost::variate_generator
< _rnd_gen_type
&, boost::normal_distribution
< Real > > 		_normal_rnd (_rnd_gen, _normal_dist)
 Global random number generator with standard normal distribution.
void rnd_seed (size_t seed)
 Sets the random seed.
Real rnd_uniform ()
 Returns a real number, distributed uniformly on [0,1).
Real rnd_stdnormal ()
 Returns a real number from a standard-normal distribution.
int rnd_int (int min, int max)
 Returns a random integer in interval [min, max].
std::vector< std::string > tokenizeString (const std::string &s, bool singleDelim, const std::string &delim="\t\n")
 Split a string into tokens delimited by one of the characters in delim.
size_t calcLinearState (const VarSet &vs, const std::map< Var, size_t > &state)
 Calculates the linear index in the Cartesian product of the variables in vs that corresponds to a particular joint assignment of the variables, specified by state.
std::map< Var, size_t > calcState (const VarSet &vs, size_t linearState)
 Calculates the joint assignment of the variables in vs corresponding to the linear index linearState.
mxArray * Factors2mx (const std::vector< Factor > &Ps)
 Convert vector<Factor> structure to a cell vector of CPTAB-like structs.
vector< Factor > mx2Factors (const mxArray *psi, long verbose)
 Convert cell vector of CPTAB-like structs to vector<Factor>.
Factor mx2Factor (const mxArray *psi)
 Convert CPTAB-like struct to Factor.
 DAI_ENUM (BBPCostFunctionBase, CFN_GIBBS_B, CFN_GIBBS_B2, CFN_GIBBS_EXP, CFN_GIBBS_B_FACTOR, CFN_GIBBS_B2_FACTOR, CFN_GIBBS_EXP_FACTOR, CFN_VAR_ENT, CFN_FACTOR_ENT, CFN_BETHE_ENT)
 Enumeration of several cost functions that can be used with BBP.
Real log (Real x)
 Returns logarithm of x.
Real log0 (Real x)
 Returns logarithm of x, or 0 if x == 0.
Real exp (Real x)
 Returns exponent of x.
Real pow (Real x, Real y)
 Returns to the power y.
template<class T>
T abs (const T &t)
 Returns absolute value of t.
int rnd (int n)
 Returns a random integer in the half-open interval [0, n).
template<class T>
std::string toString (const T &x)
 Converts a variable of type T to a std::string by using a boost::lexical_cast.
template<class T>
T fromString (const std::string &x)
 Converts a variable of type std::string to T by using a boost::lexical_cast.
template<class T>
std::ostream & operator<< (std::ostream &os, const std::vector< T > &x)
 Writes a std::vector<> to a std::ostream.
template<class T>
std::ostream & operator<< (std::ostream &os, const std::set< T > &x)
 Writes a std::set<> to a std::ostream.
template<class T1, class T2>
std::ostream & operator<< (std::ostream &os, const std::map< T1, T2 > &x)
 Writes a std::map<> to a std::ostream.
template<class T1, class T2>
std::ostream & operator<< (std::ostream &os, const std::pair< T1, T2 > &x)
 Writes a std::pair<> to a std::ostream.
template<class T>
std::vector< T > concat (const std::vector< T > &u, const std::vector< T > &v)
 Concatenates two vectors.
template<typename T>
RootedTree MinSpanningTree (const WeightedGraph< T > &G, bool usePrim)
 Constructs a minimum spanning tree from the (non-negatively) weighted graph G.
template<typename T>
RootedTree MaxSpanningTree (const WeightedGraph< T > &G, bool usePrim)
 Constructs a minimum spanning tree from the (non-negatively) weighted graph G.

Variables

boost::normal_distribution< Real > _normal_dist
 Normal distribution with mean 0 and standard deviation 1.
static const char * DAINames []
 Contains the names of all inference algorithms compiled into libDAI.

Detailed Description

Namespace for libDAI.

Typedef Documentation

typedef boost::minstd_rand dai::_rnd_gen_type

Type of global random number generator.

typedef DAIAlg<FactorGraph> dai::DAIAlgFG

Base class for inference algorithms that operate on a FactorGraph.

typedef DAIAlg<RegionGraph> dai::DAIAlgRG

Base class for inference algorithms that operate on a RegionGraph.

typedef TFactor<Real> dai::Factor

Represents a factor with values of type dai::Real.

Examples:
example_sprinkler.cpp, and uai2010-aie-solver.cpp.

typedef std::vector<Neighbor> dai::Neighbors

Describes the set of neighbors of some node in a graph.

typedef std::pair<size_t,size_t> dai::Edge

Represents an edge in a graph: an Edge(i,j) corresponds to the edge between node i and node j.

Note:
If the edge is interpreted as a directed edge, then it points from i to j.

If the edge is part of a bipartite graph, i is understood to correspond to a node of type 1, and j to a node of type 2.

Examples:
example_bipgraph.cpp.

typedef TProb<Real> dai::Prob

Represents a vector with entries of type dai::Real.

typedef std::string dai::PropertyKey

Type of the key of a Property.

typedef boost::any dai::PropertyValue

Type of the value of a Property.

typedef std::pair<PropertyKey, PropertyValue> dai::Property

A Property is a pair of a key and a corresponding value.

typedef double dai::Real

Real number (alias for double, which could be changed to long double if necessary).

Examples:
example.cpp, example_sprinkler.cpp, example_sprinkler_em.cpp, and uai2010-aie-solver.cpp.

Enumeration Type Documentation

enum dai::ProbNormType

Enumerates different ways of normalizing a probability measure.

  • NORMPROB means that the sum of all entries should be 1;
  • NORMLINF means that the maximum absolute value of all entries should be 1.

enum dai::ProbDistType

Enumerates different distance measures between probability measures.

  • DISTL1 is the $\ell_1$ distance (sum of absolute values of pointwise difference);
  • DISTLINF is the $\ell_\infty$ distance (maximum absolute value of pointwise difference);
  • DISTTV is the total variation distance (half of the $\ell_1$ distance);
  • DISTKL is the Kullback-Leibler distance ($\sum_i p_i (\log p_i - \log q_i)$).
  • DISTHEL is the Hellinger distance ($\frac{1}{2}\sum_i (\sqrt{p_i}-\sqrt{q_i})^2$).

Function Documentation

InfAlg * dai::newInfAlg ( const std::string &  name,
const FactorGraph &  fg,
const PropertySet &  opts 
)

Constructs a new inference algorithm.

Parameters:
name The name of the inference algorithm (should be one of the names in DAINames).
fg The FactorGraph that the algorithm should be applied to.
opts A PropertySet specifying the options for the algorithm.
Returns:
Returns a pointer to the new InfAlg object; it is the responsibility of the caller to delete it later.
Exceptions:
UNKNOWN_DAI_ALGORITHM if the requested name is not known/compiled in.

InfAlg * dai::newInfAlgFromString ( const std::string &  nameOpts,
const FactorGraph &  fg 
)

Constructs a new inference algorithm.

Parameters:
nameOpts The name and options of the inference algorithm (should be in the format "name[key1=val1,key2=val2,...,keyn=valn]").
fg The FactorGraph that the algorithm should be applied to.
Returns:
Returns a pointer to the new InfAlg object; it is the responsibility of the caller to delete it later.
Exceptions:
UNKNOWN_DAI_ALGORITHM if the requested name is not known/compiled in.

InfAlg * dai::newInfAlgFromString ( const std::string &  nameOpts,
const FactorGraph &  fg,
const std::map< std::string, std::string > &  aliases 
)

Constructs a new inference algorithm.

Parameters:
nameOpts The name and options of the inference algorithm (should be in the format "name[key1=val1,key2=val2,...,keyn=valn]").
fg The FactorGraph that the algorithm should be applied to.
aliases Maps names to strings in the format "name[key1=val1,key2=val2,...,keyn=valn]"; if not empty, alias substitution will be performed when parsing nameOpts by invoking parseNameProperties(const std::string &,const std::map<std::string,std::string> &)
See also:
newInfAlgFromString(const std::string &, const FactorGraph &)

std::pair< std::string, PropertySet > dai::parseNameProperties ( const std::string &  s  ) 

Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name".

std::pair< std::string, PropertySet > dai::parseNameProperties ( const std::string &  s,
const std::map< std::string, std::string > &  aliases 
)

Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name", performing alias substitution.

Alias substitution is performed as follows: as long as name appears as a key in aliases, it is substituted by its value. Properties in s override those of the alias (in case of recursion, the "outer" properties override those of the "inner" aliases).

std::map< std::string, std::string > dai::readAliasesFile ( const std::string &  filename  ) 

Reads aliases from file named filename.

Parameters:
filename Name of the alias file
Returns:
A map that maps aliases to the strings they should be substituted with.
See also:
Aliases file format

size_t dai::getFactorEntryForState ( const FactorGraph &  fg,
size_t  I,
const vector< size_t > &  state 
)

Returns the entry of the I'th factor corresponding to a global state.

vector<size_t> dai::complement ( vector< size_t > &  xis,
size_t  n_states 
)

Given a sorted vector of states xis and total state count n_states, return a vector of states not in xis.

Real dai::unSoftMax ( Real  a,
Real  b 
)

Computes $\frac{\exp(a)}{\exp(a)+\exp(b)}$.

Real dai::logSumExp ( Real  a,
Real  b 
)

Computes log of sum of exponents, i.e., $\log\left(\exp(a) + \exp(b)\right)$.

Real dai::dist ( const vector< Factor > &  b1,
const vector< Factor > &  b2,
size_t  nv 
)

Compute sum of pairwise L-infinity distances of the first nv factors in each vector.

static vector<Factor> dai::mixBeliefs ( Real  p,
const vector< Factor > &  b,
const vector< Factor > &  c 
) [static]

Calculates a vector of mixtures p * b + (1-p) * c.

size_t dai::eliminationCost_MinNeighbors ( const ClusterGraph &  cl,
size_t  i 
)

Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinNeighbors" criterion.

The cost is measured as "number of neigboring nodes in the current adjacency graph", where the adjacency graph has the variables as its nodes and connects nodes i1 and i2 iff i1 and i2 occur together in some common cluster.

size_t dai::eliminationCost_MinWeight ( const ClusterGraph &  cl,
size_t  i 
)

Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinWeight" criterion.

The cost is measured as "product of weights of neighboring nodes in the current adjacency graph", where the adjacency graph has the variables as its nodes and connects nodes i1 and i2 iff i1 and i2 occur together in some common cluster. The weight of a node is the number of states of the corresponding variable.

size_t dai::eliminationCost_MinFill ( const ClusterGraph &  cl,
size_t  i 
)

Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinFill" criterion.

The cost is measured as "number of added edges in the adjacency graph", where the adjacency graph has the variables as its nodes and connects nodes i1 and i2 iff i1 and i2 occur together in some common cluster.

size_t dai::eliminationCost_WeightedMinFill ( const ClusterGraph &  cl,
size_t  i 
)

Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "WeightedMinFill" criterion.

The cost is measured as "total weight of added edges in the adjacency graph", where the adjacency graph has the variables as its nodes and connects nodes i1 and i2 iff i1 and i2 occur together in some common cluster. The weight of an edge is the product of the number of states of the variables corresponding with its nodes.

Factor dai::calcMarginal ( const InfAlg &  obj,
const VarSet &  vs,
bool  reInit 
)

Calculates the marginal probability distribution for vs using inference algorithm obj.

calcMarginal() works by clamping all variables in vs and calculating the partition sum for each clamped state. Therefore, it can be used in combination with any inference algorithm that can calculate/approximate partition sums.

Parameters:
obj instance of inference algorithm to be used
vs variables for which the marginal should be calculated
reInit should be set to true if at least one of the possible clamped states would be invalid (leading to a factor graph with zero partition sum).

std::vector< Factor > dai::calcPairBeliefs ( const InfAlg &  obj,
const VarSet &  vs,
bool  reInit,
bool  accurate = false 
)

Calculates beliefs for all pairs of variables in vs using inference algorithm obj.

calcPairBeliefs() works by

  • clamping single variables in vs and calculating the partition sum and the single variable beliefs for each clamped state, if accurate == false;
  • clamping pairs of variables in vs and calculating the partition sum for each clamped state, if accurate == true.

Therefore, it can be used in combination with any inference algorithm that can calculate/approximate partition sums (and single variable beliefs, if accurate == true).

Parameters:
obj instance of inference algorithm to be used
vs variables for which the pair beliefs should be calculated
reInit should be set to true if at least one of the possible clamped states would be invalid (leading to a factor graph with zero partition sum).
accurate if true, uses a slower but more accurate approximation algorithm

std::vector< size_t > dai::findMaximum ( const InfAlg &  obj  ) 

Calculates the joint state of all variables that has maximum probability, according to the inference algorithm obj.

Note:
Before this method is called, obj.run() should have been called.

Factor dai::createFactorIsing ( const Var &  x,
Real  h 
)

Returns a binary unnormalized single-variable factor $ \exp(hx) $ where $ x = \pm 1 $.

Parameters:
x Variable (should be binary)
h Field strength

Factor dai::createFactorIsing ( const Var &  x1,
const Var &  x2,
Real  J 
)

Returns a binary unnormalized pairwise factor $ \exp(J x_1 x_2) $ where $ x_1, x_2 = \pm 1 $.

Parameters:
x1 First variable (should be binary)
x2 Second variable (should be binary)
J Coupling strength

Factor dai::createFactorExpGauss ( const VarSet &  vs,
Real  beta 
)

Returns a random factor on the variables vs with strength beta.

Each entry are set by drawing a normally distributed random with mean 0 and standard-deviation beta, and taking its exponent.

Parameters:
vs Variables
beta Factor strength (inverse temperature)

Factor dai::createFactorPotts ( const Var &  x1,
const Var &  x2,
Real  J 
)

Returns a pairwise Potts factor $ \exp( J \delta_{x_1, x_2} ) $.

Parameters:
x1 First variable
x2 Second variable (should have the same number of states as x1)
J Factor strength

Factor dai::createFactorDelta ( const Var &  v,
size_t  state 
)

Returns a Kronecker delta point mass.

Parameters:
v Variable
state The state of v that should get value 1

Factor dai::createFactorDelta ( const VarSet &  vs,
size_t  state 
)

Returns a Kronecker delta point mass.

Parameters:
vs Set of variables
state The state of vs that should get value 1

std::ostream& dai::operator<< ( std::ostream &  os,
const FactorGraph &  fg 
)

Writes a FactorGraph to an output stream.

Writes a factor graph to an output stream.

See also:
Factor graph (.fg) file format

std::istream& dai::operator>> ( std::istream &  is,
FactorGraph &  fg 
)

Reads a FactorGraph from an input stream.

Reads a factor graph from an input stream.

See also:
Factor graph (.fg) file format
Exceptions:
INVALID_FACTORGRAPH_FILE if the input stream is not valid

GraphAL dai::createGraphFull ( size_t  N  ) 

Creates a fully-connected graph with N nodes.

GraphAL dai::createGraphGrid ( size_t  N1,
size_t  N2,
bool  periodic 
)

Creates a two-dimensional rectangular grid of N1 by N2 nodes, which can be periodic.

GraphAL dai::createGraphGrid3D ( size_t  N1,
size_t  N2,
size_t  N3,
bool  periodic 
)

Creates a three-dimensional rectangular grid of N1 by N2 by N3 nodes, which can be periodic.

GraphAL dai::createGraphLoop ( size_t  N  ) 

Creates a graph consisting of a single loop of N nodes.

GraphAL dai::createGraphTree ( size_t  N  ) 

Creates a random tree-structured graph of N nodes.

GraphAL dai::createGraphRegular ( size_t  N,
size_t  d 
)

Creates a random regular graph of N nodes with uniform connectivity d.

Algorithm 1 in [StW99]. Draws a random graph of size N and uniform degree d from an almost uniform probability distribution over these graphs (which becomes uniform in the limit that d is small and N goes to infinity).

template<class T>
TFactor<T>& dai::makePositive ( TFactor< T > &  f,
T  epsilon 
) [inline]

Sets factor entries that lie between 0 and epsilon to epsilon.

template<class T>
TFactor<T>& dai::makeZero ( TFactor< T > &  f,
T  epsilon 
) [inline]

Sets factor entries that are smaller (in absolute value) than epsilon to 0.

void dai::ReadUaiAieFactorGraphFile ( const char *  filename,
size_t  verbose,
std::vector< Var > &  vars,
std::vector< Factor > &  factors,
std::vector< Permute > &  permutations 
)

Reads factor graph (as a pair of a variable vector and factor vector) from a file in the UAI approximate inference challenge format.

Parameters:
[in] filename The filename (usually ends with ".uai")
[in] verbose The amount of output sent to cout
[out] vars Array of variables read from the file
[out] factors Array of factors read from the file
[out] permutations Array of permutations, which permute between libDAI canonical ordering and ordering specified by the file
See also:
http://www.cs.huji.ac.il/project/UAI10 and http://graphmod.ics.uci.edu/uai08

std::vector< std::map< size_t, size_t > > dai::ReadUaiAieEvidenceFile ( const char *  filename,
size_t  verbose 
)

Reads evidence (a mapping from observed variable labels to the observed values) from a file in the UAI approximate inference challenge format.

Parameters:
[in] filename The filename (usually ends with ".uai.evid")
[in] verbose The amount of output sent to cout
See also:
http://www.cs.huji.ac.il/project/UAI10 and http://graphmod.ics.uci.edu/uai08

std::ostream & dai::operator<< ( std::ostream &  os,
const Property &  p 
)

Writes a Property object (key-value pair) to an output stream.

Note:
Not all value types are automatically supported; if a type is unknown, an UNKNOWN_PROPERTY_TYPE exception is thrown. Adding support for a new type can be done by changing this function body.

std::ostream& dai::operator<< ( std::ostream &  os,
const PropertySet &  ps 
)

Writes a PropertySet object to an output stream.

It uses the format "[key1=val1,key2=val2,...,keyn=valn]".

Note:
Only a subset of all possible types is supported (see the implementation of this function). Adding support for more types has to be done by hand.
Exceptions:
UNKNOWN_PROPERTY_TYPE if the type of a property value is not supported.

std::istream& dai::operator>> ( std::istream &  is,
PropertySet &  ps 
)

Reads a PropertySet object from an input stream, storing values as strings.

Reads a PropertySet object from an input stream.

It expects a string in the format "[key1=val1,key2=val2,...,keyn=valn]". Values are stored as strings.

Exceptions:
MALFORMED_PROPERTY if the string is not in the expected format

ostream& dai::operator<< ( ostream &  os,
const RegionGraph &  rg 
)

Send RegionGraph to output stream.

bool dai::isnan ( Real  x  ) 

Returns true if argument is NAN (Not A Number).

Examples:
uai2010-aie-solver.cpp.

double dai::toc (  ) 

Returns wall clock time in seconds.

_rnd_gen_type dai::_rnd_gen ( 42U   ) 

Global random number generator.

boost::uniform_real<Real> dai::_uni_dist ( 0  ,
1   
)

Uniform distribution with values between 0 and 1 (0 inclusive, 1 exclusive).

boost::variate_generator<_rnd_gen_type&, boost::uniform_real<Real> > dai::_uni_rnd ( _rnd_gen  ,
_uni_dist   
)

Global uniform random random number.

boost::variate_generator<_rnd_gen_type&, boost::normal_distribution<Real> > dai::_normal_rnd ( _rnd_gen  ,
_normal_dist   
)

Global random number generator with standard normal distribution.

void dai::rnd_seed ( size_t  seed  ) 

Sets the random seed.

Real dai::rnd_uniform (  ) 

Returns a real number, distributed uniformly on [0,1).

Real dai::rnd_stdnormal (  ) 

Returns a real number from a standard-normal distribution.

int dai::rnd_int ( int  min,
int  max 
)

Returns a random integer in interval [min, max].

std::vector< std::string > dai::tokenizeString ( const std::string &  s,
bool  singleDelim,
const std::string &  delim = "\t\n" 
)

Split a string into tokens delimited by one of the characters in delim.

Parameters:
s the string to be split into tokens
singleDelim if true, any single delimiter forms a boundary between two tokens; if false, a maximal group of consecutive delimiters forms a boundary between two tokens
delim delimiter characters

size_t dai::calcLinearState ( const VarSet &  vs,
const std::map< Var, size_t > &  state 
)

Calculates the linear index in the Cartesian product of the variables in vs that corresponds to a particular joint assignment of the variables, specified by state.

Parameters:
vs Set of variables for which the linear state should be calculated;
state Specifies the states of some variables.
Returns:
The linear index in the Cartesian product of the variables in vs corresponding with the joint assignment specified by state, where variables for which no state is specified are assumed to be in state 0.
The linear index is calculated as follows. The variables in vs are ordered according to their label (in ascending order); say vs corresponds with the set $\{x_{l(0)},x_{l(1)},\dots,x_{l(n-1)}\}$ with $l(0) < l(1) < \dots < l(n-1)$, where variable $x_l$ has label l. Denote by $S_l$ the number of possible values ("states") of variable $x_l$. The argument state corresponds with a mapping s that assigns to each variable $x_l$ a state $s(x_l) \in \{0,1,\dots,S_l-1\}$, where $s(x_l)=0$ if $x_l$ is not specified in state. The linear index $S$ corresponding with state is now calculated by:

\begin{eqnarray*} S &:=& \sum_{i=0}^{n-1} s(x_{l(i)}) \prod_{j=0}^{i-1} S_{l(j)} \\ &= & s(x_{l(0)}) + s(x_{l(1)}) S_{l(0)} + s(x_{l(2)}) S_{l(0)} S_{l(1)} + \dots + s(x_{l(n-1)}) S_{l(0)} \cdots S_{l(n-2)}. \end{eqnarray*}

Note:
If vs corresponds with $\{x_l\}_{l\in L}$, and state specifies a state for each variable $x_l$ for $l\in L$, calcLinearState() induces a mapping $\sigma : \prod_{l\in L} X_l \to \{0,1,\dots,\prod_{l\in L} S_l-1\}$ that maps a joint state to a linear index; this is the inverse of the mapping $\sigma^{-1}$ induced by calcState().
See also:
calcState()

std::map< Var, size_t > dai::calcState ( const VarSet &  vs,
size_t  linearState 
)

Calculates the joint assignment of the variables in vs corresponding to the linear index linearState.

Parameters:
vs Set of variables to which linearState refers
linearState should be smaller than vs.nrStates().
Returns:
A mapping $s$ that maps each Var $x_l$ in vs to its state $s(x_l)$, as specified by linearState.
The variables in vs are ordered according to their label (in ascending order); say vs corresponds with the set $\{x_{l(0)},x_{l(1)},\dots,x_{l(n-1)}\}$ with $l(0) < l(1) < \dots < l(n-1)$, where variable $x_l$ has label l. Denote by $S_l$ the number of possible values ("states") of variable $x_l$ with label l. The mapping $s$ returned by this function is defined as:

\begin{eqnarray*} s(x_{l(i)}) = \left\lfloor\frac{S \mbox { mod } \prod_{j=0}^{i} S_{l(j)}}{\prod_{j=0}^{i-1} S_{l(j)}}\right\rfloor \qquad \mbox{for all $i=0,\dots,n-1$}. \end{eqnarray*}

where $S$ denotes the value of linearState.

Note:
If vs corresponds with $\{x_l\}_{l\in L}$, calcState() induces a mapping $\sigma^{-1} : \{0,1,\dots,\prod_{l\in L} S_l-1\} \to \prod_{l\in L} X_l$ that maps a linear index to a joint state; this is the inverse of the mapping $\sigma$ induced by calcLinearState().
See also:
calcLinearState()

mxArray * dai::Factors2mx ( const vector< Factor > &  Ps  ) 

Convert vector<Factor> structure to a cell vector of CPTAB-like structs.

std::vector< Factor > dai::mx2Factors ( const mxArray *  psi,
long  verbose 
)

Convert cell vector of CPTAB-like structs to vector<Factor>.

Factor dai::mx2Factor ( const mxArray *  psi  ) 

Convert CPTAB-like struct to Factor.

dai::DAI_ENUM ( BBPCostFunctionBase  ,
CFN_GIBBS_B  ,
CFN_GIBBS_B2  ,
CFN_GIBBS_EXP  ,
CFN_GIBBS_B_FACTOR  ,
CFN_GIBBS_B2_FACTOR  ,
CFN_GIBBS_EXP_FACTOR  ,
CFN_VAR_ENT  ,
CFN_FACTOR_ENT  ,
CFN_BETHE_ENT   
)

Enumeration of several cost functions that can be used with BBP.

Note:
This class is meant as a base class for BBPCostFunction, which provides additional functionality.

Real dai::log ( Real  x  )  [inline]

Returns logarithm of x.

Examples:
uai2010-aie-solver.cpp.

Real dai::log0 ( Real  x  )  [inline]

Returns logarithm of x, or 0 if x == 0.

Real dai::exp ( Real  x  )  [inline]

Returns exponent of x.

Examples:
uai2010-aie-solver.cpp.

Real dai::pow ( Real  x,
Real  y 
) [inline]

Returns to the power y.

template<class T>
T dai::abs ( const T &  t  )  [inline]

Returns absolute value of t.

int dai::rnd ( int  n  )  [inline]

Returns a random integer in the half-open interval [0, n).

template<class T>
std::string dai::toString ( const T &  x  )  [inline]

Converts a variable of type T to a std::string by using a boost::lexical_cast.

Examples:
uai2010-aie-solver.cpp.

template<class T>
T dai::fromString ( const std::string &  x  )  [inline]

Converts a variable of type std::string to T by using a boost::lexical_cast.

template<class T>
std::ostream& dai::operator<< ( std::ostream &  os,
const std::vector< T > &  x 
) [inline]

Writes a std::vector<> to a std::ostream.

template<class T>
std::ostream& dai::operator<< ( std::ostream &  os,
const std::set< T > &  x 
) [inline]

Writes a std::set<> to a std::ostream.

template<class T1, class T2>
std::ostream& dai::operator<< ( std::ostream &  os,
const std::map< T1, T2 > &  x 
) [inline]

Writes a std::map<> to a std::ostream.

template<class T1, class T2>
std::ostream& dai::operator<< ( std::ostream &  os,
const std::pair< T1, T2 > &  x 
) [inline]

Writes a std::pair<> to a std::ostream.

template<class T>
std::vector<T> dai::concat ( const std::vector< T > &  u,
const std::vector< T > &  v 
) [inline]

Concatenates two vectors.

template<typename T>
RootedTree dai::MinSpanningTree ( const WeightedGraph< T > &  G,
bool  usePrim 
) [inline]

Constructs a minimum spanning tree from the (non-negatively) weighted graph G.

Parameters:
G Weighted graph that should have non-negative weights.
usePrim If true, use Prim's algorithm (complexity O(E log(V))), otherwise, use Kruskal's algorithm (complexity O(E log(E))).
Note:
Uses implementation from Boost Graph Library.

The vertices of G must be in the range [0,N) where N is the number of vertices of G.

template<typename T>
RootedTree dai::MaxSpanningTree ( const WeightedGraph< T > &  G,
bool  usePrim 
) [inline]

Constructs a minimum spanning tree from the (non-negatively) weighted graph G.

Parameters:
G Weighted graph that should have non-negative weights.
usePrim If true, use Prim's algorithm (complexity O(E log(V))), otherwise, use Kruskal's algorithm (complexity O(E log(E))).
Note:
Uses implementation from Boost Graph Library.

The vertices of G must be in the range [0,N) where N is the number of vertices of G.

Variable Documentation

boost::normal_distribution<Real> dai::_normal_dist

Normal distribution with mean 0 and standard deviation 1.

const char* dai::DAINames[] [static]

Contains the names of all inference algorithms compiled into libDAI.

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/namespacemembers_type.html0000644000263000017630000000552011433220721020424 0ustar jorismkyb libDAI: Class Members
 

  • _rnd_gen_type : dai
  • DAIAlgFG : dai
  • DAIAlgRG : dai
  • Edge : dai
  • Factor : dai
  • Neighbors : dai
  • Prob : dai
  • Property : dai
  • PropertyKey : dai
  • PropertyValue : dai
  • Real : dai
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/globals.html0000644000263000017630000000530211433220721015475 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented file members with links to the documentation:

Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x76.html0000644000263000017630000001503411433220721016651 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- v -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/bipgraph_8h-source.html0000644000263000017630000014635511433220721017561 0ustar jorismkyb libDAI: include/dai/bipgraph.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_139.png0000644000263000017630000000037511433220721015236 0ustar jorismkyb‰PNG  IHDR#  ‰0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf{IDAT™c`À87À™ `šù\ˆé3„æ˜$¬fN’¬ B¼@öD0“ j?KA™£ì¸ÂÔ€ÐÝ@Ü5lVCH蘃)Dö$«ˆþ4€ÌbøʦKAÌìhb`ð\9s’àLø ànJ^®IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1GraphEL.html0000644000263000017630000001470411433220721017506 0ustar jorismkyb libDAI: dai::GraphEL Class Reference

dai::GraphEL Class Reference

Represents an undirected graph, implemented as a std::set of undirected edges. More...

#include <dai/weightedgraph.h>

List of all members.

Public Member Functions

 GraphEL ()
 Default constructor.
template<class InputIterator>
 GraphEL (InputIterator begin, InputIterator end)
 Construct from range of objects that can be cast to UEdge.
 GraphEL (const GraphAL &G)
 Construct from GraphAL.

Detailed Description

Represents an undirected graph, implemented as a std::set of undirected edges.

Constructor & Destructor Documentation

dai::GraphEL::GraphEL (  )  [inline]

Default constructor.

template<class InputIterator>
dai::GraphEL::GraphEL ( InputIterator  begin,
InputIterator  end 
) [inline]

Construct from range of objects that can be cast to UEdge.

dai::GraphEL::GraphEL ( const GraphAL &  G  )  [inline]

Construct from GraphAL.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/io_8h-source.html0000644000263000017630000001044511433220721016362 0ustar jorismkyb libDAI: include/dai/io.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/emalg_8h.html0000644000263000017630000001226011433220721015537 0ustar jorismkyb libDAI: include/dai/emalg.h File Reference

include/dai/emalg.h File Reference

Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters). More...

#include <vector>
#include <map>
#include <dai/factor.h>
#include <dai/daialg.h>
#include <dai/evidence.h>
#include <dai/index.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::ParameterEstimation
 Base class for parameter estimation methods. More...
class  dai::CondProbEstimation
 Estimates the parameters of a conditional probability table, using pseudocounts. More...
class  dai::SharedParameters
 Represents a single factor or set of factors whose parameters should be estimated. More...
class  dai::MaximizationStep
 A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. More...
class  dai::EMAlg
 EMAlg performs Expectation Maximization to learn factor parameters. More...

Detailed Description

Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters).

Todo:
Implement parameter estimation for undirected models / factor graphs.
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_52.png0000644000263000017630000000045711433220721015151 0ustar jorismkyb‰PNG  IHDR+ ßiÅ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf­IDAT™c` °¤˜)±BO­0 "ìÄo3A€!¡[Èat¸^Ç  à :¸ß}ga¸ÌÀª<$nËÀÀúÈgaH``øÀÀ+Vè`fpºÈ(ð…•‰ù3Û/ ]ÌŽ±1:\äòA™Aœß}C—Ï ê6—¯Ìɦ a l!f ¡Ždþ¦ÚÀ${hT˜QÙ' _h#÷ž•TIEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1fo__log.html0000644000263000017630000000710511433220721020044 0ustar jorismkyb libDAI: dai::fo_log< T > Struct Template Reference

dai::fo_log< T > Struct Template Reference

Function object that takes the logarithm. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns log(x).

Detailed Description

template<typename T>
struct dai::fo_log< T >

Function object that takes the logarithm.

Member Function Documentation

template<typename T>
T dai::fo_log< T >::operator() ( const T &  x  )  const [inline]

Returns log(x).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/ideas.html0000644000263000017630000001727211433220721015150 0ustar jorismkyb libDAI: Ideas worth exploring

Ideas worth exploring

Class dai::BipartiteGraph
Cache second-order neighborhoods in BipartiteGraph.

Member dai::CBP::runRecurse (InfAlg *bp, Real orig_logZ, std::vector< size_t > clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, std::vector< Factor > &beliefs_out)
dai::CBP::runRecurse() could be implemented more efficiently with a nesting version of backupFactors/restoreFactors

Class dai::DAIAlg< GRM >
A DAIAlg should not inherit from a FactorGraph or RegionGraph, but should store a reference to the graphical model object. This prevents needless copying of (possibly large) data structures. Disadvantage: the caller must not change the graphical model between calls to the inference algorithm (maybe a smart_ptr or some locking mechanism would help here?).

Class dai::FactorGraph
Alternative implementation of undo factor changes: the only things that have to be undone currently are setting a factor to 1 and setting a factor to a Kronecker delta. This could also be implemented in the TFactor itself, which could maintain its state (ones/delta/full) and act accordingly. Update: it seems that the proposed functionality would not be enough for CBP, for which it would make more sense to add more levels of backup/restore.

Class dai::IndexFor
Optimize all indices as follows: keep a cache of all (or only relatively small) indices that have been computed (use a hash). Then, instead of computing on the fly, use the precomputed ones. Here the labels of the variables don't matter, but the ranges of the variables do.

Class dai::InfAlg
General marginalization functions like calcMarginal() now copy a complete InfAlg object. Instead, it would make more sense that they construct a new object without copying the FactorGraph or RegionGraph. Or they can simply be made methods of the general InfAlg class.

Class dai::InfAlg
Use a PropertySet as output of an InfAlg, instead of functions like maxDiff() and Iterations().

Class dai::RegionGraph
Generalize the definition of region graphs to the one given in [YFW05], i.e., replace the current implementation which uses a BipartiteGraph with one that uses a DAG.

Class dai::RegionGraph
The outer regions are products of factors; right now, this product is constantly cached: changing one factor results in an update of all relevant outer regions. This may not be the most efficient approach; an alternative would be to only precompute the factor products at the start of an inference algorithm - e.g., in init(). This has the additional advantage that FactorGraph e can offer write access to its factors.

Class dai::State
Make the State class a more prominent part of libDAI (and document it clearly, explaining the concept of state); add more optimized variants of the State class like IndexFor (e.g. for TFactor<>::slice()).

File bp_dual.h
BP_dual replicates a large part of the functionality of BP; would it not be more efficient to adapt BP instead?

File doc.h
Adapt (part of the) guidelines in http://www.boost.org/development/requirements.html#Design_and_Programming

File doc.h
Use "gcc -MM" to generate dependencies for targets: http://make.paulandlesley.org/autodep.html

File doc.h
Disentangle structures. In particular, ensure that graphical properties are not entangled with probabilistic properties. For example, a FactorGraph contains several components:
  • a BipartiteGraph
  • an array of variable labels
  • an array of variable state space sizes
  • an array of pointers to factor value vectors In this way, each factor could be implemented differently, e.g., we could have some sparse factors, some noisy-OR factors, some dense factors, some arbitrary precision factors, etcetera.

File doc.h
Use boost::uBLAS framework to deal with matrices, especially, with 2D sparse matrices. See http://www.boost.org/libs/numeric/ublas/doc/matrix_sparse.htm However: I read somewhere that boost::uBLAS concentrates more on correct implementation than on performance.

File hak.h
Implement more general region graphs and corresponding Generalized Belief Propagation updates as described in [YFW05].
Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1greedyVariableElimination-members.html0000644000263000017630000000554011433220721024770 0ustar jorismkyb libDAI: Member List

dai::greedyVariableElimination Member List

This is the complete list of members for dai::greedyVariableElimination, including all inherited members.

eliminationCostFunction typedefdai::greedyVariableElimination
greedyVariableElimination(eliminationCostFunction h)dai::greedyVariableElimination [inline]
heuristicdai::greedyVariableElimination [private]
operator()(const ClusterGraph &cl, const std::set< size_t > &remainingVars)dai::greedyVariableElimination

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1CondProbEstimation.html0000644000263000017630000004252111433220721021765 0ustar jorismkyb libDAI: dai::CondProbEstimation Class Reference

dai::CondProbEstimation Class Reference

Estimates the parameters of a conditional probability table, using pseudocounts. More...

#include <dai/emalg.h>

Inheritance diagram for dai::CondProbEstimation:

dai::ParameterEstimation

List of all members.

Public Member Functions

 CondProbEstimation (size_t target_dimension, const Prob &pseudocounts)
 Constructor.
virtual ParameterEstimation * clone () const
 Virtual copy constructor.
virtual ~CondProbEstimation ()
 Virtual destructor.
virtual Prob estimate ()
 Returns an estimate of the conditional probability distribution.
virtual void addSufficientStatistics (const Prob &p)
 Accumulate sufficient statistics from the expectations in p.
virtual size_t probSize () const
 Returns the required size for arguments to addSufficientStatistics().

Static Public Member Functions

static ParameterEstimation * factory (const PropertySet &p)
 Virtual constructor, using a PropertySet.

Private Attributes

size_t _target_dim
 Number of states of the variable of interest.
Prob _stats
 Current pseudocounts.
Prob _initial_stats
 Initial pseudocounts.

Detailed Description

Estimates the parameters of a conditional probability table, using pseudocounts.

Author:
Charles Vaske

Constructor & Destructor Documentation

dai::CondProbEstimation::CondProbEstimation ( size_t  target_dimension,
const Prob &  pseudocounts 
)

Constructor.

For a conditional probability $ P( X | Y ) $,

Parameters:
target_dimension should equal $ | X | $
pseudocounts are the initial pseudocounts, of length $ |X| \cdot |Y| $

virtual dai::CondProbEstimation::~CondProbEstimation (  )  [inline, virtual]

Virtual destructor.

Member Function Documentation

ParameterEstimation * dai::CondProbEstimation::factory ( const PropertySet &  p  )  [static]

Virtual constructor, using a PropertySet.

Some keys in the PropertySet are required. For a conditional probability $ P( X | Y ) $,

  • target_dimension should be equal to $ | X | $
  • total_dimension should be equal to $ |X| \cdot |Y| $

An optional key is:

  • pseudo_count which specifies the initial counts (defaults to 1)

virtual ParameterEstimation* dai::CondProbEstimation::clone (  )  const [inline, virtual]

Virtual copy constructor.

Implements dai::ParameterEstimation.

Prob dai::CondProbEstimation::estimate (  )  [virtual]

Returns an estimate of the conditional probability distribution.

The format of the resulting Prob keeps all the values for $ P(X | Y=y) $ in sequential order in the array.

Implements dai::ParameterEstimation.

void dai::CondProbEstimation::addSufficientStatistics ( const Prob &  p  )  [virtual]

Accumulate sufficient statistics from the expectations in p.

Implements dai::ParameterEstimation.

virtual size_t dai::CondProbEstimation::probSize (  )  const [inline, virtual]

Returns the required size for arguments to addSufficientStatistics().

Implements dai::ParameterEstimation.

Member Data Documentation

size_t dai::CondProbEstimation::_target_dim [private]

Number of states of the variable of interest.

Prob dai::CondProbEstimation::_stats [private]

Current pseudocounts.

Prob dai::CondProbEstimation::_initial_stats [private]

Initial pseudocounts.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x73.html0000644000263000017630000001017311433220721017700 0ustar jorismkyb libDAI: Class Members - Variables
 

- s -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/inline_dotgraph_2.dot.png0000644000263000017630000000101711433220721020045 0ustar jorismkyb‰PNG  IHDRD`VÉ¡PLTEþÿÿ???ßßß___¿¿¿ÓÓÓÿÿÿ.ÆNtRNS@æØfŸIDATH‰Õ—KnÄ †¹L¥ö=@Ñe=I¥l«ÎÈܶ“ØÀmš™E›áñØŽòánAÒ÷'MYì™àŠA„ÚB 04"<}9i‘½=¿ÁÀGˆ&HìNIÂE—™ ;0uR5²à—ï.ÜÑÊM¯ÄËs©·Þ T›!’ ½¡ BùHRo‹éÜ…äá5¦G ävDZë' LÇâã˜Ç‚0êÝ„M*JZ|ÑNG5ñTElnˆêû+d/êq['¸yÚ4¿./ÛÑÏñŠðXf#¶¯¼ŠmûÜÿ–Œ™ —÷‚ÄIMèç Ë+§Gµ lyRðª ^èfÑ‚_V¼»pG+7]â¥ÓRÅK1´ Mu‚ôñ÷cÒ#Ý1·#è×âU€¨!BÇHëŒS6-bD: ¬ â¢2ã!ä#XèrÚ¡)ƒ̱¨(61zg bÊaüëåð ¶sû#u²– 'Þ8ë*u2ÈGED•ç¦E©Á"µ–C{JÖ‚²ErEþk9œ}>¡LÉ{áÏæ| †{·ã=[IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1JTree_1_1Properties-members.html0000644000263000017630000000720511433220721023617 0ustar jorismkyb libDAI: Member List

dai::JTree::Properties Member List

This is the complete list of members for dai::JTree::Properties, including all inherited members.

DAI_ENUM(UpdateType, HUGIN, SHSH)dai::JTree::Properties
DAI_ENUM(InfType, SUMPROD, MAXPROD)dai::JTree::Properties
DAI_ENUM(HeuristicType, MINNEIGHBORS, MINWEIGHT, MINFILL, WEIGHTEDMINFILL)dai::JTree::Properties
heuristicdai::JTree::Properties
inferencedai::JTree::Properties
maxmemdai::JTree::Properties
updatesdai::JTree::Properties
verbosedai::JTree::Properties

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__log0-members.html0000644000263000017630000000356611433220721021563 0ustar jorismkyb libDAI: Member List

dai::fo_log0< T > Member List

This is the complete list of members for dai::fo_log0< T >, including all inherited members.

operator()(const T &x) const dai::fo_log0< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/util_8h.html0000644000263000017630000004657211433220721015444 0ustar jorismkyb libDAI: include/dai/util.h File Reference

include/dai/util.h File Reference

Defines general utility functions and adds an abstraction layer for platform-dependent functionality. More...

#include <string>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <boost/foreach.hpp>
#include <boost/functional/hash.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <cerrno>
#include <dai/exceptions.h>
#include <tr1/unordered_map>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::hash_map< T, U, H >
 hash_map is an alias for std::tr1::unordered_map. More...

Defines

#define foreach   BOOST_FOREACH
 An alias to the BOOST_FOREACH macro from the boost::foreach library.
#define DAI_PV(x)   do {std::cerr << #x "= " << (x) << std::endl;} while(0)
 "Print variable". Prints the text of an expression, followed by its value (only if DAI_DEBUG is defined)
#define DAI_DMSG(str)   do {std::cerr << str << std::endl;} while(0)
 "Debugging message": Prints a message (only if DAI_DEBUG is defined)
#define DAI_IFVERB(n, stmt)   if(props.verbose>=n) { std::cerr << stmt; }
 Macro to write message stmt to std::cerr if props.verbose >= n.

Typedefs

typedef double dai::Real
 Real number (alias for double, which could be changed to long double if necessary).

Enumerations

enum  dai::ProbNormType { NORMPROB, NORMLINF }
 Enumerates different ways of normalizing a probability measure. More...
enum  dai::ProbDistType {
  DISTL1, DISTLINF, DISTTV, DISTKL,
  DISTHEL
}
 Enumerates different distance measures between probability measures. More...

Functions

bool dai::isnan (Real x)
 Returns true if argument is NAN (Not A Number).
Real dai::log (Real x)
 Returns logarithm of x.
Real dai::log0 (Real x)
 Returns logarithm of x, or 0 if x == 0.
Real dai::exp (Real x)
 Returns exponent of x.
Real dai::pow (Real x, Real y)
 Returns to the power y.
double dai::toc ()
 Returns wall clock time in seconds.
template<class T>
T dai::abs (const T &t)
 Returns absolute value of t.
void dai::rnd_seed (size_t seed)
 Sets the random seed.
Real dai::rnd_uniform ()
 Returns a real number, distributed uniformly on [0,1).
Real dai::rnd_stdnormal ()
 Returns a real number from a standard-normal distribution.
int dai::rnd_int (int min, int max)
 Returns a random integer in interval [min, max].
int dai::rnd (int n)
 Returns a random integer in the half-open interval [0, n).
template<class T>
std::string dai::toString (const T &x)
 Converts a variable of type T to a std::string by using a boost::lexical_cast.
template<class T>
T dai::fromString (const std::string &x)
 Converts a variable of type std::string to T by using a boost::lexical_cast.
template<class T>
std::ostream & dai::operator<< (std::ostream &os, const std::vector< T > &x)
 Writes a std::vector<> to a std::ostream.
template<class T>
std::ostream & dai::operator<< (std::ostream &os, const std::set< T > &x)
 Writes a std::set<> to a std::ostream.
template<class T1, class T2>
std::ostream & dai::operator<< (std::ostream &os, const std::map< T1, T2 > &x)
 Writes a std::map<> to a std::ostream.
template<class T1, class T2>
std::ostream & dai::operator<< (std::ostream &os, const std::pair< T1, T2 > &x)
 Writes a std::pair<> to a std::ostream.
template<class T>
std::vector< T > dai::concat (const std::vector< T > &u, const std::vector< T > &v)
 Concatenates two vectors.
std::vector< std::string > dai::tokenizeString (const std::string &s, bool singleDelim, const std::string &delim="\t\n")
 Split a string into tokens delimited by one of the characters in delim.

Detailed Description

Defines general utility functions and adds an abstraction layer for platform-dependent functionality.

Define Documentation

#define foreach   BOOST_FOREACH

An alias to the BOOST_FOREACH macro from the boost::foreach library.

#define DAI_PV ( x   )     do {std::cerr << #x "= " << (x) << std::endl;} while(0)

"Print variable". Prints the text of an expression, followed by its value (only if DAI_DEBUG is defined)

Useful debugging macro to see what your code is doing. Example: 

 DAI_PV(3+4)
Output: 
 3+4= 7

#define DAI_DMSG ( str   )     do {std::cerr << str << std::endl;} while(0)

"Debugging message": Prints a message (only if DAI_DEBUG is defined)

#define DAI_IFVERB ( n,
stmt   )     if(props.verbose>=n) { std::cerr << stmt; }

Macro to write message stmt to std::cerr if props.verbose >= n.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x76.html0000644000263000017630000001243211433220721017663 0ustar jorismkyb libDAI: Class Members - Functions
 

- v -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_121.png0000644000263000017630000000124411433220721015221 0ustar jorismkyb‰PNG  IHDRr#º!C0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf"IDAT8ÕTMkA­ùL²$º9(žÌ â%ŠËNÌEÐEÆ@’!Añ°jl †€x“ÉEQ ã% "xSüAñ.ï‰þݘ#bÛSÕ“ÌZۈǼüÙ~óº^Ww/ÀîBoƒ°À”Z™38û*ì»ÿ“)C[™rd¹mpZ2A>ÇGÖ¯›âNn"Ùu¦,·¼ŠÁÙ'ËÈSöüƒâ}yÅŸ–ä9þ*vü;ÏAtsÃs/9}™Çît–dþéµÎêÚ /׈½fÞ`íÙ$Þ!g›·àÚÒ\>ì„'ÃßNSßá)$=T+W\.8½×wt%OÜ3øÖ£ÚÎÚùœ§-ÅÄ÷ÀrÏWŠiûuZJ™]Qãiš.œ³ú»aˆÆ­Eg^æ$Uøº]Òžœ¢p+ùÀL° ›g)?ì~±µãtÅUä£ô libDAI: dai::WeightedGraph< T > Class Template Reference

dai::WeightedGraph< T > Class Template Reference

Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights. More...

#include <dai/weightedgraph.h>

Detailed Description

template<class T>
class dai::WeightedGraph< T >

Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights.
The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x6a.html0000644000263000017630000001007511433220721016723 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- j -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_13.png0000644000263000017630000000035011433220721015136 0ustar jorismkyb‰PNG  IHDR÷áÜ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØffIDAT™c`@^ßQ¸B(Ü)¨Šíyq ¹l¹™Q¸Ø¨¦€Xa@bBÀ%6Žb W½¨¬ŽjÅÖ…‘ 2\¶¢®² ƒ$‡ cÜ@unBpBIN fXIEND®B`‚libDAI-0.2.7/doc/html/form_21.png0000644000263000017630000000027711433220721015145 0ustar jorismkyb‰PNG  IHDR Olú×0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf=IDAT™c`@ Ú3?-ËH3>ЇIuÁÏÀ4ã¯U`µ œ 2üza7„fü¿*á“Ñ  @$IEND®B`‚libDAI-0.2.7/doc/html/form_28.png0000644000263000017630000000124611433220721015151 0ustar jorismkyb‰PNG  IHDRv"x–0Ã0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf$IDAT8Ý”ÏkÓ`Ç¿iÒ6ý‘å BçÍèaé ŠŽÆ*UD0 Ü°;,Õ2¦0(c(žŒÛ<Ôð'‰Ìx런“‚þˆèqu'o†V*ì2ß4+¬i!$‚_È“7ïû|Þç›÷}yÿM|Å‘€eæÚ’$mTXhÓ°­ý6¤ì7xé ;S¥a¸;rÞÛ®Ó`tGâ~X¶AC¨Ú‰*4pÉÙåg‘™[c›î¸i,è Z?»øƒ^CøÆ%bOe;¸Ùâæ«ø*ת"^&ÊQ«@úÙD‘†$šUûû#}2)‹¯ã+o°– ‰¤4jàuy€ç!WU²“Ô° Ø¿0~Áâ \OÊ;{Ú€3±‹IPj]wØ_l“²+Sè°’Åob©9€ÍÚTb#&A¶h_‹û=j¢PQ#­²9+úmL¿Ÿÿ2®ºØYÀDTã¿7ö¶³ÛçŽ/áíü»T)_œÖ2J.¯äµ§/ÜuŸBuf9¥PóˆÉ]olBÏÆŠ ûð8º´;ݵž³qwbµ‡Ýxïbk:ŽM‡;•®,H–zИq¹ìòìˆQö2¼4d³?5¯´Aâ?ì=Ç£½]Å3³_Œ$Л#HÝ¥´³š‡Ò'ý³GN­Ÿ›_ñÏ^A¬H;㟴ÏpÆ~ÕÒجWÖ€77°JtƒÃztxq‚ä½(f}ƒQ½3}ëlwœø¦gãMIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1ParameterEstimation-members.html0000644000263000017630000001074011433220721023625 0ustar jorismkyb libDAI: Member List

dai::ParameterEstimation Member List

This is the complete list of members for dai::ParameterEstimation, including all inherited members.

_registrydai::ParameterEstimation [private, static]
addSufficientStatistics(const Prob &p)=0dai::ParameterEstimation [pure virtual]
clone() const =0dai::ParameterEstimation [pure virtual]
construct(const std::string &method, const PropertySet &p)dai::ParameterEstimation [static]
estimate()=0dai::ParameterEstimation [pure virtual]
loadDefaultRegistry()dai::ParameterEstimation [private, static]
ParamEstFactory typedefdai::ParameterEstimation
probSize() const =0dai::ParameterEstimation [pure virtual]
registerMethod(const std::string &method, const ParamEstFactory &f)dai::ParameterEstimation [inline, static]
~ParameterEstimation()dai::ParameterEstimation [inline, virtual]

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/decmap_8h.html0000644000263000017630000000577111433220721015714 0ustar jorismkyb libDAI: include/dai/decmap.h File Reference

include/dai/decmap.h File Reference

Defines class DecMAP, which constructs a MAP state by decimation. More...

#include <dai/daialg.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::DecMAP
 Approximate inference algorithm DecMAP, which constructs a MAP state by decimation. More...
struct  dai::DecMAP::Properties
 Parameters for DecMAP. More...

Detailed Description

Defines class DecMAP, which constructs a MAP state by decimation.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x71.html0000644000263000017630000000726111433220721017702 0ustar jorismkyb libDAI: Class Members - Variables
 

- q -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1FBP.html0000644000263000017630000007021011433220721016625 0ustar jorismkyb libDAI: dai::FBP Class Reference

dai::FBP Class Reference

Approximate inference algorithm "Fractional Belief Propagation" [WiH03]. More...

#include <dai/fbp.h>

Inheritance diagram for dai::FBP:

dai::BP dai::DAIAlg< GRM > dai::InfAlg

List of all members.

FBP accessors/mutators for weights

Real Weight (size_t I) const
 Returns weight of the I 'th factor.
const std::vector< Real > & Weights () const
 Returns constant reference to vector of all factor weights.
void setWeight (size_t I, Real c)
 Sets the weight of the I 'th factor to c.
void setWeights (const std::vector< Real > &c)
 Sets the weights of all factors simultaenously.
virtual Prob calcIncomingMessageProduct (size_t I, bool without_i, size_t i) const
 Calculate the product of factor I and the incoming messages.
virtual void calcNewMessage (size_t i, size_t _I)
 Calculate the updated message from the _I 'th neighbor of variable i to variable i.
virtual void calcBeliefF (size_t I, Prob &p) const
 Calculates unnormalized belief of factor I.
virtual void construct ()
 Helper function for constructors.

Public Member Functions

Constructors/destructors
 FBP ()
 Default constructor.
 FBP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual FBP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Static Public Attributes

static const char * Name = "FBP"
 Name of this inference algorithm.

Protected Attributes

std::vector< Real > _weight
 Factor weights (indexed by factor ID).

Detailed Description

Approximate inference algorithm "Fractional Belief Propagation" [WiH03].

The Fractional Belief Propagation algorithm is like Belief Propagation, but associates each factor with a weight (scale parameter) which controls the divergence measure being minimized. Standard Belief Propagation corresponds to the case of FBP where each weight is 1. When cast as an EP algorithm, BP (and EP) minimize the inclusive KL-divergence, i.e. $\min_q KL(p||q)$ (note that the Bethe free energy is typically derived from $ KL(q||p) $). If each factor I has weight $ c_I $, then FBP minimizes the alpha-divergence with $ \alpha=1/c_I $ for that factor, which also corresponds to Power EP [Min05].

The messages $m_{I\to i}(x_i)$ are passed from factors $I$ to variables $i$. The update equation is given by:

\[ m_{I\to i}(x_i) \propto \left( \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \right)^{c_I} \]

After convergence, the variable beliefs are calculated by:

\[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i} \]

and the factor beliefs are calculated by:

\[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \]

The logarithm of the partition sum is approximated by:

\[ \log Z = \sum_{I} \sum_{x_I} b_I(x_I) \big( \log f_I(x_I) - c_I \log b_I(x_I) \big) + \sum_{i} (c_i - 1) \sum_{x_i} b_i(x_i) \log b_i(x_i) \]

where the variable weights are defined as

\[ c_i := \sum_{I \in N_i} c_I \]

Todo:
Add nice way to set weights
Author:
Frederik Eaton

Constructor & Destructor Documentation

dai::FBP::FBP (  )  [inline]

Default constructor.

dai::FBP::FBP ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
BP::Properties

Member Function Documentation

virtual FBP* dai::FBP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Reimplemented from dai::BP.

string dai::FBP::identify (  )  const [virtual]

Identifies itself for logging purposes.

Reimplemented from dai::BP.

Real dai::FBP::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::BP.

Real dai::FBP::Weight ( size_t  I  )  const [inline]

Returns weight of the I 'th factor.

const std::vector<Real>& dai::FBP::Weights (  )  const [inline]

Returns constant reference to vector of all factor weights.

void dai::FBP::setWeight ( size_t  I,
Real  c 
) [inline]

Sets the weight of the I 'th factor to c.

void dai::FBP::setWeights ( const std::vector< Real > &  c  )  [inline]

Sets the weights of all factors simultaenously.

Note:
Faster than calling setWeight(size_t,Real) for each factor

Prob dai::FBP::calcIncomingMessageProduct ( size_t  I,
bool  without_i,
size_t  i 
) const [protected, virtual]

Calculate the product of factor I and the incoming messages.

If without_i == true, the message coming from variable i is omitted from the product

Note:
This function is used by calcNewMessage() and calcBeliefF()

Reimplemented from dai::BP.

void dai::FBP::calcNewMessage ( size_t  i,
size_t  _I 
) [protected, virtual]

Calculate the updated message from the _I 'th neighbor of variable i to variable i.

Reimplemented from dai::BP.

virtual void dai::FBP::calcBeliefF ( size_t  I,
Prob &  p 
) const [inline, protected, virtual]

Calculates unnormalized belief of factor I.

Reimplemented from dai::BP.

void dai::FBP::construct (  )  [protected, virtual]

Helper function for constructors.

Reimplemented from dai::BP.

Member Data Documentation

std::vector<Real> dai::FBP::_weight [protected]

Factor weights (indexed by factor ID).

const char * dai::FBP::Name = "FBP" [static]

Name of this inference algorithm.

Reimplemented from dai::BP.

The documentation for this class was generated from the following files:
  • include/dai/fbp.h
  • src/fbp.cpp
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1LC.png0000644000263000017630000000103211433220721016330 0ustar jorismkyb‰PNG  IHDRˆ<)PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf°IDAThí×Arƒ0 P¼Ééò :í…ºâþG(’°‘6ž6´‘J˜BÌC’É>úêmx]åÀ€iE² ²­@LÀ¼"j1. ðÿ ÕHH|¨,À«ÈœlÔ|rJX ¶î   ²ŠzIspTÎÞÔI4@õ]دN zv 6Æ«~ÿÐýµ~P·£?LŸOnÓôdàwÁpÀ<7^ ¼ùEfÉ5Ç âW´¿û- …kLüyK^MtQ`Ž"¤´žÕ9¦`BîI‡1EÍxéO‚¡HhÝ™Þk@ËPR2  »3@`‰‰9,êñòŽŒŒ¨CEÈšRÊKa1u°Lbl`€5&æ°Hzý´zÉfô.,  xÕFÖ3ul†Å`3,6å€çÆ_<7:à€8ðzôÕ8Œ}:ðyÅ#ìŒ;†Œf»€0Ÿ5w°sô ÀïYÎ|ÌØÓ_B'0öu8{‚L"äN<•åÀ?z¿Ö¿Â¶¼íì†IEND®B`‚libDAI-0.2.7/doc/html/form_50.png0000644000263000017630000000031311433220721015136 0ustar jorismkyb‰PNG  IHDR RiÊo0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIIDAT™c`À,)æ`†¿Íf #€Ÿ!0 $dËÀ|€H+t03¬_ÀÀÀüáÓÔß@‘6nˆ Œ-)P³×® 1i¶hÎIEND®B`‚libDAI-0.2.7/doc/html/tab_r.gif0000644000263000017630000000503111433220721014741 0ustar jorismkybGIF89a,Õö÷ùñô÷öøúüýþúûüùúûøùúêïóïóöÆÕßÒÞæØâéÞçíÝæìåìñèîòô÷ùóöø³ÈÕÁÒÝËÙâÏÜäÖá薴ŹɯÂÍ»ÎÙÃÔÞÂÓÝÈ×àÌÚâÕáèÙäê×âèåìðëðó„°ÇÑÞåÜæëãëïëñôîóõ÷úûûüüÿÿÿþþþ,,ÿ@’pH,ȤrÉl:ŸÐ¨tJ­Z¯Ø¬v •h<¬pkL.›Ïè´zÍn»ßð¸|N¯Ûïø¼~ÏwVa+‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ “*)^,*ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿ÀÁÂö)'ÆÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæÚ¥(" ðñòóôõö÷øùúûüýþÿ H° ÁƒòK"ƒRHœH±¢Å‹3jÜȱ£Ç CŠI²¤É“(Sª\éÅu&@€ Á²¦Í›8sêÜɳ§Oÿ–(±€DУH“*]Ê´©Ó§P£JJµªÕ«X³jÝʵ«×¯S84± ‰hÓª]˶­Û·pãÊK·®Ý»xóêÝË·¯ß¿€Ó} âDÌf(^̸±ãÇ#KžL¹²å˘3kÞ̹³çÏ C‹m¹ðCÄHœXͺµë×°cËžM»¶íÛ¸sëÞÍ»·ïßÀƒ N÷ÃJ” Á®¹óçУKŸN½ºõëسkßν»÷ïàËO¾úñ€ dÇ@€‚‚L¤"ÉÈF:ò‘Œ¤$9† (8…&ÉÉNzò“  ¥(G©FB^²!˨)WÉÊVºò•°l¤)1™ wÄò–¸Ì¥.wÊYºäƒà¥0‡IÌbó¾|ÉHpÌf:ó™Ðìe pJ±ˆ€}Ȧ6·ÉÍnzó›à §8û0Â%"¸æ8×ÉÎvºóðŒ§<ÉPÎQ`ò%×$€>÷ÉÏ~úóŸ ¨@JЂô M¨BÊІ:ô¡¨D'ZPKF Ö¼&16ÊÑŽzô£ ©HGJRb ÷Lç5ÏÁÒ–ºô¥ÿ0©LgJÓšš#(e>¯‰Óžúô§@ ªP‡JÔ¢õ¨HMªR—ÊÔ¦:õ©PªT§JÕª&5;%U·ÊÕ®zõ«` «XÇJV«ÂC§‹ÑjY×ÊÖ¶ºõ­p«\ŠU´À¦xÍ«^÷Ê×¾úõ¯ÐÀi)$‚”ô°ˆM¬bËØÆ:vˆ, ಘͬf7ËÙÎzö³  ­hGKÚÒšö´¨M­jWËÚÖºöµ°­*$ÛSPô¶¸Í­nwËÛÞúö·ÀÅm +„â¸ÈM®r—ËÜæ:÷¹ÐE®?±9ÏêZ÷ºØÍ®v¿9€î"‚ºÛ ¯xÇKÞòb—™ÑLÿ¯z×Ë^A¢·½ð¯|ç†÷Ò÷¾øͯ0í«ßþú÷¿¡ä/€Là»×ÀN°‚ï(à;øÁ n0„'LaýJ¸ÂÎ0{/¬á{ؘþ°ˆG|Ë“øÄ(¥‰SÌâCrÅ.Ž±Œ ãÛøÆv¬1ŽwÌc6ê¸Ç@ÞñƒLd¹ÈHNñ‘“Ìd/¹ÉPÎð“£LeO¹ÊXŽp–·|â+sùËýõ2˜ÇL_1“ùÌí53š×M5³ùÍÇt3œç¼_:ÛÙÂwÎs™õÌgøʹπp ýÌ?úÐ/F´¢ë¼èFãÒÐŽŽt!-éJã‘Ò–Îô1­éN»‘ÓžuÿA-êP“ºÔ>5ª3­êUWºÕ®Ž4¬cÝèYÓZѶ¾õ¡s­ëAóº×€þ5°ù,ìaç¹Øƶ3²“=çe3ûÍÎ~öš£-í3S»Úc¾6¶¿¬ímo¹ÛÞÆ2¸ÃMåq“Êæ>7“Ó­n$³»ÝD~7¼,ïyó¸ÞöÆ1¾ómã}óÛÈÿvµ¿Þâ\É/µÁNâ…3ÜÉ÷´Ã#Þá‰S\ÊguÆ-mñO¸ã0ÈC¾à‘“\Ë'_´ÉS^à•³|À.ùc.ó0לÐ4¿9~s®ó=÷¼Ï<ÿy|ƒ.ô4]ÏD?ºz“®ô67]ÙO§3Ó£ÞÌ©SÄW‡vÖÙl>õ­3Úëdî:Øu)ö±?ÚìÙF;˜Ë®öW²½í­|;ÜW)÷¹²îvtÞ˽w¾÷Ý|à×=xÂÞÝA;libDAI-0.2.7/doc/html/functions_vars_0x75.html0000644000263000017630000001044211433220721017701 0ustar jorismkyb libDAI: Class Members - Variables
 

- u -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/example__permute_8cpp-example.html0000644000263000017630000002650211433220721021775 0ustar jorismkyb libDAI: example_permute.cpp

example_permute.cpp

This example shows how to use the Permute, multifor and State classes.

Output

V = (x1, x2, x0)
X = {x0, x1, x2}
Note that the ordering of the variables in X is the canonical ordering
(ascendingly according to their labels) but the ordering in V is different.

The permutation between both variable orderings is sigma = (2, 0, 1), or more verbosely:
  sigma[0] = 2
  sigma[1] = 0
  sigma[2] = 1
This means that variable V[sigma[n]] should correspond with the n'th variable in X (for n=0,...,2)...OK. 

The states of the variables x0,x1,x2 are, according to the ordering in V:
SV:  x0:  x1:  x2:
 0    0    0    0
 1    0    1    0
 2    0    2    0
 3    0    0    1
 4    0    1    1
 5    0    2    1
 6    1    0    0
 7    1    1    0
 8    1    2    0
 9    1    0    1
10    1    1    1
11    1    2    1

The states of the variables x0,x1,x2 are, according to the canonical ordering in X:
SX:  x0:  x1:  x2:
 0    0    0    0
 1    1    0    0
 2    0    1    0
 3    1    1    0
 4    0    2    0
 5    1    2    0
 6    0    0    1
 7    1    0    1
 8    0    1    1
 9    1    1    1
10    0    2    1
11    1    2    1

The permutation sigma induces the following permutation of linear indices of joint states:
SV:  SX:
 0    0
 1    2
 2    4
 3    6
 4    8
 5   10
 6    1
 7    3
 8    5
 9    7
10    9
11   11

Source

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2008-2009  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/varset.h>
#include <dai/index.h>
#include <iostream>
#include <iomanip>

using namespace std;
using namespace dai;

int main() {
    Var x0(0, 2);   // Define binary  variable x0 (with label 0)
    Var x1(1, 3);   // Define ternary variable x1 (with label 1)
    Var x2(2, 2);   // Define binary  variable x2 (with label 2)

    // Define vector V = (x1, x2, x0)
    vector<Var> V;      // Define a vector of variables
    V.push_back( x1 );  // V[0] = x1;
    V.push_back( x2 );  // V[1] = x2;
    V.push_back( x0 );  // V[2] = x0;
    cout << "V = " << V << endl; // Note that the elements of X are not necessarily ordered according to their labels

    // Define set X = {x0, x1, x2}
    VarSet X; // empty
    X |= x2;  // X = {x2}
    X |= x0;  // X = {x0, x2}
    X |= x1;  // X = {x0, x1, x2}
    cout << "X = " << X << endl; // Note that the elements of X are ordered according to their labels

    cout << "Note that the ordering of the variables in X is the canonical ordering" << endl;
    cout << "(ascendingly according to their labels) but the ordering in V is different." << endl << endl;

    // N = number of variables in V (and X)
    size_t N = V.size();

    // Define a Permute object based on the variables in V
    Permute sigma(V);
    // Each Var in V corresponds with a dimension in a multi-dimensional array.
    // The permutation sigma permutes these dimensions from the canonical ordering
    // (sorted ascendingly on the label of the variable, i.e., the same ordering as
    // in X) into the ordering these variables have in V.
    cout << "The permutation between both variable orderings is sigma = " << sigma.sigma() << ", or more verbosely:" << endl;
    for( size_t n = 0; n < N; n++ )
        cout << "  sigma[" << n << "] = " << sigma[n] << endl;
    cout << "This means that variable V[sigma[n]] should correspond with the n'th variable in X (for n=0,...," << (N-1) << ")...";
    // Check whether the permutation works as advertised
    VarSet::const_iterator X_n = X.begin();
    for( size_t n = 0; n < N; n++, X_n++ )
        DAI_ASSERT( V[sigma[n]] == *X_n );
    cout << "OK. " << endl << endl;

    // Iterate over the joint states of the variables, according to the ordering in V
    cout << "The states of the variables x0,x1,x2 are, according to the ordering in V:" << endl;
    cout << "SV:  x0:  x1:  x2:" << endl;
    std::vector<size_t> ranges;
    for( size_t i = 0; i < V.size(); i++ )
        ranges.push_back( V[i].states() );
    for( multifor SV(ranges); SV.valid(); ++SV )
        cout << setw(2) << (size_t)SV << "    " << SV[sigma[0]] << "    " << SV[sigma[1]] << "    " << SV[sigma[2]] << endl;
    cout << endl;

    // Iterate over the joint states of the variables, according to the canonical ordering in X
    cout << "The states of the variables x0,x1,x2 are, according to the canonical ordering in X:" << endl;
    cout << "SX:  x0:  x1:  x2:" << endl;
    for( State SX(X); SX.valid(); SX++ )
        cout << setw(2) << SX << "    " << SX(x0) << "    " << SX(x1) << "    " << SX(x2) << endl;
    cout << endl;

    // The main functionality of the Permute object is to calculate the induced permutation of linear indices of joint states
    cout << "The permutation sigma induces the following permutation of linear indices of joint states:" << endl;
    cout << "SV:  SX:" << endl;
    for( size_t li = 0; li < X.nrStates(); li++ )
        cout << setw(2) << li << "   " << setw(2) << sigma.convertLinearIndex( li ) << endl;

    return 0;
}
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x6a.html0000644000263000017630000001015411433220721017734 0ustar jorismkyb libDAI: Class Members - Functions
 

- j -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_69.png0000644000263000017630000000054711433220721015161 0ustar jorismkyb‰PNG  IHDR0¢€á‚0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfåIDAT•c` àç`àH3ØÐTL``=c!æÎ3D Œ¸øŒ˜ d€BÞR‰ë ÿX~‹oàa`àOœÄtd%/Pâ3ÓŽMÌ¿ð10Ø1Lcgø˜ÂÀ+ÀÀüÕåÃnæ ·€ ?0€%>uå%n%.3>``Ý–`øÎÀ¡ôhÔ' Ø[|¸ÀvÈÌtÜgx'ø‹u—óÖV}·) Òðp`þ ÀÀ4*%pϱ}pî8K,V° bÇÐ;š5!idfIEND®B`‚libDAI-0.2.7/doc/html/globals_defs.html0000644000263000017630000000517211433220721016503 0ustar jorismkyb libDAI: Class Members
 

Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1sequentialVariableElimination.html0000644000263000017630000002001411433220721024224 0ustar jorismkyb libDAI: dai::sequentialVariableElimination Class Reference

dai::sequentialVariableElimination Class Reference

Helper object for dai::ClusterGraph::VarElim(). More...

#include <dai/clustergraph.h>

List of all members.

Public Member Functions

 sequentialVariableElimination (const std::vector< Var > s)
 Construct from vector of variables.
size_t operator() (const ClusterGraph &cl, const std::set< size_t > &)
 Returns next variable in sequence.

Private Attributes

std::vector< Var > seq
 The variable elimination sequence.
size_t i
 Counter.

Detailed Description

Helper object for dai::ClusterGraph::VarElim().

Chooses the next variable to eliminate by picking them sequentially from a given vector of variables.

Constructor & Destructor Documentation

dai::sequentialVariableElimination::sequentialVariableElimination ( const std::vector< Var >  s  )  [inline]

Construct from vector of variables.

Member Function Documentation

size_t dai::sequentialVariableElimination::operator() ( const ClusterGraph &  cl,
const std::set< size_t > &   
)

Returns next variable in sequence.

Member Data Documentation

std::vector<Var> dai::sequentialVariableElimination::seq [private]

The variable elimination sequence.

size_t dai::sequentialVariableElimination::i [private]

Counter.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x69.html0000644000263000017630000002704711433220721017675 0ustar jorismkyb libDAI: Class Members - Functions
 

- i -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/inline_dotgraph_4.dot.png0000644000263000017630000000113311433220721020046 0ustar jorismkyb‰PNG  IHDR­9¶v¶%PLTEþÿÿ???ßßß___¿¿¿ÓÓÓÿÿÿ.ÆNtRNS@æØfëIDATX…í–MNÄ0 F9@‚#pÀ‚9œ Å»‹‘s[ú“6Ÿý9mM%Í2/é«›:Nïò.í|W:JC[ˆ´ÈèÕ44Tl # ^MåJ¬“b1Þ;ÏýSgö…Þ A•‘ D!Ì̤óÂï2e ….ƒ†ôÞ þ.|]¤󖈾ê­1"$Ÿ3™b|žG yyç-÷y¨7ŒÈëi&eðGæ™…¼×Vï÷ºWê—ÁËÉy/÷ÞûxM¼ïOΫc²i]ß!^³¾âI°¾uT1š´c>ì•¿{í·åj ­¡õú°X½T<Éõjc£zÖ®­ ž›æ(Õ_uõw`›Ñ9ƒíÉþ¼{ÕXú_JÞ4™,ÉK^±¤“ŠŸÃYl ¡—öÂôÒü­ƒÝ±ä"ÉÇ‹Å#7ôj@üú yí+Œ¼‘áåQpB¤íÕ˜tâJÄý§/”À+ ¢R3lþSˆ½íNÝÃÒî4½B%´òül-ïâ:«ÏZ^ç–—ß0’Fºñ‡¦÷®¤ñ 椥pÉËÈÈŠíÌØ»áÄÄ£.¨±—ë…#ƒË\ìµE8&‚…>ZÈ›Lë¡C8’ˆ^§ì£Ò”øHº‰×œ9·ôîïá=¼‡÷ðþCïçEDÈ»K;ÿ×l; `IEND®B`‚libDAI-0.2.7/doc/html/util_8h-source.html0000644000263000017630000005652011433220721016734 0ustar jorismkyb libDAI: include/dai/util.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x63.html0000644000263000017630000003716511433220721016656 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- c -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_87.png0000644000263000017630000000064011433220721015153 0ustar jorismkyb‰PNG  IHDRK¬)Ÿí0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIDAT(‘c` ¥ŠÎbv@ˆ2 ("+›€`6"˜b¿ò ‘T17 Øš ‚µ£ Día@’`àRPãy€˜é¨ رöÖHª '¥‚ŽæB¸Ü ¥ À÷ ¡ŒGá«Â5s¨oB R\Ê8ÿð© e]3gN±‹¾#” Z~*cüÀÀêä&V ‘aW¨g`HrIq®3,àaàVÝ`¬üÉ^eÐñ\ÐžÄ ÀêËq Ä 1Uà2àOÝìÀ¼!‚3(ĸÍèïد õ×Ú¸ .5 00ƒ—#`1¿3ƒØ÷i‰07äeºcƒƒž!Ía*(`cL†±9àQÏbÀ@¡Ê4µAÙÑäIEND®B`‚libDAI-0.2.7/doc/html/dag_8h-source.html0000644000263000017630000012427211433220721016512 0ustar jorismkyb libDAI: include/dai/dag.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_1.png0000644000263000017630000000120011433220721015046 0ustar jorismkyb‰PNG  IHDR{ÄÚÕ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfþIDAT(‘­’OhÓPÇ¿ù»®Y×Ì (¬ÐK·K»“½Hs(;ù§ ÈaE¶Á`A„›MØ<ˆ-ƒávÙ¢^{½IØI< „é„É<ˆ;¤…yò÷’4 ež\àýò{¿ï÷ó^^Þ8¿‡‹NÔû¢Ò£njFÊ¢NAÐÏ¢E=«Ã€ì­2®Õõd½¸tž…RÔÙ$â…¨§áÅb=çh`0¸Šé2‚Šç@Š9¹±8ÂSÀ@Ï°Àç3LJf ™¸ìãw4C)ý2`#¶¼³àÔžÎ6EÒÒ{(é®ÜÚÝnü¸Ý¾k“t£PáHxøƒV.pˆæ¸æ}|Å›X×ñô ðy|\MœRí©à;ÁêIÍÁ÷†×Js(êØÃM­‚ßT#«¼¹õj8(m ªÒ.5ªý”ºøEûñ‰2ë4µ /’§%FvÿLãšAøª9q+Ä/¸hÅÙ1läò2o¼$üµX‡Û¿ŽµƒOB–ôúø6I»É4oùg߶®>.'Žÿ/ |[[¨W­ýq›³±8¾ê;<¼ï“ù¶üÑhê$M¯C2p)¸Hï èì’ý¶Ý£ñ¬Û<²—ú’«2‰rúÞa'¬°+ê´D‰æ¥VOà '¤+QQœº‡°EÅÂöÓÄ|.Í ôá¿Ÿ¿ŠjQ÷6ÜpIEND®B`‚libDAI-0.2.7/doc/html/treeep_8h-source.html0000644000263000017630000012312211433220721017234 0ustar jorismkyb libDAI: include/dai/treeep.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_71.png0000644000263000017630000000067311433220721015152 0ustar jorismkyb‰PNG  IHDRD]"Ä`0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf9IDAT(‘c` TÁÁÀÀhl„"ÄX€ªdSþbT1WsàG³ŒD€Mf60bàR2ü ˜ÁVƒ(.o©Äõ…,¿Å7ð€„f3°éxmdP‰²sRl Ÿ™>pl*`þÀø…¤äC¿˜;Cƒ=§Bhóæ¯.v30`¸RÂø‘AžÁè¢h Í‹ÁJ€b y@%7JœY?€äxJ–1°)L)aøÎÀ¡ôhÑ' [¾ó40XÆTÂ2á#;Óv [df:î3¼üÅ:èøâN¦/™Î@%¬WÛœ´ Þó¦ ŒÐÐZ$ÀÈÀt%.`ÀöH4¹žA ’}Õ†b¸˜X (Ž0£‘1C Õ4@ØEím´IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1BBP_1_1Properties-members.html0000644000263000017630000000744011433220721023212 0ustar jorismkyb libDAI: Member List

dai::BBP::Properties Member List

This is the complete list of members for dai::BBP::Properties, including all inherited members.

DAI_ENUM(UpdateType, SEQ_FIX, SEQ_MAX, SEQ_BP_REV, SEQ_BP_FWD, PAR)dai::BBP::Properties
dampingdai::BBP::Properties
get() const dai::BBP::Properties
maxiterdai::BBP::Properties
set(const PropertySet &opts)dai::BBP::Properties
toldai::BBP::Properties
toString() const dai::BBP::Properties
updatesdai::BBP::Properties
verbosedai::BBP::Properties

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1multifor.html0000644000263000017630000003732311433220721020067 0ustar jorismkyb libDAI: dai::multifor Class Reference

dai::multifor Class Reference

multifor makes it easy to perform a dynamic number of nested for loops. More...

#include <dai/index.h>

List of all members.

Public Member Functions

 multifor ()
 Default constructor.
 multifor (const std::vector< size_t > &d)
 Initialize from vector of index ranges.
 operator size_t () const
 Returns linear index (i.e., the index in the Cartesian product space).
size_t operator[] (size_t k) const
 Returns k 'th index.
multifor & operator++ ()
 Increments the current indices (prefix).
void operator++ (int)
 Increments the current indices (postfix).
multifor & reset ()
 Resets the state.
bool valid () const
 Returns true if the current indices are valid.

Private Attributes

std::vector< size_t > _ranges
 Stores the number of possible values of all indices.
std::vector< size_t > _indices
 Stores the current values of all indices.
long _linear_index
 Stores the current linear index.

Detailed Description

multifor makes it easy to perform a dynamic number of nested for loops.

An example of the usage is as follows: 

  std::vector<size_t> ranges;
  ranges.push_back( 3 );
  ranges.push_back( 4 );
  ranges.push_back( 5 );
  for( multifor s(ranges); s.valid(); ++s )
      cout << "linear index: " << (size_t)s << " corresponds to indices " << s[2] << ", " << s[1] << ", " << s[0] << endl;
which would be equivalent to: 
  size_t s = 0;
  for( size_t s2 = 0; s2 < 5; s2++ )
      for( size_t s1 = 0; s1 < 4; s1++ )
          for( size_t s0 = 0; s0 < 3; s++, s0++ )
              cout << "linear index: " << (size_t)s << " corresponds to indices " << s2 << ", " << s1 << ", " << s0 << endl;
Examples:

example_permute.cpp.

Constructor & Destructor Documentation

dai::multifor::multifor (  )  [inline]

Default constructor.

dai::multifor::multifor ( const std::vector< size_t > &  d  )  [inline]

Initialize from vector of index ranges.

Member Function Documentation

dai::multifor::operator size_t (  )  const [inline]

Returns linear index (i.e., the index in the Cartesian product space).

size_t dai::multifor::operator[] ( size_t  k  )  const [inline]

Returns k 'th index.

multifor& dai::multifor::operator++ (  )  [inline]

Increments the current indices (prefix).

void dai::multifor::operator++ ( int   )  [inline]

Increments the current indices (postfix).

multifor& dai::multifor::reset (  )  [inline]

Resets the state.

bool dai::multifor::valid (  )  const [inline]

Returns true if the current indices are valid.

Member Data Documentation

std::vector<size_t> dai::multifor::_ranges [private]

Stores the number of possible values of all indices.

std::vector<size_t> dai::multifor::_indices [private]

Stores the current values of all indices.

long dai::multifor::_linear_index [private]

Stores the current linear index.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__inv0-members.html0000644000263000017630000000356611433220721021576 0ustar jorismkyb libDAI: Member List

dai::fo_inv0< T > Member List

This is the complete list of members for dai::fo_inv0< T >, including all inherited members.

operator()(const T &x) const dai::fo_inv0< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Gibbs.html0000644000263000017630000017242211433220721017254 0ustar jorismkyb libDAI: dai::Gibbs Class Reference

dai::Gibbs Class Reference

Approximate inference algorithm "Gibbs sampling". More...

#include <dai/gibbs.h>

Inheritance diagram for dai::Gibbs:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 Gibbs ()
 Default constructor.
 Gibbs (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual Gibbs * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
std::vector< std::size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability.
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for Gibbs
void randomizeState ()
 Draw the current joint state of all variables from a uniform random distribution.
std::vector< size_t > & state ()
 Return reference to current state of all variables.
const std::vector< size_t > & state () const
 Return constant reference to current state of all variables.

Public Attributes

struct dai::Gibbs::Properties props

Static Public Attributes

static const char * Name = "GIBBS"
 Name of this inference algorithm.

Private Types

typedef std::vector< size_t > _count_t
 Type used to store the counts of various states.
typedef std::vector< size_t > _state_t
 Type used to store the joint state of all variables.

Private Member Functions

void construct ()
 Helper function for constructors.
void updateCounts ()
 Updates all counts (_sample_count, _var_counts, _factor_counts) based on current state.
Prob getVarDist (size_t i)
 Calculate conditional distribution of variable i, given the current state.
void resampleVar (size_t i)
 Draw state of variable i randomly from its conditional distribution and update the current state.
size_t getFactorEntry (size_t I)
 Calculates linear index into factor I corresponding to the current state.
size_t getFactorEntryDiff (size_t I, size_t i)
 Calculates the differences between linear indices into factor I corresponding with a state change of variable i.

Private Attributes

size_t _sample_count
 Number of samples counted so far (excluding burn-in periods).
std::vector< _count_t > _var_counts
 State counts for each variable.
std::vector< _count_t > _factor_counts
 State counts for each factor.
size_t _iters
 Number of iterations done (including burn-in periods).
_state_t _state
 Current joint state of all variables.
_state_t _max_state
 Joint state with maximum probability seen so far.
Real _max_score
 Highest score so far.

Related Functions

(Note that these are not member functions.)

std::vector< size_t > getGibbsState (const FactorGraph &fg, size_t maxiter)
 Runs Gibbs sampling for maxiter iterations (of which burnin for burn-in) on FactorGraph fg, and returns the resulting state.

Classes

struct  Properties
 Parameters for Gibbs. More...

Detailed Description

Approximate inference algorithm "Gibbs sampling".

Author:
Frederik Eaton
Examples:

example_sprinkler_gibbs.cpp.

Member Typedef Documentation

typedef std::vector<size_t> dai::Gibbs::_count_t [private]

Type used to store the counts of various states.

typedef std::vector<size_t> dai::Gibbs::_state_t [private]

Type used to store the joint state of all variables.

Constructor & Destructor Documentation

dai::Gibbs::Gibbs (  )  [inline]

Default constructor.

dai::Gibbs::Gibbs ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties

Member Function Documentation

virtual Gibbs* dai::Gibbs::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

virtual std::string dai::Gibbs::identify (  )  const [inline, virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::Gibbs::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::Gibbs::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Factor dai::Gibbs::beliefV ( size_t  i  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::Gibbs::beliefF ( size_t  I  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

vector< Factor > dai::Gibbs::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::Gibbs::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

std::vector<std::size_t> dai::Gibbs::findMaximum (  )  const [inline, virtual]

Calculates the joint state of all variables that has maximum probability.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::Gibbs::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::Gibbs::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::Gibbs::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

Examples:
example_sprinkler_gibbs.cpp.

virtual Real dai::Gibbs::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::Gibbs::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::Gibbs::setMaxIter ( size_t   )  [inline, virtual]

Sets maximum number of iterations (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::Gibbs::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::Gibbs::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::Gibbs::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

void dai::Gibbs::randomizeState (  ) 

Draw the current joint state of all variables from a uniform random distribution.

std::vector<size_t>& dai::Gibbs::state (  )  [inline]

Return reference to current state of all variables.

Examples:
example_sprinkler_gibbs.cpp.

const std::vector<size_t>& dai::Gibbs::state (  )  const [inline]

Return constant reference to current state of all variables.

void dai::Gibbs::construct (  )  [private]

Helper function for constructors.

void dai::Gibbs::updateCounts (  )  [private]

Updates all counts (_sample_count, _var_counts, _factor_counts) based on current state.

Prob dai::Gibbs::getVarDist ( size_t  i  )  [private]

Calculate conditional distribution of variable i, given the current state.

void dai::Gibbs::resampleVar ( size_t  i  )  [private]

Draw state of variable i randomly from its conditional distribution and update the current state.

size_t dai::Gibbs::getFactorEntry ( size_t  I  )  [private]

Calculates linear index into factor I corresponding to the current state.

size_t dai::Gibbs::getFactorEntryDiff ( size_t  I,
size_t  i 
) [private]

Calculates the differences between linear indices into factor I corresponding with a state change of variable i.

Friends And Related Function Documentation

std::vector< size_t > getGibbsState ( const FactorGraph &  fg,
size_t  maxiter 
) [related]

Runs Gibbs sampling for maxiter iterations (of which burnin for burn-in) on FactorGraph fg, and returns the resulting state.

Member Data Documentation

size_t dai::Gibbs::_sample_count [private]

Number of samples counted so far (excluding burn-in periods).

std::vector<_count_t> dai::Gibbs::_var_counts [private]

State counts for each variable.

std::vector<_count_t> dai::Gibbs::_factor_counts [private]

State counts for each factor.

size_t dai::Gibbs::_iters [private]

Number of iterations done (including burn-in periods).

_state_t dai::Gibbs::_state [private]

Current joint state of all variables.

_state_t dai::Gibbs::_max_state [private]

Joint state with maximum probability seen so far.

Real dai::Gibbs::_max_score [private]

Highest score so far.

const char * dai::Gibbs::Name = "GIBBS" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1ClusterGraph.html0000644000263000017630000011225711433220721020631 0ustar jorismkyb libDAI: dai::ClusterGraph Class Reference

dai::ClusterGraph Class Reference

A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges. More...

#include <dai/clustergraph.h>

List of all members.

Public Member Functions

Constructors and destructors
 ClusterGraph ()
 Default constructor.
 ClusterGraph (const std::vector< VarSet > &cls)
 Construct from vector of VarSet 's.
 ClusterGraph (const FactorGraph &fg, bool onlyMaximal)
 Construct from a factor graph.
Queries
const BipartiteGraph & bipGraph () const
 Returns a constant reference to the graph structure.
size_t nrVars () const
 Returns number of variables.
const std::vector< Var > & vars () const
 Returns a constant reference to the variables.
const Var & var (size_t i) const
 Returns a constant reference to the i'th variable.
size_t nrClusters () const
 Returns number of clusters.
const std::vector< VarSet > & clusters () const
 Returns a constant reference to the clusters.
const VarSet & cluster (size_t I) const
 Returns a constant reference to the I'th cluster.
size_t findVar (const Var &n) const
 Returns the index of variable n.
size_t findCluster (const VarSet &cl) const
 Returns the index of a cluster cl.
VarSet Delta (size_t i) const
 Returns union of clusters that contain the i 'th variable.
VarSet delta (size_t i) const
 Returns union of clusters that contain the i 'th (except this variable itself).
bool adj (size_t i1, size_t i2) const
 Returns true if variables with indices i1 and i2 are adjacent, i.e., both contained in the same cluster.
bool isMaximal (size_t I) const
 Returns true if cluster I is not contained in a larger cluster.
Operations
size_t insert (const VarSet &cl)
 Inserts a cluster (if it does not already exist) and creates new variables, if necessary.
ClusterGraph & eraseNonMaximal ()
 Erases all clusters that are not maximal.
ClusterGraph & eraseSubsuming (size_t i)
 Erases all clusters that contain the i 'th variable.
VarSet elimVar (size_t i)
 Eliminates variable with index i, without deleting the variable itself.
Variable elimination
template<class EliminationChoice>
ClusterGraph VarElim (EliminationChoice f, size_t maxStates=0) const
 Performs Variable Elimination, keeping track of the interactions that are created along the way.

Private Attributes

BipartiteGraph _G
 Stores the neighborhood structure.
std::vector< Var > _vars
 Stores the variables corresponding to the nodes.
std::vector< VarSet > _clusters
 Stores the clusters corresponding to the hyperedges.

Friends

Input/Ouput
std::ostream & operator<< (std::ostream &os, const ClusterGraph &cl)
 Writes a ClusterGraph to an output stream.

Detailed Description

A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges.

It is implemented as a bipartite graph with variable (Var) nodes and cluster (VarSet) nodes. One may think of a ClusterGraph as a FactorGraph without the actual factor values.

Todo:
Remove the _vars and _clusters variables and use only the graph and a contextual factor graph.

Constructor & Destructor Documentation

dai::ClusterGraph::ClusterGraph (  )  [inline]

Default constructor.

dai::ClusterGraph::ClusterGraph ( const std::vector< VarSet > &  cls  ) 

Construct from vector of VarSet 's.

dai::ClusterGraph::ClusterGraph ( const FactorGraph &  fg,
bool  onlyMaximal 
)

Construct from a factor graph.

Creates cluster graph which has factors in fg as clusters if onlyMaximal == false, and only the maximal factors in fg if onlyMaximal == true.

Member Function Documentation

const BipartiteGraph& dai::ClusterGraph::bipGraph (  )  const [inline]

Returns a constant reference to the graph structure.

size_t dai::ClusterGraph::nrVars (  )  const [inline]

Returns number of variables.

const std::vector<Var>& dai::ClusterGraph::vars (  )  const [inline]

Returns a constant reference to the variables.

const Var& dai::ClusterGraph::var ( size_t  i  )  const [inline]

Returns a constant reference to the i'th variable.

size_t dai::ClusterGraph::nrClusters (  )  const [inline]

Returns number of clusters.

const std::vector<VarSet>& dai::ClusterGraph::clusters (  )  const [inline]

Returns a constant reference to the clusters.

const VarSet& dai::ClusterGraph::cluster ( size_t  I  )  const [inline]

Returns a constant reference to the I'th cluster.

size_t dai::ClusterGraph::findVar ( const Var &  n  )  const [inline]

Returns the index of variable n.

size_t dai::ClusterGraph::findCluster ( const VarSet &  cl  )  const [inline]

Returns the index of a cluster cl.

VarSet dai::ClusterGraph::Delta ( size_t  i  )  const [inline]

Returns union of clusters that contain the i 'th variable.

VarSet dai::ClusterGraph::delta ( size_t  i  )  const [inline]

Returns union of clusters that contain the i 'th (except this variable itself).

bool dai::ClusterGraph::adj ( size_t  i1,
size_t  i2 
) const [inline]

Returns true if variables with indices i1 and i2 are adjacent, i.e., both contained in the same cluster.

bool dai::ClusterGraph::isMaximal ( size_t  I  )  const [inline]

Returns true if cluster I is not contained in a larger cluster.

size_t dai::ClusterGraph::insert ( const VarSet &  cl  )  [inline]

Inserts a cluster (if it does not already exist) and creates new variables, if necessary.

Note:
This function could be better optimized if the index of one variable in cl would be known. If one could assume _vars to be ordered, a binary search could be used instead of a linear one.

ClusterGraph& dai::ClusterGraph::eraseNonMaximal (  )  [inline]

Erases all clusters that are not maximal.

ClusterGraph& dai::ClusterGraph::eraseSubsuming ( size_t  i  )  [inline]

Erases all clusters that contain the i 'th variable.

VarSet dai::ClusterGraph::elimVar ( size_t  i  )  [inline]

Eliminates variable with index i, without deleting the variable itself.

Note:
This function can be better optimized

template<class EliminationChoice>
ClusterGraph dai::ClusterGraph::VarElim ( EliminationChoice  f,
size_t  maxStates = 0 
) const [inline]

Performs Variable Elimination, keeping track of the interactions that are created along the way.

Template Parameters:
EliminationChoice should support "size_t operator()( const ClusterGraph &cl, const std::set<size_t> &remainingVars )"
Parameters:
f function object which returns the next variable index to eliminate; for example, a dai::greedyVariableElimination object.
maxStates maximum total number of states of all clusters in the output cluster graph (0 means no limit).
Exceptions:
OUT_OF_MEMORY if total number of states becomes larger than maxStates
Returns:
A set of elimination "cliques".

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const ClusterGraph &  cl 
) [friend]

Writes a ClusterGraph to an output stream.

Member Data Documentation

BipartiteGraph dai::ClusterGraph::_G [private]

Stores the neighborhood structure.

std::vector<Var> dai::ClusterGraph::_vars [private]

Stores the variables corresponding to the nodes.

std::vector<VarSet> dai::ClusterGraph::_clusters [private]

Stores the clusters corresponding to the hyperedges.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1BipartiteGraph-members.html0000644000263000017630000002712311433220721022560 0ustar jorismkyb libDAI: Member List

dai::BipartiteGraph Member List

This is the complete list of members for dai::BipartiteGraph, including all inherited members.

_nb1dai::BipartiteGraph [private]
_nb2dai::BipartiteGraph [private]
addEdge(size_t n1, size_t n2, bool check=true)dai::BipartiteGraph
addNode1()dai::BipartiteGraph [inline]
addNode1(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::BipartiteGraph [inline]
addNode2()dai::BipartiteGraph [inline]
addNode2(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::BipartiteGraph [inline]
BipartiteGraph()dai::BipartiteGraph [inline]
BipartiteGraph(size_t nr1, size_t nr2)dai::BipartiteGraph [inline]
BipartiteGraph(size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::BipartiteGraph [inline]
checkConsistency() const dai::BipartiteGraph
construct(size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::BipartiteGraph [inline]
delta1(size_t n1, bool include=false) const dai::BipartiteGraph
delta2(size_t n2, bool include=false) const dai::BipartiteGraph
eraseEdge(size_t n1, size_t n2)dai::BipartiteGraph
eraseNode1(size_t n1)dai::BipartiteGraph
eraseNode2(size_t n2)dai::BipartiteGraph
findNb1(size_t n1, size_t n2)dai::BipartiteGraph [inline]
findNb2(size_t n1, size_t n2)dai::BipartiteGraph [inline]
hasEdge(size_t n1, size_t n2) const dai::BipartiteGraph [inline]
isConnected() const dai::BipartiteGraph
isTree() const dai::BipartiteGraph
nb1(size_t i1, size_t _i2) const dai::BipartiteGraph [inline]
nb1(size_t i1, size_t _i2)dai::BipartiteGraph [inline]
nb1(size_t i1) const dai::BipartiteGraph [inline]
nb1(size_t i1)dai::BipartiteGraph [inline]
nb1Set(size_t n1) const dai::BipartiteGraph
nb2(size_t i2, size_t _i1) const dai::BipartiteGraph [inline]
nb2(size_t i2, size_t _i1)dai::BipartiteGraph [inline]
nb2(size_t i2) const dai::BipartiteGraph [inline]
nb2(size_t i2)dai::BipartiteGraph [inline]
nb2Set(size_t n2) const dai::BipartiteGraph
nrEdges() const dai::BipartiteGraph [inline]
nrNodes1() const dai::BipartiteGraph [inline]
nrNodes2() const dai::BipartiteGraph [inline]
operator<<(std::ostream &os, const BipartiteGraph &g)dai::BipartiteGraph [friend]
operator==(const BipartiteGraph &x) const dai::BipartiteGraph [inline]
printDot(std::ostream &os) const dai::BipartiteGraph

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/evidence_8h.html0000644000263000017630000000473211433220721016241 0ustar jorismkyb libDAI: include/dai/evidence.h File Reference

include/dai/evidence.h File Reference

Defines class Evidence, which stores multiple observations of joint states of variables. More...

#include <istream>
#include <dai/daialg.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Evidence
 Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables. More...

Detailed Description

Defines class Evidence, which stores multiple observations of joint states of variables.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_rela.html0000644000263000017630000000737111433220721017075 0ustar jorismkyb libDAI: Class Members - Related Functions
 

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x65.html0000644000263000017630000000732211433220721017703 0ustar jorismkyb libDAI: Class Members - Variables
 

- e -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_104.png0000644000263000017630000000235711433220721015230 0ustar jorismkyb‰PNG  IHDR$ o8Ý0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfmIDATX…í˜]hUÇÿ»3»3»Ù‘ ®4ÔZL«˜Ù,$&jé‡FmY#é‡ Nª * ûÐVú $j‹}rìǨÐTjBÁ¥¶>Ñ€õ|2ÑñÉ-ˆ"®çÜMfw2³YºXD̽sçÜ{ÏïÞ{fÎÙþ¢]o„tQÉtÿƒ±å»‡ª¿ÛöÛÕŸWtw[¢ÚDÌÆQÑÿ²mûû? ‘€þ•æS@ªºôj &%û†Æÿ â¹5™ è\ǿаÿ÷ùÃd°ùvìvTÌt0…3þ6§mp¼MÜR†d:0‡ëS®#Ûö)†™Â"pØ­Z L´,ªåõº/ôÝ´ûÉÃ(zB7Ô³~0¢Jñ Ë!œm&&\J5ëí.rA'k“õæf†‰±)ÕXfðUQí¼Ÿüwb;æÚ…Iå¸LÒ¬º]º8ƒÆuHZ–› HW´~¨ºÐ #!2\KäBþ"F"Ï6Á¤·M ;ØÿÙy ™÷µAæ83[SοȪ.=tš&:5ÂìžíÞ¶eeÖ !·ÿy`¶~¾el}Ì#X OèCP°ô Ì#I3XÒUá(i {Œ"ú·¯y„PìÕšaž-'­ÄótE-§4Èu/×é:Z †h4ó-0&Î}/ð»–Ã4¬Ö“ȧi]íÀ(Å$¿uB&éú2R![)³i“G¯Éú'Aœ©eNç]Y&a¼iÆaíC³x`ÿqš{¹É'‰<ÙJ¢;nYdZ¸Cçïë¼' tm*ç˜3Ñü\0wâ8*TÍ­­aÿS ‘bm[rÝÿïI½;Þ4ø8اzŽëÃìÀßðžÄôÍ:§Ìs˜Ç¼ËÔ!›­a6àΙ´A7SÐú'jÅ-Dó|ÃÇq°¶kbÒ s†k=âì €©‰"úf´ÑÅæ®~ߙҢ2‘Ôkvæ—¤çàêþ[CSâÃKõuƒÊ&‘§p`¿c.WK˜£ÎûUÌÔ×æz¶Ý™ÆqÙõQó©-³²Çh«/°¼×O³VñÀìsxcùvanòŽhS>¸JW5½†ïðöÝPÕúå×k5é+#¥RQ~«tÞ£›žGÑRiÏ—JÌôþ—ŸÜ(Ê#Ñ×<äQº^£+2Ùi˜u± ¼ll î¶Ëº,b—åwE¦MÑVù GƒÇ´-á¼HHÍYÁýÒPC¹$"$uÇ: ³ñDœ‘Ì+…à©ïÁ•Êpâ§Á$ŽÃ`±Ë¶(^(4$Þ9…‹¹,r©=›Ö9h zBË5ÊBÔàX–6aô031Kþ‰ó§)¬×q/ý2îðÿr'sÚ]záiÿ^Ê¡9ìg?bŸFLÇt>&™ö[š $‡ô—­ N¿"RÊgV-iLë4L¨0ëdñ1ö`ÅâÛ…i_”ýà\ŸSɈuYZËߘ‚T{ΉÏIEND®B`‚libDAI-0.2.7/doc/html/form_126.png0000644000263000017630000000304211433220721015224 0ustar jorismkyb‰PNG  IHDR[$Õâ„~0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf IDATX…í˜mˆTUÇÿ÷uîÌÎî\Ål#Ñ+Z¡^XTv ÷‚KèR1«&BFW±‰ j6Ŭˆ¦reµMš†–´/9.‚з„²>¶)}n4 Ä U 1Âéyî¹ëܹ{Ｘùmÿæž—çœó;ïÏ`ZÓjYm•#¤c•Ûu­¬öWn9òYåjœ¹dUïT®rý?Þ;bPrÅår&Öbáðz(í…q*R‰-²Ò DÎPyãßV¹¤˜ô×nx5g­PsÅP¡ÞH\Éö†HýˆÊÿLjW±êÀ}¾•Jo»#¾w[XÏ? ýˆn2®š•‡FãuË;›Å•ŒbE<±\ðï…2¤J ’ïš g‘q“è€Ý`ˆÄÕ¨¢1ÐN°›Àí VÒ±´h›<Îé½YÍÌ¢Ùˆ¾È¸X¨!7áJÒˆj·fe¾l׬Ž‡©~ðÚšÔ%£b£óDe¾5æ`öw´ÓR}n°`w¦d˶´g&8»?¨‡K`Š©oËšCw“¤§vlÚr `³Øúýi ´Q':¿6»«[맱€úíAÑ'aMàÒ ^&ºëànz|ëF”lx0&ãªO¼b`”‡ªXËX½8 m‡ˆÊØ‹®oƒåM”«Ü ìõy·‚µï‡²ËìÖk²h§¡W=ˆ]ñ¸Êb7cõ#úø ãê½ø—CÆK°W ú&„ iœ÷?ã:ø"`ªÞ Öþp=šãÊ“£›Á*|…‹7ñ ÆCF”&•‘r9lÒ2$\b—M7‹¥NÀöb°à íñ¬ñœÀ¬0.Îe¨ü¨[÷Æ5Jë÷­t?-±ÇÊx joa-æ¤\·¯Œ4%åqürµx»¨‹úM íž5Nz›® \yÌ•Ë~Ô©‹;®”ÓËyF„T/M.kC4›Iö¤ã´Ã—>ù‰ý@ÑkÑ>kUu«V®xS’ö¬iUð‰Òî9jïÞ†°¡Öô?Œ+•Å]Z‹½æ Ld˜<›¤¬t)oœ;fb‘È©*QsÃ.,€¦D÷6/ßMá ¥½R˱¥\wB»ùGsýwS”¯—|R©L¡o÷IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1MaximizationStep-members.html0000644000263000017630000001134111433220721023153 0ustar jorismkyb libDAI: Member List

dai::MaximizationStep Member List

This is the complete list of members for dai::MaximizationStep, including all inherited members.

_paramsdai::MaximizationStep [private]
addExpectations(InfAlg &alg)dai::MaximizationStep
begin()dai::MaximizationStep [inline]
begin() const dai::MaximizationStep [inline]
const_iterator typedefdai::MaximizationStep
end()dai::MaximizationStep [inline]
end() const dai::MaximizationStep [inline]
iterator typedefdai::MaximizationStep
MaximizationStep()dai::MaximizationStep [inline]
MaximizationStep(std::vector< SharedParameters > &maximizations)dai::MaximizationStep [inline]
MaximizationStep(std::istream &is, const FactorGraph &fg_varlookup)dai::MaximizationStep
maximize(FactorGraph &fg)dai::MaximizationStep

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/hierarchy.html0000644000263000017630000002102311433220721016026 0ustar jorismkyb libDAI: Hierarchical Index

Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/alldai_8h-source.html0000644000263000017630000004147711433220721017212 0ustar jorismkyb libDAI: include/dai/alldai.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x66.html0000644000263000017630000002002411433220721016643 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- f -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Permute.html0000644000263000017630000003747711433220721017661 0ustar jorismkyb libDAI: dai::Permute Class Reference

dai::Permute Class Reference

Tool for calculating permutations of linear indices of multi-dimensional arrays. More...

#include <dai/index.h>

List of all members.

Public Member Functions

 Permute ()
 Default constructor.
 Permute (const std::vector< size_t > &rs, const std::vector< size_t > &sigma)
 Construct from vector of index ranges and permutation.
 Permute (const std::vector< Var > &vars, bool reverse=false)
 Construct from vector of variables.
size_t convertLinearIndex (size_t li) const
 Calculates a permuted linear index.
const std::vector< size_t > & sigma () const
 Returns constant reference to the permutation.
std::vector< size_t > & sigma ()
 Returns reference to the permutation.
const std::vector< size_t > & ranges ()
 Returns constant reference to the dimensionality vector.
size_t operator[] (size_t i) const
 Returns the result of applying the permutation on i.
Permute inverse () const
 Returns the inverse permutation.

Private Attributes

std::vector< size_t > _ranges
 Stores the number of possible values of all indices.
std::vector< size_t > _sigma
 Stores the permutation.

Detailed Description

Tool for calculating permutations of linear indices of multi-dimensional arrays.

Note:
This is mainly useful for converting indices into multi-dimensional arrays corresponding to joint states of variables to and from the canonical ordering used in libDAI.
Examples:

example_permute.cpp.

Constructor & Destructor Documentation

dai::Permute::Permute (  )  [inline]

Default constructor.

dai::Permute::Permute ( const std::vector< size_t > &  rs,
const std::vector< size_t > &  sigma 
) [inline]

Construct from vector of index ranges and permutation.

dai::Permute::Permute ( const std::vector< Var > &  vars,
bool  reverse = false 
) [inline]

Construct from vector of variables.

The implied permutation maps the index of each variable in vars according to the canonical ordering (i.e., sorted ascendingly according to their label) to the index it has in vars. If reverse == true, reverses the indexing in vars first.

Member Function Documentation

size_t dai::Permute::convertLinearIndex ( size_t  li  )  const [inline]

Calculates a permuted linear index.

Converts the linear index li to a vector index, permutes its components, and converts it back to a linear index.

Examples:
example_permute.cpp.

const std::vector<size_t>& dai::Permute::sigma (  )  const [inline]

Returns constant reference to the permutation.

Examples:
example_permute.cpp.

std::vector<size_t>& dai::Permute::sigma (  )  [inline]

Returns reference to the permutation.

const std::vector<size_t>& dai::Permute::ranges (  )  [inline]

Returns constant reference to the dimensionality vector.

size_t dai::Permute::operator[] ( size_t  i  )  const [inline]

Returns the result of applying the permutation on i.

Permute dai::Permute::inverse (  )  const [inline]

Returns the inverse permutation.

Member Data Documentation

std::vector<size_t> dai::Permute::_ranges [private]

Stores the number of possible values of all indices.

std::vector<size_t> dai::Permute::_sigma [private]

Stores the permutation.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_33.png0000644000263000017630000000100211433220721015133 0ustar jorismkyb‰PNG  IHDR‹Ô–‘L0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf€IDAT8c` !&^)£”¡lÌ`l€"ÅÓˆ[S;š±PÚ÷+ãk{†ðHCä(†13…Ö 8̽ ¼Pó?³ š4†ùûC¯¡›Â|ÁÁcõ“åœ GSkÏÀ¹€ùˆ…a Ç#TwÃñŸ¦¸/ $y0Äj Ëï$T ÆèO``ZÈÀÀV 9sæÌ©@nÜÆ0xýÐ@6†s„ÉTtÿ$•ìñÃÀ±€Í@ §CŒaX1UáØC-@:‡ WØ2°LÐEñ$H˜&0Ìg`/Z3QPPP,Éòcƒ ØŽn0’U`ŠaàV(Ç6ë0Þ_Ì«ôä$Ér/½Ï?œx @Hß$rjÆb†KpS8Ï/F1ð; »äcX2G’‰020|Añ&²1¬èÆcâg$c " ¡¨Æ hEœÅ`$îÂ*\¦ɤT$U‚õ‚IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1BP_1_1Properties-members.html0000644000263000017630000000772511433220721023116 0ustar jorismkyb libDAI: Member List

dai::BP::Properties Member List

This is the complete list of members for dai::BP::Properties, including all inherited members.

DAI_ENUM(UpdateType, SEQFIX, SEQRND, SEQMAX, PARALL)dai::BP::Properties
DAI_ENUM(InfType, SUMPROD, MAXPROD)dai::BP::Properties
dampingdai::BP::Properties
inferencedai::BP::Properties
logdomaindai::BP::Properties
maxiterdai::BP::Properties
maxtimedai::BP::Properties
toldai::BP::Properties
updatesdai::BP::Properties
verbosedai::BP::Properties

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1MR_1_1Properties.html0000644000263000017630000002414311433220721021474 0ustar jorismkyb libDAI: dai::MR::Properties Struct Reference

dai::MR::Properties Struct Reference

Parameters for MR. More...

#include <dai/mr.h>

List of all members.

Public Member Functions

 DAI_ENUM (UpdateType, FULL, LINEAR)
 Enumeration of different types of update equations.
 DAI_ENUM (InitType, RESPPROP, CLAMPING, EXACT)
 Enumeration of different ways of initializing the cavity correlations.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
Real tol
 Tolerance for convergence test.
UpdateType updates
 Update equations.
InitType inits
 How to initialize the cavity correlations.

Detailed Description

Parameters for MR.

Member Function Documentation

dai::MR::Properties::DAI_ENUM ( UpdateType  ,
FULL  ,
LINEAR   
)

Enumeration of different types of update equations.

The possible update equations are:

  • FULL full updates, slow but accurate
  • LINEAR linearized updates, faster but less accurate

dai::MR::Properties::DAI_ENUM ( InitType  ,
RESPPROP  ,
CLAMPING  ,
EXACT   
)

Enumeration of different ways of initializing the cavity correlations.

The possible cavity initializations are:

  • RESPPROP using response propagation ("linear response")
  • CLAMPING using clamping and BP
  • EXACT using JunctionTree

Member Data Documentation

size_t dai::MR::Properties::verbose

Verbosity (amount of output sent to stderr).

Real dai::MR::Properties::tol

Tolerance for convergence test.

UpdateType dai::MR::Properties::updates

Update equations.

InitType dai::MR::Properties::inits

How to initialize the cavity correlations.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x71.html0000644000263000017630000001052111433220721016640 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- q -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x62.html0000644000263000017630000002603611433220721016650 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- b -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_116.png0000644000263000017630000000051511433220721015225 0ustar jorismkyb‰PNG  IHDR#sëÑ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfËIDAT•c`À1…&0(H Šp(0$° ñ20 0\@²fpyÀpÎíèèh°bÀp.$¿Qø¢5Ÿ’*Þ ®¼ \¨BÂl ìÈB b ¨B¨—Èm@ª,Ä·H°00è)vˆÐ¬• Œ @6ÂVv/†C Á | )0±i Ül˜'4„.²a0chw`h€ ]`kH ‰+ˆ*@+fd¹÷`> ÂøHWý%0uËûëIEND®B`‚libDAI-0.2.7/doc/html/functions_vars_0x7a.html0000644000263000017630000000775111433220721017766 0ustar jorismkyb libDAI: Class Members - Variables
 

- z -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x77.html0000644000263000017630000001110411433220721016644 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- w -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/bibliography.html0000644000263000017630000001573411433220721016537 0ustar jorismkyb libDAI: Bibliography

Bibliography

EaG09 F. Eaton and Z. Ghahramani (2009): "Choosing a Variable to Clamp", Proceedings of the Twelfth International Conference on Artificial Intelligence and Statistics (AISTATS 2009) 5:145-152, http://jmlr.csail.mit.edu/proceedings/papers/v5/eaton09a/eaton09a.pdf

EMK06 G. Elidan and I. McGraw and D. Koller (2006): "Residual Belief Propagation: Informed Scheduling for Asynchronous Message Passing", Proceedings of the 22nd Annual Conference on Uncertainty in Artificial Intelligence (UAI-06), http://uai.sis.pitt.edu/papers/06/UAI2006_0091.pdf

HAK03 T. Heskes and C. A. Albers and H. J. Kappen (2003): "Approximate Inference and Constrained Optimization", Proceedings of the 19th Annual Conference on Uncertainty in Artificial Intelligence (UAI-03) pp. 313-320, http://www.snn.ru.nl/reports/Heskes.uai2003.ps.gz

KFL01 F. R. Kschischang and B. J. Frey and H.-A. Loeliger (2001): "Factor Graphs and the Sum-Product Algorithm", IEEE Transactions on Information Theory 47(2):498-519, http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=910572

KoF09 D. Koller and N. Friedman (2009): Probabilistic Graphical Models - Principles and Techniques, The MIT Press, Cambridge, Massachusetts, London, England.

Min05 T. Minka (2005): "Divergence measures and message passing", MicroSoft Research Technical Report MSR-TR-2005-173, http://research.microsoft.com/en-us/um/people/minka/papers/message-passing/minka-divergence.pdf

MiQ04 T. Minka and Y. Qi (2004): "Tree-structured Approximations by Expectation Propagation", Advances in Neural Information Processing Systems (NIPS) 16, http://books.nips.cc/papers/files/nips16/NIPS2003_AA25.pdf

MoK07 J. M. Mooij and H. J. Kappen (2007): "Loop Corrections for Approximate Inference on Factor Graphs", Journal of Machine Learning Research 8:1113-1143, http://www.jmlr.org/papers/volume8/mooij07a/mooij07a.pdf

MoK07b J. M. Mooij and H. J. Kappen (2007): "Sufficient Conditions for Convergence of the Sum-Product Algorithm", IEEE Transactions on Information Theory 53(12):4422-4437, http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=4385778

Moo08 J. M. Mooij (2008): "Understanding and Improving Belief Propagation", Ph.D. Thesis Radboud University Nijmegen http://webdoc.ubn.ru.nl/mono/m/mooij_j/undeanimb.pdf

MoR05 A. Montanari and T. Rizzo (2005): "How to Compute Loop Corrections to the Bethe Approximation", Journal of Statistical Mechanics: Theory and Experiment 2005(10)-P10011, http://stacks.iop.org/1742-5468/2005/P10011

StW99 A. Steger and N. C. Wormald (1999): "Generating Random Regular Graphs Quickly", Combinatorics, Probability and Computing Vol 8, Issue 4, pp. 377-396, http://www.math.uwaterloo.ca/~nwormald/papers/randgen.pdf

WiH03 W. Wiegerinck and T. Heskes (2003): "Fractional Belief Propagation", Advances in Neural Information Processing Systems (NIPS) 15, pp. 438-445, http://books.nips.cc/papers/files/nips15/LT16.pdf

WJW03 M. J. Wainwright, T. S. Jaakkola and A. S. Willsky (2003): "Tree-reweighted belief propagation algorithms and approximate ML estimation by pseudo-moment matching", 9th Workshop on Artificial Intelligence and Statistics, http://www.eecs.berkeley.edu/~wainwrig/Papers/WJW_AIStat03.pdf

YFW05 J. S. Yedidia and W. T. Freeman and Y. Weiss (2005): "Constructing Free-Energy Approximations and Generalized Belief Propagation Algorithms", IEEE Transactions on Information Theory 51(7):2282-2312, http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=1459044

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_30.png0000644000263000017630000000030411433220721015134 0ustar jorismkyb‰PNG  IHDR RiÊo0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfBIDAT™c`À,)æ`†¿Íc#€Ÿ!,dËÀ0 D+t03\ÒÌŽ±1>‰”°9°N‚šÀ:f–¡I ÃòH¦IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1UEdge.html0000644000263000017630000002717711433220721017225 0ustar jorismkyb libDAI: dai::UEdge Class Reference

dai::UEdge Class Reference

Represents an undirected edge. More...

#include <dai/weightedgraph.h>

List of all members.

Public Member Functions

 UEdge ()
 Default constructor.
 UEdge (size_t m1, size_t m2)
 Constructs an undirected edge between m1 and m2.
 UEdge (const DEdge &e)
 Construct from DEdge.
bool operator== (const UEdge &x)
 Tests for inequality (disregarding the ordering of the nodes).
bool operator< (const UEdge &x) const
 Smaller-than operator.

Public Attributes

size_t first
 First node index.
size_t second
 Second node index.

Friends

std::ostream & operator<< (std::ostream &os, const UEdge &e)
 Writes an undirected edge to an output stream.

Detailed Description

Represents an undirected edge.

Constructor & Destructor Documentation

dai::UEdge::UEdge (  )  [inline]

Default constructor.

dai::UEdge::UEdge ( size_t  m1,
size_t  m2 
) [inline]

Constructs an undirected edge between m1 and m2.

dai::UEdge::UEdge ( const DEdge &  e  )  [inline]

Construct from DEdge.

Member Function Documentation

bool dai::UEdge::operator== ( const UEdge &  x  )  [inline]

Tests for inequality (disregarding the ordering of the nodes).

bool dai::UEdge::operator< ( const UEdge &  x  )  const [inline]

Smaller-than operator.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const UEdge &  e 
) [friend]

Writes an undirected edge to an output stream.

Member Data Documentation

size_t dai::UEdge::first

First node index.

size_t dai::UEdge::second

Second node index.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/smallset_8h-source.html0000644000263000017630000012566011433220721017605 0ustar jorismkyb libDAI: include/dai/smallset.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1RootedTree.html0000644000263000017630000001225011433220721020272 0ustar jorismkyb libDAI: dai::RootedTree Class Reference

dai::RootedTree Class Reference

Represents a rooted tree, implemented as a vector of directed edges. More...

#include <dai/weightedgraph.h>

Inherits std::vector< T >.

List of all members.

Public Member Functions

 RootedTree ()
 Default constructor.
 RootedTree (const GraphEL &T, size_t Root)
 Constructs a rooted tree from a tree and a root.

Detailed Description

Represents a rooted tree, implemented as a vector of directed edges.

By convention, the edges are stored such that they point away from the root and such that edges nearer to the root come before edges farther away from the root.

Constructor & Destructor Documentation

dai::RootedTree::RootedTree (  )  [inline]

Default constructor.

dai::RootedTree::RootedTree ( const GraphEL &  T,
size_t  Root 
)

Constructs a rooted tree from a tree and a root.

Precondition:
T has no cycles and contains node Root

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1State-members.html0000644000263000017630000001376711433220721020744 0ustar jorismkyb libDAI: Member List

dai::State Member List

This is the complete list of members for dai::State, including all inherited members.

begin() const dai::State [inline]
const_iterator typedefdai::State
end() const dai::State [inline]
get() const dai::State [inline]
insert(InputIterator b, InputIterator e)dai::State [inline]
operator const std::map< Var, size_t > &() const dai::State [inline]
operator size_t() const dai::State [inline]
operator()(const Var &v) const dai::State [inline]
operator()(const VarSet &vs) const dai::State [inline]
operator++()dai::State [inline]
operator++(int)dai::State [inline]
reset()dai::State [inline]
statedai::State [private]
State()dai::State [inline]
State(const VarSet &vs, size_t linearState=0)dai::State [inline]
State(const std::map< Var, size_t > &s)dai::State [inline]
statesdai::State [private]
states_type typedefdai::State [private]
valid() const dai::State [inline]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_24.png0000644000263000017630000000067611433220721015153 0ustar jorismkyb‰PNG  IHDRK¬)Ÿí0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfý;ÄÐd!îv¯Üñn…ZÙ*ÏÄ0oµ2ÏÊö͇˜ýë9„´¢-IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1SmallSet.png0000644000263000017630000000103511433220721017561 0ustar jorismkyb‰PNG  IHDRrˆÉú¢1PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf³IDATX…í—Mrà …Í&kžn½A;Óót•û¡H p[¤´“¸Ã߇„°=¼£¶øeÌÜk‘®ÝЦòN«®Œæ”nyôºì´êZ÷% ž libDAI: Change Log

Change Log 

libDAI-0.2.7 (2010-08-19)
-------------------------

* Removed interfaces deprecated in 0.2.6.
* Fixed a bug in JTree::findMaximum() (reported by zhengyun84 and Dhruv Batra):
  if one or more variables had a MAP belief with more than one maximum, an 
  incorrect MAP state could result.


libDAI-0.2.6 (2010-08-05)
-------------------------

New features:
* Added decimation algorithm DecMAP for MAP inference (decmap.h/cpp).
* Added source code for one of the winning solvers of the 
  UAI 2010 Approximate Inference Challenge (examples/uai2010-aie-solver.cpp).
* Added support for reading files in the UAI Approximate Inference Challenge
  format, supporting both the 2006/2008 evidence file format and the 2010
  evidence file format (io.h/cpp).

Miscellaneous improvements:
* 'maxtime' property added to various algorithms (BP, Gibbs, HAK, TreeEP)
  for setting an upper limit on execution time.
* 'maxmem' property added to JTree for setting an upper limit on memory usage.
* SmallSet:
  - Added SmallSet::erase( const T& t ).
* VarSet:
  - nrStates() now returns a long double instead of a size_t.
* Permute:
  - Added ranges() accessor.
  - Added inverse() method.
  - Added optional reverse argument to Permute( const std::vector<Var>& ) constructor.
* Factor:
  - Added createFactorDelta( const VarSet& vs, size_t state ).
* ClusterGraph:
  - Added ClusterGraph(const FactorGraph& fg, bool onlyMaximal) constructor.
  - Added findCluster( const VarSet& cl ).
  - Added elimVar( size_t i ).
  - Added 'maxStates' argument to VarElim( EliminationChoice f, size_t maxStates=0 ).
* FactorGraph:
  - Added isMaximal(size_t).
  - Added maximalFactor(size_t).
  - Added FactorGraph::logScore( const std::vector<size_t>& statevec ).
* Gibbs:
  - Added 'restart' property.
  - Added Gibbs::findMaximum() for MAP inference.
* HAK:
  - Optimized region graph construction for HAK/GBP with clusters=BETHE.
* examples/examples_imagesegmentation.cpp:
  - [Peter Rockett] Improved Makefiles for image segmentation example.
  - Added build flag to specify the CImg version.
* util.h/cpp:
  - Added fromString<>( const std::string& x ).

Interface changes (the old interface is marked obsolete and will be removed in the next release):
* Added InfAlg::setMaxIter(size_t) for setting the maximum number of iterations.
* Deprecated Graph::Neighbor, BipartiteGraph::Neighbor and DAG::Neighbor
  and replaced them by a globally defined Neighbor structure
* Deprecated Graph::Neighbors, BipartiteGraph::Neighbors and DAG::Neighbors
  and replaced them by a globally defined Neighbors type
* Deprecated Graph::Edge, BipartiteGraph::Edge and DAG::Edge
  and replaced them by a globally defined Edge type
* Renamed 'iters' property of Gibbs algorithm into 'maxiter'.
* ClusterGraph::findVar( const Var& n ) no longer throws an exception if the
  variable is not found.
* Deprecated 'void tokenizeString( const string&, vector<string>&, const string& )'
  and replaced it with an improved version
  'vector<string> tokenizeString( const string&, bool, const string& )'
* Removed interfaces deprecated in 0.2.5.

Bug fixes:
* Fixed a problem with isnan() on FreeBSD; it is now in the dai namespace.
* Workaround for older g++ compilers (e.g. version 4.0.0 on Darwin 9.8.0)
  which have problems when comparing const_reverse_iterator with
  reverse_iterator.
* [Matt Dunham] Fixed a bug in Factors2mx in src/matlab/matlab.cpp
  (segfault if factors depending on 0 variables were passed to MatLab)


libDAI-0.2.5 (2010-05-09)
-------------------------

New features:
* Added unit tests for var, smallset, varset, graph, dag, bipgraph,
  weightedgraph, enum, util, exceptions, properties, index, prob, 
  factor, factorgraph, clustergraph, regiongraph, daialg, alldai
* [Ofer Meshi] Added a script for converting from FastInf to libDAI format
* Added utils/uai2fg, a utility to convert the UAI inference competition file
  formats to the libDAI factor graph file format
* Added dag.h/cpp, an implementation of Directed Acyclic Graphs
* Added examples/example_imagesegmentation

Miscellaneous improvements:
* TRWBP:
  - Added initialization of TRWBP weights by sampling spanning trees
* MF:
  - Added an "init" option that allows to initialize randomly
  - Added an "updates" option that allows to choose between standard
    mean field and "hard-spin" mean field
* MR:
  - rewrote response propagation implementation with help of BBP
  - now uses GraphAL to represent the Markov graph
  - miscellaneous smaller cleanups
* TreeEP:
  - Now also supports disconnected factor graphs
* JTree:
  - Now also supports disconnected factor graphs
* ExactInf:
  - Added findMaximum()
* RegionGraph:
  - Added error checking code
  - Changed the way a RegionGraph is streamed to an std::ostream.
* ClusterGraph:
  - Added nrVars() method
  - Added var( size_t ) method
  - Added cluster( size_t ) method
* FactorGraph:
  - clamped() now contains a delta factor for the clamped variable
  - Added MarkovGraph()
* TFactor:
  - Added takeAbs()
  - Added takeExp()
  - Added takeLog( bool )
  - Added operator-() const
  - Added sumAbs() const
  - Added operator==( const TFactor<T> &y )
  - Added get(size_t), set(size_t,T)
* TProb:
  - Added operator==( const TProb<T> &q )
  - accumulate() now also applies op2 to init
  - operator/= (T x) now yields 0 when dividing by 0
  - Added resize(size_t)
  - Added get(size_t) and set(size_t,T) 
  - Changed format of TProb<T> when streamed to an ostream
* multifor:
  - Added reset()
* PropertySet:
  - Added size()
  - Added clear()
  - Added erase()
* util.h/cpp:
  - Added std::string toString( const T& x )
* weightedgraph.h/cpp:
  - Added option to MaxSpanningTree and MinSpanningTree for
    choosing between Prim's algorithm and Kruskal's algorithm
  - Better error checking in RootedTree constructor
  - Added GraphEL::GraphEL( const GraphAL& G ) constructor
* BipartiteGraph:
  - Added hasEdge()
  - Added findNb1()
  - Added findNb2()
  - Added nb1Set()
  - Added nb2Set()
  - Added operator==( const BipartiteGraph& )
  - Added BipartiteGraph( size_t nr1, size_t nr2 ) constructor
  - Added operator<<( std::ostream&, const BipartiteGraph& )
* GraphAL:
  - Added hasEdge(size_t,size_t)
  - Added nbSet(size_t)
  - Added operator==( const GraphAL& )
  - Added operator<<( std::ostream&, const GraphAL& )
* SmallSet:
  - Added insert( const T& t ) method
* Improved regression test
* Made all "verbose" properties optional
* utils/createfg now has a new factor type ('ISINGUNIFORM') and the old
  'ISING' factor type has been renamed to 'ISINGGAUSS'
* tests/testdai option "marginals" now has five possible values: NONE
  outputs no marginals, VAR only variable marginals, FAC only factor
  marginals, VARFAC both types of marginals, and ALL outputs all
  marginals calculated by the algorithm.
* Compressed Makefile

Interface changes (the old interface is marked obsolete and will be removed in the next release):
* Removed RandomDRegularGraph(), please use createGraphRegular() instead
* TreeEP:
  - Changed construct( const RootedTree& ) into
    construct( const FactorGraph&, const RootedTree& )
* JTree:
  - Changed construct( const std::vector<VarSet>&, bool ) into
    construct( const FactorGraph&, const std::vector<VarSet>&, bool )
  - Changed GenerateJT( const std::vector<VarSet> & )
    into GenerateJT( const FactorGraph &, const std::vector<VarSet> & )
* RegionGraph: 
  - Made (previously public) members G, ORs, IRs and fac2OR protected and
    added DAG() accessor which returns a reference to the region graph DAG 
    structure (currently implemented as a BipartiteGraph).
  - Renamed calcCountingNumbers() into calcCVMCountingNumbers() and made it 
    protected, because exposing it to the world serves no purpose.
  - Removed partial constructor RegionGraph( const FactorGraph& fg )
  - Made RecomputeORs(), RecomputeORs( const VarSet& ) and RecomputeOR( size_t ) 
    protected and renamed them by changing the "Recompute" into "recompute", 
    because exposing them to the world serves no purpose.
* ClusterGraph:
  - Made (previously public) members G, vars and clusters private and added 
    bipGraph(), vars() and clusters() methods which offer read-only access 
    to these members.
  - Deprecated toVector()
  - Renamed size() into nrClusters()
* FactorGraph:
  - Renamed Cliques() into maximalFactorDomains() and made it faster
  - findVars( const VarSet& ) now returns a SmallSet<size_t>
    and its argument now has a const-qualifier (which fixes a small bug).
  - Made (previously public) member G private and added the 
    bipGraph() method, which offers read-only access to it.
  - Deprecated the iterator interface:
    o FactorGraph::iterator typedef
    o FactorGraph::const_iterator typedef
    o FactorGraph::begin() members
    o FactorGraph::end() members
  - Deprecated factor(size_t) which offered write access to a factor
    because using this functionality in the descendant RegionGraph is dangerous,
    as the outer regions are not automatically recomputed.
* TFactor:
  - Renamed states() into nrStates()
  - Added get(size_t) and set(size_t,T) operators; 
    get() is equivalent to "operator[](size_t) const" and set() should
    be used instead of the non-const operator[], which has been deprecated
* TProb:
  - Deprecated TProb( TIterator begin, TIterator end, size_t sizeHint=0 )
    constructor: the sizeHint argument no longer defaults to 0
  - Deprecated accumulate( T init, binOp op1, unOp op2 );
    instead, accumulateSum( T init, unOp op ) and
    accumulateMax( T init, unOp op, bool minimize ) should be used.
  - Deprecated TProb::NormType and TProb::DistType;
    ProbNormType and ProbDistType should be used instead.
  - Fixed bug by renaming operator<=() to operator<()
  - Added get(size_t) and set(size_t,T) operators; 
    get() is equivalent to "operator[](size_t) const" and set() should
    be used instead of the non-const operator[], which has been deprecated
* PropertySet:
  - Renamed Set() -> set()
  - Renamed Get() -> get()
  - Renamed GetAs<T>() -> getAs<T>()
  - Renamed ConvertTo<T>() -> convertTo<T>()
* util.h/cpp:
  - Removed max( const std::vector<Real> &v )
* weightedgraph.h/cpp:
  - Renamed MaxSpanningTreePrims into MaxSpanningTree
  - Renamed MinSpanningTreePrims into MinSpanningTree
  - The vertices in DEdge and UEdge are now named "first" and "second"
    for compatibility with a std::pair<size_t,size_t>
* BipartiteGraph:
  - delta1() and delta2() now return a SmallSet<size_t> instead of a vector<size_t>
* SmallSet:
  - The sizeHint argument of the iterator constructor
     SmallSet::SmallSet( TIterator begin, TIterator end, size_t sizeHint=0 )
    no longer has a default value in order to avoid confusion with the
     SmallSet::SmallSet( const T &t1, const T &t2 )
    constructor.

Bug fixes:
* [Stefano Pellegrini] Fixed bug in JTree::findMaximum()
* [Stefano Pellegrini] Fixed bug in BP[logdomain=1,inference=MAXPROD]
* Fixed some bugs in the MatLab interface build system
* Fixed a bug in utils/fginfo.cpp
* Fixed a bug in JTree::findMaximum() and simplified the code
* Fixed bug in BBPCostFunction::operator=() which prevented the desired 
  assignment from happening
* RegionGraph::WriteToFile( const char* ), RegionGraph::ReadFromFile( const char * )
  and RegionGraph::printDot( std::ostream& ) incorrectly called their respective
  FactorGraph ancestor methods; this has been corrected by letting them throw a
  NOT_IMPLEMENTED exception.
* Fixed bug in FactorGraph::clone()
* Fixed bug in min( const TFactor<T> &, const TFactor<T> & )
* Fixed bug in max( const TFactor<T> &, const TFactor<T> & )
* Fixed bug by renaming TProb<T>::operator<=() to TProb<T>::operator<()
* Fixed bug in PropertySet::setAsString<T>()
* Fixed a bug in rnd_seed()
* BipartiteGraph:
  - Fixed bug in eraseNode1()
  - Fixed bug in eraseNode2()
  - Fixed bug in isTree()
* GraphAL:
  - Fixed bug in nrEdges()
  - Fixed bug in addEdge()
  - Fixed bug in isTree()
  - Fixed bug in eraseNode()
  - Fixed bug in printDot()
* Fixed bug in createGraphGrid3D()
* Fixed bug in createGraphRegular()


libDAI-0.2.4 (2010-02-11)
-------------------------

New features:
* Implemented Tree-Reweighted BP
* [Frederik Eaton] Implemented Fractional Belief Propagation

Miscellaneous improvements:
* Improved documentation
* [Frederik Eaton] Added constructors for BBPCostFunction
* [Frederik Eaton] Added accessor/mutator for the elements of a SmallSet<>
* [Frederik Eaton] Added unary minus to TProb<>
* [Frederik Eaton] Added Hellinger distance to TProb<>::DistType
* [Frederik Eaton] Two small patches for src/jtree.cpp and utils/createfg.cpp
* tests/testdai option "marginals" now has three possible values: NONE
  outputs no marginals, VAR only variable marginals, and ALL outputs all
  marginals calculated by the algorithm.
* Strengthened convergence criteria of various algorithms
* Added GraphAL, an adjacency list implementation for graphs,
  similar to (but simpler than) BipartiteGraph
* Added some functionality to create various standard factors
  (the functions whose names start with "createFactor")
* Added examples example_sprinkler_gibbs and example_sprinkler_em
* Implemented various heuristics for choosing a variable elimination sequence 
  in JTree
* Added BETHE method for GBP/HAK cluster choice
* Made alias support official part of the library

Build system:
* Moved platform independent build options into Makefile.ALL
* Windows platform now needs Boost 1.37 or higher

Code cleanup:
* Cleaned up utils/createfg and tests/testdai
* Cleanup of some duplicate code in BP, FBP, TRWBP

Interface changes (the old interface is marked obsolete and will be removed in the next release):
* Removed obsolete/deprecated stuff
* Renamed Graph into GraphEL (for Graph, implemented as Edge List)
* Renamed some functions of BipartiteGraph:
    add1() -> addNode1()
    erase1() -> eraseNode1()
    nr1() -> nrNodes1()
    add2() -> addNode2()
    erase2() -> eraseNode2()
    nr2() -> nrNodes2()
* Renamed some functions in ClusterGraph:
    ClusterGraph::eliminationCost() -> ::eliminationCost_MinFill() 
    ClusterGraph::VarElim() -> ClusterGraph::VarElim( sequentialVariableElimination( ElimSeq ) ) 
    ClusterGraph::VarElim_MinFill() -> ClusterGraph::VarElim( greedyVariableElimination( eliminationCost_MinFill ) )
* Changed interface of one RegionGraph constructor
* Renamed "Clamped BP" into "Conditioned BP"

Bug fixes:
* Fixed regression in scripts/regenerate-properties (now all errors are 
  gathered before throwing the exception, as used to be the case)
* Fixed FTBFS errors on MACOSX (thanks to Sebastian Riedel for reporting this bug)
* [Alexander Schwing] Fixed error in BP that occured with damping
  and using log-domain updates
* Fixed bug in HAK for trivial region graphs (with only one outer region
  and no inner regions), reported by Alejandro Lage.
* Fixed long-standing bug in TreeEP (now, within-loop propagation optimization works)


libDAI-0.2.3 (2009-11-16)
-------------------------

New features:
* Complete doxygen documentation (although more detailed documentation still
  has to be written)
* [Charles Vaske] Added parameter learning for conditional probabilities by 
  Expectation Maximization
* [Patrick Pletscher] Added SWIG wrapper code for experimental python and 
  octave interfaces
* Added Max-Product functionality to JTree
* [Frederik Eaton] Added Back-Belief-Propagation
* [Frederik Eaton] Added approximate inference method "Clamped Belief Propagation"
* [Frederik Eaton] Added approximate inference method "Gibbs sampling"

Code cleanup:
* Updated copyright headers
* Cleaned up error handling by introducing the DAI_THROWE macro
* Introduced DAI_DEBASSERT macro to abbreviate a common pattern
* Replaced the standard assert() macro by DAI_ASSERT, which throws a
  dai::Exception and is even active if NDEBUG is defined
* Removed all the virtual default constructors *::create(), as they are not used
* [Frederik Eaton] Removed unnecessary copy constructors and assignment operators
* [Frederik Eaton] Change cout to cerr in warnings and error messages

Miscellaneous improvements:
* BipartiteGraph:
  - Added eraseEdge( size_t n1, size_t n2 )
  - [Frederik Eaton] Improved documentation of Neighbor
* TProb<T>:
  - Added divided_by(const TProb<T>&) const
  - Added constructor TProb<T>( const std::vector<S> &v )
  - Added size_t draw(), which draws a random index
  - [Frederik Eaton] Added setUniform()
  - [Frederik Eaton] Added sumAbs()
  - [Frederik Eaton] Added argmax()
  - [Giuseppe Passino] Added begin(), end()
* TFactor<T>:
  - [Giuseppe Passino] Added begin(), end()
  - [Charles Vaske] Added TFactor( const std::vector<Var> &vars, const std::vector<T> &p ),
    which reorders variables to canonical ordering before storing the table
  - Added constructor TFactor<T>( const VarSet &vars, const std::vector<S> &v )
  - Extended functionality of TFactor<T>::operators +,-,+=,-= to handle different VarSets
  - Added TFactor<T>::maxMarginal (similar to marginal but with max instead of sum)
* State:
  - [Giuseppe Passino] Added prefix ++ operator
* Permute:
  - [Charles Vaske] Added constructor in Permute for canonical variable ordering
* FactorGraph:
  - [Frederik Eaton] Added clampVar()
  - [Frederik Eaton] Added clampFactor()
  - [Giuseppe Passino] Added begin(), end()
* PropertySet:
  - Added keys(), for getting all keys
  - [Frederik Eaton] Added default constructor
  - [Frederik Eaton] Added constructor from string
* InfAlg:
  - Added setProperties(), getProperties() and printProperties()
  - [Frederik Eaton] Added beliefV(), beliefF()
* ExactInf:
  - Added calcMarginal(const VarSet &)
* HAK:
  - Added "init" parameter to allow for random initialization
* BP:
  - [Giuseppe Passino] Added findMaximum(), which can be used after running
    max-product BP to construct a global state with maximum probability
* JTree:
  - Added findMaximum(), which can be used after running
    max-product JTree to construct a global state with maximum probability
* MatLab interface:
  - MEX file dai now also returns variable and factor beliefs
  - [Sebastian Nowozin] MEX file dai now also optionally returns the MAP state
    (only for BP and JTree)
* README is now created automatically from doxygen documentation
* [Frederik Eaton] Added script for automatically generating properties code (used by CBP and BBP)
* [Frederik Eaton] Added newInfAlgFromString to alldai.h/cpp
* [Frederik Eaton] Added some utility macros (DAI_PV, DAI_DMSG, DAI_IFVERB)
  and functions (concat(),rnd()) to util.h
* Changed output stream operator<< for Var and VarSet
* [Frederik Eaton] Improved parsing code in tests/testdai to allow recursive
  alias substitutions
* [Frederik Eaton] Added useful aliases to aliases.conf
* [Giuseppe Passino] Optimised maximum-residual BP by using a reversed ordered
  set instead of the linear search (which can yield enormous speedups - a
  factor 500 has been measured on a binary Ising grid with 128x128 variables!)
* Added debug assertions to Var which check for inconsistent dimensions of
  variables with the same labels
* toc() now returns POSIX system time with maximum accuracy of microseconds
* Exception objects now remember their error code
* Examples:
  - Moved example.cpp to examples/
  - Added examples/example_bipgraph.cpp
  - Added examples/example_varset.cpp
  - Added examples/example_sprinkler.cpp
  - Added examples/example_permute.cpp
  - Added python and octave ports for examples/example_sprinkler.cpp

Build system:
* Improved Makefile:
  - Merged Makefile.win and Makefile.shared into Makefile
  - Macros DAI_VERSION and DAI_DATE have been introduced,
    in order to store this information in a central place
  - Introduced CCNODEBUGFLAGS in Makefile
  - Switched Makefile.win to GNU Make syntax
  - [Frederik Eaton] Added TAGS, lib targets to Makefile
* Compatibility:
  - [Peter Gober] libDAI can now be built on Cygwin
  - [Dan Preston] libDAI can now be built on Mac OS X
  - Changed regression test so that it also works under Windows

Interface changes (the old interface is marked obsolete and will be removed in the next release):
* Var:
  - Variable labels are now nonnegative (of type size_t)
* VarSet:
  - Replaced calcState() by non-member calcLinearState()
  - Replaced calcStates() by non-member calcState()
* Permute:
  - Renamed convert_linear_index into convertLinearIndex
* TProb<>:
  - Replaced log0() by log(true)
  - Replaced takeLog0() by takeLog(true)
  - Removed hasNonPositives()
  - Renamed minVal() to min()
  - Renamed maxVal() to max()
  - Renamed totalSum() to sum()
* TFactor<>:
  - Replaced log0() by TFactor<T>::log(true)
  - Removed divided_by, use operator/ instead
  - Removed divide, use operator/= instead
  - Removed partSum(const VarSet&), use marginal(const VarSet&,false) instead
  - Renamed minVal() to min()
  - Renamed maxVal() to max()
  - Renamed totalSum() to sum()
* FactorGraph:
  - Changed clamp and clamp interfaces (the variable to be
    clamped is now indicated by its index, not as a Var)
* RegionGraph:
  - Renamed Check_Counting_Numbers into checkCountingNumbers
  - Renamed Calc_Counting_Numbers into calcCountingNumbers
* Miscellaneous:
  - Renamed Treewidth(const FactorGraph &) into boundTreewidth(const FactorGraph &)
  - Replaced UEdgeVec by Graph
  - Replaced DEdgeVec by new RootedTree class
  - Moved functionality of GrowRootedTree() into constructor of RootedTree
  - Merged calcPairBeliefsNew() into calcPairBeliefs()
  - Removed calcMarginal2ndO()
  - Renamed smallSet<T> to SmallSet<T>
  - Removed class Diffs
  - [Frederik Eaton] Added backwards compatibility layer for edge interface to
    BipartiteGraph and FactorGraph (which will be obsoleted soon)

Bug fixes:
* Fixed reversal of min and max in 
  TFactor<T> min( const TFactor<T> &, const TFactor<T> & )
  TFactor<T> max( const TFactor<T> &, const TFactor<T> & )
* [Sebastian Nowozin] Fixed memory leak in MEX file dai
* [Frederik Eaton] In PropertySet::getStringAs(), check for typeid(ValueType) 
  before typeid(std::string) (this fixes a strange bug for empty string property)
* Added work-around for bug in Boost Graph Library
* Fixed bug in MaxSpanningTree (it wrongly assumed that the tree was not empty).
* Fixed bug in calcMarginal and calcPairBeliefs where states with zero probability 
  mass were clamped, leading to NaNs or assertion errors (thanks to Dan Preston 
  for reporting this)


libDAI-0.2.2 (2008-09-30)
-------------------------

New features:
* Approximate inference methods now report the number of iterations needed.
* Added damping to various algorithms to improve convergence properties.
* Added more features to utils/createfg for creating factor graphs.
* Added ExactInf class for brute force exact inference.
* [Giuseppe Pasino] Added "logdomain" property to BP, a boolean that controls
  whether calculations are done in the log-domain or in the linear domain;
  doing calculations in the log-domain may help if the numerical range
  of a double is too small.
* [Claudio Lima] Added Max-Product functionality to BP.
* Improved documentation.

Improved architecture:
* Added Exceptions framework.
* Pervasive change of BipartiteGraph implementation (based on an idea by
  Giuseppe Passino). BipartiteGraph no longer stores the node properties
  (former _V1 and _V2), nor does it store a dense adjacency matrix anymore,
  nor an edge list. Instead, it stores the graph structure as lists of
  neighboring nodes. This yields a significant memory/speed improvement for
  large factor graphs, and is more elegant as well. Iterating over neighbors is
  made easy by using boost::foreach.
* Added conditional compilation of inference methods.
* VarSet is now implemented using a std::vector<Var> instead of a
  std::set<Var>, which yields a significant speed improvement. Furthermore,
  the implementation has been generalized, resulting in the small_set<T> class
  which can be used to represent sets of small cardinality; VarSet is the
  specialization with T = Var.
* Improved ClusterGraph implementation, yielding significant speedups
  for the JunctionTree algorithm on large factorgraphs.

Code cleanup:
* Moved everything into namespace "dai".
* Renamed DEBUG to DAI_DEBUG to avoid conflicts.
* Replaced ENUM2,ENUM3,ENUM4,ENUM5,ENUM6 by single DAI_ENUM macro.
* Removed utils/remove_short_loops and matlab/remove_short_loops.
* Replaced sub_nb class in mr.h by boost::dynamic_bitset.
* Improved index.h:
  - Renamed Index -> IndexFor
  - Added some .reserve()'s to IndexFor methods which yields a
    25% speedup of testregression
  - Replaced multind by Permute
  - Added MultiFor
  - Added State
* New funcstionality of factor.h.
* Moved Properties and MaxDiff frameworks from InfAlg to each individual
  inference algorithm, because the Properties framework was not as
  convenient as I hoped, and not every inference algorithm needs a maxdiff
  variable. Also, replaced some FactorGraph functionality in InfAlg by a
  function that returns the FactorGraph. The result is cleaner (less
  entangled) code.
* Removed x2x.
* Replaced Complex with real numbers (negative potentials are just too rare
  to warrant the additional "complexity" :)).

Miscellaneous improvements:
* Now compiles also with MS Visual C++ (thanks to Jiuxiang Hu) and with
  GCC under Cygwin.
* Contributions by Peter Gober:
  - Renamed variable _N in mr.* for compatibility with g++ under Cygwin.
* Misc contributions by Giuseppe Passino:
  - removed "using namespace std;" from header files - bad practice;
  - moved header files in include/dai and sources in src;
  - changed #ifndefs to GNU style;
  - added extra warning checks (-W -Wextra) and fixed resulting warnings;
  - dai::TProb:
    o removed copy constructor and assignment operators (redundant);
    o implementation of some methods via STL algorithms;
    o added methods takeExp, takeLog, takeLog0 for transformation in-place;
    o explicit constructor (prevents implicit conversion from size_t to TProb);
    o added operator+,+=,-,-=, with argument T (for calculations in log-scale);
* Misc contributions by Christian Wojek:
  - New FactorGraph constructor that constructs from given ranges of factors
    and variables;
  - Optimization of FactorGraph constructors using tr1::unordered_map.
* FactorGraph constructors no longer check for short loops (huge speed
  increase for large factor graphs), nor for negative entries. Also, the
  normtype is now Prob::NORMPROB by default.
* Improved MaxSpanningTreePrims algorithm (uses boost::graph).

Interface changes:
* VarSet::
  - VarSet::stateSpace() -> nrStates(const VarSet &)
  - VarSet( const std::set<Var> ) -> VarSet( begin, end, sizeHint=0 )
  - VarSet( const std::vector<Var> ) -> VarSet( begin, end, sizeHint=0 )
  - removed bool operator||
  - operator&&(const VarSet&) -> intersects(const VarSet&)
  - operator&&(const Var&) -> contains(const Var&)
* FactorGraph::
  - delta(const Var &) -> delta(size_t)
  - Delta(const Var &) -> Delta(size_t)
  - makeCavity(const Var &) -> makeCavity(size_t)
  - vars() -> vars
  - factors() -> factors
  - removed MakeFactorCavity(size_t)
  - removed ExactMarginal(const VarSet &)
  - removed ExactlogZ()
  - removed updatedFactor(size_t)
  - removed _normtype and NormType()
  - removed hasShortLoops(...) and removeShortLoops(...)
  - WriteToDotFile(const char *filename) -> printDot( std::ostream& os )
  - undoProb(size_t) -> restoreFactor(size_t)
  - saveProb(size_t) -> backupFactor(size_t)
  - undoProbs(const VarSet &) -> restoreFactors(const VarSet &)
  - saveProbs(const VarSet &) -> backupFactors(const VarSet &)
  - ReadFromFile(const char*) returns void (throws on error)
  - WriteToFile(const char*) returns void (throws on error)
  - removed hasNegatives()
* RegionGraph::
  - nr_ORs() -> nrORs()
  - nr_IRs() -> nrIRs()
  - ORs() -> ORs
  - IRs() -> IRs
* *::Regenerate() -> *::construct()
* Renamed Index -> IndexFor
* Diffs:
  - max() -> maxDiff()
  - max_size() -> maxSize()
* Prob::max() -> Prob::maxVal()
* Factor::
  - max() -> maxVal()
  - part_sum() -> partSum()
* toc() in util.h now returns seconds as a double
* VarSet::operator&&
* Properties -> PropertySet


libDAI-0.2.1 (2008-05-26)
-------------------------

Bugfix release.
* added missing cstdio header in util.h
* fixed Properties in MR_CLAMPING_* and MR_EXACT_*
* added description of the factor graph fileformat
* improved Makefile


libDAI-0.2.0 (2006-11-30)
-------------------------

First public release.


0.1.5 (2006-11-30)
------------------

Regressions

- tests/testlcbp and tests/testlcbp are broken.
- EXACT method does not work anymore.
- The Properties framework gives a speed penalty because of the lookup
  costs involved; inner loops should be optimized.

General framework

- DAIAlg is now a template class; typedefs for DAIAlg<FactorGraph> and for
  DAIAlg<RegionGraph> are provided. In this way, we do not have to write "wrapper"
  functions to forward functionality from either FactorGraph or RegionGraph
  to DAIAlg. Functionality like clamping can be implemented in FactorGraph
  and in RegionGraph and no explicit interface is needed in descendants.
- New abstract base class InfAlg added, representing an inference algorithm,
  from which DAIAlg<T> inherits. This solves the incompatibility problems of
  DAIAlg<T> for different T (e.g. DAIAlg<FactorGraph> was incompatible with
  DAIAlg<RegionGraph>). More work is required to reduce code duplication
  (make FactorGraph part of InfAlg).
- Added generic interface (nrVars(), Vars(), nrFactors(), factor(size_t),
  beliefs(), belief(VarSet &), ...) to InfAlg and descendants.
- Added a saveProbs/undoProbs interface to InfAlg and descendants that enables
  one to save a few factors, modify them (e.g. clamp them), and then restore them
  to their old values. Undo should also init the corresponding messages / beliefs.
  This can be used if a given factor graph repeatedly needs to be clamped in
  different ways and an approximation method is run for each clamping; using the
  saveProbs/undoProbs can give a significant speed increase.
- Switched to a general Properties framework that handles the parameters of
  all inference methods in a uniform manner. The Properties class is a map of
  several properties in boost::any objects, indexed by their names (strings).
  It can read from a stream and write to a stream. It is recursive, in the sense
  that a Properties object can hold a variable of type Properties as well.
- Added a generic way of constructing inference algorithms from a factor graph,
  name and properties object. Added the newInfAlg function which constructs
  the requested object. This is used by LCBP, the Matlab interface and the
  command line (test) interface.
- Added a generic enum framework for enum parameters. Although implemented as a
  hack, it is quite useful in that it drastically simplifies and reduces the
  amount of code for handling enum parameters.
- Provided generic functions for calculating marginals in different ways that
  work for all approximate inference methods.

Bugfixes

- Fixed GBP free energy.
- Fixed bug in junctiontree (it didn't init the _vars variable).
- Corrected two bugs in operator&& and operator|| in VarSet (they returned
  the logical NOT of what they should return).
- Fixed bug in RegionGraph::RecomputeOR(s).
- Fixed bug in utils/create_dreg_fg:
  graph structure was not random for given parameters (forgot to call srand()).
- TreeEP bug workaround: use the complete junction tree instead of a subtree.
- Fixed bug in JTree::HUGIN() and JTree:ShaferShenoy() in case of junction tree
  that consists of one outer region only.
- Fixed INIT bug in LCBP2::UpdatePancake().
- Fixed MaxDiffs flow (except for MR).

New functionality

- HAK supports several default cluster choices:
  minimal (only factors)
  delta   (Markov blankets)
  loop    (all loops consisting of loops consisting of <loopdepth> or less variables)
  Only the maximal clusters are used as outer clusters.
- Implemented TreeEP. It generalizes the heuristic method described in the
  Minka & Qi paper for obtaining a tree with the most relevant interactions to
  higher order interactions. Almost all optimizations described in the Minka & Qi
  paper are used, except that evidence is passed over the whole tree instead of
  relevant subsets (the latter is almost implemented but buggy). Also added
  alternative (worst-case) algorithm that uses a maximum spanning tree on the
  weighted graph where the weight between neighbours i and j is given by
  N(psi,i,j), where psi is the product of all the factors involving both i and j
  (which is an upper bound on the effective interaction between i and j).
- Implemented MR (MontanariRizzo) based on Bastian's code, but extended it
  to be able to handle connectivities larger than 3 (in principle, up to 32).
  It supports different initialization methods (the original RESPPROP,
  the CLAMPING method and EXACT which uses JTree) and different update methods
  (FULL and LINEAR).
- Implemented LCBP2, an analogon of LCBP which represents pancakes as little
  networks and uses some approximate inference method on them for calculating
  marginals.
- Now there are several LCBP variants (LCBP, LCBPI, LCBPJ, LCBPK, LCBPL);
  LCBPJ works only for pairwise, LCBPK is LCBP improved for higher order
  interactions and LCBPL is LCBPI improved for higher-order interactions.
- Wrote one single program utils/createfg for creating various types of
  random factor graphs.
- Wrote utility to visualize factor graphs using graphviz.
  (it uses the BOOST Program Options library)
- Added fginfo utility that displays some info about a .fg file.
- Implemented Factor::strength function that calculates the potential strength
  N(psi,i,j) between variables i and j as described in cs.IT:0504030
- Wrote a general MatLab interface matlab/dai (similar to tests/test);
  this unified the matlab functions dai, dai_bp, dai_mf, dai_jt, dai_tep, dai_cvm.
- Added MATLAB routine that returns contraction matrix A for BP convergence analysis.
- Implemented a MATLAB interface ai_potstrength for Factor::strength
- Added Martijn's x2x

Improvements of existing code

- Reimplemented RegionGraph and descendants: a RegionGraph ISA FactorGraph
  and also a BipartiteGraph<FRegion,Region>. It now also keeps a map that
  associates outer region indices to factor indices (no powers yet, this
  is deemed superfluous) and provides functions to recompute (some of) the
  outer regions from the factors.
- InfAlg descendants run() methods now stop immediately and return NAN in case
  they detect NANs. Only BP does not do NAN checking for performance reasons.
- LCBP now works with factors containing zeroes (by defining x/0 = 0).
- HAK, GBP and DoubleLoop now conform to the standards for verbose reporting,
  timing and convergence criteria.
- Implemented logZ() for JTree. It does the calculation during message-passing.
- Marginal2ndO now optionally divides by the single node beliefs (to the power n-2);
  hopefully this will give more accurate approximations.
- Marginal and Marginal2ndO (optionally) use the new saveProbs/undoProbs functionality
  for a faster way of calculating marginals, which does not require a call to init()
  nor cloning the whole object for each clamping. This leads to a significant speedup.
- LCBP (and LCBP2) now have complete flexibility in the specification of the
  inner method, i.e. the method used to generate the initial cavity approximations.
  One can pass two strings, a name and a properties string, and LCBP simply invokes
  newInfAlg to construct the corresponding inference algorithm and uses the generic
  marginal functions to approximate cavity marginals.
- Replaced the global "method" variable by local properties and removed ai.h
- Added some methods to Factor (operators *, *=, /, /= with doubles as
  second argument, operators -, +=, -= with other Factors as second
  arguments, randomize(), RemoveFirstOrderInteractions) and similar
  operations to Prob
- Moving towards boost::program_options for handling command line arguments
  (tests/test is done).
- Renamed some FactorGraph methods:
  nr_vars       -> nrVars
  nr_factors    -> nrFactors
  varind        -> findVar
  factorind     -> findFactor
  makeFacCavity -> makeFactorCavity
- LCBP_SEQMAXRES has been removed because it did strange things.
- Implemented RandomDRegularGraph
- Implemented JTree::calcMarginal for marginals that are not confined
  within one cluster (using cut-set conditioning).
- Added isConnected() method to FactorGraph (some methods do not work with
  disconnected factor graphs).
- Pair beliefs are now calculated in a symmetrical way by calcPairBeliefs
- Removed single node interaction "correction" code from clamping methods
- Removed calcCavityDist and calcCavityDist2ndO
- No longer depends on GSL.
- Increased portability by combining platform dependant utility functions
  in util.{h,cpp}.
- Wrote *.m files providing help

Testing framework

- Made a new and significantly improved testing framework that provides most
  functionality from the command line.
- The basis is provided by tests/test, which uses the newInfAlg functionality
  and enables the user to easily compare from the command line different
  inference methods on a given factorgraph. All parameters can be specified.
  Output consists of CPU time, average and maximum single variable marginal
  errors, relative logZ error and MaxDiff().
- tests/aliases.conf contains aliases for standard combinations of methods
  and their options (which can be used in tests/test).
- tests/large contains several bash/python scripts that create random factor
  graphs, compare several approximate inference algorithms (using tests/test) and
  allow for easy visualization of the results using PyX.
- Added several .fg files for test purposes to /tests (e.g. two ALARM versions
  alarm.fg and alarm_bnt.fg; testfast.fg, a 4x4 periodic Ising grid for
  regression testing).
- Added a regression test to the Makefile which is included in the standard
  target.  It compares all inference methods on tests/testfast.fg with the
  results stored in tests/testfast.out

Miscellaneous

- Expanded all tabs to spaces (":set tabstop 4\n:set expandtab\n:retab" in vim)
- Experimental MATLAB code added for StarEP approximation on cavity
- Renamed project to libDAI and changed directory name accordingly.
- Renamed JunctionTree to JTree.
- Fixed licensing (now it's officially GPL).
- Improved README


revision 252
------------

Functionality
- Added RegionGraph, GBP, CVM and HAK (double-loop).
- Added JunctionTree (with two update algorithms, HUGIN and Shafer-Shenoy), which is a
  RegionGraph.
- NormType is now chosen automatically (in case of negative factors, Prob::NORMLINF is used,
  otherwise the default Prob::NORMPROB is used). Also, in case of negative factors, the
  RegionGraph constructors assign each Factor to a unique outer region instead of dividing
  it over all subsuming outer regions. See README for when negative factors are known to work
  and when not.
- FactorGraph::FactorGraph(const vector<Factor>) only gives a warning in case of short loops,
  it does not automatically merge factors anymore.
- Removed BP_SEQMAXRESNOCLEAR (all cavity initialization methods now are implicitly NOCLEAR)
- Added MATLAB interface functions ai_readfg, ai_removeshortloops and ai_bp
- Added LCBP-III type that should be equivalent to LCBP-II, but can handle zeroes
  in potentials. Note that it is significantly slower than LCBP-II (and has to be reimplemented
  such that it does not store the complete pancakes, but represents them as little factor graphs).

Implementation / code
- Made a seperate type WeightedGraph, which until now only implements Prim's
  maximal spanning tree algorithm and is only used by the junction tree code. It might
  be good to make it a class somewhere in the future and extend it's interface.
- Made a seperate class ClusterGraph, which is only used by the junction tree
  code. It's main purpose is a graph-theoretical variable elimination algorithm.
- Implemented the heuristic "minimum-new-edges-in-clique-graph" for variable elimination.
- Massive code cleanup, moving towards "generic" programming style, using
  multiple inheritance and polymorphism.
  o BP, LCBP, MF, HAK and JunctionTree now inherit from a common DAIAlg class
  o Made generic functions Marginal, Marginal2ndO, calcCavityDist, calcCavityDist2ndO, clamp
    that can be used by FactorGraph-based DAIAlgs.
  o Created TProb<T> class, which stores a probability vector (without the accompanying indexing
    and VarSet) and provides functionality for it (which is used by TFactor<T>).
  o Rewrote the VarSet class. It now caches its statespace(). It now privately inherits from set<Var>.
    I had to overload the insert methods of set<Var> so that they calculate the new statespace.
  o Rewrote the TFactor class. The TFactor class now HAS a TProb and HAS a VarSet.
- Rewrote BP to use the new TProb<T> interface. Performance of BP improved up to a factor 6 by:
  o using Prob's instead of Factor's;
  o splitting the multiplication of the messages into two parts (thanks to Vicenc!);
  o optimizing the calculation of the beliefs (only the message calculations were optimized till now).
  o replacing FactorGraph::_nb1 and _nb2 (which were set<size_t>) by vector<size_t>
- LCBP now seperately stores cavitydists and pancakes. Added InitPancakes() method
  that takes the cavitydists and multiplies them with the relevant factors. This
  resulted in an API change in AI which now accepts and returns initial cavitydists
  instead of initial pancakes.

Minor changes
- Started writing DoxyGen documentation
- Renamed lcptab2fg.m matlab/ai_writefg.m
- Moved all matlab stuff to matlab/
- More detailed reporting (also reports clocks used).
- Marginal and Marginal2ndO now use *differences* in logZ to avoid NaNs.
- Improved testing suite.
- Removed logreal support.
- FactorGraph now also supports input streams and ignores comment lines in .fg files.
- Added tests/create_full_fg.cpp and tests/create_ising_fg.cpp which create
  full and periodic 2D Ising networks according to some command line parameters.
- Now logZ really returns logZ instead of -logZ.
- Added FactorGraph::WriteToDotFile


0.1.4 (2006-04-13)
------------------
- Added file IO routines to read and write factorgraphs.
- Added L-infinity normalization for use with (partially) negative factors.
- Renamed BetheF, MFF to logZ, which now use complex numbers to be able to
handle (partially) negative factors.
- Added test suite.
- All probabilities are now represented using double instead of LogReal<double>.
- Combined Alg and Alg3 into LCBP. Several update schemes possible.
- Combined several variants of BP into doBP. Several update schemes possible.
Now uses precalculated indices for optimization.
- Renamed Node -> Var and Potential -> Factor.
- Extensive code cleanup. More use of OO techniques. Changed API.
- MaxIter now means maximum number of passes (corresponding to number of
_parallel_ updates).
- MaxDiff now means the maximum L-infinity distance between the updated and
original single variable beliefs, for all AI methods.
- Implemented RBP which converges faster than BP for difficult problems.
- Now uses method parameter which is a bitmask combining outmethod and inmethod
(see ai.h).


0.1.3   (2006-03-22)
--------------------
- All AI methods now return maxdiff
- ai.cpp:
    o Now returns maxdiffinner and maxdiffouter
    o New BP2ndO innermethod (estimate only 2nd order cavity interactions)
    o New InitCav outermethod (only create initial cavity distributions)
- bp.cpp:
    o New CavityDist2ndO which estimates 2nd order cavity interactions
- Makefile:
    o Bugfix: removed dependencies on algwim.*


0.1.2   (2006-02-28)
--------------------
- Cleaned up alg.cpp (removed Alg2 and its corresponding data structures).
- Added the possibility to provide initial cavity distributions as an input
argument to ai (not much error checking is done, so be careful).
- Potentials2mx now correctly sets the dimensions of the P field (i.e. for
the output arguments Q, Q0 of ai).
- Removed algwim.* since it does not work.


0.1.1   (2006-02-28)
--------------------
- The constructors of (Log)FactorGraph and LogFactorGraph from a
vector<(Log)Potential> now merge potentials to prevent short loops (of length
4) in the factor graph. These are used in ai to construct the factor graphs
from the psi argument. If compiled with DEBUG defined, the method calc_nb()
of BipGraph checks for the existence of short loops.
- Changed calling syntax of ai (now the actual syntax *does* correspond to its
description in the help).
- ai does not hook cout anymore (which caused weird segfaults).
- Fixed a bug in an assert statement in the matlab interface code in ai.cpp.
- Removed network.* since it is not useful.


0.1.0   (2006-02-28)
--------------------
First version worthy of a version number.
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1RegionGraph.png0000644000263000017630000000142311433220721020243 0ustar jorismkyb‰PNG  IHDRĈJYOPLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf©IDAThíšmnä †ÃŸý}³7h/4ÒJsÿ#,`› “-ÉL7ìF &àÇDŠªwù|»-áÍöÛ?A¥D½ ¸š¹ÑÅmºØÆÝ‹Š[åÕ)nìÀØÆíq†”Œ“Ÿ†Ù@Äå14R¾2&vˆBFd'N‘–¡ÔµÏˆP2$eïDÄš6ªGpp¡"0 t0 xDh-’ ‚€Ý>QTÊûéüð‰b7=(D„°ñU{~^ 1c†8â>r¦í6¿ä|ˆ_÷+ î÷Û×8Q†0„! aC†`ƒ·Ûâ_ŸgoÎ?áµqñX”juL§îEH܇iýØ>„ó~ÏY¤±‡\LiqÎKŠ^=xf á]ŠÒµH?yú ÔÛx¿¶é–+µÈˆE¹/)Š·!o âVˆ<ÃÁ1„Ó,ò^—ÂÊ­M-8/Eø½>Q^Ëݨ÷òƒrNXóˆqjÛ6‡ïõ¥7|Á^ŠØe†8â>r¦íöò<ÿÂþO{Ä5N”! aC†0„!ئ•#¦¥&×ÐäbÑ*gY†X¯j¨ UymÕ Ö±Ð­kr²ˆ5uh„é2;ªn ¢WÎb‡ÅbVÏj¸$‚Dä•„’"ª=b¥œÅö/Ý ÄRWÕp&]§ô‘U¢¢Á”8È“[U9ûˆ &d7¨œªU壚¢x‚lrsÍ¥¥"*æ!yP”1="ÏÈq "1 ¢‘µbÖÊ–¶É‚4 U?"ðY­rV丱®EA4µ²¬•ékÑ*gAÔ²ŠXŸ(Ôrw'J”µùA «/¶lKC>T¡®ü±¥÷m÷z`EƒÁptqØ q&ÄôGδý¨m«Þ!ròÜIEND®B`‚libDAI-0.2.7/doc/html/alldai_8h.html0000644000263000017630000001615211433220721015704 0ustar jorismkyb libDAI: include/dai/alldai.h File Reference

include/dai/alldai.h File Reference

Main libDAI header file. It #includes all other libDAI headers. More...

#include <string>
#include <dai/daialg.h>
#include <dai/properties.h>
#include <dai/exactinf.h>
#include <dai/evidence.h>
#include <dai/emalg.h>
#include <dai/bp.h>
#include <dai/fbp.h>
#include <dai/trwbp.h>
#include <dai/mf.h>
#include <dai/hak.h>
#include <dai/lc.h>
#include <dai/treeep.h>
#include <dai/jtree.h>
#include <dai/mr.h>
#include <dai/cbp.h>

Go to the source code of this file.

Namespaces

namespace  dai

Functions

InfAlg * dai::newInfAlg (const std::string &name, const FactorGraph &fg, const PropertySet &opts)
 Constructs a new inference algorithm.
InfAlg * dai::newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg)
 Constructs a new inference algorithm.
InfAlg * dai::newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg, const std::map< std::string, std::string > &aliases)
 Constructs a new inference algorithm.
std::pair< std::string,
PropertySet > 		dai::parseNameProperties (const std::string &s)
 Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name".
std::pair< std::string,
PropertySet > 		dai::parseNameProperties (const std::string &s, const std::map< std::string, std::string > &aliases)
 Extracts the name and property set from a string s in the format "name[key1=val1,key2=val2,...]" or "name", performing alias substitution.
std::map< std::string,
std::string > 		dai::readAliasesFile (const std::string &filename)
 Reads aliases from file named filename.

Variables

static const char * dai::DAINames []
 Contains the names of all inference algorithms compiled into libDAI.

Detailed Description

Main libDAI header file. It #includes all other libDAI headers.

Todo:
Replace VarSets by SmallSet<size_t> where appropriate, in order to minimize the use of FactorGraph::findVar().
Todo:
Improve SWIG interfaces and merge their build process with the main build process
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1BipartiteGraph.html0000644000263000017630000020532211433220721021127 0ustar jorismkyb libDAI: dai::BipartiteGraph Class Reference

dai::BipartiteGraph Class Reference

Represents the neighborhood structure of nodes in an undirected, bipartite graph. More...

#include <dai/bipgraph.h>

List of all members.

Input and output

void printDot (std::ostream &os) const
 Writes this BipartiteGraph to an output stream in GraphViz .dot syntax.
std::ostream & operator<< (std::ostream &os, const BipartiteGraph &g)
 Writes this BipartiteGraph to an output stream.

Public Member Functions

Constructors and destructors
 BipartiteGraph ()
 Default constructor (creates an empty bipartite graph).
 BipartiteGraph (size_t nr1, size_t nr2)
 Constructs BipartiteGraph with nr1 nodes of type 1, nr2 nodes of type 2 and no edges.
template<typename EdgeInputIterator>
 BipartiteGraph (size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
 Constructs BipartiteGraph from a range of edges.
Accessors and mutators
const Neighbor & nb1 (size_t i1, size_t _i2) const
 Returns constant reference to the _i2 'th neighbor of node i1 of type 1.
Neighbor & nb1 (size_t i1, size_t _i2)
 Returns reference to the _i2 'th neighbor of node i1 of type 1.
const Neighbor & nb2 (size_t i2, size_t _i1) const
 Returns constant reference to the _i1 'th neighbor of node i2 of type 2.
Neighbor & nb2 (size_t i2, size_t _i1)
 Returns reference to the _i1 'th neighbor of node i2 of type 2.
const Neighbors & nb1 (size_t i1) const
 Returns constant reference to all neighbors of node i1 of type 1.
Neighbors & nb1 (size_t i1)
 Returns reference to all neighbors of node i1 of type 1.
const Neighbors & nb2 (size_t i2) const
 Returns constant reference to all neighbors of node i2 of type 2.
Neighbors & nb2 (size_t i2)
 Returns reference to all neighbors of node i2 of type 2.
Adding nodes and edges
template<typename EdgeInputIterator>
void construct (size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
 (Re)constructs BipartiteGraph from a range of edges.
size_t addNode1 ()
 Adds a node of type 1 without neighbors and returns the index of the added node.
size_t addNode2 ()
 Adds a node of type 2 without neighbors and returns the index of the added node.
template<typename NodeInputIterator>
size_t addNode1 (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
 Adds a node of type 1, with neighbors specified by a range of nodes of type 2.
template<typename NodeInputIterator>
size_t addNode2 (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
 Adds a node of type 2, with neighbors specified by a range of nodes of type 1.
BipartiteGraph & addEdge (size_t n1, size_t n2, bool check=true)
 Adds an edge between node n1 of type 1 and node n2 of type 2.
Erasing nodes and edges
void eraseNode1 (size_t n1)
 Removes node n1 of type 1 and all incident edges; indices of other nodes are changed accordingly.
void eraseNode2 (size_t n2)
 Removes node n2 of type 2 and all incident edges; indices of other nodes are changed accordingly.
void eraseEdge (size_t n1, size_t n2)
 Removes edge between node n1 of type 1 and node n2 of type 2.
Queries
size_t nrNodes1 () const
 Returns number of nodes of type 1.
size_t nrNodes2 () const
 Returns number of nodes of type 2.
size_t nrEdges () const
 Calculates the number of edges, time complexity: O(nrNodes1()).
bool hasEdge (size_t n1, size_t n2) const
 Returns true if the graph contains an edge between node n1 of type 1 and node n2 of type 2.
size_t findNb1 (size_t n1, size_t n2)
 Returns the index of a given node n2 of type 2 amongst the neighbors of node n1 of type 1.
size_t findNb2 (size_t n1, size_t n2)
 Returns the index of a given node n1 of type 1 amongst the neighbors of node n2 of type 2.
SmallSet< size_t > nb1Set (size_t n1) const
 Returns neighbors of node n1 of type 1 as a SmallSet<size_t>.
SmallSet< size_t > nb2Set (size_t n2) const
 Returns neighbors of node n2 of type 2 as a SmallSet<size_t>.
SmallSet< size_t > delta1 (size_t n1, bool include=false) const
 Calculates second-order neighbors (i.e., neighbors of neighbors) of node n1 of type 1.
SmallSet< size_t > delta2 (size_t n2, bool include=false) const
 Calculates second-order neighbors (i.e., neighbors of neighbors) of node n2 of type 2.
bool isConnected () const
 Returns true if the graph is connected.
bool isTree () const
 Returns true if the graph is a tree, i.e., if it is singly connected and connected.
bool operator== (const BipartiteGraph &x) const
 Comparison operator which returns true if two graphs are identical.
void checkConsistency () const
 Asserts internal consistency.

Private Attributes

std::vector< Neighbors > _nb1
 Contains for each node of type 1 a vector of its neighbors.
std::vector< Neighbors > _nb2
 Contains for each node of type 2 a vector of its neighbors.

Classes

struct  levelType
 Used internally by isTree(). More...

Detailed Description

Represents the neighborhood structure of nodes in an undirected, bipartite graph.

A bipartite graph has two types of nodes: type 1 and type 2. Edges can occur only between nodes of different type. Nodes are indexed by an unsigned integer. If there are nrNodes1() nodes of type 1 and nrNodes2() nodes of type 2, the nodes of type 1 are numbered 0,1,2,...,nrNodes1()-1 and the nodes of type 2 are numbered 0,1,2,...,nrNodes2()-1. An edge between node n1 of type 1 and node n2 of type 2 is represented by a Edge(n1,n2).

A BipartiteGraph is implemented as a sparse adjacency list, i.e., it stores for each node a list of its neighboring nodes. More precisely: it stores for each node of type 1 a vector of Neighbor structures (accessible by the nb1() method) describing the neighboring nodes of type 2; similarly, for each node of type 2 it stores a vector of Neighbor structures (accessibly by the nb2() method) describing the neighboring nodes of type 1. Thus, each node has an associated variable of type BipartiteGraph::Neighbors, which is a vector of Neighbor structures, describing its neighboring nodes of the other type.

Idea:
Cache second-order neighborhoods in BipartiteGraph.
Examples:

example_bipgraph.cpp.

Constructor & Destructor Documentation

dai::BipartiteGraph::BipartiteGraph (  )  [inline]

Default constructor (creates an empty bipartite graph).

dai::BipartiteGraph::BipartiteGraph ( size_t  nr1,
size_t  nr2 
) [inline]

Constructs BipartiteGraph with nr1 nodes of type 1, nr2 nodes of type 2 and no edges.

template<typename EdgeInputIterator>
dai::BipartiteGraph::BipartiteGraph ( size_t  nrNodes1,
size_t  nrNodes2,
EdgeInputIterator  begin,
EdgeInputIterator  end,
bool  check = true 
) [inline]

Constructs BipartiteGraph from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of Edge.
Parameters:
nrNodes1 The number of nodes of type 1.
nrNodes2 The number of nodes of type 2.
begin Points to the first edge.
end Points just beyond the last edge.
check Whether to only add an edge if it does not exist already.

Member Function Documentation

const Neighbor& dai::BipartiteGraph::nb1 ( size_t  i1,
size_t  _i2 
) const [inline]

Returns constant reference to the _i2 'th neighbor of node i1 of type 1.

Neighbor& dai::BipartiteGraph::nb1 ( size_t  i1,
size_t  _i2 
) [inline]

Returns reference to the _i2 'th neighbor of node i1 of type 1.

const Neighbor& dai::BipartiteGraph::nb2 ( size_t  i2,
size_t  _i1 
) const [inline]

Returns constant reference to the _i1 'th neighbor of node i2 of type 2.

Neighbor& dai::BipartiteGraph::nb2 ( size_t  i2,
size_t  _i1 
) [inline]

Returns reference to the _i1 'th neighbor of node i2 of type 2.

const Neighbors& dai::BipartiteGraph::nb1 ( size_t  i1  )  const [inline]

Returns constant reference to all neighbors of node i1 of type 1.

Neighbors& dai::BipartiteGraph::nb1 ( size_t  i1  )  [inline]

Returns reference to all neighbors of node i1 of type 1.

const Neighbors& dai::BipartiteGraph::nb2 ( size_t  i2  )  const [inline]

Returns constant reference to all neighbors of node i2 of type 2.

Neighbors& dai::BipartiteGraph::nb2 ( size_t  i2  )  [inline]

Returns reference to all neighbors of node i2 of type 2.

template<typename EdgeInputIterator>
void dai::BipartiteGraph::construct ( size_t  nrNodes1,
size_t  nrNodes2,
EdgeInputIterator  begin,
EdgeInputIterator  end,
bool  check = true 
) [inline]

(Re)constructs BipartiteGraph from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of Edge.
Parameters:
nrNodes1 The number of nodes of type 1.
nrNodes2 The number of nodes of type 2.
begin Points to the first edge.
end Points just beyond the last edge.
check Whether to only add an edge if it does not exist already.

size_t dai::BipartiteGraph::addNode1 (  )  [inline]

Adds a node of type 1 without neighbors and returns the index of the added node.

size_t dai::BipartiteGraph::addNode2 (  )  [inline]

Adds a node of type 2 without neighbors and returns the index of the added node.

template<typename NodeInputIterator>
size_t dai::BipartiteGraph::addNode1 ( NodeInputIterator  begin,
NodeInputIterator  end,
size_t  sizeHint = 0 
) [inline]

Adds a node of type 1, with neighbors specified by a range of nodes of type 2.

Template Parameters:
NodeInputIterator Iterator that iterates over instances of size_t.
Parameters:
begin Points to the first index of the nodes of type 2 that should become neighbors of the added node.
end Points just beyond the last index of the nodes of type 2 that should become neighbors of the added node.
sizeHint For improved efficiency, the size of the range may be specified by sizeHint.
Returns:
Index of the added node.

template<typename NodeInputIterator>
size_t dai::BipartiteGraph::addNode2 ( NodeInputIterator  begin,
NodeInputIterator  end,
size_t  sizeHint = 0 
) [inline]

Adds a node of type 2, with neighbors specified by a range of nodes of type 1.

Template Parameters:
NodeInputIterator Iterator that iterates over instances of size_t.
Parameters:
begin Points to the first index of the nodes of type 1 that should become neighbors of the added node.
end Points just beyond the last index of the nodes of type 1 that should become neighbors of the added node.
sizeHint For improved efficiency, the size of the range may be specified by sizeHint.
Returns:
Index of the added node.

BipartiteGraph & dai::BipartiteGraph::addEdge ( size_t  n1,
size_t  n2,
bool  check = true 
)

Adds an edge between node n1 of type 1 and node n2 of type 2.

If check == true, only adds the edge if it does not exist already.

void dai::BipartiteGraph::eraseNode1 ( size_t  n1  ) 

Removes node n1 of type 1 and all incident edges; indices of other nodes are changed accordingly.

void dai::BipartiteGraph::eraseNode2 ( size_t  n2  ) 

Removes node n2 of type 2 and all incident edges; indices of other nodes are changed accordingly.

void dai::BipartiteGraph::eraseEdge ( size_t  n1,
size_t  n2 
)

Removes edge between node n1 of type 1 and node n2 of type 2.

size_t dai::BipartiteGraph::nrNodes1 (  )  const [inline]

Returns number of nodes of type 1.

size_t dai::BipartiteGraph::nrNodes2 (  )  const [inline]

Returns number of nodes of type 2.

size_t dai::BipartiteGraph::nrEdges (  )  const [inline]

Calculates the number of edges, time complexity: O(nrNodes1()).

bool dai::BipartiteGraph::hasEdge ( size_t  n1,
size_t  n2 
) const [inline]

Returns true if the graph contains an edge between node n1 of type 1 and node n2 of type 2.

Note:
The time complexity is linear in the number of neighbors of n1 or n2

size_t dai::BipartiteGraph::findNb1 ( size_t  n1,
size_t  n2 
) [inline]

Returns the index of a given node n2 of type 2 amongst the neighbors of node n1 of type 1.

Note:
The time complexity is linear in the number of neighbors of n1
Exceptions:
OBJECT_NOT_FOUND if n2 is not a neighbor of n1

size_t dai::BipartiteGraph::findNb2 ( size_t  n1,
size_t  n2 
) [inline]

Returns the index of a given node n1 of type 1 amongst the neighbors of node n2 of type 2.

Note:
The time complexity is linear in the number of neighbors of n2
Exceptions:
OBJECT_NOT_FOUND if n1 is not a neighbor of n2

SmallSet< size_t > dai::BipartiteGraph::nb1Set ( size_t  n1  )  const

Returns neighbors of node n1 of type 1 as a SmallSet<size_t>.

SmallSet< size_t > dai::BipartiteGraph::nb2Set ( size_t  n2  )  const

Returns neighbors of node n2 of type 2 as a SmallSet<size_t>.

SmallSet< size_t > dai::BipartiteGraph::delta1 ( size_t  n1,
bool  include = false 
) const

Calculates second-order neighbors (i.e., neighbors of neighbors) of node n1 of type 1.

If include == true, includes n1 itself, otherwise excludes n1.

Note:
In libDAI versions 0.2.4 and earlier, this function used to return a std::vector<size_t>

SmallSet< size_t > dai::BipartiteGraph::delta2 ( size_t  n2,
bool  include = false 
) const

Calculates second-order neighbors (i.e., neighbors of neighbors) of node n2 of type 2.

If include == true, includes n2 itself, otherwise excludes n2.

Note:
In libDAI versions 0.2.4 and earlier, this function used to return a std::vector<size_t>

bool dai::BipartiteGraph::isConnected (  )  const

Returns true if the graph is connected.

bool dai::BipartiteGraph::isTree (  )  const

Returns true if the graph is a tree, i.e., if it is singly connected and connected.

bool dai::BipartiteGraph::operator== ( const BipartiteGraph &  x  )  const [inline]

Comparison operator which returns true if two graphs are identical.

Note:
Two graphs are called identical if they have the same number of nodes of both types and the same edges (i.e., x has an edge between nodes n1 and n2 if and only if *this has an edge between nodes n1 and n2).

void dai::BipartiteGraph::checkConsistency (  )  const

Asserts internal consistency.

void dai::BipartiteGraph::printDot ( std::ostream &  os  )  const

Writes this BipartiteGraph to an output stream in GraphViz .dot syntax.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const BipartiteGraph &  g 
) [friend]

Writes this BipartiteGraph to an output stream.

Member Data Documentation

std::vector<Neighbors> dai::BipartiteGraph::_nb1 [private]

Contains for each node of type 1 a vector of its neighbors.

std::vector<Neighbors> dai::BipartiteGraph::_nb2 [private]

Contains for each node of type 2 a vector of its neighbors.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/example__imagesegmentation_8cpp-example.html0000644000263000017630000006665111433220721024025 0ustar jorismkyb libDAI: example_imagesegmentation.cpp

example_imagesegmentation.cpp

This example shows how one can use approximate inference in factor graphs on a simple vision task: given two images, identify smooth regions where these two images differ more than some threshold. This can be used to seperate foreground from background if one image contains the background and the other one the combination of background and foreground.

Note:
In order to build this example, a recent version of CImg needs to be installed.
/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2006-2010  Joris Mooij  [joris dot mooij at libdai dot org]
 *  Copyright (C) 2006-2007  Radboud University Nijmegen, The Netherlands
 */


#include <iostream>
#include <dai/alldai.h>  // Include main libDAI header file
#include <CImg.h>        // This example needs CImg to be installed


using namespace dai;
using namespace std;
using namespace cimg_library;



template<class T>
FactorGraph img2fg( const CImg<T> &img, double J, double th_min, double th_max, double scale, double pbg, CImg<unsigned char> &evidence ) {
    vector<Var> vars;
    vector<Factor> factors;

#ifndef NEW_CIMG
    size_t dimx = img.width;   // Width of the image in pixels
    size_t dimy = img.height;  // Height of the image in pixels
#else
    size_t dimx = img.width();   // Width of the image in pixels
    size_t dimy = img.height();  // Height of the image in pixels
#endif
    size_t N = dimx * dimy;      // One variable for each pixel

    // Create variables
    cout << "  Image width:  " << dimx << endl;
    cout << "  Image height: " << dimy << endl;
    cout << "  Pairwise interaction strength:   " << J << endl;
    cout << "  Minimal local evidence strength: " << th_min << endl;
    cout << "  Maximal local evidence strength: " << th_max << endl;
    cout << "  Scale of pixel values:           " << scale << endl;
    cout << "  Percentage of background:        " << pbg << endl;
    cout << "  Creating " << N << " variables..." << endl;
    // Reserve memory for the variables
    vars.reserve( N );
    // Create a binary variable for each pixel
    for( size_t i = 0; i < N; i++ )
        vars.push_back( Var( i, 2 ) );

    // Build image histogram
    CImg<float> hist = img.get_channel( 0 ).get_histogram( 256, 0, 255 );
    size_t cum_hist = 0;

    // Find the critical level which corresponds with the seperation
    // between foreground and background, assuming that the percentage
    // of pixels in the image that belong to the background is pbg
    size_t level = 0;
    for( level = 0; level < 256; level++ ) {
        cum_hist += (size_t)hist(level);
        if( cum_hist > pbg * dimx * dimy / 100.0 )
            break;
    }

    // Create factors
    cout << "  Creating " << (3 * N - dimx - dimy) << " factors..." << endl;
    // Reserve memory for the factors
    factors.reserve( 3 * N - dimx - dimy );
    // th_avg is the local field strength that would correspond with pixel value level
    // th_width is the width of the local field strength range
    double th_avg = (th_min + th_max) / 2.0;
    double th_width = (th_max - th_min) / 2.0;
    // For each pixel
    for( size_t i = 0; i < dimx; i++ )
        for( size_t j = 0; j < dimy; j++ ) {
            // Add a pairwise interaction with the left neighboring pixel
            if( i >= 1 )
                factors.push_back( createFactorIsing( vars[i*dimy+j], vars[(i-1)*dimy+j], J ) );
            // Add a pairwise interaction with the upper neighboring pixel
            if( j >= 1 )
                factors.push_back( createFactorIsing( vars[i*dimy+j], vars[i*dimy+(j-1)], J ) );
            // Get the pixel value
            double x = img(i,j);
            // Apply the nonlinear transformation to get the local field strength
            double th = th_avg + th_width * tanh( (x - level) / scale );
            // Add a single-variable interaction with strength th
            factors.push_back( createFactorIsing( vars[i*dimy+j], th ) );

            // For visualization, we calculate a grayscale level corresponding to the local field strength
            unsigned char g = (unsigned char)((tanh(th) + 1.0) / 2.0 * 255.0);
            // and store it in the evidence image
            if( g > 127 ) {
                evidence(i,j,0) = 255;
                evidence(i,j,1) = 2 * (g - 127);
                evidence(i,j,2) = 2 * (g - 127);
            } else {
                evidence(i,j,0) = 0;
                evidence(i,j,1) = 0;
                evidence(i,j,2) = 2*g;
            }
        }

    // Create the factor graph out of the variables and factors
    cout << "Creating the factor graph..." << endl;
    return FactorGraph( factors.begin(), factors.end(), vars.begin(), vars.end(), factors.size(), vars.size() );
}



double doInference( FactorGraph& fg, string algOpts, size_t maxIter, double tol, vector<double> &m, size_t dimx, size_t dimy, CImgDisplay &disp ) {
    // Construct inference algorithm
    cout << "Inference algorithm: " << algOpts << endl;
    cout << "Constructing inference algorithm object..." << endl;
    InfAlg* ia = newInfAlgFromString( algOpts, fg );

    // Initialize inference algorithm
    cout << "Initializing inference algorithm..." << endl;
    ia->init();

    // Initialize vector for storing the magnetizations
    m = vector<double>( fg.nrVars(), 0.0 );

    // Construct an image that will hold the intermediate single-variable beliefs
    CImg<unsigned char> image( dimx, dimy, 1, 3 );

    // maxDiff stores the current convergence level
    double maxDiff = 1.0;
    
    // Iterate while maximum number of iterations has not been
    // reached and requested convergence level has not been reached
    cout << "Starting inference algorithm..." << endl;
    for( size_t iter = 0; iter < maxIter && maxDiff > tol; iter++ ) {
        // Set magnetizations to beliefs
        for( size_t i = 0; i < fg.nrVars(); i++ )
            m[i] = ia->beliefV(i)[1] - ia->beliefV(i)[0];

        // For each pixel, calculate a color coded magnetization
        // and store it in the image for visualization
        for( size_t i = 0; i < dimx; i++ )
            for( size_t j = 0; j < dimy; j++ ) {
                unsigned char g = (unsigned char)((m[i*dimy+j] + 1.0) / 2.0 * 255.0);
                if( g > 127 ) {
                    image(i,j,0) = 255;
                    image(i,j,1) = 2 * (g - 127);
                    image(i,j,2) = 2 * (g - 127);
                } else {
                    image(i,j,0) = 0;
                    image(i,j,1) = 0;
                    image(i,j,2) = 2*g;
                }
            }

        // Display the image with the current beliefs
#ifndef NEW_CIMG
        disp << image;
#else
        disp = image;
#endif

        // Perform the requested inference algorithm for only one step
        ia->setMaxIter( iter + 1 );
        maxDiff = ia->run();

        // Output progress
        cout << "  Iterations = " << iter << ", maxDiff = " << maxDiff << endl;
    }
    cout << "Finished inference algorithm" << endl;

    // Clean up inference algorithm
    delete ia;

    // Return reached convergence level
    return maxDiff;
}



int main(int argc,char **argv) {
    cout << "This program is part of libDAI - http://www.libdai.org/" << endl;
    cout << "(Use the option -h for getting help with the command line arguments.)" << endl;
    // Display program usage, when invoked from the command line with option '-h'
    cimg_usage( "This example shows how libDAI can be used for a simple image segmentation task" );
    // Get command line arguments
    const char* file_i1 = cimg_option( "-i1", "example_img_in1.jpg", "Input image 1" );
    const char* file_i2 = cimg_option( "-i2", "example_img_in2.jpg", "Input image 2" );
    const char* file_o1 = cimg_option( "-o1", "example_img_out1.jpg", "Output image (local evidence)" );
    const char* file_o2 = cimg_option( "-o2", "example_img_out2.jpg", "Output image (magnetizations)" );
    const double J = cimg_option( "-J", 2.4, "Pairwise interaction strength (i.e., smoothing strength)" );
    const double th_min = cimg_option( "-thmin", -3.0, "Local evidence strength of background" );
    const double th_max = cimg_option( "-thmax", 3.2, "Local evidence strength of foreground" );
    const double scale = cimg_option( "-scale", 40.0, "Typical difference in pixel values between fore- and background" );
    const double pbg = cimg_option( "-pbg", 90.0, "Percentage of background in image" );
    const char *infname = cimg_option( "-method", "BP[updates=SEQMAX,maxiter=1,tol=1e-9,logdomain=0]", "Inference method in format name[key1=val1,...,keyn=valn]" );
    const size_t maxiter = cimg_option( "-maxiter", 100, "Maximum number of iterations for inference method" );
    const double tol = cimg_option( "-tol", 1e-9, "Desired tolerance level for inference method" );
    const char *file_fg = cimg_option( "-fg", "", "Output factor graph" );

    // Read input images
    cout << endl;
    cout << "Reading input image 1 (" << file_i1 << ")..." << endl;
    CImg<unsigned char> image1 = CImg<>( file_i1 );
    cout << "Reading input image 2 (" << file_i2 << ")..." << endl;
    CImg<unsigned char> image2 = CImg<>( file_i2 );

    // Check image sizes
#ifndef NEW_CIMG
    if( (image1.width != image2.width) || (image1.height != image2.height) )
        cerr << "Error: input images should have same size." << endl;
    size_t dimx = image1.width;
    size_t dimy = image1.height;
#else
    if( (image1.width() != image2.width()) || (image1.height() != image2.height()) )
        cerr << "Error: input images should have same size." << endl;
    size_t dimx = image1.width();
    size_t dimy = image1.height();
#endif

    // Display input images
    cout << "Displaying input image 1..." << endl;
    CImgDisplay disp1( image1, "Input image 1", 0 );
    cout << "Displaying input image 2..." << endl;
    CImgDisplay disp2( image2, "Input image 2", 0 );

    // Construct absolute difference image
    cout << "Constructing difference image..." << endl;
    CImg<int> image3( image1 );
    image3 -= image2;
    image3.abs();
    // Normalize difference image
    image3.norm( 1 ); // 1 = L1, 2 = L2, -1 = Linf

    // Normalize the difference by the average value of the background image
    for( size_t i = 0; i < dimx; i++ ) {
        for( size_t j = 0; j < dimy; j++ ) {
            int avg = 0;
#ifndef NEW_CIMG
            for( int c = 0; c < image1.dimv(); c++ )
                avg += image1( i, j, c );
            avg /= image1.dimv();
#else
            for( int c = 0; c < image1.spectrum(); c++ )
                avg += image1( i, j, c );
            avg /= image1.spectrum();
#endif
            image3( i, j, 0 ) /= (1.0 + avg / 255.0);
        }
    }
    image3.normalize( 0, 255 );

    // Display difference image
    cout << "Displaying difference image..." << endl;
    CImgDisplay disp3( image3, "Relative difference of both inputs", 0 );

    // Convert difference image into a factor graph and store
    // the local evidence in image4 for visualization
    CImg<unsigned char> image4( dimx, dimy, 1, 3 );
    cout << "Converting difference image into factor graph..." << endl;
    FactorGraph fg = img2fg( image3, J, th_min, th_max, scale, pbg, image4 );

    // Display local evidence
    cout << "Displaying local evidence..." << endl;
    CImgDisplay disp4( image4, "Local evidence", 0 );
    cout << "Saving local evidence as JPEG in " << file_o1 << endl;
    image4.save_jpeg( file_o1, 100 );
    if( strlen( file_fg ) > 0 ) {
        cout << "Saving factor graph as " << file_fg << endl;
        fg.WriteToFile( file_fg );
    }

    // Solve the inference problem and visualize intermediate steps
    CImgDisplay disp5( dimx, dimy, "Beliefs during inference", 0 );
    vector<double> m; // Stores the final magnetizations
    cout << "Solving the inference problem...please be patient!" << endl;
    doInference( fg, infname, maxiter, tol, m, dimx, dimy, disp5 );

    // Visualize the final magnetizations
    for( size_t i = 0; i < dimx; i++ )
        for( size_t j = 0; j < dimy; j++ ) {
            unsigned char g = (unsigned char)((m[i*dimy+j] + 1.0) / 2.0 * 255.0);
            if( g > 127 ) {
                image4(i,j,0) = image2(i,j,0);
                image4(i,j,1) = image2(i,j,1);
                image4(i,j,2) = image2(i,j,2);
            } else
#ifndef NEW_CIMG
                for( size_t c = 0; c < (size_t)image4.dimv(); c++ )
                    image4(i,j,c) = 255;
#else
                for( size_t c = 0; c < (size_t)image4.spectrum(); c++ )
                    image4(i,j,c) = 255;
#endif
        }
    cout << "Displaying the final result of the segmentation problem..." << endl;
    CImgDisplay main_disp( image4, "Foreground/background segmentation result", 0 );

    cout << "Saving the final result of the segmentation problem as JPEG in " << file_o2 << endl;
    image4.save_jpeg( file_o2, 100 );

    cout << "Close the last image display in order to finish." << endl;
#ifndef NEW_CIMG
    while( !main_disp.is_closed )
        cimg::wait( 40 );
#else
    while( !main_disp.is_closed() )
        cimg::wait( 40 );
#endif

    return 0;
}
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Region.png0000644000263000017630000000102411433220721017256 0ustar jorismkyb‰PNG  IHDRrˆÉú¢1PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfªIDATX…í—Qnà †á¥ÏØ7pvƒíB{êý0Œ1Њ¸-Ú²Hµ[!À|Ø8JľV-|nköñ^$õ°9‘tH2A0#eõØ'Rwß’À›‹›]˜‘-+$GÚZ"w$m°Éº¼òF̶aq•^%a Ir+‰i,Ru‹F2—BË d®E™É eW5[H¬1±’¤;Ôø{1Á&wÏ)µ%Ò(Ù"Ö!—}§¶Kæä9Éõ¯¦eÓû7äõûpòr½NþKmtÒI'ü=ÒõÊadØo³U¥à¸pNê:lsýB½GÊ¥( ¾RSfy£\ô‡|q•`‘]¹H_ZxŠlʱÔFÊE¬_ª?˜ÔŒeÊ&»ra`$ílGå"]¥ÊVm_0'ÏIº^q½â¤“N:éä‘$¬ZH‹ùÄw%ckšk¶ûœ¬Ëc0ìž„"ÂdîóT 9~‹ŒpŠå_œ©LÅê±H—Ú9“@Ò<$#¤šmbú2…ÔΙêÔ3$Ü‘ýœ6)µ­B7µµÉ™Íëc2.“æ+Nñ®œœ\þjþªÓˆVa¨'›IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1PropertySet.html0000644000263000017630000010561011433220721020521 0ustar jorismkyb libDAI: dai::PropertySet Class Reference

dai::PropertySet Class Reference

Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue). More...

#include <dai/properties.h>

List of all members.

Public Member Functions

Constructors and destructors
 PropertySet ()
 Default constructor.
 PropertySet (const std::string &s)
 Construct from a string.
Setting property keys/values
PropertySet & set (const PropertyKey &key, const PropertyValue &val)
 Sets a property (a key key with a corresponding value val).
PropertySet & set (const PropertySet &newProps)
 Set properties according to newProps, overriding properties that already exist with new values.
PropertySet operator() (const PropertyKey &key, const PropertyValue &val) const
 Shorthand for (temporarily) adding properties.
template<typename ValueType>
PropertySet & setAsString (const PropertyKey &key, const ValueType &val)
 Sets a property (a key key with a corresponding value val, which is first converted from ValueType to string).
template<typename ValueType>
void convertTo (const PropertyKey &key)
 Converts the type of the property value corresponding with key from string to ValueType (if necessary).
Queries
size_t size () const
 Return number of key-value pairs.
void clear ()
 Removes all key-value pairs.
size_t erase (const PropertyKey &key)
 Removes key-value pair with given key.
bool hasKey (const PropertyKey &key) const
 Check if a property with the given key is defined.
std::set< PropertyKey > keys () const
 Returns a set containing all keys.
const PropertyValue & get (const PropertyKey &key) const
 Gets the value corresponding to key.
template<typename ValueType>
ValueType getAs (const PropertyKey &key) const
 Gets the value corresponding to key, cast to ValueType.
template<typename ValueType>
ValueType getStringAs (const PropertyKey &key) const
 Gets the value corresponding to key, cast to ValueType, converting from a string if necessary.

Friends

Input/output
std::ostream & operator<< (std::ostream &os, const PropertySet &ps)
 Writes a PropertySet object to an output stream.
std::istream & operator>> (std::istream &is, PropertySet &ps)
 Reads a PropertySet object from an input stream.

Detailed Description

Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue).

Properties are used for specifying parameters of algorithms in a convenient way, where the values of the parameters can be of different types (e.g., strings, doubles, integers, enums). A PropertySet is an attempt to mimic the functionality of a Python dictionary object in C++, using the boost::any class.

A PropertySet can be converted to and from a string, using the following format:

[key1=val1,key2=val2,...,keyn=valn]

That is,

  • the whole PropertySet is wrapped in square brackets ("[", "]")
  • all properties in the PropertySet are seperated by a comma (",")
  • each Property consists of:
    • the name of the key
    • an equality sign ("=")
    • its value (represented as a string)

Also, a PropertySet provides functionality for converting the representation of individual values from some arbitrary type to and from std::string.

Note:
Not all types are automatically supported; if a type is unknown, an UNKNOWN_PROPERTY_TYPE exception is thrown. Adding support for a new type can be done in the body of the operator<<(std::ostream &, const Property &).
Examples:

example.cpp, example_sprinkler_em.cpp, and example_sprinkler_gibbs.cpp.

Constructor & Destructor Documentation

dai::PropertySet::PropertySet (  )  [inline]

Default constructor.

dai::PropertySet::PropertySet ( const std::string &  s  )  [inline]

Construct from a string.

Parameters:
s string in the format "[key1=val1,key2=val2,...,keyn=valn]"

Member Function Documentation

PropertySet& dai::PropertySet::set ( const PropertyKey &  key,
const PropertyValue &  val 
) [inline]

Sets a property (a key key with a corresponding value val).

Examples:
example.cpp, example_sprinkler_em.cpp, and example_sprinkler_gibbs.cpp.

PropertySet& dai::PropertySet::set ( const PropertySet &  newProps  )  [inline]

Set properties according to newProps, overriding properties that already exist with new values.

PropertySet dai::PropertySet::operator() ( const PropertyKey &  key,
const PropertyValue &  val 
) const [inline]

Shorthand for (temporarily) adding properties.

Example:
PropertySet p()("method","BP")("verbose",1)("tol",1e-9)

template<typename ValueType>
PropertySet& dai::PropertySet::setAsString ( const PropertyKey &  key,
const ValueType &  val 
) [inline]

Sets a property (a key key with a corresponding value val, which is first converted from ValueType to string).

The implementation makes use of boost::lexical_cast.

Template Parameters:
ValueType Type from which the value should be cast
Exceptions:
IMPOSSIBLE_TYPECAST if the type cast cannot be done

template<typename ValueType>
void dai::PropertySet::convertTo ( const PropertyKey &  key  )  [inline]

Converts the type of the property value corresponding with key from string to ValueType (if necessary).

The implementation makes use of boost::lexical_cast

Template Parameters:
ValueType Type to which the value should be cast
Exceptions:
IMPOSSIBLE_TYPECAST if the type cast cannot be done

size_t dai::PropertySet::size (  )  const [inline]

Return number of key-value pairs.

void dai::PropertySet::clear (  )  [inline]

Removes all key-value pairs.

size_t dai::PropertySet::erase ( const PropertyKey &  key  )  [inline]

Removes key-value pair with given key.

bool dai::PropertySet::hasKey ( const PropertyKey &  key  )  const [inline]

Check if a property with the given key is defined.

std::set<PropertyKey> dai::PropertySet::keys (  )  const [inline]

Returns a set containing all keys.

const PropertyValue& dai::PropertySet::get ( const PropertyKey &  key  )  const [inline]

Gets the value corresponding to key.

Exceptions:
OBJECT_NOT_FOUND if the key cannot be found in *this

template<typename ValueType>
ValueType dai::PropertySet::getAs ( const PropertyKey &  key  )  const [inline]

Gets the value corresponding to key, cast to ValueType.

Template Parameters:
ValueType Type to which the value should be cast
Exceptions:
OBJECT_NOT_FOUND if the key cannot be found in *this
IMPOSSIBLE_TYPECAST if the type cast cannot be done

template<typename ValueType>
ValueType dai::PropertySet::getStringAs ( const PropertyKey &  key  )  const [inline]

Gets the value corresponding to key, cast to ValueType, converting from a string if necessary.

If the type of the value is already equal to ValueType, no conversion is done. Otherwise, the type of the value should be a std::string, in which case boost::lexical_cast is used to convert this to ValueType.

Template Parameters:
ValueType Type to which the value should be cast/converted
Exceptions:
OBJECT_NOT_FOUND if the key cannot be found in *this
IMPOSSIBLE_TYPECAST if the type cast cannot be done

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const PropertySet &  ps 
) [friend]

Writes a PropertySet object to an output stream.

It uses the format "[key1=val1,key2=val2,...,keyn=valn]".

Note:
Only a subset of all possible types is supported (see the implementation of this function). Adding support for more types has to be done by hand.
Exceptions:
UNKNOWN_PROPERTY_TYPE if the type of a property value is not supported.

std::istream& operator>> ( std::istream &  is,
PropertySet &  ps 
) [friend]

Reads a PropertySet object from an input stream.

It expects a string in the format "[key1=val1,key2=val2,...,keyn=valn]". Values are stored as strings.

Exceptions:
MALFORMED_PROPERTY if the string is not in the expected format

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x74.html0000644000263000017630000001576711433220721016664 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- t -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BP__dual_1_1__edges__t.html0000644000263000017630000000502111433220721022530 0ustar jorismkyb libDAI: dai::BP_dual::_edges_t< T > Struct Template Reference

dai::BP_dual::_edges_t< T > Struct Template Reference

Convenience label for storing edge properties. More...

#include <dai/bp_dual.h>

Inherits std::vector< T >.

List of all members.

Detailed Description

template<class T>
struct dai::BP_dual::_edges_t< T >

Convenience label for storing edge properties.
The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/clustergraph_8h-source.html0000644000263000017630000013711511433220721020462 0ustar jorismkyb libDAI: include/dai/clustergraph.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/examples.html0000644000263000017630000000372311433220721015675 0ustar jorismkyb libDAI: Examples

Examples

Here is a list of all examples:
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_5.png0000644000263000017630000000241311433220721015061 0ustar jorismkyb‰PNG  IHDR $ÛKú0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf‰IDATX…íW]lUþfv~v‡îOƒ¦%ÄvTŒJ0™Z4v” ¨Á F~¬NÕ A£A‰¾¸h!\P‹>4PŠì #1>Ñ„õmÑ„'|lkðÅŸŽçÜ™vggvÙînŸ_2÷νçÜ{¾9çþœn຅ìý4>>~lÆË5ÓTÎx¤yn¾hçæIpñßüò0:3+ª×bvbP=*†gãão*>˜nÕrdÿñ뉦ډF„’‚ÐD\pM$ƒ:êØ„çˆúæ…Õ¤B7ãêËLh!$½QÁ;sµíß.QñÂB+¤¾¼„…àň£ë¿š¦®ûè»'mµ,Ñ5óEñ–qrÒ–*¼ ɯøzqøºšÙ°'Õ‚ú롇Ø[j5¶K'ä'G­"ëß¡·:ûœ\€K."'A=Ãwcèn¸ž¼û<Ø­eÖæedTE­žCdEe#m.öm –ëµ1¬ŽK[ðY \¨à.rÞfÁà«\X½UBë/™ø¸$–$õ«à¸ÃÿÍBL½Ý“ZÙÕHR)ÿ’ÛPi¢×>¡§‘¤.ž≠è5O¯ Ϧôéj\Ðç™fþlÉlcÌxóM•c¥Óx´TŠgŒ¥Ò)ì)•–)c¼ë7ÑC—¸ü^T°ž1zôÖöT[Ðl¬Àºb’×mÿ2ÝŽâ°{ÂeAª¢î¤íïbíqüÜ¡—«Yn…+×EòÐ(ô9Þtº¼'œ¾Y_p6a ¦DˆŽý™ûåÉŠð‚»˜wG°Û©|›Ô ˜Ð‹>¡ B 1SÕfBt}u@H:*ã•n›&³ü›¥þÏ¢’Á7ƒpû{pM:w;ÊF¼f>‚ÁÌNÈ,xÜääe¿Ù6¡—Î:Øû=ÔQÊYRÐ ÑŸÅôaj÷(ò©_83ߌ”‹ItQ”ÌËBà*p´`µ‰ÃÀ§mó$A¶NCwi‹<ÅÁ'õõváa* ”–ÜÏk…BöåèÐߘ‚"®àé­j Ù•ŽBþ½èå_¯ ™ê6N@ûü]eå¿yU¡A±†6‰')‰7˜iÒUžê”ƒâ ]k MQ·$’yŒWu‚ÿŒÒÐðSmr5¡yÚÐ [sLéA¢e.EÝÁ¢özMŸþœìãW«î¨VÐÝñ Íñ?‘—:|Ï…‚IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1ExactInf.html0000644000263000017630000012517711433220721017734 0ustar jorismkyb libDAI: dai::ExactInf Class Reference

dai::ExactInf Class Reference

Exact inference algorithm using brute force enumeration (mainly useful for testing purposes). More...

#include <dai/exactinf.h>

Inheritance diagram for dai::ExactInf:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

Constructors/destructors
 ExactInf ()
 Default constructor.
 ExactInf (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual ExactInf * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
std::vector< std::size_t > findMaximum () const
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for ExactInf
Factor calcMarginal (const VarSet &vs) const
 Calculates marginal probability distribution for variables vs.

Public Attributes

struct dai::ExactInf::Properties props

Static Public Attributes

static const char * Name = "EXACT"
 Name of this inference algorithm.

Private Member Functions

void construct ()
 Helper function for constructors.

Private Attributes

std::vector< Factor > _beliefsV
 All single variable marginals.
std::vector< Factor > _beliefsF
 All factor variable marginals.
Real _logZ
 Logarithm of partition sum.

Classes

struct  Properties
 Parameters for ExactInf. More...

Detailed Description

Exact inference algorithm using brute force enumeration (mainly useful for testing purposes).

Inference is done simply by multiplying all factors together into one large factor, and then calculating marginals and partition sum from the product.

Note:
This inference method can easily exhaust all available memory; in that case, one may try the JTree class instead.

Constructor & Destructor Documentation

dai::ExactInf::ExactInf (  )  [inline]

Default constructor.

dai::ExactInf::ExactInf ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties

Member Function Documentation

virtual ExactInf* dai::ExactInf::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::ExactInf::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::ExactInf::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::ExactInf::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

virtual Factor dai::ExactInf::beliefV ( size_t  i  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual Factor dai::ExactInf::beliefF ( size_t  I  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

vector< Factor > dai::ExactInf::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::ExactInf::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

std::vector< std::size_t > dai::ExactInf::findMaximum (  )  const [virtual]

Note:
The complexity of this calculation is exponential in the number of variables.

Reimplemented from dai::InfAlg.

void dai::ExactInf::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::ExactInf::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::ExactInf::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::ExactInf::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::ExactInf::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::ExactInf::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::ExactInf::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::ExactInf::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Factor dai::ExactInf::calcMarginal ( const VarSet &  vs  )  const

Calculates marginal probability distribution for variables vs.

Note:
The complexity of this calculation is exponential in the number of variables.

void dai::ExactInf::construct (  )  [private]

Helper function for constructors.

Member Data Documentation

const char * dai::ExactInf::Name = "EXACT" [static]

Name of this inference algorithm.

std::vector<Factor> dai::ExactInf::_beliefsV [private]

All single variable marginals.

std::vector<Factor> dai::ExactInf::_beliefsF [private]

All factor variable marginals.

Real dai::ExactInf::_logZ [private]

Logarithm of partition sum.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/lc_8h-source.html0000644000263000017630000006423411433220721016356 0ustar jorismkyb libDAI: include/dai/lc.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1IndexFor-members.html0000644000263000017630000001025311433220721021365 0ustar jorismkyb libDAI: Member List

dai::IndexFor Member List

This is the complete list of members for dai::IndexFor, including all inherited members.

_indexdai::IndexFor [private]
_rangesdai::IndexFor [private]
_statedai::IndexFor [private]
_sumdai::IndexFor [private]
IndexFor()dai::IndexFor [inline]
IndexFor(const VarSet &indexVars, const VarSet &forVars)dai::IndexFor [inline]
operator size_t() const dai::IndexFor [inline]
operator++()dai::IndexFor [inline]
operator++(int)dai::IndexFor [inline]
reset()dai::IndexFor [inline]
valid() const dai::IndexFor [inline]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_12.png0000644000263000017630000000042111433220721015134 0ustar jorismkyb‰PNG  IHDR/†¥‹©0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIDAT•c`  àÄ!ÎÜ=»SÏ$Å–á•€$*Vê«ÈÉb%ðk0é™@PäÚó@”ðu!tøÀ™@–"2Úé0uÓYXü€tXZZšSÀ#Vf°Û>MeŒ„kg¿|X…! Ìtf6`x¨— bQ`Ë„ó–£zäŸ3]Á!Á˜$ŸUfß„þµIEND®B`‚libDAI-0.2.7/doc/html/form_37.png0000644000263000017630000000031711433220721015147 0ustar jorismkyb‰PNG  IHDR <ð0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfMIDAT™c`@ÌP›Ž×«€_Ì!”g`¨€°¢ƒhÆËØ°8100}Étf> É ‘ç(†²‹‚`¦óÞ±Õ ³RUŠIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1Gibbs-members.html0000644000263000017630000003354711433220721020710 0ustar jorismkyb libDAI: Member List

dai::Gibbs Member List

This is the complete list of members for dai::Gibbs, including all inherited members.

_count_t typedefdai::Gibbs [private]
_factor_countsdai::Gibbs [private]
_itersdai::Gibbs [private]
_max_scoredai::Gibbs [private]
_max_statedai::Gibbs [private]
_sample_countdai::Gibbs [private]
_statedai::Gibbs [private]
_state_t typedefdai::Gibbs [private]
_var_countsdai::Gibbs [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::Gibbs [inline, virtual]
belief(const VarSet &vs) const dai::Gibbs [virtual]
beliefF(size_t I) const dai::Gibbs [virtual]
beliefs() const dai::Gibbs [virtual]
beliefV(size_t i) const dai::Gibbs [virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::Gibbs [inline, virtual]
construct()dai::Gibbs [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::Gibbs [inline, virtual]
getFactorEntry(size_t I)dai::Gibbs [private]
getFactorEntryDiff(size_t I, size_t i)dai::Gibbs [private]
getGibbsState(const FactorGraph &fg, size_t maxiter)dai::Gibbs [related]
getProperties() const dai::Gibbs [virtual]
getVarDist(size_t i)dai::Gibbs [private]
Gibbs()dai::Gibbs [inline]
Gibbs(const FactorGraph &fg, const PropertySet &opts)dai::Gibbs [inline]
identify() const dai::Gibbs [inline, virtual]
init()dai::Gibbs [virtual]
init(const VarSet &)dai::Gibbs [inline, virtual]
Iterations() const dai::Gibbs [inline, virtual]
logZ() const dai::Gibbs [inline, virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::Gibbs [inline, virtual]
Namedai::Gibbs [static]
printProperties() const dai::Gibbs [virtual]
props (defined in dai::Gibbs)dai::Gibbs
randomizeState()dai::Gibbs
resampleVar(size_t i)dai::Gibbs [private]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::Gibbs [virtual]
setMaxIter(size_t maxiter)dai::Gibbs [inline, virtual]
setProperties(const PropertySet &opts)dai::Gibbs [virtual]
state()dai::Gibbs [inline]
state() const dai::Gibbs [inline]
updateCounts()dai::Gibbs [private]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x69.html0000644000263000017630000003267311433220721016663 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- i -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/exactinf_8h-source.html0000644000263000017630000004632011433220721017555 0ustar jorismkyb libDAI: include/dai/exactinf.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/exceptions_8h.html0000644000263000017630000003063211433220721016636 0ustar jorismkyb libDAI: include/dai/exceptions.h File Reference

include/dai/exceptions.h File Reference

Defines the Exception class and macros for throwing exceptions and doing assertions. More...

#include <exception>
#include <stdexcept>
#include <string>
#include <iostream>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Exception
 Error handling in libDAI is done by throwing an instance of the Exception class. More...

Defines

#define DAI_QUOTE(x)   #x
 Used by DAI_THROW.
#define DAI_TOSTRING(x)   DAI_QUOTE(x)
 Used by DAI_THROW.
#define DAI_THROW(cod)   throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)))
 Macro that simplifies throwing an exception with a useful default error message.
#define DAI_THROWE(cod, msg)   throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)), msg)
 Macro that simplifies throwing an exception with a user-defined error message.
#define DAI_ASSERT(condition)   ((condition) ? ((void)0) : DAI_THROWE(ASSERTION_FAILED, std::string("Assertion \"" #condition "\" failed")))
 Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is defined.
#define DAI_DEBASSERT(x)   do {DAI_ASSERT(x);} while(0)
 Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.

Detailed Description

Defines the Exception class and macros for throwing exceptions and doing assertions.

Define Documentation

#define DAI_QUOTE ( x   )     #x

Used by DAI_THROW.

#define DAI_TOSTRING ( x   )     DAI_QUOTE(x)

Used by DAI_THROW.

#define DAI_THROW ( cod   )     throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)))

Macro that simplifies throwing an exception with a useful default error message.

The error message consists of a description of the exception, the source code file and line number where the exception has been thrown.

Parameters:
cod Corresponds to one of the enum values of dai::Exception::Code
Example:
  DAI_THROW(NOT_IMPLEMENTED);

#define DAI_THROWE ( cod,
msg   )     throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)), msg)

Macro that simplifies throwing an exception with a user-defined error message.

Parameters:
cod Corresponds to one of the enum values of dai::Exception::Code
msg Detailed error message that will be written to std::cerr.
Example:
  DAI_THROWE(NOT_IMPLEMENTED,"Detailed error message");
Examples:
uai2010-aie-solver.cpp.

#define DAI_ASSERT ( condition   )     ((condition) ? ((void)0) : DAI_THROWE(ASSERTION_FAILED, std::string("Assertion \"" #condition "\" failed")))

Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is defined.

Examples:
example_bipgraph.cpp, example_permute.cpp, and example_varset.cpp.

#define DAI_DEBASSERT ( x   )     do {DAI_ASSERT(x);} while(0)

Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1Neighbor-members.html0000644000263000017630000000570111433220721021625 0ustar jorismkyb libDAI: Member List

dai::Neighbor Member List

This is the complete list of members for dai::Neighbor, including all inherited members.

dualdai::Neighbor
iterdai::Neighbor
Neighbor()dai::Neighbor [inline]
Neighbor(size_t iter, size_t node, size_t dual)dai::Neighbor [inline]
nodedai::Neighbor
operator size_t() const dai::Neighbor [inline]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__plog0p-members.html0000644000263000017630000000360211433220721022112 0ustar jorismkyb libDAI: Member List

dai::fo_plog0p< T > Member List

This is the complete list of members for dai::fo_plog0p< T >, including all inherited members.

operator()(const T &p) const dai::fo_plog0p< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__max-members.html0000644000263000017630000000360011433220721021474 0ustar jorismkyb libDAI: Member List

dai::fo_max< T > Member List

This is the complete list of members for dai::fo_max< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_max< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_130.png0000644000263000017630000000032511433220721015220 0ustar jorismkyb‰PNG  IHDRÝê!Ã0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfSIDAT™c`@Œ p¦zœy Æbi€3yÔàòüfp¦^œiÃÀÀ¬À`bf10”ÎÒP22¹X•8>08€,s`R`?ÁÕaRľa;†„ ×®eX$IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1FRegion.html0000644000263000017630000002147111433220721017554 0ustar jorismkyb libDAI: dai::FRegion Class Reference

dai::FRegion Class Reference

An FRegion is a factor with a counting number. More...

#include <dai/regiongraph.h>

Inheritance diagram for dai::FRegion:

dai::TFactor< T >

List of all members.

Public Member Functions

 FRegion ()
 Default constructor.
 FRegion (const Factor &x, Real c)
 Constructs from a factor and a counting number.
const Real & c () const
 Returns constant reference to counting number.
Real & c ()
 Returns reference to counting number.

Private Attributes

Real _c
 Counting number.

Detailed Description

An FRegion is a factor with a counting number.

Constructor & Destructor Documentation

dai::FRegion::FRegion (  )  [inline]

Default constructor.

dai::FRegion::FRegion ( const Factor &  x,
Real  c 
) [inline]

Constructs from a factor and a counting number.

Member Function Documentation

const Real& dai::FRegion::c (  )  const [inline]

Returns constant reference to counting number.

Real& dai::FRegion::c (  )  [inline]

Returns reference to counting number.

Member Data Documentation

Real dai::FRegion::_c [private]

Counting number.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/bbp_8h-source.html0000644000263000017630000016100011433220721016510 0ustar jorismkyb libDAI: include/dai/bbp.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1BP-members.html0000644000263000017630000004133211433220721020152 0ustar jorismkyb libDAI: Member List

dai::BP Member List

This is the complete list of members for dai::BP, including all inherited members.

_edge2lutdai::BP [protected]
_edgesdai::BP [protected]
_itersdai::BP [protected]
_lutdai::BP [protected]
_maxdiffdai::BP [protected]
_oldBeliefsFdai::BP [protected]
_oldBeliefsVdai::BP [protected]
_sentMessagesdai::BP [protected]
_updateSeqdai::BP [protected]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::BP [inline, virtual]
belief(const VarSet &vs) const dai::BP [virtual]
beliefF(size_t I) const dai::BP [virtual]
beliefs() const dai::BP [virtual]
beliefV(size_t i) const dai::BP [virtual]
BP()dai::BP [inline]
BP(const FactorGraph &fg, const PropertySet &opts)dai::BP [inline]
BP(const BP &x)dai::BP [inline]
calcBeliefF(size_t I, Prob &p) const dai::BP [inline, protected, virtual]
calcBeliefV(size_t i, Prob &p) const dai::BP [protected, virtual]
calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const dai::BP [protected, virtual]
calcNewMessage(size_t i, size_t _I)dai::BP [protected, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clearSentMessages()dai::BP [inline]
clone() const dai::BP [inline, virtual]
construct()dai::BP [protected, virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::BP [inline, virtual]
findMaxResidual(size_t &i, size_t &_I)dai::BP [protected]
getProperties() const dai::BP [virtual]
getSentMessages() const dai::BP [inline]
identify() const dai::BP [virtual]
ind_t typedefdai::BP [protected]
index(size_t i, size_t _I) const dai::BP [inline, protected]
index(size_t i, size_t _I)dai::BP [inline, protected]
init()dai::BP [virtual]
init(const VarSet &ns)dai::BP [virtual]
Iterations() const dai::BP [inline, virtual]
logZ() const dai::BP [virtual]
LutType typedefdai::BP [protected]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::BP [inline, virtual]
message(size_t i, size_t _I) const dai::BP [inline, protected]
message(size_t i, size_t _I)dai::BP [inline, protected]
Namedai::BP [static]
newMessage(size_t i, size_t _I) const dai::BP [inline, protected]
newMessage(size_t i, size_t _I)dai::BP [inline, protected]
operator=(const BP &x)dai::BP [inline]
printProperties() const dai::BP [virtual]
props (defined in dai::BP)dai::BP
recordSentMessagesdai::BP
residual(size_t i, size_t _I) const dai::BP [inline, protected]
residual(size_t i, size_t _I)dai::BP [inline, protected]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::BP [virtual]
setMaxIter(size_t maxiter)dai::BP [inline, virtual]
setProperties(const PropertySet &opts)dai::BP [virtual]
updateMessage(size_t i, size_t _I)dai::BP [protected]
updateResidual(size_t i, size_t _I, Real r)dai::BP [protected]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_31.png0000644000263000017630000000034011433220721015135 0ustar jorismkyb‰PNG  IHDRC"[0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf^IDAT™c`@ʦvÙ\8ûƒ ŒÉüÆfúi€PŸ÷?Áaÿc‰20<`T„¨ c`-pél`±÷$w2,fà±Ì.8pÁô”·˜!9ª‰-ÂÀaM¼bÆÅIEND®B`‚libDAI-0.2.7/doc/html/form_3.png0000644000263000017630000000026011433220721015055 0ustar jorismkyb‰PNG  IHDR F‡Z­0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf.IDAT™c`€Œ0ÅsLñ'€)y0UQrB}“LÀ„šµn)Æ3§zKIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1BP.png0000644000263000017630000000160011433220721016334 0ustar jorismkyb‰PNG  IHDRÀ à¡PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfIDATxœíÜmnÛ0 `ú;ä è]`Ø€§À€Üÿ‹$Ó¦3¹ŠkEâ–÷mb4²Ÿ(rê†Q†¡˜Ÿçò½¼…òc: €h‡`]H¼Hñ÷@LŠ¸-DZ#„y"ž{‚)üž$í,,aóñDa1R¼Ð:A´',¢eO„ž§ ‚¨B¶=!Szz:Œ‰¿ ÇDÚ;8 LƒhºwìÇ¢é˜Ø e^4ÿó?`@¼6ÂÅ!!ï-6RŠ Äõ£·`ðx¿^{œ | L 4@h€Ð¡B„  4@h€Ð¡iƒpñ&‰‹·‹€"‹eAñ]t6§%D“„ódkµ1¼–AáR<ódJ@õ$·Ç˜$¼nþ®Ê y"V?'-7¥ú£þÄ—°EHä¥+k"ÂJyí‰ BæÍ…ÂX3"]]!d± ºC“!Þï9qºkTTE°é ­@j1T{b˜Š¨Ýdkt)†J2#ÒÓWyL¤½CÒ&‰7S %Þ ª¿N|–LÒ¤ "[ mÈC›# ˆç \òòBÿâ¡$éá¢$éác`¡B„  4@h€Ð¡B„MË¥ âäZ€¢-b\aØÝ  æ{ŒñÜAã0RÚr7Ä8Ðí–ËOýa£—¾c" Fº˜§ãPózˆËÐAýiïãÀ ã¡¢Qs €â_@¸8ä/ä…þ+ÄCIÒÂEIÒÂÇÀB„ šˆÛ«òù|œEÔx$@@ÄÓ…~ÿzä£áo…;ý.Ü^åCòoçÖñ  DØ顧~Q~~Ñbi/·öiiøɯèSDLšþ(išè1„®` –_Ñb;=ô8´ÿ2ânzèa„m?#æ/6=„X§‡êÓxdLØöa£¾{™yoEû3=t~Ùì"´½ÎªŒˆüŠöfzè—lzb•BÐIGØé¡¡ Í_)ý(妧 ò+rýŠ @8AŽÆKyè¿”?¬ý|?^  IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1PropertySet-members.html0000644000263000017630000001421511433220721022151 0ustar jorismkyb libDAI: Member List

dai::PropertySet Member List

This is the complete list of members for dai::PropertySet, including all inherited members.

clear()dai::PropertySet [inline]
convertTo(const PropertyKey &key)dai::PropertySet [inline]
erase(const PropertyKey &key)dai::PropertySet [inline]
get(const PropertyKey &key) const dai::PropertySet [inline]
getAs(const PropertyKey &key) const dai::PropertySet [inline]
getStringAs(const PropertyKey &key) const dai::PropertySet [inline]
hasKey(const PropertyKey &key) const dai::PropertySet [inline]
keys() const dai::PropertySet [inline]
operator()(const PropertyKey &key, const PropertyValue &val) const dai::PropertySet [inline]
operator<<(std::ostream &os, const PropertySet &ps)dai::PropertySet [friend]
operator>>(std::istream &is, PropertySet &ps)dai::PropertySet [friend]
PropertySet()dai::PropertySet [inline]
PropertySet(const std::string &s)dai::PropertySet [inline]
set(const PropertyKey &key, const PropertyValue &val)dai::PropertySet [inline]
set(const PropertySet &newProps)dai::PropertySet [inline]
setAsString(const PropertyKey &key, const ValueType &val)dai::PropertySet [inline]
size() const dai::PropertySet [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/namespaces.html0000644000263000017630000000312511433220721016172 0ustar jorismkyb libDAI: Namespace Index

Namespace List

Here is a list of all documented namespaces with brief descriptions:
daiNamespace for libDAI
Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_128.png0000644000263000017630000000231711433220721015232 0ustar jorismkyb‰PNG  IHDR$ŠßÉr0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfMIDATX…í—ïkEÇ¿ûãîö®w¹më‹‹$ÑjÚdmÀ6W¬ 5B[¤‹¥k_lÓz¢.6 ô…xÔßœh*[„žØ4ø"úþD_¦µyá»Düî°¨ôMœgv··w{{¹šCEú¼Ø™Ùùî>ŸyfžYà¡ýOL»_X»çºîÚ=£ÊDW²¿iê*n4ëü²ÆÚ WÐ,jR‡>½Q½i´òÂA¨»‚J˜#*&7 P²$Š'ƒf“|˜Z)æ£:‚£ŒÙJœƒ§F0¥wËñõ vƒª&ŠrÐ.‡”ÒÏäñTÐœ$ÙÉ2C½ÝÞŸ¶Y¼éºV‹¢u¿©V骙Aûõ4uƒñëbÐÜDú¥ÔÞÁ’„¯¼ÚúY]¢7–>M‚7Ä|m #ó™@ÂÌMCù•¥¡q4£ÕÂCã'Qõ¾îNÈm„c‹dȆ2cK¹Æ½¾wéÉ,0ýýuxDèÿFŸ „K×ÔÀþkÏSWÒ–6S˜ê$oq°ÿǧ>J·±Ç[ŽLOñrû™Ër‘BývŸ@Žëm宓¼ŽWŒœ.ÙŸ à‰i(øñ3ÁZœ¬i‹}¼&EÂ1Ê¡ì´óì`‹è~ÇUøjÂ1q˜¸$úÆ€×Ä«|Rl#¼ØBR圕"´<öá‹ÑÇRuâHðx„pka̤¾ãD@7êQpÄ8ÈrŠcç¼Â#9Fqž–ÖžsþøÐC³Z…DÛ2¶Í¿^ćƒË«$˜#ÍÔNÔ’„˜²ã9迳ñƒß³µ#ÇY K6²þØÊÔÕŒF"‹±?7hü)ضŸgû(N—i²¥Ì•Ë&!fX<Çcüå\%6#ÙŠ‘yv5ù&±Ó`/ø·ùÔ'½ù3TzÏ°š˜¬Eð•Nˆ¡Õã@^¡k¿>4ßQæÛNÁa'Fý®—,$îEΉm”¯Çeàôº©²ÊSë—&V»á˜£­×ýáøîÞº7éI%{]Ž¬Ö]ÍÛi ‡¼ô *к„Ø"úq¡–;Ê<› ¶€ùÖžµwþ䣵VŠÜW±nd¾}PÝ ÆÀÂÂgÒŅ둃–du%ómhƒí¿i^9‹¬µíç…‰6 yc¶\ï±q¦,ègx_1ÅF¹8l©•cÈ–8ž©Ú±’Ûxµhà mŽÏ‚’úsѤ½QšÏù›ƒb$5‰ö3§>ñÛS ­¼çXÝäºFo;þ™4bjU;ÉçŹhót‘4d¾oþéJ¯9V(ñ¤7c8ä´“š-Š1Xæ§8©„ |„ Ýè1Ï!Æõ=,¹ÒV°c4/Ò%u’µu©çóB9D)ŠE¨•Ú*“¯Ò9sØägçO)P ~¹çÍ9$Ö6{E™u/ÕšSñ?lGM:hˆ¿ÙÝÿ"Æúöý#!Æœt>IEND®B`‚libDAI-0.2.7/doc/html/form_125.png0000644000263000017630000000050411433220721015223 0ustar jorismkyb‰PNG  IHDR'áf ½0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÂIDAT•c` 0*`?€M)6ýJ@Ì.a³AÅX{DLW„æ·²À´C˜Ó&¨ &YöOf`àa`0› âòBäªøzôÀ‚—3°(ð%¦3 >fbªdxÄÀÀ,üÀ'ÀÃÀbð•a⨙Lu¸xZ/81Ü Y rû†¥,Œ" œLÂÀþºeÀЮÀv libDAI: include/dai/exceptions.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/fbp_8h-source.html0000644000263000017630000003426011433220721016523 0ustar jorismkyb libDAI: include/dai/fbp.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_93.png0000644000263000017630000000061311433220721015150 0ustar jorismkyb‰PNG  IHDR` o€¥*0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf IDAT(‘c` 0CL JX¤•˜PØt¼&@XÎËí1Õ³X@)àsp 2º%ÔÐ5ˆqlœÀPÉà ¶†ÅDÊ305h€%—10eaXÁ•ÀÀPk f[%€ÈhŽ>0ÿ#PC¿Cé°J B C,cihcàHüÀÔÀx€Œ8&0°L`h“gH`rø\×Àô%Ó™=—a×Ò%@ LOX€çÖ «¢\Ør fÎœiÀ±èsF°“„‘ÜãÀÀÈ ÀÀÎÀï· L ¾bÊp`H@Òa[(°B¸æÉ),,&Œ ÓO.¾´–PIEND®B`‚libDAI-0.2.7/doc/html/functions_0x67.html0000644000263000017630000002066311433220721016655 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- g -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1IndexFor.html0000644000263000017630000004115011433220721017735 0ustar jorismkyb libDAI: dai::IndexFor Class Reference

dai::IndexFor Class Reference

Tool for looping over the states of several variables. More...

#include <dai/index.h>

List of all members.

Public Member Functions

 IndexFor ()
 Default constructor.
 IndexFor (const VarSet &indexVars, const VarSet &forVars)
 Construct IndexFor object from indexVars and forVars.
IndexFor & reset ()
 Resets the state.
 operator size_t () const
 Conversion to size_t: returns linear index of the current state of indexVars.
IndexFor & operator++ ()
 Increments the current state of forVars (prefix).
void operator++ (int)
 Increments the current state of forVars (postfix).
bool valid () const
 Returns true if the current state is valid.

Private Attributes

long _index
 The current linear index corresponding to the state of indexVars.
std::vector< long > _sum
 For each variable in forVars, the amount of change in _index.
std::vector< size_t > _state
 For each variable in forVars, the current state.
std::vector< size_t > _ranges
 For each variable in forVars, its number of possible values.

Detailed Description

Tool for looping over the states of several variables.

The class IndexFor is an important tool for indexing Factor entries. Its usage can best be explained by an example. Assume indexVars, forVars are both VarSet 's. Then the following code: 

      IndexFor i( indexVars, forVars );
      size_t iter = 0;
      for( ; i.valid(); i++, iter++ ) {
          cout << "State of forVars: " << calcState( forVars, iter ) << "; ";
          cout << "state of indexVars: " << calcState( indexVars, size_t(i) ) << endl;
      }
loops over all joint states of the variables in forVars, and (size_t)i equals the linear index of the corresponding state of indexVars, where the variables in indexVars that are not in forVars assume their zero'th value.
Idea:
Optimize all indices as follows: keep a cache of all (or only relatively small) indices that have been computed (use a hash). Then, instead of computing on the fly, use the precomputed ones. Here the labels of the variables don't matter, but the ranges of the variables do.

Constructor & Destructor Documentation

dai::IndexFor::IndexFor (  )  [inline]

Default constructor.

dai::IndexFor::IndexFor ( const VarSet &  indexVars,
const VarSet &  forVars 
) [inline]

Construct IndexFor object from indexVars and forVars.

Member Function Documentation

IndexFor& dai::IndexFor::reset (  )  [inline]

Resets the state.

dai::IndexFor::operator size_t (  )  const [inline]

Conversion to size_t: returns linear index of the current state of indexVars.

IndexFor& dai::IndexFor::operator++ (  )  [inline]

Increments the current state of forVars (prefix).

void dai::IndexFor::operator++ ( int   )  [inline]

Increments the current state of forVars (postfix).

bool dai::IndexFor::valid (  )  const [inline]

Returns true if the current state is valid.

Member Data Documentation

long dai::IndexFor::_index [private]

The current linear index corresponding to the state of indexVars.

std::vector<long> dai::IndexFor::_sum [private]

For each variable in forVars, the amount of change in _index.

std::vector<size_t> dai::IndexFor::_state [private]

For each variable in forVars, the current state.

std::vector<size_t> dai::IndexFor::_ranges [private]

For each variable in forVars, its number of possible values.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__inv-members.html0000644000263000017630000000356011433220721021510 0ustar jorismkyb libDAI: Member List

dai::fo_inv< T > Member List

This is the complete list of members for dai::fo_inv< T >, including all inherited members.

operator()(const T &x) const dai::fo_inv< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_9.png0000644000263000017630000000352611433220721015073 0ustar jorismkyb‰PNG  IHDR†&2Å!Œ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÔIDATX…íYklU>óØÙíngE”¨LQÄG±+…HÐI[¨6%L­Õ& 1` +(ÒÊ‚›&†Ä˜’6Ö6¦D©Å,ª’·1ø—•±‹<}­çÞ;¯m»·Ä•ÄïÇ}sîœï>ΙÙøƒfÖj}(§´’T³ÿBÅ<™Æh¹Âêú*æÈ4¡eÂêú•r¤|p ,ù8ˆ‹H_ŒUÖŸràI®!ešVÖëØâv¨ øõFh×eŒe"xRùuùì7ýýýÏgC§¬ÿµú?ÈfÊrÈe}üižÍ;JèUxtctŠäGÓ´ÚZxR–VÞk%ûǺþ2m.I1©†¯Ñ{É8ÅCOS²€²ò;«ãN>!àT«æI™aÞX£¢©6ÅöM!r¬½Y6q«-«5kÜði8BÜ›ÌH `¾@ÿàyÇÃŽ½†Ý²:­o!ù„s† X…G{vsì7^bŽéà§;ÖbêEÚ#–Ñ$‘ÇŽ§hÓ ð4 —¼e= Ùå<ÿYp¯Â`«†‡ $âeÐq{ô¦;ugþ]Ö__vsð^ß ±/ÙF"+ÂYGo€‡|"[à\·Ù¿Y-…ŽÙ;ëEJ}àlÐV·©æâ_\ª?ÍFà‡[A¡† |gH?™È¯ZÖn“D6lkÜwÍbC˧,‰ž9æí1Ó³°/]Œß‚å‹tàÕ ûsÙ(£ŸÈAÑêÌ쫦DYë˜[Û=YC\— ‹Z [äÑš™È†m °ßÚ÷µËIy K¤š”ÃÜ;»ç ³¡3«¹í& •4/R-Ì'¹îö'(ؽ~³kqMï^û鱊"‡:øXŠ~fX"0Æv1‘3½úξ¿ç'Ž%Á+PZ˜ú<±šÐIå˜A#ÃJˆxé'ËmBÐ[åc‡•ÄâŸ1`&réb6×o du ^Êô0H¼ãc°.hôÙ"OèÌÍ°€… ‡íÌÂeÍ[ü£Çä•‚™rLã{U؇”?ž!ǾaÐ×àÆ ì„Ï¡ñ!zÎœ×Ý6c 86‡j[`ˆOó°„]¹0ãpgE‡‰(*å@¸­«RŒK:Ãä…þOåÐ’Ó_V«xT&!Š6\€Cr+²ñ¤¡§ Ó³ðÔMKiâ>D`U„ï ¨šd^¢q)¹œ8*ÅB „å°Jê2ŸâEˆHN'¨²'Œ(aôÏ„4ŽîEõª/Ù³ò hŒÂ%3rX§zRn‰˜`sâ²ýìâ â {‘CžµvSòaõœe˜Fë†ñxŠì‘F¥Î‡l‘Òoº+enŸ‰v§ù=«øøs$yÃh=§“MGU1E·Áe—“C· ÈGôªcÇU8ØÐ=;Ô™u¶Ó•`lpI+.ñ S2k;<UPÓÜB/«BÐ6è=‘O5,QUgOX!"¶5y›3›"$y½;[Ÿ Û”qXïû¾8r.­® ¸Ð¶ libDAI: Class Members - Functions
 

- t -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__exp.html0000644000263000017630000000710311433220721020055 0ustar jorismkyb libDAI: dai::fo_exp< T > Struct Template Reference

dai::fo_exp< T > Struct Template Reference

Function object that takes the exponent. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns exp(x).

Detailed Description

template<typename T>
struct dai::fo_exp< T >

Function object that takes the exponent.

Member Function Documentation

template<typename T>
T dai::fo_exp< T >::operator() ( const T &  x  )  const [inline]

Returns exp(x).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/dag_8h.html0000644000263000017630000000533311433220721015210 0ustar jorismkyb libDAI: include/dai/dag.h File Reference

include/dai/dag.h File Reference

Defines the DAG class, which represents a directed acyclic graph. More...

#include <ostream>
#include <vector>
#include <algorithm>
#include <dai/util.h>
#include <dai/exceptions.h>
#include <dai/smallset.h>
#include <dai/graph.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::DAG
 Represents the neighborhood structure of nodes in a directed cyclic graph. More...

Detailed Description

Defines the DAG class, which represents a directed acyclic graph.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1TreeEP_1_1Properties.html0000644000263000017630000002245211433220721022303 0ustar jorismkyb libDAI: dai::TreeEP::Properties Struct Reference

dai::TreeEP::Properties Struct Reference

Parameters for TreeEP. More...

#include <dai/treeep.h>

List of all members.

Public Member Functions

 DAI_ENUM (TypeType, ORG, ALT)
 Enumeration of possible choices for the tree.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
double maxtime
 Maximum time (in seconds).
Real tol
 Tolerance for convergence test.
TypeType type
 How to choose the tree.

Detailed Description

Parameters for TreeEP.

Member Function Documentation

dai::TreeEP::Properties::DAI_ENUM ( TypeType  ,
ORG  ,
ALT   
)

Enumeration of possible choices for the tree.

The two possibilities are:

  • ORG: take the maximum spanning tree where the weights are crude estimates of the mutual information between the nodes;
  • ALT: take the maximum spanning tree where the weights are upper bounds on the effective interaction strengths between pairs of nodes.

Member Data Documentation

size_t dai::TreeEP::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::TreeEP::Properties::maxiter

Maximum number of iterations.

double dai::TreeEP::Properties::maxtime

Maximum time (in seconds).

Real dai::TreeEP::Properties::tol

Tolerance for convergence test.

TypeType dai::TreeEP::Properties::type

How to choose the tree.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_134.png0000644000263000017630000000111611433220721015223 0ustar jorismkyb‰PNG  IHDRŸúÓ°Þ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÌIDAT8µ“¿KÃPÇ¿éK›4m&LDTDì¨]ÄEûh'ç‚ ˆê tŠj]J+8ê âØÉÕ¡à?Ðvpöîík*Eä½äîó¾w¹÷ü‹yý.ãË~fì"lžG4ð8¤Y-P; ˜žEÍʘYóÌ|7RAê 8 ¸AŒn±-«ü`=¨C´UA N÷+ßfÂÌÑJ™Ù'F7sÞCŠÜ‚ãS•ÔÅ?zNC5`‰bâRW=a^‰‰y]oƃ“•Ù…ݶÙ;Vãê[hˆ`Êg½—ˆž0”´ÉçÉ‚.˜à·y¤Áç>º€¦Ú¨Ëh}ÂPÒ&ò³ª *~;Ðß%ä5Áõè™ «AŒj&ic¯É4Á;ŒsYк\¾&h”ü^Á€q8©]NwÓ} vŠ.Œ¶jaWèGƇúŒV\Jr…LfŠ7?—Ð-îám–öf1çCZåwó´åÉ·:†Äeì‘â&p#WÈ8+Äd0û½)‰û'8ÁÇÄÊòó…çPÉœÀéÎFÚ¨3º¥ÂY~«g•-½©ö-égtÛÑ#ý1NbF+C?£›QÌÿÉ>B´_ER8ŒIEND®B`‚libDAI-0.2.7/doc/html/form_41.png0000644000263000017630000000057411433220721015147 0ustar jorismkyb‰PNG  IHDRV~y•µ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfúIDAT(‘c` 0’ V(Uì`rq¶7 â¬_ļ@l0¦ "Ä< æ’PQN1,–@eµØŠáÔéeœ!èj² ÀQ;ÿ3ƒ˜ïÿ- ]-P¡–Qx>˜ÅÀ ˜/ìà‰¦(Ë QËËÀ[Àbµ1pàb`Ød0lc`¼F@²l3y´À~cu©ÃÀìÂÀ­d0\g`ú FOÁ²Ò ·±€bÈaG÷53„Á‚*€¸àxótdPÑ,«CP"˜Ô˜Áá#V`@g ³Ùу?,b);þ—ŽsIEND®B`‚libDAI-0.2.7/doc/html/customdoxygen.css0000644000263000017630000002000711433220721016605 0ustar jorismkybBODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV { font-family: Geneva, Arial, Helvetica, sans-serif; } EM { color: #602020; } BODY,TD { font-size: 90%; } H1 { text-align: center; font-size: 160%; } H2 { font-size: 120%; } H3 { font-size: 100%; } CAPTION { font-weight: bold } DIV.qindex { width: 100%; background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.navpath { width: 100%; background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; padding: 2px; line-height: 140%; } DIV.navtab { background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } TD.navtab { font-size: 70%; } A.qindex { text-decoration: none; font-weight: bold; color: #1A419D; } A.qindex:visited { text-decoration: none; font-weight: bold; color: #1A419D } A.qindex:hover { text-decoration: none; background-color: #ddddff; } A.qindexHL { text-decoration: none; font-weight: bold; background-color: #6666cc; color: #ffffff; border: 1px double #9295C2; } A.qindexHL:hover { text-decoration: none; background-color: #6666cc; color: #ffffff; } A.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff } A.el { text-decoration: none; font-weight: bold } A.elRef { font-weight: bold } A.code:link { text-decoration: none; font-weight: normal; color: #0000FF } A.code:visited { text-decoration: none; font-weight: normal; color: #0000FF } A.codeRef:link { font-weight: normal; color: #0000FF } A.codeRef:visited { font-weight: normal; color: #0000FF } A:hover { text-decoration: none; background-color: #f2f2ff } DL.el { margin-left: -1cm } .fragment { font-family: monospace, fixed; font-size: 95%; } PRE.fragment { border: 1px solid #CCCCCC; background-color: #f5f5f5; margin-top: 4px; margin-bottom: 4px; margin-left: 2px; margin-right: 8px; padding-left: 6px; padding-right: 6px; padding-top: 4px; padding-bottom: 4px; } DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px } DIV.groupHeader { margin-left: 16px; margin-top: 12px; margin-bottom: 6px; font-weight: bold; } DIV.groupText { margin-left: 16px; font-style: italic; font-size: 90% } BODY { background: white; color: black; margin-right: 20px; margin-left: 20px; } TD.indexkey { background-color: #e8eef2; font-weight: bold; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TD.indexvalue { background-color: #e8eef2; font-style: italic; padding-right : 10px; padding-top : 2px; padding-left : 10px; padding-bottom : 2px; margin-left : 0px; margin-right : 0px; margin-top : 2px; margin-bottom : 2px; border: 1px solid #CCCCCC; } TR.memlist { background-color: #f0f0f0; } P.formulaDsp { text-align: center; } IMG.formulaDsp { } IMG.formulaInl { vertical-align: middle; } SPAN.keyword { color: #008000 } SPAN.keywordtype { color: #604020 } SPAN.keywordflow { color: #e08000 } SPAN.comment { color: #800000 } SPAN.preprocessor { color: #806020 } SPAN.stringliteral { color: #002080 } SPAN.charliteral { color: #008080 } SPAN.vhdldigit { color: #ff00ff } SPAN.vhdlchar { color: #000000 } SPAN.vhdlkeyword { color: #700070 } SPAN.vhdllogic { color: #ff0000 } .mdescLeft { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .mdescRight { padding: 0px 8px 4px 8px; font-size: 80%; font-style: italic; background-color: #FAFAFA; border-top: 1px none #E0E0E0; border-right: 1px none #E0E0E0; border-bottom: 1px none #E0E0E0; border-left: 1px none #E0E0E0; margin: 0px; } .memItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemLeft { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplItemRight { padding: 1px 8px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: none; border-right-style: none; border-bottom-style: none; border-left-style: none; background-color: #FAFAFA; font-size: 80%; } .memTemplParams { padding: 1px 0px 0px 8px; margin: 4px; border-top-width: 1px; border-right-width: 1px; border-bottom-width: 1px; border-left-width: 1px; border-top-color: #E0E0E0; border-right-color: #E0E0E0; border-bottom-color: #E0E0E0; border-left-color: #E0E0E0; border-top-style: solid; border-right-style: none; border-bottom-style: none; border-left-style: none; color: #606060; background-color: #FAFAFA; font-size: 80%; } .search { color: #003399; font-weight: bold; } FORM.search { margin-bottom: 0px; margin-top: 0px; } INPUT.search { font-size: 75%; color: #000080; font-weight: normal; background-color: #e8eef2; } TD.tiny { font-size: 75%; } a { color: #1A41A8; } a:visited { color: #2A3798; } .dirtab { padding: 4px; border-collapse: collapse; border: 1px solid #84b0c7; } TH.dirtab { background: #e8eef2; font-weight: bold; } HR { height: 1px; border: none; border-top: 1px solid black; } /* Style for detailed member documentation */ .memtemplate { font-size: 80%; color: #606060; font-weight: normal; margin-left: 3px; } .memnav { background-color: #e8eef2; border: 1px solid #84b0c7; text-align: center; margin: 2px; margin-right: 15px; padding: 2px; } .memitem { padding: 4px; background-color: #eef3f5; border-width: 1px; border-style: solid; border-color: #dedeee; -moz-border-radius: 8px 8px 8px 8px; } .memname { white-space: nowrap; font-weight: bold; } .memdoc{ padding-left: 10px; } .memproto { background-color: #d5e1e8; width: 100%; border-width: 1px; border-style: solid; border-color: #84b0c7; font-weight: bold; -moz-border-radius: 8px 8px 8px 8px; } .paramkey { text-align: right; } .paramtype { white-space: nowrap; } .paramname { color: #602020; font-style: italic; white-space: nowrap; } /* End Styling for detailed member documentation */ /* for the tree view */ .ftvtree { font-family: sans-serif; margin:0.5em; } .directory { font-size: 9pt; font-weight: bold; } .directory h3 { margin: 0px; margin-top: 1em; font-size: 11pt; } .directory > h3 { margin-top: 0; } .directory p { margin: 0px; white-space: nowrap; } .directory div { display: none; margin: 0px; } .directory img { vertical-align: -30%; } libDAI-0.2.7/doc/html/form_91.png0000644000263000017630000000146611433220721015155 0ustar jorismkyb‰PNG  IHDR×:vV0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf´IDAT8å•MhA†ßÝ$›Ÿ6ÛªôàbkM(mc¼TEº¶JA 5bQ©ˆ LA¡zirŒ ©bÁ›xòRXÚ£µ¥ ^zð´Ik=ˆ3³Ù$›lDÄ›_Èì|³ï~Ïì;»³Àb†…ö'R9mIÃí•R­zÓ‰ØTW×N‹|8ƒLºiÌ£ ÒŽµ!õÅqªFmš‘? TZ®pl#§4¹ÑH5¦öQ) ÙZ’µž³‡á»¤5¹±Eõù¤š¬/Sk0Øl5òâVK#ñ$jÕÄ…–‚ûÂF0Æ'š ¾­15áI”Ýy1†zÎiw»ËvwÙ~¼p’½sï9gæüæÜ;÷ÜîË}rafttôòT©!|ùþø/±ÜDê 5=ùrƒñ/5''ë}žÙ¨w¨.€ÒuòèÁµjbU‹Í*w_d Ù©_SÍñ÷ëÔ¼1;*r_\ P2èU¦Nž¶©ÍÎ‹Ü a:‹Æ†ÙZG59ÏÍÞ$Ùì‚Fä&AºÌw¯¨48˶Ÿ;ö®-7“ê\udzyõë„vJ¨[o?5Ћí­ÁüI?ôà5j"6Ö÷u;{Ý@¥ÁYòz6fÊ-hÅ yŸ´B®â§Oƒ ùh"nþ¢§¥[G|MÔÃ.7j"Ù±Ô·…{Ý@~p(ïc†ÐRQ7LøÙ‰A Ö‹Ús@^Ü\u8Ç×ÄM´ƒ€ðe2{o@ApüŒ“ôk&M0Íc‰&•h`‹.šrÅ@Sz“¾¦Qˆð ïÞ€‚à’¸×¤èü¢èÆO·ë8ä6CïχÃg!ÓOcßE@-y}\Nœ÷5[Ew”Ô´ÆÙ’ qjòƒCMùé9Ê×6¼qGÍJTf¾J=Ã6ÎŽ;RŽ? „O$š¾·>|ó­‹ß¤¯n¿:˜úÀâ ΤšT§F¶r¶ÔÂÎX;œÕJÑÄšÂ38çTÑgË)˜Ô1~çÕ©Ð}à 8­YöæedLõîC;ãââ jÍéz]ÿºËÁ@Ææò˵ž äíçÍb÷z6:±»FÒƒ”T©eYâžÝ*¡–)Y$¶]ݧq Õn­Võ¡è·‡ðÂeΘq€ ÿ”Úf,Hߪ5le1)—ù4mdbFs'‚»Šòeæ[¼É”Ÿ3™s8”É4~b\7ö o¥i ¹$™ -ƒìqÑ?…ð%g×õS+ D¢XÇ »x™öõ9œ^iZ=¶Š&..ºIóVÔ=D?*âòG¥ú(0ÌO¬ù›ª(Qþ¾ø-U ;héÄ“)6×­¸,½€Øì^ôØÉ)g€Çéµ;züILÿD½ÌãꉙÿÃrò•È¶èO¾Ô­ÿ%+²øu^hIEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1fo__absdiff-members.html0000644000263000017630000000363011433220721022310 0ustar jorismkyb libDAI: Member List

dai::fo_absdiff< T > Member List

This is the complete list of members for dai::fo_absdiff< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_absdiff< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_89.png0000644000263000017630000000155211433220721015160 0ustar jorismkyb‰PNG  IHDR­¦r0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfèIDATH‰í•ÏOAÇ¿û»li»ñ ¨›Hª”ÅÆ_ÑPƒb\•Æ/E°‰Æ˜M‘x)jD8­r¡žê…3G¹‚È•pðÜ„ ãUßìn·Eh&Æ‹ß¡y;óÏûîÌ›-ð?Â}¦ŸžÙeZ0þLï…/Ã¥"üSî…´¤Jy\¡þ!isõàh­œa³!Xp)Uvȶ(~”¹zŠ@Pª ß‚u“ƒl®Ë¥ _ZPœÚHÛ.ð€óVˆwZÈH¦–_WXhÏ4PìÞ°Ü >ø„¸yÀ[Ñ¿QÚŽ ›E)-©Tª›òþypõ¾ÅþDfs3—üqÝÚiU±’ZÈ%Dó%P„j±quÔÇ£À($ª•ÌçóC4³ÁÕÃÄnâ2Ór`*‡'I)é;Ô%L]ª,r†&OSÀu[·…éYè94ÑüG¨e_DÂWO þtâ”­ ´Ð1äeâüÄ9t8>Xªè9Bê.0!`ØBœí4+¡:OqÖ…D³}Åbq–Æ»®ž G®ÐA "*¯¯eDl¬B}ö𞥳MKã¦é!”»Œ8;:±òUE™mÞÓÄarë@îÒ6{0ú®~Ñë…¡3¢*­ÊzÂ,#fP/)_”KéT Z\N 'o!ÊV_Î]–òé}ïc\¨ÍíT0Z×hïÀ×?òûõ ´Œöf,ƒµNÅõo„ìŽë™t~Z¬ûB1Ù ®±6ÆËÖ$åóôé€)¢]­9衽çêåêwAX`¿ra<–ÅUf¡ÉZJ2 ?À°”dV§ÉJ­ç¹›y˜M,¸îb `e``àFq=ˆ,F’`ù=k¤Ô u%ÇàáIEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1MR_1_1Properties-members.html0000644000263000017630000000603711433220721023126 0ustar jorismkyb libDAI: Member List

dai::MR::Properties Member List

This is the complete list of members for dai::MR::Properties, including all inherited members.

DAI_ENUM(UpdateType, FULL, LINEAR)dai::MR::Properties
DAI_ENUM(InitType, RESPPROP, CLAMPING, EXACT)dai::MR::Properties
initsdai::MR::Properties
toldai::MR::Properties
updatesdai::MR::Properties
verbosedai::MR::Properties

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__pow-members.html0000644000263000017630000000360011433220721021514 0ustar jorismkyb libDAI: Member List

dai::fo_pow< T > Member List

This is the complete list of members for dai::fo_pow< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_pow< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_110.png0000644000263000017630000000310411433220721015214 0ustar jorismkyb‰PNG  IHDR3O·Qs0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÂIDATX…Õ˜ohEÀßþ¹½ÛË%»U,Æ?Ü)ÄÆt%&¥!öš ©Zƒˆ‹tKj$Šä¬ ¼(¶%ì5Ðƈګ¥) bT*ø¡$i U¡kè‡Dm¡~L45hÔóÍÌîÝîuw³Y¶|{³3ïÍûÍìÛ™7 ð—LÔráM…bd¦Äs¡M•1L9ÚòË)LÙÖPXˆƒIÒ°.¬¡ða˜ÔK!í¾‰””þpfÜoÑb0Ik¡ÌâW!~Rc¡ÌêŠÑb0 9Dňƒ‰ð{(³GÔˆ9˜üÊê@Ħ̆²ú)b SÆêI§æFFFNͱ­õ/³Vþ+GÞûñªöò¹YÔ<7Ûå§xÂSàÀ<»ùÓ¬Ktih,­nŸ&q±è«Óљ 0¬3¾iGY£sÀnyR-…1ª«ªYvfÀá'Ôæƒ ê¬é^O¡ £¬°ÿ¼UÑN.ÌA÷†ߨè[β´Yƒ¶Ä®‰›SÉ‚–{Ç 9`.[µ|É°+ø ™£‚u;à tNykÔƒ‘sКè™i—öL©`-Ê|lb‡‰/–«ûíJÚMTuëövºÜÖ”GEœ)´ûº&„1†â°ØÂh©ð‚ITjþuÀ(âçN½‡²yȧ‰ê×ršåŒÁ(íÅŽ†. íó ݵ€~Žñ58) ûÁp¥¢…;rˆ!<:õEÍxÂÈb÷ððÇ~æÌ„y*Ýc0ç”õ:°ƒ ²¾3Ù%ûÌdïÍ´B,salÚEúò‚©Ë .ÂÂ0g&ÌaÎi‚AÚEüaŽ5æ5€QhžŠê£ÀÇ .b ;ÌùØoé‘vÜBÛcÀ/ùÃÀe[N „áèˆ|`ÚÐP#.’X§Ùa&S•UK,p£’¸kñ½ävÕ&Yéå{‚Q 5 cMdD©ÊêP Ó*ÌÇ;ŠšÃqf´¼Ïé¦7Á/õm度ñÛ?$\ò…鶳àûŠ³žå™/t|^ä½ò‚IlËpûà&xúÉݤ@œ™0(÷e,µ£ôús†.HååÚFœ¶³Ü:MfJbÓŒJ•¦+Ö•œ!“*Ç Ô™b­lme˜ëéõ$c¶Ãˆ•7ènöÇRiaÙ€‡»Ì86P¬Ø»íMóÀåÍu¶Ñjî+G`Vmõ„©ìMpšý™CzÌ>„¶¥û.0HÒb¨³¬Õ¼Ú w˜Zæn‹ošâý\]È®Þ “šð2nFˆ•ÏÀGM(ÍoÈgbS*øêì ˜ZK㥳ð|éog¦/1YYÕ^¾X: ï—V¢ÉôRÎ×1‰è°ði(««t:˜ eôá®Q–ƒ©áŒ" Àz›öUbàšŽéf,ïÚÊüœ€;p÷0pß `Åÿ­p.gM¼®Þ©ôà+®Âmð–«fгvšbi5W6ëx§Xi×è6ï!wôêðl1Ž%™Â°-úJ úbÔùhMHyÜw´ï@øŒ¤»¸x&U^Oº[Š=tSÈ-6Y0x.p‡Qô`0£Ð62 qnYåéý¯¸ÑMk«˜‚‘ÌH†êÃDYbÝÂ1|L¹w Tù<±3°Ùõ³ÐÎ`,¸“ýæ:øî·ìÎפT lÐ%§­âߎ £½º ¥ ð&ÙÃÚ€›„m®à_cÁXÂhÙ‡Hõ´B¡¯“ÄÏ”%½ «â‹î¶ÓpÌžœ'g |L‰½î‰[÷¢Íì”ÐH'@œ'×V libDAI: dai::DAG Class Reference

dai::DAG Class Reference

Represents the neighborhood structure of nodes in a directed cyclic graph. More...

#include <dai/dag.h>

List of all members.

Input and output

void printDot (std::ostream &os) const
 Writes this DAG to an output stream in GraphViz .dot syntax.
std::ostream & operator<< (std::ostream &os, const DAG &g)
 Writes this DAG to an output stream.

Public Member Functions

Constructors and destructors
 DAG ()
 Default constructor (creates an empty DAG).
 DAG (size_t nr)
 Constructs DAG with nr nodes and no edges.
template<typename EdgeInputIterator>
 DAG (size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
 Constructs DAG from a range of edges.
Accessors and mutators
const Neighbor & pa (size_t n, size_t _p) const
 Returns constant reference to the _p 'th parent of node n.
Neighbor & pa (size_t n, size_t _p)
 Returns reference to the _p 'th parent of node n.
const Neighbors & pa (size_t n) const
 Returns constant reference to all parents of node n.
Neighbors & pa (size_t n)
 Returns reference to all parents of node n.
const Neighbor & ch (size_t n, size_t _c) const
 Returns constant reference to the _c 'th child of node n.
Neighbor & ch (size_t n, size_t _c)
 Returns reference to the _c 'th child of node n.
const Neighbors & ch (size_t n) const
 Returns constant reference to all children of node n.
Neighbors & ch (size_t n)
 Returns reference to all children of node n.
Adding nodes and edges
template<typename EdgeInputIterator>
void construct (size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
 (Re)constructs DAG from a range of edges.
size_t addNode ()
 Adds a node without parents and children and returns the index of the added node.
template<typename NodeInputIterator>
size_t addNode (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
 Adds a node with parents specified by a range of nodes.
DAG & addEdge (size_t n1, size_t n2, bool check=true)
 Adds an edge from node n1 and node n2.
Erasing nodes and edges
void eraseNode (size_t n)
 Removes node n and all ingoing and outgoing edges; indices of other nodes are changed accordingly.
void eraseEdge (size_t n1, size_t n2)
 Removes edge from node n1 to node n2.
Queries
size_t nrNodes () const
 Returns number of nodes.
size_t nrEdges () const
 Calculates the number of edges, time complexity: O(nrNodes()).
bool hasEdge (size_t n1, size_t n2) const
 Returns true if the DAG contains an edge from node n1 and n2.
size_t findPa (size_t n, size_t p)
 Returns the index of a given node p amongst the parents of n.
size_t findCh (size_t n, size_t c)
 Returns the index of a given node c amongst the children of n.
SmallSet< size_t > paSet (size_t n) const
 Returns parents of node n as a SmallSet<size_t>.
SmallSet< size_t > chSet (size_t n) const
 Returns children of node n as a SmallSet<size_t>.
std::set< size_t > ancestors (size_t n) const
 Returns the set of ancestors of node n, i.e., all nodes a such that there exists a directed path from a to n (excluding n itself).
std::set< size_t > descendants (size_t n) const
 Returns the set of descendants of node n, i.e., all nodes d such that there exists a directed path from n to d (excluding n itself).
bool existsDirectedPath (size_t n1, size_t n2) const
 Returns whether there exists a directed path from node n1 to node n2 (which may consist of zero edges).
bool isConnected () const
 Returns true if the DAG is connected.
void checkConsistency () const
 Asserts internal consistency.
bool operator== (const DAG &x) const
 Comparison operator which returns true if two DAGs are identical.

Private Attributes

std::vector< Neighbors > _pa
 Contains for each node a vector of its parent nodes.
std::vector< Neighbors > _ch
 Contains for each node a vector of its children nodes.

Detailed Description

Represents the neighborhood structure of nodes in a directed cyclic graph.

A directed cyclic graph has nodes connected by directed edges, such that there is no directed cycle of edges n1->n2->n3->...->n1. Nodes are indexed by an unsigned integer. If there are nrNodes() nodes, they are numbered 0,1,2,...,nrNodes()-1. An edge from node n1 to node n2 is represented by a Edge(n1,n2).

DAG is implemented as a sparse adjacency list, i.e., it stores for each node a list of its parents and a list of its children. Both lists are implemented as a vector of Neighbor structures (accessible by the pa() and ch() methods). Thus, each node has two associated variables of type DAG::Neighbors, which are vectors of Neighbor structures, describing their parent and children nodes.

Constructor & Destructor Documentation

dai::DAG::DAG (  )  [inline]

Default constructor (creates an empty DAG).

dai::DAG::DAG ( size_t  nr  )  [inline]

Constructs DAG with nr nodes and no edges.

template<typename EdgeInputIterator>
dai::DAG::DAG ( size_t  nr,
EdgeInputIterator  begin,
EdgeInputIterator  end,
bool  check = true 
) [inline]

Constructs DAG from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of Edge.
Parameters:
nr The number of nodes.
begin Points to the first edge.
end Points just beyond the last edge.
check Whether to only add an edge if it does not exist already and if it does not introduce a cycle

Member Function Documentation

const Neighbor& dai::DAG::pa ( size_t  n,
size_t  _p 
) const [inline]

Returns constant reference to the _p 'th parent of node n.

Neighbor& dai::DAG::pa ( size_t  n,
size_t  _p 
) [inline]

Returns reference to the _p 'th parent of node n.

const Neighbors& dai::DAG::pa ( size_t  n  )  const [inline]

Returns constant reference to all parents of node n.

Neighbors& dai::DAG::pa ( size_t  n  )  [inline]

Returns reference to all parents of node n.

const Neighbor& dai::DAG::ch ( size_t  n,
size_t  _c 
) const [inline]

Returns constant reference to the _c 'th child of node n.

Neighbor& dai::DAG::ch ( size_t  n,
size_t  _c 
) [inline]

Returns reference to the _c 'th child of node n.

const Neighbors& dai::DAG::ch ( size_t  n  )  const [inline]

Returns constant reference to all children of node n.

Neighbors& dai::DAG::ch ( size_t  n  )  [inline]

Returns reference to all children of node n.

template<typename EdgeInputIterator>
void dai::DAG::construct ( size_t  nr,
EdgeInputIterator  begin,
EdgeInputIterator  end,
bool  check = true 
) [inline]

(Re)constructs DAG from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of Edge.
Parameters:
nr The number of nodes.
begin Points to the first edge.
end Points just beyond the last edge.
check Whether to only add an edge if it does not exist already and does not introduce a cycle.

size_t dai::DAG::addNode (  )  [inline]

Adds a node without parents and children and returns the index of the added node.

template<typename NodeInputIterator>
size_t dai::DAG::addNode ( NodeInputIterator  begin,
NodeInputIterator  end,
size_t  sizeHint = 0 
) [inline]

Adds a node with parents specified by a range of nodes.

Template Parameters:
NodeInputIterator Iterator that iterates over instances of size_t.
Parameters:
begin Points to the first index of the nodes that should become parents of the added node.
end Points just beyond the last index of the nodes that should become parents of the added node.
sizeHint For improved efficiency, the size of the range may be specified by sizeHint.
Returns:
Index of the added node.

DAG & dai::DAG::addEdge ( size_t  n1,
size_t  n2,
bool  check = true 
)

Adds an edge from node n1 and node n2.

If check == true, only adds the edge if it does not exist already and it would not introduce a cycle.

void dai::DAG::eraseNode ( size_t  n  ) 

Removes node n and all ingoing and outgoing edges; indices of other nodes are changed accordingly.

void dai::DAG::eraseEdge ( size_t  n1,
size_t  n2 
)

Removes edge from node n1 to node n2.

size_t dai::DAG::nrNodes (  )  const [inline]

Returns number of nodes.

size_t dai::DAG::nrEdges (  )  const [inline]

Calculates the number of edges, time complexity: O(nrNodes()).

bool dai::DAG::hasEdge ( size_t  n1,
size_t  n2 
) const [inline]

Returns true if the DAG contains an edge from node n1 and n2.

Note:
The time complexity is linear in the number of children of n1 or the number of parents of n2, whichever is smaller

size_t dai::DAG::findPa ( size_t  n,
size_t  p 
) [inline]

Returns the index of a given node p amongst the parents of n.

Note:
The time complexity is linear in the number of parents of n
Exceptions:
OBJECT_NOT_FOUND if p is not a parent of n

size_t dai::DAG::findCh ( size_t  n,
size_t  c 
) [inline]

Returns the index of a given node c amongst the children of n.

Note:
The time complexity is linear in the number of children of n
Exceptions:
OBJECT_NOT_FOUND if c is not a child n

SmallSet< size_t > dai::DAG::paSet ( size_t  n  )  const

Returns parents of node n as a SmallSet<size_t>.

SmallSet< size_t > dai::DAG::chSet ( size_t  n  )  const

Returns children of node n as a SmallSet<size_t>.

std::set< size_t > dai::DAG::ancestors ( size_t  n  )  const

Returns the set of ancestors of node n, i.e., all nodes a such that there exists a directed path from a to n (excluding n itself).

Returns the set of ancestors of node n, i.e., all nodes m such that there exists a directed path from m to n (excluding n itself).

std::set< size_t > dai::DAG::descendants ( size_t  n  )  const

Returns the set of descendants of node n, i.e., all nodes d such that there exists a directed path from n to d (excluding n itself).

Returns the set of descendants of node n, i.e., all nodes m such that there exists a directed path from n to m (excluding n itself).

bool dai::DAG::existsDirectedPath ( size_t  n1,
size_t  n2 
) const

Returns whether there exists a directed path from node n1 to node n2 (which may consist of zero edges).

bool dai::DAG::isConnected (  )  const

Returns true if the DAG is connected.

void dai::DAG::checkConsistency (  )  const

Asserts internal consistency.

bool dai::DAG::operator== ( const DAG &  x  )  const [inline]

Comparison operator which returns true if two DAGs are identical.

Note:
Two DAGs are called identical if they have the same number of nodes and the same edges (i.e., x has an edge from n1 to n2 if and only if *this has an edge from node n1 to n2).

void dai::DAG::printDot ( std::ostream &  os  )  const

Writes this DAG to an output stream in GraphViz .dot syntax.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const DAG &  g 
) [friend]

Writes this DAG to an output stream.

Member Data Documentation

std::vector<Neighbors> dai::DAG::_pa [private]

Contains for each node a vector of its parent nodes.

std::vector<Neighbors> dai::DAG::_ch [private]

Contains for each node a vector of its children nodes.

The documentation for this class was generated from the following files:
  • include/dai/dag.h
  • src/dag.cpp
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/example__varset_8cpp-example.html0000644000263000017630000002512211433220721021615 0ustar jorismkyb libDAI: example_varset.cpp

example_varset.cpp

This example shows how to use the Var, VarSet and State classes. It also explains the concept of "states" for VarSets.

Output

X = {x0,x1}

Var x0 has 2 states (possible values).
Var x1 has 3 states.

VarSet {x0,x1} has 6 states (joint assignments of its variables).

States of VarSets correspond to states of their constituent Vars:
  state of x0:   state of x1:   state of X:
    0              0              0
    1              0              1
    0              1              2
    1              1              3
    0              2              4
    1              2              5

And vice versa:
  state of x0:   state of x1:   state of X:
    0              0              0
    1              0              1
    0              1              2
    1              1              3
    0              2              4
    1              2              5

Source

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2008-2009  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/varset.h>
#include <dai/index.h>
#include <iostream>

using namespace std;
using namespace dai;

int main() {
    Var x0(0, 2);   // Define binary variable x0 (with label 0)
    Var x1(1, 3);   // Define ternary variable x1 (with label 1)

    // Define set X = {x0, x1}
    VarSet X; // empty
    X |= x1;  // X = {x1}
    X |= x0;  // X = {x1, x0}
    cout << "X = " << X << endl << endl; // Note that the elements of X are ordered according to their labels

    // Output some information about x0, x1 and X
    cout << "Var " << x0 << " has " << x0.states() << " states (possible values)." << endl;
    cout << "Var " << x1 << " has " << x1.states() << " states." << endl << endl;
    cout << "VarSet " << X << " has " << X.nrStates() << " states (joint assignments of its variables)." << endl << endl;

    cout << "States of VarSets correspond to states of their constituent Vars:" << endl;
    cout << "  state of x0:   state of x1:   (linear) state of X:" << endl;
    for( size_t s1 = 0; s1 < x1.states(); s1++ ) // for all states s1 of x1
        for( size_t s0 = 0; s0 < x0.states(); s0++ ) { // for all states s0 of x0
            // store s0 and s1 in a map "states"
            map<Var,size_t> states;
            states[x0] = s0;
            states[x1] = s1;

            // output states of x0, x1 and corresponding state of X
            cout << "    " << s0 << "              " << s1 << "              " << calcLinearState(X,states) << endl;

            // calcState() is the inverse of calcLinearState()
            DAI_ASSERT( calcState(X, calcLinearState(X, states)) == states );
        }

    cout << endl << "And vice versa:" << endl;
    cout << "  state of x0:   state of x1:   (linear) state of X:" << endl;
    for( size_t S = 0; S < X.nrStates(); S++ ) { // for all (joint) states of X
        // calculate states of x0 and x1 corresponding to state S of X
        map<Var,size_t> states = calcState(X,S);

        // output state of X and corresponding states of x0, x1
        cout << "    " << states[x0] << "              " << states[x1] << "              " << S << endl;

        // calcLinearState() is the inverse of calcState()
        DAI_ASSERT( calcLinearState(X, calcState(X,S)) == S );
    }

    cout << endl << "Iterating over all joint states using the State class:" << endl;
    cout << "  state of x0:   state of x1:   (linear) state of X:   state of X (as a map):" << endl;
    for( State S(X); S.valid(); S++ ) {
        // output state of X and corresponding states of x0, x1
        cout << "    " << S(x0) << "              " << S(x1) << "              " << S << "                      " << S.get() << endl;
    }

    return 0;
}
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/properties_8h-source.html0000644000263000017630000006007311433220721020151 0ustar jorismkyb libDAI: include/dai/properties.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/decmap_8h-source.html0000644000263000017630000004532711433220721017213 0ustar jorismkyb libDAI: include/dai/decmap.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Evidence.html0000644000263000017630000005056311433220721017751 0ustar jorismkyb libDAI: dai::Evidence Class Reference

dai::Evidence Class Reference

Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables. More...

#include <dai/evidence.h>

List of all members.

Iterator interface

typedef std::vector
< Observation >::iterator 		iterator
 Iterator over the samples.
typedef std::vector
< Observation >
::const_iterator 		const_iterator
 Constant iterator over the samples.
iterator begin ()
 Returns iterator that points to the first sample.
const_iterator begin () const
 Returns constant iterator that points to the first sample.
iterator end ()
 Returns iterator that points beyond the last sample.
const_iterator end () const
 Returns constant iterator that points beyond the last sample.

Public Types

typedef std::map< Var, size_t > Observation
 Stores joint state of a set of variables.

Public Member Functions

 Evidence ()
 Default constructor.
 Evidence (std::vector< Observation > &samples)
 Construct from samples.
void addEvidenceTabFile (std::istream &is, FactorGraph &fg)
 Read in tabular data from a stream and add the read samples to *this.
size_t nrSamples () const
 Returns number of stored samples.

Private Member Functions

void addEvidenceTabFile (std::istream &is, std::map< std::string, Var > &varMap)
 Read in tabular data from a stream and add the read samples to *this.

Private Attributes

std::vector< Observation > _samples
 Each sample is an observed joint state of some variables.

Detailed Description

Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables.

Note:
Each sample can describe the joint state of a different set of variables, in order to be able to deal with missing data.
Author:
Charles Vaske
Examples:

example_sprinkler_em.cpp.

Member Typedef Documentation

typedef std::map<Var, size_t> dai::Evidence::Observation

Stores joint state of a set of variables.

typedef std::vector<Observation>::iterator dai::Evidence::iterator

Iterator over the samples.

typedef std::vector<Observation>::const_iterator dai::Evidence::const_iterator

Constant iterator over the samples.

Constructor & Destructor Documentation

dai::Evidence::Evidence (  )  [inline]

Default constructor.

dai::Evidence::Evidence ( std::vector< Observation > &  samples  )  [inline]

Construct from samples.

Member Function Documentation

void dai::Evidence::addEvidenceTabFile ( std::istream &  is,
FactorGraph &  fg 
)

Read in tabular data from a stream and add the read samples to *this.

Parameters:
is Input stream in .tab file format, describing joint observations of variables in fg
fg Factor graph describing the corresponding variables
See also:
Evidence (.tab) file format
Exceptions:
INVALID_EVIDENCE_FILE if the input stream is not valid
Examples:
example_sprinkler_em.cpp.

size_t dai::Evidence::nrSamples (  )  const [inline]

Returns number of stored samples.

Examples:
example_sprinkler_em.cpp.

iterator dai::Evidence::begin (  )  [inline]

Returns iterator that points to the first sample.

const_iterator dai::Evidence::begin (  )  const [inline]

Returns constant iterator that points to the first sample.

iterator dai::Evidence::end (  )  [inline]

Returns iterator that points beyond the last sample.

const_iterator dai::Evidence::end (  )  const [inline]

Returns constant iterator that points beyond the last sample.

void dai::Evidence::addEvidenceTabFile ( std::istream &  is,
std::map< std::string, Var > &  varMap 
) [private]

Read in tabular data from a stream and add the read samples to *this.

Member Data Documentation

std::vector<Observation> dai::Evidence::_samples [private]

Each sample is an observed joint state of some variables.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1DAIAlg-members.html0000644000263000017630000002142511433220721020673 0ustar jorismkyb libDAI: Member List

dai::DAIAlg< GRM > Member List

This is the complete list of members for dai::DAIAlg< GRM >, including all inherited members.

backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::InfAlg [inline, virtual]
belief(const VarSet &vs) const =0dai::InfAlg [pure virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const =0dai::InfAlg [pure virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const =0dai::InfAlg [pure virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::InfAlg [inline, virtual]
getProperties() const =0dai::InfAlg [pure virtual]
identify() const =0dai::InfAlg [pure virtual]
init()=0dai::InfAlg [pure virtual]
init(const VarSet &vs)=0dai::InfAlg [pure virtual]
Iterations() const dai::InfAlg [inline, virtual]
logZ() const =0dai::InfAlg [pure virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::InfAlg [inline, virtual]
printProperties() const =0dai::InfAlg [pure virtual]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()=0dai::InfAlg [pure virtual]
setMaxIter(size_t)dai::InfAlg [inline, virtual]
setProperties(const PropertySet &opts)=0dai::InfAlg [pure virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x66.html0000644000263000017630000000725511433220721017711 0ustar jorismkyb libDAI: Class Members - Variables
 

- f -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__exp-members.html0000644000263000017630000000356011433220721021510 0ustar jorismkyb libDAI: Member List

dai::fo_exp< T > Member List

This is the complete list of members for dai::fo_exp< T >, including all inherited members.

operator()(const T &x) const dai::fo_exp< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1TFactor.html0000644000263000017630000034643511433220721017577 0ustar jorismkyb libDAI: dai::TFactor< T > Class Template Reference

dai::TFactor< T > Class Template Reference

Represents a (probability) factor. More...

#include <dai/factor.h>

Inheritance diagram for dai::TFactor< T >:

dai::FRegion

List of all members.

Public Member Functions

Constructors and destructors
 TFactor (T p=1)
 Constructs factor depending on no variables with value p.
 TFactor (const Var &v)
 Constructs factor depending on the variable v with uniform distribution.
 TFactor (const VarSet &vars)
 Constructs factor depending on variables in vars with uniform distribution.
 TFactor (const VarSet &vars, T p)
 Constructs factor depending on variables in vars with all values set to p.
template<typename S>
 TFactor (const VarSet &vars, const std::vector< S > &x)
 Constructs factor depending on variables in vars, copying the values from a std::vector<>.
 TFactor (const VarSet &vars, const T *p)
 Constructs factor depending on variables in vars, copying the values from an array.
 TFactor (const VarSet &vars, const TProb< T > &p)
 Constructs factor depending on variables in vars, copying the values from p.
 TFactor (const std::vector< Var > &vars, const std::vector< T > &p)
 Constructs factor depending on variables in vars, permuting the values given in p accordingly.
Get/set individual entries
void set (size_t i, T val)
 Sets i 'th entry to val.
T get (size_t i) const
 Gets i 'th entry.
Queries
const TProb< T > & p () const
 Returns constant reference to value vector.
TProb< T > & p ()
 Returns reference to value vector.
T operator[] (size_t i) const
 Returns a copy of the i 'th entry of the value vector.
const VarSet & vars () const
 Returns constant reference to variable set (i.e., the variables on which the factor depends).
VarSet & vars ()
 Returns reference to variable set (i.e., the variables on which the factor depends).
size_t nrStates () const
 Returns the number of possible joint states of the variables on which the factor depends, $\prod_{l\in L} S_l$.
T entropy () const
 Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$.
T max () const
 Returns maximum of all values.
T min () const
 Returns minimum of all values.
T sum () const
 Returns sum of all values.
T sumAbs () const
 Returns sum of absolute values.
T maxAbs () const
 Returns maximum absolute value of all values.
bool hasNaNs () const
 Returns true if one or more values are NaN.
bool hasNegatives () const
 Returns true if one or more values are negative.
T strength (const Var &i, const Var &j) const
 Returns strength of this factor (between variables i and j), as defined in eq. (52) of [MoK07b].
bool operator== (const TFactor< T > &y) const
 Comparison.
Unary transformations
TFactor< T > operator- () const
 Returns negative of *this.
TFactor< T > abs () const
 Returns pointwise absolute value.
TFactor< T > exp () const
 Returns pointwise exponent.
TFactor< T > log (bool zero=false) const
 Returns pointwise logarithm.
TFactor< T > inverse (bool zero=true) const
 Returns pointwise inverse.
TFactor< T > normalized (ProbNormType norm=NORMPROB) const
 Returns normalized copy of *this, using the specified norm.
Unary operations
TFactor< T > & randomize ()
 Draws all values i.i.d. from a uniform distribution on [0,1).
TFactor< T > & setUniform ()
 Sets all values to $1/n$ where n is the number of states.
TFactor< T > & takeAbs ()
 Applies absolute value pointwise.
TFactor< T > & takeExp ()
 Applies exponent pointwise.
TFactor< T > & takeLog (bool zero=false)
 Applies logarithm pointwise.
T normalize (ProbNormType norm=NORMPROB)
 Normalizes factor using the specified norm.
Operations with scalars
TFactor< T > & fill (T x)
 Sets all values to x.
TFactor< T > & operator+= (T x)
 Adds scalar x to each value.
TFactor< T > & operator-= (T x)
 Subtracts scalar x from each value.
TFactor< T > & operator*= (T x)
 Multiplies each value with scalar x.
TFactor< T > & operator/= (T x)
 Divides each entry by scalar x.
TFactor< T > & operator^= (T x)
 Raises values to the power x.
Transformations with scalars
TFactor< T > operator+ (T x) const
 Returns sum of *this and scalar x.
TFactor< T > operator- (T x) const
 Returns difference of *this and scalar x.
TFactor< T > operator* (T x) const
 Returns product of *this with scalar x.
TFactor< T > operator/ (T x) const
 Returns quotient of *this with scalar x.
TFactor< T > operator^ (T x) const
 Returns *this raised to the power x.
Operations with other factors
template<typename binOp>
TFactor< T > & binaryOp (const TFactor< T > &g, binOp op)
 Applies binary operation op on two factors, *this and g.
TFactor< T > & operator+= (const TFactor< T > &g)
 Adds g to *this.
TFactor< T > & operator-= (const TFactor< T > &g)
 Subtracts g from *this.
TFactor< T > & operator*= (const TFactor< T > &g)
 Multiplies *this with g.
TFactor< T > & operator/= (const TFactor< T > &g)
 Divides *this by g (where division by zero yields zero).
Transformations with other factors
template<typename binOp>
TFactor< T > binaryTr (const TFactor< T > &g, binOp op) const
 Returns result of applying binary operation op on two factors, *this and g.
TFactor< T > operator+ (const TFactor< T > &g) const
 Returns sum of *this and g.
TFactor< T > operator- (const TFactor< T > &g) const
 Returns *this minus g.
TFactor< T > operator* (const TFactor< T > &g) const
 Returns product of *this with g.
TFactor< T > operator/ (const TFactor< T > &g) const
 Returns quotient of *this by f (where division by zero yields zero).
Miscellaneous operations
TFactor< T > slice (const VarSet &vars, size_t varsState) const
 Returns a slice of *this, where the subset vars is in state varsState.
TFactor< T > embed (const VarSet &vars) const
 Embeds this factor in a larger VarSet.
TFactor< T > marginal (const VarSet &vars, bool normed=true) const
 Returns marginal on vars, obtained by summing out all variables except those in vars, and normalizing the result if normed == true.
TFactor< T > maxMarginal (const VarSet &vars, bool normed=true) const
 Returns max-marginal on vars, obtained by maximizing all variables except those in vars, and normalizing the result if normed == true.

Private Attributes

VarSet _vs
 Stores the variables on which the factor depends.
TProb< T > _p
 Stores the factor values.

Related Functions

(Note that these are not member functions.)

template<typename T>
std::ostream & operator<< (std::ostream &os, const TFactor< T > &f)
 Writes a factor to an output stream.
template<typename T>
T dist (const TFactor< T > &f, const TFactor< T > &g, ProbDistType dt)
 Returns distance between two factors f and g, according to the distance measure dt.
template<typename T>
TFactor< T > max (const TFactor< T > &f, const TFactor< T > &g)
 Returns the pointwise maximum of two factors.
template<typename T>
TFactor< T > min (const TFactor< T > &f, const TFactor< T > &g)
 Returns the pointwise minimum of two factors.
template<typename T>
T MutualInfo (const TFactor< T > &f)
 Calculates the mutual information between the two variables that f depends on, under the distribution given by f.

Detailed Description

template<typename T>
class dai::TFactor< T >

Represents a (probability) factor.

Mathematically, a factor is a function mapping joint states of some variables to the nonnegative real numbers. More formally, denoting a discrete variable with label $l$ by $x_l$ and its state space by $X_l = \{0,1,\dots,S_l-1\}$, a factor depending on the variables $\{x_l\}_{l\in L}$ is a function $f_L : \prod_{l\in L} X_l \to [0,\infty)$.

In libDAI, a factor is represented by a TFactor<T> object, which has two components:

  • a VarSet, corresponding with the set of variables $\{x_l\}_{l\in L}$ that the factor depends on;
  • a TProb, a vector containing the value of the factor for each possible joint state of the variables.
The factor values are stored in the entries of the TProb in a particular ordering, which is defined by the one-to-one correspondence of a joint state in $\prod_{l\in L} X_l$ with a linear index in $\{0,1,\dots,\prod_{l\in L} S_l-1\}$ according to the mapping $\sigma$ induced by dai::calcLinearState().

Template Parameters:
T Should be a scalar that is castable from and to double and should support elementary arithmetic operations.
Todo:
Define a better fileformat for .fg files (maybe using XML)?
Todo:
Add support for sparse factors.

Constructor & Destructor Documentation

template<typename T>
dai::TFactor< T >::TFactor ( T  p = 1  )  [inline]

Constructs factor depending on no variables with value p.

template<typename T>
dai::TFactor< T >::TFactor ( const Var &  v  )  [inline]

Constructs factor depending on the variable v with uniform distribution.

template<typename T>
dai::TFactor< T >::TFactor ( const VarSet &  vars  )  [inline]

Constructs factor depending on variables in vars with uniform distribution.

template<typename T>
dai::TFactor< T >::TFactor ( const VarSet &  vars,
T  p 
) [inline]

Constructs factor depending on variables in vars with all values set to p.

template<typename T>
template<typename S>
dai::TFactor< T >::TFactor ( const VarSet &  vars,
const std::vector< S > &  x 
) [inline]

Constructs factor depending on variables in vars, copying the values from a std::vector<>.

Template Parameters:
S Type of values of x
Parameters:
vars contains the variables that the new factor should depend on.
x Vector with values to be copied.

template<typename T>
dai::TFactor< T >::TFactor ( const VarSet &  vars,
const T *  p 
) [inline]

Constructs factor depending on variables in vars, copying the values from an array.

Parameters:
vars contains the variables that the new factor should depend on.
p Points to array of values to be added.

template<typename T>
dai::TFactor< T >::TFactor ( const VarSet &  vars,
const TProb< T > &  p 
) [inline]

Constructs factor depending on variables in vars, copying the values from p.

template<typename T>
dai::TFactor< T >::TFactor ( const std::vector< Var > &  vars,
const std::vector< T > &  p 
) [inline]

Constructs factor depending on variables in vars, permuting the values given in p accordingly.

Member Function Documentation

template<typename T>
void dai::TFactor< T >::set ( size_t  i,
T  val 
) [inline]

Sets i 'th entry to val.

template<typename T>
T dai::TFactor< T >::get ( size_t  i  )  const [inline]

Gets i 'th entry.

template<typename T>
const TProb<T>& dai::TFactor< T >::p (  )  const [inline]

Returns constant reference to value vector.

template<typename T>
TProb<T>& dai::TFactor< T >::p (  )  [inline]

Returns reference to value vector.

template<typename T>
T dai::TFactor< T >::operator[] ( size_t  i  )  const [inline]

Returns a copy of the i 'th entry of the value vector.

template<typename T>
const VarSet& dai::TFactor< T >::vars (  )  const [inline]

Returns constant reference to variable set (i.e., the variables on which the factor depends).

template<typename T>
VarSet& dai::TFactor< T >::vars (  )  [inline]

Returns reference to variable set (i.e., the variables on which the factor depends).

template<typename T>
size_t dai::TFactor< T >::nrStates (  )  const [inline]

Returns the number of possible joint states of the variables on which the factor depends, $\prod_{l\in L} S_l$.

Note:
This is equal to the length of the value vector.

template<typename T>
T dai::TFactor< T >::entropy (  )  const [inline]

Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$.

template<typename T>
T dai::TFactor< T >::max (  )  const [inline]

Returns maximum of all values.

template<typename T>
T dai::TFactor< T >::min (  )  const [inline]

Returns minimum of all values.

template<typename T>
T dai::TFactor< T >::sum (  )  const [inline]

Returns sum of all values.

template<typename T>
T dai::TFactor< T >::sumAbs (  )  const [inline]

Returns sum of absolute values.

template<typename T>
T dai::TFactor< T >::maxAbs (  )  const [inline]

Returns maximum absolute value of all values.

template<typename T>
bool dai::TFactor< T >::hasNaNs (  )  const [inline]

Returns true if one or more values are NaN.

template<typename T>
bool dai::TFactor< T >::hasNegatives (  )  const [inline]

Returns true if one or more values are negative.

template<typename T>
T dai::TFactor< T >::strength ( const Var &  i,
const Var &  j 
) const [inline]

Returns strength of this factor (between variables i and j), as defined in eq. (52) of [MoK07b].

template<typename T>
bool dai::TFactor< T >::operator== ( const TFactor< T > &  y  )  const [inline]

Comparison.

template<typename T>
TFactor<T> dai::TFactor< T >::operator- (  )  const [inline]

Returns negative of *this.

template<typename T>
TFactor<T> dai::TFactor< T >::abs (  )  const [inline]

Returns pointwise absolute value.

template<typename T>
TFactor<T> dai::TFactor< T >::exp (  )  const [inline]

Returns pointwise exponent.

template<typename T>
TFactor<T> dai::TFactor< T >::log ( bool  zero = false  )  const [inline]

Returns pointwise logarithm.

If zero == true, uses log(0)==0; otherwise, log(0)==-Inf.

template<typename T>
TFactor<T> dai::TFactor< T >::inverse ( bool  zero = true  )  const [inline]

Returns pointwise inverse.

If zero == true, uses 1/0==0; otherwise, 1/0==Inf.

template<typename T>
TFactor<T> dai::TFactor< T >::normalized ( ProbNormType  norm = NORMPROB  )  const [inline]

Returns normalized copy of *this, using the specified norm.

Exceptions:
NOT_NORMALIZABLE if the norm is zero

template<typename T>
TFactor<T>& dai::TFactor< T >::randomize (  )  [inline]

Draws all values i.i.d. from a uniform distribution on [0,1).

template<typename T>
TFactor<T>& dai::TFactor< T >::setUniform (  )  [inline]

Sets all values to $1/n$ where n is the number of states.

template<typename T>
TFactor<T>& dai::TFactor< T >::takeAbs (  )  [inline]

Applies absolute value pointwise.

template<typename T>
TFactor<T>& dai::TFactor< T >::takeExp (  )  [inline]

Applies exponent pointwise.

template<typename T>
TFactor<T>& dai::TFactor< T >::takeLog ( bool  zero = false  )  [inline]

Applies logarithm pointwise.

If zero == true, uses log(0)==0; otherwise, log(0)==-Inf.

template<typename T>
T dai::TFactor< T >::normalize ( ProbNormType  norm = NORMPROB  )  [inline]

Normalizes factor using the specified norm.

Exceptions:
NOT_NORMALIZABLE if the norm is zero

template<typename T>
TFactor<T>& dai::TFactor< T >::fill ( T  x  )  [inline]

Sets all values to x.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator+= ( T  x  )  [inline]

Adds scalar x to each value.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator-= ( T  x  )  [inline]

Subtracts scalar x from each value.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator*= ( T  x  )  [inline]

Multiplies each value with scalar x.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator/= ( T  x  )  [inline]

Divides each entry by scalar x.

template<typename T>
TFactor<T>& dai::TFactor< T >::operator^= ( T  x  )  [inline]

Raises values to the power x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator+ ( T  x  )  const [inline]

Returns sum of *this and scalar x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator- ( T  x  )  const [inline]

Returns difference of *this and scalar x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator* ( T  x  )  const [inline]

Returns product of *this with scalar x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator/ ( T  x  )  const [inline]

Returns quotient of *this with scalar x.

template<typename T>
TFactor<T> dai::TFactor< T >::operator^ ( T  x  )  const [inline]

Returns *this raised to the power x.

template<typename T>
template<typename binOp>
TFactor<T>& dai::TFactor< T >::binaryOp ( const TFactor< T > &  g,
binOp  op 
) [inline]

Applies binary operation op on two factors, *this and g.

Template Parameters:
binOp Type of function object that accepts two arguments of type T and outputs a type T
Parameters:
g Right operand
op Operation of type binOp

template<typename T>
TFactor<T>& dai::TFactor< T >::operator+= ( const TFactor< T > &  g  )  [inline]

Adds g to *this.

The sum of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[f+g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) + g(x_M).\]

template<typename T>
TFactor<T>& dai::TFactor< T >::operator-= ( const TFactor< T > &  g  )  [inline]

Subtracts g from *this.

The difference of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[f-g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) - g(x_M).\]

template<typename T>
TFactor<T>& dai::TFactor< T >::operator*= ( const TFactor< T > &  g  )  [inline]

Multiplies *this with g.

The product of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[fg : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) g(x_M).\]

template<typename T>
TFactor<T>& dai::TFactor< T >::operator/= ( const TFactor< T > &  g  )  [inline]

Divides *this by g (where division by zero yields zero).

The quotient of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\]

template<typename T>
template<typename binOp>
TFactor<T> dai::TFactor< T >::binaryTr ( const TFactor< T > &  g,
binOp  op 
) const [inline]

Returns result of applying binary operation op on two factors, *this and g.

Template Parameters:
binOp Type of function object that accepts two arguments of type T and outputs a type T
Parameters:
g Right operand
op Operation of type binOp

template<typename T>
TFactor<T> dai::TFactor< T >::operator+ ( const TFactor< T > &  g  )  const [inline]

Returns sum of *this and g.

The sum of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[f+g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) + g(x_M).\]

template<typename T>
TFactor<T> dai::TFactor< T >::operator- ( const TFactor< T > &  g  )  const [inline]

Returns *this minus g.

The difference of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[f-g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) - g(x_M).\]

template<typename T>
TFactor<T> dai::TFactor< T >::operator* ( const TFactor< T > &  g  )  const [inline]

Returns product of *this with g.

The product of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[fg : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) g(x_M).\]

template<typename T>
TFactor<T> dai::TFactor< T >::operator/ ( const TFactor< T > &  g  )  const [inline]

Returns quotient of *this by f (where division by zero yields zero).

The quotient of two factors is defined as follows: if $f : \prod_{l\in L} X_l \to [0,\infty)$ and $g : \prod_{m\in M} X_m \to [0,\infty)$, then

\[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\]

template<typename T>
TFactor< T > dai::TFactor< T >::slice ( const VarSet &  vars,
size_t  varsState 
) const [inline]

Returns a slice of *this, where the subset vars is in state varsState.

Precondition:
vars sould be a subset of vars()

varsState < vars.nrStates()

The result is a factor that depends on the variables of *this except those in vars, obtained by setting the variables in vars to the joint state specified by the linear index varsState. Formally, if *this corresponds with the factor $f : \prod_{l\in L} X_l \to [0,\infty)$, $M \subset L$ corresponds with vars and varsState corresponds with a mapping $s$ that maps a variable $x_m$ with $m\in M$ to its state $s(x_m) \in X_m$, then the slice returned corresponds with the factor $g : \prod_{l \in L \setminus M} X_l \to [0,\infty)$ defined by $g(\{x_l\}_{l\in L \setminus M}) = f(\{x_l\}_{l\in L \setminus M}, \{s(x_m)\}_{m\in M})$.

template<typename T>
TFactor<T> dai::TFactor< T >::embed ( const VarSet &  vars  )  const [inline]

Embeds this factor in a larger VarSet.

Precondition:
vars() should be a subset of vars
If *this corresponds with $f : \prod_{l\in L} X_l \to [0,\infty)$ and $L \subset M$, then the embedded factor corresponds with $g : \prod_{m\in M} X_m \to [0,\infty) : x \mapsto f(x_L)$.

template<typename T>
TFactor< T > dai::TFactor< T >::marginal ( const VarSet &  vars,
bool  normed = true 
) const [inline]

Returns marginal on vars, obtained by summing out all variables except those in vars, and normalizing the result if normed == true.

template<typename T>
TFactor< T > dai::TFactor< T >::maxMarginal ( const VarSet &  vars,
bool  normed = true 
) const [inline]

Returns max-marginal on vars, obtained by maximizing all variables except those in vars, and normalizing the result if normed == true.

Friends And Related Function Documentation

template<typename T>
std::ostream & operator<< ( std::ostream &  os,
const TFactor< T > &  f 
) [related]

Writes a factor to an output stream.

template<typename T>
T dist ( const TFactor< T > &  f,
const TFactor< T > &  g,
ProbDistType  dt 
) [related]

Returns distance between two factors f and g, according to the distance measure dt.

Precondition:
f.vars() == g.vars()

template<typename T>
TFactor< T > max ( const TFactor< T > &  f,
const TFactor< T > &  g 
) [related]

Returns the pointwise maximum of two factors.

Precondition:
f.vars() == g.vars()

template<typename T>
TFactor< T > min ( const TFactor< T > &  f,
const TFactor< T > &  g 
) [related]

Returns the pointwise minimum of two factors.

Precondition:
f.vars() == g.vars()

template<typename T>
T MutualInfo ( const TFactor< T > &  f  )  [related]

Calculates the mutual information between the two variables that f depends on, under the distribution given by f.

Precondition:
f.vars().size() == 2

Member Data Documentation

template<typename T>
VarSet dai::TFactor< T >::_vs [private]

Stores the variables on which the factor depends.

template<typename T>
TProb<T> dai::TFactor< T >::_p [private]

Stores the factor values.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1HAK-members.html0000644000263000017630000003146011433220721020255 0ustar jorismkyb libDAI: Member List

dai::HAK Member List

This is the complete list of members for dai::HAK, including all inherited members.

_itersdai::HAK [private]
_maxdiffdai::HAK [private]
_muabdai::HAK [private]
_mubadai::HAK [private]
_Qadai::HAK [private]
_Qbdai::HAK [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const VarSet &vs) const dai::HAK [virtual]
dai::DAIAlg::belief(const Var &v) const dai::InfAlg [inline, virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::HAK [virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::HAK [inline, virtual]
construct()dai::HAK [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
doDoubleLoop()dai::HAK
doGBP()dai::HAK
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findLoopClusters(const FactorGraph &fg, std::set< VarSet > &allcl, VarSet newcl, const Var &root, size_t length, VarSet vars)dai::HAK [private]
findMaximum() const dai::InfAlg [inline, virtual]
getProperties() const dai::HAK [virtual]
HAK()dai::HAK [inline]
HAK(const FactorGraph &fg, const PropertySet &opts)dai::HAK
HAK(const RegionGraph &rg, const PropertySet &opts)dai::HAK
identify() const dai::HAK [virtual]
init()dai::HAK [virtual]
init(const VarSet &vs)dai::HAK [virtual]
Iterations() const dai::HAK [inline, virtual]
logZ() const dai::HAK [virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::HAK [inline, virtual]
muab(size_t alpha, size_t _beta)dai::HAK [inline]
muba(size_t alpha, size_t _beta)dai::HAK [inline]
Namedai::HAK [static]
printProperties() const dai::HAK [virtual]
props (defined in dai::HAK)dai::HAK
Qa(size_t alpha) const dai::HAK [inline]
Qb(size_t beta) const dai::HAK [inline]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::HAK [virtual]
setMaxIter(size_t maxiter)dai::HAK [inline, virtual]
setProperties(const PropertySet &opts)dai::HAK [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func.html0000644000263000017630000001031311433220721017073 0ustar jorismkyb libDAI: Class Members - Functions
 

- _ -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_67.png0000644000263000017630000000100711433220721015147 0ustar jorismkyb‰PNG  IHDRˆri‹D0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf…IDAT8c`L@L—ŒD´áÓË”¡™?10ƒYŒJ~ Ê>Da™ŠÄj³80p«,2ØúÐM¹ÅÀÀ»Y`&ƒ?‚ñ(3dÃv‹Ÿ !Œ¸xöȆ|cè%Îæ ÌH\4Cú‰3„áÿqdÂY a™@OÙ¶ƒ`V—ñ†0C…3gÎœ1„iX׆k ³ñÒ Ö¿ èSÆ6(Þá)³€a’Íp™íІ¯ L_@ˆíHbÈa†Ê™ €jç0p)LCâ°léÌØf-e˜ÎÀ¸„˜'0E †|`ºh&CÉÌI àfp®šŒd8@É/PC˜€Òû¨ðUC a»ör˜S€ˆ@‘× |8 øfÎdà `ƒˆ+£Âg¡ËÐäþ70®ÿÁkÌ dó3h`QÁ„7{"æÆ¥Æ ž.“‰T °¤á“dwcE`B8IEND®B`‚libDAI-0.2.7/doc/html/form_66.png0000644000263000017630000000050311433220721015146 0ustar jorismkyb‰PNG  IHDR4æ£àó0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÁIDAT•c` dtAV)ŽO‚‚þHÌ ÖG{dÅñœqHñ-paÀ!Åö­—Ã\RL÷¸°J©Ë0ð*À¥˜7€mYÒTÀ}a Ó¦™SØ'|X>3x#¤Ø¸l ×ÙWp® ˜†âQ(²ùáö1,Ÿüøº€ê1°A¥D@Dî¶û‡mÔìJ†‰ €Í½Ùˆ©Ì½S Ä’Qù í0¶¦Œ&IEND®B`‚libDAI-0.2.7/doc/html/var_8h-source.html0000644000263000017630000005005411433220721016543 0ustar jorismkyb libDAI: include/dai/var.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1MR-members.html0000644000263000017630000003376111433220721020176 0ustar jorismkyb libDAI: Member List

dai::MR Member List

This is the complete list of members for dai::MR, including all inherited members.

_itersdai::MR [private]
_maxdiffdai::MR [private]
_tJ(size_t i, sub_nb A)dai::MR [private]
appM(size_t i, sub_nb A)dai::MR [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::MR [inline, virtual]
belief(const VarSet &) const dai::MR [virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::MR [virtual]
beliefV(size_t i) const dai::MR [virtual]
calcCavityCorrelations()dai::MR [private]
calcMagnetizations()dai::MR [private]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::MR [inline, virtual]
corsdai::MR [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::InfAlg [inline, virtual]
Gdai::MR [private]
Gamma(size_t i, size_t _j, size_t _l1, size_t _l2)dai::MR [private]
Gamma(size_t i, size_t _l1, size_t _l2)dai::MR [private]
getProperties() const dai::MR [virtual]
identify() const dai::MR [virtual]
init()dai::MR [inline, virtual]
init(const VarSet &)dai::MR [inline, virtual]
Iterations() const dai::MR [inline, virtual]
logZ() const dai::MR [inline, virtual]
Mdai::MR [private]
Magdai::MR [private]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::MR [inline, virtual]
MR()dai::MR [inline]
MR(const FactorGraph &fg, const PropertySet &opts)dai::MR
Namedai::MR [static]
Omega(size_t i, size_t _j, size_t _l)dai::MR [private]
printProperties() const dai::MR [virtual]
propagateCavityFields()dai::MR [private]
props (defined in dai::MR)dai::MR
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::MR [virtual]
setMaxIter(size_t)dai::InfAlg [inline, virtual]
setProperties(const PropertySet &opts)dai::MR [virtual]
sub_nb typedefdai::MR [private]
sum_subs(size_t j, sub_nb A, Real *sum_even, Real *sum_odd)dai::MR [private]
supporteddai::MR [private]
T(size_t i, sub_nb A)dai::MR [private]
T(size_t i, size_t _j)dai::MR [private]
thetadai::MR [private]
tJdai::MR [private]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/mf_8h-source.html0000644000263000017630000005023611433220721016357 0ustar jorismkyb libDAI: include/dai/mf.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_78.png0000644000263000017630000000113111433220721015147 0ustar jorismkyb‰PNG  IHDRŽwû0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf×IDAT8Í“=HÃ@ÇÿùªI[luéhð³RÄZÅÁ ‚ B‹(u¨ *8¨  .vQ;ÆA!º¢à&îBÁÑ/q±:8µµ:8ˆwmÓ&mºùÜÝ{÷Þïîåî€+.F¥ü&TŒšL¿y68USóU–ÓC,Zâ³»0˜ýæYWø,ãhgÑhþ‚ƒ7^)uIx'_q©sTj­9 se.‰IáÂ~x–€k:ncSÀ“5Ç7™ÊáRx$½¸ùÅžylÄ%›¬9mI“Y-rÔí nȘI §ù…+rØ¥}ÈkD{ÏEN¸OÃ%í‘Šœy`‹T ÎÁ¬ ŽmçÝ"­ i¼’¾ì“›ph]L¢DŸ›9­Z“2wGöGÐÏOˆ»yNm–sŒ¤C… >GZ’‘ ÍAÒÌ8£MS •®FxògÖ±w„§|c¨U‚–m*MÅú=X•Öqêb{ÒCUô¦/«}×zb¼š»4q¨Ýeš¸5rÐ#DwÅ-ÄŒ\УÉIáŠY:‡/<+/m¸ý4®^0üÚ°û3rA÷»³ääTMf¤RÌ¢ ÓX픽ŠÒ­T ø‹˜«­XèXpu°5Žž,ÆÞ×µ$×ÙìM3åþìI{8šÁD„ç7l£ƒídeѯ€ùõKØ2¦(ÀkÙ•¿Pð»¼Î†[–6Óø ¡„‚™rTÐíPE}¢¡ßRÛäÈvévñ/ãž*Y”Z/DIEND®B`‚libDAI-0.2.7/doc/html/form_68.png0000644000263000017630000000025711433220721015156 0ustar jorismkyb‰PNG  IHDR Þ¹°0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf-IDAT™c`@ÌÆ@’õôï@Ê‹a)HìÃ4õ€á!ˆºÀZ¢ÌRš/Ú„”IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1LC_1_1Properties-members.html0000644000263000017630000001027211433220721023102 0ustar jorismkyb libDAI: Member List

dai::LC::Properties Member List

This is the complete list of members for dai::LC::Properties, including all inherited members.

cavainamedai::LC::Properties
cavaioptsdai::LC::Properties
cavitydai::LC::Properties
DAI_ENUM(CavityType, FULL, PAIR, PAIR2, UNIFORM)dai::LC::Properties
DAI_ENUM(UpdateType, SEQFIX, SEQRND)dai::LC::Properties
dampingdai::LC::Properties
maxiterdai::LC::Properties
reinitdai::LC::Properties
toldai::LC::Properties
updatesdai::LC::Properties
verbosedai::LC::Properties

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x71.html0000644000263000017630000001031011433220721017647 0ustar jorismkyb libDAI: Class Members - Functions
 

- q -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_120.png0000644000263000017630000000026011433220721015215 0ustar jorismkyb‰PNG  IHDR Þ¹°0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf.IDAT™c`@LA¢@J…Ï{JàgR‰êA$+A*>cRŒG,ạFÌí Â³IEND®B`‚libDAI-0.2.7/doc/html/form_42.png0000644000263000017630000000067011433220721015145 0ustar jorismkyb‰PNG  IHDR€ Xb¨[0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf6IDAT(‘c` 0£ 0`QeÈ,€&¬¡Ùt¼& Ê4™cêgÕ »€&41Bð‹9d€Y’3gÎœ tÀ†pgt‚x“ ¬!ÌL 2 •ì “¡rò Èjÿ/`^†á~]–ÿPV4Ãa0C¢£££èÖ¯ m ¬É*k*ûÈ&š´ïÀ26†  «!eÏÐ4€eÇîâH`ØÍlpêBˆ²†¡Z}Étf>À¼a—˜IÐÖ œx @ˆó÷h†(N25qà ¸as”0 GÐx DÀlæ#,mE(Êx™®@UÄ€“Ìe .Ä°¦Å(Ê8“áJ6£6ö„åèÊà@§ Ô;?¶ sØ IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1MF_1_1Properties-members.html0000644000263000017630000000675311433220721023117 0ustar jorismkyb libDAI: Member List

dai::MF::Properties Member List

This is the complete list of members for dai::MF::Properties, including all inherited members.

DAI_ENUM(InitType, UNIFORM, RANDOM)dai::MF::Properties
DAI_ENUM(UpdateType, NAIVE, HARDSPIN)dai::MF::Properties
dampingdai::MF::Properties
initdai::MF::Properties
maxiterdai::MF::Properties
toldai::MF::Properties
updatesdai::MF::Properties
verbosedai::MF::Properties

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/jtree_8h-source.html0000644000263000017630000006025311433220721017066 0ustar jorismkyb libDAI: include/dai/jtree.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x6d.html0000644000263000017630000002631211433220721016727 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- m -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_85.png0000644000263000017630000000030611433220721015150 0ustar jorismkyb‰PNG  IHDR '°p0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfDIDAT™c`ÀXRÌ  L'~› Pf?B…-œ¥ÐÁÌ<Ósê&æÇؘ29 –EKØó <†*ºÀ˼ Ù6 šœ$IEND®B`‚libDAI-0.2.7/doc/html/formula.repository0000644000263000017630000001710711433220721017000 0ustar jorismkyb\form#0:$\frac{\exp(a)}{\exp(a)+\exp(b)}$ \form#1:$\log\left(\exp(a) + \exp(b)\right)$ \form#2:$m_{I\to i}(x_i)$ \form#3:$I$ \form#4:$i$ \form#5:\[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\] \form#6:\[ m_{I\to i}(x_i) \propto \max_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\] \form#7:\[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}(x_i)\] \form#8:\[ b_I(x_I) \propto f_I(x_I) \prod_{j\in N_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}(x_j) \] \form#9:\[ \log Z = \sum_i (1 - |N_i|) \sum_{x_i} b_i(x_i) \log b_i(x_i) - \sum_I \sum_{x_I} b_I(x_I) \log \frac{b_I(x_I)}{f_I(x_I)} \] \form#10:$ x_i $ \form#11:$ x_i^* $ \form#12:$ x_i = x_i^* $ \form#13:$\delta_{x_i, x}$ \form#14:\[ P(\mathbf{x}) = \prod_{i\in\mathcal{V}} P(x_i \,|\, x_{\mathrm{pa}(i)}) \] \form#15:$\mathrm{pa}(i)$ \form#16:\[ P(\mathbf{x}) = \frac{1}{Z} \prod_{C\in\mathcal{C}} \psi_C(x_C) \] \form#17:$ \mathcal{C} $ \form#18:$ \psi_C(x_C) $ \form#19:$ Z $ \form#20:\[ P(\mathbf{x}) = \frac{1}{Z} \prod_{I\in \mathcal{F}} f_I(x_I) \] \form#21:$ \mathcal{F} $ \form#22:$ f_I(x_I) $ \form#23:$\{x_i\}_{i\in\mathcal{V}}$ \form#24:$\{f_I(x_I)\}_{I\in\mathcal{F}}$ \form#25:\[ Z = \sum_{\mathbf{x}_{\mathcal{V}}} \prod_{I \in \mathcal{F}} f_I(x_I) \] \form#26:$\{x_i\}_{i\in A}$ \form#27:\[ P(\mathbf{x}_{A}) = \frac{1}{Z} \sum_{\mathbf{x}_{\mathcal{V}\setminus A}} \prod_{I \in \mathcal{F}} f_I(x_I) \] \form#28:\[ \mathrm{argmax}_{\mathbf{x}}\,\prod_{I\in\mathcal{F}} f_I(x_I) \] \form#29:$l$ \form#30:$x_l$ \form#31:$S_{x_l}$ \form#32:$S_l$ \form#33:$X_l := \{0,1,\dots,S_l-1\}$ \form#34:$A := \{x_{l_1},x_{l_2},\dots,x_{l_n}\}$ \form#35:$l_1 < l_2$ \form#36:$x_{l_1}$ \form#37:$x_{l_2}$ \form#38:$(l_i)_{i=1}^n$ \form#39:$l_1 < l_2 < \dots < l_n$ \form#40:$ \prod_{i=1}^n X_{l_i}$ \form#41:$(s_1,s_2,\dots,s_n)$ \form#42:$x_{l_1} = s_1, \dots, x_{l_n} = s_n$ \form#43:\[ s := \sum_{i=1}^n s_i \prod_{j=1}^{i-1} S_{l_j} = s_1 + s_2 S_{l_1} + s_3 S_{l_1} S_{l_2} + \dots + s_n S_{l_1} \cdots S_{l_{n-1}}. \] \form#44:$s_i$ \form#45:$x_{l_i}$ \form#46:\[ s_i = \left\lfloor\frac{s \mbox { mod } \prod_{j=1}^i S_{l_j}}{\prod_{j=1}^{i-1} S_{l_j}}\right\rfloor. \] \form#47:$\prod_{i=1}^n S_{l_i}$ \form#48:\[ \begin{array}{ccc|c} x_4 & x_8 & x_7 & \mbox{value}\\ \hline 0 & 0 & 0 & 0.1\\ 1 & 0 & 0 & 3.5\\ 2 & 0 & 0 & 2.8\\ 0 & 1 & 0 & 6.3\\ 1 & 1 & 0 & 8.4\\ 2 & 1 & 0 & 0.0\\ 0 & 0 & 1 & 7.4\\ 1 & 0 & 1 & 2.4\\ 2 & 0 & 1 & 8.9\\ 0 & 1 & 1 & 1.3\\ 1 & 1 & 1 & 1.6\\ 2 & 1 & 1 & 2.6 \end{array} \] \form#49:$x_4$ \form#50:$x_8$ \form#51:$x_7$ \form#52:$x_4 x_7 x_8$ \form#53:\[ \begin{array}{ccc|c} x_4 & x_7 & x_8 & \mbox{value}\\ \hline 0 & 0 & 0 & 0.1\\ 1 & 0 & 0 & 3.5\\ 2 & 0 & 0 & 2.8\\ 0 & 1 & 0 & 7.4\\ 1 & 1 & 0 & 2.4\\ 2 & 1 & 0 & 8.9\\ 0 & 0 & 1 & 6.3\\ 1 & 0 & 1 & 8.4\\ 2 & 0 & 1 & 0.0\\ 0 & 1 & 1 & 1.3\\ 1 & 1 & 1 & 1.6\\ 2 & 1 & 1 & 2.6 \end{array} \] \form#54:$x_1 = 0, x_3 = 0, x_2 = 1$ \form#55:$x_1 = 1, x_3 = 0, x_2 = 1$ \form#56:$x_1 = 1, x_2 = 1$ \form#57:$x_3$ \form#58:$ P( X | Y ) $ \form#59:$ | X | $ \form#60:$ |X| \cdot |Y| $ \form#61:$ P(X | Y=y) $ \form#62:$ \frac{\log(Z_t) - \log(Z_{t-1})}{| \log(Z_{t-1}) | } < \mathrm{tol} $ \form#63:$X_l = \{0,1,\dots,S_l-1\}$ \form#64:$\{x_l\}_{l\in L}$ \form#65:$f_L : \prod_{l\in L} X_l \to [0,\infty)$ \form#66:$\prod_{l\in L} X_l$ \form#67:$\{0,1,\dots,\prod_{l\in L} S_l-1\}$ \form#68:$\sigma$ \form#69:$ \exp(hx) $ \form#70:$ x = \pm 1 $ \form#71:$ \exp(J x_1 x_2) $ \form#72:$ x_1, x_2 = \pm 1 $ \form#73:$ \exp( J \delta_{x_1, x_2} ) $ \form#74:$\prod_{l\in L} S_l$ \form#75:$-\sum_i p_i \log p_i$ \form#76:$1/n$ \form#77:$f : \prod_{l\in L} X_l \to [0,\infty)$ \form#78:$g : \prod_{m\in M} X_m \to [0,\infty)$ \form#79:\[f+g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) + g(x_M).\] \form#80:\[f-g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) - g(x_M).\] \form#81:\[fg : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) g(x_M).\] \form#82:\[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\] \form#83:$M \subset L$ \form#84:$s$ \form#85:$x_m$ \form#86:$m\in M$ \form#87:$s(x_m) \in X_m$ \form#88:$g : \prod_{l \in L \setminus M} X_l \to [0,\infty)$ \form#89:$g(\{x_l\}_{l\in L \setminus M}) = f(\{x_l\}_{l\in L \setminus M}, \{s(x_m)\}_{m\in M})$ \form#90:$L \subset M$ \form#91:$g : \prod_{m\in M} X_m \to [0,\infty) : x \mapsto f(x_L)$ \form#92:$N$ \form#93:$x_0,x_1,\dots,x_{N-1}$ \form#94:$M$ \form#95:\[ P(x_0,x_1,\dots,x_{N-1}) = \frac{1}{Z} \prod_{I=0}^{M-1} f_I(x_I), \qquad Z = \sum_{x_0}\dots\sum_{x_{N-1}} \prod_{I=0}^{M-1} f_I(X_I). \] \form#96:$f_I$ \form#97:$X_I \subset \{x_0,x_1,\dots,x_{N-1}\}$ \form#98:$\min_q KL(p||q)$ \form#99:$ KL(q||p) $ \form#100:$ c_I $ \form#101:$ \alpha=1/c_I $ \form#102:\[ m_{I\to i}(x_i) \propto \left( \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \right)^{c_I} \] \form#103:\[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i} \] \form#104:\[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \] \form#105:\[ \log Z = \sum_{I} \sum_{x_I} b_I(x_I) \big( \log f_I(x_I) - c_I \log b_I(x_I) \big) + \sum_{i} (c_i - 1) \sum_{x_i} b_i(x_i) \log b_i(x_i) \] \form#106:\[ c_i := \sum_{I \in N_i} c_I \] \form#107:$ \phi^{\setminus i}_I(x_{I \setminus i}) $ \form#108:$b_i$ \form#109:\[ b_i^{\mathrm{new}}(x_i) \propto \prod_{I\in N_i} \exp \left( \sum_{x_{N_I \setminus \{i\}}} \log f_I(x_I) \prod_{j \in N_I \setminus \{i\}} b_j(x_j) \right) \] \form#110:\[ b_i^{\mathrm{new}}(x_i) \propto \prod_{I\in N_i} \left( \sum_{x_{N_I \setminus \{i\}}} f_I(x_I) \prod_{j \in N_I \setminus \{i\}} b_j(x_j) \right) \] \form#111:$ M^{(i)}_j $ \form#112:$ \Omega^{(i)}_{j,l} $ \form#113:$ T^{(i)}_A $ \form#114:$ A = \{l_1,l_2,\dots\} $ \form#115:$ T^{(i)}_j $ \form#116:$ \Gamma^{(i)}_{j,l_1l_2} $ \form#117:$ \Gamma^{(i)}_{l_1l_2} $ \form#118:$\alpha$ \form#119:$\beta$ \form#120:$x$ \form#121:\[\sum_{\alpha \ni x} c_\alpha + \sum_{\beta \ni x} c_\beta = 1\] \form#122:\[ c_\beta := 1 - \sum_{\gamma \in \mathrm{an}(\beta)} c_\gamma \] \form#123:$\mathrm{an}(\beta)$ \form#124:$\tilde f_i(x_j,x_k)$ \form#125:$\tilde f_i(x_s)$ \form#126:\[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \] \form#127:\[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}^{c_I} \] \form#128:\[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \] \form#129:$\ell_1$ \form#130:$\ell_\infty$ \form#131:$\sum_i p_i (\log p_i - \log q_i)$ \form#132:$\frac{1}{2}\sum_i (\sqrt{p_i}-\sqrt{q_i})^2$ \form#133:$\{x_{l(0)},x_{l(1)},\dots,x_{l(n-1)}\}$ \form#134:$l(0) < l(1) < \dots < l(n-1)$ \form#135:$s(x_l) \in \{0,1,\dots,S_l-1\}$ \form#136:$s(x_l)=0$ \form#137:$S$ \form#138:\begin{eqnarray*} S &:=& \sum_{i=0}^{n-1} s(x_{l(i)}) \prod_{j=0}^{i-1} S_{l(j)} \\ &= & s(x_{l(0)}) + s(x_{l(1)}) S_{l(0)} + s(x_{l(2)}) S_{l(0)} S_{l(1)} + \dots + s(x_{l(n-1)}) S_{l(0)} \cdots S_{l(n-2)}. \end{eqnarray*} \form#139:$l\in L$ \form#140:$\sigma : \prod_{l\in L} X_l \to \{0,1,\dots,\prod_{l\in L} S_l-1\}$ \form#141:$\sigma^{-1}$ \form#142:$s(x_l)$ \form#143:\begin{eqnarray*} s(x_{l(i)}) = \left\lfloor\frac{S \mbox { mod } \prod_{j=0}^{i} S_{l(j)}}{\prod_{j=0}^{i-1} S_{l(j)}}\right\rfloor \qquad \mbox{for all $i=0,\dots,n-1$}. \end{eqnarray*} \form#144:$\sigma^{-1} : \{0,1,\dots,\prod_{l\in L} S_l-1\} \to \prod_{l\in L} X_l$ libDAI-0.2.7/doc/html/classdai_1_1SmallSet-members.html0000644000263000017630000003103111433220721021370 0ustar jorismkyb libDAI: Member List

dai::SmallSet< T > Member List

This is the complete list of members for dai::SmallSet< T >, including all inherited members.

_elementsdai::SmallSet< T > [private]
back()dai::SmallSet< T > [inline]
back() const dai::SmallSet< T > [inline]
begin()dai::SmallSet< T > [inline]
begin() const dai::SmallSet< T > [inline]
const_iterator typedefdai::SmallSet< T >
const_reverse_iterator typedefdai::SmallSet< T >
contains(const T &t) const dai::SmallSet< T > [inline]
elements()dai::SmallSet< T > [inline]
elements() const dai::SmallSet< T > [inline]
empty() const dai::SmallSet< T > [inline]
end()dai::SmallSet< T > [inline]
end() const dai::SmallSet< T > [inline]
erase(const T &t)dai::SmallSet< T > [inline]
front()dai::SmallSet< T > [inline]
front() const dai::SmallSet< T > [inline]
insert(const T &t)dai::SmallSet< T > [inline]
intersects(const SmallSet &x) const dai::SmallSet< T > [inline]
iterator typedefdai::SmallSet< T >
operator &(const SmallSet &x) const dai::SmallSet< T > [inline]
operator &=(const SmallSet &x)dai::SmallSet< T > [inline]
operator!=(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator/(const SmallSet &x) const dai::SmallSet< T > [inline]
operator/=(const SmallSet &x)dai::SmallSet< T > [inline]
operator/=(const T &t)dai::SmallSet< T > [inline]
operator<(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator<<(const SmallSet &x) const dai::SmallSet< T > [inline]
operator<<(std::ostream &os, const SmallSet &x)dai::SmallSet< T > [friend]
operator==(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator>>(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|=(const SmallSet &x)dai::SmallSet< T > [inline]
operator|=(const T &t)dai::SmallSet< T > [inline]
rbegin()dai::SmallSet< T > [inline]
rbegin() const dai::SmallSet< T > [inline]
rend()dai::SmallSet< T > [inline]
rend() const dai::SmallSet< T > [inline]
reverse_iterator typedefdai::SmallSet< T >
size() const dai::SmallSet< T > [inline]
SmallSet()dai::SmallSet< T > [inline]
SmallSet(const T &t)dai::SmallSet< T > [inline]
SmallSet(const T &t1, const T &t2)dai::SmallSet< T > [inline]
SmallSet(TIterator begin, TIterator end, size_t sizeHint)dai::SmallSet< T > [inline]

Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BP__dual_1_1__edges__t-members.html0000644000263000017630000000321211433220721024160 0ustar jorismkyb libDAI: Member List

dai::BP_dual::_edges_t< T > Member List

This is the complete list of members for dai::BP_dual::_edges_t< T >, including all inherited members.

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_124.png0000644000263000017630000000061711433220721015227 0ustar jorismkyb‰PNG  IHDR;ÁñXc0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf IDAT(‘c` plvÀ'­h¥@Ð& # ˆÕ14°C5p牘N€Pü@e¬˜Ò“Á$c¼!k€ T<”ÅDyBœ07‘—!¡ËbÇâ Z¢¸“̀ѡ“… d‡Ç®>ˆô5ó(ÌRž¸ôG†á ˜ÂÁÆó3(ð‰€ÅÀÂú ¼Ü“>ˆ2ipO`Ø©Ï ç`À`–e¾ÔÍîÀÞRê4mC…{CÕ&†R°Ã# ®:0n`€:ì'†ƒebß t+C0X4‚ÅÌ0`†˜QÎrT&rвb##fÈâ„F)Bž2} IEND®B`‚libDAI-0.2.7/doc/html/daialg_8h-source.html0000644000263000017630000006736111433220721017205 0ustar jorismkyb libDAI: include/dai/daialg.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_45.png0000644000263000017630000000031611433220721015145 0ustar jorismkyb‰PNG  IHDR <ð0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfLIDAT™c`@ÌP›Ž×«€_Ì!”g`¨€°¢ƒhÆËØ08000}Étf>À`‘ç(a €°‹˜ `¦³'"Y’Ò sàõ#çIEND®B`‚libDAI-0.2.7/doc/html/form_70.png0000644000263000017630000000035611433220721015147 0ustar jorismkyb‰PNG  IHDR,¦Îã0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØflIDAT•c` 09‰ aæ÷oX…®1[†Wá~Í–™@`¤fŸR a~¬†0ø1£1 Lgº+ …™?MEÑÑu¢CÁâ/PΙÙa´ 00 âõ1&d•€îûIEND®B`‚libDAI-0.2.7/doc/html/functions_func_0x75.html0000644000263000017630000001152411433220721017663 0ustar jorismkyb libDAI: Class Members - Functions
 

- u -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_16.png0000644000263000017630000000134311433220721015144 0ustar jorismkyb‰PNG  IHDR„$ºvz0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfaIDATH‰Ý•ÏkQÇ¿û#¿›dQC£zëJ tÁö`/n!â1 !X„D´E(!xq/V6½ÁCâ¡þ ­ x’è ñ"ˆS­ qÞÛüØÄ5Ö]¼8Ùyof?™7oÞ[à_ŠRŒÈTƒ§qïÿBÌu¾ÙözçC, Ÿhw:»ˆ×ûj1íPz†¤q}ºRÑçÝaûßZ¿ Ô®o¥%¬p{Ï{¬ŠqÌ+?7"â<¢Ù¾÷WñîKOÅ8´¸;Äw‚«´‰¦TX™¡9¡ê‡q˜Ýk: ¤!ÚŒgq±öؤè‰7b¾5?%Ê÷êÑ7;Nâ¼û’Âß©z¯i®T*i:×C —6Yáâe +-“ù”9žÐØТ+rƒË0b‚±¨ü s<,b!TÚƒøÊäWm±˜mÛ½’ÖÌ\:KM±Eo˜Ùi€”»ÒæE1‘<üh-gjæˆy‡wq=­-¾ådÀµ:-B±Ô*ª–l¹^¥ºžFHËy,Îàlþ^p3¡õâ¾pµ íÔZy{ÁÛâ ¦êHˆÑ9„¨«úñ¢Épܽ€+˜ÒGû(“¢Aµ-(ssuµÁ5s#˜¼3R ô“>Ù3dã$iŽ"þZº·ÌÆZqgü¿ýFR–8Ú Ú®†¯/B£{‰ø—x倈B}}; ¢'§f¯ò‡´Àüâ ïpÛÆLØ7b™ŽcÄ„¼"û%à3Ä9 kÍ·´!eS¶ €¸… ÿ6Ķ&µ?{‹ZÔ!=Îa‰ùOCpJcœ?êýœ1Ô“ñIEND®B`‚libDAI-0.2.7/doc/html/enum_8h-source.html0000644000263000017630000002231011433220721016711 0ustar jorismkyb libDAI: include/dai/enum.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/authors.html0000644000263000017630000000435711433220721015550 0ustar jorismkyb libDAI: Authors

Authors

People who contributed to libDAI

libDAI was written by Joris M. Mooij with the help of the following people:

Martijn Leisink (laid down the foundations for the library),
Frederik Eaton (contributed the Gibbs sampler, conditioned BP, fractional BP and various other improvements),
Charles Vaske (contributed the parameter learning algorithms),
Giuseppe Passino (contributed the findMaximum function, and various other improvements),
Bastian Wemmenhove (contributed the MR algorithm),
Patrick Pletscher (contributed the SWIG interface).

Smaller contributions (bug fixes and miscellaneous smaller patches) have been made by:
Claudio Lima, Christian Wojek, Sebastian Nowozin, Stefano Pellegrini, Ofer Meshi,
Dan Preston, Peter Gober, Jiuxiang Hu, Peter Rockett, Dhruv Batra, Alexander Schwing, 
Alejandro Lage, Matt Dunham.

Part of this work was part of the Interactive Collaborative Information Systems (ICIS) 
project, supported by the Dutch Ministry of Economic Affairs, grant BSIK03024.
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_54.png0000644000263000017630000000070011433220721015142 0ustar jorismkyb‰PNG  IHDR€ÞöÚõ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf>IDAT(‘c`|@=›¨[26QL1Æ\ ˜¢,x°ˆÖcQʱå¦(oÇ,.àÀ–á…lï昢ü  cÅJ}Q6 _³€äž™@`3$ª”f‰Â H°ç5pU€‹B 0àg`ð@wP”éÀrtø0p(lDsƒ4€Ñ¸0€ŠLc``‰‚ ¸ÎÀiÐ…P0lS0°=`¿Àe=ôH”{Oƒ*SÀ#V†pQ°ÌŸ¦‹‚ €ÅÜ ö`Q†¸ ãAm†zöˇU¸ÁÈÜ H:3 ÀÀÀèekðEu``a`bQ`Ø$‚„éó BŽVˆ­)“°ˆrþ{À@°`5"¬‘*>K¸¬ƒh‹IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1fo__Hellinger-members.html0000644000263000017630000000364411433220721022630 0ustar jorismkyb libDAI: Member List

dai::fo_Hellinger< T > Member List

This is the complete list of members for dai::fo_Hellinger< T >, including all inherited members.

operator()(const T &p, const T &q) const dai::fo_Hellinger< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x67.html0000644000263000017630000000710511433220721017704 0ustar jorismkyb libDAI: Class Members - Variables
 

- g -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1BBP.html0000644000263000017630000036514211433220721016634 0ustar jorismkyb libDAI: dai::BBP Class Reference

dai::BBP Class Reference

Implements BBP (Back-Belief-Propagation) [EaG09]. More...

#include <dai/bbp.h>

List of all members.

Index cache management (for performance)

std::vector< std::vector
< _ind_t > > 		_indices
 Cached indices (indexed [i][_I]).
typedef std::vector< size_t > _ind_t
 Index type.
void RegenerateInds ()
 Prepares index cache _indices.
const _ind_t & _index (size_t i, size_t _I) const
 Returns an index from the cache.

Public Member Functions

Constructors/destructors
 BBP (const InfAlg *ia, const PropertySet &opts)
 Construct BBP object from a InfAlg ia and a PropertySet opts.
Initialization
void init (const std::vector< Prob > &adj_b_V, const std::vector< Prob > &adj_b_F, const std::vector< Prob > &adj_psi_V, const std::vector< Prob > &adj_psi_F)
 Initializes from given belief adjoints adj_b_V, adj_b_F and initial factor adjoints adj_psi_V, adj_psi_F.
void init (const std::vector< Prob > &adj_b_V, const std::vector< Prob > &adj_b_F)
 Initializes from given belief adjoints adj_b_V and adj_b_F (setting initial factor adjoints to zero).
void init_V (const std::vector< Prob > &adj_b_V)
 Initializes variable belief adjoints adj_b_V (and sets factor belief adjoints and initial factor adjoints to zero).
void init_F (const std::vector< Prob > &adj_b_F)
 Initializes factor belief adjoints adj_b_F (and sets variable belief adjoints and initial factor adjoints to zero).
void initCostFnAdj (const BBPCostFunction &cfn, const std::vector< size_t > *stateP)
 Initializes with adjoints calculated from cost function cfn, and state stateP.
BBP Algorithm
void run ()
 Perform iterative updates until change is less than given tolerance.
Query results
Prob & adj_psi_V (size_t i)
 Returns reference to variable factor adjoint.
const Prob & adj_psi_V (size_t i) const
 Returns constant reference to variable factor adjoint.
Prob & adj_psi_F (size_t I)
 Returns reference to factor adjoint.
const Prob & adj_psi_F (size_t I) const
 Returns constant reference to factor adjoint.
Prob & adj_b_V (size_t i)
 Returns reference to variable belief adjoint.
const Prob & adj_b_V (size_t i) const
 Returns constant reference to variable belief adjoint.
Prob & adj_b_F (size_t I)
 Returns reference to factor belief adjoint.
const Prob & adj_b_F (size_t I) const
 Returns constant reference to factor belief adjoint.
size_t Iterations ()
 Return number of iterations done so far.

Public Attributes

struct dai::BBP::Properties props

Private Member Functions

Prob unnormAdjoint (const Prob &w, Real Z_w, const Prob &adj_w)
 Computes the adjoint of the unnormed probability vector from the normalizer and the adjoint of the normalized probability vector.
Real getUnMsgMag ()
 Calculates averaged L1 norm of unnormalized message adjoints.
void getMsgMags (Real &s, Real &new_s)
 Calculates averaged L1 norms of current and new normalized message adjoints.
void getArgmaxMsgM (size_t &i, size_t &_I, Real &mag)
 Returns indices and magnitude of the largest normalized factor->variable message adjoint.
Real getMaxMsgM ()
 Returns magnitude of the largest (in L1-norm) normalized factor->variable message adjoint.
Real getTotalMsgM ()
 Calculates sum of L1 norms of all normalized factor->variable message adjoints.
Real getTotalNewMsgM ()
 Calculates sum of L1 norms of all updated normalized factor->variable message adjoints.
Real getTotalMsgN ()
 Calculates sum of L1 norms of all normalized variable->factor message adjoints.
std::vector< Prob > getZeroAdjF (const FactorGraph &fg)
 Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the factors in the factor graph fg.
std::vector< Prob > getZeroAdjV (const FactorGraph &fg)
 Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the variables in the factor graph fg.
Initialization helper functions
void RegenerateT ()
 Calculate T values; see eqn. (41) in [EaG09].
void RegenerateU ()
 Calculate U values; see eqn. (42) in [EaG09].
void RegenerateS ()
 Calculate S values; see eqn. (43) in [EaG09].
void RegenerateR ()
 Calculate R values; see eqn. (44) in [EaG09].
void RegenerateInputs ()
 Calculate _adj_b_V_unnorm and _adj_b_F_unnorm from _adj_b_V and _adj_b_F.
void RegeneratePsiAdjoints ()
 Initialise members for factor adjoints.
void RegenerateParMessageAdjoints ()
 Initialise members for message adjoints for parallel algorithm.
void RegenerateSeqMessageAdjoints ()
 Initialise members for message adjoints for sequential algorithm.
void Regenerate ()
 Called by init, recalculates intermediate values.
Accessors/mutators
Prob & T (size_t i, size_t _I)
 Returns reference to T value; see eqn. (41) in [EaG09].
const Prob & T (size_t i, size_t _I) const
 Returns constant reference to T value; see eqn. (41) in [EaG09].
Prob & U (size_t I, size_t _i)
 Returns reference to U value; see eqn. (42) in [EaG09].
const Prob & U (size_t I, size_t _i) const
 Returns constant reference to U value; see eqn. (42) in [EaG09].
Prob & S (size_t i, size_t _I, size_t _j)
 Returns reference to S value; see eqn. (43) in [EaG09].
const Prob & S (size_t i, size_t _I, size_t _j) const
 Returns constant reference to S value; see eqn. (43) in [EaG09].
Prob & R (size_t I, size_t _i, size_t _J)
 Returns reference to R value; see eqn. (44) in [EaG09].
const Prob & R (size_t I, size_t _i, size_t _J) const
 Returns constant reference to R value; see eqn. (44) in [EaG09].
Prob & adj_n (size_t i, size_t _I)
 Returns reference to variable->factor message adjoint.
const Prob & adj_n (size_t i, size_t _I) const
 Returns constant reference to variable->factor message adjoint.
Prob & adj_m (size_t i, size_t _I)
 Returns reference to factor->variable message adjoint.
const Prob & adj_m (size_t i, size_t _I) const
 Returns constant reference to factor->variable message adjoint.
Parallel algorithm
void calcNewN (size_t i, size_t _I)
 Calculates new variable->factor message adjoint.
void calcNewM (size_t i, size_t _I)
 Calculates new factor->variable message adjoint.
void calcUnnormMsgN (size_t i, size_t _I)
 Calculates unnormalized variable->factor message adjoint from the normalized one.
void calcUnnormMsgM (size_t i, size_t _I)
 Calculates unnormalized factor->variable message adjoint from the normalized one.
void upMsgN (size_t i, size_t _I)
 Updates (un)normalized variable->factor message adjoints.
void upMsgM (size_t i, size_t _I)
 Updates (un)normalized factor->variable message adjoints.
void doParUpdate ()
 Do one parallel update of all message adjoints.
Sequential algorithm
void incrSeqMsgM (size_t i, size_t _I, const Prob &p)
 Helper function for sendSeqMsgM(): increases factor->variable message adjoint by p and calculates the corresponding unnormalized adjoint.
void setSeqMsgM (size_t i, size_t _I, const Prob &p)
 Sets normalized factor->variable message adjoint and calculates the corresponding unnormalized adjoint.
void sendSeqMsgN (size_t i, size_t _I, const Prob &f)
 Implements routine Send-n in Figure 5 in [EaG09].
void sendSeqMsgM (size_t i, size_t _I)
 Implements routine Send-m in Figure 5 in [EaG09].

Private Attributes

Input variables
BP_dual _bp_dual
 Stores a BP_dual helper object.
const FactorGraph * _fg
 Pointer to the factor graph.
const InfAlg * _ia
 Pointer to the approximate inference algorithm (currently, only BP objects are supported).
Output variables
std::vector< Prob > _adj_psi_V
 Variable factor adjoints.
std::vector< Prob > _adj_psi_F
 Factor adjoints.
std::vector< std::vector< Prob > > _adj_n
 Variable->factor message adjoints (indexed [i][_I]).
std::vector< std::vector< Prob > > _adj_m
 Factor->variable message adjoints (indexed [i][_I]).
std::vector< Prob > _adj_b_V
 Normalized variable belief adjoints.
std::vector< Prob > _adj_b_F
 Normalized factor belief adjoints.
Internal state variables
std::vector< Prob > _init_adj_psi_V
 Initial variable factor adjoints.
std::vector< Prob > _init_adj_psi_F
 Initial factor adjoints.
std::vector< std::vector< Prob > > _adj_n_unnorm
 Unnormalized variable->factor message adjoint (indexed [i][_I]).
std::vector< std::vector< Prob > > _adj_m_unnorm
 Unnormalized factor->variable message adjoint (indexed [i][_I]).
std::vector< std::vector< Prob > > _new_adj_n
 Updated normalized variable->factor message adjoint (indexed [i][_I]).
std::vector< std::vector< Prob > > _new_adj_m
 Updated normalized factor->variable message adjoint (indexed [i][_I]).
std::vector< Prob > _adj_b_V_unnorm
 Unnormalized variable belief adjoints.
std::vector< Prob > _adj_b_F_unnorm
 Unnormalized factor belief adjoints.
std::vector< std::vector< Prob > > _Tmsg
 _Tmsg[i][_I] (see eqn. (41) in [EaG09])
std::vector< std::vector< Prob > > _Umsg
 _Umsg[I][_i] (see eqn. (42) in [EaG09])
std::vector< std::vector
< std::vector< Prob > > > 		_Smsg
 _Smsg[i][_I][_j] (see eqn. (43) in [EaG09])
std::vector< std::vector
< std::vector< Prob > > > 		_Rmsg
 _Rmsg[I][_i][_J] (see eqn. (44) in [EaG09])
size_t _iters
 Number of iterations done.

Related Functions

(Note that these are not member functions.)

Real numericBBPTest (const InfAlg &bp, const std::vector< size_t > *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h)
 Function to verify the validity of adjoints computed by BBP using numerical differentiation.

Classes

struct  Properties
 Parameters for BBP. More...

Detailed Description

Implements BBP (Back-Belief-Propagation) [EaG09].

Author:
Frederik Eaton

Member Typedef Documentation

typedef std::vector<size_t> dai::BBP::_ind_t [private]

Index type.

Constructor & Destructor Documentation

dai::BBP::BBP ( const InfAlg *  ia,
const PropertySet &  opts 
) [inline]

Construct BBP object from a InfAlg ia and a PropertySet opts.

Parameters:
ia should be a BP object or something compatible
opts Parameters
See also:
Properties

Member Function Documentation

void dai::BBP::RegenerateInds (  )  [private]

Prepares index cache _indices.

See also:
bp.cpp

const _ind_t& dai::BBP::_index ( size_t  i,
size_t  _I 
) const [inline, private]

Returns an index from the cache.

void dai::BBP::RegenerateT (  )  [private]

Calculate T values; see eqn. (41) in [EaG09].

void dai::BBP::RegenerateU (  )  [private]

Calculate U values; see eqn. (42) in [EaG09].

void dai::BBP::RegenerateS (  )  [private]

Calculate S values; see eqn. (43) in [EaG09].

void dai::BBP::RegenerateR (  )  [private]

Calculate R values; see eqn. (44) in [EaG09].

void dai::BBP::RegenerateInputs (  )  [private]

Calculate _adj_b_V_unnorm and _adj_b_F_unnorm from _adj_b_V and _adj_b_F.

void dai::BBP::RegeneratePsiAdjoints (  )  [private]

Initialise members for factor adjoints.

Precondition:
RegenerateInputs() should be called first

void dai::BBP::RegenerateParMessageAdjoints (  )  [private]

Initialise members for message adjoints for parallel algorithm.

Precondition:
RegenerateInputs() should be called first

void dai::BBP::RegenerateSeqMessageAdjoints (  )  [private]

Initialise members for message adjoints for sequential algorithm.

Same as RegenerateMessageAdjoints, but calls sendSeqMsgN rather than updating _adj_n (and friends) which are unused in the sequential algorithm.

Precondition:
RegenerateInputs() should be called first

void dai::BBP::Regenerate (  )  [private]

Called by init, recalculates intermediate values.

Prob& dai::BBP::T ( size_t  i,
size_t  _I 
) [inline, private]

Returns reference to T value; see eqn. (41) in [EaG09].

const Prob& dai::BBP::T ( size_t  i,
size_t  _I 
) const [inline, private]

Returns constant reference to T value; see eqn. (41) in [EaG09].

Prob& dai::BBP::U ( size_t  I,
size_t  _i 
) [inline, private]

Returns reference to U value; see eqn. (42) in [EaG09].

const Prob& dai::BBP::U ( size_t  I,
size_t  _i 
) const [inline, private]

Returns constant reference to U value; see eqn. (42) in [EaG09].

Prob& dai::BBP::S ( size_t  i,
size_t  _I,
size_t  _j 
) [inline, private]

Returns reference to S value; see eqn. (43) in [EaG09].

const Prob& dai::BBP::S ( size_t  i,
size_t  _I,
size_t  _j 
) const [inline, private]

Returns constant reference to S value; see eqn. (43) in [EaG09].

Prob& dai::BBP::R ( size_t  I,
size_t  _i,
size_t  _J 
) [inline, private]

Returns reference to R value; see eqn. (44) in [EaG09].

const Prob& dai::BBP::R ( size_t  I,
size_t  _i,
size_t  _J 
) const [inline, private]

Returns constant reference to R value; see eqn. (44) in [EaG09].

Prob& dai::BBP::adj_n ( size_t  i,
size_t  _I 
) [inline, private]

Returns reference to variable->factor message adjoint.

const Prob& dai::BBP::adj_n ( size_t  i,
size_t  _I 
) const [inline, private]

Returns constant reference to variable->factor message adjoint.

Prob& dai::BBP::adj_m ( size_t  i,
size_t  _I 
) [inline, private]

Returns reference to factor->variable message adjoint.

const Prob& dai::BBP::adj_m ( size_t  i,
size_t  _I 
) const [inline, private]

Returns constant reference to factor->variable message adjoint.

void dai::BBP::calcNewN ( size_t  i,
size_t  _I 
) [private]

Calculates new variable->factor message adjoint.

Increases variable factor adjoint according to eqn. (27) in [EaG09] and calculates the new variable->factor message adjoint according to eqn. (29) in [EaG09].

void dai::BBP::calcNewM ( size_t  i,
size_t  _I 
) [private]

Calculates new factor->variable message adjoint.

Increases factor adjoint according to eqn. (28) in [EaG09] and calculates the new factor->variable message adjoint according to the r.h.s. of eqn. (30) in [EaG09].

void dai::BBP::calcUnnormMsgN ( size_t  i,
size_t  _I 
) [private]

Calculates unnormalized variable->factor message adjoint from the normalized one.

void dai::BBP::calcUnnormMsgM ( size_t  i,
size_t  _I 
) [private]

Calculates unnormalized factor->variable message adjoint from the normalized one.

void dai::BBP::upMsgN ( size_t  i,
size_t  _I 
) [private]

Updates (un)normalized variable->factor message adjoints.

void dai::BBP::upMsgM ( size_t  i,
size_t  _I 
) [private]

Updates (un)normalized factor->variable message adjoints.

void dai::BBP::doParUpdate (  )  [private]

Do one parallel update of all message adjoints.

void dai::BBP::incrSeqMsgM ( size_t  i,
size_t  _I,
const Prob &  p 
) [private]

Helper function for sendSeqMsgM(): increases factor->variable message adjoint by p and calculates the corresponding unnormalized adjoint.

void dai::BBP::setSeqMsgM ( size_t  i,
size_t  _I,
const Prob &  p 
) [private]

Sets normalized factor->variable message adjoint and calculates the corresponding unnormalized adjoint.

void dai::BBP::sendSeqMsgN ( size_t  i,
size_t  _I,
const Prob &  f 
) [private]

Implements routine Send-n in Figure 5 in [EaG09].

void dai::BBP::sendSeqMsgM ( size_t  i,
size_t  _I 
) [private]

Implements routine Send-m in Figure 5 in [EaG09].

Prob dai::BBP::unnormAdjoint ( const Prob &  w,
Real  Z_w,
const Prob &  adj_w 
) [private]

Computes the adjoint of the unnormed probability vector from the normalizer and the adjoint of the normalized probability vector.

See also:
eqn. (13) in [EaG09]

Real dai::BBP::getUnMsgMag (  )  [private]

Calculates averaged L1 norm of unnormalized message adjoints.

void dai::BBP::getMsgMags ( Real &  s,
Real &  new_s 
) [private]

Calculates averaged L1 norms of current and new normalized message adjoints.

void dai::BBP::getArgmaxMsgM ( size_t &  i,
size_t &  _I,
Real &  mag 
) [private]

Returns indices and magnitude of the largest normalized factor->variable message adjoint.

Real dai::BBP::getMaxMsgM (  )  [private]

Returns magnitude of the largest (in L1-norm) normalized factor->variable message adjoint.

Real dai::BBP::getTotalMsgM (  )  [private]

Calculates sum of L1 norms of all normalized factor->variable message adjoints.

Real dai::BBP::getTotalNewMsgM (  )  [private]

Calculates sum of L1 norms of all updated normalized factor->variable message adjoints.

Real dai::BBP::getTotalMsgN (  )  [private]

Calculates sum of L1 norms of all normalized variable->factor message adjoints.

std::vector< Prob > dai::BBP::getZeroAdjF ( const FactorGraph &  fg  )  [private]

Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the factors in the factor graph fg.

std::vector< Prob > dai::BBP::getZeroAdjV ( const FactorGraph &  fg  )  [private]

Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the variables in the factor graph fg.

void dai::BBP::init ( const std::vector< Prob > &  adj_b_V,
const std::vector< Prob > &  adj_b_F,
const std::vector< Prob > &  adj_psi_V,
const std::vector< Prob > &  adj_psi_F 
) [inline]

Initializes from given belief adjoints adj_b_V, adj_b_F and initial factor adjoints adj_psi_V, adj_psi_F.

void dai::BBP::init ( const std::vector< Prob > &  adj_b_V,
const std::vector< Prob > &  adj_b_F 
) [inline]

Initializes from given belief adjoints adj_b_V and adj_b_F (setting initial factor adjoints to zero).

void dai::BBP::init_V ( const std::vector< Prob > &  adj_b_V  )  [inline]

Initializes variable belief adjoints adj_b_V (and sets factor belief adjoints and initial factor adjoints to zero).

void dai::BBP::init_F ( const std::vector< Prob > &  adj_b_F  )  [inline]

Initializes factor belief adjoints adj_b_F (and sets variable belief adjoints and initial factor adjoints to zero).

void dai::BBP::initCostFnAdj ( const BBPCostFunction &  cfn,
const std::vector< size_t > *  stateP 
)

Initializes with adjoints calculated from cost function cfn, and state stateP.

Uses the internal pointer to an inference algorithm in combination with the cost function and state for initialization.

Parameters:
cfn Cost function used for initialization;
stateP is a Gibbs state and can be NULL; it will be initialised using a Gibbs run.

void dai::BBP::run (  ) 

Perform iterative updates until change is less than given tolerance.

Prob& dai::BBP::adj_psi_V ( size_t  i  )  [inline]

Returns reference to variable factor adjoint.

const Prob& dai::BBP::adj_psi_V ( size_t  i  )  const [inline]

Returns constant reference to variable factor adjoint.

Prob& dai::BBP::adj_psi_F ( size_t  I  )  [inline]

Returns reference to factor adjoint.

const Prob& dai::BBP::adj_psi_F ( size_t  I  )  const [inline]

Returns constant reference to factor adjoint.

Prob& dai::BBP::adj_b_V ( size_t  i  )  [inline]

Returns reference to variable belief adjoint.

const Prob& dai::BBP::adj_b_V ( size_t  i  )  const [inline]

Returns constant reference to variable belief adjoint.

Prob& dai::BBP::adj_b_F ( size_t  I  )  [inline]

Returns reference to factor belief adjoint.

const Prob& dai::BBP::adj_b_F ( size_t  I  )  const [inline]

Returns constant reference to factor belief adjoint.

size_t dai::BBP::Iterations (  )  [inline]

Return number of iterations done so far.

Friends And Related Function Documentation

Real numericBBPTest ( const InfAlg &  bp,
const std::vector< size_t > *  state,
const PropertySet &  bbp_props,
const BBPCostFunction &  cfn,
Real  h 
) [related]

Function to verify the validity of adjoints computed by BBP using numerical differentiation.

Factors containing a variable are multiplied by small adjustments to verify accuracy of calculated variable factor adjoints.

Parameters:
bp BP object;
state Global state of all variables;
bbp_props BBP parameters;
cfn Cost function to be used;
h Size of perturbation.

Member Data Documentation

BP_dual dai::BBP::_bp_dual [private]

Stores a BP_dual helper object.

const FactorGraph* dai::BBP::_fg [private]

Pointer to the factor graph.

const InfAlg* dai::BBP::_ia [private]

Pointer to the approximate inference algorithm (currently, only BP objects are supported).

std::vector<Prob> dai::BBP::_adj_psi_V [private]

Variable factor adjoints.

std::vector<Prob> dai::BBP::_adj_psi_F [private]

Factor adjoints.

std::vector<std::vector<Prob> > dai::BBP::_adj_n [private]

Variable->factor message adjoints (indexed [i][_I]).

std::vector<std::vector<Prob> > dai::BBP::_adj_m [private]

Factor->variable message adjoints (indexed [i][_I]).

std::vector<Prob> dai::BBP::_adj_b_V [private]

Normalized variable belief adjoints.

std::vector<Prob> dai::BBP::_adj_b_F [private]

Normalized factor belief adjoints.

std::vector<Prob> dai::BBP::_init_adj_psi_V [private]

Initial variable factor adjoints.

std::vector<Prob> dai::BBP::_init_adj_psi_F [private]

Initial factor adjoints.

std::vector<std::vector<Prob> > dai::BBP::_adj_n_unnorm [private]

Unnormalized variable->factor message adjoint (indexed [i][_I]).

std::vector<std::vector<Prob> > dai::BBP::_adj_m_unnorm [private]

Unnormalized factor->variable message adjoint (indexed [i][_I]).

std::vector<std::vector<Prob> > dai::BBP::_new_adj_n [private]

Updated normalized variable->factor message adjoint (indexed [i][_I]).

std::vector<std::vector<Prob> > dai::BBP::_new_adj_m [private]

Updated normalized factor->variable message adjoint (indexed [i][_I]).

std::vector<Prob> dai::BBP::_adj_b_V_unnorm [private]

Unnormalized variable belief adjoints.

std::vector<Prob> dai::BBP::_adj_b_F_unnorm [private]

Unnormalized factor belief adjoints.

std::vector<std::vector<Prob > > dai::BBP::_Tmsg [private]

_Tmsg[i][_I] (see eqn. (41) in [EaG09])

std::vector<std::vector<Prob > > dai::BBP::_Umsg [private]

_Umsg[I][_i] (see eqn. (42) in [EaG09])

std::vector<std::vector<std::vector<Prob > > > dai::BBP::_Smsg [private]

_Smsg[i][_I][_j] (see eqn. (43) in [EaG09])

std::vector<std::vector<std::vector<Prob > > > dai::BBP::_Rmsg [private]

_Rmsg[I][_i][_J] (see eqn. (44) in [EaG09])

size_t dai::BBP::_iters [private]

Number of iterations done.

std::vector<std::vector<_ind_t> > dai::BBP::_indices [private]

Cached indices (indexed [i][_I]).

The documentation for this class was generated from the following files:
  • include/dai/bbp.h
  • src/bbp.cpp
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_64.png0000644000263000017630000000047511433220721015154 0ustar jorismkyb‰PNG  IHDR0¢€á‚0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf»IDAT•c`À˜ ´š8ã5(ƒsªÇë#šÄ<ÌØ%Øt¼&`Jð$0ð‹9d00 libDAI: include/dai/weightedgraph.h File Reference

include/dai/weightedgraph.h File Reference

Defines some utility functions for (weighted) undirected graphs, trees and rooted trees. More...

#include <vector>
#include <map>
#include <iostream>
#include <set>
#include <limits>
#include <climits>
#include <dai/util.h>
#include <dai/exceptions.h>
#include <dai/graph.h>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/prim_minimum_spanning_tree.hpp>
#include <boost/graph/kruskal_min_spanning_tree.hpp>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::DEdge
 Represents a directed edge. More...
class  dai::UEdge
 Represents an undirected edge. More...
class  dai::GraphEL
 Represents an undirected graph, implemented as a std::set of undirected edges. More...
class  dai::WeightedGraph< T >
 Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights. More...
class  dai::RootedTree
 Represents a rooted tree, implemented as a vector of directed edges. More...

Functions

template<typename T>
RootedTree dai::MinSpanningTree (const WeightedGraph< T > &G, bool usePrim)
 Constructs a minimum spanning tree from the (non-negatively) weighted graph G.
template<typename T>
RootedTree dai::MaxSpanningTree (const WeightedGraph< T > &G, bool usePrim)
 Constructs a minimum spanning tree from the (non-negatively) weighted graph G.

Detailed Description

Defines some utility functions for (weighted) undirected graphs, trees and rooted trees.

Todo:
Improve general support for graphs and trees (in particular, a good tree implementation is needed).
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_132.png0000644000263000017630000000112311433220721015217 0ustar jorismkyb‰PNG  IHDRjŠ"…­0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÑIDAT8½’½K#AÆŸÙÝDâfÍ؈—;¸!r¸h£X˜Â¹zwØPìD-\ÁB!øÁ-,9ŒÿÍiëZ]ðâGa#¾ïlbSˆÌûÎ>3¿Ùw>€÷”–~# Û> :Y{âUjqšQ¢Œ×uwnÙ›R#¡eVUš²R?j(R8`˜Z8©¦t¹¬d%Q–Ì=%*–c‚šLÉÕÖ¤qh¹¥ÝÇ~öt8/¨tNŸÐfPJ,ñÇ‚ ÆÖU41´ñ­Ò=ípž²%/ŸMó4ÈUlŬ“•T=>ciX²‘~.òdŠ»Jʃ5Ø.màC6›TV3¶qFe[²b)íHE¦¦ <Ääˆ1ø<ÚÊ ]à:l—¨¯3T?Œ%ûˆHôâOK¾‰)286NÝ ¬ÀÊG9þS}?vVûÓzùøM?b£;åEm| ‡éz®¦.4Ç÷efÖ€s ÚW®ÿ:Îõ8_’øU´6©MpgOì‚6£ßøÐépBéò¶Oh! 8MIøùN—ñ@Oìÿ¸F‚‹* ÐCüÂêŠÆï ,©m)'…Yö ch¬vÒkzûÿajF]:ÈIEND®B`‚libDAI-0.2.7/doc/html/discussion.html0000644000263000017630000001144211433220721016237 0ustar jorismkyb libDAI: Ideas not worth exploring

Ideas not worth exploring

Extended factorgraphs/regiongraphs

A FactorGraph and a RegionGraph are often equipped with additional properties for nodes and edges. The code to initialize those is often quite similar. Maybe one could abstract this, e.g.: 
  template <typename Node1Properties, typename Node2Properties, typename EdgeProperties>
  class ExtFactorGraph : public FactorGraph {
      public:
          std::vector<Node1Properties>              node1Props;
          std::vector<Node2Properties>              node2Props;
          std::vector<std::vector<EdgeProperties> > edgeProps;
         // ...
  }

Advantages:

  • Less code duplication.
  • Easier maintainability.
  • Easier to write new inference algorithms.

Disadvantages:

  • Cachability may be worse.
  • A problem is the case where there are no properties for either type of nodes or for edges. Maybe this can be solved using specializations, or using variadac template arguments? Another possible solution would be to define a "class Empty {}", and add some code that checks for the typeid, comparing it with Empty, and doing something special in that case (e.g., not allocating memory).
  • The main disadvantage of this approach seems to be that it leads to even more entanglement. Therefore this is probably a bad idea.

Polymorphism by template parameterization

Instead of polymorphism by inheritance, use polymorphism by template parameterization. For example, the real reason for introducing the complicated inheritance scheme of dai::InfAlg was for functions like dai::calcMarginal. Instead, one could use a template function: 
  template<typename InfAlg>
  Factor calcMarginal( const InfAlg &obj, const VarSet &ns, bool reInit );
This would assume that the type InfAlg supports certain methods. Ideally, one would use concepts to define different classes of inference algorithms with different capabilities, for example the ability to calculate logZ, the ability to calculate marginals, the ability to calculate bounds, the ability to calculate MAP states, etc. Then, one would use traits classes in order to be able to query the capabilities of the model. For example, one would be able to query whether the inference algorithm supports calculation of logZ. Unfortunately, this is compile-time polymorphism, whereas tests/testdai needs runtime polymorphism. Therefore this is probably a bad idea.
Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_44.png0000644000263000017630000000027211433220721015145 0ustar jorismkyb‰PNG  IHDR ½«¡Q0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf8IDAT™c`À! `ŠCá ˜æYjÀ0H3ßßæ·1>ð(Ò‹˜,A*Eœø :­ à†ƒ& Žã.DjIEND®B`‚libDAI-0.2.7/doc/html/form_61.png0000644000263000017630000000065211433220721015146 0ustar jorismkyb‰PNG  IHDRK¬)Ÿí0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf(IDAT(‘c` @(Fœ ”ØŒ ™Œ̘Œ € °ALð¹–þ!…1#Ûw3–û óPÌ™&ù n2l``à>ÀÁÀ`Æ`oÀЀj]*˜ä`øÁZÀÀÀüyHÿ$%Ì@,fù3°_à¹æ½Hû‡$e)äxÁ¬ù3W0ð‚œ¹ž¤Œñ—ÈÇ3 €É²!"ÉðˆA,vý2†¯ÈîâSXQÆø ª¬ˆýHÓpøuƒÃGˆ2V0‡§ãW°Û€ eÅøⶹ/@jXï°ÿ-*›{ÙR.¯ Òî(m†d ² %®+e# ¸lØ•™80°3 £<º!Ë}IEND®B`‚libDAI-0.2.7/doc/html/form_65.png0000644000263000017630000000107611433220721015153 0ustar jorismkyb‰PNG  IHDR†l »÷0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf¼IDAT8Í’;KÃPÇÿ7‰MS+›¯¡~+…€8X´‚NF°Ðͺˆ¸¿A—–:YÐ |LNÝ)ˆŽ*ÎœÓÅÇ ÷&×<4VGÿ˹çõ»çÜø—ŠV˜º– n’ÛU7BnúûÛþšµ2©º4qŸ»é˜Þ /´Mg±ü-J W‹5ä‡R¾¼cjy”“~±_…bóÈ2Ÿm4ŒóZÀ…Öc¡ÃÚÊ*æ2ª,(¬8Ù×PƘáY¡FóOÔŽ¬w”•HÃÎlAx`óN‡2êÀ ?'=†Ží$ igî·íCʶ€;º·IuhxŒ âD•3ZoƒŒ’}®°çÊâÙ»"Ëv‘,ÚÁ±W6‡Ój!ZdöÅe\`ÞLá’ú‘* IuÎ`P m©‘БFmª8ñ˜%è}©=ìº K,¹}ÿ˜œî(ÿwÁÀ<S®ëuöYòXóï"4b,Ñül‹Ï°7áb•Ï€Ùì"Ñ׳¢F¯i¦äªÈÿG’ùÊ]7DR)ïu½õ¥#´;®+Ѥpõ°*±€½´:±Tþ!ÿG‰«êïE\PârÄrƒOIEND®B`‚libDAI-0.2.7/doc/html/daialg_8h.html0000644000263000017630000001473211433220721015701 0ustar jorismkyb libDAI: include/dai/daialg.h File Reference

include/dai/daialg.h File Reference

Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG). More...

#include <string>
#include <iostream>
#include <vector>
#include <dai/factorgraph.h>
#include <dai/regiongraph.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::InfAlg
 InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI. More...
class  dai::DAIAlg< GRM >
 Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph). More...

Typedefs

typedef DAIAlg< FactorGraph > dai::DAIAlgFG
 Base class for inference algorithms that operate on a FactorGraph.
typedef DAIAlg< RegionGraph > dai::DAIAlgRG
 Base class for inference algorithms that operate on a RegionGraph.

Functions

Factor dai::calcMarginal (const InfAlg &obj, const VarSet &vs, bool reInit)
 Calculates the marginal probability distribution for vs using inference algorithm obj.
vector< Factor > dai::calcPairBeliefs (const InfAlg &obj, const VarSet &vs, bool reInit, bool accurate=false)
 Calculates beliefs for all pairs of variables in vs using inference algorithm obj.
std::vector< size_t > dai::findMaximum (const InfAlg &obj)
 Calculates the joint state of all variables that has maximum probability, according to the inference algorithm obj.

Detailed Description

Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_11.png0000644000263000017630000000031711433220721015137 0ustar jorismkyb‰PNG  IHDR]R0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfMIDAT™c`À8 ŒYÓ Œ®©@‚-Ã+ABÈHà×, ðôø¥AtÁtf Íüiº(CHęـU¦¬ Æø¬e¤20S ìsüÓ5IEND®B`‚libDAI-0.2.7/doc/html/form_55.png0000644000263000017630000000066111433220721015151 0ustar jorismkyb‰PNG  IHDR€ÞöÚõ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf/IDAT(‘c`|€y6Q·dl¢Xg|À"ȲW‹h}6`3€7cVa Á–á…bÄ4Qþ°X©/ŠCÀ$ðk0ƒÜ3 `€DU€Òl Q¸ ö¼® pQˆü þè.Š2XŽî…h.`ð2€0< €¢Ó˜@¢`.€D§3p´ÁE!LgÀ”Ø!¢¬‰20pOàiPe` xÄÊÀp. 6€ùÓtQ°0ÐýCÁÞ,ÊPd<¨ÍPÏÀ~ù° 7"™û¯Igf@¢l ¾Q† †M"Hjaú|‚#‡bkÊ$,¢œÿ0,XEk$8ÆHwÊ|ÀlIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1DAG-members.html0000644000263000017630000002240611433220721020245 0ustar jorismkyb libDAI: Member List

dai::DAG Member List

This is the complete list of members for dai::DAG, including all inherited members.

_chdai::DAG [private]
_padai::DAG [private]
addEdge(size_t n1, size_t n2, bool check=true)dai::DAG
addNode()dai::DAG [inline]
addNode(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::DAG [inline]
ancestors(size_t n) const dai::DAG
ch(size_t n, size_t _c) const dai::DAG [inline]
ch(size_t n, size_t _c)dai::DAG [inline]
ch(size_t n) const dai::DAG [inline]
ch(size_t n)dai::DAG [inline]
checkConsistency() const dai::DAG
chSet(size_t n) const dai::DAG
construct(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::DAG [inline]
DAG()dai::DAG [inline]
DAG(size_t nr)dai::DAG [inline]
DAG(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::DAG [inline]
descendants(size_t n) const dai::DAG
eraseEdge(size_t n1, size_t n2)dai::DAG
eraseNode(size_t n)dai::DAG
existsDirectedPath(size_t n1, size_t n2) const dai::DAG
findCh(size_t n, size_t c)dai::DAG [inline]
findPa(size_t n, size_t p)dai::DAG [inline]
hasEdge(size_t n1, size_t n2) const dai::DAG [inline]
isConnected() const dai::DAG
nrEdges() const dai::DAG [inline]
nrNodes() const dai::DAG [inline]
operator<<(std::ostream &os, const DAG &g)dai::DAG [friend]
operator==(const DAG &x) const dai::DAG [inline]
pa(size_t n, size_t _p) const dai::DAG [inline]
pa(size_t n, size_t _p)dai::DAG [inline]
pa(size_t n) const dai::DAG [inline]
pa(size_t n)dai::DAG [inline]
paSet(size_t n) const dai::DAG
printDot(std::ostream &os) const dai::DAG

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/graph_8h.html0000644000263000017630000001545011433220721015557 0ustar jorismkyb libDAI: include/dai/graph.h File Reference

include/dai/graph.h File Reference

Defines the GraphAL class, which represents an undirected graph as an adjacency list. More...

#include <ostream>
#include <vector>
#include <algorithm>
#include <dai/util.h>
#include <dai/exceptions.h>
#include <dai/smallset.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

struct  dai::Neighbor
 Describes the neighbor relationship of two nodes in a graph. More...
class  dai::GraphAL
 Represents the neighborhood structure of nodes in an undirected graph. More...

Typedefs

typedef std::vector< Neighbor > dai::Neighbors
 Describes the set of neighbors of some node in a graph.
typedef std::pair< size_t, size_t > dai::Edge
 Represents an edge in a graph: an Edge(i,j) corresponds to the edge between node i and node j.

Functions

GraphAL dai::createGraphFull (size_t N)
 Creates a fully-connected graph with N nodes.
GraphAL dai::createGraphGrid (size_t N1, size_t N2, bool periodic)
 Creates a two-dimensional rectangular grid of N1 by N2 nodes, which can be periodic.
GraphAL dai::createGraphGrid3D (size_t N1, size_t N2, size_t N3, bool periodic)
 Creates a three-dimensional rectangular grid of N1 by N2 by N3 nodes, which can be periodic.
GraphAL dai::createGraphLoop (size_t N)
 Creates a graph consisting of a single loop of N nodes.
GraphAL dai::createGraphTree (size_t N)
 Creates a random tree-structured graph of N nodes.
GraphAL dai::createGraphRegular (size_t N, size_t d)
 Creates a random regular graph of N nodes with uniform connectivity d.

Detailed Description

Defines the GraphAL class, which represents an undirected graph as an adjacency list.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/hak_8h.html0000644000263000017630000000775511433220721015232 0ustar jorismkyb libDAI: include/dai/hak.h File Reference

include/dai/hak.h File Reference

Defines class HAK, which implements a variant of Generalized Belief Propagation. More...

#include <string>
#include <dai/daialg.h>
#include <dai/regiongraph.h>
#include <dai/enum.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::HAK
 Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]. More...
struct  dai::HAK::Properties
 Parameters for HAK. More...

Detailed Description

Defines class HAK, which implements a variant of Generalized Belief Propagation.

Idea:
Implement more general region graphs and corresponding Generalized Belief Propagation updates as described in [YFW05].
Todo:
Use ClusterGraph instead of a vector<VarSet> for speed.
Todo:
Optimize this code for large factor graphs.
Todo:
Implement GBP parent-child algorithm.
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_119.png0000644000263000017630000000031211433220721015223 0ustar jorismkyb‰PNG  IHDR&:ãG0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfHIDAT™c`@FJL<D1&0/Ñl \ šó$XZ…QL'0ð €è}0ÿà Å”ÌÖ¢Y Ú!€Ù&ÁýÅPIEND®B`‚libDAI-0.2.7/doc/html/form_97.png0000644000263000017630000000110111433220721015145 0ustar jorismkyb‰PNG  IHDR“àïPP0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf¿IDAT8c` -`&Uƒ”V6f06@–àØDªQ¶ Ú÷+ãkd ~RâX¡™>³@Mb¬èh¡È(†3áPF”¢ Ä(&%¨3ƒ†N`à 'Ü(ÿ P] h”ór{¨dÒ‘•˜&±éxMÀj”>PX£‰Ê·g`Lè–d9‡ác CºQüḃ¦9ì , âLexàF±<˸ÀV1~``yˆá,y ¶9P+ü€¸SÌTgøôÂUú@ü‘¡ÄaÝÀÀpèh 'ù Fñ]€8jÃ|= êc~ŽÄl| mŒd¸€Fq$0pƒ‘¬ƒ ãel ìl‡`FAÃjýÆû‹*ALëdc#°Q\K—8ð2´2=eÐw›b4Šóoé0è0}ÉtÑO–™3§#GÁ¤[Z2Ø(FN ÂI J!©C…!ÍU ^Šd,?$ S ’S˜ŒbƒPe ¬†§#JÒ@lS`,ƒ I™ Ñ ˜bÀˆKç4_PT`¹´IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1TreeEP_1_1Properties-members.html0000644000263000017630000000610611433220721023731 0ustar jorismkyb libDAI: Member List

dai::TreeEP::Properties Member List

This is the complete list of members for dai::TreeEP::Properties, including all inherited members.

DAI_ENUM(TypeType, ORG, ALT)dai::TreeEP::Properties
maxiterdai::TreeEP::Properties
maxtimedai::TreeEP::Properties
toldai::TreeEP::Properties
typedai::TreeEP::Properties
verbosedai::TreeEP::Properties

Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1HAK.png0000644000263000017630000000106311433220721016441 0ustar jorismkyb‰PNG  IHDRˆ<)PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfÉIDAThí×Qnà àðÒgì˜LÛ…ö”ûa`qVÒ€ÐÚL5M£%K> ¤Uÿåk®},Ÿaªp`Ùà( wD#!À\Bú[ > )Ýʤ]Hô©s*h ·‚T-ì€A€öP! ÎÁ=Ð9² (“¨€îU8n“@÷6h<ŒWý4þ3`úký¤ÝÎ.øs`ý~1p[×X 0ÀÞ °Üx€êø5ª­¶ƒ(½ƒþݯn¸ÅÄ_a1ñƒŠ.Ä(BBK¯¨1 rp: %âHÆ+/J„ ¦ådÒ Ü*Ø”/MAŠç rº à˜XâÜÏÿá+Ê¥,TU%å•°X*È“X](`‹‰5,’ŒŸ2 CVs «@r9àPap잃G­‘õT;šaqh†Å!à¤`¹ñ)€åF 0ÀÞ€¹æ?W¡Ç€/;§¶Ö¥¥Þǽë¯ÀÅò + ÙUðΧ=oÜw|5 8ÒYéÒŧMâ}uŽ‘‘!,2„øENô® ,£¬‚¯“˜V ×}” x.0ûµþús·Úå¦â&IEND®B`‚libDAI-0.2.7/doc/html/functions_func_0x64.html0000644000263000017630000002001411433220721017653 0ustar jorismkyb libDAI: Class Members - Functions
 

- d -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BipartiteGraph_1_1levelType.html0000644000263000017630000001123211433220721023673 0ustar jorismkyb libDAI: dai::BipartiteGraph::levelType Struct Reference

dai::BipartiteGraph::levelType Struct Reference

Used internally by isTree(). More...

List of all members.

Public Attributes

std::vector< size_t > ind1
 Indices of nodes of type 1.
std::vector< size_t > ind2
 Indices of nodes of type 2.

Detailed Description

Used internally by isTree().

Member Data Documentation

std::vector<size_t> dai::BipartiteGraph::levelType::ind1

Indices of nodes of type 1.

std::vector<size_t> dai::BipartiteGraph::levelType::ind2

Indices of nodes of type 2.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1MF_1_1Properties.html0000644000263000017630000002666511433220721021473 0ustar jorismkyb libDAI: dai::MF::Properties Struct Reference

dai::MF::Properties Struct Reference

Parameters for MF. More...

#include <dai/mf.h>

List of all members.

Public Member Functions

 DAI_ENUM (InitType, UNIFORM, RANDOM)
 Enumeration of possible message initializations.
 DAI_ENUM (UpdateType, NAIVE, HARDSPIN)
 Enumeration of possible update types.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
Real tol
 Tolerance for convergence test.
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping).
InitType init
 How to initialize the messages/beliefs.
UpdateType updates
 How to update the messages/beliefs.

Detailed Description

Parameters for MF.

Member Function Documentation

dai::MF::Properties::DAI_ENUM ( InitType  ,
UNIFORM  ,
RANDOM   
)

Enumeration of possible message initializations.

dai::MF::Properties::DAI_ENUM ( UpdateType  ,
NAIVE  ,
HARDSPIN   
)

Enumeration of possible update types.

Member Data Documentation

size_t dai::MF::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::MF::Properties::maxiter

Maximum number of iterations.

Real dai::MF::Properties::tol

Tolerance for convergence test.

Real dai::MF::Properties::damping

Damping constant (0.0 means no damping, 1.0 is maximum damping).

InitType dai::MF::Properties::init

How to initialize the messages/beliefs.

UpdateType dai::MF::Properties::updates

How to update the messages/beliefs.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x72.html0000644000263000017630000001107711433220721017703 0ustar jorismkyb libDAI: Class Members - Variables
 

- r -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BP__dual_1_1beliefs.html0000644000263000017630000002044411433220721022100 0ustar jorismkyb libDAI: dai::BP_dual::beliefs Struct Reference

dai::BP_dual::beliefs Struct Reference

Groups together the data structures for storing the two types of beliefs and their normalizers. More...

#include <dai/bp_dual.h>

List of all members.

Public Attributes

std::vector< Prob > b1
 Unnormalized variable beliefs.
std::vector< Real > Zb1
 Normalizers of variable beliefs.
std::vector< Prob > b2
 Unnormalized factor beliefs.
std::vector< Real > Zb2
 Normalizers of factor beliefs.

Detailed Description

Groups together the data structures for storing the two types of beliefs and their normalizers.

Member Data Documentation

std::vector<Prob> dai::BP_dual::beliefs::b1

Unnormalized variable beliefs.

std::vector<Real> dai::BP_dual::beliefs::Zb1

Normalizers of variable beliefs.

std::vector<Prob> dai::BP_dual::beliefs::b2

Unnormalized factor beliefs.

std::vector<Real> dai::BP_dual::beliefs::Zb2

Normalizers of factor beliefs.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/tab_l.gif0000644000263000017630000000130211433220721014730 0ustar jorismkybGIF89a ,Õö÷ùñô÷öøúüýþúûüùúûøùúêïóïóöÆÕßÒÞæØâéÞçíÝæìåìñèîòô÷ùóöø³ÈÕÁÒÝËÙâÏÜäÖá薴ŹɯÂÍ»ÎÙÃÔÞÂÓÝÈ×àÌÚâÕáèÙäê×âèåìðëðó„°ÇÑÞåÜæëãëïëñôîóõ÷úûûüüÿÿÿþþþ, ,ÿ@–P±É`H$!%CqVe2X­ŠÌJ(“Ä +€˜3 2$ÀÆ ¼kvŠä-Ëçõu*…"}ã|}|~q(" $f„ 'Žl(Œ&&$r‘™ › & ! )¢¤›{¨£¥r­ª°©¯„±¯¬´¦·»º³®«§¾¶ÃÂÀ¿²¹ÇÄËƲÌÉεҽͼ„ÔÈÓ×иÙÝÕÏÙÊâÜßãçæê¾äÛÅëÇíáîÖìéïøñ÷õüÑðåùü¤Pß?‚ƒœÇÛBm åAœÎáÀ†%V܈î!Çk÷Ø/áÄ;^¤¨²$Æ–#Mf)f͇(WÎL‰“æKçÒ„° ’I)L:eD ¡Cµ´x*4 U¨h  %A«£^ÁNKb¬Ùe§X±‚´k»x!ÁÖí—2tÝÖ !¯š5tÛæé—À]$¬´%ƒXíâ.i[¬]Y­•ÊfžEëõkg`µ††:zëçÒž;£}ºµj×aa‹–Mš¶é׸cçž½»vïÛºƒóî›8ðáÈ‹'?®¼9óç©G_>Ýyuè¬_ßž]zwêß­‡Ç¾º¼mîæµG~½ûôÞთ/ž>ùööÙ«Ïÿ¿ÿýÿÅà|ÖWà}v;libDAI-0.2.7/doc/html/index_8h-source.html0000644000263000017630000016334611433220721017073 0ustar jorismkyb libDAI: include/dai/index.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_10.png0000644000263000017630000000027511433220721015141 0ustar jorismkyb‰PNG  IHDR RiÊo0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf;IDAT™c`À,)æ`†¿Í0#€Ÿ̲…ªQè`fÊÒÌŽ±1yƒDJØ)@¥¯#Må)LBe0IEND®B`‚libDAI-0.2.7/doc/html/form_98.png0000644000263000017630000000075711433220721015166 0ustar jorismkyb‰PNG  IHDRT7Däƒ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfmIDAT(‘c` ;` @’Q&ÈT—·èPhaèH``(ñ&€¨˜<û¸R¶ < LŸ†& )UÇb+×& V ^$¥ N‡HªGƒDbD)‚3XƒK€+X)«ÐÅò«3~dýÂgVª/u¬!œu:ëÒMú ¬@Çò t3\cøÈüì4†úäÏ @·1=fþTÊSÀÏÀ¼¤´ Eé)†]@²Ž! áÇ Ryt¥,©@Õ_ü&žº¯ŒåOP©=Ãtæ (J=9˜?2ð/iˆa°bàÜ  ò–>Ã' ì)«ÂVY.—\žµø¯CÖJ†¬¥ ž+g.†_ÊR¶” ÜðèƒEq(\N~h¸²`àB‹óLTþÄõ ¥y—šP¥—£òÅDC0±09 Eªu>wb\WLaIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1TProb.html0000644000263000017630000040043011433220721017245 0ustar jorismkyb libDAI: dai::TProb< T > Class Template Reference

dai::TProb< T > Class Template Reference

Represents a vector with entries of type T. More...

#include <dai/prob.h>

List of all members.

Public Types

typedef std::vector< T > container_type
 Type of data structure used for storing the values.
typedef TProb< T > this_type
 Shorthand.
typedef
container_type::const_iterator 		const_iterator
 Constant iterator over the elements.
typedef container_type::iterator iterator
 Iterator over the elements.
typedef
container_type::const_reverse_iterator 		const_reverse_iterator
 Constant reverse iterator over the elements.
typedef
container_type::reverse_iterator 		reverse_iterator
 Reverse iterator over the elements.

Public Member Functions

template<typename binOp1, typename binOp2>
T innerProduct (const this_type &q, T init, binOp1 binaryOp1, binOp2 binaryOp2) const
 Performs a generalized inner product, similar to std::inner_product.
Constructors and destructors
 TProb ()
 Default constructor (constructs empty vector).
 TProb (size_t n)
 Construct uniform probability distribution over n outcomes (i.e., a vector of length n with each entry set to $1/n$).
 TProb (size_t n, T p)
 Construct vector of length n with each entry set to p.
template<typename TIterator>
 TProb (TIterator begin, TIterator end, size_t sizeHint)
 Construct vector from a range.
template<typename S>
 TProb (const std::vector< S > &v)
 Construct vector from another vector.
Iterator interface
iterator begin ()
 Returns iterator that points to the first element.
const_iterator begin () const
 Returns constant iterator that points to the first element.
iterator end ()
 Returns iterator that points beyond the last element.
const_iterator end () const
 Returns constant iterator that points beyond the last element.
reverse_iterator rbegin ()
 Returns reverse iterator that points to the last element.
const_reverse_iterator rbegin () const
 Returns constant reverse iterator that points to the last element.
reverse_iterator rend ()
 Returns reverse iterator that points beyond the first element.
const_reverse_iterator rend () const
 Returns constant reverse iterator that points beyond the first element.
Miscellaneous operations
void resize (size_t sz)
Get/set individual entries
T get (size_t i) const
 Gets i 'th entry.
void set (size_t i, T val)
 Sets i 'th entry to val.
Queries
const container_type & p () const
 Returns a const reference to the wrapped container.
container_type & p ()
 Returns a reference to the wrapped container.
T operator[] (size_t i) const
 Returns a copy of the i 'th entry.
size_t size () const
 Returns length of the vector (i.e., the number of entries).
template<typename unOp>
T accumulateSum (T init, unOp op) const
 Accumulate all values (similar to std::accumulate) by summing.
template<typename unOp>
T accumulateMax (T init, unOp op, bool minimize) const
 Accumulate all values (similar to std::accumulate) by maximization/minimization.
T entropy () const
 Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$.
T max () const
 Returns maximum value of all entries.
T min () const
 Returns minimum value of all entries.
T sum () const
 Returns sum of all entries.
T sumAbs () const
 Return sum of absolute value of all entries.
T maxAbs () const
 Returns maximum absolute value of all entries.
bool hasNaNs () const
 Returns true if one or more entries are NaN.
bool hasNegatives () const
 Returns true if one or more entries are negative.
std::pair< size_t, T > argmax () const
 Returns a pair consisting of the index of the maximum value and the maximum value itself.
size_t draw ()
 Returns a random index, according to the (normalized) distribution described by *this.
bool operator< (const this_type &q) const
 Lexicographical comparison.
bool operator== (const this_type &q) const
 Comparison.
Unary transformations
template<typename unaryOp>
this_type pwUnaryTr (unaryOp op) const
 Returns the result of applying operation op pointwise on *this.
this_type operator- () const
 Returns negative of *this.
this_type abs () const
 Returns pointwise absolute value.
this_type exp () const
 Returns pointwise exponent.
this_type log (bool zero=false) const
 Returns pointwise logarithm.
this_type inverse (bool zero=true) const
 Returns pointwise inverse.
this_type normalized (ProbNormType norm=dai::NORMPROB) const
 Returns normalized copy of *this, using the specified norm.
Unary operations
template<typename unaryOp>
this_type & pwUnaryOp (unaryOp op)
 Applies unary operation op pointwise.
this_type & randomize ()
 Draws all entries i.i.d. from a uniform distribution on [0,1).
this_type & setUniform ()
 Sets all entries to $1/n$ where n is the length of the vector.
this_type & takeAbs ()
 Applies absolute value pointwise.
this_type & takeExp ()
 Applies exponent pointwise.
this_type & takeLog (bool zero=false)
 Applies logarithm pointwise.
T normalize (ProbNormType norm=dai::NORMPROB)
 Normalizes vector using the specified norm.
Operations with scalars
this_type & fill (T x)
 Sets all entries to x.
this_type & operator+= (T x)
 Adds scalar x to each entry.
this_type & operator-= (T x)
 Subtracts scalar x from each entry.
this_type & operator*= (T x)
 Multiplies each entry with scalar x.
this_type & operator/= (T x)
 Divides each entry by scalar x, where division by 0 yields 0.
this_type & operator^= (T x)
 Raises entries to the power x.
Transformations with scalars
this_type operator+ (T x) const
 Returns sum of *this and scalar x.
this_type operator- (T x) const
 Returns difference of *this and scalar x.
this_type operator* (T x) const
 Returns product of *this with scalar x.
this_type operator/ (T x) const
 Returns quotient of *this and scalar x, where division by 0 yields 0.
this_type operator^ (T x) const
 Returns *this raised to the power x.
Operations with other equally-sized vectors
template<typename binaryOp>
this_type & pwBinaryOp (const this_type &q, binaryOp op)
 Applies binary operation pointwise on two vectors.
this_type & operator+= (const this_type &q)
 Pointwise addition with q.
this_type & operator-= (const this_type &q)
 Pointwise subtraction of q.
this_type & operator*= (const this_type &q)
 Pointwise multiplication with q.
this_type & operator/= (const this_type &q)
 Pointwise division by q, where division by 0 yields 0.
this_type & divide (const this_type &q)
 Pointwise division by q, where division by 0 yields +Inf.
this_type & operator^= (const this_type &q)
 Pointwise power.
Transformations with other equally-sized vectors
template<typename binaryOp>
this_type pwBinaryTr (const this_type &q, binaryOp op) const
 Returns the result of applying binary operation op pointwise on *this and q.
this_type operator+ (const this_type &q) const
 Returns sum of *this and q.
this_type operator- (const this_type &q) const
 Return *this minus q.
this_type operator* (const this_type &q) const
 Return product of *this with q.
this_type operator/ (const this_type &q) const
 Returns quotient of *this with q, where division by 0 yields 0.
this_type divided_by (const this_type &q) const
 Pointwise division by q, where division by 0 yields +Inf.
this_type operator^ (const this_type &q) const
 Returns *this to the power q.

Private Attributes

container_type _p
 The data structure that stores the values.

Related Functions

(Note that these are not member functions.)

template<typename T>
T dist (const TProb< T > &p, const TProb< T > &q, ProbDistType dt)
 Returns distance between p and q, measured using distance measure dt.
template<typename T>
std::ostream & operator<< (std::ostream &os, const TProb< T > &p)
 Writes a TProb<T> to an output stream.
template<typename T>
TProb< T > min (const TProb< T > &a, const TProb< T > &b)
 Returns the pointwise minimum of a and b.
template<typename T>
TProb< T > max (const TProb< T > &a, const TProb< T > &b)
 Returns the pointwise maximum of a and b.

Detailed Description

template<typename T>
class dai::TProb< T >

Represents a vector with entries of type T.

It is simply a std::vector<T> with an interface designed for dealing with probability mass functions.

It is mainly used for representing measures on a finite outcome space, for example, the probability distribution of a discrete random variable. However, entries are not necessarily non-negative; it is also used to represent logarithms of probability mass functions.

Template Parameters:
T Should be a scalar that is castable from and to dai::Real and should support elementary arithmetic operations.

Member Typedef Documentation

template<typename T>
typedef std::vector<T> dai::TProb< T >::container_type

Type of data structure used for storing the values.

template<typename T>
typedef TProb<T> dai::TProb< T >::this_type

Shorthand.

template<typename T>
typedef container_type::const_iterator dai::TProb< T >::const_iterator

Constant iterator over the elements.

template<typename T>
typedef container_type::iterator dai::TProb< T >::iterator

Iterator over the elements.

template<typename T>
typedef container_type::const_reverse_iterator dai::TProb< T >::const_reverse_iterator

Constant reverse iterator over the elements.

template<typename T>
typedef container_type::reverse_iterator dai::TProb< T >::reverse_iterator

Reverse iterator over the elements.

Constructor & Destructor Documentation

template<typename T>
dai::TProb< T >::TProb (  )  [inline]

Default constructor (constructs empty vector).

template<typename T>
dai::TProb< T >::TProb ( size_t  n  )  [inline, explicit]

Construct uniform probability distribution over n outcomes (i.e., a vector of length n with each entry set to $1/n$).

template<typename T>
dai::TProb< T >::TProb ( size_t  n,
T  p 
) [inline, explicit]

Construct vector of length n with each entry set to p.

template<typename T>
template<typename TIterator>
dai::TProb< T >::TProb ( TIterator  begin,
TIterator  end,
size_t  sizeHint 
) [inline]

Construct vector from a range.

Template Parameters:
TIterator Iterates over instances that can be cast to T
Parameters:
begin Points to first instance to be added.
end Points just beyond last instance to be added.
sizeHint For efficiency, the number of entries can be speficied by sizeHint; the value 0 can be given if the size is unknown, but this will result in a performance penalty.

template<typename T>
template<typename S>
dai::TProb< T >::TProb ( const std::vector< S > &  v  )  [inline]

Construct vector from another vector.

Template Parameters:
S type of elements in v (should be castable to type T)
Parameters:
v vector used for initialization.

Member Function Documentation

template<typename T>
iterator dai::TProb< T >::begin (  )  [inline]

Returns iterator that points to the first element.

template<typename T>
const_iterator dai::TProb< T >::begin (  )  const [inline]

Returns constant iterator that points to the first element.

template<typename T>
iterator dai::TProb< T >::end (  )  [inline]

Returns iterator that points beyond the last element.

template<typename T>
const_iterator dai::TProb< T >::end (  )  const [inline]

Returns constant iterator that points beyond the last element.

template<typename T>
reverse_iterator dai::TProb< T >::rbegin (  )  [inline]

Returns reverse iterator that points to the last element.

template<typename T>
const_reverse_iterator dai::TProb< T >::rbegin (  )  const [inline]

Returns constant reverse iterator that points to the last element.

template<typename T>
reverse_iterator dai::TProb< T >::rend (  )  [inline]

Returns reverse iterator that points beyond the first element.

template<typename T>
const_reverse_iterator dai::TProb< T >::rend (  )  const [inline]

Returns constant reverse iterator that points beyond the first element.

template<typename T>
T dai::TProb< T >::get ( size_t  i  )  const [inline]

Gets i 'th entry.

template<typename T>
void dai::TProb< T >::set ( size_t  i,
T  val 
) [inline]

Sets i 'th entry to val.

template<typename T>
const container_type& dai::TProb< T >::p (  )  const [inline]

Returns a const reference to the wrapped container.

template<typename T>
container_type& dai::TProb< T >::p (  )  [inline]

Returns a reference to the wrapped container.

template<typename T>
T dai::TProb< T >::operator[] ( size_t  i  )  const [inline]

Returns a copy of the i 'th entry.

template<typename T>
size_t dai::TProb< T >::size (  )  const [inline]

Returns length of the vector (i.e., the number of entries).

template<typename T>
template<typename unOp>
T dai::TProb< T >::accumulateSum ( T  init,
unOp  op 
) const [inline]

Accumulate all values (similar to std::accumulate) by summing.

The following calculation is done: 

  T t = op(init);
  for( const_iterator it = begin(); it != end(); it++ )
      t += op(*it);
  return t;

template<typename T>
template<typename unOp>
T dai::TProb< T >::accumulateMax ( T  init,
unOp  op,
bool  minimize 
) const [inline]

Accumulate all values (similar to std::accumulate) by maximization/minimization.

The following calculation is done (with "max" replaced by "min" if minimize == true): 

  T t = op(init);
  for( const_iterator it = begin(); it != end(); it++ )
      t = std::max( t, op(*it) );
  return t;

template<typename T>
T dai::TProb< T >::entropy (  )  const [inline]

Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$.

template<typename T>
T dai::TProb< T >::max (  )  const [inline]

Returns maximum value of all entries.

template<typename T>
T dai::TProb< T >::min (  )  const [inline]

Returns minimum value of all entries.

template<typename T>
T dai::TProb< T >::sum (  )  const [inline]

Returns sum of all entries.

template<typename T>
T dai::TProb< T >::sumAbs (  )  const [inline]

Return sum of absolute value of all entries.

template<typename T>
T dai::TProb< T >::maxAbs (  )  const [inline]

Returns maximum absolute value of all entries.

template<typename T>
bool dai::TProb< T >::hasNaNs (  )  const [inline]

Returns true if one or more entries are NaN.

template<typename T>
bool dai::TProb< T >::hasNegatives (  )  const [inline]

Returns true if one or more entries are negative.

template<typename T>
std::pair<size_t,T> dai::TProb< T >::argmax (  )  const [inline]

Returns a pair consisting of the index of the maximum value and the maximum value itself.

template<typename T>
size_t dai::TProb< T >::draw (  )  [inline]

Returns a random index, according to the (normalized) distribution described by *this.

template<typename T>
bool dai::TProb< T >::operator< ( const this_type &  q  )  const [inline]

Lexicographical comparison.

Precondition:
this->size() == q.size()

template<typename T>
bool dai::TProb< T >::operator== ( const this_type &  q  )  const [inline]

Comparison.

template<typename T>
template<typename unaryOp>
this_type dai::TProb< T >::pwUnaryTr ( unaryOp  op  )  const [inline]

Returns the result of applying operation op pointwise on *this.

template<typename T>
this_type dai::TProb< T >::operator- (  )  const [inline]

Returns negative of *this.

template<typename T>
this_type dai::TProb< T >::abs (  )  const [inline]

Returns pointwise absolute value.

template<typename T>
this_type dai::TProb< T >::exp (  )  const [inline]

Returns pointwise exponent.

template<typename T>
this_type dai::TProb< T >::log ( bool  zero = false  )  const [inline]

Returns pointwise logarithm.

If zero == true, uses log(0)==0; otherwise, log(0)==-Inf.

template<typename T>
this_type dai::TProb< T >::inverse ( bool  zero = true  )  const [inline]

Returns pointwise inverse.

If zero == true, uses 1/0==0; otherwise, 1/0==Inf.

template<typename T>
this_type dai::TProb< T >::normalized ( ProbNormType  norm = dai::NORMPROB  )  const [inline]

Returns normalized copy of *this, using the specified norm.

Exceptions:
NOT_NORMALIZABLE if the norm is zero

template<typename T>
template<typename unaryOp>
this_type& dai::TProb< T >::pwUnaryOp ( unaryOp  op  )  [inline]

Applies unary operation op pointwise.

template<typename T>
this_type& dai::TProb< T >::randomize (  )  [inline]

Draws all entries i.i.d. from a uniform distribution on [0,1).

template<typename T>
this_type& dai::TProb< T >::setUniform (  )  [inline]

Sets all entries to $1/n$ where n is the length of the vector.

template<typename T>
this_type& dai::TProb< T >::takeAbs (  )  [inline]

Applies absolute value pointwise.

template<typename T>
this_type& dai::TProb< T >::takeExp (  )  [inline]

Applies exponent pointwise.

template<typename T>
this_type& dai::TProb< T >::takeLog ( bool  zero = false  )  [inline]

Applies logarithm pointwise.

If zero == true, uses log(0)==0; otherwise, log(0)==-Inf.

template<typename T>
T dai::TProb< T >::normalize ( ProbNormType  norm = dai::NORMPROB  )  [inline]

Normalizes vector using the specified norm.

Exceptions:
NOT_NORMALIZABLE if the norm is zero

template<typename T>
this_type& dai::TProb< T >::fill ( T  x  )  [inline]

Sets all entries to x.

template<typename T>
this_type& dai::TProb< T >::operator+= ( T  x  )  [inline]

Adds scalar x to each entry.

template<typename T>
this_type& dai::TProb< T >::operator-= ( T  x  )  [inline]

Subtracts scalar x from each entry.

template<typename T>
this_type& dai::TProb< T >::operator*= ( T  x  )  [inline]

Multiplies each entry with scalar x.

template<typename T>
this_type& dai::TProb< T >::operator/= ( T  x  )  [inline]

Divides each entry by scalar x, where division by 0 yields 0.

template<typename T>
this_type& dai::TProb< T >::operator^= ( T  x  )  [inline]

Raises entries to the power x.

template<typename T>
this_type dai::TProb< T >::operator+ ( T  x  )  const [inline]

Returns sum of *this and scalar x.

template<typename T>
this_type dai::TProb< T >::operator- ( T  x  )  const [inline]

Returns difference of *this and scalar x.

template<typename T>
this_type dai::TProb< T >::operator* ( T  x  )  const [inline]

Returns product of *this with scalar x.

template<typename T>
this_type dai::TProb< T >::operator/ ( T  x  )  const [inline]

Returns quotient of *this and scalar x, where division by 0 yields 0.

template<typename T>
this_type dai::TProb< T >::operator^ ( T  x  )  const [inline]

Returns *this raised to the power x.

template<typename T>
template<typename binaryOp>
this_type& dai::TProb< T >::pwBinaryOp ( const this_type &  q,
binaryOp  op 
) [inline]

Applies binary operation pointwise on two vectors.

Template Parameters:
binaryOp Type of function object that accepts two arguments of type T and outputs a type T
Parameters:
q Right operand
op Operation of type binaryOp

template<typename T>
this_type& dai::TProb< T >::operator+= ( const this_type &  q  )  [inline]

Pointwise addition with q.

Precondition:
this->size() == q.size()

template<typename T>
this_type& dai::TProb< T >::operator-= ( const this_type &  q  )  [inline]

Pointwise subtraction of q.

Precondition:
this->size() == q.size()

template<typename T>
this_type& dai::TProb< T >::operator*= ( const this_type &  q  )  [inline]

Pointwise multiplication with q.

Precondition:
this->size() == q.size()

template<typename T>
this_type& dai::TProb< T >::operator/= ( const this_type &  q  )  [inline]

Pointwise division by q, where division by 0 yields 0.

Precondition:
this->size() == q.size()
See also:
divide(const TProb<T> &)

template<typename T>
this_type& dai::TProb< T >::divide ( const this_type &  q  )  [inline]

Pointwise division by q, where division by 0 yields +Inf.

Precondition:
this->size() == q.size()
See also:
operator/=(const TProb<T> &)

template<typename T>
this_type& dai::TProb< T >::operator^= ( const this_type &  q  )  [inline]

Pointwise power.

Precondition:
this->size() == q.size()

template<typename T>
template<typename binaryOp>
this_type dai::TProb< T >::pwBinaryTr ( const this_type &  q,
binaryOp  op 
) const [inline]

Returns the result of applying binary operation op pointwise on *this and q.

Template Parameters:
binaryOp Type of function object that accepts two arguments of type T and outputs a type T
Parameters:
q Right operand
op Operation of type binaryOp

template<typename T>
this_type dai::TProb< T >::operator+ ( const this_type &  q  )  const [inline]

Returns sum of *this and q.

Precondition:
this->size() == q.size()

template<typename T>
this_type dai::TProb< T >::operator- ( const this_type &  q  )  const [inline]

Return *this minus q.

Precondition:
this->size() == q.size()

template<typename T>
this_type dai::TProb< T >::operator* ( const this_type &  q  )  const [inline]

Return product of *this with q.

Precondition:
this->size() == q.size()

template<typename T>
this_type dai::TProb< T >::operator/ ( const this_type &  q  )  const [inline]

Returns quotient of *this with q, where division by 0 yields 0.

Precondition:
this->size() == q.size()
See also:
divided_by(const TProb<T> &)

template<typename T>
this_type dai::TProb< T >::divided_by ( const this_type &  q  )  const [inline]

Pointwise division by q, where division by 0 yields +Inf.

Precondition:
this->size() == q.size()
See also:
operator/(const TProb<T> &)

template<typename T>
this_type dai::TProb< T >::operator^ ( const this_type &  q  )  const [inline]

Returns *this to the power q.

Precondition:
this->size() == q.size()

template<typename T>
template<typename binOp1, typename binOp2>
T dai::TProb< T >::innerProduct ( const this_type &  q,
T  init,
binOp1  binaryOp1,
binOp2  binaryOp2 
) const [inline]

Performs a generalized inner product, similar to std::inner_product.

Precondition:
this->size() == q.size()

Friends And Related Function Documentation

template<typename T>
T dist ( const TProb< T > &  p,
const TProb< T > &  q,
ProbDistType  dt 
) [related]

Returns distance between p and q, measured using distance measure dt.

Precondition:
this->size() == q.size()

template<typename T>
std::ostream & operator<< ( std::ostream &  os,
const TProb< T > &  p 
) [related]

Writes a TProb<T> to an output stream.

template<typename T>
TProb< T > min ( const TProb< T > &  a,
const TProb< T > &  b 
) [related]

Returns the pointwise minimum of a and b.

Precondition:
this->size() == q.size()

template<typename T>
TProb< T > max ( const TProb< T > &  a,
const TProb< T > &  b 
) [related]

Returns the pointwise maximum of a and b.

Precondition:
this->size() == q.size()

Member Data Documentation

template<typename T>
container_type dai::TProb< T >::_p [private]

The data structure that stores the values.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1CondProbEstimation-members.html0000644000263000017630000001312111433220721023407 0ustar jorismkyb libDAI: Member List

dai::CondProbEstimation Member List

This is the complete list of members for dai::CondProbEstimation, including all inherited members.

_initial_statsdai::CondProbEstimation [private]
_statsdai::CondProbEstimation [private]
_target_dimdai::CondProbEstimation [private]
addSufficientStatistics(const Prob &p)dai::CondProbEstimation [virtual]
clone() const dai::CondProbEstimation [inline, virtual]
CondProbEstimation(size_t target_dimension, const Prob &pseudocounts)dai::CondProbEstimation
construct(const std::string &method, const PropertySet &p)dai::ParameterEstimation [private, static]
estimate()dai::CondProbEstimation [virtual]
factory(const PropertySet &p)dai::CondProbEstimation [static]
ParamEstFactory typedefdai::ParameterEstimation [private]
probSize() const dai::CondProbEstimation [inline, virtual]
registerMethod(const std::string &method, const ParamEstFactory &f)dai::ParameterEstimation [inline, private, static]
~CondProbEstimation()dai::CondProbEstimation [inline, virtual]
~ParameterEstimation()dai::ParameterEstimation [inline, private, virtual]

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/example__bipgraph_8cpp-example.html0000644000263000017630000001746311433220721022116 0ustar jorismkyb libDAI: example_bipgraph.cpp

example_bipgraph.cpp

This example deals with the following bipartite graph:
inline_dotgraph_1.dot
It has three nodes of type 1 (drawn as circles) and two nodes of type 2 (drawn as rectangles). Node 0 of type 1 has only one neighbor (node 0 of type 2), but node 0 of type 2 has three neighbors (nodes 0,1,2 of type 1). The example code shows how to construct a BipartiteGraph object representing this bipartite graph and how to iterate over nodes and their neighbors.

Output

G has 3 nodes of type 1, 2 nodes of type 2 and 5 edges.

Node 0 of type 1 has 1 neighbors:
  the 0'th neighbor is node 0 of type 2

Node 1 of type 1 has 2 neighbors:
  the 0'th neighbor is node 0 of type 2
  the 1'th neighbor is node 1 of type 2

Node 2 of type 1 has 2 neighbors:
  the 0'th neighbor is node 0 of type 2
  the 1'th neighbor is node 1 of type 2

Source

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2008-2009  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/bipgraph.h>

using namespace std;
using namespace dai;

int main() {
    // Create a list of edges
    vector<Edge> edges;
    edges.reserve( 5 );
    edges.push_back( Edge(0, 0) );
    edges.push_back( Edge(1, 0) );
    edges.push_back( Edge(2, 0) );
    edges.push_back( Edge(1, 1) );
    edges.push_back( Edge(2, 1) );

    // Create a bipartite graph with 3 nodes of type 1,
    // 2 nodes of type 2 and edge list edges.
    BipartiteGraph G( 3, 2, edges.begin(), edges.end() );

    // Display some information about G
    cout << "G has " << G.nrNodes1() << " nodes of type 1, " << G.nrNodes2() << " nodes of type 2 and " << G.nrEdges() << " edges." << endl << endl;

    // Iterate over all nodes n1 of type 1
    for( size_t n1 = 0; n1 < G.nrNodes1(); n1++ ) {
        cout << "Node " << n1 << " of type 1 has " << G.nb1(n1).size() << " neighbors:" << endl;
        // Iterate over all neighbors n2 of n1
        foreach( const Neighbor &n2, G.nb1(n1) ) {
            // The n2.iter'th neighbor of n1 is n2:
            DAI_ASSERT( G.nb1(n1)[n2.iter] == n2 );

            // The n2.dual'th neighbor of n2 is n1:
            DAI_ASSERT( G.nb2(n2)[n2.dual] == n1 );

            // n2 can be used as an abbreviation of n2.node:
            DAI_ASSERT( static_cast<size_t>(n2) == n2.node );

            cout << "  the " << n2.iter << "'th neighbor is node " << n2 << " of type 2" << endl;
        }
        cout << endl;
    }
}
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Var-members.html0000644000263000017630000001200611433220721020375 0ustar jorismkyb libDAI: Member List

dai::Var Member List

This is the complete list of members for dai::Var, including all inherited members.

_labeldai::Var [private]
_statesdai::Var [private]
label() const dai::Var [inline]
label()dai::Var [inline]
operator!=(const Var &n) const dai::Var [inline]
operator<(const Var &n) const dai::Var [inline]
operator<<(std::ostream &os, const Var &n)dai::Var [friend]
operator<=(const Var &n) const dai::Var [inline]
operator==(const Var &n) const dai::Var [inline]
operator>(const Var &n) const dai::Var [inline]
operator>=(const Var &n) const dai::Var [inline]
states() const dai::Var [inline]
states()dai::Var [inline]
Var()dai::Var [inline]
Var(size_t label, size_t states)dai::Var [inline]

Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1State.html0000644000263000017630000007102611433220721017304 0ustar jorismkyb libDAI: dai::State Class Reference

dai::State Class Reference

Makes it easy to iterate over all possible joint states of variables within a VarSet. More...

#include <dai/index.h>

List of all members.

Public Types

typedef states_type::const_iterator const_iterator
 Constant iterator over the values.

Public Member Functions

 State ()
 Default constructor.
 State (const VarSet &vs, size_t linearState=0)
 Construct from VarSet vs and corresponding linear state linearState.
 State (const std::map< Var, size_t > &s)
 Construct from a std::map<Var, size_t>.
const_iterator begin () const
 Returns constant iterator that points to the first item.
const_iterator end () const
 Returns constant iterator that points beyond the last item.
 operator size_t () const
 Return current linear state.
template<typename InputIterator>
void insert (InputIterator b, InputIterator e)
 Inserts a range of variable-state pairs, changing the current state.
const std::map< Var, size_t > & get () const
 Return current state represented as a map.
 operator const std::map< Var, size_t > & () const
 Cast into std::map<Var, size_t>.
size_t operator() (const Var &v) const
 Return current state of variable v, or 0 if v is not in *this.
size_t operator() (const VarSet &vs) const
 Return linear state of variables in vs, assuming that variables that are not in *this are in state 0.
void operator++ ()
 Increments the current state (prefix).
void operator++ (int)
 Increments the current state (postfix).
bool valid () const
 Returns true if the current state is valid.
void reset ()
 Resets the current state (to the joint state represented by linear state 0).

Private Types

typedef std::map< Var, size_t > states_type
 Type for representing a joint state of some variables as a map, which maps each variable to its state.

Private Attributes

long state
 Current state (represented linearly).
states_type states
 Current state (represented as a map).

Detailed Description

Makes it easy to iterate over all possible joint states of variables within a VarSet.

A joint state of several variables can be represented in two different ways, by a map that maps each variable to its own state, or by an integer that gives the index of the joint state in the canonical enumeration.

Both representations are useful, and the main functionality provided by the State class is to simplify iterating over the various joint states of a VarSet and to provide access to the current state in both representations.

As an example, consider the following code snippet which iterates over all joint states of variables x0 and x1: 

  VarSet vars( x0, x1 );
  for( State S(vars); S.valid(); S++ ) {
      cout << "Linear state: " << S.get() << ", x0 = " << S(x0) << ", x1 = " << S(x1) << endl;
  }

Note:
The same functionality could be achieved by simply iterating over the linear state and using dai::calcState(), but the State class offers a more efficient implementation.

A State is very similar to a dai::multifor, but tailored for Var 's and VarSet 's.

See also:
dai::calcLinearState(), dai::calcState()
Idea:
Make the State class a more prominent part of libDAI (and document it clearly, explaining the concept of state); add more optimized variants of the State class like IndexFor (e.g. for TFactor<>::slice()).
Examples:

example_permute.cpp, and example_varset.cpp.

Member Typedef Documentation

typedef std::map<Var, size_t> dai::State::states_type [private]

Type for representing a joint state of some variables as a map, which maps each variable to its state.

typedef states_type::const_iterator dai::State::const_iterator

Constant iterator over the values.

Constructor & Destructor Documentation

dai::State::State (  )  [inline]

Default constructor.

dai::State::State ( const VarSet &  vs,
size_t  linearState = 0 
) [inline]

Construct from VarSet vs and corresponding linear state linearState.

dai::State::State ( const std::map< Var, size_t > &  s  )  [inline]

Construct from a std::map<Var, size_t>.

Member Function Documentation

const_iterator dai::State::begin (  )  const [inline]

Returns constant iterator that points to the first item.

const_iterator dai::State::end (  )  const [inline]

Returns constant iterator that points beyond the last item.

dai::State::operator size_t (  )  const [inline]

Return current linear state.

template<typename InputIterator>
void dai::State::insert ( InputIterator  b,
InputIterator  e 
) [inline]

Inserts a range of variable-state pairs, changing the current state.

const std::map<Var,size_t>& dai::State::get (  )  const [inline]

Return current state represented as a map.

dai::State::operator const std::map< Var, size_t > & (  )  const [inline]

Cast into std::map<Var, size_t>.

size_t dai::State::operator() ( const Var &  v  )  const [inline]

Return current state of variable v, or 0 if v is not in *this.

size_t dai::State::operator() ( const VarSet &  vs  )  const [inline]

Return linear state of variables in vs, assuming that variables that are not in *this are in state 0.

void dai::State::operator++ (  )  [inline]

Increments the current state (prefix).

void dai::State::operator++ ( int   )  [inline]

Increments the current state (postfix).

bool dai::State::valid (  )  const [inline]

Returns true if the current state is valid.

void dai::State::reset (  )  [inline]

Resets the current state (to the joint state represented by linear state 0).

Member Data Documentation

long dai::State::state [private]

Current state (represented linearly).

states_type dai::State::states [private]

Current state (represented as a map).

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1MF.png0000644000263000017630000000104111433220721016334 0ustar jorismkyb‰PNG  IHDRˆ<)PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf·IDAThí×Arƒ0 P¼Ééò :í…ºâþG¨%a#6ž6´‘J æ!LšÉ>úêmx]åÀ€yE² ²ƒ­@Ì@Zµ„çx[ : ‰O•x™“:€/N¹ ÔvÀÝ hhÝE½¥Æ9¸*ç@Ÿê$ ú)ìW'P=»Æ«þ7þ1 ûký nG~˜>Ÿ ܦéÉÀž‚8à€/xn¼ @eò‹ÍR*Å âW´¿û- …KLüyO^MtQ ERZ¯jS0#÷€¤Ã˜#Žf¼ü'A‰Ð$´ÌÀ¥ƒ@óPR23 ‡ @`‰‰%,êùòŽŒŒ¨CE(šrÊËa1w0Obl`€%&–°Hzÿ4zËfô)\&,®€ÕçàQmd=S‡ÀfXl6ÃbpPxnüÀs£8à€¯@_ÃØס€PV<` <ß퀤1lÚ T9„tZz+È’6N|†ž¦@3`BNu0],@Ùjô)è¥ÏÕåÀ?z¿Ö¿¯«·e² 1HIEND®B`‚libDAI-0.2.7/doc/html/graph_8h-source.html0000644000263000017630000011411111433220721017047 0ustar jorismkyb libDAI: include/dai/graph.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1DEdge.html0000644000263000017630000002465411433220721017201 0ustar jorismkyb libDAI: dai::DEdge Class Reference

dai::DEdge Class Reference

Represents a directed edge. More...

#include <dai/weightedgraph.h>

List of all members.

Public Member Functions

 DEdge ()
 Default constructor.
 DEdge (size_t m1, size_t m2)
 Constructs a directed edge pointing from m1 to m2.
bool operator== (const DEdge &x) const
 Tests for equality.
bool operator< (const DEdge &x) const
 Smaller-than operator (performs lexicographical comparison).

Public Attributes

size_t first
 First node index (source of edge).
size_t second
 Second node index (target of edge).

Friends

std::ostream & operator<< (std::ostream &os, const DEdge &e)
 Writes a directed edge to an output stream.

Detailed Description

Represents a directed edge.

Constructor & Destructor Documentation

dai::DEdge::DEdge (  )  [inline]

Default constructor.

dai::DEdge::DEdge ( size_t  m1,
size_t  m2 
) [inline]

Constructs a directed edge pointing from m1 to m2.

Member Function Documentation

bool dai::DEdge::operator== ( const DEdge &  x  )  const [inline]

Tests for equality.

bool dai::DEdge::operator< ( const DEdge &  x  )  const [inline]

Smaller-than operator (performs lexicographical comparison).

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const DEdge &  e 
) [friend]

Writes a directed edge to an output stream.

Member Data Documentation

size_t dai::DEdge::first

First node index (source of edge).

size_t dai::DEdge::second

Second node index (target of edge).

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_48.png0000644000263000017630000000423011433220721015147 0ustar jorismkyb‰PNG  IHDRÓZMѵ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIDAThíš{lU‡Ï¼öÕ–(Q"âŽ_EÜE, »¾ ¢±&Ú„Ž0Ȫð”(H1Ò*jle}ÔG5JDŒ«hLLT|&jÆÄ`Œ1[y¨åõÞíÎιwfïv[1[Ò“tÚ3wæë;s~sνð¿Ù%Clùïã¬!´ôŠ S7E1PDYÀ¨6'‚„O™ÿñJÇÑ.ºé€ãÝöÑ«y€úǔߧ·”ôäÔ*cëE¦sŠùÝ Pã6­jqrìâœã‡Þ%Á­M¹ÜÉ jZIRú˜´¯u¡ Ê²Ý€ÖíHi˜Ñ˜ÌôhÒw{?`ÜÑ9@Ž‚ey@àûóò½Û†Ïÿ;F»Ò8dŹ»¦jØ€·ê•è¢¿rΙ!Ë‚ù6@úz•#Õsòÿô¥»ãçÏÜ”óŽ×O“›b¹™óDZm¼ ÍÓ^­9,³!5«ÙÄìULp€ 'ƒ¸­'È ÀZí­È9ï6ÜÔä ÆNೃ³Œ×Î`ôí)¯ü@a .M G½7]g M²ÑøóµÖË‘×H:N(ñ0Tš»|-|ßuSç9-¡=BcÃ<‹ o¬EŒªÖ¼ãOÃQ§i#ô³s€O!æˆU©¼HÃq§©t ~&'À\Â1æÅ/AêÎ}T˜AŒ±ƒ¸ž bÔ ð7MFÞÛ>§;P_ŽŒÎ@¯\7ŸÀB 9¾kqÓ’HK£RBm\ %[ëÁ)PLäˆô@ZgÒ—éDî|µÅBžHά&yefßçÕZD.&áA·b€PŽ@µ‹€Âp†ë‰ºr÷àð5Ý4¹„Âz0¶Ó¼%Æ_õà'x¢1¨ãΗb;'ÒƒeÒ±@oÀø•ÈK'ÒµèÔ‡’­ìƒiø¤æÇ矋ÛV'1@k§w•9œZ•Ñ‚¼¯4îUf=¬•ŽÓG¹–ÄÌ«&ßù¦Ü{,8D¢ *IDiÇÈÛ1ï˜`jaƒi"<0êèàíQçÏ"áLàÒ!—¤)¨H*4½?ÁjÐß¾4•-ÛVå®Îl&?k!ÌéœTœ1Ó2#ª@¿é—“ëÈ0²Îdrmeþä“°3ÓçOOXÜɤѣ‘§\…Û¦™ eÓÛ9¥ä¸9+÷`:kîBŽ”ÂM¬À-¤¾”·ñzLž…¼Fͼ„Z÷‘hŒ¾Çt£ —,ÀéA Î!ÿÏÜΘlpzðÚµYï—’‚=d{zy–ø²½¿Ÿ’§©€Óƒ}TÏwåzi" àô`tÈÉ® EIÝŒ¼å}qÇáô bóWþôøßr‹; aqàô²¹Ãˆ”' GŽHäv‹þú€;_Ýh!O¤~h$[ шô 6›Œ-ÀéAxÿÝdk•°@ÉO5˜ ¹ÃX(ÀéÁ‡tþ ¹­ŸÀéÁ~¨”“àêÒòòDz0kÁ[¤¢©í393©%Ôƒ…î#feLà¶}¼sñc"?ñhkZ}Ž…:ô \…º1fÃ}Î>ÇH½`!ê@7 Æ‚½Ï1 Âx ³³yö>l{±3€É˜ ….¡ƒ.: ®1Ðœ^6b€uðˆÚmïCGe2È[q¥lÊŽç1À¿:¥õØûf`@¿+•p¾måLÃàÊÒ:ñ<Ò…óP»Ü``@ìàAúRâ_,• Íü @…¸Æ À:z.@بræa5Ñ}ßëÊF%BH½Ìº.8j·û6J/nF^íL‡¾7÷0€c õÀ¼|†Â¸W5Pn±0pß'é\¼‹ô Б¢¿øIže!O¤¯Àoà¡Lª+ÔƒÏiíìÖÁì> ð:«ÄùO/=(PizéëÁ㊗0¡„®žá¥êÎO'Òƒ™¿=õ€µ=ž¶^éÚž"›½ü\[/ˆôà4¸€n®àL½ Ôƒ+Œq4çS]¦^F£þW’.à¹ëp½ ¨ï§hAÞÀp½ \§ö‘ü¡U|p½ Ôƒ/ûW×sç3õ‚Pö@Ú­Ç?æl½ ÒƒñO“z!ÔÖ•½L¤F¡ŠY¹Ó©`êvþ€Õ….Ê©Ûösç³õ3ÀéF×¼õø€©¸÷n¤J Ò5CƳû^"`ú&`­TÜɘz¡8à—¤1õB1€Ú½’¨"kl½ÀÌpzüâ­'Øö!À„ó$ŽÌœ€QÐñšÅ‘ù,Oa––áÉþ”ЮÞ¤Ûw·ñ(<³Í=‰}”+­úA²±NTÐ"þœh×Ç<%„ŸÄ\9Œb8¿°çm@øÒzüî|µýeä-ïÂzÐÞ‰Á®J«´¯‰ïAq+ÿ`þ€êëÁTºqéA`Ëaä‰ô &ÛèÒƒˆ)´òÍ=ÊŸÂ{^z‰\_àtþÀCØð郗³˜.h<õ¾#LO=¸Gà ÊIÍKB¯lÃHLÞú°—œÑÕ…<‘Ü×õÒˆ ÚÎ* €ý &ýäIãÿ^IEND®B`‚libDAI-0.2.7/doc/html/functions_vars_0x6c.html0000644000263000017630000000771711433220721017771 0ustar jorismkyb libDAI: Class Members - Variables
 

- l -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/jtree_8h.html0000644000263000017630000000705311433220721015567 0ustar jorismkyb libDAI: include/dai/jtree.h File Reference

include/dai/jtree.h File Reference

Defines class JTree, which implements the junction tree algorithm. More...

#include <vector>
#include <string>
#include <dai/daialg.h>
#include <dai/varset.h>
#include <dai/regiongraph.h>
#include <dai/factorgraph.h>
#include <dai/clustergraph.h>
#include <dai/weightedgraph.h>
#include <dai/enum.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::JTree
 Exact inference algorithm using junction tree. More...
struct  dai::JTree::Properties
 Parameters for JTree. More...

Detailed Description

Defines class JTree, which implements the junction tree algorithm.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_86.png0000644000263000017630000000045511433220721015156 0ustar jorismkyb‰PNG  IHDR. ïó’90PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf«IDAT•c` d$00H4aŠ³}d`è@`œ93H±b`™â« ‡°im°´è5–ã Fêž" ½¢-pCÂ'ÃcŸƒ<SD¼ ‹EùˆÁkÀÏÅÀÀ|b~+Ç8?ƒ/Ãa†ˆíö¼`­¶  €Ž.‹s*ð+ðƒΰ˜a*Èá+:f-fc™5ÅGŒ‚Hd»!µ°R IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1InfAlg.png0000644000263000017630000000726411433220721017207 0ustar jorismkyb‰PNG  IHDR`€ÉÙaPLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfJIDATxœí]vêHÍË<»j¥»ƒ™ å™9§÷¿„‘JÿX@}tC:EƵi°„…ä6¨øúzéå¼éŽ¼‹ïWpyõoÆÁ‚8X â`Aš‚]–“zõË÷p¡±Äç[¯ÞŸ|;ØmÒåë’¦5ìrùîÏÁ.ß K`°ËWê¯ö}?†“!ÖW½Ð²ô¹hºËÃþžÖ°¯M°¶¥ÏEc°KÚKÉÁn2­LÛ`ßõœƒ³lþ®ƒyvLÝK^¦þ&˜÷’¯XÚÁ¶Ë:XˆKË,ˆƒq° ÄÁ‚œ-˜Ÿf{5` ¨¶€ÿú‹m †ƒùë/°´p°(` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶À?Æ_§¯ö†!Î5̆8×0oâ\üaˆs ó†!Î5̆8×0oâ\üaˆs ó†!Î5̆8×0oâ\üaˆs ó†!Î5̆8×0oâWóŸ(ÿ‹.p²aþݽ˜?õžœg˜óÜûÃœçž8Øïæxˆ²œ¤”ûÓ¼ùXH©+Ãç|Õ[C¬÷$Ï'Ãru©åãxì4q·¤|uÍŸÃ4É_»\Ýàúµn·ÜÝ`Ó•‡;T꙲[v¸T?û¯¥ƒÛøyOÖ¥Ç[ÊõÆÇÓ㱜Ý]÷^°ò?\ö”ÃÁ»›ÁRé»çu´ñ4Í>yºáæ`¥OÓÿȧåÊ.Øð½£±‡óýBýiÆ•§Ô›é¯TòÁ0Mò{—z¾ÿÒ¸dÉÓê—çKi3ÌQ°^¨_¤_|ønnóoø^Wò6X©6]ùñsºº'}ÚþªÓí‘6ÿ–ìWcçËx2,_*ãÕÆËã¸Ë0ò;—é|]búÏP~¾”êåt/XéÆÇ[w0f™sýÉ?ƒnúÉÛn¬¬kØ.Øps×cO› é Ó¿y£9¹Ìãn‚µÉ¯.u;<Ýàüó™W¿<ËMÅn뷮똩.^OËò@ÈËÝÈãU‹íƒ¥´ 6šÖÓe½¿{>¿ORÚ«ãÈo\F‰}°zz;K°¡Øí`yóCªšËéúCšWçœ[×°²]ÃƘO7kØfìùü>Ør¥kX‹üÖeâg°Ü¼†¥Í˜“æ2漘¶)Ó] lÃ&É}°Û°m°²Œ2dϦ9Ø­mØ]ù+—Ý6¬›ºæu‹ö`6îhÊ8BÊ»1×Mÿ0ß»Áõ^2×<Ãï9Û`W{ɲlôûóÃödÜKŽK:§Ý¸W{ÉGò[—ë½ä4@}H–2•[†9þ=ìwâÜvŸãõ³ùúÃÜ•?R¸Z ìîÚtDÛ=Éo vWþXáoëRðžµ+w~õ=æ©5ìžü±Âßå3þçûÂÁ‚C8Xp q®`á'¦ÂÔ{r®aB ¾Èg¶€ž!ˆƒñüA, Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- žZê7¾ÒíMà©¥Þô’ÍßžZÊÁ‚8X â`Ašƒí'H͇‚}v°J®‡„¶lø©Áv“N8ØCö“N8XC°ý¬Þ†5['(ãšo°çÞ{ã¿íÁ¶s(œ!žZ*º s°Æû}5鄃½ s0‹ðò`þ‹kŒ?ÃÓñÇÁbœïY#?ÍfZ[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ <µ”_PįÓâ`A,ˆƒq° ͘Î']J]™>ì~°ù\ž?ì»Y+Öhvƒý¬Ölµ¢ó6ìq°uÖŠe öÂy+ö³Vœ%žZ*¶ ëv{I»ÉfÖŠå÷0{ æ`ÁÁ‚8X â`A,ˆŸf3­€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- žZÊ/¨ â—lq° ÄÁ‚8X‡Áò|²=È;Ÿ¹«oúí`?‚ l§èÓ•Ü•2¾­¼ƒ­”œ»éãK=ö»OÕ_v°›ëWÉõùñèåéPùþ?¹~Ô¶ 6¬\e]æCå×`Þ†ý –Ò,³Wäá€ùëáì(¿7ØKæ­˜‚ëÖ-Áæ/¨ÃSK5núi/¹Ìvȸ—Ìu£?ü6í%ìu8˜ƒ9X â`A,ˆƒq° ~šÍ´¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€xj)¿ .ˆ_²ÄÁ‚8X â`A+ËIÚÌ\±¼5zú¹„ƒÍ‰v_Ïeÿ]©o"?vøÎãQ¹¥ÿFNÝ£I>.XéÒx¸rWÎëÜõ[^Ã~g¨+[¿ +y¾˜—Y,ì*X'«çÈóEù`/™·¢+ët(»‡ä ‚á©¥š·aݲÑ_·av@ÝKŽ¡ôÛ°q/Yê OöÌÁ,‚ƒq° ÄÁ‚8X?ÍfZ[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ °Ô[@ <µ”_PÄ/Ù â`A,ˆƒq° MÁ6. ‡}Ïï'ï`wƒÍçrç`ØO]ÑÕù*Êp´ü÷‘ÿÌ`×SWŒóUŒ—ì0Ø:uEæDY¦úhèõ©Á6SW¬ÁÄ’¯™·¢û1uŬiËÿ{ƒá©¥"Û°1^ö6웩+úMXö^ò¥8˜ƒ9X â`A,ˆƒq° ~šÍ´¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€` ¨¶€xj)¿ .ˆ_²ÄÁ‚8X â`Aƒåù¤l>|Ì÷ƒ`Ý,çéÐy;¤äa6ÍVƒ5­`Ÿ¬á]¦©+ÆYºÒ87Êg'©kXª³ïÔ¹Rì^°”Ö‡d™§,’ö²y+ºíL(eZÕ²7ú÷‚•£`þµâ&ã^2/ý)XÓ*ö‘Áþæ`ÁÁ‚8X â`A,ˆŸf3­€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- Øj€- žZÊ/¨ â—lq° ÄÁ‚8X¶ã%—“®Ë)¥¶ƒ—?=ØDni²Jzƒþ.¸x)Ú[CaµÜCX mÿzf&q*8’)ŽˆÅ8®¶‡LY¾?œážØÝNâv{HHRðÒOCÒ9äÇÁ¨ÒÞí¿Á‹ý_vÇÌ6"Ù¬ öm‹UÉ?£Á<·’E 1 º…±%þù|b uÇ„Z„RÄYf“Æ(%ÝC–Q)/AU× tià.»'ãø‰Ë]3ä]¤M׸±®!„*5ð÷lÑì˜ÝY}ÑI¿Y}!G‘IEND®B`‚libDAI-0.2.7/doc/html/example__sprinkler__gibbs_8cpp-example.html0000644000263000017630000002010511433220721023623 0ustar jorismkyb libDAI: example_sprinkler_gibbs.cpp

example_sprinkler_gibbs.cpp

This example shows how to use the Gibbs class.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2010  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/factorgraph.h>
#include <dai/gibbs.h>
#include <dai/properties.h>
#include <iostream>
#include <fstream>

using namespace std;
using namespace dai;

int main() {
    // This example program illustrates how to use Gibbs sampling
    // to sample from a joint probability distribution described
    // by a factor graph, using the sprinkler network example discussed at
    // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html
    //
    // The file sprinkler.fg has to be generated by first running
    // example_sprinkler

    // Read the factorgraph from the file
    FactorGraph SprinklerNetwork;
    SprinklerNetwork.ReadFromFile( "sprinkler.fg" );
    cout << "Sprinkler network read from sprinkler.fg" << endl;

    // Output some information about the factorgraph
    cout << SprinklerNetwork.nrVars() << " variables" << endl;
    cout << SprinklerNetwork.nrFactors() << " factors" << endl;

    // Prepare a Gibbs sampler
    PropertySet gibbsProps;
    gibbsProps.set("iters", size_t(100));   // number of Gibbs sampler iterations
    gibbsProps.set("burnin", size_t(0));
    gibbsProps.set("verbose", size_t(0));
    Gibbs gibbsSampler( SprinklerNetwork, gibbsProps );

    // Open a .tab file for writing
    ofstream outfile;
    outfile.open( "sprinkler.tab" );
    if( !outfile.is_open() )
        throw "Cannot write to file!";

    // Write header (consisting of variable labels)
    for( size_t i = 0; i < SprinklerNetwork.nrVars(); i++ )
        outfile << (i == 0 ? "" : "\t") << SprinklerNetwork.var(i).label();
    outfile << endl << endl;

    // Draw samples from joint distribution using Gibbs sampling
    // and write them to the .tab file
    size_t nrSamples = 1000;
    std::vector<size_t> state;
    for( size_t t = 0; t < nrSamples; t++ ) {
        gibbsSampler.run();
        state = gibbsSampler.state();
        for( size_t i = 0; i < state.size(); i++ )
            outfile << (i == 0 ? "" : "\t") << state[i];
        outfile << endl;
    }
    cout << nrSamples << " samples written to sprinkler.tab" << endl;

    // Close the .tab file
    outfile.close();

    return 0;
}
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/regiongraph_8h-source.html0000644000263000017630000011330111433220721020253 0ustar jorismkyb libDAI: include/dai/regiongraph.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_95.png0000644000263000017630000000331411433220721015153 0ustar jorismkyb‰PNG  IHDRœ+¾×#s0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfJIDAThíYmleÿßs×k×um^cÜ)D"k¡1,¦Íb³ÆO"s b1bXÔd™Šc¨"È@C£!ºšFòEúÁa¢Q§F?ø©1Æ„O´ ñ|ÞÚ=×»ÚQvE~¹=/ÿ{ú{þ¿çž—ÿÝ®¢–,t‘^Ž‚´ÌEþZl4E k]¡WÊÐa‚|ÔþZ< J‰‚®Ð«¯ÁÚ0-ív…¿Oi«Ó‚;r¼ƒr„•Z"GîݼÀ3™ÝnɉÏé_&3꺉$ªòQ0 a—äÄ‚ú¿Ër®ù™¤·Üx<¡Ñz Hú0€~¥%ônÔ~{h¬Úv£“0½(¿ôö¸Ìßb\•ó_—ó°yzlìMó‹f(ÈOÇÆΘ)ѹHŒï›eZSŽ™¸vòïìezÛ•§s,à»ØÅc,>º§(ý&ÍÔ?YÕCª‰Ò ØôKìݺUæùÞ–ó—xGá9jDÈ=‡g-V“…~V“írôJAâ»Þµ™L ¼Z£îjp‡XYçÏ_”ƒ¶ôqÞÄë°wӾꎙ£¹ji’8Çn²)h‘£n"´ í–2.Žðn§:߃;/Q ´9ZE9¡í8QŒÊ-‡ ß³rþ¤Ís+¼¦8 9[I{ìw[N‘úbfö” .Ì@ž´“U”“ I zkŸ½u6jõ<¯à[A°UÎO$)à'wŽM-Þ•? GPÐÀéÐF”ƒÞ Ëk Àê9t¦ôÙ[ëÊT]Ï+èºPGŽ|‹À~|¶Ÿ|Ì¿PÊó ëEÁþû‘±'a'Õ÷vÙb(`ÆX,¶¼žåK§÷²è{:‹®wð5‚=L‹Ú<ŸV ;Ë™>ÊçH„MÏͺÆ_ŸFiI2Ž’þ¢7×ÒÎõeu†>ºŠ™¾ÃŒƒƒƒ›¹C±Z9ð#(8öUå¢Û¢NQ6¢:7`ê²b:E–G„Q´<"tb¿îÅ»_÷(È9j߈ÿˆ¹ÐH7µLÚf£ `©ÏDÑrÜ r*^å lrÊ€Š$”÷âM`Øñ•®+eÝÆŽ8Aa‡åørØ%â·’,S︜¯ðŸ›‡%ŸÁú,!ˆÛhC Á΂Á¨ :Ùà3z¿¥‘¸vJDÈ“¤' tØ=ýîäÜgÓe©ƒ:Nrv‰ø„ Ä;YÃó¤]•N©DÎ hµ4ËAehŸä—Z„)…ôßÓU9E§¾ÅµS C‡GCá4`â˜ÚŠ`VúD¬Kœ%—Ê7°5B QNPÃó ?5 {ÉÔÂN…° ¾¼Žo¤Ï{WzØ Þçvê¸si?¨i~ÉÀ®»Öáî‘4Ì(–ƒÄ‰÷„eµr|#dÈ_÷™u°S[q÷Ø¡œXh\Ö[ä⃠uä„è.À¡œ”ßGŠíá6½Òž hdE%(Á“í&‡µóBˆ°Ÿ&Üî:04U#G¹Œ´ÑÕM&L®ïÔÃÇNÆ Ø Ç{YãÕÓl¢Q°CþV/hHáœD,ÆèÕ<¬¾b3t‹}>‘hœö—íÒx0л fÖ¸È?ßo­ÖX¦×ÊIìåh58!ÅQáW’ñï}Ù`io ¾ýLË‘˜0Ÿ7©ñÒ÷³lƒÅØƲM£™ Gf–i¿‘Þ°‡£ƒ¿¥Ø#êCa1ÁuÖðŒ¦ò׬æQ»‚Ó,“Îà%tƒ©5C9˜ÁøÆ,ˆFÏb|ÙüƒUý$D8vö2‚Y¶Ì·åói5Ÿ§Ž“&ƒ%2rc‘Ö”Cùq¼çNÛÙD|.÷ÐJø'aèJû0‹Ø8~xªq«ÿºéÞÖ»òc Ý@= °YC€vçÇ€;è¡iÎß Ùl!DÓ¸ðòp)xðÓ4?9Ôþ`!Ħ Ã4-ú,ßâÜC~ùH®jVN´–—[¿¯,Mí E¦`’Éd´H_ÚZ6zqò.Ôæf£YË"©O†¢AŠ2MY<0Ùª§3AŸN“k?¯Yå,98ÆCJ&5Ù -Šôé¼Ò¢µ£°ÿ(K[šfØaÛ´ÒÉd'‹YЬ®jš¿ÅPj?~È)ö5Ø3Ðzg®<þà—©º€´óIEND®B`‚libDAI-0.2.7/doc/html/bp_8h-source.html0000644000263000017630000013727111433220721016363 0ustar jorismkyb libDAI: include/dai/bp.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1CondProbEstimation.png0000644000263000017630000000111011433220721021572 0ustar jorismkyb‰PNG  IHDR•Pâ©*{PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfÞIDATX…í•[n! E±Ô`ïÀ¬ j7ÀGö¿¦âé U¡’q£Œ±ÍáÚL•ð½Ì>ÃWZe7ë%·/D:W±?QÄ-3¸–%ÿÄ¢Ãã—ë,äÄh;„UüD$–5&$ ÉN.>K:iØv2U',{J–t¯ø!dÏx(y²Ð|G©ãÎâֺ͋†mE:/êñÎJ#q@ñµ7—€öåpï@ÈW,JEõo8¿‰u1œÆGþÉj=ÏXv\U$½¨‘{²{Ôy•±öHT߀ÎZc7ëfY+Óž²ü\Ù³>ïÉz<ò[²–ZÞ-`by·€‰åÝ&–w ˜XÞ-`by·€‰åÝ&–w ˜XÞ-`by·€‰åÝ&–w ˜X~® —Y q™ø›õ ÚW¹×ž… ·S+Ø úù0JYžÒR ­²º½xt+ ¡œi É«‚€´Ë"‚fÔ­ÅÎ*µâ€~ô4X¸,b ¨TùD=ǶX]cIUlº x¡Í Z ¬ álKôÜȼdÕ¥´ÇÊÒ-W¬x­ë̪³{<°°•Bhé:çyMYv`C÷Kÿå£Ý£âýezåk~kݬ›uf-üMûÑÁ »¤võIEND®B`‚libDAI-0.2.7/doc/html/example__sprinkler__em_8cpp-example.html0000644000263000017630000001747711433220721023160 0ustar jorismkyb libDAI: example_sprinkler_em.cpp

example_sprinkler_em.cpp

This example shows how to use the EMAlg class.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2010  Joris Mooij  [joris dot mooij at libdai dot org]
 */

#include <dai/alldai.h>
#include <iostream>
#include <fstream>
#include <string>

using namespace std;
using namespace dai;

int main() {
    // This example program illustrates how to learn the
    // parameters of a Bayesian network from a sample of
    // the sprinkler network discussed at
    // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html
    //
    // The factor graph file (sprinkler.fg) has to be generated first
    // by running example_sprinkler, and the data sample file 
    // (sprinkler.tab) by running example_sprinkler_gibbs

    // Read the factorgraph from the file
    FactorGraph SprinklerNetwork;
    SprinklerNetwork.ReadFromFile( "sprinkler.fg" );

    // Prepare junction-tree object for doing exact inference for E-step
    PropertySet infprops;
    infprops.set( "verbose", (size_t)1 );
    infprops.set( "updates", string("HUGIN") );
    InfAlg* inf = newInfAlg( "JTREE", SprinklerNetwork, infprops );
    inf->init();

    // Read sample from file
    Evidence e;
    ifstream estream( "sprinkler.tab" );
    e.addEvidenceTabFile( estream, SprinklerNetwork );
    cout << "Number of samples: " << e.nrSamples() << endl;

    // Read EM specification
    ifstream emstream( "sprinkler.em" );
    EMAlg em(e, *inf, emstream);

    // Iterate EM until convergence
    while( !em.hasSatisfiedTermConditions() ) {
        Real l = em.iterate();
        cout << "Iteration " << em.Iterations() << " likelihood: " << l <<endl;
    }

    // Output true factor graph
    cout << endl << "True factor graph:" << endl << "##################" << endl;
    cout.precision(12);
    cout << SprinklerNetwork;

    // Output learned factor graph
    cout << endl << "Learned factor graph:" << endl << "#####################" << endl;
    cout.precision(12);
    cout << inf->fg();

    // Clean up
    delete inf;

    return 0;
}
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x6b.html0000644000263000017630000001011011433220721016712 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- k -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Exception-members.html0000644000263000017630000002167211433220721021614 0ustar jorismkyb libDAI: Member List

dai::Exception Member List

This is the complete list of members for dai::Exception, including all inherited members.

ASSERTION_FAILED enum value (defined in dai::Exception)dai::Exception
BELIEF_NOT_AVAILABLE enum value (defined in dai::Exception)dai::Exception
CANNOT_READ_FILE enum value (defined in dai::Exception)dai::Exception
CANNOT_WRITE_FILE enum value (defined in dai::Exception)dai::Exception
Code enum namedai::Exception
code() const dai::Exception [inline]
errorcodedai::Exception [private]
ErrorStringsdai::Exception [private, static]
Exception(Code _code, const std::string &msg="", const std::string &detailedMsg="")dai::Exception [inline]
FACTORGRAPH_NOT_CONNECTED enum value (defined in dai::Exception)dai::Exception
IMPOSSIBLE_TYPECAST enum value (defined in dai::Exception)dai::Exception
INTERNAL_ERROR enum value (defined in dai::Exception)dai::Exception
INVALID_ALIAS enum value (defined in dai::Exception)dai::Exception
INVALID_EMALG_FILE enum value (defined in dai::Exception)dai::Exception
INVALID_EVIDENCE_FILE enum value (defined in dai::Exception)dai::Exception
INVALID_FACTORGRAPH_FILE enum value (defined in dai::Exception)dai::Exception
MALFORMED_PROPERTY enum value (defined in dai::Exception)dai::Exception
message(const Code c) const dai::Exception [inline]
MULTIPLE_UNDO enum value (defined in dai::Exception)dai::Exception
NOT_ALL_PROPERTIES_SPECIFIED enum value (defined in dai::Exception)dai::Exception
NOT_IMPLEMENTED enum value (defined in dai::Exception)dai::Exception
NOT_NORMALIZABLE enum value (defined in dai::Exception)dai::Exception
NUM_ERRORS enum value (defined in dai::Exception)dai::Exception
OBJECT_NOT_FOUND enum value (defined in dai::Exception)dai::Exception
OUT_OF_MEMORY enum value (defined in dai::Exception)dai::Exception
RUNTIME_ERROR enum value (defined in dai::Exception)dai::Exception
UNKNOWN_DAI_ALGORITHM enum value (defined in dai::Exception)dai::Exception
UNKNOWN_ENUM_VALUE enum value (defined in dai::Exception)dai::Exception
UNKNOWN_PARAMETER_ESTIMATION_METHOD enum value (defined in dai::Exception)dai::Exception
UNKNOWN_PROPERTY enum value (defined in dai::Exception)dai::Exception
UNKNOWN_PROPERTY_TYPE enum value (defined in dai::Exception)dai::Exception

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_122.png0000644000263000017630000000112511433220721015220 0ustar jorismkyb‰PNG  IHDRr$§$s¤0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÓIDATH‰c`f€ýÿÊ™3gÎ~ÿt­ÿ7€HÆ~’uêSŒHÖÉþ_L;RÈ/€&²ÿqV°è£ë”ÿ]%³š?ºNæÿÈ\FCÍZئ¹/àÔÉÐÿ™×*¡í>3ˆ00°H£m*V|8ì ô!Œç@ë ZÐ] 2¥á¾ÿÈÒ PÆ' uÊ@,‰ŽŽŽ¬v2lEbÛ±ˆñ‘ÁQÄ ˜J8&0 `ÕÉY€ÄÑg`³ÞÁdX˜80|Ên€Ê°­ßŠ®3™ÃäÀêb 0°Àp2`¾€!M‰eax52èA(C$`ƒ¿F†MjB„j¼`*¾!ÄF@ ¬ÆVGçýÿ Ä)G–ÿð›TC$0Ž  n.“Rvâ5r•%@ , ‘ ð*†ÆÕÀƒÍ]`Z¸ÀbÏK°ôDp(—066`_`Ñp˜r.3´ëÖ0†ci \. ¬@:€ÅÑ:›€Á–ãPç†4Ö†ƒÄê,`à˜ÑÀìèઠÁ,å‰ !†`0A N`žáP V'r‘ÊlLÄjÄ zcÏ$1/•IEND®B`‚libDAI-0.2.7/doc/html/form_142.png0000644000263000017630000000043011433220721015220 0ustar jorismkyb‰PNG  IHDRÖ¹ß0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf–IDAT•c`ÀÐøŠÙ&0J7Biæ(CÂàR†@&˜_8HͲ¹@¢ øX®™3o`àH pþ7àR˜.@-??0°7@®3,àaàVÝ`Ì£ÀÀr`ˆ©—êf~^¨³™À³q`Ѐ¹ìB6†p¿@<Çb€Åß•‚B.¾žIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1UEdge-members.html0000644000263000017630000000664311433220721020650 0ustar jorismkyb libDAI: Member List

dai::UEdge Member List

This is the complete list of members for dai::UEdge, including all inherited members.

firstdai::UEdge
operator<(const UEdge &x) const dai::UEdge [inline]
operator<<(std::ostream &os, const UEdge &e)dai::UEdge [friend]
operator==(const UEdge &x)dai::UEdge [inline]
seconddai::UEdge
UEdge()dai::UEdge [inline]
UEdge(size_t m1, size_t m2)dai::UEdge [inline]
UEdge(const DEdge &e)dai::UEdge [inline]

Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1EMAlg.html0000644000263000017630000011745611433220721017161 0ustar jorismkyb libDAI: dai::EMAlg Class Reference

dai::EMAlg Class Reference

EMAlg performs Expectation Maximization to learn factor parameters. More...

#include <dai/emalg.h>

List of all members.

Iterator interface

typedef std::vector
< MaximizationStep >::iterator 		s_iterator
 Iterator over the maximization steps.
typedef std::vector
< MaximizationStep >
::const_iterator 		const_s_iterator
 Constant iterator over the maximization steps.
s_iterator s_begin ()
 Returns iterator that points to the first maximization step.
const_s_iterator s_begin () const
 Returns constant iterator that points to the first maximization step.
s_iterator s_end ()
 Returns iterator that points beyond the last maximization step.
const_s_iterator s_end () const
 Returns constant iterator that points beyond the last maximization step.

Public Member Functions

 EMAlg (const Evidence &evidence, InfAlg &estep, std::vector< MaximizationStep > &msteps, const PropertySet &termconditions)
 Construct an EMAlg from several objects.
 EMAlg (const Evidence &evidence, InfAlg &estep, std::istream &mstep_file)
 Construct an EMAlg from Evidence evidence, an InfAlg estep, and an input stream mstep_file.
void setTermConditions (const PropertySet &p)
 Change the conditions for termination.
bool hasSatisfiedTermConditions () const
 Determine if the termination conditions have been met.
Real logZ () const
 Return the last calculated log likelihood.
size_t Iterations () const
 Returns number of iterations done so far.
const InfAlg & eStep () const
 Get the E-step method used.
Real iterate ()
 Iterate once over all maximization steps.
Real iterate (MaximizationStep &mstep)
 Iterate over a single MaximizationStep.
void run ()
 Iterate until termination conditions are satisfied.

Static Public Attributes

static const std::string MAX_ITERS_KEY
 Key for setting maximum iterations.
static const size_t MAX_ITERS_DEFAULT = 30
 Default maximum iterations.
static const std::string LOG_Z_TOL_KEY
 Key for setting likelihood termination condition.
static const Real LOG_Z_TOL_DEFAULT = 0.01
 Default likelihood tolerance.

Private Attributes

const Evidence & _evidence
 All the data samples used during learning.
InfAlg & _estep
 How to do the expectation step.
std::vector< MaximizationStep > _msteps
 The maximization steps to take.
size_t _iters
 Number of iterations done.
std::vector< Real > _lastLogZ
 History of likelihoods.
size_t _max_iters
 Maximum number of iterations.
Real _log_z_tol
 Convergence tolerance.

Detailed Description

EMAlg performs Expectation Maximization to learn factor parameters.

This requires specifying:

  • Evidence (instances of observations from the graphical model),
  • InfAlg for performing the E-step (which includes the factor graph),
  • a vector of MaximizationStep 's steps to be performed.

This implementation can perform incremental EM by using multiple MaximizationSteps. An expectation step is performed between execution of each MaximizationStep. A call to iterate() will cycle through all MaximizationStep 's. A call to run() will call iterate() until the termination criteria have been met.

Having multiple and separate maximization steps allows for maximizing some parameters, performing another E-step, and then maximizing separate parameters, which may result in faster convergence in some cases.

Author:
Charles Vaske
Examples:

example_sprinkler_em.cpp.

Member Typedef Documentation

typedef std::vector<MaximizationStep>::iterator dai::EMAlg::s_iterator

Iterator over the maximization steps.

typedef std::vector<MaximizationStep>::const_iterator dai::EMAlg::const_s_iterator

Constant iterator over the maximization steps.

Constructor & Destructor Documentation

dai::EMAlg::EMAlg ( const Evidence &  evidence,
InfAlg &  estep,
std::vector< MaximizationStep > &  msteps,
const PropertySet &  termconditions 
) [inline]

Construct an EMAlg from several objects.

Parameters:
evidence Specifies the observed evidence
estep Inference algorithm to be used for the E-step
msteps Vector of maximization steps, each of which is a group of parameter estimation tasks
termconditions Termination conditions
See also:
setTermConditions()

dai::EMAlg::EMAlg ( const Evidence &  evidence,
InfAlg &  estep,
std::istream &  mstep_file 
)

Construct an EMAlg from Evidence evidence, an InfAlg estep, and an input stream mstep_file.

See also:
Expectation Maximization (.em) file format

Member Function Documentation

void dai::EMAlg::setTermConditions ( const PropertySet &  p  ) 

Change the conditions for termination.

There are two possible parameters in the PropertySet p:

  • max_iters maximum number of iterations
  • log_z_tol critical proportion of increase in logZ

See also:
hasSatisifiedTermConditions()

bool dai::EMAlg::hasSatisfiedTermConditions (  )  const

Determine if the termination conditions have been met.

There are two sufficient termination conditions:

  1. the maximum number of iterations has been performed
  2. the ratio of logZ increase over previous logZ is less than the tolerance, i.e., $ \frac{\log(Z_t) - \log(Z_{t-1})}{| \log(Z_{t-1}) | } < \mathrm{tol} $.
Examples:
example_sprinkler_em.cpp.

Real dai::EMAlg::logZ (  )  const [inline]

Return the last calculated log likelihood.

size_t dai::EMAlg::Iterations (  )  const [inline]

Returns number of iterations done so far.

Examples:
example_sprinkler_em.cpp.

const InfAlg& dai::EMAlg::eStep (  )  const [inline]

Get the E-step method used.

Real dai::EMAlg::iterate (  ) 

Iterate once over all maximization steps.

Returns:
Log-likelihood after iteration
Examples:
example_sprinkler_em.cpp.

Real dai::EMAlg::iterate ( MaximizationStep &  mstep  ) 

Iterate over a single MaximizationStep.

void dai::EMAlg::run (  ) 

Iterate until termination conditions are satisfied.

s_iterator dai::EMAlg::s_begin (  )  [inline]

Returns iterator that points to the first maximization step.

const_s_iterator dai::EMAlg::s_begin (  )  const [inline]

Returns constant iterator that points to the first maximization step.

s_iterator dai::EMAlg::s_end (  )  [inline]

Returns iterator that points beyond the last maximization step.

const_s_iterator dai::EMAlg::s_end (  )  const [inline]

Returns constant iterator that points beyond the last maximization step.

Member Data Documentation

const Evidence& dai::EMAlg::_evidence [private]

All the data samples used during learning.

InfAlg& dai::EMAlg::_estep [private]

How to do the expectation step.

std::vector<MaximizationStep> dai::EMAlg::_msteps [private]

The maximization steps to take.

size_t dai::EMAlg::_iters [private]

Number of iterations done.

std::vector<Real> dai::EMAlg::_lastLogZ [private]

History of likelihoods.

size_t dai::EMAlg::_max_iters [private]

Maximum number of iterations.

Real dai::EMAlg::_log_z_tol [private]

Convergence tolerance.

const std::string dai::EMAlg::MAX_ITERS_KEY [static]

Key for setting maximum iterations.

const size_t dai::EMAlg::MAX_ITERS_DEFAULT = 30 [static]

Default maximum iterations.

const std::string dai::EMAlg::LOG_Z_TOL_KEY [static]

Key for setting likelihood termination condition.

const Real dai::EMAlg::LOG_Z_TOL_DEFAULT = 0.01 [static]

Default likelihood tolerance.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x74.html0000644000263000017630000001133211433220721017677 0ustar jorismkyb libDAI: Class Members - Variables
 

- t -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1RegionGraph-members.html0000644000263000017630000005317311433220721022064 0ustar jorismkyb libDAI: Member List

dai::RegionGraph Member List

This is the complete list of members for dai::RegionGraph, including all inherited members.

_fac2ORdai::RegionGraph [protected]
_Gdai::RegionGraph [protected]
_IRsdai::RegionGraph [protected]
_ORsdai::RegionGraph [protected]
backupFactor(size_t I)dai::FactorGraph
backupFactors(const std::set< size_t > &facs)dai::FactorGraph [virtual]
backupFactors(const VarSet &ns)dai::FactorGraph
bipGraph() const dai::FactorGraph [inline]
calcCVMCountingNumbers()dai::RegionGraph [protected]
checkCountingNumbers() const dai::RegionGraph
clamp(size_t i, size_t x, bool backup=false)dai::FactorGraph [virtual]
clamped(size_t i, size_t x) const dai::FactorGraph
clampFactor(size_t I, const std::vector< size_t > &xIs, bool backup=false)dai::FactorGraph
clampVar(size_t i, const std::vector< size_t > &xis, bool backup=false)dai::FactorGraph
clone() const dai::RegionGraph [inline, virtual]
construct(const FactorGraph &fg, const std::vector< VarSet > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)dai::RegionGraph [protected]
constructCVM(const FactorGraph &fg, const std::vector< VarSet > &cl, size_t verbose=0)dai::RegionGraph [protected]
DAG() const dai::RegionGraph [inline]
Delta(size_t i) const dai::FactorGraph
Delta(const VarSet &vs) const dai::FactorGraph
delta(size_t i) const dai::FactorGraph [inline]
delta(const VarSet &vs) const dai::FactorGraph [inline]
fac2OR(size_t I) const dai::RegionGraph [inline]
factor(size_t I) const dai::FactorGraph [inline]
FactorGraph()dai::FactorGraph [inline]
FactorGraph(const std::vector< Factor > &P)dai::FactorGraph
FactorGraph(FactorInputIterator facBegin, FactorInputIterator facEnd, VarInputIterator varBegin, VarInputIterator varEnd, size_t nrFacHint=0, size_t nrVarHint=0)dai::FactorGraph [inline]
factors() const dai::FactorGraph [inline]
findFactor(const VarSet &ns) const dai::FactorGraph [inline]
findVar(const Var &n) const dai::FactorGraph [inline]
findVars(const VarSet &ns) const dai::FactorGraph [inline]
IR(size_t beta) const dai::RegionGraph [inline]
IR(size_t beta)dai::RegionGraph [inline]
isBinary() const dai::FactorGraph
isConnected() const dai::FactorGraph [inline]
isMaximal(size_t I) const dai::FactorGraph
isPairwise() const dai::FactorGraph
isTree() const dai::FactorGraph [inline]
logScore(const std::vector< size_t > &statevec)dai::FactorGraph
makeCavity(size_t i, bool backup=false)dai::FactorGraph [virtual]
MarkovGraph() const dai::FactorGraph
maximalFactor(size_t I) const dai::FactorGraph
maximalFactorDomains() const dai::FactorGraph
maximalFactors() const dai::FactorGraph
nbF(size_t I) const dai::FactorGraph [inline]
nbF(size_t I, size_t _i) const dai::FactorGraph [inline]
nbIR(size_t beta) const dai::RegionGraph [inline]
nbOR(size_t alpha) const dai::RegionGraph [inline]
nbV(size_t i) const dai::FactorGraph [inline]
nbV(size_t i, size_t _I) const dai::FactorGraph [inline]
nrEdges() const dai::FactorGraph [inline]
nrFactors() const dai::FactorGraph [inline]
nrIRs() const dai::RegionGraph [inline]
nrORs() const dai::RegionGraph [inline]
nrVars() const dai::FactorGraph [inline]
operator<<(std::ostream &os, const RegionGraph &rg)dai::RegionGraph [friend]
dai::FactorGraph::operator<<(std::ostream &os, const FactorGraph &fg)dai::FactorGraph [friend]
operator>>(std::istream &is, FactorGraph &fg)dai::FactorGraph [friend]
OR(size_t alpha) const dai::RegionGraph [inline]
OR(size_t alpha)dai::RegionGraph [inline]
printDot(std::ostream &) const dai::RegionGraph [inline, virtual]
ReadFromFile(const char *)dai::RegionGraph [inline, virtual]
recomputeOR(size_t I)dai::RegionGraph [protected]
recomputeORs()dai::RegionGraph [protected]
recomputeORs(const VarSet &vs)dai::RegionGraph [protected]
RegionGraph()dai::RegionGraph [inline]
RegionGraph(const FactorGraph &fg, const std::vector< VarSet > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)dai::RegionGraph [inline]
RegionGraph(const FactorGraph &fg, const std::vector< VarSet > &cl)dai::RegionGraph [inline]
restoreFactor(size_t I)dai::FactorGraph
restoreFactors()dai::FactorGraph [virtual]
restoreFactors(const VarSet &ns)dai::FactorGraph
setFactor(size_t I, const Factor &newFactor, bool backup=false)dai::RegionGraph [inline, virtual]
setFactors(const std::map< size_t, Factor > &facs, bool backup=false)dai::RegionGraph [inline, virtual]
var(size_t i) const dai::FactorGraph [inline]
vars() const dai::FactorGraph [inline]
WriteToFile(const char *, size_t=15) const dai::RegionGraph [inline, virtual]
~FactorGraph()dai::FactorGraph [inline, virtual]

Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_133.png0000644000263000017630000000104111433220721015217 0ustar jorismkyb‰PNG  IHDR’Båše0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfŸIDAT8Í’½KÃ@ÆŸKÒ¤M¿b±‚pƒˆVªq©ŠKü—¢"¸»Cœ,´vpÊ&ÝêÐÝ?¡ƒÔµ‚:üªàî5É5%­‹EðåroîÞç~yó$ÀÿŒ 0gxYþ·òáåhc\Þþ€$Nƒ•ˆµýÓ¡°4DšMðÆH¿ÂÚ×|>Á#,$͘`i‰žà;Ɣےñ:!—¤,”Ã$!õƒP™çÞCoyZNш҆Zt÷º ŽÅÁÂPSžT¬6îÜ™»ÐmàŠ ©±$ªè¸f8RÄÎC$OJèŠg Ã>ð$|’ºm¤‘B -|!½ÛØÒÍZµâ6–-1 !ÕÚyAJ8N×6%ŸôŒ;Īf‰©6¦©?²E!%Ý<êõºÉI©Ðÿ¤UTçïÜ‚âîæÍË)frÛû!Q!•š–ßS¢OR]käŠÊÈ…ÅI%w7[\„òb$ ˜IƒªÅ—º^Áðî×/©—{½iÁ¹XïÓ®9Þ—÷ó,T.ð+,I™O¥Ñ¤Bp«X£%¿oç6]–´â³IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1ParameterEstimation.html0000644000263000017630000005152511433220721022203 0ustar jorismkyb libDAI: dai::ParameterEstimation Class Reference

dai::ParameterEstimation Class Reference

Base class for parameter estimation methods. More...

#include <dai/emalg.h>

Inheritance diagram for dai::ParameterEstimation:

dai::CondProbEstimation

List of all members.

Public Types

typedef ParameterEstimation *(* ParamEstFactory )(const PropertySet &)
 Type of pointer to factory function.

Public Member Functions

virtual ~ParameterEstimation ()
 Virtual destructor for deleting pointers to derived classes.
virtual ParameterEstimation * clone () const =0
 Virtual copy constructor.
virtual Prob estimate ()=0
 Estimate the factor using the accumulated sufficient statistics and reset.
virtual void addSufficientStatistics (const Prob &p)=0
 Accumulate the sufficient statistics for p.
virtual size_t probSize () const =0
 Returns the size of the Prob that should be passed to addSufficientStatistics.

Static Public Member Functions

static ParameterEstimation * construct (const std::string &method, const PropertySet &p)
 General factory method that constructs the desired ParameterEstimation subclass.
static void registerMethod (const std::string &method, const ParamEstFactory &f)
 Register a subclass so that it can be used with construct().

Static Private Member Functions

static void loadDefaultRegistry ()
 Registers default ParameterEstimation subclasses (currently, only CondProbEstimation).

Static Private Attributes

static std::map< std::string,
ParamEstFactory > * 		_registry = NULL
 A static registry containing all methods registered so far.

Detailed Description

Base class for parameter estimation methods.

This class defines the general interface of parameter estimation methods.

Implementations of this interface (see e.g. CondProbEstimation) should register a factory function (virtual constructor) via the static registerMethod() function. This factory function should return a pointer to a newly constructed object, whose type is a subclass of ParameterEstimation, and gets as input a PropertySet of parameters. After a subclass has been registered, instances of it can be constructed using the construct() method.

Implementations are responsible for collecting data from a probability vector passed to it from a SharedParameters container object.

The default registry only contains CondProbEstimation, named "CondProbEstimation".

Author:
Charles Vaske

Member Typedef Documentation

typedef ParameterEstimation*(* dai::ParameterEstimation::ParamEstFactory)(const PropertySet &)

Type of pointer to factory function.

Constructor & Destructor Documentation

virtual dai::ParameterEstimation::~ParameterEstimation (  )  [inline, virtual]

Virtual destructor for deleting pointers to derived classes.

Member Function Documentation

virtual ParameterEstimation* dai::ParameterEstimation::clone (  )  const [pure virtual]

Virtual copy constructor.

Implemented in dai::CondProbEstimation.

ParameterEstimation * dai::ParameterEstimation::construct ( const std::string &  method,
const PropertySet &  p 
) [static]

General factory method that constructs the desired ParameterEstimation subclass.

Parameters:
method Name of the subclass that should be constructed;
p Parameters passed to constructor of subclass.
Note:
method should either be in the default registry or should be registered first using registerMethod().
Exceptions:
UNKNOWN_PARAMETER_ESTIMATION_METHOD if the requested method is not registered.

static void dai::ParameterEstimation::registerMethod ( const std::string &  method,
const ParamEstFactory &  f 
) [inline, static]

Register a subclass so that it can be used with construct().

virtual Prob dai::ParameterEstimation::estimate (  )  [pure virtual]

Estimate the factor using the accumulated sufficient statistics and reset.

Implemented in dai::CondProbEstimation.

virtual void dai::ParameterEstimation::addSufficientStatistics ( const Prob &  p  )  [pure virtual]

Accumulate the sufficient statistics for p.

Implemented in dai::CondProbEstimation.

virtual size_t dai::ParameterEstimation::probSize (  )  const [pure virtual]

Returns the size of the Prob that should be passed to addSufficientStatistics.

Implemented in dai::CondProbEstimation.

void dai::ParameterEstimation::loadDefaultRegistry (  )  [static, private]

Registers default ParameterEstimation subclasses (currently, only CondProbEstimation).

Member Data Documentation

std::map< std::string, ParameterEstimation::ParamEstFactory > * dai::ParameterEstimation::_registry = NULL [static, private]

A static registry containing all methods registered so far.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1CBP.png0000644000263000017630000000104311433220721016440 0ustar jorismkyb‰PNG  IHDRˆ<)PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf¹IDAThí×Arƒ0 Ðx“µ¥È'è´êŠû¡H²H Øñ´¡T`‡°ÓLþåc¬Þ.ïi¨Ø°lHvAv°H˜7D=!&ÀÜ¿V¨ @BâKeÞ$æd§ à›SéÀ­p·°:Zw@I©s îÆ1ÐY@D4ÏÂ~ Íc°[°ña<ëㆿÖêztÂÓç“ë4=8Á,8à€8ðb€çÆÓT7 ¿¨Ñ,µæD¼&û»ßR¸ÄÄ›°È{²b2ÑE9ŠÒzW Ô˜‚¹$¦q4ã•? J„ ¡õ`ø.¬Ê§r’1È€®$&Ö°¨×Ë;rfB=U„  é ¤¼Ky `;,1±†EÒç§ è#›1ÐY =p˜°¸VŸƒïj#ë™:6Ãb°»€ƒrÀs㯞pÀx=Æ*^âX‡ì±nÂ<Ð×^ ¿ umBœï¨o‹41ÄÀ×ÈòÀGÃÒA÷ðQ€ÛGج] ØúP3 €ÎBŒri~þ. £ø'Àè×ú[¸®Ü‰°IEND®B`‚libDAI-0.2.7/doc/html/functions_0x70.html0000644000263000017630000001677311433220721016656 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- p -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_18.png0000644000263000017630000000054111433220721015145 0ustar jorismkyb‰PNG  IHDR0¢€á‚0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfßIDAT•c`   0A(˜;”v„Pp•Œ :Bm@˜±D1(€•% ˜! |¾‚­h``Óñš–Ðb6~f…Vs×dŽ†~1†4×>l +CWÃC ƒ<ƒŽËˆÄq6†‚jD4Ã' M‰mìl ŸAvL`<°ŒýHL DH·1|d`T`<Àô%Ó™} C8Ø ‰  ¢PÇ3^dpf`X–(“bÀÀ 批000€™Pï2' ‡6 s#±ìT_£IEND®B`‚libDAI-0.2.7/doc/html/form_102.png0000644000263000017630000000361311433220721015222 0ustar jorismkyb‰PNG  IHDR‡3ŽÙš0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf IDAThíY[lUþæÌìnw»Û¦ %h: -!¨l‹"–&¥D@.ËÝÊÛ D + DcŒ+ÁXžh$Ušh,^CBƒF}°¤hôE*EcbñÝ–«¢qýÏÌ”™ÎîÙvåÅ/›3—sþs¾oÏ?ÿüç ð?n;¶ªBÍY¦B<ÊÃL£\L´jVQ‘Æ•G$ÉË!àa«ã•!S.¤q^žfê#y¬BlÊÅ^^ÌèÀ›hª2\ÊFÓyÙ”»žNïÉ}æjµÁX 0J‚®šÀ©›4JîFÂwQïP.['R®ß8îšt12ŸìwÝÛHî+çÜ-cf­@=ä-Î*þ§]Jù“úÅ°E×N³êÖ {Å5³6ëe™~ý€;ø­("b?z#HÛ«Jqɧ®Ã:ÚiæETåÌ¡oÍtÚn£$¸%É^í—m¾0™ˆ`__/ÑÃ(!°çÔS!Müóm7ÃùpvΙ€Tï³ÛЈ0j¨.A„qhå¢ ŠŠ85yUD³N¢öNó"nØ[#®Úm°ƒ‹¨Ç2Rgkä-bÍf^²=:=×ÛÚ¥~ûx¥ˆ8šwøƺ­Ê&»=}%TéTPXlvŠPrö˜!íj6mçl2­g ‘‹G:R~"V)›íQµž!_n–.O^ˆî·ÿé³Ô7<Ëdé­¸w`A—SÞ±¿)ÙÛ]† Óû‚_G!ÕòçZÅjïÆ2kò—ÆŒ8I7K—ˆÕ=5zäÍ;²ÖŠ€úcZŒ0Ó‚·úáÿËÞÓ°n² bl.Ö% ?7ÿäm“‹ïÖãx>(a²„rÖ¼”t§ˆXÂèÐbÉx°àš!BG<ãÁ/ºŸ€¯¹ î7VVÀÉ=q¬ÇB",–ÌŠ*RÂ)‚w8”àxÜ\ebôoÊäITˆ°7Î%“M¨GÅ Îh0¹ˆ6ÇXB¹f]æÔ"L–eù…†F8E´¡c©ÑѶœ¢cü‘þö{FQE}4âØ‹n5š}¸1>5XM¥hJè¬Ý‘Ïèòä«Å&KD rˆ­I:EìÀ{èE4I/ž¾·Ôe«·NȨæîÝ—¹Dœ·FDH5îZyXå^¸ $Ç0,õ¢*ËÏ“hLˆ0YÒ„Ì"šŸ£FuŠ07JguÅx¢ˆØª£y{ÆÉË~˜6Ü%•$Âbšà9ñNuÓhq&>}Ú¢iLøQwu§ü·¯ðc åà“O;ÐgÌíåЗÀÚ¤e3ÿXV@D åª{(á™01o⎟ýr'+Ígºí^^„5bÀb«;l(ÒzÂ[Äz£L R˜qycwÛ~~"¼¼%¢Í(•sšˆ¹§¶Íê#VhPDÄFyQ„Ažˆ†ìŸ‹„K¹‚¿ÕwüþgBÚ;æ]=X8ÜÑÜf,Í]Ó|»]I+»àÇ&Þ±nJ§SŒÜ¿dƒ@:½ÛÓiÿ•Ý"8*¼QPصâmœõ¿ÿŠðöpAL¾ý¨ÞwÚ(ö•Ò©‹UHôf‰¤h!çëè‹Ú:Un6ÖÇ×Q×òÞ¯Œ xÞöAœ†—ea%O Ô œ¤£‘æñå4OŽ'GƒŠç³ˆ uZ:Iq$ƒ¼)%=oû šd?wÕú ¬‘ äìØéZàÙDŠNw"à/âQ,œ£"8ÂßšaCå›Þ"Ä¿]Èk¡üÖéíÏ"\tbšx¦4 fX çÔJwüE¼^ÝþLB*AY·ˆ“Â"@ñlUVWÚø_TÅE0T¡Åº»Iî•$ù<æ à#?‹qüÜE*¾ ßÛ:¬£ìLójzU\ÄK`¯D0¼­š’ D±®bFl8R[K‰Õ>ò\–!›è\æó<*sFq¢VE&x™oeõðŒäM௶2¾I7a#$ðOøY,E½Æ>„2” c­CXãœZËø¹Sxg’çÑÊ ó•É*r'¾ ìéNå|“òò!ZúÈ7f¨EÝIŠjèìC-Ìeëîâ6õèë16>fqŸ©Rí$"–‹*à¸0qr†gÞ|Û½—]€p>[zPãíïUùì”4œ´…šªÆ Lò\ÆŽ”Ô ÷YGþ _2¶Z{!%í¸RÀ}•f¤Nžõý‚£›VÙr¬*†Ù·›Àtã_Ij­í,ã–IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1MF.html0000644000263000017630000011765011433220721016532 0ustar jorismkyb libDAI: dai::MF Class Reference

dai::MF Class Reference

Approximate inference algorithm "Mean Field". More...

#include <dai/mf.h>

Inheritance diagram for dai::MF:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

Constructors/destructors
 MF ()
 Default constructor.
 MF (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual MF * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &ns)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

struct dai::MF::Properties props

Static Public Attributes

static const char * Name = "MF"
 Name of this inference algorithm.

Private Member Functions

void construct ()
 Helper function for constructors.
Factor calcNewBelief (size_t i)
 Calculates an updated belief of variable i.

Private Attributes

std::vector< Factor > _beliefs
 Current approximations of single variable marginals.
Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.

Classes

struct  Properties
 Parameters for MF. More...

Detailed Description

Approximate inference algorithm "Mean Field".

The Mean Field algorithm iteratively calculates approximations of single variable marginals (beliefs). The update equation for a single belief $b_i$ is given by:

\[ b_i^{\mathrm{new}}(x_i) \propto \prod_{I\in N_i} \exp \left( \sum_{x_{N_I \setminus \{i\}}} \log f_I(x_I) \prod_{j \in N_I \setminus \{i\}} b_j(x_j) \right) \]

for naive mean field and by

\[ b_i^{\mathrm{new}}(x_i) \propto \prod_{I\in N_i} \left( \sum_{x_{N_I \setminus \{i\}}} f_I(x_I) \prod_{j \in N_I \setminus \{i\}} b_j(x_j) \right) \]

for hard-spin mean field. These update equations are performed for all variables until convergence.

Constructor & Destructor Documentation

dai::MF::MF (  )  [inline]

Default constructor.

dai::MF::MF ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties

Member Function Documentation

virtual MF* dai::MF::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::MF::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::MF::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::MF::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Factor dai::MF::beliefV ( size_t  i  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

vector< Factor > dai::MF::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

Real dai::MF::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::MF::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

void dai::MF::init ( const VarSet &  vs  )  [virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::MF::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::MF::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::MF::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::MF::setMaxIter ( size_t   )  [inline, virtual]

Sets maximum number of iterations (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::MF::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::MF::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::MF::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

void dai::MF::construct (  )  [private]

Helper function for constructors.

Factor dai::MF::calcNewBelief ( size_t  i  )  [private]

Calculates an updated belief of variable i.

Member Data Documentation

std::vector<Factor> dai::MF::_beliefs [private]

Current approximations of single variable marginals.

Real dai::MF::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::MF::_iters [private]

Number of iterations needed.

const char * dai::MF::Name = "MF" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
  • include/dai/mf.h
  • src/mf.cpp
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_90.png0000644000263000017630000000044111433220721015144 0ustar jorismkyb‰PNG  IHDR, ëB0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfŸIDAT•c`À2:Žæ‹û ’Æõ <`þÉ:sæTp=CNH@^DNƒ¨f•`ÒZæ@„Ùù ØìÁ¬S ‚j6;oB@˜õ•!,Ê1Éà:ˆÁô$Æ.äXÆð ìÒL[.Ø^Àò€åˆ1kå¬@JzEÐ'’+™²V"{–QPÁ^ÝN5Þ IEND®B`‚libDAI-0.2.7/doc/html/form_47.png0000644000263000017630000000050611433220721015150 0ustar jorismkyb‰PNG  IHDR3ûŠ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÄIDAT•c` ˜ 03:€ IìI$¦Ç'AAÿáp‘ÌÉ óG{Ž„‡0y8 Kq ,…iŠa`FÑ…dC/)ý߸¤¢¾3À*Å”c>€,eæ=#ÀÁQ€,¥b³ libDAI: Class Members - Variables
 

- i -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1TFactor-members.html0000644000263000017630000004722711433220721021224 0ustar jorismkyb libDAI: Member List

dai::TFactor< T > Member List

This is the complete list of members for dai::TFactor< T >, including all inherited members.

_pdai::TFactor< T > [private]
_vsdai::TFactor< T > [private]
abs() const dai::TFactor< T > [inline]
binaryOp(const TFactor< T > &g, binOp op)dai::TFactor< T > [inline]
binaryTr(const TFactor< T > &g, binOp op) const dai::TFactor< T > [inline]
dist(const TFactor< T > &f, const TFactor< T > &g, ProbDistType dt)dai::TFactor< T > [related]
embed(const VarSet &vars) const dai::TFactor< T > [inline]
entropy() const dai::TFactor< T > [inline]
exp() const dai::TFactor< T > [inline]
fill(T x)dai::TFactor< T > [inline]
get(size_t i) const dai::TFactor< T > [inline]
hasNaNs() const dai::TFactor< T > [inline]
hasNegatives() const dai::TFactor< T > [inline]
inverse(bool zero=true) const dai::TFactor< T > [inline]
log(bool zero=false) const dai::TFactor< T > [inline]
marginal(const VarSet &vars, bool normed=true) const dai::TFactor< T > [inline]
max() const dai::TFactor< T > [inline]
max(const TFactor< T > &f, const TFactor< T > &g)dai::TFactor< T > [related]
maxAbs() const dai::TFactor< T > [inline]
maxMarginal(const VarSet &vars, bool normed=true) const dai::TFactor< T > [inline]
min() const dai::TFactor< T > [inline]
min(const TFactor< T > &f, const TFactor< T > &g)dai::TFactor< T > [related]
MutualInfo(const TFactor< T > &f)dai::TFactor< T > [related]
normalize(ProbNormType norm=NORMPROB)dai::TFactor< T > [inline]
normalized(ProbNormType norm=NORMPROB) const dai::TFactor< T > [inline]
nrStates() const dai::TFactor< T > [inline]
operator*(T x) const dai::TFactor< T > [inline]
operator*(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator*=(T x)dai::TFactor< T > [inline]
operator*=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator+(T x) const dai::TFactor< T > [inline]
operator+(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator+=(T x)dai::TFactor< T > [inline]
operator+=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator-() const dai::TFactor< T > [inline]
operator-(T x) const dai::TFactor< T > [inline]
operator-(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator-=(T x)dai::TFactor< T > [inline]
operator-=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator/(T x) const dai::TFactor< T > [inline]
operator/(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator/=(T x)dai::TFactor< T > [inline]
operator/=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator<<(std::ostream &os, const TFactor< T > &f)dai::TFactor< T > [related]
operator==(const TFactor< T > &y) const dai::TFactor< T > [inline]
operator[](size_t i) const dai::TFactor< T > [inline]
operator^(T x) const dai::TFactor< T > [inline]
operator^=(T x)dai::TFactor< T > [inline]
p() const dai::TFactor< T > [inline]
p()dai::TFactor< T > [inline]
randomize()dai::TFactor< T > [inline]
set(size_t i, T val)dai::TFactor< T > [inline]
setUniform()dai::TFactor< T > [inline]
slice(const VarSet &vars, size_t varsState) const dai::TFactor< T > [inline]
strength(const Var &i, const Var &j) const dai::TFactor< T > [inline]
sum() const dai::TFactor< T > [inline]
sumAbs() const dai::TFactor< T > [inline]
takeAbs()dai::TFactor< T > [inline]
takeExp()dai::TFactor< T > [inline]
takeLog(bool zero=false)dai::TFactor< T > [inline]
TFactor(T p=1)dai::TFactor< T > [inline]
TFactor(const Var &v)dai::TFactor< T > [inline]
TFactor(const VarSet &vars)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, T p)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const std::vector< S > &x)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const T *p)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const TProb< T > &p)dai::TFactor< T > [inline]
TFactor(const std::vector< Var > &vars, const std::vector< T > &p)dai::TFactor< T > [inline]
vars() const dai::TFactor< T > [inline]
vars()dai::TFactor< T > [inline]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_23.png0000644000263000017630000000050311433220721015137 0ustar jorismkyb‰PNG  IHDR0¢€á‚0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÁIDAT•c`À˜ ´0š8ã5(ƒõªÇë*šÄ름3v 6¯ ˜< übl ³Œ€Ì¼@«€XÈe`à*dP`èœÎPà+ä.``ˆf`a`XÉÀÀô?ÄÆËØXõ@v(?Њð ¤B$˜¾d:3´$˜7ØÌœÎÀ+Ö€äÏ @ NŽ•`vˆÏSA>gM`^bÌÀ «­Ð@keMaÀ •†&E#IÖ·IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1DecMAP_1_1Properties.html0000644000263000017630000001533711433220721022214 0ustar jorismkyb libDAI: dai::DecMAP::Properties Struct Reference

dai::DecMAP::Properties Struct Reference

Parameters for DecMAP. More...

#include <dai/decmap.h>

List of all members.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
bool reinit
 Complete or partial reinitialization of clamped subgraphs?
std::string ianame
 Name of the algorithm used to calculate the beliefs on clamped subgraphs.
PropertySet iaopts
 Parameters for the algorithm used to calculate the beliefs on clamped subgraphs.

Detailed Description

Parameters for DecMAP.

Member Data Documentation

size_t dai::DecMAP::Properties::verbose

Verbosity (amount of output sent to stderr).

bool dai::DecMAP::Properties::reinit

Complete or partial reinitialization of clamped subgraphs?

std::string dai::DecMAP::Properties::ianame

Name of the algorithm used to calculate the beliefs on clamped subgraphs.

PropertySet dai::DecMAP::Properties::iaopts

Parameters for the algorithm used to calculate the beliefs on clamped subgraphs.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_82.png0000644000263000017630000000210011433220721015137 0ustar jorismkyb‰PNG  IHDRØ&T–H·0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf¾IDATX…Ý–OhWÇ¿óf2;3ù3 B´à =Åd5ˆE´ÅC‘lŠ‘P,Žˆ6xÐ“Û ZZ\)+ÛXÝKsËV`O«Rz ô&³«Roñ½7ߺkÖ¹ø ̼ßo~yŸ÷{¿ý½࣑ ¬Èw8 9%„ÝÇ’€™GÑzäN'®G°Œ?öoH€E®fPùº—g¢÷Ï€)9Ò,>íùªÄ,©øL€ÌC.Á1‰%ÏÑä÷ßñéÚâ­bñÚâ/íÂj †ºs ´¹Ú"]ˆYo—E\›–bõª~W ã0qqiyÁ´Z„)šq¨èÊ‚s¹äª&Â&¿—~pâ46ÆÌãh.¶¦YéþçÛaBE*ëyÉDn)˜^Ãᱎu}¹¸Ù<±m°‹°†ïNÝnˆaÒ«”Õ{Aÿ"3ƒfêNaÊ:¼¨Eª«³̆Vg×?pšeåFÝlžªÛ×Q'ö±mDO9L})¶ëñ3ë[b}™Á¹,ÂÔ΃T|+Ãa7àšYôbbõŸ+y»Rpµ–¢¿ì È“øêº u»)ìJI*_Òâ¨C›°ôäbNúý.oוä™]6¤EC•Îù]³ß>®º‡S8³–*´/ “FX*4ÇÑJr>f ½âÞ¾ã î™m¶†b­ñÍOü;¹~ô}`ÿOúÁù.Úß¿ ûv·7í}ñ0u1{Ý&ì[Ô{ 9gûÙëÌÈ¢Ûß½Qü‹’®”oeúËåKíÁžÁí¡·´¼UJaç𤽉›©®TŒV#õˆìŽ`Gˆ»äÿ-KµÎ\´®ŠÞÓÊTT3m¢òáa›G-#cÌüjclÒ¦Gëªàky®[ǸávÙ2A HÓ\n[šîÜ ÏKÜ(@+æØ×W¶®WØeª3OOùSl$_T”‹@ÉóK'œ d=ÿ:Ÿöa¼°ËTǸ|p¥Þ9Iòô:çÁ¼Â&§ÇòCº.ó ›œ^²Ã™,tØ3˜ô ›œÆ±e$£žþ†~dýÂ&ª½v‚“¿é1õ¤šÛækIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1SharedParameters-members.html0000644000263000017630000001323711433220721023106 0ustar jorismkyb libDAI: Member List

dai::SharedParameters Member List

This is the complete list of members for dai::SharedParameters, including all inherited members.

_estimationdai::SharedParameters [private]
_ownEstimationdai::SharedParameters [private]
_permsdai::SharedParameters [private]
_varordersdai::SharedParameters [private]
_varsetsdai::SharedParameters [private]
calculatePermutation(const std::vector< Var > &varOrder, VarSet &outVS)dai::SharedParameters [private, static]
collectSufficientStatistics(InfAlg &alg)dai::SharedParameters
FactorIndex typedefdai::SharedParameters
FactorOrientations typedefdai::SharedParameters
setParameters(FactorGraph &fg)dai::SharedParameters
setPermsAndVarSetsFromVarOrders()dai::SharedParameters [private]
SharedParameters(const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE=false)dai::SharedParameters
SharedParameters(std::istream &is, const FactorGraph &fg)dai::SharedParameters
SharedParameters(const SharedParameters &sp)dai::SharedParameters [inline]
~SharedParameters()dai::SharedParameters [inline]

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/doxygen.png0000644000263000017630000000240111433220721015344 0ustar jorismkyb‰PNG  IHDRd-ok>ÂgAMAÖØÔOX2tEXtSoftwareAdobe ImageReadyqÉe<]PLTEǾÏ"&©ÈÎﶻÖÓÚú“¢Þ ¬à¶Âõ‡§ÕÙêÉÊÎáâæ{ŽÔ¡ëˆ™× ²ø§¬¹ÀÀ±ÝÝÎùùéõõçëëåED9×ÖËhg]_X<@:#mhUÿÿÿÝÀ1tRNSÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÍvÿIDATxÚbC£: d#„„………h` @¡X",***LKˆ.–], ºX@t± €èb @ÑÅ€BµD„6–š%""´° € ˜% ˆ™B:H¢ˆ²Áf@• ˆRPy"K`\PbC(!II!h©…ëƒ(ñ„Ä!ꈬC„Ä…àl!0[X\J\$TMˆ(’>a$S„ Ù@ Ш@R.$‚¬LJBR¢‰AÌG1 ¬ Â(FȃÔPhhÁTÀ¢„%!`€&q°%u P ¹¢ ¬ € ¹CT$B¢à|‚ºW„¤Àl £!B`R$( …Ĉ‘’ž@AÅ%ĤÄ%@,(—Ê‚Ú±%$ÁââRPmB U`1IˆYB  99€\1 yCCCÿf"[N 'Ü=TGÈ’øl8˜^Kû5<êSæRɤ”%î@@ à›Ê b1 qÅAXHˆ¸&ØB’R y n˜P„Ìã–4A €€j¹€€>Ü ˜ t!˜+(.ÈÅWQ±A2ÜÜMUÜ‚’’‚‚â `1 %`19€F< 3cZÄ`óe!\ˆ DÈ+. 83‹³Àä¸!lYYA -6‚EJŠ¢V €@©žXXX 4„å Ê@86Ð`RdB´€4I "Ý "–@xrÊŒ‚H€AÊ`—f ÉÈ°CŒ"XV0ɲ³C b@2…¬H ¬È“ p)!(ì‚ 0Ž4ˆ)(%RÁÎ ¶$€TÊ€¥Àþb‡b,säÐ@7À üÑ°‚Òî?f¥Ö—\PIx!I´¦"”Ȉ’3¨ QY˜ÿt^^ÛØgv- }>WJOAV`$&#”¦8ùøø8€\FF ›SFJ$ÂÆ€ÐƊС䈉ÀÀ 4ª…Èäå -Á§‡ €H²…—ŸŸŸf ?ðâ5„ €k1Âd‰,ŒÃ ³ƒ“€.€"­F™ËË€àñ‚½ÁIÈ€"±Ù4ÉH gx|‚f©m)))9´. aMDƒ& ºX@t± €èb @ÑÅ€¢‹%DKˆ.–], ºX@t± €èb @€d`‚ɽSµOIEND®B`‚libDAI-0.2.7/doc/html/form_43.png0000644000263000017630000000246211433220721015147 0ustar jorismkyb‰PNG  IHDRw+qÕÕõ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf°IDATX…í˜MlÜDÇßØÞ/³^µ ­„À¢¥U![hQ Lq$(¢8¨á£êÁQ)D(9$@á@ Ò’Ò”H ”‚ÔS9p‰UU@œHAp@ ¸%Eš²ÌŒÇã±³6•q”¿¬ùxž÷æççñØ»ËZ +µ˜).SiV¢])åŠÜõ:ÅXP–®ŽŸ•z©çX•øUµg¥zOÃøXbà³îÒºA3¬J ¼nœzÊ«î¿+˜­è¿–z³§à‘å†-1Bµ«Î‹ˆžüuÎ7 §Ä0ð÷cqRµ©Làú80QK©Ð’ôÕ4«²†°$þš?¼Ú–þú7×µ¡ïˆÛÌ<2ê°Zým, óïžjÊX¼VC¿µð îä\­‰ùj³0Èðm¨u”P.ɳ•Æ£+DÀ—L¨¶p’ìû@uyS4ˆ>à+Í‚îÛn‰D9,µ¥0\²§b“¦èçýÖz‹U¼¡e€ÕŽ ¯=HË×øϯõÐò{nVë . º!Æ&y õêfésn¸ž=弆×/ù©Yåmü¨ú„ ÿ"KLçEÿŠ8üÄvZüÅ/¼ñ…˜¹)üÚ´ ãKò:·†d¿ÒAvóÇY€/ìBÏ!Å•áaû<ÏNm ƒÉÆŸݯ~ÀŸ¿R{˜¬ë½” ^ýfkf— ¨N¥Fm¼v£¹üÈst¬6rlôü ®Ò”ÓNæN‡/xž3̪UØ3¼c|”rü~Ý­ÍÞcÊðU(À×|^Lç½N©ÃYf ™O¯ª0I²ô£žù ú2Vàx–&c Ú>u³Ì+Ngy¸Ï W¢ž¥ˆGÞ!ËæŠÉÀpן¡Cû*¼V‡§a2ÁÈÀ—Ì=䋃¨–s3Ž€¿œÜU-UÔ‰¢±É€·A7Ç”!GÀÿI弟­æ´þœ+‡á¢ž÷ñ¶:%:§b“éA1&5Áë»á*C‚Oߊ피ᬶM ^µ-8jdû0M†íÁkv%õm#ÇÈ¢#ù£0“¶ªþ z w}xdï„ã…P.ê9•-|Âœ µYj¿âBøó 3¬u‡‡{ðïÁäKäìÕK6¤ôþ¦æ=^­žŒRµÆakMj:þ#V®™,aø^«­ic‘~颩ÆïÂr[㌡~:Ÿ„ô“žÄâ@äejt°êŠV´,•cåîàGMÚ¢e×¢óÿK#bȺq`,QJ¿bÛ¶À+ý@ •dÀ{ßm¼÷šx8}m8ópCr2ß²òŽÂð +7½ Íe©,2oœfŠ>Á‰Ð˜7Á2Õ?*Û2¶m#gIEND®B`‚libDAI-0.2.7/doc/html/functions_func_0x63.html0000644000263000017630000003314411433220721017662 0ustar jorismkyb libDAI: Class Members - Functions
 

- c -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1TRWBP-members.html0000644000263000017630000004620611433220721020554 0ustar jorismkyb libDAI: Member List

dai::TRWBP Member List

This is the complete list of members for dai::TRWBP, including all inherited members.

_edge2lutdai::BP [protected]
_edgesdai::BP [protected]
_itersdai::BP [protected]
_lutdai::BP [protected]
_maxdiffdai::BP [protected]
_oldBeliefsFdai::BP [protected]
_oldBeliefsVdai::BP [protected]
_sentMessagesdai::BP [protected]
_updateSeqdai::BP [protected]
_weightdai::TRWBP [protected]
addTreeToWeights(const RootedTree &tree)dai::TRWBP
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::BP [inline, virtual]
belief(const VarSet &vs) const dai::BP [virtual]
beliefF(size_t I) const dai::BP [virtual]
beliefs() const dai::BP [virtual]
beliefV(size_t i) const dai::BP [virtual]
BP()dai::BP [inline]
BP(const FactorGraph &fg, const PropertySet &opts)dai::BP [inline]
BP(const BP &x)dai::BP [inline]
calcBeliefF(size_t I, Prob &p) const dai::TRWBP [inline, protected, virtual]
calcBeliefV(size_t i, Prob &p) const dai::TRWBP [protected, virtual]
calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const dai::TRWBP [protected, virtual]
calcNewMessage(size_t i, size_t _I)dai::BP [protected, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clearSentMessages()dai::BP [inline]
clone() const dai::TRWBP [inline, virtual]
construct()dai::TRWBP [protected, virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::BP [inline, virtual]
findMaxResidual(size_t &i, size_t &_I)dai::BP [protected]
getProperties() const dai::TRWBP [virtual]
getSentMessages() const dai::BP [inline]
identify() const dai::TRWBP [virtual]
ind_t typedefdai::BP [protected]
index(size_t i, size_t _I) const dai::BP [inline, protected]
index(size_t i, size_t _I)dai::BP [inline, protected]
init()dai::BP [virtual]
init(const VarSet &ns)dai::BP [virtual]
Iterations() const dai::BP [inline, virtual]
logZ() const dai::TRWBP [virtual]
LutType typedefdai::BP [protected]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::BP [inline, virtual]
message(size_t i, size_t _I) const dai::BP [inline, protected]
message(size_t i, size_t _I)dai::BP [inline, protected]
Namedai::TRWBP [static]
newMessage(size_t i, size_t _I) const dai::BP [inline, protected]
newMessage(size_t i, size_t _I)dai::BP [inline, protected]
nrtreesdai::TRWBP
operator=(const BP &x)dai::BP [inline]
printProperties() const dai::TRWBP [virtual]
props (defined in dai::BP)dai::BP
recordSentMessagesdai::BP
residual(size_t i, size_t _I) const dai::BP [inline, protected]
residual(size_t i, size_t _I)dai::BP [inline, protected]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::BP [virtual]
sampleWeights(size_t nrTrees)dai::TRWBP
setMaxIter(size_t maxiter)dai::BP [inline, virtual]
setProperties(const PropertySet &opts)dai::TRWBP [virtual]
setWeight(size_t I, Real c)dai::TRWBP [inline]
setWeights(const std::vector< Real > &c)dai::TRWBP [inline]
TRWBP()dai::TRWBP [inline]
TRWBP(const FactorGraph &fg, const PropertySet &opts)dai::TRWBP [inline]
updateMessage(size_t i, size_t _I)dai::BP [protected]
updateResidual(size_t i, size_t _I, Real r)dai::BP [protected]
Weight(size_t I) const dai::TRWBP [inline]
Weights() const dai::TRWBP [inline]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1FBP-members.html0000644000263000017630000004456111433220721020267 0ustar jorismkyb libDAI: Member List

dai::FBP Member List

This is the complete list of members for dai::FBP, including all inherited members.

_edge2lutdai::BP [protected]
_edgesdai::BP [protected]
_itersdai::BP [protected]
_lutdai::BP [protected]
_maxdiffdai::BP [protected]
_oldBeliefsFdai::BP [protected]
_oldBeliefsVdai::BP [protected]
_sentMessagesdai::BP [protected]
_updateSeqdai::BP [protected]
_weightdai::FBP [protected]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::BP [inline, virtual]
belief(const VarSet &vs) const dai::BP [virtual]
beliefF(size_t I) const dai::BP [virtual]
beliefs() const dai::BP [virtual]
beliefV(size_t i) const dai::BP [virtual]
BP()dai::BP [inline]
BP(const FactorGraph &fg, const PropertySet &opts)dai::BP [inline]
BP(const BP &x)dai::BP [inline]
calcBeliefF(size_t I, Prob &p) const dai::FBP [inline, protected, virtual]
calcBeliefV(size_t i, Prob &p) const dai::BP [protected, virtual]
calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const dai::FBP [protected, virtual]
calcNewMessage(size_t i, size_t _I)dai::FBP [protected, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clearSentMessages()dai::BP [inline]
clone() const dai::FBP [inline, virtual]
construct()dai::FBP [protected, virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
FBP()dai::FBP [inline]
FBP(const FactorGraph &fg, const PropertySet &opts)dai::FBP [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::BP [inline, virtual]
findMaxResidual(size_t &i, size_t &_I)dai::BP [protected]
getProperties() const dai::BP [virtual]
getSentMessages() const dai::BP [inline]
identify() const dai::FBP [virtual]
ind_t typedefdai::BP [protected]
index(size_t i, size_t _I) const dai::BP [inline, protected]
index(size_t i, size_t _I)dai::BP [inline, protected]
init()dai::BP [virtual]
init(const VarSet &ns)dai::BP [virtual]
Iterations() const dai::BP [inline, virtual]
logZ() const dai::FBP [virtual]
LutType typedefdai::BP [protected]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::BP [inline, virtual]
message(size_t i, size_t _I) const dai::BP [inline, protected]
message(size_t i, size_t _I)dai::BP [inline, protected]
Namedai::FBP [static]
newMessage(size_t i, size_t _I) const dai::BP [inline, protected]
newMessage(size_t i, size_t _I)dai::BP [inline, protected]
operator=(const BP &x)dai::BP [inline]
printProperties() const dai::BP [virtual]
props (defined in dai::BP)dai::BP
recordSentMessagesdai::BP
residual(size_t i, size_t _I) const dai::BP [inline, protected]
residual(size_t i, size_t _I)dai::BP [inline, protected]
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::BP [virtual]
setMaxIter(size_t maxiter)dai::BP [inline, virtual]
setProperties(const PropertySet &opts)dai::BP [virtual]
setWeight(size_t I, Real c)dai::FBP [inline]
setWeights(const std::vector< Real > &c)dai::FBP [inline]
updateMessage(size_t i, size_t _I)dai::BP [protected]
updateResidual(size_t i, size_t _I, Real r)dai::BP [protected]
Weight(size_t I) const dai::FBP [inline]
Weights() const dai::FBP [inline]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_115.png0000644000263000017630000000042111433220721015220 0ustar jorismkyb‰PNG  IHDR(SA»0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIDAT•c`Àج 0“ƒ&ŒSÆÀÌÀã\dÈ àp``èèèH¸È ËÀ‘ÀÀÐ&øUèÀ!†(N†¦ i  =ì ¸€ sf Ì@õ ¿’íöÈÎêâç%’D檉 ¬H8ŒÈÖ$’U\™ ˜öêSüƒIEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1fo__id.html0000644000263000017630000000707211433220721017662 0ustar jorismkyb libDAI: dai::fo_id< T > Struct Template Reference

dai::fo_id< T > Struct Template Reference

Function object that returns the value itself. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns x.

Detailed Description

template<typename T>
struct dai::fo_id< T >

Function object that returns the value itself.

Member Function Documentation

template<typename T>
T dai::fo_id< T >::operator() ( const T &  x  )  const [inline]

Returns x.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__log0.html0000644000263000017630000000731611433220721020130 0ustar jorismkyb libDAI: dai::fo_log0< T > Struct Template Reference

dai::fo_log0< T > Struct Template Reference

Function object that takes the logarithm, except that log(0) is defined to be 0. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns (x == 0 ? 0 : log(x)).

Detailed Description

template<typename T>
struct dai::fo_log0< T >

Function object that takes the logarithm, except that log(0) is defined to be 0.

Member Function Documentation

template<typename T>
T dai::fo_log0< T >::operator() ( const T &  x  )  const [inline]

Returns (x == 0 ? 0 : log(x)).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/lc_8h.html0000644000263000017630000000647411433220721015062 0ustar jorismkyb libDAI: include/dai/lc.h File Reference

include/dai/lc.h File Reference

Defines class LC, which implements loop corrections for approximate inference. More...

#include <string>
#include <dai/daialg.h>
#include <dai/enum.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>
#include <dai/exceptions.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::LC
 Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]. More...
struct  dai::LC::Properties
 Parameters for LC. More...

Detailed Description

Defines class LC, which implements loop corrections for approximate inference.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_59.png0000644000263000017630000000032211433220721015147 0ustar jorismkyb‰PNG  IHDRúÿr›0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfPIDAT™c`@(ô&cfc á±ÜÛç1è¸0 x libDAI: include/dai/mr.h File Reference

include/dai/mr.h File Reference

Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo. More...

#include <vector>
#include <string>
#include <dai/factorgraph.h>
#include <dai/daialg.h>
#include <dai/enum.h>
#include <dai/properties.h>
#include <dai/exceptions.h>
#include <dai/graph.h>
#include <boost/dynamic_bitset.hpp>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::MR
 Approximate inference algorithm by Montanari and Rizzo [MoR05]. More...
struct  dai::MR::Properties
 Parameters for MR. More...

Detailed Description

Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions.html0000644000263000017630000004636411433220721016077 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- _ -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/bp__dual_8h-source.html0000644000263000017630000006143711433220721017527 0ustar jorismkyb libDAI: include/dai/bp_dual.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_39.png0000644000263000017630000000062011433220721015146 0ustar jorismkyb‰PNG  IHDRgÀ”X0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIDAT(‘c` 0àæ¡F#(ƒã²°Ì|š˜¾A¬àb \pS1¬âOP6\c%P¿ÌÐ4=âJ`®‚)cœbÈCE™w é‘\„ì* 2ç;ÁšcD@zf é‘˜„âªXõ@ª Â[ÁØ` ¤–£éa_q,lg00ƒDØ'ƒy™ð nBÓU VÎÏÀÌf<kb`ß"?0¤Ã½ÀÐC Õ@ÂWÙíðï!Tû Ï+°6À=ÁüŠÀvuyHqD šX6+3D°B½ÁŽ8` )¼‚!<µ%HŽgü÷‚àfš‚Oim2ù8V?}IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1DecMAP.html0000644000263000017630000012320411433220721017251 0ustar jorismkyb libDAI: dai::DecMAP Class Reference

dai::DecMAP Class Reference

Approximate inference algorithm DecMAP, which constructs a MAP state by decimation. More...

#include <dai/decmap.h>

Inheritance diagram for dai::DecMAP:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 DecMAP ()
 Default constructor.
 DecMAP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual DecMAP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual std::vector< size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability.
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

struct dai::DecMAP::Properties props

Static Public Attributes

static const char * Name = "DECMAP"
 Name of this inference algorithm.

Private Attributes

std::vector< size_t > _state
 Stores the final MAP state.
Real _logp
 Stores the log probability of the MAP state.
Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.

Classes

struct  Properties
 Parameters for DecMAP. More...

Detailed Description

Approximate inference algorithm DecMAP, which constructs a MAP state by decimation.

Decimation involves repeating the following two steps until no free variables remain:

  • run an approximate inference algorithm,
  • clamp the factor with the lowest entropy to its most probable state
Examples:

example.cpp.

Constructor & Destructor Documentation

dai::DecMAP::DecMAP (  )  [inline]

Default constructor.

dai::DecMAP::DecMAP ( const FactorGraph &  fg,
const PropertySet &  opts 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties

Member Function Documentation

virtual DecMAP* dai::DecMAP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::DecMAP::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::DecMAP::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::DecMAP::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Factor dai::DecMAP::beliefV ( size_t  i  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual Factor dai::DecMAP::beliefF ( size_t  I  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

vector< Factor > dai::DecMAP::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::DecMAP::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual std::vector<size_t> dai::DecMAP::findMaximum (  )  const [inline, virtual]

Calculates the joint state of all variables that has maximum probability.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

Examples:
example.cpp.

virtual void dai::DecMAP::init (  )  [inline, virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

Examples:
example.cpp.

virtual void dai::DecMAP::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::DecMAP::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

Examples:
example.cpp.

virtual Real dai::DecMAP::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::DecMAP::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::DecMAP::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::DecMAP::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::DecMAP::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Member Data Documentation

std::vector<size_t> dai::DecMAP::_state [private]

Stores the final MAP state.

Real dai::DecMAP::_logp [private]

Stores the log probability of the MAP state.

Real dai::DecMAP::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::DecMAP::_iters [private]

Number of iterations needed.

const char * dai::DecMAP::Name = "DECMAP" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/gibbs_8h-source.html0000644000263000017630000006610211433220721017042 0ustar jorismkyb libDAI: include/dai/gibbs.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_117.png0000644000263000017630000000045611433220721015232 0ustar jorismkyb‰PNG  IHDRÃdú¸0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf¬IDAT•c`ÀQ¹$<†¶8——I€áœkÍàò€á˜ÙÑÑÑ`Å :á"˜+¿Qø¢5ŸT–wƒ+/W‚+ÌæÀÀÀnã20420ˆ1 ¸€…ËtÓB0—oȘ` ü@š áHuöµ@(·‹Wá'”{Ù€“ß!Ê5càd` `U‚ë¶:3ïõFóC‹IEND®B`‚libDAI-0.2.7/doc/html/form_143.png0000644000263000017630000000264311433220721015231 0ustar jorismkyb‰PNG  IHDR[+$´6«0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf!IDATX…å˜_h[UÇ¿÷OþÝä¦7•´Öî êFq3Rq30ºt* NêVP³¶dKuŠ1ê,iº1$!XDÚWö "Jã¦OV'›ø”ú >ͤ«†¨¿sóïÞ›Ü6Ô–ðG¸÷œßïwîùÜß=çwÎ ð?Õn½¸cyÄ­ _m)HkâŽoàÀ+V–ï·–¤%Y÷ýo³Ù/sÑ‚•Ý6\>›é•ŽÙU*3ftÎÙ»u^¶á>ŽªA{U3i¸þΚ–û×tN¶á®ÂcÔêp¥dMKÅ×uN¶á®A Ø Æ©ŽA˜ÐáêDβšm¸~bÓÿ¹Èo\QŠ=†1îOÍdÆuþ3GW®Zµ Wx—È0Hc 4ˆŽØ*šG]K¡}ØE+ǃ¬f.”PÁ–-*¶ÝS†SòÂ}@WNZz‹h7>ÅÒ0¯ê,æ*Jx[e¹G³yfûóͺýHW.£¦9î§Z@ûߠˈqh‡qʸeáØL}‚Ú¼i»áj2ò‰jÑ´-qÅ p÷³-2oÎÂm‰ œÆŠ#F[Ü´QÝN¸­BÛZ—B«xQ[XzMMÛ÷ +K\¾.Š¹{!ŽC&íƒË©¬ÜOKŠoþtHŠÑ1xdÓÙ¥}p£y1 kD ü*k^kãè*Úæ3\!òÅeàdSÓ6Àuþ~ ÇÿR-º^,VÔEYƨ©ià‚ND\e·áyµ¢å2´,›Ï±và:ÿ¾Þ¨Íß%6Ψ9~½hv²Kœãûlü >–”BÐ|DðIEND®B`‚libDAI-0.2.7/doc/html/form_27.png0000644000263000017630000000160711433220721015151 0ustar jorismkyb‰PNG  IHDR¢'~¡ŽC0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIDATH‰å–ÏKaÇ¿3³»³»¸;³a^v@ˆñó ´!˜èž"¼8‡Z¢·.Ñ¡vé BTVÄ¢`.ˆE]\:Ô±-¼ÕÁC‡.ø¤®"¶âö¼ï;êì:‘8K—žÃû>ï¯Ï<Ïû>ÏÃÿ\RN.7š¨üÏÄî1!üöÀòB<»#éú¸"FL¯y²1XÕyÿZŒ~Qó¤ð—£·vŸáœ>³&P?kQfÛeËÞ.úÐÖĨ{œq'ñRZ㼓ôzâå…Ý‘t‰®Œ¸Ùê0ËÍ_Õaº“Xf<ÛY ó–®*žz¾·¿Éˆ9G9‰|º´³°øz hnºŸDݨU\‰7M²ik} ¦ðÉÈ÷‡E,BÙ¸C•öSÐMdjˆr5åFT hë Z°´“%â°¯ŸÓ¹–e[²´ßÚ=zê‰xed—Ýˆá ¢&05z¶›8ÈÒ:hBÄ ¹#±¸¶/¡iÁ5¡ñýôz%›8Åš¤¥mrBÓ6XФÓÉÚ‹lw½G±ü9dò>„2Š4ײͼ|‡Ç¹‘yœLþá­ñÙ•Øä!•Õ|3¢|90ÏØÊÄ(|¥$9Ðêä|™˜2¹1]‰CÀó°Waîsÿl¡Ù®‡?áè+à­ÐfEW—37gà+ÛI!Ý7pl﨔ã-Ù©Xbañ ªÈMµŽØâ‰àÄj38¶Ëv:-ážP†Dw£Þk[LXü" åk•ì:…XþLNqÊ°Á»xUçæªïq½Z±TVÁ“ñxZˆðŽE=ÿ¡Lì0kË¥g‘7Ãý©ÉÑý³m¼S§õª-£PGÒW|kwú®ÁÿTGsÔ‹U/g)†$i X±á9ÛŸð@Ô1‰ù£¤ €›ž±QàÕUÄ_ÉÕÛ!ÊÊ°bs‚dÉ0TèËDŽXrÁƒ› ‰àÑI„ÊYÕOVlîæ½ÿüúɤ^9åolÀ« ¥X~A;Ó¤Í*IEND®B`‚libDAI-0.2.7/doc/html/hak_8h-source.html0000644000263000017630000006153311433220721016522 0ustar jorismkyb libDAI: include/dai/hak.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BP__dual_1_1messages.html0000644000263000017630000002164411433220721022301 0ustar jorismkyb libDAI: dai::BP_dual::messages Struct Reference

dai::BP_dual::messages Struct Reference

Groups together the data structures for storing the two types of messages and their normalizers. More...

#include <dai/bp_dual.h>

List of all members.

Public Attributes

_edges_t< Prob > n
 Unnormalized variable->factor messages.
_edges_t< Real > Zn
 Normalizers of variable->factor messages.
_edges_t< Prob > m
 Unnormalized Factor->variable messages.
_edges_t< Real > Zm
 Normalizers of factor->variable messages.

Detailed Description

Groups together the data structures for storing the two types of messages and their normalizers.

Member Data Documentation

_edges_t<Prob> dai::BP_dual::messages::n

Unnormalized variable->factor messages.

_edges_t<Real> dai::BP_dual::messages::Zn

Normalizers of variable->factor messages.

_edges_t<Prob> dai::BP_dual::messages::m

Unnormalized Factor->variable messages.

_edges_t<Real> dai::BP_dual::messages::Zm

Normalizers of factor->variable messages.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x66.html0000644000263000017630000001700111433220721017657 0ustar jorismkyb libDAI: Class Members - Functions
 

- f -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/smallset_8h.html0000644000263000017630000000473011433220721016301 0ustar jorismkyb libDAI: include/dai/smallset.h File Reference

include/dai/smallset.h File Reference

Defines the SmallSet<> class, which represents a set (optimized for a small number of elements). More...

#include <vector>
#include <algorithm>
#include <iostream>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::SmallSet< T >
 Represents a set; the implementation is optimized for a small number of elements. More...

Detailed Description

Defines the SmallSet<> class, which represents a set (optimized for a small number of elements).

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_99.png0000644000263000017630000000062611433220721015162 0ustar jorismkyb‰PNG  IHDR7@\úû0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIDAT•c` 0‚ „ecaCac†"sdvKúl/ZèýÉÙ’ìr4Ð$Yì €’I/€F.@ød†° dJš‹Îè>ëêøÜIEND®B`‚libDAI-0.2.7/doc/html/form_19.png0000644000263000017630000000030011433220721015137 0ustar jorismkyb‰PNG  IHDR  ®‘é0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf>IDAT™c`€‰ŽŽ]­(=D70¬‹;p^€(ˆƒP¬Ÿ ´¿;ˆbúÄ ¢õ˜誙³& Ž ­k‚ IEND®B`‚libDAI-0.2.7/doc/html/form_106.png0000644000263000017630000000075711433220721015234 0ustar jorismkyb‰PNG  IHDRJ#ÁÐ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfmIDAT8c`€­šñªbÿ¯((((’û¿aç/€)Y¼ªä@輪XþCLQÀoåüøå!€ÿ7¦˜["ˆä@ˆ0ýO€ÛžçJèQö 0‚Êæ„©ZƱLû1$1%€$•ãþ 3ꛂÖ" ã$‡1þ„2x&00ð‚||ÑC™a&@$Y'@Uñ&0ðƒé E1 w!™¥c°°+Ø‚­aúƒIÓ8ÓÕ¡Ê„y xÀ4lCEYQ1l…P P»°.ˆÑ\Ø¥¡ D0ZþÀ§ˆå?üŧˆ9 ’ðª¢"`4VQÊ ÌxÓýrF`0Ëp(àSõˆ!˜‚œ?°ãµòà ™°O€±`>´±@?ˆÁ·*ΦF  ܘð¨²O`–ìL˜'àV%(ÀÀ>³€è&¦b¼î‡<6búMâ©I2iIEND®B`‚libDAI-0.2.7/doc/html/factorgraph_8h-source.html0000644000263000017630000012776211433220721020266 0ustar jorismkyb libDAI: include/dai/factorgraph.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_58.png0000644000263000017630000000056111433220721015153 0ustar jorismkyb‰PNG  IHDR2¦u1¿0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfïIDAT•c`  #²˜²±1»ƒ±!“±€“±ƒ± XÆçZúC†ÆülßÌXî;0Ì àÁWÀp“a÷3{†¦ ~†¬ ÌŸ7€dø'0Éø3°_à42Þ+€dØ?U1lÉÌŸ¹‚dîz ã/ †6Ìs É°ë€d¾2@e?AeŠØ?€d˜>ÀdXA,NƯ`{€dñÜ éÖûì €2s¯ƒd.Àb”6ƒPL pWT.Dà± È8ã {†2ßÂB²IEND®B`‚libDAI-0.2.7/doc/html/form_76.png0000644000263000017630000000035211433220721015151 0ustar jorismkyb‰PNG  IHDRúÿr›0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfhIDAT™c`À9ìPóJ Á$4઺€x"ƒ"“œ·€):) Æc `åWð‚ñ€†Ø1L‡ñ¤:ÂxÅ G™.$9’÷&0,``øÀ´ jS²»8y\ XùÍr”’IEND®B`‚libDAI-0.2.7/doc/html/functions_0x72.html0000644000263000017630000002701111433220721016643 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- r -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1TFactor.png0000644000263000017630000000063711433220721017406 0ustar jorismkyb‰PNG  IHDRnP ]PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf5IDATX…íÖQnà PüÓoÛ7€Ý “vž}åþG˜Á@Í(å#«T܉˜WÀI£:Z ‡n%à=”¤TrbMÛ±±Œ§¶Ó8gÖ¦Ž@¾,ÊN¦”K„Ò8ľo#B<²ƒ”ÁÔHÖVGÆÅ¡XçKÛÈLey>²Ûu’q™•u’qèç棾ÃâúûÓz‚­‹T2–´ž£ûð|l÷*nõ=8‰ÛÒRÖÝñ}©»Ç¥îòzn·ÝvÛm7‰Ïq|MrîVâã­œ¯üÓ“K‚±ž«Ùô§Ž|𤃋“~¼ÌAæfê;H°OGv©O±ÑlßÅ©8ïÓÉJ´™8OlÖ™ì)Ç›ýq¾ libDAI: include/dai/weightedgraph.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/uai2010-aie-solver_8cpp-example.html0000644000263000017630000014210511433220721021565 0ustar jorismkyb libDAI: uai2010-aie-solver.cpp

uai2010-aie-solver.cpp

This example contains the full source code of the solver that was one of the winners (the 'libDAI2' solver) in the UAI 2010 Approximate Inference Challenge (see http://www.cs.huji.ac.il/project/UAI10/ for more information).

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2008-2010  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <iostream>
#include <fstream>
#include <ostream>
#include <cstdlib>
#include <dai/alldai.h>
#include <dai/io.h>


using namespace std;
using namespace dai;


// Type for storing a joint state of all variables
typedef std::vector<size_t> stateVec;


struct PRbest {
    Real value;
    Real maxdiff;
    bool ready;
    PRbest() : value(0.0), maxdiff(INFINITY), ready(false) {}
};

struct MARbest {
    vector<Factor> beliefs;
    Real maxdiff;
    bool ready;
    MARbest() : beliefs(), maxdiff(INFINITY), ready(false) {}
};

struct MPEbest {
    Real value;
    stateVec state;
    bool ready;
    MPEbest() : value(-INFINITY), state(), ready(false) {}
};


int main( int argc, char *argv[] ) {
    if ( argc != 5 ) {
        cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl;
        cout << "It is one of the winning solvers that participated in the" << endl;
        cout << "UAI 2010 Approximate Inference Challenge" << endl;
        cout << "(see http://www.cs.huji.ac.il/project/UAI10/)" << endl << endl;
        cout << "Usage: " << argv[0] << " <filename.uai> <filename.uai.evid> <seed> <task>" << endl << endl;
        return 1;
    } else {
        double starttic = toc();

        size_t verbose = 1;    // verbosity
        size_t ia_verbose = 0; // verbosity of inference algorithms
        bool surgery = true;   // change factor graph structure based on evidence
        if( verbose )
            cout << "Solver:               " << argv[0] << endl;

        // set random seed
        size_t seed = fromString<size_t>( argv[3] );
        rnd_seed( seed );
        if( verbose )
            cout << "Seed:                 " << seed << endl;

        // check whether the task is valid
        string task( argv[4] );
        if( task != string("PR") && task != string("MPE") && task != string("MAR") )
            DAI_THROWE(RUNTIME_ERROR,"Unknown task");
        if( verbose )
            cout << "Task:                 " << task << endl;

        // output other command line options
        if( verbose ) {
            cout << "Factorgraph filename: " << argv[1] << endl;
            cout << "Evidence filename:    " << argv[2] << endl;
        }

        // get time and memory limits
        char *buf = getenv( "UAI_TIME" );
        double UAI_time = INFINITY;
        if( buf != NULL )
            UAI_time = fromString<double>( buf );
        buf = getenv( "UAI_MEMORY" );
        size_t UAI_memory = 0;
        if( buf != NULL ) {
            UAI_memory = fromString<double>( buf ) * 1024 * 1024 * 1024;
        }
        if( verbose ) {
            cout << "Time limit:           " << UAI_time << endl;
            cout << "Memory limit:         " << UAI_memory << endl;
        }

        // build output file name
        vector<string> pathComponents = tokenizeString( string(argv[1]), true, "/" );
        string outfile = pathComponents.back() + "." + task;
        if( verbose )
            cout << "Output filename:      " << outfile << endl;

        // open output stream
        ofstream os;
        os.open( outfile.c_str() );
        if( !os.is_open() )
            DAI_THROWE(CANNOT_WRITE_FILE,"Cannot write to file " + outfile);
        if( verbose )
            cout << "Opened output stream" << endl;

        // read factor graph
        vector<Var> vars;
        vector<Factor> facs0;
        vector<Permute> permutations;
        if( verbose )
            cout << "Reading factor graph..." << endl;
        ReadUaiAieFactorGraphFile( argv[1], verbose, vars, facs0, permutations );
        if( verbose )
            cout << "Successfully read factor graph" << endl;

        // check if it could be a grid
        bool couldBeGrid = true;
        FactorGraph fg0( facs0.begin(), facs0.end(), vars.begin(), vars.end(), facs0.size(), vars.size() );
        for( size_t i = 0; i < fg0.nrVars(); i++ )
            if( fg0.delta(i).size() > 4 ) {
                couldBeGrid = false;
                break;
            }
        if( couldBeGrid )
            for( size_t I = 0; I < fg0.nrFactors(); I++ )
                if( fg0.factor(I).vars().size() > 2 ) {
                    couldBeGrid = false;
                    break;
                }
        if( verbose ) {
            if( couldBeGrid )
                cout << "This could be a grid!" << endl;
            else
                cout << "This cannot be a grid!" << endl;
        }

        // read evidence
        if( verbose )
            cout << "Reading evidence..." << endl;
        vector<map<size_t,size_t> > evid = ReadUaiAieEvidenceFile( argv[2], verbose );
        if( verbose )
            cout << "Successfully read " << evid.size() << " evidence cases" << endl;

        // write output header
        if( verbose )
            cout << "  Writing header to file..." << endl;
        os << task << endl;

        // construct clamped factor graphs
        if( verbose )
            cout << "Constructing clamped factor graphs..." << endl;
        vector<FactorGraph> fgs;
        fgs.reserve( evid.size() );
        for( size_t ev = 0; ev < evid.size(); ev++ ) {
            if( verbose )
                cout << "  Evidence case " << ev << "..." << endl;
            // copy vector of factors
            vector<Factor> facs( facs0 );

            // change factor graph to reflect observed evidence
            if( verbose )
                cout << "    Applying evidence..." << endl;
            if( surgery ) {
                // replace factors with clamped variables with slices
                for( size_t I = 0; I < facs.size(); I++ ) {
                    for( map<size_t,size_t>::const_iterator e = evid[ev].begin(); e != evid[ev].end(); e++ ) {
                        if( facs[I].vars() >> vars[e->first] ) {
                            if( verbose >= 2 )
                                cout << "      Clamping " << e->first << " to value " << e->second << " in factor " << I << " = " << facs[I].vars() << endl;
                            facs[I] = facs[I].slice( vars[e->first], e->second );
                            if( verbose >= 2 )
                                cout << "      ...remaining vars: " << facs[I].vars() << endl;
                        }
                    }
                }
                // remove empty factors
                Real logZcorr = 0.0;
                for( vector<Factor>::iterator I = facs.begin(); I != facs.end(); )
                    if( I->vars().size() == 0 ) {
                        logZcorr += std::log( (Real)(*I)[0] );
                        I = facs.erase( I );
                    } else
                        I++;
                // multiply with logZcorr constant
                if( facs.size() == 0 )
                    facs.push_back( Factor( VarSet(), std::exp(logZcorr) ) );
                else
                    facs.front() *= std::exp(logZcorr);
            }
            // add delta factors corresponding to observed variable values
            for( map<size_t,size_t>::const_iterator e = evid[ev].begin(); e != evid[ev].end(); e++ )
                facs.push_back( createFactorDelta( vars[e->first], e->second ) );

            // construct clamped factor graph
            if( verbose )
                cout << "    Constructing factor graph..." << endl;
            fgs.push_back( FactorGraph( facs.begin(), facs.end(), vars.begin(), vars.end(), facs.size(), vars.size() ) );
        }

        // variables for storing best results so far
        vector<PRbest> bestPR( evid.size() );
        vector<MARbest> bestMAR( evid.size() );
        vector<MPEbest> bestMPE( evid.size() );
        for( size_t ev = 0; ev < evid.size(); ev++ )
            bestMPE[ev].state = stateVec( fgs[ev].nrVars(), 0 );
        vector<size_t> ev2go;
        ev2go.reserve( evid.size() );
        for( size_t ev = 0; ev < evid.size(); ev++ )
            ev2go.push_back( ev );

        // solve inference problems
        if( verbose )
            cout << "Solving inference problems..." << endl;
        bool first = true;
        size_t nrsolvers = 3;
        vector<size_t> nrsubsolvers( nrsolvers );
        nrsubsolvers[0] = 2;
        nrsubsolvers[1] = 1;
        nrsubsolvers[2] = 1;
        double MPEdamping = 0.49;
        // for each (sub)solver
        for( size_t solver = 0; solver < nrsolvers; solver++ ) {
            if( verbose )
                cout << "  Solver " << solver << endl;

            // for each evidence case
            size_t subsolver = 0;
            for( long _ev = 0; _ev < (long)ev2go.size(); ) {
                bool improved = false;
                size_t ev = ev2go[_ev];
                if( verbose )
                    cout << "    Evidence case " << ev << ", subsolver = " << subsolver << "..." << endl;

                // construct inference algorithm on clamped factor graph
                if( verbose )
                    cout << "      Constructing inference algorithm..." << endl;
                InfAlg *ia = NULL;
                double tic = toc();
                bool failed = false;
                try {
                    // construct
                    if( solver == 0 ) { // the quick one
                        double remtime = (UAI_time - (toc() - starttic)) * 0.9;
                        if( remtime < 1.0 )
                            remtime = 1.0 ;
                        double maxtime = remtime / (ev2go.size() - _ev);
                        if( verbose ) {
                            cout << "      Past time:     " << (toc() - starttic) << endl;
                            cout << "      Remaining time:" << remtime << endl;
                            cout << "      Allotted time: " << maxtime << endl;
                        }
                        string maxtimestr;
                        if( maxtime != INFINITY )
                            maxtimestr = ",maxtime=" + toString(maxtime);
                        // quick and dirty...
                        if( task == "MPE" )
                            ia = newInfAlgFromString( "BP[inference=MAXPROD,updates=SEQRND,logdomain=" + toString(subsolver) + ",tol=1e-9,maxiter=10000" + maxtimestr + ",damping=0.1,verbose=" + toString(ia_verbose) + "]", fgs[ev] );
                        else {
                            if( couldBeGrid )
                                ia = newInfAlgFromString( "HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=4,tol=1e-9,maxiter=10000" + maxtimestr + ",verbose=" + toString(ia_verbose) + "]", fgs[ev] );
                            else
                                ia = newInfAlgFromString( "BP[inference=SUMPROD,updates=SEQRND,logdomain=" + toString(subsolver) + ",tol=1e-9,maxiter=10000" + maxtimestr + ",damping=0.0,verbose=" + toString(ia_verbose) + "]", fgs[ev] );
                        }
                    } else if( solver == 1 ) { // the exact one
                        string maxmemstr;
                        if( UAI_memory != 0 )
                            maxmemstr = ",maxmem=" + toString(UAI_memory);
                        if( task == "MPE" )
                            ia = newInfAlgFromString( "JTREE[inference=MAXPROD,updates=HUGIN" + maxmemstr + ",verbose=" + toString(ia_verbose) + "]", fgs[ev] );
                        else
                            ia = newInfAlgFromString( "JTREE[inference=SUMPROD,updates=HUGIN" + maxmemstr + ",verbose=" + toString(ia_verbose) + "]", fgs[ev] );
                    } else if( solver == 2 ) { // the decent one
                        double remtime = (UAI_time - (toc() - starttic));
                        if( remtime < 1.0 )
                            remtime = 1.0;
                        double maxtime = 0.95 * remtime / (ev2go.size() - _ev);
                        if( verbose ) {
                            cout << "      Past time:     " << (toc() - starttic) << endl;
                            cout << "      Remaining time:" << remtime << endl;
                            cout << "      Allotted time: " << maxtime << endl;
                        }
                        if( task == "MPE" )
                            maxtime /= fgs[ev].nrVars();
                        string maxtimestr;
                        if( maxtime != INFINITY )
                            maxtimestr = ",maxtime=" + toString(maxtime);
                        if( task == "MPE" )
                            ia = newInfAlgFromString( "DECMAP[ianame=BP,iaopts=[inference=MAXPROD,updates=SEQRND,logdomain=1,tol=1e-9,maxiter=10000" + maxtimestr + ",damping=" + toString(MPEdamping) + ",verbose=0],reinit=1,verbose=" + toString(ia_verbose) + "]", fgs[ev] );
                        else {
                            if( couldBeGrid )
                                ia = newInfAlgFromString( "HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=4,tol=1e-9" + maxtimestr + ",maxiter=100000,verbose=" + toString(ia_verbose) + "]", fgs[ev] );
                            else {
                                if( task == "PR" )
                                    ia = newInfAlgFromString( "HAK[doubleloop=1,clusters=MIN,init=UNIFORM,tol=1e-9" + maxtimestr + ",maxiter=100000,verbose=" + toString(ia_verbose) + "]", fgs[ev] );
                                else
                                    ia = newInfAlgFromString( "GIBBS[maxiter=1000000000,burnin=1000,restart=10000000" + maxtimestr + ",verbose=" + toString(ia_verbose) + "]", fgs[ev] );
                            }
                        }
                    }

                    // initialize
                    if( verbose )
                        cout << "      Initializing inference algorithm..." << endl;
                    ia->init();
                    // run
                    if( verbose )
                        cout << "      Running inference algorithm..." << endl;
                    ia->run();
                    if( verbose )
                        cout << "      Inference algorithm finished..." << endl;
                } catch( Exception &e ) {
                    failed = true;
                    if( verbose ) {
                        cout << "      Inference algorithm failed...!" << endl;
                        cout << "      Exception: " << e.what() << endl;
                    }
                }

                if( verbose )
                    cout << "      Used time:             " << toc() - tic << endl;
                if( !failed && verbose ) {
                    try {
                        cout << "      Number of iterations:  " << ia->Iterations() << endl;
                    } catch( Exception &e ) {
                        cout << "      Number of iterations:   N/A" << endl;
                    }
                    try {
                        cout << "      Final maxdiff:         " << ia->maxDiff() << endl;
                    } catch( Exception &e ) {
                        cout << "      Final maxdiff:          N/A" << endl;
                    }
                }

                // update results for inference task
                if( !failed ) {
                    if( task == "PR" ) {
                        PRbest cur;

                        // calculate PR value
                        cur.value = ia->logZ() / dai::log((Real)10.0);

                        // get maxdiff
                        try {
                            cur.maxdiff = ia->maxDiff();
                        } catch( Exception &e ) {
                            cur.maxdiff = 1e-9;
                        }

                        // only update if this run has converged
                        if( ((cur.maxdiff <= 1e-9) || (cur.maxdiff <= bestPR[ev].maxdiff)) && !dai::isnan(cur.value) ) {
                            // if this was exact inference, we are ready
                            if( solver == 1 ) {
                                ev2go.erase( ev2go.begin() + _ev );
                                _ev--;
                                cur.ready = true;
                            }

                            if( verbose )
                                cout << "    Replacing best PR value so far (" << bestPR[ev].value << ") with new value " << cur.value << endl;
                            bestPR[ev] = cur;
                            improved = true;
                        } else {
                            if( verbose )
                                cout << "    Discarding PR value " << cur.value << endl;
                        }
                    } else if( task == "MAR" ) {
                        MARbest cur;

                        // get variable beliefs
                        bool hasnans = false;
                        cur.beliefs.reserve( fgs[ev].nrVars() );
                        for( size_t i = 0; i < fgs[ev].nrVars(); i++ ) {
                            cur.beliefs.push_back( ia->beliefV(i) );
                            if( cur.beliefs.back().hasNaNs() )
                                hasnans = true;
                        }

                        // get maxdiff
                        try {
                            cur.maxdiff = ia->maxDiff();
                        } catch( Exception &e ) {
                            cur.maxdiff = 1e-9;
                        }

                        // only update if this run has converged
                        if( ((cur.maxdiff <= 1e-9) || (cur.maxdiff <= bestMAR[ev].maxdiff)) && !hasnans ) {
                            // if this was exact inference, we are ready
                            if( solver == 1 ) {
                                ev2go.erase( ev2go.begin() + _ev );
                                _ev--;
                                cur.ready = true;
                            }

                            if( verbose )
                                cout << "    Replacing best beliefs so far with new beliefs" << endl;
                            bestMAR[ev] = cur;
                            improved = true;
                        } else {
                            if( verbose )
                                cout << "    Discarding beliefs" << endl;
                        }
                    } else if( task == "MPE" ) {
                        MPEbest cur;

                        // calculate MPE state
                        cur.state = ia->findMaximum();

                        // calculate MPE value
                        cur.value = fgs[ev].logScore( cur.state );

                        // update best MPE state and value
                        if( cur.value > bestMPE[ev].value && !dai::isnan(cur.value) ) {
                            // if this was exact inference, we are ready
                            if( solver == 1 ) {
                                ev2go.erase( ev2go.begin() + _ev );
                                _ev--;
                                cur.ready = true;
                            }

                            if( verbose )
                                cout << "    Replacing best MPE value so far (" << bestMPE[ev].value << ") with new value " << cur.value << endl;
                            bestMPE[ev] = cur;
                            improved = true;
                        } else {
                            if( verbose )
                                cout << "    New MPE value " << cur.value << " not better than best one so far " << bestMPE[ev].value << endl;
                        }
                    }
                }

                // remove inference algorithm
                if( verbose )
                    cout << "    Cleaning up..." << endl;
                if( !failed )
                    delete ia;

                // write current best output to stream
                if( improved ) {
                    if( verbose )
                        cout << "    Writing output..." << endl;
                    if( first )
                        first = false;
                    else
                        os << "-BEGIN-" << endl;
                    os << evid.size() << endl;
                    for( size_t ev = 0; ev < evid.size(); ev++ ) {
                        if( task == "PR" ) {
                            // output probability of evidence
                            os << bestPR[ev].value << endl;
                        } else if( task == "MAR" ) {
                            // output variable marginals
                            os << bestMAR[ev].beliefs.size() << " ";
                            for( size_t i = 0; i < bestMAR[ev].beliefs.size(); i++ ) {
                                os << bestMAR[ev].beliefs[i].nrStates() << " ";
                                for( size_t s = 0; s < bestMAR[ev].beliefs[i].nrStates(); s++ )
                                    os << bestMAR[ev].beliefs[i][s] << " ";
                            }
                            os << endl;
                        } else if( task == "MPE" ) {
                            // output MPE state
                            os << fgs[ev].nrVars() << " ";
                            for( size_t i = 0; i < fgs[ev].nrVars(); i++ )
                                os << bestMPE[ev].state[i] << " ";
                            os << endl;
                        }
                    }
                    os.flush();
                }

                if( verbose )
                    cout << "    Done..." << endl;

                if( !improved )
                    subsolver++;
                if( improved || subsolver >= nrsubsolvers[solver] || couldBeGrid ) {
                    subsolver = 0;
                    _ev++;
                }
            }

            if( task == "MPE" && solver == 2 && (toc() - starttic) < UAI_time && MPEdamping != 0.0 ) {
                MPEdamping /= 2.0;
                solver--;  // repeat this one
            }
            if( ev2go.size() == 0 )
                break;
        }

        // close output file
        if( verbose )
            cout << "Closing output file..." << endl;
        os.close();
        
        if( verbose )
            cout << "Done!" << endl;
    }

    return 0;
}
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x70.html0000644000263000017630000001663411433220721017665 0ustar jorismkyb libDAI: Class Members - Functions
 

- p -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_40.png0000644000263000017630000000051111433220721015135 0ustar jorismkyb‰PNG  IHDR6âV0Î0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÇIDAT•c` ˜ °ˆftA“Ø“H,rŸý„TÀ:,Z Læ ö a†2¾eu@–ãX 7É_ YÙþÕ 8åØ>1à”cÿÁ!W4ŸÁYÎÌ)iSÐ7`hG–[Ïòè…% ¼2$ÀåXÀ /20X­`ðZÉðIŸòGDp)ë9@û+0o€éƒ#F\î¶û‡y\Pô#¦ÎdM»eªql6lÏÂK¡IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1DEdge-members.html0000644000263000017630000000627111433220721020624 0ustar jorismkyb libDAI: Member List

dai::DEdge Member List

This is the complete list of members for dai::DEdge, including all inherited members.

DEdge()dai::DEdge [inline]
DEdge(size_t m1, size_t m2)dai::DEdge [inline]
firstdai::DEdge
operator<(const DEdge &x) const dai::DEdge [inline]
operator<<(std::ostream &os, const DEdge &e)dai::DEdge [friend]
operator==(const DEdge &x) const dai::DEdge [inline]
seconddai::DEdge

Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1RootedTree-members.html0000644000263000017630000000411211433220721021720 0ustar jorismkyb libDAI: Member List

dai::RootedTree Member List

This is the complete list of members for dai::RootedTree, including all inherited members.

RootedTree()dai::RootedTree [inline]
RootedTree(const GraphEL &T, size_t Root)dai::RootedTree

Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1SharedParameters.html0000644000263000017630000006537211433220721021465 0ustar jorismkyb libDAI: dai::SharedParameters Class Reference

dai::SharedParameters Class Reference

Represents a single factor or set of factors whose parameters should be estimated. More...

#include <dai/emalg.h>

List of all members.

Public Types

typedef size_t FactorIndex
 Convenience label for an index of a factor in a FactorGraph.
typedef std::map< FactorIndex,
std::vector< Var > > 		FactorOrientations
 Convenience label for a grouping of factor orientations.

Public Member Functions

 SharedParameters (const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE=false)
 Constructor.
 SharedParameters (std::istream &is, const FactorGraph &fg)
 Construct a SharedParameters object from an input stream is and a factor graph fg.
 SharedParameters (const SharedParameters &sp)
 Copy constructor.
 ~SharedParameters ()
 Destructor.
void collectSufficientStatistics (InfAlg &alg)
 Collect the sufficient statistics from expected values (beliefs) according to alg.
void setParameters (FactorGraph &fg)
 Estimate and set the shared parameters.

Private Member Functions

void setPermsAndVarSetsFromVarOrders ()
 Initializes _varsets and _perms from _varorders and checks whether their state spaces correspond with _estimation.probSize().

Static Private Member Functions

static Permute calculatePermutation (const std::vector< Var > &varOrder, VarSet &outVS)
 Calculates the permutation that permutes the canonical ordering into the desired ordering.

Private Attributes

std::map< FactorIndex, VarSet > _varsets
 Maps factor indices to the corresponding VarSets.
std::map< FactorIndex, Permute > _perms
 Maps factor indices to the corresponding Permute objects that permute the canonical ordering into the desired ordering.
FactorOrientations _varorders
 Maps factor indices to the corresponding desired variable orderings.
ParameterEstimation * _estimation
 Parameter estimation method to be used.
bool _ownEstimation
 Indicates whether *this gets ownership of _estimation.

Detailed Description

Represents a single factor or set of factors whose parameters should be estimated.

To ensure that parameters can be shared between different factors during EM learning, each factor's values are reordered to match a desired variable ordering. The ordering of the variables in a factor may therefore differ from the canonical ordering used in libDAI. The SharedParameters class combines one or more factors (together with the specified orderings of the variables) with a ParameterEstimation object, taking care of the necessary permutations of the factor entries / parameters.

Author:
Charles Vaske

Member Typedef Documentation

typedef size_t dai::SharedParameters::FactorIndex

Convenience label for an index of a factor in a FactorGraph.

typedef std::map<FactorIndex, std::vector<Var> > dai::SharedParameters::FactorOrientations

Convenience label for a grouping of factor orientations.

Constructor & Destructor Documentation

dai::SharedParameters::SharedParameters ( const FactorOrientations &  varorders,
ParameterEstimation *  estimation,
bool  ownPE = false 
)

Constructor.

Parameters:
varorders all the factor orientations for this parameter
estimation a pointer to the parameter estimation method
ownPE whether the constructed object gets ownership of estimation

dai::SharedParameters::SharedParameters ( std::istream &  is,
const FactorGraph &  fg 
)

Construct a SharedParameters object from an input stream is and a factor graph fg.

See also:
Shared parameters block format
Exceptions:
INVALID_EMALG_FILE if the input stream is not valid

dai::SharedParameters::SharedParameters ( const SharedParameters &  sp  )  [inline]

Copy constructor.

dai::SharedParameters::~SharedParameters (  )  [inline]

Destructor.

Member Function Documentation

Permute dai::SharedParameters::calculatePermutation ( const std::vector< Var > &  varOrder,
VarSet &  outVS 
) [static, private]

Calculates the permutation that permutes the canonical ordering into the desired ordering.

Parameters:
varOrder Desired ordering of variables
outVS Contains variables in varOrder represented as a VarSet
Returns:
Permute object for permuting variables in varOrder from the canonical libDAI ordering into the desired ordering

void dai::SharedParameters::setPermsAndVarSetsFromVarOrders (  )  [private]

Initializes _varsets and _perms from _varorders and checks whether their state spaces correspond with _estimation.probSize().

void dai::SharedParameters::collectSufficientStatistics ( InfAlg &  alg  ) 

Collect the sufficient statistics from expected values (beliefs) according to alg.

For each of the relevant factors (that shares the parameters we are interested in), the corresponding belief according to alg is obtained and its entries are permuted such that their ordering corresponds with the shared parameters that we are estimating. Then, the parameter estimation subclass method addSufficientStatistics() is called with this vector of expected values of the parameters as input.

void dai::SharedParameters::setParameters ( FactorGraph &  fg  ) 

Estimate and set the shared parameters.

Based on the sufficient statistics collected so far, the shared parameters are estimated using the parameter estimation subclass method estimate(). Then, each of the relevant factors in fg (that shares the parameters we are interested in) is set according to those parameters (permuting the parameters accordingly).

Member Data Documentation

std::map<FactorIndex, VarSet> dai::SharedParameters::_varsets [private]

Maps factor indices to the corresponding VarSets.

std::map<FactorIndex, Permute> dai::SharedParameters::_perms [private]

Maps factor indices to the corresponding Permute objects that permute the canonical ordering into the desired ordering.

FactorOrientations dai::SharedParameters::_varorders [private]

Maps factor indices to the corresponding desired variable orderings.

ParameterEstimation* dai::SharedParameters::_estimation [private]

Parameter estimation method to be used.

bool dai::SharedParameters::_ownEstimation [private]

Indicates whether *this gets ownership of _estimation.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1TreeEP_1_1TreeEPSubTree-members.html0000644000263000017630000001551511433220721024000 0ustar jorismkyb libDAI: Member List

dai::TreeEP::TreeEPSubTree Member List

This is the complete list of members for dai::TreeEP::TreeEPSubTree, including all inherited members.

_adai::TreeEP::TreeEPSubTree [private]
_bdai::TreeEP::TreeEPSubTree [private]
_Idai::TreeEP::TreeEPSubTree [private]
_logZdai::TreeEP::TreeEPSubTree [private]
_nsdai::TreeEP::TreeEPSubTree [private]
_nsremdai::TreeEP::TreeEPSubTree [private]
_Qadai::TreeEP::TreeEPSubTree [private]
_Qbdai::TreeEP::TreeEPSubTree [private]
_RTreedai::TreeEP::TreeEPSubTree [private]
HUGIN_with_I(std::vector< Factor > &Qa, std::vector< Factor > &Qb)dai::TreeEP::TreeEPSubTree
I()dai::TreeEP::TreeEPSubTree [inline]
init()dai::TreeEP::TreeEPSubTree
InvertAndMultiply(const std::vector< Factor > &Qa, const std::vector< Factor > &Qb)dai::TreeEP::TreeEPSubTree
logZ(const std::vector< Factor > &Qa, const std::vector< Factor > &Qb) const dai::TreeEP::TreeEPSubTree
operator=(const TreeEPSubTree &x)dai::TreeEP::TreeEPSubTree [inline]
TreeEPSubTree()dai::TreeEP::TreeEPSubTree [inline]
TreeEPSubTree(const TreeEPSubTree &x)dai::TreeEP::TreeEPSubTree [inline]
TreeEPSubTree(const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector< Factor > &jt_Qa, const std::vector< Factor > &jt_Qb, const Factor *I)dai::TreeEP::TreeEPSubTree

Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_92.png0000644000263000017630000000031211433220721015143 0ustar jorismkyb‰PNG  IHDR Olú×0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfHIDAT™c`@€Œ†Œ&ƒý3ƒ´ˆÁ¶‹,%bÏ` f$ð$€l †¯`“Ã|ƒSA,3k+’ñ l Çe:ÑçIEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1fo__inv.html0000644000263000017630000000707711433220721020067 0ustar jorismkyb libDAI: dai::fo_inv< T > Struct Template Reference

dai::fo_inv< T > Struct Template Reference

Function object that takes the inverse. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns 1 / x.

Detailed Description

template<typename T>
struct dai::fo_inv< T >

Function object that takes the inverse.

Member Function Documentation

template<typename T>
T dai::fo_inv< T >::operator() ( const T &  x  )  const [inline]

Returns 1 / x.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/build.html0000644000263000017630000002241611433220721015156 0ustar jorismkyb libDAI: Building libDAI

Building libDAI

Building libDAI under UNIX variants (Linux / Cygwin / Mac OS X)

Preparations

You need:
  • a recent version of gcc (at least version 3.4)
  • GNU make
  • recent boost C++ libraries (at least version 1.37; however, version 1.37 shipped with Ubuntu 9.04 is known not to work)
  • doxygen (only for building the documentation)
  • graphviz (only for using some of the libDAI command line utilities)
  • CImg library (only for building the image segmentation example)

On Debian/Ubuntu, you can easily install the required packages with a single command: 

  apt-get install g++ make doxygen graphviz libboost-dev libboost-graph-dev libboost-program-options-dev libboost-test-dev cimg-dev
(root permissions needed).

On Mac OS X (10.4 is known to work), these packages can be installed easily via MacPorts. If MacPorts is not already installed, install it according to the instructions at http://www.macports.org/. Then, a simple 

  sudo port install gmake boost doxygen graphviz
should be enough to install everything that is needed.

On Cygwin, the prebuilt Cygwin package boost-1.33.1-x is known not to work. You can however obtain the latest boost version (you need at least 1.37.0) from http://www.boost.org/ and build it as described in the next subsection.

Building boost under Cygwin

  • Download the latest boost libraries from http://www.boost.org
  • Build the required boost libraries using: 
        ./bootstrap.sh --with-libraries=program_options,math,graph,test --prefix=/boost_root/
    ./bjam
  • In order to use dynamic linking, the boost .dll's should be somewhere in the path. This can be achieved by a command like: 
        export PATH=$PATH:/boost_root/stage/lib

Building libDAI

To build the libDAI source, first copy a template Makefile.* to Makefile.conf (for example, copy Makefile.LINUX to Makefile.conf if you use GNU/Linux). Then, edit the Makefile.conf template to adapt it to your local setup. In case you want to use Boost libraries which are installed in non-standard locations, you have to tell the compiler and linker about their locations (using the -I, -L flags for GCC; also you may need to set the LD_LIBRARY_PATH environment variable correctly before running libDAI binaries). Platform independent build options can be set in Makefile.ALL. Finally, run 
  make
The build includes a regression test, which may take a while to complete.

If the build is successful, you can test the example program: 

  examples/example tests/alarm.fg
or the more extensive test program: 
  tests/testdai --aliases tests/aliases.conf --filename tests/alarm.fg --methods JTREE_HUGIN BP_SEQMAX

Building libDAI under Windows

Preparations

You need:
  • A recent version of MicroSoft Visual Studio (2008 is known to work)
  • recent boost C++ libraries (version 1.37 or higher)
  • GNU make (can be obtained from http://gnuwin32.sourceforge.net)
  • CImg library (only for building the image segmentation example)

For the regression test, you need:

Building boost under Windows

Because building boost under Windows is tricky, I provide some guidance here.

  • Download the boost zip file from http://www.boost.org/users/download and unpack it somewhere.
  • Download the bjam executable from http://www.boost.org/users/download and unpack it somewhere else.
  • Download Boost.Build (v2) from http://www.boost.org/docs/tools/build/index.html and unpack it yet somewhere else.
  • Edit the file boost-build.jam in the main boost directory to change the BOOST_BUILD directory to the place where you put Boost.Build (use UNIX / instead of Windows \ in pathnames).
  • Copy the bjam.exe executable into the main boost directory. Now if you issue "bjam --version" you should get a version and no errors. Issueing "bjam --show-libraries" will show the libraries that will be built.
  • The following command builds the boost libraries that are relevant for libDAI: 
        bjam --with-graph --with-math --with-program_options --with-test link=static runtime-link=shared

Building libDAI

To build the source, copy Makefile.WINDOWS to Makefile.conf. Then, edit Makefile.conf to adapt it to your local setup. Platform independent build options can be set in Makefile.ALL. Finally, run (from the command line) 
  make
The build includes a regression test, which may take a while to complete.

If the build is successful, you can test the example program: 

  examples\example tests\alarm.fg
or the more extensive test program: 
  tests\testdai --aliases tests\aliases.conf --filename tests\alarm.fg --methods JTREE_HUGIN BP_SEQMAX

Building the libDAI MatLab interface

You need:
  • MatLab
  • The platform-dependent requirements described above

First, you need to build the libDAI source as described above for your platform. By default, the MatLab interface is disabled, so before compiling the source, you have to enable it in Makefile.ALL by setting 

  WITH_MATLAB=true
Also, you have to configure the MatLab-specific parts of Makefile.conf to match your system (in particular, the Makefile variables ME, MATLABDIR and MEX). The MEX file extension depends on your platform; for a 64-bit linux x86_64 system this would be "ME=.mexa64", for a 32-bit linux x86 system "ME=.mexglx". If you are unsure about your MEX file extension: it needs to be the same as what the MatLab command "mexext" returns. The required MEX files are built by issuing 
  make
from the command line. The MatLab interface is much less powerful than using libDAI from C++. There are two reasons for this: (i) it is boring to write MEX files; (ii) the large performance penalty paid when large data structures (like factor graphs) have to be converted between their native C++ data structure to something that MatLab understands.

A simple example of how to use the MatLab interface is the following (entered at the MatLab prompt), which performs exact inference by the junction tree algorithm and approximate inference by belief propagation on the ALARM network: 

  cd path_to_libdai/matlab
  [psi] = dai_readfg ('../tests/alarm.fg');
  [logZ,q,md,qv,qf] = dai (psi, 'JTREE', '[updates=HUGIN,verbose=0]')
  [logZ,q,md,qv,qf] = dai (psi, 'BP', '[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0]')
where "path_to_libdai" has to be replaced with the directory in which libDAI was installed. For other algorithms and some default parameters, see the file tests/aliases.conf.

Building the documentation

Install doxygen, graphviz and a TeX distribution and use 
  make doc
to build the documentation. If the documentation is not clear enough, feel free to send me an email (or even better, to improve the documentation and send a patch!). The documentation can also be browsed online at http://www.libdai.org.
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1DecMAP-members.html0000644000263000017630000002473311433220721020710 0ustar jorismkyb libDAI: Member List

dai::DecMAP Member List

This is the complete list of members for dai::DecMAP, including all inherited members.

_itersdai::DecMAP [private]
_logpdai::DecMAP [private]
_maxdiffdai::DecMAP [private]
_statedai::DecMAP [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::DecMAP [inline, virtual]
belief(const VarSet &) const dai::DecMAP [virtual]
beliefF(size_t I) const dai::DecMAP [inline, virtual]
beliefs() const dai::DecMAP [virtual]
beliefV(size_t i) const dai::DecMAP [virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::DecMAP [inline, virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
DecMAP()dai::DecMAP [inline]
DecMAP(const FactorGraph &fg, const PropertySet &opts)dai::DecMAP
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::DecMAP [inline, virtual]
getProperties() const dai::DecMAP [virtual]
identify() const dai::DecMAP [virtual]
init()dai::DecMAP [inline, virtual]
init(const VarSet &)dai::DecMAP [inline, virtual]
Iterations() const dai::DecMAP [inline, virtual]
logZ() const dai::DecMAP [inline, virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::DecMAP [inline, virtual]
Namedai::DecMAP [static]
printProperties() const dai::DecMAP [virtual]
props (defined in dai::DecMAP)dai::DecMAP
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::DecMAP [virtual]
setMaxIter(size_t)dai::InfAlg [inline, virtual]
setProperties(const PropertySet &opts)dai::DecMAP [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_56.png0000644000263000017630000000047711433220721015157 0ustar jorismkyb‰PNG  IHDRTˆ õÆ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf½IDAT(‘c` `ž€M”µ‹àŒX»`3›RR¶ ¯L¥è¢`¥ üšÌ@še&À”‚DU€Z@¢0¥ü þè¦EYZÑLeða`à*e4¸[}€ž¶b``‰Â”Lg+eJˆRvˆ(Ãb ³@¢P¥ÌŸ¦‹‚•Â@÷{°(g"°ú~Igf¥‚‚ Œ`Ñ©¬(¢à„ˆ%¬ÿž0,„•àZY.†²QqIEND®B`‚libDAI-0.2.7/doc/html/form_20.png0000644000263000017630000000127211433220721015140 0ustar jorismkyb‰PNG  IHDR|$¹íC0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf8IDATH‰Õ”¿kaÇ¿¹ùe/ Šƒ(4N:éÕ‚A*(ºè‹•ºXpêT‡àâIQ¹tðÀ)çPuÊ’ŽW)‚¸¤E…ˆŸçÍß\¯©¹ààî¹÷Þ÷ýÜó}ÿJjs*üxcºôÿüf¿ç8›ý/Q³—»´ ýCú9˜aøBWrþ[ÄB½n"‘çâU™>ñÑÞ‡W™<ãwˆ­rŒïýŒk¢"æKÂãÏKÝaË2‡´‹Gh‰o}uZr:btÁi'£Ñ|ÄRËs—ïGÄY+µü%_žó%í÷LIEND®B`‚libDAI-0.2.7/doc/html/bbp_8h.html0000644000263000017630000001124511433220721015217 0ustar jorismkyb libDAI: include/dai/bbp.h File Reference

include/dai/bbp.h File Reference

Defines class BBP, which implements Back-Belief-Propagation. More...

#include <vector>
#include <utility>
#include <dai/prob.h>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/enum.h>
#include <dai/bp_dual.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::BBPCostFunction
 Predefined cost functions that can be used with BBP. More...
class  dai::BBP
 Implements BBP (Back-Belief-Propagation) [EaG09]. More...
struct  dai::BBP::Properties
 Parameters for BBP. More...

Functions

 dai::DAI_ENUM (BBPCostFunctionBase, CFN_GIBBS_B, CFN_GIBBS_B2, CFN_GIBBS_EXP, CFN_GIBBS_B_FACTOR, CFN_GIBBS_B2_FACTOR, CFN_GIBBS_EXP_FACTOR, CFN_VAR_ENT, CFN_FACTOR_ENT, CFN_BETHE_ENT)
 Enumeration of several cost functions that can be used with BBP.

Detailed Description

Defines class BBP, which implements Back-Belief-Propagation.

Todo:
Clean up code
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_enum.html0000644000263000017630000000405611433220721017113 0ustar jorismkyb libDAI: Class Members - Enumerations
 

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_51.png0000644000263000017630000000030211433220721015135 0ustar jorismkyb‰PNG  IHDR RiÊo0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf@IDAT™c`À,)æ`†¿Í0#€Ÿéß;Ë–YÀ H+t030:0008ÆÆÀ’)as`à†Á‡džªR#0ÏXIEND®B`‚libDAI-0.2.7/doc/html/form_53.png0000644000263000017630000000414411433220721015147 0ustar jorismkyb‰PNG  IHDRÓZMѵ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfâIDAThíš]lUÇÏìÌìnK—(Q"à®iP¬àn1aW%"±$¤ ŒP’ k„€D¾¢@ ÑրƖ(«X>0BL¬hÄQ”ø‚ÆlåÃXêÙsïÌÞÙÝ Yšžd'={g~½sçžÿ=çÎÜ1{¬¿€ÿ`¤ÖO€œê'@´Dµy5¢Šš Bj 2T¾dÞ™Õ–#_xÎò–~}8 þªùsò(MLMH®Q›Ç‡¬KBž)fÒËÍÍ™Vô4Šuj¦ÏBb³”Sþ¤2<åíF]èh¦£¨p°Ét„<(´eJ$á}> y½ÈY°2 ¨ó²½;ÁÆXàûDíÓ€{ñH{l¢<Î|Ü FÓ]®iþ¾H ü =âµJ¿ÙÿÊò㱇¦lËx7&ß|ẽ‘FùJ' eÒáê«ž_6'§µXƒhÜÅ yô a>˜c` *àSt«}9>Ü"-PŒÝ>À¿åg}N_^$€ayÚÛN_²Ù1x<Ži&nš£ Bä ³×ËmS‘×éOXNy|'T„Žx[Ù¾+!%–u<)Mô°àX F¼ÑVmYÇ—‚ëVÓH³3€³uDÕ@2ëøSpÓjjEC€‹äÜÛ náu q÷[P"ŠõEj£ô n"ƒ±|[' ï„×ê ‰5aÀµÓßã©ŸŒ-Ðã…›ã ,qiÅ2àn%¬ †ÃÓaCH_L«˜ë¥V y<=]I¦yEß1¶ÖÒꢒp‚2»bW®@¥€Üp†gˆWþÔñâp^?,q¹…Üz0ÞЗÎ({ÀÕƒKðD¢PÏ\/D÷ §+…þ¿úð¬hDO¤v¢BK ¶’¦» ´¼‰<ßlܶ6r‡þT©Óu ¨­ÈûYFá5`Àzá¦>•k@4N-mzòmʬcÀe]Pe @&«cÖñSÁÔJS¼ 0ôú|`íuëO—p&pá²MÒDT¤ðCâzz‹T£¿½)]¶L[“¹;°|ÖCÑOB´ÆÀ“òP¢ð…|žÄ2Œ´ûúr}Ê}‰·0`_¯/5fY'† Cž8·M a€`¤·u…ä¸+õ`€u/"GHâ&ZƧËê/˜ëË÷#oŠfV¦v!GŸ¡›¢pÉ‚›=ˆÃRrÁ¨l0zbŒ´Â”“ê`‘~ÀHɳ5€Õƒoȧ¥½7”)1ƒŒ±ò$ÀÖ1¹yM½1Ëaô€HSÛb#p,Œ@Ì~F~VòÁ4þrxzÎlz mÑÇÓ#?°ë•êrõÀÈìzÀ8åv=à40ò»Ðó»pNù]8§üÀAZ/ §F~à Ô¦OÒùÁ ”$@j?¼±xšxö¾RG’N¡ÂÒ° Z& PÔépŒ#§‡V1R/hÈÅ€zPBð¤:R°(4€‰F埄^ÛŠo8…@ú<©Øà¥F…xZê%±÷Ú¶³!×-,¡Çà§ônÀ&æzùÕɹA5=`ÀI¨–º•Ø@êä­º…R6qÏ0ê¤|¥|Ú'r50 ýZ¡ˆr¡äƒi :ñ>ÒÃsÐcòd¦½ è8@b×WÌõq¼WÝ#^±)LñïôÄö õ‚f]’‚¿©6 Xlœa¬ñØ8»û àûYzÜz~/p ‘ãäm@[þ€‹FŠ/0€ °âKæA—˜k“´¡ñ´j&ôPïui@KÝ«‰*Ò&|¸yµS,xžÄßi¢eí_23è3æîÌûÆ­äƒéî°ÏI˜‹‹wžù=ÑôLÓÇÓ#?/7Wæê‘@ÀF#?p©¸#?ùé>`äU|WŒüàe~½ÀÕ#?°?Fiÿ·Èãé‘Àœ[lhãéA1©(Ú…Õ <=×µY5„et½ÀÓƒé°Ñª!,£ê®t襂YCXFÕ .«3YWÍ ªŠàz¡(®\òƒ¨UCXFÕ \=¨‡ÝR·YCXF× Üü`-ѳ†Èi<=²‡­Ôƒi ¨zÞ? õ@Ô_Ê¹Õ Ôþ£²þÎÛ¥^`.z*;.õ‚;À¥^ÈÀ¯òðëw€K½àp¯¨ýFÊ~•+´†¢F,„ù?'r´òN”Àöcž‚ÜŸ¹¢¶=UJp~aæ& ¼)%¶›¹^ê8„¼¦.¬PÖµGlNoe{àn¥Lw? 2o=˜¨lzàßqy<=¨6mz…s½ùf¦òYøÌI‘œïÀ>}/ÍAèðâ郓À¯ØáäsŽz€¾Ã<Žzð’ç z²“”´ #9z0¡y§“Ü×Õ…<žlì:8¨EÛýä°ÿ„ã ’RIEND®B`‚libDAI-0.2.7/doc/html/form_108.png0000644000263000017630000000030711433220721015225 0ustar jorismkyb‰PNG  IHDRíf0â0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfEIDAT™c`€fÍyBs4@h^¨8x˜¶eøÀ(¤Û>²(éË,„@â¹ã@â)>ŒºPó–Bµ¶+Àm>ƒ ¢pÈIEND®B`‚libDAI-0.2.7/doc/html/form_22.png0000644000263000017630000000047611433220721015147 0ustar jorismkyb‰PNG  IHDR(–ù ž0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf¼IDAT•c`À ÑøÁ BÊaSœõ zL „Á/$8`‚©`RDð2003€X2 ‚eÿd ÉÃÀtd%Tº˜— X1°3|Lað `àÛtŒáƒÐQô ‚Ÿ˜€Y700TÂ?0°Oš$ÕÀpj&óž EúnS € ¤Á^i`àz$ÄšÃPrõk†H¨GÔ›€"â ¨‡Øqš½^œÔIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1CBP.html0000644000263000017630000017560411433220721016637 0ustar jorismkyb libDAI: dai::CBP Class Reference

dai::CBP Class Reference

Class for CBP (Conditioned Belief Propagation) [EaG09]. More...

#include <dai/cbp.h>

Inheritance diagram for dai::CBP:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 CBP (const FactorGraph &fg, const PropertySet &opts)
 Construct CBP object from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual CBP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

struct dai::CBP::Properties props

Static Public Attributes

static const char * Name = "CBP"
 Name of this inference algorithm.

Private Member Functions

void printDebugInfo ()
 Prints beliefs, variables and partition sum, in case of a debugging build.
void runRecurse (InfAlg *bp, Real orig_logZ, std::vector< size_t > clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, std::vector< Factor > &beliefs_out)
 Called by run(), and by itself. Implements the main algorithm.
virtual bool chooseNextClampVar (InfAlg *bp, std::vector< size_t > &clamped_vars_list, size_t &i, std::vector< size_t > &xis, Real *maxVarOut)
 Choose the next variable to clamp.
InfAlg * getInfAlg ()
 Return the InfAlg to use at each step of the recursion.
void setBeliefs (const std::vector< Factor > &bs, Real logZ)
 Sets variable beliefs, factor beliefs and log partition sum to the specified values.
void construct ()
 Constructor helper function.

Private Attributes

std::vector< Factor > _beliefsV
 Variable beliefs.
std::vector< Factor > _beliefsF
 Factor beliefs.
Real _logZ
 Logarithm of partition sum.
size_t _iters
 Numer of iterations needed.
Real _maxdiff
 Maximum difference encountered so far.
Real _sum_level
 Number of clampings at each leaf node.
size_t _num_leaves
 Number of leaves of recursion tree.
boost::shared_ptr< std::ofstream > _clamp_ofstream
 Output stream where information about the clampings is written.

Related Functions

(Note that these are not member functions.)

std::pair< size_t, size_t > BBPFindClampVar (const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut)
 Find the best variable/factor to clamp using BBP.

Classes

struct  Properties
 Parameters for CBP. More...

Detailed Description

Class for CBP (Conditioned Belief Propagation) [EaG09].

This approximate inference algorithm uses configurable heuristics to choose a variable $ x_i $ and a state $ x_i^* $. Inference is done with $ x_i $ "clamped" to $ x_i^* $ (i.e., conditional on $ x_i = x_i^* $), and also with the negation of this condition. Clamping is done recursively up to a fixed number of levels (other stopping criteria are also implemented, see the CBP::Properties::RecurseType property). The resulting approximate marginals are combined using estimates of the partition sum.

Author:
Frederik Eaton

Constructor & Destructor Documentation

dai::CBP::CBP ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct CBP object from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties

Member Function Documentation

virtual CBP* dai::CBP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

virtual std::string dai::CBP::identify (  )  const [inline, virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::CBP::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual Factor dai::CBP::belief ( const VarSet &  vs  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

virtual Factor dai::CBP::beliefV ( size_t  i  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual Factor dai::CBP::beliefF ( size_t  I  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual std::vector<Factor> dai::CBP::beliefs (  )  const [inline, virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::CBP::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual void dai::CBP::init (  )  [inline, virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::CBP::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::CBP::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::CBP::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::CBP::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::CBP::setMaxIter ( size_t   )  [inline, virtual]

Sets maximum number of iterations (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::CBP::setProperties ( const PropertySet &  opts  )  [inline, virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

virtual PropertySet dai::CBP::getProperties (  )  const [inline, virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

virtual std::string dai::CBP::printProperties (  )  const [inline, virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

void dai::CBP::printDebugInfo (  )  [private]

Prints beliefs, variables and partition sum, in case of a debugging build.

void dai::CBP::runRecurse ( InfAlg *  bp,
Real  orig_logZ,
std::vector< size_t >  clamped_vars_list,
size_t &  num_leaves,
size_t &  choose_count,
Real &  sum_level,
Real &  lz_out,
std::vector< Factor > &  beliefs_out 
) [private]

Called by run(), and by itself. Implements the main algorithm.

Chooses a variable to clamp, recurses, combines the partition sum and belief estimates of the children, and returns the improved estimates in lz_out and beliefs_out to its parent.

Idea:
dai::CBP::runRecurse() could be implemented more efficiently with a nesting version of backupFactors/restoreFactors

bool dai::CBP::chooseNextClampVar ( InfAlg *  bp,
std::vector< size_t > &  clamped_vars_list,
size_t &  i,
std::vector< size_t > &  xis,
Real *  maxVarOut 
) [private, virtual]

Choose the next variable to clamp.

Choose the next variable to clamp, given a converged InfAlg bp, and a vector of variables that are already clamped (clamped_vars_list). Returns the chosen variable in i, and the set of states in xis. If maxVarOut is non-NULL and props.choose == CHOOSE_BBP then it is used to store the adjoint of the chosen variable.

InfAlg * dai::CBP::getInfAlg (  )  [private]

Return the InfAlg to use at each step of the recursion.

Todo:
At present, CBP::getInfAlg() only returns a BP instance; it should be possible to select other inference algorithms via a property

void dai::CBP::setBeliefs ( const std::vector< Factor > &  bs,
Real  logZ 
) [private]

Sets variable beliefs, factor beliefs and log partition sum to the specified values.

Parameters:
bs should be a concatenation of the variable beliefs followed by the factor beliefs
logZ log partition sum

void dai::CBP::construct (  )  [private]

Constructor helper function.

Friends And Related Function Documentation

std::pair< size_t, size_t > BBPFindClampVar ( const InfAlg &  in_bp,
bool  clampingVar,
const PropertySet &  bbp_props,
const BBPCostFunction &  cfn,
Real *  maxVarOut 
) [related]

Find the best variable/factor to clamp using BBP.

Takes a converged inference algorithm as input, runs Gibbs and BP_dual, creates and runs a BBP object, finds the best variable/factor (the one with the maximum factor adjoint), and returns the corresponding (index,state) pair.

Parameters:
in_bp inference algorithm (compatible with BP) that should have converged;
clampingVar if true, finds best variable, otherwise, finds best factor;
bbp_props BBP parameters to use;
cfn BBP cost function to use;
maxVarOut maximum adjoint value (only set if not NULL).
See also:
BBP

Member Data Documentation

std::vector<Factor> dai::CBP::_beliefsV [private]

Variable beliefs.

std::vector<Factor> dai::CBP::_beliefsF [private]

Factor beliefs.

Real dai::CBP::_logZ [private]

Logarithm of partition sum.

size_t dai::CBP::_iters [private]

Numer of iterations needed.

Real dai::CBP::_maxdiff [private]

Maximum difference encountered so far.

Real dai::CBP::_sum_level [private]

Number of clampings at each leaf node.

size_t dai::CBP::_num_leaves [private]

Number of leaves of recursion tree.

boost::shared_ptr<std::ofstream> dai::CBP::_clamp_ofstream [private]

Output stream where information about the clampings is written.

const char * dai::CBP::Name = "CBP" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
  • include/dai/cbp.h
  • src/cbp.cpp
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1InfAlg.html0000644000263000017630000021100311433220721017353 0ustar jorismkyb libDAI: dai::InfAlg Class Reference

dai::InfAlg Class Reference

InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI. More...

#include <dai/daialg.h>

Inheritance diagram for dai::InfAlg:

dai::DAIAlg< GRM > dai::DAIAlg< dai::FactorGraph > dai::DAIAlg< dai::RegionGraph > dai::BP dai::CBP dai::DecMAP dai::ExactInf dai::Gibbs dai::HAK dai::JTree dai::LC dai::MF dai::MR

List of all members.

Public Member Functions

Constructors/destructors
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions).
virtual InfAlg * clone () const =0
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
Queries
virtual std::string identify () const =0
 Identifies itself for logging purposes.
virtual FactorGraph & fg ()=0
 Returns reference to underlying FactorGraph.
virtual const FactorGraph & fg () const =0
 Returns constant reference to underlying FactorGraph.
Inference interface
virtual void init ()=0
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &vs)=0
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()=0
 Runs the approximate inference algorithm.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const =0
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const =0
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const =0
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual std::vector< std::size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setMaxIter (size_t)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph).
Changing the factor graph
virtual void clamp (size_t i, size_t x, bool backup=false)=0
 Clamp variable with index i to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).
virtual void makeCavity (size_t i, bool backup=false)=0
 Sets all factors interacting with variable with index i to one.
Backup/restore mechanism for factors
virtual void backupFactor (size_t I)=0
 Make a backup copy of factor I.
virtual void backupFactors (const VarSet &vs)=0
 Make backup copies of all factors involving the variables in vs.
virtual void restoreFactor (size_t I)=0
 Restore factor I from its backup copy.
virtual void restoreFactors (const VarSet &vs)=0
 Restore the factors involving the variables in vs from their backup copies.
Managing parameters
virtual void setProperties (const PropertySet &opts)=0
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const =0
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const =0
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Detailed Description

InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI.

Idea:
General marginalization functions like calcMarginal() now copy a complete InfAlg object. Instead, it would make more sense that they construct a new object without copying the FactorGraph or RegionGraph. Or they can simply be made methods of the general InfAlg class.
Idea:
Use a PropertySet as output of an InfAlg, instead of functions like maxDiff() and Iterations().
Examples:

example_imagesegmentation.cpp, example_sprinkler_em.cpp, and uai2010-aie-solver.cpp.

Constructor & Destructor Documentation

virtual dai::InfAlg::~InfAlg (  )  [inline, virtual]

Virtual destructor (needed because this class contains virtual functions).

Member Function Documentation

virtual InfAlg* dai::InfAlg::clone (  )  const [pure virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::FBP, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, dai::TreeEP, and dai::TRWBP.

virtual std::string dai::InfAlg::identify (  )  const [pure virtual]

Identifies itself for logging purposes.

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::FBP, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, dai::TreeEP, and dai::TRWBP.

virtual FactorGraph& dai::InfAlg::fg (  )  [pure virtual]

Returns reference to underlying FactorGraph.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

Examples:
example_sprinkler_em.cpp.

virtual const FactorGraph& dai::InfAlg::fg (  )  const [pure virtual]

Returns constant reference to underlying FactorGraph.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::init (  )  [pure virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

Examples:
example_imagesegmentation.cpp, example_sprinkler_em.cpp, and uai2010-aie-solver.cpp.

virtual void dai::InfAlg::init ( const VarSet &  vs  )  [pure virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

virtual Real dai::InfAlg::run (  )  [pure virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

Examples:
example_imagesegmentation.cpp, and uai2010-aie-solver.cpp.

virtual Factor dai::InfAlg::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::LC, dai::MF, and dai::MR.

virtual Factor dai::InfAlg::belief ( const VarSet &  vs  )  const [pure virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, and dai::MR.

virtual Factor dai::InfAlg::beliefV ( size_t  i  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::LC, dai::MF, and dai::MR.

Examples:
example_imagesegmentation.cpp, and uai2010-aie-solver.cpp.

virtual Factor dai::InfAlg::beliefF ( size_t  I  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, and dai::Gibbs.

Examples:
example.cpp.

virtual std::vector<Factor> dai::InfAlg::beliefs (  )  const [pure virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, and dai::MR.

Examples:
uai2010-aie-solver.cpp.

virtual Real dai::InfAlg::logZ (  )  const [pure virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::FBP, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, dai::TreeEP, and dai::TRWBP.

Examples:
uai2010-aie-solver.cpp.

virtual std::vector<std::size_t> dai::InfAlg::findMaximum (  )  const [inline, virtual]

Calculates the joint state of all variables that has maximum probability.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented in dai::BP, dai::DecMAP, dai::ExactInf, dai::Gibbs, and dai::JTree.

Examples:
uai2010-aie-solver.cpp.

virtual Real dai::InfAlg::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

Examples:
uai2010-aie-solver.cpp.

virtual size_t dai::InfAlg::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, and dai::TreeEP.

Examples:
uai2010-aie-solver.cpp.

virtual void dai::InfAlg::setMaxIter ( size_t   )  [inline, virtual]

Sets maximum number of iterations (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented in dai::BP, dai::CBP, dai::Gibbs, dai::HAK, dai::LC, dai::MF, and dai::TreeEP.

Examples:
example_imagesegmentation.cpp.

virtual void dai::InfAlg::clamp ( size_t  i,
size_t  x,
bool  backup = false 
) [pure virtual]

Clamp variable with index i to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).

If backup == true, make a backup of all factors that are changed.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::makeCavity ( size_t  i,
bool  backup = false 
) [pure virtual]

Sets all factors interacting with variable with index i to one.

If backup == true, make a backup of all factors that are changed.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::backupFactor ( size_t  I  )  [pure virtual]

Make a backup copy of factor I.

Exceptions:
MULTIPLE_UNDO if a backup already exists

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::backupFactors ( const VarSet &  vs  )  [pure virtual]

Make backup copies of all factors involving the variables in vs.

Exceptions:
MULTIPLE_UNDO if a backup already exists

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::restoreFactor ( size_t  I  )  [pure virtual]

Restore factor I from its backup copy.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::restoreFactors ( const VarSet &  vs  )  [pure virtual]

Restore the factors involving the variables in vs from their backup copies.

Implemented in dai::DAIAlg< GRM >, dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

virtual void dai::InfAlg::setProperties ( const PropertySet &  opts  )  [pure virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, dai::TreeEP, and dai::TRWBP.

virtual PropertySet dai::InfAlg::getProperties (  )  const [pure virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, dai::TreeEP, and dai::TRWBP.

virtual std::string dai::InfAlg::printProperties (  )  const [pure virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implemented in dai::BP, dai::CBP, dai::DecMAP, dai::ExactInf, dai::Gibbs, dai::HAK, dai::JTree, dai::LC, dai::MF, dai::MR, dai::TreeEP, and dai::TRWBP.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x7a.html0000644000263000017630000001033211433220721017733 0ustar jorismkyb libDAI: Class Members - Functions
 

- z -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/mf_8h.html0000644000263000017630000000607711433220721015065 0ustar jorismkyb libDAI: include/dai/mf.h File Reference

include/dai/mf.h File Reference

Defines class MF which implements the Mean Field algorithm. More...

#include <string>
#include <dai/enum.h>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::MF
 Approximate inference algorithm "Mean Field". More...
struct  dai::MF::Properties
 Parameters for MF. More...

Detailed Description

Defines class MF which implements the Mean Field algorithm.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1HAK_1_1Properties-members.html0000644000263000017630000001033511433220721023207 0ustar jorismkyb libDAI: Member List

dai::HAK::Properties Member List

This is the complete list of members for dai::HAK::Properties, including all inherited members.

clustersdai::HAK::Properties
DAI_ENUM(ClustersType, MIN, BETHE, DELTA, LOOP)dai::HAK::Properties
DAI_ENUM(InitType, UNIFORM, RANDOM)dai::HAK::Properties
dampingdai::HAK::Properties
doubleloopdai::HAK::Properties
initdai::HAK::Properties
loopdepthdai::HAK::Properties
maxiterdai::HAK::Properties
maxtimedai::HAK::Properties
toldai::HAK::Properties
verbosedai::HAK::Properties

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars.html0000644000263000017630000004442111433220721017122 0ustar jorismkyb libDAI: Class Members - Variables
 

- _ -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/fbp_8h.html0000644000263000017630000000542411433220721015225 0ustar jorismkyb libDAI: include/dai/fbp.h File Reference

include/dai/fbp.h File Reference

Defines class FBP, which implements Fractional Belief Propagation. More...

#include <string>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>
#include <dai/enum.h>
#include <dai/bp.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::FBP
 Approximate inference algorithm "Fractional Belief Propagation" [WiH03]. More...

Detailed Description

Defines class FBP, which implements Fractional Belief Propagation.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x62.html0000644000263000017630000001015511433220721017676 0ustar jorismkyb libDAI: Class Members - Variables
 

- b -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_72.png0000644000263000017630000000050611433220721015146 0ustar jorismkyb‰PNG  IHDRF«W¤0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÄIDAT(‘c` `bÖüj8»TÃÀRÖá•2›‹CM¿f3X(¡GÁU(5sæÌé j«1àg`ðÊ00 LgàbÜ€Í^°Ø#†‹ ÌÆ@€¢¦`: H3‹ÁV& 9¬iii)Èj˜?M©9ËÀÓzÁ‰AaGG_Gcß Ó™Ù¤†•1@hŒ\ £   ƒ  ”ëT¼ÿà /æe—2+ð1°*\3g0b`^RÀÏàÃÀ𢓉H~d`P€Èò3Ø1,e`z’3:(Ëø%"«ÇÐÉð¡€ì3&; ½ÜªŒ•0°ƒìÍd8ÊpT'€mæÌ™s¬NåOÝìÀ¼äxà“ G˜À¦ð¸@ü ‘P/‡104‚hÖ†b¬!ÉñcVY$þ$è¥nK&IEND®B`‚libDAI-0.2.7/doc/html/form_35.png0000644000263000017630000000042711433220721015147 0ustar jorismkyb‰PNG  IHDR'^.ø0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf•IDAT•c`À ˜ °ð8> ÊlS¬à" \`”b``¬ ò+€ÙPŠqˆ!á)áŒ`É‘ Ë ¾HUA”¬`l°R3˜A‚ì“Á‚™𨰠ûù!€!H=„ 2°OšüXµÈa€ 2°-Tfˆ`sÔ– y‰ñß ìÁ]z$ù ôûIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1LC.html0000644000263000017630000014577611433220721016540 0ustar jorismkyb libDAI: dai::LC Class Reference

dai::LC Class Reference

Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]. More...

#include <dai/lc.h>

Inheritance diagram for dai::LC:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 LC ()
 Default constructor.
 LC (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual LC * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for LC
Real CalcCavityDist (size_t i, const std::string &name, const PropertySet &opts)
 Approximates the cavity distribution of variable i, using the inference algorithm name with parameters opts.
Real InitCavityDists (const std::string &name, const PropertySet &opts)
 Approximates all cavity distributions using inference algorithm name with parameters opts.
long SetCavityDists (std::vector< Factor > &Q)
 Sets approximate cavity distributions to Q.
Factor NewPancake (size_t i, size_t _I, bool &hasNaNs)
 Updates the belief of the Markov blanket of variable i based upon the information from its _I 'th neighboring factor.
void CalcBelief (size_t i)
 Calculates the belief of variable i.
const Factor & pancake (size_t i) const
 Returns the belief of the Markov blanket of variable i (including the variable itself).
const Factor & cavitydist (size_t i) const
 Returns the approximate cavity distribution for variable i.

Public Attributes

struct dai::LC::Properties props

Static Public Attributes

static const char * Name = "LC"
 Name of this inference algorithm.

Private Attributes

std::vector< Factor > _pancakes
 Stores for each variable the approximate cavity distribution multiplied with the omitted factors.
std::vector< Factor > _cavitydists
 Stores for each variable the approximate cavity distribution.
std::vector< std::vector
< Factor > > 		_phis
 _phis[i][_I] corresponds to $ \phi^{\setminus i}_I(x_{I \setminus i}) $ in the paper
std::vector< Factor > _beliefs
 Single variable beliefs.
Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.

Classes

struct  Properties
 Parameters for LC. More...

Detailed Description

Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07].

Constructor & Destructor Documentation

dai::LC::LC (  )  [inline]

Default constructor.

dai::LC::LC ( const FactorGraph &  fg,
const PropertySet &  opts 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties

Member Function Documentation

virtual LC* dai::LC::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::LC::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::LC::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::LC::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

virtual Factor dai::LC::beliefV ( size_t  i  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

virtual std::vector<Factor> dai::LC::beliefs (  )  const [inline, virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::LC::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::LC::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::LC::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::LC::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::LC::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::LC::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::LC::setMaxIter ( size_t   )  [inline, virtual]

Sets maximum number of iterations (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::LC::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::LC::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::LC::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Real dai::LC::CalcCavityDist ( size_t  i,
const std::string &  name,
const PropertySet &  opts 
)

Approximates the cavity distribution of variable i, using the inference algorithm name with parameters opts.

Real dai::LC::InitCavityDists ( const std::string &  name,
const PropertySet &  opts 
)

Approximates all cavity distributions using inference algorithm name with parameters opts.

long dai::LC::SetCavityDists ( std::vector< Factor > &  Q  ) 

Sets approximate cavity distributions to Q.

Factor dai::LC::NewPancake ( size_t  i,
size_t  _I,
bool &  hasNaNs 
)

Updates the belief of the Markov blanket of variable i based upon the information from its _I 'th neighboring factor.

void dai::LC::CalcBelief ( size_t  i  ) 

Calculates the belief of variable i.

const Factor& dai::LC::pancake ( size_t  i  )  const [inline]

Returns the belief of the Markov blanket of variable i (including the variable itself).

const Factor& dai::LC::cavitydist ( size_t  i  )  const [inline]

Returns the approximate cavity distribution for variable i.

Member Data Documentation

std::vector<Factor> dai::LC::_pancakes [private]

Stores for each variable the approximate cavity distribution multiplied with the omitted factors.

std::vector<Factor> dai::LC::_cavitydists [private]

Stores for each variable the approximate cavity distribution.

std::vector<std::vector<Factor> > dai::LC::_phis [private]

_phis[i][_I] corresponds to $ \phi^{\setminus i}_I(x_{I \setminus i}) $ in the paper

std::vector<Factor> dai::LC::_beliefs [private]

Single variable beliefs.

Real dai::LC::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::LC::_iters [private]

Number of iterations needed.

const char * dai::LC::Name = "LC" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
  • include/dai/lc.h
  • src/lc.cpp
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x68.html0000644000263000017630000001272411433220721016655 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- h -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/inline_dotgraph_1.dot.png0000644000263000017630000000215111433220721020044 0ustar jorismkyb‰PNG  IHDRÕµ:š§ê!PLTEþÿÿƒƒƒ¸¸¸OOO444iiižžžÓÓÓÿÿÿnnaÂtRNS@æØföIDATxœíšKsÓ0Çû%˜+‡Nó ÊfzäF®Ì0$÷àØ@™cKÒÈ'ŽQ>%vcY¯Ý•¬È ´Ò¡µõWö·zxõ°ÏöÙÒŸ³Â*¬Â*¬Â*¬Ô,>^rXõhõ…UX…u*cìñkZÞ5r0kÇšÀ²5Ê›¶H™U¬ûB±vo̹îͺžÏ¹OÑ7X‹Þ‰aû/mã(ö@R2àJ=l_©mˆA)×÷ËÚF<ôèe—Õæ :Ø« 䀅Uˆ,¾lÃÏ7ÜbH¾#×­Ð3"¤b–áìPR±S°,¹¶þcy\HË‚+ÖçÖþÜç‡ôø4\©‹¤,]3±ÀF< K“kà få|wƒ&¨b¸Ô*·QÈû/húue ëg(ÜkÝ~< ø©ûÃõp<ÿš7†ùÿ„…ÌõºìdD³œŠ9¦k;c,–HÉr~l³93ŠeW̶m?Š…-bämN]z ‹6ž¶^Èô'Å”cåæ]Â1Ÿ—…¬¥”.F9æGŒ½¹Y†ñæJ×þxkš•tmX8+íZôÑbž5¶ò¾6o­«{‡DÈÉŠÚ°´³¸ñYî69n¿ÂR‡§ Õàs€(2«%aٌȳ”(²¦I²‚¶DMÁÂãÏcDŽc9¯¿Œ—7Îë¯N.¬Â*¬Âbìfº~I°úϧR°æœoVÿùTÖ‚>?|\³ÔçSdz–÷Œ½™ýU¥cÝ>0öýSÖÏ;Æ&ò°ZS¹'ÅÊÙ†9ÇFÎ1ï{–S²ü1J~Ò4~ìMÊRéiÍ_…UX…UXÏ•óÌ!.VaÖ3eÅ¿¹üî&E*¬Â*¬Â*¬'Îú §oÀµÚU“IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1Region-members.html0000644000263000017630000003624411433220721021102 0ustar jorismkyb libDAI: Member List

dai::Region Member List

This is the complete list of members for dai::Region, including all inherited members.

_cdai::Region [private]
back()dai::SmallSet< T > [inline]
back() const dai::SmallSet< T > [inline]
begin()dai::SmallSet< T > [inline]
begin() const dai::SmallSet< T > [inline]
c() const dai::Region [inline]
c()dai::Region [inline]
const_iterator typedefdai::SmallSet< T >
const_reverse_iterator typedefdai::SmallSet< T >
contains(const T &t) const dai::SmallSet< T > [inline]
elements()dai::SmallSet< T > [inline]
elements() const dai::SmallSet< T > [inline]
empty() const dai::SmallSet< T > [inline]
end()dai::SmallSet< T > [inline]
end() const dai::SmallSet< T > [inline]
erase(const T &t)dai::SmallSet< T > [inline]
front()dai::SmallSet< T > [inline]
front() const dai::SmallSet< T > [inline]
insert(const T &t)dai::SmallSet< T > [inline]
intersects(const SmallSet &x) const dai::SmallSet< T > [inline]
iterator typedefdai::SmallSet< T >
nrStates() const dai::VarSet [inline]
operator &(const SmallSet &x) const dai::SmallSet< T > [inline]
operator &=(const SmallSet &x)dai::SmallSet< T > [inline]
operator!=(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator/(const SmallSet &x) const dai::SmallSet< T > [inline]
operator/=(const SmallSet &x)dai::SmallSet< T > [inline]
operator/=(const T &t)dai::SmallSet< T > [inline]
operator<(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator<<(std::ostream &os, const VarSet &vs)dai::VarSet [friend]
dai::SmallSet::operator<<(const SmallSet &x) const dai::SmallSet< T > [inline]
dai::SmallSet::operator<<(std::ostream &os, const SmallSet &x)dai::SmallSet< T > [friend]
operator==(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator>>(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|=(const SmallSet &x)dai::SmallSet< T > [inline]
operator|=(const T &t)dai::SmallSet< T > [inline]
rbegin()dai::SmallSet< T > [inline]
rbegin() const dai::SmallSet< T > [inline]
Region()dai::Region [inline]
Region(const VarSet &x, Real c)dai::Region [inline]
rend()dai::SmallSet< T > [inline]
rend() const dai::SmallSet< T > [inline]
reverse_iterator typedefdai::SmallSet< T >
size() const dai::SmallSet< T > [inline]
SmallSet()dai::SmallSet< T > [inline]
SmallSet(const T &t)dai::SmallSet< T > [inline]
SmallSet(const T &t1, const T &t2)dai::SmallSet< T > [inline]
SmallSet(TIterator begin, TIterator end, size_t sizeHint)dai::SmallSet< T > [inline]
VarSet()dai::VarSet [inline]
VarSet(const SmallSet< Var > &x)dai::VarSet [inline]
VarSet(const Var &v)dai::VarSet [inline]
VarSet(const Var &v1, const Var &v2)dai::VarSet [inline]
VarSet(VarIterator begin, VarIterator end, size_t sizeHint=0)dai::VarSet [inline]

Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_96.png0000644000263000017630000000032011433220721015146 0ustar jorismkyb‰PNG  IHDR]R0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfNIDAT™c`@JPšµÊà·„1 4ËþÉPVs™ˆ±œá#Xä1ã0ãëÍô+lÞ~Z¶[ ±@s+Š½ Ñ2 ËiZnBIEND®B`‚libDAI-0.2.7/doc/html/form_57.png0000644000263000017630000000031311433220721015145 0ustar jorismkyb‰PNG  IHDR RiÊo0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIIDAT™c`À,)æ`†¿Íf #€ŸqáQ-cAVè`f`YÀÀÀüáãJ H ›K‚Äææ­P³â¿ \a-ÊIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1MR.png0000644000263000017630000000104511433220721016354 0ustar jorismkyb‰PNG  IHDRˆ<)PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf»IDAThí×Arƒ0 P¼Ééò :í…ºâþG¨-ÙFn ØxÚÐF a1a’Lþô1VoÓ»*öÌ+âMà ì|Š¨ D˜:@ˆ¯j⡼@\ùÈñFON¹ ´v»… è¨î€¼\RçÜs weÐ|ökhžƒÝ‚ãU¿ þY?¨ÛÑ€–Ï'·ey2p»`€`À‹–/PYÿ£Fµ” 1ˆâÓëÿýàÂ5&~ ‹q‹ŸèUt DZΪS0#÷§CŸ#Žd¼üà D¨bZvf îÀµƒ  44)žƒÈî(€cb ‹r<¿Ã#=ÊP €ªƒœòrX̤IÌ€î°ÆÄI®Ÿ —¬æ@îÉpÀ Pa°ªÏÁ£ÚÈzªÍ°Øl†Å.à  °Üø+€åF 0À^€±š§y¬C®¬â€Ùœ¸Â‘nvÓÎÀ=Üä@”S€ ‡…·/áÅ ž|–9` s"à Žq[ãóT'ç 9yäÔç€æ2àŸ£?ë_¥®·¶·BW-IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1fo__KL.html0000644000263000017630000000774611433220722017605 0ustar jorismkyb libDAI: dai::fo_KL< T > Struct Template Reference

dai::fo_KL< T > Struct Template Reference

Function object useful for calculating the KL distance. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &p, const T &q) const
 Returns (p == 0 ? 0 : (p * (log(p) - log(q)))).

Detailed Description

template<typename T>
struct dai::fo_KL< T >

Function object useful for calculating the KL distance.

Member Function Documentation

template<typename T>
T dai::fo_KL< T >::operator() ( const T &  p,
const T &  q 
) const [inline]

Returns (p == 0 ? 0 : (p * (log(p) - log(q)))).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__absdiff.html0000644000263000017630000000772711433220722020674 0ustar jorismkyb libDAI: dai::fo_absdiff< T > Struct Template Reference

dai::fo_absdiff< T > Struct Template Reference

Function object that returns the absolute difference of x and y. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns abs( x - y ).

Detailed Description

template<typename T>
struct dai::fo_absdiff< T >

Function object that returns the absolute difference of x and y.

Member Function Documentation

template<typename T>
T dai::fo_absdiff< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns abs( x - y ).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Permute-members.html0000644000263000017630000001040311433220722021266 0ustar jorismkyb libDAI: Member List

dai::Permute Member List

This is the complete list of members for dai::Permute, including all inherited members.

_rangesdai::Permute [private]
_sigmadai::Permute [private]
convertLinearIndex(size_t li) const dai::Permute [inline]
inverse() const dai::Permute [inline]
operator[](size_t i) const dai::Permute [inline]
Permute()dai::Permute [inline]
Permute(const std::vector< size_t > &rs, const std::vector< size_t > &sigma)dai::Permute [inline]
Permute(const std::vector< Var > &vars, bool reverse=false)dai::Permute [inline]
ranges()dai::Permute [inline]
sigma() const dai::Permute [inline]
sigma()dai::Permute [inline]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1ExactInf_1_1Properties.html0000644000263000017630000000721211433220722022656 0ustar jorismkyb libDAI: dai::ExactInf::Properties Struct Reference

dai::ExactInf::Properties Struct Reference

Parameters for ExactInf. More...

#include <dai/exactinf.h>

List of all members.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).

Detailed Description

Parameters for ExactInf.

Member Data Documentation

size_t dai::ExactInf::Properties::verbose

Verbosity (amount of output sent to stderr).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__pow.html0000644000263000017630000000757511433220722020104 0ustar jorismkyb libDAI: dai::fo_pow< T > Struct Template Reference

dai::fo_pow< T > Struct Template Reference

Function object that returns x to the power y. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (x ^ y).

Detailed Description

template<typename T>
struct dai::fo_pow< T >

Function object that returns x to the power y.

Member Function Documentation

template<typename T>
T dai::fo_pow< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns (x ^ y).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1HAK_1_1Properties.html0000644000263000017630000003721011433220722021561 0ustar jorismkyb libDAI: dai::HAK::Properties Struct Reference

dai::HAK::Properties Struct Reference

Parameters for HAK. More...

#include <dai/hak.h>

List of all members.

Public Member Functions

 DAI_ENUM (ClustersType, MIN, BETHE, DELTA, LOOP)
 Enumeration of possible cluster choices.
 DAI_ENUM (InitType, UNIFORM, RANDOM)
 Enumeration of possible message initializations.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
double maxtime
 Maximum time (in seconds).
Real tol
 Tolerance for convergence test.
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping).
ClustersType clusters
 How to choose the outer regions.
InitType init
 How to initialize the messages.
bool doubleloop
 Use single-loop (GBP) or double-loop (HAK).
size_t loopdepth
 Depth of loops (only relevant for clusters == ClustersType::LOOP).

Detailed Description

Parameters for HAK.

Member Function Documentation

dai::HAK::Properties::DAI_ENUM ( ClustersType  ,
MIN  ,
BETHE  ,
DELTA  ,
LOOP   
)

Enumeration of possible cluster choices.

The following cluster choices are defined:

  • MIN minimal clusters, i.e., one outer region for each maximal factor
  • DELTA one outer region for each variable and its Markov blanket
  • LOOP one cluster for each loop of length at most Properties::loopdepth, and in addition one cluster for each maximal factor
  • BETHE Bethe approximation (one outer region for each maximal factor, inner regions are single variables)

dai::HAK::Properties::DAI_ENUM ( InitType  ,
UNIFORM  ,
RANDOM   
)

Enumeration of possible message initializations.

Member Data Documentation

size_t dai::HAK::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::HAK::Properties::maxiter

Maximum number of iterations.

double dai::HAK::Properties::maxtime

Maximum time (in seconds).

Real dai::HAK::Properties::tol

Tolerance for convergence test.

Real dai::HAK::Properties::damping

Damping constant (0.0 means no damping, 1.0 is maximum damping).

ClustersType dai::HAK::Properties::clusters

How to choose the outer regions.

InitType dai::HAK::Properties::init

How to initialize the messages.

bool dai::HAK::Properties::doubleloop

Use single-loop (GBP) or double-loop (HAK).

size_t dai::HAK::Properties::loopdepth

Depth of loops (only relevant for clusters == ClustersType::LOOP).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1FRegion.png0000644000263000017630000000062511433220722017373 0ustar jorismkyb‰PNG  IHDRnP ]PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf+IDATX…íÔKnÄ `ØÌÚ¿oàôí…ºÊýP5*A)ÒD­O‚Äããa4 sÞ·™x{ 'G!ôåÒ-~¬õõ\ö•ÆY_ë :YTœ.©M`-6澓 ÚÄbOq:QiÒŸRáêàœ åº^:†‘Œ­‰ÝzðNÀí>á\aÇ>áo“kë¡ïøpýóå|ŠÏ‹fÒR)9Ÿg÷ðûXÙïà £Î'¸ýóV÷Ø÷[Ýíù\n¹å–[n˜‹@S[‰/åb-,c@íû1yÇÕäêC‡"òàÃiÝš)èÚ„¾‹Án“bzŠKuX‘{ûΖ¢r>J/e’‹‹ ·Ïd/9 ÔœJóØ¡ã¾Ïwær>c“—&Ÿgî,:×xÁÅIÐò?ÿGw¸ÉïàáQÄZ¡š§MIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1ClusterGraph-members.html0000644000263000017630000001774411433220722022267 0ustar jorismkyb libDAI: Member List

dai::ClusterGraph Member List

This is the complete list of members for dai::ClusterGraph, including all inherited members.

_clustersdai::ClusterGraph [private]
_Gdai::ClusterGraph [private]
_varsdai::ClusterGraph [private]
adj(size_t i1, size_t i2) const dai::ClusterGraph [inline]
bipGraph() const dai::ClusterGraph [inline]
cluster(size_t I) const dai::ClusterGraph [inline]
ClusterGraph()dai::ClusterGraph [inline]
ClusterGraph(const std::vector< VarSet > &cls)dai::ClusterGraph
ClusterGraph(const FactorGraph &fg, bool onlyMaximal)dai::ClusterGraph
clusters() const dai::ClusterGraph [inline]
Delta(size_t i) const dai::ClusterGraph [inline]
delta(size_t i) const dai::ClusterGraph [inline]
elimVar(size_t i)dai::ClusterGraph [inline]
eraseNonMaximal()dai::ClusterGraph [inline]
eraseSubsuming(size_t i)dai::ClusterGraph [inline]
findCluster(const VarSet &cl) const dai::ClusterGraph [inline]
findVar(const Var &n) const dai::ClusterGraph [inline]
insert(const VarSet &cl)dai::ClusterGraph [inline]
isMaximal(size_t I) const dai::ClusterGraph [inline]
nrClusters() const dai::ClusterGraph [inline]
nrVars() const dai::ClusterGraph [inline]
operator<<(std::ostream &os, const ClusterGraph &cl)dai::ClusterGraph [friend]
var(size_t i) const dai::ClusterGraph [inline]
VarElim(EliminationChoice f, size_t maxStates=0) const dai::ClusterGraph [inline]
vars() const dai::ClusterGraph [inline]

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/mr_8h-source.html0000644000263000017630000006624511433220722016403 0ustar jorismkyb libDAI: include/dai/mr.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_127.png0000644000263000017630000000121611433220722015227 0ustar jorismkyb‰PNG  IHDRr#º!C0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf IDAT8Ý”±kÔpÇ¿Éï—Ëåè5I¡Î?«hE‡”j­¥Wi¥Ò.ŠCÄrNÒPýÅ’R‡R "žàèÐ:ŠHÅŵèâ(êæù’‹—x‘ØÜàÐ/ä]ÞïÞçýÞ{¿ûpdÄü®¼ò蹎išKß6í™ ‹ƒœîljb’µDæë7‘Q“õÊräWSv#2çGÚ*$?¦‘¤w‘Ùûíí’;Š±–zßî“Ù_ž´èå!=ãN’9CVV['/ƒÏ!èr¨“iã’~1ªtœk›êí~rîûRµii»GªžnÜamØ”  \Ô>媡 ÙÙV0dÏRH˜‰]"9¤ƒɃšK¹VJÖ§Š'ïBø wyj ìmŽÔ\],ŽàVBEiÇ÷ÇB|`áû Ÿ‰'Äìiu¯Ÿ:Öm<ΖۂâÑ©<¨4ññè¦Üì'«8c>Ç£Á¼›|ãݲ—Mšÿ݆ÝG[”;–ÔD%î¼ …$@·g”jO×’“gŸÇ;aÚE±xD.eHéW•=ë|ÅTç§w¸ð¬¨'H¦9ÀÂÿkDVš@£l¹JÕ^b¹ìžš+¿2{–S–5²üTà¢d¹:ê¾OwîÀ‘­Ggµˆ§Š1Z”_Š\1ê8SŽMçÆ“ÈBk–D{bƒ‚Õ/Á×}Z>”õæIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1TreeEP_1_1TreeEPSubTree.html0000644000263000017630000007111611433220722022350 0ustar jorismkyb libDAI: dai::TreeEP::TreeEPSubTree Class Reference

dai::TreeEP::TreeEPSubTree Class Reference

Stores the data structures needed to efficiently update the approximation of an off-tree factor. More...

List of all members.

Public Member Functions

void init ()
 Initializes beliefs of this subtree.
void InvertAndMultiply (const std::vector< Factor > &Qa, const std::vector< Factor > &Qb)
 Inverts this approximation and multiplies it by the (super) junction tree marginals Qa and Qb.
void HUGIN_with_I (std::vector< Factor > &Qa, std::vector< Factor > &Qb)
 Runs junction tree algorithm (including off-tree factor I) storing the results in the (super) junction tree Qa and Qb.
Real logZ (const std::vector< Factor > &Qa, const std::vector< Factor > &Qb) const
 Returns energy (?) of this subtree.
const Factor *& I ()
 Returns constant reference to the pointer to the off-tree factor.
Constructors/destructors
 TreeEPSubTree ()
 Default constructor.
 TreeEPSubTree (const TreeEPSubTree &x)
 Copy constructor.
TreeEPSubTree & operator= (const TreeEPSubTree &x)
 Assignment operator.
 TreeEPSubTree (const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector< Factor > &jt_Qa, const std::vector< Factor > &jt_Qb, const Factor *I)
 Construct from subRTree, which is a subtree of the main tree jt_RTree, with distribution represented by jt_Qa and jt_Qb, for off-tree factor I.

Private Attributes

std::vector< Factor > _Qa
 Outer region pseudomarginals (corresponding with the $\tilde f_i(x_j,x_k)$ in [MiQ04]).
std::vector< Factor > _Qb
 Inner region pseudomarginals (corresponding with the $\tilde f_i(x_s)$ in [MiQ04]).
RootedTree _RTree
 The junction tree (stored as a rooted tree).
std::vector< size_t > _a
 Index conversion table for outer region indices (_Qa[alpha] corresponds with Qa[_a[alpha]] of the supertree).
std::vector< size_t > _b
 Index conversion table for inner region indices (_Qb[beta] corresponds with Qb[_b[beta]] of the supertree).
const Factor * _I
 Pointer to off-tree factor.
VarSet _ns
 Variables in off-tree factor.
VarSet _nsrem
 Variables in off-tree factor which are not in the root of this subtree.
Real _logZ
 Used for calculating the free energy.

Detailed Description

Stores the data structures needed to efficiently update the approximation of an off-tree factor.

The TreeEP object stores a TreeEPSubTree object for each off-tree factor. It stores the approximation of that off-tree factor, which is represented as a distribution on a subtree of the main tree.

Constructor & Destructor Documentation

dai::TreeEP::TreeEPSubTree::TreeEPSubTree (  )  [inline]

Default constructor.

dai::TreeEP::TreeEPSubTree::TreeEPSubTree ( const TreeEPSubTree &  x  )  [inline]

Copy constructor.

dai::TreeEP::TreeEPSubTree::TreeEPSubTree ( const RootedTree &  subRTree,
const RootedTree &  jt_RTree,
const std::vector< Factor > &  jt_Qa,
const std::vector< Factor > &  jt_Qb,
const Factor *  I 
)

Construct from subRTree, which is a subtree of the main tree jt_RTree, with distribution represented by jt_Qa and jt_Qb, for off-tree factor I.

Member Function Documentation

TreeEPSubTree& dai::TreeEP::TreeEPSubTree::operator= ( const TreeEPSubTree &  x  )  [inline]

Assignment operator.

void dai::TreeEP::TreeEPSubTree::init (  ) 

Initializes beliefs of this subtree.

void dai::TreeEP::TreeEPSubTree::InvertAndMultiply ( const std::vector< Factor > &  Qa,
const std::vector< Factor > &  Qb 
)

Inverts this approximation and multiplies it by the (super) junction tree marginals Qa and Qb.

void dai::TreeEP::TreeEPSubTree::HUGIN_with_I ( std::vector< Factor > &  Qa,
std::vector< Factor > &  Qb 
)

Runs junction tree algorithm (including off-tree factor I) storing the results in the (super) junction tree Qa and Qb.

Real dai::TreeEP::TreeEPSubTree::logZ ( const std::vector< Factor > &  Qa,
const std::vector< Factor > &  Qb 
) const

Returns energy (?) of this subtree.

const Factor*& dai::TreeEP::TreeEPSubTree::I (  )  [inline]

Returns constant reference to the pointer to the off-tree factor.

Member Data Documentation

std::vector<Factor> dai::TreeEP::TreeEPSubTree::_Qa [private]

Outer region pseudomarginals (corresponding with the $\tilde f_i(x_j,x_k)$ in [MiQ04]).

std::vector<Factor> dai::TreeEP::TreeEPSubTree::_Qb [private]

Inner region pseudomarginals (corresponding with the $\tilde f_i(x_s)$ in [MiQ04]).

RootedTree dai::TreeEP::TreeEPSubTree::_RTree [private]

The junction tree (stored as a rooted tree).

std::vector<size_t> dai::TreeEP::TreeEPSubTree::_a [private]

Index conversion table for outer region indices (_Qa[alpha] corresponds with Qa[_a[alpha]] of the supertree).

std::vector<size_t> dai::TreeEP::TreeEPSubTree::_b [private]

Index conversion table for inner region indices (_Qb[beta] corresponds with Qb[_b[beta]] of the supertree).

const Factor* dai::TreeEP::TreeEPSubTree::_I [private]

Pointer to off-tree factor.

VarSet dai::TreeEP::TreeEPSubTree::_ns [private]

Variables in off-tree factor.

VarSet dai::TreeEP::TreeEPSubTree::_nsrem [private]

Variables in off-tree factor which are not in the root of this subtree.

Real dai::TreeEP::TreeEPSubTree::_logZ [private]

Used for calculating the free energy.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1ExactInf.png0000644000263000017630000000110411433220722017534 0ustar jorismkyb‰PNG  IHDRˆ<)PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfÚIDAThí—Arà EÍ&k¤ˆtÚ u•û¡H2X$N äI)6c@~Éñø/_sö±|¦)sÀ-–†¤ ÒÁQ@*€Ü1® ðµ€úHH|«ÀMbœtú¼8•, 7ŽÀ €Ú(é–sp èÌV5‰Ð]…Û6 èÎÁMƒ‡ñUÿ 0ýZ?°Ó‘ÃÃçï'Nçó“/P8ÀpÀ›\7¾ €jòE樖eñ™ìw¿ˆá&/Ä"÷äÄd¤‹²!EëªPe È5@Ôa*G5^ù‰P"´´àA Õ•…”ä`èp€ÈÄ*õ~™Ï„ê*„ @AQyE,–Ö$€ `“‰U,’îŸV€nÙä@«@êØŒXlÍspÏv´ž±CÀ®XìŠÅ!À9Àuã¯\7:Àp€Þs—8¡v±4s\-èDˆ—Þû½ÅZØÈw!Æe-nùÀݹ!Ä|qˆÙ‰W“cÑ+^\b8Ž@–(ÑWT nÚ¿f ý€ÐrþLzZ…(þ9ZN~ˆ}€QsÀ?̾Ö{¬º†•áIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1GraphEL-members.html0000644000263000017630000000447711433220722021145 0ustar jorismkyb libDAI: Member List

dai::GraphEL Member List

This is the complete list of members for dai::GraphEL, including all inherited members.

GraphEL()dai::GraphEL [inline]
GraphEL(InputIterator begin, InputIterator end)dai::GraphEL [inline]
GraphEL(const GraphAL &G)dai::GraphEL [inline]

Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x73.html0000644000263000017630000002772311433220722016657 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- s -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1ParameterEstimation.png0000644000263000017630000000110611433220722022012 0ustar jorismkyb‰PNG  IHDR•Pâ©*{PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfÜIDATX…í•ímÄ †±Ôl6p&¨ÚøqûÏT`àšPNHôGÞD ØæÁØ9]¢e„i•nÖ[,hmÇIPßÒ,[Í3 ŸXÕ0x³ðéõkXY ÈW(KÆ Q- sJ„nÒX1¨;™ÙW éìN`F· AõTSªaJ«+$: Úѽ^8,k,´za·wVzb!DÀ~fÑÈuè'Pò Sga\ÃþcŸ0î˼èOV;ãpðËû‘E²F5‹öÉûhõ’3Rœ1¾€ÎZ£›u³Î¬•ÿi/©,K~)ëãñ?YGù—¬¥*»˜¨ìN`¢²;‰Êî&*»˜¨ìN`¢²;‰Êî&*»˜¨ìN`¢²;‰Êî&*¯…}/Ógú:Véf½Åâö8ˆº—e–ëXÞì3>rÈ=zdUïàÖÐpåÕƒÇa°ˆeOwH¶Ïdfe1WƒL2›Ç†\Y+®ÌvÛnfq³Lr3XªzgÛÇ—x\ciTnyñQ½^Ü 2ã†ó%¹úFÓ%+¦Õ`g –-¹båë¼Î¬¨ÅxÆ'µP>š;êÀǹ^S–÷‘½ú}ikä¢È+ú¨Õ“WŽ32×>¬5ºY7ëÌZøŸöZšoQ_\·IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1FactorGraph.png0000644000263000017630000000227411433220722020244 0ustar jorismkyb‰PNG  IHDR’ˆ?–p€PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfRIDATxœíš[’ã EÃO;À³ƒ™ Q5UÙÿ†—0vlÇr+íá&EÀ!º:Æ8]i=x)óié Y]‘ú¸Ã Ájœ× ÁêˆDC£æ;PoÌzæQ½%YMRó«Þ˜yåÃÚ'QZ?ÂRh˜úÊ„64­ózÅRa’Ù Ó‰VZ…·uzƉ¡“Fáar~& ÇÌA¾Äì“Gég’D“×Kă8<:&1¦¹ºÌ’$5Êü kò€«kM¢Äš¨  $a$ºw’|ïÒ°ãc?Þ©ò½+ ÓÕ¥TAÚ“< U„A‚Õ 9¯A‚Õ 9¯A‚Õ}~%BëK:2݇äé¥3 ÒmH¾žOéˆt’íøAÒŸI$ýiô§NIž<òŸ'a°`²a°`²a°`²a°`²a°`²a°`²a°`²a°`²a°`²a°`²a°`²a°`²a°`²a°`²a°¸fó«¿ØpÙüž>¬_‰„Áf , Òæ¿ ±Ð8cà˜«ïÎÇ`êžÅL²Šèšç,W3{€3v5ó4IùÄKªËc’ùÓÖ¦ŽÝ YGµõÕmÍ<$qÁ!œ ¾¡¹pV&çl9½Ff/LC²Œè$ñ½,“- ýÐ môwy½\ “OXÓ/ñ9•~ÁKt…‘Ù_•™dÑ-6&•¯¸t*¬n&I“ãÅá;’ÈÕ«:…› Iê—Ó[FgHšˆ/$1`J3-‡-ûÄBßÖ©y½j€ò†Ä˜âëÍ’$Í;ER#–ÐÖ 4{ÙæêZ’ä’É;%¢“¸ù æp¯$·&MÄbn›5±ÓLb§ ’:éÜš¸I³Or0 ±gI–—$/û¤%}’î<…ÄÉÛ}’ï4vüâÞ•Øæ«Ë¹‚ô–¤¿)Z’Õ½ËÕúÑ:ß»ò0›Û’GµÁ}ùnåë6Žm’àC#æãH¶Ï< ÉÁ¢î~beƒ!q›ß$$Û¡ô-’Kêá/H*‹A‚´$ &ôÏ7h]û•èš Jÿ‘N奠Ò×}ª3oCÂRQ¢ûÜgÇ’å¥ “—N€L^:2yéÈä¥ “—N€L^:2yéÈä¥ “—N€L^:2yéÈä¥ “—N€L^:2yéÈä¥ “—N€L^:2yéÈä¥ “—N€L^:=¡ÿãr­^˜ALÿ$ƒdôCÒ–èæò°ù9ëZý°IIÁ¥2ÖØY— _«f%Y–èډʫõÃœ$«]Û>â{¹ÒðBý°á'™Kt_I\)™¼R?lHš]›¶}i]-ù¾T?løIšÂÖ\*^ÛfMÐõÃükÒ–è–òâJ²Þ'•ä}ý0û>iKtM)Ë’õ½ _?ÜÏwüaé鉪Û^HÜÉ©úá^H&³•,ä|¦~¸’ok ’AÒ úW"´˜@þQîf·¹IEND®B`‚libDAI-0.2.7/doc/html/form_63.png0000644000263000017630000000077011433220722015152 0ustar jorismkyb‰PNG  IHDR‡ΪqÂ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfvIDAT8c` `&A­”V6f06@çØ„GS„ƒ ßÊõýÊøÚIœ_€AÓKä¢^ 3tãö1ú0p,€°™>³ ›2ä#ó ƒÕÃ# Ü“m܆3á( ùX>0|±ì1 ùÄÀŠÄãE2Äš!¾a7ä} 2Ùý L 8gÎœ9¬·!÷/p Âòêµ² à2,ñÂÀø‘²@ëfB aèT‹«u0]FmGGGÈa ¬¸Â„ƒá?ŠwX/@2a>{ÐAAAp˜0~dþÀ­2„e Et˜'è` “õï/æU@H£ØÒJ·óübÖ œ (R±b&C;Âãó#¤ÑÅ ‚ˆ ‰ƒØŒ —‘S7Š!¬ˆ g໊ⶄ8TÄ Ù 7±¶) ’ ™Ä±æËh솀ÜL4ÅžRvb~IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1Gibbs.png0000644000263000017630000000106311433220722017065 0ustar jorismkyb‰PNG  IHDRˆ<)PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfÉIDAThí×Qr `xé3»7XNÐi/Ô']–l410L«­»ÆLˆä“€:þás®ÞÃGž*ŽÔq¸£@V`Ù„˜ëʱ@}R¹”7(»\8nôåÍIG`Þ”ÑÂh;ÊrKƒsp tάÊ$ {Žk螃Âã³~ÿ0ý³~Rog~¸|=x»\ <Á*8à€8ðb€çƧ¨í€ÿQ£ÙZ-1ˆÊ3ÛÿýàÂ5&^…ÅÒâ'f]X¢ -ïjSP‘[€ÓaÖˆ#O”-@LËIÊ \G°¨v-AŠç rºà˜Ø¢\ϯpόҕ… ¦< ‹:‚:‰ Ø€Ö˜ØÂ"ÉýSä–ÍÈ*tÜ&,n€Íçà^íd=S§ÀnXvÃâpRxnüÀs£8à€¯À\¥æFèÀÛnY¤å ikУ†ˆ!‚\’IK+¦wúî1@9yÓv”v'P:¦:`&E™Šn ‚aúo¡^r ìÍäÝ9, ϬB” ¥áU*þ 0û³þ :*¸IVBX IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1BP__dual-members.html0000644000263000017630000001752311433220722021324 0ustar jorismkyb libDAI: Member List

dai::BP_dual Member List

This is the complete list of members for dai::BP_dual, including all inherited members.

_beliefsdai::BP_dual [protected]
_iadai::BP_dual [protected]
_msgsdai::BP_dual [protected]
beliefF(size_t I) const dai::BP_dual [inline]
beliefFZ(size_t I) const dai::BP_dual [inline]
beliefV(size_t i) const dai::BP_dual [inline]
beliefVZ(size_t i) const dai::BP_dual [inline]
BP_dual(const InfAlg *ia)dai::BP_dual [inline]
calcBeliefF(size_t I)dai::BP_dual [protected]
calcBeliefs()dai::BP_dual [protected]
calcBeliefV(size_t i)dai::BP_dual [protected]
calcMessages()dai::BP_dual [protected]
calcNewM(size_t i, size_t _I)dai::BP_dual [protected]
calcNewN(size_t i, size_t _I)dai::BP_dual [protected]
fg() const dai::BP_dual [inline]
init()dai::BP_dual [protected]
msgM(size_t i, size_t _I)dai::BP_dual [inline]
msgM(size_t i, size_t _I) const dai::BP_dual [inline]
msgN(size_t i, size_t _I)dai::BP_dual [inline]
msgN(size_t i, size_t _I) const dai::BP_dual [inline]
regenerateBeliefs()dai::BP_dual [protected]
regenerateMessages()dai::BP_dual [protected]
zM(size_t i, size_t _I)dai::BP_dual [inline]
zM(size_t i, size_t _I) const dai::BP_dual [inline]
zN(size_t i, size_t _I)dai::BP_dual [inline]
zN(size_t i, size_t _I) const dai::BP_dual [inline]

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1ExactInf_1_1Properties-members.html0000644000263000017630000000356611433220722024316 0ustar jorismkyb libDAI: Member List

dai::ExactInf::Properties Member List

This is the complete list of members for dai::ExactInf::Properties, including all inherited members.

verbosedai::ExactInf::Properties

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_46.png0000644000263000017630000000147411433220722015155 0ustar jorismkyb‰PNG  IHDR—+‡¹D0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfºIDATH‰ÅÖOkÓ`ðïÓ´%v«I¦Ñt RðZ¸V¡NE&nz)TŠ±¸‹Þꔵl{ÓxÙ@êÜ`/`*¬7OÂ`¢0D¦/`¶ÛTt>OšþI›6M:ðyš>}žß$O ü×’¬ ^3ù=nÐÇÍ·¼ÙÞâ ;­bdyEQÞ§¯ͳ‚¹>°V 3>ãX¤ÖÏ+§l$ûÈ/±R-ë7|ê Ä«½žv€9¯ÒOË£"®ÉàuX]ys•uÒ›òÐfÙÿÃUè•2¸A~bî½èÛ=B›Y”¸â,NŠÛ0N†¾UyÄ›Û¡Í Ã6 $J-0 žø°)æg*ØA=æQG…鑃GΘb‚4VÁFÄ;x‡æ{v;ÂW¸M0.¡Otib1°À½Îáè­·rs&¡Pˆaܸ’BÉ4™q•1×|>ŸšŒ)yǸ-L ûÉ _I¦Vgì`äùú—Rt‹ªKFkÊV2Í,¨/hßûR:ì\ÂFVä†è°ùˬå³ÙìtÉD£Î*Æý ‚f#ôNˆv;k©¤ºdsÛ—9š´Tb ;Ž¼+ Påi—iX*ÆnærE}²æRŸ—o‡ñìeà¢`ÉÚcåšn‡‘XùÜ;Ö;L—{(è.˜c•"‘–Xàw2ywÝ¿IWÎT#÷ÚbºÒcl÷âü=ÂŽŠÝô?éë™d§ŽWìÑÓ¦ûؼ"\û‚±"'›çØÅøžæcû…Ñ ímØ9,bD݈п*kBãk˜Sͦ€UYÛØ!õœ§Øâ³—ÈhIíaÎ+ˆF£ÃØÖº._Ò²„¡šŒÕ úmaá½·º‹áZ2µ<¶0BW}å­ÄùGZ¯s°Clk+ÝÔiø?ïÐ/´/SZWRêhØ?> i~6ǾIEND®B`‚libDAI-0.2.7/doc/html/functions_func_0x7e.html0000644000263000017630000001124011433220722017737 0ustar jorismkyb libDAI: Class Members - Functions
 

- ~ -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x6d.html0000644000263000017630000001366111433220722017766 0ustar jorismkyb libDAI: Class Members - Variables
 

- m -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x67.html0000644000263000017630000002060411433220722017664 0ustar jorismkyb libDAI: Class Members - Functions
 

- g -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/trwbp_8h-source.html0000644000263000017630000004105411433220722017112 0ustar jorismkyb libDAI: include/dai/trwbp.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/tab_b.gif0000644000263000017630000000004311433220722014720 0ustar jorismkybGIF89a€„°Ç,D;libDAI-0.2.7/doc/html/classdai_1_1GraphAL.html0000644000263000017630000012414611433220722017505 0ustar jorismkyb libDAI: dai::GraphAL Class Reference

dai::GraphAL Class Reference

Represents the neighborhood structure of nodes in an undirected graph. More...

#include <dai/graph.h>

List of all members.

Input and output

void printDot (std::ostream &os) const
 Writes this GraphAL to an output stream in GraphViz .dot syntax.
std::ostream & operator<< (std::ostream &os, const GraphAL &g)
 Writes this GraphAL to an output stream.

Public Member Functions

Constructors and destructors
 GraphAL ()
 Default constructor (creates an empty graph).
 GraphAL (size_t nr)
 Constructs GraphAL with nr nodes and no edges.
template<typename EdgeInputIterator>
 GraphAL (size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
 Constructs GraphAL from a range of edges.
Accessors and mutators
const Neighbor & nb (size_t n1, size_t _n2) const
 Returns constant reference to the _n2 'th neighbor of node n1.
Neighbor & nb (size_t n1, size_t _n2)
 Returns reference to the _n2 'th neighbor of node n1.
const Neighbors & nb (size_t n) const
 Returns constant reference to all neighbors of node n.
Neighbors & nb (size_t n)
 Returns reference to all neighbors of node n.
Adding nodes and edges
template<typename EdgeInputIterator>
void construct (size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
 (Re)constructs GraphAL from a range of edges.
size_t addNode ()
 Adds a node without neighbors and returns the index of the added node.
template<typename NodeInputIterator>
size_t addNode (NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
 Adds a node, with neighbors specified by a range of nodes.
GraphAL & addEdge (size_t n1, size_t n2, bool check=true)
 Adds an edge between node n1 and node n2.
Erasing nodes and edges
void eraseNode (size_t n)
 Removes node n and all incident edges; indices of other nodes are changed accordingly.
void eraseEdge (size_t n1, size_t n2)
 Removes edge between node n1 and node n2.
Queries
size_t nrNodes () const
 Returns number of nodes.
size_t nrEdges () const
 Calculates the number of edges, time complexity: O(nrNodes()).
bool hasEdge (size_t n1, size_t n2) const
 Returns true if the graph contains an edge between nodes n1 and n2.
size_t findNb (size_t n1, size_t n2)
 Returns the index of a given node n2 amongst the neighbors of n1.
SmallSet< size_t > nbSet (size_t n) const
 Returns neighbors of node n as a SmallSet<size_t>.
bool isConnected () const
 Returns true if the graph is connected.
bool isTree () const
 Returns true if the graph is a tree, i.e., if it is singly connected and connected.
void checkConsistency () const
 Asserts internal consistency.
bool operator== (const GraphAL &x) const
 Comparison operator which returns true if two graphs are identical.

Private Attributes

std::vector< Neighbors > _nb
 Contains for each node a vector of its neighbors.

Detailed Description

Represents the neighborhood structure of nodes in an undirected graph.

A graph has nodes connected by edges. Nodes are indexed by an unsigned integer. If there are nrNodes() nodes, they are numbered 0,1,2,...,nrNodes()-1. An edge between node n1 and node n2 is represented by a Edge(n1,n2).

GraphAL is implemented as a sparse adjacency list, i.e., it stores for each node a list of its neighboring nodes. The list of neighboring nodes is implemented as a vector of Neighbor structures (accessible by the nb() method). Thus, each node has an associated variable of type GraphAL::Neighbors, which is a vector of Neighbor structures, describing its neighboring nodes.

Constructor & Destructor Documentation

dai::GraphAL::GraphAL (  )  [inline]

Default constructor (creates an empty graph).

dai::GraphAL::GraphAL ( size_t  nr  )  [inline]

Constructs GraphAL with nr nodes and no edges.

template<typename EdgeInputIterator>
dai::GraphAL::GraphAL ( size_t  nr,
EdgeInputIterator  begin,
EdgeInputIterator  end,
bool  check = true 
) [inline]

Constructs GraphAL from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of Edge.
Parameters:
nr The number of nodes.
begin Points to the first edge.
end Points just beyond the last edge.
check Whether to only add an edge if it does not exist already.

Member Function Documentation

const Neighbor& dai::GraphAL::nb ( size_t  n1,
size_t  _n2 
) const [inline]

Returns constant reference to the _n2 'th neighbor of node n1.

Neighbor& dai::GraphAL::nb ( size_t  n1,
size_t  _n2 
) [inline]

Returns reference to the _n2 'th neighbor of node n1.

const Neighbors& dai::GraphAL::nb ( size_t  n  )  const [inline]

Returns constant reference to all neighbors of node n.

Neighbors& dai::GraphAL::nb ( size_t  n  )  [inline]

Returns reference to all neighbors of node n.

template<typename EdgeInputIterator>
void dai::GraphAL::construct ( size_t  nr,
EdgeInputIterator  begin,
EdgeInputIterator  end,
bool  check = true 
) [inline]

(Re)constructs GraphAL from a range of edges.

Template Parameters:
EdgeInputIterator Iterator that iterates over instances of Edge.
Parameters:
nr The number of nodes.
begin Points to the first edge.
end Points just beyond the last edge.
check Whether to only add an edge if it does not exist already.

size_t dai::GraphAL::addNode (  )  [inline]

Adds a node without neighbors and returns the index of the added node.

template<typename NodeInputIterator>
size_t dai::GraphAL::addNode ( NodeInputIterator  begin,
NodeInputIterator  end,
size_t  sizeHint = 0 
) [inline]

Adds a node, with neighbors specified by a range of nodes.

Template Parameters:
NodeInputIterator Iterator that iterates over instances of size_t.
Parameters:
begin Points to the first index of the nodes that should become neighbors of the added node.
end Points just beyond the last index of the nodes that should become neighbors of the added node.
sizeHint For improved efficiency, the size of the range may be specified by sizeHint.
Returns:
Index of the added node.

GraphAL & dai::GraphAL::addEdge ( size_t  n1,
size_t  n2,
bool  check = true 
)

Adds an edge between node n1 and node n2.

If check == true, only adds the edge if it does not exist already.

void dai::GraphAL::eraseNode ( size_t  n  ) 

Removes node n and all incident edges; indices of other nodes are changed accordingly.

void dai::GraphAL::eraseEdge ( size_t  n1,
size_t  n2 
)

Removes edge between node n1 and node n2.

size_t dai::GraphAL::nrNodes (  )  const [inline]

Returns number of nodes.

size_t dai::GraphAL::nrEdges (  )  const [inline]

Calculates the number of edges, time complexity: O(nrNodes()).

bool dai::GraphAL::hasEdge ( size_t  n1,
size_t  n2 
) const [inline]

Returns true if the graph contains an edge between nodes n1 and n2.

Note:
The time complexity is linear in the number of neighbors of n1 or n2

size_t dai::GraphAL::findNb ( size_t  n1,
size_t  n2 
) [inline]

Returns the index of a given node n2 amongst the neighbors of n1.

Note:
The time complexity is linear in the number of neighbors of n1
Exceptions:
OBJECT_NOT_FOUND if n2 is not a neighbor of n1

SmallSet< size_t > dai::GraphAL::nbSet ( size_t  n  )  const

Returns neighbors of node n as a SmallSet<size_t>.

bool dai::GraphAL::isConnected (  )  const

Returns true if the graph is connected.

bool dai::GraphAL::isTree (  )  const

Returns true if the graph is a tree, i.e., if it is singly connected and connected.

void dai::GraphAL::checkConsistency (  )  const

Asserts internal consistency.

bool dai::GraphAL::operator== ( const GraphAL &  x  )  const [inline]

Comparison operator which returns true if two graphs are identical.

Note:
Two graphs are called identical if they have the same number of nodes and the same edges (i.e., x has an edge between nodes n1 and n2 if and only if *this has an edge between nodes n1 and n2).

void dai::GraphAL::printDot ( std::ostream &  os  )  const

Writes this GraphAL to an output stream in GraphViz .dot syntax.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const GraphAL &  g 
) [friend]

Writes this GraphAL to an output stream.

Member Data Documentation

std::vector<Neighbors> dai::GraphAL::_nb [private]

Contains for each node a vector of its neighbors.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/example_8cpp-example.html0000644000263000017630000005763611433220722020112 0ustar jorismkyb libDAI: example.cpp

example.cpp

This example illustrates how to read a factor graph from a file and how to run several inference algorithms (junction tree, loopy belief propagation, and the max-product algorithm) on it.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2006-2009  Joris Mooij  [joris dot mooij at libdai dot org]
 *  Copyright (C) 2006-2007  Radboud University Nijmegen, The Netherlands
 */


#include <iostream>
#include <map>
#include <dai/alldai.h>  // Include main libDAI header file


using namespace dai;
using namespace std;


int main( int argc, char *argv[] ) {
    if ( argc != 2 ) {
        cout << "Usage: " << argv[0] << " <filename.fg>" << endl << endl;
        cout << "Reads factor graph <filename.fg> and runs" << endl;
        cout << "Belief Propagation and JunctionTree on it." << endl << endl;
        return 1;
    } else {
        // Read FactorGraph from the file specified by the first command line argument
        FactorGraph fg;
        fg.ReadFromFile(argv[1]);

        // Set some constants
        size_t maxiter = 10000;
        Real   tol = 1e-9;
        size_t verb = 1;

        // Store the constants in a PropertySet object
        PropertySet opts;
        opts.set("maxiter",maxiter);  // Maximum number of iterations
        opts.set("tol",tol);          // Tolerance for convergence
        opts.set("verbose",verb);     // Verbosity (amount of output generated)

        // Construct a JTree (junction tree) object from the FactorGraph fg
        // using the parameters specified by opts and an additional property
        // that specifies the type of updates the JTree algorithm should perform
        JTree jt( fg, opts("updates",string("HUGIN")) );
        // Initialize junction tree algorithm
        jt.init();
        // Run junction tree algorithm
        jt.run();

        // Construct another JTree (junction tree) object that is used to calculate
        // the joint configuration of variables that has maximum probability (MAP state)
        JTree jtmap( fg, opts("updates",string("HUGIN"))("inference",string("MAXPROD")) );
        // Initialize junction tree algorithm
        jtmap.init();
        // Run junction tree algorithm
        jtmap.run();
        // Calculate joint state of all variables that has maximum probability
        vector<size_t> jtmapstate = jtmap.findMaximum();

        // Construct a BP (belief propagation) object from the FactorGraph fg
        // using the parameters specified by opts and two additional properties,
        // specifying the type of updates the BP algorithm should perform and
        // whether they should be done in the real or in the logdomain
        BP bp(fg, opts("updates",string("SEQRND"))("logdomain",false));
        // Initialize belief propagation algorithm
        bp.init();
        // Run belief propagation algorithm
        bp.run();

        // Construct a BP (belief propagation) object from the FactorGraph fg
        // using the parameters specified by opts and two additional properties,
        // specifying the type of updates the BP algorithm should perform and
        // whether they should be done in the real or in the logdomain
        //
        // Note that inference is set to MAXPROD, which means that the object
        // will perform the max-product algorithm instead of the sum-product algorithm
        BP mp(fg, opts("updates",string("SEQRND"))("logdomain",false)("inference",string("MAXPROD"))("damping",string("0.1")));
        // Initialize max-product algorithm
        mp.init();
        // Run max-product algorithm
        mp.run();
        // Calculate joint state of all variables that has maximum probability
        // based on the max-product result
        vector<size_t> mpstate = mp.findMaximum();

        // Construct a decimation algorithm object from the FactorGraph fg
        // using the parameters specified by opts and three additional properties,
        // specifying that the decimation algorithm should use the max-product
        // algorithm and should completely reinitalize its state at every step
        DecMAP decmap(fg, opts("reinit",true)("ianame",string("BP"))("iaopts",string("[damping=0.1,inference=MAXPROD,logdomain=0,maxiter=1000,tol=1e-9,updates=SEQRND,verbose=1]")) );
        decmap.init();
        decmap.run();
        vector<size_t> decmapstate = decmap.findMaximum();

        // Report variable marginals for fg, calculated by the junction tree algorithm
        cout << "Exact variable marginals:" << endl;
        for( size_t i = 0; i < fg.nrVars(); i++ ) // iterate over all variables in fg
            cout << jt.belief(fg.var(i)) << endl; // display the "belief" of jt for that variable

        // Report variable marginals for fg, calculated by the belief propagation algorithm
        cout << "Approximate (loopy belief propagation) variable marginals:" << endl;
        for( size_t i = 0; i < fg.nrVars(); i++ ) // iterate over all variables in fg
            cout << bp.belief(fg.var(i)) << endl; // display the belief of bp for that variable

        // Report factor marginals for fg, calculated by the junction tree algorithm
        cout << "Exact factor marginals:" << endl;
        for( size_t I = 0; I < fg.nrFactors(); I++ ) // iterate over all factors in fg
            cout << jt.belief(fg.factor(I).vars()) << endl;  // display the "belief" of jt for the variables in that factor

        // Report factor marginals for fg, calculated by the belief propagation algorithm
        cout << "Approximate (loopy belief propagation) factor marginals:" << endl;
        for( size_t I = 0; I < fg.nrFactors(); I++ ) // iterate over all factors in fg
            cout << bp.belief(fg.factor(I).vars()) << endl; // display the belief of bp for the variables in that factor

        // Report log partition sum (normalizing constant) of fg, calculated by the junction tree algorithm
        cout << "Exact log partition sum: " << jt.logZ() << endl;

        // Report log partition sum of fg, approximated by the belief propagation algorithm
        cout << "Approximate (loopy belief propagation) log partition sum: " << bp.logZ() << endl;

        // Report exact MAP variable marginals
        cout << "Exact MAP variable marginals:" << endl;
        for( size_t i = 0; i < fg.nrVars(); i++ )
            cout << jtmap.belief(fg.var(i)) << endl;

        // Report max-product variable marginals
        cout << "Approximate (max-product) MAP variable marginals:" << endl;
        for( size_t i = 0; i < fg.nrVars(); i++ )
            cout << mp.belief(fg.var(i)) << endl;

        // Report exact MAP factor marginals
        cout << "Exact MAP factor marginals:" << endl;
        for( size_t I = 0; I < fg.nrFactors(); I++ )
            cout << jtmap.belief(fg.factor(I).vars()) << " == " << jtmap.beliefF(I) << endl;

        // Report max-product factor marginals
        cout << "Approximate (max-product) MAP factor marginals:" << endl;
        for( size_t I = 0; I < fg.nrFactors(); I++ )
            cout << mp.belief(fg.factor(I).vars()) << " == " << mp.beliefF(I) << endl;

        // Report exact MAP joint state
        cout << "Exact MAP state (log score = " << fg.logScore( jtmapstate ) << "):" << endl;
        for( size_t i = 0; i < jtmapstate.size(); i++ )
            cout << fg.var(i) << ": " << jtmapstate[i] << endl;

        // Report max-product MAP joint state
        cout << "Approximate (max-product) MAP state (log score = " << fg.logScore( mpstate ) << "):" << endl;
        for( size_t i = 0; i < mpstate.size(); i++ )
            cout << fg.var(i) << ": " << mpstate[i] << endl;

        // Report DecMAP joint state
        cout << "Approximate DecMAP state (log score = " << fg.logScore( decmapstate ) << "):" << endl;
        for( size_t i = 0; i < decmapstate.size(); i++ )
            cout << fg.var(i) << ": " << decmapstate[i] << endl;
    }

    return 0;
}
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/var_8h.html0000644000263000017630000000450711433220722015250 0ustar jorismkyb libDAI: include/dai/var.h File Reference

include/dai/var.h File Reference

Defines class Var, which represents a discrete random variable. More...

#include <iostream>
#include <dai/exceptions.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Var
 Represents a discrete random variable. More...

Detailed Description

Defines class Var, which represents a discrete random variable.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/tabs.css0000644000263000017630000000334211433220722014632 0ustar jorismkyb/* tabs styles, based on http://www.alistapart.com/articles/slidingdoors */ DIV.tabs { float : left; width : 100%; background : url("tab_b.gif") repeat-x bottom; margin-bottom : 4px; } DIV.tabs UL { margin : 0px; padding-left : 10px; list-style : none; } DIV.tabs LI, DIV.tabs FORM { display : inline; margin : 0px; padding : 0px; } DIV.tabs FORM { float : right; } DIV.tabs A { float : left; background : url("tab_r.gif") no-repeat right top; border-bottom : 1px solid #84B0C7; font-size : x-small; font-weight : bold; text-decoration : none; } DIV.tabs A:hover { background-position: 100% -150px; } DIV.tabs A:link, DIV.tabs A:visited, DIV.tabs A:active, DIV.tabs A:hover { color: #1A419D; } DIV.tabs SPAN { float : left; display : block; background : url("tab_l.gif") no-repeat left top; padding : 5px 9px; white-space : nowrap; } DIV.tabs INPUT { float : right; display : inline; font-size : 1em; } DIV.tabs TD { font-size : x-small; font-weight : bold; text-decoration : none; } /* Commented Backslash Hack hides rule from IE5-Mac \*/ DIV.tabs SPAN {float : none;} /* End IE5-Mac hack */ DIV.tabs A:hover SPAN { background-position: 0% -150px; } DIV.tabs LI.current A { background-position: 100% -150px; border-width : 0px; } DIV.tabs LI.current SPAN { background-position: 0% -150px; padding-bottom : 6px; } DIV.navpath { background : none; border : none; border-bottom : 1px solid #84B0C7; } libDAI-0.2.7/doc/html/classdai_1_1HAK.html0000644000263000017630000014756111433220722016640 0ustar jorismkyb libDAI: dai::HAK Class Reference

dai::HAK Class Reference

Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]. More...

#include <dai/hak.h>

Inheritance diagram for dai::HAK:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

Constructors/destructors
 HAK ()
 Default constructor.
 HAK (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
 HAK (const RegionGraph &rg, const PropertySet &opts)
 Construct from RegionGraph rg and PropertySet opts.
General InfAlg interface
virtual HAK * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &vs)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for HAK
Factor & muab (size_t alpha, size_t _beta)
 Returns reference to message from outer region alpha to its _beta 'th neighboring inner region.
Factor & muba (size_t alpha, size_t _beta)
 Returns reference to message the _beta 'th neighboring inner region of outer region alpha to that outer region.
const Factor & Qa (size_t alpha) const
 Returns belief of outer region alpha.
const Factor & Qb (size_t beta) const
 Returns belief of inner region beta.
Real doGBP ()
 Runs single-loop algorithm (algorithm 1 in [HAK03]).
Real doDoubleLoop ()
 Runs double-loop algorithm (as described in section 4.2 of [HAK03]), which always convergences.

Public Attributes

struct dai::HAK::Properties props

Static Public Attributes

static const char * Name = "HAK"
 Name of this inference algorithm.

Private Member Functions

void construct ()
 Helper function for constructors.
void findLoopClusters (const FactorGraph &fg, std::set< VarSet > &allcl, VarSet newcl, const Var &root, size_t length, VarSet vars)
 Recursive procedure for finding clusters of variables containing loops of length at most length.

Private Attributes

std::vector< Factor > _Qa
 Outer region beliefs.
std::vector< Factor > _Qb
 Inner region beliefs.
std::vector< std::vector
< Factor > > 		_muab
 Messages from outer to inner regions.
std::vector< std::vector
< Factor > > 		_muba
 Messages from inner to outer regions.
Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.

Classes

struct  Properties
 Parameters for HAK. More...

Detailed Description

Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03].

Constructor & Destructor Documentation

dai::HAK::HAK (  )  [inline]

Default constructor.

dai::HAK::HAK ( const FactorGraph &  fg,
const PropertySet &  opts 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties

dai::HAK::HAK ( const RegionGraph &  rg,
const PropertySet &  opts 
)

Construct from RegionGraph rg and PropertySet opts.

Member Function Documentation

virtual HAK* dai::HAK::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::HAK::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

Factor dai::HAK::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

vector< Factor > dai::HAK::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

Real dai::HAK::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

void dai::HAK::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

void dai::HAK::init ( const VarSet &  vs  )  [virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::HAK::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::HAK::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::HAK::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::HAK::setMaxIter ( size_t   )  [inline, virtual]

Sets maximum number of iterations (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::HAK::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::HAK::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::HAK::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Factor& dai::HAK::muab ( size_t  alpha,
size_t  _beta 
) [inline]

Returns reference to message from outer region alpha to its _beta 'th neighboring inner region.

Factor& dai::HAK::muba ( size_t  alpha,
size_t  _beta 
) [inline]

Returns reference to message the _beta 'th neighboring inner region of outer region alpha to that outer region.

const Factor& dai::HAK::Qa ( size_t  alpha  )  const [inline]

Returns belief of outer region alpha.

const Factor& dai::HAK::Qb ( size_t  beta  )  const [inline]

Returns belief of inner region beta.

Real dai::HAK::doGBP (  ) 

Runs single-loop algorithm (algorithm 1 in [HAK03]).

Real dai::HAK::doDoubleLoop (  ) 

Runs double-loop algorithm (as described in section 4.2 of [HAK03]), which always convergences.

void dai::HAK::construct (  )  [private]

Helper function for constructors.

void dai::HAK::findLoopClusters ( const FactorGraph &  fg,
std::set< VarSet > &  allcl,
VarSet  newcl,
const Var &  root,
size_t  length,
VarSet  vars 
) [private]

Recursive procedure for finding clusters of variables containing loops of length at most length.

Parameters:
fg the factor graph
allcl the clusters found so far
newcl partial candidate cluster
root start (and end) point of the loop
length number of variables that may be added to newcl
vars neighboring variables of newcl
Returns:
allcl all clusters of variables with loops of length at most length passing through root

Member Data Documentation

std::vector<Factor> dai::HAK::_Qa [private]

Outer region beliefs.

std::vector<Factor> dai::HAK::_Qb [private]

Inner region beliefs.

std::vector<std::vector<Factor> > dai::HAK::_muab [private]

Messages from outer to inner regions.

std::vector<std::vector<Factor> > dai::HAK::_muba [private]

Messages from inner to outer regions.

Real dai::HAK::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::HAK::_iters [private]

Number of iterations needed.

const char * dai::HAK::Name = "HAK" [static]

Name of this inference algorithm.

The documentation for this class was generated from the following files:
  • include/dai/hak.h
  • src/hak.cpp
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Exception.html0000644000263000017630000003361011433220722020160 0ustar jorismkyb libDAI: dai::Exception Class Reference

dai::Exception Class Reference

Error handling in libDAI is done by throwing an instance of the Exception class. More...

#include <dai/exceptions.h>

List of all members.

Public Types

enum  Code {
  NOT_IMPLEMENTED, ASSERTION_FAILED, IMPOSSIBLE_TYPECAST, OBJECT_NOT_FOUND,
  BELIEF_NOT_AVAILABLE, UNKNOWN_ENUM_VALUE, UNKNOWN_DAI_ALGORITHM, UNKNOWN_PARAMETER_ESTIMATION_METHOD,
  UNKNOWN_PROPERTY_TYPE, UNKNOWN_PROPERTY, MALFORMED_PROPERTY, NOT_ALL_PROPERTIES_SPECIFIED,
  INVALID_ALIAS, CANNOT_READ_FILE, CANNOT_WRITE_FILE, INVALID_FACTORGRAPH_FILE,
  INVALID_EVIDENCE_FILE, INVALID_EMALG_FILE, NOT_NORMALIZABLE, MULTIPLE_UNDO,
  FACTORGRAPH_NOT_CONNECTED, INTERNAL_ERROR, RUNTIME_ERROR, OUT_OF_MEMORY,
  NUM_ERRORS
}
 Enumeration of exceptions used in libDAI. More...

Public Member Functions

 Exception (Code _code, const std::string &msg="", const std::string &detailedMsg="")
 Constructor.
Code code () const
 Returns error code of this exception.
const std::string & message (const Code c) const
 Returns error message corresponding to an error code.

Private Attributes

Code errorcode
 Contains the error code of this exception.

Static Private Attributes

static std::string ErrorStrings [NUM_ERRORS]
 Error messages corresponding to the exceptions enumerated above.

Detailed Description

Error handling in libDAI is done by throwing an instance of the Exception class.

The Exception class inherits from std::runtime_error. It defines several types of exceptions and corresponding error messages. The recommended way to throw an instance of the Exception class is by using the DAI_THROW or DAI_THROWE macros.

Examples:

uai2010-aie-solver.cpp.

Member Enumeration Documentation

enum dai::Exception::Code

Enumeration of exceptions used in libDAI.

Constructor & Destructor Documentation

dai::Exception::Exception ( Code  _code,
const std::string &  msg = "",
const std::string &  detailedMsg = "" 
) [inline]

Constructor.

Member Function Documentation

Code dai::Exception::code (  )  const [inline]

Returns error code of this exception.

const std::string& dai::Exception::message ( const Code  c  )  const [inline]

Returns error message corresponding to an error code.

Member Data Documentation

Code dai::Exception::errorcode [private]

Contains the error code of this exception.

std::string dai::Exception::ErrorStrings [static, private]

Initial value:

 {
        "Feature not implemented",
        "Assertion failed",
        "Impossible typecast",
        "Requested object not found",
        "Requested belief not available",
        "Unknown ENUM value",
        "Unknown DAI algorithm",
        "Unrecognized parameter estimation method",
        "Unknown Property type",
        "Unknown Property",
        "Malformed Property",
        "Not all mandatory Properties specified",
        "Invalid alias",
        "Cannot read file",
        "Cannot write file",
        "Invalid FactorGraph file",
        "Invalid Evidence file",
        "Invalid Expectation-Maximization file",
        "Quantity not normalizable",
        "Multiple undo levels unsupported",
        "FactorGraph is not connected",
        "Internal error",
        "Runtime error",
        "Out of memory"
    }
Error messages corresponding to the exceptions enumerated above.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/exactinf_8h.html0000644000263000017630000000633211433220722016257 0ustar jorismkyb libDAI: include/dai/exactinf.h File Reference

include/dai/exactinf.h File Reference

Defines ExactInf class, which can be used for exact inference on small factor graphs. More...

#include <dai/daialg.h>
#include <dai/properties.h>
#include <dai/factorgraph.h>
#include <dai/enum.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::ExactInf
 Exact inference algorithm using brute force enumeration (mainly useful for testing purposes). More...
struct  dai::ExactInf::Properties
 Parameters for ExactInf. More...

Detailed Description

Defines ExactInf class, which can be used for exact inference on small factor graphs.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_38.png0000644000263000017630000000046611433220722015156 0ustar jorismkyb‰PNG  IHDR'gò{0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf´IDAT•c`À± ª3´ÉTÁ þ@R‚ãX\ŒÃ¡Hq (_ˆ„ ò20R¬ ì‡`‚< Ó…«pA+¦ " í±b`?À „!ÈUÀLq™7B,âWg[ÊÀ´ê•‹‹¸œ/0°°601€ÙØ[¸”>0 @>b`*b0g@V ô Øï¼!H*á¡å"YB f ìÍRqIEND®B`‚libDAI-0.2.7/doc/html/form_105.png0000644000263000017630000000352311433220722015226 0ustar jorismkyb‰PNG  IHDRÌ" Ìôó0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÑIDATX…íXÿoE»{»·×Þõ®¡Ô„®Z¡+¨%ГbE{¥P &ºMËh¿°¥UŒZCâ&"cBñ°–è&0þbÃþf¼R‹h¢ç›7³³{ÇÑÚx)hxI»oç3óyŸ7ófvZ€ÛvÛþ/¦õpÛ` wÏÔDÞ*ÂÅ‹¢%£åZ+++§mËÅ üz•Õ‡þ(Þ3V’xŠôÞ¸ÂÂ5ÿ˜-Úo1“¶Þz”uƒ’K“»¦h¿€]’pJŸë…ÿä ç‹÷WÌä­‚Gdmù•<Õv1C¬¸ ‚žOÊæ#ýG õ{ M°Ã Mo%íÑ-jÎ̶ML¢ºÞ8"x­ónå|~M0XæU>I4=~1õ"–—ÐàΕt T HIHˆn®¦;ô0ðŽ±ÈeIL<ÙÝLÞ5|.®]ÇJ=·Êëø¦l<ÆÇ *Le Åè>ŒÓËwTÄxm<˜ÃPŸQçU¹¢ý{’nZÂõ šüiŸŒï8®˜I›’Æ®ÒÜ®•†y"ká2EÑ‹QSÜ°¾uáÚ¥ažÈ‹pVQtŠÅܶÿš)õÖÍ–0%vüfMi4ñ%µ©uÜ~SjÊò¶3º¹Ú¥ËÙ__Sfê¶qÀ`´¶ð_~ÿÎè/|²Ýƒ7îWrSŸ]Pâh!÷ÿ‹+†îÒ4aȺ16ã-]ï»1‡“[e̬ÀD¼ B Œ€óS0V2ð00ù00\ Ø3È;à°b`ãg`¸à]à`ˆ‚ LyRÁðX* ¯›À/ÂËÀô b†óVÖ#†nW`Ü`;ìv ‘os)ÈOi .ÀâiP•š¶­25IEND®B`‚libDAI-0.2.7/doc/html/form_77.png0000644000263000017630000000105411433220722015153 0ustar jorismkyb‰PNG  IHDR€ù¤0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfªIDAT8Í’¿KÃ@Ç_~]RÛ4é"8‘jtì&þ²éfD(N¶ ZÝ‚uˆNQpÈ tpê ¡«Cÿ;ù¸§K‹ƒâ]~G£tô wï{ïÝçÞ»;€ÿdË&¶Ë?S•¤bB§êOì Tšl%(ó™©-7À¨±b?_ ’žÌ_0¸Nª :›)é™$ÿȹ3é¬1#_åŽ_èÞ"Õ,=t¾$]èá™kÕAô³î÷„~º±KÕ€‹g³Öš›2 à‡®HXË<ÉÀ‡Eœ%õî ¢ßük˜þ [ à“7llr`dXÓc@?`¼Ñ 䂨QƒT ê9§(÷1 hÔ„Ü@÷hûxòBe†P ,äˆê€N;]å6ˆ1äZ+ðF»|'\[CíúVê z+2LØÀh0ë=Ânô°  cWŠö4´É 2ðÏ‘ö\ãæ‹\ºlÓ¡¢ oª„zûSc_ÞV+ä÷ãoŸa¶šT(+P…o.ѧëFft4?=÷ š&emÌÜÅ/IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1fo__log-members.html0000644000263000017630000000356011433220722021476 0ustar jorismkyb libDAI: Member List

dai::fo_log< T > Member List

This is the complete list of members for dai::fo_log< T >, including all inherited members.

operator()(const T &x) const dai::fo_log< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1RegionGraph.html0000644000263000017630000015113411433220722020431 0ustar jorismkyb libDAI: dai::RegionGraph Class Reference

dai::RegionGraph Class Reference

A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph. More...

#include <dai/regiongraph.h>

Inheritance diagram for dai::RegionGraph:

dai::FactorGraph dai::DAIAlg< dai::RegionGraph >

List of all members.

Input/output

virtual void ReadFromFile (const char *)
 Reads a region graph from a file.
virtual void WriteToFile (const char *, size_t=15) const
 Writes a factor graph to a file.
virtual void printDot (std::ostream &) const
 Writes a region graph to a GraphViz .dot file.
std::ostream & operator<< (std::ostream &os, const RegionGraph &rg)
 Writes a RegionGraph to an output stream.

Public Member Functions

Constructors and destructors
 RegionGraph ()
 Default constructor.
 RegionGraph (const FactorGraph &fg, const std::vector< VarSet > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)
 Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions and a vector of edges.
 RegionGraph (const FactorGraph &fg, const std::vector< VarSet > &cl)
 Constructs a region graph from a factor graph and a vector of outer clusters (CVM style).
virtual RegionGraph * clone () const
 Clone *this (virtual copy constructor).
Accessors and mutators
size_t nrORs () const
 Returns number of outer regions.
size_t nrIRs () const
 Returns number of inner regions.
const FRegion & OR (size_t alpha) const
 Returns constant reference to outer region alpha.
FRegion & OR (size_t alpha)
 Returns reference to outer region alpha.
const Region & IR (size_t beta) const
 Returns constant reference to inner region beta.
Region & IR (size_t beta)
 Returns reference to inner region beta.
size_t fac2OR (size_t I) const
 Returns the index of the outer region to which the I 'th factor corresponds.
const Neighbors & nbOR (size_t alpha) const
 Returns constant reference to the neighbors of outer region alpha.
const Neighbors & nbIR (size_t beta) const
 Returns constant reference to the neighbors of inner region beta.
const BipartiteGraph & DAG () const
 Returns DAG structure of the region graph.
Queries
bool checkCountingNumbers () const
 Check whether the counting numbers are valid.
Operations
virtual void setFactor (size_t I, const Factor &newFactor, bool backup=false)
 Set the content of the I 'th factor and make a backup of its old content if backup == true.
virtual void setFactors (const std::map< size_t, Factor > &facs, bool backup=false)
 Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true.

Protected Member Functions

void construct (const FactorGraph &fg, const std::vector< VarSet > &ors, const std::vector< Region > &irs, const std::vector< std::pair< size_t, size_t > > &edges)
 Helper function for constructors.
void constructCVM (const FactorGraph &fg, const std::vector< VarSet > &cl, size_t verbose=0)
 Helper function for constructors (CVM style).
void recomputeORs ()
 Recompute all outer regions.
void recomputeORs (const VarSet &vs)
 Recompute all outer regions involving the variables in vs.
void recomputeOR (size_t I)
 Recompute all outer regions involving factor I.
void calcCVMCountingNumbers ()
 Calculates counting numbers of inner regions based upon counting numbers of outer regions.

Protected Attributes

BipartiteGraph _G
 Stores the neighborhood structure.
std::vector< FRegion > _ORs
 The outer regions (corresponding to nodes of type 1).
std::vector< Region > _IRs
 The inner regions (corresponding to nodes of type 2).
std::vector< size_t > _fac2OR
 Stores for each factor index the index of the outer region it belongs to.

Detailed Description

A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph.

A RegionGraph inherits from a FactorGraph and adds additional structure in the form of a "region graph". Our definition of region graph is inspired by [HAK03], which is less general than the definition given in [YFW05].

The extra structure described by a RegionGraph compared with that described by a FactorGraph is:

  • a set of outer regions (indexed by $\alpha$), where each outer region consists of
    • a factor defined on a subset of variables
    • a counting number
  • a set of inner regions (indexed by $\beta$), where each inner region consists of
    • a subset of variables
    • a counting number
  • edges between inner and outer regions

Each factor in the factor graph belongs to an outer region; normally, the factor contents of an outer region would be the product of all the factors that belong to that region.

Idea:
Generalize the definition of region graphs to the one given in [YFW05], i.e., replace the current implementation which uses a BipartiteGraph with one that uses a DAG.
Idea:
The outer regions are products of factors; right now, this product is constantly cached: changing one factor results in an update of all relevant outer regions. This may not be the most efficient approach; an alternative would be to only precompute the factor products at the start of an inference algorithm - e.g., in init(). This has the additional advantage that FactorGraph e can offer write access to its factors.

Constructor & Destructor Documentation

dai::RegionGraph::RegionGraph (  )  [inline]

Default constructor.

dai::RegionGraph::RegionGraph ( const FactorGraph &  fg,
const std::vector< VarSet > &  ors,
const std::vector< Region > &  irs,
const std::vector< std::pair< size_t, size_t > > &  edges 
) [inline]

Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions and a vector of edges.

The counting numbers for the outer regions are set to 1.

dai::RegionGraph::RegionGraph ( const FactorGraph &  fg,
const std::vector< VarSet > &  cl 
) [inline]

Constructs a region graph from a factor graph and a vector of outer clusters (CVM style).

The region graph is constructed as in the Cluster Variation Method.

The outer regions have as variable subsets the clusters specified in cl. Each factor in the factor graph fg is assigned to one of the outer regions. Each outer region gets counting number 1.

The inner regions are (repeated) intersections of outer regions. An inner and an outer region are connected if the variables in the inner region form a subset of the variables in the outer region. The counting numbers for the inner regions are calculated by calcCountingNumbers() and satisfy the Moebius formula.

Member Function Documentation

virtual RegionGraph* dai::RegionGraph::clone (  )  const [inline, virtual]

Clone *this (virtual copy constructor).

Reimplemented from dai::FactorGraph.

size_t dai::RegionGraph::nrORs (  )  const [inline]

Returns number of outer regions.

size_t dai::RegionGraph::nrIRs (  )  const [inline]

Returns number of inner regions.

const FRegion& dai::RegionGraph::OR ( size_t  alpha  )  const [inline]

Returns constant reference to outer region alpha.

FRegion& dai::RegionGraph::OR ( size_t  alpha  )  [inline]

Returns reference to outer region alpha.

const Region& dai::RegionGraph::IR ( size_t  beta  )  const [inline]

Returns constant reference to inner region beta.

Region& dai::RegionGraph::IR ( size_t  beta  )  [inline]

Returns reference to inner region beta.

size_t dai::RegionGraph::fac2OR ( size_t  I  )  const [inline]

Returns the index of the outer region to which the I 'th factor corresponds.

const Neighbors& dai::RegionGraph::nbOR ( size_t  alpha  )  const [inline]

Returns constant reference to the neighbors of outer region alpha.

const Neighbors& dai::RegionGraph::nbIR ( size_t  beta  )  const [inline]

Returns constant reference to the neighbors of inner region beta.

const BipartiteGraph& dai::RegionGraph::DAG (  )  const [inline]

Returns DAG structure of the region graph.

Note:
Currently, the DAG is implemented as a BipartiteGraph; the nodes of type 1 are the outer regions, the nodes of type 2 the inner regions, and edges correspond with arrows from nodes of type 1 to type 2.

bool dai::RegionGraph::checkCountingNumbers (  )  const

Check whether the counting numbers are valid.

Counting numbers are said to be (variable) valid if for each variable $x$,

\[\sum_{\alpha \ni x} c_\alpha + \sum_{\beta \ni x} c_\beta = 1\]

or in words, if the sum of the counting numbers of the regions that contain the variable equals one.

virtual void dai::RegionGraph::setFactor ( size_t  I,
const Factor &  newFactor,
bool  backup = false 
) [inline, virtual]

Set the content of the I 'th factor and make a backup of its old content if backup == true.

Reimplemented from dai::FactorGraph.

virtual void dai::RegionGraph::setFactors ( const std::map< size_t, Factor > &  facs,
bool  backup = false 
) [inline, virtual]

Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true.

Reimplemented from dai::FactorGraph.

virtual void dai::RegionGraph::ReadFromFile ( const char *   )  [inline, virtual]

Reads a region graph from a file.

Note:
Not implemented yet

Reimplemented from dai::FactorGraph.

virtual void dai::RegionGraph::WriteToFile ( const char *  ,
size_t  = 15 
) const [inline, virtual]

Writes a factor graph to a file.

Note:
Not implemented yet

Reimplemented from dai::FactorGraph.

virtual void dai::RegionGraph::printDot ( std::ostream &   )  const [inline, virtual]

Writes a region graph to a GraphViz .dot file.

Note:
Not implemented yet

Reimplemented from dai::FactorGraph.

void dai::RegionGraph::construct ( const FactorGraph &  fg,
const std::vector< VarSet > &  ors,
const std::vector< Region > &  irs,
const std::vector< std::pair< size_t, size_t > > &  edges 
) [protected]

Helper function for constructors.

void dai::RegionGraph::constructCVM ( const FactorGraph &  fg,
const std::vector< VarSet > &  cl,
size_t  verbose = 0 
) [protected]

Helper function for constructors (CVM style).

void dai::RegionGraph::recomputeORs (  )  [protected]

Recompute all outer regions.

The factor contents of each outer region is set to the product of the factors belonging to that region.

void dai::RegionGraph::recomputeORs ( const VarSet &  vs  )  [protected]

Recompute all outer regions involving the variables in vs.

The factor contents of each outer region involving at least one of the variables in vs is set to the product of the factors belonging to that region.

void dai::RegionGraph::recomputeOR ( size_t  I  )  [protected]

Recompute all outer regions involving factor I.

The factor contents of each outer region involving the I 'th factor is set to the product of the factors belonging to that region.

void dai::RegionGraph::calcCVMCountingNumbers (  )  [protected]

Calculates counting numbers of inner regions based upon counting numbers of outer regions.

The counting numbers of the inner regions are set using the Moebius inversion formula:

\[ c_\beta := 1 - \sum_{\gamma \in \mathrm{an}(\beta)} c_\gamma \]

where $\mathrm{an}(\beta)$ are the ancestors of inner region $\beta$ according to the partial ordering induced by the subset relation (i.e., a region is a child of another region if its variables are a subset of the variables of its parent region).

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const RegionGraph &  rg 
) [friend]

Writes a RegionGraph to an output stream.

Member Data Documentation

BipartiteGraph dai::RegionGraph::_G [protected]

Stores the neighborhood structure.

Reimplemented from dai::FactorGraph.

std::vector<FRegion> dai::RegionGraph::_ORs [protected]

The outer regions (corresponding to nodes of type 1).

std::vector<Region> dai::RegionGraph::_IRs [protected]

The inner regions (corresponding to nodes of type 2).

std::vector<size_t> dai::RegionGraph::_fac2OR [protected]

Stores for each factor index the index of the outer region it belongs to.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x6f.html0000644000263000017630000003625111433220722016735 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- o -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x63.html0000644000263000017630000001072011433220722017676 0ustar jorismkyb libDAI: Class Members - Variables
 

- c -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1CBP_1_1Properties.html0000644000263000017630000007223011433220722021563 0ustar jorismkyb libDAI: dai::CBP::Properties Struct Reference

dai::CBP::Properties Struct Reference

Parameters for CBP. More...

#include <dai/cbp.h>

List of all members.

Public Types

typedef BP::Properties::UpdateType UpdateType
 Enumeration of possible update schedules.

Public Member Functions

 DAI_ENUM (RecurseType, REC_FIXED, REC_LOGZ, REC_BDIFF)
 Enumeration of possible methods for deciding when to stop recursing.
 DAI_ENUM (ChooseMethodType, CHOOSE_RANDOM, CHOOSE_MAXENT, CHOOSE_BBP, CHOOSE_BP_L1, CHOOSE_BP_CFN)
 Enumeration of possible heuristics for choosing clamping variable.
 DAI_ENUM (ClampType, CLAMP_VAR, CLAMP_FACTOR)
 Enumeration of possible clampings: variables or factors.
void set (const PropertySet &opts)
 Set members from PropertySet.
PropertySet get () const
 Get members into PropertySet.
std::string toString () const
 Convert to a string which can be parsed as a PropertySet.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
Real tol
 Tolerance for BP convergence test.
UpdateType updates
 Update style for BP.
size_t maxiter
 Maximum number of iterations for BP.
Real rec_tol
 Tolerance used for controlling recursion depth (recurse is REC_LOGZ or REC_BDIFF).
size_t max_levels
 Maximum number of levels of recursion (recurse is REC_FIXED).
Real min_max_adj
 If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse.
ChooseMethodType choose
 Heuristic for choosing clamping variable.
RecurseType recursion
 Method for deciding when to stop recursing.
ClampType clamp
 Whether to clamp variables or factors.
PropertySet bbp_props
 Properties to pass to BBP.
BBPCostFunction bbp_cfn
 Cost function to use for BBP.
size_t rand_seed
 Random seed.
std::string clamp_outfile
 If non-empty, write clamping choices to this file.

Detailed Description

Parameters for CBP.

Member Typedef Documentation

typedef BP::Properties::UpdateType dai::CBP::Properties::UpdateType

Enumeration of possible update schedules.

Member Function Documentation

dai::CBP::Properties::DAI_ENUM ( RecurseType  ,
REC_FIXED  ,
REC_LOGZ  ,
REC_BDIFF   
)

Enumeration of possible methods for deciding when to stop recursing.

dai::CBP::Properties::DAI_ENUM ( ChooseMethodType  ,
CHOOSE_RANDOM  ,
CHOOSE_MAXENT  ,
CHOOSE_BBP  ,
CHOOSE_BP_L1  ,
CHOOSE_BP_CFN   
)

Enumeration of possible heuristics for choosing clamping variable.

dai::CBP::Properties::DAI_ENUM ( ClampType  ,
CLAMP_VAR  ,
CLAMP_FACTOR   
)

Enumeration of possible clampings: variables or factors.

void dai::CBP::Properties::set ( const PropertySet &  opts  ) 

Set members from PropertySet.

Exceptions:
UNKNOWN_PROPERTY if a Property key is not recognized
NOT_ALL_PROPERTIES_SPECIFIED if an expected Property is missing

PropertySet dai::CBP::Properties::get (  )  const

Get members into PropertySet.

string dai::CBP::Properties::toString (  )  const

Convert to a string which can be parsed as a PropertySet.

Member Data Documentation

size_t dai::CBP::Properties::verbose

Verbosity (amount of output sent to stderr).

Real dai::CBP::Properties::tol

Tolerance for BP convergence test.

UpdateType dai::CBP::Properties::updates

Update style for BP.

size_t dai::CBP::Properties::maxiter

Maximum number of iterations for BP.

Real dai::CBP::Properties::rec_tol

Tolerance used for controlling recursion depth (recurse is REC_LOGZ or REC_BDIFF).

size_t dai::CBP::Properties::max_levels

Maximum number of levels of recursion (recurse is REC_FIXED).

Real dai::CBP::Properties::min_max_adj

If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse.

ChooseMethodType dai::CBP::Properties::choose

Heuristic for choosing clamping variable.

RecurseType dai::CBP::Properties::recursion

Method for deciding when to stop recursing.

ClampType dai::CBP::Properties::clamp

Whether to clamp variables or factors.

PropertySet dai::CBP::Properties::bbp_props

Properties to pass to BBP.

BBPCostFunction dai::CBP::Properties::bbp_cfn

Cost function to use for BBP.

size_t dai::CBP::Properties::rand_seed

Random seed.

std::string dai::CBP::Properties::clamp_outfile

If non-empty, write clamping choices to this file.

The documentation for this struct was generated from the following files:
  • include/dai/cbp.h
  • src/cbp.cpp
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/clustergraph_8h.html0000644000263000017630000001463511433220722017166 0ustar jorismkyb libDAI: include/dai/clustergraph.h File Reference

include/dai/clustergraph.h File Reference

Defines class ClusterGraph, which is used by JTree, TreeEP and HAK. More...

#include <set>
#include <vector>
#include <dai/varset.h>
#include <dai/bipgraph.h>
#include <dai/factorgraph.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::ClusterGraph
 A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges. More...
class  dai::sequentialVariableElimination
 Helper object for dai::ClusterGraph::VarElim(). More...
class  dai::greedyVariableElimination
 Helper object for dai::ClusterGraph::VarElim(). More...

Functions

size_t dai::eliminationCost_MinNeighbors (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinNeighbors" criterion.
size_t dai::eliminationCost_MinWeight (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinWeight" criterion.
size_t dai::eliminationCost_MinFill (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "MinFill" criterion.
size_t dai::eliminationCost_WeightedMinFill (const ClusterGraph &cl, size_t i)
 Calculates cost of eliminating the i 'th variable from cluster graph cl according to the "WeightedMinFill" criterion.

Detailed Description

Defines class ClusterGraph, which is used by JTree, TreeEP and HAK.

Todo:
The "MinFill" and "WeightedMinFill" variable elimination heuristics seem designed for Markov graphs; add similar heuristics which are designed for factor graphs.
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/gibbs_8h.html0000644000263000017630000000573111433220722015546 0ustar jorismkyb libDAI: include/dai/gibbs.h File Reference

include/dai/gibbs.h File Reference

Defines class Gibbs, which implements Gibbs sampling. More...

#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Gibbs
 Approximate inference algorithm "Gibbs sampling". More...
struct  dai::Gibbs::Properties
 Parameters for Gibbs. More...

Detailed Description

Defines class Gibbs, which implements Gibbs sampling.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_79.png0000644000263000017630000000210611433220722015154 0ustar jorismkyb‰PNG  IHDR"Ý{º0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÄIDATX…íWMˆGþº«g¦gž©Ñ,^¶¨›‹‡c&½‰k î€Yôb:íD–À„‰dÛ’UDÛC@oBÅCp!$à­sÉ1ÎEð¹…Ì‚+DæUÿMõÚ“ÍE›Lu½î÷Þ÷Õ{Õõz€çò¿}6»h"‘(ï†Û}Mu+ê)hv¢ŒdŸíÊqoL‰Ñ²"; ¯œEôÕàÅþòp.ŸNýÖ¤J•g°æ%»ÄýÕp<±*roö¹_ë ù}uG>ðIª0_ƪȵ‹ÝË¿z© ;Bàcè(¼ÔW«ôŽ¾HסÛÐ.X¨Óô=úMl>% 4bW?ÇÔ÷‡£8‹2–Á1òÑD²_à©É[Jøy\•ÖâÇtÈs[—à]ÔhúmEÖ[ŽÃ…©˜âèâc:$‚@Æ2 Ø·?‹#ÖâëoôÛÔškÑ‚–Ù¢¹‚ŽzÖB…ª½®Erœ§t øÐ`Dû¨Äº4~‘á¼H‰mXP7A‰’°êäõ °ÕÇkVâ±ÀÝîO®µWñÓyiM½Co‡Krª_,ƱA¢Ý£áËÄ·Â 5b «ÝÔGâÎzHÈz5Ú\kóé¨m †kA§æ ùªÈÎÁûtnˆlo$;òãz#,Šeî„f-± ¨¬Ë°¹«}%Š—æS:XØ'äÒQfLöÈJö›"Ÿ†y˜,{3‡çaЭ‡À™ &­ÉNŒÄnü÷?-EYëÊX5Þxs~΂MȈ€«>M¼ô›ré0×Ò\{¯TKÚ©#“XÏQù슉=tëu`ýèaÙH£|¸82< Ã*Cód¬²Snïçè\²ˆóžXÿ0ª™¨B™ÏÊ‘ršÄ´|R„ûLKÕ‹Èíy …Ó>ˆg)VäâeA2¯J ™9t2)¤³-^Ñb‡k4°0ÆØ®vÿL‹°¶‡Žm^jçºóŒ¶Z =–i,Z¾QòåD³³Xp€»$uAçÏÁtž­è×Ïáôã‡vÑD"QšMú,šÇsùO‰zj l™+â…œ®ñÕž¢ôpÙõ¼ª8ѧ,­Ø7,ÐÍðK!¤3í¬ëJ§êÔZ-êy/¾J§nÖ\—z^…ZÞ9uô¦Þ)”Ž1.Šµß°ïwx:¿—~u#ª…“³x{ÌAi[lþŠ](!E4‡¿ü²ùò¨6ˆIEND®B`‚libDAI-0.2.7/doc/html/io_8h.html0000644000263000017630000000641511433220722015067 0ustar jorismkyb libDAI: include/dai/io.h File Reference

include/dai/io.h File Reference

Provides functionality for input/output of data structures in various file formats. More...

#include <dai/factor.h>
#include <vector>
#include <map>

Go to the source code of this file.

Namespaces

namespace  dai

Functions

void dai::ReadUaiAieFactorGraphFile (const char *filename, size_t verbose, std::vector< Var > &vars, std::vector< Factor > &factors, std::vector< Permute > &permutations)
 Reads factor graph (as a pair of a variable vector and factor vector) from a file in the UAI approximate inference challenge format.
std::vector< std::map< size_t,
size_t > > 		dai::ReadUaiAieEvidenceFile (const char *filename, size_t verbose)
 Reads evidence (a mapping from observed variable labels to the observed values) from a file in the UAI approximate inference challenge format.

Detailed Description

Provides functionality for input/output of data structures in various file formats.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/index_8h.html0000644000263000017630000000767311433220722015576 0ustar jorismkyb libDAI: include/dai/index.h File Reference

include/dai/index.h File Reference

Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays. More...

#include <vector>
#include <algorithm>
#include <map>
#include <dai/varset.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::IndexFor
 Tool for looping over the states of several variables. More...
class  dai::Permute
 Tool for calculating permutations of linear indices of multi-dimensional arrays. More...
class  dai::multifor
 multifor makes it easy to perform a dynamic number of nested for loops. More...
class  dai::State
 Makes it easy to iterate over all possible joint states of variables within a VarSet. More...

Detailed Description

Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/prob_8h-source.html0000644000263000017630000031443111433220722016720 0ustar jorismkyb libDAI: include/dai/prob.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1FBP.png0000644000263000017630000000115211433220722016445 0ustar jorismkyb‰PNG  IHDRÀß¡€PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfIDAThíÙArƒ0 PØttùöB]åþG(’°‘lö<¸ü¼ø¸\^ œà*8à€8ðf€çÆÓ”6 wÔh–Ts "^ƒ½ï·€®1ñ*,òž¬LtQ`Ž"¤´¾ªRLÁˆÜ’CŒ8šñâŸ%B Ðú`ø\g´ å %=X}8˜˜Â¢/ÏÈÈ€:T„ ™ALy1,Æ,MŒ€`‰),’ž?-€ž²é^Òá€`Â"`dïƒ{µ‘õLí›a±Ø ‹MÀN9à¹ñ)€çFpÀÞðÜxf ’PºçÞ¤P‚GᮿdQòGÉCÀ%õ ’TøÁu°Ið}Àu”ljËxn|8à¹ÑpÀ÷ ¯¦aꛡe`L›¹Ó7›×V`Áë(k=ã0‚qàgFYŽŒgýküg@÷×úF]¶&<¸~?¸\¯ONppÀx3Àsãi*;;j4ÏRc "Þ’½ï·€Î1ñ&,òH6L&º(0FRZßÕ%¦`FîI‡)GÍxù!A‰Ð$´ÌÀy@ÓTRÒƒ Ðà 0€ÄÄõõò™™P§ŠP4+È)/‡Å¼‚©‰°+Ì1±„EÒó§ ÐS6=Ы@:°LX¬€êsð[-d=S›ÀbXÜ,†Å]ÀF9à¹ñOÏ8à€¼à¹ñÌ@%aíž{B +wý«@%u”<ÌQòPê(I+ÿpÝl<@p%÷­åÀ‹žxntÀpàýè«8ľ:° ļã&kŸÇGxk¤Â ºm!Æ!_ÝC@ ã¼À“cdÔð‘PVÀ=c Í=à#ã¼ù2 +h‚YA,J3:½ Ñ6QîA °³x ÷ký÷ÿ‘ì‰æLIEND®B`‚libDAI-0.2.7/doc/html/functions_type.html0000644000263000017630000001252511433220722017131 0ustar jorismkyb libDAI: Class Members - Typedefs
 

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/namespacemembers.html0000644000263000017630000002630011433220722017363 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented namespace members with links to the namespaces they belong to:

- _ -

  • _normal_dist : dai
  • _normal_rnd() : dai
  • _rnd_gen() : dai
  • _rnd_gen_type : dai
  • _uni_dist() : dai
  • _uni_rnd() : dai

- a -

- c -

  • calcLinearState() : dai
  • calcMarginal() : dai
  • calcPairBeliefs() : dai
  • calcState() : dai
  • complement() : dai
  • concat() : dai
  • createFactorDelta() : dai
  • createFactorExpGauss() : dai
  • createFactorIsing() : dai
  • createFactorPotts() : dai
  • createGraphFull() : dai
  • createGraphGrid() : dai
  • createGraphGrid3D() : dai
  • createGraphLoop() : dai
  • createGraphRegular() : dai
  • createGraphTree() : dai

- d -

  • DAI_ENUM() : dai
  • DAIAlgFG : dai
  • DAIAlgRG : dai
  • DAINames : dai
  • dist() : dai

- e -

  • Edge : dai
  • eliminationCost_MinFill() : dai
  • eliminationCost_MinNeighbors() : dai
  • eliminationCost_MinWeight() : dai
  • eliminationCost_WeightedMinFill() : dai
  • exp() : dai

- f -

  • Factor : dai
  • Factors2mx() : dai
  • findMaximum() : dai
  • fromString() : dai

- g -

  • getFactorEntryForState() : dai

- i -

  • isnan() : dai

- l -

- m -

  • makePositive() : dai
  • makeZero() : dai
  • MaxSpanningTree() : dai
  • MinSpanningTree() : dai
  • mixBeliefs() : dai
  • mx2Factor() : dai
  • mx2Factors() : dai

- n -

  • Neighbors : dai
  • newInfAlg() : dai
  • newInfAlgFromString() : dai

- o -

  • operator<<() : dai
  • operator>>() : dai

- p -

  • parseNameProperties() : dai
  • pow() : dai
  • Prob : dai
  • ProbDistType : dai
  • ProbNormType : dai
  • Property : dai
  • PropertyKey : dai
  • PropertyValue : dai

- r -

  • readAliasesFile() : dai
  • ReadUaiAieEvidenceFile() : dai
  • ReadUaiAieFactorGraphFile() : dai
  • Real : dai
  • rnd() : dai
  • rnd_int() : dai
  • rnd_seed() : dai
  • rnd_stdnormal() : dai
  • rnd_uniform() : dai

- t -

  • toc() : dai
  • tokenizeString() : dai
  • toString() : dai

- u -

  • unSoftMax() : dai
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_36.png0000644000263000017630000000031611433220722015146 0ustar jorismkyb‰PNG  IHDR <ð0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfLIDAT™c`@ÌP›Ž×«€_Ì!”g`¨€°¢ƒhÆËØ08000}Étf>À¼"ÏQÂÕÎXcÕl†[$ȵ⠬ÐHCIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1TRWBP.html0000644000263000017630000011132711433220722017122 0ustar jorismkyb libDAI: dai::TRWBP Class Reference

dai::TRWBP Class Reference

Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]. More...

#include <dai/trwbp.h>

Inheritance diagram for dai::TRWBP:

dai::BP dai::DAIAlg< GRM > dai::InfAlg

List of all members.

TRWBP accessors/mutators for scale parameters

Real Weight (size_t I) const
 Returns weight corresponding to the I 'th factor.
const std::vector< Real > & Weights () const
 Returns constant reference to vector of all weights.
void setWeight (size_t I, Real c)
 Sets the weight of the I 'th factor to c.
void setWeights (const std::vector< Real > &c)
 Sets the weights of all factors simultaenously.
void addTreeToWeights (const RootedTree &tree)
 Increases weights corresponding to pairwise factors in tree with 1.
void sampleWeights (size_t nrTrees)
 Samples weights from a sample of nrTrees random spanning trees.
virtual Prob calcIncomingMessageProduct (size_t I, bool without_i, size_t i) const
 Calculate the product of factor I and the incoming messages.
virtual void calcBeliefV (size_t i, Prob &p) const
 Calculates unnormalized belief of variable i.
virtual void calcBeliefF (size_t I, Prob &p) const
 Calculates unnormalized belief of factor I.
virtual void construct ()
 Helper function for constructors.

Public Member Functions

Constructors/destructors
 TRWBP ()
 Default constructor.
 TRWBP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual TRWBP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

size_t nrtrees
 Size of sample of trees used to set the weights.

Static Public Attributes

static const char * Name = "TRWBP"
 Name of this inference algorithm.

Protected Attributes

std::vector< Real > _weight
 "Edge weights" (indexed by factor ID)

Detailed Description

Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03].

The Tree-Reweighted Belief Propagation algorithm is like Belief Propagation, but associates each factor with a scale parameter. which controls the divergence measure being minimized.

The messages $m_{I\to i}(x_i)$ are passed from factors $I$ to variables $i$. The update equation is given by:

\[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \]

After convergence, the variable beliefs are calculated by:

\[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}^{c_I} \]

and the factor beliefs are calculated by:

\[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \]

The logarithm of the partition sum is approximated by:

\[ \log Z = \sum_{I} \sum_{x_I} b_I(x_I) \big( \log f_I(x_I) - c_I \log b_I(x_I) \big) + \sum_{i} (c_i - 1) \sum_{x_i} b_i(x_i) \log b_i(x_i) \]

where the variable weights are defined as

\[ c_i := \sum_{I \in N_i} c_I \]

Note:
TRWBP is actually equivalent to FBP
Todo:
Merge code of FBP and TRWBP

Constructor & Destructor Documentation

dai::TRWBP::TRWBP (  )  [inline]

Default constructor.

dai::TRWBP::TRWBP ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

There is an additional property "nrtrees" which allows to specify the number of random spanning trees used to set the scale parameters.

Parameters:
fg Factor graph.
opts Parameters
See also:
BP::Properties.

Member Function Documentation

virtual TRWBP* dai::TRWBP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Reimplemented from dai::BP.

string dai::TRWBP::identify (  )  const [virtual]

Identifies itself for logging purposes.

Reimplemented from dai::BP.

Real dai::TRWBP::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::BP.

void dai::TRWBP::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Reimplemented from dai::BP.

PropertySet dai::TRWBP::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Reimplemented from dai::BP.

string dai::TRWBP::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Reimplemented from dai::BP.

Real dai::TRWBP::Weight ( size_t  I  )  const [inline]

Returns weight corresponding to the I 'th factor.

const std::vector<Real>& dai::TRWBP::Weights (  )  const [inline]

Returns constant reference to vector of all weights.

void dai::TRWBP::setWeight ( size_t  I,
Real  c 
) [inline]

Sets the weight of the I 'th factor to c.

void dai::TRWBP::setWeights ( const std::vector< Real > &  c  )  [inline]

Sets the weights of all factors simultaenously.

Note:
Faster than calling setWeight(size_t,Real) for each factor

void dai::TRWBP::addTreeToWeights ( const RootedTree &  tree  ) 

Increases weights corresponding to pairwise factors in tree with 1.

void dai::TRWBP::sampleWeights ( size_t  nrTrees  ) 

Samples weights from a sample of nrTrees random spanning trees.

Prob dai::TRWBP::calcIncomingMessageProduct ( size_t  I,
bool  without_i,
size_t  i 
) const [protected, virtual]

Calculate the product of factor I and the incoming messages.

If without_i == true, the message coming from variable i is omitted from the product

Note:
This function is used by calcNewMessage() and calcBeliefF()

Reimplemented from dai::BP.

void dai::TRWBP::calcBeliefV ( size_t  i,
Prob &  p 
) const [protected, virtual]

Calculates unnormalized belief of variable i.

Reimplemented from dai::BP.

virtual void dai::TRWBP::calcBeliefF ( size_t  I,
Prob &  p 
) const [inline, protected, virtual]

Calculates unnormalized belief of factor I.

Reimplemented from dai::BP.

void dai::TRWBP::construct (  )  [protected, virtual]

Helper function for constructors.

Reimplemented from dai::BP.

Member Data Documentation

std::vector<Real> dai::TRWBP::_weight [protected]

"Edge weights" (indexed by factor ID)

In [WJW03], only unary or pairwise factors are considered. Here we are more general by having a weight for each factor in the factor graph. If unary factors have weight 1, and higher-order factors are absent, then we have the special case considered in [WJW03].

size_t dai::TRWBP::nrtrees

Size of sample of trees used to set the weights.

Todo:
See if there is a way to wrap TRWBP::nrtrees in a props struct together with the other properties currently in TRWBP::props (without copying al lot of BP code literally)

const char * dai::TRWBP::Name = "TRWBP" [static]

Name of this inference algorithm.

Reimplemented from dai::BP.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x64.html0000644000263000017630000002145211433220722016650 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- d -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1JTree.html0000644000263000017630000016077311433220722017246 0ustar jorismkyb libDAI: dai::JTree Class Reference

dai::JTree Class Reference

Exact inference algorithm using junction tree. More...

#include <dai/jtree.h>

Inheritance diagram for dai::JTree:

dai::DAIAlg< GRM > dai::InfAlg dai::TreeEP

List of all members.

Public Member Functions

Constructors/destructors
 JTree ()
 Default constructor.
 JTree (const FactorGraph &fg, const PropertySet &opts, bool automatic=true)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual JTree * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
std::vector< std::size_t > findMaximum () const
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for JTree
void construct (const FactorGraph &fg, const std::vector< VarSet > &cl, bool verify=false)
 Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence).
void GenerateJT (const FactorGraph &fg, const std::vector< VarSet > &cl)
 Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence).
const Factor & message (size_t alpha, size_t _beta) const
 Returns constant reference to the message from outer region alpha to its _beta 'th neighboring inner region.
Factor & message (size_t alpha, size_t _beta)
 Returns reference to the message from outer region alpha to its _beta 'th neighboring inner region.
void runHUGIN ()
 Runs junction tree algorithm using HUGIN (message-free) updates.
void runShaferShenoy ()
 Runs junction tree algorithm using Shafer-Shenoy updates.
size_t findEfficientTree (const VarSet &vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1) const
 Finds an efficient subtree for calculating the marginal of the variables in vs.
Factor calcMarginal (const VarSet &vs)
 Calculates the marginal of a set of variables (using cutset conditioning, if necessary).

Public Attributes

RootedTree RTree
 The junction tree (stored as a rooted tree).
std::vector< Factor > Qa
 Outer region beliefs.
std::vector< Factor > Qb
 Inner region beliefs.
struct dai::JTree::Properties props

Static Public Attributes

static const char * Name = "JTREE"
 Name of this inference algorithm.

Private Attributes

std::vector< std::vector
< Factor > > 		_mes
 Stores the messages.
Real _logZ
 Stores the logarithm of the partition sum.

Related Functions

(Note that these are not member functions.)

std::pair< size_t, long double > boundTreewidth (const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates=0)
 Calculates upper bound to the treewidth of a FactorGraph, using the specified heuristic.

Classes

struct  Properties
 Parameters for JTree. More...

Detailed Description

Exact inference algorithm using junction tree.

The junction tree algorithm uses message passing on a junction tree to calculate exact marginal probability distributions ("beliefs") for specified cliques (outer regions) and separators (intersections of pairs of cliques).

There are two variants, the sum-product algorithm (corresponding to finite temperature) and the max-product algorithm (corresponding to zero temperature).

Examples:

example.cpp.

Constructor & Destructor Documentation

dai::JTree::JTree (  )  [inline]

Default constructor.

dai::JTree::JTree ( const FactorGraph &  fg,
const PropertySet &  opts,
bool  automatic = true 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg factor graph
opts Parameters
See also:
Properties
Parameters:
automatic if true, construct the junction tree automatically, using the heuristic in opts['heuristic'].

Member Function Documentation

virtual JTree* dai::JTree::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

string dai::JTree::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Factor dai::JTree::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Examples:
example.cpp.

vector< Factor > dai::JTree::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

Real dai::JTree::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Examples:
example.cpp.

std::vector<std::size_t> dai::JTree::findMaximum (  )  const [inline, virtual]

Precondition:
Assumes that run() has been called and that props.inference == MAXPROD

Reimplemented from dai::InfAlg.

Examples:
example.cpp.

virtual void dai::JTree::init (  )  [inline, virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Examples:
example.cpp.

virtual void dai::JTree::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Real dai::JTree::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Examples:
example.cpp.

virtual Real dai::JTree::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

Reimplemented in dai::TreeEP.

virtual size_t dai::JTree::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

Reimplemented in dai::TreeEP.

void dai::JTree::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

PropertySet dai::JTree::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

string dai::JTree::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

void dai::JTree::construct ( const FactorGraph &  fg,
const std::vector< VarSet > &  cl,
bool  verify = false 
)

Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence).

First, constructs a weighted graph, where the nodes are the elements of cl, and each edge is weighted with the cardinality of the intersection of the state spaces of the nodes. Then, a maximal spanning tree for this weighted graph is calculated. Subsequently, a corresponding region graph is built:

  • the outer regions correspond with the cliques and have counting number 1;
  • the inner regions correspond with the seperators, i.e., the intersections of two cliques that are neighbors in the spanning tree, and have counting number -1 (except empty ones, which have counting number 0);
  • inner and outer regions are connected by an edge if the inner region is a seperator for the outer region. Finally, Beliefs are constructed. If verify == true, checks whether each factor is subsumed by a clique.

void dai::JTree::GenerateJT ( const FactorGraph &  fg,
const std::vector< VarSet > &  cl 
)

Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence).

Invokes construct() and then constructs messages.

See also:
construct()

const Factor& dai::JTree::message ( size_t  alpha,
size_t  _beta 
) const [inline]

Returns constant reference to the message from outer region alpha to its _beta 'th neighboring inner region.

Factor& dai::JTree::message ( size_t  alpha,
size_t  _beta 
) [inline]

Returns reference to the message from outer region alpha to its _beta 'th neighboring inner region.

void dai::JTree::runHUGIN (  ) 

Runs junction tree algorithm using HUGIN (message-free) updates.

Note:
The initial messages may be arbitrary; actually they are not used at all.

void dai::JTree::runShaferShenoy (  ) 

Runs junction tree algorithm using Shafer-Shenoy updates.

Note:
The initial messages may be arbitrary.

size_t dai::JTree::findEfficientTree ( const VarSet &  vs,
RootedTree &  Tree,
size_t  PreviousRoot = (size_t)-1 
) const

Finds an efficient subtree for calculating the marginal of the variables in vs.

First, the current junction tree is reordered such that it gets as root the clique that has maximal state space overlap with vs. Then, the minimal subtree (starting from the root) is identified that contains all the variables in vs and also the outer region with index PreviousRoot (if specified). Finally, the current junction tree is reordered such that this minimal subtree comes before the other edges, and the size of the minimal subtree is returned.

Factor dai::JTree::calcMarginal ( const VarSet &  vs  ) 

Calculates the marginal of a set of variables (using cutset conditioning, if necessary).

Precondition:
assumes that run() has been called already

Friends And Related Function Documentation

std::pair< size_t, long double > boundTreewidth ( const FactorGraph &  fg,
greedyVariableElimination::eliminationCostFunction  fn,
size_t  maxStates = 0 
) [related]

Calculates upper bound to the treewidth of a FactorGraph, using the specified heuristic.

Parameters:
fg the factor graph for which the treewidth should be bounded
fn the heuristic cost function used for greedy variable elimination
maxStates maximum total number of states in outer regions of junction tree (0 means no limit)
Exceptions:
OUT_OF_MEMORY if the total number of states becomes larger than maxStates
Returns:
a pair (number of variables in largest clique, number of states in largest clique)

Member Data Documentation

std::vector<std::vector<Factor> > dai::JTree::_mes [private]

Stores the messages.

Real dai::JTree::_logZ [private]

Stores the logarithm of the partition sum.

RootedTree dai::JTree::RTree

The junction tree (stored as a rooted tree).

std::vector<Factor> dai::JTree::Qa

Outer region beliefs.

std::vector<Factor> dai::JTree::Qb

Inner region beliefs.

const char * dai::JTree::Name = "JTREE" [static]

Name of this inference algorithm.

Reimplemented in dai::TreeEP.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BBP_1_1Properties.html0000644000263000017630000003577211433220722021574 0ustar jorismkyb libDAI: dai::BBP::Properties Struct Reference

dai::BBP::Properties Struct Reference

Parameters for BBP. More...

#include <dai/bbp.h>

List of all members.

Public Member Functions

 DAI_ENUM (UpdateType, SEQ_FIX, SEQ_MAX, SEQ_BP_REV, SEQ_BP_FWD, PAR)
 Enumeration of possible update schedules.
void set (const PropertySet &opts)
 Set members from PropertySet.
PropertySet get () const
 Get members into PropertySet.
std::string toString () const
 Convert to a string which can be parsed as a PropertySet.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
Real tol
 Tolerance for convergence test.
Real damping
 Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [EaG09].
UpdateType updates
 Update schedule.

Detailed Description

Parameters for BBP.

Member Function Documentation

dai::BBP::Properties::DAI_ENUM ( UpdateType  ,
SEQ_FIX  ,
SEQ_MAX  ,
SEQ_BP_REV  ,
SEQ_BP_FWD  ,
PAR   
)

Enumeration of possible update schedules.

The following update schedules are defined:

  • SEQ_FIX fixed sequential updates
  • SEQ_MAX maximum residual updates (inspired by [EMK06])
  • SEQ_BP_REV schedule used by BP, but reversed
  • SEQ_BP_FWD schedule used by BP
  • PAR parallel updates

void dai::BBP::Properties::set ( const PropertySet &  opts  ) 

Set members from PropertySet.

Exceptions:
UNKNOWN_PROPERTY if a Property key is not recognized
NOT_ALL_PROPERTIES_SPECIFIED if an expected Property is missing

PropertySet dai::BBP::Properties::get (  )  const

Get members into PropertySet.

string dai::BBP::Properties::toString (  )  const

Convert to a string which can be parsed as a PropertySet.

Member Data Documentation

size_t dai::BBP::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::BBP::Properties::maxiter

Maximum number of iterations.

Real dai::BBP::Properties::tol

Tolerance for convergence test.

Note:
Not used for updates = SEQ_BP_REV, SEQ_BP_FWD

Real dai::BBP::Properties::damping

Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [EaG09].

UpdateType dai::BBP::Properties::updates

Update schedule.

The documentation for this struct was generated from the following files:
  • include/dai/bbp.h
  • src/bbp.cpp
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x6e.html0000644000263000017630000002316311433220722016732 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- n -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_34.png0000644000263000017630000000102011433220722015135 0ustar jorismkyb‰PNG  IHDRˆ?¡*O0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfŽIDAT8µ’?H1Æ¿Ü]¯g[ì•‚.Š ž‹“b¡*èÔM¡§´“Eu±êtˆKÑ¡ ºXÝ„‚N.Š‚â tÐÙ¥³¹%¶çpƒÉËË—Ç/äà$P?Õš›,ð.yöuå˜s%ið®RöQJöÚÑðr}BR¯­®&6·q¢ÁC¢Û ’¿cᚃȉÃÙ “Gï^ÅÛÓ_™î²¸DŠLi ¢#íJ.;5bmOI·1‚¨gå 3“ª–Ñ[üäÏÏØìÖm ŒˆÇƒH A ‚jF+–½Í”Ây Ü8Õ!Qç4Ù+j7ˆ1Y$•UÖ9ÉÀtTÍ'0A±\™ƒ<‚TÐÒõN®'ç†tÏ’÷¥$|çRbE¸@ Žù¹,-†CàÅ„ Mík£|c[d»Ê6$T< k$®$nÅBr6÷$hýX²jBtËA€¢Ÿ+±ín:b"—Ô^UÁõÞ* \‰›„udøƒvÅ<ÓV©lþŠ>T'Õ=IEND®B`‚libDAI-0.2.7/doc/html/form_103.png0000644000263000017630000000116311433220722015222 0ustar jorismkyb‰PNG  IHDRr#º!C0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfñIDAT8Ý”?hÕ@Ç¿É%//¦I ÕõlÅVpˆÑW[útV MA(:E,)ćí*dQRºt-|ƒ£Cë("Yt.8¸ºt ëæówÉ«}äé½ÁÁä{ùÝÝç~¿ÜïrÀc,),–G¯5]×]óÚN§eU‚;*OÁP),ëjBå¥D b YW šQùaEØ­$Æ¢BR@åÅ&˜˜PãßeMÔt‰‰Ñ?îŠ1JÔzéiïîÙ‘®ýRæÞ3çì9çë}ôÎ @UyšÙø"¾â_*¾áâÈêN²ðRn›A*<ÊMÇI1(‹/kÉ)™LšKYhÊdöN$Êp>j--:ŸòyÀê‰D¹x_Ò÷Fm}ÓA|žù–‘_Zx\[tßRi ®gÿÈ!\*e9zùt éÏþÍÓ×!þFŠÎ!žRB—e\u¢©dòÁ²\53KõKyc¨yÿl‘MTRY•”åÉ{j»¸A±à͵WmWYÉ=d_–²rfJ]5öÕVH¥#¤]ºyÀRn°Æ'¹ñÁ/ p4o Û5I× t¹ÇQ…¥¼ 9®9^gü¼×®-L¸5á¿Êi{q\÷åsŽ*d°”Û~¨¯…ö”KýåÚ4c+ú¥­ Z¡”¢•°Qˆ‚b|³TŒÁv€h23YÊâáßa¬D5Ó×Ô¯Â0Oóh‘–ÁR,ŠŠa†”$d5/eܵO YhJ¬÷l¯ÐO¿#<“Á›"-[îB”…!-<ˆ•”›²˜„ jØ8ìWÚÿwƒdwåxO€}üº\~ ù0„fYñ`r̶„„u†r û qhõ0¨_ú gWzòÕìixýC‹5?õI" 0Ó‚"jU†²–Ûo*YD¹™´þ«yÙ©é ’®p›Ñ á;ÐH˜ ®±¬ƒ¶.Š{ŒZW?VUP ´ ^oÁ|3‘ y𬱵çQ_ßUc™ù´˜G •Žñ *‚†Œ‡€ç±B6õó0Íç¯/„ˤP¯¸ï¢>‡V½OR™ž•x½!úúÅÊ|\ò<0´8‘^ƒŸþÕшþå6NxµD‘âèå÷N}kNªï†m ÿÈûcyw $×nÓŸlüCh”ýŽ ÑåS&>@Þ#ÅãñNî›G±K@úúzõ¨|ßµò)+·zîŠL$ÊÂ9ÜÊwñ;ö&ÜÊ·ê~&5¾P{q+'¥yÇp+K©=>æ4Þ Ï+¸zº™2Ó—\n |eþ×4Ð@ 4ð¿Ãw4å5Zúáfd¬tI“ÝÊ9UJ¹W£e/³SæF@ºÖÍ?îXý²ÝAd÷¾|¶Jùiëwcs#^¸¹²qêF@°æ]!Í‹;V¿.xXld5áUªYp-¸—pÝ„ÌÓŠK€òKöWËy~y¿*.Çïp'Ü ³+r _(åVüZÊ£Œ˜îÃí7­‚˲Ù`,]ð(ßGÑEª>1º±*.ÇïèPïL=ðä…+·zð…PnZŽÏx”Á«k]Ú7âªcß³–ÑßÑ%‡òÒ©PeAW?x1¿*.ÇoM¬Éårï8®”T/š†»ò {B9"XÕÊm%š¢³I»ãF•†Þf-…7ñ™ ly¸åóa(ºȖš ˜–F}'ê‰;‰|ngý–cˆ¶«ÐKÞ£, f¯Bc³šš;œ;ˆâü‰wCˆ2»9]VBØÜ ;Äîd ¿¿Ïñ÷GÝ(q³j—mÙ¦ï†<²Ôt"œDÂ>ÀÂÖÜO9vbÌå~Ì!žG® ÊЬÃ2Xj«$ ^ ”QÜe°ºM÷ù\$ˆmMc{Ñ‘Édœ‰ÀØœ¤¹ª©°‚ú<¶•Gòeeä<e‚É>°Bp€Îí7šIÜöeú¤4²³DÒp¨üF·V+ ­G0å6€û™9©ˆgÆ(‰‹nãG Ïø³ì ŽqØ~£È‚=D ©Æ˜®™fÄ8EÕDÓÕ‹å+2’©r#Hy ÊAÀ’Ž¢f=cS¦nÖ4ë)ì&!–b?Ü Z [öaH‹áÎÐoSðG.Ø”#) å3K±>¡ ïÝêP6à.·OIãm¸32veçÓD&±gÕ¬+ô·¬‚é°põ»(±‹„²ŽçÌ2å-í( UöÊH)}”9Š ñ­^›2uóÄÆn»ƒÄ2°ÿ,#:¶¼ˆÙB·{Ëÿ[S¯àR´)++Ö¡‰þ·Çà”WNFõÖx<†(«&šÛ·¸•S¨2³ÖW”IÔ†‹½G:7]ÝŒ%Z‡..Ÿ bZÚóõ‚Ìk‹ /Äd"Ëëõítø¶…w½Ë-DÔo"U{ÌÀ§%*³½JÒ­Ü€þ©ÆXÜ@ÿ´šÂˆ˜ËÔ™…&'¯Òò‘錀G‰ÓpŒkX5…Á.:™¿àÄeÎäÖÿ1‡kÄ? Ébܤ:ÍIEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1BP_1_1EdgeProp-members.html0000644000263000017630000000476411433220722022470 0ustar jorismkyb libDAI: Member List

dai::BP::EdgeProp Member List

This is the complete list of members for dai::BP::EdgeProp, including all inherited members.

indexdai::BP::EdgeProp
messagedai::BP::EdgeProp
newMessagedai::BP::EdgeProp
residualdai::BP::EdgeProp

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__inv0.html0000644000263000017630000000730611433220722020143 0ustar jorismkyb libDAI: dai::fo_inv0< T > Struct Template Reference

dai::fo_inv0< T > Struct Template Reference

Function object that takes the inverse, except that 1/0 is defined to be 0. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns (x == 0 ? 0 : (1 / x)).

Detailed Description

template<typename T>
struct dai::fo_inv0< T >

Function object that takes the inverse, except that 1/0 is defined to be 0.

Member Function Documentation

template<typename T>
T dai::fo_inv0< T >::operator() ( const T &  x  )  const [inline]

Returns (x == 0 ? 0 : (1 / x)).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1SmallSet.html0000644000263000017630000020012611433220722017744 0ustar jorismkyb libDAI: dai::SmallSet< T > Class Template Reference

dai::SmallSet< T > Class Template Reference

Represents a set; the implementation is optimized for a small number of elements. More...

#include <dai/smallset.h>

Inheritance diagram for dai::SmallSet< T >:

dai::VarSet dai::Region

List of all members.

Public Types

typedef std::vector< T >
::const_iterator 		const_iterator
 Constant iterator over the elements.
typedef std::vector< T >::iterator iterator
 Iterator over the elements.
typedef std::vector< T >
::const_reverse_iterator 		const_reverse_iterator
 Constant reverse iterator over the elements.
typedef std::vector< T >
::reverse_iterator 		reverse_iterator
 Reverse iterator over the elements.

Public Member Functions

Constructors and destructors
 SmallSet ()
 Default constructor (constructs an empty set).
 SmallSet (const T &t)
 Construct a set consisting of one element.
 SmallSet (const T &t1, const T &t2)
 Construct a set consisting of two elements.
template<typename TIterator>
 SmallSet (TIterator begin, TIterator end, size_t sizeHint)
 Construct a SmallSet from a range of elements.
Operators for set-theoretic operations
SmallSet & insert (const T &t)
 Inserts t into *this.
SmallSet & erase (const T &t)
 Erases t from *this.
SmallSet operator/ (const SmallSet &x) const
 Set-minus operator: returns all elements in *this, except those in x.
SmallSet operator| (const SmallSet &x) const
 Set-union operator: returns all elements in *this, plus those in x.
SmallSet operator & (const SmallSet &x) const
 Set-intersection operator: returns all elements in *this that are also contained in x.
SmallSet & operator/= (const SmallSet &x)
 Erases from *this all elements in x.
SmallSet & operator/= (const T &t)
 Erases one element.
SmallSet & operator|= (const SmallSet &x)
 Adds to *this all elements in x.
SmallSet & operator|= (const T &t)
 Adds one element.
SmallSet & operator &= (const SmallSet &x)
 Erases from *this all elements not in x.
bool operator<< (const SmallSet &x) const
 Returns true if *this is a subset of x.
bool operator>> (const SmallSet &x) const
 Returns true if x is a subset of *this.
Queries
bool intersects (const SmallSet &x) const
 Returns true if *this and x have elements in common.
bool contains (const T &t) const
 Returns true if *this contains the element t.
std::vector< T >::size_type size () const
 Returns number of elements.
bool empty () const
 Returns whether *this is empty.
std::vector< T > & elements ()
 Returns reference to the elements.
const std::vector< T > & elements () const
 Returns constant reference to the elements.
Iterator interface
iterator begin ()
 Returns iterator that points to the first element.
const_iterator begin () const
 Returns constant iterator that points to the first element.
iterator end ()
 Returns iterator that points beyond the last element.
const_iterator end () const
 Returns constant iterator that points beyond the last element.
reverse_iterator rbegin ()
 Returns reverse iterator that points to the last element.
const_reverse_iterator rbegin () const
 Returns constant reverse iterator that points to the last element.
reverse_iterator rend ()
 Returns reverse iterator that points beyond the first element.
const_reverse_iterator rend () const
 Returns constant reverse iterator that points beyond the first element.
T & front ()
 Returns reference to first element.
const T & front () const
 Returns constant reference to first element.
T & back ()
 Returns reference to last element.
const T & back () const
 Returns constant reference to last element.

Private Attributes

std::vector< T > _elements
 The elements in this set.

Friends

Comparison operators
bool operator== (const SmallSet &a, const SmallSet &b)
 Returns true if a and b are identical.
bool operator!= (const SmallSet &a, const SmallSet &b)
 Returns true if a and b are not identical.
bool operator< (const SmallSet &a, const SmallSet &b)
 Lexicographical comparison of elements.
Streaming input/output
std::ostream & operator<< (std::ostream &os, const SmallSet &x)
 Writes a SmallSet to an output stream.

Detailed Description

template<typename T>
class dai::SmallSet< T >

Represents a set; the implementation is optimized for a small number of elements.

SmallSet uses an ordered std::vector<T> to represent a set; this is faster than using a std::set<T> if the number of elements is small.

Template Parameters:
T Should be less-than-comparable.

Member Typedef Documentation

template<typename T>
typedef std::vector<T>::const_iterator dai::SmallSet< T >::const_iterator

Constant iterator over the elements.

template<typename T>
typedef std::vector<T>::iterator dai::SmallSet< T >::iterator

Iterator over the elements.

template<typename T>
typedef std::vector<T>::const_reverse_iterator dai::SmallSet< T >::const_reverse_iterator

Constant reverse iterator over the elements.

template<typename T>
typedef std::vector<T>::reverse_iterator dai::SmallSet< T >::reverse_iterator

Reverse iterator over the elements.

Constructor & Destructor Documentation

template<typename T>
dai::SmallSet< T >::SmallSet (  )  [inline]

Default constructor (constructs an empty set).

template<typename T>
dai::SmallSet< T >::SmallSet ( const T &  t  )  [inline]

Construct a set consisting of one element.

template<typename T>
dai::SmallSet< T >::SmallSet ( const T &  t1,
const T &  t2 
) [inline]

Construct a set consisting of two elements.

template<typename T>
template<typename TIterator>
dai::SmallSet< T >::SmallSet ( TIterator  begin,
TIterator  end,
size_t  sizeHint 
) [inline]

Construct a SmallSet from a range of elements.

Template Parameters:
TIterator Iterates over instances of type T.
Parameters:
begin Points to first element to be added.
end Points just beyond last element to be added.
sizeHint For efficiency, the number of elements can be speficied by sizeHint.
Note:
The sizeHint parameter used to be optional in libDAI versions 0.2.4 and earlier.

Member Function Documentation

template<typename T>
SmallSet& dai::SmallSet< T >::insert ( const T &  t  )  [inline]

Inserts t into *this.

template<typename T>
SmallSet& dai::SmallSet< T >::erase ( const T &  t  )  [inline]

Erases t from *this.

template<typename T>
SmallSet dai::SmallSet< T >::operator/ ( const SmallSet< T > &  x  )  const [inline]

Set-minus operator: returns all elements in *this, except those in x.

template<typename T>
SmallSet dai::SmallSet< T >::operator| ( const SmallSet< T > &  x  )  const [inline]

Set-union operator: returns all elements in *this, plus those in x.

template<typename T>
SmallSet dai::SmallSet< T >::operator & ( const SmallSet< T > &  x  )  const [inline]

Set-intersection operator: returns all elements in *this that are also contained in x.

template<typename T>
SmallSet& dai::SmallSet< T >::operator/= ( const SmallSet< T > &  x  )  [inline]

Erases from *this all elements in x.

template<typename T>
SmallSet& dai::SmallSet< T >::operator/= ( const T &  t  )  [inline]

Erases one element.

template<typename T>
SmallSet& dai::SmallSet< T >::operator|= ( const SmallSet< T > &  x  )  [inline]

Adds to *this all elements in x.

template<typename T>
SmallSet& dai::SmallSet< T >::operator|= ( const T &  t  )  [inline]

Adds one element.

template<typename T>
SmallSet& dai::SmallSet< T >::operator &= ( const SmallSet< T > &  x  )  [inline]

Erases from *this all elements not in x.

template<typename T>
bool dai::SmallSet< T >::operator<< ( const SmallSet< T > &  x  )  const [inline]

Returns true if *this is a subset of x.

template<typename T>
bool dai::SmallSet< T >::operator>> ( const SmallSet< T > &  x  )  const [inline]

Returns true if x is a subset of *this.

template<typename T>
bool dai::SmallSet< T >::intersects ( const SmallSet< T > &  x  )  const [inline]

Returns true if *this and x have elements in common.

template<typename T>
bool dai::SmallSet< T >::contains ( const T &  t  )  const [inline]

Returns true if *this contains the element t.

template<typename T>
std::vector<T>::size_type dai::SmallSet< T >::size (  )  const [inline]

Returns number of elements.

Examples:
example_permute.cpp.

template<typename T>
bool dai::SmallSet< T >::empty (  )  const [inline]

Returns whether *this is empty.

template<typename T>
std::vector<T>& dai::SmallSet< T >::elements (  )  [inline]

Returns reference to the elements.

template<typename T>
const std::vector<T>& dai::SmallSet< T >::elements (  )  const [inline]

Returns constant reference to the elements.

template<typename T>
iterator dai::SmallSet< T >::begin (  )  [inline]

Returns iterator that points to the first element.

Examples:
example_permute.cpp.

template<typename T>
const_iterator dai::SmallSet< T >::begin (  )  const [inline]

Returns constant iterator that points to the first element.

template<typename T>
iterator dai::SmallSet< T >::end (  )  [inline]

Returns iterator that points beyond the last element.

template<typename T>
const_iterator dai::SmallSet< T >::end (  )  const [inline]

Returns constant iterator that points beyond the last element.

template<typename T>
reverse_iterator dai::SmallSet< T >::rbegin (  )  [inline]

Returns reverse iterator that points to the last element.

template<typename T>
const_reverse_iterator dai::SmallSet< T >::rbegin (  )  const [inline]

Returns constant reverse iterator that points to the last element.

template<typename T>
reverse_iterator dai::SmallSet< T >::rend (  )  [inline]

Returns reverse iterator that points beyond the first element.

template<typename T>
const_reverse_iterator dai::SmallSet< T >::rend (  )  const [inline]

Returns constant reverse iterator that points beyond the first element.

template<typename T>
T& dai::SmallSet< T >::front (  )  [inline]

Returns reference to first element.

template<typename T>
const T& dai::SmallSet< T >::front (  )  const [inline]

Returns constant reference to first element.

template<typename T>
T& dai::SmallSet< T >::back (  )  [inline]

Returns reference to last element.

template<typename T>
const T& dai::SmallSet< T >::back (  )  const [inline]

Returns constant reference to last element.

Friends And Related Function Documentation

template<typename T>
bool operator== ( const SmallSet< T > &  a,
const SmallSet< T > &  b 
) [friend]

Returns true if a and b are identical.

template<typename T>
bool operator!= ( const SmallSet< T > &  a,
const SmallSet< T > &  b 
) [friend]

Returns true if a and b are not identical.

template<typename T>
bool operator< ( const SmallSet< T > &  a,
const SmallSet< T > &  b 
) [friend]

Lexicographical comparison of elements.

template<typename T>
std::ostream& operator<< ( std::ostream &  os,
const SmallSet< T > &  x 
) [friend]

Writes a SmallSet to an output stream.

Member Data Documentation

template<typename T>
std::vector<T> dai::SmallSet< T >::_elements [private]

The elements in this set.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1BP.html0000644000263000017630000025505211433220722016531 0ustar jorismkyb libDAI: dai::BP Class Reference

dai::BP Class Reference

Approximate inference algorithm "(Loopy) Belief Propagation". More...

#include <dai/bp.h>

Inheritance diagram for dai::BP:

dai::DAIAlg< GRM > dai::InfAlg dai::FBP dai::TRWBP

List of all members.

Public Member Functions

Constructors/destructors
 BP ()
 Default constructor.
 BP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
 BP (const BP &x)
 Copy constructor.
BP & operator= (const BP &x)
 Assignment operator.
General InfAlg interface
virtual BP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
std::vector< std::size_t > findMaximum () const
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &ns)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".
Additional interface specific for BP
const std::vector< std::pair
< std::size_t, std::size_t > > & 		getSentMessages () const
 Returns history of which messages have been updated.
void clearSentMessages ()
 Clears history of which messages have been updated.

Public Attributes

struct dai::BP::Properties props
bool recordSentMessages
 Specifies whether the history of message updates should be recorded.

Static Public Attributes

static const char * Name = "BP"
 Name of this inference algorithm.

Protected Types

typedef std::vector< size_t > ind_t
 Type used for index cache.
typedef std::multimap< Real,
std::pair< std::size_t,
std::size_t > > 		LutType
 Type of lookup table (only used for maximum-residual BP).

Protected Member Functions

const Prob & message (size_t i, size_t _I) const
 Returns constant reference to message from the _I 'th neighbor of variable i to variable i.
Prob & message (size_t i, size_t _I)
 Returns reference to message from the _I 'th neighbor of variable i to variable i.
const Prob & newMessage (size_t i, size_t _I) const
 Returns constant reference to updated message from the _I 'th neighbor of variable i to variable i.
Prob & newMessage (size_t i, size_t _I)
 Returns reference to updated message from the _I 'th neighbor of variable i to variable i.
const ind_t & index (size_t i, size_t _I) const
 Returns constant reference to cached index for the edge between variable i and its _I 'th neighbor.
ind_t & index (size_t i, size_t _I)
 Returns reference to cached index for the edge between variable i and its _I 'th neighbor.
const Real & residual (size_t i, size_t _I) const
 Returns constant reference to residual for the edge between variable i and its _I 'th neighbor.
Real & residual (size_t i, size_t _I)
 Returns reference to residual for the edge between variable i and its _I 'th neighbor.
virtual Prob calcIncomingMessageProduct (size_t I, bool without_i, size_t i) const
 Calculate the product of factor I and the incoming messages.
virtual void calcNewMessage (size_t i, size_t _I)
 Calculate the updated message from the _I 'th neighbor of variable i to variable i.
void updateMessage (size_t i, size_t _I)
 Replace the "old" message from the _I 'th neighbor of variable i to variable i by the "new" (updated) message.
void updateResidual (size_t i, size_t _I, Real r)
 Set the residual (difference between new and old message) for the edge between variable i and its _I 'th neighbor to r.
void findMaxResidual (size_t &i, size_t &_I)
 Finds the edge which has the maximum residual (difference between new and old message).
virtual void calcBeliefV (size_t i, Prob &p) const
 Calculates unnormalized belief of variable i.
virtual void calcBeliefF (size_t I, Prob &p) const
 Calculates unnormalized belief of factor I.
virtual void construct ()
 Helper function for constructors.

Protected Attributes

std::vector< std::vector
< EdgeProp > > 		_edges
 Stores all edge properties.
std::vector< std::vector
< LutType::iterator > > 		_edge2lut
 Lookup table (only used for maximum-residual BP).
LutType _lut
 Lookup table (only used for maximum-residual BP).
Real _maxdiff
 Maximum difference between variable beliefs encountered so far.
size_t _iters
 Number of iterations needed.
std::vector< std::pair
< std::size_t, std::size_t > > 		_sentMessages
 The history of message updates (only recorded if recordSentMessages is true).
std::vector< Factor > _oldBeliefsV
 Stores variable beliefs of previous iteration.
std::vector< Factor > _oldBeliefsF
 Stores factor beliefs of previous iteration.
std::vector< Edge > _updateSeq
 Stores the update schedule.

Classes

struct  EdgeProp
 Type used for storing edge properties. More...
struct  Properties
 Parameters for BP. More...

Detailed Description

Approximate inference algorithm "(Loopy) Belief Propagation".

The Loopy Belief Propagation algorithm uses message passing to approximate marginal probability distributions ("beliefs") for variables and factors (more precisely, for the subset of variables depending on the factor). There are two variants, the sum-product algorithm (corresponding to finite temperature) and the max-product algorithm (corresponding to zero temperature).

The messages $m_{I\to i}(x_i)$ are passed from factors $I$ to variables $i$. In case of the sum-product algorith, the update equation is:

\[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\]

and in case of the max-product algorithm:

\[ m_{I\to i}(x_i) \propto \max_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\]

In order to improve convergence, the updates can be damped. For improved numerical stability, the updates can be done in the log-domain alternatively.

After convergence, the variable beliefs are calculated by:

\[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}(x_i)\]

and the factor beliefs are calculated by:

\[ b_I(x_I) \propto f_I(x_I) \prod_{j\in N_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}(x_j) \]

The logarithm of the partition sum is calculated by:

\[ \log Z = \sum_i (1 - |N_i|) \sum_{x_i} b_i(x_i) \log b_i(x_i) - \sum_I \sum_{x_I} b_I(x_I) \log \frac{b_I(x_I)}{f_I(x_I)} \]

For the max-product algorithm, a heuristic way of finding the MAP state (the joint configuration of all variables which has maximum probability) is provided by the findMaximum() method, which can be called after convergence.

Note:
There are two implementations, an optimized one (the default) which caches IndexFor objects, and a slower, less complicated one which is easier to maintain/understand. The slower one can be enabled by defining DAI_BP_FAST as false in the source file.
Examples:

example.cpp.

Member Typedef Documentation

typedef std::vector<size_t> dai::BP::ind_t [protected]

Type used for index cache.

typedef std::multimap<Real, std::pair<std::size_t, std::size_t> > dai::BP::LutType [protected]

Type of lookup table (only used for maximum-residual BP).

Constructor & Destructor Documentation

dai::BP::BP (  )  [inline]

Default constructor.

dai::BP::BP ( const FactorGraph &  fg,
const PropertySet &  opts 
) [inline]

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties

dai::BP::BP ( const BP &  x  )  [inline]

Copy constructor.

Member Function Documentation

BP& dai::BP::operator= ( const BP &  x  )  [inline]

Assignment operator.

virtual BP* dai::BP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

Reimplemented in dai::FBP, and dai::TRWBP.

string dai::BP::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

Reimplemented in dai::FBP, and dai::TRWBP.

virtual Factor dai::BP::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Examples:
example.cpp.

Factor dai::BP::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Factor dai::BP::beliefV ( size_t  i  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::BP::beliefF ( size_t  I  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variables on which factor I depends.

For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Examples:
example.cpp.

vector< Factor > dai::BP::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

Real dai::BP::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::FBP, and dai::TRWBP.

Examples:
example.cpp.

std::vector<std::size_t> dai::BP::findMaximum (  )  const [inline, virtual]

Precondition:
Assumes that run() has been called and that props.inference == MAXPROD

Reimplemented from dai::InfAlg.

Examples:
example.cpp.

void dai::BP::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

Examples:
example.cpp.

void dai::BP::init ( const VarSet &  vs  )  [virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::BP::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

Examples:
example.cpp.

virtual Real dai::BP::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::BP::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::BP::setMaxIter ( size_t   )  [inline, virtual]

Sets maximum number of iterations (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::BP::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

Reimplemented in dai::TRWBP.

PropertySet dai::BP::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

Reimplemented in dai::TRWBP.

string dai::BP::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Reimplemented in dai::TRWBP.

const std::vector<std::pair<std::size_t, std::size_t> >& dai::BP::getSentMessages (  )  const [inline]

Returns history of which messages have been updated.

void dai::BP::clearSentMessages (  )  [inline]

Clears history of which messages have been updated.

const Prob& dai::BP::message ( size_t  i,
size_t  _I 
) const [inline, protected]

Returns constant reference to message from the _I 'th neighbor of variable i to variable i.

Prob& dai::BP::message ( size_t  i,
size_t  _I 
) [inline, protected]

Returns reference to message from the _I 'th neighbor of variable i to variable i.

const Prob& dai::BP::newMessage ( size_t  i,
size_t  _I 
) const [inline, protected]

Returns constant reference to updated message from the _I 'th neighbor of variable i to variable i.

Prob& dai::BP::newMessage ( size_t  i,
size_t  _I 
) [inline, protected]

Returns reference to updated message from the _I 'th neighbor of variable i to variable i.

const ind_t& dai::BP::index ( size_t  i,
size_t  _I 
) const [inline, protected]

Returns constant reference to cached index for the edge between variable i and its _I 'th neighbor.

ind_t& dai::BP::index ( size_t  i,
size_t  _I 
) [inline, protected]

Returns reference to cached index for the edge between variable i and its _I 'th neighbor.

const Real& dai::BP::residual ( size_t  i,
size_t  _I 
) const [inline, protected]

Returns constant reference to residual for the edge between variable i and its _I 'th neighbor.

Real& dai::BP::residual ( size_t  i,
size_t  _I 
) [inline, protected]

Returns reference to residual for the edge between variable i and its _I 'th neighbor.

Prob dai::BP::calcIncomingMessageProduct ( size_t  I,
bool  without_i,
size_t  i 
) const [protected, virtual]

Calculate the product of factor I and the incoming messages.

If without_i == true, the message coming from variable i is omitted from the product

Note:
This function is used by calcNewMessage() and calcBeliefF()

Reimplemented in dai::FBP, and dai::TRWBP.

void dai::BP::calcNewMessage ( size_t  i,
size_t  _I 
) [protected, virtual]

Calculate the updated message from the _I 'th neighbor of variable i to variable i.

Reimplemented in dai::FBP.

void dai::BP::updateMessage ( size_t  i,
size_t  _I 
) [protected]

Replace the "old" message from the _I 'th neighbor of variable i to variable i by the "new" (updated) message.

void dai::BP::updateResidual ( size_t  i,
size_t  _I,
Real  r 
) [protected]

Set the residual (difference between new and old message) for the edge between variable i and its _I 'th neighbor to r.

void dai::BP::findMaxResidual ( size_t &  i,
size_t &  _I 
) [protected]

Finds the edge which has the maximum residual (difference between new and old message).

void dai::BP::calcBeliefV ( size_t  i,
Prob &  p 
) const [protected, virtual]

Calculates unnormalized belief of variable i.

Reimplemented in dai::TRWBP.

virtual void dai::BP::calcBeliefF ( size_t  I,
Prob &  p 
) const [inline, protected, virtual]

Calculates unnormalized belief of factor I.

Reimplemented in dai::FBP, and dai::TRWBP.

void dai::BP::construct (  )  [protected, virtual]

Helper function for constructors.

Reimplemented in dai::FBP, and dai::TRWBP.

Member Data Documentation

std::vector<std::vector<EdgeProp> > dai::BP::_edges [protected]

Stores all edge properties.

std::vector<std::vector<LutType::iterator> > dai::BP::_edge2lut [protected]

Lookup table (only used for maximum-residual BP).

LutType dai::BP::_lut [protected]

Lookup table (only used for maximum-residual BP).

Real dai::BP::_maxdiff [protected]

Maximum difference between variable beliefs encountered so far.

size_t dai::BP::_iters [protected]

Number of iterations needed.

std::vector<std::pair<std::size_t, std::size_t> > dai::BP::_sentMessages [protected]

The history of message updates (only recorded if recordSentMessages is true).

std::vector<Factor> dai::BP::_oldBeliefsV [protected]

Stores variable beliefs of previous iteration.

std::vector<Factor> dai::BP::_oldBeliefsF [protected]

Stores factor beliefs of previous iteration.

std::vector<Edge> dai::BP::_updateSeq [protected]

Stores the update schedule.

const char * dai::BP::Name = "BP" [static]

Name of this inference algorithm.

Reimplemented in dai::FBP, and dai::TRWBP.

bool dai::BP::recordSentMessages

Specifies whether the history of message updates should be recorded.

The documentation for this class was generated from the following files:
  • include/dai/bp.h
  • src/bp.cpp
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1FactorGraph.html0000644000263000017630000026622111433220722020430 0ustar jorismkyb libDAI: dai::FactorGraph Class Reference

dai::FactorGraph Class Reference

Represents a factor graph. More...

#include <dai/factorgraph.h>

Inheritance diagram for dai::FactorGraph:

dai::RegionGraph dai::DAIAlg< dai::FactorGraph > dai::DAIAlg< dai::RegionGraph >

List of all members.

Input/Output

virtual void ReadFromFile (const char *filename)
 Reads a factor graph from a file.
virtual void WriteToFile (const char *filename, size_t precision=15) const
 Writes a factor graph to a file.
virtual void printDot (std::ostream &os) const
 Writes a factor graph to a GraphViz .dot file.
std::ostream & operator<< (std::ostream &os, const FactorGraph &fg)
 Writes a factor graph to an output stream.
std::istream & operator>> (std::istream &is, FactorGraph &fg)
 Reads a factor graph from an input stream.

Public Member Functions

Constructors and destructors
 FactorGraph ()
 Default constructor.
 FactorGraph (const std::vector< Factor > &P)
 Constructs a factor graph from a vector of factors.
template<typename FactorInputIterator, typename VarInputIterator>
 FactorGraph (FactorInputIterator facBegin, FactorInputIterator facEnd, VarInputIterator varBegin, VarInputIterator varEnd, size_t nrFacHint=0, size_t nrVarHint=0)
 Constructs a factor graph from given factor and variable iterators.
virtual ~FactorGraph ()
 Destructor.
virtual FactorGraph * clone () const
 Virtual copy constructor.
Accessors and mutators
const Var & var (size_t i) const
 Returns constant reference the i 'th variable.
const std::vector< Var > & vars () const
 Returns constant reference to all variables.
const Factor & factor (size_t I) const
 Returns constant reference to I 'th factor.
const std::vector< Factor > & factors () const
 Returns constant reference to all factors.
const Neighbors & nbV (size_t i) const
 Returns constant reference to neighbors of the i 'th variable.
const Neighbors & nbF (size_t I) const
 Returns constant reference to neighbors of the I 'th factor.
const Neighbor & nbV (size_t i, size_t _I) const
 Returns constant reference to the _I 'th neighbor of the i 'th variable.
const Neighbor & nbF (size_t I, size_t _i) const
 Returns constant reference to the _i 'th neighbor of the I 'th factor.
Queries
const BipartiteGraph & bipGraph () const
 Returns neighborhood structure.
size_t nrVars () const
 Returns number of variables.
size_t nrFactors () const
 Returns number of factors.
size_t nrEdges () const
 Calculates number of edges.
size_t findVar (const Var &n) const
 Returns the index of a particular variable.
SmallSet< size_t > findVars (const VarSet &ns) const
 Returns a set of indexes corresponding to a set of variables.
size_t findFactor (const VarSet &ns) const
 Returns index of the first factor that depends on the variables.
VarSet Delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself included.
VarSet Delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself included.
VarSet delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself excluded.
VarSet delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself excluded.
bool isConnected () const
 Returns true if the factor graph is connected.
bool isTree () const
 Returns true if the factor graph is a tree (i.e., has no cycles and is connected).
bool isPairwise () const
 Returns true if each factor depends on at most two variables.
bool isBinary () const
 Returns true if each variable has only two possible values.
GraphAL MarkovGraph () const
 Constructs the corresponding Markov graph.
bool isMaximal (size_t I) const
 Returns whether the I 'th factor is maximal.
size_t maximalFactor (size_t I) const
 Returns the index of a maximal factor that contains the I 'th factor.
std::vector< VarSet > maximalFactorDomains () const
 Returns the maximal factor domains in this factorgraph.
Real logScore (const std::vector< size_t > &statevec)
 Evaluates the log score (i.e., minus the energy) of the joint configuration statevec.
Backup/restore mechanism for factors
virtual void setFactor (size_t I, const Factor &newFactor, bool backup=false)
 Set the content of the I 'th factor and make a backup of its old content if backup == true.
virtual void setFactors (const std::map< size_t, Factor > &facs, bool backup=false)
 Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true.
void backupFactor (size_t I)
 Makes a backup of the I 'th factor.
void restoreFactor (size_t I)
 Restores the I 'th factor from the backup (it should be backed up first).
virtual void backupFactors (const std::set< size_t > &facs)
 Backup the factors specified by indices in facs.
virtual void restoreFactors ()
 Restore all factors to the backup copies.
void backupFactors (const VarSet &ns)
 Makes a backup of all factors connected to a set of variables.
void restoreFactors (const VarSet &ns)
 Restores all factors connected to a set of variables from their backups.
Transformations
FactorGraph maximalFactors () const
 Returns a copy of *this, where all factors that are subsumed by some larger factor are merged with the larger factors.
FactorGraph clamped (size_t i, size_t x) const
 Returns a copy of *this, where the i 'th variable has been clamped to value x.
Operations
virtual void clamp (size_t i, size_t x, bool backup=false)
 Clamp the i 'th variable to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).
void clampVar (size_t i, const std::vector< size_t > &xis, bool backup=false)
 Clamp a variable in a factor graph to have one out of a list of values.
void clampFactor (size_t I, const std::vector< size_t > &xIs, bool backup=false)
 Clamp a factor in a factor graph to have one out of a list of values.
virtual void makeCavity (size_t i, bool backup=false)
 Set all factors interacting with the i 'th variable to 1.

Private Member Functions

void constructGraph (size_t nrEdges)
 Part of constructors (creates edges, neighbors and adjacency matrix).

Private Attributes

BipartiteGraph _G
 Stores the neighborhood structure.
std::vector< Var > _vars
 Stores the variables.
std::vector< Factor > _factors
 Stores the factors.
std::map< size_t, Factor > _backup
 Stores backups of some factors.

Detailed Description

Represents a factor graph.

Both Bayesian Networks and Markov random fields can be represented in a unifying representation, called factor graph [KFL01], implemented in libDAI by the FactorGraph class.

Consider a probability distribution over $N$ discrete random variables $x_0,x_1,\dots,x_{N-1}$ that factorizes as a product of $M$ factors, each of which depends on some subset of the variables:

\[ P(x_0,x_1,\dots,x_{N-1}) = \frac{1}{Z} \prod_{I=0}^{M-1} f_I(x_I), \qquad Z = \sum_{x_0}\dots\sum_{x_{N-1}} \prod_{I=0}^{M-1} f_I(X_I). \]

Each factor $f_I$ is a function from an associated subset of variables $X_I \subset \{x_0,x_1,\dots,x_{N-1}\}$ to the nonnegative real numbers.

For a Bayesian network, each factor corresponds to a (conditional) probability table, whereas for a Markov random field, each factor corresponds to a maximal clique of the undirected graph.

Factor graphs explicitly express the factorization structure of the corresponding probability distribution. A factor graph is a bipartite graph, containing variable nodes and factor nodes, and an edge between a variable node and a factor node if the corresponding factor depends on that variable. In libDAI, this structure is represented by a BipartiteGraph.

So basically, a FactorGraph consists of a BipartiteGraph, a vector of Var 's and a vector of TFactor 's.

Idea:
Alternative implementation of undo factor changes: the only things that have to be undone currently are setting a factor to 1 and setting a factor to a Kronecker delta. This could also be implemented in the TFactor itself, which could maintain its state (ones/delta/full) and act accordingly. Update: it seems that the proposed functionality would not be enough for CBP, for which it would make more sense to add more levels of backup/restore.
Todo:
Write a method that applies evidence (should we represent evidence as a map<Var,size_t> or as a map<size_t,size_t>?)
Examples:

example.cpp, example_imagesegmentation.cpp, example_sprinkler.cpp, example_sprinkler_em.cpp, example_sprinkler_gibbs.cpp, and uai2010-aie-solver.cpp.

Constructor & Destructor Documentation

dai::FactorGraph::FactorGraph (  )  [inline]

Default constructor.

dai::FactorGraph::FactorGraph ( const std::vector< Factor > &  P  ) 

Constructs a factor graph from a vector of factors.

template<typename FactorInputIterator, typename VarInputIterator>
dai::FactorGraph::FactorGraph ( FactorInputIterator  facBegin,
FactorInputIterator  facEnd,
VarInputIterator  varBegin,
VarInputIterator  varEnd,
size_t  nrFacHint = 0,
size_t  nrVarHint = 0 
) [inline]

Constructs a factor graph from given factor and variable iterators.

Template Parameters:
FactorInputIterator Iterates over instances of type dai::Factor
VarInputIterator Iterates over instances of type Var
Precondition:
Assumes that the set of variables in [varBegin, varEnd) is the union of the variables in the factors in [facBegin, facEnd)

virtual dai::FactorGraph::~FactorGraph (  )  [inline, virtual]

Destructor.

Member Function Documentation

virtual FactorGraph* dai::FactorGraph::clone (  )  const [inline, virtual]

Virtual copy constructor.

Reimplemented in dai::RegionGraph.

const Var& dai::FactorGraph::var ( size_t  i  )  const [inline]

Returns constant reference the i 'th variable.

Examples:
example.cpp, and example_sprinkler_gibbs.cpp.

const std::vector<Var>& dai::FactorGraph::vars (  )  const [inline]

Returns constant reference to all variables.

const Factor& dai::FactorGraph::factor ( size_t  I  )  const [inline]

Returns constant reference to I 'th factor.

Examples:
example.cpp, and example_sprinkler.cpp.

const std::vector<Factor>& dai::FactorGraph::factors (  )  const [inline]

Returns constant reference to all factors.

const Neighbors& dai::FactorGraph::nbV ( size_t  i  )  const [inline]

Returns constant reference to neighbors of the i 'th variable.

const Neighbors& dai::FactorGraph::nbF ( size_t  I  )  const [inline]

Returns constant reference to neighbors of the I 'th factor.

const Neighbor& dai::FactorGraph::nbV ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to the _I 'th neighbor of the i 'th variable.

const Neighbor& dai::FactorGraph::nbF ( size_t  I,
size_t  _i 
) const [inline]

Returns constant reference to the _i 'th neighbor of the I 'th factor.

const BipartiteGraph& dai::FactorGraph::bipGraph (  )  const [inline]

Returns neighborhood structure.

size_t dai::FactorGraph::nrVars (  )  const [inline]

Returns number of variables.

Examples:
example.cpp, example_imagesegmentation.cpp, example_sprinkler.cpp, and example_sprinkler_gibbs.cpp.

size_t dai::FactorGraph::nrFactors (  )  const [inline]

Returns number of factors.

Examples:
example.cpp, example_sprinkler.cpp, and example_sprinkler_gibbs.cpp.

size_t dai::FactorGraph::nrEdges (  )  const [inline]

Calculates number of edges.

Note:
Time complexity: O(nrVars())

size_t dai::FactorGraph::findVar ( const Var &  n  )  const [inline]

Returns the index of a particular variable.

Note:
Time complexity: O(nrVars())
Exceptions:
OBJECT_NOT_FOUND if the variable is not part of this factor graph

SmallSet<size_t> dai::FactorGraph::findVars ( const VarSet &  ns  )  const [inline]

Returns a set of indexes corresponding to a set of variables.

Note:
Time complexity: O( nrVars() * ns.size() )
Exceptions:
OBJECT_NOT_FOUND if one of the variables is not part of this factor graph

size_t dai::FactorGraph::findFactor ( const VarSet &  ns  )  const [inline]

Returns index of the first factor that depends on the variables.

Note:
Time complexity: O(nrFactors())
Exceptions:
OBJECT_NOT_FOUND if no factor in this factor graph depends on those variables

VarSet dai::FactorGraph::Delta ( size_t  i  )  const

Return all variables that occur in a factor involving the i 'th variable, itself included.

VarSet dai::FactorGraph::Delta ( const VarSet &  vs  )  const

Return all variables that occur in a factor involving some variable in vs, vs itself included.

VarSet dai::FactorGraph::delta ( size_t  i  )  const [inline]

Return all variables that occur in a factor involving the i 'th variable, itself excluded.

VarSet dai::FactorGraph::delta ( const VarSet &  vs  )  const [inline]

Return all variables that occur in a factor involving some variable in vs, vs itself excluded.

bool dai::FactorGraph::isConnected (  )  const [inline]

Returns true if the factor graph is connected.

bool dai::FactorGraph::isTree (  )  const [inline]

Returns true if the factor graph is a tree (i.e., has no cycles and is connected).

bool dai::FactorGraph::isPairwise (  )  const

Returns true if each factor depends on at most two variables.

bool dai::FactorGraph::isBinary (  )  const

Returns true if each variable has only two possible values.

GraphAL dai::FactorGraph::MarkovGraph (  )  const

Constructs the corresponding Markov graph.

Note:
The Markov graph has the variables as nodes and an edge between two variables if and only if the variables share a factor.

bool dai::FactorGraph::isMaximal ( size_t  I  )  const

Returns whether the I 'th factor is maximal.

Note:
A factor (domain) is maximal if and only if it is not a strict subset of another factor domain.

size_t dai::FactorGraph::maximalFactor ( size_t  I  )  const

Returns the index of a maximal factor that contains the I 'th factor.

Note:
A factor (domain) is maximal if and only if it is not a strict subset of another factor domain.

vector< VarSet > dai::FactorGraph::maximalFactorDomains (  )  const

Returns the maximal factor domains in this factorgraph.

Note:
A factor domain is maximal if and only if it is not a strict subset of another factor domain.

Real dai::FactorGraph::logScore ( const std::vector< size_t > &  statevec  ) 

Evaluates the log score (i.e., minus the energy) of the joint configuration statevec.

Examples:
example.cpp.

virtual void dai::FactorGraph::setFactor ( size_t  I,
const Factor &  newFactor,
bool  backup = false 
) [inline, virtual]

Set the content of the I 'th factor and make a backup of its old content if backup == true.

Reimplemented in dai::RegionGraph.

virtual void dai::FactorGraph::setFactors ( const std::map< size_t, Factor > &  facs,
bool  backup = false 
) [inline, virtual]

Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true.

Reimplemented in dai::RegionGraph.

void dai::FactorGraph::backupFactor ( size_t  I  ) 

Makes a backup of the I 'th factor.

Exceptions:
MULTIPLE_UNDO if a backup already exists

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::restoreFactor ( size_t  I  ) 

Restores the I 'th factor from the backup (it should be backed up first).

Exceptions:
OBJECT_NOT_FOUND if a backup does not exist

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::backupFactors ( const std::set< size_t > &  facs  )  [virtual]

Backup the factors specified by indices in facs.

Exceptions:
MULTIPLE_UNDO if a backup already exists

void dai::FactorGraph::restoreFactors (  )  [virtual]

Restore all factors to the backup copies.

void dai::FactorGraph::backupFactors ( const VarSet &  ns  ) 

Makes a backup of all factors connected to a set of variables.

Exceptions:
MULTIPLE_UNDO if a backup already exists

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::restoreFactors ( const VarSet &  ns  ) 

Restores all factors connected to a set of variables from their backups.

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

FactorGraph dai::FactorGraph::maximalFactors (  )  const

Returns a copy of *this, where all factors that are subsumed by some larger factor are merged with the larger factors.

FactorGraph dai::FactorGraph::clamped ( size_t  i,
size_t  x 
) const

Returns a copy of *this, where the i 'th variable has been clamped to value x.

Note:
This version changes the factor graph structure and thus returns a newly constructed FactorGraph and keeps the current one constant, contrary to clamp()

void dai::FactorGraph::clamp ( size_t  i,
size_t  x,
bool  backup = false 
) [virtual]

Clamp the i 'th variable to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).

If backup == true, make a backup of all factors that are changed

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::clampVar ( size_t  i,
const std::vector< size_t > &  xis,
bool  backup = false 
)

Clamp a variable in a factor graph to have one out of a list of values.

If backup == true, make a backup of all factors that are changed

void dai::FactorGraph::clampFactor ( size_t  I,
const std::vector< size_t > &  xIs,
bool  backup = false 
)

Clamp a factor in a factor graph to have one out of a list of values.

If backup == true, make a backup of all factors that are changed

void dai::FactorGraph::makeCavity ( size_t  i,
bool  backup = false 
) [virtual]

Set all factors interacting with the i 'th variable to 1.

If backup == true, make a backup of all factors that are changed

Reimplemented in dai::DAIAlg< dai::RegionGraph >, and dai::DAIAlg< dai::FactorGraph >.

void dai::FactorGraph::ReadFromFile ( const char *  filename  )  [virtual]

Reads a factor graph from a file.

See also:
Factor graph (.fg) file format
Exceptions:
CANNOT_READ_FILE if the file cannot be opened
INVALID_FACTORGRAPH_FILE if the file is not valid

Reimplemented in dai::RegionGraph.

Examples:
example.cpp, example_sprinkler_em.cpp, and example_sprinkler_gibbs.cpp.

void dai::FactorGraph::WriteToFile ( const char *  filename,
size_t  precision = 15 
) const [virtual]

Writes a factor graph to a file.

See also:
Factor graph (.fg) file format
Exceptions:
CANNOT_WRITE_FILE if the file cannot be written

Reimplemented in dai::RegionGraph.

Examples:
example_imagesegmentation.cpp, and example_sprinkler.cpp.

void dai::FactorGraph::printDot ( std::ostream &  os  )  const [virtual]

Writes a factor graph to a GraphViz .dot file.

Reimplemented in dai::RegionGraph.

void dai::FactorGraph::constructGraph ( size_t  nrEdges  )  [private]

Part of constructors (creates edges, neighbors and adjacency matrix).

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const FactorGraph &  fg 
) [friend]

Writes a factor graph to an output stream.

See also:
Factor graph (.fg) file format

std::istream& operator>> ( std::istream &  is,
FactorGraph &  fg 
) [friend]

Reads a factor graph from an input stream.

See also:
Factor graph (.fg) file format
Exceptions:
INVALID_FACTORGRAPH_FILE if the input stream is not valid

Member Data Documentation

BipartiteGraph dai::FactorGraph::_G [private]

Stores the neighborhood structure.

Reimplemented in dai::RegionGraph.

std::vector<Var> dai::FactorGraph::_vars [private]

Stores the variables.

std::vector<Factor> dai::FactorGraph::_factors [private]

Stores the factors.

std::map<size_t,Factor> dai::FactorGraph::_backup [private]

Stores backups of some factors.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x61.html0000644000263000017630000001562311433220722017663 0ustar jorismkyb libDAI: Class Members - Functions
 

- a -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1DecMAP_1_1Properties-members.html0000644000263000017630000000511111433220722023632 0ustar jorismkyb libDAI: Member List

dai::DecMAP::Properties Member List

This is the complete list of members for dai::DecMAP::Properties, including all inherited members.

ianamedai::DecMAP::Properties
iaoptsdai::DecMAP::Properties
reinitdai::DecMAP::Properties
verbosedai::DecMAP::Properties

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/enum_8h.html0000644000263000017630000000766211433220722015431 0ustar jorismkyb libDAI: include/dai/enum.h File Reference

include/dai/enum.h File Reference

Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality. More...

#include <cstring>
#include <iostream>
#include <dai/exceptions.h>

Go to the source code of this file.

Defines

#define DAI_ENUM(x, val0,...)
 Extends the C++ enum type by supporting input/output streaming and conversion to and from const char* and size_t.

Detailed Description

Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.

Define Documentation

#define DAI_ENUM ( x,
val0,
...   ) 

Extends the C++ enum type by supporting input/output streaming and conversion to and from const char* and size_t.

For more details see the source code.

Example:
  DAI_ENUM(colors,RED,GREEN,BLUE)
defines a class colors encapsulating an 
  enum {RED, GREEN, BLUE};
which offers additional functionality over the plain enum keyword.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/properties_8h.html0000644000263000017630000001124011433220722016644 0ustar jorismkyb libDAI: include/dai/properties.h File Reference

include/dai/properties.h File Reference

Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms. More...

#include <iostream>
#include <sstream>
#include <boost/any.hpp>
#include <map>
#include <vector>
#include <typeinfo>
#include <dai/exceptions.h>
#include <dai/util.h>
#include <boost/lexical_cast.hpp>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::PropertySet
 Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue). More...

Typedefs

typedef std::string dai::PropertyKey
 Type of the key of a Property.
typedef boost::any dai::PropertyValue
 Type of the value of a Property.
typedef std::pair< PropertyKey,
PropertyValue > 		dai::Property
 A Property is a pair of a key and a corresponding value.

Functions

std::ostream & dai::operator<< (std::ostream &os, const Property &p)
 Writes a Property object (key-value pair) to an output stream.

Detailed Description

Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1GraphAL-members.html0000644000263000017630000001713211433220722021131 0ustar jorismkyb libDAI: Member List

dai::GraphAL Member List

This is the complete list of members for dai::GraphAL, including all inherited members.

_nbdai::GraphAL [private]
addEdge(size_t n1, size_t n2, bool check=true)dai::GraphAL
addNode()dai::GraphAL [inline]
addNode(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::GraphAL [inline]
checkConsistency() const dai::GraphAL
construct(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::GraphAL [inline]
eraseEdge(size_t n1, size_t n2)dai::GraphAL
eraseNode(size_t n)dai::GraphAL
findNb(size_t n1, size_t n2)dai::GraphAL [inline]
GraphAL()dai::GraphAL [inline]
GraphAL(size_t nr)dai::GraphAL [inline]
GraphAL(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::GraphAL [inline]
hasEdge(size_t n1, size_t n2) const dai::GraphAL [inline]
isConnected() const dai::GraphAL
isTree() const dai::GraphAL
nb(size_t n1, size_t _n2) const dai::GraphAL [inline]
nb(size_t n1, size_t _n2)dai::GraphAL [inline]
nb(size_t n) const dai::GraphAL [inline]
nb(size_t n)dai::GraphAL [inline]
nbSet(size_t n) const dai::GraphAL
nrEdges() const dai::GraphAL [inline]
nrNodes() const dai::GraphAL [inline]
operator<<(std::ostream &os, const GraphAL &g)dai::GraphAL [friend]
operator==(const GraphAL &x) const dai::GraphAL [inline]
printDot(std::ostream &os) const dai::GraphAL

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__Hellinger.html0000644000263000017630000000777311433220722021210 0ustar jorismkyb libDAI: dai::fo_Hellinger< T > Struct Template Reference

dai::fo_Hellinger< T > Struct Template Reference

Function object useful for calculating the Hellinger distance. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &p, const T &q) const
 Returns (sqrt(p) - sqrt(q))^2.

Detailed Description

template<typename T>
struct dai::fo_Hellinger< T >

Function object useful for calculating the Hellinger distance.

Member Function Documentation

template<typename T>
T dai::fo_Hellinger< T >::operator() ( const T &  p,
const T &  q 
) const [inline]

Returns (sqrt(p) - sqrt(q))^2.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/regiongraph_8h.html0000644000263000017630000001020711433220722016757 0ustar jorismkyb libDAI: include/dai/regiongraph.h File Reference

include/dai/regiongraph.h File Reference

Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs. More...

#include <iostream>
#include <dai/bipgraph.h>
#include <dai/factorgraph.h>
#include <dai/weightedgraph.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::Region
 A Region is a set of variables with a counting number. More...
class  dai::FRegion
 An FRegion is a factor with a counting number. More...
class  dai::RegionGraph
 A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph. More...

Detailed Description

Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x6e.html0000644000263000017630000002004611433220722017742 0ustar jorismkyb libDAI: Class Members - Functions
 

- n -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1MR.html0000644000263000017630000017702011433220722016544 0ustar jorismkyb libDAI: dai::MR Class Reference

dai::MR Class Reference

Approximate inference algorithm by Montanari and Rizzo [MoR05]. More...

#include <dai/mr.h>

Inheritance diagram for dai::MR:

dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 MR ()
 Default constructor.
 MR (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual MR * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable.
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables.
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i.
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

struct dai::MR::Properties props

Static Public Attributes

static const char * Name = "MR"
 Name of this inference method.

Private Types

typedef boost::dynamic_bitset sub_nb
 Type used for managing a subset of neighbors.

Private Member Functions

Real calcCavityCorrelations ()
 Initialize cors.
void propagateCavityFields ()
 Iterate update equations for cavity fields.
void calcMagnetizations ()
 Calculate magnetizations.
Real _tJ (size_t i, sub_nb A)
 Calculate the product of all tJ[i][_j] for _j in A.
Real Omega (size_t i, size_t _j, size_t _l)
 Calculate $ \Omega^{(i)}_{j,l} $ as defined in [MoR05] eqn. (2.15).
Real T (size_t i, sub_nb A)
 Calculate $ T^{(i)}_A $ as defined in [MoR05] eqn. (2.17) with $ A = \{l_1,l_2,\dots\} $.
Real T (size_t i, size_t _j)
 Calculates $ T^{(i)}_j $ where j is the _j 'th neighbor of i.
Real Gamma (size_t i, size_t _j, size_t _l1, size_t _l2)
 Calculates $ \Gamma^{(i)}_{j,l_1l_2} $ as defined in [MoR05] eqn. (2.16).
Real Gamma (size_t i, size_t _l1, size_t _l2)
 Calculates $ \Gamma^{(i)}_{l_1l_2} $ as defined in [MoK07] on page 1141.
Real appM (size_t i, sub_nb A)
 Approximates moments of variables in A.
void sum_subs (size_t j, sub_nb A, Real *sum_even, Real *sum_odd)
 Calculate sum over all even/odd subsets B of A of _tJ(j,B) appM(j,B).

Private Attributes

bool supported
 Is the underlying factor graph supported?
GraphAL G
 The interaction graph (Markov graph).
std::vector< std::vector< Real > > tJ
 tJ[i][_j] is the hyperbolic tangent of the interaction between spin i and its neighbour G.nb(i,_j)
std::vector< Real > theta
 theta[i] is the local field on spin i
std::vector< std::vector< Real > > M
 M[i][_j] is $ M^{(i)}_j $.
std::vector< std::vector
< std::vector< Real > > > 		cors
 Cavity correlations.
std::vector< Real > Mag
 Magnetizations.
Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.

Classes

struct  Properties
 Parameters for MR. More...

Detailed Description

Approximate inference algorithm by Montanari and Rizzo [MoR05].

Author:
Bastian Wemmenhove wrote the original implementation before it was merged into libDAI

Member Typedef Documentation

typedef boost::dynamic_bitset dai::MR::sub_nb [private]

Type used for managing a subset of neighbors.

Constructor & Destructor Documentation

dai::MR::MR (  )  [inline]

Default constructor.

dai::MR::MR ( const FactorGraph &  fg,
const PropertySet &  opts 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties
Note:
This implementation only deals with binary variables and pairwise interactions.
Exceptions:
NOT_IMPLEMENTED if fg has factors depending on three or more variables or has variables with more than two possible states.

Member Function Documentation

virtual MR* dai::MR::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Implements dai::InfAlg.

string dai::MR::identify (  )  const [virtual]

Identifies itself for logging purposes.

Implements dai::InfAlg.

virtual Factor dai::MR::belief ( const Var &  v  )  const [inline, virtual]

Returns the (approximate) marginal probability distribution of a variable.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

Factor dai::MR::belief ( const VarSet &  vs  )  const [virtual]

Returns the (approximate) marginal probability distribution of a set of variables.

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported.
BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

Factor dai::MR::beliefV ( size_t  i  )  const [virtual]

Returns the (approximate) marginal probability distribution of the variable with index i.

For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons.

Note:
Before this method is called, run() should have been called.

Reimplemented from dai::InfAlg.

vector< Factor > dai::MR::beliefs (  )  const [virtual]

Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm.

Note:
Before this method is called, run() should have been called.

Implements dai::InfAlg.

virtual Real dai::MR::logZ (  )  const [inline, virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

virtual void dai::MR::init (  )  [inline, virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Implements dai::InfAlg.

virtual void dai::MR::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Implements dai::InfAlg.

Real dai::MR::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Implements dai::InfAlg.

virtual Real dai::MR::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::MR::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::MR::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Implements dai::InfAlg.

PropertySet dai::MR::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

string dai::MR::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Implements dai::InfAlg.

Real dai::MR::calcCavityCorrelations (  )  [private]

Initialize cors.

void dai::MR::propagateCavityFields (  )  [private]

Iterate update equations for cavity fields.

void dai::MR::calcMagnetizations (  )  [private]

Calculate magnetizations.

Real dai::MR::_tJ ( size_t  i,
sub_nb  A 
) [private]

Calculate the product of all tJ[i][_j] for _j in A.

Parameters:
i variable index
A subset of neighbors of variable i

Real dai::MR::Omega ( size_t  i,
size_t  _j,
size_t  _l 
) [private]

Calculate $ \Omega^{(i)}_{j,l} $ as defined in [MoR05] eqn. (2.15).

Real dai::MR::T ( size_t  i,
sub_nb  A 
) [private]

Calculate $ T^{(i)}_A $ as defined in [MoR05] eqn. (2.17) with $ A = \{l_1,l_2,\dots\} $.

Parameters:
i variable index
A subset of neighbors of variable i

Real dai::MR::T ( size_t  i,
size_t  _j 
) [private]

Calculates $ T^{(i)}_j $ where j is the _j 'th neighbor of i.

Real dai::MR::Gamma ( size_t  i,
size_t  _j,
size_t  _l1,
size_t  _l2 
) [private]

Calculates $ \Gamma^{(i)}_{j,l_1l_2} $ as defined in [MoR05] eqn. (2.16).

Real dai::MR::Gamma ( size_t  i,
size_t  _l1,
size_t  _l2 
) [private]

Calculates $ \Gamma^{(i)}_{l_1l_2} $ as defined in [MoK07] on page 1141.

Real dai::MR::appM ( size_t  i,
sub_nb  A 
) [private]

Approximates moments of variables in A.

Calculate the moment of variables in A from M and cors, neglecting higher order cumulants, defined as the sum over all partitions of A into subsets of cardinality two at most of the product of the cumulants (either first order, i.e. M, or second order, i.e. cors) of the entries of the partitions.

Parameters:
i variable index
A subset of neighbors of variable i

void dai::MR::sum_subs ( size_t  j,
sub_nb  A,
Real *  sum_even,
Real *  sum_odd 
) [private]

Calculate sum over all even/odd subsets B of A of _tJ(j,B) appM(j,B).

Parameters:
j variable index
A subset of neighbors of variable j
sum_even on return, will contain the sum over all even subsets
sum_odd on return, will contain the sum over all odd subsets

Member Data Documentation

bool dai::MR::supported [private]

Is the underlying factor graph supported?

GraphAL dai::MR::G [private]

The interaction graph (Markov graph).

std::vector<std::vector<Real> > dai::MR::tJ [private]

tJ[i][_j] is the hyperbolic tangent of the interaction between spin i and its neighbour G.nb(i,_j)

std::vector<Real> dai::MR::theta [private]

theta[i] is the local field on spin i

std::vector<std::vector<Real> > dai::MR::M [private]

M[i][_j] is $ M^{(i)}_j $.

std::vector<std::vector<std::vector<Real> > > dai::MR::cors [private]

Cavity correlations.

std::vector<Real> dai::MR::Mag [private]

Magnetizations.

Real dai::MR::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::MR::_iters [private]

Number of iterations needed.

const char * dai::MR::Name = "MR" [static]

Name of this inference method.

The documentation for this class was generated from the following files:
  • include/dai/mr.h
  • src/mr.cpp
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Var.html0000644000263000017630000005220611433220722016754 0ustar jorismkyb libDAI: dai::Var Class Reference

dai::Var Class Reference

Represents a discrete random variable. More...

#include <dai/var.h>

List of all members.

Public Member Functions

 Var ()
 Default constructor (creates a variable with label 0 and 0 states).
 Var (size_t label, size_t states)
 Constructs a variable with a given label and number of states.
size_t label () const
 Returns the label.
size_t & label ()
 Returns reference to label.
size_t states () const
 Returns the number of states.
size_t & states ()
 Returns reference to number of states.
bool operator< (const Var &n) const
 Smaller-than operator (only compares labels).
bool operator> (const Var &n) const
 Larger-than operator (only compares labels).
bool operator<= (const Var &n) const
 Smaller-than-or-equal-to operator (only compares labels).
bool operator>= (const Var &n) const
 Larger-than-or-equal-to operator (only compares labels).
bool operator!= (const Var &n) const
 Not-equal-to operator (only compares labels).
bool operator== (const Var &n) const
 Equal-to operator (only compares labels).

Private Attributes

size_t _label
 Label of the variable (its unique ID).
size_t _states
 Number of possible values.

Friends

std::ostream & operator<< (std::ostream &os, const Var &n)
 Writes a Var to an output stream.

Detailed Description

Represents a discrete random variable.

A Var stores the label of the variable (an unsigned integer-valued unique ID) and the number of possible values (states) of that variable. Two Var objects with the same label are assumed to be identical (i.e., it is assumed that they have the same number of possible states).

In the documentation, we use the following notational conventions. The discrete random variable with label $l$ is denoted as $x_l$, and the number of possible values of this variable as $S_l$; this is represented in code by the object Var($l$,$S_l$). The set of possible values of variable $x_l$ is denoted $X_l := \{0,1,\dots,S_l-1\}$.

Examples:

example_imagesegmentation.cpp, example_permute.cpp, example_sprinkler.cpp, and example_varset.cpp.

Constructor & Destructor Documentation

dai::Var::Var (  )  [inline]

Default constructor (creates a variable with label 0 and 0 states).

dai::Var::Var ( size_t  label,
size_t  states 
) [inline]

Constructs a variable with a given label and number of states.

Member Function Documentation

size_t dai::Var::label (  )  const [inline]

Returns the label.

Examples:
example_sprinkler_gibbs.cpp.

size_t& dai::Var::label (  )  [inline]

Returns reference to label.

size_t dai::Var::states (  )  const [inline]

Returns the number of states.

Examples:
example_varset.cpp.

size_t& dai::Var::states (  )  [inline]

Returns reference to number of states.

bool dai::Var::operator< ( const Var &  n  )  const [inline]

Smaller-than operator (only compares labels).

bool dai::Var::operator> ( const Var &  n  )  const [inline]

Larger-than operator (only compares labels).

bool dai::Var::operator<= ( const Var &  n  )  const [inline]

Smaller-than-or-equal-to operator (only compares labels).

bool dai::Var::operator>= ( const Var &  n  )  const [inline]

Larger-than-or-equal-to operator (only compares labels).

bool dai::Var::operator!= ( const Var &  n  )  const [inline]

Not-equal-to operator (only compares labels).

bool dai::Var::operator== ( const Var &  n  )  const [inline]

Equal-to operator (only compares labels).

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const Var &  n 
) [friend]

Writes a Var to an output stream.

Member Data Documentation

size_t dai::Var::_label [private]

Label of the variable (its unique ID).

size_t dai::Var::_states [private]

Number of possible values.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1CBP-members.html0000644000263000017630000003203011433220722020251 0ustar jorismkyb libDAI: Member List

dai::CBP Member List

This is the complete list of members for dai::CBP, including all inherited members.

_beliefsFdai::CBP [private]
_beliefsVdai::CBP [private]
_clamp_ofstreamdai::CBP [private]
_itersdai::CBP [private]
_logZdai::CBP [private]
_maxdiffdai::CBP [private]
_num_leavesdai::CBP [private]
_sum_leveldai::CBP [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
BBPFindClampVar(const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut)dai::CBP [related]
belief(const Var &v) const dai::CBP [inline, virtual]
belief(const VarSet &) const dai::CBP [inline, virtual]
beliefF(size_t I) const dai::CBP [inline, virtual]
beliefs() const dai::CBP [inline, virtual]
beliefV(size_t i) const dai::CBP [inline, virtual]
CBP(const FactorGraph &fg, const PropertySet &opts)dai::CBP [inline]
chooseNextClampVar(InfAlg *bp, std::vector< size_t > &clamped_vars_list, size_t &i, std::vector< size_t > &xis, Real *maxVarOut)dai::CBP [private, virtual]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::CBP [inline, virtual]
construct()dai::CBP [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::InfAlg [inline, virtual]
getInfAlg()dai::CBP [private]
getProperties() const dai::CBP [inline, virtual]
identify() const dai::CBP [inline, virtual]
init()dai::CBP [inline, virtual]
init(const VarSet &)dai::CBP [inline, virtual]
Iterations() const dai::CBP [inline, virtual]
logZ() const dai::CBP [inline, virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::CBP [inline, virtual]
Namedai::CBP [static]
printDebugInfo()dai::CBP [private]
printProperties() const dai::CBP [inline, virtual]
props (defined in dai::CBP)dai::CBP
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::CBP [virtual]
runRecurse(InfAlg *bp, Real orig_logZ, std::vector< size_t > clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, std::vector< Factor > &beliefs_out)dai::CBP [private]
setBeliefs(const std::vector< Factor > &bs, Real logZ)dai::CBP [private]
setMaxIter(size_t maxiter)dai::CBP [inline, virtual]
setProperties(const PropertySet &opts)dai::CBP [inline, virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__max.html0000644000263000017630000000762311433220722020056 0ustar jorismkyb libDAI: dai::fo_max< T > Struct Template Reference

dai::fo_max< T > Struct Template Reference

Function object that returns the maximum of two values. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (x > y ? x : y).

Detailed Description

template<typename T>
struct dai::fo_max< T >

Function object that returns the maximum of two values.

Member Function Documentation

template<typename T>
T dai::fo_max< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns (x > y ? x : y).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_131.png0000644000263000017630000000117711433220722015230 0ustar jorismkyb‰PNG  IHDRzfÐ×à0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfýIDAT8ÅRÏkQþ6»›d“M6Ó›ºETJB½ÕCÒBêÁŸmý|‚±…¶b$—‚–R< ”ÒÆÓ‚‚(TE¡§•B¥`¼xŽô؈xœÙ4ݤ­à¥tó˜o曟8N¹ÿŒd¾ Ðþ“h³šìO§3_SúШ­¬uÚÓ¬âu®7”–h^ìj§iø)ÿ°.ì&þÅÎïcç|°ÅÔD‘ôf2£wîé`gF Ž Rd˜Z…Áh«”¾¬;ÀMbÇÄÕÀµíDÛBò!7ž+ÇK&Mª¸>ºµëíÝV=´þFÖ-‡«%ä¹€mJÝûuq“6ÁuͶÜ^”f/ ñÒ½M£=±áájµºHlKªrLÂ’‡7ÙKþò ÐêæÓ¨±Æ$’³sÔ\RdµÙ ¶%5¯t°ì!†ýÆýéƇ½Œ>bŸ.dÏ,örØ'}=`GjñJéb Vê3ÁªÃà«ÜÙ’÷*øF3Þ(kõÍU×…ò¥EV^L¿Æó·¿¡>úIp„‡ q!ù@€†Q7vÏÈƬÐEÚ?1¸8E‰<‚cl›6©;öI(ï%0øƒ *õJx‡|¢ƒW¼ÖK¿¾Îæ -ôÝÊ馿«ùœ DiµH?@á_Оö¼}0òˆå/s²>:IEND®B`‚libDAI-0.2.7/doc/html/license.html0000644000263000017630000004670311433220722015507 0ustar jorismkyb libDAI: License

License

License

libDAI is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

libDAI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

GNU General Public License version 2

		    GNU GENERAL PUBLIC LICENSE
		       Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

			    Preamble

  The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

  To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

  We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

  Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

  Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

  The precise terms and conditions for copying, distribution and
modification follow.

		    GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

  0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

  1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

  2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

  3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

    a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

    b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

    c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

  4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

  5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

  6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

  7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

  8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

  9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

  10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

			    NO WARRANTY

  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

		     END OF TERMS AND CONDITIONS

	    How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA


Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

    Gnomovision version 69, Copyright (C) year name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:

  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

  <signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice

This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Library General
Public License instead of this License.
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1DAIAlg.png0000644000263000017630000000355411433220722017067 0ustar jorismkyb‰PNG  IHDR€’ÓûäPLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfIDATxœíÝan«8†á ‘æwì˜n`4³¡‘Fêþ—01ðM“†¶Oš÷»mÔ$½å©cz¹œsùçXþºœ‘¿ûC¢Âë& wÝpÇ·@ôBÜnB¨Þ÷ÎO#á]üxD¸PáƒqóÛ‹7}$ wê!â DŠ¨9qä]†p®"ä#úñåi0'¾"*ΉqïðãÄLU÷ŽÇ1€¨:'ÆÝù¡ùËÿñÞ‡üOòg<‹ Äç¿­ˆ???[Œ lLL „B¡€P@(  „B©ƒpÇr=qð«€QÑÍ7ã|¿&osœ»tñ]ŸZ1ݽ}ÜuÃ]¶xox¿=æ \wûGÉuÙüxëºä "ºÛ½Æo3¾ÅG’?ñ¹KwMÝÀ<¿èu‰ ÑÍ›s×aNLˆ…v¢s "ÎÎé6nñªOI—ëø©ƒâTÄ5‰85—Ûe$¦‰)ÄÙ#áÄðâ$͉ˆéæÑ8}NŒ{G7nÒ]3IJwܦD†Xþú9ˆoÓ}ûlDgqyrØòÛþ"‰‰Cþ'y£ÿ=‰…’¤ „‰’¤ „‰ B¡€P@(  „B¡€P@(¯ƒøãào Ÿƒ8ö«ø @ÔE,§Î ïÍ1±ÉñaÏiQDÖxÚ ‘5ž6C$§ÍæDÖx:ŒÄ^Äç†ü÷±ô|B‰`‘6žÆ9ѱ5 L!,Y}X@X8Æü°€8íhÛÂ!é€P@(  „B¡€P@(  „By„‰“$¿á<&ˆ·A„ù¦Ÿ*`ª`Åúè»z`A„ ·ï|”<©Œ–C KðöZó´"‚_F¢Åœˆˆàüúå؇Ø[ óJÀ' ö„›ÉÞQ1î!LË"÷ßTFýOL @XAX8ä/ „B¡€P@(  „B¡€P@(¯ƒ0q’ÄÆé" ž ²6ÑôÁñ2¥nuÅ»‚ˆ˜´üçbwÚt‘мúR‘·‰ÕÑx¿."o¯y£y?^$´"½>éR\5æDÞ&â6Ç:m˜ë*q‰ºhÞ&Æq™z Úœè§½cFùŠˆU›¨öŽºˆpÈ_:  „B¡€P@(  „B¡€P^aâ$‰ÓE @ÖD×Õᢈ¼itºïT)­…H›Fƒ›{ï-›Z‘6Î’»^Žëè~i¢ê˱4ß~“9‘4öÃ/ ´Ø;~ @¼ÂÂ!é€P@(  „B¡€P@(  „By„‰“$6N± ±´eúå­j ¬_5jñÚ¦×w¯¡Xíú¢Ór¥wkÄu®/êÜ´fêºg¶"iVÐÝùr쬋®›FçŽ+„»‡¨¼‹&M£ âÞPüúŸ˜ @€°‚°pÈ_:  „B¡€P@(  „B¡€P^aâ$‰ÓE @l@¤‹Õz·¾|dMÄ”ûŸòˆ¤*ª®Õa­ÐP±#.­Š ±ô(VC,Uѹ·BUÑáÜ— œnCì«‹æUÑy$î÷2Ÿ9¢îË‘VEã1ötWÞ;~¦Ž¬>, ,c~X@œv´má¿t@(  „B¡€P@(  „B¡¼ÂÄI’ßpÄ;!æµt§Ávˆ~B„G éE¬ÖÒ}X#.ŠX­¥Û‘®¥Û±¬¥{±·_´_¯¥ÛxNôí÷Ža-ÝX¡nõsb[@€ñ ‡ü¥B¡€P@(  „B¡€P@(  åu&N’Ø8]ÄFDV qéÔVˆ˜àûÞ=¬?]Ì7)‹6C¤eÑ{V› ’²è€xÔH\1—EýÝëinE쯋feÑcˆ#‘–Eç‹VF¤eÑfˆÍÄ; ,ò—„B¡€P@(  „B¡€P@( ”×A˜8Ibãt_ê¢ šÑ¾ÖEï/§[¹.Zq§.Úa´.ºqj]tç˱)›ë¢õwê¢õ›ˆw@<äÿŸ'”«ZJlVIEND®B`‚libDAI-0.2.7/doc/html/form_136.png0000644000263000017630000000052511433220722015231 0ustar jorismkyb‰PNG  IHDR7@\úû0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÓIDAT•c` ðÈq@(fl’ t#’úô¨Ž¨ˆ&B²Šá(XJ€KH™<Ég Ý ¹Â @± £¹@6·\òC?HµÂ>V…kæÌ82gÎœ9&Éù߀H}d`º–DÑ)hù(Éø½,™ÑÑÑÑ’ìJ^gXÀÃÀ­ºÁ˜GŒ‚‚‚@jÃ5 dˆ©—êf~^„k9à AÇ ¤€‡(8dØ` >ˆ2l’8ôn) Œ¡ûjIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1multifor-members.html0000644000263000017630000001027411433220722021514 0ustar jorismkyb libDAI: Member List

dai::multifor Member List

This is the complete list of members for dai::multifor, including all inherited members.

_indicesdai::multifor [private]
_linear_indexdai::multifor [private]
_rangesdai::multifor [private]
multifor()dai::multifor [inline]
multifor(const std::vector< size_t > &d)dai::multifor [inline]
operator size_t() const dai::multifor [inline]
operator++()dai::multifor [inline]
operator++(int)dai::multifor [inline]
operator[](size_t k) const dai::multifor [inline]
reset()dai::multifor [inline]
valid() const dai::multifor [inline]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/index.html0000644000263000017630000001556511433220722015176 0ustar jorismkyb libDAI: Reference manual for libDAI - A free/open source C++ library for Discrete Approximate Inference methods

Reference manual for libDAI - A free/open source C++ library for Discrete Approximate Inference methods

Author:
Joris Mooij (with contributions of Frederik Eaton)
Version:
0.2.7
Date:
August 19, 2010

About libDAI

libDAI is a free/open source C++ library (licensed under GPL 2+) that provides implementations of various (approximate) inference methods for discrete graphical models. libDAI supports arbitrary factor graphs with discrete variables; this includes discrete Markov Random Fields and Bayesian Networks.

The library is targeted at researchers. To be able to use the library, a good understanding of graphical models is needed.

The best way to use libDAI is by writing C++ code that invokes the library; in addition, part of the functionality is accessibly by using the

  • command line interface
  • (limited) MatLab interface
  • (experimental) python interface
  • (experimental) octave interface.

libDAI can be used to implement novel (approximate) inference algorithms and to easily compare the accuracy and performance with existing algorithms that have been implemented already.

A solver using libDAI was amongst the three winners of the UAI 2010 Approximate Inference Challenge (see http://www.cs.huji.ac.il/project/UAI10/ for more information). The full source code is provided as part of the library.

Features

Currently, libDAI supports the following (approximate) inference methods:
  • Exact inference by brute force enumeration;
  • Exact inference by junction-tree methods;
  • Mean Field;
  • Loopy Belief Propagation [KFL01];
  • Fractional Belief Propagation [WiH03];
  • Tree-Reweighted Belief Propagation [WJW03];
  • Tree Expectation Propagation [MiQ04];
  • Generalized Belief Propagation [YFW05];
  • Double-loop GBP [HAK03];
  • Various variants of Loop Corrected Belief Propagation [MoK07, MoR05];
  • Gibbs sampler;
  • Conditioned Belief Propagation [EaG09];
  • Decimation algorithm.

These inference methods can be used to calculate partition sums, marginals over subsets of variables, and MAP states (the joint state of variables that has maximum probability).

In addition, libDAI supports parameter learning of conditional probability tables by Expectation Maximization.

Limitations

libDAI is not intended to be a complete package for approximate inference. Instead, it should be considered as an "inference engine", providing various inference methods. In particular, it contains no GUI, currently only supports its own file format for input and output (although support for standard file formats may be added later), and provides very limited visualization functionalities. The only learning method supported currently is Expectation Maximization (or Maximum Likelihood if no data is missing) for learning factor parameters.

Rationale

In my opinion, the lack of open source "reference" implementations hampers progress in research on approximate inference. Methods differ widely in terms of quality and performance characteristics, which also depend in different ways on various properties of the graphical models. Finding the best approximate inference method for a particular application therefore often requires empirical comparisons. However, implementing and debugging these methods takes a lot of time which could otherwise be spent on research. I hope that this code will aid researchers to be able to easily compare various (existing as well as new) approximate inference methods, in this way accelerating research and stimulating real-world applications of approximate inference.

Language

Because libDAI is implemented in C++, it is very fast compared with implementations in MatLab (a factor 1000 faster is not uncommon). libDAI does provide a (limited) MatLab interface for easy integration with MatLab. It also provides a command line interface and experimental python and octave interfaces (thanks to Patrick Pletscher).

Compatibility

The code has been developed under Debian GNU/Linux with the GCC compiler suite. libDAI compiles successfully with g++ versions 3.4 up to 4.4.

libDAI has also been successfully compiled with MS Visual Studio 2008 under Windows (but not all build targets are supported yet) and with Cygwin under Windows.

Finally, libDAI has been compiled successfully on MacOS X.

Downloading libDAI

The libDAI sources and documentation can be downloaded from the libDAI website: http://www.libdai.org.

Mailing list

The Google group "libDAI" (http://groups.google.com/group/libdai) can be used for getting support and discussing development issues.
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/annotated.html0000644000263000017630000005700711433220722016041 0ustar jorismkyb libDAI: Class List

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
dai::BBPImplements BBP (Back-Belief-Propagation) [EaG09]
dai::BBP::PropertiesParameters for BBP
dai::BBPCostFunctionPredefined cost functions that can be used with BBP
dai::BipartiteGraphRepresents the neighborhood structure of nodes in an undirected, bipartite graph
dai::BipartiteGraph::levelTypeUsed internally by isTree()
dai::BPApproximate inference algorithm "(Loopy) Belief Propagation"
dai::BP::EdgePropType used for storing edge properties
dai::BP::PropertiesParameters for BP
dai::BP_dualCalculates both types of BP messages and their normalizers from an InfAlg
dai::BP_dual::_edges_t< T >Convenience label for storing edge properties
dai::BP_dual::beliefsGroups together the data structures for storing the two types of beliefs and their normalizers
dai::BP_dual::messagesGroups together the data structures for storing the two types of messages and their normalizers
dai::CBPClass for CBP (Conditioned Belief Propagation) [EaG09]
dai::CBP::PropertiesParameters for CBP
dai::ClusterGraphA ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges
dai::CondProbEstimationEstimates the parameters of a conditional probability table, using pseudocounts
dai::DAGRepresents the neighborhood structure of nodes in a directed cyclic graph
dai::DAIAlg< GRM >Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)
dai::DecMAPApproximate inference algorithm DecMAP, which constructs a MAP state by decimation
dai::DecMAP::PropertiesParameters for DecMAP
dai::DEdgeRepresents a directed edge
dai::EMAlgEMAlg performs Expectation Maximization to learn factor parameters
dai::EvidenceStores a data set consisting of multiple samples, where each sample is the observed joint state of some variables
dai::ExactInfExact inference algorithm using brute force enumeration (mainly useful for testing purposes)
dai::ExactInf::PropertiesParameters for ExactInf
dai::ExceptionError handling in libDAI is done by throwing an instance of the Exception class
dai::FactorGraphRepresents a factor graph
dai::FBPApproximate inference algorithm "Fractional Belief Propagation" [WiH03]
dai::fo_abs< T >Function object that takes the absolute value
dai::fo_absdiff< T >Function object that returns the absolute difference of x and y
dai::fo_divides0< T >Function object similar to std::divides(), but different in that dividing by zero results in zero
dai::fo_exp< T >Function object that takes the exponent
dai::fo_Hellinger< T >Function object useful for calculating the Hellinger distance
dai::fo_id< T >Function object that returns the value itself
dai::fo_inv< T >Function object that takes the inverse
dai::fo_inv0< T >Function object that takes the inverse, except that 1/0 is defined to be 0
dai::fo_KL< T >Function object useful for calculating the KL distance
dai::fo_log< T >Function object that takes the logarithm
dai::fo_log0< T >Function object that takes the logarithm, except that log(0) is defined to be 0
dai::fo_max< T >Function object that returns the maximum of two values
dai::fo_min< T >Function object that returns the minimum of two values
dai::fo_plog0p< T >Function object that returns p*log0(p)
dai::fo_pow< T >Function object that returns x to the power y
dai::FRegionAn FRegion is a factor with a counting number
dai::GibbsApproximate inference algorithm "Gibbs sampling"
dai::Gibbs::PropertiesParameters for Gibbs
dai::GraphALRepresents the neighborhood structure of nodes in an undirected graph
dai::GraphELRepresents an undirected graph, implemented as a std::set of undirected edges
dai::greedyVariableEliminationHelper object for dai::ClusterGraph::VarElim()
dai::HAKApproximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]
dai::HAK::PropertiesParameters for HAK
dai::hash_map< T, U, H >Hash_map is an alias for std::tr1::unordered_map
dai::IndexForTool for looping over the states of several variables
dai::InfAlgInfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI
dai::JTreeExact inference algorithm using junction tree
dai::JTree::PropertiesParameters for JTree
dai::LCApproximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]
dai::LC::PropertiesParameters for LC
dai::MaximizationStepA MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit
dai::MFApproximate inference algorithm "Mean Field"
dai::MF::PropertiesParameters for MF
dai::MRApproximate inference algorithm by Montanari and Rizzo [MoR05]
dai::MR::PropertiesParameters for MR
dai::multiforMultifor makes it easy to perform a dynamic number of nested for loops
dai::NeighborDescribes the neighbor relationship of two nodes in a graph
dai::ParameterEstimationBase class for parameter estimation methods
dai::PermuteTool for calculating permutations of linear indices of multi-dimensional arrays
dai::PropertySetRepresents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue)
dai::RegionA Region is a set of variables with a counting number
dai::RegionGraphA RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph
dai::RootedTreeRepresents a rooted tree, implemented as a vector of directed edges
dai::sequentialVariableEliminationHelper object for dai::ClusterGraph::VarElim()
dai::SharedParametersRepresents a single factor or set of factors whose parameters should be estimated
dai::SmallSet< T >Represents a set; the implementation is optimized for a small number of elements
dai::StateMakes it easy to iterate over all possible joint states of variables within a VarSet
dai::TFactor< T >Represents a (probability) factor
dai::TProb< T >Represents a vector with entries of type T
dai::TreeEPApproximate inference algorithm "Tree Expectation Propagation" [MiQ04]
dai::TreeEP::PropertiesParameters for TreeEP
dai::TreeEP::TreeEPSubTreeStores the data structures needed to efficiently update the approximation of an off-tree factor
dai::TRWBPApproximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]
dai::UEdgeRepresents an undirected edge
dai::VarRepresents a discrete random variable
dai::VarSetRepresents a set of variables
dai::WeightedGraph< T >Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights
Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/trwbp_8h.html0000644000263000017630000000546311433220722015620 0ustar jorismkyb libDAI: include/dai/trwbp.h File Reference

include/dai/trwbp.h File Reference

Defines class TRWBP, which implements Tree-Reweighted Belief Propagation. More...

#include <string>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>
#include <dai/enum.h>
#include <dai/bp.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::TRWBP
 Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]. More...

Detailed Description

Defines class TRWBP, which implements Tree-Reweighted Belief Propagation.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_113.png0000644000263000017630000000042611433220722015224 0ustar jorismkyb‰PNG  IHDRe›à°0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf”IDAT•c`À `l.¦„Lj¹aœÅ  Ü PÎE† ¾¸™f=¸È #â40|b˜°„¡#Gh(ˆ Vˆœ€(ÚâðÕ200€ “@rI<ˆ‚rV1ã7;ão#Û ‡Q¨Ç9 I_K‚ÍÊÀ‡àd0èÃ½Æ ÀÀ¢³! ¼©¸ÖIEND®B`‚libDAI-0.2.7/doc/html/form_75.png0000644000263000017630000000067411433220722015160 0ustar jorismkyb‰PNG  IHDRP>¯Dù0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf:IDAT(‘c` àè ¹> å@ø`WÈø D6#Y±‡‘ö@‚……ìa¬$Q°BÆPS—U¡@•g¡4«œÁE°B†Íì ÛR7É¢(”‡ºžÕ—áSPá1†xÞ„.†È~d „äÌ™3AjØ.@uÌ`ø 6ñƒ½xÃ2>{¹A.cH``xÊôÁC¬ÐŸ=Èçg¨em@R¸L00|âˆ1*¬eØÉlÈÀàÏpI )€9AÖ3³:0°\)e`ðZʶ«€ãÔú†Y È&Fˆà  œ@ÁŽˆ  ã†Ç ¼!puL@øÀ‘Àès¨(—GÇO`¼9 ¼²sæÌÙï'ð10 9Ü$Q ` À&J©¡HUÁâÑIEND®B`‚libDAI-0.2.7/doc/html/form_17.png0000644000263000017630000000027411433220722015150 0ustar jorismkyb‰PNG  IHDR ¤[AÔ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf:IDAT™c`€–µ j©Ô É£À“¤f2°Ä>°~SŠý;bú#0Äû©7 À½ ÿTí^!IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1VarSet-members.html0000644000263000017630000003404211433220722021056 0ustar jorismkyb libDAI: Member List

dai::VarSet Member List

This is the complete list of members for dai::VarSet, including all inherited members.

back()dai::SmallSet< T > [inline]
back() const dai::SmallSet< T > [inline]
begin()dai::SmallSet< T > [inline]
begin() const dai::SmallSet< T > [inline]
const_iterator typedefdai::SmallSet< T >
const_reverse_iterator typedefdai::SmallSet< T >
contains(const T &t) const dai::SmallSet< T > [inline]
elements()dai::SmallSet< T > [inline]
elements() const dai::SmallSet< T > [inline]
empty() const dai::SmallSet< T > [inline]
end()dai::SmallSet< T > [inline]
end() const dai::SmallSet< T > [inline]
erase(const T &t)dai::SmallSet< T > [inline]
front()dai::SmallSet< T > [inline]
front() const dai::SmallSet< T > [inline]
insert(const T &t)dai::SmallSet< T > [inline]
intersects(const SmallSet &x) const dai::SmallSet< T > [inline]
iterator typedefdai::SmallSet< T >
nrStates() const dai::VarSet [inline]
operator &(const SmallSet &x) const dai::SmallSet< T > [inline]
operator &=(const SmallSet &x)dai::SmallSet< T > [inline]
operator!=(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator/(const SmallSet &x) const dai::SmallSet< T > [inline]
operator/=(const SmallSet &x)dai::SmallSet< T > [inline]
operator/=(const T &t)dai::SmallSet< T > [inline]
operator<(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator<<(std::ostream &os, const VarSet &vs)dai::VarSet [friend]
dai::SmallSet::operator<<(const SmallSet &x) const dai::SmallSet< T > [inline]
dai::SmallSet::operator<<(std::ostream &os, const SmallSet &x)dai::SmallSet< T > [friend]
operator==(const SmallSet &a, const SmallSet &b)dai::SmallSet< T > [friend]
operator>>(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|(const SmallSet &x) const dai::SmallSet< T > [inline]
operator|=(const SmallSet &x)dai::SmallSet< T > [inline]
operator|=(const T &t)dai::SmallSet< T > [inline]
rbegin()dai::SmallSet< T > [inline]
rbegin() const dai::SmallSet< T > [inline]
rend()dai::SmallSet< T > [inline]
rend() const dai::SmallSet< T > [inline]
reverse_iterator typedefdai::SmallSet< T >
size() const dai::SmallSet< T > [inline]
SmallSet()dai::SmallSet< T > [inline]
SmallSet(const T &t)dai::SmallSet< T > [inline]
SmallSet(const T &t1, const T &t2)dai::SmallSet< T > [inline]
SmallSet(TIterator begin, TIterator end, size_t sizeHint)dai::SmallSet< T > [inline]
VarSet()dai::VarSet [inline]
VarSet(const SmallSet< Var > &x)dai::VarSet [inline]
VarSet(const Var &v)dai::VarSet [inline]
VarSet(const Var &v1, const Var &v2)dai::VarSet [inline]
VarSet(VarIterator begin, VarIterator end, size_t sizeHint=0)dai::VarSet [inline]

Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BP__dual_1_1beliefs-members.html0000644000263000017630000000504511433220722023531 0ustar jorismkyb libDAI: Member List

dai::BP_dual::beliefs Member List

This is the complete list of members for dai::BP_dual::beliefs, including all inherited members.

b1dai::BP_dual::beliefs
b2dai::BP_dual::beliefs
Zb1dai::BP_dual::beliefs
Zb2dai::BP_dual::beliefs

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1JTree_1_1Properties.html0000644000263000017630000003270711433220722022175 0ustar jorismkyb libDAI: dai::JTree::Properties Struct Reference

dai::JTree::Properties Struct Reference

Parameters for JTree. More...

#include <dai/jtree.h>

List of all members.

Public Member Functions

 DAI_ENUM (UpdateType, HUGIN, SHSH)
 Enumeration of possible JTree updates.
 DAI_ENUM (InfType, SUMPROD, MAXPROD)
 Enumeration of inference variants.
 DAI_ENUM (HeuristicType, MINNEIGHBORS, MINWEIGHT, MINFILL, WEIGHTEDMINFILL)
 Enumeration of elimination cost functions used for constructing the junction tree.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
UpdateType updates
 Type of updates.
InfType inference
 Type of inference.
HeuristicType heuristic
 Heuristic to use for constructing the junction tree.
size_t maxmem
 Maximum memory to use in bytes (0 means unlimited).

Detailed Description

Parameters for JTree.

Member Function Documentation

dai::JTree::Properties::DAI_ENUM ( UpdateType  ,
HUGIN  ,
SHSH   
)

Enumeration of possible JTree updates.

There are two types of updates:

  • HUGIN similar to those in HUGIN
  • SHSH Shafer-Shenoy type

dai::JTree::Properties::DAI_ENUM ( InfType  ,
SUMPROD  ,
MAXPROD   
)

Enumeration of inference variants.

There are two inference variants:

  • SUMPROD Sum-Product
  • MAXPROD Max-Product (equivalent to Min-Sum)

dai::JTree::Properties::DAI_ENUM ( HeuristicType  ,
MINNEIGHBORS  ,
MINWEIGHT  ,
MINFILL  ,
WEIGHTEDMINFILL   
)

Enumeration of elimination cost functions used for constructing the junction tree.

The cost of eliminating a variable can be (

See also:
[KoF09], page 314)):
  • MINNEIGHBORS the number of neighbors it has in the current adjacency graph;
  • MINWEIGHT the product of the number of states of all neighbors in the current adjacency graph;
  • MINFILL the number of edges that need to be added to the adjacency graph due to the elimination;
  • WEIGHTEDMINFILL the sum of weights of the edges that need to be added to the adjacency graph due to the elimination, where a weight of an edge is the produt of weights of its constituent vertices. The elimination sequence is chosen greedily in order to minimize the cost.

Member Data Documentation

size_t dai::JTree::Properties::verbose

Verbosity (amount of output sent to stderr).

UpdateType dai::JTree::Properties::updates

Type of updates.

InfType dai::JTree::Properties::inference

Type of inference.

HeuristicType dai::JTree::Properties::heuristic

Heuristic to use for constructing the junction tree.

size_t dai::JTree::Properties::maxmem

Maximum memory to use in bytes (0 means unlimited).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_81.png0000644000263000017630000000203711433220722015150 0ustar jorismkyb‰PNG  IHDRü"‰±© 0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIDATX…í–MhÔ@Çÿ™d7i»ÙÍÚ–^„ƯŠà!R=XЦՊ"â *zѵÖUÐC h…FÑRE4„öVP¢ z‹xò¢­^\‘¡ šã:›ÝG ?± sYe<³¤¨ºß³8>a7:Œgx–òáÅ_A~ªaúÅ·Š²T|} ¯*®2‘BL± ŸhKÝɃ¨†4¹é½X/ ëâO#é ü戮ªßúãöðÀc¨ôÓÃì…X±*S̽I w'²YXy³À—Þ<÷“\º¶"´EðbÎræîÐC+«£mä;è”Ð ´õ „¸l'Z{ qH6ZÎSd“œ¬7Í._Œ½Üm<ƒ¸6Ž¬°ée"xWêN ‚qY4zÍNQKÆsÄ=1ó”–³½ÁØ$9ŒHTÀG6v¿± Ϭ0ÉAžFßö}´§tï´ü•Ëhk2hð5ÿZ±ó‘@ªìäInzfñ‡P+«Ê'9þkuü¿5åÕ¯{¸ñkÞ¬^H§5Ð÷N}èÿ­NÆ>uBœÓþ¢ “ÚŸƒþ¢p?ÇO¥¾Eœ6¤Ú~m‹®¢{'§‡Ê6jŠoÈ&:;éŒ(â'¶¹5Å'õD.Gg„L‡ÅmÖóV±jŠW3¼ø[pW|ºÙV´O¥¯ŒÚ3pmú²ˆõc©m2kŠçVËÍö7²nî¢í)O‚IEND®B`‚libDAI-0.2.7/doc/html/evidence_8h-source.html0000644000263000017630000002422211433220722017534 0ustar jorismkyb libDAI: include/dai/evidence.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1VarSet.html0000644000263000017630000004120711433220722017427 0ustar jorismkyb libDAI: dai::VarSet Class Reference

dai::VarSet Class Reference

Represents a set of variables. More...

#include <dai/varset.h>

Inheritance diagram for dai::VarSet:

dai::SmallSet< T > dai::Region

List of all members.

Public Member Functions

Constructors and destructors
 VarSet ()
 Default constructor (constructs an empty set).
 VarSet (const SmallSet< Var > &x)
 Construct from SmallSet<Var> x.
 VarSet (const Var &v)
 Construct a VarSet with one element, v.
 VarSet (const Var &v1, const Var &v2)
 Construct a VarSet with two elements, v1 and v2.
template<typename VarIterator>
 VarSet (VarIterator begin, VarIterator end, size_t sizeHint=0)
 Construct a VarSet from the range between begin and end.
Queries
long double nrStates () const
 Calculates the number of states of this VarSet, which is simply the number of possible joint states of the variables in *this.

Friends

Input and output
std::ostream & operator<< (std::ostream &os, const VarSet &vs)
 Writes a VarSet to an output stream.

Detailed Description

Represents a set of variables.

Note:
A VarSet is implemented using a SmallSet<Var> instead of the more natural std::set<Var> because of efficiency reasons. That is, internally, the variables in the set are sorted ascendingly according to their labels.
Examples:

example_permute.cpp, example_sprinkler.cpp, example_varset.cpp, and uai2010-aie-solver.cpp.

Constructor & Destructor Documentation

dai::VarSet::VarSet (  )  [inline]

Default constructor (constructs an empty set).

dai::VarSet::VarSet ( const SmallSet< Var > &  x  )  [inline]

Construct from SmallSet<Var> x.

dai::VarSet::VarSet ( const Var &  v  )  [inline]

Construct a VarSet with one element, v.

dai::VarSet::VarSet ( const Var &  v1,
const Var &  v2 
) [inline]

Construct a VarSet with two elements, v1 and v2.

template<typename VarIterator>
dai::VarSet::VarSet ( VarIterator  begin,
VarIterator  end,
size_t  sizeHint = 0 
) [inline]

Construct a VarSet from the range between begin and end.

Template Parameters:
VarIterator Iterates over instances of type Var.
Parameters:
begin Points to first Var to be added.
end Points just beyond last Var to be added.
sizeHint For efficiency, the number of elements can be speficied by sizeHint.

Member Function Documentation

long double dai::VarSet::nrStates (  )  const [inline]

Calculates the number of states of this VarSet, which is simply the number of possible joint states of the variables in *this.

The number of states of the Cartesian product of the variables in this VarSet is simply the product of the number of states of each variable in this VarSet. If *this corresponds with the set $\{x_l\}_{l\in L}$, where variable $x_l$ has label $l$, and denoting by $S_l$ the number of possible values ("states") of variable $x_l$, the number of joint configurations of the variables in $\{x_l\}_{l\in L}$ is given by $\prod_{l\in L} S_l$.

Examples:
example_permute.cpp, and example_varset.cpp.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const VarSet &  vs 
) [friend]

Writes a VarSet to an output stream.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/cbp_8h.html0000644000263000017630000000615311433220722015223 0ustar jorismkyb libDAI: include/dai/cbp.h File Reference

include/dai/cbp.h File Reference

Defines class CBP, which implements Conditioned Belief Propagation. More...

#include <fstream>
#include <boost/shared_ptr.hpp>
#include <dai/daialg.h>
#include <dai/bbp.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::CBP
 Class for CBP (Conditioned Belief Propagation) [EaG09]. More...
struct  dai::CBP::Properties
 Parameters for CBP. More...

Detailed Description

Defines class CBP, which implements Conditioned Belief Propagation.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1TProb-members.html0000644000263000017630000005474211433220722020711 0ustar jorismkyb libDAI: Member List

dai::TProb< T > Member List

This is the complete list of members for dai::TProb< T >, including all inherited members.

_pdai::TProb< T > [private]
abs() const dai::TProb< T > [inline]
accumulateMax(T init, unOp op, bool minimize) const dai::TProb< T > [inline]
accumulateSum(T init, unOp op) const dai::TProb< T > [inline]
argmax() const dai::TProb< T > [inline]
begin()dai::TProb< T > [inline]
begin() const dai::TProb< T > [inline]
const_iterator typedefdai::TProb< T >
const_reverse_iterator typedefdai::TProb< T >
container_type typedefdai::TProb< T >
dist(const TProb< T > &p, const TProb< T > &q, ProbDistType dt)dai::TProb< T > [related]
divide(const this_type &q)dai::TProb< T > [inline]
divided_by(const this_type &q) const dai::TProb< T > [inline]
draw()dai::TProb< T > [inline]
end()dai::TProb< T > [inline]
end() const dai::TProb< T > [inline]
entropy() const dai::TProb< T > [inline]
exp() const dai::TProb< T > [inline]
fill(T x)dai::TProb< T > [inline]
get(size_t i) const dai::TProb< T > [inline]
hasNaNs() const dai::TProb< T > [inline]
hasNegatives() const dai::TProb< T > [inline]
innerProduct(const this_type &q, T init, binOp1 binaryOp1, binOp2 binaryOp2) const dai::TProb< T > [inline]
inverse(bool zero=true) const dai::TProb< T > [inline]
iterator typedefdai::TProb< T >
log(bool zero=false) const dai::TProb< T > [inline]
max() const dai::TProb< T > [inline]
max(const TProb< T > &a, const TProb< T > &b)dai::TProb< T > [related]
maxAbs() const dai::TProb< T > [inline]
min() const dai::TProb< T > [inline]
min(const TProb< T > &a, const TProb< T > &b)dai::TProb< T > [related]
normalize(ProbNormType norm=dai::NORMPROB)dai::TProb< T > [inline]
normalized(ProbNormType norm=dai::NORMPROB) const dai::TProb< T > [inline]
operator*(T x) const dai::TProb< T > [inline]
operator*(const this_type &q) const dai::TProb< T > [inline]
operator*=(T x)dai::TProb< T > [inline]
operator*=(const this_type &q)dai::TProb< T > [inline]
operator+(T x) const dai::TProb< T > [inline]
operator+(const this_type &q) const dai::TProb< T > [inline]
operator+=(T x)dai::TProb< T > [inline]
operator+=(const this_type &q)dai::TProb< T > [inline]
operator-() const dai::TProb< T > [inline]
operator-(T x) const dai::TProb< T > [inline]
operator-(const this_type &q) const dai::TProb< T > [inline]
operator-=(T x)dai::TProb< T > [inline]
operator-=(const this_type &q)dai::TProb< T > [inline]
operator/(T x) const dai::TProb< T > [inline]
operator/(const this_type &q) const dai::TProb< T > [inline]
operator/=(T x)dai::TProb< T > [inline]
operator/=(const this_type &q)dai::TProb< T > [inline]
operator<(const this_type &q) const dai::TProb< T > [inline]
operator<<(std::ostream &os, const TProb< T > &p)dai::TProb< T > [related]
operator==(const this_type &q) const dai::TProb< T > [inline]
operator[](size_t i) const dai::TProb< T > [inline]
operator^(T x) const dai::TProb< T > [inline]
operator^(const this_type &q) const dai::TProb< T > [inline]
operator^=(T x)dai::TProb< T > [inline]
operator^=(const this_type &q)dai::TProb< T > [inline]
p() const dai::TProb< T > [inline]
p()dai::TProb< T > [inline]
pwBinaryOp(const this_type &q, binaryOp op)dai::TProb< T > [inline]
pwBinaryTr(const this_type &q, binaryOp op) const dai::TProb< T > [inline]
pwUnaryOp(unaryOp op)dai::TProb< T > [inline]
pwUnaryTr(unaryOp op) const dai::TProb< T > [inline]
randomize()dai::TProb< T > [inline]
rbegin()dai::TProb< T > [inline]
rbegin() const dai::TProb< T > [inline]
rend()dai::TProb< T > [inline]
rend() const dai::TProb< T > [inline]
resize(size_t sz) (defined in dai::TProb< T >)dai::TProb< T > [inline]
reverse_iterator typedefdai::TProb< T >
set(size_t i, T val)dai::TProb< T > [inline]
setUniform()dai::TProb< T > [inline]
size() const dai::TProb< T > [inline]
sum() const dai::TProb< T > [inline]
sumAbs() const dai::TProb< T > [inline]
takeAbs()dai::TProb< T > [inline]
takeExp()dai::TProb< T > [inline]
takeLog(bool zero=false)dai::TProb< T > [inline]
this_type typedefdai::TProb< T >
TProb()dai::TProb< T > [inline]
TProb(size_t n)dai::TProb< T > [inline, explicit]
TProb(size_t n, T p)dai::TProb< T > [inline, explicit]
TProb(TIterator begin, TIterator end, size_t sizeHint)dai::TProb< T > [inline]
TProb(const std::vector< S > &v)dai::TProb< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1LC-members.html0000644000263000017630000003035311433220722020151 0ustar jorismkyb libDAI: Member List

dai::LC Member List

This is the complete list of members for dai::LC, including all inherited members.

_beliefsdai::LC [private]
_cavitydistsdai::LC [private]
_itersdai::LC [private]
_maxdiffdai::LC [private]
_pancakesdai::LC [private]
_phisdai::LC [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::LC [inline, virtual]
belief(const VarSet &) const dai::LC [virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::LC [inline, virtual]
beliefV(size_t i) const dai::LC [inline, virtual]
CalcBelief(size_t i)dai::LC
CalcCavityDist(size_t i, const std::string &name, const PropertySet &opts)dai::LC
cavitydist(size_t i) const dai::LC [inline]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::LC [inline, virtual]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::InfAlg [inline, virtual]
getProperties() const dai::LC [virtual]
identify() const dai::LC [virtual]
init()dai::LC [virtual]
init(const VarSet &)dai::LC [inline, virtual]
InitCavityDists(const std::string &name, const PropertySet &opts)dai::LC
Iterations() const dai::LC [inline, virtual]
LC()dai::LC [inline]
LC(const FactorGraph &fg, const PropertySet &opts)dai::LC
logZ() const dai::LC [inline, virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::LC [inline, virtual]
Namedai::LC [static]
NewPancake(size_t i, size_t _I, bool &hasNaNs)dai::LC
pancake(size_t i) const dai::LC [inline]
printProperties() const dai::LC [virtual]
props (defined in dai::LC)dai::LC
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::LC [virtual]
SetCavityDists(std::vector< Factor > &Q)dai::LC
setMaxIter(size_t maxiter)dai::LC [inline, virtual]
setProperties(const PropertySet &opts)dai::LC [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_26.png0000644000263000017630000000050211433220722015142 0ustar jorismkyb‰PNG  IHDR2¦u1¿0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfÀIDAT•c`À˜ ´0ºã5(ƒõš Çë*ºÌëf2l:^°Èð$0ð‹9°10Ìb`0‚ˆ}“«€XžhW!ƒCçt6ˆ wC4CÃJ–.猯Bía<°ŒUdò PAT†éK¦3CH†yƒÍÌé ,!³ýóY(Ãã dª2Ø‚…Ø!a Öæ%ÆLÍ ‘ àpÛªqª8X3k ±–(iùTòIEND®B`‚libDAI-0.2.7/doc/html/form_25.png0000644000263000017630000000125511433220722015147 0ustar jorismkyb‰PNG  IHDRp"uˆ@„0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf+IDAT8Õ”OhAÆ¿Ìî&éâ&´Ðƒ`""Vs°J·<šƒŠÁ€˜‚Ì­–*5ÇEZ/ ‚‚zðÞõèͨˆ×ª z2)¡ë›·›fã.tz¿Ã{ogÞoçí›Ùþ[5#Ù€…žøúc‰tò{›âý…³«¶¸kÞ!£d¦ºj¥êË~O*X‹ü4Ûñw^æZ=vâ/pä™\9Jʳ]B¡: ¿7Â8xû™‰þŒÁ€‡o±jDPKßKót#‹K´·ùñ¯¼ø#ûå’]˜å÷¾á„GÒÈã1s=òËE;¬…ù|3eë!·Ó3Ÿi{öÝÕÚp-Ú›úBº5©¯©jÌû°Q¤‡.4º8Dn™Ôàü{)¥Z5BÄ”'áhTáM;sv¢_0맀E“@?/È{aWÖën<4º'·ãÜè4ÕmÇ°D8–wž>{½$ë&ÁB™]n_„~Œò9uÜÁX’ÃÛpÁOH;äý~;IÎä¹Ýeº.ÁYÅߪ„òhÁVð‡ƒuO libDAI: Class Members
 

- _ -

  • _normal_rnd() : dai
  • _rnd_gen() : dai
  • _uni_dist() : dai
  • _uni_rnd() : dai

- a -

- c -

  • calcLinearState() : dai
  • calcMarginal() : dai
  • calcPairBeliefs() : dai
  • calcState() : dai
  • complement() : dai
  • concat() : dai
  • createFactorDelta() : dai
  • createFactorExpGauss() : dai
  • createFactorIsing() : dai
  • createFactorPotts() : dai
  • createGraphFull() : dai
  • createGraphGrid() : dai
  • createGraphGrid3D() : dai
  • createGraphLoop() : dai
  • createGraphRegular() : dai
  • createGraphTree() : dai

- d -

  • DAI_ENUM() : dai
  • dist() : dai

- e -

  • eliminationCost_MinFill() : dai
  • eliminationCost_MinNeighbors() : dai
  • eliminationCost_MinWeight() : dai
  • eliminationCost_WeightedMinFill() : dai
  • exp() : dai

- f -

  • Factors2mx() : dai
  • findMaximum() : dai
  • fromString() : dai

- g -

  • getFactorEntryForState() : dai

- i -

  • isnan() : dai

- l -

- m -

  • makePositive() : dai
  • makeZero() : dai
  • MaxSpanningTree() : dai
  • MinSpanningTree() : dai
  • mixBeliefs() : dai
  • mx2Factor() : dai
  • mx2Factors() : dai

- n -

  • newInfAlg() : dai
  • newInfAlgFromString() : dai

- o -

  • operator<<() : dai
  • operator>>() : dai

- p -

  • parseNameProperties() : dai
  • pow() : dai

- r -

  • readAliasesFile() : dai
  • ReadUaiAieEvidenceFile() : dai
  • ReadUaiAieFactorGraphFile() : dai
  • rnd() : dai
  • rnd_int() : dai
  • rnd_seed() : dai
  • rnd_stdnormal() : dai
  • rnd_uniform() : dai

- t -

  • toc() : dai
  • tokenizeString() : dai
  • toString() : dai

- u -

  • unSoftMax() : dai
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__min-members.html0000644000263000017630000000360011433220722021473 0ustar jorismkyb libDAI: Member List

dai::fo_min< T > Member List

This is the complete list of members for dai::fo_min< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_min< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x68.html0000644000263000017630000001236611433220722017673 0ustar jorismkyb libDAI: Class Members - Functions
 

- h -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1CBP_1_1Properties-members.html0000644000263000017630000001531011433220722023207 0ustar jorismkyb libDAI: Member List

dai::CBP::Properties Member List

This is the complete list of members for dai::CBP::Properties, including all inherited members.

bbp_cfndai::CBP::Properties
bbp_propsdai::CBP::Properties
choosedai::CBP::Properties
clampdai::CBP::Properties
clamp_outfiledai::CBP::Properties
DAI_ENUM(RecurseType, REC_FIXED, REC_LOGZ, REC_BDIFF)dai::CBP::Properties
DAI_ENUM(ChooseMethodType, CHOOSE_RANDOM, CHOOSE_MAXENT, CHOOSE_BBP, CHOOSE_BP_L1, CHOOSE_BP_CFN)dai::CBP::Properties
DAI_ENUM(ClampType, CLAMP_VAR, CLAMP_FACTOR)dai::CBP::Properties
get() const dai::CBP::Properties
max_levelsdai::CBP::Properties
maxiterdai::CBP::Properties
min_max_adjdai::CBP::Properties
rand_seeddai::CBP::Properties
rec_toldai::CBP::Properties
recursiondai::CBP::Properties
set(const PropertySet &opts)dai::CBP::Properties
toldai::CBP::Properties
toString() const dai::CBP::Properties
updatesdai::CBP::Properties
UpdateType typedefdai::CBP::Properties
verbosedai::CBP::Properties

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1JTree-members.html0000644000263000017630000003155511433220722020671 0ustar jorismkyb libDAI: Member List

dai::JTree Member List

This is the complete list of members for dai::JTree, including all inherited members.

_logZdai::JTree [private]
_mesdai::JTree [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const VarSet &vs) const dai::JTree [virtual]
dai::DAIAlg::belief(const Var &v) const dai::InfAlg [inline, virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::JTree [virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
boundTreewidth(const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates=0)dai::JTree [related]
calcMarginal(const VarSet &vs)dai::JTree
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::JTree [inline, virtual]
construct(const FactorGraph &fg, const std::vector< VarSet > &cl, bool verify=false)dai::JTree
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findEfficientTree(const VarSet &vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1) const dai::JTree
findMaximum() const dai::JTree [inline, virtual]
GenerateJT(const FactorGraph &fg, const std::vector< VarSet > &cl)dai::JTree
getProperties() const dai::JTree [virtual]
identify() const dai::JTree [virtual]
init()dai::JTree [inline, virtual]
init(const VarSet &)dai::JTree [inline, virtual]
Iterations() const dai::JTree [inline, virtual]
JTree()dai::JTree [inline]
JTree(const FactorGraph &fg, const PropertySet &opts, bool automatic=true)dai::JTree
logZ() const dai::JTree [virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::JTree [inline, virtual]
message(size_t alpha, size_t _beta) const dai::JTree [inline]
message(size_t alpha, size_t _beta)dai::JTree [inline]
Namedai::JTree [static]
printProperties() const dai::JTree [virtual]
props (defined in dai::JTree)dai::JTree
Qadai::JTree
Qbdai::JTree
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
RTreedai::JTree
run()dai::JTree [virtual]
runHUGIN()dai::JTree
runShaferShenoy()dai::JTree
setMaxIter(size_t)dai::InfAlg [inline, virtual]
setProperties(const PropertySet &opts)dai::JTree [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_74.png0000644000263000017630000000047511433220722015156 0ustar jorismkyb‰PNG  IHDR2ë½´0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf»IDAT•c` dtA6ŽO‚‚þÈ"š3”Á4óG{$ –ŒŸ°Ëð+0LÀ!ãÀ`€]†ëo#v‹û ÕXeøÚ2Ì@l¶%@b/Ã%„ Ó¦™SØŽbùÈPÆð!ÃÞÀ dó}Ìf93€eB†G¡ä`¨Uì¥`/=ì¯ÀÏÐ4M "­Ü?l÷Û8¨Ù• 1•ͽو©Ì½CÄ’Q¸¢0PÏKIEND®B`‚libDAI-0.2.7/doc/html/functions_func_0x65.html0000644000263000017630000001770411433220722017671 0ustar jorismkyb libDAI: Class Members - Functions
 

- e -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BP_1_1EdgeProp.html0000644000263000017630000001465011433220722021033 0ustar jorismkyb libDAI: dai::BP::EdgeProp Struct Reference

dai::BP::EdgeProp Struct Reference

Type used for storing edge properties. More...

#include <dai/bp.h>

List of all members.

Public Attributes

ind_t index
 Index cached for this edge.
Prob message
 Old message living on this edge.
Prob newMessage
 New message living on this edge.
Real residual
 Residual for this edge.

Detailed Description

Type used for storing edge properties.

Member Data Documentation

ind_t dai::BP::EdgeProp::index

Index cached for this edge.

Prob dai::BP::EdgeProp::message

Old message living on this edge.

Prob dai::BP::EdgeProp::newMessage

New message living on this edge.

Real dai::BP::EdgeProp::residual

Residual for this edge.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BipartiteGraph_1_1levelType-members.html0000644000263000017630000000423111433220722025325 0ustar jorismkyb libDAI: Member List

dai::BipartiteGraph::levelType Member List

This is the complete list of members for dai::BipartiteGraph::levelType, including all inherited members.

ind1dai::BipartiteGraph::levelType
ind2dai::BipartiteGraph::levelType

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x6c.html0000644000263000017630000001531011433220722016723 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- l -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x72.html0000644000263000017630000002422211433220722017660 0ustar jorismkyb libDAI: Class Members - Functions
 

- r -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/inline_dotgraph_3.dot.png0000644000263000017630000000140511433220722020050 0ustar jorismkyb‰PNG  IHDRRi"!!PLTEþÿÿ___ßßߟŸŸ???¿¿¿ÓÓÓÿÿÿ*ÛXtRNS@æØf’IDATX…µ˜KNä0†û# kÄ!X‰ Á9ظv£j•O $vR¿ü M§ò¥Êz¸}Ê£×éIcdZ.[²05dª v¨&ÅûÔ&)h;’ÃK®ÏOo¨§Š\ß}ÜÞ#ó€äro¬É“ÓÖˈš¤²×ûø|Ž¯ÑĺûÒ„NøüºD(’‰cîIÙÏú%HdþÉâ÷²$0ïHš%½ùã¤7oÉM×o®£ ;Q,ßÏ4Fº5äÖM÷ r &Q~2$ð9j‘,s‹Lê3jºd„4HÖHêêdÕݦõÜ'a]‚UÖ%\úkT¥ýu'÷>ò%¡ª¬ë>¸¨ÂRõy¬“u+)3IÛ#Crû^&f8K¤:‘C’Õ ­&&Ù“6#öI{§$ø }b¤€ô‰Ñ‘:Øn!É“KC«2mÊ,©‚­I$¿[†ÔU("ɪüÉ‚\vܦ&Oò‰Je•Uõ§U˜Å-g [É=OsF¶’ñû]¶rÖÝ·öB– ôX¬ˆ›ñY-¾ «^¶ÅÈ‹0ëe‚GæMk(E$Vj2í$ Í»<*uU&T^©¯†‘R_a¥ jJñî)&ƒ½70_C’(®ƒó:T1¹Õ®>8ô[ňôÛÏ€DG-xì`›ÜŸÏæØËxÿÈL‹Wº'±/ýÖæcòßu—¬ÿßêœvuÚ aßç[$>¶ëú|Û?‡×hbÝÇ} Û$8¶‹ÈìRIƒ4×'Ë43•Ý‹xŠIEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1Gibbs_1_1Properties.html0000644000263000017630000001657211433220722022214 0ustar jorismkyb libDAI: dai::Gibbs::Properties Struct Reference

dai::Gibbs::Properties Struct Reference

Parameters for Gibbs. More...

#include <dai/gibbs.h>

List of all members.

Public Attributes

size_t maxiter
 Maximum number of iterations.
double maxtime
 Maximum time (in seconds).
size_t restart
 Number of iterations after which a random restart is made.
size_t burnin
 Number of "burn-in" iterations after each (re)start (for which no statistics are gathered).
size_t verbose
 Verbosity (amount of output sent to stderr).

Detailed Description

Parameters for Gibbs.

Member Data Documentation

size_t dai::Gibbs::Properties::maxiter

Maximum number of iterations.

double dai::Gibbs::Properties::maxtime

Maximum time (in seconds).

size_t dai::Gibbs::Properties::restart

Number of iterations after which a random restart is made.

size_t dai::Gibbs::Properties::burnin

Number of "burn-in" iterations after each (re)start (for which no statistics are gathered).

size_t dai::Gibbs::Properties::verbose

Verbosity (amount of output sent to stderr).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_14.png0000644000263000017630000000136611433220722015150 0ustar jorismkyb‰PNG  IHDR"”Ï—0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØftIDATH‰å”ÏkAÇ¿ÛÝlvó£ÙõìAH­ô BVE‘ˆ¸…Š·B{×&уôlX‚”`1â`DPµ> in‡$ì+î—šo´Jø¶ú€b܆ë8·¸¿´í6®õ¥!¬Ä5$/Mz Ðì¤? ˆó·ØÓïPGxõ8pŒ¶UOjèêÞSV°o¤=u8á8 D1yàå,Ð^Òº2ô®“6Fô&oa‚QÆ]Ð!/Jª!7Û ”p\P÷ÒÖè¦gy=G%ÏGÕ`Hsè&3uà} $H’á‰KÍ‘¤"¥–%yzJ8ªÅ2i®ÊüÅÌ."S¸Xììƒ+,“ZüŽ3Zb åלèÈh=ƒ“ Ú(¾kÉ<å1cŒgñªhæ,Ù³û a‘„ËI %—kdت<«·C…ž9âª2£Ì¯×‘M «»ØCKËuf‰<]ª³äηÖA_gC¹b ²%Tÿÿw3³½Hl— w²ÌHô5%¢¯P]©Í_ŠS¼9³éÊè¡ó­¦-?n=à6X«o]×{þ›ÚB#(C¥ Å<‘ŠÔƒ‡SÖ!WÛ÷ñKº.αk˜•\ ‰eån‰Žæ΀࣠libDAI: libDAI file formats

libDAI file formats

Factor graph (.fg) file format

This section describes the .fg file format used in libDAI to store factor graphs. Markov Random Fields are special cases of factor graphs, as are Bayesian networks. A factor graph can be specified as follows: for each factor, one has to specify which variables occur in the factor, what their respective cardinalities (i.e., number of possible values) are, and a table listing all the values of that factor for all possible configurations of these variables.

A .fg file is not much more than that. It starts with a line containing the number of factors in that graph, followed by an empty line. Then all factors are specified, using one block for each factor, where the blocks are seperated by empty lines. Each variable occurring in the factor graph has a unique identifier, its label (which should be a nonnegative integer). Comment lines which start with # are ignored.

Factor block format

Each block describing a factor starts with a line containing the number of variables in that factor. The second line contains the labels of these variables, seperated by spaces (labels are nonnegative integers and to avoid confusion, it is suggested to start counting at 0). The third line contains the number of possible values of each of these variables, also seperated by spaces. Note that there is some redundancy here, since if a variable appears in more than one factor, the cardinality of that variable appears several times in the .fg file; obviously, these cardinalities should be consistent. The fourth line contains the number of nonzero entries in the factor table. The rest of the lines contain these nonzero entries; each line consists of a table index, followed by white-space, followed by the value corresponding to that table index. The most difficult part is getting the indexing right. The convention that is used is that the left-most variables cycle through their values the fastest (similar to MatLab indexing of multidimensional arrays).

Example

An example block describing one factor is:

  3
  4 8 7
  3 2 2
  11
  0 0.1
  1 3.5
  2 2.8
  3 6.3
  4 8.4
  6 7.4
  7 2.4
  8 8.9
  9 1.3
  10 1.6
  11 2.6

which corresponds to the following factor:

\[ \begin{array}{ccc|c} x_4 & x_8 & x_7 & \mbox{value}\\ \hline 0 & 0 & 0 & 0.1\\ 1 & 0 & 0 & 3.5\\ 2 & 0 & 0 & 2.8\\ 0 & 1 & 0 & 6.3\\ 1 & 1 & 0 & 8.4\\ 2 & 1 & 0 & 0.0\\ 0 & 0 & 1 & 7.4\\ 1 & 0 & 1 & 2.4\\ 2 & 0 & 1 & 8.9\\ 0 & 1 & 1 & 1.3\\ 1 & 1 & 1 & 1.6\\ 2 & 1 & 1 & 2.6 \end{array} \]

Note that the value of $x_4$ changes fastest, followed by that of $x_8$, and $x_7$ varies the slowest, corresponding to the second line of the block ("4 8 7"). Further, $x_4$ can take on three values, and $x_8$ and $x_7$ each have two possible values, as described in the third line of the block ("3 2 2"). The table contains 11 non-zero entries (all except for the fifth entry). Note that the eleventh and twelveth entries are interchanged.

A final note: the internal representation in libDAI of the factor above is different, because the variables are ordered according to their indices (i.e., the ordering would be $x_4 x_7 x_8$) and the values of the table are stored accordingly, with the variable having the smallest index changing fastest:

\[ \begin{array}{ccc|c} x_4 & x_7 & x_8 & \mbox{value}\\ \hline 0 & 0 & 0 & 0.1\\ 1 & 0 & 0 & 3.5\\ 2 & 0 & 0 & 2.8\\ 0 & 1 & 0 & 7.4\\ 1 & 1 & 0 & 2.4\\ 2 & 1 & 0 & 8.9\\ 0 & 0 & 1 & 6.3\\ 1 & 0 & 1 & 8.4\\ 2 & 0 & 1 & 0.0\\ 0 & 1 & 1 & 1.3\\ 1 & 1 & 1 & 1.6\\ 2 & 1 & 1 & 2.6 \end{array} \]

Evidence (.tab) file format

This section describes the .tab fileformat used in libDAI to store "evidence", i.e., a data set consisting of multiple samples, where each sample is the observed joint state of some variables.

A .tab file is a tabular data file, consisting of a header line, followed by an empty line, followed by the data points, with one line for each data point. Each line (apart from the empty one) should have the same number of columns, where columns are separated by one tab character. Each column corresponds to a variable. The header line consists of the variable labels (corresponding to dai::Var::label()). The other lines are observed joint states of the variables, i.e., each line corresponds to a joint observation of the variables, and each column of a line contains the state of the variable associated with that column. Missing data is handled simply by having two consecutive tab characters, without any characters in between.

Example

  1       3       2

  0       0       1
  1       0       1
  1               1

This would correspond to a data set consisting of three observations concerning the variables with labels 1, 3 and 2; the first observation being $x_1 = 0, x_3 = 0, x_2 = 1$, the second observation being $x_1 = 1, x_3 = 0, x_2 = 1$, and the third observation being $x_1 = 1, x_2 = 1$ (where the state of $x_3$ is missing).

Expectation Maximization (.em) file format

This section describes the file format of .em files, which are used to specify a particular EM algorithm. The .em files are complementary to .fg files; in other words, an .em file without a corresponding .fg file is useless. Furthermore, one also needs a corresponding .tab file containing the data used for parameter learning.

An .em file starts with a line specifying the number of maximization steps, followed by an empty line. Then, each maximization step is described in a block, which should satisfy the format described in the next subsection.

Maximization Step block format

A maximization step block of an .em file starts with a single line describing the number of shared parameters blocks that will follow. Then, each shared parameters block follows, in the format described in the next subsection.

Shared parameters block format

A shared parameters block of an .em file starts with a single line consisting of the name of a ParameterEstimation subclass and its parameters in the format of a PropertySet. For example: 
  CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1]
The next line contains the number of factors that share their parameters. Then, each of these factors is specified on separate lines (possibly seperated by empty lines), where each line consists of several fields seperated by a space or a tab character. The first field contains the index of the factor in the factor graph. The following fields should contain the variable labels of the variables on which that factor depends, in a specific ordering. This ordering can be different from the canonical ordering of the variables used internally in libDAI (which would be sorted ascendingly according to the variable labels). The ordering of the variables specifies the implicit ordering of the shared parameters: when iterating over all shared parameters, the corresponding index of the first variable changes fastest (in the inner loop), and the corresponding index of the last variable changes slowest (in the outer loop). By choosing the right ordering, it is possible to let different factors (depending on different variables) share parameters in parameter learning using EM. This convention is similar to the convention used in factor blocks in a factor graph .fg file (see Factor block format).

Aliases file format

An aliases file is basically a list of "macros" and the strings that they should be substituted with.

Each line of the aliases file can be either empty, contain a comment (if the first character is a '#') or contain an alias. In the latter case, the line should contain a colon; the part before the colon contains the name of the alias, the part after the colon the string that it should be substituted with. Any whitespace before and after the colon is ignored.

For example, the following line would define the alias BP_SEQFIX as a shorthand for "BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0]": 

  BP_SEQFIX:  BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0]

Aliases files can be used to store default options for algorithms.

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/citations.html0000644000263000017630000000410411433220722016047 0ustar jorismkyb libDAI: Citing libDAI

Citing libDAI

Citing libDAI

If you write a scientific paper describing research that made substantive use of this library, please cite the following paper describing libDAI:

Joris M. Mooij;
libDAI: A free & open source C++ library for Discrete Approximate Inference in graphical models;
Journal of Machine Learning Research, in press, 2010.

In BiBTeX format (for your convenience):

  @article{mooij2010libDAI,
    author  = {Joris M. Mooij},
    title   = {lib{DAI}: A free & open source {C}++ Library for {D}iscrete {A}pproximate {I}nference in graphical models},
    journal = {Journal of Machine Learning Research},
    volume  = {in press},
    year    = 2010
  }

Moreover, as a personal note, I would appreciate it to be informed about any publications using libDAI at joris dot mooij at libdai dot org.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/varset_8h.html0000644000263000017630000000737711433220722015774 0ustar jorismkyb libDAI: include/dai/varset.h File Reference

include/dai/varset.h File Reference

Defines the VarSet class, which represents a set of random variables. More...

#include <vector>
#include <map>
#include <ostream>
#include <dai/var.h>
#include <dai/util.h>
#include <dai/smallset.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::VarSet
 Represents a set of variables. More...

Functions

size_t dai::calcLinearState (const VarSet &vs, const std::map< Var, size_t > &state)
 Calculates the linear index in the Cartesian product of the variables in vs that corresponds to a particular joint assignment of the variables, specified by state.
std::map< Var, size_t > dai::calcState (const VarSet &vs, size_t linearState)
 Calculates the joint assignment of the variables in vs corresponding to the linear index linearState.

Detailed Description

Defines the VarSet class, which represents a set of random variables.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1FRegion-members.html0000644000263000017630000005047311433220722021211 0ustar jorismkyb libDAI: Member List

dai::FRegion Member List

This is the complete list of members for dai::FRegion, including all inherited members.

_cdai::FRegion [private]
abs() const dai::TFactor< T > [inline]
binaryOp(const TFactor< T > &g, binOp op)dai::TFactor< T > [inline]
binaryTr(const TFactor< T > &g, binOp op) const dai::TFactor< T > [inline]
c() const dai::FRegion [inline]
c()dai::FRegion [inline]
dist(const TFactor< T > &f, const TFactor< T > &g, ProbDistType dt)dai::TFactor< T > [related]
embed(const VarSet &vars) const dai::TFactor< T > [inline]
entropy() const dai::TFactor< T > [inline]
exp() const dai::TFactor< T > [inline]
fill(T x)dai::TFactor< T > [inline]
FRegion()dai::FRegion [inline]
FRegion(const Factor &x, Real c)dai::FRegion [inline]
get(size_t i) const dai::TFactor< T > [inline]
hasNaNs() const dai::TFactor< T > [inline]
hasNegatives() const dai::TFactor< T > [inline]
inverse(bool zero=true) const dai::TFactor< T > [inline]
log(bool zero=false) const dai::TFactor< T > [inline]
marginal(const VarSet &vars, bool normed=true) const dai::TFactor< T > [inline]
max() const dai::TFactor< T > [inline]
max(const TFactor< T > &f, const TFactor< T > &g)dai::TFactor< T > [related]
maxAbs() const dai::TFactor< T > [inline]
maxMarginal(const VarSet &vars, bool normed=true) const dai::TFactor< T > [inline]
min() const dai::TFactor< T > [inline]
min(const TFactor< T > &f, const TFactor< T > &g)dai::TFactor< T > [related]
MutualInfo(const TFactor< T > &f)dai::TFactor< T > [related]
normalize(ProbNormType norm=NORMPROB)dai::TFactor< T > [inline]
normalized(ProbNormType norm=NORMPROB) const dai::TFactor< T > [inline]
nrStates() const dai::TFactor< T > [inline]
operator*(T x) const dai::TFactor< T > [inline]
operator*(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator*=(T x)dai::TFactor< T > [inline]
operator*=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator+(T x) const dai::TFactor< T > [inline]
operator+(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator+=(T x)dai::TFactor< T > [inline]
operator+=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator-() const dai::TFactor< T > [inline]
operator-(T x) const dai::TFactor< T > [inline]
operator-(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator-=(T x)dai::TFactor< T > [inline]
operator-=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator/(T x) const dai::TFactor< T > [inline]
operator/(const TFactor< T > &g) const dai::TFactor< T > [inline]
operator/=(T x)dai::TFactor< T > [inline]
operator/=(const TFactor< T > &g)dai::TFactor< T > [inline]
operator<<(std::ostream &os, const TFactor< T > &f)dai::TFactor< T > [related]
operator==(const TFactor< T > &y) const dai::TFactor< T > [inline]
operator[](size_t i) const dai::TFactor< T > [inline]
operator^(T x) const dai::TFactor< T > [inline]
operator^=(T x)dai::TFactor< T > [inline]
p() const dai::TFactor< T > [inline]
p()dai::TFactor< T > [inline]
randomize()dai::TFactor< T > [inline]
set(size_t i, T val)dai::TFactor< T > [inline]
setUniform()dai::TFactor< T > [inline]
slice(const VarSet &vars, size_t varsState) const dai::TFactor< T > [inline]
strength(const Var &i, const Var &j) const dai::TFactor< T > [inline]
sum() const dai::TFactor< T > [inline]
sumAbs() const dai::TFactor< T > [inline]
takeAbs()dai::TFactor< T > [inline]
takeExp()dai::TFactor< T > [inline]
takeLog(bool zero=false)dai::TFactor< T > [inline]
TFactor(T p=1)dai::TFactor< T > [inline]
TFactor(const Var &v)dai::TFactor< T > [inline]
TFactor(const VarSet &vars)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, T p)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const std::vector< S > &x)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const T *p)dai::TFactor< T > [inline]
TFactor(const VarSet &vars, const TProb< T > &p)dai::TFactor< T > [inline]
TFactor(const std::vector< Var > &vars, const std::vector< T > &p)dai::TFactor< T > [inline]
vars() const dai::TFactor< T > [inline]
vars()dai::TFactor< T > [inline]

Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1BP__dual_1_1messages-members.html0000644000263000017630000000506011433220722023724 0ustar jorismkyb libDAI: Member List

dai::BP_dual::messages Member List

This is the complete list of members for dai::BP_dual::messages, including all inherited members.

mdai::BP_dual::messages
ndai::BP_dual::messages
Zmdai::BP_dual::messages
Zndai::BP_dual::messages

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1ExactInf-members.html0000644000263000017630000002561211433220722021356 0ustar jorismkyb libDAI: Member List

dai::ExactInf Member List

This is the complete list of members for dai::ExactInf, including all inherited members.

_beliefsFdai::ExactInf [private]
_beliefsVdai::ExactInf [private]
_logZdai::ExactInf [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::ExactInf [inline, virtual]
belief(const VarSet &vs) const dai::ExactInf [virtual]
beliefF(size_t I) const dai::ExactInf [inline, virtual]
beliefs() const dai::ExactInf [virtual]
beliefV(size_t i) const dai::ExactInf [inline, virtual]
calcMarginal(const VarSet &vs) const dai::ExactInf
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::ExactInf [inline, virtual]
construct()dai::ExactInf [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
ExactInf()dai::ExactInf [inline]
ExactInf(const FactorGraph &fg, const PropertySet &opts)dai::ExactInf [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::ExactInf [virtual]
getProperties() const dai::ExactInf [virtual]
identify() const dai::ExactInf [virtual]
init()dai::ExactInf [virtual]
init(const VarSet &)dai::ExactInf [inline, virtual]
Iterations() const dai::ExactInf [inline, virtual]
logZ() const dai::ExactInf [inline, virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::ExactInf [inline, virtual]
Namedai::ExactInf [static]
printProperties() const dai::ExactInf [virtual]
props (defined in dai::ExactInf)dai::ExactInf
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::ExactInf [virtual]
setMaxIter(size_t)dai::InfAlg [inline, virtual]
setProperties(const PropertySet &opts)dai::ExactInf [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__plog0p.html0000644000263000017630000000717611433220722020475 0ustar jorismkyb libDAI: dai::fo_plog0p< T > Struct Template Reference

dai::fo_plog0p< T > Struct Template Reference

Function object that returns p*log0(p). More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &p) const
 Returns p * log0(p).

Detailed Description

template<typename T>
struct dai::fo_plog0p< T >

Function object that returns p*log0(p).

Member Function Documentation

template<typename T>
T dai::fo_plog0p< T >::operator() ( const T &  p  )  const [inline]

Returns p * log0(p).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_137.png0000644000263000017630000000030011433220722015221 0ustar jorismkyb‰PNG  IHDR  ®‘é0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf>IDAT™c`€–™¡`z&ƒ?ˆbüÀÀ¢™?20ƒÅÿ‡ª›D1T)#˜?‡KD—Ìœ„0“ D(JÖIIEND®B`‚libDAI-0.2.7/doc/html/form_141.png0000644000263000017630000000030311433220722015217 0ustar jorismkyb‰PNG  IHDRÇÖÁM0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfAIDAT™c`ÀØ,e°r libDAI: Member List

dai::BBP Member List

This is the complete list of members for dai::BBP, including all inherited members.

_adj_b_Fdai::BBP [private]
_adj_b_F_unnormdai::BBP [private]
_adj_b_Vdai::BBP [private]
_adj_b_V_unnormdai::BBP [private]
_adj_mdai::BBP [private]
_adj_m_unnormdai::BBP [private]
_adj_ndai::BBP [private]
_adj_n_unnormdai::BBP [private]
_adj_psi_Fdai::BBP [private]
_adj_psi_Vdai::BBP [private]
_bp_dualdai::BBP [private]
_fgdai::BBP [private]
_iadai::BBP [private]
_ind_t typedefdai::BBP [private]
_index(size_t i, size_t _I) const dai::BBP [inline, private]
_indicesdai::BBP [private]
_init_adj_psi_Fdai::BBP [private]
_init_adj_psi_Vdai::BBP [private]
_itersdai::BBP [private]
_new_adj_mdai::BBP [private]
_new_adj_ndai::BBP [private]
_Rmsgdai::BBP [private]
_Smsgdai::BBP [private]
_Tmsgdai::BBP [private]
_Umsgdai::BBP [private]
adj_b_F(size_t I)dai::BBP [inline]
adj_b_F(size_t I) const dai::BBP [inline]
adj_b_V(size_t i)dai::BBP [inline]
adj_b_V(size_t i) const dai::BBP [inline]
adj_m(size_t i, size_t _I)dai::BBP [inline, private]
adj_m(size_t i, size_t _I) const dai::BBP [inline, private]
adj_n(size_t i, size_t _I)dai::BBP [inline, private]
adj_n(size_t i, size_t _I) const dai::BBP [inline, private]
adj_psi_F(size_t I)dai::BBP [inline]
adj_psi_F(size_t I) const dai::BBP [inline]
adj_psi_V(size_t i)dai::BBP [inline]
adj_psi_V(size_t i) const dai::BBP [inline]
BBP(const InfAlg *ia, const PropertySet &opts)dai::BBP [inline]
calcNewM(size_t i, size_t _I)dai::BBP [private]
calcNewN(size_t i, size_t _I)dai::BBP [private]
calcUnnormMsgM(size_t i, size_t _I)dai::BBP [private]
calcUnnormMsgN(size_t i, size_t _I)dai::BBP [private]
doParUpdate()dai::BBP [private]
getArgmaxMsgM(size_t &i, size_t &_I, Real &mag)dai::BBP [private]
getMaxMsgM()dai::BBP [private]
getMsgMags(Real &s, Real &new_s)dai::BBP [private]
getTotalMsgM()dai::BBP [private]
getTotalMsgN()dai::BBP [private]
getTotalNewMsgM()dai::BBP [private]
getUnMsgMag()dai::BBP [private]
getZeroAdjF(const FactorGraph &fg)dai::BBP [private]
getZeroAdjV(const FactorGraph &fg)dai::BBP [private]
incrSeqMsgM(size_t i, size_t _I, const Prob &p)dai::BBP [private]
init(const std::vector< Prob > &adj_b_V, const std::vector< Prob > &adj_b_F, const std::vector< Prob > &adj_psi_V, const std::vector< Prob > &adj_psi_F)dai::BBP [inline]
init(const std::vector< Prob > &adj_b_V, const std::vector< Prob > &adj_b_F)dai::BBP [inline]
init_F(const std::vector< Prob > &adj_b_F)dai::BBP [inline]
init_V(const std::vector< Prob > &adj_b_V)dai::BBP [inline]
initCostFnAdj(const BBPCostFunction &cfn, const std::vector< size_t > *stateP)dai::BBP
Iterations()dai::BBP [inline]
numericBBPTest(const InfAlg &bp, const std::vector< size_t > *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h)dai::BBP [related]
props (defined in dai::BBP)dai::BBP
R(size_t I, size_t _i, size_t _J)dai::BBP [inline, private]
R(size_t I, size_t _i, size_t _J) const dai::BBP [inline, private]
Regenerate()dai::BBP [private]
RegenerateInds()dai::BBP [private]
RegenerateInputs()dai::BBP [private]
RegenerateParMessageAdjoints()dai::BBP [private]
RegeneratePsiAdjoints()dai::BBP [private]
RegenerateR()dai::BBP [private]
RegenerateS()dai::BBP [private]
RegenerateSeqMessageAdjoints()dai::BBP [private]
RegenerateT()dai::BBP [private]
RegenerateU()dai::BBP [private]
run()dai::BBP
S(size_t i, size_t _I, size_t _j)dai::BBP [inline, private]
S(size_t i, size_t _I, size_t _j) const dai::BBP [inline, private]
sendSeqMsgM(size_t i, size_t _I)dai::BBP [private]
sendSeqMsgN(size_t i, size_t _I, const Prob &f)dai::BBP [private]
setSeqMsgM(size_t i, size_t _I, const Prob &p)dai::BBP [private]
T(size_t i, size_t _I)dai::BBP [inline, private]
T(size_t i, size_t _I) const dai::BBP [inline, private]
U(size_t I, size_t _i)dai::BBP [inline, private]
U(size_t I, size_t _i) const dai::BBP [inline, private]
unnormAdjoint(const Prob &w, Real Z_w, const Prob &adj_w)dai::BBP [private]
upMsgM(size_t i, size_t _I)dai::BBP [private]
upMsgN(size_t i, size_t _I)dai::BBP [private]

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x75.html0000644000263000017630000001334411433220722016653 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- u -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x64.html0000644000263000017630000001045011433220722017677 0ustar jorismkyb libDAI: Class Members - Variables
 

- d -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/terminology.html0000644000263000017630000003420111433220722016423 0ustar jorismkyb libDAI: Terminology and conventions

Terminology and conventions

Graphical models

Commonly used graphical models are Bayesian networks and Markov random fields. In libDAI, both types of graphical models are represented by a slightly more general type of graphical model: a factor graph [KFL01].

An example of a Bayesian network is:

inline_dotgraph_2.dot
The probability distribution of a Bayesian network factorizes as:

\[ P(\mathbf{x}) = \prod_{i\in\mathcal{V}} P(x_i \,|\, x_{\mathrm{pa}(i)}) \]

where $\mathrm{pa}(i)$ are the parents of node i in a DAG.

The same probability distribution can be represented as a Markov random field:

inline_dotgraph_3.dot

The probability distribution of a Markov random field factorizes as:

\[ P(\mathbf{x}) = \frac{1}{Z} \prod_{C\in\mathcal{C}} \psi_C(x_C) \]

where $ \mathcal{C} $ are the cliques of an undirected graph, $ \psi_C(x_C) $ are "potentials" or "compatibility functions", and $ Z $ is the partition sum which properly normalizes the probability distribution.

Finally, the same probability distribution can be represented as a factor graph:

inline_dotgraph_4.dot

The probability distribution of a factor graph factorizes as:

\[ P(\mathbf{x}) = \frac{1}{Z} \prod_{I\in \mathcal{F}} f_I(x_I) \]

where $ \mathcal{F} $ are the factor nodes of a factor graph (a bipartite graph consisting of variable nodes and factor nodes), $ f_I(x_I) $ are the factors, and $ Z $ is the partition sum which properly normalizes the probability distribution.

Looking at the expressions for the joint probability distributions, it is obvious that Bayesian networks and Markov random fields can both be easily represented as factor graphs. Factor graphs most naturally express the factorization structure of a probability distribution, and hence are a convenient representation for approximate inference algorithms, which all try to exploit this factorization. This is why libDAI uses a factor graph as representation of a graphical model, implemented in the dai::FactorGraph class.

Inference tasks

Given a factor graph, specified by the variable nodes $\{x_i\}_{i\in\mathcal{V}}$ the factor nodes $ \mathcal{F} $, the graph structure, and the factors $\{f_I(x_I)\}_{I\in\mathcal{F}}$, the following tasks are important:

  • Calculating the partition sum:

    \[ Z = \sum_{\mathbf{x}_{\mathcal{V}}} \prod_{I \in \mathcal{F}} f_I(x_I) \]

  • Calculating the marginal distribution of a subset of variables $\{x_i\}_{i\in A}$:

    \[ P(\mathbf{x}_{A}) = \frac{1}{Z} \sum_{\mathbf{x}_{\mathcal{V}\setminus A}} \prod_{I \in \mathcal{F}} f_I(x_I) \]

  • Calculating the MAP state which has the maximum probability mass:

    \[ \mathrm{argmax}_{\mathbf{x}}\,\prod_{I\in\mathcal{F}} f_I(x_I) \]

libDAI offers several inference algorithms, which solve (a subset of) these tasks either approximately or exactly, for factor graphs with discrete variables. The following algorithms are implemented:

Exact inference:

Approximate inference:

Not all inference tasks are implemented by each method: calculating MAP states is only possible with dai::JTree, dai::BP and dai::DECMAP; calculating partition sums is not possible with dai::MR, dai::LC and dai::Gibbs.

Parameter learning

In addition, libDAI supports parameter learning of conditional probability tables by Expectation Maximization (or Maximum Likelihood, if there is no missing data). This is implemented in dai::EMAlg.

Variables and states

Linear states are a concept that is used often in libDAI, for example for storing and accessing factors, which are functions mapping from states of a set of variables to the real numbers. Internally, a factor is stored as an array, and the array index of an entry corresponds with the linear state of the set of variables. Below we will define variables, states and linear states of (sets of) variables.

Variables

Each (random) variable has a unique identifier, its label (which has a non-negative integer value). If two variables have the same label, they are considered as identical. A variable can take on a finite number of different values or states.

We use the following notational conventions. The discrete random variable with label $l$ is denoted as $x_l$, and the number of possible values of this variable as $S_{x_l}$ or simply $S_l$. The set of possible values of variable $x_l$ is denoted $X_l := \{0,1,\dots,S_l-1\}$ and called its state space.

Sets of variables and the canonical ordering

Let $A := \{x_{l_1},x_{l_2},\dots,x_{l_n}\}$ be a set of variables.

The canonical ordering of the variables in A is induced by their labels. That is: if $l_1 < l_2$, then $x_{l_1}$ occurs before $x_{l_2}$ in the canonical ordering. Below, we will assume that $(l_i)_{i=1}^n$ is ordered according to the canonical ordering, i.e., $l_1 < l_2 < \dots < l_n$.

States and linear states of sets of variables

A state of the variables in A refers to a joint assignment of the variables, or in other words, to an element of the Cartesian product $ \prod_{i=1}^n X_{l_i}$ of the state spaces of the variables in A. Note that a state can also be interpreted as a mapping from variables (or variable labels) to the natural numbers, which assigns to a variable (or its label) the corresponding state of the variable.

A state of n variables can be represented as an n-tuple of non-negative integers: $(s_1,s_2,\dots,s_n)$ corresponds to the joint assignment $x_{l_1} = s_1, \dots, x_{l_n} = s_n$. Alternatively, a state can be represented compactly as one non-negative integer; this representation is called a linear state. The linear state s corresponding to the state $(s_1,s_2,\dots,s_n)$ would be:

\[ s := \sum_{i=1}^n s_i \prod_{j=1}^{i-1} S_{l_j} = s_1 + s_2 S_{l_1} + s_3 S_{l_1} S_{l_2} + \dots + s_n S_{l_1} \cdots S_{l_{n-1}}. \]

Vice versa, given a linear state s for the variables A, the corresponding state $s_i$ of the i 'th variable $x_{l_i}$ (according to the canonical ordering of the variables in A) is given by

\[ s_i = \left\lfloor\frac{s \mbox { mod } \prod_{j=1}^i S_{l_j}}{\prod_{j=1}^{i-1} S_{l_j}}\right\rfloor. \]

Finally, the number of states of the set of variables A is simply the number of different joint assignments of the variables, that is, $\prod_{i=1}^n S_{l_i}$.

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/example__sprinkler_8cpp-example.html0000644000263000017630000002226011433220722022323 0ustar jorismkyb libDAI: example_sprinkler.cpp

example_sprinkler.cpp

This example illustrates how to manually construct a factor graph and write it to a file.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  libDAI is licensed under the terms of the GNU General Public License version
 *  2, or (at your option) any later version. libDAI is distributed without any
 *  warranty. See the file COPYING for more details.
 *
 *  Copyright (C) 2008-2010  Joris Mooij  [joris dot mooij at libdai dot org]
 */


#include <dai/factorgraph.h>
#include <iostream>
#include <fstream>

using namespace std;
using namespace dai;

int main() {
    // This example program illustrates how to construct a factorgraph
    // by means of the sprinkler network example discussed at
    // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html

    Var C(0, 2);  // Define binary variable Cloudy (with label 0)
    Var S(1, 2);  // Define binary variable Sprinkler (with label 1)
    Var R(2, 2);  // Define binary variable Rain (with label 2)
    Var W(3, 2);  // Define binary variable Wetgrass (with label 3)

    // Define probability distribution for C
    Factor P_C( C );
    P_C.set(0, 0.5);   // C = 0
    P_C.set(1, 0.5);   // C = 1

    // Define conditional probability of S given C
    Factor P_S_given_C( VarSet( S, C ) );
    P_S_given_C.set(0, 0.5);   // C = 0, S = 0
    P_S_given_C.set(1, 0.9);   // C = 1, S = 0
    P_S_given_C.set(2, 0.5);   // C = 0, S = 1
    P_S_given_C.set(3, 0.1);   // C = 1, S = 1

    // Define conditional probability of R given C
    Factor P_R_given_C( VarSet( R, C ) );
    P_R_given_C.set(0, 0.8);   // C = 0, R = 0
    P_R_given_C.set(1, 0.2);   // C = 1, R = 0
    P_R_given_C.set(2, 0.2);   // C = 0, R = 1
    P_R_given_C.set(3, 0.8);   // C = 1, R = 1

    // Define conditional probability of W given S and R
    Factor P_W_given_S_R( VarSet( S, R ) | W );
    P_W_given_S_R.set(0, 1.0);  // S = 0, R = 0, W = 0
    P_W_given_S_R.set(1, 0.1);  // S = 1, R = 0, W = 0
    P_W_given_S_R.set(2, 0.1);  // S = 0, R = 1, W = 0
    P_W_given_S_R.set(3, 0.01); // S = 1, R = 1, W = 0
    P_W_given_S_R.set(4, 0.0);  // S = 0, R = 0, W = 1
    P_W_given_S_R.set(5, 0.9);  // S = 1, R = 0, W = 1
    P_W_given_S_R.set(6, 0.9);  // S = 0, R = 1, W = 1
    P_W_given_S_R.set(7, 0.99); // S = 1, R = 1, W = 1

    // Build factor graph consisting of those four factors
    vector<Factor> SprinklerFactors;
    SprinklerFactors.push_back( P_C );
    SprinklerFactors.push_back( P_R_given_C );
    SprinklerFactors.push_back( P_S_given_C );
    SprinklerFactors.push_back( P_W_given_S_R );
    FactorGraph SprinklerNetwork( SprinklerFactors );

    // Write factorgraph to a file
    SprinklerNetwork.WriteToFile( "sprinkler.fg" );
    cout << "Sprinkler network written to sprinkler.fg" << endl;

    // Output some information about the factorgraph
    cout << SprinklerNetwork.nrVars() << " variables" << endl;
    cout << SprinklerNetwork.nrFactors() << " factors" << endl;

    // Calculate joint probability of all four variables
    Factor P;
    for( size_t I = 0; I < SprinklerNetwork.nrFactors(); I++ )
        P *= SprinklerNetwork.factor( I );
    // P.normalize();  // Not necessary: a Bayesian network is already normalized by definition

    // Calculate some probabilities
    Real denom = P.marginal( W )[1];
    cout << "P(W=1) = " << denom << endl;
    cout << "P(S=1 | W=1) = " << P.marginal( VarSet( S, W ) )[3] / denom << endl;
    cout << "P(R=1 | W=1) = " << P.marginal( VarSet( R, W ) )[3] / denom << endl;

    return 0;
}
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Evidence-members.html0000644000263000017630000001127111433220722021373 0ustar jorismkyb libDAI: Member List

dai::Evidence Member List

This is the complete list of members for dai::Evidence, including all inherited members.

_samplesdai::Evidence [private]
addEvidenceTabFile(std::istream &is, FactorGraph &fg)dai::Evidence
addEvidenceTabFile(std::istream &is, std::map< std::string, Var > &varMap)dai::Evidence [private]
begin()dai::Evidence [inline]
begin() const dai::Evidence [inline]
const_iterator typedefdai::Evidence
end()dai::Evidence [inline]
end() const dai::Evidence [inline]
Evidence()dai::Evidence [inline]
Evidence(std::vector< Observation > &samples)dai::Evidence [inline]
iterator typedefdai::Evidence
nrSamples() const dai::Evidence [inline]
Observation typedefdai::Evidence

Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_60.png0000644000263000017630000000043411433220722015144 0ustar jorismkyb‰PNG  IHDR6¯ž‘Å0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfšIDAT•c`À PhFdj“±³1Nc#f#¨Ëý¹-p¹øË 2›ár ú. p9ö ê 9ž£9Æ/LHr,?r gØ䘠rB`¹ød9õ|},§/€$ÇTÀŸ–SËÕ1 Éi2p~@²ï$’×Ù_p9ÉßÈö!Ñœ…r8¨&¢Ó µIEND®B`‚libDAI-0.2.7/doc/html/files.html0000644000263000017630000002567211433220722015171 0ustar jorismkyb libDAI: File Index

File List

Here is a list of all documented files with brief descriptions:
include/dai/alldai.h [code]Main libDAI header file. It #includes all other libDAI headers
include/dai/bbp.h [code]Defines class BBP, which implements Back-Belief-Propagation
include/dai/bipgraph.h [code]Defines the BipartiteGraph class, which represents a bipartite graph
include/dai/bp.h [code]Defines class BP, which implements (Loopy) Belief Propagation
include/dai/bp_dual.h [code]Defines class BP_dual, which is used primarily by BBP
include/dai/cbp.h [code]Defines class CBP, which implements Conditioned Belief Propagation
include/dai/clustergraph.h [code]Defines class ClusterGraph, which is used by JTree, TreeEP and HAK
include/dai/dag.h [code]Defines the DAG class, which represents a directed acyclic graph
include/dai/daialg.h [code]Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG)
include/dai/decmap.h [code]Defines class DecMAP, which constructs a MAP state by decimation
include/dai/doc.h [code]Contains additional doxygen documentation
include/dai/emalg.h [code]Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters)
include/dai/enum.h [code]Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality
include/dai/evidence.h [code]Defines class Evidence, which stores multiple observations of joint states of variables
include/dai/exactinf.h [code]Defines ExactInf class, which can be used for exact inference on small factor graphs
include/dai/exceptions.h [code]Defines the Exception class and macros for throwing exceptions and doing assertions
include/dai/factor.h [code]Defines TFactor<> and Factor classes which represent factors in probability distributions
include/dai/factorgraph.h [code]Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields)
include/dai/fbp.h [code]Defines class FBP, which implements Fractional Belief Propagation
include/dai/gibbs.h [code]Defines class Gibbs, which implements Gibbs sampling
include/dai/graph.h [code]Defines the GraphAL class, which represents an undirected graph as an adjacency list
include/dai/hak.h [code]Defines class HAK, which implements a variant of Generalized Belief Propagation
include/dai/index.h [code]Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays
include/dai/io.h [code]Provides functionality for input/output of data structures in various file formats
include/dai/jtree.h [code]Defines class JTree, which implements the junction tree algorithm
include/dai/lc.h [code]Defines class LC, which implements loop corrections for approximate inference
include/dai/mf.h [code]Defines class MF which implements the Mean Field algorithm
include/dai/mr.h [code]Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo
include/dai/prob.h [code]Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables)
include/dai/properties.h [code]Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms
include/dai/regiongraph.h [code]Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs
include/dai/smallset.h [code]Defines the SmallSet<> class, which represents a set (optimized for a small number of elements)
include/dai/treeep.h [code]Defines class TreeEP, which implements Tree Expectation Propagation
include/dai/trwbp.h [code]Defines class TRWBP, which implements Tree-Reweighted Belief Propagation
include/dai/util.h [code]Defines general utility functions and adds an abstraction layer for platform-dependent functionality
include/dai/var.h [code]Defines class Var, which represents a discrete random variable
include/dai/varset.h [code]Defines the VarSet class, which represents a set of random variables
include/dai/weightedgraph.h [code]Defines some utility functions for (weighted) undirected graphs, trees and rooted trees
include/dai/matlab/matlab.h [code]Defines some utility functions for interfacing with MatLab
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_109.png0000644000263000017630000000337011433220722015232 0ustar jorismkyb‰PNG  IHDRB3Š0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfvIDAThÝ™kŒÔT€O3íÌΣˆâVEÑ d‹ës%Ù‰ D0ÁlÖHaa 0²Hà×.bÑèÄ(ŒŒ 5DÀÄÂĨÃJ†ÉDQ˜Ù•‡d<·¯i§íÒnb<É´·½÷žóõÞ{Î=íüß…9ÕT8jZÃQã$ÌÁPÔTBÑâ,ï„¡¤AC‹‹4 !(i A‡«DØæ_BÐá.WÁŒä2x/¸ŠD>¸i¾Åà’î ¬¢'8…—pÁÑï!`x3XÅå0¼ä¯  Ø00<älPüÈ€¾  ’å(¼dµÏpÃ8W(œ³¿tQ+|ÿ96(œ?/ú7=z»=›ójÔ–ñ©¯’ÖvÇJëÌ;•9zgÉ?!$þÆC_Ù³M³l¿ç8¬ŒBh_t†‚Ô5åDr3å –W‹õ·-y«:ì«°l¾tKw¬óРµA¿Ía›NHWes·eb­Í=Ž×eÜ ‘ƒÈD0hËhÒL±?Én­ÈÓ›g}­V[–@Z6ŠÔbÄXÁÝ A ]zS…@#¬@Š)^œ§–ÊðšÞÜ’š¹ö“¿n¾Ÿ¬r‡Eìß«_ÞïA¨èç3f‚¤rýRDµ¬OŠÐ0…!vw»ÞMÔ”ÑäÔgRU“)Bø:pq²lâ"Ðâ]¤&áNˆ¤+Z 4•0¶ëðCæâ Å” 2i>bBþÚ鎰á¹þU•¾MW—Z¡í’…°iB‘_sÍïܧr=¹OIÇDWBäP›.úê#ÐT”øzm°Š0/Ù™£òGK‰ bý®„#ÔàøX ¹ªÉ]“ò I §°˜ày)”üÆX¸wð²+!á Ñ.‹ÉKn«A˜†Í„D'+’z¨+POxþ©í$Žž†9‚…NÔlA²súÒâÏXlè€öâdË^„„ƒ'v)4Ä™ §Â%Ãa#ÀMJ}à¨ð;ü5•°Í:†Ð,Z ßâ—’%øa#„ʳ{I±‹>r§™°•)×t÷ÃáfÊ‹¬#Á+²"WO¸¢tn?~RGx²VÄY¾ âJq aK¿°%Ïž¨õ¨'DnzÊø¸,G'!Ðù™â3ÆæX‚ËR“váŲwá ±Žû¶wU¾§xfzÉJ3ЕŸß‘ÿq «O‘I‹Kñ=fpº‰«º"µ¦yúÛ5U%P qGzÌû%Êq¤D#J߃ÌÑF½sZ9š `–—±B&΃@)Kñ>wB²3ž„¨ú¤›µxXÖêR¢1j½ÈIfs¶ˆMÿª°ÍÉè7"ª%ÆÔiYtWBëFm+aÑ·M@NûrYßS~…ÀHž7f™êUÏ·Z:ÚÙ.…ÐØ—a’zšhêD/ÑhƒÍšÜpZC sK*AÚRí!CgeåÎ[zE/­ÓÎFz7”DI8^m7o(Hv¶ l¨öƒ°á<óîÑ(ûÓÅ~Zý fV¯»çØ'ªªøTH$z¬zVT¯yçØY¯Zb¸Ú(Mê³É‚ ŸEþûïzÃòŒ‘sþšEºÉ‘ú1§.94–ÌÅfÍÌVçê+þ´à¦0¦ Áû°ÐVuõF¨pWh‘Ð 0Õ!”'ï3[Ò>¿ÛÄe w ª#kw»ôÉY›k׸§Ð>wSW.s*­’î8ÿ¥à÷ÛWZˆ¡ÕÈÍå%ÖU5 À`jµ¶©ûÅ0Á¼±9 =_i"M#$ÄHíL˜ò°¡¡P8¸¥êÇ'Õ Ô Ú³2^ôª›êF›«Dî`vã,çf·À³"ö˜%FÖÃíŽÏïÔe[å0«~Äf­MÛçÁË?e˜5¸L©<›‡î¡ôµ3{q–s© libDAI: Class Members - Functions
 

- l -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_84.png0000644000263000017630000000025411433220722015152 0ustar jorismkyb‰PNG  IHDR ÒŽ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf*IDAT™c`@*@‚5`!ä l’lÿ €¤3Ë y”$¢â S ©”ó –·IEND®B`‚libDAI-0.2.7/doc/html/prob_8h.html0000644000263000017630000002241011433220722015413 0ustar jorismkyb libDAI: include/dai/prob.h File Reference

include/dai/prob.h File Reference

Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables). More...

#include <cmath>
#include <vector>
#include <ostream>
#include <algorithm>
#include <numeric>
#include <functional>
#include <dai/util.h>
#include <dai/exceptions.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

struct  dai::fo_id< T >
 Function object that returns the value itself. More...
struct  dai::fo_abs< T >
 Function object that takes the absolute value. More...
struct  dai::fo_exp< T >
 Function object that takes the exponent. More...
struct  dai::fo_log< T >
 Function object that takes the logarithm. More...
struct  dai::fo_log0< T >
 Function object that takes the logarithm, except that log(0) is defined to be 0. More...
struct  dai::fo_inv< T >
 Function object that takes the inverse. More...
struct  dai::fo_inv0< T >
 Function object that takes the inverse, except that 1/0 is defined to be 0. More...
struct  dai::fo_plog0p< T >
 Function object that returns p*log0(p). More...
struct  dai::fo_divides0< T >
 Function object similar to std::divides(), but different in that dividing by zero results in zero. More...
struct  dai::fo_KL< T >
 Function object useful for calculating the KL distance. More...
struct  dai::fo_Hellinger< T >
 Function object useful for calculating the Hellinger distance. More...
struct  dai::fo_pow< T >
 Function object that returns x to the power y. More...
struct  dai::fo_max< T >
 Function object that returns the maximum of two values. More...
struct  dai::fo_min< T >
 Function object that returns the minimum of two values. More...
struct  dai::fo_absdiff< T >
 Function object that returns the absolute difference of x and y. More...
class  dai::TProb< T >
 Represents a vector with entries of type T. More...

Typedefs

typedef TProb< Real > dai::Prob
 Represents a vector with entries of type dai::Real.

Detailed Description

Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables).

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1TreeEP.html0000644000263000017630000011017211433220722017345 0ustar jorismkyb libDAI: dai::TreeEP Class Reference

dai::TreeEP Class Reference

Approximate inference algorithm "Tree Expectation Propagation" [MiQ04]. More...

#include <dai/treeep.h>

Inheritance diagram for dai::TreeEP:

dai::JTree dai::DAIAlg< GRM > dai::InfAlg

List of all members.

Public Member Functions

 TreeEP ()
 Default constructor.
 TreeEP (const TreeEP &x)
 Copy constructor.
TreeEP & operator= (const TreeEP &x)
 Assignment operator.
 TreeEP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts.
General InfAlg interface
virtual TreeEP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).
virtual std::string identify () const
 Identifies itself for logging purposes.
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).
virtual void init ()
 Initializes all data structures of the approximate inference algorithm.
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables.
virtual Real run ()
 Runs the approximate inference algorithm.
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration.
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph).
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph).
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm.
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet.
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Public Attributes

struct dai::TreeEP::Properties props

Static Public Attributes

static const char * Name = "TREEEP"
 Name of this inference method.

Private Member Functions

void construct (const FactorGraph &fg, const RootedTree &tree)
 Helper function for constructors.
bool offtree (size_t I) const
 Returns true if factor I is not part of the tree.

Private Attributes

Real _maxdiff
 Maximum difference encountered so far.
size_t _iters
 Number of iterations needed.
std::map< size_t, TreeEPSubTree > _Q
 Stores a TreeEPSubTree object for each off-tree factor.

Classes

struct  Properties
 Parameters for TreeEP. More...
class  TreeEPSubTree
 Stores the data structures needed to efficiently update the approximation of an off-tree factor. More...

Detailed Description

Approximate inference algorithm "Tree Expectation Propagation" [MiQ04].

Constructor & Destructor Documentation

dai::TreeEP::TreeEP (  )  [inline]

Default constructor.

dai::TreeEP::TreeEP ( const TreeEP &  x  )  [inline]

Copy constructor.

dai::TreeEP::TreeEP ( const FactorGraph &  fg,
const PropertySet &  opts 
)

Construct from FactorGraph fg and PropertySet opts.

Parameters:
fg Factor graph.
opts Parameters
See also:
Properties

Member Function Documentation

TreeEP& dai::TreeEP::operator= ( const TreeEP &  x  )  [inline]

Assignment operator.

virtual TreeEP* dai::TreeEP::clone (  )  const [inline, virtual]

Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor).

Reimplemented from dai::JTree.

string dai::TreeEP::identify (  )  const [virtual]

Identifies itself for logging purposes.

Reimplemented from dai::JTree.

Real dai::TreeEP::logZ (  )  const [virtual]

Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph).

Note:
Before this method is called, run() should have been called.
Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::JTree.

void dai::TreeEP::init (  )  [virtual]

Initializes all data structures of the approximate inference algorithm.

Note:
This method should be called at least once before run() is called.

Reimplemented from dai::JTree.

virtual void dai::TreeEP::init ( const VarSet &  vs  )  [inline, virtual]

Initializes all data structures corresponding to some set of variables.

This method can be used to do a partial initialization after a part of the factor graph has changed. Instead of initializing all data structures, it only initializes those involving the variables in vs.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::JTree.

Real dai::TreeEP::run (  )  [virtual]

Runs the approximate inference algorithm.

Note:
Before run() is called the first time, init() should have been called.

Reimplemented from dai::JTree.

virtual Real dai::TreeEP::maxDiff (  )  const [inline, virtual]

Returns maximum difference between single variable beliefs in the last iteration.

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::JTree.

virtual size_t dai::TreeEP::Iterations (  )  const [inline, virtual]

Returns number of iterations done (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::JTree.

virtual void dai::TreeEP::setMaxIter ( size_t   )  [inline, virtual]

Sets maximum number of iterations (one iteration passes over the complete factorgraph).

Exceptions:
NOT_IMPLEMENTED if not implemented/supported

Reimplemented from dai::InfAlg.

void dai::TreeEP::setProperties ( const PropertySet &  opts  )  [virtual]

Set parameters of this inference algorithm.

The parameters are set according to the PropertySet opts. The values can be stored either as std::string or as the type of the corresponding MF::props member.

Reimplemented from dai::JTree.

PropertySet dai::TreeEP::getProperties (  )  const [virtual]

Returns parameters of this inference algorithm converted into a PropertySet.

Reimplemented from dai::JTree.

string dai::TreeEP::printProperties (  )  const [virtual]

Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]".

Reimplemented from dai::JTree.

void dai::TreeEP::construct ( const FactorGraph &  fg,
const RootedTree &  tree 
) [private]

Helper function for constructors.

bool dai::TreeEP::offtree ( size_t  I  )  const [inline, private]

Returns true if factor I is not part of the tree.

Member Data Documentation

Real dai::TreeEP::_maxdiff [private]

Maximum difference encountered so far.

size_t dai::TreeEP::_iters [private]

Number of iterations needed.

const char * dai::TreeEP::Name = "TREEEP" [static]

Name of this inference method.

Reimplemented from dai::JTree.

std::map<size_t, TreeEPSubTree> dai::TreeEP::_Q [private]

Stores a TreeEPSubTree object for each off-tree factor.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1sequentialVariableElimination-members.html0000644000263000017630000000561511433220722025667 0ustar jorismkyb libDAI: Member List

dai::sequentialVariableElimination Member List

This is the complete list of members for dai::sequentialVariableElimination, including all inherited members.

idai::sequentialVariableElimination [private]
operator()(const ClusterGraph &cl, const std::set< size_t > &)dai::sequentialVariableElimination
seqdai::sequentialVariableElimination [private]
sequentialVariableElimination(const std::vector< Var > s)dai::sequentialVariableElimination [inline]

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/bp_8h.html0000644000263000017630000000720411433220722015056 0ustar jorismkyb libDAI: include/dai/bp.h File Reference

include/dai/bp.h File Reference

Defines class BP, which implements (Loopy) Belief Propagation. More...

#include <string>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/properties.h>
#include <dai/enum.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::BP
 Approximate inference algorithm "(Loopy) Belief Propagation". More...
struct  dai::BP::EdgeProp
 Type used for storing edge properties. More...
struct  dai::BP::Properties
 Parameters for BP. More...

Detailed Description

Defines class BP, which implements (Loopy) Belief Propagation.

Todo:
Consider using a priority_queue for maximum residual schedule
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__divides0-members.html0000644000263000017630000000363611433220722022430 0ustar jorismkyb libDAI: Member List

dai::fo_divides0< T > Member List

This is the complete list of members for dai::fo_divides0< T >, including all inherited members.

operator()(const T &x, const T &y) const dai::fo_divides0< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_140.png0000644000263000017630000000136011433220722015222 0ustar jorismkyb‰PNG  IHDRß)¡u0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfnIDAT8å”MhAÇÿûQvSÛl¢5?Šš…BA<4 ŠàB/R=l¥jS÷Ršâ%ÄŠ^ÔC‘x±=ö ±xðàGÁƒm+ÔKô ¥õÍ&û1ÛÍ&=ûØ}óæ½ùͼ}3À$Ò “\¬p©åˆmÅH… çFÒé aÏŒ>6͹ êtG #»Nä¬ù»A~ ÂPˆFã¿‚qtÎ¥qa’)cá`ô>> =f¢ˆ¬ïÛñ@´y—4C3˜Öx’å÷vù@©ŸfØ ÌÞ ÍZ¾To±3àˆžä»^m’ë§HàŽº¯ïnSlæN€ÙM3xsÔîvÓ´î&Ú˜°¼ †‹kðšSSk¸ß´m¿·¹B2» ¨: DQöR¬Ýö°¬rÀŽ>ž£FÅ à]sTeMšž´b€ª“Æ>:®j 祷׎ö¦‹Uâ3x‡+&¦¨/¾…fÓ‚ÂÊŠþa·¥a‘´ŸÐLdslIô,ºÀC©”¡‘CÒj ËÊÞ?¸ÌÚ«°€yÒ—èžÃøcy>¸pky:ÔOÌ„ŒŽã`OÞj˜ ·c,#ù ’º9[5ZœÃç ;g^y*! [m£“óí² <ú8ùqÒ¬ÓV¿®V+¦¸7\Ìu§=ÙXJÀN–$¥â;•ØWJéR3Z48Àgž'¿þ‚³†^°ÛE)'¶\–¤õåýt™¿Åe£LºXŒp9dEQúõƒ£…V3ÇË2C†|ï´ÑÞÕáʶÜÃrÊŠý ç¯(BØ’óIEND®B`‚libDAI-0.2.7/doc/html/functions_func_0x62.html0000644000263000017630000002471311433220722017664 0ustar jorismkyb libDAI: Class Members - Functions
 

- b -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__divides0.html0000644000263000017630000001011411433220722020765 0ustar jorismkyb libDAI: dai::fo_divides0< T > Struct Template Reference

dai::fo_divides0< T > Struct Template Reference

Function object similar to std::divides(), but different in that dividing by zero results in zero. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (y == 0 ? 0 : (x / y)).

Detailed Description

template<typename T>
struct dai::fo_divides0< T >

Function object similar to std::divides(), but different in that dividing by zero results in zero.

Member Function Documentation

template<typename T>
T dai::fo_divides0< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns (y == 0 ? 0 : (x / y)).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1BBPCostFunction.html0000644000263000017630000002220411433220722021161 0ustar jorismkyb libDAI: dai::BBPCostFunction Class Reference

dai::BBPCostFunction Class Reference

Predefined cost functions that can be used with BBP. More...

#include <dai/bbp.h>

List of all members.

Public Member Functions

 BBPCostFunction ()
 Default constructor.
 BBPCostFunction (const BBPCostFunctionBase &x)
 Construct from BBPCostFunctionBase x.
bool needGibbsState () const
 Returns whether this cost function depends on having a Gibbs state.
Real evaluate (const InfAlg &ia, const std::vector< size_t > *stateP) const
 Evaluates cost function in state stateP using the information in inference algorithm ia.
BBPCostFunction & operator= (const BBPCostFunctionBase &x)
 Assignment operator.

Detailed Description

Predefined cost functions that can be used with BBP.

Constructor & Destructor Documentation

dai::BBPCostFunction::BBPCostFunction (  )  [inline]

Default constructor.

dai::BBPCostFunction::BBPCostFunction ( const BBPCostFunctionBase &  x  )  [inline]

Construct from BBPCostFunctionBase x.

Member Function Documentation

bool dai::BBPCostFunction::needGibbsState (  )  const

Returns whether this cost function depends on having a Gibbs state.

Real dai::BBPCostFunction::evaluate ( const InfAlg &  ia,
const std::vector< size_t > *  stateP 
) const

Evaluates cost function in state stateP using the information in inference algorithm ia.

BBPCostFunction& dai::BBPCostFunction::operator= ( const BBPCostFunctionBase &  x  )  [inline]

Assignment operator.

The documentation for this class was generated from the following files:
  • include/dai/bbp.h
  • src/bbp.cpp
Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_100.png0000644000263000017630000000030111433220722015210 0ustar jorismkyb‰PNG  IHDR RiÊo0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf?IDAT™c`ÀR 4¯ÂQ&c cCÃcÈW þb|d`d9b,fhà,1Ø\ø ø@‚@ í‰ 9½ë.IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1hash__map.html0000644000263000017630000000526711433220722020150 0ustar jorismkyb libDAI: dai::hash_map< T, U, H > Class Template Reference

dai::hash_map< T, U, H > Class Template Reference

hash_map is an alias for std::tr1::unordered_map. More...

#include <dai/util.h>

Detailed Description

template<typename T, typename U, typename H = boost::hash<T>>
class dai::hash_map< T, U, H >

hash_map is an alias for std::tr1::unordered_map.

We use the (experimental) TR1 unordered_map implementation included in modern GCC distributions or in boost versions 1.37 and higher.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_101.png0000644000263000017630000000046411433220722015223 0ustar jorismkyb‰PNG  IHDR6¯ž‘Å0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf²IDAT•c` à–bjÀ*ÌÜ $8±ëcõ\Hj$í8”A¢•µ°Œ UnGà0ÏŽA^”ÁsæÌ™“!rŒª˜>°òž3ð èc7`øtì ïƒEGGGDŽ›ùPÅ ï#ƒ<ÐbFAAAˆœÓ†ž ÏÂĺn$çùÅ @í¥¦ üXCâD=lÞgI‘L X丰ˆa6HÞnv BIEND®B`‚libDAI-0.2.7/doc/html/form_94.png0000644000263000017630000000032611433220722015153 0ustar jorismkyb‰PNG  IHDR <ð0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfTIDAT™c`@ M ÛG†~‹ýË°¬è5–ã`Và †„O`VA‹òË•ãˆÁ`À[bq*ð+ðƒ ™µ˜eÖdd«ÚÛw©.xIEND®B`‚libDAI-0.2.7/doc/html/form_80.png0000644000263000017630000000206611433220722015151 0ustar jorismkyb‰PNG  IHDR"Ý{º0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf´IDATX…íWÏ‹Iþº«“tÆtÒY½¶¨ãÅCKv<¨=®ƒ‚ˆÐÁ½hœÕV²,Ë ŠEtYÛƒ 7AQ<ˆ¢à-þšqw<8¢àMÌ€#¬ôUÿ¬ÖŽñ26Š¤º^×{õ}õóu€ïø& Ž{°ÒâAÚùº\.O=H[Gí5Sµ´eè&ç¤)Z™OôÔTãïýãðÌÏ’#]¿™{à ·Yr ‰OA±£/Þ¶>!¼4òYrPjd㌎Ü\ g“{)îÀœÐÈ뱶 ¡„¯é æC9ÙöÖx»S¨÷8‘¹*¹—ðWh0Glʉkç‡g7"ï=D>ÐAŽô6r”ø(RM}BÏž‡P.˜(Rõ7ú -=˜»q“÷özý<¹4} ùvÑÞŽ&p³ÔîuƒÂX_ùãòŠéíØ…Uÿ§­ÈÚ3À‘À #:Z˜§zBš"—ÉzxØ· þó—Z©Th@3,Rÿ‘ùŒ‰­ö\ò­ÒC9’‰hÞ°2¬Eå±À çù”Xš ù¹š(«HQÿ+¬5ƒpðηmÛ‚ÜÎ9å,ŸÓ„Z§ÓA¾ö)„‹Åt,ä@mPq libDAI: dai::BP::Properties Struct Reference

dai::BP::Properties Struct Reference

Parameters for BP. More...

#include <dai/bp.h>

List of all members.

Public Member Functions

 DAI_ENUM (UpdateType, SEQFIX, SEQRND, SEQMAX, PARALL)
 Enumeration of possible update schedules.
 DAI_ENUM (InfType, SUMPROD, MAXPROD)
 Enumeration of inference variants.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
double maxtime
 Maximum time (in seconds).
Real tol
 Tolerance for convergence test.
bool logdomain
 Whether updates should be done in logarithmic domain or not.
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping).
UpdateType updates
 Message update schedule.
InfType inference
 Inference variant.

Detailed Description

Parameters for BP.

Member Function Documentation

dai::BP::Properties::DAI_ENUM ( UpdateType  ,
SEQFIX  ,
SEQRND  ,
SEQMAX  ,
PARALL   
)

Enumeration of possible update schedules.

The following update schedules have been defined:

  • PARALL parallel updates
  • SEQFIX sequential updates using a fixed sequence
  • SEQRND sequential updates using a random sequence
  • SEQMAX maximum-residual updates [EMK06]

dai::BP::Properties::DAI_ENUM ( InfType  ,
SUMPROD  ,
MAXPROD   
)

Enumeration of inference variants.

There are two inference variants:

  • SUMPROD Sum-Product
  • MAXPROD Max-Product (equivalent to Min-Sum)

Member Data Documentation

size_t dai::BP::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::BP::Properties::maxiter

Maximum number of iterations.

double dai::BP::Properties::maxtime

Maximum time (in seconds).

Real dai::BP::Properties::tol

Tolerance for convergence test.

bool dai::BP::Properties::logdomain

Whether updates should be done in logarithmic domain or not.

Real dai::BP::Properties::damping

Damping constant (0.0 means no damping, 1.0 is maximum damping).

UpdateType dai::BP::Properties::updates

Message update schedule.

InfType dai::BP::Properties::inference

Inference variant.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1TreeEP-members.html0000644000263000017630000003517211433220722021003 0ustar jorismkyb libDAI: Member List

dai::TreeEP Member List

This is the complete list of members for dai::TreeEP, including all inherited members.

_itersdai::TreeEP [private]
_maxdiffdai::TreeEP [private]
_Qdai::TreeEP [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const VarSet &vs) const dai::JTree [virtual]
dai::DAIAlg::belief(const Var &v) const dai::InfAlg [inline, virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::JTree [virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
boundTreewidth(const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates=0)dai::JTree [related]
calcMarginal(const VarSet &vs)dai::JTree
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::TreeEP [inline, virtual]
construct(const FactorGraph &fg, const RootedTree &tree)dai::TreeEP [private]
dai::JTree::construct(const FactorGraph &fg, const std::vector< VarSet > &cl, bool verify=false)dai::JTree
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findEfficientTree(const VarSet &vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1) const dai::JTree
findMaximum() const dai::JTree [inline, virtual]
GenerateJT(const FactorGraph &fg, const std::vector< VarSet > &cl)dai::JTree
getProperties() const dai::TreeEP [virtual]
identify() const dai::TreeEP [virtual]
init()dai::TreeEP [virtual]
init(const VarSet &)dai::TreeEP [inline, virtual]
Iterations() const dai::TreeEP [inline, virtual]
JTree()dai::JTree [inline]
JTree(const FactorGraph &fg, const PropertySet &opts, bool automatic=true)dai::JTree
logZ() const dai::TreeEP [virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::TreeEP [inline, virtual]
message(size_t alpha, size_t _beta) const dai::JTree [inline]
message(size_t alpha, size_t _beta)dai::JTree [inline]
Namedai::TreeEP [static]
offtree(size_t I) const dai::TreeEP [inline, private]
operator=(const TreeEP &x)dai::TreeEP [inline]
printProperties() const dai::TreeEP [virtual]
props (defined in dai::TreeEP)dai::TreeEP
Qadai::JTree
Qbdai::JTree
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
RTreedai::JTree
run()dai::TreeEP [virtual]
runHUGIN()dai::JTree
runShaferShenoy()dai::JTree
setMaxIter(size_t maxiter)dai::TreeEP [inline, virtual]
setProperties(const PropertySet &opts)dai::TreeEP [virtual]
TreeEP()dai::TreeEP [inline]
TreeEP(const TreeEP &x)dai::TreeEP [inline]
TreeEP(const FactorGraph &fg, const PropertySet &opts)dai::TreeEP
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x65.html0000644000263000017630000002007711433220722016653 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- e -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1VarSet.png0000644000263000017630000000104311433220722017241 0ustar jorismkyb‰PNG  IHDRrˆÉú¢1PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf¹IDATX…í™]nÂ0 Çã—=Ǿ³lÒγ'î„%v¾ZÚ"`•°A%qò‹§€àï¾gÍ}…9û|/’Û©—.«ƒq‹ÔÙ}›K—Ûð’Ä´¸§!ŠHˆÁ„L‘BMdErÀ óâ ”JlíÊ´2‰Éš›$Vbq¨,QcbOÆR”2(k!ž˜PÊ`É;’rLÊ$—rü½˜8&w÷©µe.¨Ùån*ûNm§ÌÈs’óŸš#ûŽ>‡¼ü¾œü¸\^NþKm4ÒH#|‰³æüd>ð®$Ô‹wu,2{ŽÈ2ÏWŸ?$` _Ð;é¢àÒ{HÏúðÑ)­QL‰“°ÚÖ+ÞD*é¼—Úh¹`}»mÞ5²d¬®1‰· ÇÙjmA*¤ô©•Î¥Pûäífä9ÉùOÍ‘Ù‘'üæ5ÒH#4òrôgàé+$›(‚Mi¡pmÛdžÎa`kr¡´H;¹HÔ‘½ÒR%T—I_‘MiIû¤*]È*dQZHD–{È…^’]·+¥¥Ûç˜ì•–«ÚŽÉ-Û>Öc’§É€[÷ÞIÞ+''§õ•?Ò†A*˜pIEND®B`‚libDAI-0.2.7/doc/html/namespacemembers_vars.html0000644000263000017630000000377511433220722020431 0ustar jorismkyb libDAI: Class Members
 

  • _normal_dist : dai
  • DAINames : dai
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1InfAlg-members.html0000644000263000017630000002023111433220722021005 0ustar jorismkyb libDAI: Member List

dai::InfAlg Member List

This is the complete list of members for dai::InfAlg, including all inherited members.

backupFactor(size_t I)=0dai::InfAlg [pure virtual]
backupFactors(const VarSet &vs)=0dai::InfAlg [pure virtual]
belief(const Var &v) const dai::InfAlg [inline, virtual]
belief(const VarSet &vs) const =0dai::InfAlg [pure virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const =0dai::InfAlg [pure virtual]
beliefV(size_t i) const dai::InfAlg [inline, virtual]
clamp(size_t i, size_t x, bool backup=false)=0dai::InfAlg [pure virtual]
clone() const =0dai::InfAlg [pure virtual]
fg()=0dai::InfAlg [pure virtual]
fg() const =0dai::InfAlg [pure virtual]
findMaximum() const dai::InfAlg [inline, virtual]
getProperties() const =0dai::InfAlg [pure virtual]
identify() const =0dai::InfAlg [pure virtual]
init()=0dai::InfAlg [pure virtual]
init(const VarSet &vs)=0dai::InfAlg [pure virtual]
Iterations() const dai::InfAlg [inline, virtual]
logZ() const =0dai::InfAlg [pure virtual]
makeCavity(size_t i, bool backup=false)=0dai::InfAlg [pure virtual]
maxDiff() const dai::InfAlg [inline, virtual]
printProperties() const =0dai::InfAlg [pure virtual]
restoreFactor(size_t I)=0dai::InfAlg [pure virtual]
restoreFactors(const VarSet &vs)=0dai::InfAlg [pure virtual]
run()=0dai::InfAlg [pure virtual]
setMaxIter(size_t)dai::InfAlg [inline, virtual]
setProperties(const PropertySet &opts)=0dai::InfAlg [pure virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_88.png0000644000263000017630000000117111433220722015155 0ustar jorismkyb‰PNG  IHDRŽ´+(¦0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf÷IDAT8c`´€eïÊ™3i9 WUV>á;6mlgdŽ# 0'0¸8 ¸ì(Êùæ|Ãj>—ª9\í.ã"Íá/@UÉœ Ï ÄßLêwÅkço„s˜ÁæÔ3ð;¾›8f00´‚$|?00œÃk#0Ø„¡Àj2§¬šyb|Á&ÆOÄWæ„üÅ~—hŽ1\C˜ÃÊÀt©ƒP Óö ØÌat@˜S¤oÀÀ¤ÃÒ€à0Ô_ÀÂÂÀ°^€Áló ˆÜ{ µ µ @Ó9/0È%Ùø0xAÍdS™c g9k/00x€$.ú‰ûpsl"Ó : `J²ìfàú"°æNp8s;dÓS‚´âH8³Ø1@’$Äœvpj¸ÌÀ 4ç ‹0ÒÄÒ!…sCJ(Ž5›Ø—10¹S ƒ9|r$ýŒBN•Vaxr;†j8t €©¤;l”«?é'ÃGö²4æ Œ, ‘—°ÅÄœ—LÂ2˪¥ ^«‚—‚üÅÑ Ã è º ‡a´|ª„Mƒe‡ƒjH0 ™ƒY‚°©!B( Œ@¬$¨ Ûp’‰È¾äIEND®B`‚libDAI-0.2.7/doc/html/form_0.png0000644000263000017630000000101511433220722015052 0ustar jorismkyb‰PNG  IHDRG«OÛ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf‹IDAT(‘’ÏJÃ@Æ'É6¦i¶l[¡ˆÑúç B*¢*¶b!P[°=Ñ¢7+xSðb)žƒOP¡Ђx>‚âÙ]J5…´?Ø%ùÍìî| ðO æÙèÈáÓCŸŸ)1ˆO¢|0£ÎÙÍ*ú0 µkÀÁÐF¶-ð”CªZ5ˆC `Ì>ƒ§®QLÞA †¤£¬{N¾J¢+•a§ÿÅ<€;ŒÄˆqQÆÿU~¦FźZf#ëÑh,Ÿ"¾’Â-›Ô^ç.‘Ó9aWažlPˆ/¹ä+T”éÕjNg-.èÐâ Ùe%g…-µJ4žô¤ Í lÜ›I¸Ðæ)ÓºƒIL¢zC±ô™‡=ÀÄ4ál„B{fwóf›Nê’ƒ'È’è1+Ù›@pâb½º•èJg»uÈ·$W‹¦j©:oÔ–’©ãSCù€ ‡Ä’lW¤WŠìPÁg"&€xÙ°¨Û{§ãMéše5‹,¦~[‚ØÇXìñg€¾-SfáŠ6IEND®B`‚libDAI-0.2.7/doc/html/functions_vars_0x68.html0000644000263000017630000000736411433220722017715 0ustar jorismkyb libDAI: Class Members - Variables
 

- h -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1BP__dual.html0000644000263000017630000012545611433220722017701 0ustar jorismkyb libDAI: dai::BP_dual Class Reference

dai::BP_dual Class Reference

Calculates both types of BP messages and their normalizers from an InfAlg. More...

#include <dai/bp_dual.h>

List of all members.

Public Member Functions

 BP_dual (const InfAlg *ia)
 Construct BP_dual object from (converged) InfAlg object's beliefs and factors.
const FactorGraph & fg () const
 Returns the underlying FactorGraph.
Prob & msgM (size_t i, size_t _I)
 Returns reference to factor->variable message (I -> i).
const Prob & msgM (size_t i, size_t _I) const
 Returns constant reference to factor->variable message (I -> i).
Prob & msgN (size_t i, size_t _I)
 Returns reference to variable -> factor message (i -> I).
const Prob & msgN (size_t i, size_t _I) const
 Returns constant reference to variable -> factor message (i -> I).
Real & zM (size_t i, size_t _I)
 Returns reference to normalizer for factor->variable message (I -> i).
const Real & zM (size_t i, size_t _I) const
 Returns constant reference to normalizer for factor->variable message (I -> i).
Real & zN (size_t i, size_t _I)
 Returns reference to normalizer for variable -> factor message (i -> I).
const Real & zN (size_t i, size_t _I) const
 Returns constant reference to normalizer for variable -> factor message (i -> I).
Factor beliefV (size_t i) const
 Returns belief of variable i.
Factor beliefF (size_t I) const
 Returns belief of factor I.
Real beliefVZ (size_t i) const
 Returns normalizer for belief of variable i.
Real beliefFZ (size_t I) const
 Returns normalizer for belief of factor I.

Protected Member Functions

void init ()
 Does all necessary preprocessing.
void regenerateMessages ()
 Allocates space for _msgs.
void regenerateBeliefs ()
 Allocates space for _beliefs.
void calcMessages ()
 Calculate all messages from InfAlg beliefs.
void calcNewM (size_t i, size_t _I)
 Update factor->variable message (i -> I).
void calcNewN (size_t i, size_t _I)
 Update variable->factor message (I -> i).
void calcBeliefs ()
 Calculate all variable and factor beliefs from messages.
void calcBeliefV (size_t i)
 Calculate belief of variable i.
void calcBeliefF (size_t I)
 Calculate belief of factor I.

Protected Attributes

messages _msgs
 Stores all messages.
beliefs _beliefs
 Stores all beliefs.
const InfAlg * _ia
 Pointer to the InfAlg object.

Classes

struct  _edges_t
 Convenience label for storing edge properties. More...
struct  beliefs
 Groups together the data structures for storing the two types of beliefs and their normalizers. More...
struct  messages
 Groups together the data structures for storing the two types of messages and their normalizers. More...

Detailed Description

Calculates both types of BP messages and their normalizers from an InfAlg.

BP_dual calculates "dual" versions of BP messages (both messages from factors to variables and messages from variables to factors), and normalizers, given an InfAlg. These are computed from the variable and factor beliefs of the InfAlg. This class is used primarily by BBP.

Author:
Frederik Eaton

Constructor & Destructor Documentation

dai::BP_dual::BP_dual ( const InfAlg *  ia  )  [inline]

Construct BP_dual object from (converged) InfAlg object's beliefs and factors.

Warning:
A pointer to the the InfAlg object is stored, so the object must not be destroyed before the BP_dual is destroyed.

Member Function Documentation

void dai::BP_dual::init (  )  [protected]

Does all necessary preprocessing.

void dai::BP_dual::regenerateMessages (  )  [protected]

Allocates space for _msgs.

void dai::BP_dual::regenerateBeliefs (  )  [protected]

Allocates space for _beliefs.

void dai::BP_dual::calcMessages (  )  [protected]

Calculate all messages from InfAlg beliefs.

void dai::BP_dual::calcNewM ( size_t  i,
size_t  _I 
) [protected]

Update factor->variable message (i -> I).

void dai::BP_dual::calcNewN ( size_t  i,
size_t  _I 
) [protected]

Update variable->factor message (I -> i).

void dai::BP_dual::calcBeliefs (  )  [protected]

Calculate all variable and factor beliefs from messages.

void dai::BP_dual::calcBeliefV ( size_t  i  )  [protected]

Calculate belief of variable i.

void dai::BP_dual::calcBeliefF ( size_t  I  )  [protected]

Calculate belief of factor I.

const FactorGraph& dai::BP_dual::fg (  )  const [inline]

Returns the underlying FactorGraph.

Prob& dai::BP_dual::msgM ( size_t  i,
size_t  _I 
) [inline]

Returns reference to factor->variable message (I -> i).

const Prob& dai::BP_dual::msgM ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to factor->variable message (I -> i).

Prob& dai::BP_dual::msgN ( size_t  i,
size_t  _I 
) [inline]

Returns reference to variable -> factor message (i -> I).

const Prob& dai::BP_dual::msgN ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to variable -> factor message (i -> I).

Real& dai::BP_dual::zM ( size_t  i,
size_t  _I 
) [inline]

Returns reference to normalizer for factor->variable message (I -> i).

const Real& dai::BP_dual::zM ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to normalizer for factor->variable message (I -> i).

Real& dai::BP_dual::zN ( size_t  i,
size_t  _I 
) [inline]

Returns reference to normalizer for variable -> factor message (i -> I).

const Real& dai::BP_dual::zN ( size_t  i,
size_t  _I 
) const [inline]

Returns constant reference to normalizer for variable -> factor message (i -> I).

Factor dai::BP_dual::beliefV ( size_t  i  )  const [inline]

Returns belief of variable i.

Factor dai::BP_dual::beliefF ( size_t  I  )  const [inline]

Returns belief of factor I.

Real dai::BP_dual::beliefVZ ( size_t  i  )  const [inline]

Returns normalizer for belief of variable i.

Real dai::BP_dual::beliefFZ ( size_t  I  )  const [inline]

Returns normalizer for belief of factor I.

Member Data Documentation

messages dai::BP_dual::_msgs [protected]

Stores all messages.

beliefs dai::BP_dual::_beliefs [protected]

Stores all beliefs.

const InfAlg* dai::BP_dual::_ia [protected]

Pointer to the InfAlg object.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1greedyVariableElimination.html0000644000263000017630000002277411433220722023351 0ustar jorismkyb libDAI: dai::greedyVariableElimination Class Reference

dai::greedyVariableElimination Class Reference

Helper object for dai::ClusterGraph::VarElim(). More...

#include <dai/clustergraph.h>

List of all members.

Public Types

typedef size_t(* eliminationCostFunction )(const ClusterGraph &, size_t)
 Type of cost functions to be used for greedy variable elimination.

Public Member Functions

 greedyVariableElimination (eliminationCostFunction h)
 Construct from cost function.
size_t operator() (const ClusterGraph &cl, const std::set< size_t > &remainingVars)
 Returns the best variable from remainingVars to eliminate in the cluster graph cl by greedily minimizing the cost function.

Private Attributes

eliminationCostFunction heuristic
 Pointer to the cost function used.

Detailed Description

Helper object for dai::ClusterGraph::VarElim().

Chooses the next variable to eliminate greedily by taking the one that minimizes a given heuristic cost function.

Member Typedef Documentation

typedef size_t(* dai::greedyVariableElimination::eliminationCostFunction)(const ClusterGraph &, size_t)

Type of cost functions to be used for greedy variable elimination.

Constructor & Destructor Documentation

dai::greedyVariableElimination::greedyVariableElimination ( eliminationCostFunction  h  )  [inline]

Construct from cost function.

Note:
Examples of cost functions are eliminationCost_MinFill() and eliminationCost_WeightedMinFill().

Member Function Documentation

size_t dai::greedyVariableElimination::operator() ( const ClusterGraph &  cl,
const std::set< size_t > &  remainingVars 
)

Returns the best variable from remainingVars to eliminate in the cluster graph cl by greedily minimizing the cost function.

This function calculates the cost for eliminating each variable in remaingVars and returns the variable which has lowest cost.

Member Data Documentation

eliminationCostFunction dai::greedyVariableElimination::heuristic [private]

Pointer to the cost function used.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:12 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1DecMAP.png0000644000263000017630000000111011433220722017061 0ustar jorismkyb‰PNG  IHDRˆ<)PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfÞIDAThí—Arà Ea“µ¥ˆtÚ u•û¡H,§Æôq)˜,BØÿð1goá=M™°V$M¤ ÈÑ!&ÀŸ+h €„ÄC¥W‰qÒðäT#°€Ñ8ZèÔG@I—t0÷€Áè. &цwá±M†sðÐ`ãf<ëÓøÇÓ¯õ»ì9ü8àúùdÀåz}2à»à8Àx1€ëÆÓ¨U _ÔhJ³,ƒˆd¿û-@ W™x#¹%&#]¥)Zgµ€&S°Bî¢S•8ªñêO„¡ µ³¸×:WR’ƒÐî 0‘‰M,êx¹"ž ÕU €&‚ªòªX¬”$V€ `•‰M,’®Ÿ @—lr »@êØŒXìÝ}ðmh=c»€M±x°)vÌ®àºÑp€ðz˜³%,s:`[Å6Q À \jç1;å‹tõnó$:rá’£àö0 f¿Ü¥®£´ó?ŸÆO¾´ `'êcÈÑëàÂ.`é"+ v å è.4`YË.@w!Jå>(»08lø'€Ù×úµX¹ƒEÊ¥%IEND®B`‚libDAI-0.2.7/doc/html/functions_vars_0x6e.html0000644000263000017630000001216211433220722017762 0ustar jorismkyb libDAI: Class Members - Variables
 

- n -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1JTree.png0000644000263000017630000000126111433220722017050 0ustar jorismkyb‰PNG  IHDRÀß¡€PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØfGIDAThíÚáRƒ0 `úg¿›¼AúžÞù<þÚû?‚mÒ–e´rº¹%nœ | )ÎÅ2}œ‹·é=œ ö, âUàBâ‚h Ę3@Hß Ô !¥CùiÇ+}@zq*h 7ƒ”-,€A€–PS¬Á謌JÐ= ûqè®Án@ãb|ÔßÆœ~[?ˆËÑ¿\¿î \®×;0 `€¼`}ãÃTÀŸ¨Q=jÄ6ˆÒ3èÏýàÀ¹M\5‹iŸTë"@lEHhyU Ô6 ²¸; ¥Å‘¯|q£D¨bZ6 mÀ9ƒ@y×ÔHq 2 ›+@ nk³(ÇóOxÏ€²+ @•AéòJ³X2ÈE,€Î0·‰µY$9Ê€œ²ªŒÉî€ @5‹€ `qÜŠF¯§âh6‹#@³YÂëÿ°¾Ñ 0À€×à\øÉŸËЀ=À×Åä\,õÏ 7Ýα8ï§:¾xïbРZ€wÞÅãÂÒŽic .2V@¼h]«š;€Ë8•Aëõo×`ôŸ‚Œ‚ç"‚ÏÀÈ( …Oœ~[?ˆûÿi³¾ñFÁ 0À€þñüió÷ê]ªj††@¦Úz9HmÍó”ë9Ÿ- îRÍs—iî úu—*¨¦òú€ù.U™t+@o Ô]ªˆk%ƒ.€VIª   kp ¨»T(£Oã ž8;ßø r( q…IEND®B`‚libDAI-0.2.7/doc/html/form_129.png0000644000263000017630000000030211433220722015224 0ustar jorismkyb‰PNG  IHDRíf0â0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf@IDAT™c`€F­¡$€)–Í£æ7c`Ñz þ@Ú†DgAi.V0ÍèáOÜgš<Œè8IEND®B`‚libDAI-0.2.7/doc/html/bp__dual_8h.html0000644000263000017630000001151111433220722016216 0ustar jorismkyb libDAI: include/dai/bp_dual.h File Reference

include/dai/bp_dual.h File Reference

Defines class BP_dual, which is used primarily by BBP. More...

#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/enum.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::BP_dual
 Calculates both types of BP messages and their normalizers from an InfAlg. More...
struct  dai::BP_dual::_edges_t< T >
 Convenience label for storing edge properties. More...
struct  dai::BP_dual::messages
 Groups together the data structures for storing the two types of messages and their normalizers. More...
struct  dai::BP_dual::beliefs
 Groups together the data structures for storing the two types of beliefs and their normalizers. More...

Detailed Description

Defines class BP_dual, which is used primarily by BBP.

Idea:
BP_dual replicates a large part of the functionality of BP; would it not be more efficient to adapt BP instead?
Author:
Frederik Eaton
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x73.html0000644000263000017630000002607311433220722017667 0ustar jorismkyb libDAI: Class Members - Functions
 

- s -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/matlab_8h.html0000644000263000017630000000645711433220722015726 0ustar jorismkyb libDAI: include/dai/matlab/matlab.h File Reference

include/dai/matlab/matlab.h File Reference

Defines some utility functions for interfacing with MatLab. More...

#include "mex.h"
#include <dai/factor.h>

Go to the source code of this file.

Namespaces

namespace  dai

Functions

mxArray * dai::Factors2mx (const std::vector< Factor > &Ps)
 Convert vector<Factor> structure to a cell vector of CPTAB-like structs.
vector< Factor > dai::mx2Factors (const mxArray *psi, long verbose)
 Convert cell vector of CPTAB-like structs to vector<Factor>.
Factor dai::mx2Factor (const mxArray *psi)
 Convert CPTAB-like struct to Factor.

Detailed Description

Defines some utility functions for interfacing with MatLab.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x6b.html0000644000263000017630000001016711433220722017742 0ustar jorismkyb libDAI: Class Members - Functions
 

- k -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__abs.html0000644000263000017630000000711711433220722020034 0ustar jorismkyb libDAI: dai::fo_abs< T > Struct Template Reference

dai::fo_abs< T > Struct Template Reference

Function object that takes the absolute value. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x) const
 Returns abs(x).

Detailed Description

template<typename T>
struct dai::fo_abs< T >

Function object that takes the absolute value.

Member Function Documentation

template<typename T>
T dai::fo_abs< T >::operator() ( const T &  x  )  const [inline]

Returns abs(x).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1MaximizationStep.html0000644000263000017630000004766011433220722021541 0ustar jorismkyb libDAI: dai::MaximizationStep Class Reference

dai::MaximizationStep Class Reference

A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. More...

#include <dai/emalg.h>

List of all members.

Iterator interface

typedef std::vector
< SharedParameters >::iterator 		iterator
 Iterator over the parameter estimation tasks.
typedef std::vector
< SharedParameters >
::const_iterator 		const_iterator
 Constant iterator over the parameter estimation tasks.
iterator begin ()
 Returns iterator that points to the first parameter estimation task.
const_iterator begin () const
 Returns constant iterator that points to the first parameter estimation task.
iterator end ()
 Returns iterator that points beyond the last parameter estimation task.
const_iterator end () const
 Returns constant iterator that points beyond the last parameter estimation task.

Public Member Functions

 MaximizationStep ()
 Default constructor.
 MaximizationStep (std::vector< SharedParameters > &maximizations)
 Construct MaximizationStep from a vector of parameter estimation tasks.
 MaximizationStep (std::istream &is, const FactorGraph &fg_varlookup)
 Constructor from an input stream and a corresponding factor graph.
void addExpectations (InfAlg &alg)
 Collect the beliefs from this InfAlg as expectations for the next Maximization step.
void maximize (FactorGraph &fg)
 Using all of the currently added expectations, make new factors with maximized parameters and set them in the FactorGraph.

Private Attributes

std::vector< SharedParameters > _params
 Vector of parameter estimation tasks of which this maximization step consists.

Detailed Description

A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit.

Author:
Charles Vaske

Member Typedef Documentation

typedef std::vector<SharedParameters>::iterator dai::MaximizationStep::iterator

Iterator over the parameter estimation tasks.

typedef std::vector<SharedParameters>::const_iterator dai::MaximizationStep::const_iterator

Constant iterator over the parameter estimation tasks.

Constructor & Destructor Documentation

dai::MaximizationStep::MaximizationStep (  )  [inline]

Default constructor.

dai::MaximizationStep::MaximizationStep ( std::vector< SharedParameters > &  maximizations  )  [inline]

Construct MaximizationStep from a vector of parameter estimation tasks.

dai::MaximizationStep::MaximizationStep ( std::istream &  is,
const FactorGraph &  fg_varlookup 
)

Constructor from an input stream and a corresponding factor graph.

See also:
Maximization Step block format

Member Function Documentation

void dai::MaximizationStep::addExpectations ( InfAlg &  alg  ) 

Collect the beliefs from this InfAlg as expectations for the next Maximization step.

void dai::MaximizationStep::maximize ( FactorGraph &  fg  ) 

Using all of the currently added expectations, make new factors with maximized parameters and set them in the FactorGraph.

iterator dai::MaximizationStep::begin (  )  [inline]

Returns iterator that points to the first parameter estimation task.

const_iterator dai::MaximizationStep::begin (  )  const [inline]

Returns constant iterator that points to the first parameter estimation task.

iterator dai::MaximizationStep::end (  )  [inline]

Returns iterator that points beyond the last parameter estimation task.

const_iterator dai::MaximizationStep::end (  )  const [inline]

Returns constant iterator that points beyond the last parameter estimation task.

Member Data Documentation

std::vector<SharedParameters> dai::MaximizationStep::_params [private]

Vector of parameter estimation tasks of which this maximization step consists.

The documentation for this class was generated from the following files:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/doc_8h-source.html0000644000263000017630000000414311433220722016517 0ustar jorismkyb libDAI: include/dai/doc.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x77.html0000644000263000017630000001116311433220722017665 0ustar jorismkyb libDAI: Class Members - Functions
 

- w -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/matlab_8h-source.html0000644000263000017630000001152311433220722017212 0ustar jorismkyb libDAI: include/dai/matlab/matlab.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_111.png0000644000263000017630000000046011433220722015220 0ustar jorismkyb‰PNG  IHDR%M1ü0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf®IDAT•c`ÀÑøM H\憶ŸG€I€á‚ÏÇàò€áˆ•‘ÀÀ ÑÄÇ :á"ˆÏö‘¡_€O"Ïþ‰e·W„/zå8SPÆÄ\Áð‰!™A lrA‹ò$—ø±r@rw€}oS”Ï©À¯À/€Ÿµ˜eÖd†p$! `Ò @áÝ dÐø¨Ų̈|XèÎ`5\8vIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1BBPCostFunction-members.html0000644000263000017630000000573611433220722022624 0ustar jorismkyb libDAI: Member List

dai::BBPCostFunction Member List

This is the complete list of members for dai::BBPCostFunction, including all inherited members.

BBPCostFunction()dai::BBPCostFunction [inline]
BBPCostFunction(const BBPCostFunctionBase &x)dai::BBPCostFunction [inline]
evaluate(const InfAlg &ia, const std::vector< size_t > *stateP) const dai::BBPCostFunction
needGibbsState() const dai::BBPCostFunction
operator=(const BBPCostFunctionBase &x)dai::BBPCostFunction [inline]

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x61.html0000644000263000017630000001554411433220722016652 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- a -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/emalg_8h-source.html0000644000263000017630000013722511433220722017047 0ustar jorismkyb libDAI: include/dai/emalg.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1Gibbs_1_1Properties-members.html0000644000263000017630000000545711433220722023644 0ustar jorismkyb libDAI: Member List

dai::Gibbs::Properties Member List

This is the complete list of members for dai::Gibbs::Properties, including all inherited members.

burnindai::Gibbs::Properties
maxiterdai::Gibbs::Properties
maxtimedai::Gibbs::Properties
restartdai::Gibbs::Properties
verbosedai::Gibbs::Properties

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_vars_0x76.html0000644000263000017630000001160511433220722017705 0ustar jorismkyb libDAI: Class Members - Variables
 

- v -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x7a.html0000644000263000017630000001125511433220722016726 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- z -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_83.png0000644000263000017630000000044311433220722015151 0ustar jorismkyb‰PNG  IHDR. ïó’90PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf¡IDAT•c`À 2$š|‹0Íö‘¡_!âƒû'–9 †åÌ™@ŠkD\ôËq Í:ÂçO€Ð+>iI¨9úP3 ºX”?é"¨x=”.ðcå8¤¡ü“ Œ 1Øð‚ì3ƒŠeàQœ ü ü #¹ ÀÂÌ;Aô¬Ål,³&ƒY@§d­œµÍç‚‚p&Çö Aþt±¡IEND®B`‚libDAI-0.2.7/doc/html/bipgraph_8h.html0000644000263000017630000000656111433220722016256 0ustar jorismkyb libDAI: include/dai/bipgraph.h File Reference

include/dai/bipgraph.h File Reference

Defines the BipartiteGraph class, which represents a bipartite graph. More...

#include <ostream>
#include <vector>
#include <algorithm>
#include <dai/util.h>
#include <dai/smallset.h>
#include <dai/exceptions.h>
#include <dai/graph.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::BipartiteGraph
 Represents the neighborhood structure of nodes in an undirected, bipartite graph. More...
struct  dai::BipartiteGraph::levelType
 Used internally by isTree(). More...

Detailed Description

Defines the BipartiteGraph class, which represents a bipartite graph.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/factor_8h-source.html0000644000263000017630000032534111433220722017236 0ustar jorismkyb libDAI: include/dai/factor.h Source File
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_107.png0000644000263000017630000000064011433220722015225 0ustar jorismkyb‰PNG  IHDR7–æ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfIDAT(‘…PÁjÂ@}Ù¬©Æµ ØžB‘Z/EèÅ£J¡”úþÀzô&~Ÿ„Þ¼z¨=û BÀOèìl"æt`vvx3ûÞ>àß°ÊÀeP D…«+ˆV!ø‰ç#0¾”‘ ‰´³‚¼±HkH ›Üc}Sd‹¹ ëè™òjEÀâ£sÖUe’AÿV+‚• ç¿ÅXaÒƒc†ìQSâ©‹´®S7̺Gª¿’i¬FQKÎÉå €­OÏ6ðôîQœ~Èf¸OhIŒ¶šú’Xߣ j ]ôÔY·=4\xa!~@–xwp¹s(çü3ž}B† …¥±˜rÏ7¥6Øq6Z~åœ#E%Ñ.Óø2),<NA)IEND®B`‚libDAI-0.2.7/doc/html/factorgraph_8h.html0000644000263000017630000000525111433220722016755 0ustar jorismkyb libDAI: include/dai/factorgraph.h File Reference

include/dai/factorgraph.h File Reference

Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields). More...

#include <iostream>
#include <map>
#include <dai/bipgraph.h>
#include <dai/graph.h>
#include <dai/factor.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::FactorGraph
 Represents a factor graph. More...

Detailed Description

Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields).

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1DAIAlg.html0000644000263000017630000005214411433220722017246 0ustar jorismkyb libDAI: dai::DAIAlg< GRM > Class Template Reference

dai::DAIAlg< GRM > Class Template Reference

Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph). More...

#include <dai/daialg.h>

Inheritance diagram for dai::DAIAlg< GRM >:

dai::InfAlg dai::BP dai::CBP dai::DecMAP dai::ExactInf dai::Gibbs dai::HAK dai::JTree dai::LC dai::MF dai::MR

List of all members.

Public Member Functions

Constructors/destructors
 DAIAlg ()
 Default constructor.
 DAIAlg (const GRM &grm)
 Construct from GRM.
Queries
FactorGraph & fg ()
 Returns reference to underlying FactorGraph.
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph.
Changing the factor graph
void clamp (size_t i, size_t x, bool backup=false)
 Clamp variable with index i to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one.
Backup/restore mechanism for factors
void backupFactor (size_t I)
 Make a backup copy of factor I.
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs.
void restoreFactor (size_t I)
 Restore factor I from its backup copy.
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies.

Detailed Description

template<class GRM>
class dai::DAIAlg< GRM >

Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph).

Inference algorithms in libDAI directly inherit from a DAIAlg, currently either from a DAIAlg<FactorGraph> or from a DAIAlg<RegionGraph>.

Template Parameters:
GRM Should be castable to FactorGraph
Idea:
A DAIAlg should not inherit from a FactorGraph or RegionGraph, but should store a reference to the graphical model object. This prevents needless copying of (possibly large) data structures. Disadvantage: the caller must not change the graphical model between calls to the inference algorithm (maybe a smart_ptr or some locking mechanism would help here?).

Constructor & Destructor Documentation

template<class GRM>
dai::DAIAlg< GRM >::DAIAlg (  )  [inline]

Default constructor.

template<class GRM>
dai::DAIAlg< GRM >::DAIAlg ( const GRM &  grm  )  [inline]

Construct from GRM.

Member Function Documentation

template<class GRM>
FactorGraph& dai::DAIAlg< GRM >::fg (  )  [inline, virtual]

Returns reference to underlying FactorGraph.

Implements dai::InfAlg.

template<class GRM>
const FactorGraph& dai::DAIAlg< GRM >::fg (  )  const [inline, virtual]

Returns constant reference to underlying FactorGraph.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::clamp ( size_t  i,
size_t  x,
bool  backup = false 
) [inline, virtual]

Clamp variable with index i to value x (i.e. multiply with a Kronecker delta $\delta_{x_i, x}$).

If backup == true, make a backup of all factors that are changed.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::makeCavity ( size_t  i,
bool  backup = false 
) [inline, virtual]

Sets all factors interacting with variable with index i to one.

If backup == true, make a backup of all factors that are changed.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::backupFactor ( size_t  I  )  [inline, virtual]

Make a backup copy of factor I.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::backupFactors ( const VarSet &  vs  )  [inline, virtual]

Make backup copies of all factors involving the variables in vs.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::restoreFactor ( size_t  I  )  [inline, virtual]

Restore factor I from its backup copy.

Implements dai::InfAlg.

template<class GRM>
void dai::DAIAlg< GRM >::restoreFactors ( const VarSet &  vs  )  [inline, virtual]

Restore the factors involving the variables in vs from their backup copies.

Implements dai::InfAlg.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:13 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x6f.html0000644000263000017630000003332311433220722017745 0ustar jorismkyb libDAI: Class Members - Functions
 

- o -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1Region.html0000644000263000017630000002164211433220722017447 0ustar jorismkyb libDAI: dai::Region Class Reference

dai::Region Class Reference

A Region is a set of variables with a counting number. More...

#include <dai/regiongraph.h>

Inheritance diagram for dai::Region:

dai::VarSet dai::SmallSet< T >

List of all members.

Public Member Functions

 Region ()
 Default constructor.
 Region (const VarSet &x, Real c)
 Construct from a set of variables and a counting number.
const Real & c () const
 Returns constant reference to counting number.
Real & c ()
 Returns reference to counting number.

Private Attributes

Real _c
 Counting number.

Detailed Description

A Region is a set of variables with a counting number.

Constructor & Destructor Documentation

dai::Region::Region (  )  [inline]

Default constructor.

dai::Region::Region ( const VarSet &  x,
Real  c 
) [inline]

Construct from a set of variables and a counting number.

Member Function Documentation

const Real& dai::Region::c (  )  const [inline]

Returns constant reference to counting number.

Real& dai::Region::c (  )  [inline]

Returns reference to counting number.

Member Data Documentation

Real dai::Region::_c [private]

Counting number.

The documentation for this class was generated from the following file:
Generated on Thu Aug 19 13:58:16 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/namespacemembers_enum.html0000644000263000017630000000400111433220722020401 0ustar jorismkyb libDAI: Class Members
 

  • ProbDistType : dai
  • ProbNormType : dai
Generated on Thu Aug 19 13:58:17 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__abs-members.html0000644000263000017630000000356011433220722021462 0ustar jorismkyb libDAI: Member List

dai::fo_abs< T > Member List

This is the complete list of members for dai::fo_abs< T >, including all inherited members.

operator()(const T &x) const dai::fo_abs< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/doc_8h.html0000644000263000017630000000641611433220722015226 0ustar jorismkyb libDAI: include/dai/doc.h File Reference

include/dai/doc.h File Reference

Contains additional doxygen documentation. More...

Go to the source code of this file.

Detailed Description

Contains additional doxygen documentation.

Todo:
Replace all Name members by virtual functions (or add virtual functions returning the Name)
Idea:
Adapt (part of the) guidelines in http://www.boost.org/development/requirements.html#Design_and_Programming
Idea:
Use "gcc -MM" to generate dependencies for targets: http://make.paulandlesley.org/autodep.html
Idea:
Disentangle structures. In particular, ensure that graphical properties are not entangled with probabilistic properties. For example, a FactorGraph contains several components:
  • a BipartiteGraph
  • an array of variable labels
  • an array of variable state space sizes
  • an array of pointers to factor value vectors In this way, each factor could be implemented differently, e.g., we could have some sparse factors, some noisy-OR factors, some dense factors, some arbitrary precision factors, etcetera.
Idea:
Use boost::uBLAS framework to deal with matrices, especially, with 2D sparse matrices. See http://www.boost.org/libs/numeric/ublas/doc/matrix_sparse.htm However: I read somewhere that boost::uBLAS concentrates more on correct implementation than on performance.
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_0x7e.html0000644000263000017630000001116111433220722016726 0ustar jorismkyb libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- ~ -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/todo.html0000644000263000017630000001303111433220722015016 0ustar jorismkyb libDAI: Todo List

Todo List

Member dai::CBP::getInfAlg ()
At present, CBP::getInfAlg() only returns a BP instance; it should be possible to select other inference algorithms via a property

Class dai::ClusterGraph
Remove the _vars and _clusters variables and use only the graph and a contextual factor graph.

Class dai::FactorGraph
Write a method that applies evidence (should we represent evidence as a map<Var,size_t> or as a map<size_t,size_t>?)

Class dai::FBP
Add nice way to set weights

Class dai::TFactor< T >
Define a better fileformat for .fg files (maybe using XML)?

Class dai::TFactor< T >
Add support for sparse factors.

Class dai::TRWBP
Merge code of FBP and TRWBP

Member dai::TRWBP::nrtrees
See if there is a way to wrap TRWBP::nrtrees in a props struct together with the other properties currently in TRWBP::props (without copying al lot of BP code literally)

File alldai.h
Replace VarSets by SmallSet<size_t> where appropriate, in order to minimize the use of FactorGraph::findVar().

File alldai.h
Improve SWIG interfaces and merge their build process with the main build process

File bbp.h
Clean up code

File bp.h
Consider using a priority_queue for maximum residual schedule

File clustergraph.h
The "MinFill" and "WeightedMinFill" variable elimination heuristics seem designed for Markov graphs; add similar heuristics which are designed for factor graphs.

File doc.h
Replace all Name members by virtual functions (or add virtual functions returning the Name)

File emalg.h
Implement parameter estimation for undirected models / factor graphs.

File hak.h
Use ClusterGraph instead of a vector<VarSet> for speed.

File hak.h
Optimize this code for large factor graphs.

File hak.h
Implement GBP parent-child algorithm.

File treeep.h
Clean up the TreeEP code (exploiting that a large part of the code is just a special case of JTree).

File weightedgraph.h
Improve general support for graphs and trees (in particular, a good tree implementation is needed).
Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1Neighbor.html0000644000263000017630000003172311433220722020201 0ustar jorismkyb libDAI: dai::Neighbor Struct Reference

dai::Neighbor Struct Reference

Describes the neighbor relationship of two nodes in a graph. More...

#include <dai/graph.h>

List of all members.

Public Member Functions

 Neighbor ()
 Default constructor.
 Neighbor (size_t iter, size_t node, size_t dual)
 Constructor that allows setting the values of the member variables.
 operator size_t () const
 Cast to size_t returns node member.

Public Attributes

size_t iter
 Corresponds to the index of this Neighbor entry in the vector of neighbors.
size_t node
 Contains the absolute index of the neighboring node.
size_t dual
 Contains the "dual" index (i.e., the index of this node in the Neighbors vector of the neighboring node).

Detailed Description

Describes the neighbor relationship of two nodes in a graph.

Most graphs that libDAI deals with are sparse. Therefore, a fast and memory-efficient way of representing the structure of a sparse graph is needed. A frequently used operation that also needs to be fast is switching between viewing node a as a neighbor of node b, and node b as a neighbor of node a. The Neighbor struct solves both of these problems.

Most sparse graphs in libDAI are represented by storing for each node in the graph the set of its neighbors. In practice, this set of neighbors is stored using the Neighbors type, which is simply a std::vector<Neighbor>. The Neighbor struct contains the label of the neighboring node (the node member) and additional information which allows to access a node as a neighbor of its neighbor (the dual member). For convenience, each Neighbor structure also stores its index in the Neighbors vector that it is part of (the iter member).

By convention, variable identifiers naming indices into a vector of neighbors are prefixed with an underscore ("_"). The neighbor list which they point into is then understood from the context.

Let us denote the _j 'th neighbor of node i by nb(i,_j), which is of the Neighbor type. Here, i is the "absolute" index of node i, but _j is understood as a "relative" index, giving node j 's entry in the Neighbors nb(i) of node i. The absolute index of _j, which would be denoted j, can be recovered from the node member, nb(i,_j).node. The iter member nb(i,_j).iter gives the relative index _j, and the dual member nb(i,_j).dual gives the "dual" relative index, i.e., the index of i in j 's neighbor list.

Iteration over edges can be easily accomplished: 

  for( size_t i = 0; i < nrNodes(); ++i ) {
      size_t _j = 0;
      foreach( const Neighbor &j, nb(i) ) {
          assert( j == nb(i,j.iter) );
          assert( nb(j.node,j.dual).node == i );
          assert( _j = j.iter );
          _j++;
      }
  }
Examples:

example_bipgraph.cpp.

Constructor & Destructor Documentation

dai::Neighbor::Neighbor (  )  [inline]

Default constructor.

dai::Neighbor::Neighbor ( size_t  iter,
size_t  node,
size_t  dual 
) [inline]

Constructor that allows setting the values of the member variables.

Member Function Documentation

dai::Neighbor::operator size_t (  )  const [inline]

Cast to size_t returns node member.

Member Data Documentation

size_t dai::Neighbor::iter

Corresponds to the index of this Neighbor entry in the vector of neighbors.

Examples:
example_bipgraph.cpp.

size_t dai::Neighbor::node

Contains the absolute index of the neighboring node.

Examples:
example_bipgraph.cpp.

size_t dai::Neighbor::dual

Contains the "dual" index (i.e., the index of this node in the Neighbors vector of the neighboring node).

Examples:
example_bipgraph.cpp.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_49.png0000644000263000017630000000031111433220722015145 0ustar jorismkyb‰PNG  IHDR RiÊo0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfGIDAT™c`À,)æ`†¿Í #€H| Ù20°>Ò Ì N˜?cct2JØX\¾B`þe0 2äý ÿÿáé^IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1fo__min.html0000644000263000017630000000762311433220722020054 0ustar jorismkyb libDAI: dai::fo_min< T > Struct Template Reference

dai::fo_min< T > Struct Template Reference

Function object that returns the minimum of two values. More...

#include <dai/prob.h>

List of all members.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (x > y ? y : x).

Detailed Description

template<typename T>
struct dai::fo_min< T >

Function object that returns the minimum of two values.

Member Function Documentation

template<typename T>
T dai::fo_min< T >::operator() ( const T &  x,
const T &  y 
) const [inline]

Returns (x > y ? y : x).

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_112.png0000644000263000017630000000047111433220722015223 0ustar jorismkyb‰PNG  IHDRã’0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf·IDAT•c`ÀØ Œ 0Ž9‹‚&ŒsAˆÆyÀ'Àád¸¹)9º  ¼ Ç0,5à4``èe`ÐØÄЮÒs‹?Al"Ã^y6 ’ ÇŸ!n9wÃ8Çqゆ¦…@Nòö” …€¯,«X ˜.ÀÔ&>``/€qX60ð*À8œªü0/ƒkÌ£^ lp»€†a‚(Èsn¸IEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1fo__KL-members.html0000644000263000017630000000357211433220722021226 0ustar jorismkyb libDAI: Member List

dai::fo_KL< T > Member List

This is the complete list of members for dai::fo_KL< T >, including all inherited members.

operator()(const T &p, const T &q) const dai::fo_KL< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/functions_func_0x6d.html0000644000263000017630000002103411433220722017737 0ustar jorismkyb libDAI: Class Members - Functions
 

- m -

Generated on Thu Aug 19 13:58:11 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_8.png0000644000263000017630000000206411433220722015067 0ustar jorismkyb‰PNG  IHDRê$uX»¹0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf²IDATX…í—Ï‹GÇ¿]5Ý==nÛ-ëï·A‰,ˆŒ«bð 79¸I u¶»þ@¼ TÄÈ›E’&³Ž!Éä‡3у'[AÄÛ z΂ÿÀ®¬Š ŽïÕô¬=J ww<ø U¯jêSõêÕ«àƒ¼wòkí~©ô{íFÌ”ºZ+•J·^Ûˆ­€ý¼É¤×Hm˜ùXnâ¦ÿ˜ú¬É$Pµ¦Ú°Ò¦Uóñ6=KJ4LæD-4Ž)}°Ñ¸4Þsd’”Õ¨Ys¡NRŒ(]m3qNæH 5j†?ê§Í€ÇìE=-ÛÉU½ð¦§¦Æ²RUÃÄTá®DOS—?uÒLõ‘²²Xµo ¯LЪå/eý•¿|Á3 a¬é+Fü„Ô…÷6/óâ]BèkvE¤BÇÝtÀvQØjyúq`œ\‰qÏtŸ È2òÎâ\ê[àAbªÿDNXäáh¿<v‡=˜Ç€t¹ŽKTôÓê«Ê¸ó•3;d¢¢«îíäT1ž.Χµ^ŽêyÖ!Hoj{ûiP¦ŽÒNÊØ“ƒŽG=™M(9Õ,Úþ Ô tÞ…Ë%ž»W·u¸wiÐt.Uœ4y6‚ &ºÏ(ªê9¦…£†šPò}íðœÚMQ{1Ò¾^ë—ÙÏC€<’§UêýÑð6fP4Cž/š©m‹Ze(¦Žöò„´jbªƒµØãÓ’ Jпy!þ³þ p'@É$ŸWWSŒLlsN)·«Àâ ™¹ÄT Ë;ø à3¤óè®w §:­ë e»âbÓ›Ÿýx ©GQVß{þɳÄÒ“QÂ&­¢9Ä0²Q!–‡ÕmZ¡¹iæ¹Iÿ˜ÔYúRö[‰>¹ÌœjQÁ˜’ ·‰ð²éúËÔrÀÕ©Ù™@.U*¾U©\Ž™R—*ÿb{¥ÒηÄi¯¬Œªøû–…ô OþÔzjN”.Àø':v›ÿ€ä»B\WÙDV‘zŠ¾–C¹óH›]"§ª¶§ÿ<ã4OÂtA÷“Ãæ–S¿)gê¼08Ù8XÆU§3«rQÓ…6P­à;òð*ñi~»}…áõäak"‡"º}ØY,÷[MµÝÕຠö´7‚“‡±^{É7=ZèNþÈk9æ¹1„•T‚¸3®<\ÀEìu)œÈÃ_£õ^Bÿªâ>ÊÄ(l/‰ôËp8ɲØ嵞ª{ú=`q8IõÚØÞjêÿŠÉw˜Ý¤å,oÐvËk”‘‰ö%ØIEND®B`‚libDAI-0.2.7/doc/html/structdai_1_1LC_1_1Properties.html0000644000263000017630000003771011433220722021461 0ustar jorismkyb libDAI: dai::LC::Properties Struct Reference

dai::LC::Properties Struct Reference

Parameters for LC. More...

#include <dai/lc.h>

List of all members.

Public Member Functions

 DAI_ENUM (CavityType, FULL, PAIR, PAIR2, UNIFORM)
 Enumeration of possible ways to initialize the cavities.
 DAI_ENUM (UpdateType, SEQFIX, SEQRND)
 Enumeration of different update schedules.

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr).
size_t maxiter
 Maximum number of iterations.
Real tol
 Tolerance for convergence test.
bool reinit
 Complete or partial reinitialization of cavity graphs?
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping).
CavityType cavity
 How to initialize the cavities.
UpdateType updates
 What update schedule to use.
std::string cavainame
 Name of the algorithm used to initialize the cavity distributions.
PropertySet cavaiopts
 Parameters for the algorithm used to initialize the cavity distributions.

Detailed Description

Parameters for LC.

Member Function Documentation

dai::LC::Properties::DAI_ENUM ( CavityType  ,
FULL  ,
PAIR  ,
PAIR2  ,
UNIFORM   
)

Enumeration of possible ways to initialize the cavities.

The following initialization methods are defined:

  • FULL calculates the marginal using calcMarginal()
  • PAIR calculates only second order interactions using calcPairBeliefs() with accurate == false
  • PAIR2 calculates only second order interactions using calcPairBeliefs() with accurate == true
  • UNIFORM uses a uniform distribution

dai::LC::Properties::DAI_ENUM ( UpdateType  ,
SEQFIX  ,
SEQRND   
)

Enumeration of different update schedules.

The following update schedules are defined:

  • SEQFIX sequential fixed schedule
  • SEQRND sequential random schedule

Member Data Documentation

size_t dai::LC::Properties::verbose

Verbosity (amount of output sent to stderr).

size_t dai::LC::Properties::maxiter

Maximum number of iterations.

Real dai::LC::Properties::tol

Tolerance for convergence test.

bool dai::LC::Properties::reinit

Complete or partial reinitialization of cavity graphs?

Real dai::LC::Properties::damping

Damping constant (0.0 means no damping, 1.0 is maximum damping).

CavityType dai::LC::Properties::cavity

How to initialize the cavities.

UpdateType dai::LC::Properties::updates

What update schedule to use.

std::string dai::LC::Properties::cavainame

Name of the algorithm used to initialize the cavity distributions.

PropertySet dai::LC::Properties::cavaiopts

Parameters for the algorithm used to initialize the cavity distributions.

The documentation for this struct was generated from the following file:
Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/classdai_1_1FactorGraph-members.html0000644000263000017630000004020011433220722022043 0ustar jorismkyb libDAI: Member List

dai::FactorGraph Member List

This is the complete list of members for dai::FactorGraph, including all inherited members.

_backupdai::FactorGraph [private]
_factorsdai::FactorGraph [private]
_Gdai::FactorGraph [private]
_varsdai::FactorGraph [private]
backupFactor(size_t I)dai::FactorGraph
backupFactors(const std::set< size_t > &facs)dai::FactorGraph [virtual]
backupFactors(const VarSet &ns)dai::FactorGraph
bipGraph() const dai::FactorGraph [inline]
clamp(size_t i, size_t x, bool backup=false)dai::FactorGraph [virtual]
clamped(size_t i, size_t x) const dai::FactorGraph
clampFactor(size_t I, const std::vector< size_t > &xIs, bool backup=false)dai::FactorGraph
clampVar(size_t i, const std::vector< size_t > &xis, bool backup=false)dai::FactorGraph
clone() const dai::FactorGraph [inline, virtual]
constructGraph(size_t nrEdges)dai::FactorGraph [private]
Delta(size_t i) const dai::FactorGraph
Delta(const VarSet &vs) const dai::FactorGraph
delta(size_t i) const dai::FactorGraph [inline]
delta(const VarSet &vs) const dai::FactorGraph [inline]
factor(size_t I) const dai::FactorGraph [inline]
FactorGraph()dai::FactorGraph [inline]
FactorGraph(const std::vector< Factor > &P)dai::FactorGraph
FactorGraph(FactorInputIterator facBegin, FactorInputIterator facEnd, VarInputIterator varBegin, VarInputIterator varEnd, size_t nrFacHint=0, size_t nrVarHint=0)dai::FactorGraph [inline]
factors() const dai::FactorGraph [inline]
findFactor(const VarSet &ns) const dai::FactorGraph [inline]
findVar(const Var &n) const dai::FactorGraph [inline]
findVars(const VarSet &ns) const dai::FactorGraph [inline]
isBinary() const dai::FactorGraph
isConnected() const dai::FactorGraph [inline]
isMaximal(size_t I) const dai::FactorGraph
isPairwise() const dai::FactorGraph
isTree() const dai::FactorGraph [inline]
logScore(const std::vector< size_t > &statevec)dai::FactorGraph
makeCavity(size_t i, bool backup=false)dai::FactorGraph [virtual]
MarkovGraph() const dai::FactorGraph
maximalFactor(size_t I) const dai::FactorGraph
maximalFactorDomains() const dai::FactorGraph
maximalFactors() const dai::FactorGraph
nbF(size_t I) const dai::FactorGraph [inline]
nbF(size_t I, size_t _i) const dai::FactorGraph [inline]
nbV(size_t i) const dai::FactorGraph [inline]
nbV(size_t i, size_t _I) const dai::FactorGraph [inline]
nrEdges() const dai::FactorGraph [inline]
nrFactors() const dai::FactorGraph [inline]
nrVars() const dai::FactorGraph [inline]
operator<<(std::ostream &os, const FactorGraph &fg)dai::FactorGraph [friend]
operator>>(std::istream &is, FactorGraph &fg)dai::FactorGraph [friend]
printDot(std::ostream &os) const dai::FactorGraph [virtual]
ReadFromFile(const char *filename)dai::FactorGraph [virtual]
restoreFactor(size_t I)dai::FactorGraph
restoreFactors()dai::FactorGraph [virtual]
restoreFactors(const VarSet &ns)dai::FactorGraph
setFactor(size_t I, const Factor &newFactor, bool backup=false)dai::FactorGraph [inline, virtual]
setFactors(const std::map< size_t, Factor > &facs, bool backup=false)dai::FactorGraph [inline, virtual]
var(size_t i) const dai::FactorGraph [inline]
vars() const dai::FactorGraph [inline]
WriteToFile(const char *filename, size_t precision=15) const dai::FactorGraph [virtual]
~FactorGraph()dai::FactorGraph [inline, virtual]

Generated on Thu Aug 19 13:58:14 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_114.png0000644000263000017630000000061711433220722015227 0ustar jorismkyb‰PNG  IHDR^m®ÕA0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf IDAT(‘c` à’0„³‘D»˜›!,¶FTõÒ Pã7$Ñ ×LdÀòÊàDSUÇôU=3Œï|E=Lûê N¡¨‡©ãIÀ®žM¡ H΂° P]Hœ_€5Y=#Ô²3ß#ý øX‚˜ú ‹¸P7›À$;€ ìIy†‹ ñ†$Îdó!îa5`°R‚@qŒP=·ÃòmíÃAP÷¯ŸÀr~²µ€êy2˜6€è8bF _˜z°{t] €4zø ‚O@Ì2UEHW­bÓPõ°©Ï„È S„ñr@W XEaÄöAO 6dPIEND®B`‚libDAI-0.2.7/doc/html/form_73.png0000644000263000017630000000067111433220722015153 0ustar jorismkyb‰PNG  IHDRJ#UØ0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf7IDAT(‘c` `À&*ˆÆWg``îhaðúŽ"ʦjË0¡ÚP€Âeq妠i>ÄÌa Æ Æ‰m < gÅ10Ø£9¯ˆ«Øæ'¾Tý"s$´’#nªª þÄøå‰ó†o| ¡¯ lPUY-üê²€a.PÕ-*¦ ™1U1}ÒÙ@™@§±?`xÀ¾@5 ì/Öð"e Ä» ¤?3`þÀ+Àð…/€aBÀ%  ”’›3C(ÐV*®2\üÅSÝ!¤¶¥ 8Amchád`Ø·äÆ 0ÞÖ…ŒR/9âáe©o@"ÆSVaà`hdaQ`1bàP€«bYÀ†œš @Êî%ƒ U7óEf$sIEND®B`‚libDAI-0.2.7/doc/html/form_29.png0000644000263000017630000000026011433220722015146 0ustar jorismkyb‰PNG  IHDR ­°á®0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf.IDAT™c`Î @‚ùà˜$x€?HÂDtƒˆc@âc(€h±@7ÿç‡uIEND®B`‚libDAI-0.2.7/doc/html/form_118.png0000644000263000017630000000026311433220722015230 0ustar jorismkyb‰PNG  IHDR r¢É0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf1IDAT™c`@¦ ’+ ŠHå0ð«©o ü @ê#?Hòƒ½w/‚iÄïȽ±àIEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1TreeEP.png0000644000263000017630000000123511433220722017164 0ustar jorismkyb‰PNG  IHDRÀß¡€PLTEÿÿÿÿÿÀŸŸ`ÀÀÀ{ÂÿätRNS@æØf3IDAThí™Krà †Í¦k¤ˆtÚ u•û¡ YX~$†xÒ¸‰›‰|Âñø ßÇìsøJ‡Ìר ± ì`/ ) 7D=BL€c廀ÚHHe*PšTpì´ÊÅI#°€ÖJ´0th%YRgÖ€ÆÈ. $Ñšwáº4çàªÁÆÍxÖã?~¬ïØÇÞ€‡.?O|\.Oœ`à8ÀopÝxÕøÍQ-Ë *g²ïýÀ†“L\ˆÅâñ‰ÉHd)B‚–«Z@•)¨5€ÕaR‰#O?,”-€- (8E0Ð8´)ÎÁî 0–‰U,Ê|þ…G&”¡L¨4¨ÊS±¨ŒIT€ `’‰U,’¬ŸF€,Ùä@vd8à `Ä"à 0»nÙ†Ö3¶ Ø‹=€M±ØØ1¸nü€ëF8ÀpÀû\7žPëElÔ§ZbW 7¦Þ¨€¬U ½Ldê €îráX¬«Ü[oœ ª³0• §¶ÅÓn½ñž%˜z#'^}Ç.t™^àºñá×p€à€÷À1‹C<¡¶QN²ZÈN>›2Éô9—Ã׀㠻›'„P¼í€bÈ#s ^ñ[¥'L hÍAéÉã {eò"'·aÁ Aµ `s°]ˆ5‰ƒî¸Œ]@§9àEGë¿PÕchËdIEND®B`‚libDAI-0.2.7/doc/html/treeep_8h.html0000644000263000017630000001063511433220722015743 0ustar jorismkyb libDAI: include/dai/treeep.h File Reference

include/dai/treeep.h File Reference

Defines class TreeEP, which implements Tree Expectation Propagation. More...

#include <vector>
#include <string>
#include <dai/daialg.h>
#include <dai/varset.h>
#include <dai/regiongraph.h>
#include <dai/factorgraph.h>
#include <dai/clustergraph.h>
#include <dai/weightedgraph.h>
#include <dai/jtree.h>
#include <dai/properties.h>
#include <dai/enum.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::TreeEP
 Approximate inference algorithm "Tree Expectation Propagation" [MiQ04]. More...
struct  dai::TreeEP::Properties
 Parameters for TreeEP. More...
class  dai::TreeEP::TreeEPSubTree
 Stores the data structures needed to efficiently update the approximation of an off-tree factor. More...

Detailed Description

Defines class TreeEP, which implements Tree Expectation Propagation.

Todo:
Clean up the TreeEP code (exploiting that a large part of the code is just a special case of JTree).
Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/factor_8h.html0000644000263000017630000001455711433220722015744 0ustar jorismkyb libDAI: include/dai/factor.h File Reference

include/dai/factor.h File Reference

Defines TFactor<> and Factor classes which represent factors in probability distributions. More...

#include <iostream>
#include <functional>
#include <cmath>
#include <dai/prob.h>
#include <dai/varset.h>
#include <dai/index.h>
#include <dai/util.h>

Go to the source code of this file.

Namespaces

namespace  dai

Classes

class  dai::TFactor< T >
 Represents a (probability) factor. More...

Typedefs

typedef TFactor< Real > dai::Factor
 Represents a factor with values of type dai::Real.

Functions

Factor dai::createFactorIsing (const Var &x, Real h)
 Returns a binary unnormalized single-variable factor $ \exp(hx) $ where $ x = \pm 1 $.
Factor dai::createFactorIsing (const Var &x1, const Var &x2, Real J)
 Returns a binary unnormalized pairwise factor $ \exp(J x_1 x_2) $ where $ x_1, x_2 = \pm 1 $.
Factor dai::createFactorExpGauss (const VarSet &vs, Real beta)
 Returns a random factor on the variables vs with strength beta.
Factor dai::createFactorPotts (const Var &x1, const Var &x2, Real J)
 Returns a pairwise Potts factor $ \exp( J \delta_{x_1, x_2} ) $.
Factor dai::createFactorDelta (const Var &v, size_t state)
 Returns a Kronecker delta point mass.
Factor dai::createFactorDelta (const VarSet &vs, size_t state)
 Returns a Kronecker delta point mass.

Detailed Description

Defines TFactor<> and Factor classes which represent factors in probability distributions.

Generated on Thu Aug 19 13:58:10 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/pages.html0000644000263000017630000000354711433220722015163 0ustar jorismkyb libDAI: Page Index

Related Pages

Here is a list of all related documentation pages:
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/structdai_1_1fo__id-members.html0000644000263000017630000000355211433220722021312 0ustar jorismkyb libDAI: Member List

dai::fo_id< T > Member List

This is the complete list of members for dai::fo_id< T >, including all inherited members.

operator()(const T &x) const dai::fo_id< T > [inline]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_62.png0000644000263000017630000000116111433220722015144 0ustar jorismkyb‰PNG  IHDR~?öæ)0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfïIDAT8­“1kÛ@Åßù\Åv"#×à! EYã”! Thh ý&Ćdrik(dp1 8U'2¤[ç~‚¦d „N͈ñèÿ%\j—>ÐîI¿ûŸîž€ÿ%kj3®—ª{à¢û¬lÉÑSe¦ZÊ”b‰|Uu9z9_æå(7•à9àømênh˜q/Í•ÈT2'óüÕû¥ŠsAP†t yev#S¬ÞÆÂdÞ´ªÄßpìƒ÷wÂÐÏ+³™¤¹:Ìän.] ~Þ~>çãUÊðK¤;²¾2Û‘IâõX}_zwÔì²7­G¡ßÄžwŠYG libDAI: include/dai/cbp.h Source File
Generated on Thu Aug 19 13:58:09 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_32.png0000644000263000017630000000031611433220722015142 0ustar jorismkyb‰PNG  IHDRÔ¹0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØfLIDAT™c`@ÊPZ»l.„ñˆAL3``3˜~@Õäý`ƒ°Ù?p)Q†| ~kXÛžäN† CÀLá0Lc9’…. £«±S2IEND®B`‚libDAI-0.2.7/doc/html/classdai_1_1MF-members.html0000644000263000017630000002463411433220722020162 0ustar jorismkyb libDAI: Member List

dai::MF Member List

This is the complete list of members for dai::MF, including all inherited members.

_beliefsdai::MF [private]
_itersdai::MF [private]
_maxdiffdai::MF [private]
backupFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
backupFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
belief(const Var &v) const dai::MF [inline, virtual]
belief(const VarSet &vs) const dai::MF [virtual]
beliefF(size_t I) const dai::InfAlg [inline, virtual]
beliefs() const dai::MF [virtual]
beliefV(size_t i) const dai::MF [virtual]
calcNewBelief(size_t i)dai::MF [private]
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
clone() const dai::MF [inline, virtual]
construct()dai::MF [private]
DAIAlg()dai::DAIAlg< GRM > [inline]
DAIAlg(const GRM &grm)dai::DAIAlg< GRM > [inline]
fg()dai::DAIAlg< GRM > [inline, virtual]
fg() const dai::DAIAlg< GRM > [inline, virtual]
findMaximum() const dai::InfAlg [inline, virtual]
getProperties() const dai::MF [virtual]
identify() const dai::MF [virtual]
init()dai::MF [virtual]
init(const VarSet &ns)dai::MF [virtual]
Iterations() const dai::MF [inline, virtual]
logZ() const dai::MF [virtual]
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM > [inline, virtual]
maxDiff() const dai::MF [inline, virtual]
MF()dai::MF [inline]
MF(const FactorGraph &fg, const PropertySet &opts)dai::MF [inline]
Namedai::MF [static]
printProperties() const dai::MF [virtual]
props (defined in dai::MF)dai::MF
restoreFactor(size_t I)dai::DAIAlg< GRM > [inline, virtual]
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM > [inline, virtual]
run()dai::MF [virtual]
setMaxIter(size_t maxiter)dai::MF [inline, virtual]
setProperties(const PropertySet &opts)dai::MF [virtual]
~InfAlg()dai::InfAlg [inline, virtual]

Generated on Thu Aug 19 13:58:15 2010 for libDAI by  doxygen 1.5.5
libDAI-0.2.7/doc/html/form_4.png0000644000263000017630000000025511433220722015063 0ustar jorismkyb‰PNG  IHDR ©E1“0PLTEÿÿÿàààÐÐÐÀÀÀ°°°   €€€ppp```PPP@@@000 4ŸtRNS@æØf+IDAT™c`€0ù…X @dàºDò€Eä™Ad‡1ˆ4O€©®Â‘y,IEND®B`‚libDAI-0.2.7/README0000644000263000017630000003213411433220722012337 0ustar jorismkyblibDAI - A free/open source C++ library for Discrete Approximate Inference ------------------------------------------------------------------------------- Version: 0.2.7 Date: August 19, 2010 See also: http://www.libdai.org ------------------------------------------------------------------------------- License libDAI is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. libDAI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with libDAI in the file COPYING. If not, see http://www.gnu.org/licenses/ ------------------------------------------------------------------------------- Citing libDAI If you write a scientific paper describing research that made substantive use of this library, please cite the following paper describing libDAI: Joris M. Mooij; libDAI: A free & open source C++ library for Discrete Approximate Inference in graphical models; Journal of Machine Learning Research, in press, 2010. In BiBTeX format (for your convenience): @article{mooij2010libDAI, author = {Joris M. Mooij}, title = {lib{DAI}: A free & open source {C}++ Library for {D}iscrete {A}pproximate {I}nference in graphical models}, journal = {Journal of Machine Learning Research}, volume = {in press}, year = 2010 } Moreover, as a personal note, I would appreciate it to be informed about any publications using libDAI at joris dot mooij at libdai dot org. ------------------------------------------------------------------------------- About libDAI libDAI is a free/open source C++ library (licensed under GPL 2+) that provides implementations of various (approximate) inference methods for discrete graphical models. libDAI supports arbitrary factor graphs with discrete variables; this includes discrete Markov Random Fields and Bayesian Networks. The library is targeted at researchers. To be able to use the library, a good understanding of graphical models is needed. The best way to use libDAI is by writing C++ code that invokes the library; in addition, part of the functionality is accessibly by using the * command line interface * (limited) MatLab interface * (experimental) python interface * (experimental) octave interface. libDAI can be used to implement novel (approximate) inference algorithms and to easily compare the accuracy and performance with existing algorithms that have been implemented already. A solver using libDAI was amongst the three winners of the UAI 2010 Approximate Inference Challenge (see http://www.cs.huji.ac.il/project/UAI10/ for more information). The full source code is provided as part of the library. Features Currently, libDAI supports the following (approximate) inference methods: * Exact inference by brute force enumeration; * Exact inference by junction-tree methods; * Mean Field; * Loopy Belief Propagation [KFL01]; * Fractional Belief Propagation [WiH03]; * Tree-Reweighted Belief Propagation [WJW03]; * Tree Expectation Propagation [MiQ04]; * Generalized Belief Propagation [YFW05]; * Double-loop GBP [HAK03]; * Various variants of Loop Corrected Belief Propagation [MoK07, MoR05]; * Gibbs sampler; * Conditioned Belief Propagation [EaG09]; * Decimation algorithm. These inference methods can be used to calculate partition sums, marginals over subsets of variables, and MAP states (the joint state of variables that has maximum probability). In addition, libDAI supports parameter learning of conditional probability tables by Expectation Maximization. Limitations libDAI is not intended to be a complete package for approximate inference. Instead, it should be considered as an "inference engine", providing various inference methods. In particular, it contains no GUI, currently only supports its own file format for input and output (although support for standard file formats may be added later), and provides very limited visualization functionalities. The only learning method supported currently is Expectation Maximization (or Maximum Likelihood if no data is missing) for learning factor parameters. Rationale In my opinion, the lack of open source "reference" implementations hampers progress in research on approximate inference. Methods differ widely in terms of quality and performance characteristics, which also depend in different ways on various properties of the graphical models. Finding the best approximate inference method for a particular application therefore often requires empirical comparisons. However, implementing and debugging these methods takes a lot of time which could otherwise be spent on research. I hope that this code will aid researchers to be able to easily compare various (existing as well as new) approximate inference methods, in this way accelerating research and stimulating real-world applications of approximate inference. Language Because libDAI is implemented in C++, it is very fast compared with implementations in MatLab (a factor 1000 faster is not uncommon). libDAI does provide a (limited) MatLab interface for easy integration with MatLab. It also provides a command line interface and experimental python and octave interfaces (thanks to Patrick Pletscher). Compatibility The code has been developed under Debian GNU/Linux with the GCC compiler suite. libDAI compiles successfully with g++ versions 3.4 up to 4.4. libDAI has also been successfully compiled with MS Visual Studio 2008 under Windows (but not all build targets are supported yet) and with Cygwin under Windows. Finally, libDAI has been compiled successfully on MacOS X. Downloading libDAI The libDAI sources and documentation can be downloaded from the libDAI website: http://www.libdai.org. Mailing list The Google group "libDAI" (http://groups.google.com/group/libdai) can be used for getting support and discussing development issues. ------------------------------------------------------------------------------- Building libDAI under UNIX variants (Linux / Cygwin / Mac OS X) Preparations You need: * a recent version of gcc (at least version 3.4) * GNU make * recent boost C++ libraries (at least version 1.37; however, version 1.37 shipped with Ubuntu 9.04 is known not to work) * doxygen (only for building the documentation) * graphviz (only for using some of the libDAI command line utilities) * CImg library (only for building the image segmentation example) On Debian/Ubuntu, you can easily install the required packages with a single command: apt-get install g++ make doxygen graphviz libboost-dev libboost-graph-dev libboost-program-options-dev libboost-test-dev cimg-dev (root permissions needed). On Mac OS X (10.4 is known to work), these packages can be installed easily via MacPorts. If MacPorts is not already installed, install it according to the instructions at http://www.macports.org/. Then, a simple sudo port install gmake boost doxygen graphviz should be enough to install everything that is needed. On Cygwin, the prebuilt Cygwin package boost-1.33.1-x is known not to work. You can however obtain the latest boost version (you need at least 1.37.0) from http://www.boost.org/ and build it as described in the next subsection. Building boost under Cygwin * Download the latest boost libraries from http://www.boost.org * Build the required boost libraries using: ./bootstrap.sh --with-libraries=program_options,math,graph,test --prefix=/boost_root/ ./bjam * In order to use dynamic linking, the boost .dll's should be somewhere in the path. This can be achieved by a command like: export PATH=$PATH:/boost_root/stage/lib Building libDAI To build the libDAI source, first copy a template Makefile.* to Makefile.conf (for example, copy Makefile.LINUX to Makefile.conf if you use GNU/Linux). Then, edit the Makefile.conf template to adapt it to your local setup. In case you want to use Boost libraries which are installed in non-standard locations, you have to tell the compiler and linker about their locations (using the -I, -L flags for GCC; also you may need to set the LD_LIBRARY_PATH environment variable correctly before running libDAI binaries). Platform independent build options can be set in Makefile.ALL. Finally, run make The build includes a regression test, which may take a while to complete. If the build is successful, you can test the example program: examples/example tests/alarm.fg or the more extensive test program: tests/testdai --aliases tests/aliases.conf --filename tests/alarm.fg --methods JTREE_HUGIN BP_SEQMAX ------------------------------------------------------------------------------- Building libDAI under Windows Preparations You need: * A recent version of MicroSoft Visual Studio (2008 is known to work) * recent boost C++ libraries (version 1.37 or higher) * GNU make (can be obtained from http://gnuwin32.sourceforge.net) * CImg library (only for building the image segmentation example) For the regression test, you need: * GNU diff, GNU sed (can be obtained from http://gnuwin32.sourceforge.net) Building boost under Windows Because building boost under Windows is tricky, I provide some guidance here. * Download the boost zip file from http://www.boost.org/users/download and unpack it somewhere. * Download the bjam executable from http://www.boost.org/users/download and unpack it somewhere else. * Download Boost.Build (v2) from http://www.boost.org/docs/tools/build/ index.html and unpack it yet somewhere else. * Edit the file boost-build.jam in the main boost directory to change the BOOST_BUILD directory to the place where you put Boost.Build (use UNIX / instead of Windows \ in pathnames). * Copy the bjam.exe executable into the main boost directory. Now if you issue "bjam --version" you should get a version and no errors. Issueing "bjam --show-libraries" will show the libraries that will be built. * The following command builds the boost libraries that are relevant for libDAI: bjam --with-graph --with-math --with-program_options --with-test link=static runtime-link=shared Building libDAI To build the source, copy Makefile.WINDOWS to Makefile.conf. Then, edit Makefile.conf to adapt it to your local setup. Platform independent build options can be set in Makefile.ALL. Finally, run (from the command line) make The build includes a regression test, which may take a while to complete. If the build is successful, you can test the example program: examples\example tests\alarm.fg or the more extensive test program: tests\testdai --aliases tests\aliases.conf --filename tests\alarm.fg --methods JTREE_HUGIN BP_SEQMAX ------------------------------------------------------------------------------- Building the libDAI MatLab interface You need: * MatLab * The platform-dependent requirements described above First, you need to build the libDAI source as described above for your platform. By default, the MatLab interface is disabled, so before compiling the source, you have to enable it in Makefile.ALL by setting WITH_MATLAB=true Also, you have to configure the MatLab-specific parts of Makefile.conf to match your system (in particular, the Makefile variables ME, MATLABDIR and MEX). The MEX file extension depends on your platform; for a 64-bit linux x86_64 system this would be "ME=.mexa64", for a 32-bit linux x86 system "ME=.mexglx". If you are unsure about your MEX file extension: it needs to be the same as what the MatLab command "mexext" returns. The required MEX files are built by issuing make from the command line. The MatLab interface is much less powerful than using libDAI from C++. There are two reasons for this: (i) it is boring to write MEX files; (ii) the large performance penalty paid when large data structures (like factor graphs) have to be converted between their native C++ data structure to something that MatLab understands. A simple example of how to use the MatLab interface is the following (entered at the MatLab prompt), which performs exact inference by the junction tree algorithm and approximate inference by belief propagation on the ALARM network: cd path_to_libdai/matlab [psi] = dai_readfg ('../tests/alarm.fg'); [logZ,q,md,qv,qf] = dai (psi, 'JTREE', '[updates=HUGIN,verbose=0]') [logZ,q,md,qv,qf] = dai (psi, 'BP', '[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0]') where "path_to_libdai" has to be replaced with the directory in which libDAI was installed. For other algorithms and some default parameters, see the file tests/aliases.conf. ------------------------------------------------------------------------------- Building the documentation Install doxygen, graphviz and a TeX distribution and use make doc to build the documentation. If the documentation is not clear enough, feel free to send me an email (or even better, to improve the documentation and send a patch!). The documentation can also be browsed online at http://www.libdai.org. libDAI-0.2.7/COPYING0000644000263000017630000004313311433220722012513 0ustar jorismkyb GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. libDAI-0.2.7/tests/0000755000263000017630000000000011433220722012616 5ustar jorismkyblibDAI-0.2.7/tests/unit/0000755000263000017630000000000011433220722013575 5ustar jorismkyblibDAI-0.2.7/tests/unit/clustergraph_test.cpp0000644000263000017630000004316511433220722020054 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; const double tol = 1e-8; #define BOOST_TEST_MODULE ClusterGraphTest #include #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { Var v0( 0, 2 ); Var v1( 1, 3 ); Var v2( 2, 2 ); Var v3( 3, 4 ); ClusterGraph G; BOOST_CHECK_EQUAL( G.clusters(), std::vector() ); BOOST_CHECK( G.bipGraph() == BipartiteGraph() ); BOOST_CHECK_EQUAL( G.nrVars(), 0 ); BOOST_CHECK_EQUAL( G.nrClusters(), 0 ); #ifdef DAI_DEBUG BOOST_CHECK_THROW( G.var( 0 ), Exception ); BOOST_CHECK_THROW( G.cluster( 0 ), Exception ); #endif BOOST_CHECK_EQUAL( G.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G.findCluster( v0 ), 0 ); BOOST_CHECK_EQUAL( G.findCluster( VarSet(v0,v1) ), 0 ); std::vector vs; vs.push_back( v0 ); vs.push_back( v1 ); vs.push_back( v2 ); vs.push_back( v3 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v03( v0, v3 ); VarSet v12( v1, v2 ); VarSet v13( v1, v3 ); VarSet v23( v2, v3 ); std::vector cl; cl.push_back( v01 ); cl.push_back( v12 ); cl.push_back( v23 ); cl.push_back( v13 ); ClusterGraph G2( cl ); BOOST_CHECK_EQUAL( G2.nrVars(), 4 ); BOOST_CHECK_EQUAL( G2.nrClusters(), 4 ); BOOST_CHECK_EQUAL( G2.vars(), vs ); BOOST_CHECK_EQUAL( G2.clusters(), cl ); BOOST_CHECK_EQUAL( G2.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G2.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G2.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G2.findVar( v3 ), 3 ); BOOST_CHECK_EQUAL( G2.findVar( Var(4, 2) ), 4 ); BOOST_CHECK_EQUAL( G2.findCluster( v01 ), 0 ); BOOST_CHECK_EQUAL( G2.findCluster( v12 ), 1 ); BOOST_CHECK_EQUAL( G2.findCluster( v23 ), 2 ); BOOST_CHECK_EQUAL( G2.findCluster( v13 ), 3 ); BOOST_CHECK_EQUAL( G2.findCluster( v02 ), 4 ); BOOST_CHECK_EQUAL( G2.findCluster( v03 ), 4 ); ClusterGraph Gb( G ); BOOST_CHECK( G.bipGraph() == Gb.bipGraph() ); BOOST_CHECK( G.vars() == Gb.vars() ); BOOST_CHECK( G.clusters() == Gb.clusters() ); ClusterGraph Gc = G; BOOST_CHECK( G.bipGraph() == Gc.bipGraph() ); BOOST_CHECK( G.vars() == Gc.vars() ); BOOST_CHECK( G.clusters() == Gc.clusters() ); ClusterGraph G2b( G2 ); BOOST_CHECK( G2.bipGraph() == G2b.bipGraph() ); BOOST_CHECK( G2.vars() == G2b.vars() ); BOOST_CHECK( G2.clusters() == G2b.clusters() ); ClusterGraph G2c = G2; BOOST_CHECK( G2.bipGraph() == G2c.bipGraph() ); BOOST_CHECK( G2.vars() == G2c.vars() ); BOOST_CHECK( G2.clusters() == G2c.clusters() ); std::vector facs; facs.push_back( Factor( v01 ) ); facs.push_back( Factor( v12 ) ); facs.push_back( Factor( v1 ) ); facs.push_back( Factor( v2 ) ); facs.push_back( Factor( v23 ) ); facs.push_back( Factor( v13 ) ); FactorGraph F3( facs ); ClusterGraph G3( F3, false ); BOOST_CHECK_EQUAL( G3.bipGraph(), F3.bipGraph() ); BOOST_CHECK_EQUAL( G3.nrVars(), F3.nrVars() ); for( size_t i = 0; i < 4; i++ ) BOOST_CHECK_EQUAL( G3.var(i), F3.var(i) ); BOOST_CHECK_EQUAL( G3.vars(), F3.vars() ); BOOST_CHECK_EQUAL( G3.nrClusters(), F3.nrFactors() ); for( size_t I = 0; I < 6; I++ ) BOOST_CHECK_EQUAL( G3.cluster(I), F3.factor(I).vars() ); ClusterGraph G4( FactorGraph( facs ), true ); BOOST_CHECK_EQUAL( G4.nrVars(), 4 ); BOOST_CHECK_EQUAL( G4.var(0), v0 ); BOOST_CHECK_EQUAL( G4.var(1), v1 ); BOOST_CHECK_EQUAL( G4.var(2), v2 ); BOOST_CHECK_EQUAL( G4.var(3), v3 ); BOOST_CHECK_EQUAL( G4.nrClusters(), 4 ); BOOST_CHECK_EQUAL( G4.cluster(0), v01 ); BOOST_CHECK_EQUAL( G4.cluster(1), v12 ); BOOST_CHECK_EQUAL( G4.cluster(2), v23 ); BOOST_CHECK_EQUAL( G4.cluster(3), v13 ); std::vector edges; edges.push_back( Edge(0, 0) ); edges.push_back( Edge(1, 0) ); edges.push_back( Edge(1, 1) ); edges.push_back( Edge(1, 3) ); edges.push_back( Edge(2, 1) ); edges.push_back( Edge(2, 2) ); edges.push_back( Edge(3, 2) ); edges.push_back( Edge(3, 3) ); BipartiteGraph G4G( 4, 4, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G4.bipGraph(), G4G ); } BOOST_AUTO_TEST_CASE( QueriesTest ) { Var v0( 0, 2 ); Var v1( 1, 3 ); Var v2( 2, 2 ); Var v3( 3, 4 ); Var v4( 4, 2 ); std::vector vs; vs.push_back( v0 ); vs.push_back( v1 ); vs.push_back( v2 ); vs.push_back( v3 ); vs.push_back( v4 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v03( v0, v3 ); VarSet v04( v0, v4 ); VarSet v12( v1, v2 ); VarSet v13( v1, v3 ); VarSet v14( v1, v4 ); VarSet v23( v2, v3 ); VarSet v24( v2, v4 ); VarSet v34( v3, v4 ); VarSet v123 = v12 | v3; std::vector cl; cl.push_back( v01 ); cl.push_back( v12 ); cl.push_back( v123 ); cl.push_back( v34 ); cl.push_back( v04 ); ClusterGraph G( cl ); BOOST_CHECK_EQUAL( G.nrVars(), 5 ); BOOST_CHECK_EQUAL( G.vars(), vs ); BOOST_CHECK_EQUAL( G.var(0), v0 ); BOOST_CHECK_EQUAL( G.var(1), v1 ); BOOST_CHECK_EQUAL( G.var(2), v2 ); BOOST_CHECK_EQUAL( G.var(3), v3 ); BOOST_CHECK_EQUAL( G.var(4), v4 ); BOOST_CHECK_EQUAL( G.nrClusters(), 5 ); BOOST_CHECK_EQUAL( G.clusters(), cl ); BOOST_CHECK_EQUAL( G.cluster(0), v01 ); BOOST_CHECK_EQUAL( G.cluster(1), v12 ); BOOST_CHECK_EQUAL( G.cluster(2), v123 ); BOOST_CHECK_EQUAL( G.cluster(3), v34 ); BOOST_CHECK_EQUAL( G.cluster(4), v04 ); BOOST_CHECK_EQUAL( G.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G.findVar( v3 ), 3 ); BOOST_CHECK_EQUAL( G.findVar( v4 ), 4 ); BOOST_CHECK_EQUAL( G.findCluster( v01 ), 0 ); BOOST_CHECK_EQUAL( G.findCluster( v12 ), 1 ); BOOST_CHECK_EQUAL( G.findCluster( v123 ), 2 ); BOOST_CHECK_EQUAL( G.findCluster( v34 ), 3 ); BOOST_CHECK_EQUAL( G.findCluster( v04 ), 4 ); BOOST_CHECK_EQUAL( G.findCluster( v02 ), 5 ); BOOST_CHECK_EQUAL( G.findCluster( v03 ), 5 ); BOOST_CHECK_EQUAL( G.findCluster( v13 ), 5 ); BOOST_CHECK_EQUAL( G.findCluster( v14 ), 5 ); BOOST_CHECK_EQUAL( G.findCluster( v23 ), 5 ); BOOST_CHECK_EQUAL( G.findCluster( v24 ), 5 ); BipartiteGraph H( 5, 5 ); H.addEdge( 0, 0 ); H.addEdge( 1, 0 ); H.addEdge( 1, 1 ); H.addEdge( 2, 1 ); H.addEdge( 1, 2 ); H.addEdge( 2, 2 ); H.addEdge( 3, 2 ); H.addEdge( 3, 3 ); H.addEdge( 4, 3 ); H.addEdge( 0, 4 ); H.addEdge( 4, 4 ); BOOST_CHECK( G.bipGraph() == H ); BOOST_CHECK_EQUAL( G.delta( 0 ), v14 ); BOOST_CHECK_EQUAL( G.delta( 1 ), v02 | v3 ); BOOST_CHECK_EQUAL( G.delta( 2 ), v13 ); BOOST_CHECK_EQUAL( G.delta( 3 ), v12 | v4 ); BOOST_CHECK_EQUAL( G.delta( 4 ), v03 ); BOOST_CHECK_EQUAL( G.Delta( 0 ), v14 | v0 ); BOOST_CHECK_EQUAL( G.Delta( 1 ), v01 | v23 ); BOOST_CHECK_EQUAL( G.Delta( 2 ), v13 | v2 ); BOOST_CHECK_EQUAL( G.Delta( 3 ), v12 | v34 ); BOOST_CHECK_EQUAL( G.Delta( 4 ), v03 | v4 ); BOOST_CHECK( !G.adj( 0, 0 ) ); BOOST_CHECK( G.adj( 0, 1 ) ); BOOST_CHECK( !G.adj( 0, 2 ) ); BOOST_CHECK( !G.adj( 0, 3 ) ); BOOST_CHECK( G.adj( 0, 4 ) ); BOOST_CHECK( G.adj( 1, 0 ) ); BOOST_CHECK( !G.adj( 1, 1 ) ); BOOST_CHECK( G.adj( 1, 2 ) ); BOOST_CHECK( G.adj( 1, 3 ) ); BOOST_CHECK( !G.adj( 1, 4 ) ); BOOST_CHECK( !G.adj( 2, 0 ) ); BOOST_CHECK( G.adj( 2, 1 ) ); BOOST_CHECK( !G.adj( 2, 2 ) ); BOOST_CHECK( G.adj( 2, 3 ) ); BOOST_CHECK( !G.adj( 2, 4 ) ); BOOST_CHECK( !G.adj( 3, 0 ) ); BOOST_CHECK( G.adj( 3, 1 ) ); BOOST_CHECK( G.adj( 3, 2 ) ); BOOST_CHECK( !G.adj( 3, 3 ) ); BOOST_CHECK( G.adj( 3, 4 ) ); BOOST_CHECK( G.adj( 4, 0 ) ); BOOST_CHECK( !G.adj( 4, 1 ) ); BOOST_CHECK( !G.adj( 4, 2 ) ); BOOST_CHECK( G.adj( 4, 3 ) ); BOOST_CHECK( !G.adj( 4, 4 ) ); BOOST_CHECK( G.isMaximal( 0 ) ); BOOST_CHECK( !G.isMaximal( 1 ) ); BOOST_CHECK( G.isMaximal( 2 ) ); BOOST_CHECK( G.isMaximal( 3 ) ); BOOST_CHECK( G.isMaximal( 4 ) ); } BOOST_AUTO_TEST_CASE( OperationsTest ) { Var v0( 0, 2 ); Var v1( 1, 3 ); Var v2( 2, 2 ); Var v3( 3, 4 ); Var v4( 4, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v03( v0, v3 ); VarSet v04( v0, v4 ); VarSet v12( v1, v2 ); VarSet v13( v1, v3 ); VarSet v14( v1, v4 ); VarSet v23( v2, v3 ); VarSet v24( v2, v4 ); VarSet v34( v3, v4 ); VarSet v123 = v12 | v3; std::vector cl; cl.push_back( v01 ); cl.push_back( v12 ); cl.push_back( v123 ); cl.push_back( v34 ); cl.push_back( v04 ); ClusterGraph G( cl ); BipartiteGraph H( 5, 5 ); H.addEdge( 0, 0 ); H.addEdge( 1, 0 ); H.addEdge( 1, 1 ); H.addEdge( 2, 1 ); H.addEdge( 1, 2 ); H.addEdge( 2, 2 ); H.addEdge( 3, 2 ); H.addEdge( 3, 3 ); H.addEdge( 4, 3 ); H.addEdge( 0, 4 ); H.addEdge( 4, 4 ); BOOST_CHECK( G.bipGraph() == H ); G.eraseNonMaximal(); BOOST_CHECK_EQUAL( G.nrClusters(), 4 ); H.eraseNode2( 1 ); BOOST_CHECK( G.bipGraph() == H ); G.eraseSubsuming( 4 ); BOOST_CHECK_EQUAL( G.nrClusters(), 2 ); H.eraseNode2( 2 ); H.eraseNode2( 2 ); BOOST_CHECK( G.bipGraph() == H ); G.insert( v34 ); BOOST_CHECK_EQUAL( G.nrClusters(), 3 ); G.insert( v123 ); BOOST_CHECK_EQUAL( G.nrClusters(), 3 ); H.addNode2(); H.addEdge( 3, 2 ); H.addEdge( 4, 2 ); BOOST_CHECK( G.bipGraph() == H ); G.insert( v12 ); G.insert( v23 ); BOOST_CHECK_EQUAL( G.nrClusters(), 5 ); H.addNode2(); H.addNode2(); H.addEdge( 1, 3 ); H.addEdge( 2, 3 ); H.addEdge( 2, 4 ); H.addEdge( 3, 4 ); BOOST_CHECK( G.bipGraph() == H ); G.eraseNonMaximal(); BOOST_CHECK_EQUAL( G.nrClusters(), 3 ); H.eraseNode2( 3 ); H.eraseNode2( 3 ); BOOST_CHECK( G.bipGraph() == H ); G.eraseSubsuming( 2 ); BOOST_CHECK_EQUAL( G.nrClusters(), 2 ); H.eraseNode2( 1 ); BOOST_CHECK( G.bipGraph() == H ); G.eraseNonMaximal(); BOOST_CHECK_EQUAL( G.nrClusters(), 2 ); BOOST_CHECK( G.bipGraph() == H ); G.eraseSubsuming( 0 ); BOOST_CHECK_EQUAL( G.nrClusters(), 1 ); H.eraseNode2( 0 ); BOOST_CHECK( G.bipGraph() == H ); G.eraseSubsuming( 4 ); BOOST_CHECK_EQUAL( G.nrClusters(), 0 ); H.eraseNode2( 0 ); BOOST_CHECK( G.bipGraph() == H ); } BOOST_AUTO_TEST_CASE( VarElimTest ) { Var v0( 0, 2 ); Var v1( 1, 3 ); Var v2( 2, 2 ); Var v3( 3, 4 ); Var v4( 4, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v03( v0, v3 ); VarSet v04( v0, v4 ); VarSet v12( v1, v2 ); VarSet v13( v1, v3 ); VarSet v14( v1, v4 ); VarSet v23( v2, v3 ); VarSet v24( v2, v4 ); VarSet v34( v3, v4 ); VarSet v123 = v12 | v3; std::vector cl; cl.push_back( v01 ); cl.push_back( v12 ); cl.push_back( v123 ); cl.push_back( v34 ); cl.push_back( v04 ); ClusterGraph G( cl ); ClusterGraph Gorg = G; BipartiteGraph H( 5, 5 ); H.addEdge( 0, 0 ); H.addEdge( 1, 0 ); H.addEdge( 1, 1 ); H.addEdge( 2, 1 ); H.addEdge( 1, 2 ); H.addEdge( 2, 2 ); H.addEdge( 3, 2 ); H.addEdge( 3, 3 ); H.addEdge( 4, 3 ); H.addEdge( 0, 4 ); H.addEdge( 4, 4 ); BOOST_CHECK( G.bipGraph() == H ); G = Gorg; BOOST_CHECK_EQUAL( G.elimVar( 0 ), v14 | v0 ); BOOST_CHECK_EQUAL( G.vars(), Gorg.vars() ); BOOST_CHECK_EQUAL( G.nrClusters(), 3 ); BOOST_CHECK_EQUAL( G.cluster(0), v123 ); BOOST_CHECK_EQUAL( G.cluster(1), v34 ); BOOST_CHECK_EQUAL( G.cluster(2), v14 ); BipartiteGraph H_0( 5, 3 ); H_0.addEdge( 1, 0 ); H_0.addEdge( 2, 0 ); H_0.addEdge( 3, 0 ); H_0.addEdge( 3, 1 ); H_0.addEdge( 4, 1 ); H_0.addEdge( 1, 2 ); H_0.addEdge( 4, 2 ); BOOST_CHECK( G.bipGraph() == H_0 ); G = Gorg; BOOST_CHECK_EQUAL( G.elimVar( 1 ), v01 | v23 ); BOOST_CHECK_EQUAL( G.vars(), Gorg.vars() ); BOOST_CHECK_EQUAL( G.nrClusters(), 3 ); BOOST_CHECK_EQUAL( G.cluster(0), v34 ); BOOST_CHECK_EQUAL( G.cluster(1), v04 ); BOOST_CHECK_EQUAL( G.cluster(2), v02 | v3 ); BipartiteGraph H_1( 5, 3 ); H_1.addEdge( 3, 0 ); H_1.addEdge( 4, 0 ); H_1.addEdge( 0, 1 ); H_1.addEdge( 4, 1 ); H_1.addEdge( 0, 2 ); H_1.addEdge( 2, 2 ); H_1.addEdge( 3, 2 ); BOOST_CHECK( G.bipGraph() == H_1 ); G = Gorg; BOOST_CHECK_EQUAL( G.elimVar( 2 ), v123 ); BOOST_CHECK_EQUAL( G.vars(), Gorg.vars() ); BOOST_CHECK_EQUAL( G.nrClusters(), 4 ); BOOST_CHECK_EQUAL( G.cluster(0), v01 ); BOOST_CHECK_EQUAL( G.cluster(1), v34 ); BOOST_CHECK_EQUAL( G.cluster(2), v04 ); BOOST_CHECK_EQUAL( G.cluster(3), v13 ); BipartiteGraph H_2( 5, 4 ); H_2.addEdge( 0, 0 ); H_2.addEdge( 1, 0 ); H_2.addEdge( 3, 1 ); H_2.addEdge( 4, 1 ); H_2.addEdge( 0, 2 ); H_2.addEdge( 4, 2 ); H_2.addEdge( 1, 3 ); H_2.addEdge( 3, 3 ); BOOST_CHECK( G.bipGraph() == H_2 ); G = Gorg; BOOST_CHECK_EQUAL( G.elimVar( 3 ), v12 | v34 ); BOOST_CHECK_EQUAL( G.vars(), Gorg.vars() ); BOOST_CHECK_EQUAL( G.nrClusters(), 3 ); BOOST_CHECK_EQUAL( G.cluster(0), v01 ); BOOST_CHECK_EQUAL( G.cluster(1), v04 ); BOOST_CHECK_EQUAL( G.cluster(2), v12 | v4 ); BipartiteGraph H_3( 5, 3 ); H_3.addEdge( 0, 0 ); H_3.addEdge( 1, 0 ); H_3.addEdge( 0, 1 ); H_3.addEdge( 4, 1 ); H_3.addEdge( 1, 2 ); H_3.addEdge( 2, 2 ); H_3.addEdge( 4, 2 ); BOOST_CHECK( G.bipGraph() == H_3 ); G = Gorg; BOOST_CHECK_EQUAL( G.elimVar( 4 ), v03 | v4 ); BOOST_CHECK_EQUAL( G.vars(), Gorg.vars() ); BOOST_CHECK_EQUAL( G.nrClusters(), 3 ); BOOST_CHECK_EQUAL( G.cluster(0), v01 ); BOOST_CHECK_EQUAL( G.cluster(1), v123 ); BOOST_CHECK_EQUAL( G.cluster(2), v03 ); BipartiteGraph H_4( 5, 3 ); H_4.addEdge( 0, 0 ); H_4.addEdge( 1, 0 ); H_4.addEdge( 1, 1 ); H_4.addEdge( 2, 1 ); H_4.addEdge( 3, 1 ); H_4.addEdge( 0, 2 ); H_4.addEdge( 3, 2 ); BOOST_CHECK( G.bipGraph() == H_4 ); G = Gorg; BOOST_CHECK_EQUAL( eliminationCost_MinFill( G, 0 ), 1 ); BOOST_CHECK_EQUAL( eliminationCost_MinFill( G, 1 ), 2 ); BOOST_CHECK_EQUAL( eliminationCost_MinFill( G, 2 ), 0 ); BOOST_CHECK_EQUAL( eliminationCost_MinFill( G, 3 ), 2 ); BOOST_CHECK_EQUAL( eliminationCost_MinFill( G, 4 ), 1 ); cl.clear(); cl.push_back( v123 ); cl.push_back( v01 | v4 ); cl.push_back( v13 | v4 ); cl.push_back( v34 ); cl.push_back( v4 ); BOOST_CHECK_EQUAL( G.VarElim( greedyVariableElimination( eliminationCost_MinFill ) ).clusters(), cl ); G = Gorg; BOOST_CHECK_EQUAL( eliminationCost_WeightedMinFill( G, 0 ), 2*3 ); BOOST_CHECK_EQUAL( eliminationCost_WeightedMinFill( G, 1 ), 2*2+2*4 ); BOOST_CHECK_EQUAL( eliminationCost_WeightedMinFill( G, 2 ), 0 ); BOOST_CHECK_EQUAL( eliminationCost_WeightedMinFill( G, 3 ), 3*2+2*2 ); BOOST_CHECK_EQUAL( eliminationCost_WeightedMinFill( G, 4 ), 2*4 ); cl.clear(); cl.push_back( v123 ); cl.push_back( v01 | v4 ); cl.push_back( v13 | v4 ); cl.push_back( v34 ); cl.push_back( v4 ); BOOST_CHECK_EQUAL( G.VarElim( greedyVariableElimination( eliminationCost_WeightedMinFill ) ).clusters(), cl ); G = Gorg; BOOST_CHECK_EQUAL( eliminationCost_MinNeighbors( G, 0 ), 2 ); BOOST_CHECK_EQUAL( eliminationCost_MinNeighbors( G, 1 ), 3 ); BOOST_CHECK_EQUAL( eliminationCost_MinNeighbors( G, 2 ), 2 ); BOOST_CHECK_EQUAL( eliminationCost_MinNeighbors( G, 3 ), 3 ); BOOST_CHECK_EQUAL( eliminationCost_MinNeighbors( G, 4 ), 2 ); cl.clear(); cl.push_back( v01 | v4 ); cl.push_back( v123 ); cl.push_back( v13 | v4 ); cl.push_back( v34 ); cl.push_back( v4 ); BOOST_CHECK_EQUAL( G.VarElim( greedyVariableElimination( eliminationCost_MinNeighbors ) ).clusters(), cl ); G = Gorg; BOOST_CHECK_EQUAL( eliminationCost_MinWeight( G, 0 ), 3*2 ); BOOST_CHECK_EQUAL( eliminationCost_MinWeight( G, 1 ), 2*2*4 ); BOOST_CHECK_EQUAL( eliminationCost_MinWeight( G, 2 ), 3*4 ); BOOST_CHECK_EQUAL( eliminationCost_MinWeight( G, 3 ), 3*2*2 ); BOOST_CHECK_EQUAL( eliminationCost_MinWeight( G, 4 ), 2*4 ); cl.clear(); cl.push_back( v01 | v4 ); cl.push_back( v123 ); cl.push_back( v13 | v4 ); cl.push_back( v14 ); cl.push_back( v4 ); BOOST_CHECK_EQUAL( G.VarElim( greedyVariableElimination( eliminationCost_MinWeight ) ).clusters(), cl ); G = Gorg; std::vector vs; vs.push_back( v4 ); vs.push_back( v3 ); vs.push_back( v2 ); vs.push_back( v1 ); vs.push_back( v0 ); cl.clear(); cl.push_back( v03 | v4 ); cl.push_back( v01 | v23 ); cl.push_back( v01 | v2 ); cl.push_back( v01 ); cl.push_back( v0 ); BOOST_CHECK_EQUAL( G.VarElim( sequentialVariableElimination( vs ) ).clusters(), cl ); } BOOST_AUTO_TEST_CASE( IOTest ) { Var v0( 0, 2 ); Var v1( 1, 3 ); Var v2( 2, 2 ); Var v3( 3, 4 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v03( v0, v3 ); VarSet v12( v1, v2 ); VarSet v13( v1, v3 ); VarSet v23( v2, v3 ); std::vector cl; cl.push_back( v01 ); cl.push_back( v12 ); cl.push_back( v23 ); cl.push_back( v13 ); ClusterGraph G( cl ); std::stringstream ss; ss << G; std::string s; getline( ss, s ); BOOST_CHECK_EQUAL( s, "({x0, x1}, {x1, x2}, {x2, x3}, {x1, x3})" ); } libDAI-0.2.7/tests/unit/varset_test.cpp0000644000263000017630000007770611433220722016665 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; #define BOOST_TEST_MODULE VarSetTest #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { Var v1( 1, 2 ); Var v2( 2, 2 ); Var v3( 3, 2 ); Var v4( 4, 2 ); Var v5( 5, 2 ); // check constructors VarSet x; BOOST_CHECK( x.empty() ); BOOST_CHECK_EQUAL( x.size(), 0 ); BOOST_CHECK( !x.contains( v1 ) ); VarSet y( v1 ); BOOST_CHECK( !y.empty() ); BOOST_CHECK_EQUAL( y.size(), 1 ); BOOST_CHECK( !y.contains( v2 ) ); BOOST_CHECK( y.contains( v1 ) ); VarSet z( v1, v2 ); BOOST_CHECK_EQUAL( z.size(), 2 ); BOOST_CHECK( !z.contains( v3 ) ); BOOST_CHECK( z.contains( v1 ) ); BOOST_CHECK( z.contains( v2 ) ); VarSet v( v1, v1 ); BOOST_CHECK_EQUAL( v.size(), 1 ); BOOST_CHECK( v.contains( v1 ) ); BOOST_CHECK( !v.contains( v2 ) ); std::vector a; a.push_back( v1 ); a.push_back( v3 ); a.push_back( v4 ); a.push_back( v3 ); a.push_back( v2 ); VarSet w( a.begin(), a.end() ); BOOST_CHECK_EQUAL( w.size(), 4 ); BOOST_CHECK( w.contains( v1 ) ); BOOST_CHECK( w.contains( v2 ) ); BOOST_CHECK( w.contains( v3 ) ); BOOST_CHECK( w.contains( v4 ) ); BOOST_CHECK( !w.contains( v5 ) ); x = y; BOOST_CHECK( x == y ); } BOOST_AUTO_TEST_CASE( ComparisonTest ) { // check comparison operators Var v1( 1, 2 ); Var v2( 2, 2 ); Var v3( 3, 2 ); VarSet x, y; BOOST_CHECK( x == y ); BOOST_CHECK( !(x != y) ); VarSet z( v1 ); BOOST_CHECK( x != z ); BOOST_CHECK( !(x == z) ); BOOST_CHECK( x < z ); VarSet u( v2 ); BOOST_CHECK( x < u ); BOOST_CHECK( z < u ); BOOST_CHECK( !(u < z) ); VarSet v( v2, v1 ); BOOST_CHECK( x < v ); BOOST_CHECK( z < v ); BOOST_CHECK( !(v < z) ); BOOST_CHECK( v < u ); BOOST_CHECK( !(u < v) ); VarSet w( v1, v3 ); BOOST_CHECK( x < w ); BOOST_CHECK( v < w ); BOOST_CHECK( z < w ); BOOST_CHECK( w < u ); BOOST_CHECK( !(w < x) ); BOOST_CHECK( !(w < v) ); BOOST_CHECK( !(w < z) ); BOOST_CHECK( !(u < w) ); } BOOST_AUTO_TEST_CASE( IteratorTest ) { // check iterator interface std::vector v; Var v1( 1, 2 ); Var v2( 2, 2 ); Var v3( 3, 2 ); v.push_back( v3 ); v.push_back( v2 ); v.push_back( v2 ); v.push_back( v1 ); v.push_back( v3 ); VarSet x( v.begin(), v.end(), v.size() ); BOOST_CHECK( x.begin() != x.end() ); BOOST_CHECK( x.rbegin() != x.rend() ); BOOST_CHECK_EQUAL( x.front(), v1 ); BOOST_CHECK_EQUAL( x.back(), v3 ); VarSet::const_iterator j = x.begin(); VarSet::iterator k = x.begin(); for( size_t i = 1; i < 4; i++, j++, k++ ) { BOOST_CHECK_EQUAL( i, j->label() ); BOOST_CHECK_EQUAL( i, k->label() ); } BOOST_CHECK( j == x.end() ); BOOST_CHECK( k == x.end() ); VarSet::const_reverse_iterator rj = x.rbegin(); VarSet::reverse_iterator rk = x.rbegin(); for( size_t i = 3; i > 0; i--, rj++, rk++ ) { BOOST_CHECK_EQUAL( i, rj->label() ); BOOST_CHECK_EQUAL( i, rk->label() ); } BOOST_CHECK( rj == static_cast(x.rend()) ); BOOST_CHECK( rk == x.rend() ); } BOOST_AUTO_TEST_CASE( QueriesTest ) { Var v1( 1, 2 ); Var v2( 2, 2 ); Var v3( 3, 2 ); Var v4( 4, 2 ); // check queries VarSet x( v2, v1 ); VarSet y( v2, v3 ); VarSet z( v4, v3 ); BOOST_CHECK_EQUAL( x.nrStates(), 4 ); BOOST_CHECK_EQUAL( y.nrStates(), 4 ); BOOST_CHECK_EQUAL( z.nrStates(), 4 ); BOOST_CHECK( x.intersects( y ) ); BOOST_CHECK( !x.intersects( z ) ); BOOST_CHECK( y.intersects( x ) ); BOOST_CHECK( y.intersects( z ) ); BOOST_CHECK( !z.intersects( x ) ); BOOST_CHECK( z.intersects( y ) ); BOOST_CHECK( x.contains( v1 ) ); BOOST_CHECK( x.contains( v2 ) ); BOOST_CHECK( !x.contains( v3 ) ); BOOST_CHECK( !x.contains( v4 ) ); BOOST_CHECK( !y.contains( v1 ) ); BOOST_CHECK( y.contains( v2 ) ); BOOST_CHECK( y.contains( v3 ) ); BOOST_CHECK( !y.contains( v4 ) ); BOOST_CHECK( !z.contains( v1 ) ); BOOST_CHECK( !z.contains( v2 ) ); BOOST_CHECK( z.contains( v3 ) ); BOOST_CHECK( z.contains( v4 ) ); BOOST_CHECK_EQUAL( x.size(), 2 ); BOOST_CHECK( !x.empty() ); x.elements()[0] = v3; x.elements()[1] = v4; std::vector v; v.push_back( v3 ); v.push_back( v4 ); BOOST_CHECK( x.elements() == v ); } BOOST_AUTO_TEST_CASE( OperatorTest ) { Var v1( 1, 2 ); Var v2( 2, 2 ); Var v3( 3, 2 ); // check operators VarSet x; VarSet x1( v1 ); VarSet x2( v2 ); VarSet x3( v3 ); VarSet x12( v2, v1 ); VarSet x23( v2, v3 ); VarSet x13( v1, v3 ); VarSet x123 = x12 | v3; VarSet y; // check operator/ BOOST_CHECK_EQUAL( x / x, x ); BOOST_CHECK_EQUAL( x / x1, x ); BOOST_CHECK_EQUAL( x / x2, x ); BOOST_CHECK_EQUAL( x / x3, x ); BOOST_CHECK_EQUAL( x / x12, x ); BOOST_CHECK_EQUAL( x / x23, x ); BOOST_CHECK_EQUAL( x / x13, x ); BOOST_CHECK_EQUAL( x / x123, x ); BOOST_CHECK_EQUAL( x1 / x, x1 ); BOOST_CHECK_EQUAL( x1 / x1, x ); BOOST_CHECK_EQUAL( x1 / x2, x1 ); BOOST_CHECK_EQUAL( x1 / x3, x1 ); BOOST_CHECK_EQUAL( x1 / x12, x ); BOOST_CHECK_EQUAL( x1 / x23, x1 ); BOOST_CHECK_EQUAL( x1 / x13, x ); BOOST_CHECK_EQUAL( x1 / x123, x ); BOOST_CHECK_EQUAL( x2 / x, x2 ); BOOST_CHECK_EQUAL( x2 / x1, x2 ); BOOST_CHECK_EQUAL( x2 / x2, x ); BOOST_CHECK_EQUAL( x2 / x3, x2 ); BOOST_CHECK_EQUAL( x2 / x12, x ); BOOST_CHECK_EQUAL( x2 / x23, x ); BOOST_CHECK_EQUAL( x2 / x13, x2 ); BOOST_CHECK_EQUAL( x2 / x123, x ); BOOST_CHECK_EQUAL( x3 / x, x3 ); BOOST_CHECK_EQUAL( x3 / x1, x3 ); BOOST_CHECK_EQUAL( x3 / x2, x3 ); BOOST_CHECK_EQUAL( x3 / x3, x ); BOOST_CHECK_EQUAL( x3 / x12, x3 ); BOOST_CHECK_EQUAL( x3 / x23, x ); BOOST_CHECK_EQUAL( x3 / x13, x ); BOOST_CHECK_EQUAL( x3 / x123, x ); BOOST_CHECK_EQUAL( x12 / x, x12 ); BOOST_CHECK_EQUAL( x12 / x1, x2 ); BOOST_CHECK_EQUAL( x12 / x2, x1 ); BOOST_CHECK_EQUAL( x12 / x3, x12 ); BOOST_CHECK_EQUAL( x12 / x12, x ); BOOST_CHECK_EQUAL( x12 / x23, x1 ); BOOST_CHECK_EQUAL( x12 / x13, x2 ); BOOST_CHECK_EQUAL( x12 / x123, x ); BOOST_CHECK_EQUAL( x23 / x, x23 ); BOOST_CHECK_EQUAL( x23 / x1, x23 ); BOOST_CHECK_EQUAL( x23 / x2, x3 ); BOOST_CHECK_EQUAL( x23 / x3, x2 ); BOOST_CHECK_EQUAL( x23 / x12, x3 ); BOOST_CHECK_EQUAL( x23 / x23, x ); BOOST_CHECK_EQUAL( x23 / x13, x2 ); BOOST_CHECK_EQUAL( x23 / x123, x ); BOOST_CHECK_EQUAL( x13 / x, x13 ); BOOST_CHECK_EQUAL( x13 / x1, x3 ); BOOST_CHECK_EQUAL( x13 / x2, x13 ); BOOST_CHECK_EQUAL( x13 / x3, x1 ); BOOST_CHECK_EQUAL( x13 / x12, x3 ); BOOST_CHECK_EQUAL( x13 / x23, x1 ); BOOST_CHECK_EQUAL( x13 / x13, x ); BOOST_CHECK_EQUAL( x13 / x123, x ); BOOST_CHECK_EQUAL( x123 / x, x123 ); BOOST_CHECK_EQUAL( x123 / x1, x23 ); BOOST_CHECK_EQUAL( x123 / x2, x13 ); BOOST_CHECK_EQUAL( x123 / x3, x12 ); BOOST_CHECK_EQUAL( x123 / x12, x3 ); BOOST_CHECK_EQUAL( x123 / x23, x1 ); BOOST_CHECK_EQUAL( x123 / x13, x2 ); BOOST_CHECK_EQUAL( x123 / x123, x ); // check operator| BOOST_CHECK_EQUAL( x | x, x ); BOOST_CHECK_EQUAL( x | x1, x1 ); BOOST_CHECK_EQUAL( x | x2, x2 ); BOOST_CHECK_EQUAL( x | x3, x3 ); BOOST_CHECK_EQUAL( x | x12, x12 ); BOOST_CHECK_EQUAL( x | x23, x23 ); BOOST_CHECK_EQUAL( x | x13, x13 ); BOOST_CHECK_EQUAL( x | x123, x123 ); BOOST_CHECK_EQUAL( x1 | x, x1 ); BOOST_CHECK_EQUAL( x1 | x1, x1 ); BOOST_CHECK_EQUAL( x1 | x2, x12 ); BOOST_CHECK_EQUAL( x1 | x3, x13 ); BOOST_CHECK_EQUAL( x1 | x12, x12 ); BOOST_CHECK_EQUAL( x1 | x23, x123 ); BOOST_CHECK_EQUAL( x1 | x13, x13 ); BOOST_CHECK_EQUAL( x1 | x123, x123 ); BOOST_CHECK_EQUAL( x2 | x, x2 ); BOOST_CHECK_EQUAL( x2 | x1, x12 ); BOOST_CHECK_EQUAL( x2 | x2, x2 ); BOOST_CHECK_EQUAL( x2 | x3, x23 ); BOOST_CHECK_EQUAL( x2 | x12, x12 ); BOOST_CHECK_EQUAL( x2 | x23, x23 ); BOOST_CHECK_EQUAL( x2 | x13, x123 ); BOOST_CHECK_EQUAL( x2 | x123, x123 ); BOOST_CHECK_EQUAL( x3 | x, x3 ); BOOST_CHECK_EQUAL( x3 | x1, x13 ); BOOST_CHECK_EQUAL( x3 | x2, x23 ); BOOST_CHECK_EQUAL( x3 | x3, x3 ); BOOST_CHECK_EQUAL( x3 | x12, x123 ); BOOST_CHECK_EQUAL( x3 | x23, x23 ); BOOST_CHECK_EQUAL( x3 | x13, x13 ); BOOST_CHECK_EQUAL( x3 | x123, x123 ); BOOST_CHECK_EQUAL( x12 | x, x12 ); BOOST_CHECK_EQUAL( x12 | x1, x12 ); BOOST_CHECK_EQUAL( x12 | x2, x12 ); BOOST_CHECK_EQUAL( x12 | x3, x123 ); BOOST_CHECK_EQUAL( x12 | x12, x12 ); BOOST_CHECK_EQUAL( x12 | x23, x123 ); BOOST_CHECK_EQUAL( x12 | x13, x123 ); BOOST_CHECK_EQUAL( x12 | x123, x123 ); BOOST_CHECK_EQUAL( x23 | x, x23 ); BOOST_CHECK_EQUAL( x23 | x1, x123 ); BOOST_CHECK_EQUAL( x23 | x2, x23 ); BOOST_CHECK_EQUAL( x23 | x3, x23 ); BOOST_CHECK_EQUAL( x23 | x12, x123 ); BOOST_CHECK_EQUAL( x23 | x23, x23 ); BOOST_CHECK_EQUAL( x23 | x13, x123 ); BOOST_CHECK_EQUAL( x23 | x123, x123 ); BOOST_CHECK_EQUAL( x13 | x, x13 ); BOOST_CHECK_EQUAL( x13 | x1, x13 ); BOOST_CHECK_EQUAL( x13 | x2, x123 ); BOOST_CHECK_EQUAL( x13 | x3, x13 ); BOOST_CHECK_EQUAL( x13 | x12, x123 ); BOOST_CHECK_EQUAL( x13 | x23, x123 ); BOOST_CHECK_EQUAL( x13 | x13, x13 ); BOOST_CHECK_EQUAL( x13 | x123, x123 ); BOOST_CHECK_EQUAL( x123 | x, x123 ); BOOST_CHECK_EQUAL( x123 | x1, x123 ); BOOST_CHECK_EQUAL( x123 | x2, x123 ); BOOST_CHECK_EQUAL( x123 | x3, x123 ); BOOST_CHECK_EQUAL( x123 | x12, x123 ); BOOST_CHECK_EQUAL( x123 | x23, x123 ); BOOST_CHECK_EQUAL( x123 | x13, x123 ); BOOST_CHECK_EQUAL( x123 | x123, x123 ); // check operator& BOOST_CHECK_EQUAL( x & x, x ); BOOST_CHECK_EQUAL( x & x1, x ); BOOST_CHECK_EQUAL( x & x2, x ); BOOST_CHECK_EQUAL( x & x3, x ); BOOST_CHECK_EQUAL( x & x12, x ); BOOST_CHECK_EQUAL( x & x23, x ); BOOST_CHECK_EQUAL( x & x13, x ); BOOST_CHECK_EQUAL( x & x123, x ); BOOST_CHECK_EQUAL( x1 & x, x ); BOOST_CHECK_EQUAL( x1 & x1, x1 ); BOOST_CHECK_EQUAL( x1 & x2, x ); BOOST_CHECK_EQUAL( x1 & x3, x ); BOOST_CHECK_EQUAL( x1 & x12, x1 ); BOOST_CHECK_EQUAL( x1 & x23, x ); BOOST_CHECK_EQUAL( x1 & x13, x1 ); BOOST_CHECK_EQUAL( x1 & x123, x1 ); BOOST_CHECK_EQUAL( x2 & x, x ); BOOST_CHECK_EQUAL( x2 & x1, x ); BOOST_CHECK_EQUAL( x2 & x2, x2 ); BOOST_CHECK_EQUAL( x2 & x3, x ); BOOST_CHECK_EQUAL( x2 & x12, x2 ); BOOST_CHECK_EQUAL( x2 & x23, x2 ); BOOST_CHECK_EQUAL( x2 & x13, x ); BOOST_CHECK_EQUAL( x2 & x123, x2 ); BOOST_CHECK_EQUAL( x3 & x, x ); BOOST_CHECK_EQUAL( x3 & x1, x ); BOOST_CHECK_EQUAL( x3 & x2, x ); BOOST_CHECK_EQUAL( x3 & x3, x3 ); BOOST_CHECK_EQUAL( x3 & x12, x ); BOOST_CHECK_EQUAL( x3 & x23, x3 ); BOOST_CHECK_EQUAL( x3 & x13, x3 ); BOOST_CHECK_EQUAL( x3 & x123, x3 ); BOOST_CHECK_EQUAL( x12 & x, x ); BOOST_CHECK_EQUAL( x12 & x1, x1 ); BOOST_CHECK_EQUAL( x12 & x2, x2 ); BOOST_CHECK_EQUAL( x12 & x3, x ); BOOST_CHECK_EQUAL( x12 & x12, x12 ); BOOST_CHECK_EQUAL( x12 & x23, x2 ); BOOST_CHECK_EQUAL( x12 & x13, x1 ); BOOST_CHECK_EQUAL( x12 & x123, x12 ); BOOST_CHECK_EQUAL( x23 & x, x ); BOOST_CHECK_EQUAL( x23 & x1, x ); BOOST_CHECK_EQUAL( x23 & x2, x2 ); BOOST_CHECK_EQUAL( x23 & x3, x3 ); BOOST_CHECK_EQUAL( x23 & x12, x2 ); BOOST_CHECK_EQUAL( x23 & x23, x23 ); BOOST_CHECK_EQUAL( x23 & x13, x3 ); BOOST_CHECK_EQUAL( x23 & x123, x23 ); BOOST_CHECK_EQUAL( x13 & x, x ); BOOST_CHECK_EQUAL( x13 & x1, x1 ); BOOST_CHECK_EQUAL( x13 & x2, x ); BOOST_CHECK_EQUAL( x13 & x3, x3 ); BOOST_CHECK_EQUAL( x13 & x12, x1 ); BOOST_CHECK_EQUAL( x13 & x23, x3 ); BOOST_CHECK_EQUAL( x13 & x13, x13 ); BOOST_CHECK_EQUAL( x13 & x123, x13 ); BOOST_CHECK_EQUAL( x123 & x, x ); BOOST_CHECK_EQUAL( x123 & x1, x1 ); BOOST_CHECK_EQUAL( x123 & x2, x2 ); BOOST_CHECK_EQUAL( x123 & x3, x3 ); BOOST_CHECK_EQUAL( x123 & x12, x12 ); BOOST_CHECK_EQUAL( x123 & x23, x23 ); BOOST_CHECK_EQUAL( x123 & x13, x13 ); BOOST_CHECK_EQUAL( x123 & x123, x123 ); // check operator/= y = x ; y /= x; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x1; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x2; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x3; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x12; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x23; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x13; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= x; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= x1; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= x2; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= x3; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= x12; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= x23; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= x13; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= x; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= x1; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= x2; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= x3; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= x12; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= x23; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= x13; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y /= x; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= x1; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= x2; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= x3; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y /= x12; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= x23; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y /= x13; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y /= x; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y /= x1; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y /= x2; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y /= x3; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y /= x12; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y /= x23; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y /= x13; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x23 ; y /= x; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y /= x1; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y /= x2; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y /= x3; BOOST_CHECK_EQUAL( y, x2 ); y = x23 ; y /= x12; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y /= x23; BOOST_CHECK_EQUAL( y, x ); y = x23 ; y /= x13; BOOST_CHECK_EQUAL( y, x2 ); y = x23 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x13 ; y /= x; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y /= x1; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y /= x2; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y /= x3; BOOST_CHECK_EQUAL( y, x1 ); y = x13 ; y /= x12; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y /= x23; BOOST_CHECK_EQUAL( y, x1 ); y = x13 ; y /= x13; BOOST_CHECK_EQUAL( y, x ); y = x13 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x123; y /= x; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y /= x1; BOOST_CHECK_EQUAL( y, x23 ); y = x123; y /= x2; BOOST_CHECK_EQUAL( y, x13 ); y = x123; y /= x3; BOOST_CHECK_EQUAL( y, x12 ); y = x123; y /= x12; BOOST_CHECK_EQUAL( y, x3 ); y = x123; y /= x23; BOOST_CHECK_EQUAL( y, x1 ); y = x123; y /= x13; BOOST_CHECK_EQUAL( y, x2 ); y = x123; y /= x123; BOOST_CHECK_EQUAL( y, x ); // check operator|= y = x ; y |= x; BOOST_CHECK_EQUAL( y, x ); y = x ; y |= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x ; y |= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x ; y |= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x ; y |= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x ; y |= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x ; y |= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x1 ; y |= x; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y |= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y |= x2; BOOST_CHECK_EQUAL( y, x12 ); y = x1 ; y |= x3; BOOST_CHECK_EQUAL( y, x13 ); y = x1 ; y |= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x1 ; y |= x23; BOOST_CHECK_EQUAL( y, x123 ); y = x1 ; y |= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x1 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x2 ; y |= x; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y |= x1; BOOST_CHECK_EQUAL( y, x12 ); y = x2 ; y |= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y |= x3; BOOST_CHECK_EQUAL( y, x23 ); y = x2 ; y |= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x2 ; y |= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x2 ; y |= x13; BOOST_CHECK_EQUAL( y, x123 ); y = x2 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x3 ; y |= x; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y |= x1; BOOST_CHECK_EQUAL( y, x13 ); y = x3 ; y |= x2; BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y |= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y |= x12; BOOST_CHECK_EQUAL( y, x123 ); y = x3 ; y |= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y |= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x3 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x12 ; y |= x; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= x1; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= x2; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= x3; BOOST_CHECK_EQUAL( y, x123 ); y = x12 ; y |= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= x23; BOOST_CHECK_EQUAL( y, x123 ); y = x12 ; y |= x13; BOOST_CHECK_EQUAL( y, x123 ); y = x12 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= x; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= x1; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= x2; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= x3; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= x12; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= x13; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= x; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= x1; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= x2; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= x3; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= x12; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= x23; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x1; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x2; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x3; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x12; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x23; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x13; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); // check operator&= y = x ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x1; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x2; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x3; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x12; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x23; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x13; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x123; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y &= x2; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x3; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x12; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y &= x23; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x13; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y &= x123; BOOST_CHECK_EQUAL( y, x1 ); y = x2 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y &= x1; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y &= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y &= x3; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y &= x12; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y &= x23; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y &= x13; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y &= x123; BOOST_CHECK_EQUAL( y, x2 ); y = x3 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y &= x1; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y &= x2; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y &= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y &= x12; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y &= x23; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y &= x13; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y &= x123; BOOST_CHECK_EQUAL( y, x3 ); y = x12 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y &= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y &= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y &= x3; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y &= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y &= x23; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y &= x13; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y &= x123; BOOST_CHECK_EQUAL( y, x12 ); y = x23 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x23 ; y &= x1; BOOST_CHECK_EQUAL( y, x ); y = x23 ; y &= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x23 ; y &= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y &= x12; BOOST_CHECK_EQUAL( y, x2 ); y = x23 ; y &= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y &= x13; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y &= x123; BOOST_CHECK_EQUAL( y, x23 ); y = x13 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x13 ; y &= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x13 ; y &= x2; BOOST_CHECK_EQUAL( y, x ); y = x13 ; y &= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y &= x12; BOOST_CHECK_EQUAL( y, x1 ); y = x13 ; y &= x23; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y &= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y &= x123; BOOST_CHECK_EQUAL( y, x13 ); y = x123; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x123; y &= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x123; y &= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x123; y &= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x123; y &= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x123; y &= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x123; y &= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x123; y &= x123; BOOST_CHECK_EQUAL( y, x123 ); // check operator/= y = x ; y /= v1; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= v2; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= v3; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= v1; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= v2; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= v3; BOOST_CHECK_EQUAL( y, x1 ); y = x2 ; y /= v1; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= v2; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= v3; BOOST_CHECK_EQUAL( y, x2 ); y = x3 ; y /= v1; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= v2; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= v3; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y /= v1; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y /= v2; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y /= v3; BOOST_CHECK_EQUAL( y, x12 ); y = x13 ; y /= v1; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y /= v2; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y /= v3; BOOST_CHECK_EQUAL( y, x1 ); y = x23 ; y /= v1; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y /= v2; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y /= v3; BOOST_CHECK_EQUAL( y, x2 ); y = x123; y /= v1; BOOST_CHECK_EQUAL( y, x23 ); y = x123; y /= v2; BOOST_CHECK_EQUAL( y, x13 ); y = x123; y /= v3; BOOST_CHECK_EQUAL( y, x12 ); // check operator|= y = x ; y |= v1; BOOST_CHECK_EQUAL( y, x1 ); y = x ; y |= v2; BOOST_CHECK_EQUAL( y, x2 ); y = x ; y |= v3; BOOST_CHECK_EQUAL( y, x3 ); y = x1 ; y |= v1; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y |= v2; BOOST_CHECK_EQUAL( y, x12 ); y = x1 ; y |= v3; BOOST_CHECK_EQUAL( y, x13 ); y = x2 ; y |= v1; BOOST_CHECK_EQUAL( y, x12 ); y = x2 ; y |= v2; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y |= v3; BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y |= v1; BOOST_CHECK_EQUAL( y, x13 ); y = x3 ; y |= v2; BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y |= v3; BOOST_CHECK_EQUAL( y, x3 ); y = x12 ; y |= v1; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= v2; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= v3; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= v1; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= v2; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= v3; BOOST_CHECK_EQUAL( y, x13 ); y = x23 ; y |= v1; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= v2; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= v3; BOOST_CHECK_EQUAL( y, x23 ); y = x123; y |= v1; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= v2; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= v3; BOOST_CHECK_EQUAL( y, x123 ); // check operator<< BOOST_CHECK( (x << x ) ); BOOST_CHECK( (x << x1 ) ); BOOST_CHECK( (x << x2 ) ); BOOST_CHECK( (x << x3 ) ); BOOST_CHECK( (x << x12 ) ); BOOST_CHECK( (x << x13 ) ); BOOST_CHECK( (x << x23 ) ); BOOST_CHECK( (x << x123) ); BOOST_CHECK( !(x1 << x ) ); BOOST_CHECK( (x1 << x1 ) ); BOOST_CHECK( !(x1 << x2 ) ); BOOST_CHECK( !(x1 << x3 ) ); BOOST_CHECK( (x1 << x12 ) ); BOOST_CHECK( (x1 << x13 ) ); BOOST_CHECK( !(x1 << x23 ) ); BOOST_CHECK( (x1 << x123) ); BOOST_CHECK( !(x2 << x ) ); BOOST_CHECK( !(x2 << x1 ) ); BOOST_CHECK( (x2 << x2 ) ); BOOST_CHECK( !(x2 << x3 ) ); BOOST_CHECK( (x2 << x12 ) ); BOOST_CHECK( !(x2 << x13 ) ); BOOST_CHECK( (x2 << x23 ) ); BOOST_CHECK( (x2 << x123) ); BOOST_CHECK( !(x3 << x ) ); BOOST_CHECK( !(x3 << x1 ) ); BOOST_CHECK( !(x3 << x2 ) ); BOOST_CHECK( (x3 << x3 ) ); BOOST_CHECK( !(x3 << x12 ) ); BOOST_CHECK( (x3 << x13 ) ); BOOST_CHECK( (x3 << x23 ) ); BOOST_CHECK( (x3 << x123) ); BOOST_CHECK( !(x12 << x ) ); BOOST_CHECK( !(x12 << x1 ) ); BOOST_CHECK( !(x12 << x2 ) ); BOOST_CHECK( !(x12 << x3 ) ); BOOST_CHECK( (x12 << x12 ) ); BOOST_CHECK( !(x12 << x13 ) ); BOOST_CHECK( !(x12 << x23 ) ); BOOST_CHECK( (x12 << x123) ); BOOST_CHECK( !(x13 << x ) ); BOOST_CHECK( !(x13 << x1 ) ); BOOST_CHECK( !(x13 << x2 ) ); BOOST_CHECK( !(x13 << x3 ) ); BOOST_CHECK( !(x13 << x12 ) ); BOOST_CHECK( (x13 << x13 ) ); BOOST_CHECK( !(x13 << x23 ) ); BOOST_CHECK( (x13 << x123) ); BOOST_CHECK( !(x23 << x ) ); BOOST_CHECK( !(x23 << x1 ) ); BOOST_CHECK( !(x23 << x2 ) ); BOOST_CHECK( !(x23 << x3 ) ); BOOST_CHECK( !(x23 << x12 ) ); BOOST_CHECK( !(x23 << x13 ) ); BOOST_CHECK( (x23 << x23 ) ); BOOST_CHECK( (x23 << x123) ); BOOST_CHECK( !(x123 << x ) ); BOOST_CHECK( !(x123 << x1 ) ); BOOST_CHECK( !(x123 << x2 ) ); BOOST_CHECK( !(x123 << x3 ) ); BOOST_CHECK( !(x123 << x12 ) ); BOOST_CHECK( !(x123 << x13 ) ); BOOST_CHECK( !(x123 << x23 ) ); BOOST_CHECK( (x123 << x123) ); // check operator>> BOOST_CHECK( (x >> x ) ); BOOST_CHECK( !(x >> x1 ) ); BOOST_CHECK( !(x >> x2 ) ); BOOST_CHECK( !(x >> x3 ) ); BOOST_CHECK( !(x >> x12 ) ); BOOST_CHECK( !(x >> x13 ) ); BOOST_CHECK( !(x >> x23 ) ); BOOST_CHECK( !(x >> x123) ); BOOST_CHECK( (x1 >> x ) ); BOOST_CHECK( (x1 >> x1 ) ); BOOST_CHECK( !(x1 >> x2 ) ); BOOST_CHECK( !(x1 >> x3 ) ); BOOST_CHECK( !(x1 >> x12 ) ); BOOST_CHECK( !(x1 >> x13 ) ); BOOST_CHECK( !(x1 >> x23 ) ); BOOST_CHECK( !(x1 >> x123) ); BOOST_CHECK( (x2 >> x ) ); BOOST_CHECK( !(x2 >> x1 ) ); BOOST_CHECK( (x2 >> x2 ) ); BOOST_CHECK( !(x2 >> x3 ) ); BOOST_CHECK( !(x2 >> x12 ) ); BOOST_CHECK( !(x2 >> x13 ) ); BOOST_CHECK( !(x2 >> x23 ) ); BOOST_CHECK( !(x2 >> x123) ); BOOST_CHECK( (x3 >> x ) ); BOOST_CHECK( !(x3 >> x1 ) ); BOOST_CHECK( !(x3 >> x2 ) ); BOOST_CHECK( (x3 >> x3 ) ); BOOST_CHECK( !(x3 >> x12 ) ); BOOST_CHECK( !(x3 >> x13 ) ); BOOST_CHECK( !(x3 >> x23 ) ); BOOST_CHECK( !(x3 >> x123) ); BOOST_CHECK( (x12 >> x ) ); BOOST_CHECK( (x12 >> x1 ) ); BOOST_CHECK( (x12 >> x2 ) ); BOOST_CHECK( !(x12 >> x3 ) ); BOOST_CHECK( (x12 >> x12 ) ); BOOST_CHECK( !(x12 >> x13 ) ); BOOST_CHECK( !(x12 >> x23 ) ); BOOST_CHECK( !(x12 >> x123) ); BOOST_CHECK( (x13 >> x ) ); BOOST_CHECK( (x13 >> x1 ) ); BOOST_CHECK( !(x13 >> x2 ) ); BOOST_CHECK( (x13 >> x3 ) ); BOOST_CHECK( !(x13 >> x12 ) ); BOOST_CHECK( (x13 >> x13 ) ); BOOST_CHECK( !(x13 >> x23 ) ); BOOST_CHECK( !(x13 >> x123) ); BOOST_CHECK( (x23 >> x ) ); BOOST_CHECK( !(x23 >> x1 ) ); BOOST_CHECK( (x23 >> x2 ) ); BOOST_CHECK( (x23 >> x3 ) ); BOOST_CHECK( !(x23 >> x12 ) ); BOOST_CHECK( !(x23 >> x13 ) ); BOOST_CHECK( (x23 >> x23 ) ); BOOST_CHECK( !(x23 >> x123) ); BOOST_CHECK( (x123 >> x ) ); BOOST_CHECK( (x123 >> x1 ) ); BOOST_CHECK( (x123 >> x2 ) ); BOOST_CHECK( (x123 >> x3 ) ); BOOST_CHECK( (x123 >> x12 ) ); BOOST_CHECK( (x123 >> x13 ) ); BOOST_CHECK( (x123 >> x23 ) ); BOOST_CHECK( (x123 >> x123) ); } BOOST_AUTO_TEST_CASE( StreamTest ) { Var v1( 1, 2 ); Var v2( 2, 2 ); // check output VarSet x( v1, v2 ); std::stringstream ss; ss << x << std::endl; std::string s; std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "{x1, x2}" ); } BOOST_AUTO_TEST_CASE( StateTest ) { // check calcState and calcLinearState Var x0(0, 2); Var x1(1, 3); VarSet X(x0, x1); size_t s = 0; for( size_t s1 = 0; s1 < x1.states(); s1++ ) for( size_t s0 = 0; s0 < x0.states(); s0++ ) { std::map states; states[x0] = s0; states[x1] = s1; BOOST_CHECK_EQUAL( calcLinearState(X,states), s ); BOOST_CHECK_EQUAL( calcState(X, s), states ); s++; } for( s = 0; s < X.nrStates(); s++ ) BOOST_CHECK_EQUAL( calcLinearState(X, calcState(X,s)), s ); } libDAI-0.2.7/tests/unit/exceptions_test.cpp0000644000263000017630000000365211433220722017527 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include using namespace dai; #define BOOST_TEST_MODULE ExceptionsTest #include BOOST_AUTO_TEST_CASE( ExceptionsTest ) { BOOST_CHECK_THROW( DAI_THROW(NOT_IMPLEMENTED), Exception ); BOOST_CHECK_THROW( DAI_THROW(NOT_IMPLEMENTED), std::runtime_error ); BOOST_CHECK_THROW( DAI_THROWE(NOT_IMPLEMENTED,"Detailed error message"), Exception ); BOOST_CHECK_THROW( DAI_THROWE(NOT_IMPLEMENTED,"Detailed error messgae"), std::runtime_error ); BOOST_CHECK_THROW( DAI_ASSERT( 0 ), Exception ); BOOST_CHECK_THROW( DAI_ASSERT( 0 == 1 ), std::runtime_error ); try { DAI_THROW(NOT_IMPLEMENTED); } catch( Exception& e ) { BOOST_CHECK_EQUAL( e.code(), Exception::NOT_IMPLEMENTED ); BOOST_CHECK_EQUAL( e.message(e.code()), std::string("Feature not implemented") ); } try { DAI_THROWE(NOT_IMPLEMENTED,"Detailed error message"); } catch( Exception& e ) { BOOST_CHECK_EQUAL( e.code(), Exception::NOT_IMPLEMENTED ); BOOST_CHECK_EQUAL( e.message(e.code()), std::string("Feature not implemented") ); } try { DAI_THROW(NOT_IMPLEMENTED); } catch( std::runtime_error& e ) { BOOST_CHECK_EQUAL( e.what(), std::string("Feature not implemented [tests/unit/exceptions_test.cpp, line 47]") ); } try { DAI_THROWE(NOT_IMPLEMENTED,"Detailed error message"); } catch( std::runtime_error& e ) { BOOST_CHECK_EQUAL( e.what(), std::string("Feature not implemented [tests/unit/exceptions_test.cpp, line 53]") ); } } libDAI-0.2.7/tests/unit/var_test.cpp0000644000263000017630000000314211433220722016130 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include using namespace dai; #define BOOST_TEST_MODULE VarTest #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { // check constructors Var x; BOOST_CHECK_EQUAL( x.label(), 0 ); BOOST_CHECK_EQUAL( x.states(), 0 ); x = Var( 0, 2 ); BOOST_CHECK_EQUAL( x.label(), 0 ); BOOST_CHECK_EQUAL( x.states(), 2 ); } BOOST_AUTO_TEST_CASE( AccMutTest ) { // check states and labels mutators Var x; x.states() = 3; BOOST_CHECK_EQUAL( x.states(), 3 ); x.label() = 5; BOOST_CHECK_EQUAL( x.label(), 5 ); } BOOST_AUTO_TEST_CASE( ComparisonTest ) { // check comparison operators Var x( 5, 3 ); Var y( 6, 3 ); Var z( 5, 3 ); BOOST_CHECK( x < y ); BOOST_CHECK( !(x < z) ); BOOST_CHECK( y > x ); BOOST_CHECK( !(z > x) ); BOOST_CHECK( x <= y ); BOOST_CHECK( x <= z ); BOOST_CHECK( !(x >= y) ); BOOST_CHECK( x >= z ); BOOST_CHECK( !(x == y) ); BOOST_CHECK( x == z ); BOOST_CHECK( x != y ); BOOST_CHECK( !(x != z) ); } BOOST_AUTO_TEST_CASE( StreamTest ) { // check stream output Var x( 5, 3 ); std::stringstream ss; ss << x; std::string s; ss >> s; BOOST_CHECK_EQUAL( s, "x5" ); } libDAI-0.2.7/tests/unit/smallset_test.cpp0000644000263000017630000010343111433220722017166 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include using namespace dai; #define BOOST_TEST_MODULE SmallSetTest #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { // check constructors SmallSet x; BOOST_CHECK( x.empty() ); BOOST_CHECK_EQUAL( x.size(), 0 ); BOOST_CHECK( !x.contains( 5 ) ); SmallSet y( 1 ); BOOST_CHECK( !y.empty() ); BOOST_CHECK_EQUAL( y.size(), 1 ); BOOST_CHECK( !y.contains( 5 ) ); BOOST_CHECK( y.contains( 1 ) ); SmallSet u( 0, 1 ); BOOST_CHECK( !u.empty() ); BOOST_CHECK_EQUAL( u.size(), 2 ); BOOST_CHECK( !u.contains( 2 ) ); BOOST_CHECK( u.contains( 1 ) ); BOOST_CHECK( u.contains( 0 ) ); SmallSet z( 1.0, 2.0 ); BOOST_CHECK_EQUAL( z.size(), 2 ); BOOST_CHECK( !z.contains( 5.0 ) ); BOOST_CHECK( z.contains( 1.0 ) ); BOOST_CHECK( z.contains( 2.0 ) ); SmallSet v( 'a', 'a' ); BOOST_CHECK_EQUAL( v.size(), 1 ); BOOST_CHECK( v.contains( 'a' ) ); BOOST_CHECK( !v.contains( 'b' ) ); std::vector a; a.push_back( 1 ); a.push_back( 3 ); a.push_back( 4 ); a.push_back( 3 ); a.push_back( 2 ); SmallSet w( a.begin(), a.end(), a.size() ); BOOST_CHECK_EQUAL( w.size(), 4 ); BOOST_CHECK( w.contains( 1 ) ); BOOST_CHECK( w.contains( 2 ) ); BOOST_CHECK( w.contains( 3 ) ); BOOST_CHECK( w.contains( 4 ) ); BOOST_CHECK( !w.contains( 0 ) ); x = y; BOOST_CHECK( x == y ); } BOOST_AUTO_TEST_CASE( ComparisonTest ) { // check comparison operators SmallSet x, y; BOOST_CHECK( x == y ); BOOST_CHECK( !(x != y) ); SmallSet z( 1 ); BOOST_CHECK( x != z ); BOOST_CHECK( !(x == z) ); BOOST_CHECK( x < z ); SmallSet u( 2 ); BOOST_CHECK( x < u ); BOOST_CHECK( z < u ); BOOST_CHECK( !(u < z) ); SmallSet v( 2, 1 ); BOOST_CHECK( x < v ); BOOST_CHECK( z < v ); BOOST_CHECK( !(v < z) ); BOOST_CHECK( v < u ); BOOST_CHECK( !(u < v) ); SmallSet w( 1, 3 ); BOOST_CHECK( x < w ); BOOST_CHECK( v < w ); BOOST_CHECK( z < w ); BOOST_CHECK( w < u ); BOOST_CHECK( !(w < x) ); BOOST_CHECK( !(w < v) ); BOOST_CHECK( !(w < z) ); BOOST_CHECK( !(u < w) ); } BOOST_AUTO_TEST_CASE( IteratorTest ) { // check iterator interface std::vector v; v.push_back( 3 ); v.push_back( 2 ); v.push_back( 2 ); v.push_back( 1 ); v.push_back( 3 ); SmallSet x( v.begin(), v.end(), v.size() ); BOOST_CHECK( x.begin() != x.end() ); BOOST_CHECK( x.rbegin() != x.rend() ); BOOST_CHECK_EQUAL( x.front(), 1 ); BOOST_CHECK_EQUAL( x.back(), 3 ); SmallSet::const_iterator j = x.begin(); SmallSet::iterator k = x.begin(); for( size_t i = 1; i < 4; i++, j++, k++ ) { BOOST_CHECK_EQUAL( i, *j ); BOOST_CHECK_EQUAL( i, *k ); } BOOST_CHECK( j == x.end() ); BOOST_CHECK( k == x.end() ); SmallSet::const_reverse_iterator rj = x.rbegin(); SmallSet::reverse_iterator rk = x.rbegin(); for( size_t i = 3; i > 0; i--, rj++, rk++ ) { BOOST_CHECK_EQUAL( i, *rj ); BOOST_CHECK_EQUAL( i, *rk ); } BOOST_CHECK( rj == static_cast::const_reverse_iterator>(x.rend()) ); BOOST_CHECK( rk == x.rend() ); } BOOST_AUTO_TEST_CASE( QueriesTest ) { // check queries SmallSet x( 2, 1 ); SmallSet y( 2, 3 ); SmallSet z( 4, 3 ); BOOST_CHECK( x.intersects( y ) ); BOOST_CHECK( !x.intersects( z ) ); BOOST_CHECK( y.intersects( x ) ); BOOST_CHECK( y.intersects( z ) ); BOOST_CHECK( !z.intersects( x ) ); BOOST_CHECK( z.intersects( y ) ); BOOST_CHECK( x.contains( 1 ) ); BOOST_CHECK( x.contains( 2 ) ); BOOST_CHECK( !x.contains( 3 ) ); BOOST_CHECK( !x.contains( 4 ) ); BOOST_CHECK( !y.contains( 1 ) ); BOOST_CHECK( y.contains( 2 ) ); BOOST_CHECK( y.contains( 3 ) ); BOOST_CHECK( !y.contains( 4 ) ); BOOST_CHECK( !z.contains( 1 ) ); BOOST_CHECK( !z.contains( 2 ) ); BOOST_CHECK( z.contains( 3 ) ); BOOST_CHECK( z.contains( 4 ) ); BOOST_CHECK_EQUAL( x.size(), 2 ); BOOST_CHECK( !x.empty() ); x.elements()[0] = 3; x.elements()[1] = 4; std::vector v; v.push_back( 3 ); v.push_back( 4 ); BOOST_CHECK( x.elements() == v ); } BOOST_AUTO_TEST_CASE( OperatorTest ) { // check operators SmallSet x; SmallSet x1( 1 ); SmallSet x2( 2 ); SmallSet x3( 3 ); SmallSet x12( 2, 1 ); SmallSet x23( 2, 3 ); SmallSet x13( 1, 3 ); SmallSet x123 = x12 | 3; SmallSet y; // check operator/ BOOST_CHECK_EQUAL( x / x, x ); BOOST_CHECK_EQUAL( x / x1, x ); BOOST_CHECK_EQUAL( x / x2, x ); BOOST_CHECK_EQUAL( x / x3, x ); BOOST_CHECK_EQUAL( x / x12, x ); BOOST_CHECK_EQUAL( x / x23, x ); BOOST_CHECK_EQUAL( x / x13, x ); BOOST_CHECK_EQUAL( x / x123, x ); BOOST_CHECK_EQUAL( x1 / x, x1 ); BOOST_CHECK_EQUAL( x1 / x1, x ); BOOST_CHECK_EQUAL( x1 / x2, x1 ); BOOST_CHECK_EQUAL( x1 / x3, x1 ); BOOST_CHECK_EQUAL( x1 / x12, x ); BOOST_CHECK_EQUAL( x1 / x23, x1 ); BOOST_CHECK_EQUAL( x1 / x13, x ); BOOST_CHECK_EQUAL( x1 / x123, x ); BOOST_CHECK_EQUAL( x2 / x, x2 ); BOOST_CHECK_EQUAL( x2 / x1, x2 ); BOOST_CHECK_EQUAL( x2 / x2, x ); BOOST_CHECK_EQUAL( x2 / x3, x2 ); BOOST_CHECK_EQUAL( x2 / x12, x ); BOOST_CHECK_EQUAL( x2 / x23, x ); BOOST_CHECK_EQUAL( x2 / x13, x2 ); BOOST_CHECK_EQUAL( x2 / x123, x ); BOOST_CHECK_EQUAL( x3 / x, x3 ); BOOST_CHECK_EQUAL( x3 / x1, x3 ); BOOST_CHECK_EQUAL( x3 / x2, x3 ); BOOST_CHECK_EQUAL( x3 / x3, x ); BOOST_CHECK_EQUAL( x3 / x12, x3 ); BOOST_CHECK_EQUAL( x3 / x23, x ); BOOST_CHECK_EQUAL( x3 / x13, x ); BOOST_CHECK_EQUAL( x3 / x123, x ); BOOST_CHECK_EQUAL( x12 / x, x12 ); BOOST_CHECK_EQUAL( x12 / x1, x2 ); BOOST_CHECK_EQUAL( x12 / x2, x1 ); BOOST_CHECK_EQUAL( x12 / x3, x12 ); BOOST_CHECK_EQUAL( x12 / x12, x ); BOOST_CHECK_EQUAL( x12 / x23, x1 ); BOOST_CHECK_EQUAL( x12 / x13, x2 ); BOOST_CHECK_EQUAL( x12 / x123, x ); BOOST_CHECK_EQUAL( x23 / x, x23 ); BOOST_CHECK_EQUAL( x23 / x1, x23 ); BOOST_CHECK_EQUAL( x23 / x2, x3 ); BOOST_CHECK_EQUAL( x23 / x3, x2 ); BOOST_CHECK_EQUAL( x23 / x12, x3 ); BOOST_CHECK_EQUAL( x23 / x23, x ); BOOST_CHECK_EQUAL( x23 / x13, x2 ); BOOST_CHECK_EQUAL( x23 / x123, x ); BOOST_CHECK_EQUAL( x13 / x, x13 ); BOOST_CHECK_EQUAL( x13 / x1, x3 ); BOOST_CHECK_EQUAL( x13 / x2, x13 ); BOOST_CHECK_EQUAL( x13 / x3, x1 ); BOOST_CHECK_EQUAL( x13 / x12, x3 ); BOOST_CHECK_EQUAL( x13 / x23, x1 ); BOOST_CHECK_EQUAL( x13 / x13, x ); BOOST_CHECK_EQUAL( x13 / x123, x ); BOOST_CHECK_EQUAL( x123 / x, x123 ); BOOST_CHECK_EQUAL( x123 / x1, x23 ); BOOST_CHECK_EQUAL( x123 / x2, x13 ); BOOST_CHECK_EQUAL( x123 / x3, x12 ); BOOST_CHECK_EQUAL( x123 / x12, x3 ); BOOST_CHECK_EQUAL( x123 / x23, x1 ); BOOST_CHECK_EQUAL( x123 / x13, x2 ); BOOST_CHECK_EQUAL( x123 / x123, x ); // check operator| BOOST_CHECK_EQUAL( x | x, x ); BOOST_CHECK_EQUAL( x | x1, x1 ); BOOST_CHECK_EQUAL( x | x2, x2 ); BOOST_CHECK_EQUAL( x | x3, x3 ); BOOST_CHECK_EQUAL( x | x12, x12 ); BOOST_CHECK_EQUAL( x | x23, x23 ); BOOST_CHECK_EQUAL( x | x13, x13 ); BOOST_CHECK_EQUAL( x | x123, x123 ); BOOST_CHECK_EQUAL( x1 | x, x1 ); BOOST_CHECK_EQUAL( x1 | x1, x1 ); BOOST_CHECK_EQUAL( x1 | x2, x12 ); BOOST_CHECK_EQUAL( x1 | x3, x13 ); BOOST_CHECK_EQUAL( x1 | x12, x12 ); BOOST_CHECK_EQUAL( x1 | x23, x123 ); BOOST_CHECK_EQUAL( x1 | x13, x13 ); BOOST_CHECK_EQUAL( x1 | x123, x123 ); BOOST_CHECK_EQUAL( x2 | x, x2 ); BOOST_CHECK_EQUAL( x2 | x1, x12 ); BOOST_CHECK_EQUAL( x2 | x2, x2 ); BOOST_CHECK_EQUAL( x2 | x3, x23 ); BOOST_CHECK_EQUAL( x2 | x12, x12 ); BOOST_CHECK_EQUAL( x2 | x23, x23 ); BOOST_CHECK_EQUAL( x2 | x13, x123 ); BOOST_CHECK_EQUAL( x2 | x123, x123 ); BOOST_CHECK_EQUAL( x3 | x, x3 ); BOOST_CHECK_EQUAL( x3 | x1, x13 ); BOOST_CHECK_EQUAL( x3 | x2, x23 ); BOOST_CHECK_EQUAL( x3 | x3, x3 ); BOOST_CHECK_EQUAL( x3 | x12, x123 ); BOOST_CHECK_EQUAL( x3 | x23, x23 ); BOOST_CHECK_EQUAL( x3 | x13, x13 ); BOOST_CHECK_EQUAL( x3 | x123, x123 ); BOOST_CHECK_EQUAL( x12 | x, x12 ); BOOST_CHECK_EQUAL( x12 | x1, x12 ); BOOST_CHECK_EQUAL( x12 | x2, x12 ); BOOST_CHECK_EQUAL( x12 | x3, x123 ); BOOST_CHECK_EQUAL( x12 | x12, x12 ); BOOST_CHECK_EQUAL( x12 | x23, x123 ); BOOST_CHECK_EQUAL( x12 | x13, x123 ); BOOST_CHECK_EQUAL( x12 | x123, x123 ); BOOST_CHECK_EQUAL( x23 | x, x23 ); BOOST_CHECK_EQUAL( x23 | x1, x123 ); BOOST_CHECK_EQUAL( x23 | x2, x23 ); BOOST_CHECK_EQUAL( x23 | x3, x23 ); BOOST_CHECK_EQUAL( x23 | x12, x123 ); BOOST_CHECK_EQUAL( x23 | x23, x23 ); BOOST_CHECK_EQUAL( x23 | x13, x123 ); BOOST_CHECK_EQUAL( x23 | x123, x123 ); BOOST_CHECK_EQUAL( x13 | x, x13 ); BOOST_CHECK_EQUAL( x13 | x1, x13 ); BOOST_CHECK_EQUAL( x13 | x2, x123 ); BOOST_CHECK_EQUAL( x13 | x3, x13 ); BOOST_CHECK_EQUAL( x13 | x12, x123 ); BOOST_CHECK_EQUAL( x13 | x23, x123 ); BOOST_CHECK_EQUAL( x13 | x13, x13 ); BOOST_CHECK_EQUAL( x13 | x123, x123 ); BOOST_CHECK_EQUAL( x123 | x, x123 ); BOOST_CHECK_EQUAL( x123 | x1, x123 ); BOOST_CHECK_EQUAL( x123 | x2, x123 ); BOOST_CHECK_EQUAL( x123 | x3, x123 ); BOOST_CHECK_EQUAL( x123 | x12, x123 ); BOOST_CHECK_EQUAL( x123 | x23, x123 ); BOOST_CHECK_EQUAL( x123 | x13, x123 ); BOOST_CHECK_EQUAL( x123 | x123, x123 ); // check operator& BOOST_CHECK_EQUAL( x & x, x ); BOOST_CHECK_EQUAL( x & x1, x ); BOOST_CHECK_EQUAL( x & x2, x ); BOOST_CHECK_EQUAL( x & x3, x ); BOOST_CHECK_EQUAL( x & x12, x ); BOOST_CHECK_EQUAL( x & x23, x ); BOOST_CHECK_EQUAL( x & x13, x ); BOOST_CHECK_EQUAL( x & x123, x ); BOOST_CHECK_EQUAL( x1 & x, x ); BOOST_CHECK_EQUAL( x1 & x1, x1 ); BOOST_CHECK_EQUAL( x1 & x2, x ); BOOST_CHECK_EQUAL( x1 & x3, x ); BOOST_CHECK_EQUAL( x1 & x12, x1 ); BOOST_CHECK_EQUAL( x1 & x23, x ); BOOST_CHECK_EQUAL( x1 & x13, x1 ); BOOST_CHECK_EQUAL( x1 & x123, x1 ); BOOST_CHECK_EQUAL( x2 & x, x ); BOOST_CHECK_EQUAL( x2 & x1, x ); BOOST_CHECK_EQUAL( x2 & x2, x2 ); BOOST_CHECK_EQUAL( x2 & x3, x ); BOOST_CHECK_EQUAL( x2 & x12, x2 ); BOOST_CHECK_EQUAL( x2 & x23, x2 ); BOOST_CHECK_EQUAL( x2 & x13, x ); BOOST_CHECK_EQUAL( x2 & x123, x2 ); BOOST_CHECK_EQUAL( x3 & x, x ); BOOST_CHECK_EQUAL( x3 & x1, x ); BOOST_CHECK_EQUAL( x3 & x2, x ); BOOST_CHECK_EQUAL( x3 & x3, x3 ); BOOST_CHECK_EQUAL( x3 & x12, x ); BOOST_CHECK_EQUAL( x3 & x23, x3 ); BOOST_CHECK_EQUAL( x3 & x13, x3 ); BOOST_CHECK_EQUAL( x3 & x123, x3 ); BOOST_CHECK_EQUAL( x12 & x, x ); BOOST_CHECK_EQUAL( x12 & x1, x1 ); BOOST_CHECK_EQUAL( x12 & x2, x2 ); BOOST_CHECK_EQUAL( x12 & x3, x ); BOOST_CHECK_EQUAL( x12 & x12, x12 ); BOOST_CHECK_EQUAL( x12 & x23, x2 ); BOOST_CHECK_EQUAL( x12 & x13, x1 ); BOOST_CHECK_EQUAL( x12 & x123, x12 ); BOOST_CHECK_EQUAL( x23 & x, x ); BOOST_CHECK_EQUAL( x23 & x1, x ); BOOST_CHECK_EQUAL( x23 & x2, x2 ); BOOST_CHECK_EQUAL( x23 & x3, x3 ); BOOST_CHECK_EQUAL( x23 & x12, x2 ); BOOST_CHECK_EQUAL( x23 & x23, x23 ); BOOST_CHECK_EQUAL( x23 & x13, x3 ); BOOST_CHECK_EQUAL( x23 & x123, x23 ); BOOST_CHECK_EQUAL( x13 & x, x ); BOOST_CHECK_EQUAL( x13 & x1, x1 ); BOOST_CHECK_EQUAL( x13 & x2, x ); BOOST_CHECK_EQUAL( x13 & x3, x3 ); BOOST_CHECK_EQUAL( x13 & x12, x1 ); BOOST_CHECK_EQUAL( x13 & x23, x3 ); BOOST_CHECK_EQUAL( x13 & x13, x13 ); BOOST_CHECK_EQUAL( x13 & x123, x13 ); BOOST_CHECK_EQUAL( x123 & x, x ); BOOST_CHECK_EQUAL( x123 & x1, x1 ); BOOST_CHECK_EQUAL( x123 & x2, x2 ); BOOST_CHECK_EQUAL( x123 & x3, x3 ); BOOST_CHECK_EQUAL( x123 & x12, x12 ); BOOST_CHECK_EQUAL( x123 & x23, x23 ); BOOST_CHECK_EQUAL( x123 & x13, x13 ); BOOST_CHECK_EQUAL( x123 & x123, x123 ); // check operator/= y = x ; y /= x; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x1; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x2; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x3; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x12; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x23; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x13; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= x; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= x1; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= x2; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= x3; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= x12; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= x23; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= x13; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= x; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= x1; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= x2; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= x3; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= x12; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= x23; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= x13; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y /= x; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= x1; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= x2; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= x3; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y /= x12; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= x23; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y /= x13; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y /= x; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y /= x1; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y /= x2; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y /= x3; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y /= x12; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y /= x23; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y /= x13; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x23 ; y /= x; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y /= x1; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y /= x2; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y /= x3; BOOST_CHECK_EQUAL( y, x2 ); y = x23 ; y /= x12; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y /= x23; BOOST_CHECK_EQUAL( y, x ); y = x23 ; y /= x13; BOOST_CHECK_EQUAL( y, x2 ); y = x23 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x13 ; y /= x; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y /= x1; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y /= x2; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y /= x3; BOOST_CHECK_EQUAL( y, x1 ); y = x13 ; y /= x12; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y /= x23; BOOST_CHECK_EQUAL( y, x1 ); y = x13 ; y /= x13; BOOST_CHECK_EQUAL( y, x ); y = x13 ; y /= x123; BOOST_CHECK_EQUAL( y, x ); y = x123; y /= x; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y /= x1; BOOST_CHECK_EQUAL( y, x23 ); y = x123; y /= x2; BOOST_CHECK_EQUAL( y, x13 ); y = x123; y /= x3; BOOST_CHECK_EQUAL( y, x12 ); y = x123; y /= x12; BOOST_CHECK_EQUAL( y, x3 ); y = x123; y /= x23; BOOST_CHECK_EQUAL( y, x1 ); y = x123; y /= x13; BOOST_CHECK_EQUAL( y, x2 ); y = x123; y /= x123; BOOST_CHECK_EQUAL( y, x ); // check insert y = x ; y.insert( 1 ); BOOST_CHECK_EQUAL( y, x1 ); y = x ; y.insert( 2 ); BOOST_CHECK_EQUAL( y, x2 ); y = x ; y.insert( 3 ); BOOST_CHECK_EQUAL( y, x3 ); y = x1 ; y.insert( 1 ); BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y.insert( 2 ); BOOST_CHECK_EQUAL( y, x12 ); y = x1 ; y.insert( 3 ); BOOST_CHECK_EQUAL( y, x13 ); y = x2 ; y.insert( 1 ); BOOST_CHECK_EQUAL( y, x12 ); y = x2 ; y.insert( 2 ); BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y.insert( 3 ); BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y.insert( 1 ); BOOST_CHECK_EQUAL( y, x13 ); y = x3 ; y.insert( 2 ); BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y.insert( 3 ); BOOST_CHECK_EQUAL( y, x3 ); y = x12 ; y.insert( 1 ); BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y.insert( 2 ); BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y.insert( 3 ); BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y.insert( 1 ); BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y.insert( 2 ); BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y.insert( 3 ); BOOST_CHECK_EQUAL( y, x23 ); y = x13 ; y.insert( 1 ); BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y.insert( 2 ); BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y.insert( 3 ); BOOST_CHECK_EQUAL( y, x13 ); y = x123; y.insert( 1 ); BOOST_CHECK_EQUAL( y, x123 ); y = x123; y.insert( 2 ); BOOST_CHECK_EQUAL( y, x123 ); y = x123; y.insert( 3 ); BOOST_CHECK_EQUAL( y, x123 ); // check erase y = x ; y.erase( 1 ); BOOST_CHECK_EQUAL( y, x ); y = x ; y.erase( 2 ); BOOST_CHECK_EQUAL( y, x ); y = x ; y.erase( 3 ); BOOST_CHECK_EQUAL( y, x ); y = x1 ; y.erase( 1 ); BOOST_CHECK_EQUAL( y, x ); y = x1 ; y.erase( 2 ); BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y.erase( 3 ); BOOST_CHECK_EQUAL( y, x1 ); y = x2 ; y.erase( 1 ); BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y.erase( 2 ); BOOST_CHECK_EQUAL( y, x ); y = x2 ; y.erase( 3 ); BOOST_CHECK_EQUAL( y, x2 ); y = x3 ; y.erase( 1 ); BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y.erase( 2 ); BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y.erase( 3 ); BOOST_CHECK_EQUAL( y, x ); y = x12 ; y.erase( 1 ); BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y.erase( 2 ); BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y.erase( 3 ); BOOST_CHECK_EQUAL( y, x12 ); y = x13 ; y.erase( 1 ); BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y.erase( 2 ); BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y.erase( 3 ); BOOST_CHECK_EQUAL( y, x1 ); y = x23 ; y.erase( 1 ); BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y.erase( 2 ); BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y.erase( 3 ); BOOST_CHECK_EQUAL( y, x2 ); y = x123; y.erase( 1 ); BOOST_CHECK_EQUAL( y, x23 ); y = x123; y.erase( 2 ); BOOST_CHECK_EQUAL( y, x13 ); y = x123; y.erase( 3 ); BOOST_CHECK_EQUAL( y, x12 ); // check operator|= y = x ; y |= x; BOOST_CHECK_EQUAL( y, x ); y = x ; y |= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x ; y |= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x ; y |= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x ; y |= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x ; y |= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x ; y |= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x1 ; y |= x; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y |= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y |= x2; BOOST_CHECK_EQUAL( y, x12 ); y = x1 ; y |= x3; BOOST_CHECK_EQUAL( y, x13 ); y = x1 ; y |= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x1 ; y |= x23; BOOST_CHECK_EQUAL( y, x123 ); y = x1 ; y |= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x1 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x2 ; y |= x; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y |= x1; BOOST_CHECK_EQUAL( y, x12 ); y = x2 ; y |= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y |= x3; BOOST_CHECK_EQUAL( y, x23 ); y = x2 ; y |= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x2 ; y |= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x2 ; y |= x13; BOOST_CHECK_EQUAL( y, x123 ); y = x2 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x3 ; y |= x; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y |= x1; BOOST_CHECK_EQUAL( y, x13 ); y = x3 ; y |= x2; BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y |= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y |= x12; BOOST_CHECK_EQUAL( y, x123 ); y = x3 ; y |= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y |= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x3 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x12 ; y |= x; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= x1; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= x2; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= x3; BOOST_CHECK_EQUAL( y, x123 ); y = x12 ; y |= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= x23; BOOST_CHECK_EQUAL( y, x123 ); y = x12 ; y |= x13; BOOST_CHECK_EQUAL( y, x123 ); y = x12 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= x; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= x1; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= x2; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= x3; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= x12; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= x13; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= x; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= x1; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= x2; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= x3; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= x12; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= x23; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x1; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x2; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x3; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x12; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x23; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x13; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= x123; BOOST_CHECK_EQUAL( y, x123 ); // check operator&= y = x ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x1; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x2; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x3; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x12; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x23; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x13; BOOST_CHECK_EQUAL( y, x ); y = x ; y &= x123; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y &= x2; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x3; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x12; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y &= x23; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y &= x13; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y &= x123; BOOST_CHECK_EQUAL( y, x1 ); y = x2 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y &= x1; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y &= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y &= x3; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y &= x12; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y &= x23; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y &= x13; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y &= x123; BOOST_CHECK_EQUAL( y, x2 ); y = x3 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y &= x1; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y &= x2; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y &= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y &= x12; BOOST_CHECK_EQUAL( y, x ); y = x3 ; y &= x23; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y &= x13; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y &= x123; BOOST_CHECK_EQUAL( y, x3 ); y = x12 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y &= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y &= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y &= x3; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y &= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y &= x23; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y &= x13; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y &= x123; BOOST_CHECK_EQUAL( y, x12 ); y = x23 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x23 ; y &= x1; BOOST_CHECK_EQUAL( y, x ); y = x23 ; y &= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x23 ; y &= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y &= x12; BOOST_CHECK_EQUAL( y, x2 ); y = x23 ; y &= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y &= x13; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y &= x123; BOOST_CHECK_EQUAL( y, x23 ); y = x13 ; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x13 ; y &= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x13 ; y &= x2; BOOST_CHECK_EQUAL( y, x ); y = x13 ; y &= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y &= x12; BOOST_CHECK_EQUAL( y, x1 ); y = x13 ; y &= x23; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y &= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y &= x123; BOOST_CHECK_EQUAL( y, x13 ); y = x123; y &= x; BOOST_CHECK_EQUAL( y, x ); y = x123; y &= x1; BOOST_CHECK_EQUAL( y, x1 ); y = x123; y &= x2; BOOST_CHECK_EQUAL( y, x2 ); y = x123; y &= x3; BOOST_CHECK_EQUAL( y, x3 ); y = x123; y &= x12; BOOST_CHECK_EQUAL( y, x12 ); y = x123; y &= x23; BOOST_CHECK_EQUAL( y, x23 ); y = x123; y &= x13; BOOST_CHECK_EQUAL( y, x13 ); y = x123; y &= x123; BOOST_CHECK_EQUAL( y, x123 ); // check operator/= y = x ; y /= 1; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= 2; BOOST_CHECK_EQUAL( y, x ); y = x ; y /= 3; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= 1; BOOST_CHECK_EQUAL( y, x ); y = x1 ; y /= 2; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y /= 3; BOOST_CHECK_EQUAL( y, x1 ); y = x2 ; y /= 1; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y /= 2; BOOST_CHECK_EQUAL( y, x ); y = x2 ; y /= 3; BOOST_CHECK_EQUAL( y, x2 ); y = x3 ; y /= 1; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= 2; BOOST_CHECK_EQUAL( y, x3 ); y = x3 ; y /= 3; BOOST_CHECK_EQUAL( y, x ); y = x12 ; y /= 1; BOOST_CHECK_EQUAL( y, x2 ); y = x12 ; y /= 2; BOOST_CHECK_EQUAL( y, x1 ); y = x12 ; y /= 3; BOOST_CHECK_EQUAL( y, x12 ); y = x13 ; y /= 1; BOOST_CHECK_EQUAL( y, x3 ); y = x13 ; y /= 2; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y /= 3; BOOST_CHECK_EQUAL( y, x1 ); y = x23 ; y /= 1; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y /= 2; BOOST_CHECK_EQUAL( y, x3 ); y = x23 ; y /= 3; BOOST_CHECK_EQUAL( y, x2 ); y = x123; y /= 1; BOOST_CHECK_EQUAL( y, x23 ); y = x123; y /= 2; BOOST_CHECK_EQUAL( y, x13 ); y = x123; y /= 3; BOOST_CHECK_EQUAL( y, x12 ); // check operator|= y = x ; y |= 1; BOOST_CHECK_EQUAL( y, x1 ); y = x ; y |= 2; BOOST_CHECK_EQUAL( y, x2 ); y = x ; y |= 3; BOOST_CHECK_EQUAL( y, x3 ); y = x1 ; y |= 1; BOOST_CHECK_EQUAL( y, x1 ); y = x1 ; y |= 2; BOOST_CHECK_EQUAL( y, x12 ); y = x1 ; y |= 3; BOOST_CHECK_EQUAL( y, x13 ); y = x2 ; y |= 1; BOOST_CHECK_EQUAL( y, x12 ); y = x2 ; y |= 2; BOOST_CHECK_EQUAL( y, x2 ); y = x2 ; y |= 3; BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y |= 1; BOOST_CHECK_EQUAL( y, x13 ); y = x3 ; y |= 2; BOOST_CHECK_EQUAL( y, x23 ); y = x3 ; y |= 3; BOOST_CHECK_EQUAL( y, x3 ); y = x12 ; y |= 1; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= 2; BOOST_CHECK_EQUAL( y, x12 ); y = x12 ; y |= 3; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= 1; BOOST_CHECK_EQUAL( y, x13 ); y = x13 ; y |= 2; BOOST_CHECK_EQUAL( y, x123 ); y = x13 ; y |= 3; BOOST_CHECK_EQUAL( y, x13 ); y = x23 ; y |= 1; BOOST_CHECK_EQUAL( y, x123 ); y = x23 ; y |= 2; BOOST_CHECK_EQUAL( y, x23 ); y = x23 ; y |= 3; BOOST_CHECK_EQUAL( y, x23 ); y = x123; y |= 1; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= 2; BOOST_CHECK_EQUAL( y, x123 ); y = x123; y |= 3; BOOST_CHECK_EQUAL( y, x123 ); // check operator<< BOOST_CHECK( (x << x ) ); BOOST_CHECK( (x << x1 ) ); BOOST_CHECK( (x << x2 ) ); BOOST_CHECK( (x << x3 ) ); BOOST_CHECK( (x << x12 ) ); BOOST_CHECK( (x << x13 ) ); BOOST_CHECK( (x << x23 ) ); BOOST_CHECK( (x << x123) ); BOOST_CHECK( !(x1 << x ) ); BOOST_CHECK( (x1 << x1 ) ); BOOST_CHECK( !(x1 << x2 ) ); BOOST_CHECK( !(x1 << x3 ) ); BOOST_CHECK( (x1 << x12 ) ); BOOST_CHECK( (x1 << x13 ) ); BOOST_CHECK( !(x1 << x23 ) ); BOOST_CHECK( (x1 << x123) ); BOOST_CHECK( !(x2 << x ) ); BOOST_CHECK( !(x2 << x1 ) ); BOOST_CHECK( (x2 << x2 ) ); BOOST_CHECK( !(x2 << x3 ) ); BOOST_CHECK( (x2 << x12 ) ); BOOST_CHECK( !(x2 << x13 ) ); BOOST_CHECK( (x2 << x23 ) ); BOOST_CHECK( (x2 << x123) ); BOOST_CHECK( !(x3 << x ) ); BOOST_CHECK( !(x3 << x1 ) ); BOOST_CHECK( !(x3 << x2 ) ); BOOST_CHECK( (x3 << x3 ) ); BOOST_CHECK( !(x3 << x12 ) ); BOOST_CHECK( (x3 << x13 ) ); BOOST_CHECK( (x3 << x23 ) ); BOOST_CHECK( (x3 << x123) ); BOOST_CHECK( !(x12 << x ) ); BOOST_CHECK( !(x12 << x1 ) ); BOOST_CHECK( !(x12 << x2 ) ); BOOST_CHECK( !(x12 << x3 ) ); BOOST_CHECK( (x12 << x12 ) ); BOOST_CHECK( !(x12 << x13 ) ); BOOST_CHECK( !(x12 << x23 ) ); BOOST_CHECK( (x12 << x123) ); BOOST_CHECK( !(x13 << x ) ); BOOST_CHECK( !(x13 << x1 ) ); BOOST_CHECK( !(x13 << x2 ) ); BOOST_CHECK( !(x13 << x3 ) ); BOOST_CHECK( !(x13 << x12 ) ); BOOST_CHECK( (x13 << x13 ) ); BOOST_CHECK( !(x13 << x23 ) ); BOOST_CHECK( (x13 << x123) ); BOOST_CHECK( !(x23 << x ) ); BOOST_CHECK( !(x23 << x1 ) ); BOOST_CHECK( !(x23 << x2 ) ); BOOST_CHECK( !(x23 << x3 ) ); BOOST_CHECK( !(x23 << x12 ) ); BOOST_CHECK( !(x23 << x13 ) ); BOOST_CHECK( (x23 << x23 ) ); BOOST_CHECK( (x23 << x123) ); BOOST_CHECK( !(x123 << x ) ); BOOST_CHECK( !(x123 << x1 ) ); BOOST_CHECK( !(x123 << x2 ) ); BOOST_CHECK( !(x123 << x3 ) ); BOOST_CHECK( !(x123 << x12 ) ); BOOST_CHECK( !(x123 << x13 ) ); BOOST_CHECK( !(x123 << x23 ) ); BOOST_CHECK( (x123 << x123) ); // check operator>> BOOST_CHECK( (x >> x ) ); BOOST_CHECK( !(x >> x1 ) ); BOOST_CHECK( !(x >> x2 ) ); BOOST_CHECK( !(x >> x3 ) ); BOOST_CHECK( !(x >> x12 ) ); BOOST_CHECK( !(x >> x13 ) ); BOOST_CHECK( !(x >> x23 ) ); BOOST_CHECK( !(x >> x123) ); BOOST_CHECK( (x1 >> x ) ); BOOST_CHECK( (x1 >> x1 ) ); BOOST_CHECK( !(x1 >> x2 ) ); BOOST_CHECK( !(x1 >> x3 ) ); BOOST_CHECK( !(x1 >> x12 ) ); BOOST_CHECK( !(x1 >> x13 ) ); BOOST_CHECK( !(x1 >> x23 ) ); BOOST_CHECK( !(x1 >> x123) ); BOOST_CHECK( (x2 >> x ) ); BOOST_CHECK( !(x2 >> x1 ) ); BOOST_CHECK( (x2 >> x2 ) ); BOOST_CHECK( !(x2 >> x3 ) ); BOOST_CHECK( !(x2 >> x12 ) ); BOOST_CHECK( !(x2 >> x13 ) ); BOOST_CHECK( !(x2 >> x23 ) ); BOOST_CHECK( !(x2 >> x123) ); BOOST_CHECK( (x3 >> x ) ); BOOST_CHECK( !(x3 >> x1 ) ); BOOST_CHECK( !(x3 >> x2 ) ); BOOST_CHECK( (x3 >> x3 ) ); BOOST_CHECK( !(x3 >> x12 ) ); BOOST_CHECK( !(x3 >> x13 ) ); BOOST_CHECK( !(x3 >> x23 ) ); BOOST_CHECK( !(x3 >> x123) ); BOOST_CHECK( (x12 >> x ) ); BOOST_CHECK( (x12 >> x1 ) ); BOOST_CHECK( (x12 >> x2 ) ); BOOST_CHECK( !(x12 >> x3 ) ); BOOST_CHECK( (x12 >> x12 ) ); BOOST_CHECK( !(x12 >> x13 ) ); BOOST_CHECK( !(x12 >> x23 ) ); BOOST_CHECK( !(x12 >> x123) ); BOOST_CHECK( (x13 >> x ) ); BOOST_CHECK( (x13 >> x1 ) ); BOOST_CHECK( !(x13 >> x2 ) ); BOOST_CHECK( (x13 >> x3 ) ); BOOST_CHECK( !(x13 >> x12 ) ); BOOST_CHECK( (x13 >> x13 ) ); BOOST_CHECK( !(x13 >> x23 ) ); BOOST_CHECK( !(x13 >> x123) ); BOOST_CHECK( (x23 >> x ) ); BOOST_CHECK( !(x23 >> x1 ) ); BOOST_CHECK( (x23 >> x2 ) ); BOOST_CHECK( (x23 >> x3 ) ); BOOST_CHECK( !(x23 >> x12 ) ); BOOST_CHECK( !(x23 >> x13 ) ); BOOST_CHECK( (x23 >> x23 ) ); BOOST_CHECK( !(x23 >> x123) ); BOOST_CHECK( (x123 >> x ) ); BOOST_CHECK( (x123 >> x1 ) ); BOOST_CHECK( (x123 >> x2 ) ); BOOST_CHECK( (x123 >> x3 ) ); BOOST_CHECK( (x123 >> x12 ) ); BOOST_CHECK( (x123 >> x13 ) ); BOOST_CHECK( (x123 >> x23 ) ); BOOST_CHECK( (x123 >> x123) ); } libDAI-0.2.7/tests/unit/enum_test.cpp0000644000263000017630000000444311433220722016311 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include using namespace dai; #define BOOST_TEST_MODULE EnumTest #include DAI_ENUM(colors,RED,GREEN,BLUE); BOOST_AUTO_TEST_CASE( ConstructorsTest ) { colors c; BOOST_CHECK( c == colors::RED ); BOOST_CHECK_EQUAL( static_cast(c), 0 ); BOOST_CHECK_EQUAL( strcmp( static_cast(c), "RED" ), 0 ); colors d(colors::GREEN); BOOST_CHECK( d == colors::GREEN ); BOOST_CHECK_EQUAL( static_cast(d), 1 ); BOOST_CHECK_EQUAL( strcmp( static_cast(d), "GREEN" ), 0 ); colors e("BLUE"); BOOST_CHECK( e == colors::BLUE ); BOOST_CHECK_EQUAL( static_cast(e), 2 ); BOOST_CHECK_EQUAL( strcmp( static_cast(e), "BLUE" ), 0 ); BOOST_CHECK_THROW( colors f("BLUEISH"), Exception ); colors f = e; colors g(f); BOOST_CHECK( f == colors::BLUE ); BOOST_CHECK( g == colors::BLUE ); BOOST_CHECK( static_cast(f) == static_cast(e) ); BOOST_CHECK( static_cast(e) == static_cast(g) ); BOOST_CHECK( static_cast(f) == static_cast(g) ); } BOOST_AUTO_TEST_CASE( StreamTest ) { std::stringstream ss1, ss2, ss3, ss4, ss5, ss6, ss7; std::string s; ss1 << colors(colors::RED); ss1 >> s; BOOST_CHECK_EQUAL( s, "RED" ); ss2 << colors(colors::GREEN); std::getline( ss2, s ); BOOST_CHECK_EQUAL( s, "GREEN" ); ss3 << colors(colors::BLUE); ss3 >> s; BOOST_CHECK_EQUAL( s, "BLUE" ); colors c; ss4 << colors(colors::RED); ss4 >> c; BOOST_CHECK_EQUAL( c, colors::RED ); ss5 << colors(colors::GREEN); ss5 >> c; BOOST_CHECK_EQUAL( c, colors::GREEN ); ss6 << colors(colors::BLUE); ss6 >> c; BOOST_CHECK_EQUAL( c, colors::BLUE ); ss7 << "BLUEISH"; BOOST_CHECK_THROW( ss7 >> c, Exception ); } libDAI-0.2.7/tests/unit/weightedgraph_test.cpp0000644000263000017630000001253711433220722020172 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include using namespace dai; #define BOOST_TEST_MODULE WeighedGraphTest #include BOOST_AUTO_TEST_CASE( DEdgeTest ) { DEdge a; BOOST_CHECK_EQUAL( a.first, 0 ); BOOST_CHECK_EQUAL( a.second, 0 ); DEdge b( 3, 5 ); BOOST_CHECK_EQUAL( b.first, 3 ); BOOST_CHECK_EQUAL( b.second, 5 ); DEdge c( 5, 3 ); BOOST_CHECK_EQUAL( c.first, 5 ); BOOST_CHECK_EQUAL( c.second, 3 ); DEdge d( c ); DEdge e = c; DEdge f( 5, 4 ); DEdge g( 3, 6 ); BOOST_CHECK( !(a == b) ); BOOST_CHECK( !(a == c) ); BOOST_CHECK( !(b == c) ); BOOST_CHECK( d == c ); BOOST_CHECK( c == d ); BOOST_CHECK( e == c ); BOOST_CHECK( c == e ); BOOST_CHECK( d == e ); BOOST_CHECK( e == d ); BOOST_CHECK( a < b ); BOOST_CHECK( a < c ); BOOST_CHECK( b < c ); BOOST_CHECK( !(c < d) ); BOOST_CHECK( !(b < a) ); BOOST_CHECK( !(c < a) ); BOOST_CHECK( !(c < b) ); BOOST_CHECK( !(d < c) ); BOOST_CHECK( a < f ); BOOST_CHECK( b < f ); BOOST_CHECK( c < f ); BOOST_CHECK( g < f ); BOOST_CHECK( !(f < a) ); BOOST_CHECK( !(f < b) ); BOOST_CHECK( !(f < c) ); BOOST_CHECK( !(f < g) ); BOOST_CHECK( a < g ); BOOST_CHECK( b < g ); BOOST_CHECK( !(c < g) ); BOOST_CHECK( !(g < a) ); BOOST_CHECK( !(g < b) ); BOOST_CHECK( g < c ); std::stringstream ss; ss << c; std::string s; ss >> s; BOOST_CHECK_EQUAL( s, "(5->3)" ); } BOOST_AUTO_TEST_CASE( UEdgeTest ) { UEdge a; BOOST_CHECK_EQUAL( a.first, 0 ); BOOST_CHECK_EQUAL( a.second, 0 ); UEdge b( 3, 5 ); BOOST_CHECK_EQUAL( b.first, 3 ); BOOST_CHECK_EQUAL( b.second, 5 ); UEdge c( 5, 3 ); BOOST_CHECK_EQUAL( c.first, 5 ); BOOST_CHECK_EQUAL( c.second, 3 ); UEdge d( c ); UEdge e = c; UEdge f( 5, 4 ); UEdge g( 3, 6 ); UEdge h( DEdge( 5, 3 ) ); BOOST_CHECK_EQUAL( h.first, 5 ); BOOST_CHECK_EQUAL( h.second, 3 ); BOOST_CHECK( !(a == b) ); BOOST_CHECK( !(a == c) ); BOOST_CHECK( b == c ); BOOST_CHECK( d == c ); BOOST_CHECK( c == d ); BOOST_CHECK( e == c ); BOOST_CHECK( c == e ); BOOST_CHECK( d == e ); BOOST_CHECK( e == d ); BOOST_CHECK( a < b ); BOOST_CHECK( a < c ); BOOST_CHECK( !(b < c) ); BOOST_CHECK( !(c < d) ); BOOST_CHECK( !(b < a) ); BOOST_CHECK( !(c < a) ); BOOST_CHECK( !(c < b) ); BOOST_CHECK( !(d < c) ); BOOST_CHECK( a < f ); BOOST_CHECK( b < f ); BOOST_CHECK( c < f ); BOOST_CHECK( g < f ); BOOST_CHECK( !(f < a) ); BOOST_CHECK( !(f < b) ); BOOST_CHECK( !(f < c) ); BOOST_CHECK( !(f < g) ); BOOST_CHECK( a < g ); BOOST_CHECK( b < g ); BOOST_CHECK( c < g ); BOOST_CHECK( !(g < a) ); BOOST_CHECK( !(g < b) ); BOOST_CHECK( !(g < c) ); std::stringstream ss; std::string s; ss << c; ss >> s; BOOST_CHECK_EQUAL( s, "{3--5}" ); ss << b; ss >> s; BOOST_CHECK_EQUAL( s, "{3--5}" ); } BOOST_AUTO_TEST_CASE( RootedTreeTest ) { typedef UEdge E; std::vector edges; edges.push_back( E( 1, 2 ) ); edges.push_back( E( 2, 3 ) ); edges.push_back( E( 3, 1 ) ); GraphEL G( edges.begin(), edges.end() ); BOOST_CHECK_THROW( RootedTree T( G, 0 ), Exception ); BOOST_CHECK_THROW( RootedTree T( G, 1 ), Exception ); edges.back().second = 4; G = GraphEL( edges.begin(), edges.end() ); RootedTree T; T = RootedTree( G, 1 ); BOOST_CHECK_EQUAL( T.size(), 3 ); BOOST_CHECK_EQUAL( T[0], DEdge( 1, 2 ) ); BOOST_CHECK_EQUAL( T[1], DEdge( 2, 3 ) ); BOOST_CHECK_EQUAL( T[2], DEdge( 3, 4 ) ); edges.push_back( E(5, 6) ); G = GraphEL( edges.begin(), edges.end() ); BOOST_CHECK_THROW( RootedTree T( G, 1 ), Exception ); GraphAL H( 3 ); H.addEdge( 0, 1 ); H.addEdge( 1, 2 ); H.addEdge( 2, 1 ); G = GraphEL( H ); for( GraphEL::const_iterator e = G.begin(); e != G.end(); e++ ) BOOST_CHECK( H.hasEdge( e->first, e->second ) ); } BOOST_AUTO_TEST_CASE( SpanningTreeTest ) { RootedTree T; WeightedGraph G; G[UEdge(0,1)] = 1; G[UEdge(0,2)] = 2; G[UEdge(1,2)] = 3; G[UEdge(1,3)] = 4; G[UEdge(2,3)] = 5; RootedTree TMin; TMin.push_back( DEdge( 0,1 ) ); TMin.push_back( DEdge( 0,2 ) ); TMin.push_back( DEdge( 1,3 ) ); RootedTree TMax; TMax.push_back( DEdge( 0,2 ) ); TMax.push_back( DEdge( 2,3 ) ); TMax.push_back( DEdge( 3,1 ) ); T = MinSpanningTree( G, true ); BOOST_CHECK_EQUAL( T, TMin ); T = MinSpanningTree( G, false ); BOOST_CHECK_EQUAL( T, TMin ); T = MaxSpanningTree( G, true ); BOOST_CHECK_EQUAL( T, TMax ); T = MaxSpanningTree( G, false ); BOOST_CHECK_EQUAL( T, TMax ); WeightedGraph H; H[UEdge(1,2)] = 1; H[UEdge(1,3)] = 2; H[UEdge(2,3)] = 3; H[UEdge(2,4)] = 4; H[UEdge(3,4)] = 5; BOOST_CHECK_THROW( T = MinSpanningTree( H, true ), Exception ); } libDAI-0.2.7/tests/unit/alldai_test.cpp0000644000263000017630000001150711433220722016572 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; const double tol = 1e-8; #define BOOST_TEST_MODULE DAIAlgTest #include BOOST_AUTO_TEST_CASE( newInfAlgTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); Var v3( 3, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v03( v0, v3 ); VarSet v12( v1, v2 ); VarSet v13( v1, v3 ); VarSet v23( v2, v3 ); std::vector facs; facs.push_back( createFactorIsing( v0, v1, 1.0 ) ); facs.push_back( createFactorIsing( v1, v2, 1.0 ) ); facs.push_back( createFactorIsing( v2, v3, 1.0 ) ); facs.push_back( createFactorIsing( v3, v0, 1.0 ) ); facs.push_back( createFactorIsing( v0, -1.0 ) ); facs.push_back( createFactorIsing( v1, -1.0 ) ); facs.push_back( createFactorIsing( v2, -1.0 ) ); facs.push_back( createFactorIsing( v3, 1.0 ) ); Factor joint = facs[0] * facs[1] * facs[2] * facs[3] * facs[4] * facs[5] * facs[6] * facs[7]; FactorGraph fg( facs ); VarSet vs = v01; InfAlg* ia = newInfAlg( "EXACT", fg, PropertySet()("verbose",(size_t)0) ); ia->init(); ia->run(); BOOST_CHECK( dist( ia->belief( v01 ), joint.marginal( vs ), DISTTV ) < tol ); BOOST_CHECK( dist( calcMarginal( *ia, vs, true ), joint.marginal( vs ), DISTTV ) < tol ); delete ia; ia = newInfAlgFromString( "EXACT[verbose=0]", fg ); ia->init(); ia->run(); BOOST_CHECK( dist( ia->belief( v01 ), joint.marginal( vs ), DISTTV ) < tol ); BOOST_CHECK( dist( calcMarginal( *ia, vs, true ), joint.marginal( vs ), DISTTV ) < tol ); delete ia; std::map aliases; aliases["alias"] = "EXACT[verbose=1]"; ia = newInfAlgFromString( "alias[verbose=0]", fg, aliases ); ia->init(); ia->run(); BOOST_CHECK( dist( ia->belief( v01 ), joint.marginal( vs ), DISTTV ) < tol ); BOOST_CHECK( dist( calcMarginal( *ia, vs, true ), joint.marginal( vs ), DISTTV ) < tol ); delete ia; } BOOST_AUTO_TEST_CASE( parseTest ) { std::pair nameProps = parseNameProperties( "name" ); BOOST_CHECK_EQUAL( nameProps.first, "name" ); BOOST_CHECK_EQUAL( nameProps.second.size(), 0 ); nameProps = parseNameProperties( "name[]" ); BOOST_CHECK_EQUAL( nameProps.first, "name" ); BOOST_CHECK_EQUAL( nameProps.second.size(), 0 ); nameProps = parseNameProperties( "name[key1=value,key2=0.5]" ); BOOST_CHECK_EQUAL( nameProps.first, "name" ); BOOST_CHECK_EQUAL( nameProps.second.size(), 2 ); BOOST_CHECK( nameProps.second.hasKey( "key1" ) ); BOOST_CHECK( nameProps.second.hasKey( "key2" ) ); BOOST_CHECK_EQUAL( nameProps.second.getAs("key1"), "value" ); BOOST_CHECK_EQUAL( nameProps.second.getAs("key2"), "0.5" ); std::map aliases; aliases["alias"] = "name[key1=other]"; nameProps = parseNameProperties( "alias", aliases ); BOOST_CHECK_EQUAL( nameProps.first, "name" ); BOOST_CHECK_EQUAL( nameProps.second.size(), 1 ); BOOST_CHECK( nameProps.second.hasKey( "key1" ) ); BOOST_CHECK_EQUAL( nameProps.second.getAs("key1"), "other" ); nameProps = parseNameProperties( "alias[]", aliases ); BOOST_CHECK_EQUAL( nameProps.first, "name" ); BOOST_CHECK_EQUAL( nameProps.second.size(), 1 ); BOOST_CHECK( nameProps.second.hasKey( "key1" ) ); BOOST_CHECK_EQUAL( nameProps.second.getAs("key1"), "other" ); nameProps = parseNameProperties( "alias[key1=value,key2=0.5]", aliases ); BOOST_CHECK_EQUAL( nameProps.first, "name" ); BOOST_CHECK_EQUAL( nameProps.second.size(), 2 ); BOOST_CHECK( nameProps.second.hasKey( "key1" ) ); BOOST_CHECK( nameProps.second.hasKey( "key2" ) ); BOOST_CHECK_EQUAL( nameProps.second.getAs("key1"), "value" ); BOOST_CHECK_EQUAL( nameProps.second.getAs("key2"), "0.5" ); } BOOST_AUTO_TEST_CASE( readAliasFileTest ) { std::ofstream outfile; std::string filename( "alldai_test.aliases" ); outfile.open( filename.c_str() ); if( outfile.is_open() ) { outfile << "alias:\tname[key1=other]" << std::endl; outfile.close(); } else DAI_THROWE(CANNOT_WRITE_FILE,"Cannot write to file " + std::string(filename)); std::map aliases; aliases["alias"] = "name[key1=other]"; std::map aliases2 = readAliasesFile( filename ); BOOST_CHECK( aliases == aliases2 ); } libDAI-0.2.7/tests/unit/regiongraph_test.cpp0000644000263000017630000012065211433220722017653 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; const double tol = 1e-8; #define BOOST_TEST_MODULE RegionGraphTest #include #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); RegionGraph G; BOOST_CHECK_EQUAL( G.vars(), std::vector() ); BOOST_CHECK_EQUAL( G.factors(), std::vector() ); BOOST_CHECK( G.bipGraph() == BipartiteGraph() ); BOOST_CHECK( G.DAG() == BipartiteGraph() ); BOOST_CHECK_EQUAL( G.nrORs(), 0 ); BOOST_CHECK_EQUAL( G.nrIRs(), 0 ); std::vector facs; facs.push_back( Factor( v01 ) ); facs.push_back( Factor( v02 ) ); facs.push_back( Factor( v12 ) ); facs.push_back( Factor( v1 ) ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); BipartiteGraph dag( 3, 3 ); dag.addEdge( 0, 0 ); dag.addEdge( 0, 1 ); dag.addEdge( 1, 0 ); dag.addEdge( 1, 2 ); dag.addEdge( 2, 1 ); dag.addEdge( 2, 2 ); BipartiteGraph bipgraph( dag ); bipgraph.addNode2(); bipgraph.addEdge( 1, 3 ); FactorGraph fg(facs); RegionGraph G1( fg, fg.maximalFactorDomains() ); BOOST_CHECK_EQUAL( G1.vars(), vars ); BOOST_CHECK_EQUAL( G1.factors(), facs ); BOOST_CHECK( G1.bipGraph() == bipgraph ); BOOST_CHECK( G1.DAG() == dag ); BOOST_CHECK_EQUAL( G1.nrORs(), 3 ); BOOST_CHECK_EQUAL( G1.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G1.OR(0), facs[0] * facs[3] ); BOOST_CHECK_EQUAL( G1.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G1.OR(1), facs[1] ); BOOST_CHECK_EQUAL( G1.OR(2).c(), 1 ); BOOST_CHECK_EQUAL( G1.OR(2), facs[2] ); BOOST_CHECK_EQUAL( G1.nrIRs(), 3 ); BOOST_CHECK_EQUAL( G1.IR(0).c(), -1 ); BOOST_CHECK_EQUAL( G1.IR(0), v0 ); BOOST_CHECK_EQUAL( G1.IR(1).c(), -1 ); BOOST_CHECK_EQUAL( G1.IR(1), v1 ); BOOST_CHECK_EQUAL( G1.IR(2).c(), -1 ); BOOST_CHECK_EQUAL( G1.IR(2), v2 ); BOOST_CHECK_EQUAL( G1.fac2OR(0), 0 ); BOOST_CHECK_EQUAL( G1.fac2OR(1), 1 ); BOOST_CHECK_EQUAL( G1.fac2OR(2), 2 ); BOOST_CHECK_EQUAL( G1.fac2OR(3), 0 ); BOOST_CHECK( G1.checkCountingNumbers() ); std::vector ors; std::vector irs; ors.push_back( v01 | v2 ); irs.push_back( Region( v01, 0.0 ) ); irs.push_back( Region( v2, 0.0 ) ); typedef std::pair edge; std::vector edges; edges.push_back( edge( 0, 0 ) ); edges.push_back( edge( 0, 1 ) ); BipartiteGraph dag2( 1, 2, edges.begin(), edges.end() ); RegionGraph G2( fg, ors, irs, edges ); BOOST_CHECK_EQUAL( G2.vars(), vars ); BOOST_CHECK_EQUAL( G2.factors(), facs ); BOOST_CHECK( G2.bipGraph() == bipgraph ); BOOST_CHECK( G2.DAG() == dag2 ); BOOST_CHECK_EQUAL( G2.nrORs(), 1 ); BOOST_CHECK_EQUAL( G2.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G2.OR(0), facs[0] * facs[1] * facs[2] * facs[3] ); BOOST_CHECK_EQUAL( G2.nrIRs(), 2 ); BOOST_CHECK_EQUAL( G2.IR(0), irs[0] ); BOOST_CHECK_EQUAL( G2.IR(1), irs[1] ); BOOST_CHECK_EQUAL( G2.fac2OR(0), 0 ); BOOST_CHECK_EQUAL( G2.fac2OR(1), 0 ); BOOST_CHECK_EQUAL( G2.fac2OR(2), 0 ); BOOST_CHECK_EQUAL( G2.fac2OR(3), 0 ); BOOST_CHECK( G2.checkCountingNumbers() ); RegionGraph *G3 = G1.clone(); BOOST_CHECK_EQUAL( G3->vars(), G1.vars() ); BOOST_CHECK_EQUAL( G3->factors(), G1.factors() ); BOOST_CHECK( G3->bipGraph() == bipgraph ); BOOST_CHECK( G3->DAG() == dag ); BOOST_CHECK_EQUAL( G3->nrORs(), G1.nrORs() ); BOOST_CHECK_EQUAL( G3->OR(0), G1.OR(0) ); BOOST_CHECK_EQUAL( G3->OR(1), G1.OR(1) ); BOOST_CHECK_EQUAL( G3->OR(2), G1.OR(2) ); BOOST_CHECK_EQUAL( G3->nrIRs(), G1.nrIRs() ); BOOST_CHECK_EQUAL( G3->IR(0), G1.IR(0) ); BOOST_CHECK_EQUAL( G3->IR(1), G1.IR(1) ); BOOST_CHECK_EQUAL( G3->IR(2), G1.IR(2) ); BOOST_CHECK_EQUAL( G3->fac2OR(0), G1.fac2OR(0) ); BOOST_CHECK_EQUAL( G3->fac2OR(1), G1.fac2OR(1) ); BOOST_CHECK_EQUAL( G3->fac2OR(2), G1.fac2OR(2) ); BOOST_CHECK_EQUAL( G3->fac2OR(3), G1.fac2OR(3) ); BOOST_CHECK( G3->checkCountingNumbers() ); delete G3; RegionGraph G4 = G1; BOOST_CHECK_EQUAL( G4.vars(), G1.vars() ); BOOST_CHECK_EQUAL( G4.factors(), G1.factors() ); BOOST_CHECK( G4.bipGraph() == bipgraph ); BOOST_CHECK( G4.DAG() == dag ); BOOST_CHECK_EQUAL( G4.nrORs(), G1.nrORs() ); BOOST_CHECK_EQUAL( G4.OR(0), G1.OR(0) ); BOOST_CHECK_EQUAL( G4.OR(1), G1.OR(1) ); BOOST_CHECK_EQUAL( G4.OR(2), G1.OR(2) ); BOOST_CHECK_EQUAL( G4.nrIRs(), G1.nrIRs() ); BOOST_CHECK_EQUAL( G4.IR(0), G1.IR(0) ); BOOST_CHECK_EQUAL( G4.IR(1), G1.IR(1) ); BOOST_CHECK_EQUAL( G4.IR(2), G1.IR(2) ); BOOST_CHECK_EQUAL( G4.fac2OR(0), G1.fac2OR(0) ); BOOST_CHECK_EQUAL( G4.fac2OR(1), G1.fac2OR(1) ); BOOST_CHECK_EQUAL( G4.fac2OR(2), G1.fac2OR(2) ); BOOST_CHECK_EQUAL( G4.fac2OR(3), G1.fac2OR(3) ); BOOST_CHECK( G4.checkCountingNumbers() ); RegionGraph G5( G1 ); BOOST_CHECK_EQUAL( G5.vars(), G1.vars() ); BOOST_CHECK_EQUAL( G5.factors(), G1.factors() ); BOOST_CHECK( G5.bipGraph() == bipgraph ); BOOST_CHECK( G5.DAG() == dag ); BOOST_CHECK_EQUAL( G5.nrORs(), G1.nrORs() ); BOOST_CHECK_EQUAL( G5.OR(0), G1.OR(0) ); BOOST_CHECK_EQUAL( G5.OR(1), G1.OR(1) ); BOOST_CHECK_EQUAL( G5.OR(2), G1.OR(2) ); BOOST_CHECK_EQUAL( G5.nrIRs(), G1.nrIRs() ); BOOST_CHECK_EQUAL( G5.IR(0), G1.IR(0) ); BOOST_CHECK_EQUAL( G5.IR(1), G1.IR(1) ); BOOST_CHECK_EQUAL( G5.IR(2), G1.IR(2) ); BOOST_CHECK_EQUAL( G5.fac2OR(0), G1.fac2OR(0) ); BOOST_CHECK_EQUAL( G5.fac2OR(1), G1.fac2OR(1) ); BOOST_CHECK_EQUAL( G5.fac2OR(2), G1.fac2OR(2) ); BOOST_CHECK_EQUAL( G5.fac2OR(3), G1.fac2OR(3) ); BOOST_CHECK( G5.checkCountingNumbers() ); } BOOST_AUTO_TEST_CASE( AccMutTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); std::vector facs; facs.push_back( Factor( v01 ) ); facs.push_back( Factor( v02 ) ); facs.push_back( Factor( v12 ) ); facs.push_back( Factor( v1 ) ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); BipartiteGraph dag( 3, 3 ); dag.addEdge( 0, 0 ); dag.addEdge( 0, 1 ); dag.addEdge( 1, 0 ); dag.addEdge( 1, 2 ); dag.addEdge( 2, 1 ); dag.addEdge( 2, 2 ); BipartiteGraph bipgraph( dag ); bipgraph.addNode2(); bipgraph.addEdge( 1, 3 ); FactorGraph fg( facs ); RegionGraph G( fg, fg.maximalFactorDomains() ); BOOST_CHECK_EQUAL( G.var(0), v0 ); BOOST_CHECK_EQUAL( G.var(1), v1 ); BOOST_CHECK_EQUAL( G.var(2), v2 ); BOOST_CHECK_EQUAL( G.vars(), vars ); BOOST_CHECK_EQUAL( G.factor(0), facs[0] ); BOOST_CHECK_EQUAL( G.factor(1), facs[1] ); BOOST_CHECK_EQUAL( G.factor(2), facs[2] ); BOOST_CHECK_EQUAL( G.factor(3), facs[3] ); BOOST_CHECK_EQUAL( G.factors(), facs ); BOOST_CHECK( G.bipGraph() == bipgraph ); BOOST_CHECK_EQUAL( G.nbV(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nbV(0,0), 0 ); BOOST_CHECK_EQUAL( G.nbV(0,1), 1 ); BOOST_CHECK_EQUAL( G.nbV(1).size(), 3 ); BOOST_CHECK_EQUAL( G.nbV(1,0), 0 ); BOOST_CHECK_EQUAL( G.nbV(1,1), 2 ); BOOST_CHECK_EQUAL( G.nbV(1,2), 3 ); BOOST_CHECK_EQUAL( G.nbV(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nbV(2,0), 1 ); BOOST_CHECK_EQUAL( G.nbV(2,1), 2 ); BOOST_CHECK_EQUAL( G.nbF(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nbF(0,0), 0 ); BOOST_CHECK_EQUAL( G.nbF(0,1), 1 ); BOOST_CHECK_EQUAL( G.nbF(1).size(), 2 ); BOOST_CHECK_EQUAL( G.nbF(1,0), 0 ); BOOST_CHECK_EQUAL( G.nbF(1,1), 2 ); BOOST_CHECK_EQUAL( G.nbF(2).size(), 2 ); BOOST_CHECK_EQUAL( G.nbF(2,0), 1 ); BOOST_CHECK_EQUAL( G.nbF(2,1), 2 ); BOOST_CHECK_EQUAL( G.nbF(3).size(), 1 ); BOOST_CHECK_EQUAL( G.nbF(3,0), 1 ); BOOST_CHECK( G.DAG() == dag ); BOOST_CHECK_EQUAL( G.nrORs(), 3 ); BOOST_CHECK_EQUAL( G.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(0).vars(), v01 ); BOOST_CHECK_EQUAL( G.OR(0), facs[0] * facs[3] ); BOOST_CHECK_EQUAL( G.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(1).vars(), v02 ); BOOST_CHECK_EQUAL( G.OR(1), facs[1] ); BOOST_CHECK_EQUAL( G.OR(2).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(2).vars(), v12 ); BOOST_CHECK_EQUAL( G.OR(2), facs[2] ); BOOST_CHECK_EQUAL( G.nrIRs(), 3 ); BOOST_CHECK_EQUAL( G.IR(0).c(), -1 ); BOOST_CHECK_EQUAL( G.IR(0), v0 ); BOOST_CHECK_EQUAL( G.IR(1).c(), -1 ); BOOST_CHECK_EQUAL( G.IR(1), v1 ); BOOST_CHECK_EQUAL( G.IR(2).c(), -1 ); BOOST_CHECK_EQUAL( G.IR(2), v2 ); BOOST_CHECK_EQUAL( G.fac2OR(0), 0 ); BOOST_CHECK_EQUAL( G.fac2OR(1), 1 ); BOOST_CHECK_EQUAL( G.fac2OR(2), 2 ); BOOST_CHECK_EQUAL( G.fac2OR(3), 0 ); BOOST_CHECK_EQUAL( G.nbOR(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nbOR(0)[0], 0 ); BOOST_CHECK_EQUAL( G.nbOR(0)[1], 1 ); BOOST_CHECK_EQUAL( G.nbOR(1).size(), 2 ); BOOST_CHECK_EQUAL( G.nbOR(1)[0], 0 ); BOOST_CHECK_EQUAL( G.nbOR(1)[1], 2 ); BOOST_CHECK_EQUAL( G.nbOR(2).size(), 2 ); BOOST_CHECK_EQUAL( G.nbOR(2)[0], 1 ); BOOST_CHECK_EQUAL( G.nbOR(2)[1], 2 ); BOOST_CHECK_EQUAL( G.nbIR(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nbIR(0)[0], 0 ); BOOST_CHECK_EQUAL( G.nbIR(0)[1], 1 ); BOOST_CHECK_EQUAL( G.nbIR(1).size(), 2 ); BOOST_CHECK_EQUAL( G.nbIR(1)[0], 0 ); BOOST_CHECK_EQUAL( G.nbIR(1)[1], 2 ); BOOST_CHECK_EQUAL( G.nbIR(2).size(), 2 ); BOOST_CHECK_EQUAL( G.nbIR(2)[0], 1 ); BOOST_CHECK_EQUAL( G.nbIR(2)[1], 2 ); } BOOST_AUTO_TEST_CASE( QueriesTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; RegionGraph G0; BOOST_CHECK_EQUAL( G0.nrVars(), 0 ); BOOST_CHECK_EQUAL( G0.nrFactors(), 0 ); BOOST_CHECK_EQUAL( G0.nrEdges(), 0 ); BOOST_CHECK_THROW( G0.findVar( v0 ), Exception ); BOOST_CHECK_THROW( G0.findVars( v01 ), Exception ); BOOST_CHECK_THROW( G0.findFactor( v01 ), Exception ); #ifdef DAI_DBEUG BOOST_CHECK_THROW( G0.delta( 0 ), Exception ); BOOST_CHECK_THROW( G0.Delta( 0 ), Exception ); BOOST_CHECK_THROW( G0.delta( v0 ), Exception ); BOOST_CHECK_THROW( G0.Delta( v0 ), Exception ); BOOST_CHECK_THROW( G0.fac2OR( 0 ), Exception ); #endif BOOST_CHECK( G0.isConnected() ); BOOST_CHECK( G0.isTree() ); BOOST_CHECK( G0.isBinary() ); BOOST_CHECK( G0.isPairwise() ); BOOST_CHECK( G0.MarkovGraph() == GraphAL() ); BOOST_CHECK( G0.bipGraph() == BipartiteGraph() ); BOOST_CHECK_EQUAL( G0.maximalFactorDomains().size(), 1 ); BOOST_CHECK( G0.DAG() == BipartiteGraph() ); BOOST_CHECK( G0.checkCountingNumbers() ); BOOST_CHECK_EQUAL( G0.nrORs(), 0 ); BOOST_CHECK_EQUAL( G0.nrIRs(), 0 ); std::vector facs; facs.push_back( Factor( v01 ) ); facs.push_back( Factor( v12 ) ); facs.push_back( Factor( v1 ) ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); GraphAL H(3); H.addEdge( 0, 1 ); H.addEdge( 1, 2 ); BipartiteGraph K(3, 3); K.addEdge( 0, 0 ); K.addEdge( 1, 0 ); K.addEdge( 1, 1 ); K.addEdge( 2, 1 ); K.addEdge( 1, 2 ); BipartiteGraph dag(2, 1); dag.addEdge( 0, 0 ); dag.addEdge( 1, 0 ); FactorGraph fg( facs ); RegionGraph G1( fg, fg.maximalFactorDomains() ); BOOST_CHECK_EQUAL( G1.nrVars(), 3 ); BOOST_CHECK_EQUAL( G1.nrFactors(), 3 ); BOOST_CHECK_EQUAL( G1.nrEdges(), 5 ); BOOST_CHECK_EQUAL( G1.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G1.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G1.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G1.findVars( v01 ), SmallSet( 0, 1 ) ); BOOST_CHECK_EQUAL( G1.findVars( v02 ), SmallSet( 0, 2 ) ); BOOST_CHECK_EQUAL( G1.findVars( v12 ), SmallSet( 1, 2 ) ); BOOST_CHECK_EQUAL( G1.findFactor( v01 ), 0 ); BOOST_CHECK_EQUAL( G1.findFactor( v12 ), 1 ); BOOST_CHECK_EQUAL( G1.findFactor( v1 ), 2 ); BOOST_CHECK_THROW( G1.findFactor( v02 ), Exception ); BOOST_CHECK_EQUAL( G1.delta( 0 ), v1 ); BOOST_CHECK_EQUAL( G1.delta( 1 ), v02 ); BOOST_CHECK_EQUAL( G1.delta( 2 ), v1 ); BOOST_CHECK_EQUAL( G1.Delta( 0 ), v01 ); BOOST_CHECK_EQUAL( G1.Delta( 1 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( 2 ), v12 ); BOOST_CHECK_EQUAL( G1.delta( v0 ), v1 ); BOOST_CHECK_EQUAL( G1.delta( v1 ), v02 ); BOOST_CHECK_EQUAL( G1.delta( v2 ), v1 ); BOOST_CHECK_EQUAL( G1.delta( v01 ), v2 ); BOOST_CHECK_EQUAL( G1.delta( v02 ), v1 ); BOOST_CHECK_EQUAL( G1.delta( v12 ), v0 ); BOOST_CHECK_EQUAL( G1.delta( v012 ), VarSet() ); BOOST_CHECK_EQUAL( G1.Delta( v0 ), v01 ); BOOST_CHECK_EQUAL( G1.Delta( v1 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( v2 ), v12 ); BOOST_CHECK_EQUAL( G1.Delta( v01 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( v02 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( v12 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( v012 ), v012 ); BOOST_CHECK( G1.isConnected() ); BOOST_CHECK( G1.isTree() ); BOOST_CHECK( G1.isBinary() ); BOOST_CHECK( G1.isPairwise() ); BOOST_CHECK( G1.MarkovGraph() == H ); BOOST_CHECK( G1.bipGraph() == K ); BOOST_CHECK_EQUAL( G1.maximalFactorDomains().size(), 2 ); BOOST_CHECK_EQUAL( G1.maximalFactorDomains()[0], v01 ); BOOST_CHECK_EQUAL( G1.maximalFactorDomains()[1], v12 ); BOOST_CHECK( G1.DAG() == dag ); BOOST_CHECK( G1.checkCountingNumbers() ); BOOST_CHECK_EQUAL( G1.nrORs(), 2 ); BOOST_CHECK_EQUAL( G1.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G1.OR(0), facs[0] * facs[2] ); BOOST_CHECK_EQUAL( G1.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G1.OR(1), facs[1] ); BOOST_CHECK_EQUAL( G1.nrIRs(), 1 ); BOOST_CHECK_EQUAL( G1.IR(0).c(), -1 ); BOOST_CHECK_EQUAL( G1.IR(0), v1 ); BOOST_CHECK_EQUAL( G1.fac2OR(0), 0 ); BOOST_CHECK_EQUAL( G1.fac2OR(1), 1 ); BOOST_CHECK_EQUAL( G1.fac2OR(2), 0 ); facs.push_back( Factor( v02 ) ); H.addEdge( 0, 2 ); K.addNode2(); K.addEdge( 0, 3 ); K.addEdge( 2, 3 ); dag = BipartiteGraph( 3, 3 ); dag.addEdge( 0, 0 ); dag.addEdge( 0, 1 ); dag.addEdge( 1, 1 ); dag.addEdge( 1, 2 ); dag.addEdge( 2, 0 ); dag.addEdge( 2, 2 ); fg = FactorGraph( facs ); RegionGraph G2( fg, fg.maximalFactorDomains() ); BOOST_CHECK_EQUAL( G2.nrVars(), 3 ); BOOST_CHECK_EQUAL( G2.nrFactors(), 4 ); BOOST_CHECK_EQUAL( G2.nrEdges(), 7 ); BOOST_CHECK_EQUAL( G2.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G2.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G2.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G2.findVars( v01 ), SmallSet( 0, 1 ) ); BOOST_CHECK_EQUAL( G2.findVars( v02 ), SmallSet( 0, 2 ) ); BOOST_CHECK_EQUAL( G2.findVars( v12 ), SmallSet( 1, 2 ) ); BOOST_CHECK_EQUAL( G2.findFactor( v01 ), 0 ); BOOST_CHECK_EQUAL( G2.findFactor( v12 ), 1 ); BOOST_CHECK_EQUAL( G2.findFactor( v1 ), 2 ); BOOST_CHECK_EQUAL( G2.findFactor( v02 ), 3 ); BOOST_CHECK_EQUAL( G2.delta( 0 ), v12 ); BOOST_CHECK_EQUAL( G2.delta( 1 ), v02 ); BOOST_CHECK_EQUAL( G2.delta( 2 ), v01 ); BOOST_CHECK_EQUAL( G2.Delta( 0 ), v012 ); BOOST_CHECK_EQUAL( G2.Delta( 1 ), v012 ); BOOST_CHECK_EQUAL( G2.Delta( 2 ), v012 ); BOOST_CHECK( G2.isConnected() ); BOOST_CHECK( !G2.isTree() ); BOOST_CHECK( G2.isBinary() ); BOOST_CHECK( G2.isPairwise() ); BOOST_CHECK( G2.MarkovGraph() == H ); BOOST_CHECK( G2.bipGraph() == K ); BOOST_CHECK_EQUAL( G2.maximalFactorDomains().size(), 3 ); BOOST_CHECK_EQUAL( G2.maximalFactorDomains()[0], v01 ); BOOST_CHECK_EQUAL( G2.maximalFactorDomains()[1], v12 ); BOOST_CHECK_EQUAL( G2.maximalFactorDomains()[2], v02 ); BOOST_CHECK( G2.DAG() == dag ); BOOST_CHECK( G2.checkCountingNumbers() ); BOOST_CHECK_EQUAL( G2.nrORs(), 3 ); BOOST_CHECK_EQUAL( G2.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G2.OR(0), facs[0] * facs[2] ); BOOST_CHECK_EQUAL( G2.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G2.OR(1), facs[1] ); BOOST_CHECK_EQUAL( G2.OR(2).c(), 1 ); BOOST_CHECK_EQUAL( G2.OR(2), facs[3] ); BOOST_CHECK_EQUAL( G2.nrIRs(), 3 ); BOOST_CHECK_EQUAL( G2.IR(0).c(), -1.0 ); BOOST_CHECK_EQUAL( G2.IR(0), v0 ); BOOST_CHECK_EQUAL( G2.IR(1).c(), -1.0 ); BOOST_CHECK_EQUAL( G2.IR(1), v1 ); BOOST_CHECK_EQUAL( G2.IR(2).c(), -1.0 ); BOOST_CHECK_EQUAL( G2.IR(2), v2 ); BOOST_CHECK_EQUAL( G2.fac2OR(0), 0 ); BOOST_CHECK_EQUAL( G2.fac2OR(1), 1 ); BOOST_CHECK_EQUAL( G2.fac2OR(2), 0 ); BOOST_CHECK_EQUAL( G2.fac2OR(3), 2 ); Var v3( 3, 3 ); VarSet v03( v0, v3 ); VarSet v13( v1, v3 ); VarSet v23( v2, v3 ); VarSet v013 = v01 | v3; VarSet v023 = v02 | v3; VarSet v123 = v12 | v3; VarSet v0123 = v012 | v3; vars.push_back( v3 ); facs.push_back( Factor( v3 ) ); H.addNode(); K.addNode1(); K.addNode2(); K.addEdge( 3, 4 ); dag.addNode1(); fg = FactorGraph( facs ); RegionGraph G3( fg, fg.maximalFactorDomains() ); BOOST_CHECK_EQUAL( G3.nrVars(), 4 ); BOOST_CHECK_EQUAL( G3.nrFactors(), 5 ); BOOST_CHECK_EQUAL( G3.nrEdges(), 8 ); BOOST_CHECK_EQUAL( G3.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G3.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G3.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G3.findVar( v3 ), 3 ); BOOST_CHECK_EQUAL( G3.findVars( v01 ), SmallSet( 0, 1 ) ); BOOST_CHECK_EQUAL( G3.findVars( v02 ), SmallSet( 0, 2 ) ); BOOST_CHECK_EQUAL( G3.findVars( v12 ), SmallSet( 1, 2 ) ); BOOST_CHECK_EQUAL( G3.findFactor( v01 ), 0 ); BOOST_CHECK_EQUAL( G3.findFactor( v12 ), 1 ); BOOST_CHECK_EQUAL( G3.findFactor( v1 ), 2 ); BOOST_CHECK_EQUAL( G3.findFactor( v02 ), 3 ); BOOST_CHECK_EQUAL( G3.findFactor( v3 ), 4 ); BOOST_CHECK_THROW( G3.findFactor( v23 ), Exception ); BOOST_CHECK_EQUAL( G3.delta( 0 ), v12 ); BOOST_CHECK_EQUAL( G3.delta( 1 ), v02 ); BOOST_CHECK_EQUAL( G3.delta( 2 ), v01 ); BOOST_CHECK_EQUAL( G3.delta( 3 ), VarSet() ); BOOST_CHECK_EQUAL( G3.Delta( 0 ), v012 ); BOOST_CHECK_EQUAL( G3.Delta( 1 ), v012 ); BOOST_CHECK_EQUAL( G3.Delta( 2 ), v012 ); BOOST_CHECK_EQUAL( G3.Delta( 3 ), v3 ); BOOST_CHECK( !G3.isConnected() ); BOOST_CHECK( !G3.isTree() ); BOOST_CHECK( !G3.isBinary() ); BOOST_CHECK( G3.isPairwise() ); BOOST_CHECK( G3.MarkovGraph() == H ); BOOST_CHECK( G3.bipGraph() == K ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains().size(), 4 ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[0], v01 ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[1], v12 ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[2], v02 ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[3], v3 ); BOOST_CHECK( G3.DAG() == dag ); BOOST_CHECK( G3.checkCountingNumbers() ); BOOST_CHECK_EQUAL( G3.nrORs(), 4 ); BOOST_CHECK_EQUAL( G3.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G3.OR(0), facs[0] * facs[2] ); BOOST_CHECK_EQUAL( G3.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G3.OR(1), facs[1] ); BOOST_CHECK_EQUAL( G3.OR(2).c(), 1 ); BOOST_CHECK_EQUAL( G3.OR(2), facs[3] ); BOOST_CHECK_EQUAL( G3.OR(3).c(), 1 ); BOOST_CHECK_EQUAL( G3.OR(3), facs[4] ); BOOST_CHECK_EQUAL( G3.nrIRs(), 3 ); BOOST_CHECK_EQUAL( G3.IR(0).c(), -1.0 ); BOOST_CHECK_EQUAL( G3.IR(0), v0 ); BOOST_CHECK_EQUAL( G3.IR(1).c(), -1.0 ); BOOST_CHECK_EQUAL( G3.IR(1), v1 ); BOOST_CHECK_EQUAL( G3.IR(2).c(), -1.0 ); BOOST_CHECK_EQUAL( G3.IR(2), v2 ); BOOST_CHECK_EQUAL( G3.fac2OR(0), 0 ); BOOST_CHECK_EQUAL( G3.fac2OR(1), 1 ); BOOST_CHECK_EQUAL( G3.fac2OR(2), 0 ); BOOST_CHECK_EQUAL( G3.fac2OR(3), 2 ); BOOST_CHECK_EQUAL( G3.fac2OR(4), 3 ); facs.push_back( Factor( v123 ) ); H.addEdge( 1, 3 ); H.addEdge( 2, 3 ); K.addNode2(); K.addEdge( 1, 5 ); K.addEdge( 2, 5 ); K.addEdge( 3, 5 ); dag = BipartiteGraph( 3, 3 ); dag.addEdge( 0, 0 ); dag.addEdge( 0, 1 ); dag.addEdge( 1, 0 ); dag.addEdge( 1, 2 ); dag.addEdge( 2, 1 ); dag.addEdge( 2, 2 ); fg = FactorGraph( facs ); RegionGraph G4( fg, fg.maximalFactorDomains() ); BOOST_CHECK_EQUAL( G4.nrVars(), 4 ); BOOST_CHECK_EQUAL( G4.nrFactors(), 6 ); BOOST_CHECK_EQUAL( G4.nrEdges(), 11 ); BOOST_CHECK_EQUAL( G4.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G4.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G4.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G4.findVar( v3 ), 3 ); BOOST_CHECK_EQUAL( G4.findVars( v01 ), SmallSet( 0, 1 ) ); BOOST_CHECK_EQUAL( G4.findVars( v02 ), SmallSet( 0, 2 ) ); BOOST_CHECK_EQUAL( G4.findVars( v12 ), SmallSet( 1, 2 ) ); BOOST_CHECK_EQUAL( G4.findFactor( v01 ), 0 ); BOOST_CHECK_EQUAL( G4.findFactor( v12 ), 1 ); BOOST_CHECK_EQUAL( G4.findFactor( v1 ), 2 ); BOOST_CHECK_EQUAL( G4.findFactor( v02 ), 3 ); BOOST_CHECK_EQUAL( G4.findFactor( v3 ), 4 ); BOOST_CHECK_EQUAL( G4.findFactor( v123 ), 5 ); BOOST_CHECK_THROW( G4.findFactor( v23 ), Exception ); BOOST_CHECK_EQUAL( G4.delta( 0 ), v12 ); BOOST_CHECK_EQUAL( G4.delta( 1 ), v023 ); BOOST_CHECK_EQUAL( G4.delta( 2 ), v013 ); BOOST_CHECK_EQUAL( G4.delta( 3 ), v12 ); BOOST_CHECK_EQUAL( G4.Delta( 0 ), v012 ); BOOST_CHECK_EQUAL( G4.Delta( 1 ), v0123 ); BOOST_CHECK_EQUAL( G4.Delta( 2 ), v0123 ); BOOST_CHECK_EQUAL( G4.Delta( 3 ), v123 ); BOOST_CHECK( G4.isConnected() ); BOOST_CHECK( !G4.isTree() ); BOOST_CHECK( !G4.isBinary() ); BOOST_CHECK( !G4.isPairwise() ); BOOST_CHECK( G4.MarkovGraph() == H ); BOOST_CHECK( G4.bipGraph() == K ); BOOST_CHECK_EQUAL( G4.maximalFactorDomains().size(), 3 ); BOOST_CHECK_EQUAL( G4.maximalFactorDomains()[0], v01 ); BOOST_CHECK_EQUAL( G4.maximalFactorDomains()[1], v02 ); BOOST_CHECK_EQUAL( G4.maximalFactorDomains()[2], v123 ); BOOST_CHECK( G4.DAG() == dag ); BOOST_CHECK( G4.checkCountingNumbers() ); BOOST_CHECK_EQUAL( G4.nrORs(), 3 ); BOOST_CHECK_EQUAL( G4.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G4.OR(0), facs[0] * facs[2] ); BOOST_CHECK_EQUAL( G4.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G4.OR(1), facs[3] ); BOOST_CHECK_EQUAL( G4.OR(2).c(), 1 ); BOOST_CHECK_EQUAL( G4.OR(2), facs[1] * facs[4] * facs[5] ); BOOST_CHECK_EQUAL( G4.nrIRs(), 3 ); BOOST_CHECK_EQUAL( G4.IR(0).c(), -1.0 ); BOOST_CHECK_EQUAL( G4.IR(0), v0 ); BOOST_CHECK_EQUAL( G4.IR(1).c(), -1.0 ); BOOST_CHECK_EQUAL( G4.IR(1), v1 ); BOOST_CHECK_EQUAL( G4.IR(2).c(), -1.0 ); BOOST_CHECK_EQUAL( G4.IR(2), v2 ); BOOST_CHECK_EQUAL( G4.fac2OR(0), 0 ); BOOST_CHECK_EQUAL( G4.fac2OR(1), 2 ); BOOST_CHECK_EQUAL( G4.fac2OR(2), 0 ); BOOST_CHECK_EQUAL( G4.fac2OR(3), 1 ); BOOST_CHECK_EQUAL( G4.fac2OR(4), 2 ); BOOST_CHECK_EQUAL( G4.fac2OR(5), 2 ); } BOOST_AUTO_TEST_CASE( BackupRestoreTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; std::vector facs; facs.push_back( Factor( v01 ) ); facs.push_back( Factor( v12 ) ); facs.push_back( Factor( v1 ) ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); FactorGraph fg( facs ); RegionGraph G( fg, fg.maximalFactorDomains() ); RegionGraph Gorg( G ); BOOST_CHECK_EQUAL( G.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); BOOST_CHECK_THROW( G.setFactor( 0, Factor( v0 ), false ), Exception ); G.setFactor( 0, Factor( v01, 2.0 ), false ); BOOST_CHECK_EQUAL( G.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); BOOST_CHECK_THROW( G.restoreFactor( 0 ), Exception ); G.setFactor( 0, Factor( v01, 3.0 ), true ); BOOST_CHECK_EQUAL( G.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.restoreFactor( 0 ); BOOST_CHECK_EQUAL( G.factor( 0 )[0], 2.0 ); BOOST_CHECK_EQUAL( G.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.setFactor( 0, Gorg.factor( 0 ), false ); BOOST_CHECK_EQUAL( G.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.backupFactor( 0 ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); G.setFactor( 0, Factor( v01, 2.0 ), false ); BOOST_CHECK_EQUAL( G.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); BOOST_CHECK_EQUAL( G.factor( 0 )[0], 2.0 ); G.restoreFactor( 0 ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.OR(0).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1).c(), 1 ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); std::map fs; fs[0] = Factor( v01, 3.0 ); fs[2] = Factor( v1, 2.0 ); G.setFactors( fs, false ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.restoreFactors(); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G = Gorg; BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.setFactors( fs, true ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.restoreFactors(); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); std::set fsind; fsind.insert( 0 ); fsind.insert( 2 ); G.backupFactors( fsind ); G.setFactors( fs, false ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.restoreFactors(); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.backupFactors( v2 ); G.setFactor( 1, Factor(v12, 5.0) ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Factor(v12, 5.0) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.restoreFactors( v2 ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.backupFactors( v1 ); fs[1] = Factor( v12, 5.0 ); G.setFactors( fs, false ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(1), fs[1] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.restoreFactors(); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.setFactors( fs, true ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(1), fs[1] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); G.restoreFactors( v1 ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); BOOST_CHECK_EQUAL( G.OR(0), G.factor(0) * G.factor(2) ); BOOST_CHECK_EQUAL( G.OR(1), G.factor(1) ); } BOOST_AUTO_TEST_CASE( TransformationsTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; std::vector facs; facs.push_back( Factor( v01 ).randomize() ); facs.push_back( Factor( v12 ).randomize() ); facs.push_back( Factor( v1 ).randomize() ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); FactorGraph fg( facs ); RegionGraph G( fg, fg.maximalFactorDomains() ); FactorGraph Gsmall = G.maximalFactors(); BOOST_CHECK_EQUAL( Gsmall.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gsmall.nrFactors(), 2 ); BOOST_CHECK_EQUAL( Gsmall.factor( 0 ), G.factor( 0 ) * G.factor( 2 ) ); BOOST_CHECK_EQUAL( Gsmall.factor( 1 ), G.factor( 1 ) ); size_t i = 0; for( size_t x = 0; x < 2; x++ ) { FactorGraph Gcl = G.clamped( i, x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); BOOST_CHECK_EQUAL( Gcl.factor(0), createFactorDelta(vars[i], x) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(0).slice(vars[i], x) * G.factor(2) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(1) ); } i = 1; for( size_t x = 0; x < 2; x++ ) { FactorGraph Gcl = G.clamped( i, x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); BOOST_CHECK_EQUAL( Gcl.factor(0), createFactorDelta(vars[i], x) * G.factor(2).slice(vars[i],x) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(0).slice(vars[i], x) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(1).slice(vars[i], x) ); } i = 2; for( size_t x = 0; x < 2; x++ ) { FactorGraph Gcl = G.clamped( i, x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); BOOST_CHECK_EQUAL( Gcl.factor(0), createFactorDelta(vars[i], x) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(0) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(1).slice(vars[i], x) * G.factor(2) ); } } BOOST_AUTO_TEST_CASE( OperationsTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; std::vector facs; facs.push_back( Factor( v01 ).randomize() ); facs.push_back( Factor( v12 ).randomize() ); facs.push_back( Factor( v1 ).randomize() ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); FactorGraph fg( facs ); RegionGraph G( fg, fg.maximalFactorDomains() ); // clamp RegionGraph Gcl = G; for( size_t i = 0; i < 3; i++ ) for( size_t x = 0; x < 2; x++ ) { Gcl.clamp( i, x, true ); Factor delta = createFactorDelta( vars[i], x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); for( size_t j = 0; j < 3; j++ ) if( G.factor(j).vars().contains( vars[i] ) ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) * delta ); else BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); Gcl.restoreFactors(); for( size_t j = 0; j < 3; j++ ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); } // clampVar for( size_t i = 0; i < 3; i++ ) for( size_t x = 0; x < 2; x++ ) { Gcl.clampVar( i, std::vector(1, x), true ); Factor delta = createFactorDelta( vars[i], x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); for( size_t j = 0; j < 3; j++ ) if( G.factor(j).vars().contains( vars[i] ) ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) * delta ); else BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); Gcl.restoreFactors(); for( size_t j = 0; j < 3; j++ ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); } for( size_t i = 0; i < 3; i++ ) for( size_t x = 0; x < 2; x++ ) { Gcl.clampVar( i, std::vector(), true ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); for( size_t j = 0; j < 3; j++ ) if( G.factor(j).vars().contains( vars[i] ) ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) * 0.0 ); else BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); Gcl.restoreFactors(); for( size_t j = 0; j < 3; j++ ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); } std::vector both; both.push_back( 0 ); both.push_back( 1 ); for( size_t i = 0; i < 3; i++ ) for( size_t x = 0; x < 2; x++ ) { Gcl.clampVar( i, both, true ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); for( size_t j = 0; j < 3; j++ ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); Gcl.restoreFactors(); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); } // clampFactor for( size_t x = 0; x < 4; x++ ) { Gcl.clampFactor( 0, std::vector(1,x), true ); Factor mask( v01, 0.0 ); mask.set( x, 1.0 ); BOOST_CHECK_EQUAL( Gcl.factor(0), G.factor(0) * mask ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(1) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); Gcl.restoreFactor( 0 ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); } for( size_t x = 0; x < 4; x++ ) { Gcl.clampFactor( 1, std::vector(1,x), true ); Factor mask( v12, 0.0 ); mask.set( x, 1.0 ); BOOST_CHECK_EQUAL( Gcl.factor(0), G.factor(0) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(1) * mask ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); Gcl.restoreFactor( 1 ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); } for( size_t x = 0; x < 2; x++ ) { Gcl.clampFactor( 2, std::vector(1,x), true ); Factor mask( v1, 0.0 ); mask.set( x, 1.0 ); BOOST_CHECK_EQUAL( Gcl.factor(0), G.factor(0) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(1) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(2) * mask ); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); Gcl.restoreFactors(); BOOST_CHECK_EQUAL( Gcl.OR(0), Gcl.factor(0) * Gcl.factor(2) ); BOOST_CHECK_EQUAL( Gcl.OR(1), Gcl.factor(1) ); } // makeCavity RegionGraph Gcav( G ); Gcav.makeCavity( 0, true ); BOOST_CHECK_EQUAL( Gcav.factor(0), Factor( v01, 1.0 ) ); BOOST_CHECK_EQUAL( Gcav.factor(1), G.factor(1) ); BOOST_CHECK_EQUAL( Gcav.factor(2), G.factor(2) ); BOOST_CHECK_EQUAL( Gcav.OR(0), Gcav.factor(0) * Gcav.factor(2) ); BOOST_CHECK_EQUAL( Gcav.OR(1), Gcav.factor(1) ); Gcav.restoreFactors(); BOOST_CHECK_EQUAL( Gcav.OR(0), Gcav.factor(0) * Gcav.factor(2) ); BOOST_CHECK_EQUAL( Gcav.OR(1), Gcav.factor(1) ); Gcav.makeCavity( 1, true ); BOOST_CHECK_EQUAL( Gcav.factor(0), Factor( v01, 1.0 ) ); BOOST_CHECK_EQUAL( Gcav.factor(1), Factor( v12, 1.0 ) ); BOOST_CHECK_EQUAL( Gcav.factor(2), Factor( v1, 1.0 ) ); BOOST_CHECK_EQUAL( Gcav.OR(0), Gcav.factor(0) * Gcav.factor(2) ); BOOST_CHECK_EQUAL( Gcav.OR(1), Gcav.factor(1) ); Gcav.restoreFactors(); BOOST_CHECK_EQUAL( Gcav.OR(0), Gcav.factor(0) * Gcav.factor(2) ); BOOST_CHECK_EQUAL( Gcav.OR(1), Gcav.factor(1) ); Gcav.makeCavity( 2, true ); BOOST_CHECK_EQUAL( Gcav.factor(0), G.factor(0) ); BOOST_CHECK_EQUAL( Gcav.factor(1), Factor( v12, 1.0 ) ); BOOST_CHECK_EQUAL( Gcav.factor(2), G.factor(2) ); BOOST_CHECK_EQUAL( Gcav.OR(0), Gcav.factor(0) * Gcav.factor(2) ); BOOST_CHECK_EQUAL( Gcav.OR(1), Gcav.factor(1) ); Gcav.restoreFactors(); BOOST_CHECK_EQUAL( Gcav.OR(0), Gcav.factor(0) * Gcav.factor(2) ); BOOST_CHECK_EQUAL( Gcav.OR(1), Gcav.factor(1) ); } BOOST_AUTO_TEST_CASE( IOTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; std::vector facs; facs.push_back( Factor( v01, 1.0 ) ); facs.push_back( Factor( v12, 2.0 ) ); facs.push_back( Factor( v1, 3.0 ) ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); FactorGraph fg( facs ); RegionGraph G( fg, fg.maximalFactorDomains() ); BOOST_CHECK_THROW( G.WriteToFile( "regiongraph_test.fg" ), Exception ); BOOST_CHECK_THROW( G.ReadFromFile( "regiongraph_test.fg" ), Exception ); BOOST_CHECK_THROW( G.printDot( std::cout ), Exception ); std::stringstream ss; std::string s; ss << G; std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "digraph RegionGraph {" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=box];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ta0 [label=\"a0: {x0, x1}, c=1\"];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ta1 [label=\"a1: {x1, x2}, c=1\"];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=ellipse];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tb0 [label=\"b0: {x1}, c=-1\"];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ta0 -> b0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ta1 -> b0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "}" ); } libDAI-0.2.7/tests/unit/factor_test.cpp0000644000263000017630000010146511433220722016625 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include using namespace dai; const Real tol = 1e-8; #define BOOST_TEST_MODULE FactorTest #include #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { // check constructors Factor x1; BOOST_CHECK_EQUAL( x1.nrStates(), 1 ); BOOST_CHECK( x1.p() == Prob( 1, 1.0 ) ); BOOST_CHECK( x1.vars() == VarSet() ); Factor x2( 5.0 ); BOOST_CHECK_EQUAL( x2.nrStates(), 1 ); BOOST_CHECK( x2.p() == Prob( 1, 5.0 ) ); BOOST_CHECK( x2.vars() == VarSet() ); Var v1( 0, 3 ); Factor x3( v1 ); BOOST_CHECK_EQUAL( x3.nrStates(), 3 ); BOOST_CHECK_SMALL( dist( x3.p(), Prob( 3, 1.0 / 3.0 ), DISTL1 ), tol ); BOOST_CHECK( x3.vars() == VarSet( v1 ) ); BOOST_CHECK_CLOSE( x3[0], (Real)(1.0 / 3.0), tol ); BOOST_CHECK_CLOSE( x3[1], (Real)(1.0 / 3.0), tol ); BOOST_CHECK_CLOSE( x3[2], (Real)(1.0 / 3.0), tol ); Var v2( 1, 2 ); Factor x4( VarSet( v1, v2 ) ); BOOST_CHECK_EQUAL( x4.nrStates(), 6 ); BOOST_CHECK_SMALL( dist( x4.p(), Prob( 6, 1.0 / 6.0 ), DISTL1 ), tol ); BOOST_CHECK( x4.vars() == VarSet( v1, v2 ) ); for( size_t i = 0; i < 6; i++ ) BOOST_CHECK_CLOSE( x4[i], (Real)(1.0 / 6.0), tol ); Factor x5( VarSet( v1, v2 ), 1.0 ); BOOST_CHECK_EQUAL( x5.nrStates(), 6 ); BOOST_CHECK( x5.p() == Prob( 6, 1.0 ) ); BOOST_CHECK( x5.vars() == VarSet( v1, v2 ) ); for( size_t i = 0; i < 6; i++ ) BOOST_CHECK_EQUAL( x5[i], (Real)1.0 ); std::vector x( 6, 1.0 ); for( size_t i = 0; i < 6; i++ ) x[i] = 10.0 - i; Factor x6( VarSet( v1, v2 ), x ); BOOST_CHECK_EQUAL( x6.nrStates(), 6 ); BOOST_CHECK( x6.vars() == VarSet( v1, v2 ) ); for( size_t i = 0; i < 6; i++ ) BOOST_CHECK_EQUAL( x6[i], x[i] ); x.resize( 4 ); BOOST_CHECK_THROW( Factor x7( VarSet( v1, v2 ), x ), Exception ); x.resize( 6 ); x[4] = 10.0 - 4; x[5] = 10.0 - 5; Factor x8( VarSet( v2, v1 ), &(x[0]) ); BOOST_CHECK_EQUAL( x8.nrStates(), 6 ); BOOST_CHECK( x8.vars() == VarSet( v1, v2 ) ); for( size_t i = 0; i < 6; i++ ) BOOST_CHECK_EQUAL( x8[i], x[i] ); Prob xx( x ); Factor x9( VarSet( v2, v1 ), xx ); BOOST_CHECK_EQUAL( x9.nrStates(), 6 ); BOOST_CHECK( x9.vars() == VarSet( v1, v2 ) ); for( size_t i = 0; i < 6; i++ ) BOOST_CHECK_EQUAL( x9[i], x[i] ); xx.resize( 4 ); BOOST_CHECK_THROW( Factor x10( VarSet( v2, v1 ), xx ), Exception ); std::vector w; w.push_back( 0.1 ); w.push_back( 3.5 ); w.push_back( 2.8 ); w.push_back( 6.3 ); w.push_back( 8.4 ); w.push_back( 0.0 ); w.push_back( 7.4 ); w.push_back( 2.4 ); w.push_back( 8.9 ); w.push_back( 1.3 ); w.push_back( 1.6 ); w.push_back( 2.6 ); Var v4( 4, 3 ); Var v8( 8, 2 ); Var v7( 7, 2 ); std::vector vars; vars.push_back( v4 ); vars.push_back( v8 ); vars.push_back( v7 ); Factor x11( vars, w ); BOOST_CHECK_EQUAL( x11.nrStates(), 12 ); BOOST_CHECK( x11.vars() == VarSet( vars.begin(), vars.end() ) ); BOOST_CHECK_EQUAL( x11[0], (Real)0.1 ); BOOST_CHECK_EQUAL( x11[1], (Real)3.5 ); BOOST_CHECK_EQUAL( x11[2], (Real)2.8 ); BOOST_CHECK_EQUAL( x11[3], (Real)7.4 ); BOOST_CHECK_EQUAL( x11[4], (Real)2.4 ); BOOST_CHECK_EQUAL( x11[5], (Real)8.9 ); BOOST_CHECK_EQUAL( x11[6], (Real)6.3 ); BOOST_CHECK_EQUAL( x11[7], (Real)8.4 ); BOOST_CHECK_EQUAL( x11[8], (Real)0.0 ); BOOST_CHECK_EQUAL( x11[9], (Real)1.3 ); BOOST_CHECK_EQUAL( x11[10], (Real)1.6 ); BOOST_CHECK_EQUAL( x11[11], (Real)2.6 ); Factor x12( x11 ); BOOST_CHECK( x12 == x11 ); Factor x13 = x12; BOOST_CHECK( x13 == x11 ); } BOOST_AUTO_TEST_CASE( QueriesTest ) { Factor x( Var( 5, 5 ), 0.0 ); for( size_t i = 0; i < x.nrStates(); i++ ) x.set( i, 2.0 - i ); // test min, max, sum, sumAbs, maxAbs BOOST_CHECK_CLOSE( x.sum(), (Real)0.0, tol ); BOOST_CHECK_CLOSE( x.max(), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.min(), (Real)-2.0, tol ); BOOST_CHECK_CLOSE( x.sumAbs(), (Real)6.0, tol ); BOOST_CHECK_CLOSE( x.maxAbs(), (Real)2.0, tol ); x.set( 1, 1.0 ); BOOST_CHECK_CLOSE( x.maxAbs(), (Real)2.0, tol ); x /= x.sum(); // test entropy BOOST_CHECK( x.entropy() < Prob(5).entropy() ); for( size_t i = 1; i < 100; i++ ) BOOST_CHECK_CLOSE( Factor( Var(0,i) ).entropy(), dai::log((Real)i), tol ); // test hasNaNs and hasNegatives BOOST_CHECK( !Factor( 0.0 ).hasNaNs() ); Real c = 0.0; BOOST_CHECK( Factor( c / c ).hasNaNs() ); BOOST_CHECK( !Factor( 0.0 ).hasNegatives() ); BOOST_CHECK( !Factor( 1.0 ).hasNegatives() ); BOOST_CHECK( Factor( -1.0 ).hasNegatives() ); x.set( 0, 0.0 ); x.set( 1, 0.0 ); x.set( 2, -1.0 ); x.set( 3, 1.0 ); x.set( 4, 100.0 ); BOOST_CHECK( x.hasNegatives() ); x.set( 2, -INFINITY ); BOOST_CHECK( x.hasNegatives() ); x.set( 2, INFINITY ); BOOST_CHECK( !x.hasNegatives() ); x.set( 2, -1.0 ); // test strength Var x0(0,2); Var x1(1,2); BOOST_CHECK_CLOSE( createFactorIsing( x0, x1, 1.0 ).strength( x0, x1 ), std::tanh( (Real)1.0 ), tol ); BOOST_CHECK_CLOSE( createFactorIsing( x0, x1, -1.0 ).strength( x0, x1 ), std::tanh( (Real)1.0 ), tol ); BOOST_CHECK_CLOSE( createFactorIsing( x0, x1, 0.5 ).strength( x0, x1 ), std::tanh( (Real)0.5 ), tol ); // test == Factor a(Var(0,3)), b(Var(0,3)); Factor d(Var(1,3)); BOOST_CHECK( !(a == d) ); BOOST_CHECK( !(b == d) ); BOOST_CHECK( a == b ); a.set( 0, 0.0 ); BOOST_CHECK( !(a == b) ); b.set( 2, 0.0 ); BOOST_CHECK( !(a == b) ); b.set( 0, 0.0 ); BOOST_CHECK( !(a == b) ); a.set( 1, 0.0 ); BOOST_CHECK( !(a == b) ); b.set( 1, 0.0 ); BOOST_CHECK( !(a == b) ); a.set( 2, 0.0 ); BOOST_CHECK( a == b ); } BOOST_AUTO_TEST_CASE( UnaryTransformationsTest ) { Var v( 0, 3 ); Factor x( v ); x.set( 0, -2.0 ); x.set( 1, 0.0 ); x.set( 2, 2.0 ); Factor y = -x; BOOST_CHECK_CLOSE( y[0], (Real)2.0, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)-2.0, tol ); y = x.abs(); BOOST_CHECK_CLOSE( y[0], (Real)2.0, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)2.0, tol ); y = x.exp(); BOOST_CHECK_CLOSE( y[0], dai::exp((Real)-2.0), tol ); BOOST_CHECK_CLOSE( y[1], (Real)1.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)1.0 / y[0], tol ); y = x.log(false); BOOST_CHECK( dai::isnan( y[0] ) ); BOOST_CHECK_EQUAL( y[1], -INFINITY ); BOOST_CHECK_CLOSE( y[2], dai::log((Real)2.0), tol ); y = x.log(true); BOOST_CHECK( dai::isnan( y[0] ) ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], dai::log((Real)2.0), tol ); y = x.inverse(false); BOOST_CHECK_CLOSE( y[0], (Real)-0.5, tol ); BOOST_CHECK_EQUAL( y[1], INFINITY ); BOOST_CHECK_CLOSE( y[2], (Real)0.5, tol ); y = x.inverse(true); BOOST_CHECK_CLOSE( y[0], (Real)-0.5, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)0.5, tol ); x.set( 0, 2.0 ); y = x.normalized(); BOOST_CHECK_CLOSE( y[0], (Real)0.5, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)0.5, tol ); y = x.normalized( NORMPROB ); BOOST_CHECK_CLOSE( y[0], (Real)0.5, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)0.5, tol ); x.set( 0, -2.0 ); y = x.normalized( NORMLINF ); BOOST_CHECK_CLOSE( y[0], (Real)-1.0, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)1.0, tol ); } BOOST_AUTO_TEST_CASE( UnaryOperationsTest ) { Var v( 0, 3 ); Factor xorg( v ); xorg.set( 0, 2.0 ); xorg.set( 1, 0.0 ); xorg.set( 2, 1.0 ); Factor y( v ); Factor x = xorg; BOOST_CHECK( x.setUniform() == Factor( v ) ); BOOST_CHECK( x == Factor( v ) ); y.set( 0, dai::exp(2.0) ); y.set( 1, 1.0 ); y.set( 2, dai::exp(1.0) ); x = xorg; BOOST_CHECK_SMALL( dist( x.takeExp(), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, dai::log(2.0) ); y.set( 1, -INFINITY ); y.set( 2, 0.0 ); x = xorg; Factor z = x.takeLog(); BOOST_CHECK_CLOSE( z[0], y[0], tol ); //BOOST_CHECK_CLOSE( z[1], y[1], tol ); BOOST_CHECK_CLOSE( z[2], y[2], tol ); BOOST_CHECK( z.vars() == y.vars() ); BOOST_CHECK( x == z ); x = xorg; z = x.takeLog(false); BOOST_CHECK_CLOSE( z[0], y[0], tol ); //BOOST_CHECK_CLOSE( z[1], y[1], tol ); BOOST_CHECK_CLOSE( z[2], y[2], tol ); BOOST_CHECK( z.vars() == y.vars() ); BOOST_CHECK( x == z ); y.set( 1, 0.0 ); x = xorg; BOOST_CHECK_SMALL( dist( x.takeLog(true), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 2.0 / 3.0 ); y.set( 1, 0.0 / 3.0 ); y.set( 2, 1.0 / 3.0 ); x = xorg; BOOST_CHECK_CLOSE( x.normalize(), (Real)3.0, tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; BOOST_CHECK_CLOSE( x.normalize( NORMPROB ), (Real)3.0, tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 2.0 / 2.0 ); y.set( 1, 0.0 / 2.0 ); y.set( 2, 1.0 / 2.0 ); x = xorg; BOOST_CHECK_CLOSE( x.normalize( NORMLINF ), (Real)2.0, tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); xorg.set( 0, -2.0 ); y.set( 0, 2.0 ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); x = xorg; BOOST_CHECK_SMALL( dist( x.takeAbs(), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); for( size_t repeat = 0; repeat < 10000; repeat++ ) { x.randomize(); for( size_t i = 0; i < x.nrStates(); i++ ) { BOOST_CHECK( x[i] < (Real)1.0 ); BOOST_CHECK( x[i] >= (Real)0.0 ); } } } BOOST_AUTO_TEST_CASE( ScalarOperationsTest ) { Var v( 0, 3 ); Factor xorg( v ), x( v ); xorg.set( 0, 2.0 ); xorg.set( 1, 0.0 ); xorg.set( 2, 1.0 ); Factor y( v ); x = xorg; BOOST_CHECK( x.fill( 1.0 ) == Factor(v, 1.0) ); BOOST_CHECK( x == Factor(v, 1.0) ); BOOST_CHECK( x.fill( 2.0 ) == Factor(v, 2.0) ); BOOST_CHECK( x == Factor(v, 2.0) ); BOOST_CHECK( x.fill( 0.0 ) == Factor(v, 0.0) ); BOOST_CHECK( x == Factor(v, 0.0) ); x = xorg; y.set( 0, 3.0 ); y.set( 1, 1.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x += 1.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 1.0 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); BOOST_CHECK_SMALL( dist( (x += -2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; y.set( 0, 1.0 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); BOOST_CHECK_SMALL( dist( (x -= 1.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 3.0 ); y.set( 1, 1.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x -= -2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; BOOST_CHECK_SMALL( dist( (x *= 1.0), x, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, x, DISTL1 ), tol ); y.set( 0, 4.0 ); y.set( 1, 0.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x *= 2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, -1.0 ); y.set( 1, 0.0 ); y.set( 2, -0.5 ); BOOST_CHECK_SMALL( dist( (x *= -0.25), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; BOOST_CHECK_SMALL( dist( (x /= 1.0), x, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, x, DISTL1 ), tol ); y.set( 0, 1.0 ); y.set( 1, 0.0 ); y.set( 2, 0.5 ); BOOST_CHECK_SMALL( dist( (x /= 2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, -4.0 ); y.set( 1, 0.0 ); y.set( 2, -2.0 ); BOOST_CHECK_SMALL( dist( (x /= -0.25), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( (x /= 0.0), Factor(v, 0.0), DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, Factor(v, 0.0), DISTL1 ), tol ); x = xorg; BOOST_CHECK_SMALL( dist( (x ^= 1.0), x, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, x, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( (x ^= 0.0), Factor(v, 1.0), DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, Factor(v, 1.0), DISTL1 ), tol ); x = xorg; y.set( 0, 4.0 ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); BOOST_CHECK_SMALL( dist( (x ^= 2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 2.0 ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); BOOST_CHECK( (x ^= 0.5) == y ); BOOST_CHECK( x == y ); } BOOST_AUTO_TEST_CASE( ScalarTransformationsTest ) { Var v( 0, 3 ); Factor x( v ); x.set( 0, 2.0 ); x.set( 1, 0.0 ); x.set( 2, 1.0 ); Factor y( v ); y.set( 0, 3.0 ); y.set( 1, 1.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x + 1.0), y, DISTL1 ), tol ); y.set( 0, 0.0 ); y.set( 1, -2.0 ); y.set( 2, -1.0 ); BOOST_CHECK_SMALL( dist( (x + (-2.0)), y, DISTL1 ), tol ); y.set( 0, 1.0 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); BOOST_CHECK_SMALL( dist( (x - 1.0), y, DISTL1 ), tol ); y.set( 0, 4.0 ); y.set( 1, 2.0 ); y.set( 2, 3.0 ); BOOST_CHECK_SMALL( dist( (x - (-2.0)), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( (x * 1.0), x, DISTL1 ), tol ); y.set( 0, 4.0 ); y.set( 1, 0.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x * 2.0), y, DISTL1 ), tol ); y.set( 0, -1.0 ); y.set( 1, 0.0 ); y.set( 2, -0.5 ); BOOST_CHECK_SMALL( dist( (x * -0.5), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( (x / 1.0), x, DISTL1 ), tol ); y.set( 0, 1.0 ); y.set( 1, 0.0 ); y.set( 2, 0.5 ); BOOST_CHECK_SMALL( dist( (x / 2.0), y, DISTL1 ), tol ); y.set( 0, -4.0 ); y.set( 1, 0.0 ); y.set( 2, -2.0 ); BOOST_CHECK_SMALL( dist( (x / -0.5), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( (x / 0.0), Factor(v, 0.0), DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( (x ^ 1.0), x, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( (x ^ 0.0), Factor(v, 1.0), DISTL1 ), tol ); y.set( 0, 4.0 ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); BOOST_CHECK_SMALL( dist( (x ^ 2.0), y, DISTL1 ), tol ); y.set( 0, std::sqrt(2.0) ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); BOOST_CHECK_SMALL( dist( (x ^ 0.5), y, DISTL1 ), tol ); } BOOST_AUTO_TEST_CASE( SimilarFactorOperationsTest ) { size_t N = 6; Var v( 0, N ); Factor xorg( v ), x( v ); xorg.set( 0, 2.0 ); xorg.set( 1, 0.0 ); xorg.set( 2, 1.0 ); xorg.set( 3, 0.0 ); xorg.set( 4, 2.0 ); xorg.set( 5, 3.0 ); Factor y( v ); y.set( 0, 0.5 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); y.set( 3, 0.0 ); y.set( 4, -2.0 ); y.set( 5, 3.0 ); Factor z( v ), r( v ); z.set( 0, 2.5 ); z.set( 1, -1.0 ); z.set( 2, 1.0 ); z.set( 3, 0.0 ); z.set( 4, 0.0 ); z.set( 5, 6.0 ); x = xorg; r = (x += y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); x = xorg; BOOST_CHECK( x.binaryOp( y, std::plus() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 1.5 ); z.set( 1, 1.0 ); z.set( 2, 1.0 ); z.set( 3, 0.0 ); z.set( 4, 4.0 ); z.set( 5, 0.0 ); x = xorg; r = (x -= y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); x = xorg; BOOST_CHECK( x.binaryOp( y, std::minus() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 1.0 ); z.set( 1, 0.0 ); z.set( 2, 0.0 ); z.set( 3, 0.0 ); z.set( 4, -4.0 ); z.set( 5, 9.0 ); x = xorg; r = (x *= y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); x = xorg; BOOST_CHECK( x.binaryOp( y, std::multiplies() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 4.0 ); z.set( 1, 0.0 ); z.set( 2, 0.0 ); z.set( 3, 0.0 ); z.set( 4, -1.0 ); z.set( 5, 1.0 ); x = xorg; r = (x /= y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); x = xorg; BOOST_CHECK( x.binaryOp( y, fo_divides0() ) == r ); BOOST_CHECK( x == r ); } BOOST_AUTO_TEST_CASE( SimilarFactorTransformationsTest ) { size_t N = 6; Var v( 0, N ); Factor x( v ); x.set( 0, 2.0 ); x.set( 1, 0.0 ); x.set( 2, 1.0 ); x.set( 3, 0.0 ); x.set( 4, 2.0 ); x.set( 5, 3.0 ); Factor y( v ); y.set( 0, 0.5 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); y.set( 3, 0.0 ); y.set( 4, -2.0 ); y.set( 5, 3.0 ); Factor z( v ), r( v ); z.set( 0, 2.5 ); z.set( 1, -1.0 ); z.set( 2, 1.0 ); z.set( 3, 0.0 ); z.set( 4, 0.0 ); z.set( 5, 6.0 ); r = x + y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.binaryTr( y, std::plus() ); BOOST_CHECK( r == z ); z.set( 0, 1.5 ); z.set( 1, 1.0 ); z.set( 2, 1.0 ); z.set( 3, 0.0 ); z.set( 4, 4.0 ); z.set( 5, 0.0 ); r = x - y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.binaryTr( y, std::minus() ); BOOST_CHECK( r == z ); z.set( 0, 1.0 ); z.set( 1, 0.0 ); z.set( 2, 0.0 ); z.set( 3, 0.0 ); z.set( 4, -4.0 ); z.set( 5, 9.0 ); r = x * y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.binaryTr( y, std::multiplies() ); BOOST_CHECK( r == z ); z.set( 0, 4.0 ); z.set( 1, 0.0 ); z.set( 2, 0.0 ); z.set( 3, 0.0 ); z.set( 4, -1.0 ); z.set( 5, 1.0 ); r = x / y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.binaryTr( y, fo_divides0() ); BOOST_CHECK( r == z ); } BOOST_AUTO_TEST_CASE( FactorOperationsTest ) { size_t N = 9; Var v1( 1, 3 ); Var v2( 2, 3 ); Factor xorg( v1 ), x( v1 ); xorg.set( 0, 2.0 ); xorg.set( 1, 0.0 ); xorg.set( 2, -1.0 ); Factor y( v2 ); y.set( 0, 0.5 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); Factor r; Factor z( VarSet( v1, v2 ) ); z.set( 0, 2.5 ); z.set( 1, 0.5 ); z.set( 2, -0.5 ); z.set( 3, 1.0 ); z.set( 4, -1.0 ); z.set( 5, -2.0 ); z.set( 6, 2.0 ); z.set( 7, 0.0 ); z.set( 8, -1.0 ); x = xorg; r = (x += y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); x = xorg; BOOST_CHECK( x.binaryOp( y, std::plus() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 1.5 ); z.set( 1, -0.5 ); z.set( 2, -1.5 ); z.set( 3, 3.0 ); z.set( 4, 1.0 ); z.set( 5, 0.0 ); z.set( 6, 2.0 ); z.set( 7, 0.0 ); z.set( 8, -1.0 ); x = xorg; r = (x -= y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); x = xorg; BOOST_CHECK( x.binaryOp( y, std::minus() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 1.0 ); z.set( 1, 0.0 ); z.set( 2, -0.5 ); z.set( 3, -2.0 ); z.set( 4, 0.0 ); z.set( 5, 1.0 ); z.set( 6, 0.0 ); z.set( 7, 0.0 ); z.set( 8, 0.0 ); x = xorg; r = (x *= y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); x = xorg; BOOST_CHECK( x.binaryOp( y, std::multiplies() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 4.0 ); z.set( 1, 0.0 ); z.set( 2, -2.0 ); z.set( 3, -2.0 ); z.set( 4, 0.0 ); z.set( 5, 1.0 ); z.set( 6, 0.0 ); z.set( 7, 0.0 ); z.set( 8, 0.0 ); x = xorg; r = (x /= y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); x = xorg; BOOST_CHECK( x.binaryOp( y, fo_divides0() ) == r ); BOOST_CHECK( x == r ); } BOOST_AUTO_TEST_CASE( FactorTransformationsTest ) { size_t N = 9; Var v1( 1, 3 ); Var v2( 2, 3 ); Factor x( v1 ); x.set( 0, 2.0 ); x.set( 1, 0.0 ); x.set( 2, -1.0 ); Factor y( v2 ); y.set( 0, 0.5 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); Factor r; Factor z( VarSet( v1, v2 ) ); z.set( 0, 2.5 ); z.set( 1, 0.5 ); z.set( 2, -0.5 ); z.set( 3, 1.0 ); z.set( 4, -1.0 ); z.set( 5, -2.0 ); z.set( 6, 2.0 ); z.set( 7, 0.0 ); z.set( 8, -1.0 ); r = x + y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.binaryTr( y, std::plus() ); BOOST_CHECK( r == z ); z.set( 0, 1.5 ); z.set( 1, -0.5 ); z.set( 2, -1.5 ); z.set( 3, 3.0 ); z.set( 4, 1.0 ); z.set( 5, 0.0 ); z.set( 6, 2.0 ); z.set( 7, 0.0 ); z.set( 8, -1.0 ); r = x - y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.binaryTr( y, std::minus() ); BOOST_CHECK( r == z ); z.set( 0, 1.0 ); z.set( 1, 0.0 ); z.set( 2, -0.5 ); z.set( 3, -2.0 ); z.set( 4, 0.0 ); z.set( 5, 1.0 ); z.set( 6, 0.0 ); z.set( 7, 0.0 ); z.set( 8, 0.0 ); r = x * y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.binaryTr( y, std::multiplies() ); BOOST_CHECK( r == z ); z.set( 0, 4.0 ); z.set( 1, 0.0 ); z.set( 2, -2.0 ); z.set( 3, -2.0 ); z.set( 4, 0.0 ); z.set( 5, 1.0 ); z.set( 6, 0.0 ); z.set( 7, 0.0 ); z.set( 8, 0.0 ); r = x / y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.binaryOp( y, fo_divides0() ); BOOST_CHECK( r == z ); } BOOST_AUTO_TEST_CASE( MiscOperationsTest ) { Var v1(1, 2); Var v2(2, 3); Factor x( VarSet( v1, v2 ) ); x.randomize(); // slice Factor y = x.slice( v1, 0 ); BOOST_CHECK( y.vars() == VarSet( v2 ) ); BOOST_CHECK_EQUAL( y.nrStates(), 3 ); BOOST_CHECK_EQUAL( y[0], x[0] ); BOOST_CHECK_EQUAL( y[1], x[2] ); BOOST_CHECK_EQUAL( y[2], x[4] ); y = x.slice( v1, 1 ); BOOST_CHECK( y.vars() == VarSet( v2 ) ); BOOST_CHECK_EQUAL( y.nrStates(), 3 ); BOOST_CHECK_EQUAL( y[0], x[1] ); BOOST_CHECK_EQUAL( y[1], x[3] ); BOOST_CHECK_EQUAL( y[2], x[5] ); y = x.slice( v2, 0 ); BOOST_CHECK( y.vars() == VarSet( v1 ) ); BOOST_CHECK_EQUAL( y.nrStates(), 2 ); BOOST_CHECK_EQUAL( y[0], x[0] ); BOOST_CHECK_EQUAL( y[1], x[1] ); y = x.slice( v2, 1 ); BOOST_CHECK( y.vars() == VarSet( v1 ) ); BOOST_CHECK_EQUAL( y.nrStates(), 2 ); BOOST_CHECK_EQUAL( y[0], x[2] ); BOOST_CHECK_EQUAL( y[1], x[3] ); y = x.slice( v2, 2 ); BOOST_CHECK( y.vars() == VarSet( v1 ) ); BOOST_CHECK_EQUAL( y.nrStates(), 2 ); BOOST_CHECK_EQUAL( y[0], x[4] ); BOOST_CHECK_EQUAL( y[1], x[5] ); for( size_t i = 0; i < x.nrStates(); i++ ) { y = x.slice( VarSet( v1, v2 ), 0 ); BOOST_CHECK( y.vars() == VarSet() ); BOOST_CHECK_EQUAL( y.nrStates(), 1 ); BOOST_CHECK_EQUAL( y[0], x[0] ); } y = x.slice( VarSet(), 0 ); BOOST_CHECK_EQUAL( y, x ); // embed Var v3(3, 4); BOOST_CHECK_THROW( x.embed( VarSet( v3 ) ), Exception ); BOOST_CHECK_THROW( x.embed( VarSet( v3, v2 ) ), Exception ); y = x.embed( VarSet( v3, v2 ) | v1 ); for( size_t i = 0; i < y.nrStates(); i++ ) BOOST_CHECK_EQUAL( y[i], x[i % 6] ); y = x.embed( VarSet( v1, v2 ) ); BOOST_CHECK_EQUAL( x, y ); // marginal y = x.marginal( v1 ); BOOST_CHECK( y.vars() == VarSet( v1 ) ); BOOST_CHECK_CLOSE( y[0], (x[0] + x[2] + x[4]) / x.sum(), tol ); BOOST_CHECK_CLOSE( y[1], (x[1] + x[3] + x[5]) / x.sum(),tol ); y = x.marginal( v2 ); BOOST_CHECK( y.vars() == VarSet( v2 ) ); BOOST_CHECK_CLOSE( y[0], (x[0] + x[1]) / x.sum(), tol ); BOOST_CHECK_CLOSE( y[1], (x[2] + x[3]) / x.sum(), tol ); BOOST_CHECK_CLOSE( y[2], (x[4] + x[5]) / x.sum(), tol ); y = x.marginal( VarSet() ); BOOST_CHECK( y.vars() == VarSet() ); BOOST_CHECK_CLOSE( y[0], (Real)1.0, tol ); y = x.marginal( VarSet( v1, v2 ) ); BOOST_CHECK_SMALL( dist( y, x.normalized(), DISTL1 ), tol ); y = x.marginal( v1, true ); BOOST_CHECK( y.vars() == VarSet( v1 ) ); BOOST_CHECK_CLOSE( y[0], (x[0] + x[2] + x[4]) / x.sum(), tol ); BOOST_CHECK_CLOSE( y[1], (x[1] + x[3] + x[5]) / x.sum(), tol ); y = x.marginal( v2, true ); BOOST_CHECK( y.vars() == VarSet( v2 ) ); BOOST_CHECK_CLOSE( y[0], (x[0] + x[1]) / x.sum(), tol ); BOOST_CHECK_CLOSE( y[1], (x[2] + x[3]) / x.sum(), tol ); BOOST_CHECK_CLOSE( y[2], (x[4] + x[5]) / x.sum(), tol ); y = x.marginal( VarSet(), true ); BOOST_CHECK( y.vars() == VarSet() ); BOOST_CHECK_CLOSE( y[0], (Real)1.0, tol ); y = x.marginal( VarSet( v1, v2 ), true ); BOOST_CHECK_SMALL( dist( y, x.normalized(), DISTL1 ), tol ); y = x.marginal( v1, false ); BOOST_CHECK( y.vars() == VarSet( v1 ) ); BOOST_CHECK_CLOSE( y[0], x[0] + x[2] + x[4], tol ); BOOST_CHECK_CLOSE( y[1], x[1] + x[3] + x[5], tol ); y = x.marginal( v2, false ); BOOST_CHECK( y.vars() == VarSet( v2 ) ); BOOST_CHECK_CLOSE( y[0], x[0] + x[1], tol ); BOOST_CHECK_CLOSE( y[1], x[2] + x[3], tol ); BOOST_CHECK_CLOSE( y[2], x[4] + x[5], tol ); y = x.marginal( VarSet(), false ); BOOST_CHECK( y.vars() == VarSet() ); BOOST_CHECK_CLOSE( y[0], x.sum(), tol ); y = x.marginal( VarSet( v1, v2 ), false ); BOOST_CHECK_SMALL( dist( y, x, DISTL1 ), tol ); // maxMarginal y = x.maxMarginal( v1 ); BOOST_CHECK( y.vars() == VarSet( v1 ) ); BOOST_CHECK_CLOSE( y[0], x.slice( v1, 0 ).max() / (x.slice( v1, 0 ).max() + x.slice( v1, 1 ).max()), tol ); BOOST_CHECK_CLOSE( y[1], x.slice( v1, 1 ).max() / (x.slice( v1, 0 ).max() + x.slice( v1, 1 ).max()), tol ); y = x.maxMarginal( v2 ); BOOST_CHECK( y.vars() == VarSet( v2 ) ); BOOST_CHECK_CLOSE( y[0], x.slice( v2, 0 ).max() / (x.slice( v2, 0 ).max() + x.slice( v2, 1 ).max() + x.slice( v2, 2 ).max()), tol ); BOOST_CHECK_CLOSE( y[1], x.slice( v2, 1 ).max() / (x.slice( v2, 0 ).max() + x.slice( v2, 1 ).max() + x.slice( v2, 2 ).max()), tol ); BOOST_CHECK_CLOSE( y[2], x.slice( v2, 2 ).max() / (x.slice( v2, 0 ).max() + x.slice( v2, 1 ).max() + x.slice( v2, 2 ).max()), tol ); y = x.maxMarginal( VarSet() ); BOOST_CHECK( y.vars() == VarSet() ); BOOST_CHECK_CLOSE( y[0], (Real)1.0, tol ); y = x.maxMarginal( VarSet( v1, v2 ) ); BOOST_CHECK_SMALL( dist( y, x.normalized(), DISTL1 ), tol ); y = x.maxMarginal( v1, true ); BOOST_CHECK( y.vars() == VarSet( v1 ) ); BOOST_CHECK_CLOSE( y[0], x.slice( v1, 0 ).max() / (x.slice( v1, 0 ).max() + x.slice( v1, 1 ).max()), tol ); BOOST_CHECK_CLOSE( y[1], x.slice( v1, 1 ).max() / (x.slice( v1, 0 ).max() + x.slice( v1, 1 ).max()), tol ); y = x.maxMarginal( v2, true ); BOOST_CHECK( y.vars() == VarSet( v2 ) ); BOOST_CHECK_CLOSE( y[0], x.slice( v2, 0 ).max() / (x.slice( v2, 0 ).max() + x.slice( v2, 1 ).max() + x.slice( v2, 2 ).max()), tol ); BOOST_CHECK_CLOSE( y[1], x.slice( v2, 1 ).max() / (x.slice( v2, 0 ).max() + x.slice( v2, 1 ).max() + x.slice( v2, 2 ).max()), tol ); BOOST_CHECK_CLOSE( y[2], x.slice( v2, 2 ).max() / (x.slice( v2, 0 ).max() + x.slice( v2, 1 ).max() + x.slice( v2, 2 ).max()), tol ); y = x.maxMarginal( VarSet(), true ); BOOST_CHECK( y.vars() == VarSet() ); BOOST_CHECK_CLOSE( y[0], (Real)1.0, tol ); y = x.maxMarginal( VarSet( v1, v2 ), true ); BOOST_CHECK_SMALL( dist( y, x.normalized(), DISTL1 ), tol ); y = x.maxMarginal( v1, false ); BOOST_CHECK( y.vars() == VarSet( v1 ) ); BOOST_CHECK_EQUAL( y[0], x.slice( v1, 0 ).max() ); BOOST_CHECK_EQUAL( y[1], x.slice( v1, 1 ).max() ); y = x.maxMarginal( v2, false ); BOOST_CHECK( y.vars() == VarSet( v2 ) ); BOOST_CHECK_EQUAL( y[0], x.slice( v2, 0 ).max() ); BOOST_CHECK_EQUAL( y[1], x.slice( v2, 1 ).max() ); BOOST_CHECK_EQUAL( y[2], x.slice( v2, 2 ).max() ); y = x.maxMarginal( VarSet(), false ); BOOST_CHECK( y.vars() == VarSet() ); BOOST_CHECK_EQUAL( y[0], x.max() ); y = x.maxMarginal( VarSet( v1, v2 ), false ); BOOST_CHECK( y == x ); } BOOST_AUTO_TEST_CASE( RelatedFunctionsTest ) { Var v( 0, 3 ); Factor x(v), y(v), z(v); x.set( 0, 0.2 ); x.set( 1, 0.8 ); x.set( 2, 0.0 ); y.set( 0, 0.0 ); y.set( 1, 0.6 ); y.set( 2, 0.4 ); z = min( x, y ); BOOST_CHECK_EQUAL( z[0], (Real)0.0 ); BOOST_CHECK_EQUAL( z[1], (Real)0.6 ); BOOST_CHECK_EQUAL( z[2], (Real)0.0 ); z = max( x, y ); BOOST_CHECK_EQUAL( z[0], (Real)0.2 ); BOOST_CHECK_EQUAL( z[1], (Real)0.8 ); BOOST_CHECK_EQUAL( z[2], (Real)0.4 ); BOOST_CHECK_CLOSE( dist( x, x, DISTL1 ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTL1 ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTL1 ), (Real)(0.2 + 0.2 + 0.4), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTL1 ), (Real)(0.2 + 0.2 + 0.4), tol ); BOOST_CHECK_CLOSE( dist( x, x, DISTLINF ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTLINF ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTLINF ), (Real)0.4, tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTLINF ), (Real)0.4, tol ); BOOST_CHECK_CLOSE( dist( x, x, DISTTV ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTTV ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTTV ), (Real)(0.5 * (0.2 + 0.2 + 0.4)), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTTV ), (Real)(0.5 * (0.2 + 0.2 + 0.4)), tol ); BOOST_CHECK_CLOSE( dist( x, x, DISTKL ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTKL ), (Real)0.0, tol ); BOOST_CHECK_EQUAL( dist( x, y, DISTKL ), INFINITY ); BOOST_CHECK_EQUAL( dist( y, x, DISTKL ), INFINITY ); BOOST_CHECK_CLOSE( dist( x, x, DISTHEL ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTHEL ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTHEL ), (Real)(0.5 * (0.2 + dai::pow(std::sqrt(0.8) - std::sqrt(0.6), 2.0) + 0.4)), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTHEL ), (Real)(0.5 * (0.2 + dai::pow(std::sqrt(0.8) - std::sqrt(0.6), 2.0) + 0.4)), tol ); x.set( 1, 0.7 ); x.set( 2, 0.1 ); y.set( 0, 0.1 ); y.set( 1, 0.5 ); BOOST_CHECK_CLOSE( dist( x, y, DISTKL ), (Real)(0.2 * dai::log(0.2 / 0.1) + 0.7 * dai::log(0.7 / 0.5) + 0.1 * dai::log(0.1 / 0.4)), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTKL ), (Real)(0.1 * dai::log(0.1 / 0.2) + 0.5 * dai::log(0.5 / 0.7) + 0.4 * dai::log(0.4 / 0.1)), tol ); std::stringstream ss; ss << x; std::string s; std::getline( ss, s ); BOOST_CHECK_EQUAL( s, std::string("({x0}, (0.2, 0.7, 0.1))") ); std::stringstream ss2; ss2 << y; std::getline( ss2, s ); BOOST_CHECK_EQUAL( s, std::string("({x0}, (0.1, 0.5, 0.4))") ); z = min( x, y ); BOOST_CHECK_EQUAL( z[0], (Real)0.1 ); BOOST_CHECK_EQUAL( z[1], (Real)0.5 ); BOOST_CHECK_EQUAL( z[2], (Real)0.1 ); z = max( x, y ); BOOST_CHECK_EQUAL( z[0], (Real)0.2 ); BOOST_CHECK_EQUAL( z[1], (Real)0.7 ); BOOST_CHECK_EQUAL( z[2], (Real)0.4 ); for( Real J = -1.0; J <= 1.01; J += 0.1 ) { Factor x = createFactorIsing( Var(0,2), Var(1,2), J ).normalized(); BOOST_CHECK_CLOSE( x[0], dai::exp(J) / (4.0 * std::cosh(J)), tol ); BOOST_CHECK_CLOSE( x[1], dai::exp(-J) / (4.0 * std::cosh(J)), tol ); BOOST_CHECK_CLOSE( x[2], dai::exp(-J) / (4.0 * std::cosh(J)), tol ); BOOST_CHECK_CLOSE( x[3], dai::exp(J) / (4.0 * std::cosh(J)), tol ); BOOST_CHECK_SMALL( MutualInfo( x ) - (J * std::tanh(J) - dai::log(std::cosh(J))), tol ); } Var v1( 1, 3 ); Var v2( 2, 4 ); BOOST_CHECK_SMALL( MutualInfo( (Factor(v1).randomize() * Factor(v2).randomize()).normalized() ), tol ); BOOST_CHECK_THROW( MutualInfo( createFactorIsing( Var(0,2), 1.0 ).normalized() ), Exception ); BOOST_CHECK_THROW( createFactorIsing( v1, 0.0 ), Exception ); BOOST_CHECK_THROW( createFactorIsing( v1, v2, 0.0 ), Exception ); for( Real J = -1.0; J <= 1.01; J += 0.1 ) { Factor x = createFactorIsing( Var(0,2), J ).normalized(); BOOST_CHECK_CLOSE( x[0], dai::exp(-J) / (2.0 * std::cosh(J)), tol ); BOOST_CHECK_CLOSE( x[1], dai::exp(J) / (2.0 * std::cosh(J)), tol ); BOOST_CHECK_SMALL( x.entropy() - (-J * std::tanh(J) + dai::log(2.0 * std::cosh(J))), tol ); } x = createFactorDelta( v1, 2 ); BOOST_CHECK_EQUAL( x[0], (Real)0.0 ); BOOST_CHECK_EQUAL( x[1], (Real)0.0 ); BOOST_CHECK_EQUAL( x[2], (Real)1.0 ); x = createFactorDelta( v1, 1 ); BOOST_CHECK_EQUAL( x[0], (Real)0.0 ); BOOST_CHECK_EQUAL( x[1], (Real)1.0 ); BOOST_CHECK_EQUAL( x[2], (Real)0.0 ); x = createFactorDelta( v1, 0 ); BOOST_CHECK_EQUAL( x[0], (Real)1.0 ); BOOST_CHECK_EQUAL( x[1], (Real)0.0 ); BOOST_CHECK_EQUAL( x[2], (Real)0.0 ); BOOST_CHECK_THROW( createFactorDelta( v1, 4 ), Exception ); for( size_t i = 0; i < 12; i++ ) { Factor xx = createFactorDelta( VarSet( v1, v2 ), i ); for( size_t j = 0; j < 12; j++ ) BOOST_CHECK_EQUAL( xx[j], (Real)(i == j) ); } BOOST_CHECK_THROW( createFactorDelta( VarSet( v1, v2 ), 12 ), Exception ); } libDAI-0.2.7/tests/unit/util_test.cpp0000644000263000017630000001604011433220722016316 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include #include #include using namespace dai; #define BOOST_TEST_MODULE UtilTest #include BOOST_AUTO_TEST_CASE( IsNanTest ) { double x = 0.0, y = 0.0; BOOST_CHECK( dai::isnan( x / y ) ); BOOST_CHECK( !dai::isnan( x ) ); } BOOST_AUTO_TEST_CASE( RndTest ) { rnd_seed( 123 ); Real a1 = rnd_uniform(); Real b1 = rnd_stdnormal(); int c1 = rnd_int(0,1); int d1 = rnd(2); rnd_seed( 123 ); Real a2 = rnd_uniform(); Real b2 = rnd_stdnormal(); int c2 = rnd_int(0,1); int d2 = rnd(2); BOOST_CHECK_EQUAL( a1, a2 ); BOOST_CHECK_EQUAL( b1, b2 ); BOOST_CHECK_EQUAL( c1, c2 ); BOOST_CHECK_EQUAL( d1, d2 ); for( size_t i = 0; i < 10000; i++ ) { Real x = rnd_uniform(); BOOST_CHECK( x >= 0.0 ); BOOST_CHECK( x < 1 ); } for( int min = -5; min <= 5; min++ ) for( int max = min; max <= min + 10; max++ ) for( size_t i = 0; i < 1000; i++ ) { int j = rnd_int( min, max ); BOOST_CHECK( j >= min ); BOOST_CHECK( j <= max ); } for( int max = 1; max <= 100; max++ ) for( size_t i = 0; i < 100; i++ ) { int j = rnd( max ); BOOST_CHECK( j >= 0 ); BOOST_CHECK( j < max ); } } BOOST_AUTO_TEST_CASE( StreamTest ) { std::vector v; v.push_back( 1 ); v.push_back( 3 ); v.push_back( 2 ); std::stringstream ss; ss << v; std::string s; std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "(1, 3, 2)" ); std::set x; x.insert( 6 ); x.insert( 5 ); x.insert( 4 ); std::stringstream ss2; ss2 << x; std::getline( ss2, s ); BOOST_CHECK_EQUAL( s, "{4, 5, 6}" ); std::map y; y[1] = 6; y[3] = 5; y[2] = 4; std::stringstream ss3; ss3 << y; std::getline( ss3, s ); BOOST_CHECK_EQUAL( s, "{1->6, 2->4, 3->5}" ); std::pair z; z.first = 5; z.second = 1.2345; std::stringstream ss4; ss4 << z; std::getline( ss4, s ); BOOST_CHECK_EQUAL( s, "(5, 1.2345)" ); } BOOST_AUTO_TEST_CASE( concatTest ) { std::vector a; a.push_back( 0 ); a.push_back( 1 ); std::vector b; b.push_back( 2 ); b.push_back( 3 ); b.push_back( 4 ); std::vector c; c.push_back( 0 ); c.push_back( 1 ); c.push_back( 2 ); c.push_back( 3 ); c.push_back( 4 ); BOOST_CHECK( concat( a, b ) == c ); } BOOST_AUTO_TEST_CASE( stringTest ) { int a = 5; BOOST_CHECK_EQUAL( toString( a ), std::string("5") ); BOOST_CHECK_EQUAL( fromString( "5" ), a ); bool b = true; BOOST_CHECK_EQUAL( toString( b ), std::string("1") ); BOOST_CHECK_EQUAL( fromString( "1" ), b ); double c = -3.5; BOOST_CHECK_EQUAL( toString( c ), std::string("-3.5") ); BOOST_CHECK_EQUAL( fromString( "-3.5" ), c ); unsigned char d = 'e'; BOOST_CHECK_EQUAL( toString( d ), std::string("e") ); BOOST_CHECK_EQUAL( fromString( "e" ), d ); } BOOST_AUTO_TEST_CASE( tokenizeStringTest ) { std::string s; std::vector tokens; s = ""; tokens = tokenizeString( s, true, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 0 ); s = " "; tokens = tokenizeString( s, true, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 1 ); BOOST_CHECK_EQUAL( tokens[0], "" ); s = " \t"; tokens = tokenizeString( s, true, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 2 ); BOOST_CHECK_EQUAL( tokens[0], "" ); BOOST_CHECK_EQUAL( tokens[1], "" ); s = " \tHello"; tokens = tokenizeString( s, true, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 3 ); BOOST_CHECK_EQUAL( tokens[0], "" ); BOOST_CHECK_EQUAL( tokens[1], "" ); BOOST_CHECK_EQUAL( tokens[2], "Hello" ); s = " \tHello\r\n there"; tokens = tokenizeString( s, true, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 4 ); BOOST_CHECK_EQUAL( tokens[0], "" ); BOOST_CHECK_EQUAL( tokens[1], "" ); BOOST_CHECK_EQUAL( tokens[2], "Hello\r\n" ); BOOST_CHECK_EQUAL( tokens[3], "there" ); s = " \tHello\r\n there !"; tokens = tokenizeString( s, true, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 5 ); BOOST_CHECK_EQUAL( tokens[0], "" ); BOOST_CHECK_EQUAL( tokens[1], "" ); BOOST_CHECK_EQUAL( tokens[2], "Hello\r\n" ); BOOST_CHECK_EQUAL( tokens[3], "there" ); BOOST_CHECK_EQUAL( tokens[4], "!" ); s = " \tHello\r\n there !\r"; tokens = tokenizeString( s, true, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 5 ); BOOST_CHECK_EQUAL( tokens[0], "" ); BOOST_CHECK_EQUAL( tokens[1], "" ); BOOST_CHECK_EQUAL( tokens[2], "Hello\r\n" ); BOOST_CHECK_EQUAL( tokens[3], "there" ); BOOST_CHECK_EQUAL( tokens[4], "!\r" ); s = " \tHello\r\n there !\r"; tokens = tokenizeString( s, true, " \t\r\n" ); BOOST_CHECK_EQUAL( tokens.size(), 7 ); BOOST_CHECK_EQUAL( tokens[0], "" ); BOOST_CHECK_EQUAL( tokens[1], "" ); BOOST_CHECK_EQUAL( tokens[2], "Hello" ); BOOST_CHECK_EQUAL( tokens[3], "" ); BOOST_CHECK_EQUAL( tokens[4], "" ); BOOST_CHECK_EQUAL( tokens[5], "there" ); BOOST_CHECK_EQUAL( tokens[6], "!" ); s = ""; tokens = tokenizeString( s, false, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 0 ); s = " "; tokens = tokenizeString( s, false, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 0 ); s = " \t"; tokens = tokenizeString( s, false, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 0 ); s = " \tHello"; tokens = tokenizeString( s, false, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 1 ); BOOST_CHECK_EQUAL( tokens[0], "Hello" ); s = " \tHello\r\n there"; tokens = tokenizeString( s, false, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 2 ); BOOST_CHECK_EQUAL( tokens[0], "Hello\r\n" ); BOOST_CHECK_EQUAL( tokens[1], "there" ); s = " \tHello\r\n there !"; tokens = tokenizeString( s, false, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 3 ); BOOST_CHECK_EQUAL( tokens[0], "Hello\r\n" ); BOOST_CHECK_EQUAL( tokens[1], "there" ); BOOST_CHECK_EQUAL( tokens[2], "!" ); s = " \tHello\r\n there !\r"; tokens = tokenizeString( s, false, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 3 ); BOOST_CHECK_EQUAL( tokens[0], "Hello\r\n" ); BOOST_CHECK_EQUAL( tokens[1], "there" ); BOOST_CHECK_EQUAL( tokens[2], "!\r" ); s = " \tHello\r\n there !\r"; tokens = tokenizeString( s, false, " \t\r\n" ); BOOST_CHECK_EQUAL( tokens.size(), 3 ); BOOST_CHECK_EQUAL( tokens[0], "Hello" ); BOOST_CHECK_EQUAL( tokens[1], "there" ); BOOST_CHECK_EQUAL( tokens[2], "!" ); } libDAI-0.2.7/tests/unit/prob_test.cpp0000644000263000017630000007255611433220722016321 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; const Real tol = 1e-8; #define BOOST_TEST_MODULE ProbTest #include #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { // check constructors Prob x1; BOOST_CHECK_EQUAL( x1.size(), 0U ); BOOST_CHECK( x1.p() == Prob::container_type() ); Prob x2( 3 ); BOOST_CHECK_EQUAL( x2.size(), 3 ); BOOST_CHECK_CLOSE( x2[0], (Real)(1.0 / 3.0), tol ); BOOST_CHECK_CLOSE( x2[1], (Real)(1.0 / 3.0), tol ); BOOST_CHECK_CLOSE( x2[2], (Real)(1.0 / 3.0), tol ); Prob x3( 4, (Real)1.0 ); BOOST_CHECK_EQUAL( x3.size(), 4 ); BOOST_CHECK( x3.p() == Prob::container_type( 4, (Real)1.0 ) ); BOOST_CHECK_EQUAL( x3[0], (Real)1.0 ); BOOST_CHECK_EQUAL( x3[1], (Real)1.0 ); BOOST_CHECK_EQUAL( x3[2], (Real)1.0 ); BOOST_CHECK_EQUAL( x3[3], (Real)1.0 ); x3.set( 0, 0.5 ); x3.set( 1, 1.0 ); x3.set( 2, 2.0 ); x3.set( 3, 4.0 ); std::vector v; v.push_back( 0.5 ); v.push_back( 1.0 ); v.push_back( 2.0 ); v.push_back( 4.0 ); Prob x4( v.begin(), v.end(), 0 ); BOOST_CHECK_EQUAL( x4.size(), 4 ); BOOST_CHECK( x4.p() == x3.p() ); BOOST_CHECK( x4 == x3 ); BOOST_CHECK_EQUAL( x4[0], (Real)0.5 ); BOOST_CHECK_EQUAL( x4[1], (Real)1.0 ); BOOST_CHECK_EQUAL( x4[2], (Real)2.0 ); BOOST_CHECK_EQUAL( x4[3], (Real)4.0 ); Prob x5( v.begin(), v.end(), v.size() ); BOOST_CHECK_EQUAL( x5.size(), 4 ); BOOST_CHECK( x5.p() == x3.p() ); BOOST_CHECK( x5 == x3 ); BOOST_CHECK_EQUAL( x5[0], (Real)0.5 ); BOOST_CHECK_EQUAL( x5[1], (Real)1.0 ); BOOST_CHECK_EQUAL( x5[2], (Real)2.0 ); BOOST_CHECK_EQUAL( x5[3], (Real)4.0 ); std::vector y( 3, 2 ); Prob x6( y ); BOOST_CHECK_EQUAL( x6.size(), 3 ); BOOST_CHECK_EQUAL( x6[0], (Real)2.0 ); BOOST_CHECK_EQUAL( x6[1], (Real)2.0 ); BOOST_CHECK_EQUAL( x6[2], (Real)2.0 ); Prob x7( x6 ); BOOST_CHECK( x7 == x6 ); Prob x8 = x6; BOOST_CHECK( x8 == x6 ); x7.resize( 5 ); BOOST_CHECK_EQUAL( x7.size(), 5 ); BOOST_CHECK_EQUAL( x7[0], (Real)2.0 ); BOOST_CHECK_EQUAL( x7[1], (Real)2.0 ); BOOST_CHECK_EQUAL( x7[2], (Real)2.0 ); BOOST_CHECK_EQUAL( x7[3], (Real)0.0 ); BOOST_CHECK_EQUAL( x7[4], (Real)0.0 ); x8.resize( 1 ); BOOST_CHECK_EQUAL( x8.size(), 1 ); BOOST_CHECK_EQUAL( x8[0], (Real)2.0 ); } #ifndef DAI_SPARSE BOOST_AUTO_TEST_CASE( IteratorTest ) { Prob x( 5, 0.0 ); size_t i; for( i = 0; i < x.size(); i++ ) x.set( i, (Real)i ); i = 0; for( Prob::const_iterator cit = x.begin(); cit != x.end(); cit++, i++ ) BOOST_CHECK_EQUAL( *cit, (Real)i ); i = 0; for( Prob::iterator it = x.begin(); it != x.end(); it++, i++ ) *it = (Real)(4 - i); i = 0; for( Prob::const_iterator it = x.begin(); it != x.end(); it++, i++ ) BOOST_CHECK_EQUAL( *it, (Real)(4 - i) ); i = 0; for( Prob::const_reverse_iterator crit = x.rbegin(); crit != static_cast(x.rend()); crit++, i++ ) BOOST_CHECK_EQUAL( *crit, (Real)i ); i = 0; for( Prob::reverse_iterator rit = x.rbegin(); rit != x.rend(); rit++, i++ ) *rit = (Real)(2 * i); i = 0; for( Prob::const_reverse_iterator crit = x.rbegin(); crit != static_cast(x.rend()); crit++, i++ ) BOOST_CHECK_EQUAL( *crit, (Real)2 * i ); } #endif BOOST_AUTO_TEST_CASE( QueriesTest ) { Prob x( 5, 0.0 ); for( size_t i = 0; i < x.size(); i++ ) x.set( i, 2.0 - i ); // test accumulate, min, max, sum, sumAbs, maxAbs BOOST_CHECK_CLOSE( x.sum(), (Real)0.0, tol ); BOOST_CHECK_CLOSE( x.accumulateSum( 0.0, fo_id() ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( x.accumulateSum( 1.0, fo_id() ), (Real)1.0, tol ); BOOST_CHECK_CLOSE( x.accumulateSum( -1.0, fo_id() ), (Real)-1.0, tol ); BOOST_CHECK_CLOSE( x.max(), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( -INFINITY, fo_id(), false ), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( 3.0, fo_id(), false ), (Real)3.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( -5.0, fo_id(), false ), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.min(), (Real)-2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( INFINITY, fo_id(), true ), (Real)-2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( -3.0, fo_id(), true ), (Real)-3.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( 5.0, fo_id(), true ), (Real)-2.0, tol ); BOOST_CHECK_CLOSE( x.sumAbs(), (Real)6.0, tol ); BOOST_CHECK_CLOSE( x.accumulateSum( 0.0, fo_abs() ), (Real)6.0, tol ); BOOST_CHECK_CLOSE( x.accumulateSum( 1.0, fo_abs() ), (Real)7.0, tol ); BOOST_CHECK_CLOSE( x.accumulateSum( -1.0, fo_abs() ), (Real)7.0, tol ); BOOST_CHECK_CLOSE( x.maxAbs(), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( 0.0, fo_abs(), false ), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( 1.0, fo_abs(), false ), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( -1.0, fo_abs(), false ), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( 3.0, fo_abs(), false ), (Real)3.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( -3.0, fo_abs(), false ), (Real)3.0, tol ); x.set( 1, 1.0 ); BOOST_CHECK_CLOSE( x.maxAbs(), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( 0.0, fo_abs(), false ), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( 1.0, fo_abs(), false ), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( -1.0, fo_abs(), false ), (Real)2.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( 3.0, fo_abs(), false ), (Real)3.0, tol ); BOOST_CHECK_CLOSE( x.accumulateMax( -3.0, fo_abs(), false ), (Real)3.0, tol ); for( size_t i = 0; i < x.size(); i++ ) x.set( i, i ? (1.0 / i) : 0.0 ); BOOST_CHECK_CLOSE( x.accumulateSum( 0.0, fo_inv0() ), (Real)10.0, tol ); x /= x.sum(); // test entropy BOOST_CHECK( x.entropy() < Prob(5).entropy() ); for( size_t i = 1; i < 100; i++ ) BOOST_CHECK_CLOSE( Prob(i).entropy(), dai::log((Real)i), tol ); // test hasNaNs and hasNegatives BOOST_CHECK( !Prob( 3, 0.0 ).hasNaNs() ); Real c = 0.0; BOOST_CHECK( Prob( 3, c / c ).hasNaNs() ); BOOST_CHECK( !Prob( 3, 0.0 ).hasNegatives() ); BOOST_CHECK( !Prob( 3, 1.0 ).hasNegatives() ); BOOST_CHECK( Prob( 3, -1.0 ).hasNegatives() ); x.set( 0, 0.0 ); x.set( 1, 0.0 ); x.set( 2, -1.0 ); x.set( 3, 1.0 ); x.set( 4, 100.0 ); BOOST_CHECK( x.hasNegatives() ); x.set( 2, -INFINITY ); BOOST_CHECK( x.hasNegatives() ); x.set( 2, INFINITY ); BOOST_CHECK( !x.hasNegatives() ); x.set( 2, -1.0 ); // test argmax BOOST_CHECK( x.argmax() == std::make_pair( (size_t)4, (Real)100.0 ) ); x.set( 4, 0.5 ); BOOST_CHECK( x.argmax() == std::make_pair( (size_t)3, (Real)1.0 ) ); x.set( 3, -2.0 ); BOOST_CHECK( x.argmax() == std::make_pair( (size_t)4, (Real)0.5 ) ); x.set( 4, -1.0 ); BOOST_CHECK( x.argmax() == std::make_pair( (size_t)0, (Real)0.0 ) ); x.set( 0, -2.0 ); BOOST_CHECK( x.argmax() == std::make_pair( (size_t)1, (Real)0.0 ) ); x.set( 1, -3.0 ); BOOST_CHECK( x.argmax() == std::make_pair( (size_t)2, (Real)-1.0 ) ); x.set( 2, -2.0 ); BOOST_CHECK( x.argmax() == std::make_pair( (size_t)4, (Real)-1.0 ) ); // test draw for( size_t i = 0; i < x.size(); i++ ) x.set( i, i ? (1.0 / i) : 0.0 ); for( size_t repeat = 0; repeat < 10000; repeat++ ) { BOOST_CHECK( x.draw() < x.size() ); BOOST_CHECK( x.draw() != 0 ); } x.set( 2, 0.0 ); for( size_t repeat = 0; repeat < 10000; repeat++ ) { BOOST_CHECK( x.draw() < x.size() ); BOOST_CHECK( x.draw() != 0 ); BOOST_CHECK( x.draw() != 2 ); } x.set( 4, 0.0 ); for( size_t repeat = 0; repeat < 10000; repeat++ ) { BOOST_CHECK( x.draw() < x.size() ); BOOST_CHECK( x.draw() != 0 ); BOOST_CHECK( x.draw() != 2 ); BOOST_CHECK( x.draw() != 4 ); } x.set( 1, 0.0 ); for( size_t repeat = 0; repeat < 10000; repeat++ ) BOOST_CHECK( x.draw() == 3 ); // test <, == Prob a(3, 1.0), b(3, 1.0); BOOST_CHECK( !(a < b) ); BOOST_CHECK( !(b < a) ); BOOST_CHECK( a == b ); a.set( 0, 0.0 ); BOOST_CHECK( a < b ); BOOST_CHECK( !(b < a) ); BOOST_CHECK( !(a == b) ); b.set( 2, 0.0 ); BOOST_CHECK( a < b ); BOOST_CHECK( !(b < a) ); BOOST_CHECK( !(a == b) ); b.set( 0, 0.0 ); BOOST_CHECK( !(a < b) ); BOOST_CHECK( b < a ); BOOST_CHECK( !(a == b) ); a.set( 1, 0.0 ); BOOST_CHECK( a < b ); BOOST_CHECK( !(b < a) ); BOOST_CHECK( !(a == b) ); b.set( 1, 0.0 ); BOOST_CHECK( !(a < b) ); BOOST_CHECK( b < a ); BOOST_CHECK( !(a == b) ); a.set( 2, 0.0 ); BOOST_CHECK( !(a < b) ); BOOST_CHECK( !(b < a) ); BOOST_CHECK( a == b ); } BOOST_AUTO_TEST_CASE( UnaryTransformationsTest ) { Prob x( 3 ); x.set( 0, -2.0 ); x.set( 1, 0.0 ); x.set( 2, 2.0 ); Prob y = -x; Prob z = x.pwUnaryTr( std::negate() ); BOOST_CHECK_CLOSE( y[0], (Real)2.0, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)-2.0, tol ); BOOST_CHECK( y == z ); y = x.abs(); z = x.pwUnaryTr( fo_abs() ); BOOST_CHECK_CLOSE( y[0], (Real)2.0, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)2.0, tol ); BOOST_CHECK( y == z ); y = x.exp(); z = x.pwUnaryTr( fo_exp() ); BOOST_CHECK_CLOSE( y[0], dai::exp((Real)-2.0), tol ); BOOST_CHECK_CLOSE( y[1], (Real)1.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)1.0 / y[0], tol ); BOOST_CHECK( y == z ); y = x.log(false); z = x.pwUnaryTr( fo_log() ); BOOST_CHECK( dai::isnan( y[0] ) ); BOOST_CHECK_EQUAL( y[1], -INFINITY ); BOOST_CHECK_CLOSE( y[2], dai::log((Real)2.0), tol ); BOOST_CHECK( !(y == z) ); y.set( 0, 0.0 ); z.set( 0, 0.0 ); BOOST_CHECK( y == z ); y = x.log(true); z = x.pwUnaryTr( fo_log0() ); BOOST_CHECK( dai::isnan( y[0] ) ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], dai::log((Real)2.0), tol ); BOOST_CHECK( !(y == z) ); y.set( 0, 0.0 ); z.set( 0, 0.0 ); BOOST_CHECK( y == z ); y = x.inverse(false); z = x.pwUnaryTr( fo_inv() ); BOOST_CHECK_CLOSE( y[0], (Real)-0.5, tol ); BOOST_CHECK_EQUAL( y[1], INFINITY ); BOOST_CHECK_CLOSE( y[2], (Real)0.5, tol ); BOOST_CHECK( y == z ); y = x.inverse(true); z = x.pwUnaryTr( fo_inv0() ); BOOST_CHECK_CLOSE( y[0], (Real)-0.5, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)0.5, tol ); BOOST_CHECK( y == z ); x.set( 0, 2.0 ); y = x.normalized(); BOOST_CHECK_CLOSE( y[0], (Real)0.5, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)0.5, tol ); y = x.normalized( NORMPROB ); BOOST_CHECK_CLOSE( y[0], (Real)0.5, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)0.5, tol ); x.set( 0, -2.0 ); y = x.normalized( NORMLINF ); BOOST_CHECK_CLOSE( y[0], (Real)-1.0, tol ); BOOST_CHECK_CLOSE( y[1], (Real)0.0, tol ); BOOST_CHECK_CLOSE( y[2], (Real)1.0, tol ); } BOOST_AUTO_TEST_CASE( UnaryOperationsTest ) { Prob xorg(3); xorg.set( 0, 2.0 ); xorg.set( 1, 0.0 ); xorg.set( 2, 1.0 ); Prob y(3); Prob x = xorg; BOOST_CHECK( x.setUniform() == Prob(3) ); BOOST_CHECK( x == Prob(3) ); y.set( 0, dai::exp(2.0) ); y.set( 1, 1.0 ); y.set( 2, dai::exp(1.0) ); x = xorg; BOOST_CHECK_SMALL( dist( x.takeExp(), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; BOOST_CHECK_SMALL( dist( x.pwUnaryOp( fo_exp() ), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, dai::log(2.0) ); y.set( 1, -INFINITY ); y.set( 2, 0.0 ); x = xorg; Prob z = x.takeLog(); BOOST_CHECK_CLOSE( z[0], y[0], tol ); // BOOST_CHECK_CLOSE( z[1], y[1], tol ); BOOST_CHECK_CLOSE( z[2], y[2], tol ); BOOST_CHECK( x == z ); x = xorg; z = x.takeLog(false); BOOST_CHECK_CLOSE( z[0], y[0], tol ); // BOOST_CHECK_CLOSE( z[1], y[1], tol ); BOOST_CHECK_CLOSE( z[2], y[2], tol ); BOOST_CHECK( x == z ); x = xorg; z = x.pwUnaryOp( fo_log() ); BOOST_CHECK_CLOSE( z[0], y[0], tol ); // BOOST_CHECK_CLOSE( z[1], y[1], tol ); BOOST_CHECK_CLOSE( z[2], y[2], tol ); BOOST_CHECK( x == z ); y.set( 1, 0.0 ); x = xorg; BOOST_CHECK_SMALL( dist( x.takeLog(true), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; BOOST_CHECK_SMALL( dist( x.pwUnaryOp( fo_log0() ), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 2.0 / 3.0 ); y.set( 1, 0.0 / 3.0 ); y.set( 2, 1.0 / 3.0 ); x = xorg; BOOST_CHECK_CLOSE( x.normalize(), (Real)3.0, tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; BOOST_CHECK_CLOSE( x.normalize( NORMPROB ), (Real)3.0, tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 2.0 / 2.0 ); y.set( 1, 0.0 / 2.0 ); y.set( 2, 1.0 / 2.0 ); x = xorg; BOOST_CHECK_CLOSE( x.normalize( NORMLINF ), (Real)2.0, tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); xorg.set( 0, -2.0 ); y.set( 0, 2.0 ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); x = xorg; BOOST_CHECK( x.takeAbs() == y ); BOOST_CHECK( x == y ); for( size_t repeat = 0; repeat < 10000; repeat++ ) { x.randomize(); for( size_t i = 0; i < x.size(); i++ ) { BOOST_CHECK( x[i] < (Real)1.0 ); BOOST_CHECK( x[i] >= (Real)0.0 ); } } } BOOST_AUTO_TEST_CASE( ScalarTransformationsTest ) { Prob x(3); x.set( 0, 2.0 ); x.set( 1, 0.0 ); x.set( 2, 1.0 ); Prob y(3); y.set( 0, 3.0 ); y.set( 1, 1.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x + 1.0), y, DISTL1 ), tol ); y.set( 0, 0.0 ); y.set( 1, -2.0 ); y.set( 2, -1.0 ); BOOST_CHECK_SMALL( dist( (x + (-2.0)), y, DISTL1 ), tol ); y.set( 0, 1.0 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); BOOST_CHECK_SMALL( dist( (x - 1.0), y, DISTL1 ), tol ); y.set( 0, 4.0 ); y.set( 1, 2.0 ); y.set( 2, 3.0 ); BOOST_CHECK_SMALL( dist( (x - (-2.0)), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( (x * 1.0), x, DISTL1 ), tol ); y.set( 0, 4.0 ); y.set( 1, 0.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x * 2.0), y, DISTL1 ), tol ); y.set( 0, -1.0 ); y.set( 1, 0.0 ); y.set( 2, -0.5 ); BOOST_CHECK_SMALL( dist( (x * -0.5), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( (x / 1.0), x, DISTL1 ), tol ); y.set( 0, 1.0 ); y.set( 1, 0.0 ); y.set( 2, 0.5 ); BOOST_CHECK_SMALL( dist( (x / 2.0), y, DISTL1 ), tol ); y.set( 0, -4.0 ); y.set( 1, 0.0 ); y.set( 2, -2.0 ); BOOST_CHECK_SMALL( dist( (x / -0.5), y, DISTL1 ), tol ); BOOST_CHECK( (x / 0.0) == Prob(3, 0.0) ); BOOST_CHECK( (x ^ 1.0) == x ); BOOST_CHECK( (x ^ 0.0) == Prob(3, 1.0) ); y.set( 0, 4.0 ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); BOOST_CHECK_SMALL( dist( (x ^ 2.0), y, DISTL1 ), tol ); y.set( 0, std::sqrt(2.0) ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); BOOST_CHECK_SMALL( dist( (x ^ 0.5), y, DISTL1 ), tol ); } BOOST_AUTO_TEST_CASE( ScalarOperationsTest ) { Prob xorg(3), x(3); xorg.set( 0, 2.0 ); xorg.set( 1, 0.0 ); xorg.set( 2, 1.0 ); Prob y(3); x = xorg; BOOST_CHECK( x.fill( 1.0 ) == Prob(3, 1.0) ); BOOST_CHECK( x == Prob(3, 1.0) ); BOOST_CHECK( x.fill( 2.0 ) == Prob(3, 2.0) ); BOOST_CHECK( x == Prob(3, 2.0) ); BOOST_CHECK( x.fill( 0.0 ) == Prob(3, 0.0) ); BOOST_CHECK( x == Prob(3, 0.0) ); x = xorg; y.set( 0, 3.0 ); y.set( 1, 1.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x += 1.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 1.0 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); BOOST_CHECK_SMALL( dist( (x += -2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; y.set( 0, 1.0 ); y.set( 1, -1.0 ); y.set( 2, 0.0 ); BOOST_CHECK_SMALL( dist( (x -= 1.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 3.0 ); y.set( 1, 1.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x -= -2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; BOOST_CHECK_SMALL( dist( (x *= 1.0), x, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, x, DISTL1 ), tol ); y.set( 0, 4.0 ); y.set( 1, 0.0 ); y.set( 2, 2.0 ); BOOST_CHECK_SMALL( dist( (x *= 2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, -1.0 ); y.set( 1, 0.0 ); y.set( 2, -0.5 ); BOOST_CHECK_SMALL( dist( (x *= -0.25), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); x = xorg; BOOST_CHECK_SMALL( dist( (x /= 1.0), x, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, x, DISTL1 ), tol ); y.set( 0, 1.0 ); y.set( 1, 0.0 ); y.set( 2, 0.5 ); BOOST_CHECK_SMALL( dist( (x /= 2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, -4.0 ); y.set( 1, 0.0 ); y.set( 2, -2.0 ); BOOST_CHECK_SMALL( dist( (x /= -0.25), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); BOOST_CHECK( (x /= 0.0) == Prob(3, 0.0) ); BOOST_CHECK( x == Prob(3, 0.0) ); x = xorg; BOOST_CHECK( (x ^= 1.0) == x ); BOOST_CHECK( x == x ); BOOST_CHECK( (x ^= 0.0) == Prob(3, 1.0) ); BOOST_CHECK( x == Prob(3, 1.0) ); x = xorg; y.set( 0, 4.0 ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); BOOST_CHECK_SMALL( dist( (x ^= 2.0), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); y.set( 0, 2.0 ); y.set( 1, 0.0 ); y.set( 2, 1.0 ); BOOST_CHECK_SMALL( dist( (x ^= 0.5), y, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( x, y, DISTL1 ), tol ); } BOOST_AUTO_TEST_CASE( VectorOperationsTest ) { size_t N = 6; Prob xorg(N), x(N); xorg.set( 0, 2.0 ); xorg.set( 1, 0.0 ); xorg.set( 2, 1.0 ); xorg.set( 3, 0.0 ); xorg.set( 4, 2.0 ); xorg.set( 5, 3.0 ); Prob y(N); y.set( 0, 0.5 ); y.set( 1, 1.0 ); y.set( 2, 0.0 ); y.set( 3, 0.0 ); y.set( 4, -2.0 ); y.set( 5, 3.0 ); Prob z(N), r(N); z.set( 0, 2.5 ); z.set( 1, 1.0 ); z.set( 2, 1.0 ); z.set( 3, 0.0 ); z.set( 4, 0.0 ); z.set( 5, 6.0 ); x = xorg; r = (x += y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK_SMALL( dist( x, z, DISTL1 ), tol ); x = xorg; BOOST_CHECK( x.pwBinaryOp( y, std::plus() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 1.5 ); z.set( 1, -1.0 ); z.set( 2, 1.0 ); z.set( 3, 0.0 ); z.set( 4, 4.0 ); z.set( 5, 0.0 ); x = xorg; r = (x -= y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK_SMALL( dist( x, z, DISTL1 ), tol ); x = xorg; BOOST_CHECK( x.pwBinaryOp( y, std::minus() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 1.0 ); z.set( 1, 0.0 ); z.set( 2, 0.0 ); z.set( 3, 0.0 ); z.set( 4, -4.0 ); z.set( 5, 9.0 ); x = xorg; r = (x *= y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK_SMALL( dist( x, z, DISTL1 ), tol ); x = xorg; BOOST_CHECK( x.pwBinaryOp( y, std::multiplies() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 4.0 ); z.set( 1, 0.0 ); z.set( 2, 0.0 ); z.set( 3, 0.0 ); z.set( 4, -1.0 ); z.set( 5, 1.0 ); x = xorg; r = (x /= y); for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK_SMALL( dist( x, z, DISTL1 ), tol ); x = xorg; BOOST_CHECK( x.pwBinaryOp( y, fo_divides0() ) == r ); BOOST_CHECK( x == r ); z.set( 0, 4.0 ); z.set( 1, 0.0 ); z.set( 2, INFINITY ); /*z.set( 3, INFINITY );*/ z.set( 4, -1.0 ); z.set( 5, 1.0 ); x = xorg; r = (x.divide( y )); BOOST_CHECK_CLOSE( r[0], z[0], tol ); BOOST_CHECK_CLOSE( r[1], z[1], tol ); BOOST_CHECK_EQUAL( r[2], z[2] ); BOOST_CHECK( dai::isnan(r[3]) ); BOOST_CHECK_CLOSE( r[4], z[4], tol ); BOOST_CHECK_CLOSE( r[5], z[5], tol ); x.set( 3, 0.0 ); r.set( 3, 0.0 ); BOOST_CHECK( x == r ); x = xorg; r = x.pwBinaryOp( y, std::divides() ); BOOST_CHECK_CLOSE( r[0], z[0], tol ); BOOST_CHECK_CLOSE( r[1], z[1], tol ); BOOST_CHECK_EQUAL( r[2], z[2] ); BOOST_CHECK( dai::isnan(r[3]) ); BOOST_CHECK_CLOSE( r[4], z[4], tol ); BOOST_CHECK_CLOSE( r[5], z[5], tol ); x.set( 3, 0.0 ); r.set( 3, 0.0 ); BOOST_CHECK( x == r ); z.set( 0, std::sqrt(2.0) ); z.set( 1, 0.0 ); z.set( 2, 1.0 ); z.set( 3, 1.0 ); z.set( 4, 0.25 ); z.set( 5, 27.0 ); x = xorg; r = (x ^= y); for( size_t i = 0; i < 6; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); x = xorg; r = x.pwBinaryOp( y, fo_pow() ); for( size_t i = 0; i < 6; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); BOOST_CHECK( x == r ); } BOOST_AUTO_TEST_CASE( VectorTransformationsTest ) { size_t N = 6; Prob x(N); x.set( 0, 2.0 ); x.set( 1, 0.0 ); x.set( 2, 1.0 ); x.set( 3, 0.0 ); x.set( 4, 2.0 ); x.set( 5, 3.0 ); Prob y(N); y.set( 0, 0.5 ); y.set( 1, 1.0 ); y.set( 2, 0.0 ); y.set( 3, 0.0 ); y.set( 4, -2.0 ); y.set( 5, 3.0 ); Prob z(N), r(N); z.set( 0, 2.5 ); z.set( 1, 1.0 ); z.set( 2, 1.0 ); z.set( 3, 0.0 ); z.set( 4, 0.0 ); z.set( 5, 6.0 ); r = x + y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.pwBinaryTr( y, std::plus() ); BOOST_CHECK( r == z ); z.set( 0, 1.5 ); z.set( 1, -1.0 ); z.set( 2, 1.0 ); z.set( 3, 0.0 ); z.set( 4, 4.0 ); z.set( 5, 0.0 ); r = x - y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.pwBinaryTr( y, std::minus() ); BOOST_CHECK( r == z ); z.set( 0, 1.0 ); z.set( 1, 0.0 ); z.set( 2, 0.0 ); z.set( 3, 0.0 ); z.set( 4, -4.0 ); z.set( 5, 9.0 ); r = x * y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.pwBinaryTr( y, std::multiplies() ); BOOST_CHECK( r == z ); z.set( 0, 4.0 ); z.set( 1, 0.0 ); z.set( 2, 0.0 ); z.set( 3, 0.0 ); z.set( 4, -1.0 ); z.set( 5, 1.0 ); r = x / y; for( size_t i = 0; i < N; i++ ) BOOST_CHECK_CLOSE( r[i], z[i], tol ); z = x.pwBinaryTr( y, fo_divides0() ); BOOST_CHECK( r == z ); z.set( 0, 4.0 ); z.set( 1, 0.0 ); z.set( 2, INFINITY ); /*z.set( 3, INFINITY );*/ z.set( 4, -1.0 ); z.set( 5, 1.0 ); r = x.divided_by( y ); BOOST_CHECK_CLOSE( r[0], z[0], tol ); BOOST_CHECK_CLOSE( r[1], z[1], tol ); BOOST_CHECK_EQUAL( r[2], z[2] ); BOOST_CHECK( dai::isnan(r[3]) ); BOOST_CHECK_CLOSE( r[4], z[4], tol ); BOOST_CHECK_CLOSE( r[5], z[5], tol ); z = x.pwBinaryTr( y, std::divides() ); BOOST_CHECK_CLOSE( r[0], z[0], tol ); BOOST_CHECK_CLOSE( r[1], z[1], tol ); BOOST_CHECK_EQUAL( r[2], z[2] ); BOOST_CHECK( dai::isnan(r[3]) ); BOOST_CHECK_CLOSE( r[4], z[4], tol ); BOOST_CHECK_CLOSE( r[5], z[5], tol ); z.set( 0, std::sqrt(2.0) ); z.set( 1, 0.0 ); z.set( 2, 1.0 ); z.set( 3, 1.0 ); z.set( 4, 0.25 ); z.set( 5, 27.0 ); r = x ^ y; BOOST_CHECK_CLOSE( r[0], z[0], tol ); BOOST_CHECK_CLOSE( r[1], z[1], tol ); BOOST_CHECK_CLOSE( r[2], z[2], tol ); BOOST_CHECK_CLOSE( r[3], z[3], tol ); BOOST_CHECK_CLOSE( r[4], z[4], tol ); BOOST_CHECK_CLOSE( r[5], z[5], tol ); z = x.pwBinaryTr( y, fo_pow() ); BOOST_CHECK( r == z ); } BOOST_AUTO_TEST_CASE( RelatedFunctionsTest ) { Prob x(3), y(3), z(3); x.set( 0, 0.2 ); x.set( 1, 0.8 ); x.set( 2, 0.0 ); y.set( 0, 0.0 ); y.set( 1, 0.6 ); y.set( 2, 0.4 ); z = min( x, y ); BOOST_CHECK_EQUAL( z[0], (Real)0.0 ); BOOST_CHECK_EQUAL( z[1], (Real)0.6 ); BOOST_CHECK_EQUAL( z[2], (Real)0.0 ); z = max( x, y ); BOOST_CHECK_EQUAL( z[0], (Real)0.2 ); BOOST_CHECK_EQUAL( z[1], (Real)0.8 ); BOOST_CHECK_EQUAL( z[2], (Real)0.4 ); BOOST_CHECK_CLOSE( dist( x, x, DISTL1 ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTL1 ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTL1 ), (Real)(0.2 + 0.2 + 0.4), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTL1 ), (Real)(0.2 + 0.2 + 0.4), tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTL1 ), x.innerProduct( y, 0.0, std::plus(), fo_absdiff() ), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTL1 ), y.innerProduct( x, 0.0, std::plus(), fo_absdiff() ), tol ); BOOST_CHECK_CLOSE( dist( x, x, DISTLINF ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTLINF ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTLINF ), (Real)0.4, tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTLINF ), (Real)0.4, tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTLINF ), x.innerProduct( y, 0.0, fo_max(), fo_absdiff() ), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTLINF ), y.innerProduct( x, 0.0, fo_max(), fo_absdiff() ), tol ); BOOST_CHECK_CLOSE( dist( x, x, DISTTV ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTTV ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTTV ), (Real)(0.5 * (0.2 + 0.2 + 0.4)), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTTV ), (Real)(0.5 * (0.2 + 0.2 + 0.4)), tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTTV ), x.innerProduct( y, 0.0, std::plus(), fo_absdiff() ) / 2.0, tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTTV ), y.innerProduct( x, 0.0, std::plus(), fo_absdiff() ) / 2.0, tol ); BOOST_CHECK_CLOSE( dist( x, x, DISTKL ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTKL ), (Real)0.0, tol ); BOOST_CHECK_EQUAL( dist( x, y, DISTKL ), INFINITY ); BOOST_CHECK_EQUAL( dist( y, x, DISTKL ), INFINITY ); BOOST_CHECK_EQUAL( dist( x, y, DISTKL ), x.innerProduct( y, 0.0, std::plus(), fo_KL() ) ); BOOST_CHECK_EQUAL( dist( y, x, DISTKL ), y.innerProduct( x, 0.0, std::plus(), fo_KL() ) ); BOOST_CHECK_CLOSE( dist( x, x, DISTHEL ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( y, y, DISTHEL ), (Real)0.0, tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTHEL ), (Real)(0.5 * (0.2 + dai::pow(std::sqrt(0.8) - std::sqrt(0.6), 2.0) + 0.4)), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTHEL ), (Real)(0.5 * (0.2 + dai::pow(std::sqrt(0.8) - std::sqrt(0.6), 2.0) + 0.4)), tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTHEL ), x.innerProduct( y, 0.0, std::plus(), fo_Hellinger() ) / 2.0, tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTHEL ), y.innerProduct( x, 0.0, std::plus(), fo_Hellinger() ) / 2.0, tol ); x.set( 1, 0.7 ); x.set( 2, 0.1 ); y.set( 0, 0.1 ); y.set( 1, 0.5 ); BOOST_CHECK_CLOSE( dist( x, y, DISTKL ), (Real)(0.2 * dai::log(0.2 / 0.1) + 0.7 * dai::log(0.7 / 0.5) + 0.1 * dai::log(0.1 / 0.4)), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTKL ), (Real)(0.1 * dai::log(0.1 / 0.2) + 0.5 * dai::log(0.5 / 0.7) + 0.4 * dai::log(0.4 / 0.1)), tol ); BOOST_CHECK_CLOSE( dist( x, y, DISTKL ), x.innerProduct( y, 0.0, std::plus(), fo_KL() ), tol ); BOOST_CHECK_CLOSE( dist( y, x, DISTKL ), y.innerProduct( x, 0.0, std::plus(), fo_KL() ), tol ); Prob xx(4), yy(4); for( size_t i = 0; i < 3; i++ ) { xx.set( i, x[i] ); yy.set( i, y[i] ); } std::stringstream ss; ss << xx; std::string s; std::getline( ss, s ); #ifdef DAI_SPARSE BOOST_CHECK_EQUAL( s, std::string("(size:4, def:0.25, 0:0.2, 1:0.7, 2:0.1)") ); #else BOOST_CHECK_EQUAL( s, std::string("(0.2, 0.7, 0.1, 0.25)") ); #endif std::stringstream ss2; ss2 << yy; std::getline( ss2, s ); #ifdef DAI_SPARSE BOOST_CHECK_EQUAL( s, std::string("(size:4, def:0.25, 0:0.1, 1:0.5, 2:0.4)") ); #else BOOST_CHECK_EQUAL( s, std::string("(0.1, 0.5, 0.4, 0.25)") ); #endif z = min( x, y ); BOOST_CHECK_EQUAL( z[0], (Real)0.1 ); BOOST_CHECK_EQUAL( z[1], (Real)0.5 ); BOOST_CHECK_EQUAL( z[2], (Real)0.1 ); z = max( x, y ); BOOST_CHECK_EQUAL( z[0], (Real)0.2 ); BOOST_CHECK_EQUAL( z[1], (Real)0.7 ); BOOST_CHECK_EQUAL( z[2], (Real)0.4 ); BOOST_CHECK_CLOSE( x.innerProduct( y, 0.0, std::plus(), std::multiplies() ), (Real)(0.2*0.1 + 0.7*0.5 + 0.1*0.4), tol ); BOOST_CHECK_CLOSE( y.innerProduct( x, 0.0, std::plus(), std::multiplies() ), (Real)(0.2*0.1 + 0.7*0.5 + 0.1*0.4), tol ); BOOST_CHECK_CLOSE( x.innerProduct( y, 1.0, std::plus(), std::multiplies() ), (Real)(1.0 + 0.2*0.1 + 0.7*0.5 + 0.1*0.4), tol ); BOOST_CHECK_CLOSE( y.innerProduct( x, 1.0, std::plus(), std::multiplies() ), (Real)(1.0 + 0.2*0.1 + 0.7*0.5 + 0.1*0.4), tol ); BOOST_CHECK_CLOSE( x.innerProduct( y, -1.0, std::plus(), std::multiplies() ), (Real)(-1.0 + 0.2*0.1 + 0.7*0.5 + 0.1*0.4), tol ); BOOST_CHECK_CLOSE( y.innerProduct( x, -1.0, std::plus(), std::multiplies() ), (Real)(-1.0 + 0.2*0.1 + 0.7*0.5 + 0.1*0.4), tol ); } libDAI-0.2.7/tests/unit/bipgraph_test.cpp0000644000263000017630000003631611433220722017145 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; #define BOOST_TEST_MODULE BipartiteGraphTest #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { // check constructors BipartiteGraph G; BOOST_CHECK_EQUAL( G.nrNodes1(), 0 ); BOOST_CHECK_EQUAL( G.nrNodes2(), 0 ); BOOST_CHECK_EQUAL( G.nrEdges(), 0 ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); G.checkConsistency(); BipartiteGraph G1( 2, 3 ); BOOST_CHECK_EQUAL( G1.nrNodes1(), 2 ); BOOST_CHECK_EQUAL( G1.nrNodes2(), 3 ); BOOST_CHECK_EQUAL( G1.nrEdges(), 0 ); BOOST_CHECK( !G1.isConnected() ); BOOST_CHECK( !G1.isTree() ); BOOST_CHECK( !(G1 == G) ); G1.checkConsistency(); std::vector edges; edges.push_back( Edge(0, 0) ); edges.push_back( Edge(0, 1) ); edges.push_back( Edge(1, 1) ); edges.push_back( Edge(1, 2) ); edges.push_back( Edge(1, 2) ); BipartiteGraph G2( 2, 3, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G2.nrNodes1(), 2 ); BOOST_CHECK_EQUAL( G2.nrNodes2(), 3 ); BOOST_CHECK_EQUAL( G2.nrEdges(), 4 ); BOOST_CHECK( G2.isConnected() ); BOOST_CHECK( G2.isTree() ); BOOST_CHECK( !(G2 == G) ); BOOST_CHECK( !(G2 == G1) ); G2.checkConsistency(); edges.push_back( Edge(1, 0) ); BipartiteGraph G3( 2, 3, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G3.nrNodes1(), 2 ); BOOST_CHECK_EQUAL( G3.nrNodes2(), 3 ); BOOST_CHECK_EQUAL( G3.nrEdges(), 5 ); BOOST_CHECK( G3.isConnected() ); BOOST_CHECK( !G3.isTree() ); BOOST_CHECK( !(G3 == G) ); BOOST_CHECK( !(G3 == G1) ); BOOST_CHECK( !(G3 == G2) ); G3.checkConsistency(); BipartiteGraph G4( 3, 3, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G4.nrNodes1(), 3 ); BOOST_CHECK_EQUAL( G4.nrNodes2(), 3 ); BOOST_CHECK_EQUAL( G4.nrEdges(), 5 ); BOOST_CHECK( !G4.isConnected() ); BOOST_CHECK( !G4.isTree() ); BOOST_CHECK( !(G4 == G) ); BOOST_CHECK( !(G4 == G1) ); BOOST_CHECK( !(G4 == G2) ); BOOST_CHECK( !(G4 == G3) ); G4.checkConsistency(); G.construct( 3, 3, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G.nrNodes1(), 3 ); BOOST_CHECK_EQUAL( G.nrNodes2(), 3 ); BOOST_CHECK_EQUAL( G.nrEdges(), 5 ); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); BOOST_CHECK( !(G == G1) ); BOOST_CHECK( !(G == G2) ); BOOST_CHECK( !(G == G3) ); BOOST_CHECK( G == G4 ); G.checkConsistency(); BipartiteGraph G5( G4 ); BOOST_CHECK( G5 == G4 ); BipartiteGraph G6 = G4; BOOST_CHECK( G6 == G4 ); } BOOST_AUTO_TEST_CASE( NeighborTest ) { // check nb() accessor / mutator std::vector edges; edges.push_back( Edge(0, 0) ); edges.push_back( Edge(0, 1) ); edges.push_back( Edge(1, 1) ); edges.push_back( Edge(1, 2) ); BipartiteGraph G( 2, 3, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G.nb1(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nb1(1).size(), 2 ); BOOST_CHECK_EQUAL( G.nb2(0).size(), 1 ); BOOST_CHECK_EQUAL( G.nb2(1).size(), 2 ); BOOST_CHECK_EQUAL( G.nb2(2).size(), 1 ); BOOST_CHECK_EQUAL( G.nb1(0,0).iter, 0 ); BOOST_CHECK_EQUAL( G.nb1(0,0).node, 0 ); BOOST_CHECK_EQUAL( G.nb1(0,0).dual, 0 ); BOOST_CHECK_EQUAL( G.nb1(0,1).iter, 1 ); BOOST_CHECK_EQUAL( G.nb1(0,1).node, 1 ); BOOST_CHECK_EQUAL( G.nb1(0,1).dual, 0 ); BOOST_CHECK_EQUAL( G.nb1(1,0).iter, 0 ); BOOST_CHECK_EQUAL( G.nb1(1,0).node, 1 ); BOOST_CHECK_EQUAL( G.nb1(1,0).dual, 1 ); BOOST_CHECK_EQUAL( G.nb1(1,1).iter, 1 ); BOOST_CHECK_EQUAL( G.nb1(1,1).node, 2 ); BOOST_CHECK_EQUAL( G.nb1(1,1).dual, 0 ); BOOST_CHECK_EQUAL( G.nb2(0,0).iter, 0 ); BOOST_CHECK_EQUAL( G.nb2(0,0).node, 0 ); BOOST_CHECK_EQUAL( G.nb2(0,0).dual, 0 ); BOOST_CHECK_EQUAL( G.nb2(1,0).iter, 0 ); BOOST_CHECK_EQUAL( G.nb2(1,0).node, 0 ); BOOST_CHECK_EQUAL( G.nb2(1,0).dual, 1 ); BOOST_CHECK_EQUAL( G.nb2(1,1).iter, 1 ); BOOST_CHECK_EQUAL( G.nb2(1,1).node, 1 ); BOOST_CHECK_EQUAL( G.nb2(1,1).dual, 0 ); BOOST_CHECK_EQUAL( G.nb2(2,0).iter, 0 ); BOOST_CHECK_EQUAL( G.nb2(2,0).node, 1 ); BOOST_CHECK_EQUAL( G.nb2(2,0).dual, 1 ); BOOST_CHECK_EQUAL( G.nb1Set(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nb1Set(1).size(), 2 ); BOOST_CHECK_EQUAL( G.nb2Set(0).size(), 1 ); BOOST_CHECK_EQUAL( G.nb2Set(1).size(), 2 ); BOOST_CHECK_EQUAL( G.nb2Set(2).size(), 1 ); BOOST_CHECK( G.nb1Set(0) == SmallSet( 0, 1 ) ); BOOST_CHECK( G.nb1Set(1) == SmallSet( 1, 2 ) ); BOOST_CHECK( G.nb2Set(0) == SmallSet( 0 ) ); BOOST_CHECK( G.nb2Set(1) == SmallSet( 0, 1 ) ); BOOST_CHECK( G.nb2Set(2) == SmallSet( 1 ) ); } BOOST_AUTO_TEST_CASE( AddEraseTest ) { // check addition and erasure of nodes and edges std::vector edges; edges.push_back( Edge( 0, 0 ) ); edges.push_back( Edge( 0, 1 ) ); edges.push_back( Edge( 1, 1 ) ); BipartiteGraph G( 2, 2, edges.begin(), edges.end() ); G.checkConsistency(); BOOST_CHECK_EQUAL( G.nrNodes1(), 2 ); BOOST_CHECK_EQUAL( G.nrNodes2(), 2 ); BOOST_CHECK_EQUAL( G.nrEdges(), 3 ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); BOOST_CHECK_EQUAL( G.addNode1(), 2 ); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); BOOST_CHECK_EQUAL( G.addNode2(), 2 ); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); BOOST_CHECK_EQUAL( G.addNode1(), 3 ); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); G.checkConsistency(); std::vector nbs; nbs.push_back( 2 ); nbs.push_back( 0 ); BOOST_CHECK_EQUAL( G.addNode1( nbs.begin(), nbs.end() ), 4 ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); BOOST_CHECK_EQUAL( G.addNode2( nbs.begin(), nbs.end() ), 3 ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); G.addEdge( 3, 3 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); G.addEdge( 1, 3 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( !G.isTree() ); BOOST_CHECK_EQUAL( G.nrNodes1(), 5 ); BOOST_CHECK_EQUAL( G.nrNodes2(), 4 ); BOOST_CHECK_EQUAL( G.nrEdges(), 9 ); G.eraseEdge( 0, 3 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); G.eraseEdge( 4, 2 ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); G.eraseNode2( 2 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); G.eraseNode1( 0 ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); G.addEdge( 1, 0 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); G.eraseNode1( 2 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); G.eraseNode2( 2 ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); G.addEdge( 1, 1 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); G.eraseNode2( 1 ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); G.eraseNode1( 1 ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); G.addEdge( 0, 0 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); G.eraseNode2( 0 ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); BOOST_CHECK( !G.isTree() ); G.eraseNode1( 0 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); G.eraseNode1( 0 ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); BOOST_CHECK_EQUAL( G.nrNodes1(), 0 ); BOOST_CHECK_EQUAL( G.nrNodes2(), 0 ); BOOST_CHECK_EQUAL( G.nrEdges(), 0 ); } BOOST_AUTO_TEST_CASE( RandomAddEraseTest ) { // check adding and erasing nodes and edges randomly BipartiteGraph G; for( size_t maxN1 = 2; maxN1 < 10; maxN1++ ) for( size_t maxN2 = 2; maxN2 < 10; maxN2++ ) for( size_t repeats = 0; repeats < 100000; repeats++ ) { size_t action = rnd( 5 ); size_t N1 = G.nrNodes1(); size_t N2 = G.nrNodes2(); size_t M = G.nrEdges(); size_t maxM = N1 * N2; if( action == 0 ) { // add node if( rnd( 2 ) == 0 ) { // add node of type 1 if( N1 < maxN1 ) G.addNode1(); } else { // add node of type 2 if( N2 < maxN2 ) G.addNode2(); } } else if( action == 1 ) { // erase node if( rnd( 2 ) == 0 ) { // erase node of type 1 if( N1 > 0 ) G.eraseNode1( rnd( N1 ) ); } else { // erase node of type 2 if( N2 > 0 ) G.eraseNode2( rnd( N2 ) ); } } else if( action == 2 || action == 3 ) { // add edge if( N1 >= 1 && N2 >= 1 && M < maxM ) { size_t n1 = 0; size_t n2 = 0; if( rnd( 2 ) == 0 ) { do { n1 = rnd( N1 ); } while( G.nb1(n1).size() >= N2 ); do { n2 = rnd( N2 ); } while( G.hasEdge( n1, n2 ) ); } else { do { n2 = rnd( N2 ); } while( G.nb2(n2).size() >= N1 ); do { n1 = rnd( N1 ); } while( G.hasEdge( n1, n2 ) ); } G.addEdge( n1, n2 ); } } else if( action == 4 ) { // erase edge if( M > 0 ) { size_t n1 = 0; size_t n2 = 0; if( rnd( 2 ) == 0 ) { do { n1 = rnd( N1 ); } while( G.nb1(n1).size() == 0 ); do { n2 = rnd( N2 ); } while( !G.hasEdge( n1, n2 ) ); } else { do { n2 = rnd( N2 ); } while( G.nb2(n2).size() == 0 ); do { n1 = rnd( N1 ); } while( !G.hasEdge( n1, n2 ) ); } G.eraseEdge( n1, n2 ); } } G.checkConsistency(); } } BOOST_AUTO_TEST_CASE( QueriesTest ) { // check queries which have not been tested in another test case std::vector edges; edges.push_back( Edge( 0, 1 ) ); edges.push_back( Edge( 1, 1 ) ); edges.push_back( Edge( 0, 0 ) ); BipartiteGraph G( 3, 2, edges.begin(), edges.end() ); G.checkConsistency(); SmallSet v; SmallSet v0( 0 ); SmallSet v1( 1 ); SmallSet v01( 0, 1 ); BOOST_CHECK_EQUAL( G.delta1( 0, true ), v01 ); BOOST_CHECK_EQUAL( G.delta1( 1, true ), v01 ); BOOST_CHECK_EQUAL( G.delta1( 2, true ), v ); BOOST_CHECK_EQUAL( G.delta2( 0, true ), v01 ); BOOST_CHECK_EQUAL( G.delta2( 1, true ), v01 ); BOOST_CHECK_EQUAL( G.delta1( 0, false ), v1 ); BOOST_CHECK_EQUAL( G.delta1( 1, false ), v0 ); BOOST_CHECK_EQUAL( G.delta1( 2, false ), v ); BOOST_CHECK_EQUAL( G.delta2( 0, false ), v1 ); BOOST_CHECK_EQUAL( G.delta2( 1, false ), v0 ); BOOST_CHECK( G.hasEdge( 0, 0 ) ); BOOST_CHECK( G.hasEdge( 0, 1 ) ); BOOST_CHECK( G.hasEdge( 1, 1 ) ); BOOST_CHECK( !G.hasEdge( 1, 0 ) ); BOOST_CHECK( !G.hasEdge( 2, 0 ) ); BOOST_CHECK( !G.hasEdge( 2, 1 ) ); BOOST_CHECK_EQUAL( G.findNb1( 0, 0 ), 1 ); BOOST_CHECK_EQUAL( G.findNb1( 0, 1 ), 0 ); BOOST_CHECK_EQUAL( G.findNb1( 1, 1 ), 0 ); BOOST_CHECK_EQUAL( G.findNb2( 0, 0 ), 0 ); BOOST_CHECK_EQUAL( G.findNb2( 0, 1 ), 0 ); BOOST_CHECK_EQUAL( G.findNb2( 1, 1 ), 1 ); } BOOST_AUTO_TEST_CASE( StreamTest ) { // check printDot std::vector edges; edges.push_back( Edge(0, 0) ); edges.push_back( Edge(0, 1) ); edges.push_back( Edge(1, 1) ); edges.push_back( Edge(1, 2) ); BipartiteGraph G( 2, 3, edges.begin(), edges.end() ); std::stringstream ss; std::string s; G.printDot( ss ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "graph BipartiteGraph {" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=circle,width=0.4,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=box,width=0.3,height=0.3,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ty0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ty1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ty2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -- y0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -- y1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1 -- y1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1 -- y2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "}" ); ss << G; std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "graph BipartiteGraph {" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=circle,width=0.4,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=box,width=0.3,height=0.3,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ty0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ty1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\ty2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -- y0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -- y1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1 -- y1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1 -- y2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "}" ); } libDAI-0.2.7/tests/unit/dag_test.cpp0000644000263000017630000003416711433220722016106 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include using namespace dai; #define BOOST_TEST_MODULE DAGTest #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { // check constructors DAG G0; BOOST_CHECK_EQUAL( G0.nrNodes(), 0 ); BOOST_CHECK_EQUAL( G0.nrEdges(), 0 ); BOOST_CHECK_EQUAL( G0.isConnected(), true ); G0.checkConsistency(); DAG G2( 2 ); BOOST_CHECK_EQUAL( G2.nrNodes(), 2 ); BOOST_CHECK_EQUAL( G2.nrEdges(), 0 ); BOOST_CHECK_EQUAL( G2.isConnected(), false ); G2.checkConsistency(); BOOST_CHECK( !(G2 == G0) ); std::vector edges; edges.push_back( Edge( 0, 1 ) ); edges.push_back( Edge( 1, 2 ) ); edges.push_back( Edge( 2, 1 ) ); edges.push_back( Edge( 1, 2 ) ); DAG G3( 3, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G3.nrNodes(), 3 ); BOOST_CHECK_EQUAL( G3.nrEdges(), 2 ); BOOST_CHECK_EQUAL( G3.isConnected(), true ); G3.checkConsistency(); BOOST_CHECK( !(G3 == G0) ); BOOST_CHECK( !(G3 == G2) ); DAG G4( G3 ); BOOST_CHECK( !(G4 == G0) ); BOOST_CHECK( !(G4 == G2) ); BOOST_CHECK( G4 == G3 ); DAG G5 = G3; BOOST_CHECK( !(G5 == G0) ); BOOST_CHECK( !(G5 == G2) ); BOOST_CHECK( G5 == G3 ); } BOOST_AUTO_TEST_CASE( NeighborTest ) { // check pa(), ch() accessors / mutators std::vector edges; edges.push_back( Edge( 0, 2 ) ); edges.push_back( Edge( 1, 2 ) ); edges.push_back( Edge( 1, 3 ) ); DAG G( 4, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G.pa(0).size(), 0 ); BOOST_CHECK_EQUAL( G.pa(1).size(), 0 ); BOOST_CHECK_EQUAL( G.pa(2).size(), 2 ); BOOST_CHECK_EQUAL( G.pa(3).size(), 1 ); BOOST_CHECK_EQUAL( G.pa(2,0).iter, 0 ); BOOST_CHECK_EQUAL( G.pa(2,0).node, 0 ); BOOST_CHECK_EQUAL( G.pa(2,0).dual, 0 ); BOOST_CHECK_EQUAL( G.pa(2,1).iter, 1 ); BOOST_CHECK_EQUAL( G.pa(2,1).node, 1 ); BOOST_CHECK_EQUAL( G.pa(2,1).dual, 0 ); BOOST_CHECK_EQUAL( G.pa(3,0).iter, 0 ); BOOST_CHECK_EQUAL( G.pa(3,0).node, 1 ); BOOST_CHECK_EQUAL( G.pa(3,0).dual, 1 ); BOOST_CHECK( G.paSet(0) == SmallSet() ); BOOST_CHECK( G.paSet(1) == SmallSet() ); BOOST_CHECK( G.paSet(2) == SmallSet(0,1) ); BOOST_CHECK( G.paSet(3) == SmallSet(1) ); BOOST_CHECK_EQUAL( G.ch(0).size(), 1 ); BOOST_CHECK_EQUAL( G.ch(1).size(), 2 ); BOOST_CHECK_EQUAL( G.ch(2).size(), 0 ); BOOST_CHECK_EQUAL( G.ch(3).size(), 0 ); BOOST_CHECK_EQUAL( G.ch(0,0).iter, 0 ); BOOST_CHECK_EQUAL( G.ch(0,0).node, 2 ); BOOST_CHECK_EQUAL( G.ch(0,0).dual, 0 ); BOOST_CHECK_EQUAL( G.ch(1,0).iter, 0 ); BOOST_CHECK_EQUAL( G.ch(1,0).node, 2 ); BOOST_CHECK_EQUAL( G.ch(1,0).dual, 1 ); BOOST_CHECK_EQUAL( G.ch(1,1).iter, 1 ); BOOST_CHECK_EQUAL( G.ch(1,1).node, 3 ); BOOST_CHECK_EQUAL( G.ch(1,1).dual, 0 ); BOOST_CHECK( G.chSet(0) == SmallSet(2) ); BOOST_CHECK( G.chSet(1) == SmallSet(2,3) ); BOOST_CHECK( G.chSet(2) == SmallSet() ); BOOST_CHECK( G.chSet(3) == SmallSet() ); } BOOST_AUTO_TEST_CASE( AddEraseTest ) { // check addition and erasure of nodes and edges std::vector edges; edges.push_back( Edge( 0, 1 ) ); edges.push_back( Edge( 1, 2 ) ); edges.push_back( Edge( 1, 0 ) ); DAG G( 2 ); G.construct( 3, edges.begin(), edges.end() ); G.checkConsistency(); BOOST_CHECK_EQUAL( G.nrNodes(), 3 ); BOOST_CHECK_EQUAL( G.nrEdges(), 2 ); BOOST_CHECK_EQUAL( G, DAG(3).addEdge(0,1).addEdge(1,2) ); BOOST_CHECK_EQUAL( G.addNode(), 3 ); BOOST_CHECK_EQUAL( G, DAG(4).addEdge(0,1).addEdge(1,2) ); G.checkConsistency(); std::vector pa; pa.push_back( 3 ); BOOST_CHECK_EQUAL( G.addNode( pa.begin(), pa.end() ), 4 ); BOOST_CHECK_EQUAL( G, DAG(5).addEdge(0,1).addEdge(1,2).addEdge(3,4) ); BOOST_CHECK_EQUAL( G.addNode(), 5 ); BOOST_CHECK_EQUAL( G, DAG(6).addEdge(0,1).addEdge(1,2).addEdge(3,4) ); G.checkConsistency(); G.addEdge( 0, 4 ); BOOST_CHECK_EQUAL( G, DAG(6).addEdge(0,1).addEdge(1,2).addEdge(3,4).addEdge(0,4) ); G.checkConsistency(); G.addEdge( 0, 5 ); BOOST_CHECK_EQUAL( G, DAG(6).addEdge(0,1).addEdge(1,2).addEdge(3,4).addEdge(0,4).addEdge(0,5) ); G.checkConsistency(); BOOST_CHECK_EQUAL( G.nrNodes(), 6 ); BOOST_CHECK_EQUAL( G.nrEdges(), 5 ); G.addEdge( 2, 3 ); BOOST_CHECK_EQUAL( G, DAG(6).addEdge(0,1).addEdge(1,2).addEdge(3,4).addEdge(0,4).addEdge(0,5).addEdge(2,3) ); G.addEdge( 3, 0 ); BOOST_CHECK_EQUAL( G, DAG(6).addEdge(0,1).addEdge(1,2).addEdge(3,4).addEdge(0,4).addEdge(0,5).addEdge(2,3) ); G.addEdge( 5, 3 ); BOOST_CHECK_EQUAL( G, DAG(6).addEdge(0,1).addEdge(1,2).addEdge(3,4).addEdge(0,4).addEdge(0,5).addEdge(2,3).addEdge(5,3) ); G.eraseNode( 0 ); BOOST_CHECK_EQUAL( G, DAG(5).addEdge(0,1).addEdge(1,2).addEdge(4,2).addEdge(2,3) ); G.checkConsistency(); G.eraseEdge( 0, 1 ); BOOST_CHECK_EQUAL( G, DAG(5).addEdge(1,2).addEdge(4,2).addEdge(2,3) ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); G.eraseNode( 0 ); BOOST_CHECK_EQUAL( G, DAG(4).addEdge(0,1).addEdge(3,1).addEdge(1,2) ); G.checkConsistency(); G.addEdge( 3, 2 ); BOOST_CHECK_EQUAL( G, DAG(4).addEdge(0,1).addEdge(3,1).addEdge(1,2).addEdge(3,2) ); G.checkConsistency(); G.eraseNode( 1 ); BOOST_CHECK_EQUAL( G, DAG(3).addEdge(2,1) ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); G.eraseNode( 2 ); BOOST_CHECK_EQUAL( G, DAG(2) ); G.checkConsistency(); BOOST_CHECK( !G.isConnected() ); G.addEdge( 1, 0 ); BOOST_CHECK_EQUAL( G, DAG(2).addEdge(1,0) ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); G.eraseNode( 1 ); BOOST_CHECK_EQUAL( G, DAG(1) ); G.checkConsistency(); BOOST_CHECK( G.isConnected() ); G.eraseNode( 0 ); BOOST_CHECK_EQUAL( G, DAG() ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK_EQUAL( G.nrNodes(), 0 ); BOOST_CHECK_EQUAL( G.nrEdges(), 0 ); G.addNode(); G.addNode(); G.addNode(); G.addNode(); G.addEdge( 0, 1 ); G.addEdge( 2, 3 ); G.addEdge( 0, 3 ); G.checkConsistency(); G.eraseNode( 2 ); G.checkConsistency(); } BOOST_AUTO_TEST_CASE( RandomAddEraseTest ) { // check adding and erasing nodes and edges randomly DAG G; for( size_t maxN = 2; maxN < 50; maxN++ ) for( size_t repeats = 0; repeats < 10000; repeats++ ) { size_t action = rnd( 5 ); size_t N = G.nrNodes(); size_t M = G.nrEdges(); size_t maxM = N * (N - 1) / 2; if( action == 0 ) { // add node if( N < maxN ) G.addNode(); } else if( action == 1 ) { // erase node if( N > 0 ) G.eraseNode( rnd( N ) ); } else if( action == 2 || action == 3 ) { // add edge if( N >= 2 && M < maxM ) { size_t n1 = 0; size_t n2 = 0; do { n1 = rnd( N ); n2 = rnd( N ); } while( n1 == n2 || G.ch(n1).size() >= N - 1 || G.pa(n2).size() >= N - 1 || G.hasEdge( n1, n2 ) || G.existsDirectedPath( n2, n1 ) ); G.addEdge( n1, n2 ); } } else if( action == 4 ) { // erase edge if( M > 0 ) { size_t n1 = 0; do { n1 = rnd( N ); } while( G.ch(n1).size() == 0 ); size_t n2 = 0; do { n2 = rnd( N ); } while( !G.hasEdge( n1, n2 ) ); G.eraseEdge( n1, n2 ); } } G.checkConsistency(); } } BOOST_AUTO_TEST_CASE( QueriesTest ) { // check queries which have not been tested in another test case std::vector edges; edges.push_back( Edge( 0, 1 ) ); edges.push_back( Edge( 0, 3 ) ); edges.push_back( Edge( 2, 3 ) ); DAG G( 4, edges.begin(), edges.end() ); G.checkConsistency(); BOOST_CHECK( !G.hasEdge( 0, 0 ) ); BOOST_CHECK( G.hasEdge( 0, 1 ) ); BOOST_CHECK( !G.hasEdge( 0, 2 ) ); BOOST_CHECK( G.hasEdge( 0, 3 ) ); BOOST_CHECK( !G.hasEdge( 1, 0 ) ); BOOST_CHECK( !G.hasEdge( 1, 1 ) ); BOOST_CHECK( !G.hasEdge( 1, 2 ) ); BOOST_CHECK( !G.hasEdge( 1, 3 ) ); BOOST_CHECK( !G.hasEdge( 2, 0 ) ); BOOST_CHECK( !G.hasEdge( 2, 1 ) ); BOOST_CHECK( !G.hasEdge( 2, 2 ) ); BOOST_CHECK( G.hasEdge( 2, 3 ) ); BOOST_CHECK( !G.hasEdge( 3, 0 ) ); BOOST_CHECK( !G.hasEdge( 3, 1 ) ); BOOST_CHECK( !G.hasEdge( 3, 2 ) ); BOOST_CHECK( !G.hasEdge( 3, 3 ) ); BOOST_CHECK_THROW( G.findPa( 0, 0 ), Exception ); BOOST_CHECK_THROW( G.findPa( 0, 1 ), Exception ); BOOST_CHECK_THROW( G.findPa( 0, 2 ), Exception ); BOOST_CHECK_THROW( G.findPa( 0, 3 ), Exception ); BOOST_CHECK_EQUAL( G.findPa( 1, 0 ), 0 ); BOOST_CHECK_THROW( G.findPa( 1, 1 ), Exception ); BOOST_CHECK_THROW( G.findPa( 1, 2 ), Exception ); BOOST_CHECK_THROW( G.findPa( 1, 3 ), Exception ); BOOST_CHECK_THROW( G.findPa( 2, 0 ), Exception ); BOOST_CHECK_THROW( G.findPa( 2, 1 ), Exception ); BOOST_CHECK_THROW( G.findPa( 2, 2 ), Exception ); BOOST_CHECK_THROW( G.findPa( 2, 3 ), Exception ); BOOST_CHECK_EQUAL( G.findPa( 3, 0 ), 0 ); BOOST_CHECK_THROW( G.findPa( 3, 1 ), Exception ); BOOST_CHECK_EQUAL( G.findPa( 3, 2 ), 1 ); BOOST_CHECK_THROW( G.findPa( 3, 3 ), Exception ); BOOST_CHECK_THROW( G.findCh( 0, 0 ), Exception ); BOOST_CHECK_EQUAL( G.findCh( 0, 1 ), 0 ); BOOST_CHECK_THROW( G.findCh( 0, 2 ), Exception ); BOOST_CHECK_EQUAL( G.findCh( 0, 3 ), 1 ); BOOST_CHECK_THROW( G.findCh( 1, 0 ), Exception ); BOOST_CHECK_THROW( G.findCh( 1, 1 ), Exception ); BOOST_CHECK_THROW( G.findCh( 1, 2 ), Exception ); BOOST_CHECK_THROW( G.findCh( 1, 3 ), Exception ); BOOST_CHECK_THROW( G.findCh( 2, 0 ), Exception ); BOOST_CHECK_THROW( G.findCh( 2, 1 ), Exception ); BOOST_CHECK_THROW( G.findCh( 2, 2 ), Exception ); BOOST_CHECK_EQUAL( G.findCh( 2, 3 ), 0 ); BOOST_CHECK_THROW( G.findCh( 3, 0 ), Exception ); BOOST_CHECK_THROW( G.findCh( 3, 1 ), Exception ); BOOST_CHECK_THROW( G.findCh( 3, 2 ), Exception ); BOOST_CHECK_THROW( G.findCh( 3, 3 ), Exception ); BOOST_CHECK( G.existsDirectedPath( 0, 0 ) ); BOOST_CHECK( G.existsDirectedPath( 0, 1 ) ); BOOST_CHECK( !G.existsDirectedPath( 0, 2 ) ); BOOST_CHECK( G.existsDirectedPath( 0, 3 ) ); BOOST_CHECK( !G.existsDirectedPath( 1, 0 ) ); BOOST_CHECK( G.existsDirectedPath( 1, 1 ) ); BOOST_CHECK( !G.existsDirectedPath( 1, 2 ) ); BOOST_CHECK( !G.existsDirectedPath( 1, 3 ) ); BOOST_CHECK( !G.existsDirectedPath( 2, 0 ) ); BOOST_CHECK( !G.existsDirectedPath( 2, 1 ) ); BOOST_CHECK( G.existsDirectedPath( 2, 2 ) ); BOOST_CHECK( G.existsDirectedPath( 2, 3 ) ); BOOST_CHECK( !G.existsDirectedPath( 3, 0 ) ); BOOST_CHECK( !G.existsDirectedPath( 3, 1 ) ); BOOST_CHECK( !G.existsDirectedPath( 3, 2 ) ); BOOST_CHECK( G.existsDirectedPath( 3, 3 ) ); std::set s; G.addNode(); G.addEdge( 3, 4 ); G.addNode(); G.addEdge( 1, 4 ); G.addEdge( 1, 5 ); BOOST_CHECK( G.descendants( 4 ) == s ); BOOST_CHECK( G.descendants( 5 ) == s ); s.insert( 4 ); BOOST_CHECK( G.descendants( 3 ) == s ); s.insert( 5 ); BOOST_CHECK( G.descendants( 1 ) == s ); s.erase( 5 ); s.insert( 3 ); BOOST_CHECK( G.descendants( 2 ) == s ); s.insert( 1 ); s.insert( 5 ); BOOST_CHECK( G.descendants( 0 ) == s ); s.clear(); BOOST_CHECK( G.ancestors( 0 ) == s ); BOOST_CHECK( G.ancestors( 2 ) == s ); s.insert( 0 ); BOOST_CHECK( G.ancestors( 1 ) == s ); s.insert( 2 ); BOOST_CHECK( G.ancestors( 3 ) == s ); s.erase( 2 ); s.insert( 1 ); BOOST_CHECK( G.ancestors( 5 ) == s ); s.insert( 2 ); s.insert( 3 ); BOOST_CHECK( G.ancestors( 4 ) == s ); } BOOST_AUTO_TEST_CASE( StreamTest ) { // check printDot DAG G( 4 ); G.addEdge( 0, 1 ); G.addEdge( 0, 2 ); G.addEdge( 1, 3 ); G.addEdge( 2, 3 ); G.addEdge( 2, 2 ); G.addEdge( 3, 2 ); std::stringstream ss; std::string s; G.printDot( ss ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "digraph DAG {" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=circle,width=0.4,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -> x1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -> x2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1 -> x3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx2 -> x3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "}" ); ss << G; std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "digraph DAG {" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=circle,width=0.4,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -> x1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -> x2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1 -> x3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx2 -> x3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "}" ); } libDAI-0.2.7/tests/unit/index_test.cpp0000644000263000017630000003013411433220722016450 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; #define BOOST_TEST_MODULE IndexTest #include BOOST_AUTO_TEST_CASE( IndexForTest ) { IndexFor x; BOOST_CHECK( !x.valid() ); x.reset(); BOOST_CHECK( x.valid() ); size_t nrVars = 5; std::vector vars; for( size_t i = 0; i < nrVars; i++ ) vars.push_back( Var( i, i+2 ) ); for( size_t repeat = 0; repeat < 10000; repeat++ ) { VarSet indexVars; VarSet forVars; for( size_t i = 0; i < 5; i++ ) { if( rnd(2) == 0 ) indexVars |= vars[i]; if( rnd(2) == 0 ) forVars |= vars[i]; } IndexFor ind( indexVars, forVars ); size_t iter = 0; for( ; ind.valid(); ind++, iter++ ) BOOST_CHECK_EQUAL( calcLinearState( indexVars, calcState( forVars, iter ) ), (size_t)ind ); BOOST_CHECK_EQUAL( iter, forVars.nrStates() ); iter = 0; ind.reset(); for( ; ind.valid(); ++ind, iter++ ) BOOST_CHECK_EQUAL( calcLinearState( indexVars, calcState( forVars, iter ) ), (size_t)ind ); BOOST_CHECK_EQUAL( iter, forVars.nrStates() ); } } BOOST_AUTO_TEST_CASE( PermuteTest ) { Permute x; Var x0(0, 2); Var x1(1, 3); Var x2(2, 2); std::vector V; V.push_back( x1 ); V.push_back( x2 ); V.push_back( x0 ); VarSet X( V.begin(), V.end() ); Permute sigma(V); BOOST_CHECK_EQUAL( sigma.sigma().size(), 3 ); BOOST_CHECK_EQUAL( sigma.sigma()[0], 2 ); BOOST_CHECK_EQUAL( sigma.sigma()[1], 0 ); BOOST_CHECK_EQUAL( sigma.sigma()[2], 1 ); BOOST_CHECK_EQUAL( sigma[0], 2 ); BOOST_CHECK_EQUAL( sigma[1], 0 ); BOOST_CHECK_EQUAL( sigma[2], 1 ); BOOST_CHECK_EQUAL( sigma.ranges().size(), 3 ); BOOST_CHECK_EQUAL( sigma.ranges()[0], 3 ); BOOST_CHECK_EQUAL( sigma.ranges()[1], 2 ); BOOST_CHECK_EQUAL( sigma.ranges()[2], 2 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 0 ), 0 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 1 ), 2 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 2 ), 4 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 3 ), 6 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 4 ), 8 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 5 ), 10 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 6 ), 1 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 7 ), 3 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 8 ), 5 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 9 ), 7 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 10 ), 9 ); BOOST_CHECK_EQUAL( sigma.convertLinearIndex( 11 ), 11 ); Permute sigmar(V, true); BOOST_CHECK_EQUAL( sigmar.sigma().size(), 3 ); BOOST_CHECK_EQUAL( sigmar.sigma()[0], 0 ); BOOST_CHECK_EQUAL( sigmar.sigma()[1], 2 ); BOOST_CHECK_EQUAL( sigmar.sigma()[2], 1 ); BOOST_CHECK_EQUAL( sigmar[0], 0 ); BOOST_CHECK_EQUAL( sigmar[1], 2 ); BOOST_CHECK_EQUAL( sigmar[2], 1 ); BOOST_CHECK_EQUAL( sigmar.ranges().size(), 3 ); BOOST_CHECK_EQUAL( sigmar.ranges()[0], 2 ); BOOST_CHECK_EQUAL( sigmar.ranges()[1], 2 ); BOOST_CHECK_EQUAL( sigmar.ranges()[2], 3 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 0 ), 0 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 1 ), 1 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 2 ), 6 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 3 ), 7 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 4 ), 2 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 5 ), 3 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 6 ), 8 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 7 ), 9 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 8 ), 4 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 9 ), 5 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 10 ), 10 ); BOOST_CHECK_EQUAL( sigmar.convertLinearIndex( 11 ), 11 ); std::vector rs, sig; rs.push_back(3); rs.push_back(2); rs.push_back(2); sig.push_back(2); sig.push_back(0); sig.push_back(1); Permute tau( rs, sig ); BOOST_CHECK( tau.sigma() == sig ); BOOST_CHECK( tau.ranges() == rs ); BOOST_CHECK_EQUAL( tau[0], 2 ); BOOST_CHECK_EQUAL( tau[1], 0 ); BOOST_CHECK_EQUAL( tau[2], 1 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 0 ), 0 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 1 ), 2 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 2 ), 4 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 3 ), 6 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 4 ), 8 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 5 ), 10 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 6 ), 1 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 7 ), 3 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 8 ), 5 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 9 ), 7 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 10 ), 9 ); BOOST_CHECK_EQUAL( tau.convertLinearIndex( 11 ), 11 ); Permute tauinv = tau.inverse(); BOOST_CHECK_EQUAL( tauinv.sigma().size(), 3 ); BOOST_CHECK_EQUAL( tauinv.ranges().size(), 3 ); BOOST_CHECK_EQUAL( tauinv[0], 1 ); BOOST_CHECK_EQUAL( tauinv[1], 2 ); BOOST_CHECK_EQUAL( tauinv[2], 0 ); BOOST_CHECK_EQUAL( tauinv.ranges()[0], 2 ); BOOST_CHECK_EQUAL( tauinv.ranges()[1], 3 ); BOOST_CHECK_EQUAL( tauinv.ranges()[2], 2 ); for( size_t i = 0; i < 12; i++ ) { BOOST_CHECK_EQUAL( tau.convertLinearIndex( tauinv.convertLinearIndex( i ) ), i ); BOOST_CHECK_EQUAL( tauinv.convertLinearIndex( tau.convertLinearIndex( i ) ), i ); } } BOOST_AUTO_TEST_CASE( multiforTest ) { multifor x; BOOST_CHECK( x.valid() ); std::vector ranges; ranges.push_back( 3 ); ranges.push_back( 4 ); ranges.push_back( 5 ); multifor S(ranges); size_t s = 0; for( size_t s2 = 0; s2 < 5; s2++ ) for( size_t s1 = 0; s1 < 4; s1++ ) for( size_t s0 = 0; s0 < 3; s0++, s++, S++ ) { BOOST_CHECK( S.valid() ); BOOST_CHECK_EQUAL( s, (size_t)S ); BOOST_CHECK_EQUAL( S[0], s0 ); BOOST_CHECK_EQUAL( S[1], s1 ); BOOST_CHECK_EQUAL( S[2], s2 ); } BOOST_CHECK( !S.valid() ); for( size_t repeat = 0; repeat < 10000; repeat++ ) { std::vector dims; size_t total = 1; for( size_t i = 0; i < 4; i++ ) { dims.push_back( rnd(3) + 1 ); total *= dims.back(); } multifor ind( dims ); size_t iter = 0; for( ; ind.valid(); ind++, iter++ ) { BOOST_CHECK_EQUAL( (size_t)ind, iter ); BOOST_CHECK_EQUAL( ind[0], iter % dims[0] ); BOOST_CHECK_EQUAL( ind[1], (iter / dims[0]) % dims[1] ); BOOST_CHECK_EQUAL( ind[2], (iter / (dims[0] * dims[1])) % dims[2] ); BOOST_CHECK_EQUAL( ind[3], (iter / (dims[0] * dims[1] * dims[2])) % dims[3] ); } BOOST_CHECK_EQUAL( iter, total ); iter = 0; ind.reset(); for( ; ind.valid(); ++ind, iter++ ) { BOOST_CHECK_EQUAL( (size_t)ind, iter ); BOOST_CHECK_EQUAL( ind[0], iter % dims[0] ); BOOST_CHECK_EQUAL( ind[1], (iter / dims[0]) % dims[1] ); BOOST_CHECK_EQUAL( ind[2], (iter / (dims[0] * dims[1])) % dims[2] ); BOOST_CHECK_EQUAL( ind[3], (iter / (dims[0] * dims[1] * dims[2])) % dims[3] ); } BOOST_CHECK_EQUAL( iter, total ); } } BOOST_AUTO_TEST_CASE( StateTest ) { State x; BOOST_CHECK( x.valid() ); Var v0( 0, 3 ); Var v1( 1, 4 ); Var v2( 3, 5 ); VarSet vars; vars |= v2; vars |= v1; vars |= v0; State S( vars ); size_t s = 0; for( size_t s2 = 0; s2 < 5; s2++ ) for( size_t s1 = 0; s1 < 4; s1++ ) for( size_t s0 = 0; s0 < 3; s0++, s++, S++ ) { BOOST_CHECK( S.valid() ); BOOST_CHECK_EQUAL( s, (size_t)S ); BOOST_CHECK_EQUAL( S(v0), s0 ); BOOST_CHECK_EQUAL( S(v1), s1 ); BOOST_CHECK_EQUAL( S(v2), s2 ); BOOST_CHECK_EQUAL( S( Var( 2, 2 ) ), 0 ); } BOOST_CHECK( !S.valid() ); S.reset(); std::vector > ps; ps.push_back( std::make_pair( Var( 2, 2 ), 1 ) ); ps.push_back( std::make_pair( Var( 4, 2 ), 1 ) ); S.insert( ps.begin(), ps.end() ); BOOST_CHECK( S.valid() ); BOOST_CHECK_EQUAL( (size_t)S, 132 ); for( size_t repeat = 0; repeat < 10000; repeat++ ) { std::vector dims; size_t total = 1; for( size_t i = 0; i < 4; i++ ) { dims.push_back( rnd(3) + 1 ); total *= dims.back(); } std::vector vs; for( size_t i = 0; i < 4; i++ ) vs.push_back( Var( i, dims[i] ) ); State ind( VarSet( vs.begin(), vs.end() ) ); size_t iter = 0; for( ; ind.valid(); ind++, iter++ ) { BOOST_CHECK_EQUAL( (size_t)ind, iter ); BOOST_CHECK_EQUAL( ind(vs[0]), iter % dims[0] ); BOOST_CHECK_EQUAL( ind(vs[1]), (iter / dims[0]) % dims[1] ); BOOST_CHECK_EQUAL( ind(vs[2]), (iter / (dims[0] * dims[1])) % dims[2] ); BOOST_CHECK_EQUAL( ind(vs[3]), (iter / (dims[0] * dims[1] * dims[2])) % dims[3] ); BOOST_CHECK_EQUAL( ind(VarSet(vs[0], vs[1])), iter % (dims[0] * dims[1]) ); BOOST_CHECK_EQUAL( ind(VarSet(vs[1], vs[2])), (iter / dims[0]) % (dims[1] * dims[2]) ); BOOST_CHECK_EQUAL( ind(VarSet(vs[2], vs[3])), (iter / (dims[0] * dims[1])) % (dims[2] * dims[3]) ); BOOST_CHECK_EQUAL( ind(VarSet(vs.begin(), vs.end())), iter ); State indcopy( VarSet(vs.begin(), vs.end()), (size_t)ind ); BOOST_CHECK_EQUAL( ind(vs[0]), indcopy(vs[0]) ); BOOST_CHECK_EQUAL( ind(vs[1]), indcopy(vs[1]) ); BOOST_CHECK_EQUAL( ind(vs[2]), indcopy(vs[2]) ); BOOST_CHECK_EQUAL( ind(vs[3]), indcopy(vs[3]) ); State indcopy2( indcopy.get() ); BOOST_CHECK_EQUAL( ind(vs[0]), indcopy2(vs[0]) ); BOOST_CHECK_EQUAL( ind(vs[1]), indcopy2(vs[1]) ); BOOST_CHECK_EQUAL( ind(vs[2]), indcopy2(vs[2]) ); BOOST_CHECK_EQUAL( ind(vs[3]), indcopy2(vs[3]) ); std::map indmap( ind ); State indcopy3( indmap ); BOOST_CHECK_EQUAL( ind(vs[0]), indcopy3(vs[0]) ); BOOST_CHECK_EQUAL( ind(vs[1]), indcopy3(vs[1]) ); BOOST_CHECK_EQUAL( ind(vs[2]), indcopy3(vs[2]) ); BOOST_CHECK_EQUAL( ind(vs[3]), indcopy3(vs[3]) ); } BOOST_CHECK_EQUAL( iter, total ); iter = 0; ind.reset(); for( ; ind.valid(); ++ind, iter++ ) { BOOST_CHECK_EQUAL( (size_t)ind, iter ); BOOST_CHECK_EQUAL( ind(vs[0]), iter % dims[0] ); BOOST_CHECK_EQUAL( ind(vs[1]), (iter / dims[0]) % dims[1] ); BOOST_CHECK_EQUAL( ind(vs[2]), (iter / (dims[0] * dims[1])) % dims[2] ); BOOST_CHECK_EQUAL( ind(vs[3]), (iter / (dims[0] * dims[1] * dims[2])) % dims[3] ); State::const_iterator ci = ind.begin(); BOOST_CHECK_EQUAL( (ci++)->second, iter % dims[0] ); BOOST_CHECK_EQUAL( (ci++)->second, (iter / dims[0]) % dims[1] ); BOOST_CHECK_EQUAL( (ci++)->second, (iter / (dims[0] * dims[1])) % dims[2] ); BOOST_CHECK_EQUAL( (ci++)->second, (iter / (dims[0] * dims[1] * dims[2])) % dims[3] ); BOOST_CHECK( ci == ind.end() ); } BOOST_CHECK_EQUAL( iter, total ); State::const_iterator ci = ind.begin(); BOOST_CHECK_EQUAL( (ci++)->first, vs[0] ); BOOST_CHECK_EQUAL( (ci++)->first, vs[1] ); BOOST_CHECK_EQUAL( (ci++)->first, vs[2] ); BOOST_CHECK_EQUAL( (ci++)->first, vs[3] ); BOOST_CHECK( ci == ind.end() ); } } libDAI-0.2.7/tests/unit/properties_test.cpp0000644000263000017630000002136011433220722017536 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include using namespace dai; #define BOOST_TEST_MODULE PropertiesTest #include BOOST_AUTO_TEST_CASE( PropertyTest ) { std::stringstream str1, str2, str3, str4, str5, str6, str7, str8; std::string s; Property p; p.first = "key"; p.second = (int)-5; str1 << p; str1 >> s; BOOST_CHECK_EQUAL( s, "key=-5" ); p.second = (size_t)5; str2 << p; str2 >> s; BOOST_CHECK_EQUAL( s, "key=5" ); p.second = std::string("value"); str3 << p; str3 >> s; BOOST_CHECK_EQUAL( s, "key=value" ); p.second = 3.141; str4 << p; str4 >> s; BOOST_CHECK_EQUAL( s, "key=3.141" ); p.second = (long double)3.141; str5 << p; str5 >> s; BOOST_CHECK_EQUAL( s, "key=3.141" ); p.second = false; str6 << p; str6 >> s; BOOST_CHECK_EQUAL( s, "key=0" ); p.second = PropertySet()("prop2",(size_t)5)("prop1",std::string("hi")); str7 << p; str7 >> s; BOOST_CHECK_EQUAL( s, "key=[prop1=hi,prop2=5]" ); p.second = std::vector(); BOOST_CHECK_THROW( str7 << p, Exception ); } BOOST_AUTO_TEST_CASE( ConstructorsTest ) { PropertySet x; PropertySet y("[key1=val1,key2=5,key3=[key3a=val,key3b=7.0],key4=1.0]"); PropertySet z = PropertySet()("key1",std::string("val1"))("key2",5)("key3",PropertySet("[key3a=val,key3b=7.0]"))("key4",1.0); BOOST_CHECK( !x.hasKey("key") ); BOOST_CHECK( !y.hasKey("key") ); BOOST_CHECK( !z.hasKey("key") ); BOOST_CHECK( y.hasKey("key1") ); BOOST_CHECK( y.hasKey("key2") ); BOOST_CHECK( y.hasKey("key3") ); BOOST_CHECK( !y.hasKey("key3a") ); BOOST_CHECK( !y.hasKey("key3b") ); BOOST_CHECK( y.hasKey("key4") ); BOOST_CHECK( z.hasKey("key1") ); BOOST_CHECK( z.hasKey("key2") ); BOOST_CHECK( z.hasKey("key3") ); BOOST_CHECK( !z.hasKey("key3a") ); BOOST_CHECK( !z.hasKey("key3b") ); BOOST_CHECK( z.hasKey("key4") ); BOOST_CHECK_EQUAL( x.size(), 0 ); BOOST_CHECK_EQUAL( y.size(), 4 ); BOOST_CHECK_EQUAL( z.size(), 4 ); std::set keys; keys.insert( "key1" ); keys.insert( "key2" ); keys.insert( "key3" ); keys.insert( "key4" ); BOOST_CHECK( y.keys() == keys ); BOOST_CHECK( z.keys() == keys ); BOOST_CHECK_THROW( x.get( "key" ), Exception ); BOOST_CHECK_THROW( y.get( "key" ), Exception ); BOOST_CHECK_THROW( z.get( "key" ), Exception ); BOOST_CHECK_THROW( x.getAs( "key" ), Exception ); BOOST_CHECK_THROW( y.getAs( "key" ), Exception ); BOOST_CHECK_THROW( z.getAs( "key" ), Exception ); BOOST_CHECK_THROW( x.getStringAs( "key" ), Exception ); BOOST_CHECK_THROW( y.getStringAs( "key" ), Exception ); BOOST_CHECK_THROW( z.getStringAs( "key" ), Exception ); BOOST_CHECK_EQUAL( boost::any_cast(y.get( "key1" )), std::string("val1") ); BOOST_CHECK_EQUAL( boost::any_cast(y.get( "key2" )), std::string("5") ); BOOST_CHECK_EQUAL( boost::any_cast(y.get( "key3" )), std::string("[key3a=val,key3b=7.0]") ); BOOST_CHECK_EQUAL( boost::any_cast(y.get( "key4" )), std::string("1.0") ); BOOST_CHECK_EQUAL( y.getAs( "key1" ), std::string("val1") ); BOOST_CHECK_EQUAL( y.getAs( "key2" ), std::string("5") ); BOOST_CHECK_EQUAL( y.getAs( "key3" ), std::string("[key3a=val,key3b=7.0]") ); BOOST_CHECK_EQUAL( y.getAs( "key4" ), std::string("1.0") ); BOOST_CHECK_EQUAL( y.getStringAs( "key1" ), std::string("val1") ); BOOST_CHECK_EQUAL( y.getStringAs( "key2" ), 5 ); BOOST_CHECK_EQUAL( y.getStringAs( "key2" ), 5 ); BOOST_CHECK_EQUAL( y.getStringAs( "key4" ), 1.0 ); PropertySet key3val = y.getStringAs( "key3" ); BOOST_CHECK_EQUAL( key3val.size(), 2 ); BOOST_CHECK( key3val.hasKey( "key3a" ) ); BOOST_CHECK( key3val.hasKey( "key3b" ) ); BOOST_CHECK_EQUAL( key3val.getStringAs( "key3a" ), std::string("val") ); BOOST_CHECK_EQUAL( key3val.getStringAs( "key3b" ), 7.0 ); BOOST_CHECK_THROW( y.getAs( "key2" ), Exception ); BOOST_CHECK_THROW( y.getStringAs( "key4" ), Exception ); BOOST_CHECK_EQUAL( boost::any_cast(z.get( "key1" )), std::string("val1") ); BOOST_CHECK_EQUAL( boost::any_cast(z.get( "key2" )), 5 ); BOOST_CHECK_EQUAL( boost::any_cast(z.get( "key3" )).size(), 2 ); BOOST_CHECK_EQUAL( boost::any_cast(z.get( "key4" )), 1.0 ); BOOST_CHECK_EQUAL( z.getAs( "key1" ), std::string("val1") ); BOOST_CHECK_EQUAL( z.getAs( "key2" ), 5 ); BOOST_CHECK_EQUAL( z.getAs( "key3" ).size(), 2 ); BOOST_CHECK_EQUAL( z.getAs( "key4" ), 1.0 ); BOOST_CHECK_EQUAL( z.getStringAs( "key1" ), std::string("val1") ); BOOST_CHECK_EQUAL( z.getStringAs( "key2" ), 5 ); BOOST_CHECK_EQUAL( z.getStringAs( "key4" ), 1.0 ); key3val = z.getAs( "key3" ); BOOST_CHECK_EQUAL( key3val.size(), 2 ); BOOST_CHECK( key3val.hasKey( "key3a" ) ); BOOST_CHECK( key3val.hasKey( "key3b" ) ); BOOST_CHECK_EQUAL( key3val.getStringAs( "key3a" ), std::string("val") ); BOOST_CHECK_EQUAL( key3val.getStringAs( "key3b" ), 7.0 ); BOOST_CHECK_THROW( z.getAs( "key2" ), Exception ); BOOST_CHECK_THROW( z.getStringAs( "key4" ), Exception ); } BOOST_AUTO_TEST_CASE( SetTest ) { PropertySet x; PropertySet y("[key1=val1,key2=5]"); x.set( "key1", 5 ); BOOST_CHECK( x.hasKey( "key1" ) ); BOOST_CHECK( !x.hasKey( "key2" ) ); BOOST_CHECK_EQUAL( x.getAs( "key1" ), 5 ); BOOST_CHECK_THROW( x.getAs( "key1" ), Exception ); BOOST_CHECK_THROW( x.getAs( "key2" ), Exception ); x.set( y ); BOOST_CHECK( x.hasKey( "key1" ) ); BOOST_CHECK( x.hasKey( "key2" ) ); BOOST_CHECK( !x.hasKey( "key" ) ); BOOST_CHECK_EQUAL( x.getAs( "key1" ), std::string("val1") ); BOOST_CHECK_EQUAL( x.getAs( "key2" ), std::string("5") ); x.setAsString( "key1", 5 ); BOOST_CHECK_EQUAL( x.getAs( "key1" ), std::string("5") ); x.convertTo( "key1" ); BOOST_CHECK_EQUAL( x.getAs( "key1" ), 5 ); x.setAsString( "key1", -5 ); BOOST_CHECK_EQUAL( x.getAs( "key1" ), std::string("-5") ); x.convertTo( "key1" ); BOOST_CHECK_EQUAL( x.getAs( "key1" ), -5 ); x.setAsString( "key1", 1.234 ); BOOST_CHECK_EQUAL( x.getAs( "key1" ), std::string("1.234") ); BOOST_CHECK_THROW( x.convertTo( "key1" ), Exception ); x.convertTo( "key1" ); BOOST_CHECK_EQUAL( x.getAs( "key1" ), 1.234 ); x.setAsString( "key1", "val1"); BOOST_CHECK_EQUAL( x.getAs( "key1" ), std::string("val1") ); BOOST_CHECK_THROW( x.convertTo( "key1" ), Exception ); x.convertTo( "key1" ); BOOST_CHECK_EQUAL( x.getAs( "key1" ), std::string("val1") ); BOOST_CHECK_EQUAL( x.erase( "key1" ), 1 ); BOOST_CHECK( !x.hasKey( "key1" ) ); } BOOST_AUTO_TEST_CASE( StreamTest ) { std::stringstream ss1, ss2, ss3; std::string s; PropertySet z = PropertySet()("key1",std::string("val1"))("key2",5)("key3",PropertySet("[key3a=val,key3b=7.0]"))("key4",1.0); ss1 << z; ss1 >> s; BOOST_CHECK_EQUAL( s, std::string("[key1=val1,key2=5,key3=[key3a=val,key3b=7.0],key4=1]") ); PropertySet y; ss2 << z; ss2 >> y; BOOST_CHECK( y.hasKey( "key1" ) ); BOOST_CHECK( y.hasKey( "key2" ) ); BOOST_CHECK( y.hasKey( "key3" ) ); BOOST_CHECK( y.hasKey( "key4" ) ); BOOST_CHECK_EQUAL( y.getAs( "key1" ), std::string("val1") ); BOOST_CHECK_EQUAL( y.getAs( "key2" ), std::string("5") ); BOOST_CHECK_EQUAL( y.getAs( "key3" ), std::string("[key3a=val,key3b=7.0]") ); BOOST_CHECK_EQUAL( y.getAs( "key4" ), std::string("1") ); z.set( "key5", std::vector() ); BOOST_CHECK_THROW( ss1 << z, Exception ); y.clear(); BOOST_CHECK_EQUAL( y.size(), 0 ); ss3 << "[]"; ss3 >> y; BOOST_CHECK_EQUAL( y.size(), 0 ); ss3 << ""; BOOST_CHECK_THROW( ss3 >> y, Exception ); ss3 << "[key1 = val1]"; BOOST_CHECK_THROW( ss3 >> y, Exception ); ss3 << "[key1=val1"; BOOST_CHECK_THROW( ss3 >> y, Exception ); } libDAI-0.2.7/tests/unit/factorgraph_test.cpp0000644000263000017630000007260211433220722017647 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include using namespace dai; const double tol = 1e-8; #define BOOST_TEST_MODULE FactorGraphTest #include #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { FactorGraph G; BOOST_CHECK_EQUAL( G.vars(), std::vector() ); BOOST_CHECK_EQUAL( G.factors(), std::vector() ); std::vector facs; facs.push_back( Factor( VarSet( Var(0, 2), Var(1, 2) ) ) ); facs.push_back( Factor( VarSet( Var(0, 2), Var(2, 2) ) ) ); facs.push_back( Factor( VarSet( Var(1, 2), Var(2, 2) ) ) ); facs.push_back( Factor( VarSet( Var(1, 2) ) ) ); std::vector vars; vars.push_back( Var( 0, 2 ) ); vars.push_back( Var( 1, 2 ) ); vars.push_back( Var( 2, 2 ) ); FactorGraph G1( facs ); BOOST_CHECK_EQUAL( G1.vars(), vars ); BOOST_CHECK_EQUAL( G1.factors(), facs ); FactorGraph G2( facs.begin(), facs.end(), vars.begin(), vars.end(), facs.size(), vars.size() ); BOOST_CHECK_EQUAL( G2.vars(), vars ); BOOST_CHECK_EQUAL( G2.factors(), facs ); FactorGraph *G3 = G2.clone(); BOOST_CHECK_EQUAL( G3->vars(), vars ); BOOST_CHECK_EQUAL( G3->factors(), facs ); delete G3; FactorGraph G4 = G2; BOOST_CHECK_EQUAL( G4.vars(), vars ); BOOST_CHECK_EQUAL( G4.factors(), facs ); FactorGraph G5( G2 ); BOOST_CHECK_EQUAL( G5.vars(), vars ); BOOST_CHECK_EQUAL( G5.factors(), facs ); } BOOST_AUTO_TEST_CASE( AccMutTest ) { std::vector facs; facs.push_back( Factor( VarSet( Var(0, 2), Var(1, 2) ) ) ); facs.push_back( Factor( VarSet( Var(0, 2), Var(2, 2) ) ) ); facs.push_back( Factor( VarSet( Var(1, 2), Var(2, 2) ) ) ); facs.push_back( Factor( VarSet( Var(1, 2) ) ) ); std::vector vars; vars.push_back( Var( 0, 2 ) ); vars.push_back( Var( 1, 2 ) ); vars.push_back( Var( 2, 2 ) ); FactorGraph G( facs ); BOOST_CHECK_EQUAL( G.var(0), Var(0, 2) ); BOOST_CHECK_EQUAL( G.var(1), Var(1, 2) ); BOOST_CHECK_EQUAL( G.var(2), Var(2, 2) ); BOOST_CHECK_EQUAL( G.vars(), vars ); BOOST_CHECK_EQUAL( G.factor(0), facs[0] ); BOOST_CHECK_EQUAL( G.factor(1), facs[1] ); BOOST_CHECK_EQUAL( G.factor(2), facs[2] ); BOOST_CHECK_EQUAL( G.factor(3), facs[3] ); BOOST_CHECK_EQUAL( G.factors(), facs ); BOOST_CHECK_EQUAL( G.nbV(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nbV(0,0), 0 ); BOOST_CHECK_EQUAL( G.nbV(0,1), 1 ); BOOST_CHECK_EQUAL( G.nbV(1).size(), 3 ); BOOST_CHECK_EQUAL( G.nbV(1,0), 0 ); BOOST_CHECK_EQUAL( G.nbV(1,1), 2 ); BOOST_CHECK_EQUAL( G.nbV(1,2), 3 ); BOOST_CHECK_EQUAL( G.nbV(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nbV(2,0), 1 ); BOOST_CHECK_EQUAL( G.nbV(2,1), 2 ); BOOST_CHECK_EQUAL( G.nbF(0).size(), 2 ); BOOST_CHECK_EQUAL( G.nbF(0,0), 0 ); BOOST_CHECK_EQUAL( G.nbF(0,1), 1 ); BOOST_CHECK_EQUAL( G.nbF(1).size(), 2 ); BOOST_CHECK_EQUAL( G.nbF(1,0), 0 ); BOOST_CHECK_EQUAL( G.nbF(1,1), 2 ); BOOST_CHECK_EQUAL( G.nbF(2).size(), 2 ); BOOST_CHECK_EQUAL( G.nbF(2,0), 1 ); BOOST_CHECK_EQUAL( G.nbF(2,1), 2 ); BOOST_CHECK_EQUAL( G.nbF(3).size(), 1 ); BOOST_CHECK_EQUAL( G.nbF(3,0), 1 ); } BOOST_AUTO_TEST_CASE( QueriesTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; FactorGraph G0; BOOST_CHECK_EQUAL( G0.nrVars(), 0 ); BOOST_CHECK_EQUAL( G0.nrFactors(), 0 ); BOOST_CHECK_EQUAL( G0.nrEdges(), 0 ); BOOST_CHECK_THROW( G0.findVar( v0 ), Exception ); BOOST_CHECK_THROW( G0.findVars( v01 ), Exception ); BOOST_CHECK_THROW( G0.findFactor( v01 ), Exception ); #ifdef DAI_DBEUG BOOST_CHECK_THROW( G0.delta( 0 ), Exception ); BOOST_CHECK_THROW( G0.Delta( 0 ), Exception ); BOOST_CHECK_THROW( G0.delta( v0 ), Exception ); BOOST_CHECK_THROW( G0.Delta( v0 ), Exception ); #endif BOOST_CHECK( G0.isConnected() ); BOOST_CHECK( G0.isTree() ); BOOST_CHECK( G0.isBinary() ); BOOST_CHECK( G0.isPairwise() ); BOOST_CHECK( G0.MarkovGraph() == GraphAL() ); BOOST_CHECK( G0.bipGraph() == BipartiteGraph() ); BOOST_CHECK_EQUAL( G0.maximalFactorDomains().size(), 1 ); BOOST_CHECK_CLOSE( G0.logScore( std::vector() ), (Real)0.0, tol ); std::vector facs; facs.push_back( Factor( v01 ) ); facs.push_back( Factor( v12 ) ); facs.push_back( Factor( v1 ) ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); GraphAL H(3); H.addEdge( 0, 1 ); H.addEdge( 1, 2 ); BipartiteGraph K(3, 3); K.addEdge( 0, 0 ); K.addEdge( 1, 0 ); K.addEdge( 1, 1 ); K.addEdge( 2, 1 ); K.addEdge( 1, 2 ); FactorGraph G1( facs ); BOOST_CHECK_EQUAL( G1.nrVars(), 3 ); BOOST_CHECK_EQUAL( G1.nrFactors(), 3 ); BOOST_CHECK_EQUAL( G1.nrEdges(), 5 ); BOOST_CHECK_EQUAL( G1.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G1.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G1.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G1.findVars( v01 ), SmallSet( 0, 1 ) ); BOOST_CHECK_EQUAL( G1.findVars( v02 ), SmallSet( 0, 2 ) ); BOOST_CHECK_EQUAL( G1.findVars( v12 ), SmallSet( 1, 2 ) ); BOOST_CHECK_EQUAL( G1.findFactor( v01 ), 0 ); BOOST_CHECK_EQUAL( G1.findFactor( v12 ), 1 ); BOOST_CHECK_EQUAL( G1.findFactor( v1 ), 2 ); BOOST_CHECK_THROW( G1.findFactor( v02 ), Exception ); BOOST_CHECK_EQUAL( G1.delta( 0 ), v1 ); BOOST_CHECK_EQUAL( G1.delta( 1 ), v02 ); BOOST_CHECK_EQUAL( G1.delta( 2 ), v1 ); BOOST_CHECK_EQUAL( G1.Delta( 0 ), v01 ); BOOST_CHECK_EQUAL( G1.Delta( 1 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( 2 ), v12 ); BOOST_CHECK_EQUAL( G1.delta( v0 ), v1 ); BOOST_CHECK_EQUAL( G1.delta( v1 ), v02 ); BOOST_CHECK_EQUAL( G1.delta( v2 ), v1 ); BOOST_CHECK_EQUAL( G1.delta( v01 ), v2 ); BOOST_CHECK_EQUAL( G1.delta( v02 ), v1 ); BOOST_CHECK_EQUAL( G1.delta( v12 ), v0 ); BOOST_CHECK_EQUAL( G1.delta( v012 ), VarSet() ); BOOST_CHECK_EQUAL( G1.Delta( v0 ), v01 ); BOOST_CHECK_EQUAL( G1.Delta( v1 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( v2 ), v12 ); BOOST_CHECK_EQUAL( G1.Delta( v01 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( v02 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( v12 ), v012 ); BOOST_CHECK_EQUAL( G1.Delta( v012 ), v012 ); BOOST_CHECK( G1.isConnected() ); BOOST_CHECK( G1.isTree() ); BOOST_CHECK( G1.isBinary() ); BOOST_CHECK( G1.isPairwise() ); BOOST_CHECK( G1.MarkovGraph() == H ); BOOST_CHECK( G1.bipGraph() == K ); BOOST_CHECK( G1.isMaximal( 0 ) ); BOOST_CHECK( G1.isMaximal( 1 ) ); BOOST_CHECK( !G1.isMaximal( 2 ) ); BOOST_CHECK_EQUAL( G1.maximalFactor( 0 ), 0 ); BOOST_CHECK_EQUAL( G1.maximalFactor( 1 ), 1 ); BOOST_CHECK_EQUAL( G1.maximalFactor( 2 ), 0 ); BOOST_CHECK_EQUAL( G1.maximalFactorDomains().size(), 2 ); BOOST_CHECK_EQUAL( G1.maximalFactorDomains()[0], v01 ); BOOST_CHECK_EQUAL( G1.maximalFactorDomains()[1], v12 ); BOOST_CHECK_CLOSE( G1.logScore( std::vector(3,0) ), -dai::log((Real)32.0), tol ); facs.push_back( Factor( v02 ) ); H.addEdge( 0, 2 ); K.addNode2(); K.addEdge( 0, 3 ); K.addEdge( 2, 3 ); FactorGraph G2( facs ); BOOST_CHECK_EQUAL( G2.nrVars(), 3 ); BOOST_CHECK_EQUAL( G2.nrFactors(), 4 ); BOOST_CHECK_EQUAL( G2.nrEdges(), 7 ); BOOST_CHECK_EQUAL( G2.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G2.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G2.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G2.findVars( v01 ), SmallSet( 0, 1 ) ); BOOST_CHECK_EQUAL( G2.findVars( v02 ), SmallSet( 0, 2 ) ); BOOST_CHECK_EQUAL( G2.findVars( v12 ), SmallSet( 1, 2 ) ); BOOST_CHECK_EQUAL( G2.findFactor( v01 ), 0 ); BOOST_CHECK_EQUAL( G2.findFactor( v12 ), 1 ); BOOST_CHECK_EQUAL( G2.findFactor( v1 ), 2 ); BOOST_CHECK_EQUAL( G2.findFactor( v02 ), 3 ); BOOST_CHECK_EQUAL( G2.delta( 0 ), v12 ); BOOST_CHECK_EQUAL( G2.delta( 1 ), v02 ); BOOST_CHECK_EQUAL( G2.delta( 2 ), v01 ); BOOST_CHECK_EQUAL( G2.Delta( 0 ), v012 ); BOOST_CHECK_EQUAL( G2.Delta( 1 ), v012 ); BOOST_CHECK_EQUAL( G2.Delta( 2 ), v012 ); BOOST_CHECK( G2.isConnected() ); BOOST_CHECK( !G2.isTree() ); BOOST_CHECK( G2.isBinary() ); BOOST_CHECK( G2.isPairwise() ); BOOST_CHECK( G2.MarkovGraph() == H ); BOOST_CHECK( G2.bipGraph() == K ); BOOST_CHECK( G2.isMaximal( 0 ) ); BOOST_CHECK( G2.isMaximal( 1 ) ); BOOST_CHECK( !G2.isMaximal( 2 ) ); BOOST_CHECK( G2.isMaximal( 3 ) ); BOOST_CHECK_EQUAL( G2.maximalFactor( 0 ), 0 ); BOOST_CHECK_EQUAL( G2.maximalFactor( 1 ), 1 ); BOOST_CHECK_EQUAL( G2.maximalFactor( 2 ), 0 ); BOOST_CHECK_EQUAL( G2.maximalFactor( 3 ), 3 ); BOOST_CHECK_EQUAL( G2.maximalFactorDomains().size(), 3 ); BOOST_CHECK_EQUAL( G2.maximalFactorDomains()[0], v01 ); BOOST_CHECK_EQUAL( G2.maximalFactorDomains()[1], v12 ); BOOST_CHECK_EQUAL( G2.maximalFactorDomains()[2], v02 ); BOOST_CHECK_CLOSE( G2.logScore( std::vector(3,0) ), -dai::log((Real)128.0), tol ); Var v3( 3, 3 ); VarSet v03( v0, v3 ); VarSet v13( v1, v3 ); VarSet v23( v2, v3 ); VarSet v013 = v01 | v3; VarSet v023 = v02 | v3; VarSet v123 = v12 | v3; VarSet v0123 = v012 | v3; vars.push_back( v3 ); facs.push_back( Factor( v3 ) ); H.addNode(); K.addNode1(); K.addNode2(); K.addEdge( 3, 4 ); FactorGraph G3( facs ); BOOST_CHECK_EQUAL( G3.nrVars(), 4 ); BOOST_CHECK_EQUAL( G3.nrFactors(), 5 ); BOOST_CHECK_EQUAL( G3.nrEdges(), 8 ); BOOST_CHECK_EQUAL( G3.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G3.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G3.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G3.findVar( v3 ), 3 ); BOOST_CHECK_EQUAL( G3.findVars( v01 ), SmallSet( 0, 1 ) ); BOOST_CHECK_EQUAL( G3.findVars( v02 ), SmallSet( 0, 2 ) ); BOOST_CHECK_EQUAL( G3.findVars( v12 ), SmallSet( 1, 2 ) ); BOOST_CHECK_EQUAL( G3.findFactor( v01 ), 0 ); BOOST_CHECK_EQUAL( G3.findFactor( v12 ), 1 ); BOOST_CHECK_EQUAL( G3.findFactor( v1 ), 2 ); BOOST_CHECK_EQUAL( G3.findFactor( v02 ), 3 ); BOOST_CHECK_EQUAL( G3.findFactor( v3 ), 4 ); BOOST_CHECK_THROW( G3.findFactor( v23 ), Exception ); BOOST_CHECK_EQUAL( G3.delta( 0 ), v12 ); BOOST_CHECK_EQUAL( G3.delta( 1 ), v02 ); BOOST_CHECK_EQUAL( G3.delta( 2 ), v01 ); BOOST_CHECK_EQUAL( G3.delta( 3 ), VarSet() ); BOOST_CHECK_EQUAL( G3.Delta( 0 ), v012 ); BOOST_CHECK_EQUAL( G3.Delta( 1 ), v012 ); BOOST_CHECK_EQUAL( G3.Delta( 2 ), v012 ); BOOST_CHECK_EQUAL( G3.Delta( 3 ), v3 ); BOOST_CHECK( !G3.isConnected() ); BOOST_CHECK( !G3.isTree() ); BOOST_CHECK( !G3.isBinary() ); BOOST_CHECK( G3.isPairwise() ); BOOST_CHECK( G3.MarkovGraph() == H ); BOOST_CHECK( G3.bipGraph() == K ); BOOST_CHECK( G3.isMaximal( 0 ) ); BOOST_CHECK( G3.isMaximal( 1 ) ); BOOST_CHECK( !G3.isMaximal( 2 ) ); BOOST_CHECK( G3.isMaximal( 3 ) ); BOOST_CHECK( G3.isMaximal( 4 ) ); BOOST_CHECK_EQUAL( G3.maximalFactor( 0 ), 0 ); BOOST_CHECK_EQUAL( G3.maximalFactor( 1 ), 1 ); BOOST_CHECK_EQUAL( G3.maximalFactor( 2 ), 0 ); BOOST_CHECK_EQUAL( G3.maximalFactor( 3 ), 3 ); BOOST_CHECK_EQUAL( G3.maximalFactor( 4 ), 4 ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains().size(), 4 ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[0], v01 ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[1], v12 ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[2], v02 ); BOOST_CHECK_EQUAL( G3.maximalFactorDomains()[3], v3 ); BOOST_CHECK_CLOSE( G3.logScore( std::vector(4,0) ), -dai::log((Real)384.0), tol ); facs.push_back( Factor( v123 ) ); H.addEdge( 1, 3 ); H.addEdge( 2, 3 ); K.addNode2(); K.addEdge( 1, 5 ); K.addEdge( 2, 5 ); K.addEdge( 3, 5 ); FactorGraph G4( facs ); BOOST_CHECK_EQUAL( G4.nrVars(), 4 ); BOOST_CHECK_EQUAL( G4.nrFactors(), 6 ); BOOST_CHECK_EQUAL( G4.nrEdges(), 11 ); BOOST_CHECK_EQUAL( G4.findVar( v0 ), 0 ); BOOST_CHECK_EQUAL( G4.findVar( v1 ), 1 ); BOOST_CHECK_EQUAL( G4.findVar( v2 ), 2 ); BOOST_CHECK_EQUAL( G4.findVar( v3 ), 3 ); BOOST_CHECK_EQUAL( G4.findVars( v01 ), SmallSet( 0, 1 ) ); BOOST_CHECK_EQUAL( G4.findVars( v02 ), SmallSet( 0, 2 ) ); BOOST_CHECK_EQUAL( G4.findVars( v12 ), SmallSet( 1, 2 ) ); BOOST_CHECK_EQUAL( G4.findFactor( v01 ), 0 ); BOOST_CHECK_EQUAL( G4.findFactor( v12 ), 1 ); BOOST_CHECK_EQUAL( G4.findFactor( v1 ), 2 ); BOOST_CHECK_EQUAL( G4.findFactor( v02 ), 3 ); BOOST_CHECK_EQUAL( G4.findFactor( v3 ), 4 ); BOOST_CHECK_EQUAL( G4.findFactor( v123 ), 5 ); BOOST_CHECK_THROW( G4.findFactor( v23 ), Exception ); BOOST_CHECK_EQUAL( G4.delta( 0 ), v12 ); BOOST_CHECK_EQUAL( G4.delta( 1 ), v023 ); BOOST_CHECK_EQUAL( G4.delta( 2 ), v013 ); BOOST_CHECK_EQUAL( G4.delta( 3 ), v12 ); BOOST_CHECK_EQUAL( G4.Delta( 0 ), v012 ); BOOST_CHECK_EQUAL( G4.Delta( 1 ), v0123 ); BOOST_CHECK_EQUAL( G4.Delta( 2 ), v0123 ); BOOST_CHECK_EQUAL( G4.Delta( 3 ), v123 ); BOOST_CHECK( G4.isConnected() ); BOOST_CHECK( !G4.isTree() ); BOOST_CHECK( !G4.isBinary() ); BOOST_CHECK( !G4.isPairwise() ); BOOST_CHECK( G4.MarkovGraph() == H ); BOOST_CHECK( G4.bipGraph() == K ); BOOST_CHECK( G4.isMaximal( 0 ) ); BOOST_CHECK( !G4.isMaximal( 1 ) ); BOOST_CHECK( !G4.isMaximal( 2 ) ); BOOST_CHECK( G4.isMaximal( 3 ) ); BOOST_CHECK( !G4.isMaximal( 4 ) ); BOOST_CHECK( G4.isMaximal( 5 ) ); BOOST_CHECK_EQUAL( G4.maximalFactor( 0 ), 0 ); BOOST_CHECK_EQUAL( G4.maximalFactor( 1 ), 5 ); BOOST_CHECK_EQUAL( G4.maximalFactor( 2 ), 0 ); BOOST_CHECK_EQUAL( G4.maximalFactor( 3 ), 3 ); BOOST_CHECK_EQUAL( G4.maximalFactor( 4 ), 5 ); BOOST_CHECK_EQUAL( G4.maximalFactor( 5 ), 5 ); BOOST_CHECK_EQUAL( G4.maximalFactorDomains().size(), 3 ); BOOST_CHECK_EQUAL( G4.maximalFactorDomains()[0], v01 ); BOOST_CHECK_EQUAL( G4.maximalFactorDomains()[1], v02 ); BOOST_CHECK_EQUAL( G4.maximalFactorDomains()[2], v123 ); BOOST_CHECK_CLOSE( G4.logScore( std::vector(4,0) ), -dai::log((Real)4608.0), tol ); } BOOST_AUTO_TEST_CASE( BackupRestoreTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; std::vector facs; facs.push_back( Factor( v01 ) ); facs.push_back( Factor( v12 ) ); facs.push_back( Factor( v1 ) ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); FactorGraph G( facs ); FactorGraph Gorg( G ); BOOST_CHECK_THROW( G.setFactor( 0, Factor( v0 ), false ), Exception ); G.setFactor( 0, Factor( v01, 2.0 ), false ); BOOST_CHECK_THROW( G.restoreFactor( 0 ), Exception ); G.setFactor( 0, Factor( v01, 3.0 ), true ); G.restoreFactor( 0 ); BOOST_CHECK_EQUAL( G.factor( 0 )[0], 2.0 ); G.setFactor( 0, Gorg.factor( 0 ), false ); G.backupFactor( 0 ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); G.setFactor( 0, Factor( v01, 2.0 ), false ); BOOST_CHECK_EQUAL( G.factor( 0 )[0], 2.0 ); G.restoreFactor( 0 ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); std::map fs; fs[0] = Factor( v01, 3.0 ); fs[2] = Factor( v1, 2.0 ); G.setFactors( fs, false ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); G.restoreFactors(); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); G = Gorg; BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); G.setFactors( fs, true ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); G.restoreFactors(); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); std::set fsind; fsind.insert( 0 ); fsind.insert( 2 ); G.backupFactors( fsind ); G.setFactors( fs, false ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); G.restoreFactors(); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); G.backupFactors( v2 ); G.setFactor( 1, Factor(v12, 5.0) ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Factor(v12, 5.0) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); G.restoreFactors( v2 ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); G.backupFactors( v1 ); fs[1] = Factor( v12, 5.0 ); G.setFactors( fs, false ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(1), fs[1] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); G.restoreFactors(); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); G.setFactors( fs, true ); BOOST_CHECK_EQUAL( G.factor(0), fs[0] ); BOOST_CHECK_EQUAL( G.factor(1), fs[1] ); BOOST_CHECK_EQUAL( G.factor(2), fs[2] ); G.restoreFactors( v1 ); BOOST_CHECK_EQUAL( G.factor(0), Gorg.factor(0) ); BOOST_CHECK_EQUAL( G.factor(1), Gorg.factor(1) ); BOOST_CHECK_EQUAL( G.factor(2), Gorg.factor(2) ); } BOOST_AUTO_TEST_CASE( TransformationsTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; std::vector facs; facs.push_back( Factor( v01 ).randomize() ); facs.push_back( Factor( v12 ).randomize() ); facs.push_back( Factor( v1 ).randomize() ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); FactorGraph G( facs ); FactorGraph Gsmall = G.maximalFactors(); BOOST_CHECK_EQUAL( Gsmall.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gsmall.nrFactors(), 2 ); BOOST_CHECK_EQUAL( Gsmall.factor( 0 ), G.factor( 0 ) * G.factor( 2 ) ); BOOST_CHECK_EQUAL( Gsmall.factor( 1 ), G.factor( 1 ) ); size_t i = 0; for( size_t x = 0; x < 2; x++ ) { FactorGraph Gcl = G.clamped( i, x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); BOOST_CHECK_EQUAL( Gcl.factor(0), createFactorDelta(vars[i], x) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(0).slice(vars[i], x) * G.factor(2) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(1) ); } i = 1; for( size_t x = 0; x < 2; x++ ) { FactorGraph Gcl = G.clamped( i, x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); BOOST_CHECK_EQUAL( Gcl.factor(0), createFactorDelta(vars[i], x) * G.factor(2).slice(vars[i],x) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(0).slice(vars[i], x) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(1).slice(vars[i], x) ); } i = 2; for( size_t x = 0; x < 2; x++ ) { FactorGraph Gcl = G.clamped( i, x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); BOOST_CHECK_EQUAL( Gcl.factor(0), createFactorDelta(vars[i], x) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(0) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(1).slice(vars[i], x) * G.factor(2) ); } } BOOST_AUTO_TEST_CASE( OperationsTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; std::vector facs; facs.push_back( Factor( v01 ).randomize() ); facs.push_back( Factor( v12 ).randomize() ); facs.push_back( Factor( v1 ).randomize() ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); FactorGraph G( facs ); // clamp FactorGraph Gcl = G; for( size_t i = 0; i < 3; i++ ) for( size_t x = 0; x < 2; x++ ) { Gcl.clamp( i, x, true ); Factor delta = createFactorDelta( vars[i], x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); for( size_t j = 0; j < 3; j++ ) if( G.factor(j).vars().contains( vars[i] ) ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) * delta ); else BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); Gcl.restoreFactors(); for( size_t j = 0; j < 3; j++ ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); } // clampVar for( size_t i = 0; i < 3; i++ ) for( size_t x = 0; x < 2; x++ ) { Gcl.clampVar( i, std::vector(1, x), true ); Factor delta = createFactorDelta( vars[i], x ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); for( size_t j = 0; j < 3; j++ ) if( G.factor(j).vars().contains( vars[i] ) ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) * delta ); else BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); Gcl.restoreFactors(); for( size_t j = 0; j < 3; j++ ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); } for( size_t i = 0; i < 3; i++ ) for( size_t x = 0; x < 2; x++ ) { Gcl.clampVar( i, std::vector(), true ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); for( size_t j = 0; j < 3; j++ ) if( G.factor(j).vars().contains( vars[i] ) ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) * 0.0 ); else BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); Gcl.restoreFactors(); for( size_t j = 0; j < 3; j++ ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); } std::vector both; both.push_back( 0 ); both.push_back( 1 ); for( size_t i = 0; i < 3; i++ ) for( size_t x = 0; x < 2; x++ ) { Gcl.clampVar( i, both, true ); BOOST_CHECK_EQUAL( Gcl.nrVars(), 3 ); BOOST_CHECK_EQUAL( Gcl.nrFactors(), 3 ); for( size_t j = 0; j < 3; j++ ) BOOST_CHECK_EQUAL( Gcl.factor(j), G.factor(j) ); Gcl.restoreFactors(); } // clampFactor for( size_t x = 0; x < 4; x++ ) { Gcl.clampFactor( 0, std::vector(1,x), true ); Factor mask( v01, 0.0 ); mask.set( x, 1.0 ); BOOST_CHECK_EQUAL( Gcl.factor(0), G.factor(0) * mask ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(1) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(2) ); Gcl.restoreFactor( 0 ); } for( size_t x = 0; x < 4; x++ ) { Gcl.clampFactor( 1, std::vector(1,x), true ); Factor mask( v12, 0.0 ); mask.set( x, 1.0 ); BOOST_CHECK_EQUAL( Gcl.factor(0), G.factor(0) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(1) * mask ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(2) ); Gcl.restoreFactor( 1 ); } for( size_t x = 0; x < 2; x++ ) { Gcl.clampFactor( 2, std::vector(1,x), true ); Factor mask( v1, 0.0 ); mask.set( x, 1.0 ); BOOST_CHECK_EQUAL( Gcl.factor(0), G.factor(0) ); BOOST_CHECK_EQUAL( Gcl.factor(1), G.factor(1) ); BOOST_CHECK_EQUAL( Gcl.factor(2), G.factor(2) * mask ); Gcl.restoreFactors(); } // makeCavity FactorGraph Gcav( G ); Gcav.makeCavity( 0, true ); BOOST_CHECK_EQUAL( Gcav.factor(0), Factor( v01, 1.0 ) ); BOOST_CHECK_EQUAL( Gcav.factor(1), G.factor(1) ); BOOST_CHECK_EQUAL( Gcav.factor(2), G.factor(2) ); Gcav.restoreFactors(); Gcav.makeCavity( 1, true ); BOOST_CHECK_EQUAL( Gcav.factor(0), Factor( v01, 1.0 ) ); BOOST_CHECK_EQUAL( Gcav.factor(1), Factor( v12, 1.0 ) ); BOOST_CHECK_EQUAL( Gcav.factor(2), Factor( v1, 1.0 ) ); Gcav.restoreFactors(); Gcav.makeCavity( 2, true ); BOOST_CHECK_EQUAL( Gcav.factor(0), G.factor(0) ); BOOST_CHECK_EQUAL( Gcav.factor(1), Factor( v12, 1.0 ) ); BOOST_CHECK_EQUAL( Gcav.factor(2), G.factor(2) ); Gcav.restoreFactors(); } BOOST_AUTO_TEST_CASE( IOTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v12( v1, v2 ); VarSet v012 = v01 | v2; std::vector facs; facs.push_back( Factor( v01 ).randomize() ); facs.push_back( Factor( v12 ).randomize() ); facs.push_back( Factor( v1 ).randomize() ); std::vector vars; vars.push_back( v0 ); vars.push_back( v1 ); vars.push_back( v2 ); FactorGraph G( facs ); G.WriteToFile( "factorgraph_test.fg" ); FactorGraph G2; G2.ReadFromFile( "factorgraph_test.fg" ); BOOST_CHECK( G.vars() == G2.vars() ); BOOST_CHECK( G.bipGraph() == G2.bipGraph() ); BOOST_CHECK_EQUAL( G.nrFactors(), G2.nrFactors() ); for( size_t I = 0; I < G.nrFactors(); I++ ) { BOOST_CHECK( G.factor(I).vars() == G2.factor(I).vars() ); for( size_t s = 0; s < G.factor(I).nrStates(); s++ ) BOOST_CHECK_CLOSE( G.factor(I)[s], G2.factor(I)[s], tol ); } std::stringstream ss; std::string s; G.printDot( ss ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "graph FactorGraph {" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=circle,width=0.4,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tv0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tv1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tv2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=box,width=0.3,height=0.3,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tf0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tf1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tf2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tv0 -- f0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tv1 -- f0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tv1 -- f1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tv1 -- f2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tv2 -- f1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "}" ); G.setFactor( 0, Factor( G.factor(0).vars(), 1.0 ) ); G.setFactor( 1, Factor( G.factor(1).vars(), 2.0 ) ); G.setFactor( 2, Factor( G.factor(2).vars(), 3.0 ) ); ss << G; std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "3" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "2" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "0 1 " ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "2 2 " ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "4" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "0 1" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "1 1" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "2 1" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "3 1" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "2" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "1 2 " ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "2 2 " ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "4" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "0 2" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "1 2" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "2 2" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "3 2" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "1" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "1 " ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "2 " ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "2" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "0 3" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "1 3" ); ss << G; FactorGraph G3; ss >> G3; BOOST_CHECK( G.vars() == G3.vars() ); BOOST_CHECK( G.bipGraph() == G3.bipGraph() ); BOOST_CHECK_EQUAL( G.nrFactors(), G3.nrFactors() ); for( size_t I = 0; I < G.nrFactors(); I++ ) { BOOST_CHECK( G.factor(I).vars() == G3.factor(I).vars() ); for( size_t s = 0; s < G.factor(I).nrStates(); s++ ) BOOST_CHECK_CLOSE( G.factor(I)[s], G3.factor(I)[s], tol ); } } libDAI-0.2.7/tests/unit/graph_test.cpp0000644000263000017630000004413011433220722016443 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; #define BOOST_TEST_MODULE GraphALTest #include BOOST_AUTO_TEST_CASE( ConstructorsTest ) { // check constructors GraphAL G0; BOOST_CHECK_EQUAL( G0.nrNodes(), 0 ); BOOST_CHECK_EQUAL( G0.nrEdges(), 0 ); BOOST_CHECK_EQUAL( G0.isConnected(), true ); BOOST_CHECK_EQUAL( G0.isTree(), true ); G0.checkConsistency(); GraphAL G2( 2 ); BOOST_CHECK_EQUAL( G2.nrNodes(), 2 ); BOOST_CHECK_EQUAL( G2.nrEdges(), 0 ); BOOST_CHECK_EQUAL( G2.isConnected(), false ); BOOST_CHECK_EQUAL( G2.isTree(), false ); G2.checkConsistency(); BOOST_CHECK( !(G2 == G0) ); std::vector edges; edges.push_back( Edge( 0, 1 ) ); edges.push_back( Edge( 1, 2 ) ); edges.push_back( Edge( 2, 1 ) ); edges.push_back( Edge( 1, 2 ) ); GraphAL G3( 3, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G3.nrNodes(), 3 ); BOOST_CHECK_EQUAL( G3.nrEdges(), 2 ); BOOST_CHECK_EQUAL( G3.isConnected(), true ); BOOST_CHECK_EQUAL( G3.isTree(), true ); G3.checkConsistency(); BOOST_CHECK( !(G3 == G0) ); BOOST_CHECK( !(G3 == G2) ); GraphAL G4( G3 ); BOOST_CHECK( !(G4 == G0) ); BOOST_CHECK( !(G4 == G2) ); BOOST_CHECK( G4 == G3 ); GraphAL G5 = G3; BOOST_CHECK( !(G5 == G0) ); BOOST_CHECK( !(G5 == G2) ); BOOST_CHECK( G5 == G3 ); } BOOST_AUTO_TEST_CASE( NeighborTest ) { // check nb() accessor / mutator std::vector edges; edges.push_back( Edge( 0, 1 ) ); edges.push_back( Edge( 1, 2 ) ); GraphAL G( 3, edges.begin(), edges.end() ); BOOST_CHECK_EQUAL( G.nb(0).size(), 1 ); BOOST_CHECK_EQUAL( G.nb(1).size(), 2 ); BOOST_CHECK_EQUAL( G.nb(2).size(), 1 ); BOOST_CHECK_EQUAL( G.nb(0,0).iter, 0 ); BOOST_CHECK_EQUAL( G.nb(0,0).node, 1 ); BOOST_CHECK_EQUAL( G.nb(0,0).dual, 0 ); BOOST_CHECK_EQUAL( G.nb(1,0).iter, 0 ); BOOST_CHECK_EQUAL( G.nb(1,0).node, 0 ); BOOST_CHECK_EQUAL( G.nb(1,0).dual, 0 ); BOOST_CHECK_EQUAL( G.nb(1,1).iter, 1 ); BOOST_CHECK_EQUAL( G.nb(1,1).node, 2 ); BOOST_CHECK_EQUAL( G.nb(1,1).dual, 0 ); BOOST_CHECK_EQUAL( G.nb(2,0).iter, 0 ); BOOST_CHECK_EQUAL( G.nb(2,0).node, 1 ); BOOST_CHECK_EQUAL( G.nb(2,0).dual, 1 ); BOOST_CHECK( G.nbSet(0) == SmallSet( 1 ) ); BOOST_CHECK( G.nbSet(1) == SmallSet( 0, 2 ) ); BOOST_CHECK( G.nbSet(2) == SmallSet( 1 ) ); } BOOST_AUTO_TEST_CASE( AddEraseTest ) { // check addition and erasure of nodes and edges std::vector edges; edges.push_back( Edge( 0, 1 ) ); edges.push_back( Edge( 1, 2 ) ); edges.push_back( Edge( 1, 0 ) ); GraphAL G( 2 ); G.construct( 3, edges.begin(), edges.end() ); G.checkConsistency(); BOOST_CHECK_EQUAL( G.nrNodes(), 3 ); BOOST_CHECK_EQUAL( G.nrEdges(), 2 ); BOOST_CHECK_EQUAL( G.addNode(), 3 ); G.checkConsistency(); std::vector nbs; nbs.push_back( 3 ); BOOST_CHECK_EQUAL( G.addNode( nbs.begin(), nbs.end() ), 4 ); BOOST_CHECK_EQUAL( G.addNode(), 5 ); G.checkConsistency(); G.addEdge( 0, 4 ); G.checkConsistency(); G.addEdge( 0, 5 ); BOOST_CHECK( G.isTree() ); G.checkConsistency(); BOOST_CHECK_EQUAL( G.nrNodes(), 6 ); BOOST_CHECK_EQUAL( G.nrEdges(), 5 ); G.addEdge( 2, 3 ); BOOST_CHECK( !G.isTree() ); G.addEdge( 5, 3 ); G.eraseNode( 0 ); G.checkConsistency(); BOOST_CHECK( G.isTree() ); G.eraseEdge( 0, 1 ); G.checkConsistency(); BOOST_CHECK( !G.isTree() ); BOOST_CHECK( !G.isConnected() ); G.eraseNode( 0 ); G.checkConsistency(); BOOST_CHECK( G.isTree() ); G.addEdge( 3, 2 ); G.checkConsistency(); BOOST_CHECK( !G.isTree() ); G.eraseNode( 1 ); G.checkConsistency(); BOOST_CHECK( !G.isTree() ); BOOST_CHECK( !G.isConnected() ); G.eraseNode( 2 ); G.checkConsistency(); BOOST_CHECK( !G.isTree() ); BOOST_CHECK( !G.isConnected() ); G.addEdge( 1, 0 ); G.checkConsistency(); BOOST_CHECK( G.isTree() ); BOOST_CHECK( G.isConnected() ); G.eraseNode( 1 ); G.checkConsistency(); BOOST_CHECK( G.isTree() ); BOOST_CHECK( G.isConnected() ); G.eraseNode( 0 ); BOOST_CHECK( G.isTree() ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK_EQUAL( G.nrNodes(), 0 ); BOOST_CHECK_EQUAL( G.nrEdges(), 0 ); G.addNode(); G.addNode(); G.addNode(); G.addNode(); G.addEdge( 0, 1 ); G.addEdge( 2, 3 ); G.addEdge( 0, 3 ); G.checkConsistency(); G.eraseNode( 2 ); G.checkConsistency(); } BOOST_AUTO_TEST_CASE( RandomAddEraseTest ) { // check adding and erasing nodes and edges randomly GraphAL G; for( size_t maxN = 2; maxN < 50; maxN++ ) for( size_t repeats = 0; repeats < 10000; repeats++ ) { size_t action = rnd( 5 ); size_t N = G.nrNodes(); size_t M = G.nrEdges(); size_t maxM = N * (N - 1) / 2; if( action == 0 ) { // add node if( N < maxN ) G.addNode(); } else if( action == 1 ) { // erase node if( N > 0 ) G.eraseNode( rnd( N ) ); } else if( action == 2 || action == 3 ) { // add edge if( N >= 2 && M < maxM ) { size_t n1 = 0; do { n1 = rnd( N ); } while( G.nb(n1).size() >= N - 1 ); size_t n2 = 0; do { n2 = rnd( N ); } while( G.hasEdge( n1, n2 ) ); G.addEdge( n1, n2 ); } } else if( action == 4 ) { // erase edge if( M > 0 ) { size_t n1 = 0; do { n1 = rnd( N ); } while( G.nb(n1).size() == 0 ); size_t n2 = 0; do { n2 = rnd( N ); } while( !G.hasEdge( n1, n2 ) ); G.eraseEdge( n1, n2 ); } } G.checkConsistency(); } } BOOST_AUTO_TEST_CASE( QueriesAndCreationTest ) { // check queries and createGraph* functions // createGraphFull for( size_t N = 0; N < 20; N++ ) { GraphAL G = createGraphFull( N ); BOOST_CHECK_EQUAL( G.nrNodes(), N ); BOOST_CHECK_EQUAL( G.nrEdges(), N > 0 ? N * (N-1) / 2 : 0 ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK_EQUAL( G.isTree(), N < 3 ); for( size_t n1 = 0; n1 < G.nrNodes(); n1++ ) { foreach( const Neighbor &n2, G.nb(n1) ) { BOOST_CHECK( G.hasEdge( n1, n2 ) ); BOOST_CHECK( G.hasEdge( n2, n1 ) ); } for( size_t n2 = 0; n2 < G.nrNodes(); n2++ ) if( G.hasEdge( n1, n2 ) ) { BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ), n2 ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ), n1 ); BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ).iter, G.findNb( n1, n2 ) ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ).iter, G.findNb( n2, n1 ) ); } } G.checkConsistency(); } // createGraphGrid for( size_t N1 = 0; N1 < 10; N1++ ) for( size_t N2 = 0; N2 < 10; N2++ ) { GraphAL G = createGraphGrid( N1, N2, false ); BOOST_CHECK_EQUAL( G.nrNodes(), N1 * N2 ); BOOST_CHECK_EQUAL( G.nrEdges(), (N1 > 0 && N2 > 0) ? 2 * (N1-1) * (N2-1) + (N1-1) + (N2-1) : 0 ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK_EQUAL( G.isTree(), (N1 <= 1) || (N2 <= 1) ); for( size_t n1 = 0; n1 < G.nrNodes(); n1++ ) { foreach( const Neighbor &n2, G.nb(n1) ) { BOOST_CHECK( G.hasEdge( n1, n2 ) ); BOOST_CHECK( G.hasEdge( n2, n1 ) ); } for( size_t n2 = 0; n2 < G.nrNodes(); n2++ ) if( G.hasEdge( n1, n2 ) ) { BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ), n2 ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ), n1 ); BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ).iter, G.findNb( n1, n2 ) ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ).iter, G.findNb( n2, n1 ) ); } } G.checkConsistency(); G = createGraphGrid( N1, N2, true ); BOOST_CHECK_EQUAL( G.nrNodes(), N1 * N2 ); if( N1 == 0 || N2 == 0 ) BOOST_CHECK_EQUAL( G.nrEdges(), 0 ); else BOOST_CHECK_EQUAL( G.nrEdges(), (N1 <= 2 ? (N1-1) : N1) * N2 + N1 * (N2 <= 2 ? (N2-1) : N2) ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK_EQUAL( G.isTree(), (G.nrNodes() <= 2) ); for( size_t n1 = 0; n1 < G.nrNodes(); n1++ ) { foreach( const Neighbor &n2, G.nb(n1) ) { BOOST_CHECK( G.hasEdge( n1, n2 ) ); BOOST_CHECK( G.hasEdge( n2, n1 ) ); } for( size_t n2 = 0; n2 < G.nrNodes(); n2++ ) if( G.hasEdge( n1, n2 ) ) { BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ), n2 ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ), n1 ); BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ).iter, G.findNb( n1, n2 ) ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ).iter, G.findNb( n2, n1 ) ); } } G.checkConsistency(); } // createGraphGrid3D for( size_t N1 = 0; N1 < 8; N1++ ) for( size_t N2 = 0; N2 < 8; N2++ ) for( size_t N3 = 0; N3 < 8; N3++ ) { GraphAL G = createGraphGrid3D( N1, N2, N3, false ); BOOST_CHECK_EQUAL( G.nrNodes(), N1 * N2 * N3 ); BOOST_CHECK_EQUAL( G.nrEdges(), (N1 > 0 && N2 > 0 && N3 > 0) ? 3 * (N1-1) * (N2-1) * (N3-1) + 2 * (N1-1) * (N2-1) + 2 * (N1-1) * (N3-1) + 2 * (N2-1) * (N3-1) + (N1-1) + (N2-1) + (N3-1) : 0 ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK_EQUAL( G.isTree(), (G.nrNodes() == 0) || (N1 <= 1 && N2 <= 1) || (N1 <= 1 && N3 <= 1) || (N2 <= 1 && N3 <= 1) ); for( size_t n1 = 0; n1 < G.nrNodes(); n1++ ) { foreach( const Neighbor &n2, G.nb(n1) ) { BOOST_CHECK( G.hasEdge( n1, n2 ) ); BOOST_CHECK( G.hasEdge( n2, n1 ) ); } for( size_t n2 = 0; n2 < G.nrNodes(); n2++ ) if( G.hasEdge( n1, n2 ) ) { BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ), n2 ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ), n1 ); BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ).iter, G.findNb( n1, n2 ) ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ).iter, G.findNb( n2, n1 ) ); } } G.checkConsistency(); G = createGraphGrid3D( N1, N2, N3, true ); BOOST_CHECK_EQUAL( G.nrNodes(), N1 * N2 * N3 ); if( N1 == 0 || N2 == 0 || N3 == 0 ) BOOST_CHECK_EQUAL( G.nrEdges(), 0 ); else BOOST_CHECK_EQUAL( G.nrEdges(), (N1 <= 2 ? (N1-1) : N1) * N2 * N3 + N1 * (N2 <= 2 ? (N2-1) : N2) * N3 + N1 * N2 * (N3 <= 2 ? (N3-1) : N3) ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK_EQUAL( G.isTree(), (G.nrNodes() <= 2) ); for( size_t n1 = 0; n1 < G.nrNodes(); n1++ ) { foreach( const Neighbor &n2, G.nb(n1) ) { BOOST_CHECK( G.hasEdge( n1, n2 ) ); BOOST_CHECK( G.hasEdge( n2, n1 ) ); } for( size_t n2 = 0; n2 < G.nrNodes(); n2++ ) if( G.hasEdge( n1, n2 ) ) { BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ), n2 ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ), n1 ); BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ).iter, G.findNb( n1, n2 ) ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ).iter, G.findNb( n2, n1 ) ); } } G.checkConsistency(); } // createGraphLoop for( size_t N = 0; N < 100; N++ ) { GraphAL G = createGraphLoop( N ); BOOST_CHECK_EQUAL( G.nrNodes(), N ); if( N == 0 ) BOOST_CHECK_EQUAL( G.nrEdges(), 0 ); else if( N <= 2 ) BOOST_CHECK_EQUAL( G.nrEdges(), N-1 ); else BOOST_CHECK_EQUAL( G.nrEdges(), N ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK_EQUAL( G.isTree(), N <= 2 ); for( size_t n1 = 0; n1 < G.nrNodes(); n1++ ) { foreach( const Neighbor &n2, G.nb(n1) ) { BOOST_CHECK( G.hasEdge( n1, n2 ) ); BOOST_CHECK( G.hasEdge( n2, n1 ) ); } for( size_t n2 = 0; n2 < G.nrNodes(); n2++ ) if( G.hasEdge( n1, n2 ) ) { BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ), n2 ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ), n1 ); BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ).iter, G.findNb( n1, n2 ) ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ).iter, G.findNb( n2, n1 ) ); } } G.checkConsistency(); } // createGraphTree for( size_t N = 0; N < 100; N++ ) { GraphAL G = createGraphTree( N ); BOOST_CHECK_EQUAL( G.nrNodes(), N ); BOOST_CHECK_EQUAL( G.nrEdges(), N > 0 ? N - 1 : N ); BOOST_CHECK( G.isConnected() ); BOOST_CHECK( G.isTree() ); for( size_t n1 = 0; n1 < G.nrNodes(); n1++ ) { foreach( const Neighbor &n2, G.nb(n1) ) { BOOST_CHECK( G.hasEdge( n1, n2 ) ); BOOST_CHECK( G.hasEdge( n2, n1 ) ); } for( size_t n2 = 0; n2 < G.nrNodes(); n2++ ) if( G.hasEdge( n1, n2 ) ) { BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ), n2 ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ), n1 ); BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ).iter, G.findNb( n1, n2 ) ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ).iter, G.findNb( n2, n1 ) ); } } G.checkConsistency(); } // createGraphRegular for( size_t N = 0; N < 50; N++ ) { for( size_t d = 0; d < N && d <= 15; d++ ) { if( (N * d) % 2 == 0 ) { GraphAL G = createGraphRegular( N, d ); BOOST_CHECK_EQUAL( G.nrNodes(), N ); BOOST_CHECK_EQUAL( G.nrEdges(), d * N / 2 ); for( size_t n1 = 0; n1 < G.nrNodes(); n1++ ) { BOOST_CHECK_EQUAL( G.nb(n1).size(), d ); foreach( const Neighbor &n2, G.nb(n1) ) { BOOST_CHECK( G.hasEdge( n1, n2 ) ); BOOST_CHECK( G.hasEdge( n2, n1 ) ); } for( size_t n2 = 0; n2 < G.nrNodes(); n2++ ) if( G.hasEdge( n1, n2 ) ) { BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ), n2 ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ), n1 ); BOOST_CHECK_EQUAL( G.nb( n1, G.findNb( n1, n2 ) ).iter, G.findNb( n1, n2 ) ); BOOST_CHECK_EQUAL( G.nb( n2, G.findNb( n2, n1 ) ).iter, G.findNb( n2, n1 ) ); } } G.checkConsistency(); } } } } BOOST_AUTO_TEST_CASE( StreamTest ) { // check printDot GraphAL G( 4 ); G.addEdge( 0, 1 ); G.addEdge( 0, 2 ); G.addEdge( 1, 3 ); G.addEdge( 2, 3 ); G.addEdge( 2, 2 ); G.addEdge( 3, 2 ); std::stringstream ss; std::string s; G.printDot( ss ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "graph GraphAL {" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=circle,width=0.4,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -- x1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -- x2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1 -- x3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx2 -- x3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "}" ); ss << G; std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "graph GraphAL {" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "node[shape=circle,width=0.4,fixedsize=true];" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -- x1;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx0 -- x2;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx1 -- x3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "\tx2 -- x3;" ); std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "}" ); } libDAI-0.2.7/tests/unit/daialg_test.cpp0000644000263000017630000001203711433220722016564 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; const double tol = 1e-8; #define BOOST_TEST_MODULE DAIAlgTest #include BOOST_AUTO_TEST_CASE( calcMarginalTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); Var v3( 3, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v03( v0, v3 ); VarSet v12( v1, v2 ); VarSet v13( v1, v3 ); VarSet v23( v2, v3 ); std::vector facs; facs.push_back( createFactorIsing( v0, v1, 1.0 ) ); facs.push_back( createFactorIsing( v1, v2, 1.0 ) ); facs.push_back( createFactorIsing( v2, v3, 1.0 ) ); facs.push_back( createFactorIsing( v3, v0, 1.0 ) ); facs.push_back( createFactorIsing( v0, -1.0 ) ); facs.push_back( createFactorIsing( v1, -1.0 ) ); facs.push_back( createFactorIsing( v2, -1.0 ) ); facs.push_back( createFactorIsing( v3, 1.0 ) ); Factor joint = facs[0] * facs[1] * facs[2] * facs[3] * facs[4] * facs[5] * facs[6] * facs[7]; FactorGraph fg( facs ); ExactInf ei( fg, PropertySet()("verbose",(size_t)0) ); ei.init(); ei.run(); VarSet vs; vs = v0; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v1; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v2; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v3; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v01; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v02; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v03; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v12; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v13; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v23; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v01 | v2; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v01 | v3; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v02 | v3; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v12 | v3; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); vs = v01 | v23; BOOST_CHECK( dist( calcMarginal( ei, vs, false ), joint.marginal( vs ), DISTTV ) < tol ); } BOOST_AUTO_TEST_CASE( calcPairBeliefsTest ) { Var v0( 0, 2 ); Var v1( 1, 2 ); Var v2( 2, 2 ); Var v3( 3, 2 ); VarSet v01( v0, v1 ); VarSet v02( v0, v2 ); VarSet v03( v0, v3 ); VarSet v12( v1, v2 ); VarSet v13( v1, v3 ); VarSet v23( v2, v3 ); std::vector facs; facs.push_back( createFactorIsing( v0, v1, 1.0 ) ); facs.push_back( createFactorIsing( v1, v2, 1.0 ) ); facs.push_back( createFactorIsing( v2, v3, 1.0 ) ); facs.push_back( createFactorIsing( v3, v0, 1.0 ) ); facs.push_back( createFactorIsing( v0, -1.0 ) ); facs.push_back( createFactorIsing( v1, -1.0 ) ); facs.push_back( createFactorIsing( v2, -1.0 ) ); facs.push_back( createFactorIsing( v3, 1.0 ) ); Factor joint = facs[0] * facs[1] * facs[2] * facs[3] * facs[4] * facs[5] * facs[6] * facs[7]; FactorGraph fg( facs ); ExactInf ei( fg, PropertySet()("verbose",(size_t)0) ); ei.init(); ei.run(); VarSet vs; std::vector pb = calcPairBeliefs( ei, v01 | v23, false, false ); BOOST_CHECK( dist( pb[0], joint.marginal( v01 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[1], joint.marginal( v02 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[2], joint.marginal( v03 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[3], joint.marginal( v12 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[4], joint.marginal( v13 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[5], joint.marginal( v23 ), DISTTV ) < tol ); pb = calcPairBeliefs( ei, v01 | v23, false, true ); BOOST_CHECK( dist( pb[0], joint.marginal( v01 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[1], joint.marginal( v02 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[2], joint.marginal( v03 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[3], joint.marginal( v12 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[4], joint.marginal( v13 ), DISTTV ) < tol ); BOOST_CHECK( dist( pb[5], joint.marginal( v23 ), DISTTV ) < tol ); } libDAI-0.2.7/tests/testem/0000755000263000017630000000000011433220722014117 5ustar jorismkyblibDAI-0.2.7/tests/testem/2var.em0000644000263000017630000000011211433220722015306 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1] 1 0 1 0 libDAI-0.2.7/tests/testem/testem.cpp0000644000263000017630000000347011433220722016130 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California Santa Cruz */ #include #include #include #include #include #include using namespace std; using namespace dai; void usage( const string &msg ) { cerr << msg << endl; cerr << "Usage:" << endl; cerr << " testem factorgraph.fg evidence.tab emconfig.em" << endl; exit( 1 ); } int main( int argc, char** argv ) { if( argc != 4 ) usage("Incorrect number of arguments."); FactorGraph fg; fg.ReadFromFile( argv[1] ); PropertySet infprops; infprops.set( "verbose", (size_t)0 ); infprops.set( "updates", string("HUGIN") ); InfAlg* inf = newInfAlg( "JTREE", fg, infprops ); inf->init(); Evidence e; ifstream estream( argv[2] ); e.addEvidenceTabFile( estream, fg ); cout << "Number of samples: " << e.nrSamples() << endl; for( Evidence::iterator ps = e.begin(); ps != e.end(); ps++ ) cout << "Sample #" << (ps - e.begin()) << " has " << ps->size() << " observations." << endl; ifstream emstream( argv[3] ); EMAlg em(e, *inf, emstream); while( !em.hasSatisfiedTermConditions() ) { Real l = em.iterate(); cout << "Iteration " << em.Iterations() << " likelihood: " << l <fg(); delete inf; return 0; } libDAI-0.2.7/tests/testem/2var_data.tab0000644000263000017630000000012511433220722016450 0ustar jorismkyb0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0 1 1 1 1 1 1 1 0 1 0 1 0 1 0 1 0 1 0 1 0 libDAI-0.2.7/tests/testem/testem.out0000644000263000017630000000663611433220722016164 0ustar jorismkybNumber of samples: 20 Sample #0 has 2 observations. Sample #1 has 2 observations. Sample #2 has 2 observations. Sample #3 has 2 observations. Sample #4 has 2 observations. Sample #5 has 2 observations. Sample #6 has 2 observations. Sample #7 has 2 observations. Sample #8 has 2 observations. Sample #9 has 2 observations. Sample #10 has 2 observations. Sample #11 has 2 observations. Sample #12 has 2 observations. Sample #13 has 2 observations. Sample #14 has 2 observations. Sample #15 has 2 observations. Sample #16 has 2 observations. Sample #17 has 2 observations. Sample #18 has 2 observations. Sample #19 has 2 observations. Iteration 1 likelihood: -27.7259 Iteration 2 likelihood: -23.4297 Iteration 3 likelihood: -23.4297 Inferred Factor Graph: ###################### 1 2 0 1 2 2 4 0 0.166666666667 1 0.666666666667 2 0.833333333333 3 0.333333333333 Number of samples: 20 Sample #0 has 2 observations. Sample #1 has 2 observations. Sample #2 has 2 observations. Sample #3 has 2 observations. Sample #4 has 2 observations. Sample #5 has 2 observations. Sample #6 has 2 observations. Sample #7 has 2 observations. Sample #8 has 2 observations. Sample #9 has 2 observations. Sample #10 has 2 observations. Sample #11 has 2 observations. Sample #12 has 2 observations. Sample #13 has 2 observations. Sample #14 has 2 observations. Sample #15 has 2 observations. Sample #16 has 2 observations. Sample #17 has 2 observations. Sample #18 has 2 observations. Sample #19 has 2 observations. Iteration 1 likelihood: -27.7259 Iteration 2 likelihood: -23.7555 Iteration 3 likelihood: -23.7555 Inferred Factor Graph: ###################### 1 3 0 1 2 2 2 2 8 0 0.214285714286 1 0.642857142857 2 0.785714285714 3 0.357142857143 4 0.214285714286 5 0.642857142857 6 0.785714285714 7 0.357142857143 Number of samples: 5 Sample #0 has 5 observations. Sample #1 has 4 observations. Sample #2 has 6 observations. Sample #3 has 6 observations. Sample #4 has 5 observations. Iteration 1 likelihood: -16.4893 Iteration 2 likelihood: -15.4406 Iteration 3 likelihood: -15.3299 Inferred Factor Graph: ###################### 3 3 2 6 7 2 2 2 8 0 0.396387112396 1 0.356649908835 2 0.603612887604 3 0.643350091165 4 0.805779039527 5 0.669278114097 6 0.194220960473 7 0.330721885903 3 0 1 6 2 2 2 8 0 1.03521336269 1 1.54747895212 2 2.31765218974 3 1.28041900719 4 4.922079813 5 2.52725575019 6 0.831279296316 7 0.262805630803 3 1 2 4 2 2 2 8 0 0.396387112396 1 0.603612887604 2 0.356649908835 3 0.643350091165 4 0.805779039527 5 0.194220960473 6 0.669278114097 7 0.330721885903 Number of samples: 5 Sample #0 has 5 observations. Sample #1 has 4 observations. Sample #2 has 6 observations. Sample #3 has 6 observations. Sample #4 has 5 observations. Iteration 1 likelihood: -16.4893 Iteration 2 likelihood: -17.6905 Iteration 3 likelihood: -17.6582 Inferred Factor Graph: ###################### 3 3 2 6 7 2 2 2 8 0 0.495312199726 1 0.499107942908 2 0.504687800274 3 0.500892057092 4 0.640416549958 5 0.495122293924 6 0.359583450042 7 0.504877706076 3 0 1 6 2 2 2 8 0 0.495312199726 1 0.504687800274 2 0.499107942908 3 0.500892057092 4 0.640416549958 5 0.359583450042 6 0.495122293924 7 0.504877706076 3 1 2 4 2 2 2 8 0 0.495312199726 1 0.504687800274 2 0.499107942908 3 0.500892057092 4 0.640416549958 5 0.359583450042 6 0.495122293924 7 0.504877706076 libDAI-0.2.7/tests/testem/runtests.bat0000755000263000017630000000046211433220722016503 0ustar jorismkybtestem 2var.fg 2var_data.tab 2var.em > testem.out.tmp testem 3var.fg 2var_data.tab 3var.em >> testem.out.tmp testem ..\hoi1.fg hoi1_data.tab hoi1_share_f0_f2.em >> testem.out.tmp testem ..\hoi1.fg hoi1_data.tab hoi1_share_f0_f1_f2.em >> testem.out.tmp diff -s testem.out.tmp testem.out del testem.out.tmp libDAI-0.2.7/tests/testem/hoi1_share_f0_f2.em0000644000263000017630000000012411433220722017435 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 2 2 1 2 4 0 6 2 7 libDAI-0.2.7/tests/testem/3var.fg0000644000263000017630000000010211433220722015301 0ustar jorismkyb1 3 0 1 2 2 2 2 8 0 0.5 1 0.5 2 0.5 3 0.5 4 0.5 5 0.5 6 0.5 7 0.5libDAI-0.2.7/tests/testem/2var.fg0000644000263000017630000000004611433220722015307 0ustar jorismkyb1 2 0 1 2 2 4 0 0.5 1 0.5 2 0.5 3 0.5libDAI-0.2.7/tests/testem/runtests0000755000263000017630000000057411433220722015742 0ustar jorismkyb#!/bin/bash TMPFILE1=`mktemp /var/tmp/testem.XXXXXX` trap 'rm -f $TMPFILE1' 0 1 15 ./testem 2var.fg 2var_data.tab 2var.em > $TMPFILE1 ./testem 3var.fg 2var_data.tab 3var.em >> $TMPFILE1 ./testem ../hoi1.fg hoi1_data.tab hoi1_share_f0_f2.em >> $TMPFILE1 ./testem ../hoi1.fg hoi1_data.tab hoi1_share_f0_f1_f2.em >> $TMPFILE1 diff -s $TMPFILE1 testem.out || exit 1 rm -f $TMPFILE1 libDAI-0.2.7/tests/testem/3var.em0000644000263000017630000000011411433220722015311 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 1 0 1 0 2 libDAI-0.2.7/tests/testem/hoi1_data.tab0000644000263000017630000000010511433220722016434 0ustar jorismkyb0 1 2 4 6 7 0 0 1 1 0 1 1 1 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 1 0 libDAI-0.2.7/tests/testem/hoi1_infer_f2.em0000644000263000017630000000011411433220722017050 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 1 2 1 2 4 libDAI-0.2.7/tests/testem/hoi1_share_f0_f1_f2.em0000644000263000017630000000013411433220722020024 0ustar jorismkyb1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 3 2 1 2 4 1 0 1 6 0 6 2 7 libDAI-0.2.7/tests/testall0000755000263000017630000000404411433220722014216 0ustar jorismkyb#!/bin/bash # Marginal inference ./testdai --report-iters false --report-time false --marginals VAR --aliases aliases.conf --filename $1 --methods EXACT JTREE_MINFILL_HUGIN JTREE_MINFILL_SHSH JTREE_WEIGHTEDMINFILL_HUGIN JTREE_WEIGHTEDMINFILL_SHSH JTREE_MINWEIGHT_HUGIN JTREE_MINWEIGHT_SHSH JTREE_MINNEIGHBORS_HUGIN JTREE_MINNEIGHBORS_SHSH BP BP_SEQFIX BP_SEQRND BP_SEQMAX BP_PARALL BP_SEQFIX_LOG BP_SEQRND_LOG BP_SEQMAX_LOG BP_PARALL_LOG FBP FBP_SEQFIX FBP_SEQRND FBP_SEQMAX FBP_PARALL FBP_SEQFIX_LOG FBP_SEQRND_LOG FBP_SEQMAX_LOG FBP_PARALL_LOG TRWBP TRWBP_SEQFIX TRWBP_SEQRND TRWBP_SEQMAX TRWBP_PARALL TRWBP_SEQFIX_LOG TRWBP_SEQRND_LOG TRWBP_SEQMAX_LOG TRWBP_PARALL_LOG MF MF_NAIVE_UNI MF_NAIVE_RND MF_HARDSPIN_UNI MF_HARDSPIN_RND TREEEP TREEEPWC GBP_MIN GBP_BETHE GBP_LOOP3 HAK_MIN HAK_BETHE HAK_DELTA HAK_LOOP3 HAK_LOOP4 HAK_LOOP5 MR_RESPPROP_FULL MR_CLAMPING_FULL MR_EXACT_FULL MR_RESPPROP_LINEAR MR_CLAMPING_LINEAR MR_EXACT_LINEAR LCBP LCBP_FULLCAV_SEQFIX LCBP_FULLCAVin_SEQFIX LCBP_FULLCAV_SEQRND LCBP_FULLCAVin_SEQRND LCBP_FULLCAV_NONE LCBP_FULLCAVin_NONE LCBP_PAIRCAV_SEQFIX LCBP_PAIRCAVin_SEQFIX LCBP_PAIRCAV_SEQRND LCBP_PAIRCAVin_SEQRND LCBP_PAIRCAV_NONE LCBP_PAIRCAVin_NONE LCBP_PAIR2CAV_SEQFIX LCBP_PAIR2CAVin_SEQFIX LCBP_PAIR2CAV_SEQRND LCBP_PAIR2CAVin_SEQRND LCBP_PAIR2CAV_NONE LCBP_PAIR2CAVin_NONE LCBP_UNICAV_SEQFIX LCBP_UNICAV_SEQRND LCTREEEP BBP # GBP_DELTA, GBP_LOOP4, GBP_LOOP5, GBP_LOOP6, GBP_LOOP7 misbehave # MAP inference ./testdai --report-iters false --report-time false --marginals VAR --aliases aliases.conf --filename $1 --methods JTREE_MINFILL_HUGIN_MAP JTREE_MINFILL_SHSH_MAP JTREE_WEIGHTEDMINFILL_HUGIN_MAP JTREE_WEIGHTEDMINFILL_SHSH_MAP JTREE_MINWEIGHT_HUGIN_MAP JTREE_MINWEIGHT_SHSH_MAP JTREE_MINNEIGHBORS_HUGIN_MAP JTREE_MINNEIGHBORS_SHSH_MAP MP_SEQFIX MP_SEQRND MP_PARALL MP_SEQFIX_LOG MP_SEQRND_LOG MP_PARALL_LOG FMP_SEQFIX FMP_SEQRND FMP_PARALL FMP_SEQFIX_LOG FMP_SEQRND_LOG FMP_PARALL_LOG TRWMP_SEQFIX TRWMP_SEQRND TRWMP_PARALL TRWMP_SEQFIX_LOG TRWMP_SEQRND_LOG TRWMP_PARALL_LOG DECMAP # *MP_SEQMAX and *MP_SEQMAX_LOG make no sense, apparently libDAI-0.2.7/tests/maxprodbug.fg0000644000263000017630000000013111433220722015277 0ustar jorismkyb3 2 1 2 2 2 4 0 1 1 0 2 0 3 1 2 1 3 2 2 4 0 1 1 1 2 1 3 1 2 2 3 2 2 4 0 0 1 1 2 1 3 0 libDAI-0.2.7/tests/hoi2.fg0000644000263000017630000000151111433220722013773 0ustar jorismkyb# Factor graph made by ../utils/createfg # type = hoi # N = 10 # M = 2 # k = 4 # beta = 1 # seed = 1234567 2 4 0 2 7 8 2 2 2 2 16 0 2.2435781084647 1 4.0907955014965 2 1.1211049952628 3 1.1924200451373 4 0.6827733720955 5 10.160805816224 6 0.67358126735639 7 0.11391058009404 8 0.48125062895484 9 0.72144061373552 10 0.42394324261549 11 1.8698790799175 12 0.751673014734 13 3.3944709353 14 3.0697466018763 15 1.3518859952286 4 1 2 6 7 2 2 2 2 16 0 0.73767149678205 1 1.0407773095719 2 3.128053583949 3 4.9605310970883 4 0.13720523936748 5 7.321038643904 6 0.32066394017723 7 1.4685064382197 8 0.17120387482343 9 0.98014607500624 10 0.10935224527934 11 0.67077127555589 12 1.1255976822923 13 2.0774604864366 14 0.36868871983683 15 0.8542593124821 libDAI-0.2.7/tests/jtreemapbug.fg0000644000263000017630000000003711433220722015441 0ustar jorismkyb1 2 0 1 2 2 4 0 1 1 2 2 2 3 1 libDAI-0.2.7/tests/testbbp.cpp0000644000263000017630000000767311433220722015002 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace dai; using namespace std; int main( int argc, char *argv[] ) { if ( argc != 2 ) { cout << "Usage: " << argv[0] << " " << endl << endl; cout << "Reads factor graph and verifies" << endl; cout << "whether BBP works correctly on it." << endl << endl; return 1; } else { // Read FactorGraph from the file specified by the first command line argument FactorGraph fg; fg.ReadFromFile(argv[1]); // Set some constants size_t verbose = 0; Real tol = 1.0e-9; size_t maxiter = 10000; Real damping = 0.0; BBP::Properties::UpdateType updates = BBP::Properties::UpdateType::PAR; // Store the constants in a PropertySet object PropertySet opts; opts.set("verbose",verbose); // Verbosity (amount of output generated) opts.set("tol",tol); // Tolerance for convergence opts.set("maxiter",maxiter); // Maximum number of iterations opts.set("damping",damping); // Amount of damping applied // Construct a BP (belief propagation) object from the FactorGraph fg BP bp(fg, opts("updates",string("SEQFIX"))("logdomain",false)); bp.recordSentMessages = true; bp.init(); bp.run(); vector state( fg.nrVars(), 0 ); for( size_t t = 0; t < 45; t++ ) { BBP::Properties::UpdateType updates; switch( t % 5 ) { case BBP::Properties::UpdateType::SEQ_FIX: updates = BBP::Properties::UpdateType::SEQ_FIX; break; case BBP::Properties::UpdateType::SEQ_MAX: updates = BBP::Properties::UpdateType::SEQ_MAX; break; case BBP::Properties::UpdateType::SEQ_BP_REV: updates = BBP::Properties::UpdateType::SEQ_BP_REV; break; case BBP::Properties::UpdateType::SEQ_BP_FWD: updates = BBP::Properties::UpdateType::SEQ_BP_FWD; break; case BBP::Properties::UpdateType::PAR: updates = BBP::Properties::UpdateType::PAR; break; } BBPCostFunction cfn; switch( (t / 5) % 9 ) { case 0: cfn = BBPCostFunction::CFN_GIBBS_B; break; case 1: cfn = BBPCostFunction::CFN_GIBBS_B2; break; case 2: cfn = BBPCostFunction::CFN_GIBBS_EXP; break; case 3: cfn = BBPCostFunction::CFN_GIBBS_B_FACTOR; break; case 4: cfn = BBPCostFunction::CFN_GIBBS_B2_FACTOR; break; case 5: cfn = BBPCostFunction::CFN_GIBBS_EXP_FACTOR; break; case 6: cfn = BBPCostFunction::CFN_VAR_ENT; break; case 7: cfn = BBPCostFunction::CFN_FACTOR_ENT; break; case 8: cfn = BBPCostFunction::CFN_BETHE_ENT; break; } Real h = 1e-4; Real result = numericBBPTest( bp, &state, opts("updates",updates), cfn, h ); cout << "result: " << result << ",\tupdates=" << updates << ", cfn=" << cfn << endl; } } return 0; } libDAI-0.2.7/tests/testdai.cpp0000644000263000017630000004305411433220722014765 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include #include #include using namespace std; using namespace dai; namespace po = boost::program_options; std::vector calcDists( const vector &x, const vector &y ) { vector errs; errs.reserve( x.size() ); DAI_ASSERT( x.size() == y.size() ); for( size_t i = 0; i < x.size(); i++ ) errs.push_back( dist( x[i], y[i], DISTTV ) ); return errs; } /// Wrapper class for DAI approximate inference algorithms class TestDAI { protected: /// Stores a pointer to an InfAlg object, managed by this class InfAlg *obj; /// Stores the name of the InfAlg algorithm string name; /// Stores the total variation distances of the variable marginals vector varErr; /// Stores the total variation distances of the factor marginals vector facErr; public: /// Stores the variable marginals vector varMarginals; /// Stores the factor marginals vector facMarginals; /// Stores all marginals vector allMarginals; /// Stores the logarithm of the partition sum Real logZ; /// Stores the maximum difference in the last iteration Real maxdiff; /// Stores the computation time (in seconds) double time; /// Stores the number of iterations needed size_t iters; /// Does the InfAlg support logZ()? bool has_logZ; /// Does the InfAlg support maxDiff()? bool has_maxdiff; /// Does the InfAlg support Iterations()? bool has_iters; /// Construct from factor graph \a fg, name \a _name, and set of properties \a opts TestDAI( const FactorGraph &fg, const string &_name, const PropertySet &opts ) : obj(NULL), name(_name), varErr(), facErr(), varMarginals(), facMarginals(), allMarginals(), logZ(0.0), maxdiff(0.0), time(0), iters(0U), has_logZ(false), has_maxdiff(false), has_iters(false) { double tic = toc(); if( name == "LDPC" ) { // special case: simulating a Low Density Parity Check code Real zero[2] = {1.0, 0.0}; for( size_t i = 0; i < fg.nrVars(); i++ ) varMarginals.push_back( Factor(fg.var(i), zero) ); allMarginals = varMarginals; logZ = 0.0; maxdiff = 0.0; iters = 1; has_logZ = false; has_maxdiff = false; has_iters = false; } else // create a corresponding InfAlg object obj = newInfAlg( name, fg, opts ); // Add the time needed to create the object time += toc() - tic; } /// Destructor ~TestDAI() { if( obj != NULL ) delete obj; } /// Identify string identify() const { if( obj != NULL ) return obj->identify(); else return "NULL"; } /// Run the algorithm and store its results void doDAI() { double tic = toc(); if( obj != NULL ) { // Initialize obj->init(); // Run obj->run(); // Record the time time += toc() - tic; // Store logarithm of the partition sum (if supported) try { logZ = obj->logZ(); has_logZ = true; } catch( Exception &e ) { if( e.code() == Exception::NOT_IMPLEMENTED ) has_logZ = false; else throw; } // Store maximum difference encountered in last iteration (if supported) try { maxdiff = obj->maxDiff(); has_maxdiff = true; } catch( Exception &e ) { if( e.code() == Exception::NOT_IMPLEMENTED ) has_maxdiff = false; else throw; } // Store number of iterations needed (if supported) try { iters = obj->Iterations(); has_iters = true; } catch( Exception &e ) { if( e.code() == Exception::NOT_IMPLEMENTED ) has_iters = false; else throw; } // Store variable marginals varMarginals.clear(); for( size_t i = 0; i < obj->fg().nrVars(); i++ ) varMarginals.push_back( obj->beliefV( i ) ); // Store factor marginals facMarginals.clear(); for( size_t I = 0; I < obj->fg().nrFactors(); I++ ) try { facMarginals.push_back( obj->beliefF( I ) ); } catch( Exception &e ) { if( e.code() == Exception::BELIEF_NOT_AVAILABLE ) facMarginals.push_back( Factor( obj->fg().factor(I).vars(), INFINITY ) ); else throw; } // Store all marginals calculated by the method allMarginals = obj->beliefs(); }; } /// Calculate total variation distance of variable and factor marginals with respect to those in \a varMargs and \a facMargs void calcErrors( const vector& varMargs, const vector& facMargs ) { varErr = calcDists( varMarginals, varMargs ); facErr = calcDists( facMarginals, facMargs ); } /// Return maximum variable error Real maxVarErr() { return( *max_element( varErr.begin(), varErr.end() ) ); } /// Return average variable error Real avgVarErr() { return( accumulate( varErr.begin(), varErr.end(), 0.0 ) / varErr.size() ); } /// Return maximum factor error Real maxFacErr() { return( *max_element( facErr.begin(), facErr.end() ) ); } /// Return average factor error Real avgFacErr() { return( accumulate( facErr.begin(), facErr.end(), 0.0 ) / facErr.size() ); } }; /// Clips a real number: if the absolute value of \a x is less than \a minabs, return \a minabs, else return \a x Real clipReal( Real x, Real minabs ) { if( abs(x) < minabs ) return minabs; else return x; } /// Which marginals to outpu (none, only variable, only factor, variable and factor, all) DAI_ENUM(MarginalsOutputType,NONE,VAR,FAC,VARFAC,ALL); /// Main function int main( int argc, char *argv[] ) { // Variables to store command line options // Filename of factor graph string filename; // Filename for aliases string aliases; // Approximate Inference methods to use vector methods; // Which marginals to output MarginalsOutputType marginals; // Output number of iterations? bool report_iters = true; // Output calculation time? bool report_time = true; // Define required command line options po::options_description opts_required("Required options"); opts_required.add_options() ("filename", po::value< string >(&filename), "Filename of factor graph") ("methods", po::value< vector >(&methods)->multitoken(), "DAI methods to perform") ; // Define allowed command line options po::options_description opts_optional("Allowed options"); opts_optional.add_options() ("help", "Produce help message") ("aliases", po::value< string >(&aliases), "Filename for aliases") ("marginals", po::value< MarginalsOutputType >(&marginals), "Output marginals? (NONE/VAR/FAC/VARFAC/ALL, default=NONE)") ("report-time", po::value< bool >(&report_time), "Output calculation time (default==1)?") ("report-iters", po::value< bool >(&report_iters), "Output iterations needed (default==1)?") ; // Define all command line options po::options_description cmdline_options; cmdline_options.add(opts_required).add(opts_optional); // Parse command line po::variables_map vm; po::store(po::parse_command_line(argc, argv, cmdline_options), vm); po::notify(vm); // Display help message if necessary if( vm.count("help") || !(vm.count("filename") && vm.count("methods")) ) { cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "Usage: ./testdai --filename --methods [ ...]" << endl << endl; cout << "Reads factor graph and performs the approximate inference algorithms" << endl; cout << ", reporting for each method:" << endl; cout << " o the calculation time needed, in seconds (if report-time == 1);" << endl; cout << " o the number of iterations needed (if report-iters == 1);" << endl; cout << " o the maximum (over all variables) total variation error in the variable marginals;" << endl; cout << " o the average (over all variables) total variation error in the variable marginals;" << endl; cout << " o the maximum (over all factors) total variation error in the factor marginals;" << endl; cout << " o the average (over all factors) total variation error in the factor marginals;" << endl; cout << " o the error (difference) of the logarithm of the partition sums;" << endl << endl; cout << "All errors are calculated by comparing the results of the current method with" << endl; cout << "the results of the first method (the base method). If marginals==VAR, additional" << endl; cout << "output consists of the variable marginals, if marginals==FAC, the factor marginals" << endl; cout << "if marginals==VARFAC, both variable and factor marginals, and if marginals==ALL, all" << endl; cout << "marginals calculated by the method are reported." << endl << endl; cout << " should be a list of one or more methods, seperated by spaces, in the format:" << endl << endl; cout << " name[key1=val1,key2=val2,key3=val3,...,keyn=valn]" << endl << endl; cout << "where name should be the name of an algorithm in libDAI (or an alias, if an alias" << endl; cout << "filename is provided), followed by a list of properties (surrounded by rectangular" << endl; cout << "brackets), where each property consists of a key=value pair and the properties are" << endl; cout << "seperated by commas. If an alias file is specified, alias substitution is performed." << endl; cout << "This is done by looking up the name in the alias file and substituting the alias" << endl; cout << "by its corresponding method as defined in the alias file. Properties are parsed from" << endl; cout << "left to right, so if a property occurs repeatedly, the right-most value is used." << endl << endl; cout << opts_required << opts_optional << endl; #ifdef DAI_DEBUG cout << "Note: this is a debugging build of libDAI." << endl << endl; #endif cout << "Example: ./testdai --filename testfast.fg --aliases aliases.conf --methods JTREE_HUGIN BP_SEQFIX BP_PARALL[maxiter=5]" << endl; return 1; } try { // Read aliases map Aliases; if( !aliases.empty() ) Aliases = readAliasesFile( aliases ); // Read factor graph FactorGraph fg; fg.ReadFromFile( filename.c_str() ); // Declare variables used for storing variable factor marginals and log partition sum of base method vector varMarginals0; vector facMarginals0; Real logZ0 = 0.0; // Output header cout.setf( ios_base::scientific ); cout.precision( 3 ); cout << "# " << filename << endl; cout.width( 39 ); cout << left << "# METHOD" << "\t"; if( report_time ) cout << right << "SECONDS " << "\t"; if( report_iters ) cout << "ITERS" << "\t"; cout << "MAX VAR ERR" << "\t"; cout << "AVG VAR ERR" << "\t"; cout << "MAX FAC ERR" << "\t"; cout << "AVG FAC ERR" << "\t"; cout << "LOGZ ERROR" << "\t"; cout << "MAXDIFF" << "\t"; cout << endl; // For each method... for( size_t m = 0; m < methods.size(); m++ ) { // Parse method pair meth = parseNameProperties( methods[m], Aliases ); // Check whether name is valid size_t n = 0; for( ; strlen( DAINames[n] ) != 0; n++ ) if( meth.first == DAINames[n] ) break; if( strlen( DAINames[n] ) == 0 ) DAI_THROWE(UNKNOWN_DAI_ALGORITHM,string("Unknown DAI algorithm \"") + meth.first + string("\" in \"") + methods[m] + string("\"")); // Construct object for running the method TestDAI testdai(fg, meth.first, meth.second ); // Run the method testdai.doDAI(); // For the base method, store its variable marginals and logarithm of the partition sum if( m == 0 ) { varMarginals0 = testdai.varMarginals; facMarginals0 = testdai.facMarginals; logZ0 = testdai.logZ; } // Calculate errors relative to base method testdai.calcErrors( varMarginals0, facMarginals0 ); // Output method name cout.width( 39 ); cout << left << methods[m] << "\t"; // Output calculation time, if requested if( report_time ) cout << right << testdai.time << "\t"; // Output number of iterations, if requested if( report_iters ) { if( testdai.has_iters ) { cout << testdai.iters << "\t"; } else { cout << "N/A \t"; } } // If this is not the base method if( m > 0 ) { cout.setf( ios_base::scientific ); cout.precision( 3 ); // Output maximum error in variable marginals Real mev = clipReal( testdai.maxVarErr(), 1e-9 ); cout << mev << "\t"; // Output average error in variable marginals Real aev = clipReal( testdai.avgVarErr(), 1e-9 ); cout << aev << "\t"; // Output maximum error in factor marginals Real mef = clipReal( testdai.maxFacErr(), 1e-9 ); if( mef == INFINITY ) cout << "N/A \t"; else cout << mef << "\t"; // Output average error in factor marginals Real aef = clipReal( testdai.avgFacErr(), 1e-9 ); if( aef == INFINITY ) cout << "N/A \t"; else cout << aef << "\t"; // Output error in log partition sum if( testdai.has_logZ ) { cout.setf( ios::showpos ); Real le = clipReal( testdai.logZ - logZ0, 1e-9 ); cout << le << "\t"; cout.unsetf( ios::showpos ); } else cout << "N/A \t"; // Output maximum difference in last iteration if( testdai.has_maxdiff ) { Real md = clipReal( testdai.maxdiff, 1e-9 ); if( dai::isnan( mev ) ) md = mev; if( dai::isnan( aev ) ) md = aev; if( md == INFINITY ) md = 1.0; cout << md << "\t"; } else cout << "N/A \t"; } cout << endl; // Output marginals, if requested if( marginals == MarginalsOutputType::VAR || marginals == MarginalsOutputType::VARFAC ) for( size_t i = 0; i < testdai.varMarginals.size(); i++ ) cout << "# " << testdai.varMarginals[i] << endl; if( marginals == MarginalsOutputType::FAC || marginals == MarginalsOutputType::VARFAC ) for( size_t I = 0; I < testdai.facMarginals.size(); I++ ) cout << "# " << testdai.facMarginals[I] << endl; if( marginals == MarginalsOutputType::ALL ) for( size_t I = 0; I < testdai.allMarginals.size(); I++ ) cout << "# " << testdai.allMarginals[I] << endl; } return 0; } catch( string &s ) { // Abort with error message cerr << "Exception: " << s << endl; return 2; } } libDAI-0.2.7/tests/hoi4.fg0000644000263000017630000000123511433220722014000 0ustar jorismkyb# Factor graph made by ../utils/createfg # type = hoi # N = 10 # M = 3 # k = 3 # beta = 1 # seed = 123456 3 3 5 7 9 2 2 2 8 0 0.34695110012176 1 5.2445568426086 2 0.40353951923864 3 0.87337008674168 4 1.8484229288021 5 1.3558019751326 6 0.18957537662536 7 1.0106086348982 3 7 8 9 2 2 2 8 0 1.4346630217766 1 1.7381665310949 2 1.4305082973985 3 0.93926886261587 4 0.37893660692703 5 0.82593511761888 6 0.24322233722175 7 0.30679804692782 3 0 6 7 2 2 2 8 0 0.5061849993673 1 1.6117048972906 2 2.0693735419645 3 0.5455720871037 4 2.0160537987371 5 0.30172846959351 6 1.8962849316602 7 3.5838027075412 libDAI-0.2.7/tests/aliases.conf0000644000263000017630000003724111433220722015115 0ustar jorismkyb# This file contains reasonable default settings for various inference # algorithms in libDAI. Each non-empty line should either be a comment # (starting with #) or contain an alias definition in the format # # alias: name[key1=val1,key2=val2,...,keyn=valn] # # where name should be a valid libDAI algorithm name, and the list of # its properties (between rectangular brackets) consists of key=value # pairs, seperated by spaces. This defines 'alias' as a shortcut for # the rest of the line (more precisely, the contents to the right of # the colon and possible whitespace). # --- BP ---------------------- BP: BP[inference=SUMPROD,updates=SEQMAX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] BP_SEQFIX: BP[inference=SUMPROD,updates=SEQFIX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] BP_SEQRND: BP[inference=SUMPROD,updates=SEQRND,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] BP_SEQMAX: BP[inference=SUMPROD,updates=SEQMAX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] BP_PARALL: BP[inference=SUMPROD,updates=PARALL,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] BP_SEQFIX_LOG: BP[inference=SUMPROD,updates=SEQFIX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] BP_SEQRND_LOG: BP[inference=SUMPROD,updates=SEQRND,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] BP_SEQMAX_LOG: BP[inference=SUMPROD,updates=SEQMAX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] BP_PARALL_LOG: BP[inference=SUMPROD,updates=PARALL,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] MP_SEQFIX: BP[inference=MAXPROD,updates=SEQFIX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] MP_SEQRND: BP[inference=MAXPROD,updates=SEQRND,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] MP_SEQMAX: BP[inference=MAXPROD,updates=SEQMAX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] MP_PARALL: BP[inference=MAXPROD,updates=PARALL,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] MP_SEQFIX_LOG: BP[inference=MAXPROD,updates=SEQFIX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] MP_SEQRND_LOG: BP[inference=MAXPROD,updates=SEQRND,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] MP_SEQMAX_LOG: BP[inference=MAXPROD,updates=SEQMAX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] MP_PARALL_LOG: BP[inference=MAXPROD,updates=PARALL,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] # --- FBP --------------------- FBP: FBP[inference=SUMPROD,updates=SEQMAX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] FBP_SEQFIX: FBP[inference=SUMPROD,updates=SEQFIX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] FBP_SEQRND: FBP[inference=SUMPROD,updates=SEQRND,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] FBP_SEQMAX: FBP[inference=SUMPROD,updates=SEQMAX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] FBP_PARALL: FBP[inference=SUMPROD,updates=PARALL,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] FBP_SEQFIX_LOG: FBP[inference=SUMPROD,updates=SEQFIX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] FBP_SEQRND_LOG: FBP[inference=SUMPROD,updates=SEQRND,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] FBP_SEQMAX_LOG: FBP[inference=SUMPROD,updates=SEQMAX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] FBP_PARALL_LOG: FBP[inference=SUMPROD,updates=PARALL,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] FMP_SEQFIX: FBP[inference=MAXPROD,updates=SEQFIX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] FMP_SEQRND: FBP[inference=MAXPROD,updates=SEQRND,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] FMP_SEQMAX: FBP[inference=MAXPROD,updates=SEQMAX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] FMP_PARALL: FBP[inference=MAXPROD,updates=PARALL,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0] FMP_SEQFIX_LOG: FBP[inference=MAXPROD,updates=SEQFIX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] FMP_SEQRND_LOG: FBP[inference=MAXPROD,updates=SEQRND,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] FMP_SEQMAX_LOG: FBP[inference=MAXPROD,updates=SEQMAX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] FMP_PARALL_LOG: FBP[inference=MAXPROD,updates=PARALL,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0] # --- TRWBP ------------------- TRWBP: TRWBP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0,nrtrees=0] TRWBP_SEQFIX: TRWBP[inference=SUMPROD,updates=SEQFIX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWBP_SEQRND: TRWBP[inference=SUMPROD,updates=SEQRND,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWBP_SEQMAX: TRWBP[inference=SUMPROD,updates=SEQMAX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWBP_PARALL: TRWBP[inference=SUMPROD,updates=PARALL,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWBP_SEQFIX_LOG: TRWBP[inference=SUMPROD,updates=SEQFIX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWBP_SEQRND_LOG: TRWBP[inference=SUMPROD,updates=SEQRND,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWBP_SEQMAX_LOG: TRWBP[inference=SUMPROD,updates=SEQMAX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWBP_PARALL_LOG: TRWBP[inference=SUMPROD,updates=PARALL,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWMP_SEQFIX: TRWBP[inference=MAXPROD,updates=SEQFIX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWMP_SEQRND: TRWBP[inference=MAXPROD,updates=SEQRND,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWMP_SEQMAX: TRWBP[inference=MAXPROD,updates=SEQMAX,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWMP_PARALL: TRWBP[inference=MAXPROD,updates=PARALL,logdomain=0,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWMP_SEQFIX_LOG: TRWBP[inference=MAXPROD,updates=SEQFIX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWMP_SEQRND_LOG: TRWBP[inference=MAXPROD,updates=SEQRND,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWMP_SEQMAX_LOG: TRWBP[inference=MAXPROD,updates=SEQMAX,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] TRWMP_PARALL_LOG: TRWBP[inference=MAXPROD,updates=PARALL,logdomain=1,tol=1e-9,maxiter=10000,damping=0.0,nrtrees=0] # --- JTREE ------------------- JTREE_HUGIN: JTREE[inference=SUMPROD,updates=HUGIN] JTREE_SHSH: JTREE[inference=SUMPROD,updates=SHSH] JTREE_MINFILL_HUGIN: JTREE[inference=SUMPROD,heuristic=MINFILL,updates=HUGIN] JTREE_MINFILL_SHSH: JTREE[inference=SUMPROD,heuristic=MINFILL,updates=SHSH] JTREE_MINFILL_HUGIN_MAP: JTREE[inference=MAXPROD,heuristic=MINFILL,updates=HUGIN] JTREE_MINFILL_SHSH_MAP: JTREE[inference=MAXPROD,heuristic=MINFILL,updates=SHSH] JTREE_WEIGHTEDMINFILL_HUGIN: JTREE[inference=SUMPROD,heuristic=WEIGHTEDMINFILL,updates=HUGIN] JTREE_WEIGHTEDMINFILL_SHSH: JTREE[inference=SUMPROD,heuristic=WEIGHTEDMINFILL,updates=SHSH] JTREE_WEIGHTEDMINFILL_HUGIN_MAP:JTREE[inference=MAXPROD,heuristic=WEIGHTEDMINFILL,updates=HUGIN] JTREE_WEIGHTEDMINFILL_SHSH_MAP: JTREE[inference=MAXPROD,heuristic=WEIGHTEDMINFILL,updates=SHSH] JTREE_MINWEIGHT_HUGIN: JTREE[inference=SUMPROD,heuristic=MINWEIGHT,updates=HUGIN] JTREE_MINWEIGHT_SHSH: JTREE[inference=SUMPROD,heuristic=MINWEIGHT,updates=SHSH] JTREE_MINWEIGHT_HUGIN_MAP: JTREE[inference=MAXPROD,heuristic=MINWEIGHT,updates=HUGIN] JTREE_MINWEIGHT_SHSH_MAP: JTREE[inference=MAXPROD,heuristic=MINWEIGHT,updates=SHSH] JTREE_MINNEIGHBORS_HUGIN: JTREE[inference=SUMPROD,heuristic=MINNEIGHBORS,updates=HUGIN] JTREE_MINNEIGHBORS_SHSH: JTREE[inference=SUMPROD,heuristic=MINNEIGHBORS,updates=SHSH] JTREE_MINNEIGHBORS_HUGIN_MAP: JTREE[inference=MAXPROD,heuristic=MINNEIGHBORS,updates=HUGIN] JTREE_MINNEIGHBORS_SHSH_MAP: JTREE[inference=MAXPROD,heuristic=MINNEIGHBORS,updates=SHSH] # --- MF ---------------------- MF: MF[tol=1e-9,maxiter=10000,damping=0.0,init=UNIFORM,updates=NAIVE] MF_NAIVE_UNI: MF[tol=1e-9,maxiter=10000,damping=0.0,init=UNIFORM,updates=NAIVE] MF_NAIVE_RND: MF[tol=1e-9,maxiter=10000,damping=0.0,init=RANDOM,updates=NAIVE] MF_HARDSPIN_UNI: MF[tol=1e-9,maxiter=10000,damping=0.0,init=UNIFORM,updates=HARDSPIN] MF_HARDSPIN_RND: MF[tol=1e-9,maxiter=10000,damping=0.0,init=RANDOM,updates=HARDSPIN] # --- TREEEP ------------------ TREEEP: TREEEP[type=ORG,tol=1e-9,maxiter=10000] TREEEPWC: TREEEP[type=ALT,tol=1e-9,maxiter=10000] # --- MR ---------------------- MR_DEFAULT: MR[updates=FULL,inits=RESPPROP,tol=1e-9] MR_RESPPROP_FULL: MR[updates=FULL,inits=RESPPROP,tol=1e-9] MR_RESPPROP_LINEAR: MR[updates=LINEAR,inits=RESPPROP,tol=1e-9] MR_CLAMPING_FULL: MR[updates=FULL,inits=CLAMPING,tol=1e-9] MR_CLAMPING_LINEAR: MR[updates=LINEAR,inits=CLAMPING,tol=1e-9] MR_EXACT_FULL: MR[updates=FULL,inits=EXACT,tol=1e-9] MR_EXACT_LINEAR: MR[updates=LINEAR,inits=EXACT,tol=1e-9] # --- HAK --------------------- GBP_MIN: HAK[doubleloop=0,clusters=MIN,init=UNIFORM,tol=1e-9,maxiter=10000] GBP_BETHE: HAK[doubleloop=0,clusters=BETHE,init=UNIFORM,tol=1e-9,maxiter=10000] GBP_DELTA: HAK[doubleloop=0,clusters=DELTA,init=UNIFORM,tol=1e-9,maxiter=10000] GBP_LOOP3: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=3,tol=1e-9,maxiter=10000] GBP_LOOP4: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=4,tol=1e-9,maxiter=10000] GBP_LOOP5: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=5,tol=1e-9,maxiter=10000] GBP_LOOP6: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=6,tol=1e-9,maxiter=10000] GBP_LOOP7: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=7,tol=1e-9,maxiter=10000] GBP_LOOP8: HAK[doubleloop=0,clusters=LOOP,init=UNIFORM,loopdepth=8,tol=1e-9,maxiter=10000] HAK_MIN: HAK[doubleloop=1,clusters=MIN,init=UNIFORM,tol=1e-9,maxiter=10000] HAK_BETHE: HAK[doubleloop=1,clusters=BETHE,init=UNIFORM,tol=1e-9,maxiter=10000] HAK_DELTA: HAK[doubleloop=1,clusters=DELTA,init=UNIFORM,tol=1e-9,maxiter=10000] HAK_LOOP3: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=3,tol=1e-9,maxiter=10000] HAK_LOOP4: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=4,tol=1e-9,maxiter=10000] HAK_LOOP5: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=5,tol=1e-9,maxiter=10000] HAK_LOOP6: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=6,tol=1e-9,maxiter=10000] HAK_LOOP7: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=7,tol=1e-9,maxiter=10000] HAK_LOOP8: HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=8,tol=1e-9,maxiter=10000] # --- LC ---------------------- LCBP_FULLCAVin_SEQFIX: LC[cavity=FULL,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_FULLCAVin_SEQRND: LC[cavity=FULL,reinit=1,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_FULLCAVin_NONE: LC[cavity=FULL,reinit=1,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_FULLCAV_SEQFIX: LC[cavity=FULL,reinit=0,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_FULLCAV_SEQRND: LC[cavity=FULL,reinit=0,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_FULLCAV_NONE: LC[cavity=FULL,reinit=0,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIRCAVin_SEQFIX: LC[cavity=PAIR,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIRCAVin_SEQRND: LC[cavity=PAIR,reinit=1,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIRCAVin_NONE: LC[cavity=PAIR,reinit=1,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIRCAV_SEQFIX: LC[cavity=PAIR,reinit=0,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIRCAV_SEQRND: LC[cavity=PAIR,reinit=0,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIRCAV_NONE: LC[cavity=PAIR,reinit=0,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIR2CAVin_SEQFIX: LC[cavity=PAIR2,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIR2CAVin_SEQRND: LC[cavity=PAIR2,reinit=1,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIR2CAVin_NONE: LC[cavity=PAIR2,reinit=1,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIR2CAV_SEQFIX: LC[cavity=PAIR2,reinit=0,updates=SEQFIX,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIR2CAV_SEQRND: LC[cavity=PAIR2,reinit=0,updates=SEQRND,maxiter=10000,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_PAIR2CAV_NONE: LC[cavity=PAIR2,reinit=0,updates=SEQFIX,maxiter=0,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],tol=1e-9] LCBP_UNICAV_SEQFIX: LC[cavity=UNIFORM,updates=SEQFIX,maxiter=10000,tol=1e-9,cavaiopts=[],cavainame=NONE] LCBP_UNICAV_SEQRND: LC[cavity=UNIFORM,updates=SEQRND,maxiter=10000,tol=1e-9,cavaiopts=[],cavainame=NONE] LCTREEEP: LC[cavity=FULL,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=TREEEP,cavaiopts=[type=ORG,tol=1e-9,maxiter=10000],tol=1e-9] LCMF: LC[cavity=FULL,reinit=1,updates=SEQFIX,maxiter=10000,cavainame=MF,cavaiopts=[tol=1e-9,maxiter=10000],tol=1e-9] LCBP: LCBP_FULLCAVin_SEQRND # --- GIBBS ------------------- GIBBS: GIBBS[maxiter=10000,burnin=100,restart=10000] # --- CBP --------------------- CBP: CBP[max_levels=12,updates=SEQMAX,tol=1e-9,rec_tol=1e-9,maxiter=500,choose=CHOOSE_RANDOM,recursion=REC_FIXED,clamp=CLAMP_VAR,min_max_adj=1.0e-9,bbp_cfn=CFN_FACTOR_ENT,rand_seed=0,bbp_props=[tol=1.0e-9,maxiter=10000,damping=0,updates=SEQ_BP_REV],clamp_outfile=] BBP: CBP[choose=CHOOSE_BBP] # --- DECMAP ------------------ DECMAP: DECMAP[ianame=BP,iaopts=[inference=MAXPROD,updates=SEQRND,logdomain=1,tol=1e-9,maxiter=10000,damping=0.1,verbose=0],reinit=1,verbose=0] libDAI-0.2.7/tests/testregression.bat0000755000263000017630000000017411433220722016373 0ustar jorismkybtestall testfast.fg | sed "s/\(e[+-]\)0/\1/g" > testfast.out.tmp diff -s testfast.out.tmp testfast.out del testfast.out.tmp libDAI-0.2.7/tests/hoi1.fg0000644000263000017630000000123111433220722013771 0ustar jorismkyb# Factor graph made by utils/createfg # type = hoi # N = 10 # M = 3 # k = 3 # beta = 1 # seed = 12345 3 3 2 6 7 2 2 2 8 0 2.6190635748817 1 0.68885412652977 2 0.83464115122831 3 0.38475684223169 4 0.3255025197617 5 1.9692111887049 6 0.55208846715017 7 0.38595110280868 3 0 1 6 2 2 2 8 0 1.0352133626924 1 1.547478952122 2 2.3176521897449 3 1.2804190071868 4 4.9220798130027 5 2.5272557501946 6 0.83127929631575 7 0.26280563080263 3 1 2 4 2 2 2 8 0 0.2371680948972 1 3.7876163914702 2 5.3196087077347 3 0.96049191560722 4 4.8483648454236 5 0.45974506954001 6 2.1151447659773 7 0.57337737335857 libDAI-0.2.7/tests/testall.bat0000755000263000017630000000405111433220722014761 0ustar jorismkyb@ECHO OFF REM Marginal inference @testdai --report-iters false --report-time false --marginals VAR --aliases aliases.conf --filename %1 --methods EXACT JTREE_MINFILL_HUGIN JTREE_MINFILL_SHSH JTREE_WEIGHTEDMINFILL_HUGIN JTREE_WEIGHTEDMINFILL_SHSH JTREE_MINWEIGHT_HUGIN JTREE_MINWEIGHT_SHSH JTREE_MINNEIGHBORS_HUGIN JTREE_MINNEIGHBORS_SHSH BP BP_SEQFIX BP_SEQRND BP_SEQMAX BP_PARALL BP_SEQFIX_LOG BP_SEQRND_LOG BP_SEQMAX_LOG BP_PARALL_LOG FBP FBP_SEQFIX FBP_SEQRND FBP_SEQMAX FBP_PARALL FBP_SEQFIX_LOG FBP_SEQRND_LOG FBP_SEQMAX_LOG FBP_PARALL_LOG TRWBP TRWBP_SEQFIX TRWBP_SEQRND TRWBP_SEQMAX TRWBP_PARALL TRWBP_SEQFIX_LOG TRWBP_SEQRND_LOG TRWBP_SEQMAX_LOG TRWBP_PARALL_LOG MF MF_NAIVE_UNI MF_NAIVE_RND MF_HARDSPIN_UNI MF_HARDSPIN_RND TREEEP TREEEPWC GBP_MIN GBP_BETHE GBP_LOOP3 HAK_MIN HAK_BETHE HAK_DELTA HAK_LOOP3 HAK_LOOP4 HAK_LOOP5 MR_RESPPROP_FULL MR_CLAMPING_FULL MR_EXACT_FULL MR_RESPPROP_LINEAR MR_CLAMPING_LINEAR MR_EXACT_LINEAR LCBP LCBP_FULLCAV_SEQFIX LCBP_FULLCAVin_SEQFIX LCBP_FULLCAV_SEQRND LCBP_FULLCAVin_SEQRND LCBP_FULLCAV_NONE LCBP_FULLCAVin_NONE LCBP_PAIRCAV_SEQFIX LCBP_PAIRCAVin_SEQFIX LCBP_PAIRCAV_SEQRND LCBP_PAIRCAVin_SEQRND LCBP_PAIRCAV_NONE LCBP_PAIRCAVin_NONE LCBP_PAIR2CAV_SEQFIX LCBP_PAIR2CAVin_SEQFIX LCBP_PAIR2CAV_SEQRND LCBP_PAIR2CAVin_SEQRND LCBP_PAIR2CAV_NONE LCBP_PAIR2CAVin_NONE LCBP_UNICAV_SEQFIX LCBP_UNICAV_SEQRND LCTREEEP BBP REM GBP_DELTA, GBP_LOOP4, GBP_LOOP5, GBP_LOOP6, GBP_LOOP7 misbehave REM MAP inference @testdai --report-iters false --report-time false --marginals VAR --aliases aliases.conf --filename %1 --methods JTREE_MINFILL_HUGIN_MAP JTREE_MINFILL_SHSH_MAP JTREE_WEIGHTEDMINFILL_HUGIN_MAP JTREE_WEIGHTEDMINFILL_SHSH_MAP JTREE_MINWEIGHT_HUGIN_MAP JTREE_MINWEIGHT_SHSH_MAP JTREE_MINNEIGHBORS_HUGIN_MAP JTREE_MINNEIGHBORS_SHSH_MAP MP_SEQFIX MP_SEQRND MP_PARALL MP_SEQFIX_LOG MP_SEQRND_LOG MP_PARALL_LOG FMP_SEQFIX FMP_SEQRND FMP_PARALL FMP_SEQFIX_LOG FMP_SEQRND_LOG FMP_PARALL_LOG TRWMP_SEQFIX TRWMP_SEQRND TRWMP_PARALL TRWMP_SEQFIX_LOG TRWMP_SEQRND_LOG TRWMP_PARALL_LOG DECMAP REM *MP_SEQMAX and *MP_SEQMAX_LOG make no sense, apparently libDAI-0.2.7/tests/testregression0000755000263000017630000000026211433220722015624 0ustar jorismkyb#!/bin/bash TMPFILE1=`mktemp /var/tmp/testfast.XXXXXX` trap 'rm -f $TMP_FILE' 0 1 15 ./testall testfast.fg > $TMPFILE1 diff -s $TMPFILE1 testfast.out || exit 1 rm -f $TMPFILE1 libDAI-0.2.7/tests/testfast.fg0000644000263000017630000000453011433220722014773 0ustar jorismkyb# Factor graph made by ../utils/createfg # type = GRID # states = 2 # n1 = 4 # n2 = 4 # options = [mean_th=0,mean_w=0,sigma_th=0.4,sigma_w=0.4] # N = 16 # seed = 123 40 2 0 4 2 2 4 0 1.55785 1 0.641909 2 0.641909 3 1.55785 2 0 1 2 2 4 0 1.00773 1 0.992328 2 0.992328 3 1.00773 2 1 5 2 2 4 0 1.78772 1 0.559373 2 0.559373 3 1.78772 2 1 2 2 2 4 0 0.882839 1 1.13271 2 1.13271 3 0.882839 2 2 6 2 2 4 0 1.39819 1 0.715211 2 0.715211 3 1.39819 2 2 3 2 2 4 0 1.13791 1 0.878807 2 0.878807 3 1.13791 2 3 7 2 2 4 0 0.580131 1 1.72375 2 1.72375 3 0.580131 2 4 8 2 2 4 0 2.30325 1 0.434168 2 0.434168 3 2.30325 2 4 5 2 2 4 0 0.795215 1 1.25752 2 1.25752 3 0.795215 2 5 9 2 2 4 0 1.45375 1 0.687876 2 0.687876 3 1.45375 2 5 6 2 2 4 0 2.49364 1 0.40102 2 0.40102 3 2.49364 2 6 10 2 2 4 0 1.08628 1 0.920573 2 0.920573 3 1.08628 2 6 7 2 2 4 0 0.673644 1 1.48446 2 1.48446 3 0.673644 2 7 11 2 2 4 0 0.708219 1 1.41199 2 1.41199 3 0.708219 2 8 12 2 2 4 0 1.38777 1 0.720582 2 0.720582 3 1.38777 2 8 9 2 2 4 0 0.409675 1 2.44096 2 2.44096 3 0.409675 2 9 13 2 2 4 0 1.20244 1 0.831645 2 0.831645 3 1.20244 2 9 10 2 2 4 0 0.700179 1 1.42821 2 1.42821 3 0.700179 2 10 14 2 2 4 0 0.684168 1 1.46163 2 1.46163 3 0.684168 2 10 11 2 2 4 0 2.12998 1 0.469487 2 0.469487 3 2.12998 2 11 15 2 2 4 0 0.675744 1 1.47985 2 1.47985 3 0.675744 2 12 13 2 2 4 0 0.895744 1 1.11639 2 1.11639 3 0.895744 2 13 14 2 2 4 0 0.797362 1 1.25414 2 1.25414 3 0.797362 2 14 15 2 2 4 0 0.765242 1 1.30678 2 1.30678 3 0.765242 1 0 2 2 0 0.784958 1 1.27395 1 1 2 2 0 1.22582 1 0.815779 1 2 2 2 0 1.03047 1 0.970432 1 3 2 2 0 0.61121 1 1.6361 1 4 2 2 0 1.26126 1 0.792857 1 5 2 2 0 1.06453 1 0.939384 1 6 2 2 0 0.988982 1 1.01114 1 7 2 2 0 0.983169 1 1.01712 1 8 2 2 0 0.715963 1 1.39672 1 9 2 2 0 1.14095 1 0.876466 1 10 2 2 0 1.15512 1 0.865708 1 11 2 2 0 1.18486 1 0.843984 1 12 2 2 0 0.916541 1 1.09106 1 13 2 2 0 2.61467 1 0.382458 1 14 2 2 0 0.725142 1 1.37904 1 15 2 2 0 1.43262 1 0.698024 libDAI-0.2.7/tests/testfast.out0000644000263000017630000020642011433220722015210 0ustar jorismkyb# testfast.fg # METHOD MAX VAR ERR AVG VAR ERR MAX FAC ERR AVG FAC ERR LOGZ ERROR MAXDIFF EXACT # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) JTREE_MINFILL_HUGIN 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) JTREE_MINFILL_SHSH 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) JTREE_WEIGHTEDMINFILL_HUGIN 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) JTREE_WEIGHTEDMINFILL_SHSH 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) JTREE_MINWEIGHT_HUGIN 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) JTREE_MINWEIGHT_SHSH 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) JTREE_MINNEIGHBORS_HUGIN 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) JTREE_MINNEIGHBORS_SHSH 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) BP 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) BP_SEQFIX 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) BP_SEQRND 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) BP_SEQMAX 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) BP_PARALL 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) BP_SEQFIX_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) BP_SEQRND_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) BP_SEQMAX_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) BP_PARALL_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) FBP 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) FBP_SEQFIX 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) FBP_SEQRND 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) FBP_SEQMAX 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) FBP_PARALL 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) FBP_SEQFIX_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) FBP_SEQRND_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) FBP_SEQMAX_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) FBP_PARALL_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) TRWBP 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) TRWBP_SEQFIX 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) TRWBP_SEQRND 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) TRWBP_SEQMAX 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) TRWBP_PARALL 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) TRWBP_SEQFIX_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) TRWBP_SEQRND_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) TRWBP_SEQMAX_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) TRWBP_PARALL_LOG 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) MF 3.234e-01 1.576e-01 N/A N/A -1.235e+00 1.000e-09 # ({x0}, (2.399e-01, 7.601e-01)) # ({x1}, (8.072e-01, 1.928e-01)) # ({x2}, (5.885e-01, 4.115e-01)) # ({x3}, (3.549e-01, 6.451e-01)) # ({x4}, (1.174e-01, 8.826e-01)) # ({x5}, (9.635e-01, 3.649e-02)) # ({x6}, (8.922e-01, 1.078e-01)) # ({x7}, (3.433e-01, 6.567e-01)) # ({x8}, (2.194e-02, 9.781e-01)) # ({x9}, (9.347e-01, 6.532e-02)) # ({x10}, (7.263e-01, 2.737e-01)) # ({x11}, (7.253e-01, 2.747e-01)) # ({x12}, (2.706e-01, 7.294e-01)) # ({x13}, (9.334e-01, 6.662e-02)) # ({x14}, (1.733e-01, 8.267e-01)) # ({x15}, (6.716e-01, 3.284e-01)) MF_NAIVE_UNI 3.234e-01 1.576e-01 N/A N/A -1.235e+00 1.000e-09 # ({x0}, (2.399e-01, 7.601e-01)) # ({x1}, (8.072e-01, 1.928e-01)) # ({x2}, (5.885e-01, 4.115e-01)) # ({x3}, (3.549e-01, 6.451e-01)) # ({x4}, (1.174e-01, 8.826e-01)) # ({x5}, (9.635e-01, 3.649e-02)) # ({x6}, (8.922e-01, 1.078e-01)) # ({x7}, (3.433e-01, 6.567e-01)) # ({x8}, (2.194e-02, 9.781e-01)) # ({x9}, (9.347e-01, 6.532e-02)) # ({x10}, (7.263e-01, 2.737e-01)) # ({x11}, (7.253e-01, 2.747e-01)) # ({x12}, (2.706e-01, 7.294e-01)) # ({x13}, (9.334e-01, 6.662e-02)) # ({x14}, (1.733e-01, 8.267e-01)) # ({x15}, (6.716e-01, 3.284e-01)) MF_NAIVE_RND 3.234e-01 1.576e-01 N/A N/A -1.235e+00 1.000e-09 # ({x0}, (2.399e-01, 7.601e-01)) # ({x1}, (8.072e-01, 1.928e-01)) # ({x2}, (5.885e-01, 4.115e-01)) # ({x3}, (3.549e-01, 6.451e-01)) # ({x4}, (1.174e-01, 8.826e-01)) # ({x5}, (9.635e-01, 3.649e-02)) # ({x6}, (8.922e-01, 1.078e-01)) # ({x7}, (3.433e-01, 6.567e-01)) # ({x8}, (2.194e-02, 9.781e-01)) # ({x9}, (9.347e-01, 6.532e-02)) # ({x10}, (7.263e-01, 2.737e-01)) # ({x11}, (7.253e-01, 2.747e-01)) # ({x12}, (2.706e-01, 7.294e-01)) # ({x13}, (9.334e-01, 6.662e-02)) # ({x14}, (1.733e-01, 8.267e-01)) # ({x15}, (6.716e-01, 3.284e-01)) MF_HARDSPIN_UNI 3.081e-01 1.331e-01 N/A N/A -1.247e+00 1.000e-09 # ({x0}, (2.475e-01, 7.525e-01)) # ({x1}, (7.992e-01, 2.008e-01)) # ({x2}, (5.729e-01, 4.271e-01)) # ({x3}, (3.214e-01, 6.786e-01)) # ({x4}, (1.300e-01, 8.700e-01)) # ({x5}, (9.482e-01, 5.176e-02)) # ({x6}, (8.600e-01, 1.400e-01)) # ({x7}, (3.996e-01, 6.004e-01)) # ({x8}, (2.867e-02, 9.713e-01)) # ({x9}, (9.356e-01, 6.440e-02)) # ({x10}, (6.441e-01, 3.559e-01)) # ({x11}, (6.328e-01, 3.672e-01)) # ({x12}, (2.729e-01, 7.271e-01)) # ({x13}, (9.322e-01, 6.784e-02)) # ({x14}, (1.897e-01, 8.103e-01)) # ({x15}, (7.000e-01, 3.000e-01)) MF_HARDSPIN_RND 3.081e-01 1.331e-01 N/A N/A -1.247e+00 1.000e-09 # ({x0}, (2.475e-01, 7.525e-01)) # ({x1}, (7.992e-01, 2.008e-01)) # ({x2}, (5.729e-01, 4.271e-01)) # ({x3}, (3.214e-01, 6.786e-01)) # ({x4}, (1.300e-01, 8.700e-01)) # ({x5}, (9.482e-01, 5.176e-02)) # ({x6}, (8.600e-01, 1.400e-01)) # ({x7}, (3.996e-01, 6.004e-01)) # ({x8}, (2.867e-02, 9.713e-01)) # ({x9}, (9.356e-01, 6.440e-02)) # ({x10}, (6.441e-01, 3.559e-01)) # ({x11}, (6.328e-01, 3.672e-01)) # ({x12}, (2.729e-01, 7.271e-01)) # ({x13}, (9.322e-01, 6.784e-02)) # ({x14}, (1.897e-01, 8.103e-01)) # ({x15}, (7.000e-01, 3.000e-01)) TREEEP 1.113e-03 4.413e-04 N/A N/A -6.650e-03 1.000e-09 # ({x0}, (3.499e-01, 6.501e-01)) # ({x1}, (6.450e-01, 3.550e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.047e-01, 6.953e-01)) # ({x4}, (3.695e-01, 6.305e-01)) # ({x5}, (6.408e-01, 3.592e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.441e-01, 4.559e-01)) # ({x8}, (2.796e-01, 7.204e-01)) # ({x9}, (7.087e-01, 2.913e-01)) # ({x10}, (5.783e-01, 4.217e-01)) # ({x11}, (5.378e-01, 4.622e-01)) # ({x12}, (3.538e-01, 6.462e-01)) # ({x13}, (9.049e-01, 9.506e-02)) # ({x14}, (2.405e-01, 7.595e-01)) # ({x15}, (6.909e-01, 3.091e-01)) TREEEPWC 1.113e-03 4.413e-04 N/A N/A -6.650e-03 1.000e-09 # ({x0}, (3.499e-01, 6.501e-01)) # ({x1}, (6.450e-01, 3.550e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.047e-01, 6.953e-01)) # ({x4}, (3.695e-01, 6.305e-01)) # ({x5}, (6.408e-01, 3.592e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.441e-01, 4.559e-01)) # ({x8}, (2.796e-01, 7.204e-01)) # ({x9}, (7.087e-01, 2.913e-01)) # ({x10}, (5.783e-01, 4.217e-01)) # ({x11}, (5.378e-01, 4.622e-01)) # ({x12}, (3.538e-01, 6.462e-01)) # ({x13}, (9.049e-01, 9.506e-02)) # ({x14}, (2.405e-01, 7.595e-01)) # ({x15}, (6.909e-01, 3.091e-01)) GBP_MIN 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) GBP_BETHE 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) GBP_LOOP3 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) HAK_MIN 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) HAK_BETHE 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) HAK_DELTA 2.096e-01 9.486e-02 6.592e-01 2.033e-01 +3.456e-01 1.000e-09 # ({x0}, (4.896e-01, 5.104e-01)) # ({x1}, (5.104e-01, 4.896e-01)) # ({x2}, (5.104e-01, 4.896e-01)) # ({x3}, (5.104e-01, 4.896e-01)) # ({x4}, (4.896e-01, 5.104e-01)) # ({x5}, (5.104e-01, 4.896e-01)) # ({x6}, (5.104e-01, 4.896e-01)) # ({x7}, (4.896e-01, 5.104e-01)) # ({x8}, (4.896e-01, 5.104e-01)) # ({x9}, (5.104e-01, 4.896e-01)) # ({x10}, (4.896e-01, 5.104e-01)) # ({x11}, (4.896e-01, 5.104e-01)) # ({x12}, (4.204e-01, 5.796e-01)) # ({x13}, (8.870e-01, 1.130e-01)) # ({x14}, (2.536e-01, 7.464e-01)) # ({x15}, (7.070e-01, 2.930e-01)) HAK_LOOP3 8.924e-03 3.480e-03 5.619e-02 1.096e-02 +7.187e-04 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) HAK_LOOP4 1.302e-05 4.029e-06 1.186e-04 1.930e-05 -1.179e-05 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.618e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) HAK_LOOP5 1.302e-05 4.029e-06 1.186e-04 1.930e-05 -1.179e-05 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.618e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) MR_RESPPROP_FULL 1.078e-03 3.742e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.498e-01, 6.502e-01)) # ({x1}, (6.454e-01, 3.546e-01)) # ({x2}, (4.999e-01, 5.001e-01)) # ({x3}, (3.050e-01, 6.950e-01)) # ({x4}, (3.693e-01, 6.307e-01)) # ({x5}, (6.412e-01, 3.588e-01)) # ({x6}, (5.800e-01, 4.200e-01)) # ({x7}, (5.434e-01, 4.566e-01)) # ({x8}, (2.792e-01, 7.208e-01)) # ({x9}, (7.091e-01, 2.909e-01)) # ({x10}, (5.775e-01, 4.225e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.539e-01, 6.461e-01)) # ({x13}, (9.039e-01, 9.611e-02)) # ({x14}, (2.409e-01, 7.591e-01)) # ({x15}, (6.910e-01, 3.090e-01)) MR_CLAMPING_FULL 8.566e-04 2.978e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.498e-01, 6.502e-01)) # ({x1}, (6.452e-01, 3.548e-01)) # ({x2}, (4.999e-01, 5.001e-01)) # ({x3}, (3.050e-01, 6.950e-01)) # ({x4}, (3.694e-01, 6.306e-01)) # ({x5}, (6.409e-01, 3.591e-01)) # ({x6}, (5.799e-01, 4.201e-01)) # ({x7}, (5.434e-01, 4.566e-01)) # ({x8}, (2.794e-01, 7.206e-01)) # ({x9}, (7.090e-01, 2.910e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.376e-01, 4.624e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.039e-01, 9.609e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) MR_EXACT_FULL 9.079e-04 2.836e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.498e-01, 6.502e-01)) # ({x1}, (6.452e-01, 3.548e-01)) # ({x2}, (4.999e-01, 5.001e-01)) # ({x3}, (3.050e-01, 6.950e-01)) # ({x4}, (3.694e-01, 6.306e-01)) # ({x5}, (6.410e-01, 3.590e-01)) # ({x6}, (5.799e-01, 4.201e-01)) # ({x7}, (5.434e-01, 4.566e-01)) # ({x8}, (2.796e-01, 7.204e-01)) # ({x9}, (7.089e-01, 2.911e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.376e-01, 4.624e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.039e-01, 9.611e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) MR_RESPPROP_LINEAR 1.222e-03 3.928e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.498e-01, 6.502e-01)) # ({x1}, (6.455e-01, 3.545e-01)) # ({x2}, (4.999e-01, 5.001e-01)) # ({x3}, (3.050e-01, 6.950e-01)) # ({x4}, (3.693e-01, 6.307e-01)) # ({x5}, (6.413e-01, 3.587e-01)) # ({x6}, (5.800e-01, 4.200e-01)) # ({x7}, (5.434e-01, 4.566e-01)) # ({x8}, (2.791e-01, 7.209e-01)) # ({x9}, (7.092e-01, 2.908e-01)) # ({x10}, (5.775e-01, 4.225e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.539e-01, 6.461e-01)) # ({x13}, (9.039e-01, 9.611e-02)) # ({x14}, (2.409e-01, 7.591e-01)) # ({x15}, (6.910e-01, 3.090e-01)) MR_CLAMPING_LINEAR 1.002e-03 3.154e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.498e-01, 6.502e-01)) # ({x1}, (6.452e-01, 3.548e-01)) # ({x2}, (4.999e-01, 5.001e-01)) # ({x3}, (3.050e-01, 6.950e-01)) # ({x4}, (3.694e-01, 6.306e-01)) # ({x5}, (6.411e-01, 3.589e-01)) # ({x6}, (5.799e-01, 4.201e-01)) # ({x7}, (5.434e-01, 4.566e-01)) # ({x8}, (2.793e-01, 7.207e-01)) # ({x9}, (7.090e-01, 2.910e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.376e-01, 4.624e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.039e-01, 9.608e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) MR_EXACT_LINEAR 1.054e-03 3.011e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.499e-01, 6.501e-01)) # ({x1}, (6.452e-01, 3.548e-01)) # ({x2}, (4.999e-01, 5.001e-01)) # ({x3}, (3.050e-01, 6.950e-01)) # ({x4}, (3.695e-01, 6.305e-01)) # ({x5}, (6.411e-01, 3.589e-01)) # ({x6}, (5.799e-01, 4.201e-01)) # ({x7}, (5.434e-01, 4.566e-01)) # ({x8}, (2.795e-01, 7.205e-01)) # ({x9}, (7.090e-01, 2.910e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.376e-01, 4.624e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.039e-01, 9.610e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) LCBP 1.671e-04 3.175e-05 N/A N/A N/A 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.698e-01, 6.302e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.798e-01, 7.202e-01)) # ({x9}, (7.084e-01, 2.916e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.541e-01, 6.459e-01)) # ({x13}, (9.038e-01, 9.615e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) LCBP_FULLCAV_SEQFIX 1.671e-04 3.175e-05 N/A N/A N/A 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.698e-01, 6.302e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.798e-01, 7.202e-01)) # ({x9}, (7.084e-01, 2.916e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.541e-01, 6.459e-01)) # ({x13}, (9.038e-01, 9.615e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) LCBP_FULLCAVin_SEQFIX 1.671e-04 3.175e-05 N/A N/A N/A 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.698e-01, 6.302e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.798e-01, 7.202e-01)) # ({x9}, (7.084e-01, 2.916e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.541e-01, 6.459e-01)) # ({x13}, (9.038e-01, 9.615e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) LCBP_FULLCAV_SEQRND 1.671e-04 3.175e-05 N/A N/A N/A 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.698e-01, 6.302e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.798e-01, 7.202e-01)) # ({x9}, (7.084e-01, 2.916e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.541e-01, 6.459e-01)) # ({x13}, (9.038e-01, 9.615e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) LCBP_FULLCAVin_SEQRND 1.671e-04 3.175e-05 N/A N/A N/A 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.698e-01, 6.302e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.798e-01, 7.202e-01)) # ({x9}, (7.084e-01, 2.916e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.541e-01, 6.459e-01)) # ({x13}, (9.038e-01, 9.615e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) LCBP_FULLCAV_NONE 1.754e-03 3.875e-04 N/A N/A N/A 1.000e+00 # ({x0}, (3.504e-01, 6.496e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (5.004e-01, 4.996e-01)) # ({x3}, (3.052e-01, 6.948e-01)) # ({x4}, (3.698e-01, 6.302e-01)) # ({x5}, (6.403e-01, 3.597e-01)) # ({x6}, (5.794e-01, 4.206e-01)) # ({x7}, (5.428e-01, 4.572e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.358e-01, 4.642e-01)) # ({x12}, (3.545e-01, 6.455e-01)) # ({x13}, (9.038e-01, 9.623e-02)) # ({x14}, (2.415e-01, 7.585e-01)) # ({x15}, (6.916e-01, 3.084e-01)) LCBP_FULLCAVin_NONE 1.754e-03 3.875e-04 N/A N/A N/A 1.000e+00 # ({x0}, (3.504e-01, 6.496e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (5.004e-01, 4.996e-01)) # ({x3}, (3.052e-01, 6.948e-01)) # ({x4}, (3.698e-01, 6.302e-01)) # ({x5}, (6.403e-01, 3.597e-01)) # ({x6}, (5.794e-01, 4.206e-01)) # ({x7}, (5.428e-01, 4.572e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.358e-01, 4.642e-01)) # ({x12}, (3.545e-01, 6.455e-01)) # ({x13}, (9.038e-01, 9.623e-02)) # ({x14}, (2.415e-01, 7.585e-01)) # ({x15}, (6.916e-01, 3.084e-01)) LCBP_PAIRCAV_SEQFIX 1.355e-03 5.520e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.498e-01, 6.502e-01)) # ({x1}, (6.455e-01, 3.545e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.051e-01, 6.949e-01)) # ({x4}, (3.694e-01, 6.306e-01)) # ({x5}, (6.414e-01, 3.586e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.433e-01, 4.567e-01)) # ({x8}, (2.795e-01, 7.205e-01)) # ({x9}, (7.093e-01, 2.907e-01)) # ({x10}, (5.788e-01, 4.212e-01)) # ({x11}, (5.380e-01, 4.620e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.041e-01, 9.593e-02)) # ({x14}, (2.406e-01, 7.594e-01)) # ({x15}, (6.909e-01, 3.091e-01)) LCBP_PAIRCAVin_SEQFIX 1.355e-03 5.520e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.498e-01, 6.502e-01)) # ({x1}, (6.455e-01, 3.545e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.051e-01, 6.949e-01)) # ({x4}, (3.694e-01, 6.306e-01)) # ({x5}, (6.414e-01, 3.586e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.433e-01, 4.567e-01)) # ({x8}, (2.795e-01, 7.205e-01)) # ({x9}, (7.093e-01, 2.907e-01)) # ({x10}, (5.788e-01, 4.212e-01)) # ({x11}, (5.380e-01, 4.620e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.041e-01, 9.593e-02)) # ({x14}, (2.406e-01, 7.594e-01)) # ({x15}, (6.909e-01, 3.091e-01)) LCBP_PAIRCAV_SEQRND 1.355e-03 5.520e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.498e-01, 6.502e-01)) # ({x1}, (6.455e-01, 3.545e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.051e-01, 6.949e-01)) # ({x4}, (3.694e-01, 6.306e-01)) # ({x5}, (6.414e-01, 3.586e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.433e-01, 4.567e-01)) # ({x8}, (2.795e-01, 7.205e-01)) # ({x9}, (7.093e-01, 2.907e-01)) # ({x10}, (5.788e-01, 4.212e-01)) # ({x11}, (5.380e-01, 4.620e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.041e-01, 9.593e-02)) # ({x14}, (2.406e-01, 7.594e-01)) # ({x15}, (6.909e-01, 3.091e-01)) LCBP_PAIRCAVin_SEQRND 1.355e-03 5.520e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.498e-01, 6.502e-01)) # ({x1}, (6.455e-01, 3.545e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.051e-01, 6.949e-01)) # ({x4}, (3.694e-01, 6.306e-01)) # ({x5}, (6.414e-01, 3.586e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.433e-01, 4.567e-01)) # ({x8}, (2.795e-01, 7.205e-01)) # ({x9}, (7.093e-01, 2.907e-01)) # ({x10}, (5.788e-01, 4.212e-01)) # ({x11}, (5.380e-01, 4.620e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.041e-01, 9.593e-02)) # ({x14}, (2.406e-01, 7.594e-01)) # ({x15}, (6.909e-01, 3.091e-01)) LCBP_PAIRCAV_NONE 1.695e-01 4.680e-02 N/A N/A N/A 1.000e+00 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.909e-01, 3.091e-01)) # ({x2}, (5.012e-01, 4.988e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (2.003e-01, 7.997e-01)) # ({x5}, (7.799e-01, 2.201e-01)) # ({x6}, (6.886e-01, 3.114e-01)) # ({x7}, (5.689e-01, 4.311e-01)) # ({x8}, (2.305e-01, 7.695e-01)) # ({x9}, (8.445e-01, 1.555e-01)) # ({x10}, (5.781e-01, 4.219e-01)) # ({x11}, (5.160e-01, 4.840e-01)) # ({x12}, (3.533e-01, 6.467e-01)) # ({x13}, (9.242e-01, 7.582e-02)) # ({x14}, (2.130e-01, 7.870e-01)) # ({x15}, (6.916e-01, 3.084e-01)) LCBP_PAIRCAVin_NONE 1.695e-01 4.680e-02 N/A N/A N/A 1.000e+00 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.909e-01, 3.091e-01)) # ({x2}, (5.012e-01, 4.988e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (2.003e-01, 7.997e-01)) # ({x5}, (7.799e-01, 2.201e-01)) # ({x6}, (6.886e-01, 3.114e-01)) # ({x7}, (5.689e-01, 4.311e-01)) # ({x8}, (2.305e-01, 7.695e-01)) # ({x9}, (8.445e-01, 1.555e-01)) # ({x10}, (5.781e-01, 4.219e-01)) # ({x11}, (5.160e-01, 4.840e-01)) # ({x12}, (3.533e-01, 6.467e-01)) # ({x13}, (9.242e-01, 7.582e-02)) # ({x14}, (2.130e-01, 7.870e-01)) # ({x15}, (6.916e-01, 3.084e-01)) LCBP_PAIR2CAV_SEQFIX 1.254e-03 5.210e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.499e-01, 6.501e-01)) # ({x1}, (6.454e-01, 3.546e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.051e-01, 6.949e-01)) # ({x4}, (3.695e-01, 6.305e-01)) # ({x5}, (6.413e-01, 3.587e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.433e-01, 4.567e-01)) # ({x8}, (2.796e-01, 7.204e-01)) # ({x9}, (7.093e-01, 2.907e-01)) # ({x10}, (5.788e-01, 4.212e-01)) # ({x11}, (5.380e-01, 4.620e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.041e-01, 9.592e-02)) # ({x14}, (2.405e-01, 7.595e-01)) # ({x15}, (6.909e-01, 3.091e-01)) LCBP_PAIR2CAVin_SEQFIX 1.254e-03 5.210e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.499e-01, 6.501e-01)) # ({x1}, (6.454e-01, 3.546e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.051e-01, 6.949e-01)) # ({x4}, (3.695e-01, 6.305e-01)) # ({x5}, (6.413e-01, 3.587e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.433e-01, 4.567e-01)) # ({x8}, (2.796e-01, 7.204e-01)) # ({x9}, (7.093e-01, 2.907e-01)) # ({x10}, (5.788e-01, 4.212e-01)) # ({x11}, (5.380e-01, 4.620e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.041e-01, 9.592e-02)) # ({x14}, (2.405e-01, 7.595e-01)) # ({x15}, (6.909e-01, 3.091e-01)) LCBP_PAIR2CAV_SEQRND 1.254e-03 5.210e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.499e-01, 6.501e-01)) # ({x1}, (6.454e-01, 3.546e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.051e-01, 6.949e-01)) # ({x4}, (3.695e-01, 6.305e-01)) # ({x5}, (6.413e-01, 3.587e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.433e-01, 4.567e-01)) # ({x8}, (2.796e-01, 7.204e-01)) # ({x9}, (7.093e-01, 2.907e-01)) # ({x10}, (5.788e-01, 4.212e-01)) # ({x11}, (5.380e-01, 4.620e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.041e-01, 9.592e-02)) # ({x14}, (2.405e-01, 7.595e-01)) # ({x15}, (6.909e-01, 3.091e-01)) LCBP_PAIR2CAVin_SEQRND 1.254e-03 5.210e-04 N/A N/A N/A 1.000e-09 # ({x0}, (3.499e-01, 6.501e-01)) # ({x1}, (6.454e-01, 3.546e-01)) # ({x2}, (5.000e-01, 5.000e-01)) # ({x3}, (3.051e-01, 6.949e-01)) # ({x4}, (3.695e-01, 6.305e-01)) # ({x5}, (6.413e-01, 3.587e-01)) # ({x6}, (5.804e-01, 4.196e-01)) # ({x7}, (5.433e-01, 4.567e-01)) # ({x8}, (2.796e-01, 7.204e-01)) # ({x9}, (7.093e-01, 2.907e-01)) # ({x10}, (5.788e-01, 4.212e-01)) # ({x11}, (5.380e-01, 4.620e-01)) # ({x12}, (3.540e-01, 6.460e-01)) # ({x13}, (9.041e-01, 9.592e-02)) # ({x14}, (2.405e-01, 7.595e-01)) # ({x15}, (6.909e-01, 3.091e-01)) LCBP_PAIR2CAV_NONE 1.706e-01 4.655e-02 N/A N/A N/A 1.000e+00 # ({x0}, (3.504e-01, 6.496e-01)) # ({x1}, (6.896e-01, 3.104e-01)) # ({x2}, (5.009e-01, 4.991e-01)) # ({x3}, (3.052e-01, 6.948e-01)) # ({x4}, (1.992e-01, 8.008e-01)) # ({x5}, (7.808e-01, 2.192e-01)) # ({x6}, (6.838e-01, 3.162e-01)) # ({x7}, (5.678e-01, 4.322e-01)) # ({x8}, (2.289e-01, 7.711e-01)) # ({x9}, (8.447e-01, 1.553e-01)) # ({x10}, (5.786e-01, 4.214e-01)) # ({x11}, (5.169e-01, 4.831e-01)) # ({x12}, (3.545e-01, 6.455e-01)) # ({x13}, (9.242e-01, 7.578e-02)) # ({x14}, (2.131e-01, 7.869e-01)) # ({x15}, (6.916e-01, 3.084e-01)) LCBP_PAIR2CAVin_NONE 1.706e-01 4.655e-02 N/A N/A N/A 1.000e+00 # ({x0}, (3.504e-01, 6.496e-01)) # ({x1}, (6.896e-01, 3.104e-01)) # ({x2}, (5.009e-01, 4.991e-01)) # ({x3}, (3.052e-01, 6.948e-01)) # ({x4}, (1.992e-01, 8.008e-01)) # ({x5}, (7.808e-01, 2.192e-01)) # ({x6}, (6.838e-01, 3.162e-01)) # ({x7}, (5.678e-01, 4.322e-01)) # ({x8}, (2.289e-01, 7.711e-01)) # ({x9}, (8.447e-01, 1.553e-01)) # ({x10}, (5.786e-01, 4.214e-01)) # ({x11}, (5.169e-01, 4.831e-01)) # ({x12}, (3.545e-01, 6.455e-01)) # ({x13}, (9.242e-01, 7.578e-02)) # ({x14}, (2.131e-01, 7.869e-01)) # ({x15}, (6.916e-01, 3.084e-01)) LCBP_UNICAV_SEQFIX 8.924e-03 3.480e-03 N/A N/A N/A 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) LCBP_UNICAV_SEQRND 8.924e-03 3.480e-03 N/A N/A N/A 1.000e-09 # ({x0}, (3.486e-01, 6.514e-01)) # ({x1}, (6.432e-01, 3.568e-01)) # ({x2}, (5.007e-01, 4.993e-01)) # ({x3}, (3.027e-01, 6.973e-01)) # ({x4}, (3.661e-01, 6.339e-01)) # ({x5}, (6.415e-01, 3.585e-01)) # ({x6}, (5.819e-01, 4.181e-01)) # ({x7}, (5.445e-01, 4.555e-01)) # ({x8}, (2.718e-01, 7.282e-01)) # ({x9}, (7.144e-01, 2.856e-01)) # ({x10}, (5.711e-01, 4.289e-01)) # ({x11}, (5.339e-01, 4.661e-01)) # ({x12}, (3.515e-01, 6.485e-01)) # ({x13}, (9.038e-01, 9.620e-02)) # ({x14}, (2.497e-01, 7.503e-01)) # ({x15}, (6.859e-01, 3.141e-01)) LCTREEEP 4.322e-05 7.793e-06 N/A N/A N/A 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.801e-01, 7.199e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.616e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) BBP 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.447e-01, 3.553e-01)) # ({x2}, (4.997e-01, 5.003e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.401e-01, 3.599e-01)) # ({x6}, (5.793e-01, 4.207e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.800e-01, 7.200e-01)) # ({x9}, (7.083e-01, 2.917e-01)) # ({x10}, (5.776e-01, 4.224e-01)) # ({x11}, (5.375e-01, 4.625e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.038e-01, 9.617e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) # testfast.fg # METHOD MAX VAR ERR AVG VAR ERR MAX FAC ERR AVG FAC ERR LOGZ ERROR MAXDIFF JTREE_MINFILL_HUGIN_MAP # ({x0}, (2.050e-01, 7.950e-01)) # ({x1}, (6.683e-01, 3.317e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (1.858e-01, 8.142e-01)) # ({x5}, (6.683e-01, 3.317e-01)) # ({x6}, (6.354e-01, 3.646e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (1.858e-01, 8.142e-01)) # ({x9}, (8.142e-01, 1.858e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (2.592e-01, 7.408e-01)) # ({x13}, (9.509e-01, 4.908e-02)) # ({x14}, (2.640e-01, 7.360e-01)) # ({x15}, (6.154e-01, 3.846e-01)) JTREE_MINFILL_SHSH_MAP 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (2.050e-01, 7.950e-01)) # ({x1}, (6.683e-01, 3.317e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (1.858e-01, 8.142e-01)) # ({x5}, (6.683e-01, 3.317e-01)) # ({x6}, (6.354e-01, 3.646e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (1.858e-01, 8.142e-01)) # ({x9}, (8.142e-01, 1.858e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (2.592e-01, 7.408e-01)) # ({x13}, (9.509e-01, 4.908e-02)) # ({x14}, (2.640e-01, 7.360e-01)) # ({x15}, (6.154e-01, 3.846e-01)) JTREE_WEIGHTEDMINFILL_HUGIN_MAP 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (2.050e-01, 7.950e-01)) # ({x1}, (6.683e-01, 3.317e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (1.858e-01, 8.142e-01)) # ({x5}, (6.683e-01, 3.317e-01)) # ({x6}, (6.354e-01, 3.646e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (1.858e-01, 8.142e-01)) # ({x9}, (8.142e-01, 1.858e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (2.592e-01, 7.408e-01)) # ({x13}, (9.509e-01, 4.908e-02)) # ({x14}, (2.640e-01, 7.360e-01)) # ({x15}, (6.154e-01, 3.846e-01)) JTREE_WEIGHTEDMINFILL_SHSH_MAP 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (2.050e-01, 7.950e-01)) # ({x1}, (6.683e-01, 3.317e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (1.858e-01, 8.142e-01)) # ({x5}, (6.683e-01, 3.317e-01)) # ({x6}, (6.354e-01, 3.646e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (1.858e-01, 8.142e-01)) # ({x9}, (8.142e-01, 1.858e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (2.592e-01, 7.408e-01)) # ({x13}, (9.509e-01, 4.908e-02)) # ({x14}, (2.640e-01, 7.360e-01)) # ({x15}, (6.154e-01, 3.846e-01)) JTREE_MINWEIGHT_HUGIN_MAP 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (2.050e-01, 7.950e-01)) # ({x1}, (6.683e-01, 3.317e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (1.858e-01, 8.142e-01)) # ({x5}, (6.683e-01, 3.317e-01)) # ({x6}, (6.354e-01, 3.646e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (1.858e-01, 8.142e-01)) # ({x9}, (8.142e-01, 1.858e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (2.592e-01, 7.408e-01)) # ({x13}, (9.509e-01, 4.908e-02)) # ({x14}, (2.640e-01, 7.360e-01)) # ({x15}, (6.154e-01, 3.846e-01)) JTREE_MINWEIGHT_SHSH_MAP 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (2.050e-01, 7.950e-01)) # ({x1}, (6.683e-01, 3.317e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (1.858e-01, 8.142e-01)) # ({x5}, (6.683e-01, 3.317e-01)) # ({x6}, (6.354e-01, 3.646e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (1.858e-01, 8.142e-01)) # ({x9}, (8.142e-01, 1.858e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (2.592e-01, 7.408e-01)) # ({x13}, (9.509e-01, 4.908e-02)) # ({x14}, (2.640e-01, 7.360e-01)) # ({x15}, (6.154e-01, 3.846e-01)) JTREE_MINNEIGHBORS_HUGIN_MAP 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (2.050e-01, 7.950e-01)) # ({x1}, (6.683e-01, 3.317e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (1.858e-01, 8.142e-01)) # ({x5}, (6.683e-01, 3.317e-01)) # ({x6}, (6.354e-01, 3.646e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (1.858e-01, 8.142e-01)) # ({x9}, (8.142e-01, 1.858e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (2.592e-01, 7.408e-01)) # ({x13}, (9.509e-01, 4.908e-02)) # ({x14}, (2.640e-01, 7.360e-01)) # ({x15}, (6.154e-01, 3.846e-01)) JTREE_MINNEIGHBORS_SHSH_MAP 1.000e-09 1.000e-09 1.000e-09 1.000e-09 +1.000e-09 1.000e-09 # ({x0}, (2.050e-01, 7.950e-01)) # ({x1}, (6.683e-01, 3.317e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (1.858e-01, 8.142e-01)) # ({x5}, (6.683e-01, 3.317e-01)) # ({x6}, (6.354e-01, 3.646e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (1.858e-01, 8.142e-01)) # ({x9}, (8.142e-01, 1.858e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (2.592e-01, 7.408e-01)) # ({x13}, (9.509e-01, 4.908e-02)) # ({x14}, (2.640e-01, 7.360e-01)) # ({x15}, (6.154e-01, 3.846e-01)) MP_SEQFIX 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) MP_SEQRND 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) MP_PARALL 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) MP_SEQFIX_LOG 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) MP_SEQRND_LOG 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) MP_PARALL_LOG 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) FMP_SEQFIX 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) FMP_SEQRND 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) FMP_PARALL 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) FMP_SEQFIX_LOG 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) FMP_SEQRND_LOG 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) FMP_PARALL_LOG 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) TRWMP_SEQFIX 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) TRWMP_SEQRND 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) TRWMP_PARALL 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) TRWMP_SEQFIX_LOG 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) TRWMP_SEQRND_LOG 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) TRWMP_PARALL_LOG 1.313e-01 4.991e-02 1.702e-01 6.840e-02 +2.808e+00 1.000e-09 # ({x0}, (3.104e-01, 6.896e-01)) # ({x1}, (6.246e-01, 3.754e-01)) # ({x2}, (5.929e-01, 4.071e-01)) # ({x3}, (5.383e-01, 4.617e-01)) # ({x4}, (3.104e-01, 6.896e-01)) # ({x5}, (6.246e-01, 3.754e-01)) # ({x6}, (6.246e-01, 3.754e-01)) # ({x7}, (4.617e-01, 5.383e-01)) # ({x8}, (3.104e-01, 6.896e-01)) # ({x9}, (6.896e-01, 3.104e-01)) # ({x10}, (5.383e-01, 4.617e-01)) # ({x11}, (5.383e-01, 4.617e-01)) # ({x12}, (3.104e-01, 6.896e-01)) # ({x13}, (9.230e-01, 7.703e-02)) # ({x14}, (3.953e-01, 6.047e-01)) # ({x15}, (6.047e-01, 3.953e-01)) DECMAP 4.617e-01 3.126e-01 6.691e-01 4.224e-01 -9.136e-01 1.000e-09 # ({x0}, (0.000e+00, 1.000e+00)) # ({x1}, (1.000e+00, 0.000e+00)) # ({x2}, (1.000e+00, 0.000e+00)) # ({x3}, (1.000e+00, 0.000e+00)) # ({x4}, (0.000e+00, 1.000e+00)) # ({x5}, (1.000e+00, 0.000e+00)) # ({x6}, (1.000e+00, 0.000e+00)) # ({x7}, (0.000e+00, 1.000e+00)) # ({x8}, (0.000e+00, 1.000e+00)) # ({x9}, (1.000e+00, 0.000e+00)) # ({x10}, (1.000e+00, 0.000e+00)) # ({x11}, (1.000e+00, 0.000e+00)) # ({x12}, (0.000e+00, 1.000e+00)) # ({x13}, (1.000e+00, 0.000e+00)) # ({x14}, (0.000e+00, 1.000e+00)) # ({x15}, (1.000e+00, 0.000e+00)) libDAI-0.2.7/tests/twofactors.fg0000644000263000017630000000020711433220722015326 0ustar jorismkyb2 2 0 1 2 2 4 0 0.570273 1 0.702232 2 0.774333 3 3.41627 2 2 3 2 2 4 0 1.51657 1 0.920425 2 0.254792 3 1.50469 libDAI-0.2.7/tests/zeroes1.fg0000644000263000017630000000025111433220722014522 0ustar jorismkyb# Factor graph that contains many zeroes (useful for testing purposes) 3 1 0 2 2 0 0 1 1 2 0 1 2 2 4 0 1 1 2 2 2 3 1 2 1 2 2 2 4 0 1 1 2 2 2 3 1 libDAI-0.2.7/tests/alarm.fg0000644000263000017630000004107411433220722014236 0ustar jorismkyb# ALARM network # from http://compbio.cs.huji.ac.il/Repository/Datasets/alarm/alarm.dsc 37 2 0 5 2 2 4 0 0.9 1 0.1 2 0.01 3 0.99 2 1 4 3 3 9 0 0.95 1 0.04 2 0.01 3 0.04 4 0.95 5 0.01 6 0.01 7 0.29 8 0.7 2 2 4 3 3 9 0 0.95 1 0.04 2 0.01 3 0.04 4 0.95 5 0.01 6 0.01 7 0.04 8 0.95 1 3 2 2 0 0.2 1 0.8 3 3 4 5 2 3 2 12 0 0.95 1 0.01 2 0.04 3 0.09 4 0.01 5 0.9 6 0.98 7 0.05 8 0.01 9 0.9 10 0.01 11 0.05 1 5 2 2 0 0.05 1 0.95 3 3 5 6 2 2 3 12 0 0.98 1 0.5 2 0.95 3 0.05 4 0.01 5 0.49 6 0.04 7 0.9 8 0.01 9 0.01 10 0.01 11 0.05 1 7 2 2 0 0.05 1 0.95 3 7 8 34 2 3 3 18 0 0.98 1 0.98 2 0.01 3 0.01 4 0.01 5 0.01 6 0.4 7 0.01 8 0.59 9 0.98 10 0.01 11 0.01 12 0.3 13 0.01 14 0.4 15 0.01 16 0.3 17 0.98 3 9 10 34 3 2 3 18 0 0.333 1 0.333 2 0.333 3 0.98 4 0.01 5 0.01 6 0.333 7 0.333 8 0.333 9 0.01 10 0.98 11 0.01 12 0.333 13 0.333 14 0.333 15 0.01 16 0.01 17 0.98 1 10 2 2 0 0.1 1 0.9 3 10 11 34 2 3 3 18 0 0.333 1 0.98 2 0.333 3 0.01 4 0.333 5 0.01 6 0.333 7 0.01 8 0.333 9 0.98 10 0.333 11 0.01 12 0.333 13 0.01 14 0.333 15 0.01 16 0.333 17 0.98 1 12 2 2 0 0.1 1 0.9 1 13 2 2 0 0.01 1 0.99 2 13 14 2 3 6 0 0.98 1 0.3 2 0.01 3 0.4 4 0.01 5 0.3 3 15 30 32 4 4 3 48 0 0.97 1 0.01 2 0.01 3 0.01 4 0.01 5 0.97 6 0.01 7 0.01 8 0.01 9 0.01 10 0.97 11 0.01 12 0.01 13 0.01 14 0.01 15 0.97 16 0.01 17 0.97 18 0.01 19 0.01 20 0.97 21 0.01 22 0.01 23 0.01 24 0.01 25 0.01 26 0.97 27 0.01 28 0.01 29 0.01 30 0.01 31 0.97 32 0.01 33 0.97 34 0.01 35 0.01 36 0.01 37 0.01 38 0.97 39 0.01 40 0.97 41 0.01 42 0.01 43 0.01 44 0.01 45 0.01 46 0.01 47 0.97 1 16 2 2 0 0.04 1 0.96 3 17 24 30 4 3 4 48 0 0.97 1 0.01 2 0.01 3 0.01 4 0.97 5 0.01 6 0.01 7 0.01 8 0.97 9 0.01 10 0.01 11 0.01 12 0.01 13 0.97 14 0.01 15 0.01 16 0.6 17 0.38 18 0.01 19 0.01 20 0.01 21 0.97 22 0.01 23 0.01 24 0.01 25 0.01 26 0.97 27 0.01 28 0.5 29 0.48 30 0.01 31 0.01 32 0.01 33 0.01 34 0.97 35 0.01 36 0.01 37 0.01 38 0.01 39 0.97 40 0.5 41 0.48 42 0.01 43 0.01 44 0.01 45 0.01 46 0.01 47 0.97 1 18 2 2 0 0.05 1 0.95 3 18 19 31 2 3 4 19 0 1 1 1 6 0.99 7 0.95 8 0.01 9 0.04 11 0.01 12 0.95 13 0.01 14 0.04 15 0.95 16 0.01 17 0.04 18 0.95 19 0.01 20 0.04 21 0.01 22 0.01 23 0.98 3 19 20 23 3 3 2 18 0 0.98 1 0.01 2 0.98 3 0.01 4 0.01 5 0.01 6 0.01 7 0.98 8 0.01 9 0.01 10 0.98 11 0.69 12 0.98 13 0.01 14 0.3 15 0.01 16 0.01 17 0.01 2 21 22 3 2 6 0 0.01 1 0.19 2 0.8 3 0.05 4 0.9 5 0.05 1 22 2 2 0 0.01 1 0.99 3 22 23 24 2 2 3 12 0 0.1 1 0.95 2 0.9 3 0.05 4 0.1 5 0.95 6 0.9 7 0.05 8 0.01 9 0.05 10 0.99 11 0.95 1 24 3 3 0 0.92 1 0.03 2 0.05 4 16 24 25 29 2 3 4 4 96 0 0.97 1 0.97 2 0.97 3 0.97 4 0.97 5 0.97 6 0.01 7 0.01 8 0.01 9 0.01 10 0.01 11 0.01 12 0.01 13 0.01 14 0.01 15 0.01 16 0.01 17 0.01 18 0.01 19 0.01 20 0.01 21 0.01 22 0.01 23 0.01 24 0.01 25 0.01 26 0.1 27 0.4 28 0.01 29 0.01 30 0.3 31 0.97 32 0.84 33 0.58 34 0.29 35 0.9 36 0.49 37 0.01 38 0.05 39 0.01 40 0.3 41 0.08 42 0.2 43 0.01 44 0.01 45 0.01 46 0.4 47 0.01 48 0.01 49 0.01 50 0.05 51 0.2 52 0.01 53 0.01 54 0.01 55 0.01 56 0.25 57 0.75 58 0.01 59 0.01 60 0.08 61 0.97 62 0.25 63 0.04 64 0.08 65 0.38 66 0.9 67 0.01 68 0.45 69 0.01 70 0.9 71 0.6 72 0.01 73 0.01 74 0.01 75 0.2 76 0.01 77 0.01 78 0.01 79 0.01 80 0.15 81 0.7 82 0.01 83 0.01 84 0.01 85 0.01 86 0.25 87 0.09 88 0.01 89 0.01 90 0.97 91 0.97 92 0.59 93 0.01 94 0.97 95 0.97 1 26 2 2 0 0.1 1 0.9 1 27 3 3 0 0.05 1 0.9 2 0.05 2 27 28 3 4 12 0 0.05 1 0.05 2 0.05 3 0.93 4 0.01 5 0.01 6 0.01 7 0.93 8 0.01 9 0.01 10 0.01 11 0.93 3 26 28 29 2 4 4 32 0 0.97 1 0.97 2 0.97 3 0.01 4 0.97 5 0.01 6 0.97 7 0.01 8 0.01 9 0.01 10 0.01 11 0.97 12 0.01 13 0.01 14 0.01 15 0.01 16 0.01 17 0.01 18 0.01 19 0.01 20 0.01 21 0.97 22 0.01 23 0.01 24 0.01 25 0.01 26 0.01 27 0.01 28 0.01 29 0.01 30 0.01 31 0.97 4 16 24 29 30 2 3 4 4 96 0 0.97 1 0.97 2 0.97 3 0.97 4 0.97 5 0.97 6 0.95 7 0.01 8 0.97 9 0.97 10 0.95 11 0.01 12 0.4 13 0.01 14 0.97 15 0.97 16 0.5 17 0.01 18 0.3 19 0.01 20 0.97 21 0.97 22 0.3 23 0.01 24 0.01 25 0.01 26 0.01 27 0.01 28 0.01 29 0.01 30 0.03 31 0.97 32 0.01 33 0.01 34 0.03 35 0.97 36 0.58 37 0.01 38 0.01 39 0.01 40 0.48 41 0.01 42 0.68 43 0.01 44 0.01 45 0.01 46 0.68 47 0.01 48 0.01 49 0.01 50 0.01 51 0.01 52 0.01 53 0.01 54 0.01 55 0.01 56 0.01 57 0.01 58 0.01 59 0.01 60 0.01 61 0.97 62 0.01 63 0.01 64 0.01 65 0.97 66 0.01 67 0.01 68 0.01 69 0.01 70 0.01 71 0.01 72 0.01 73 0.01 74 0.01 75 0.01 76 0.01 77 0.01 78 0.01 79 0.01 80 0.01 81 0.01 82 0.01 83 0.01 84 0.01 85 0.01 86 0.01 87 0.01 88 0.01 89 0.01 90 0.01 91 0.97 92 0.01 93 0.01 94 0.01 95 0.97 3 24 30 31 3 4 4 48 0 0.97 1 0.97 2 0.97 3 0.01 4 0.01 5 0.03 6 0.01 7 0.01 8 0.01 9 0.01 10 0.01 11 0.01 12 0.01 13 0.01 14 0.01 15 0.97 16 0.97 17 0.95 18 0.01 19 0.01 20 0.94 21 0.01 22 0.01 23 0.88 24 0.01 25 0.01 26 0.01 27 0.01 28 0.01 29 0.01 30 0.97 31 0.97 32 0.04 33 0.01 34 0.01 35 0.1 36 0.01 37 0.01 38 0.01 39 0.01 40 0.01 41 0.01 42 0.01 43 0.01 44 0.01 45 0.97 46 0.97 47 0.01 2 31 32 4 3 12 0 0.01 1 0.01 2 0.04 3 0.9 4 0.01 5 0.01 6 0.92 7 0.09 8 0.98 9 0.98 10 0.04 11 0.01 5 12 14 20 32 33 2 3 3 3 2 108 0 0.01 1 0.05 2 0.01 3 0.7 4 0.01 5 0.95 6 0.01 7 0.05 8 0.01 9 0.7 10 0.05 11 0.95 12 0.01 13 0.05 14 0.05 15 0.7 16 0.05 17 0.95 18 0.01 19 0.05 20 0.01 21 0.7 22 0.01 23 0.99 24 0.01 25 0.05 26 0.01 27 0.7 28 0.05 29 0.99 30 0.01 31 0.05 32 0.05 33 0.7 34 0.05 35 0.99 36 0.01 37 0.01 38 0.01 39 0.1 40 0.01 41 0.3 42 0.01 43 0.01 44 0.01 45 0.1 46 0.01 47 0.3 48 0.01 49 0.01 50 0.01 51 0.1 52 0.01 53 0.3 54 0.99 55 0.95 56 0.99 57 0.3 58 0.99 59 0.05 60 0.99 61 0.95 62 0.99 63 0.3 64 0.95 65 0.05 66 0.99 67 0.95 68 0.95 69 0.3 70 0.95 71 0.05 72 0.99 73 0.95 74 0.99 75 0.3 76 0.99 77 0.01 78 0.99 79 0.95 80 0.99 81 0.3 82 0.95 83 0.01 84 0.99 85 0.95 86 0.95 87 0.3 88 0.95 89 0.01 90 0.99 91 0.99 92 0.99 93 0.9 94 0.99 95 0.7 96 0.99 97 0.99 98 0.99 99 0.9 100 0.99 101 0.7 102 0.99 103 0.99 104 0.99 105 0.9 106 0.99 107 0.7 2 33 34 2 3 6 0 0.05 1 0.01 2 0.9 3 0.09 4 0.05 5 0.9 3 6 34 35 3 3 3 27 0 0.98 1 0.95 2 0.3 3 0.95 4 0.04 5 0.01 6 0.8 7 0.01 8 0.01 9 0.01 10 0.04 11 0.69 12 0.04 13 0.95 14 0.3 15 0.19 16 0.04 17 0.01 18 0.01 19 0.01 20 0.01 21 0.01 22 0.01 23 0.69 24 0.01 25 0.95 26 0.98 3 14 35 36 3 3 3 27 0 0.98 1 0.98 2 0.3 3 0.98 4 0.1 5 0.05 6 0.9 7 0.05 8 0.01 9 0.01 10 0.01 11 0.6 12 0.01 13 0.85 14 0.4 15 0.09 16 0.2 17 0.09 18 0.01 19 0.01 20 0.1 21 0.01 22 0.05 23 0.55 24 0.01 25 0.75 26 0.9 libDAI-0.2.7/tests/hoi3.fg0000644000263000017630000000123611433220722014000 0ustar jorismkyb# Factor graph made by ../utils/createfg # type = hoi # N = 10 # M = 3 # k = 3 # beta = 1 # seed = 1234567 3 3 0 2 7 2 2 2 8 0 1.4681858088541 1 0.62677975912889 2 0.93772291212951 3 0.55789818196925 4 2.2169178835152 5 1.1158597402573 6 4.3668946864226 7 0.5386131975631 3 2 5 9 2 2 2 8 0 0.42394324261549 1 1.8698790799175 2 0.751673014734 3 3.3944709353 4 3.0697466018763 5 1.3518859952286 6 0.85108939407003 7 0.44249854609337 3 1 4 6 2 2 2 8 0 1.7323418161587 1 1.1774643424739 2 1.8134284856927 3 0.46535724537261 4 2.9520075062676 5 0.87717718658893 6 0.30844599722711 7 0.9045019040901 libDAI-0.2.7/.gitignore0000644000263000017630000000003111433220722013436 0ustar jorismkyb.gitignore Makefile.conf libDAI-0.2.7/utils/0000755000263000017630000000000011433220722012614 5ustar jorismkyblibDAI-0.2.7/utils/fg2dot.cpp0000644000263000017630000000345111433220722014510 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include using namespace dai; using namespace std; int main( int argc, char *argv[] ) { if( argc != 3 ) { // Display help message if number of command line arguments is incorrect cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "Usage: ./fg2dot " << endl << endl; cout << "Converts a libDAI factor graph file to a GraphViz .dot file for visualization." << endl; cout << "The .dot file can be converted to .ps (PostScript) by" << endl; cout << "'neato -T ps out.dot > out.ps' or by 'dot -T ps out.dot > out.ps'" << endl << endl; return 1; } else { // Read factorgraph FactorGraph fg; char *infile = argv[1]; fg.ReadFromFile( infile ); // Open output file for writing (except if filename equals "-") ostream *os = &cout; ofstream outfile; if( string( argv[2] ) != "-" ) { outfile.open( argv[2] ); if( !outfile.is_open() ) { cerr << "Cannot open " << argv[2] << " for writing" << endl; return 1; } os = &outfile; } // else, write to cout // Write the .dot file fg.printDot( *os ); return 0; } } libDAI-0.2.7/utils/uai2fg.cpp0000644000263000017630000001342211433220722014477 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include #include using namespace std; using namespace dai; int main( int argc, char *argv[] ) { if ( argc != 4 ) { cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "Usage: ./uai2fg " << endl << endl; cout << "Converts input files in the UAI 2006/2008/2010 approximate inference evaluation format" << endl; cout << "(see http://graphmod.ics.uci.edu/uai08/ and http://www.cs.huji.ac.il/project/UAI10/)" << endl; cout << "to the libDAI factor graph format." << endl << endl; cout << "Reads factor graph and evidence " << endl; cout << "and writes the resulting clamped factor graphs to ," << endl; cout << "where X=0,1,2,... enumerates the different evidence cases." << endl << endl; cout << "If surgery!=0, uses surgery on the factor graph (recommended)," << endl; cout << "otherwise, just adds delta factors to the factor graph." << endl; return 1; } else { string basename( argv[1] ); bool surgery = fromString( argv[2] ); size_t verbose = fromString( argv[3] ); string uainame = basename + ".uai"; string evidname = uainame + ".evid"; // output command line options if( verbose ) { cout << "Factorgraph filename: " << uainame << endl; cout << "Evidence filename: " << evidname << endl; cout << "Output basename: " << basename << endl; cout << "Surgery: " << surgery << endl; } // read factor graph vector vars; vector facs0; vector permutations; if( verbose ) cout << "Reading factor graph..." << endl; ReadUaiAieFactorGraphFile( uainame.c_str(), verbose, vars, facs0, permutations ); if( verbose ) cout << "Successfully read factor graph" << endl; // read evidence if( verbose ) cout << "Reading evidence..." << endl; vector > evid = ReadUaiAieEvidenceFile( evidname.c_str(), verbose ); if( verbose ) cout << "Successfully read " << evid.size() << " evidence cases" << endl; // build output file names vector fgnames; fgnames.reserve( evid.size() ); for( size_t ev = 0; ev < evid.size(); ev++ ) fgnames.push_back( basename + '.' + toString(ev) + ".fg" ); // construct clamped factor graphs which reflect observed evidence cases if( verbose ) cout << "Constructing clamped factor graphs..." << endl; vector fgs; fgs.reserve( evid.size() ); for( size_t ev = 0; ev < evid.size(); ev++ ) { if( verbose ) cout << " Evidence case " << ev << "..." << endl; // copy vector of factors vector facs( facs0 ); // change factor graph to reflect observed evidence if( verbose ) cout << " Applying evidence..." << endl; if( surgery ) { // replace factors with clamped variables with slices for( size_t I = 0; I < facs.size(); I++ ) { for( map::const_iterator e = evid[ev].begin(); e != evid[ev].end(); e++ ) { if( facs[I].vars() >> vars[e->first] ) { if( verbose >= 2 ) cout << " Clamping " << e->first << " to value " << e->second << " in factor " << I << " = " << facs[I].vars() << endl; facs[I] = facs[I].slice( vars[e->first], e->second ); if( verbose >= 2 ) cout << " ...remaining vars: " << facs[I].vars() << endl; } } } // remove empty factors Real logZcorr = 0.0; for( vector::iterator I = facs.begin(); I != facs.end(); ) if( I->vars().size() == 0 ) { logZcorr += std::log( (Real)(*I)[0] ); I = facs.erase( I ); } else I++; // multiply with logZcorr constant if( facs.size() == 0 ) facs.push_back( Factor( VarSet(), std::exp(logZcorr) ) ); else facs.front() *= std::exp(logZcorr); } // add delta factors corresponding to observed variable values for( map::const_iterator e = evid[ev].begin(); e != evid[ev].end(); e++ ) facs.push_back( createFactorDelta( vars[e->first], e->second ) ); // construct clamped factor graph if( verbose ) cout << " Constructing factor graph..." << endl; fgs.push_back( FactorGraph( facs.begin(), facs.end(), vars.begin(), vars.end(), facs.size(), vars.size() ) ); // write it to a file if( verbose ) cout << " Saving factor graph as " << fgnames[ev] << "..." << endl; fgs[ev].WriteToFile( fgnames[ev].c_str() ); } if( verbose ) cout << "Done!" << endl; } return 0; } libDAI-0.2.7/utils/createfg.cpp0000644000263000017630000006770611433220722015120 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; using namespace dai; namespace po = boost::program_options; /// Possible factor types DAI_ENUM(FactorType,ISINGGAUSS,ISINGUNIFORM,EXPGAUSS,POTTS); /// Creates a factor graph from a pairwise interactions graph /** \param G Graph describing interactions between variables * \param ft Type of factors to use for interactions * \param states Number of states of the variables * \param props Additional properties for generating the interactions */ FactorGraph createFG( const GraphAL &G, FactorType ft, size_t states, const PropertySet &props ) { size_t N = G.nrNodes(); if( states > 2 ) DAI_ASSERT( ft != FactorType::ISINGGAUSS && ft != FactorType::ISINGUNIFORM ); // Get inverse temperature Real beta = 1.0; if( ft != FactorType::ISINGGAUSS && ft != FactorType::ISINGUNIFORM ) beta = props.getAs("beta"); // Get properties for Ising factors Real mean_h = 0.0; Real sigma_h = 0.0; Real mean_J = 0.0; Real sigma_J = 0.0; if( ft == FactorType::ISINGGAUSS ) { mean_h = props.getAs("mean_th"); sigma_h = props.getAs("sigma_th"); mean_J = props.getAs("mean_w"); sigma_J = props.getAs("sigma_w"); } Real min_h = 0.0; Real min_J = 0.0; Real max_h = 0.0; Real max_J = 0.0; if( ft == FactorType::ISINGUNIFORM ) { min_h = props.getAs("min_th"); min_J = props.getAs("min_w"); max_h = props.getAs("max_th"); max_J = props.getAs("max_w"); } // Create variables vector vars; vars.reserve( N ); for( size_t i = 0; i < N; i++ ) vars.push_back( Var( i, states ) ); // Create factors vector factors; factors.reserve( G.nrEdges() + N ); // Pairwise factors for( size_t i = 0; i < N; i++ ) foreach( const Neighbor &j, G.nb(i) ) if( i < j ) { if( ft == FactorType::POTTS ) factors.push_back( createFactorPotts( vars[i], vars[j], beta ) ); else if( ft == FactorType::EXPGAUSS ) factors.push_back( createFactorExpGauss( VarSet( vars[i], vars[j] ), beta ) ); else if( ft == FactorType::ISINGGAUSS ) { Real J = rnd_stdnormal() * sigma_J + mean_J; factors.push_back( createFactorIsing( vars[i], vars[j], J ) ); } else if( ft == FactorType::ISINGUNIFORM ) { Real J = min_J + rnd_uniform() * (max_J - min_J); factors.push_back( createFactorIsing( vars[i], vars[j], J ) ); } } // Unary factors if( ft == FactorType::ISINGGAUSS ) for( size_t i = 0; i < N; i++ ) { Real h = rnd_stdnormal() * sigma_h + mean_h; factors.push_back( createFactorIsing( vars[i], h ) ); } else if( ft == FactorType::ISINGUNIFORM ) for( size_t i = 0; i < N; i++ ) { Real h = min_h + rnd_uniform() * (max_h - min_h); factors.push_back( createFactorIsing( vars[i], h ) ); } return FactorGraph( factors.begin(), factors.end(), vars.begin(), vars.end(), factors.size(), vars.size() ); } /// Return a random factor graph with higher-order interactions /** \param N number of variables * \param M number of factors * \param k number of variables that each factor depends on * \param beta standard-deviation of Gaussian log-factor entries */ FactorGraph createHOIFG( size_t N, size_t M, size_t k, Real beta ) { vector vars; vector factors; vars.reserve(N); for( size_t i = 0; i < N; i++ ) vars.push_back(Var(i,2)); for( size_t I = 0; I < M; I++ ) { VarSet vars; while( vars.size() < k ) { do { size_t newind = (size_t)(N * rnd_uniform()); Var newvar = Var(newind, 2); if( !vars.contains( newvar ) ) { vars |= newvar; break; } } while( 1 ); } factors.push_back( createFactorExpGauss( vars, beta ) ); } return FactorGraph( factors.begin(), factors.end(), vars.begin(), vars.end(), factors.size(), vars.size() ); } /// Creates a regular random bipartite graph /** \param N1 = number of nodes of type 1 * \param d1 = size of neighborhoods of nodes of type 1 * \param N2 = number of nodes of type 2 * \param d2 = size of neighborhoods of nodes of type 2 * \note asserts that N1 * d1 == N2 * d2 */ BipartiteGraph createRandomBipartiteGraph( size_t N1, size_t N2, size_t d1, size_t d2 ) { BipartiteGraph G; DAI_ASSERT( N1 * d1 == N2 * d2 ); // build lists of degree-repeated vertex numbers std::vector stubs1( N1*d1, 0 ); for( size_t n1 = 0; n1 < N1; n1++ ) for( size_t t = 0; t < d1; t++ ) stubs1[n1*d1 + t] = n1; // build lists of degree-repeated vertex numbers std::vector stubs2( N2*d2, 0 ); for( size_t n2 = 0; n2 < N2; n2++ ) for( size_t t = 0; t < d2; t++ ) stubs2[n2*d2 + t] = n2; // shuffle lists random_shuffle( stubs1.begin(), stubs1.end() ); random_shuffle( stubs2.begin(), stubs2.end() ); // add edges vector edges; edges.reserve( N1*d1 ); for( size_t e = 0; e < N1*d1; e++ ) edges.push_back( Edge(stubs1[e], stubs2[e]) ); // finish construction G.construct( N1, N2, edges.begin(), edges.end() ); return G; } /// Returns x**n % p, assuming p is prime int powmod (int x, int n, int p) { int y = 1; for( int m = 0; m < n; m++ ) y = (x * y) % p; return y; } /// Returns order of x in GF(p) with p prime size_t order (int x, int p) { x = x % p; DAI_ASSERT( x != 0 ); size_t n = 0; size_t prod = 1; do { prod = (prod * x) % p; n++; } while( prod != 1 ); return n; } /// Returns whether n is a prime number bool isPrime (size_t n) { bool result = true; for( size_t k = 2; (k < n) && result; k++ ) if( n % k == 0 ) result = false; return result; } /// Constructs a regular LDPC graph with N=6, j=2, K=4, k=3 BipartiteGraph createSmallLDPCGraph() { BipartiteGraph G; size_t N=4, j=3, K=4; // k=3; vector edges; edges.reserve( N*j ); edges.push_back( Edge(0,0) ); edges.push_back( Edge(1,0) ); edges.push_back( Edge(2,0) ); edges.push_back( Edge(0,1) ); edges.push_back( Edge(1,1) ); edges.push_back( Edge(3,1) ); edges.push_back( Edge(0,2) ); edges.push_back( Edge(2,2) ); edges.push_back( Edge(3,2) ); edges.push_back( Edge(1,3) ); edges.push_back( Edge(2,3) ); edges.push_back( Edge(3,3) ); // finish construction G.construct( N, K, edges.begin(), edges.end() ); return G; } /// Creates group-structured LDPC code /** Use construction described in "A Class of Group-Structured LDPC Codes" * by R. M. Tanner, D. Sridhara and T. Fuja * Proceedings of ICSTA, 2001 * * Example parameters: (p,j,k) = (31,3,5) * (p,j,k) = (37,3,4) * (p,j,k) = (7,2,4) * (p,j,k) = (29,2,4) * * j and k must be divisors of p-1 */ BipartiteGraph createGroupStructuredLDPCGraph( size_t p, size_t j, size_t k ) { BipartiteGraph G; size_t n = j; size_t N = p * k; size_t K = p * j; size_t a, b; for( a = 2; a < p; a++ ) if( order(a,p) == k ) break; DAI_ASSERT( a != p ); for( b = 2; b < p; b++ ) if( order(b,p) == j ) break; DAI_ASSERT( b != p ); // cout << "# order(a=" << a << ") = " << order(a,p) << endl; // cout << "# order(b=" << b << ") = " << order(b,p) << endl; DAI_ASSERT( N * n == K * k ); vector edges; edges.reserve( N * n ); for( size_t s = 0; s < j; s++ ) for( size_t t = 0; t < k; t++ ) { size_t P = (powmod(b,s,p) * powmod(a,t,p)) % p; for( size_t m = 0; m < p; m++ ) edges.push_back( Edge(t*p + m, s*p + ((m + P) % p)) ); } // finish construction G.construct( N, K, edges.begin(), edges.end() ); return G; } // Constructs a parity check table void createParityCheck( Real *result, size_t n, Real eps ) { size_t N = 1 << n; for( size_t i = 0; i < N; i++ ) { size_t c = 0; for( size_t t = 0; t < n; t++ ) if( i & (1 << t) ) c ^= 1; if( c ) result[i] = eps; else result[i] = 1.0 - eps; } return; } /// Predefined names of various factor graph types const char *FULL_TYPE = "FULL"; const char *DREG_TYPE = "DREG"; const char *LOOP_TYPE = "LOOP"; const char *TREE_TYPE = "TREE"; const char *GRID_TYPE = "GRID"; const char *GRID3D_TYPE = "GRID3D"; const char *HOI_TYPE = "HOI"; const char *LDPC_TYPE = "LDPC"; /// Possible LDPC structures DAI_ENUM(LDPCType,SMALL,GROUP,RANDOM); /// Main function int main( int argc, char *argv[] ) { try { // Variables for storing command line arguments size_t seed; size_t states = 2; string type; size_t d, N, K, k, j, n1, n2, n3, prime; bool periodic = false; FactorType ft; LDPCType ldpc; Real beta, sigma_w, sigma_th, mean_w, mean_th, min_w, min_th, max_w, max_th, noise; // Declare the supported options. po::options_description opts("General command line options"); opts.add_options() ("help", "produce help message") ("seed", po::value(&seed), "random number seed (tries to read from /dev/urandom if not specified)") ("states", po::value(&states), "number of states of each variable (default=2 for binary variables)") ; // Graph structure options po::options_description opts_graph("Options for specifying graph structure"); opts_graph.add_options() ("type", po::value(&type), "factor graph type (one of 'FULL', 'DREG', 'LOOP', 'TREE', 'GRID', 'GRID3D', 'HOI', 'LDPC')") ("d", po::value(&d), "variable connectivity (only for type=='DREG');\n\t should be even") ("N", po::value(&N), "number of variables (not for type=='GRID','GRID3D')") ("n1", po::value(&n1), "width of grid (only for type=='GRID','GRID3D')") ("n2", po::value(&n2), "height of grid (only for type=='GRID','GRID3D')") ("n3", po::value(&n3), "length of grid (only for type=='GRID3D')") ("periodic", po::value(&periodic), "periodic grid? (only for type=='GRID','GRID3D'; default=0)") ("K", po::value(&K), "number of factors (only for type=='HOI','LDPC')") ("k", po::value(&k), "number of variables per factor (only for type=='HOI','LDPC')") ; // Factor options po::options_description opts_factors("Options for specifying factors"); opts_factors.add_options() ("factors", po::value(&ft), "factor type (one of 'EXPGAUSS','POTTS','ISINGGAUSS','ISINGUNIFORM')") ("beta", po::value(&beta), "inverse temperature (ignored for factors=='ISINGGAUSS','ISINGUNIFORM')") ("mean_w", po::value(&mean_w), "mean of pairwise interactions w_{ij} (only for factors=='ISINGGAUSS')") ("mean_th", po::value(&mean_th), "mean of unary interactions th_i (only for factors=='ISINGGAUSS')") ("sigma_w", po::value(&sigma_w), "stddev of pairwise interactions w_{ij} (only for factors=='ISINGGAUSS')") ("sigma_th", po::value(&sigma_th), "stddev of unary interactions th_i (only for factors=='ISINGGAUSS'") ("min_w", po::value(&min_w), "minimum of pairwise interactions w_{ij} (only for factors=='ISINGUNIFORM')") ("min_th", po::value(&min_th), "minimum of unary interactions th_i (only for factors=='ISINGUNIFORM')") ("max_w", po::value(&max_w), "maximum of pairwise interactions w_{ij} (only for factors=='ISINGUNIFORM')") ("max_th", po::value(&max_th), "maximum of unary interactions th_i (only for factors=='ISINGUNIFORM')") ; // LDPC options po::options_description opts_ldpc("Options for specifying LDPC code factor graphs"); opts_ldpc.add_options() ("ldpc", po::value(&ldpc), "type of LDPC code (one of 'SMALL','GROUP','RANDOM')") ("j", po::value(&j), "number of parity checks per bit (only for type=='LDPC')") ("noise", po::value(&noise), "bitflip probability for binary symmetric channel (only for type=='LDPC')") ("prime", po::value(&prime), "prime number for construction of LDPC code (only for type=='LDPC' with ldpc='GROUP'))") ; // All options opts.add(opts_graph).add(opts_factors).add(opts_ldpc); // Parse command line arguments po::variables_map vm; po::store(po::parse_command_line(argc, argv, opts), vm); po::notify(vm); // Display help message if necessary if( vm.count("help") || !vm.count("type") ) { cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "Usage: ./createfg [options]" << endl << endl; cout << "Creates a factor graph according to the specified options." << endl << endl; cout << endl << opts << endl; cout << "The following factor graph types with pairwise interactions can be created:" << endl; cout << "\t'FULL': fully connected graph of variables" << endl; cout << "\t'DREG': random regular graph of variables where each variable is connected with others" << endl; cout << "\t'LOOP': a single loop of variables" << endl; cout << "\t'TREE': random tree-structured (acyclic, connected) graph of variables" << endl; cout << "\t'GRID': 2D grid of x variables" << endl; cout << "\t'GRID3D': 3D grid of xx variables" << endl; cout << "The following higher-order interactions factor graphs can be created:" << endl; cout << "\t'HOI': random factor graph consisting of variables and factors," << endl; cout << "\t each factor being an interaction of variables." << endl; cout << "The following LDPC code factor graphs can be created:" << endl; cout << "\t'LDPC': simulates LDPC decoding problem, using an LDPC code of bits and " << endl; cout << "\t parity checks, with bits per check and checks per bit, transmitted" << endl; cout << "\t on a binary symmetric channel with probability of flipping a bit." << endl; cout << "\t The transmitted codeword has all bits set to zero. The argument 'ldpc'" << endl; cout << "\t determines how the LDPC code is constructed: either using a group structure," << endl; cout << "\t or randomly, or a fixed small code with (N,K,k,j) = (4,4,3,3)." << endl << endl; cout << "For all types except type=='LDPC', the factors have to be specified as well." << endl << endl; cout << "EXPGAUSS factors (the default) are created by drawing all log-factor entries" << endl; cout << "independently from a Gaussian with mean 0 and standard deviation ." << endl << endl; cout << "In case of pairwise interactions, one can also choose POTTS factors, for which" << endl; cout << "the log-factors are simply delta functions multiplied by the strength ." << endl << endl; cout << "For pairwise interactions and binary variables, one can also use ISINGGAUSS factors." << endl; cout << "Here variables x1...xN are assumed to be +1/-1--valued, and unary interactions" << endl; cout << "are of the form exp(th*xi) with th drawn from a Gaussian distribution with mean" << endl; cout << " and standard deviation , and pairwise interactions are of the" << endl; cout << "form exp(w*xi*xj) with w drawn from a Gaussian distribution with mean " << endl; cout << "and standard deviation ." << endl; cout << "Alternatively, one can use ISINGUNIFORM factors: here th is drawn from a uniform" << endl; cout << "distribution on [, ), and w is drawn from a uniform distribution" << endl; cout << "on [, )." << endl; return 1; } // Set default number of states if( !vm.count("states") ) states = 2; // Set default factor type if( !vm.count("factors") ) ft = FactorType::EXPGAUSS; // Check validness of factor type if( ft == FactorType::POTTS ) if( type == HOI_TYPE ) throw "For factors=='POTTS', interactions should be pairwise (type!='HOI')"; if( ft == FactorType::ISINGGAUSS ) if( ((states != 2) || (type == HOI_TYPE)) ) throw "For factors=='ISINGGAUSS', variables should be binary (states==2) and interactions should be pairwise (type!='HOI')"; if( ft == FactorType::ISINGUNIFORM ) if( ((states != 2) || (type == HOI_TYPE)) ) throw "For factors=='ISINGUNIFORM', variables should be binary (states==2) and interactions should be pairwise (type!='HOI')"; // Read random seed if( !vm.count("seed") ) { ifstream infile; bool success; infile.open( "/dev/urandom" ); success = infile.is_open(); if( success ) { infile.read( (char *)&seed, sizeof(size_t) / sizeof(char) ); success = infile.good(); infile.close(); } if( !success ) throw "Please specify random number seed."; } rnd_seed( seed ); // Set default periodicity if( !vm.count("periodic") ) periodic = false; // Store some options in a PropertySet object PropertySet options; if( vm.count("mean_th") ) options.set("mean_th", mean_th); if( vm.count("sigma_th") ) options.set("sigma_th", sigma_th); if( vm.count("mean_w") ) options.set("mean_w", mean_w); if( vm.count("sigma_w") ) options.set("sigma_w", sigma_w); if( vm.count("beta") ) options.set("beta", beta); if( vm.count("min_w") ) options.set("min_w", min_w); if( vm.count("min_th") ) options.set("min_th", min_th); if( vm.count("max_w") ) options.set("max_w", max_w); if( vm.count("max_th") ) options.set("max_th", max_th); // Output some comments cout << "# Factor graph made by " << argv[0] << endl; cout << "# type = " << type << endl; cout << "# states = " << states << endl; cout << "# factor type = " << ft << endl; // The factor graph to be constructed FactorGraph fg; #define NEED_ARG(name, desc) do { if(!vm.count(name)) throw "Please specify " desc " with --" name; } while(0); if( type == FULL_TYPE || type == DREG_TYPE || type == LOOP_TYPE || type == TREE_TYPE || type == GRID_TYPE || type == GRID3D_TYPE ) { // Pairwise interactions // Check command line options if( type == GRID_TYPE ) { NEED_ARG("n1", "width of grid"); NEED_ARG("n2", "height of grid"); N = n1 * n2; } else if( type == GRID3D_TYPE ) { NEED_ARG("n1", "width of grid"); NEED_ARG("n2", "height of grid"); NEED_ARG("n3", "depth of grid"); N = n1 * n2 * n3; } else NEED_ARG("N", "number of variables"); if( ft == FactorType::ISINGGAUSS ) { NEED_ARG("mean_w", "mean of pairwise interactions"); NEED_ARG("mean_th", "mean of unary interactions"); NEED_ARG("sigma_w", "stddev of pairwise interactions"); NEED_ARG("sigma_th", "stddev of unary interactions"); } else if( ft == FactorType::ISINGUNIFORM ) { NEED_ARG("min_w", "minimum of pairwise interactions"); NEED_ARG("min_th", "minimum of unary interactions"); NEED_ARG("max_w", "maximum of pairwise interactions"); NEED_ARG("max_th", "maximum of unary interactions"); } else NEED_ARG("beta", "stddev of log-factor entries"); if( type == DREG_TYPE ) NEED_ARG("d", "connectivity (number of neighboring variables of each variable)"); // Build pairwise interaction graph GraphAL G; if( type == FULL_TYPE ) G = createGraphFull( N ); else if( type == DREG_TYPE ) G = createGraphRegular( N, d ); else if( type == LOOP_TYPE ) G = createGraphLoop( N ); else if( type == TREE_TYPE ) G = createGraphTree( N ); else if( type == GRID_TYPE ) G = createGraphGrid( n1, n2, periodic ); else if( type == GRID3D_TYPE ) G = createGraphGrid3D( n1, n2, n3, periodic ); // Construct factor graph from pairwise interaction graph fg = createFG( G, ft, states, options ); // Output some additional comments if( type == GRID_TYPE || type == GRID3D_TYPE ) { cout << "# n1 = " << n1 << endl; cout << "# n2 = " << n2 << endl; if( type == GRID3D_TYPE ) cout << "# n3 = " << n3 << endl; } if( type == DREG_TYPE ) cout << "# d = " << d << endl; cout << "# options = " << options << endl; } else if( type == HOI_TYPE ) { // Higher order interactions // Check command line arguments NEED_ARG("N", "number of variables"); NEED_ARG("K", "number of factors"); NEED_ARG("k", "number of variables per factor"); NEED_ARG("beta", "stddev of log-factor entries"); // Create higher-order interactions factor graph do { fg = createHOIFG( N, K, k, beta ); } while( !fg.isConnected() ); // Output some additional comments cout << "# K = " << K << endl; cout << "# k = " << k << endl; cout << "# beta = " << beta << endl; } else if( type == LDPC_TYPE ) { // LDPC codes // Check command line arguments NEED_ARG("ldpc", "type of LDPC code"); NEED_ARG("noise", "bitflip probability for binary symmetric channel"); // Check more command line arguments (seperately for each LDPC type) if( ldpc == LDPCType::RANDOM ) { NEED_ARG("N", "number of variables"); NEED_ARG("K", "number of factors"); NEED_ARG("k", "number of variables per factor"); NEED_ARG("j", "number of parity checks per bit"); if( N * j != K * k ) throw "Parameters should satisfy N * j == K * k"; } else if( ldpc == LDPCType::GROUP ) { NEED_ARG("prime", "prime number"); NEED_ARG("k", "number of variables per factor"); NEED_ARG("j", "number of parity checks per bit"); if( !isPrime(prime) ) throw "Parameter should be prime"; if( !((prime-1) % j == 0 ) ) throw "Parameters should satisfy (prime-1) % j == 0"; if( !((prime-1) % k == 0 ) ) throw "Parameters should satisfy (prime-1) % k == 0"; N = prime * k; K = prime * j; } else if( ldpc == LDPCType::SMALL ) { N = 4; K = 4; j = 3; k = 3; } // Output some additional comments cout << "# N = " << N << endl; cout << "# K = " << K << endl; cout << "# j = " << j << endl; cout << "# k = " << k << endl; if( ldpc == LDPCType::GROUP ) cout << "# prime = " << prime << endl; cout << "# noise = " << noise << endl; // Construct likelihood and paritycheck factors Real likelihood[4] = {1.0 - noise, noise, noise, 1.0 - noise}; Real *paritycheck = new Real[1 << k]; createParityCheck(paritycheck, k, 0.0); // Create LDPC structure BipartiteGraph ldpcG; bool regular; do { if( ldpc == LDPCType::GROUP ) ldpcG = createGroupStructuredLDPCGraph( prime, j, k ); else if( ldpc == LDPCType::RANDOM ) ldpcG = createRandomBipartiteGraph( N, K, j, k ); else if( ldpc == LDPCType::SMALL ) ldpcG = createSmallLDPCGraph(); regular = true; for( size_t i = 0; i < N; i++ ) if( ldpcG.nb1(i).size() != j ) regular = false; for( size_t I = 0; I < K; I++ ) if( ldpcG.nb2(I).size() != k ) regular = false; } while( !regular && !ldpcG.isConnected() ); // Convert to FactorGraph vector factors; for( size_t I = 0; I < K; I++ ) { VarSet vs; for( size_t _i = 0; _i < k; _i++ ) { size_t i = ldpcG.nb2(I)[_i]; vs |= Var( i, 2 ); } factors.push_back( Factor( vs, paritycheck ) ); } delete paritycheck; // Generate noise vector vector noisebits(N,0); size_t bitflips = 0; for( size_t i = 0; i < N; i++ ) { if( rnd_uniform() < noise ) { noisebits[i] = 1; bitflips++; } } cout << "# bitflips = " << bitflips << endl; // Simulate transmission of all-zero codeword vector input(N,0); vector output(N,0); for( size_t i = 0; i < N; i++ ) output[i] = (input[i] + noisebits[i]) & 1; // Add likelihoods for( size_t i = 0; i < N; i++ ) factors.push_back( Factor(Var(i,2), likelihood + output[i]*2) ); // Construct Factor Graph fg = FactorGraph( factors ); } else throw "Invalid type"; // Output additional comments cout << "# N = " << fg.nrVars() << endl; cout << "# seed = " << seed << endl; // Output factor graph cout << fg; } catch( const char *e ) { /// Display error message cerr << "Error: " << e << endl; return 1; } return 0; } libDAI-0.2.7/utils/fginfo.cpp0000644000263000017630000002000311433220722014563 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include using namespace std; using namespace dai; void findLoopClusters( const FactorGraph & fg, std::set &allcl, VarSet newcl, const Var & root, size_t length, VarSet vars ) { for( VarSet::const_iterator in = vars.begin(); in != vars.end(); in++ ) { VarSet ind = fg.delta( *in ); if( (newcl.size()) >= 2 && ind.contains( root ) ) { allcl.insert( newcl | *in ); } else if( length > 1 ) findLoopClusters( fg, allcl, newcl | *in, root, length - 1, ind / newcl ); } } size_t countLoops( const FactorGraph & fg, size_t loopdepth ) { set loops; for( vector::const_iterator i0 = fg.vars().begin(); i0 != fg.vars().end(); i0++ ) { VarSet i0d = fg.delta(*i0); if( loopdepth > 1 ) findLoopClusters( fg, loops, *i0, *i0, loopdepth - 1, i0d ); } return loops.size(); } bool hasShortLoops( const std::vector &P ) { bool found = false; vector::const_iterator I, J; for( I = P.begin(); I != P.end(); I++ ) { J = I; J++; for( ; J != P.end(); J++ ) if( (I->vars() & J->vars()).size() >= 2 ) { found = true; break; } if( found ) break; } return found; } bool hasNegatives( const std::vector &P ) { bool found = false; for( size_t I = 0; I < P.size(); I++ ) if( P[I].hasNegatives() ) { found = true; break; } return found; } int main( int argc, char *argv[] ) { if( argc != 3 ) { // Display help message if number of command line arguments is incorrect cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "Usage: ./fginfo " << endl << endl; cout << "Reports some detailed information about the factor graph ." << endl; cout << "Also calculates treewidth, with maximum total number of states" << endl; cout << "given by , where 0 means unlimited." << endl << endl; return 1; } else { // Read factorgraph FactorGraph fg; char *infile = argv[1]; size_t maxstates = fromString( argv[2] ); fg.ReadFromFile( infile ); // Output various statistics cout << "Number of variables: " << fg.nrVars() << endl; cout << "Number of factors: " << fg.nrFactors() << endl; cout << "Connected: " << fg.isConnected() << endl; cout << "Tree: " << fg.isTree() << endl; cout << "Has short loops: " << hasShortLoops(fg.factors()) << endl; cout << "Has negatives: " << hasNegatives(fg.factors()) << endl; cout << "Binary variables? " << fg.isBinary() << endl; cout << "Pairwise interactions? " << fg.isPairwise() << endl; // Calculate treewidth using various heuristics std::pair tw; cout << "Treewidth (MinNeighbors): "; try { tw = boundTreewidth(fg, &eliminationCost_MinNeighbors, maxstates ); cout << tw.first << " (" << tw.second << " states)" << endl; } catch( Exception &e ) { if( e.code() == Exception::OUT_OF_MEMORY ) cout << "> " << maxstates << endl; else cout << "an exception occurred" << endl; } cout << "Treewidth (MinWeight): "; try { tw = boundTreewidth(fg, &eliminationCost_MinWeight, maxstates ); cout << tw.first << " (" << tw.second << " states)" << endl; } catch( Exception &e ) { if( e.code() == Exception::OUT_OF_MEMORY ) cout << "> " << maxstates << endl; else cout << "an exception occurred" << endl; } cout << "Treewidth (MinFill): "; try { tw = boundTreewidth(fg, &eliminationCost_MinFill, maxstates ); cout << tw.first << " (" << tw.second << " states)" << endl; } catch( Exception &e ) { if( e.code() == Exception::OUT_OF_MEMORY ) cout << "> " << maxstates << endl; else cout << "an exception occurred" << endl; } cout << "Treewidth (WeightedMinFill): "; try { tw = boundTreewidth(fg, &eliminationCost_WeightedMinFill, maxstates ); cout << tw.first << " (" << tw.second << " states)" << endl; } catch( Exception &e ) { if( e.code() == Exception::OUT_OF_MEMORY ) cout << "> " << maxstates << endl; else cout << "an exception occurred" << endl; } // Calculate total state space long double stsp = 1.0; for( size_t i = 0; i < fg.nrVars(); i++ ) stsp *= fg.var(i).states(); cout << "Total state space: " << stsp << endl; // Output type of factor graph cout << "Type: " << (fg.isPairwise() ? "pairwise" : "higher order") << " interactions, " << (fg.isBinary() ? "binary" : "nonbinary") << " variables" << endl; // Calculate complexity for LCBP long double cavsum_lcbp = 0.0; long double cavsum_lcbp2 = 0.0; long double max_Delta_size = 0.0; map cavsizes; for( size_t i = 0; i < fg.nrVars(); i++ ) { VarSet di = fg.delta(i); if( cavsizes.count(di.size()) ) cavsizes[di.size()]++; else cavsizes[di.size()] = 1; long double Ds = fg.Delta(i).nrStates(); if( Ds > max_Delta_size ) max_Delta_size = Ds; cavsum_lcbp += di.nrStates(); for( VarSet::const_iterator j = di.begin(); j != di.end(); j++ ) cavsum_lcbp2 += j->states(); } cout << "Maximum pancake has " << max_Delta_size << " states" << endl; cout << "LCBP with full cavities needs " << cavsum_lcbp << " BP runs" << endl; cout << "LCBP with only pairinteractions needs " << cavsum_lcbp2 << " BP runs" << endl; cout << "Cavity sizes: "; for( map::const_iterator it = cavsizes.begin(); it != cavsizes.end(); it++ ) cout << it->first << "(" << it->second << ") "; cout << endl; // Calculate girth and length of loops if( fg.isPairwise() ) { bool girth_reached = false; size_t loopdepth; for( loopdepth = 2; loopdepth <= fg.nrVars() && !girth_reached; loopdepth++ ) { size_t nr_loops = countLoops( fg, loopdepth ); cout << "Loops up to " << loopdepth << " variables: " << nr_loops << endl; if( nr_loops > 0 ) girth_reached = true; } if( girth_reached ) cout << "Girth: " << loopdepth-1 << endl; else cout << "Girth: infinity" << endl; } // Output factor state spaces map facsizes; for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t Isize = fg.factor(I).vars().size(); if( facsizes.count( Isize ) ) facsizes[Isize]++; else facsizes[Isize] = 1; } cout << "Factor sizes: "; for( map::const_iterator it = facsizes.begin(); it != facsizes.end(); it++ ) cout << it->first << "(" << it->second << ") "; cout << endl; return 0; } } libDAI-0.2.7/utils/viewfg0000755000263000017630000000005711433220722014033 0ustar jorismkyb#!/bin/bash ./fg2dot $1 - | neato -T ps | gv - libDAI-0.2.7/AUTHORS0000644000263000017630000000167511433220722012535 0ustar jorismkyblibDAI was written by Joris M. Mooij with the help of the following people: Martijn Leisink (laid down the foundations for the library), Frederik Eaton (contributed the Gibbs sampler, conditioned BP, fractional BP and various other improvements), Charles Vaske (contributed the parameter learning algorithms), Giuseppe Passino (contributed the findMaximum function, and various other improvements), Bastian Wemmenhove (contributed the MR algorithm), Patrick Pletscher (contributed the SWIG interface). Smaller contributions (bug fixes and miscellaneous smaller patches) have been made by: Claudio Lima, Christian Wojek, Sebastian Nowozin, Stefano Pellegrini, Ofer Meshi, Dan Preston, Peter Gober, Jiuxiang Hu, Peter Rockett, Dhruv Batra, Alexander Schwing, Alejandro Lage, Matt Dunham. Part of this work was part of the Interactive Collaborative Information Systems (ICIS) project, supported by the Dutch Ministry of Economic Affairs, grant BSIK03024. libDAI-0.2.7/Makefile.CYGWIN0000644000263000017630000000454111433220722014117 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This template contains configurations for compiling libDAI under Cygwin # # It has been tested with Windows XP, Cygwin 1.7.4 and Boost 1.42.0 # # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf' # to your local setup # OPERATING SYSTEM # Choose OS from {LINUX, WINDOWS, CYGWIN, MACOSX} OS=CYGWIN # FILE EXTENSIONS # Static library LE=.a # Object file OE=.o # Binary executable EE= # MatLab compiled MEX file ME=.mexglx # COMPILER # Compile using GNU C++ Compiler CC=g++ # Output filename option of the compiler CCO=-o # Flags for the C++ compiler CCFLAGS=-Wno-deprecated -Wall -W -Wextra -DCYGWIN # Flags to add in debugging mode (if DEBUG=true) CCDEBUGFLAGS=-O3 -g -DDAI_DEBUG # Flags to add in non-debugging mode (if DEBUG=false) CCNODEBUGFLAGS=-O3 # Standard include directories CCINC=-Iinclude -I/cygdrive/e/cygwin/boost_1_42_0 # LINKER # Standard libraries to include LIBS=-ldai # For linking with BOOST libraries BOOSTLIBS_PO=-lboost_program_options BOOSTLIBS_UTF=-lboost_unit_test_framework # Additional library search paths for linker CCLIB=-Llib -L/cygdrive/e/cygwin/boost_1_42_0/stage/lib # MATLAB # MatLab version 7.3 (R2006b) or newer? NEW_MATLAB=true # Replace the following by the directory where MatLab has been installed MATLABDIR=/agbs/share/sw/matlab # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)/bin/mex # Specify the same C++ compiler and flags to mex MEXFLAGS:=CXX\#$(CC) CXXFLAGS\#'$(CCFLAGS)' # Standard include directories for MEX MEXINC:=$(CCINC) # Additional library search paths for MEX MEXLIB= # SWIG PYTHON INTERFACE # The following should resolve to the SWIG command SWIG=swig # Location of Python header files INCLUDE_PYTHON=/usr/include/python2.5 # Location of Boost C++ library header files INCLUDE_BOOST=/cygdrive/e/cygwin/boost_1_42_0 # CIMG # CImg version 1.3.0 or newer? NEW_CIMG=true # Include directory for image segmentation example CIMGINC=-I/cygdrive/e/cygwin/CImg-1.3.9 # Libraries for image segmentation example CIMGLIBS=-lpthread -lX11 libDAI-0.2.7/Makefile0000644000263000017630000002626011433220722013122 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] # Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands # Load the platform independent build configuration file include Makefile.ALL # Load the local configuration from Makefile.conf include Makefile.conf # Set version and date DAI_VERSION="0.2.7" DAI_DATE="August 19, 2010" # Directories of libDAI sources # Location of libDAI headers INC=include/dai # Location of libDAI source files SRC=src # Destination directory of libDAI library LIB=lib # Set final compiler flags ifdef DEBUG CCFLAGS:=$(CCFLAGS) $(CCDEBUGFLAGS) else CCFLAGS:=$(CCFLAGS) $(CCNODEBUGFLAGS) endif # Define build targets TARGETS:=lib tests utils examples ifdef WITH_MATLAB TARGETS:=$(TARGETS) matlabs endif TARGETS:=$(TARGETS) unittests testregression testem ifdef WITH_DOC TARGETS:=$(TARGETS) doc endif # Define conditional build targets NAMES:=graph dag bipgraph varset daialg alldai clustergraph factor factorgraph properties regiongraph util weightedgraph exceptions exactinf evidence emalg io ifdef WITH_BP WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_BP NAMES:=$(NAMES) bp endif ifdef WITH_FBP WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_FBP NAMES:=$(NAMES) fbp endif ifdef WITH_TRWBP WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_TRWBP NAMES:=$(NAMES) trwbp endif ifdef WITH_MF WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_MF NAMES:=$(NAMES) mf endif ifdef WITH_HAK WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_HAK NAMES:=$(NAMES) hak endif ifdef WITH_LC WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_LC NAMES:=$(NAMES) lc endif ifdef WITH_TREEEP WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_TREEEP NAMES:=$(NAMES) treeep endif ifdef WITH_JTREE WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_JTREE NAMES:=$(NAMES) jtree endif ifdef WITH_MR WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_MR NAMES:=$(NAMES) mr endif ifdef WITH_GIBBS WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_GIBBS NAMES:=$(NAMES) gibbs endif ifdef WITH_CBP WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_CBP NAMES:=$(NAMES) bbp cbp bp_dual endif ifdef WITH_DECMAP WITHFLAGS:=$(WITHFLAGS) -DDAI_WITH_DECMAP NAMES:=$(NAMES) decmap endif # Define standard libDAI header dependencies, source file names and object file names HEADERS=$(foreach name,graph dag bipgraph index var factor varset smallset prob daialg properties alldai enum exceptions util,$(INC)/$(name).h) SOURCES:=$(foreach name,$(NAMES),$(SRC)/$(name).cpp) OBJECTS:=$(foreach name,$(NAMES),$(name)$(OE)) # Setup final command for C++ compiler ifneq ($(OS),WINDOWS) CC:=$(CC) $(CCINC) $(CCFLAGS) $(WITHFLAGS) $(CCLIB) else CC:=$(CC) $(CCINC) $(CCFLAGS) $(WITHFLAGS) LIBS:=$(LIBS) $(CCLIB) endif # Setup final command for MEX ifdef NEW_MATLAB MEXFLAGS:=$(MEXFLAGS) -largeArrayDims else MEXFLAGS:=$(MEXFLAGS) -DSMALLMEM endif MEX:=$(MEX) $(MEXINC) $(MEXFLAGS) $(WITHFLAGS) $(MEXLIB) # META TARGETS ############### all : $(TARGETS) @echo @echo libDAI built successfully! EXAMPLES=$(foreach name,example example_bipgraph example_varset example_permute example_sprinkler example_sprinkler_em,examples/$(name)$(EE)) ifdef WITH_GIBBS EXAMPLES:=$(EXAMPLES) examples/example_sprinkler_gibbs$(EE) endif ifdef WITH_CIMG EXAMPLES:=$(EXAMPLES) examples/example_imagesegmentation$(EE) endif examples : $(EXAMPLES) matlabs : matlab/dai$(ME) matlab/dai_readfg$(ME) matlab/dai_writefg$(ME) matlab/dai_potstrength$(ME) unittests : tests/unit/var_test$(EE) tests/unit/smallset_test$(EE) tests/unit/varset_test$(EE) tests/unit/graph_test$(EE) tests/unit/dag_test$(EE) tests/unit/bipgraph_test$(EE) tests/unit/weightedgraph_test$(EE) tests/unit/enum_test$(EE) tests/unit/enum_test$(EE) tests/unit/util_test$(EE) tests/unit/exceptions_test$(EE) tests/unit/properties_test$(EE) tests/unit/index_test$(EE) tests/unit/prob_test$(EE) tests/unit/factor_test$(EE) tests/unit/factorgraph_test$(EE) tests/unit/clustergraph_test$(EE) tests/unit/regiongraph_test$(EE) tests/unit/daialg_test$(EE) tests/unit/alldai_test$(EE) @echo 'Running unit tests...(note: output containing "EXCEPTION" does not indicate an error)' @echo tests/unit/var_test$(EE) tests/unit/smallset_test$(EE) tests/unit/varset_test$(EE) tests/unit/graph_test$(EE) tests/unit/dag_test$(EE) tests/unit/bipgraph_test$(EE) tests/unit/weightedgraph_test$(EE) tests/unit/enum_test$(EE) tests/unit/util_test$(EE) tests/unit/exceptions_test$(EE) tests/unit/properties_test$(EE) tests/unit/index_test$(EE) tests/unit/prob_test$(EE) tests/unit/factor_test$(EE) tests/unit/factorgraph_test$(EE) tests/unit/clustergraph_test$(EE) tests/unit/regiongraph_test$(EE) tests/unit/daialg_test$(EE) tests/unit/alldai_test$(EE) @echo @echo 'All unit tests completed successfully!' @echo tests : tests/testdai$(EE) tests/testem/testem$(EE) tests/testbbp$(EE) $(unittests) utils : utils/createfg$(EE) utils/fg2dot$(EE) utils/fginfo$(EE) utils/uai2fg$(EE) lib: $(LIB)/libdai$(LE) # OBJECTS ########## %$(OE) : $(SRC)/%.cpp $(INC)/%.h $(HEADERS) $(CC) -c $< bbp$(OE) : $(SRC)/bbp.cpp $(INC)/bbp.h $(INC)/bp_dual.h $(HEADERS) $(CC) -c $< cbp$(OE) : $(SRC)/cbp.cpp $(INC)/cbp.h $(INC)/bbp.h $(INC)/bp_dual.h $(HEADERS) $(CC) -c $< hak$(OE) : $(SRC)/hak.cpp $(INC)/hak.h $(HEADERS) $(INC)/regiongraph.h $(CC) -c $< jtree$(OE) : $(SRC)/jtree.cpp $(INC)/jtree.h $(HEADERS) $(INC)/weightedgraph.h $(INC)/clustergraph.h $(INC)/regiongraph.h $(CC) -c $< treeep$(OE) : $(SRC)/treeep.cpp $(INC)/treeep.h $(HEADERS) $(INC)/weightedgraph.h $(INC)/clustergraph.h $(INC)/regiongraph.h $(INC)/jtree.h $(CC) -c $< emalg$(OE) : $(SRC)/emalg.cpp $(INC)/emalg.h $(INC)/evidence.h $(HEADERS) $(CC) -c $< decmap$(OE) : $(SRC)/decmap.cpp $(INC)/decmap.h $(HEADERS) $(CC) -c $< # EXAMPLES ########### examples/%$(EE) : examples/%.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)$@ $< $(LIBS) examples/example_sprinkler_gibbs$(EE) : examples/example_sprinkler_gibbs.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)$@ $< $(LIBS) examples/example_imagesegmentation$(EE) : examples/example_imagesegmentation.cpp $(HEADERS) $(LIB)/libdai$(LE) ifdef NEW_CIMG $(CC) -DNEW_CIMG $(CIMGINC) $(CCO)$@ $< $(LIBS) $(CIMGLIBS) else $(CC) $(CIMGINC) $(CCO)$@ $< $(LIBS) $(CIMGLIBS) endif # UNIT TESTS ############# tests/unit/%$(EE) : tests/unit/%.cpp $(HEADERS) $(LIB)/libdai$(LE) ifneq ($(OS),WINDOWS) $(CC) -DBOOST_TEST_DYN_LINK $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_UTF) else $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_UTF) /SUBSYSTEM:CONSOLE endif # TESTS ######## tests/testdai$(EE) : tests/testdai.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_PO) tests/testem/testem$(EE) : tests/testem/testem.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_PO) tests/testbbp$(EE) : tests/testbbp.cpp $(HEADERS) $(LIB)/libdai$(LE) ifdef WITH_CBP $(CC) $(CCO)$@ $< $(LIBS) else @echo Skipping $@ endif # MATLAB INTERFACE ################### matlab/dai$(ME) : $(SRC)/matlab/dai.cpp $(HEADERS) $(SOURCES) $(SRC)/matlab/matlab.cpp $(MEX) -output $@ $< $(SRC)/matlab/matlab.cpp $(SOURCES) matlab/dai_readfg$(ME) : $(SRC)/matlab/dai_readfg.cpp $(HEADERS) $(SRC)/matlab/matlab.cpp $(SRC)/factorgraph.cpp $(SRC)/exceptions.cpp $(SRC)/bipgraph.cpp $(SRC)/graph.cpp $(SRC)/factor.cpp $(SRC)/util.cpp $(MEX) -output $@ $< $(SRC)/matlab/matlab.cpp $(SRC)/factorgraph.cpp $(SRC)/exceptions.cpp $(SRC)/bipgraph.cpp $(SRC)/graph.cpp $(SRC)/factor.cpp $(SRC)/util.cpp matlab/dai_writefg$(ME) : $(SRC)/matlab/dai_writefg.cpp $(HEADERS) $(SRC)/matlab/matlab.cpp $(SRC)/factorgraph.cpp $(SRC)/exceptions.cpp $(SRC)/bipgraph.cpp $(SRC)/graph.cpp $(SRC)/factor.cpp $(SRC)/util.cpp $(MEX) -output $@ $< $(SRC)/matlab/matlab.cpp $(SRC)/factorgraph.cpp $(SRC)/exceptions.cpp $(SRC)/bipgraph.cpp $(SRC)/graph.cpp $(SRC)/factor.cpp $(SRC)/util.cpp matlab/dai_potstrength$(ME) : $(SRC)/matlab/dai_potstrength.cpp $(HEADERS) $(SRC)/matlab/matlab.cpp $(SRC)/exceptions.cpp $(MEX) -output $@ $< $(SRC)/matlab/matlab.cpp $(SRC)/exceptions.cpp # UTILS ######## utils/createfg$(EE) : utils/createfg.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)$@ $< $(LIBS) $(BOOSTLIBS_PO) utils/fg2dot$(EE) : utils/fg2dot.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)$@ $< $(LIBS) utils/fginfo$(EE) : utils/fginfo.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)$@ $< $(LIBS) utils/uai2fg$(EE) : utils/uai2fg.cpp $(HEADERS) $(LIB)/libdai$(LE) $(CC) $(CCO)$@ $< $(LIBS) # LIBRARY ########## ifneq ($(OS),WINDOWS) $(LIB)/libdai$(LE) : $(OBJECTS) -mkdir -p lib ar rcus $(LIB)/libdai$(LE) $(OBJECTS) else $(LIB)/libdai$(LE) : $(OBJECTS) -mkdir lib lib /out:$(LIB)/libdai$(LE) $(OBJECTS) endif # REGRESSION TESTS ################### testregression : tests/testdai$(EE) @echo Starting regression test...this can take a minute or so! ifneq ($(OS),WINDOWS) cd tests && ./testregression && cd .. else cd tests && testregression.bat && cd .. endif testem : tests/testem/testem$(EE) @echo Starting EM tests ifneq ($(OS),WINDOWS) cd tests/testem && ./runtests && cd ../.. else cd tests\testem && runtests && cd ..\.. endif # DOCUMENTATION ################ doc : $(INC)/*.h $(SRC)/*.cpp examples/*.cpp doxygen.conf doxygen doxygen.conf README : doc scripts/makeREADME DAI_VERSION=$(DAI_VERSION) DAI_DATE=$(DAI_DATE) scripts/makeREADME TAGS : etags src/*.cpp include/dai/*.h tests/*.cpp utils/*.cpp ctags src/*.cpp include/dai/*.h tests/*.cpp utils/*.cpp # CLEAN ######## .PHONY : clean ifneq ($(OS),WINDOWS) clean : -rm $(OBJECTS) -rm matlab/*$(ME) -rm examples/example$(EE) examples/example_bipgraph$(EE) examples/example_varset$(EE) examples/example_permute$(EE) examples/example_sprinkler$(EE) examples/example_sprinkler_gibbs$(EE) examples/example_sprinkler_em$(EE) examples/example_imagesegmentation$(EE) -rm tests/testdai$(EE) tests/testem/testem$(EE) tests/testbbp$(EE) -rm tests/unit/var_test$(EE) tests/unit/smallset_test$(EE) tests/unit/varset_test$(EE) tests/unit/graph_test$(EE) tests/unit/dag_test$(EE) tests/unit/bipgraph_test$(EE) tests/unit/weightedgraph_test$(EE) tests/unit/enum_test$(EE) tests/unit/util_test$(EE) tests/unit/exceptions_test$(EE) tests/unit/properties_test$(EE) tests/unit/index_test$(EE) tests/unit/prob_test$(EE) tests/unit/factor_test$(EE) tests/unit/factorgraph_test$(EE) tests/unit/clustergraph_test$(EE) tests/unit/regiongraph_test$(EE) tests/unit/daialg_test$(EE) tests/unit/alldai_test$(EE) -rm factorgraph_test.fg alldai_test.aliases -rm utils/fg2dot$(EE) utils/createfg$(EE) utils/fginfo$(EE) utils/uai2fg$(EE) -rm -R doc -rm -R lib else clean : -del *.obj -del *.ilk -del *.pdb -del matlab\*$(ME) -del examples\*$(EE) -del examples\*$(EE).manifest -del examples\*.ilk -del examples\*.pdb -del tests\*$(EE) -del tests\*$(EE).manifest -del tests\*.pdb -del tests\*.ilk -del tests\testem\*$(EE) -del tests\testem\*$(EE).manifest -del tests\testem\*.pdb -del tests\testem\*.ilk -del utils\*$(EE) -del utils\*$(EE).manifest -del utils\*.pdb -del utils\*.ilk -del tests\unit\*_test$(EE) -del tests\unit\*_test$(EE).manifest -del tests\unit\*_test.pdb -del tests\unit\*_test.ilk -del factorgraph_test.fg -del alldai_test.aliases -del $(LIB)\libdai$(LE) -rmdir lib endif libDAI-0.2.7/Makefile.LINUX0000644000263000017630000000447611433220722014025 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # It has been tested with Ubuntu 8.04, Ubuntu 9.04 and Debian testing # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This template contains configurations for compiling libDAI under GNU/Linux # and other UNIX variants # # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf' # to your local setup # OPERATING SYSTEM # Choose OS from {LINUX, WINDOWS, CYGWIN, MACOSX} OS=LINUX # FILE EXTENSIONS # Static library LE=.a # Object file OE=.o # Binary executable EE= # MatLab compiled MEX file ME=.mexglx # COMPILER # Compile using GNU C++ Compiler CC=g++ # Output filename option of the compiler CCO=-o # Flags for the C++ compiler CCFLAGS=-Wno-deprecated -Wall -W -Wextra -fpic # Flags to add in debugging mode (if DEBUG=true) CCDEBUGFLAGS=-O3 -g -DDAI_DEBUG # Flags to add in non-debugging mode (if DEBUG=false) CCNODEBUGFLAGS=-O3 # Standard include directories CCINC=-Iinclude # LINKER # Standard libraries to include LIBS=-ldai # For linking with BOOST libraries BOOSTLIBS_PO=-lboost_program_options-mt BOOSTLIBS_UTF=-lboost_unit_test_framework-mt # Additional library search paths for linker CCLIB=-Llib # MATLAB # MatLab version 7.3 (R2006b) or newer? NEW_MATLAB=true # Replace the following by the directory where MatLab has been installed MATLABDIR=/agbs/share/sw/matlab # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)/bin/mex # Specify the C++ compiler and flags for MEX # (MatLab R2008b only works with older versions of g++) MEXFLAGS:=CXX\#g++-4.1 CXXFLAGS\#'$(CCFLAGS)' # Standard include directories for MEX MEXINC:=$(CCINC) # Additional library search paths for MEX MEXLIB= # SWIG PYTHON INTERFACE # The following should resolve to the SWIG command SWIG=swig # Location of Python header files INCLUDE_PYTHON=/usr/include/python2.5 # Location of Boost C++ library header files INCLUDE_BOOST=/usr/include/boost # CIMG # CImg version 1.3.0 or newer? NEW_CIMG=true # Include directory for image segmentation example CIMGINC= # Libraries for image segmentation example CIMGLIBS=-lpthread -lX11 libDAI-0.2.7/DISCLAIMER0000644000263000017630000000145411433221307013017 0ustar jorismkybTHIS SOURCE CODE IS SUPPLIED "AS IS" WITHOUT WARRANTY OF ANY KIND, AND ITS AUTHOR AND THE JOURNAL OF MACHINE LEARNING RESEARCH (JMLR) AND JMLR'S PUBLISHERS AND DISTRIBUTORS, DISCLAIM ANY AND ALL WARRANTIES, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, AND ANY WARRANTIES OR NON INFRINGEMENT. THE USER ASSUMES ALL LIABILITY AND RESPONSIBILITY FOR USE OF THIS SOURCE CODE, AND NEITHER THE AUTHOR NOR JMLR, NOR JMLR'S PUBLISHERS AND DISTRIBUTORS, WILL BE LIABLE FOR DAMAGES OF ANY KIND RESULTING FROM ITS USE. Without limiting the generality of the foregoing, neither the author, nor JMLR, nor JMLR's poublishers and distributors, warrant that the Source Code will be error-free, will operate without interruption, or will meet the needs of the user. libDAI-0.2.7/src/0000755000263000017630000000000011433220723012244 5ustar jorismkyblibDAI-0.2.7/src/evidence.cpp0000644000263000017630000000565611433220722014545 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California, Santa Cruz */ #include #include #include #include #include #include namespace dai { void Evidence::addEvidenceTabFile( std::istream &is, FactorGraph &fg ) { std::map varMap; for( std::vector::const_iterator v = fg.vars().begin(); v != fg.vars().end(); ++v ) { std::stringstream s; s << v->label(); varMap[s.str()] = *v; } addEvidenceTabFile( is, varMap ); } void Evidence::addEvidenceTabFile( std::istream &is, std::map &varMap ) { std::string line; getline( is, line ); size_t line_number = 0; // Parse header std::vector header_fields; header_fields = tokenizeString( line, true ); std::vector::const_iterator p_field = header_fields.begin(); if( p_field == header_fields.end() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Empty header line"); std::vector vars; for( ; p_field != header_fields.end(); ++p_field ) { std::map::iterator elem = varMap.find( *p_field ); if( elem == varMap.end() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Variable " + *p_field + " not known"); vars.push_back( elem->second ); } getline(is,line); if( is.fail() || line.size() > 0 ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Expecting empty line"); // Read samples while( getline(is, line) ) { line_number++; std::vector fields; fields = tokenizeString( line, true ); if( fields.size() != vars.size() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Invalid number of fields in line " + boost::lexical_cast(line_number)); Observation sample; for( size_t i = 0; i < vars.size(); ++i ) { if( fields[i].size() > 0 ) { // skip if missing observation if( fields[i].find_first_not_of("0123456789") != std::string::npos ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Invalid state " + fields[i] + " in line " + boost::lexical_cast(line_number)); size_t state = fromString( fields[i].c_str() ); if( state >= vars[i].states() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"State " + fields[i] + " too large in line " + boost::lexical_cast(line_number)); sample[vars[i]] = state; } } _samples.push_back( sample ); } // finished sample line } } // end of namespace dai libDAI-0.2.7/src/exactinf.cpp0000644000263000017630000000704511433220722014556 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include namespace dai { using namespace std; const char *ExactInf::Name = "EXACT"; void ExactInf::setProperties( const PropertySet &opts ) { if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; } PropertySet ExactInf::getProperties() const { PropertySet opts; opts.set( "verbose", props.verbose ); return opts; } string ExactInf::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "verbose=" << props.verbose << "]"; return s.str(); } void ExactInf::construct() { // clear variable beliefs and reserve space _beliefsV.clear(); _beliefsV.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) _beliefsV.push_back( Factor( var(i) ) ); // clear factor beliefs and reserve space _beliefsF.clear(); _beliefsF.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) _beliefsF.push_back( Factor( factor(I).vars() ) ); } void ExactInf::init() { for( size_t i = 0; i < nrVars(); i++ ) _beliefsV[i].fill( 1.0 ); for( size_t I = 0; I < nrFactors(); I++ ) _beliefsF[I].fill( 1.0 ); } Real ExactInf::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; Factor P; for( size_t I = 0; I < nrFactors(); I++ ) P *= factor(I); Real Z = P.sum(); _logZ = std::log(Z); for( size_t i = 0; i < nrVars(); i++ ) _beliefsV[i] = P.marginal(var(i)); for( size_t I = 0; I < nrFactors(); I++ ) _beliefsF[I] = P.marginal(factor(I).vars()); if( props.verbose >= 1 ) cerr << "finished" << endl; return 0.0; } Factor ExactInf::calcMarginal( const VarSet &vs ) const { Factor P; for( size_t I = 0; I < nrFactors(); I++ ) P *= factor(I); return P.marginal( vs, true ); } std::vector ExactInf::findMaximum() const { Factor P; for( size_t I = 0; I < nrFactors(); I++ ) P *= factor(I); size_t linearState = P.p().argmax().first; // convert to state map state = calcState( P.vars(), linearState ); // convert to desired output data structure vector mapState; mapState.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) mapState.push_back( state[var(i)] ); return mapState; } vector ExactInf::beliefs() const { vector result = _beliefsV; result.insert( result.end(), _beliefsF.begin(), _beliefsF.end() ); return result; } Factor ExactInf::belief( const VarSet &ns ) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) { return beliefV( findVar( *(ns.begin()) ) ); } else { size_t I; for( I = 0; I < nrFactors(); I++ ) if( factor(I).vars() >> ns ) break; if( I == nrFactors() ) DAI_THROW(BELIEF_NOT_AVAILABLE); return beliefF(I).marginal(ns); } } string ExactInf::identify() const { return string(Name) + printProperties(); } } // end of namespace dai libDAI-0.2.7/src/lc.cpp0000644000263000017630000002536211433220722013355 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include namespace dai { using namespace std; const char *LC::Name = "LC"; void LC::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("maxiter") ); DAI_ASSERT( opts.hasKey("cavity") ); DAI_ASSERT( opts.hasKey("updates") ); props.tol = opts.getStringAs("tol"); props.maxiter = opts.getStringAs("maxiter"); props.cavity = opts.getStringAs("cavity"); props.updates = opts.getStringAs("updates"); if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; if( opts.hasKey("cavainame") ) props.cavainame = opts.getStringAs("cavainame"); if( opts.hasKey("cavaiopts") ) props.cavaiopts = opts.getStringAs("cavaiopts"); if( opts.hasKey("reinit") ) props.reinit = opts.getStringAs("reinit"); if( opts.hasKey("damping") ) props.damping = opts.getStringAs("damping"); else props.damping = 0.0; } PropertySet LC::getProperties() const { PropertySet opts; opts.set( "tol", props.tol ); opts.set( "maxiter", props.maxiter ); opts.set( "verbose", props.verbose ); opts.set( "cavity", props.cavity ); opts.set( "updates", props.updates ); opts.set( "cavainame", props.cavainame ); opts.set( "cavaiopts", props.cavaiopts ); opts.set( "reinit", props.reinit ); opts.set( "damping", props.damping ); return opts; } string LC::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "verbose=" << props.verbose << ","; s << "cavity=" << props.cavity << ","; s << "updates=" << props.updates << ","; s << "cavainame=" << props.cavainame << ","; s << "cavaiopts=" << props.cavaiopts << ","; s << "reinit=" << props.reinit << ","; s << "damping=" << props.damping << "]"; return s.str(); } LC::LC( const FactorGraph & fg, const PropertySet &opts ) : DAIAlgFG(fg), _pancakes(), _cavitydists(), _phis(), _beliefs(), _maxdiff(0.0), _iters(0), props() { setProperties( opts ); // create pancakes _pancakes.resize( nrVars() ); // create cavitydists for( size_t i=0; i < nrVars(); i++ ) _cavitydists.push_back(Factor( delta(i) )); // create phis _phis.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) { _phis.push_back( vector() ); _phis[i].reserve( nbV(i).size() ); foreach( const Neighbor &I, nbV(i) ) _phis[i].push_back( Factor( factor(I).vars() / var(i) ) ); } // create beliefs _beliefs.reserve( nrVars() ); for( size_t i=0; i < nrVars(); i++ ) _beliefs.push_back(Factor(var(i))); } string LC::identify() const { return string(Name) + printProperties(); } void LC::CalcBelief (size_t i) { _beliefs[i] = _pancakes[i].marginal(var(i)); } Factor LC::belief (const VarSet &ns) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) return beliefV( findVar( *(ns.begin()) ) ); else { DAI_THROW(BELIEF_NOT_AVAILABLE); return Factor(); } } Real LC::CalcCavityDist (size_t i, const std::string &name, const PropertySet &opts) { Factor Bi; Real maxdiff = 0; if( props.verbose >= 2 ) cerr << "Initing cavity " << var(i) << "(" << delta(i).size() << " vars, " << delta(i).nrStates() << " states)" << endl; if( props.cavity == Properties::CavityType::UNIFORM ) Bi = Factor(delta(i)); else { InfAlg *cav = newInfAlg( name, *this, opts ); cav->makeCavity( i ); if( props.cavity == Properties::CavityType::FULL ) Bi = calcMarginal( *cav, cav->fg().delta(i), props.reinit ); else if( props.cavity == Properties::CavityType::PAIR ) { vector pairbeliefs = calcPairBeliefs( *cav, cav->fg().delta(i), props.reinit, false ); for( size_t ij = 0; ij < pairbeliefs.size(); ij++ ) Bi *= pairbeliefs[ij]; } else if( props.cavity == Properties::CavityType::PAIR2 ) { vector pairbeliefs = calcPairBeliefs( *cav, cav->fg().delta(i), props.reinit, true ); for( size_t ij = 0; ij < pairbeliefs.size(); ij++ ) Bi *= pairbeliefs[ij]; } maxdiff = cav->maxDiff(); delete cav; } Bi.normalize(); _cavitydists[i] = Bi; return maxdiff; } Real LC::InitCavityDists( const std::string &name, const PropertySet &opts ) { double tic = toc(); if( props.verbose >= 1 ) { cerr << Name << "::InitCavityDists: "; if( props.cavity == Properties::CavityType::UNIFORM ) cerr << "Using uniform initial cavity distributions" << endl; else if( props.cavity == Properties::CavityType::FULL ) cerr << "Using full " << name << opts << "..."; else if( props.cavity == Properties::CavityType::PAIR ) cerr << "Using pairwise " << name << opts << "..."; else if( props.cavity == Properties::CavityType::PAIR2 ) cerr << "Using pairwise(new) " << name << opts << "..."; } Real maxdiff = 0.0; for( size_t i = 0; i < nrVars(); i++ ) { Real md = CalcCavityDist(i, name, opts); if( md > maxdiff ) maxdiff = md; } if( props.verbose >= 1 ) { cerr << Name << "::InitCavityDists used " << toc() - tic << " seconds." << endl; } return maxdiff; } long LC::SetCavityDists( std::vector &Q ) { if( props.verbose >= 1 ) cerr << Name << "::SetCavityDists: Setting initial cavity distributions" << endl; if( Q.size() != nrVars() ) return -1; for( size_t i = 0; i < nrVars(); i++ ) { if( _cavitydists[i].vars() != Q[i].vars() ) { return i+1; } else _cavitydists[i] = Q[i]; } return 0; } void LC::init() { for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) if( props.updates == Properties::UpdateType::SEQRND ) _phis[i][I.iter].randomize(); else _phis[i][I.iter].fill(1.0); } Factor LC::NewPancake (size_t i, size_t _I, bool & hasNaNs) { size_t I = nbV(i)[_I]; Factor piet = _pancakes[i]; // recalculate _pancake[i] VarSet Ivars = factor(I).vars(); Factor A_I; for( VarSet::const_iterator k = Ivars.begin(); k != Ivars.end(); k++ ) if( var(i) != *k ) A_I *= (_pancakes[findVar(*k)] * factor(I).inverse()).marginal( Ivars / var(i), false ); if( Ivars.size() > 1 ) A_I ^= (1.0 / (Ivars.size() - 1)); Factor A_Ii = (_pancakes[i] * factor(I).inverse() * _phis[i][_I].inverse()).marginal( Ivars / var(i), false ); Factor quot = A_I / A_Ii; if( props.damping != 0.0 ) quot = (quot^(1.0 - props.damping)) * (_phis[i][_I]^props.damping); piet *= quot / _phis[i][_I].normalized(); _phis[i][_I] = quot.normalized(); piet.normalize(); if( piet.hasNaNs() ) { cerr << Name << "::NewPancake(" << i << ", " << _I << "): has NaNs!" << endl; hasNaNs = true; } return piet; } Real LC::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 2 ) cerr << endl; double tic = toc(); Real md = InitCavityDists( props.cavainame, props.cavaiopts ); if( md > _maxdiff ) _maxdiff = md; for( size_t i = 0; i < nrVars(); i++ ) { _pancakes[i] = _cavitydists[i]; foreach( const Neighbor &I, nbV(i) ) { _pancakes[i] *= factor(I); if( props.updates == Properties::UpdateType::SEQRND ) _pancakes[i] *= _phis[i][I.iter]; } _pancakes[i].normalize(); CalcBelief(i); } vector oldBeliefsV; for( size_t i = 0; i < nrVars(); i++ ) oldBeliefsV.push_back( beliefV(i) ); bool hasNaNs = false; for( size_t i=0; i < nrVars(); i++ ) if( _pancakes[i].hasNaNs() ) { hasNaNs = true; break; } if( hasNaNs ) { cerr << Name << "::run: initial _pancakes has NaNs!" << endl; return 1.0; } size_t nredges = nrEdges(); vector update_seq; update_seq.reserve( nredges ); for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) update_seq.push_back( Edge( i, I.iter ) ); // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance Real maxDiff = INFINITY; for( _iters = 0; _iters < props.maxiter && maxDiff > props.tol; _iters++ ) { // Sequential updates if( props.updates == Properties::UpdateType::SEQRND ) random_shuffle( update_seq.begin(), update_seq.end() ); for( size_t t=0; t < nredges; t++ ) { size_t i = update_seq[t].first; size_t _I = update_seq[t].second; _pancakes[i] = NewPancake( i, _I, hasNaNs); if( hasNaNs ) return 1.0; CalcBelief( i ); } // compare new beliefs with old ones maxDiff = -INFINITY; for( size_t i = 0; i < nrVars(); i++ ) { maxDiff = std::max( maxDiff, dist( beliefV(i), oldBeliefsV[i], DISTLINF ) ); oldBeliefsV[i] = beliefV(i); } if( props.verbose >= 3 ) cerr << Name << "::run: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::run: WARNING: not converged within " << props.maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 2 ) cerr << Name << "::run: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } } // end of namespace dai libDAI-0.2.7/src/mf.cpp0000644000263000017630000001457111433220722013361 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include namespace dai { using namespace std; const char *MF::Name = "MF"; void MF::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("maxiter") ); props.tol = opts.getStringAs("tol"); props.maxiter = opts.getStringAs("maxiter"); if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0U; if( opts.hasKey("damping") ) props.damping = opts.getStringAs("damping"); else props.damping = 0.0; if( opts.hasKey("init") ) props.init = opts.getStringAs("init"); else props.init = Properties::InitType::UNIFORM; if( opts.hasKey("updates") ) props.updates = opts.getStringAs("updates"); else props.updates = Properties::UpdateType::NAIVE; } PropertySet MF::getProperties() const { PropertySet opts; opts.set( "tol", props.tol ); opts.set( "maxiter", props.maxiter ); opts.set( "verbose", props.verbose ); opts.set( "damping", props.damping ); opts.set( "init", props.init ); opts.set( "updates", props.updates ); return opts; } string MF::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "verbose=" << props.verbose << ","; s << "init=" << props.init << ","; s << "updates=" << props.updates << ","; s << "damping=" << props.damping << "]"; return s.str(); } void MF::construct() { // create beliefs _beliefs.clear(); _beliefs.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); ++i ) _beliefs.push_back( Factor( var(i) ) ); } string MF::identify() const { return string(Name) + printProperties(); } void MF::init() { if( props.init == Properties::InitType::UNIFORM ) for( size_t i = 0; i < nrVars(); i++ ) _beliefs[i].fill( 1.0 ); else for( size_t i = 0; i < nrVars(); i++ ) _beliefs[i].randomize(); } Factor MF::calcNewBelief( size_t i ) { Factor result; foreach( const Neighbor &I, nbV(i) ) { Factor belief_I_minus_i; foreach( const Neighbor &j, nbF(I) ) // for all j in I \ i if( j != i ) belief_I_minus_i *= _beliefs[j]; Factor f_I = factor(I); if( props.updates == Properties::UpdateType::NAIVE ) f_I.takeLog(); Factor msg_I_i = (belief_I_minus_i * f_I).marginal( var(i), false ); if( props.updates == Properties::UpdateType::NAIVE ) result *= msg_I_i.exp(); else result *= msg_I_i; } result.normalize(); return result; } Real MF::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; double tic = toc(); vector update_seq; update_seq.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) update_seq.push_back( i ); // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance Real maxDiff = INFINITY; for( _iters = 0; _iters < props.maxiter && maxDiff > props.tol; _iters++ ) { random_shuffle( update_seq.begin(), update_seq.end() ); maxDiff = -INFINITY; foreach( const size_t &i, update_seq ) { Factor nb = calcNewBelief( i ); if( nb.hasNaNs() ) { cerr << Name << "::run(): ERROR: new belief of variable " << var(i) << " has NaNs!" << endl; return 1.0; } if( props.damping != 0.0 ) nb = (nb^(1.0 - props.damping)) * (_beliefs[i]^props.damping); maxDiff = std::max( maxDiff, dist( nb, _beliefs[i], DISTLINF ) ); _beliefs[i] = nb; } if( props.verbose >= 3 ) cerr << Name << "::run: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::run: WARNING: not converged within " << props.maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 3 ) cerr << Name << "::run: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } Factor MF::beliefV( size_t i ) const { return _beliefs[i].normalized(); } Factor MF::belief (const VarSet &ns) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) return beliefV( findVar( *(ns.begin()) ) ); else { DAI_THROW(BELIEF_NOT_AVAILABLE); return Factor(); } } vector MF::beliefs() const { vector result; for( size_t i = 0; i < nrVars(); i++ ) result.push_back( beliefV(i) ); return result; } Real MF::logZ() const { Real s = 0.0; for( size_t i = 0; i < nrVars(); i++ ) s -= beliefV(i).entropy(); for( size_t I = 0; I < nrFactors(); I++ ) { Factor henk; foreach( const Neighbor &j, nbF(I) ) // for all j in I henk *= _beliefs[j]; henk.normalize(); Factor piet; piet = factor(I).log(true); piet *= henk; s -= piet.sum(); } return -s; } void MF::init( const VarSet &ns ) { for( size_t i = 0; i < nrVars(); i++ ) if( ns.contains(var(i) ) ) { if( props.init == Properties::InitType::UNIFORM ) _beliefs[i].fill( 1.0 ); else _beliefs[i].randomize(); } } } // end of namespace dai libDAI-0.2.7/src/bipgraph.cpp0000644000263000017630000002746411433220722014560 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include namespace dai { using namespace std; BipartiteGraph& BipartiteGraph::addEdge( size_t n1, size_t n2, bool check ) { DAI_ASSERT( n1 < nrNodes1() ); DAI_ASSERT( n2 < nrNodes2() ); bool exists = false; if( check ) { // Check whether the edge already exists foreach( const Neighbor &nb2, nb1(n1) ) if( nb2 == n2 ) { exists = true; break; } } if( !exists ) { // Add edge Neighbor nb_1( nb1(n1).size(), n2, nb2(n2).size() ); Neighbor nb_2( nb_1.dual, n1, nb_1.iter ); nb1(n1).push_back( nb_1 ); nb2(n2).push_back( nb_2 ); } return *this; } void BipartiteGraph::eraseNode1( size_t n1 ) { DAI_ASSERT( n1 < nrNodes1() ); // Erase neighbor entry of node n1 _nb1.erase( _nb1.begin() + n1 ); // Adjust neighbor entries of nodes of type 2 for( size_t n2 = 0; n2 < nrNodes2(); n2++ ) { for( size_t iter = 0; iter < nb2(n2).size(); ) { Neighbor &m1 = nb2(n2, iter); if( m1.node == n1 ) { // delete this entry, because it points to the deleted node nb2(n2).erase( nb2(n2).begin() + iter ); } else { // update this entry and the corresponding dual of the neighboring node of type 1 if( m1.node > n1 ) m1.node--; nb1( m1.node, m1.dual ).dual = iter; m1.iter = iter++; } } } } void BipartiteGraph::eraseNode2( size_t n2 ) { DAI_ASSERT( n2 < nrNodes2() ); // Erase neighbor entry of node n2 _nb2.erase( _nb2.begin() + n2 ); // Adjust neighbor entries of nodes of type 1 for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) { for( size_t iter = 0; iter < nb1(n1).size(); ) { Neighbor &m2 = nb1(n1, iter); if( m2.node == n2 ) { // delete this entry, because it points to the deleted node nb1(n1).erase( nb1(n1).begin() + iter ); } else { // update this entry and the corresponding dual of the neighboring node of type 2 if( m2.node > n2 ) m2.node--; nb2( m2.node, m2.dual ).dual = iter; m2.iter = iter++; } } } } void BipartiteGraph::eraseEdge( size_t n1, size_t n2 ) { DAI_ASSERT( n1 < nrNodes1() ); DAI_ASSERT( n2 < nrNodes2() ); size_t iter; // Search for edge among neighbors of n1 for( iter = 0; iter < nb1(n1).size(); iter++ ) if( nb1(n1, iter).node == n2 ) { // Remove it nb1(n1).erase( nb1(n1).begin() + iter ); break; } // Change the iter and dual values of the subsequent neighbors for( ; iter < nb1(n1).size(); iter++ ) { Neighbor &m2 = nb1( n1, iter ); m2.iter = iter; nb2( m2.node, m2.dual ).dual = iter; } // Search for edge among neighbors of n2 for( iter = 0; iter < nb2(n2).size(); iter++ ) if( nb2(n2, iter).node == n1 ) { // Remove it nb2(n2).erase( nb2(n2).begin() + iter ); break; } // Change the iter and node values of the subsequent neighbors for( ; iter < nb2(n2).size(); iter++ ) { Neighbor &m1 = nb2( n2, iter ); m1.iter = iter; nb1( m1.node, m1.dual ).dual = iter; } } SmallSet BipartiteGraph::nb1Set( size_t n1 ) const { SmallSet result; foreach( const Neighbor &n2, nb1(n1) ) result |= n2; return result; } SmallSet BipartiteGraph::nb2Set( size_t n2 ) const { SmallSet result; foreach( const Neighbor &n1, nb2(n2) ) result |= n1; return result; } SmallSet BipartiteGraph::delta1( size_t n1, bool include ) const { // get all second-order neighbors SmallSet result; foreach( const Neighbor &n2, nb1(n1) ) foreach( const Neighbor &m1, nb2(n2) ) if( include || (m1 != n1) ) result |= m1; return result; } SmallSet BipartiteGraph::delta2( size_t n2, bool include ) const { // store all second-order neighbors SmallSet result; foreach( const Neighbor &n1, nb2(n2) ) foreach( const Neighbor &m2, nb1(n1) ) if( include || (m2 != n2) ) result |= m2; return result; } bool BipartiteGraph::isConnected() const { if( nrNodes1() == 0 ) { return true; } else { /* // The BGL implementation is significantly slower... using namespace boost; typedef adjacency_list< vecS, vecS, undirectedS, property > boostGraph; typedef pair E; // Copy graph structure into boostGraph object size_t N = nrNodes1(); vector edges; edges.reserve( nrEdges() ); for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) foreach( const Neighbor &n2, nb1(n1) ) edges.push_back( E( n1, n2.node + N ) ); boostGraph g( edges.begin(), edges.end(), nrNodes1() + nrNodes2() ); // Construct connected components using Boost Graph Library std::vector component( num_vertices( g ) ); int num_comp = connected_components( g, make_iterator_property_map(component.begin(), get(vertex_index, g)) ); return (num_comp == 1); */ std::vector incomponent1( nrNodes1(), false ); std::vector incomponent2( nrNodes2(), false ); incomponent1[0] = true; bool found_new_nodes; do { found_new_nodes = false; // For all nodes of type 2, check if they are connected with the (growing) component for( size_t n2 = 0; n2 < nrNodes2(); n2++ ) if( !incomponent2[n2] ) { foreach( const Neighbor &n1, nb2(n2) ) { if( incomponent1[n1] ) { found_new_nodes = true; incomponent2[n2] = true; break; } } } // For all nodes of type 1, check if they are connected with the (growing) component for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) if( !incomponent1[n1] ) { foreach( const Neighbor &n2, nb1(n1) ) { if( incomponent2[n2] ) { found_new_nodes = true; incomponent1[n1] = true; break; } } } } while( found_new_nodes ); // Check if there are remaining nodes (not in the component) bool all_connected = true; for( size_t n1 = 0; (n1 < nrNodes1()) && all_connected; n1++ ) if( !incomponent1[n1] ) all_connected = false; for( size_t n2 = 0; (n2 < nrNodes2()) && all_connected; n2++ ) if( !incomponent2[n2] ) all_connected = false; return all_connected; } } bool BipartiteGraph::isTree() const { vector levels; bool foundCycle = false; size_t nr_1 = 0; size_t nr_2 = 0; if( nrNodes1() == 0 ) return (nrNodes2() < 2 ); else if( nrNodes2() == 0 ) return (nrNodes1() < 2 ); else { levelType newLevel; do { newLevel.ind1.clear(); newLevel.ind2.clear(); if( levels.size() == 0 ) { size_t n1 = 0; // add n1 to ind1 newLevel.ind1 = vector( 1, n1 ); // add all neighbors of n1 to ind2 newLevel.ind2.reserve( nb1(n1).size() ); foreach( const Neighbor &n2, nb1(n1) ) newLevel.ind2.push_back( n2 ); } else { const levelType &prevLevel = levels.back(); // build newLevel.ind1 foreach( size_t n2, prevLevel.ind2 ) { // for all n2 in the previous level foreach( const Neighbor &n1, nb2(n2) ) { // for all neighbors n1 of n2 if( find( prevLevel.ind1.begin(), prevLevel.ind1.end(), n1 ) == prevLevel.ind1.end() ) { // n1 not in previous level if( find( newLevel.ind1.begin(), newLevel.ind1.end(), n1 ) != newLevel.ind1.end() ) foundCycle = true; // n1 already in new level: we found a cycle else newLevel.ind1.push_back( n1 ); // add n1 to new level } if( foundCycle ) break; } if( foundCycle ) break; } // build newLevel.ind2 foreach( size_t n1, newLevel.ind1 ) { // for all n1 in this level foreach( const Neighbor &n2, nb1(n1) ) { // for all neighbors n2 of n1 if( find( prevLevel.ind2.begin(), prevLevel.ind2.end(), n2 ) == prevLevel.ind2.end() ) { // n2 not in previous level if( find( newLevel.ind2.begin(), newLevel.ind2.end(), n2 ) != newLevel.ind2.end() ) foundCycle = true; // n2 already in new level: we found a cycle else newLevel.ind2.push_back( n2 ); // add n2 to new level } if( foundCycle ) break; } if( foundCycle ) break; } } levels.push_back( newLevel ); nr_1 += newLevel.ind1.size(); nr_2 += newLevel.ind2.size(); } while( ((newLevel.ind1.size() != 0) || (newLevel.ind2.size() != 0)) && !foundCycle ); if( nr_1 == nrNodes1() && nr_2 == nrNodes2() && !foundCycle ) return true; else return false; } } void BipartiteGraph::printDot( std::ostream& os ) const { os << "graph BipartiteGraph {" << endl; os << "node[shape=circle,width=0.4,fixedsize=true];" << endl; for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) os << "\tx" << n1 << ";" << endl; os << "node[shape=box,width=0.3,height=0.3,fixedsize=true];" << endl; for( size_t n2 = 0; n2 < nrNodes2(); n2++ ) os << "\ty" << n2 << ";" << endl; for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) foreach( const Neighbor &n2, nb1(n1) ) os << "\tx" << n1 << " -- y" << n2 << ";" << endl; os << "}" << endl; } void BipartiteGraph::checkConsistency() const { size_t N1 = nrNodes1(); size_t N2 = nrNodes2(); for( size_t n1 = 0; n1 < N1; n1++ ) { size_t iter = 0; foreach( const Neighbor &n2, nb1(n1) ) { DAI_ASSERT( n2.iter == iter ); DAI_ASSERT( n2.node < N2 ); DAI_ASSERT( n2.dual < nb2(n2).size() ); DAI_ASSERT( nb2(n2, n2.dual) == n1 ); iter++; } } for( size_t n2 = 0; n2 < N2; n2++ ) { size_t iter = 0; foreach( const Neighbor &n1, nb2(n2) ) { DAI_ASSERT( n1.iter == iter ); DAI_ASSERT( n1.node < N1 ); DAI_ASSERT( n1.dual < nb1(n1).size() ); DAI_ASSERT( nb1(n1, n1.dual) == n2 ); iter++; } } } } // end of namespace dai libDAI-0.2.7/src/cbp.cpp0000644000263000017630000005527211433220722013526 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ #include #include #include #include #include #include #include #include #include #include #include namespace dai { using namespace std; using boost::shared_ptr; const char *CBP::Name = "CBP"; /// Given a sorted vector of states \a xis and total state count \a n_states, return a vector of states not in \a xis vector complement( vector &xis, size_t n_states ) { vector cmp_xis( 0 ); size_t j = 0; for( size_t xi = 0; xi < n_states; xi++ ) { while( j < xis.size() && xis[j] < xi ) j++; if( j >= xis.size() || xis[j] > xi ) cmp_xis.push_back(xi); } DAI_ASSERT( xis.size()+cmp_xis.size() == n_states ); return cmp_xis; } /// Computes \f$\frac{\exp(a)}{\exp(a)+\exp(b)}\f$ Real unSoftMax( Real a, Real b ) { if( a > b ) return 1.0 / (1.0 + exp(b-a)); else return exp(a-b) / (exp(a-b) + 1.0); } /// Computes log of sum of exponents, i.e., \f$\log\left(\exp(a) + \exp(b)\right)\f$ Real logSumExp( Real a, Real b ) { if( a > b ) return a + log1p( exp( b-a ) ); else return b + log1p( exp( a-b ) ); } /// Compute sum of pairwise L-infinity distances of the first \a nv factors in each vector Real dist( const vector &b1, const vector &b2, size_t nv ) { Real d = 0.0; for( size_t k = 0; k < nv; k++ ) d += dist( b1[k], b2[k], DISTLINF ); return d; } void CBP::setBeliefs( const std::vector &bs, Real logZ ) { size_t i = 0; _beliefsV.clear(); _beliefsV.reserve( nrVars() ); _beliefsF.clear(); _beliefsF.reserve( nrFactors() ); for( i = 0; i < nrVars(); i++ ) _beliefsV.push_back( bs[i] ); for( ; i < nrVars() + nrFactors(); i++ ) _beliefsF.push_back( bs[i] ); _logZ = logZ; } void CBP::construct() { _beliefsV.clear(); _beliefsV.reserve(nrVars()); for( size_t i = 0; i < nrVars(); i++ ) _beliefsV.push_back( Factor(var(i)).normalized() ); _beliefsF.clear(); _beliefsF.reserve(nrFactors()); for( size_t I = 0; I < nrFactors(); I++ ) { Factor f = factor(I); f.fill(1); f.normalize(); _beliefsF.push_back( f ); } // to compute average level _sum_level = 0; _num_leaves = 0; _maxdiff = 0; _iters = 0; if( props.clamp_outfile.length() > 0 ) { _clamp_ofstream = shared_ptr(new ofstream( props.clamp_outfile.c_str(), ios_base::out|ios_base::trunc )); *_clamp_ofstream << "# COUNT LEVEL VAR STATE" << endl; } } /// Calculates a vector of mixtures p * b + (1-p) * c static vector mixBeliefs( Real p, const vector &b, const vector &c ) { vector out; DAI_ASSERT( b.size() == c.size() ); out.reserve( b.size() ); Real pc = 1 - p; for( size_t i = 0; i < b.size(); i++ ) // probably already normalized, but do it again just in case out.push_back( b[i].normalized() * p + c[i].normalized() * pc ); return out; } Real CBP::run() { size_t seed = props.rand_seed; if( seed > 0 ) rnd_seed( seed ); InfAlg *bp = getInfAlg(); bp->init(); bp->run(); _iters += bp->Iterations(); vector beliefs_out; Real lz_out; size_t choose_count=0; runRecurse( bp, bp->logZ(), vector(0), _num_leaves, choose_count, _sum_level, lz_out, beliefs_out ); if( props.verbose >= 1 ) cerr << "CBP average levels = " << (_sum_level / _num_leaves) << ", leaves = " << _num_leaves << endl; setBeliefs( beliefs_out, lz_out ); return 0.0; } InfAlg* CBP::getInfAlg() { PropertySet bpProps; bpProps.set("updates", props.updates); bpProps.set("tol", props.tol); bpProps.set("maxiter", props.maxiter); bpProps.set("verbose", props.verbose); bpProps.set("logdomain", false); bpProps.set("damping", (Real)0.0); BP *bp = new BP( *this, bpProps ); bp->recordSentMessages = true; bp->init(); return bp; } void CBP::runRecurse( InfAlg *bp, Real orig_logZ, vector clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, vector& beliefs_out) { // choose a variable/states to clamp: size_t i; vector xis; Real maxVar = 0.0; bool found; bool clampingVar = (props.clamp == Properties::ClampType::CLAMP_VAR); if( props.recursion == Properties::RecurseType::REC_LOGZ && props.rec_tol > 0 && exp( bp->logZ() - orig_logZ ) < props.rec_tol ) found = false; else found = chooseNextClampVar( bp, clamped_vars_list, i, xis, &maxVar ); if( !found ) { num_leaves++; sum_level += clamped_vars_list.size(); beliefs_out = bp->beliefs(); lz_out = bp->logZ(); return; } choose_count++; if( props.clamp_outfile.length() > 0 ) *_clamp_ofstream << choose_count << "\t" << clamped_vars_list.size() << "\t" << i << "\t" << xis[0] << endl; if( clampingVar ) foreach( size_t xi, xis ) DAI_ASSERT(/*0<=xi &&*/ xi < var(i).states() ); else foreach( size_t xI, xis ) DAI_ASSERT(/*0<=xI &&*/ xI < factor(i).nrStates() ); // - otherwise, clamp and recurse, saving margin estimates for each // clamp setting. afterwards, combine estimates. // compute complement of 'xis' vector cmp_xis = complement( xis, clampingVar ? var(i).states() : factor(i).nrStates() ); /// \idea dai::CBP::runRecurse() could be implemented more efficiently with a nesting version of backupFactors/restoreFactors // this improvement could also be done locally: backup the clamped factor in a local variable, // and restore it just before we return. Real lz; vector b; InfAlg *bp_c = bp->clone(); if( clampingVar ) { bp_c->fg().clampVar( i, xis ); bp_c->init( var(i) ); } else { bp_c->fg().clampFactor( i, xis ); bp_c->init( factor(i).vars() ); } bp_c->run(); _iters += bp_c->Iterations(); lz = bp_c->logZ(); b = bp_c->beliefs(); Real cmp_lz; vector cmp_b; InfAlg *cmp_bp_c = bp->clone(); if( clampingVar ) { cmp_bp_c->fg().clampVar( i, cmp_xis ); cmp_bp_c->init(var(i)); } else { cmp_bp_c->fg().clampFactor( i, cmp_xis ); cmp_bp_c->init( factor(i).vars() ); } cmp_bp_c->run(); _iters += cmp_bp_c->Iterations(); cmp_lz = cmp_bp_c->logZ(); cmp_b = cmp_bp_c->beliefs(); Real p = unSoftMax( lz, cmp_lz ); Real bp__d = 0.0; if( props.recursion == Properties::RecurseType::REC_BDIFF && props.rec_tol > 0 ) { vector combined_b( mixBeliefs( p, b, cmp_b ) ); Real new_lz = logSumExp( lz,cmp_lz ); bp__d = dist( bp->beliefs(), combined_b, nrVars() ); if( exp( new_lz - orig_logZ) * bp__d < props.rec_tol ) { num_leaves++; sum_level += clamped_vars_list.size(); beliefs_out = combined_b; lz_out = new_lz; return; } } // either we are not doing REC_BDIFF or the distance was large // enough to recurse: runRecurse( bp_c, orig_logZ, clamped_vars_list, num_leaves, choose_count, sum_level, lz, b ); runRecurse( cmp_bp_c, orig_logZ, clamped_vars_list, num_leaves, choose_count, sum_level, cmp_lz, cmp_b ); p = unSoftMax( lz, cmp_lz ); beliefs_out = mixBeliefs( p, b, cmp_b ); lz_out = logSumExp( lz, cmp_lz ); if( props.verbose >= 2 ) { Real d = dist( bp->beliefs(), beliefs_out, nrVars() ); cerr << "Distance (clamping " << i << "): " << d; if( props.recursion == Properties::RecurseType::REC_BDIFF ) cerr << "; bp_dual predicted " << bp__d; cerr << "; max_adjoint = " << maxVar << "; logZ = " << lz_out << " (in " << bp->logZ() << ") (orig " << orig_logZ << "); p = " << p << "; level = " << clamped_vars_list.size() << endl; } delete bp_c; delete cmp_bp_c; } // 'xis' must be sorted bool CBP::chooseNextClampVar( InfAlg *bp, vector &clamped_vars_list, size_t &i, vector &xis, Real *maxVarOut ) { Real tiny = 1.0e-14; if( props.verbose >= 3 ) cerr << "clamped_vars_list" << clamped_vars_list << endl; if( clamped_vars_list.size() >= props.max_levels ) return false; if( props.choose == Properties::ChooseMethodType::CHOOSE_RANDOM ) { if( props.clamp == Properties::ClampType::CLAMP_VAR ) { int t = 0, t1 = 100; do { i = rnd( nrVars() ); t++; } while( abs( bp->beliefV(i).p().max() - 1) < tiny && t < t1 ); if( t == t1 ) { return false; // die("Too many levels requested in CBP"); } // only pick probable values for variable size_t xi; do { xi = rnd( var(i).states() ); t++; } while( bp->beliefV(i).p()[xi] < tiny && t < t1 ); DAI_ASSERT( t < t1 ); xis.resize( 1, xi ); // DAI_ASSERT(!_clamped_vars.count(i)); // not true for >2-ary variables DAI_IFVERB(2, "CHOOSE_RANDOM at level " << clamped_vars_list.size() << " chose variable " << i << " state " << xis[0] << endl); } else { int t = 0, t1 = 100; do { i = rnd( nrFactors() ); t++; } while( abs( bp->beliefF(i).p().max() - 1) < tiny && t < t1 ); if( t == t1 ) return false; // die("Too many levels requested in CBP"); // only pick probable values for variable size_t xi; do { xi = rnd( factor(i).nrStates() ); t++; } while( bp->beliefF(i).p()[xi] < tiny && t < t1 ); DAI_ASSERT( t < t1 ); xis.resize( 1, xi ); // DAI_ASSERT(!_clamped_vars.count(i)); // not true for >2-ary variables DAI_IFVERB(2, endl<<"CHOOSE_RANDOM chose factor "<beliefV(k).entropy(); if( max_ent < ent ) { max_ent = ent; win_k = k; win_xk = bp->beliefV(k).p().argmax().first; } } DAI_ASSERT( win_k >= 0 ); DAI_ASSERT( win_xk >= 0 ); i = win_k; xis.resize( 1, win_xk ); DAI_IFVERB(2, endl<<"CHOOSE_MAXENT chose variable "<beliefV(i).p()[xis[0]] < tiny ) { DAI_IFVERB(2, "Warning: CHOOSE_MAXENT found unlikely state, not recursing"); return false; } } else { Real max_ent = -1.0; int win_k = -1, win_xk = -1; for( size_t k = 0; k < nrFactors(); k++ ) { Real ent = bp->beliefF(k).entropy(); if( max_ent < ent ) { max_ent = ent; win_k = k; win_xk = bp->beliefF(k).p().argmax().first; } } DAI_ASSERT( win_k >= 0 ); DAI_ASSERT( win_xk >= 0 ); i = win_k; xis.resize( 1, win_xk ); DAI_IFVERB(2, endl<<"CHOOSE_MAXENT chose factor "<beliefF(i).p()[xis[0]] < tiny ) { DAI_IFVERB(2, "Warning: CHOOSE_MAXENT found unlikely state, not recursing"); return false; } } } else if( props.choose==Properties::ChooseMethodType::CHOOSE_BP_L1 || props.choose==Properties::ChooseMethodType::CHOOSE_BP_CFN ) { bool doL1 = (props.choose == Properties::ChooseMethodType::CHOOSE_BP_L1); vector state; if( !doL1 && props.bbp_cfn.needGibbsState() ) state = getGibbsState( bp->fg(), 2*bp->Iterations() ); // try clamping each variable manually DAI_ASSERT( props.clamp == Properties::ClampType::CLAMP_VAR ); Real max_cost = 0.0; int win_k = -1, win_xk = -1; for( size_t k = 0; k < nrVars(); k++ ) { for( size_t xk = 0; xk < var(k).states(); xk++ ) { if( bp->beliefV(k)[xk] < tiny ) continue; InfAlg *bp1 = bp->clone(); bp1->clamp( k, xk ); bp1->init( var(k) ); bp1->run(); Real cost = 0; if( doL1 ) for( size_t j = 0; j < nrVars(); j++ ) cost += dist( bp->beliefV(j), bp1->beliefV(j), DISTL1 ); else cost = props.bbp_cfn.evaluate( *bp1, &state ); if( cost > max_cost || win_k == -1 ) { max_cost = cost; win_k = k; win_xk = xk; } delete bp1; } } DAI_ASSERT( win_k >= 0 ); DAI_ASSERT( win_xk >= 0 ); i = win_k; xis.resize( 1, win_xk ); } else if( props.choose == Properties::ChooseMethodType::CHOOSE_BBP ) { Real mvo; if( !maxVarOut ) maxVarOut = &mvo; bool clampingVar = (props.clamp == Properties::ClampType::CLAMP_VAR); pair cv = BBPFindClampVar( *bp, clampingVar, props.bbp_props, props.bbp_cfn, &mvo ); // if slope isn't big enough then don't clamp if( mvo < props.min_max_adj ) return false; size_t xi = cv.second; i = cv.first; #define VAR_INFO (clampingVar?"variable ":"factor ") \ << i << " state " << xi \ << " (p=" << (clampingVar?bp->beliefV(i)[xi]:bp->beliefF(i)[xi]) \ << ", entropy = " << (clampingVar?bp->beliefV(i):bp->beliefF(i)).entropy() \ << ", maxVar = "<< mvo << ")" Prob b = ( clampingVar ? bp->beliefV(i).p() : bp->beliefF(i).p()); if( b[xi] < tiny ) { cerr << "Warning, at level " << clamped_vars_list.size() << ", BBPFindClampVar found unlikely " << VAR_INFO << endl; return false; } if( abs(b[xi] - 1) < tiny ) { cerr << "Warning at level " << clamped_vars_list.size() << ", BBPFindClampVar found overly likely " << VAR_INFO << endl; return false; } xis.resize( 1, xi ); if( clampingVar ) DAI_ASSERT(/*0<=xi &&*/ xi < var(i).states() ); else DAI_ASSERT(/*0<=xi &&*/ xi < factor(i).nrStates() ); DAI_IFVERB(2, "CHOOSE_BBP (num clamped = " << clamped_vars_list.size() << ") chose " << i << " state " << xi << endl); } else DAI_THROW(UNKNOWN_ENUM_VALUE); clamped_vars_list.push_back( i ); return true; } void CBP::printDebugInfo() { DAI_PV(_beliefsV); DAI_PV(_beliefsF); DAI_PV(_logZ); } std::pair BBPFindClampVar( const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut ) { BBP bbp( &in_bp, bbp_props ); bbp.initCostFnAdj( cfn, NULL ); bbp.run(); // find and return the (variable,state) with the largest adj_psi_V size_t argmax_var = 0; size_t argmax_var_state = 0; Real max_var = 0; if( clampingVar ) { for( size_t i = 0; i < in_bp.fg().nrVars(); i++ ) { Prob adj_psi_V = bbp.adj_psi_V(i); if(0) { // helps to account for amount of movement possible in variable // i's beliefs? seems not.. adj_psi_V *= in_bp.beliefV(i).entropy(); } if(0){ // adj_psi_V *= Prob(in_bp.fg().var(i).states(),1.0)-in_bp.beliefV(i).p(); adj_psi_V *= in_bp.beliefV(i).p(); } // try to compensate for effect on same variable (doesn't work) // adj_psi_V[gibbs.state()[i]] -= bp_dual.beliefV(i)[gibbs.state()[i]]/10; pair argmax_state = adj_psi_V.argmax(); if( i == 0 || argmax_state.second > max_var ) { argmax_var = i; max_var = argmax_state.second; argmax_var_state = argmax_state.first; } } DAI_ASSERT(/*0 <= argmax_var_state &&*/ argmax_var_state < in_bp.fg().var(argmax_var).states() ); } else { for( size_t I = 0; I < in_bp.fg().nrFactors(); I++ ) { Prob adj_psi_F = bbp.adj_psi_F(I); if(0) { // helps to account for amount of movement possible in variable // i's beliefs? seems not.. adj_psi_F *= in_bp.beliefF(I).entropy(); } // try to compensate for effect on same variable (doesn't work) // adj_psi_V[gibbs.state()[i]] -= bp_dual.beliefV(i)[gibbs.state()[i]]/10; pair argmax_state = adj_psi_F.argmax(); if( I == 0 || argmax_state.second > max_var ) { argmax_var = I; max_var = argmax_state.second; argmax_var_state = argmax_state.first; } } DAI_ASSERT(/*0 <= argmax_var_state &&*/ argmax_var_state < in_bp.fg().factor(argmax_var).nrStates() ); } if( maxVarOut ) *maxVarOut = max_var; return make_pair( argmax_var, argmax_var_state ); } } // end of namespace dai /* {{{ GENERATED CODE: DO NOT EDIT. Created by ./scripts/regenerate-properties include/dai/cbp.h src/cbp.cpp */ namespace dai { void CBP::Properties::set(const PropertySet &opts) { const std::set &keys = opts.keys(); std::string errormsg; for( std::set::const_iterator i = keys.begin(); i != keys.end(); i++ ) { if( *i == "verbose" ) continue; if( *i == "tol" ) continue; if( *i == "updates" ) continue; if( *i == "maxiter" ) continue; if( *i == "rec_tol" ) continue; if( *i == "max_levels" ) continue; if( *i == "min_max_adj" ) continue; if( *i == "choose" ) continue; if( *i == "recursion" ) continue; if( *i == "clamp" ) continue; if( *i == "bbp_props" ) continue; if( *i == "bbp_cfn" ) continue; if( *i == "rand_seed" ) continue; if( *i == "clamp_outfile" ) continue; errormsg = errormsg + "CBP: Unknown property " + *i + "\n"; } if( !errormsg.empty() ) DAI_THROWE(UNKNOWN_PROPERTY, errormsg); if( !opts.hasKey("tol") ) errormsg = errormsg + "CBP: Missing property \"tol\" for method \"CBP\"\n"; if( !opts.hasKey("updates") ) errormsg = errormsg + "CBP: Missing property \"updates\" for method \"CBP\"\n"; if( !opts.hasKey("maxiter") ) errormsg = errormsg + "CBP: Missing property \"maxiter\" for method \"CBP\"\n"; if( !opts.hasKey("rec_tol") ) errormsg = errormsg + "CBP: Missing property \"rec_tol\" for method \"CBP\"\n"; if( !opts.hasKey("min_max_adj") ) errormsg = errormsg + "CBP: Missing property \"min_max_adj\" for method \"CBP\"\n"; if( !opts.hasKey("choose") ) errormsg = errormsg + "CBP: Missing property \"choose\" for method \"CBP\"\n"; if( !opts.hasKey("recursion") ) errormsg = errormsg + "CBP: Missing property \"recursion\" for method \"CBP\"\n"; if( !opts.hasKey("clamp") ) errormsg = errormsg + "CBP: Missing property \"clamp\" for method \"CBP\"\n"; if( !opts.hasKey("bbp_props") ) errormsg = errormsg + "CBP: Missing property \"bbp_props\" for method \"CBP\"\n"; if( !opts.hasKey("bbp_cfn") ) errormsg = errormsg + "CBP: Missing property \"bbp_cfn\" for method \"CBP\"\n"; if( !errormsg.empty() ) DAI_THROWE(NOT_ALL_PROPERTIES_SPECIFIED,errormsg); if( opts.hasKey("verbose") ) { verbose = opts.getStringAs("verbose"); } else { verbose = 0; } tol = opts.getStringAs("tol"); updates = opts.getStringAs("updates"); maxiter = opts.getStringAs("maxiter"); rec_tol = opts.getStringAs("rec_tol"); if( opts.hasKey("max_levels") ) { max_levels = opts.getStringAs("max_levels"); } else { max_levels = 10; } min_max_adj = opts.getStringAs("min_max_adj"); choose = opts.getStringAs("choose"); recursion = opts.getStringAs("recursion"); clamp = opts.getStringAs("clamp"); bbp_props = opts.getStringAs("bbp_props"); bbp_cfn = opts.getStringAs("bbp_cfn"); if( opts.hasKey("rand_seed") ) { rand_seed = opts.getStringAs("rand_seed"); } else { rand_seed = 0; } if( opts.hasKey("clamp_outfile") ) { clamp_outfile = opts.getStringAs("clamp_outfile"); } else { clamp_outfile = ""; } } PropertySet CBP::Properties::get() const { PropertySet opts; opts.set("verbose", verbose); opts.set("tol", tol); opts.set("updates", updates); opts.set("maxiter", maxiter); opts.set("rec_tol", rec_tol); opts.set("max_levels", max_levels); opts.set("min_max_adj", min_max_adj); opts.set("choose", choose); opts.set("recursion", recursion); opts.set("clamp", clamp); opts.set("bbp_props", bbp_props); opts.set("bbp_cfn", bbp_cfn); opts.set("rand_seed", rand_seed); opts.set("clamp_outfile", clamp_outfile); return opts; } string CBP::Properties::toString() const { stringstream s(stringstream::out); s << "["; s << "verbose=" << verbose << ","; s << "tol=" << tol << ","; s << "updates=" << updates << ","; s << "maxiter=" << maxiter << ","; s << "rec_tol=" << rec_tol << ","; s << "max_levels=" << max_levels << ","; s << "min_max_adj=" << min_max_adj << ","; s << "choose=" << choose << ","; s << "recursion=" << recursion << ","; s << "clamp=" << clamp << ","; s << "bbp_props=" << bbp_props << ","; s << "bbp_cfn=" << bbp_cfn << ","; s << "rand_seed=" << rand_seed << ","; s << "clamp_outfile=" << clamp_outfile; s << "]"; return s.str(); } } // end of namespace dai /* }}} END OF GENERATED CODE */ libDAI-0.2.7/src/regiongraph.cpp0000644000263000017630000002047511433220722015264 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include namespace dai { using namespace std; void RegionGraph::construct( const FactorGraph &fg, const std::vector &ors, const std::vector &irs, const std::vector > &edges ) { // Copy factor graph structure FactorGraph::operator=( fg ); // Copy inner regions _IRs = irs; // Construct outer regions (giving them counting number 1.0) _ORs.clear(); _ORs.reserve( ors.size() ); foreach( const VarSet &alpha, ors ) _ORs.push_back( FRegion(Factor(alpha, 1.0), 1.0) ); // For each factor, find an outer region that subsumes that factor. // Then, multiply the outer region with that factor. _fac2OR.clear(); _fac2OR.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) { size_t alpha; for( alpha = 0; alpha < nrORs(); alpha++ ) if( OR(alpha).vars() >> factor(I).vars() ) { _fac2OR.push_back( alpha ); break; } DAI_ASSERT( alpha != nrORs() ); } recomputeORs(); // Create bipartite graph _G.construct( nrORs(), nrIRs(), edges.begin(), edges.end() ); } void RegionGraph::constructCVM( const FactorGraph &fg, const std::vector &cl, size_t verbose ) { if( verbose ) cerr << "constructCVM called (" << fg.nrVars() << " vars, " << fg.nrFactors() << " facs, " << cl.size() << " clusters)" << endl; // Retain only maximal clusters if( verbose ) cerr << " Constructing ClusterGraph" << endl; ClusterGraph cg( cl ); if( verbose ) cerr << " Erasing non-maximal clusters" << endl; cg.eraseNonMaximal(); // Create inner regions - first pass if( verbose ) cerr << " Creating inner regions (first pass)" << endl; set betas; for( size_t alpha = 0; alpha < cg.nrClusters(); alpha++ ) for( size_t alpha2 = alpha; (++alpha2) != cg.nrClusters(); ) { VarSet intersection = cg.cluster(alpha) & cg.cluster(alpha2); if( intersection.size() > 0 ) betas.insert( intersection ); } // Create inner regions - subsequent passes if( verbose ) cerr << " Creating inner regions (next passes)" << endl; set new_betas; do { new_betas.clear(); for( set::const_iterator gamma = betas.begin(); gamma != betas.end(); gamma++ ) for( set::const_iterator gamma2 = gamma; (++gamma2) != betas.end(); ) { VarSet intersection = (*gamma) & (*gamma2); if( (intersection.size() > 0) && (betas.count(intersection) == 0) ) new_betas.insert( intersection ); } betas.insert(new_betas.begin(), new_betas.end()); } while( new_betas.size() ); // Create inner regions - final phase if( verbose ) cerr << " Creating inner regions (final phase)" << endl; vector irs; irs.reserve( betas.size() ); for( set::const_iterator beta = betas.begin(); beta != betas.end(); beta++ ) irs.push_back( Region(*beta,0.0) ); // Create edges if( verbose ) cerr << " Creating edges" << endl; vector > edges; for( size_t beta = 0; beta < irs.size(); beta++ ) for( size_t alpha = 0; alpha < cg.nrClusters(); alpha++ ) if( cg.cluster(alpha) >> irs[beta] ) edges.push_back( pair(alpha,beta) ); // Construct region graph if( verbose ) cerr << " Constructing region graph" << endl; construct( fg, cg.clusters(), irs, edges ); // Calculate counting numbers if( verbose ) cerr << " Calculating counting numbers" << endl; calcCVMCountingNumbers(); if( verbose ) cerr << "Done." << endl; } void RegionGraph::calcCVMCountingNumbers() { // Calculates counting numbers of inner regions based upon counting numbers of outer regions vector > ancestors(nrIRs()); boost::dynamic_bitset<> assigned(nrIRs()); for( size_t beta = 0; beta < nrIRs(); beta++ ) { IR(beta).c() = 0.0; for( size_t beta2 = 0; beta2 < nrIRs(); beta2++ ) if( (beta2 != beta) && IR(beta2) >> IR(beta) ) ancestors[beta].push_back(beta2); } bool new_counting; do { new_counting = false; for( size_t beta = 0; beta < nrIRs(); beta++ ) { if( !assigned[beta] ) { bool has_unassigned_ancestor = false; for( vector::const_iterator beta2 = ancestors[beta].begin(); (beta2 != ancestors[beta].end()) && !has_unassigned_ancestor; beta2++ ) if( !assigned[*beta2] ) has_unassigned_ancestor = true; if( !has_unassigned_ancestor ) { Real c = 1.0; foreach( const Neighbor &alpha, nbIR(beta) ) c -= OR(alpha).c(); for( vector::const_iterator beta2 = ancestors[beta].begin(); beta2 != ancestors[beta].end(); beta2++ ) c -= IR(*beta2).c(); IR(beta).c() = c; assigned.set(beta, true); new_counting = true; } } } } while( new_counting ); } bool RegionGraph::checkCountingNumbers() const { // Checks whether the counting numbers satisfy the fundamental relation bool all_valid = true; for( vector::const_iterator n = vars().begin(); n != vars().end(); n++ ) { Real c_n = 0.0; for( size_t alpha = 0; alpha < nrORs(); alpha++ ) if( OR(alpha).vars().contains( *n ) ) c_n += OR(alpha).c(); for( size_t beta = 0; beta < nrIRs(); beta++ ) if( IR(beta).contains( *n ) ) c_n += IR(beta).c(); if( fabs(c_n - 1.0) > 1e-15 ) { all_valid = false; cerr << "WARNING: counting numbers do not satisfy relation for " << *n << "(c_n = " << c_n << ")." << endl; } } return all_valid; } void RegionGraph::recomputeORs() { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) OR(alpha).fill( 1.0 ); for( size_t I = 0; I < nrFactors(); I++ ) if( fac2OR(I) != -1U ) OR( fac2OR(I) ) *= factor( I ); } void RegionGraph::recomputeORs( const VarSet &ns ) { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) if( OR(alpha).vars().intersects( ns ) ) OR(alpha).fill( 1.0 ); for( size_t I = 0; I < nrFactors(); I++ ) if( fac2OR(I) != -1U ) if( OR( fac2OR(I) ).vars().intersects( ns ) ) OR( fac2OR(I) ) *= factor( I ); } void RegionGraph::recomputeOR( size_t I ) { DAI_ASSERT( I < nrFactors() ); if( fac2OR(I) != -1U ) { size_t alpha = fac2OR(I); OR(alpha).fill( 1.0 ); for( size_t J = 0; J < nrFactors(); J++ ) if( fac2OR(J) == alpha ) OR(alpha) *= factor( J ); } } /// Send RegionGraph to output stream ostream & operator << (ostream & os, const RegionGraph & rg) { os << "digraph RegionGraph {" << endl; os << "node[shape=box];" << endl; for( size_t alpha = 0; alpha < rg.nrORs(); alpha++ ) os << "\ta" << alpha << " [label=\"a" << alpha << ": " << rg.OR(alpha).vars() << ", c=" << rg.OR(alpha).c() << "\"];" << endl; os << "node[shape=ellipse];" << endl; for( size_t beta = 0; beta < rg.nrIRs(); beta++ ) os << "\tb" << beta << " [label=\"b" << beta << ": " << (VarSet)rg.IR(beta) << ", c=" << rg.IR(beta).c() << "\"];" << endl; for( size_t alpha = 0; alpha < rg.nrORs(); alpha++ ) foreach( const Neighbor &beta, rg.nbOR(alpha) ) os << "\ta" << alpha << " -> b" << beta << ";" << endl; os << "}" << endl; return os; } } // end of namespace dai libDAI-0.2.7/src/bp.cpp0000644000263000017630000003631011433220722013353 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include namespace dai { using namespace std; const char *BP::Name = "BP"; #define DAI_BP_FAST 1 void BP::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("logdomain") ); DAI_ASSERT( opts.hasKey("updates") ); props.tol = opts.getStringAs("tol"); props.logdomain = opts.getStringAs("logdomain"); props.updates = opts.getStringAs("updates"); if( opts.hasKey("maxiter") ) props.maxiter = opts.getStringAs("maxiter"); else props.maxiter = 10000; if( opts.hasKey("maxtime") ) props.maxtime = opts.getStringAs("maxtime"); else props.maxtime = INFINITY; if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; if( opts.hasKey("damping") ) props.damping = opts.getStringAs("damping"); else props.damping = 0.0; if( opts.hasKey("inference") ) props.inference = opts.getStringAs("inference"); else props.inference = Properties::InfType::SUMPROD; } PropertySet BP::getProperties() const { PropertySet opts; opts.set( "tol", props.tol ); opts.set( "maxiter", props.maxiter ); opts.set( "maxtime", props.maxtime ); opts.set( "verbose", props.verbose ); opts.set( "logdomain", props.logdomain ); opts.set( "updates", props.updates ); opts.set( "damping", props.damping ); opts.set( "inference", props.inference ); return opts; } string BP::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "maxtime=" << props.maxtime << ","; s << "verbose=" << props.verbose << ","; s << "logdomain=" << props.logdomain << ","; s << "updates=" << props.updates << ","; s << "damping=" << props.damping << ","; s << "inference=" << props.inference << "]"; return s.str(); } void BP::construct() { // create edge properties _edges.clear(); _edges.reserve( nrVars() ); _edge2lut.clear(); if( props.updates == Properties::UpdateType::SEQMAX ) _edge2lut.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); ++i ) { _edges.push_back( vector() ); _edges[i].reserve( nbV(i).size() ); if( props.updates == Properties::UpdateType::SEQMAX ) { _edge2lut.push_back( vector() ); _edge2lut[i].reserve( nbV(i).size() ); } foreach( const Neighbor &I, nbV(i) ) { EdgeProp newEP; newEP.message = Prob( var(i).states() ); newEP.newMessage = Prob( var(i).states() ); if( DAI_BP_FAST ) { newEP.index.reserve( factor(I).nrStates() ); for( IndexFor k( var(i), factor(I).vars() ); k.valid(); ++k ) newEP.index.push_back( k ); } newEP.residual = 0.0; _edges[i].push_back( newEP ); if( props.updates == Properties::UpdateType::SEQMAX ) _edge2lut[i].push_back( _lut.insert( make_pair( newEP.residual, make_pair( i, _edges[i].size() - 1 ))) ); } } // create old beliefs _oldBeliefsV.clear(); _oldBeliefsV.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); ++i ) _oldBeliefsV.push_back( Factor( var(i) ) ); _oldBeliefsF.clear(); _oldBeliefsF.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); ++I ) _oldBeliefsF.push_back( Factor( factor(I).vars() ) ); // create update sequence _updateSeq.clear(); _updateSeq.reserve( nrEdges() ); for( size_t I = 0; I < nrFactors(); I++ ) foreach( const Neighbor &i, nbF(I) ) _updateSeq.push_back( Edge( i, i.dual ) ); } void BP::init() { Real c = props.logdomain ? 0.0 : 1.0; for( size_t i = 0; i < nrVars(); ++i ) { foreach( const Neighbor &I, nbV(i) ) { message( i, I.iter ).fill( c ); newMessage( i, I.iter ).fill( c ); if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, I.iter, 0.0 ); } } _iters = 0; } void BP::findMaxResidual( size_t &i, size_t &_I ) { DAI_ASSERT( !_lut.empty() ); LutType::const_iterator largestEl = _lut.end(); --largestEl; i = largestEl->second.first; _I = largestEl->second.second; } Prob BP::calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const { Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); if( props.logdomain ) prod.takeLog(); // Calculate product of incoming messages and factor I foreach( const Neighbor &j, nbF(I) ) if( !(without_i && (j == i)) ) { // prod_j will be the product of messages coming into j Prob prod_j( var(j).states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &J, nbV(j) ) if( J != I ) { // for all J in nb(j) \ I if( props.logdomain ) prod_j += message( j, J.iter ); else prod_j *= message( j, J.iter ); } // multiply prod with prod_j if( !DAI_BP_FAST ) { // UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION if( props.logdomain ) Fprod += Factor( var(j), prod_j ); else Fprod *= Factor( var(j), prod_j ); } else { // OPTIMIZED VERSION size_t _I = j.dual; // ind is the precalculated IndexFor(j,I) i.e. to x_I == k corresponds x_j == ind[k] const ind_t &ind = index(j, _I); for( size_t r = 0; r < prod.size(); ++r ) if( props.logdomain ) prod.set( r, prod[r] + prod_j[ind[r]] ); else prod.set( r, prod[r] * prod_j[ind[r]] ); } } return prod; } void BP::calcNewMessage( size_t i, size_t _I ) { // calculate updated message I->i size_t I = nbV(i,_I); Prob marg; if( factor(I).vars().size() == 1 ) // optimization marg = factor(I).p(); else { Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); prod = calcIncomingMessageProduct( I, true, i ); if( props.logdomain ) { prod -= prod.max(); prod.takeExp(); } // Marginalize onto i if( !DAI_BP_FAST ) { // UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION if( props.inference == Properties::InfType::SUMPROD ) marg = Fprod.marginal( var(i) ).p(); else marg = Fprod.maxMarginal( var(i) ).p(); } else { // OPTIMIZED VERSION marg = Prob( var(i).states(), 0.0 ); // ind is the precalculated IndexFor(i,I) i.e. to x_I == k corresponds x_i == ind[k] const ind_t ind = index(i,_I); if( props.inference == Properties::InfType::SUMPROD ) for( size_t r = 0; r < prod.size(); ++r ) marg.set( ind[r], marg[ind[r]] + prod[r] ); else for( size_t r = 0; r < prod.size(); ++r ) if( prod[r] > marg[ind[r]] ) marg.set( ind[r], prod[r] ); marg.normalize(); } } // Store result if( props.logdomain ) newMessage(i,_I) = marg.log(); else newMessage(i,_I) = marg; // Update the residual if necessary if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, _I , dist( newMessage( i, _I ), message( i, _I ), DISTLINF ) ); } // BP::run does not check for NANs for performance reasons // Somehow NaNs do not often occur in BP... Real BP::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3) cerr << endl; double tic = toc(); // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance Real maxDiff = INFINITY; for( ; _iters < props.maxiter && maxDiff > props.tol && (toc() - tic) < props.maxtime; _iters++ ) { if( props.updates == Properties::UpdateType::SEQMAX ) { if( _iters == 0 ) { // do the first pass for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) calcNewMessage( i, I.iter ); } // Maximum-Residual BP [\ref EMK06] for( size_t t = 0; t < _updateSeq.size(); ++t ) { // update the message with the largest residual size_t i, _I; findMaxResidual( i, _I ); updateMessage( i, _I ); // I->i has been updated, which means that residuals for all // J->j with J in nb[i]\I and j in nb[J]\i have to be updated foreach( const Neighbor &J, nbV(i) ) { if( J.iter != _I ) { foreach( const Neighbor &j, nbF(J) ) { size_t _J = j.dual; if( j != i ) calcNewMessage( j, _J ); } } } } } else if( props.updates == Properties::UpdateType::PARALL ) { // Parallel updates for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) calcNewMessage( i, I.iter ); for( size_t i = 0; i < nrVars(); ++i ) foreach( const Neighbor &I, nbV(i) ) updateMessage( i, I.iter ); } else { // Sequential updates if( props.updates == Properties::UpdateType::SEQRND ) random_shuffle( _updateSeq.begin(), _updateSeq.end() ); foreach( const Edge &e, _updateSeq ) { calcNewMessage( e.first, e.second ); updateMessage( e.first, e.second ); } } // calculate new beliefs and compare with old ones maxDiff = -INFINITY; for( size_t i = 0; i < nrVars(); ++i ) { Factor b( beliefV(i) ); maxDiff = std::max( maxDiff, dist( b, _oldBeliefsV[i], DISTLINF ) ); _oldBeliefsV[i] = b; } for( size_t I = 0; I < nrFactors(); ++I ) { Factor b( beliefF(I) ); maxDiff = std::max( maxDiff, dist( b, _oldBeliefsF[I], DISTLINF ) ); _oldBeliefsF[I] = b; } if( props.verbose >= 3 ) cerr << Name << "::run: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::run: WARNING: not converged after " << _iters << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 3 ) cerr << Name << "::run: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } void BP::calcBeliefV( size_t i, Prob &p ) const { p = Prob( var(i).states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &I, nbV(i) ) if( props.logdomain ) p += newMessage( i, I.iter ); else p *= newMessage( i, I.iter ); } Factor BP::beliefV( size_t i ) const { Prob p; calcBeliefV( i, p ); if( props.logdomain ) { p -= p.max(); p.takeExp(); } p.normalize(); return( Factor( var(i), p ) ); } Factor BP::beliefF( size_t I ) const { Prob p; calcBeliefF( I, p ); if( props.logdomain ) { p -= p.max(); p.takeExp(); } p.normalize(); return( Factor( factor(I).vars(), p ) ); } vector BP::beliefs() const { vector result; for( size_t i = 0; i < nrVars(); ++i ) result.push_back( beliefV(i) ); for( size_t I = 0; I < nrFactors(); ++I ) result.push_back( beliefF(I) ); return result; } Factor BP::belief( const VarSet &ns ) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) return beliefV( findVar( *(ns.begin() ) ) ); else { size_t I; for( I = 0; I < nrFactors(); I++ ) if( factor(I).vars() >> ns ) break; if( I == nrFactors() ) DAI_THROW(BELIEF_NOT_AVAILABLE); return beliefF(I).marginal(ns); } } Real BP::logZ() const { Real sum = 0.0; for( size_t i = 0; i < nrVars(); ++i ) sum += (1.0 - nbV(i).size()) * beliefV(i).entropy(); for( size_t I = 0; I < nrFactors(); ++I ) sum -= dist( beliefF(I), factor(I), DISTKL ); return sum; } string BP::identify() const { return string(Name) + printProperties(); } void BP::init( const VarSet &ns ) { for( VarSet::const_iterator n = ns.begin(); n != ns.end(); ++n ) { size_t ni = findVar( *n ); foreach( const Neighbor &I, nbV( ni ) ) { Real val = props.logdomain ? 0.0 : 1.0; message( ni, I.iter ).fill( val ); newMessage( ni, I.iter ).fill( val ); if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( ni, I.iter, 0.0 ); } } _iters = 0; } void BP::updateMessage( size_t i, size_t _I ) { if( recordSentMessages ) _sentMessages.push_back(make_pair(i,_I)); if( props.damping == 0.0 ) { message(i,_I) = newMessage(i,_I); if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, _I, 0.0 ); } else { if( props.logdomain ) message(i,_I) = (message(i,_I) * props.damping) + (newMessage(i,_I) * (1.0 - props.damping)); else message(i,_I) = (message(i,_I) ^ props.damping) * (newMessage(i,_I) ^ (1.0 - props.damping)); if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, _I, dist( newMessage(i,_I), message(i,_I), DISTLINF ) ); } } void BP::updateResidual( size_t i, size_t _I, Real r ) { EdgeProp* pEdge = &_edges[i][_I]; pEdge->residual = r; // rearrange look-up table (delete and reinsert new key) _lut.erase( _edge2lut[i][_I] ); _edge2lut[i][_I] = _lut.insert( make_pair( r, make_pair(i, _I) ) ); } } // end of namespace dai libDAI-0.2.7/src/mr.cpp0000644000263000017630000003607211433220722013375 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2007 Bastian Wemmenhove * Copyright (C) 2007-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include #include namespace dai { using namespace std; const char *MR::Name = "MR"; void MR::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("updates") ); DAI_ASSERT( opts.hasKey("inits") ); props.tol = opts.getStringAs("tol"); props.updates = opts.getStringAs("updates"); props.inits = opts.getStringAs("inits"); if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; } PropertySet MR::getProperties() const { PropertySet opts; opts.set( "tol", props.tol ); opts.set( "verbose", props.verbose ); opts.set( "updates", props.updates ); opts.set( "inits", props.inits ); return opts; } string MR::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "verbose=" << props.verbose << ","; s << "updates=" << props.updates << ","; s << "inits=" << props.inits << "]"; return s.str(); } Real MR::T(size_t i, sub_nb A) { sub_nb _nbi_min_A(G.nb(i).size()); _nbi_min_A.set(); _nbi_min_A &= ~A; Real res = theta[i]; for( size_t _j = 0; _j < _nbi_min_A.size(); _j++ ) if( _nbi_min_A.test(_j) ) res += atanh(tJ[i][_j] * M[i][_j]); return tanh(res); } Real MR::T(size_t i, size_t _j) { sub_nb j(G.nb(i).size()); j.set(_j); return T(i,j); } Real MR::Omega(size_t i, size_t _j, size_t _l) { sub_nb jl(G.nb(i).size()); jl.set(_j); jl.set(_l); Real Tijl = T(i,jl); return Tijl / (1.0 + tJ[i][_l] * M[i][_l] * Tijl); } Real MR::Gamma(size_t i, size_t _j, size_t _l1, size_t _l2) { sub_nb jll(G.nb(i).size()); jll.set(_j); Real Tij = T(i,jll); jll.set(_l1); jll.set(_l2); Real Tijll = T(i,jll); return (Tijll - Tij) / (1.0 + tJ[i][_l1] * tJ[i][_l2] * M[i][_l1] * M[i][_l2] + tJ[i][_l1] * M[i][_l1] * Tijll + tJ[i][_l2] * M[i][_l2] * Tijll); } Real MR::Gamma(size_t i, size_t _l1, size_t _l2) { sub_nb ll(G.nb(i).size()); Real Ti = T(i,ll); ll.set(_l1); ll.set(_l2); Real Till = T(i,ll); return (Till - Ti) / (1.0 + tJ[i][_l1] * tJ[i][_l2] * M[i][_l1] * M[i][_l2] + tJ[i][_l1] * M[i][_l1] * Till + tJ[i][_l2] * M[i][_l2] * Till); } Real MR::_tJ(size_t i, sub_nb A) { sub_nb::size_type _j = A.find_first(); if( _j == sub_nb::npos ) return 1.0; else return tJ[i][_j] * _tJ(i, A.reset(_j)); } Real MR::appM(size_t i, sub_nb A) { sub_nb::size_type _j = A.find_first(); if( _j == sub_nb::npos ) return 1.0; else { sub_nb A_j(A); A_j.reset(_j); Real result = M[i][_j] * appM(i, A_j); for( size_t _k = 0; _k < A_j.size(); _k++ ) if( A_j.test(_k) ) { sub_nb A_jk(A_j); A_jk.reset(_k); result += cors[i][_j][_k] * appM(i,A_jk); } return result; } } void MR::sum_subs(size_t j, sub_nb A, Real *sum_even, Real *sum_odd) { *sum_even = 0.0; *sum_odd = 0.0; sub_nb B(A.size()); do { if( B.count() % 2 ) *sum_odd += _tJ(j,B) * appM(j,B); else *sum_even += _tJ(j,B) * appM(j,B); // calc next subset B size_t bit = 0; for( ; bit < A.size(); bit++ ) if( A.test(bit) ) { if( B.test(bit) ) B.reset(bit); else { B.set(bit); break; } } } while (!B.none()); } void MR::propagateCavityFields() { Real sum_even, sum_odd; Real maxdev; size_t maxruns = 1000; for( size_t i = 0; i < G.nrNodes(); i++ ) foreach( const Neighbor &j, G.nb(i) ) M[i][j.iter] = 0.1; size_t run=0; do { maxdev=0.0; run++; for( size_t i = 0; i < G.nrNodes(); i++ ) { foreach( const Neighbor &j, G.nb(i) ) { size_t _j = j.iter; size_t _i = G.findNb(j,i); DAI_ASSERT( G.nb(j,_i) == i ); Real newM = 0.0; if( props.updates == Properties::UpdateType::FULL ) { // find indices in nb(j) that do not correspond with i sub_nb _nbj_min_i(G.nb(j).size()); _nbj_min_i.set(); _nbj_min_i.reset(_i); // find indices in nb(i) that do not correspond with j sub_nb _nbi_min_j(G.nb(i).size()); _nbi_min_j.set(); _nbi_min_j.reset(_j); sum_subs(j, _nbj_min_i, &sum_even, &sum_odd); newM = (tanh(theta[j]) * sum_even + sum_odd) / (sum_even + tanh(theta[j]) * sum_odd); sum_subs(i, _nbi_min_j, &sum_even, &sum_odd); Real denom = sum_even + tanh(theta[i]) * sum_odd; Real numer = 0.0; for(size_t _k=0; _k < G.nb(i).size(); _k++) if(_k != _j) { sub_nb _nbi_min_jk(_nbi_min_j); _nbi_min_jk.reset(_k); sum_subs(i, _nbi_min_jk, &sum_even, &sum_odd); numer += tJ[i][_k] * cors[i][_j][_k] * (tanh(theta[i]) * sum_even + sum_odd); } newM -= numer / denom; } else if( props.updates == Properties::UpdateType::LINEAR ) { newM = T(j,_i); for(size_t _l=0; _l= maxdev ) maxdev = abs(dev); newM = M[i][_j] + dev; if( abs(newM) > 1.0 ) newM = (newM > 0.0) ? 1.0 : -1.0; M[i][_j] = newM; } } } while((maxdev>props.tol)&&(run _maxdiff ) _maxdiff = maxdev; if(run==maxruns){ if( props.verbose >= 1 ) cerr << "MR::propagateCavityFields: Convergence not reached (maxdev=" << maxdev << ")..." << endl; } } void MR::calcMagnetizations() { for( size_t i = 0; i < G.nrNodes(); i++ ) { if( props.updates == Properties::UpdateType::FULL ) { // find indices in nb(i) sub_nb _nbi( G.nb(i).size() ); _nbi.set(); // calc numerator1 and denominator1 Real sum_even, sum_odd; sum_subs(i, _nbi, &sum_even, &sum_odd); Mag[i] = (tanh(theta[i]) * sum_even + sum_odd) / (sum_even + tanh(theta[i]) * sum_odd); } else if( props.updates == Properties::UpdateType::LINEAR ) { sub_nb empty( G.nb(i).size() ); Mag[i] = T(i,empty); for( size_t _l1 = 0; _l1 < G.nb(i).size(); _l1++ ) for( size_t _l2 = _l1 + 1; _l2 < G.nb(i).size(); _l2++ ) Mag[i] += Gamma(i,_l1,_l2) * tJ[i][_l1] * tJ[i][_l2] * cors[i][_l1][_l2]; } if( abs( Mag[i] ) > 1.0 ) Mag[i] = (Mag[i] > 0.0) ? 1.0 : -1.0; } } Real MR::calcCavityCorrelations() { Real md = 0.0; for( size_t i = 0; i < nrVars(); i++ ) { vector pairq; if( props.inits == Properties::InitType::EXACT ) { JTree jtcav(*this, PropertySet()("updates", string("HUGIN"))("verbose", (size_t)0) ); jtcav.makeCavity( i ); pairq = calcPairBeliefs( jtcav, delta(i), false, true ); } else if( props.inits == Properties::InitType::CLAMPING ) { BP bpcav(*this, PropertySet()("updates", string("SEQMAX"))("tol", (Real)1.0e-9)("maxiter", (size_t)10000)("verbose", (size_t)0)("logdomain", false)); bpcav.makeCavity( i ); pairq = calcPairBeliefs( bpcav, delta(i), false, true ); md = std::max( md, bpcav.maxDiff() ); } else if( props.inits == Properties::InitType::RESPPROP ) { BP bpcav(*this, PropertySet()("updates", string("SEQMAX"))("tol", (Real)1.0e-9)("maxiter", (size_t)10000)("verbose", (size_t)0)("logdomain", false)); bpcav.makeCavity( i ); bpcav.makeCavity( i ); bpcav.init(); bpcav.run(); BBP bbp( &bpcav, PropertySet()("verbose",(size_t)0)("tol",(Real)1.0e-9)("maxiter",(size_t)10000)("damping",(Real)0.0)("updates",string("SEQ_MAX")) ); foreach( const Neighbor &j, G.nb(i) ) { // Create weights for magnetization of some spin Prob p( 2, 0.0 ); p.set( 0, -1.0 ); p.set( 1, 1.0 ); // BBP cost function would be the magnetization of spin j vector b1_adj; b1_adj.reserve( nrVars() ); for( size_t l = 0; l < nrVars(); l++ ) if( l == j ) b1_adj.push_back( p ); else b1_adj.push_back( Prob( 2, 0.0 ) ); bbp.init_V( b1_adj ); // run BBP to estimate adjoints bbp.run(); foreach( const Neighbor &k, G.nb(i) ) { if( k != j ) cors[i][j.iter][k.iter] = (bbp.adj_psi_V(k)[1] - bbp.adj_psi_V(k)[0]); else cors[i][j.iter][k.iter] = 0.0; } } } if( props.inits != Properties::InitType::RESPPROP ) { for( size_t jk = 0; jk < pairq.size(); jk++ ) { VarSet::const_iterator kit = pairq[jk].vars().begin(); size_t j = findVar( *(kit) ); size_t k = findVar( *(++kit) ); pairq[jk].normalize(); Real cor = (pairq[jk][3] - pairq[jk][2] - pairq[jk][1] + pairq[jk][0]) - (pairq[jk][3] + pairq[jk][2] - pairq[jk][1] - pairq[jk][0]) * (pairq[jk][3] - pairq[jk][2] + pairq[jk][1] - pairq[jk][0]); size_t _j = G.findNb(i,j); size_t _k = G.findNb(i,k); cors[i][_j][_k] = cor; cors[i][_k][_j] = cor; } } } return md; } string MR::identify() const { return string(Name) + printProperties(); } Real MR::run() { if( supported ) { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; double tic = toc(); // approximate correlations of cavity spins Real md = calcCavityCorrelations(); if( md > _maxdiff ) _maxdiff = md; // solve messages propagateCavityFields(); // calculate magnetizations calcMagnetizations(); if( props.verbose >= 1 ) cerr << Name << " needed " << toc() - tic << " seconds." << endl; return _maxdiff; } else return 1.0; } Factor MR::beliefV( size_t i ) const { if( supported ) { Real x[2]; x[0] = 0.5 - Mag[i] / 2.0; x[1] = 0.5 + Mag[i] / 2.0; return Factor( var(i), x ); } else return Factor(); } Factor MR::belief (const VarSet &ns) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) return beliefV( findVar( *(ns.begin()) ) ); else { DAI_THROW(BELIEF_NOT_AVAILABLE); return Factor(); } } vector MR::beliefs() const { vector result; for( size_t i = 0; i < nrVars(); i++ ) result.push_back( beliefV( i ) ); return result; } MR::MR( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), supported(true), _maxdiff(0.0), _iters(0) { setProperties( opts ); size_t N = fg.nrVars(); // check whether all vars in fg are binary for( size_t i = 0; i < N; i++ ) if( (fg.var(i).states() > 2) ) { supported = false; break; } if( !supported ) DAI_THROWE(NOT_IMPLEMENTED,"MR only supports binary variables"); // check whether all interactions are pairwise or single // and construct Markov graph G = GraphAL(N); for( size_t I = 0; I < fg.nrFactors(); I++ ) { const Factor &psi = fg.factor(I); if( psi.vars().size() > 2 ) { supported = false; break; } else if( psi.vars().size() == 2 ) { VarSet::const_iterator jit = psi.vars().begin(); size_t i = fg.findVar( *(jit) ); size_t j = fg.findVar( *(++jit) ); G.addEdge( i, j, false ); } } if( !supported ) DAI_THROWE(NOT_IMPLEMENTED,"MR does not support higher order interactions (only single and pairwise are supported)"); // construct theta theta.clear(); theta.resize( N, 0.0 ); // construct tJ tJ.resize( N ); for( size_t i = 0; i < N; i++ ) tJ[i].resize( G.nb(i).size(), 0.0 ); // initialize theta and tJ for( size_t I = 0; I < fg.nrFactors(); I++ ) { const Factor &psi = fg.factor(I); if( psi.vars().size() == 1 ) { size_t i = fg.findVar( *(psi.vars().begin()) ); theta[i] += 0.5 * log(psi[1] / psi[0]); } else if( psi.vars().size() == 2 ) { VarSet::const_iterator jit = psi.vars().begin(); size_t i = fg.findVar( *(jit) ); size_t j = fg.findVar( *(++jit) ); Real w_ij = 0.25 * log(psi[3] * psi[0] / (psi[2] * psi[1])); tJ[i][G.findNb(i,j)] += w_ij; tJ[j][G.findNb(j,i)] += w_ij; theta[i] += 0.25 * log(psi[3] / psi[2] * psi[1] / psi[0]); theta[j] += 0.25 * log(psi[3] / psi[1] * psi[2] / psi[0]); } } for( size_t i = 0; i < N; i++ ) foreach( const Neighbor &j, G.nb(i) ) tJ[i][j.iter] = tanh( tJ[i][j.iter] ); // construct M M.resize( N ); for( size_t i = 0; i < N; i++ ) M[i].resize( G.nb(i).size() ); // construct cors cors.resize( N ); for( size_t i = 0; i < N; i++ ) cors[i].resize( G.nb(i).size() ); for( size_t i = 0; i < N; i++ ) for( size_t _j = 0; _j < cors[i].size(); _j++ ) cors[i][_j].resize( G.nb(i).size() ); // construct Mag Mag.resize( N ); } } // end of namespace dai libDAI-0.2.7/src/factorgraph.cpp0000644000263000017630000003702211433220722015253 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include #include #include #include #include #include #include #include namespace dai { using namespace std; FactorGraph::FactorGraph( const std::vector &P ) : _G(), _backup() { // add factors, obtain variables set varset; _factors.reserve( P.size() ); size_t nrEdges = 0; for( vector::const_iterator p2 = P.begin(); p2 != P.end(); p2++ ) { _factors.push_back( *p2 ); copy( p2->vars().begin(), p2->vars().end(), inserter( varset, varset.begin() ) ); nrEdges += p2->vars().size(); } // add vars _vars.reserve( varset.size() ); for( set::const_iterator p1 = varset.begin(); p1 != varset.end(); p1++ ) _vars.push_back( *p1 ); // create graph structure constructGraph( nrEdges ); } void FactorGraph::constructGraph( size_t nrEdges ) { // create a mapping for indices hash_map hashmap; for( size_t i = 0; i < vars().size(); i++ ) hashmap[var(i).label()] = i; // create edge list vector edges; edges.reserve( nrEdges ); for( size_t i2 = 0; i2 < nrFactors(); i2++ ) { const VarSet& ns = factor(i2).vars(); for( VarSet::const_iterator q = ns.begin(); q != ns.end(); q++ ) edges.push_back( Edge(hashmap[q->label()], i2) ); } // create bipartite graph _G.construct( nrVars(), nrFactors(), edges.begin(), edges.end() ); } /// Writes a FactorGraph to an output stream std::ostream& operator<< ( std::ostream &os, const FactorGraph &fg ) { os << fg.nrFactors() << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) { os << endl; os << fg.factor(I).vars().size() << endl; for( VarSet::const_iterator i = fg.factor(I).vars().begin(); i != fg.factor(I).vars().end(); i++ ) os << i->label() << " "; os << endl; for( VarSet::const_iterator i = fg.factor(I).vars().begin(); i != fg.factor(I).vars().end(); i++ ) os << i->states() << " "; os << endl; size_t nr_nonzeros = 0; for( size_t k = 0; k < fg.factor(I).nrStates(); k++ ) if( fg.factor(I)[k] != (Real)0 ) nr_nonzeros++; os << nr_nonzeros << endl; for( size_t k = 0; k < fg.factor(I).nrStates(); k++ ) if( fg.factor(I)[k] != (Real)0 ) os << k << " " << setw(os.precision()+4) << fg.factor(I)[k] << endl; } return(os); } /// Reads a FactorGraph from an input stream std::istream& operator>> ( std::istream& is, FactorGraph &fg ) { long verbose = 0; vector facs; size_t nr_Factors; string line; while( (is.peek()) == '#' ) getline(is,line); is >> nr_Factors; if( is.fail() ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read number of factors"); if( verbose >= 2 ) cerr << "Reading " << nr_Factors << " factors..." << endl; getline (is,line); if( is.fail() || line.size() > 0 ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Expecting empty line"); map vardims; for( size_t I = 0; I < nr_Factors; I++ ) { if( verbose >= 3 ) cerr << "Reading factor " << I << "..." << endl; size_t nr_members; while( (is.peek()) == '#' ) getline(is,line); is >> nr_members; if( verbose >= 3 ) cerr << " nr_members: " << nr_members << endl; vector labels; for( size_t mi = 0; mi < nr_members; mi++ ) { long mi_label; while( (is.peek()) == '#' ) getline(is,line); is >> mi_label; labels.push_back(mi_label); } if( verbose >= 3 ) cerr << " labels: " << labels << endl; vector dims; for( size_t mi = 0; mi < nr_members; mi++ ) { size_t mi_dim; while( (is.peek()) == '#' ) getline(is,line); is >> mi_dim; dims.push_back(mi_dim); } if( verbose >= 3 ) cerr << " dimensions: " << dims << endl; // add the Factor vector Ivars; Ivars.reserve( nr_members ); for( size_t mi = 0; mi < nr_members; mi++ ) { map::iterator vdi = vardims.find( labels[mi] ); if( vdi != vardims.end() ) { // check whether dimensions are consistent if( vdi->second != dims[mi] ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Variable with label " + boost::lexical_cast(labels[mi]) + " has inconsistent dimensions."); } else vardims[labels[mi]] = dims[mi]; Ivars.push_back( Var(labels[mi], dims[mi]) ); } facs.push_back( Factor( VarSet( Ivars.begin(), Ivars.end(), Ivars.size() ), (Real)0 ) ); // calculate permutation object Permute permindex( Ivars ); // read values size_t nr_nonzeros; while( (is.peek()) == '#' ) getline(is,line); is >> nr_nonzeros; if( verbose >= 3 ) cerr << " nonzeroes: " << nr_nonzeros << endl; for( size_t k = 0; k < nr_nonzeros; k++ ) { size_t li; Real val; while( (is.peek()) == '#' ) getline(is,line); is >> li; while( (is.peek()) == '#' ) getline(is,line); is >> val; // store value, but permute indices first according to internal representation facs.back().set( permindex.convertLinearIndex( li ), val ); } } if( verbose >= 3 ) cerr << "factors:" << facs << endl; fg = FactorGraph(facs); return is; } VarSet FactorGraph::Delta( size_t i ) const { // calculate Markov Blanket VarSet Del; foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i foreach( const Neighbor &j, nbF(I) ) // for all neighboring variables j of I Del |= var(j); return Del; } VarSet FactorGraph::Delta( const VarSet &ns ) const { VarSet result; for( VarSet::const_iterator n = ns.begin(); n != ns.end(); n++ ) result |= Delta( findVar(*n) ); return result; } void FactorGraph::makeCavity( size_t i, bool backup ) { // fills all Factors that include var(i) with ones map newFacs; foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i newFacs[I] = Factor( factor(I).vars(), (Real)1 ); setFactors( newFacs, backup ); } void FactorGraph::ReadFromFile( const char *filename ) { ifstream infile; infile.open( filename ); if( infile.is_open() ) { infile >> *this; infile.close(); } else DAI_THROWE(CANNOT_READ_FILE,"Cannot read from file " + std::string(filename)); } void FactorGraph::WriteToFile( const char *filename, size_t precision ) const { ofstream outfile; outfile.open( filename ); if( outfile.is_open() ) { outfile.precision( precision ); outfile << *this; outfile.close(); } else DAI_THROWE(CANNOT_WRITE_FILE,"Cannot write to file " + std::string(filename)); } void FactorGraph::printDot( std::ostream &os ) const { os << "graph FactorGraph {" << endl; os << "node[shape=circle,width=0.4,fixedsize=true];" << endl; for( size_t i = 0; i < nrVars(); i++ ) os << "\tv" << var(i).label() << ";" << endl; os << "node[shape=box,width=0.3,height=0.3,fixedsize=true];" << endl; for( size_t I = 0; I < nrFactors(); I++ ) os << "\tf" << I << ";" << endl; for( size_t i = 0; i < nrVars(); i++ ) foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i os << "\tv" << var(i).label() << " -- f" << I << ";" << endl; os << "}" << endl; } GraphAL FactorGraph::MarkovGraph() const { GraphAL G( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) foreach( const Neighbor &I, nbV(i) ) foreach( const Neighbor &j, nbF(I) ) if( i < j ) G.addEdge( i, j, true ); return G; } bool FactorGraph::isMaximal( size_t I ) const { const VarSet& I_vars = factor(I).vars(); size_t I_size = I_vars.size(); if( I_size == 0 ) { for( size_t J = 0; J < nrFactors(); J++ ) if( J != I ) if( factor(J).vars().size() > 0 ) return false; return true; } else { foreach( const Neighbor& i, nbF(I) ) { foreach( const Neighbor& J, nbV(i) ) { if( J != I ) if( (factor(J).vars() >> I_vars) && (factor(J).vars().size() != I_size) ) return false; } } return true; } } size_t FactorGraph::maximalFactor( size_t I ) const { const VarSet& I_vars = factor(I).vars(); size_t I_size = I_vars.size(); if( I_size == 0 ) { for( size_t J = 0; J < nrFactors(); J++ ) if( J != I ) if( factor(J).vars().size() > 0 ) return maximalFactor( J ); return I; } else { foreach( const Neighbor& i, nbF(I) ) { foreach( const Neighbor& J, nbV(i) ) { if( J != I ) if( (factor(J).vars() >> I_vars) && (factor(J).vars().size() != I_size) ) return maximalFactor( J ); } } return I; } } vector FactorGraph::maximalFactorDomains() const { vector result; for( size_t I = 0; I < nrFactors(); I++ ) if( isMaximal( I ) ) result.push_back( factor(I).vars() ); if( result.size() == 0 ) result.push_back( VarSet() ); return result; } Real FactorGraph::logScore( const std::vector& statevec ) { // Construct a State object that represents statevec // This decouples the representation of the joint state in statevec from the factor graph map statemap; for( size_t i = 0; i < statevec.size(); i++ ) statemap[var(i)] = statevec[i]; State S(statemap); // Evaluate the log probability of the joint configuration in statevec // by summing the log factor entries of the factors that correspond to this joint configuration Real lS = 0.0; for( size_t I = 0; I < nrFactors(); I++ ) lS += dai::log( factor(I)[S(factor(I).vars())] ); return lS; } void FactorGraph::clamp( size_t i, size_t x, bool backup ) { DAI_ASSERT( x <= var(i).states() ); Factor mask( var(i), (Real)0 ); mask.set( x, (Real)1 ); map newFacs; foreach( const Neighbor &I, nbV(i) ) newFacs[I] = factor(I) * mask; setFactors( newFacs, backup ); return; } void FactorGraph::clampVar( size_t i, const vector &is, bool backup ) { Var n = var(i); Factor mask_n( n, (Real)0 ); foreach( size_t i, is ) { DAI_ASSERT( i <= n.states() ); mask_n.set( i, (Real)1 ); } map newFacs; foreach( const Neighbor &I, nbV(i) ) newFacs[I] = factor(I) * mask_n; setFactors( newFacs, backup ); } void FactorGraph::clampFactor( size_t I, const vector &is, bool backup ) { size_t st = factor(I).nrStates(); Factor newF( factor(I).vars(), (Real)0 ); foreach( size_t i, is ) { DAI_ASSERT( i <= st ); newF.set( i, factor(I)[i] ); } setFactor( I, newF, backup ); } void FactorGraph::backupFactor( size_t I ) { map::iterator it = _backup.find( I ); if( it != _backup.end() ) DAI_THROW(MULTIPLE_UNDO); _backup[I] = factor(I); } void FactorGraph::restoreFactor( size_t I ) { map::iterator it = _backup.find( I ); if( it != _backup.end() ) { setFactor(I, it->second); _backup.erase(it); } else DAI_THROW(OBJECT_NOT_FOUND); } void FactorGraph::backupFactors( const VarSet &ns ) { for( size_t I = 0; I < nrFactors(); I++ ) if( factor(I).vars().intersects( ns ) ) backupFactor( I ); } void FactorGraph::restoreFactors( const VarSet &ns ) { map facs; for( map::iterator uI = _backup.begin(); uI != _backup.end(); ) { if( factor(uI->first).vars().intersects( ns ) ) { facs.insert( *uI ); _backup.erase(uI++); } else uI++; } setFactors( facs ); } void FactorGraph::restoreFactors() { setFactors( _backup ); _backup.clear(); } void FactorGraph::backupFactors( const std::set & facs ) { for( std::set::const_iterator fac = facs.begin(); fac != facs.end(); fac++ ) backupFactor( *fac ); } bool FactorGraph::isPairwise() const { bool pairwise = true; for( size_t I = 0; I < nrFactors() && pairwise; I++ ) if( factor(I).vars().size() > 2 ) pairwise = false; return pairwise; } bool FactorGraph::isBinary() const { bool binary = true; for( size_t i = 0; i < nrVars() && binary; i++ ) if( var(i).states() > 2 ) binary = false; return binary; } FactorGraph FactorGraph::clamped( size_t i, size_t state ) const { Var v = var( i ); Real zeroth_order = (Real)1; vector clamped_facs; clamped_facs.push_back( createFactorDelta( v, state ) ); for( size_t I = 0; I < nrFactors(); I++ ) { VarSet v_I = factor(I).vars(); Factor new_factor; if( v_I.intersects( v ) ) new_factor = factor(I).slice( v, state ); else new_factor = factor(I); if( new_factor.vars().size() != 0 ) { size_t J = 0; // if it can be merged with a previous one, do that for( J = 0; J < clamped_facs.size(); J++ ) if( clamped_facs[J].vars() == new_factor.vars() ) { clamped_facs[J] *= new_factor; break; } // otherwise, push it back if( J == clamped_facs.size() || clamped_facs.size() == 0 ) clamped_facs.push_back( new_factor ); } else zeroth_order *= new_factor[0]; } *(clamped_facs.begin()) *= zeroth_order; return FactorGraph( clamped_facs ); } FactorGraph FactorGraph::maximalFactors() const { vector maxfac( nrFactors() ); map newindex; size_t nrmax = 0; for( size_t I = 0; I < nrFactors(); I++ ) { maxfac[I] = I; VarSet maxfacvars = factor(maxfac[I]).vars(); for( size_t J = 0; J < nrFactors(); J++ ) { VarSet Jvars = factor(J).vars(); if( Jvars >> maxfacvars && (Jvars != maxfacvars) ) { maxfac[I] = J; maxfacvars = factor(maxfac[I]).vars(); } } if( maxfac[I] == I ) newindex[I] = nrmax++; } vector facs( nrmax ); for( size_t I = 0; I < nrFactors(); I++ ) facs[newindex[maxfac[I]]] *= factor(I); return FactorGraph( facs.begin(), facs.end(), vars().begin(), vars().end(), facs.size(), nrVars() ); } } // end of namespace dai libDAI-0.2.7/src/dag.cpp0000644000263000017630000002074311433220723013511 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include namespace dai { using namespace std; DAG& DAG::addEdge( size_t n1, size_t n2, bool check ) { DAI_ASSERT( n1 < nrNodes() ); DAI_ASSERT( n2 < nrNodes() ); bool allowed = true; if( check ) { // Check whether the edge already exists foreach( const Neighbor& n, ch(n1) ) if( n == n2 ) { allowed = false; break; } // Check whether there exists a directed path from n2 to n1 already if( allowed && existsDirectedPath( n2, n1 ) ) allowed = false; } if( allowed && n1 != n2 ) { // Add edge Neighbor ch_1( ch(n1).size(), n2, pa(n2).size() ); Neighbor pa_2( ch_1.dual, n1, ch_1.iter ); ch(n1).push_back( ch_1 ); pa(n2).push_back( pa_2 ); } return *this; } void DAG::eraseNode( size_t n ) { DAI_ASSERT( n < nrNodes() ); // Erase parents entry of node n _pa.erase( _pa.begin() + n ); // Erase children entry of node n _ch.erase( _ch.begin() + n ); // Adjust parents and children entries of remaining nodes for( size_t m = 0; m < nrNodes(); m++ ) { // Adjust parents entries of node m for( size_t iter = 0; iter < pa(m).size(); ) { Neighbor &p = pa(m, iter); if( p.node == n ) { // delete this entry, because it points to the deleted node pa(m).erase( pa(m).begin() + iter ); } else { // update this entry and the corresponding dual of the child node if( p.node > n ) p.node--; ch( p.node, p.dual ).dual = iter; p.iter = iter++; } } // Adjust children entries of node m for( size_t iter = 0; iter < ch(m).size(); ) { Neighbor &c = ch(m, iter); if( c.node == n ) { // delete this entry, because it points to the deleted node ch(m).erase( ch(m).begin() + iter ); } else { if( c.node > n ) c.node--; // update this entry and the corresponding dual of the child node pa( c.node, c.dual ).dual = iter; c.iter = iter++; } } } } void DAG::eraseEdge( size_t n1, size_t n2 ) { DAI_ASSERT( n1 < nrNodes() ); DAI_ASSERT( n2 < nrNodes() ); size_t iter; // Search for edge among children of n1 for( iter = 0; iter < ch(n1).size(); iter++ ) if( ch(n1, iter).node == n2 ) { // Remove it ch(n1).erase( ch(n1).begin() + iter ); break; } // Change the iter and dual values of the subsequent children for( ; iter < ch(n1).size(); iter++ ) { Neighbor &m = ch( n1, iter ); m.iter = iter; pa( m.node, m.dual ).dual = iter; } // Search for edge among parents of n2 for( iter = 0; iter < pa(n2).size(); iter++ ) if( pa(n2, iter).node == n1 ) { // Remove it pa(n2).erase( pa(n2).begin() + iter ); break; } // Change the iter and node values of the subsequent parents for( ; iter < pa(n2).size(); iter++ ) { Neighbor &m = pa( n2, iter ); m.iter = iter; ch( m.node, m.dual ).dual = iter; } } SmallSet DAG::paSet( size_t n ) const { SmallSet result; foreach( const Neighbor &p, pa(n) ) result |= p; return result; } SmallSet DAG::chSet( size_t n ) const { SmallSet result; foreach( const Neighbor &c, ch(n) ) result |= c; return result; } /// Returns the set of ancestors of node \a n, i.e., all nodes \a m such that there exists a directed path from \a m to \a n (excluding \a n itself) std::set DAG::ancestors( size_t n ) const { set anc; set curParents; curParents.insert( n ); while( curParents.size() ) { size_t node = *(curParents.begin()); // Add node to ancestors if( node != n ) anc.insert( node ); // Add all parents of node to curParents foreach( const Neighbor& p, pa(node) ) curParents.insert( p.node ); // Erase node from curParents curParents.erase( node ); } return anc; } /// Returns the set of descendants of node \a n, i.e., all nodes \a m such that there exists a directed path from \a n to \a m (excluding \a n itself) std::set DAG::descendants( size_t n ) const { set desc; set curChildren; curChildren.insert( n ); while( curChildren.size() ) { size_t node = *(curChildren.begin()); // Add node to descendants if( node != n ) desc.insert( node ); // Add all children of node to curChildren foreach( const Neighbor& c, ch(node) ) curChildren.insert( c.node ); // Erase node from curChildren curChildren.erase( node ); } return desc; } bool DAG::existsDirectedPath( size_t n1, size_t n2 ) const { set curChildren; curChildren.insert( n1 ); while( curChildren.size() ) { size_t node = *(curChildren.begin()); // If we reached n2, we found a directed path from n1 to n2 if( node == n2 ) return true; // Add all children of node to curChildren foreach( const Neighbor& c, ch(node) ) curChildren.insert( c.node ); // Erase node from curChildren curChildren.erase( node ); } return false; } bool DAG::isConnected() const { if( nrNodes() == 0 ) { return true; } else { std::vector incomponent( nrNodes(), false ); incomponent[0] = true; bool found_new_nodes; do { found_new_nodes = false; // For all nodes, check if they are connected with the (growing) component for( size_t n1 = 0; n1 < nrNodes(); n1++ ) { if( !incomponent[n1] ) { foreach( const Neighbor &n2, pa(n1) ) if( incomponent[n2] ) { found_new_nodes = true; incomponent[n1] = true; break; } } if( !incomponent[n1] ) { foreach( const Neighbor &n2, ch(n1) ) if( incomponent[n2] ) { found_new_nodes = true; incomponent[n1] = true; break; } } } } while( found_new_nodes ); // Check if there are remaining nodes (not in the component) bool all_connected = true; for( size_t n1 = 0; (n1 < nrNodes()) && all_connected; n1++ ) if( !incomponent[n1] ) all_connected = false; return all_connected; } } void DAG::printDot( std::ostream& os ) const { os << "digraph DAG {" << endl; os << "node[shape=circle,width=0.4,fixedsize=true];" << endl; for( size_t n = 0; n < nrNodes(); n++ ) os << "\tx" << n << ";" << endl; for( size_t n1 = 0; n1 < nrNodes(); n1++ ) foreach( const Neighbor &n2, ch(n1) ) os << "\tx" << n1 << " -> x" << n2 << ";" << endl; os << "}" << endl; } void DAG::checkConsistency() const { size_t N = nrNodes(); for( size_t n1 = 0; n1 < N; n1++ ) { size_t iter = 0; foreach( const Neighbor &n2, pa(n1) ) { DAI_ASSERT( n2.iter == iter ); DAI_ASSERT( n2.node < N ); DAI_ASSERT( n2.dual < ch(n2).size() ); DAI_ASSERT( ch(n2, n2.dual) == n1 ); iter++; } iter = 0; foreach( const Neighbor &n2, ch(n1) ) { DAI_ASSERT( n2.iter == iter ); DAI_ASSERT( n2.node < N ); DAI_ASSERT( n2.dual < pa(n2).size() ); DAI_ASSERT( pa(n2, n2.dual) == n1 ); iter++; } } // Check acyclicity for( size_t n1 = 0; n1 < N; n1++ ) foreach( const Neighbor& n2, ch(n1) ) DAI_ASSERT( !existsDirectedPath( n2, n1 ) ); } } // end of namespace dai libDAI-0.2.7/src/properties.cpp0000644000263000017630000000656411433220723015157 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include namespace dai { std::ostream& operator<< (std::ostream & os, const Property & p) { os << p.first << "="; if( p.second.type() == typeid(size_t) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(int) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(std::string) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(double) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(long double) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(bool) ) os << boost::any_cast(p.second); else if( p.second.type() == typeid(PropertySet) ) os << boost::any_cast(p.second); else DAI_THROW(UNKNOWN_PROPERTY_TYPE); return( os ); } /// Writes a PropertySet object to an output stream std::ostream& operator<< (std::ostream & os, const PropertySet & ps) { os << "["; for( PropertySet::const_iterator p = ps.begin(); p != ps.end(); p++ ) { if( p != ps.begin() ) os << ","; os << (Property)*p; } os << "]"; return os; } /// Reads a PropertySet object from an input stream, storing values as strings std::istream& operator>> (std::istream& is, PropertySet & ps) { ps = PropertySet(); std::string s; is >> s; // Check whether s is of the form "[.*]" if( (s.length() < 2) || (s.at(0) != '[') || (s.at(s.length()-1)) != ']' ) DAI_THROWE(MALFORMED_PROPERTY,"Malformed PropertySet: " + s); size_t N = s.length() - 1; for( size_t token_start = 1; token_start < N; ) { size_t token_end; // scan until '=' is found for( token_end = token_start + 1; token_end < N; token_end++ ) if( s[token_end] == '=' ) break; // we found a key std::string key = s.substr(token_start, token_end - token_start); if( token_end == N ) DAI_THROWE(MALFORMED_PROPERTY,"Malformed Property: " + key); token_start = token_end + 1; // scan until matching ',' is found int level = 0; for( token_end = token_start; token_end < N; token_end++ ) { if( s[token_end] == '[' ) level++; else if( s[token_end] == ']' ) level--; else if( (s[token_end] == ',') && (level == 0) ) break; } if( !(level == 0) ) DAI_THROWE(MALFORMED_PROPERTY,"Malformed Property: " + s.substr(token_start, token_end - token_start)); // we found a vlue std::string value = s.substr(token_start, token_end - token_start); // store the key,value pair ps.set(key,value); // go on with the next one token_start = token_end + 1; } return is; } } // end of namespace dai libDAI-0.2.7/src/weightedgraph.cpp0000644000263000017630000000475611433220723015606 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include namespace dai { using namespace std; RootedTree::RootedTree( const GraphEL &T, size_t Root ) { if( T.size() != 0 ) { // Make a copy GraphEL Gr = T; // Nodes in the tree set nodes; // Check whether the root is in the tree bool valid = false; for( GraphEL::iterator e = Gr.begin(); e != Gr.end() && !valid; e++ ) if( e->first == Root || e->second == Root ) valid = true; if( !valid ) DAI_THROWE(RUNTIME_ERROR,"Graph does not contain specified root."); // Start with the root nodes.insert( Root ); // Keep adding edges until done bool done = false; while( !done ) { bool changed = false; for( GraphEL::iterator e = Gr.begin(); e != Gr.end(); ) { bool e1_in_nodes = nodes.count( e->first ); bool e2_in_nodes = nodes.count( e->second ); if( e1_in_nodes && e2_in_nodes ) DAI_THROWE(RUNTIME_ERROR,"Graph is not acyclic."); if( e1_in_nodes ) { // Add directed edge, pointing away from the root push_back( DEdge( e->first, e->second ) ); nodes.insert( e->second ); // Erase the edge Gr.erase( e++ ); changed = true; } else if( e2_in_nodes ) { // Add directed edge, pointing away from the root push_back( DEdge( e->second, e->first ) ); nodes.insert( e->first ); // Erase the edge Gr.erase( e++ ); changed = true; } else e++; } if( Gr.empty() ) done = true; if( !changed && !done ) DAI_THROWE(RUNTIME_ERROR,"Graph is not connected."); } } } } // end of namespace dai libDAI-0.2.7/src/matlab/0000755000263000017630000000000011433220723013504 5ustar jorismkyblibDAI-0.2.7/src/matlab/dai_readfg.cpp0000644000263000017630000000353411433220723016262 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include "mex.h" #include #include using namespace std; using namespace dai; /* Input Arguments */ #define FILENAME_IN prhs[0] #define NR_IN 1 /* Output Arguments */ #define PSI_OUT plhs[0] #define NR_OUT 1 void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[] ) { char *filename; // Check for proper number of arguments if ((nrhs != NR_IN) || (nlhs != NR_OUT)) { mexErrMsgTxt("Usage: [psi] = dai_readfg(filename);\n\n" "\n" "INPUT: filename = filename of a .fg file\n" "\n" "OUTPUT: psi = linear cell array containing the factors\n" " (psi{i} is a structure with a Member field\n" " and a P field, like a CPTAB).\n"); } // Get input parameters size_t buflen; buflen = mxGetN( FILENAME_IN ) + 1; filename = (char *)mxCalloc( buflen, sizeof(char) ); mxGetString( FILENAME_IN, filename, buflen ); // Read factorgraph FactorGraph fg; try { fg.ReadFromFile( filename ); } catch( std::exception &e ) { mexErrMsgTxt( e.what() ); } // Save factors vector psi; for( size_t I = 0; I < fg.nrFactors(); I++ ) psi.push_back(fg.factor(I)); // Hand over results to MATLAB PSI_OUT = Factors2mx(psi); return; } libDAI-0.2.7/src/matlab/dai.cpp0000644000263000017630000001112611433220723014746 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include "mex.h" #include #include #include using namespace std; using namespace dai; /* Input Arguments */ #define PSI_IN prhs[0] #define METHOD_IN prhs[1] #define OPTS_IN prhs[2] #define NR_IN 3 #define NR_IN_OPT 0 /* Output Arguments */ #define LOGZ_OUT plhs[0] #define Q_OUT plhs[1] #define MD_OUT plhs[2] #define QV_OUT plhs[3] #define QF_OUT plhs[4] #define QMAP_OUT plhs[5] #define NR_OUT 3 #define NR_OUT_OPT 3 void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[] ) { size_t buflen; // Check for proper number of arguments if( ((nrhs < NR_IN) || (nrhs > NR_IN + NR_IN_OPT)) || ((nlhs < NR_OUT) || (nlhs > NR_OUT + NR_OUT_OPT)) ) { mexErrMsgTxt("Usage: [logZ,q,md,qv,qf,qmap] = dai(psi,method,opts)\n\n" "\n" "INPUT: psi = linear cell array containing the factors\n" " (psi{i} should be a structure with a Member field\n" " and a P field).\n" " method = name of the method\n" " opts = string of options\n" "\n" "OUTPUT: logZ = approximation of the logarithm of the partition sum.\n" " q = linear cell array containing all final beliefs.\n" " md = maxdiff (final linf-dist between new and old single node beliefs).\n" " qv = linear cell array containing all variable beliefs.\n" " qf = linear cell array containing all factor beliefs.\n" " qmap = linear array containing the MAP state (only for BP,JTree).\n"); } char *method; char *opts; // Get psi and construct factorgraph vector factors = mx2Factors(PSI_IN, 0); FactorGraph fg(factors); // Get method buflen = mxGetN( METHOD_IN ) + 1; method = (char *)mxCalloc( buflen, sizeof(char) ); mxGetString( METHOD_IN, method, buflen ); // Get options string buflen = mxGetN( OPTS_IN ) + 1; opts = (char *)mxCalloc( buflen, sizeof(char) ); mxGetString( OPTS_IN, opts, buflen ); // Convert to options object props stringstream ss; ss << opts; PropertySet props; ss >> props; // Construct InfAlg object, init and run InfAlg *obj = newInfAlg( method, fg, props ); obj->init(); obj->run(); // Save logZ double logZ = obj->logZ(); // Save maxdiff double maxdiff = obj->maxDiff(); // Hand over results to MATLAB LOGZ_OUT = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(LOGZ_OUT)) = logZ; Q_OUT = Factors2mx(obj->beliefs()); MD_OUT = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(MD_OUT)) = maxdiff; if( nlhs >= 4 ) { vector qv; qv.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) qv.push_back( obj->belief( fg.var(i) ) ); QV_OUT = Factors2mx( qv ); } if( nlhs >= 5 ) { vector qf; qf.reserve( fg.nrFactors() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) qf.push_back( obj->belief( fg.factor(I).vars() ) ); QF_OUT = Factors2mx( qf ); } if( nlhs >= 6 ) { std::vector map_state; if( obj->identify() == "BP" ) { BP* obj_bp = dynamic_cast(obj); DAI_ASSERT( obj_bp != 0 ); map_state = obj_bp->findMaximum(); } else if( obj->identify() == "JTREE" ) { JTree* obj_jtree = dynamic_cast(obj); DAI_ASSERT( obj_jtree != 0 ); map_state = obj_jtree->findMaximum(); } else { mexErrMsgTxt("MAP state assignment works only for BP, JTree.\n"); delete obj; return; } QMAP_OUT = mxCreateNumericMatrix(map_state.size(), 1, mxUINT32_CLASS, mxREAL); uint32_T* qmap_p = reinterpret_cast(mxGetPr(QMAP_OUT)); for (size_t n = 0; n < map_state.size(); ++n) qmap_p[n] = map_state[n]; } delete obj; return; } libDAI-0.2.7/src/matlab/dai_writefg.cpp0000644000263000017630000000332011433220723016472 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include "mex.h" #include #include using namespace std; using namespace dai; /* Input Arguments */ #define PSI_IN prhs[0] #define FILENAME_IN prhs[1] #define NR_IN 2 /* Output Arguments */ #define NR_OUT 0 void mexFunction( int nlhs, mxArray * /*plhs*/[], int nrhs, const mxArray*prhs[] ) { char *filename; // Check for proper number of arguments if ((nrhs != NR_IN) || (nlhs != NR_OUT)) { mexErrMsgTxt("Usage: dai_writefg(psi,filename);\n\n" "\n" "INPUT: psi = linear cell array containing the factors\n" " (psi{i} should be a structure with a Member field\n" " and a P field, like a CPTAB).\n" " filename = filename of a .fg file\n"); } // Get input parameters vector factors = mx2Factors(PSI_IN,0); size_t buflen; buflen = mxGetN( FILENAME_IN ) + 1; filename = (char *)mxCalloc( buflen, sizeof(char) ); mxGetString( FILENAME_IN, filename, buflen ); // Construct factorgraph FactorGraph fg(factors); try { fg.WriteToFile( filename ); } catch( std::exception &e ) { mexErrMsgTxt( e.what() ); } return; } libDAI-0.2.7/src/matlab/dai_potstrength.cpp0000644000263000017630000000431611433220723017412 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include "mex.h" #include #include using namespace std; using namespace dai; /* Input Arguments */ #define PSI_IN prhs[0] #define I_IN prhs[1] #define J_IN prhs[2] #define NR_IN 3 /* Output Arguments */ #define N_OUT plhs[0] #define NR_OUT 1 void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[] ) { size_t ilabel, jlabel; // Check for proper number of arguments if ((nrhs != NR_IN) || (nlhs != NR_OUT)) { mexErrMsgTxt("Usage: N = dai_potstrength(psi,i,j);\n\n" "\n" "INPUT: psi = structure with a Member field and a P field, like a CPTAB.\n" " i = label of a variable in psi.\n" " j = label of another variable in psi.\n" "\n" "OUTPUT: N = strength of psi in direction i->j.\n"); } // Get input parameters Factor psi = mx2Factor(PSI_IN); ilabel = (size_t)*mxGetPr(I_IN); jlabel = (size_t)*mxGetPr(J_IN); // Find variable in psi with label ilabel Var i; for( VarSet::const_iterator n = psi.vars().begin(); n != psi.vars().end(); n++ ) if( n->label() == ilabel ) { i = *n; break; } DAI_ASSERT( i.label() == ilabel ); // Find variable in psi with label jlabel Var j; for( VarSet::const_iterator n = psi.vars().begin(); n != psi.vars().end(); n++ ) if( n->label() == jlabel ) { j = *n; break; } DAI_ASSERT( j.label() == jlabel ); // Calculate N(psi,i,j); double N = psi.strength( i, j ); // Hand over result to MATLAB N_OUT = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(N_OUT)) = N; return; } libDAI-0.2.7/src/matlab/matlab.cpp0000644000263000017630000001274611433220723015462 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include namespace dai { using namespace std; /* Convert vector structure to a cell vector of CPTAB-like structs */ mxArray *Factors2mx(const vector &Ps) { size_t nr = Ps.size(); mxArray *psi = mxCreateCellMatrix(nr,1); const char *fieldnames[2]; fieldnames[0] = "Member"; fieldnames[1] = "P"; size_t I_ind = 0; for( vector::const_iterator I = Ps.begin(); I != Ps.end(); I++, I_ind++ ) { mxArray *Bi = mxCreateStructMatrix(1,1,2,fieldnames); mxArray *BiMember = mxCreateDoubleMatrix(1,I->vars().size(),mxREAL); double *BiMember_data = mxGetPr(BiMember); size_t i = 0; vector dims; for( VarSet::const_iterator j = I->vars().begin(); j != I->vars().end(); j++,i++ ) { BiMember_data[i] = j->label(); dims.push_back( j->states() ); } while( dims.size() <= 2 ) dims.push_back( 1 ); mxArray *BiP = mxCreateNumericArray(dims.size(), &(*(dims.begin())), mxDOUBLE_CLASS, mxREAL); double *BiP_data = mxGetPr(BiP); for( size_t j = 0; j < I->nrStates(); j++ ) BiP_data[j] = (*I)[j]; mxSetField(Bi,0,"Member",BiMember); mxSetField(Bi,0,"P",BiP); mxSetCell(psi, I_ind, Bi); } return( psi ); } /* Convert cell vector of CPTAB-like structs to vector */ vector mx2Factors(const mxArray *psi, long verbose) { set vars; vector factors; int n1 = mxGetM(psi); int n2 = mxGetN(psi); if( n2 != 1 && n1 != 1 ) mexErrMsgTxt("psi should be a Nx1 or 1xN cell matrix."); size_t nr_f = n1; if( n1 == 1 ) nr_f = n2; // interpret psi, linear cell array of cptabs for( size_t cellind = 0; cellind < nr_f; cellind++ ) { if( verbose >= 3 ) cerr << "reading factor " << cellind << ": " << endl; mxArray *cell = mxGetCell(psi, cellind); mxArray *mx_member = mxGetField(cell, 0, "Member"); size_t nr_mem = mxGetN(mx_member); double *members = mxGetPr(mx_member); const mwSize *dims = mxGetDimensions(mxGetField(cell,0,"P")); double *factordata = mxGetPr(mxGetField(cell, 0, "P")); // add variables VarSet factorvars; vector labels(nr_mem,0); if( verbose >= 3 ) cerr << " vars: "; for( size_t mi = 0; mi < nr_mem; mi++ ) { labels[mi] = (long)members[mi]; if( verbose >= 3 ) cerr << labels[mi] << "(" << dims[mi] << ") "; vars.insert( Var(labels[mi], dims[mi]) ); factorvars |= Var(labels[mi], dims[mi]); } factors.push_back(Factor(factorvars)); // calculate permutation matrix vector perm(nr_mem,0); VarSet::iterator j = factorvars.begin(); for( size_t mi = 0; mi < nr_mem; mi++,j++ ) { long gezocht = j->label(); vector::iterator piet = find(labels.begin(),labels.end(),gezocht); perm[mi] = piet - labels.begin(); } if( verbose >= 3 ) { cerr << endl << " perm: "; for( vector::iterator r=perm.begin(); r!=perm.end(); r++ ) cerr << *r << " "; cerr << endl; } // read Factor vector di(nr_mem,0); size_t prod = 1; for( size_t k = 0; k < nr_mem; k++ ) { di[k] = dims[k]; prod *= dims[k]; } Permute permindex( di, perm ); for( size_t li = 0; li < prod; li++ ) factors.back().set( permindex.convertLinearIndex(li), factordata[li] ); } if( verbose >= 3 ) { for(vector::const_iterator I=factors.begin(); I!=factors.end(); I++ ) cerr << *I << endl; } return( factors ); } /* Convert CPTAB-like struct to Factor */ Factor mx2Factor(const mxArray *psi) { mxArray *mx_member = mxGetField(psi, 0, "Member"); size_t nr_mem = mxGetN(mx_member); double *members = mxGetPr(mx_member); const mwSize *dims = mxGetDimensions(mxGetField(psi,0,"P")); double *factordata = mxGetPr(mxGetField(psi, 0, "P")); // add variables VarSet vars; vector labels(nr_mem,0); for( size_t mi = 0; mi < nr_mem; mi++ ) { labels[mi] = (long)members[mi]; vars |= Var(labels[mi], dims[mi]); } Factor factor(vars); // calculate permutation matrix vector perm(nr_mem,0); VarSet::iterator j = vars.begin(); for( size_t mi = 0; mi < nr_mem; mi++,j++ ) { long gezocht = j->label(); vector::iterator piet = find(labels.begin(),labels.end(),gezocht); perm[mi] = piet - labels.begin(); } // read Factor vector di(nr_mem,0); size_t prod = 1; for( size_t k = 0; k < nr_mem; k++ ) { di[k] = dims[k]; prod *= dims[k]; } Permute permindex( di, perm ); for( size_t li = 0; li < prod; li++ ) factor.set( permindex.convertLinearIndex(li), factordata[li] ); return( factor ); } } libDAI-0.2.7/src/gibbs.cpp0000644000263000017630000001652011433220723014042 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008 Frederik Eaton [frederik at ofb dot net] * Copyright (C) 2008-2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include #include #include #include #include namespace dai { using namespace std; const char *Gibbs::Name = "GIBBS"; void Gibbs::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("maxiter") ); props.maxiter = opts.getStringAs("maxiter"); if( opts.hasKey("restart") ) props.restart = opts.getStringAs("restart"); else props.restart = props.maxiter; if( opts.hasKey("burnin") ) props.burnin = opts.getStringAs("burnin"); else props.burnin = 0; if( opts.hasKey("maxtime") ) props.maxtime = opts.getStringAs("maxtime"); else props.maxtime = INFINITY; if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; } PropertySet Gibbs::getProperties() const { PropertySet opts; opts.set( "maxiter", props.maxiter ); opts.set( "maxtime", props.maxtime ); opts.set( "restart", props.restart ); opts.set( "burnin", props.burnin ); opts.set( "verbose", props.verbose ); return opts; } string Gibbs::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "maxiter=" << props.maxiter << ","; s << "maxtime=" << props.maxtime << ","; s << "restart=" << props.restart << ","; s << "burnin=" << props.burnin << ","; s << "verbose=" << props.verbose << "]"; return s.str(); } void Gibbs::construct() { _sample_count = 0; _var_counts.clear(); _var_counts.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) _var_counts.push_back( _count_t( var(i).states(), 0 ) ); _factor_counts.clear(); _factor_counts.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) _factor_counts.push_back( _count_t( factor(I).nrStates(), 0 ) ); _iters = 0; _state.clear(); _state.resize( nrVars(), 0 ); _max_state.clear(); _max_state.resize( nrVars(), 0 ); _max_score = logScore( _max_state ); } void Gibbs::updateCounts() { _sample_count++; for( size_t i = 0; i < nrVars(); i++ ) _var_counts[i][_state[i]]++; for( size_t I = 0; I < nrFactors(); I++ ) _factor_counts[I][getFactorEntry(I)]++; Real score = logScore( _state ); if( score > _max_score ) { _max_state = _state; _max_score = score; } } size_t Gibbs::getFactorEntry( size_t I ) { size_t f_entry = 0; for( int _j = nbF(I).size() - 1; _j >= 0; _j-- ) { // note that iterating over nbF(I) yields the same ordering // of variables as iterating over factor(I).vars() size_t j = nbF(I)[_j]; f_entry *= var(j).states(); f_entry += _state[j]; } return f_entry; } size_t Gibbs::getFactorEntryDiff( size_t I, size_t i ) { size_t skip = 1; for( size_t _j = 0; _j < nbF(I).size(); _j++ ) { // note that iterating over nbF(I) yields the same ordering // of variables as iterating over factor(I).vars() size_t j = nbF(I)[_j]; if( i == j ) break; else skip *= var(j).states(); } return skip; } Prob Gibbs::getVarDist( size_t i ) { DAI_ASSERT( i < nrVars() ); size_t i_states = var(i).states(); Prob i_given_MB( i_states, 1.0 ); // use Markov blanket of var(i) to calculate distribution foreach( const Neighbor &I, nbV(i) ) { const Factor &f_I = factor(I); size_t I_skip = getFactorEntryDiff( I, i ); size_t I_entry = getFactorEntry(I) - (_state[i] * I_skip); for( size_t st_i = 0; st_i < i_states; st_i++ ) { i_given_MB.set( st_i, i_given_MB[st_i] * f_I[I_entry] ); I_entry += I_skip; } } if( i_given_MB.sum() == 0.0 ) // If no state of i is allowed, use uniform distribution // FIXME is that indeed the right thing to do? i_given_MB = Prob( i_states ); else i_given_MB.normalize(); return i_given_MB; } void Gibbs::resampleVar( size_t i ) { _state[i] = getVarDist(i).draw(); } void Gibbs::randomizeState() { for( size_t i = 0; i < nrVars(); i++ ) _state[i] = rnd( var(i).states() ); } void Gibbs::init() { _sample_count = 0; for( size_t i = 0; i < nrVars(); i++ ) fill( _var_counts[i].begin(), _var_counts[i].end(), 0 ); for( size_t I = 0; I < nrFactors(); I++ ) fill( _factor_counts[I].begin(), _factor_counts[I].end(), 0 ); _iters = 0; } Real Gibbs::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3 ) cerr << endl; double tic = toc(); for( ; _iters < props.maxiter && (toc() - tic) < props.maxtime; _iters++ ) { if( (_iters % props.restart) == 0 ) randomizeState(); for( size_t i = 0; i < nrVars(); i++ ) resampleVar( i ); if( (_iters % props.restart) > props.burnin ) updateCounts(); } if( props.verbose >= 3 ) { for( size_t i = 0; i < nrVars(); i++ ) { cerr << "Belief for variable " << var(i) << ": " << beliefV(i) << endl; cerr << "Counts for variable " << var(i) << ": " << Prob( _var_counts[i] ) << endl; } } if( props.verbose >= 3 ) cerr << Name << "::run: ran " << _iters << " passes (" << toc() - tic << " seconds)." << endl; if( _iters == 0 ) return INFINITY; else return std::pow( _iters, -0.5 ); } Factor Gibbs::beliefV( size_t i ) const { if( _sample_count == 0 ) return Factor( var(i) ); else return Factor( var(i), _var_counts[i] ).normalized(); } Factor Gibbs::beliefF( size_t I ) const { if( _sample_count == 0 ) return Factor( factor(I).vars() ); else return Factor( factor(I).vars(), _factor_counts[I] ).normalized(); } vector Gibbs::beliefs() const { vector result; for( size_t i = 0; i < nrVars(); ++i ) result.push_back( beliefV(i) ); for( size_t I = 0; I < nrFactors(); ++I ) result.push_back( beliefF(I) ); return result; } Factor Gibbs::belief( const VarSet &ns ) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) return beliefV( findVar( *(ns.begin()) ) ); else { size_t I; for( I = 0; I < nrFactors(); I++ ) if( factor(I).vars() >> ns ) break; if( I == nrFactors() ) DAI_THROW(BELIEF_NOT_AVAILABLE); return beliefF(I).marginal(ns); } } std::vector getGibbsState( const FactorGraph &fg, size_t maxiter ) { PropertySet gibbsProps; gibbsProps.set( "maxiter", maxiter ); gibbsProps.set( "burnin", size_t(0) ); gibbsProps.set( "verbose", size_t(0) ); Gibbs gibbs( fg, gibbsProps ); gibbs.run(); return gibbs.state(); } } // end of namespace dai libDAI-0.2.7/src/hak.cpp0000644000263000017630000005255011433220723013522 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include namespace dai { using namespace std; const char *HAK::Name = "HAK"; /// Sets factor entries that lie between 0 and \a epsilon to \a epsilon template TFactor& makePositive( TFactor &f, T epsilon ) { for( size_t t = 0; t < f.states(); t++ ) if( (0 < f[t]) && (f[t] < epsilon) ) f[t] = epsilon; return f; } /// Sets factor entries that are smaller (in absolute value) than \a epsilon to 0 template TFactor& makeZero( TFactor &f, T epsilon ) { for( size_t t = 0; t < f.states(); t++ ) if( f[t] < epsilon && f[t] > -epsilon ) f[t] = 0; return f; } void HAK::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("doubleloop") ); DAI_ASSERT( opts.hasKey("clusters") ); props.tol = opts.getStringAs("tol"); props.doubleloop = opts.getStringAs("doubleloop"); props.clusters = opts.getStringAs("clusters"); if( opts.hasKey("maxiter") ) props.maxiter = opts.getStringAs("maxiter"); else props.maxiter = 10000; if( opts.hasKey("maxtime") ) props.maxtime = opts.getStringAs("maxtime"); else props.maxtime = INFINITY; if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; if( opts.hasKey("loopdepth") ) props.loopdepth = opts.getStringAs("loopdepth"); else DAI_ASSERT( props.clusters != Properties::ClustersType::LOOP ); if( opts.hasKey("damping") ) props.damping = opts.getStringAs("damping"); else props.damping = 0.0; if( opts.hasKey("init") ) props.init = opts.getStringAs("init"); else props.init = Properties::InitType::UNIFORM; } PropertySet HAK::getProperties() const { PropertySet opts; opts.set( "tol", props.tol ); opts.set( "maxiter", props.maxiter ); opts.set( "maxtime", props.maxtime ); opts.set( "verbose", props.verbose ); opts.set( "doubleloop", props.doubleloop ); opts.set( "clusters", props.clusters ); opts.set( "init", props.init ); opts.set( "loopdepth", props.loopdepth ); opts.set( "damping", props.damping ); return opts; } string HAK::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "maxtime=" << props.maxtime << ","; s << "verbose=" << props.verbose << ","; s << "doubleloop=" << props.doubleloop << ","; s << "clusters=" << props.clusters << ","; s << "init=" << props.init << ","; s << "loopdepth=" << props.loopdepth << ","; s << "damping=" << props.damping << "]"; return s.str(); } void HAK::construct() { // Create outer beliefs if( props.verbose >= 3 ) cerr << "Constructing outer beliefs" << endl; _Qa.clear(); _Qa.reserve(nrORs()); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) _Qa.push_back( Factor( OR(alpha) ) ); // Create inner beliefs if( props.verbose >= 3 ) cerr << "Constructing inner beliefs" << endl; _Qb.clear(); _Qb.reserve(nrIRs()); for( size_t beta = 0; beta < nrIRs(); beta++ ) _Qb.push_back( Factor( IR(beta) ) ); // Create messages if( props.verbose >= 3 ) cerr << "Constructing messages" << endl; _muab.clear(); _muab.reserve( nrORs() ); _muba.clear(); _muba.reserve( nrORs() ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { _muab.push_back( vector() ); _muba.push_back( vector() ); _muab[alpha].reserve( nbOR(alpha).size() ); _muba[alpha].reserve( nbOR(alpha).size() ); foreach( const Neighbor &beta, nbOR(alpha) ) { _muab[alpha].push_back( Factor( IR(beta) ) ); _muba[alpha].push_back( Factor( IR(beta) ) ); } } } HAK::HAK( const RegionGraph &rg, const PropertySet &opts ) : DAIAlgRG(rg), _Qa(), _Qb(), _muab(), _muba(), _maxdiff(0.0), _iters(0U), props() { setProperties( opts ); construct(); } void HAK::findLoopClusters( const FactorGraph & fg, std::set &allcl, VarSet newcl, const Var & root, size_t length, VarSet vars ) { for( VarSet::const_iterator in = vars.begin(); in != vars.end(); in++ ) { VarSet ind = fg.delta( fg.findVar( *in ) ); if( (newcl.size()) >= 2 && ind.contains( root ) ) allcl.insert( newcl | *in ); else if( length > 1 ) findLoopClusters( fg, allcl, newcl | *in, root, length - 1, ind / newcl ); } } HAK::HAK(const FactorGraph & fg, const PropertySet &opts) : DAIAlgRG(), _Qa(), _Qb(), _muab(), _muba(), _maxdiff(0.0), _iters(0U), props() { setProperties( opts ); if( props.verbose >= 3 ) cerr << "Constructing clusters" << endl; vector cl; if( props.clusters == Properties::ClustersType::MIN ) { cl = fg.maximalFactorDomains(); constructCVM( fg, cl ); } else if( props.clusters == Properties::ClustersType::DELTA ) { cl.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) cl.push_back( fg.Delta(i) ); constructCVM( fg, cl ); } else if( props.clusters == Properties::ClustersType::LOOP ) { cl = fg.maximalFactorDomains(); set scl; if( props.verbose >= 2 ) cerr << "Searching loops..."; for( size_t i0 = 0; i0 < fg.nrVars(); i0++ ) { VarSet i0d = fg.delta(i0); if( props.loopdepth > 1 ) findLoopClusters( fg, scl, fg.var(i0), fg.var(i0), props.loopdepth - 1, fg.delta(i0) ); } if( props.verbose >= 2 ) cerr << "done" << endl; for( set::const_iterator c = scl.begin(); c != scl.end(); c++ ) cl.push_back(*c); if( props.verbose >= 3 ) { cerr << Name << " uses the following clusters: " << endl; for( vector::const_iterator cli = cl.begin(); cli != cl.end(); cli++ ) cerr << *cli << endl; } constructCVM( fg, cl ); } else if( props.clusters == Properties::ClustersType::BETHE ) { // Copy factor graph structure if( props.verbose >= 3 ) cerr << "Copying factor graph" << endl; FactorGraph::operator=( fg ); // Construct inner regions (single variables) if( props.verbose >= 3 ) cerr << "Constructing inner regions" << endl; _IRs.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) _IRs.push_back( Region( fg.var(i), 1.0 ) ); // Construct graph if( props.verbose >= 3 ) cerr << "Constructing graph" << endl; _G = BipartiteGraph( 0, nrIRs() ); // Construct outer regions: // maximal factors become new outer regions // non-maximal factors are assigned an outer region that contains them if( props.verbose >= 3 ) cerr << "Construct outer regions" << endl; _fac2OR.reserve( nrFactors() ); queue > todo; for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t J = fg.maximalFactor( I ); if( J == I ) { // I is maximal; add it to the outer regions _fac2OR.push_back( nrORs() ); // Construct outer region (with counting number 1.0) _ORs.push_back( FRegion( fg.factor(I), 1.0 ) ); // Add node and edges to graph SmallSet irs = fg.bipGraph().nb2Set( I ); _G.addNode1( irs.begin(), irs.end(), irs.size() ); } else if( J < I ) { // J is larger and has already been assigned to an outer region // so I should belong to the same outer region as J _fac2OR.push_back( _fac2OR[J] ); _ORs[_fac2OR[J]] *= fg.factor(I); } else { // J is larger but has not yet been assigned to an outer region // we handle this case later _fac2OR.push_back( -1 ); todo.push( make_pair( I, J ) ); } } // finish the construction while( !todo.empty() ) { size_t I = todo.front().first; size_t J = todo.front().second; todo.pop(); _fac2OR[I] = _fac2OR[J]; _ORs[_fac2OR[J]] *= fg.factor(I); } // Calculate inner regions' counting numbers for( size_t beta = 0; beta < nrIRs(); beta++ ) _IRs[beta].c() = 1.0 - _G.nb2(beta).size(); } else DAI_THROW(UNKNOWN_ENUM_VALUE); construct(); if( props.verbose >= 3 ) cerr << Name << " regiongraph: " << *this << endl; } string HAK::identify() const { return string(Name) + printProperties(); } void HAK::init( const VarSet &ns ) { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) if( _Qa[alpha].vars().intersects( ns ) ) { if( props.init == Properties::InitType::UNIFORM ) _Qa[alpha].setUniform(); else _Qa[alpha].randomize(); _Qa[alpha] *= OR(alpha); _Qa[alpha].normalize(); } for( size_t beta = 0; beta < nrIRs(); beta++ ) if( IR(beta).intersects( ns ) ) { if( props.init == Properties::InitType::UNIFORM ) _Qb[beta].fill( 1.0 ); else _Qb[beta].randomize(); foreach( const Neighbor &alpha, nbIR(beta) ) { size_t _beta = alpha.dual; if( props.init == Properties::InitType::UNIFORM ) { muab( alpha, _beta ).fill( 1.0 ); muba( alpha, _beta ).fill( 1.0 ); } else { muab( alpha, _beta ).randomize(); muba( alpha, _beta ).randomize(); } } } } void HAK::init() { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { if( props.init == Properties::InitType::UNIFORM ) _Qa[alpha].setUniform(); else _Qa[alpha].randomize(); _Qa[alpha] *= OR(alpha); _Qa[alpha].normalize(); } for( size_t beta = 0; beta < nrIRs(); beta++ ) if( props.init == Properties::InitType::UNIFORM ) _Qb[beta].setUniform(); else _Qb[beta].randomize(); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) foreach( const Neighbor &beta, nbOR(alpha) ) { size_t _beta = beta.iter; if( props.init == Properties::InitType::UNIFORM ) { muab( alpha, _beta ).setUniform(); muba( alpha, _beta ).setUniform(); } else { muab( alpha, _beta ).randomize(); muba( alpha, _beta ).randomize(); } } } Real HAK::doGBP() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3) cerr << endl; double tic = toc(); // Check whether counting numbers won't lead to problems for( size_t beta = 0; beta < nrIRs(); beta++ ) DAI_ASSERT( nbIR(beta).size() + IR(beta).c() != 0.0 ); // Keep old beliefs to check convergence vector oldBeliefsV; oldBeliefsV.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) oldBeliefsV.push_back( beliefV(i) ); vector oldBeliefsF; oldBeliefsF.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) oldBeliefsF.push_back( beliefF(I) ); // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance Real maxDiff = INFINITY; for( _iters = 0; _iters < props.maxiter && maxDiff > props.tol; _iters++ ) { for( size_t beta = 0; beta < nrIRs(); beta++ ) { foreach( const Neighbor &alpha, nbIR(beta) ) { size_t _beta = alpha.dual; muab( alpha, _beta ) = _Qa[alpha].marginal(IR(beta)) / muba(alpha,_beta); /* TODO: INVESTIGATE THIS PROBLEM * * In some cases, the muab's can have very large entries because the muba's have very * small entries. This may cause NANs later on (e.g., multiplying large quantities may * result in +inf; normalization then tries to calculate inf / inf which is NAN). * A fix of this problem would consist in normalizing the messages muab. * However, it is not obvious whether this is a real solution, because it has a * negative performance impact and the NAN's seem to be a symptom of a fundamental * numerical unstability. */ muab(alpha,_beta).normalize(); } Factor Qb_new; foreach( const Neighbor &alpha, nbIR(beta) ) { size_t _beta = alpha.dual; Qb_new *= muab(alpha,_beta) ^ (1 / (nbIR(beta).size() + IR(beta).c())); } Qb_new.normalize(); if( Qb_new.hasNaNs() ) { // TODO: WHAT TO DO IN THIS CASE? cerr << Name << "::doGBP: Qb_new has NaNs!" << endl; return 1.0; } /* TODO: WHAT IS THE PURPOSE OF THE FOLLOWING CODE? * * _Qb[beta] = Qb_new.makeZero(1e-100); */ if( props.doubleloop || props.damping == 0.0 ) _Qb[beta] = Qb_new; // no damping for double loop else _Qb[beta] = (Qb_new^(1.0 - props.damping)) * (_Qb[beta]^props.damping); foreach( const Neighbor &alpha, nbIR(beta) ) { size_t _beta = alpha.dual; muba(alpha,_beta) = _Qb[beta] / muab(alpha,_beta); /* TODO: INVESTIGATE WHETHER THIS HACK (INVENTED BY KEES) TO PREVENT NANS MAKES SENSE * * muba(beta,*alpha).makePositive(1e-100); * */ Factor Qa_new = OR(alpha); foreach( const Neighbor &gamma, nbOR(alpha) ) Qa_new *= muba(alpha,gamma.iter); Qa_new ^= (1.0 / OR(alpha).c()); Qa_new.normalize(); if( Qa_new.hasNaNs() ) { cerr << Name << "::doGBP: Qa_new has NaNs!" << endl; return 1.0; } /* TODO: WHAT IS THE PURPOSE OF THE FOLLOWING CODE? * * _Qb[beta] = Qb_new.makeZero(1e-100); */ if( props.doubleloop || props.damping == 0.0 ) _Qa[alpha] = Qa_new; // no damping for double loop else // FIXME: GEOMETRIC DAMPING IS SLOW! _Qa[alpha] = (Qa_new^(1.0 - props.damping)) * (_Qa[alpha]^props.damping); } } // Calculate new single variable beliefs and compare with old ones maxDiff = -INFINITY; for( size_t i = 0; i < nrVars(); ++i ) { Factor b = beliefV(i); maxDiff = std::max( maxDiff, dist( b, oldBeliefsV[i], DISTLINF ) ); oldBeliefsV[i] = b; } for( size_t I = 0; I < nrFactors(); ++I ) { Factor b = beliefF(I); maxDiff = std::max( maxDiff, dist( b, oldBeliefsF[I], DISTLINF ) ); oldBeliefsF[I] = b; } if( props.verbose >= 3 ) cerr << Name << "::doGBP: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::doGBP: WARNING: not converged within " << props.maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 2 ) cerr << Name << "::doGBP: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } Real HAK::doDoubleLoop() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3) cerr << endl; double tic = toc(); // Save original outer regions vector org_ORs = _ORs; // Save original inner counting numbers and set negative counting numbers to zero vector org_IR_cs( nrIRs(), 0.0 ); for( size_t beta = 0; beta < nrIRs(); beta++ ) { org_IR_cs[beta] = IR(beta).c(); if( IR(beta).c() < 0.0 ) IR(beta).c() = 0.0; } // Keep old beliefs to check convergence vector oldBeliefsV; oldBeliefsV.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) oldBeliefsV.push_back( beliefV(i) ); vector oldBeliefsF; oldBeliefsF.reserve( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) oldBeliefsF.push_back( beliefF(I) ); size_t outer_maxiter = props.maxiter; Real outer_tol = props.tol; size_t outer_verbose = props.verbose; Real org_maxdiff = _maxdiff; // Set parameters for inner loop props.maxiter = 5; props.verbose = outer_verbose ? outer_verbose - 1 : 0; size_t outer_iter = 0; size_t total_iter = 0; Real maxDiff = INFINITY; for( outer_iter = 0; outer_iter < outer_maxiter && maxDiff > outer_tol && (toc() - tic) < props.maxtime; outer_iter++ ) { // Calculate new outer regions for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { OR(alpha) = org_ORs[alpha]; foreach( const Neighbor &beta, nbOR(alpha) ) OR(alpha) *= _Qb[beta] ^ ((IR(beta).c() - org_IR_cs[beta]) / nbIR(beta).size()); } // Inner loop if( isnan( doGBP() ) ) return 1.0; // Calculate new single variable beliefs and compare with old ones maxDiff = -INFINITY; for( size_t i = 0; i < nrVars(); ++i ) { Factor b = beliefV(i); maxDiff = std::max( maxDiff, dist( b, oldBeliefsV[i], DISTLINF ) ); oldBeliefsV[i] = b; } for( size_t I = 0; I < nrFactors(); ++I ) { Factor b = beliefF(I); maxDiff = std::max( maxDiff, dist( b, oldBeliefsF[I], DISTLINF ) ); oldBeliefsF[I] = b; } total_iter += Iterations(); if( props.verbose >= 3 ) cerr << Name << "::doDoubleLoop: maxdiff " << maxDiff << " after " << total_iter << " passes" << endl; } // restore _maxiter, _verbose and _maxdiff props.maxiter = outer_maxiter; props.verbose = outer_verbose; _maxdiff = org_maxdiff; _iters = total_iter; if( maxDiff > _maxdiff ) _maxdiff = maxDiff; // Restore original outer regions _ORs = org_ORs; // Restore original inner counting numbers for( size_t beta = 0; beta < nrIRs(); ++beta ) IR(beta).c() = org_IR_cs[beta]; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::doDoubleLoop: WARNING: not converged after " << total_iter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 3 ) cerr << Name << "::doDoubleLoop: "; cerr << "converged in " << total_iter << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } Real HAK::run() { if( props.doubleloop ) return doDoubleLoop(); else return doGBP(); } Factor HAK::belief( const VarSet &ns ) const { vector::const_iterator beta; for( beta = _Qb.begin(); beta != _Qb.end(); beta++ ) if( beta->vars() >> ns ) break; if( beta != _Qb.end() ) return( beta->marginal(ns) ); else { vector::const_iterator alpha; for( alpha = _Qa.begin(); alpha != _Qa.end(); alpha++ ) if( alpha->vars() >> ns ) break; if( alpha == _Qa.end() ) DAI_THROW(BELIEF_NOT_AVAILABLE); return( alpha->marginal(ns) ); } } vector HAK::beliefs() const { vector result; for( size_t beta = 0; beta < nrIRs(); beta++ ) result.push_back( Qb(beta) ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) result.push_back( Qa(alpha) ); return result; } Real HAK::logZ() const { Real s = 0.0; for( size_t beta = 0; beta < nrIRs(); beta++ ) s += IR(beta).c() * Qb(beta).entropy(); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { s += OR(alpha).c() * Qa(alpha).entropy(); s += (OR(alpha).log(true) * Qa(alpha)).sum(); } return s; } } // end of namespace dai libDAI-0.2.7/src/trwbp.cpp0000644000263000017630000001436411433220723014116 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #define DAI_TRWBP_FAST 1 namespace dai { using namespace std; const char *TRWBP::Name = "TRWBP"; void TRWBP::setProperties( const PropertySet &opts ) { BP::setProperties( opts ); if( opts.hasKey("nrtrees") ) nrtrees = opts.getStringAs("nrtrees"); else nrtrees = 0; } PropertySet TRWBP::getProperties() const { PropertySet opts = BP::getProperties(); opts.set( "nrtrees", nrtrees ); return opts; } string TRWBP::printProperties() const { stringstream s( stringstream::out ); string sbp = BP::printProperties(); s << sbp.substr( 0, sbp.size() - 1 ); s << ","; s << "nrtrees=" << nrtrees << "]"; return s.str(); } string TRWBP::identify() const { return string(Name) + printProperties(); } // This code has been copied from bp.cpp, except where comments indicate TRWBP-specific behaviour Real TRWBP::logZ() const { Real sum = 0.0; for( size_t I = 0; I < nrFactors(); I++ ) { sum += (beliefF(I) * factor(I).log(true)).sum(); // TRWBP/FBP sum += Weight(I) * beliefF(I).entropy(); // TRWBP/FBP } for( size_t i = 0; i < nrVars(); ++i ) { Real c_i = 0.0; foreach( const Neighbor &I, nbV(i) ) c_i += Weight(I); sum += (1.0 - c_i) * beliefV(i).entropy(); // TRWBP/FBP } return sum; } // This code has been copied from bp.cpp, except where comments indicate TRWBP-specific behaviour Prob TRWBP::calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const { Real c_I = Weight(I); // TRWBP: c_I Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); if( props.logdomain ) { prod.takeLog(); prod /= c_I; // TRWBP } else prod ^= (1.0 / c_I); // TRWBP // Calculate product of incoming messages and factor I foreach( const Neighbor &j, nbF(I) ) if( !(without_i && (j == i)) ) { const Var &v_j = var(j); // prod_j will be the product of messages coming into j // TRWBP: corresponds to messages n_jI Prob prod_j( v_j.states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &J, nbV(j) ) { Real c_J = Weight(J); // TRWBP if( J != I ) { // for all J in nb(j) \ I if( props.logdomain ) prod_j += message( j, J.iter ) * c_J; else prod_j *= message( j, J.iter ) ^ c_J; } else { // TRWBP: multiply by m_Ij^(c_I-1) if( props.logdomain ) prod_j += message( j, J.iter ) * (c_J - 1.0); else prod_j *= message( j, J.iter ) ^ (c_J - 1.0); } } // multiply prod with prod_j if( !DAI_TRWBP_FAST ) { // UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION if( props.logdomain ) Fprod += Factor( v_j, prod_j ); else Fprod *= Factor( v_j, prod_j ); } else { // OPTIMIZED VERSION size_t _I = j.dual; // ind is the precalculated IndexFor(j,I) i.e. to x_I == k corresponds x_j == ind[k] const ind_t &ind = index(j, _I); for( size_t r = 0; r < prod.size(); ++r ) if( props.logdomain ) prod.set( r, prod[r] + prod_j[ind[r]] ); else prod.set( r, prod[r] * prod_j[ind[r]] ); } } return prod; } // This code has been copied from bp.cpp, except where comments indicate TRWBP-specific behaviour void TRWBP::calcBeliefV( size_t i, Prob &p ) const { p = Prob( var(i).states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &I, nbV(i) ) { Real c_I = Weight(I); if( props.logdomain ) p += newMessage( i, I.iter ) * c_I; else p *= newMessage( i, I.iter ) ^ c_I; } } void TRWBP::construct() { BP::construct(); _weight.resize( nrFactors(), 1.0 ); sampleWeights( nrtrees ); if( props.verbose >= 2 ) cerr << "Weights: " << _weight << endl; } void TRWBP::addTreeToWeights( const RootedTree &tree ) { for( RootedTree::const_iterator e = tree.begin(); e != tree.end(); e++ ) { VarSet ij( var(e->first), var(e->second) ); size_t I = findFactor( ij ); _weight[I] += 1.0; } } void TRWBP::sampleWeights( size_t nrTrees ) { if( !nrTrees ) return; // initialize weights to zero fill( _weight.begin(), _weight.end(), 0.0 ); // construct Markov adjacency graph, with edges weighted with // random weights drawn from the uniform distribution on the interval [0,1] WeightedGraph wg; for( size_t i = 0; i < nrVars(); ++i ) { const Var &v_i = var(i); VarSet di = delta(i); for( VarSet::const_iterator j = di.begin(); j != di.end(); j++ ) if( v_i < *j ) wg[UEdge(i,findVar(*j))] = rnd_uniform(); } // now repeatedly change the random weights, find the minimal spanning tree, and add it to the weights for( size_t nr = 0; nr < nrTrees; nr++ ) { // find minimal spanning tree RootedTree randTree = MinSpanningTree( wg, true ); // add it to the weights addTreeToWeights( randTree ); // resample weights of the graph for( WeightedGraph::iterator e = wg.begin(); e != wg.end(); e++ ) e->second = rnd_uniform(); } // normalize the weights and set the single-variable weights to 1.0 for( size_t I = 0; I < nrFactors(); I++ ) { size_t sizeI = factor(I).vars().size(); if( sizeI == 1 ) _weight[I] = 1.0; else if( sizeI == 2 ) _weight[I] /= nrTrees; else DAI_THROW(NOT_IMPLEMENTED); } } } // end of namespace dai libDAI-0.2.7/src/factor.cpp0000644000263000017630000000347711433220723014241 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include namespace dai { using namespace std; Factor createFactorIsing( const Var &n, Real h ) { DAI_ASSERT( n.states() == 2 ); Real buf[2]; buf[0] = std::exp(-h); buf[1] = std::exp(h); return Factor(n, &buf[0]); } Factor createFactorIsing( const Var &n1, const Var &n2, Real J ) { DAI_ASSERT( n1.states() == 2 ); DAI_ASSERT( n2.states() == 2 ); DAI_ASSERT( n1 != n2 ); Real buf[4]; buf[0] = (buf[3] = std::exp(J)); buf[1] = (buf[2] = std::exp(-J)); return Factor( VarSet(n1, n2), &buf[0] ); } Factor createFactorExpGauss( const VarSet &ns, Real beta ) { Factor fac( ns ); for( size_t t = 0; t < fac.nrStates(); t++ ) fac.set( t, std::exp(rnd_stdnormal() * beta) ); return fac; } Factor createFactorPotts( const Var &n1, const Var &n2, Real J ) { Factor fac( VarSet( n1, n2 ), 1.0 ); DAI_ASSERT( n1.states() == n2.states() ); for( size_t s = 0; s < n1.states(); s++ ) fac.set( s * (n1.states() + 1), std::exp(J) ); return fac; } Factor createFactorDelta( const Var &v, size_t state ) { Factor fac( v, 0.0 ); DAI_ASSERT( state < v.states() ); fac.set( state, 1.0 ); return fac; } Factor createFactorDelta( const VarSet& vs, size_t state ) { Factor fac( vs, 0.0 ); DAI_ASSERT( state < vs.nrStates() ); fac.set( state, 1.0 ); return fac; } } // end of namespace dai libDAI-0.2.7/src/alldai.cpp0000644000263000017630000001134311433220723014200 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include namespace dai { using namespace std; InfAlg *newInfAlg( const std::string &name, const FactorGraph &fg, const PropertySet &opts ) { if( name == ExactInf::Name ) return new ExactInf (fg, opts); #ifdef DAI_WITH_BP if( name == BP::Name ) return new BP (fg, opts); #endif #ifdef DAI_WITH_FBP if( name == FBP::Name ) return new FBP (fg, opts); #endif #ifdef DAI_WITH_TRWBP if( name == TRWBP::Name ) return new TRWBP (fg, opts); #endif #ifdef DAI_WITH_MF if( name == MF::Name ) return new MF (fg, opts); #endif #ifdef DAI_WITH_HAK if( name == HAK::Name ) return new HAK (fg, opts); #endif #ifdef DAI_WITH_LC if( name == LC::Name ) return new LC (fg, opts); #endif #ifdef DAI_WITH_TREEEP if( name == TreeEP::Name ) return new TreeEP (fg, opts); #endif #ifdef DAI_WITH_JTREE if( name == JTree::Name ) return new JTree (fg, opts); #endif #ifdef DAI_WITH_MR if( name == MR::Name ) return new MR (fg, opts); #endif #ifdef DAI_WITH_GIBBS if( name == Gibbs::Name ) return new Gibbs (fg, opts); #endif #ifdef DAI_WITH_CBP if( name == CBP::Name ) return new CBP (fg, opts); #endif #ifdef DAI_WITH_DECMAP if( name == DecMAP::Name ) return new DecMAP (fg, opts); #endif DAI_THROWE(UNKNOWN_DAI_ALGORITHM,"Unknown libDAI algorithm: " + name); } InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg ) { pair no = parseNameProperties( nameOpts ); return newInfAlg( no.first, fg, no.second ); } InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg, const std::map &aliases ) { pair no = parseNameProperties( nameOpts, aliases ); return newInfAlg( no.first, fg, no.second ); } std::pair parseNameProperties( const std::string &s ) { string::size_type pos = s.find_first_of('['); string name; PropertySet opts; if( pos == string::npos ) { name = s; } else { name = s.substr(0,pos); stringstream ss; ss << s.substr(pos,s.length()); ss >> opts; } return make_pair(name,opts); } std::pair parseNameProperties( const std::string &s, const std::map &aliases ) { // break string into method[properties] pair ps = parseNameProperties(s); bool looped = false; // as long as 'method' is an alias, update: while( aliases.find(ps.first) != aliases.end() && !looped ) { string astr = aliases.find(ps.first)->second; pair aps = parseNameProperties(astr); if( aps.first == ps.first ) looped = true; // override aps properties by ps properties aps.second.set( ps.second ); // replace ps by aps ps = aps; // repeat until method name == alias name ('looped'), or // there is no longer an alias 'method' } return ps; } std::map readAliasesFile( const std::string &filename ) { // Read aliases map result; ifstream infile; infile.open( filename.c_str() ); if( infile.is_open() ) { while( true ) { string line; getline( infile,line ); if( infile.fail() ) break; if( (!line.empty()) && (line[0] != '#') ) { string::size_type pos = line.find(':',0); if( pos == string::npos ) DAI_THROWE(INVALID_ALIAS,"Invalid alias '" + line + "'"); else { string::size_type posl = line.substr(0, pos).find_last_not_of(" \t"); string key = line.substr(0, posl + 1); string::size_type posr = line.substr(pos + 1, line.length()).find_first_not_of(" \t"); string val = line.substr(pos + 1 + posr, line.length()); result[key] = val; } } } infile.close(); } else DAI_THROWE(CANNOT_READ_FILE,"Error opening aliases file " + filename); return result; } } // end of namespace dai libDAI-0.2.7/src/graph.cpp0000644000263000017630000002727611433220723014067 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include namespace dai { using namespace std; GraphAL& GraphAL::addEdge( size_t n1, size_t n2, bool check ) { DAI_ASSERT( n1 < nrNodes() ); DAI_ASSERT( n2 < nrNodes() ); bool exists = false; if( check ) { // Check whether the edge already exists foreach( const Neighbor &n, nb(n1) ) if( n == n2 ) { exists = true; break; } } if( !exists && n1 != n2 ) { // Add edge Neighbor nb_1( nb(n1).size(), n2, nb(n2).size() ); Neighbor nb_2( nb_1.dual, n1, nb_1.iter ); nb(n1).push_back( nb_1 ); nb(n2).push_back( nb_2 ); } return *this; } void GraphAL::eraseNode( size_t n ) { DAI_ASSERT( n < nrNodes() ); // Erase neighbor entry of node n _nb.erase( _nb.begin() + n ); // Adjust neighbor entries of nodes for( size_t n2 = 0; n2 < nrNodes(); n2++ ) { for( size_t iter = 0; iter < nb(n2).size(); ) { Neighbor &m = nb(n2, iter); if( m.node == n ) { // delete this entry, because it points to the deleted node nb(n2).erase( nb(n2).begin() + iter ); } else { // update this entry and the corresponding dual of the neighboring node if( m.node > n ) m.node--; nb( m.node, m.dual ).dual = iter; m.iter = iter++; } } } } void GraphAL::eraseEdge( size_t n1, size_t n2 ) { DAI_ASSERT( n1 < nrNodes() ); DAI_ASSERT( n2 < nrNodes() ); size_t iter; // Search for edge among neighbors of n1 for( iter = 0; iter < nb(n1).size(); iter++ ) if( nb(n1, iter).node == n2 ) { // Remove it nb(n1).erase( nb(n1).begin() + iter ); break; } // Change the iter and dual values of the subsequent neighbors for( ; iter < nb(n1).size(); iter++ ) { Neighbor &m = nb( n1, iter ); m.iter = iter; nb( m.node, m.dual ).dual = iter; } // Search for edge among neighbors of n2 for( iter = 0; iter < nb(n2).size(); iter++ ) if( nb(n2, iter).node == n1 ) { // Remove it nb(n2).erase( nb(n2).begin() + iter ); break; } // Change the iter and node values of the subsequent neighbors for( ; iter < nb(n2).size(); iter++ ) { Neighbor &m = nb( n2, iter ); m.iter = iter; nb( m.node, m.dual ).dual = iter; } } SmallSet GraphAL::nbSet( size_t n ) const { SmallSet result; foreach( const Neighbor &m, nb(n) ) result |= m; return result; } bool GraphAL::isConnected() const { if( nrNodes() == 0 ) { return true; } else { std::vector incomponent( nrNodes(), false ); incomponent[0] = true; bool found_new_nodes; do { found_new_nodes = false; // For all nodes, check if they are connected with the (growing) component for( size_t n1 = 0; n1 < nrNodes(); n1++ ) if( !incomponent[n1] ) { foreach( const Neighbor &n2, nb(n1) ) { if( incomponent[n2] ) { found_new_nodes = true; incomponent[n1] = true; break; } } } } while( found_new_nodes ); // Check if there are remaining nodes (not in the component) bool all_connected = true; for( size_t n1 = 0; (n1 < nrNodes()) && all_connected; n1++ ) if( !incomponent[n1] ) all_connected = false; return all_connected; // BGL implementation is slower... /* using namespace boost; typedef adjacency_list< vecS, vecS, undirectedS, property > boostGraphAL; typedef pair E; // Copy graph structure into boostGraphAL object vector edges; edges.reserve( nrEdges() ); for( size_t n1 = 0; n1 < nrNodes(); n1++ ) foreach( const Neighbor &n2, nb(n1) ) if( n1 < n2 ) edges.push_back( E( n1, n2 ) ); boostGraphAL g( edges.begin(), edges.end(), nrNodes() ); // Construct connected components using Boost GraphAL Library std::vector component( num_vertices( g ) ); int num_comp = connected_components( g, make_iterator_property_map(component.begin(), get(vertex_index, g)) ); return (num_comp == 1); */ } } bool GraphAL::isTree() const { typedef vector levelType; // first is node, second is its parent vector levels; if( nrNodes() == 0 ) return true; else { // start with root node 0 levels.push_back( levelType( 1, Edge( 0, 0 ) ) ); size_t treeSize = 1; bool foundCycle = false; do { levels.push_back( levelType() ); const levelType &prevLevel = levels[levels.size() - 2]; // build new level: add all neighbors of nodes in the previous level // (without backtracking), aborting if a cycle is detected for( size_t e = 0; e < prevLevel.size(); e++ ) { size_t n2 = prevLevel[e].first; // for all nodes n2 in the previous level foreach( const Neighbor &n1, nb(n2) ) { // for all neighbors n1 of n2 if( n1 != prevLevel[e].second ) { // no backtracking allowed for( size_t l = 0; l < levels.size() && !foundCycle; l++ ) for( size_t f = 0; f < levels[l].size() && !foundCycle; f++ ) if( levels[l][f].first == n1 ) // n1 has been visited before -> found a cycle foundCycle = true; if( !foundCycle ) // add n1 (and its parent n2) to current level levels.back().push_back( Edge( n1, n2 ) ); } if( foundCycle ) break; } if( foundCycle ) break; } treeSize += levels.back().size(); } while( (levels.back().size() != 0) && !foundCycle ); if( treeSize == nrNodes() && !foundCycle ) return true; else return false; } } void GraphAL::printDot( std::ostream& os ) const { os << "graph GraphAL {" << endl; os << "node[shape=circle,width=0.4,fixedsize=true];" << endl; for( size_t n = 0; n < nrNodes(); n++ ) os << "\tx" << n << ";" << endl; for( size_t n1 = 0; n1 < nrNodes(); n1++ ) foreach( const Neighbor &n2, nb(n1) ) if( n1 < n2 ) os << "\tx" << n1 << " -- x" << n2 << ";" << endl; os << "}" << endl; } void GraphAL::checkConsistency() const { size_t N = nrNodes(); for( size_t n1 = 0; n1 < N; n1++ ) { size_t iter = 0; foreach( const Neighbor &n2, nb(n1) ) { DAI_ASSERT( n2.iter == iter ); DAI_ASSERT( n2.node < N ); DAI_ASSERT( n2.dual < nb(n2).size() ); DAI_ASSERT( nb(n2, n2.dual) == n1 ); iter++; } } } GraphAL createGraphFull( size_t N ) { GraphAL result( N ); for( size_t i = 0; i < N; i++ ) for( size_t j = i+1; j < N; j++ ) result.addEdge( i, j, false ); return result; } GraphAL createGraphGrid( size_t N1, size_t N2, bool periodic ) { GraphAL result( N1*N2 ); if( N1 == 1 && N2 == 1 ) return result; for( size_t i1 = 0; i1 < N1; i1++ ) for( size_t i2 = 0; i2 < N2; i2++ ) { if( i1+1 < N1 || periodic ) result.addEdge( i1*N2 + i2, ((i1+1)%N1)*N2 + i2, N1 <= 2 ); if( i2+1 < N2 || periodic ) result.addEdge( i1*N2 + i2, i1*N2 + ((i2+1)%N2), N2 <= 2 ); } return result; } GraphAL createGraphGrid3D( size_t N1, size_t N2, size_t N3, bool periodic ) { GraphAL result( N1*N2*N3 ); for( size_t i1 = 0; i1 < N1; i1++ ) for( size_t i2 = 0; i2 < N2; i2++ ) for( size_t i3 = 0; i3 < N3; i3++ ) { if( i1+1 < N1 || periodic ) result.addEdge( i1*N2*N3 + i2*N3 + i3, ((i1+1)%N1)*N2*N3 + i2*N3 + i3, N1 <= 2 ); if( i2+1 < N2 || periodic ) result.addEdge( i1*N2*N3 + i2*N3 + i3, i1*N2*N3 + ((i2+1)%N2)*N3 + i3, N2 <= 2 ); if( i3+1 < N3 || periodic ) result.addEdge( i1*N2*N3 + i2*N3 + i3, i1*N2*N3 + i2*N3 + ((i3+1)%N3), N3 <= 2 ); } return result; } GraphAL createGraphLoop( size_t N ) { GraphAL result( N ); for( size_t i = 0; i < N; i++ ) result.addEdge( i, (i+1)%N, N <= 2 ); return result; } GraphAL createGraphTree( size_t N ) { GraphAL result( N ); for( size_t i = 1; i < N; i++ ) { size_t j = rnd_int( 0, i-1 ); result.addEdge( i, j, false ); } return result; } GraphAL createGraphRegular( size_t N, size_t d ) { DAI_ASSERT( (N * d) % 2 == 0 ); DAI_ASSERT( d < N ); GraphAL G( N ); if( d > 0 ) { bool ready = false; size_t tries = 0; while( !ready ) { tries++; // Start with N*d points {0,1,...,N*d-1} (N*d even) in N groups. // Put U = {0,1,...,N*d-1}. (U denotes the set of unpaired points.) vector U; U.reserve( N * d ); for( size_t i = 0; i < N * d; i++ ) U.push_back( i ); // Repeat the following until no suitable pair can be found: Choose // two random points i and j in U, and if they are suitable, pair // i with j and delete i and j from U. G = GraphAL( N ); bool finished = false; while( !finished ) { random_shuffle( U.begin(), U.end() ); size_t i1, i2; bool suit_pair_found = false; for( i1 = 0; i1 < U.size()-1 && !suit_pair_found; i1++ ) for( i2 = i1+1; i2 < U.size() && !suit_pair_found; i2++ ) if( ((U[i1] / d) != (U[i2] / d)) && !G.hasEdge( U[i1] / d, U[i2] / d ) ) { // they are suitable suit_pair_found = true; G.addEdge( U[i1] / d, U[i2] / d, false ); U.erase( U.begin() + i2 ); // first remove largest U.erase( U.begin() + i1 ); // remove smallest } if( !suit_pair_found || U.empty() ) finished = true; } if( U.empty() ) { // G is a graph with edge from vertex r to vertex s if and only if // there is a pair containing points in the r'th and s'th groups. // If G is d-regular, output, otherwise return to Step 1. ready = true; for( size_t n = 0; n < N; n++ ) if( G.nb(n).size() != d ) { ready = false; break; } } else ready = false; } } return G; } } // end of namespace dai libDAI-0.2.7/src/bp_dual.cpp0000644000263000017630000001050611433220723014360 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ #include #include #include #include #include #include namespace dai { using namespace std; void BP_dual::init() { regenerateMessages(); regenerateBeliefs(); calcMessages(); calcBeliefs(); } void BP_dual::regenerateMessages() { size_t nv = fg().nrVars(); _msgs.Zn.resize(nv); _msgs.Zm.resize(nv); _msgs.m.resize(nv); _msgs.n.resize(nv); for( size_t i = 0; i < nv; i++ ) { size_t nvf = fg().nbV(i).size(); _msgs.Zn[i].resize(nvf, 1.0); _msgs.Zm[i].resize(nvf, 1.0); size_t states = fg().var(i).states(); _msgs.n[i].resize(nvf, Prob(states)); _msgs.m[i].resize(nvf, Prob(states)); } } void BP_dual::regenerateBeliefs() { _beliefs.b1.clear(); _beliefs.b1.reserve(fg().nrVars()); _beliefs.Zb1.resize(fg().nrVars(), 1.0); _beliefs.b2.clear(); _beliefs.b2.reserve(fg().nrFactors()); _beliefs.Zb2.resize(fg().nrFactors(), 1.0); for( size_t i = 0; i < fg().nrVars(); i++ ) _beliefs.b1.push_back( Prob( fg().var(i).states() ) ); for( size_t I = 0; I < fg().nrFactors(); I++ ) _beliefs.b2.push_back( Prob( fg().factor(I).nrStates() ) ); } void BP_dual::calcMessages() { // calculate 'n' messages from "factor marginal / factor" for( size_t I = 0; I < fg().nrFactors(); I++ ) { Factor f = _ia->beliefF(I) / fg().factor(I); foreach( const Neighbor &i, fg().nbF(I) ) msgN(i, i.dual) = f.marginal( fg().var(i) ).p(); } // calculate 'm' messages and normalizers from 'n' messages for( size_t i = 0; i < fg().nrVars(); i++ ) foreach( const Neighbor &I, fg().nbV(i) ) calcNewM( i, I.iter ); // recalculate 'n' messages and normalizers from 'm' messages for( size_t i = 0; i < fg().nrVars(); i++ ) foreach( const Neighbor &I, fg().nbV(i) ) calcNewN(i, I.iter); } void BP_dual::calcNewM( size_t i, size_t _I ) { // calculate updated message I->i const Neighbor &I = fg().nbV(i)[_I]; Prob prod( fg().factor(I).p() ); foreach( const Neighbor &j, fg().nbF(I) ) if( j != i ) { // for all j in I \ i Prob &n = msgN(j,j.dual); IndexFor ind( fg().var(j), fg().factor(I).vars() ); for( size_t x = 0; ind.valid(); x++, ++ind ) prod.set( x, prod[x] * n[ind] ); } // Marginalize onto i Prob marg( fg().var(i).states(), 0.0 ); // ind is the precalculated Index(i,I) i.e. to x_I == k corresponds x_i == ind[k] IndexFor ind( fg().var(i), fg().factor(I).vars() ); for( size_t x = 0; ind.valid(); x++, ++ind ) marg.set( ind, marg[ind] + prod[x] ); _msgs.Zm[i][_I] = marg.normalize(); _msgs.m[i][_I] = marg; } void BP_dual::calcNewN( size_t i, size_t _I ) { // calculate updated message i->I const Neighbor &I = fg().nbV(i)[_I]; Prob prod( fg().var(i).states(), 1.0 ); foreach( const Neighbor &J, fg().nbV(i) ) if( J.node != I.node ) // for all J in i \ I prod *= msgM(i,J.iter); _msgs.Zn[i][_I] = prod.normalize(); _msgs.n[i][_I] = prod; } void BP_dual::calcBeliefs() { for( size_t i = 0; i < fg().nrVars(); i++ ) calcBeliefV(i); // calculate b_i for( size_t I = 0; I < fg().nrFactors(); I++ ) calcBeliefF(I); // calculate b_I } void BP_dual::calcBeliefV( size_t i ) { Prob prod( fg().var(i).states(), 1.0 ); foreach( const Neighbor &I, fg().nbV(i) ) prod *= msgM(i,I.iter); _beliefs.Zb1[i] = prod.normalize(); _beliefs.b1[i] = prod; } void BP_dual::calcBeliefF( size_t I ) { Prob prod( fg().factor(I).p() ); foreach( const Neighbor &j, fg().nbF(I) ) { IndexFor ind( fg().var(j), fg().factor(I).vars() ); Prob n( msgN(j,j.dual) ); for( size_t x = 0; ind.valid(); x++, ++ind ) prod.set( x, prod[x] * n[ind] ); } _beliefs.Zb2[I] = prod.normalize(); _beliefs.b2[I] = prod; } } // end of namespace dai libDAI-0.2.7/src/exceptions.cpp0000644000263000017630000000254011433220723015132 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include namespace dai { std::string Exception::ErrorStrings[NUM_ERRORS] = { "Feature not implemented", "Assertion failed", "Impossible typecast", "Requested object not found", "Requested belief not available", "Unknown ENUM value", "Unknown DAI algorithm", "Unrecognized parameter estimation method", "Unknown Property type", "Unknown Property", "Malformed Property", "Not all mandatory Properties specified", "Invalid alias", "Cannot read file", "Cannot write file", "Invalid FactorGraph file", "Invalid Evidence file", "Invalid Expectation-Maximization file", "Quantity not normalizable", "Multiple undo levels unsupported", "FactorGraph is not connected", "Internal error", "Runtime error", "Out of memory" }; } libDAI-0.2.7/src/decmap.cpp0000644000263000017630000001247011433220723014205 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include namespace dai { using namespace std; const char *DecMAP::Name = "DECMAP"; void DecMAP::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("ianame") ); DAI_ASSERT( opts.hasKey("iaopts") ); props.ianame = opts.getStringAs("ianame"); props.iaopts = opts.getStringAs("iaopts"); if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; if( opts.hasKey("reinit") ) props.reinit = opts.getStringAs("reinit"); else props.reinit = true; } PropertySet DecMAP::getProperties() const { PropertySet opts; opts.set( "verbose", props.verbose ); opts.set( "reinit", props.reinit ); opts.set( "ianame", props.ianame ); opts.set( "iaopts", props.iaopts ); return opts; } string DecMAP::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "verbose=" << props.verbose << ","; s << "reinit=" << props.reinit << ","; s << "ianame=" << props.ianame << ","; s << "iaopts=" << props.iaopts << "]"; return s.str(); } DecMAP::DecMAP( const FactorGraph& fg, const PropertySet& opts ) : DAIAlgFG(fg), _state(), _logp(), _maxdiff(), _iters(), props() { setProperties( opts ); _state = vector( nrVars(), 0 ); _logp = -INFINITY; } string DecMAP::identify() const { return string(Name) + printProperties(); } Factor DecMAP::belief( const VarSet& vs ) const { if( vs.size() == 0 ) return Factor(); else { map state; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) state[*v] = _state[findVar(*v)]; return createFactorDelta( vs, calcLinearState( vs, state ) ); } } Factor DecMAP::beliefV( size_t i ) const { return createFactorDelta( var(i), _state[i] ); } vector DecMAP::beliefs() const { vector result; for( size_t i = 0; i < nrVars(); ++i ) result.push_back( beliefV(i) ); for( size_t I = 0; I < nrFactors(); ++I ) result.push_back( beliefF(I) ); return result; } Real DecMAP::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 2 ) cerr << endl; // the variables which have not been clamped yet SmallSet freeVars; for( size_t i = 0; i < nrVars(); i++ ) freeVars |= i; // prepare the inference algorithm object InfAlg *clamped = newInfAlg( props.ianame, fg(), props.iaopts ); // decimate until no free variables remain while( freeVars.size() ) { Real md = clamped->run(); if( md > _maxdiff ) _maxdiff = md; _iters += clamped->Iterations(); // store the variables that need initialization VarSet varsToInit; SmallSet varsToClamp; // schedule clamping for the free variables with zero entropy for( SmallSet::const_iterator it = freeVars.begin(); it != freeVars.end(); ) { if( clamped->beliefV( *it ).entropy() == 0.0 ) { // this variable should be clamped varsToInit |= var( *it ); varsToClamp |= *it; _state[*it] = clamped->beliefV( *it ).p().argmax().first; freeVars.erase( *it ); } else it++; } // find the free factor with lowest entropy size_t bestI = 0; Real bestEnt = INFINITY; for( size_t I = 0; I < nrFactors(); I++ ) { // check if the factor is still free if( freeVars.intersects( bipGraph().nb2Set(I) ) ) { Real EntI = clamped->beliefF(I).entropy(); if( EntI < bestEnt ) { bestI = I; bestEnt = EntI; } } } // schedule clamping for the factor with lowest entropy vector Istate(1,0); Istate[0] = clamped->beliefF(bestI).p().argmax().first; map Istatemap = calcState( factor(bestI).vars(), Istate[0] ); foreach( size_t i, bipGraph().nb2Set(bestI) & freeVars ) { varsToInit |= var(i); varsToClamp |= i; _state[i] = Istatemap[var(i)]; freeVars.erase(i); } // clamp all variables scheduled for clamping foreach( size_t i, varsToClamp ) clamped->clamp( i, _state[i], false ); // initialize clamped for the next run if( props.reinit ) clamped->init(); else clamped->init( varsToInit ); } // calculate MAP state map state; for( size_t i = 0; i < nrVars(); i++ ) state[var(i)] = _state[i]; _logp = 0.0; for( size_t I = 0; I < nrFactors(); I++ ) _logp += dai::log( factor(I)[calcLinearState( factor(I).vars(), state )] ); // clean up delete clamped; return _maxdiff; } } // end of namespace dai libDAI-0.2.7/src/io.cpp0000644000263000017630000002221411433220723013360 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include namespace dai { using namespace std; void ReadUaiAieFactorGraphFile( const char *filename, size_t verbose, std::vector& vars, std::vector& factors, std::vector& permutations ) { vars.clear(); factors.clear(); permutations.clear(); // open file ifstream is; is.open( filename ); if( is.is_open() ) { size_t nrFacs, nrVars; string line; // read header line getline(is,line); if( is.fail() || line.size() == 0 ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"UAI factor graph file should start with nonempty header line"); if( line[line.size() - 1] == '\r' ) line.resize( line.size() - 1 ); // for DOS text files if( line != "BAYES" && line != "MARKOV" ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"UAI factor graph file should start with \"BAYES\" or \"MARKOV\""); if( verbose >= 2 ) cout << "Reading " << line << " network..." << endl; // read number of variables is >> nrVars; if( is.fail() ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read number of variables"); if( verbose >= 2 ) cout << "Reading " << nrVars << " variables..." << endl; // for each variable, read its number of states vars.reserve( nrVars ); for( size_t i = 0; i < nrVars; i++ ) { size_t dim; is >> dim; if( is.fail() ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read number of states of " + toString(i) + "'th variable"); vars.push_back( Var( i, dim ) ); } // read number of factors is >> nrFacs; if( is.fail() ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read number of factors"); if( verbose >= 2 ) cout << "Reading " << nrFacs << " factors..." << endl; // for each factor, read the variables on which it depends vector > factorVars; factors.reserve( nrFacs ); factorVars.reserve( nrFacs ); for( size_t I = 0; I < nrFacs; I++ ) { if( verbose >= 3 ) cout << "Reading factor " << I << "..." << endl; // read number of variables for factor I size_t I_nrVars; is >> I_nrVars; if( is.fail() ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read number of variables for " + toString(I) + "'th factor"); if( verbose >= 3 ) cout << " which depends on " << I_nrVars << " variables" << endl; // read the variable labels vector I_labels; vector I_dims; I_labels.reserve( I_nrVars ); I_dims.reserve( I_nrVars ); factorVars[I].reserve( I_nrVars ); for( size_t _i = 0; _i < I_nrVars; _i++ ) { long label; is >> label; if( is.fail() ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read variable labels for " + toString(I) + "'th factor"); I_labels.push_back( label ); I_dims.push_back( vars[label].states() ); factorVars[I].push_back( vars[label] ); } if( verbose >= 3 ) cout << " labels: " << I_labels << ", dimensions " << I_dims << endl; // add the factor and the labels factors.push_back( Factor( VarSet( factorVars[I].begin(), factorVars[I].end(), factorVars[I].size() ), (Real)0 ) ); } // for each factor, read its values permutations.reserve( nrFacs ); for( size_t I = 0; I < nrFacs; I++ ) { if( verbose >= 3 ) cout << "Reading factor " << I << "..." << endl; // calculate permutation object, reversing the indexing in factorVars[I] first Permute permindex( factorVars[I], true ); permutations.push_back( permindex ); // read factor values size_t nrNonZeros; is >> nrNonZeros; if( is.fail() ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read number of nonzero factor values for " + toString(I) + "'th factor"); if( verbose >= 3 ) cout << " number of nonzero values: " << nrNonZeros << endl; DAI_ASSERT( nrNonZeros == factors[I].nrStates() ); for( size_t li = 0; li < nrNonZeros; li++ ) { Real val; is >> val; if( is.fail() ) DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Cannot read factor values of " + toString(I) + "'th factor"); // assign value after calculating its linear index corresponding to the permutation if( verbose >= 4 ) cout << " " << li << "'th value " << val << " corresponds with index " << permindex.convertLinearIndex(li) << endl; factors[I].set( permindex.convertLinearIndex( li ), val ); } } if( verbose >= 3 ) cout << "variables:" << vars << endl; if( verbose >= 3 ) cout << "factors:" << factors << endl; // close file is.close(); } else DAI_THROWE(CANNOT_READ_FILE,"Cannot read from file " + std::string(filename)); } std::vector > ReadUaiAieEvidenceFile( const char* filename, size_t verbose ) { vector > evid; // open file ifstream is; string line; is.open( filename ); if( is.is_open() ) { // read number of lines getline( is, line ); if( is.fail() || line.size() == 0 ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Cannot read header line of evidence file"); if( line[line.size() - 1] == '\r' ) line.resize( line.size() - 1 ); // for DOS text files size_t nrLines = fromString( line ); if( verbose >= 2 ) cout << "Reading " << nrLines << " evidence file lines..." << endl; if( nrLines ) { // detect version (pre-2010 or 2010) streampos pos = is.tellg(); getline( is, line ); if( is.fail() || line.size() == 0 ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Cannot read second line of evidence file"); if( line[line.size() - 1] == '\r' ) line.resize( line.size() - 1 ); // for DOS text files vector cols; cols = tokenizeString( line, false, " \t" ); bool oldVersion = true; if( cols.size() % 2 ) oldVersion = false; if( verbose >= 2 ) { if( oldVersion ) cout << "Detected old (2006, 2008) evidence file format" << endl; else cout << "Detected new (2010) evidence file format" << endl; } size_t nrEvid; if( oldVersion ) { nrEvid = 1; is.seekg( 0 ); } else { nrEvid = nrLines; is.seekg( pos ); } // read all evidence cases if( verbose >= 2 ) cout << "Reading " << nrEvid << " evidence cases..." << endl; evid.resize( nrEvid ); for( size_t i = 0; i < nrEvid; i++ ) { // read number of variables size_t nrObs; is >> nrObs; if( is.fail() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Evidence case " + toString(i) + ": Cannot read number of observations"); if( verbose >= 2 ) cout << "Evidence case " << i << ": reading " << nrObs << " observations..." << endl; // for each observation, read the variable label and the observed value for( size_t j = 0; j < nrObs; j++ ) { size_t label, val; is >> label; if( is.fail() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Evidence case " + toString(i) + ": Cannot read label for " + toString(j) + "'th observed variable"); is >> val; if( is.fail() ) DAI_THROWE(INVALID_EVIDENCE_FILE,"Evidence case " + toString(i) + ": Cannot read value of " + toString(j) + "'th observed variable"); if( verbose >= 3 ) cout << " variable: " << label << ", value: " << val << endl; evid[i][label] = val; } } } // close file is.close(); } else DAI_THROWE(CANNOT_READ_FILE,"Cannot read from file " + std::string(filename)); if( evid.size() == 0 ) evid.resize( 1 ); return evid; } } // end of namespace dai libDAI-0.2.7/src/clustergraph.cpp0000644000263000017630000001035311433220723015455 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include namespace dai { using namespace std; ClusterGraph::ClusterGraph( const std::vector & cls ) : _G(), _vars(), _clusters() { // construct vars, clusters and edge list vector edges; foreach( const VarSet &cl, cls ) { if( find( clusters().begin(), clusters().end(), cl ) == clusters().end() ) { // add cluster size_t n2 = nrClusters(); _clusters.push_back( cl ); for( VarSet::const_iterator n = cl.begin(); n != cl.end(); n++ ) { size_t n1 = find( vars().begin(), vars().end(), *n ) - vars().begin(); if( n1 == nrVars() ) // add variable _vars.push_back( *n ); edges.push_back( Edge( n1, n2 ) ); } } // disregard duplicate clusters } // Create bipartite graph _G.construct( nrVars(), nrClusters(), edges.begin(), edges.end() ); } ClusterGraph::ClusterGraph( const FactorGraph& fg, bool onlyMaximal ) : _G( fg.bipGraph() ), _vars(), _clusters() { // copy variables _vars.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) _vars.push_back( fg.var(i) ); // copy clusters _clusters.reserve( fg.nrFactors() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) _clusters.push_back( fg.factor(I).vars() ); if( onlyMaximal ) eraseNonMaximal(); } size_t sequentialVariableElimination::operator()( const ClusterGraph &cl, const std::set &/*remainingVars*/ ) { return cl.findVar( seq.at(i++) ); } size_t greedyVariableElimination::operator()( const ClusterGraph &cl, const std::set &remainingVars ) { set::const_iterator lowest = remainingVars.end(); size_t lowest_cost = -1UL; for( set::const_iterator i = remainingVars.begin(); i != remainingVars.end(); i++ ) { size_t cost = heuristic( cl, *i ); if( lowest == remainingVars.end() || lowest_cost > cost ) { lowest = i; lowest_cost = cost; } } return *lowest; } size_t eliminationCost_MinNeighbors( const ClusterGraph &cl, size_t i ) { return cl.bipGraph().delta1( i ).size(); } size_t eliminationCost_MinWeight( const ClusterGraph &cl, size_t i ) { SmallSet id_n = cl.bipGraph().delta1( i ); size_t cost = 1; for( SmallSet::const_iterator it = id_n.begin(); it != id_n.end(); it++ ) cost *= cl.vars()[*it].states(); return cost; } size_t eliminationCost_MinFill( const ClusterGraph &cl, size_t i ) { SmallSet id_n = cl.bipGraph().delta1( i ); size_t cost = 0; // for each unordered pair {i1,i2} adjacent to n for( SmallSet::const_iterator it1 = id_n.begin(); it1 != id_n.end(); it1++ ) for( SmallSet::const_iterator it2 = it1; it2 != id_n.end(); it2++ ) if( it1 != it2 ) { // if i1 and i2 are not adjacent, eliminating n would make them adjacent if( !cl.adj(*it1, *it2) ) cost++; } return cost; } size_t eliminationCost_WeightedMinFill( const ClusterGraph &cl, size_t i ) { SmallSet id_n = cl.bipGraph().delta1( i ); size_t cost = 0; // for each unordered pair {i1,i2} adjacent to n for( SmallSet::const_iterator it1 = id_n.begin(); it1 != id_n.end(); it1++ ) for( SmallSet::const_iterator it2 = it1; it2 != id_n.end(); it2++ ) if( it1 != it2 ) { // if i1 and i2 are not adjacent, eliminating n would make them adjacent if( !cl.adj(*it1, *it2) ) cost += cl.vars()[*it1].states() * cl.vars()[*it2].states(); } return cost; } } // end of namespace dai libDAI-0.2.7/src/varset.cpp0000644000263000017630000000232611433220723014257 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ #include namespace dai { using namespace std; size_t calcLinearState( const VarSet &vs, const std::map &state ) { size_t prod = 1; size_t st = 0; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) { std::map::const_iterator m = state.find( *v ); if( m != state.end() ) st += prod * m->second; prod *= v->states(); } return st; } std::map calcState( const VarSet &vs, size_t linearState ) { std::map state; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) { state[*v] = linearState % v->states(); linearState /= v->states(); } DAI_ASSERT( linearState == 0 ); return state; } } // end of namespace dai libDAI-0.2.7/src/bbp.cpp0000644000263000017630000012225411433220723013521 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ #include #include #include #include #include namespace dai { using namespace std; /// Returns the entry of the I'th factor corresponding to a global state size_t getFactorEntryForState( const FactorGraph &fg, size_t I, const vector &state ) { size_t f_entry = 0; for( int _j = fg.nbF(I).size() - 1; _j >= 0; _j-- ) { // note that iterating over nbF(I) yields the same ordering // of variables as iterating over factor(I).vars() size_t j = fg.nbF(I)[_j]; f_entry *= fg.var(j).states(); f_entry += state[j]; } return f_entry; } bool BBPCostFunction::needGibbsState() const { switch( (size_t)(*this) ) { case CFN_GIBBS_B: case CFN_GIBBS_B2: case CFN_GIBBS_EXP: case CFN_GIBBS_B_FACTOR: case CFN_GIBBS_B2_FACTOR: case CFN_GIBBS_EXP_FACTOR: return true; default: return false; } } Real BBPCostFunction::evaluate( const InfAlg &ia, const vector *stateP ) const { Real cf = 0.0; const FactorGraph &fg = ia.fg(); switch( (size_t)(*this) ) { case CFN_BETHE_ENT: // ignores state cf = -ia.logZ(); break; case CFN_VAR_ENT: // ignores state for( size_t i = 0; i < fg.nrVars(); i++ ) cf += -ia.beliefV(i).entropy(); break; case CFN_FACTOR_ENT: // ignores state for( size_t I = 0; I < fg.nrFactors(); I++ ) cf += -ia.beliefF(I).entropy(); break; case CFN_GIBBS_B: case CFN_GIBBS_B2: case CFN_GIBBS_EXP: { DAI_ASSERT( stateP != NULL ); vector state = *stateP; DAI_ASSERT( state.size() == fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) { Real b = ia.beliefV(i)[state[i]]; switch( (size_t)(*this) ) { case CFN_GIBBS_B: cf += b; break; case CFN_GIBBS_B2: cf += b * b / 2.0; break; case CFN_GIBBS_EXP: cf += exp( b ); break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } } break; } case CFN_GIBBS_B_FACTOR: case CFN_GIBBS_B2_FACTOR: case CFN_GIBBS_EXP_FACTOR: { DAI_ASSERT( stateP != NULL ); vector state = *stateP; DAI_ASSERT( state.size() == fg.nrVars() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t x_I = getFactorEntryForState( fg, I, state ); Real b = ia.beliefF(I)[x_I]; switch( (size_t)(*this) ) { case CFN_GIBBS_B_FACTOR: cf += b; break; case CFN_GIBBS_B2_FACTOR: cf += b * b / 2.0; break; case CFN_GIBBS_EXP_FACTOR: cf += exp( b ); break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } } break; } default: DAI_THROWE(UNKNOWN_ENUM_VALUE, "Unknown cost function " + std::string(*this)); } return cf; } #define LOOP_ij(body) { \ size_t i_states = _fg->var(i).states(); \ size_t j_states = _fg->var(j).states(); \ if(_fg->var(i) > _fg->var(j)) { \ size_t xij=0; \ for(size_t xi=0; xi _ind_t; // std::vector > _indices; _indices.resize( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { _indices[i].clear(); _indices[i].reserve( _fg->nbV(i).size() ); foreach( const Neighbor &I, _fg->nbV(i) ) { _ind_t index; index.reserve( _fg->factor(I).nrStates() ); for( IndexFor k(_fg->var(i), _fg->factor(I).vars()); k.valid(); ++k ) index.push_back( k ); _indices[i].push_back( index ); } } } void BBP::RegenerateT() { // _Tmsg[i][_I] _Tmsg.resize( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { _Tmsg[i].resize( _fg->nbV(i).size() ); foreach( const Neighbor &I, _fg->nbV(i) ) { Prob prod( _fg->var(i).states(), 1.0 ); foreach( const Neighbor &J, _fg->nbV(i) ) if( J.node != I.node ) prod *= _bp_dual.msgM( i, J.iter ); _Tmsg[i][I.iter] = prod; } } } void BBP::RegenerateU() { // _Umsg[I][_i] _Umsg.resize( _fg->nrFactors() ); for( size_t I = 0; I < _fg->nrFactors(); I++ ) { _Umsg[I].resize( _fg->nbF(I).size() ); foreach( const Neighbor &i, _fg->nbF(I) ) { Prob prod( _fg->factor(I).nrStates(), 1.0 ); foreach( const Neighbor &j, _fg->nbF(I) ) if( i.node != j.node ) { Prob n_jI( _bp_dual.msgN( j, j.dual ) ); const _ind_t &ind = _index( j, j.dual ); // multiply prod by n_jI for( size_t x_I = 0; x_I < prod.size(); x_I++ ) prod.set( x_I, prod[x_I] * n_jI[ind[x_I]] ); } _Umsg[I][i.iter] = prod; } } } void BBP::RegenerateS() { // _Smsg[i][_I][_j] _Smsg.resize( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { _Smsg[i].resize( _fg->nbV(i).size() ); foreach( const Neighbor &I, _fg->nbV(i) ) { _Smsg[i][I.iter].resize( _fg->nbF(I).size() ); foreach( const Neighbor &j, _fg->nbF(I) ) if( i != j ) { Factor prod( _fg->factor(I) ); foreach( const Neighbor &k, _fg->nbF(I) ) { if( k != i && k.node != j.node ) { const _ind_t &ind = _index( k, k.dual ); Prob p( _bp_dual.msgN( k, k.dual ) ); for( size_t x_I = 0; x_I < prod.nrStates(); x_I++ ) prod.set( x_I, prod[x_I] * p[ind[x_I]] ); } } // "Marginalize" onto i|j (unnormalized) Prob marg; marg = prod.marginal( VarSet(_fg->var(i), _fg->var(j)), false ).p(); _Smsg[i][I.iter][j.iter] = marg; } } } } void BBP::RegenerateR() { // _Rmsg[I][_i][_J] _Rmsg.resize( _fg->nrFactors() ); for( size_t I = 0; I < _fg->nrFactors(); I++ ) { _Rmsg[I].resize( _fg->nbF(I).size() ); foreach( const Neighbor &i, _fg->nbF(I) ) { _Rmsg[I][i.iter].resize( _fg->nbV(i).size() ); foreach( const Neighbor &J, _fg->nbV(i) ) { if( I != J ) { Prob prod( _fg->var(i).states(), 1.0 ); foreach( const Neighbor &K, _fg->nbV(i) ) if( K.node != I && K.node != J.node ) prod *= _bp_dual.msgM( i, K.iter ); _Rmsg[I][i.iter][J.iter] = prod; } } } } } void BBP::RegenerateInputs() { _adj_b_V_unnorm.clear(); _adj_b_V_unnorm.reserve( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) _adj_b_V_unnorm.push_back( unnormAdjoint( _bp_dual.beliefV(i).p(), _bp_dual.beliefVZ(i), _adj_b_V[i] ) ); _adj_b_F_unnorm.clear(); _adj_b_F_unnorm.reserve( _fg->nrFactors() ); for( size_t I = 0; I < _fg->nrFactors(); I++ ) _adj_b_F_unnorm.push_back( unnormAdjoint( _bp_dual.beliefF(I).p(), _bp_dual.beliefFZ(I), _adj_b_F[I] ) ); } void BBP::RegeneratePsiAdjoints() { _adj_psi_V.clear(); _adj_psi_V.reserve( _fg->nrVars() ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { Prob p( _adj_b_V_unnorm[i] ); DAI_ASSERT( p.size() == _fg->var(i).states() ); foreach( const Neighbor &I, _fg->nbV(i) ) p *= _bp_dual.msgM( i, I.iter ); p += _init_adj_psi_V[i]; _adj_psi_V.push_back( p ); } _adj_psi_F.clear(); _adj_psi_F.reserve( _fg->nrFactors() ); for( size_t I = 0; I < _fg->nrFactors(); I++ ) { Prob p( _adj_b_F_unnorm[I] ); DAI_ASSERT( p.size() == _fg->factor(I).nrStates() ); foreach( const Neighbor &i, _fg->nbF(I) ) { Prob n_iI( _bp_dual.msgN( i, i.dual ) ); const _ind_t& ind = _index( i, i.dual ); // multiply prod with n_jI for( size_t x_I = 0; x_I < p.size(); x_I++ ) p.set( x_I, p[x_I] * n_iI[ind[x_I]] ); } p += _init_adj_psi_F[I]; _adj_psi_F.push_back( p ); } } void BBP::RegenerateParMessageAdjoints() { size_t nv = _fg->nrVars(); _adj_n.resize( nv ); _adj_m.resize( nv ); _adj_n_unnorm.resize( nv ); _adj_m_unnorm.resize( nv ); _new_adj_n.resize( nv ); _new_adj_m.resize( nv ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { size_t n_i = _fg->nbV(i).size(); _adj_n[i].resize( n_i ); _adj_m[i].resize( n_i ); _adj_n_unnorm[i].resize( n_i ); _adj_m_unnorm[i].resize( n_i ); _new_adj_n[i].resize( n_i ); _new_adj_m[i].resize( n_i ); foreach( const Neighbor &I, _fg->nbV(i) ) { { // calculate adj_n Prob prod( _fg->factor(I).p() ); prod *= _adj_b_F_unnorm[I]; foreach( const Neighbor &j, _fg->nbF(I) ) if( i != j ) { Prob n_jI( _bp_dual.msgN( j, j.dual ) ); const _ind_t &ind = _index( j, j.dual ); // multiply prod with n_jI for( size_t x_I = 0; x_I < prod.size(); x_I++ ) prod.set( x_I, prod[x_I] * n_jI[ind[x_I]] ); } Prob marg( _fg->var(i).states(), 0.0 ); const _ind_t &ind = _index( i, I.iter ); for( size_t r = 0; r < prod.size(); r++ ) marg.set( ind[r], marg[ind[r]] + prod[r] ); _new_adj_n[i][I.iter] = marg; upMsgN( i, I.iter ); } { // calculate adj_m Prob prod( _adj_b_V_unnorm[i] ); DAI_ASSERT( prod.size() == _fg->var(i).states() ); foreach( const Neighbor &J, _fg->nbV(i) ) if( J.node != I.node ) prod *= _bp_dual.msgM(i,J.iter); _new_adj_m[i][I.iter] = prod; upMsgM( i, I.iter ); } } } } void BBP::RegenerateSeqMessageAdjoints() { size_t nv = _fg->nrVars(); _adj_m.resize( nv ); _adj_m_unnorm.resize( nv ); _new_adj_m.resize( nv ); for( size_t i = 0; i < _fg->nrVars(); i++ ) { size_t n_i = _fg->nbV(i).size(); _adj_m[i].resize( n_i ); _adj_m_unnorm[i].resize( n_i ); _new_adj_m[i].resize( n_i ); foreach( const Neighbor &I, _fg->nbV(i) ) { // calculate adj_m Prob prod( _adj_b_V_unnorm[i] ); DAI_ASSERT( prod.size() == _fg->var(i).states() ); foreach( const Neighbor &J, _fg->nbV(i) ) if( J.node != I.node ) prod *= _bp_dual.msgM( i, J.iter ); _adj_m[i][I.iter] = prod; calcUnnormMsgM( i, I.iter ); _new_adj_m[i][I.iter] = Prob( _fg->var(i).states(), 0.0 ); } } for( size_t i = 0; i < _fg->nrVars(); i++ ) { foreach( const Neighbor &I, _fg->nbV(i) ) { // calculate adj_n Prob prod( _fg->factor(I).p() ); prod *= _adj_b_F_unnorm[I]; foreach( const Neighbor &j, _fg->nbF(I) ) if( i != j ) { Prob n_jI( _bp_dual.msgN( j, j.dual) ); const _ind_t& ind = _index( j, j.dual ); // multiply prod with n_jI for( size_t x_I = 0; x_I < prod.size(); x_I++ ) prod.set( x_I, prod[x_I] * n_jI[ind[x_I]] ); } Prob marg( _fg->var(i).states(), 0.0 ); const _ind_t &ind = _index( i, I.iter ); for( size_t r = 0; r < prod.size(); r++ ) marg.set( ind[r], marg[ind[r]] + prod[r] ); sendSeqMsgN( i, I.iter,marg ); } } } void BBP::Regenerate() { RegenerateInds(); RegenerateT(); RegenerateU(); RegenerateS(); RegenerateR(); RegenerateInputs(); RegeneratePsiAdjoints(); if( props.updates == Properties::UpdateType::PAR ) RegenerateParMessageAdjoints(); else RegenerateSeqMessageAdjoints(); _iters = 0; } void BBP::calcNewN( size_t i, size_t _I ) { _adj_psi_V[i] += T(i,_I) * _adj_n_unnorm[i][_I]; Prob &new_adj_n_iI = _new_adj_n[i][_I]; new_adj_n_iI = Prob( _fg->var(i).states(), 0.0 ); size_t I = _fg->nbV(i)[_I]; foreach( const Neighbor &j, _fg->nbF(I) ) if( j != i ) { const Prob &p = _Smsg[i][_I][j.iter]; const Prob &_adj_m_unnorm_jI = _adj_m_unnorm[j][j.dual]; LOOP_ij( new_adj_n_iI.set( xi, new_adj_n_iI[xi] + p[xij] * _adj_m_unnorm_jI[xj] ); ); /* THE FOLLOWING WOULD BE ABOUT TWICE AS SLOW: Var vi = _fg->var(i); Var vj = _fg->var(j); new_adj_n_iI = (Factor(VarSet(vi, vj), p) * Factor(vj,_adj_m_unnorm_jI)).marginal(vi,false).p(); */ } } void BBP::calcNewM( size_t i, size_t _I ) { const Neighbor &I = _fg->nbV(i)[_I]; Prob p( U(I, I.dual) ); const Prob &adj = _adj_m_unnorm[i][_I]; const _ind_t &ind = _index(i,_I); for( size_t x_I = 0; x_I < p.size(); x_I++ ) p.set( x_I, p[x_I] * adj[ind[x_I]] ); _adj_psi_F[I] += p; /* THE FOLLOWING WOULD BE SLIGHTLY SLOWER: _adj_psi_F[I] += (Factor( _fg->factor(I).vars(), U(I, I.dual) ) * Factor( _fg->var(i), _adj_m_unnorm[i][_I] )).p(); */ _new_adj_m[i][_I] = Prob( _fg->var(i).states(), 0.0 ); foreach( const Neighbor &J, _fg->nbV(i) ) if( J != I ) _new_adj_m[i][_I] += _Rmsg[I][I.dual][J.iter] * _adj_n_unnorm[i][J.iter]; } void BBP::calcUnnormMsgN( size_t i, size_t _I ) { _adj_n_unnorm[i][_I] = unnormAdjoint( _bp_dual.msgN(i,_I), _bp_dual.zN(i,_I), _adj_n[i][_I] ); } void BBP::calcUnnormMsgM( size_t i, size_t _I ) { _adj_m_unnorm[i][_I] = unnormAdjoint( _bp_dual.msgM(i,_I), _bp_dual.zM(i,_I), _adj_m[i][_I] ); } void BBP::upMsgN( size_t i, size_t _I ) { _adj_n[i][_I] = _new_adj_n[i][_I]; calcUnnormMsgN( i, _I ); } void BBP::upMsgM( size_t i, size_t _I ) { _adj_m[i][_I] = _new_adj_m[i][_I]; calcUnnormMsgM( i, _I ); } void BBP::doParUpdate() { for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { calcNewM( i, I.iter ); calcNewN( i, I.iter ); } for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { upMsgM( i, I.iter ); upMsgN( i, I.iter ); } } void BBP::incrSeqMsgM( size_t i, size_t _I, const Prob &p ) { /* if( props.clean_updates ) _new_adj_m[i][_I] += p; else {*/ _adj_m[i][_I] += p; calcUnnormMsgM(i, _I); // } } #if 0 Real pv_thresh=1000; #endif /* void BBP::updateSeqMsgM( size_t i, size_t _I ) { if( props.clean_updates ) { #if 0 if(_new_adj_m[i][_I].sumAbs() > pv_thresh || _adj_m[i][_I].sumAbs() > pv_thresh) { DAI_DMSG("in updateSeqMsgM"); DAI_PV(i); DAI_PV(_I); DAI_PV(_adj_m[i][_I]); DAI_PV(_new_adj_m[i][_I]); } #endif _adj_m[i][_I] += _new_adj_m[i][_I]; calcUnnormMsgM( i, _I ); _new_adj_m[i][_I].fill( 0.0 ); } } */ void BBP::setSeqMsgM( size_t i, size_t _I, const Prob &p ) { _adj_m[i][_I] = p; calcUnnormMsgM( i, _I ); } void BBP::sendSeqMsgN( size_t i, size_t _I, const Prob &f ) { Prob f_unnorm = unnormAdjoint( _bp_dual.msgN(i,_I), _bp_dual.zN(i,_I), f ); const Neighbor &I = _fg->nbV(i)[_I]; DAI_ASSERT( I.iter == _I ); _adj_psi_V[i] += f_unnorm * T( i, _I ); #if 0 if(f_unnorm.sumAbs() > pv_thresh) { DAI_DMSG("in sendSeqMsgN"); DAI_PV(i); DAI_PV(I); DAI_PV(_I); DAI_PV(_bp_dual.msgN(i,_I)); DAI_PV(_bp_dual.zN(i,_I)); DAI_PV(_bp_dual.msgM(i,_I)); DAI_PV(_bp_dual.zM(i,_I)); DAI_PV(_fg->factor(I).p()); } #endif foreach( const Neighbor &J, _fg->nbV(i) ) { if( J.node != I.node ) { #if 0 if(f_unnorm.sumAbs() > pv_thresh) { DAI_DMSG("in sendSeqMsgN loop"); DAI_PV(J); DAI_PV(f_unnorm); DAI_PV(_Rmsg[J][J.dual][_I]); DAI_PV(f_unnorm * _Rmsg[J][J.dual][_I]); } #endif incrSeqMsgM( i, J.iter, f_unnorm * R(J, J.dual, _I) ); } } } void BBP::sendSeqMsgM( size_t j, size_t _I ) { const Neighbor &I = _fg->nbV(j)[_I]; // DAI_PV(j); // DAI_PV(I); // DAI_PV(_adj_m_unnorm_jI); // DAI_PV(_adj_m[j][_I]); // DAI_PV(_bp_dual.zM(j,_I)); size_t _j = I.dual; const Prob &_adj_m_unnorm_jI = _adj_m_unnorm[j][_I]; Prob um( U(I, _j) ); const _ind_t &ind = _index(j, _I); for( size_t x_I = 0; x_I < um.size(); x_I++ ) um.set( x_I, um[x_I] * _adj_m_unnorm_jI[ind[x_I]] ); um *= 1 - props.damping; _adj_psi_F[I] += um; /* THE FOLLOWING WOULD BE SLIGHTLY SLOWER: _adj_psi_F[I] += (Factor( _fg->factor(I).vars(), U(I, _j) ) * Factor( _fg->var(j), _adj_m_unnorm[j][_I] )).p() * (1.0 - props.damping); */ // DAI_DMSG("in sendSeqMsgM"); // DAI_PV(j); // DAI_PV(I); // DAI_PV(_I); // DAI_PV(_fg->nbF(I).size()); foreach( const Neighbor &i, _fg->nbF(I) ) { if( i.node != j ) { const Prob &S = _Smsg[i][i.dual][_j]; Prob msg( _fg->var(i).states(), 0.0 ); LOOP_ij( msg.set( xi, msg[xi] + S[xij] * _adj_m_unnorm_jI[xj] ); ); msg *= 1.0 - props.damping; /* THE FOLLOWING WOULD BE ABOUT TWICE AS SLOW: Var vi = _fg->var(i); Var vj = _fg->var(j); msg = (Factor(VarSet(vi,vj), S) * Factor(vj,_adj_m_unnorm_jI)).marginal(vi,false).p() * (1.0 - props.damping); */ #if 0 if(msg.sumAbs() > pv_thresh) { DAI_DMSG("in sendSeqMsgM loop"); DAI_PV(j); DAI_PV(I); DAI_PV(_I); DAI_PV(_fg->nbF(I).size()); DAI_PV(_fg->factor(I).p()); DAI_PV(_Smsg[i][i.dual][_j]); DAI_PV(i); DAI_PV(i.dual); DAI_PV(msg); DAI_PV(_fg->nbV(i).size()); } #endif DAI_ASSERT( _fg->nbV(i)[i.dual].node == I ); sendSeqMsgN( i, i.dual, msg ); } } setSeqMsgM( j, _I, _adj_m[j][_I] * props.damping ); } Prob BBP::unnormAdjoint( const Prob &w, Real Z_w, const Prob &adj_w ) { DAI_ASSERT( w.size() == adj_w.size() ); Prob adj_w_unnorm( w.size(), 0.0 ); Real s = 0.0; for( size_t i = 0; i < w.size(); i++ ) s += w[i] * adj_w[i]; for( size_t i = 0; i < w.size(); i++ ) adj_w_unnorm.set( i, (adj_w[i] - s) / Z_w ); return adj_w_unnorm; // THIS WOULD BE ABOUT 50% SLOWER: return (adj_w - (w * adj_w).sum()) / Z_w; } Real BBP::getUnMsgMag() { Real s = 0.0; size_t e = 0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { s += _adj_m_unnorm[i][I.iter].sumAbs(); s += _adj_n_unnorm[i][I.iter].sumAbs(); e++; } return s / e; } void BBP::getMsgMags( Real &s, Real &new_s ) { s = 0.0; new_s = 0.0; size_t e = 0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { s += _adj_m[i][I.iter].sumAbs(); s += _adj_n[i][I.iter].sumAbs(); new_s += _new_adj_m[i][I.iter].sumAbs(); new_s += _new_adj_n[i][I.iter].sumAbs(); e++; } s /= e; new_s /= e; } // tuple BBP::getArgMaxPsi1Adj() { // size_t argmax_var=0; // size_t argmax_var_state=0; // Real max_var=0; // for( size_t i = 0; i < _fg->nrVars(); i++ ) { // pair argmax_state = adj_psi_V(i).argmax(); // if(i==0 || argmax_state.second>max_var) { // argmax_var = i; // max_var = argmax_state.second; // argmax_var_state = argmax_state.first; // } // } // DAI_ASSERT(/*0 <= argmax_var_state &&*/ // argmax_var_state < _fg->var(argmax_var).states()); // return tuple(argmax_var,argmax_var_state,max_var); // } void BBP::getArgmaxMsgM( size_t &out_i, size_t &out__I, Real &mag ) { bool found = false; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) { Real thisMag = _adj_m[i][I.iter].sumAbs(); if( !found || mag < thisMag ) { found = true; mag = thisMag; out_i = i; out__I = I.iter; } } DAI_ASSERT( found ); } Real BBP::getMaxMsgM() { size_t dummy; Real mag; getArgmaxMsgM( dummy, dummy, mag ); return mag; } Real BBP::getTotalMsgM() { Real mag = 0.0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) mag += _adj_m[i][I.iter].sumAbs(); return mag; } Real BBP::getTotalNewMsgM() { Real mag = 0.0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) mag += _new_adj_m[i][I.iter].sumAbs(); return mag; } Real BBP::getTotalMsgN() { Real mag = 0.0; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) mag += _adj_n[i][I.iter].sumAbs(); return mag; } std::vector BBP::getZeroAdjF( const FactorGraph &fg ) { vector adj_2; adj_2.reserve( fg.nrFactors() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) adj_2.push_back( Prob( fg.factor(I).nrStates(), 0.0 ) ); return adj_2; } std::vector BBP::getZeroAdjV( const FactorGraph &fg ) { vector adj_1; adj_1.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) adj_1.push_back( Prob( fg.var(i).states(), 0.0 ) ); return adj_1; } void BBP::initCostFnAdj( const BBPCostFunction &cfn, const vector *stateP ) { const FactorGraph &fg = _ia->fg(); switch( (size_t)cfn ) { case BBPCostFunction::CFN_BETHE_ENT: { vector b1_adj; vector b2_adj; vector psi1_adj; vector psi2_adj; b1_adj.reserve( fg.nrVars() ); psi1_adj.reserve( fg.nrVars() ); b2_adj.reserve( fg.nrFactors() ); psi2_adj.reserve( fg.nrFactors() ); for( size_t i = 0; i < fg.nrVars(); i++ ) { size_t dim = fg.var(i).states(); int c = fg.nbV(i).size(); Prob p(dim,0.0); for( size_t xi = 0; xi < dim; xi++ ) p.set( xi, (1 - c) * (1 + log( _ia->beliefV(i)[xi] )) ); b1_adj.push_back( p ); for( size_t xi = 0; xi < dim; xi++ ) p.set( xi, -_ia->beliefV(i)[xi] ); psi1_adj.push_back( p ); } for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t dim = fg.factor(I).nrStates(); Prob p( dim, 0.0 ); for( size_t xI = 0; xI < dim; xI++ ) p.set( xI, 1 + log( _ia->beliefF(I)[xI] / fg.factor(I).p()[xI] ) ); b2_adj.push_back( p ); for( size_t xI = 0; xI < dim; xI++ ) p.set( xI, -_ia->beliefF(I)[xI] / fg.factor(I).p()[xI] ); psi2_adj.push_back( p ); } init( b1_adj, b2_adj, psi1_adj, psi2_adj ); break; } case BBPCostFunction::CFN_FACTOR_ENT: { vector b2_adj; b2_adj.reserve( fg.nrFactors() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t dim = fg.factor(I).nrStates(); Prob p( dim, 0.0 ); for( size_t xI = 0; xI < dim; xI++ ) { Real bIxI = _ia->beliefF(I)[xI]; if( bIxI < 1.0e-15 ) p.set( xI, -1.0e10 ); else p.set( xI, 1 + log( bIxI ) ); } b2_adj.push_back(p); } init_F( b2_adj ); break; } case BBPCostFunction::CFN_VAR_ENT: { vector b1_adj; b1_adj.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) { size_t dim = fg.var(i).states(); Prob p( dim, 0.0 ); for( size_t xi = 0; xi < fg.var(i).states(); xi++ ) { Real bixi = _ia->beliefV(i)[xi]; if( bixi < 1.0e-15 ) p.set( xi, -1.0e10 ); else p.set( xi, 1 + log( bixi ) ); } b1_adj.push_back( p ); } init_V( b1_adj ); break; } case BBPCostFunction::CFN_GIBBS_B: case BBPCostFunction::CFN_GIBBS_B2: case BBPCostFunction::CFN_GIBBS_EXP: { // cost functions that use Gibbs sample, summing over variable marginals vector state; if( stateP == NULL ) state = getGibbsState( _ia->fg(), 2*_ia->Iterations() ); else state = *stateP; DAI_ASSERT( state.size() == fg.nrVars() ); vector b1_adj; b1_adj.reserve(fg.nrVars()); for( size_t i = 0; i < state.size(); i++ ) { size_t n = fg.var(i).states(); Prob delta( n, 0.0 ); DAI_ASSERT(/*0<=state[i] &&*/ state[i] < n); Real b = _ia->beliefV(i)[state[i]]; switch( (size_t)cfn ) { case BBPCostFunction::CFN_GIBBS_B: delta.set( state[i], 1.0 ); break; case BBPCostFunction::CFN_GIBBS_B2: delta.set( state[i], b ); break; case BBPCostFunction::CFN_GIBBS_EXP: delta.set( state[i], exp(b) ); break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } b1_adj.push_back( delta ); } init_V( b1_adj ); break; } case BBPCostFunction::CFN_GIBBS_B_FACTOR: case BBPCostFunction::CFN_GIBBS_B2_FACTOR: case BBPCostFunction::CFN_GIBBS_EXP_FACTOR: { // cost functions that use Gibbs sample, summing over factor marginals vector state; if( stateP == NULL ) state = getGibbsState( _ia->fg(), 2*_ia->Iterations() ); else state = *stateP; DAI_ASSERT( state.size() == fg.nrVars() ); vector b2_adj; b2_adj.reserve( fg.nrVars() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) { size_t n = fg.factor(I).nrStates(); Prob delta( n, 0.0 ); size_t x_I = getFactorEntryForState( fg, I, state ); DAI_ASSERT(/*0<=x_I &&*/ x_I < n); Real b = _ia->beliefF(I)[x_I]; switch( (size_t)cfn ) { case BBPCostFunction::CFN_GIBBS_B_FACTOR: delta.set( x_I, 1.0 ); break; case BBPCostFunction::CFN_GIBBS_B2_FACTOR: delta.set( x_I, b ); break; case BBPCostFunction::CFN_GIBBS_EXP_FACTOR: delta.set( x_I, exp( b ) ); break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } b2_adj.push_back( delta ); } init_F( b2_adj ); break; } default: DAI_THROW(UNKNOWN_ENUM_VALUE); } } void BBP::run() { typedef BBP::Properties::UpdateType UT; Real tol = props.tol; UT &updates = props.updates; Real tic = toc(); switch( (size_t)updates ) { case UT::SEQ_MAX: { size_t i, _I; Real mag; do { _iters++; getArgmaxMsgM( i, _I, mag ); sendSeqMsgM( i, _I ); } while( mag > tol && _iters < props.maxiter ); if( _iters >= props.maxiter ) if( props.verbose >= 1 ) cerr << "Warning: BBP didn't converge in " << _iters << " iterations (greatest message magnitude = " << mag << ")" << endl; break; } case UT::SEQ_FIX: { Real mag; do { _iters++; mag = getTotalMsgM(); if( mag < tol ) break; for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) sendSeqMsgM( i, I.iter ); /* for( size_t i = 0; i < _fg->nrVars(); i++ ) foreach( const Neighbor &I, _fg->nbV(i) ) updateSeqMsgM( i, I.iter );*/ } while( mag > tol && _iters < props.maxiter ); if( _iters >= props.maxiter ) if( props.verbose >= 1 ) cerr << "Warning: BBP didn't converge in " << _iters << " iterations (greatest message magnitude = " << mag << ")" << endl; break; } case UT::SEQ_BP_REV: case UT::SEQ_BP_FWD: { const BP *bp = static_cast(_ia); vector > sentMessages = bp->getSentMessages(); size_t totalMessages = sentMessages.size(); if( totalMessages == 0 ) DAI_THROWE(INTERNAL_ERROR, "Asked for updates=" + std::string(updates) + " but no BP messages; did you forget to set recordSentMessages?"); if( updates==UT::SEQ_BP_FWD ) reverse( sentMessages.begin(), sentMessages.end() ); // DAI_PV(sentMessages.size()); // DAI_PV(_iters); // DAI_PV(props.maxiter); while( sentMessages.size() > 0 && _iters < props.maxiter ) { // DAI_PV(sentMessages.size()); // DAI_PV(_iters); _iters++; pair e = sentMessages.back(); sentMessages.pop_back(); size_t i = e.first, _I = e.second; sendSeqMsgM( i, _I ); } if( _iters >= props.maxiter ) if( props.verbose >= 1 ) cerr << "Warning: BBP updates limited to " << props.maxiter << " iterations, but using UpdateType " << updates << " with " << totalMessages << " messages" << endl; break; } case UT::PAR: { do { _iters++; doParUpdate(); } while( (_iters < 2 || getUnMsgMag() > tol) && _iters < props.maxiter ); if( _iters == props.maxiter ) { Real s, new_s; getMsgMags( s, new_s ); if( props.verbose >= 1 ) cerr << "Warning: BBP didn't converge in " << _iters << " iterations (unnorm message magnitude = " << getUnMsgMag() << ", norm message mags = " << s << " -> " << new_s << ")" << endl; } break; } } if( props.verbose >= 3 ) cerr << "BBP::run() took " << toc()-tic << " seconds " << Iterations() << " iterations" << endl; } Real numericBBPTest( const InfAlg &bp, const std::vector *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h ) { BBP bbp( &bp, bbp_props ); // calculate the value of the unperturbed cost function Real cf0 = cfn.evaluate( bp, state ); // run BBP to estimate adjoints bbp.initCostFnAdj( cfn, state ); bbp.run(); Real d = 0; const FactorGraph& fg = bp.fg(); if( 1 ) { // verify bbp.adj_psi_V // for each variable i for( size_t i = 0; i < fg.nrVars(); i++ ) { vector adj_est; // for each value xi for( size_t xi = 0; xi < fg.var(i).states(); xi++ ) { // Clone 'bp' (which may be any InfAlg) InfAlg *bp_prb = bp.clone(); // perturb it size_t n = bp_prb->fg().var(i).states(); Prob psi_1_prb( n, 1.0 ); psi_1_prb.set( xi, psi_1_prb[xi] + h ); // psi_1_prb.normalize(); size_t I = bp_prb->fg().nbV(i)[0]; // use first factor in list of neighbors of i Factor tmp = bp_prb->fg().factor(I) * Factor( bp_prb->fg().var(i), psi_1_prb ); bp_prb->fg().setFactor( I, tmp ); // call 'init' on the perturbed variables bp_prb->init( bp_prb->fg().var(i) ); // run copy to convergence bp_prb->run(); // calculate new value of cost function Real cf_prb = cfn.evaluate( *bp_prb, state ); // use to estimate adjoint for i adj_est.push_back( (cf_prb - cf0) / h ); // free cloned InfAlg delete bp_prb; } Prob p_adj_est( adj_est ); // compare this numerical estimate to the BBP estimate; sum the distances cout << "i: " << i << ", p_adj_est: " << p_adj_est << ", bbp.adj_psi_V(i): " << bbp.adj_psi_V(i) << endl; d += dist( p_adj_est, bbp.adj_psi_V(i), DISTL1 ); } } /* if(1) { // verify bbp.adj_n and bbp.adj_m // We actually want to check the responsiveness of objective // function to changes in the final messages. But at the end of a // BBP run, the message adjoints are for the initial messages (and // they should be close to zero, see paper). So this resets the // BBP adjoints to the refer to the desired final messages bbp.RegenerateMessageAdjoints(); // for each variable i for(size_t i=0; i adj_n_est; // for each value xi for(size_t xi=0; xi adj_m_est; // for each value xi for(size_t xi=0; xi adj_b_V_est; // for each value xi for(size_t xi=0; xi &keys = opts.keys(); std::string errormsg; for( std::set::const_iterator i = keys.begin(); i != keys.end(); i++ ) { if( *i == "verbose" ) continue; if( *i == "maxiter" ) continue; if( *i == "tol" ) continue; if( *i == "damping" ) continue; if( *i == "updates" ) continue; errormsg = errormsg + "BBP: Unknown property " + *i + "\n"; } if( !errormsg.empty() ) DAI_THROWE(UNKNOWN_PROPERTY, errormsg); if( !opts.hasKey("maxiter") ) errormsg = errormsg + "BBP: Missing property \"maxiter\" for method \"BBP\"\n"; if( !opts.hasKey("tol") ) errormsg = errormsg + "BBP: Missing property \"tol\" for method \"BBP\"\n"; if( !opts.hasKey("damping") ) errormsg = errormsg + "BBP: Missing property \"damping\" for method \"BBP\"\n"; if( !opts.hasKey("updates") ) errormsg = errormsg + "BBP: Missing property \"updates\" for method \"BBP\"\n"; if( !errormsg.empty() ) DAI_THROWE(NOT_ALL_PROPERTIES_SPECIFIED,errormsg); if( opts.hasKey("verbose") ) { verbose = opts.getStringAs("verbose"); } else { verbose = 0; } maxiter = opts.getStringAs("maxiter"); tol = opts.getStringAs("tol"); damping = opts.getStringAs("damping"); updates = opts.getStringAs("updates"); } PropertySet BBP::Properties::get() const { PropertySet opts; opts.set("verbose", verbose); opts.set("maxiter", maxiter); opts.set("tol", tol); opts.set("damping", damping); opts.set("updates", updates); return opts; } string BBP::Properties::toString() const { stringstream s(stringstream::out); s << "["; s << "verbose=" << verbose << ","; s << "maxiter=" << maxiter << ","; s << "tol=" << tol << ","; s << "damping=" << damping << ","; s << "updates=" << updates; s << "]"; return s.str(); } } // end of namespace dai /* }}} END OF GENERATED CODE */ libDAI-0.2.7/src/daialg.cpp0000644000263000017630000002433011433220723014173 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include namespace dai { using namespace std; Factor calcMarginal( const InfAlg &obj, const VarSet &vs, bool reInit ) { Factor Pvs (vs); InfAlg *clamped = obj.clone(); if( !reInit ) clamped->init(); map varindices; for( VarSet::const_iterator n = vs.begin(); n != vs.end(); n++ ) varindices[*n] = obj.fg().findVar( *n ); Real logZ0 = -INFINITY; for( State s(vs); s.valid(); s++ ) { // save unclamped factors connected to vs clamped->backupFactors( vs ); // set clamping Factors to delta functions for( VarSet::const_iterator n = vs.begin(); n != vs.end(); n++ ) clamped->clamp( varindices[*n], s(*n) ); // run DAIAlg, calc logZ, store in Pvs if( reInit ) clamped->init(); else clamped->init(vs); Real logZ; try { clamped->run(); logZ = clamped->logZ(); } catch( Exception &e ) { if( e.code() == Exception::NOT_NORMALIZABLE ) logZ = -INFINITY; else throw; } if( logZ0 == -INFINITY ) if( logZ != -INFINITY ) logZ0 = logZ; if( logZ == -INFINITY ) Pvs.set( s, 0 ); else Pvs.set( s, exp(logZ - logZ0) ); // subtract logZ0 to avoid very large numbers // restore clamped factors clamped->restoreFactors( vs ); } delete clamped; return( Pvs.normalized() ); } vector calcPairBeliefs( const InfAlg & obj, const VarSet& vs, bool reInit, bool accurate ) { vector result; size_t N = vs.size(); result.reserve( N * (N - 1) / 2 ); InfAlg *clamped = obj.clone(); if( !reInit ) clamped->init(); map varindices; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) varindices[*v] = obj.fg().findVar( *v ); if( accurate ) { Real logZ0 = 0.0; VarSet::const_iterator nj = vs.begin(); for( long j = 0; j < (long)N - 1; j++, nj++ ) { size_t k = 0; for( VarSet::const_iterator nk = nj; (++nk) != vs.end(); k++ ) { Factor pairbelief( VarSet(*nj, *nk) ); // clamp Vars j and k to their possible values for( size_t j_val = 0; j_val < nj->states(); j_val++ ) for( size_t k_val = 0; k_val < nk->states(); k_val++ ) { // save unclamped factors connected to vs clamped->backupFactors( vs ); clamped->clamp( varindices[*nj], j_val ); clamped->clamp( varindices[*nk], k_val ); if( reInit ) clamped->init(); else clamped->init(vs); Real logZ; try { clamped->run(); logZ = clamped->logZ(); } catch( Exception &e ) { if( e.code() == Exception::NOT_NORMALIZABLE ) logZ = -INFINITY; else throw; } if( logZ0 == -INFINITY ) if( logZ != -INFINITY ) logZ0 = logZ; Real Z_xj; if( logZ == -INFINITY ) Z_xj = 0; else Z_xj = exp(logZ - logZ0); // subtract logZ0 to avoid very large numbers // we assume that j.label() < k.label() // i.e. we make an assumption here about the indexing pairbelief.set( j_val + (k_val * nj->states()), Z_xj ); // restore clamped factors clamped->restoreFactors( vs ); } result.push_back( pairbelief.normalized() ); } } } else { // convert vs to vector vector vvs( vs.begin(), vs.end() ); vector pairbeliefs; pairbeliefs.reserve( N * N ); for( size_t j = 0; j < N; j++ ) for( size_t k = 0; k < N; k++ ) if( j == k ) pairbeliefs.push_back( Factor() ); else pairbeliefs.push_back( Factor( VarSet(vvs[j], vvs[k]) ) ); Real logZ0 = -INFINITY; for( size_t j = 0; j < N; j++ ) { // clamp Var j to its possible values for( size_t j_val = 0; j_val < vvs[j].states(); j_val++ ) { clamped->clamp( varindices[vvs[j]], j_val, true ); if( reInit ) clamped->init(); else clamped->init(vs); Real logZ; try { clamped->run(); logZ = clamped->logZ(); } catch( Exception &e ) { if( e.code() == Exception::NOT_NORMALIZABLE ) logZ = -INFINITY; else throw; } if( logZ0 == -INFINITY ) if( logZ != -INFINITY ) logZ0 = logZ; Real Z_xj; if( logZ == -INFINITY ) Z_xj = 0; else Z_xj = exp(logZ - logZ0); // subtract logZ0 to avoid very large numbers for( size_t k = 0; k < N; k++ ) if( k != j ) { Factor b_k = clamped->belief(vvs[k]); for( size_t k_val = 0; k_val < vvs[k].states(); k_val++ ) if( vvs[j].label() < vvs[k].label() ) pairbeliefs[j * N + k].set( j_val + (k_val * vvs[j].states()), Z_xj * b_k[k_val] ); else pairbeliefs[j * N + k].set( k_val + (j_val * vvs[k].states()), Z_xj * b_k[k_val] ); } // restore clamped factors clamped->restoreFactors( vs ); } } // Calculate result by taking the geometric average for( size_t j = 0; j < N; j++ ) for( size_t k = j+1; k < N; k++ ) result.push_back( ((pairbeliefs[j * N + k] * pairbeliefs[k * N + j]) ^ 0.5).normalized() ); } delete clamped; return result; } std::vector findMaximum( const InfAlg& obj ) { vector maximum( obj.fg().nrVars() ); vector visitedVars( obj.fg().nrVars(), false ); vector visitedFactors( obj.fg().nrFactors(), false ); stack scheduledFactors; for( size_t i = 0; i < obj.fg().nrVars(); ++i ) { if( visitedVars[i] ) continue; visitedVars[i] = true; // Maximise with respect to variable i Prob prod = obj.beliefV(i).p(); maximum[i] = prod.argmax().first; foreach( const Neighbor &I, obj.fg().nbV(i) ) if( !visitedFactors[I] ) scheduledFactors.push(I); while( !scheduledFactors.empty() ){ size_t I = scheduledFactors.top(); scheduledFactors.pop(); if( visitedFactors[I] ) continue; visitedFactors[I] = true; // Evaluate if some neighboring variables still need to be fixed; if not, we're done bool allDetermined = true; foreach( const Neighbor &j, obj.fg().nbF(I) ) if( !visitedVars[j.node] ) { allDetermined = false; break; } if( allDetermined ) continue; // Get marginal of factor I Prob probF = obj.beliefF(I).p(); // The allowed configuration is restrained according to the variables assigned so far: // pick the argmax amongst the allowed states Real maxProb = -numeric_limits::max(); State maxState( obj.fg().factor(I).vars() ); for( State s( obj.fg().factor(I).vars() ); s.valid(); ++s ) { // First, calculate whether this state is consistent with variables that // have been assigned already bool allowedState = true; foreach( const Neighbor &j, obj.fg().nbF(I) ) if( visitedVars[j.node] && maximum[j.node] != s(obj.fg().var(j.node)) ) { allowedState = false; break; } // If it is consistent, check if its probability is larger than what we have seen so far if( allowedState && probF[s] > maxProb ) { maxState = s; maxProb = probF[s]; } } // Decode the argmax foreach( const Neighbor &j, obj.fg().nbF(I) ) { if( visitedVars[j.node] ) { // We have already visited j earlier - hopefully our state is consistent if( maximum[j.node] != maxState( obj.fg().var(j.node) ) ) DAI_THROWE(RUNTIME_ERROR,"MAP state inconsistent due to loops"); } else { // We found a consistent state for variable j visitedVars[j.node] = true; maximum[j.node] = maxState( obj.fg().var(j.node) ); foreach( const Neighbor &J, obj.fg().nbV(j) ) if( !visitedFactors[J] ) scheduledFactors.push(J); } } } } return maximum; } } // end of namespace dai libDAI-0.2.7/src/fbp.cpp0000644000263000017630000001206711433220723013525 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] * Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #define DAI_FBP_FAST 1 namespace dai { using namespace std; const char *FBP::Name = "FBP"; string FBP::identify() const { return string(Name) + printProperties(); } // This code has been copied from bp.cpp, except where comments indicate FBP-specific behaviour Real FBP::logZ() const { Real sum = 0.0; for( size_t I = 0; I < nrFactors(); I++ ) { sum += (beliefF(I) * factor(I).log(true)).sum(); // FBP sum += Weight(I) * beliefF(I).entropy(); // FBP } for( size_t i = 0; i < nrVars(); ++i ) { Real c_i = 0.0; foreach( const Neighbor &I, nbV(i) ) c_i += Weight(I); sum += (1.0 - c_i) * beliefV(i).entropy(); // FBP } return sum; } // This code has been copied from bp.cpp, except where comments indicate FBP-specific behaviour Prob FBP::calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const { Real c_I = Weight(I); // FBP: c_I Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); if( props.logdomain ) { prod.takeLog(); prod /= c_I; // FBP } else prod ^= (1.0 / c_I); // FBP // Calculate product of incoming messages and factor I foreach( const Neighbor &j, nbF(I) ) if( !(without_i && (j == i)) ) { // prod_j will be the product of messages coming into j // FBP: corresponds to messages n_jI Prob prod_j( var(j).states(), props.logdomain ? 0.0 : 1.0 ); foreach( const Neighbor &J, nbV(j) ) if( J != I ) { // for all J in nb(j) \ I if( props.logdomain ) prod_j += message( j, J.iter ); else prod_j *= message( j, J.iter ); } else { // FBP: multiply by m_Ij^(1-1/c_I) if( props.logdomain ) prod_j += newMessage( j, J.iter) * (1.0 - 1.0 / c_I); else prod_j *= newMessage( j, J.iter) ^ (1.0 - 1.0 / c_I); } // multiply prod with prod_j if( !DAI_FBP_FAST ) { // UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION if( props.logdomain ) Fprod += Factor( var(j), prod_j ); else Fprod *= Factor( var(j), prod_j ); } else { // OPTIMIZED VERSION size_t _I = j.dual; // ind is the precalculated IndexFor(j,I) i.e. to x_I == k corresponds x_j == ind[k] const ind_t &ind = index(j, _I); for( size_t r = 0; r < prod.size(); ++r ) if( props.logdomain ) prod.set( r, prod[r] + prod_j[ind[r]] ); else prod.set( r, prod[r] * prod_j[ind[r]] ); } } return prod; } // This code has been copied from bp.cpp, except where comments indicate FBP-specific behaviour void FBP::calcNewMessage( size_t i, size_t _I ) { // calculate updated message I->i size_t I = nbV(i,_I); Real c_I = Weight(I); // FBP: c_I Factor Fprod( factor(I) ); Prob &prod = Fprod.p(); prod = calcIncomingMessageProduct( I, true, i ); if( props.logdomain ) { prod -= prod.max(); prod.takeExp(); } // Marginalize onto i Prob marg; if( !DAI_FBP_FAST ) { // UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION if( props.inference == Properties::InfType::SUMPROD ) marg = Fprod.marginal( var(i) ).p(); else marg = Fprod.maxMarginal( var(i) ).p(); } else { // OPTIMIZED VERSION marg = Prob( var(i).states(), 0.0 ); // ind is the precalculated IndexFor(i,I) i.e. to x_I == k corresponds x_i == ind[k] const ind_t ind = index(i,_I); if( props.inference == Properties::InfType::SUMPROD ) for( size_t r = 0; r < prod.size(); ++r ) marg.set( ind[r], marg[ind[r]] + prod[r] ); else for( size_t r = 0; r < prod.size(); ++r ) if( prod[r] > marg[ind[r]] ) marg.set( ind[r], prod[r] ); marg.normalize(); } // FBP marg ^= c_I; // Store result if( props.logdomain ) newMessage(i,_I) = marg.log(); else newMessage(i,_I) = marg; // Update the residual if necessary if( props.updates == Properties::UpdateType::SEQMAX ) updateResidual( i, _I , dist( newMessage( i, _I ), message( i, _I ), DISTLINF ) ); } void FBP::construct() { BP::construct(); _weight.resize( nrFactors(), 1.0 ); } } // end of namespace dai libDAI-0.2.7/src/treeep.cpp0000644000263000017630000003356311433220723014246 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #include namespace dai { using namespace std; const char *TreeEP::Name = "TREEEP"; void TreeEP::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("type") ); props.tol = opts.getStringAs("tol"); props.type = opts.getStringAs("type"); if( opts.hasKey("maxiter") ) props.maxiter = opts.getStringAs("maxiter"); else props.maxiter = 10000; if( opts.hasKey("maxtime") ) props.maxtime = opts.getStringAs("maxtime"); else props.maxtime = INFINITY; if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; } PropertySet TreeEP::getProperties() const { PropertySet opts; opts.set( "tol", props.tol ); opts.set( "maxiter", props.maxiter ); opts.set( "maxtime", props.maxtime ); opts.set( "verbose", props.verbose ); opts.set( "type", props.type ); return opts; } string TreeEP::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "maxtime=" << props.maxtime << ","; s << "verbose=" << props.verbose << ","; s << "type=" << props.type << "]"; return s.str(); } TreeEP::TreeEP( const FactorGraph &fg, const PropertySet &opts ) : JTree(fg, opts("updates",string("HUGIN")), false), _maxdiff(0.0), _iters(0), props(), _Q() { setProperties( opts ); if( opts.hasKey("tree") ) { construct( fg, opts.getAs("tree") ); } else { if( props.type == Properties::TypeType::ORG || props.type == Properties::TypeType::ALT ) { // ORG: construct weighted graph with as weights a crude estimate of the // mutual information between the nodes // ALT: construct weighted graph with as weights an upper bound on the // effective interaction strength between pairs of nodes WeightedGraph wg; // in order to get a connected weighted graph, we start // by connecting every variable to the zero'th variable with weight 0 for( size_t i = 1; i < fg.nrVars(); i++ ) wg[UEdge(i,0)] = 0.0; for( size_t i = 0; i < fg.nrVars(); i++ ) { SmallSet delta_i = fg.bipGraph().delta1( i, false ); const Var& v_i = fg.var(i); foreach( size_t j, delta_i ) if( i < j ) { const Var& v_j = fg.var(j); VarSet v_ij( v_i, v_j ); SmallSet nb_ij = fg.bipGraph().nb1Set( i ) | fg.bipGraph().nb1Set( j ); Factor piet; foreach( size_t I, nb_ij ) { const VarSet& Ivars = fg.factor(I).vars(); if( props.type == Properties::TypeType::ORG ) { if( (Ivars == v_i) || (Ivars == v_j) ) piet *= fg.factor(I); else if( Ivars >> v_ij ) piet *= fg.factor(I).marginal( v_ij ); } else { if( Ivars >> v_ij ) piet *= fg.factor(I); } } if( props.type == Properties::TypeType::ORG ) { if( piet.vars() >> v_ij ) { piet = piet.marginal( v_ij ); Factor pietf = piet.marginal(v_i) * piet.marginal(v_j); wg[UEdge(i,j)] = dist( piet, pietf, DISTKL ); } else { // this should never happen... DAI_ASSERT( 0 == 1 ); wg[UEdge(i,j)] = 0; } } else wg[UEdge(i,j)] = piet.strength(v_i, v_j); } } // find maximal spanning tree if( props.verbose >= 3 ) cerr << "WeightedGraph: " << wg << endl; RootedTree t = MaxSpanningTree( wg, true ); if( props.verbose >= 3 ) cerr << "Spanningtree: " << t << endl; construct( fg, t ); } else DAI_THROW(UNKNOWN_ENUM_VALUE); } } void TreeEP::construct( const FactorGraph& fg, const RootedTree& tree ) { // Copy the factor graph FactorGraph::operator=( fg ); vector cl; for( size_t i = 0; i < tree.size(); i++ ) cl.push_back( VarSet( var(tree[i].first), var(tree[i].second) ) ); // If no outer region can be found subsuming that factor, label the // factor as off-tree. JTree::construct( *this, cl, false ); if( props.verbose >= 1 ) cerr << "TreeEP::construct: The tree has size " << JTree::RTree.size() << endl; if( props.verbose >= 3 ) cerr << " it is " << JTree::RTree << " with cliques " << cl << endl; // Create factor approximations _Q.clear(); size_t PreviousRoot = (size_t)-1; // Second repetition: previous root of first off-tree factor should be the root of the last off-tree factor for( size_t repeats = 0; repeats < 2; repeats++ ) for( size_t I = 0; I < nrFactors(); I++ ) if( offtree(I) ) { // find efficient subtree RootedTree subTree; size_t subTreeSize = findEfficientTree( factor(I).vars(), subTree, PreviousRoot ); PreviousRoot = subTree[0].first; subTree.resize( subTreeSize ); if( props.verbose >= 1 ) cerr << "Subtree " << I << " has size " << subTreeSize << endl; if( props.verbose >= 3 ) cerr << " it is " << subTree << endl; _Q[I] = TreeEPSubTree( subTree, RTree, Qa, Qb, &factor(I) ); if( repeats == 1 ) break; } if( props.verbose >= 3 ) cerr << "Resulting regiongraph: " << *this << endl; } string TreeEP::identify() const { return string(Name) + printProperties(); } void TreeEP::init() { runHUGIN(); // Init factor approximations for( size_t I = 0; I < nrFactors(); I++ ) if( offtree(I) ) _Q[I].init(); } Real TreeEP::run() { if( props.verbose >= 1 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 3 ) cerr << endl; double tic = toc(); vector oldBeliefs = beliefs(); // do several passes over the network until maximum number of iterations has // been reached or until the maximum belief difference is smaller than tolerance Real maxDiff = INFINITY; for( _iters = 0; _iters < props.maxiter && maxDiff > props.tol && (toc() - tic) < props.maxtime; _iters++ ) { for( size_t I = 0; I < nrFactors(); I++ ) if( offtree(I) ) { _Q[I].InvertAndMultiply( Qa, Qb ); _Q[I].HUGIN_with_I( Qa, Qb ); _Q[I].InvertAndMultiply( Qa, Qb ); } // calculate new beliefs and compare with old ones vector newBeliefs = beliefs(); maxDiff = -INFINITY; for( size_t t = 0; t < oldBeliefs.size(); t++ ) maxDiff = std::max( maxDiff, dist( newBeliefs[t], oldBeliefs[t], DISTLINF ) ); swap( newBeliefs, oldBeliefs ); if( props.verbose >= 3 ) cerr << Name << "::run: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 1 ) { if( maxDiff > props.tol ) { if( props.verbose == 1 ) cerr << endl; cerr << Name << "::run: WARNING: not converged after " << _iters << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 3 ) cerr << Name << "::run: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } return maxDiff; } Real TreeEP::logZ() const { Real s = 0.0; // entropy of the tree for( size_t beta = 0; beta < nrIRs(); beta++ ) s -= Qb[beta].entropy(); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) s += Qa[alpha].entropy(); // energy of the on-tree factors for( size_t alpha = 0; alpha < nrORs(); alpha++ ) s += (OR(alpha).log(true) * Qa[alpha]).sum(); // energy of the off-tree factors for( size_t I = 0; I < nrFactors(); I++ ) if( offtree(I) ) s += (_Q.find(I))->second.logZ( Qa, Qb ); return s; } TreeEP::TreeEPSubTree::TreeEPSubTree( const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector &jt_Qa, const std::vector &jt_Qb, const Factor *I ) : _Qa(), _Qb(), _RTree(), _a(), _b(), _I(I), _ns(), _nsrem(), _logZ(0.0) { _ns = _I->vars(); // Make _Qa, _Qb, _a and _b corresponding to the subtree _b.reserve( subRTree.size() ); _Qb.reserve( subRTree.size() ); _RTree.reserve( subRTree.size() ); for( size_t i = 0; i < subRTree.size(); i++ ) { size_t alpha1 = subRTree[i].first; // old index 1 size_t alpha2 = subRTree[i].second; // old index 2 size_t beta; // old sep index for( beta = 0; beta < jt_RTree.size(); beta++ ) if( UEdge( jt_RTree[beta].first, jt_RTree[beta].second ) == UEdge( alpha1, alpha2 ) ) break; DAI_ASSERT( beta != jt_RTree.size() ); size_t newalpha1 = find(_a.begin(), _a.end(), alpha1) - _a.begin(); if( newalpha1 == _a.size() ) { _Qa.push_back( Factor( jt_Qa[alpha1].vars(), 1.0 ) ); _a.push_back( alpha1 ); // save old index in index conversion table } size_t newalpha2 = find(_a.begin(), _a.end(), alpha2) - _a.begin(); if( newalpha2 == _a.size() ) { _Qa.push_back( Factor( jt_Qa[alpha2].vars(), 1.0 ) ); _a.push_back( alpha2 ); // save old index in index conversion table } _RTree.push_back( DEdge( newalpha1, newalpha2 ) ); _Qb.push_back( Factor( jt_Qb[beta].vars(), 1.0 ) ); _b.push_back( beta ); } // Find remaining variables (which are not in the new root) _nsrem = _ns / _Qa[0].vars(); } void TreeEP::TreeEPSubTree::init() { for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) _Qa[alpha].fill( 1.0 ); for( size_t beta = 0; beta < _Qb.size(); beta++ ) _Qb[beta].fill( 1.0 ); } void TreeEP::TreeEPSubTree::InvertAndMultiply( const std::vector &Qa, const std::vector &Qb ) { for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) _Qa[alpha] = Qa[_a[alpha]] / _Qa[alpha]; for( size_t beta = 0; beta < _Qb.size(); beta++ ) _Qb[beta] = Qb[_b[beta]] / _Qb[beta]; } void TreeEP::TreeEPSubTree::HUGIN_with_I( std::vector &Qa, std::vector &Qb ) { // Backup _Qa and _Qb vector _Qa_old(_Qa); vector _Qb_old(_Qb); // Clear Qa and Qb for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) Qa[_a[alpha]].fill( 0.0 ); for( size_t beta = 0; beta < _Qb.size(); beta++ ) Qb[_b[beta]].fill( 0.0 ); // For all states of _nsrem for( State s(_nsrem); s.valid(); s++ ) { // Multiply root with slice of I _Qa[0] *= _I->slice( _nsrem, s ); // CollectEvidence for( size_t i = _RTree.size(); (i--) != 0; ) { // clamp variables in nsrem for( VarSet::const_iterator n = _nsrem.begin(); n != _nsrem.end(); n++ ) if( _Qa[_RTree[i].second].vars() >> *n ) _Qa[_RTree[i].second] *= createFactorDelta( *n, s(*n) ); Factor new_Qb = _Qa[_RTree[i].second].marginal( _Qb[i].vars(), false ); _Qa[_RTree[i].first] *= new_Qb / _Qb[i]; _Qb[i] = new_Qb; } // DistributeEvidence for( size_t i = 0; i < _RTree.size(); i++ ) { Factor new_Qb = _Qa[_RTree[i].first].marginal( _Qb[i].vars(), false ); _Qa[_RTree[i].second] *= new_Qb / _Qb[i]; _Qb[i] = new_Qb; } // Store Qa's and Qb's for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) Qa[_a[alpha]].p() += _Qa[alpha].p(); for( size_t beta = 0; beta < _Qb.size(); beta++ ) Qb[_b[beta]].p() += _Qb[beta].p(); // Restore _Qa and _Qb _Qa = _Qa_old; _Qb = _Qb_old; } // Normalize Qa and Qb _logZ = 0.0; for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) { _logZ += log(Qa[_a[alpha]].sum()); Qa[_a[alpha]].normalize(); } for( size_t beta = 0; beta < _Qb.size(); beta++ ) { _logZ -= log(Qb[_b[beta]].sum()); Qb[_b[beta]].normalize(); } } Real TreeEP::TreeEPSubTree::logZ( const std::vector &Qa, const std::vector &Qb ) const { Real s = 0.0; for( size_t alpha = 0; alpha < _Qa.size(); alpha++ ) s += (Qa[_a[alpha]] * _Qa[alpha].log(true)).sum(); for( size_t beta = 0; beta < _Qb.size(); beta++ ) s -= (Qb[_b[beta]] * _Qb[beta].log(true)).sum(); return s + _logZ; } } // end of namespace dai libDAI-0.2.7/src/jtree.cpp0000644000263000017630000005035211433220723014066 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include namespace dai { using namespace std; const char *JTree::Name = "JTREE"; void JTree::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("updates") ); props.updates = opts.getStringAs("updates"); if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; if( opts.hasKey("inference") ) props.inference = opts.getStringAs("inference"); else props.inference = Properties::InfType::SUMPROD; if( opts.hasKey("heuristic") ) props.heuristic = opts.getStringAs("heuristic"); else props.heuristic = Properties::HeuristicType::MINFILL; if( opts.hasKey("maxmem") ) props.maxmem = opts.getStringAs("maxmem"); else props.maxmem = 0; } PropertySet JTree::getProperties() const { PropertySet opts; opts.set( "verbose", props.verbose ); opts.set( "updates", props.updates ); opts.set( "inference", props.inference ); opts.set( "heuristic", props.heuristic ); opts.set( "maxmem", props.maxmem ); return opts; } string JTree::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "verbose=" << props.verbose << ","; s << "updates=" << props.updates << ","; s << "heuristic=" << props.heuristic << ","; s << "inference=" << props.inference << ","; s << "maxmem=" << props.maxmem << "]"; return s.str(); } JTree::JTree( const FactorGraph &fg, const PropertySet &opts, bool automatic ) : DAIAlgRG(), _mes(), _logZ(), RTree(), Qa(), Qb(), props() { setProperties( opts ); if( automatic ) { // Create ClusterGraph which contains maximal factors as clusters ClusterGraph _cg( fg, true ); if( props.verbose >= 3 ) cerr << "Initial clusters: " << _cg << endl; // Use heuristic to guess optimal elimination sequence greedyVariableElimination::eliminationCostFunction ec(NULL); switch( (size_t)props.heuristic ) { case Properties::HeuristicType::MINNEIGHBORS: ec = eliminationCost_MinNeighbors; break; case Properties::HeuristicType::MINWEIGHT: ec = eliminationCost_MinWeight; break; case Properties::HeuristicType::MINFILL: ec = eliminationCost_MinFill; break; case Properties::HeuristicType::WEIGHTEDMINFILL: ec = eliminationCost_WeightedMinFill; break; default: DAI_THROW(UNKNOWN_ENUM_VALUE); } size_t fudge = 6; // this yields a rough estimate of the memory needed (for some reason not yet clearly understood) vector ElimVec = _cg.VarElim( greedyVariableElimination( ec ), props.maxmem / (sizeof(Real) * fudge) ).eraseNonMaximal().clusters(); if( props.verbose >= 3 ) cerr << "VarElim result: " << ElimVec << endl; // Estimate memory needed (rough upper bound) long double memneeded = 0; foreach( const VarSet& cl, ElimVec ) memneeded += cl.nrStates(); memneeded *= sizeof(Real) * fudge; if( props.verbose >= 1 ) { cerr << "Estimate of needed memory: " << memneeded / 1024 << "kB" << endl; cerr << "Maximum memory: "; if( props.maxmem ) cerr << props.maxmem / 1024 << "kB" << endl; else cerr << "unlimited" << endl; } if( props.maxmem && memneeded > props.maxmem ) DAI_THROW(OUT_OF_MEMORY); // Generate the junction tree corresponding to the elimination sequence GenerateJT( fg, ElimVec ); } } void JTree::construct( const FactorGraph &fg, const std::vector &cl, bool verify ) { // Copy the factor graph FactorGraph::operator=( fg ); // Construct a weighted graph (each edge is weighted with the cardinality // of the intersection of the nodes, where the nodes are the elements of cl). WeightedGraph JuncGraph; // Start by connecting all clusters with cluster zero, and weight zero, // in order to get a connected weighted graph for( size_t i = 1; i < cl.size(); i++ ) JuncGraph[UEdge(i,0)] = 0; for( size_t i = 0; i < cl.size(); i++ ) { for( size_t j = i + 1; j < cl.size(); j++ ) { size_t w = (cl[i] & cl[j]).size(); if( w ) JuncGraph[UEdge(i,j)] = w; } } if( props.verbose >= 3 ) cerr << "Weightedgraph: " << JuncGraph << endl; // Construct maximal spanning tree using Prim's algorithm RTree = MaxSpanningTree( JuncGraph, true ); if( props.verbose >= 3 ) cerr << "Spanning tree: " << RTree << endl; DAI_DEBASSERT( RTree.size() == cl.size() - 1 ); // Construct corresponding region graph // Create outer regions _ORs.clear(); _ORs.reserve( cl.size() ); for( size_t i = 0; i < cl.size(); i++ ) _ORs.push_back( FRegion( Factor(cl[i], 1.0), 1.0 ) ); // For each factor, find an outer region that subsumes that factor. // Then, multiply the outer region with that factor. _fac2OR.clear(); _fac2OR.resize( nrFactors(), -1U ); for( size_t I = 0; I < nrFactors(); I++ ) { size_t alpha; for( alpha = 0; alpha < nrORs(); alpha++ ) if( OR(alpha).vars() >> factor(I).vars() ) { _fac2OR[I] = alpha; break; } if( verify ) DAI_ASSERT( alpha != nrORs() ); } recomputeORs(); // Create inner regions and edges _IRs.clear(); _IRs.reserve( RTree.size() ); vector edges; edges.reserve( 2 * RTree.size() ); for( size_t i = 0; i < RTree.size(); i++ ) { edges.push_back( Edge( RTree[i].first, nrIRs() ) ); edges.push_back( Edge( RTree[i].second, nrIRs() ) ); // inner clusters have counting number -1, except if they are empty VarSet intersection = cl[RTree[i].first] & cl[RTree[i].second]; _IRs.push_back( Region( intersection, intersection.size() ? -1.0 : 0.0 ) ); } // create bipartite graph _G.construct( nrORs(), nrIRs(), edges.begin(), edges.end() ); // Check counting numbers #ifdef DAI_DEBUG checkCountingNumbers(); #endif // Create beliefs Qa.clear(); Qa.reserve( nrORs() ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) Qa.push_back( OR(alpha) ); Qb.clear(); Qb.reserve( nrIRs() ); for( size_t beta = 0; beta < nrIRs(); beta++ ) Qb.push_back( Factor( IR(beta), 1.0 ) ); } void JTree::GenerateJT( const FactorGraph &fg, const std::vector &cl ) { construct( fg, cl, true ); // Create messages _mes.clear(); _mes.reserve( nrORs() ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { _mes.push_back( vector() ); _mes[alpha].reserve( nbOR(alpha).size() ); foreach( const Neighbor &beta, nbOR(alpha) ) _mes[alpha].push_back( Factor( IR(beta), 1.0 ) ); } if( props.verbose >= 3 ) cerr << "Regiongraph generated by JTree::GenerateJT: " << *this << endl; } string JTree::identify() const { return string(Name) + printProperties(); } Factor JTree::belief( const VarSet &vs ) const { vector::const_iterator beta; for( beta = Qb.begin(); beta != Qb.end(); beta++ ) if( beta->vars() >> vs ) break; if( beta != Qb.end() ) { if( props.inference == Properties::InfType::SUMPROD ) return( beta->marginal(vs) ); else return( beta->maxMarginal(vs) ); } else { vector::const_iterator alpha; for( alpha = Qa.begin(); alpha != Qa.end(); alpha++ ) if( alpha->vars() >> vs ) break; if( alpha == Qa.end() ) { DAI_THROW(BELIEF_NOT_AVAILABLE); return Factor(); } else { if( props.inference == Properties::InfType::SUMPROD ) return( alpha->marginal(vs) ); else return( alpha->maxMarginal(vs) ); } } } vector JTree::beliefs() const { vector result; for( size_t beta = 0; beta < nrIRs(); beta++ ) result.push_back( Qb[beta] ); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) result.push_back( Qa[alpha] ); return result; } void JTree::runHUGIN() { for( size_t alpha = 0; alpha < nrORs(); alpha++ ) Qa[alpha] = OR(alpha); for( size_t beta = 0; beta < nrIRs(); beta++ ) Qb[beta].fill( 1.0 ); // CollectEvidence _logZ = 0.0; for( size_t i = RTree.size(); (i--) != 0; ) { // Make outer region RTree[i].first consistent with outer region RTree[i].second // IR(i) = seperator OR(RTree[i].first) && OR(RTree[i].second) Factor new_Qb; if( props.inference == Properties::InfType::SUMPROD ) new_Qb = Qa[RTree[i].second].marginal( IR( i ), false ); else new_Qb = Qa[RTree[i].second].maxMarginal( IR( i ), false ); _logZ += log(new_Qb.normalize()); Qa[RTree[i].first] *= new_Qb / Qb[i]; Qb[i] = new_Qb; } if( RTree.empty() ) _logZ += log(Qa[0].normalize() ); else _logZ += log(Qa[RTree[0].first].normalize()); // DistributeEvidence for( size_t i = 0; i < RTree.size(); i++ ) { // Make outer region RTree[i].second consistent with outer region RTree[i].first // IR(i) = seperator OR(RTree[i].first) && OR(RTree[i].second) Factor new_Qb; if( props.inference == Properties::InfType::SUMPROD ) new_Qb = Qa[RTree[i].first].marginal( IR( i ) ); else new_Qb = Qa[RTree[i].first].maxMarginal( IR( i ) ); Qa[RTree[i].second] *= new_Qb / Qb[i]; Qb[i] = new_Qb; } // Normalize for( size_t alpha = 0; alpha < nrORs(); alpha++ ) Qa[alpha].normalize(); } void JTree::runShaferShenoy() { // First pass _logZ = 0.0; for( size_t e = nrIRs(); (e--) != 0; ) { // send a message from RTree[e].second to RTree[e].first // or, actually, from the seperator IR(e) to RTree[e].first size_t i = nbIR(e)[1].node; // = RTree[e].second size_t j = nbIR(e)[0].node; // = RTree[e].first size_t _e = nbIR(e)[0].dual; Factor msg = OR(i); foreach( const Neighbor &k, nbOR(i) ) if( k != e ) msg *= message( i, k.iter ); if( props.inference == Properties::InfType::SUMPROD ) message( j, _e ) = msg.marginal( IR(e), false ); else message( j, _e ) = msg.maxMarginal( IR(e), false ); _logZ += log( message(j,_e).normalize() ); } // Second pass for( size_t e = 0; e < nrIRs(); e++ ) { size_t i = nbIR(e)[0].node; // = RTree[e].first size_t j = nbIR(e)[1].node; // = RTree[e].second size_t _e = nbIR(e)[1].dual; Factor msg = OR(i); foreach( const Neighbor &k, nbOR(i) ) if( k != e ) msg *= message( i, k.iter ); if( props.inference == Properties::InfType::SUMPROD ) message( j, _e ) = msg.marginal( IR(e) ); else message( j, _e ) = msg.maxMarginal( IR(e) ); } // Calculate beliefs for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { Factor piet = OR(alpha); foreach( const Neighbor &k, nbOR(alpha) ) piet *= message( alpha, k.iter ); if( nrIRs() == 0 ) { _logZ += log( piet.normalize() ); Qa[alpha] = piet; } else if( alpha == nbIR(0)[0].node /*RTree[0].first*/ ) { _logZ += log( piet.normalize() ); Qa[alpha] = piet; } else Qa[alpha] = piet.normalized(); } // Only for logZ (and for belief)... for( size_t beta = 0; beta < nrIRs(); beta++ ) { if( props.inference == Properties::InfType::SUMPROD ) Qb[beta] = Qa[nbIR(beta)[0].node].marginal( IR(beta) ); else Qb[beta] = Qa[nbIR(beta)[0].node].maxMarginal( IR(beta) ); } } Real JTree::run() { if( props.updates == Properties::UpdateType::HUGIN ) runHUGIN(); else if( props.updates == Properties::UpdateType::SHSH ) runShaferShenoy(); return 0.0; } Real JTree::logZ() const { /* Real s = 0.0; for( size_t beta = 0; beta < nrIRs(); beta++ ) s += IR(beta).c() * Qb[beta].entropy(); for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { s += OR(alpha).c() * Qa[alpha].entropy(); s += (OR(alpha).log(true) * Qa[alpha]).sum(); } DAI_ASSERT( abs( _logZ - s ) < 1e-8 ); return s;*/ return _logZ; } size_t JTree::findEfficientTree( const VarSet& vs, RootedTree &Tree, size_t PreviousRoot ) const { // find new root clique (the one with maximal statespace overlap with vs) long double maxval = 0.0; size_t maxalpha = 0; for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { long double val = VarSet(vs & OR(alpha).vars()).nrStates(); if( val > maxval ) { maxval = val; maxalpha = alpha; } } // reorder the tree edges such that maxalpha becomes the new root RootedTree newTree( GraphEL( RTree.begin(), RTree.end() ), maxalpha ); // identify subtree that contains all variables of vs which are not in the new root set subTree; // for each variable in vs for( VarSet::const_iterator n = vs.begin(); n != vs.end(); n++ ) { for( size_t e = 0; e < newTree.size(); e++ ) { if( OR(newTree[e].second).vars().contains( *n ) ) { size_t f = e; subTree.insert( newTree[f] ); size_t pos = newTree[f].first; for( ; f > 0; f-- ) if( newTree[f-1].second == pos ) { subTree.insert( newTree[f-1] ); pos = newTree[f-1].first; } } } } if( PreviousRoot != (size_t)-1 && PreviousRoot != maxalpha) { // find first occurence of PreviousRoot in the tree, which is closest to the new root size_t e = 0; for( ; e != newTree.size(); e++ ) { if( newTree[e].second == PreviousRoot ) break; } DAI_ASSERT( e != newTree.size() ); // track-back path to root and add edges to subTree subTree.insert( newTree[e] ); size_t pos = newTree[e].first; for( ; e > 0; e-- ) if( newTree[e-1].second == pos ) { subTree.insert( newTree[e-1] ); pos = newTree[e-1].first; } } // Resulting Tree is a reordered copy of newTree // First add edges in subTree to Tree Tree.clear(); vector remTree; for( RootedTree::const_iterator e = newTree.begin(); e != newTree.end(); e++ ) if( subTree.count( *e ) ) Tree.push_back( *e ); else remTree.push_back( *e ); size_t subTreeSize = Tree.size(); // Then add remaining edges copy( remTree.begin(), remTree.end(), back_inserter( Tree ) ); return subTreeSize; } Factor JTree::calcMarginal( const VarSet& vs ) { vector::const_iterator beta; for( beta = Qb.begin(); beta != Qb.end(); beta++ ) if( beta->vars() >> vs ) break; if( beta != Qb.end() ) { if( props.inference == Properties::InfType::SUMPROD ) return( beta->marginal(vs) ); else return( beta->maxMarginal(vs) ); } else { vector::const_iterator alpha; for( alpha = Qa.begin(); alpha != Qa.end(); alpha++ ) if( alpha->vars() >> vs ) break; if( alpha != Qa.end() ) { if( props.inference == Properties::InfType::SUMPROD ) return( alpha->marginal(vs) ); else return( alpha->maxMarginal(vs) ); } else { // Find subtree to do efficient inference RootedTree T; size_t Tsize = findEfficientTree( vs, T ); // Find remaining variables (which are not in the new root) VarSet vsrem = vs / OR(T.front().first).vars(); Factor Pvs (vs, 0.0); // Save Qa and Qb on the subtree map Qa_old; map Qb_old; vector b(Tsize, 0); for( size_t i = Tsize; (i--) != 0; ) { size_t alpha1 = T[i].first; size_t alpha2 = T[i].second; size_t beta; for( beta = 0; beta < nrIRs(); beta++ ) if( UEdge( RTree[beta].first, RTree[beta].second ) == UEdge( alpha1, alpha2 ) ) break; DAI_ASSERT( beta != nrIRs() ); b[i] = beta; if( !Qa_old.count( alpha1 ) ) Qa_old[alpha1] = Qa[alpha1]; if( !Qa_old.count( alpha2 ) ) Qa_old[alpha2] = Qa[alpha2]; if( !Qb_old.count( beta ) ) Qb_old[beta] = Qb[beta]; } // For all states of vsrem for( State s(vsrem); s.valid(); s++ ) { // CollectEvidence Real logZ = 0.0; for( size_t i = Tsize; (i--) != 0; ) { // Make outer region T[i].first consistent with outer region T[i].second // IR(i) = seperator OR(T[i].first) && OR(T[i].second) for( VarSet::const_iterator n = vsrem.begin(); n != vsrem.end(); n++ ) if( Qa[T[i].second].vars() >> *n ) { Factor piet( *n, 0.0 ); piet.set( s(*n), 1.0 ); Qa[T[i].second] *= piet; } Factor new_Qb; if( props.inference == Properties::InfType::SUMPROD ) new_Qb = Qa[T[i].second].marginal( IR( b[i] ), false ); else new_Qb = Qa[T[i].second].maxMarginal( IR( b[i] ), false ); logZ += log(new_Qb.normalize()); Qa[T[i].first] *= new_Qb / Qb[b[i]]; Qb[b[i]] = new_Qb; } logZ += log(Qa[T[0].first].normalize()); Factor piet( vsrem, 0.0 ); piet.set( s, exp(logZ) ); if( props.inference == Properties::InfType::SUMPROD ) Pvs += piet * Qa[T[0].first].marginal( vs / vsrem, false ); // OPTIMIZE ME else Pvs += piet * Qa[T[0].first].maxMarginal( vs / vsrem, false ); // OPTIMIZE ME // Restore clamped beliefs for( map::const_iterator alpha = Qa_old.begin(); alpha != Qa_old.end(); alpha++ ) Qa[alpha->first] = alpha->second; for( map::const_iterator beta = Qb_old.begin(); beta != Qb_old.end(); beta++ ) Qb[beta->first] = beta->second; } return( Pvs.normalized() ); } } } std::pair boundTreewidth( const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates ) { // Create cluster graph from factor graph ClusterGraph _cg( fg, true ); // Obtain elimination sequence vector ElimVec = _cg.VarElim( greedyVariableElimination( fn ), maxStates ).eraseNonMaximal().clusters(); // Calculate treewidth size_t treewidth = 0; double nrstates = 0.0; for( size_t i = 0; i < ElimVec.size(); i++ ) { if( ElimVec[i].size() > treewidth ) treewidth = ElimVec[i].size(); long double s = ElimVec[i].nrStates(); if( s > nrstates ) nrstates = s; } return make_pair(treewidth, nrstates); } } // end of namespace dai libDAI-0.2.7/src/emalg.cpp0000644000263000017630000002372111433220723014042 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California, Santa Cruz */ #include #include namespace dai { // Initialize static private member of ParameterEstimation std::map *ParameterEstimation::_registry = NULL; void ParameterEstimation::loadDefaultRegistry() { _registry = new std::map(); (*_registry)["CondProbEstimation"] = CondProbEstimation::factory; } ParameterEstimation* ParameterEstimation::construct( const std::string &method, const PropertySet &p ) { if( _registry == NULL ) loadDefaultRegistry(); std::map::iterator i = _registry->find(method); if( i == _registry->end() ) DAI_THROWE(UNKNOWN_PARAMETER_ESTIMATION_METHOD, "Unknown parameter estimation method: " + method); ParamEstFactory factory = i->second; return factory(p); } ParameterEstimation* CondProbEstimation::factory( const PropertySet &p ) { size_t target_dimension = p.getStringAs("target_dim"); size_t total_dimension = p.getStringAs("total_dim"); Real pseudo_count = 1; if( p.hasKey("pseudo_count") ) pseudo_count = p.getStringAs("pseudo_count"); return new CondProbEstimation( target_dimension, Prob( total_dimension, pseudo_count ) ); } CondProbEstimation::CondProbEstimation( size_t target_dimension, const Prob &pseudocounts ) : _target_dim(target_dimension), _stats(pseudocounts), _initial_stats(pseudocounts) { DAI_ASSERT( !(_stats.size() % _target_dim) ); } void CondProbEstimation::addSufficientStatistics( const Prob &p ) { _stats += p; } Prob CondProbEstimation::estimate() { // normalize pseudocounts for( size_t parent = 0; parent < _stats.size(); parent += _target_dim ) { // calculate norm size_t top = parent + _target_dim; Real norm = 0.0; for( size_t i = parent; i < top; ++i ) norm += _stats[i]; if( norm != 0.0 ) norm = 1.0 / norm; // normalize for( size_t i = parent; i < top; ++i ) _stats.set( i, _stats[i] * norm ); } // reset _stats to _initial_stats Prob result = _stats; _stats = _initial_stats; return result; } Permute SharedParameters::calculatePermutation( const std::vector &varOrder, VarSet &outVS ) { outVS = VarSet( varOrder.begin(), varOrder.end(), varOrder.size() ); return Permute( varOrder ); } void SharedParameters::setPermsAndVarSetsFromVarOrders() { if( _varorders.size() == 0 ) return; DAI_ASSERT( _estimation != NULL ); // Construct the permutation objects and the varsets for( FactorOrientations::const_iterator foi = _varorders.begin(); foi != _varorders.end(); ++foi ) { VarSet vs; _perms[foi->first] = calculatePermutation( foi->second, vs ); _varsets[foi->first] = vs; DAI_ASSERT( _estimation->probSize() == vs.nrStates() ); } } SharedParameters::SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE ) : _varsets(), _perms(), _varorders(varorders), _estimation(estimation), _ownEstimation(ownPE) { // Calculate the necessary permutations and varsets setPermsAndVarSetsFromVarOrders(); } SharedParameters::SharedParameters( std::istream &is, const FactorGraph &fg ) : _varsets(), _perms(), _varorders(), _estimation(NULL), _ownEstimation(true) { // Read the desired parameter estimation method from the stream std::string est_method; PropertySet props; is >> est_method; is >> props; // Construct a corresponding object _estimation = ParameterEstimation::construct( est_method, props ); // Read in the factors that are to be estimated size_t num_factors; is >> num_factors; for( size_t sp_i = 0; sp_i < num_factors; ++sp_i ) { std::string line; while( line.size() == 0 && getline(is, line) ) ; std::vector fields = tokenizeString( line, true, " \t" ); // Lookup the factor in the factorgraph if( fields.size() < 1 ) DAI_THROWE(INVALID_EMALG_FILE,"Empty line unexpected"); std::istringstream iss; iss.str( fields[0] ); size_t factor; iss >> factor; const VarSet &vs = fg.factor(factor).vars(); if( fields.size() != vs.size() + 1 ) DAI_THROWE(INVALID_EMALG_FILE,"Number of fields does not match factor size"); // Construct the vector of Vars std::vector var_order; var_order.reserve( vs.size() ); for( size_t fi = 1; fi < fields.size(); ++fi ) { // Lookup a single variable by label size_t label; std::istringstream labelparse( fields[fi] ); labelparse >> label; VarSet::const_iterator vsi = vs.begin(); for( ; vsi != vs.end(); ++vsi ) if( vsi->label() == label ) break; if( vsi == vs.end() ) DAI_THROWE(INVALID_EMALG_FILE,"Specified variables do not match the factor variables"); var_order.push_back( *vsi ); } _varorders[factor] = var_order; } // Calculate the necessary permutations setPermsAndVarSetsFromVarOrders(); } void SharedParameters::collectSufficientStatistics( InfAlg &alg ) { for( std::map< FactorIndex, Permute >::iterator i = _perms.begin(); i != _perms.end(); ++i ) { Permute &perm = i->second; VarSet &vs = _varsets[i->first]; Factor b = alg.belief(vs); Prob p( b.nrStates(), 0.0 ); for( size_t entry = 0; entry < b.nrStates(); ++entry ) p.set( entry, b[perm.convertLinearIndex(entry)] ); // apply inverse permutation _estimation->addSufficientStatistics( p ); } } void SharedParameters::setParameters( FactorGraph &fg ) { Prob p = _estimation->estimate(); for( std::map::iterator i = _perms.begin(); i != _perms.end(); ++i ) { Permute &perm = i->second; VarSet &vs = _varsets[i->first]; Factor f( vs, 0.0 ); for( size_t entry = 0; entry < f.nrStates(); ++entry ) f.set( perm.convertLinearIndex(entry), p[entry] ); fg.setFactor( i->first, f ); } } MaximizationStep::MaximizationStep( std::istream &is, const FactorGraph &fg_varlookup ) : _params() { size_t num_params = -1; is >> num_params; _params.reserve( num_params ); for( size_t i = 0; i < num_params; ++i ) _params.push_back( SharedParameters( is, fg_varlookup ) ); } void MaximizationStep::addExpectations( InfAlg &alg ) { for( size_t i = 0; i < _params.size(); ++i ) _params[i].collectSufficientStatistics( alg ); } void MaximizationStep::maximize( FactorGraph &fg ) { for( size_t i = 0; i < _params.size(); ++i ) _params[i].setParameters( fg ); } const std::string EMAlg::MAX_ITERS_KEY("max_iters"); const std::string EMAlg::LOG_Z_TOL_KEY("log_z_tol"); const size_t EMAlg::MAX_ITERS_DEFAULT = 30; const Real EMAlg::LOG_Z_TOL_DEFAULT = 0.01; EMAlg::EMAlg( const Evidence &evidence, InfAlg &estep, std::istream &msteps_file ) : _evidence(evidence), _estep(estep), _msteps(), _iters(0), _lastLogZ(), _max_iters(MAX_ITERS_DEFAULT), _log_z_tol(LOG_Z_TOL_DEFAULT) { msteps_file.exceptions( std::istream::eofbit | std::istream::failbit | std::istream::badbit ); size_t num_msteps = -1; msteps_file >> num_msteps; _msteps.reserve(num_msteps); for( size_t i = 0; i < num_msteps; ++i ) _msteps.push_back( MaximizationStep( msteps_file, estep.fg() ) ); } void EMAlg::setTermConditions( const PropertySet &p ) { if( p.hasKey(MAX_ITERS_KEY) ) _max_iters = p.getStringAs(MAX_ITERS_KEY); if( p.hasKey(LOG_Z_TOL_KEY) ) _log_z_tol = p.getStringAs(LOG_Z_TOL_KEY); } bool EMAlg::hasSatisfiedTermConditions() const { if( _iters >= _max_iters ) return true; else if( _lastLogZ.size() < 3 ) // need at least 2 to calculate ratio // Also, throw away first iteration, as the parameters may not // have been normalized according to the estimation method return false; else { Real current = _lastLogZ[_lastLogZ.size() - 1]; Real previous = _lastLogZ[_lastLogZ.size() - 2]; if( previous == 0 ) return false; Real diff = current - previous; if( diff < 0 ) { std::cerr << "Error: in EM log-likehood decreased from " << previous << " to " << current << std::endl; return true; } return (diff / fabs(previous)) <= _log_z_tol; } } Real EMAlg::iterate( MaximizationStep &mstep ) { Real logZ = 0; Real likelihood = 0; _estep.run(); logZ = _estep.logZ(); // Expectation calculation for( Evidence::const_iterator e = _evidence.begin(); e != _evidence.end(); ++e ) { InfAlg* clamped = _estep.clone(); // Apply evidence for( Evidence::Observation::const_iterator i = e->begin(); i != e->end(); ++i ) clamped->clamp( clamped->fg().findVar(i->first), i->second ); clamped->init(); clamped->run(); likelihood += clamped->logZ() - logZ; mstep.addExpectations( *clamped ); delete clamped; } // Maximization of parameters mstep.maximize( _estep.fg() ); return likelihood; } Real EMAlg::iterate() { Real likelihood; for( size_t i = 0; i < _msteps.size(); ++i ) likelihood = iterate( _msteps[i] ); _lastLogZ.push_back( likelihood ); ++_iters; return likelihood; } void EMAlg::run() { while( !hasSatisfiedTermConditions() ) iterate(); } } // end of namespace dai libDAI-0.2.7/src/util.cpp0000644000263000017630000000714511433220723013734 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include #include #include #ifdef WINDOWS #include #include // for atanh #include // for log1p #include // for _isnan #else // Assume POSIX compliant system. We need the following for querying the system time #include #endif #ifdef WINDOWS double atanh( double x ) { return boost::math::atanh( x ); } double log1p( double x ) { return boost::math::log1p( x ); } #endif namespace dai { #if defined CYGWIN bool isnan( Real x ) { return __isnand( x ); // isnan() is a macro in Cygwin (as required by C99) } #elif defined WINDOWS bool isnan( Real x ) { return _isnan( x ); } #else bool isnan( Real x ) { return std::isnan( x ); } #endif // Returns user+system time in seconds double toc() { #ifdef WINDOWS SYSTEMTIME tbuf; GetSystemTime(&tbuf); return( (double)(tbuf.wSecond + (double)tbuf.wMilliseconds / 1000.0) ); #else struct timeval tv; struct timezone tz; gettimeofday( &tv, &tz ); return( (double)(tv.tv_sec + (double)tv.tv_usec / 1000000.0) ); #endif } /// Type of global random number generator typedef boost::minstd_rand _rnd_gen_type; // Try boost::mt19937 or boost::ecuyer1988 instead of boost::minstd_rand /// Global random number generator _rnd_gen_type _rnd_gen(42U); /// Uniform distribution with values between 0 and 1 (0 inclusive, 1 exclusive). boost::uniform_real _uni_dist(0,1); /// Normal distribution with mean 0 and standard deviation 1. boost::normal_distribution _normal_dist; /// Global uniform random random number boost::variate_generator<_rnd_gen_type&, boost::uniform_real > _uni_rnd(_rnd_gen, _uni_dist); /// Global random number generator with standard normal distribution boost::variate_generator<_rnd_gen_type&, boost::normal_distribution > _normal_rnd(_rnd_gen, _normal_dist); void rnd_seed( size_t seed ) { _rnd_gen.seed(seed); _normal_rnd.distribution().reset(); // needed for clearing the cache used in boost::normal_distribution } Real rnd_uniform() { return _uni_rnd(); } Real rnd_stdnormal() { return _normal_rnd(); } int rnd_int( int min, int max ) { return (int)floor(_uni_rnd() * (max + 1 - min) + min); } std::vector tokenizeString( const std::string& s, bool singleDelim, const std::string& delim ) { using namespace std; vector tokens; string::size_type start = 0; while( start < s.size() ) { string::size_type end = s.find_first_of( delim, start ); if( end == string::npos ) end = s.size(); if( end == start && !singleDelim ) { // skip to next non-delimiter start = s.find_first_not_of( delim, start ); if( start == string::npos ) start = s.size(); } else { // we found a token tokens.push_back( s.substr(start, end - start) ); start = end + 1; } } return tokens; } } // end of namespace dai libDAI-0.2.7/examples/0000755000263000017630000000000011433220723013273 5ustar jorismkyblibDAI-0.2.7/examples/example_varset.cpp0000644000263000017630000000576311433220723017031 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2009 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace std; using namespace dai; int main() { Var x0(0, 2); // Define binary variable x0 (with label 0) Var x1(1, 3); // Define ternary variable x1 (with label 1) // Define set X = {x0, x1} VarSet X; // empty X |= x1; // X = {x1} X |= x0; // X = {x1, x0} cout << "X = " << X << endl << endl; // Note that the elements of X are ordered according to their labels // Output some information about x0, x1 and X cout << "Var " << x0 << " has " << x0.states() << " states (possible values)." << endl; cout << "Var " << x1 << " has " << x1.states() << " states." << endl << endl; cout << "VarSet " << X << " has " << X.nrStates() << " states (joint assignments of its variables)." << endl << endl; cout << "States of VarSets correspond to states of their constituent Vars:" << endl; cout << " state of x0: state of x1: (linear) state of X:" << endl; for( size_t s1 = 0; s1 < x1.states(); s1++ ) // for all states s1 of x1 for( size_t s0 = 0; s0 < x0.states(); s0++ ) { // for all states s0 of x0 // store s0 and s1 in a map "states" map states; states[x0] = s0; states[x1] = s1; // output states of x0, x1 and corresponding state of X cout << " " << s0 << " " << s1 << " " << calcLinearState(X,states) << endl; // calcState() is the inverse of calcLinearState() DAI_ASSERT( calcState(X, calcLinearState(X, states)) == states ); } cout << endl << "And vice versa:" << endl; cout << " state of x0: state of x1: (linear) state of X:" << endl; for( size_t S = 0; S < X.nrStates(); S++ ) { // for all (joint) states of X // calculate states of x0 and x1 corresponding to state S of X map states = calcState(X,S); // output state of X and corresponding states of x0, x1 cout << " " << states[x0] << " " << states[x1] << " " << S << endl; // calcLinearState() is the inverse of calcState() DAI_ASSERT( calcLinearState(X, calcState(X,S)) == S ); } cout << endl << "Iterating over all joint states using the State class:" << endl; cout << " state of x0: state of x1: (linear) state of X: state of X (as a map):" << endl; for( State S(X); S.valid(); S++ ) { // output state of X and corresponding states of x0, x1 cout << " " << S(x0) << " " << S(x1) << " " << S << " " << S.get() << endl; } return 0; } libDAI-0.2.7/examples/example_permute.out0000644000263000017630000000234111433220723017220 0ustar jorismkybV = (x1, x2, x0) X = {x0, x1, x2} Note that the ordering of the variables in X is the canonical ordering (ascendingly according to their labels) but the ordering in V is different. The permutation between both variable orderings is sigma = (2, 0, 1), or more verbosely: sigma[0] = 2 sigma[1] = 0 sigma[2] = 1 This means that variable V[sigma[n]] should correspond with the n'th variable in X (for n=0,...,2)...OK. The states of the variables x0,x1,x2 are, according to the ordering in V: SV: x0: x1: x2: 0 0 0 0 1 0 1 0 2 0 2 0 3 0 0 1 4 0 1 1 5 0 2 1 6 1 0 0 7 1 1 0 8 1 2 0 9 1 0 1 10 1 1 1 11 1 2 1 The states of the variables x0,x1,x2 are, according to the canonical ordering in X: SX: x0: x1: x2: 0 0 0 0 1 1 0 0 2 0 1 0 3 1 1 0 4 0 2 0 5 1 2 0 6 0 0 1 7 1 0 1 8 0 1 1 9 1 1 1 10 0 2 1 11 1 2 1 The permutation sigma induces the following permutation of linear indices of joint states: SV: SX: 0 0 1 2 2 4 3 6 4 8 5 10 6 1 7 3 8 5 9 7 10 9 11 11 libDAI-0.2.7/examples/example_img_in1.jpg0000644000263000017630000007457011433220723017050 0ustar jorismkybÿØÿþ>SNC-CS3P)ÏF‹eîyxFÅÝRÿÛ„   !(!/)21.).-4;K?47G8-.AYBGMPTUT2?\b[QbKRTP&&P6.6PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPÿÄ¢  }!1AQa"q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúw!1AQaq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿÀà€!ÿÚ ?¸ŸZCœûÖ k”7>ô½µÃéøÔ3œFÇÐP›Ä9Ì®}XÒ˜«D\è4^lW=sZ§w Ã¡¥9ǽ ”£ïR»£ó§qBV üTþô6 àRöÖú”/aGSJý)ôý+ ^âö>‡¥Rz‰™@|çò¢Nô§d7©Þx[þ´ÓÒ©;…†°¨n?Õ¶} ÐÃ?ÿSGSV¶ ßÐù°ükKŽžµ- âŠMØ¡¥è°…ïZêPéݺИà?:\P<Ž´ z皶ƒ Â×Æ/cÿv™,ÉËD‡ï»V3½ð¾³ Ï÷{}kw¯cš‡¡›Ü^´ÖuLnïíIj+óÐv'ð¤7ˆVÚ ±­pÇ°Ã#­IèÉwO\šnÎjô° §Þ”Ÿ­J×q $ÓðilË1¤‘±Ç4ƒüæ®ý 2uS‹€qYèø—¡‹1õã=+Ñ< £û.GÏ&CǵmI'veSDtõ_PÇØ'ÏM†’ÜÊçž!æ3ŽÞžõÓøX~þàñÐQ›ËJw:J*LÛÐ(¦M¸o‰ ‹@¼ò1ZSÜ—º<àãhÀÇ¥ ú×3w; š*oÕPv'?ZêíUJ9E sŠNâêNG½0äÝZ¨Ï3(âºètf“=Ò–²z¶7² ­¨0K˜ãî÷ª‰“84åx&–›ŠÊ¥¹™Õ º€àsš¡êk%æ]Ãñ¤ãÓv@æƒ×…¨ =(<ñÏ’³Ç3€yÅ,c&®#?Ä'>µ‚Ÿ'„¬†t´ÓÒ¥&†!¤ëMjj‡ÈßCÖ„#†þúO÷"ŽM]»ßпãÌýkO¦*]Æðçµ¹©Ô¥¯AŠ:ÒŠ!»S‡N)=Å¥a@àu¥À8Õƒâþ›ÃMy‰™fc‘Z&ãqéÅ; ï|1ÿ èÏ+[£Ú#9+‡¿ôª÷IIhAxéKœš,ÇÔN}E÷¦Lûþ´”®¬&®( Ðž‚CO=©­Ðý)¥qØÇ~e$zпýje£#V ÝÀæ³Ófvô¥Ô¢Ô`îb½Àà ¬„þµ½'¹]Ž’ªj§n™pxûèKS‡¸ ëÇå]G…°^sÇlT'€è¨¦fŠd…p˜ã³ØŒt­)î'Ðóã÷G§µ¥su;VÅíãQ‘½#þµÒiçýˆã,OëCØ]K,ÄMˆnÔlWƒ›…ÍtѺHæ­³=ŠÅn7² ¥¬6Ý.÷kHîfÏ>O¸=….âõ®yk6uÇa‰êsÇ­7Ÿz›jP˜æ‚£¿Z[èc¸¦´`ñàÑ‘íŠlc“Çj–“Ïÿ®§P2¼JÑ”sRhC÷@ö«èùÿõÒv¬Ú(CIK`zT2ãcj»Üaþ‘'o˜ÓGÓéU¹&þ‚sfÃ<î5¨O4¥®€Å£æ–Á¸žü^¥/äóI€ò<ŒæŸ@ž)qJö Eü3õ¥¥$1àqéX éñ‡gõ«½‰f@ÿZGSI7F÷Zc;ï È:÷koÐTóX‡ ¼z«\}ñëŠ~d1™ÉãùÑŸóšK`ØJæj·A°Òi3JÖì(4íE»ßjk”ý(WZ}Œ‡åÛÜúТ¬v1µ^.ÿ ¥0”ãƒô¢å¢ÄJÆ@sŽkÒ|1¡ŒwrsøÖ´ú™TzG­QÖóý‘sîzâ…¹—CƒSûÅÇLq]O…—&vìZ„½öl׸t4S3aE2B¼ïâS  ÏëZ@]QÁ·LP>ïÖ¹¬vô0>×;r#þµ¹¦ÈÏ \aA<­Mì rëpØ¥²µ<ùì tÒ{ÕµLô:+4d!úV~¼êšDå€ ¯zÒ;™³‚Nn”§·zç—ÄÎŲ‘ŸÎƒYê†'oQõ£ã­=ŠÞ‚9'úSÜéÓ¥ è*L‘Š±Í!˜¾&?* ·¢ŒB¾•{ w6é*#±BN£¥W¨†šŠ_ºAô¥n p×ûT¸þñ¨Æj–¢7¼?²?¡jÕÆ;TìÀ(8ÍêÆ'¿õ¥þªÚÞsKß“¼?;éUÐvÍèº µ81Kv€Í`x‡þ?bÿrš1×ýi4“p·j€ï|2?â];/JÛíI£9j.yÿëÕ{ƒûÁD•Éd@ÒçëRÒóÅ]ÖÁb2sHOÒ“o`ZóŠ[„ŠcŸòqŠz’~ñÏJP9çVº¸ÑªÿÇ×ðª1†óqI»‹Q€YA'­zO‚Æ4$8ÆXÖÔú³:«C¯ÿÈàç-4õ1¶‡ ?×'ûµÕxWý\ç½J?6—ÀtR3 )’æßXˆ—Ž½…\:‡Tq ÒŽßZç¹ÖihJK¬ã„­½0ªC³i ß&“Z-HþÿO¥eµûŽŽOOjÞ–Ç=e£= Š”)t Éñ+mÑåµqÜÍœHÎÐ ò+–NÍ‹a1Hyÿ -¡AoƒøTÛ@øhÿ'šcûòE!ëýj¬!Î X€p3ÅK@`ø”æHÇ©¥¤ Bœ{жÜפÆsSm Ð*”º0ÿ*ŽA‘Oep8[®/gíÔcҚؓwÃçýO÷«_¶i=Æ£¥6ž)~µ1}/^”¼cЕ˜˜õJÌB¯J_Ç­!ô“Lsò7҈݉#)ºœã“Þ•zÞõ{bj|Þ6{ÕH×ç?0¤ÝØËhY{šôÏ‚4‡^O5½=™MÊÌñmÑ.:r1BÜÏ¡Ä/úÕúWWáL›imÕ~ó6nÐFýHÅ…+̾$‘öèWŽOAW˜­ª8ÆÅû×1Øhhí±._«_M}Ñç›Ø.^‘~+CÃÑç_¶c‚U[·JÞ“ÒÇ=C»¢³ˆOp¬_œi-Î9­!¹›8ì`qŠõë\ïWc±l&;*B*|†”R“°ØŸRBô÷¤úÿúª®®HË ³ éCWC9ßÿÇäC§"¶4¥"úU-€ÓïIß?ʳè6!¦Ž”â FþUÿJjp÷¿ñý7^¡ô5¢ff燎a—ýïË¥kõ¨êP½JQùRz€ùâj,Å䎴½3Çãš›ØBƒÍ;#¹ÍUî$€ãž¿•)|S*â4€Ž=éÈozBh™'þ÷æ+ÄŒ­}Sœ¥P6cõƉW~WR)½5BÇXÕ,#XíîÁEâq|W­¯Þ–ÝùèbÅLM/ÖXíÄRjlÛšÖÔýéNé_ðIqöŸ#Ò_þµH¾/”›M_ø ÔYÊÉÆ üZlŸ„€ÔƒÅ¶ö— ôÒqKQZCljôÖ­Âúæ3RéGƒ,ª}â5/Èvh™5Ý+§ÛgÔb¥¾˜Ü øï¡U¶-G‹ë'û·ø¡ç·(vÜB~Ž(Õ æ~Aä2œÿµO qÿצʹ‡ªe¯˜mn*œKóä«qê(-ÑŽäÂ7×éÞ]¾€œÖ´ú™UØÚ¬Ÿ¹M|wâœw28¡þ¼sÚºï ôO«Ô¥«fòøMÚ(2aE2B¼¿âA'U„u_¯z¸ìÂþò8öÅí\¨ì/iÜXÜ·|â¶4¥Åºüʧª&úš ³Ÿ˜cØÖLJ¶Ók#c€zÖôÌ*—z*")îƒâÖ#NP3‚{V°ÜÎLÑŽ+«gbšB>”Æ?Ö‚(è19Í%$ºƒ§ó£§4[A ?xU¸‡Ê­$ÆŽ_]?ñ5G8'¿zè4Ñû¤ã°ÍPº—IͽJW(ni094&úÓQ¶?\Òó`Ž+Qu‡|æ«g¡«V Ûðö6Kõ­ª]F'jp?Ê‹\þ*ô¡®À/z\Ь»§éN hµÆ8/~´lÈúÐìÄ+Æç'5  Gµ`ë„‹¤ÿv˜Œ­ß½?J“ÌÈéúÓáý©|οáL{†ðGCH]}?JV&Tþ„¯ ühùqØÑòõº 9ï@õ?-•;š ñÛò¢ö›º®>‚“`!T¥=zƒ ;÷ìMqÒGð2(½ÀPÏÙÜÿÀ³OYåSÃ?Óu4··+ÒG\еñ_ˆlâÛßè Õ¥9r»Ø‰Ã™X¶¾;ñ*u¹¶÷ Çò¢ëÇ:Õí±‚â;?-;Q²ZÛÚǪ9Ö§£*/ˆf–†}²+cKñüšm¹„èÞhÎw%À¦ cÅ?ëü¥Õ‘©Äë_ùo£Ý§ûŒ¯þr?‰:(2 ¨‰ìГʵQƒÙ˜55аŸ¼0ä|éŸïÀãúUÈücáÉH «Ûäô‘üê•+ìÌœÜwEÅ×t†Æ5+SŸúj+Î|yuÖ³[ÍÈ«ÉFͦárá>i+³­!÷®#½—¬Î4É»ÿŸµ§gÉ{¢z—~õ­á [Ä.N0°qß5´R±ÏWc·¢¡÷ ç|`Ù´…–Íi É[œÅ!ÈÝŽÄ'ãAÇ4¢€L ÑŽ)ܽ&:P´1ÀíFr?¾¬þ!üªÚ}Ñš—e°ÎOUùµ Pk¦ÓÇî×ðü)Ë`êZ¤?ç^Ãþ”ÞŸç­P„8ëQ±é͌Ն59Žzš©Ži¤M¯g}kkõ¤ôc°½½½(êi=ÀZ3ïŠ: \vþT¶p;óRÇJ¨­p§ò(Ø”|• j\‘’)\I(ä:q\ïˆúb{i f8l=<6j‰Ü‘U[¹ÍIåûŸ®hL¡|£êßSÁcÛ¥+……0ËŽôÅ?ìSœ`©w>´Óep¶ÿhÊóz‹kÂ…¨Ãº!Ï÷iÚâsÂœP:t4–›€™ã¿ãFF:‘N÷ÜF´gñ4X@ùdûP žØ¥Ýè(@.î:~”™äScLL.}i@\ç’Ú¾‚—éˆM£ɦ˜c#TýE>kl+\i¶„ôáJˆ‘‚BýMõµ×­¥JEí†4¦ÿiÿ¥lØàB¢‚KƒVσÔfẕˆ.é_ ÏPí(¬¢Ü+šñym×¹jÖ·9¼zw£Ÿµr7©Ùê'^”Ÿç¥nP1ÇΖà'n”R~9¤ÿ?ZoÈb(ùÿúÕd68éEµ¸ŽFèïÖÛŸ§é]eˆÂ´Ý‡Ô›ò ÷ÍNãliúRtç4ÚÐBõê2j[h,qÚÂíÔåãëTºÖ‘w$Øðñùæõ¸E&õ¼ãŠãÛéK˜AÒ‚qš]F±NPIéšQÀ£z/WQøÓzì°ŸkµRwNƒñ¦6©bƒæ¸qBWÈ¥ÖlJ¬Ì}1Y×zªHafCÜÑg°îUS‘s;çÕM%ÔÐ_:¼³a‡¨Å;h"#§ÿaÁêAÍ\¼Òì-cG–I0래¥©H“M²²Ôe1Û•Ët­”ðò²(ú v±-¤Nš¨3¹oQŠƒû—2¯§Ö~ðÔÑžÜ0·ÒãýÑUφ\¥ëÀª õh‘·†.Á»zsQ·†.ÁL‡ßÒ´ÑÑørü}Ó?Z‰´@ˆö¬ùÒþ¿à]ôÛÄl4? ŠiÓo ä“튮dÇaet½`oÀS>Íp:Àãð¡JîÁÊƘdbaøS rŒ3þÍSиçƒFžÔ\V(?ýj]¾„ŠB ˜xÒ`ã$†úûQ†ïŠ}Ðz @¥"C$”4.Ãw®hÝÅ6ó{~tž”n‚åøsý˜£ý+fÑqQ}¸ ½à°Mõãr@Uí]1øYÍSs¯ïEg…=¹ß[ ÷Î*âJÝùçÖ|W ¯s´LRÖ­\L=ûR~t 9Ær(ö¥k‚ù«„®Ù2¨ÖÈlŸnÇ1_ÀÞÌ„f²õO \é¬÷·ùLÛCFIäû|©íý~©»êg¶™o¼ ¾PqžEMÿÆ­$ 5­³ÏtuÅDuv.ëvU—CÖ#Îý.ìcÒ"•Vk;Å?=•ÒV…‡ô­y%¸¹£Ü…” Ë‚þ`Gó¦y‘ÿyG8ëYJÉ4ö`OC‘×4ÞÎAô¡[t1É4§Ò˜™zÝÿÑ"ŒŒ`çé[örE,‡]à}Ðj­ ¯b~Aäƺç^œñ:{ êŠ÷_¡ÏStu”W:Ø%¸W)âÛè$€¤ãiÙ2cº0ñG_¥r3°B:RcÛÛšw³:ÑÛ·çKvÚ“üô¡& ÓÎqÏ¥;XŒ|ôùIÚÇÐS³`r¶#~¬çÕ…v6Ã(“°ŸP³Lþü~5ëHq¹˜û ˜Å Ð…õÈ ‘P¾¸ç!{œÓµÀõ›¢8¿Nõ^MFíó™qôùm¨䕤rîrÞ¤ri¥±ÑˆúSHîÎrM4¶i€„ñI’h ¡€‚ƒI€)9Úh¼c‡=¨°]{°Ïz7ÀÉÏ ¦ô‡rp#rÝ4K°ãÌ“wBí$À`è;Rö?J¸ß·úk¨ÿžÖºüóëI²d <ÒŽqRH™?áKœQpJáœQÞ€<úQž(݃`zRSh.&j;õ-“DX\Ë~ž;U”qú‘þ^NsM¶[æ'Ô"‘i2Ñ·.ÓÖ½¯GÑìÁÿž+üª—ÂÈ–è¹\wăÿËŽ·#ùqÜ%±Ä\ô™99Úy¯TðÈÛáë!Œb1E=¤L·W5(¤›E5r'·‚O¿ mþòƒPÉ¥i²¬Óí_ýèTÿJ|ÌV¶Å9¼5 Ò"Ì0åb׎ßÊd¼…EUf c'¢ZÄq“½™PrO¦iíÐVe—"#ɈsŠÑÑ€Û“Ͻ]ÄÍa‚1œWQà´ÄWë/ðÓî¿Cš{¯S¦¢°C–á\‡ŠHmU\GùUtbÄŒƒHk˜ëõéúRv¡ÛaãŸëE!GoÌR}9¢ìbvÀýhÁþ•WÐBÅËÑpÅaç·j‹Ìi7Ì}ú×eú°=j¤Æ¯s‰éŒQÓŒâªâ ÐIÅ0½'j@ÔS{ñNÀ! Ð $ôÝêQCÜ›³ÐÏ © ‡Hþ*é÷®ãÜ©¦]ñ¹>ZýNjy˜¦…1Æë„ô2èä﹓ðšzhÑèGžVüqVWBÓTäÁ¸ú±©ó„¿ÙÖ1'ÉiÇN(†4F@úSO¸“'uchÇÒ°×Åz”rµEÑ÷)•"«ê‚þí®¼½›€4Npåv)µ-Y¦ç¿jãZ;B{ÒÍ6x£¡¡€‡Ò“ê*u¸0îiAž?¤˜@8j—·ÿ^šÜ,6Aû¾2*þÿ ¡¡·QX~&àÁý?W³C tçò£ÏÒ®×½á1ûÃé·ÎºŒ÷¤ßBe¨ŠãéJÖÔH^â€xçëCwQ3ÞŒþTµ°•É)gŠUÀ3Ú¡¹oܵ; Ýû)Ü“ïTÐÎ6õÏÛ¦ÇMÇ9°3·Ê¸¾;Ñb‹P¢™¡‹9MŸ¡a‘^îªB¨@À ªW±âbà_ʸˆ¶ñý§Fœ HÓ´dƒÕJÓ‹Ô$´8íK0Ëpç*£Rõ¯d··öÑB˜F¡rOZ­£~ä4œçÌl©3+pØäqïýð—ýjÍ"H}X1þ•6¼Z+DÐÿqJÍfhKúÏ}¦¹›£›©½7Ê•®ÆB”­Ò¨:›qþÍlèãýzžÃµY —Á®·Ã3-Ÿ†æB0¥˜×\!xØä­+Yœ‡%Ô­w9Ý,§$ž v…8œdtë\õ~- ¡°™i9AÏ?ZÊF‹qpqAäóPÕûâŽô–à˜#ÿÕEÀ;ã­'ãU{ƒbv¤=)_P%€~ìñÖ³5ÖÛ`–h*øm1òk§•:Ô°Z±ÑŸzS³VŠèT”þðÔyÅA M1²GJw\åâãY}êÖ¢'ÓÎ/SšÝÈÇøÒz±9¹æ¥Ýl0=}é=3úS»ÏùÍ8`/>”áÒ£Ô ï{f¦¦’@5ÇÊ}~µyßœR»{+v¬/ôƒÛÿ¯T# 8ªÕ»áN%8î¿Öº|Òƒ4¹©Wz3G¯n(ºB°~4‡›Aah¤ìf‹$€Nõ ×ú“éô£šÁ±žsÅ)û§éÅZÔg>ãq!ãï‡Þ¦¶ÈsÚ†R-Û~òòÑxU71 ôÇÌ:׺Õý”GÚ â>"s¨hþ›JñÑDUØ=Ž+Q,÷2wÝ4`Üîí•WýÚ^lŸ·ò ò½jÑ´ßj®mĦî?įËôlÒOI.è'Ñ•{ôíÖ€y’±©,œôSÒ¹™Îf“ýãšƶ#LRžÕH ÑÆYzœb¶¬#Háڋƨ‹ºdÖÕÑh¼€B¸PÜ ry®êZ•Uìa˜ÇjwkŠKÞw:"¬ƒ'9ÍZ_º8ü*²¹qÜ_ŠÊê'ò£&•¬4'8þ¦“½?6HG0Œþµ!àqúPµ@Oú£X¾#m¶J9äôõ¤µz”ƒÃ‰¶ß¯àk¢*‚ÇM)î(„G Oèi­«7úÃý*<óô¤’cBgŠcœðªz!³'ZÇîN:šÈ=r)ĆMdH»½oö¥%¨ZzMÜž{RëƒN⸠ÓÁÀϧ­(§Z-q’Ç÷ên´÷MWŒfOÆ€&aÐ÷¬/ãd=賸™‚¸À«¹á\n#ýšé³ÜÖoFDƒ4µjèBg¿¥/­FáqÿõRç­ZTJ7?Z;ÔÚÀòù5…$óhȾk”ÏÝ'Š»\h±Ãâ2j¶qw@‹™FˆŠ|#š F•‚)•×*YxükØmÚ!µ† ®ª ñiœ¸—k‰PÿßUçþ8rþ$¶Ë»£%Czâ´Œ»1‹m¤sh¦y ݃æ)܃^Ë’¼¾èÉeÉÈ"°§h´tU“ƒRD›ß¦Õ'Ù¿úÕ…â­ûjÒ/,D—6Ͼ7'Ÿuú¸S´“1•vÕ¬p3,–Ó®chdé†è~†‚ÊKtç­sÎ-£®2æW&µ,\¤n`Aƒ /ç\¼‡.øé“Š\®:²Ó¿ZQ÷‡~i1šp®c¨­›sÖ´]¾„Çî§zë`°þÒðP³çhŽÃ×æŠëRåW9*.f‘ÅZÈeY”¤€”t<aÁèjn+’GDu@;uâ®Ú³eDZi©ZšÔu£ß­0ßµ©>À!ÎzR`ëRïaŠzb˜}óU‹ Ä'#šÆÖy¹¶xç…-é°¼R>ãÆxÍkà{ÔÉØq!òãŽôà¼ôª@V”|þ”ÎÜŽh¸z #ð⑇Þôž¬fV²¿ºŒÿµþ5ˆ~õ\t!’ÚÿÇÊc×ÐqŸÂ”˜¢¤@G¡¤4;¼Ó‡OZ,‡×ñ§ ‘Lw$N¦Ç<â«@Æÿ:¬ƒ÷¿Cnã&~+ ÄüGùõ£©,À¿…h‡ÐÛð¾óÙ­t§½KÜL^‚ŽüÐCaÛ½/AR´b?­Ó½†ƒùRç‡aJ3Å XL^ø®qÎ5'ÿ{µPÑxðs¥ p¬}S`q²„2ÈOw5, (ùNïzOrѧ¦ãí±s†_ç^½ˆ¶ñçpùGjí ½Öqâo Æ˜?FÀõÅyÿ‹[> Àlâ:Õ¯u˜R~ñ§e¥@;¸Çç^·l¬-£ Ù;Gzdz:1;"B„>nzÔ& ž=kdqîA=’\³Æ’/£.j€Ðôè›réñg9éÞžM#VQVL¯âSéNè=1Il¯(ßCQÕQ¸}1LlœñW¸šÐÿFRA5†ß{½RV Ûq?Å]õ¥&!E8FJöüê[»° bldàR‰çŠ›YŠÂˆÙy ~t cîÖš n;Çñ"œ£'åHdŠ2F*TÀ=x¥ËÔ¬r¤ }jª¬¡«î ’·AüëÄàùPš3tý(5{ ÛðÎDŸE®—ñ©dÈ3Å -‰ ÒŒñE˜Ð‘Ižôí` ;… ½'J7ÐL^‡ŸÖ¹©5?íÓH¤hŽH¦È@†O÷OJ¦ÄqŒê]ÉùZƒ8Èri-$x„vaŸzôÁrÏÐÅwaµM3›®… ò;× â‡®HÞ‘Öõ4ƒ0¢­#;IšÜÿ¶8¯XGQ ôQ\ømS5Ål?~Þ"”I‚>jÞÇ Ç LÓ&ºò×{ VÇ3â¹·iRÆq^fNFk›¬Ñèá׺ ÒŸ&hþµÊni@€]–ÏÍØzVÕ¶šux”&?Ö°4’!»"OøFee J­øó]5Œ±X¢¸pô¯N4}š½Î*•.9«`sëÅC-¼ßë BO^0iZû’¤E%¤0;¥¸ ½šÍ¿­qâ ¢®Žº¸v¤®‡@…ôèi¤­ n´ŸJ€:‘íÒ“ÞŸ éM=úô¶å p£Þ±'ùõìz.qùÓM”lÆ2¬ Á99úÖm÷u>§÷ª“²¼Ã/õõ¨Ê1Ú—A!»N:ÓJã½1ØÌÖýœòÒ°O ÖªÎÂb¡ýêqÖºNÜPÄ¥Xe-¯µ%«ŒŽFýi<§=‹ bdVáºÑ´c(êìR:SäÒl1ßúT©´·'Ÿ­Uì;uO­@ª7ýyô©¿Al?ýu‹âl}š/­4¬ úôúRö÷§fØ>ÿZû'ù×IžiKpbÑBÕ’ cñ¦µ¦Ï_Ò…ØaÖ¥NÌBwõ¥§°Àk™ãP8þý;ŒÒïü©$Á‰Çû&©Ûq_SŽ2Êà.FN*Ä{š,¿Ê:}jJ4t‚ Êä ®ôIòŽ{WnvsÖØp—‘Íqzû“ªNßìŽ+¢»´ é|E}#ýl§Ì+ÐÖãä^{b±Â=ÊÄ+ûOmÔár}k²Èãåî+]àuçÒ¡i·“š@£cÄòçM`=+Ïz'>•Á‰ø¬z4>EKj»îáQÔž+Ôì…¢‰r:äu©¢@1íìÒŒœ]Á««2asp½³øU„Ö.Q6ÔßWZÆKíK(ÕFèNO¡©WTˆžUÇâ j±1frÃÛa“ßE4ˆ['ÔVAô¬15Õ‘­8îÔŸç5Ên“µ°AÇó£Ö˜ H~½}©&ŸÆ“ø‡’ê"Ãp V»yšÔíÐ/4^Åô7a8©=ì˜ÊÎz—¨ÐøúšwùÍb¹¿|TGÓ`7½4Ê­Ø íc?`qÁë\ñûÝhŽ¢pÉþðÅt©÷Ò“&⊵ú±I+0ŸQÿÖ xL#å4€ñÓõ©ÓqŠ'=9â™Ó¥UµÄûäþ4õ“/Óõ©“ì2SÈ" ‘ÅR×Q rqŒÖGˆ±öXò{⎠ـ½:©è¿†Ö?ºtƒÛ‰†qíFin+Š(%`´’õ.i=Á†~¼W.ß5ù?ôÓ?JQZ‚4é%lA!Ü5¦Àq½]¹5f-Ì£$õ£vR5´…Ût§§#5Ú†àõÙ‡Ðç¬8uÏS\V¸s}ryôã½m]û„Qz‰£€f€*í¹üq\ø]n]d4„àp+¹œà êNO­ÍMÂÆ/ˆ_ýLœqÞ¸£µÁˆ~ñÙKá*Ƙ»µ8¡?‡λšÔ\8üj^3ÓëYÉ°¡çóÅtÈ\Ó›Põ)?»Vé°¢© `ûŠ‹ðüªR°›BPG4í  Åö¥}_ÆŒÓLïʼnüêV '=qH¹ßØþöÐ’f~‚±´Ñ¾þåñÆâ?Zl¾†ô9ɧù±‰DE€sÐT­JŽÃãïÏåN=)Ý-C7 *Å!xŠiÿõеc(jÀ6%sdôª‹7A],|¢:U;XCªÔ<Æ=k; aÄÐÒ ãVÈòóŠF:óIê†p5 ÏjiX7#ȧÄnqS`ÄïÿøQ¨1%Àžý+'Ä?ñä‡Þn#Ÿ=©G"´­á§ÿIÙßoõ®—>õ/q=€ôg½]ˆbþ4gùRÙh÷£<Ñ° ŸÂŠM‚ æ—‘G@Ÿ•s·wq¥ô¥žxàÿ*IȳÙ|V¶Ð0…$Ớ·"D0rßÊ‹v©¢e®WœÕÛ׆Þæ… ÍqÁÍåÑ÷­q –¤š(ÿI‡Ó5Øä瑃Yal]p-ŠoS“]rg8r;ÓX°y¤3Ä,~Àã=ÇJä{ ó«?xì§ðŽoI j1·pIǶ+- ±ÙG8c?CS,èݘ~ \v%Œô?Òœ á‡×57i€ ƒÐõ§ßý+TÊ"›_ZƒüñSêHcþµ!ö¢À'ò£¶) è!ëAëJÉ ñUèv¢>dò ”mÜÙ¬Íe§|}é 㶆ä<äԸݟ^õ-ë¡qØTêGJSøSDÌ>j‹­RZNÔÃÀ¤®)êý†o¥s' Rbb7Ý®’û”=±M€ÿò*Ô#ñHH{8¤ž¼{Sì2‡Šhûµ+Pœ}ª!È?þº,"€pE/’‚z@9×?Ö™›éM!‰ ùk+ÄØ&{AÐçÅ*ŽjøÔ1ꇊêr1Iî æ—ü(H–'·¹ïE®‚÷§™¥`ùÑI»€:^ÔÂâò×*9¾@?¾iZÃHÕRÜTfUæ¼õ#?…p§©Ò9daа©VòQß6>´Ô¤¶*'MFå@ÅÃý3R RäËRG|Õ*²BäD¼ï>šŒÝKqùÖÁ"¡»»—k!{t­¶ê\‚r” s°Žd‚:ÔÂU=õ¬Þƒâ^Ÿ•Rw@('×ò4¼ç¡¤‡±×ÝQý*±ü*–ÀÃô£¨úRzlHRúÔl9ÅÚÐaŠ9÷4EÜbsõ¥„|æ§TÄWÔ›mœÇ=©š2í±Cê3My”Ö†¼c÷cëRãÖ²kÞ)-QóŸ§jv+GdI Àc'·ØÃg‘FÞ>µVC!•?tãý“\¹‹æ  U$ aå#Ú·¬—6©Îxô©wB&ÛƒÛ»N;RwÝ»jn>`{PíaèLNÁNVöªKKˆváƒÁ¨Ô°)¦ºÖ9n*Lž8¤ÜŒ)ééPÿN)=„9±Ž˜ü++Ä 7ñ¨Ñ°9´à{S—¯5¨Ëz#ùwèÝrvžzfº³Ò”¬öØwÏ>´µ6&Ú/µ%d ÷£Ö„=Åõ þ•z 1‘ü蟭p­ô5ËBq}éóÔiøôéžµø`›ýÃT€ä•ÜpH5f"Î98(¹áôÅÚŒq]nÎ8æºðúõ@žÓò®Q't¤wãóªÄ+ ¤µ¹*ýÐ -pXévÍJ«h‹I´c ©ÖàI¨ºDxà~5zŠ« wn•bÍÚ’Dm¬7 ~DØÔ³Ô/<¬´¡È=XU‘©ÜóD‡. H5SÑíÇ>†¥]Zgd‹S¶Ã&S€ô•Æ:äTÑßBßòÝM¾À=䜆 ;ShÕn!;ñŠ? }5GZ\{Ñ0ÆýT½;RõüZ>¼Õ+!ÇðiÐ ƒ­+§¨u‡Å“`ã-SéªRÎ0º3íGK”ÍD ¢8–<€Xäç$æ³wõûÀúJiîK#—îçÒ¡…¹;Ž&šyª¸ˆäVàƒ\¹8ýM8Œ˜m­½8æÎ:l,X9ô¥ äãÒ’ÐBHÀ¦’A÷¦À²@=F{Pg#"¡»-AÓÒ“aüê“ÒÂ#*D£!Sžÿ…'Ø A8¨wv÷§aŽc‘YZðΙÛ9©kQÒô¯¥Hƒ,áT2}/þ>¢çþZ ëIçÒ•¬Kô4vþTEÝ€{Ð;u¤Ð úûÑüªD(4©1†iGZ{…Ä~#o§jå æú>SM 5‰æ Ô:|ßîÓ¿A ^<Õ¸ÈHÀ¶((ØÐ&Ž)£y\(îMu‹uk!ÊOÿWm’0©Ç»îSòž„WŸß±%óÔÈ,C÷t4Ó'4uÿëWGH¸¥éڛϹÎGZ›íTíÓí×ÜŸÔVIûßJ¥t†;Ú¤ŒþâO~)ÞIJý¯/çS“Á©`„ ñùS³×ùSè1ȱN´ð‹·§åÅ Ó°P¶ÃêÅ&ÔóIíM®£QŽ*nã“G?äÑk€}h¤1Ó£ÿVNhê™zÙÿF{—½Åi[.ØwÀ¦ÞƒeöeŽ=Íœ(ÉïDn$Upb1PÕÊB¡ÊFpOÊ)çƒM]’ÆI÷ Aßš$Sõ¦=jž€2C”8ô®NC‰˜´iÅÜLA^µ³¥°6KŽ1þ5LeÂ~½zÐ:z „ï¡(^1Ml cŠ¦ÆX^‚”R@…>Ýiyîi7¨ÈØÃ¥OéU¾ !à}*·ñ(@+}ÓYºàΔÝùïS¸Êt§©ÃUt>—:ts]f:–ŸA±3þE(ö¥Ð‘x&OzwÐþ´síI6Hv¥íŠeZ¤Ý„„“ý[ýÊÚó}9ÎhC5óUµ"Ÿ1ÿdÕ5a3–¬'ÝíÔÓµÊ.ið«˜Pc¨í[gA#îÝ:ek¢>c9JÄSiKâáH=ÆZçf•‰ÚÃîš*EÄ#$ÉEç¯ãR­â‘ÊœžõÎh=n¢#©ü¨ûD@}ñùR°Ç‰PŸ¼ãK¹JðsÆ:К¿Ëoj?Ùÿ ÊïM ŽíOOø÷=:Ó³$Ѐ-EK’{P ^”¾Çžæ‹h2HÏÇ4ìöéJâ5¬Æ-—f¦Ç­'rƒ§øÑíCnÀ.8£¥-@_Z9ý*¯}†)¤ì ¥*ÿª÷>Õ6[“«÷ÑñËgùVÄC@¦2ð4ë=he¿6ðœÿþU1­±/Q¯Êš¬x"•ìÄ“Ö“¨íG¨†ã·µr×1‘w(Ú89ëZ+D$ÆÓZú8Vµ8<CÚÂF–¾´ÒU~µ­u¦1à‘õ£ ä«ðN9Y¿½O`¸ôÝNÞã8©`0ÈþbînõwsUЖò*¹Îê~@ FÓ’3éYÚÉΖ玽}*ZÔe>ৃ֨e8|èé ë]NsÍ&ÄÀäfœQ~â)3Å 4¹¤Ý¶ö¥¨ºÖ”g¥ q%8†CþÉ®^Ó›ôãûÔí ÙùºŽ TÕ?ä/8ÈëT€æO­NTqL.ii¶÷*òýÞä éã¾µq‘0¹bºh»#*ŠâMu…ÂÎŒpx¸«¥cJuÖMY‘cÖ£æ¹.…ÁÏ¥Λ †ê:šBÚbF®¯Äv©Ÿùgþ›ÕªJš‘9LvÍ1’r«*O´ ô"‡äwÚ#8çqJ&N>aCT•0FïÇ5 ‘1׊,6í—éÍIŒw„ƒµüinPKÚ‹ô Ü:g­/lԥأó§kˆktúûSÏzP¶°Ì‹¿ŸXGa“úVÜ#æQSmÔ²ë!\FÊ­êÔ¬&Û½(üêw½ÿ­¾Ôúƒ úR÷¢ÀÆ?•槮qsŽô¹ìhw¸n$ä}žN8Úk™²æú?÷OJjì CÔæ©ê§3Éè*ÀçÕy«1¥ZArý´G=½9«ˆŒ:íjÖ+C6C2o=½Pš23šÑ•íNç°¬Ÿb® ”Ó#œÓå°\Cni>ÎIÜqJÁræ² v1ý+<}þ•%⥌|™÷¤&J4½)ØH1Å!÷úÑqaÏ4rG=sM gcl6ÚÄ8û¢¥ôÍ@ ÇùÅ!60íG8©»¸Oþ”™#Òž Ãqô£w¨¦‡mc ⥸¤õ2‰u×=‘¥nÛœPÖƒêY,ªFæ< ž´äá²k>ºô(èÍ»K‡Žƒ­^Š×­ˆ°†  î"–¨–0Œ¶:ŽÔÜà{Qt\£\¶¨ìºŒÀõãùSOQ2’€XšÓÑ8/¥XÜcqŒšÄ8êsIŒçõ4 sýÅ¡}) <óRgžiŠSÒ­€ úU§Ð˜ ž3P‘Í$ÆWÞ¨êÀ:@hV±ÊG¢ž:ŽßZoM†McÃA þuÔö¥ éƒJ9ë2E¤ïI0½ÿÊ‹Ûpâ—šiX=)qÇZw¸n2ãþ=¤ÿt×7eÿÑû)4kp4Ï'ÛÒ©ê§ý’1WaŠ¼uè*xÁÕH I#/F?…ZI'‘J†àðHZÙ2X¬\dôÆHª®œãšMµcEH ŽÕ:?Žê1BD¤dcó¦ÕÁŠÐâš°åÆ=zE•¬:ÉÿNÇ¢úVxûƱêj)ã9«°.a^)ÇRY&Îå@Ú»ÃÊði \sBLWåH±±uÏr( zq®:(ïNþu‹Üµ¨`‘IøÑ¥À;f_éM¦Å'çUö`'©£Z–õ‘õõ©$è3Ò“h 8oÔn_Ü] ¨Ëg½;_qõ&1£Ì€‘БҟÓ'8àÖp·6…³+ÃÌ[K ŸºH­QÒ´êH„sP8;¿­Cmˆk.zSJœvªJè,0©q\®²„jNp9QZGD&Q8­ Ÿ:Ué@œôæ}j_px=hÇ"¥±êHTº u¥X·2sÛ#ŠhDžCsK°œ Š/vrFNHÀŒu§}Ga1ïUÈù½½+“bEç_S\éÒÅ;œ’}Áý)ýóœÓ@McÔž˜WP: Mè¼Rô7°ƒœzÒû \QÅSAê/J;TÞÃaŸJpëG[ˆŽèÿ¢KþéÍs–?ñü¹êÓLf‘àæ©jÄ}„ST+v1TsÆNƒbh³äUøfSn­„=Ei£a×…Wb‡ÀÕ^àƒ “ȥؽ…HÄeÉÛÕ{àÑ€:Ž=éu6íK±2Äå†9ªk@Ô««Ÿø˜8€ª*Msš±[¡úV¥º%3ü꣹-ycÐ#¼V„ å’{PÑö8æ’bùT±@|øùþ qNÄÜèGAÞŽ•Î÷6Böãò¤ú6Çýj1C?ÏZB)·dœRP;äÔ“p¹ì.U¸Z Ýç>s¹úþuÑZ)Á¤Ð-És'›·ÊýÞ>þ¥6å¶[¹éÅLl™£2|0se*ú9­¥éVÞ¤1 4¨cÒ¦×ÔC28¨ÙÏZvÔDg=ÇJæµá·R2ÿ…0frõ«šC¥²çªñCˆ&nRÑÓAŠ¸-õ£üš«Q :S•›ûÆ•‚ÃÁoSK–öÏÒ«A ‘˜w4 ä Òî/Ö q‡8ê)ØCÀÆ* D J=¨Zç œ¯zqçëTÀšÏ£×A]8ãÆ1Q¾à(äÒÒ!yÏáKÌaœ­¦›{€´¿…&¾´½¨b"¼?èssü&¹ûþ˜8þDPìhš£ªe­‚ƒÎkKØFZÆ}jÄcÏJ´"e;±RÎMRL‘J‘ÔÓpxïU¸ FiHÛÓŠA(îž=ªEš< ’1ëB²Am ÏB)ТùñôûÊOa\ËÔ›uüÇÞª/Ö°FÈùO ëZ±(òמ޵QÜLÍØšP[±>ÕlDÎ@ú┶NIÆ(¸¬($tjšÐ“s'<ô§Ð Îøõ£®fµ5—µ×PøéINÀ&hö4-ì1:sIïO­€ïJ[ÇÙo#qÂÒk "Ž†¸³Õ‰ýk¢µŠ¢Lkrr§æ©ê,ÌñÔÒ‰§C'Ãýz9­ð9Åh÷2Òcš@!SH¡.à1—"¹ÿÄ>Ó ÇP{Ñu³2¼°OOþ½YÓ#ÛŽåj÷ÐFàAK°Tí¢(AœÓ¼° 6†Î8”ð«ŸZZX¡F3ØÒ…ö¦]GÒœ¨08æ¥-DGj…Ðnãç¿4žÀg]äÝÊ}ÿ:€V:îj;¸y­”QåŽAÍ8®¬–)Lôþt›@=qZnH`Žø£ùз¿CÞ¬X.oSÚªK°#pŽ¾™¢¹Ziš ÿ ;f€=ºPÝÄp)Ê8¡ê€_ð¨¤5$´{j¶ 3i'ÒŸKÅ àŠZ«Ù ¶ ‚~è Ÿj׋XÓä^.†Rq.!“&F'¦T›½9ϧj‡¸…Ïéõ¥ÝÏjOpqÿ×¥œÌÓå°…Ç'·4£×4 QùŠQÐ{Ѿ±éÅœ™ôëX6YûKd“òþtÒjI$ ÷¬ëùD‘ì÷ÍiÐE5`*ecÚœDÉ•Îq¥H%Çö5¢¹#ƒäýiKêH¡aÅ·£¥óškQXõ¤$~t†ç¯557hqÒ‡°Ì©Žf”ó÷Jbv5ŠÔÐwñ/û¶W…ÆOœIh\‚xãúRUr±=9¦òj£¨Å'"®é ›ÜžËD˜TW6æøÒc#Ú’ÐuëTÁÚ'ëŠ(½€ïzU?>,±Ý›“rÁvÛÆ;àVäcl+Æp3Sº)h*?™팃ч5©|×p&zÖp•¤Êm˜žljŒ8ùuük©?ZÝÚä_AÖŠ[0BRb†!§¥cxsmzÒ‹Ô†955¯ÑñúV¢Lè(ýjà.9éNïC²Í-O ü9¥“W  aÅ*—éR1Õ sÖ­ˆpÅCx¹µcµ: áÓØõ4ì~Ui x¹ÈQ´ùs‘µªvc!6S/HyÏcŠpk¨s‰&Lz1§dÅbdÕµÏLGûc5aµ°_Ê­2d!lcŒŽçŽüS @Ä öúÑÏùXm_ð­s<‡)éa-Ícìx£°ëX5©¨c¿_jL{Õ5pïG56?¥%lN;ÿ*-aØT8ïøÖn¾Ij‡$™-#^Õ0ª½¸ë[j¸Ú=©4†…#zɸV›WŽ4n¦+Rå±ÏèÏ·W‹œ…uçƒZJÆbLzT¥t!¦“µ4¯¸Ä9ÅekÊNŸŸF¡-Dõ9ìŒu§ÂvÝÄ{nÅSòÑ‚1œö¥R}^~†žzZ:êNqJ:ÔÙþt£Ò€°Ž>SJ¼Š`çƒQ¸çV9óPÝñö{Rå(áÀÁ`GsKïš¡[ýéùê^HÁAƒÔRl˜¾†$Œàt5:0Do#æ_Ò«µ”.rcz \Ö :l'Õ~†¡m,s¶Vöª¿Q6(?+«c¹¨ÛOWî)ú¤ï¸†ù(ß(‘Ý5(¾Ô"}¦Aè 懮ƒý±zT¤’¬‘·U+Š‚iŒÄ`âšÐ.5ÈÇoÖ¤}ÍÔç´jÄ*¯"­À¸#"ª:ÍKp;w«]: ×DZ{ѧõ¨²A= Bîÿgð»=qŽ¾ÔºêVÀOõ4\‘Œør*[.d”㨖ţ‘ƒßšp+š4Ø’núÖ®þy­#©2a¸cî⑹jÚÐÆûA=:Ò‹¾€º}+[Cù–VÎ3ëD–ƒ¶¦®:sI­s²ÅÇQü©1úR»1ÅqUpBÖô£Ì=i:}i¤Æ>|Öf¬wêö±z|Ʀ×»j¹‘ZÖ’3"•Wd8ûËÖ¦MlT¦#Q¸œw=ë:ÁKø–1é“UN:Ž[¥Ù¨ÀÚÇé]±ªoB=DïïIPü€JCÀÈéMgz¡«¦ý:Qíž”-ÆÎ]N@4àq4GÆ9«ê#¥Oº^)ÀsŠ›ƒŽ9§T¾àÿ]œâžú‰QKŽ2i-Æ 8¤Pxâ¬ÐÔr 7TÞâ8ÐÌOŸJ¡œ/Y# Þœ}þµWk÷æ¶óZ‘ŸÝ/N‚”‘BŒŠ8•gÖ œ“Öò}~”=ÀB SLy ) B£Æ(0ç§&•ì!¦": â…´æ ïM1Šm!`7D¼ûsQ6›hØ°)¶O…›äÜ‹ëÔÓ[MâSǨªL›j5l%á•¿Jš+Y”ýÍÃÔ¤Á¢ì1Σ'úâ¤Ä˜û¬?à&·LÍ‘ì1ïÍ7žGµ&$9p1JW=:õ£qŒj‰øúÓ“íÖ§´8ŽäúFy¬Ûw1+œwäR¨ôæ³5$·é ÏJÑÜ3ýjàD“¸gœ'Ú¨‘TŽâž¼œb…°6” B]FÇ­G'üikqn*”Tw÷Mì5cgÃÈ;n¤ H’Ûýd€ÿw"´ã»^: ™ q#ÖŒöúTGF‘ÛúÑøõ¦ÕÁ ©žFp{Ô˜À¦š'­ã§jtê¥G'9úT›”´ìIgƒMe$`U$"39¤d<ç°¡ z“ô©á"šzÍ8@#Ö¦Ú¸é]ØÍ¢…–Do@EEöHÿ«¸ÁÅ•ÐC¦ÀÀàÈ?ÔSi»N#˜ÿÀ–«aÚÂ`~ò7§8¨^Öp>à>àÔ¶Á<2¯6ö¡£²»$%N8¨“.+SýÑü©ã¥fY-ªæ|w®ã9'óq%†8¥éT݉P~j­m ‰·4¥È™53Úã[—psŠ0qšÂìÐLséIÍ-hô˜¤#šihIŒÕ.À‡F>nµcûÝzéÿ»òÒh¯M_ßè+EzqY5©q!¸`˜©?)uªþ]ú”òuïÚª¸å¢<ýøQŽÆ»Ëv mõZÑ¢bIIÔ‘Ö€ô>ÔßSP÷¤r*)€häþUn »^0Ì= ­+ŸÝ©ÎH Õ-DŽŠÛ˜#?슛¥NÁ¸êp/¯­!=¨÷¡j1ÜqJ=…4Š_›cAL{P&"}Úlã1œsÅprñu/ûÔÚ¡¢K~%“þ¹Ö”y'°¢Cè8Žz ^‡ÜVVbœúÓâBNHâ˜@ÀqF§)j@ cÖ¡nIÀâ©.¢õ“ϧçMjŸˆ¥9â‡q ¸×·J2½hP(Ï8ÍOïúúÓD²ì?wµX$t´Ýæ©«ˆBø=)ŒÀ‚<ƒQ«Vc8™æU¹™ ‰ãÍ1§B„÷õ¥´°‘ÑØH­g#hèjØ#·÷¥³8fœ¿pRê$/®hìpôüh<õ¥¶ /S¿Jê0¦IJⵄN†›7ܪƒ¸½œµý)©Œ’ØþýÿÜ«±±1®#Ò‰Zà ÿ¥87¨¨¸·%…7€ØÂÕ•R£¥EûŒZ8zS¾šDí¸óÀ¤3ØU-F'cL'=Oµ®?­79éHÀ¤ý)õåÎG8«1ÏëÍR±,Ѓ•éÍOÑpHæºa±›EyG^*5ãÔ~4ž£DÈN~ñÇzyÆ:ŠÐCb “€sÖ•´}s“Uµ#6_CÅD´.;œû”áQn¥3CE½˜÷±üé¢þT¹ç®>µHWŒqÅñéM;˜Îr3šÙ€b%¦[j5¹&(ÇáYÙ\±:Rcÿ×HÅô¢Ö >Ÿ…&?Î)­F'~´uúSMl!’–ò±àô¬ÿ &,÷Ÿâ9¤3®Ó—ìqÉ5b9BÊ»¾^¹¬dµ4ŠÐ©¨HÆLŸ¼xÏÒ¬ø[gÙ]Cá¹´PKcñDdE ã8ö©¼?.Ý-SÍ…vqó¾ N®7'©²eµò˹Iån¡Fþ=éˆÁ×#QJ3¿…!ëÍ]î!‡ŠB>aB×Pg ¨¨MRé}5\å·aTž¶ÐèÇ:|—Ò´qϽ'äšz“·#56}@pc×4noZmöáÎNiD‡Ó4rŒUóÆ}©wŽ>Z:ˆ]ãÒ›#N)5`ÜÁïI+)BsM á.ÊýºbëÒ£õõéTÄIkÍÃûÄx«‘«銙 ^ß…H‰¸tàRJÀN ( SÕØ€ÔÉ'  æ`ýÞ3Ly7 /—’˜8ëÍ5b¸dçŠx\lcˆ?JaUî>¸¥}@O-}? O+Ðöª°c?Þ«¡Î8?JpHL»Àæ¦'ŠÞ u3d2sQK`½h{‚,¢…\Ε•Hè(èF08]ßFëÏ$‘éJ[DËþMQÕ¸Ó\z·?JR^è㹂~ðáÓŠÏÐÐÔÑ@Û)÷­@hD1GšR «V±!ŠN‚’Õ€©Ô{ÖÚ.@ô§-GÇHF{Ö.ÈÐzL”í¥ÀLRc‘@„qIZJH<Òbʺ£ùZeÃÞôš ~^›9/zº ÇWf˜¶AëÍXíY½ËØÃÕäÌ‘ÃÓ¾*Æ€Z;‰§"'?Z´îSz7ˆÛ‘·Fa´ö=*Ÿ…B½¼êȬUø$dö¤¾6½ãu• •!qH‚4–3½;h„ˆ­/zk@E#v4ܬ8½q6ëöÎóª<í#SD›z ÍŽ=zÔ$6î=zÓ“š„™#º J¡î8vâŽÞ´›îþÔ¼mÎ)ù6A9¥p­6o¸h`póŒ^L=¦çš¡¢[_øù ŽLdUÈyŒRz¡“ª—nx:AÒ¢ì‘NÓïCN÷5ߥ+ \LŠLdc¹ýi=¬ë‘“Kå¯`E-lYïŠM‡=i¤ ÚqÛ…OLUÜGýjž#ƒÇ©h&ZF#iå ¢}‰Ð†BsÓò¤rC‘Eõ‰Ç·¤Õ¶!§©út©µÆBzô¬ýhcOŽ\R›Òȸ˜Gï}E;¶:}+"µ54eͳ·3Vã¿ÓW!±ÝixÇ4œã¯4 ’: ¤…rUQ½F;ÖØp*dìÇ Ãqüé1ϽgröÓ½&\.&8¤4ÞÀ†‘ÒŒ~µ 6Ôõç­ôªhfWˆ¤Ù¦„yØùŠÓÓcÙmŽÃZ$K~áT:ŽÔäB‘a¤.¼k+êUÎ{Sÿ‡ÐUÕÿFÓ@âIÎN; Õ ‘LtÍgGkräG`¬¥‚0úU4»_ io,z}õÕóœT—Ìý@µ(¨ÚÁ(¶îÔ ýF<ôiØõé'½¿¹„ÄËooê#RN>µ ´ìIF±Æª>èéGz§n‚Œâ˜ü(W œ‡ˆ×Á?ÞOêk4rJÒäšÞlÃ"ú5miIë¨Ç zøP!{㘭° qN⧨ú1Ò–Ÿ5Ý„Ž=i¯ÈÏjMŽãWëšl£ä#¥>kè-Î&ìbúO­EگТ[_øû¾CZ6è Ô=@Óµ;½FÈúÒòN1Dt7iÆiqUp sRÇ1žÕîðzÒíM+ ÿ]&=ÿ{€˜ö£Ð rœžõ{ì"uè=éùÅZІ†18¤Vç ?Jk@$ Kœ ¥k]’'ÞïHÊ{ŸÎ“}†È™:Ö^»‘gŸïÿCYÉ•©ŠrXt¢’4¹±¤ŒYêÙ«üð§d@«Å(ªÓbG`zP'=¨Z5º–™@Ål2}*g©P sIøT"“SI]1 ïF(êqíIŽÝiÚ㸘Ï4˜ÏQÅ+¤?ˆylâõ|ŸÂ·ìÓ>ZCWvG %Y±€3K!ýÐlžpzÔ;ìQÏÝlŸQXœzTÒ>ù2: À«Ð»µƒO¢ù¬ªQÐ`X^ “ÉÔž"¡wGÓñA+X‡½ŽÛ;»æŒi´KaÎ)0 ‹ q˜ÿwµ]ì;·ŠWзv^¸¬nÕKVGSKÃÍóξù­áÛŠOq±Ôôh°1ÝyëIÜÒº@(àw¥y ¥¡+0§×Æ:óIyã­#ýÂ3NâØ⯆5 G=jyªZ [ÇÐõC[6‡ý”†LëŠPŠ:qŠÎÁaÇ~ž½éq“ô¤õz¸Å5VÐ,=#t§â¡€bƒÒ­lý)1߯¥€0'±)[qsô§ ïWº bdéŸåN-´V®õ$fzzúRŽÔÆ8: p=jº£§4~) ×Ç#­ckì6Û¨=I8Lš*&6rßJqéžÔ®Ê6´¼.ŸxÍ\üx§¾Ä‹ŸÎœ =DÇǾ)AÇoʪâ,Xü×=:JÖöéQ=Ê€‡´cž*.XŸ§ãF;4èb“·­JLBÆiãü)­Lf“;n4bê?¾×­c|ŠIü«¦±LÏ&Ø_Sp Ž* î Ü"¥hQÎÉ»Ï<òyéS§Cô¦ÝŠ2Tlá9b ô:V.¡5%~¼ÕGDC¹×«m850"„H9$ Òo[ n{R0&¨kÅ+ó[7¾?`㱧^åíâöUÆk¢ý)KFQžŸ{éT»ñœRTØBŠP94Æà{T»¦ k6>´ÀrxëEº€/4’ !éœSK[ÆjC”žàU^æ¨-¯ü}§EkÙsl¿SJHe‘žØŒàqPß@Ü#úS€ç¥M´@Á?ãOEÉç¥ `%ÇŒ{P˜ ´g<ŠM ŽµzX1ñÁ´›±4Ÿq‰±‡QM*æ‹iq@1ɧ*zÓ‹°‰”`c?¥# ž{t­â°úèê(ê&‡c(P ÎGµP¶ÓëHjúc`I¬=u³4ýœóYH¸C©"•ø•Ê7ì,¢Õ8íëL—¸Æ8œSLCÁúâÖ©\Ó—31=†+L Î[—#µ&1Ú³,1Hi$À1Å6©&‚ÂJZÜÀþ”c<*v¸Q;ÄÒ±èŠýk¯Ó7ú °u4šԯe<«ªÉ²={TY©a°ý÷áVmмˆƒø˜U}«C#F>fœ™íÆ+ 3äkãþºõªŠèvL Eòsš\· ÁwéHo_åL=ǵ6„ŽÅ)þ‹õ Ý}+œÕ«XE­!¶ê}zñ®˜žô¤ƒ åäÓÐá¨a¸îüÐy4'qužÜúÓ©'®ƒµ#6=éÜòyëïGøÐïЀÒ9Ÿ¥+;…Î;UãSb}*¡ëéøÕh’Üâê?ËŠØ°æÜwäÒ•˜Ùd×cc8©Ñ耜r:Sºv©zh~^9%ÀåIƒ$©í‚iÊèz0Ÿ*ÆޠӰ)_A úÒbž ÷œT]h»ØÛÎ)@ãÐõâ© ¶/NiŽô'blÆh £Õ­@p`x})øTŸrD9ìؤù³Ôc]‚C$/Œc¯½akŒ>Þ‹ÏËÏçJL¤ÌÄç=zÓ¤â6út¤3¢¶M¶ÑŽx_Z—olÓ 9ýzpõæš8u§SMÜEý,|Ò6?ÑÅDÝÙQØ1øÑŠÎI'çGáV™CHô¤57w˜âš@¦õz‡w£ëÚÆaèƒÍÔîç#«•Ïç]ž–¼¹ö¥'m=KêÍæl1£øóÁ¬fLΑ­Ô´gg3·µii1ù—ñÿ³É£í lp6z­Õ¿• ÆsÞAœUWžI.Òâ\3oàbª+©'w‰ÕE8®G­+ê6œ>”Þáplc­3½KÕâTΖÍÝ\­Ttb±.žÅuH¨#¯µu#‘NNÂ?•=~𤖂yëH*XÎŽù4ZÌb1è:S~´­fÐGãNöŸÒ‘‡ÊhÜg¬ø˜ƒ‘ÒªçëBCCà;n#?íVÍ‚æ/øÍØ ªŽüTŠ½bÝ Ž:õ©²U˦š»eX¯ÉÁÏÿZÞŽ·%¡qíKŽOåOW¨Ø»yã­;$ãNý(w\àûóN6q´ÔúŒyäžÞÔ`)Ù1ŠŠ\Sëa9Ëôät¦ãÞ›¸¥ÇKQ2D^ü{S±ÂªÂ0A¤ÇáëŠn7ao›5Îk-»S“ØS«zŽ%%?ÝǽZÓGÄhè8ÔéÔ‘p=iõ;°¸ ŒðNh{Ó5t Þõ{Õ rÒGõ¤Ö€%!T¤Æ‚›GQ±1žô‡¥;’'¦i³°ÈOe4Òh Ÿ §î$Ž^F?©®ÓM\@OLšR³zEsº–_RÜN(½™Eoùy~=kk@éŸ@U½ä+hyYg_BE2C„'Û4CbNêÅ÷YBÝrµg<š\º”)© â± Ô”öfkÈdÒgÙ®8Š/qöä.¡¸ÉíÅukÈâ›ÔcÁéOCó~4­a9É4‡ßG5„õô¤fíEî”vëÿפ¼Æ/N”¼Pû€œgÒšÿpý*„r:ØÿNS튤s“L¡bÿˆmÜÖî³·;&2òƒžj“Ö,À^OAQ›¨ã¶i¡ÜnÅçz6~´1 ³·­;a”Öˆ p0(Ú•ÂàF: |I‘¸þK]A’qŽ´b¥î1qÞ™#1š¤Ä3Nhò…¥-WaX—¥/~†ÄÄÇçÞôÀêN(ÜLy.?•rZ™ ©\I±ŸÂ’Ü¥±Yz rŒËžì*¯fëÇð¤Ú;¨¥¹!°zPPH&§aà¶Θ1f8ÆNjØ©Ý”€õ¤üi$1>´„QqˆhéKpsÞ‚:Ñm ïUuGò´»‡ãî~Tù„3@ˆG§Gî3ù×]d»m“=é=î4J"ŽsÏ'ÍÚK·cÉ$Ñwrºæé[ž^&op)ßÞýÓÊnT¥ÜËèÇ­BÃ÷dzƒN:¢ØèRoÒa´¦ªâ°™=:ÑžqÚÜå|@?ÒPÖiëškP@?÷ÅmÙ;©p½ û¤Q+Xeõ¹u2)Æœg2®”æ¹ígrƒà~”Çj¡nŸ~M9IÏ_Γwà~” úŠ,ÇoJ1ŸsMé¨*íµ*ìbãŠ\f¯ ï¡óÀü©¸£BÒ“hÆ;{SW`Є`Œ@éŒf‹Ù……ïÍ/zb`@ǽ<(\J õö®2FÜò09ÜăíBÔ®‚¨Æ9«v£|Õ“¡Ñ”‡¯ÿ^³°„ÏΑ 6I<{ИëGøÕÐÛä@ƒÑjN¾õ6»Ð? OÃ/Q‰Š1Ml%q) .6Š¦¬ ?ckç|¶PâPõØfõ’dÆ£ù×@òG ƒ#mÏÊ8ïI 3|GxözYhy–C…ǽ3þÈÓL H£’zæ´ŠØ \Ë+»}âs]ˆ¸Ó”ÿy‰¡|A-2ñD{50sà Çï×µ8ìAÑøNO–â3ýàtzÒl®Í)€/SÎiÓð§dõÃɸKÄò¯gOFÍ V&ŠÓÝú⺋ÝkõZÑìŒã¯jkHnr¬÷V]fÍþS.ÞŒ1Vc¸ŠOõr£Ø”˜ìIÈíJð¦„( ÷¥Îy¢éˆvxQÒ©Y®OÊ“8éJ÷—×Æ%\úñY§­5d4Æÿtçø‡ó­¼{YŠ…R84†Iý¨ â ñœzUèµ+7çÛþðÅfâ4ËI4.p’¡ú5K·¾¥k¡_nhÛëSm]´à¼ã¿ZzXh]½éñG““I±’cŠúŠ.…¤lš"œÑÚ©h £ÕwÐ`nÝKBB ~T´60EÜÜö©JŠ5À zt&¸÷½TC ñVô•-©(ëµsÍPüóô¤ý*\¬iÆÜÓ‚àŠVO9¡.£¯Ì(ØGK¨è)Üú ”µ-8¤ïWÖÀÄ'Þ“¶(I âRcÞ”n‡t%n„'ZÄ¿&oÛÅÆÔMØ÷È©w¸ÑÓéɺá=¹­Þ¹¦ ( â [ œ¨÷⧴I@.ÈÏéUÊ{"ŒÛD‡hÀº]9<«AþîhŽìLóG‰¢“¿?Ò¹®ÑÔÚð´›5)?}Géšë;óJZ•ÐB!©‹ƒ©æŽAäóT‡a‡¯ó\^°uIø984E+’Ê2`ÂÃ5½¤¸kÏL ¦› e•"Œ»° ü럿¿{·À8AÀ´•€¨TȦŽGJk@'Žòæ,lÀ‰È«Qëw©÷öKé‘Š¸\»ˆ"Ïï`eÏuæ­Ã«YH0' Ogâ—*è.GôÛK@Ø3øûÒ{R•‡Ðæõüä¼ÖQè)¡!ásß55áýð9þȧ¯Q‘ cµ;õh Ï>•$rMe&uöÎE –¢Õ/#2†ö**ÌzÔÃàB=A¬ÜSÜw-ǬÛ1ã‘sè3V£¾´% žÍÅKƒ¹w,FÉ1[ÜVcTËÝÜ ŽEö¥£›˜v£b[ŸZ- tÒ“Ö­JûŠÁŒR7$ZÄÇáF)î„÷¤< ÓHøQÏ¿4þ½c#¹!`~ØS\B«^ÞÔã ™'­^Зv¡!Æp•L“ŒJa¢É a–ÒœEZ cœŠu¸Ýsôù³Ië°6<âŽýiYŽâB() ? ¦Óê!úÒvë@'LñQª`(ŠÁ´Äþ$¸“¨L(>+K×éK™‰çZžXiVBì1Û<‹j3î!y«¬L7G˜{qZ—‘Çk¦4qˆ `u­)½»9¥&AÀ$¹ 1ï]¡?Ù­cOïÀu¥ÙMjq^06aÿºkíÔR†Æ}KúùzÄ'¹Wl(¨WAzgÒ›ò*Pþ´Ò1FÌ,4ž r~"Œ&¦c/¯¥RÜLÉa•"´´Ë˜àÓ·Hq´ôõªŸ{v÷o胠õ¨ Ö€bgqç½Ö€]Ür8ïG0 Þƒ’¸œÖ'‡Áyîn;<™§U¨ž’˜ŸÔÕÐÒ ûã ª>V œþÆfØ.¤ïúÖ–¤»¬%^Ø­c°ºœÍ¯îZ7P>C¸TÒN÷7^tœ“ÀÇjÍÊÎÆѶåC»Mã‘Ïë\û S‹ÐÁîMfþUôz8Íwá²õM1­…çh#­$„&i­÷©ëpê0úW3âhÈš)z‚6Эq3±¨KòçŒô«ØΩ¦ç4…qØæ“Ըⓔ 1z1E„8¤$ÐbL‚>eÇ›Ah²C>Cߎ”½‡Ò­°!²}ÆëœU›¹a9þÖ“c!¾1Nh$<:xÆx8¦µ@I|ñGz,´ŽFhç­#aÓµwélrþtfˆ¶Àp<ãVäŒâ› RPq‘éíR%ÝÄxÙ4ƒÛ9¤¢·l™5KÀ@iUÇûKÍXMbAÄ©÷SS87¨ù‰ÓY·#çŽD'¶3Š³¥dÇ™ö¼¤ãdR³Dâh¥Ç*>= X‰p¾¦³{X,?væ“BÑ Ö3uÖÙ§Íôι,a”v´ƒ@ÇŒ[_ô{‡ÏY¥hö Ø#Š°OÞ³z „tàP_Ž™¬€alŸO­hè£}Û–=^è ¼;Ôè˜Æç’0x¤ÍPM¥nÁa: CÛ¡¤$ö¤Ï5/P"¹“˵•ý¨øn-š|mݹéB±°,ÁŸZvÐLx9#EH¨O8¤4<¾”¥O§Jbųé@}³K‚O·4ÄñŠw8ô†2¹„žÙÍpCŽÔÞs×£a‹Œœ \ûñNÌ› »·éKÇž½((nÕÈ8tö§¬Ž‡)+©ëÃQuk ¹a5 Ää\±Ç÷¹« ­Þ¯_-ýÈÅC…ÇÌ•ãÝèï+Æ™‚áOE`ŒÎz –ÃnãJÜðã ÓŸ,7 Æi½l{qPÌr»HäÖ\ÀB uÚƒûF©>ÀFb> û×Г™XñØb©h¸Qr„ö¤©ÔBøSp=êž›œu¦àRÁ‡j(×a™¾ “ËÒ%ÇVãõ«š\^]”kì8l„ÑÕÛ©XP{UiÂÇCÇ8©Ñ”‹Úl~]’œ`·5K_“mŠÆúÖ­º·2£íMø¬–§Lv-ß.èÝzŒW™Þ'—w*ú1«Š±ÈÈ*Evú,¢]&ÏðÇÒ«tR/zÐO½@ '¥ rI4h´+UÕbÓÐŽSÑæ¹s,׎òÊYˆì; ij"»Æ›æ~•[1óyÆiVQÿ꣨ܤdâªyÉô掠XÏ ùði o×oåD€gz;PÀ3EÎh¤Þ¢#n=8¥^{t¦4pG^*K®mm¢àÒ`W<Òûç¥ê=8ô§«0 i…Ç œõõ¸Áåx¥pÔOÆõ§)Œœ‚?:i€ìm9àŠFb=}±N÷@('q#éIÀ}±IdÖšFN})€å½iXs€qHhÛÍ ‚)ŠÂ…à’(ÛƒÆ9÷é@ îh=±‘@ œ â—$Œvõ¢â'»%4x—?zBsëÒ²Çß?J›Ðqû´ûQûsßµ QRI|²8ÇÜiëyr¤bRqëÍW*¸\”jsŽPþ§®ªÞ‹ò5›˜î‰F§ ÆU—õ®ƒ@‘&´i£9RxↀÕüé8Í(8ÇjLÞ„ÔÓMì!­&9Å+ØëG­5¨#ÄŒYmmÆ?xüZݳZûŠ‰;!³£)¾0…ŠñÕzÖNµ=ýœHI.B“ùÑC¡ºGEì0+Ÿ×¤ß} =n"µè(•ã?)¨‹r žçŽ¶:–ÆÐê§józ3¨þã?­\t9Ôý+­ðÌ›´­§’§J¦4kæž0j/  $zÖN±¬%”f4ùå#€JÈ<’\JÒHä³’z –+ƒâ<óÞ­'ÔWe—P­4ùMØ­€Óoºù4†FN8¦w0Ån:S[x›œçó§‰A>ƒÛŠÃC¼ÀÃ=r3N&6þèi€›S0úŠC=9ô56B2²žGzf= 0é¡xAMl4!üÿ¥>ošÎQž´ €=)ÀRµ„ÇÅ(¦¬$ö£õ¦ÆEÅKØ9 ÷©WUÎAϨ ]EÞQõ§ ”þ$àJvï:#œ:sNHûÀþ4 ’£,¡Elô=Å3ž…Ççr`àGÊ0ySHÉ#Ö—ŒÿJl£9èzM§wò¡ v)qœÐ&O¨º}¢úäÖb}ö¨¶¥¡Îp‡žÕ%¸Ä)Î8¡ ’gŠLõ§wqO8ê)¤œõÅ;›ºæ»o .Í,Œg'õ4;Scñ uÍeªeˆ4úU5¦…=ƒµ&hW±#i)=@3ï@úÑt=™‡©~û_¶‹?pn?­túzn¸ŒzsI­4WfÛ7.ÅRÞÉäUK•Ý¬ÚžÀQî7±§Ÿ˜ åoßÍÕ§aÑ~_Ö´“²Š˜}*"ª_æç8¬Ö›1ØÒ¹Ýëñ\[/Ñÿ¼93•˜~õÐøRO’x‰þ,ÿ*§°-΀ž1HÇŽ*ÀbëzÒÙ výrŸ<ò’Ç«¨.¢Žjô¦ã5LC{ÒÊ…  AϽ b>é¤öþ{q¸„Q˜XÑíÏ÷M ÉÏÉ.ßfß³Ê Û‡ÿtÕ-ŒùŠvGÔR¬¸çûQÔyÃ¥3ÀäÖmètÇcNä»q^/÷qH;qøÕZîç+Øåÿkøj]šƒ'÷–¬Hê …5ƒ­ëkk{c™{žÂ£[œÐ #s¸±Éc×4æ=—V‰¸Ð9Î)~œÐ_J1Š03F?=7~‚“ü*Fy挑ßì2E¸‘Þ${Òùˆßë"_¨â†LQ¿)¹IõP¶’F8=Å4ôa-”pÏœzsN&(Çaõ<Ð4†4ý”vÍFÒ»ŒÀíSÔãÊ–^l“Ô1¢àD£õ©1Š!Þ—Ÿ¥0r0•)â“„éF8Å4ŽUvç­GϯãKQ£·éNð˜öÇÖŽ§š‡®iϵƒùR÷ⵧÇå@õª½Àp‘×£x¸“»~”€‘nØ@úÒý¥åH=)lµ¬“ç[Œp"Ÿãñ ¶î$Ü¡¤U”N=(±,;uÅ&NqÚ…`'©þsFãË‘ƒú×ye{eötE½€²ŒÞ2)7aÅj]YQ°UÐÿÀ©ù9úÖI”¸þ´„ûU] Q3Iøši 'Ž½(Í°gŽM.ì'°ÍZ…Ìm y—73╱ù×e¥/îݽMLݘ÷4AIT f #include #include #include using namespace std; using namespace dai; int main() { // This example program illustrates how to learn the // parameters of a Bayesian network from a sample of // the sprinkler network discussed at // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html // // The factor graph file (sprinkler.fg) has to be generated first // by running example_sprinkler, and the data sample file // (sprinkler.tab) by running example_sprinkler_gibbs // Read the factorgraph from the file FactorGraph SprinklerNetwork; SprinklerNetwork.ReadFromFile( "sprinkler.fg" ); // Prepare junction-tree object for doing exact inference for E-step PropertySet infprops; infprops.set( "verbose", (size_t)1 ); infprops.set( "updates", string("HUGIN") ); InfAlg* inf = newInfAlg( "JTREE", SprinklerNetwork, infprops ); inf->init(); // Read sample from file Evidence e; ifstream estream( "sprinkler.tab" ); e.addEvidenceTabFile( estream, SprinklerNetwork ); cout << "Number of samples: " << e.nrSamples() << endl; // Read EM specification ifstream emstream( "sprinkler.em" ); EMAlg em(e, *inf, emstream); // Iterate EM until convergence while( !em.hasSatisfiedTermConditions() ) { Real l = em.iterate(); cout << "Iteration " << em.Iterations() << " likelihood: " << l <fg(); // Clean up delete inf; return 0; } libDAI-0.2.7/examples/example_sprinkler.png0000644000263000017630000004654011433220723017536 0ustar jorismkyb‰PNG  IHDRý¹À¯ObKGDÿÿÿ ½§“tIMEÙ3 â®[– IDATxœìÝw\Våÿ?ð×-S¶ HܲT† (j  ¤¸b’«D±ü˜ei¹*Wå Ó´\ ÓD©ˆÌPP”åÀT† ±‡ÀÍõûÃ÷WDqàpÃûùxðx|8ãº^7ãÍ9ç:×%`Œ1B!¤ÓëÆwB!„´*ú„BHAEŸBé"¨èB!]}B!¤‹ä;!¤kËÊÊÂÕ«W…ÔÔT<|øyyy())((( W¯^2dtuuajj KKK¨««óœœñ# Wö!í-33'Ož„nݺ999AGGC† AïÞ½!//(--ÅóçÏñðáC¤¤¤ >>eee044„³³3æÏŸ¾}ûòü‰Tô !í&99Û¶mƒzöì‰Ù³gÃÉÉ fff––nR•••ˆŠŠÂ™3gpêÔ)`þüùøâ‹/ ««ÛÆŸ€ñFEŸÒæ °aÃüòË/ÐÕÕźuë0gÎHIIµªÝªª*œ:u Û¶mCZZÜÜÜ°e˨¨¨p”œÎ…Š>!¤MÃÕÕB¡»ví‚‹‹ ºuãv qMM Nž<‰µk×BJJ 'Ož„••§}ÒÐè}BH›`ŒaÓ¦M°³³ƒ¥¥%RSSñÁp^ð [·nX¸p!RSSñÞ{ïÁÆÆ[¶l]ÓRÞ'„pN(bÙ²eðòò¡C‡°dÉ’vé·Gðòò„ àîîŽÇãСCh—þ éè¨èB8ÅÃÂ… áçç‡ÀÀ@XZZ¶{†eË–aèС˜9s&***pòäI‚vÏAHGC·÷ !œrww‡¿¿?‚ƒƒy)øµ&Nœˆàà`œ?Ÿ}öo9éHh !„3'OžÄ’%KØaÒ]¾|vvvøý÷ß1þ|¾ãÂ+*ú„N¤¥¥ÁØØ»víÂòåËùŽS‡‡‡Ö­[‡›7oBKK‹ï8„ð†Š>!¤Õc˜8q"z÷î?þøƒï8oäàà€¢¢"„„„ð…ÞÐ3}BH«ÕN§ëááÁw”ýòË/ˆ‹‹ÃéÓ§ùŽBoèJŸÒ*•••ÐÔÔÄgŸ}†U«Vñ§Q?ýôöïß´´´VÏHˆ8¢+}BH«œÄÀùŽÓ$ééé:t(¢££1zôh¾ãÒ®hF>Ò¦®_¿Ž}ûöñClXXXtøçâ¯òôôÄرc9-ø~~~ððð@\\ !++ èééáܹs­nðàÁ077‡··7}ÒåÐí}Ò¦?~ ___¾cˆ___ÄÄÄð£YBCCakkËY{ÀôéÓ¡¢¢‚ÈÈHTTT ==6l@pp0gýØÚÚÒ«{¤K¢Ûû¤My{{cþüù´ÚYÔÎçååÅs’¦ÉÌÌ„††ÂÃÃaaaÁI›ýû÷ÇÓ§OQTTEEÅ:ûlll8+Ô×®]Ä  555NÚ$DЕ>!¤E†††œµ™›› HMM­·Ë+óÚÌñññœµIˆ8 ¢Oi‘ÔÔTôë× œµijj °··‡ªªª8kûUJJJèÛ·ïÿ¸ ¤3£¢Oi‘ÿý à´Í@]]ÙÙÙpvv†šš-Z„ððpNû€âßÿå¼]B:2*ú„)))©÷ܽµôõõ‘””„­[·BSSùùù8zô(ÆiÓ¦¡¬¬Œ³¾Q\\ÌY{„ˆ*ú„)//‡œœçíöèÑ6lÀ½{÷‡Å‹C àÂ… X»v-gýÈÉÉqúG! >!¤E$%%QYYÙ¦}˜˜˜àÈ‘#8pàpºXNUUÍ¿Oº*ú„QPP@QQ§mNœ8ñÛ.\(--嬯ÂÂBÎOÒÑQÑ'„´ˆºººè;®ÄÇÇ£ºººÞöxyåÏ•œœ¨««sÖ!…á%„¼•P(DZZ€øøx$$$   ÕÕÕ”äæWI~~>¬¬¬°aÃŒ3’’’ˆÅÊ•+!--mÛ¶qÒOUU>|mmmNÚ#D\PÑ'„ÔQVV†ÄÄÄ:Å=11eee’’‚žž add„;wâÞ½{ÐÕÕå¤ï}ûö!$$Ë–-CVVjjj ªªŠqãÆáøñã022⤟´´4TWWC__Ÿ“öTô é¢^¼xääd$''#11ÉÉɸsçÒÓÓ! ¡¤¤„‘#GbôèÑX¶l a``iii@MM ~ûí7\»v³¢ïîîwwwNÚjLXXúôéÃYnBÄ}B:¹²²2Ü»w)))uŠûƒ  !-- mmmèëëãƒ>]É2 Áv»uëKKKüý÷ßøè£ÚñµÞåË—aeeÕèç#¤3¢¢OH'PRR‚û÷ï¿ñ+## %%---èëëÃÙÙzzz000€¦¦f‹_]sttÄ’%KPZZ yyy.?R›)..Æ¥K—pìØ1¾£Òî¨è"ŠŠŠðôéS}út|ôÑG8{ö,,XÀiÛmåܹs’’‚½½=ßQiwTôI‡±wï^ìرYYY¢m’’’èÝ»7ÌÍͱvíZ˜››7©­û÷ïcݺu8sæ ÀÏψ‹‹Caa!dee¡¡¡===œ;wNtž@ ¨· paa!Ž9ܹsèÖ­zöì‰þýûcäÈ‘8|ø0€—W¾;wîÄ!CšýùkjjžžŽM›6áñãÇÈÌÌÄ“'OðäÉ“:ÓÅÊÉÉaàÀèß¿? 0cÆ Qa2ddddšÝwKÉÊÊbñâÅøùçŸÅ¦èÿüóÏXºti»þœé0!mÈËË‹5÷ŸÑ9¥¥¥,,,Œéêê2 øÖóÏž=Ë´´´ØÝ»wcŒyxx0löìÙ,%%…UUU±œœvâÄ &''W¯ïWݼy“õëש««³_~ù…=zôˆUVV²ââbvãÆ ¶}ûvÖ«W/ÑñwîÜaÚÚÚìüùóÍúÌŒ1æìì̤¥¥™žž³µµe~ø!Û¸q#ûõ×_ÙÅ‹Ybb"ËÏÏov»m-33“ÉÊʲ¾£¼Õ¥K—X÷îÝYVVßQá}Ò¦Z[ôkEDD0ÌÔÔ´Ñsƒƒƒ™”” mëׯÀŠŠŠêomm]¯ïZLCCƒ©¨¨°ôôôû´µµ­ó}xx8“’’jvtvvfÎÎÎÍ:§£X³f 366fÕÕÕ|GiPuu5344dëÖ­ã; !¼¡ùˆX¨‰-!!¡Ác***àêê kkkXXXˆ¶×Î÷¦µÓCBBlïàÁƒÈÈÈÀ'Ÿ|‚Aƒ5x\PPPï-,,`mm WWWTTT4x^g²qãF<{ö û÷ïç;JƒöìÙƒ¼¼<¬_¿žï(„ð†Š> µS³6öÖËË ™™™prrª³ÝÔÔ`ooTUU5©OÀÔ©S›×ÉÉ ðññiö¹âHQQ{öìÁºuëpóæM¾ãÔsãÆ |õÕWسgøŽCo¨è±pýúuht ß… ï¾ûn퀺º:²³³áìì 555,Z´áááö™œœ ÐÒÒjvÞÚ;Í>W\9::bÁ‚˜={6çsò·Fnn.œœœàêêŠY³fñ‡^QÑ'Zyy9BBBðñÇCVV›7onðØÛ·oúõëWg»¾¾>’’’°uëVhjj"??GÅøñã1mÚ´×T/,,€]jhhnݺÕìsÅÙÞ½{!//©S§Š~~|*,,ÄäÉ“Ñ»woìÙ³‡ï8„ðŽŠ>é°àââ‚Q£F!::Zt«þMž={àÍEºGØ°aîÝ»‡¸¸8,^¼.\ÀÚµkßØ^m;-YεvÉÖÚ÷ç» 999„††â¿ÿþƒþûï?Þ²ÔfÈÍÍÅ™3gн{wÞ²ÒQPÑ'c B¡Ïž=ƒ¯¯/FŽÙèñµƒæ޶⛉‰ Ž9‚NŸ>ýÆãttt)))Í.š§¼¼¼Ù犻>}ú 88¹¹¹7nÒÓÓÛ=Czz:Ƈœœ,Z´¨Á;:„t%TôI§Q{%' ëlŸ8qâ_¸p!€†¯ä§OŸu&ïy“™3gÖÛV;X°«^]<ׯ_‡œœŒñ×_µ[ßgÎœ±±1óçÏ#!!¡ÑG9„tTôI§¡¦¦à唵¯ŠþÕƒüß »×¹¹¹aÀ€Ø¿¿hPß›¼éUÀÚ êêêM ß ©©©!<<ÎÎΘ9s&æÍ›Wg¶E®effbîܹprr‚‹‹ ®]»555"44” ?! ¢O:‘#Fž>}Zg{~~>¬¬¬Œ’’TTTàÚµkpvv†´´4¶mÛöÆö”””€>}ú`üøñ¢÷ö…B!òóóGGG>÷ï߇¬¬l“Ι?>€—“ uf¥¥¥8vìNœ8ØØX¨ªªÂÒÒfffÐÑÑÁàÁƒÑ§OÑÛ%%%ÈÍÍEzz:RRR…«W¯"''¦¦¦X°`\]]›¼´oBB¬­­ahh???ÈÉɵåÇ%¤C¡¢OÚT{}ÆÔ©SÞèë} á¢èGGGcüøñ€M“Ïë*EÿU÷îÝCpp0._¾Œ˜˜ddd4z¼††ÌÌÌ`ee[[[hjj¶¨_*ü¤«¢¥uI§bkk ooo¸ººâܹs¢×îÚKrr2\]]qúôéfü®JKK ZZZX±b€— ÓÓÓ‘››‹’’/çKèÓ§† "šÿ µjoõ[[[cÚ´iTøI—AEŸt:ŽŽŽ9r$¾üòKœ9s¦]ûþú므¡C‡¶k¿…’’R» ~¤ÂOº"ÈG:%--­üÖÞÚ?sæ |1BƒûHWCEŸÒ¥Qá'] }BH—G…ŸtTô !TøI×@EŸBþ?*ü¤³£Ñû„ò ÕOZêÙ³gˆEjj*RSSñüùs”””   òòò——G=0tèPèèè`øðáÐ×ׇ@ h·ŒTô !ä5TøISÔN}öìYüý÷ßHJJ‚@ À€ ­­Þ½{CUUÊÊÊ(--Eii) ðçŸâþýûxñâ…hFJ;;;888ˆf¢l+Tô !ä ¨ð“†äææâÀøý÷ßñøñc˜ššÂÉÉ VVV5jT“þ…B¤¦¦âÊ•+ Åòå˱bŠ̘1kÖ¬‘‘Q›d§gú„ÒzÆO^õüùsüïÿÃàÁƒááá>ø©©©ˆŽŽÆ¦M›0~üø&ÿa(!!===¬X±çÎCVVvïÞ””ãý÷߯·x¨èBH#¨ð“šš>|:::8uê¾ýö[!„¼þ®+;;ÖÖÖpss]Ùúé§mú¨ÇÎÎááá8vìþúë/èééáÊ•+œ´MEŸBš€ ×síÚ5áéÓ§ˆÅO?ýÄÙ¢Oo#°`Á$''cܸq°±±Áwß}×ê©Â©èBHQáï:Îœ9[[[¼÷Þ{ˆ‹‹k³uo£¢¢‚?þøûöíÖ-[°téR…·GEŸBš çwôèQÌ;Ÿ~ú)¼½½¡¤¤Äw$¸¹¹áâÅ‹øã?0{öì~ze´‹Ù³g·iû••mÓ>Úš¯¯/œùŽAš€^çë¼üüü°téRlß¾Ÿ}ößqê˜8q"®\¹|ôÑG8|øp³'ö¡+}Ò¦ ''§6í#;;bÅåääSSS¾c&¢+þÎ'..óæÍÃçŸÞá ~-ÂÇÇ›6mjöùÖÚQ„ðlòäÉxñâg£[ iŽ„„X[[ÃÐЮøÅXAAŒŒŒ`ccƒ_ý•ï8oåççÂÚÚºÉçQÑ'b-)) 8wî¦OŸÎwÒEQᎎŽxøð!"##ÅæQáúõëñÛo¿!11}úôiÒ9Tô‰X[¶l®\¹‚ÔÔTtëFO«¨ð‹/Ì›77nÜàl²ö  1aÂhkkã÷ßoÒ9ô[’ˆ­çÏŸÃÓÓ«V­¢‚OxGÏøÅSyy9V­Z…o¾ùF¬ >ðr*ß#GŽÀËË M:‡~S±uðàAÈÈÈàÃ?ä; !¨ð‹£Ý»wCZZŸ~ú)ßQZDGGŸ|ò >ýôÓ&MÜCEŸˆ¥ÊÊJ8pK–,ió¥( i*ü⣤¤»wïÆW_})))¾ã´ØÚµk‘””„‹/¾õX*úD,:u ¹¹¹pwwç; !õPá¿þú+Ä~~Œ>}ú`Ù²eøþûïßz, ä#bÉØØZZZ8}ú4ßQi îëØ´µµ±páB¬_¿žï(­–’’]]]$$$`äÈ‘ GWúDì\½zñññX½z5ßQi]ñw\QQQxðà\\\øŽÂ ˜ššÂÓÓ³Ñã¨è±³oß>˜™™ÁÌÌŒï(„¼þŽÉÇÇæææ8p ßQ83wî\øøø4z ͽOÄÊãÇqáÂxyyñ…t2ûöíÃõë×Û¬}ccc„……ÁÈȨÑÛ¯ä¥U«VÁ¢ÍÚ¿|ù2[ÕFAAF{÷îTUU1yòd?~ü­çN:±±±ÈÍÍ…¶¶6âââZ½lïĉ±zõj$''CWW÷ÇЕ>+{÷îEß¾}1kÖ,¾£N&&&¾¾¾mÖ¾ŠŠ ,--¡§§×f}t¾¾¾xüøq›µŸ»wïÂÊʪUí¨¨¨ -- Æ ðò‰× ¾§§':Tg»¿¿?ÂÃá««‹ÔÔÔV|000€ªª*._¾Üà1t¥OÄF~~>~ýõWlܸ’’ôO—pÏÙÙ™î"uÍ]9®¹âââ 0jÔ(NÚ›>}:vîÜ ???èëë×Ù¸té>úè£:ûΟ?N2}¦ØØX¬X±âÇЕ>””¬÷!„4Grr2ú÷ïÏÙÛ3fÌðrœWÕÔÔàÆèÙ³'._¾Œêêê:ûÏŸ?Ïù]KÑã†7¡¢OÄByy9öíÛ777NnƒBº®û÷ï‹nÉsÁÌÌ êêêˆENNŽhû?ÿü#Z¹¯¨¨‘‘‘¢}999ÈÉÉ‘‘g9@KK ))) OÄÂï¿ÿŽ’’¬ZµŠï(„1—ÝäUéšB ÀÞÞ555¸pá‚h{`` &OžŒÉ“'‚‚‚DûüýýEw¸¤¦¦†üüüzwjQÑ'^uu5~úé',\¸jjj|Ç!„ˆ¹’’())qÚæ›nñ‰Š¾@ À¥K—DûüüüÚd@ríÐâââ7î§ÑP¤Ã«É»f;£B:ŠŠ Î×ì˜8q"Šòòr”••¡ººZt¡2räHÄÇÇ#77 HJJj“¹Fdee¼,ú=zô¨·Ÿ®ôI‡Æî]»0kÖ,hjjò‡Ò HHHp>I’ŒŒ &OžŒ²²2„††"((¶¶¶¢ývvv`Œ!((¡¡¡˜4iR›¼¥  ü_ñ}Ò¡#>>ëÖ­ã; !¤“PRRBII çí¾z‹¿öy~­Úÿ}éÒ¥6µ_«¨¨ðLEŸthÛ·o‡­­-ç#\ !]WÏž=EÅ‘KS¦L¤¤$üýýsssѾ1cÆ@YYÁÁÁˆ‰‰Áøñã9ïþûï?ÈÈÈ {÷îoÜOÏôI‡‹«W¯"44”ï(„1–˜˜DEE!** %%%¨¬¬ä¼L˜0ÿý7ÆŽ[g1IIILœ8gÏžÅôéÓ!!!ÁyÿððáChii5¸Ÿ®ôI‡µcÇŒ5 'Nä; !DŒ¤¤¤àðáÃøàƒ0tèP¼óÎ;˜5k ­­ KKK¤¥¥‰žs©öÿ«·ökÙÙÙ@›N#ž––Öhѧ+}Ò!¥¥¥á¯¿þ©S§øŽBéÀª««qëÖ-DDDàÚµkGNN`nnŽ… b̘1x÷Ýw¡¬¬ ¸sç~üñG¤¥¥5¸0MK­\¹+W®|ã¾%K–`É’%œö÷º[·naÎœ9 O:¤]»vaÈ!œÎKMÅÅňŠŠBDD"##ƒââbôìÙøüóÏ1nÜ87¸F‡¾¾¾ha®‹>Ÿ²³³‘œœ KKË¡¢O:œÌÌLœ8q?ÿü3ºu£'P„tU%%%¸uënÞ¼)úº{÷.„B!4551vìXüðÃ;v,ôôôšü œ@ €¥¥%®\¹ÒàÂ4âèòåË““ƒ©©iƒÇc¬3òVkÖ¬ÒÓÓ!##ÃwÒEÌŸ?h•½@ @CCYYY¨©©AÏž=abb###˜™™ÁÜÜêêê­êãôéÓX²d ²³³!//ÏQr~999¡[·n8}útƒÇÐeéPòòòð믿bÍš5TðI‡¶wï^ôíÛ@ô%%%%4Õä¶îß¿kkkhkk‹ÚRSSÃÂ… ›tþÔ©S¡ªª @€aÆ¡¸¸¸ÞU¯ŸŸ&Mš„^½zARR 6lfÎœÙìÏ) -- 555Lš4 üñG½óñðáÃ&ÿ ^÷î»ïâÌ™3HOOG^^‚ƒƒ±cÇÌœ9³Õ€hý¹sçZÝVGPPP€ .ÀÅÅ¥ñ!ÈÆYÏž=Yqq1ßQHãììÌœ›}Vû«´´´”………1]]]&!!ÁßzþÙ³g™––»{÷.cŒ±aÆ1ìÎ;õŽ=yò$Àÿüs€}ÿý÷ò͘1£Þ¾;v° 6ÔÉU«_¿~ +**ªwžµµu£_mïM׉©©© ÓÐШ·/<<œIII±&õñj_íQôïß¿Ï$%%YLLL›÷Õ–ªªªØàÁƒÙ?þøÖcéö>é0:„ÊÊJ¸»»ó…V111$$$4xLEE\]]amm Ñö7­Ö555¸qãzöì‰Ë—/×[:µ±©]sss©©©õö…„„4á5lÈ!uúx•……¬­­áêꊊŠŠVõÓ†Š9sæàÛo¿å;J«xzz¢¤¤}ôÑ[¥¢O:„/^àÇIJeËЫW/¾ãÒ*µ¹±q)^^^ÈÌÌ„““SífffPWWGll,rrrDÛÿùçÁÆÆEEEˆŒŒíËÉÉANNNƒÓU׎涷·‡ªªªZüÙ^—–– öíää„ŒŒ øøøpÖ'—¶nÝŠ±ù³¸¸6lÀæÍ››4 ‘Š>éŽ?Ž¼¼—t ׯ_€:s¯¿îÂ… ^X{•@ €½½=jjjDÇ-àR;Ó[PPhŸ¿¿¿èÁ›8pêêêÈÎΆ³³3ÔÔÔ°hÑ"„‡‡7ÿÃýeeeˆŠŠÂ¢E‹ ##ƒ;w¾ñ¸Ú»-î«- <_~ù%V®\‰òòr¾ã4Û7ß|555,[¶¬i'´ÃãBUÚ@T IDATUUÅ455ÙÒ¥KùŽBº0.žé—••±àà`6hÐ &++Ë¢££^í«=‹>c/&ÒÒÒíÞoK=~ü˜õîÝ›mÚ´©YçÑí}Â+ƶoß'''hjjò‡cŒA(âÙ³gðõõÅÈ‘#=¾v`Û›¦Š•‘‘ÁäÉ“QVV†ÐÐPÁÖÖV´ßÎÎŒ1!44“&MjòltÀË[îGŽÁ ÑÉ\Ò·o_ìß¿±±±Ø´iSƒÇIII@‡¿unbb‚~ø‹-ÂåË—ùŽÓ¨ÂÂBL™2#FŒÀ† šu.}«€€$&&bݺu|G!¤]Õ®wÞÐJo¯Žâ¯}ž_«ö_ºt©ÑQûµZ©²vòŸÒÒÒæ…ÿÿ\\\0sæLlß¾]4ŽáuµƒZß½#qwwÇ¢E‹0kÖ¬Fß¼àSii)¦L™ÆN:Õì%z©è^mÛ¶ ï¿ÿþ[¯ŠélÔÔÔEEEoÜ?eÊHJJÂßß111uŽ3ÊÊÊFLL Æßh_ñññõ^ñ€ø¿Áv-qðàAôèÑ ,@aaa½ýµŸ‹YôÚÃþýûaccKKK„……ñ§Ž¼¼uêÔ·æì(¤¤¤püøq¸»»cîܹpwwçur¡S§NaÔ¨QPVVÆõë×1hР–7Öƒ y«„„&˜¿¿?ßQaŒµ|ô~K•——³¾}û2{{û6i¿¥¿Þ³²²Ø;ï¼ÃYŽ©S§2 V^^ÞäsÀÃèý†œ={–©¨¨0víÚµví;33“Í›7 ¶zõê·Î«ßt¥Ox±sçNàý÷ßç; !¼••ÅÑ£GqéÒ%ÄÄÄðGÄßßœ´   =z²²²œ´ÙÞfÎœ‰øøxôë×&LÀÂ… ‘žžÞ¦}–––b×®]ÐÕÕETT.\¸€Ÿ~úIô&DkPÑ'íîÑ£Gøã?°víÚf½fDHgckk ooo¸ºº"%%…ï8€¿þú«Î3þ–JNN†««+NŸ> ’ñgРA „¯¯/""" ­­ WWWܺu‹Ó~rrrðý÷ßcðàÁؼy3ÜÝÝ‘””„)S¦p× w i–•+W²4:¡!í­½oï¿*--988pÚ&ß¿ÞØýû÷[t.:Ðíý×UUU±“'O2}}}€ >œíÚµ‹Ý¾}»ÞIM‘••Å<==ÙÔ©S™””SVVf_}õËÉÉiƒôŒ cŒ»?!iÜóçÏ1`ÀìرƒVÓ#Êüùó¼\‡ðK ÀËË ÎÎÎ|GiTLL <==ñçŸ"++ ªªª5jttt ­­Þ½{CYYJJJ(--EII ‘––†´´4$&&")) rrr°±±Áüùó1mÚ´Fjj­úSAÒ†öíÛyyy,Z´ˆï(„Ò*¦¦¦055Åþýû‘œœŒ+W® 668zô(òóóë###MMM 6 NNN°²²‚™™¤¥¥Û%3}ÒnJJJàááww÷&-I!âBWWºººuæ* …(**Baa!äå塨¨Èû€F*ú¤Ý9r/^¼ÀÊ•+ùŽB!mNBB=zô@=øŽ"BEŸ´Hí_° ¬¬Œnݤ²²»wïÆ¢E‹Ð»wïöˆH!ä5TôI£c¸}û6®^½Š¨¨(¤¥¥!55eeeuŽ“——‡¶¶6´µµann+++ˆ^É;uê233ñÙgŸññ1!„€Š>i@bb"Ž= ooo<{ö }ûö…™™&OžŒU«VAQQÊÊÊ^.óX\\ŒÔÔT¤¥¥aÇŽøôÓO¡¡¡Ù³gãÃ?ıcÇ0oÞ¼:ÓyBi_TôIaaaøöÛo ¸»»ÃÑÑÆ kV;)))ðõõ…··7vïÞ Ìž=»RBi š‘?~Œ™3gâ½÷ÞƒP(DHH’““±~ýúf|ÐÑÑÁ×_ääd„„„ ²²öööptt­ºE!¤}QÑ'8vìôõõ‘””„\¾|ÖÖÖœµomm«W¯âÒ¥K¸uëôõõiBáý.¬²²‹/Æ¢E‹àææ†ÄÄDN‹ýë&Mš„;wîàã?Æ‚ °téRTUUµY„Bê¢gú]Tii)œœœ ÿv[íNFF;wîÄ„ àââ‚ŒŒ øúúÒd=„ÒèJ¿ ª¬¬Ä´iÓ€°°0^–·2e €iÓ¦¡²²²Ý3BHWCE¿‹aŒaÎœ9HMMŵk×0|øpÞ²Œ1×®]ÃÝ»wñÁ€Ö~"„¶E·÷»˜mÛ¶áÊ•+‡¦¦&ßq ©©‰Œ7;wîÄ_|Áw$Ò…y{{wÈq&/^¼hÓ•×H×AE¿ ‰ŒŒÄÆñçŸòz…ÿºáÇãèÑ£˜3g&L˜333¾#‘.ÈÔÔ´Cü§OŸ"66S¦Lé2…ßÉɉ&òj#F÷T»„ªª*ÁÆÆ»wïæ;έZµ aaa¸qã$%éïQBc022‚––|}}ùŽC:z¦ßEìÛ·eeeøî»ïøŽÒ íÛ·£  ûöíã; !‚ŸŸnß¾¯¿þšï(¤“ +ý.   Ä‘#GàääÄwœF>}ü1ÒÓÓ¡¢¢ÂwBxÃûﾋþýûãܹs|Ç!]éwû÷†øŽòVNNNPSSÃøŽB¯póæM|óÍ7|G!]éwr•••èׯ¾ûî;,]º”ï8MrðàA|óÍ7ÈÈÈ€””ßqáÅèÑ£¡®®???¾£N„®ô;¹ÀÀ@”””`Îœ9|Gi²¹s碨¨—.]â; !¼¸xñ"þùçºÊ'œ£+ýNnöìÙ`Œq6ò·°°GŽ¿¿?îܹƒ‚‚tëÖ ={öDÿþý1räH>|¸Õý888@ZZ>>>¤&D¼˜››£W¯^ð÷÷ç; édèJ¿«©©átżøøxà‡~Àœ9s‡²²2äåå! œ 8²¶¶Fhh(ÍÒGºœàà`DGGÓˆ}Ò&èJ¿‹‡±±1ÒÒÒ ¥¥Õª¶ ¡¯¯ÒÒRÄÇÇcРAo55óæÍã¬=B:š˜˜q6¿!oCE_Œ"** ׯ_GDDþùç”––¢gÏž3f f̘ÇãùóçèÝ»w«û300@bb"> ooo¬_¿––†††ôõõñÝwßqðÉ€ÜÜ\äææBOO“ö鈶lÙsssØÚÚò…tTôÅÈljÈÈH„‡‡#)) 555ÐÖÖ†¹¹9æÏŸ±cÇBGGeee8~ü8ÂÃÃ9{Ö®  €Õ«WcõêÕœ´×°°0ÈÈÈÀÔÔ´Mû!„/qqq¸xñ".^¼ÈwÒ…PÑï ª««‘€ëׯ‹ }íúò£F¤I“°eËŒ3jjjolCNN¦¦¦¸|ù2§ìÚÕ+W`nnŽîÝ»ó…6±e˼ûî»°³³ã; éB¨èwµ·ê£¢¢píÚµ:·êÍÍͱbÅ XXX`Ô¨QÍ*„ŽŽŽØ¹s'öîÝËÙóý¶& qîÜ9|õÕW|G!¤MÄÇÇÃßß~~~|G!] }ž¤¥¥‰ÜEFFŠnÕkjjbìر˜7o,,, ««Ûª¹óç΋Ï>û ¡¡¡bóÜ0$$yyy˜;w.ßQi[¶l±±1¦L™ÂwÒÅPÑo/^¼ªˆˆ@dd$ž={˜˜˜ˆnÕ›››C]]Ó¾UUUáä䄈MÑ÷ððÀìÙ³9|HHGsûömœ?çÎãd1,BšƒŠ~¸ÿ>bccE_7oÞÄ‹/ ªªŠ±cÇbíÚµ077‡‰‰ dddÚ<Ï—_~‰‘#G"11ÇoóþZãÖ­[ Dbb"ßQi[¶lÁˆ#0mÚ4¾£.ˆŠ~+åå削{LL bcc‘——))) >ffføè£`nnmmm^2`Þ¼yøâ‹/:üHáÏ?ÿ...ÐÕÕå; !œ»{÷.Î;___ºÊ'ü` À¼¼¼ÚÝ${öìaï¼ó ú’””dêêêlæÌ™,22²ÉmÝ»w988ÔÙVPPÀ~øáöÞ{ï±Þ½{3III&--ÍÔÕÕÙ»ï¾Ë–,Y":ÖÁÁ=xð UŸçU˜šššès :”Í›7íÞ½›EDD°²²2ÎúâBFFSRRbüñßQäííÍ”••YVVßQi...LOOÕÔÔð…tQmZô_m«öï‹ÒÒRÆtuu™„„ |ëùgÏžeZZZìîÝ»¢m7oÞdýúõcêêêì—_~a=b•••¬¸¸˜Ý¸qƒmß¾õêÕKtü;w˜¶¶6;þdÊÊÊlÿþý|G!¤M¤§§3IIIvüøq¾£.¬Ý‹~­ˆˆ€™šš6znpp0“’’bááá¢mLCCƒ©¨¨4ZÀlmmë|Τ¤¤XHHHó?Äk¸üù´—ššfggÇFÅJKKùŽ#RZZÊLLLØÔ©Sé ˆtZ+V¬` `UUU|G!]o/n›˜˜<¦¢¢®®®°¶¶†………hûÁƒ‘‘‘O>ùƒ jðü×糶°°€µµ5\]]9[rVœœ8qÏž=ÃìÙ³QYYÉw$TVVbÖ¬Y(,,ıcÇè9'é”rrrðûï¿cíÚµ”¤¡T„?¼ýêêjhtôº——233áääTg»¿¿?`êÔ©Íî×ÉÉ ðññiö¹AïÞ½qùòeÄÆÆbÎœ9¼þñS^^Ž9sæ 66gÏžE¯^½xËBH[Ú³g°xñb¾£.Ž·¢ýúu€¹¹yƒÇ\¸pðî»ïÖÙ^»´«––V³û­½ÃÐìs; MMM"""“'OF^^^»gÈË˃­­-"##!''‡µk×âÅ‹힃¶VXXˆ_~ùŸ|ò M+Mx×îE¿¼¼!!!øøã!++‹Í›77xìíÛ·ýúõ«³½°°ÀËÅ_šKCCÀË÷Á»2\¿~?†±±1¢¢¢Ú­ïððp"++ 8þ<¢££1kÖ¬ñÈ.·³ÑÖÖF\\Œ1~üx¬Y³%%%mÖ_QQV¯^ +++Œ5 qqqÐÔÔ„‰‰ ‚‚‚¹sçRá'Fyy9öîÝ‹åË—CEE…ï8„´oÑgŒA(âÙ³gðõõÅÈ‘#=¾öyóë_ttt)))ÍÎ %%àåŒèÙ³'Ξ=‹àرc6l<<<8}Ö_^^Žýû÷CGGžžž8xð Ξ=[ç— ©©) …BÎú'„/ÇŽC~~>>ýôS¾£€ÇgúMQûüëõ0}útÀ¹sç=ÿMËÉVUUÕi›¼¼³téR¤¦¦ÂÁÁk×®ÅàÁƒñõ×_·è«Z)))X¿~=Œ/¾øNNNHNNÆâÅ‹ß8Jìر@@@,X@…ŸˆµêêjüðÃX¸p!Þyç¾ãòRCïò¡ßÓoŠ!C†0ì¿ÿþ«³½°° 0€ÉË˳¤¤¤Ï×ÕÕ­·-77—`šššÍÎó*.>Mvv6ûúë¯ÙÀ¦¯¯ÏV­Zż¼¼X\\+**ªwNQQ‹‹‹c^^^ÌÝÝéëë3lРAì›o¾aÏž=krÿÁÁÁ¬{÷îÌÕÕ• …B.?!íÆËË‹IJJ²{÷îñ…‘ýÂèˆ#ððáC<}ú=zômWRRB@@ìíí1~üxlݺöööPWWGQQâââpèÐ!’’’øõ×_éý}"Vcرcœœœ ©©ÉwBDÚ´èoÞ¼¿ýö›è{555#00°IçÛÛÛ㯿þÂ7ê­g``€ÄÄD>|ÞÞÞX¿~= -- èëëã»ï¾«×fíd@-yÇ¿«;v,ÆŽ‹Í›7C(âÑ£GHKKCQQ‘è- eee())A[[ƒ ‚„„D«ûž]ÁŸþ‰¹sçÂÝÝ?ýôßqiKKKÈÉÉuéù@HÇÔ¡oïËÊÊâèÑ£˜:u*bbb}½¯)¢££„€€€V|Ò~pâÄ ,X°ŠŠŠÎë@HG«W¯âÊ•+|G!¤ž]ôÀÖÖÞÞÞpuuŹsçD¯ë5Wrr2\]]qúôiØØØpœ’´¥yóæ¡´´Ë–-ƒ¢¢">ûì3¾#Ò ={öÀÈÈï½÷ßQ©§Ã}pttÄÈ‘#ñå—_âÌ™3-jã믿F@@†Êq:Ò–,Y‚ÒÒR¬^½òòòX¾|9ß‘©'++ §NÂÏ?ÿÌwBÞH,Š>ðržý–|­:—t Ÿ|ò Š‹‹±bÅ ÈËËãƒ>à;!u8pJJJpqqá; !o$6EŸØ°aŠ‹‹±hÑ"ÈËËÃÁÁïH„x9óäÁƒññÇÓä_¤Ã¢¢OÄÎŽ;PVVgggüõ×_°³³ã;!ðôôDQQÜÜÜøŽBHƒ¨è±´oß>”””ÀÑÑþþþ°´´ä;éÂcسgæÎKSî’Š>KGŽAii)¦OŸŽV¿ÒIHK#)) žžž|G!¤QzÁB#!!OOOŒ?“'OÆíÛ·ùŽDº¨Ý»wã½÷Þƒ‘‘ßQi}"Ö¤¥¥áëë cccX[[·jU@BZ")) ÁÁÁ´|. t{Ÿˆ½îÝ»ÃÏÏ666°±±ÁÕ«Wi>Ò$555¸}û6âãã‘––†G¡¤¤€’’TUU¡££===˜™™ANN®N{öìÁСCaooÏÓ§ ¤é¨è“NA^^°´´„­­-ÂÂÂЯ_?¾c‘¨¼¼çÏŸÇ™3gpõêUäååA^^ÚÚÚ}úð‹tøñÇñûï¿£¬¬ ï¿ÿ>¾ÿþ{L˜0Æ {ëùÏŸ?Gxx8BCCñã?âË/¿„ V®\‰?ü°>!­Gš’N¥OŸ> ‚P(„µµ5òóóùŽDxVRR‚5kÖ`èСðõõÅ7ß|ƒ¬¬,üõ×_X¶lY“ >ôîÝ3g΄‡‡ž>}Š?ÿüeeeصkf̘¤¤¤6þ$„´}Òéhhh 44ÿý÷ìììPTTÄw$“‹/bØ°a8~ü8~üñGÂÂÂÉkB^Õ`Ñ'¤³ Á´iÓ0oÞ<üöÛot7«“ùßÿþOOOüý÷ßâ꺲²vvvÈÌÌD\\äååùŽD=Ó']‡ Ξ= ///,[¶ ô÷nçqþüyüüóÏ8{öl‡(øÀË)¢Ïž= Æ–/_ÎwBPÑ']Œ|}}qâÄ ¸»»Sáï °téRlÙ²|Ç©CYY§OŸÆ™3gpá¾ãB·÷I×ôçŸbîܹX¹r%vïÞÍwÒ nnn¸uë®_¿ÞaÙüðÃðððÀÝ»wëÍÝOH{¢¢Oº¬?þøÎÎÎX½z5víÚÅwÒ‰‰‰011All, ùŽÓ ªª*aöìÙøæ›oøŽCº0*ú¤K;yò$>üðC¬[·ß~û-ßqH3Í™3B¡gÎœá;Ê[ùøøÀÍÍ ÿþû/”””øŽCº(‰M›6mâ;!|9r$ú÷ïµk×Þ{ï=~‘&»ÿ>ÜÜÜpâÄ ôíÛ—ï8o¥§§‡ß~û 0vìXžÓ®ŠVÙ#]Þ‡~¡PˆeË–AJJ _}õß‘H=z#FŒàež–€««+Ž9"ú#“öF·÷I§òøñcÄÄÄ´èÜK—.áèÑ£puu…ÇÉ:>qšlŠ1†AƒaÕªUX³fM‹ÛÙ»w/vìج¬¬:Û¥¤¤Ð£GbñâŘ={v¥Ãñ êIDATk#=z„!C† ::£Gæ¤MBšƒŠ>éT¼½½1þ|¾cˆ%qšVúÖ­[044DJJJ“—ÆmLí¨ÿÚ_‡¥¥¥HLLÄš5k‰íÛ·ã‹/¾hu?0|øpÌœ9[¶lá¤=BšƒÞÓ'cŒ¾šñ%n®^½Š¾}ûrRðßD^^fff8zô(`ÿþýœµmii‰+W®pÖ!ÍAEŸ"v¢££ajjÚæý 2››ËY›æææøçŸ  9k“¦¢¢O;)))ÐÑÑió~ÒÒÒFFFœµ9lØ0¼xñ=â¬MBšŠŠ>!DìÜ»wZZZmÖ~YY¢¢¢°hÑ"ÈÈÈ`çÎœµ]»âÞƒ8k“¦¢Wö!bE(¢´´***œ·ýú4¾ÖÖÖˆ‹‹ƒg}())¡[·nÈËËã¬MBšŠ®ô !b¥¤¤   ÀyÛµ322 ¢¢‚¢¢¢6yŒ ¨¨ˆââbÎÛ%äm¨èBÈkúöí‹ýû÷#664i)éL¨èBÄJí~í[qqqÁÌ™3±}ûv\¿~Ó¶‹‹‹¡¨¨Èi›„4}BˆX‘€‚‚òóóÛ¼¯ƒ¢GX°` 9i³¨¨555èÕ«'íÒTô !b!77!!!عs'zöì‰û÷ï·yŸªªªøå—_ðèÑ#¸¹¹qÒæ½{÷üß(~BÚÞ'„t(Œ1<|øñññHHH}edd444 ¬¬Œ”””V÷µyófÑÊw ®®kkkxzzŠ¶9::bîܹðööFdd$Nœ8qãƵ¸ÏÔÔTÈÈÈ`àÀ­ÊNHKPÑ'„ð&//wïÞERR‘˜˜ˆ[·n¡¨¨ÐÖÖ†¡¡!V­Z###¢OŸ>Ø»w/'ïÎoܸ7n|ëq>>>ðññiu…Ñ£GCBB‚“öi*ú„6—ŸŸ/*îwîÜARRîÞ½‹ììl@= §§ÌŸ?†††>|8äääÞØž••>ýôS$''CWW·=?J«]¹r|Ç ]}B'ÊÊÊpÿþýz_©©©ÈÌÌ(++CWW˜2e ôõõ¡¯¯ fõe``€ââÅ‹bUôÓÓÓ‘””„ßÿï(¤‹¢¢Oi²ììldffâáÇõŠ{í3÷nݺ¡ÿþÐÔÔ„¶¶6¦L™èêêbÀ€œäpqqÁÉ“'±fÍNÚlžžž6lFÍwÒEQÑ'„ ‡§OŸâÉ“'xúô)233ñï¿ÿ"##xñ‗¯Í 0šššÐÓÓôiÓ ©© --- 2222mž÷Ã?ĶmÛ‡Q£Fµy­U]ýÿÚ»·¨¾6 àϤ“&Zžµ¢e˜–f¥7™iQŒ§2ŒÀŠèʈH,0¥›2R0¨.œ3Ë”œ"£¬´ÈjyHÒ(í$ä1mTÖwã—錣ãßI÷ó»s\ïÚïáuö^k½¸|ù2’’’, I˜LLÇfÚDh4ìÞ½ÛäñgÎœAzz:>þ<ô™µµ5œœœŒääd›4Wcc#Ž=Šs€\.‡££#V­Z…½{÷"&&fØïe2Ùˆ¼;::pᡦ¦ííí˜5kæÏŸOOO¬\¹999~¯2ÏÈÈj;Ÿ9ïâ⸻»cáÂ…P(ðôô„§§'ÜÝݱhÑ"Ìž={Ü×™lñññÐétÈÏÏ·t*cÒh48tèš››y0YŽ šArssÅDþ¬ Åõôôˆ___aee%nß¾=füõë×…···xóæͨs !Dww·(//ëׯ„Z­‘ß^¼x!<<<„›››ÈÊÊÍÍÍB§Ó‰®®.QYY)ÔjµX°`ÁÐøššáãã#nÞ¼9¡ûOII¢¯¯oÜñ–RUU%är¹¨¬¬´t*Fét:±lÙ2‘––féTHâXôiF™Œ¢¯÷øñc@½sçŽË墬¬lÌ9…¢¾¾^îîî#Æëµ·· wwwáàà ššš ^;<<|ØÏeeeB.—‹»wïÍùoDnnî¸bþëÖ­ƒƒƒ–NÅ ôôt±dÉÑÛÛkéTHâx"‘€W¯^Ó×וJ…°°0lܸѤyõß¿ÿnpLvv6ZZZpøða,^¼Øà8­V;ìç7",, *• }}}&å3Ý¥¥¥¡©© jµÚÒ©ŒêåË—HMMEff&lmm-I‹>‘`tQZnn.Z[[mò¼ €Õ«WSTTˆŒŒ4y^½èèh´´´LÚa2ÿ:äää 55eee–Ng˜ŽŽÄÅÅ!66[·nµt:D,úD†è;«[ÈwëÖ-ÀÚµkÇœïçÏŸ(//Gbb"lllŒž(W[[ ðööOÊþÿ„¢¸¸xܱÓUTT>ŒíÛ·£ººÚÒét:vîÜ +++œ?ÞÒéà–=¢z{{ñèÑ#$%%ÁÖÖ'Ož48¶ªª àááapÌß+ãÃÂÂðüùsøùùŒÑwtÓ·‘ýA7¯_¿wìt–žžŽwïÞ!""÷î݃ÅrÑétؽ{7jkkñðáCƒ' M5~Ó'úƒL&ƒ½½=°fÍTTT ((Èàø¯_¿0^œÅï³hiiƒƒ:;;±lÙ2£yèçëéé÷=跃鸕 +++\¹r^^^ Aee¥EòèêêBDDJKK¡ÕjÙMþ),úDB`pp_¿~E^^V®\it¼~±œµõØÍ 233ñìÙ3œ8qÂèXý?é$'—Ëü~b!5vvv())Á† ŠK—.Méõkjjˆ††”••aÅŠSz}¢±°è™aÎœ9€ÁÁA“Æ'$$`ÇŽP«ÕCkF³}ûv@AAÑùvìØ1â³þþþa¹I­­-òòòpèÐ!$&&"!!ÁèN‰É000€³gÏ"((ÎÎÎ(//ÇòåËÿÓkM‹>‘\]]&ÇdggÃÑÑ{öìzwÿ·`áÂ…ÈÌÌZÔ7šúúúŸésqss39§™ÆÊÊ jµ%%%xøð!|||pîܹ¡c„'Sii)‘œœŒ#GŽ ´´tÜ „ˆ¦ ‹>‘üýýŸ>}29ÆÅÅYYYhnnÆF3oÞ<ÃÙÙ¡¡¡CûöñãÇܽ{J¥?~«ÿl¬WRŽ·oßbß¾}HNN†——NŸ>oß¾™5o?nܸ 6`Ó¦MpvvFUURSSMzÕCd),ú$i'OžÖùÍÕÕ[¶l19>** †-û{N777$$$ ‹S*•ˆ‹‹ƒF£Á’%KFÝ_îçç‡êêj;v þþþ˜={6 öïßþþ~œ:ujDœþ0¡‰ìñŸ‰ìíí‘‘‘÷ïß#66iiiðððÀ¶mÛ••…ºº:“z5|ûö ùùùHJJ‚››”J%œœœðäÉhµZ,]ºt î†È|ø€ÎÎN|ùòÖÖÖ˜;w.°k×.øúúbݺu’] I3‹>‘™ÂÃáÑh R©PPP0æüÿJmm-T*®^½ŠÍ›7[$‡éF&“ÁßßhmÑLÇwúD“@©T¢°°Ç·X)))(..uÀoúD“ÆÛÛ×®]›p¼¹ïó͹6I¿éI‹>‘D°èI‹>‘D°èI‹>‘D°èI‹>‘D°èI‹>‘D°èI‹>‘D°áÍHyyy–NˆèŸÃ¢O3RLLŒ¥S "úçÈ„¹ý<‰ˆˆhZà;}"""‰`Ñ'""’}"""‰`Ñ'""’}"""‰øvAźÇ}BIEND®B`‚libDAI-0.2.7/examples/example.cpp0000644000263000017630000001742211433220723015440 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include #include // Include main libDAI header file using namespace dai; using namespace std; int main( int argc, char *argv[] ) { if ( argc != 2 ) { cout << "Usage: " << argv[0] << " " << endl << endl; cout << "Reads factor graph and runs" << endl; cout << "Belief Propagation and JunctionTree on it." << endl << endl; return 1; } else { // Read FactorGraph from the file specified by the first command line argument FactorGraph fg; fg.ReadFromFile(argv[1]); // Set some constants size_t maxiter = 10000; Real tol = 1e-9; size_t verb = 1; // Store the constants in a PropertySet object PropertySet opts; opts.set("maxiter",maxiter); // Maximum number of iterations opts.set("tol",tol); // Tolerance for convergence opts.set("verbose",verb); // Verbosity (amount of output generated) // Construct a JTree (junction tree) object from the FactorGraph fg // using the parameters specified by opts and an additional property // that specifies the type of updates the JTree algorithm should perform JTree jt( fg, opts("updates",string("HUGIN")) ); // Initialize junction tree algorithm jt.init(); // Run junction tree algorithm jt.run(); // Construct another JTree (junction tree) object that is used to calculate // the joint configuration of variables that has maximum probability (MAP state) JTree jtmap( fg, opts("updates",string("HUGIN"))("inference",string("MAXPROD")) ); // Initialize junction tree algorithm jtmap.init(); // Run junction tree algorithm jtmap.run(); // Calculate joint state of all variables that has maximum probability vector jtmapstate = jtmap.findMaximum(); // Construct a BP (belief propagation) object from the FactorGraph fg // using the parameters specified by opts and two additional properties, // specifying the type of updates the BP algorithm should perform and // whether they should be done in the real or in the logdomain BP bp(fg, opts("updates",string("SEQRND"))("logdomain",false)); // Initialize belief propagation algorithm bp.init(); // Run belief propagation algorithm bp.run(); // Construct a BP (belief propagation) object from the FactorGraph fg // using the parameters specified by opts and two additional properties, // specifying the type of updates the BP algorithm should perform and // whether they should be done in the real or in the logdomain // // Note that inference is set to MAXPROD, which means that the object // will perform the max-product algorithm instead of the sum-product algorithm BP mp(fg, opts("updates",string("SEQRND"))("logdomain",false)("inference",string("MAXPROD"))("damping",string("0.1"))); // Initialize max-product algorithm mp.init(); // Run max-product algorithm mp.run(); // Calculate joint state of all variables that has maximum probability // based on the max-product result vector mpstate = mp.findMaximum(); // Construct a decimation algorithm object from the FactorGraph fg // using the parameters specified by opts and three additional properties, // specifying that the decimation algorithm should use the max-product // algorithm and should completely reinitalize its state at every step DecMAP decmap(fg, opts("reinit",true)("ianame",string("BP"))("iaopts",string("[damping=0.1,inference=MAXPROD,logdomain=0,maxiter=1000,tol=1e-9,updates=SEQRND,verbose=1]")) ); decmap.init(); decmap.run(); vector decmapstate = decmap.findMaximum(); // Report variable marginals for fg, calculated by the junction tree algorithm cout << "Exact variable marginals:" << endl; for( size_t i = 0; i < fg.nrVars(); i++ ) // iterate over all variables in fg cout << jt.belief(fg.var(i)) << endl; // display the "belief" of jt for that variable // Report variable marginals for fg, calculated by the belief propagation algorithm cout << "Approximate (loopy belief propagation) variable marginals:" << endl; for( size_t i = 0; i < fg.nrVars(); i++ ) // iterate over all variables in fg cout << bp.belief(fg.var(i)) << endl; // display the belief of bp for that variable // Report factor marginals for fg, calculated by the junction tree algorithm cout << "Exact factor marginals:" << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) // iterate over all factors in fg cout << jt.belief(fg.factor(I).vars()) << endl; // display the "belief" of jt for the variables in that factor // Report factor marginals for fg, calculated by the belief propagation algorithm cout << "Approximate (loopy belief propagation) factor marginals:" << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) // iterate over all factors in fg cout << bp.belief(fg.factor(I).vars()) << endl; // display the belief of bp for the variables in that factor // Report log partition sum (normalizing constant) of fg, calculated by the junction tree algorithm cout << "Exact log partition sum: " << jt.logZ() << endl; // Report log partition sum of fg, approximated by the belief propagation algorithm cout << "Approximate (loopy belief propagation) log partition sum: " << bp.logZ() << endl; // Report exact MAP variable marginals cout << "Exact MAP variable marginals:" << endl; for( size_t i = 0; i < fg.nrVars(); i++ ) cout << jtmap.belief(fg.var(i)) << endl; // Report max-product variable marginals cout << "Approximate (max-product) MAP variable marginals:" << endl; for( size_t i = 0; i < fg.nrVars(); i++ ) cout << mp.belief(fg.var(i)) << endl; // Report exact MAP factor marginals cout << "Exact MAP factor marginals:" << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) cout << jtmap.belief(fg.factor(I).vars()) << " == " << jtmap.beliefF(I) << endl; // Report max-product factor marginals cout << "Approximate (max-product) MAP factor marginals:" << endl; for( size_t I = 0; I < fg.nrFactors(); I++ ) cout << mp.belief(fg.factor(I).vars()) << " == " << mp.beliefF(I) << endl; // Report exact MAP joint state cout << "Exact MAP state (log score = " << fg.logScore( jtmapstate ) << "):" << endl; for( size_t i = 0; i < jtmapstate.size(); i++ ) cout << fg.var(i) << ": " << jtmapstate[i] << endl; // Report max-product MAP joint state cout << "Approximate (max-product) MAP state (log score = " << fg.logScore( mpstate ) << "):" << endl; for( size_t i = 0; i < mpstate.size(); i++ ) cout << fg.var(i) << ": " << mpstate[i] << endl; // Report DecMAP joint state cout << "Approximate DecMAP state (log score = " << fg.logScore( decmapstate ) << "):" << endl; for( size_t i = 0; i < decmapstate.size(); i++ ) cout << fg.var(i) << ": " << decmapstate[i] << endl; } return 0; } libDAI-0.2.7/examples/example_bipgraph.out0000644000263000017630000000055211433220723017335 0ustar jorismkybG has 3 nodes of type 1, 2 nodes of type 2 and 5 edges. Node 0 of type 1 has 1 neighbors: the 0'th neighbor is node 0 of type 2 Node 1 of type 1 has 2 neighbors: the 0'th neighbor is node 0 of type 2 the 1'th neighbor is node 1 of type 2 Node 2 of type 1 has 2 neighbors: the 0'th neighbor is node 0 of type 2 the 1'th neighbor is node 1 of type 2 libDAI-0.2.7/examples/sprinkler.em0000644000263000017630000000043111433220723015625 0ustar jorismkyb1 4 CondProbEstimation [target_dim=2,total_dim=2,pseudo_count=1] 1 0 0 CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1] 1 1 2 0 CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1] 1 2 1 0 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 1 3 3 1 2 libDAI-0.2.7/examples/example_sprinkler.dot0000644000263000017630000000045311433220723017531 0ustar jorismkybgraph Sprinkler { node[shape=circle]; C; S; R; W; node[shape=box]; f0 [label="P (C)"]; f1 [label="P (S|C)"]; f2 [label="P (R|C)"]; f3 [label="P (W|S,R)"]; f0 -- C; f1 -- S; f1 -- C; f2 -- R; f2 -- C; f3 -- W; f3 -- S; f3 -- R; }; libDAI-0.2.7/examples/example_permute.cpp0000644000263000017630000000746011433220723017202 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2009 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include using namespace std; using namespace dai; int main() { Var x0(0, 2); // Define binary variable x0 (with label 0) Var x1(1, 3); // Define ternary variable x1 (with label 1) Var x2(2, 2); // Define binary variable x2 (with label 2) // Define vector V = (x1, x2, x0) vector V; // Define a vector of variables V.push_back( x1 ); // V[0] = x1; V.push_back( x2 ); // V[1] = x2; V.push_back( x0 ); // V[2] = x0; cout << "V = " << V << endl; // Note that the elements of X are not necessarily ordered according to their labels // Define set X = {x0, x1, x2} VarSet X; // empty X |= x2; // X = {x2} X |= x0; // X = {x0, x2} X |= x1; // X = {x0, x1, x2} cout << "X = " << X << endl; // Note that the elements of X are ordered according to their labels cout << "Note that the ordering of the variables in X is the canonical ordering" << endl; cout << "(ascendingly according to their labels) but the ordering in V is different." << endl << endl; // N = number of variables in V (and X) size_t N = V.size(); // Define a Permute object based on the variables in V Permute sigma(V); // Each Var in V corresponds with a dimension in a multi-dimensional array. // The permutation sigma permutes these dimensions from the canonical ordering // (sorted ascendingly on the label of the variable, i.e., the same ordering as // in X) into the ordering these variables have in V. cout << "The permutation between both variable orderings is sigma = " << sigma.sigma() << ", or more verbosely:" << endl; for( size_t n = 0; n < N; n++ ) cout << " sigma[" << n << "] = " << sigma[n] << endl; cout << "This means that variable V[sigma[n]] should correspond with the n'th variable in X (for n=0,...," << (N-1) << ")..."; // Check whether the permutation works as advertised VarSet::const_iterator X_n = X.begin(); for( size_t n = 0; n < N; n++, X_n++ ) DAI_ASSERT( V[sigma[n]] == *X_n ); cout << "OK. " << endl << endl; // Iterate over the joint states of the variables, according to the ordering in V cout << "The states of the variables x0,x1,x2 are, according to the ordering in V:" << endl; cout << "SV: x0: x1: x2:" << endl; std::vector ranges; for( size_t i = 0; i < V.size(); i++ ) ranges.push_back( V[i].states() ); for( multifor SV(ranges); SV.valid(); ++SV ) cout << setw(2) << (size_t)SV << " " << SV[sigma[0]] << " " << SV[sigma[1]] << " " << SV[sigma[2]] << endl; cout << endl; // Iterate over the joint states of the variables, according to the canonical ordering in X cout << "The states of the variables x0,x1,x2 are, according to the canonical ordering in X:" << endl; cout << "SX: x0: x1: x2:" << endl; for( State SX(X); SX.valid(); SX++ ) cout << setw(2) << SX << " " << SX(x0) << " " << SX(x1) << " " << SX(x2) << endl; cout << endl; // The main functionality of the Permute object is to calculate the induced permutation of linear indices of joint states cout << "The permutation sigma induces the following permutation of linear indices of joint states:" << endl; cout << "SV: SX:" << endl; for( size_t li = 0; li < X.nrStates(); li++ ) cout << setw(2) << li << " " << setw(2) << sigma.convertLinearIndex( li ) << endl; return 0; } libDAI-0.2.7/examples/example_bipgraph.cpp0000644000263000017630000000342311433220723017310 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2009 Joris Mooij [joris dot mooij at libdai dot org] */ #include using namespace std; using namespace dai; int main() { // Create a list of edges vector edges; edges.reserve( 5 ); edges.push_back( Edge(0, 0) ); edges.push_back( Edge(1, 0) ); edges.push_back( Edge(2, 0) ); edges.push_back( Edge(1, 1) ); edges.push_back( Edge(2, 1) ); // Create a bipartite graph with 3 nodes of type 1, // 2 nodes of type 2 and edge list edges. BipartiteGraph G( 3, 2, edges.begin(), edges.end() ); // Display some information about G cout << "G has " << G.nrNodes1() << " nodes of type 1, " << G.nrNodes2() << " nodes of type 2 and " << G.nrEdges() << " edges." << endl << endl; // Iterate over all nodes n1 of type 1 for( size_t n1 = 0; n1 < G.nrNodes1(); n1++ ) { cout << "Node " << n1 << " of type 1 has " << G.nb1(n1).size() << " neighbors:" << endl; // Iterate over all neighbors n2 of n1 foreach( const Neighbor &n2, G.nb1(n1) ) { // The n2.iter'th neighbor of n1 is n2: DAI_ASSERT( G.nb1(n1)[n2.iter] == n2 ); // The n2.dual'th neighbor of n2 is n1: DAI_ASSERT( G.nb2(n2)[n2.dual] == n1 ); // n2 can be used as an abbreviation of n2.node: DAI_ASSERT( static_cast(n2) == n2.node ); cout << " the " << n2.iter << "'th neighbor is node " << n2 << " of type 2" << endl; } cout << endl; } } libDAI-0.2.7/examples/Makefile0000644000263000017630000000062411433220723014735 0ustar jorismkyb# Include flags INC=-I../include # Library path flags LIBS= # Location of libDAI library LIB=../lib # Compiler CC=g++ # Compiler flags CCFLAGS=-Wno-deprecated -Wall -W -Wextra -fpic -O3 -static $(INC) $(LIBS) all : uai2010-aie-solver uai2010-aie-solver : uai2010-aie-solver.cpp $(LIB)/libdai.a $(CC) $(CCFLAGS) -o$@ $< $(LIB)/libdai.a # CLEAN ######## .PHONY : clean clean : -rm uai2010-aie-solver libDAI-0.2.7/examples/example_imagesegmentation.cpp0000644000263000017630000003471011433220723021217 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ #include #include // Include main libDAI header file #include // This example needs CImg to be installed using namespace dai; using namespace std; using namespace cimg_library; /// Converts an image into a FactorGraph as described in section 1.1.3 of [\ref Moo08] /** The grayscale pixel values of the image are transformed by a nonlinear transformation into the local fields for each binary Ising variable, and the pairwise interactions are uniform. \param img The input image (should be grayscale, with 0 corresponding to background and 255 corresponding to foreground) \param J The pairwise interaction strength (should be positive for smoothing) \param th_min Minimal value of local field strength (corresponding to background) \param th_max Maximal value of local field strength (corresponding to foreground) \param scale Typical difference in pixel values between fore- and background \param pbg Probability that a pixel belongs to the background (in percent) \param evidence The local evidence (represented as a grayscale image) **/ template FactorGraph img2fg( const CImg &img, double J, double th_min, double th_max, double scale, double pbg, CImg &evidence ) { vector vars; vector factors; #ifndef NEW_CIMG size_t dimx = img.width; // Width of the image in pixels size_t dimy = img.height; // Height of the image in pixels #else size_t dimx = img.width(); // Width of the image in pixels size_t dimy = img.height(); // Height of the image in pixels #endif size_t N = dimx * dimy; // One variable for each pixel // Create variables cout << " Image width: " << dimx << endl; cout << " Image height: " << dimy << endl; cout << " Pairwise interaction strength: " << J << endl; cout << " Minimal local evidence strength: " << th_min << endl; cout << " Maximal local evidence strength: " << th_max << endl; cout << " Scale of pixel values: " << scale << endl; cout << " Percentage of background: " << pbg << endl; cout << " Creating " << N << " variables..." << endl; // Reserve memory for the variables vars.reserve( N ); // Create a binary variable for each pixel for( size_t i = 0; i < N; i++ ) vars.push_back( Var( i, 2 ) ); // Build image histogram CImg hist = img.get_channel( 0 ).get_histogram( 256, 0, 255 ); size_t cum_hist = 0; // Find the critical level which corresponds with the seperation // between foreground and background, assuming that the percentage // of pixels in the image that belong to the background is pbg size_t level = 0; for( level = 0; level < 256; level++ ) { cum_hist += (size_t)hist(level); if( cum_hist > pbg * dimx * dimy / 100.0 ) break; } // Create factors cout << " Creating " << (3 * N - dimx - dimy) << " factors..." << endl; // Reserve memory for the factors factors.reserve( 3 * N - dimx - dimy ); // th_avg is the local field strength that would correspond with pixel value level // th_width is the width of the local field strength range double th_avg = (th_min + th_max) / 2.0; double th_width = (th_max - th_min) / 2.0; // For each pixel for( size_t i = 0; i < dimx; i++ ) for( size_t j = 0; j < dimy; j++ ) { // Add a pairwise interaction with the left neighboring pixel if( i >= 1 ) factors.push_back( createFactorIsing( vars[i*dimy+j], vars[(i-1)*dimy+j], J ) ); // Add a pairwise interaction with the upper neighboring pixel if( j >= 1 ) factors.push_back( createFactorIsing( vars[i*dimy+j], vars[i*dimy+(j-1)], J ) ); // Get the pixel value double x = img(i,j); // Apply the nonlinear transformation to get the local field strength double th = th_avg + th_width * tanh( (x - level) / scale ); // Add a single-variable interaction with strength th factors.push_back( createFactorIsing( vars[i*dimy+j], th ) ); // For visualization, we calculate a grayscale level corresponding to the local field strength unsigned char g = (unsigned char)((tanh(th) + 1.0) / 2.0 * 255.0); // and store it in the evidence image if( g > 127 ) { evidence(i,j,0) = 255; evidence(i,j,1) = 2 * (g - 127); evidence(i,j,2) = 2 * (g - 127); } else { evidence(i,j,0) = 0; evidence(i,j,1) = 0; evidence(i,j,2) = 2*g; } } // Create the factor graph out of the variables and factors cout << "Creating the factor graph..." << endl; return FactorGraph( factors.begin(), factors.end(), vars.begin(), vars.end(), factors.size(), vars.size() ); } /// Perform an inference algorithm on a factorgraph, and visualize intermediate beliefs /** \param fg The factorgraph (should have only binary variables) * \param algOpts String specifying the inference algorithm and its options in the format "NAME[key1=val1,key2=val2,...,keyn=valn]" * \param maxIter Maximum number of iterations to perform * \param tol Convergence tolerance * \param m Final magnetizations * \param dimx Image width * \param dimy Image height * \param disp Handle for displaying the intermediate beliefs */ double doInference( FactorGraph& fg, string algOpts, size_t maxIter, double tol, vector &m, size_t dimx, size_t dimy, CImgDisplay &disp ) { // Construct inference algorithm cout << "Inference algorithm: " << algOpts << endl; cout << "Constructing inference algorithm object..." << endl; InfAlg* ia = newInfAlgFromString( algOpts, fg ); // Initialize inference algorithm cout << "Initializing inference algorithm..." << endl; ia->init(); // Initialize vector for storing the magnetizations m = vector( fg.nrVars(), 0.0 ); // Construct an image that will hold the intermediate single-variable beliefs CImg image( dimx, dimy, 1, 3 ); // maxDiff stores the current convergence level double maxDiff = 1.0; // Iterate while maximum number of iterations has not been // reached and requested convergence level has not been reached cout << "Starting inference algorithm..." << endl; for( size_t iter = 0; iter < maxIter && maxDiff > tol; iter++ ) { // Set magnetizations to beliefs for( size_t i = 0; i < fg.nrVars(); i++ ) m[i] = ia->beliefV(i)[1] - ia->beliefV(i)[0]; // For each pixel, calculate a color coded magnetization // and store it in the image for visualization for( size_t i = 0; i < dimx; i++ ) for( size_t j = 0; j < dimy; j++ ) { unsigned char g = (unsigned char)((m[i*dimy+j] + 1.0) / 2.0 * 255.0); if( g > 127 ) { image(i,j,0) = 255; image(i,j,1) = 2 * (g - 127); image(i,j,2) = 2 * (g - 127); } else { image(i,j,0) = 0; image(i,j,1) = 0; image(i,j,2) = 2*g; } } // Display the image with the current beliefs #ifndef NEW_CIMG disp << image; #else disp = image; #endif // Perform the requested inference algorithm for only one step ia->setMaxIter( iter + 1 ); maxDiff = ia->run(); // Output progress cout << " Iterations = " << iter << ", maxDiff = " << maxDiff << endl; } cout << "Finished inference algorithm" << endl; // Clean up inference algorithm delete ia; // Return reached convergence level return maxDiff; } /// Main program /** This example shows how one can use approximate inference in factor graphs * on a simple vision task: given two images, identify smooth regions where these * two images differ more than some threshold. This can be used to seperate * foreground from background if one image contains the background and the other * one the combination of background and foreground. */ int main(int argc,char **argv) { cout << "This program is part of libDAI - http://www.libdai.org/" << endl; cout << "(Use the option -h for getting help with the command line arguments.)" << endl; // Display program usage, when invoked from the command line with option '-h' cimg_usage( "This example shows how libDAI can be used for a simple image segmentation task" ); // Get command line arguments const char* file_i1 = cimg_option( "-i1", "example_img_in1.jpg", "Input image 1" ); const char* file_i2 = cimg_option( "-i2", "example_img_in2.jpg", "Input image 2" ); const char* file_o1 = cimg_option( "-o1", "example_img_out1.jpg", "Output image (local evidence)" ); const char* file_o2 = cimg_option( "-o2", "example_img_out2.jpg", "Output image (magnetizations)" ); const double J = cimg_option( "-J", 2.4, "Pairwise interaction strength (i.e., smoothing strength)" ); const double th_min = cimg_option( "-thmin", -3.0, "Local evidence strength of background" ); const double th_max = cimg_option( "-thmax", 3.2, "Local evidence strength of foreground" ); const double scale = cimg_option( "-scale", 40.0, "Typical difference in pixel values between fore- and background" ); const double pbg = cimg_option( "-pbg", 90.0, "Percentage of background in image" ); const char *infname = cimg_option( "-method", "BP[updates=SEQMAX,maxiter=1,tol=1e-9,logdomain=0]", "Inference method in format name[key1=val1,...,keyn=valn]" ); const size_t maxiter = cimg_option( "-maxiter", 100, "Maximum number of iterations for inference method" ); const double tol = cimg_option( "-tol", 1e-9, "Desired tolerance level for inference method" ); const char *file_fg = cimg_option( "-fg", "", "Output factor graph" ); // Read input images cout << endl; cout << "Reading input image 1 (" << file_i1 << ")..." << endl; CImg image1 = CImg<>( file_i1 ); cout << "Reading input image 2 (" << file_i2 << ")..." << endl; CImg image2 = CImg<>( file_i2 ); // Check image sizes #ifndef NEW_CIMG if( (image1.width != image2.width) || (image1.height != image2.height) ) cerr << "Error: input images should have same size." << endl; size_t dimx = image1.width; size_t dimy = image1.height; #else if( (image1.width() != image2.width()) || (image1.height() != image2.height()) ) cerr << "Error: input images should have same size." << endl; size_t dimx = image1.width(); size_t dimy = image1.height(); #endif // Display input images cout << "Displaying input image 1..." << endl; CImgDisplay disp1( image1, "Input image 1", 0 ); cout << "Displaying input image 2..." << endl; CImgDisplay disp2( image2, "Input image 2", 0 ); // Construct absolute difference image cout << "Constructing difference image..." << endl; CImg image3( image1 ); image3 -= image2; image3.abs(); // Normalize difference image image3.norm( 1 ); // 1 = L1, 2 = L2, -1 = Linf // Normalize the difference by the average value of the background image for( size_t i = 0; i < dimx; i++ ) { for( size_t j = 0; j < dimy; j++ ) { int avg = 0; #ifndef NEW_CIMG for( int c = 0; c < image1.dimv(); c++ ) avg += image1( i, j, c ); avg /= image1.dimv(); #else for( int c = 0; c < image1.spectrum(); c++ ) avg += image1( i, j, c ); avg /= image1.spectrum(); #endif image3( i, j, 0 ) /= (1.0 + avg / 255.0); } } image3.normalize( 0, 255 ); // Display difference image cout << "Displaying difference image..." << endl; CImgDisplay disp3( image3, "Relative difference of both inputs", 0 ); // Convert difference image into a factor graph and store // the local evidence in image4 for visualization CImg image4( dimx, dimy, 1, 3 ); cout << "Converting difference image into factor graph..." << endl; FactorGraph fg = img2fg( image3, J, th_min, th_max, scale, pbg, image4 ); // Display local evidence cout << "Displaying local evidence..." << endl; CImgDisplay disp4( image4, "Local evidence", 0 ); cout << "Saving local evidence as JPEG in " << file_o1 << endl; image4.save_jpeg( file_o1, 100 ); if( strlen( file_fg ) > 0 ) { cout << "Saving factor graph as " << file_fg << endl; fg.WriteToFile( file_fg ); } // Solve the inference problem and visualize intermediate steps CImgDisplay disp5( dimx, dimy, "Beliefs during inference", 0 ); vector m; // Stores the final magnetizations cout << "Solving the inference problem...please be patient!" << endl; doInference( fg, infname, maxiter, tol, m, dimx, dimy, disp5 ); // Visualize the final magnetizations for( size_t i = 0; i < dimx; i++ ) for( size_t j = 0; j < dimy; j++ ) { unsigned char g = (unsigned char)((m[i*dimy+j] + 1.0) / 2.0 * 255.0); if( g > 127 ) { image4(i,j,0) = image2(i,j,0); image4(i,j,1) = image2(i,j,1); image4(i,j,2) = image2(i,j,2); } else #ifndef NEW_CIMG for( size_t c = 0; c < (size_t)image4.dimv(); c++ ) image4(i,j,c) = 255; #else for( size_t c = 0; c < (size_t)image4.spectrum(); c++ ) image4(i,j,c) = 255; #endif } cout << "Displaying the final result of the segmentation problem..." << endl; CImgDisplay main_disp( image4, "Foreground/background segmentation result", 0 ); cout << "Saving the final result of the segmentation problem as JPEG in " << file_o2 << endl; image4.save_jpeg( file_o2, 100 ); cout << "Close the last image display in order to finish." << endl; #ifndef NEW_CIMG while( !main_disp.is_closed ) cimg::wait( 40 ); #else while( !main_disp.is_closed() ) cimg::wait( 40 ); #endif return 0; } libDAI-0.2.7/examples/example_img_in2.jpg0000644000263000017630000007514711433220723017052 0ustar jorismkybÿØÿþ>SNC-CS3P)ÏF‹e zgFÅÝRÿÛ„   (1#%(:3=<9387@H\N@DWE78PmQW_bghg>Mqypdx\egc//cB8BccccccccccccccccccccccccccccccccccccccccccccccccccÿÄ¢  }!1AQa"q2‘¡#B±ÁRÑð$3br‚ %&'()*456789:CDEFGHIJSTUVWXYZcdefghijstuvwxyzƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚáâãäåæçèéêñòóôõö÷øùúw!1AQaq"2B‘¡±Á #3RðbrÑ $4á%ñ&'()*56789:CDEFGHIJSTUVWXYZcdefghijstuvwxyz‚ƒ„…†‡ˆ‰Š’“”•–—˜™š¢£¤¥¦§¨©ª²³´µ¶·¸¹ºÂÃÄÅÆÇÈÉÊÒÓÔÕÖ×ØÙÚâãäåæçèéêòóôõö÷øùúÿÀà€!ÿÚ ?´yè:ÒvÍb¯b„=M'j¿P·QñQLqçÒ§a›œÈçÜÐ:U¢M'þ<Á«½ñÞ§v0#Æ”{Ó:ãŠ1Š™w|R÷úÓnêÈ`:¥/jJ6Ü,/øñKø}i»€Z\qJ>îà.+Yÿ•>Ôîîc<œÑ'FÏ¥imëü9ÿQöksŒÔ5Ô‰1E'§\RÖäŽv£ðÍ-‚CONi„sÒœZØLaÏ4ÓžÕ]CP&“=¨vcBqHOž”I¤ÆdÎzÞæ™Ce™º˜ýòóÎ3T²¡ñšÉC‚F+±ðq& ã¥\>3*¯Ý:Mã8ÝÏÒ¢½b-%#ãÒº:œËc†˜ªW¹&·<<3sÉ'Œæ±ZÎç_Ø:Zn9?ãV·9å¨Âz|§ó¥ïWc>¢‡dô®_ÆN¦Ù¶ÿv„‹R±ÁrÞÒ¹[¾Çb&Ó†uG¿5ÓÃþ²CŽ½)=ƒ¨ùda‹µFÑïAÎ9½cc9+–ɞ›@¦–RzÖNV‡cïS' [¿9h {rì}XÓ~ø}+ž«÷ÎÈlMtæ48ÆMRÞA÷¬ÖÚ!<œæ‚@Èè*nÀLÇÒŽ>´×p R†ÀÅ`‰¥ºZ„r~´-¡r L‘hßJ¡£ ±Í8u¸š:SéMÇëÒ¦å=ri\Ñ{ˆiíPÍÌO×¥4&ß}¾´f«q:Oüz ½õ©åê ÷Á¥¥'¨1ô¥ÊÅÇ=ù¥î*¶*áÑ¿¥)ëJ+[‘qE-[Üh\uÀúQŒý)ZÀ…Ç5‘¬óvžËš»g÷¢NJw±ðç1»[@æ—RX~tgš¦‰>†Ãð¬ÔuBíLaW`°Æü*2GÒ¢J ëEÃq ëÏ>Ô×8žÔo¨+™2127Ö“½=Ñ¢ff¤s0ÕD_šš ¨«´ð‹µ“.dñ[SZ˜ÖÑ òµEzÄYJI8­ ĺ—òÔ}k@L\œvŠÖgT¾¡#¯¹šÑ-Nym Üú S”ñÔâ´2#¿5ÊxÕÂÛ§ŠI]£†t})"¸šÔî[tßù!=…tV²«N @Ùtg´¢g=ç‰FqÒ˜TóÎkDõ9®0©î8¨îN-$ÎÞ•dêr€cߜ房׊ä¨ýævÃa×ßp^*•eèhžžÔÅÔ;縣½;Øwß…‚;PÞ¢,L~AQ(É e]_"ÐŒÕ]zŸJI4Á„þµ) i NŸ†š†lùmî(Šîä˜aØ»j™µ¤si×Õwñª`/'ŠC` QÇZ- ÅqøÒõw£Ôþ*v84·bbúóÖ—Ÿ®jdÛ¸­Öy¬}l¥Çþï5ÞÂfwY)$ÆéÒµˆº‡Oú'ýšÙZ™\™ ßÖu\dšM»±¾rúAŸ°ZvÆ™˜Ž”Â䊸\i9Ï4™ÁªÀ3ÅñPÐ1 Í5¹U;Øi™°yÍ õíBØ­Ìí@â|cñªJØpqÞ©N˜$cÔìü(ªm±ä±­ik#*ß ¾6ŽúT:† Œ§<ã­jsGs_¼ž•» q;“éÅcïØë ½ÇjaÐcëZ-Îw±T‘ϵ;zv$~d7a3ŸºÍœúW#ãVýÖsÛŠ¢õGNá@W!è-‰ôåÝ~ƒ¶2:é­BùLT´žÀ‚Q’)Ÿ Ž?x+z Í#s»l„\gò¦ýN*Ó«9Ù²¨¯_e„™qëT¸9Ÿz!æsí\“ÖLïŽÁz:sTý8¨ZpÇžÕ6bÿÕF?Jk@1KE€sF òES¶ábžµÅ©üE£/ÉïO ÝE&=ë(ÞÅi§švbª)†Q¹ìiŒä_ýkýM «D:AÍ©8ïWûŠMj0ÆM¥-@9ç¦)qŸÆ…pG8Í jŒšp¡[  œžiqÍÇNÔî´ÓqÍcëñ÷ÿf„…±š>ù¤”ãqö¦´Ùxw‹‡û5° KdH3žõççóN÷%¢<óތԽÅæŽõ=A£Ú¯`° ª°XLÓ[¡úTÞúÆT™ÞÇÞ ~E#;R#ÏT†<Δm É£åÀúWiá\-ƒw9?ε£ñUøM½àþ¤â_/Òº:œñ9÷×Óµnè äÏó®d½ó®_»þ½DÌ9济ç<˜ÐÜôüiÀÄOr~•¡e…ŠþÆxÕ+†Ï¯Å+hËŽêÇ"ßwÚojã;–Å­,xÄô Ö·ì9¶cþÑ¡µa™‰#·Cuå°ÉæQÚ·£¬‘…M™ß>p0{ÔlÍŠÓí3„e˜ç‘Š«©¶,dÎ:J´BÑœšô^N09¥ A<šà©»=ðbÓ“HyãÖ¦7˜¤#ò§­ÀM¹æ—·µ }@3øÑÆzûÕ0JÂódT±ý…HîgkÇ÷;}x§èãäõ¦Þš ›'¯Ö’’VE1;R9÷¦£—î¶}*\DÎBQ‰¤Ï÷ ÷q$ÙÒú1õÍ_íD†/ÒŽ;t¥}AÔ½¨ j…:ÂÁߥ; ¤Ò[ Z=¨z\qKÞœUÕÆ;ëXÚÞ~×ÇðÑ°­s4ÞçI7FÕ@v^ÿÝ­p:KRd/ò¨'?8íÅMï©›ó#ÏCKš:ŒAE8Œoz3TÒ¸µhëži>Âûk”òsBÐf[òÍõ¤”îR35øøJ¦‡æ8¢/©Dñä¸5ÛxX§Ôkj;˜Õ~é¶9«jãn›)µæ88+U»9º b¸ÉQøU=ZE-…õ«DY·¡Ë…w¯:_=ì' ~´1‰Ó4S‰AÚ‚9ëIî!8íF8çÓZ¥ªÔ<? š@ekç¿QV4¡ˆ–ÿþª¿áQ¹Wi;Pä1ëQIÐý)½Är3Œ\Kþñ¦Š64SþŒùìØ­òi´·ÄçžiE%Ü}EÎ &;Píºï§Ö”g'óÍ q §“Þ¦Àœ(‹¸ 8UG@C‡ V.·ÅÜîS½ÀÌëO4’ç ô¦€ì|?ÍŒ>›kb’Ñ Î* ÏÎ(jûº’9Íô5¨ 6IøSó ûŠ?<ØЄ÷×áO9â¥Ü ÆûÄÒR9ïUÐhÍÔAóÆ?¦ î¤®Š'LdzúWoáœÿfñÆMmIêgU^&¶ÎFj¶°鯂zV÷9¢¬rÃýhö¿ d sÇY3øM†½©§[£'Ê;µ)cêi™ØLdŽMp¾2lÌz:2¡«G2ÇŠ>µÉêwt•Üóg¨SÍké¸[}¸ ç½)+Œ’ã;ÉÉ÷©4Ü>¯h1Ÿ›5ÑKtaQhÎÚàd¯¶j<Ÿá¢ÝœCpÇ"³µ·a Z¤>§9Ž:v¤Åp5«hïŽÁÏ(îy¡;ŒOJ9À©\ÁÐ;qÖŽÿZ«ê!?¥'×µ&ÝÆ! X‡…ö¢^c1uã™#î*þ˜?t´ï :*v(i£´¦£|U=Dr7]L=˜RØF¾‹Ì=Z´J‰+ˆ:t£¦rxªµÐÃ=Í(ú÷©líKß­;h @ã=ißƋh1G Þ”zÒQ°ž¢Ç¿jzŽéò¾ Ç Ä×8»AÛgõ¥¨µ2Áý餛•lzUÞÃgg ØDGM¢µ»ÔßR$ƒ8ççÅ>ml‰#”v¡î¿­5ŽW@3µÅN¢P~´Û„4Ö?#SŽ»˜zþ4/8õª)3+PÏÚIöUÌpi'wa¢ÒmHú×qá¼1@'Ú¶¤µdU~é«“¸súU=yÏödœš×©‚9aþ¸qÚº“¶CÅaïøM†åI¨Ž}Hü+dsH@îÄý)Û;Õ²P›yWã..ã\÷4ŸÂʇÄsÛ?••Çs´·§¿–³7û&µtçÝlž¹ DÓ6çÀ«ú`êФkz[˜ÕÙtÇàt¨²µišZlqŠË×ãÐc9Ï¥h“m£Š?k‚[ž‚Ñ ÚŒ{Ô¿!ˆx4Jàÿô ç¥RZ€‡ß¡¤õ¤Ö !Õˆ¸Qš}5®ak\ÝÆ=ñZºjâ%úQÐL¾O¥'^)\¡=é:Z•±6ò FÔõg%uÿ’ÿ½Q£¹­ÄšÚ1ÄRzÓ=@©jã@?JQÁ¢ÁpÅ— žGëJz~¼<óN¶hq ¸Q»½5½€øR+œäÍT’¬£Õ®n¢#V–ú”ó½ñK"îÈìx§²宩d‚8'`àn5i&»c–?J»$O(ÂK8Îm3×øÅ=|Q&0lýüÜnî7ãÄüe¬ÈöóJ])5½-Ìkliàä`óTuöa§0+ÆzÖ›£˜S‰GÒº/ÜÈO9¬ ï&tOà±®O”ÖǾ~•ª0Ì㜟^”íàw&¬Êú€`yÁüëÏüeŸ·ÇúœÐþkOsžcϾh=+£¬³kÅ´Ç¥ki£6ËÎ憴É@ÒdšÔДjG‚8C[ÒÜÆ£Ñ,ã,8íëPžô­bsH®I5—®3uÖ¬˜üHÃõ¢¼ínîz!—­!‰©^öã cQU¶ƒÑéS­Ä&0¥ªnÀ7øªÌcŽhÎXçQAß9­<~í>‚H:T¤Ø!\S}êš!¦5DS¸îrw£môÀö5Åiv´"Æ®‡÷%íZ”ZÃ[zZ¬ (늀sÎ;Ð:cà)Àd})ÝÜÛüéJT¶·PdÂñMÀÈíEØÀŽÞõ«ô…úsUæ ÎÝûÊ?=8ÍVà(PiÁò;ÒÜ.‡¥&GSBW‡i猯_Znöœg ¥ÈÏZJà3ëÒ“œŽMv=é¥9¥ÊÊ€‹ÙWÛŠ»‹`—¦.ùGG#Ò}†äþû~t¢Y's~t-Ç­Ì ƒ½ÿ>•vßÄ:¬^\€£³fª2åÕ8ó+ÅÚÊò^Üû•?ãIsâ½Nê/*³öSŸç[ª·Z£‡±Yu©s¸¬gè+WNñ€±cY<™î¤TBQ‹»6qº± <oŸN¹ã!–§Çk/γFqÈb8«Œ¡-™Ï8H•|c£7Þ»Ç×?áSÅâ}BuòN0Aÿ Õ%-™•¤ºÆ«¦±^EÏNµÃø¦xçÔ…Õ”¢”ãËsZIÜÂ=­/c\[…ˆú ™é“[ë‘Ú“ØCÙ¾oñ­/ üÚÞN8‹ú×EkVøY×Hq/*ÅFNOÝü«DsÜi<†cëÇ1ƾ¦« £ñ#§Z1Û°¯=»èz[†i1Å5N½>´{Šž QÒ©¾Ãb1ÇjLvã5¯¨ñ}jÊtÅ]»Îjvª¥oY "j%¢²RÇCIž”õBSGz.;ÜOéM”m ì/N3GNôZìÖŽõ[ v9ü©ãª"+ÊœxÅ€’ggZãŒÕ&1YG"°õœ‹…é÷h減¾riÁ‡çN÷"…cך ÇZƒ°lô4ylG¡÷@T˜èÞ˜Å=­eÂí¸†›Y–7*W8¨ðÜp)¡ˆsŽƒ=hú-@3Øç4èZmgJ7)\gž´néÍ+ˆ &€zš  Ž¸¥ÏÖÃpÏj4-ÀN=©p)ujñÇÒ—hôšìcš1È9«M­€a‰N2 üiÀw=hroF{ ášOD,Åÿ,=Z¶,ÿÔ íŠOan9¹cõéZÞ\êÒ:GÅtRÒÇ=o…\€ï=*.sß­i˜LqËƱuð Œ öª½‘QK™‚ \÷£Fõ擹¤»u4áךr1Ö—z¬£>ôzˆW“"õ¦ûd<È)1\ŠMR×n“éT®u é¶"WÞšˆãÔ[Ÿ®sI4±]ÎçpÉ¢Ár#h3”ÃdãƒVî´ë[tF‘œû½)^ÏAŽÓ¬íïe1Ážrx­EЀ/Öªúj+–G…F²~”ÖÑ£ÇË1^?»Q'Ø\ÖD/¢ÒäãýÚ‹þù·ˆ·Ô9®0è3cwqQà7)Ï^k],UÈ·v£¢ŸÆ˜t‹Ì}ÁŸ­FP {„m¦&úâØÜ…'Ê>õW]D4ÚN½b?•0Á(<ÆGáIâŸ?q±ô¦ì9#c~TÜ@B¸Þ›þ½€¸ .i¤´óƒÍO\Ñ `ö£­$a½(9Å=6¿CŠ3ß,A“øQžhsÁ¤=)ß 2ÒdÙ(Æ>`kbÙqŸjLBÿ:Üðšæúváq]Q…W¡ÑIŸ5ŽOnÔÐyàŸÊ´G3ì#×5‰®ŸßF)ËX²©üJæ_ò¢¸.Žñ…GpéI@ƒÚŠjÀ'Ò“µK'3R±*IÏ’ZæÓæÔØûŠéí‡È*úÜZNÔX ==±IÏJÓÏÒ˜Üu¥`9½[þB£oZ¨ äp*¨ö44“åI&󴕤naîôžà0ÞÂ8ÝÍFu(Áû¤ät Hcjc²ó×éQ6§!# >^£Ú”çû ãҘ׷?¼ê{P»¹œ‘™1ŠŒÈìyvüèk¢ÒIi;“@0ã­pE0‡ð¤ ž€(fSò±_¥>Yå•q#³Ó'4$–ã5¼-ÿR¸+¦¢è†ÑI­õèè ÍΓ½‡°g„â‹Ùg9Í!¸ï{ÖU'•Ñ Œƒ4ïfàáJQIû‹ž)»²®c]^47/Š-Šp>Qšj^$™2Û(ا±I[;`Ú¶1×p®ŽÛÁÿk´Žâ;ñ¥sŠ¨E¶DäÐ×ðEÀÎÛ…>œV~£áÇÓQd¹”vÀÇ­W"èʼnîRû$án?CR ùÐI ~bzŠˆ«»íY šEôc慇ᚬîó ÿß&©ÓdóǹC(Ïîßþù4ÂŒ*Ãð©åe\oú‘Ò“Ô‡a\Òþ•6¶¢¹f&ÿGDíœÖÜ,½@ªbÎ@®ƒÂ#÷÷'=ÿ ®šV0©±¾ç÷×­ Úzg5HÁ±01ÔVºÓdc]T×¼Œî”:óìw E?Óš1éNVAq1Ûð£ŽÔ¶ ‰Gò¡l#å©òä+ØR³èNvÐnÔ\ÿ´+¨ƒýXÅ90OR»^Û§YA8¨Ž§l3†Ï¦*uNù êÑtT5êÇ?,cWè&BڤǦBú…à ïæŽP+¼†FËàŸSI¼÷&¨î=I4„ð6€ ¤ëCV;ûRqÒ’bûRžžôÚÔçò¢‹kqØ3G­]„&Gõ£9ÆsHbìsŒ!¢Hä‹b'‘šhCs×4v¤ÀØð¹Íäžé]6x4J¹¢‰Y+4dzÖh,&{RúÓoQ…&xªqW ô¤çÒc² ŽõGéIn3;¡=éðªÜ,s7Ä5ä¼÷¦EŒòx£b‘f_©¨¨¯—MɽYTg4òsXô6'Cû´ÏZÐÓ0#sÆsT„\«£ðŠ.[ŒÇò®ªJ×0­±¸IÇ'­&¡ Ø½ñšç5¢ ðJ÷YQ^ú(QùŸ­qô;X””€;ÑÛúÒ—p°‡½üéî‚ÂQÛ¥% &,_{ŸÂ–rD/Ïj¿0Òç?¥óysófºˆxJ,¬4µ9>p~´¶hB Jv3ëëIÚÐ &ŒÒv'j:Òºb°›‡sÞ°õWºz}Å8C3"ʦÍ"ÙÜ1ÀŒ\Ô‹¦\‘“°dúӸɆ‘!ûÒì Hº2ôy›éEÓ ’Ç¢Ûã–f"§]ÉyòóEí°&Iöhã!QŠX£EaµÓ-+(ž”g2$3ŸåFi\,ÂçIî ‡Š}(§pBŽj+†Ä&—˜ÑF–© èsLMÔ¸Äi"f<ôÑ: :*Ÿ½"©ú+ØÞPF›T` V‹á"ZÊÌ>ÍüñOûæ¹?B‰s¦H‹†y:cªƒw ·9k“ä¼ßPã^md"·‰<É>U”dãpšæh’h¡uŠR®Ã·8¯5ÚHÙŸïï`ßPNhœ›ƒBŒlî;'=8Å8uZÅèjÙ$'.8íùV ÉÿH“ýãB؉y¥#&¬ ÿ*×ÓÇú(õ§} e¡œû×K \-Ÿ‡Þwè2G=kª’¹ËWTsFG¸s<ß4ŽzžÞÔðI¬j;ÈÚ´l!=*ÊýÁô¬¥Ø¸Ž¤¬ìXcÒ“üñOm;ÒàÒ÷cÞ­0btëHxÍ ,?pšÏÖm£sÞ¡o`H¯¡/îó[ࣵ ÷*+`ƒV¢˜?¨¡‚"þðúb˜i/!!„œô¦9w¦®ÆcêùßÒ³ûô«Ô–Y±í*AúÖÝ) ;Ð;R¸®óõ£=è@ ÏÓšpííFûŒQÐqOzÓ²ÃÓïcŠç­=Ga%MAÞR`LÕâ<ÿúèHF@•§@låfËO!ï¸Ôp¹n?­MúгÍ}ÐÓF ôù«ØAÖ‰{¦oâ ä•ãBÒwÇJ–͵j˜ ïŠ:v¥è!;u£Ö‹âzÒ¢à‰£â2k']?読(½F.†¸ˆzô­ÀB®XàõSŠ{‰-J`þ4 ç¡©zó <Š]ÀŠ"µ ˆNj'ÏÓÖÂ2µpvk=@=N UÅ}KVœ\%lc?J¸QŸz‹€øÑüCŠ·°˜fœ8©‹Ð,(ïNQB‹$cž•)Î:Лz7Ý<Ô>qI»)â…‡Š¨»Ž3­/9úS°oñ!ìæº ÔËQH)j’$=¨Ï4˜ œçÖ—4¹÷Ô{ö©ê0ÏçINÂõ4ò›Ç]ß)8Å4;J\|§=1T„ŽVlùòF4øùýi$R/Y¨3(#‚½ ÝcÇsS]”i¦sâ„Ê꧌ƹ?ÈdÖ¢fbv¥là’l妛‘ùóK‚ÐäW¥ÛÝËä!l3É'ÏJ*qhë«'Pãy>p"ŒÿÀ«Ä6©¤R*F·µƒu¨ªs]½9gS‘J7Lôu¹¥Wc±;­ aUÜ+Áù€â¹÷åÛêjZe!«Í8ri°.ZŒ\ãÓÖµS¥ +’Çœì>¸®ƒìM{áQå Ê«¹G©×e6Žj—G;‰Xwý)þ€W,Õ¥cdî€ã=:ö«€qô©eÄ=i)2€óõ¤ïRØ0ÇQæzžÔæ†t‘£¨ Ä^õ•ªs=´xêiØfÂ؇¥i€éJNÃEv‡räsP”ÁÁ©~BŠm5q†HïM'4˜33V»CïYžÿ•ZÔ‚{gÄ鞤ã5¹Û…7¡Aõ£½.—îh"’bZpè>´'t1Ê9§ g­UôHƒææ¥Çæj€|¸¨ïúTX,JÇŠÇ×þäT“ÖÈ.c ^ù«­áì 9붷Áç&¦ÂRÒL”é­ïa°õ£4Yfœ~4’½èÏåNú :‘XRŸôçϨ¥\hµéJÇ OlVG`læ$ æ¿=XÓãc4‘H½cÿ1÷;‡è1È‚ãWVhÎlBÐkJ€qøW%¯¶u3“Ÿ’ºj+A˜Ò^ñŸdw2c»W}Ÿ!7޵͆[›b,ò¤”žj#zšëGh‚[4˜fTVÇ·5Xé–ÊÙòOâj%MI›Æl‹S šê (Ç@1\3}æôÍrâ´G]'t"ýßzrrÀwÍsزí¿ÍvGzÒóÍÞ—]hB§æÇ•Ôé·­o¥Æ‘cu5×F)èaYhb]Û:O$ª×;ˆQÐÕoǚμ-+— £ï ¹\óo¡¤w OéI²ƒµÖ†À1šN¼Ò¶£@zÒµHBPÔšuŒ{ÖV¡ójp®>ï5OašI€Â§vePQw7Ö³mõ¥$‘„"¤‹µ°i„zt¦®ÂãH¦¶HȦ„gjàý8þ*Êôþ•Iˆ|\L‡Þº945ÔaŽ)Á ÒzˆSÇZl@Î9¥ÐF@9ëJ¸ÝÒ„’‡;R¨ãüj†‰…H¸èr²Ç+ÀªËþ³µ-l+’1÷¬ý\DÒM&8ôô¢¯Ì _Ÿß]¦ºµ Š[ š_^ô_°v£¥-õú Þ“­R±aüèôÇåI騚aF}(¿R@c"°&?éþý {”\Ï>¦•Î"÷MSw–.¬äq“Ò¦‡N={Ñ{_ÓñöGb v^qd\ž€Wfs Û $éž•ËëO»QŽ0µÑ]Ú Æ’÷Šºyù£=³]Ê8ؾ°ÂlÍ1ó©¥óN~÷Jìå8Ú¶À%?•$“í4Y ÍÔ›¬œ‘ÉÄŸç\8Îú+ÝÒžƒ÷‚¹×Srõªÿ¤±=kMlMÚd8\Ö1»²&öÔQ£HAýà#Ú¶í­-QX:Wt(¸ó—0â»N:Œt¨šÒ9Ø3íU(shÉR°Öµ†4$/ wªãœjâ¯MEhoMÜ;P}k™Ææ¢{QJ̓ƒ·ZJnè`yõ£ð¥Ðÿ"òF}h¿QnXj+"_ŸYç°¢í±£V1’µ:sI¦4 ÆE?ÞœWqu+N™lTx"Ž[1uGaÿê¦0ªÐ ¨ÿDÈç±Æ¡°õ8•O½t ÓÖ›ÅúTåI„mëH: *ÄcO-‡AíH Qw†ë@Q×[[ŒpAŽ„`éÞ›w`~5*`·\Ô±Žej¿=è/QíÔc¡5“¯óduͳc­jh÷ÃýÓ[þ՛ܖuãÚ—½R²Ð”¿JU°©¥b’ÔÐF±a“ŸZ–ÒÀ?ïÆ: ™NÚ‘§ %˜–P }H§Ï¦Æ±®ÞOëBз³:KY‘I H‡Zƒø©´rT¦â/~µÏKÍÙÿåN1ÐÉÿ•#óçºÕô™`|ÆÀÏ5,aŠ Ü .i¼ËœwÔ‡;EoAêcWaD+œÕ7søµgxKr=;ïÅïÍu‚o”sڳ»2«Fã¼ïzQ7½w©&sòê}¿Za“'&“i)¬Iþ†ã¯× …y؇yt¾Ý>Üž5å«ZGM²ç"1žõaÆ0ƒJ!&µ &‡ï‘IàÔ‹y"¨F:W\qmnféDQsÏ+OkžõK›3t» $Êñ•æ«vþµ•y©ZƔӎ➼zÒr@ϱ¢¸zzR`~~µ/Èz‡8¤íøT«­Äƒ¸Í¿ mè1?Ê“«;ÓH;p VD dÕecÛŠ]@Ø‹ï*FB̧{/¨éIÛR©ÞTű ½ Ç'Ö’wÜcëLaǵ7°5@~ÆÞƱ€«HLpá—>µÐF>Aô¨– -YO¸)ÅŒRIê(½}D)ÒíJéŒ\àLSz vÅ?1=éèù“°2¸Ö„‡•#Ú¢QƒUa0|‘YšàÿGOLÐÕØ3{Ò÷âžÃ4´øøý“[ô¤CÆ”~”­­ÃÌ;Õ­>/2MØàtªr. òF‘Ì |Ä"ŒYY½YØô(J®MBã/ßéFÛz•î¢–1¸·Ú²n à|›rO@¨Ó‰®uþk®:—«»8MçI'ú§ÿtÑ{ËÁ‰í“SÆIQš«ŒÐÓÆ%Zèƒp+j Ê¢¸áÁæ¹ÍLþþcËÖ¶«ð“¨º~wGëŒ×EØsÅcCVUA2i #ÿ×]ŒÊ‚MÿýzM±4PÕýOa\Î8ÅSâ:iè‡g5‚æöœõ¬•îZÐë¢éRzPÀpÎ1ŒÑè*RÖàWž5#¦ñ¨ŒÔ}©_PŽÇÔ ¥¢Ä£Ö—[Œ3IJúƒ =ª¯ÜAÛÞ}úƒH‘˜j̱¯&aÏÌ+»Ül׋¯ýÊ&FãÛ52\Îà‡'SNÇz® ÈeëP7¥t†‘éLn”KS²zà jB¸$ãšècÏ–¾¸¢]Àw­OÜÅ%Ü°¤Á=¨nà8Œ©9¡T`iZÅ8?JfãÉ#O|SãÁ`M-õÎH`)£ïýh@æ³5À ²žÙ¦˜Ý/ojmÜf†‚عÚ:í®ƒšLNÀ4¢Ž¤ŽDij ±í]…‹ÃÝæ’‹fÔWV]¶€¡.êv«×µkrÜÀŽ1M¨ç4h EK£œ¨äVEÕš‘¾?½éQvÍ­xÙ™Ä8#½sÇþ>ÇûÕ®Œâq³±<ñM˜þâOe4ìšS—8äÜÕˆð±ðr}h(¿¦äÈ©®ˆp>•½¯¡•AAçñ®oPoÞ̓޵ªýÒ`µ$Ó‡ïc­üúÔa÷A3üé:Œçšèêepä !'ö¨zª7ú¹ö®µrÔÖGDv1V´î/#=Åd·(éã”w*̇¿éCkaŽ/©Å<2œG7@íKß­SiÉ~çz†¥;° ñšOëÖ­®ä½X~¹¢×Ô¢¦ÝXÒÔLcš=iµqˆiW>g½,˜\Ÿ@k?Ki[ÕÎ(ÜwÐ׊¤Uƒ`g¦qRR@ŸÅšqõ§bZ!—‚**¬+ê*3Ç)X —Ã6’ñÛ8¬Òª+¨˜§§ò®‚#û¤>Ôå°ñëV`û‚¥"‡cÒ{ÕFÖÍÂJAÍK E5$u¡è…a óKå€F¥kŒs.¦&®Â`ãYº×üy¯µ ¹Š:S‡z6 4./±þÏõ®Šœ‹E@ÍËäóœuäVíZ6nÑH(¦eq)’6Š‰hi YFb0Mf]\ªä ÁW´L÷räŸZæóþ–3ýãZF.Ç¥vh¾ÔËŸøö”ÿ²kDÉ9ÜûÔñ/ ¡šZ^<ÜzèIàœv­ðú\Ê €óZæ¯ÏÏ1÷âgh„w&±a)c€:ÖØž&Y⢄­¸ê+ŽÜÎáJ99Ít7}Œ„çS¸ÀëIªálÛÜŒÖ ÎrÏâ:#°îÕsI¯ÁÀ œÔ1Üê#Eàmý‹Æü*Zèå®ZO!{ÀïRûÅ“Ñ€£Ë“®ïʆ®É uq<Ô{ˆ«µ†ô Þ´¹â¥Êáa3š\äSZ=¨ÏJ%¨!LQIŒ:þTEËŠ­ÄĹlE!ã…5SI¸-ر4›±F´?wžôª\±ÊáGCPÐ!ËÁ"—šw¸Ù½@{ÓébÖïL#­`e{‘›yµs€`â®,¨$gµnۜۧӊ‰qÚ¥Ž@‹ƒšš¼žh'nÔtÐLS*@ɧ/Lbšó…ì{SW©=êZ¸„秞ÜS[9éœÔ_ÅÈâ…u¸ Ã98ǽgkcý qëCiƒ0ñšròZ{¡—4>/údm5ÑsM« €=ªkXŒ÷)8'šÎW`–§a b(•aRVˆºP¢™˜U{–X×ql{TMÙSÜü¿ÜJŒqY¬åØ“XÆíÝšUŸA§¡úW:‡7kîƶ»0F‰=I5ĪÖÎÈaŠ!m÷8¥ øEô{Lÿ\>µ¹Û5ÕFËVc0õ9ÅsW§&\õÝÖª´oŠŠ¬T SćŽµÈ·eaŒ*Eº~•\í •­ô€`5;í²w'‘UíXr¢FS%ˆ'»sYÔÔ]½Xú è*öŽØ¾¸¥v€é’EÇcNÇ?…Z‹zËéš„ŽzÓ[ˆg­4÷ô¦+Ì3ûŠæ†A>Æ”XÚ±4)•­ÛUB}*®›y£Õ›ÐÛÀÍ&ÜcëU°2còƒšPÜôãØ…ÏÊ@ëŠh$gŒPIùÿLV8úTda…+8ãšÎÖÆlsïE­¸¬`Ž”îãHe!ö^£zü¿t?­'pèµ [–v›/j‚©/xèh­H“» (ÖÈS·­sÚ»\,‡9e>•…X¹3¦’êdäs@÷«JÈç–ãepªyÅa¢&ö= .·‰eFj©$ Â@àgÒ2ŠÂVU!y„mã*í \‘ÂCü«nÎéfLw­)k©W-œl?Jåïyþÿõ­ê»ÄÎ’ŒbŽƒÇkÜZPy©ÛpÝ( U=F·£nÞ¬Üt¢úØúTÐ;E¹Ñ°@¢×4-ogÒn9ôëV£ äúPâ]K¦è¸õ¥MF"zsI+'Žú3Œ9…J·hHgãM Šò "˜GåQv(¦Ø ãšZiˆR3Åé· ÐvíGj]B:þ´èGSFˆOTlZ7¹©¬m´cý‘IØlÐQò¨õ¤HÂŒò{ÔKÝ+qã¨>¢UÔ†ˆ%ûÝ*"9«JÈž´ÆèFzÒØäVƹ’6»Øš"º‰²Ì|DµlYmõª^sKÇ4–£$ŠCœŽ{Ñn NyÆFq@AŒŒŠK¸ ´úý)6BÕˆaVš“So X—'¨ ;ºPØn†³µ‘þÏcšRc0@ãÖœ£šØi£Q{=t¿®h¸˜ø¢yäÆ»‰ý+¬ÓmÖ¥¸ô¢ÅÃErífaI@ ”°O”dÕ")ó>¹¬¥£¹ÕIès÷© ÈL'©éU³B›{™UøŠ:Œ»"àdžÙ¬™¦ ¡þT›³% B]yç?¥:H‰]ª­ZÔ¤®Eäȧp:äŠ Î3ŸJ¶¬„Õˆ0YCÅM 퀦qބɱÐÁ0–ÙÅsw\Œc«VÓ•âf£fN>ï4ŸJçl» @éÍ+\oQAâŒÓu,á§5›ÐŠIYƒÓºFß•i°mÿÕ/6>^*$Ø‹ÒœÇ@;Rld‰ÏaNÀÿ«ÛAl^µ]°ÍL!¡N9Å%KìùÒçŽhHp:ÑŒU4Š:æ¦Áa >1…4·;V?¹Aýç~5~ÜbÔ÷Ce²B&ãÐ šæáœZ—Ø}'*§=¨v Òž«`d-É9¦xªoBFž´Æäcšv#q•8êEs.13Žûª£æ•Àõ­[þŒ£8Å6ÒØE†äÐ9çPž—cÚšÄ`c<›è2pxúÓç¡;……Ï—<óO`LŒòãš›)7¨®€qUÿŠ‡®Ãc›€qÖ¨jüØ7±¤ûçÓ §©ùª˜É´ÿõéÿ-uD÷,Q “ü¨`•ô:­7OŽÊ.\ýãWª‡7­„c´f¡–å‚ùªö¨”ãÁA²O1ñ iž!ÖASí¡Üǽ2 ÂÔµ0‘{VS©Ï¤M¢¹Ù•žyäÑœ ¸'mL¾¦N¡ f*qÞ³Vn®yg½h‘HéôŸ Ìê¯tàÎÒºxt;(Àýҟ“gTmMú悳[Á^˜®&îÖkY¶‚B÷Óº×ÕVb/Dp«è*lñè1CÔIS†zš]@‘8”ðyèh°3BßýH©Oµ7k0?äP?ÍZàÀŽ´£ëU 㱧c&’nà!÷£oqí „|¿Êœ¹š{3uºhÔæ´âU¨nÃlµííGqYßR“"‰Ë[Çþè¥Ç= ⶱ,F•FÃô¤!¤r !¡+ˆ×50 s ÇF¢öKÉÒµ4Цg¿åV•Ð2îÑýáHv©ëI¾T"˜Hç;Ò¶€HldÐœŒ‘KaÜ~ãëNÜÙàÑkˆivÞ*×jkVBF* ØÍŠÄc­QÕlŽôÚsè2)ʱ¦£Iuh2Ìà`W¦érÙÀ€ódškb⬹*kºÆ¥˜à ²¹ ]˜š†²•^•…=Ë\‘‘€{ƒ\vöŽìé~äEY$ {qïKæÉÿ=5¢£ìcíŒìÄnbi¹éO——b\¹…Öû¿^õI’a^±m Áæ®øuL÷á ácäýjÛ²5Ž­ƒh=ªÊžaNW7žãeû¸=;×9«i)3£äâªNÎåR¶Ç/¨imk–9ö¬i”ÇnéZ)ÝÕ‡+²¨æO›#½Zf ŒŽhÁØ®/áA¥a0#4€0Oµ A—õ#û»qÜ'øUy©óãŒÒuCV¥œPAÍN’‚;ŠBç.zOWcp÷©ÔdªéÓ#4ðùã½UÄÍX÷+NÇEKc@FsF íSËmF/µ(Îp1N"Øó£üóGPb÷Å'ãTІ·O­<ñ©[ê=ÌÛS…}ò­XÆYhz;†#ä SJ8ÏZ‹+”CgóÚD{cúTûp¦µê""9¦Ö›Õ ×i¤u©¶‚À#ë\ÍââîO­/Pd`0£¤±1¸Ï æ©í "ÿ ÐsSkҌàþ´ÝÖ€+u}*DTâ…  8ïÒœW§¦y¥k®ÓÇ5m¹NQNöØc0¹äÔG†‹ÜòÕ Kæ±qŒsšŒåGvqœž”ì5±×xHožþuûÇäµvô#Ié„f¥A\þ­¨õUl Æ´º"¨Æîæ3Hä¶O4å¥N:RWvžhÍR¹g"ŽõVôqM êNYAä€ObiË÷¹¬–æ‰4³»N‹àu«}ÖÜ–BÝi„u¢îı¦‘Eô ÇÍ\ÕøÛ{'çVK"QœŸj¿¥cçÖ‡ä3Güæ—×5,dâ“ #Ú« Ç68>Ô/_JLLEñÍf÷,^õ4j6z.!ØïÒžƒŽ•H. ¤ñŠ]„KV&î!SB¡.£ÜS°2 "@){‹¤Ræ(Ç5)ƒ ;S[ 'J¤õ Rv§¨ÀrEJøÀ¤Ø#2Än¾ýñ[6üµ ÙRc9”3Ú—ŒñŠ”ú”Õ‘CClØpjùÎ*ÚÔ µ4ŽzS"ãH¦ž™Ï¶Ò9ç½sš¨ÿOaÓŠ¤ÄÊÈ5{JâY+§ŽëGn)n$*òsëGzNã¹&ÍÊê(Xòqš˜0‘Óâ§Ö„î$CǦ*BJm o#½@G'ëIé ‰G#­WÔ6Rœâ‡¸Îm:dô®³Àašâ]VU÷pý{ŸÈÕÞȺz»ö;²qÖ¨ê7‹d+ Êȸ«³”½ºó_ƒÅgçt¼ššf• c… ÖËÌäh_j\zš{  ˜4t½E ÏŒ¡Ô¡bžàÐÝÝSÄðƒ(±§ßp⺛D7s+`—ùªe¹ÝCJf—‘rPTq"™‰PýhM[Q&ÌܫʹlsùÕ©ì œ®9ê)$›ÐךÊæ6©BòªnãŠâ%šñÈüç ½ã*‘ºÐ„¼néš•Ho¥n·9Xð.ÐkTÌØ„zPF: 3Kc2z)1¢-LæðûŸÊªrk4º”ÅêÔj6¥ j&?g^jDLêkT´.{sK·šÃe:(ÿ|Ÿï ”„Ð8Øâ³q--¢‹]~”¼ƒ`÷ ~4ZÁqJNœUÜ~ð©%ÀLã Ï¶¥ ù¯ž­Ö¶í‡ÊMEM€“æß·iÛýêmÁÛ ÍÚ¢:ú1­#ë[_¹Â;w¦ã#•õÐVÓH¦µVczó\þ²6ߎ:¯_Ê”nØš±N1†$÷«ºk´0öªÙ­‘F(vC@ÏÇTߨX8ÈÈæœ tÍ 6ÉKqó_š†„v#ÒŽq‘C~µ ?sEÀx¨/¹³“>œÓê3‚b`8ȯHð¥äH¶‚<|¨£\ ÔÔvF´z£Jöq lIæ¹MBý¦r8®g¬£¡žrIÀ¤ØsžõЗ.¢Ü’9vð{qSg#ƒŸzîa5f/Ö—9] Ø R0i][@94£­ ½1†W¶™.£˜¹Ç­kéZ»jö‘—ƒ´ŠÆª•ô:¨Í/uL6Ç­g]Áv³½Å¼¬T«8Í )FÌÚ ÏS7O‚ý5÷XÆâÞý륚@‹ýi¤¡¡uvG3­\yƒšÎ†Å-Äœ*òsN ÚäXå9•‹¦B“•Ï¥J«µk¢z£Š{±Ûx¥Æ;VˆÉ qN ¤~4Óè ŸOjt* Äyäd¬5¹Rüî»ÕqÎA¬om aŒ©=ªâö«[‰ŽäSÔ°_z§¢àpE.sÏAI0a“Ž KlK\ ÷¢ÊÂ6³Å&+$Í SIIˆ?ži?ÃØLÐiÜ¡(=)^Â`¿{¥-ÛlϢеÔ©¤.Û`sœ’ZÚ·_Ýæ³”XÖäØ8ª·çÇIâ”l™Ff€×!=óZý«G¹ 4Þ⎠!Sý*›H‘íX:ðÅÔ$wSý)EÙ’V2™«V(ïíMû8¥ =h* È¥òÆFk7¸n(P)vŒS¾¡qØÏj0Z{Šâ:‚)Ê£R]€]£ÓµDê SK  °~5òÿ¢ÉŽâ’vÐ9eéZþ¾kKåB؉†$®Šƒ³¹»«jbåöDß.y¬±ÍcÜêm=‰V"ݸ5n+<Œ‘Z=Pâ†Ëc•àUKÛƒqëRÞ¢œ.ˆãÔ#‘¶ž*Òº²åXkKÙXãhpæ´Ý¤tí³[îIv²Ž*(ã¾T,.Ôp ô¬“¾Ç£M­™M®u/´íÂÎKq€´ïædUGá±È¬Ú{°šW9Zq29ì?ZçÚòò{# Íò7`1[Ñ‹‘ÉV|¬‰hÀ)õÕt䓸½Í4äœÕ­IŽ”cð¡­@;ûÔ¶¼Ü&}h–¨eK®nd>ø¨‡^•‹Jºâ©nK¯à>Z¦Þ“ŠV$^*{›´öª¶ƒ6ºÒ:Âö(;QIwQKšú€˜ÅjÄÅ:Õ%ÜM £&¡ÔØ¥”§¾)l4ÔÛjœcŽkfˆEKz1V0ŒÅI9ääæªj<¬kêÕWe3+@cö™W¦TZÜ=+k\žƒO&ŠM Q§¦i¤dqÞ¥ÇPaëëóBþäVš ¡RÜ“:U»BêÔŽ” ×Ï£§JX^ãØRž´Ö Ô sD´Ýh¢;÷ÇZU ²¸!Üãš•Áè/AP^ŒÛ?ûµ2$å¡>ôîœç¥\UÑDÖ÷,†BÇ…9'Úµmníçá$÷õ2F•X£Òdåc®$æëÞ¨^YBìhL¦ï¡ÄÝÂc¹‘W<5F—ÇŒ×RHóç£,Ûj/ßËZQj8ãŠVÔÌ´Ž|¤{yà –õ/¡ÙÿE“éYÚ)+ª3¿ãQmÂ?Ýé³ ¢)àÕÙ-”ÇŸnk($´;/mJ+"A+2JÖuõææ29çµCwv4o©Îkn¶ù¿‰‡ó¬°ØÅuQVGgv.áFå­u1Ÿá8ïFqŠ¡{ÒgÚ†ÀBy©¬ù¹JÃ[”¦ Í'ûÕéúŠÅ2Þã½îjêñƒøÕÇMDÅÿõÓ‡ÝÅUõ$óMÇZ4þ~•sKæìg°¡½×ïIíšÁ+–¸äqGÖª°\@?4·`Þ“œõ¦Ý†þªJ~bb¯ÞëU5¦Å¨ø›¯p-ÙŒB£ØV² D=†jPС·¦ìcëT/€kˆG¡ÍL^¥=Œˆ¿qد­oÖ´¾· Nô‡'ëB½ÀNôÒ: N÷CX:Ç××6èÞ†šÜ–Œë~S±«6ü]Çõªm™ì)@õ©zƒÜ=)ø¡YÄïÖü©I…‡§j\tÉ¡1ˆÝµ(éŠrW¿^•ƒœô$­¨ÅÆj+¡þŽøô¤•Àä‡ñ¼i{š½ Y‡sëQ%´ñ6ô#ð¥'Ülز¾•p²ƒÒ¶-ïJ€sßšç’ÔÚ4m¯Õ€ç­]2,‘³ÊMB¼]™Ó¾§,~dÒIØ»:¢ðàž:WlU¢yÓw“"1c±õ¥U cU$Ia'‘íVa¼‘U™ÎGRp[;Ý íÈ yi4¸+ؤ/‚Ä®=EKƒ±QÜè"¹}2w Dß7Ò´¿o,[Këï\3M;­ŽÛ\ʽÕ€qT7<‡æ9ÏéU½Å'ÑõD1$„ “€{ô¨ q°ÎÑ]”]ÑÇZ÷!x” ‹g>Ù­^„&;ËóøR˜‰Ô¶z ±¥?áL*zã"žå&7gŠŸOæäúª’*Xí©EÎ]_˜óH:VVE ¿y~µw¾ h˜gڟŤ†:B}ºP÷üjö”7JçÖ›zX B8¤óéX'cNŽhëÛުⰞÔb¤4Ÿ…(¦‡°„c±¤5mØB§ßGY¤·^~øüx5 ·ªNÝp¨>•ªÊµ9v**àã‚k:`Òê‘¢ƒ’(ob¤´0ô¶Û¨¦?ˆJé1ƒÅ\Ռģð¤¯aè4 àR0Å;ÝaéYzâ“aÇ8aüé 2mÿÕ槌âḡ±#ptâõ©iÜ:…8ІÃðúÐ*šº°!Ôu÷¥Ëa\¥ ÷i^ÁqIì;ÓƒU¸ :TW_ê[×Èãz^Ÿ€¡vúÉ9ì*øL¨ÇÒ“Ôò²F©bvN¡«è4ZI8ëVó¤,™É ŠM]ØÝKC<ñŽKsQIZLz×lU‘Ç-ÈÚ Æó¡móž)%}pµÉæªÈ…7Ú¦I¡Ü|Sj††O55–<×ltCRöÜËì~´£ùÖV,rd:úƒV÷U-Ihrz”ì‚:PHŸÊ“=éXbƒÎkKGY›Ø¥Ž8£Vh Å¤ÀLg?Z: VÇjCH{ˆGjCÇjk}A ƒçCR;õ+xýiµ`5í—.£Ö´ ŒÚ}E'®¥ÅS´ ôïT¬W~½°4âØæ¬Ûmì-êzúq]IÏ4䯩,LdÒc$Pž„Øx\ d‹òñRÀ¿¶*†ª¹Óäö«ZÏÛ?j²$CþЦêôJu-À^”ãÐT9Xt¤ïL{¨ VéH3Óµ èxP*7ûSÙ Uè*;û¶úRBêrï¸÷ Õ'Üc¡ÿY'ºÖ’äT½€^˜õ¥$šI€É ›k`ž•B+É£•Pzã5pQóXÓr)ϽO\ó])\Ë­ÉVð õÎ)Xœ€8Æi´MîN° ¼;Ö|Ð~úåOeQË Çk¸/xTÑÀÁÁ20"—-†vZ6«å¢Ç3*J[ŽÔùl }Äמí Y•õE&Ó–“(¨ü¶9ãÖ¦r] âÓ(ÞÏ -ÎGV’C!?;“ZÐÝÙ…ytbY‡8>¢ –ÞDÉÆTg‘]zÜä#À£nNiXLB8ÃÆhòq‡>j{CòÎÞˆj[)ŸÃÒœ:VKRÇ'úÕýjÀ v­#±-NÖž)ŠâŽ´,Ñ»A‚Øãò­M-ÂÛzsNV°‘pô sÖ¹õŽÆ‚qŽôb›×Q‡cIØ E&(ZŒCô¤ïF— ‡ ù«:SækÛ{"çCrÍs2ûUç‘Q€läôÀÍcÔ¸¡dªº*ïÖ˜žŠ 8'Ô%±È£$g¸aŠë%AïÖ¶[\„-*ŽsJ÷z SÅ#ýÜRè ƒÖ«^¡k9‡û51¹694%YqWØŒ#qÔV¶ÔhÜ‹5úSÆzT±6.;v2fÕÀ;ÒŠÒ,QÇãKøõ¢áp#ÛÒ”)Y!‹Ž˜¦H>lþå¾¢èi“ñç§jìÜK í»Š XÇCïîµ£ kéQ x惧µK gÔÔ²ÚÁqI kJrKBYLÉ– tè kXß#¼WDYˆ Ãn¦Ê§Í Û¡­Zd"銦ɛ›ÂGU§ÒÀO!£B;c48¹p:š,&Ȥ¶F}ÄaÇCéO‰î¢ÿW;cКƥÏ}ËŒÚ,6­¨y^[2CU庼’6MáAî¼æX[3u_KX©öVÜK1bxÉ¡¢#êk§’ËC&ÝÈœm;ùšŸt$§¨õ§° 6ðÊøù£=°x¦I`P€²{óPßP±Ø¥;>ÔƶgåÍ.ƒ"h¤ÊiÑ–÷,F>^*dÆ·3¹Å(¬Ö…ŽˆfQì N2N*ã{Çô¥úÓ¸!G=¨v¡¾ÀÇnâ¶ôÕÅšŸSD„µe¼zR`ã#ñ¬oÐÑ ÚŒQv \ñGZwÐÁô÷¤ÅJºÎhÅU®1É÷ºV]¯ïu™ßÓå¦3¢±\ÊOµ^>µ›²eDŠv #Œ•‡AkéŸt¢)ÞìsZQ8uМ‡ڴ{XÏaا'Sš›YZB3š÷!aÍC2æ9û&õÇc Tñ‚jà9·Œç§øÕu7`ù¡Cê*^¹¤Ø1ztíOíDFŠW Ž9¥¦¶…ëš)nÓ$°¦¼ÀDé’)³«$RvŽbyqÓ4jl:ïo÷kB?õKÏj‰h€p篭/z”6©È„·=;ûÐÞºh“äHéŠ[I'Vsó tB] ’6PXÿz£˜þä>éÍuô2Ð|m‚j„ôÛÝ”qCY·¸ÔÙ̯èpiÚÈ@àíLƵO@ªõÆin9#œÓHl ÔqM(;ôëG×b” d&vçwOj—Ë8éYõ)"94‘Íól—Á=êf¬RFA÷¦0àûv¬Û29÷¨®Ž-%ã´T±iq1Ó“HGµ¨‡ûš1Çz¤ú UãqÇAYš8ßqs'«Ô½ΛO^ªÎÆÞÌm¿ÝíJkBã¢"º†Cè)|4¿,Ïêqši[Må´¶Ä T Ž0k£Ódól"löª½‘EŸz2EBÐq¤Þ{ŠÚÃúÓAz©¢=˜tÃmÄ«èæž®¢,Ò´B[›Ön­n„Õg+ëøTÉj vy§/ÝÎx§~€.)Z”u/lÕZÀ(£Žêl¯t ‹L“Ò›Ô)â›/Ü<â¦ÖÇL1q/¹¦öü*×`[ƒýc»WQŽÅ”;!XxcŠ7sŒRKA¢XÔ¾ íÒ§ ÇáY½!{Ó €Å‡ZªriÜLÑV#ÛšwÞV_Q^‚z42Ý=ÇÒ?Ó þòj®"Ä|dÁäSY¢àÅ^AÅdR˜À¡zš{qE5òQ€ô4·B+Ûôh×½Lp½{œ Ij29Ìuj§|›TíëIÙ Í úŠsqšæ‘H„¶95÷62㊒–æ9ôô¥ÏÔ“l¢æš3$‡µi(ª%ŽÆ:t£¿4­a :g½4ŒãŒÓƒh äøV´#l(è(“HqV$Ç4˜É¬ÚÖå0Å&)4ž äR~M”b…  ÓšL~f…Üí†FôZ£ .mC‘ËE€é¬Wêjtpû‚îx9”¯bÒЫzá-_ÔñV|;·ìΠüÛ²Gµi…#–×Ô퉽 XÐÜÿg…%F=y¢ë”—£5 Â!e¿p®)ŠC.j#+‚ B9­6†‘Ï4„sR&r7ë·P¸šƒaÍj¶%ZY-h N*î1õ¨{ŽÃ‡Öœ ÛŠ1ÙúpÔìvÍH\Sè+[Dk8ìüìªÍVf=yçü**6–…GVhZÝ û$¸³ – ¼zdUM2ÀÙX­½àRVV™ÝxFbIïîJçLÔÄÕíÖÛIJù7Qù›Gðã T îf'äS·?JèƒÐÍÆÃL¥ iÏñp‚‚ Ø°`KJ÷RÜác=‡z¶y¬ÞŒ­Æ0â©j‡‹îÕ•õ)úS接ôåÄ,}Mh/n8¤·$p?ÊÒšbvæqÛ×úÜ Auï[p1S=êz*r„Ç_z1íNÀ&);T­tÁ¤ì1Ö´é`¸„QŠ–~¶ø± Î]€ãê+BÉvÀƒqÎ*–¢7c_ܪçRª2Eµ˜±©ïXI_R‘}ó^ý\¸Ó–!ÃÊrkXÌÖ:®–muYÖ=„‘ŽÇÿª«i¶ú›½lîšï<° 󊘸¥Ê÷ ´Ñt^ÁŸô{ ×LŠI®îîcòÙ"…?Ø9þtFRNÏa-4dhTv¸äb“$F kJ«Ëk£¡=™?­Q樞¦žŠsF­ZZDl\p*Eîj[ì÷>”ƒK¸­a@¥yªM ^OZZ¸0õ¦·Ý效¼f› % S½„ŽN狹qÅDxS½ÊCàÿþé­ uÌkØóD¶uzv§ ñíRõ@/j 'úÔ½@M¸£¿N´h„_ŒŸ%O"þÝOc)=@ÀúŽE+;ÕuäÛÁJoJ½zÉU¾”ô9õ/°‡š»¢ZCus3L ŸÖ”›Hqz—ÚãML7DFÒ¨òˆTç^»ŽèÒFVŽEÀy®fú›Øäu‰÷k‘®Ñ›hŒ[ÿ¼2¬t“Ì`^³HY¾™­#¢"Z—dui–4ùC3K1?b‘›©«±Bœ|@·QW܃&²šh¤!^ÍÕ¸‚0¾sùT;X¤ežqì){Ô\f–œ¿è㎦®/NŸJj°îÔ½…ž?U­5}ÄÉ¡]Ò¯×5«Ž}(–£AŽùͬü‘HOOZ? ïŠ1ßÚªé­4Еƒ¨u4˜ˆ¦ÀËÖ²ÒÛEŽ­šÙ¶_¸=êu¸.Â4 U²Žh‘‡–1ŸZͽK±8YoAc¡©¤}òg”`ÒNÚ©“©Ù´º_šÀmdã²|,þ]ë!P¹OOqIE5~¤;ÜêóJ*¢G§¥$„5¸æšý3MÎx‰@»‰‡R¸¬±Àª/è§÷’ƒÛœVÏ·j—®Œlp§§^œRD±hïD‡p€iÊ,ñš(å÷JGǯj§`=©|„{T]½ŽNðböOz„ô«°Ó ­qä/ëJnÈdØéK´b¡Ý ñÅäÒ½Ãai@ã¥=Á—Pb5Ô ­wÓk”ÆAѾ´€u^ôÉn]§ï FAíCo¡B 'Æ•IV9ª¹)È¥ŠY`“̉ö>1ŸjM_qìÍ{ Z#hý÷K¸’vñŒñT®ïínÒ\Âé!á\ƹ’ÖÆÉ©-Nrú_ô¶Éû±ã9æ©YyÉN[_j¹=lB5bˆCÕÎãÔÓï8´:“V¶'©T&Øùô©à?¹_Ê¢oBòF+'X9ò×ß5ƒe¤fÿ4еV­`1jœqVøéÚ‰bŽ”½€ dRƒÒ„OgÌÿAZ~Ô™K`íIŠ–¬0¢•îƒÇj¤B3Jà6—ß4Á#&üùšÅºv@MoÙ&eAŠ%°Í€9" ¼â÷*l4b¿úâjdŒzÓžéægÍ%¤_3mÛŒgŠÊÓf¦|‘úÓVH—¹Ò«•Îj`r(ŒRu©v¸!Ò˜Ã#­4`øy¿ZÆ­L»¤]:÷ Và¥%¨=…ö§§ZïIÎzb†À÷¥ j.ZÑË@¶:uÅ4þ¢„“CÎiîZ–¬#”¿¾zƒ¹ªM°C¡ÿ^¿CZ¶™òקØdù ŸJ‹“NûRŒm¨ÅÇŸn {Óµ˜‹dqQñº»¢½Ó¸ãÊãÚ£‘±‡S@+ J½?‹?úÁ‘U}ÀÁQ‘Ú™¼79ü)11ƒK¸ð3ŸzIê‘»d`ôô¨Ä¤j–4ŒmJB׎2µgIŒù{úzŸjÍjÊz#Ug€j;£¹€²Z\Kb.1Å-¿1‘ØÎKÝH@ÅbêÍûèÔÿw5ƒ5Eø¥'çµJvvjÍ@¶ŒJœŠo¹)ZQéš"+ )G•[Ø-éà™OLZ=³PÕŠˆŸ…ŠÎͱèž•M Z…&)ìØqõ¦÷¤†…ö¤Äc¯ïuç=B WM§¯ï¾‚©ì‹{+a·°=j¶£&ÔÅEŠFQ¼ü*Õªož4õj® Œ7/b‡Ðb²#ÄZÈõ~†”#dGS§eÏ#ëBœ~u^@»äR¼š‡{¡ØFëÞšzœU­6‰â%ͼ-þЬ/õËZ¶Dy9ÇsS?0,`žƒ4loJ›Ù ÷ÑïHwü¿Z–Ëc§KV–OëÅzJÆ"ŒL a“×¥>‚Ãln„Sãs ¥3ÁéS­ÇbÁà §:4d2ž)´ FF\ в†SƒÈ¬Ü‡Ô®÷E[æLÁr§5*WÜišŒ‡ÌGPr~ZØÓÛuëK®€Í BFI'ñª¹g'Œ}kkô%¹ß¤mè¶É2c¥gQ;µ%mÛ1íÍbj‡ý(ák—ÐÑv(ƒÍ+«foJrØeÐÇÌÛ±±Ù»Vn¨ÿ¿DêSh¤QÊkOIM÷{» ªM¹}"ÛRžÒ.%V¬zT 3=ÊÍ!ËnÓWz’uѶäSê?¶) ïíÚœ4Ôô@nŸZaëMêWˆ4·£gÎÓZ d–A¨5ÑÀ¢âCÁ✼7ãCWøé\BŽ>´¹¡»h1¤ñH)õ RsšlŠkciÏLT!£—ÔÁÝzŠ¬G5]F‡Dq4g=MjY ÂqýãJkA—@À✨¨Jè›Xv9¦É´ ¶*:”ˆy'ß5=ª‚äÖzØL´ÃŠ‹“ùס¥Œ:†NáHýAiy c/ÌvŽGÌ*B¢hü:ІÅð¡OjᔃL’«Gä¹aÊž¢ ž1Þ™ÇqYÈkR´øbA¶ªî+Z’Ö„*G¨é[ºbi= ÷¢ƒÔžPîz£¥Dêä`𵬑Ÿ Ó*Fx¦D6\c±¬å±KÌ°S*Npsº‰ÍãŸÂ¹Ù¢+(úS°zy¢Ã7ãù#®?<õ Cô¥ãµ;…ÄïKžØ¢àÙ¡§ DÇÞ®p­K}‡q(Í)"¶a×µ©+«ƒ¹£ÓÞ¦ö„ûÒzRkP›) ·¢“BZŽÆv€„Æî‰ØþµÕiˈIõ4I‹€ŽpsJþùïÃŒP¢2ÿ\ó¢/2Ÿ¥\tvèór0Ì= ¦É÷N([uÖºÖ3×å©Á©Ü¦;¯4™Å6„…=)’ºS?YMútÃÐf¹Pr*—™/rH[È[§?Òº59š¾Ã[‘N_¼=(kA´œÐ´€ PÕ¥Õ˜¿­.Œ,Í5¾éÏ¥O3™Õãíxê85PõªZ­B:f¶tñûƒìƉì4\QøÓÂô¬“O’j6ùºŽ(oQ‰´dššÝpO¹«†’&[hM# ~Qï^‚ØÈ:œÐÃ"  ãŠU&9yû¯@\G]­‘ÐÓÔåjÐ×$äbªÈ~SíEî4Ê®7=yQþñã)Móãæõ®ÊËL»’Î9"ˆ22äe±IK•–£ÌY^ÅÃ[gèsTf3Eþ²ýÓVê!ª/ ÈÜʤãâžQr8çµdæš…´c߈Ȯ^øî¼—ëŠÍ l@½*HÆeŒÕª*Ž‚¨Áâ¡Þú6 c­!QŒgñªlV¡Ç\Ñü©±ØÑ°·Z³×¡©`ƒ4})«Xl;ÒQ²¸%H ßšN˜æ\;àŽ•^þO.Âvÿdÿ*}Æh¨RÊ>ÄŒ×Of¸·Z4ê—bĬW##=k‘¤¸f<œ“BvwC{ §sf¶´aþŽÍêÕv¼®'±æ· RæUï¸Ôg¡úKbNŸI}útGÓŠº=i1Ž=i{Põ ãéMíJÚh©¾ÒU>•Ç¹U{ƒÒX›Þº8ÏÔ+tñúÓæ“»CAéšÒà4·LQîM-@= ¥% º‹íKV¬1;bƒÏ“]@æµq‹¡ùU"2i¦· pëþð­7ýKz–©©ª}GŸ^•Œl†Bï¸àP0{Ólb€< “Ú´§fÉbHÙlŠh¯A+#‚Óõ©mØcsµ°{Ó™|Ä#ºÐ›êHèÛ͇iûÊh%G¶(zè6…cš®ÀõëI$)2§&ªÜqÈïY4Û-—/4kê½_Dÿ=¨ô‰GéXÍ»£Hu/U O2Aã½e93Z-ó‹…[‰ð3ÒrIôª§µØW^û'oã\µÁ&æcþѪ[˜Œ*Xn¢ôÝš½t:LŽÔdzç½F·SXàb¨BÍ /Ò€¹©j6Û¦}3SÛ¥KÐ¥ ™½€ùR~<Ó¿A‰ÜÑJáa1Ç­ÓZ°óÓš¡¬¶, ÷vÇ×4¯­…Ô»aËx×¾®‰T!±Á"”¢Ø Û„?> cœVU’™oŒŒâ•5Ü®ƒneÛŒŽÂµôþ„?Þ5ªzØÇj‹åê뚧ŒƒéÒ”QCáöÝbWû¬™­<zR–ŒwS³RÝÐ\N´ßJWÐåFí\f0Xz1§!$Ú}ZèámÑ)õ£W‰A§ ”ÂãÉ8›¸ô V úPiÞÈbúúRÖ€Ô)zÔÆãéGÒ®Dœæ²?Ò@ôç8©CC‰L05¯dÌ»€èy¢Z¡—’rÊŽ})Þi‘pß½b£b•¬7úRŒ÷Ú¸®.Oÿª­¶%N9­h«È™=›œš_ñ®äbÓÏ4Ö€C¤RïÁ Û¡¤;ŠÀÇ&ð­ÀjL[4ÛƒJç##šÙv ”/;¾¢©N0¸¥!ÓmüË–r>TéZ'G·Ïeô®j½ )õ4k;T8ŒÖ3ØÖÄr.wJçý£N ïÅ8­,þ1“q=5ËHw3ŸV5¤L€t©ì†ëØóÎ ]õ7‡CIô¥k±ö¤RI>”7m ëéGl=)' hx‰{qRPÇq>húQ{ÔwÍbþU7Ä?_¥Ú´½„™¬Ïmz¸$RÓq›6iÌk[ŒëÈ ©r»°%bŽ»tÖ¶‹™qLÐCw–EùÀÉÏ­8«•K™$iœÖöš»lb÷¢/P–ÇŸx6_†ì²ûâ©>¤›ž|¬ñúÿ:ÚÇÔ0`)3P-‡/_›E»‚€x®6íwS§£f’w`Õˆe'¿Zè-6éôæ›mœqҚΖàhz ¦©lçÈúŒTË´Æ'”î)YØT“»Å,S`?J„ìʘì*­ÓƒÓó¢LhÐÓãÛh¤õa“]¯‡$i1Œ`¡*GÒ¹*>¦´ÍJÏÕ‡îsíS-µ4¦ýã‘ |×ö4ò1U¬*ß"œà•rWëW©ŸAËV´á›Ð}Õ’mÓÖ‚ECÜvž)pÿ Mê' c¥*œ{šm¥ 3Y?ÕžÔþô=GÐCEKod>€qŠ?ÆŽ‚µ!ï@ ü4U[MãYW‡ÌÖ`qIþTXgC`™¸Oa[@g¨¨¶·‹â Æ7`¯ §µWM¤æcÍiO]G'¡RP¼ WE"¶Lðò¦šl†p^'FÿaåI=ÔÔðó…¾eþòë]r‚›ŠOÈ6y÷£ëCØCMrš¢…Ôfíœ ´ÔQÿÕŸjØÓœHÍ6„‘<²¬jYŽÑX×—­pøRBŽ•/W`+Ç$RÊ~RF:j´`KÕÂ}Ù[דš±­rŸøb¦JÚ¡ßKâÖ£#÷±•úÕ¨ui2˜úŒR +RhÛîȤû0§ƒœw°t š3Í ÝˆÀÖÌ úVqíô«K@C[î“Ü–cóƒê´1Ræ”w¥5q ¯N¦ž’J¼¬øµ6•ÆlèòÍ,RI33Å^rHâ·¥ÉÝAÛõ§:¥]šdÇ¡¥ãp?§=ê9AÎáC`C('§ñÅ87œ§´‹Í ãÊ$Œ1aÖªJ»8ÇZØ GÜ»S¸ãpÇn•/̤nÆ»"Eìu~Œ¦…‡,Å«–ZèkZ¨j¬<œTTv‰t•ärYdŸïS²Cšªmr¡ÕøÙ ÙÛ öO5Ê)ùjﮆlw­]Ò7mÇE«ÙlúzÒ†í¨Æ‘È÷§wéIYî¡¥‰KJ£Þ‡mÄÍp)x¡nVâQÐÓM4”ÒL.!ëISä!;QT€ê+&Û÷ºÜÏœ„þTÒ`ΣK\ÊO ­=€È¯’1Û5,hɸíZ¨†WÖÜio§2F0«ŽµPVV¦,YšXÀçsŸjØÔní·SËuö¢¬;]œ¯‰Ó6»»‚+˜÷¥ =KšCùzœG×"º¼ç¨«lwÐ_zJ‰j‡B1Hzõ¡yˆa1 …ºÑ®*Áîm™f±µ™‚DÄñŠæ®kE{Ç;)¸ÿÍ(E8àV”Ûk”Σ¼ÙSRù-œçø{×0:(ö­"¬ÉcûV†Œ™+œ VbM\…ëK‘ÜÖ[î$7«gµ/z­€B*[QºåFqÞ¤f éGáW}ƒ­Šµ?¥-]ÀN1Iß­&É-O½;ÛAÜ3€}«3F]óO6>ûÑ}AV–¤#1ïWC0ß¹JªŒƒëY¶îR3ìI~ÍëZ7êÎEö­ã¢z˜v„ÀQÀiȧ,-ÃHç$ÖrÜÖ%M~=Ö}=+1íTŒ^䶯åÝÂþÖ»0r3ê)Ø:O­-fÀJFêi¥Üdg+_„ÑÉü$b’JâfIèj OÝãÒ´HAÐ1“S°Ç F)︚Æ(Ça@!1Íb˜04gžŸJœØâ“öö4=® áO<ÑéJ/K±ØFÆÆúTŽ2ˆ}VŸ˜ÄÆ{RѸ˜õíéVôè|ÛÅî«É§Äo[8üê&8aœ×U´3 dæœQý*oØcÖ—#«L,4`7±¦µ¾µ=F†J¹\ŒŠŒ6Hn½ˆ©°‘ð”a$Ž)ñ¸‘–Ê"¸Úc Õ8åh$VSÆj{ZLÃPÕ!¶XÛÎ8À5ߨڠ€b°iÜÞ/Ý#mRk—×f-…©ÅaUêè«jRUÚ})~µ¬_)Ï-]ÌÝi±jÿJçZÒ+[’ô+[BRa•wÅ;»i‘×4Óž•ê25ã>”¥¸àQv alõ«ZwÍ3ÀSItLRSH½ûÓåºÄϵ¯Ð9ÇZ·j•¾¢°™­f©…ˆî˶‘Éà «¡&,ÕŽrܜҿ`:»Ùj ïÍ:îulèÀŽ™K©IèÉ•i^•jõÂÙLÇÓ²zÔ„¢7ŠÎÇD6SMö®¡®®ÒG¡âœ59ú‰¤t`Zí }ðFÝAQVƉ(ÏZZXëô¤&¥;€ÂG9ô¬myƒZ¢ä>ôÄÕÌ!Ë}i|¼wúÓNÈB4g=©6y–à©{UØz‰ŠZ›j!;Gj.GRcš¦ã4…zÒèyý)ÃîzV¬2§ò§ÊvÇ ÿgšƬƒœñOÜ~´0§8qZú ©áÉàúŠÒ=If¡ŒžGÒ˜K)îEu=Lî&U¹éJ#õ<úЬÅqJý FO8©jÃÔNinëCî0,pj;_=ZW¸‰8ÔUò¥ÞÊzŠ†‡Ô%×*~Z§"þµ6eo€mA³šù‡2¶ÕÏ È®¾±“Ôßh¢­ì¢4çÒ¸rã¸ëž?Jä~ôΚjÐlÇKË•?,ÇJ5[•8 7׊é•6qóê7Mqhdd AÆëY9ɦ“ûŽìOµl茫fÙ` rpOÒœž‚4ºŒŽ~”ÉWpjSAmFmÒ'£sTöÃëŸz½¦)ÌŒ@§„ž¶4pqE-J°uúRw¡6!1ÞŒdc½^€7ëAýªF'Z1CL[”µwÙ§¾:ž?Zµ§G²ÙÚŽ€töë¶×Ú©êî#ˆ9É5)täÙf÷²j¶²ûm;¹­–ˆ“9zqL‹ïþ5šêtGDZ»\£jàn—eÔ©èÕI£œˆž}+¬ÒŸÌÓ¡oöGò§aÜ·A?-&ÒbhCÒž¤Ðô±¨êQÙ©ÉËž‚¹Ó$—.ÒHKç”Яb8äuô¤}j1ÞgÒæsÓõ©¹R9ÅTŸJ.Ày6i ‘Æ)ËA ÁÍÝèÑ”¦˜„¤ï@öO§¸)l1;íN—ýD>¸4¼ÄÈñ‘žÔ½³Þ–àÝ…©c–HÎôr¬ X5©0«(±aZqÞ¬ª:0­!=u"Q&ج ZŽB@Ç~õºVZEæ7~”ÞIÍJe\\g¥Fß)4˜<ŽjÇ#ñ¥° ú©éëD‰jîtb¬QºTW‹¶ÞF^¡N*Ùèú ¢ØèÖÖê1±yüë@œ šänú/tŒ]RsƒŠâµywË·Ó¯é\ðÖgLýÚeð¤ÏJìgž%ÑÅ¢ƒÝ±T‡ÞÀ¤Êè.qÅXƒ!$}*’¾â&Ydýcþtõ»˜½‘Û4œP\•u GÞ }x§®£ƒƒëR•‡qâþ.‡#k[Iu–"”š¶¢[šÞÔŸZêUÊ1H,&?* Ü B)¥Üœñ@éCzØ™­Â€ÈfæµìÓ˜×ÜRz ît,›£Ù’8ƒYz¼l÷Ö±©$¹Ûüénî6Í ¢8B¯@1XúÃ>Ê2kW¢êV^•%[*2AéëYó] cBä`Šáµˆü½EøÆFOçT¢·9™Dqé]&€ùÓö“÷)ÚèiYÀ úT(êr=óYº®¨–i±~iHà §m€æäšF‘ر'©©’(‡ëNÖ”3À÷¤ù>¦š°†˜Çð°Ï¥#C"òG½Mû L°ëKæsÞ…¦áqÂ^‡?=dã‚? m\Lp½ÏÖŒ£vÇû´mûçzO,àãš4©qIŒÑ¨60ŒP¸Ø)z€‡¯áDœÛÆ3ëD†1riÀ`P€píKëNâ`NžÂ¶ì4‰d·ŽA)˜gµ8«ŠÅ›‰.l‰#-âZ¨ºÁª¼lP÷­yœIZ—ã’Úèf7ô¥xdQÇ"­ÙìKЀ>ÏÔ÷ÁÆ(Zn=ȆGҜۿ M1•\mlÿ¥I»Ç=j[°$C<{†TàûS!CuqooüO zPö=I*…Eu&Ä#5Å)Z'JW‘Ëê· Éé\œÎe™›ÔñYQN÷f؇h¤Gœ;d×]΄w‡F=óTÇ|úPPãÒ¬Dpƒµ4ÝÄÇçšLœsNÁa3Ç­+XLMØJê41 ÉÏêjZºSK<Ð?œRQª•ûÍ^ó÷k °M×;hiÛQ›d¾å ê¥ÂçW¶' ¢¬õ±§üB¹ËÆó5Û²¢´–Áƒš`Ì9ç5:RMî:šã|GËÄ~Ì1TŸC•ìdt­ÏÉò;GéFȳž1HN;óEîÀÊÕuUµTD4§·¥sŸ<ÎYÉbz“Fì.åázw¤#§JvÔC@◯қВ™Häæ¥-@p•±ƒ‚(ÌL~eÁö¡ï`&3÷_ïS|™;pØô¦€ko\‚úÐ$ÁŒÐЇ )Áýèñ.>”»÷TúÐÁŽØ®ƒíQV Ül‹¹:Ub­qRãÔɃ1ô«þ²"Iâ-øž*g¤[.¼‘Þ³RMe_\ŒùWŸQéc¶”o#ŒÖn‹¹@zŽk/¦9­(«#cùSò‰ÚƆ´Üð*7‘˜`ô§{€Â0¤~m‡<†¤¯pGµ?©[]I{ÑCcEíÜÜëP(è™sùq]ÂùEŠÈ1žÖ®7Z‰¡“éæ#¹æì3Ua‰Õ0Ë(ÝšÒËu¸¶Ð§yç wb)cµU±Ç”œw Šžk²˜—vó’AÚ㸨<‹è£½G­;Ü–ˆTš0DÑœƒƒZ±ü¶8Í%Qõ‡3Æ-ÅFþSîæª2B± s”“ë«ðE¹SÝ7&Y>Sþȱ­$îm_Nvƒ\æ§t±DÌOjó¥~sФ­ÙÄË;Í+HIËsŠA+tê+²+CÏ›¼…1ŒÓ¼áÔŠv{‰ ¾?¼QþȪëM\­À«KÀ§ÔLZCÅ$µ„ñƒHiê1¤gŠêí®í„>Ñ@èXTÉÛq¥vZY‘„û5<ô9¬Ô•Ê'­ªµè+E&}éò÷Ò“uH`Þ—pŸLš Ù™¥|óÍ/¬„WY¥.#v¥ÐF€+Œ‚8¨%\ þøªŽã,ܸŽÞV=”×7àg©4O±QDƒ©4¡~p*o¡½´?ÿÙlibDAI-0.2.7/examples/example_sprinkler.cpp0000644000263000017630000000653611433220723017535 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include using namespace std; using namespace dai; int main() { // This example program illustrates how to construct a factorgraph // by means of the sprinkler network example discussed at // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html Var C(0, 2); // Define binary variable Cloudy (with label 0) Var S(1, 2); // Define binary variable Sprinkler (with label 1) Var R(2, 2); // Define binary variable Rain (with label 2) Var W(3, 2); // Define binary variable Wetgrass (with label 3) // Define probability distribution for C Factor P_C( C ); P_C.set(0, 0.5); // C = 0 P_C.set(1, 0.5); // C = 1 // Define conditional probability of S given C Factor P_S_given_C( VarSet( S, C ) ); P_S_given_C.set(0, 0.5); // C = 0, S = 0 P_S_given_C.set(1, 0.9); // C = 1, S = 0 P_S_given_C.set(2, 0.5); // C = 0, S = 1 P_S_given_C.set(3, 0.1); // C = 1, S = 1 // Define conditional probability of R given C Factor P_R_given_C( VarSet( R, C ) ); P_R_given_C.set(0, 0.8); // C = 0, R = 0 P_R_given_C.set(1, 0.2); // C = 1, R = 0 P_R_given_C.set(2, 0.2); // C = 0, R = 1 P_R_given_C.set(3, 0.8); // C = 1, R = 1 // Define conditional probability of W given S and R Factor P_W_given_S_R( VarSet( S, R ) | W ); P_W_given_S_R.set(0, 1.0); // S = 0, R = 0, W = 0 P_W_given_S_R.set(1, 0.1); // S = 1, R = 0, W = 0 P_W_given_S_R.set(2, 0.1); // S = 0, R = 1, W = 0 P_W_given_S_R.set(3, 0.01); // S = 1, R = 1, W = 0 P_W_given_S_R.set(4, 0.0); // S = 0, R = 0, W = 1 P_W_given_S_R.set(5, 0.9); // S = 1, R = 0, W = 1 P_W_given_S_R.set(6, 0.9); // S = 0, R = 1, W = 1 P_W_given_S_R.set(7, 0.99); // S = 1, R = 1, W = 1 // Build factor graph consisting of those four factors vector SprinklerFactors; SprinklerFactors.push_back( P_C ); SprinklerFactors.push_back( P_R_given_C ); SprinklerFactors.push_back( P_S_given_C ); SprinklerFactors.push_back( P_W_given_S_R ); FactorGraph SprinklerNetwork( SprinklerFactors ); // Write factorgraph to a file SprinklerNetwork.WriteToFile( "sprinkler.fg" ); cout << "Sprinkler network written to sprinkler.fg" << endl; // Output some information about the factorgraph cout << SprinklerNetwork.nrVars() << " variables" << endl; cout << SprinklerNetwork.nrFactors() << " factors" << endl; // Calculate joint probability of all four variables Factor P; for( size_t I = 0; I < SprinklerNetwork.nrFactors(); I++ ) P *= SprinklerNetwork.factor( I ); // P.normalize(); // Not necessary: a Bayesian network is already normalized by definition // Calculate some probabilities Real denom = P.marginal( W )[1]; cout << "P(W=1) = " << denom << endl; cout << "P(S=1 | W=1) = " << P.marginal( VarSet( S, W ) )[3] / denom << endl; cout << "P(R=1 | W=1) = " << P.marginal( VarSet( R, W ) )[3] / denom << endl; return 0; } libDAI-0.2.7/examples/example_varset.out0000644000263000017630000000135011433220723017042 0ustar jorismkybX = {x0,x1} Var x0 has 2 states (possible values). Var x1 has 3 states. VarSet {x0,x1} has 6 states (joint assignments of its variables). States of VarSets correspond to states of their constituent Vars: state of x0: state of x1: state of X: 0 0 0 1 0 1 0 1 2 1 1 3 0 2 4 1 2 5 And vice versa: state of x0: state of x1: state of X: 0 0 0 1 0 1 0 1 2 1 1 3 0 2 4 1 2 5 libDAI-0.2.7/examples/uai2010-aie-solver.cpp0000644000263000017630000005373711433220723017143 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include #include #include using namespace std; using namespace dai; // Type for storing a joint state of all variables typedef std::vector stateVec; struct PRbest { Real value; Real maxdiff; bool ready; PRbest() : value(0.0), maxdiff(INFINITY), ready(false) {} }; struct MARbest { vector beliefs; Real maxdiff; bool ready; MARbest() : beliefs(), maxdiff(INFINITY), ready(false) {} }; struct MPEbest { Real value; stateVec state; bool ready; MPEbest() : value(-INFINITY), state(), ready(false) {} }; int main( int argc, char *argv[] ) { if ( argc != 5 ) { cout << "This program is part of libDAI - http://www.libdai.org/" << endl << endl; cout << "It is one of the winning solvers that participated in the" << endl; cout << "UAI 2010 Approximate Inference Challenge" << endl; cout << "(see http://www.cs.huji.ac.il/project/UAI10/)" << endl << endl; cout << "Usage: " << argv[0] << " " << endl << endl; return 1; } else { double starttic = toc(); size_t verbose = 1; // verbosity size_t ia_verbose = 0; // verbosity of inference algorithms bool surgery = true; // change factor graph structure based on evidence if( verbose ) cout << "Solver: " << argv[0] << endl; // set random seed size_t seed = fromString( argv[3] ); rnd_seed( seed ); if( verbose ) cout << "Seed: " << seed << endl; // check whether the task is valid string task( argv[4] ); if( task != string("PR") && task != string("MPE") && task != string("MAR") ) DAI_THROWE(RUNTIME_ERROR,"Unknown task"); if( verbose ) cout << "Task: " << task << endl; // output other command line options if( verbose ) { cout << "Factorgraph filename: " << argv[1] << endl; cout << "Evidence filename: " << argv[2] << endl; } // get time and memory limits char *buf = getenv( "UAI_TIME" ); double UAI_time = INFINITY; if( buf != NULL ) UAI_time = fromString( buf ); buf = getenv( "UAI_MEMORY" ); size_t UAI_memory = 0; if( buf != NULL ) { UAI_memory = fromString( buf ) * 1024 * 1024 * 1024; } if( verbose ) { cout << "Time limit: " << UAI_time << endl; cout << "Memory limit: " << UAI_memory << endl; } // build output file name vector pathComponents = tokenizeString( string(argv[1]), true, "/" ); string outfile = pathComponents.back() + "." + task; if( verbose ) cout << "Output filename: " << outfile << endl; // open output stream ofstream os; os.open( outfile.c_str() ); if( !os.is_open() ) DAI_THROWE(CANNOT_WRITE_FILE,"Cannot write to file " + outfile); if( verbose ) cout << "Opened output stream" << endl; // read factor graph vector vars; vector facs0; vector permutations; if( verbose ) cout << "Reading factor graph..." << endl; ReadUaiAieFactorGraphFile( argv[1], verbose, vars, facs0, permutations ); if( verbose ) cout << "Successfully read factor graph" << endl; // check if it could be a grid bool couldBeGrid = true; FactorGraph fg0( facs0.begin(), facs0.end(), vars.begin(), vars.end(), facs0.size(), vars.size() ); for( size_t i = 0; i < fg0.nrVars(); i++ ) if( fg0.delta(i).size() > 4 ) { couldBeGrid = false; break; } if( couldBeGrid ) for( size_t I = 0; I < fg0.nrFactors(); I++ ) if( fg0.factor(I).vars().size() > 2 ) { couldBeGrid = false; break; } if( verbose ) { if( couldBeGrid ) cout << "This could be a grid!" << endl; else cout << "This cannot be a grid!" << endl; } // read evidence if( verbose ) cout << "Reading evidence..." << endl; vector > evid = ReadUaiAieEvidenceFile( argv[2], verbose ); if( verbose ) cout << "Successfully read " << evid.size() << " evidence cases" << endl; // write output header if( verbose ) cout << " Writing header to file..." << endl; os << task << endl; // construct clamped factor graphs if( verbose ) cout << "Constructing clamped factor graphs..." << endl; vector fgs; fgs.reserve( evid.size() ); for( size_t ev = 0; ev < evid.size(); ev++ ) { if( verbose ) cout << " Evidence case " << ev << "..." << endl; // copy vector of factors vector facs( facs0 ); // change factor graph to reflect observed evidence if( verbose ) cout << " Applying evidence..." << endl; if( surgery ) { // replace factors with clamped variables with slices for( size_t I = 0; I < facs.size(); I++ ) { for( map::const_iterator e = evid[ev].begin(); e != evid[ev].end(); e++ ) { if( facs[I].vars() >> vars[e->first] ) { if( verbose >= 2 ) cout << " Clamping " << e->first << " to value " << e->second << " in factor " << I << " = " << facs[I].vars() << endl; facs[I] = facs[I].slice( vars[e->first], e->second ); if( verbose >= 2 ) cout << " ...remaining vars: " << facs[I].vars() << endl; } } } // remove empty factors Real logZcorr = 0.0; for( vector::iterator I = facs.begin(); I != facs.end(); ) if( I->vars().size() == 0 ) { logZcorr += std::log( (Real)(*I)[0] ); I = facs.erase( I ); } else I++; // multiply with logZcorr constant if( facs.size() == 0 ) facs.push_back( Factor( VarSet(), std::exp(logZcorr) ) ); else facs.front() *= std::exp(logZcorr); } // add delta factors corresponding to observed variable values for( map::const_iterator e = evid[ev].begin(); e != evid[ev].end(); e++ ) facs.push_back( createFactorDelta( vars[e->first], e->second ) ); // construct clamped factor graph if( verbose ) cout << " Constructing factor graph..." << endl; fgs.push_back( FactorGraph( facs.begin(), facs.end(), vars.begin(), vars.end(), facs.size(), vars.size() ) ); } // variables for storing best results so far vector bestPR( evid.size() ); vector bestMAR( evid.size() ); vector bestMPE( evid.size() ); for( size_t ev = 0; ev < evid.size(); ev++ ) bestMPE[ev].state = stateVec( fgs[ev].nrVars(), 0 ); vector ev2go; ev2go.reserve( evid.size() ); for( size_t ev = 0; ev < evid.size(); ev++ ) ev2go.push_back( ev ); // solve inference problems if( verbose ) cout << "Solving inference problems..." << endl; bool first = true; size_t nrsolvers = 3; vector nrsubsolvers( nrsolvers ); nrsubsolvers[0] = 2; nrsubsolvers[1] = 1; nrsubsolvers[2] = 1; double MPEdamping = 0.49; // for each (sub)solver for( size_t solver = 0; solver < nrsolvers; solver++ ) { if( verbose ) cout << " Solver " << solver << endl; // for each evidence case size_t subsolver = 0; for( long _ev = 0; _ev < (long)ev2go.size(); ) { bool improved = false; size_t ev = ev2go[_ev]; if( verbose ) cout << " Evidence case " << ev << ", subsolver = " << subsolver << "..." << endl; // construct inference algorithm on clamped factor graph if( verbose ) cout << " Constructing inference algorithm..." << endl; InfAlg *ia = NULL; double tic = toc(); bool failed = false; try { // construct if( solver == 0 ) { // the quick one double remtime = (UAI_time - (toc() - starttic)) * 0.9; if( remtime < 1.0 ) remtime = 1.0 ; double maxtime = remtime / (ev2go.size() - _ev); if( verbose ) { cout << " Past time: " << (toc() - starttic) << endl; cout << " Remaining time:" << remtime << endl; cout << " Allotted time: " << maxtime << endl; } string maxtimestr; if( maxtime != INFINITY ) maxtimestr = ",maxtime=" + toString(maxtime); // quick and dirty... if( task == "MPE" ) ia = newInfAlgFromString( "BP[inference=MAXPROD,updates=SEQRND,logdomain=" + toString(subsolver) + ",tol=1e-9,maxiter=10000" + maxtimestr + ",damping=0.1,verbose=" + toString(ia_verbose) + "]", fgs[ev] ); else { if( couldBeGrid ) ia = newInfAlgFromString( "HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=4,tol=1e-9,maxiter=10000" + maxtimestr + ",verbose=" + toString(ia_verbose) + "]", fgs[ev] ); else ia = newInfAlgFromString( "BP[inference=SUMPROD,updates=SEQRND,logdomain=" + toString(subsolver) + ",tol=1e-9,maxiter=10000" + maxtimestr + ",damping=0.0,verbose=" + toString(ia_verbose) + "]", fgs[ev] ); } } else if( solver == 1 ) { // the exact one string maxmemstr; if( UAI_memory != 0 ) maxmemstr = ",maxmem=" + toString(UAI_memory); if( task == "MPE" ) ia = newInfAlgFromString( "JTREE[inference=MAXPROD,updates=HUGIN" + maxmemstr + ",verbose=" + toString(ia_verbose) + "]", fgs[ev] ); else ia = newInfAlgFromString( "JTREE[inference=SUMPROD,updates=HUGIN" + maxmemstr + ",verbose=" + toString(ia_verbose) + "]", fgs[ev] ); } else if( solver == 2 ) { // the decent one double remtime = (UAI_time - (toc() - starttic)); if( remtime < 1.0 ) remtime = 1.0; double maxtime = 0.95 * remtime / (ev2go.size() - _ev); if( verbose ) { cout << " Past time: " << (toc() - starttic) << endl; cout << " Remaining time:" << remtime << endl; cout << " Allotted time: " << maxtime << endl; } if( task == "MPE" ) maxtime /= fgs[ev].nrVars(); string maxtimestr; if( maxtime != INFINITY ) maxtimestr = ",maxtime=" + toString(maxtime); if( task == "MPE" ) ia = newInfAlgFromString( "DECMAP[ianame=BP,iaopts=[inference=MAXPROD,updates=SEQRND,logdomain=1,tol=1e-9,maxiter=10000" + maxtimestr + ",damping=" + toString(MPEdamping) + ",verbose=0],reinit=1,verbose=" + toString(ia_verbose) + "]", fgs[ev] ); else { if( couldBeGrid ) ia = newInfAlgFromString( "HAK[doubleloop=1,clusters=LOOP,init=UNIFORM,loopdepth=4,tol=1e-9" + maxtimestr + ",maxiter=100000,verbose=" + toString(ia_verbose) + "]", fgs[ev] ); else { if( task == "PR" ) ia = newInfAlgFromString( "HAK[doubleloop=1,clusters=MIN,init=UNIFORM,tol=1e-9" + maxtimestr + ",maxiter=100000,verbose=" + toString(ia_verbose) + "]", fgs[ev] ); else ia = newInfAlgFromString( "GIBBS[maxiter=1000000000,burnin=1000,restart=10000000" + maxtimestr + ",verbose=" + toString(ia_verbose) + "]", fgs[ev] ); } } } // initialize if( verbose ) cout << " Initializing inference algorithm..." << endl; ia->init(); // run if( verbose ) cout << " Running inference algorithm..." << endl; ia->run(); if( verbose ) cout << " Inference algorithm finished..." << endl; } catch( Exception &e ) { failed = true; if( verbose ) { cout << " Inference algorithm failed...!" << endl; cout << " Exception: " << e.what() << endl; } } if( verbose ) cout << " Used time: " << toc() - tic << endl; if( !failed && verbose ) { try { cout << " Number of iterations: " << ia->Iterations() << endl; } catch( Exception &e ) { cout << " Number of iterations: N/A" << endl; } try { cout << " Final maxdiff: " << ia->maxDiff() << endl; } catch( Exception &e ) { cout << " Final maxdiff: N/A" << endl; } } // update results for inference task if( !failed ) { if( task == "PR" ) { PRbest cur; // calculate PR value cur.value = ia->logZ() / dai::log((Real)10.0); // get maxdiff try { cur.maxdiff = ia->maxDiff(); } catch( Exception &e ) { cur.maxdiff = 1e-9; } // only update if this run has converged if( ((cur.maxdiff <= 1e-9) || (cur.maxdiff <= bestPR[ev].maxdiff)) && !dai::isnan(cur.value) ) { // if this was exact inference, we are ready if( solver == 1 ) { ev2go.erase( ev2go.begin() + _ev ); _ev--; cur.ready = true; } if( verbose ) cout << " Replacing best PR value so far (" << bestPR[ev].value << ") with new value " << cur.value << endl; bestPR[ev] = cur; improved = true; } else { if( verbose ) cout << " Discarding PR value " << cur.value << endl; } } else if( task == "MAR" ) { MARbest cur; // get variable beliefs bool hasnans = false; cur.beliefs.reserve( fgs[ev].nrVars() ); for( size_t i = 0; i < fgs[ev].nrVars(); i++ ) { cur.beliefs.push_back( ia->beliefV(i) ); if( cur.beliefs.back().hasNaNs() ) hasnans = true; } // get maxdiff try { cur.maxdiff = ia->maxDiff(); } catch( Exception &e ) { cur.maxdiff = 1e-9; } // only update if this run has converged if( ((cur.maxdiff <= 1e-9) || (cur.maxdiff <= bestMAR[ev].maxdiff)) && !hasnans ) { // if this was exact inference, we are ready if( solver == 1 ) { ev2go.erase( ev2go.begin() + _ev ); _ev--; cur.ready = true; } if( verbose ) cout << " Replacing best beliefs so far with new beliefs" << endl; bestMAR[ev] = cur; improved = true; } else { if( verbose ) cout << " Discarding beliefs" << endl; } } else if( task == "MPE" ) { MPEbest cur; // calculate MPE state cur.state = ia->findMaximum(); // calculate MPE value cur.value = fgs[ev].logScore( cur.state ); // update best MPE state and value if( cur.value > bestMPE[ev].value && !dai::isnan(cur.value) ) { // if this was exact inference, we are ready if( solver == 1 ) { ev2go.erase( ev2go.begin() + _ev ); _ev--; cur.ready = true; } if( verbose ) cout << " Replacing best MPE value so far (" << bestMPE[ev].value << ") with new value " << cur.value << endl; bestMPE[ev] = cur; improved = true; } else { if( verbose ) cout << " New MPE value " << cur.value << " not better than best one so far " << bestMPE[ev].value << endl; } } } // remove inference algorithm if( verbose ) cout << " Cleaning up..." << endl; if( !failed ) delete ia; // write current best output to stream if( improved ) { if( verbose ) cout << " Writing output..." << endl; if( first ) first = false; else os << "-BEGIN-" << endl; os << evid.size() << endl; for( size_t ev = 0; ev < evid.size(); ev++ ) { if( task == "PR" ) { // output probability of evidence os << bestPR[ev].value << endl; } else if( task == "MAR" ) { // output variable marginals os << bestMAR[ev].beliefs.size() << " "; for( size_t i = 0; i < bestMAR[ev].beliefs.size(); i++ ) { os << bestMAR[ev].beliefs[i].nrStates() << " "; for( size_t s = 0; s < bestMAR[ev].beliefs[i].nrStates(); s++ ) os << bestMAR[ev].beliefs[i][s] << " "; } os << endl; } else if( task == "MPE" ) { // output MPE state os << fgs[ev].nrVars() << " "; for( size_t i = 0; i < fgs[ev].nrVars(); i++ ) os << bestMPE[ev].state[i] << " "; os << endl; } } os.flush(); } if( verbose ) cout << " Done..." << endl; if( !improved ) subsolver++; if( improved || subsolver >= nrsubsolvers[solver] || couldBeGrid ) { subsolver = 0; _ev++; } } if( task == "MPE" && solver == 2 && (toc() - starttic) < UAI_time && MPEdamping != 0.0 ) { MPEdamping /= 2.0; solver--; // repeat this one } if( ev2go.size() == 0 ) break; } // close output file if( verbose ) cout << "Closing output file..." << endl; os.close(); if( verbose ) cout << "Done!" << endl; } return 0; } libDAI-0.2.7/examples/example_sprinkler_gibbs.cpp0000644000263000017630000000466211433220723020701 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ #include #include #include #include #include using namespace std; using namespace dai; int main() { // This example program illustrates how to use Gibbs sampling // to sample from a joint probability distribution described // by a factor graph, using the sprinkler network example discussed at // http://www.cs.ubc.ca/~murphyk/Bayes/bnintro.html // // The file sprinkler.fg has to be generated by first running // example_sprinkler // Read the factorgraph from the file FactorGraph SprinklerNetwork; SprinklerNetwork.ReadFromFile( "sprinkler.fg" ); cout << "Sprinkler network read from sprinkler.fg" << endl; // Output some information about the factorgraph cout << SprinklerNetwork.nrVars() << " variables" << endl; cout << SprinklerNetwork.nrFactors() << " factors" << endl; // Prepare a Gibbs sampler PropertySet gibbsProps; gibbsProps.set("iters", size_t(100)); // number of Gibbs sampler iterations gibbsProps.set("burnin", size_t(0)); gibbsProps.set("verbose", size_t(0)); Gibbs gibbsSampler( SprinklerNetwork, gibbsProps ); // Open a .tab file for writing ofstream outfile; outfile.open( "sprinkler.tab" ); if( !outfile.is_open() ) throw "Cannot write to file!"; // Write header (consisting of variable labels) for( size_t i = 0; i < SprinklerNetwork.nrVars(); i++ ) outfile << (i == 0 ? "" : "\t") << SprinklerNetwork.var(i).label(); outfile << endl << endl; // Draw samples from joint distribution using Gibbs sampling // and write them to the .tab file size_t nrSamples = 1000; std::vector state; for( size_t t = 0; t < nrSamples; t++ ) { gibbsSampler.run(); state = gibbsSampler.state(); for( size_t i = 0; i < state.size(); i++ ) outfile << (i == 0 ? "" : "\t") << state[i]; outfile << endl; } cout << nrSamples << " samples written to sprinkler.tab" << endl; // Close the .tab file outfile.close(); return 0; } libDAI-0.2.7/include/0000755000263000017630000000000011433220723013100 5ustar jorismkyblibDAI-0.2.7/include/dai/0000755000263000017630000000000011433220723013635 5ustar jorismkyblibDAI-0.2.7/include/dai/decmap.h0000644000263000017630000000632211433220723015242 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ /// \file /// \brief Defines class DecMAP, which constructs a MAP state by decimation #ifndef __defined_libdai_decmap_h #define __defined_libdai_decmap_h #include namespace dai { /// Approximate inference algorithm DecMAP, which constructs a MAP state by decimation /** Decimation involves repeating the following two steps until no free variables remain: * - run an approximate inference algorithm, * - clamp the factor with the lowest entropy to its most probable state */ class DecMAP : public DAIAlgFG { private: /// Stores the final MAP state std::vector _state; /// Stores the log probability of the MAP state Real _logp; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for DecMAP struct Properties { /// Verbosity (amount of output sent to stderr) size_t verbose; /// Complete or partial reinitialization of clamped subgraphs? bool reinit; /// Name of the algorithm used to calculate the beliefs on clamped subgraphs std::string ianame; /// Parameters for the algorithm used to calculate the beliefs on clamped subgraphs PropertySet iaopts; } props; /// Name of this inference algorithm static const char *Name; public: /// Default constructor DecMAP() : DAIAlgFG(), _state(), _logp(), _maxdiff(), _iters(), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ DecMAP( const FactorGraph &fg, const PropertySet &opts ); /// \name General InfAlg interface //@{ virtual DecMAP* clone() const { return new DecMAP(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &/*vs*/ ) const; virtual Factor beliefV( size_t i ) const; virtual Factor beliefF( size_t I ) const { return belief( factor(I).vars() ); } virtual std::vector beliefs() const; virtual Real logZ() const { return _logp; } virtual std::vector findMaximum() const { return _state; } virtual void init() { _maxdiff = 0.0; _iters = 0; } virtual void init( const VarSet &/*ns*/ ) { init(); } virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/regiongraph.h0000644000263000017630000002720311433220723016317 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs. #ifndef __defined_libdai_regiongraph_h #define __defined_libdai_regiongraph_h #include #include #include #include namespace dai { /// A Region is a set of variables with a counting number class Region : public VarSet { private: /// Counting number Real _c; public: /// Default constructor Region() : VarSet(), _c(1.0) {} /// Construct from a set of variables and a counting number Region( const VarSet& x, Real c ) : VarSet(x), _c(c) {} /// Returns constant reference to counting number const Real& c() const { return _c; } /// Returns reference to counting number Real& c() { return _c; } }; /// An FRegion is a factor with a counting number class FRegion : public Factor { private: /// Counting number Real _c; public: /// Default constructor FRegion() : Factor(), _c(1.0) {} /// Constructs from a factor and a counting number FRegion( const Factor& x, Real c ) : Factor(x), _c(c) {} /// Returns constant reference to counting number const Real& c() const { return _c; } /// Returns reference to counting number Real& c() { return _c; } }; /// A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph /** A RegionGraph inherits from a FactorGraph and adds additional structure in the form of a "region graph". Our definition of region graph * is inspired by [\ref HAK03], which is less general than the definition given in [\ref YFW05]. * * The extra structure described by a RegionGraph compared with that described by a FactorGraph is: * - a set of outer regions (indexed by \f$\alpha\f$), where each outer region consists of * - a factor defined on a subset of variables * - a counting number * - a set of inner regions (indexed by \f$\beta\f$), where each inner region consists of * - a subset of variables * - a counting number * - edges between inner and outer regions * * Each factor in the factor graph belongs to an outer region; normally, the factor contents * of an outer region would be the product of all the factors that belong to that region. * \idea Generalize the definition of region graphs to the one given in [\ref YFW05], i.e., replace * the current implementation which uses a BipartiteGraph with one that uses a DAG. * \idea The outer regions are products of factors; right now, this product is constantly cached: * changing one factor results in an update of all relevant outer regions. This may not be the most * efficient approach; an alternative would be to only precompute the factor products at the start * of an inference algorithm - e.g., in init(). This has the additional advantage that FactorGraph e can offer write access to its factors. */ class RegionGraph : public FactorGraph { protected: /// Stores the neighborhood structure BipartiteGraph _G; /// The outer regions (corresponding to nodes of type 1) std::vector _ORs; /// The inner regions (corresponding to nodes of type 2) std::vector _IRs; /// Stores for each factor index the index of the outer region it belongs to std::vector _fac2OR; public: /// \name Constructors and destructors //@{ /// Default constructor RegionGraph() : FactorGraph(), _G(), _ORs(), _IRs(), _fac2OR() {} /// Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions and a vector of edges /** The counting numbers for the outer regions are set to 1. */ RegionGraph( const FactorGraph& fg, const std::vector& ors, const std::vector& irs, const std::vector >& edges ) : FactorGraph(), _G(), _ORs(), _IRs(), _fac2OR() { construct( fg, ors, irs, edges ); // Check counting numbers #ifdef DAI_DEBUG checkCountingNumbers(); #endif } /// Constructs a region graph from a factor graph and a vector of outer clusters (CVM style) /** The region graph is constructed as in the Cluster Variation Method. * * The outer regions have as variable subsets the clusters specified in \a cl. * Each factor in the factor graph \a fg is assigned to one of the outer regions. * Each outer region gets counting number 1. * * The inner regions are (repeated) intersections of outer regions. * An inner and an outer region are connected if the variables in the inner region form a * subset of the variables in the outer region. The counting numbers for the inner * regions are calculated by calcCountingNumbers() and satisfy the Moebius formula. */ RegionGraph( const FactorGraph& fg, const std::vector& cl ) : FactorGraph(), _G(), _ORs(), _IRs(), _fac2OR() { constructCVM( fg, cl ); // Check counting numbers #ifdef DAI_DEBUG checkCountingNumbers(); #endif } /// Clone \c *this (virtual copy constructor) virtual RegionGraph* clone() const { return new RegionGraph(*this); } //@} /// \name Accessors and mutators //@{ /// Returns number of outer regions size_t nrORs() const { return _ORs.size(); } /// Returns number of inner regions size_t nrIRs() const { return _IRs.size(); } /// Returns constant reference to outer region \a alpha const FRegion& OR( size_t alpha ) const { DAI_DEBASSERT( alpha < nrORs() ); return _ORs[alpha]; } /// Returns reference to outer region \a alpha FRegion& OR( size_t alpha ) { DAI_DEBASSERT( alpha < nrORs() ); return _ORs[alpha]; } /// Returns constant reference to inner region \a beta const Region& IR( size_t beta ) const { DAI_DEBASSERT( beta < nrIRs() ); return _IRs[beta]; } /// Returns reference to inner region \a beta Region& IR( size_t beta ) { DAI_DEBASSERT( beta < nrIRs() ); return _IRs[beta]; } /// Returns the index of the outer region to which the \a I 'th factor corresponds size_t fac2OR( size_t I ) const { DAI_DEBASSERT( I < nrFactors() ); DAI_DEBASSERT( I < _fac2OR.size() ); return _fac2OR[I]; } /// Returns constant reference to the neighbors of outer region \a alpha const Neighbors& nbOR( size_t alpha ) const { return _G.nb1(alpha); } /// Returns constant reference to the neighbors of inner region \a beta const Neighbors& nbIR( size_t beta ) const { return _G.nb2(beta); } /// Returns DAG structure of the region graph /** \note Currently, the DAG is implemented as a BipartiteGraph; the nodes of * type 1 are the outer regions, the nodes of type 2 the inner regions, and * edges correspond with arrows from nodes of type 1 to type 2. */ const BipartiteGraph& DAG() const { return _G; } //@} /// \name Queries //@{ /// Check whether the counting numbers are valid /** Counting numbers are said to be (variable) valid if for each variable \f$x\f$, * \f[\sum_{\alpha \ni x} c_\alpha + \sum_{\beta \ni x} c_\beta = 1\f] * or in words, if the sum of the counting numbers of the regions * that contain the variable equals one. */ bool checkCountingNumbers() const; //@} /// \name Operations //@{ /// Set the content of the \a I 'th factor and make a backup of its old content if \a backup == \c true virtual void setFactor( size_t I, const Factor& newFactor, bool backup = false ) { FactorGraph::setFactor( I, newFactor, backup ); recomputeOR( I ); } /// Set the contents of all factors as specified by \a facs and make a backup of the old contents if \a backup == \c true virtual void setFactors( const std::map& facs, bool backup = false ) { FactorGraph::setFactors( facs, backup ); VarSet ns; for( std::map::const_iterator fac = facs.begin(); fac != facs.end(); fac++ ) ns |= fac->second.vars(); recomputeORs( ns ); } //@} /// \name Input/output //@{ /// Reads a region graph from a file /** \note Not implemented yet */ virtual void ReadFromFile( const char* /*filename*/ ) { DAI_THROW(NOT_IMPLEMENTED); } /// Writes a factor graph to a file /** \note Not implemented yet */ virtual void WriteToFile( const char* /*filename*/, size_t /*precision*/=15 ) const { DAI_THROW(NOT_IMPLEMENTED); } /// Writes a RegionGraph to an output stream friend std::ostream& operator<< ( std::ostream& os, const RegionGraph& rg ); /// Writes a region graph to a GraphViz .dot file /** \note Not implemented yet */ virtual void printDot( std::ostream& /*os*/ ) const { DAI_THROW(NOT_IMPLEMENTED); } //@} protected: /// Helper function for constructors void construct( const FactorGraph& fg, const std::vector& ors, const std::vector& irs, const std::vector >& edges ); /// Helper function for constructors (CVM style) void constructCVM( const FactorGraph& fg, const std::vector& cl, size_t verbose=0 ); /// Recompute all outer regions /** The factor contents of each outer region is set to the product of the factors belonging to that region. */ void recomputeORs(); /// Recompute all outer regions involving the variables in \a vs /** The factor contents of each outer region involving at least one of the variables in \a vs is set to the product of the factors belonging to that region. */ void recomputeORs( const VarSet& vs ); /// Recompute all outer regions involving factor \a I /** The factor contents of each outer region involving the \a I 'th factor is set to the product of the factors belonging to that region. */ void recomputeOR( size_t I ); /// Calculates counting numbers of inner regions based upon counting numbers of outer regions /** The counting numbers of the inner regions are set using the Moebius inversion formula: * \f[ c_\beta := 1 - \sum_{\gamma \in \mathrm{an}(\beta)} c_\gamma \f] * where \f$\mathrm{an}(\beta)\f$ are the ancestors of inner region \f$\beta\f$ according to * the partial ordering induced by the subset relation (i.e., a region is a child of another * region if its variables are a subset of the variables of its parent region). */ void calcCVMCountingNumbers(); }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/factorgraph.h0000644000263000017630000003674311433220723016323 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields) #ifndef __defined_libdai_factorgraph_h #define __defined_libdai_factorgraph_h #include #include #include #include #include namespace dai { /// Represents a factor graph. /** Both Bayesian Networks and Markov random fields can be represented in a * unifying representation, called factor graph [\ref KFL01], * implemented in libDAI by the FactorGraph class. * * Consider a probability distribution over \f$N\f$ discrete random variables * \f$x_0,x_1,\dots,x_{N-1}\f$ that factorizes as a product of \f$M\f$ factors, each of * which depends on some subset of the variables: * \f[ * P(x_0,x_1,\dots,x_{N-1}) = \frac{1}{Z} \prod_{I=0}^{M-1} f_I(x_I), \qquad * Z = \sum_{x_0}\dots\sum_{x_{N-1}} \prod_{I=0}^{M-1} f_I(X_I). * \f] * Each factor \f$f_I\f$ is a function from an associated subset * of variables \f$X_I \subset \{x_0,x_1,\dots,x_{N-1}\}\f$ to the nonnegative * real numbers. * * For a Bayesian network, each factor corresponds to a (conditional) * probability table, whereas for a Markov random field, each factor * corresponds to a maximal clique of the undirected graph. * * Factor graphs explicitly express the factorization structure of the * corresponding probability distribution. A factor graph is a bipartite graph, * containing variable nodes and factor nodes, and an edge between a variable * node and a factor node if the corresponding factor depends on that variable. * In libDAI, this structure is represented by a BipartiteGraph. * * So basically, a FactorGraph consists of a BipartiteGraph, a vector of Var 's * and a vector of TFactor 's. * * \idea Alternative implementation of undo factor changes: the only things that have to be * undone currently are setting a factor to 1 and setting a factor to a Kronecker delta. This * could also be implemented in the TFactor itself, which could maintain its state * (ones/delta/full) and act accordingly. Update: it seems that the proposed functionality * would not be enough for CBP, for which it would make more sense to add more levels of * backup/restore. * * \todo Write a method that applies evidence (should we represent evidence as a map or as a map?) */ class FactorGraph { private: /// Stores the neighborhood structure BipartiteGraph _G; /// Stores the variables std::vector _vars; /// Stores the factors std::vector _factors; /// Stores backups of some factors std::map _backup; public: /// \name Constructors and destructors //@{ /// Default constructor FactorGraph() : _G(), _vars(), _factors(), _backup() {} /// Constructs a factor graph from a vector of factors FactorGraph( const std::vector& P ); /// Constructs a factor graph from given factor and variable iterators /** \tparam FactorInputIterator Iterates over instances of type dai::Factor * \tparam VarInputIterator Iterates over instances of type Var * \pre Assumes that the set of variables in [\a varBegin, \a varEnd) is the union of the variables in the factors in [\a facBegin, \a facEnd) */ template FactorGraph(FactorInputIterator facBegin, FactorInputIterator facEnd, VarInputIterator varBegin, VarInputIterator varEnd, size_t nrFacHint = 0, size_t nrVarHint = 0 ); /// Destructor virtual ~FactorGraph() {} /// Virtual copy constructor virtual FactorGraph* clone() const { return new FactorGraph(*this); } //@} /// \name Accessors and mutators //@{ /// Returns constant reference the \a i 'th variable const Var& var( size_t i ) const { DAI_DEBASSERT( i < nrVars() ); return _vars[i]; } /// Returns constant reference to all variables const std::vector& vars() const { return _vars; } /// Returns constant reference to \a I 'th factor const Factor& factor( size_t I ) const { DAI_DEBASSERT( I < nrFactors() ); return _factors[I]; } /// Returns constant reference to all factors const std::vector& factors() const { return _factors; } /// Returns constant reference to neighbors of the \a i 'th variable const Neighbors& nbV( size_t i ) const { return _G.nb1(i); } /// Returns constant reference to neighbors of the \a I 'th factor const Neighbors& nbF( size_t I ) const { return _G.nb2(I); } /// Returns constant reference to the \a _I 'th neighbor of the \a i 'th variable const Neighbor& nbV( size_t i, size_t _I ) const { return _G.nb1(i)[_I]; } /// Returns constant reference to the \a _i 'th neighbor of the \a I 'th factor const Neighbor& nbF( size_t I, size_t _i ) const { return _G.nb2(I)[_i]; } //@} /// \name Queries //@{ /// Returns neighborhood structure const BipartiteGraph& bipGraph() const { return _G; } /// Returns number of variables size_t nrVars() const { return vars().size(); } /// Returns number of factors size_t nrFactors() const { return factors().size(); } /// Calculates number of edges /** \note Time complexity: O(nrVars()) */ size_t nrEdges() const { return _G.nrEdges(); } /// Returns the index of a particular variable /** \note Time complexity: O(nrVars()) * \throw OBJECT_NOT_FOUND if the variable is not part of this factor graph */ size_t findVar( const Var& n ) const { size_t i = find( vars().begin(), vars().end(), n ) - vars().begin(); if( i == nrVars() ) DAI_THROW(OBJECT_NOT_FOUND); return i; } /// Returns a set of indexes corresponding to a set of variables /** \note Time complexity: O( nrVars() * ns.size() ) * \throw OBJECT_NOT_FOUND if one of the variables is not part of this factor graph */ SmallSet findVars( const VarSet& ns ) const { SmallSet result; for( VarSet::const_iterator n = ns.begin(); n != ns.end(); n++ ) result.insert( findVar( *n ) ); return result; } /// Returns index of the first factor that depends on the variables /** \note Time complexity: O(nrFactors()) * \throw OBJECT_NOT_FOUND if no factor in this factor graph depends on those variables */ size_t findFactor( const VarSet& ns ) const { size_t I; for( I = 0; I < nrFactors(); I++ ) if( factor(I).vars() == ns ) break; if( I == nrFactors() ) DAI_THROW(OBJECT_NOT_FOUND); return I; } /// Return all variables that occur in a factor involving the \a i 'th variable, itself included VarSet Delta( size_t i ) const; /// Return all variables that occur in a factor involving some variable in \a vs, \a vs itself included VarSet Delta( const VarSet& vs ) const; /// Return all variables that occur in a factor involving the \a i 'th variable, itself excluded VarSet delta( size_t i ) const { return( Delta( i ) / var( i ) ); } /// Return all variables that occur in a factor involving some variable in \a vs, \a vs itself excluded VarSet delta( const VarSet& vs ) const { return Delta( vs ) / vs; } /// Returns \c true if the factor graph is connected bool isConnected() const { return _G.isConnected(); } /// Returns \c true if the factor graph is a tree (i.e., has no cycles and is connected) bool isTree() const { return _G.isTree(); } /// Returns \c true if each factor depends on at most two variables bool isPairwise() const; /// Returns \c true if each variable has only two possible values bool isBinary() const; /// Constructs the corresponding Markov graph /** \note The Markov graph has the variables as nodes and an edge * between two variables if and only if the variables share a factor. */ GraphAL MarkovGraph() const; /// Returns whether the \a I 'th factor is maximal /** \note A factor (domain) is \a maximal if and only if it is not a * strict subset of another factor domain. */ bool isMaximal( size_t I ) const; /// Returns the index of a maximal factor that contains the \a I 'th factor /** \note A factor (domain) is \a maximal if and only if it is not a * strict subset of another factor domain. */ size_t maximalFactor( size_t I ) const; /// Returns the maximal factor domains in this factorgraph /** \note A factor domain is \a maximal if and only if it is not a * strict subset of another factor domain. */ std::vector maximalFactorDomains() const; /// Evaluates the log score (i.e., minus the energy) of the joint configuration \a statevec Real logScore( const std::vector& statevec ); //@} /// \name Backup/restore mechanism for factors //@{ /// Set the content of the \a I 'th factor and make a backup of its old content if \a backup == \c true virtual void setFactor( size_t I, const Factor& newFactor, bool backup = false ) { DAI_ASSERT( newFactor.vars() == factor(I).vars() ); if( backup ) backupFactor( I ); _factors[I] = newFactor; } /// Set the contents of all factors as specified by \a facs and make a backup of the old contents if \a backup == \c true virtual void setFactors( const std::map& facs, bool backup = false ) { for( std::map::const_iterator fac = facs.begin(); fac != facs.end(); fac++ ) { if( backup ) backupFactor( fac->first ); setFactor( fac->first, fac->second ); } } /// Makes a backup of the \a I 'th factor /** \throw MULTIPLE_UNDO if a backup already exists */ void backupFactor( size_t I ); /// Restores the \a I 'th factor from the backup (it should be backed up first) /** \throw OBJECT_NOT_FOUND if a backup does not exist */ void restoreFactor( size_t I ); /// Backup the factors specified by indices in \a facs /** \throw MULTIPLE_UNDO if a backup already exists */ virtual void backupFactors( const std::set& facs ); /// Restore all factors to the backup copies virtual void restoreFactors(); /// Makes a backup of all factors connected to a set of variables /** \throw MULTIPLE_UNDO if a backup already exists */ void backupFactors( const VarSet& ns ); /// Restores all factors connected to a set of variables from their backups void restoreFactors( const VarSet& ns ); //@} /// \name Transformations //@{ /// Returns a copy of \c *this, where all factors that are subsumed by some larger factor are merged with the larger factors. FactorGraph maximalFactors() const; /// Returns a copy of \c *this, where the \a i 'th variable has been clamped to value \a x /** \note This version changes the factor graph structure and thus returns a newly constructed FactorGraph * and keeps the current one constant, contrary to clamp() */ FactorGraph clamped( size_t i, size_t x ) const; //@} /// \name Operations //@{ /// Clamp the \a i 'th variable to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{x_i, x}\f$) /** If \a backup == \c true, make a backup of all factors that are changed */ virtual void clamp( size_t i, size_t x, bool backup = false ); /// Clamp a variable in a factor graph to have one out of a list of values /** If \a backup == \c true, make a backup of all factors that are changed */ void clampVar( size_t i, const std::vector& xis, bool backup = false ); /// Clamp a factor in a factor graph to have one out of a list of values /** If \a backup == \c true, make a backup of all factors that are changed */ void clampFactor( size_t I, const std::vector& xIs, bool backup = false ); /// Set all factors interacting with the \a i 'th variable to 1 /** If \a backup == \c true, make a backup of all factors that are changed */ virtual void makeCavity( size_t i, bool backup = false ); //@} /// \name Input/Output //@{ /// Reads a factor graph from a file /** \see \ref fileformats-factorgraph * \throw CANNOT_READ_FILE if the file cannot be opened * \throw INVALID_FACTORGRAPH_FILE if the file is not valid */ virtual void ReadFromFile( const char *filename ); /// Writes a factor graph to a file /** \see \ref fileformats-factorgraph * \throw CANNOT_WRITE_FILE if the file cannot be written */ virtual void WriteToFile( const char *filename, size_t precision=15 ) const; /// Writes a factor graph to an output stream /** \see \ref fileformats-factorgraph */ friend std::ostream& operator<< (std::ostream& os, const FactorGraph& fg ); /// Reads a factor graph from an input stream /** \see \ref fileformats-factorgraph * \throw INVALID_FACTORGRAPH_FILE if the input stream is not valid */ friend std::istream& operator>> (std::istream& is, FactorGraph& fg ); /// Writes a factor graph to a GraphViz .dot file virtual void printDot( std::ostream& os ) const; //@} private: /// Part of constructors (creates edges, neighbors and adjacency matrix) void constructGraph( size_t nrEdges ); }; template FactorGraph::FactorGraph(FactorInputIterator facBegin, FactorInputIterator facEnd, VarInputIterator varBegin, VarInputIterator varEnd, size_t nrFacHint, size_t nrVarHint ) : _G(), _backup() { // add factors size_t nrEdges = 0; _factors.reserve( nrFacHint ); for( FactorInputIterator p2 = facBegin; p2 != facEnd; ++p2 ) { _factors.push_back( *p2 ); nrEdges += p2->vars().size(); } // add variables _vars.reserve( nrVarHint ); for( VarInputIterator p1 = varBegin; p1 != varEnd; ++p1 ) _vars.push_back( *p1 ); // create graph structure constructGraph( nrEdges ); } /** \example example_sprinkler.cpp * This example illustrates how to manually construct a factor graph and * write it to a file. */ } // end of namespace dai #endif libDAI-0.2.7/include/dai/mr.h0000644000263000017630000001601511433220723014427 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2007 Bastian Wemmenhove * Copyright (C) 2007-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo #ifndef __defined_libdai_mr_h #define __defined_libdai_mr_h #include #include #include #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm by Montanari and Rizzo [\ref MoR05] /** \author Bastian Wemmenhove wrote the original implementation before it was merged into libDAI */ class MR : public DAIAlgFG { private: /// Is the underlying factor graph supported? bool supported; /// The interaction graph (Markov graph) GraphAL G; /// tJ[i][_j] is the hyperbolic tangent of the interaction between spin \a i and its neighbour G.nb(i,_j) std::vector > tJ; /// theta[i] is the local field on spin \a i std::vector theta; /// M[i][_j] is \f$ M^{(i)}_j \f$ std::vector > M; /// Cavity correlations std::vector > > cors; /// Type used for managing a subset of neighbors typedef boost::dynamic_bitset<> sub_nb; /// Magnetizations std::vector Mag; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for MR struct Properties { /// Enumeration of different types of update equations /** The possible update equations are: * - FULL full updates, slow but accurate * - LINEAR linearized updates, faster but less accurate */ DAI_ENUM(UpdateType,FULL,LINEAR); /// Enumeration of different ways of initializing the cavity correlations /** The possible cavity initializations are: * - RESPPROP using response propagation ("linear response") * - CLAMPING using clamping and BP * - EXACT using JunctionTree */ DAI_ENUM(InitType,RESPPROP,CLAMPING,EXACT); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Tolerance for convergence test Real tol; /// Update equations UpdateType updates; /// How to initialize the cavity correlations InitType inits; } props; /// Name of this inference method static const char *Name; public: /// Default constructor MR() : DAIAlgFG(), supported(), G(), tJ(), theta(), M(), cors(), Mag(), _maxdiff(), _iters(), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties * \note This implementation only deals with binary variables and pairwise interactions. * \throw NOT_IMPLEMENTED if \a fg has factors depending on three or more variables or has variables with more than two possible states. */ MR( const FactorGraph &fg, const PropertySet &opts ); /// \name General InfAlg interface //@{ virtual MR* clone() const { return new MR(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &/*vs*/ ) const; virtual Factor beliefV( size_t i ) const; virtual std::vector beliefs() const; virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual void init() {} virtual void init( const VarSet &/*ns*/ ) { DAI_THROW(NOT_IMPLEMENTED); } virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} private: /// Initialize cors Real calcCavityCorrelations(); /// Iterate update equations for cavity fields void propagateCavityFields(); /// Calculate magnetizations void calcMagnetizations(); /// Calculate the product of all tJ[i][_j] for _j in A /** \param i variable index * \param A subset of neighbors of variable \a i */ Real _tJ(size_t i, sub_nb A); /// Calculate \f$ \Omega^{(i)}_{j,l} \f$ as defined in [\ref MoR05] eqn. (2.15) Real Omega(size_t i, size_t _j, size_t _l); /// Calculate \f$ T^{(i)}_A \f$ as defined in [\ref MoR05] eqn. (2.17) with \f$ A = \{l_1,l_2,\dots\} \f$ /** \param i variable index * \param A subset of neighbors of variable \a i */ Real T(size_t i, sub_nb A); /// Calculates \f$ T^{(i)}_j \f$ where \a j is the \a _j 'th neighbor of \a i Real T(size_t i, size_t _j); /// Calculates \f$ \Gamma^{(i)}_{j,l_1l_2} \f$ as defined in [\ref MoR05] eqn. (2.16) Real Gamma(size_t i, size_t _j, size_t _l1, size_t _l2); /// Calculates \f$ \Gamma^{(i)}_{l_1l_2} \f$ as defined in [\ref MoK07] on page 1141 Real Gamma(size_t i, size_t _l1, size_t _l2); /// Approximates moments of variables in \a A /** Calculate the moment of variables in \a A from M and cors, neglecting higher order cumulants, * defined as the sum over all partitions of A into subsets of cardinality two at most of the * product of the cumulants (either first order, i.e. M, or second order, i.e. cors) of the * entries of the partitions. * * \param i variable index * \param A subset of neighbors of variable \a i */ Real appM(size_t i, sub_nb A); /// Calculate sum over all even/odd subsets B of \a A of _tJ(j,B) appM(j,B) /** \param j variable index * \param A subset of neighbors of variable \a j * \param sum_even on return, will contain the sum over all even subsets * \param sum_odd on return, will contain the sum over all odd subsets */ void sum_subs(size_t j, sub_nb A, Real *sum_even, Real *sum_odd); }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/properties.h0000644000263000017630000002427411433220723016213 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms #ifndef __defined_libdai_properties_h #define __defined_libdai_properties_h #include #include #include #include #include #include #include #include #include namespace dai { /// Type of the key of a Property typedef std::string PropertyKey; /// Type of the value of a Property typedef boost::any PropertyValue; /// A Property is a pair of a key and a corresponding value typedef std::pair Property; /// Writes a Property object (key-value pair) to an output stream /** \note Not all value types are automatically supported; if a type is unknown, an * UNKNOWN_PROPERTY_TYPE exception is thrown. Adding support for a new type can * be done by changing this function body. */ std::ostream& operator<< ( std::ostream & os, const Property &p ); /// Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) /** Properties are used for specifying parameters of algorithms in a convenient way, where the values of * the parameters can be of different types (e.g., strings, doubles, integers, enums). A PropertySet is * an attempt to mimic the functionality of a Python dictionary object in C++, using the boost::any class. * * A PropertySet can be converted to and from a string, using the following format: * * [key1=val1,key2=val2,...,keyn=valn] * * That is, * - the whole PropertySet is wrapped in square brackets ("[", "]") * - all properties in the PropertySet are seperated by a comma (",") * - each Property consists of: * - the name of the key * - an equality sign ("=") * - its value (represented as a string) * * Also, a PropertySet provides functionality for converting the representation of * individual values from some arbitrary type to and from std::string. * * \note Not all types are automatically supported; if a type is unknown, an UNKNOWN_PROPERTY_TYPE * exception is thrown. Adding support for a new type can be done in the body of the * operator<<(std::ostream &, const Property &). */ class PropertySet : private std::map { public: /// \name Constructors and destructors //@{ /// Default constructor PropertySet() {} /// Construct from a string /** \param s string in the format "[key1=val1,key2=val2,...,keyn=valn]" */ PropertySet( const std::string& s ) { std::stringstream ss; ss << s; ss >> *this; } //@} /// \name Setting property keys/values //@{ /// Sets a property (a key \a key with a corresponding value \a val) PropertySet& set( const PropertyKey& key, const PropertyValue& val ) { this->operator[](key) = val; return *this; } /// Set properties according to \a newProps, overriding properties that already exist with new values PropertySet& set( const PropertySet& newProps ) { const std::map *m = &newProps; foreach(value_type i, *m) set( i.first, i.second ); return *this; } /// Shorthand for (temporarily) adding properties /** \par Example: \code PropertySet p()("method","BP")("verbose",1)("tol",1e-9) \endcode */ PropertySet operator()( const PropertyKey& key, const PropertyValue& val ) const { PropertySet copy = *this; return copy.set(key,val); } /// Sets a property (a key \a key with a corresponding value \a val, which is first converted from \a ValueType to string) /** The implementation makes use of boost::lexical_cast. * \tparam ValueType Type from which the value should be cast * \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done */ template PropertySet& setAsString( const PropertyKey& key, const ValueType& val ) { try { return set( key, boost::lexical_cast(val) ); } catch( boost::bad_lexical_cast & ) { DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' to string."); } } /// Converts the type of the property value corresponding with \a key from string to \a ValueType (if necessary) /** The implementation makes use of boost::lexical_cast * \tparam ValueType Type to which the value should be cast * \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done */ template void convertTo( const PropertyKey& key ) { PropertyValue val = get(key); if( val.type() != typeid(ValueType) ) { DAI_ASSERT( val.type() == typeid(std::string) ); try { set(key, boost::lexical_cast(getAs(key))); } catch(boost::bad_lexical_cast &) { DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' from string to desired type."); } } } //@} //@} /// \name Queries //@{ /// Return number of key-value pairs size_t size() const { return std::map::size(); } /// Removes all key-value pairs void clear() { std::map::clear(); } /// Removes key-value pair with given \a key size_t erase( const PropertyKey &key ) { return std::map::erase( key ); } /// Check if a property with the given \a key is defined bool hasKey( const PropertyKey& key ) const { PropertySet::const_iterator x = find(key); return (x != this->end()); } /// Returns a set containing all keys std::set keys() const { std::set res; const_iterator i; for( i = begin(); i != end(); i++ ) res.insert( i->first ); return res; } /// Gets the value corresponding to \a key /** \throw OBJECT_NOT_FOUND if the key cannot be found in \c *this */ const PropertyValue& get( const PropertyKey& key ) const { PropertySet::const_iterator x = find(key); if( x == this->end() ) DAI_THROWE(OBJECT_NOT_FOUND,"PropertySet::get cannot find property '" + key + "'"); return x->second; } /// Gets the value corresponding to \a key, cast to \a ValueType /** \tparam ValueType Type to which the value should be cast * \throw OBJECT_NOT_FOUND if the key cannot be found in \c *this * \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done */ template ValueType getAs( const PropertyKey& key ) const { try { return boost::any_cast(get(key)); } catch( const boost::bad_any_cast & ) { DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' to desired type."); return ValueType(); } } /// Gets the value corresponding to \a key, cast to \a ValueType, converting from a string if necessary /** If the type of the value is already equal to \a ValueType, no conversion is done. * Otherwise, the type of the value should be a std::string, in which case boost::lexical_cast is * used to convert this to \a ValueType. * \tparam ValueType Type to which the value should be cast/converted * \throw OBJECT_NOT_FOUND if the key cannot be found in \c *this * \throw IMPOSSIBLE_TYPECAST if the type cast cannot be done */ template ValueType getStringAs( const PropertyKey& key ) const { PropertyValue val = get(key); if( val.type() == typeid(ValueType) ) { return boost::any_cast(val); } else if( val.type() == typeid(std::string) ) { try { return boost::lexical_cast(getAs(key)); } catch(boost::bad_lexical_cast &) { DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' from string to desired type."); } } else DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' from string to desired type."); return ValueType(); } //@} /// \name Input/output //@{ /// Writes a PropertySet object to an output stream. /** It uses the format "[key1=val1,key2=val2,...,keyn=valn]". * \note Only a subset of all possible types is supported (see the implementation of this function). * Adding support for more types has to be done by hand. * \throw UNKNOWN_PROPERTY_TYPE if the type of a property value is not supported. */ friend std::ostream& operator<< ( std::ostream& os, const PropertySet& ps ); /// Reads a PropertySet object from an input stream. /** It expects a string in the format "[key1=val1,key2=val2,...,keyn=valn]". * Values are stored as strings. * \throw MALFORMED_PROPERTY if the string is not in the expected format */ friend std::istream& operator>> ( std::istream& is, PropertySet& ps ); //@} }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/util.h0000644000263000017630000001625311433220723014772 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines general utility functions and adds an abstraction layer for platform-dependent functionality #ifndef __defined_libdai_util_h #define __defined_libdai_util_h #include #include #include #include #include #include #include #include #include #include #include #if defined(WINDOWS) #include // only present in boost 1.37 and higher #elif defined(CYGWIN) #include // only present in boost 1.37 and higher #elif defined(MACOSX) #include // only present in boost 1.37 and higher #else #include // only present in modern GCC distributions #endif /// An alias to the BOOST_FOREACH macro from the boost::foreach library #define foreach BOOST_FOREACH #ifdef DAI_DEBUG /// \brief "Print variable". Prints the text of an expression, followed by its value (only if DAI_DEBUG is defined) /** * Useful debugging macro to see what your code is doing. * Example: \code DAI_PV(3+4) \endcode * Output: \code 3+4= 7 \endcode */ #define DAI_PV(x) do {std::cerr << #x "= " << (x) << std::endl;} while(0) /// "Debugging message": Prints a message (only if DAI_DEBUG is defined) #define DAI_DMSG(str) do {std::cerr << str << std::endl;} while(0) #else #define DAI_PV(x) do {} while(0) #define DAI_DMSG(str) do {} while(0) #endif /// Macro to write message \a stmt to \c std::cerr if \a props.verbose >= \a n #define DAI_IFVERB(n, stmt) if(props.verbose>=n) { std::cerr << stmt; } #ifdef WINDOWS /// Returns inverse hyperbolic tangent of argument double atanh( double x ); /// Returns log(1+x) double log1p( double x ); /// Define INFINITY #define INFINITY (std::numeric_limits::infinity()) #endif namespace dai { /// Real number (alias for \c double, which could be changed to long double if necessary) typedef double Real; /// Returns true if argument is NAN (Not A Number) bool isnan( Real x ); /// Returns logarithm of \a x inline Real log( Real x ) { return std::log(x); } /// Returns logarithm of \a x, or 0 if \a x == 0 inline Real log0( Real x ) { return x ? std::log(x) : 0; } /// Returns exponent of \a x inline Real exp( Real x ) { return std::exp(x); } /// Returns \a to the power \a y inline Real pow( Real x, Real y ) { errno = 0; Real result = std::pow(x, y); DAI_DEBASSERT( errno == 0 ); return result; } /// hash_map is an alias for \c std::tr1::unordered_map. /** We use the (experimental) TR1 unordered_map implementation included in modern GCC distributions or in boost versions 1.37 and higher. */ template > class hash_map : public std::tr1::unordered_map {}; /// Returns wall clock time in seconds double toc(); /// Returns absolute value of \a t template inline T abs( const T &t ) { return (t < 0) ? (-t) : t; } /// Sets the random seed void rnd_seed( size_t seed ); /// Returns a real number, distributed uniformly on [0,1) Real rnd_uniform(); /// Returns a real number from a standard-normal distribution Real rnd_stdnormal(); /// Returns a random integer in interval [\a min, \a max] int rnd_int( int min, int max ); /// Returns a random integer in the half-open interval [0, \a n) inline int rnd( int n ) { return rnd_int( 0, n-1 ); } /// Converts a variable of type \a T to a \c std::string by using a \c boost::lexical_cast template std::string toString( const T& x ) { return boost::lexical_cast(x); } /// Converts a variable of type std::string to \a T by using a \c boost::lexical_cast template T fromString( const std::string& x ) { return boost::lexical_cast(x); } /// Writes a \c std::vector<> to a \c std::ostream template std::ostream& operator << (std::ostream& os, const std::vector & x) { os << "("; for( typename std::vector::const_iterator it = x.begin(); it != x.end(); it++ ) os << (it != x.begin() ? ", " : "") << *it; os << ")"; return os; } /// Writes a \c std::set<> to a \c std::ostream template std::ostream& operator << (std::ostream& os, const std::set & x) { os << "{"; for( typename std::set::const_iterator it = x.begin(); it != x.end(); it++ ) os << (it != x.begin() ? ", " : "") << *it; os << "}"; return os; } /// Writes a \c std::map<> to a \c std::ostream template std::ostream& operator << (std::ostream& os, const std::map & x) { os << "{"; for( typename std::map::const_iterator it = x.begin(); it != x.end(); it++ ) os << (it != x.begin() ? ", " : "") << it->first << "->" << it->second; os << "}"; return os; } /// Writes a \c std::pair<> to a \c std::ostream template std::ostream& operator << (std::ostream& os, const std::pair & x) { os << "(" << x.first << ", " << x.second << ")"; return os; } /// Concatenates two vectors template std::vector concat( const std::vector& u, const std::vector& v ) { std::vector w; w.reserve( u.size() + v.size() ); for( size_t i = 0; i < u.size(); i++ ) w.push_back( u[i] ); for( size_t i = 0; i < v.size(); i++ ) w.push_back( v[i] ); return w; } /// Split a string into tokens delimited by one of the characters in \a delim /** \param s the string to be split into tokens * \param singleDelim if \c true, any single delimiter forms a boundary between two tokens; * if \c false, a maximal group of consecutive delimiters forms a boundary between two tokens * \param delim delimiter characters */ std::vector tokenizeString( const std::string& s, bool singleDelim, const std::string& delim="\t\n" ); /// Enumerates different ways of normalizing a probability measure. /** * - NORMPROB means that the sum of all entries should be 1; * - NORMLINF means that the maximum absolute value of all entries should be 1. */ typedef enum { NORMPROB, NORMLINF } ProbNormType; /// Enumerates different distance measures between probability measures. /** * - DISTL1 is the \f$\ell_1\f$ distance (sum of absolute values of pointwise difference); * - DISTLINF is the \f$\ell_\infty\f$ distance (maximum absolute value of pointwise difference); * - DISTTV is the total variation distance (half of the \f$\ell_1\f$ distance); * - DISTKL is the Kullback-Leibler distance (\f$\sum_i p_i (\log p_i - \log q_i)\f$). * - DISTHEL is the Hellinger distance (\f$\frac{1}{2}\sum_i (\sqrt{p_i}-\sqrt{q_i})^2\f$). */ typedef enum { DISTL1, DISTLINF, DISTTV, DISTKL, DISTHEL } ProbDistType; } // end of namespace dai #endif libDAI-0.2.7/include/dai/trwbp.h0000644000263000017630000001272611433220723015154 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ /// \file /// \brief Defines class TRWBP, which implements Tree-Reweighted Belief Propagation #ifndef __defined_libdai_trwbp_h #define __defined_libdai_trwbp_h #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm "Tree-Reweighted Belief Propagation" [\ref WJW03] /** The Tree-Reweighted Belief Propagation algorithm is like Belief * Propagation, but associates each factor with a scale parameter. * which controls the divergence measure being minimized. * * The messages \f$m_{I\to i}(x_i)\f$ are passed from factors \f$I\f$ to variables \f$i\f$. * The update equation is given by: * \f[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \f] * After convergence, the variable beliefs are calculated by: * \f[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}^{c_I} \f] * and the factor beliefs are calculated by: * \f[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{c_I-1} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}^{c_J} \f] * The logarithm of the partition sum is approximated by: * \f[ \log Z = \sum_{I} \sum_{x_I} b_I(x_I) \big( \log f_I(x_I) - c_I \log b_I(x_I) \big) + \sum_{i} (c_i - 1) \sum_{x_i} b_i(x_i) \log b_i(x_i) \f] * where the variable weights are defined as * \f[ c_i := \sum_{I \in N_i} c_I \f] * * \note TRWBP is actually equivalent to FBP * \todo Merge code of FBP and TRWBP */ class TRWBP : public BP { protected: /// "Edge weights" (indexed by factor ID) /** In [\ref WJW03], only unary or pairwise factors are considered. * Here we are more general by having a weight for each factor in the * factor graph. If unary factors have weight 1, and higher-order factors * are absent, then we have the special case considered in [\ref WJW03]. */ std::vector _weight; public: /// Size of sample of trees used to set the weights /** \todo See if there is a way to wrap TRWBP::nrtrees in a props struct * together with the other properties currently in TRWBP::props * (without copying al lot of BP code literally) */ size_t nrtrees; /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor TRWBP() : BP(), _weight() {} /// Construct from FactorGraph \a fg and PropertySet \a opts. /** There is an additional property "nrtrees" which allows to specify the * number of random spanning trees used to set the scale parameters. * \param fg Factor graph. * \param opts Parameters @see BP::Properties. */ TRWBP( const FactorGraph &fg, const PropertySet &opts ) : BP(fg, opts), _weight() { setProperties( opts ); construct(); } //@} /// \name General InfAlg interface //@{ virtual TRWBP* clone() const { return new TRWBP(*this); } virtual std::string identify() const; virtual Real logZ() const; virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name TRWBP accessors/mutators for scale parameters //@{ /// Returns weight corresponding to the \a I 'th factor Real Weight( size_t I ) const { return _weight[I]; } /// Returns constant reference to vector of all weights const std::vector& Weights() const { return _weight; } /// Sets the weight of the \a I 'th factor to \a c void setWeight( size_t I, Real c ) { _weight[I] = c; } /// Sets the weights of all factors simultaenously /** \note Faster than calling setWeight(size_t,Real) for each factor */ void setWeights( const std::vector &c ) { _weight = c; } /// Increases weights corresponding to pairwise factors in \a tree with 1 void addTreeToWeights( const RootedTree &tree ); /// Samples weights from a sample of \a nrTrees random spanning trees void sampleWeights( size_t nrTrees ); protected: /// Calculate the product of factor \a I and the incoming messages /** If \a without_i == \c true, the message coming from variable \a i is omitted from the product * \note This function is used by calcNewMessage() and calcBeliefF() */ virtual Prob calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const; /// Calculates unnormalized belief of variable \a i virtual void calcBeliefV( size_t i, Prob &p ) const; // Calculates unnormalized belief of factor \a I virtual void calcBeliefF( size_t I, Prob &p ) const { p = calcIncomingMessageProduct( I, false, 0 ); } // Helper function for constructors virtual void construct(); }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/evidence.h0000644000263000017630000000564411433220723015601 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California, Santa Cruz */ /// \file /// \brief Defines class Evidence, which stores multiple observations of joint states of variables #ifndef __defined_libdai_evidence_h #define __defined_libdai_evidence_h #include #include namespace dai { /// Stores a data set consisting of multiple samples, where each sample is the observed joint state of some variables. /** \note Each sample can describe the joint state of a different set of variables, * in order to be able to deal with missing data. * * \author Charles Vaske */ class Evidence { public: /// Stores joint state of a set of variables typedef std::map Observation; private: /// Each sample is an observed joint state of some variables std::vector _samples; public: /// Default constructor Evidence() : _samples() {} /// Construct from \a samples Evidence( std::vector &samples ) : _samples(samples) {} /// Read in tabular data from a stream and add the read samples to \c *this. /** \param is Input stream in .tab file format, describing joint observations of variables in \a fg * \param fg Factor graph describing the corresponding variables * \see \ref fileformats-evidence * \throw INVALID_EVIDENCE_FILE if the input stream is not valid */ void addEvidenceTabFile( std::istream& is, FactorGraph& fg ); /// Returns number of stored samples size_t nrSamples() const { return _samples.size(); } /// \name Iterator interface //@{ /// Iterator over the samples typedef std::vector::iterator iterator; /// Constant iterator over the samples typedef std::vector::const_iterator const_iterator; /// Returns iterator that points to the first sample iterator begin() { return _samples.begin(); } /// Returns constant iterator that points to the first sample const_iterator begin() const { return _samples.begin(); } /// Returns iterator that points beyond the last sample iterator end() { return _samples.end(); } /// Returns constant iterator that points beyond the last sample const_iterator end() const { return _samples.end(); } //@} private: /// Read in tabular data from a stream and add the read samples to \c *this. void addEvidenceTabFile( std::istream& is, std::map &varMap ); }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/daialg.h0000644000263000017630000003121711433220723015233 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG). #ifndef __defined_libdai_daialg_h #define __defined_libdai_daialg_h #include #include #include #include #include #include namespace dai { /// InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI. /** \idea General marginalization functions like calcMarginal() now copy a complete InfAlg object. Instead, * it would make more sense that they construct a new object without copying the FactorGraph or RegionGraph. * Or they can simply be made methods of the general InfAlg class. * \idea Use a PropertySet as output of an InfAlg, instead of functions like maxDiff() and Iterations(). */ class InfAlg { public: /// \name Constructors/destructors //@{ /// Virtual destructor (needed because this class contains virtual functions) virtual ~InfAlg() {} /// Returns a pointer to a new, cloned copy of \c *this (i.e., virtual copy constructor) virtual InfAlg* clone() const = 0; //@} /// \name Queries //@{ /// Identifies itself for logging purposes virtual std::string identify() const = 0; /// Returns reference to underlying FactorGraph. virtual FactorGraph &fg() = 0; /// Returns constant reference to underlying FactorGraph. virtual const FactorGraph &fg() const = 0; //@} /// \name Inference interface //@{ /// Initializes all data structures of the approximate inference algorithm. /** \note This method should be called at least once before run() is called. */ virtual void init() = 0; /// Initializes all data structures corresponding to some set of variables. /** This method can be used to do a partial initialization after a part of the factor graph has changed. * Instead of initializing all data structures, it only initializes those involving the variables in \a vs. * \throw NOT_IMPLEMENTED if not implemented/supported */ virtual void init( const VarSet &vs ) = 0; /// Runs the approximate inference algorithm. /** \note Before run() is called the first time, init() should have been called. */ virtual Real run() = 0; /// Returns the (approximate) marginal probability distribution of a variable. /** \note Before this method is called, run() should have been called. */ virtual Factor belief( const Var &v ) const { return belief( VarSet(v) ); } /// Returns the (approximate) marginal probability distribution of a set of variables. /** \note Before this method is called, run() should have been called. * \throw NOT_IMPLEMENTED if not implemented/supported. * \throw BELIEF_NOT_AVAILABLE if the requested belief cannot be calculated with this algorithm. */ virtual Factor belief( const VarSet &vs ) const = 0; /// Returns the (approximate) marginal probability distribution of the variable with index \a i. /** For some approximate inference algorithms, using beliefV() is preferred to belief() for performance reasons. * \note Before this method is called, run() should have been called. */ virtual Factor beliefV( size_t i ) const { return belief( fg().var(i) ); } /// Returns the (approximate) marginal probability distribution of the variables on which factor \a I depends. /** For some approximate inference algorithms, using beliefF() is preferred to belief() for performance reasons. * \note Before this method is called, run() should have been called. */ virtual Factor beliefF( size_t I ) const { return belief( fg().factor(I).vars() ); } /// Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. /** \note Before this method is called, run() should have been called. */ virtual std::vector beliefs() const = 0; /// Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). /** \note Before this method is called, run() should have been called. * \throw NOT_IMPLEMENTED if not implemented/supported */ virtual Real logZ() const = 0; /// Calculates the joint state of all variables that has maximum probability /** \note Before this method is called, run() should have been called. * \throw NOT_IMPLEMENTED if not implemented/supported */ virtual std::vector findMaximum() const { DAI_THROW(NOT_IMPLEMENTED); } /// Returns maximum difference between single variable beliefs in the last iteration. /** \throw NOT_IMPLEMENTED if not implemented/supported */ virtual Real maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); }; /// Returns number of iterations done (one iteration passes over the complete factorgraph). /** \throw NOT_IMPLEMENTED if not implemented/supported */ virtual size_t Iterations() const { DAI_THROW(NOT_IMPLEMENTED); }; /// Sets maximum number of iterations (one iteration passes over the complete factorgraph). /** \throw NOT_IMPLEMENTED if not implemented/supported */ virtual void setMaxIter( size_t /*maxiter*/ ) { DAI_THROW(NOT_IMPLEMENTED); } //@} /// \name Changing the factor graph //@{ /// Clamp variable with index \a i to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{x_i, x}\f$) /** If \a backup == \c true, make a backup of all factors that are changed. */ virtual void clamp( size_t i, size_t x, bool backup = false ) = 0; /// Sets all factors interacting with variable with index \a i to one. /** If \a backup == \c true, make a backup of all factors that are changed. */ virtual void makeCavity( size_t i, bool backup = false ) = 0; //@} /// \name Backup/restore mechanism for factors //@{ /// Make a backup copy of factor \a I /** \throw MULTIPLE_UNDO if a backup already exists */ virtual void backupFactor( size_t I ) = 0; /// Make backup copies of all factors involving the variables in \a vs /** \throw MULTIPLE_UNDO if a backup already exists */ virtual void backupFactors( const VarSet &vs ) = 0; /// Restore factor \a I from its backup copy virtual void restoreFactor( size_t I ) = 0; /// Restore the factors involving the variables in \a vs from their backup copies virtual void restoreFactors( const VarSet &vs ) = 0; //@} /// \name Managing parameters //@{ /// Set parameters of this inference algorithm. /** The parameters are set according to the PropertySet \a opts. * The values can be stored either as std::string or as the type of the corresponding MF::props member. */ virtual void setProperties( const PropertySet &opts ) = 0; /// Returns parameters of this inference algorithm converted into a PropertySet. virtual PropertySet getProperties() const = 0; /// Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". virtual std::string printProperties() const = 0; //@} }; /// Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph). /** Inference algorithms in libDAI directly inherit from a DAIAlg, currently either * from a DAIAlg or from a DAIAlg. * * \tparam GRM Should be castable to FactorGraph * \idea A DAIAlg should not inherit from a FactorGraph or RegionGraph, but should * store a reference to the graphical model object. This prevents needless copying * of (possibly large) data structures. Disadvantage: the caller must not change * the graphical model between calls to the inference algorithm (maybe a smart_ptr * or some locking mechanism would help here?). */ template class DAIAlg : public InfAlg, public GRM { public: /// \name Constructors/destructors //@{ /// Default constructor DAIAlg() : InfAlg(), GRM() {} /// Construct from GRM DAIAlg( const GRM &grm ) : InfAlg(), GRM(grm) {} //@} /// \name Queries //@{ /// Returns reference to underlying FactorGraph. FactorGraph &fg() { return (FactorGraph &)(*this); } /// Returns constant reference to underlying FactorGraph. const FactorGraph &fg() const { return (const FactorGraph &)(*this); } //@} /// \name Changing the factor graph //@{ /// Clamp variable with index \a i to value \a x (i.e. multiply with a Kronecker delta \f$\delta_{x_i, x}\f$) /** If \a backup == \c true, make a backup of all factors that are changed. */ void clamp( size_t i, size_t x, bool backup = false ) { GRM::clamp( i, x, backup ); } /// Sets all factors interacting with variable with index \a i to one. /** If \a backup == \c true, make a backup of all factors that are changed. */ void makeCavity( size_t i, bool backup = false ) { GRM::makeCavity( i, backup ); } //@} /// \name Backup/restore mechanism for factors //@{ /// Make a backup copy of factor \a I void backupFactor( size_t I ) { GRM::backupFactor( I ); } /// Make backup copies of all factors involving the variables in \a vs void backupFactors( const VarSet &vs ) { GRM::backupFactors( vs ); } /// Restore factor \a I from its backup copy void restoreFactor( size_t I ) { GRM::restoreFactor( I ); } /// Restore the factors involving the variables in \a vs from their backup copies void restoreFactors( const VarSet &vs ) { GRM::restoreFactors( vs ); } //@} }; /// Base class for inference algorithms that operate on a FactorGraph typedef DAIAlg DAIAlgFG; /// Base class for inference algorithms that operate on a RegionGraph typedef DAIAlg DAIAlgRG; /// Calculates the marginal probability distribution for \a vs using inference algorithm \a obj. /** calcMarginal() works by clamping all variables in \a vs and calculating the partition sum for each clamped state. * Therefore, it can be used in combination with any inference algorithm that can calculate/approximate partition sums. * \param obj instance of inference algorithm to be used * \param vs variables for which the marginal should be calculated * \param reInit should be set to \c true if at least one of the possible clamped states would be invalid (leading to a factor graph with zero partition sum). */ Factor calcMarginal( const InfAlg& obj, const VarSet& vs, bool reInit ); /// Calculates beliefs for all pairs of variables in \a vs using inference algorithm \a obj. /** calcPairBeliefs() works by * - clamping single variables in \a vs and calculating the partition sum and the single variable beliefs for each clamped state, if \a accurate == \c false; * - clamping pairs of variables in \a vs and calculating the partition sum for each clamped state, if \a accurate == \c true. * * Therefore, it can be used in combination with any inference algorithm that can calculate/approximate partition sums (and single variable beliefs, if * \a accurate == \c true). * \param obj instance of inference algorithm to be used * \param vs variables for which the pair beliefs should be calculated * \param reInit should be set to \c true if at least one of the possible clamped states would be invalid (leading to a factor graph with zero partition sum). * \param accurate if \c true, uses a slower but more accurate approximation algorithm */ std::vector calcPairBeliefs( const InfAlg& obj, const VarSet& vs, bool reInit, bool accurate=false ); /// Calculates the joint state of all variables that has maximum probability, according to the inference algorithm \a obj /** \note Before this method is called, obj.run() should have been called. */ std::vector findMaximum( const InfAlg& obj ); } // end of namespace dai #endif libDAI-0.2.7/include/dai/factor.h0000644000263000017630000006365311433220723015301 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines TFactor<> and Factor classes which represent factors in probability distributions. #ifndef __defined_libdai_factor_h #define __defined_libdai_factor_h #include #include #include #include #include #include #include namespace dai { /// Represents a (probability) factor. /** Mathematically, a \e factor is a function mapping joint states of some * variables to the nonnegative real numbers. * More formally, denoting a discrete variable with label \f$l\f$ by * \f$x_l\f$ and its state space by \f$X_l = \{0,1,\dots,S_l-1\}\f$, * a factor depending on the variables \f$\{x_l\}_{l\in L}\f$ is * a function \f$f_L : \prod_{l\in L} X_l \to [0,\infty)\f$. * * In libDAI, a factor is represented by a TFactor object, which has two * components: * \arg a VarSet, corresponding with the set of variables \f$\{x_l\}_{l\in L}\f$ * that the factor depends on; * \arg a TProb, a vector containing the value of the factor for each possible * joint state of the variables. * * The factor values are stored in the entries of the TProb in a particular * ordering, which is defined by the one-to-one correspondence of a joint state * in \f$\prod_{l\in L} X_l\f$ with a linear index in * \f$\{0,1,\dots,\prod_{l\in L} S_l-1\}\f$ according to the mapping \f$\sigma\f$ * induced by dai::calcLinearState(). * * \tparam T Should be a scalar that is castable from and to double and should support elementary arithmetic operations. * \todo Define a better fileformat for .fg files (maybe using XML)? * \todo Add support for sparse factors. */ template class TFactor { private: /// Stores the variables on which the factor depends VarSet _vs; /// Stores the factor values TProb _p; public: /// \name Constructors and destructors //@{ /// Constructs factor depending on no variables with value \a p TFactor ( T p = 1 ) : _vs(), _p(1,p) {} /// Constructs factor depending on the variable \a v with uniform distribution TFactor( const Var &v ) : _vs(v), _p(v.states()) {} /// Constructs factor depending on variables in \a vars with uniform distribution TFactor( const VarSet& vars ) : _vs(vars), _p((size_t)_vs.nrStates()) { DAI_ASSERT( _vs.nrStates() <= std::numeric_limits::max() ); } /// Constructs factor depending on variables in \a vars with all values set to \a p TFactor( const VarSet& vars, T p ) : _vs(vars), _p((size_t)_vs.nrStates(),p) { DAI_ASSERT( _vs.nrStates() <= std::numeric_limits::max() ); } /// Constructs factor depending on variables in \a vars, copying the values from a std::vector<> /** \tparam S Type of values of \a x * \param vars contains the variables that the new factor should depend on. * \param x Vector with values to be copied. */ template TFactor( const VarSet& vars, const std::vector &x ) : _vs(vars), _p() { DAI_ASSERT( x.size() == vars.nrStates() ); _p = TProb( x.begin(), x.end(), x.size() ); } /// Constructs factor depending on variables in \a vars, copying the values from an array /** \param vars contains the variables that the new factor should depend on. * \param p Points to array of values to be added. */ TFactor( const VarSet& vars, const T* p ) : _vs(vars), _p(p, p + (size_t)_vs.nrStates(), (size_t)_vs.nrStates()) { DAI_ASSERT( _vs.nrStates() <= std::numeric_limits::max() ); } /// Constructs factor depending on variables in \a vars, copying the values from \a p TFactor( const VarSet& vars, const TProb &p ) : _vs(vars), _p(p) { DAI_ASSERT( _vs.nrStates() == _p.size() ); } /// Constructs factor depending on variables in \a vars, permuting the values given in \a p accordingly TFactor( const std::vector &vars, const std::vector &p ) : _vs(vars.begin(), vars.end(), vars.size()), _p(p.size()) { size_t nrStates = 1; for( size_t i = 0; i < vars.size(); i++ ) nrStates *= vars[i].states(); DAI_ASSERT( nrStates == p.size() ); Permute permindex(vars); for( size_t li = 0; li < p.size(); ++li ) _p.set( permindex.convertLinearIndex(li), p[li] ); } //@} /// \name Get/set individual entries //@{ /// Sets \a i 'th entry to \a val void set( size_t i, T val ) { _p.set( i, val ); } /// Gets \a i 'th entry T get( size_t i ) const { return _p[i]; } //@} /// \name Queries //@{ /// Returns constant reference to value vector const TProb& p() const { return _p; } /// Returns reference to value vector TProb& p() { return _p; } /// Returns a copy of the \a i 'th entry of the value vector T operator[] (size_t i) const { return _p[i]; } /// Returns constant reference to variable set (i.e., the variables on which the factor depends) const VarSet& vars() const { return _vs; } /// Returns reference to variable set (i.e., the variables on which the factor depends) VarSet& vars() { return _vs; } /// Returns the number of possible joint states of the variables on which the factor depends, \f$\prod_{l\in L} S_l\f$ /** \note This is equal to the length of the value vector. */ size_t nrStates() const { return _p.size(); } /// Returns the Shannon entropy of \c *this, \f$-\sum_i p_i \log p_i\f$ T entropy() const { return _p.entropy(); } /// Returns maximum of all values T max() const { return _p.max(); } /// Returns minimum of all values T min() const { return _p.min(); } /// Returns sum of all values T sum() const { return _p.sum(); } /// Returns sum of absolute values T sumAbs() const { return _p.sumAbs(); } /// Returns maximum absolute value of all values T maxAbs() const { return _p.maxAbs(); } /// Returns \c true if one or more values are NaN bool hasNaNs() const { return _p.hasNaNs(); } /// Returns \c true if one or more values are negative bool hasNegatives() const { return _p.hasNegatives(); } /// Returns strength of this factor (between variables \a i and \a j), as defined in eq. (52) of [\ref MoK07b] T strength( const Var &i, const Var &j ) const; /// Comparison bool operator==( const TFactor& y ) const { return (_vs == y._vs) && (_p == y._p); } //@} /// \name Unary transformations //@{ /// Returns negative of \c *this TFactor operator- () const { // Note: the alternative (shorter) way of implementing this, // return TFactor( _vs, _p.abs() ); // is slower because it invokes the copy constructor of TProb TFactor x; x._vs = _vs; x._p = -_p; return x; } /// Returns pointwise absolute value TFactor abs() const { TFactor x; x._vs = _vs; x._p = _p.abs(); return x; } /// Returns pointwise exponent TFactor exp() const { TFactor x; x._vs = _vs; x._p = _p.exp(); return x; } /// Returns pointwise logarithm /** If \a zero == \c true, uses log(0)==0; otherwise, log(0)==-Inf. */ TFactor log(bool zero=false) const { TFactor x; x._vs = _vs; x._p = _p.log(zero); return x; } /// Returns pointwise inverse /** If \a zero == \c true, uses 1/0==0; otherwise, 1/0==Inf. */ TFactor inverse(bool zero=true) const { TFactor x; x._vs = _vs; x._p = _p.inverse(zero); return x; } /// Returns normalized copy of \c *this, using the specified norm /** \throw NOT_NORMALIZABLE if the norm is zero */ TFactor normalized( ProbNormType norm=NORMPROB ) const { TFactor x; x._vs = _vs; x._p = _p.normalized( norm ); return x; } //@} /// \name Unary operations //@{ /// Draws all values i.i.d. from a uniform distribution on [0,1) TFactor& randomize() { _p.randomize(); return *this; } /// Sets all values to \f$1/n\f$ where \a n is the number of states TFactor& setUniform() { _p.setUniform(); return *this; } /// Applies absolute value pointwise TFactor& takeAbs() { _p.takeAbs(); return *this; } /// Applies exponent pointwise TFactor& takeExp() { _p.takeExp(); return *this; } /// Applies logarithm pointwise /** If \a zero == \c true, uses log(0)==0; otherwise, log(0)==-Inf. */ TFactor& takeLog( bool zero = false ) { _p.takeLog(zero); return *this; } /// Normalizes factor using the specified norm /** \throw NOT_NORMALIZABLE if the norm is zero */ T normalize( ProbNormType norm=NORMPROB ) { return _p.normalize( norm ); } //@} /// \name Operations with scalars //@{ /// Sets all values to \a x TFactor& fill (T x) { _p.fill( x ); return *this; } /// Adds scalar \a x to each value TFactor& operator+= (T x) { _p += x; return *this; } /// Subtracts scalar \a x from each value TFactor& operator-= (T x) { _p -= x; return *this; } /// Multiplies each value with scalar \a x TFactor& operator*= (T x) { _p *= x; return *this; } /// Divides each entry by scalar \a x TFactor& operator/= (T x) { _p /= x; return *this; } /// Raises values to the power \a x TFactor& operator^= (T x) { _p ^= x; return *this; } //@} /// \name Transformations with scalars //@{ /// Returns sum of \c *this and scalar \a x TFactor operator+ (T x) const { // Note: the alternative (shorter) way of implementing this, // TFactor result(*this); // result._p += x; // is slower because it invokes the copy constructor of TFactor TFactor result; result._vs = _vs; result._p = p() + x; return result; } /// Returns difference of \c *this and scalar \a x TFactor operator- (T x) const { TFactor result; result._vs = _vs; result._p = p() - x; return result; } /// Returns product of \c *this with scalar \a x TFactor operator* (T x) const { TFactor result; result._vs = _vs; result._p = p() * x; return result; } /// Returns quotient of \c *this with scalar \a x TFactor operator/ (T x) const { TFactor result; result._vs = _vs; result._p = p() / x; return result; } /// Returns \c *this raised to the power \a x TFactor operator^ (T x) const { TFactor result; result._vs = _vs; result._p = p() ^ x; return result; } //@} /// \name Operations with other factors //@{ /// Applies binary operation \a op on two factors, \c *this and \a g /** \tparam binOp Type of function object that accepts two arguments of type \a T and outputs a type \a T * \param g Right operand * \param op Operation of type \a binOp */ template TFactor& binaryOp( const TFactor &g, binOp op ) { if( _vs == g._vs ) // optimize special case _p.pwBinaryOp( g._p, op ); else { TFactor f(*this); // make a copy _vs |= g._vs; DAI_ASSERT( _vs.nrStates() < std::numeric_limits::max() ); size_t N = (size_t)_vs.nrStates(); IndexFor i_f( f._vs, _vs ); IndexFor i_g( g._vs, _vs ); _p.p().clear(); _p.p().reserve( N ); for( size_t i = 0; i < N; i++, ++i_f, ++i_g ) _p.p().push_back( op( f._p[i_f], g._p[i_g] ) ); } return *this; } /// Adds \a g to \c *this /** The sum of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[f+g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) + g(x_M).\f] */ TFactor& operator+= (const TFactor& g) { return binaryOp( g, std::plus() ); } /// Subtracts \a g from \c *this /** The difference of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[f-g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) - g(x_M).\f] */ TFactor& operator-= (const TFactor& g) { return binaryOp( g, std::minus() ); } /// Multiplies \c *this with \a g /** The product of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[fg : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) g(x_M).\f] */ TFactor& operator*= (const TFactor& g) { return binaryOp( g, std::multiplies() ); } /// Divides \c *this by \a g (where division by zero yields zero) /** The quotient of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\f] */ TFactor& operator/= (const TFactor& g) { return binaryOp( g, fo_divides0() ); } //@} /// \name Transformations with other factors //@{ /// Returns result of applying binary operation \a op on two factors, \c *this and \a g /** \tparam binOp Type of function object that accepts two arguments of type \a T and outputs a type \a T * \param g Right operand * \param op Operation of type \a binOp */ template TFactor binaryTr( const TFactor &g, binOp op ) const { // Note that to prevent a copy to be made, it is crucial // that the result is declared outside the if-else construct. TFactor result; if( _vs == g._vs ) { // optimize special case result._vs = _vs; result._p = _p.pwBinaryTr( g._p, op ); } else { result._vs = _vs | g._vs; DAI_ASSERT( result._vs.nrStates() < std::numeric_limits::max() ); size_t N = (size_t)result._vs.nrStates(); IndexFor i_f( _vs, result.vars() ); IndexFor i_g( g._vs, result.vars() ); result._p.p().clear(); result._p.p().reserve( N ); for( size_t i = 0; i < N; i++, ++i_f, ++i_g ) result._p.p().push_back( op( _p[i_f], g[i_g] ) ); } return result; } /// Returns sum of \c *this and \a g /** The sum of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[f+g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) + g(x_M).\f] */ TFactor operator+ (const TFactor& g) const { return binaryTr(g,std::plus()); } /// Returns \c *this minus \a g /** The difference of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[f-g : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) - g(x_M).\f] */ TFactor operator- (const TFactor& g) const { return binaryTr(g,std::minus()); } /// Returns product of \c *this with \a g /** The product of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[fg : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto f(x_L) g(x_M).\f] */ TFactor operator* (const TFactor& g) const { return binaryTr(g,std::multiplies()); } /// Returns quotient of \c *this by \a f (where division by zero yields zero) /** The quotient of two factors is defined as follows: if * \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$g : \prod_{m\in M} X_m \to [0,\infty)\f$, then * \f[\frac{f}{g} : \prod_{l\in L\cup M} X_l \to [0,\infty) : x \mapsto \frac{f(x_L)}{g(x_M)}.\f] */ TFactor operator/ (const TFactor& g) const { return binaryTr(g,fo_divides0()); } //@} /// \name Miscellaneous operations //@{ /// Returns a slice of \c *this, where the subset \a vars is in state \a varsState /** \pre \a vars sould be a subset of vars() * \pre \a varsState < vars.nrStates() * * The result is a factor that depends on the variables of *this except those in \a vars, * obtained by setting the variables in \a vars to the joint state specified by the linear index * \a varsState. Formally, if \c *this corresponds with the factor \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$, * \f$M \subset L\f$ corresponds with \a vars and \a varsState corresponds with a mapping \f$s\f$ that * maps a variable \f$x_m\f$ with \f$m\in M\f$ to its state \f$s(x_m) \in X_m\f$, then the slice * returned corresponds with the factor \f$g : \prod_{l \in L \setminus M} X_l \to [0,\infty)\f$ * defined by \f$g(\{x_l\}_{l\in L \setminus M}) = f(\{x_l\}_{l\in L \setminus M}, \{s(x_m)\}_{m\in M})\f$. */ TFactor slice( const VarSet& vars, size_t varsState ) const; /// Embeds this factor in a larger VarSet /** \pre vars() should be a subset of \a vars * * If *this corresponds with \f$f : \prod_{l\in L} X_l \to [0,\infty)\f$ and \f$L \subset M\f$, then * the embedded factor corresponds with \f$g : \prod_{m\in M} X_m \to [0,\infty) : x \mapsto f(x_L)\f$. */ TFactor embed(const VarSet & vars) const { DAI_ASSERT( vars >> _vs ); if( _vs == vars ) return *this; else return (*this) * TFactor(vars / _vs, (T)1); } /// Returns marginal on \a vars, obtained by summing out all variables except those in \a vars, and normalizing the result if \a normed == \c true TFactor marginal(const VarSet &vars, bool normed=true) const; /// Returns max-marginal on \a vars, obtained by maximizing all variables except those in \a vars, and normalizing the result if \a normed == \c true TFactor maxMarginal(const VarSet &vars, bool normed=true) const; //@} }; template TFactor TFactor::slice( const VarSet& vars, size_t varsState ) const { DAI_ASSERT( vars << _vs ); VarSet varsrem = _vs / vars; TFactor result( varsrem, T(0) ); // OPTIMIZE ME IndexFor i_vars (vars, _vs); IndexFor i_varsrem (varsrem, _vs); for( size_t i = 0; i < nrStates(); i++, ++i_vars, ++i_varsrem ) if( (size_t)i_vars == varsState ) result.set( i_varsrem, _p[i] ); return result; } template TFactor TFactor::marginal(const VarSet &vars, bool normed) const { VarSet res_vars = vars & _vs; TFactor res( res_vars, 0.0 ); IndexFor i_res( res_vars, _vs ); for( size_t i = 0; i < _p.size(); i++, ++i_res ) res.set( i_res, res[i_res] + _p[i] ); if( normed ) res.normalize( NORMPROB ); return res; } template TFactor TFactor::maxMarginal(const VarSet &vars, bool normed) const { VarSet res_vars = vars & _vs; TFactor res( res_vars, 0.0 ); IndexFor i_res( res_vars, _vs ); for( size_t i = 0; i < _p.size(); i++, ++i_res ) if( _p[i] > res._p[i_res] ) res.set( i_res, _p[i] ); if( normed ) res.normalize( NORMPROB ); return res; } template T TFactor::strength( const Var &i, const Var &j ) const { DAI_DEBASSERT( _vs.contains( i ) ); DAI_DEBASSERT( _vs.contains( j ) ); DAI_DEBASSERT( i != j ); VarSet ij(i, j); T max = 0.0; for( size_t alpha1 = 0; alpha1 < i.states(); alpha1++ ) for( size_t alpha2 = 0; alpha2 < i.states(); alpha2++ ) if( alpha2 != alpha1 ) for( size_t beta1 = 0; beta1 < j.states(); beta1++ ) for( size_t beta2 = 0; beta2 < j.states(); beta2++ ) if( beta2 != beta1 ) { size_t as = 1, bs = 1; if( i < j ) bs = i.states(); else as = j.states(); T f1 = slice( ij, alpha1 * as + beta1 * bs ).p().divide( slice( ij, alpha2 * as + beta1 * bs ).p() ).max(); T f2 = slice( ij, alpha2 * as + beta2 * bs ).p().divide( slice( ij, alpha1 * as + beta2 * bs ).p() ).max(); T f = f1 * f2; if( f > max ) max = f; } return std::tanh( 0.25 * std::log( max ) ); } /// Writes a factor to an output stream /** \relates TFactor */ template std::ostream& operator<< (std::ostream& os, const TFactor& f) { os << "(" << f.vars() << ", ("; for( size_t i = 0; i < f.nrStates(); i++ ) os << (i == 0 ? "" : ", ") << f[i]; os << "))"; return os; } /// Returns distance between two factors \a f and \a g, according to the distance measure \a dt /** \relates TFactor * \pre f.vars() == g.vars() */ template T dist( const TFactor &f, const TFactor &g, ProbDistType dt ) { if( f.vars().empty() || g.vars().empty() ) return -1; else { DAI_DEBASSERT( f.vars() == g.vars() ); return dist( f.p(), g.p(), dt ); } } /// Returns the pointwise maximum of two factors /** \relates TFactor * \pre f.vars() == g.vars() */ template TFactor max( const TFactor &f, const TFactor &g ) { DAI_ASSERT( f.vars() == g.vars() ); return TFactor( f.vars(), max( f.p(), g.p() ) ); } /// Returns the pointwise minimum of two factors /** \relates TFactor * \pre f.vars() == g.vars() */ template TFactor min( const TFactor &f, const TFactor &g ) { DAI_ASSERT( f.vars() == g.vars() ); return TFactor( f.vars(), min( f.p(), g.p() ) ); } /// Calculates the mutual information between the two variables that \a f depends on, under the distribution given by \a f /** \relates TFactor * \pre f.vars().size() == 2 */ template T MutualInfo(const TFactor &f) { DAI_ASSERT( f.vars().size() == 2 ); VarSet::const_iterator it = f.vars().begin(); Var i = *it; it++; Var j = *it; TFactor projection = f.marginal(i) * f.marginal(j); return dist( f.normalized(), projection, DISTKL ); } /// Represents a factor with values of type dai::Real. typedef TFactor Factor; /// Returns a binary unnormalized single-variable factor \f$ \exp(hx) \f$ where \f$ x = \pm 1 \f$ /** \param x Variable (should be binary) * \param h Field strength */ Factor createFactorIsing( const Var &x, Real h ); /// Returns a binary unnormalized pairwise factor \f$ \exp(J x_1 x_2) \f$ where \f$ x_1, x_2 = \pm 1 \f$ /** \param x1 First variable (should be binary) * \param x2 Second variable (should be binary) * \param J Coupling strength */ Factor createFactorIsing( const Var &x1, const Var &x2, Real J ); /// Returns a random factor on the variables \a vs with strength \a beta /** Each entry are set by drawing a normally distributed random with mean * 0 and standard-deviation \a beta, and taking its exponent. * \param vs Variables * \param beta Factor strength (inverse temperature) */ Factor createFactorExpGauss( const VarSet &vs, Real beta ); /// Returns a pairwise Potts factor \f$ \exp( J \delta_{x_1, x_2} ) \f$ /** \param x1 First variable * \param x2 Second variable (should have the same number of states as \a x1) * \param J Factor strength */ Factor createFactorPotts( const Var &x1, const Var &x2, Real J ); /// Returns a Kronecker delta point mass /** \param v Variable * \param state The state of \a v that should get value 1 */ Factor createFactorDelta( const Var &v, size_t state ); /// Returns a Kronecker delta point mass /** \param vs Set of variables * \param state The state of \a vs that should get value 1 */ Factor createFactorDelta( const VarSet& vs, size_t state ); } // end of namespace dai #endif libDAI-0.2.7/include/dai/cbp.h0000644000263000017630000002523311433220723014557 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ /// \file /// \brief Defines class CBP, which implements Conditioned Belief Propagation #ifndef __defined_libdai_cbp_h #define __defined_libdai_cbp_h #include #include #include #include namespace dai { /// Class for CBP (Conditioned Belief Propagation) [\ref EaG09] /** This approximate inference algorithm uses configurable heuristics to choose a variable * \f$ x_i \f$ and a state \f$ x_i^* \f$. Inference is done with \f$ x_i \f$ "clamped" to \f$ x_i^* \f$ * (i.e., conditional on \f$ x_i = x_i^* \f$), and also with the negation of this condition. * Clamping is done recursively up to a fixed number of levels (other stopping criteria are * also implemented, see the CBP::Properties::RecurseType property). The resulting approximate * marginals are combined using estimates of the partition sum. * * \author Frederik Eaton */ class CBP : public DAIAlgFG { private: /// Variable beliefs std::vector _beliefsV; /// Factor beliefs std::vector _beliefsF; /// Logarithm of partition sum Real _logZ; /// Numer of iterations needed size_t _iters; /// Maximum difference encountered so far Real _maxdiff; /// Number of clampings at each leaf node Real _sum_level; /// Number of leaves of recursion tree size_t _num_leaves; /// Output stream where information about the clampings is written boost::shared_ptr _clamp_ofstream; public: /// Construct CBP object from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ CBP( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg) { props.set( opts ); construct(); } /// Name of this inference algorithm static const char *Name; /// \name General InfAlg interface //@{ virtual CBP* clone() const { return new CBP(*this); } virtual std::string identify() const { return std::string(Name) + props.toString(); } virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet & ) const { DAI_THROW(NOT_IMPLEMENTED); } virtual Factor beliefV( size_t i ) const { return _beliefsV[i]; } virtual Factor beliefF( size_t I ) const { return _beliefsF[I]; } virtual std::vector beliefs() const { return concat(_beliefsV, _beliefsF); } virtual Real logZ() const { return _logZ; } virtual void init() {}; virtual void init( const VarSet & ) {}; virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; } virtual void setProperties( const PropertySet &opts ) { props.set( opts ); } virtual PropertySet getProperties() const { return props.get(); } virtual std::string printProperties() const { return props.toString(); } //@} //---------------------------------------------------------------- /// Parameters for CBP /* PROPERTIES(props,CBP) { /// Enumeration of possible update schedules typedef BP::Properties::UpdateType UpdateType; /// Enumeration of possible methods for deciding when to stop recursing DAI_ENUM(RecurseType,REC_FIXED,REC_LOGZ,REC_BDIFF); /// Enumeration of possible heuristics for choosing clamping variable DAI_ENUM(ChooseMethodType,CHOOSE_RANDOM,CHOOSE_MAXENT,CHOOSE_BBP,CHOOSE_BP_L1,CHOOSE_BP_CFN); /// Enumeration of possible clampings: variables or factors DAI_ENUM(ClampType,CLAMP_VAR,CLAMP_FACTOR); /// Verbosity (amount of output sent to stderr) size_t verbose = 0; /// Tolerance for BP convergence test Real tol; /// Update style for BP UpdateType updates; /// Maximum number of iterations for BP size_t maxiter; /// Tolerance used for controlling recursion depth (\a recurse is REC_LOGZ or REC_BDIFF) Real rec_tol; /// Maximum number of levels of recursion (\a recurse is REC_FIXED) size_t max_levels = 10; /// If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse Real min_max_adj; /// Heuristic for choosing clamping variable ChooseMethodType choose; /// Method for deciding when to stop recursing RecurseType recursion; /// Whether to clamp variables or factors ClampType clamp; /// Properties to pass to BBP PropertySet bbp_props; /// Cost function to use for BBP BBPCostFunction bbp_cfn; /// Random seed size_t rand_seed = 0; /// If non-empty, write clamping choices to this file std::string clamp_outfile = ""; } */ /* {{{ GENERATED CODE: DO NOT EDIT. Created by ./scripts/regenerate-properties include/dai/cbp.h src/cbp.cpp */ struct Properties { /// Enumeration of possible update schedules typedef BP::Properties::UpdateType UpdateType; /// Enumeration of possible methods for deciding when to stop recursing DAI_ENUM(RecurseType,REC_FIXED,REC_LOGZ,REC_BDIFF); /// Enumeration of possible heuristics for choosing clamping variable DAI_ENUM(ChooseMethodType,CHOOSE_RANDOM,CHOOSE_MAXENT,CHOOSE_BBP,CHOOSE_BP_L1,CHOOSE_BP_CFN); /// Enumeration of possible clampings: variables or factors DAI_ENUM(ClampType,CLAMP_VAR,CLAMP_FACTOR); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Tolerance for BP convergence test Real tol; /// Update style for BP UpdateType updates; /// Maximum number of iterations for BP size_t maxiter; /// Tolerance used for controlling recursion depth (\a recurse is REC_LOGZ or REC_BDIFF) Real rec_tol; /// Maximum number of levels of recursion (\a recurse is REC_FIXED) size_t max_levels; /// If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse Real min_max_adj; /// Heuristic for choosing clamping variable ChooseMethodType choose; /// Method for deciding when to stop recursing RecurseType recursion; /// Whether to clamp variables or factors ClampType clamp; /// Properties to pass to BBP PropertySet bbp_props; /// Cost function to use for BBP BBPCostFunction bbp_cfn; /// Random seed size_t rand_seed; /// If non-empty, write clamping choices to this file std::string clamp_outfile; /// Set members from PropertySet /** \throw UNKNOWN_PROPERTY if a Property key is not recognized * \throw NOT_ALL_PROPERTIES_SPECIFIED if an expected Property is missing */ void set(const PropertySet &opts); /// Get members into PropertySet PropertySet get() const; /// Convert to a string which can be parsed as a PropertySet std::string toString() const; } props; /* }}} END OF GENERATED CODE */ private: /// Prints beliefs, variables and partition sum, in case of a debugging build void printDebugInfo(); /// Called by run(), and by itself. Implements the main algorithm. /** Chooses a variable to clamp, recurses, combines the partition sum * and belief estimates of the children, and returns the improved * estimates in \a lz_out and \a beliefs_out to its parent. */ void runRecurse( InfAlg *bp, Real orig_logZ, std::vector clamped_vars_list, size_t &num_leaves, size_t &choose_count, Real &sum_level, Real &lz_out, std::vector &beliefs_out ); /// Choose the next variable to clamp. /** Choose the next variable to clamp, given a converged InfAlg \a bp, * and a vector of variables that are already clamped (\a * clamped_vars_list). Returns the chosen variable in \a i, and * the set of states in \a xis. If \a maxVarOut is non-NULL and * \a props.choose == \c CHOOSE_BBP then it is used to store the * adjoint of the chosen variable. */ virtual bool chooseNextClampVar( InfAlg* bp, std::vector &clamped_vars_list, size_t &i, std::vector &xis, Real *maxVarOut ); /// Return the InfAlg to use at each step of the recursion. /** \todo At present, CBP::getInfAlg() only returns a BP instance; * it should be possible to select other inference algorithms via a property */ InfAlg* getInfAlg(); /// Sets variable beliefs, factor beliefs and log partition sum to the specified values /** \param bs should be a concatenation of the variable beliefs followed by the factor beliefs * \param logZ log partition sum */ void setBeliefs( const std::vector &bs, Real logZ ); /// Constructor helper function void construct(); }; /// Find the best variable/factor to clamp using BBP. /** Takes a converged inference algorithm as input, runs Gibbs and BP_dual, creates * and runs a BBP object, finds the best variable/factor (the one with the maximum * factor adjoint), and returns the corresponding (index,state) pair. * \param in_bp inference algorithm (compatible with BP) that should have converged; * \param clampingVar if \c true, finds best variable, otherwise, finds best factor; * \param bbp_props BBP parameters to use; * \param cfn BBP cost function to use; * \param maxVarOut maximum adjoint value (only set if not NULL). * \see BBP * \relates CBP */ std::pair BBPFindClampVar( const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut ); } // end of namespace dai #endif libDAI-0.2.7/include/dai/index.h0000644000263000017630000004227411433220723015126 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays #ifndef __defined_libdai_index_h #define __defined_libdai_index_h #include #include #include #include namespace dai { /// Tool for looping over the states of several variables. /** The class IndexFor is an important tool for indexing Factor entries. * Its usage can best be explained by an example. * Assume \a indexVars, \a forVars are both VarSet 's. * Then the following code: * \code * IndexFor i( indexVars, forVars ); * size_t iter = 0; * for( ; i.valid(); i++, iter++ ) { * cout << "State of forVars: " << calcState( forVars, iter ) << "; "; * cout << "state of indexVars: " << calcState( indexVars, size_t(i) ) << endl; * } * \endcode * loops over all joint states of the variables in \a forVars, * and (size_t)i equals the linear index of the corresponding * state of \a indexVars, where the variables in \a indexVars that are * not in \a forVars assume their zero'th value. * \idea Optimize all indices as follows: keep a cache of all (or only * relatively small) indices that have been computed (use a hash). Then, * instead of computing on the fly, use the precomputed ones. Here the * labels of the variables don't matter, but the ranges of the variables do. */ class IndexFor { private: /// The current linear index corresponding to the state of indexVars long _index; /// For each variable in forVars, the amount of change in _index std::vector _sum; /// For each variable in forVars, the current state std::vector _state; /// For each variable in forVars, its number of possible values std::vector _ranges; public: /// Default constructor IndexFor() : _index(-1) {} /// Construct IndexFor object from \a indexVars and \a forVars IndexFor( const VarSet& indexVars, const VarSet& forVars ) : _state( forVars.size(), 0 ) { long sum = 1; _ranges.reserve( forVars.size() ); _sum.reserve( forVars.size() ); VarSet::const_iterator j = forVars.begin(); for( VarSet::const_iterator i = indexVars.begin(); i != indexVars.end(); ++i ) { for( ; j != forVars.end() && *j <= *i; ++j ) { _ranges.push_back( j->states() ); _sum.push_back( (*i == *j) ? sum : 0 ); } sum *= i->states(); } for( ; j != forVars.end(); ++j ) { _ranges.push_back( j->states() ); _sum.push_back( 0 ); } _index = 0; } /// Resets the state IndexFor& reset() { fill( _state.begin(), _state.end(), 0 ); _index = 0; return( *this ); } /// Conversion to \c size_t: returns linear index of the current state of indexVars operator size_t() const { DAI_ASSERT( valid() ); return( _index ); } /// Increments the current state of \a forVars (prefix) IndexFor& operator++ () { if( _index >= 0 ) { size_t i = 0; while( i < _state.size() ) { _index += _sum[i]; if( ++_state[i] < _ranges[i] ) break; _index -= _sum[i] * _ranges[i]; _state[i] = 0; i++; } if( i == _state.size() ) _index = -1; } return( *this ); } /// Increments the current state of \a forVars (postfix) void operator++( int ) { operator++(); } /// Returns \c true if the current state is valid bool valid() const { return( _index >= 0 ); } }; /// Tool for calculating permutations of linear indices of multi-dimensional arrays. /** \note This is mainly useful for converting indices into multi-dimensional arrays * corresponding to joint states of variables to and from the canonical ordering used in libDAI. */ class Permute { private: /// Stores the number of possible values of all indices std::vector _ranges; /// Stores the permutation std::vector _sigma; public: /// Default constructor Permute() : _ranges(), _sigma() {} /// Construct from vector of index ranges and permutation Permute( const std::vector &rs, const std::vector &sigma ) : _ranges(rs), _sigma(sigma) { DAI_ASSERT( _ranges.size() == _sigma.size() ); } /// Construct from vector of variables. /** The implied permutation maps the index of each variable in \a vars according to the canonical ordering * (i.e., sorted ascendingly according to their label) to the index it has in \a vars. * If \a reverse == \c true, reverses the indexing in \a vars first. */ Permute( const std::vector &vars, bool reverse=false ) : _ranges(), _sigma() { size_t N = vars.size(); // construct ranges _ranges.reserve( N ); for( size_t i = 0; i < N; ++i ) if( reverse ) _ranges.push_back( vars[N - 1 - i].states() ); else _ranges.push_back( vars[i].states() ); // construct VarSet out of vars VarSet vs( vars.begin(), vars.end(), N ); DAI_ASSERT( vs.size() == N ); // construct sigma _sigma.reserve( N ); for( VarSet::const_iterator vs_i = vs.begin(); vs_i != vs.end(); ++vs_i ) { size_t ind = find( vars.begin(), vars.end(), *vs_i ) - vars.begin(); if( reverse ) _sigma.push_back( N - 1 - ind ); else _sigma.push_back( ind ); } } /// Calculates a permuted linear index. /** Converts the linear index \a li to a vector index, permutes its * components, and converts it back to a linear index. */ size_t convertLinearIndex( size_t li ) const { size_t N = _ranges.size(); // calculate vector index corresponding to linear index std::vector vi; vi.reserve( N ); size_t prod = 1; for( size_t k = 0; k < N; k++ ) { vi.push_back( li % _ranges[k] ); li /= _ranges[k]; prod *= _ranges[k]; } // convert permuted vector index to corresponding linear index prod = 1; size_t sigma_li = 0; for( size_t k = 0; k < N; k++ ) { sigma_li += vi[_sigma[k]] * prod; prod *= _ranges[_sigma[k]]; } return sigma_li; } /// Returns constant reference to the permutation const std::vector& sigma() const { return _sigma; } /// Returns reference to the permutation std::vector& sigma() { return _sigma; } /// Returns constant reference to the dimensionality vector const std::vector& ranges() { return _ranges; } /// Returns the result of applying the permutation on \a i size_t operator[]( size_t i ) const { #ifdef DAI_DEBUG return _sigma.at(i); #else return _sigma[i]; #endif } /// Returns the inverse permutation Permute inverse() const { size_t N = _ranges.size(); std::vector invRanges( N, 0 ); std::vector invSigma( N, 0 ); for( size_t i = 0; i < N; i++ ) { invSigma[_sigma[i]] = i; invRanges[i] = _ranges[_sigma[i]]; } return Permute( invRanges, invSigma ); } }; /// multifor makes it easy to perform a dynamic number of nested \c for loops. /** An example of the usage is as follows: * \code * std::vector ranges; * ranges.push_back( 3 ); * ranges.push_back( 4 ); * ranges.push_back( 5 ); * for( multifor s(ranges); s.valid(); ++s ) * cout << "linear index: " << (size_t)s << " corresponds to indices " << s[2] << ", " << s[1] << ", " << s[0] << endl; * \endcode * which would be equivalent to: * \code * size_t s = 0; * for( size_t s2 = 0; s2 < 5; s2++ ) * for( size_t s1 = 0; s1 < 4; s1++ ) * for( size_t s0 = 0; s0 < 3; s++, s0++ ) * cout << "linear index: " << (size_t)s << " corresponds to indices " << s2 << ", " << s1 << ", " << s0 << endl; * \endcode */ class multifor { private: /// Stores the number of possible values of all indices std::vector _ranges; /// Stores the current values of all indices std::vector _indices; /// Stores the current linear index long _linear_index; public: /// Default constructor multifor() : _ranges(), _indices(), _linear_index(0) {} /// Initialize from vector of index ranges multifor( const std::vector &d ) : _ranges(d), _indices(d.size(),0), _linear_index(0) {} /// Returns linear index (i.e., the index in the Cartesian product space) operator size_t() const { DAI_DEBASSERT( valid() ); return( _linear_index ); } /// Returns \a k 'th index size_t operator[]( size_t k ) const { DAI_DEBASSERT( valid() ); DAI_DEBASSERT( k < _indices.size() ); return _indices[k]; } /// Increments the current indices (prefix) multifor & operator++() { if( valid() ) { _linear_index++; size_t i; for( i = 0; i != _indices.size(); i++ ) { if( ++(_indices[i]) < _ranges[i] ) break; _indices[i] = 0; } if( i == _indices.size() ) _linear_index = -1; } return *this; } /// Increments the current indices (postfix) void operator++( int ) { operator++(); } /// Resets the state multifor& reset() { fill( _indices.begin(), _indices.end(), 0 ); _linear_index = 0; return( *this ); } /// Returns \c true if the current indices are valid bool valid() const { return( _linear_index >= 0 ); } }; /// Makes it easy to iterate over all possible joint states of variables within a VarSet. /** A joint state of several variables can be represented in two different ways, by a map that maps each variable * to its own state, or by an integer that gives the index of the joint state in the canonical enumeration. * * Both representations are useful, and the main functionality provided by the State class is to simplify iterating * over the various joint states of a VarSet and to provide access to the current state in both representations. * * As an example, consider the following code snippet which iterates over all joint states of variables \a x0 and \a x1: * \code * VarSet vars( x0, x1 ); * for( State S(vars); S.valid(); S++ ) { * cout << "Linear state: " << S.get() << ", x0 = " << S(x0) << ", x1 = " << S(x1) << endl; * } * \endcode * * \note The same functionality could be achieved by simply iterating over the linear state and using dai::calcState(), * but the State class offers a more efficient implementation. * * \note A State is very similar to a dai::multifor, but tailored for Var 's and VarSet 's. * * \see dai::calcLinearState(), dai::calcState() * * \idea Make the State class a more prominent part of libDAI * (and document it clearly, explaining the concept of state); * add more optimized variants of the State class like IndexFor * (e.g. for TFactor<>::slice()). */ class State { private: /// Type for representing a joint state of some variables as a map, which maps each variable to its state typedef std::map states_type; /// Current state (represented linearly) long state; /// Current state (represented as a map) states_type states; public: /// Default constructor State() : state(0), states() {} /// Construct from VarSet \a vs and corresponding linear state \a linearState State( const VarSet &vs, size_t linearState=0 ) : state(linearState), states() { if( linearState == 0 ) for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) states[*v] = 0; else { for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) { states[*v] = linearState % v->states(); linearState /= v->states(); } DAI_ASSERT( linearState == 0 ); } } /// Construct from a std::map State( const std::map &s ) : state(0), states() { insert( s.begin(), s.end() ); } /// Constant iterator over the values typedef states_type::const_iterator const_iterator; /// Returns constant iterator that points to the first item const_iterator begin() const { return states.begin(); } /// Returns constant iterator that points beyond the last item const_iterator end() const { return states.end(); } /// Return current linear state operator size_t() const { DAI_ASSERT( valid() ); return( state ); } /// Inserts a range of variable-state pairs, changing the current state template void insert( InputIterator b, InputIterator e ) { states.insert( b, e ); VarSet vars; for( const_iterator it = begin(); it != end(); it++ ) vars |= it->first; state = 0; state = this->operator()( vars ); } /// Return current state represented as a map const std::map& get() const { return states; } /// Cast into std::map operator const std::map& () const { return states; } /// Return current state of variable \a v, or 0 if \a v is not in \c *this size_t operator() ( const Var &v ) const { DAI_ASSERT( valid() ); states_type::const_iterator entry = states.find( v ); if( entry == states.end() ) return 0; else return entry->second; } /// Return linear state of variables in \a vs, assuming that variables that are not in \c *this are in state 0 size_t operator() ( const VarSet &vs ) const { DAI_ASSERT( valid() ); size_t vs_state = 0; size_t prod = 1; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) { states_type::const_iterator entry = states.find( *v ); if( entry != states.end() ) vs_state += entry->second * prod; prod *= v->states(); } return vs_state; } /// Increments the current state (prefix) void operator++( ) { if( valid() ) { state++; states_type::iterator entry = states.begin(); while( entry != states.end() ) { if( ++(entry->second) < entry->first.states() ) break; entry->second = 0; entry++; } if( entry == states.end() ) state = -1; } } /// Increments the current state (postfix) void operator++( int ) { operator++(); } /// Returns \c true if the current state is valid bool valid() const { return( state >= 0 ); } /// Resets the current state (to the joint state represented by linear state 0) void reset() { state = 0; for( states_type::iterator s = states.begin(); s != states.end(); s++ ) s->second = 0; } }; } // end of namespace dai /** \example example_permute.cpp * This example shows how to use the Permute, multifor and State classes. * * \section Output * \verbinclude examples/example_permute.out * * \section Source */ #endif libDAI-0.2.7/include/dai/bipgraph.h0000644000263000017630000004026711433220723015613 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the BipartiteGraph class, which represents a bipartite graph #ifndef __defined_libdai_bipgraph_h #define __defined_libdai_bipgraph_h #include #include #include #include #include #include #include namespace dai { /// Represents the neighborhood structure of nodes in an undirected, bipartite graph. /** A bipartite graph has two types of nodes: type 1 and type 2. Edges can occur only between * nodes of different type. Nodes are indexed by an unsigned integer. If there are nrNodes1() * nodes of type 1 and nrNodes2() nodes of type 2, the nodes of type 1 are numbered * 0,1,2,...,nrNodes1()-1 and the nodes of type 2 are numbered 0,1,2,...,nrNodes2()-1. An edge * between node \a n1 of type 1 and node \a n2 of type 2 is represented by a Edge(\a n1,\a n2). * * A BipartiteGraph is implemented as a sparse adjacency list, i.e., it stores for each node a list of * its neighboring nodes. More precisely: it stores for each node of type 1 a vector of Neighbor structures * (accessible by the nb1() method) describing the neighboring nodes of type 2; similarly, for each node * of type 2 it stores a vector of Neighbor structures (accessibly by the nb2() method) describing the * neighboring nodes of type 1. * Thus, each node has an associated variable of type BipartiteGraph::Neighbors, which is a vector of * Neighbor structures, describing its neighboring nodes of the other type. * \idea Cache second-order neighborhoods in BipartiteGraph. */ class BipartiteGraph { private: /// Contains for each node of type 1 a vector of its neighbors std::vector _nb1; /// Contains for each node of type 2 a vector of its neighbors std::vector _nb2; /// Used internally by isTree() struct levelType { /// Indices of nodes of type 1 std::vector ind1; /// Indices of nodes of type 2 std::vector ind2; }; public: /// \name Constructors and destructors //@{ /// Default constructor (creates an empty bipartite graph) BipartiteGraph() : _nb1(), _nb2() {} /// Constructs BipartiteGraph with \a nr1 nodes of type 1, \a nr2 nodes of type 2 and no edges. BipartiteGraph( size_t nr1, size_t nr2 ) : _nb1(nr1), _nb2(nr2) {} /// Constructs BipartiteGraph from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of Edge. * \param nrNodes1 The number of nodes of type 1. * \param nrNodes2 The number of nodes of type 2. * \param begin Points to the first edge. * \param end Points just beyond the last edge. * \param check Whether to only add an edge if it does not exist already. */ template BipartiteGraph( size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true ) : _nb1(), _nb2() { construct( nrNodes1, nrNodes2, begin, end, check ); } //@} /// \name Accessors and mutators //@{ /// Returns constant reference to the \a _i2 'th neighbor of node \a i1 of type 1 const Neighbor & nb1( size_t i1, size_t _i2 ) const { DAI_DEBASSERT( i1 < _nb1.size() ); DAI_DEBASSERT( _i2 < _nb1[i1].size() ); return _nb1[i1][_i2]; } /// Returns reference to the \a _i2 'th neighbor of node \a i1 of type 1 Neighbor & nb1( size_t i1, size_t _i2 ) { DAI_DEBASSERT( i1 < _nb1.size() ); DAI_DEBASSERT( _i2 < _nb1[i1].size() ); return _nb1[i1][_i2]; } /// Returns constant reference to the \a _i1 'th neighbor of node \a i2 of type 2 const Neighbor & nb2( size_t i2, size_t _i1 ) const { DAI_DEBASSERT( i2 < _nb2.size() ); DAI_DEBASSERT( _i1 < _nb2[i2].size() ); return _nb2[i2][_i1]; } /// Returns reference to the \a _i1 'th neighbor of node \a i2 of type 2 Neighbor & nb2( size_t i2, size_t _i1 ) { DAI_DEBASSERT( i2 < _nb2.size() ); DAI_DEBASSERT( _i1 < _nb2[i2].size() ); return _nb2[i2][_i1]; } /// Returns constant reference to all neighbors of node \a i1 of type 1 const Neighbors & nb1( size_t i1 ) const { DAI_DEBASSERT( i1 < _nb1.size() ); return _nb1[i1]; } /// Returns reference to all neighbors of node \a i1 of type 1 Neighbors & nb1( size_t i1 ) { DAI_DEBASSERT( i1 < _nb1.size() ); return _nb1[i1]; } /// Returns constant reference to all neighbors of node \a i2 of type 2 const Neighbors & nb2( size_t i2 ) const { DAI_DEBASSERT( i2 < _nb2.size() ); return _nb2[i2]; } /// Returns reference to all neighbors of node \a i2 of type 2 Neighbors & nb2( size_t i2 ) { DAI_DEBASSERT( i2 < _nb2.size() ); return _nb2[i2]; } //@} /// \name Adding nodes and edges //@{ /// (Re)constructs BipartiteGraph from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of Edge. * \param nrNodes1 The number of nodes of type 1. * \param nrNodes2 The number of nodes of type 2. * \param begin Points to the first edge. * \param end Points just beyond the last edge. * \param check Whether to only add an edge if it does not exist already. */ template void construct( size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true ); /// Adds a node of type 1 without neighbors and returns the index of the added node. size_t addNode1() { _nb1.push_back( Neighbors() ); return _nb1.size() - 1; } /// Adds a node of type 2 without neighbors and returns the index of the added node. size_t addNode2() { _nb2.push_back( Neighbors() ); return _nb2.size() - 1; } /// Adds a node of type 1, with neighbors specified by a range of nodes of type 2. /** \tparam NodeInputIterator Iterator that iterates over instances of \c size_t. * \param begin Points to the first index of the nodes of type 2 that should become neighbors of the added node. * \param end Points just beyond the last index of the nodes of type 2 that should become neighbors of the added node. * \param sizeHint For improved efficiency, the size of the range may be specified by \a sizeHint. * \returns Index of the added node. */ template size_t addNode1( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) { Neighbors nbs1new; nbs1new.reserve( sizeHint ); size_t iter = 0; for( NodeInputIterator it = begin; it != end; ++it ) { DAI_ASSERT( *it < nrNodes2() ); Neighbor nb1new( iter, *it, nb2(*it).size() ); Neighbor nb2new( nb2(*it).size(), nrNodes1(), iter++ ); nbs1new.push_back( nb1new ); nb2( *it ).push_back( nb2new ); } _nb1.push_back( nbs1new ); return _nb1.size() - 1; } /// Adds a node of type 2, with neighbors specified by a range of nodes of type 1. /** \tparam NodeInputIterator Iterator that iterates over instances of \c size_t. * \param begin Points to the first index of the nodes of type 1 that should become neighbors of the added node. * \param end Points just beyond the last index of the nodes of type 1 that should become neighbors of the added node. * \param sizeHint For improved efficiency, the size of the range may be specified by \a sizeHint. * \returns Index of the added node. */ template size_t addNode2( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) { Neighbors nbs2new; nbs2new.reserve( sizeHint ); size_t iter = 0; for( NodeInputIterator it = begin; it != end; ++it ) { DAI_ASSERT( *it < nrNodes1() ); Neighbor nb2new( iter, *it, nb1(*it).size() ); Neighbor nb1new( nb1(*it).size(), nrNodes2(), iter++ ); nbs2new.push_back( nb2new ); nb1( *it ).push_back( nb1new ); } _nb2.push_back( nbs2new ); return _nb2.size() - 1; } /// Adds an edge between node \a n1 of type 1 and node \a n2 of type 2. /** If \a check == \c true, only adds the edge if it does not exist already. */ BipartiteGraph& addEdge( size_t n1, size_t n2, bool check = true ); //@} /// \name Erasing nodes and edges //@{ /// Removes node \a n1 of type 1 and all incident edges; indices of other nodes are changed accordingly. void eraseNode1( size_t n1 ); /// Removes node \a n2 of type 2 and all incident edges; indices of other nodes are changed accordingly. void eraseNode2( size_t n2 ); /// Removes edge between node \a n1 of type 1 and node \a n2 of type 2. void eraseEdge( size_t n1, size_t n2 ); //@} /// \name Queries //@{ /// Returns number of nodes of type 1 size_t nrNodes1() const { return _nb1.size(); } /// Returns number of nodes of type 2 size_t nrNodes2() const { return _nb2.size(); } /// Calculates the number of edges, time complexity: O(nrNodes1()) size_t nrEdges() const { size_t sum = 0; for( size_t i1 = 0; i1 < nrNodes1(); i1++ ) sum += nb1(i1).size(); return sum; } /// Returns true if the graph contains an edge between node \a n1 of type 1 and node \a n2 of type 2. /** \note The time complexity is linear in the number of neighbors of \a n1 or \a n2 */ bool hasEdge( size_t n1, size_t n2 ) const { if( nb1(n1).size() < nb2(n2).size() ) { for( size_t _n2 = 0; _n2 < nb1(n1).size(); _n2++ ) if( nb1( n1, _n2 ) == n2 ) return true; } else { for( size_t _n1 = 0; _n1 < nb2(n2).size(); _n1++ ) if( nb2( n2, _n1 ) == n1 ) return true; } return false; } /// Returns the index of a given node \a n2 of type 2 amongst the neighbors of node \a n1 of type 1 /** \note The time complexity is linear in the number of neighbors of \a n1 * \throw OBJECT_NOT_FOUND if \a n2 is not a neighbor of \a n1 */ size_t findNb1( size_t n1, size_t n2 ) { for( size_t _n2 = 0; _n2 < nb1(n1).size(); _n2++ ) if( nb1( n1, _n2 ) == n2 ) return _n2; DAI_THROW(OBJECT_NOT_FOUND); return nb1(n1).size(); } /// Returns the index of a given node \a n1 of type 1 amongst the neighbors of node \a n2 of type 2 /** \note The time complexity is linear in the number of neighbors of \a n2 * \throw OBJECT_NOT_FOUND if \a n1 is not a neighbor of \a n2 */ size_t findNb2( size_t n1, size_t n2 ) { for( size_t _n1 = 0; _n1 < nb2(n2).size(); _n1++ ) if( nb2( n2, _n1 ) == n1 ) return _n1; DAI_THROW(OBJECT_NOT_FOUND); return nb2(n2).size(); } /// Returns neighbors of node \a n1 of type 1 as a SmallSet. SmallSet nb1Set( size_t n1 ) const; /// Returns neighbors of node \a n2 of type 2 as a SmallSet. SmallSet nb2Set( size_t n2 ) const; /// Calculates second-order neighbors (i.e., neighbors of neighbors) of node \a n1 of type 1. /** If \a include == \c true, includes \a n1 itself, otherwise excludes \a n1. * \note In libDAI versions 0.2.4 and earlier, this function used to return a std::vector */ SmallSet delta1( size_t n1, bool include = false ) const; /// Calculates second-order neighbors (i.e., neighbors of neighbors) of node \a n2 of type 2. /** If \a include == \c true, includes \a n2 itself, otherwise excludes \a n2. * \note In libDAI versions 0.2.4 and earlier, this function used to return a std::vector */ SmallSet delta2( size_t n2, bool include = false ) const; /// Returns true if the graph is connected bool isConnected() const; /// Returns true if the graph is a tree, i.e., if it is singly connected and connected. bool isTree() const; /// Comparison operator which returns true if two graphs are identical /** \note Two graphs are called identical if they have the same number of nodes * of both types and the same edges (i.e., \a x has an edge between nodes * \a n1 and \a n2 if and only if \c *this has an edge between nodes \a n1 and \a n2). */ bool operator==( const BipartiteGraph& x ) const { if( nrNodes1() != x.nrNodes1() ) return false; if( nrNodes2() != x.nrNodes2() ) return false; for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) { if( nb1(n1).size() != x.nb1(n1).size() ) return false; foreach( const Neighbor &n2, nb1(n1) ) if( !x.hasEdge( n1, n2 ) ) return false; foreach( const Neighbor &n2, x.nb1(n1) ) if( !hasEdge( n1, n2 ) ) return false; } return true; } /// Asserts internal consistency void checkConsistency() const; //@} /// \name Input and output //@{ /// Writes this BipartiteGraph to an output stream in GraphViz .dot syntax void printDot( std::ostream& os ) const; /// Writes this BipartiteGraph to an output stream friend std::ostream& operator<<( std::ostream& os, const BipartiteGraph& g ) { g.printDot( os ); return os; } //@} }; template void BipartiteGraph::construct( size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check ) { _nb1.clear(); _nb1.resize( nrNodes1 ); _nb2.clear(); _nb2.resize( nrNodes2 ); for( EdgeInputIterator e = begin; e != end; e++ ) addEdge( e->first, e->second, check ); } } // end of namespace dai /** \example example_bipgraph.cpp * This example deals with the following bipartite graph: * \dot * graph example { * ordering=out; * subgraph cluster_type1 { * node[shape=circle,width=0.4,fixedsize=true,style=filled]; * 12 [label="2"]; * 11 [label="1"]; * 10 [label="0"]; * } * subgraph cluster_type2 { * node[shape=polygon,regular=true,sides=4,width=0.4,fixedsize=true,style=filled]; * 21 [label="1"]; * 20 [label="0"]; * } * 10 -- 20; * 11 -- 20; * 12 -- 20; * 11 -- 21; * 12 -- 21; * } * \enddot * It has three nodes of type 1 (drawn as circles) and two nodes of type 2 (drawn as rectangles). * Node 0 of type 1 has only one neighbor (node 0 of type 2), but node 0 of type 2 has three neighbors (nodes 0,1,2 of type 1). * The example code shows how to construct a BipartiteGraph object representing this bipartite graph and * how to iterate over nodes and their neighbors. * * \section Output * \verbinclude examples/example_bipgraph.out * * \section Source */ #endif libDAI-0.2.7/include/dai/prob.h0000644000263000017630000006361411433220723014762 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables) #ifndef __defined_libdai_prob_h #define __defined_libdai_prob_h #include #include #include #include #include #include #include #include namespace dai { /// Function object that returns the value itself template struct fo_id : public std::unary_function { /// Returns \a x T operator()( const T &x ) const { return x; } }; /// Function object that takes the absolute value template struct fo_abs : public std::unary_function { /// Returns abs(\a x) T operator()( const T &x ) const { if( x < (T)0 ) return -x; else return x; } }; /// Function object that takes the exponent template struct fo_exp : public std::unary_function { /// Returns exp(\a x) T operator()( const T &x ) const { return exp( x ); } }; /// Function object that takes the logarithm template struct fo_log : public std::unary_function { /// Returns log(\a x) T operator()( const T &x ) const { return log( x ); } }; /// Function object that takes the logarithm, except that log(0) is defined to be 0 template struct fo_log0 : public std::unary_function { /// Returns (\a x == 0 ? 0 : log(\a x)) T operator()( const T &x ) const { if( x ) return log( x ); else return 0; } }; /// Function object that takes the inverse template struct fo_inv : public std::unary_function { /// Returns 1 / \a x T operator()( const T &x ) const { return 1 / x; } }; /// Function object that takes the inverse, except that 1/0 is defined to be 0 template struct fo_inv0 : public std::unary_function { /// Returns (\a x == 0 ? 0 : (1 / \a x)) T operator()( const T &x ) const { if( x ) return 1 / x; else return 0; } }; /// Function object that returns p*log0(p) template struct fo_plog0p : public std::unary_function { /// Returns \a p * log0(\a p) T operator()( const T &p ) const { return p * dai::log0(p); } }; /// Function object similar to std::divides(), but different in that dividing by zero results in zero template struct fo_divides0 : public std::binary_function { /// Returns (\a y == 0 ? 0 : (\a x / \a y)) T operator()( const T &x, const T &y ) const { if( y == (T)0 ) return (T)0; else return x / y; } }; /// Function object useful for calculating the KL distance template struct fo_KL : public std::binary_function { /// Returns (\a p == 0 ? 0 : (\a p * (log(\a p) - log(\a q)))) T operator()( const T &p, const T &q ) const { if( p == (T)0 ) return (T)0; else return p * (log(p) - log(q)); } }; /// Function object useful for calculating the Hellinger distance template struct fo_Hellinger : public std::binary_function { /// Returns (sqrt(\a p) - sqrt(\a q))^2 T operator()( const T &p, const T &q ) const { T x = sqrt(p) - sqrt(q); return x * x; } }; /// Function object that returns x to the power y template struct fo_pow : public std::binary_function { /// Returns (\a x ^ \a y) T operator()( const T &x, const T &y ) const { if( y != 1 ) return pow( x, y ); else return x; } }; /// Function object that returns the maximum of two values template struct fo_max : public std::binary_function { /// Returns (\a x > y ? x : y) T operator()( const T &x, const T &y ) const { return (x > y) ? x : y; } }; /// Function object that returns the minimum of two values template struct fo_min : public std::binary_function { /// Returns (\a x > y ? y : x) T operator()( const T &x, const T &y ) const { return (x > y) ? y : x; } }; /// Function object that returns the absolute difference of x and y template struct fo_absdiff : public std::binary_function { /// Returns abs( \a x - \a y ) T operator()( const T &x, const T &y ) const { return dai::abs( x - y ); } }; /// Represents a vector with entries of type \a T. /** It is simply a std::vector<T> with an interface designed for dealing with probability mass functions. * * It is mainly used for representing measures on a finite outcome space, for example, the probability * distribution of a discrete random variable. However, entries are not necessarily non-negative; it is also used to * represent logarithms of probability mass functions. * * \tparam T Should be a scalar that is castable from and to dai::Real and should support elementary arithmetic operations. */ template class TProb { public: /// Type of data structure used for storing the values typedef std::vector container_type; /// Shorthand typedef TProb this_type; private: /// The data structure that stores the values container_type _p; public: /// \name Constructors and destructors //@{ /// Default constructor (constructs empty vector) TProb() : _p() {} /// Construct uniform probability distribution over \a n outcomes (i.e., a vector of length \a n with each entry set to \f$1/n\f$) explicit TProb( size_t n ) : _p( n, (T)1 / n ) {} /// Construct vector of length \a n with each entry set to \a p explicit TProb( size_t n, T p ) : _p( n, p ) {} /// Construct vector from a range /** \tparam TIterator Iterates over instances that can be cast to \a T * \param begin Points to first instance to be added. * \param end Points just beyond last instance to be added. * \param sizeHint For efficiency, the number of entries can be speficied by \a sizeHint; * the value 0 can be given if the size is unknown, but this will result in a performance penalty. */ template TProb( TIterator begin, TIterator end, size_t sizeHint ) : _p() { _p.reserve( sizeHint ); _p.insert( _p.begin(), begin, end ); } /// Construct vector from another vector /** \tparam S type of elements in \a v (should be castable to type \a T) * \param v vector used for initialization. */ template TProb( const std::vector &v ) : _p() { _p.reserve( v.size() ); _p.insert( _p.begin(), v.begin(), v.end() ); } //@} /// Constant iterator over the elements typedef typename container_type::const_iterator const_iterator; /// Iterator over the elements typedef typename container_type::iterator iterator; /// Constant reverse iterator over the elements typedef typename container_type::const_reverse_iterator const_reverse_iterator; /// Reverse iterator over the elements typedef typename container_type::reverse_iterator reverse_iterator; /// \name Iterator interface //@{ /// Returns iterator that points to the first element iterator begin() { return _p.begin(); } /// Returns constant iterator that points to the first element const_iterator begin() const { return _p.begin(); } /// Returns iterator that points beyond the last element iterator end() { return _p.end(); } /// Returns constant iterator that points beyond the last element const_iterator end() const { return _p.end(); } /// Returns reverse iterator that points to the last element reverse_iterator rbegin() { return _p.rbegin(); } /// Returns constant reverse iterator that points to the last element const_reverse_iterator rbegin() const { return _p.rbegin(); } /// Returns reverse iterator that points beyond the first element reverse_iterator rend() { return _p.rend(); } /// Returns constant reverse iterator that points beyond the first element const_reverse_iterator rend() const { return _p.rend(); } //@} /// \name Miscellaneous operations //@{ void resize( size_t sz ) { _p.resize( sz ); } //@} /// \name Get/set individual entries //@{ /// Gets \a i 'th entry T get( size_t i ) const { #ifdef DAI_DEBUG return _p.at(i); #else return _p[i]; #endif } /// Sets \a i 'th entry to \a val void set( size_t i, T val ) { DAI_DEBASSERT( i < _p.size() ); _p[i] = val; } //@} /// \name Queries //@{ /// Returns a const reference to the wrapped container const container_type& p() const { return _p; } /// Returns a reference to the wrapped container container_type& p() { return _p; } /// Returns a copy of the \a i 'th entry T operator[]( size_t i ) const { return get(i); } /// Returns length of the vector (i.e., the number of entries) size_t size() const { return _p.size(); } /// Accumulate all values (similar to std::accumulate) by summing /** The following calculation is done: * \code * T t = op(init); * for( const_iterator it = begin(); it != end(); it++ ) * t += op(*it); * return t; * \endcode */ template T accumulateSum( T init, unOp op ) const { T t = op(init); for( const_iterator it = begin(); it != end(); it++ ) t += op(*it); return t; } /// Accumulate all values (similar to std::accumulate) by maximization/minimization /** The following calculation is done (with "max" replaced by "min" if \a minimize == \c true): * \code * T t = op(init); * for( const_iterator it = begin(); it != end(); it++ ) * t = std::max( t, op(*it) ); * return t; * \endcode */ template T accumulateMax( T init, unOp op, bool minimize ) const { T t = op(init); if( minimize ) { for( const_iterator it = begin(); it != end(); it++ ) t = std::min( t, op(*it) ); } else { for( const_iterator it = begin(); it != end(); it++ ) t = std::max( t, op(*it) ); } return t; } /// Returns the Shannon entropy of \c *this, \f$-\sum_i p_i \log p_i\f$ T entropy() const { return -accumulateSum( (T)0, fo_plog0p() ); } /// Returns maximum value of all entries T max() const { return accumulateMax( (T)(-INFINITY), fo_id(), false ); } /// Returns minimum value of all entries T min() const { return accumulateMax( (T)INFINITY, fo_id(), true ); } /// Returns sum of all entries T sum() const { return accumulateSum( (T)0, fo_id() ); } /// Return sum of absolute value of all entries T sumAbs() const { return accumulateSum( (T)0, fo_abs() ); } /// Returns maximum absolute value of all entries T maxAbs() const { return accumulateMax( (T)0, fo_abs(), false ); } /// Returns \c true if one or more entries are NaN bool hasNaNs() const { bool foundnan = false; for( const_iterator x = _p.begin(); x != _p.end(); x++ ) if( dai::isnan( *x ) ) { foundnan = true; break; } return foundnan; } /// Returns \c true if one or more entries are negative bool hasNegatives() const { return (std::find_if( _p.begin(), _p.end(), std::bind2nd( std::less(), (T)0 ) ) != _p.end()); } /// Returns a pair consisting of the index of the maximum value and the maximum value itself std::pair argmax() const { T max = _p[0]; size_t arg = 0; for( size_t i = 1; i < size(); i++ ) { if( _p[i] > max ) { max = _p[i]; arg = i; } } return std::make_pair( arg, max ); } /// Returns a random index, according to the (normalized) distribution described by *this size_t draw() { Real x = rnd_uniform() * sum(); T s = 0; for( size_t i = 0; i < size(); i++ ) { s += get(i); if( s > x ) return i; } return( size() - 1 ); } /// Lexicographical comparison /** \pre this->size() == q.size() */ bool operator<( const this_type& q ) const { DAI_DEBASSERT( size() == q.size() ); return lexicographical_compare( begin(), end(), q.begin(), q.end() ); } /// Comparison bool operator==( const this_type& q ) const { if( size() != q.size() ) return false; return p() == q.p(); } //@} /// \name Unary transformations //@{ /// Returns the result of applying operation \a op pointwise on \c *this template this_type pwUnaryTr( unaryOp op ) const { this_type r; r._p.reserve( size() ); std::transform( _p.begin(), _p.end(), back_inserter( r._p ), op ); return r; } /// Returns negative of \c *this this_type operator- () const { return pwUnaryTr( std::negate() ); } /// Returns pointwise absolute value this_type abs() const { return pwUnaryTr( fo_abs() ); } /// Returns pointwise exponent this_type exp() const { return pwUnaryTr( fo_exp() ); } /// Returns pointwise logarithm /** If \a zero == \c true, uses log(0)==0; otherwise, log(0)==-Inf. */ this_type log(bool zero=false) const { if( zero ) return pwUnaryTr( fo_log0() ); else return pwUnaryTr( fo_log() ); } /// Returns pointwise inverse /** If \a zero == \c true, uses 1/0==0; otherwise, 1/0==Inf. */ this_type inverse(bool zero=true) const { if( zero ) return pwUnaryTr( fo_inv0() ); else return pwUnaryTr( fo_inv() ); } /// Returns normalized copy of \c *this, using the specified norm /** \throw NOT_NORMALIZABLE if the norm is zero */ this_type normalized( ProbNormType norm = dai::NORMPROB ) const { T Z = 0; if( norm == dai::NORMPROB ) Z = sum(); else if( norm == dai::NORMLINF ) Z = maxAbs(); if( Z == (T)0 ) { DAI_THROW(NOT_NORMALIZABLE); return *this; } else return pwUnaryTr( std::bind2nd( std::divides(), Z ) ); } //@} /// \name Unary operations //@{ /// Applies unary operation \a op pointwise template this_type& pwUnaryOp( unaryOp op ) { std::transform( _p.begin(), _p.end(), _p.begin(), op ); return *this; } /// Draws all entries i.i.d. from a uniform distribution on [0,1) this_type& randomize() { std::generate( _p.begin(), _p.end(), rnd_uniform ); return *this; } /// Sets all entries to \f$1/n\f$ where \a n is the length of the vector this_type& setUniform () { fill( (T)1 / size() ); return *this; } /// Applies absolute value pointwise this_type& takeAbs() { return pwUnaryOp( fo_abs() ); } /// Applies exponent pointwise this_type& takeExp() { return pwUnaryOp( fo_exp() ); } /// Applies logarithm pointwise /** If \a zero == \c true, uses log(0)==0; otherwise, log(0)==-Inf. */ this_type& takeLog(bool zero=false) { if( zero ) { return pwUnaryOp( fo_log0() ); } else return pwUnaryOp( fo_log() ); } /// Normalizes vector using the specified norm /** \throw NOT_NORMALIZABLE if the norm is zero */ T normalize( ProbNormType norm=dai::NORMPROB ) { T Z = 0; if( norm == dai::NORMPROB ) Z = sum(); else if( norm == dai::NORMLINF ) Z = maxAbs(); if( Z == (T)0 ) DAI_THROW(NOT_NORMALIZABLE); else *this /= Z; return Z; } //@} /// \name Operations with scalars //@{ /// Sets all entries to \a x this_type& fill( T x ) { std::fill( _p.begin(), _p.end(), x ); return *this; } /// Adds scalar \a x to each entry this_type& operator+= (T x) { if( x != 0 ) return pwUnaryOp( std::bind2nd( std::plus(), x ) ); else return *this; } /// Subtracts scalar \a x from each entry this_type& operator-= (T x) { if( x != 0 ) return pwUnaryOp( std::bind2nd( std::minus(), x ) ); else return *this; } /// Multiplies each entry with scalar \a x this_type& operator*= (T x) { if( x != 1 ) return pwUnaryOp( std::bind2nd( std::multiplies(), x ) ); else return *this; } /// Divides each entry by scalar \a x, where division by 0 yields 0 this_type& operator/= (T x) { if( x != 1 ) return pwUnaryOp( std::bind2nd( fo_divides0(), x ) ); else return *this; } /// Raises entries to the power \a x this_type& operator^= (T x) { if( x != (T)1 ) return pwUnaryOp( std::bind2nd( fo_pow(), x) ); else return *this; } //@} /// \name Transformations with scalars //@{ /// Returns sum of \c *this and scalar \a x this_type operator+ (T x) const { return pwUnaryTr( std::bind2nd( std::plus(), x ) ); } /// Returns difference of \c *this and scalar \a x this_type operator- (T x) const { return pwUnaryTr( std::bind2nd( std::minus(), x ) ); } /// Returns product of \c *this with scalar \a x this_type operator* (T x) const { return pwUnaryTr( std::bind2nd( std::multiplies(), x ) ); } /// Returns quotient of \c *this and scalar \a x, where division by 0 yields 0 this_type operator/ (T x) const { return pwUnaryTr( std::bind2nd( fo_divides0(), x ) ); } /// Returns \c *this raised to the power \a x this_type operator^ (T x) const { return pwUnaryTr( std::bind2nd( fo_pow(), x ) ); } //@} /// \name Operations with other equally-sized vectors //@{ /// Applies binary operation pointwise on two vectors /** \tparam binaryOp Type of function object that accepts two arguments of type \a T and outputs a type \a T * \param q Right operand * \param op Operation of type \a binaryOp */ template this_type& pwBinaryOp( const this_type &q, binaryOp op ) { DAI_DEBASSERT( size() == q.size() ); std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), op ); return *this; } /// Pointwise addition with \a q /** \pre this->size() == q.size() */ this_type& operator+= (const this_type & q) { return pwBinaryOp( q, std::plus() ); } /// Pointwise subtraction of \a q /** \pre this->size() == q.size() */ this_type& operator-= (const this_type & q) { return pwBinaryOp( q, std::minus() ); } /// Pointwise multiplication with \a q /** \pre this->size() == q.size() */ this_type& operator*= (const this_type & q) { return pwBinaryOp( q, std::multiplies() ); } /// Pointwise division by \a q, where division by 0 yields 0 /** \pre this->size() == q.size() * \see divide(const TProb &) */ this_type& operator/= (const this_type & q) { return pwBinaryOp( q, fo_divides0() ); } /// Pointwise division by \a q, where division by 0 yields +Inf /** \pre this->size() == q.size() * \see operator/=(const TProb &) */ this_type& divide (const this_type & q) { return pwBinaryOp( q, std::divides() ); } /// Pointwise power /** \pre this->size() == q.size() */ this_type& operator^= (const this_type & q) { return pwBinaryOp( q, fo_pow() ); } //@} /// \name Transformations with other equally-sized vectors //@{ /// Returns the result of applying binary operation \a op pointwise on \c *this and \a q /** \tparam binaryOp Type of function object that accepts two arguments of type \a T and outputs a type \a T * \param q Right operand * \param op Operation of type \a binaryOp */ template this_type pwBinaryTr( const this_type &q, binaryOp op ) const { DAI_DEBASSERT( size() == q.size() ); TProb r; r._p.reserve( size() ); std::transform( _p.begin(), _p.end(), q._p.begin(), back_inserter( r._p ), op ); return r; } /// Returns sum of \c *this and \a q /** \pre this->size() == q.size() */ this_type operator+ ( const this_type& q ) const { return pwBinaryTr( q, std::plus() ); } /// Return \c *this minus \a q /** \pre this->size() == q.size() */ this_type operator- ( const this_type& q ) const { return pwBinaryTr( q, std::minus() ); } /// Return product of \c *this with \a q /** \pre this->size() == q.size() */ this_type operator* ( const this_type &q ) const { return pwBinaryTr( q, std::multiplies() ); } /// Returns quotient of \c *this with \a q, where division by 0 yields 0 /** \pre this->size() == q.size() * \see divided_by(const TProb &) */ this_type operator/ ( const this_type &q ) const { return pwBinaryTr( q, fo_divides0() ); } /// Pointwise division by \a q, where division by 0 yields +Inf /** \pre this->size() == q.size() * \see operator/(const TProb &) */ this_type divided_by( const this_type &q ) const { return pwBinaryTr( q, std::divides() ); } /// Returns \c *this to the power \a q /** \pre this->size() == q.size() */ this_type operator^ ( const this_type &q ) const { return pwBinaryTr( q, fo_pow() ); } //@} /// Performs a generalized inner product, similar to std::inner_product /** \pre this->size() == q.size() */ template T innerProduct( const this_type &q, T init, binOp1 binaryOp1, binOp2 binaryOp2 ) const { DAI_DEBASSERT( size() == q.size() ); return std::inner_product( begin(), end(), q.begin(), init, binaryOp1, binaryOp2 ); } }; /// Returns distance between \a p and \a q, measured using distance measure \a dt /** \relates TProb * \pre this->size() == q.size() */ template T dist( const TProb &p, const TProb &q, ProbDistType dt ) { switch( dt ) { case DISTL1: return p.innerProduct( q, (T)0, std::plus(), fo_absdiff() ); case DISTLINF: return p.innerProduct( q, (T)0, fo_max(), fo_absdiff() ); case DISTTV: return p.innerProduct( q, (T)0, std::plus(), fo_absdiff() ) / 2; case DISTKL: return p.innerProduct( q, (T)0, std::plus(), fo_KL() ); case DISTHEL: return p.innerProduct( q, (T)0, std::plus(), fo_Hellinger() ) / 2; default: DAI_THROW(UNKNOWN_ENUM_VALUE); return INFINITY; } } /// Writes a TProb to an output stream /** \relates TProb */ template std::ostream& operator<< (std::ostream& os, const TProb& p) { os << "("; for( size_t i = 0; i < p.size(); i++ ) os << ((i != 0) ? ", " : "") << p.get(i); os << ")"; return os; } /// Returns the pointwise minimum of \a a and \a b /** \relates TProb * \pre this->size() == q.size() */ template TProb min( const TProb &a, const TProb &b ) { return a.pwBinaryTr( b, fo_min() ); } /// Returns the pointwise maximum of \a a and \a b /** \relates TProb * \pre this->size() == q.size() */ template TProb max( const TProb &a, const TProb &b ) { return a.pwBinaryTr( b, fo_max() ); } /// Represents a vector with entries of type dai::Real. typedef TProb Prob; } // end of namespace dai #endif libDAI-0.2.7/include/dai/matlab/0000755000263000017630000000000011433220723015075 5ustar jorismkyblibDAI-0.2.7/include/dai/matlab/matlab.h0000644000263000017630000000211111433220723016501 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines some utility functions for interfacing with MatLab #ifndef __defined_libdai_matlab_h #define __defined_libdai_matlab_h #include "mex.h" #include namespace dai { #ifdef SMALLMEM typedef int mwSize; typedef int mwIndex; #endif /// Convert vector structure to a cell vector of CPTAB-like structs mxArray *Factors2mx(const std::vector &Ps); /// Convert cell vector of CPTAB-like structs to vector std::vector mx2Factors(const mxArray *psi, long verbose); /// Convert CPTAB-like struct to Factor Factor mx2Factor(const mxArray *psi); } // end of namespace dai #endif libDAI-0.2.7/include/dai/treeep.h0000644000263000017630000002045011433220723015273 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class TreeEP, which implements Tree Expectation Propagation /// \todo Clean up the TreeEP code (exploiting that a large part of the code /// is just a special case of JTree). #ifndef __defined_libdai_treeep_h #define __defined_libdai_treeep_h #include #include #include #include #include #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm "Tree Expectation Propagation" [\ref MiQ04] class TreeEP : public JTree { private: /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for TreeEP struct Properties { /// Enumeration of possible choices for the tree /** The two possibilities are: * - \c ORG: take the maximum spanning tree where the weights are crude * estimates of the mutual information between the nodes; * - \c ALT: take the maximum spanning tree where the weights are upper * bounds on the effective interaction strengths between pairs of nodes. */ DAI_ENUM(TypeType,ORG,ALT); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Maximum time (in seconds) double maxtime; /// Tolerance for convergence test Real tol; /// How to choose the tree TypeType type; } props; /// Name of this inference method static const char *Name; private: /// Stores the data structures needed to efficiently update the approximation of an off-tree factor. /** The TreeEP object stores a TreeEPSubTree object for each off-tree factor. * It stores the approximation of that off-tree factor, which is represented * as a distribution on a subtree of the main tree. */ class TreeEPSubTree { private: /// Outer region pseudomarginals (corresponding with the \f$\tilde f_i(x_j,x_k)\f$ in [\ref MiQ04]) std::vector _Qa; /// Inner region pseudomarginals (corresponding with the \f$\tilde f_i(x_s)\f$ in [\ref MiQ04]) std::vector _Qb; /// The junction tree (stored as a rooted tree) RootedTree _RTree; /// Index conversion table for outer region indices (_Qa[alpha] corresponds with Qa[_a[alpha]] of the supertree) std::vector _a; /// Index conversion table for inner region indices (_Qb[beta] corresponds with Qb[_b[beta]] of the supertree) std::vector _b; /// Pointer to off-tree factor const Factor * _I; /// Variables in off-tree factor VarSet _ns; /// Variables in off-tree factor which are not in the root of this subtree VarSet _nsrem; /// Used for calculating the free energy Real _logZ; public: /// \name Constructors/destructors //@{ /// Default constructor TreeEPSubTree() : _Qa(), _Qb(), _RTree(), _a(), _b(), _I(NULL), _ns(), _nsrem(), _logZ(0.0) {} /// Copy constructor TreeEPSubTree( const TreeEPSubTree &x ) : _Qa(x._Qa), _Qb(x._Qb), _RTree(x._RTree), _a(x._a), _b(x._b), _I(x._I), _ns(x._ns), _nsrem(x._nsrem), _logZ(x._logZ) {} /// Assignment operator TreeEPSubTree & operator=( const TreeEPSubTree& x ) { if( this != &x ) { _Qa = x._Qa; _Qb = x._Qb; _RTree = x._RTree; _a = x._a; _b = x._b; _I = x._I; _ns = x._ns; _nsrem = x._nsrem; _logZ = x._logZ; } return *this; } /// Construct from \a subRTree, which is a subtree of the main tree \a jt_RTree, with distribution represented by \a jt_Qa and \a jt_Qb, for off-tree factor \a I TreeEPSubTree( const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector &jt_Qa, const std::vector &jt_Qb, const Factor *I ); //@} /// Initializes beliefs of this subtree void init(); /// Inverts this approximation and multiplies it by the (super) junction tree marginals \a Qa and \a Qb void InvertAndMultiply( const std::vector &Qa, const std::vector &Qb ); /// Runs junction tree algorithm (including off-tree factor I) storing the results in the (super) junction tree \a Qa and \a Qb void HUGIN_with_I( std::vector &Qa, std::vector &Qb ); /// Returns energy (?) of this subtree Real logZ( const std::vector &Qa, const std::vector &Qb ) const; /// Returns constant reference to the pointer to the off-tree factor const Factor *& I() { return _I; } }; /// Stores a TreeEPSubTree object for each off-tree factor std::map _Q; public: /// Default constructor TreeEP() : JTree(), _maxdiff(0.0), _iters(0), props(), _Q() {} /// Copy constructor TreeEP( const TreeEP &x ) : JTree(x), _maxdiff(x._maxdiff), _iters(x._iters), props(x.props), _Q(x._Q) { for( size_t I = 0; I < nrFactors(); I++ ) if( offtree( I ) ) _Q[I].I() = &factor(I); } /// Assignment operator TreeEP& operator=( const TreeEP &x ) { if( this != &x ) { JTree::operator=( x ); _maxdiff = x._maxdiff; _iters = x._iters; props = x.props; _Q = x._Q; for( size_t I = 0; I < nrFactors(); I++ ) if( offtree( I ) ) _Q[I].I() = &factor(I); } return *this; } /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ TreeEP( const FactorGraph &fg, const PropertySet &opts ); /// \name General InfAlg interface //@{ virtual TreeEP* clone() const { return new TreeEP(*this); } virtual std::string identify() const; virtual Real logZ() const; virtual void init(); virtual void init( const VarSet &/*ns*/ ) { init(); } virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} private: /// Helper function for constructors void construct( const FactorGraph& fg, const RootedTree& tree ); /// Returns \c true if factor \a I is not part of the tree bool offtree( size_t I ) const { return (fac2OR(I) == -1U); } }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/dag.h0000644000263000017630000002741311433220723014550 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ /// \file /// \brief Defines the DAG class, which represents a directed acyclic graph #ifndef __defined_libdai_dag_h #define __defined_libdai_dag_h #include #include #include #include #include #include #include namespace dai { /// Represents the neighborhood structure of nodes in a directed cyclic graph. /** A directed cyclic graph has nodes connected by directed edges, such that there is no * directed cycle of edges n1->n2->n3->...->n1. Nodes are indexed by an unsigned integer. * If there are nrNodes() nodes, they are numbered 0,1,2,...,nrNodes()-1. An edge * from node \a n1 to node \a n2 is represented by a Edge(\a n1,\a n2). * * DAG is implemented as a sparse adjacency list, i.e., it stores for each node a list of * its parents and a list of its children. Both lists are implemented as a vector of Neighbor * structures (accessible by the pa() and ch() methods). Thus, each node has two associated * variables of type DAG::Neighbors, which are vectors of Neighbor structures, describing their * parent and children nodes. */ class DAG { private: /// Contains for each node a vector of its parent nodes std::vector _pa; /// Contains for each node a vector of its children nodes std::vector _ch; public: /// \name Constructors and destructors //@{ /// Default constructor (creates an empty DAG). DAG() : _pa(), _ch() {} /// Constructs DAG with \a nr nodes and no edges. DAG( size_t nr ) : _pa( nr ), _ch( nr ) {} /// Constructs DAG from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of Edge. * \param nr The number of nodes. * \param begin Points to the first edge. * \param end Points just beyond the last edge. * \param check Whether to only add an edge if it does not exist already and * if it does not introduce a cycle */ template DAG( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true ) : _pa(), _ch() { construct( nr, begin, end, check ); } //@} /// \name Accessors and mutators //@{ /// Returns constant reference to the \a _p 'th parent of node \a n const Neighbor& pa( size_t n, size_t _p ) const { DAI_DEBASSERT( n < _pa.size() ); DAI_DEBASSERT( _p < _pa[n].size() ); return _pa[n][_p]; } /// Returns reference to the \a _p 'th parent of node \a n Neighbor& pa( size_t n, size_t _p ) { DAI_DEBASSERT( n < _pa.size() ); DAI_DEBASSERT( _p < _pa[n].size() ); return _pa[n][_p]; } /// Returns constant reference to all parents of node \a n const Neighbors& pa( size_t n ) const { DAI_DEBASSERT( n < _pa.size() ); return _pa[n]; } /// Returns reference to all parents of node \a n Neighbors& pa( size_t n ) { DAI_DEBASSERT( n < _pa.size() ); return _pa[n]; } /// Returns constant reference to the \a _c 'th child of node \a n const Neighbor& ch( size_t n, size_t _c ) const { DAI_DEBASSERT( n < _ch.size() ); DAI_DEBASSERT( _c < _ch[n].size() ); return _ch[n][_c]; } /// Returns reference to the \a _c 'th child of node \a n Neighbor& ch( size_t n, size_t _c ) { DAI_DEBASSERT( n < _ch.size() ); DAI_DEBASSERT( _c < _ch[n].size() ); return _ch[n][_c]; } /// Returns constant reference to all children of node \a n const Neighbors& ch( size_t n ) const { DAI_DEBASSERT( n < _ch.size() ); return _ch[n]; } /// Returns reference to all children of node \a n Neighbors& ch( size_t n ) { DAI_DEBASSERT( n < _ch.size() ); return _ch[n]; } //@} /// \name Adding nodes and edges //@{ /// (Re)constructs DAG from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of Edge. * \param nr The number of nodes. * \param begin Points to the first edge. * \param end Points just beyond the last edge. * \param check Whether to only add an edge if it does not exist already and does not introduce a cycle. */ template void construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true ); /// Adds a node without parents and children and returns the index of the added node. size_t addNode() { _pa.push_back( Neighbors() ); _ch.push_back( Neighbors() ); return _pa.size() - 1; } /// Adds a node with parents specified by a range of nodes. /** \tparam NodeInputIterator Iterator that iterates over instances of \c size_t. * \param begin Points to the first index of the nodes that should become parents of the added node. * \param end Points just beyond the last index of the nodes that should become parents of the added node. * \param sizeHint For improved efficiency, the size of the range may be specified by \a sizeHint. * \returns Index of the added node. */ template size_t addNode( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0 ) { Neighbors newparents; newparents.reserve( sizeHint ); size_t iter = 0; for( NodeInputIterator it = begin; it != end; ++it ) { DAI_ASSERT( *it < nrNodes() ); Neighbor newparent( iter, *it, ch(*it).size() ); Neighbor newchild( ch(*it).size(), nrNodes(), iter++ ); newparents.push_back( newparent ); ch( *it ).push_back( newchild ); } _pa.push_back( newparents ); _ch.push_back( Neighbors() ); return _pa.size() - 1; } /// Adds an edge from node \a n1 and node \a n2. /** If \a check == \c true, only adds the edge if it does not exist already and it would not introduce a cycle. */ DAG& addEdge( size_t n1, size_t n2, bool check=true ); //@} /// \name Erasing nodes and edges //@{ /// Removes node \a n and all ingoing and outgoing edges; indices of other nodes are changed accordingly. void eraseNode( size_t n ); /// Removes edge from node \a n1 to node \a n2. void eraseEdge( size_t n1, size_t n2 ); //@} /// \name Queries //@{ /// Returns number of nodes size_t nrNodes() const { DAI_DEBASSERT( _pa.size() == _ch.size() ); return _pa.size(); } /// Calculates the number of edges, time complexity: O(nrNodes()) size_t nrEdges() const { size_t sum = 0; for( size_t i = 0; i < _pa.size(); i++ ) sum += _pa[i].size(); return sum; } /// Returns true if the DAG contains an edge from node \a n1 and \a n2 /** \note The time complexity is linear in the number of children of \a n1 or the number of parents of \a n2, whichever is smaller */ bool hasEdge( size_t n1, size_t n2 ) const { if( ch(n1).size() < pa(n2).size() ) { for( size_t _n2 = 0; _n2 < ch(n1).size(); _n2++ ) if( ch( n1, _n2 ) == n2 ) return true; } else { for( size_t _n1 = 0; _n1 < pa(n2).size(); _n1++ ) if( pa( n2, _n1 ) == n1 ) return true; } return false; } /// Returns the index of a given node \a p amongst the parents of \a n /** \note The time complexity is linear in the number of parents of \a n * \throw OBJECT_NOT_FOUND if \a p is not a parent of \a n */ size_t findPa( size_t n, size_t p ) { for( size_t _p = 0; _p < pa(n).size(); _p++ ) if( pa( n, _p ) == p ) return _p; DAI_THROW(OBJECT_NOT_FOUND); return pa(n).size(); } /// Returns the index of a given node \a c amongst the children of \a n /** \note The time complexity is linear in the number of children of \a n * \throw OBJECT_NOT_FOUND if \a c is not a child \a n */ size_t findCh( size_t n, size_t c ) { for( size_t _c = 0; _c < ch(n).size(); _c++ ) if( ch( n, _c ) == c ) return _c; DAI_THROW(OBJECT_NOT_FOUND); return ch(n).size(); } /// Returns parents of node \a n as a SmallSet. SmallSet paSet( size_t n ) const; /// Returns children of node \a n as a SmallSet. SmallSet chSet( size_t n ) const; /// Returns the set of ancestors of node \a n, i.e., all nodes \a a such that there exists a directed path from \a a to \a n (excluding \a n itself) std::set ancestors( size_t n ) const; /// Returns the set of descendants of node \a n, i.e., all nodes \a d such that there exists a directed path from \a n to \a d (excluding \a n itself) std::set descendants( size_t n ) const; /// Returns whether there exists a directed path from node \a n1 to node \a n2 (which may consist of zero edges) bool existsDirectedPath( size_t n1, size_t n2 ) const; /// Returns true if the DAG is connected bool isConnected() const; /// Asserts internal consistency void checkConsistency() const; /// Comparison operator which returns true if two DAGs are identical /** \note Two DAGs are called identical if they have the same number * of nodes and the same edges (i.e., \a x has an edge from \a n1 to \a n2 * if and only if \c *this has an edge from node \a n1 to \a n2). */ bool operator==( const DAG& x ) const { if( nrNodes() != x.nrNodes() ) return false; for( size_t n1 = 0; n1 < nrNodes(); n1++ ) { if( pa(n1).size() != x.pa(n1).size() ) return false; foreach( const Neighbor &n2, pa(n1) ) if( !x.hasEdge( n2, n1 ) ) return false; foreach( const Neighbor &n2, x.pa(n1) ) if( !hasEdge( n2, n1 ) ) return false; } return true; } //@} /// \name Input and output //@{ /// Writes this DAG to an output stream in GraphViz .dot syntax void printDot( std::ostream& os ) const; /// Writes this DAG to an output stream friend std::ostream& operator<<( std::ostream& os, const DAG& g ) { g.printDot( os ); return os; } //@} }; template void DAG::construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check ) { _pa.clear(); _pa.resize( nr ); _ch.clear(); _ch.resize( nr ); for( EdgeInputIterator e = begin; e != end; e++ ) addEdge( e->first, e->second, check ); } } // end of namespace dai #endif libDAI-0.2.7/include/dai/lc.h0000644000263000017630000001362011433220723014406 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class LC, which implements loop corrections for approximate inference #ifndef __defined_libdai_lc_h #define __defined_libdai_lc_h #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm "Loop Corrected Belief Propagation" [\ref MoK07] class LC : public DAIAlgFG { private: /// Stores for each variable the approximate cavity distribution multiplied with the omitted factors std::vector _pancakes; /// Stores for each variable the approximate cavity distribution std::vector _cavitydists; /// _phis[i][_I] corresponds to \f$ \phi^{\setminus i}_I(x_{I \setminus i}) \f$ in the paper std::vector > _phis; /// Single variable beliefs std::vector _beliefs; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for LC struct Properties { /// Enumeration of possible ways to initialize the cavities /** The following initialization methods are defined: * - FULL calculates the marginal using calcMarginal() * - PAIR calculates only second order interactions using calcPairBeliefs() with \a accurate == \c false * - PAIR2 calculates only second order interactions using calcPairBeliefs() with \a accurate == \c true * - UNIFORM uses a uniform distribution */ DAI_ENUM(CavityType,FULL,PAIR,PAIR2,UNIFORM); /// Enumeration of different update schedules /** The following update schedules are defined: * - SEQFIX sequential fixed schedule * - SEQRND sequential random schedule */ DAI_ENUM(UpdateType,SEQFIX,SEQRND); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test Real tol; /// Complete or partial reinitialization of cavity graphs? bool reinit; /// Damping constant (0.0 means no damping, 1.0 is maximum damping) Real damping; /// How to initialize the cavities CavityType cavity; /// What update schedule to use UpdateType updates; /// Name of the algorithm used to initialize the cavity distributions std::string cavainame; /// Parameters for the algorithm used to initialize the cavity distributions PropertySet cavaiopts; } props; /// Name of this inference algorithm static const char *Name; public: /// Default constructor LC() : DAIAlgFG(), _pancakes(), _cavitydists(), _phis(), _beliefs(), _maxdiff(), _iters(), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ LC( const FactorGraph &fg, const PropertySet &opts ); /// \name General InfAlg interface //@{ virtual LC* clone() const { return new LC(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &/*vs*/ ) const; virtual Factor beliefV( size_t i ) const { return _beliefs[i]; } virtual std::vector beliefs() const { return _beliefs; } virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual void init(); virtual void init( const VarSet &/*ns*/ ) { init(); } virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for LC //@{ /// Approximates the cavity distribution of variable \a i, using the inference algorithm \a name with parameters \a opts Real CalcCavityDist( size_t i, const std::string &name, const PropertySet &opts ); /// Approximates all cavity distributions using inference algorithm \a name with parameters \a opts Real InitCavityDists( const std::string &name, const PropertySet &opts ); /// Sets approximate cavity distributions to \a Q long SetCavityDists( std::vector &Q ); /// Updates the belief of the Markov blanket of variable \a i based upon the information from its \a _I 'th neighboring factor Factor NewPancake (size_t i, size_t _I, bool & hasNaNs); /// Calculates the belief of variable \a i void CalcBelief (size_t i); /// Returns the belief of the Markov blanket of variable \a i (including the variable itself) const Factor &pancake (size_t i) const { return _pancakes[i]; }; /// Returns the approximate cavity distribution for variable \a i const Factor &cavitydist (size_t i) const { return _cavitydists[i]; }; //@} }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/jtree.h0000644000263000017630000002222011433220723015115 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class JTree, which implements the junction tree algorithm #ifndef __defined_libdai_jtree_h #define __defined_libdai_jtree_h #include #include #include #include #include #include #include #include #include #include namespace dai { /// Exact inference algorithm using junction tree /** The junction tree algorithm uses message passing on a junction tree to calculate * exact marginal probability distributions ("beliefs") for specified cliques * (outer regions) and separators (intersections of pairs of cliques). * * There are two variants, the sum-product algorithm (corresponding to * finite temperature) and the max-product algorithm (corresponding to * zero temperature). */ class JTree : public DAIAlgRG { private: /// Stores the messages std::vector > _mes; /// Stores the logarithm of the partition sum Real _logZ; public: /// The junction tree (stored as a rooted tree) RootedTree RTree; /// Outer region beliefs std::vector Qa; /// Inner region beliefs std::vector Qb; /// Parameters for JTree struct Properties { /// Enumeration of possible JTree updates /** There are two types of updates: * - HUGIN similar to those in HUGIN * - SHSH Shafer-Shenoy type */ DAI_ENUM(UpdateType,HUGIN,SHSH); /// Enumeration of inference variants /** There are two inference variants: * - SUMPROD Sum-Product * - MAXPROD Max-Product (equivalent to Min-Sum) */ DAI_ENUM(InfType,SUMPROD,MAXPROD); /// Enumeration of elimination cost functions used for constructing the junction tree /** The cost of eliminating a variable can be (\see [\ref KoF09], page 314)): * - MINNEIGHBORS the number of neighbors it has in the current adjacency graph; * - MINWEIGHT the product of the number of states of all neighbors in the current adjacency graph; * - MINFILL the number of edges that need to be added to the adjacency graph due to the elimination; * - WEIGHTEDMINFILL the sum of weights of the edges that need to be added to the adjacency graph * due to the elimination, where a weight of an edge is the produt of weights of its constituent * vertices. * The elimination sequence is chosen greedily in order to minimize the cost. */ DAI_ENUM(HeuristicType,MINNEIGHBORS,MINWEIGHT,MINFILL,WEIGHTEDMINFILL); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Type of updates UpdateType updates; /// Type of inference InfType inference; /// Heuristic to use for constructing the junction tree HeuristicType heuristic; /// Maximum memory to use in bytes (0 means unlimited) size_t maxmem; } props; /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor JTree() : DAIAlgRG(), _mes(), _logZ(), RTree(), Qa(), Qb(), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg factor graph ** \param opts Parameters @see Properties * \param automatic if \c true, construct the junction tree automatically, using the heuristic in opts['heuristic']. */ JTree( const FactorGraph &fg, const PropertySet &opts, bool automatic=true ); //@} /// \name General InfAlg interface //@{ virtual JTree* clone() const { return new JTree(*this); } virtual std::string identify() const; virtual Factor belief( const VarSet &vs ) const; virtual std::vector beliefs() const; virtual Real logZ() const; /** \pre Assumes that run() has been called and that \a props.inference == \c MAXPROD */ std::vector findMaximum() const { return dai::findMaximum( *this ); } virtual void init() {} virtual void init( const VarSet &/*ns*/ ) {} virtual Real run(); virtual Real maxDiff() const { return 0.0; } virtual size_t Iterations() const { return 1UL; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for JTree //@{ /// Constructs a junction tree based on the cliques \a cl (corresponding to some elimination sequence). /** First, constructs a weighted graph, where the nodes are the elements of \a cl, and * each edge is weighted with the cardinality of the intersection of the state spaces of the nodes. * Then, a maximal spanning tree for this weighted graph is calculated. * Subsequently, a corresponding region graph is built: * - the outer regions correspond with the cliques and have counting number 1; * - the inner regions correspond with the seperators, i.e., the intersections of two * cliques that are neighbors in the spanning tree, and have counting number -1 * (except empty ones, which have counting number 0); * - inner and outer regions are connected by an edge if the inner region is a * seperator for the outer region. * Finally, Beliefs are constructed. * If \a verify == \c true, checks whether each factor is subsumed by a clique. */ void construct( const FactorGraph &fg, const std::vector &cl, bool verify=false ); /// Constructs a junction tree based on the cliques \a cl (corresponding to some elimination sequence). /** Invokes construct() and then constructs messages. * \see construct() */ void GenerateJT( const FactorGraph &fg, const std::vector &cl ); /// Returns constant reference to the message from outer region \a alpha to its \a _beta 'th neighboring inner region const Factor & message( size_t alpha, size_t _beta ) const { return _mes[alpha][_beta]; } /// Returns reference to the message from outer region \a alpha to its \a _beta 'th neighboring inner region Factor & message( size_t alpha, size_t _beta ) { return _mes[alpha][_beta]; } /// Runs junction tree algorithm using HUGIN (message-free) updates /** \note The initial messages may be arbitrary; actually they are not used at all. */ void runHUGIN(); /// Runs junction tree algorithm using Shafer-Shenoy updates /** \note The initial messages may be arbitrary. */ void runShaferShenoy(); /// Finds an efficient subtree for calculating the marginal of the variables in \a vs /** First, the current junction tree is reordered such that it gets as root the clique * that has maximal state space overlap with \a vs. Then, the minimal subtree * (starting from the root) is identified that contains all the variables in \a vs * and also the outer region with index \a PreviousRoot (if specified). Finally, * the current junction tree is reordered such that this minimal subtree comes * before the other edges, and the size of the minimal subtree is returned. */ size_t findEfficientTree( const VarSet& vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1 ) const; /// Calculates the marginal of a set of variables (using cutset conditioning, if necessary) /** \pre assumes that run() has been called already */ Factor calcMarginal( const VarSet& vs ); //@} }; /// Calculates upper bound to the treewidth of a FactorGraph, using the specified heuristic /** \relates JTree * \param fg the factor graph for which the treewidth should be bounded * \param fn the heuristic cost function used for greedy variable elimination * \param maxStates maximum total number of states in outer regions of junction tree (0 means no limit) * \throws OUT_OF_MEMORY if the total number of states becomes larger than maxStates * \return a pair (number of variables in largest clique, number of states in largest clique) */ std::pair boundTreewidth( const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates=0 ); } // end of namespace dai #endif libDAI-0.2.7/include/dai/bp.h0000644000263000017630000003072011433220723014411 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class BP, which implements (Loopy) Belief Propagation /// \todo Consider using a priority_queue for maximum residual schedule #ifndef __defined_libdai_bp_h #define __defined_libdai_bp_h #include #include #include #include #include namespace dai { /// Approximate inference algorithm "(Loopy) Belief Propagation" /** The Loopy Belief Propagation algorithm uses message passing * to approximate marginal probability distributions ("beliefs") for variables * and factors (more precisely, for the subset of variables depending on the factor). * There are two variants, the sum-product algorithm (corresponding to * finite temperature) and the max-product algorithm (corresponding to * zero temperature). * * The messages \f$m_{I\to i}(x_i)\f$ are passed from factors \f$I\f$ to variables \f$i\f$. * In case of the sum-product algorith, the update equation is: * \f[ m_{I\to i}(x_i) \propto \sum_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\f] * and in case of the max-product algorithm: * \f[ m_{I\to i}(x_i) \propto \max_{x_{N_I\setminus\{i\}}} f_I(x_I) \prod_{j\in N_I\setminus\{i\}} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}\f] * In order to improve convergence, the updates can be damped. For improved numerical stability, * the updates can be done in the log-domain alternatively. * * After convergence, the variable beliefs are calculated by: * \f[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i}(x_i)\f] * and the factor beliefs are calculated by: * \f[ b_I(x_I) \propto f_I(x_I) \prod_{j\in N_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j}(x_j) \f] * The logarithm of the partition sum is calculated by: * \f[ \log Z = \sum_i (1 - |N_i|) \sum_{x_i} b_i(x_i) \log b_i(x_i) - \sum_I \sum_{x_I} b_I(x_I) \log \frac{b_I(x_I)}{f_I(x_I)} \f] * * For the max-product algorithm, a heuristic way of finding the MAP state (the * joint configuration of all variables which has maximum probability) is provided * by the findMaximum() method, which can be called after convergence. * * \note There are two implementations, an optimized one (the default) which caches IndexFor objects, * and a slower, less complicated one which is easier to maintain/understand. The slower one can be * enabled by defining DAI_BP_FAST as false in the source file. */ class BP : public DAIAlgFG { protected: /// Type used for index cache typedef std::vector ind_t; /// Type used for storing edge properties struct EdgeProp { /// Index cached for this edge ind_t index; /// Old message living on this edge Prob message; /// New message living on this edge Prob newMessage; /// Residual for this edge Real residual; }; /// Stores all edge properties std::vector > _edges; /// Type of lookup table (only used for maximum-residual BP) typedef std::multimap > LutType; /// Lookup table (only used for maximum-residual BP) std::vector > _edge2lut; /// Lookup table (only used for maximum-residual BP) LutType _lut; /// Maximum difference between variable beliefs encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; /// The history of message updates (only recorded if \a recordSentMessages is \c true) std::vector > _sentMessages; /// Stores variable beliefs of previous iteration std::vector _oldBeliefsV; /// Stores factor beliefs of previous iteration std::vector _oldBeliefsF; /// Stores the update schedule std::vector _updateSeq; public: /// Parameters for BP struct Properties { /// Enumeration of possible update schedules /** The following update schedules have been defined: * - PARALL parallel updates * - SEQFIX sequential updates using a fixed sequence * - SEQRND sequential updates using a random sequence * - SEQMAX maximum-residual updates [\ref EMK06] */ DAI_ENUM(UpdateType,SEQFIX,SEQRND,SEQMAX,PARALL); /// Enumeration of inference variants /** There are two inference variants: * - SUMPROD Sum-Product * - MAXPROD Max-Product (equivalent to Min-Sum) */ DAI_ENUM(InfType,SUMPROD,MAXPROD); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Maximum time (in seconds) double maxtime; /// Tolerance for convergence test Real tol; /// Whether updates should be done in logarithmic domain or not bool logdomain; /// Damping constant (0.0 means no damping, 1.0 is maximum damping) Real damping; /// Message update schedule UpdateType updates; /// Inference variant InfType inference; } props; /// Name of this inference algorithm static const char *Name; /// Specifies whether the history of message updates should be recorded bool recordSentMessages; public: /// \name Constructors/destructors //@{ /// Default constructor BP() : DAIAlgFG(), _edges(), _edge2lut(), _lut(), _maxdiff(0.0), _iters(0U), _sentMessages(), _oldBeliefsV(), _oldBeliefsF(), _updateSeq(), props(), recordSentMessages(false) {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ BP( const FactorGraph & fg, const PropertySet &opts ) : DAIAlgFG(fg), _edges(), _maxdiff(0.0), _iters(0U), _sentMessages(), _oldBeliefsV(), _oldBeliefsF(), _updateSeq(), props(), recordSentMessages(false) { setProperties( opts ); construct(); } /// Copy constructor BP( const BP &x ) : DAIAlgFG(x), _edges(x._edges), _edge2lut(x._edge2lut), _lut(x._lut), _maxdiff(x._maxdiff), _iters(x._iters), _sentMessages(x._sentMessages), _oldBeliefsV(x._oldBeliefsV), _oldBeliefsF(x._oldBeliefsF), _updateSeq(x._updateSeq), props(x.props), recordSentMessages(x.recordSentMessages) { for( LutType::iterator l = _lut.begin(); l != _lut.end(); ++l ) _edge2lut[l->second.first][l->second.second] = l; } /// Assignment operator BP& operator=( const BP &x ) { if( this != &x ) { DAIAlgFG::operator=( x ); _edges = x._edges; _lut = x._lut; for( LutType::iterator l = _lut.begin(); l != _lut.end(); ++l ) _edge2lut[l->second.first][l->second.second] = l; _maxdiff = x._maxdiff; _iters = x._iters; _sentMessages = x._sentMessages; _oldBeliefsV = x._oldBeliefsV; _oldBeliefsF = x._oldBeliefsF; _updateSeq = x._updateSeq; props = x.props; recordSentMessages = x.recordSentMessages; } return *this; } //@} /// \name General InfAlg interface //@{ virtual BP* clone() const { return new BP(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &vs ) const; virtual Factor beliefV( size_t i ) const; virtual Factor beliefF( size_t I ) const; virtual std::vector beliefs() const; virtual Real logZ() const; /** \pre Assumes that run() has been called and that \a props.inference == \c MAXPROD */ std::vector findMaximum() const { return dai::findMaximum( *this ); } virtual void init(); virtual void init( const VarSet &ns ); virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for BP //@{ /// Returns history of which messages have been updated const std::vector >& getSentMessages() const { return _sentMessages; } /// Clears history of which messages have been updated void clearSentMessages() { _sentMessages.clear(); } //@} protected: /// Returns constant reference to message from the \a _I 'th neighbor of variable \a i to variable \a i const Prob & message(size_t i, size_t _I) const { return _edges[i][_I].message; } /// Returns reference to message from the \a _I 'th neighbor of variable \a i to variable \a i Prob & message(size_t i, size_t _I) { return _edges[i][_I].message; } /// Returns constant reference to updated message from the \a _I 'th neighbor of variable \a i to variable \a i const Prob & newMessage(size_t i, size_t _I) const { return _edges[i][_I].newMessage; } /// Returns reference to updated message from the \a _I 'th neighbor of variable \a i to variable \a i Prob & newMessage(size_t i, size_t _I) { return _edges[i][_I].newMessage; } /// Returns constant reference to cached index for the edge between variable \a i and its \a _I 'th neighbor const ind_t & index(size_t i, size_t _I) const { return _edges[i][_I].index; } /// Returns reference to cached index for the edge between variable \a i and its \a _I 'th neighbor ind_t & index(size_t i, size_t _I) { return _edges[i][_I].index; } /// Returns constant reference to residual for the edge between variable \a i and its \a _I 'th neighbor const Real & residual(size_t i, size_t _I) const { return _edges[i][_I].residual; } /// Returns reference to residual for the edge between variable \a i and its \a _I 'th neighbor Real & residual(size_t i, size_t _I) { return _edges[i][_I].residual; } /// Calculate the product of factor \a I and the incoming messages /** If \a without_i == \c true, the message coming from variable \a i is omitted from the product * \note This function is used by calcNewMessage() and calcBeliefF() */ virtual Prob calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const; /// Calculate the updated message from the \a _I 'th neighbor of variable \a i to variable \a i virtual void calcNewMessage( size_t i, size_t _I ); /// Replace the "old" message from the \a _I 'th neighbor of variable \a i to variable \a i by the "new" (updated) message void updateMessage( size_t i, size_t _I ); /// Set the residual (difference between new and old message) for the edge between variable \a i and its \a _I 'th neighbor to \a r void updateResidual( size_t i, size_t _I, Real r ); /// Finds the edge which has the maximum residual (difference between new and old message) void findMaxResidual( size_t &i, size_t &_I ); /// Calculates unnormalized belief of variable \a i virtual void calcBeliefV( size_t i, Prob &p ) const; /// Calculates unnormalized belief of factor \a I virtual void calcBeliefF( size_t I, Prob &p ) const { p = calcIncomingMessageProduct( I, false, 0 ); } /// Helper function for constructors virtual void construct(); }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/fbp.h0000644000263000017630000001141711433220723014561 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ /// \file /// \brief Defines class FBP, which implements Fractional Belief Propagation #ifndef __defined_libdai_fbp_h #define __defined_libdai_fbp_h #include #include #include #include #include #include namespace dai { /// Approximate inference algorithm "Fractional Belief Propagation" [\ref WiH03] /** The Fractional Belief Propagation algorithm is like Belief * Propagation, but associates each factor with a weight (scale parameter) * which controls the divergence measure being minimized. Standard * Belief Propagation corresponds to the case of FBP where each weight * is 1. When cast as an EP algorithm, BP (and EP) minimize * the inclusive KL-divergence, i.e. \f$\min_q KL(p||q)\f$ (note that the * Bethe free energy is typically derived from \f$ KL(q||p) \f$). If each * factor \a I has weight \f$ c_I \f$, then FBP minimizes the * alpha-divergence with \f$ \alpha=1/c_I \f$ for that factor, which also * corresponds to Power EP [\ref Min05]. * * The messages \f$m_{I\to i}(x_i)\f$ are passed from factors \f$I\f$ to variables \f$i\f$. * The update equation is given by: * \f[ m_{I\to i}(x_i) \propto \left( \sum_{x_{N_I\setminus\{i\}}} f_I(x_I)^{1/c_I} \prod_{j\in N_I\setminus\{i\}} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \right)^{c_I} \f] * After convergence, the variable beliefs are calculated by: * \f[ b_i(x_i) \propto \prod_{I\in N_i} m_{I\to i} \f] * and the factor beliefs are calculated by: * \f[ b_I(x_I) \propto f_I(x_I)^{1/c_I} \prod_{j \in N_I} m_{I\to j}^{1-1/c_I} \prod_{J\in N_j\setminus\{I\}} m_{J\to j} \f] * The logarithm of the partition sum is approximated by: * \f[ \log Z = \sum_{I} \sum_{x_I} b_I(x_I) \big( \log f_I(x_I) - c_I \log b_I(x_I) \big) + \sum_{i} (c_i - 1) \sum_{x_i} b_i(x_i) \log b_i(x_i) \f] * where the variable weights are defined as * \f[ c_i := \sum_{I \in N_i} c_I \f] * * \todo Add nice way to set weights * \author Frederik Eaton */ class FBP : public BP { protected: /// Factor weights (indexed by factor ID) std::vector _weight; public: /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor FBP() : BP(), _weight() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see BP::Properties */ FBP( const FactorGraph &fg, const PropertySet &opts ) : BP(fg, opts), _weight() { setProperties( opts ); construct(); } //@} /// \name General InfAlg interface //@{ virtual FBP* clone() const { return new FBP(*this); } virtual std::string identify() const; virtual Real logZ() const; //@} /// \name FBP accessors/mutators for weights //@{ /// Returns weight of the \a I 'th factor Real Weight( size_t I ) const { return _weight[I]; } /// Returns constant reference to vector of all factor weights const std::vector& Weights() const { return _weight; } /// Sets the weight of the \a I 'th factor to \a c void setWeight( size_t I, Real c ) { _weight[I] = c; } /// Sets the weights of all factors simultaenously /** \note Faster than calling setWeight(size_t,Real) for each factor */ void setWeights( const std::vector &c ) { _weight = c; } protected: /// Calculate the product of factor \a I and the incoming messages /** If \a without_i == \c true, the message coming from variable \a i is omitted from the product * \note This function is used by calcNewMessage() and calcBeliefF() */ virtual Prob calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const; // Calculate the updated message from the \a _I 'th neighbor of variable \a i to variable \a i virtual void calcNewMessage( size_t i, size_t _I ); // Calculates unnormalized belief of factor \a I virtual void calcBeliefF( size_t I, Prob &p ) const { p = calcIncomingMessageProduct( I, false, 0 ); } // Helper function for constructors virtual void construct(); }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/clustergraph.h0000644000263000017630000003414211433220723016515 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class ClusterGraph, which is used by JTree, TreeEP and HAK /// \todo The "MinFill" and "WeightedMinFill" variable elimination heuristics seem designed for Markov graphs; /// add similar heuristics which are designed for factor graphs. #ifndef __defined_libdai_clustergraph_h #define __defined_libdai_clustergraph_h #include #include #include #include #include namespace dai { /// A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges. /** It is implemented as a bipartite graph with variable (Var) nodes and cluster (VarSet) nodes. * One may think of a ClusterGraph as a FactorGraph without the actual factor values. * \todo Remove the _vars and _clusters variables and use only the graph and a contextual factor graph. */ class ClusterGraph { private: /// Stores the neighborhood structure BipartiteGraph _G; /// Stores the variables corresponding to the nodes std::vector _vars; /// Stores the clusters corresponding to the hyperedges std::vector _clusters; public: /// \name Constructors and destructors //@{ /// Default constructor ClusterGraph() : _G(), _vars(), _clusters() {} /// Construct from vector of VarSet 's ClusterGraph( const std::vector& cls ); /// Construct from a factor graph /** Creates cluster graph which has factors in \a fg as clusters if \a onlyMaximal == \c false, * and only the maximal factors in \a fg if \a onlyMaximal == \c true. */ ClusterGraph( const FactorGraph& fg, bool onlyMaximal ); //@} /// \name Queries //@{ /// Returns a constant reference to the graph structure const BipartiteGraph& bipGraph() const { return _G; } /// Returns number of variables size_t nrVars() const { return _vars.size(); } /// Returns a constant reference to the variables const std::vector& vars() const { return _vars; } /// Returns a constant reference to the \a i'th variable const Var& var( size_t i ) const { DAI_DEBASSERT( i < nrVars() ); return _vars[i]; } /// Returns number of clusters size_t nrClusters() const { return _clusters.size(); } /// Returns a constant reference to the clusters const std::vector& clusters() const { return _clusters; } /// Returns a constant reference to the \a I'th cluster const VarSet& cluster( size_t I ) const { DAI_DEBASSERT( I < nrClusters() ); return _clusters[I]; } /// Returns the index of variable \a n size_t findVar( const Var& n ) const { return find( _vars.begin(), _vars.end(), n ) - _vars.begin(); } /// Returns the index of a cluster \a cl size_t findCluster( const VarSet& cl ) const { return find( _clusters.begin(), _clusters.end(), cl ) - _clusters.begin(); } /// Returns union of clusters that contain the \a i 'th variable VarSet Delta( size_t i ) const { VarSet result; foreach( const Neighbor& I, _G.nb1(i) ) result |= _clusters[I]; return result; } /// Returns union of clusters that contain the \a i 'th (except this variable itself) VarSet delta( size_t i ) const { return Delta( i ) / _vars[i]; } /// Returns \c true if variables with indices \a i1 and \a i2 are adjacent, i.e., both contained in the same cluster bool adj( size_t i1, size_t i2 ) const { if( i1 == i2 ) return false; bool result = false; foreach( const Neighbor& I, _G.nb1(i1) ) if( find( _G.nb2(I).begin(), _G.nb2(I).end(), i2 ) != _G.nb2(I).end() ) { result = true; break; } return result; } /// Returns \c true if cluster \a I is not contained in a larger cluster bool isMaximal( size_t I ) const { DAI_DEBASSERT( I < _G.nrNodes2() ); const VarSet & clI = _clusters[I]; bool maximal = true; // The following may not be optimal, since it may repeatedly test the same cluster *J foreach( const Neighbor& i, _G.nb2(I) ) { foreach( const Neighbor& J, _G.nb1(i) ) if( (J != I) && (clI << _clusters[J]) ) { maximal = false; break; } if( !maximal ) break; } return maximal; } //@} /// \name Operations //@{ /// Inserts a cluster (if it does not already exist) and creates new variables, if necessary /** \note This function could be better optimized if the index of one variable in \a cl would be known. * If one could assume _vars to be ordered, a binary search could be used instead of a linear one. */ size_t insert( const VarSet& cl ) { size_t index = findCluster( cl ); // OPTIMIZE ME if( index == _clusters.size() ) { _clusters.push_back( cl ); // add variables (if necessary) and calculate neighborhood of new cluster std::vector nbs; for( VarSet::const_iterator n = cl.begin(); n != cl.end(); n++ ) { size_t iter = findVar( *n ); // OPTIMIZE ME nbs.push_back( iter ); if( iter == _vars.size() ) { _G.addNode1(); _vars.push_back( *n ); } } _G.addNode2( nbs.begin(), nbs.end(), nbs.size() ); } return index; } /// Erases all clusters that are not maximal ClusterGraph& eraseNonMaximal() { for( size_t I = 0; I < _G.nrNodes2(); ) { if( !isMaximal(I) ) { _clusters.erase( _clusters.begin() + I ); _G.eraseNode2(I); } else I++; } return *this; } /// Erases all clusters that contain the \a i 'th variable ClusterGraph& eraseSubsuming( size_t i ) { DAI_ASSERT( i < nrVars() ); while( _G.nb1(i).size() ) { _clusters.erase( _clusters.begin() + _G.nb1(i)[0] ); _G.eraseNode2( _G.nb1(i)[0] ); } return *this; } /// Eliminates variable with index \a i, without deleting the variable itself /** \note This function can be better optimized */ VarSet elimVar( size_t i ) { DAI_ASSERT( i < nrVars() ); VarSet Di = Delta( i ); insert( Di / var(i) ); eraseSubsuming( i ); eraseNonMaximal(); return Di; } //@} /// \name Input/Ouput //@{ /// Writes a ClusterGraph to an output stream friend std::ostream& operator << ( std::ostream& os, const ClusterGraph& cl ) { os << cl.clusters(); return os; } //@} /// \name Variable elimination //@{ /// Performs Variable Elimination, keeping track of the interactions that are created along the way. /** \tparam EliminationChoice should support "size_t operator()( const ClusterGraph &cl, const std::set &remainingVars )" * \param f function object which returns the next variable index to eliminate; for example, a dai::greedyVariableElimination object. * \param maxStates maximum total number of states of all clusters in the output cluster graph (0 means no limit). * \throws OUT_OF_MEMORY if total number of states becomes larger than maxStates * \return A set of elimination "cliques". */ template ClusterGraph VarElim( EliminationChoice f, size_t maxStates=0 ) const { // Make a copy ClusterGraph cl(*this); cl.eraseNonMaximal(); ClusterGraph result; // Construct set of variable indices std::set varindices; for( size_t i = 0; i < _vars.size(); ++i ) varindices.insert( i ); // Do variable elimination long double totalStates = 0.0; while( !varindices.empty() ) { size_t i = f( cl, varindices ); VarSet Di = cl.elimVar( i ); result.insert( Di ); if( maxStates ) { totalStates += Di.nrStates(); if( totalStates > maxStates ) DAI_THROW(OUT_OF_MEMORY); } varindices.erase( i ); } return result; } //@} }; /// Helper object for dai::ClusterGraph::VarElim() /** Chooses the next variable to eliminate by picking them sequentially from a given vector of variables. */ class sequentialVariableElimination { private: /// The variable elimination sequence std::vector seq; /// Counter size_t i; public: /// Construct from vector of variables sequentialVariableElimination( const std::vector s ) : seq(s), i(0) {} /// Returns next variable in sequence size_t operator()( const ClusterGraph &cl, const std::set &/*remainingVars*/ ); }; /// Helper object for dai::ClusterGraph::VarElim() /** Chooses the next variable to eliminate greedily by taking the one that minimizes * a given heuristic cost function. */ class greedyVariableElimination { public: /// Type of cost functions to be used for greedy variable elimination typedef size_t (*eliminationCostFunction)(const ClusterGraph &, size_t); private: /// Pointer to the cost function used eliminationCostFunction heuristic; public: /// Construct from cost function /** \note Examples of cost functions are eliminationCost_MinFill() and eliminationCost_WeightedMinFill(). */ greedyVariableElimination( eliminationCostFunction h ) : heuristic(h) {} /// Returns the best variable from \a remainingVars to eliminate in the cluster graph \a cl by greedily minimizing the cost function. /** This function calculates the cost for eliminating each variable in \a remaingVars and returns the variable which has lowest cost. */ size_t operator()( const ClusterGraph &cl, const std::set& remainingVars ); }; /// Calculates cost of eliminating the \a i 'th variable from cluster graph \a cl according to the "MinNeighbors" criterion. /** The cost is measured as "number of neigboring nodes in the current adjacency graph", * where the adjacency graph has the variables as its nodes and connects * nodes \a i1 and \a i2 iff \a i1 and \a i2 occur together in some common cluster. */ size_t eliminationCost_MinNeighbors( const ClusterGraph& cl, size_t i ); /// Calculates cost of eliminating the \a i 'th variable from cluster graph \a cl according to the "MinWeight" criterion. /** The cost is measured as "product of weights of neighboring nodes in the current adjacency graph", * where the adjacency graph has the variables as its nodes and connects * nodes \a i1 and \a i2 iff \a i1 and \a i2 occur together in some common cluster. * The weight of a node is the number of states of the corresponding variable. */ size_t eliminationCost_MinWeight( const ClusterGraph& cl, size_t i ); /// Calculates cost of eliminating the \a i 'th variable from cluster graph \a cl according to the "MinFill" criterion. /** The cost is measured as "number of added edges in the adjacency graph", * where the adjacency graph has the variables as its nodes and connects * nodes \a i1 and \a i2 iff \a i1 and \a i2 occur together in some common cluster. */ size_t eliminationCost_MinFill( const ClusterGraph& cl, size_t i ); /// Calculates cost of eliminating the \a i 'th variable from cluster graph \a cl according to the "WeightedMinFill" criterion. /** The cost is measured as "total weight of added edges in the adjacency graph", * where the adjacency graph has the variables as its nodes and connects * nodes \a i1 and \a i2 iff \a i1 and \a i2 occur together in some common cluster. * The weight of an edge is the product of the number of states of the variables corresponding with its nodes. */ size_t eliminationCost_WeightedMinFill( const ClusterGraph& cl, size_t i ); } // end of namespace dai #endif libDAI-0.2.7/include/dai/gibbs.h0000644000263000017630000001274111433220723015101 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008 Frederik Eaton [frederik at ofb dot net] */ /// \file /// \brief Defines class Gibbs, which implements Gibbs sampling #ifndef __defined_libdai_gibbs_h #define __defined_libdai_gibbs_h #include #include #include namespace dai { /// Approximate inference algorithm "Gibbs sampling" /** \author Frederik Eaton */ class Gibbs : public DAIAlgFG { private: /// Type used to store the counts of various states typedef std::vector _count_t; /// Type used to store the joint state of all variables typedef std::vector _state_t; /// Number of samples counted so far (excluding burn-in periods) size_t _sample_count; /// State counts for each variable std::vector<_count_t> _var_counts; /// State counts for each factor std::vector<_count_t> _factor_counts; /// Number of iterations done (including burn-in periods) size_t _iters; /// Current joint state of all variables _state_t _state; /// Joint state with maximum probability seen so far _state_t _max_state; /// Highest score so far Real _max_score; public: /// Parameters for Gibbs struct Properties { /// Maximum number of iterations size_t maxiter; /// Maximum time (in seconds) double maxtime; /// Number of iterations after which a random restart is made size_t restart; /// Number of "burn-in" iterations after each (re)start (for which no statistics are gathered) size_t burnin; /// Verbosity (amount of output sent to stderr) size_t verbose; } props; /// Name of this inference algorithm static const char *Name; public: /// Default constructor Gibbs() : DAIAlgFG(), _sample_count(0), _var_counts(), _factor_counts(), _iters(0), _state(), _max_state(), _max_score(-INFINITY) {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ Gibbs( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), _sample_count(0), _var_counts(), _factor_counts(), _iters(0), _state(), _max_state(), _max_score(-INFINITY) { setProperties( opts ); construct(); } /// \name General InfAlg interface //@{ virtual Gibbs* clone() const { return new Gibbs(*this); } virtual std::string identify() const { return std::string(Name) + printProperties(); } virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &vs ) const; virtual Factor beliefV( size_t i ) const; virtual Factor beliefF( size_t I ) const; virtual std::vector beliefs() const; virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } std::vector findMaximum() const { return _max_state; } virtual void init(); virtual void init( const VarSet &/*ns*/ ) { init(); } virtual Real run(); virtual Real maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual size_t Iterations() const { return _iters; } virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for Gibbs //@{ /// Draw the current joint state of all variables from a uniform random distribution void randomizeState(); /// Return reference to current state of all variables std::vector& state() { return _state; } /// Return constant reference to current state of all variables const std::vector& state() const { return _state; } //@} private: /// Helper function for constructors void construct(); /// Updates all counts (_sample_count, _var_counts, _factor_counts) based on current state void updateCounts(); /// Calculate conditional distribution of variable \a i, given the current state Prob getVarDist( size_t i ); /// Draw state of variable \a i randomly from its conditional distribution and update the current state void resampleVar( size_t i ); /// Calculates linear index into factor \a I corresponding to the current state size_t getFactorEntry( size_t I ); /// Calculates the differences between linear indices into factor \a I corresponding with a state change of variable \a i size_t getFactorEntryDiff( size_t I, size_t i ); }; /// Runs Gibbs sampling for \a maxiter iterations (of which \a burnin for burn-in) on FactorGraph \a fg, and returns the resulting state /** \relates Gibbs */ std::vector getGibbsState( const FactorGraph &fg, size_t maxiter ); } // end of namespace dai /** \example example_sprinkler_gibbs.cpp * This example shows how to use the Gibbs class. */ #endif libDAI-0.2.7/include/dai/weightedgraph.h0000644000263000017630000002133111433220723016630 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /** \file * \brief Defines some utility functions for (weighted) undirected graphs, trees and rooted trees. * \todo Improve general support for graphs and trees (in particular, a good tree implementation is needed). */ #ifndef __defined_libdai_weightedgraph_h #define __defined_libdai_weightedgraph_h #include #include #include #include #include #include // Work-around for bug in boost graph library #include #include #include #include #include #include namespace dai { /// Represents a directed edge class DEdge { public: /// First node index (source of edge) size_t first; /// Second node index (target of edge) size_t second; /// Default constructor DEdge() : first(0), second(0) {} /// Constructs a directed edge pointing from \a m1 to \a m2 DEdge( size_t m1, size_t m2 ) : first(m1), second(m2) {} /// Tests for equality bool operator==( const DEdge &x ) const { return ((first == x.first) && (second == x.second)); } /// Smaller-than operator (performs lexicographical comparison) bool operator<( const DEdge &x ) const { return( (first < x.first) || ((first == x.first) && (second < x.second)) ); } /// Writes a directed edge to an output stream friend std::ostream & operator << (std::ostream & os, const DEdge & e) { os << "(" << e.first << "->" << e.second << ")"; return os; } }; /// Represents an undirected edge class UEdge { public: /// First node index size_t first; /// Second node index size_t second; /// Default constructor UEdge() : first(0), second(0) {} /// Constructs an undirected edge between \a m1 and \a m2 UEdge( size_t m1, size_t m2 ) : first(m1), second(m2) {} /// Construct from DEdge UEdge( const DEdge &e ) : first(e.first), second(e.second) {} /// Tests for inequality (disregarding the ordering of the nodes) bool operator==( const UEdge &x ) { return ((first == x.first) && (second == x.second)) || ((first == x.second) && (second == x.first)); } /// Smaller-than operator bool operator<( const UEdge &x ) const { size_t s = std::min( first, second ); size_t l = std::max( first, second ); size_t xs = std::min( x.first, x.second ); size_t xl = std::max( x.first, x.second ); return( (s < xs) || ((s == xs) && (l < xl)) ); } /// Writes an undirected edge to an output stream friend std::ostream & operator << (std::ostream & os, const UEdge & e) { if( e.first < e.second ) os << "{" << e.first << "--" << e.second << "}"; else os << "{" << e.second << "--" << e.first << "}"; return os; } }; /// Represents an undirected graph, implemented as a std::set of undirected edges class GraphEL : public std::set { public: /// Default constructor GraphEL() {} /// Construct from range of objects that can be cast to UEdge template GraphEL( InputIterator begin, InputIterator end ) { insert( begin, end ); } /// Construct from GraphAL GraphEL( const GraphAL& G ) { for( size_t n1 = 0; n1 < G.nrNodes(); n1++ ) foreach( const Neighbor n2, G.nb(n1) ) if( n1 < n2 ) insert( UEdge( n1, n2 ) ); } }; /// Represents an undirected weighted graph, with weights of type \a T, implemented as a std::map mapping undirected edges to weights template class WeightedGraph : public std::map {}; /// Represents a rooted tree, implemented as a vector of directed edges /** By convention, the edges are stored such that they point away from * the root and such that edges nearer to the root come before edges * farther away from the root. */ class RootedTree : public std::vector { public: /// Default constructor RootedTree() {} /// Constructs a rooted tree from a tree and a root /** \pre T has no cycles and contains node \a Root */ RootedTree( const GraphEL &T, size_t Root ); }; /// Constructs a minimum spanning tree from the (non-negatively) weighted graph \a G. /** \param G Weighted graph that should have non-negative weights. * \param usePrim If true, use Prim's algorithm (complexity O(E log(V))), otherwise, use Kruskal's algorithm (complexity O(E log(E))). * \note Uses implementation from Boost Graph Library. * \note The vertices of \a G must be in the range [0,N) where N is the number of vertices of \a G. */ template RootedTree MinSpanningTree( const WeightedGraph &G, bool usePrim ) { RootedTree result; if( G.size() > 0 ) { using namespace boost; using namespace std; typedef adjacency_list< vecS, vecS, undirectedS, no_property, property > boostGraph; set nodes; vector edges; vector weights; edges.reserve( G.size() ); weights.reserve( G.size() ); for( typename WeightedGraph::const_iterator e = G.begin(); e != G.end(); e++ ) { weights.push_back( e->second ); edges.push_back( e->first ); nodes.insert( e->first.first ); nodes.insert( e->first.second ); } size_t N = nodes.size(); for( set::const_iterator it = nodes.begin(); it != nodes.end(); it++ ) if( *it >= N ) DAI_THROWE(RUNTIME_ERROR,"Vertices must be in range [0..N) where N is the number of vertices."); boostGraph g( edges.begin(), edges.end(), weights.begin(), nodes.size() ); size_t root = *(nodes.begin()); GraphEL tree; if( usePrim ) { // Prim's algorithm vector< graph_traits< boostGraph >::vertex_descriptor > p(N); prim_minimum_spanning_tree( g, &(p[0]) ); // Store tree edges in result for( size_t i = 0; i != p.size(); i++ ) { if( p[i] != i ) tree.insert( UEdge( p[i], i ) ); } } else { // Kruskal's algorithm vector< graph_traits< boostGraph >::edge_descriptor > t; t.reserve( N - 1 ); kruskal_minimum_spanning_tree( g, std::back_inserter(t) ); // Store tree edges in result for( size_t i = 0; i != t.size(); i++ ) { size_t v1 = source( t[i], g ); size_t v2 = target( t[i], g ); if( v1 != v2 ) tree.insert( UEdge( v1, v2 ) ); } } // Direct edges in order to obtain a rooted tree result = RootedTree( tree, root ); } return result; } /// Constructs a minimum spanning tree from the (non-negatively) weighted graph \a G. /** \param G Weighted graph that should have non-negative weights. * \param usePrim If true, use Prim's algorithm (complexity O(E log(V))), otherwise, use Kruskal's algorithm (complexity O(E log(E))). * \note Uses implementation from Boost Graph Library. * \note The vertices of \a G must be in the range [0,N) where N is the number of vertices of \a G. */ template RootedTree MaxSpanningTree( const WeightedGraph &G, bool usePrim ) { if( G.size() == 0 ) return RootedTree(); else { T maxweight = G.begin()->second; for( typename WeightedGraph::const_iterator it = G.begin(); it != G.end(); it++ ) if( it->second > maxweight ) maxweight = it->second; // make a copy of the graph WeightedGraph gr( G ); // invoke MinSpanningTree with negative weights // (which have to be shifted to satisfy positivity criterion) for( typename WeightedGraph::iterator it = gr.begin(); it != gr.end(); it++ ) it->second = maxweight - it->second; return MinSpanningTree( gr, usePrim ); } } } // end of namespace dai #endif libDAI-0.2.7/include/dai/bp_dual.h0000644000263000017630000001264611433220723015425 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] */ /// \file /// \brief Defines class BP_dual, which is used primarily by BBP. /// \idea BP_dual replicates a large part of the functionality of BP; would it not be more efficient to adapt BP instead? /// \author Frederik Eaton #ifndef __defined_libdai_bp_dual_h #define __defined_libdai_bp_dual_h #include #include #include namespace dai { /// Calculates both types of BP messages and their normalizers from an InfAlg. /** BP_dual calculates "dual" versions of BP messages (both messages from factors * to variables and messages from variables to factors), and normalizers, given an InfAlg. * These are computed from the variable and factor beliefs of the InfAlg. * This class is used primarily by BBP. * * \author Frederik Eaton */ class BP_dual { protected: /// Convenience label for storing edge properties template struct _edges_t : public std::vector > {}; /// Groups together the data structures for storing the two types of messages and their normalizers struct messages { /// Unnormalized variable->factor messages _edges_t n; /// Normalizers of variable->factor messages _edges_t Zn; /// Unnormalized Factor->variable messages _edges_t m; /// Normalizers of factor->variable messages _edges_t Zm; }; /// Stores all messages messages _msgs; /// Groups together the data structures for storing the two types of beliefs and their normalizers struct beliefs { /// Unnormalized variable beliefs std::vector b1; /// Normalizers of variable beliefs std::vector Zb1; /// Unnormalized factor beliefs std::vector b2; /// Normalizers of factor beliefs std::vector Zb2; }; /// Stores all beliefs beliefs _beliefs; /// Pointer to the InfAlg object const InfAlg *_ia; /// Does all necessary preprocessing void init(); /// Allocates space for \a _msgs void regenerateMessages(); /// Allocates space for \a _beliefs void regenerateBeliefs(); /// Calculate all messages from InfAlg beliefs void calcMessages(); /// Update factor->variable message (\a i -> \a I) void calcNewM(size_t i, size_t _I); /// Update variable->factor message (\a I -> \a i) void calcNewN(size_t i, size_t _I); /// Calculate all variable and factor beliefs from messages void calcBeliefs(); /// Calculate belief of variable \a i void calcBeliefV(size_t i); /// Calculate belief of factor \a I void calcBeliefF(size_t I); public: /// Construct BP_dual object from (converged) InfAlg object's beliefs and factors. /** \warning A pointer to the the InfAlg object is stored, * so the object must not be destroyed before the BP_dual is destroyed. */ BP_dual( const InfAlg *ia ) : _ia(ia) { init(); } /// Returns the underlying FactorGraph const FactorGraph& fg() const { return _ia->fg(); } /// Returns reference to factor->variable message (\a I -> \a i) Prob & msgM( size_t i, size_t _I ) { return _msgs.m[i][_I]; } /// Returns constant reference to factor->variable message (\a I -> \a i) const Prob & msgM( size_t i, size_t _I ) const { return _msgs.m[i][_I]; } /// Returns reference to variable -> factor message (\a i -> \a I) Prob & msgN( size_t i, size_t _I ) { return _msgs.n[i][_I]; } /// Returns constant reference to variable -> factor message (\a i -> \a I) const Prob & msgN( size_t i, size_t _I ) const { return _msgs.n[i][_I]; } /// Returns reference to normalizer for factor->variable message (\a I -> \a i) Real & zM( size_t i, size_t _I ) { return _msgs.Zm[i][_I]; } /// Returns constant reference to normalizer for factor->variable message (\a I -> \a i) const Real & zM( size_t i, size_t _I ) const { return _msgs.Zm[i][_I]; } /// Returns reference to normalizer for variable -> factor message (\a i -> \a I) Real & zN( size_t i, size_t _I ) { return _msgs.Zn[i][_I]; } /// Returns constant reference to normalizer for variable -> factor message (\a i -> \a I) const Real & zN( size_t i, size_t _I ) const { return _msgs.Zn[i][_I]; } /// Returns belief of variable \a i Factor beliefV( size_t i ) const { return Factor( _ia->fg().var(i), _beliefs.b1[i] ); } /// Returns belief of factor \a I Factor beliefF( size_t I ) const { return Factor( _ia->fg().factor(I).vars(), _beliefs.b2[I] ); } /// Returns normalizer for belief of variable \a i Real beliefVZ( size_t i ) const { return _beliefs.Zb1[i]; } /// Returns normalizer for belief of factor \a I Real beliefFZ( size_t I ) const { return _beliefs.Zb2[I]; } }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/emalg.h0000644000263000017630000004251011433220723015075 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Charles Vaske [cvaske at soe dot ucsc dot edu] * Copyright (C) 2009 University of California, Santa Cruz */ #ifndef __defined_libdai_emalg_h #define __defined_libdai_emalg_h #include #include #include #include #include #include #include /// \file /// \brief Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters) /// \todo Implement parameter estimation for undirected models / factor graphs. namespace dai { /// Base class for parameter estimation methods. /** This class defines the general interface of parameter estimation methods. * * Implementations of this interface (see e.g. CondProbEstimation) should * register a factory function (virtual constructor) via the static * registerMethod() function. * This factory function should return a pointer to a newly constructed * object, whose type is a subclass of ParameterEstimation, and gets as * input a PropertySet of parameters. After a subclass has been registered, * instances of it can be constructed using the construct() method. * * Implementations are responsible for collecting data from a probability * vector passed to it from a SharedParameters container object. * * The default registry only contains CondProbEstimation, named * "CondProbEstimation". * * \author Charles Vaske */ class ParameterEstimation { public: /// Type of pointer to factory function. typedef ParameterEstimation* (*ParamEstFactory)( const PropertySet& ); /// Virtual destructor for deleting pointers to derived classes. virtual ~ParameterEstimation() {} /// Virtual copy constructor. virtual ParameterEstimation* clone() const = 0; /// General factory method that constructs the desired ParameterEstimation subclass /** \param method Name of the subclass that should be constructed; * \param p Parameters passed to constructor of subclass. * \note \a method should either be in the default registry or should be registered first using registerMethod(). * \throw UNKNOWN_PARAMETER_ESTIMATION_METHOD if the requested \a method is not registered. */ static ParameterEstimation* construct( const std::string &method, const PropertySet &p ); /// Register a subclass so that it can be used with construct(). static void registerMethod( const std::string &method, const ParamEstFactory &f ) { if( _registry == NULL ) loadDefaultRegistry(); (*_registry)[method] = f; } /// Estimate the factor using the accumulated sufficient statistics and reset. virtual Prob estimate() = 0; /// Accumulate the sufficient statistics for \a p. virtual void addSufficientStatistics( const Prob &p ) = 0; /// Returns the size of the Prob that should be passed to addSufficientStatistics. virtual size_t probSize() const = 0; private: /// A static registry containing all methods registered so far. static std::map *_registry; /// Registers default ParameterEstimation subclasses (currently, only CondProbEstimation). static void loadDefaultRegistry(); }; /// Estimates the parameters of a conditional probability table, using pseudocounts. /** \author Charles Vaske */ class CondProbEstimation : private ParameterEstimation { private: /// Number of states of the variable of interest size_t _target_dim; /// Current pseudocounts Prob _stats; /// Initial pseudocounts Prob _initial_stats; public: /// Constructor /** For a conditional probability \f$ P( X | Y ) \f$, * \param target_dimension should equal \f$ | X | \f$ * \param pseudocounts are the initial pseudocounts, of length \f$ |X| \cdot |Y| \f$ */ CondProbEstimation( size_t target_dimension, const Prob &pseudocounts ); /// Virtual constructor, using a PropertySet. /** Some keys in the PropertySet are required. * For a conditional probability \f$ P( X | Y ) \f$, * - \a target_dimension should be equal to \f$ | X | \f$ * - \a total_dimension should be equal to \f$ |X| \cdot |Y| \f$ * * An optional key is: * - \a pseudo_count which specifies the initial counts (defaults to 1) */ static ParameterEstimation* factory( const PropertySet &p ); /// Virtual copy constructor virtual ParameterEstimation* clone() const { return new CondProbEstimation( _target_dim, _initial_stats ); } /// Virtual destructor virtual ~CondProbEstimation() {} /// Returns an estimate of the conditional probability distribution. /** The format of the resulting Prob keeps all the values for * \f$ P(X | Y=y) \f$ in sequential order in the array. */ virtual Prob estimate(); /// Accumulate sufficient statistics from the expectations in \a p virtual void addSufficientStatistics( const Prob &p ); /// Returns the required size for arguments to addSufficientStatistics(). virtual size_t probSize() const { return _stats.size(); } }; /// Represents a single factor or set of factors whose parameters should be estimated. /** To ensure that parameters can be shared between different factors during * EM learning, each factor's values are reordered to match a desired variable * ordering. The ordering of the variables in a factor may therefore differ * from the canonical ordering used in libDAI. The SharedParameters * class combines one or more factors (together with the specified orderings * of the variables) with a ParameterEstimation object, taking care of the * necessary permutations of the factor entries / parameters. * * \author Charles Vaske */ class SharedParameters { public: /// Convenience label for an index of a factor in a FactorGraph. typedef size_t FactorIndex; /// Convenience label for a grouping of factor orientations. typedef std::map > FactorOrientations; private: /// Maps factor indices to the corresponding VarSets std::map _varsets; /// Maps factor indices to the corresponding Permute objects that permute the canonical ordering into the desired ordering std::map _perms; /// Maps factor indices to the corresponding desired variable orderings FactorOrientations _varorders; /// Parameter estimation method to be used ParameterEstimation *_estimation; /// Indicates whether \c *this gets ownership of _estimation bool _ownEstimation; /// Calculates the permutation that permutes the canonical ordering into the desired ordering /** \param varOrder Desired ordering of variables * \param outVS Contains variables in \a varOrder represented as a VarSet * \return Permute object for permuting variables in varOrder from the canonical libDAI ordering into the desired ordering */ static Permute calculatePermutation( const std::vector &varOrder, VarSet &outVS ); /// Initializes _varsets and _perms from _varorders and checks whether their state spaces correspond with _estimation.probSize() void setPermsAndVarSetsFromVarOrders(); public: /// Constructor /** \param varorders all the factor orientations for this parameter * \param estimation a pointer to the parameter estimation method * \param ownPE whether the constructed object gets ownership of \a estimation */ SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE=false ); /// Construct a SharedParameters object from an input stream \a is and a factor graph \a fg /** \see \ref fileformats-emalg-sharedparameters * \throw INVALID_EMALG_FILE if the input stream is not valid */ SharedParameters( std::istream &is, const FactorGraph &fg ); /// Copy constructor SharedParameters( const SharedParameters &sp ) : _varsets(sp._varsets), _perms(sp._perms), _varorders(sp._varorders), _estimation(sp._estimation), _ownEstimation(sp._ownEstimation) { // If sp owns its _estimation object, we should clone it instead of copying the pointer if( _ownEstimation ) _estimation = _estimation->clone(); } /// Destructor ~SharedParameters() { // If we own the _estimation object, we should delete it now if( _ownEstimation ) delete _estimation; } /// Collect the sufficient statistics from expected values (beliefs) according to \a alg /** For each of the relevant factors (that shares the parameters we are interested in), * the corresponding belief according to \a alg is obtained and its entries are permuted * such that their ordering corresponds with the shared parameters that we are estimating. * Then, the parameter estimation subclass method addSufficientStatistics() is called with * this vector of expected values of the parameters as input. */ void collectSufficientStatistics( InfAlg &alg ); /// Estimate and set the shared parameters /** Based on the sufficient statistics collected so far, the shared parameters are estimated * using the parameter estimation subclass method estimate(). Then, each of the relevant * factors in \a fg (that shares the parameters we are interested in) is set according * to those parameters (permuting the parameters accordingly). */ void setParameters( FactorGraph &fg ); }; /// A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. /** \author Charles Vaske */ class MaximizationStep { private: /// Vector of parameter estimation tasks of which this maximization step consists std::vector _params; public: /// Default constructor MaximizationStep() : _params() {} /// Construct MaximizationStep from a vector of parameter estimation tasks MaximizationStep( std::vector &maximizations ) : _params(maximizations) {} /// Constructor from an input stream and a corresponding factor graph /** \see \ref fileformats-emalg-maximizationstep */ MaximizationStep( std::istream &is, const FactorGraph &fg_varlookup ); /// Collect the beliefs from this InfAlg as expectations for the next Maximization step void addExpectations( InfAlg &alg ); /// Using all of the currently added expectations, make new factors with maximized parameters and set them in the FactorGraph. void maximize( FactorGraph &fg ); /// \name Iterator interface //@{ /// Iterator over the parameter estimation tasks typedef std::vector::iterator iterator; /// Constant iterator over the parameter estimation tasks typedef std::vector::const_iterator const_iterator; /// Returns iterator that points to the first parameter estimation task iterator begin() { return _params.begin(); } /// Returns constant iterator that points to the first parameter estimation task const_iterator begin() const { return _params.begin(); } /// Returns iterator that points beyond the last parameter estimation task iterator end() { return _params.end(); } /// Returns constant iterator that points beyond the last parameter estimation task const_iterator end() const { return _params.end(); } //@} }; /// EMAlg performs Expectation Maximization to learn factor parameters. /** This requires specifying: * - Evidence (instances of observations from the graphical model), * - InfAlg for performing the E-step (which includes the factor graph), * - a vector of MaximizationStep 's steps to be performed. * * This implementation can perform incremental EM by using multiple * MaximizationSteps. An expectation step is performed between execution * of each MaximizationStep. A call to iterate() will cycle through all * MaximizationStep 's. A call to run() will call iterate() until the * termination criteria have been met. * * Having multiple and separate maximization steps allows for maximizing some * parameters, performing another E-step, and then maximizing separate * parameters, which may result in faster convergence in some cases. * * \author Charles Vaske */ class EMAlg { private: /// All the data samples used during learning const Evidence &_evidence; /// How to do the expectation step InfAlg &_estep; /// The maximization steps to take std::vector _msteps; /// Number of iterations done size_t _iters; /// History of likelihoods std::vector _lastLogZ; /// Maximum number of iterations size_t _max_iters; /// Convergence tolerance Real _log_z_tol; public: /// Key for setting maximum iterations static const std::string MAX_ITERS_KEY; /// Default maximum iterations static const size_t MAX_ITERS_DEFAULT; /// Key for setting likelihood termination condition static const std::string LOG_Z_TOL_KEY; /// Default likelihood tolerance static const Real LOG_Z_TOL_DEFAULT; /// Construct an EMAlg from several objects /** \param evidence Specifies the observed evidence * \param estep Inference algorithm to be used for the E-step * \param msteps Vector of maximization steps, each of which is a group of parameter estimation tasks * \param termconditions Termination conditions @see setTermConditions() */ EMAlg( const Evidence &evidence, InfAlg &estep, std::vector &msteps, const PropertySet &termconditions ) : _evidence(evidence), _estep(estep), _msteps(msteps), _iters(0), _lastLogZ(), _max_iters(MAX_ITERS_DEFAULT), _log_z_tol(LOG_Z_TOL_DEFAULT) { setTermConditions( termconditions ); } /// Construct an EMAlg from Evidence \a evidence, an InfAlg \a estep, and an input stream \a mstep_file /** \see \ref fileformats-emalg */ EMAlg( const Evidence &evidence, InfAlg &estep, std::istream &mstep_file ); /// Change the conditions for termination /** There are two possible parameters in the PropertySet \a p: * - \a max_iters maximum number of iterations * - \a log_z_tol critical proportion of increase in logZ * * \see hasSatisifiedTermConditions() */ void setTermConditions( const PropertySet &p ); /// Determine if the termination conditions have been met. /** There are two sufficient termination conditions: * -# the maximum number of iterations has been performed * -# the ratio of logZ increase over previous logZ is less than the * tolerance, i.e., * \f$ \frac{\log(Z_t) - \log(Z_{t-1})}{| \log(Z_{t-1}) | } < \mathrm{tol} \f$. */ bool hasSatisfiedTermConditions() const; /// Return the last calculated log likelihood Real logZ() const { return _lastLogZ.back(); } /// Returns number of iterations done so far size_t Iterations() const { return _iters; } /// Get the E-step method used const InfAlg& eStep() const { return _estep; } /// Iterate once over all maximization steps /** \return Log-likelihood after iteration */ Real iterate(); /// Iterate over a single MaximizationStep Real iterate( MaximizationStep &mstep ); /// Iterate until termination conditions are satisfied void run(); /// \name Iterator interface //@{ /// Iterator over the maximization steps typedef std::vector::iterator s_iterator; /// Constant iterator over the maximization steps typedef std::vector::const_iterator const_s_iterator; /// Returns iterator that points to the first maximization step s_iterator s_begin() { return _msteps.begin(); } /// Returns constant iterator that points to the first maximization step const_s_iterator s_begin() const { return _msteps.begin(); } /// Returns iterator that points beyond the last maximization step s_iterator s_end() { return _msteps.end(); } /// Returns constant iterator that points beyond the last maximization step const_s_iterator s_end() const { return _msteps.end(); } //@} }; } // end of namespace dai /** \example example_sprinkler_em.cpp * This example shows how to use the EMAlg class. */ #endif libDAI-0.2.7/include/dai/exceptions.h0000644000263000017630000001077411433220723016200 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the Exception class and macros for throwing exceptions and doing assertions #ifndef __defined_libdai_exceptions_h #define __defined_libdai_exceptions_h #include #include #include #include /// Used by DAI_THROW #define DAI_QUOTE(x) #x /// Used by DAI_THROW #define DAI_TOSTRING(x) DAI_QUOTE(x) /// Macro that simplifies throwing an exception with a useful default error message. /** The error message consists of a description of the exception, the source * code file and line number where the exception has been thrown. * \param cod Corresponds to one of the enum values of dai::Exception::Code * * \par Example: * \code * DAI_THROW(NOT_IMPLEMENTED); * \endcode */ #define DAI_THROW(cod) throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__))) /// Macro that simplifies throwing an exception with a user-defined error message. /** \param cod Corresponds to one of the enum values of dai::Exception::Code * \param msg Detailed error message that will be written to std::cerr. * * \par Example: * \code * DAI_THROWE(NOT_IMPLEMENTED,"Detailed error message"); * \endcode */ #define DAI_THROWE(cod,msg) throw dai::Exception(dai::Exception::cod, std::string(__FILE__ ", line " DAI_TOSTRING(__LINE__)), msg) /// Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is defined #define DAI_ASSERT(condition) ((condition) ? ((void)0) : DAI_THROWE(ASSERTION_FAILED, std::string("Assertion \"" #condition "\" failed"))) // Assertion only if DAI_DEBUG is defined #ifdef DAI_DEBUG /// Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined #define DAI_DEBASSERT(x) do {DAI_ASSERT(x);} while(0) #else #define DAI_DEBASSERT(x) do {} while(0) #endif namespace dai { /// Error handling in libDAI is done by throwing an instance of the Exception class. /** The Exception class inherits from std::runtime_error. It defines several types of exceptions * and corresponding error messages. The recommended way to throw an instance of the Exception * class is by using the #DAI_THROW or #DAI_THROWE macros. */ class Exception : public std::runtime_error { public: /// Enumeration of exceptions used in libDAI enum Code {NOT_IMPLEMENTED, ASSERTION_FAILED, IMPOSSIBLE_TYPECAST, OBJECT_NOT_FOUND, BELIEF_NOT_AVAILABLE, UNKNOWN_ENUM_VALUE, UNKNOWN_DAI_ALGORITHM, UNKNOWN_PARAMETER_ESTIMATION_METHOD, UNKNOWN_PROPERTY_TYPE, UNKNOWN_PROPERTY, MALFORMED_PROPERTY, NOT_ALL_PROPERTIES_SPECIFIED, INVALID_ALIAS, CANNOT_READ_FILE, CANNOT_WRITE_FILE, INVALID_FACTORGRAPH_FILE, INVALID_EVIDENCE_FILE, INVALID_EMALG_FILE, NOT_NORMALIZABLE, MULTIPLE_UNDO, FACTORGRAPH_NOT_CONNECTED, INTERNAL_ERROR, RUNTIME_ERROR, OUT_OF_MEMORY, NUM_ERRORS}; // NUM_ERRORS should be the last entry /// Constructor Exception( Code _code, const std::string& msg="", const std::string& detailedMsg="" ) : std::runtime_error(ErrorStrings[_code] + " [" + msg + "]"), errorcode(_code) { if( !detailedMsg.empty() ) std::cerr << "EXCEPTION: " << detailedMsg << std::endl; } /// Returns error code of this exception Code code() const { return errorcode; } /// Returns error message corresponding to an error code const std::string& message( const Code c ) const { return ErrorStrings[c]; } private: /// Contains the error code of this exception Code errorcode; /// Error messages corresponding to the exceptions enumerated above static std::string ErrorStrings[NUM_ERRORS]; }; } #endif libDAI-0.2.7/include/dai/alldai.h0000644000263000017630000001415511433220723015242 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /** \file * \brief Main libDAI header file. It \#includes all other libDAI headers. * * \todo Replace VarSets by SmallSet where appropriate, in order to minimize the use of FactorGraph::findVar(). * * \todo Improve SWIG interfaces and merge their build process with the main build process */ #ifndef __defined_libdai_alldai_h #define __defined_libdai_alldai_h #include #include #include #include #include #include #ifdef DAI_WITH_BP #include #endif #ifdef DAI_WITH_FBP #include #endif #ifdef DAI_WITH_TRWBP #include #endif #ifdef DAI_WITH_MF #include #endif #ifdef DAI_WITH_HAK #include #endif #ifdef DAI_WITH_LC #include #endif #ifdef DAI_WITH_TREEEP #include #endif #ifdef DAI_WITH_JTREE #include #endif #ifdef DAI_WITH_MR #include #endif #ifdef DAI_WITH_GIBBS #include #endif #ifdef DAI_WITH_CBP #include #endif #ifdef DAI_WITH_DECMAP #include #endif /// Namespace for libDAI namespace dai { /// Constructs a new inference algorithm. /** \param name The name of the inference algorithm (should be one of the names in DAINames). * \param fg The FactorGraph that the algorithm should be applied to. * \param opts A PropertySet specifying the options for the algorithm. * \return Returns a pointer to the new InfAlg object; it is the responsibility of the caller to delete it later. * \throw UNKNOWN_DAI_ALGORITHM if the requested name is not known/compiled in. */ InfAlg *newInfAlg( const std::string &name, const FactorGraph &fg, const PropertySet &opts ); /// Constructs a new inference algorithm. /** \param nameOpts The name and options of the inference algorithm (should be in the format "name[key1=val1,key2=val2,...,keyn=valn]"). * \param fg The FactorGraph that the algorithm should be applied to. * \return Returns a pointer to the new InfAlg object; it is the responsibility of the caller to delete it later. * \throw UNKNOWN_DAI_ALGORITHM if the requested name is not known/compiled in. */ InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg ); /// Constructs a new inference algorithm. /** \param nameOpts The name and options of the inference algorithm (should be in the format "name[key1=val1,key2=val2,...,keyn=valn]"). * \param fg The FactorGraph that the algorithm should be applied to. * \param aliases Maps names to strings in the format "name[key1=val1,key2=val2,...,keyn=valn]"; if not empty, alias substitution * will be performed when parsing \a nameOpts by invoking parseNameProperties(const std::string &,const std::map &) * \see newInfAlgFromString(const std::string &, const FactorGraph &) */ InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg, const std::map &aliases ); /// Extracts the name and property set from a string \a s in the format "name[key1=val1,key2=val2,...]" or "name" std::pair parseNameProperties( const std::string &s ); /// Extracts the name and property set from a string \a s in the format "name[key1=val1,key2=val2,...]" or "name", performing alias substitution /** Alias substitution is performed as follows: as long as name appears as a key in \a aliases, * it is substituted by its value. Properties in \a s override those of the alias (in case of * recursion, the "outer" properties override those of the "inner" aliases). */ std::pair parseNameProperties( const std::string &s, const std::map &aliases ); /// Reads aliases from file named \a filename /** \param filename Name of the alias file * \return A map that maps aliases to the strings they should be substituted with. * \see \ref fileformats-aliases */ std::map readAliasesFile( const std::string &filename ); /// Contains the names of all inference algorithms compiled into libDAI. static const char* DAINames[] = { ExactInf::Name, #ifdef DAI_WITH_BP BP::Name, #endif #ifdef DAI_WITH_FBP FBP::Name, #endif #ifdef DAI_WITH_TRWBP TRWBP::Name, #endif #ifdef DAI_WITH_MF MF::Name, #endif #ifdef DAI_WITH_HAK HAK::Name, #endif #ifdef DAI_WITH_LC LC::Name, #endif #ifdef DAI_WITH_TREEEP TreeEP::Name, #endif #ifdef DAI_WITH_JTREE JTree::Name, #endif #ifdef DAI_WITH_MR MR::Name, #endif #ifdef DAI_WITH_GIBBS Gibbs::Name, #endif #ifdef DAI_WITH_CBP CBP::Name, #endif #ifdef DAI_WITH_DECMAP DecMAP::Name, #endif "" }; } // end of namespace dai /** \example example.cpp * This example illustrates how to read a factor graph from a file and how to * run several inference algorithms (junction tree, loopy belief propagation, * and the max-product algorithm) on it. */ /** \example example_imagesegmentation.cpp * This example shows how one can use approximate inference in factor graphs * on a simple vision task: given two images, identify smooth regions where these * two images differ more than some threshold. This can be used to seperate * foreground from background if one image contains the background and the other * one the combination of background and foreground. * * \note In order to build this example, a recent version of CImg needs to be installed. */ /** \example uai2010-aie-solver.cpp * This example contains the full source code of the solver that was one of the * winners (the 'libDAI2' solver) in the UAI 2010 Approximate Inference Challenge * (see http://www.cs.huji.ac.il/project/UAI10/ for more information). */ #endif libDAI-0.2.7/include/dai/doc.h0000644000263000017630000012100011433220723014545 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2008-2010 Joris Mooij [joris dot mooij at libdai dot org] */ /** \file * \brief Contains additional doxygen documentation * * \todo Replace all Name members by virtual functions (or add virtual functions returning the Name) * * \idea Adapt (part of the) guidelines in http://www.boost.org/development/requirements.html#Design_and_Programming * * \idea Use "gcc -MM" to generate dependencies for targets: http://make.paulandlesley.org/autodep.html * * \idea Disentangle structures. In particular, ensure that graphical properties are not * entangled with probabilistic properties. For example, a FactorGraph contains several components: * - a BipartiteGraph * - an array of variable labels * - an array of variable state space sizes * - an array of pointers to factor value vectors * In this way, each factor could be implemented differently, e.g., we could have * some sparse factors, some noisy-OR factors, some dense factors, some arbitrary * precision factors, etcetera. * * \idea Use boost::uBLAS framework to deal with matrices, especially, with 2D sparse matrices. * See http://www.boost.org/libs/numeric/ublas/doc/matrix_sparse.htm * However: I read somewhere that boost::uBLAS concentrates more on correct implementation than on performance. **/ /** \mainpage Reference manual for libDAI - A free/open source C++ library for Discrete Approximate Inference methods * \author Joris Mooij (with contributions of Frederik Eaton) * \version 0.2.7 * \date August 19, 2010 * *
* \section about About libDAI * libDAI is a free/open source C++ library (licensed under GPL 2+) that provides * implementations of various (approximate) inference methods for discrete * graphical models. libDAI supports arbitrary factor graphs with discrete * variables; this includes discrete Markov Random Fields and Bayesian * Networks. * * The library is targeted at researchers. To be able to use the library, a * good understanding of graphical models is needed. * * The best way to use libDAI is by writing C++ code that invokes the library; * in addition, part of the functionality is accessibly by using the * - command line interface * - (limited) MatLab interface * - (experimental) python interface * - (experimental) octave interface. * * libDAI can be used to implement novel (approximate) inference algorithms * and to easily compare the accuracy and performance with existing algorithms * that have been implemented already. * * A solver using libDAI was amongst the three winners of the UAI 2010 Approximate * Inference Challenge (see http://www.cs.huji.ac.il/project/UAI10/ for more * information). The full source code is provided as part of the library. * * \section features Features * Currently, libDAI supports the following (approximate) inference methods: * - Exact inference by brute force enumeration; * - Exact inference by junction-tree methods; * - Mean Field; * - Loopy Belief Propagation [\ref KFL01]; * - Fractional Belief Propagation [\ref WiH03]; * - Tree-Reweighted Belief Propagation [\ref WJW03]; * - Tree Expectation Propagation [\ref MiQ04]; * - Generalized Belief Propagation [\ref YFW05]; * - Double-loop GBP [\ref HAK03]; * - Various variants of Loop Corrected Belief Propagation * [\ref MoK07, \ref MoR05]; * - Gibbs sampler; * - Conditioned Belief Propagation [\ref EaG09]; * - Decimation algorithm. * * These inference methods can be used to calculate partition sums, marginals * over subsets of variables, and MAP states (the joint state of variables that * has maximum probability). * * In addition, libDAI supports parameter learning of conditional probability * tables by Expectation Maximization. * * \section limitations Limitations * libDAI is not intended to be a complete package for approximate inference. * Instead, it should be considered as an "inference engine", providing * various inference methods. In particular, it contains no GUI, currently * only supports its own file format for input and output (although support * for standard file formats may be added later), and provides very limited * visualization functionalities. The only learning method supported currently * is Expectation Maximization (or Maximum Likelihood if no data is missing) * for learning factor parameters. * * \section rationale Rationale * * In my opinion, the lack of open source "reference" implementations hampers * progress in research on approximate inference. Methods differ widely in terms * of quality and performance characteristics, which also depend in different * ways on various properties of the graphical models. Finding the best * approximate inference method for a particular application therefore often * requires empirical comparisons. However, implementing and debugging these * methods takes a lot of time which could otherwise be spent on research. I hope * that this code will aid researchers to be able to easily compare various * (existing as well as new) approximate inference methods, in this way * accelerating research and stimulating real-world applications of approximate * inference. * * \section language Language * Because libDAI is implemented in C++, it is very fast compared with * implementations in MatLab (a factor 1000 faster is not uncommon). * libDAI does provide a (limited) MatLab interface for easy integration with MatLab. * It also provides a command line interface and experimental python and octave * interfaces (thanks to Patrick Pletscher). * * \section compatibility Compatibility * * The code has been developed under Debian GNU/Linux with the GCC compiler suite. * libDAI compiles successfully with g++ versions 3.4 up to 4.4. * * libDAI has also been successfully compiled with MS Visual Studio 2008 under Windows * (but not all build targets are supported yet) and with Cygwin under Windows. * * Finally, libDAI has been compiled successfully on MacOS X. * * \section download Downloading libDAI * The libDAI sources and documentation can be downloaded from the libDAI website: * http://www.libdai.org. * * \section support Mailing list * The Google group "libDAI" (http://groups.google.com/group/libdai) * can be used for getting support and discussing development issues. */ /** \page license License *
* \section license-license License * * libDAI is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * libDAI is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * *
* \section license-gpl GNU General Public License version 2 * * \verbinclude COPYING */ /** \page citations Citing libDAI *
* \section citations-citations Citing libDAI * * If you write a scientific paper describing research that made substantive use * of this library, please cite the following paper describing libDAI:\n * * Joris M. Mooij;\n * libDAI: A free & open source C++ library for Discrete Approximate Inference in graphical models;\n * Journal of Machine Learning Research, in press, 2010.\n * * In BiBTeX format (for your convenience):\n * * 
 *  \@article{mooij2010libDAI,
 *    author  = {Joris M. Mooij},
 *    title   = {lib{DAI}: A free \& open source {C}++ Library for {D}iscrete {A}pproximate {I}nference in graphical models},
 *    journal = {Journal of Machine Learning Research},
 *    volume  = {in press},
 *    year    = 2010
 *  }
* * Moreover, as a personal note, I would appreciate it to be informed about any * publications using libDAI at joris dot mooij at libdai dot org. */ /** \page authors Authors * \section authors-authors People who contributed to libDAI * * \verbinclude AUTHORS */ /** \page build Building libDAI *
* \section build-unix Building libDAI under UNIX variants (Linux / Cygwin / Mac OS X) * * \subsection build-unix-preparations Preparations * * You need: * - a recent version of gcc (at least version 3.4) * - GNU make * - recent boost C++ libraries (at least version 1.37; however, * version 1.37 shipped with Ubuntu 9.04 is known not to work) * - doxygen (only for building the documentation) * - graphviz (only for using some of the libDAI command line utilities) * - CImg library (only for building the image segmentation example) * * On Debian/Ubuntu, you can easily install the required packages with a single command: * 
  apt-get install g++ make doxygen graphviz libboost-dev libboost-graph-dev libboost-program-options-dev libboost-test-dev cimg-dev
* (root permissions needed). * * On Mac OS X (10.4 is known to work), these packages can be installed easily via MacPorts. * If MacPorts is not already installed, install it according to the instructions at http://www.macports.org/. * Then, a simple * 
  sudo port install gmake boost doxygen graphviz
* should be enough to install everything that is needed. * * On Cygwin, the prebuilt Cygwin package boost-1.33.1-x is known not to work. * You can however obtain the latest boost version (you need at least 1.37.0) * from http://www.boost.org/ and build it as described in the next subsection. * * \subsubsection build-unix-boost Building boost under Cygwin * * - Download the latest boost libraries from http://www.boost.org * - Build the required boost libraries using: * 
 *    ./bootstrap.sh --with-libraries=program_options,math,graph,test --prefix=/boost_root/
 *    ./bjam
* - In order to use dynamic linking, the boost .dll's should be somewhere in the path. * This can be achieved by a command like: * 
 *    export PATH=$PATH:/boost_root/stage/lib
* * * \subsection build-unix-libdai Building libDAI * * To build the libDAI source, first copy a template Makefile.* to Makefile.conf * (for example, copy Makefile.LINUX to Makefile.conf if you use GNU/Linux). * Then, edit the Makefile.conf template to adapt it to your local setup. In case * you want to use Boost libraries which are installed in non-standard locations, * you have to tell the compiler and linker about their locations (using the * -I, -L flags for GCC; also you may need to set the LD_LIBRARY_PATH environment * variable correctly before running libDAI binaries). Platform independent build * options can be set in Makefile.ALL. Finally, run * 
  make
* The build includes a regression test, which may take a while to complete. * * If the build is successful, you can test the example program: * 
  examples/example tests/alarm.fg
* or the more extensive test program: * 
  tests/testdai --aliases tests/aliases.conf --filename tests/alarm.fg --methods JTREE_HUGIN BP_SEQMAX
* * *
* \section build-windows Building libDAI under Windows * * \subsection build-windows-preparations Preparations * * You need: * - A recent version of MicroSoft Visual Studio (2008 is known to work) * - recent boost C++ libraries (version 1.37 or higher) * - GNU make (can be obtained from http://gnuwin32.sourceforge.net) * - CImg library (only for building the image segmentation example) * * For the regression test, you need: * - GNU diff, GNU sed (can be obtained from http://gnuwin32.sourceforge.net) * * \subsubsection build-windows-boost Building boost under Windows * * Because building boost under Windows is tricky, I provide some guidance here. * * - Download the boost zip file from http://www.boost.org/users/download * and unpack it somewhere. * - Download the bjam executable from http://www.boost.org/users/download * and unpack it somewhere else. * - Download Boost.Build (v2) from http://www.boost.org/docs/tools/build/index.html * and unpack it yet somewhere else. * - Edit the file \c boost-build.jam in the main boost directory to change the * \c BOOST_BUILD directory to the place where you put Boost.Build (use UNIX * / instead of Windows \ in pathnames). * - Copy the \c bjam.exe executable into the main boost directory. * Now if you issue "bjam --version" you should get a version and no errors. * Issueing "bjam --show-libraries" will show the libraries that will be built. * - The following command builds the boost libraries that are relevant for libDAI: * 
 *    bjam --with-graph --with-math --with-program_options --with-test link=static runtime-link=shared
* * \subsection build-windows-libdai Building libDAI * * To build the source, copy Makefile.WINDOWS to Makefile.conf. Then, edit * Makefile.conf to adapt it to your local setup. Platform independent * build options can be set in Makefile.ALL. Finally, run (from the command line) * 
  make
* The build includes a regression test, which may take a while to complete. * * If the build is successful, you can test the example program: * 
  examples\\example tests\\alarm.fg
* or the more extensive test program: * 
  tests\\testdai --aliases tests\\aliases.conf --filename tests\\alarm.fg --methods JTREE_HUGIN BP_SEQMAX
* * *
* \section build-matlab Building the libDAI MatLab interface * * You need: * - MatLab * - The platform-dependent requirements described above * * First, you need to build the libDAI source as described above for your * platform. By default, the MatLab interface is disabled, so before compiling the * source, you have to enable it in Makefile.ALL by setting * 
  WITH_MATLAB=true
* Also, you have to configure the MatLab-specific parts of * Makefile.conf to match your system (in particular, the Makefile variables ME, * MATLABDIR and MEX). The MEX file extension depends on your platform; for a * 64-bit linux x86_64 system this would be "ME=.mexa64", for a 32-bit linux x86 * system "ME=.mexglx". If you are unsure about your MEX file * extension: it needs to be the same as what the MatLab command "mexext" returns. * The required MEX files are built by issuing * 
  make
* from the command line. The MatLab interface is much less powerful than using * libDAI from C++. There are two reasons for this: (i) it is boring to write MEX * files; (ii) the large performance penalty paid when large data structures (like * factor graphs) have to be converted between their native C++ data structure to * something that MatLab understands. * * A simple example of how to use the MatLab interface is the following (entered * at the MatLab prompt), which performs exact inference by the junction tree * algorithm and approximate inference by belief propagation on the ALARM network: * 
  cd path_to_libdai/matlab
 *  [psi] = dai_readfg ('../tests/alarm.fg');
 *  [logZ,q,md,qv,qf] = dai (psi, 'JTREE', '[updates=HUGIN,verbose=0]')
 *  [logZ,q,md,qv,qf] = dai (psi, 'BP', '[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0]')
* where "path_to_libdai" has to be replaced with the directory in which libDAI * was installed. For other algorithms and some default parameters, see the file * tests/aliases.conf. * *
* \section build-doxygen Building the documentation * * Install doxygen, graphviz and a TeX distribution and use * 
  make doc
* to build the documentation. If the documentation is not clear enough, feel free * to send me an email (or even better, to improve the documentation and send a patch!). * The documentation can also be browsed online at http://www.libdai.org. */ /** \page changelog Change Log * \verbinclude ChangeLog */ /** \page terminology Terminology and conventions * * \section terminology-graphicalmodels Graphical models * * Commonly used graphical models are Bayesian networks and Markov random fields. * In libDAI, both types of graphical models are represented by a slightly more * general type of graphical model: a factor graph [\ref KFL01]. * * An example of a Bayesian network is: * \dot * digraph bayesnet { * size="1,1"; * x0 [label="0"]; * x1 [label="1"]; * x2 [label="2"]; * x3 [label="3"]; * x4 [label="4"]; * x0 -> x1; * x0 -> x2; * x1 -> x3; * x1 -> x4; * x2 -> x4; * } * \enddot * The probability distribution of a Bayesian network factorizes as: * \f[ P(\mathbf{x}) = \prod_{i\in\mathcal{V}} P(x_i \,|\, x_{\mathrm{pa}(i)}) \f] * where \f$\mathrm{pa}(i)\f$ are the parents of node \a i in a DAG. * * The same probability distribution can be represented as a Markov random field: * \dot * graph mrf { * size="1.5,1.5"; * x0 [label="0"]; * x1 [label="1"]; * x2 [label="2"]; * x3 [label="3"]; * x4 [label="4"]; * x0 -- x1; * x0 -- x2; * x1 -- x2; * x1 -- x3; * x1 -- x4; * x2 -- x4; * } * \enddot * * The probability distribution of a Markov random field factorizes as: * \f[ P(\mathbf{x}) = \frac{1}{Z} \prod_{C\in\mathcal{C}} \psi_C(x_C) \f] * where \f$ \mathcal{C} \f$ are the cliques of an undirected graph, * \f$ \psi_C(x_C) \f$ are "potentials" or "compatibility functions", and * \f$ Z \f$ is the partition sum which properly normalizes the probability * distribution. * * Finally, the same probability distribution can be represented as a factor graph: * \dot * graph factorgraph { * size="1.8,1"; * x0 [label="0"]; * x1 [label="1"]; * x2 [label="2"]; * x3 [label="3"]; * x4 [label="4"]; * f01 [shape="box",label=""]; * f02 [shape="box",label=""]; * f13 [shape="box",label=""]; * f124 [shape="box",label=""]; * x0 -- f01; * x1 -- f01; * x0 -- f02; * x2 -- f02; * x1 -- f13; * x3 -- f13; * x1 -- f124; * x2 -- f124; * x4 -- f124; * } * \enddot * * The probability distribution of a factor graph factorizes as: * \f[ P(\mathbf{x}) = \frac{1}{Z} \prod_{I\in \mathcal{F}} f_I(x_I) \f] * where \f$ \mathcal{F} \f$ are the factor nodes of a factor graph (a * bipartite graph consisting of variable nodes and factor nodes), * \f$ f_I(x_I) \f$ are the factors, and \f$ Z \f$ is the partition sum * which properly normalizes the probability distribution. * * Looking at the expressions for the joint probability distributions, * it is obvious that Bayesian networks and Markov random fields can * both be easily represented as factor graphs. Factor graphs most * naturally express the factorization structure of a probability * distribution, and hence are a convenient representation for approximate * inference algorithms, which all try to exploit this factorization. * This is why libDAI uses a factor graph as representation of a * graphical model, implemented in the dai::FactorGraph class. * * \section terminology-inference Inference tasks * * Given a factor graph, specified by the variable nodes \f$\{x_i\}_{i\in\mathcal{V}}\f$ * the factor nodes \f$ \mathcal{F} \f$, the graph structure, and the factors * \f$\{f_I(x_I)\}_{I\in\mathcal{F}}\f$, the following tasks are important: * * - Calculating the partition sum: * \f[ Z = \sum_{\mathbf{x}_{\mathcal{V}}} \prod_{I \in \mathcal{F}} f_I(x_I) \f] * - Calculating the marginal distribution of a subset of variables * \f$\{x_i\}_{i\in A}\f$: * \f[ P(\mathbf{x}_{A}) = \frac{1}{Z} \sum_{\mathbf{x}_{\mathcal{V}\setminus A}} \prod_{I \in \mathcal{F}} f_I(x_I) \f] * - Calculating the MAP state which has the maximum probability mass: * \f[ \mathrm{argmax}_{\mathbf{x}}\,\prod_{I\in\mathcal{F}} f_I(x_I) \f] * * libDAI offers several inference algorithms, which solve (a subset of) these tasks either * approximately or exactly, for factor graphs with discrete variables. The following * algorithms are implemented: * * Exact inference: * - Brute force enumeration: dai::ExactInf * - Junction-tree method: dai::JTree * * Approximate inference: * - Mean Field: dai::MF * - (Loopy) Belief Propagation: dai::BP [\ref KFL01] * - Fractional Belief Propagation: dai::FBP [\ref WiH03] * - Tree-Reweighted Belief Propagation: dai::TRWBP [\ref WJW03] * - Tree Expectation Propagation: dai::TreeEP [\ref MiQ04] * - Generalized Belief Propagation: dai::HAK [\ref YFW05] * - Double-loop GBP: dai::HAK [\ref HAK03] * - Loop Corrected Belief Propagation: dai::MR [\ref MoR05] and dai::LC [\ref MoK07] * - Gibbs sampling: dai::Gibbs * - Conditioned Belief Propagation: dai::CBP [\ref EaG09] * - Decimation algorithm: dai::DecMAP * * Not all inference tasks are implemented by each method: calculating MAP states * is only possible with dai::JTree, dai::BP and dai::DECMAP; calculating partition sums is * not possible with dai::MR, dai::LC and dai::Gibbs. * * \section terminology-learning Parameter learning * * In addition, libDAI supports parameter learning of conditional probability * tables by Expectation Maximization (or Maximum Likelihood, if there is no * missing data). This is implemented in dai::EMAlg. * * \section terminology-variables-states Variables and states * * Linear states are a concept that is used often in libDAI, for example for storing * and accessing factors, which are functions mapping from states of a set of variables * to the real numbers. Internally, a factor is stored as an array, and the array index * of an entry corresponds with the linear state of the set of variables. Below we will * define variables, states and linear states of (sets of) variables. * * \subsection terminology-variables Variables * * Each (random) \a variable has a unique identifier, its \a label (which has * a non-negative integer value). If two variables have the same * label, they are considered as identical. A variable can take on a finite * number of different values or \a states. * * We use the following notational conventions. The discrete * random variable with label \f$l\f$ is denoted as \f$x_l\f$, and the number * of possible values of this variable as \f$S_{x_l}\f$ or simply \f$S_l\f$. * The set of possible values of variable \f$x_l\f$ is denoted * \f$X_l := \{0,1,\dots,S_l-1\}\f$ and called its \a state \a space. * * \subsection terminology-variable-sets Sets of variables and the canonical ordering * * Let \f$A := \{x_{l_1},x_{l_2},\dots,x_{l_n}\}\f$ be a set of variables. * * The \a canonical \a ordering of the variables in \a A is induced by their labels. * That is: if \f$l_1 < l_2\f$, then \f$x_{l_1}\f$ occurs before \f$x_{l_2}\f$ in the * canonical ordering. Below, we will assume that \f$(l_i)_{i=1}^n\f$ is * ordered according to the canonical ordering, i.e., \f$l_1 < l_2 < \dots < l_n\f$. * * \subsection terminology-variable-states States and linear states of sets of variables * * A \a state of the variables in \a A refers to a joint assignment of the * variables, or in other words, to an element of the Cartesian product * \f$ \prod_{i=1}^n X_{l_i}\f$ of the state spaces of the variables in \a A. * Note that a state can also be interpreted as a mapping from variables (or * variable labels) to the natural numbers, which assigns to a variable (or its * label) the corresponding state of the variable. * * A state of \a n variables can be represented as an n-tuple of * non-negative integers: \f$(s_1,s_2,\dots,s_n)\f$ corresponds to the * joint assignment \f$x_{l_1} = s_1, \dots, x_{l_n} = s_n\f$. * Alternatively, a state can be represented compactly as one non-negative integer; * this representation is called a \a linear \a state. The linear state * \a s corresponding to the state \f$(s_1,s_2,\dots,s_n)\f$ would be: * \f[ * s := \sum_{i=1}^n s_i \prod_{j=1}^{i-1} S_{l_j} * = s_1 + s_2 S_{l_1} + s_3 S_{l_1} S_{l_2} + \dots + s_n S_{l_1} \cdots S_{l_{n-1}}. * \f] * * Vice versa, given a linear state \a s for the variables \a A, the * corresponding state \f$s_i\f$ of the \a i 'th variable \f$x_{l_i}\f$ (according to * the canonical ordering of the variables in \a A) is given by * \f[ * s_i = \left\lfloor\frac{s \mbox { mod } \prod_{j=1}^i S_{l_j}}{\prod_{j=1}^{i-1} S_{l_j}}\right\rfloor. * \f] * * Finally, the \a number \a of \a states of the set of variables \a A is simply the * number of different joint assignments of the variables, that is, \f$\prod_{i=1}^n S_{l_i}\f$. */ /** \page fileformats libDAI file formats * * \section fileformats-factorgraph Factor graph (.fg) file format * * This section describes the .fg file format used in libDAI to store factor graphs. * Markov Random Fields are special cases of factor graphs, as are Bayesian * networks. A factor graph can be specified as follows: for each factor, one has * to specify which variables occur in the factor, what their respective * cardinalities (i.e., number of possible values) are, and a table listing all * the values of that factor for all possible configurations of these variables. * * A .fg file is not much more than that. It starts with a line containing the * number of factors in that graph, followed by an empty line. Then all factors * are specified, using one block for each factor, where the blocks are seperated * by empty lines. Each variable occurring in the factor graph has a unique * identifier, its label (which should be a nonnegative integer). Comment lines * which start with # are ignored. * * \subsection fileformats-factorgraph-factor Factor block format * * Each block describing a factor starts with a line containing the number of * variables in that factor. The second line contains the labels of these * variables, seperated by spaces (labels are nonnegative integers and to avoid * confusion, it is suggested to start counting at 0). The third line contains * the number of possible values of each of these variables, also seperated by * spaces. Note that there is some redundancy here, since if a variable appears * in more than one factor, the cardinality of that variable appears several * times in the .fg file; obviously, these cardinalities should be consistent. * The fourth line contains the number of nonzero entries * in the factor table. The rest of the lines contain these nonzero entries; * each line consists of a table index, followed by white-space, followed by the * value corresponding to that table index. The most difficult part is getting * the indexing right. The convention that is used is that the left-most * variables cycle through their values the fastest (similar to MatLab indexing * of multidimensional arrays). * * \subsubsection fileformats-factorgraph-factor-example Example * * An example block describing one factor is: * * 
 *  3
 *  4 8 7
 *  3 2 2
 *  11
 *  0 0.1
 *  1 3.5
 *  2 2.8
 *  3 6.3
 *  4 8.4
 *  6 7.4
 *  7 2.4
 *  8 8.9
 *  9 1.3
 *  10 1.6
 *  11 2.6
 *
* * which corresponds to the following factor: * * \f[ * \begin{array}{ccc|c} * x_4 & x_8 & x_7 & \mbox{value}\\ * \hline * 0 & 0 & 0 & 0.1\\ * 1 & 0 & 0 & 3.5\\ * 2 & 0 & 0 & 2.8\\ * 0 & 1 & 0 & 6.3\\ * 1 & 1 & 0 & 8.4\\ * 2 & 1 & 0 & 0.0\\ * 0 & 0 & 1 & 7.4\\ * 1 & 0 & 1 & 2.4\\ * 2 & 0 & 1 & 8.9\\ * 0 & 1 & 1 & 1.3\\ * 1 & 1 & 1 & 1.6\\ * 2 & 1 & 1 & 2.6 * \end{array} * \f] * * Note that the value of \f$x_4\f$ changes fastest, followed by that of \f$x_8\f$, and \f$x_7\f$ * varies the slowest, corresponding to the second line of the block ("4 8 7"). * Further, \f$x_4\f$ can take on three values, and \f$x_8\f$ and \f$x_7\f$ each have two possible * values, as described in the third line of the block ("3 2 2"). The table * contains 11 non-zero entries (all except for the fifth entry). Note that the * eleventh and twelveth entries are interchanged. * * A final note: the internal representation in libDAI of the factor above is * different, because the variables are ordered according to their indices * (i.e., the ordering would be \f$x_4 x_7 x_8\f$) and the values of the table are * stored accordingly, with the variable having the smallest index changing * fastest: * * \f[ * \begin{array}{ccc|c} * x_4 & x_7 & x_8 & \mbox{value}\\ * \hline * 0 & 0 & 0 & 0.1\\ * 1 & 0 & 0 & 3.5\\ * 2 & 0 & 0 & 2.8\\ * 0 & 1 & 0 & 7.4\\ * 1 & 1 & 0 & 2.4\\ * 2 & 1 & 0 & 8.9\\ * 0 & 0 & 1 & 6.3\\ * 1 & 0 & 1 & 8.4\\ * 2 & 0 & 1 & 0.0\\ * 0 & 1 & 1 & 1.3\\ * 1 & 1 & 1 & 1.6\\ * 2 & 1 & 1 & 2.6 * \end{array} * \f] * * * \section fileformats-evidence Evidence (.tab) file format * * This section describes the .tab fileformat used in libDAI to store "evidence", * i.e., a data set consisting of multiple samples, where each sample is the * observed joint state of some variables. * * A .tab file is a tabular data file, consisting of a header line, followed by * an empty line, followed by the data points, with one line for each data point. * Each line (apart from the empty one) should have the same number of columns, * where columns are separated by one tab character. Each column corresponds to * a variable. The header line consists of the variable labels (corresponding to * dai::Var::label()). The other lines are observed joint states of the variables, i.e., * each line corresponds to a joint observation of the variables, and each column * of a line contains the state of the variable associated with that column. * Missing data is handled simply by having two consecutive tab characters, * without any characters in between. * * \subsection fileformats-evidence-example Example * * 
 *  1       3       2
 *
 *  0       0       1
 *  1       0       1
 *  1               1
 *
* * This would correspond to a data set consisting of three observations concerning * the variables with labels 1, 3 and 2; the first observation being * \f$x_1 = 0, x_3 = 0, x_2 = 1\f$, the second observation being * \f$x_1 = 1, x_3 = 0, x_2 = 1\f$, and the third observation being * \f$x_1 = 1, x_2 = 1\f$ (where the state of \f$x_3\f$ is missing). * * \section fileformats-emalg Expectation Maximization (.em) file format * * This section describes the file format of .em files, which are used * to specify a particular EM algorithm. The .em files are complementary * to .fg files; in other words, an .em file without a corresponding .fg * file is useless. Furthermore, one also needs a corresponding .tab file * containing the data used for parameter learning. * * An .em file starts with a line specifying the number of maximization steps, * followed by an empty line. Then, each maximization step is described in a * block, which should satisfy the format described in the next subsection. * * \subsection fileformats-emalg-maximizationstep Maximization Step block format * * A maximization step block of an .em file starts with a single line * describing the number of shared parameters blocks that will follow. * Then, each shared parameters block follows, in the format described in * the next subsection. * * \subsection fileformats-emalg-sharedparameters Shared parameters block format * * A shared parameters block of an .em file starts with a single line * consisting of the name of a ParameterEstimation subclass * and its parameters in the format of a PropertySet. For example: * 
  CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1]
* The next line contains the number of factors that share their parameters. * Then, each of these factors is specified on separate lines (possibly * seperated by empty lines), where each line consists of several fields * seperated by a space or a tab character. The first field contains * the index of the factor in the factor graph. The following fields should * contain the variable labels of the variables on which that factor depends, * in a specific ordering. This ordering can be different from the canonical * ordering of the variables used internally in libDAI (which would be sorted * ascendingly according to the variable labels). The ordering of the variables * specifies the implicit ordering of the shared parameters: when iterating * over all shared parameters, the corresponding index of the first variable * changes fastest (in the inner loop), and the corresponding index of the * last variable changes slowest (in the outer loop). By choosing the right * ordering, it is possible to let different factors (depending on different * variables) share parameters in parameter learning using EM. This convention * is similar to the convention used in factor blocks in a factor graph .fg * file (see \ref fileformats-factorgraph-factor). * * \section fileformats-aliases Aliases file format * * An aliases file is basically a list of "macros" and the strings that they * should be substituted with. * * Each line of the aliases file can be either empty, contain a comment * (if the first character is a '#') or contain an alias. In the latter case, * the line should contain a colon; the part before the colon contains the * name of the alias, the part after the colon the string that it should be * substituted with. Any whitespace before and after the colon is ignored. * * For example, the following line would define the alias \c BP_SEQFIX * as a shorthand for "BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0]": * 
 *  BP_SEQFIX:  BP[updates=SEQFIX,tol=1e-9,maxiter=10000,logdomain=0]
 *
* * Aliases files can be used to store default options for algorithms. */ /** \page bibliography Bibliography * \anchor EaG09 \ref EaG09 * F. Eaton and Z. Ghahramani (2009): * "Choosing a Variable to Clamp", * Proceedings of the Twelfth International Conference on Artificial Intelligence and Statistics (AISTATS 2009) 5:145-152, * http://jmlr.csail.mit.edu/proceedings/papers/v5/eaton09a/eaton09a.pdf * * \anchor EMK06 \ref EMK06 * G. Elidan and I. McGraw and D. Koller (2006): * "Residual Belief Propagation: Informed Scheduling for Asynchronous Message Passing", * Proceedings of the 22nd Annual Conference on Uncertainty in Artificial Intelligence (UAI-06), * http://uai.sis.pitt.edu/papers/06/UAI2006_0091.pdf * * \anchor HAK03 \ref HAK03 * T. Heskes and C. A. Albers and H. J. Kappen (2003): * "Approximate Inference and Constrained Optimization", * Proceedings of the 19th Annual Conference on Uncertainty in Artificial Intelligence (UAI-03) pp. 313-320, * http://www.snn.ru.nl/reports/Heskes.uai2003.ps.gz * * \anchor KFL01 \ref KFL01 * F. R. Kschischang and B. J. Frey and H.-A. Loeliger (2001): * "Factor Graphs and the Sum-Product Algorithm", * IEEE Transactions on Information Theory 47(2):498-519, * http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=910572 * * \anchor KoF09 \ref KoF09 * D. Koller and N. Friedman (2009): * Probabilistic Graphical Models - Principles and Techniques, * The MIT Press, Cambridge, Massachusetts, London, England. * \anchor Min05 \ref Min05 * T. Minka (2005): * "Divergence measures and message passing", * MicroSoft Research Technical Report MSR-TR-2005-173, * http://research.microsoft.com/en-us/um/people/minka/papers/message-passing/minka-divergence.pdf * * \anchor MiQ04 \ref MiQ04 * T. Minka and Y. Qi (2004): * "Tree-structured Approximations by Expectation Propagation", * Advances in Neural Information Processing Systems (NIPS) 16, * http://books.nips.cc/papers/files/nips16/NIPS2003_AA25.pdf * * \anchor MoK07 \ref MoK07 * J. M. Mooij and H. J. Kappen (2007): * "Loop Corrections for Approximate Inference on Factor Graphs", * Journal of Machine Learning Research 8:1113-1143, * http://www.jmlr.org/papers/volume8/mooij07a/mooij07a.pdf * * \anchor MoK07b \ref MoK07b * J. M. Mooij and H. J. Kappen (2007): * "Sufficient Conditions for Convergence of the Sum-Product Algorithm", * IEEE Transactions on Information Theory 53(12):4422-4437, * http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=4385778 * * \anchor Moo08 \ref Moo08 * J. M. Mooij (2008): * "Understanding and Improving Belief Propagation", * Ph.D. Thesis Radboud University Nijmegen * http://webdoc.ubn.ru.nl/mono/m/mooij_j/undeanimb.pdf * * \anchor MoR05 \ref MoR05 * A. Montanari and T. Rizzo (2005): * "How to Compute Loop Corrections to the Bethe Approximation", * Journal of Statistical Mechanics: Theory and Experiment 2005(10)-P10011, * http://stacks.iop.org/1742-5468/2005/P10011 * * \anchor StW99 \ref StW99 * A. Steger and N. C. Wormald (1999): * "Generating Random Regular Graphs Quickly", * Combinatorics, Probability and Computing Vol 8, Issue 4, pp. 377-396, * http://www.math.uwaterloo.ca/~nwormald/papers/randgen.pdf * * \anchor WiH03 \ref WiH03 * W. Wiegerinck and T. Heskes (2003): * "Fractional Belief Propagation", * Advances in Neural Information Processing Systems (NIPS) 15, pp. 438-445, * http://books.nips.cc/papers/files/nips15/LT16.pdf * * \anchor WJW03 \ref WJW03 * M. J. Wainwright, T. S. Jaakkola and A. S. Willsky (2003): * "Tree-reweighted belief propagation algorithms and approximate ML estimation by pseudo-moment matching", * 9th Workshop on Artificial Intelligence and Statistics, * http://www.eecs.berkeley.edu/~wainwrig/Papers/WJW_AIStat03.pdf * * \anchor YFW05 \ref YFW05 * J. S. Yedidia and W. T. Freeman and Y. Weiss (2005): * "Constructing Free-Energy Approximations and Generalized Belief Propagation Algorithms", * IEEE Transactions on Information Theory 51(7):2282-2312, * http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=1459044 */ /** \page discussion Ideas not worth exploring * \section discuss_extendedgraphs Extended factorgraphs/regiongraphs * * A FactorGraph and a RegionGraph are often equipped with * additional properties for nodes and edges. The code to initialize those * is often quite similar. Maybe one could abstract this, e.g.: * \code * template * class ExtFactorGraph : public FactorGraph { * public: * std::vector node1Props; * std::vector node2Props; * std::vector > edgeProps; * // ... * } * \endcode * * Advantages: * - Less code duplication. * - Easier maintainability. * - Easier to write new inference algorithms. * * Disadvantages: * - Cachability may be worse. * - A problem is the case where there are no properties for either type of nodes or for edges. * Maybe this can be solved using specializations, or using variadac template arguments? * Another possible solution would be to define a "class Empty {}", and add some code * that checks for the typeid, comparing it with Empty, and doing something special in that case * (e.g., not allocating memory). * - The main disadvantage of this approach seems to be that it leads to even more entanglement. * Therefore this is probably a bad idea. * * \section discuss_templates Polymorphism by template parameterization * * Instead of polymorphism by inheritance, use polymorphism by template parameterization. * For example, the real reason for introducing the complicated inheritance scheme of dai::InfAlg * was for functions like dai::calcMarginal. Instead, one could use a template function: * \code * template * Factor calcMarginal( const InfAlg &obj, const VarSet &ns, bool reInit ); * \endcode * This would assume that the type InfAlg supports certain methods. Ideally, one would use * concepts to define different classes of inference algorithms with different capabilities, * for example the ability to calculate logZ, the ability to calculate marginals, the ability to * calculate bounds, the ability to calculate MAP states, etc. Then, one would use traits * classes in order to be able to query the capabilities of the model. For example, one would be * able to query whether the inference algorithm supports calculation of logZ. Unfortunately, * this is compile-time polymorphism, whereas tests/testdai needs runtime polymorphism. * Therefore this is probably a bad idea. */ libDAI-0.2.7/include/dai/hak.h0000644000263000017630000001466611433220723014566 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class HAK, which implements a variant of Generalized Belief Propagation. /// \idea Implement more general region graphs and corresponding Generalized Belief Propagation updates as described in [\ref YFW05]. /// \todo Use ClusterGraph instead of a vector for speed. /// \todo Optimize this code for large factor graphs. /// \todo Implement GBP parent-child algorithm. #ifndef __defined_libdai_hak_h #define __defined_libdai_hak_h #include #include #include #include #include namespace dai { /// Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [\ref HAK03] class HAK : public DAIAlgRG { private: /// Outer region beliefs std::vector _Qa; /// Inner region beliefs std::vector _Qb; /// Messages from outer to inner regions std::vector > _muab; /// Messages from inner to outer regions std::vector > _muba; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for HAK struct Properties { /// Enumeration of possible cluster choices /** The following cluster choices are defined: * - MIN minimal clusters, i.e., one outer region for each maximal factor * - DELTA one outer region for each variable and its Markov blanket * - LOOP one cluster for each loop of length at most \a Properties::loopdepth, and in addition one cluster for each maximal factor * - BETHE Bethe approximation (one outer region for each maximal factor, inner regions are single variables) */ DAI_ENUM(ClustersType,MIN,BETHE,DELTA,LOOP); /// Enumeration of possible message initializations DAI_ENUM(InitType,UNIFORM,RANDOM); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Maximum time (in seconds) double maxtime; /// Tolerance for convergence test Real tol; /// Damping constant (0.0 means no damping, 1.0 is maximum damping) Real damping; /// How to choose the outer regions ClustersType clusters; /// How to initialize the messages InitType init; /// Use single-loop (GBP) or double-loop (HAK) bool doubleloop; /// Depth of loops (only relevant for \a clusters == \c ClustersType::LOOP) size_t loopdepth; } props; /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor HAK() : DAIAlgRG(), _Qa(), _Qb(), _muab(), _muba(), _maxdiff(0.0), _iters(0U), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ HAK( const FactorGraph &fg, const PropertySet &opts ); /// Construct from RegionGraph \a rg and PropertySet \a opts HAK( const RegionGraph &rg, const PropertySet &opts ); //@} /// \name General InfAlg interface //@{ virtual HAK* clone() const { return new HAK(*this); } virtual std::string identify() const; virtual Factor belief( const VarSet &vs ) const; virtual std::vector beliefs() const; virtual Real logZ() const; virtual void init(); virtual void init( const VarSet &vs ); virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for HAK //@{ /// Returns reference to message from outer region \a alpha to its \a _beta 'th neighboring inner region Factor & muab( size_t alpha, size_t _beta ) { return _muab[alpha][_beta]; } /// Returns reference to message the \a _beta 'th neighboring inner region of outer region \a alpha to that outer region Factor & muba( size_t alpha, size_t _beta ) { return _muba[alpha][_beta]; } /// Returns belief of outer region \a alpha const Factor& Qa( size_t alpha ) const { return _Qa[alpha]; }; /// Returns belief of inner region \a beta const Factor& Qb( size_t beta ) const { return _Qb[beta]; }; /// Runs single-loop algorithm (algorithm 1 in [\ref HAK03]) Real doGBP(); /// Runs double-loop algorithm (as described in section 4.2 of [\ref HAK03]), which always convergences Real doDoubleLoop(); //@} private: /// Helper function for constructors void construct(); /// Recursive procedure for finding clusters of variables containing loops of length at most \a length /** \param fg the factor graph * \param allcl the clusters found so far * \param newcl partial candidate cluster * \param root start (and end) point of the loop * \param length number of variables that may be added to \a newcl * \param vars neighboring variables of \a newcl * \return allcl all clusters of variables with loops of length at most \a length passing through root */ void findLoopClusters( const FactorGraph &fg, std::set &allcl, VarSet newcl, const Var & root, size_t length, VarSet vars ); }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/exactinf.h0000644000263000017630000000740211433220723015612 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines ExactInf class, which can be used for exact inference on small factor graphs. #ifndef __defined_libdai_exactinf_h #define __defined_libdai_exactinf_h #include #include #include #include namespace dai { /// Exact inference algorithm using brute force enumeration (mainly useful for testing purposes) /** Inference is done simply by multiplying all factors together into one large factor, * and then calculating marginals and partition sum from the product. * \note This inference method can easily exhaust all available memory; in that case, one * may try the JTree class instead. */ class ExactInf : public DAIAlgFG { public: /// Parameters for ExactInf struct Properties { /// Verbosity (amount of output sent to stderr) size_t verbose; } props; /// Name of this inference algorithm static const char *Name; private: /// All single variable marginals std::vector _beliefsV; /// All factor variable marginals std::vector _beliefsF; /// Logarithm of partition sum Real _logZ; public: /// \name Constructors/destructors //@{ /// Default constructor ExactInf() : DAIAlgFG(), props(), _beliefsV(), _beliefsF(), _logZ(0) {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ ExactInf( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), props(), _beliefsV(), _beliefsF(), _logZ() { setProperties( opts ); construct(); } //@} /// \name General InfAlg interface //@{ virtual ExactInf* clone() const { return new ExactInf(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &vs ) const; virtual Factor beliefV( size_t i ) const { return _beliefsV[i]; } virtual Factor beliefF( size_t I ) const { return _beliefsF[I]; } virtual std::vector beliefs() const; virtual Real logZ() const { return _logZ; } /** \note The complexity of this calculation is exponential in the number of variables. */ std::vector findMaximum() const; virtual void init(); virtual void init( const VarSet &/*ns*/ ) {} virtual Real run(); virtual Real maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual size_t Iterations() const { DAI_THROW(NOT_IMPLEMENTED); return 0; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} /// \name Additional interface specific for ExactInf //@{ /// Calculates marginal probability distribution for variables \a vs /** \note The complexity of this calculation is exponential in the number of variables. */ Factor calcMarginal( const VarSet &vs ) const; //@} private: /// Helper function for constructors void construct(); }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/enum.h0000644000263000017630000000631611433220723014760 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the DAI_ENUM macro, which can be used to define an \c enum with additional functionality. #ifndef __defined_libdai_enum_h #define __defined_libdai_enum_h #include #include #include /// Extends the C++ \c enum type by supporting input/output streaming and conversion to and from const char* and \c size_t /** For more details see the source code. * * \par Example: * \code * DAI_ENUM(colors,RED,GREEN,BLUE) * \endcode * defines a class \a colors encapsulating an * \code * enum {RED, GREEN, BLUE}; * \endcode * which offers additional functionality over the plain \c enum keyword. */ #define DAI_ENUM(x,val0,...) class x {\ public:\ enum value {val0,__VA_ARGS__};\ \ x() : v(val0) {}\ \ x(value w) : v(w) {}\ \ x(char const *w) {\ static char const* labelstring = #val0 "," #__VA_ARGS__;\ size_t pos_begin = 0;\ size_t i = 0;\ for( size_t pos_end = 0; ; pos_end++ ) {\ if( (labelstring[pos_end] == ',') || (labelstring[pos_end] == '\0') ) {\ if( (strlen( w ) == pos_end - pos_begin) && (strncmp( labelstring + pos_begin, w, pos_end - pos_begin ) == 0) ) {\ v = (value)i;\ return;\ } else {\ i++;\ pos_begin = pos_end + 1;\ }\ }\ if( labelstring[pos_end] == '\0' )\ break;\ }\ DAI_THROWE(UNKNOWN_ENUM_VALUE,"'" + std::string(w) + "' is not in [" + std::string(labelstring) + "]");\ }\ \ operator value() const { return v; }\ \ operator size_t() const { return (size_t)v; }\ \ operator char const*() const {\ static char labelstring[] = #val0 "," #__VA_ARGS__;\ size_t pos_begin = 0;\ size_t i = 0;\ for( size_t pos_end = 0; ; pos_end++ )\ if( (labelstring[pos_end] == ',') || (labelstring[pos_end] == '\0') ) {\ if( (size_t)v == i ) {\ labelstring[pos_end] = '\0';\ return labelstring + pos_begin;\ } else {\ i++;\ pos_begin = pos_end + 1;\ }\ }\ }\ \ friend std::istream& operator >> (std::istream& is, x& y) {\ std::string s;\ is >> s;\ y = x(s.c_str());\ return is;\ }\ \ friend std::ostream& operator << (std::ostream& os, const x& y) {\ os << (const char *)y;\ return os;\ }\ \ protected:\ value v;\ }; #endif libDAI-0.2.7/include/dai/mf.h0000644000263000017630000001030311433220723014405 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class MF which implements the Mean Field algorithm #ifndef __defined_libdai_mf_h #define __defined_libdai_mf_h #include #include #include #include #include namespace dai { /// Approximate inference algorithm "Mean Field" /** The Mean Field algorithm iteratively calculates approximations of * single variable marginals (beliefs). The update equation for * a single belief \f$b_i\f$ is given by: * \f[ b_i^{\mathrm{new}}(x_i) \propto \prod_{I\in N_i} \exp \left( \sum_{x_{N_I \setminus \{i\}}} \log f_I(x_I) \prod_{j \in N_I \setminus \{i\}} b_j(x_j) \right) \f] * for naive mean field and by * \f[ b_i^{\mathrm{new}}(x_i) \propto \prod_{I\in N_i} \left( \sum_{x_{N_I \setminus \{i\}}} f_I(x_I) \prod_{j \in N_I \setminus \{i\}} b_j(x_j) \right) \f] * for hard-spin mean field. * These update equations are performed for all variables until convergence. */ class MF : public DAIAlgFG { private: /// Current approximations of single variable marginals std::vector _beliefs; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for MF struct Properties { /// Enumeration of possible message initializations DAI_ENUM(InitType,UNIFORM,RANDOM); /// Enumeration of possible update types DAI_ENUM(UpdateType,NAIVE,HARDSPIN); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test Real tol; /// Damping constant (0.0 means no damping, 1.0 is maximum damping) Real damping; /// How to initialize the messages/beliefs InitType init; /// How to update the messages/beliefs UpdateType updates; } props; /// Name of this inference algorithm static const char *Name; public: /// \name Constructors/destructors //@{ /// Default constructor MF() : DAIAlgFG(), _beliefs(), _maxdiff(0.0), _iters(0U), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ MF( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), _beliefs(), _maxdiff(0.0), _iters(0U), props() { setProperties( opts ); construct(); } //@} /// \name General InfAlg interface //@{ virtual MF* clone() const { return new MF(*this); } virtual std::string identify() const; virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); } virtual Factor belief( const VarSet &vs ) const; virtual Factor beliefV( size_t i ) const; virtual std::vector beliefs() const; virtual Real logZ() const; virtual void init(); virtual void init( const VarSet &ns ); virtual Real run(); virtual Real maxDiff() const { return _maxdiff; } virtual size_t Iterations() const { return _iters; } virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; } virtual void setProperties( const PropertySet &opts ); virtual PropertySet getProperties() const; virtual std::string printProperties() const; //@} private: /// Helper function for constructors void construct(); /// Calculates an updated belief of variable \a i Factor calcNewBelief( size_t i ); }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/smallset.h0000644000263000017630000002371111433220723015636 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the SmallSet<> class, which represents a set (optimized for a small number of elements). #ifndef __defined_libdai_smallset_h #define __defined_libdai_smallset_h #include #include #include namespace dai { /// Represents a set; the implementation is optimized for a small number of elements. /** SmallSet uses an ordered std::vector<T> to represent a set; this is faster than * using a std::set<T> if the number of elements is small. * \tparam T Should be less-than-comparable. */ template class SmallSet { private: /// The elements in this set std::vector _elements; public: /// \name Constructors and destructors //@{ /// Default constructor (constructs an empty set) SmallSet() : _elements() {} /// Construct a set consisting of one element SmallSet( const T &t ) : _elements() { _elements.push_back( t ); } /// Construct a set consisting of two elements SmallSet( const T &t1, const T &t2 ) { if( t1 < t2 ) { _elements.push_back( t1 ); _elements.push_back( t2 ); } else if( t2 < t1 ) { _elements.push_back( t2 ); _elements.push_back( t1 ); } else _elements.push_back( t1 ); } /// Construct a SmallSet from a range of elements. /** \tparam TIterator Iterates over instances of type \a T. * \param begin Points to first element to be added. * \param end Points just beyond last element to be added. * \param sizeHint For efficiency, the number of elements can be speficied by \a sizeHint. * \note The \a sizeHint parameter used to be optional in libDAI versions 0.2.4 and earlier. */ template SmallSet( TIterator begin, TIterator end, size_t sizeHint ) { _elements.reserve( sizeHint ); _elements.insert( _elements.begin(), begin, end ); std::sort( _elements.begin(), _elements.end() ); typename std::vector::iterator new_end = std::unique( _elements.begin(), _elements.end() ); _elements.erase( new_end, _elements.end() ); } //@} /// \name Operators for set-theoretic operations //@{ /// Inserts \a t into \c *this SmallSet& insert( const T& t ) { typename SmallSet::iterator it = std::lower_bound( _elements.begin(), _elements.end(), t ); if( (it == _elements.end()) || (*it != t) ) _elements.insert( it, t ); return *this; } /// Erases \a t from \c *this SmallSet& erase( const T& t ) { return (*this /= t); } /// Set-minus operator: returns all elements in \c *this, except those in \a x SmallSet operator/ ( const SmallSet& x ) const { SmallSet res; std::set_difference( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) ); return res; } /// Set-union operator: returns all elements in \c *this, plus those in \a x SmallSet operator| ( const SmallSet& x ) const { SmallSet res; std::set_union( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) ); return res; } /// Set-intersection operator: returns all elements in \c *this that are also contained in \a x SmallSet operator& ( const SmallSet& x ) const { SmallSet res; std::set_intersection( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) ); return res; } /// Erases from \c *this all elements in \a x SmallSet& operator/= ( const SmallSet& x ) { return (*this = (*this / x)); } /// Erases one element SmallSet& operator/= ( const T &t ) { typename std::vector::iterator pos = lower_bound( _elements.begin(), _elements.end(), t ); if( pos != _elements.end() ) if( *pos == t ) // found element, delete it _elements.erase( pos ); return *this; } /// Adds to \c *this all elements in \a x SmallSet& operator|= ( const SmallSet& x ) { return( *this = (*this | x) ); } /// Adds one element SmallSet& operator|= ( const T& t ) { typename std::vector::iterator pos = lower_bound( _elements.begin(), _elements.end(), t ); if( pos == _elements.end() || *pos != t ) // insert it _elements.insert( pos, t ); return *this; } /// Erases from \c *this all elements not in \a x SmallSet& operator&= ( const SmallSet& x ) { return (*this = (*this & x)); } /// Returns \c true if \c *this is a subset of \a x bool operator<< ( const SmallSet& x ) const { return std::includes( x._elements.begin(), x._elements.end(), _elements.begin(), _elements.end() ); } /// Returns \c true if \a x is a subset of \c *this bool operator>> ( const SmallSet& x ) const { return std::includes( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end() ); } //@} /// \name Queries //@{ /// Returns \c true if \c *this and \a x have elements in common bool intersects( const SmallSet& x ) const { return( (*this & x).size() > 0 ); } /// Returns \c true if \c *this contains the element \a t bool contains( const T &t ) const { return std::binary_search( _elements.begin(), _elements.end(), t ); } /// Returns number of elements typename std::vector::size_type size() const { return _elements.size(); } /// Returns whether \c *this is empty bool empty() const { return _elements.size() == 0; } /// Returns reference to the elements std::vector& elements() { return _elements; } /// Returns constant reference to the elements const std::vector& elements() const { return _elements; } //@} /// Constant iterator over the elements typedef typename std::vector::const_iterator const_iterator; /// Iterator over the elements typedef typename std::vector::iterator iterator; /// Constant reverse iterator over the elements typedef typename std::vector::const_reverse_iterator const_reverse_iterator; /// Reverse iterator over the elements typedef typename std::vector::reverse_iterator reverse_iterator; /// \name Iterator interface //@{ /// Returns iterator that points to the first element iterator begin() { return _elements.begin(); } /// Returns constant iterator that points to the first element const_iterator begin() const { return _elements.begin(); } /// Returns iterator that points beyond the last element iterator end() { return _elements.end(); } /// Returns constant iterator that points beyond the last element const_iterator end() const { return _elements.end(); } /// Returns reverse iterator that points to the last element reverse_iterator rbegin() { return _elements.rbegin(); } /// Returns constant reverse iterator that points to the last element const_reverse_iterator rbegin() const { return _elements.rbegin(); } /// Returns reverse iterator that points beyond the first element reverse_iterator rend() { return _elements.rend(); } /// Returns constant reverse iterator that points beyond the first element const_reverse_iterator rend() const { return _elements.rend(); } /// Returns reference to first element T& front() { return _elements.front(); } /// Returns constant reference to first element const T& front() const { return _elements.front(); } /// Returns reference to last element T& back() { return _elements.back(); } /// Returns constant reference to last element const T& back() const { return _elements.back(); } //@} /// \name Comparison operators //@{ /// Returns \c true if \a a and \a b are identical friend bool operator==( const SmallSet &a, const SmallSet &b ) { return (a._elements == b._elements); } /// Returns \c true if \a a and \a b are not identical friend bool operator!=( const SmallSet &a, const SmallSet &b ) { return !(a._elements == b._elements); } /// Lexicographical comparison of elements friend bool operator<( const SmallSet &a, const SmallSet &b ) { return a._elements < b._elements; } //@} /// \name Streaming input/output //@{ /// Writes a SmallSet to an output stream friend std::ostream& operator << ( std::ostream& os, const SmallSet& x ) { os << "{"; for( typename std::vector::const_iterator it = x.begin(); it != x.end(); it++ ) os << (it != x.begin() ? ", " : "") << *it; os << "}"; return os; } //@} }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/varset.h0000644000263000017630000001625111433220723015317 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the VarSet class, which represents a set of random variables. #ifndef __defined_libdai_varset_h #define __defined_libdai_varset_h #include #include #include #include #include #include namespace dai { // Predefine for definitions of calcLinearState() and calcState() class VarSet; /// Calculates the linear index in the Cartesian product of the variables in \a vs that corresponds to a particular joint assignment of the variables, specified by \a state. /** \param vs Set of variables for which the linear state should be calculated; * \param state Specifies the states of some variables. * \return The linear index in the Cartesian product of the variables in \a vs * corresponding with the joint assignment specified by \a state, where variables * for which no state is specified are assumed to be in state 0. * * The linear index is calculated as follows. The variables in \a vs are * ordered according to their label (in ascending order); say \a vs corresponds with * the set \f$\{x_{l(0)},x_{l(1)},\dots,x_{l(n-1)}\}\f$ with \f$l(0) < l(1) < \dots < l(n-1)\f$, * where variable \f$x_l\f$ has label \a l. Denote by \f$S_l\f$ the number of possible values * ("states") of variable \f$x_l\f$. The argument \a state corresponds * with a mapping \a s that assigns to each variable \f$x_l\f$ a state \f$s(x_l) \in \{0,1,\dots,S_l-1\}\f$, * where \f$s(x_l)=0\f$ if \f$x_l\f$ is not specified in \a state. The linear index \f$S\f$ corresponding * with \a state is now calculated by: * \f{eqnarray*} * S &:=& \sum_{i=0}^{n-1} s(x_{l(i)}) \prod_{j=0}^{i-1} S_{l(j)} \\ * &= & s(x_{l(0)}) + s(x_{l(1)}) S_{l(0)} + s(x_{l(2)}) S_{l(0)} S_{l(1)} + \dots + s(x_{l(n-1)}) S_{l(0)} \cdots S_{l(n-2)}. * \f} * * \note If \a vs corresponds with \f$\{x_l\}_{l\in L}\f$, and \a state specifies a state * for each variable \f$x_l\f$ for \f$l\in L\f$, calcLinearState() induces a mapping * \f$\sigma : \prod_{l\in L} X_l \to \{0,1,\dots,\prod_{l\in L} S_l-1\}\f$ that * maps a joint state to a linear index; this is the inverse of the mapping * \f$\sigma^{-1}\f$ induced by calcState(). * * \see calcState() */ size_t calcLinearState( const VarSet &vs, const std::map &state ); /// Calculates the joint assignment of the variables in \a vs corresponding to the linear index \a linearState. /** \param vs Set of variables to which \a linearState refers * \param linearState should be smaller than vs.nrStates(). * \return A mapping \f$s\f$ that maps each Var \f$x_l\f$ in \a vs to its state \f$s(x_l)\f$, as specified by \a linearState. * * The variables in \a vs are ordered according to their label (in ascending order); say \a vs corresponds with * the set \f$\{x_{l(0)},x_{l(1)},\dots,x_{l(n-1)}\}\f$ with \f$l(0) < l(1) < \dots < l(n-1)\f$, * where variable \f$x_l\f$ has label \a l. Denote by \f$S_l\f$ the number of possible values * ("states") of variable \f$x_l\f$ with label \a l. * The mapping \f$s\f$ returned by this function is defined as: * \f{eqnarray*} * s(x_{l(i)}) = \left\lfloor\frac{S \mbox { mod } \prod_{j=0}^{i} S_{l(j)}}{\prod_{j=0}^{i-1} S_{l(j)}}\right\rfloor \qquad \mbox{for all $i=0,\dots,n-1$}. * \f} * where \f$S\f$ denotes the value of \a linearState. * * \note If \a vs corresponds with \f$\{x_l\}_{l\in L}\f$, calcState() induces a mapping * \f$\sigma^{-1} : \{0,1,\dots,\prod_{l\in L} S_l-1\} \to \prod_{l\in L} X_l\f$ that * maps a linear index to a joint state; this is the inverse of the mapping \f$\sigma\f$ * induced by calcLinearState(). * * \see calcLinearState() */ std::map calcState( const VarSet &vs, size_t linearState ); /// Represents a set of variables. /** \note A VarSet is implemented using a SmallSet instead * of the more natural std::set because of efficiency reasons. * That is, internally, the variables in the set are sorted ascendingly * according to their labels. */ class VarSet : public SmallSet { public: /// \name Constructors and destructors //@{ /// Default constructor (constructs an empty set) VarSet() : SmallSet() {} /// Construct from \link SmallSet \endlink<\link Var \endlink> \a x VarSet( const SmallSet &x ) : SmallSet(x) {} /// Construct a VarSet with one element, \a v VarSet( const Var &v ) : SmallSet(v) {} /// Construct a VarSet with two elements, \a v1 and \a v2 VarSet( const Var &v1, const Var &v2 ) : SmallSet(v1,v2) {} /// Construct a VarSet from the range between \a begin and \a end. /** \tparam VarIterator Iterates over instances of type Var. * \param begin Points to first Var to be added. * \param end Points just beyond last Var to be added. * \param sizeHint For efficiency, the number of elements can be speficied by \a sizeHint. */ template VarSet( VarIterator begin, VarIterator end, size_t sizeHint=0 ) : SmallSet(begin,end,sizeHint) {} //@} /// \name Queries //@{ /// Calculates the number of states of this VarSet, which is simply the number of possible joint states of the variables in \c *this. /** The number of states of the Cartesian product of the variables in this VarSet * is simply the product of the number of states of each variable in this VarSet. * If \c *this corresponds with the set \f$\{x_l\}_{l\in L}\f$, * where variable \f$x_l\f$ has label \f$l\f$, and denoting by \f$S_l\f$ the * number of possible values ("states") of variable \f$x_l\f$, the number of * joint configurations of the variables in \f$\{x_l\}_{l\in L}\f$ is given by \f$\prod_{l\in L} S_l\f$. */ long double nrStates() const { long double states = 1.0; for( VarSet::const_iterator n = begin(); n != end(); n++ ) states *= n->states(); return states; } //@} /// \name Input and output //@{ /// Writes a VarSet to an output stream friend std::ostream& operator<<( std::ostream &os, const VarSet &vs ) { os << "{"; for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) os << (v != vs.begin() ? ", " : "") << *v; os << "}"; return( os ); } //@} }; } // end of namespace dai /** \example example_varset.cpp * This example shows how to use the Var, VarSet and State classes. It also explains the concept of "states" for VarSets. * * \section Output * \verbinclude examples/example_varset.out * * \section Source */ #endif libDAI-0.2.7/include/dai/bbp.h0000644000263000017630000004444611433220723014565 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2009 Frederik Eaton [frederik at ofb dot net] * Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] */ /// \file /// \brief Defines class BBP, which implements Back-Belief-Propagation /// \todo Clean up code #ifndef ___defined_libdai_bbp_h #define ___defined_libdai_bbp_h #include #include #include #include #include #include #include namespace dai { /// Enumeration of several cost functions that can be used with BBP /** \note This class is meant as a base class for BBPCostFunction, which provides additional functionality. */ DAI_ENUM(BBPCostFunctionBase,CFN_GIBBS_B,CFN_GIBBS_B2,CFN_GIBBS_EXP,CFN_GIBBS_B_FACTOR,CFN_GIBBS_B2_FACTOR,CFN_GIBBS_EXP_FACTOR,CFN_VAR_ENT,CFN_FACTOR_ENT,CFN_BETHE_ENT); /// Predefined cost functions that can be used with BBP class BBPCostFunction : public BBPCostFunctionBase { public: /// Default constructor BBPCostFunction() : BBPCostFunctionBase() {} /// Construct from BBPCostFunctionBase \a x BBPCostFunction( const BBPCostFunctionBase &x ) : BBPCostFunctionBase(x) {} /// Returns whether this cost function depends on having a Gibbs state bool needGibbsState() const; /// Evaluates cost function in state \a stateP using the information in inference algorithm \a ia Real evaluate( const InfAlg &ia, const std::vector *stateP ) const; /// Assignment operator BBPCostFunction& operator=( const BBPCostFunctionBase &x ) { BBPCostFunctionBase::operator=( x ); return *this; } }; /// Implements BBP (Back-Belief-Propagation) [\ref EaG09] /** \author Frederik Eaton */ class BBP { private: /// \name Input variables //@{ /// Stores a BP_dual helper object BP_dual _bp_dual; /// Pointer to the factor graph const FactorGraph *_fg; /// Pointer to the approximate inference algorithm (currently, only BP objects are supported) const InfAlg *_ia; //@} /// \name Output variables //@{ /// Variable factor adjoints std::vector _adj_psi_V; /// Factor adjoints std::vector _adj_psi_F; /// Variable->factor message adjoints (indexed [i][_I]) std::vector > _adj_n; /// Factor->variable message adjoints (indexed [i][_I]) std::vector > _adj_m; /// Normalized variable belief adjoints std::vector _adj_b_V; /// Normalized factor belief adjoints std::vector _adj_b_F; //@} /// \name Internal state variables //@{ /// Initial variable factor adjoints std::vector _init_adj_psi_V; /// Initial factor adjoints std::vector _init_adj_psi_F; /// Unnormalized variable->factor message adjoint (indexed [i][_I]) std::vector > _adj_n_unnorm; /// Unnormalized factor->variable message adjoint (indexed [i][_I]) std::vector > _adj_m_unnorm; /// Updated normalized variable->factor message adjoint (indexed [i][_I]) std::vector > _new_adj_n; /// Updated normalized factor->variable message adjoint (indexed [i][_I]) std::vector > _new_adj_m; /// Unnormalized variable belief adjoints std::vector _adj_b_V_unnorm; /// Unnormalized factor belief adjoints std::vector _adj_b_F_unnorm; /// _Tmsg[i][_I] (see eqn. (41) in [\ref EaG09]) std::vector > _Tmsg; /// _Umsg[I][_i] (see eqn. (42) in [\ref EaG09]) std::vector > _Umsg; /// _Smsg[i][_I][_j] (see eqn. (43) in [\ref EaG09]) std::vector > > _Smsg; /// _Rmsg[I][_i][_J] (see eqn. (44) in [\ref EaG09]) std::vector > > _Rmsg; /// Number of iterations done size_t _iters; //@} /// \name Index cache management (for performance) //@{ /// Index type typedef std::vector _ind_t; /// Cached indices (indexed [i][_I]) std::vector > _indices; /// Prepares index cache _indices /** \see bp.cpp */ void RegenerateInds(); /// Returns an index from the cache const _ind_t& _index(size_t i, size_t _I) const { return _indices[i][_I]; } //@} /// \name Initialization helper functions //@{ /// Calculate T values; see eqn. (41) in [\ref EaG09] void RegenerateT(); /// Calculate U values; see eqn. (42) in [\ref EaG09] void RegenerateU(); /// Calculate S values; see eqn. (43) in [\ref EaG09] void RegenerateS(); /// Calculate R values; see eqn. (44) in [\ref EaG09] void RegenerateR(); /// Calculate _adj_b_V_unnorm and _adj_b_F_unnorm from _adj_b_V and _adj_b_F void RegenerateInputs(); /// Initialise members for factor adjoints /** \pre RegenerateInputs() should be called first */ void RegeneratePsiAdjoints(); /// Initialise members for message adjoints for parallel algorithm /** \pre RegenerateInputs() should be called first */ void RegenerateParMessageAdjoints(); /// Initialise members for message adjoints for sequential algorithm /** Same as RegenerateMessageAdjoints, but calls sendSeqMsgN rather * than updating _adj_n (and friends) which are unused in the sequential algorithm. * \pre RegenerateInputs() should be called first */ void RegenerateSeqMessageAdjoints(); /// Called by \a init, recalculates intermediate values void Regenerate(); //@} /// \name Accessors/mutators //@{ /// Returns reference to T value; see eqn. (41) in [\ref EaG09] Prob & T(size_t i, size_t _I) { return _Tmsg[i][_I]; } /// Returns constant reference to T value; see eqn. (41) in [\ref EaG09] const Prob & T(size_t i, size_t _I) const { return _Tmsg[i][_I]; } /// Returns reference to U value; see eqn. (42) in [\ref EaG09] Prob & U(size_t I, size_t _i) { return _Umsg[I][_i]; } /// Returns constant reference to U value; see eqn. (42) in [\ref EaG09] const Prob & U(size_t I, size_t _i) const { return _Umsg[I][_i]; } /// Returns reference to S value; see eqn. (43) in [\ref EaG09] Prob & S(size_t i, size_t _I, size_t _j) { return _Smsg[i][_I][_j]; } /// Returns constant reference to S value; see eqn. (43) in [\ref EaG09] const Prob & S(size_t i, size_t _I, size_t _j) const { return _Smsg[i][_I][_j]; } /// Returns reference to R value; see eqn. (44) in [\ref EaG09] Prob & R(size_t I, size_t _i, size_t _J) { return _Rmsg[I][_i][_J]; } /// Returns constant reference to R value; see eqn. (44) in [\ref EaG09] const Prob & R(size_t I, size_t _i, size_t _J) const { return _Rmsg[I][_i][_J]; } /// Returns reference to variable->factor message adjoint Prob& adj_n(size_t i, size_t _I) { return _adj_n[i][_I]; } /// Returns constant reference to variable->factor message adjoint const Prob& adj_n(size_t i, size_t _I) const { return _adj_n[i][_I]; } /// Returns reference to factor->variable message adjoint Prob& adj_m(size_t i, size_t _I) { return _adj_m[i][_I]; } /// Returns constant reference to factor->variable message adjoint const Prob& adj_m(size_t i, size_t _I) const { return _adj_m[i][_I]; } //@} /// \name Parallel algorithm //@{ /// Calculates new variable->factor message adjoint /** Increases variable factor adjoint according to eqn. (27) in [\ref EaG09] and * calculates the new variable->factor message adjoint according to eqn. (29) in [\ref EaG09]. */ void calcNewN( size_t i, size_t _I ); /// Calculates new factor->variable message adjoint /** Increases factor adjoint according to eqn. (28) in [\ref EaG09] and * calculates the new factor->variable message adjoint according to the r.h.s. of eqn. (30) in [\ref EaG09]. */ void calcNewM( size_t i, size_t _I ); /// Calculates unnormalized variable->factor message adjoint from the normalized one void calcUnnormMsgN( size_t i, size_t _I ); /// Calculates unnormalized factor->variable message adjoint from the normalized one void calcUnnormMsgM( size_t i, size_t _I ); /// Updates (un)normalized variable->factor message adjoints void upMsgN( size_t i, size_t _I ); /// Updates (un)normalized factor->variable message adjoints void upMsgM( size_t i, size_t _I ); /// Do one parallel update of all message adjoints void doParUpdate(); //@} /// \name Sequential algorithm //@{ /// Helper function for sendSeqMsgM(): increases factor->variable message adjoint by \a p and calculates the corresponding unnormalized adjoint void incrSeqMsgM( size_t i, size_t _I, const Prob& p ); // DISABLED BECAUSE IT IS BUGGY: // void updateSeqMsgM( size_t i, size_t _I ); /// Sets normalized factor->variable message adjoint and calculates the corresponding unnormalized adjoint void setSeqMsgM( size_t i, size_t _I, const Prob &p ); /// Implements routine Send-n in Figure 5 in [\ref EaG09] void sendSeqMsgN( size_t i, size_t _I, const Prob &f ); /// Implements routine Send-m in Figure 5 in [\ref EaG09] void sendSeqMsgM( size_t i, size_t _I ); //@} /// Computes the adjoint of the unnormed probability vector from the normalizer and the adjoint of the normalized probability vector /** \see eqn. (13) in [\ref EaG09] */ Prob unnormAdjoint( const Prob &w, Real Z_w, const Prob &adj_w ); /// Calculates averaged L1 norm of unnormalized message adjoints Real getUnMsgMag(); /// Calculates averaged L1 norms of current and new normalized message adjoints void getMsgMags( Real &s, Real &new_s ); /// Returns indices and magnitude of the largest normalized factor->variable message adjoint void getArgmaxMsgM( size_t &i, size_t &_I, Real &mag ); /// Returns magnitude of the largest (in L1-norm) normalized factor->variable message adjoint Real getMaxMsgM(); /// Calculates sum of L1 norms of all normalized factor->variable message adjoints Real getTotalMsgM(); /// Calculates sum of L1 norms of all updated normalized factor->variable message adjoints Real getTotalNewMsgM(); /// Calculates sum of L1 norms of all normalized variable->factor message adjoints Real getTotalMsgN(); /// Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the factors in the factor graph \a fg std::vector getZeroAdjF( const FactorGraph &fg ); /// Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the variables in the factor graph \a fg std::vector getZeroAdjV( const FactorGraph &fg ); public: /// \name Constructors/destructors //@{ /// Construct BBP object from a InfAlg \a ia and a PropertySet \a opts /** \param ia should be a BP object or something compatible * \param opts Parameters @see Properties */ BBP( const InfAlg *ia, const PropertySet &opts ) : _bp_dual(ia), _fg(&(ia->fg())), _ia(ia) { props.set(opts); } //@} /// \name Initialization //@{ /// Initializes from given belief adjoints \a adj_b_V, \a adj_b_F and initial factor adjoints \a adj_psi_V, \a adj_psi_F void init( const std::vector &adj_b_V, const std::vector &adj_b_F, const std::vector &adj_psi_V, const std::vector &adj_psi_F ) { _adj_b_V = adj_b_V; _adj_b_F = adj_b_F; _init_adj_psi_V = adj_psi_V; _init_adj_psi_F = adj_psi_F; Regenerate(); } /// Initializes from given belief adjoints \a adj_b_V and \a adj_b_F (setting initial factor adjoints to zero) void init( const std::vector &adj_b_V, const std::vector &adj_b_F ) { init( adj_b_V, adj_b_F, getZeroAdjV(*_fg), getZeroAdjF(*_fg) ); } /// Initializes variable belief adjoints \a adj_b_V (and sets factor belief adjoints and initial factor adjoints to zero) void init_V( const std::vector &adj_b_V ) { init( adj_b_V, getZeroAdjF(*_fg) ); } /// Initializes factor belief adjoints \a adj_b_F (and sets variable belief adjoints and initial factor adjoints to zero) void init_F( const std::vector &adj_b_F ) { init( getZeroAdjV(*_fg), adj_b_F ); } /// Initializes with adjoints calculated from cost function \a cfn, and state \a stateP /** Uses the internal pointer to an inference algorithm in combination with the cost function and state for initialization. * \param cfn Cost function used for initialization; * \param stateP is a Gibbs state and can be NULL; it will be initialised using a Gibbs run. */ void initCostFnAdj( const BBPCostFunction &cfn, const std::vector *stateP ); //@} /// \name BBP Algorithm //@{ /// Perform iterative updates until change is less than given tolerance void run(); //@} /// \name Query results //@{ /// Returns reference to variable factor adjoint Prob& adj_psi_V(size_t i) { return _adj_psi_V[i]; } /// Returns constant reference to variable factor adjoint const Prob& adj_psi_V(size_t i) const { return _adj_psi_V[i]; } /// Returns reference to factor adjoint Prob& adj_psi_F(size_t I) { return _adj_psi_F[I]; } /// Returns constant reference to factor adjoint const Prob& adj_psi_F(size_t I) const { return _adj_psi_F[I]; } /// Returns reference to variable belief adjoint Prob& adj_b_V(size_t i) { return _adj_b_V[i]; } /// Returns constant reference to variable belief adjoint const Prob& adj_b_V(size_t i) const { return _adj_b_V[i]; } /// Returns reference to factor belief adjoint Prob& adj_b_F(size_t I) { return _adj_b_F[I]; } /// Returns constant reference to factor belief adjoint const Prob& adj_b_F(size_t I) const { return _adj_b_F[I]; } /// Return number of iterations done so far size_t Iterations() { return _iters; } //@} public: /// Parameters for BBP /* PROPERTIES(props,BBP) { /// Enumeration of possible update schedules /// The following update schedules are defined: /// - SEQ_FIX fixed sequential updates /// - SEQ_MAX maximum residual updates (inspired by [\ref EMK06]) /// - SEQ_BP_REV schedule used by BP, but reversed /// - SEQ_BP_FWD schedule used by BP /// - PAR parallel updates DAI_ENUM(UpdateType,SEQ_FIX,SEQ_MAX,SEQ_BP_REV,SEQ_BP_FWD,PAR); /// Verbosity (amount of output sent to stderr) size_t verbose = 0; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test /// \note Not used for updates = SEQ_BP_REV, SEQ_BP_FWD Real tol; /// Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [\ref EaG09] Real damping; /// Update schedule UpdateType updates; // DISABLED BECAUSE IT IS BUGGY: // bool clean_updates; } */ /* {{{ GENERATED CODE: DO NOT EDIT. Created by ./scripts/regenerate-properties include/dai/bbp.h src/bbp.cpp */ struct Properties { /// Enumeration of possible update schedules /** The following update schedules are defined: * - SEQ_FIX fixed sequential updates * - SEQ_MAX maximum residual updates (inspired by [\ref EMK06]) * - SEQ_BP_REV schedule used by BP, but reversed * - SEQ_BP_FWD schedule used by BP * - PAR parallel updates */ DAI_ENUM(UpdateType,SEQ_FIX,SEQ_MAX,SEQ_BP_REV,SEQ_BP_FWD,PAR); /// Verbosity (amount of output sent to stderr) size_t verbose; /// Maximum number of iterations size_t maxiter; /// Tolerance for convergence test /** \note Not used for updates = SEQ_BP_REV, SEQ_BP_FWD */ Real tol; /// Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [\ref EaG09] Real damping; /// Update schedule UpdateType updates; /// Set members from PropertySet /** \throw UNKNOWN_PROPERTY if a Property key is not recognized * \throw NOT_ALL_PROPERTIES_SPECIFIED if an expected Property is missing */ void set(const PropertySet &opts); /// Get members into PropertySet PropertySet get() const; /// Convert to a string which can be parsed as a PropertySet std::string toString() const; } props; /* }}} END OF GENERATED CODE */ }; /// Function to verify the validity of adjoints computed by BBP using numerical differentiation. /** Factors containing a variable are multiplied by small adjustments to verify accuracy of calculated variable factor adjoints. * \param bp BP object; * \param state Global state of all variables; * \param bbp_props BBP parameters; * \param cfn Cost function to be used; * \param h Size of perturbation. * \relates BBP */ Real numericBBPTest( const InfAlg &bp, const std::vector *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h ); } // end of namespace dai #endif libDAI-0.2.7/include/dai/graph.h0000644000263000017630000003327611433220723015122 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2006-2010 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2006-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines the GraphAL class, which represents an undirected graph as an adjacency list #ifndef __defined_libdai_graph_h #define __defined_libdai_graph_h #include #include #include #include #include #include namespace dai { /// Describes the neighbor relationship of two nodes in a graph. /** Most graphs that libDAI deals with are sparse. Therefore, * a fast and memory-efficient way of representing the structure * of a sparse graph is needed. A frequently used operation that * also needs to be fast is switching between viewing node \a a as a * neighbor of node \a b, and node \a b as a neighbor of node \a a. * The Neighbor struct solves both of these problems. * * Most sparse graphs in libDAI are represented by storing for each * node in the graph the set of its neighbors. In practice, this set * of neighbors is stored using the Neighbors type, which is simply a * std::vector<\link Neighbor \endlink>. The Neighbor struct contains * the label of the neighboring node (the \c node member) and * additional information which allows to access a node as a neighbor * of its neighbor (the \c dual member). For convenience, each Neighbor * structure also stores its index in the Neighbors vector that it is * part of (the \c iter member). * * By convention, variable identifiers naming indices into a vector * of neighbors are prefixed with an underscore ("_"). The neighbor list * which they point into is then understood from the context. * * Let us denote the \a _j 'th neighbor of node \a i by nb(i,_j), * which is of the Neighbor type. Here, \a i is the "absolute" index of * node \a i, but \a _j is understood as a "relative" index, giving node * \a j 's entry in the Neighbors nb(i) of node \a i. The absolute * index of \a _j, which would be denoted \a j, can be recovered from the * \c node member, nb(i,_j).node. The \c iter member * nb(i,_j).iter gives the relative index \a _j, and the \c dual * member nb(i,_j).dual gives the "dual" relative index, i.e., * the index of \a i in \a j 's neighbor list. * * Iteration over edges can be easily accomplished: * \code * for( size_t i = 0; i < nrNodes(); ++i ) { * size_t _j = 0; * foreach( const Neighbor &j, nb(i) ) { * assert( j == nb(i,j.iter) ); * assert( nb(j.node,j.dual).node == i ); * assert( _j = j.iter ); * _j++; * } * } * \endcode */ struct Neighbor { /// Corresponds to the index of this Neighbor entry in the vector of neighbors size_t iter; /// Contains the absolute index of the neighboring node size_t node; /// Contains the "dual" index (i.e., the index of this node in the Neighbors vector of the neighboring node) size_t dual; /// Default constructor Neighbor() {} /// Constructor that allows setting the values of the member variables Neighbor( size_t iter, size_t node, size_t dual ) : iter(iter), node(node), dual(dual) {} /// Cast to \c size_t returns \c node member operator size_t () const { return node; } }; /// Describes the set of neighbors of some node in a graph typedef std::vector Neighbors; /// Represents an edge in a graph: an Edge(\a i,\a j) corresponds to the edge between node \a i and node \a j. /** \note If the edge is interpreted as a directed edge, then it points from \a i to \a j. * \note If the edge is part of a bipartite graph, \a i is understood to correspond to a node of type 1, and * \a j to a node of type 2. */ typedef std::pair Edge; /// Represents the neighborhood structure of nodes in an undirected graph. /** A graph has nodes connected by edges. Nodes are indexed by an unsigned integer. * If there are nrNodes() nodes, they are numbered 0,1,2,...,nrNodes()-1. An edge * between node \a n1 and node \a n2 is represented by a Edge(\a n1,\a n2). * * GraphAL is implemented as a sparse adjacency list, i.e., it stores for each node a list of * its neighboring nodes. The list of neighboring nodes is implemented as a vector of Neighbor * structures (accessible by the nb() method). Thus, each node has an associated variable of * type GraphAL::Neighbors, which is a vector of Neighbor structures, describing its * neighboring nodes. */ class GraphAL { private: /// Contains for each node a vector of its neighbors std::vector _nb; public: /// \name Constructors and destructors //@{ /// Default constructor (creates an empty graph). GraphAL() : _nb() {} /// Constructs GraphAL with \a nr nodes and no edges. GraphAL( size_t nr ) : _nb( nr ) {} /// Constructs GraphAL from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of Edge. * \param nr The number of nodes. * \param begin Points to the first edge. * \param end Points just beyond the last edge. * \param check Whether to only add an edge if it does not exist already. */ template GraphAL( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true ) : _nb() { construct( nr, begin, end, check ); } //@} /// \name Accessors and mutators //@{ /// Returns constant reference to the \a _n2 'th neighbor of node \a n1 const Neighbor & nb( size_t n1, size_t _n2 ) const { DAI_DEBASSERT( n1 < _nb.size() ); DAI_DEBASSERT( _n2 < _nb[n1].size() ); return _nb[n1][_n2]; } /// Returns reference to the \a _n2 'th neighbor of node \a n1 Neighbor & nb( size_t n1, size_t _n2 ) { DAI_DEBASSERT( n1 < _nb.size() ); DAI_DEBASSERT( _n2 < _nb[n1].size() ); return _nb[n1][_n2]; } /// Returns constant reference to all neighbors of node \a n const Neighbors & nb( size_t n ) const { DAI_DEBASSERT( n < _nb.size() ); return _nb[n]; } /// Returns reference to all neighbors of node \a n Neighbors & nb( size_t n ) { DAI_DEBASSERT( n < _nb.size() ); return _nb[n]; } //@} /// \name Adding nodes and edges //@{ /// (Re)constructs GraphAL from a range of edges. /** \tparam EdgeInputIterator Iterator that iterates over instances of Edge. * \param nr The number of nodes. * \param begin Points to the first edge. * \param end Points just beyond the last edge. * \param check Whether to only add an edge if it does not exist already. */ template void construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true ); /// Adds a node without neighbors and returns the index of the added node. size_t addNode() { _nb.push_back( Neighbors() ); return _nb.size() - 1; } /// Adds a node, with neighbors specified by a range of nodes. /** \tparam NodeInputIterator Iterator that iterates over instances of \c size_t. * \param begin Points to the first index of the nodes that should become neighbors of the added node. * \param end Points just beyond the last index of the nodes that should become neighbors of the added node. * \param sizeHint For improved efficiency, the size of the range may be specified by \a sizeHint. * \returns Index of the added node. */ template size_t addNode( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) { Neighbors nbsnew; nbsnew.reserve( sizeHint ); size_t iter = 0; for( NodeInputIterator it = begin; it != end; ++it ) { DAI_ASSERT( *it < nrNodes() ); Neighbor nb1new( iter, *it, nb(*it).size() ); Neighbor nb2new( nb(*it).size(), nrNodes(), iter++ ); nbsnew.push_back( nb1new ); nb( *it ).push_back( nb2new ); } _nb.push_back( nbsnew ); return _nb.size() - 1; } /// Adds an edge between node \a n1 and node \a n2. /** If \a check == \c true, only adds the edge if it does not exist already. */ GraphAL& addEdge( size_t n1, size_t n2, bool check = true ); //@} /// \name Erasing nodes and edges //@{ /// Removes node \a n and all incident edges; indices of other nodes are changed accordingly. void eraseNode( size_t n ); /// Removes edge between node \a n1 and node \a n2. void eraseEdge( size_t n1, size_t n2 ); //@} /// \name Queries //@{ /// Returns number of nodes size_t nrNodes() const { return _nb.size(); } /// Calculates the number of edges, time complexity: O(nrNodes()) size_t nrEdges() const { size_t sum = 0; for( size_t i = 0; i < nrNodes(); i++ ) sum += nb(i).size(); return sum / 2; } /// Returns true if the graph contains an edge between nodes \a n1 and \a n2 /** \note The time complexity is linear in the number of neighbors of \a n1 or \a n2 */ bool hasEdge( size_t n1, size_t n2 ) const { if( nb(n1).size() < nb(n2).size() ) { for( size_t _n2 = 0; _n2 < nb(n1).size(); _n2++ ) if( nb( n1, _n2 ) == n2 ) return true; } else { for( size_t _n1 = 0; _n1 < nb(n2).size(); _n1++ ) if( nb( n2, _n1 ) == n1 ) return true; } return false; } /// Returns the index of a given node \a n2 amongst the neighbors of \a n1 /** \note The time complexity is linear in the number of neighbors of \a n1 * \throw OBJECT_NOT_FOUND if \a n2 is not a neighbor of \a n1 */ size_t findNb( size_t n1, size_t n2 ) { for( size_t _n2 = 0; _n2 < nb(n1).size(); _n2++ ) if( nb( n1, _n2 ) == n2 ) return _n2; DAI_THROW(OBJECT_NOT_FOUND); return nb(n1).size(); } /// Returns neighbors of node \a n as a SmallSet. SmallSet nbSet( size_t n ) const; /// Returns true if the graph is connected bool isConnected() const; /// Returns true if the graph is a tree, i.e., if it is singly connected and connected. bool isTree() const; /// Asserts internal consistency void checkConsistency() const; /// Comparison operator which returns true if two graphs are identical /** \note Two graphs are called identical if they have the same number * of nodes and the same edges (i.e., \a x has an edge between nodes * \a n1 and \a n2 if and only if \c *this has an edge between nodes \a n1 and \a n2). */ bool operator==( const GraphAL& x ) const { if( nrNodes() != x.nrNodes() ) return false; for( size_t n1 = 0; n1 < nrNodes(); n1++ ) { if( nb(n1).size() != x.nb(n1).size() ) return false; foreach( const Neighbor &n2, nb(n1) ) if( !x.hasEdge( n1, n2 ) ) return false; foreach( const Neighbor &n2, x.nb(n1) ) if( !hasEdge( n1, n2 ) ) return false; } return true; } //@} /// \name Input and output //@{ /// Writes this GraphAL to an output stream in GraphViz .dot syntax void printDot( std::ostream& os ) const; /// Writes this GraphAL to an output stream friend std::ostream& operator<<( std::ostream& os, const GraphAL& g ) { g.printDot( os ); return os; } //@} }; template void GraphAL::construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check ) { _nb.clear(); _nb.resize( nr ); for( EdgeInputIterator e = begin; e != end; e++ ) addEdge( e->first, e->second, check ); } /// Creates a fully-connected graph with \a N nodes GraphAL createGraphFull( size_t N ); /// Creates a two-dimensional rectangular grid of \a N1 by \a N2 nodes, which can be \a periodic GraphAL createGraphGrid( size_t N1, size_t N2, bool periodic ); /// Creates a three-dimensional rectangular grid of \a N1 by \a N2 by \a N3 nodes, which can be \a periodic GraphAL createGraphGrid3D( size_t N1, size_t N2, size_t N3, bool periodic ); /// Creates a graph consisting of a single loop of \a N nodes GraphAL createGraphLoop( size_t N ); /// Creates a random tree-structured graph of \a N nodes GraphAL createGraphTree( size_t N ); /// Creates a random regular graph of \a N nodes with uniform connectivity \a d /** Algorithm 1 in [\ref StW99]. * Draws a random graph of size \a N and uniform degree \a d * from an almost uniform probability distribution over these graphs * (which becomes uniform in the limit that \a d is small and \a N goes * to infinity). */ GraphAL createGraphRegular( size_t N, size_t d ); } // end of namespace dai #endif libDAI-0.2.7/include/dai/var.h0000644000263000017630000001003711433220723014577 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2002 Martijn Leisink [martijn@mbfys.kun.nl] * Copyright (C) 2006-2009 Joris Mooij [joris dot mooij at libdai dot org] * Copyright (C) 2002-2007 Radboud University Nijmegen, The Netherlands */ /// \file /// \brief Defines class Var, which represents a discrete random variable. #ifndef __defined_libdai_var_h #define __defined_libdai_var_h #include #include namespace dai { /// Represents a discrete random variable. /** A Var stores the \a label of the variable (an unsigned integer-valued * unique ID) and the number of possible values (\a states) of that variable. * Two Var objects with the same label are assumed to be identical (i.e., it * is assumed that they have the same number of possible states). * * In the documentation, we use the following notational conventions. The discrete * random variable with label \f$l\f$ is denoted as \f$x_l\f$, and the number * of possible values of this variable as \f$S_l\f$; this is represented in * code by the object Var(\f$l\f$,\f$S_l\f$). The set of possible values of * variable \f$x_l\f$ is denoted \f$X_l := \{0,1,\dots,S_l-1\}\f$. */ class Var { private: /// Label of the variable (its unique ID) size_t _label; /// Number of possible values size_t _states; public: /// Default constructor (creates a variable with label 0 and 0 states) Var() : _label(0), _states(0) {} /// Constructs a variable with a given label and number of states Var( size_t label, size_t states ) : _label(label), _states(states) {} /// Returns the label size_t label() const { return _label; } /// Returns reference to label size_t& label() { return _label; } /// Returns the number of states size_t states() const { return _states; } /// Returns reference to number of states size_t& states() { return _states; } /// Smaller-than operator (only compares labels) bool operator< ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label < n._label ); } /// Larger-than operator (only compares labels) bool operator> ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label > n._label ); } /// Smaller-than-or-equal-to operator (only compares labels) bool operator<= ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label <= n._label ); } /// Larger-than-or-equal-to operator (only compares labels) bool operator>= ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label >= n._label ); } /// Not-equal-to operator (only compares labels) bool operator!= ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label != n._label ); } /// Equal-to operator (only compares labels) bool operator== ( const Var& n ) const { #ifdef DAI_DEBUG if( _label == n._label ) DAI_ASSERT( _states == n._states ); #endif return( _label == n._label ); } /// Writes a Var to an output stream friend std::ostream& operator << ( std::ostream& os, const Var& n ) { return( os << "x" << n.label() ); } }; } // end of namespace dai #endif libDAI-0.2.7/include/dai/io.h0000644000263000017630000000351411433220723014420 0ustar jorismkyb/* This file is part of libDAI - http://www.libdai.org/ * * libDAI is licensed under the terms of the GNU General Public License version * 2, or (at your option) any later version. libDAI is distributed without any * warranty. See the file COPYING for more details. * * Copyright (C) 2010 Joris Mooij [joris dot mooij at libdai dot org] */ /// \file /// \brief Provides functionality for input/output of data structures in various file formats #ifndef __defined_libdai_io_h #define __defined_libdai_io_h #include #include #include namespace dai { /// Reads factor graph (as a pair of a variable vector and factor vector) from a file in the UAI approximate inference challenge format /** \param[in] filename The filename (usually ends with ".uai") * \param[in] verbose The amount of output sent to cout * \param[out] vars Array of variables read from the file * \param[out] factors Array of factors read from the file * \param[out] permutations Array of permutations, which permute between libDAI canonical ordering and ordering specified by the file * \see http://www.cs.huji.ac.il/project/UAI10 and http://graphmod.ics.uci.edu/uai08 */ void ReadUaiAieFactorGraphFile( const char *filename, size_t verbose, std::vector& vars, std::vector& factors, std::vector& permutations ); /// Reads evidence (a mapping from observed variable labels to the observed values) from a file in the UAI approximate inference challenge format /** \param[in] filename The filename (usually ends with ".uai.evid") * \param[in] verbose The amount of output sent to cout * \see http://www.cs.huji.ac.il/project/UAI10 and http://graphmod.ics.uci.edu/uai08 */ std::vector > ReadUaiAieEvidenceFile( const char* filename, size_t verbose ); } // end of namespace dai #endif libDAI-0.2.7/Makefile.MACOSX0000644000263000017630000000432011433220723014105 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This template contains configurations for compiling libDAI under Mac OS X # # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf' # to your local setup # OPERATING SYSTEM # Choose OS from {LINUX, WINDOWS, CYGWIN, MACOSX} OS=MACOSX # FILE EXTENSIONS # Static library LE=.a # Object file OE=.o # Binary executable EE= # MatLab compiled MEX file ME=.mexglx # COMPILER # Compile using GNU C++ Compiler CC=g++ # Output filename option of the compiler CCO=-o # Flags for the C++ compiler CCFLAGS=-Wno-deprecated -Wall -W -Wextra -fPIC -DMACOSX # Flags to add in debugging mode (if DEBUG=true) CCDEBUGFLAGS=-O3 -g -DDAI_DEBUG # Flags to add in non-debugging mode (if DEBUG=false) CCNODEBUGFLAGS=-O3 # Standard include directories CCINC=-Iinclude -I/opt/local/include # LINKER # Standard libraries to include LIBS=-ldai # For linking with BOOST libraries BOOSTLIBS_PO=-lboost_program_options BOOSTLIBS_UTF=-lboost_unit_test_framework # Additional library search paths for linker CCLIB=-Llib -L/opt/local/lib # MATLAB # MatLab version 7.3 (R2006b) or newer? NEW_MATLAB=true # Replace the following by the directory where MatLab has been installed MATLABDIR=/agbs/share/sw/matlab # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)/bin/mex # Specify the same C++ compiler and flags to mex MEXFLAGS:=CXX\#$(CC) CXXFLAGS\#'$(CCFLAGS)' # Standard include directories for MEX MEXINC:=$(CCINC) # Additional library search paths for MEX MEXLIB= # SWIG PYTHON INTERFACE # The following should resolve to the SWIG command SWIG=swig # Location of Python header files INCLUDE_PYTHON=/usr/include/python2.5 # Location of Boost C++ library header files INCLUDE_BOOST=/usr/include/boost # CIMG # CImg version 1.3.0 or newer? NEW_CIMG=true # Include directory for image segmentation example CIMGINC= # Libraries for image segmentation example CIMGLIBS=-lpthread -lX11 libDAI-0.2.7/doxygen.conf0000644000263000017630000017607111433220723014015 0ustar jorismkyb# Doxyfile 1.5.9 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project # # All text after a hash (#) is considered a comment and will be ignored # The format is: # TAG = value [value, ...] # For lists items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (" ") #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all # text before the first occurrence of this tag. Doxygen uses libiconv (or the # iconv built into libc) for the transcoding. See # http://www.gnu.org/software/libiconv for the list of possible encodings. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded # by quotes) that should identify the project. PROJECT_NAME = libDAI # The PROJECT_NUMBER tag can be used to enter a project or revision number. # This could be handy for archiving the generated documentation or # if some version control system is used. PROJECT_NUMBER = # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) # base path where the generated documentation will be put. # If a relative path is entered, it will be relative to the location # where doxygen was started. If left blank the current directory will be used. OUTPUT_DIRECTORY = doc # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create # 4096 sub-directories (in 2 levels) under the output directory of each output # format and will distribute the generated files over these directories. # Enabling this option can be useful when feeding doxygen a huge amount of # source files, where putting all generated files in the same directory would # otherwise cause performance problems for the file system. CREATE_SUBDIRS = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # The default language is English, other supported languages are: # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will # include brief member descriptions after the members that are listed in # the file and class documentation (similar to JavaDoc). # Set to NO to disable this. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend # the brief description of a member or function before the detailed description. # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator # that is used to form the text in various listings. Each string # in this list, if found as the leading text of the brief description, will be # stripped from the text and the result after processing the whole list, is # used as the annotated text. Otherwise, the brief description is used as-is. # If left blank, the following values are used ("$name" is automatically # replaced with the name of the entity): "The $name class" "The $name widget" # "The $name file" "is" "provides" "specifies" "contains" # "represents" "a" "an" "the" ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # Doxygen will generate a detailed section even if there is only a brief # description. ALWAYS_DETAILED_SEC = YES # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full # path before files name in the file list and in the header files. If set # to NO the shortest path that makes the file name unique will be used. FULL_PATH_NAMES = YES # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag # can be used to strip a user-defined part of the path. Stripping is # only done if one of the specified strings matches the left-hand part of # the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the # path to strip. STRIP_FROM_PATH = # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of # the path mentioned in the documentation of a class, which tells # the reader which header file to include in order to use a class. # If left blank only the name of the header file containing the class # definition is used. Otherwise one should specify the include paths that # are normally passed to the compiler using the -I flag. STRIP_FROM_INC_PATH = include/ # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter # (but less readable) file names. This can be useful is your file systems # doesn't support long names like on DOS, Mac, or CD-ROM. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen # will interpret the first line (until the first dot) of a JavaDoc-style # comment as the brief description. If set to NO, the JavaDoc # comments will behave just like regular Qt-style comments # (thus requiring an explicit @brief command for a brief description.) JAVADOC_AUTOBRIEF = NO # If the QT_AUTOBRIEF tag is set to YES then Doxygen will # interpret the first line (until the first dot) of a Qt-style # comment as the brief description. If set to NO, the comments # will behave just like regular Qt-style comments (thus requiring # an explicit \brief command for a brief description.) QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen # treat a multi-line C++ special comment block (i.e. a block of //! or /// # comments) as a brief description. This used to be the default behaviour. # The new default is to treat a multi-line C++ comment block as a detailed # description. Set this tag to YES if you prefer the old behaviour instead. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented # member inherits the documentation from any documented member that it # re-implements. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce # a new page for each member. If set to NO, the documentation of a member will # be part of the file/class/namespace that contains it. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. # Doxygen uses this value to replace tabs by spaces in code fragments. TAB_SIZE = 4 # This tag can be used to specify a number of aliases that acts # as commands in the documentation. An alias has the form "name=value". # For example adding "sideeffect=\par Side Effects:\n" will allow you to # put the command \sideeffect (or @sideeffect) in the documentation, which # will result in a user-defined paragraph with heading "Side Effects:". # You can put \n's in the value part of an alias to insert newlines. ALIASES = "idea=\xrefitem ideas \"Idea\" \"Ideas worth exploring\"" # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C # sources only. Doxygen will then generate output that is more tailored for C. # For instance, some of the names that are used will be different. The list # of all members will be omitted, etc. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java # sources only. Doxygen will then generate output that is more tailored for # Java. For instance, namespaces will be presented as packages, qualified # scopes will look different, etc. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources only. Doxygen will then generate output that is more tailored for # Fortran. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for # VHDL. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it parses. # With this tag you can assign which parser to use for a given extension. # Doxygen has a built-in mapping, but you can override or extend it using this tag. # The format is ext=language, where ext is a file extension, and language is one of # the parsers supported by doxygen: IDL, Java, Javascript, C#, C, C++, D, PHP, # Objective-C, Python, Fortran, VHDL, C, C++. For instance to make doxygen treat # .inc files as Fortran files (default is PHP), and .f files as C (default is Fortran), # use: inc=Fortran f=C. Note that for custom extensions you also need to set FILE_PATTERNS otherwise the files are not read by doxygen. EXTENSION_MAPPING = # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should # set this tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); v.s. # func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. BUILTIN_STL_SUPPORT = YES # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only. # Doxygen will parse them like normal C++ but will assume all classes use public # instead of private inheritance when no explicit protection keyword is present. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate getter # and setter methods for a property. Setting this option to YES (the default) # will make doxygen to replace the get and set methods by a property in the # documentation. This will only work if the methods are indeed getting or # setting a simple type. If this is not the case, or you want to show the # methods anyway, you should set this option to NO. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. DISTRIBUTE_GROUP_DOC = NO # Set the SUBGROUPING tag to YES (the default) to allow class member groups of # the same type (for instance a group of public functions) to be put as a # subgroup of that type (e.g. under the Public Functions section). Set it to # NO to prevent subgrouping. Alternatively, this can be done per class using # the \nosubgrouping command. SUBGROUPING = YES # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum # is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically # be useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. TYPEDEF_HIDES_STRUCT = NO # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to # determine which symbols to keep in memory and which to flush to disk. # When the cache is full, less often used symbols will be written to disk. # For small to medium size projects (<1000 input files) the default value is # probably good enough. For larger projects a too small cache size can cause # doxygen to be busy swapping symbols to and from disk most of the time # causing a significant performance penality. # If the system has enough physical memory increasing the cache will improve the # performance by keeping more symbols in memory. Note that the value works on # a logarithmic scale so increasing the size by one will rougly double the # memory usage. The cache size is given by this formula: # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, # corresponding to a cache size of 2^16 = 65536 symbols SYMBOL_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. # Private class members and static file members will be hidden unless # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES EXTRACT_ALL = NO # If the EXTRACT_PRIVATE tag is set to YES all private members of a class # will be included in the documentation. EXTRACT_PRIVATE = YES # If the EXTRACT_STATIC tag is set to YES all static members of a file # will be included in the documentation. EXTRACT_STATIC = YES # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) # defined locally in source files will be included in the documentation. # If set to NO only classes defined in header files are included. EXTRACT_LOCAL_CLASSES = NO # This flag is only useful for Objective-C code. When set to YES local # methods, which are defined in the implementation section but not in # the interface are included in the documentation. # If set to NO (the default) only methods in the interface are included. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base # name of the file that contains the anonymous namespace. By default # anonymous namespace are hidden. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all # undocumented members of documented classes, files or namespaces. # If set to NO (the default) these members will be included in the # various overviews, but no documentation section is generated. # This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. # If set to NO (the default) these classes will be included in the various # overviews. This option has no effect if EXTRACT_ALL is enabled. HIDE_UNDOC_CLASSES = YES # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all # friend (class|struct|union) declarations. # If set to NO (the default) these declarations will be included in the # documentation. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any # documentation blocks found inside the body of a function. # If set to NO (the default) these blocks will be appended to the # function's detailed documentation block. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation # that is typed after a \internal command is included. If the tag is set # to NO (the default) then the documentation will be excluded. # Set it to YES to include the internal documentation. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate # file names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen # will show members with their full class and namespace scopes in the # documentation. If set to YES the scope will be hidden. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen # will put a list of the files that are included by a file in the documentation # of that file. SHOW_INCLUDE_FILES = YES # If the INLINE_INFO tag is set to YES (the default) then a tag [inline] # is inserted in the documentation for inline members. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen # will sort the (detailed) documentation of file and class members # alphabetically by member name. If set to NO the members will appear in # declaration order. SORT_MEMBER_DOCS = NO # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the # brief documentation of file, namespace and class members alphabetically # by member name. If set to NO (the default) the members will appear in # declaration order. SORT_BRIEF_DOCS = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the # hierarchy of group names into alphabetical order. If set to NO (the default) # the group names will appear in their defined order. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be # sorted by fully-qualified names, including namespaces. If set to # NO (the default), the class list will be sorted only by class name, # not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the # alphabetical list. SORT_BY_SCOPE_NAME = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or # disable (NO) the todo list. This list is created by putting \todo # commands in the documentation. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable (YES) or # disable (NO) the test list. This list is created by putting \test # commands in the documentation. GENERATE_TESTLIST = NO # The GENERATE_BUGLIST tag can be used to enable (YES) or # disable (NO) the bug list. This list is created by putting \bug # commands in the documentation. GENERATE_BUGLIST = NO # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or # disable (NO) the deprecated list. This list is created by putting # \deprecated commands in the documentation. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional # documentation sections, marked by \if sectionname ... \endif. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines # the initial value of a variable or define consists of for it to appear in # the documentation. If the initializer consists of more lines than specified # here it will be hidden. Use a value of 0 to hide initializers completely. # The appearance of the initializer of individual variables and defines in the # documentation can be controlled using \showinitializer or \hideinitializer # command in the documentation regardless of this setting. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated # at the bottom of the documentation of classes and structs. If set to YES the # list will mention the files that were used to generate the documentation. SHOW_USED_FILES = YES # If the sources in your project are distributed over multiple directories # then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy # in the documentation. The default is NO. SHOW_DIRECTORIES = NO # Set the SHOW_FILES tag to NO to disable the generation of the Files page. # This will remove the Files entry from the Quick Index and from the # Folder Tree View (if specified). The default is YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the # Namespaces page. # This will remove the Namespaces entry from the Quick Index # and from the Folder Tree View (if specified). The default is YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command , where is the value of # the FILE_VERSION_FILTER tag, and is the name of an input file # provided by doxygen. Whatever the program writes to standard output # is used as the file version. See the manual for examples. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed by # doxygen. The layout file controls the global structure of the generated output files # in an output format independent way. The create the layout file that represents # doxygen's defaults, run doxygen with the -l option. You can optionally specify a # file name after the option, if omitted DoxygenLayout.xml will be used as the name # of the layout file. LAYOUT_FILE = #--------------------------------------------------------------------------- # configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated # by doxygen. Possible values are YES and NO. If left blank NO is used. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated by doxygen. Possible values are YES and NO. If left blank # NO is used. WARNINGS = YES # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings # for undocumented members. If EXTRACT_ALL is set to YES then this flag will # automatically be disabled. WARN_IF_UNDOCUMENTED = YES # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some # parameters in a documented function, or documenting parameters that # don't exist or using markup commands wrongly. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be abled to get warnings for # functions that are documented, but have no documentation for their parameters # or return value. If set to NO (the default) doxygen will only warn about # wrong or incomplete parameter documentation, but not about the absence of # documentation. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that # doxygen can produce. The string should contain the $file, $line, and $text # tags, which will be replaced by the file and line number from which the # warning originated and the warning text. Optionally the format may contain # $version, which will be replaced by the version of the file (if it could # be obtained via FILE_VERSION_FILTER) WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning # and error messages should be written. If left blank the output is written # to stderr. WARN_LOGFILE = #--------------------------------------------------------------------------- # configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag can be used to specify the files and/or directories that contain # documented source files. You may enter file names like "myfile.cpp" or # directories like "/usr/src/myproject". Separate the files or directories # with spaces. INPUT = src \ src/matlab \ include/dai \ include/dai/matlab \ . # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is # also the default input encoding. Doxygen uses libiconv (or the iconv built # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for # the list of possible encodings. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank the following patterns are tested: # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 FILE_PATTERNS = # The RECURSIVE tag can be used to turn specify whether or not subdirectories # should be searched for input files as well. Possible values are YES and NO. # If left blank NO is used. RECURSIVE = NO # The EXCLUDE tag can be used to specify files and/or directories that should # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used select whether or not files or # directories that are symbolic links (a Unix filesystem feature) are excluded # from the input. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. Note that the wildcards are matched # against the file with absolute path, so to exclude all test directories # for example use the pattern */test/* EXCLUDE_PATTERNS = # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or # directories that contain example code fragments that are included (see # the \include command). EXAMPLE_PATH = . examples # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp # and *.h) to filter out the source-files in the directories. If left # blank all files are included. EXAMPLE_PATTERNS = *.cpp *.out COPYING README AUTHORS ChangeLog # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude # commands irrespective of the value of the RECURSIVE tag. # Possible values are YES and NO. If left blank NO is used. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or # directories that contain image that are included in the documentation (see # the \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command , where # is the value of the INPUT_FILTER tag, and is the name of an # input file. Doxygen will then use the output that the filter program writes # to standard output. # If FILTER_PATTERNS is specified, this tag will be # ignored. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. # Doxygen will compare the file name with each pattern and apply the # filter if there is a match. # The filters are a list of the form: # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further # info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER # is applied to all files. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will be used to filter the input files when producing source # files to browse (i.e. when SOURCE_BROWSER is set to YES). FILTER_SOURCE_FILES = NO #--------------------------------------------------------------------------- # configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will # be generated. Documented entities will be cross-referenced with these sources. # Note: To get rid of all source code in the generated output, make sure also # VERBATIM_HEADERS is set to NO. SOURCE_BROWSER = NO # Setting the INLINE_SOURCES tag to YES will include the body # of functions and classes directly in the documentation. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct # doxygen to hide any special comment blocks from generated source code # fragments. Normal C and C++ comments will always remain visible. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES # then for each documented function all documented # functions referencing it will be listed. REFERENCED_BY_RELATION = NO # If the REFERENCES_RELATION tag is set to YES # then for each documented function all documented entities # called/used by that function will be listed. REFERENCES_RELATION = NO # If the REFERENCES_LINK_SOURCE tag is set to YES (the default) # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will # link to the source code. # Otherwise they will link to the documentation. REFERENCES_LINK_SOURCE = YES # If the USE_HTAGS tag is set to YES then the references to source code # will point to the HTML generated by the htags(1) tool instead of doxygen # built-in source browser. The htags tool is part of GNU's global source # tagging system (see http://www.gnu.org/software/global/global.html). You # will need version 4.8.6 or higher. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen # will generate a verbatim copy of the header file for each class for # which an include is specified. Set to NO to disable this. VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index # of all compounds will be generated. Enable this if the project # contains a lot of classes, structs, unions or interfaces. ALPHABETICAL_INDEX = NO # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns # in which this list will be split (can be a number in the range [1..20]) COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all # classes will be put under the same header in the alphabetical index. # The IGNORE_PREFIX tag can be used to specify one or more prefixes that # should be ignored while generating the index headers. IGNORE_PREFIX = #--------------------------------------------------------------------------- # configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES (the default) Doxygen will # generate HTML output. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `html' will be used as the default path. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for # each generated HTML page (for example: .htm,.php,.asp). If it is left blank # doxygen will generate files with .html extension. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a personal HTML header for # each generated HTML page. If it is left blank doxygen will generate a # standard header. HTML_HEADER = # The HTML_FOOTER tag can be used to specify a personal HTML footer for # each generated HTML page. If it is left blank doxygen will generate a # standard footer. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading # style sheet that is used by each HTML page. It can be used to # fine-tune the look of the HTML output. If the tag is left blank doxygen # will generate a default style sheet. Note that doxygen will try to copy # the style sheet file to the HTML output directory, so don't put your own # stylesheet in the HTML output directory as well, or it will be erased! HTML_STYLESHEET = customdoxygen.css # If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, # files or namespaces will be aligned in HTML using tables. If set to # NO a bullet list will be used. HTML_ALIGN_MEMBERS = YES # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. For this to work a browser that supports # JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox # Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). HTML_DYNAMIC_SECTIONS = NO # If the GENERATE_DOCSET tag is set to YES, additional index files # will be generated that can be used as input for Apple's Xcode 3 # integrated development environment, introduced with OSX 10.5 (Leopard). # To create a documentation set, doxygen will generate a Makefile in the # HTML output directory. Running make will produce the docset in that # directory and running "make install" will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find # it at startup. # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html for more information. GENERATE_DOCSET = NO # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the # feed. A documentation feed provides an umbrella under which multiple # documentation sets from a single provider (such as a company or product suite) # can be grouped. DOCSET_FEEDNAME = "Doxygen generated docs" # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that # should uniquely identify the documentation set bundle. This should be a # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen # will append .docset to the name. DOCSET_BUNDLE_ID = org.doxygen.Project # If the GENERATE_HTMLHELP tag is set to YES, additional index files # will be generated that can be used as input for tools like the # Microsoft HTML help workshop to generate a compiled HTML help file (.chm) # of the generated HTML documentation. GENERATE_HTMLHELP = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can # be used to specify the file name of the resulting .chm file. You # can add a path in front of the file if the result should not be # written to the html output directory. CHM_FILE = # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can # be used to specify the location (absolute path including file name) of # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run # the HTML help compiler on the generated index.hhp. HHC_LOCATION = # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag # controls if a separate .chi index file is generated (YES) or that # it should be included in the master .chm file (NO). GENERATE_CHI = NO # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING # is used to encode HtmlHelp index (hhk), content (hhc) and project file # content. CHM_INDEX_ENCODING = # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag # controls whether a binary table of contents is generated (YES) or a # normal table of contents (NO) in the .chm file. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members # to the contents of the HTML help documentation and to the tree view. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and QHP_VIRTUAL_FOLDER # are set, an additional index file will be generated that can be used as input for # Qt's qhelpgenerator to generate a Qt Compressed Help (.qch) of the generated # HTML documentation. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can # be used to specify the file name of the resulting .qch file. # The path specified is relative to the HTML output folder. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#namespace QHP_NAMESPACE = # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating # Qt Help Project output. For more information please see # http://doc.trolltech.com/qthelpproject.html#virtual-folders QHP_VIRTUAL_FOLDER = doc # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. # For more information please see # http://doc.trolltech.com/qthelpproject.html#custom-filters QHP_CUST_FILTER_NAME = # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see # Qt Help Project / Custom Filters. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this project's # filter section matches. # Qt Help Project / Filter Attributes. QHP_SECT_FILTER_ATTRS = # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can # be used to specify the location of Qt's qhelpgenerator. # If non-empty doxygen will try to run qhelpgenerator on the generated # .qhp file. QHG_LOCATION = # The DISABLE_INDEX tag can be used to turn on/off the condensed index at # top of each HTML page. The value NO (the default) enables the index and # the value YES disables it. DISABLE_INDEX = NO # This tag can be used to set the number of enum values (range [1..20]) # that doxygen will group on one line in the generated HTML documentation. ENUM_VALUES_PER_LINE = 4 # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. # If the tag value is set to FRAME, a side panel will be generated # containing a tree-like index structure (just like the one that # is generated for HTML Help). For this to work a browser that supports # JavaScript, DHTML, CSS and frames is required (for instance Mozilla 1.0+, # Netscape 6.0+, Internet explorer 5.0+, or Konqueror). Windows users are # probably better off using the HTML help feature. Other possible values # for this tag are: HIERARCHIES, which will generate the Groups, Directories, # and Class Hierarchy pages using a tree view instead of an ordered list; # ALL, which combines the behavior of FRAME and HIERARCHIES; and NONE, which # disables this behavior completely. For backwards compatibility with previous # releases of Doxygen, the values YES and NO are equivalent to FRAME and NONE # respectively. GENERATE_TREEVIEW = NO # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be # used to set the initial width (in pixels) of the frame in which the tree # is shown. TREEVIEW_WIDTH = 250 # Use this tag to change the font size of Latex formulas included # as images in the HTML documentation. The default is 10. Note that # when you change the font size after a successful doxygen run you need # to manually remove any form_*.png images from the HTML output directory # to force them to be regenerated. FORMULA_FONTSIZE = 10 #--------------------------------------------------------------------------- # configuration options related to the LaTeX output #--------------------------------------------------------------------------- # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will # generate Latex output. GENERATE_LATEX = YES # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `latex' will be used as the default path. LATEX_OUTPUT = latex # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be # invoked. If left blank `latex' will be used as the default command name. LATEX_CMD_NAME = latex # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to # generate index for LaTeX. If left blank `makeindex' will be used as the # default command name. MAKEINDEX_CMD_NAME = makeindex # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact # LaTeX documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_LATEX = NO # The PAPER_TYPE tag can be used to set the paper type that is used # by the printer. Possible values are: a4, a4wide, letter, legal and # executive. If left blank a4wide will be used. PAPER_TYPE = a4wide # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX # packages that should be included in the LaTeX output. EXTRA_PACKAGES = # The LATEX_HEADER tag can be used to specify a personal LaTeX header for # the generated latex document. The header should contain everything until # the first chapter. If it is left blank doxygen will generate a # standard header. Notice: only use this tag if you know what you are doing! LATEX_HEADER = # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated # is prepared for conversion to pdf (using ps2pdf). The pdf file will # contain links (just like the HTML output) instead of page references # This makes the output suitable for online browsing using a pdf viewer. PDF_HYPERLINKS = YES # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of # plain latex in the generated Makefile. Set this option to YES to get a # higher quality PDF documentation. USE_PDFLATEX = YES # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. # command to the generated LaTeX files. This will instruct LaTeX to keep # running if errors occur, instead of asking the user for help. # This option is also used when generating formulas in HTML. LATEX_BATCHMODE = NO # If LATEX_HIDE_INDICES is set to YES then doxygen will not # include the index chapters (such as File Index, Compound Index, etc.) # in the output. LATEX_HIDE_INDICES = NO # If LATEX_SOURCE_CODE is set to YES then doxygen will include source code with syntax highlighting in the LaTeX output. Note that which sources are shown also depends on other settings such as SOURCE_BROWSER. LATEX_SOURCE_CODE = NO #--------------------------------------------------------------------------- # configuration options related to the RTF output #--------------------------------------------------------------------------- # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output # The RTF output is optimized for Word 97 and may not look very pretty with # other RTF readers or editors. GENERATE_RTF = NO # The RTF_OUTPUT tag is used to specify where the RTF docs will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `rtf' will be used as the default path. RTF_OUTPUT = rtf # If the COMPACT_RTF tag is set to YES Doxygen generates more compact # RTF documents. This may be useful for small projects and may help to # save some trees in general. COMPACT_RTF = NO # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated # will contain hyperlink fields. The RTF file will # contain links (just like the HTML output) instead of page references. # This makes the output suitable for online browsing using WORD or other # programs which support those fields. # Note: wordpad (write) and others do not support links. RTF_HYPERLINKS = NO # Load stylesheet definitions from file. Syntax is similar to doxygen's # config file, i.e. a series of assignments. You only have to provide # replacements, missing definitions are set to their default value. RTF_STYLESHEET_FILE = # Set optional variables used in the generation of an rtf document. # Syntax is similar to doxygen's config file. RTF_EXTENSIONS_FILE = #--------------------------------------------------------------------------- # configuration options related to the man page output #--------------------------------------------------------------------------- # If the GENERATE_MAN tag is set to YES (the default) Doxygen will # generate man pages GENERATE_MAN = NO # The MAN_OUTPUT tag is used to specify where the man pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `man' will be used as the default path. MAN_OUTPUT = man # The MAN_EXTENSION tag determines the extension that is added to # the generated man pages (default is the subroutine's section .3) MAN_EXTENSION = .3 # If the MAN_LINKS tag is set to YES and Doxygen generates man output, # then it will generate one additional man file for each entity # documented in the real man page(s). These additional files # only source the real man page, but without them the man command # would be unable to find the correct page. The default is NO. MAN_LINKS = NO #--------------------------------------------------------------------------- # configuration options related to the XML output #--------------------------------------------------------------------------- # If the GENERATE_XML tag is set to YES Doxygen will # generate an XML file that captures the structure of # the code including all documentation. GENERATE_XML = NO # The XML_OUTPUT tag is used to specify where the XML pages will be put. # If a relative path is entered the value of OUTPUT_DIRECTORY will be # put in front of it. If left blank `xml' will be used as the default path. XML_OUTPUT = xml # The XML_SCHEMA tag can be used to specify an XML schema, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_SCHEMA = # The XML_DTD tag can be used to specify an XML DTD, # which can be used by a validating XML parser to check the # syntax of the XML files. XML_DTD = # If the XML_PROGRAMLISTING tag is set to YES Doxygen will # dump the program listings (including syntax highlighting # and cross-referencing information) to the XML output. Note that # enabling this will significantly increase the size of the XML output. XML_PROGRAMLISTING = YES #--------------------------------------------------------------------------- # configuration options for the AutoGen Definitions output #--------------------------------------------------------------------------- # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will # generate an AutoGen Definitions (see autogen.sf.net) file # that captures the structure of the code including all # documentation. Note that this feature is still experimental # and incomplete at the moment. GENERATE_AUTOGEN_DEF = NO #--------------------------------------------------------------------------- # configuration options related to the Perl module output #--------------------------------------------------------------------------- # If the GENERATE_PERLMOD tag is set to YES Doxygen will # generate a Perl module file that captures the structure of # the code including all documentation. Note that this # feature is still experimental and incomplete at the # moment. GENERATE_PERLMOD = NO # If the PERLMOD_LATEX tag is set to YES Doxygen will generate # the necessary Makefile rules, Perl scripts and LaTeX code to be able # to generate PDF and DVI output from the Perl module output. PERLMOD_LATEX = NO # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be # nicely formatted so it can be parsed by a human reader. # This is useful # if you want to understand what is going on. # On the other hand, if this # tag is set to NO the size of the Perl module output will be much smaller # and Perl will parse it just the same. PERLMOD_PRETTY = YES # The names of the make variables in the generated doxyrules.make file # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. # This is useful so different doxyrules.make files included by the same # Makefile don't overwrite each other's variables. PERLMOD_MAKEVAR_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the preprocessor #--------------------------------------------------------------------------- # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will # evaluate all C-preprocessor directives found in the sources and include # files. ENABLE_PREPROCESSING = YES # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro # names in the source code. If set to NO (the default) only conditional # compilation will be performed. Macro expansion can be done in a controlled # way by setting EXPAND_ONLY_PREDEF to YES. MACRO_EXPANSION = YES # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES # then the macro expansion is limited to the macros specified with the # PREDEFINED and EXPAND_AS_DEFINED tags. EXPAND_ONLY_PREDEF = YES # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files # in the INCLUDE_PATH (see below) will be search if a #include is found. SEARCH_INCLUDES = YES # The INCLUDE_PATH tag can be used to specify one or more directories that # contain include files that are not input files but should be processed by # the preprocessor. INCLUDE_PATH = # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard # patterns (like *.h and *.hpp) to filter out the header-files in the # directories. If left blank, the patterns specified with FILE_PATTERNS will # be used. INCLUDE_FILE_PATTERNS = # The PREDEFINED tag can be used to specify one or more macro names that # are defined before the preprocessor is started (similar to the -D option of # gcc). The argument of the tag is a list of macros of the form: name # or name=definition (no spaces). If the definition and the = are # omitted =1 is assumed. To prevent a macro definition from being # undefined via #undef or recursively expanded use the := operator # instead of the = operator. PREDEFINED = DAI_WITH_BP \ DAI_WITH_FBP \ DAI_WITH_TRWBP \ DAI_WITH_MF \ DAI_WITH_HAK \ DAI_WITH_LC \ DAI_WITH_TREEEP \ DAI_WITH_JTREE \ DAI_WITH_MR \ DAI_WITH_CBP \ DAI_DEBUG \ DAI_DATE \ DAI_VERSION # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then # this tag can be used to specify a list of macro names that should be expanded. # The macro definition that is found in the sources will be used. # Use the PREDEFINED tag if you want to use a different macro definition. EXPAND_AS_DEFINED = # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then # doxygen's preprocessor will remove all function-like macros that are alone # on a line, have an all uppercase name, and do not end with a semicolon. Such # function macros are typically used for boiler-plate code, and will confuse # the parser if not removed. SKIP_FUNCTION_MACROS = NO #--------------------------------------------------------------------------- # Configuration::additions related to external references #--------------------------------------------------------------------------- # The TAGFILES option can be used to specify one or more tagfiles. # Optionally an initial location of the external documentation # can be added for each tagfile. The format of a tag file without # this location is as follows: # # TAGFILES = file1 file2 ... # Adding location for the tag files is done as follows: # # TAGFILES = file1=loc1 "file2 = loc2" ... # where "loc1" and "loc2" can be relative or absolute paths or # URLs. If a location is present for each tag, the installdox tool # does not have to be run to correct the links. # Note that each tag file must have a unique name # (where the name does NOT include the path) # If a tag file is not located in the directory in which doxygen # is run, you must also specify the path to the tagfile here. TAGFILES = # When a file name is specified after GENERATE_TAGFILE, doxygen will create # a tag file that is based on the input files it reads. GENERATE_TAGFILE = # If the ALLEXTERNALS tag is set to YES all external classes will be listed # in the class index. If set to NO only the inherited external classes # will be listed. ALLEXTERNALS = NO # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed # in the modules index. If set to NO, only the current project's groups will # be listed. EXTERNAL_GROUPS = YES # The PERL_PATH should be the absolute path and name of the perl script # interpreter (i.e. the result of `which perl'). PERL_PATH = /usr/bin/perl #--------------------------------------------------------------------------- # Configuration options related to the dot tool #--------------------------------------------------------------------------- # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base # or super classes. Setting the tag to NO turns the diagrams off. Note that # this option is superseded by the HAVE_DOT option below. This is only a # fallback. It is recommended to install and use dot, since it yields more # powerful graphs. CLASS_DIAGRAMS = YES # You can define message sequence charts within doxygen comments using the \msc # command. Doxygen will then run the mscgen tool (see # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the # documentation. The MSCGEN_PATH tag allows you to specify the directory where # the mscgen tool resides. If left empty the tool is assumed to be found in the # default search path. MSCGEN_PATH = # If set to YES, the inheritance and collaboration graphs will hide # inheritance and usage relations if the target is undocumented # or is not a class. HIDE_UNDOC_RELATIONS = YES # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is # available from the path. This tool is part of Graphviz, a graph visualization # toolkit from AT&T and Lucent Bell Labs. The other options in this section # have no effect if this option is set to NO (the default) HAVE_DOT = NO # By default doxygen will write a font called FreeSans.ttf to the output # directory and reference it in all dot files that doxygen generates. This # font does not include all possible unicode characters however, so when you need # these (or just want a differently looking font) you can specify the font name # using DOT_FONTNAME. You need need to make sure dot is able to find the font, # which can be done by putting it in a standard location or by setting the # DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory # containing the font. DOT_FONTNAME = FreeSans # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. # The default size is 10pt. DOT_FONTSIZE = 10 # By default doxygen will tell dot to use the output directory to look for the # FreeSans.ttf font (which doxygen will put there itself). If you specify a # different font using DOT_FONTNAME you can set the path where dot # can find it using this tag. DOT_FONTPATH = # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect inheritance relations. Setting this tag to YES will force the # the CLASS_DIAGRAMS tag to NO. CLASS_GRAPH = YES # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen # will generate a graph for each documented class showing the direct and # indirect implementation dependencies (inheritance, containment, and # class references variables) of the class with other documented classes. COLLABORATION_GRAPH = YES # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen # will generate a graph for groups, showing the direct groups dependencies GROUP_GRAPHS = YES # If the UML_LOOK tag is set to YES doxygen will generate inheritance and # collaboration diagrams in a style similar to the OMG's Unified Modeling # Language. UML_LOOK = NO # If set to YES, the inheritance and collaboration graphs will show the # relations between templates and their instances. TEMPLATE_RELATIONS = NO # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT # tags are set to YES then doxygen will generate a graph for each documented # file showing the direct and indirect include dependencies of the file with # other documented files. INCLUDE_GRAPH = YES # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and # HAVE_DOT tags are set to YES then doxygen will generate a graph for each # documented header file showing the documented files that directly or # indirectly include this file. INCLUDED_BY_GRAPH = YES # If the CALL_GRAPH and HAVE_DOT options are set to YES then # doxygen will generate a call dependency graph for every global function # or class method. Note that enabling this option will significantly increase # the time of a run. So in most cases it will be better to enable call graphs # for selected functions only using the \callgraph command. CALL_GRAPH = NO # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then # doxygen will generate a caller dependency graph for every global function # or class method. Note that enabling this option will significantly increase # the time of a run. So in most cases it will be better to enable caller # graphs for selected functions only using the \callergraph command. CALLER_GRAPH = NO # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen # will graphical hierarchy of all classes instead of a textual one. GRAPHICAL_HIERARCHY = YES # If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES # then doxygen will show the dependencies a directory has on other directories # in a graphical way. The dependency relations are determined by the #include # relations between the files in the directories. DIRECTORY_GRAPH = YES # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images # generated by dot. Possible values are png, jpg, or gif # If left blank png will be used. DOT_IMAGE_FORMAT = png # The tag DOT_PATH can be used to specify the path where the dot tool can be # found. If left blank, it is assumed the dot tool can be found in the path. DOT_PATH = # The DOTFILE_DIRS tag can be used to specify one or more directories that # contain dot files that are included in the documentation (see the # \dotfile command). DOTFILE_DIRS = # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of # nodes that will be shown in the graph. If the number of nodes in a graph # becomes larger than this value, doxygen will truncate the graph, which is # visualized by representing a node as a red box. Note that doxygen if the # number of direct children of the root node in a graph is already larger than # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. DOT_GRAPH_MAX_NODES = 50 # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the # graphs generated by dot. A depth value of 3 means that only nodes reachable # from the root by following a path via at most 3 edges will be shown. Nodes # that lay further from the root node will be omitted. Note that setting this # option to 1 or 2 may greatly reduce the computation time needed for large # code bases. Also note that the size of a graph can be further restricted by # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. MAX_DOT_GRAPH_DEPTH = 0 # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent # background. This is disabled by default, because dot on Windows does not # seem to support this out of the box. Warning: Depending on the platform used, # enabling this option may lead to badly anti-aliased labels on the edges of # a graph (i.e. they become hard to read). DOT_TRANSPARENT = NO # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output # files in one run (i.e. multiple -o and -T options on the command line). This # makes dot run faster, but since only newer versions of dot (>1.8.10) # support this, this feature is disabled by default. DOT_MULTI_TARGETS = NO # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will # generate a legend page explaining the meaning of the various boxes and # arrows in the dot generated graphs. GENERATE_LEGEND = YES # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will # remove the intermediate dot files that are used to generate # the various graphs. DOT_CLEANUP = YES #--------------------------------------------------------------------------- # Options related to the search engine #--------------------------------------------------------------------------- # The SEARCHENGINE tag specifies whether or not a search engine should be # used. If set to NO the values of all tags below this one will be ignored. SEARCHENGINE = NO libDAI-0.2.7/Makefile.ALL0000644000263000017630000000243511433220723013530 0ustar jorismkyb# This file is part of libDAI - http://www.libdai.org/ # # libDAI is licensed under the terms of the GNU General Public License version # 2, or (at your option) any later version. libDAI is distributed without any # warranty. See the file COPYING for more details. # # Copyright (C) 2009-2010 Joris Mooij [joris dot mooij at libdai dot org] # This file can be used to configure compile time options of libDAI. # Here the user can enable or disable various approximate inference # methods and additional build targets (documentation, MatLab interface) # and specify whether to build with debug information included. # # It is platform independent and is included by Makefile. # # A boolean variable VAR can be set to true ("VAR=true") or to false ("VAR=") # COMPILATION AND BUILD FLAGS # Enable/disable various approximate inference methods WITH_BP=true WITH_FBP=true WITH_TRWBP=true WITH_MF=true WITH_HAK=true WITH_LC=true WITH_TREEEP=true WITH_JTREE=true WITH_MR=true WITH_GIBBS=true WITH_CBP=true WITH_DECMAP=true # Build with debug info? (slower but safer) DEBUG=true # Build doxygen documentation? (doxygen and TeX need to be installed) WITH_DOC= # Build MatLab interface? (MatLab needs to be installed) WITH_MATLAB= # Build image segmentation example? (CImg needs to be installed) WITH_CIMG=