libDAI-0.3.2/0000755000175000017500000000000012552203325012167 5ustar jorismjorismlibDAI-0.3.2/swig/0000755000175000017500000000000012552203065013141 5ustar jorismjorismlibDAI-0.3.2/swig/example_sprinkler.py0000644000175000017500000000542712275703401017250 0ustar jorismjorism# This file is part of libDAI - http://www.libdai.org/ # # Copyright (c) 2006-2011, The libDAI authors. All rights reserved. # # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. # 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.3.2/swig/example_sprinkler.m0000644000175000017500000000555111605337426017060 0ustar jorismjorism% This file is part of libDAI - http://www.libdai.org/ % % Copyright (c) 2006-2011, The libDAI authors. All rights reserved. % % Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. % 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.3.2/swig/README0000644000175000017500000000035712053443232014024 0ustar jorismjorismThis directory contains preliminary experimental SWIG wrappers for libDAI written originally by Patrick Pletscher, extended later by Kyle Ellrott and Joris Mooij. They enable usage of libDAI functionality directly from python and octave. libDAI-0.3.2/swig/Makefile0000644000175000017500000000150012327731603014601 0ustar jorismjorism# This file is part of libDAI - http://www.libdai.org/ # # Copyright (c) 2006-2011, The libDAI authors. All rights reserved. # # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. 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 -lgmpxx -lgmp g++ -shared dai_wrap.o -o _dai.so ../lib/libdai.a -lgmpxx -lgmp 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 -lgmpxx -lgmp .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.3.2/swig/example.py0000644000175000017500000002176412053435451015162 0ustar jorismjorism# This file is part of libDAI - http:#www.libdai.org/ # # Copyright (c) 2006-2011, The libDAI authors. All rights reserved. # # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. # This example program illustrates how to read a factrograph from # a file and run Belief Propagation, Max-Product and JunctionTree on it. # This version uses the SWIG python wrapper of libDAI import dai import sys a = dai.IntVector() if len(sys.argv) != 2 and len(sys.argv) != 3: print 'Usage:', sys.argv[0], " [maxstates]" print 'Reads factor graph and runs' print 'Belief Propagation, Max-Product and JunctionTree on it.' print 'JunctionTree is only run if a junction tree is found with' print 'total number of states less than (where 0 means unlimited).' sys.exit(1) else: # Report inference algorithms built into libDAI # print 'Builtin inference algorithms:', dai.builtinInfAlgNames() # TODO THIS CRASHES # Read FactorGraph from the file specified by the first command line argument fg = dai.FactorGraph() fg.ReadFromFile(sys.argv[1]) maxstates = 1000000 if len(sys.argv) == 3: maxstates = int(sys.argv[2]) # Set some constants maxiter = 10000 tol = 1e-9 verb = 1 # Store the constants in a PropertySet object opts = dai.PropertySet() opts["maxiter"] = str(maxiter) # Maximum number of iterations opts["tol"] = str(tol) # Tolerance for convergence opts["verbose"] = str(verb) # Verbosity (amount of output generated) # Bound treewidth for junctiontree do_jt = True # TODO # try { # boundTreewidth(fg, &eliminationCost_MinFill, maxstates ); # } catch( Exception &e ) { # if( e.getCode() == Exception::OUT_OF_MEMORY ) { # do_jt = false; # cout << "Skipping junction tree (need more than " << maxstates << " states)." << endl; # } # else # throw; # } if do_jt: # 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 jtopts = opts jtopts["updates"] = "HUGIN" jt = dai.JTree( fg, jtopts ) # 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) jtmapopts = opts jtmapopts["updates"] = "HUGIN" jtmapopts["inference"] = "MAXPROD" jtmap = dai.JTree( fg, jtmapopts ) # Initialize junction tree algorithm jtmap.init() # Run junction tree algorithm jtmap.run() # Calculate joint state of all variables that has maximum probability 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 bpopts = opts bpopts["updates"] = "SEQRND" bpopts["logdomain"] = "0" bp = dai.BP( fg, bpopts ) # 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 mpopts = opts mpopts["updates"] = "SEQRND" mpopts["logdomain"] = "0" mpopts["inference"] = "MAXPROD" mpopts["damping"] = "0.1" mp = dai.BP( fg, mpopts ) # 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 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 decmapopts = opts decmapopts["reinit"] = "1" decmapopts["ianame"] = "BP" decmapopts["iaopts"] = "[damping=0.1,inference=MAXPROD,logdomain=0,maxiter=1000,tol=1e-9,updates=SEQRND,verbose=1]" decmap = dai.DecMAP( fg, decmapopts ) decmap.init() decmap.run() decmapstate = decmap.findMaximum() if do_jt: # Report variable marginals for fg, calculated by the junction tree algorithm print 'Exact variable marginals:' for i in range(fg.nrVars()): # iterate over all variables in fg print jt.belief(dai.VarSet(fg.var(i))) # display the "belief" of jt for that variable # Report variable marginals for fg, calculated by the belief propagation algorithm print 'Approximate (loopy belief propagation) variable marginals:' for i in range(fg.nrVars()): # iterate over all variables in fg print bp.belief(dai.VarSet(fg.var(i))) # display the belief of bp for that variable if do_jt: # Report factor marginals for fg, calculated by the junction tree algorithm print 'Exact factor marginals:' for I in range(fg.nrFactors()): # iterate over all factors in fg print jt.belief(fg.factor(I).vars()) # display the "belief" of jt for the variables in that factor # Report factor marginals for fg, calculated by the belief propagation algorithm print 'Approximate (loopy belief propagation) factor marginals:' for I in range(fg.nrFactors()): # iterate over all factors in fg print bp.belief(fg.factor(I).vars()) # display the belief of bp for the variables in that factor if do_jt: # Report log partition sum (normalizing constant) of fg, calculated by the junction tree algorithm print 'Exact log partition sum:', jt.logZ() # Report log partition sum of fg, approximated by the belief propagation algorithm print 'Approximate (loopy belief propagation) log partition sum:', bp.logZ() if do_jt: # Report exact MAP variable marginals print 'Exact MAP variable marginals:' for i in range(fg.nrVars()): print jtmap.belief(dai.VarSet(fg.var(i))) # Report max-product variable marginals print 'Approximate (max-product) MAP variable marginals:' for i in range(fg.nrVars()): print mp.belief(dai.VarSet(fg.var(i))) if do_jt: # Report exact MAP factor marginals print 'Exact MAP factor marginals:' for I in range(fg.nrFactors()): print jtmap.belief(fg.factor(I).vars()), '==', jtmap.belief(fg.factor(I).vars()) # Report max-product factor marginals print 'Approximate (max-product) MAP factor marginals:' for I in range(fg.nrFactors()): print mp.belief(fg.factor(I).vars()), '==', mp.belief(fg.factor(I).vars()) if do_jt: # Report exact MAP joint state hoie = dai.IntVector() hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) hoie.push_back( 0 ) print 'Exact MAP state (log score =', fg.logScore( hoie ), '):' for i in range(len(jtmapstate)): print fg.var(i), ':', jtmapstate[i] # Report max-product MAP joint state print 'Approximate (max-product) MAP state (log score =', fg.logScore( mpstate ), '):' for i in range(len(mpstate)): print fg.var(i), ':', mpstate[i] # Report DecMAP joint state print 'Approximate DecMAP state (log score =', fg.logScore( decmapstate ), '):' for i in range(len(decmapstate)): print fg.var(i), ':', decmapstate[i] libDAI-0.3.2/swig/dai.i0000644000175000017500000002407012275703276014066 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ %module dai #include %include "std_string.i" %include "std_vector.i" %template(IntVector) std::vector; //%include "std_set.i" /* for python */ %include "../include/dai/dai_config.h" %{ #include "../include/dai/alldai.h" using namespace dai; %} // ************************************************************************************************ %include "../include/dai/util.h" // ************************************************************************************************ %ignore dai::Var::label() const; %ignore dai::Var::states() const; %ignore operator<<(std::ostream&, const Var&); %include "../include/dai/var.h" %extend dai::Var { inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ }; // ************************************************************************************************ %ignore operator<<(std::ostream&, const SmallSet&); %rename(__eq__) operator==(const SmallSet&, const SmallSet&); /* for python */ %rename(__ne__) operator!=(const SmallSet&, const SmallSet&); /* for python */ %rename(__lt__) operator<(const SmallSet&, const SmallSet&); /* for python */ %include "../include/dai/smallset.h" %template(SmallSetVar) dai::SmallSet< dai::Var >; %extend dai::SmallSet { inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ } // ************************************************************************************************ %ignore operator<<(std::ostream&, const VarSet&); %include "../include/dai/varset.h" %extend dai::VarSet { inline void append(const dai::Var &v) { (*self) |= v; } /* for python, octave */ inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ }; // ************************************************************************************************ %ignore dai::TProb::operator[]; %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 */ inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ }; // ************************************************************************************************ %ignore dai::TFactor::operator[]; %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 */ inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ }; %template(Factor) dai::TFactor; %inline %{ typedef std::vector VecFactor; typedef std::vector VecVecFactor; %} %template(VecFactor) std::vector; %template(VecVecFactor) std::vector; // ************************************************************************************************ %ignore operator<<(std::ostream&, const GraphAL&); %rename(toInt) dai::Neighbor::operator size_t() const; %include "../include/dai/graph.h" %extend dai::GraphAL { inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ } // ************************************************************************************************ %ignore operator<<(std::ostream&, const BipartiteGraph&); %include "../include/dai/bipgraph.h" %extend dai::BipartiteGraph { inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ } // ************************************************************************************************ %ignore operator<<(std::ostream&, const FactorGraph&); %ignore operator>>(std::istream&,FactorGraph&); %include "../include/dai/factorgraph.h" %extend dai::FactorGraph { inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ inline void printDot(const std::string& fname) const { std::ofstream o(fname.c_str(), std::ofstream::out); self->printDot(o); o.close(); } } // ************************************************************************************************ %ignore operator<<(std::ostream&, const RegionGraph&); %include "../include/dai/regiongraph.h" %extend dai::RegionGraph { inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ } // ************************************************************************************************ //%ignore operator<<(std::ostream&, const CobwebGraph&); //%include "../include/dai/cobwebgraph.h" //%extend dai::CobwebGraph { // inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ // inline std::string __str() const { return (*self).toString(); } /* for octave */ //} //TODO fix problems with CobwebGraph // ************************************************************************************************ %ignore operator<<(std::ostream&, const PropertySet&); %ignore operator>>(std::istream&,PropertySet&); %include "../include/dai/properties.h" %extend dai::PropertySet { inline void __setitem__(char *name, char *val) { self->set(std::string(name), std::string(val)); } inline const char* __str__() const { return (*self).toString().c_str(); } /* for python */ inline std::string __str() const { return (*self).toString(); } /* for octave */ } // ************************************************************************************************ %ignore dai::IndexFor::operator++; %rename(toInt) dai::IndexFor::operator size_t() const; %ignore dai::Permute::operator[]; %ignore dai::multifor::operator++; %ignore dai::multifor::operator[]; %rename(toInt) dai::multifor::operator size_t() const; %ignore dai::State::operator++; %rename(toInt) dai::State::operator size_t() const; %ignore dai::State::operator const std::map&; %include "../include/dai/index.h" %extend dai::IndexFor { inline void next() { return (*self)++; } }; %extend dai::Permute { inline size_t __getitem__(int i) const {return (*self)[i];} /* for python */ inline size_t __paren__(int i) const {return (*self)[i];} /* for octave */ }; %extend dai::multifor { inline void next() { return (*self)++; } inline size_t __getitem__(int i) const {return (*self)[i];} /* for python */ inline size_t __paren__(int i) const {return (*self)[i];} /* for octave */ }; %extend dai::State { inline void next() { return (*self)++; } }; // ************************************************************************************************ %include "../include/dai/daialg.h" //TODO: why do the following lines not work? //%template(DAIAlgFG) dai::DAIAlg; //%template(DAIAlgRG) dai::DAIAlg; //%template(DAIAlgCG) dai::DAIAlg; // ************************************************************************************************ %include "../include/dai/alldai.h" // ************************************************************************************************ %ignore dai::BP::operator=; %include "../include/dai/bp.h" // ************************************************************************************************ %include "../include/dai/fbp.h" // ************************************************************************************************ %include "../include/dai/trwbp.h" // ************************************************************************************************ %include "../include/dai/mf.h" // ************************************************************************************************ %include "../include/dai/hak.h" // ************************************************************************************************ %include "../include/dai/lc.h" // ************************************************************************************************ %include "../include/dai/jtree.h" // ************************************************************************************************ %ignore dai::TreeEP::operator=; %include "../include/dai/treeep.h" // ************************************************************************************************ %include "../include/dai/mr.h" // ************************************************************************************************ %include "../include/dai/gibbs.h" // ************************************************************************************************ %include "../include/dai/cbp.h" // ************************************************************************************************ %include "../include/dai/decmap.h" // ************************************************************************************************ %include "../include/dai/glc.h" libDAI-0.3.2/AUTHORS0000644000175000017500000000231712552201240013234 0ustar jorismjorismlibDAI 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), Siamak Ravanbakhsh (contributed the generalized loop corrections code), 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, Laurens van der Maaten, Jerome Maye, Priya, Hynek Urban, Avneesh Saluja, Thomas Mensink, Julien Rebetez, Kyle Ellrott. Part of this work was part of the Interactive Collaborative Information Systems (ICIS) project, supported by the Dutch Ministry of Economic Affairs, grant BSIK03024. The Radboud University Nijmegen, The Netherlands, is one of the copyright holders. libDAI-0.3.2/include/0000755000175000017500000000000012533555767013635 5ustar jorismjorismlibDAI-0.3.2/include/dai/0000755000175000017500000000000012552202746014355 5ustar jorismjorismlibDAI-0.3.2/include/dai/cobwebgraph.h0000644000175000017500000002555712053444420017020 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2012, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class CobwebGraph, which implements a type of region graph used by GLC. #ifndef __defined_libdai_cobwebgraph_h #define __defined_libdai_cobwebgraph_h #include #include #include #include #include #include #include #include namespace dai { /// A CobwebGraph is a special type of region graph used by the GLC algorithm /** \author Siamak Ravanbakhsh * \todo Implement unit test for Cobwebgraph */ class CobwebGraph : public FactorGraph { public: /// The information in connection between two regions struct Connection { /// Index of the first region (p) size_t my; /// Index of the second region (q) size_t his; /// Index of this connection in the connections of the first region size_t iter; /// Index of the mirror of this connection in the connections of the second region. (reference of this message in _outM) size_t dual; /// The message sent from region q (his) to p (my) Factor msg; /// "Index" of variables in the message std::vector varinds; /// Used as a temporary factor only /** \todo Remove CobwebGraph::Connection::newmsg */ Factor newmsg; /// Index of factors in common std::vector fc; /// Regions rho that are descendents of msg from q to p in p's msg-region graph (not used in partitioning case) std::vector subregions; }; /** Indicates what happens if a subset of variables in the boundary of a region (\ominus r_p) is shared by * some neighbors such that one (\ominus r_{p,q1}) is a subset of another (\ominus r_{p,q2}). * - ALL all such neighbors are included in the the updates. * - TOP only (\ominus r_{p,q2}) is included unless (\ominus r_{p,q2} = \ominus r_{p,q1}) in which case both are included * - CLOSEST (default): similar to TOP but in case of a tie the the region r_q with largest r_q \cap r_p is considered * \note Not important in perfomance! */ DAI_ENUM(NeighborType,ALL,TOP,CLOSEST); protected: /// Vector of variable indices internal to each region (r) std::vector > _INRs; /// Vector of variable indices on the boundary of each region (\ominus r) std::vector > _EXRs; /// Index of factors in each region std::vector > _Rfs; /// Index of factors internal to each region, i.e., all its variables are internal to the region std::vector > _Rifs; /// Index of factors that bridge each region, i.e., not all its variables are internal to the region std::vector > _Rxfs; /// The vector of domain of messages leaving each region (\ominus r_{p,q}) std::vector > _outM; /// Vector of all connections to each region std::vector > _M; /// For each i the index of (cobweb) regions that contain variable i std::vector > _var2CW; /** For each region r_p a mapping from all variables rho in its msg-region graph to a pair: * first: counting number * second: the index of top-regions that contain rho */ std::vector > > > _cn; /// Whether a given set of region vars makes a partitioning or not bool isPartition; public: /// \name Constructors and destructors //@{ /// Default constructor CobwebGraph() : FactorGraph(), _INRs(), _EXRs(),_Rfs(),_Rifs(),_Rxfs(), _M(), _var2CW(), _cn(), isPartition(true) {} /// Constructs a cobweb graph from a factor graph CobwebGraph( const FactorGraph& fg ): FactorGraph(), _INRs(), _EXRs(),_Rfs(), _M(), _var2CW(), _cn(), isPartition(true) { // Copy factor graph structure FactorGraph::operator=( fg ); } /// Clone \c *this (virtual copy constructor) virtual CobwebGraph* clone() const { return new CobwebGraph(*this); } //@} /// \name Accessors and mutators //@{ /// Returns the number of regions size_t nrCWs() const { return _INRs.size(); } /// Returns constant reference to the _cn for region \a R const std::map > >& cn( size_t R ) const { DAI_DEBASSERT( R < nrCWs() ); return _cn[R]; } /// Returns a reference to the _cn for region \a R std::map > >& cn( size_t R ) { DAI_DEBASSERT( R < nrCWs() ); return _cn[R]; } /// Returns constant reference the vector of domain of all outgoing messages from region \a R const std::vector& outM( size_t R ) const { DAI_DEBASSERT( R < _outM.size() ); return _outM[R]; } /// Returns reference the vector of domain of all outgoing messages from region \a R std::vector& outM( size_t R ) { DAI_DEBASSERT( R < _outM.size() ); return _outM[R]; } /// Returns constant reference to the variables in the outgoing message from region \a R to its \a j'th neighbor /** \a j corresponds to dual in the connection construct */ const VarSet& outM( size_t R, size_t j ) const { DAI_DEBASSERT( R < _outM.size() ); DAI_DEBASSERT( j < _outM[R].size() ); return _outM[R][j]; } /// Returns a reference to the variables in the outgoing message from region \a R to its \a j'th neighbor /** \a j corresponds to dual in the connection construct */ VarSet& outM( size_t R, size_t j ) { DAI_DEBASSERT( R < _outM.size() ); DAI_DEBASSERT( j < _outM[R].size() ); return _outM[R][j]; } /// Returns constant reference to the index of factors of region \a R const SmallSet& Rfs( size_t R ) const { DAI_DEBASSERT( R < _Rfs.size() ); return _Rfs[R]; } /// Returns reference to the index of factors of region \a R SmallSet& Rfs( size_t R ) { DAI_DEBASSERT( R < _Rfs.size() ); return _Rfs[R]; } /// Returns constant reference to the index of variables on the boundary of region \a R (\ominus r) const SmallSet& EXRs( size_t R ) const { DAI_DEBASSERT( R < _EXRs.size() ); return _EXRs[R]; } /// Returns reference to the index of variables on the boundary of region \a R (\ominus r) SmallSet& EXRs( size_t R ) { DAI_DEBASSERT( R < _EXRs.size() ); return _EXRs[R]; } /// Returns constant reference to the index of variables inside region \a R (r) const SmallSet& INRs( size_t R ) const { DAI_DEBASSERT( R < _INRs.size() ); return _INRs[R]; } /// Returns reference to the index of variables inside region \a R (r) SmallSet& INRs( size_t R ) { DAI_DEBASSERT( R < _INRs.size() ); return _INRs[R]; } /// Returns constant reference to the connection structure from region \a R to its \a i'th neighbour const Connection& M( size_t R, size_t i ) const { DAI_DEBASSERT(R < _M.size()); DAI_DEBASSERT(i < _M[R].size()); return _M[R][i]; } /// Returns reference to the connection structure from region \a R to its \a i'th neighbour Connection& M( size_t R, size_t i ) { DAI_DEBASSERT(R < _M.size()); DAI_DEBASSERT(i < _M[R].size()); return _M[R][i]; } /// Returns constant reference to the vector of connection structure from region \a R to all its neighbours const std::vector& M( size_t R ) const { DAI_DEBASSERT(R < _M.size()); return _M[R]; } /// Returns vector of all connections to region \a R std::vector& M( size_t R ) { return _M[R]; } /// Returns the vector of region indices that contain \a i as internal variable const std::vector& var2CW( size_t i ) const { return _var2CW[i]; } //@} /// \name Operations //@{ /// Sets up all the regions and messages void setRgn( std::vector > regions, NeighborType neighbors, bool debugging = false ); //@} /// \name Input/output //@{ /// Reads a cobweb graph from a file /** \note Not implemented yet */ virtual void ReadFromFile( const char* /*filename*/ ) { DAI_THROW(NOT_IMPLEMENTED); } /// Writes a cobweb 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 cobweb graph to an output stream friend std::ostream& operator<< ( std::ostream& /*os*/, const CobwebGraph& /*rg*/ ) { DAI_THROW(NOT_IMPLEMENTED); } /// Formats a cobweb graph as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } /// Writes a cobweb graph to a GraphViz .dot file /** \note Not implemented yet */ virtual void printDot( std::ostream& /*os*/ ) const { DAI_THROW(NOT_IMPLEMENTED); } //@} protected: /// The function to check for partitioning bool checkPartition( const std::vector >& regions ) const; /// Helper function that sets the regions containing each variable using the values in _INRs void setVar2CW(); /// Setup the _INRs, _EXRs and all the factor indices (e.g. Rifs) void setExtnFact(); /// Helper function that setups the msgs (_M, _outM) using the values in _INRs and _EXRs void setMSGs( NeighborType neighbors ); /// Sets _cn void setCountingNumbers( bool debugging = false ); /// For the given set of variables for each region, removes the regions that are non-maximal void eraseNonMaximal( std::vector >& regions ); }; } // end of namespace dai #endif libDAI-0.3.2/include/dai/bbp.h0000644000175000017500000004424412233677370015306 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 #ifdef DAI_WITH_CBP #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 #endif libDAI-0.3.2/include/dai/gibbs.h0000644000175000017500000001266712233677213015631 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class Gibbs, which implements Gibbs sampling #ifndef __defined_libdai_gibbs_h #define __defined_libdai_gibbs_h #include #ifdef DAI_WITH_GIBBS #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; 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 Gibbs* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new Gibbs( fg, opts ); } virtual std::string name() const { return "GIBBS"; } 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 #endif libDAI-0.3.2/include/dai/glc.h0000644000175000017500000003777312233677520015316 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2012, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines classes GLC and Cobweb, which implement the "Generalized Loop Correction method" /// \todo Fix the init of GLC #ifndef __defined_libdai_glc_h #define __defined_libdai_glc_h #include #ifdef DAI_WITH_GLC #include #include #include #include #include #include #include #include #include namespace dai { /// Represents a region for the GLC algorithm. /** This region contains all the proper factors from the factor graph. It also contains a factor for incoming messages and the * cavity distribution over this region. The outgoing messages also receive a factor mainly so that we can easily calculate the marginal * of the region over the outgoing message variables. * * \author Siamak Ravanbakhsh */ class Cobweb { public: /// Pointer to the approximate inference algorithm and factor graph over region R (provided in parameters of GLC) DAIAlgFG *cav; /// Global to local factor index conversion. /** Factor(I) in original graph corresponds to cav->factor(_g2l[I]) in this region * the j'th incoming message to this region M(R,j) corresponds to cav->factor(_g2l[-j-1]) * the j'th cavity factor (for pairwise case),_cavitydists[R][j] corresponds to cav->factor(_g2l[-m-j-1]) * when m = M(R).size() * note that for full cavity the _cavitydists[R] has a single factor and for uniform cavity it is empty * the j'th outgoing message from this region outM(R,j) corresponds to cav->factor(_g2l[-c-m-j-1]) * when m = M(R).size() and c = _cavitydists[R].size() */ std::map _g2l; /// Default constructor Cobweb(){} /// Construct from global-to-local factor index conversion structure Cobweb( const std::map& g2l ): cav(0), _g2l(g2l) {} /// Default destructor virtual ~Cobweb(){ delete cav; } /// Sets the factor graph and inference algorithm for this region void setInfAlg( DAIAlgFG* alg ) { cav = alg; } /// Returns the factor of this region globaly indexed by \a I (mainly used to access messages to and from this region) Factor factor( size_t I ) { return cav->factor( _g2l[I] ); } /// Initializes the inference algorithm over this region void initialize() { cav->init(); } /// Calculates the marginal over \a ns after temporarily removing the factors indexed by \a rmgind Factor marginal( const VarSet& ns, const std::vector& rmgind ) { // Set the factors in rmgind to one VarSet vs; std::vector rmlinds; // local index rmlinds.reserve( rmgind.size() ); for( std::vector::const_iterator it = rmgind.begin(); it != rmgind.end(); it++ ) { vs |= cav->factor( _g2l[*it] ).vars(); rmlinds.push_back( _g2l[*it] ); } cav->makeRegionCavity( rmlinds, true ); // Initialize if necessary cav->init( vs ); cav->run(); Factor result; result = cav->belief( ns ); cav->restoreFactors(); return result; } /// Calculates the marginal over the variables in outgoing message indexed by \a outmsgind after temporarily removing the factors indexed by \a rmgind /** This function is used to calculate outgoing messages from this region */ Factor marginal( const int& outmsgind, const std::vector& rmgind ) { // set the factors in rmgind to one VarSet vs; std::vector rmlinds; // local index rmlinds.reserve( rmgind.size() ); for( std::vector::const_iterator it = rmgind.begin(); it != rmgind.end(); it++ ) { vs |= cav->factor( _g2l[*it] ).vars(); rmlinds.push_back( _g2l[*it] ); } cav->makeRegionCavity( rmlinds, true ); // Initialize if necessary cav->init( vs ); cav->run(); Factor result; result = cav->beliefF( _g2l[outmsgind] ); cav->restoreFactors(); return result; } /// Sets (or multiplies, if \a multiply == \c true) the factor indexed by \a gind by factor \a msg void updateFactor( int gind, const Factor& msg, bool multiply=false ) { if( !multiply ) cav->setFactor( _g2l[gind], msg, false ); else cav->setFactor( _g2l[gind], (msg*(cav->factor( _g2l[gind] ))).normalized(), false ); } /// Runs inference and returns belief of variable \a v Factor belief( const Var v ) { cav->run(); return cav->belief( v ); } /// Runs inference and returns belief of variables \a vs Factor belief( const VarSet& vs ) { cav->run(); return cav->belief( vs ); } }; /// Approximate inference algorithm "Generalized Loop Correction" [\ref RYG12] /** Inherits from a CobwebGraph which in turn inherits from a FactorGraph. * Although a CobwebGraph represents the graph with cobweb clusters (for design reasons?), * the actual vector of cobwebs is contained in GLC class. All the other functionalities * needed to represent the cobwebgraph is in its own class. The cobweb provides the function * of marginalization using the provided inference method. This can be beneficial when using * uniform cavities (or a subset of pairwise cavities, but this is not implemented yet). * However, in general the performance does not improve using Junction Tree instead of exact marginalization... * * \author Siamak Ravanbakhsh */ class GLC : public DAIAlgCG { private: /// Stores for each variable the approximate cavity distribution std::vector _CWs; /// Gives the starting global index for the factors of outgoing messages of each region std::vector _outOffset; /// Cavity distributions /** For each region it contains: * - Nothing if using UniCAV * - One Factor if using FullCAV * - All pairwise caivity factors if using PairCAV or Pair2CAV */ std::vector > _cavitydists; /// Single variable beliefs std::vector _beliefs; /// Beliefs over factors std::map _factorBeliefs; /// Maximum difference encountered so far Real _maxdiff; /// Number of iterations needed size_t _iters; public: /// Parameters for GLC 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 possible types of region (\ominus r in the paper) /** The following initialization methods are defined: * - SINGLE using single variable * - FACTOR partitioning regions of that form corresponding to GLC (in the paper) * - LOOP partitioning regions of that form corresponding to GLC (in the paper) * - DELTA partitioning regions of that form corresponding to GLC (in the paper) * - OVFACTOR, OVLOOP, OVDELTA the corresponding form of region in the overlapping form corresponding to GLC+ (in the paper) * For example, using OVFACTOR each factor becomes a region (\ominus r), while using FACTOR the regions contain only * non-overlapping factors and if some variables can't be covered by any remaining factors single variable regions * are constructed for them. * With this convention OVDELTA here corresponds to DELTA using CVM (HAK). */ DAI_ENUM(RegionType,SINGLE,FACTOR,OVFACTOR,LOOP,OVLOOP,DELTA,OVDELTA) /// 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 length of the loops to use in construction of loopy regions size_t loopdepth; /// Maximum number of iterations size_t maxiter; /// The algorithm will quit and report the current result at reaching this runtime Real maxtime; /// Tolerance for convergence test Real tol; /// Complete or partial reinitialization of the messages in calculating the cavity distribution? bool reinit; /// Whether or not to include auxiliary factors in a region. /** The auxilary factors are the ones that only depend on variables on the boundary of a region (\oplus r - \ominus r). * This sometimes produces orders of magnitude improvement (e.g., in grids), but it is not discussed in the paper. */ bool auxfactors; /// How to initialize the cavities CavityType cavity; // Type of region RegionType rgntype; /// What update schedule to use UpdateType updates; /** Indicates what happens if a subset of variables in the boundary of a region (\ominus r_p) is shared by * some neighbors such that one (\ominus r_{p,q1}) is a subset of another (\ominus r_{p,q2}). * - ALL all such neighbors are included in the the updates. * - TOP only (\ominus r_{p,q2}) is included unless (\ominus r_{p,q2} = \ominus r_{p,q1}) in which case both are included * - CLOSEST (default): similar to TOP but in case of a tie the the region r_q with largest r_q \cap r_p is considered * \note Not important in perfomance! */ CobwebGraph::NeighborType neighbors; /// 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; // Name of the algorithm used for marginalization over a region (EXACT is fine) std::string inainame; // Parameters for algorithm used for marginalization over a region PropertySet inaiopts; } props; public: /// Default constructor GLC() : DAIAlgCG(), _CWs(),_outOffset(), _cavitydists(), _beliefs(), _factorBeliefs(), _maxdiff(), _iters(), props() {} /// Construct from FactorGraph \a fg and PropertySet \a opts /** \param fg Factor graph. * \param opts Parameters @see Properties */ GLC( const FactorGraph &fg, const PropertySet &opts ); /// \name General InfAlg interface //@{ virtual GLC* clone() const { return new GLC(*this); } virtual GLC* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new GLC( fg, opts ); } virtual std::string name() const { return "GLC"; } 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; virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; } virtual void init(){ initCWs(); } 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 GLC //@{ /// Returns constant reference to outer region \a alpha const Cobweb& CW( size_t alpha ) const { DAI_DEBASSERT( alpha < nrCWs() ); return _CWs[alpha]; } /// Returns reference to outer region \a alpha Cobweb& CW( size_t alpha ) { DAI_DEBASSERT( alpha < nrCWs() ); return _CWs[alpha]; } /// 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 ); /// Updates the belief of the Markov blanket of region \a R using its intersection with \a _R2'th neighbor (partitioning case). void NewPancake( size_t R, size_t _R2 ); /// Updates the belief of the Markov blanket of region \a R using all its overlapping neighbors (non-partitioning case). /** \note The implementation uses a more compact form than the message passing over neighborhood region-graph explained in the paper. */ void OVNewPancake( size_t R ); /// Calculates the belief of variable \a i: if \a isFinal == \c true, it returns the geometric average given by all regions that include \a i void CalcBelief( size_t i, bool isFinal = false ); /// Calculates the belief of factor \a I void CalcFactorBelief( size_t I ); /// Designates the variables in each region of the graph based on the rgntype std::vector > calcRegions(); /// Initializes the cobweb regions and all the messages between regions. void initCWs(); /// Initializes all the cobweb regions. /** Defines their factors using the cavity distribution (as factor(s)) * and all the anticipated messages to be exchanged with other regions (treating a message as a factor), * and also it builds a mapping from cobweb factors to factors of the original factor graph and messages. */ void setCWs( const std::string &name, const PropertySet &opts ); /// Helper function for partitioning case to build the regions by finding loops of maximum given size. /** If a variable is contained in a loop it is not considered for inclusion in any other loop. */ void findLoopClusters( SmallSet& remaining, std::set > &allcl, SmallSet newcl, const size_t& root, size_t length, SmallSet vars ); /// Helper function for general case to build the regions by finding loops of maximum given size. /** All loops of max-size are found and variables that are not covered are contained in smaller loops or in factor-sized or single-variable regions. */ void findOVLoopClusters( SmallSet& remaining, std::set > &allcl, SmallSet newcl, const size_t& root, size_t length, SmallSet vars ); //@} }; } // end of namespace dai #endif #endif libDAI-0.3.2/include/dai/jtree.h0000644000175000017500000002202712233677064015647 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class JTree, which implements the junction tree algorithm #ifndef __defined_libdai_jtree_h #define __defined_libdai_jtree_h #include #ifdef DAI_WITH_JTREE #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; 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 JTree* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new JTree( fg, opts ); } virtual std::string name() const { return "JTREE"; } 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; 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 #endif libDAI-0.3.2/include/dai/doc.h0000644000175000017500000012213312552201347015271 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /** \file * \brief Contains additional doxygen documentation * * \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.3.2 * \date July 17, 2015 * *
* \section about About libDAI * libDAI is a free/open source C++ library 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.7 (both 32 and 64 bits). * * libDAI has also been successfully compiled with MS Visual Studio 2008 under Windows, * MS Visual Studio 2010 under Windows 64, and with Cygwin under Windows. * * Finally, libDAI has been compiled successfully on MacOS X (both 32 and 64 bits). * * \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 BSD 2-clause license (also known as the FreeBSD license), which * can be found in the accompanying LICENSE file. * * [Note: up to and including version 0.2.7, libDAI was licensed under the GNU * General Public License (GPL) version 2 or higher.] * *
* \section license-freebsd libDAI license (similar to FreeBSD license) * * \verbinclude LICENSE */ /** \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, 11(Aug):2169-2173, 2010.\n * * In BiBTeX format (for your convenience):\n * * 
 *  \@article{Mooij_libDAI_10,
 *    author    = {Joris M. Mooij},
 *    title     = {lib{DAI}: A Free and Open Source {C++} Library for Discrete Approximate Inference in Graphical Models},
 *    journal   = {Journal of Machine Learning Research},
 *    year      = 2010,
 *    month     = Aug,
 *    volume    = 11,
 *    pages     = {2169-2173},
 *    url       = "http://www.jmlr.org/papers/volume11/mooij10a/mooij10a.pdf"
 *  }
* * 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) * - GMP library (or the Windows port called MPIR, for 64 bits builds MPIR 2.5.0 or higher is needed) * - 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 libgmp-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 gmp 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) * - GMP or MPIR library (for 64-bits builds, MPIR 2.5.0 or higher is needed) * - 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-gmp Building GMP or MPIR under Windows * * Information about how to build GPR or MPIR under Windows can be found on the internet. * The user has to update Makefile.WINDOWS in order to link with the GPR/MPIR libraries. * Note that for 64-bit builds, MPIR 2.5.0 or higher is needed. * * \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 RYG12 \ref RYG12 * S. Ravanbakhsh, C.-N. Yu, R. Greiner (2012): * "A Generalized Loop Correction Method for Approximate Inference in Graphical Models", * 29th International Conference on Machine Learning (ICML 2012), * http://www.icml.cc/2012/papers/#paper-304 * * \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.3.2/include/dai/evidence.h0000644000175000017500000000536511605337426016323 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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.3.2/include/dai/mr.h0000644000175000017500000001561212233677130015150 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 #ifdef DAI_WITH_MR #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; 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 MR* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new MR( fg, opts ); } virtual std::string name() const { return "MR"; } 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 #endif libDAI-0.3.2/include/dai/hak.h0000644000175000017500000001454412233676626015311 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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. #include #ifdef DAI_WITH_HAK #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; 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 HAK* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new HAK( fg, opts ); } virtual std::string name() const { return "HAK"; } 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 #endif libDAI-0.3.2/include/dai/alldai.h0000644000175000017500000001410012054704070015742 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /** \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 #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 #ifdef DAI_WITH_GLC #include #endif /// Namespace for libDAI namespace dai { /// Returns a map that contains for each built-in inference algorithm its name and a pointer to an object of that type /** \obsolete This functionality is obsolete and will be removed in future versions of libDAI */ std::map& builtinInfAlgs(); /// Returns a set of names of all available inference algorithms /* These are the names of the algorithms that were compiled in and can be * given to \ref newInfAlg and \ref newInfAlgFromString. * \return A set of strings, each one corresponding with the name of an available inference algorithm. * \note The set is returned by value because it will be reasonably small * enough and this function is expected to be called infrequently. */ std::set builtinInfAlgNames(); /// Constructs a new inference algorithm. /** \param name The name of the inference algorithm. * \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 ); } // 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.3.2/include/dai/trwbp.h0000644000175000017500000001273312233706372015672 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class TRWBP, which implements Tree-Reweighted Belief Propagation #ifndef __defined_libdai_trwbp_h #define __defined_libdai_trwbp_h #include #ifdef DAI_WITH_TRWBP #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; 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 TRWBP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new TRWBP( fg, opts ); } virtual std::string name() const { return "TRWBP"; } 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 #endif libDAI-0.3.2/include/dai/properties.h0000644000175000017500000002454612053400024016716 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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; bforeach(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 ); /// Formats a PropertySet as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } /// 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 ); /// Reads a PropertySet from a string void fromString( const std::string& s ) { std::stringstream ss( s ); ss >> *this; } //@} }; } // end of namespace dai #endif libDAI-0.3.2/include/dai/varset.h0000644000175000017500000001611512053365470016036 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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$. */ BigInt nrStates() const { BigInt states = 1; for( VarSet::const_iterator n = begin(); n != end(); n++ ) states *= (BigInt)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 ); } /// Formats a VarSet as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } //@} }; } // 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.3.2/include/dai/factorgraph.h0000644000175000017500000004111312053377776017042 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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; } /// Returns the VarSet corresponding to a vector of variable indices VarSet inds2vars( const std::vector& inds ) const { VarSet vs; for( std::vector::const_iterator it = inds.begin(); it != inds.end(); it++ ) vs.insert( var(*it) ); return vs; } /// 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; } /// Return all the indices of variables that occur in a factor involving the \a i 'th variable, itself included SmallSet Deltai( size_t i ) const; /// Return all the indices of variables that occur in a factor involving the \a i 'th variable, itself excluded SmallSet deltai( size_t i ) const { return( Deltai( i ) / i ); } /// 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 ) const; //@} /// \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 ); /// Set all factors indexed by \a facInds to 1 /** If \a backup == \c true, make a backup of all factors that are changed */ virtual void makeRegionCavity( std::vector facInds, bool backup ); //@} /// \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; /// Formats a factor graph as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } /// Reads a factor graph from a string void fromString( const std::string& s ) { std::stringstream ss( s ); ss >> *this; } //@} 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.3.2/include/dai/smallset.h0000644000175000017500000002357412053366465016372 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 #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 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; } /// Formats a SmallSet as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } //@} }; } // end of namespace dai #endif libDAI-0.3.2/include/dai/enum.h0000644000175000017500000000776512451266046015512 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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;\ }\ }\ }\ \ operator wchar_t const*() const {\ static wchar_t labelstring[] = #val0 L"," #__VA_ARGS__;\ size_t pos_begin = 0;\ size_t i = 0;\ for( size_t pos_end = 0; ; pos_end++ )\ if( (labelstring[pos_end] == L',') || (labelstring[pos_end] == L'\0') ) {\ if( (size_t)v == i ) {\ labelstring[pos_end] = L'\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::wistream& operator >> (std::wistream& wis, x& y) {\ std::wstring s;\ wis >> s;\ y = x((const char *)s.c_str());\ return wis;\ }\ \ friend std::ostream& operator << (std::ostream& os, const x& y) {\ os << (const char *)y;\ return os;\ }\ \ friend std::wostream& operator << (std::wostream& wos, const x& y) {\ wos << (const wchar_t *)y;\ return wos;\ }\ \ protected:\ value v;\ }; #endif libDAI-0.3.2/include/dai/var.h0000644000175000017500000000772712053366045015332 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class Var, which represents a discrete random variable. #ifndef __defined_libdai_var_h #define __defined_libdai_var_h #include #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() ); } /// Formats a Var as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } }; } // end of namespace dai #endif libDAI-0.3.2/include/dai/matlab/0000755000175000017500000000000012025567350015615 5ustar jorismjorismlibDAI-0.3.2/include/dai/matlab/matlab.h0000644000175000017500000000160712025567350017232 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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.3.2/include/dai/factor.h0000644000175000017500000006307512053365012016007 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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() { _p = TProb( BigInt_size_t( _vs.nrStates() ) ); } /// Constructs factor depending on variables in \a vars with all values set to \a p TFactor( const VarSet& vars, T p ) : _vs(vars), _p() { _p = TProb( BigInt_size_t( _vs.nrStates() ), p ); } /// 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( (BigInt)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() { size_t N = BigInt_size_t( _vs.nrStates() ); _p = TProb( p, p + N, N ); } /// 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() == (BigInt)_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()) { BigInt 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); } /// Formats a factor as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } //@} /// \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; size_t N = BigInt_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; size_t N = BigInt_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.3.2/include/dai/exactinf.h0000644000175000017500000000717412053436221016331 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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; 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 ExactInf* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new ExactInf( fg, opts ); } virtual std::string name() const { return "EXACT"; } 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.3.2/include/dai/index.h0000644000175000017500000004164312042452776015651 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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) BigInt 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, BigInt 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] = BigInt_size_t( linearState % (BigInt)v->states() ); linearState /= (BigInt)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( BigInt_size_t( 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 { 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 BigInt operator() ( const VarSet &vs ) const { BigInt vs_state = 0; BigInt 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 += (BigInt)entry->second * prod; prod *= (BigInt)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.3.2/include/dai/io.h0000644000175000017500000000333111605337426015137 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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.3.2/include/dai/decmap.h0000644000175000017500000000633312233677464015775 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class DecMAP, which constructs a MAP state by decimation #ifndef __defined_libdai_decmap_h #define __defined_libdai_decmap_h #include #ifdef DAI_WITH_DECMAP #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; 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 DecMAP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new DecMAP( fg, opts ); } virtual std::string name() const { return "DECMAP"; } 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 #endif libDAI-0.3.2/include/dai/clustergraph.h0000644000175000017500000003416612053364513017240 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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; bforeach( 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; bforeach( 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 bforeach( const Neighbor& i, _G.nb2(I) ) { bforeach( 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; } /// Formats a ClusterGraph as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } //@} /// \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 BigInt totalStates = 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 > (BigInt)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.3.2/include/dai/prob.h0000644000175000017500000006357412053365210015477 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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(); } /// Formats a TProb as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } //@} /// \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.3.2/include/dai/dag.h0000644000175000017500000002763212237210741015265 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 (including \a n itself if \a inclusive == \c true) std::set ancestors( size_t n, bool inclusive ) 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 if \a inclusive == \c true) std::set descendants( size_t n, bool inclusive ) 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; bforeach( const Neighbor &n2, pa(n1) ) if( !x.hasEdge( n2, n1 ) ) return false; bforeach( const Neighbor &n2, x.pa(n1) ) if( !hasEdge( n2, n1 ) ) return false; } return true; } //@} /// \name Input and output //@{ /// Writes a DAG to an output stream in GraphViz .dot syntax void printDot( std::ostream& os ) const; /// Writes a DAG to an output stream friend std::ostream& operator<<( std::ostream& os, const DAG& g ) { g.printDot( os ); return os; } /// Formats a DAG as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } //@} }; 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.3.2/include/dai/treeep.h0000644000175000017500000002034512233677012016014 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 #ifdef DAI_WITH_TREEEP #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; 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 TreeEP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new TreeEP( fg, opts ); } virtual std::string name() const { return "TREEEP"; } 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 #endif libDAI-0.3.2/include/dai/weightedgraph.h0000644000175000017500000002162012232725007017344 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /** \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; } /// Formats a directed edge as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } }; /// 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; } /// Formats an undirected edge as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } }; /// 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++ ) bforeach( 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.3.2/include/dai/lc.h0000644000175000017500000001347212233676731015140 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class LC, which implements loop corrections for approximate inference #ifndef __defined_libdai_lc_h #define __defined_libdai_lc_h #include #ifdef DAI_WITH_LC #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; 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 LC* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new LC( fg, opts ); } virtual std::string name() const { return "LC"; } 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 #endif libDAI-0.3.2/include/dai/cbp.h0000644000175000017500000002544212233706416015300 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class CBP, which implements Conditioned Belief Propagation #ifndef __defined_libdai_cbp_h #define __defined_libdai_cbp_h #include #ifdef DAI_WITH_CBP #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: /// Default constructor CBP() : DAIAlgFG(), _beliefsV(), _beliefsF(), _logZ(0.0), _iters(0), _maxdiff(0.0), _sum_level(0.0), _num_leaves(0), _clamp_ofstream() {} /// 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 General InfAlg interface //@{ virtual CBP* clone() const { return new CBP(*this); } virtual CBP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new CBP( fg, opts ); } virtual std::string name() const { return "CBP"; } 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 #endif libDAI-0.3.2/include/dai/bp_dual.h0000644000175000017500000001256612233677375016160 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 #ifdef DAI_WITH_CBP #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 #endif libDAI-0.3.2/include/dai/mf.h0000644000175000017500000001015512233676513015135 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class MF which implements the Mean Field algorithm #ifndef __defined_libdai_mf_h #define __defined_libdai_mf_h #include #ifdef DAI_WITH_MF #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; 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 MF* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new MF( fg, opts ); } virtual std::string name() const { return "MF"; } 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 #endif libDAI-0.3.2/include/dai/bipgraph.h0000644000175000017500000004025412053364540016324 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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; bforeach( const Neighbor &n2, nb1(n1) ) if( !x.hasEdge( n1, n2 ) ) return false; bforeach( 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 a BipartiteGraph to an output stream in GraphViz .dot syntax void printDot( std::ostream& os ) const; /// Writes a BipartiteGraph to an output stream friend std::ostream& operator<<( std::ostream& os, const BipartiteGraph& g ) { g.printDot( os ); return os; } /// Formats a BipartiteGraph as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } //@} }; 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.3.2/include/dai/regiongraph.h0000644000175000017500000002717312053365346017047 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 region 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 region graph to an output stream friend std::ostream& operator<< ( std::ostream& os, const RegionGraph& rg ); /// Formats a region graph as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } /// 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.3.2/include/dai/daialg.h0000644000175000017500000003325512053436205015752 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 #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; /// Returns a pointer to a newly constructed inference algorithm /** \param fg Factor graph on which to perform the inference algorithm; * \param opts Parameters passed to constructor of inference algorithm; */ virtual InfAlg* construct( const FactorGraph &fg, const PropertySet &opts ) const = 0; //@} /// \name Queries //@{ /// Returns the name of the algorithm virtual std::string name() const = 0; /// Identifies itself for logging purposes virtual std::string identify() const { return name() + printProperties(); } /// 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; /// Sets all factors indicated by \a facInds to one. /** If \a backup == \c true, make a backup of all factors that are changed. */ virtual void makeRegionCavity( std::vector facInds, 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 ); } /// Sets all factors indicated by \a facInds to one. /** If \a backup == \c true, make a backup of all factors that are changed. */ void makeRegionCavity( std::vector facInds, bool backup ){ GRM::makeRegionCavity( facInds, 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 ); } /// Restore all factors from their backup copies void restoreFactors() { GRM::restoreFactors(); } //@} }; /// 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; /// Base class for GLC that operates on CobwebGraph typedef DAIAlg DAIAlgCG; /// 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.3.2/include/dai/graph.h0000644000175000017500000003325512053365105015632 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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; * bforeach( 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; bforeach( const Neighbor &n2, nb(n1) ) if( !x.hasEdge( n1, n2 ) ) return false; bforeach( const Neighbor &n2, x.nb(n1) ) if( !hasEdge( n1, n2 ) ) return false; } return true; } //@} /// \name Input and output //@{ /// Writes a GraphAL to an output stream in GraphViz .dot syntax void printDot( std::ostream& os ) const; /// Writes a GraphAL to an output stream friend std::ostream& operator<<( std::ostream& os, const GraphAL& g ) { g.printDot( os ); return os; } /// Formats a GraphAL as a string std::string toString() const { std::stringstream ss; ss << *this; return ss.str(); } //@} }; 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.3.2/include/dai/bp.h0000644000175000017500000003052712233676462015144 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 #ifdef DAI_WITH_BP #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; /// 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 BP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new BP( fg, opts ); } virtual std::string name() const { return "BP"; } 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 #endif libDAI-0.3.2/include/dai/util.h0000644000175000017500000002005412053436252015501 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 #if defined(WINDOWS) #include // only defined in C++11 and higher, but needed for Win64 builds in order to enable conditional code in MPIR library #endif #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::bforeach library #define bforeach 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()) /// Define NAN #define NAN (std::numeric_limits::quiet_NaN()) #if defined(_MSC_VER) // Disable unsafe warning (use of the function 'strcpy' instead of // 'strcpy_s' for portability reasons; #pragma warning( disable : 4996 ) // Workaround for the char16_t type defined in Matlab and MSVC 2010 #if (_MSC_VER >= 1600) #define __STDC_UTF_16__ #endif #endif #endif namespace dai { /// Real number (alias for \c double, which could be changed to long double if necessary) typedef double Real; /// Arbitrary precision integer number typedef mpz_class BigInt; /// Safe down-cast of big integer to size_t inline size_t BigInt_size_t( const BigInt &N ) { DAI_ASSERT( N <= (BigInt)std::numeric_limits::max() ); return N.get_ui(); } /// 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 x to the power \a y /** We use the convention that division by zero yields zero; * for powers, this means that if \a x == 0.0 and \a y < 0.0, we * return 0.0 instead of generating an error. */ inline Real pow( Real x, Real y ) { errno = 0; if( x == 0.0 && y < 0.0 ) return 0.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.3.2/include/dai/dai_config.h0000644000175000017500000000126612234433075016613 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Allows the user to specify which algorithms will be built into libDAI #ifndef __defined_libdai_config_h #define __defined_libdai_config_h #define DAI_WITH_BP #define DAI_WITH_FBP #define DAI_WITH_TRWBP #define DAI_WITH_MF #define DAI_WITH_HAK #define DAI_WITH_LC #define DAI_WITH_TREEEP #define DAI_WITH_JTREE #define DAI_WITH_MR #define DAI_WITH_GIBBS #define DAI_WITH_CBP #define DAI_WITH_DECMAP #define DAI_WITH_GLC #endif libDAI-0.3.2/include/dai/fbp.h0000644000175000017500000001130012233676441015273 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \file /// \brief Defines class FBP, which implements Fractional Belief Propagation #ifndef __defined_libdai_fbp_h #define __defined_libdai_fbp_h #include #ifdef DAI_WITH_FBP #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 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 FBP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new FBP( fg, opts ); } virtual std::string name() const { return "FBP"; } 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 #endif libDAI-0.3.2/include/dai/exceptions.h0000644000175000017500000001366312042452776016724 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ /// \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 */ #if defined __GNUG__ // GNU C++ #define FUNCTION_NAME __PRETTY_FUNCTION__ #elif defined _MSC_VER // Visual Studio #define FUNCTION_NAME __FUNCTION__ #else // other compilers #define FUNCTION_NAME __func__ #endif #define DAI_THROW(cod) throw dai::Exception(dai::Exception::cod, __FILE__, FUNCTION_NAME, 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, __FILE__, FUNCTION_NAME, 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 char *filename, const char *function, const char *line, const std::string& detailedMsg ) : std::runtime_error(ErrorStrings[code] + (detailedMsg.empty() ? "" : (": " + detailedMsg)) + " [File " + filename + ", line " + line + ", function: " + function + "]"), _errorcode(code), _detailedMsg(detailedMsg), _filename(filename), _function(function), _line(line) {} /// Destructor ~Exception() throw () {} /// Returns error code of this exception Code getCode() const { return _errorcode; } /// Returns error code of this exception /** \deprecated Please use dai::Exceptions::getCode() instead */ Code code() const { return getCode(); } /// Returns short error message of this exception const std::string& getMsg() const { return ErrorStrings[_errorcode]; } /// Returns detailed error message of this exception const std::string& getDetailedMsg() const { return _detailedMsg; } /// Returns filename where this exception was thrown const std::string& getFilename() const { return _filename; } /// Returns function name in which this exception was thrown const std::string& getFunction() const { return _function; } /// Returns line number where this exception was thrown const std::string& getLine() const { return _line; } /// 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; /// Contains the detailed message of this exception, if any std::string _detailedMsg; /// Contains the filename where this exception was thrown std::string _filename; /// Contains the function name in which this exception was thrown std::string _function; /// Contains the line number where this exception was thrown std::string _line; /// Error messages corresponding to the exceptions enumerated above static std::string ErrorStrings[NUM_ERRORS]; }; } #endif libDAI-0.3.2/include/dai/emalg.h0000644000175000017500000004513012327726520015617 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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 provided expectations. virtual Prob estimate(const Prob &p) { return parametersToFactor(parameters(p)); } /// Convert a set of estimated parameters to a factor virtual Prob parametersToFactor(const Prob ¶ms) = 0; /// Return parameters for the estimated factor, in a format specific to the parameter estimation virtual Prob parameters(const Prob &p) = 0; /// Returns the size of the Prob that should be passed to estimate and parameters virtual size_t probSize() const = 0; // Returns the name of the class of this parameter estimation virtual const std::string& name() const = 0; virtual const PropertySet& properties() 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; /// Initial pseudocounts Prob _initial_stats; static std::string _name; // = "CondProbEstimation"; /// PropertySet that allows reconstruction of this estimator PropertySet _props; 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 parameters(const Prob &p); // For a discrete conditional probability distribution, // the parameters are equivalent to the resulting factor virtual Prob parametersToFactor(const Prob &p); /// Returns the required size for arguments to estimate(). virtual size_t probSize() const { return _initial_stats.size(); } virtual const std::string& name() const { return _name; } virtual const PropertySet& properties() const { return _props; } }; /// 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; /// The accumulated expectations Prob* _expectations; /// 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), _expectations(NULL) { // If sp owns its _estimation object, we should clone it instead of copying the pointer if( _ownEstimation ) _estimation = _estimation->clone(); _expectations = new Prob(*sp._expectations); } /// Destructor ~SharedParameters() { // If we own the _estimation object, we should delete it now if( _ownEstimation ) delete _estimation; if( _expectations != NULL) delete _expectations; } /// Collect the 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. */ void collectExpectations( InfAlg &alg ); /// Return the current accumulated expectations const Prob& currentExpectations() const { return *_expectations; } ParameterEstimation& getPEst() const { return *_estimation; } /// Estimate and set the shared parameters /** Based on the expectation 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 ); /// Return a reference to the vector of factor orientations /** This is necessary for determing which variables were used * to estimate parameters, and analysis of expectations * after an Estimation step has been performed. */ const FactorOrientations& getFactorOrientations() const { return _varorders; } /// Reset the current expectations void clear( ) { _expectations->fill(0); } }; /// 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 ); /// Clear the step, to be called at the begining of each step void clear( ); /// \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.3.2/tests/0000755000175000017500000000000012552203115013326 5ustar jorismjorismlibDAI-0.3.2/tests/testbbp.cpp0000644000175000017500000000756612233721445015522 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #include using namespace dai; using namespace std; int main( int argc, char *argv[] ) { #ifdef DAI_WITH_CBP 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; // 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; #else cout << "libDAI is configured not to include CBP (this can be changed in include/dai/dai_config.h)." << endl; #endif } libDAI-0.3.2/tests/maxprodbug.fg0000644000175000017500000000013111363265652016024 0ustar jorismjorism3 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.3.2/tests/unit/0000755000175000017500000000000012552202330014303 5ustar jorismjorismlibDAI-0.3.2/tests/unit/regiongraph_test.cpp0000644000175000017500000012104712053446667020403 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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, "}" ); BOOST_CHECK_EQUAL( G.toString(), "digraph RegionGraph {\nnode[shape=box];\n\ta0 [label=\"a0: {x0, x1}, c=1\"];\n\ta1 [label=\"a1: {x1, x2}, c=1\"];\nnode[shape=ellipse];\n\tb0 [label=\"b0: {x1}, c=-1\"];\n\ta0 -> b0;\n\ta1 -> b0;\n}\n" ); } libDAI-0.3.2/tests/unit/util_test.cpp0000644000175000017500000001611111605337426017040 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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[0], "" ); BOOST_CHECK_EQUAL( tokens.size(), 1 ); s = " "; tokens = tokenizeString( s, true, " \t" ); BOOST_CHECK_EQUAL( tokens.size(), 2 ); BOOST_CHECK_EQUAL( tokens[0], "" ); BOOST_CHECK_EQUAL( tokens[1], "" ); s = " \t"; 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], "" ); 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(), 8 ); 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], "!" ); BOOST_CHECK_EQUAL( tokens[7], "" ); 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.3.2/tests/unit/weightedgraph_test.cpp0000644000175000017500000001272412233716337020713 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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_CHECK_EQUAL( c.toString(), s ); } 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}" ); BOOST_CHECK_EQUAL( c.toString(), s ); ss << b; ss >> s; BOOST_CHECK_EQUAL( s, "{3--5}" ); BOOST_CHECK_EQUAL( b.toString(), s ); } 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 ); // disabled because of bug in boost graph library 1.54 // BOOST_CHECK_EQUAL( T, TMin ); T = MinSpanningTree( G, false ); BOOST_CHECK_EQUAL( T, TMin ); // T = MaxSpanningTree( G, true ); // disabled because of bug in boost graph library 1.54 // 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.3.2/tests/unit/bipgraph_test.cpp0000644000175000017500000003653112053444301017654 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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, "}" ); BOOST_CHECK_EQUAL( G.toString(), "graph BipartiteGraph {\nnode[shape=circle,width=0.4,fixedsize=true];\n\tx0;\n\tx1;\nnode[shape=box,width=0.3,height=0.3,fixedsize=true];\n\ty0;\n\ty1;\n\ty2;\n\tx0 -- y0;\n\tx0 -- y1;\n\tx1 -- y1;\n\tx1 -- y2;\n}\n" ); } libDAI-0.3.2/tests/unit/prob_test.cpp0000644000175000017500000007211012053446147017025 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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_SMALL( x.sum(), tol ); BOOST_CHECK_SMALL( x.accumulateSum( 0.0, fo_id() ), 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( dist( x, x, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( y, y, DISTL1 ), 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_SMALL( dist( x, x, DISTLINF ), tol ); BOOST_CHECK_SMALL( dist( y, y, DISTLINF ), 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_SMALL( dist( x, x, DISTTV ), tol ); BOOST_CHECK_SMALL( dist( y, y, DISTTV ), 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_SMALL( dist( x, x, DISTKL ), tol ); BOOST_CHECK_SMALL( dist( x, x, DISTKL ), 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_SMALL( dist( x, x, DISTHEL ), tol ); BOOST_CHECK_SMALL( dist( y, y, DISTHEL ), 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, "(size:4, def:0.25, 0:0.2, 1:0.7, 2:0.1)" ); #else BOOST_CHECK_EQUAL( s, "(0.2, 0.7, 0.1, 0.25)" ); #endif BOOST_CHECK_EQUAL( xx.toString(), s ); std::stringstream ss2; ss2 << yy; std::getline( ss2, s ); #ifdef DAI_SPARSE BOOST_CHECK_EQUAL( s, "(size:4, def:0.25, 0:0.1, 1:0.5, 2:0.4)" ); #else BOOST_CHECK_EQUAL( s, "(0.1, 0.5, 0.4, 0.25)" ); #endif BOOST_CHECK_EQUAL( yy.toString(), s ); 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.3.2/tests/unit/dag_test.cpp0000644000175000017500000003616112245370304016616 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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; std::set ss; G.addNode(); G.addEdge( 3, 4 ); G.addNode(); G.addEdge( 1, 4 ); G.addEdge( 1, 5 ); BOOST_CHECK( G.descendants( 4, false ) == s ); ss = s; ss.insert( 4 ); BOOST_CHECK( G.descendants( 4, true ) == ss ); BOOST_CHECK( G.descendants( 5, false ) == s ); ss = s; ss.insert( 5 ); BOOST_CHECK( G.descendants( 5, true ) == ss ); s.insert( 4 ); BOOST_CHECK( G.descendants( 3, false ) == s ); ss = s; ss.insert( 3 ); BOOST_CHECK( G.descendants( 3, true ) == ss ); s.insert( 5 ); BOOST_CHECK( G.descendants( 1, false ) == s ); ss = s; ss.insert( 1 ); BOOST_CHECK( G.descendants( 1, true ) == ss ); s.erase( 5 ); s.insert( 3 ); BOOST_CHECK( G.descendants( 2, false ) == s ); ss = s; ss.insert( 2 ); BOOST_CHECK( G.descendants( 2, true ) == ss ); s.insert( 1 ); s.insert( 5 ); BOOST_CHECK( G.descendants( 0, false ) == s ); ss = s; ss.insert( 0 ); BOOST_CHECK( G.descendants( 0, true ) == ss ); s.clear(); BOOST_CHECK( G.ancestors( 0, false ) == s ); ss = s; ss.insert( 0 ); BOOST_CHECK( G.ancestors( 0, true ) == ss ); BOOST_CHECK( G.ancestors( 2, false ) == s ); ss = s; ss.insert( 2 ); BOOST_CHECK( G.ancestors( 2, true ) == ss ); s.insert( 0 ); BOOST_CHECK( G.ancestors( 1, false ) == s ); ss = s; ss.insert( 1 ); BOOST_CHECK( G.ancestors( 1, true ) == ss ); s.insert( 2 ); BOOST_CHECK( G.ancestors( 3, false ) == s ); ss = s; ss.insert( 3 ); BOOST_CHECK( G.ancestors( 3, true ) == ss ); s.erase( 2 ); s.insert( 1 ); BOOST_CHECK( G.ancestors( 5, false ) == s ); ss = s; ss.insert( 5 ); BOOST_CHECK( G.ancestors( 5, true ) == ss ); s.insert( 2 ); s.insert( 3 ); BOOST_CHECK( G.ancestors( 4, false ) == s ); ss = s; ss.insert( 4 ); BOOST_CHECK( G.ancestors( 4, true ) == ss ); } 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, "}" ); BOOST_CHECK_EQUAL( G.toString(), "digraph DAG {\nnode[shape=circle,width=0.4,fixedsize=true];\n\tx0;\n\tx1;\n\tx2;\n\tx3;\n\tx0 -> x1;\n\tx0 -> x2;\n\tx1 -> x3;\n\tx2 -> x3;\n}\n" ); } libDAI-0.3.2/tests/unit/clustergraph_test.cpp0000644000175000017500000004312212053444353020564 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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})" ); BOOST_CHECK_EQUAL( G.toString(), "({x0, x1}, {x1, x2}, {x2, x3}, {x1, x3})" ); } libDAI-0.3.2/tests/unit/properties_test.cpp0000644000175000017500000002224412053446121020252 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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]") ); BOOST_CHECK_EQUAL( z.toString(), s ); 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") ); y.fromString( z.toString() ); 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.3.2/tests/unit/varset_test.cpp0000644000175000017500000007757112053447005017401 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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_CHECK_EQUAL( x.toString(), s ); } 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.3.2/tests/unit/smallset_test.cpp0000644000175000017500000010367112053446704017715 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #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) ); } BOOST_AUTO_TEST_CASE( IOTest ) { SmallSet u( 0, 5 ); u |= 1; std::stringstream ss; std::string s; ss << u; std::getline( ss, s ); BOOST_CHECK_EQUAL( s, "{0, 1, 5}" ); BOOST_CHECK_EQUAL( u.toString(), "{0, 1, 5}" ); } libDAI-0.3.2/tests/unit/var_test.cpp0000644000175000017500000000302512053446757016661 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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" ); BOOST_CHECK_EQUAL( x.toString(), s ); } libDAI-0.3.2/tests/unit/factorgraph_test.cpp0000644000175000017500000007371012053445451020367 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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" ); BOOST_CHECK_EQUAL( G.toString(), "3\n\n2\n0 1 \n2 2 \n4\n0 1\n1 1\n2 1\n3 1\n\n2\n1 2 \n2 2 \n4\n0 2\n1 2\n2 2\n3 2\n\n1\n1 \n2 \n2\n0 3\n1 3\n" ); 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 ); } FactorGraph G4; G4.fromString( G.toString() ); BOOST_CHECK( G.vars() == G4.vars() ); BOOST_CHECK( G.bipGraph() == G4.bipGraph() ); BOOST_CHECK_EQUAL( G.nrFactors(), G4.nrFactors() ); for( size_t I = 0; I < G.nrFactors(); I++ ) { BOOST_CHECK( G.factor(I).vars() == G4.factor(I).vars() ); for( size_t s = 0; s < G.factor(I).nrStates(); s++ ) BOOST_CHECK_CLOSE( G.factor(I)[s], G4.factor(I)[s], tol ); } } libDAI-0.3.2/tests/unit/graph_test.cpp0000644000175000017500000004424712053445433017173 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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++ ) { bforeach( 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++ ) { bforeach( 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++ ) { bforeach( 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++ ) { bforeach( 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++ ) { bforeach( 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++ ) { bforeach( 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++ ) { bforeach( 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 ); bforeach( 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, "}" ); BOOST_CHECK_EQUAL( G.toString(), "graph GraphAL {\nnode[shape=circle,width=0.4,fixedsize=true];\n\tx0;\n\tx1;\n\tx2;\n\tx3;\n\tx0 -- x1;\n\tx0 -- x2;\n\tx1 -- x3;\n\tx2 -- x3;\n}\n" ); } libDAI-0.3.2/tests/unit/daialg_test.cpp0000644000175000017500000001165011605337426017307 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/tests/unit/factor_test.cpp0000644000175000017500000010117512053445466017350 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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_SMALL( x.sum(), 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_SMALL( y[1], tol ); BOOST_CHECK_CLOSE( y[2], (Real)-2.0, tol ); y = x.abs(); BOOST_CHECK_CLOSE( y[0], (Real)2.0, tol ); BOOST_CHECK_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( y[1], 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_SMALL( dist( x, x, DISTL1 ), tol ); BOOST_CHECK_SMALL( dist( y, y, DISTL1 ), 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_SMALL( dist( x, x, DISTLINF ), tol ); BOOST_CHECK_SMALL( dist( y, y, DISTLINF ), 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_SMALL( dist( x, x, DISTTV ), tol ); BOOST_CHECK_SMALL( dist( y, y, DISTTV ), 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_SMALL( dist( x, x, DISTKL ), tol ); BOOST_CHECK_SMALL( dist( y, y, DISTKL ), tol ); BOOST_CHECK_EQUAL( dist( x, y, DISTKL ), INFINITY ); BOOST_CHECK_EQUAL( dist( y, x, DISTKL ), INFINITY ); BOOST_CHECK_SMALL( dist( x, x, DISTHEL ), tol ); BOOST_CHECK_SMALL( dist( y, y, DISTHEL ), 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))") ); BOOST_CHECK_EQUAL( x.toString(), "({x0}, (0.2, 0.7, 0.1))" ); BOOST_CHECK_EQUAL( y.toString(), "({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.3.2/tests/unit/exceptions_test.cpp0000644000175000017500000000506511613512537020247 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.getCode(), Exception::NOT_IMPLEMENTED ); BOOST_CHECK_EQUAL( e.getMsg(), std::string("Feature not implemented") ); BOOST_CHECK_EQUAL( e.getDetailedMsg(), std::string("") ); BOOST_CHECK_EQUAL( e.getFilename(), std::string("tests/unit/exceptions_test.cpp") ); BOOST_CHECK_EQUAL( e.getFunction(), std::string("void ExceptionsTest::test_method()") ); BOOST_CHECK_EQUAL( e.getLine(), std::string("31") ); } try { DAI_THROWE(NOT_IMPLEMENTED,"Detailed error message"); } catch( Exception& e ) { BOOST_CHECK_EQUAL( e.getCode(), Exception::NOT_IMPLEMENTED ); BOOST_CHECK_EQUAL( e.getMsg(), std::string("Feature not implemented") ); BOOST_CHECK_EQUAL( e.getDetailedMsg(), std::string("Detailed error message") ); BOOST_CHECK_EQUAL( e.getFilename(), std::string("tests/unit/exceptions_test.cpp") ); BOOST_CHECK_EQUAL( e.getFunction(), std::string("void ExceptionsTest::test_method()") ); BOOST_CHECK_EQUAL( e.getLine(), std::string("42") ); } try { DAI_THROW(NOT_IMPLEMENTED); } catch( std::runtime_error& e ) { BOOST_CHECK_EQUAL( e.what(), std::string("Feature not implemented [File tests/unit/exceptions_test.cpp, line 53, function: void ExceptionsTest::test_method()]") ); } try { DAI_THROWE(NOT_IMPLEMENTED,"Detailed error message"); } catch( std::runtime_error& e ) { BOOST_CHECK_EQUAL( e.what(), std::string("Feature not implemented: Detailed error message [File tests/unit/exceptions_test.cpp, line 59, function: void ExceptionsTest::test_method()]") ); } } libDAI-0.3.2/tests/unit/alldai_test.cpp0000644000175000017500000001132011605337426017306 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/tests/unit/index_test.cpp0000644000175000017500000002774511605616404017205 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/tests/unit/enum_test.cpp0000644000175000017500000000425411605337426017034 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/tests/zeroes1.fg0000644000175000017500000000025111235602301015227 0ustar jorismjorism# 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.3.2/tests/testall0000755000175000017500000000445312451267635014751 0ustar jorismjorism#!/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 GLC_UNICAV_SINGLE GLC_PAIRCAV_SINGLE GLC_PAIR2CAV_SINGLE GLC_FULLCAV_SINGLE GLC+_UNICAV_FACTOR GLC+_FULLCAV_FACTOR GLC+_UNICAV_LOOP3 GLC+_FULLCAV_LOOP3 GLC_UNICAV_LOOP4 GLC_FULLCAV_LOOP4 GLC+_UNICAV_LOOP4 GLC+_UNICAV_LOOP5 # GBP_DELTA, GBP_LOOP4, GBP_LOOP5, GBP_LOOP6, GBP_LOOP7, GLC+_FULLCAV_LOOP4, GLC+_FULLCAV_LOOP5 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.3.2/tests/twofactors.fg0000644000175000017500000000020711605021575016044 0ustar jorismjorism2 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.3.2/tests/jtreemapbug.fg0000644000175000017500000000003711605021575016157 0ustar jorismjorism1 2 0 1 2 2 4 0 1 1 2 2 2 3 1 libDAI-0.3.2/tests/maxprodbug2.fg0000644000175000017500000023405211605021575016112 0ustar jorismjorism25 2 2 4 33 39 1287 561 0.025641 231 0.025641 264 0.025641 297 0.025641 462 0.025641 363 0.025641 396 0.025641 429 0.025641 1023 0.025641 957 0.025641 990 0.025641 858 0.025641 1056 0.025641 1122 0.025641 1155 0.025641 1221 0.025641 1254 0.025641 1089 0.025641 660 0.025641 66 0.025641 132 0.025641 330 0.025641 0 0.025641 99 0.025641 495 0.025641 528 0.025641 198 0.025641 594 0.025641 627 0.025641 693 0.025641 726 0.025641 759 0.025641 792 0.025641 825 0.025641 165 0.025641 891 0.025641 924 0.025641 33 0.025641 1188 0.025641 562 0.025641 232 0.025641 265 0.025641 298 0.025641 463 0.025641 364 0.025641 397 0.025641 430 0.025641 1024 0.025641 958 0.025641 991 0.025641 859 0.025641 1057 0.025641 1123 0.025641 1156 0.025641 1222 0.025641 1255 0.025641 1090 0.025641 661 0.025641 67 0.025641 133 0.025641 331 0.025641 1 0.025641 100 0.025641 496 0.025641 529 0.025641 199 0.025641 595 0.025641 628 0.025641 694 0.025641 727 0.025641 760 0.025641 793 0.025641 826 0.025641 166 0.025641 892 0.025641 925 0.025641 34 0.025641 1189 0.025641 563 0.025641 233 0.025641 266 0.025641 299 0.025641 464 0.025641 365 0.025641 398 0.025641 431 0.025641 1025 0.025641 959 0.025641 992 0.025641 860 0.025641 1058 0.025641 1124 0.025641 1157 0.025641 1223 0.025641 1256 0.025641 1091 0.025641 662 0.025641 68 0.025641 134 0.025641 332 0.025641 2 0.025641 101 0.025641 497 0.025641 530 0.025641 200 0.025641 596 0.025641 629 0.025641 695 0.025641 728 0.025641 761 0.025641 794 0.025641 827 0.025641 167 0.025641 893 0.025641 926 0.025641 35 0.025641 1190 0.025641 564 0.025641 234 0.025641 267 0.025641 300 0.025641 465 0.025641 366 0.025641 399 0.025641 432 0.025641 1026 0.025641 960 0.025641 993 0.025641 861 0.025641 1059 0.025641 1125 0.025641 1158 0.025641 1224 0.025641 1257 0.025641 1092 0.025641 663 0.025641 69 0.025641 135 0.025641 333 0.025641 3 0.025641 102 0.025641 498 0.025641 531 0.025641 201 0.025641 597 0.025641 630 0.025641 696 0.025641 729 0.025641 762 0.025641 795 0.025641 828 0.025641 168 0.025641 894 0.025641 927 0.025641 36 0.025641 1191 0.025641 565 0.025641 235 0.025641 268 0.025641 301 0.025641 466 0.025641 367 0.025641 400 0.025641 433 0.025641 1027 0.025641 961 0.025641 994 0.025641 862 0.025641 1060 0.025641 1126 0.025641 1159 0.025641 1225 0.025641 1258 0.025641 1093 0.025641 664 0.025641 70 0.025641 136 0.025641 334 0.025641 4 0.025641 103 0.025641 499 0.025641 532 0.025641 202 0.025641 598 0.025641 631 0.025641 697 0.025641 730 0.025641 763 0.025641 796 0.025641 829 0.025641 169 0.025641 895 0.025641 928 0.025641 37 0.025641 1192 0.025641 566 0.025641 236 0.025641 269 0.025641 302 0.025641 467 0.025641 368 0.025641 401 0.025641 434 0.025641 1028 0.025641 962 0.025641 995 0.025641 863 0.025641 1061 0.025641 1127 0.025641 1160 0.025641 1226 0.025641 1259 0.025641 1094 0.025641 665 0.025641 71 0.025641 137 0.025641 335 0.025641 5 0.025641 104 0.025641 500 0.025641 533 0.025641 203 0.025641 599 0.025641 632 0.025641 698 0.025641 731 0.025641 764 0.025641 797 0.025641 830 0.025641 170 0.025641 896 0.025641 929 0.025641 38 0.025641 1193 0.025641 567 0.025641 237 0.025641 270 0.025641 303 0.025641 468 0.025641 369 0.025641 402 0.025641 435 0.025641 1029 0.025641 963 0.025641 996 0.025641 864 0.025641 1062 0.025641 1128 0.025641 1161 0.025641 1227 0.025641 1260 0.025641 1095 0.025641 666 0.025641 72 0.025641 138 0.025641 336 0.025641 6 0.025641 105 0.025641 501 0.025641 534 0.025641 204 0.025641 600 0.025641 633 0.025641 699 0.025641 732 0.025641 765 0.025641 798 0.025641 831 0.025641 171 0.025641 897 0.025641 930 0.025641 39 0.025641 1194 0.025641 568 0.025641 238 0.025641 271 0.025641 304 0.025641 469 0.025641 370 0.025641 403 0.025641 436 0.025641 1030 0.025641 964 0.025641 997 0.025641 865 0.025641 1063 0.025641 1129 0.025641 1162 0.025641 1228 0.025641 1261 0.025641 1096 0.025641 667 0.025641 73 0.025641 139 0.025641 337 0.025641 7 0.025641 106 0.025641 502 0.025641 535 0.025641 205 0.025641 601 0.025641 634 0.025641 700 0.025641 733 0.025641 766 0.025641 799 0.025641 832 0.025641 172 0.025641 898 0.025641 931 0.025641 40 0.025641 1195 0.025641 569 0.025641 239 0.025641 272 0.025641 305 0.025641 470 0.025641 371 0.025641 404 0.025641 437 0.025641 1031 0.025641 965 0.025641 998 0.025641 866 0.025641 1064 0.025641 1130 0.025641 1163 0.025641 1229 0.025641 1262 0.025641 1097 0.025641 668 0.025641 74 0.025641 140 0.025641 338 0.025641 8 0.025641 107 0.025641 503 0.025641 536 0.025641 206 0.025641 602 0.025641 635 0.025641 701 0.025641 734 0.025641 767 0.025641 800 0.025641 833 0.025641 173 0.025641 899 0.025641 932 0.025641 41 0.025641 1196 0.025641 570 0.025641 240 0.025641 273 0.025641 306 0.025641 471 0.025641 372 0.025641 405 0.025641 438 0.025641 1032 0.025641 966 0.025641 999 0.025641 867 0.025641 1065 0.025641 1131 0.025641 1164 0.025641 1230 0.025641 1263 0.025641 1098 0.025641 669 0.025641 75 0.025641 141 0.025641 339 0.025641 9 0.025641 108 0.025641 504 0.025641 537 0.025641 207 0.025641 603 0.025641 636 0.025641 702 0.025641 735 0.025641 768 0.025641 801 0.025641 834 0.025641 174 0.025641 900 0.025641 933 0.025641 42 0.025641 1197 0.025641 571 0.025641 241 0.025641 274 0.025641 307 0.025641 472 0.025641 373 0.025641 406 0.025641 439 0.025641 1033 0.025641 967 0.025641 1000 0.025641 868 0.025641 1066 0.025641 1132 0.025641 1165 0.025641 1231 0.025641 1264 0.025641 1099 0.025641 670 0.025641 76 0.025641 142 0.025641 340 0.025641 10 0.025641 109 0.025641 505 0.025641 538 0.025641 208 0.025641 604 0.025641 637 0.025641 703 0.025641 736 0.025641 769 0.025641 802 0.025641 835 0.025641 175 0.025641 901 0.025641 934 0.025641 43 0.025641 1198 0.025641 572 0.025641 242 0.025641 275 0.025641 308 0.025641 473 0.025641 374 0.025641 407 0.025641 440 0.025641 1034 0.025641 968 0.025641 1001 0.025641 869 0.025641 1067 0.025641 1133 0.025641 1166 0.025641 1232 0.025641 1265 0.025641 1100 0.025641 671 0.025641 77 0.025641 143 0.025641 341 0.025641 11 0.025641 110 0.025641 506 0.025641 539 0.025641 209 0.025641 605 0.025641 638 0.025641 704 0.025641 737 0.025641 770 0.025641 803 0.025641 836 0.025641 176 0.025641 902 0.025641 935 0.025641 44 0.025641 1199 0.025641 573 0.025641 243 0.025641 276 0.025641 309 0.025641 474 0.025641 375 0.025641 408 0.025641 441 0.025641 1035 0.025641 969 0.025641 1002 0.025641 870 0.025641 1068 0.025641 1134 0.025641 1167 0.025641 1233 0.025641 1266 0.025641 1101 0.025641 672 0.025641 78 0.025641 144 0.025641 342 0.025641 12 0.025641 111 0.025641 507 0.025641 540 0.025641 210 0.025641 606 0.025641 639 0.025641 705 0.025641 738 0.025641 771 0.025641 804 0.025641 837 0.025641 177 0.025641 903 0.025641 936 0.025641 45 0.025641 1200 0.025641 574 0.025641 244 0.025641 277 0.025641 310 0.025641 475 0.025641 376 0.025641 409 0.025641 442 0.025641 1036 0.025641 970 0.025641 1003 0.025641 871 0.025641 1069 0.025641 1135 0.025641 1168 0.025641 1234 0.025641 1267 0.025641 1102 0.025641 673 0.025641 79 0.025641 145 0.025641 343 0.025641 13 0.025641 112 0.025641 508 0.025641 541 0.025641 211 0.025641 607 0.025641 640 0.025641 706 0.025641 739 0.025641 772 0.025641 805 0.025641 838 0.025641 178 0.025641 904 0.025641 937 0.025641 46 0.025641 1201 0.025641 575 0.025641 245 0.025641 278 0.025641 311 0.025641 476 0.025641 377 0.025641 410 0.025641 443 0.025641 1037 0.025641 971 0.025641 1004 0.025641 872 0.025641 1070 0.025641 1136 0.025641 1169 0.025641 1235 0.025641 1268 0.025641 1103 0.025641 674 0.025641 80 0.025641 146 0.025641 344 0.025641 14 0.025641 113 0.025641 509 0.025641 542 0.025641 212 0.025641 608 0.025641 641 0.025641 707 0.025641 740 0.025641 773 0.025641 806 0.025641 839 0.025641 179 0.025641 905 0.025641 938 0.025641 47 0.025641 1202 0.025641 576 0.025641 246 0.025641 279 0.025641 312 0.025641 477 0.025641 378 0.025641 411 0.025641 444 0.025641 1038 0.025641 972 0.025641 1005 0.025641 873 0.025641 1071 0.025641 1137 0.025641 1170 0.025641 1236 0.025641 1269 0.025641 1104 0.025641 675 0.025641 81 0.025641 147 0.025641 345 0.025641 15 0.025641 114 0.025641 510 0.025641 543 0.025641 213 0.025641 609 0.025641 642 0.025641 708 0.025641 741 0.025641 774 0.025641 807 0.025641 840 0.025641 180 0.025641 906 0.025641 939 0.025641 48 0.025641 1203 0.025641 577 0.025641 247 0.025641 280 0.025641 313 0.025641 478 0.025641 379 0.025641 412 0.025641 445 0.025641 1039 0.025641 973 0.025641 1006 0.025641 874 0.025641 1072 0.025641 1138 0.025641 1171 0.025641 1237 0.025641 1270 0.025641 1105 0.025641 676 0.025641 82 0.025641 148 0.025641 346 0.025641 16 0.025641 115 0.025641 511 0.025641 544 0.025641 214 0.025641 610 0.025641 643 0.025641 709 0.025641 742 0.025641 775 0.025641 808 0.025641 841 0.025641 181 0.025641 907 0.025641 940 0.025641 49 0.025641 1204 0.025641 578 0.025641 248 0.025641 281 0.025641 314 0.025641 479 0.025641 380 0.025641 413 0.025641 446 0.025641 1040 0.025641 974 0.025641 1007 0.025641 875 0.025641 1073 0.025641 1139 0.025641 1172 0.025641 1238 0.025641 1271 0.025641 1106 0.025641 677 0.025641 83 0.025641 149 0.025641 347 0.025641 17 0.025641 116 0.025641 512 0.025641 545 0.025641 215 0.025641 611 0.025641 644 0.025641 710 0.025641 743 0.025641 776 0.025641 809 0.025641 842 0.025641 182 0.025641 908 0.025641 941 0.025641 50 0.025641 1205 0.025641 579 0.025641 249 0.025641 282 0.025641 315 0.025641 480 0.025641 381 0.025641 414 0.025641 447 0.025641 1041 0.025641 975 0.025641 1008 0.025641 876 0.025641 1074 0.025641 1140 0.025641 1173 0.025641 1239 0.025641 1272 0.025641 1107 0.025641 678 0.025641 84 0.025641 150 0.025641 348 0.025641 18 0.025641 117 0.025641 513 0.025641 546 0.025641 216 0.025641 612 0.025641 645 0.025641 711 0.025641 744 0.025641 777 0.025641 810 0.025641 843 0.025641 183 0.025641 909 0.025641 942 0.025641 51 0.025641 1206 0.025641 580 0.025641 250 0.025641 283 0.025641 316 0.025641 481 0.025641 382 0.025641 415 0.025641 448 0.025641 1042 0.025641 976 0.025641 1009 0.025641 877 0.025641 1075 0.025641 1141 0.025641 1174 0.025641 1240 0.025641 1273 0.025641 1108 0.025641 679 0.025641 85 0.025641 151 0.025641 349 0.025641 19 0.025641 118 0.025641 514 0.025641 547 0.025641 217 0.025641 613 0.025641 646 0.025641 712 0.025641 745 0.025641 778 0.025641 811 0.025641 844 0.025641 184 0.025641 910 0.025641 943 0.025641 52 0.025641 1207 0.025641 581 0.025641 251 0.025641 284 0.025641 317 0.025641 482 0.025641 383 0.025641 416 0.025641 449 0.025641 1043 0.025641 977 0.025641 1010 0.025641 878 0.025641 1076 0.025641 1142 0.025641 1175 0.025641 1241 0.025641 1274 0.025641 1109 0.025641 680 0.025641 86 0.025641 152 0.025641 350 0.025641 20 0.025641 119 0.025641 515 0.025641 548 0.025641 218 0.025641 614 0.025641 647 0.025641 713 0.025641 746 0.025641 779 0.025641 812 0.025641 845 0.025641 185 0.025641 911 0.025641 944 0.025641 53 0.025641 1208 0.025641 582 0.025641 252 0.025641 285 0.025641 318 0.025641 483 0.025641 384 0.025641 417 0.025641 450 0.025641 1044 0.025641 978 0.025641 1011 0.025641 879 0.025641 1077 0.025641 1143 0.025641 1176 0.025641 1242 0.025641 1275 0.025641 1110 0.025641 681 0.025641 87 0.025641 153 0.025641 351 0.025641 21 0.025641 120 0.025641 516 0.025641 549 0.025641 219 0.025641 615 0.025641 648 0.025641 714 0.025641 747 0.025641 780 0.025641 813 0.025641 846 0.025641 186 0.025641 912 0.025641 945 0.025641 54 0.025641 1209 0.025641 583 0.025641 253 0.025641 286 0.025641 319 0.025641 484 0.025641 385 0.025641 418 0.025641 451 0.025641 1045 0.025641 979 0.025641 1012 0.025641 880 0.025641 1078 0.025641 1144 0.025641 1177 0.025641 1243 0.025641 1276 0.025641 1111 0.025641 682 0.025641 88 0.025641 154 0.025641 352 0.025641 22 0.025641 121 0.025641 517 0.025641 550 0.025641 220 0.025641 616 0.025641 649 0.025641 715 0.025641 748 0.025641 781 0.025641 814 0.025641 847 0.025641 187 0.025641 913 0.025641 946 0.025641 55 0.025641 1210 0.025641 584 0.025641 254 0.025641 287 0.025641 320 0.025641 485 0.025641 386 0.025641 419 0.025641 452 0.025641 1046 0.025641 980 0.025641 1013 0.025641 881 0.025641 1079 0.025641 1145 0.025641 1178 0.025641 1244 0.025641 1277 0.025641 1112 0.025641 683 0.025641 89 0.025641 155 0.025641 353 0.025641 23 0.025641 122 0.025641 518 0.025641 551 0.025641 221 0.025641 617 0.025641 650 0.025641 716 0.025641 749 0.025641 782 0.025641 815 0.025641 848 0.025641 188 0.025641 914 0.025641 947 0.025641 56 0.025641 1211 0.025641 585 0.025641 255 0.025641 288 0.025641 321 0.025641 486 0.025641 387 0.025641 420 0.025641 453 0.025641 1047 0.025641 981 0.025641 1014 0.025641 882 0.025641 1080 0.025641 1146 0.025641 1179 0.025641 1245 0.025641 1278 0.025641 1113 0.025641 684 0.025641 90 0.025641 156 0.025641 354 0.025641 24 0.025641 123 0.025641 519 0.025641 552 0.025641 222 0.025641 618 0.025641 651 0.025641 717 0.025641 750 0.025641 783 0.025641 816 0.025641 849 0.025641 189 0.025641 915 0.025641 948 0.025641 57 0.025641 1212 0.025641 586 0.025641 256 0.025641 289 0.025641 322 0.025641 487 0.025641 388 0.025641 421 0.025641 454 0.025641 1048 0.025641 982 0.025641 1015 0.025641 883 0.025641 1081 0.025641 1147 0.025641 1180 0.025641 1246 0.025641 1279 0.025641 1114 0.025641 685 0.025641 91 0.025641 157 0.025641 355 0.025641 25 0.025641 124 0.025641 520 0.025641 553 0.025641 223 0.025641 619 0.025641 652 0.025641 718 0.025641 751 0.025641 784 0.025641 817 0.025641 850 0.025641 190 0.025641 916 0.025641 949 0.025641 58 0.025641 1213 0.025641 587 0.025641 257 0.025641 290 0.025641 323 0.025641 488 0.025641 389 0.025641 422 0.025641 455 0.025641 1049 0.025641 983 0.025641 1016 0.025641 884 0.025641 1082 0.025641 1148 0.025641 1181 0.025641 1247 0.025641 1280 0.025641 1115 0.025641 686 0.025641 92 0.025641 158 0.025641 356 0.025641 26 0.025641 125 0.025641 521 0.025641 554 0.025641 224 0.025641 620 0.025641 653 0.025641 719 0.025641 752 0.025641 785 0.025641 818 0.025641 851 0.025641 191 0.025641 917 0.025641 950 0.025641 59 0.025641 1214 0.025641 588 0.025641 258 0.025641 291 0.025641 324 0.025641 489 0.025641 390 0.025641 423 0.025641 456 0.025641 1050 0.025641 984 0.025641 1017 0.025641 885 0.025641 1083 0.025641 1149 0.025641 1182 0.025641 1248 0.025641 1281 0.025641 1116 0.025641 687 0.025641 93 0.025641 159 0.025641 357 0.025641 27 0.025641 126 0.025641 522 0.025641 555 0.025641 225 0.025641 621 0.025641 654 0.025641 720 0.025641 753 0.025641 786 0.025641 819 0.025641 852 0.025641 192 0.025641 918 0.025641 951 0.025641 60 0.025641 1215 0.025641 589 0.025641 259 0.025641 292 0.025641 325 0.025641 490 0.025641 391 0.025641 424 0.025641 457 0.025641 1051 0.025641 985 0.025641 1018 0.025641 886 0.025641 1084 0.025641 1150 0.025641 1183 0.025641 1249 0.025641 1282 0.025641 1117 0.025641 688 0.025641 94 0.025641 160 0.025641 358 0.025641 28 0.025641 127 0.025641 523 0.025641 556 0.025641 226 0.025641 622 0.025641 655 0.025641 721 0.025641 754 0.025641 787 0.025641 820 0.025641 853 0.025641 193 0.025641 919 0.025641 952 0.025641 61 0.025641 1216 0.025641 590 0.025641 260 0.025641 293 0.025641 326 0.025641 491 0.025641 392 0.025641 425 0.025641 458 0.025641 1052 0.025641 986 0.025641 1019 0.025641 887 0.025641 1085 0.025641 1151 0.025641 1184 0.025641 1250 0.025641 1283 0.025641 1118 0.025641 689 0.025641 95 0.025641 161 0.025641 359 0.025641 29 0.025641 128 0.025641 524 0.025641 557 0.025641 227 0.025641 623 0.025641 656 0.025641 722 0.025641 755 0.025641 788 0.025641 821 0.025641 854 0.025641 194 0.025641 920 0.025641 953 0.025641 62 0.025641 1217 0.025641 591 0.025641 261 0.025641 294 0.025641 327 0.025641 492 0.025641 393 0.025641 426 0.025641 459 0.025641 1053 0.025641 987 0.025641 1020 0.025641 888 0.025641 1086 0.025641 1152 0.025641 1185 0.025641 1251 0.025641 1284 0.025641 1119 0.025641 690 0.025641 96 0.025641 162 0.025641 360 0.025641 30 0.025641 129 0.025641 525 0.025641 558 0.025641 228 0.025641 624 0.025641 657 0.025641 723 0.025641 756 0.025641 789 0.025641 822 0.025641 855 0.025641 195 0.025641 921 0.025641 954 0.025641 63 0.025641 1218 0.025641 592 0.025641 262 0.025641 295 0.025641 328 0.025641 493 0.025641 394 0.025641 427 0.025641 460 0.025641 1054 0.025641 988 0.025641 1021 0.025641 889 0.025641 1087 0.025641 1153 0.025641 1186 0.025641 1252 0.025641 1285 0.025641 1120 0.025641 691 0.025641 97 0.025641 163 0.025641 361 0.025641 31 0.025641 130 0.025641 526 0.025641 559 0.025641 229 0.025641 625 0.025641 658 0.025641 724 0.025641 757 0.025641 790 0.025641 823 0.025641 856 0.025641 196 0.025641 922 0.025641 955 0.025641 64 0.025641 1219 0.025641 593 0.025641 263 0.025641 296 0.025641 329 0.025641 494 0.025641 395 0.025641 428 0.025641 461 0.025641 1055 0.025641 989 0.025641 1022 0.025641 890 0.025641 1088 0.025641 1154 0.025641 1187 0.025641 1253 0.025641 1286 0.025641 1121 0.025641 692 0.025641 98 0.025641 164 0.025641 362 0.025641 32 0.025641 131 0.025641 527 0.025641 560 0.025641 230 0.025641 626 0.025641 659 0.025641 725 0.025641 758 0.025641 791 0.025641 824 0.025641 857 0.025641 197 0.025641 923 0.025641 956 0.025641 65 0.025641 1220 0.025641 2 1 3 27 33 891 756 0.030303 783 0.030303 135 0.030303 162 0.030303 216 0.030303 243 0.030303 270 0.030303 324 0.030303 351 0.030303 378 0.030303 405 0.030303 27 0.030303 729 0.030303 81 0.030303 648 0.030303 675 0.030303 702 0.030303 0 0.030303 297 0.030303 189 0.030303 864 0.030303 432 0.030303 459 0.030303 486 0.030303 513 0.030303 540 0.030303 567 0.030303 594 0.030303 621 0.030303 54 0.030303 108 0.030303 810 0.030303 837 0.030303 757 0.030303 784 0.030303 136 0.030303 163 0.030303 217 0.030303 244 0.030303 271 0.030303 325 0.030303 352 0.030303 379 0.030303 406 0.030303 28 0.030303 730 0.030303 82 0.030303 649 0.030303 676 0.030303 703 0.030303 1 0.030303 298 0.030303 190 0.030303 865 0.030303 433 0.030303 460 0.030303 487 0.030303 514 0.030303 541 0.030303 568 0.030303 595 0.030303 622 0.030303 55 0.030303 109 0.030303 811 0.030303 838 0.030303 758 0.030303 785 0.030303 137 0.030303 164 0.030303 218 0.030303 245 0.030303 272 0.030303 326 0.030303 353 0.030303 380 0.030303 407 0.030303 29 0.030303 731 0.030303 83 0.030303 650 0.030303 677 0.030303 704 0.030303 2 0.030303 299 0.030303 191 0.030303 866 0.030303 434 0.030303 461 0.030303 488 0.030303 515 0.030303 542 0.030303 569 0.030303 596 0.030303 623 0.030303 56 0.030303 110 0.030303 812 0.030303 839 0.030303 759 0.030303 786 0.030303 138 0.030303 165 0.030303 219 0.030303 246 0.030303 273 0.030303 327 0.030303 354 0.030303 381 0.030303 408 0.030303 30 0.030303 732 0.030303 84 0.030303 651 0.030303 678 0.030303 705 0.030303 3 0.030303 300 0.030303 192 0.030303 867 0.030303 435 0.030303 462 0.030303 489 0.030303 516 0.030303 543 0.030303 570 0.030303 597 0.030303 624 0.030303 57 0.030303 111 0.030303 813 0.030303 840 0.030303 760 0.030303 787 0.030303 139 0.030303 166 0.030303 220 0.030303 247 0.030303 274 0.030303 328 0.030303 355 0.030303 382 0.030303 409 0.030303 31 0.030303 733 0.030303 85 0.030303 652 0.030303 679 0.030303 706 0.030303 4 0.030303 301 0.030303 193 0.030303 868 0.030303 436 0.030303 463 0.030303 490 0.030303 517 0.030303 544 0.030303 571 0.030303 598 0.030303 625 0.030303 58 0.030303 112 0.030303 814 0.030303 841 0.030303 761 0.030303 788 0.030303 140 0.030303 167 0.030303 221 0.030303 248 0.030303 275 0.030303 329 0.030303 356 0.030303 383 0.030303 410 0.030303 32 0.030303 734 0.030303 86 0.030303 653 0.030303 680 0.030303 707 0.030303 5 0.030303 302 0.030303 194 0.030303 869 0.030303 437 0.030303 464 0.030303 491 0.030303 518 0.030303 545 0.030303 572 0.030303 599 0.030303 626 0.030303 59 0.030303 113 0.030303 815 0.030303 842 0.030303 762 0.030303 789 0.030303 141 0.030303 168 0.030303 222 0.030303 249 0.030303 276 0.030303 330 0.030303 357 0.030303 384 0.030303 411 0.030303 33 0.030303 735 0.030303 87 0.030303 654 0.030303 681 0.030303 708 0.030303 6 0.030303 303 0.030303 195 0.030303 870 0.030303 438 0.030303 465 0.030303 492 0.030303 519 0.030303 546 0.030303 573 0.030303 600 0.030303 627 0.030303 60 0.030303 114 0.030303 816 0.030303 843 0.030303 763 0.030303 790 0.030303 142 0.030303 169 0.030303 223 0.030303 250 0.030303 277 0.030303 331 0.030303 358 0.030303 385 0.030303 412 0.030303 34 0.030303 736 0.030303 88 0.030303 655 0.030303 682 0.030303 709 0.030303 7 0.030303 304 0.030303 196 0.030303 871 0.030303 439 0.030303 466 0.030303 493 0.030303 520 0.030303 547 0.030303 574 0.030303 601 0.030303 628 0.030303 61 0.030303 115 0.030303 817 0.030303 844 0.030303 764 0.030303 791 0.030303 143 0.030303 170 0.030303 224 0.030303 251 0.030303 278 0.030303 332 0.030303 359 0.030303 386 0.030303 413 0.030303 35 0.030303 737 0.030303 89 0.030303 656 0.030303 683 0.030303 710 0.030303 8 0.030303 305 0.030303 197 0.030303 872 0.030303 440 0.030303 467 0.030303 494 0.030303 521 0.030303 548 0.030303 575 0.030303 602 0.030303 629 0.030303 62 0.030303 116 0.030303 818 0.030303 845 0.030303 765 0.030303 792 0.030303 144 0.030303 171 0.030303 225 0.030303 252 0.030303 279 0.030303 333 0.030303 360 0.030303 387 0.030303 414 0.030303 36 0.030303 738 0.030303 90 0.030303 657 0.030303 684 0.030303 711 0.030303 9 0.030303 306 0.030303 198 0.030303 873 0.030303 441 0.030303 468 0.030303 495 0.030303 522 0.030303 549 0.030303 576 0.030303 603 0.030303 630 0.030303 63 0.030303 117 0.030303 819 0.030303 846 0.030303 766 0.030303 793 0.030303 145 0.030303 172 0.030303 226 0.030303 253 0.030303 280 0.030303 334 0.030303 361 0.030303 388 0.030303 415 0.030303 37 0.030303 739 0.030303 91 0.030303 658 0.030303 685 0.030303 712 0.030303 10 0.030303 307 0.030303 199 0.030303 874 0.030303 442 0.030303 469 0.030303 496 0.030303 523 0.030303 550 0.030303 577 0.030303 604 0.030303 631 0.030303 64 0.030303 118 0.030303 820 0.030303 847 0.030303 767 0.030303 794 0.030303 146 0.030303 173 0.030303 227 0.030303 254 0.030303 281 0.030303 335 0.030303 362 0.030303 389 0.030303 416 0.030303 38 0.030303 740 0.030303 92 0.030303 659 0.030303 686 0.030303 713 0.030303 11 0.030303 308 0.030303 200 0.030303 875 0.030303 443 0.030303 470 0.030303 497 0.030303 524 0.030303 551 0.030303 578 0.030303 605 0.030303 632 0.030303 65 0.030303 119 0.030303 821 0.030303 848 0.030303 768 0.030303 795 0.030303 147 0.030303 174 0.030303 228 0.030303 255 0.030303 282 0.030303 336 0.030303 363 0.030303 390 0.030303 417 0.030303 39 0.030303 741 0.030303 93 0.030303 660 0.030303 687 0.030303 714 0.030303 12 0.030303 309 0.030303 201 0.030303 876 0.030303 444 0.030303 471 0.030303 498 0.030303 525 0.030303 552 0.030303 579 0.030303 606 0.030303 633 0.030303 66 0.030303 120 0.030303 822 0.030303 849 0.030303 769 0.030303 796 0.030303 148 0.030303 175 0.030303 229 0.030303 256 0.030303 283 0.030303 337 0.030303 364 0.030303 391 0.030303 418 0.030303 40 0.030303 742 0.030303 94 0.030303 661 0.030303 688 0.030303 715 0.030303 13 0.030303 310 0.030303 202 0.030303 877 0.030303 445 0.030303 472 0.030303 499 0.030303 526 0.030303 553 0.030303 580 0.030303 607 0.030303 634 0.030303 67 0.030303 121 0.030303 823 0.030303 850 0.030303 770 0.030303 797 0.030303 149 0.030303 176 0.030303 230 0.030303 257 0.030303 284 0.030303 338 0.030303 365 0.030303 392 0.030303 419 0.030303 41 0.030303 743 0.030303 95 0.030303 662 0.030303 689 0.030303 716 0.030303 14 0.030303 311 0.030303 203 0.030303 878 0.030303 446 0.030303 473 0.030303 500 0.030303 527 0.030303 554 0.030303 581 0.030303 608 0.030303 635 0.030303 68 0.030303 122 0.030303 824 0.030303 851 0.030303 771 0.030303 798 0.030303 150 0.030303 177 0.030303 231 0.030303 258 0.030303 285 0.030303 339 0.030303 366 0.030303 393 0.030303 420 0.030303 42 0.030303 744 0.030303 96 0.030303 663 0.030303 690 0.030303 717 0.030303 15 0.030303 312 0.030303 204 0.030303 879 0.030303 447 0.030303 474 0.030303 501 0.030303 528 0.030303 555 0.030303 582 0.030303 609 0.030303 636 0.030303 69 0.030303 123 0.030303 825 0.030303 852 0.030303 772 0.030303 799 0.030303 151 0.030303 178 0.030303 232 0.030303 259 0.030303 286 0.030303 340 0.030303 367 0.030303 394 0.030303 421 0.030303 43 0.030303 745 0.030303 97 0.030303 664 0.030303 691 0.030303 718 0.030303 16 0.030303 313 0.030303 205 0.030303 880 0.030303 448 0.030303 475 0.030303 502 0.030303 529 0.030303 556 0.030303 583 0.030303 610 0.030303 637 0.030303 70 0.030303 124 0.030303 826 0.030303 853 0.030303 773 0.030303 800 0.030303 152 0.030303 179 0.030303 233 0.030303 260 0.030303 287 0.030303 341 0.030303 368 0.030303 395 0.030303 422 0.030303 44 0.030303 746 0.030303 98 0.030303 665 0.030303 692 0.030303 719 0.030303 17 0.030303 314 0.030303 206 0.030303 881 0.030303 449 0.030303 476 0.030303 503 0.030303 530 0.030303 557 0.030303 584 0.030303 611 0.030303 638 0.030303 71 0.030303 125 0.030303 827 0.030303 854 0.030303 774 0.030303 801 0.030303 153 0.030303 180 0.030303 234 0.030303 261 0.030303 288 0.030303 342 0.030303 369 0.030303 396 0.030303 423 0.030303 45 0.030303 747 0.030303 99 0.030303 666 0.030303 693 0.030303 720 0.030303 18 0.030303 315 0.030303 207 0.030303 882 0.030303 450 0.030303 477 0.030303 504 0.030303 531 0.030303 558 0.030303 585 0.030303 612 0.030303 639 0.030303 72 0.030303 126 0.030303 828 0.030303 855 0.030303 775 0.030303 802 0.030303 154 0.030303 181 0.030303 235 0.030303 262 0.030303 289 0.030303 343 0.030303 370 0.030303 397 0.030303 424 0.030303 46 0.030303 748 0.030303 100 0.030303 667 0.030303 694 0.030303 721 0.030303 19 0.030303 316 0.030303 208 0.030303 883 0.030303 451 0.030303 478 0.030303 505 0.030303 532 0.030303 559 0.030303 586 0.030303 613 0.030303 640 0.030303 73 0.030303 127 0.030303 829 0.030303 856 0.030303 776 0.030303 803 0.030303 155 0.030303 182 0.030303 236 0.030303 263 0.030303 290 0.030303 344 0.030303 371 0.030303 398 0.030303 425 0.030303 47 0.030303 749 0.030303 101 0.030303 668 0.030303 695 0.030303 722 0.030303 20 0.030303 317 0.030303 209 0.030303 884 0.030303 452 0.030303 479 0.030303 506 0.030303 533 0.030303 560 0.030303 587 0.030303 614 0.030303 641 0.030303 74 0.030303 128 0.030303 830 0.030303 857 0.030303 777 0.030303 804 0.030303 156 0.030303 183 0.030303 237 0.030303 264 0.030303 291 0.030303 345 0.030303 372 0.030303 399 0.030303 426 0.030303 48 0.030303 750 0.030303 102 0.030303 669 0.030303 696 0.030303 723 0.030303 21 0.030303 318 0.030303 210 0.030303 885 0.030303 453 0.030303 480 0.030303 507 0.030303 534 0.030303 561 0.030303 588 0.030303 615 0.030303 642 0.030303 75 0.030303 129 0.030303 831 0.030303 858 0.030303 778 0.030303 805 0.030303 157 0.030303 184 0.030303 238 0.030303 265 0.030303 292 0.030303 346 0.030303 373 0.030303 400 0.030303 427 0.030303 49 0.030303 751 0.030303 103 0.030303 670 0.030303 697 0.030303 724 0.030303 22 0.030303 319 0.030303 211 0.030303 886 0.030303 454 0.030303 481 0.030303 508 0.030303 535 0.030303 562 0.030303 589 0.030303 616 0.030303 643 0.030303 76 0.030303 130 0.030303 832 0.030303 859 0.030303 779 0.030303 806 0.030303 158 0.030303 185 0.030303 239 0.030303 266 0.030303 293 0.030303 347 0.030303 374 0.030303 401 0.030303 428 0.030303 50 0.030303 752 0.030303 104 0.030303 671 0.030303 698 0.030303 725 0.030303 23 0.030303 320 0.030303 212 0.030303 887 0.030303 455 0.030303 482 0.030303 509 0.030303 536 0.030303 563 0.030303 590 0.030303 617 0.030303 644 0.030303 77 0.030303 131 0.030303 833 0.030303 860 0.030303 780 0.030303 807 0.030303 159 0.030303 186 0.030303 240 0.030303 267 0.030303 294 0.030303 348 0.030303 375 0.030303 402 0.030303 429 0.030303 51 0.030303 753 0.030303 105 0.030303 672 0.030303 699 0.030303 726 0.030303 24 0.030303 321 0.030303 213 0.030303 888 0.030303 456 0.030303 483 0.030303 510 0.030303 537 0.030303 564 0.030303 591 0.030303 618 0.030303 645 0.030303 78 0.030303 132 0.030303 834 0.030303 861 0.030303 781 0.030303 808 0.030303 160 0.030303 187 0.030303 241 0.030303 268 0.030303 295 0.030303 349 0.030303 376 0.030303 403 0.030303 430 0.030303 52 0.030303 754 0.030303 106 0.030303 673 0.030303 700 0.030303 727 0.030303 25 0.030303 322 0.030303 214 0.030303 889 0.030303 457 0.030303 484 0.030303 511 0.030303 538 0.030303 565 0.030303 592 0.030303 619 0.030303 646 0.030303 79 0.030303 133 0.030303 835 0.030303 862 0.030303 782 0.030303 809 0.030303 161 0.030303 188 0.030303 242 0.030303 269 0.030303 296 0.030303 350 0.030303 377 0.030303 404 0.030303 431 0.030303 53 0.030303 755 0.030303 107 0.030303 674 0.030303 701 0.030303 728 0.030303 26 0.030303 323 0.030303 215 0.030303 890 0.030303 458 0.030303 485 0.030303 512 0.030303 539 0.030303 566 0.030303 593 0.030303 620 0.030303 647 0.030303 80 0.030303 134 0.030303 836 0.030303 863 0.030303 2 9 19 8 2 8 8 1.000000 9 1.000000 10 1.000000 11 1.000000 12 1.000000 5 1.000000 6 1.000000 7 1.000000 2 3 13 33 2 33 33 1.000000 1 1.000000 35 1.000000 36 1.000000 37 1.000000 5 1.000000 6 1.000000 40 1.000000 8 1.000000 9 1.000000 10 1.000000 44 1.000000 12 1.000000 13 1.000000 14 1.000000 15 1.000000 16 1.000000 17 1.000000 18 1.000000 19 1.000000 20 1.000000 21 1.000000 22 1.000000 23 1.000000 57 1.000000 58 1.000000 59 1.000000 60 1.000000 28 1.000000 29 1.000000 63 1.000000 64 1.000000 65 1.000000 2 8 18 8 2 8 8 1.000000 9 1.000000 10 1.000000 11 1.000000 12 1.000000 5 1.000000 6 1.000000 7 1.000000 3 10 11 20 1 1 1 1 0 1.000000 2 6 8 16 8 128 0 0.125000 16 0.125000 32 0.125000 48 0.125000 64 0.125000 80 0.125000 96 0.125000 112 0.125000 1 0.125000 17 0.125000 33 0.125000 49 0.125000 65 0.125000 81 0.125000 97 0.125000 113 0.125000 2 0.125000 18 0.125000 34 0.125000 50 0.125000 66 0.125000 82 0.125000 98 0.125000 114 0.125000 3 0.125000 19 0.125000 35 0.125000 51 0.125000 67 0.125000 83 0.125000 99 0.125000 115 0.125000 4 0.125000 20 0.125000 36 0.125000 52 0.125000 68 0.125000 84 0.125000 100 0.125000 116 0.125000 5 0.125000 21 0.125000 37 0.125000 53 0.125000 69 0.125000 85 0.125000 101 0.125000 117 0.125000 6 0.125000 22 0.125000 38 0.125000 54 0.125000 70 0.125000 86 0.125000 102 0.125000 118 0.125000 7 0.125000 23 0.125000 39 0.125000 55 0.125000 71 0.125000 87 0.125000 103 0.125000 119 0.125000 8 0.125000 24 0.125000 40 0.125000 56 0.125000 72 0.125000 88 0.125000 104 0.125000 120 0.125000 9 0.125000 25 0.125000 41 0.125000 57 0.125000 73 0.125000 89 0.125000 105 0.125000 121 0.125000 10 0.125000 26 0.125000 42 0.125000 58 0.125000 74 0.125000 90 0.125000 106 0.125000 122 0.125000 11 0.125000 27 0.125000 43 0.125000 59 0.125000 75 0.125000 91 0.125000 107 0.125000 123 0.125000 12 0.125000 28 0.125000 44 0.125000 60 0.125000 76 0.125000 92 0.125000 108 0.125000 124 0.125000 13 0.125000 29 0.125000 45 0.125000 61 0.125000 77 0.125000 93 0.125000 109 0.125000 125 0.125000 14 0.125000 30 0.125000 46 0.125000 62 0.125000 78 0.125000 94 0.125000 110 0.125000 126 0.125000 15 0.125000 31 0.125000 47 0.125000 63 0.125000 79 0.125000 95 0.125000 111 0.125000 127 0.125000 3 14 15 22 2 2 1 2 2 1.000000 1 1.000000 1 1 27 27 0 0.037037 1 0.037037 2 0.037037 3 0.037037 4 0.037037 5 0.037037 6 0.037037 9 0.037037 10 0.037037 11 0.037037 12 0.037037 13 0.037037 14 0.037037 16 0.037037 23 0.037037 19 0.037037 15 0.037037 7 0.037037 8 0.037037 26 0.037037 21 0.037037 22 0.037037 20 0.037037 17 0.037037 18 0.037037 24 0.037037 25 0.037037 2 7 9 16 8 128 0 0.125000 16 0.125000 32 0.125000 48 0.125000 64 0.125000 80 0.125000 96 0.125000 112 0.125000 1 0.125000 17 0.125000 33 0.125000 49 0.125000 65 0.125000 81 0.125000 97 0.125000 113 0.125000 2 0.125000 18 0.125000 34 0.125000 50 0.125000 66 0.125000 82 0.125000 98 0.125000 114 0.125000 3 0.125000 19 0.125000 35 0.125000 51 0.125000 67 0.125000 83 0.125000 99 0.125000 115 0.125000 4 0.125000 20 0.125000 36 0.125000 52 0.125000 68 0.125000 84 0.125000 100 0.125000 116 0.125000 5 0.125000 21 0.125000 37 0.125000 53 0.125000 69 0.125000 85 0.125000 101 0.125000 117 0.125000 6 0.125000 22 0.125000 38 0.125000 54 0.125000 70 0.125000 86 0.125000 102 0.125000 118 0.125000 7 0.125000 23 0.125000 39 0.125000 55 0.125000 71 0.125000 87 0.125000 103 0.125000 119 0.125000 8 0.125000 24 0.125000 40 0.125000 56 0.125000 72 0.125000 88 0.125000 104 0.125000 120 0.125000 9 0.125000 25 0.125000 41 0.125000 57 0.125000 73 0.125000 89 0.125000 105 0.125000 121 0.125000 10 0.125000 26 0.125000 42 0.125000 58 0.125000 74 0.125000 90 0.125000 106 0.125000 122 0.125000 11 0.125000 27 0.125000 43 0.125000 59 0.125000 75 0.125000 91 0.125000 107 0.125000 123 0.125000 12 0.125000 28 0.125000 44 0.125000 60 0.125000 76 0.125000 92 0.125000 108 0.125000 124 0.125000 13 0.125000 29 0.125000 45 0.125000 61 0.125000 77 0.125000 93 0.125000 109 0.125000 125 0.125000 14 0.125000 30 0.125000 46 0.125000 62 0.125000 78 0.125000 94 0.125000 110 0.125000 126 0.125000 15 0.125000 31 0.125000 47 0.125000 63 0.125000 79 0.125000 95 0.125000 111 0.125000 127 0.125000 2 1 11 27 1 27 0 1.000000 1 1.000000 2 1.000000 3 1.000000 4 1.000000 5 1.000000 6 1.000000 7 1.000000 8 1.000000 9 1.000000 10 1.000000 11 1.000000 12 1.000000 13 1.000000 14 1.000000 15 1.000000 16 1.000000 17 1.000000 18 1.000000 19 1.000000 20 1.000000 21 1.000000 22 1.000000 23 1.000000 24 1.000000 25 1.000000 26 1.000000 3 18 19 24 2 2 1 2 2 1.000000 1 1.000000 2 4 14 39 2 39 39 1.000000 40 1.000000 41 1.000000 42 1.000000 43 1.000000 5 1.000000 6 1.000000 7 1.000000 47 1.000000 9 1.000000 49 1.000000 50 1.000000 51 1.000000 52 1.000000 53 1.000000 54 1.000000 55 1.000000 56 1.000000 18 1.000000 19 1.000000 59 1.000000 21 1.000000 22 1.000000 23 1.000000 24 1.000000 25 1.000000 26 1.000000 27 1.000000 28 1.000000 29 1.000000 30 1.000000 31 1.000000 32 1.000000 72 1.000000 34 1.000000 35 1.000000 36 1.000000 37 1.000000 38 1.000000 2 0 2 27 33 891 756 0.030303 783 0.030303 135 0.030303 162 0.030303 216 0.030303 243 0.030303 270 0.030303 324 0.030303 351 0.030303 378 0.030303 405 0.030303 27 0.030303 729 0.030303 81 0.030303 648 0.030303 675 0.030303 702 0.030303 0 0.030303 297 0.030303 189 0.030303 864 0.030303 432 0.030303 459 0.030303 486 0.030303 513 0.030303 540 0.030303 567 0.030303 594 0.030303 621 0.030303 54 0.030303 108 0.030303 810 0.030303 837 0.030303 757 0.030303 784 0.030303 136 0.030303 163 0.030303 217 0.030303 244 0.030303 271 0.030303 325 0.030303 352 0.030303 379 0.030303 406 0.030303 28 0.030303 730 0.030303 82 0.030303 649 0.030303 676 0.030303 703 0.030303 1 0.030303 298 0.030303 190 0.030303 865 0.030303 433 0.030303 460 0.030303 487 0.030303 514 0.030303 541 0.030303 568 0.030303 595 0.030303 622 0.030303 55 0.030303 109 0.030303 811 0.030303 838 0.030303 758 0.030303 785 0.030303 137 0.030303 164 0.030303 218 0.030303 245 0.030303 272 0.030303 326 0.030303 353 0.030303 380 0.030303 407 0.030303 29 0.030303 731 0.030303 83 0.030303 650 0.030303 677 0.030303 704 0.030303 2 0.030303 299 0.030303 191 0.030303 866 0.030303 434 0.030303 461 0.030303 488 0.030303 515 0.030303 542 0.030303 569 0.030303 596 0.030303 623 0.030303 56 0.030303 110 0.030303 812 0.030303 839 0.030303 759 0.030303 786 0.030303 138 0.030303 165 0.030303 219 0.030303 246 0.030303 273 0.030303 327 0.030303 354 0.030303 381 0.030303 408 0.030303 30 0.030303 732 0.030303 84 0.030303 651 0.030303 678 0.030303 705 0.030303 3 0.030303 300 0.030303 192 0.030303 867 0.030303 435 0.030303 462 0.030303 489 0.030303 516 0.030303 543 0.030303 570 0.030303 597 0.030303 624 0.030303 57 0.030303 111 0.030303 813 0.030303 840 0.030303 760 0.030303 787 0.030303 139 0.030303 166 0.030303 220 0.030303 247 0.030303 274 0.030303 328 0.030303 355 0.030303 382 0.030303 409 0.030303 31 0.030303 733 0.030303 85 0.030303 652 0.030303 679 0.030303 706 0.030303 4 0.030303 301 0.030303 193 0.030303 868 0.030303 436 0.030303 463 0.030303 490 0.030303 517 0.030303 544 0.030303 571 0.030303 598 0.030303 625 0.030303 58 0.030303 112 0.030303 814 0.030303 841 0.030303 761 0.030303 788 0.030303 140 0.030303 167 0.030303 221 0.030303 248 0.030303 275 0.030303 329 0.030303 356 0.030303 383 0.030303 410 0.030303 32 0.030303 734 0.030303 86 0.030303 653 0.030303 680 0.030303 707 0.030303 5 0.030303 302 0.030303 194 0.030303 869 0.030303 437 0.030303 464 0.030303 491 0.030303 518 0.030303 545 0.030303 572 0.030303 599 0.030303 626 0.030303 59 0.030303 113 0.030303 815 0.030303 842 0.030303 762 0.030303 789 0.030303 141 0.030303 168 0.030303 222 0.030303 249 0.030303 276 0.030303 330 0.030303 357 0.030303 384 0.030303 411 0.030303 33 0.030303 735 0.030303 87 0.030303 654 0.030303 681 0.030303 708 0.030303 6 0.030303 303 0.030303 195 0.030303 870 0.030303 438 0.030303 465 0.030303 492 0.030303 519 0.030303 546 0.030303 573 0.030303 600 0.030303 627 0.030303 60 0.030303 114 0.030303 816 0.030303 843 0.030303 763 0.030303 790 0.030303 142 0.030303 169 0.030303 223 0.030303 250 0.030303 277 0.030303 331 0.030303 358 0.030303 385 0.030303 412 0.030303 34 0.030303 736 0.030303 88 0.030303 655 0.030303 682 0.030303 709 0.030303 7 0.030303 304 0.030303 196 0.030303 871 0.030303 439 0.030303 466 0.030303 493 0.030303 520 0.030303 547 0.030303 574 0.030303 601 0.030303 628 0.030303 61 0.030303 115 0.030303 817 0.030303 844 0.030303 764 0.030303 791 0.030303 143 0.030303 170 0.030303 224 0.030303 251 0.030303 278 0.030303 332 0.030303 359 0.030303 386 0.030303 413 0.030303 35 0.030303 737 0.030303 89 0.030303 656 0.030303 683 0.030303 710 0.030303 8 0.030303 305 0.030303 197 0.030303 872 0.030303 440 0.030303 467 0.030303 494 0.030303 521 0.030303 548 0.030303 575 0.030303 602 0.030303 629 0.030303 62 0.030303 116 0.030303 818 0.030303 845 0.030303 765 0.030303 792 0.030303 144 0.030303 171 0.030303 225 0.030303 252 0.030303 279 0.030303 333 0.030303 360 0.030303 387 0.030303 414 0.030303 36 0.030303 738 0.030303 90 0.030303 657 0.030303 684 0.030303 711 0.030303 9 0.030303 306 0.030303 198 0.030303 873 0.030303 441 0.030303 468 0.030303 495 0.030303 522 0.030303 549 0.030303 576 0.030303 603 0.030303 630 0.030303 63 0.030303 117 0.030303 819 0.030303 846 0.030303 766 0.030303 793 0.030303 145 0.030303 172 0.030303 226 0.030303 253 0.030303 280 0.030303 334 0.030303 361 0.030303 388 0.030303 415 0.030303 37 0.030303 739 0.030303 91 0.030303 658 0.030303 685 0.030303 712 0.030303 10 0.030303 307 0.030303 199 0.030303 874 0.030303 442 0.030303 469 0.030303 496 0.030303 523 0.030303 550 0.030303 577 0.030303 604 0.030303 631 0.030303 64 0.030303 118 0.030303 820 0.030303 847 0.030303 767 0.030303 794 0.030303 146 0.030303 173 0.030303 227 0.030303 254 0.030303 281 0.030303 335 0.030303 362 0.030303 389 0.030303 416 0.030303 38 0.030303 740 0.030303 92 0.030303 659 0.030303 686 0.030303 713 0.030303 11 0.030303 308 0.030303 200 0.030303 875 0.030303 443 0.030303 470 0.030303 497 0.030303 524 0.030303 551 0.030303 578 0.030303 605 0.030303 632 0.030303 65 0.030303 119 0.030303 821 0.030303 848 0.030303 768 0.030303 795 0.030303 147 0.030303 174 0.030303 228 0.030303 255 0.030303 282 0.030303 336 0.030303 363 0.030303 390 0.030303 417 0.030303 39 0.030303 741 0.030303 93 0.030303 660 0.030303 687 0.030303 714 0.030303 12 0.030303 309 0.030303 201 0.030303 876 0.030303 444 0.030303 471 0.030303 498 0.030303 525 0.030303 552 0.030303 579 0.030303 606 0.030303 633 0.030303 66 0.030303 120 0.030303 822 0.030303 849 0.030303 769 0.030303 796 0.030303 148 0.030303 175 0.030303 229 0.030303 256 0.030303 283 0.030303 337 0.030303 364 0.030303 391 0.030303 418 0.030303 40 0.030303 742 0.030303 94 0.030303 661 0.030303 688 0.030303 715 0.030303 13 0.030303 310 0.030303 202 0.030303 877 0.030303 445 0.030303 472 0.030303 499 0.030303 526 0.030303 553 0.030303 580 0.030303 607 0.030303 634 0.030303 67 0.030303 121 0.030303 823 0.030303 850 0.030303 770 0.030303 797 0.030303 149 0.030303 176 0.030303 230 0.030303 257 0.030303 284 0.030303 338 0.030303 365 0.030303 392 0.030303 419 0.030303 41 0.030303 743 0.030303 95 0.030303 662 0.030303 689 0.030303 716 0.030303 14 0.030303 311 0.030303 203 0.030303 878 0.030303 446 0.030303 473 0.030303 500 0.030303 527 0.030303 554 0.030303 581 0.030303 608 0.030303 635 0.030303 68 0.030303 122 0.030303 824 0.030303 851 0.030303 771 0.030303 798 0.030303 150 0.030303 177 0.030303 231 0.030303 258 0.030303 285 0.030303 339 0.030303 366 0.030303 393 0.030303 420 0.030303 42 0.030303 744 0.030303 96 0.030303 663 0.030303 690 0.030303 717 0.030303 15 0.030303 312 0.030303 204 0.030303 879 0.030303 447 0.030303 474 0.030303 501 0.030303 528 0.030303 555 0.030303 582 0.030303 609 0.030303 636 0.030303 69 0.030303 123 0.030303 825 0.030303 852 0.030303 772 0.030303 799 0.030303 151 0.030303 178 0.030303 232 0.030303 259 0.030303 286 0.030303 340 0.030303 367 0.030303 394 0.030303 421 0.030303 43 0.030303 745 0.030303 97 0.030303 664 0.030303 691 0.030303 718 0.030303 16 0.030303 313 0.030303 205 0.030303 880 0.030303 448 0.030303 475 0.030303 502 0.030303 529 0.030303 556 0.030303 583 0.030303 610 0.030303 637 0.030303 70 0.030303 124 0.030303 826 0.030303 853 0.030303 773 0.030303 800 0.030303 152 0.030303 179 0.030303 233 0.030303 260 0.030303 287 0.030303 341 0.030303 368 0.030303 395 0.030303 422 0.030303 44 0.030303 746 0.030303 98 0.030303 665 0.030303 692 0.030303 719 0.030303 17 0.030303 314 0.030303 206 0.030303 881 0.030303 449 0.030303 476 0.030303 503 0.030303 530 0.030303 557 0.030303 584 0.030303 611 0.030303 638 0.030303 71 0.030303 125 0.030303 827 0.030303 854 0.030303 774 0.030303 801 0.030303 153 0.030303 180 0.030303 234 0.030303 261 0.030303 288 0.030303 342 0.030303 369 0.030303 396 0.030303 423 0.030303 45 0.030303 747 0.030303 99 0.030303 666 0.030303 693 0.030303 720 0.030303 18 0.030303 315 0.030303 207 0.030303 882 0.030303 450 0.030303 477 0.030303 504 0.030303 531 0.030303 558 0.030303 585 0.030303 612 0.030303 639 0.030303 72 0.030303 126 0.030303 828 0.030303 855 0.030303 775 0.030303 802 0.030303 154 0.030303 181 0.030303 235 0.030303 262 0.030303 289 0.030303 343 0.030303 370 0.030303 397 0.030303 424 0.030303 46 0.030303 748 0.030303 100 0.030303 667 0.030303 694 0.030303 721 0.030303 19 0.030303 316 0.030303 208 0.030303 883 0.030303 451 0.030303 478 0.030303 505 0.030303 532 0.030303 559 0.030303 586 0.030303 613 0.030303 640 0.030303 73 0.030303 127 0.030303 829 0.030303 856 0.030303 776 0.030303 803 0.030303 155 0.030303 182 0.030303 236 0.030303 263 0.030303 290 0.030303 344 0.030303 371 0.030303 398 0.030303 425 0.030303 47 0.030303 749 0.030303 101 0.030303 668 0.030303 695 0.030303 722 0.030303 20 0.030303 317 0.030303 209 0.030303 884 0.030303 452 0.030303 479 0.030303 506 0.030303 533 0.030303 560 0.030303 587 0.030303 614 0.030303 641 0.030303 74 0.030303 128 0.030303 830 0.030303 857 0.030303 777 0.030303 804 0.030303 156 0.030303 183 0.030303 237 0.030303 264 0.030303 291 0.030303 345 0.030303 372 0.030303 399 0.030303 426 0.030303 48 0.030303 750 0.030303 102 0.030303 669 0.030303 696 0.030303 723 0.030303 21 0.030303 318 0.030303 210 0.030303 885 0.030303 453 0.030303 480 0.030303 507 0.030303 534 0.030303 561 0.030303 588 0.030303 615 0.030303 642 0.030303 75 0.030303 129 0.030303 831 0.030303 858 0.030303 778 0.030303 805 0.030303 157 0.030303 184 0.030303 238 0.030303 265 0.030303 292 0.030303 346 0.030303 373 0.030303 400 0.030303 427 0.030303 49 0.030303 751 0.030303 103 0.030303 670 0.030303 697 0.030303 724 0.030303 22 0.030303 319 0.030303 211 0.030303 886 0.030303 454 0.030303 481 0.030303 508 0.030303 535 0.030303 562 0.030303 589 0.030303 616 0.030303 643 0.030303 76 0.030303 130 0.030303 832 0.030303 859 0.030303 779 0.030303 806 0.030303 158 0.030303 185 0.030303 239 0.030303 266 0.030303 293 0.030303 347 0.030303 374 0.030303 401 0.030303 428 0.030303 50 0.030303 752 0.030303 104 0.030303 671 0.030303 698 0.030303 725 0.030303 23 0.030303 320 0.030303 212 0.030303 887 0.030303 455 0.030303 482 0.030303 509 0.030303 536 0.030303 563 0.030303 590 0.030303 617 0.030303 644 0.030303 77 0.030303 131 0.030303 833 0.030303 860 0.030303 780 0.030303 807 0.030303 159 0.030303 186 0.030303 240 0.030303 267 0.030303 294 0.030303 348 0.030303 375 0.030303 402 0.030303 429 0.030303 51 0.030303 753 0.030303 105 0.030303 672 0.030303 699 0.030303 726 0.030303 24 0.030303 321 0.030303 213 0.030303 888 0.030303 456 0.030303 483 0.030303 510 0.030303 537 0.030303 564 0.030303 591 0.030303 618 0.030303 645 0.030303 78 0.030303 132 0.030303 834 0.030303 861 0.030303 781 0.030303 808 0.030303 160 0.030303 187 0.030303 241 0.030303 268 0.030303 295 0.030303 349 0.030303 376 0.030303 403 0.030303 430 0.030303 52 0.030303 754 0.030303 106 0.030303 673 0.030303 700 0.030303 727 0.030303 25 0.030303 322 0.030303 214 0.030303 889 0.030303 457 0.030303 484 0.030303 511 0.030303 538 0.030303 565 0.030303 592 0.030303 619 0.030303 646 0.030303 79 0.030303 133 0.030303 835 0.030303 862 0.030303 782 0.030303 809 0.030303 161 0.030303 188 0.030303 242 0.030303 269 0.030303 296 0.030303 350 0.030303 377 0.030303 404 0.030303 431 0.030303 53 0.030303 755 0.030303 107 0.030303 674 0.030303 701 0.030303 728 0.030303 26 0.030303 323 0.030303 215 0.030303 890 0.030303 458 0.030303 485 0.030303 512 0.030303 539 0.030303 566 0.030303 593 0.030303 620 0.030303 647 0.030303 80 0.030303 134 0.030303 836 0.030303 863 0.030303 1 0 27 27 0 0.037037 1 0.037037 2 0.037037 3 0.037037 4 0.037037 5 0.037037 6 0.037037 9 0.037037 10 0.037037 11 0.037037 12 0.037037 13 0.037037 14 0.037037 16 0.037037 23 0.037037 19 0.037037 15 0.037037 7 0.037037 8 0.037037 26 0.037037 21 0.037037 22 0.037037 20 0.037037 17 0.037037 18 0.037037 24 0.037037 25 0.037037 2 2 12 33 2 33 33 1.000000 1 1.000000 35 1.000000 36 1.000000 37 1.000000 5 1.000000 6 1.000000 40 1.000000 8 1.000000 9 1.000000 10 1.000000 44 1.000000 12 1.000000 13 1.000000 14 1.000000 15 1.000000 16 1.000000 17 1.000000 18 1.000000 19 1.000000 20 1.000000 21 1.000000 22 1.000000 23 1.000000 57 1.000000 58 1.000000 59 1.000000 60 1.000000 28 1.000000 29 1.000000 63 1.000000 64 1.000000 65 1.000000 2 3 5 33 39 1287 561 0.025641 231 0.025641 264 0.025641 297 0.025641 462 0.025641 363 0.025641 396 0.025641 429 0.025641 1023 0.025641 957 0.025641 990 0.025641 858 0.025641 1056 0.025641 1122 0.025641 1155 0.025641 1221 0.025641 1254 0.025641 1089 0.025641 660 0.025641 66 0.025641 132 0.025641 330 0.025641 0 0.025641 99 0.025641 495 0.025641 528 0.025641 198 0.025641 594 0.025641 627 0.025641 693 0.025641 726 0.025641 759 0.025641 792 0.025641 825 0.025641 165 0.025641 891 0.025641 924 0.025641 33 0.025641 1188 0.025641 562 0.025641 232 0.025641 265 0.025641 298 0.025641 463 0.025641 364 0.025641 397 0.025641 430 0.025641 1024 0.025641 958 0.025641 991 0.025641 859 0.025641 1057 0.025641 1123 0.025641 1156 0.025641 1222 0.025641 1255 0.025641 1090 0.025641 661 0.025641 67 0.025641 133 0.025641 331 0.025641 1 0.025641 100 0.025641 496 0.025641 529 0.025641 199 0.025641 595 0.025641 628 0.025641 694 0.025641 727 0.025641 760 0.025641 793 0.025641 826 0.025641 166 0.025641 892 0.025641 925 0.025641 34 0.025641 1189 0.025641 563 0.025641 233 0.025641 266 0.025641 299 0.025641 464 0.025641 365 0.025641 398 0.025641 431 0.025641 1025 0.025641 959 0.025641 992 0.025641 860 0.025641 1058 0.025641 1124 0.025641 1157 0.025641 1223 0.025641 1256 0.025641 1091 0.025641 662 0.025641 68 0.025641 134 0.025641 332 0.025641 2 0.025641 101 0.025641 497 0.025641 530 0.025641 200 0.025641 596 0.025641 629 0.025641 695 0.025641 728 0.025641 761 0.025641 794 0.025641 827 0.025641 167 0.025641 893 0.025641 926 0.025641 35 0.025641 1190 0.025641 564 0.025641 234 0.025641 267 0.025641 300 0.025641 465 0.025641 366 0.025641 399 0.025641 432 0.025641 1026 0.025641 960 0.025641 993 0.025641 861 0.025641 1059 0.025641 1125 0.025641 1158 0.025641 1224 0.025641 1257 0.025641 1092 0.025641 663 0.025641 69 0.025641 135 0.025641 333 0.025641 3 0.025641 102 0.025641 498 0.025641 531 0.025641 201 0.025641 597 0.025641 630 0.025641 696 0.025641 729 0.025641 762 0.025641 795 0.025641 828 0.025641 168 0.025641 894 0.025641 927 0.025641 36 0.025641 1191 0.025641 565 0.025641 235 0.025641 268 0.025641 301 0.025641 466 0.025641 367 0.025641 400 0.025641 433 0.025641 1027 0.025641 961 0.025641 994 0.025641 862 0.025641 1060 0.025641 1126 0.025641 1159 0.025641 1225 0.025641 1258 0.025641 1093 0.025641 664 0.025641 70 0.025641 136 0.025641 334 0.025641 4 0.025641 103 0.025641 499 0.025641 532 0.025641 202 0.025641 598 0.025641 631 0.025641 697 0.025641 730 0.025641 763 0.025641 796 0.025641 829 0.025641 169 0.025641 895 0.025641 928 0.025641 37 0.025641 1192 0.025641 566 0.025641 236 0.025641 269 0.025641 302 0.025641 467 0.025641 368 0.025641 401 0.025641 434 0.025641 1028 0.025641 962 0.025641 995 0.025641 863 0.025641 1061 0.025641 1127 0.025641 1160 0.025641 1226 0.025641 1259 0.025641 1094 0.025641 665 0.025641 71 0.025641 137 0.025641 335 0.025641 5 0.025641 104 0.025641 500 0.025641 533 0.025641 203 0.025641 599 0.025641 632 0.025641 698 0.025641 731 0.025641 764 0.025641 797 0.025641 830 0.025641 170 0.025641 896 0.025641 929 0.025641 38 0.025641 1193 0.025641 567 0.025641 237 0.025641 270 0.025641 303 0.025641 468 0.025641 369 0.025641 402 0.025641 435 0.025641 1029 0.025641 963 0.025641 996 0.025641 864 0.025641 1062 0.025641 1128 0.025641 1161 0.025641 1227 0.025641 1260 0.025641 1095 0.025641 666 0.025641 72 0.025641 138 0.025641 336 0.025641 6 0.025641 105 0.025641 501 0.025641 534 0.025641 204 0.025641 600 0.025641 633 0.025641 699 0.025641 732 0.025641 765 0.025641 798 0.025641 831 0.025641 171 0.025641 897 0.025641 930 0.025641 39 0.025641 1194 0.025641 568 0.025641 238 0.025641 271 0.025641 304 0.025641 469 0.025641 370 0.025641 403 0.025641 436 0.025641 1030 0.025641 964 0.025641 997 0.025641 865 0.025641 1063 0.025641 1129 0.025641 1162 0.025641 1228 0.025641 1261 0.025641 1096 0.025641 667 0.025641 73 0.025641 139 0.025641 337 0.025641 7 0.025641 106 0.025641 502 0.025641 535 0.025641 205 0.025641 601 0.025641 634 0.025641 700 0.025641 733 0.025641 766 0.025641 799 0.025641 832 0.025641 172 0.025641 898 0.025641 931 0.025641 40 0.025641 1195 0.025641 569 0.025641 239 0.025641 272 0.025641 305 0.025641 470 0.025641 371 0.025641 404 0.025641 437 0.025641 1031 0.025641 965 0.025641 998 0.025641 866 0.025641 1064 0.025641 1130 0.025641 1163 0.025641 1229 0.025641 1262 0.025641 1097 0.025641 668 0.025641 74 0.025641 140 0.025641 338 0.025641 8 0.025641 107 0.025641 503 0.025641 536 0.025641 206 0.025641 602 0.025641 635 0.025641 701 0.025641 734 0.025641 767 0.025641 800 0.025641 833 0.025641 173 0.025641 899 0.025641 932 0.025641 41 0.025641 1196 0.025641 570 0.025641 240 0.025641 273 0.025641 306 0.025641 471 0.025641 372 0.025641 405 0.025641 438 0.025641 1032 0.025641 966 0.025641 999 0.025641 867 0.025641 1065 0.025641 1131 0.025641 1164 0.025641 1230 0.025641 1263 0.025641 1098 0.025641 669 0.025641 75 0.025641 141 0.025641 339 0.025641 9 0.025641 108 0.025641 504 0.025641 537 0.025641 207 0.025641 603 0.025641 636 0.025641 702 0.025641 735 0.025641 768 0.025641 801 0.025641 834 0.025641 174 0.025641 900 0.025641 933 0.025641 42 0.025641 1197 0.025641 571 0.025641 241 0.025641 274 0.025641 307 0.025641 472 0.025641 373 0.025641 406 0.025641 439 0.025641 1033 0.025641 967 0.025641 1000 0.025641 868 0.025641 1066 0.025641 1132 0.025641 1165 0.025641 1231 0.025641 1264 0.025641 1099 0.025641 670 0.025641 76 0.025641 142 0.025641 340 0.025641 10 0.025641 109 0.025641 505 0.025641 538 0.025641 208 0.025641 604 0.025641 637 0.025641 703 0.025641 736 0.025641 769 0.025641 802 0.025641 835 0.025641 175 0.025641 901 0.025641 934 0.025641 43 0.025641 1198 0.025641 572 0.025641 242 0.025641 275 0.025641 308 0.025641 473 0.025641 374 0.025641 407 0.025641 440 0.025641 1034 0.025641 968 0.025641 1001 0.025641 869 0.025641 1067 0.025641 1133 0.025641 1166 0.025641 1232 0.025641 1265 0.025641 1100 0.025641 671 0.025641 77 0.025641 143 0.025641 341 0.025641 11 0.025641 110 0.025641 506 0.025641 539 0.025641 209 0.025641 605 0.025641 638 0.025641 704 0.025641 737 0.025641 770 0.025641 803 0.025641 836 0.025641 176 0.025641 902 0.025641 935 0.025641 44 0.025641 1199 0.025641 573 0.025641 243 0.025641 276 0.025641 309 0.025641 474 0.025641 375 0.025641 408 0.025641 441 0.025641 1035 0.025641 969 0.025641 1002 0.025641 870 0.025641 1068 0.025641 1134 0.025641 1167 0.025641 1233 0.025641 1266 0.025641 1101 0.025641 672 0.025641 78 0.025641 144 0.025641 342 0.025641 12 0.025641 111 0.025641 507 0.025641 540 0.025641 210 0.025641 606 0.025641 639 0.025641 705 0.025641 738 0.025641 771 0.025641 804 0.025641 837 0.025641 177 0.025641 903 0.025641 936 0.025641 45 0.025641 1200 0.025641 574 0.025641 244 0.025641 277 0.025641 310 0.025641 475 0.025641 376 0.025641 409 0.025641 442 0.025641 1036 0.025641 970 0.025641 1003 0.025641 871 0.025641 1069 0.025641 1135 0.025641 1168 0.025641 1234 0.025641 1267 0.025641 1102 0.025641 673 0.025641 79 0.025641 145 0.025641 343 0.025641 13 0.025641 112 0.025641 508 0.025641 541 0.025641 211 0.025641 607 0.025641 640 0.025641 706 0.025641 739 0.025641 772 0.025641 805 0.025641 838 0.025641 178 0.025641 904 0.025641 937 0.025641 46 0.025641 1201 0.025641 575 0.025641 245 0.025641 278 0.025641 311 0.025641 476 0.025641 377 0.025641 410 0.025641 443 0.025641 1037 0.025641 971 0.025641 1004 0.025641 872 0.025641 1070 0.025641 1136 0.025641 1169 0.025641 1235 0.025641 1268 0.025641 1103 0.025641 674 0.025641 80 0.025641 146 0.025641 344 0.025641 14 0.025641 113 0.025641 509 0.025641 542 0.025641 212 0.025641 608 0.025641 641 0.025641 707 0.025641 740 0.025641 773 0.025641 806 0.025641 839 0.025641 179 0.025641 905 0.025641 938 0.025641 47 0.025641 1202 0.025641 576 0.025641 246 0.025641 279 0.025641 312 0.025641 477 0.025641 378 0.025641 411 0.025641 444 0.025641 1038 0.025641 972 0.025641 1005 0.025641 873 0.025641 1071 0.025641 1137 0.025641 1170 0.025641 1236 0.025641 1269 0.025641 1104 0.025641 675 0.025641 81 0.025641 147 0.025641 345 0.025641 15 0.025641 114 0.025641 510 0.025641 543 0.025641 213 0.025641 609 0.025641 642 0.025641 708 0.025641 741 0.025641 774 0.025641 807 0.025641 840 0.025641 180 0.025641 906 0.025641 939 0.025641 48 0.025641 1203 0.025641 577 0.025641 247 0.025641 280 0.025641 313 0.025641 478 0.025641 379 0.025641 412 0.025641 445 0.025641 1039 0.025641 973 0.025641 1006 0.025641 874 0.025641 1072 0.025641 1138 0.025641 1171 0.025641 1237 0.025641 1270 0.025641 1105 0.025641 676 0.025641 82 0.025641 148 0.025641 346 0.025641 16 0.025641 115 0.025641 511 0.025641 544 0.025641 214 0.025641 610 0.025641 643 0.025641 709 0.025641 742 0.025641 775 0.025641 808 0.025641 841 0.025641 181 0.025641 907 0.025641 940 0.025641 49 0.025641 1204 0.025641 578 0.025641 248 0.025641 281 0.025641 314 0.025641 479 0.025641 380 0.025641 413 0.025641 446 0.025641 1040 0.025641 974 0.025641 1007 0.025641 875 0.025641 1073 0.025641 1139 0.025641 1172 0.025641 1238 0.025641 1271 0.025641 1106 0.025641 677 0.025641 83 0.025641 149 0.025641 347 0.025641 17 0.025641 116 0.025641 512 0.025641 545 0.025641 215 0.025641 611 0.025641 644 0.025641 710 0.025641 743 0.025641 776 0.025641 809 0.025641 842 0.025641 182 0.025641 908 0.025641 941 0.025641 50 0.025641 1205 0.025641 579 0.025641 249 0.025641 282 0.025641 315 0.025641 480 0.025641 381 0.025641 414 0.025641 447 0.025641 1041 0.025641 975 0.025641 1008 0.025641 876 0.025641 1074 0.025641 1140 0.025641 1173 0.025641 1239 0.025641 1272 0.025641 1107 0.025641 678 0.025641 84 0.025641 150 0.025641 348 0.025641 18 0.025641 117 0.025641 513 0.025641 546 0.025641 216 0.025641 612 0.025641 645 0.025641 711 0.025641 744 0.025641 777 0.025641 810 0.025641 843 0.025641 183 0.025641 909 0.025641 942 0.025641 51 0.025641 1206 0.025641 580 0.025641 250 0.025641 283 0.025641 316 0.025641 481 0.025641 382 0.025641 415 0.025641 448 0.025641 1042 0.025641 976 0.025641 1009 0.025641 877 0.025641 1075 0.025641 1141 0.025641 1174 0.025641 1240 0.025641 1273 0.025641 1108 0.025641 679 0.025641 85 0.025641 151 0.025641 349 0.025641 19 0.025641 118 0.025641 514 0.025641 547 0.025641 217 0.025641 613 0.025641 646 0.025641 712 0.025641 745 0.025641 778 0.025641 811 0.025641 844 0.025641 184 0.025641 910 0.025641 943 0.025641 52 0.025641 1207 0.025641 581 0.025641 251 0.025641 284 0.025641 317 0.025641 482 0.025641 383 0.025641 416 0.025641 449 0.025641 1043 0.025641 977 0.025641 1010 0.025641 878 0.025641 1076 0.025641 1142 0.025641 1175 0.025641 1241 0.025641 1274 0.025641 1109 0.025641 680 0.025641 86 0.025641 152 0.025641 350 0.025641 20 0.025641 119 0.025641 515 0.025641 548 0.025641 218 0.025641 614 0.025641 647 0.025641 713 0.025641 746 0.025641 779 0.025641 812 0.025641 845 0.025641 185 0.025641 911 0.025641 944 0.025641 53 0.025641 1208 0.025641 582 0.025641 252 0.025641 285 0.025641 318 0.025641 483 0.025641 384 0.025641 417 0.025641 450 0.025641 1044 0.025641 978 0.025641 1011 0.025641 879 0.025641 1077 0.025641 1143 0.025641 1176 0.025641 1242 0.025641 1275 0.025641 1110 0.025641 681 0.025641 87 0.025641 153 0.025641 351 0.025641 21 0.025641 120 0.025641 516 0.025641 549 0.025641 219 0.025641 615 0.025641 648 0.025641 714 0.025641 747 0.025641 780 0.025641 813 0.025641 846 0.025641 186 0.025641 912 0.025641 945 0.025641 54 0.025641 1209 0.025641 583 0.025641 253 0.025641 286 0.025641 319 0.025641 484 0.025641 385 0.025641 418 0.025641 451 0.025641 1045 0.025641 979 0.025641 1012 0.025641 880 0.025641 1078 0.025641 1144 0.025641 1177 0.025641 1243 0.025641 1276 0.025641 1111 0.025641 682 0.025641 88 0.025641 154 0.025641 352 0.025641 22 0.025641 121 0.025641 517 0.025641 550 0.025641 220 0.025641 616 0.025641 649 0.025641 715 0.025641 748 0.025641 781 0.025641 814 0.025641 847 0.025641 187 0.025641 913 0.025641 946 0.025641 55 0.025641 1210 0.025641 584 0.025641 254 0.025641 287 0.025641 320 0.025641 485 0.025641 386 0.025641 419 0.025641 452 0.025641 1046 0.025641 980 0.025641 1013 0.025641 881 0.025641 1079 0.025641 1145 0.025641 1178 0.025641 1244 0.025641 1277 0.025641 1112 0.025641 683 0.025641 89 0.025641 155 0.025641 353 0.025641 23 0.025641 122 0.025641 518 0.025641 551 0.025641 221 0.025641 617 0.025641 650 0.025641 716 0.025641 749 0.025641 782 0.025641 815 0.025641 848 0.025641 188 0.025641 914 0.025641 947 0.025641 56 0.025641 1211 0.025641 585 0.025641 255 0.025641 288 0.025641 321 0.025641 486 0.025641 387 0.025641 420 0.025641 453 0.025641 1047 0.025641 981 0.025641 1014 0.025641 882 0.025641 1080 0.025641 1146 0.025641 1179 0.025641 1245 0.025641 1278 0.025641 1113 0.025641 684 0.025641 90 0.025641 156 0.025641 354 0.025641 24 0.025641 123 0.025641 519 0.025641 552 0.025641 222 0.025641 618 0.025641 651 0.025641 717 0.025641 750 0.025641 783 0.025641 816 0.025641 849 0.025641 189 0.025641 915 0.025641 948 0.025641 57 0.025641 1212 0.025641 586 0.025641 256 0.025641 289 0.025641 322 0.025641 487 0.025641 388 0.025641 421 0.025641 454 0.025641 1048 0.025641 982 0.025641 1015 0.025641 883 0.025641 1081 0.025641 1147 0.025641 1180 0.025641 1246 0.025641 1279 0.025641 1114 0.025641 685 0.025641 91 0.025641 157 0.025641 355 0.025641 25 0.025641 124 0.025641 520 0.025641 553 0.025641 223 0.025641 619 0.025641 652 0.025641 718 0.025641 751 0.025641 784 0.025641 817 0.025641 850 0.025641 190 0.025641 916 0.025641 949 0.025641 58 0.025641 1213 0.025641 587 0.025641 257 0.025641 290 0.025641 323 0.025641 488 0.025641 389 0.025641 422 0.025641 455 0.025641 1049 0.025641 983 0.025641 1016 0.025641 884 0.025641 1082 0.025641 1148 0.025641 1181 0.025641 1247 0.025641 1280 0.025641 1115 0.025641 686 0.025641 92 0.025641 158 0.025641 356 0.025641 26 0.025641 125 0.025641 521 0.025641 554 0.025641 224 0.025641 620 0.025641 653 0.025641 719 0.025641 752 0.025641 785 0.025641 818 0.025641 851 0.025641 191 0.025641 917 0.025641 950 0.025641 59 0.025641 1214 0.025641 588 0.025641 258 0.025641 291 0.025641 324 0.025641 489 0.025641 390 0.025641 423 0.025641 456 0.025641 1050 0.025641 984 0.025641 1017 0.025641 885 0.025641 1083 0.025641 1149 0.025641 1182 0.025641 1248 0.025641 1281 0.025641 1116 0.025641 687 0.025641 93 0.025641 159 0.025641 357 0.025641 27 0.025641 126 0.025641 522 0.025641 555 0.025641 225 0.025641 621 0.025641 654 0.025641 720 0.025641 753 0.025641 786 0.025641 819 0.025641 852 0.025641 192 0.025641 918 0.025641 951 0.025641 60 0.025641 1215 0.025641 589 0.025641 259 0.025641 292 0.025641 325 0.025641 490 0.025641 391 0.025641 424 0.025641 457 0.025641 1051 0.025641 985 0.025641 1018 0.025641 886 0.025641 1084 0.025641 1150 0.025641 1183 0.025641 1249 0.025641 1282 0.025641 1117 0.025641 688 0.025641 94 0.025641 160 0.025641 358 0.025641 28 0.025641 127 0.025641 523 0.025641 556 0.025641 226 0.025641 622 0.025641 655 0.025641 721 0.025641 754 0.025641 787 0.025641 820 0.025641 853 0.025641 193 0.025641 919 0.025641 952 0.025641 61 0.025641 1216 0.025641 590 0.025641 260 0.025641 293 0.025641 326 0.025641 491 0.025641 392 0.025641 425 0.025641 458 0.025641 1052 0.025641 986 0.025641 1019 0.025641 887 0.025641 1085 0.025641 1151 0.025641 1184 0.025641 1250 0.025641 1283 0.025641 1118 0.025641 689 0.025641 95 0.025641 161 0.025641 359 0.025641 29 0.025641 128 0.025641 524 0.025641 557 0.025641 227 0.025641 623 0.025641 656 0.025641 722 0.025641 755 0.025641 788 0.025641 821 0.025641 854 0.025641 194 0.025641 920 0.025641 953 0.025641 62 0.025641 1217 0.025641 591 0.025641 261 0.025641 294 0.025641 327 0.025641 492 0.025641 393 0.025641 426 0.025641 459 0.025641 1053 0.025641 987 0.025641 1020 0.025641 888 0.025641 1086 0.025641 1152 0.025641 1185 0.025641 1251 0.025641 1284 0.025641 1119 0.025641 690 0.025641 96 0.025641 162 0.025641 360 0.025641 30 0.025641 129 0.025641 525 0.025641 558 0.025641 228 0.025641 624 0.025641 657 0.025641 723 0.025641 756 0.025641 789 0.025641 822 0.025641 855 0.025641 195 0.025641 921 0.025641 954 0.025641 63 0.025641 1218 0.025641 592 0.025641 262 0.025641 295 0.025641 328 0.025641 493 0.025641 394 0.025641 427 0.025641 460 0.025641 1054 0.025641 988 0.025641 1021 0.025641 889 0.025641 1087 0.025641 1153 0.025641 1186 0.025641 1252 0.025641 1285 0.025641 1120 0.025641 691 0.025641 97 0.025641 163 0.025641 361 0.025641 31 0.025641 130 0.025641 526 0.025641 559 0.025641 229 0.025641 625 0.025641 658 0.025641 724 0.025641 757 0.025641 790 0.025641 823 0.025641 856 0.025641 196 0.025641 922 0.025641 955 0.025641 64 0.025641 1219 0.025641 593 0.025641 263 0.025641 296 0.025641 329 0.025641 494 0.025641 395 0.025641 428 0.025641 461 0.025641 1055 0.025641 989 0.025641 1022 0.025641 890 0.025641 1088 0.025641 1154 0.025641 1187 0.025641 1253 0.025641 1286 0.025641 1121 0.025641 692 0.025641 98 0.025641 164 0.025641 362 0.025641 32 0.025641 131 0.025641 527 0.025641 560 0.025641 230 0.025641 626 0.025641 659 0.025641 725 0.025641 758 0.025641 791 0.025641 824 0.025641 857 0.025641 197 0.025641 923 0.025641 956 0.025641 65 0.025641 1220 0.025641 3 12 13 21 2 2 1 2 2 1.000000 1 1.000000 2 4 6 39 16 624 0 0.062500 39 0.062500 78 0.062500 117 0.062500 156 0.062500 195 0.062500 234 0.062500 273 0.062500 312 0.062500 351 0.062500 390 0.062500 429 0.062500 468 0.062500 507 0.062500 546 0.062500 585 0.062500 1 0.062500 40 0.062500 79 0.062500 118 0.062500 157 0.062500 196 0.062500 235 0.062500 274 0.062500 313 0.062500 352 0.062500 391 0.062500 430 0.062500 469 0.062500 508 0.062500 547 0.062500 586 0.062500 2 0.062500 41 0.062500 80 0.062500 119 0.062500 158 0.062500 197 0.062500 236 0.062500 275 0.062500 314 0.062500 353 0.062500 392 0.062500 431 0.062500 470 0.062500 509 0.062500 548 0.062500 587 0.062500 3 0.062500 42 0.062500 81 0.062500 120 0.062500 159 0.062500 198 0.062500 237 0.062500 276 0.062500 315 0.062500 354 0.062500 393 0.062500 432 0.062500 471 0.062500 510 0.062500 549 0.062500 588 0.062500 4 0.062500 43 0.062500 82 0.062500 121 0.062500 160 0.062500 199 0.062500 238 0.062500 277 0.062500 316 0.062500 355 0.062500 394 0.062500 433 0.062500 472 0.062500 511 0.062500 550 0.062500 589 0.062500 5 0.062500 44 0.062500 83 0.062500 122 0.062500 161 0.062500 200 0.062500 239 0.062500 278 0.062500 317 0.062500 356 0.062500 395 0.062500 434 0.062500 473 0.062500 512 0.062500 551 0.062500 590 0.062500 6 0.062500 45 0.062500 84 0.062500 123 0.062500 162 0.062500 201 0.062500 240 0.062500 279 0.062500 318 0.062500 357 0.062500 396 0.062500 435 0.062500 474 0.062500 513 0.062500 552 0.062500 591 0.062500 7 0.062500 46 0.062500 85 0.062500 124 0.062500 163 0.062500 202 0.062500 241 0.062500 280 0.062500 319 0.062500 358 0.062500 397 0.062500 436 0.062500 475 0.062500 514 0.062500 553 0.062500 592 0.062500 8 0.062500 47 0.062500 86 0.062500 125 0.062500 164 0.062500 203 0.062500 242 0.062500 281 0.062500 320 0.062500 359 0.062500 398 0.062500 437 0.062500 476 0.062500 515 0.062500 554 0.062500 593 0.062500 9 0.062500 48 0.062500 87 0.062500 126 0.062500 165 0.062500 204 0.062500 243 0.062500 282 0.062500 321 0.062500 360 0.062500 399 0.062500 438 0.062500 477 0.062500 516 0.062500 555 0.062500 594 0.062500 10 0.062500 49 0.062500 88 0.062500 127 0.062500 166 0.062500 205 0.062500 244 0.062500 283 0.062500 322 0.062500 361 0.062500 400 0.062500 439 0.062500 478 0.062500 517 0.062500 556 0.062500 595 0.062500 11 0.062500 50 0.062500 89 0.062500 128 0.062500 167 0.062500 206 0.062500 245 0.062500 284 0.062500 323 0.062500 362 0.062500 401 0.062500 440 0.062500 479 0.062500 518 0.062500 557 0.062500 596 0.062500 12 0.062500 51 0.062500 90 0.062500 129 0.062500 168 0.062500 207 0.062500 246 0.062500 285 0.062500 324 0.062500 363 0.062500 402 0.062500 441 0.062500 480 0.062500 519 0.062500 558 0.062500 597 0.062500 13 0.062500 52 0.062500 91 0.062500 130 0.062500 169 0.062500 208 0.062500 247 0.062500 286 0.062500 325 0.062500 364 0.062500 403 0.062500 442 0.062500 481 0.062500 520 0.062500 559 0.062500 598 0.062500 14 0.062500 53 0.062500 92 0.062500 131 0.062500 170 0.062500 209 0.062500 248 0.062500 287 0.062500 326 0.062500 365 0.062500 404 0.062500 443 0.062500 482 0.062500 521 0.062500 560 0.062500 599 0.062500 15 0.062500 54 0.062500 93 0.062500 132 0.062500 171 0.062500 210 0.062500 249 0.062500 288 0.062500 327 0.062500 366 0.062500 405 0.062500 444 0.062500 483 0.062500 522 0.062500 561 0.062500 600 0.062500 16 0.062500 55 0.062500 94 0.062500 133 0.062500 172 0.062500 211 0.062500 250 0.062500 289 0.062500 328 0.062500 367 0.062500 406 0.062500 445 0.062500 484 0.062500 523 0.062500 562 0.062500 601 0.062500 17 0.062500 56 0.062500 95 0.062500 134 0.062500 173 0.062500 212 0.062500 251 0.062500 290 0.062500 329 0.062500 368 0.062500 407 0.062500 446 0.062500 485 0.062500 524 0.062500 563 0.062500 602 0.062500 18 0.062500 57 0.062500 96 0.062500 135 0.062500 174 0.062500 213 0.062500 252 0.062500 291 0.062500 330 0.062500 369 0.062500 408 0.062500 447 0.062500 486 0.062500 525 0.062500 564 0.062500 603 0.062500 19 0.062500 58 0.062500 97 0.062500 136 0.062500 175 0.062500 214 0.062500 253 0.062500 292 0.062500 331 0.062500 370 0.062500 409 0.062500 448 0.062500 487 0.062500 526 0.062500 565 0.062500 604 0.062500 20 0.062500 59 0.062500 98 0.062500 137 0.062500 176 0.062500 215 0.062500 254 0.062500 293 0.062500 332 0.062500 371 0.062500 410 0.062500 449 0.062500 488 0.062500 527 0.062500 566 0.062500 605 0.062500 21 0.062500 60 0.062500 99 0.062500 138 0.062500 177 0.062500 216 0.062500 255 0.062500 294 0.062500 333 0.062500 372 0.062500 411 0.062500 450 0.062500 489 0.062500 528 0.062500 567 0.062500 606 0.062500 22 0.062500 61 0.062500 100 0.062500 139 0.062500 178 0.062500 217 0.062500 256 0.062500 295 0.062500 334 0.062500 373 0.062500 412 0.062500 451 0.062500 490 0.062500 529 0.062500 568 0.062500 607 0.062500 23 0.062500 62 0.062500 101 0.062500 140 0.062500 179 0.062500 218 0.062500 257 0.062500 296 0.062500 335 0.062500 374 0.062500 413 0.062500 452 0.062500 491 0.062500 530 0.062500 569 0.062500 608 0.062500 24 0.062500 63 0.062500 102 0.062500 141 0.062500 180 0.062500 219 0.062500 258 0.062500 297 0.062500 336 0.062500 375 0.062500 414 0.062500 453 0.062500 492 0.062500 531 0.062500 570 0.062500 609 0.062500 25 0.062500 64 0.062500 103 0.062500 142 0.062500 181 0.062500 220 0.062500 259 0.062500 298 0.062500 337 0.062500 376 0.062500 415 0.062500 454 0.062500 493 0.062500 532 0.062500 571 0.062500 610 0.062500 26 0.062500 65 0.062500 104 0.062500 143 0.062500 182 0.062500 221 0.062500 260 0.062500 299 0.062500 338 0.062500 377 0.062500 416 0.062500 455 0.062500 494 0.062500 533 0.062500 572 0.062500 611 0.062500 27 0.062500 66 0.062500 105 0.062500 144 0.062500 183 0.062500 222 0.062500 261 0.062500 300 0.062500 339 0.062500 378 0.062500 417 0.062500 456 0.062500 495 0.062500 534 0.062500 573 0.062500 612 0.062500 28 0.062500 67 0.062500 106 0.062500 145 0.062500 184 0.062500 223 0.062500 262 0.062500 301 0.062500 340 0.062500 379 0.062500 418 0.062500 457 0.062500 496 0.062500 535 0.062500 574 0.062500 613 0.062500 29 0.062500 68 0.062500 107 0.062500 146 0.062500 185 0.062500 224 0.062500 263 0.062500 302 0.062500 341 0.062500 380 0.062500 419 0.062500 458 0.062500 497 0.062500 536 0.062500 575 0.062500 614 0.062500 30 0.062500 69 0.062500 108 0.062500 147 0.062500 186 0.062500 225 0.062500 264 0.062500 303 0.062500 342 0.062500 381 0.062500 420 0.062500 459 0.062500 498 0.062500 537 0.062500 576 0.062500 615 0.062500 31 0.062500 70 0.062500 109 0.062500 148 0.062500 187 0.062500 226 0.062500 265 0.062500 304 0.062500 343 0.062500 382 0.062500 421 0.062500 460 0.062500 499 0.062500 538 0.062500 577 0.062500 616 0.062500 32 0.062500 71 0.062500 110 0.062500 149 0.062500 188 0.062500 227 0.062500 266 0.062500 305 0.062500 344 0.062500 383 0.062500 422 0.062500 461 0.062500 500 0.062500 539 0.062500 578 0.062500 617 0.062500 33 0.062500 72 0.062500 111 0.062500 150 0.062500 189 0.062500 228 0.062500 267 0.062500 306 0.062500 345 0.062500 384 0.062500 423 0.062500 462 0.062500 501 0.062500 540 0.062500 579 0.062500 618 0.062500 34 0.062500 73 0.062500 112 0.062500 151 0.062500 190 0.062500 229 0.062500 268 0.062500 307 0.062500 346 0.062500 385 0.062500 424 0.062500 463 0.062500 502 0.062500 541 0.062500 580 0.062500 619 0.062500 35 0.062500 74 0.062500 113 0.062500 152 0.062500 191 0.062500 230 0.062500 269 0.062500 308 0.062500 347 0.062500 386 0.062500 425 0.062500 464 0.062500 503 0.062500 542 0.062500 581 0.062500 620 0.062500 36 0.062500 75 0.062500 114 0.062500 153 0.062500 192 0.062500 231 0.062500 270 0.062500 309 0.062500 348 0.062500 387 0.062500 426 0.062500 465 0.062500 504 0.062500 543 0.062500 582 0.062500 621 0.062500 37 0.062500 76 0.062500 115 0.062500 154 0.062500 193 0.062500 232 0.062500 271 0.062500 310 0.062500 349 0.062500 388 0.062500 427 0.062500 466 0.062500 505 0.062500 544 0.062500 583 0.062500 622 0.062500 38 0.062500 77 0.062500 116 0.062500 155 0.062500 194 0.062500 233 0.062500 272 0.062500 311 0.062500 350 0.062500 389 0.062500 428 0.062500 467 0.062500 506 0.062500 545 0.062500 584 0.062500 623 0.062500 2 5 7 39 16 624 0 0.062500 39 0.062500 78 0.062500 117 0.062500 156 0.062500 195 0.062500 234 0.062500 273 0.062500 312 0.062500 351 0.062500 390 0.062500 429 0.062500 468 0.062500 507 0.062500 546 0.062500 585 0.062500 1 0.062500 40 0.062500 79 0.062500 118 0.062500 157 0.062500 196 0.062500 235 0.062500 274 0.062500 313 0.062500 352 0.062500 391 0.062500 430 0.062500 469 0.062500 508 0.062500 547 0.062500 586 0.062500 2 0.062500 41 0.062500 80 0.062500 119 0.062500 158 0.062500 197 0.062500 236 0.062500 275 0.062500 314 0.062500 353 0.062500 392 0.062500 431 0.062500 470 0.062500 509 0.062500 548 0.062500 587 0.062500 3 0.062500 42 0.062500 81 0.062500 120 0.062500 159 0.062500 198 0.062500 237 0.062500 276 0.062500 315 0.062500 354 0.062500 393 0.062500 432 0.062500 471 0.062500 510 0.062500 549 0.062500 588 0.062500 4 0.062500 43 0.062500 82 0.062500 121 0.062500 160 0.062500 199 0.062500 238 0.062500 277 0.062500 316 0.062500 355 0.062500 394 0.062500 433 0.062500 472 0.062500 511 0.062500 550 0.062500 589 0.062500 5 0.062500 44 0.062500 83 0.062500 122 0.062500 161 0.062500 200 0.062500 239 0.062500 278 0.062500 317 0.062500 356 0.062500 395 0.062500 434 0.062500 473 0.062500 512 0.062500 551 0.062500 590 0.062500 6 0.062500 45 0.062500 84 0.062500 123 0.062500 162 0.062500 201 0.062500 240 0.062500 279 0.062500 318 0.062500 357 0.062500 396 0.062500 435 0.062500 474 0.062500 513 0.062500 552 0.062500 591 0.062500 7 0.062500 46 0.062500 85 0.062500 124 0.062500 163 0.062500 202 0.062500 241 0.062500 280 0.062500 319 0.062500 358 0.062500 397 0.062500 436 0.062500 475 0.062500 514 0.062500 553 0.062500 592 0.062500 8 0.062500 47 0.062500 86 0.062500 125 0.062500 164 0.062500 203 0.062500 242 0.062500 281 0.062500 320 0.062500 359 0.062500 398 0.062500 437 0.062500 476 0.062500 515 0.062500 554 0.062500 593 0.062500 9 0.062500 48 0.062500 87 0.062500 126 0.062500 165 0.062500 204 0.062500 243 0.062500 282 0.062500 321 0.062500 360 0.062500 399 0.062500 438 0.062500 477 0.062500 516 0.062500 555 0.062500 594 0.062500 10 0.062500 49 0.062500 88 0.062500 127 0.062500 166 0.062500 205 0.062500 244 0.062500 283 0.062500 322 0.062500 361 0.062500 400 0.062500 439 0.062500 478 0.062500 517 0.062500 556 0.062500 595 0.062500 11 0.062500 50 0.062500 89 0.062500 128 0.062500 167 0.062500 206 0.062500 245 0.062500 284 0.062500 323 0.062500 362 0.062500 401 0.062500 440 0.062500 479 0.062500 518 0.062500 557 0.062500 596 0.062500 12 0.062500 51 0.062500 90 0.062500 129 0.062500 168 0.062500 207 0.062500 246 0.062500 285 0.062500 324 0.062500 363 0.062500 402 0.062500 441 0.062500 480 0.062500 519 0.062500 558 0.062500 597 0.062500 13 0.062500 52 0.062500 91 0.062500 130 0.062500 169 0.062500 208 0.062500 247 0.062500 286 0.062500 325 0.062500 364 0.062500 403 0.062500 442 0.062500 481 0.062500 520 0.062500 559 0.062500 598 0.062500 14 0.062500 53 0.062500 92 0.062500 131 0.062500 170 0.062500 209 0.062500 248 0.062500 287 0.062500 326 0.062500 365 0.062500 404 0.062500 443 0.062500 482 0.062500 521 0.062500 560 0.062500 599 0.062500 15 0.062500 54 0.062500 93 0.062500 132 0.062500 171 0.062500 210 0.062500 249 0.062500 288 0.062500 327 0.062500 366 0.062500 405 0.062500 444 0.062500 483 0.062500 522 0.062500 561 0.062500 600 0.062500 16 0.062500 55 0.062500 94 0.062500 133 0.062500 172 0.062500 211 0.062500 250 0.062500 289 0.062500 328 0.062500 367 0.062500 406 0.062500 445 0.062500 484 0.062500 523 0.062500 562 0.062500 601 0.062500 17 0.062500 56 0.062500 95 0.062500 134 0.062500 173 0.062500 212 0.062500 251 0.062500 290 0.062500 329 0.062500 368 0.062500 407 0.062500 446 0.062500 485 0.062500 524 0.062500 563 0.062500 602 0.062500 18 0.062500 57 0.062500 96 0.062500 135 0.062500 174 0.062500 213 0.062500 252 0.062500 291 0.062500 330 0.062500 369 0.062500 408 0.062500 447 0.062500 486 0.062500 525 0.062500 564 0.062500 603 0.062500 19 0.062500 58 0.062500 97 0.062500 136 0.062500 175 0.062500 214 0.062500 253 0.062500 292 0.062500 331 0.062500 370 0.062500 409 0.062500 448 0.062500 487 0.062500 526 0.062500 565 0.062500 604 0.062500 20 0.062500 59 0.062500 98 0.062500 137 0.062500 176 0.062500 215 0.062500 254 0.062500 293 0.062500 332 0.062500 371 0.062500 410 0.062500 449 0.062500 488 0.062500 527 0.062500 566 0.062500 605 0.062500 21 0.062500 60 0.062500 99 0.062500 138 0.062500 177 0.062500 216 0.062500 255 0.062500 294 0.062500 333 0.062500 372 0.062500 411 0.062500 450 0.062500 489 0.062500 528 0.062500 567 0.062500 606 0.062500 22 0.062500 61 0.062500 100 0.062500 139 0.062500 178 0.062500 217 0.062500 256 0.062500 295 0.062500 334 0.062500 373 0.062500 412 0.062500 451 0.062500 490 0.062500 529 0.062500 568 0.062500 607 0.062500 23 0.062500 62 0.062500 101 0.062500 140 0.062500 179 0.062500 218 0.062500 257 0.062500 296 0.062500 335 0.062500 374 0.062500 413 0.062500 452 0.062500 491 0.062500 530 0.062500 569 0.062500 608 0.062500 24 0.062500 63 0.062500 102 0.062500 141 0.062500 180 0.062500 219 0.062500 258 0.062500 297 0.062500 336 0.062500 375 0.062500 414 0.062500 453 0.062500 492 0.062500 531 0.062500 570 0.062500 609 0.062500 25 0.062500 64 0.062500 103 0.062500 142 0.062500 181 0.062500 220 0.062500 259 0.062500 298 0.062500 337 0.062500 376 0.062500 415 0.062500 454 0.062500 493 0.062500 532 0.062500 571 0.062500 610 0.062500 26 0.062500 65 0.062500 104 0.062500 143 0.062500 182 0.062500 221 0.062500 260 0.062500 299 0.062500 338 0.062500 377 0.062500 416 0.062500 455 0.062500 494 0.062500 533 0.062500 572 0.062500 611 0.062500 27 0.062500 66 0.062500 105 0.062500 144 0.062500 183 0.062500 222 0.062500 261 0.062500 300 0.062500 339 0.062500 378 0.062500 417 0.062500 456 0.062500 495 0.062500 534 0.062500 573 0.062500 612 0.062500 28 0.062500 67 0.062500 106 0.062500 145 0.062500 184 0.062500 223 0.062500 262 0.062500 301 0.062500 340 0.062500 379 0.062500 418 0.062500 457 0.062500 496 0.062500 535 0.062500 574 0.062500 613 0.062500 29 0.062500 68 0.062500 107 0.062500 146 0.062500 185 0.062500 224 0.062500 263 0.062500 302 0.062500 341 0.062500 380 0.062500 419 0.062500 458 0.062500 497 0.062500 536 0.062500 575 0.062500 614 0.062500 30 0.062500 69 0.062500 108 0.062500 147 0.062500 186 0.062500 225 0.062500 264 0.062500 303 0.062500 342 0.062500 381 0.062500 420 0.062500 459 0.062500 498 0.062500 537 0.062500 576 0.062500 615 0.062500 31 0.062500 70 0.062500 109 0.062500 148 0.062500 187 0.062500 226 0.062500 265 0.062500 304 0.062500 343 0.062500 382 0.062500 421 0.062500 460 0.062500 499 0.062500 538 0.062500 577 0.062500 616 0.062500 32 0.062500 71 0.062500 110 0.062500 149 0.062500 188 0.062500 227 0.062500 266 0.062500 305 0.062500 344 0.062500 383 0.062500 422 0.062500 461 0.062500 500 0.062500 539 0.062500 578 0.062500 617 0.062500 33 0.062500 72 0.062500 111 0.062500 150 0.062500 189 0.062500 228 0.062500 267 0.062500 306 0.062500 345 0.062500 384 0.062500 423 0.062500 462 0.062500 501 0.062500 540 0.062500 579 0.062500 618 0.062500 34 0.062500 73 0.062500 112 0.062500 151 0.062500 190 0.062500 229 0.062500 268 0.062500 307 0.062500 346 0.062500 385 0.062500 424 0.062500 463 0.062500 502 0.062500 541 0.062500 580 0.062500 619 0.062500 35 0.062500 74 0.062500 113 0.062500 152 0.062500 191 0.062500 230 0.062500 269 0.062500 308 0.062500 347 0.062500 386 0.062500 425 0.062500 464 0.062500 503 0.062500 542 0.062500 581 0.062500 620 0.062500 36 0.062500 75 0.062500 114 0.062500 153 0.062500 192 0.062500 231 0.062500 270 0.062500 309 0.062500 348 0.062500 387 0.062500 426 0.062500 465 0.062500 504 0.062500 543 0.062500 582 0.062500 621 0.062500 37 0.062500 76 0.062500 115 0.062500 154 0.062500 193 0.062500 232 0.062500 271 0.062500 310 0.062500 349 0.062500 388 0.062500 427 0.062500 466 0.062500 505 0.062500 544 0.062500 583 0.062500 622 0.062500 38 0.062500 77 0.062500 116 0.062500 155 0.062500 194 0.062500 233 0.062500 272 0.062500 311 0.062500 350 0.062500 389 0.062500 428 0.062500 467 0.062500 506 0.062500 545 0.062500 584 0.062500 623 0.062500 2 0 10 27 1 27 0 1.000000 1 1.000000 2 1.000000 3 1.000000 4 1.000000 5 1.000000 6 1.000000 7 1.000000 8 1.000000 9 1.000000 10 1.000000 11 1.000000 12 1.000000 13 1.000000 14 1.000000 15 1.000000 16 1.000000 17 1.000000 18 1.000000 19 1.000000 20 1.000000 21 1.000000 22 1.000000 23 1.000000 24 1.000000 25 1.000000 26 1.000000 3 16 17 23 2 2 1 2 2 1.000000 1 1.000000 2 6 16 16 2 16 16 1.000000 17 1.000000 18 1.000000 19 1.000000 20 1.000000 21 1.000000 6 1.000000 7 1.000000 8 1.000000 9 1.000000 10 1.000000 11 1.000000 12 1.000000 13 1.000000 14 1.000000 15 1.000000 2 7 17 16 2 16 16 1.000000 17 1.000000 18 1.000000 19 1.000000 20 1.000000 21 1.000000 6 1.000000 7 1.000000 8 1.000000 9 1.000000 10 1.000000 11 1.000000 12 1.000000 13 1.000000 14 1.000000 15 1.000000 2 5 15 39 2 39 39 1.000000 40 1.000000 41 1.000000 42 1.000000 43 1.000000 5 1.000000 6 1.000000 7 1.000000 47 1.000000 9 1.000000 49 1.000000 50 1.000000 51 1.000000 52 1.000000 53 1.000000 54 1.000000 55 1.000000 56 1.000000 18 1.000000 19 1.000000 59 1.000000 21 1.000000 22 1.000000 23 1.000000 24 1.000000 25 1.000000 26 1.000000 27 1.000000 28 1.000000 29 1.000000 30 1.000000 31 1.000000 32 1.000000 72 1.000000 34 1.000000 35 1.000000 36 1.000000 37 1.000000 38 1.000000 libDAI-0.3.2/tests/testall.bat0000755000175000017500000000445612042452776015517 0ustar jorismjorism@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 GLC_UNICAV_SINGLE GLC_PAIRCAV_SINGLE GLC_PAIR2CAV_SINGLE GLC_FULLCAV_SINGLE GLC+_UNICAV_FACTOR GLC+_FULLCAV_FACTOR GLC+_UNICAV_LOOP3 GLC+_FULLCAV_LOOP3 GLC_UNICAV_LOOP4 GLC_FULLCAV_LOOP4 GLC+_UNICAV_LOOP4 GLC+_FULLCAV_LOOP4 GLC+_UNICAV_LOOP5 GLC+_FULLCAV_LOOP5 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.3.2/tests/hoi2.fg0000644000175000017500000000151111235602300014477 0ustar jorismjorism# 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.3.2/tests/testregression0000755000175000017500000000026211236233664016346 0ustar jorismjorism#!/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.3.2/tests/testfast.out0000644000175000017500000022535412451270033015730 0ustar jorismjorism# 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)) GLC_UNICAV_SINGLE 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)) GLC_PAIRCAV_SINGLE 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)) GLC_PAIR2CAV_SINGLE 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)) GLC_FULLCAV_SINGLE 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)) GLC+_UNICAV_FACTOR 2.790e-03 6.317e-04 9.520e-03 2.247e-03 N/A 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.444e-01, 3.556e-01)) # ({x2}, (5.002e-01, 4.998e-01)) # ({x3}, (3.054e-01, 6.946e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.398e-01, 3.601e-01)) # ({x6}, (5.803e-01, 4.197e-01)) # ({x7}, (5.435e-01, 4.565e-01)) # ({x8}, (2.800e-01, 7.199e-01)) # ({x9}, (7.086e-01, 2.913e-01)) # ({x10}, (5.748e-01, 4.252e-01)) # ({x11}, (5.360e-01, 4.640e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.037e-01, 9.631e-02)) # ({x14}, (2.427e-01, 7.573e-01)) # ({x15}, (6.915e-01, 3.085e-01)) GLC+_FULLCAV_FACTOR 3.871e-05 9.116e-06 1.157e-04 1.534e-05 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.800e-01, 7.200e-01)) # ({x9}, (7.084e-01, 2.916e-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)) GLC+_UNICAV_LOOP3 2.790e-03 6.317e-04 9.520e-03 2.247e-03 N/A 1.000e-09 # ({x0}, (3.500e-01, 6.500e-01)) # ({x1}, (6.444e-01, 3.556e-01)) # ({x2}, (5.002e-01, 4.998e-01)) # ({x3}, (3.054e-01, 6.946e-01)) # ({x4}, (3.699e-01, 6.301e-01)) # ({x5}, (6.398e-01, 3.601e-01)) # ({x6}, (5.803e-01, 4.197e-01)) # ({x7}, (5.435e-01, 4.565e-01)) # ({x8}, (2.800e-01, 7.199e-01)) # ({x9}, (7.086e-01, 2.913e-01)) # ({x10}, (5.748e-01, 4.252e-01)) # ({x11}, (5.360e-01, 4.640e-01)) # ({x12}, (3.542e-01, 6.458e-01)) # ({x13}, (9.037e-01, 9.631e-02)) # ({x14}, (2.427e-01, 7.573e-01)) # ({x15}, (6.915e-01, 3.085e-01)) GLC+_FULLCAV_LOOP3 3.871e-05 9.116e-06 1.157e-04 1.534e-05 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.800e-01, 7.200e-01)) # ({x9}, (7.084e-01, 2.916e-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)) GLC_UNICAV_LOOP4 5.304e-03 1.690e-03 N/A N/A N/A 1.000e-09 # ({x0}, (3.512e-01, 6.488e-01)) # ({x1}, (6.430e-01, 3.570e-01)) # ({x2}, (4.992e-01, 5.008e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.729e-01, 6.271e-01)) # ({x5}, (6.365e-01, 3.635e-01)) # ({x6}, (5.773e-01, 4.227e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.842e-01, 7.158e-01)) # ({x9}, (7.030e-01, 2.970e-01)) # ({x10}, (5.756e-01, 4.244e-01)) # ({x11}, (5.363e-01, 4.637e-01)) # ({x12}, (3.555e-01, 6.445e-01)) # ({x13}, (9.035e-01, 9.653e-02)) # ({x14}, (2.412e-01, 7.588e-01)) # ({x15}, (6.913e-01, 3.087e-01)) GLC_FULLCAV_LOOP4 5.304e-03 1.690e-03 N/A N/A N/A 1.000e-09 # ({x0}, (3.512e-01, 6.488e-01)) # ({x1}, (6.430e-01, 3.570e-01)) # ({x2}, (4.992e-01, 5.008e-01)) # ({x3}, (3.049e-01, 6.951e-01)) # ({x4}, (3.729e-01, 6.271e-01)) # ({x5}, (6.365e-01, 3.635e-01)) # ({x6}, (5.773e-01, 4.227e-01)) # ({x7}, (5.437e-01, 4.563e-01)) # ({x8}, (2.842e-01, 7.158e-01)) # ({x9}, (7.030e-01, 2.970e-01)) # ({x10}, (5.756e-01, 4.244e-01)) # ({x11}, (5.363e-01, 4.637e-01)) # ({x12}, (3.555e-01, 6.445e-01)) # ({x13}, (9.035e-01, 9.653e-02)) # ({x14}, (2.412e-01, 7.588e-01)) # ({x15}, (6.913e-01, 3.087e-01)) GLC+_UNICAV_LOOP4 5.578e-06 1.980e-06 3.523e-05 6.616e-06 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.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.616e-02)) # ({x14}, (2.408e-01, 7.592e-01)) # ({x15}, (6.910e-01, 3.090e-01)) GLC+_UNICAV_LOOP5 5.578e-06 1.980e-06 3.523e-05 6.616e-06 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.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.616e-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.3.2/tests/hoi4.fg0000644000175000017500000000123511235602301014505 0ustar jorismjorism# 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.3.2/tests/hoi1.fg0000644000175000017500000000123111235602300014475 0ustar jorismjorism# 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.3.2/tests/aliases.conf0000644000175000017500000004560012042452776015640 0ustar jorismjorism# 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] #-------GLC(+)-------------- GLC_UNICAV_SINGLE: GLC[rgntype=SINGLE,cavity=UNIFORM,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=EXACT,inaiopts=[],tol=1e-9,verbose=0] GLC_PAIRCAV_SINGLE: GLC[rgntype=SINGLE,cavity=PAIR,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=EXACT,inaiopts=[],tol=1e-9] GLC_PAIR2CAV_SINGLE: GLC[rgntype=SINGLE,cavity=PAIR2,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=EXACT,inaiopts=[],tol=1e-9] GLC_FULLCAV_SINGLE: GLC[rgntype=SINGLE,cavity=FULL,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=EXACT,inaiopts=[],tol=1e-9] GLC+_UNICAV_FACTOR: GLC[rgntype=OVFACTOR,cavity=UNIFORM,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=JTREE,inaiopts=[inference=SUMPROD,updates=HUGIN],tol=1e-9] GLC+_FULLCAV_FACTOR: GLC[rgntype=OVFACTOR,cavity=FULL,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=EXACT,inaiopts=[],tol=1e-9] GLC+_UNICAV_LOOP3: GLC[rgntype=OVLOOP,loopdepth=3,cavity=UNIFORM,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=JTREE,inaiopts=[inference=SUMPROD,updates=HUGIN],tol=1e-9] GLC+_FULLCAV_LOOP3: GLC[rgntype=OVLOOP,loopdepth=3,cavity=FULL,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=EXACT,inaiopts=[],tol=1e-9] GLC_UNICAV_LOOP4: GLC[rgntype=LOOP,loopdepth=4,cavity=UNIFORM,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=JTREE,inaiopts=[inference=SUMPROD,updates=HUGIN],tol=1e-9] GLC_FULLCAV_LOOP4: GLC[rgntype=LOOP,loopdepth=4,cavity=UNIFORM,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=EXACT,inaiopts=[],tol=1e-9] GLC+_UNICAV_LOOP4: GLC[rgntype=OVLOOP,loopdepth=4,cavity=UNIFORM,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=JTREE,inaiopts=[inference=SUMPROD,updates=HUGIN],tol=1e-9] GLC+_FULLCAV_LOOP4: GLC[rgntype=OVLOOP,loopdepth=4,cavity=FULL,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=EXACT,inaiopts=[],tol=1e-9] GLC+_UNICAV_LOOP5: GLC[rgntype=OVLOOP,loopdepth=5,cavity=UNIFORM,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=JTREE,inaiopts=[inference=SUMPROD,updates=HUGIN],tol=1e-9] GLC+_FULLCAV_LOOP5: GLC[rgntype=OVLOOP,loopdepth=5,cavity=FULL,updates=SEQRND,maxiter=10000,tol=1e-9,cavainame=BP,cavaiopts=[updates=SEQMAX,tol=1e-9,maxiter=10000,logdomain=0],inainame=EXACT,inaiopts=[],tol=1e-9] libDAI-0.3.2/tests/hoi3.fg0000644000175000017500000000123611235602301014505 0ustar jorismjorism# 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.3.2/tests/testregression.bat0000755000175000017500000000017411235602301017100 0ustar jorismjorismtestall testfast.fg | sed "s/\(e[+-]\)0/\1/g" > testfast.out.tmp diff -s testfast.out.tmp testfast.out del testfast.out.tmp libDAI-0.3.2/tests/alarm.fg0000644000175000017500000004107411235602300014742 0ustar jorismjorism# 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.3.2/tests/testdai.cpp0000644000175000017500000004175712451267654015525 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.getCode() == 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.getCode() == 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.getCode() == 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.getCode() == 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 ); // 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.3.2/tests/testfast.fg0000644000175000017500000000453011605021575015511 0ustar jorismjorism# 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.3.2/tests/maxprodbug3.fg0000644000175000017500000023405211605021575016113 0ustar jorismjorism25 2 9 19 8 2 8 8 0.353730 9 0.248852 10 0.474271 11 0.727656 12 0.460699 5 0.827078 6 0.683060 7 0.965001 2 1 11 27 1 27 0 0.213525 1 0.029426 2 0.426186 3 0.937233 4 0.944460 5 0.917238 6 0.606650 7 0.695628 8 0.109687 9 0.660242 10 0.852626 11 0.616040 12 0.428290 13 0.325841 14 0.423286 15 0.478041 16 0.790551 17 0.603138 18 0.114287 19 0.157221 20 0.070385 21 0.976143 22 0.840699 23 0.176599 24 0.502327 25 0.121862 26 0.675613 2 8 18 8 2 8 8 0.353730 9 0.248852 10 0.474271 11 0.727656 12 0.460699 5 0.827078 6 0.683060 7 0.965001 3 10 11 20 1 1 1 1 0 1.000000 2 3 5 33 39 1287 561 0.037369 231 0.022984 264 0.001267 297 0.037733 462 0.009309 363 0.016339 396 0.039048 429 0.015038 1023 0.032211 957 0.043261 990 0.043881 858 0.016487 1056 0.005674 1122 0.037937 1155 0.042788 1221 0.009568 1254 0.033646 1089 0.028035 660 0.041890 66 0.041794 132 0.021378 330 0.033912 0 0.028408 99 0.005992 495 0.042820 528 0.023709 198 0.007244 594 0.039988 627 0.035330 693 0.018541 726 0.022735 759 0.027452 792 0.032487 825 0.009538 165 0.015457 891 0.026392 924 0.010019 33 0.037265 1188 0.005075 562 0.037369 232 0.022984 265 0.001267 298 0.037733 463 0.009309 364 0.016339 397 0.039048 430 0.015038 1024 0.032211 958 0.043261 991 0.043881 859 0.016487 1057 0.005674 1123 0.037937 1156 0.042788 1222 0.009568 1255 0.033646 1090 0.028035 661 0.041890 67 0.041794 133 0.021378 331 0.033912 1 0.028408 100 0.005992 496 0.042820 529 0.023709 199 0.007244 595 0.039988 628 0.035330 694 0.018541 727 0.022735 760 0.027452 793 0.032487 826 0.009538 166 0.015457 892 0.026392 925 0.010019 34 0.037265 1189 0.005075 563 0.037369 233 0.022984 266 0.001267 299 0.037733 464 0.009309 365 0.016339 398 0.039048 431 0.015038 1025 0.032211 959 0.043261 992 0.043881 860 0.016487 1058 0.005674 1124 0.037937 1157 0.042788 1223 0.009568 1256 0.033646 1091 0.028035 662 0.041890 68 0.041794 134 0.021378 332 0.033912 2 0.028408 101 0.005992 497 0.042820 530 0.023709 200 0.007244 596 0.039988 629 0.035330 695 0.018541 728 0.022735 761 0.027452 794 0.032487 827 0.009538 167 0.015457 893 0.026392 926 0.010019 35 0.037265 1190 0.005075 564 0.037369 234 0.022984 267 0.001267 300 0.037733 465 0.009309 366 0.016339 399 0.039048 432 0.015038 1026 0.032211 960 0.043261 993 0.043881 861 0.016487 1059 0.005674 1125 0.037937 1158 0.042788 1224 0.009568 1257 0.033646 1092 0.028035 663 0.041890 69 0.041794 135 0.021378 333 0.033912 3 0.028408 102 0.005992 498 0.042820 531 0.023709 201 0.007244 597 0.039988 630 0.035330 696 0.018541 729 0.022735 762 0.027452 795 0.032487 828 0.009538 168 0.015457 894 0.026392 927 0.010019 36 0.037265 1191 0.005075 565 0.037369 235 0.022984 268 0.001267 301 0.037733 466 0.009309 367 0.016339 400 0.039048 433 0.015038 1027 0.032211 961 0.043261 994 0.043881 862 0.016487 1060 0.005674 1126 0.037937 1159 0.042788 1225 0.009568 1258 0.033646 1093 0.028035 664 0.041890 70 0.041794 136 0.021378 334 0.033912 4 0.028408 103 0.005992 499 0.042820 532 0.023709 202 0.007244 598 0.039988 631 0.035330 697 0.018541 730 0.022735 763 0.027452 796 0.032487 829 0.009538 169 0.015457 895 0.026392 928 0.010019 37 0.037265 1192 0.005075 566 0.037369 236 0.022984 269 0.001267 302 0.037733 467 0.009309 368 0.016339 401 0.039048 434 0.015038 1028 0.032211 962 0.043261 995 0.043881 863 0.016487 1061 0.005674 1127 0.037937 1160 0.042788 1226 0.009568 1259 0.033646 1094 0.028035 665 0.041890 71 0.041794 137 0.021378 335 0.033912 5 0.028408 104 0.005992 500 0.042820 533 0.023709 203 0.007244 599 0.039988 632 0.035330 698 0.018541 731 0.022735 764 0.027452 797 0.032487 830 0.009538 170 0.015457 896 0.026392 929 0.010019 38 0.037265 1193 0.005075 567 0.037369 237 0.022984 270 0.001267 303 0.037733 468 0.009309 369 0.016339 402 0.039048 435 0.015038 1029 0.032211 963 0.043261 996 0.043881 864 0.016487 1062 0.005674 1128 0.037937 1161 0.042788 1227 0.009568 1260 0.033646 1095 0.028035 666 0.041890 72 0.041794 138 0.021378 336 0.033912 6 0.028408 105 0.005992 501 0.042820 534 0.023709 204 0.007244 600 0.039988 633 0.035330 699 0.018541 732 0.022735 765 0.027452 798 0.032487 831 0.009538 171 0.015457 897 0.026392 930 0.010019 39 0.037265 1194 0.005075 568 0.037369 238 0.022984 271 0.001267 304 0.037733 469 0.009309 370 0.016339 403 0.039048 436 0.015038 1030 0.032211 964 0.043261 997 0.043881 865 0.016487 1063 0.005674 1129 0.037937 1162 0.042788 1228 0.009568 1261 0.033646 1096 0.028035 667 0.041890 73 0.041794 139 0.021378 337 0.033912 7 0.028408 106 0.005992 502 0.042820 535 0.023709 205 0.007244 601 0.039988 634 0.035330 700 0.018541 733 0.022735 766 0.027452 799 0.032487 832 0.009538 172 0.015457 898 0.026392 931 0.010019 40 0.037265 1195 0.005075 569 0.037369 239 0.022984 272 0.001267 305 0.037733 470 0.009309 371 0.016339 404 0.039048 437 0.015038 1031 0.032211 965 0.043261 998 0.043881 866 0.016487 1064 0.005674 1130 0.037937 1163 0.042788 1229 0.009568 1262 0.033646 1097 0.028035 668 0.041890 74 0.041794 140 0.021378 338 0.033912 8 0.028408 107 0.005992 503 0.042820 536 0.023709 206 0.007244 602 0.039988 635 0.035330 701 0.018541 734 0.022735 767 0.027452 800 0.032487 833 0.009538 173 0.015457 899 0.026392 932 0.010019 41 0.037265 1196 0.005075 570 0.037369 240 0.022984 273 0.001267 306 0.037733 471 0.009309 372 0.016339 405 0.039048 438 0.015038 1032 0.032211 966 0.043261 999 0.043881 867 0.016487 1065 0.005674 1131 0.037937 1164 0.042788 1230 0.009568 1263 0.033646 1098 0.028035 669 0.041890 75 0.041794 141 0.021378 339 0.033912 9 0.028408 108 0.005992 504 0.042820 537 0.023709 207 0.007244 603 0.039988 636 0.035330 702 0.018541 735 0.022735 768 0.027452 801 0.032487 834 0.009538 174 0.015457 900 0.026392 933 0.010019 42 0.037265 1197 0.005075 571 0.037369 241 0.022984 274 0.001267 307 0.037733 472 0.009309 373 0.016339 406 0.039048 439 0.015038 1033 0.032211 967 0.043261 1000 0.043881 868 0.016487 1066 0.005674 1132 0.037937 1165 0.042788 1231 0.009568 1264 0.033646 1099 0.028035 670 0.041890 76 0.041794 142 0.021378 340 0.033912 10 0.028408 109 0.005992 505 0.042820 538 0.023709 208 0.007244 604 0.039988 637 0.035330 703 0.018541 736 0.022735 769 0.027452 802 0.032487 835 0.009538 175 0.015457 901 0.026392 934 0.010019 43 0.037265 1198 0.005075 572 0.037369 242 0.022984 275 0.001267 308 0.037733 473 0.009309 374 0.016339 407 0.039048 440 0.015038 1034 0.032211 968 0.043261 1001 0.043881 869 0.016487 1067 0.005674 1133 0.037937 1166 0.042788 1232 0.009568 1265 0.033646 1100 0.028035 671 0.041890 77 0.041794 143 0.021378 341 0.033912 11 0.028408 110 0.005992 506 0.042820 539 0.023709 209 0.007244 605 0.039988 638 0.035330 704 0.018541 737 0.022735 770 0.027452 803 0.032487 836 0.009538 176 0.015457 902 0.026392 935 0.010019 44 0.037265 1199 0.005075 573 0.037369 243 0.022984 276 0.001267 309 0.037733 474 0.009309 375 0.016339 408 0.039048 441 0.015038 1035 0.032211 969 0.043261 1002 0.043881 870 0.016487 1068 0.005674 1134 0.037937 1167 0.042788 1233 0.009568 1266 0.033646 1101 0.028035 672 0.041890 78 0.041794 144 0.021378 342 0.033912 12 0.028408 111 0.005992 507 0.042820 540 0.023709 210 0.007244 606 0.039988 639 0.035330 705 0.018541 738 0.022735 771 0.027452 804 0.032487 837 0.009538 177 0.015457 903 0.026392 936 0.010019 45 0.037265 1200 0.005075 574 0.037369 244 0.022984 277 0.001267 310 0.037733 475 0.009309 376 0.016339 409 0.039048 442 0.015038 1036 0.032211 970 0.043261 1003 0.043881 871 0.016487 1069 0.005674 1135 0.037937 1168 0.042788 1234 0.009568 1267 0.033646 1102 0.028035 673 0.041890 79 0.041794 145 0.021378 343 0.033912 13 0.028408 112 0.005992 508 0.042820 541 0.023709 211 0.007244 607 0.039988 640 0.035330 706 0.018541 739 0.022735 772 0.027452 805 0.032487 838 0.009538 178 0.015457 904 0.026392 937 0.010019 46 0.037265 1201 0.005075 575 0.037369 245 0.022984 278 0.001267 311 0.037733 476 0.009309 377 0.016339 410 0.039048 443 0.015038 1037 0.032211 971 0.043261 1004 0.043881 872 0.016487 1070 0.005674 1136 0.037937 1169 0.042788 1235 0.009568 1268 0.033646 1103 0.028035 674 0.041890 80 0.041794 146 0.021378 344 0.033912 14 0.028408 113 0.005992 509 0.042820 542 0.023709 212 0.007244 608 0.039988 641 0.035330 707 0.018541 740 0.022735 773 0.027452 806 0.032487 839 0.009538 179 0.015457 905 0.026392 938 0.010019 47 0.037265 1202 0.005075 576 0.037369 246 0.022984 279 0.001267 312 0.037733 477 0.009309 378 0.016339 411 0.039048 444 0.015038 1038 0.032211 972 0.043261 1005 0.043881 873 0.016487 1071 0.005674 1137 0.037937 1170 0.042788 1236 0.009568 1269 0.033646 1104 0.028035 675 0.041890 81 0.041794 147 0.021378 345 0.033912 15 0.028408 114 0.005992 510 0.042820 543 0.023709 213 0.007244 609 0.039988 642 0.035330 708 0.018541 741 0.022735 774 0.027452 807 0.032487 840 0.009538 180 0.015457 906 0.026392 939 0.010019 48 0.037265 1203 0.005075 577 0.037369 247 0.022984 280 0.001267 313 0.037733 478 0.009309 379 0.016339 412 0.039048 445 0.015038 1039 0.032211 973 0.043261 1006 0.043881 874 0.016487 1072 0.005674 1138 0.037937 1171 0.042788 1237 0.009568 1270 0.033646 1105 0.028035 676 0.041890 82 0.041794 148 0.021378 346 0.033912 16 0.028408 115 0.005992 511 0.042820 544 0.023709 214 0.007244 610 0.039988 643 0.035330 709 0.018541 742 0.022735 775 0.027452 808 0.032487 841 0.009538 181 0.015457 907 0.026392 940 0.010019 49 0.037265 1204 0.005075 578 0.037369 248 0.022984 281 0.001267 314 0.037733 479 0.009309 380 0.016339 413 0.039048 446 0.015038 1040 0.032211 974 0.043261 1007 0.043881 875 0.016487 1073 0.005674 1139 0.037937 1172 0.042788 1238 0.009568 1271 0.033646 1106 0.028035 677 0.041890 83 0.041794 149 0.021378 347 0.033912 17 0.028408 116 0.005992 512 0.042820 545 0.023709 215 0.007244 611 0.039988 644 0.035330 710 0.018541 743 0.022735 776 0.027452 809 0.032487 842 0.009538 182 0.015457 908 0.026392 941 0.010019 50 0.037265 1205 0.005075 579 0.037369 249 0.022984 282 0.001267 315 0.037733 480 0.009309 381 0.016339 414 0.039048 447 0.015038 1041 0.032211 975 0.043261 1008 0.043881 876 0.016487 1074 0.005674 1140 0.037937 1173 0.042788 1239 0.009568 1272 0.033646 1107 0.028035 678 0.041890 84 0.041794 150 0.021378 348 0.033912 18 0.028408 117 0.005992 513 0.042820 546 0.023709 216 0.007244 612 0.039988 645 0.035330 711 0.018541 744 0.022735 777 0.027452 810 0.032487 843 0.009538 183 0.015457 909 0.026392 942 0.010019 51 0.037265 1206 0.005075 580 0.037369 250 0.022984 283 0.001267 316 0.037733 481 0.009309 382 0.016339 415 0.039048 448 0.015038 1042 0.032211 976 0.043261 1009 0.043881 877 0.016487 1075 0.005674 1141 0.037937 1174 0.042788 1240 0.009568 1273 0.033646 1108 0.028035 679 0.041890 85 0.041794 151 0.021378 349 0.033912 19 0.028408 118 0.005992 514 0.042820 547 0.023709 217 0.007244 613 0.039988 646 0.035330 712 0.018541 745 0.022735 778 0.027452 811 0.032487 844 0.009538 184 0.015457 910 0.026392 943 0.010019 52 0.037265 1207 0.005075 581 0.037369 251 0.022984 284 0.001267 317 0.037733 482 0.009309 383 0.016339 416 0.039048 449 0.015038 1043 0.032211 977 0.043261 1010 0.043881 878 0.016487 1076 0.005674 1142 0.037937 1175 0.042788 1241 0.009568 1274 0.033646 1109 0.028035 680 0.041890 86 0.041794 152 0.021378 350 0.033912 20 0.028408 119 0.005992 515 0.042820 548 0.023709 218 0.007244 614 0.039988 647 0.035330 713 0.018541 746 0.022735 779 0.027452 812 0.032487 845 0.009538 185 0.015457 911 0.026392 944 0.010019 53 0.037265 1208 0.005075 582 0.037369 252 0.022984 285 0.001267 318 0.037733 483 0.009309 384 0.016339 417 0.039048 450 0.015038 1044 0.032211 978 0.043261 1011 0.043881 879 0.016487 1077 0.005674 1143 0.037937 1176 0.042788 1242 0.009568 1275 0.033646 1110 0.028035 681 0.041890 87 0.041794 153 0.021378 351 0.033912 21 0.028408 120 0.005992 516 0.042820 549 0.023709 219 0.007244 615 0.039988 648 0.035330 714 0.018541 747 0.022735 780 0.027452 813 0.032487 846 0.009538 186 0.015457 912 0.026392 945 0.010019 54 0.037265 1209 0.005075 583 0.037369 253 0.022984 286 0.001267 319 0.037733 484 0.009309 385 0.016339 418 0.039048 451 0.015038 1045 0.032211 979 0.043261 1012 0.043881 880 0.016487 1078 0.005674 1144 0.037937 1177 0.042788 1243 0.009568 1276 0.033646 1111 0.028035 682 0.041890 88 0.041794 154 0.021378 352 0.033912 22 0.028408 121 0.005992 517 0.042820 550 0.023709 220 0.007244 616 0.039988 649 0.035330 715 0.018541 748 0.022735 781 0.027452 814 0.032487 847 0.009538 187 0.015457 913 0.026392 946 0.010019 55 0.037265 1210 0.005075 584 0.037369 254 0.022984 287 0.001267 320 0.037733 485 0.009309 386 0.016339 419 0.039048 452 0.015038 1046 0.032211 980 0.043261 1013 0.043881 881 0.016487 1079 0.005674 1145 0.037937 1178 0.042788 1244 0.009568 1277 0.033646 1112 0.028035 683 0.041890 89 0.041794 155 0.021378 353 0.033912 23 0.028408 122 0.005992 518 0.042820 551 0.023709 221 0.007244 617 0.039988 650 0.035330 716 0.018541 749 0.022735 782 0.027452 815 0.032487 848 0.009538 188 0.015457 914 0.026392 947 0.010019 56 0.037265 1211 0.005075 585 0.037369 255 0.022984 288 0.001267 321 0.037733 486 0.009309 387 0.016339 420 0.039048 453 0.015038 1047 0.032211 981 0.043261 1014 0.043881 882 0.016487 1080 0.005674 1146 0.037937 1179 0.042788 1245 0.009568 1278 0.033646 1113 0.028035 684 0.041890 90 0.041794 156 0.021378 354 0.033912 24 0.028408 123 0.005992 519 0.042820 552 0.023709 222 0.007244 618 0.039988 651 0.035330 717 0.018541 750 0.022735 783 0.027452 816 0.032487 849 0.009538 189 0.015457 915 0.026392 948 0.010019 57 0.037265 1212 0.005075 586 0.037369 256 0.022984 289 0.001267 322 0.037733 487 0.009309 388 0.016339 421 0.039048 454 0.015038 1048 0.032211 982 0.043261 1015 0.043881 883 0.016487 1081 0.005674 1147 0.037937 1180 0.042788 1246 0.009568 1279 0.033646 1114 0.028035 685 0.041890 91 0.041794 157 0.021378 355 0.033912 25 0.028408 124 0.005992 520 0.042820 553 0.023709 223 0.007244 619 0.039988 652 0.035330 718 0.018541 751 0.022735 784 0.027452 817 0.032487 850 0.009538 190 0.015457 916 0.026392 949 0.010019 58 0.037265 1213 0.005075 587 0.037369 257 0.022984 290 0.001267 323 0.037733 488 0.009309 389 0.016339 422 0.039048 455 0.015038 1049 0.032211 983 0.043261 1016 0.043881 884 0.016487 1082 0.005674 1148 0.037937 1181 0.042788 1247 0.009568 1280 0.033646 1115 0.028035 686 0.041890 92 0.041794 158 0.021378 356 0.033912 26 0.028408 125 0.005992 521 0.042820 554 0.023709 224 0.007244 620 0.039988 653 0.035330 719 0.018541 752 0.022735 785 0.027452 818 0.032487 851 0.009538 191 0.015457 917 0.026392 950 0.010019 59 0.037265 1214 0.005075 588 0.037369 258 0.022984 291 0.001267 324 0.037733 489 0.009309 390 0.016339 423 0.039048 456 0.015038 1050 0.032211 984 0.043261 1017 0.043881 885 0.016487 1083 0.005674 1149 0.037937 1182 0.042788 1248 0.009568 1281 0.033646 1116 0.028035 687 0.041890 93 0.041794 159 0.021378 357 0.033912 27 0.028408 126 0.005992 522 0.042820 555 0.023709 225 0.007244 621 0.039988 654 0.035330 720 0.018541 753 0.022735 786 0.027452 819 0.032487 852 0.009538 192 0.015457 918 0.026392 951 0.010019 60 0.037265 1215 0.005075 589 0.037369 259 0.022984 292 0.001267 325 0.037733 490 0.009309 391 0.016339 424 0.039048 457 0.015038 1051 0.032211 985 0.043261 1018 0.043881 886 0.016487 1084 0.005674 1150 0.037937 1183 0.042788 1249 0.009568 1282 0.033646 1117 0.028035 688 0.041890 94 0.041794 160 0.021378 358 0.033912 28 0.028408 127 0.005992 523 0.042820 556 0.023709 226 0.007244 622 0.039988 655 0.035330 721 0.018541 754 0.022735 787 0.027452 820 0.032487 853 0.009538 193 0.015457 919 0.026392 952 0.010019 61 0.037265 1216 0.005075 590 0.037369 260 0.022984 293 0.001267 326 0.037733 491 0.009309 392 0.016339 425 0.039048 458 0.015038 1052 0.032211 986 0.043261 1019 0.043881 887 0.016487 1085 0.005674 1151 0.037937 1184 0.042788 1250 0.009568 1283 0.033646 1118 0.028035 689 0.041890 95 0.041794 161 0.021378 359 0.033912 29 0.028408 128 0.005992 524 0.042820 557 0.023709 227 0.007244 623 0.039988 656 0.035330 722 0.018541 755 0.022735 788 0.027452 821 0.032487 854 0.009538 194 0.015457 920 0.026392 953 0.010019 62 0.037265 1217 0.005075 591 0.037369 261 0.022984 294 0.001267 327 0.037733 492 0.009309 393 0.016339 426 0.039048 459 0.015038 1053 0.032211 987 0.043261 1020 0.043881 888 0.016487 1086 0.005674 1152 0.037937 1185 0.042788 1251 0.009568 1284 0.033646 1119 0.028035 690 0.041890 96 0.041794 162 0.021378 360 0.033912 30 0.028408 129 0.005992 525 0.042820 558 0.023709 228 0.007244 624 0.039988 657 0.035330 723 0.018541 756 0.022735 789 0.027452 822 0.032487 855 0.009538 195 0.015457 921 0.026392 954 0.010019 63 0.037265 1218 0.005075 592 0.037369 262 0.022984 295 0.001267 328 0.037733 493 0.009309 394 0.016339 427 0.039048 460 0.015038 1054 0.032211 988 0.043261 1021 0.043881 889 0.016487 1087 0.005674 1153 0.037937 1186 0.042788 1252 0.009568 1285 0.033646 1120 0.028035 691 0.041890 97 0.041794 163 0.021378 361 0.033912 31 0.028408 130 0.005992 526 0.042820 559 0.023709 229 0.007244 625 0.039988 658 0.035330 724 0.018541 757 0.022735 790 0.027452 823 0.032487 856 0.009538 196 0.015457 922 0.026392 955 0.010019 64 0.037265 1219 0.005075 593 0.037369 263 0.022984 296 0.001267 329 0.037733 494 0.009309 395 0.016339 428 0.039048 461 0.015038 1055 0.032211 989 0.043261 1022 0.043881 890 0.016487 1088 0.005674 1154 0.037937 1187 0.042788 1253 0.009568 1286 0.033646 1121 0.028035 692 0.041890 98 0.041794 164 0.021378 362 0.033912 32 0.028408 131 0.005992 527 0.042820 560 0.023709 230 0.007244 626 0.039988 659 0.035330 725 0.018541 758 0.022735 791 0.027452 824 0.032487 857 0.009538 197 0.015457 923 0.026392 956 0.010019 65 0.037265 1220 0.005075 3 18 19 24 2 2 1 2 2 1.000000 1 1.000000 2 6 8 16 8 128 0 0.062977 16 0.269346 32 0.082001 48 0.209981 64 0.109436 80 0.167129 96 0.077156 112 0.021974 1 0.062977 17 0.269346 33 0.082001 49 0.209981 65 0.109436 81 0.167129 97 0.077156 113 0.021974 2 0.062977 18 0.269346 34 0.082001 50 0.209981 66 0.109436 82 0.167129 98 0.077156 114 0.021974 3 0.062977 19 0.269346 35 0.082001 51 0.209981 67 0.109436 83 0.167129 99 0.077156 115 0.021974 4 0.062977 20 0.269346 36 0.082001 52 0.209981 68 0.109436 84 0.167129 100 0.077156 116 0.021974 5 0.062977 21 0.269346 37 0.082001 53 0.209981 69 0.109436 85 0.167129 101 0.077156 117 0.021974 6 0.062977 22 0.269346 38 0.082001 54 0.209981 70 0.109436 86 0.167129 102 0.077156 118 0.021974 7 0.062977 23 0.269346 39 0.082001 55 0.209981 71 0.109436 87 0.167129 103 0.077156 119 0.021974 8 0.062977 24 0.269346 40 0.082001 56 0.209981 72 0.109436 88 0.167129 104 0.077156 120 0.021974 9 0.062977 25 0.269346 41 0.082001 57 0.209981 73 0.109436 89 0.167129 105 0.077156 121 0.021974 10 0.062977 26 0.269346 42 0.082001 58 0.209981 74 0.109436 90 0.167129 106 0.077156 122 0.021974 11 0.062977 27 0.269346 43 0.082001 59 0.209981 75 0.109436 91 0.167129 107 0.077156 123 0.021974 12 0.062977 28 0.269346 44 0.082001 60 0.209981 76 0.109436 92 0.167129 108 0.077156 124 0.021974 13 0.062977 29 0.269346 45 0.082001 61 0.209981 77 0.109436 93 0.167129 109 0.077156 125 0.021974 14 0.062977 30 0.269346 46 0.082001 62 0.209981 78 0.109436 94 0.167129 110 0.077156 126 0.021974 15 0.062977 31 0.269346 47 0.082001 63 0.209981 79 0.109436 95 0.167129 111 0.077156 127 0.021974 3 14 15 22 2 2 1 2 2 1.000000 1 1.000000 1 1 27 27 0 0.013045 1 0.015003 2 0.015908 3 0.032127 4 0.028694 5 0.047807 6 0.029714 9 0.028389 10 0.031943 11 0.006187 12 0.057942 13 0.048390 14 0.061707 16 0.046532 23 0.053173 19 0.049666 15 0.053604 7 0.029841 8 0.046227 26 0.016579 21 0.054866 22 0.049434 20 0.061138 17 0.022464 18 0.019233 24 0.054571 25 0.025817 2 6 16 16 2 16 16 0.321459 17 0.983510 18 0.004694 19 0.084624 20 0.629796 21 0.067153 6 0.119949 7 0.483484 8 0.616065 9 0.302564 10 0.460740 11 0.422487 12 0.001786 13 0.055548 14 0.476132 15 0.096033 2 7 9 16 8 128 0 0.062977 16 0.269346 32 0.082001 48 0.209981 64 0.109436 80 0.167129 96 0.077156 112 0.021974 1 0.062977 17 0.269346 33 0.082001 49 0.209981 65 0.109436 81 0.167129 97 0.077156 113 0.021974 2 0.062977 18 0.269346 34 0.082001 50 0.209981 66 0.109436 82 0.167129 98 0.077156 114 0.021974 3 0.062977 19 0.269346 35 0.082001 51 0.209981 67 0.109436 83 0.167129 99 0.077156 115 0.021974 4 0.062977 20 0.269346 36 0.082001 52 0.209981 68 0.109436 84 0.167129 100 0.077156 116 0.021974 5 0.062977 21 0.269346 37 0.082001 53 0.209981 69 0.109436 85 0.167129 101 0.077156 117 0.021974 6 0.062977 22 0.269346 38 0.082001 54 0.209981 70 0.109436 86 0.167129 102 0.077156 118 0.021974 7 0.062977 23 0.269346 39 0.082001 55 0.209981 71 0.109436 87 0.167129 103 0.077156 119 0.021974 8 0.062977 24 0.269346 40 0.082001 56 0.209981 72 0.109436 88 0.167129 104 0.077156 120 0.021974 9 0.062977 25 0.269346 41 0.082001 57 0.209981 73 0.109436 89 0.167129 105 0.077156 121 0.021974 10 0.062977 26 0.269346 42 0.082001 58 0.209981 74 0.109436 90 0.167129 106 0.077156 122 0.021974 11 0.062977 27 0.269346 43 0.082001 59 0.209981 75 0.109436 91 0.167129 107 0.077156 123 0.021974 12 0.062977 28 0.269346 44 0.082001 60 0.209981 76 0.109436 92 0.167129 108 0.077156 124 0.021974 13 0.062977 29 0.269346 45 0.082001 61 0.209981 77 0.109436 93 0.167129 109 0.077156 125 0.021974 14 0.062977 30 0.269346 46 0.082001 62 0.209981 78 0.109436 94 0.167129 110 0.077156 126 0.021974 15 0.062977 31 0.269346 47 0.082001 63 0.209981 79 0.109436 95 0.167129 111 0.077156 127 0.021974 2 7 17 16 2 16 16 0.321459 17 0.983510 18 0.004694 19 0.084624 20 0.629796 21 0.067153 6 0.119949 7 0.483484 8 0.616065 9 0.302564 10 0.460740 11 0.422487 12 0.001786 13 0.055548 14 0.476132 15 0.096033 2 1 3 27 33 891 756 0.033250 783 0.038373 135 0.007428 162 0.036410 216 0.058566 243 0.020644 270 0.025517 324 0.030151 351 0.042916 378 0.053412 405 0.003348 27 0.027843 729 0.045796 81 0.020860 648 0.014792 675 0.024139 702 0.052849 0 0.039890 297 0.043977 189 0.028105 864 0.049056 432 0.004283 459 0.024615 486 0.012581 513 0.020798 540 0.053555 567 0.053124 594 0.027697 621 0.018077 54 0.012288 108 0.008018 810 0.027992 837 0.039652 757 0.033250 784 0.038373 136 0.007428 163 0.036410 217 0.058566 244 0.020644 271 0.025517 325 0.030151 352 0.042916 379 0.053412 406 0.003348 28 0.027843 730 0.045796 82 0.020860 649 0.014792 676 0.024139 703 0.052849 1 0.039890 298 0.043977 190 0.028105 865 0.049056 433 0.004283 460 0.024615 487 0.012581 514 0.020798 541 0.053555 568 0.053124 595 0.027697 622 0.018077 55 0.012288 109 0.008018 811 0.027992 838 0.039652 758 0.033250 785 0.038373 137 0.007428 164 0.036410 218 0.058566 245 0.020644 272 0.025517 326 0.030151 353 0.042916 380 0.053412 407 0.003348 29 0.027843 731 0.045796 83 0.020860 650 0.014792 677 0.024139 704 0.052849 2 0.039890 299 0.043977 191 0.028105 866 0.049056 434 0.004283 461 0.024615 488 0.012581 515 0.020798 542 0.053555 569 0.053124 596 0.027697 623 0.018077 56 0.012288 110 0.008018 812 0.027992 839 0.039652 759 0.033250 786 0.038373 138 0.007428 165 0.036410 219 0.058566 246 0.020644 273 0.025517 327 0.030151 354 0.042916 381 0.053412 408 0.003348 30 0.027843 732 0.045796 84 0.020860 651 0.014792 678 0.024139 705 0.052849 3 0.039890 300 0.043977 192 0.028105 867 0.049056 435 0.004283 462 0.024615 489 0.012581 516 0.020798 543 0.053555 570 0.053124 597 0.027697 624 0.018077 57 0.012288 111 0.008018 813 0.027992 840 0.039652 760 0.033250 787 0.038373 139 0.007428 166 0.036410 220 0.058566 247 0.020644 274 0.025517 328 0.030151 355 0.042916 382 0.053412 409 0.003348 31 0.027843 733 0.045796 85 0.020860 652 0.014792 679 0.024139 706 0.052849 4 0.039890 301 0.043977 193 0.028105 868 0.049056 436 0.004283 463 0.024615 490 0.012581 517 0.020798 544 0.053555 571 0.053124 598 0.027697 625 0.018077 58 0.012288 112 0.008018 814 0.027992 841 0.039652 761 0.033250 788 0.038373 140 0.007428 167 0.036410 221 0.058566 248 0.020644 275 0.025517 329 0.030151 356 0.042916 383 0.053412 410 0.003348 32 0.027843 734 0.045796 86 0.020860 653 0.014792 680 0.024139 707 0.052849 5 0.039890 302 0.043977 194 0.028105 869 0.049056 437 0.004283 464 0.024615 491 0.012581 518 0.020798 545 0.053555 572 0.053124 599 0.027697 626 0.018077 59 0.012288 113 0.008018 815 0.027992 842 0.039652 762 0.033250 789 0.038373 141 0.007428 168 0.036410 222 0.058566 249 0.020644 276 0.025517 330 0.030151 357 0.042916 384 0.053412 411 0.003348 33 0.027843 735 0.045796 87 0.020860 654 0.014792 681 0.024139 708 0.052849 6 0.039890 303 0.043977 195 0.028105 870 0.049056 438 0.004283 465 0.024615 492 0.012581 519 0.020798 546 0.053555 573 0.053124 600 0.027697 627 0.018077 60 0.012288 114 0.008018 816 0.027992 843 0.039652 763 0.033250 790 0.038373 142 0.007428 169 0.036410 223 0.058566 250 0.020644 277 0.025517 331 0.030151 358 0.042916 385 0.053412 412 0.003348 34 0.027843 736 0.045796 88 0.020860 655 0.014792 682 0.024139 709 0.052849 7 0.039890 304 0.043977 196 0.028105 871 0.049056 439 0.004283 466 0.024615 493 0.012581 520 0.020798 547 0.053555 574 0.053124 601 0.027697 628 0.018077 61 0.012288 115 0.008018 817 0.027992 844 0.039652 764 0.033250 791 0.038373 143 0.007428 170 0.036410 224 0.058566 251 0.020644 278 0.025517 332 0.030151 359 0.042916 386 0.053412 413 0.003348 35 0.027843 737 0.045796 89 0.020860 656 0.014792 683 0.024139 710 0.052849 8 0.039890 305 0.043977 197 0.028105 872 0.049056 440 0.004283 467 0.024615 494 0.012581 521 0.020798 548 0.053555 575 0.053124 602 0.027697 629 0.018077 62 0.012288 116 0.008018 818 0.027992 845 0.039652 765 0.033250 792 0.038373 144 0.007428 171 0.036410 225 0.058566 252 0.020644 279 0.025517 333 0.030151 360 0.042916 387 0.053412 414 0.003348 36 0.027843 738 0.045796 90 0.020860 657 0.014792 684 0.024139 711 0.052849 9 0.039890 306 0.043977 198 0.028105 873 0.049056 441 0.004283 468 0.024615 495 0.012581 522 0.020798 549 0.053555 576 0.053124 603 0.027697 630 0.018077 63 0.012288 117 0.008018 819 0.027992 846 0.039652 766 0.033250 793 0.038373 145 0.007428 172 0.036410 226 0.058566 253 0.020644 280 0.025517 334 0.030151 361 0.042916 388 0.053412 415 0.003348 37 0.027843 739 0.045796 91 0.020860 658 0.014792 685 0.024139 712 0.052849 10 0.039890 307 0.043977 199 0.028105 874 0.049056 442 0.004283 469 0.024615 496 0.012581 523 0.020798 550 0.053555 577 0.053124 604 0.027697 631 0.018077 64 0.012288 118 0.008018 820 0.027992 847 0.039652 767 0.033250 794 0.038373 146 0.007428 173 0.036410 227 0.058566 254 0.020644 281 0.025517 335 0.030151 362 0.042916 389 0.053412 416 0.003348 38 0.027843 740 0.045796 92 0.020860 659 0.014792 686 0.024139 713 0.052849 11 0.039890 308 0.043977 200 0.028105 875 0.049056 443 0.004283 470 0.024615 497 0.012581 524 0.020798 551 0.053555 578 0.053124 605 0.027697 632 0.018077 65 0.012288 119 0.008018 821 0.027992 848 0.039652 768 0.033250 795 0.038373 147 0.007428 174 0.036410 228 0.058566 255 0.020644 282 0.025517 336 0.030151 363 0.042916 390 0.053412 417 0.003348 39 0.027843 741 0.045796 93 0.020860 660 0.014792 687 0.024139 714 0.052849 12 0.039890 309 0.043977 201 0.028105 876 0.049056 444 0.004283 471 0.024615 498 0.012581 525 0.020798 552 0.053555 579 0.053124 606 0.027697 633 0.018077 66 0.012288 120 0.008018 822 0.027992 849 0.039652 769 0.033250 796 0.038373 148 0.007428 175 0.036410 229 0.058566 256 0.020644 283 0.025517 337 0.030151 364 0.042916 391 0.053412 418 0.003348 40 0.027843 742 0.045796 94 0.020860 661 0.014792 688 0.024139 715 0.052849 13 0.039890 310 0.043977 202 0.028105 877 0.049056 445 0.004283 472 0.024615 499 0.012581 526 0.020798 553 0.053555 580 0.053124 607 0.027697 634 0.018077 67 0.012288 121 0.008018 823 0.027992 850 0.039652 770 0.033250 797 0.038373 149 0.007428 176 0.036410 230 0.058566 257 0.020644 284 0.025517 338 0.030151 365 0.042916 392 0.053412 419 0.003348 41 0.027843 743 0.045796 95 0.020860 662 0.014792 689 0.024139 716 0.052849 14 0.039890 311 0.043977 203 0.028105 878 0.049056 446 0.004283 473 0.024615 500 0.012581 527 0.020798 554 0.053555 581 0.053124 608 0.027697 635 0.018077 68 0.012288 122 0.008018 824 0.027992 851 0.039652 771 0.033250 798 0.038373 150 0.007428 177 0.036410 231 0.058566 258 0.020644 285 0.025517 339 0.030151 366 0.042916 393 0.053412 420 0.003348 42 0.027843 744 0.045796 96 0.020860 663 0.014792 690 0.024139 717 0.052849 15 0.039890 312 0.043977 204 0.028105 879 0.049056 447 0.004283 474 0.024615 501 0.012581 528 0.020798 555 0.053555 582 0.053124 609 0.027697 636 0.018077 69 0.012288 123 0.008018 825 0.027992 852 0.039652 772 0.033250 799 0.038373 151 0.007428 178 0.036410 232 0.058566 259 0.020644 286 0.025517 340 0.030151 367 0.042916 394 0.053412 421 0.003348 43 0.027843 745 0.045796 97 0.020860 664 0.014792 691 0.024139 718 0.052849 16 0.039890 313 0.043977 205 0.028105 880 0.049056 448 0.004283 475 0.024615 502 0.012581 529 0.020798 556 0.053555 583 0.053124 610 0.027697 637 0.018077 70 0.012288 124 0.008018 826 0.027992 853 0.039652 773 0.033250 800 0.038373 152 0.007428 179 0.036410 233 0.058566 260 0.020644 287 0.025517 341 0.030151 368 0.042916 395 0.053412 422 0.003348 44 0.027843 746 0.045796 98 0.020860 665 0.014792 692 0.024139 719 0.052849 17 0.039890 314 0.043977 206 0.028105 881 0.049056 449 0.004283 476 0.024615 503 0.012581 530 0.020798 557 0.053555 584 0.053124 611 0.027697 638 0.018077 71 0.012288 125 0.008018 827 0.027992 854 0.039652 774 0.033250 801 0.038373 153 0.007428 180 0.036410 234 0.058566 261 0.020644 288 0.025517 342 0.030151 369 0.042916 396 0.053412 423 0.003348 45 0.027843 747 0.045796 99 0.020860 666 0.014792 693 0.024139 720 0.052849 18 0.039890 315 0.043977 207 0.028105 882 0.049056 450 0.004283 477 0.024615 504 0.012581 531 0.020798 558 0.053555 585 0.053124 612 0.027697 639 0.018077 72 0.012288 126 0.008018 828 0.027992 855 0.039652 775 0.033250 802 0.038373 154 0.007428 181 0.036410 235 0.058566 262 0.020644 289 0.025517 343 0.030151 370 0.042916 397 0.053412 424 0.003348 46 0.027843 748 0.045796 100 0.020860 667 0.014792 694 0.024139 721 0.052849 19 0.039890 316 0.043977 208 0.028105 883 0.049056 451 0.004283 478 0.024615 505 0.012581 532 0.020798 559 0.053555 586 0.053124 613 0.027697 640 0.018077 73 0.012288 127 0.008018 829 0.027992 856 0.039652 776 0.033250 803 0.038373 155 0.007428 182 0.036410 236 0.058566 263 0.020644 290 0.025517 344 0.030151 371 0.042916 398 0.053412 425 0.003348 47 0.027843 749 0.045796 101 0.020860 668 0.014792 695 0.024139 722 0.052849 20 0.039890 317 0.043977 209 0.028105 884 0.049056 452 0.004283 479 0.024615 506 0.012581 533 0.020798 560 0.053555 587 0.053124 614 0.027697 641 0.018077 74 0.012288 128 0.008018 830 0.027992 857 0.039652 777 0.033250 804 0.038373 156 0.007428 183 0.036410 237 0.058566 264 0.020644 291 0.025517 345 0.030151 372 0.042916 399 0.053412 426 0.003348 48 0.027843 750 0.045796 102 0.020860 669 0.014792 696 0.024139 723 0.052849 21 0.039890 318 0.043977 210 0.028105 885 0.049056 453 0.004283 480 0.024615 507 0.012581 534 0.020798 561 0.053555 588 0.053124 615 0.027697 642 0.018077 75 0.012288 129 0.008018 831 0.027992 858 0.039652 778 0.033250 805 0.038373 157 0.007428 184 0.036410 238 0.058566 265 0.020644 292 0.025517 346 0.030151 373 0.042916 400 0.053412 427 0.003348 49 0.027843 751 0.045796 103 0.020860 670 0.014792 697 0.024139 724 0.052849 22 0.039890 319 0.043977 211 0.028105 886 0.049056 454 0.004283 481 0.024615 508 0.012581 535 0.020798 562 0.053555 589 0.053124 616 0.027697 643 0.018077 76 0.012288 130 0.008018 832 0.027992 859 0.039652 779 0.033250 806 0.038373 158 0.007428 185 0.036410 239 0.058566 266 0.020644 293 0.025517 347 0.030151 374 0.042916 401 0.053412 428 0.003348 50 0.027843 752 0.045796 104 0.020860 671 0.014792 698 0.024139 725 0.052849 23 0.039890 320 0.043977 212 0.028105 887 0.049056 455 0.004283 482 0.024615 509 0.012581 536 0.020798 563 0.053555 590 0.053124 617 0.027697 644 0.018077 77 0.012288 131 0.008018 833 0.027992 860 0.039652 780 0.033250 807 0.038373 159 0.007428 186 0.036410 240 0.058566 267 0.020644 294 0.025517 348 0.030151 375 0.042916 402 0.053412 429 0.003348 51 0.027843 753 0.045796 105 0.020860 672 0.014792 699 0.024139 726 0.052849 24 0.039890 321 0.043977 213 0.028105 888 0.049056 456 0.004283 483 0.024615 510 0.012581 537 0.020798 564 0.053555 591 0.053124 618 0.027697 645 0.018077 78 0.012288 132 0.008018 834 0.027992 861 0.039652 781 0.033250 808 0.038373 160 0.007428 187 0.036410 241 0.058566 268 0.020644 295 0.025517 349 0.030151 376 0.042916 403 0.053412 430 0.003348 52 0.027843 754 0.045796 106 0.020860 673 0.014792 700 0.024139 727 0.052849 25 0.039890 322 0.043977 214 0.028105 889 0.049056 457 0.004283 484 0.024615 511 0.012581 538 0.020798 565 0.053555 592 0.053124 619 0.027697 646 0.018077 79 0.012288 133 0.008018 835 0.027992 862 0.039652 782 0.033250 809 0.038373 161 0.007428 188 0.036410 242 0.058566 269 0.020644 296 0.025517 350 0.030151 377 0.042916 404 0.053412 431 0.003348 53 0.027843 755 0.045796 107 0.020860 674 0.014792 701 0.024139 728 0.052849 26 0.039890 323 0.043977 215 0.028105 890 0.049056 458 0.004283 485 0.024615 512 0.012581 539 0.020798 566 0.053555 593 0.053124 620 0.027697 647 0.018077 80 0.012288 134 0.008018 836 0.027992 863 0.039652 2 0 2 27 33 891 756 0.033250 783 0.038373 135 0.007428 162 0.036410 216 0.058566 243 0.020644 270 0.025517 324 0.030151 351 0.042916 378 0.053412 405 0.003348 27 0.027843 729 0.045796 81 0.020860 648 0.014792 675 0.024139 702 0.052849 0 0.039890 297 0.043977 189 0.028105 864 0.049056 432 0.004283 459 0.024615 486 0.012581 513 0.020798 540 0.053555 567 0.053124 594 0.027697 621 0.018077 54 0.012288 108 0.008018 810 0.027992 837 0.039652 757 0.033250 784 0.038373 136 0.007428 163 0.036410 217 0.058566 244 0.020644 271 0.025517 325 0.030151 352 0.042916 379 0.053412 406 0.003348 28 0.027843 730 0.045796 82 0.020860 649 0.014792 676 0.024139 703 0.052849 1 0.039890 298 0.043977 190 0.028105 865 0.049056 433 0.004283 460 0.024615 487 0.012581 514 0.020798 541 0.053555 568 0.053124 595 0.027697 622 0.018077 55 0.012288 109 0.008018 811 0.027992 838 0.039652 758 0.033250 785 0.038373 137 0.007428 164 0.036410 218 0.058566 245 0.020644 272 0.025517 326 0.030151 353 0.042916 380 0.053412 407 0.003348 29 0.027843 731 0.045796 83 0.020860 650 0.014792 677 0.024139 704 0.052849 2 0.039890 299 0.043977 191 0.028105 866 0.049056 434 0.004283 461 0.024615 488 0.012581 515 0.020798 542 0.053555 569 0.053124 596 0.027697 623 0.018077 56 0.012288 110 0.008018 812 0.027992 839 0.039652 759 0.033250 786 0.038373 138 0.007428 165 0.036410 219 0.058566 246 0.020644 273 0.025517 327 0.030151 354 0.042916 381 0.053412 408 0.003348 30 0.027843 732 0.045796 84 0.020860 651 0.014792 678 0.024139 705 0.052849 3 0.039890 300 0.043977 192 0.028105 867 0.049056 435 0.004283 462 0.024615 489 0.012581 516 0.020798 543 0.053555 570 0.053124 597 0.027697 624 0.018077 57 0.012288 111 0.008018 813 0.027992 840 0.039652 760 0.033250 787 0.038373 139 0.007428 166 0.036410 220 0.058566 247 0.020644 274 0.025517 328 0.030151 355 0.042916 382 0.053412 409 0.003348 31 0.027843 733 0.045796 85 0.020860 652 0.014792 679 0.024139 706 0.052849 4 0.039890 301 0.043977 193 0.028105 868 0.049056 436 0.004283 463 0.024615 490 0.012581 517 0.020798 544 0.053555 571 0.053124 598 0.027697 625 0.018077 58 0.012288 112 0.008018 814 0.027992 841 0.039652 761 0.033250 788 0.038373 140 0.007428 167 0.036410 221 0.058566 248 0.020644 275 0.025517 329 0.030151 356 0.042916 383 0.053412 410 0.003348 32 0.027843 734 0.045796 86 0.020860 653 0.014792 680 0.024139 707 0.052849 5 0.039890 302 0.043977 194 0.028105 869 0.049056 437 0.004283 464 0.024615 491 0.012581 518 0.020798 545 0.053555 572 0.053124 599 0.027697 626 0.018077 59 0.012288 113 0.008018 815 0.027992 842 0.039652 762 0.033250 789 0.038373 141 0.007428 168 0.036410 222 0.058566 249 0.020644 276 0.025517 330 0.030151 357 0.042916 384 0.053412 411 0.003348 33 0.027843 735 0.045796 87 0.020860 654 0.014792 681 0.024139 708 0.052849 6 0.039890 303 0.043977 195 0.028105 870 0.049056 438 0.004283 465 0.024615 492 0.012581 519 0.020798 546 0.053555 573 0.053124 600 0.027697 627 0.018077 60 0.012288 114 0.008018 816 0.027992 843 0.039652 763 0.033250 790 0.038373 142 0.007428 169 0.036410 223 0.058566 250 0.020644 277 0.025517 331 0.030151 358 0.042916 385 0.053412 412 0.003348 34 0.027843 736 0.045796 88 0.020860 655 0.014792 682 0.024139 709 0.052849 7 0.039890 304 0.043977 196 0.028105 871 0.049056 439 0.004283 466 0.024615 493 0.012581 520 0.020798 547 0.053555 574 0.053124 601 0.027697 628 0.018077 61 0.012288 115 0.008018 817 0.027992 844 0.039652 764 0.033250 791 0.038373 143 0.007428 170 0.036410 224 0.058566 251 0.020644 278 0.025517 332 0.030151 359 0.042916 386 0.053412 413 0.003348 35 0.027843 737 0.045796 89 0.020860 656 0.014792 683 0.024139 710 0.052849 8 0.039890 305 0.043977 197 0.028105 872 0.049056 440 0.004283 467 0.024615 494 0.012581 521 0.020798 548 0.053555 575 0.053124 602 0.027697 629 0.018077 62 0.012288 116 0.008018 818 0.027992 845 0.039652 765 0.033250 792 0.038373 144 0.007428 171 0.036410 225 0.058566 252 0.020644 279 0.025517 333 0.030151 360 0.042916 387 0.053412 414 0.003348 36 0.027843 738 0.045796 90 0.020860 657 0.014792 684 0.024139 711 0.052849 9 0.039890 306 0.043977 198 0.028105 873 0.049056 441 0.004283 468 0.024615 495 0.012581 522 0.020798 549 0.053555 576 0.053124 603 0.027697 630 0.018077 63 0.012288 117 0.008018 819 0.027992 846 0.039652 766 0.033250 793 0.038373 145 0.007428 172 0.036410 226 0.058566 253 0.020644 280 0.025517 334 0.030151 361 0.042916 388 0.053412 415 0.003348 37 0.027843 739 0.045796 91 0.020860 658 0.014792 685 0.024139 712 0.052849 10 0.039890 307 0.043977 199 0.028105 874 0.049056 442 0.004283 469 0.024615 496 0.012581 523 0.020798 550 0.053555 577 0.053124 604 0.027697 631 0.018077 64 0.012288 118 0.008018 820 0.027992 847 0.039652 767 0.033250 794 0.038373 146 0.007428 173 0.036410 227 0.058566 254 0.020644 281 0.025517 335 0.030151 362 0.042916 389 0.053412 416 0.003348 38 0.027843 740 0.045796 92 0.020860 659 0.014792 686 0.024139 713 0.052849 11 0.039890 308 0.043977 200 0.028105 875 0.049056 443 0.004283 470 0.024615 497 0.012581 524 0.020798 551 0.053555 578 0.053124 605 0.027697 632 0.018077 65 0.012288 119 0.008018 821 0.027992 848 0.039652 768 0.033250 795 0.038373 147 0.007428 174 0.036410 228 0.058566 255 0.020644 282 0.025517 336 0.030151 363 0.042916 390 0.053412 417 0.003348 39 0.027843 741 0.045796 93 0.020860 660 0.014792 687 0.024139 714 0.052849 12 0.039890 309 0.043977 201 0.028105 876 0.049056 444 0.004283 471 0.024615 498 0.012581 525 0.020798 552 0.053555 579 0.053124 606 0.027697 633 0.018077 66 0.012288 120 0.008018 822 0.027992 849 0.039652 769 0.033250 796 0.038373 148 0.007428 175 0.036410 229 0.058566 256 0.020644 283 0.025517 337 0.030151 364 0.042916 391 0.053412 418 0.003348 40 0.027843 742 0.045796 94 0.020860 661 0.014792 688 0.024139 715 0.052849 13 0.039890 310 0.043977 202 0.028105 877 0.049056 445 0.004283 472 0.024615 499 0.012581 526 0.020798 553 0.053555 580 0.053124 607 0.027697 634 0.018077 67 0.012288 121 0.008018 823 0.027992 850 0.039652 770 0.033250 797 0.038373 149 0.007428 176 0.036410 230 0.058566 257 0.020644 284 0.025517 338 0.030151 365 0.042916 392 0.053412 419 0.003348 41 0.027843 743 0.045796 95 0.020860 662 0.014792 689 0.024139 716 0.052849 14 0.039890 311 0.043977 203 0.028105 878 0.049056 446 0.004283 473 0.024615 500 0.012581 527 0.020798 554 0.053555 581 0.053124 608 0.027697 635 0.018077 68 0.012288 122 0.008018 824 0.027992 851 0.039652 771 0.033250 798 0.038373 150 0.007428 177 0.036410 231 0.058566 258 0.020644 285 0.025517 339 0.030151 366 0.042916 393 0.053412 420 0.003348 42 0.027843 744 0.045796 96 0.020860 663 0.014792 690 0.024139 717 0.052849 15 0.039890 312 0.043977 204 0.028105 879 0.049056 447 0.004283 474 0.024615 501 0.012581 528 0.020798 555 0.053555 582 0.053124 609 0.027697 636 0.018077 69 0.012288 123 0.008018 825 0.027992 852 0.039652 772 0.033250 799 0.038373 151 0.007428 178 0.036410 232 0.058566 259 0.020644 286 0.025517 340 0.030151 367 0.042916 394 0.053412 421 0.003348 43 0.027843 745 0.045796 97 0.020860 664 0.014792 691 0.024139 718 0.052849 16 0.039890 313 0.043977 205 0.028105 880 0.049056 448 0.004283 475 0.024615 502 0.012581 529 0.020798 556 0.053555 583 0.053124 610 0.027697 637 0.018077 70 0.012288 124 0.008018 826 0.027992 853 0.039652 773 0.033250 800 0.038373 152 0.007428 179 0.036410 233 0.058566 260 0.020644 287 0.025517 341 0.030151 368 0.042916 395 0.053412 422 0.003348 44 0.027843 746 0.045796 98 0.020860 665 0.014792 692 0.024139 719 0.052849 17 0.039890 314 0.043977 206 0.028105 881 0.049056 449 0.004283 476 0.024615 503 0.012581 530 0.020798 557 0.053555 584 0.053124 611 0.027697 638 0.018077 71 0.012288 125 0.008018 827 0.027992 854 0.039652 774 0.033250 801 0.038373 153 0.007428 180 0.036410 234 0.058566 261 0.020644 288 0.025517 342 0.030151 369 0.042916 396 0.053412 423 0.003348 45 0.027843 747 0.045796 99 0.020860 666 0.014792 693 0.024139 720 0.052849 18 0.039890 315 0.043977 207 0.028105 882 0.049056 450 0.004283 477 0.024615 504 0.012581 531 0.020798 558 0.053555 585 0.053124 612 0.027697 639 0.018077 72 0.012288 126 0.008018 828 0.027992 855 0.039652 775 0.033250 802 0.038373 154 0.007428 181 0.036410 235 0.058566 262 0.020644 289 0.025517 343 0.030151 370 0.042916 397 0.053412 424 0.003348 46 0.027843 748 0.045796 100 0.020860 667 0.014792 694 0.024139 721 0.052849 19 0.039890 316 0.043977 208 0.028105 883 0.049056 451 0.004283 478 0.024615 505 0.012581 532 0.020798 559 0.053555 586 0.053124 613 0.027697 640 0.018077 73 0.012288 127 0.008018 829 0.027992 856 0.039652 776 0.033250 803 0.038373 155 0.007428 182 0.036410 236 0.058566 263 0.020644 290 0.025517 344 0.030151 371 0.042916 398 0.053412 425 0.003348 47 0.027843 749 0.045796 101 0.020860 668 0.014792 695 0.024139 722 0.052849 20 0.039890 317 0.043977 209 0.028105 884 0.049056 452 0.004283 479 0.024615 506 0.012581 533 0.020798 560 0.053555 587 0.053124 614 0.027697 641 0.018077 74 0.012288 128 0.008018 830 0.027992 857 0.039652 777 0.033250 804 0.038373 156 0.007428 183 0.036410 237 0.058566 264 0.020644 291 0.025517 345 0.030151 372 0.042916 399 0.053412 426 0.003348 48 0.027843 750 0.045796 102 0.020860 669 0.014792 696 0.024139 723 0.052849 21 0.039890 318 0.043977 210 0.028105 885 0.049056 453 0.004283 480 0.024615 507 0.012581 534 0.020798 561 0.053555 588 0.053124 615 0.027697 642 0.018077 75 0.012288 129 0.008018 831 0.027992 858 0.039652 778 0.033250 805 0.038373 157 0.007428 184 0.036410 238 0.058566 265 0.020644 292 0.025517 346 0.030151 373 0.042916 400 0.053412 427 0.003348 49 0.027843 751 0.045796 103 0.020860 670 0.014792 697 0.024139 724 0.052849 22 0.039890 319 0.043977 211 0.028105 886 0.049056 454 0.004283 481 0.024615 508 0.012581 535 0.020798 562 0.053555 589 0.053124 616 0.027697 643 0.018077 76 0.012288 130 0.008018 832 0.027992 859 0.039652 779 0.033250 806 0.038373 158 0.007428 185 0.036410 239 0.058566 266 0.020644 293 0.025517 347 0.030151 374 0.042916 401 0.053412 428 0.003348 50 0.027843 752 0.045796 104 0.020860 671 0.014792 698 0.024139 725 0.052849 23 0.039890 320 0.043977 212 0.028105 887 0.049056 455 0.004283 482 0.024615 509 0.012581 536 0.020798 563 0.053555 590 0.053124 617 0.027697 644 0.018077 77 0.012288 131 0.008018 833 0.027992 860 0.039652 780 0.033250 807 0.038373 159 0.007428 186 0.036410 240 0.058566 267 0.020644 294 0.025517 348 0.030151 375 0.042916 402 0.053412 429 0.003348 51 0.027843 753 0.045796 105 0.020860 672 0.014792 699 0.024139 726 0.052849 24 0.039890 321 0.043977 213 0.028105 888 0.049056 456 0.004283 483 0.024615 510 0.012581 537 0.020798 564 0.053555 591 0.053124 618 0.027697 645 0.018077 78 0.012288 132 0.008018 834 0.027992 861 0.039652 781 0.033250 808 0.038373 160 0.007428 187 0.036410 241 0.058566 268 0.020644 295 0.025517 349 0.030151 376 0.042916 403 0.053412 430 0.003348 52 0.027843 754 0.045796 106 0.020860 673 0.014792 700 0.024139 727 0.052849 25 0.039890 322 0.043977 214 0.028105 889 0.049056 457 0.004283 484 0.024615 511 0.012581 538 0.020798 565 0.053555 592 0.053124 619 0.027697 646 0.018077 79 0.012288 133 0.008018 835 0.027992 862 0.039652 782 0.033250 809 0.038373 161 0.007428 188 0.036410 242 0.058566 269 0.020644 296 0.025517 350 0.030151 377 0.042916 404 0.053412 431 0.003348 53 0.027843 755 0.045796 107 0.020860 674 0.014792 701 0.024139 728 0.052849 26 0.039890 323 0.043977 215 0.028105 890 0.049056 458 0.004283 485 0.024615 512 0.012581 539 0.020798 566 0.053555 593 0.053124 620 0.027697 647 0.018077 80 0.012288 134 0.008018 836 0.027992 863 0.039652 2 4 14 39 2 39 39 0.773355 40 0.328187 41 0.978416 42 0.987741 43 0.346198 5 0.488251 6 0.165234 7 0.807702 47 0.352563 9 0.522636 49 0.436526 50 0.571640 51 0.395222 52 0.903515 53 0.331638 54 0.707912 55 0.686021 56 0.063673 18 0.401360 19 0.980267 59 0.165796 21 0.327613 22 0.309333 23 0.135552 24 0.010502 25 0.718824 26 0.388349 27 0.318216 28 0.589841 29 0.955370 30 0.870163 31 0.971916 32 0.939387 72 0.782441 34 0.661667 35 0.432755 36 0.761180 37 0.738377 38 0.291109 1 0 27 27 0 0.013045 1 0.015003 2 0.015908 3 0.032127 4 0.028694 5 0.047807 6 0.029714 9 0.028389 10 0.031943 11 0.006187 12 0.057942 13 0.048390 14 0.061707 16 0.046532 23 0.053173 19 0.049666 15 0.053604 7 0.029841 8 0.046227 26 0.016579 21 0.054866 22 0.049434 20 0.061138 17 0.022464 18 0.019233 24 0.054571 25 0.025817 2 3 13 33 2 33 33 0.794800 1 0.732836 35 0.857183 36 0.397489 37 0.171521 5 0.946475 6 0.098399 40 0.485288 8 0.597361 9 0.669142 10 0.489993 44 0.905549 12 0.056892 13 0.143421 14 0.652299 15 0.866205 16 0.550558 17 0.300213 18 0.035790 19 0.123618 20 0.203302 21 0.675652 22 0.383100 23 0.213044 57 0.851535 58 0.185657 59 0.183531 60 0.904590 28 0.616268 29 0.272716 63 0.943421 64 0.522575 65 0.340239 3 12 13 21 2 2 1 2 2 1.000000 1 1.000000 2 4 6 39 16 624 0 0.049280 39 0.111545 78 0.095086 117 0.062084 156 0.021471 195 0.030912 234 0.116810 273 0.087739 312 0.113574 351 0.019612 390 0.024051 429 0.015819 468 0.086184 507 0.077588 546 0.015752 585 0.072492 1 0.049280 40 0.111545 79 0.095086 118 0.062084 157 0.021471 196 0.030912 235 0.116810 274 0.087739 313 0.113574 352 0.019612 391 0.024051 430 0.015819 469 0.086184 508 0.077588 547 0.015752 586 0.072492 2 0.049280 41 0.111545 80 0.095086 119 0.062084 158 0.021471 197 0.030912 236 0.116810 275 0.087739 314 0.113574 353 0.019612 392 0.024051 431 0.015819 470 0.086184 509 0.077588 548 0.015752 587 0.072492 3 0.049280 42 0.111545 81 0.095086 120 0.062084 159 0.021471 198 0.030912 237 0.116810 276 0.087739 315 0.113574 354 0.019612 393 0.024051 432 0.015819 471 0.086184 510 0.077588 549 0.015752 588 0.072492 4 0.049280 43 0.111545 82 0.095086 121 0.062084 160 0.021471 199 0.030912 238 0.116810 277 0.087739 316 0.113574 355 0.019612 394 0.024051 433 0.015819 472 0.086184 511 0.077588 550 0.015752 589 0.072492 5 0.049280 44 0.111545 83 0.095086 122 0.062084 161 0.021471 200 0.030912 239 0.116810 278 0.087739 317 0.113574 356 0.019612 395 0.024051 434 0.015819 473 0.086184 512 0.077588 551 0.015752 590 0.072492 6 0.049280 45 0.111545 84 0.095086 123 0.062084 162 0.021471 201 0.030912 240 0.116810 279 0.087739 318 0.113574 357 0.019612 396 0.024051 435 0.015819 474 0.086184 513 0.077588 552 0.015752 591 0.072492 7 0.049280 46 0.111545 85 0.095086 124 0.062084 163 0.021471 202 0.030912 241 0.116810 280 0.087739 319 0.113574 358 0.019612 397 0.024051 436 0.015819 475 0.086184 514 0.077588 553 0.015752 592 0.072492 8 0.049280 47 0.111545 86 0.095086 125 0.062084 164 0.021471 203 0.030912 242 0.116810 281 0.087739 320 0.113574 359 0.019612 398 0.024051 437 0.015819 476 0.086184 515 0.077588 554 0.015752 593 0.072492 9 0.049280 48 0.111545 87 0.095086 126 0.062084 165 0.021471 204 0.030912 243 0.116810 282 0.087739 321 0.113574 360 0.019612 399 0.024051 438 0.015819 477 0.086184 516 0.077588 555 0.015752 594 0.072492 10 0.049280 49 0.111545 88 0.095086 127 0.062084 166 0.021471 205 0.030912 244 0.116810 283 0.087739 322 0.113574 361 0.019612 400 0.024051 439 0.015819 478 0.086184 517 0.077588 556 0.015752 595 0.072492 11 0.049280 50 0.111545 89 0.095086 128 0.062084 167 0.021471 206 0.030912 245 0.116810 284 0.087739 323 0.113574 362 0.019612 401 0.024051 440 0.015819 479 0.086184 518 0.077588 557 0.015752 596 0.072492 12 0.049280 51 0.111545 90 0.095086 129 0.062084 168 0.021471 207 0.030912 246 0.116810 285 0.087739 324 0.113574 363 0.019612 402 0.024051 441 0.015819 480 0.086184 519 0.077588 558 0.015752 597 0.072492 13 0.049280 52 0.111545 91 0.095086 130 0.062084 169 0.021471 208 0.030912 247 0.116810 286 0.087739 325 0.113574 364 0.019612 403 0.024051 442 0.015819 481 0.086184 520 0.077588 559 0.015752 598 0.072492 14 0.049280 53 0.111545 92 0.095086 131 0.062084 170 0.021471 209 0.030912 248 0.116810 287 0.087739 326 0.113574 365 0.019612 404 0.024051 443 0.015819 482 0.086184 521 0.077588 560 0.015752 599 0.072492 15 0.049280 54 0.111545 93 0.095086 132 0.062084 171 0.021471 210 0.030912 249 0.116810 288 0.087739 327 0.113574 366 0.019612 405 0.024051 444 0.015819 483 0.086184 522 0.077588 561 0.015752 600 0.072492 16 0.049280 55 0.111545 94 0.095086 133 0.062084 172 0.021471 211 0.030912 250 0.116810 289 0.087739 328 0.113574 367 0.019612 406 0.024051 445 0.015819 484 0.086184 523 0.077588 562 0.015752 601 0.072492 17 0.049280 56 0.111545 95 0.095086 134 0.062084 173 0.021471 212 0.030912 251 0.116810 290 0.087739 329 0.113574 368 0.019612 407 0.024051 446 0.015819 485 0.086184 524 0.077588 563 0.015752 602 0.072492 18 0.049280 57 0.111545 96 0.095086 135 0.062084 174 0.021471 213 0.030912 252 0.116810 291 0.087739 330 0.113574 369 0.019612 408 0.024051 447 0.015819 486 0.086184 525 0.077588 564 0.015752 603 0.072492 19 0.049280 58 0.111545 97 0.095086 136 0.062084 175 0.021471 214 0.030912 253 0.116810 292 0.087739 331 0.113574 370 0.019612 409 0.024051 448 0.015819 487 0.086184 526 0.077588 565 0.015752 604 0.072492 20 0.049280 59 0.111545 98 0.095086 137 0.062084 176 0.021471 215 0.030912 254 0.116810 293 0.087739 332 0.113574 371 0.019612 410 0.024051 449 0.015819 488 0.086184 527 0.077588 566 0.015752 605 0.072492 21 0.049280 60 0.111545 99 0.095086 138 0.062084 177 0.021471 216 0.030912 255 0.116810 294 0.087739 333 0.113574 372 0.019612 411 0.024051 450 0.015819 489 0.086184 528 0.077588 567 0.015752 606 0.072492 22 0.049280 61 0.111545 100 0.095086 139 0.062084 178 0.021471 217 0.030912 256 0.116810 295 0.087739 334 0.113574 373 0.019612 412 0.024051 451 0.015819 490 0.086184 529 0.077588 568 0.015752 607 0.072492 23 0.049280 62 0.111545 101 0.095086 140 0.062084 179 0.021471 218 0.030912 257 0.116810 296 0.087739 335 0.113574 374 0.019612 413 0.024051 452 0.015819 491 0.086184 530 0.077588 569 0.015752 608 0.072492 24 0.049280 63 0.111545 102 0.095086 141 0.062084 180 0.021471 219 0.030912 258 0.116810 297 0.087739 336 0.113574 375 0.019612 414 0.024051 453 0.015819 492 0.086184 531 0.077588 570 0.015752 609 0.072492 25 0.049280 64 0.111545 103 0.095086 142 0.062084 181 0.021471 220 0.030912 259 0.116810 298 0.087739 337 0.113574 376 0.019612 415 0.024051 454 0.015819 493 0.086184 532 0.077588 571 0.015752 610 0.072492 26 0.049280 65 0.111545 104 0.095086 143 0.062084 182 0.021471 221 0.030912 260 0.116810 299 0.087739 338 0.113574 377 0.019612 416 0.024051 455 0.015819 494 0.086184 533 0.077588 572 0.015752 611 0.072492 27 0.049280 66 0.111545 105 0.095086 144 0.062084 183 0.021471 222 0.030912 261 0.116810 300 0.087739 339 0.113574 378 0.019612 417 0.024051 456 0.015819 495 0.086184 534 0.077588 573 0.015752 612 0.072492 28 0.049280 67 0.111545 106 0.095086 145 0.062084 184 0.021471 223 0.030912 262 0.116810 301 0.087739 340 0.113574 379 0.019612 418 0.024051 457 0.015819 496 0.086184 535 0.077588 574 0.015752 613 0.072492 29 0.049280 68 0.111545 107 0.095086 146 0.062084 185 0.021471 224 0.030912 263 0.116810 302 0.087739 341 0.113574 380 0.019612 419 0.024051 458 0.015819 497 0.086184 536 0.077588 575 0.015752 614 0.072492 30 0.049280 69 0.111545 108 0.095086 147 0.062084 186 0.021471 225 0.030912 264 0.116810 303 0.087739 342 0.113574 381 0.019612 420 0.024051 459 0.015819 498 0.086184 537 0.077588 576 0.015752 615 0.072492 31 0.049280 70 0.111545 109 0.095086 148 0.062084 187 0.021471 226 0.030912 265 0.116810 304 0.087739 343 0.113574 382 0.019612 421 0.024051 460 0.015819 499 0.086184 538 0.077588 577 0.015752 616 0.072492 32 0.049280 71 0.111545 110 0.095086 149 0.062084 188 0.021471 227 0.030912 266 0.116810 305 0.087739 344 0.113574 383 0.019612 422 0.024051 461 0.015819 500 0.086184 539 0.077588 578 0.015752 617 0.072492 33 0.049280 72 0.111545 111 0.095086 150 0.062084 189 0.021471 228 0.030912 267 0.116810 306 0.087739 345 0.113574 384 0.019612 423 0.024051 462 0.015819 501 0.086184 540 0.077588 579 0.015752 618 0.072492 34 0.049280 73 0.111545 112 0.095086 151 0.062084 190 0.021471 229 0.030912 268 0.116810 307 0.087739 346 0.113574 385 0.019612 424 0.024051 463 0.015819 502 0.086184 541 0.077588 580 0.015752 619 0.072492 35 0.049280 74 0.111545 113 0.095086 152 0.062084 191 0.021471 230 0.030912 269 0.116810 308 0.087739 347 0.113574 386 0.019612 425 0.024051 464 0.015819 503 0.086184 542 0.077588 581 0.015752 620 0.072492 36 0.049280 75 0.111545 114 0.095086 153 0.062084 192 0.021471 231 0.030912 270 0.116810 309 0.087739 348 0.113574 387 0.019612 426 0.024051 465 0.015819 504 0.086184 543 0.077588 582 0.015752 621 0.072492 37 0.049280 76 0.111545 115 0.095086 154 0.062084 193 0.021471 232 0.030912 271 0.116810 310 0.087739 349 0.113574 388 0.019612 427 0.024051 466 0.015819 505 0.086184 544 0.077588 583 0.015752 622 0.072492 38 0.049280 77 0.111545 116 0.095086 155 0.062084 194 0.021471 233 0.030912 272 0.116810 311 0.087739 350 0.113574 389 0.019612 428 0.024051 467 0.015819 506 0.086184 545 0.077588 584 0.015752 623 0.072492 2 5 7 39 16 624 0 0.049280 39 0.111545 78 0.095086 117 0.062084 156 0.021471 195 0.030912 234 0.116810 273 0.087739 312 0.113574 351 0.019612 390 0.024051 429 0.015819 468 0.086184 507 0.077588 546 0.015752 585 0.072492 1 0.049280 40 0.111545 79 0.095086 118 0.062084 157 0.021471 196 0.030912 235 0.116810 274 0.087739 313 0.113574 352 0.019612 391 0.024051 430 0.015819 469 0.086184 508 0.077588 547 0.015752 586 0.072492 2 0.049280 41 0.111545 80 0.095086 119 0.062084 158 0.021471 197 0.030912 236 0.116810 275 0.087739 314 0.113574 353 0.019612 392 0.024051 431 0.015819 470 0.086184 509 0.077588 548 0.015752 587 0.072492 3 0.049280 42 0.111545 81 0.095086 120 0.062084 159 0.021471 198 0.030912 237 0.116810 276 0.087739 315 0.113574 354 0.019612 393 0.024051 432 0.015819 471 0.086184 510 0.077588 549 0.015752 588 0.072492 4 0.049280 43 0.111545 82 0.095086 121 0.062084 160 0.021471 199 0.030912 238 0.116810 277 0.087739 316 0.113574 355 0.019612 394 0.024051 433 0.015819 472 0.086184 511 0.077588 550 0.015752 589 0.072492 5 0.049280 44 0.111545 83 0.095086 122 0.062084 161 0.021471 200 0.030912 239 0.116810 278 0.087739 317 0.113574 356 0.019612 395 0.024051 434 0.015819 473 0.086184 512 0.077588 551 0.015752 590 0.072492 6 0.049280 45 0.111545 84 0.095086 123 0.062084 162 0.021471 201 0.030912 240 0.116810 279 0.087739 318 0.113574 357 0.019612 396 0.024051 435 0.015819 474 0.086184 513 0.077588 552 0.015752 591 0.072492 7 0.049280 46 0.111545 85 0.095086 124 0.062084 163 0.021471 202 0.030912 241 0.116810 280 0.087739 319 0.113574 358 0.019612 397 0.024051 436 0.015819 475 0.086184 514 0.077588 553 0.015752 592 0.072492 8 0.049280 47 0.111545 86 0.095086 125 0.062084 164 0.021471 203 0.030912 242 0.116810 281 0.087739 320 0.113574 359 0.019612 398 0.024051 437 0.015819 476 0.086184 515 0.077588 554 0.015752 593 0.072492 9 0.049280 48 0.111545 87 0.095086 126 0.062084 165 0.021471 204 0.030912 243 0.116810 282 0.087739 321 0.113574 360 0.019612 399 0.024051 438 0.015819 477 0.086184 516 0.077588 555 0.015752 594 0.072492 10 0.049280 49 0.111545 88 0.095086 127 0.062084 166 0.021471 205 0.030912 244 0.116810 283 0.087739 322 0.113574 361 0.019612 400 0.024051 439 0.015819 478 0.086184 517 0.077588 556 0.015752 595 0.072492 11 0.049280 50 0.111545 89 0.095086 128 0.062084 167 0.021471 206 0.030912 245 0.116810 284 0.087739 323 0.113574 362 0.019612 401 0.024051 440 0.015819 479 0.086184 518 0.077588 557 0.015752 596 0.072492 12 0.049280 51 0.111545 90 0.095086 129 0.062084 168 0.021471 207 0.030912 246 0.116810 285 0.087739 324 0.113574 363 0.019612 402 0.024051 441 0.015819 480 0.086184 519 0.077588 558 0.015752 597 0.072492 13 0.049280 52 0.111545 91 0.095086 130 0.062084 169 0.021471 208 0.030912 247 0.116810 286 0.087739 325 0.113574 364 0.019612 403 0.024051 442 0.015819 481 0.086184 520 0.077588 559 0.015752 598 0.072492 14 0.049280 53 0.111545 92 0.095086 131 0.062084 170 0.021471 209 0.030912 248 0.116810 287 0.087739 326 0.113574 365 0.019612 404 0.024051 443 0.015819 482 0.086184 521 0.077588 560 0.015752 599 0.072492 15 0.049280 54 0.111545 93 0.095086 132 0.062084 171 0.021471 210 0.030912 249 0.116810 288 0.087739 327 0.113574 366 0.019612 405 0.024051 444 0.015819 483 0.086184 522 0.077588 561 0.015752 600 0.072492 16 0.049280 55 0.111545 94 0.095086 133 0.062084 172 0.021471 211 0.030912 250 0.116810 289 0.087739 328 0.113574 367 0.019612 406 0.024051 445 0.015819 484 0.086184 523 0.077588 562 0.015752 601 0.072492 17 0.049280 56 0.111545 95 0.095086 134 0.062084 173 0.021471 212 0.030912 251 0.116810 290 0.087739 329 0.113574 368 0.019612 407 0.024051 446 0.015819 485 0.086184 524 0.077588 563 0.015752 602 0.072492 18 0.049280 57 0.111545 96 0.095086 135 0.062084 174 0.021471 213 0.030912 252 0.116810 291 0.087739 330 0.113574 369 0.019612 408 0.024051 447 0.015819 486 0.086184 525 0.077588 564 0.015752 603 0.072492 19 0.049280 58 0.111545 97 0.095086 136 0.062084 175 0.021471 214 0.030912 253 0.116810 292 0.087739 331 0.113574 370 0.019612 409 0.024051 448 0.015819 487 0.086184 526 0.077588 565 0.015752 604 0.072492 20 0.049280 59 0.111545 98 0.095086 137 0.062084 176 0.021471 215 0.030912 254 0.116810 293 0.087739 332 0.113574 371 0.019612 410 0.024051 449 0.015819 488 0.086184 527 0.077588 566 0.015752 605 0.072492 21 0.049280 60 0.111545 99 0.095086 138 0.062084 177 0.021471 216 0.030912 255 0.116810 294 0.087739 333 0.113574 372 0.019612 411 0.024051 450 0.015819 489 0.086184 528 0.077588 567 0.015752 606 0.072492 22 0.049280 61 0.111545 100 0.095086 139 0.062084 178 0.021471 217 0.030912 256 0.116810 295 0.087739 334 0.113574 373 0.019612 412 0.024051 451 0.015819 490 0.086184 529 0.077588 568 0.015752 607 0.072492 23 0.049280 62 0.111545 101 0.095086 140 0.062084 179 0.021471 218 0.030912 257 0.116810 296 0.087739 335 0.113574 374 0.019612 413 0.024051 452 0.015819 491 0.086184 530 0.077588 569 0.015752 608 0.072492 24 0.049280 63 0.111545 102 0.095086 141 0.062084 180 0.021471 219 0.030912 258 0.116810 297 0.087739 336 0.113574 375 0.019612 414 0.024051 453 0.015819 492 0.086184 531 0.077588 570 0.015752 609 0.072492 25 0.049280 64 0.111545 103 0.095086 142 0.062084 181 0.021471 220 0.030912 259 0.116810 298 0.087739 337 0.113574 376 0.019612 415 0.024051 454 0.015819 493 0.086184 532 0.077588 571 0.015752 610 0.072492 26 0.049280 65 0.111545 104 0.095086 143 0.062084 182 0.021471 221 0.030912 260 0.116810 299 0.087739 338 0.113574 377 0.019612 416 0.024051 455 0.015819 494 0.086184 533 0.077588 572 0.015752 611 0.072492 27 0.049280 66 0.111545 105 0.095086 144 0.062084 183 0.021471 222 0.030912 261 0.116810 300 0.087739 339 0.113574 378 0.019612 417 0.024051 456 0.015819 495 0.086184 534 0.077588 573 0.015752 612 0.072492 28 0.049280 67 0.111545 106 0.095086 145 0.062084 184 0.021471 223 0.030912 262 0.116810 301 0.087739 340 0.113574 379 0.019612 418 0.024051 457 0.015819 496 0.086184 535 0.077588 574 0.015752 613 0.072492 29 0.049280 68 0.111545 107 0.095086 146 0.062084 185 0.021471 224 0.030912 263 0.116810 302 0.087739 341 0.113574 380 0.019612 419 0.024051 458 0.015819 497 0.086184 536 0.077588 575 0.015752 614 0.072492 30 0.049280 69 0.111545 108 0.095086 147 0.062084 186 0.021471 225 0.030912 264 0.116810 303 0.087739 342 0.113574 381 0.019612 420 0.024051 459 0.015819 498 0.086184 537 0.077588 576 0.015752 615 0.072492 31 0.049280 70 0.111545 109 0.095086 148 0.062084 187 0.021471 226 0.030912 265 0.116810 304 0.087739 343 0.113574 382 0.019612 421 0.024051 460 0.015819 499 0.086184 538 0.077588 577 0.015752 616 0.072492 32 0.049280 71 0.111545 110 0.095086 149 0.062084 188 0.021471 227 0.030912 266 0.116810 305 0.087739 344 0.113574 383 0.019612 422 0.024051 461 0.015819 500 0.086184 539 0.077588 578 0.015752 617 0.072492 33 0.049280 72 0.111545 111 0.095086 150 0.062084 189 0.021471 228 0.030912 267 0.116810 306 0.087739 345 0.113574 384 0.019612 423 0.024051 462 0.015819 501 0.086184 540 0.077588 579 0.015752 618 0.072492 34 0.049280 73 0.111545 112 0.095086 151 0.062084 190 0.021471 229 0.030912 268 0.116810 307 0.087739 346 0.113574 385 0.019612 424 0.024051 463 0.015819 502 0.086184 541 0.077588 580 0.015752 619 0.072492 35 0.049280 74 0.111545 113 0.095086 152 0.062084 191 0.021471 230 0.030912 269 0.116810 308 0.087739 347 0.113574 386 0.019612 425 0.024051 464 0.015819 503 0.086184 542 0.077588 581 0.015752 620 0.072492 36 0.049280 75 0.111545 114 0.095086 153 0.062084 192 0.021471 231 0.030912 270 0.116810 309 0.087739 348 0.113574 387 0.019612 426 0.024051 465 0.015819 504 0.086184 543 0.077588 582 0.015752 621 0.072492 37 0.049280 76 0.111545 115 0.095086 154 0.062084 193 0.021471 232 0.030912 271 0.116810 310 0.087739 349 0.113574 388 0.019612 427 0.024051 466 0.015819 505 0.086184 544 0.077588 583 0.015752 622 0.072492 38 0.049280 77 0.111545 116 0.095086 155 0.062084 194 0.021471 233 0.030912 272 0.116810 311 0.087739 350 0.113574 389 0.019612 428 0.024051 467 0.015819 506 0.086184 545 0.077588 584 0.015752 623 0.072492 2 0 10 27 1 27 0 0.213525 1 0.029426 2 0.426186 3 0.937233 4 0.944460 5 0.917238 6 0.606650 7 0.695628 8 0.109687 9 0.660242 10 0.852626 11 0.616040 12 0.428290 13 0.325841 14 0.423286 15 0.478041 16 0.790551 17 0.603138 18 0.114287 19 0.157221 20 0.070385 21 0.976143 22 0.840699 23 0.176599 24 0.502327 25 0.121862 26 0.675613 3 16 17 23 2 2 1 2 2 1.000000 1 1.000000 2 2 4 33 39 1287 561 0.037369 231 0.022984 264 0.001267 297 0.037733 462 0.009309 363 0.016339 396 0.039048 429 0.015038 1023 0.032211 957 0.043261 990 0.043881 858 0.016487 1056 0.005674 1122 0.037937 1155 0.042788 1221 0.009568 1254 0.033646 1089 0.028035 660 0.041890 66 0.041794 132 0.021378 330 0.033912 0 0.028408 99 0.005992 495 0.042820 528 0.023709 198 0.007244 594 0.039988 627 0.035330 693 0.018541 726 0.022735 759 0.027452 792 0.032487 825 0.009538 165 0.015457 891 0.026392 924 0.010019 33 0.037265 1188 0.005075 562 0.037369 232 0.022984 265 0.001267 298 0.037733 463 0.009309 364 0.016339 397 0.039048 430 0.015038 1024 0.032211 958 0.043261 991 0.043881 859 0.016487 1057 0.005674 1123 0.037937 1156 0.042788 1222 0.009568 1255 0.033646 1090 0.028035 661 0.041890 67 0.041794 133 0.021378 331 0.033912 1 0.028408 100 0.005992 496 0.042820 529 0.023709 199 0.007244 595 0.039988 628 0.035330 694 0.018541 727 0.022735 760 0.027452 793 0.032487 826 0.009538 166 0.015457 892 0.026392 925 0.010019 34 0.037265 1189 0.005075 563 0.037369 233 0.022984 266 0.001267 299 0.037733 464 0.009309 365 0.016339 398 0.039048 431 0.015038 1025 0.032211 959 0.043261 992 0.043881 860 0.016487 1058 0.005674 1124 0.037937 1157 0.042788 1223 0.009568 1256 0.033646 1091 0.028035 662 0.041890 68 0.041794 134 0.021378 332 0.033912 2 0.028408 101 0.005992 497 0.042820 530 0.023709 200 0.007244 596 0.039988 629 0.035330 695 0.018541 728 0.022735 761 0.027452 794 0.032487 827 0.009538 167 0.015457 893 0.026392 926 0.010019 35 0.037265 1190 0.005075 564 0.037369 234 0.022984 267 0.001267 300 0.037733 465 0.009309 366 0.016339 399 0.039048 432 0.015038 1026 0.032211 960 0.043261 993 0.043881 861 0.016487 1059 0.005674 1125 0.037937 1158 0.042788 1224 0.009568 1257 0.033646 1092 0.028035 663 0.041890 69 0.041794 135 0.021378 333 0.033912 3 0.028408 102 0.005992 498 0.042820 531 0.023709 201 0.007244 597 0.039988 630 0.035330 696 0.018541 729 0.022735 762 0.027452 795 0.032487 828 0.009538 168 0.015457 894 0.026392 927 0.010019 36 0.037265 1191 0.005075 565 0.037369 235 0.022984 268 0.001267 301 0.037733 466 0.009309 367 0.016339 400 0.039048 433 0.015038 1027 0.032211 961 0.043261 994 0.043881 862 0.016487 1060 0.005674 1126 0.037937 1159 0.042788 1225 0.009568 1258 0.033646 1093 0.028035 664 0.041890 70 0.041794 136 0.021378 334 0.033912 4 0.028408 103 0.005992 499 0.042820 532 0.023709 202 0.007244 598 0.039988 631 0.035330 697 0.018541 730 0.022735 763 0.027452 796 0.032487 829 0.009538 169 0.015457 895 0.026392 928 0.010019 37 0.037265 1192 0.005075 566 0.037369 236 0.022984 269 0.001267 302 0.037733 467 0.009309 368 0.016339 401 0.039048 434 0.015038 1028 0.032211 962 0.043261 995 0.043881 863 0.016487 1061 0.005674 1127 0.037937 1160 0.042788 1226 0.009568 1259 0.033646 1094 0.028035 665 0.041890 71 0.041794 137 0.021378 335 0.033912 5 0.028408 104 0.005992 500 0.042820 533 0.023709 203 0.007244 599 0.039988 632 0.035330 698 0.018541 731 0.022735 764 0.027452 797 0.032487 830 0.009538 170 0.015457 896 0.026392 929 0.010019 38 0.037265 1193 0.005075 567 0.037369 237 0.022984 270 0.001267 303 0.037733 468 0.009309 369 0.016339 402 0.039048 435 0.015038 1029 0.032211 963 0.043261 996 0.043881 864 0.016487 1062 0.005674 1128 0.037937 1161 0.042788 1227 0.009568 1260 0.033646 1095 0.028035 666 0.041890 72 0.041794 138 0.021378 336 0.033912 6 0.028408 105 0.005992 501 0.042820 534 0.023709 204 0.007244 600 0.039988 633 0.035330 699 0.018541 732 0.022735 765 0.027452 798 0.032487 831 0.009538 171 0.015457 897 0.026392 930 0.010019 39 0.037265 1194 0.005075 568 0.037369 238 0.022984 271 0.001267 304 0.037733 469 0.009309 370 0.016339 403 0.039048 436 0.015038 1030 0.032211 964 0.043261 997 0.043881 865 0.016487 1063 0.005674 1129 0.037937 1162 0.042788 1228 0.009568 1261 0.033646 1096 0.028035 667 0.041890 73 0.041794 139 0.021378 337 0.033912 7 0.028408 106 0.005992 502 0.042820 535 0.023709 205 0.007244 601 0.039988 634 0.035330 700 0.018541 733 0.022735 766 0.027452 799 0.032487 832 0.009538 172 0.015457 898 0.026392 931 0.010019 40 0.037265 1195 0.005075 569 0.037369 239 0.022984 272 0.001267 305 0.037733 470 0.009309 371 0.016339 404 0.039048 437 0.015038 1031 0.032211 965 0.043261 998 0.043881 866 0.016487 1064 0.005674 1130 0.037937 1163 0.042788 1229 0.009568 1262 0.033646 1097 0.028035 668 0.041890 74 0.041794 140 0.021378 338 0.033912 8 0.028408 107 0.005992 503 0.042820 536 0.023709 206 0.007244 602 0.039988 635 0.035330 701 0.018541 734 0.022735 767 0.027452 800 0.032487 833 0.009538 173 0.015457 899 0.026392 932 0.010019 41 0.037265 1196 0.005075 570 0.037369 240 0.022984 273 0.001267 306 0.037733 471 0.009309 372 0.016339 405 0.039048 438 0.015038 1032 0.032211 966 0.043261 999 0.043881 867 0.016487 1065 0.005674 1131 0.037937 1164 0.042788 1230 0.009568 1263 0.033646 1098 0.028035 669 0.041890 75 0.041794 141 0.021378 339 0.033912 9 0.028408 108 0.005992 504 0.042820 537 0.023709 207 0.007244 603 0.039988 636 0.035330 702 0.018541 735 0.022735 768 0.027452 801 0.032487 834 0.009538 174 0.015457 900 0.026392 933 0.010019 42 0.037265 1197 0.005075 571 0.037369 241 0.022984 274 0.001267 307 0.037733 472 0.009309 373 0.016339 406 0.039048 439 0.015038 1033 0.032211 967 0.043261 1000 0.043881 868 0.016487 1066 0.005674 1132 0.037937 1165 0.042788 1231 0.009568 1264 0.033646 1099 0.028035 670 0.041890 76 0.041794 142 0.021378 340 0.033912 10 0.028408 109 0.005992 505 0.042820 538 0.023709 208 0.007244 604 0.039988 637 0.035330 703 0.018541 736 0.022735 769 0.027452 802 0.032487 835 0.009538 175 0.015457 901 0.026392 934 0.010019 43 0.037265 1198 0.005075 572 0.037369 242 0.022984 275 0.001267 308 0.037733 473 0.009309 374 0.016339 407 0.039048 440 0.015038 1034 0.032211 968 0.043261 1001 0.043881 869 0.016487 1067 0.005674 1133 0.037937 1166 0.042788 1232 0.009568 1265 0.033646 1100 0.028035 671 0.041890 77 0.041794 143 0.021378 341 0.033912 11 0.028408 110 0.005992 506 0.042820 539 0.023709 209 0.007244 605 0.039988 638 0.035330 704 0.018541 737 0.022735 770 0.027452 803 0.032487 836 0.009538 176 0.015457 902 0.026392 935 0.010019 44 0.037265 1199 0.005075 573 0.037369 243 0.022984 276 0.001267 309 0.037733 474 0.009309 375 0.016339 408 0.039048 441 0.015038 1035 0.032211 969 0.043261 1002 0.043881 870 0.016487 1068 0.005674 1134 0.037937 1167 0.042788 1233 0.009568 1266 0.033646 1101 0.028035 672 0.041890 78 0.041794 144 0.021378 342 0.033912 12 0.028408 111 0.005992 507 0.042820 540 0.023709 210 0.007244 606 0.039988 639 0.035330 705 0.018541 738 0.022735 771 0.027452 804 0.032487 837 0.009538 177 0.015457 903 0.026392 936 0.010019 45 0.037265 1200 0.005075 574 0.037369 244 0.022984 277 0.001267 310 0.037733 475 0.009309 376 0.016339 409 0.039048 442 0.015038 1036 0.032211 970 0.043261 1003 0.043881 871 0.016487 1069 0.005674 1135 0.037937 1168 0.042788 1234 0.009568 1267 0.033646 1102 0.028035 673 0.041890 79 0.041794 145 0.021378 343 0.033912 13 0.028408 112 0.005992 508 0.042820 541 0.023709 211 0.007244 607 0.039988 640 0.035330 706 0.018541 739 0.022735 772 0.027452 805 0.032487 838 0.009538 178 0.015457 904 0.026392 937 0.010019 46 0.037265 1201 0.005075 575 0.037369 245 0.022984 278 0.001267 311 0.037733 476 0.009309 377 0.016339 410 0.039048 443 0.015038 1037 0.032211 971 0.043261 1004 0.043881 872 0.016487 1070 0.005674 1136 0.037937 1169 0.042788 1235 0.009568 1268 0.033646 1103 0.028035 674 0.041890 80 0.041794 146 0.021378 344 0.033912 14 0.028408 113 0.005992 509 0.042820 542 0.023709 212 0.007244 608 0.039988 641 0.035330 707 0.018541 740 0.022735 773 0.027452 806 0.032487 839 0.009538 179 0.015457 905 0.026392 938 0.010019 47 0.037265 1202 0.005075 576 0.037369 246 0.022984 279 0.001267 312 0.037733 477 0.009309 378 0.016339 411 0.039048 444 0.015038 1038 0.032211 972 0.043261 1005 0.043881 873 0.016487 1071 0.005674 1137 0.037937 1170 0.042788 1236 0.009568 1269 0.033646 1104 0.028035 675 0.041890 81 0.041794 147 0.021378 345 0.033912 15 0.028408 114 0.005992 510 0.042820 543 0.023709 213 0.007244 609 0.039988 642 0.035330 708 0.018541 741 0.022735 774 0.027452 807 0.032487 840 0.009538 180 0.015457 906 0.026392 939 0.010019 48 0.037265 1203 0.005075 577 0.037369 247 0.022984 280 0.001267 313 0.037733 478 0.009309 379 0.016339 412 0.039048 445 0.015038 1039 0.032211 973 0.043261 1006 0.043881 874 0.016487 1072 0.005674 1138 0.037937 1171 0.042788 1237 0.009568 1270 0.033646 1105 0.028035 676 0.041890 82 0.041794 148 0.021378 346 0.033912 16 0.028408 115 0.005992 511 0.042820 544 0.023709 214 0.007244 610 0.039988 643 0.035330 709 0.018541 742 0.022735 775 0.027452 808 0.032487 841 0.009538 181 0.015457 907 0.026392 940 0.010019 49 0.037265 1204 0.005075 578 0.037369 248 0.022984 281 0.001267 314 0.037733 479 0.009309 380 0.016339 413 0.039048 446 0.015038 1040 0.032211 974 0.043261 1007 0.043881 875 0.016487 1073 0.005674 1139 0.037937 1172 0.042788 1238 0.009568 1271 0.033646 1106 0.028035 677 0.041890 83 0.041794 149 0.021378 347 0.033912 17 0.028408 116 0.005992 512 0.042820 545 0.023709 215 0.007244 611 0.039988 644 0.035330 710 0.018541 743 0.022735 776 0.027452 809 0.032487 842 0.009538 182 0.015457 908 0.026392 941 0.010019 50 0.037265 1205 0.005075 579 0.037369 249 0.022984 282 0.001267 315 0.037733 480 0.009309 381 0.016339 414 0.039048 447 0.015038 1041 0.032211 975 0.043261 1008 0.043881 876 0.016487 1074 0.005674 1140 0.037937 1173 0.042788 1239 0.009568 1272 0.033646 1107 0.028035 678 0.041890 84 0.041794 150 0.021378 348 0.033912 18 0.028408 117 0.005992 513 0.042820 546 0.023709 216 0.007244 612 0.039988 645 0.035330 711 0.018541 744 0.022735 777 0.027452 810 0.032487 843 0.009538 183 0.015457 909 0.026392 942 0.010019 51 0.037265 1206 0.005075 580 0.037369 250 0.022984 283 0.001267 316 0.037733 481 0.009309 382 0.016339 415 0.039048 448 0.015038 1042 0.032211 976 0.043261 1009 0.043881 877 0.016487 1075 0.005674 1141 0.037937 1174 0.042788 1240 0.009568 1273 0.033646 1108 0.028035 679 0.041890 85 0.041794 151 0.021378 349 0.033912 19 0.028408 118 0.005992 514 0.042820 547 0.023709 217 0.007244 613 0.039988 646 0.035330 712 0.018541 745 0.022735 778 0.027452 811 0.032487 844 0.009538 184 0.015457 910 0.026392 943 0.010019 52 0.037265 1207 0.005075 581 0.037369 251 0.022984 284 0.001267 317 0.037733 482 0.009309 383 0.016339 416 0.039048 449 0.015038 1043 0.032211 977 0.043261 1010 0.043881 878 0.016487 1076 0.005674 1142 0.037937 1175 0.042788 1241 0.009568 1274 0.033646 1109 0.028035 680 0.041890 86 0.041794 152 0.021378 350 0.033912 20 0.028408 119 0.005992 515 0.042820 548 0.023709 218 0.007244 614 0.039988 647 0.035330 713 0.018541 746 0.022735 779 0.027452 812 0.032487 845 0.009538 185 0.015457 911 0.026392 944 0.010019 53 0.037265 1208 0.005075 582 0.037369 252 0.022984 285 0.001267 318 0.037733 483 0.009309 384 0.016339 417 0.039048 450 0.015038 1044 0.032211 978 0.043261 1011 0.043881 879 0.016487 1077 0.005674 1143 0.037937 1176 0.042788 1242 0.009568 1275 0.033646 1110 0.028035 681 0.041890 87 0.041794 153 0.021378 351 0.033912 21 0.028408 120 0.005992 516 0.042820 549 0.023709 219 0.007244 615 0.039988 648 0.035330 714 0.018541 747 0.022735 780 0.027452 813 0.032487 846 0.009538 186 0.015457 912 0.026392 945 0.010019 54 0.037265 1209 0.005075 583 0.037369 253 0.022984 286 0.001267 319 0.037733 484 0.009309 385 0.016339 418 0.039048 451 0.015038 1045 0.032211 979 0.043261 1012 0.043881 880 0.016487 1078 0.005674 1144 0.037937 1177 0.042788 1243 0.009568 1276 0.033646 1111 0.028035 682 0.041890 88 0.041794 154 0.021378 352 0.033912 22 0.028408 121 0.005992 517 0.042820 550 0.023709 220 0.007244 616 0.039988 649 0.035330 715 0.018541 748 0.022735 781 0.027452 814 0.032487 847 0.009538 187 0.015457 913 0.026392 946 0.010019 55 0.037265 1210 0.005075 584 0.037369 254 0.022984 287 0.001267 320 0.037733 485 0.009309 386 0.016339 419 0.039048 452 0.015038 1046 0.032211 980 0.043261 1013 0.043881 881 0.016487 1079 0.005674 1145 0.037937 1178 0.042788 1244 0.009568 1277 0.033646 1112 0.028035 683 0.041890 89 0.041794 155 0.021378 353 0.033912 23 0.028408 122 0.005992 518 0.042820 551 0.023709 221 0.007244 617 0.039988 650 0.035330 716 0.018541 749 0.022735 782 0.027452 815 0.032487 848 0.009538 188 0.015457 914 0.026392 947 0.010019 56 0.037265 1211 0.005075 585 0.037369 255 0.022984 288 0.001267 321 0.037733 486 0.009309 387 0.016339 420 0.039048 453 0.015038 1047 0.032211 981 0.043261 1014 0.043881 882 0.016487 1080 0.005674 1146 0.037937 1179 0.042788 1245 0.009568 1278 0.033646 1113 0.028035 684 0.041890 90 0.041794 156 0.021378 354 0.033912 24 0.028408 123 0.005992 519 0.042820 552 0.023709 222 0.007244 618 0.039988 651 0.035330 717 0.018541 750 0.022735 783 0.027452 816 0.032487 849 0.009538 189 0.015457 915 0.026392 948 0.010019 57 0.037265 1212 0.005075 586 0.037369 256 0.022984 289 0.001267 322 0.037733 487 0.009309 388 0.016339 421 0.039048 454 0.015038 1048 0.032211 982 0.043261 1015 0.043881 883 0.016487 1081 0.005674 1147 0.037937 1180 0.042788 1246 0.009568 1279 0.033646 1114 0.028035 685 0.041890 91 0.041794 157 0.021378 355 0.033912 25 0.028408 124 0.005992 520 0.042820 553 0.023709 223 0.007244 619 0.039988 652 0.035330 718 0.018541 751 0.022735 784 0.027452 817 0.032487 850 0.009538 190 0.015457 916 0.026392 949 0.010019 58 0.037265 1213 0.005075 587 0.037369 257 0.022984 290 0.001267 323 0.037733 488 0.009309 389 0.016339 422 0.039048 455 0.015038 1049 0.032211 983 0.043261 1016 0.043881 884 0.016487 1082 0.005674 1148 0.037937 1181 0.042788 1247 0.009568 1280 0.033646 1115 0.028035 686 0.041890 92 0.041794 158 0.021378 356 0.033912 26 0.028408 125 0.005992 521 0.042820 554 0.023709 224 0.007244 620 0.039988 653 0.035330 719 0.018541 752 0.022735 785 0.027452 818 0.032487 851 0.009538 191 0.015457 917 0.026392 950 0.010019 59 0.037265 1214 0.005075 588 0.037369 258 0.022984 291 0.001267 324 0.037733 489 0.009309 390 0.016339 423 0.039048 456 0.015038 1050 0.032211 984 0.043261 1017 0.043881 885 0.016487 1083 0.005674 1149 0.037937 1182 0.042788 1248 0.009568 1281 0.033646 1116 0.028035 687 0.041890 93 0.041794 159 0.021378 357 0.033912 27 0.028408 126 0.005992 522 0.042820 555 0.023709 225 0.007244 621 0.039988 654 0.035330 720 0.018541 753 0.022735 786 0.027452 819 0.032487 852 0.009538 192 0.015457 918 0.026392 951 0.010019 60 0.037265 1215 0.005075 589 0.037369 259 0.022984 292 0.001267 325 0.037733 490 0.009309 391 0.016339 424 0.039048 457 0.015038 1051 0.032211 985 0.043261 1018 0.043881 886 0.016487 1084 0.005674 1150 0.037937 1183 0.042788 1249 0.009568 1282 0.033646 1117 0.028035 688 0.041890 94 0.041794 160 0.021378 358 0.033912 28 0.028408 127 0.005992 523 0.042820 556 0.023709 226 0.007244 622 0.039988 655 0.035330 721 0.018541 754 0.022735 787 0.027452 820 0.032487 853 0.009538 193 0.015457 919 0.026392 952 0.010019 61 0.037265 1216 0.005075 590 0.037369 260 0.022984 293 0.001267 326 0.037733 491 0.009309 392 0.016339 425 0.039048 458 0.015038 1052 0.032211 986 0.043261 1019 0.043881 887 0.016487 1085 0.005674 1151 0.037937 1184 0.042788 1250 0.009568 1283 0.033646 1118 0.028035 689 0.041890 95 0.041794 161 0.021378 359 0.033912 29 0.028408 128 0.005992 524 0.042820 557 0.023709 227 0.007244 623 0.039988 656 0.035330 722 0.018541 755 0.022735 788 0.027452 821 0.032487 854 0.009538 194 0.015457 920 0.026392 953 0.010019 62 0.037265 1217 0.005075 591 0.037369 261 0.022984 294 0.001267 327 0.037733 492 0.009309 393 0.016339 426 0.039048 459 0.015038 1053 0.032211 987 0.043261 1020 0.043881 888 0.016487 1086 0.005674 1152 0.037937 1185 0.042788 1251 0.009568 1284 0.033646 1119 0.028035 690 0.041890 96 0.041794 162 0.021378 360 0.033912 30 0.028408 129 0.005992 525 0.042820 558 0.023709 228 0.007244 624 0.039988 657 0.035330 723 0.018541 756 0.022735 789 0.027452 822 0.032487 855 0.009538 195 0.015457 921 0.026392 954 0.010019 63 0.037265 1218 0.005075 592 0.037369 262 0.022984 295 0.001267 328 0.037733 493 0.009309 394 0.016339 427 0.039048 460 0.015038 1054 0.032211 988 0.043261 1021 0.043881 889 0.016487 1087 0.005674 1153 0.037937 1186 0.042788 1252 0.009568 1285 0.033646 1120 0.028035 691 0.041890 97 0.041794 163 0.021378 361 0.033912 31 0.028408 130 0.005992 526 0.042820 559 0.023709 229 0.007244 625 0.039988 658 0.035330 724 0.018541 757 0.022735 790 0.027452 823 0.032487 856 0.009538 196 0.015457 922 0.026392 955 0.010019 64 0.037265 1219 0.005075 593 0.037369 263 0.022984 296 0.001267 329 0.037733 494 0.009309 395 0.016339 428 0.039048 461 0.015038 1055 0.032211 989 0.043261 1022 0.043881 890 0.016487 1088 0.005674 1154 0.037937 1187 0.042788 1253 0.009568 1286 0.033646 1121 0.028035 692 0.041890 98 0.041794 164 0.021378 362 0.033912 32 0.028408 131 0.005992 527 0.042820 560 0.023709 230 0.007244 626 0.039988 659 0.035330 725 0.018541 758 0.022735 791 0.027452 824 0.032487 857 0.009538 197 0.015457 923 0.026392 956 0.010019 65 0.037265 1220 0.005075 2 2 12 33 2 33 33 0.794800 1 0.732836 35 0.857183 36 0.397489 37 0.171521 5 0.946475 6 0.098399 40 0.485288 8 0.597361 9 0.669142 10 0.489993 44 0.905549 12 0.056892 13 0.143421 14 0.652299 15 0.866205 16 0.550558 17 0.300213 18 0.035790 19 0.123618 20 0.203302 21 0.675652 22 0.383100 23 0.213044 57 0.851535 58 0.185657 59 0.183531 60 0.904590 28 0.616268 29 0.272716 63 0.943421 64 0.522575 65 0.340239 2 5 15 39 2 39 39 0.773355 40 0.328187 41 0.978416 42 0.987741 43 0.346198 5 0.488251 6 0.165234 7 0.807702 47 0.352563 9 0.522636 49 0.436526 50 0.571640 51 0.395222 52 0.903515 53 0.331638 54 0.707912 55 0.686021 56 0.063673 18 0.401360 19 0.980267 59 0.165796 21 0.327613 22 0.309333 23 0.135552 24 0.010502 25 0.718824 26 0.388349 27 0.318216 28 0.589841 29 0.955370 30 0.870163 31 0.971916 32 0.939387 72 0.782441 34 0.661667 35 0.432755 36 0.761180 37 0.738377 38 0.291109 libDAI-0.3.2/tests/testem/0000755000175000017500000000000012552202330014625 5ustar jorismjorismlibDAI-0.3.2/tests/testem/hoi1_share_f0_f1_f2.em0000644000175000017500000000013411342712572020544 0ustar jorismjorism1 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.3.2/tests/testem/hoi1_share_f0_f2.em0000644000175000017500000000012411342712572020155 0ustar jorismjorism1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 2 2 1 2 4 0 6 2 7 libDAI-0.3.2/tests/testem/2var.fg0000644000175000017500000000004611236233664016031 0ustar jorismjorism1 2 0 1 2 2 4 0 0.5 1 0.5 2 0.5 3 0.5libDAI-0.3.2/tests/testem/runtests.bat0000755000175000017500000000046211236233664017225 0ustar jorismjorismtestem 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.3.2/tests/testem/2var.em0000644000175000017500000000011211342712572016026 0ustar jorismjorism1 1 CondProbEstimation [target_dim=2,total_dim=4,pseudo_count=1] 1 0 1 0 libDAI-0.3.2/tests/testem/hoi1_infer_f2.em0000644000175000017500000000011411342712572017570 0ustar jorismjorism1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 1 2 1 2 4 libDAI-0.3.2/tests/testem/3var.em0000644000175000017500000000011411342712572016031 0ustar jorismjorism1 1 CondProbEstimation [target_dim=2,total_dim=8,pseudo_count=1] 1 0 1 0 2 libDAI-0.3.2/tests/testem/testem.cpp0000644000175000017500000000321211605337426016645 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/tests/testem/hoi1_data.tab0000644000175000017500000000010511342712572017154 0ustar jorismjorism0 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.3.2/tests/testem/2var_data.tab0000644000175000017500000000012511342712572017170 0ustar jorismjorism0 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.3.2/tests/testem/testem.out0000644000175000017500000000663611251414145016676 0ustar jorismjorismNumber 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.3.2/tests/testem/3var.fg0000644000175000017500000000010211236233664016023 0ustar jorismjorism1 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.3.2/tests/testem/runtests0000755000175000017500000000057411251420346016454 0ustar jorismjorism#!/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.3.2/customdoxygen.css0000644000175000017500000002000711277002562015613 0ustar jorismjorismBODY,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.3.2/Makefile.ALL0000644000175000017500000000176212233721125014243 0ustar jorismjorism# This file is part of libDAI - http://www.libdai.org/ # # Copyright (c) 2006-2011, The libDAI authors. All rights reserved. # # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. # This file can be used to configure compile time options of libDAI. # Here the user can enable or disable 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=") # # Disabling/enabling inference algorithms in libDAI can be done in include/dai/dai_config.h # COMPILATION AND BUILD FLAGS # 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= libDAI-0.3.2/Makefile.MACOSX640000644000175000017500000000426312042452776015011 0ustar jorismjorism# This file is part of libDAI - http://www.libdai.org/ # # Copyright (c) 2006-2011, The libDAI authors. All rights reserved. # # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. # 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 -arch x86_64 # 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 -lgmpxx -lgmp -arch x86_64 # 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=/opt/Matlab-R2010b # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)/bin/mex # Specify the C++ compiler and flags for MEX MEXFLAGS:=CXX\#$(CC) CXXFLAGS\#'$(CCFLAGS)' # Standard include directories for MEX MEXINC:=$(CCINC) # Standard libraries to include MEXLIBS=-lgmpxx -lgmp # 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.3.2/src/0000755000175000017500000000000012552202713012756 5ustar jorismjorismlibDAI-0.3.2/src/glc.cpp0000644000175000017500000005612212233677545014254 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2012, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_GLC #include #include #include #include #include #include #include namespace dai { using namespace std; void GLC::setProperties( const PropertySet &opts ) { DAI_ASSERT( opts.hasKey("tol") ); DAI_ASSERT( opts.hasKey("maxiter") ); DAI_ASSERT( opts.hasKey("cavity") ); DAI_ASSERT( opts.hasKey("updates") ); DAI_ASSERT( opts.hasKey("rgntype") ); DAI_ASSERT( opts.hasKey("cavainame") ); DAI_ASSERT( opts.hasKey("cavaiopts") ); DAI_ASSERT( opts.hasKey("inainame") ); DAI_ASSERT( opts.hasKey("inaiopts") ); if( opts.hasKey("maxtime") ) props.maxtime = opts.getStringAs("maxtime"); else props.maxtime = INFINITY; props.tol = opts.getStringAs("tol"); props.maxiter = opts.getStringAs("maxiter"); props.cavity = opts.getStringAs("cavity"); props.updates = opts.getStringAs("updates"); props.rgntype = opts.getStringAs("rgntype"); if(opts.hasKey("neighbors")) props.neighbors = opts.getStringAs("neighbors"); else props.neighbors = CobwebGraph::NeighborType::CLOSEST; if( opts.hasKey("verbose") ) props.verbose = opts.getStringAs("verbose"); else props.verbose = 0; if( opts.hasKey("loopdepth") ) props.loopdepth = opts.getStringAs("loopdepth"); else props.loopdepth = 4; if( opts.hasKey("cavainame") ) props.cavainame = opts.getStringAs("cavainame"); if( opts.hasKey("cavaiopts") ) props.cavaiopts = opts.getStringAs("cavaiopts"); if( opts.hasKey("inainame") ) props.inainame = opts.getStringAs("inainame"); if( opts.hasKey("inaiopts") ) props.inaiopts = opts.getStringAs("inaiopts"); if( opts.hasKey("reinit") ) props.reinit = opts.getStringAs("reinit"); } PropertySet GLC::getProperties() const { PropertySet opts; opts.set( "tol", props.tol ); opts.set( "maxiter", props.maxiter ); opts.set( "verbose", props.verbose ); opts.set( "loopdepth", props.loopdepth ); opts.set( "cavity", props.cavity ); opts.set( "neighbors", props.neighbors ); opts.set( "updates", props.updates ); opts.set( "rgntype", props.rgntype ); opts.set( "cavainame", props.cavainame ); opts.set( "cavaiopts", props.cavaiopts ); opts.set( "inainame", props.inainame ); opts.set( "inaiopts", props.inaiopts ); opts.set( "reinit", props.reinit ); opts.set( "maxtime", props.maxtime ); return opts; } string GLC::printProperties() const { stringstream s( stringstream::out ); s << "["; s << "tol=" << props.tol << ","; s << "maxiter=" << props.maxiter << ","; s << "verbose=" << props.verbose << ","; s << "loopdepth=" << props.loopdepth << ","; s << "cavity=" << props.cavity << ","; s << "updates=" << props.updates << ","; s << "neighbors=" << props.neighbors << ","; s << "rgntype=" << props.rgntype << ","; s << "cavainame=" << props.cavainame << ","; s << "cavaiopts=" << props.cavaiopts << ","; s << "inainame=" << props.inainame << ","; s << "inaiopts=" << props.inaiopts << ","; s << "reinit=" << props.reinit << ","; s << "maxtime=" << props.maxtime << "]"; return s.str(); } GLC::GLC( const FactorGraph& fg, const PropertySet &opts ) : DAIAlgCG(fg), _CWs(),_outOffset(), _cavitydists(), _beliefs(), _factorBeliefs(), _maxdiff(0.0), _iters(0), props() { setProperties( opts ); setRgn( calcRegions(), props.neighbors, false ); if( props.verbose >= 3 ){ cerr << "#regions: " << nrCWs() << endl; for( size_t i = 0; i < nrCWs(); i++ ) cerr << INRs(i).elements() << endl; } if( props.verbose >= 3 ) cerr << "initializing cavity dists" << endl; _cavitydists.resize( nrCWs() ); _maxdiff = InitCavityDists( props.cavainame, props.cavaiopts ); // build the vector of Cobweb Regions setCWs( props.inainame, props.inaiopts ); if( props.verbose >= 3 ) cerr << "Regions are built" << endl; // create beliefs _beliefs.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) _beliefs.push_back( Factor(var(i)) ); } vector > GLC::calcRegions() { // contains the variable indices for each region vector > regions; // single variables if( props.rgntype == Properties::RegionType::SINGLE ) { regions.resize( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) regions[i] = SmallSet(i); // partitioning factors } else if( props.rgntype == Properties::RegionType::FACTOR ) { SmallSet remainingVars; for( size_t i = 0; i < nrVars(); i++ ) remainingVars.insert( i ); vector > facVars( nrFactors() ); for( size_t I = 0; I < nrFactors(); I++ ) facVars[I] = findVars( factor(I).vars() ); bool canadd = true; while( canadd ) { canadd = false; for( size_t I = 0; I < nrFactors(); I++ ) { if( facVars[I] << remainingVars ) { regions.push_back( facVars[I] ); remainingVars /= facVars[I]; canadd = true; break; } } } // add the variables that are not covered as single variable regions bforeach(size_t i, remainingVars) regions.push_back( SmallSet(i) ); // overlapping factors (non-partitioning) } else if( props.rgntype == Properties::RegionType::OVFACTOR ) { SmallSet remainingVars; for( size_t I = 0; I < nrFactors(); I++ ) regions.push_back( findVars( factor(I).vars() ) ); // partitioning: adds loops over variables that are not covered recursively } else if( props.rgntype == Properties::RegionType::LOOP ) { set > scl; // to contain clusters SmallSet remaining; // variables not in a cluster yet // build the set of all var inds for( size_t v = 0; v < nrVars(); v++ ) remaining.insert( v ); // while there for a remaining var we can find a loop bool changing = true; while( changing ) { changing = false; for( size_t i0 = 0; i0 < nrVars(); i0++ ) { if( !remaining.contains(i0) ) continue; size_t currentsize = scl.size(); if( props.loopdepth > 1 ) findLoopClusters( remaining, scl, SmallSet(i0),i0, props.loopdepth - 1, deltai(i0) & remaining ); if(scl.size() > currentsize) changing = true; } } copy( scl.begin(), scl.end(), back_inserter(regions) ); // add the vars that are not covered as single variable regions bforeach( size_t i, remaining ) regions.push_back( SmallSet(i) ); // adds overlapping loops of maximum size loopdepth recursively } else if( props.rgntype == Properties::RegionType::OVLOOP ) { for( size_t I = 0; I < nrFactors(); I++ ) regions.push_back( findVars( factor(I).vars() ) ); SmallSet remaining; // variables not in a cluster yet // build the set of all var inds for( size_t v = 0; v < nrVars(); v++ ) remaining.insert( v ); set > scl; // to contain clusters // while there for a remaining var we can find a loop for( size_t i0 = 0; i0 < nrVars(); i0++ ) findOVLoopClusters( remaining, scl, SmallSet(i0),i0, props.loopdepth - 1, deltai(i0) ); copy( scl.begin(), scl.end(), back_inserter(regions) ); // non-partitioning: overlapping (variable+markov blanket)s } else if( props.rgntype == Properties::RegionType::OVDELTA ) { for( size_t I = 0; I < nrFactors(); I++ ) regions.push_back( findVars(factor(I).vars()) ); SmallSet remaining; // variables not in a cluster yet // build the set of all var inds for( size_t v = 0; v < nrVars(); v++ ) remaining.insert( v ); set > scl; // to contain clusters // while there for a remaining var we can find a loop for( size_t i0 = 0; i0 < nrVars(); i0++ ) findOVLoopClusters( remaining, scl, SmallSet(i0),i0, props.loopdepth - 1, deltai(i0) ); copy( scl.begin(), scl.end(), back_inserter(regions) ); } else if( props.rgntype == Properties::RegionType::DELTA ) { SmallSet remaining; // variables not in a cluster yet // build the set of all var inds for( size_t v = 0; v < nrVars(); v++ ) remaining.insert( v ); while( remaining.size() > 0 ) { size_t cv = remaining.elements()[ rand() % remaining.size() ]; regions.push_back( Deltai(cv) & remaining ); remaining /= Deltai(cv); } } return regions; } void GLC::findOVLoopClusters( SmallSet& remaining, set > &allcl, SmallSet newcl, const size_t& root, size_t length, SmallSet vars ) { for( SmallSet::const_iterator in = vars.begin(); in != vars.end(); in++ ) { SmallSet ind = deltai( *in ); if( (newcl.size()) >= 2 && ind.contains( root ) ) { allcl.insert( newcl | *in ); remaining /= (newcl | *in); } else if( length > 1 ) findOVLoopClusters( remaining, allcl, newcl | *in, root, length - 1, ind / newcl ); } } void GLC::findLoopClusters( SmallSet& remaining, set > &allcl, SmallSet newcl, const size_t& root, size_t length, SmallSet vars ) { for( SmallSet::const_iterator in = vars.begin(); in != vars.end(); in++ ) { SmallSet ind = deltai( *in ) & remaining; if( (newcl.size()) >= 2 && ind.contains( root ) ) { allcl.insert( newcl | *in ); remaining /= (newcl | *in); break; } else if( length > 1 ) findLoopClusters( remaining, allcl, newcl | *in, root, length - 1, ind / newcl ); } } void GLC::CalcBelief( size_t i, bool isFinal ) { if( !isFinal ) _beliefs[i] = CW( var2CW(i)[0] ).belief( var(i) ); else{ // take geometric average _beliefs[i] = Factor(var(i), (Real)1); for( size_t rind = 0; rind < var2CW(i).size(); rind++ ) _beliefs[i] *= CW( var2CW(i)[rind] ).belief( var(i) ); _beliefs[i] ^= (Real)1 / var2CW(i).size(); } } void GLC::CalcFactorBelief( size_t I ) { VarSet ns = factor(I).vars(); Factor tmp( ns, 1.0 ); size_t counter = 0; for( size_t R = 0; R < nrCWs(); R++ ) if( ns << inds2vars( INRs(R).elements() ) ) { tmp *= CW(R).belief(ns); counter++; } if( counter > 0 ) _factorBeliefs[ns] = tmp ^ (1.0 / counter); } Factor GLC::belief( const VarSet &ns ) const { if( ns.size() == 0 ) return Factor(); else if( ns.size() == 1 ) return beliefV( findVar( *(ns.begin()) ) ); else { map::const_iterator it = _factorBeliefs.find(ns); if( it != _factorBeliefs.end() ) return it->second; for( map::const_iterator it = _factorBeliefs.begin(); it != _factorBeliefs.end(); it++ ) if( ns << it->second.vars() ) return it->second.marginal( ns ); } DAI_THROW(BELIEF_NOT_AVAILABLE); return Factor(); } vector GLC::beliefs() const { vector result = _beliefs; for( map::const_iterator it = _factorBeliefs.begin(); it != _factorBeliefs.end(); it++ ) result.push_back( it->second ); return result; } Real GLC::CalcCavityDist( size_t R, const std::string &name, const PropertySet& opts ) { vector pairbeliefs; Real maxdiff = 0; if( props.cavity != Properties::CavityType::UNIFORM ) { InfAlg *cav = newInfAlg( name, *this, opts ); cav->makeRegionCavity( Rfs(R).elements() ); if( props.cavity == Properties::CavityType::FULL ) pairbeliefs.push_back( calcMarginal( *cav, inds2vars(EXRs(R).elements()), props.reinit ) ); if( props.cavity == Properties::CavityType::PAIR ) pairbeliefs = calcPairBeliefs( *cav, inds2vars(EXRs(R).elements()), props.reinit, false ); else if( props.cavity == Properties::CavityType::PAIR2 ) pairbeliefs = calcPairBeliefs( *cav, inds2vars(EXRs(R).elements()), props.reinit, true ); maxdiff = cav->maxDiff(); delete cav; } if( props.verbose >= 3 ) cerr << "R:" << R << "cavity of size " << pairbeliefs.size() << endl; _cavitydists[R] = pairbeliefs; return maxdiff; } Real GLC::InitCavityDists( const std::string &name, const PropertySet &opts ) { double tic = toc(); if( props.verbose >= 2 ) { cerr << this->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 R = 0; R < nrCWs(); R++ ) { Real md = CalcCavityDist(R, name, opts); if( md > maxdiff ) maxdiff = md; } if( props.verbose >= 2 ) cerr << this->name() << "::InitCavityDists used " << toc() - tic << " seconds." << endl; return maxdiff; } void GLC::NewPancake( size_t R, size_t _R2 ) { Factor newmsg; // calculate the new msg newmsg = CW(M(R, _R2).his).marginal( M(R, _R2).msg.vars(), M(R, _R2).fc) / ((CW(R).marginal( M(R, _R2).msg.vars(), M(R, _R2).fc))*M(R, _R2).msg.inverse()); newmsg.normalize(); // update the cobweb-graph with this new msg M(R, _R2).msg = newmsg; // update the corresponding factor in the cobweb region so to be used in future marginalizations (-_R2 - 1) is the index (see cobweb class documents) CW(R).updateFactor( -_R2 - 1 ,newmsg); } void GLC::OVNewPancake( size_t R ) { Factor newmsg, allmsgs, marg; for( size_t _R2 = 0; _R2 < M(R).size(); _R2++ ) { // for all _R2 that send messages to R // calculate the message newmsg = (CW(M(R, _R2).his).marginal( M(R, _R2).msg.vars(), M(R, _R2).fc) / ((CW(R).marginal( M(R, _R2).msg.vars(), M(R, _R2).fc))))*M(R, _R2).msg; newmsg.normalize(); // allmsgs takes care of the double-counts the way using the region-graph does in the paper. It is more compact but not as efficient allmsgs = newmsg; for( size_t sub = 0; sub < M(R,_R2).subregions.size(); sub++ ) { //for all descendants of rho of (\ominus r_{R, R2}) Real c = (Real)cn(R)[M(R, _R2).subregions[sub]].first; // counting number for rho size_t nrParents = cn(R)[M(R, _R2).subregions[sub]].second.size(); // number of rho's parents marg = newmsg.marginal(M(R, _R2).subregions[sub], false); // marginal of the message from R2 to R over rho allmsgs *= (marg^(c / nrParents)); // discount the double counting of rho from the message for( size_t pind = 0; pind < nrParents; pind++ ) // this operation corresponds to the upward pass if( cn(R)[M(R, _R2).subregions[sub]].second[pind] != _R2 ) M(R, cn(R)[M(R, _R2).subregions[sub]].second[pind]).newmsg *= marg^(-c / (nrParents * (nrParents - (Real)1))); } // set the message after taking double-countings into account M(R, _R2).msg = allmsgs.normalized(); } for( size_t _R2 = 0; _R2 < M(R).size(); _R2++ ) { M(R, _R2).newmsg *= M(R, _R2).msg; M(R, _R2).newmsg.normalize(); // update the corresponding factor in the cobweb region: to be used in future marginalizations CW(R).updateFactor( -_R2 - 1 , M(R, _R2).msg, false); M(R, _R2).msg = M(R, _R2).newmsg; M(R, _R2).newmsg.fill( (Real)1 ); } } Real GLC::run() { if( props.verbose >= 2 ) cerr << "Starting " << identify() << "..."; if( props.verbose >= 2 ) cerr << endl; double tic = toc(); if( props.verbose >= 3 ) cerr << "Initializing older beliefs" << endl; vector > oldBeliefsM; vector oldBeliefsP; if( isPartition ) { oldBeliefsM.reserve( nrCWs() ); for( size_t R = 0; R < nrCWs(); R++ ) { oldBeliefsM.push_back( vector() ); oldBeliefsM[R].reserve( M(R).size() ); for( size_t m = 0; m < M(R).size(); m++ ) oldBeliefsM[R].push_back( M(R,m).msg ); } } else { oldBeliefsP.reserve( nrVars() ); for( size_t i = 0; i < nrVars(); i++ ) { CalcBelief( i, true ); oldBeliefsP.push_back( _beliefs[i] ); } } if( props.verbose >= 3 ) cerr << "Setting the update sequence" < update_seq; update_seq.reserve( nredges ); for( size_t R = 0; R < nrCWs(); ++R ) for( size_t R2 = 0; R2 < M(R).size(); R2++ ) { update_seq.push_back( Edge( R, R2 ) ); nredges++; } vector update_seq_node; update_seq_node.reserve( nrCWs() ); for( size_t R = 0; R < nrCWs(); ++R ) update_seq_node.push_back( R ); if( props.verbose >= 3 ) cerr << "Going into the main loop" << endl; Real maxDiff = INFINITY; for( _iters = 0; _iters < props.maxiter && maxDiff > props.tol && (toc() - tic) < props.maxtime; _iters++ ) { if( props.updates == Properties::UpdateType::SEQRND ) { random_shuffle( update_seq.begin(), update_seq.end() ); random_shuffle( update_seq_node.begin(), update_seq_node.end() ); } if( isPartition ) { for( size_t t = 0; t < nredges; t++ ) { size_t R = update_seq[t].first; size_t _R2 = update_seq[t].second; NewPancake( R, _R2); } } else { for( size_t t = 0; t < nrCWs(); t++ ) OVNewPancake( update_seq_node[t] ); } if( !isPartition ) for( size_t i = 0; i < nrVars(); i++ ) CalcBelief( i , true ); maxDiff = -INFINITY; if( isPartition ) { for( size_t R = 0; R < nrCWs(); R++ ) { for( size_t m = 0; m < M(R).size(); m++ ) { maxDiff = std::max( maxDiff, dist( M(R, m).msg, oldBeliefsM[R][m], DISTLINF ) ); oldBeliefsM[R][m] = M(R,m).msg; } } } else { for( size_t i = 0; i < nrVars(); i++ ) { maxDiff = std::max( maxDiff, dist( _beliefs[i], oldBeliefsP[i], DISTLINF ) ); oldBeliefsP[i] = _beliefs[i]; } } if( props.verbose >= 2 ) cerr << this->name() << "::run: maxdiff " << maxDiff << " after " << _iters+1 << " passes" << endl; } if( isPartition ) for( size_t i = 0; i < nrVars(); i++ ) CalcBelief( i, true ); if( maxDiff > _maxdiff ) _maxdiff = maxDiff; if( props.verbose >= 2 ) { if( maxDiff > props.tol ) { if( props.verbose == 2 ) cerr << endl; cerr << this->name() << "::run: WARNING: not converged within " << props.maxiter << " passes (" << toc() - tic << " seconds)...final maxdiff:" << maxDiff << endl; } else { if( props.verbose >= 2 ) cerr << this->name() << "::run: "; cerr << "converged in " << _iters << " passes (" << toc() - tic << " seconds)." << endl; } } for( size_t I = 0; I < nrFactors(); I++ ) CalcFactorBelief( I ); return maxDiff; } void GLC::setCWs( const std::string &name, const PropertySet &opts ) { // needs to generate a vector of relevant factors, and a dictionary for mapping between local and global factors _CWs.clear(); _CWs.reserve( _INRs.size() ); _outOffset.clear(); _outOffset.reserve( _INRs.size() ); // main factors if( props.verbose >= 3 ) cerr << "Setting CWs..." << endl; for( size_t R = 0; R < nrCWs(); R++ ) { // for each region map g2l; vector Rfactors; // contains all factors size_t potsize = Rfs(R).size() + M(R).size() + _cavitydists[R].size(); Rfactors.reserve( potsize ); size_t _I = 0; // adding main factors for( SmallSet::const_iterator it = Rfs(R).begin(); it != Rfs(R).end(); it++ ) { Rfactors.push_back( factor(*it) ); g2l[(int)(*it)] = _I; _I++; } // adding factors for incoming messages size_t m = 0; size_t offset = Rfs(R).size(); for( vector::const_iterator it = M(R).begin(); it != M(R).end(); it++ ) { Rfactors.push_back( (*it).msg ); g2l[(int)-m-1] = m + offset; m++; } // cavities offset = Rfs(R).size() + M(R).size(); for( size_t c = 0; c < _cavitydists[R].size(); c++ ) { Rfactors.push_back( _cavitydists[R][c] ); g2l[(int)-M(R).size() - c - 1] = offset + c; } // outgoing msgs offset = Rfs(R).size() + M(R).size() + _cavitydists[R].size(); // _outOffset.push_back(-M(R).size() - _cavitydists[R].size() - 1); size_t counter = 0; if( props.verbose >= 3 ) cerr << "going to the loop!" << endl; for( size_t c = 0; c < outM(R).size(); c++ ) { bool isAvailable = false; for( size_t I = 0; I < Rfactors.size(); I++ ) if( outM(R,c) << Rfactors[I].vars() ) { isAvailable = true; break; } if( !isAvailable ) { Rfactors.push_back( Factor( outM(R)[c], (Real)1 ) ); g2l[(int)-M(R).size() - _cavitydists[R].size() - 1 - counter] = offset + counter; counter++; } } _CWs.push_back( Cobweb(g2l) ); InfAlg *alg = newInfAlg( name, FactorGraph(Rfactors), opts ); DAIAlgFG *dalg = static_cast (alg); _CWs[R].setInfAlg( dalg ); } } void GLC::initCWs(){ for( size_t R = 0; R < nrCWs(); R++ ) { _CWs[R].initialize(); for( size_t m = 0; m < M(R).size(); m++ ) { M(R)[m].msg.fill( (Real)1 ); M(R)[m].newmsg.fill( (Real)1 ); } } } } // end of namespace dai #endif libDAI-0.3.2/src/bbp.cpp0000644000175000017500000012223712233677421014244 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_CBP #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() ); bforeach( 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() ); bforeach( const Neighbor &I, _fg->nbV(i) ) { Prob prod( _fg->var(i).states(), 1.0 ); bforeach( 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() ); bforeach( const Neighbor &i, _fg->nbF(I) ) { Prob prod( _fg->factor(I).nrStates(), 1.0 ); bforeach( 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() ); bforeach( const Neighbor &I, _fg->nbV(i) ) { _Smsg[i][I.iter].resize( _fg->nbF(I).size() ); bforeach( const Neighbor &j, _fg->nbF(I) ) if( i != j ) { Factor prod( _fg->factor(I) ); bforeach( 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() ); bforeach( const Neighbor &i, _fg->nbF(I) ) { _Rmsg[I][i.iter].resize( _fg->nbV(i).size() ); bforeach( const Neighbor &J, _fg->nbV(i) ) { if( I != J ) { Prob prod( _fg->var(i).states(), 1.0 ); bforeach( 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() ); bforeach( 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() ); bforeach( 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 ); bforeach( const Neighbor &I, _fg->nbV(i) ) { { // calculate adj_n Prob prod( _fg->factor(I).p() ); prod *= _adj_b_F_unnorm[I]; bforeach( 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() ); bforeach( 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 ); bforeach( const Neighbor &I, _fg->nbV(i) ) { // calculate adj_m Prob prod( _adj_b_V_unnorm[i] ); DAI_ASSERT( prod.size() == _fg->var(i).states() ); bforeach( 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++ ) { bforeach( const Neighbor &I, _fg->nbV(i) ) { // calculate adj_n Prob prod( _fg->factor(I).p() ); prod *= _adj_b_F_unnorm[I]; bforeach( 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]; bforeach( 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 ); bforeach( 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++ ) bforeach( const Neighbor &I, _fg->nbV(i) ) { calcNewM( i, I.iter ); calcNewN( i, I.iter ); } for( size_t i = 0; i < _fg->nrVars(); i++ ) bforeach( 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 bforeach( 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()); bforeach( 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++ ) bforeach( 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++ ) bforeach( 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++ ) bforeach( 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++ ) bforeach( 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++ ) bforeach( 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++ ) bforeach( 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++ ) bforeach( const Neighbor &I, _fg->nbV(i) ) sendSeqMsgM( i, I.iter ); /* for( size_t i = 0; i < _fg->nrVars(); i++ ) bforeach( 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 */ #endif libDAI-0.3.2/src/weightedgraph.cpp0000644000175000017500000000445411605337426016323 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/src/factorgraph.cpp0000644000175000017500000004003012042452776015771 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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 >= 1 ) 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 >= 2 ) cerr << "Reading factor " << I << "..." << endl; size_t nr_members; while( (is.peek()) == '#' ) getline(is,line); is >> nr_members; if( verbose >= 2 ) 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 >= 2 ) 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 >= 2 ) 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 ) ); if( verbose >= 2 ) cerr << " vardims: " << vardims << endl; // calculate permutation object Permute permindex( Ivars ); // read values size_t nr_nonzeros; while( (is.peek()) == '#' ) getline(is,line); is >> nr_nonzeros; if( verbose >= 2 ) 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; bforeach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i bforeach( 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; } SmallSet FactorGraph::Deltai( size_t i ) const { // calculate Markov Blanket SmallSet Del; bforeach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i bforeach( const Neighbor &j, nbF(I) ) // for all neighboring variables j of I Del |= j; return Del; } void FactorGraph::makeCavity( size_t i, bool backup ) { // fills all Factors that include var(i) with ones map newFacs; bforeach( 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::makeRegionCavity( std::vector facInds, bool backup ) { map newFacs; for( size_t I = 0; I < facInds.size(); I++ ) newFacs[facInds[I]] = Factor(factor(facInds[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++ ) bforeach( 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++ ) bforeach( const Neighbor &I, nbV(i) ) bforeach( 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 { bforeach( const Neighbor& i, nbF(I) ) { bforeach( 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 { bforeach( const Neighbor& i, nbF(I) ) { bforeach( 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 ) const { // 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)[BigInt_size_t(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; bforeach( 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 ); bforeach( size_t i, is ) { DAI_ASSERT( i <= n.states() ); mask_n.set( i, (Real)1 ); } map newFacs; bforeach( 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 ); bforeach( 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.3.2/src/graph.cpp0000644000175000017500000002701012042452776014575 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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 bforeach( 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; bforeach( 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] ) { bforeach( 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++ ) bforeach( 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 bforeach( 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++ ) bforeach( 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; bforeach( 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(), rnd ); 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.3.2/src/mf.cpp0000644000175000017500000001423012233676533014077 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_MF #include #include #include #include #include #include namespace dai { using namespace std; 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) ) ); } 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; bforeach( const Neighbor &I, nbV(i) ) { Factor belief_I_minus_i; bforeach( 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(true); 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(), rnd ); maxDiff = -INFINITY; bforeach( 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; bforeach( 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 #endif libDAI-0.3.2/src/emalg.cpp0000644000175000017500000002452612327726520014567 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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); } std::string CondProbEstimation::_name = "CondProbEstimation"; 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), _initial_stats(pseudocounts), _props() { DAI_ASSERT( !(_initial_stats.size() % _target_dim) ); _props.setAsString("target_dim", _target_dim); _props.setAsString("total_dim", _initial_stats.size()); _props.setAsString("pseudo_count", _initial_stats.get(0)); } Prob CondProbEstimation::parametersToFactor(const Prob& p) { Prob result(p); return result; } // In the case of a conditional probability table, the // parameters are identical to the estimated factor Prob CondProbEstimation::parameters(const Prob& p) { Prob stats = p + _initial_stats; // 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 ); } return stats; } 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 ); _expectations = new Prob(_estimation->probSize(), 0); // 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( (BigInt)_estimation->probSize() == vs.nrStates() ); } } SharedParameters::SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE ) : _varsets(), _perms(), _varorders(varorders), _estimation(estimation), _ownEstimation(ownPE), _expectations(NULL) { // Calculate the necessary permutations and varsets setPermsAndVarSetsFromVarOrders(); } SharedParameters::SharedParameters( std::istream &is, const FactorGraph &fg ) : _varsets(), _perms(), _varorders(), _estimation(NULL), _ownEstimation(true), _expectations(NULL) { // 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::collectExpectations( 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 (*_expectations) += p; } } void SharedParameters::setParameters( FactorGraph &fg ) { Prob p = _estimation->estimate(this->currentExpectations()); 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].collectExpectations( alg ); } void MaximizationStep::maximize( FactorGraph &fg ) { for( size_t i = 0; i < _params.size(); ++i ) _params[i].setParameters( fg ); } void MaximizationStep::clear( ) { for( size_t i = 0; i < _params.size(); ++i ) _params[i].clear( ); } 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; mstep.clear(); _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.3.2/src/util.cpp0000644000175000017500000000631511605337426014454 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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::mt19937 _rnd_gen_type; /// 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( static_cast(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 ) break; } else { // we found a token tokens.push_back( s.substr(start, end - start) ); start = end + 1; } } return tokens; } } // end of namespace dai libDAI-0.3.2/src/factor.cpp0000644000175000017500000000320512042452776014752 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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( (BigInt)state < vs.nrStates() ); fac.set( state, 1.0 ); return fac; } } // end of namespace dai libDAI-0.3.2/src/evidence.cpp0000644000175000017500000000540511605337426015260 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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 = 2; // 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, "\t" ); 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.3.2/src/matlab/0000755000175000017500000000000012053447615014226 5ustar jorismjorismlibDAI-0.3.2/src/matlab/dai_writefg.cpp0000644000175000017500000000301611624743014017211 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/src/matlab/dai_readfg.cpp0000644000175000017500000000323211605337426016777 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/src/matlab/dai.cpp0000644000175000017500000001155012053436314015463 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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 = NAN; try { logZ = obj->logZ(); } catch( Exception &e ) { if( e.getCode() == Exception::NOT_IMPLEMENTED ) mexWarnMsgTxt("Calculating the log-partition function is not supported by this inference algorithm."); else throw; } // Save maxdiff double maxdiff = NAN; try { maxdiff = obj->maxDiff(); } catch( Exception &e ) { if( e.getCode() == Exception::NOT_IMPLEMENTED ) mexWarnMsgTxt("Calculating the max-differences is not supported by this inference algorithm."); else throw; } // 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; bool supported = true; try { map_state = obj->findMaximum(); } catch( Exception &e ) { if( e.getCode() == Exception::NOT_IMPLEMENTED ) supported = false; else throw; } if( supported ) { 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]; } else { delete obj; mexErrMsgTxt("Calculating a MAP state is not supported by this inference algorithm."); } } delete obj; return; } libDAI-0.3.2/src/matlab/dai_potstrength.cpp0000644000175000017500000000401411605337426020127 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/src/matlab/matlab.cpp0000644000175000017500000001244411720151144016164 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/src/matlab/dai_jtree.cpp0000644000175000017500000001640612053436323016661 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #include #include "mex.h" #include using namespace std; using namespace dai; /* Convert cell vector of Matlab sets to vector */ vector mx2VarSets(const mxArray *vs, const FactorGraph &fg, long verbose, vector &perms) { vector varsets; int n1 = mxGetM(vs); int n2 = mxGetN(vs); if( n2 != 1 && n1 != 1 ) mexErrMsgTxt("varsets should be a Nx1 or 1xN cell matrix."); size_t nr_vs = n1; if( n1 == 1 ) nr_vs = n2; // interpret vs, linear cell array of varsets varsets.reserve( nr_vs ); perms.clear(); perms.reserve( nr_vs ); for( size_t cellind = 0; cellind < nr_vs; cellind++ ) { if( verbose >= 3 ) cerr << "reading varset " << cellind << ": " << endl; mxArray *cell = mxGetCell(vs, cellind); if( verbose >= 3 ) cerr << " got cell " << endl; size_t nr_mem = mxGetN(cell); if( verbose >= 3 ) cerr << " number members: " << nr_mem << endl; double *members = mxGetPr(cell); if( verbose >= 3 ) cerr << " got them! " << endl; // add variables VarSet vsvars; if( verbose >= 3 ) cerr << " vars: "; vector labels(nr_mem,0); vector dims(nr_mem,0); for( size_t mi = 0; mi < nr_mem; mi++ ) { labels[mi] = (long)members[mi]; dims[mi] = fg.var(labels[mi]).states(); if( verbose >= 3 ) cerr << labels[mi] << " "; vsvars.insert( fg.var(labels[mi]) ); } if( verbose >= 3 ) cerr << endl; DAI_ASSERT( nr_mem == vsvars.size() ); varsets.push_back(vsvars); // calculate permutation matrix vector perm(nr_mem,0); VarSet::iterator j = vsvars.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; } // create Permute object 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 ); perms.push_back( permindex ); } if( verbose >= 3 ) { for(vector::const_iterator I=varsets.begin(); I!=varsets.end(); I++ ) cerr << *I << endl; } return( varsets ); } /* Input Arguments */ #define PSI_IN prhs[0] #define VARSETS_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 QV_OUT plhs[2] #define QF_OUT plhs[3] #define QMAP_OUT plhs[4] #define MARGS_OUT plhs[5] #define NR_OUT 3 #define NR_OUT_OPT 3 void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray*prhs[] ) { // 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,qv,qf,qmap,margs] = dai_jtree(psi,varsets,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" " varsets = linear cell array containing varsets for which marginals\n" " are requested.\n" " opts = string of options.\n" "\n" "OUTPUT: logZ = logarithm of the partition sum.\n" " q = linear cell array containing all calculated marginals.\n" " qv = linear cell array containing all variable marginals.\n" " qf = linear cell array containing all factor marginals.\n" " qmap = linear array containing the MAP state.\n" " margs = linear cell array containing all requested marginals.\n"); } // Get psi and construct factorgraph vector factors = mx2Factors(PSI_IN, 0); FactorGraph fg(factors); // Get varsets vector perms; vector varsets = mx2VarSets(VARSETS_IN,fg,0,perms); // Get options string char *opts; size_t 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 JTree jt = JTree( fg, props ); jt.init(); jt.run(); // Save logZ double logZ = NAN; logZ = jt.logZ(); // Hand over results to MATLAB LOGZ_OUT = mxCreateDoubleMatrix(1,1,mxREAL); *(mxGetPr(LOGZ_OUT)) = logZ; Q_OUT = Factors2mx(jt.beliefs()); if( nlhs >= 3 ) { vector qv; qv.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) qv.push_back( jt.belief( fg.var(i) ) ); QV_OUT = Factors2mx( qv ); } if( nlhs >= 4 ) { vector qf; qf.reserve( fg.nrFactors() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) qf.push_back( jt.belief( fg.factor(I).vars() ) ); QF_OUT = Factors2mx( qf ); } if( nlhs >= 5 ) { std::vector map_state; bool supported = true; try { map_state = jt.findMaximum(); } catch( Exception &e ) { if( e.getCode() == Exception::NOT_IMPLEMENTED ) supported = false; else throw; } if( supported ) { 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]; } else { mexErrMsgTxt("Calculating a MAP state is not supported by this inference algorithm."); } } if( nlhs >= 6 ) { vector margs; margs.reserve( varsets.size() ); for( size_t s = 0; s < varsets.size(); s++ ) { Factor marg; jt.init(); jt.run(); marg = jt.calcMarginal( varsets[s] ); // permute entries of marg Factor margperm = marg; for( size_t li = 0; li < marg.nrStates(); li++ ) margperm.set( li, marg[perms[s].convertLinearIndex(li)] ); margs.push_back( margperm ); } MARGS_OUT = Factors2mx( margs ); } return; } libDAI-0.3.2/src/decmap.cpp0000644000175000017500000001221312233677472014730 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_DECMAP #include namespace dai { using namespace std; 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; } 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] ); bforeach( 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 bforeach( 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 #endif libDAI-0.3.2/src/treeep.cpp0000644000175000017500000003330012233710266014750 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_TREEEP #include #include #include #include #include #include namespace dai { using namespace std; 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); bforeach( 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; bforeach( 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*/false ); // WORKAROUND FOR BUG IN BOOST GRAPH LIBRARY VERSION 1.54 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; } 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 #endif libDAI-0.3.2/src/properties.cpp0000644000175000017500000000626211605337426015674 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/src/io.cpp0000644000175000017500000002202411605337426014101 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/src/regiongraph.cpp0000644000175000017500000002017612042452776016007 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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() ); bforeach( 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; bforeach( 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++ ) bforeach( const Neighbor &beta, rg.nbOR(alpha) ) os << "\ta" << alpha << " -> b" << beta << ";" << endl; os << "}" << endl; return os; } } // end of namespace dai libDAI-0.3.2/src/jtree.cpp0000644000175000017500000005514512233710251014602 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_JTREE #include #include #include namespace dai { using namespace std; 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) BigInt memneeded = 0; bforeach( const VarSet& cl, ElimVec ) memneeded += cl.nrStates(); memneeded *= (BigInt)sizeof(Real) * (BigInt)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 > (BigInt)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 RTree = MaxSpanningTree( JuncGraph, /*true*/false ); // WORKAROUND FOR BUG IN BOOST GRAPH LIBRARY VERSION 1.54 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() ); bforeach( 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; } 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); bforeach( 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); bforeach( 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); bforeach( 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) BigInt maxval = 0; size_t maxalpha = 0; for( size_t alpha = 0; alpha < nrORs(); alpha++ ) { BigInt 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; BigInt nrstates = 0.0; for( size_t i = 0; i < ElimVec.size(); i++ ) { if( ElimVec[i].size() > treewidth ) treewidth = ElimVec[i].size(); BigInt s = ElimVec[i].nrStates(); if( s > nrstates ) nrstates = s; } return make_pair(treewidth, nrstates); } std::vector JTree::findMaximum() const { vector maximum( nrVars() ); vector visitedVars( nrVars(), false ); vector visitedORs( nrORs(), false ); stack scheduledORs; scheduledORs.push( 0 ); while( !scheduledORs.empty() ) { size_t alpha = scheduledORs.top(); scheduledORs.pop(); if( visitedORs[alpha] ) continue; visitedORs[alpha] = true; // Get marginal of outer region alpha Prob probF = Qa[alpha].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( OR(alpha).vars() ); size_t maxcount = 0; for( State s( OR(alpha).vars() ); s.valid(); ++s ) { // First, calculate whether this state is consistent with variables that // have been assigned already bool allowedState = true; bforeach( const Var& j, OR(alpha).vars() ) { size_t j_index = findVar(j); if( visitedVars[j_index] && maximum[j_index] != s(j) ) { allowedState = false; break; } } // If it is consistent, check if its probability is larger than what we have seen so far if( allowedState ) { if( probF[s] > maxProb ) { maxState = s; maxProb = probF[s]; maxcount = 1; } else maxcount++; } } DAI_ASSERT( maxProb != 0.0 ); DAI_ASSERT( Qa[alpha][maxState] != 0.0 ); // Decode the argmax bforeach( const Var& j, OR(alpha).vars() ) { size_t j_index = findVar(j); if( visitedVars[j_index] ) { // We have already visited j earlier - hopefully our state is consistent if( maximum[j_index] != maxState( j ) ) DAI_THROWE(RUNTIME_ERROR,"MAP state inconsistent due to loops"); } else { // We found a consistent state for variable j visitedVars[j_index] = true; maximum[j_index] = maxState( j ); bforeach( const Neighbor &beta, nbOR(alpha) ) bforeach( const Neighbor &alpha2, nbIR(beta) ) if( !visitedORs[alpha2] ) scheduledORs.push(alpha2); } } } return maximum; } } // end of namespace dai #endif libDAI-0.3.2/src/varset.cpp0000644000175000017500000000202011605337426014770 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/src/exactinf.cpp0000644000175000017500000000634112053436300015264 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #include namespace dai { using namespace std; 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); } } } // end of namespace dai libDAI-0.3.2/src/bp_dual.cpp0000644000175000017500000001043512233677423015105 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_CBP #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); bforeach( 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++ ) bforeach( 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++ ) bforeach( 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() ); bforeach( 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 ); bforeach( 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 ); bforeach( 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() ); bforeach( 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 #endif libDAI-0.3.2/src/fbp.cpp0000644000175000017500000001157012233676561014251 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_FBP #include #define DAI_FBP_FAST 1 namespace dai { using namespace std; // 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; bforeach( const Neighbor &I, nbV(i) ) c_i += Weight(I); if( c_i != 1.0 ) 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 bforeach( 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 ); bforeach( 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 if( c_I != 1.0 ) { // 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 #endif libDAI-0.3.2/src/dag.cpp0000644000175000017500000002105512237211133014214 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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 bforeach( 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; bforeach( const Neighbor &p, pa(n) ) result |= p; return result; } SmallSet DAG::chSet( size_t n ) const { SmallSet result; bforeach( const Neighbor &c, ch(n) ) result |= c; return result; } /// 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 (including \a n itself if \a inclusive == \c true) std::set DAG::ancestors( size_t n, bool inclusive ) const { set anc; if( inclusive ) anc.insert( n ); 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 bforeach( 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 d such that there exists a directed path from \a n to \a d (excluding \a n itself if \a inclusive == \c true) std::set DAG::descendants( size_t n, bool inclusive ) const { set desc; if( inclusive ) desc.insert( n ); 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 bforeach( 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 bforeach( 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] ) { bforeach( const Neighbor &n2, pa(n1) ) if( incomponent[n2] ) { found_new_nodes = true; incomponent[n1] = true; break; } } if( !incomponent[n1] ) { bforeach( 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++ ) bforeach( 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; bforeach( 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; bforeach( 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++ ) bforeach( const Neighbor& n2, ch(n1) ) DAI_ASSERT( !existsDirectedPath( n2, n1 ) ); } } // end of namespace dai libDAI-0.3.2/src/daialg.cpp0000644000175000017500000002404412042452776014721 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.getCode() == 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.getCode() == 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.getCode() == 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; size_t nrVisitedFactors = 0; size_t firstUnvisitedFactor = 0; while( nrVisitedFactors < obj.fg().nrFactors() ) { if( scheduledFactors.size() == 0 ) { while( visitedFactors[firstUnvisitedFactor] ) { firstUnvisitedFactor++; if( firstUnvisitedFactor >= obj.fg().nrFactors() ) DAI_THROWE(RUNTIME_ERROR,"Internal error in findMaximum()"); } scheduledFactors.push( firstUnvisitedFactor ); } size_t I = scheduledFactors.top(); scheduledFactors.pop(); if( visitedFactors[I] ) continue; visitedFactors[I] = true; nrVisitedFactors++; // 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() ); size_t maxcount = 0; 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; bforeach( 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 ) { if( probF[s] > maxProb ) { maxState = s; maxProb = probF[s]; maxcount = 1; } else maxcount++; } } if( maxProb == 0.0 ) DAI_THROWE(RUNTIME_ERROR,"Failed to decode the MAP state (should try harder using a SAT solver, but that's not implemented yet)"); DAI_ASSERT( obj.fg().factor(I).p()[maxState] != 0.0 ); // Decode the argmax bforeach( 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,"Detected inconsistency while decoding MAP state (should try harder using a SAT solver, but that's not implemented yet)"); } else { // We found a consistent state for variable j visitedVars[j.node] = true; maximum[j.node] = maxState( obj.fg().var(j.node) ); bforeach( const Neighbor &J, obj.fg().nbV(j) ) if( !visitedFactors[J] ) scheduledFactors.push(J); } } } return maximum; } } // end of namespace dai libDAI-0.3.2/src/clustergraph.cpp0000644000175000017500000001065612042452776016207 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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; bforeach( 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.nrVars(), 0 ), _vars(), _clusters() { // copy variables _vars.reserve( fg.nrVars() ); for( size_t i = 0; i < fg.nrVars(); i++ ) _vars.push_back( fg.var(i) ); if( onlyMaximal ) { for( size_t I = 0; I < fg.nrFactors(); I++ ) if( fg.isMaximal( I ) ) { _clusters.push_back( fg.factor(I).vars() ); size_t clind = _G.addNode2(); bforeach( const Neighbor &i, fg.nbF(I) ) _G.addEdge( i, clind, true ); } } else { // copy clusters _clusters.reserve( fg.nrFactors() ); for( size_t I = 0; I < fg.nrFactors(); I++ ) _clusters.push_back( fg.factor(I).vars() ); // copy bipartite graph _G = fg.bipGraph(); } } 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.3.2/src/bipgraph.cpp0000644000175000017500000002720412042452776015275 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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 bforeach( 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; bforeach( const Neighbor &n2, nb1(n1) ) result |= n2; return result; } SmallSet BipartiteGraph::nb2Set( size_t n2 ) const { SmallSet result; bforeach( 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; bforeach( const Neighbor &n2, nb1(n1) ) bforeach( 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; bforeach( const Neighbor &n1, nb2(n2) ) bforeach( 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++ ) bforeach( 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] ) { bforeach( 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] ) { bforeach( 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() ); bforeach( const Neighbor &n2, nb1(n1) ) newLevel.ind2.push_back( n2 ); } else { const levelType &prevLevel = levels.back(); // build newLevel.ind1 bforeach( size_t n2, prevLevel.ind2 ) { // for all n2 in the previous level bforeach( 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 bforeach( size_t n1, newLevel.ind1 ) { // for all n1 in this level bforeach( 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++ ) bforeach( 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; bforeach( 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; bforeach( 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.3.2/src/alldai.cpp0000644000175000017500000001240112042452776014720 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #include #include #include #include namespace dai { using namespace std; class _builtinInfAlgs : public std::map { public: _builtinInfAlgs() { operator[]( ExactInf().name() ) = new ExactInf; #ifdef DAI_WITH_BP operator[]( BP().name() ) = new BP; #endif #ifdef DAI_WITH_FBP operator[]( FBP().name() ) = new FBP; #endif #ifdef DAI_WITH_TRWBP operator[]( TRWBP().name() ) = new TRWBP; #endif #ifdef DAI_WITH_MF operator[]( MF().name() ) = new MF; #endif #ifdef DAI_WITH_HAK operator[]( HAK().name() ) = new HAK; #endif #ifdef DAI_WITH_LC operator[]( LC().name() ) = new LC; #endif #ifdef DAI_WITH_TREEEP operator[]( TreeEP().name() ) = new TreeEP; #endif #ifdef DAI_WITH_JTREE operator[]( JTree().name() ) = new JTree; #endif #ifdef DAI_WITH_MR operator[]( MR().name() ) = new MR; #endif #ifdef DAI_WITH_GIBBS operator[]( Gibbs().name() ) = new Gibbs; #endif #ifdef DAI_WITH_CBP operator[]( CBP().name() ) = new CBP; #endif #ifdef DAI_WITH_DECMAP operator[]( DecMAP().name() ) = new DecMAP; #endif #ifdef DAI_WITH_GLC operator[]( GLC().name() ) = new GLC; #endif } ~_builtinInfAlgs() { for( iterator it = begin(); it != end(); it++ ) delete it->second; } }; static _builtinInfAlgs allBuiltinInfAlgs; std::map& builtinInfAlgs() { return allBuiltinInfAlgs; } std::set builtinInfAlgNames() { std::set algNames; for( _builtinInfAlgs::const_iterator it = allBuiltinInfAlgs.begin(); it != allBuiltinInfAlgs.end(); it++ ) algNames.insert( it->first ); return algNames; } InfAlg *newInfAlg( const std::string &name, const FactorGraph &fg, const PropertySet &opts ) { _builtinInfAlgs::const_iterator i = allBuiltinInfAlgs.find( name ); if( i == allBuiltinInfAlgs.end() ) DAI_THROWE(UNKNOWN_DAI_ALGORITHM, "Unknown inference algorithm: " + name); InfAlg *ia = i->second; return ia->construct( fg, opts ); } 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.3.2/src/trwbp.cpp0000644000175000017500000001427412233710314014625 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_TRWBP #include #define DAI_TRWBP_FAST 1 namespace dai { using namespace std; 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(); } // 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; bforeach( const Neighbor &I, nbV(i) ) c_i += Weight(I); if( c_i != 1.0 ) 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 bforeach( 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 ); bforeach( 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 if( c_J != 1.0 ) { // 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 ); bforeach( 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*/false ); // WORKAROUND FOR BUG IN BOOST GRAPH LIBRARY VERSION 1.54 // 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 #endif libDAI-0.3.2/src/cobwebgraph.cpp0000644000175000017500000002272512451266046015764 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2012, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #include #include #include namespace dai { using namespace std; void CobwebGraph::setRgn( vector > partition, NeighborType neighbors, bool debugging ) { if( checkPartition( partition ) ) isPartition = true; else isPartition = false; eraseNonMaximal( partition ); if( debugging ) cerr << "isPartition:" << isPartition << endl; _INRs = partition; if( debugging ) cerr << "setting external factors and regional factors" << endl; setExtnFact(); if( debugging ) cerr << "setting msgs" << endl; setMSGs( neighbors ); // if(!isPartition) if( debugging ) cerr << "setting the counting numbers" << endl; if( !isPartition ) setCountingNumbers( debugging ); if( debugging ) cerr << "setting var2dr" << endl; setVar2CW(); } void CobwebGraph::eraseNonMaximal( vector >& partition ) { vector >::iterator del = partition.begin(); while( del != partition.end() ){ bool isNonMax = false; for( vector >::iterator it = partition.begin(); it != partition.end(); it++ ) if( (*it) >> (*del) && it != del ) { isNonMax = true; break; } if( isNonMax ) del = partition.erase( del ); else del++; } } void CobwebGraph::setCountingNumbers( bool debugging ) { // should handle the case when one region in the msg-region graph is subset of another or even to top regions are the same _cn.reserve( nrCWs() ); for( size_t R = 0; R < _INRs.size(); R++ ) { vector topR; // finding the intersection of messages SmallSet betas; for( size_t m1 = 0; m1 < M(R).size(); m1++ ) { topR.push_back( M(R,m1).msg.vars() ); for( size_t m2 = 0; m2 < M(R).size(); m2++ ) { if( m1 == m2 ) continue; VarSet b = M(R,m1).msg.vars() & M(R,m2).msg.vars(); if( b.size() == 0 ) continue; betas.insert( b ); } } if( debugging ) cerr << "topR: " << topR << endl; // finding the intersections of intersections bool somechange = true; while( somechange ) { SmallSet newbetas; somechange = false; bforeach( const VarSet &b1, betas ) { bforeach( const VarSet &b2, betas ) { if( b1 == b2 ) continue; VarSet b3 = b1 & b2; if( betas.contains(b3) || b3.size() == 0 ) continue; newbetas |= b3; somechange = true; } } betas |= newbetas; } if( debugging ) cerr << "betas: " << betas << endl; // set the counting number _cn.push_back( map > >() ); // adding sub-regions of every message for( size_t i = 0; i < topR.size(); i++ ) { M(R,i).subregions.clear(); bforeach( const VarSet& b, betas ) if( b << topR[i] ) M(R,i).subregions.push_back( b ); } SmallSet subVisited; SmallSet topRSet( topR.begin(), topR.end(), topR.size() ); // looks to see if all parents of a sub-region got their counting number while( !betas.empty() ) { bforeach( const VarSet &beta, betas ) { bool allparentsset = true; bforeach( const VarSet &beta2, betas ) if( beta2 >> beta && beta2 != beta ) { allparentsset = false; break; } if( allparentsset ) { // the first in the pair is cn and the second the index of top regions containing it _cn[R][beta] = make_pair( 1, vector() ); for( size_t TR = 0; TR < topR.size(); TR++ ) { if( topR[TR] >> beta ) { _cn[R][beta].first--; _cn[R][beta].second.push_back( TR ); } } bforeach( const VarSet& possibleparent, subVisited ) if( possibleparent >> beta ) _cn[R][beta].first -= _cn[R][possibleparent].first; if( debugging ) cerr << "cn[" << R << "][" << beta << "] <- " << _cn[R][beta] << endl; subVisited.insert( beta ); betas /= beta; break; // since betas has changed we need to enter the loop again } } } // if( debugging ) // cerr << "cn[" << R << "] " << _cn[R] << endl; } } bool CobwebGraph::checkPartition( const vector >& regions ) const { for( size_t i = 0; i < regions.size(); i++ ) for( size_t j = 0; j < regions.size(); j++ ) { if( j == i ) continue; if( regions[i].intersects( regions[j] ) ) return false; } return true; } void CobwebGraph::setVar2CW() { _var2CW.clear(); _var2CW.resize( nrVars() ); for( size_t R = 0; R < _INRs.size(); R++ ) { bforeach( size_t i, _INRs[R] ) _var2CW[i].push_back( R ); } } // assumes availablity of externals and internals void CobwebGraph::setMSGs( NeighborType neighbors ) { // initialize _outM.clear(); _outM.reserve( nrCWs() ); for( size_t R = 0; R < nrCWs(); R++ ) _outM.push_back( vector() ); _M.clear(); _M.reserve( _INRs.size() ); for( size_t R = 0; R < _INRs.size(); R++ ) { _M.push_back( vector() ); for( size_t R2 = 0; R2 < _INRs.size(); R2++ ) { if( R2 == R ) continue; SmallSet tmpSet = _EXRs[R] & (_INRs[R2]); // if R2 has boundary of R1 inside it if( tmpSet.size() == 0 ) continue; Connection tmp; tmp.fc = (_Rfs[R] & _Rfs[R2]).elements(); tmp.my = R; tmp.iter = _M[R].size(); tmp.his = R2; tmp.dual = _outM[R2].size(); VarSet tmpVarSet; bforeach( const size_t &i, tmpSet ) tmpVarSet.insert( var(i) ); tmp.msg = Factor( tmpVarSet, (Real)1.0 ); //* _outM[R2].push_back( tmpVarSet ); //* // tmp.varinds = tmpSet.elements(); _M[R].push_back( tmp ); } if( neighbors == NeighborType::CLOSEST || neighbors == NeighborType::TOP ) { bool foundone = true; while( foundone ) { for( size_t Rfirst = 0; Rfirst < _M[R].size(); Rfirst++ ) { foundone = false; for( size_t Rsec = 0; Rsec < _M[R].size(); Rsec++ ) { if( Rfirst == Rsec ) continue; if( _M[R][Rfirst].msg.vars() >> _M[R][Rsec].msg.vars() ) { // one message is subseteq of the other // only if one exclusively contains the other remove it if( ((neighbors == NeighborType::TOP || neighbors == NeighborType::CLOSEST) && _M[R][Rfirst].msg.vars().size() > _M[R][Rsec].msg.vars().size()) ) { _M[R].erase( _M[R].begin() + Rsec ); foundone = true; break; } else if( neighbors == NeighborType::CLOSEST && // if both have the same size then in case of CLOSEST delete the second one if it has smaller inner region overlap (INRs(_M[R][Rfirst].his) & INRs(R)).size() > (INRs(_M[R][Rsec].his) & INRs(R)).size() ) { _M[R].erase( _M[R].begin() + Rsec ); foundone = true; break; } } } if( foundone ) break; } } } } } void CobwebGraph::setExtnFact() { // finds and sets all the externals using _INRs SmallSet allpots; _EXRs.clear(); _Rfs.clear(); _EXRs.reserve( _INRs.size() ); _Rfs.reserve( _INRs.size() ); _Rifs.reserve( _INRs.size() ); _Rxfs.reserve( _INRs.size() ); for( size_t R = 0; R < _INRs.size(); R++ ) { _EXRs.push_back( SmallSet() ); _Rfs.push_back( SmallSet() ); _Rifs.push_back( SmallSet() ); _Rxfs.push_back( SmallSet() ); bforeach( const size_t &i, _INRs[R] ) { _EXRs[R] |= deltai(i) / _INRs[R]; bforeach( const Neighbor &I, nbV(i) ) { _Rfs[R] |= I.node; if( factor(I).vars() << inds2vars(INRs(R).elements()) ) _Rifs[R] |= I.node; else _Rxfs[R] |= I.node; } } } } } // end of namespace dai libDAI-0.3.2/src/gibbs.cpp0000644000175000017500000001626112233677234014570 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_GIBBS #include #include #include #include #include #include #include #include namespace dai { using namespace std; 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 bforeach( 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 #endif libDAI-0.3.2/src/mr.cpp0000644000175000017500000003543312233677151014120 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_MR #include #include #include #include #include #include #include #include #include namespace dai { using namespace std; 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++ ) bforeach( 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++ ) { bforeach( 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")) ); bforeach( 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(); bforeach( 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; } 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++ ) bforeach( 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 #endif libDAI-0.3.2/src/bp.cpp0000644000175000017500000003607512233675526014112 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_BP #include #include #include #include #include #include #include #include namespace dai { using namespace std; #define DAI_BP_FAST 1 /// \todo Make DAI_BP_FAST a compile-time choice, as it is a memory/speed tradeoff 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() ); } bforeach( 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++ ) bforeach( 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 ) { bforeach( 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 bforeach( 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 ); bforeach( 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 ) bforeach( 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 bforeach( const Neighbor &J, nbV(i) ) { if( J.iter != _I ) { bforeach( 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 ) bforeach( const Neighbor &I, nbV(i) ) calcNewMessage( i, I.iter ); for( size_t i = 0; i < nrVars(); ++i ) bforeach( const Neighbor &I, nbV(i) ) updateMessage( i, I.iter ); } else { // Sequential updates if( props.updates == Properties::UpdateType::SEQRND ) random_shuffle( _updateSeq.begin(), _updateSeq.end(), rnd ); bforeach( 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 ); bforeach( 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; } void BP::init( const VarSet &ns ) { for( VarSet::const_iterator n = ns.begin(); n != ns.end(); ++n ) { size_t ni = findVar( *n ); bforeach( 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 #endif libDAI-0.3.2/src/lc.cpp0000644000175000017500000002504112233676754014102 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_LC #include #include #include #include #include #include #include namespace dai { using namespace std; 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() ); bforeach( 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))); } 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 << this->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 << this->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 ) bforeach( 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]; bforeach( 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 ) bforeach( 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(), rnd ); 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 #endif libDAI-0.3.2/src/exceptions.cpp0000644000175000017500000000223611605337426015656 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #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.3.2/src/hak.cpp0000644000175000017500000005221412233676701014241 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_HAK #include #include #include #include namespace dai { using namespace std; /// 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() ); bforeach( 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; } 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(); bforeach( 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++ ) bforeach( 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++ ) { bforeach( 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; bforeach( 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); bforeach( 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); bforeach( 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]; bforeach( 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 #endif libDAI-0.3.2/src/cbp.cpp0000644000175000017500000005517212233677413014251 0ustar jorismjorism/* This file is part of libDAI - http://www.libdai.org/ * * Copyright (c) 2006-2011, The libDAI authors. All rights reserved. * * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. */ #include #ifdef DAI_WITH_CBP #include #include #include #include #include #include #include #include #include #include #include namespace dai { using namespace std; using boost::shared_ptr; /// 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 ); delete bp; 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 ) bforeach( size_t xi, xis ) DAI_ASSERT(/*0<=xi &&*/ xi < var(i).states() ); else bforeach( 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 */ #endif libDAI-0.3.2/LICENSE0000644000175000017500000000243311605337426013206 0ustar jorismjorismCopyright (c) 2006-2011, the libDAI authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. libDAI-0.3.2/Makefile.LINUX0000644000175000017500000000431312233465025014531 0ustar jorismjorism# This file is part of libDAI - http://www.libdai.org/ # # Copyright (c) 2006-2011, The libDAI authors. All rights reserved. # # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. # This template contains configurations for compiling libDAI under GNU/Linux # and other UNIX variants # # It has been tested with Ubuntu 8.04, Ubuntu 9.04 and Debian testing # # 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=.mexa64 # 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 -lgmpxx -lgmp # For linking with BOOST libraries BOOSTLIBS_PO=-lboost_program_options BOOSTLIBS_UTF=-lboost_unit_test_framework # 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=/opt/Matlab-R2010b # The following should resolve to the MatLab mex compile command MEX=$(MATLABDIR)/bin/mex # Specify the C++ compiler and flags for MEX MEXFLAGS:=CXX\#$(CC) CXXFLAGS\#'$(CCFLAGS)' # Standard include directories for MEX MEXINC:=$(CCINC) # Standard libraries to include MEXLIBS=-lgmpxx -lgmp # 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.7 # 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.3.2/matlab/0000755000175000017500000000000012225733657013444 5ustar jorismjorismlibDAI-0.3.2/matlab/dai_jtree.m0000644000175000017500000000146512042452776015553 0ustar jorismjorism% [logZ,q,qv,qf,qmap,margs] = dai_jtree(psi,varsets,opts) % % INPUT: psi = linear cell array containing the factors % (psi{i} should be a structure with a Member field % and a P field). % varsets = linear cell array containing varsets for which marginals % are requested. % opts = string of options. % % OUTPUT: logZ = logarithm of the partition sum. % q = linear cell array containing all calculated marginals. % qv = linear cell array containing all variable marginals. % qf = linear cell array containing all factor marginals. % qmap = linear array containing the MAP state. % margs = linear cell array containing all requested marginals. libDAI-0.3.2/matlab/dai.m0000644000175000017500000000141311605021575014344 0ustar jorismjorism% [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.3.2/matlab/dai_writefg.m0000644000175000017500000000042611235602300016064 0ustar jorismjorism% 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.3.2/matlab/dai_potstrength.m0000644000175000017500000000045211251417221017001 0ustar jorismjorism% 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.3.2/matlab/dai_readfg.m0000644000175000017500000000042511235602300015644 0ustar jorismjorism% [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.3.2/Makefile.CYGWIN0000644000175000017500000000446112042452776014645 0ustar jorismjorism# This file is part of libDAI - http://www.libdai.org/ # # Copyright (c) 2006-2011, The libDAI authors. All rights reserved. # # Use of this source code is governed by a BSD-style license that can be found in the LICENSE file. # 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 -lgmpxx -lgmp # 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) # Standard libraries to include MEXLIBS=-lgmpxx -lgmp # 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.3.2/doc/0000755000175000017500000000000012552201371012733 5ustar jorismjorismlibDAI-0.3.2/doc/doxygen_sqlite3.db0000644000175000017500000073200012552201371016365 0ustar jorismjorismSQLite format 3@ í -æ ñûöñ ѧûõïéãÝ×Ѥ…¡„=Ÿƒlœƒš‚K”{-\ á H oªÍñÀ†^H +innernamespacesŒ!innerclassx#compounddefÐ-memberdef_params ° xrefsÒ+basecompoundref¼ paramsH memberdef includesÙ"<ìûöñìçâÝØÒÌÆÀº´®¨¢œ–Š„~xrlf`ZTNHB<ë„lê„Sè„=ç„)æ„å„äƒnàƒZ߃DÞƒ/܃كтzÈ‚oÄ‚b°‚T£‚G ‚9‚ •‚ ‘sŒa‹MŠ9~#}|z{bwLv@T6O)54Ú¢ûöñìæàÚ›d“?Ž]iCQ/5.Gf–ÉÓ’™f{+._boost/graph/kruskal_min_spanning_tree.hppåY5m/home/jorism/vcs/libdai/src/matlab/dai_jtree.cppô-5o/home/jorism/vcs/libdai/include/dai/regiongraph.h6’3src/cobwebgraph.cppž1include/dai/enum.h¸0¨)dai/exactinf.h(@/c/home/jorism/vcs/libdai/src/cobwebgraph.cpp,2i/home/jorism/vcs/libdai/include/dai/exactinf.h'¤˜ûöñìæàÚÔÎȼ¶°ª¤…ƒ‚‚yt‚`o‚Gm‚.h‚d}\dRKL4G=8i(Q"5!$“—ùÏÌN5¬¤÷xÖV,#`“u4knamespacedai_1a8676cd0faacaec12b2acf0e0472e3280'&Oa31d68730f49619179aff649cbe5c3d3dHQ&Oaaa6ec0e95ae9ed3e20a20416b1d114f7 k%Oaff430369632930fca8b328180ce87d9a6%Oa403799e0ba09a3eaf9fb97f78faa3198[&Oab4cfb99bfafa3e661caa11171c8918beF%Oa885f296c16fdeeb33f5fa51309db5c7b^ %Oa27ef52cae918a8e91913d92b0e4e6fa5D&Oa143a4623be8c9356e3cdb2f75f64f0d80,e%Oadf6152701bfbb28221bd2e69e662b876U†&Oad15e329ec639092806617301eba9d622©s&Oa6c82ecf70996c18280e063d1c5e02834R‡%Oa5b4639a278afc734c0d4b074f53d87b5p`&Oac422893fd7b8e37f914860aeba9602dcK&Oa99e3f91437fee148644706ac0a77093fæ« <&Oa51bfe57cacf9f79e788c490ed369869eÅn;classdai_1_1RegionGraph€y%Oaef5d551a623efc6e6b9c9e10e97b9805)U*¡âûõïéãÝ×ÑËÅ¿¹³­§¡Û‡+Ö†mІ6Ê…Å…Gº…±„R‰„€ƒZpƒj‚b_‚-Nu?<&%@ö«ûö  N|PþRØ#\«|Nƒtablexrefsxrefs CREATE TABLE xrefs (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,refid]ƒtablexrefsxrefs CREATE TABLE xrefs (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,refid_src INTEGER NOT NULL, refid_dst INTEGER NOT NULL, id_file INTEGER NOT NULL, line INTEGER NOT NULL, column INTEGER NOT NULL)MwtablerefidsrefidsCREATE TABLE refids (refid TEXT PRIMARY KEY NOT NULL)+?indexsqlite_autoindex_refids_1refidsIstablefilesfilesCREATE TABLE files (name TEXT PRIMARY KEY NOT NULL))=indexsqlite_autoindex_files_1files)!!‚tableinnerclassinnerclassCREATE TABLE innerclass (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, refid TEXT NOT NULL,prot INTEGER NOT NULL,name TEXT NOT NULL)P++Ytablesqlite_sequencesqlite_sequenceCREATE TABLE sqlite_sequence(name,seq)-‚-tableincludesincludesCREATE TABLE includes (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, local INTEGER NOT NULL,id_src INTEGER NOT NULL,id_dst INTEGER NOT NULL) ÿ…z ‹Ctablememberdefmemberdef CREATE TABLE memberdef (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, id_file INTEGER NOT NULL,line INTEGER NOT NULL,column INTEGER NOT NULL,refid TEXT NOT NULL,name TEXT NOT NULL,definition TEXT,type TEXT,argsstring TEXT,scope TEXT,initializer TEXT,prot INTEGER,const INTEGER,virt INTEGER,static INTEGER NOT NULL,explicit INTEGER,inline INTEGER,final INTEGER,sealed INTEGER,new INTEGER,optional INTEGER,required INTEGER,mutable INTEGER,initonly INTEGER,readable INTEGER,writable INTEGER,gettable INTEGER,settable INTEGER,accessor INTEGER,addable INTEGER,removable INTEGER,raisable INTEGER,kind INTEGER,id_bodyfile INTEGER,bodystart INTEGER,bodyend INTEGER,detaileddescription TEXT,briefdescription TEXT,inbodydescription TEXT)NÚûöñìçâÝØÒÌÆÀº´®¨¢œ–Š„~xrlf`ZTNÒƒ?΃/̓˃ǃÂw‚g¿‚Z¹‚H·‚6¶‚'µ‚´‚­‚ ªyxigWbGa7W-SJIBr9`2N1?06),  !ø!\Xm 11ƒtablederivedcompoundrefderivedcompoundrefCREATE TABLE derivedcompoundref (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, base TEXT NOT NULL,derived TEXT NOT NULL,refid TEXT NOT NULL,prot INTEGER NOT NULL,virt INTEGER NOT NULL)d ++‚tablebasecompoundrefbasecompoundrefCREATE TABLE basecompoundref (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, base TEXT NOT NULL,derived TEXT NOT NULL,refid TEXT NOT NULL,prot INTEGER NOT NULL,virt INTEGER NOT NULL)‚ ##ƒQtablecompounddefcompounddef CREATE TABLE compounddef (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,name TEXT NOT NULL,kind TEXT NOT NULL,prot INTEGER NOT NULL,refid TEXT NOT NULL,id_file INTEGER NOT NULL,line INTEGER NOT NULL,column INTEGER NOT NULL)µÝûöñìçâÝØÓÍÇÁ»µØ;É/Á¾»¬y©kz^XRHBA4:' ÕûöñëåßÙÓÍÇÁ»µ¯©£²„2ˆ„ƒƒsƒQqƒ*iƒc‚mZ‚KV‚/P‚E_;A7$+#dD!MãûõïéãÝ×ÑËÅ¿¹³­§¡›•‰ƒ}wqke_YSMá”\×”Ô“/Ó’YÏ’Ì‘/ÆYÀ½*¼ŽR¸y³ ¯ŒD®‹h™‹ „Š3‰^r‰lˆ1f‡\^‡U†1M…\D…>„+3ƒR*‚z$‚Ce ß;ƒß!++ytableinnernamespacesinnernamespacesCREATE TABLE innernamespaces (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,refid TEXT NOT NULL,name TEXT NOT NULL)5--‚tablememberdef_paramsmemberdef_paramsCREATE TABLE memberdef_params (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,id_memberdef INTEGER NOT NULL,id_param INTEGER NOT NULL)B ‚_tableparamsparamsCREATE TABLE params (rowid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,attributes TEXT,type TEXT,declname TEXT,defnname TEXT,array TEXT,defval TEXT,briefdescription TEXT)ðíûöðé¦X¥, gÌK¾%!( O)I?)  ad0323f84e9cee8227f1ad0d142aa7721AbstractFactorAbstractFactor::AbstractFactor(const AbstractFactor &x)AbstractFactor#+( O)I/)  a9d2c183bf9d96aa0f2b5f444f7aed883AbstractFactorAbstractFactor::AbstractFactor(const int &vars)AbstractFactor ( O)I)   a7f8f62dae0aa093cc83c8a9eb5921da6AbstractFactorAbstractFactor::AbstractFactor()AbstractFactor ( O?)a8ad323339da0a16248927aee2eb99e44_varsint AbstractFactor::_varsintAbstractFactorÿ(  O-Y5  Da63786caa251620f796f5901eeb2b3812~_builtinInfAlgsdai::_builtinInfAlgs::~_builtinInfAlgs()dai::_builtinInfAlgsDG(  O+W5  a1e37d38a271a46e1387bf6227b881ced_builtinInfAlgsdai::_builtinInfAlgs::_builtinInfAlgs()dai::_builtinInfAlgsB ŽiÐ5´'Ž ( O)I/)  a9d2c183bf9d96aa0f2b5f444f7aed883AbstractFactorAbstractFactor::AbstractFactor(const int &vars)AbstractFactor ( O)I)   a7f8f62dae0aa093cc83c8a9eb5921da6AbstractFactorAbstractFactor::AbstractFactor()AbstractFactor  ( O?)a8ad323339da0a16248927aee2eb99e44_varsint AbstractFactor::_varsintAbstractFactorÿ (  O-Y5  Da63786caa251620f796f5901eeb2b3812~_builtinInfAlgsdai::_builtinInfAlgs::~_builtinInfAlgs()dai::_builtinInfAlgsDG(  O+W5  a1e37d38a271a46e1387bf6227b881ced_builtinInfAlgsdai::_builtinInfAlgs::_builtinInfAlgs()dai::_builtinInfAlgsB( O+[)   aba84ec4080ec3ed10171ebac195fe998~AbstractFactorvirtual AbstractFactor::~AbstractFactor()AbstractFactor [¿s@ à­xEÑ”U á¤[G =M std::basic_istringstreamclassclassstd_1_1basic__istringstream; 1A std::basic_istreamclassclassstd_1_1basic__istream= 3C std::basic_iostreamclassclassstd_1_1basic__iostream3 )9 std::basic_iosclassclassstd_1_1basic__ios= 3C std::basic_ifstreamclassclassstd_1_1basic__ifstream; 1A std::basic_fstreamclassclassstd_1_1basic__fstream5 +; std::bad_typeidclassclassstd_1_1bad__typeid; 1A std::bad_exceptionclassclassstd_1_1bad__exception1 '7 std::bad_castclassclassstd_1_1bad__cast3 )9 std::bad_allocclassclassstd_1_1bad__alloc1 '7 std::auto_ptrclassclassstd_1_1auto__ptr* !/ std::arrayclassclassstd_1_1array2 )7 std::allocatorclassclassstd_1_1allocator1 )3 AbstractFactorclassclassAbstractFactorJ 9 S dai::BP_dual::_edges_tstructstructdai_1_1BP__dual_1_1__edges__t+? 5E  dai::_builtinInfAlgsclassclassdai_1_1__builtinInfAlgs ^Á„;¹OʈIô™^9 /= dai::ClusterGraphclassclassdai_1_1ClusterGraph"' + dai::CBPclassclassdai_1_1CBP)0 %5 dai::BP_dualclassclassdai_1_1BP__dual'% ) dai::BPclassclassdai_1_1BP ?, #1 std::bitsetclassclassstd_1_1bitset= 3A dai::BipartiteGraphclassclassdai_1_1BipartiteGraph -@ 5E std::binary_functionclassclassstd_1_1binary__function pF 7 M dai::BP_dual::beliefsstructstructdai_1_1BP__dual_1_1beliefs<; 3= BBPCostFunctionBaseclassclassBBPCostFunctionBase*? 5C dai::BBPCostFunctionclassclassdai_1_1BBPCostFunction*' + dai::BBPclassclassdai_1_1BBPCE ;K std::basic_stringstreamclassclassstd_1_1basic__stringstream9 /? std::basic_stringclassclassstd_1_1basic__stringG =M std::basic_ostringstreamclassclassstd_1_1basic__ostringstream; 1A std::basic_ostreamclassclassstd_1_1basic__ostream= 3C std::basic_ofstreamclassclassstd_1_1basic__ofstream $³^$ë­rÁ€(Ð$[ AMAstd::basic_istream< Char >std::basic_istringstream< Char >classstd_1_1basic__istreamM 9A9 std::basic_ios< Char >std::basic_istream< Char >classstd_1_1basic__iosV ACAstd::basic_ostream< Char >std::basic_iostream< Char >classstd_1_1basic__ostreamV ACAstd::basic_istream< Char >std::basic_iostream< Char >classstd_1_1basic__istream? '97std::ios_basestd::basic_ios< Char >classstd_1_1ios__baseVACAstd::basic_istream< Char >std::basic_ifstream< Char >classstd_1_1basic__istreamWCACstd::basic_iostream< Char >std::basic_fstream< Char >classstd_1_1basic__iostream9)+7std::exceptionstd::bad_typeidclassstd_1_1exception<)17std::exceptionstd::bad_exceptionclassstd_1_1exception7)'7std::exceptionstd::bad_castclassstd_1_1exception8))7std::exceptionstd::bad_allocclassstd_1_1exceptionSKC1std::vector< std::vector< T > >dai::BP_dual::_edges_t< T >classstd_1_1vectorKO5+std::map< std::string, InfAlg * >dai::_builtinInfAlgsclassstd_1_1map .¨YüžVÝE ç²p.@A'1dai::DAIAlg< FactorGraph >dai::ExactInfclassdai_1_1DAIAlg@-/=std::logic_errorstd::domain_errorclassstd_1_1logic__error3)#3AbstractFactorDenseFactorclassAbstractFactor$1GRMdai::DAIAlg< GRM >classGRM6#11dai::InfAlgdai::DAIAlg< GRM >classdai_1_1InfAlgV=;Kdai::ParameterEstimationdai::CondProbEstimationclassdai_1_1ParameterEstimation>--;dai::FactorGraphdai::CobwebGraphclassdai_1_1FactorGraph;A1dai::DAIAlg< FactorGraph >dai::CBPclassdai_1_1DAIAlg:A1dai::DAIAlg< FactorGraph >dai::BPclassdai_1_1DAIAlgF35=BBPCostFunctionBasedai::BBPCostFunctionclassBBPCostFunctionBase\CKCstd::basic_iostream< Char >std::basic_stringstream< Char >classstd_1_1basic__iostream[AMAstd::basic_ostream< Char >std::basic_ostringstream< Char >classstd_1_1basic__ostreamM9A9 std::basic_ios< Char >std::basic_ostream< Char >classstd_1_1basic__iosVACAstd::basic_ostream< Char >std::basic_ofstream< Char >classstd_1_1basic__ostream !qîÔ²‚lYG5"üä̱b5ײ„lZ>,íÙ¹žq+! Gconst std::vector< size_t > *state )const InfAlg &bp 3const FactorGraph &fg Real &mag size_t &_I size_t &i Real &new_s Real &s %const Prob &adj_w RealZ_w %const Prob &w, Gconst std::vector< size_t > *stateP# ;const BBPCostFunction &cfn- Cconst std::vector< Prob > &adj_psi_F- Cconst std::vector< Prob > &adj_psi_V+ Cconst std::vector< Prob > &adj_b_F+ Cconst std::vector< Prob > &adj_b_V  3const PropertySet &opts )const InfAlg *ia %const Prob &f %const Prob &p size_t_J size_t_j size_t_i size_tI size_ti size_t_I size_tiChar typenameCharChar typenameTT  9const AbstractFactor &x #const int &vars classTT #WÙÉ¢‡s_:!çÈ°‰vb4ôÚµ¡ŽwdI"åÊ´‚oWD boolwithout_iC size_tvsB )const VarSet &vsA #const Var &v@ !const BP &x? typenameBitsBits > 9const BipartiteGraph &g= )std::ostream &os%< 9const BipartiteGraph &xfalse; boolincludefalse: size_tn19 size_tn1true8 size_tn27 size_tn10#6 Atypename NodeInputIterator5 size_tsizeHint04 /NodeInputIteratorend3 /NodeInputIteratorbegin,2 Atypename NodeInputIteratorchecktrue1 size_t_i10 size_ti2/ size_t_i2. size_ti1- boolchecktrue, /EdgeInputIteratorend+ /EdgeInputIteratorbegin* size_tnrNodes2) size_tnrNodes1#( Atypename EdgeInputIterator' size_tnr2& size_tnr1% )const InfAlg &ia%$ Cconst BBPCostFunctionBase &x# Realh%" 3const PropertySet &bbp_props eØøðèàØÐÈÀ¸°¨ ˜ˆ€xph`XPH@80( øðèàØÐÈÀ¸°¨ ˜ˆ€xph`XPH@80( øðèàØÐÈÀ¸°¨ ˜ˆ€xph`XPH@80( øðèàØeÿ-dÿ,cÿ+bÿ*aÿ)`ÿ'_ÿ&^ÿ$]ÿ\ÿ%[ÿ$Zÿ#YÿXÿ"Wÿ!Vÿ UÿTÿSÿRÿQÿPÿOÿNÿMÿLÿKÿ Jÿ IÿHÿGÿ Fÿ EÿDÿCÿBÿAÿ@ÿ?ÿ>ÿ=ÿ<ÿ;ÿ:ÿ9ÿ8ÿ7ÿ6ÿ5ÿ4ÿ3ÿ2ÿ 1ÿ0ÿ/ÿ .ÿ-ÿ,ÿ+ÿ*ÿ)ÿ(ÿ'ÿ&ÿ%ÿ$ÿ#ÿ"ÿ!ÿ ÿÿÿÿÿÿÿÿÿ ÿ ÿ ÿ ÿ ÿ ÿ ÿÿÿ ÿ ÿ ÿ  ÿ  ÿ  ÿ ÿÿÿÿÿÿ ^ÌøðèàØÐÈÀ¸°¨ ˜ˆ€xph`XPH@80' úñèßÖÍÄ»²© —Ž…|sjaXOF=4+"þõìãÚÑÈ¿¶­¤›’‰€wne\SJA8/& ùðçÞÕÌCÿBÿAÿ@ÿF?ÿ >ÿF=ÿ<ÿ;ÿ:ÿE9ÿ8ÿ7ÿ6ÿ5ÿ4ÿ3ÿ2ÿD1ÿ 0ÿ/ÿ.ÿ-ÿ,ÿ+ÿ*ÿ)ÿ(ÿ'ÿ&ÿ%ÿ$ÿ#ÿ"ÿ!ÿ ÿÿCÿBÿ ÿÿBÿAÿÿÿ@ÿ@ÿÿÿ>ÿ=ÿ=ÿ<ÿ;ÿ8 ÿ; ÿ: ÿ8 ÿ: ÿ8ÿ:ÿ8ÿ:ÿ8ÿ:ÿ8ÿ:ÿ8ÿ9ÿ-~ÿ8}ÿ7|ÿ5{ÿ4zÿ3yÿ5xÿ4wÿ3vÿ-uÿ,tÿ+sÿ*rÿ)qÿ0pÿ0oÿ.nÿ.mÿ1lÿ0kÿ1jÿ0iÿ/hÿ.gÿ/fÿ. N=dÚ´ŽgAôͲ§Z'3 çÙÁ›t=‹N&Oa124aabb51e1b8e52ab6d9d62e938b7ac%&Oa00375a4d7b55534c14f993c909b04c3cˆ&Oa13e0ffe16298c7be7f448ad35ad6fa82 &Oa0ae27f56ca9a4d285772921d7555f6b19&Oa1091a5da35d620692783a17dbf265158]&Oa05a9012934012426c9ea6a5d8ba26a72h&Oa0e910ae9247869ee549df8eed173a6df|&&Oa1248e3988e6b78b275ee68287a613ac2—%Oa1134a0eea0cfe45a62198a297bf32b7fz%Oa10a491805ac80fb701028bf0e8fcda7eT%Oa0fe521e9633f7327f8c8335a5e718638j%Oa0f7c0df5e3409e0a840686f144caaf30(&Oa0ec4068ab9fe8a5690f560a2e7d778fcÎ&Oa0ce242f87aa02bac9d603f89b50a2451Ç%Oa0cb633f4b26b5a13c03dc532e263e61c %Oa0bb57567044b5ba964eb7ba479b1fb7a&Oa0ade6772ff232cead91c887338fa7c6bØ&Oa0a76e072fc766e6a7ec4e1dadfb3d1e4%Oa075f89dbdc79429fd78b62a6d3849063%Oa05ff600cceba50b8064c4023747912a5,&Oa038dedcc2e4810bf072d829a693859bfÞ%Oa0174fd852e724bd48e040ed9c5a0ca448%Oa01729ffd68fb5b32f021bd8f59d2f065i%Oa014dde3f2b7ec66332fb1cbe00538b89Y ¾_® X—IûÔÙ²‹1e_>ñË"¥p†¾­:&Oa21deaa91800f5ff86df64e0030057563G&Oa26f755375f7302f3cad54098c1064347E%Oa147ceaf651f4f3dcfef7057c09ffb7bc&Oa1a46412aa54525a5f9ea332ad1048f2aƒ&Oa1a19802d6b49b4d488d908f7e0b0a0ceË&Oa246c23914fee45f8b7f01f9073bdd6feY&Oa1959bfaf52d37ee89151540faae18a14&Oa269bd60101452a427cc794572a6018a6g&Oa177194e1a32e016c3b59376443e9dcc1ÕL&Oa16465ce3d62a6456fd06e9a226c966f2Š&Oa205aca5e7688c28a95ecc978b4f79879&Oa17520d36314443f8e9c2761695c4a68f?%Oa268a8e8d32c78594cd12b504abdc8e36\%Oa25f3ffef7d09bbea7fe4ec69840395b3f%Oa23a45a96ea996832c667d346c99bc7609&Oa2395b393cfa1b05ed5eb8984bb06de0f%Oa23271880a30ebb198bac41a1638258d87&Oa22bcf17b9eb7d6680d163eafff62e325*%Oa21bdb0ca1a92339709ceb86ea696260c_&Oa1f4a5f8e20582ec271009604893bb222¸&Oa1cb94d00b6f5ff6a3f708a06e1b9a6ec&Oa1ad2b3713a0588cdda7f8b3f9ff2611bê RÛ¨ƒ^9#ã¾™tO0 سŽiN)ߺœwR#Oacdfb5e4da942d55f02540d7a5fc29145#Oafdc73b83924ea54de96b90b9367e5df2Aclassdai_1_1BipartiteGraph#Oa0bb57567044b5ba964eb7ba479b1fb7a#Oa311cd7f2a141022a8f7b2b9ece9ad54a#Oa58489efe89114b2afa9e250ef03bbf4d#Oaff430369632930fca8b328180ce87d9a;classdai_1_1FactorGraph#Oa2d7fde3ef3a9beb69dfde9d71bd30646#Oa403799e0ba09a3eaf9fb97f78faa3198#Oa440e71ba670b2c108f08d3f477da699e1knamespacedai_1ae7d0472fdc89a8635825d01940e91cbf#Oafb1021aaed050bf090adaee7a0eda17b Cclassdai_1_1BBPCostFunction# Oa0cb633f4b26b5a13c03dc532e263e61c# Oa9ba932b768dff5a0b78fcac5d02088fb# Oa6a3b13b021a2823036dfa52037955307# Oa57aa22969b5feca8d2506262b9b2a2ca#Oa413168256e1eea300269422dfbfbd1e0;classdai_1_1PropertySet1classdai_1_1InfAlg#Oad181ae777f715e6659aeaefe552b9e6a#Oae3517f9e23e01e188055361bd0084005#Oa075f89dbdc79429fd78b62a6d38490631knamespacedai_1a90f06137ef74bb483e30ee2c7e31b2c8#Oa3bc7caeec63b50668e51fd87b110c662 ?ÛɤZG" çÂxS. ä¿šuP+øÓ®‰d?#5Oa6a80d5a63b0e2c3e9cf81f92fd0456a5#4Oa5509e79c9c41d7219104eaf07fce6a36#3Oaa4c5e31aeedeb2a02018024948ae197f#2Oa85b152e74a123d348253b5cef6d6ff16#1Oac0aafe3dbcdfb24cac6cf8c1fa7a2efb10knamespacedai_1a7515abf9952cd312e95a34ada0670e85#/Oae5315044de332e92a6ed12acce7f0f75#.Oaaf65e36b21311c3b87bbe98464686f75#-Oa61c78c13bcc18b2e160b5bccaa9afe3b#,Oa05ff600cceba50b8064c4023747912a5#+Oae6070148d57ea999a3a1980b54df9318#*Oa511c8853382d1d506f6c08b097895c22#)Oaef5d551a623efc6e6b9c9e10e97b9805#(Oa0f7c0df5e3409e0a840686f144caaf30#'Oabd4a62c43f86f5b17c774f6a71d46950#&Oada42bd8c274d16179909327d8d062991#%Oaadcfd932c08690541849847e720e950f#$Oa6a169aace3fd0538e79cef8392cfe2a4##Oab711dcd5db848b6d993fac482b64ee20"1classdai_1_1VarSet#!Oa6e30add24796c14c7e45adcaa7e73e62 +classdai_1_1Var#Oab480cc0971e4c417867952425e28a281#Oa147ceaf651f4f3dcfef7057c09ffb7bc#Oaba6124da6c2a11b01c0f66cbe8ae9562)classdai_1_1BP#Oae8480cbb4a614119a211ffc03221ba47 OðÞ˶žmP1Ó {a7$ìÁ§uT2úèÖ£ƒfOd %const char *c booldebuggingfalseb %NeighborTypeneighbors1a Ostd::vector< SmallSet< size_t > >regions` size_tj_ size_tR^ size_tmaxStates0] /EliminationChoicef \ ;class EliminationChoice[ 5const ClusterGraph &clZ )const VarSet &clY #const Var &nX #boolonlyMaximal)W Gconst std::vector< VarSet > &clsV #boolclampingVarU )const InfAlg &in_bpT ReallogZ(S Gconst std::vector< Factor > &bsR Real *maxVarOut#Q ;std::vector< size_t > &xis1P ;/std::vector< size_t > &clamped_vars_list+O ;#std::vector< Factor > &beliefs_outN Real &lz_outM Real &sum_levelL %size_t &choose_countK !size_t &num_leaves/J 7/std::vector< size_t >clamped_vars_listI Realorig_logZH InfAlg *bpG size_tvsF Prob &pE Realr \Ä÷îåÜÓÊÁ¸¯¦”‹‚ypg^ULC:1( ûòéà×Îż³ª¡˜†}tkbYPG>5,#ÿöíäÛÒÉÀ·®¥œ“Šxof]TKB90' úñèßÖÍÄ‚ÿ_‚ÿ‚ÿ_‚ÿ_‚ÿ_‚ÿ_‚ÿ_‚ÿ_‚ÿ_‚ÿ`‚ÿ_‚ÿ`‚ÿ_‚ÿ_‚ÿ_‚ÿ_‚ÿ_‚ÿ‚ ÿ^‚ ÿ]‚ ÿ[‚ ÿ=‚ ÿ‚ÿ‚ÿZ‚ÿ ‚ÿ0‚ÿ.‚ÿ‚ÿ‚ÿZ‚ÿYÿ ~ÿ}ÿX|ÿ{ÿWzÿRyÿxÿ"wÿVvÿUuÿTtÿSsÿRrÿQqÿpÿPoÿHnÿOmÿNlÿMkÿLjÿKiÿJhÿIgÿHfÿeÿdÿcÿGbÿBaÿ `ÿ_ÿB^ÿA]ÿ\ÿ[ÿ ZÿYÿ XÿWÿVÿUÿTÿSÿRÿQÿPÿOÿNÿMÿLÿKÿJÿIÿHÿGÿFÿ EÿDÿ @‹óå×É»­Ÿ‘ƒugYK=/!÷éÛÍ¿±£•ˆzl^PB4& üîàÒĶ©œ‚uh[NA3% ûíßÑõ§™‹ @ 3ù ? 3 ù > 3ù = 3ù < 2æ ; 20æ : 1Ú 9 1Ú 8 /0Ï 7 /Ï 6 /Ï 5 /Ï 4 /Ï 3 .H 2 .H 1 -^ 0 ,"Y / +"S . * R - )P , )P + (f * '  ) &  ( % ü ' $ Ð & #" Ë % !"  $  Á #  ¿ "  ¿ !  ¨   ¢   œ   œ   K   /  6  ¤   ¤  ¤  ¤      ù  ÷  ÷  ò  ò  ò  4  +  &  !  !              ê  è   ä AŠóæÙ̾°£•‡yk^PB4& üïâÕǹ«seXK>1$ ýðãÖÉ»­Ÿ‘ƒuhZM?1#ùëÝÏÁ³¦˜Š  r2S  q2J  q2J ~ p/h } o/b | n"/% { m"/" z l0/ y k0/ý x j"/Æ w i"/¾ v h"/¨ u g"/ t f /’ s e0/S r dc*Œ q bc*m p `*Ÿ o `P*Ÿ n `*Ÿ m `a*Ÿ l `a*Ÿ k `a*Ÿ j _"'] i ^'S h ]"'O g \"'F f [ 'E e Z'C d Z'C c Y': b Y': a X $L ` W$4 _ UV$, ^ TQž ] S„ \ R{ [ RP{ Z Or Y OQr X Or W OPr V NL"> U ML"9 T KL"6 S J" ÿ R I" ú Q HG P FG O E… N D• M C‘ L Bz K A= J @= I >?ô H <=à G ;h F 9:Ð E 8"— D 7"` C 6 [ B 5: A 4"4 U\Ò=Ù²‹d\ƒªø.๒lEÑñÊ£|Uˆ&Oa3b73d7c4dc8c88725fb26da4d8089&Oa2afe0ebb307f835920656e75f9a1961eS&Oa2cccf0cd38b68a3b22b167b2af90e518&Oa2d46eaa02bcc8ff6a0a480302cdcd7c0%Oa28c7dc4daf39c3debb087e52d7cccd1aA%Oa2d7fde3ef3a9beb69dfde9d71bd30646&Oa28fad4d7ae2fbd669adb66e6ff68aa8c&Oa315cd21d6454d9f3b677af43a5977b27Ê%Oa311cd7f2a141022a8f7b2b9ece9ad54a&Oa30ea8a783f28550835226f139fa87e97&Oa30e73d762d643d9cd20dd7a06126ed52ç&Oa30364f948c89de11c4708b0c3b131a92&Oa2f0ced4bc2927eea87bf14438aa63f8e&Oa2e0ccbad2966a265471a939855be73b2èèè&Oa29c0e906e26c7484c268d111c71f79da”&Oa2afce2bdf9612aeb82935f02c87f3215&Oa2aeaf6c4106d09935a038895d9563bc9B&Oa2a7c09e89e9be126ae75fa23adf57c3cª&Oa2a57b201409b36909b8c336a2748ac81Œ HÛ¶‘lP+îÉ®‰d?õЫ˜sN)ïÊ¥€hHQEclassdai_1_1MaximizationStepP5classdai_1_1Evidence#OOaf062d83cd85b5eb6571373aef78bcc78#NOac12ac5065e77dc3040d464405fe1f609#MOab2378683166fd3eb5518edce5823c1edL/classdai_1_1DEdge#KOaac85e6f5aa72f552c3d6a6fd7941d2db#JOa333a182249b2abeb93ff21377d0e8ffd#IOac74e4ae749a3f706462bb5c0c0f204ca#HOa58c0f9a380d5c4dd348aa701a142c127G+classdai_1_1DAG#FOac3100fa72427f00a2867e40419c5ae2d#EOadd12b9035b91ef9d27a0c1a24bbd0064#DOa27ef52cae918a8e91913d92b0e4e6fa5#COaf8ac0b97fc2059c27793f81f7424fa2f#BOa548db9c240464901a5d5cc37fe0e8caa#AOa28c7dc4daf39c3debb087e52d7cccd1a#@Oaa3c2759ac28711b05a4d607da0b4b26d?;classdai_1_1CobwebGraph#>Oa73e0206b02ac2989cf407005a69d9a2d=5classdai_1_1SmallSet#<Oaa8bb4312e60a0bf2b0501773e9356bfd#;Oa8c8df69ed14b2751eef3cc65136b0310:=classdai_1_1ClusterGraph#9Oa23a45a96ea996832c667d346c99bc760#8Oa0174fd852e724bd48e040ed9c5a0ca44#7Oa23271880a30ebb198bac41a1638258d8#6Oabd0f148c5953b0ec4340e1b1c37ab0ef =Ç—Pû®P¥Gòˆ=I, =Q std::set::const_iteratorclassclassstd_1_1set_1_1const__iteratorh+ [q std::unordered_multimap::const_iteratorclassclassstd_1_1unordered__multimap_1_1const__iteratorS* G[ std::multimap::const_iteratorclassclassstd_1_1multimap_1_1const__iterator\) Oe std::basic_string::const_iteratorclassclassstd_1_1basic__string_1_1const__iterator^( Qg std::unordered_map::const_iteratorclassclassstd_1_1unordered__map_1_1const__iteratorI' =Q std::map::const_iteratorclassclassstd_1_1map_1_1const__iterator\& Oe std::forward_list::const_iteratorclassclassstd_1_1forward__list_1_1const__iteratorK% ?S std::list::const_iteratorclassclassstd_1_1list_1_1const__iteratorS$ EY dai::CobwebGraph::Connectionstructstructdai_1_1CobwebGraph_1_1Connection%E# ;I dai::CondProbEstimationclassclassdai_1_1CondProbEstimationh." %3 std::complexclassclassstd_1_1complex7! -; dai::CobwebGraphclassclassdai_1_1CobwebGraph" [Ç÷îåÜÓÊÁ¸¯¦”‹‚ypg^ULC:1( ûòéà×Îż³ª¡˜†}tkbYPG>5,#ÿöíäÛÒÉÀ·®¥œ“Šxof]TKB90& øîäÚÐÇ‚zÿ=‚yÿ„‚xÿ„‚wÿƒ‚vÿ‚‚uÿB‚tÿ ‚sÿB‚rÿ ‚qÿ‚pÿ€‚oÿ‚nÿ‚mÿ‚lÿ~‚kÿ‚jÿ}‚iÿ{‚hÿ=‚gÿ=‚fÿz‚eÿ8‚dÿ:‚cÿy‚bÿu‚aÿy‚`ÿu‚_ÿu‚^ÿu‚]ÿx‚\ÿu‚[ÿw‚Zÿu‚Yÿ8‚Xÿ:‚Wÿ8‚Vÿ:‚Uÿu‚Tÿ-‚Sÿ8‚Rÿ:‚Qÿ5‚Pÿ4‚Oÿ3‚Nÿ-‚Mÿ,‚Lÿ+‚Kÿr‚Jÿu‚Iÿu‚Hÿv‚Gÿu‚Fÿv‚Eÿu‚Dÿu‚Cÿu‚Bÿt‚Aÿu‚@ÿt‚?ÿs‚>ÿ-‚=ÿ,‚<ÿ+‚;ÿr‚:ÿr‚9ÿq‚8ÿp‚7ÿ ‚6ÿo‚5ÿn‚4ÿm‚3ÿc‚2ÿb‚1ÿl‚0ÿk‚/ÿj‚.ÿi‚-ÿh‚,ÿg‚+ÿf‚*ÿf‚)ÿe‚(ÿd‚'ÿd‚&ÿc‚%ÿb‚$ÿa‚#ÿ‚"ÿ_‚!ÿ_‚ ÿ #wíÔ¶Ÿ‘ƒq6üÛ¸›|iS@.óÛÄ­™€nT'ýéϵw InfAlg &estep" -const Evidence &evidenceT 'const DEdge &e 'const DEdge &x size_tm2 size_tm1 boolbackup* 7std::vector< size_t >facIndsfalse boolbackupfalse~ size_tx} #const GRM &grm| class GRM{ #const DAG &gz #const DAG &xy boolinclusivex size_tcw size_tptruev size_t_cu size_tnt size_t_ps size_tntruer size_tnrq 3const PropertySet &pp %const Prob ¶ms!o %%const Prob &pseudocountsn -size_ttarget_dimension8m Sstd::vector< SmallSet< size_t > > ®ionsfalse9l _const std::vector< SmallSet< size_t > > ®ionsk CLOSEST j TOP i ALLh %NeighborTypeg 3const CobwebGraph &f )std::ostream &e size_t15 ˆ00ÒŸr@Û¥UwãF±Kã°{ˆ$M/home/jorism/vcs/libdai/config.hi2i/home/jorism/vcs/libdai/include/dai/createfg.hh{)1e/home/jorism/vcs/libdai/include/dai/decmap.h¨5m/home/jorism/vcs/libdai/include/dai/dai_config.h‘0e/home/jorism/vcs/libdai/include/dai/alldai.hj/a/home/jorism/vcs/libdai/include/dai/enum.hªh2i/home/jorism/vcs/libdai/include/dai/evidence.h$/c/home/jorism/vcs/libdai/include/dai/emalg.h0e/home/jorism/vcs/libdai/include/dai/daialg.h -_/home/jorism/vcs/libdai/include/dai/dag.h5o/home/jorism/vcs/libdai/include/dai/cobwebgraph.h6q/home/jorism/vcs/libdai/include/dai/clustergraph.h-_/home/jorism/vcs/libdai/include/dai/cbp.h1g/home/jorism/vcs/libdai/include/dai/bp_dual.h,]/home/jorism/vcs/libdai/include/dai/bp.h 2i/home/jorism/vcs/libdai/include/dai/bipgraph.h -_/home/jorism/vcs/libdai/include/dai/bbp.h ‘1\Êœk1; Ýc­€#S&÷ÂõÑ._/home/jorism/vcs/libdai/include/dai/glc.hÉ-]/home/jorism/vcs/libdai/include/dai/io.hÌ’8s/home/jorism/vcs/libdai/include/dai/matlab/matlab.hÎ0e/home/jorism/vcs/libdai/include/dai/factor.hW4m/home/jorism/vcs/libdai/include/dai/exceptions.h*4m/home/jorism/vcs/libdai/include/dai/properties.hP.a/home/jorism/vcs/libdai/include/dai/prob.h ,]/home/jorism/vcs/libdai/include/dai/mr.hK,]/home/jorism/vcs/libdai/include/dai/mf.hH,]/home/jorism/vcs/libdai/include/dai/lc.hE/c/home/jorism/vcs/libdai/include/dai/jtree.hB/c/home/jorism/vcs/libdai/include/dai/index.h@-_/home/jorism/vcs/libdai/include/dai/hak.h;/c/home/jorism/vcs/libdai/include/dai/graph.h80c/home/jorism/vcs/libdai/include/dai/gibbs.hÈ-_/home/jorism/vcs/libdai/include/dai/fbp.h25o/home/jorism/vcs/libdai/include/dai/factorgraph.h/ >Ö¥”cZ- ùË™‡[/#ýÒ¥˜q;%õÀ«|M> #dai/emalg.h-c/home/jorism/vcs/libdai/include/dai/emalg.h-c/home/jorism/vcs/libdai/src/cobwebgraph.cpp/dai/cobwebgraph.h3o/home/jorism/vcs/libdai/include/dai/cobwebgraph.h.e/home/jorism/vcs/libdai/src/clustergraph.cpp1dai/clustergraph.h4q/home/jorism/vcs/libdai/include/dai/clustergraph.h%S/home/jorism/vcs/libdai/src/cbp.cpp dai/cbp.h+_/home/jorism/vcs/libdai/include/dai/cbp.h)[/home/jorism/vcs/libdai/src/bp_dual.cpp$Q/home/jorism/vcs/libdai/src/bp.cpp dai/bp.h* ]/home/jorism/vcs/libdai/include/dai/bp.h* ]/home/jorism/vcs/libdai/src/bipgraph.cpp )dai/bipgraph.h0 i/home/jorism/vcs/libdai/include/dai/bipgraph.h, a/home/jorism/vcs/libdai/include/dai/prob.h%S/home/jorism/vcs/libdai/src/bbp.cpp dai/bbp.h+_/home/jorism/vcs/libdai/include/dai/bbp.h[STL]/g/home/jorism/vcs/libdai/include/dai/test1.cpp'dai/bp_dual.h/g/home/jorism/vcs/libdai/include/dai/bp_dual.h(Y/home/jorism/vcs/libdai/src/alldai.cpp EתvF6ÿ趤xF4ÔÀ^-øã´‡zSE 5!dai/prob.h%4S/home/jorism/vcs/libdai/src/fbp.cpp 3dai/fbp.h+2_/home/jorism/vcs/libdai/include/dai/fbp.h-1c/home/jorism/vcs/libdai/src/factorgraph.cpp0/dai/factorgraph.h3/o/home/jorism/vcs/libdai/include/dai/factorgraph.h/.g/home/jorism/vcs/libdai/include/dai/test4.cpp/-g/home/jorism/vcs/libdai/include/dai/test3.cpp/,g/home/jorism/vcs/libdai/include/dai/test2.cpp+-dai/exceptions.h2*m/home/jorism/vcs/libdai/include/dai/exceptions.h*)]/home/jorism/vcs/libdai/src/exactinf.cpp()dai/exactinf.h0'i/home/jorism/vcs/libdai/include/dai/exactinf.h*&]/home/jorism/vcs/libdai/src/evidence.cpp%)dai/evidence.h0$i/home/jorism/vcs/libdai/include/dai/evidence.h#3dai/weightedgraph.h5"s/home/jorism/vcs/libdai/include/dai/weightedgraph.h!%dai/daialg.h. e/home/jorism/vcs/libdai/include/dai/daialg.h%S/home/jorism/vcs/libdai/src/dag.cpp dai/dag.h+_/home/jorism/vcs/libdai/include/dai/dag.h'W/home/jorism/vcs/libdai/src/emalg.cpp t¯Oü§=ì?ÐtZ6 Mc std::map::const_reverse_iteratorclassclassstd_1_1map_1_1const__reverse__iteratorm5 _w std::forward_list::const_reverse_iteratorclassclassstd_1_1forward__list_1_1const__reverse__iterator\4 Oe std::list::const_reverse_iteratorclassclassstd_1_1list_1_1const__reverse__iteratorM3 AU std::deque::const_iteratorclassclassstd_1_1deque_1_1const__iteratorO2 CW std::vector::const_iteratorclassclassstd_1_1vector_1_1const__iteratorh1 [q std::unordered_multiset::const_iteratorclassclassstd_1_1unordered__multiset_1_1const__iteratorS0 G[ std::multiset::const_iteratorclassclassstd_1_1multiset_1_1const__iteratorQ/ EY std::wstring::const_iteratorclassclassstd_1_1wstring_1_1const__iterator^. Qg std::unordered_set::const_iteratorclassclassstd_1_1unordered__set_1_1const__iteratorO- CW std::string::const_iteratorclassclassstd_1_1string_1_1const__iterator E)º>
Eb? Uk std::wstring::const_reverse_iteratorclassclassstd_1_1wstring_1_1const__reverse__iteratord> Wm std::multiset::const_reverse_iteratorclassclassstd_1_1multiset_1_1const__reverse__iteratoro= ay std::unordered_set::const_reverse_iteratorclassclassstd_1_1unordered__set_1_1const__reverse__iterator`< Si std::string::const_reverse_iteratorclassclassstd_1_1string_1_1const__reverse__iteratorZ; Mc std::set::const_reverse_iteratorclassclassstd_1_1set_1_1const__reverse__iteratorz: k std::unordered_multimap::const_reverse_iteratorclassclassstd_1_1unordered__multimap_1_1const__reverse__iteratorm9 _w std::basic_string::const_reverse_iteratorclassclassstd_1_1basic__string_1_1const__reverse__iteratord8 Wm std::multimap::const_reverse_iteratorclassclassstd_1_1multimap_1_1const__reverse__iteratoro7 ay std::unordered_map::const_reverse_iteratorclassclassstd_1_1unordered__map_1_1const__reverse__iterator Q„"™i<ã¨i;üÅ„Q1N '5 dai::Evidenceclassclassdai_1_1Evidence$?M 5E std::error_conditionclassclassstd_1_1error__condition5L +; std::error_codeclassclassstd_1_1error__code=K 3C std::error_categoryclassclassstd_1_1error__category,J !/ dai::EMAlgclassclassdai_1_1EMAlgK=I / C dai::BP::EdgePropstructstructdai_1_1BP_1_1EdgeProp D9H /? std::domain_errorclassclassstd_1_1domain__error*G !/ std::dequeclassclassstd_1_1deque+F #- DenseFactorclassclassDenseFactor+E !/ dai::DEdgeclassclassdai_1_1DEdge"'.D #1 dai::DAIAlgclassclassdai_1_1DAIAlg Ï'C + dai::DAGclassclassdai_1_1DAG)^B Qg std::deque::const_reverse_iteratorclassclassstd_1_1deque_1_1const__reverse__iterator`A Si std::vector::const_reverse_iteratorclassclassstd_1_1vector_1_1const__reverse__iteratorz@ k std::unordered_multiset::const_reverse_iteratorclassclassstd_1_1unordered__multiset_1_1const__reverse__iterator X¹öíãÙÏÅ»±§ž”Š€vlbYPG>5,#ÿõìãÚÐƼ²¨ž”Š€vlbXND:0&þôëâÙÐǾµ¬£™…|sjaXOF=3*  ûòèÞÔ˹ƒRÿƒQÿ~ƒPÿƒOÿ¦ƒNÿ¦ƒMÿ«ƒLÿ ƒKÿ ƒJÿƒIÿªƒHÿƒGÿ©ƒFÿ ƒEÿ¨ƒDÿ ƒCÿ ƒBÿƒAÿƒ@ÿBƒ?ÿƒ>ÿBƒ=ÿƒ<ÿ§ƒ;ÿ¦ƒ:ÿ¦ƒ9ÿYƒ8ÿ ƒ7ÿ ƒ6ÿƒ5ÿƒ4ÿ ƒ3ÿƒ2ÿ ƒ1ÿƒ0ÿ¥ƒ/ÿ¤ƒ.ÿ£ƒ-ÿ¢ƒ,ÿ¡ƒ+ÿ ƒ*ÿƒ)ÿ™ƒ(ÿœƒ'ÿ™ƒ&ÿ›ƒ%ÿ›ƒ$ÿšƒ#ÿ˜ƒ"ÿ—ƒ!ÿ™ƒ ÿ˜ƒÿ—ƒÿ–ƒÿ•ƒÿ”ƒÿ“ƒÿ’ƒÿdƒÿdƒÿdƒÿ‘ƒÿBƒÿƒÿBƒÿ ƒÿƒÿBƒÿAƒÿƒ ÿƒ ÿƒ ÿƒ ÿƒ ÿŽƒÿƒÿŽƒÿƒÿŒƒÿqƒÿ‹ƒÿ‡ƒÿŠƒÿ‰‚ÿˆ‚~ÿ‡‚}ÿ†‚|ÿ‚{ÿ… 6¬G¨o!î·w;ýÄ{6CUAclassstd_1_1deque_1_1const__iteratorstd::deque::const_iteratorG YEstructdai_1_1CobwebGraph_1_1Connectiondai::CobwebGraph::Connection7 I5structdai_1_1CBP_1_1Propertiesdai::CBP::Properties< O 9structdai_1_1BP__dual_1_1messagesdai::BP_dual::messages: M 7structdai_1_1BP__dual_1_1beliefsdai::BP_dual::beliefs> S 9structdai_1_1BP__dual_1_1__edges__tdai::BP_dual::_edges_t5G3structdai_1_1BP_1_1Propertiesdai::BP::Properties1C /structdai_1_1BP_1_1EdgePropdai::BP::EdgePropL]Istructdai_1_1BipartiteGraph_1_1levelTypedai::BipartiteGraph::levelType7I5structdai_1_1BBP_1_1Propertiesdai::BBP::PropertiesViSclassstd_1_1basic__string_1_1reverse__iteratorstd::basic_string::reverse_iteratorEWCclassstd_1_1basic__string_1_1iteratorstd::basic_string::iteratorcw_classstd_1_1basic__string_1_1const__reverse__iteratorstd::basic_string::const_reverse_iteratorReOclassstd_1_1basic__string_1_1const__iteratorstd::basic_string::const_iterator aªr)æ’-æŽUÛ¤aAS?classstd_1_1list_1_1const__iteratorstd::list::const_iterator5G3structdai_1_1LC_1_1Propertiesdai::LC::Properties;M9structdai_1_1JTree_1_1Propertiesdai::JTree::Properties;M9classstd_1_1ios__base_1_1failurestd::ios_base::failure7I5structdai_1_1HAK_1_1Propertiesdai::HAK::PropertiesViSclassstd_1_1forward__list_1_1reverse__iteratorstd::forward_list::reverse_iteratorEWCclassstd_1_1forward__list_1_1iteratorstd::forward_list::iteratorcw_classstd_1_1forward__list_1_1const__reverse__iteratorstd::forward_list::const_reverse_iteratorReOclassstd_1_1forward__list_1_1const__iteratorstd::forward_list::const_iteratorAS?structdai_1_1ExactInf_1_1Propertiesdai::ExactInf::PropertiesGYEclassstd_1_1deque_1_1reverse__iteratorstd::deque::reverse_iterator6G5classstd_1_1deque_1_1iteratorstd::deque::iteratorTgQclassstd_1_1deque_1_1const__reverse__iteratorstd::deque::const_reverse_iterator ÑÙ³Œe>ñÊ£|U.๔mFøÑ&Oa3ff68e22e5bbd6a37142f6d759956fdfÓ&Oa3e65fbe83ba367cc54b6ae2fc59a0e39ô&Oa3dc75e63b05b1186858ba6825d3a2a4aF&Oa3cc3718d1fbdf67db23a846283f99d082&Oa3c5ffdef3221d23afa47edafde339299³$O a3bc7caeec63b50668e51fd87b110c662&Oa3b7a4334ac70694ea16160c0067b92e5™&Oa3b73d7c4dc8c88725fb26da4d8089caaÝ&Oa394197d7c57ab6f1dd5bad99df18d51c&Oa3afe96990b767effef2e2a857b74dee0‰&Oa3aafaddd7cfeb51b46606a4d77e99c41#&Oa395904b1e262b0b188d9d8277b4a0162<&Oa3930b35d8c209c4ec1fd0dd6c963cb26ò&Oa38ee418f4d5ac9136f13a087528a8718»&Oa38c683ce0ce0532625780e76f5eb5b9bT%Oa3800b4fc0c176d6d05b776289b11ad69R&Oa3780be9d74b4c1b0ed1713d7cab8211c†&Oa36f9ee114f04e1453b12c895ac6368e0ì&Oa365c52b5f264c844ac5c010026719350‘%Oa333a182249b2abeb93ff21377d0e8ffdJ&Oa3248cc18f8683a95e7d318e5c7d27258¼ MÍ |X5êÏŸ‹aJ/üéÕÀ¤‰rH ûÔ¯‹iM$ size_tnrFacHint0# -VarInputIteratorvarEnd!" -VarInputIteratorvarBegin"! 3FactorInputIteratorfacEnd$ 3FactorInputIteratorfacBegin" ?typename VarInputIterator% Etypename FactorInputIterator' Gconst std::vector< Factor > &P ostream &os )const Factor &f )const Factor &f0 Factor &f inttype0 doubled )const Factor &x boollogfalse boolsparsefalse !const Codec' 3#const std::string &detailedMsg Codecode- Istd::map< std::string, Var > &varMap 'FactorGraph &fg )std::istream &is, Estd::vector< Observation > &samples 1MaximizationStep &mstep! )!std::istream &mstep_file! -const Evidence &evidence* 3)const PropertySet &termconditions0 Ostd::vector< MaximizationStep > &msteps MÛ¶‘l1 çÂxS. ä¿Œg+á¼—rM#iOa01729ffd68fb5b32f021bd8f59d2f065#hOac7a2074bd52b7cb35a6473208140bb34#gOad40deb407b61be3a3f0d6f862983c51b#fOa25f3ffef7d09bbea7fe4ec69840395b3#eOafd0bbc52192c65e207d721906e3e0a2b#dOaae58f898e6570e76bb91912dd7157598:c}classdai_1_1Exception_1a03abb65a270707eca57262d8b569e92b#bOacfe1088cf3a677e92d05ac1dc234825b1aknamespacedai_1acbc670414e04eecf5c284e42d9d036e3#`Oafa381567faaf7abf0d1291389e576396#_Oa21bdb0ca1a92339709ceb86ea696260c#^Oa885f296c16fdeeb33f5fa51309db5c7b#]Oaace58f99e40bb4084c73d6b77fd26456#\Oa268a8e8d32c78594cd12b504abdc8e36#[Oa9fc5612a5b4930a51880949acf7341c9#ZOa4877ad65a296aa86cf4493de12b0b609#YOa014dde3f2b7ec66332fb1cbe00538b89#XOa7519ba1667a64e614f2161f2733e4a79#WOa86aa114bd9377d0f953bf28e5e2e9e879V{classdai_1_1Evidence_1ae322863268ee661c1209d6a5c4e8750e#UOadf6152701bfbb28221bd2e69e662b876#TOa10a491805ac80fb701028bf0e8fcda7e#SOab05088fa0e00f7bc2cf3b86c6aeadc07#ROa3800b4fc0c176d6d05b776289b11ad69 R͘dAÁ˜f+ï½~N踆R2` %7 dai::fo_log0structstructdai_1_1fo__log0 F0_ #5 dai::fo_logstructstructdai_1_1fo__log =.^ !3 dai::fo_KLstructstructdai_1_1fo__KL |2] %7 dai::fo_inv0structstructdai_1_1fo__inv0 [0\ #5 dai::fo_invstructstructdai_1_1fo__inv R.[ !3 dai::fo_idstructstructdai_1_1fo__id =Z /A dai::fo_Hellingerstructstructdai_1_1fo__Hellinger ˆ0Y #5 dai::fo_expstructstructdai_1_1fo__exp 4:X -? dai::fo_divides0structstructdai_1_1fo__divides0 p9W += dai::fo_absdiffstructstructdai_1_1fo__absdiff °0V #5 dai::fo_absstructstructdai_1_1fo__abs ('U + dai::FBPclassclassdai_1_1FBP2;ET 9M std::ios_base::failureclassclassstd_1_1ios__base_1_1failure7S -; dai::FactorGraphclassclassdai_1_1FactorGraph/A!R # FactorclassclassFactor,2Q )7 std::exceptionclassclassstd_1_1exception3P )7 dai::Exceptionclassclassdai_1_1Exception*O1O '5 dai::ExactInfclassclassdai_1_1ExactInf' l½{U®U¬^¿lQ'K+Estd::binary_function< T, T, T >dai::fo_KL< T >classstd_1_1binary__functionN&C/Cstd::unary_function< T, T >dai::fo_inv0< T >classstd_1_1unary__functionM%C-Cstd::unary_function< T, T >dai::fo_inv< T >classstd_1_1unary__functionL$C+Cstd::unary_function< T, T >dai::fo_id< T >classstd_1_1unary__functionX#K9Estd::binary_function< T, T, T >dai::fo_Hellinger< T >classstd_1_1binary__functionM"C-Cstd::unary_function< T, T >dai::fo_exp< T >classstd_1_1unary__functionW!K7Estd::binary_function< T, T, T >dai::fo_divides0< T >classstd_1_1binary__functionV K5Estd::binary_function< T, T, T >dai::fo_absdiff< T >classstd_1_1binary__functionMC-Cstd::unary_function< T, T >dai::fo_abs< T >classstd_1_1unary__function$)dai::BPdai::FBPclassdai_1_1BP@)97std::exceptionstd::ios_base::failureclassstd_1_1exceptionA1)Astd::runtime_errordai::Exceptionclassstd_1_1runtime__error UäÈ›jGá°R0ÞDZ›…oY?* îϱ•yU!A ;eliminationCostFunctionh@ +const GraphAL &G? 'InputIteratorend> 'InputIteratorbegin= 3class InputIterator< +const GraphAL &g; +const GraphAL &xtrue: size_t_n29 size_t_n2Ttrue8 const T &q7 const T &p6 const T &y5 !typename T4 const T &x3 !typename Tp%2 Cconst std::vector< Real > &c1 Realc0 size_tnrEdges/ 3const std::string &s15*. 7std::vector< size_t >facIndsfalse.- Gconst std::vector< size_t > &xIsfalse., Gconst std::vector< size_t > &xisfalse,+ Aconst std::set< size_t > &facsfalse4* Qconst std::map< size_t, Factor > &facsfalse ) )const Factor &newFactor.( Gconst std::vector< size_t > &statevec*' Gconst std::vector< size_t > &inds& )const VarSet &ns% size_tnrVarHint0 _óͦX1†ä½–o_H!úÓ­ Ú³&Oa4ac9b14596c7195e8401be42f18a4bf9x&Oa47ac972d2a1556524159ff0765ae19c5u%Oa4e042494d8e453005d0c8bfd788dc687n&Oa4c572b1ce73ce427af3ffdb6f6a73a45‹&Oa4b9e5254e7ec388e69aa68dfc54509e0X&Oa4b4c3f31cf1ed2fb04a3e2ae48465606î&Oa4b0c1aaf86d63308fb04b1805d85d482¬&Oa49ddd5c9c9f51ee9fb5e153b7194ac71«&Oa49d00fd7e213b351704b554c5c0039ce„&Oa4908ad29222b60d669d234d0805605b8ÿ%Oa4877ad65a296aa86cf4493de12b0b609Z&Oa4e662584f2066697602c41ce9b8f8984ö&Oa471d38b5a945d9eefe694fde30f78cccâ&Oa4655db9d766470f1a555cba7d3ec7190Š&Oa45912403206dece7aa792325378f9bcb+&Oa454801bc228b5826d37f4142d79751d0º%Oa440e71ba670b2c108f08d3f477da699e%Oa413168256e1eea300269422dfbfbd1e0t%Oa511c8853382d1d506f6c08b097895c22*&Oa50d919bf70f5740e6fd2f3b2358a6545 %Oa506a66f1b25e49700f6ae564a5c33531k PÛ¶‘lG"ýسŽiDúã¾™t'ݸœvP#Oaa208216fc2982c0a4af71d2c04486142#Oacc72b3ade238acae11dcaf9d948a5b8b;classdai_1_1RegionGraph#Oaf0608983940f78bd6fefe0933404861e#~Oa5cd7000971e68e732d5dffa7c665804a#}Oa54d0f7a94af04a274884c546bcad79c9K|classdai_1_1greedyVariableElimination_1a4df26af88ad423ec9489da4cf418a4be#{Oad38098f89c197e0202c1d657a37743bf#zOa1134a0eea0cfe45a62198a297bf32b7f#yOaf46505d1fc833ef90b5698eb5eae57d2x3classdai_1_1GraphAL#wOa56156ed9aeb1fcb50000c553fbeceaf6#vOaf476d8a940e49dbc7997c4c9b3f5e752#uOae678616088bb43db04d4ba44c8d52f38#tOaa703e03528543f90b130184e7b1b6416#sOa644d6e3dbb32cfc815955a5ebd53df68#rOad41a02444c605aaff2ab9d87cce561ee#qOa61f8685d3cab6ef99ca41c612e44284c#pOa5b4639a278afc734c0d4b074f53d87b5#oOac2f9ce21f6b9947b11c2bd731bb882d9#nOa4e042494d8e453005d0c8bfd788dc687#mOa8b3606b4ee589e4a0fb8fcdbdff97bae#lOae620ed3291b0a1a229a94b0872c8ad81#kOa506a66f1b25e49700f6ae564a5c33531#jOa0fe521e9633f7327f8c8335a5e718638 Y»÷îåÛÒÉ¿¶­¤š‡~ulbYPF<2) üòèßÖÍÄ»²©Ÿ•‹wmcYOE;1' ÿõëá×Íù°§ž•Œƒypf]TKB90' úñèßÖÍÄ»„+ÿ8„*ÿ:„)ÿ8„(ÿ:„'ÿ8„&ÿ:„%ÿu„$ÿ-„#ÿ8„"ÿ:„!ÿ5„ ÿ4„ÿ3„ÿ-„ÿ,„ÿ+„ÿr„ÿu„ÿu„ÿº„ÿ:„ÿ¹„ÿ:„ÿ-„ÿ,„ÿ+„ÿr„ÿr„ÿ±„ÿ–„ ÿ¶„ ÿ´„ ÿ·„ ÿ¶„ ÿ´„ÿ¶„ÿ´„ÿ´„ÿ´„ÿ¸„ÿ·„ÿ´„ÿ´„ÿ´ƒÿ¸ƒ~ÿ·ƒ}ÿ´ƒ|ÿ¶ƒ{ÿ´ƒzÿ¶ƒyÿ´ƒxÿ´ƒwÿFƒvÿ ƒuÿƒtÿƒsÿƒrÿDƒqÿ ƒpÿ²ƒoÿ±ƒnÿ ƒmÿ ƒlÿƒkÿƒjÿƒiÿƒhÿ°ƒgÿƒfÿŽƒeÿƒdÿ=ƒcÿ¯ƒbÿ=ƒaÿeƒ`ÿdƒ_ÿdƒ^ÿƒ]ÿ®ƒ\ÿƒ[ÿƒZÿƒYÿ­ƒXÿ ƒWÿƒVÿ¬ƒUÿƒTÿƒSÿ~ ;~òäÖȺ¬ŽpaSE6( ûìÝͽ­~o`QB3$ôåÖǸ©™‰yiYI9(øéÚ˼­žŽ~ < ŸE„ ; žE‚ : Ez 9 œ"Eu 8 ›"Ep 7 š Eo 6 ™Em 5 ™Em 4 ˜|BÑ 3 ˜BÑ 2 —"BÄ1 •–B¿ 0 •"B¿ / ”"B¦ . ”B¦ - “"B  , “B  + ’BŠ * ‘"B† ) "B ( B} ' B} & ŽBv % ŽBv $  º # Œ" ± " ‹" ¬ ! Š" b  ‰ [  ˆ" Q  ‡ 1  ‡ 1  †"@C  †"@C  …";   … ;   …";   …";   …;   „;}  ƒ";x  ‚";t  ;r  ;r  ;k  €;k  ~;h  ~;h  }:0  {|+  zx"‹  yx8.  wx8  v6:  v06:  u2s  t2f  s2a  r2S ³Í›i7Ô¤uGÞ´Œ_8 䳃V^V­/c/home/joris0e/home/jorism/vcs/libdai/src/clustergraph.cpp'S/home/jorism/vcs/libdai/src/cbp.cpp+[/home/jorism/vcs/libdai/src/bp_dual.cpp&Q/home/jorism/vcs/libdai/src/bp.cpp,]/home/jorism/vcs/libdai/src/bipgraph.cpp 'S/home/jorism/vcs/libdai/src/bbp.cpp)Y /home/jorism/vcs/libdai/src/alldai.cpp7s/home/jorism/vcs/libdai/include/dai/weightedgraph.h"0e/home/jorism/vcs/libdai/include/dai/varset.h_-_/home/jorism/vcs/libdai/include/dai/var.h].a/home/jorism/vcs/libdai/include/dai/util.h>/c/home/jorism/vcs/libdai/include/dai/trwbp.hZ0e/home/jorism/vcs/libdai/include/dai/treeep.hN1g/home/jorism/vcs/libdai/include/dai/test4.cpp.1g/home/jorism/vcs/libdai/include/dai/test3.cpp-1g/home/jorism/vcs/libdai/include/dai/test2.cpp,1g/home/jorism/vcs/libdai/include/dai/test1.cpp2i/home/jorism/vcs/libdai/include/dai/smallset.hU &±a ¹g׎Y¸l&D4-7=std::logic_errorstd::invalid_argumentclassstd_1_1logic__errorJ3C'Cstd::basic_ifstream< char >std::ifstreamclassstd_1_1basic__ifstreamb2Q=Ostd::tr1::unordered_map< T, U, H >dai::hash_map< T, U, H >classstd_1_1tr1_1_1unordered__map;1A1dai::DAIAlg< RegionGraph >dai::HAKclassdai_1_1DAIAlg30/%+std::set< UEdge >dai::GraphELclassstd_1_1setG/A%Astd::basic_fstream< char >std::fstreamclassstd_1_1basic__fstream:.5%3dai::TFactor< Real >dai::FRegionclassdai_1_1TFactorR-K-Estd::binary_function< T, T, T >dai::fo_pow< T >classstd_1_1binary__functionP,C3Cstd::unary_function< T, T >dai::fo_plog0p< T >classstd_1_1unary__functionR+K-Estd::binary_function< T, T, T >dai::fo_min< T >classstd_1_1binary__functionR*K-Estd::binary_function< T, T, T >dai::fo_max< T >classstd_1_1binary__functionN)C/Cstd::unary_function< T, T >dai::fo_log0< T >classstd_1_1unary__functionM(C-Cstd::unary_function< T, T >dai::fo_log< T >classstd_1_1unary__function `Íšb/ôÓb1Û½”_-úˈ`&r + std::iosclassclassstd_1_1iosAq 7G std::invalid_argumentclassclassstd_1_1invalid__argument-p #1 dai::InfAlgclassclassdai_1_1InfAlg #1o '5 dai::IndexForclassclassdai_1_1IndexFor@00n '5 std::ifstreamclassclassstd_1_1ifstream3m '7 dai::hash_mapclassclassdai_1_1hash__map>’'l + dai::HAKclassclassdai_1_1HAK;$k  GRMclassclassGRM ÏTj IW dai::greedyVariableEliminationclassclassdai_1_1greedyVariableElimination/i %3 dai::GraphELclassclassdai_1_1GraphEL"/h %3 dai::GraphALclassclassdai_1_1GraphAL8r.g %3 std::fstreamclassclassstd_1_1fstream/f %3 dai::FRegionclassclassdai_1_1FRegion609e /? std::forward_listclassclassstd_1_1forward__list1d #5 dai::fo_powstructstructdai_1_1fo__pow ’6c ); dai::fo_plog0pstructstructdai_1_1fo__plog0p g1b #5 dai::fo_minstructstructdai_1_1fo__min §1a #5 dai::fo_maxstructstructdai_1_1fo__max ž k˶‡xO"îÀ²ƒtE6 áÕ¯ƒwQ%óókQ-dai/properties.h2Pm/home/jorism/vcs/libdai/include/dai/properties.hO%dai/treeep.h.Ne/home/jorism/vcs/libdai/include/dai/treeep.h$MQ/home/jorism/vcs/libdai/src/mr.cpp Ldai/mr.h*K]/home/jorism/vcs/libdai/include/dai/mr.h$JQ/home/jorism/vcs/libdai/src/mf.cpp Idai/mf.h*H]/home/jorism/vcs/libdai/include/dai/mf.h$GQ/home/jorism/vcs/libdai/src/lc.cpp Fdai/lc.h*E]/home/jorism/vcs/libdai/include/dai/lc.h'DW/home/jorism/vcs/libdai/src/jtree.cpp C#dai/jtree.h-Bc/home/jorism/vcs/libdai/include/dai/jtree.h A#dai/index.h-@c/home/jorism/vcs/libdai/include/dai/index.h ?!dai/util.h,>a/home/jorism/vcs/libdai/include/dai/util.h%=S/home/jorism/vcs/libdai/src/hak.cpp <dai/hak.h+;_/home/jorism/vcs/libdai/include/dai/hak.h':W/home/jorism/vcs/libdai/src/graph.cpp 9#dai/graph.h-8c/home/jorism/vcs/libdai/include/dai/graph.h7/dai/regiongraph.h36o/home/jorism/vcs/libdai/include/dai/regiongraph.h Yº÷íäÛÑǽ³© –„zqh_VMC:0&þõëá×Íù¯¥œ“Šxof\SJA8/% øïæÝÓÊÁ¸¯¦“‰€vlbXNE;1( úñèßÖÌú…ÿ…ÿ…ÿÚ…ÿB…ÿ„ÿB„~ÿA„}ÿ„|ÿ„{ÿ^„zÿÙ„yÿ„xÿB„wÿØ„vÿׄuÿB„tÿÆ„sÿÅ„rÿÆ„qÿÅ„pÿÕ„oÿ„nÿÖ„mÿÕ„lÿ„kÿ„jÿB„iÿB„hÿ„gÿ„fÿÔ„eÿ„dÿ„cÿ„bÿB„aÿ „`ÿB„_ÿ „^ÿ„]ÿÓ„\ÿ„[ÿ„Zÿ„Yÿ~„Xÿ„WÿÒ„Vÿ „Uÿ„TÿB„SÿA„RÿB„Qÿ„Pÿ„OÿÑ„NÿЄMÿÏ„LÿÌ„KÿË„JÿÊ„IÿÉ„HÿÈ„Gÿ„FÿÇ„EÿÅ„DÿÆ„CÿÅ„BÿÆ„AÿÅ„@ÿ„?ÿÄ„>ÿB„=ÿB„<ÿ„;ÿ„:ÿ„9ÿÄ8ÿ„7ÿ„6ÿ„5ÿ[„4ÿÁ„3ÿÀ„2ÿ¿„1ÿ¾„0ÿ¼„/ÿ=„.ÿ=„-ÿ»„,ÿu Uͬ˜jT/ýåϹ•rQB/废ƒ[㿦U8_ O'std::vector< SharedParameters > &maximizationsT^ typenameKK] bool &hasNaNs!\ ;std::vector< Factor > &Q [ 3const std::string &nameZ size_tvs0=Y qgreedyVariableElimination::eliminationCostFunctionfn%X %!size_tPreviousRoot(size_t)-1W %RootedTree &TreeV boolverifyfalse(U Gconst std::vector< VarSet > &clT boolautomatictrue*S 7std::vector< size_t >facIndsfalseR size_tI Q intP )const VarSet &forVars O )const VarSet &indexVars!N !)typename Hboost::hashM !typename UL VarSetvarsK size_tlengthJ #const Var &rootI VarSetnewcl"H 5std::set< VarSet > &allclG size_tbetaF size_t_betaE size_talphaD size_tvsC 3const RegionGraph &rg0B A'const std::set< size_t > &remainingVars „Ù³Œe>„òˤ}V/ẓlEøÒ«^:&Oa7d006595c29b6328464f96bcd924071&Oa750c3807e7375265c3fb410a1f1223feƒ&Oa882dd82ffb2b2d3cd709b07fede37a46(%Oa86aa114bd9377d0f953bf28e5e2e9e87W%Oa85b152e74a123d348253b5cef6d6ff162&Oa85ad330af53b8353bb88ebc104a1e6aa &Oa82e775a1e2908856f13fa1aa7c081d4cj&Oa824c1f237a11e5a35addd01295f8ea2bÛ&Oa81bfc3f1f223aa3b1df8d90dfc842345Ì&Oa80cbccb94b3979e10647def9c4ae8582Ä&Oa7e87a1887051cf2fa76b472456cdf5df,&Oa7dd9cb2405e798802d8cbb9b879fdf90l&Oa7d2acdd799407118d8fb1f24acad62fc &Oa7d006595c29b6328464f96bcd924071e@&Oa7bfc52374ce25ebf05f9bd8387512428P&Oa783929437b952f005e2a1405ac23baf7&Oa75cb64b76a701c692def907f319883acñ%Oa7519ba1667a64e614f2161f2733e4a79X%Oa73e0206b02ac2989cf407005a69d9a2d>&Oa7324f2d3100d67b7f638e37a7fdf3241ð&Oa7314bfdc86e320ad1d0f0446340fed82‡&Oa6e722d35851c22aa8ada313a53786d66›%Oa6e30add24796c14c7e45adcaa7e73e62!&Oa6d4790b31f1e3ccc210bc3fa27fecfbb UÚ´ŽhBöЪ„^8ìÆ zT.íÇ¡{U#Oa6e722d35851c22aa8ada313a53786d66#Oad5ae1f76a8794bfc0a5a757f83d2a245#Oac19fd3f56dbd82bbfe1789820ad3519e#Oa9046531a81e82734a866f99d1473dcaf#Oa1248e3988e6b78b275ee68287a613ac29classdai_1_1RootedTree#Oa5aee1c116573bb069b0ef12c3c10a9b1#Oaddebd3eea8092f2e9bc545d3040467fb#Oac960b7288a1230e23800dd97e399da7a#Oac87e0972ae1b74bce8f5d75d2e230c52#Oa365c52b5f264c844ac5c010026719350#Oa0a76e072fc766e6a7ec4e1dadfb3d1e4#Oa1959bfaf52d37ee89151540faae18a14#Oa5c81f2500cc196eb50921d7db7794216# Oac422893fd7b8e37f914860aeba9602dc# Oa2a57b201409b36909b8c336a2748ac81# Oa4c572b1ce73ce427af3ffdb6f6a73a45# Oa4655db9d766470f1a555cba7d3ec7190# Oa3afe96990b767effef2e2a857b74dee0#Oa5b1e6d8af207bcc47fd954fdef382a77#Oa7314bfdc86e320ad1d0f0446340fed82#Oa3780be9d74b4c1b0ed1713d7cab8211c#Oa99a0d6ef936d4c27159e044fa1ef5a93#Oa49d00fd7e213b351704b554c5c0039ce#Oa1a46412aa54525a5f9ea332ad1048f2a 4Ãzà¤b&ê®b¾|4FB13Astd::runtime_errorstd::overflow_errorclassstd_1_1runtime__error@A-/=std::logic_errorstd::out_of_rangeclassstd_1_1logic__errorY@M1Mstd::basic_ostringstream< char >std::ostringstreamclassstd_1_1basic__ostringstreamG?A%Astd::basic_ostream< char >std::ostreamclassstd_1_1basic__ostreamJ>C'Cstd::basic_ofstream< char >std::ofstreamclassstd_1_1basic__ofstream:=A1dai::DAIAlg< FactorGraph >dai::MRclassdai_1_1DAIAlg:<A1dai::DAIAlg< FactorGraph >dai::MFclassdai_1_1DAIAlg:;)-7std::exceptionstd::logic_errorclassstd_1_1exception@:-/=std::logic_errorstd::length_errorclassstd_1_1logic__error:9A1dai::DAIAlg< FactorGraph >dai::LCclassdai_1_1DAIAlg=8A!1dai::DAIAlg< RegionGraph >dai::JTreeclassdai_1_1DAIAlgY7M1Mstd::basic_istringstream< char >std::istringstreamclassstd_1_1basic__istringstreamG6A%Astd::basic_istream< char >std::istreamclassstd_1_1basic__istream;599std::basic_ios< char >std::iosclassstd_1_1basic__ios -Ía!Ð}5ä‡I²l-< 1C std::map::iteratorclassclassstd_1_1map_1_1iteratorD 9K std::wstring::iteratorclassclassstd_1_1wstring_1_1iteratorQ~ EY std::unordered_set::iteratorclassclassstd_1_1unordered__set_1_1iteratorB} 7I std::string::iteratorclassclassstd_1_1string_1_1iterator<| 1C std::set::iteratorclassclassstd_1_1set_1_1iterator[{ Oc std::unordered_multimap::iteratorclassclassstd_1_1unordered__multimap_1_1iteratorOz CW std::basic_string::iteratorclassclassstd_1_1basic__string_1_1iteratorFy ;M std::multimap::iteratorclassclassstd_1_1multimap_1_1iteratorQx EY std::unordered_map::iteratorclassclassstd_1_1unordered__map_1_1iteratorOw CW std::forward_list::iteratorclassclassstd_1_1forward__list_1_1iterator>v 3E std::list::iteratorclassclassstd_1_1list_1_1iterator:u 1? std::istringstreamclassclassstd_1_1istringstream.t %3 std::istreamclassclassstd_1_1istream1s '7 std::ios_baseclassclassstd_1_1ios__base A·YÑ£{?ä¹VÆžvA2 '5 dai::multiforclassclassdai_1_1multifor@% ) dai::MRclassclassdai_1_1MRK&% ) dai::MFclassclassdai_1_1MFH)H 9 O dai::BP_dual::messagesstructstructdai_1_1BP__dual_1_1messages.B 7E dai::MaximizationStepclassclassdai_1_1MaximizationStep & + std::mapclassclassstd_1_1map7 -= std::logic_errorclassclassstd_1_1logic__error( - std::listclassclassstd_1_1listX I] dai::BipartiteGraph::levelTypestructstructdai_1_1BipartiteGraph_1_1levelType 69 /? std::length_errorclassclassstd_1_1length__error% ) dai::LCclassclassdai_1_1LCE!+ !/ dai::JTreeclassclassdai_1_1JTreeB-@ 5G std::deque::iteratorclassclassstd_1_1deque_1_1iteratorB 7I std::vector::iteratorclassclassstd_1_1vector_1_1iterator[ Oc std::unordered_multiset::iteratorclassclassstd_1_1unordered__multiset_1_1iteratorF ;M std::multiset::iteratorclassclassstd_1_1multiset_1_1iterator öÚ³Œe>¨ðÉ¢{ÏT-߸‘jC[a&Oa934491ad55f57c9072271b4a32ea4919‡&Oa8f9fdd7b607434fcda10d5be59f512d1†&Oa95e934001307cafa4576b31fb0569e2c~%Oa8b3606b4ee589e4a0fb8fcdbdff97baem&Oa8a5471649c2517951a1fc9d48d54f2f7Ü&Oa99dec3f9c09badfa0bc78985dfa62cdeµ&Oa99a0d6ef936d4c27159e044fa1ef5a93…&Oa994c9f22df68683a13c5c6730a41a6afõ&Oa990ea70014c5c6a90932d9cee11f393be&Oa9886ca4103eac52b3f82698e12e86672}&Oa968fe2b9d9cc604a9d81c9ea15be8d72§&Oa9651abf1bb2c4c6f99227b4f4b20574a¨&Oa962f785eb9ca94350e766986a82d731a±&Oa9500b7b06612043d3d936e53d22e76acÀ&Oa90d9a0813d92ef6e15e0fb9a73ec8c55.&Oa90b550b54e6768683137b4d2657a96c4Æ&Oa9046531a81e82734a866f99d1473dcaf˜&Oa8f59139807c33a041c6af432cd3ea010Ï&Oa8f378501c011772b7bf9a753af3e131d &Oa8e08ac168bd27da1f7ff0352f9d2c71e¶&Oa8da41eabb003895e074d2c98a2e976a6÷&Oa8d7fe99f8f97ffba15a45bb1f0cdc117%Oa8c8df69ed14b2751eef3cc65136b0310; ?Ú´ŽhBöÕ¯‰c=ñË¥Y3 çÁ›u?34oclassdai_1_1MR_1a4fe1bd2e25b9582105ec6ca44af0df3f#3Oa3c5ffdef3221d23afa47edafde339299#2Oa58f561154d9c74ac2f39a3b13196857f#1Oa962f785eb9ca94350e766986a82d731a#0Oada0e0829e87b541633dbb6078529c21d#/Oaff5afd515efbd7e6bcf78fe9e68d366d#.Oadff10df2f1a0320d2b67d94bbfbb5b99#-Oaf4920b0a867f986f2a2b8981567ee5d1#,Oa4b0c1aaf86d63308fb04b1805d85d482#+Oa49ddd5c9c9f51ee9fb5e153b7194ac71#*Oa2a7c09e89e9be126ae75fa23adf57c3c#)Oad15e329ec639092806617301eba9d622#(Oa9651abf1bb2c4c6f99227b4f4b20574a#'Oa968fe2b9d9cc604a9d81c9ea15be8d72#&Oaa91aab0e5776b645a738b8644b5a9042#%Oa5dcaac5456934d874a030e4b1db1c961#$Oad705857af3c53a94264590f8a6d1a120#Eclassdai_1_1SharedParameters#"Oacb3cc6c7e710caa546f86b043befadef#!Oaf7876f0893b969c4d2842927085c18e3# Oa8f378501c011772b7bf9a753af3e131d#Oacc10d4cd212255ae2edf44f121347665#Oa5434630d65c22c3f3dfc7b913b58bdaf#Oa5e7f0c159e23c48c93b92a83572a1b37#Oab077c808ad6ca6b9e134746d0846ea5d X¼öíãÚÐǾ´«¢™‡}si_ULC:1( úñèßÖÍÄ»²© —„{qh^ULC:0& öíãÙÏÅ»±§“Šxne[QG=3) øîäÚÐƼ…\ÿý…[ÿü…Zÿû…Yÿú…Xÿù…Wÿø…Vÿ÷…Uÿö…Tÿõ…Sÿ…Rÿô…Qÿó…Pÿò…Oÿñ…Nÿð…Mÿï…Lÿî…Kÿq…Jÿî…Iÿ …Hÿp…Gÿ …Fÿí…Eÿì…Dÿë…CÿÑ…Bÿê…Aÿé…@ÿè…?ÿç…>ÿã…=ÿ`…<ÿã…;ÿ…:ÿæ…9ÿå…8ÿ…7ÿæ…6ÿå…5ÿ …4ÿ…3ÿ …2ÿ…1ÿã…0ÿ…/ÿä….ÿ …-ÿ…,ÿã…+ÿ…*ÿ…)ÿ…(ÿ…'ÿB…&ÿ…%ÿB…$ÿA…#ÿ…"ÿ…!ÿ… ÿ…ÿâ…ÿB…ÿ…ÿB…ÿA…ÿ…ÿ…ÿ…ÿ…ÿ…ÿá…ÿà…ÿŽ…ÿß…ÿ…ÿ…ÿ…ÿ… ÿ… ÿÝ… ÿ… ÿ… ÿÜ…ÿ…ÿÛ…ÿ…ÿÛ 9€ðáÒÁ±¡‘‚sdUF7( ûìÝο°¡n]M=.ñáÑÁ±¡’‚rbQ@/ üìÜ;¯ € u Ò6ˆ t ÐÑ6s s Ð"6s r Ð6s q Ï6% p Ï"6% o ÎP n ÍPòm ÌÂPÚl ËÂPÈk ÊÂP»j ÉÂPªi ÈÂP¥h ÇÂP‰ g ÆÂP{ f ÅÃPp e ÅÂPp d ÄPc c ÁÃP] b ÁÂP] a À¾ ` ¿‘ _ ¾ @ž ^ ¼½F ] »C \ ºS [ ¹P Z ¸M Y ·K· X ·K·W ·´K·V ¶´K¯U µ´K›T ³´K’ S ²Km R ²Km Q ±K P °"K{ O ¯"Kv N ® Ku M ­Ks L ­Ks K ¬Hn J «"Hi I ª"Hd H © Hc G ¨Ha F ¨Ha E §HX D §HX C ¦! B ¥ A ¤@ ¢£ ? ¡Eg > ¡Eg =  0E† 6¬v/îœh#ìµjÐ6I)[Gclassstd_1_1multiset_1_1const__iteratorstd::multiset::const_iteratorM(_Kclassstd_1_1multimap_1_1reverse__iteratorstd::multimap::reverse_iterator<'M;classstd_1_1multimap_1_1iteratorstd::multimap::iteratorZ&mWclassstd_1_1multimap_1_1const__reverse__iteratorstd::multimap::const_reverse_iteratorI%[Gclassstd_1_1multimap_1_1const__iteratorstd::multimap::const_iterator5$G3structdai_1_1MR_1_1Propertiesdai::MR::Properties5#G3structdai_1_1MF_1_1Propertiesdai::MF::PropertiesC"UAclassstd_1_1map_1_1reverse__iteratorstd::map::reverse_iterator2!C1classstd_1_1map_1_1iteratorstd::map::iteratorP cMclassstd_1_1map_1_1const__reverse__iteratorstd::map::const_reverse_iterator?Q=classstd_1_1map_1_1const__iteratorstd::map::const_iteratorEWCclassstd_1_1list_1_1reverse__iteratorstd::list::reverse_iterator4E3classstd_1_1list_1_1iteratorstd::list::iteratorReOclassstd_1_1list_1_1const__reverse__iteratorstd::list::const_reverse_iterator &eÕ¾ª—ƒnY?&üéÒ¼¦]2Ú¾ª’‚p\H4# ûé×ŲŸŒte ‚ MIN‚ %ClustersType‚ MAXPROD‚ SUMPROD‚ InfType‚ PARALL SEQMAX~ SEQRND} SEQFIX| !UpdateType{ EXACTz CLAMPINGy RESPPROPx InitTypew LINEAR v FULLu !UpdateTypeTTt size_tlis boolreversefalse'r Aconst std::vector< Var > &vars+q Gconst std::vector< size_t > &sigma(p Gconst std::vector< size_t > &rs!o ;const ParamEstFactory &f"n 3const std::string &methodm size_tduall size_tnodek size_titerKj size_tk'i Gconst std::vector< size_t > &dh Real *sum_oddg Real *sum_evenf size_t_l2e size_t_l1d size_t_lc sub_nbAb size_tvsa InfAlg &alg(` 3%const FactorGraph &fg_varlookup G²Œ¼•nGd=ðʤ}V0 ÙâH"ûÕ¯‰²&Oaa1528118bca7246714984dfe88d569d8ø&Oaa0e26d77620b8a3d07d1ec7843fa0c56!&Oaa07d388e9201b937cc7275dc9c2d2c8e4%Oa9fc5612a5b4930a51880949acf7341c9[&Oaa9de4c6919232d931772b43625fb0c3b1&Oaa91aab0e5776b645a738b8644b5a9042¦%Oaa8bb4312e60a0bf2b0501773e9356bfd<&Oaa8334fedf3a5da32bc022464071222c7&Oaa80198b5748e12b059ce6b99160cc6e98%Oaa703e03528543f90b130184e7b1b6416t%Oaa4c5e31aeedeb2a02018024948ae197f3&Oaa456a343b232915dd94de066c9a54f28;%Oaa3c2759ac28711b05a4d607da0b4b26d@&Oaa37766332e1b1969df5bbaa46cc741fdë&Oaa208216fc2982c0a4af71d2c04486142‚%Oa9ba932b768dff5a0b78fcac5d02088fb &Oa9ab2b5c7d1e9a85f4666d44bbb97528dÙ&Oaa9aa5a66a5df1ae48e29c4ad0965f3c6q XÚ´ŽhBöЈb<ð¼ˆb<ðʤ~X#KOa1a19802d6b49b4d488d908f7e0b0a0ce#JOa315cd21d6454d9f3b677af43a5977b27#IOabc3df170db0dbba57cb11e3ef87f5948#HOa5f88f13fab6393e609bdc8a47f538141#GOa0ce242f87aa02bac9d603f89b50a2451#FOa90b550b54e6768683137b4d2657a96c4#EOa51bfe57cacf9f79e788c490ed369869e#DOa80cbccb94b3979e10647def9c4ae85821Cknamespacedai_1aeb056b768d73d02c5796c4012f4170c71Bknamespacedai_1acc877a85f4f4dbb6a0d58c434bb2b996#AOaf1fe425c6fa07fe9888c8b00238b4b42#@Oa9500b7b06612043d3d936e53d22e76ac#?Oaf91c0967330dd41b93da470527c42a46#>Oabac10d00389021b4e5cf1a158e5672b6E=classdai_1_1ParameterEstimation_1a20a742581e5e8f4af0905e440d084031#<Oa3248cc18f8683a95e7d318e5c7d27258#;Oa38ee418f4d5ac9136f13a087528a8718#:Oa454801bc228b5826d37f4142d79751d0#9Oa5c279ce0fa2cda3fda5379252d1bdd99#8Oa1f4a5f8e20582ec271009604893bb222#7Oae972f478c3167b4b5a88840165828518#6Oa8e08ac168bd27da1f7ff0352f9d2c71e#5Oa99dec3f9c09badfa0bc78985dfa62cde kÍšd1ÆFüɉE±kC 5I dai::HAK::Propertiesstructstructdai_1_1HAK_1_1Properties;5M ?S dai::ExactInf::Propertiesstructstructdai_1_1ExactInf_1_1Properties'#A 3G dai::BP::Propertiesstructstructdai_1_1BP_1_1Properties eA 3G dai::MR::Propertiesstructstructdai_1_1MR_1_1PropertiesKF= 3C std::priority_queueclassclassstd_1_1priority__queue0 %3 dai::Permuteclassclassdai_1_1Permute@‰G =K dai::ParameterEstimationclassclassdai_1_1ParameterEstimation2= 3C std::overflow_errorclassclassstd_1_1overflow__error: /A std::out_of_rangeclassclassstd_1_1out__of__range: 1? std::ostringstreamclassclassstd_1_1ostringstream. %3 std::ostreamclassclassstd_1_1ostream0 '5 std::ofstreamclassclassstd_1_1ofstream3 '7 dai::Neighborstructstructdai_1_1Neighbor8I0 '5 std::multisetclassclassstd_1_1multiset0 '5 std::multimapclassclassstd_1_1multimap c¤fÖ„P Äl2ç¨cC6SAclassdai_1_1TreeEP_1_1TreeEPSubTreedai::TreeEP::TreeEPSubTree=5O;structdai_1_1TreeEP_1_1Propertiesdai::TreeEP::PropertiesI4[Gclassstd_1_1string_1_1reverse__iteratorstd::string::reverse_iterator83I7classstd_1_1string_1_1iteratorstd::string::iteratorV2iSclassstd_1_1string_1_1const__reverse__iteratorstd::string::const_reverse_iteratorE1WCclassstd_1_1string_1_1const__iteratorstd::string::const_iteratorC0UAclassstd_1_1set_1_1reverse__iteratorstd::set::reverse_iterator2/C1classstd_1_1set_1_1iteratorstd::set::iteratorP.cMclassstd_1_1set_1_1const__reverse__iteratorstd::set::const_reverse_iterator?-Q=classstd_1_1set_1_1const__iteratorstd::set::const_iteratorM,_Kclassstd_1_1multiset_1_1reverse__iteratorstd::multiset::reverse_iterator<+M;classstd_1_1multiset_1_1iteratorstd::multiset::iteratorZ*mWclassstd_1_1multiset_1_1const__reverse__iteratorstd::multiset::const_reverse_iterator U²öìâØÎĺ°¦œ’ˆ~tj`VLB8.$üòèÞÔÊÀ¶¬¢˜Ž„zpf\RH>4*  ùïåÛÑǽ³©Ÿ•Œ‚xndZPF<2( öíãÙÏÅ»²†1ÿ†0ÿ±†/ÿ5†.ÿ4†-ÿŽ†,ÿ3†+ÿ=†*ÿ,†)ÿ-†(ÿ-†'ÿ-†&ÿ-†%ÿ-†$ÿ-†#ÿ1†"ÿ-†!ÿ.† ÿ-†ÿ/†ÿ.†ÿ-†ÿ,†ÿ†ÿ+†ÿ*†ÿ)†ÿ(†ÿ'†ÿ&†ÿ%†ÿ$†ÿ#†ÿ"†ÿ!†ÿ †ÿ† ÿ† ÿ† ÿ† ÿ† ÿ†ÿ†ÿü†ÿ†ÿ†ÿ†ÿþ†ÿý†ÿü†ÿ …ÿ…~ÿ…}ÿö…|ÿ…{ÿ…zÿ…yÿü…xÿ …wÿ …vÿø…uÿ…tÿ…sÿ…rÿ…qÿ …pÿ…oÿ…nÿ…mÿ …lÿ …kÿü…jÿ …iÿ …hÿø…gÿ…fÿ…eÿ…dÿ…cÿ…bÿ…aÿ…`ÿ…_ÿ…^ÿÿ…]ÿþ *hïÞλ©˜ˆoWB/ïÙɸ¤•†s`J4% õáÌ°—~hP7" õÕ³h$‚/ 3const PropertySet &newProps!‚. 7const PropertyValue &val‚- 3const PropertyKey &key‚, 3const std::string &s‚+ %CLAMP_FACTOR‚* CLAMP_VAR‚) ClampType‚( 'CHOOSE_BP_CFN‚' %CHOOSE_BP_L1‚& !CHOOSE_BBP‚% 'CHOOSE_MAXENT‚$ 'CHOOSE_RANDOM‚# -ChooseMethodType‚" REC_BDIFF‚! REC_LOGZ‚ REC_FIXED‚ #RecurseTypeopts ‚ PAR‚ !SEQ_BP_FWD‚ !SEQ_BP_REV‚ SEQ_MAX‚ SEQ_FIX ‚ ALT ‚ ORG‚ TypeType‚ PAIR2 ‚ PAIR‚ !CavityType‚ HARDSPIN‚ NAIVE‚ +WEIGHTEDMINFILL‚ MINFILL‚ MINWEIGHT‚ %MINNEIGHBORS‚ 'HeuristicType ‚ SHSH‚ HUGIN‚ RANDOM‚ UNIFORM ‚ LOOP‚ DELTA‚ BETHE D¶r.â›Tí³ƒI÷”DM- AU std::map::reverse_iteratorclassclassstd_1_1map_1_1reverse__iterator`, Si std::forward_list::reverse_iteratorclassclassstd_1_1forward__list_1_1reverse__iteratorO+ CW std::list::reverse_iteratorclassclassstd_1_1list_1_1reverse__iterator7* -; dai::RegionGraphclassclassdai_1_1RegionGraph6[-) #1 dai::Regionclassclassdai_1_1Region67( -= std::range_errorclassclassstd_1_1range__error*' !/ std::queueclassclassstd_1_1queue7& -; dai::PropertySetclassclassdai_1_1PropertySetPID% 5I dai::CBP::Propertiesstructstructdai_1_1CBP_1_1Properties”D$ 5I dai::BBP::Propertiesstructstructdai_1_1BBP_1_1PropertiesvI# ;O dai::TreeEP::Propertiesstructstructdai_1_1TreeEP_1_1PropertiesN1A" 3G dai::LC::Propertiesstructstructdai_1_1LC_1_1PropertiesE2A! 3G dai::MF::Propertiesstructstructdai_1_1MF_1_1PropertiesH4G 9M dai::JTree::Propertiesstructstructdai_1_1JTree_1_1PropertiesB@ Q±l;û½Ií¾IñšQGR15Astd::runtime_errorstd::underflow_errorclassstd_1_1runtime__error&Q!)dai::BPdai::TRWBPclassdai_1_1BP-P!#/dai::JTreedai::TreeEPclassdai_1_1JTreeVOK/Kstd::basic_stringstream< char >std::stringstreamclassstd_1_1basic__stringstreamDN?#?std::basic_string< char >std::stringclassstd_1_1basic__string-M##-StateFactorStateSparseclassStateFactor-L##-StateFactorStateSparseclassStateFactor,K#!-StateFactorStateDenseclassStateFactor,J#!-StateFactorStateDenseclassStateFactor4I)%3AbstractFactorSparseFactorclassAbstractFactordai::RootedTreeclassstd_1_1vector>F--;dai::FactorGraphdai::RegionGraphclassdai_1_1FactorGraph/E##1dai::VarSetdai::Regionclassdai_1_1VarSetCD1-Astd::runtime_errorstd::range_errorclassstd_1_1runtime__errorMCY-+std::map< PropertyKey, PropertyValue >dai::PropertySetclassstd_1_1map Ï÷ÏÕ©R%õÊšrGôÌ¥{T$ˤu'S/home/jorism/vcs/libdai/src/dag.cpp,]/home/jorism/vcs/libdai/src/createfg.cppb/a/home/jorism/vcs/libdai/src/matlab/dai.cppò&Q/home/jorism/vcs/libdai/src/lc.cppG)W/home/jorism/vcs/libdai/src/jtree.cppD&Q/home/jorism/vcs/libdai/src/io.cppe'S/home/jorism/vcs/libdai/src/hak.cpp=)W/home/jorism/vcs/libdai/src/graph.cpp:(S/home/jorism/vcs/libdai/src/glc.cppð*W/home/jorism/vcs/libdai/src/gibbs.cppï'S/home/jorism/vcs/libdai/src/fbp.cpp4/c/home/jorism/vcs/libdai/src/factorgraph.cpp1*Y/home/jorism/vcs/libdai/src/factor.cppd/a/home/jorism/vcs/libdai/src/exceptions.cppí,]/home/jorism/vcs/libdai/src/exactinf.cpp),]/home/jorism/vcs/libdai/src/evidence.cpp&)W/home/jorism/vcs/libdai/src/emalg.cpp+Y/home/jorism/vcs/libdai/src/decmap.cppë*Y/home/jorism/vcs/libdai/src/daialg.cppc Mß¿¡€eIñ®w]A+Þ¯–g<"üåη™gM‚K size_tsizeHint‚J TIteratorend‚I TIteratorbegin‚H 1typename TIterator‚G const T &t2‚F const T &t1‚E const T &tT#‚D =const SharedParameters &sp‚C boolownPEfalse(‚B 7!ParameterEstimation *estimation,‚A Aconst FactorOrientations &varorders‚@ VarSet &outVS,‚? Aconst std::vector< Var > &varOrderK%‚> Aconst std::set< size_t > &cl"‚= =const std::vector< Var >s‚< size_tRoot‚; +const GraphEL &T‚: size_tverbose04‚9 Qconst std::map< size_t, Factor > &facsfalse@‚8 qconst std::vector< std::pair< size_t, size_t > > &edges)‚7 Gconst std::vector< Region > &irs)‚6 Gconst std::vector< VarSet > &ors‚5 )const VarSet &xT‚4 'PropertySet &ps‚3 3const PropertySet &ps‚2 1typename ValueType‚1 /const ValueType &val‚0 1typename ValueTypeval ®Ù²‹d>òË¥Y2 ä½—pI"ûÕ®&Oab48f95b7d1bdfe60ef2f25cd78dec376/%Oab480cc0971e4c417867952425e28a281&Oab43e580b79ff06a7bf35b7b9faa92af6ú&Oab41645939efa15bb66b14e20d1641c8fa&Oab339baefa9f588de2fba07526d8df7baz&Oab2414cf14329da58b0519adf8d783cb5%Oab2378683166fd3eb5518edce5823c1edM&Oab1b9d59848e415c32330d4a7cbb3269as&Oab0d3e811b3335ac42245ec03864ede45—&Oab077c808ad6ca6b9e134746d0846ea5dœ&Oab0668fe05276356dd72bc0c4ba8e38fbQ%Oab05088fa0e00f7bc2cf3b86c6aeadc07S%Oaaf65e36b21311c3b87bbe98464686f75.%Oaae58f898e6570e76bb91912dd7157598d&Oaadf664acf42371b8f25ade335a805da1`%Oaadcfd932c08690541849847e720e950f%%Oaace58f99e40bb4084c73d6b77fd26456]%Oaac85e6f5aa72f552c3d6a6fd7941d2dbK&Oaab8aabfe0fcfd4b4bd24757c101449d5i&Oaab76d678deecbe23d367bd86e59656c1&Oaab6d25e30baf39ea06c57b5f71c61a4eo&Oaab0479dd285fd4021ecaa80947d40da3{ JÚ´ŽhB+ß¹“mG!ûã½—qKâ¼–pJ#dOae1477e1babd787c9642d16e2a085697b#cOae3805b761d8750c61af23b3a1a51a0be#bOa471d38b5a945d9eefe694fde30f78ccc#aOaece6000831c8fad8e42364cd8ef41594!`Kclassdai_1_1ParameterEstimationB_ classdai_1_1SharedParameters_1af9cec794f26b175ed0bed628bfe746f7#^Oa038dedcc2e4810bf072d829a693859bf#]Oa3b73d7c4dc8c88725fb26da4d8089caa#\Oa8a5471649c2517951a1fc9d48d54f2f7#[Oa824c1f237a11e5a35addd01295f8ea2bZ3classdai_1_1GraphEL#YOa9ab2b5c7d1e9a85f4666d44bbb97528d#XOa0ade6772ff232cead91c887338fa7c6b#WOac418230edd85c5126999d70243476bef#VOa5620ffd618614200a976e78070bfc41f#UOa177194e1a32e016c3b59376443e9dcc1#TOad856e0dce255c429a4cddaba99c7d0f0#SOa3ff68e22e5bbd6a37142f6d759956fdf#ROabbb85bc05de8136b5ff12ba66df7867bQ1classdai_1_1Region#POa55b77f60fc90fc287c9cba9df9306bfa#OOa8f59139807c33a041c6af432cd3ea010#NOa0ec4068ab9fe8a5690f560a2e7d778fc#MOa55c10d86bc897277108b545f22e06fb7#LOa81bfc3f1f223aa3b1df8d90dfc842345 dÒ£r@.þîÄ•†]0#óã»e;뺈d"iM/home/jorism/vcs/libdai/config.h0hi/home/jorism/vcs/libdai/include/dai/createfg.h/gg/home/jorism/vcs/libdai/src/matlab/matlab.cpp(fY/home/jorism/vcs/libdai/src/varset.cpp$eQ/home/jorism/vcs/libdai/src/io.cpp(dY/home/jorism/vcs/libdai/src/factor.cpp(cY/home/jorism/vcs/libdai/src/daialg.cpp*b]/home/jorism/vcs/libdai/src/createfg.cpp&aU/home/jorism/vcs/libdai/src/util.cpp`%dai/varset.h._e/home/jorism/vcs/libdai/include/dai/varset.h ^dai/var.h+]_/home/jorism/vcs/libdai/include/dai/var.h'\W/home/jorism/vcs/libdai/src/trwbp.cpp [#dai/trwbp.h-Zc/home/jorism/vcs/libdai/include/dai/trwbp.h(YY/home/jorism/vcs/libdai/src/treeep.cppX%dai/factor.h.We/home/jorism/vcs/libdai/include/dai/factor.hV)dai/smallset.h0Ui/home/jorism/vcs/libdai/include/dai/smallset.h/Tg/home/jorism/vcs/libdai/src/weightedgraph.cpp-Sc/home/jorism/vcs/libdai/src/regiongraph.cpp,Ra/home/jorism/vcs/libdai/src/properties.cpp V¹öìâÙÏÅ»±§ž”Šwnd[RI@7.$ýôêà×Îĺ°§“‰ukaXND:0&þôêàÖ̸®¤š†|rh^TJ@6-#ýóéà×Íù‡ÿU‡ÿ—‡ÿчÿB‡ÿA‡ÿT‡ÿS‡ÿQ†ÿP†~ÿB†}ÿ†|ÿM†{ÿ=†zÿO†yÿN†xÿO†wÿN†vÿO†uÿN†tÿL†sÿM†rÿM†qÿM†pÿM†oÿL†nÿM†mÿL†lÿM†kÿM†jÿM†iÿM†hÿL†gÿL†fÿK†eÿJ†dÿI†cÿG†bÿF†aÿE†`ÿ†_ÿá†^ÿD†]ÿ†\ÿŽ†[ÿC†ZÿB†YÿA†Xÿ@†Wÿ?†Vÿ>†Uÿ[†Tÿ=†Sÿ<†Rÿ;†Qÿ †PÿB†Oÿ:†NÿÕ†Mÿ†Lÿ8†Kÿ7†Jÿ6†Iÿ†HÿÆGÿ=†Fÿf†Eÿe†Dÿd†Cÿd†Bÿ†Aÿ9†@ÿ†?ÿ©†>ÿ †=ÿdž<ÿņ;ÿ †:ÿdž9ÿdž8ÿņ7ÿņ6ÿÕ†5ÿ†4ÿ8†3ÿ7†2ÿ6 8€ðàп¯ŸŽ~n^M=- üëÛʺª›Œ}n^N>.þîÞξ®ž}m]N?0!óäÔij¢‘€‚- W]‚, W‚+ Wñ‚* W± ‚) ÿ W® ‚( ÿ W® ‚' þ Wk ‚& üýWf ‚% ü"Wf ‚$ û"W` ‚# ú"WW ‚" ù"WM ‚! ø"WH ‚  ÷ WE ‚ ö"@¬ ‚ õ @£ ‚ ô @~‚ òó@p ‚ ò"@p ‚ ñ=Uô ‚ ð=Uì ‚ ð=Uì ‚ ï=Uç ‚ ï=Uç ‚ î=Uâ ‚ î=Uâ ‚ í=UŸ ‚ ì=U— ‚ ë=U’ ‚ ê=U ‚ é=U€ ‚ è=Ur ‚  ç=Uk ‚  æ=Ud ‚  å=U] ‚  äû ‚  ãî‚ â£Ù ‚ áÖ‚ ÞàЂ ÞßÐ ‚ Ý"Å ‚ Ý Å ‚ Ü: ‚ Û ‚ ÙÚ"¥  Ø"6 ~ ×"6 } ×6 | ÖÑ6 { Ö"6 z Ö6y Õ€6õ x Ô06Û w Ó06Õ v Ò"6ˆ ˜bbrK%þÌ×°‰³Œf@ó¥Y2 ä&Oab6cfdf0bf047e72e324c04e96d310edbd&Oabd07922b69c64c0f873cbb0c6723a908-&Oabc3df170db0dbba57cb11e3ef87f5948É&Oabbb85bc05de8136b5ff12ba66df7867bÒ&Oabac10d00389021b4e5cf1a158e5672b6¾%Oaba6124da6c2a11b01c0f66cbe8ae9562&Oaba509d63554e9ce6f06ee2e2f3189487%Oab711dcd5db848b6d993fac482b64ee20#ÙL&Oac418230edd85c5126999d70243476bef×&Oac3f12eb0685ac91e4f3970accb65b0dd6&Oac336ffb182b6e6fa3f7df13620aab012‰%Oac3100fa72427f00a2867e40419c5ae2dF%Oac2f9ce21f6b9947b11c2bd731bb882d9o&Oac19fd3f56dbd82bbfe1789820ad3519e™&Oabb00ff16fe071140d9eb4c555c43e5d3b&Oac18760d5642f14aa1b64e0d3c611cb0fK%Oac12ac5065e77dc3040d464405fe1f609N%Oac0aafe3dbcdfb24cac6cf8c1fa7a2efb1%Oabd4a62c43f86f5b17c774f6a71d46950'&Oabd29d7c5df8a54c8139edeaaddc61c81'%Oabd0f148c5953b0ec4340e1b1c37ab0ef6' P›Aë›6Çm¦PS7 G[ std::vector::reverse_iteratorclassclassstd_1_1vector_1_1reverse__iteratorl6 _u std::unordered_multiset::reverse_iteratorclassclassstd_1_1unordered__multiset_1_1reverse__iteratorU5 I] std::wstring::reverse_iteratorclassclassstd_1_1wstring_1_1reverse__iteratorW4 K_ std::multiset::reverse_iteratorclassclassstd_1_1multiset_1_1reverse__iteratorl3 _u std::unordered_multimap::reverse_iteratorclassclassstd_1_1unordered__multimap_1_1reverse__iteratorb2 Uk std::unordered_set::reverse_iteratorclassclassstd_1_1unordered__set_1_1reverse__iteratorM1 AU std::set::reverse_iteratorclassclassstd_1_1set_1_1reverse__iteratorS0 G[ std::string::reverse_iteratorclassclassstd_1_1string_1_1reverse__iteratorW/ K_ std::multimap::reverse_iteratorclassclassstd_1_1multimap_1_1reverse__iteratorb. Uk std::unordered_map::reverse_iteratorclassclassstd_1_1unordered__map_1_1reverse__iterator XIÒsJÑ›k>㵇X,G #1 std::stringclassclassstd_1_1string+F #- StateSparseclassclassStateSparse-+E #- StateFactorclassclassStateFactor-)D !+ StateDenseclassclassStateDense-,C !/ dai::Stateclassclassdai_1_1State@`*B !/ std::stackclassclassstd_1_1stack-A %/ SparseFactorclassclassSparseFactor3@ )9 std::smart_ptrclassclassstd_1_1smart__ptr1? '5 dai::SmallSetclassclassdai_1_1SmallSetU B> 7E dai::SharedParametersclassclassdai_1_1SharedParameters«&= + std::setclassclassstd_1_1set\< Q_ dai::sequentialVariableEliminationclassclassdai_1_1sequentialVariableElimination ;; 1A std::runtime_errorclassclassstd_1_1runtime__error6: +9 dai::RootedTreeclassclassdai_1_1RootedTree"Q9 EY std::deque::reverse_iteratorclassclassstd_1_1deque_1_1reverse__iterator`8 Si std::basic_string::reverse_iteratorclassclassstd_1_1basic__string_1_1reverse__iterator "ZêÍ°“tH& òÓ¹žƒiN;áѳ¥jT5èЯ–~Z!‚m %ProbNormTypenormNORMPROB‚l boolzerotrue‚k boolzerofalse‚j 5const TFactor< T > &y‚i #const Var &j‚h #const Var &i ‚g Tval"‚f =const std::vector< T > &p‚e 1const TProb< T > &p‚d const T *p"‚c =const std::vector< S > &x‚b !typename S ‚a Tp‚` )const VarSet &vars ‚_ TpT1‚^ 3const StateSparse &f‚] 'StateFactor &f‚\ 3const StateFactor &f‚[ doubles‚Z 'StateSparse &ss‚Y %StateDense &sd‚X 'StateFactor &sf‚W 'StateSparse &sf‚V %StateDense &sf‚U 1const StateDense &f‚T 'InputIteratore‚S 'InputIteratorb‚R 9typename InputIterator)‚Q Kconst std::map< Var, size_t > &s‚P #BigIntlinearStateT0‚O -const SmallSet &b‚N -const SmallSet &a‚M -const SmallSet &x‚L const T &t LÚ´ŽhBöЪ„^8츒lF úÔ®ˆbL}/classdai_1_1TProb#|Oac789826f975318da74da79eede4b2584#{Oa66bba72aedd5bd53390424d68bdd3b4c#zOab43e580b79ff06a7bf35b7b9faa92af6#yOaffa1342a2ff6444cda2661c2e9829acf#xOaa1528118bca7246714984dfe88d569d8#wOa8da41eabb003895e074d2c98a2e976a6#vOa4e662584f2066697602c41ce9b8f8984#uOa994c9f22df68683a13c5c6730a41a6af#tOa3e65fbe83ba367cc54b6ae2fc59a0e391sknamespacedai_1acc277bd4f0edae875fca22f063a37220#rOa3930b35d8c209c4ec1fd0dd6c963cb26#qOa75cb64b76a701c692def907f319883ac#pOa7324f2d3100d67b7f638e37a7fdf3241#oOae7fe73bdb5deae06075b47e28de54cbf#nOa4b4c3f31cf1ed2fb04a3e2ae48465606#mOacb4b126915d4e22a2cf54cc5d98cd8d0#lOa36f9ee114f04e1453b12c895ac6368e0#kOaa37766332e1b1969df5bbaa46cc741fd#jOa1ad2b3713a0588cdda7f8b3f9ff2611b#iOac4b6eb394223ae0b6c8a8eea17e2e4fd#hOa2e0ccbad2966a265471a939855be73b2#gOa30e73d762d643d9cd20dd7a06126ed52#fOa99e3f91437fee148644706ac0a77093f#eOaf3059c205c78aeda6fa9e9a9e1406a93 f`@ôΧ€Y2 ä½Ù–oH!úÔ­‡`²‹adO&Oad973502d526f51f447d704fa41ac17dd&Oaddebd3eea8092f2e9bc545d3040467fb”%Oadd12b9035b91ef9d27a0c1a24bbd0064E&Oadd0675bc15f6b004150014a1e28cf15eD%Oada42bd8c274d16179909327d8d062991&&Oada0e0829e87b541633dbb6078529c21d°&Oada04f5f0822a7ef518da4608c6c6b8e5&Oad973502d526f51f447d704fa41ac17dd&Oad856e0dce255c429a4cddaba99c7d0f0Ô&Oad822c8364c05c09800989bc2cd1ba56b3&Oad7480992a3c33f1b18e7b18b1f7f4241N&Oad723be19b6d346867d5477ae26cc4bf1L&Oad705857af3c53a94264590f8a6d1a120¤&Oad6e23438f9dd7ea3e7514c3ba6238875f&Oad626a9026442276889c629217f10f04d&&Oad5ae1f76a8794bfc0a5a757f83d2a245š&Oad4acfd3184f92a0418f42be88256b4ea%Oad41a02444c605aaff2ab9d87cce561eer%Oad40deb407b61be3a3f0d6f862983c51bg%Oad38098f89c197e0202c1d657a37743bf{%Oad181ae777f715e6659aeaefe552b9e6a%&Oadeaba07976118ad2b6b2d891a4bf2009O&Oade7f623237328458325bce5322abe03em&Oad7aa0cb04517a5423a6456097c076d08Ž U³öìâØÎĺ°¦œ’ˆ~tj`VLB8.$üòèÞÕËÁ·­£™…{qg^TKB8.$üòèÞÔÊÀ¶¬¢˜Ž„zpf\RH>4*  øîäÚÐƽ³‡\ÿv‡[ÿ=‡Zÿu‡Yÿ`‡Xÿu‡Wÿ`‡Vÿ`‡Uÿt‡Tÿ`‡Sÿq‡Rÿq‡Qÿq‡Pÿq‡Oÿr‡Nÿq‡Mÿq‡Lÿq‡Kÿq‡Jÿq‡Iÿr‡Hÿq‡Gÿo‡Fÿo‡Eÿo‡Dÿo‡Cÿo‡Bÿo‡Aÿo‡@ÿo‡?ÿo‡>ÿo‡=ÿn‡<ÿm‡;ÿk‡:ÿm‡9ÿl‡8ÿk‡7ÿj‡6ÿi‡5ÿh‡4ÿ‡3ÿ‡2ÿg‡1ÿ‡0ÿf‡/ÿò‡.ÿe‡-ÿ`‡,ÿd‡+ÿ`‡*ÿc‡)ÿ`‡(ÿa‡'ÿ`‡&ÿ`‡%ÿA‡$ÿ_‡#ÿœ‡"ÿY‡!ÿZ‡ ÿ^‡ÿ[‡ÿX‡ÿV‡ÿW‡ÿ^‡ÿ[‡ÿ]‡ÿœ‡ÿœ‡ÿW‡ÿV‡ÿ\‡ÿ[‡ÿX‡ÿ\‡ÿ[‡ÿœ‡ÿZ‡ ÿY‡ ÿU‡ ÿ—‡ ÿX‡ ÿW‡ÿV GʼnW(ùÉxJÛ™a#×GEW ;K std::unordered_multisetclassclassstd_1_1unordered__multisetEV ;K std::unordered_multimapclassclassstd_1_1unordered__multimapIU ;O std::tr1::unordered_mapclassclassstd_1_1tr1_1_1unordered__map>’;T 1A std::unordered_mapclassclassstd_1_1unordered__map5S +; std::unique_ptrclassclassstd_1_1unique__ptr?R 5E std::underflow_errorclassclassstd_1_1underflow__error>Q 3C std::unary_functionclassclassstd_1_1unary__function R+P !/ dai::UEdgeclassclassdai_1_1UEdge"M+O !/ dai::TRWBPclassclassdai_1_1TRWBPZ4NN AS dai::TreeEP::TreeEPSubTreeclassclassdai_1_1TreeEP_1_1TreeEPSubTreeNQ-M #1 dai::TreeEPclassclassdai_1_1TreeEPN(,L !/ dai::TProbclassclassdai_1_1TProb Â,K #1 std::threadclassclassstd_1_1thread/J %3 dai::TFactorclassclassdai_1_1TFactorW79I /? std::system_errorclassclassstd_1_1system__error8H /= std::stringstreamclassclassstd_1_1stringstream <Ú´ŽvPöЪ„^8ìÆ zT.â¼–b<#‚Oa2cccf0cd38b68a3b22b167b2af90e5181‚knamespacedai_1aa2735a823696443089d2de23e8ee6ecb#‚Oaefdaa35a881dd00aff2894986f5967c2#‚Oab4cfb99bfafa3e661caa11171c8918be#‚Oa28fad4d7ae2fbd669adb66e6ff68aa8c#‚Oa8d7fe99f8f97ffba15a45bb1f0cdc117#‚Oa2afce2bdf9612aeb82935f02c87f3215#‚Oa783929437b952f005e2a1405ac23baf7#‚Oae3e812f227cfe10e36696a76967a31b7#‚ Oa7d2acdd799407118d8fb1f24acad62fc#‚ Oa50d919bf70f5740e6fd2f3b2358a6545#‚ Oa13e0ffe16298c7be7f448ad35ad6fa82#‚ Oaaa6ec0e95ae9ed3e20a20416b1d114f7#‚ Oa85ad330af53b8353bb88ebc104a1e6aa#‚Oa1cb94d00b6f5ff6a3f708a06e1b9a6ec#‚Oaba509d63554e9ce6f06ee2e2f3189487#‚Oaf43065824e2a8607b8448a772981ea98#‚Oa30364f948c89de11c4708b0c3b131a92#‚Oa2395b393cfa1b05ed5eb8984bb06de0f1‚knamespacedai_1ae0d0ef753bd0ba57586e556ab6312677#‚Oada04f5f0822a7ef518da4608c6c6b8e5‚3classdai_1_1TFactor#‚Oa6d4790b31f1e3ccc210bc3fa27fecfbb#Oa4908ad29222b60d669d234d0805605b8#~Oa55d8a523959045be1a040f2d33436c8d "cêÜÁ rW=÷Ý·£‰xfM5úå¼ u_A% ïÔµ–wcƒ size_tvsƒ 1const TProb< T > &bƒ 1const TProb< T > &aƒ 1const TProb< T > &qƒ binOp2binaryOp2ƒ binOp1binaryOp1ƒ +typename binOp2ƒ +typename binOp1qƒ /typename binaryOpqƒ binaryOpop(ƒ /'typename binaryOpxdai::NORMPROBƒ -typename unaryOp&ƒ %'ProbNormTypenormdai::NORMPROBƒ unaryOpopƒ -typename unaryOpqƒ /const this_type &q‚ boolminimize‚~ 'typename unOp‚} unOpop‚| Tinit‚{ 'typename unOpi‚z size_tsz#‚y =const std::vector< S > &vT‚x %ProbDistTypedt‚w 5const TFactor< T > &f"‚v 5const TFactor< T > &ftrue‚u boolnormedtrue‚t size_tvarsState‚s )typename binOpg‚r binOpop‚q 5const TFactor< T > &g‚p )typename binOpx ‚o Tx‚n TxNORMPROB 5ƒïÞͼ«š‰xgWG7'ôãÒÁ°ŸŽ}l[J9(õäÓ± ~m\K:)öåÔ󣓃 ‚b 3Nà ‚a 2"N¾ ‚` 1Nº ‚_ 1Nº‚^ 0ý ø‚] 0ý ø‚\ /ý ï‚[ /ý ï‚Z .ý â‚Y - Ì‚X -ý Ì‚W -ý Ì‚V , Á‚U + »‚T * ¶‚S ) °‚R ( ª‚Q ' ¥‚P &  ‚O % •‚N $ ‹‚M # †‚L " €‚K ! z‚J   u‚I  p‚H  g‚G  ‚F  Ú‚E  ¢‚D  œ‚C Wv‚B Wl‚A Wl‚@ Wb‚? Wb‚> WT‚= WT‚< WT‚; WG ‚: "Wñ ‚9 "Wî ‚8 "Wå ‚7 "WÝ‚6 WÊ‚5  WÁ‚4  W¸‚3  W¯‚2  W”‚1  WŠ‚0 Wƒ‚/ W|‚. Wu b;Ù³f?;ñË¥~Wˆ0 ã¼–pI"üÖ¯b&Oaf37305c285dbe556f8a40cbf3ccf4be3‹&&Oaf50adc4fad1e07093579e746302bc884•&Oafea9f9b5f84f7e25dbe42f9ef928e798W%Oafdc73b83924ea54de96b90b9367e5df2%Oafd0bbc52192c65e207d721906e3e0a2be&Oafcfc874f85b4a2944ec128ebd1dd19f1„&Oafbde3d057ec404d5f4f962da46bcccedv%Oafb1021aaed050bf090adaee7a0eda17b%Oafa381567faaf7abf0d1291389e576396`&Oaf91c0967330dd41b93da470527c42a46¿%Oaf8ac0b97fc2059c27793f81f7424fa2fC&Oaf7876f0893b969c4d2842927085c18e3¡&Oaf688c62fd7c8dff22e24835547cec7e7Z&Oaf4ebfa31613bde8eea1a9b2d67749c41>&Oaf4920b0a867f986f2a2b8981567ee5d1­%Oaf476d8a940e49dbc7997c4c9b3f5e752v%Oaf46505d1fc833ef90b5698eb5eae57d2y&Oaf43065824e2a8607b8448a772981ea98&Oaf3059c205c78aeda6fa9e9a9e1406a93å&Oaf2af5b7cf99d958b867338e54734c45a &Oaf1fe425c6fa07fe9888c8b00238b4b42Á%Oaf062d83cd85b5eb6571373aef78bcc78O%Oaf0608983940f78bd6fefe0933404861e&Oaefdaa35a881dd00aff2894986f5967c2 U»öìâØÎĺ°§ž”Š€vlbYPF=3) ÷íãÙÏÅ»±§“‰ukaWMC9/%ýóéßÕËÁ·­£™…{qg]TJ@6,"ýôêà×ÎÅ»ˆ1ÿ‘ˆ0ÿˆ/ÿˆ.ÿˆ-ÿˆ,ÿˆ+ÿˆ*ÿˆ)ÿBˆ(ÿˆ'ÿˆ&ÿŽˆ%ÿˆ$ÿŽˆ#ÿˆ"ÿeˆ!ÿ=ˆ ÿxˆÿŒˆÿeˆÿ‹ˆÿŠˆÿ|ˆÿ€ˆÿ€ˆÿ€ˆÿ€ˆÿ€ˆÿ€ˆÿ€ˆÿ†ˆÿ€ˆÿ€ˆÿ€ˆÿ€ˆÿ€ˆ ÿ€ˆ ÿ€ˆ ÿ†ˆ ÿ€ˆ ÿoˆÿoˆÿoˆÿoˆÿoˆÿoˆÿoˆÿoˆÿoˆÿo‡ÿo‡~ÿƒ‡}ÿk‡|ÿ‚‡{ÿƒ‡zÿl‡yÿk‡xÿ‚‡wÿ€‡vÿ€‡uÿ‡tÿ}‡sÿ|‡rÿ}‡qÿ|‡pÿ‡oÿg‡nÿ‡mÿ‡lÿz‡kÿy‡jÿK‡iÿJ‡hÿI‡gÿa‡fÿu‡eÿu‡dÿw‡cÿq‡bÿw‡aÿq‡`ÿw‡_ÿx‡^ÿq‡]ÿw ]Ú´ŽU/ ã½—qK%ÿÙ³gAõÏ©ƒ]#‚.Oa90d9a0813d92ef6e15e0fb9a73ec8c55#‚-Oabd07922b69c64c0f873cbb0c6723a908#‚,Oa7e87a1887051cf2fa76b472456cdf5df#‚+Oa45912403206dece7aa792325378f9bcb#‚*Oa22bcf17b9eb7d6680d163eafff62e325#‚)Oae10251b3e36a146d92732e0df5ca3fc5#‚(Oa882dd82ffb2b2d3cd709b07fede37a46#‚'Oabd29d7c5df8a54c8139edeaaddc61c81#‚&Oad626a9026442276889c629217f10f04d#‚%Oa124aabb51e1b8e52ab6d9d62e938b7ac#‚$Oa61e35d41a5716685f8536f9ecbc655cd#‚#Oa3aafaddd7cfeb51b46606a4d77e99c41#‚"Oa5a141778b339e2cce742ca6f7a5a2eaa#‚!Oaa0e26d77620b8a3d07d1ec7843fa0c56#‚ Oaf2af5b7cf99d958b867338e54734c45a#‚Oad4acfd3184f92a0418f42be88256b4ea#‚Oaa8334fedf3a5da32bc022464071222c7#‚Oab2414cf14329da58b0519adf8d783cb5#‚Oa2d46eaa02bcc8ff6a0a480302cdcd7c0#‚Oaab76d678deecbe23d367bd86e59656c16‚uclassdai_1_1TProb_1a3fd857f47bad7e3917df607cb38aa2ae#‚Oad973502d526f51f447d704fa41ac17dd#‚Oa2f0ced4bc2927eea87bf14438aa63f8e#‚Oa30ea8a783f28550835226f139fa87e97 å_8 íƩdz„H ï×¾§pO*ºž†åw^G3classdai_1_1Permutew=classdai_1_1ClusterGraph:Aclassdai_1_1BipartiteGraph87classdai_1_1Exception‘&Oaffa1342a2ff6444cda2661c2e9829acfù&Oaff5afd515efbd7e6bcf78fe9e68d366d¯1classdai_1_1RegionÑ;classdai_1_1PropertySetHclassdai_1_1ParameterEstimation_1a20a742581e5e8f4af0905e440d084031½ãCclassdai_1_1BBPCostFunction $Kclassdai_1_1ParameterEstimationà Eclassdai_1_1MaximizationStepQ6oclassdai_1_1MR_1a4fe1bd2e25b9582105ec6ca44af0df3f´1classdai_1_1InfAlg3classdai_1_1GraphELÚ3classdai_1_1GraphALx;classdai_1_1FactorGraph<}classdai_1_1Exception_1a03abb65a270707eca57262d8b569e92bc;{classdai_1_1Evidence_1ae322863268ee661c1209d6a5c4e8750eV5classdai_1_1EvidenceP/classdai_1_1DEdgeL+classdai_1_1DAGG;classdai_1_1CobwebGraph? )classdai_1_1BP WÚ´ŽhBß¹“mEùÓ­‡a;ïÉ£}W#‚GOa21deaa91800f5ff86df64e0030057563#‚FOa3dc75e63b05b1186858ba6825d3a2a4a#‚EOa26f755375f7302f3cad54098c1064347#‚DOadd0675bc15f6b004150014a1e28cf15e#‚COae2be45ffdcaed373e473d9618cc221b6#‚BOa2aeaf6c4106d09935a038895d9563bc9#‚AOacc601513c56733dcac61edb09013b074#‚@Oa7d006595c29b6328464f96bcd924071e#‚?Oa17520d36314443f8e9c2761695c4a68f#‚>Oaf4ebfa31613bde8eea1a9b2d67749c41#‚=Oae06e3d56616ed75b8b34cd945d25c2a2#‚<Oa395904b1e262b0b188d9d8277b4a0162#‚;Oaa456a343b232915dd94de066c9a54f28%‚:Sclassdai_1_1TreeEP_1_1TreeEPSubTree#‚9Oa0ae27f56ca9a4d285772921d7555f6b1#‚8Oaa80198b5748e12b059ce6b99160cc6e9#‚7Oa6a1582e1c93f0b9d18fdf08c02201c0f#‚6Oac3f12eb0685ac91e4f3970accb65b0dd‚51classdai_1_1TreeEP#‚4Oaa07d388e9201b937cc7275dc9c2d2c8e#‚3Oad822c8364c05c09800989bc2cd1ba56b#‚2Oa3cc3718d1fbdf67db23a846283f99d08#‚1Oaa9de4c6919232d931772b43625fb0c3b#‚0Oa143a4623be8c9356e3cdb2f75f64f0d8#‚/Oab48f95b7d1bdfe60ef2f25cd78dec376 :ƒïÞξ®}l[K;+ ûëÛ˼­ž€qbRB2#óäÕÆ·¨™Š{l]N?/!÷éÚ˼­Ÿ‘ƒ ƒ  ^; ƒ  ]2 ƒ  ]2 ƒ  \Û ƒ  \ Û ƒ  \Û ƒ  \Û ƒ  [ ƒ  Zj ƒ  Yd ƒ  X[ ƒ  X[ ƒ W"_ ƒ V _l ƒ V _l ƒ  U _i ƒ  T _f ƒ  T=_f ƒ  S ]t ƒ  R ]k ƒ Q ]b ƒ P ]Y ƒ O ]P ƒ N ]G ƒ M ]> ƒ LJ"m ƒ KJ"d ƒ IJ"_ ƒ HL"\ ‚ GZ„ ‚~ FZ ‚} E–Zt ‚| DZq ‚{ CZl ‚z BZ^ ‚y AZ[ ‚x AZ[ ‚w @ZR ‚v @ZR ‚u ?0N ‚t ?0N ‚s >0NŠ ‚r >0NŠ ‚q =0N‡ ‚p =0N‡ ‚o <0N€ ‚n <0N€ ‚m <0N€‚l <–N€‚k <–N€ ‚j ;:Np ‚i 9:Nm‚h 8–NÊ ‚g 8NÊ ‚f 7N´ ‚e 7N´‚d 65N¢‚c 45N› _åá{U'ùÞ³ˆc>% ñÙÁ„kK/ìņ_$ƒ* 3const std::string &filename<ƒ) econst std::map< std::string, std::string > &aliases$ƒ( 3const std::string &nameOpts&ƒ' 3const std::string &nameOptsT0ƒ& #VarIteratorendƒ% #VarIteratorbeginƒ$ 5typename VarIteratorƒ# #const Var &v2ƒ" #const Var &v1!ƒ! ;const SmallSet< Var > &xƒ size_tstatesƒ size_tlabelTƒ 'const UEdge &eƒ 'const UEdge &xƒ size_tnrTrees"ƒ ;std::vector< Factor > &Qb"ƒ ;std::vector< Factor > &Qa(ƒ Gconst std::vector< Factor > &Qb(ƒ Gconst std::vector< Factor > &Qaƒ )const Factor *I+ƒ Gconst std::vector< Factor > &jt_Qb+ƒ Gconst std::vector< Factor > &jt_Qa#ƒ 1const RootedTree &jt_RTree#ƒ 1const RootedTree &subRTreeƒ 7const TreeEPSubTree &xƒ 1const RootedTree &treeƒ )const TreeEP &x WÁ÷íãÙÏÅ»±§“‰ulcZQH?6,"üóêáØÏÅ»±§”Š€vmd[RI@7.$ýóêáØÎż²©Ÿ–Œ‚xnd[RH?6-$ýóéßÕËÁ‰ÿ²‰ÿ±‰ÿ°‰ÿ¯‰ÿ®‰ÿ¯‰ÿ®‰ÿ­‰ÿ¬ˆÿ#ˆ~ÿˆ}ÿ"ˆ|ÿ!ˆ{ÿ ˆzÿ«ˆyÿ ˆxÿˆwÿªˆvÿ©ˆuÿ,ˆtÿ,ˆsÿ©ˆrÿˆqÿ¨ˆpÿˆoÿ§ˆnÿˆmÿˆlÿÛˆkÿBˆjÿ=ˆiÿ5ˆhÿ¦ˆgÿ¥ˆfÿ£ˆeÿ¢ˆdÿAˆcÿ¡ˆbÿYˆaÿ=ˆ`ÿYˆ_ÿYˆ^ÿYˆ]ÿYˆ\ÿYˆ[ÿYˆZÿ ˆYÿŸˆXÿžˆWÿ=ˆVÿˆUÿˆTÿ…ˆSÿƒˆRÿ‚ˆQÿFˆPÿ ˆOÿFˆNÿˆMÿˆLÿDˆKÿ ˆJÿœˆIÿ‘ˆHÿ²ˆGÿ±ˆFÿ ˆEÿ ˆDÿˆCÿˆBÿˆAÿˆ@ÿˆ?ÿ™ˆ>ÿ˜ˆ=ÿ›ˆ<ÿšˆ;ÿ™ˆ:ÿ˜ˆ9ÿ—ˆ8ÿ–ˆ7ÿ•ˆ6ÿ”ˆ5ÿ“ˆ4ÿ’ˆ3ÿ’ˆ2ÿ ¯:ðÊ£|U:ˆ/⼕ÕüaoI#Ö&Oa610Ö&Oa6104711a37099d2bea16ebc26f35592dI&Oa6a1582e1c93f0b9d18fdf08c02201c0f7&Oa6154e193b6b0581b1552728a03b26f39\>&&Oa6715831e60e66582bce1c69518a40dd3n&Oa68ec048cdbefcf8a488469dd14938452c%Oa6a80d5a63b0e2c3e9cf81f92fd0456a55%Oa6a3b13b021a2823036dfa52037955307 %Oa6a169aace3fd0538e79cef8392cfe2a4$&Oa66bba72aedd5bd53390424d68bdd3b4cû%Oa644d6e3dbb32cfc815955a5ebd53df68s%Oa61f8685d3cab6ef99ca41c612e44284cq&Oa61e35d41a5716685f8536f9ecbc655cd$%Oa61c78c13bcc18b2e160b5bccaa9afe3b-&Oa5f88f13fab6393e609bdc8a47f538141È&Oa5e7f0c159e23c48c93b92a83572a1b37&Oa5dcaac5456934d874a030e4b1db1c961¥%Oa5cd7000971e68e732d5dffa7c665804a~&Oa5c81f2500cc196eb50921d7db7794216Ž&Oa5c279ce0fa2cda3fda5379252d1bdd99¹Â ZÚ´žxR,ດnH"üÖ°Šd>ò̦€Z#‚`Oaadf664acf42371b8f25ade335a805da1#‚_Oaee9a0cc9279a7add0849f964e3bdfbed#‚^Oa56e006b34155719d5ab9c0dbc9bd57f4#‚]Oa1091a5da35d620692783a17dbf265158#‚\Oa6154e193b6b0581b1552728a03b26f39#‚[Oacfb030b9c48de7885795f4d03d7226ee#‚ZOaf688c62fd7c8dff22e24835547cec7e7#‚YOa246c23914fee45f8b7f01f9073bdd6fe#‚XOa4b9e5254e7ec388e69aa68dfc54509e0#‚WOafea9f9b5f84f7e25dbe42f9ef928e798#‚VOae45f3b824a354219f7ee3ab8ee432fb2#‚UOac9e2eee9017df71e91f5ef4f01956de7#‚TOa38c683ce0ce0532625780e76f5eb5b9b#‚SOa2afe0ebb307f835920656e75f9a1961e#‚ROa6c82ecf70996c18280e063d1c5e02834#‚QOab0668fe05276356dd72bc0c4ba8e38fb#‚POa7bfc52374ce25ebf05f9bd8387512428#‚OOadeaba07976118ad2b6b2d891a4bf2009#‚NOad7480992a3c33f1b18e7b18b1f7f4241#‚MOac997b317a3b324312d03d8adaf387f15#‚LOad723be19b6d346867d5477ae26cc4bf1#‚KOac18760d5642f14aa1b64e0d3c611cb0f‚J/classdai_1_1UEdge#‚IOa6104711a37099d2bea16ebc26f35592d#‚HOa31d68730f49619179aff649cbe5c3d3d ]äÂ|cJ3ùḡvW Óg1]üÇ“5mexceptions_8h_1af50adc4fad1e07093579e746302bc884˜3knamespacedai_1a7515abf9952cd312e95a34ada0670e8504knamespacedai_1a72200157ce1fbccfe91f66a3f8416823‚4knamespacedai_1a2cff7aad0084432ddcc7ef52618b74bd€5mexceptions_8h_1af10f03c819f0c08973f3bb7c47b950675mexceptions_8h_1ad7aa0cb04517a5423a6456097c076d08“5mexceptions_8h_1a922d2784284e8f6ee4009c3d92ba48b6’5mexceptions_8h_1a29c0e906e26c7484c268d111c71f79da–Mclassdai_1_1greedyVariableElimination_1a4df26af88ad423ec9489da4cf418a4be|?classdai_1_1WeightedGraphŒ1classdai_1_1VarSet"+classdai_1_1Var /classdai_1_1UEdgeJ(Sclassdai_1_1TreeEP_1_1TreeEPSubTree:1classdai_1_1TreeEP59uclassdai_1_1TProb_1a3fd857f47bad7e3917df607cb38aa2ae/classdai_1_1TProbý3classdai_1_1TFactor5classdai_1_1SmallSet=E classdai_1_1SharedParameters_1af9cec794f26b175ed0bed628bfe746f7ß!Eclassdai_1_1SharedParameters£9classdai_1_1RootedTree– EªCú @Î{·Ep@kclassstd_1_1unordered__multiset_1_1const__reverse__iteratorstd::unordered_multiset::const_reverse_iterator^?q[classstd_1_1unordered__multiset_1_1const__iteratorstd::unordered_multiset::const_iteratorb>u_classstd_1_1unordered__multimap_1_1reverse__iteratorstd::unordered_multimap::reverse_iteratorQ=cOclassstd_1_1unordered__multimap_1_1iteratorstd::unordered_multimap::iteratorp<kclassstd_1_1unordered__multimap_1_1const__reverse__iteratorstd::unordered_multimap::const_reverse_iterator^;q[classstd_1_1unordered__multimap_1_1const__iteratorstd::unordered_multimap::const_iteratorX:kUclassstd_1_1unordered__map_1_1reverse__iteratorstd::unordered_map::reverse_iteratorG9YEclassstd_1_1unordered__map_1_1iteratorstd::unordered_map::iteratore8yaclassstd_1_1unordered__map_1_1const__reverse__iteratorstd::unordered_map::const_reverse_iteratorT7gQclassstd_1_1unordered__map_1_1const__iteratorstd::unordered_map::const_iterator "­IóŒCé¢JÅ|"XLkUclassstd_1_1wstring_1_1const__reverse__iteratorstd::wstring::const_reverse_iteratorGKYEclassstd_1_1wstring_1_1const__iteratorstd::wstring::const_iteratorIJ[Gclassstd_1_1vector_1_1reverse__iteratorstd::vector::reverse_iterator8II7classstd_1_1vector_1_1iteratorstd::vector::iteratorVHiSclassstd_1_1vector_1_1const__reverse__iteratorstd::vector::const_reverse_iteratorEGWCclassstd_1_1vector_1_1const__iteratorstd::vector::const_iteratorXFkUclassstd_1_1unordered__set_1_1reverse__iteratorstd::unordered_set::reverse_iteratorGEYEclassstd_1_1unordered__set_1_1iteratorstd::unordered_set::iteratoreDyaclassstd_1_1unordered__set_1_1const__reverse__iteratorstd::unordered_set::const_reverse_iteratorTCgQclassstd_1_1unordered__set_1_1const__iteratorstd::unordered_set::const_iteratorbBu_classstd_1_1unordered__multiset_1_1reverse__iteratorstd::unordered_multiset::reverse_iteratorQAcOclassstd_1_1unordered__multiset_1_1iteratorstd::unordered_multiset::iterator 7Âe5Ò“`+ÍŽY&ç¶y7?i 5E  dai::_builtinInfAlgsclassclassdai_1_1__builtinInfAlgs:h 1? std::wstringstreamclassclassstd_1_1wstringstream.g %3 std::wstringclassclassstd_1_1wstringðÉ£|UÙ.ổ_oH!ûÔ­†&Oae62bf4dfaa6694edc2d180b71656d430…&Oaee9a0cc9279a7add0849f964e3bdfbed_&Oaece6000831c8fad8e42364cd8ef41594á&Oae972f478c3167b4b5a88840165828518·%Oae8480cbb4a614119a211ffc03221ba47&Oae7fe73bdb5deae06075b47e28de54cbfï&Oae686384295f9909532d78328f87ae260k%Oae678616088bb43db04d4ba44c8d52f38u%Oae620ed3291b0a1a229a94b0872c8ad81l%Oae6070148d57ea999a3a1980b54df9318+%Oae5315044de332e92a6ed12acce7f0f75/&Oae45f3b824a354219f7ee3ab8ee432fb2V&Oae412446097e88867fc9a327d07f12daat&Oae3e812f227cfe10e36696a76967a31b7&Oae3805b761d8750c61af23b3a1a51a0beã%Oae3517f9e23e01e188055361bd0084005&Oae2be45ffdcaed373e473d9618cc221b6C&Oae1477e1babd787c9642d16e2a085697bä&Oae10251b3e36a146d92732e0df5ca3fc5)&Oae06e3d56616ed75b8b34cd945d25c2a2=&Oadff10df2f1a0320d2b67d94bbfbb5b99®&Oadf624997c47362bc5db95242b76a66a4p&&Oae40c2873869c363218a8945a44e03525 UÄ4ä£V÷§Zû±UZ^Q1Kstd::basic_stringstream< wchar_t >std::wstringstreamclassstd_1_1basic__stringstreamH]E%?std::basic_string< wchar_t >std::wstringclassstd_1_1basic__string]\S3Mstd::basic_ostringstream< wchar_t >std::wostringstreamclassstd_1_1basic__ostringstreamK[G'Astd::basic_ostream< wchar_t >std::wostreamclassstd_1_1basic__ostreamNZI)Cstd::basic_ofstream< wchar_t >std::wofstreamclassstd_1_1basic__ofstream]YS3Mstd::basic_istringstream< wchar_t >std::wistringstreamclassstd_1_1basic__istringstreamKXG'Astd::basic_istream< wchar_t >std::wistreamclassstd_1_1basic__istream?W?9std::basic_ios< wchar_t >std::wiosclassstd_1_1basic__iosNVI)Cstd::basic_ifstream< wchar_t >std::wifstreamclassstd_1_1basic__ifstreamKUG'Astd::basic_fstream< wchar_t >std::wfstreamclassstd_1_1basic__fstreamAT5;+std::map< UEdge, T >dai::WeightedGraph< T >classstd_1_1map:S5#5dai::SmallSet< Var >dai::VarSetclassdai_1_1SmallSet KÄw@"츜uW'ù½Ÿ{Y7ç½qK$b5#structdai_1_1fo__absdai::fo_absa+classdai_1_1FBPdai::FBP,`;-classdai_1_1FactorGraphdai::FactorGraph(_7)classdai_1_1Exceptiondai::Exception&^5'classdai_1_1ExactInfdai::ExactInf&]5'classdai_1_1Evidencedai::Evidence \/!classdai_1_1EMAlgdai::EMAlg [/!classdai_1_1DEdgedai::DEdge"Z1#classdai_1_1DAIAlgdai::DAIAlgY+classdai_1_1DAGdai::DAG:XI;classdai_1_1CondProbEstimationdai::CondProbEstimation,W;-classdai_1_1CobwebGraphdai::CobwebGraph.V=/classdai_1_1ClusterGraphdai::ClusterGraphU+classdai_1_1CBPdai::CBP%T5%classdai_1_1BP__dualdai::BP_dualS)classdai_1_1BPdai::BP2RA3classdai_1_1BipartiteGraphdai::BipartiteGraph4QC5classdai_1_1BBPCostFunctiondai::BBPCostFunctionP+classdai_1_1BBPdai::BBP5OE5classdai_1_1__builtinInfAlgsdai::_builtinInfAlgsKN]Iclassstd_1_1wstring_1_1reverse__iteratorstd::wstring::reverse_iterator:MK9classstd_1_1wstring_1_1iteratorstd::wstring::iterator ;Ò¢|J&Ø´Žf@îÈ¢|V îÅyW;z)classdai_1_1LCdai::LC y/!classdai_1_1JTreedai::JTree"x1#classdai_1_1InfAlgdai::InfAlg&w5'classdai_1_1IndexFordai::IndexFor'v7'classdai_1_1hash__mapdai::hash_mapu+classdai_1_1HAKdai::HAKHtWIclassdai_1_1greedyVariableEliminationdai::greedyVariableElimination$s3%classdai_1_1GraphELdai::GraphEL$r3%classdai_1_1GraphALdai::GraphAL$q3%classdai_1_1FRegiondai::FRegion$p5#structdai_1_1fo__powdai::fo_pow*o;)structdai_1_1fo__plog0pdai::fo_plog0p$n5#structdai_1_1fo__mindai::fo_min$m5#structdai_1_1fo__maxdai::fo_max&l7%structdai_1_1fo__log0dai::fo_log0$k5#structdai_1_1fo__logdai::fo_log"j3!structdai_1_1fo__KLdai::fo_KL&i7%structdai_1_1fo__inv0dai::fo_inv0$h5#structdai_1_1fo__invdai::fo_inv"g3!structdai_1_1fo__iddai::fo_id0fA/structdai_1_1fo__Hellingerdai::fo_Hellinger$e5#structdai_1_1fo__expdai::fo_exp.d?-structdai_1_1fo__divides0dai::fo_divides0,c=+structdai_1_1fo__absdiffdai::fo_absdiff XȬh?Ùª…V)ÖtQ*â¿œ}X"1#classdai_1_1VarSetdai::VarSet+classdai_1_1Vardai::Var /!classdai_1_1UEdgedai::UEdge /!classdai_1_1TRWBPdai::TRWBP" 1#classdai_1_1TreeEPdai::TreeEP /!classdai_1_1TProbdai::TProb$ 3%classdai_1_1TFactordai::TFactor /!classdai_1_1Statedai::State&5'classdai_1_1SmallSetdai::SmallSet6E7classdai_1_1SharedParametersdai::SharedParametersP_Qclassdai_1_1sequentialVariableEliminationdai::sequentialVariableElimination*9+classdai_1_1RootedTreedai::RootedTree,;-classdai_1_1RegionGraphdai::RegionGraph"1#classdai_1_1Regiondai::Region,;-classdai_1_1PropertySetdai::PropertySet$3%classdai_1_1Permutedai::Permute<K=classdai_1_1ParameterEstimationdai::ParameterEstimation'7'structdai_1_1Neighbordai::Neighbor&~5'classdai_1_1multifordai::multifor})classdai_1_1MRdai::MR|)classdai_1_1MFdai::MF6{E7classdai_1_1MaximizationStepdai::MaximizationStep CÍ¢U)ÿËi3Ñ]'ó³C;#K;classstd_1_1basic__stringstreamstd::basic_stringstream/"?/classstd_1_1basic__stringstd::basic_string=!M=classstd_1_1basic__ostringstreamstd::basic_ostringstream1 A1classstd_1_1basic__ostreamstd::basic_ostream3C3classstd_1_1basic__ofstreamstd::basic_ofstream=M=classstd_1_1basic__istringstreamstd::basic_istringstream1A1classstd_1_1basic__istreamstd::basic_istream3C3classstd_1_1basic__iostreamstd::basic_iostream)9)classstd_1_1basic__iosstd::basic_ios3C3classstd_1_1basic__ifstreamstd::basic_ifstream1A1classstd_1_1basic__fstreamstd::basic_fstream+;+classstd_1_1bad__typeidstd::bad_typeid1A1classstd_1_1bad__exceptionstd::bad_exception'7'classstd_1_1bad__caststd::bad_cast)9)classstd_1_1bad__allocstd::bad_alloc'7'classstd_1_1auto__ptrstd::auto_ptr /!classstd_1_1arraystd::array(7)classstd_1_1allocatorstd::allocator0?1classdai_1_1WeightedGraphdai::WeightedGraph 'V׶œ‹zT. 俧ƒp]I5! ùæλ§–…hR5ëÚë—„qVƒQ )TFactor< T > &fƒP class TƒO size_tdƒN size_tN3ƒM boolperiodicƒL size_tstateƒK RealJƒJ #const Var &x2ƒI #const Var &x1ƒH #const Var &xƒG boolaccuratefalseƒF boolreInitƒE )const InfAlg &objƒD GROUPƒC SMALLƒB LDPCTypeƒA Realepsƒ@ Real *resultƒ? size_tpƒ> size_td2ƒ= size_td1ƒ< size_tN2ƒ; size_tN1ƒ: Realbetaƒ9 size_tMƒ8 size_tN!ƒ7 3const PropertySet &propsƒ6 !FactorTypeft"ƒ5 =const vector< Factor > &c"ƒ4 =const vector< Factor > &bƒ3 Realpƒ2 size_tnv#ƒ1 =const vector< Factor > &b2#ƒ0 =const vector< Factor > &b1ƒ/ Realbƒ. Realaƒ- size_tn_statesƒ, 1vector< size_t > &xis&ƒ+ =const vector< size_t > &state >‰òäÖȺ¬ŽpbTF8*ÿðâÔƸ©›qcUG9+óåÖǹ«œ~pbTD6' úìÞг¥—‰ ƒZ  ‰{ ƒY  ˆv ƒX  ‡q ƒW  †óh ƒV  …0 ƒU  „" ƒT  ƒ  ƒS  ƒ" ƒR  ‚O ƒQ  O ƒP  ~€L ƒO  ~L ƒN  }, ƒM  |€Ú ƒL  {5 ƒK  z( ƒJ  ya ƒI  x|3 ƒH  x3 ƒG  vw ƒF  v0 ƒE  v  ƒD  u$ ƒC  t ƒB  sd ƒA  rI ƒ@  q"? ƒ?  p 7 ƒ>  o. ƒ=  o . ƒ<  o . ƒ;  n& ƒ:  n"& ƒ9  m ƒ8  m  ƒ7  m  ƒ6  l ƒ5  l  ƒ4  kÓ ƒ3  j"L ƒ2  jL ƒ1  i" ƒ0  i ƒ/  h ƒ.  h ƒ-  gs ƒ,  f# ƒ+  fx# ƒ*  e:z ƒ)  d:i ƒ(  c:^ ƒ'  b:Y ƒ&  aÆ ƒ%  a Æ ƒ$  aÆ ƒ#  aÆ ƒ"  `0w ƒ!  `0w ƒ   `w ƒ  _0D ƒ  _0D ƒ  ^; V¼öìâÙÐǾµ¬£š‘ˆvmcYOE;1' ÿõëá×Íú°§“Š€vlbXNE;1( ÷íãÙÐƼ²¨Ÿ•Œ‚ypf\RH>4*  øîäÚÐƼ‰^ÿÒ‰]ÿщ\ÿÒ‰[ÿщZÿωYÿ¸‰Xÿ¸‰Wÿ¸‰Vÿ͉UÿΉTÿ¼‰Sÿ»‰Rÿ͉Qÿ¼‰Pÿ»‰Oÿ¸‰Nÿ‰MÿŽ‰Lÿ‰Kÿ=‰Jÿ̉IÿB‰Hÿ̉GÿA‰FÿˉEÿʉDÿɉCÿº‰BÿB‰Aÿˉ@ÿʉ?ÿɉ>ÿ#‰=ÿȉ<ÿʼn;ÿlj:ÿƉ9ÿB‰8ÿʼn7ÿƉ6ÿB‰5ÿʼn4ÿ ‰3ÿĉ2ÿÉ1ÿ‰0ÿÁ‰/ÿu‰.ÿÀ‰-ÿê‰,ÿ`‰+ÿ¿‰*ÿu‰)ÿщ(ÿщ'ÿщ&ÿщ%ÿщ$ÿ¾‰#ÿ½‰"ÿ¼‰!ÿ»‰ ÿº‰ÿê‰ÿ¹‰ÿ¸‰ÿ·‰ÿ ‰ÿ¶‰ÿÀ‰ÿ‰ÿ[‰ÿ‰ÿ[‰ÿ‰ÿ[‰ÿ‰ÿ[‰ÿR‰ÿ‰ÿ"‰ ÿV‰ ÿU‰ ÿµ‰ ÿ´‰ ÿ³ XÚ´ŽhBöЪ„^8ìÆ zT.⼤~X#‚yOac63c2f1d67d01aeda5c3cdd95843ea86#‚xOa4ac9b14596c7195e8401be42f18a4bf9‚w3classdai_1_1Permute#‚vOafbde3d057ec404d5f4f962da46bccced#‚uOa47ac972d2a1556524159ff0765ae19c5#‚tOae412446097e88867fc9a327d07f12daa#‚sOab1b9d59848e415c32330d4a7cbb3269a#‚rOa57fa52134afbd3da21c99975fbba7080#‚qOaa9aa5a66a5df1ae48e29c4ad0965f3c6#‚pOadf624997c47362bc5db95242b76a66a4#‚oOaab6d25e30baf39ea06c57b5f71c61a4e#‚nOa6715831e60e66582bce1c69518a40dd3#‚mOade7f623237328458325bce5322abe03e#‚lOa7dd9cb2405e798802d8cbb9b879fdf90#‚kOae686384295f9909532d78328f87ae260#‚jOa82e775a1e2908856f13fa1aa7c081d4c#‚iOaab8aabfe0fcfd4b4bd24757c101449d5#‚hOa05a9012934012426c9ea6a5d8ba26a72#‚gOa269bd60101452a427cc794572a6018a6#‚fOad6e23438f9dd7ea3e7514c3ba6238875#‚eOa990ea70014c5c6a90932d9cee11f393b#‚dOab6cfdf0bf047e72e324c04e96d310edb#‚cOa68ec048cdbefcf8a488469dd14938452#‚bOabb00ff16fe071140d9eb4c555c43e5d3#‚aOab41645939efa15bb66b14e20d1641c8f "bìÓ¯…U: ýðãϺ¢ŒqGúÔ¶Ÿ}fN5øØÁ§Žxbƒs !ISINGGAUSSƒr !FactorTypeƒq 'CFN_BETHE_ENTƒp )CFN_FACTOR_ENTƒo #CFN_VAR_ENTƒn 5CFN_GIBBS_EXP_FACTORƒm 3CFN_GIBBS_B2_FACTORƒl 1CFN_GIBBS_B_FACTORƒk 'CFN_GIBBS_EXPƒj %CFN_GIBBS_B2ƒi #CFN_GIBBS_Bƒh 3BBPCostFunctionBasepsiƒg longverboseƒf +const mxArray *psi#ƒe =const vector< Factor > &Psƒd #size_tlinearState-ƒc Kconst std::map< Var, size_t > &state'ƒb 3const std::string &delim"\t\n"ƒa #boolsingleDelimƒ` size_tseedƒ_ %_normal_distƒ^ _uni_distƒ] _rnd_gen ƒ\ 1 ƒ[ 0 ƒZ 42UƒY RealxƒX -const Property &pƒW size_tmaxStates-ƒV =%std::vector< Permute > &permutations'ƒU ;std::vector< Factor > &factors!ƒT 5std::vector< Var > &varsƒS size_tverboseƒR Tepsilon U¹÷íãÙÏƼ³©Ÿ–Œƒyoe[QG=3) ÷íãÙÏż²©Ÿ•‹wmcYOE;1' ÿõëá×Íù¯¥›‘‡}tjaWND;1' ÿõëá×ÍùŠ3ÿ Š2ÿŠ1ÿŠ0ÿŠ/ÿŠ.ÿŠ-ÿŠ,ÿŠ+ÿŠ*ÿŠ)ÿŠ(ÿŠ'ÿÿŠ&ÿ=Š%ÿþŠ$ÿ=Š#ÿûŠ"ÿ=Š!ÿúŠ ÿ=ŠÿùŠÿ´ŠÿÑŠÿLŠÿøŠÿÙŠÿÙŠÿÙŠÿÙŠÿ÷ŠÿöŠÿõŠÿôŠÿóŠÿòŠÿñŠÿðŠÿïŠ ÿîŠ ÿíŠ ÿìŠ ÿëŠ ÿêŠÿéŠÿèŠÿæŠÿçŠÿæŠÿåŠÿäŠÿBŠÿã‰ÿB‰~ÿâ‰}ÿá‰|ÿ,‰{ÿщzÿщyÿà‰xÿ߉wÿ݉vÿÞ‰uÿ݉tÿ܉sÿÛ‰rÿÚ‰qÿÙ‰pÿÉoÿœ‰nÿ4‰mÿŽ‰lÿ3‰kÿ=‰jÿ؉iÿ=‰hÿ׉gÿÙ‰fÿ‰eÿÓ‰dÿd‰cÿÖ‰bÿÕ‰aÿÔ‰`ÿÓ‰_ÿd KÚ´ŽhBÚ´€Z4èÂœvP* æÀ‹eKƒ7classdai_1_1Exception#ƒOae40c2873869c363218a8945a44e035252ƒmexceptions_8h_1af10f03c819f0c08973f3bb7c47b95067#ƒOad7aa0cb04517a5423a6456097c076d08#ƒ Oa394197d7c57ab6f1dd5bad99df18d51cƒ ?classdai_1_1WeightedGraph#ƒ Oaf37305c285dbe556f8a40cbf3ccf4be3#ƒ Oa16465ce3d62a6456fd06e9a226c966f2#ƒ Oac336ffb182b6e6fa3f7df13620aab012#ƒOa00375a4d7b55534c14f993c909b04c3c#ƒOa934491ad55f57c9072271b4a32ea4919#ƒOa8f9fdd7b607434fcda10d5be59f512d1#ƒOae62bf4dfaa6694edc2d180b71656d430#ƒOafcfc874f85b4a2944ec128ebd1dd19f1#ƒOa750c3807e7375265c3fb410a1f1223fe1ƒknamespacedai_1a72200157ce1fbccfe91f66a3f8416823#ƒOa205aca5e7688c28a95ecc978b4f798791ƒknamespacedai_1a2cff7aad0084432ddcc7ef52618b74bd1‚knamespacedai_1a8676cd0faacaec12b2acf0e0472e3280#‚~Oa95e934001307cafa4576b31fb0569e2c#‚}Oa9886ca4103eac52b3f82698e12e86672#‚|Oa0e910ae9247869ee549df8eed173a6df#‚{Oaab0479dd285fd4021ecaa80947d40da3#‚zOab339baefa9f588de2fba07526d8df7ba °b€#Z3 æ¿ÕÙ˜qJ‰²c‹eÚ´Ú´%Oacdfb5e4da942d55f02540d7a5fc29145&Oacc601513c56733dcac61edb09013b074Aü%&Oac997b317a3b324312d03d8adaf387f15M§'&Oac63c2f1d67d01aeda5c3cdd95843ea86y&Oacc10d4cd212255ae2edf44f121347665Ÿ&Oacb4b126915d4e22a2cf54cc5d98cd8d0í&Oacb3cc6c7e710caa546f86b043befadef¢&Oac960b7288a1230e23800dd97e399da7a“&Oac87e0972ae1b74bce8f5d75d2e230c52’%Oac7a2074bd52b7cb35a6473208140bb34h&Oac789826f975318da74da79eede4b2584ü%Oac74e4ae749a3f706462bb5c0c0f204caI&Oac4b6eb394223ae0b6c8a8eea17e2e4fdé¾p$%Oacfe1088cf3a677e92d05ac1dc234825bb&Oacfb030b9c48de7885795f4d03d7226ee[&Oacc72b3ade238acae11dcaf9d948a5b8b&Oac9e2eee9017df71e91f5ef4f01956de7U V:/ ã½–oH"û:Õˆ¯bÙ²‹d341557&341557&Oa56e006b34155719d5ab9c0dbc9bd57f4^%Oa58c0f9a380d5c4dd348aa701a142c127H&Oa57fa52134afbd3da21c99975fbba7080r%Oa58489efe89114b2afa9e250ef03bbf4d%Oa57aa22969b5feca8d2506262b9b2a2ca &Oa5620ffd618614200a976e78070bfc41fÖ%Oa56156ed9aeb1fcb50000c553fbeceaf6w&Oa55d8a523959045be1a040f2d33436c8dþ&Oa55c10d86bc897277108b545f22e06fb7Í&Oa55b77f60fc90fc287c9cba9df9306bfaÐ%Oa5509e79c9c41d7219104eaf07fce6a364%Oa54d0f7a94af04a274884c546bcad79c9}%Oa548db9c240464901a5d5cc37fe0e8caaB&Oa5434630d65c22c3f3dfc7b913b58bdafžt&Oa5b1e6d8af207bcc47fd954fdef382a77ˆ&Oa5aee1c116573bb069b0ef12c3c10a9b1•&Oa5a141778b339e2cce742ca6f7a5a2eaa"&Oa58f561154d9c74ac2f39a3b13196857f² &cèÔè—wR0á¹”oH1 úíàѳž‘{l_O?$æ§{c„ size_tvsBits)„ 9const BipartiteGraph &xCharfalse„ mxArray *nlhs[]!„ 3vector< Permute > &perms„ +const mxArray *vs„ +const mxArray *prhs[]„ mxArray *plhs[] „ body „ stmt „ n „ str„ Factor &fx „ x„ condition „ msg „ cod „ cod „ x „ x „ ... „ val0„ boolusePrimx„ boolusePrim$„ Aconst WeightedGraph< T > &G"„ =const std::vector< T > &v"„ =const std::vector< T > &u%ƒ Cconst std::pair< T1, T2 > &x$ƒ~ Aconst std::map< T1, T2 > &xƒ} class T2ƒ| class T1ƒ{ 7const std::set< T > &x"ƒz =const std::vector< T > &xƒy 3const std::string &xƒx Realyƒw )const BigInt &Nƒv POTTSƒu EXPGAUSSƒt %ISINGUNIFORM ;ñâÒ²¢’‚rbRB2"ôåÖǸ©š‹|m^O@1"õæ×ȹª›Œ~o`QB3$÷èÙÊ»¬ „ )P „ (f „ '  „ &  „ % ü „ $ Ð „ #" Ë „ !"  „   Á „   ¿ „   ¿ „   ¨ „   ¢ „  œ „  œ „  K „  / „ 6 „ ¤ „  ¤ „ ¤ „ ¤ ƒ  ƒ~  ƒ} ù ƒ| ÷ ƒ{ ÷ ƒz ò ƒy ò ƒx ò ƒw 4 ƒv + ƒu & ƒt ! ƒs ! ƒr  ƒq  ƒp  ƒo  ƒn  ƒm  ƒl ê ƒk è ƒj  äƒi ™wô ƒh ™ô ƒg —˜*A ƒf •–*< ƒe ”“*9 ƒd ”’*9 ƒc ”‘*9 ƒb “*. ƒa ’*. ƒ` ‘*. ƒ_ Ž* ƒ^  Œð ƒ]  ‹Œ¯ ƒ\  Š„ ƒ[  Š„ EÛ´‘_)ûØf?ܽ“l9涗nE&95'classstd_1_1multisetstd::multiset&85'classstd_1_1multimapstd::multimap7+classstd_1_1mapstd::map-6=-classstd_1_1logic__errorstd::logic_error5-classstd_1_1liststd::list/4?/classstd_1_1length__errorstd::length_error03?1classstd_1_1istringstreamstd::istringstream$23%classstd_1_1istreamstd::istream'17'classstd_1_1ios__basestd::ios_base0+classstd_1_1iosstd::ios7/G7classstd_1_1invalid__argumentstd::invalid_argument&.5'classstd_1_1ifstreamstd::ifstream$-3%classstd_1_1fstreamstd::fstream/,?/classstd_1_1forward__liststd::forward_list(+7)classstd_1_1exceptionstd::exception5*E5classstd_1_1error__conditionstd::error_condition+);+classstd_1_1error__codestd::error_code3(C3classstd_1_1error__categorystd::error_category/'?/classstd_1_1domain__errorstd::domain_error &/!classstd_1_1dequestd::deque$%3%classstd_1_1complexstd::complex"$1#classstd_1_1bitsetstd::bitset d×°}JÞ»‹W8 éÄ“a<Ö¢d;MK;classstd_1_1unordered__multimapstd::unordered_multimap1LA1classstd_1_1unordered__mapstd::unordered_map+K;+classstd_1_1unique__ptrstd::unique_ptr5JE5classstd_1_1underflow__errorstd::underflow_error"I1#classstd_1_1threadstd::thread/H?/classstd_1_1system__errorstd::system_error.G=/classstd_1_1stringstreamstd::stringstream"F1#classstd_1_1stringstd::string E/!classstd_1_1stackstd::stack)D9)classstd_1_1smart__ptrstd::smart_ptrC+classstd_1_1setstd::set1BA1classstd_1_1runtime__errorstd::runtime_error-A=-classstd_1_1range__errorstd::range_error @/!classstd_1_1queuestd::queue3?C3classstd_1_1priority__queuestd::priority_queue3>C3classstd_1_1overflow__errorstd::overflow_error0=A/classstd_1_1out__of__rangestd::out_of_range0<?1classstd_1_1ostringstreamstd::ostringstream$;3%classstd_1_1ostreamstd::ostream&:5'classstd_1_1ofstreamstd::ofstream LÂŽe@í¡xCﺓ`) ЛLLa]Istructdai_1_1BipartiteGraph_1_1levelTypedai::BipartiteGraph::levelType2`A3classdai_1_1BipartiteGraphdai::BipartiteGraph7_I5structdai_1_1BBP_1_1Propertiesdai::BBP::Properties^+classdai_1_1BBPdai::BBP4]C5classdai_1_1BBPCostFunctiondai::BBPCostFunction0\?1classstd_1_1wstringstreamstd::wstringstream$[3%classstd_1_1wstringstd::wstring2ZA3classstd_1_1wostringstreamstd::wostringstream&Y5'classstd_1_1wostreamstd::wostream(X7)classstd_1_1wofstreamstd::wofstream2WA3classstd_1_1wistringstreamstd::wistringstream&V5'classstd_1_1wistreamstd::wistreamU-classstd_1_1wiosstd::wios(T7)classstd_1_1wifstreamstd::wifstream&S5'classstd_1_1wfstreamstd::wfstream'R7'classstd_1_1weak__ptrstd::weak_ptr"Q1#classstd_1_1vectorstd::vector&P5'classstd_1_1valarraystd::valarray1OA1classstd_1_1unordered__setstd::unordered_set;NK;classstd_1_1unordered__multisetstd::unordered_multiset Ñ­:$ìẋ[ÈžR'õëÝʬ•v­íîáÏÁª”Ù†q`PA.Ñ#Iboost/graph/adjacency_list.hppã{7q/home/jorism/vcs/libdai/src/matlab/dai_writefg.cpp÷6o/home/jorism/vcs/libdai/src/matlab/dai_readfg.cppö/c/home/jorism/vcs/libdai/src/regiongraph.cppS.a/home/jorism/vcs/libdai/src/properties.cppR&Q/home/jorism/vcs/libdai/src/mr.cppM&Q/home/jorism/vcs/libdai/src/mf.cppJ1g/home/jorism/vcs/libdai/src/matlab/matlab.cppg;y/home/jorism/vcs/libdai/src/matlab/dai_potstrength.cppõ?boost/functional/hash.hppÚ/boost/foreach.hppÙ=boost/dynamic_bitset.hppÑ'boost/any.hppÔ algorithmy [STL]1g/home/jorism/vcs/libdai/src/weightedgraph.cppT*Y/home/jorism/vcs/libdai/src/varset.cppf(U/home/jorism/vcs/libdai/src/util.cppaó#)W/home/jorism/vcs/libdai/src/trwbp.cpp\*Y/home/jorism/vcs/libdai/src/treeep.cppY .rм² ’„ndYK<- ÿòÞË­seL6üãÛª’yldL3Ùƶ¤”„r'src/jtree.cpp #src/hak.cpp #src/glc.cpp'src/gibbs.cpp #src/fbp.cpp)src/decmap.cpp2m/home/jorism/vcs/libdai/include/dai/dai_config.h #src/dag.cpp-src/createfg.cpp5include/dai/daialg.h 3src/cobwebgraph.cpp map iostream 5include/dai/treeep.h 3include/dai/jtree.h3src/regiongraph.cpp5src/clustergraph.cppset5boost/shared_ptr.hpp fstream/include/dai/bbp.h3include/dai/trwbp.h/include/dai/fbp.h5include/dai/alldai.h !src/bp.cpp~?include/dai/regiongraph.h}?include/dai/factorgraph.h|Ainclude/dai/clustergraph.h{+src/bp_dual.cppz-src/bipgraph.cpp yalgorithm xostreamw/include/dai/cbp.h v!src/mr.cpp u#src/cbp.cpp t#src/bbp.cpp s!dai/enum.h rutilityqvectorp1src/matlab/dai.cpp o!src/lc.cpp n!src/io.cppm)src/alldai.cpplstringk-dai/dai_config.h.je/home/jorism/vcs/libdai/include/dai/alldai.h \Â÷îåÜÓÊÁ¸¯¦”‹‚ypg^ULC:1( ûòéà×Îż³ª¡˜†}tkbYPG>5,#ÿöíäÛÒÉÀ·®¥œ“Šxof]TKB90' úñèßÖÌÂ\ [€ Zp Yv Xu W Vt U sT QS 0R !Q lP kO~ N} M| L{ Kz Jt I 9H +G VF ?E yD qC xBwAv@u?t>=s<0;!:59r8q7k6pj5oj4nj3mj2j1jL0jC/jO.jF-j<,jI+j[*j3)j(j'j%&j(%jQ$j!#jl"jk!_` ]^Z[WXUVPQNOKLHIEFBC@A>?;<8967 523/0*+ '( $% "#  !    Q¯öíäÛÒÉ¿¶¬¢™‡}sjaXOE;1' ùðæÜÒÈ¿¶« –Œ‚xndZOD9.# ÿóçÛÐĹ­¡•‰}qfZNB6*úîâØÍù¯- 7, 0+ q* ‹) l (‚‘ 'Š‘ &£‘ %¢‘ $¡‘ #‰‘ " ‘ !Ÿ‘ ž‘ ‘ ‘w‘ œ‘ ›‘ ƒ‘ €‘ š‘ ™‘v‘ ˜‘o‘ —‘ –‘ •‘ ”‘ “‘ ’‘ u‘ {‘ ‘ t‘ 9V+?yqxhhŒhq~hX}Ž|{†zŒyyxswVv#u0t‹sŠr‰qˆp‡o0n m`lqk†j€iuhg!f…e„dkcƒb{as`0_!^k]‚ Iã¯wOÏ’s9µj;ñÒ­ˆIfS 9structdai_1_1BP__dual_1_1__edges__tdai::BP_dual::_edges_t%e5%classdai_1_1BP__dualdai::BP_dual5dG3structdai_1_1BP_1_1Propertiesdai::BP::Properties1cC /structdai_1_1BP_1_1EdgePropdai::BP::EdgePropb)classdai_1_1BPdai::BP C+m' ŸíÖ½¦vpÚmê¹Ô¾^@ †m(•ðI_RVdI‰”‡=4!üíÙɯ†Ã¸¬¡3include/dai/jtree.h‰ numericÒ mex.hÏ5include/dai/factor.hË Cinclude/dai/matlab/matlab.hÅ-include/dai/io.hÄ Cinclude/dai/weightedgraph.h¾/include/dai/var.h½1include/dai/util.h¼=include/dai/properties.h»1include/dai/prob.hº/include/dai/hak.h 3include/dai/graph.h¹/include/dai/glc.hŸ3include/dai/gibbs.hž/include/dai/fbp.h?include/dai/factorgraph.h}9include/dai/exactinf.h§9include/dai/evidence.h¦ iomanipî iteratorè limitsá3include/dai/index.hà math.hØ5include/dai/varset.h×5src/clustergraph.cpp‡#src/cbp.cppu+src/bp_dual.cpp{!src/bp.cpp-src/bipgraph.cppz#src/bbp.cppt)src/alldai.cppmset† ostreamxmapŒ istream­ iostream‹3include/dai/trwbp.h‚5include/dai/treeep.hŠ?include/dai/regiongraph.h~-include/dai/mr.h£-include/dai/mf.h¢-include/dai/lc.h¡ (bñÞÌ·„lV@+îÖ» o]."øãÎÀ²›ƒlR7! òÛ¾§‘qb ?!functional>Cinclude/dai/weightedgraph.h=/include/dai/var.h<1include/dai/util.h;=include/dai/properties.h:1include/dai/prob.h93include/dai/graph.h81include/dai/enum.h7/include/dai/dag.h69include/dai/bipgraph.h57src/weightedgraph.cpp41src/properties.cpp33src/factorgraph.cpp21src/exceptions.cpp 1stdexcept 0exception/-src/exactinf.cpp.-src/evidence.cpp -istream,?include/dai/cobwebgraph.h +cstring,*a/home/jorism/vcs/libdai/include/dai/enum.h)'src/emalg.cpp.(e/home/jorism/vcs/libdai/include/dai/decmap.h'9include/dai/exactinf.h&9include/dai/evidence.h%3include/dai/emalg.h$)src/daialg.cpp#-include/dai/mr.h"-include/dai/mf.h!-include/dai/lc.h /include/dai/hak.h/include/dai/glc.h3include/dai/gibbs.h5include/dai/decmap.h7include/dai/bp_dual.h-include/dai/bp.h'src/trwbp.cpp)src/treeep.cpp !src/mf.cpp N¦öìáÖËÀµ« •Šti^SH=2'þôêàÕʾ²§›ƒwk_SG;/# ÿôêßÔÉ¿µ«¡–‹€uk`VK@5* þóèÝÒǼ±¦{¾*z½*y¼*x»*wº*v£*u¡*t¹*s¸*r·*q¶*pµ*o´*n–*m³*l²*km*j*‹i*lh*±g*°f€'e¯'d'sc'0b'Qa'!`¥$_€$^®$]$!\$­ [‚ª ZŠª Y£ª X¢ª W¡ª V‰ª U ª Tª S§ª R¬ª Qœª P›ª Oƒª NªMª+ Lª‹ Kª«J€I©HQGAF%E!DXCŒBqA¨k@‚ ?Š >£ =¢ <¡ ;‰ :  9 8§ 7¦ 6¥ 5w 4œ 3› 2ƒ 1€ 0¤ / Q.  4ÊQ.ܘmFøΧˆN%þÕ²Q4‚ )classdai_1_1LCdai::LC;‚M9structdai_1_1JTree_1_1Propertiesdai::JTree::Properties ‚/!classdai_1_1JTreedai::JTree ‚/!classdai_1_1Statedai::State&‚5'classdai_1_1multifordai::multifor$‚3%classdai_1_1Permutedai::Permute&‚5'classdai_1_1IndexFordai::IndexFor7‚I5structdai_1_1HAK_1_1Propertiesdai::HAK::Properties‚+classdai_1_1HAKdai::HAK$‚3%classdai_1_1GraphALdai::GraphAL'7'structdai_1_1Neighbordai::Neighbor~+classdai_1_1FBPdai::FBP,};-classdai_1_1FactorGraphdai::FactorGraph$|3%classdai_1_1TFactordai::TFactor({7)classdai_1_1Exceptiondai::ExceptionAzS?structdai_1_1ExactInf_1_1Propertiesdai::ExactInf::Properties&y5'classdai_1_1ExactInfdai::ExactInf&x5'classdai_1_1Evidencedai::Evidence w/!classdai_1_1EMAlgdai::EMAlg6vE7classdai_1_1MaximizationStepdai::MaximizationStep6uE7classdai_1_1SharedParametersdai::SharedParameters:tI;classdai_1_1CondProbEstimationdai::CondProbEstimation *ºK:&í×Á©+l[µJ;(—èÈ|òã˲ž‹éÕpoÊaVºûaJ?!sys/time.hû stackê)src/varset.cppß%src/util.cppÞ/tr1/unordered_mapÝ)src/decmap.cpp’)src/daialg.cpp¤#src/dag.cpp-src/createfg.cpp typeinfoÕ sstreamÓ7src/matlab/matlab.cppÐ=src/matlab/dai_jtree.cppÍ'src/graph.cppÊAsrc/matlab/dai_writefg.cppÇ?src/matlab/dai_readfg.cppÆ#Isrc/matlab/dai_potstrength.cppÂ)src/factor.cppÁ vectorq utilityr stringlstdexcept±7src/weightedgraph.cppµ'src/trwbp.cppš)src/treeep.cpp™3src/regiongraph.cppˆ1src/properties.cpp´!src/mr.cppv!src/mf.cpp˜1src/matlab/dai.cppp!src/lc.cppo'src/jtree.cpp—!src/io.cppn#src/hak.cpp–#src/glc.cpp•'src/gibbs.cpp”#src/fbp.cpp“3src/factorgraph.cpp³1src/exceptions.cpp²-src/exactinf.cpp¯-src/evidence.cpp®'src/emalg.cpp© [Ì—c.ùÄ[4knamespacedai_1aeb056b768d73d02c5796c4012f4170c7Ã3knamespacedai_1ae7d0472fdc89a8635825d01940e91cbf4knamespacedai_1ae0d0ef753bd0ba57586e556ab63126774knamespacedai_1acc877a85f4f4dbb6a0d58c434bb2b996Â4knamespacedai_1acc277bd4f0edae875fca22f063a37220ó3knamespacedai_1acbc670414e04eecf5c284e42d9d036e3a4knamespacedai_1aa2735a823696443089d2de23e8ee6ecb3knamespacedai_1a90f06137ef74bb483e30ee2c7e31b2c8 ”Ë–pJﺔ#ƒOa3b7a4334ac70694ea16160c0067b92e52ƒmexceptions_8h_1af50adc4fad1e07093579e746302bc884#ƒOab0d3e811b3335ac42245ec03864ede452ƒmexceptions_8h_1a29c0e906e26c7484c268d111c71f79da#ƒOaf50adc4fad1e07093579e746302bc884#ƒOa29c0e906e26c7484c268d111c71f79da2ƒmexceptions_8h_1ad7aa0cb04517a5423a6456097c076d082ƒmexceptions_8h_1a922d2784284e8f6ee4009c3d92ba48b6 Y»öìâØÎĺ°¦œ’ˆ~tj`VLC9/%ýóéßÕËÁ·­£™†}tkbYPG>5,#ÿöíäÛÒÉÀ·®¥œ“Šxof]TKB90' úñèßÖÍÄ»‹ ÿ‹ ÿ‹ ÿ ‹ ÿ‹ÿ‹ÿ ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿŠÿŠ~ÿŠ}ÿŠ|ÿŠ{ÿŠzÿŠyÿŠxÿŠwÿŠvÿŠuÿŠtÿŠsÿŠrÿŠqÿŠpÿ Šoÿ Šnÿ Šmÿ Šlÿ Škÿ Šjÿ ŠiÿŠhÿŠgÿ ŠfÿŠeÿŠdÿ Šcÿ Šbÿ Šaÿ Š`ÿŠ_ÿŠ^ÿŠ]ÿŠ\ÿŠ[ÿŠZ ŠY ŠXÿŠWÿÑŠVÿŠUÿÑŠTÿŠSÿÑŠRÿŠQÿÑŠPÿŠOÿÑŠNÿŠMÿÑŠLÿŠKÿÑŠJÿŠIÿÑŠHÿŠGÿçŠFÿŠEÿŠDÿŠCÿÑŠBÿŠAÿÑŠ@ÿŠ?ÿŠ>ÿŠ=ÿŠ<ÿŠ;ÿ™Š:ÿœŠ9ÿ]Š8ÿœŠ7ÿ Š6ÿ Š5ÿ Š4ÿ P±õêßÕËÁ·¬¡–‹vk`UKA7,! õêßÕÊ¿´©ž“ˆ}sh]SI?5+! öëàÕËÁ·­£™ŽƒxmcXMC9/%ûñçÜÒǼ±‚KÌX‚JË@‚I¥@‚H@`‚G@Œ‚F@y‚E@q‚D€;‚C–;‚B;Q‚A;s‚@;7‚?;!‚>;l‚=;k‚<¾8‚;£8‚:}8‚9·8‚8¶8‚7Ê8‚68‚58V‚48+‚38?‚28y‚18q‚08x‚/Ék‚.uÈ‚-tÈ‚,Èk‚+€2‚*“2‚)2‚(2s‚'2Q‚&20‚%2!‚$2l‚#2k‚"‚/‚!Š/‚ ~/‚£/‚¢/‚¡/‚‰/‚/‚§/‚Ž/‚¬/‚|/‚œ/‚›/‚ƒ/‚Ç/‚Æ/‚ˆ/‚³/‚/‚/X‚ /9‚ / ‚ /Œ‚ /‹‚ ÅW‚ÄW‚}W‚¥W‚ÃW‚ÂW‚ÁW‚W?‚WA‚W`W5~WÀ}W¿|W‹ %köãÀ¥pR3Õê}`(çÛϽ°•|q[=2&ÿìÔɽšk,daboost/graph/prim_minimum_spanning_tree.hpp cIboost/graph/adjacency_list.hpp bclimitsalimits`3include/dai/index.h_)src/varset.cpp^%src/util.cpp]/tr1/unordered_map \gmpxx.h[cerrnoZ?boost/functional/hash.hppY/boost/foreach.hppXmath.hW5include/dai/varset.hV9boost/lexical_cast.hpp UtypeinfoT'boost/any.hpp Ssstream RnumericQ=boost/dynamic_bitset.hppP7src/matlab/matlab.cppOmex.h5Ns/home/jorism/vcs/libdai/include/dai/matlab/matlab.hM=src/matlab/dai_jtree.cpp*L]/home/jorism/vcs/libdai/include/dai/io.hK5include/dai/factor.hJ'src/graph.cpp+I_/home/jorism/vcs/libdai/include/dai/glc.h-Hc/home/jorism/vcs/libdai/include/dai/gibbs.hGAsrc/matlab/dai_writefg.cppF?src/matlab/dai_readfg.cppECinclude/dai/matlab/matlab.hD-include/dai/io.hC9include/dai/createfg.h BIsrc/matlab/dai_potstrength.cppA)src/factor.cpp@cmath Q®õéÞÔÊÀ¶¬¢˜Ž„zpe[PF;0%ýóéßÕʾ³¨œ„xlbXND:0%üòèÞÔÊÀµ« •‹wlaWMB7,! öìâ×Íù®ƒPƒuPƒPƒmPƒPÖƒP?ƒP+ƒPÕƒPqƒPŒƒPÔƒPÓƒP‹ƒË ƒƒ ƒ  +ƒ  ?ƒ  ¿ƒ  Òƒ  yƒ xƒ qƒ Àƒ€KƒvKƒKуK9ƒK+ƒKQ‚Ks‚~K!‚}K0‚|Kl‚{Kq‚zKk‚y€H‚x˜H‚wHQ‚vH0‚uH!‚tHs‚sHl‚rHk ‚qÐÎ ‚pÇÎ ‚oÆÎ ‚nÂÎ ‚mÍ΂lp΂kÎX ‚j ÎÏ‚i€E‚hoE‚gE+‚fEQ‚eE0‚dEs‚cE!‚bEl‚aEk‚`ŠB‚_€B‚^ÍB‚]pB‚\™B‚[vB‚Z—B‚YBQ‚XBs‚WB#‚VB‚UB0‚TB7‚SB`‚RB!‚QBl‚PBq‚OBk‚NnÌ ‚MÌŒ‚LÌq :È«sVùÒ«„[4 Þ­ˆU.౎_:"‚ 1#classdai_1_1Regiondai::Region,‚;-classdai_1_1PropertySetdai::PropertySet ‚/!classdai_1_1TProbdai::TProb,‚=+structdai_1_1fo__absdiffdai::fo_absdiff$‚5#structdai_1_1fo__mindai::fo_min$‚5#structdai_1_1fo__maxdai::fo_max$‚5#structdai_1_1fo__powdai::fo_pow0‚A/structdai_1_1fo__Hellingerdai::fo_Hellinger"‚3!structdai_1_1fo__KLdai::fo_KL.‚?-structdai_1_1fo__divides0dai::fo_divides0*‚;)structdai_1_1fo__plog0pdai::fo_plog0p&‚7%structdai_1_1fo__inv0dai::fo_inv0$‚5#structdai_1_1fo__invdai::fo_inv&‚7%structdai_1_1fo__log0dai::fo_log0$‚5#structdai_1_1fo__logdai::fo_log$‚5#structdai_1_1fo__expdai::fo_exp$‚5#structdai_1_1fo__absdai::fo_abs"‚3!structdai_1_1fo__iddai::fo_id5‚G3structdai_1_1MR_1_1Propertiesdai::MR::Properties‚ )classdai_1_1MRdai::MR5‚ G3structdai_1_1MF_1_1Propertiesdai::MF::Properties‚ )classdai_1_1MFdai::MF5‚ G3structdai_1_1LC_1_1Propertiesdai::LC::Properties ë)¦ õòÑârbÃREª8+ñÞͽ® wh[Û1A*øÝǨ‰¿rX>¦/include/da3include/dai/emalg.h¥9include/dai/createfg.hÃ!functional¿€ /dai/factorgraph.h0%dai/factor.hX-dai/exceptions.h+ gmpxx.hÜ5include/dai/decmap.h5include/dai/daialg.hŽ/include/dai/dag.h·?include/dai/cobwebgraph.h¬Ainclude/dai/clustergraph.h|/include/dai/cbp.hw7include/dai/bp_dual.hœ-include/dai/bp.h›9include/dai/bipgraph.h¶/include/dai/bbp.hƒ5include/dai/alldai.h€ fstream„exception°3dai/weightedgraph.h#%dai/varset.h` dai/var.h^!dai/util.h?#dai/trwbp.h[%dai/treeep.hO)dai/smallset.hV/dai/regiongraph.h7-dai/properties.hQ!dai/prob.h5 dai/mr.hL dai/mf.hI dai/lc.hF#dai/jtree.hC#dai/index.hA dai/hak.h<*3dai/matlab/matlab.hó dai/io.hñ#dai/gibbs.hç#dai/graph.h9 dai/fbp.h3 P°õêßÔɾ³¨’‡|qf[QG=2'üòçÜÑÆ»°¥š„yncXND:0&þôêàÕÊÀ¶¬¢˜Ž„yndZOD9.#øîãÙÏÅ»°ƒl>ƒku>ƒj{>ƒi>ƒht>ƒg>݃f>+ƒe>܃d>Ûƒc>yƒb>Öƒa>Úƒ`>Ùƒ_>‹ƒ^>Œƒ]>†ƒ\>qƒ[>lƒZ€ZƒYšZƒXZƒWZsƒVZQƒUZ0ƒTZ!ƒSZlƒRZkƒQ€NƒP™NƒONsƒNNQƒMNCƒLN#ƒKNƒJN0ƒIN7ƒHN`ƒGN!ƒFNlƒENqƒDNkƒC.؃B.‹ƒA.Õƒ@-؃?-‹ƒ>,‹ƒ=‹ƒ<×Uƒ;¹Uƒ:·Uƒ9¬Uƒ8¶Uƒ7UÓƒ6U‹ƒ5Uyƒ4Uqƒ3Š6ƒ2‰6ƒ1 6ƒ0Ž6ƒ/ˆ6ƒ.6#ƒ-60ƒ,6 ƒ+6‹ƒ*‚Pƒ)ŠPƒ(£Pƒ'¢Pƒ&¡Pƒ%‰Pƒ$ Pƒ#Pƒ"§Pƒ!¥Pƒ ŽPƒ›Pƒ€Pƒ´P NÙªX5÷Ô±wT1÷Ò’L)ÿ໘uN$‚93%classdai_1_1GraphELdai::GraphEL ‚8/!classdai_1_1UEdgedai::UEdge ‚7/!classdai_1_1DEdgedai::DEdge"‚61#classdai_1_1VarSetdai::VarSet‚5+classdai_1_1Vardai::Var'‚47'classdai_1_1hash__mapdai::hash_map ‚3/!classdai_1_1TRWBPdai::TRWBPC‚2SAclassdai_1_1TreeEP_1_1TreeEPSubTreedai::TreeEP::TreeEPSubTree=‚1O;structdai_1_1TreeEP_1_1Propertiesdai::TreeEP::Properties"‚01#classdai_1_1TreeEPdai::TreeEP‚/#classFactorFactor‚.+!classStateDenseStateDense ‚--#classStateSparseStateSparse ‚,-#classStateFactorStateFactor‚+#classFactorFactor‚*+!classStateDenseStateDense ‚)-#classStateSparseStateSparse ‚(-#classStateFactorStateFactor‚'#classFactorFactor"‚&/%classSparseFactorSparseFactor ‚%-#classDenseFactorDenseFactor&‚$3)classAbstractFactorAbstractFactor&‚#5'classdai_1_1SmallSetdai::SmallSet,‚";-classdai_1_1RegionGraphdai::RegionGraph$‚!3%classdai_1_1FRegiondai::FRegion Q«õêßÔÊ¿µªŸ”‰~sh]RG<1&üòèÞÔɾ´©ž“ˆ~sh]RG<1&ýòçÜÒǾ´ª¡˜Ž„zoe[QG<1&ýóéÞÓÉ¿µ«„= „<?„;„:y„9Ó„8‹„7k„6Q„5?„4„3y„2†„1Œ„0Ó„/‹„.k„- „, „+?„*ç„)„(„'k„& +„% Q„$ æ„# „„" l„!Š"„ ~"„‰"„¬"„µ"„"„"9„"+„"?„"å„"ä„"ã„"â„"á„"†„"‹„"Œ„"q„Š_„‰_„ à_„ Ë_„ |_„ ß_„ ‡_„_V„_?„_^„_x„_Œ„_q„×]„]+„]Óƒ]‹ƒ~¾>ƒ}×>ƒ|»>ƒ{º>ƒz¹>ƒyË>ƒx·>ƒw¶>ƒvµ>ƒuÞ>ƒt™>ƒsv>ƒr˜>ƒqo>ƒp–>ƒo³>ƒn®>ƒm©> YÒÁ±¤‘‡\P!ëö‡o:ÿÉ’‡}hY {!sys/time.hz-boost/random.hppyctimexcstdio4wq/home/jorism/vcs/libdai/src/matlab/dai_writefg.cpp3vo/home/jorism/vcs/libdai/src/matlab/dai_readfg.cpp8uy/home/jorism/vcs/libdai/src/matlab/dai_potstrength.cpp2tm/home/jorism/vcs/libdai/src/matlab/dai_jtree.cpps3dai/matlab/matlab.h,ra/home/jorism/vcs/libdai/src/matlab/dai.cpp qdai/io.h%pS/home/jorism/vcs/libdai/src/glc.cpp'oW/home/jorism/vcs/libdai/src/gibbs.cpp niomanip,ma/home/jorism/vcs/libdai/src/exceptions.cpp lcstdlib(kY/home/jorism/vcs/libdai/src/decmap.cppjstacki)dai/createfg.h hiterator g#dai/gibbs.hf%dai/alldai.h+e_boost/graph/kruskal_min_spanning_tree.hpp ZÍ h­e ÒƒOÖ™Z<‚GO 9structdai_1_1BP__dual_1_1messagesdai::BP_dual::messages:‚FM 7structdai_1_1BP__dual_1_1beliefsdai::BP_dual::beliefs>‚ES 9structdai_1_1BP__dual_1_1__edges__tdai::BP_dual::_edges_t5‚DG3structdai_1_1BP_1_1Propertiesdai::BP::Properties1‚CC /structdai_1_1BP_1_1EdgePropdai::BP::EdgePropL‚B]Istructdai_1_1BipartiteGraph_1_1levelTypedai::BipartiteGraph::levelType7‚AI5structdai_1_1BBP_1_1Propertiesdai::BBP::PropertiesV‚@iSclassstd_1_1basic__string_1_1reverse__iteratorstd::basic_string::reverse_iteratorE‚?WCclassstd_1_1basic__string_1_1iteratorstd::basic_string::iteratorc‚>w_classstd_1_1basic__string_1_1const__reverse__iteratorstd::basic_string::const_reverse_iteratorR‚=eOclassstd_1_1basic__string_1_1const__iteratorstd::basic_string::const_iterator5‚<E5classdai_1_1__builtinInfAlgsdai::_builtinInfAlgs*‚;9+classdai_1_1RootedTreedai::RootedTree0‚:?1classdai_1_1WeightedGraphdai::WeightedGraph Q±öëàÕÊÀ¶¬¡—ƒxncYOE;0%úðæÜÒȾ´©Ÿ•Š€ukaVLA7-" øíâ×ÌÁ¶¬¢—ƒyndZOD:0%üñæÛÑÆ»±…DC… Dê… D‹… Dk… e„… e‹…eæ…eñ…=+…=?…=<…=Œ…=k…:9…ðk„ïk„~43„}4k„|1Ö„{1+„z1?„y10„x1¿„w1y„v1l„u1„„t1†„s1Œ„r1è„q1î„p1‹„odX„ní+„m)Ó„l)(„k&Ö„j&%„i&?„h&ì„g&l„f&Ó„e„d?„cëk„bc!„acê„`cq„_„^bé„]bQ„\bs„[b9„Zb?„Yb#„Xb0„Wby„Vbè„Ubq„Tb„„Sb‹„R†„QŒ„Py„O„N„M`„L‹„Kq„J†„I„H„G„Fç„EQ„D?„Cy„B†„AŒ„@Ó„?‹„>k ,dëÖÁ¬—‚mXC.ïÚÅ°›†q\G2óÞÉ´ŸŠu`K6! ÷â͸£Žyd,%namespacedaidai+%namespacedaidai*%namespacedaidai)%namespacedaidai(%namespacedaidai'%namespacedaidai&%namespacedaidai%%namespacedaidai$%namespacedaidai#%namespacedaidai"%namespacedaidai!%namespacedaidai %namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai %namespacedaidai %namespacedaidai %namespacedaidai %namespacedaidai %namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai ,dëÖÁ¬—‚mXC.ïÚÅ°›†q\G2óÞÉ´ŸŠu`K6! ÷â͸£ŽydX%namespacedaidaiW%namespacedaidaiV%namespacedaidaiU%namespacedaidaiT%namespacedaidaiS%namespacedaidaiR%namespacedaidaiQ%namespacedaidaiP%namespacedaidaiO%namespacedaidaiN%namespacedaidaiM%namespacedaidaiL%namespacedaidaiK%namespacedaidaiJ%namespacedaidaiI%namespacedaidaiH%namespacedaidaiG%namespacedaidaiF%namespacedaidaiE%namespacedaidaiD%namespacedaidaiC%namespacedaidaiB%namespacedaidaiA%namespacedaidai@%namespacedaidai?%namespacedaidai>%namespacedaidai=%namespacedaidai<%namespacedaidai;%namespacedaidai:%namespacedaidai9%namespacedaidai8%namespacedaidai7%namespacedaidai6%namespacedaidai5%namespacedaidai4%namespacedaidai3%namespacedaidai2%namespacedaidai1%namespacedaidai0%namespacedaidai/%namespacedaidai.%namespacedaidai-%namespacedaidai K×öëáÖËÁ·¬ ”ˆ|qfZNB7+üðäÙÍÁµªŸ”Šti^TJ@5* öìâ×Íù®£™…{pe[QG=3) ÿõëá×…YT+…XT?…WT#…VTy…Uf`…Taû…Saú…Ra?…Q\[…P\k…OY?…NYO…MYC…LYq…KY„…JY‹…IYk…HS…GS0…FS7…ESÑ…DSÀ…CSy…BR+…ARQ…@R‹…?M…>M?…=MC…<M…;ML…:Mì…9MÀ…8Mù…7Mø…6Mk…5J?…4JI…3J†…2JŒ…1JÓ…0J‹…/Jk….gó…-g‹…,÷0 …+÷ó …* ÷Ï …)÷‹…(ö0 …'öó …& öÏ …%ö‹…$õX …#õó …" õÏ …!õ‹… ôC … ôÏ …ôó …ô‹…òC…ò …òæ … òÏ …òó …ò‹…Gæ…G?…GF…G†…GŒ…Gy…G‹…Gk (д(šŽvIi\>J<) üåÏ»­˜‡whU-boost/random.hppú ctimeù cstdioø)dai/evidence.h%!dai/enum.hs#dai/emalg.h%dai/daialg.h!-dai/dai_config.hk dai/dag.h)dai/createfg.hé/dai/cobwebgraph.h1dai/clustergraph.h dai/cbp.h'dai/bp_dual.h dai/bp.h)dai/bipgraph.h dai/bbp.h%dai/alldai.hæ cstring« cstdlibì cmathÀ climitsâ cerrnoÛ5boost/shared_ptr.hpp…9boost/lexical_cast.hppÖ/aboost/graph/prim_minimum_spanning_tree.hppä $³^$ë­rÁ€(Ð$[kAMAstd::basic_istream< Char >std::basic_istringstream< Char >classstd_1_1basic__istreamMj9A9 std::basic_ios< Char >std::basic_istream< Char >classstd_1_1basic__iosViACAstd::basic_ostream< Char >std::basic_iostream< Char >classstd_1_1basic__ostreamVhACAstd::basic_istream< Char >std::basic_iostream< Char >classstd_1_1basic__istream?g'97std::ios_basestd::basic_ios< Char >classstd_1_1ios__baseVfACAstd::basic_istream< Char >std::basic_ifstream< Char >classstd_1_1basic__istreamWeCACstd::basic_iostream< Char >std::basic_fstream< Char >classstd_1_1basic__iostream9d)+7std::exceptionstd::bad_typeidclassstd_1_1exception >dai::BP_dual::_edges_t< T >classstd_1_1vectorK_O5+std::map< std::string, InfAlg * >dai::_builtinInfAlgsclassstd_1_1map M³Jé³A Ë‹U×M=y 3C std::basic_ofstreamclassclassstd_1_1basic__ofstreamGx =M std::basic_istringstreamclassclassstd_1_1basic__istringstream;w 1A std::basic_istreamclassclassstd_1_1basic__istream=v 3C std::basic_iostreamclassclassstd_1_1basic__iostream3u )9 std::basic_iosclassclassstd_1_1basic__ios=t 3C std::basic_ifstreamclassclassstd_1_1basic__ifstream;s 1A std::basic_fstreamclassclassstd_1_1basic__fstream5r +; std::bad_typeidclassclassstd_1_1bad__typeid;q 1A std::bad_exceptionclassclassstd_1_1bad__exception1p '7 std::bad_castclassclassstd_1_1bad__cast3o )9 std::bad_allocclassclassstd_1_1bad__alloc1n '7 std::auto_ptrclassclassstd_1_1auto__ptr*m !/ std::arrayclassclassstd_1_1array2l )7 std::allocatorclassclassstd_1_1allocator1k )3 AbstractFactorclassclassAbstractFactorJj 9 S dai::BP_dual::_edges_tstructstructdai_1_1BP__dual_1_1__edges__t+ Å\Å( O+[)   aba84ec4080ec3ed10171ebac195fe998~AbstractFactorvirtual AbstractFactor::~AbstractFactor()AbstractFactor! ( O)I?)  ad0323f84e9cee8227f1ad0d142aa7721AbstractFactorAbstractFactor::AbstractFactor(const AbstractFactor &x)AbstractFactor#+ .¨YüžVÝE ç²p.@yA'1dai::DAIAlg< FactorGraph >dai::ExactInfclassdai_1_1DAIAlg@x-/=std::logic_errorstd::domain_errorclassstd_1_1logic__error3w)#3AbstractFactorDenseFactorclassAbstractFactor$v1GRMdai::DAIAlg< GRM >classGRM6u#11dai::InfAlgdai::DAIAlg< GRM >classdai_1_1InfAlgVt=;Kdai::ParameterEstimationdai::CondProbEstimationclassdai_1_1ParameterEstimation>s--;dai::FactorGraphdai::CobwebGraphclassdai_1_1FactorGraph;rA1dai::DAIAlg< FactorGraph >dai::CBPclassdai_1_1DAIAlg:qA1dai::DAIAlg< FactorGraph >dai::BPclassdai_1_1DAIAlgFp35=BBPCostFunctionBasedai::BBPCostFunctionclassBBPCostFunctionBase\oCKCstd::basic_iostream< Char >std::basic_stringstream< Char >classstd_1_1basic__iostream[nAMAstd::basic_ostream< Char >std::basic_ostringstream< Char >classstd_1_1basic__ostreamMm9A9 std::basic_ios< Char >std::basic_ostream< Char >classstd_1_1basic__iosVlACAstd::basic_ostream< Char >std::basic_ofstream< Char >classstd_1_1basic__ostream TÂx<ôʈJ¾~O'ôÊŽT7‚ -; dai::CobwebGraphclassclassdai_1_1CobwebGraph"9‚ /= dai::ClusterGraphclassclassdai_1_1ClusterGraph"'‚ + dai::CBPclassclassdai_1_1CBP)0‚ %5 dai::BP_dualclassclassdai_1_1BP__dual'%‚ ) dai::BPclassclassdai_1_1BP ?,‚ #1 std::bitsetclassclassstd_1_1bitset=‚ 3A dai::BipartiteGraphclassclassdai_1_1BipartiteGraph -@‚ 5E std::binary_functionclassclassstd_1_1binary__function pF‚ 7 M dai::BP_dual::beliefsstructstructdai_1_1BP__dual_1_1beliefs<;‚ 3= BBPCostFunctionBaseclassclassBBPCostFunctionBase*? 5C dai::BBPCostFunctionclassclassdai_1_1BBPCostFunction*'~ + dai::BBPclassclassdai_1_1BBPCE} ;K std::basic_stringstreamclassclassstd_1_1basic__stringstream9| /? std::basic_stringclassclassstd_1_1basic__stringG{ =M std::basic_ostringstreamclassclassstd_1_1basic__ostringstream;z 1A std::basic_ostreamclassclassstd_1_1basic__ostream \Ã÷îåÜÓÊÁ¸¯¦”‹‚ypg^ULC:1( ûòéà×Îż³ª¡˜†}tkbYPG>5,#ÿöíäÛÒÉÀ·®¥œ“Šxof]TKB90' úñèßÖÍËhÿ‹gÿ;‹fÿ8‹eÿ;‹dÿ:‹cÿ8‹bÿ:‹aÿ8‹`ÿ:‹_ÿ8‹^ÿ:‹]ÿ8‹\ÿ:‹[ÿ8‹Zÿ:‹Yÿ8‹Xÿ:‹Wÿ-‹Vÿ8‹Uÿ:‹Tÿ5‹Sÿ4‹Rÿ3‹Qÿ5‹Pÿ4‹Oÿ3‹Nÿ-‹Mÿ,‹Lÿ+‹Kÿ*‹Jÿ)‹Iÿ0‹Hÿ0‹Gÿ.‹Fÿ.‹Eÿ1‹Dÿ0‹Cÿ1‹Bÿ0‹Aÿ/‹@ÿ.‹?ÿ/‹>ÿ.‹=ÿ-‹<ÿ,‹;ÿ+‹:ÿ*‹9ÿ)‹8ÿ'‹7ÿ&‹6ÿ$‹5ÿ‹4ÿ%‹3ÿ$‹2ÿ#‹1ÿ‹0ÿ"‹/ÿ!‹.ÿ ‹-ÿ‹,ÿ‹+ÿ‹*ÿ‹)ÿ‹(ÿ‹'ÿ‹&ÿ‹%ÿ‹$ÿ‹#ÿ ‹"ÿ ‹!ÿ‹ ÿ‹ÿ ‹ÿ ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ÿ‹ ÿ \Â÷îåÜÓÊÁ¸¯¦”‹‚xof]TKB90' úñèßÖÍÄ»²© —Ž…|sjaXOF=4+"þõìãÚÑÈ¿¶­¤›’‰€wne\SJA8/& øïæÝÔËÂŒDÿMŒCÿLŒBÿKŒAÿJŒ@ÿIŒ?ÿHŒ>ÿŒ=ÿŒ<ÿŒ;ÿŒ:ÿBŒ9ÿ Œ8ÿŒ7ÿBŒ6ÿAŒ5ÿŒ4ÿŒ3ÿ Œ2ÿŒ1ÿ Œ0ÿŒ/ÿŒ.ÿŒ-ÿŒ,ÿŒ+ÿŒ*ÿŒ)ÿŒ(ÿŒ'ÿŒ&ÿŒ%ÿŒ$ÿŒ#ÿŒ"ÿŒ!ÿŒ ÿŒÿŒÿ ŒÿŒÿŒÿŒÿŒÿŒÿFŒÿ ŒÿFŒÿŒÿŒÿŒÿEŒÿŒÿŒÿŒÿŒ ÿŒ ÿŒ ÿŒ ÿDŒ ÿ ŒÿŒÿŒÿŒÿŒÿŒÿŒÿŒÿŒÿ‹ÿ‹~ÿ‹}ÿ‹|ÿ‹{ÿ‹zÿ‹yÿ‹xÿ‹wÿ‹vÿB‹uÿ ‹tÿ‹sÿB‹rÿA‹qÿ‹pÿ‹oÿ@‹nÿ@‹mÿ‹lÿ‹kÿ>‹jÿ=‹iÿ= DÆ|6ߦ\Ã]¼‚D;‚TM9classstd_1_1ios__base_1_1failurestd::ios_base::failure7‚SI5structdai_1_1HAK_1_1Propertiesdai::HAK::PropertiesV‚RiSclassstd_1_1forward__list_1_1reverse__iteratorstd::forward_list::reverse_iteratorE‚QWCclassstd_1_1forward__list_1_1iteratorstd::forward_list::iteratorc‚Pw_classstd_1_1forward__list_1_1const__reverse__iteratorstd::forward_list::const_reverse_iteratorR‚OeOclassstd_1_1forward__list_1_1const__iteratorstd::forward_list::const_iteratorA‚NS?structdai_1_1ExactInf_1_1Propertiesdai::ExactInf::PropertiesG‚MYEclassstd_1_1deque_1_1reverse__iteratorstd::deque::reverse_iterator6‚LG5classstd_1_1deque_1_1iteratorstd::deque::iteratorT‚KgQclassstd_1_1deque_1_1const__reverse__iteratorstd::deque::const_reverse_iteratorC‚JUAclassstd_1_1deque_1_1const__iteratorstd::deque::const_iteratorG‚IYEstructdai_1_1CobwebGraph_1_1Connectiondai::CobwebGraph::Connection7‚HI5structdai_1_1CBP_1_1Propertiesdai::CBP::Properties =ˆòäÖȺ¬ž€qbSD5&ùêÛÍ¿±£”…whYJ;-ñâÓĶ¨š‹|m^O@1"øêÜÎÀ²¤–ˆ „R ^'S „Q ]"'O „P \"'F „O [ 'E „N Z'C „M Z'C „L Y': „K Y': „J X $L „I W$4 „H UV$, „G TQž „F S„ „E R{ „D RP{ „C Or „B OQr „A Or „@ OPr „? NL"> „> ML"9 „= KL"6 „< J" ÿ „; I" ú „: HG „9 FG „8 E… „7 D• „6 C‘ „5 Bz „4 A= „3 @= „2 >?ô „1 <=à „0 ;h „/ 9:Ð „. 8"— „- 7"` „, 6 [ „+ 5: „* 4"4 „) 3ù „( 3 ù „' 3ù „& 3ù „% 2æ „$ 20æ „# 1Ú „" 1Ú „! /0Ï „  /Ï „ /Ï „ /Ï „ /Ï „ .H „ .H „ -^ „ ,"Y „ +"S „ * R „ )P <채L컎mY8 ö»§oSóÄ¥f<'„2 =const std::vector< S > &vTtrue„1 )typename binOpg!„0 )typename binOpxTNORMPROB„/ #BigIntlinearStateT0,„. Aconst std::vector< Var > &varOrderK&„- Aconst std::set< size_t > &cl04„, Qconst std::map< size_t, Factor > &facsfalse„+ )const VarSet &xT„* #RecurseTypeoptsTfalse„) size_titerK„( size_tvs8„' O'std::vector< SharedParameters > &maximizationsT„& size_tvs0*„% 7std::vector< size_t >facIndsfalse„$ )size_tIboost::hash„# size_tvs„" +const GraphAL &xTtrue*„! 7std::vector< size_t >facIndsfalse.„ Gconst std::vector< size_t > &xIsfalse.„ Gconst std::vector< size_t > &xisfalse,„ Aconst std::set< size_t > &facsfalse5„ Qconst std::map< size_t, Factor > &facsTfalse*„ 7std::vector< size_t >facIndsfalse8„ Sstd::vector< SmallSet< size_t > > ®ionsfalse„ size_tvs \Ã÷îåÜÓÊÁ¸¯¦”‹‚ypg^ULC:1( ûòéà×Îż³ª¡˜†}tkbYPG>5,#ÿöíäÛÒÉÀ·®¥œ“Šwne\SJA8/& ùðçÞÕÌà ÿvÿuÿvÿuÿuÿuÿtÿuÿtÿuÿ-ÿ,ÿ+ÿrÿrÿqÿpÿ ÿo ÿn ÿ ÿc ÿb ÿlÿkÿjÿiÿhÿgÿfÿfÿeÿdŒÿdŒ~ÿcŒ}ÿbŒ|ÿaŒ{ÿŒzÿ_Œyÿ_ŒxÿŒwÿ_ŒvÿŒuÿ_Œtÿ_Œsÿ_Œrÿ_Œqÿ_Œpÿ_Œoÿ_Œnÿ`Œmÿ_Œlÿ`Œkÿ_Œjÿ_Œiÿ_Œhÿ_Œgÿ_ŒfÿŒeÿ^Œdÿ]Œcÿ[Œbÿ=ŒaÿŒ`ÿŒ_ÿZŒ^ÿ Œ]ÿ0Œ\ÿ.Œ[ÿŒZÿŒYÿZŒXÿYŒWÿ ŒVÿŒUÿXŒTÿŒSÿWŒRÿRŒQÿŒPÿ"ŒOÿVŒNÿUŒMÿTŒLÿSŒKÿRŒJÿQŒIÿŒHÿPŒGÿHŒFÿOŒEÿN kχ1ã„8×x"·kI‚ =Q std::set::const_iteratorclassclassstd_1_1set_1_1const__iteratorh‚ [q std::unordered_multimap::const_iteratorclassclassstd_1_1unordered__multimap_1_1const__iteratorS‚ G[ std::multimap::const_iteratorclassclassstd_1_1multimap_1_1const__iterator\‚ Oe std::basic_string::const_iteratorclassclassstd_1_1basic__string_1_1const__iterator^‚ Qg std::unordered_map::const_iteratorclassclassstd_1_1unordered__map_1_1const__iteratorI‚ =Q std::map::const_iteratorclassclassstd_1_1map_1_1const__iterator\‚ Oe std::forward_list::const_iteratorclassclassstd_1_1forward__list_1_1const__iteratorK‚ ?S std::list::const_iteratorclassclassstd_1_1list_1_1const__iteratorS‚ EY dai::CobwebGraph::Connectionstructstructdai_1_1CobwebGraph_1_1Connection%E‚ ;I dai::CondProbEstimationclassclassdai_1_1CondProbEstimationh.‚ %3 std::complexclassclassstd_1_1complex j®Mù£8æ–7ÇjZ‚ Mc std::map::const_reverse_iteratorclassclassstd_1_1map_1_1const__reverse__iteratorm‚ _w std::forward_list::const_reverse_iteratorclassclassstd_1_1forward__list_1_1const__reverse__iterator\‚ Oe std::list::const_reverse_iteratorclassclassstd_1_1list_1_1const__reverse__iteratorM‚ AU std::deque::const_iteratorclassclassstd_1_1deque_1_1const__iteratorO‚ CW std::vector::const_iteratorclassclassstd_1_1vector_1_1const__iteratorh‚ [q std::unordered_multiset::const_iteratorclassclassstd_1_1unordered__multiset_1_1const__iteratorS‚ G[ std::multiset::const_iteratorclassclassstd_1_1multiset_1_1const__iteratorQ‚ EY std::wstring::const_iteratorclassclassstd_1_1wstring_1_1const__iterator^‚ Qg std::unordered_set::const_iteratorclassclassstd_1_1unordered__set_1_1const__iteratorO‚ CW std::string::const_iteratorclassclassstd_1_1string_1_1const__iterator <Ž'·:Ýz¡<b‚' Uk std::wstring::const_reverse_iteratorclassclassstd_1_1wstring_1_1const__reverse__iteratord‚& Wm std::multiset::const_reverse_iteratorclassclassstd_1_1multiset_1_1const__reverse__iteratoro‚% ay std::unordered_set::const_reverse_iteratorclassclassstd_1_1unordered__set_1_1const__reverse__iterator`‚$ Si std::string::const_reverse_iteratorclassclassstd_1_1string_1_1const__reverse__iteratorZ‚# Mc std::set::const_reverse_iteratorclassclassstd_1_1set_1_1const__reverse__iteratorz‚" k std::unordered_multimap::const_reverse_iteratorclassclassstd_1_1unordered__multimap_1_1const__reverse__iteratorm‚! _w std::basic_string::const_reverse_iteratorclassclassstd_1_1basic__string_1_1const__reverse__iteratord‚ Wm std::multimap::const_reverse_iteratorclassclassstd_1_1multimap_1_1const__reverse__iteratoro‚ ay std::unordered_map::const_reverse_iteratorclassclassstd_1_1unordered__map_1_1const__reverse__iterator Bƒ ¿•d6ÛŸ_0ð¸vB1‚6 '5 dai::Evidenceclassclassdai_1_1Evidence$?‚5 5E std::error_conditionclassclassstd_1_1error__condition5‚4 +; std::error_codeclassclassstd_1_1error__code=‚3 3C std::error_categoryclassclassstd_1_1error__category,‚2 !/ dai::EMAlgclassclassdai_1_1EMAlgK=‚1 / C dai::BP::EdgePropstructstructdai_1_1BP_1_1EdgeProp D9‚0 /? std::domain_errorclassclassstd_1_1domain__error*‚/ !/ std::dequeclassclassstd_1_1deque+‚. #- DenseFactorclassclassDenseFactor+‚- !/ dai::DEdgeclassclassdai_1_1DEdge"'.‚, #1 dai::DAIAlgclassclassdai_1_1DAIAlg Ï'‚+ + dai::DAGclassclassdai_1_1DAG)^‚* Qg std::deque::const_reverse_iteratorclassclassstd_1_1deque_1_1const__reverse__iterator`‚) Si std::vector::const_reverse_iteratorclassclassstd_1_1vector_1_1const__reverse__iteratorz‚( k std::unordered_multiset::const_reverse_iteratorclassclassstd_1_1unordered__multiset_1_1const__reverse__iterator YÁ÷îåÜÓÊÁ¸¯¦”‹‚ypg^TKB90' úñèßÖÍÄ»²© –Œƒzqh^TJ@7-$üòèÞÕËÁ·­£™‡~ulcZQH?6,#ýóéßÕËÁyÿ™xÿ˜wÿ—vÿ–uÿ•tÿ”sÿ“rÿ’qÿdpÿdoÿdnÿ‘mÿBlÿkÿBjÿ iÿhÿBgÿAfÿeÿdÿcÿbÿaÿŽ`ÿ_ÿŽ^ÿ]ÿŒ\ÿq[ÿ‹Zÿ‡YÿŠXÿ‰WÿˆVÿ‡UÿŠTÿSÿ…Rÿ=Qÿ„Pÿ„OÿƒNÿ‚MÿBLÿ KÿBJÿ IÿHÿGÿFÿEÿDÿ~CÿBÿ}Aÿ{@ÿ=?ÿ=>ÿz=ÿ8<ÿ:;ÿy:ÿu9ÿy8ÿu7ÿu6ÿu5ÿx4ÿu3ÿ¿2ÿu1ÿ80ÿ:/ÿ8.ÿ:-ÿu,ÿ-+ÿ8*ÿ:)ÿ5(ÿ4'ÿ3&ÿ-%ÿ,$ÿ+#ÿr"ÿu!ÿu @Ì–a=»‘^"å²rAÙ¨u@2‚H %7 dai::fo_log0structstructdai_1_1fo__log0 F0‚G #5 dai::fo_logstructstructdai_1_1fo__log =.‚F !3 dai::fo_KLstructstructdai_1_1fo__KL |2‚E %7 dai::fo_inv0structstructdai_1_1fo__inv0 [0‚D #5 dai::fo_invstructstructdai_1_1fo__inv R.‚C !3 dai::fo_idstructstructdai_1_1fo__id =‚B /A dai::fo_Hellingerstructstructdai_1_1fo__Hellinger ˆ0‚A #5 dai::fo_expstructstructdai_1_1fo__exp 4:‚@ -? dai::fo_divides0structstructdai_1_1fo__divides0 p9‚? += dai::fo_absdiffstructstructdai_1_1fo__absdiff °0‚> #5 dai::fo_absstructstructdai_1_1fo__abs ('‚= + dai::FBPclassclassdai_1_1FBP2;E‚< 9M std::ios_base::failureclassclassstd_1_1ios__base_1_1failure7‚; -; dai::FactorGraphclassclassdai_1_1FactorGraph/A!‚: # FactorclassclassFactor,2‚9 )7 std::exceptionclassclassstd_1_1exception3‚8 )7 dai::Exceptionclassclassdai_1_1Exception*O1‚7 '5 dai::ExactInfclassclassdai_1_1ExactInf' <ƒòãÔŶ§˜Š{m^O@1"õæ×Ⱥ¬ž‚tfXJ;,ÿñãÔÆ·¨™Š{k[K;+ þïàѲ¢’ƒ … ŽBv …   º …  Œ" ± …  ‹" ¬ …  Š" b …  ‰ [ … ˆ" Q … ‡ 1 … ‡ 1 … †"@C … †"@C … …";  … … ;  … …";  … …";  „ …;  „~ „;} „} ƒ";x „| ‚";t „{ ;r „z ;r „y ;k „x €;k „w ~;h „v ~;h „u }:0 „t {|+ „s zx"‹ „r yx8. „q wx8 „p v6: „o v06: „n u2s „m t2f „l s2a „k r2S „j r2S „i q2J „h q2J „g p/h „f o/b „e n"/% „d m"/" „c l0/ „b k0/ý „a j"/Æ „` i"/¾ „_ h"/¨ „^ g"/ „] f /’ „\ e0/S „[ dc*Œ „Z bc*m „Y `*Ÿ „X `P*Ÿ „W `*Ÿ „V `a*Ÿ „U `a*Ÿ „T `a*Ÿ „S _"'] f½{U®Uª[ ºfQK+Estd::binary_function< T, T, T >dai::fo_KL< T >classstd_1_1binary__functionNC/Cstd::unary_function< T, T >dai::fo_inv0< T >classstd_1_1unary__functionMC-Cstd::unary_function< T, T >dai::fo_inv< T >classstd_1_1unary__functionLC+Cstd::unary_function< T, T >dai::fo_id< T >classstd_1_1unary__functionXK9Estd::binary_function< T, T, T >dai::fo_Hellinger< T >classstd_1_1binary__functionMC-Cstd::unary_function< T, T >dai::fo_exp< T >classstd_1_1unary__functionWK7Estd::binary_function< T, T, T >dai::fo_divides0< T >classstd_1_1binary__functionV~K5Estd::binary_function< T, T, T >dai::fo_absdiff< T >classstd_1_1binary__functionM}C-Cstd::unary_function< T, T >dai::fo_abs< T >classstd_1_1unary__function$|)dai::BPdai::FBPclassdai_1_1BP@{)97std::exceptionstd::ios_base::failureclassstd_1_1exceptionAz1)Astd::runtime_errordai::Exceptionclassstd_1_1runtime__error YºöìâØÎĺ°¦œ’ˆ~tjaXOF=4+"ûòéà×Îż³© –ƒzqh^TJA8/& øîåÜÓÉ¿¶­¤›‘ˆukaXOF=4+!üóêáØÎĺŽRÿ¶ŽQÿ´ŽPÿ´ŽOÿFŽNÿ ŽMÿŽLÿŽKÿŽJÿDŽIÿ ŽHÿ²ŽGÿ±ŽFÿ ŽEÿ ŽDÿŽCÿŽBÿŽAÿŽ@ÿ°Ž?ÿŽ>ÿŽŽ=ÿŽ<ÿ=Ž;ÿ,Ž:ÿ=Ž9ÿeŽ8ÿdŽ7ÿdŽ6ÿŽ5ÿ!Ž4ÿŽ3ÿŽ2ÿŽ1ÿ Ž0ÿ Ž/ÿŽ.ÿŽ-ÿŽ,ÿŽ+ÿ~Ž*ÿŽ)ÿ~Ž(ÿŽ'ÿ¦Ž&ÿ¦Ž%ÿŽ$ÿ Ž#ÿ Ž"ÿŽ!ÿŽ ÿŽÿ©Žÿ Žÿ¨Žÿ Žÿ ŽÿŽÿŽÿBŽÿŽÿBŽÿŽÿ§Žÿ¦Žÿ¦ŽÿYŽÿ Žÿ ŽÿŽ ÿŽ ÿ Ž ÿŽ ÿ Ž ÿŽÿ¥Žÿ¤Žÿ£Žÿ¢Žÿ¡Žÿ ŽÿŽÿ™Žÿœÿ™~ÿ›}ÿ›|ÿ›{ÿ˜zÿ— XºöìâØÎĺ°¦œ’ˆ~tj`VLB8.% øîåÛÒÉÀ·®¥œ“Šxof]TKB90' ÷íãÙÐƽ´ª¡˜†}sj`VLB8.%ýóéßÕÌú*ÿB)ÿ(ÿ'ÿÑ&ÿÐ%ÿÏ$ÿÌ#ÿË"ÿÊ!ÿÉ ÿÈÿÿÇÿÅÿÆÿÅÿÆÿÅÿÿ#ÿBÿBÿÿÿÿÃÿÿÿ ÿ[ ÿÁ ÿÀ ÿ¿ ÿ¾ÿ¼ÿ=ÿ=ÿ"ÿuÿ8ÿ:ÿ8ÿ:Žÿ8Ž~ÿ:Ž}ÿuŽ|ÿ-Ž{ÿ8Žzÿ:Žyÿ5Žxÿ4Žwÿ3Žvÿ-Žuÿ,Žtÿ+ŽsÿrŽrÿuŽqÿuŽpÿºŽoÿ:ŽnÿºŽmÿ:Žlÿ-Žkÿ,Žjÿ+ŽiÿrŽhÿrŽgÿ±Žfÿ–Žeÿ¶Ždÿ´Žcÿ·Žbÿ¶Žaÿ´Ž`ÿ¶Ž_ÿ´Ž^ÿ´Ž]ÿ´Ž\ÿ¸Ž[ÿ·ŽZÿ´ŽYÿ´ŽXÿ´ŽWÿ¸ŽVÿ·ŽUÿ´ŽTÿ¶ŽSÿ´ `°_ µb ІP­`JC'Cstd::basic_ifstream< char >std::ifstreamclassstd_1_1basic__ifstreambQ=Ostd::tr1::unordered_map< T, U, H >dai::hash_map< T, U, H >classstd_1_1tr1_1_1unordered__map;A1dai::DAIAlg< RegionGraph >dai::HAKclassdai_1_1DAIAlg3/%+std::set< UEdge >dai::GraphELclassstd_1_1setG A%Astd::basic_fstream< char >std::fstreamclassstd_1_1basic__fstream: 5%3dai::TFactor< Real >dai::FRegionclassdai_1_1TFactorR K-Estd::binary_function< T, T, T >dai::fo_pow< T >classstd_1_1binary__functionP C3Cstd::unary_function< T, T >dai::fo_plog0p< T >classstd_1_1unary__functionR K-Estd::binary_function< T, T, T >dai::fo_min< T >classstd_1_1binary__functionRK-Estd::binary_function< T, T, T >dai::fo_max< T >classstd_1_1binary__functionNC/Cstd::unary_function< T, T >dai::fo_log0< T >classstd_1_1unary__functionMC-Cstd::unary_function< T, T >dai::fo_log< T >classstd_1_1unary__function N̘_+ｌZ(ѲˆRë»wN&‚Z + std::iosclassclassstd_1_1iosA‚Y 7G std::invalid_argumentclassclassstd_1_1invalid__argument-‚X #1 dai::InfAlgclassclassdai_1_1InfAlg #1‚W '5 dai::IndexForclassclassdai_1_1IndexFor@00‚V '5 std::ifstreamclassclassstd_1_1ifstream3‚U '7 dai::hash_mapclassclassdai_1_1hash__map>’'‚T + dai::HAKclassclassdai_1_1HAK;$‚S  GRMclassclassGRM ÏT‚R IW dai::greedyVariableEliminationclassclassdai_1_1greedyVariableElimination/‚Q %3 dai::GraphELclassclassdai_1_1GraphEL"/‚P %3 dai::GraphALclassclassdai_1_1GraphAL8r.‚O %3 std::fstreamclassclassstd_1_1fstream/‚N %3 dai::FRegionclassclassdai_1_1FRegion609‚M /? std::forward_listclassclassstd_1_1forward__list1‚L #5 dai::fo_powstructstructdai_1_1fo__pow ’6‚K ); dai::fo_plog0pstructstructdai_1_1fo__plog0p g1‚J #5 dai::fo_minstructstructdai_1_1fo__min §1‚I #5 dai::fo_maxstructstructdai_1_1fo__max ž Z½÷îåÜÒÉÀ·®¥›’‰€wne\SI@7.% ÿöìâØÎÄ»±§ž•‹‚ypg^ULB90& ÷îäÛÒÉÀ·­£™…|sjaXOF=3*!ýôëâÙÐǽÿãÿÿÿÿÿB~ÿ}ÿB|ÿA{ÿzÿyÿxÿwÿ(vÿBuÿtÿBsÿArÿqÿpÿoÿnÿmÿálÿàkÿŽjÿ'iÿhÿgÿfÿeÿdÿÝcÿbÿaÿÜ`ÿ_ÿÛ^ÿ]ÿÛ\ÿ[ÿZÿ&YÿBXÿWÿBVÿAUÿTÿSÿ^RÿÙQÿPÿBOÿØNÿ×MÿBLÿÆKÿÅJÿÆIÿÅHÿÕGÿFÿÖEÿÕDÿCÿBÿBAÿB@ÿ?ÿ>ÿÔ=ÿ<ÿ;ÿ:ÿB9ÿ 8ÿB7ÿ 6ÿ5ÿ%4ÿ3ÿ2ÿ1ÿ~0ÿ/ÿ$.ÿ -ÿ,ÿB+ÿA (¹{1Õ•XØ›^Çk(@-/=std::logic_errorstd::out_of_rangeclassstd_1_1logic__errorYM1Mstd::basic_ostringstream< char >std::ostringstreamclassstd_1_1basic__ostringstreamGA%Astd::basic_ostream< char >std::ostreamclassstd_1_1basic__ostreamJC'Cstd::basic_ofstream< char >std::ofstreamclassstd_1_1basic__ofstream:A1dai::DAIAlg< FactorGraph >dai::MRclassdai_1_1DAIAlg:A1dai::DAIAlg< FactorGraph >dai::MFclassdai_1_1DAIAlg:)-7std::exceptionstd::logic_errorclassstd_1_1exception@-/=std::logic_errorstd::length_errorclassstd_1_1logic__error:A1dai::DAIAlg< FactorGraph >dai::LCclassdai_1_1DAIAlg=A!1dai::DAIAlg< RegionGraph >dai::JTreeclassdai_1_1DAIAlgYM1Mstd::basic_istringstream< char >std::istringstreamclassstd_1_1basic__istringstreamGA%Astd::basic_istream< char >std::istreamclassstd_1_1basic__istream;99std::basic_ios< char >std::iosclassstd_1_1basic__iosD-7=std::logic_errorstd::invalid_argumentclassstd_1_1logic__error _Ì›^Ëw.Ü~?ú¦_D‚g 9K std::wstring::iteratorclassclassstd_1_1wstring_1_1iteratorQ‚f EY std::unordered_set::iteratorclassclassstd_1_1unordered__set_1_1iteratorB‚e 7I std::string::iteratorclassclassstd_1_1string_1_1iterator<‚d 1C std::set::iteratorclassclassstd_1_1set_1_1iterator[‚c Oc std::unordered_multimap::iteratorclassclassstd_1_1unordered__multimap_1_1iteratorO‚b CW std::basic_string::iteratorclassclassstd_1_1basic__string_1_1iteratorF‚a ;M std::multimap::iteratorclassclassstd_1_1multimap_1_1iteratorQ‚` EY std::unordered_map::iteratorclassclassstd_1_1unordered__map_1_1iteratorO‚_ CW std::forward_list::iteratorclassclassstd_1_1forward__list_1_1iterator>‚^ 3E std::list::iteratorclassclassstd_1_1list_1_1iterator:‚] 1? std::istringstreamclassclassstd_1_1istringstream.‚\ %3 std::istreamclassclassstd_1_1istream1‚[ '7 std::ios_baseclassclassstd_1_1ios__base 7ÁxÕ’d<¥z@Ò‡_7%‚w ) dai::MRclassclassdai_1_1MRK&%‚v ) dai::MFclassclassdai_1_1MFH)H‚u 9 O dai::BP_dual::messagesstructstructdai_1_1BP__dual_1_1messages.B‚t 7E dai::MaximizationStepclassclassdai_1_1MaximizationStep &‚s + std::mapclassclassstd_1_1map7‚r -= std::logic_errorclassclassstd_1_1logic__error(‚q - std::listclassclassstd_1_1listX‚p I] dai::BipartiteGraph::levelTypestructstructdai_1_1BipartiteGraph_1_1levelType 69‚o /? std::length_errorclassclassstd_1_1length__error%‚n ) dai::LCclassclassdai_1_1LCE!+‚m !/ dai::JTreeclassclassdai_1_1JTreeB-@‚l 5G std::deque::iteratorclassclassstd_1_1deque_1_1iteratorB‚k 7I std::vector::iteratorclassclassstd_1_1vector_1_1iterator[‚j Oc std::unordered_multiset::iteratorclassclassstd_1_1unordered__multiset_1_1iteratorF‚i ;M std::multiset::iteratorclassclassstd_1_1multiset_1_1iterator<‚h 1C std::map::iteratorclassclassstd_1_1map_1_1iterator IŠFñºr0ݨb*ò¦IZ‚bmWclassstd_1_1multimap_1_1const__reverse__iteratorstd::multimap::const_reverse_iteratorI‚a[Gclassstd_1_1multimap_1_1const__iteratorstd::multimap::const_iterator5‚`G3structdai_1_1MR_1_1Propertiesdai::MR::Properties5‚_G3structdai_1_1MF_1_1Propertiesdai::MF::PropertiesC‚^UAclassstd_1_1map_1_1reverse__iteratorstd::map::reverse_iterator2‚]C1classstd_1_1map_1_1iteratorstd::map::iteratorP‚\cMclassstd_1_1map_1_1const__reverse__iteratorstd::map::const_reverse_iterator?‚[Q=classstd_1_1map_1_1const__iteratorstd::map::const_iteratorE‚ZWCclassstd_1_1list_1_1reverse__iteratorstd::list::reverse_iterator4‚YE3classstd_1_1list_1_1iteratorstd::list::iteratorR‚XeOclassstd_1_1list_1_1const__reverse__iteratorstd::list::const_reverse_iteratorA‚WS?classstd_1_1list_1_1const__iteratorstd::list::const_iterator5‚VG3structdai_1_1LC_1_1Propertiesdai::LC::Properties;‚UM9structdai_1_1JTree_1_1Propertiesdai::JTree::Properties 9ŠñâÓÄ´¤”„tdTC3#õæ×ȹ©™‰zkZJ:* ýîßÐÁ²£”…vgXI:)öæÖǸ©šŠ …G ¼½F …F »C …E ºS …D ¹P …C ¸M …B ·K· …A ·K·…@ ·´K·…? ¶´K¯…> µ´K›…= ³´K’ …< ²Km …; ²Km …: ±K …9 °"K{ …8 ¯"Kv …7 ® Ku …6 ­Ks …5 ­Ks …4 ¬Hn …3 «"Hi …2 ª"Hd …1 © Hc …0 ¨Ha …/ ¨Ha …. §HX …- §HX …, ¦! …+ ¥ …* ¤…) ¢£ …( ¡Eg …' ¡Eg …&  0E† …% ŸE„ …$ žE‚ …# Ez …" œ"Eu …! ›"Ep …  š Eo … ™Em … ™Em … ˜|BÑ … ˜BÑ … —"BÄ… •–B¿ … •"B¿ … ”"B¦ … ”B¦ … “"B  … “B  … ’BŠ … ‘"B† … "B … B} … B} … ŽBv U½÷îäÛÑÈ¿¶­£™†|si`VLB8.$ýôëáØÎĺ°¦œ’‰ukaWMC9/%ýóéßÕËÁ·­£™…{qg]SI?5+! ùïåÛÑǽYÿüXÿ WÿVÿUÿöTÿSÿRÿQÿüPÿ Oÿ NÿøMÿLÿKÿJÿIÿ HÿGÿFÿEÿ Dÿ CÿüBÿ Aÿ @ÿø?ÿ>ÿ=ÿ<ÿ;ÿ:ÿ9ÿ8ÿ7ÿ6ÿÿ5ÿþ4ÿý3ÿü2ÿû1ÿú0ÿù/ÿø.ÿ÷-ÿö,ÿü+ÿ*ÿô)ÿó(ÿò'ÿñ&ÿð%ÿï$ÿî#ÿq"ÿî!ÿ  ÿpÿ ÿíÿìÿ)ÿÑÿêÿéÿèÿçÿãÿ`ÿãÿÿæÿåÿÿæÿå ÿ  ÿ ÿ  ÿ ÿãÿÿäÿ ÿ 6˘e/üËŽQÇ”TÌ|6Cƒ 5I dai::HAK::Propertiesstructstructdai_1_1HAK_1_1Properties;5Mƒ ?S dai::ExactInf::Propertiesstructstructdai_1_1ExactInf_1_1Properties'#Aƒ 3G dai::BP::Propertiesstructstructdai_1_1BP_1_1Properties eAƒ 3G dai::MR::Propertiesstructstructdai_1_1MR_1_1PropertiesKF=ƒ 3C std::priority_queueclassclassstd_1_1priority__queue0ƒ %3 dai::Permuteclassclassdai_1_1Permute@‰Gƒ =K dai::ParameterEstimationclassclassdai_1_1ParameterEstimation2=ƒ 3C std::overflow_errorclassclassstd_1_1overflow__error:‚ /A std::out_of_rangeclassclassstd_1_1out__of__range:‚~ 1? std::ostringstreamclassclassstd_1_1ostringstream.‚} %3 std::ostreamclassclassstd_1_1ostream0‚| '5 std::ofstreamclassclassstd_1_1ofstream3‚{ '7 dai::Neighborstructstructdai_1_1Neighbor8I0‚z '5 std::multisetclassclassstd_1_1multiset0‚y '5 std::multimapclassclassstd_1_1multimap2‚x '5 dai::multiforclassclassdai_1_1multifor@ MÁq%ȉ9÷¤o)áˆM8‚oI7classstd_1_1string_1_1iteratorstd::string::iteratorV‚niSclassstd_1_1string_1_1const__reverse__iteratorstd::string::const_reverse_iteratorE‚mWCclassstd_1_1string_1_1const__iteratorstd::string::const_iteratorC‚lUAclassstd_1_1set_1_1reverse__iteratorstd::set::reverse_iterator2‚kC1classstd_1_1set_1_1iteratorstd::set::iteratorP‚jcMclassstd_1_1set_1_1const__reverse__iteratorstd::set::const_reverse_iterator?‚iQ=classstd_1_1set_1_1const__iteratorstd::set::const_iteratorM‚h_Kclassstd_1_1multiset_1_1reverse__iteratorstd::multiset::reverse_iterator<‚gM;classstd_1_1multiset_1_1iteratorstd::multiset::iteratorZ‚fmWclassstd_1_1multiset_1_1const__reverse__iteratorstd::multiset::const_reverse_iteratorI‚e[Gclassstd_1_1multiset_1_1const__iteratorstd::multiset::const_iteratorM‚d_Kclassstd_1_1multimap_1_1reverse__iteratorstd::multimap::reverse_iterator<‚cM;classstd_1_1multimap_1_1iteratorstd::multimap::iterator B·g!ï®o0ùÊ›k;ô›kB&/!)dai::BPdai::TRWBPclassdai_1_1BP-.!#/dai::JTreedai::TreeEPclassdai_1_1JTreeV-K/Kstd::basic_stringstream< char >std::stringstreamclassstd_1_1basic__stringstreamD,?#?std::basic_string< char >std::stringclassstd_1_1basic__string-+##-StateFactorStateSparseclassStateFactor-*##-StateFactorStateSparseclassStateFactor,)#!-StateFactorStateDenseclassStateFactor,(#!-StateFactorStateDenseclassStateFactor4')%3AbstractFactorSparseFactorclassAbstractFactor<&)17std::exceptionstd::runtime_errorclassstd_1_1exception<%5+1std::vector< DEdge >dai::RootedTreeclassstd_1_1vector>$--;dai::FactorGraphdai::RegionGraphclassdai_1_1FactorGraph/###1dai::VarSetdai::Regionclassdai_1_1VarSetC"1-Astd::runtime_errorstd::range_errorclassstd_1_1runtime__errorM!Y-+std::map< PropertyKey, PropertyValue >dai::PropertySetclassstd_1_1mapF 13Astd::runtime_errorstd::overflow_errorclassstd_1_1runtime__error 8}ðàÐÀ°¡‘q`O>- ûëÜ;¯Ÿo_N>. ýíÜ̼¬œ‹zjYI9* ýíÝͽ­} … ï=Uç …~ î=Uâ …} î=Uâ …| í=UŸ …{ ì=U— …z ë=U’ …y ê=U …x é=U€ …w è=Ur …v ç=Uk …u æ=Ud …t å=U] …s äû …r ãî…q â£Ù …p áÖ…o ÞàÐ…n ÞßÐ …m Ý"Å …l Ý Å …k Ü: …j Û …i ÙÚ"¥ …h Ø"6 …g ×"6 …f ×6 …e ÖÑ6 …d Ö"6 …c Ö6…b Õ€6õ …a Ô06Û …` Ó06Õ …_ Ò"6ˆ …^ Ò6ˆ …] ÐÑ6s …\ Ð"6s …[ Ð6s …Z Ï6% …Y Ï"6% …X ÎP …W ÍPò…V ÌÂPÚ…U ËÂPÈ…T ÊÂP»…S ÉÂPª…R ÈÂP¥…Q ÇÂP‰ …P ÆÂP{ …O ÅÃPp …N ÅÂPp …M ÄPc …L ÁÃP] …K ÁÂP] …J À¾ …I ¿‘ …H ¾ @ž D¶r.â›Tí³ƒI÷”DMƒ AU std::map::reverse_iteratorclassclassstd_1_1map_1_1reverse__iterator`ƒ Si std::forward_list::reverse_iteratorclassclassstd_1_1forward__list_1_1reverse__iteratorOƒ CW std::list::reverse_iteratorclassclassstd_1_1list_1_1reverse__iterator7ƒ -; dai::RegionGraphclassclassdai_1_1RegionGraph6[-ƒ #1 dai::Regionclassclassdai_1_1Region67ƒ -= std::range_errorclassclassstd_1_1range__error*ƒ !/ std::queueclassclassstd_1_1queue7ƒ -; dai::PropertySetclassclassdai_1_1PropertySetPIDƒ 5I dai::CBP::Propertiesstructstructdai_1_1CBP_1_1Properties”Dƒ 5I dai::BBP::Propertiesstructstructdai_1_1BBP_1_1PropertiesvIƒ ;O dai::TreeEP::Propertiesstructstructdai_1_1TreeEP_1_1PropertiesN1Aƒ 3G dai::LC::Propertiesstructstructdai_1_1LC_1_1PropertiesE2Aƒ 3G dai::MF::Propertiesstructstructdai_1_1MF_1_1PropertiesH4Gƒ 9M dai::JTree::Propertiesstructstructdai_1_1JTree_1_1PropertiesB@ V·öìâØÎĺ°¦œ’‰ukaWMC9/%þôêàÖ̸®¤š†|rh_UKA7-$ýóéßÕ˸®¥›’ˆvmd[RH?5+!ûòèÞÔËÁ·‘/ÿ.‘.ÿ-‘-ÿ[‘,ÿ=‘+ÿ<‘*ÿ;‘)ÿ ‘(ÿB‘'ÿ:‘&ÿÕ‘%ÿ‘$ÿ8‘#ÿ7‘"ÿ6‘!ÿ‘ ÿÑÿ=‘ÿf‘ÿe‘ÿd‘ÿd‘ÿ‘ÿ,‘ÿ‘ÿ©‘ÿ ‘ÿÇ‘ÿÅ‘ÿ ‘ÿÇ‘ÿÇ‘ÿÅ‘ÿÅ‘ÿÕ‘ ÿ‘ ÿ8‘ ÿ7‘ ÿ6‘ ÿ‘ÿ±‘ÿ+‘ÿ4‘ÿŽ‘ÿ3‘ÿ=‘ÿ,‘ÿ-‘ÿ-ÿ-~ÿ-}ÿ-|ÿ-{ÿ1zÿ-yÿ.xÿ-wÿ/vÿ.uÿ-tÿ,sÿrÿ+qÿ*pÿ)oÿ(nÿ'mÿ&lÿ%kÿ$jÿ#iÿ"hÿ!gÿ fÿ*eÿdÿcÿbÿaÿ`ÿ_ÿü^ÿ]ÿ\ÿ[ÿþZÿý P›Aë›6Çm¦PSƒ G[ std::vector::reverse_iteratorclassclassstd_1_1vector_1_1reverse__iteratorlƒ _u std::unordered_multiset::reverse_iteratorclassclassstd_1_1unordered__multiset_1_1reverse__iteratorUƒ I] std::wstring::reverse_iteratorclassclassstd_1_1wstring_1_1reverse__iteratorWƒ K_ std::multiset::reverse_iteratorclassclassstd_1_1multiset_1_1reverse__iteratorlƒ _u std::unordered_multimap::reverse_iteratorclassclassstd_1_1unordered__multimap_1_1reverse__iteratorbƒ Uk std::unordered_set::reverse_iteratorclassclassstd_1_1unordered__set_1_1reverse__iteratorMƒ AU std::set::reverse_iteratorclassclassstd_1_1set_1_1reverse__iteratorSƒ G[ std::string::reverse_iteratorclassclassstd_1_1string_1_1reverse__iteratorWƒ K_ std::multimap::reverse_iteratorclassclassstd_1_1multimap_1_1reverse__iteratorbƒ Uk std::unordered_map::reverse_iteratorclassclassstd_1_1unordered__map_1_1reverse__iterator XIÒsJÑ›k>㵇X,ƒ/ #1 std::stringclassclassstd_1_1string+ƒ. #- StateSparseclassclassStateSparse-+ƒ- #- StateFactorclassclassStateFactor-)ƒ, !+ StateDenseclassclassStateDense-,ƒ+ !/ dai::Stateclassclassdai_1_1State@`*ƒ* !/ std::stackclassclassstd_1_1stack-ƒ) %/ SparseFactorclassclassSparseFactor3ƒ( )9 std::smart_ptrclassclassstd_1_1smart__ptr1ƒ' '5 dai::SmallSetclassclassdai_1_1SmallSetU Bƒ& 7E dai::SharedParametersclassclassdai_1_1SharedParameters«&ƒ% + std::setclassclassstd_1_1set\ƒ$ Q_ dai::sequentialVariableEliminationclassclassdai_1_1sequentialVariableElimination ;ƒ# 1A std::runtime_errorclassclassstd_1_1runtime__error6ƒ" +9 dai::RootedTreeclassclassdai_1_1RootedTree"Qƒ! EY std::deque::reverse_iteratorclassclassstd_1_1deque_1_1reverse__iterator`ƒ Si std::basic_string::reverse_iteratorclassclassstd_1_1basic__string_1_1reverse__iterator UµöìâØÎÅ»±§“‰ukaWMC9/%ýóéßÕËÁ·­£š‡~tj`VMD:0&þôêàÖ̸®¤š†|rh^TJ@6,"ûñçÝÓÉ¿µ’ÿd’ÿ`’ÿc’ÿ`’ÿa‘ÿ`‘~ÿ`‘}ÿA‘|ÿa‘{ÿœ‘zÿY‘yÿZ‘xÿ^‘wÿ[‘vÿX‘uÿV‘tÿW‘sÿ^‘rÿ[‘qÿ]‘pÿœ‘oÿœ‘nÿW‘mÿV‘lÿ\‘kÿ[‘jÿX‘iÿ\‘hÿ[‘gÿœ‘fÿZ‘eÿY‘dÿU‘cÿ—‘bÿX‘aÿW‘`ÿV‘_ÿU‘^ÿ—‘]ÿÑ‘\ÿB‘[ÿA‘ZÿT‘YÿS‘XÿQ‘Wÿ/‘VÿB‘Uÿ‘TÿM‘Sÿ=‘RÿO‘QÿN‘PÿO‘OÿN‘NÿO‘MÿN‘LÿL‘KÿM‘JÿM‘IÿM‘HÿM‘GÿL‘FÿM‘EÿL‘DÿM‘CÿM‘BÿM‘AÿM‘@ÿL‘?ÿL‘>ÿK‘=ÿJ‘<ÿI‘;ÿG‘:ÿF‘9ÿL‘8ÿ‘7ÿá‘6ÿD‘5ÿ‘4ÿŽ‘3ÿC‘2ÿB‘1ÿA‘0ÿ@ 7vðàÐÀ°Ÿo`QB3$öæÖÅ´£’p_N=, ùéÙɹ¨—†udSB1 þíÜ˺©˜‡v†6 # ††5 " €†4 ! z†3   u†2  p†1  g†0  †/  Ú†.  ¢†-  œ†, Wv†+ Wl†* Wl†) Wb†( Wb†' WT†& WT†% WT†$ WG †# "Wñ †" "Wî †! "Wå †  "W݆ Wʆ  WÁ†  W¸†  W¯†  W”†  WŠ† Wƒ† W|† Wu† W]† W† Wñ† W± † ÿ W® † ÿ W® † þ Wk † üýWf † ü"Wf †  û"W` †  ú"WW †  ù"WM †  ø"WH †  ÷ WE † ö"@¬ † õ @£ † ô @~† òó@p † ò"@p † ñ=Uô † ð=Uì † ð=Uì † ï=Uç =´t.×o%Êiö¢=b‚zu_classstd_1_1unordered__multimap_1_1reverse__iteratorstd::unordered_multimap::reverse_iteratorQ‚ycOclassstd_1_1unordered__multimap_1_1iteratorstd::unordered_multimap::iteratorp‚xkclassstd_1_1unordered__multimap_1_1const__reverse__iteratorstd::unordered_multimap::const_reverse_iterator^‚wq[classstd_1_1unordered__multimap_1_1const__iteratorstd::unordered_multimap::const_iteratorX‚vkUclassstd_1_1unordered__map_1_1reverse__iteratorstd::unordered_map::reverse_iteratorG‚uYEclassstd_1_1unordered__map_1_1iteratorstd::unordered_map::iteratore‚tyaclassstd_1_1unordered__map_1_1const__reverse__iteratorstd::unordered_map::const_reverse_iteratorT‚sgQclassstd_1_1unordered__map_1_1const__iteratorstd::unordered_map::const_iteratorC‚rSAclassdai_1_1TreeEP_1_1TreeEPSubTreedai::TreeEP::TreeEPSubTree=‚qO;structdai_1_1TreeEP_1_1Propertiesdai::TreeEP::PropertiesI‚p[Gclassstd_1_1string_1_1reverse__iteratorstd::string::reverse_iterator GʼnW(ùÉxJÛ™a#×GEƒ? ;K std::unordered_multisetclassclassstd_1_1unordered__multisetEƒ> ;K std::unordered_multimapclassclassstd_1_1unordered__multimapIƒ= ;O std::tr1::unordered_mapclassclassstd_1_1tr1_1_1unordered__map>’;ƒ< 1A std::unordered_mapclassclassstd_1_1unordered__map5ƒ; +; std::unique_ptrclassclassstd_1_1unique__ptr?ƒ: 5E std::underflow_errorclassclassstd_1_1underflow__error>ƒ9 3C std::unary_functionclassclassstd_1_1unary__function R+ƒ8 !/ dai::UEdgeclassclassdai_1_1UEdge"M+ƒ7 !/ dai::TRWBPclassclassdai_1_1TRWBPZ4Nƒ6 AS dai::TreeEP::TreeEPSubTreeclassclassdai_1_1TreeEP_1_1TreeEPSubTreeNQ-ƒ5 #1 dai::TreeEPclassclassdai_1_1TreeEPN(,ƒ4 !/ dai::TProbclassclassdai_1_1TProb Â,ƒ3 #1 std::threadclassclassstd_1_1thread/ƒ2 %3 dai::TFactorclassclassdai_1_1TFactorW79ƒ1 /? std::system_errorclassclassstd_1_1system__error8ƒ0 /= std::stringstreamclassclassstd_1_1stringstream U·öìâØÏż³©Ÿ•‹wmcYOE;1' ÿõëá×Íù¯¥›‘‡}si_UKA7.$üòèÞÔ˸®¤š†}tjaWMC9/%ýóéßÕËÁ·’Yÿo’Xÿo’Wÿo’Vÿƒ’Uÿk’Tÿ‚’Sÿƒ’Rÿl’Qÿk’Pÿ‚’Oÿ€’Nÿ€’Mÿ’Lÿ}’Kÿ|’Jÿ}’Iÿ|’Hÿ’Gÿg’Fÿ’Eÿ’Dÿz’Cÿ2’BÿK’AÿJ’@ÿI’?ÿa’>ÿu’=ÿu’<ÿw’;ÿq’:ÿw’9ÿq’8ÿw’7ÿx’6ÿq’5ÿw’4ÿw’3ÿ=’2ÿu’1ÿ`’0ÿu’/ÿ`’.ÿ`’-ÿt’,ÿ`’+ÿq’*ÿq’)ÿq’(ÿq’'ÿr’&ÿq’%ÿq’$ÿq’#ÿq’"ÿq’!ÿr’ ÿq’ÿo’ÿo’ÿo’ÿo’ÿo’ÿo’ÿo’ÿo’ÿo’ÿo’ÿo’ÿm’ÿk’ÿm’ÿl’ÿk’ÿj’ÿi’ ÿh’ ÿ’ ÿ’ ÿg’ ÿ’ÿf’ÿò’ÿe’ÿ` V¼öìâØÎĺ°¦œ’ˆ~tj`VLB8.$üòèÞÔÊÁ·­£™†}tjaWMD;2( ÷íãÙÏÅ»±§”‹‚ypg^TJ@6-$ ÷íãÙÏż“/ÿ=“.ÿ“-ÿ“,ÿ…“+ÿƒ“*ÿ‚“)ÿF“(ÿ “'ÿF“&ÿ“%ÿ“$ÿD“#ÿ “"ÿœ“!ÿ‘“ ÿ²“ÿ±“ÿ “ÿ “ÿ“ÿ“ÿ“ÿ“ÿ“ÿ™“ÿ˜“ÿ›“ÿš“ÿ™“ÿ˜“ÿ—“ÿ–“ÿ•“ÿ”“ ÿ““ ÿ’“ ÿ’“ ÿ “ ÿ‘“ÿ“ÿ“ÿ“ÿ“ÿ“ÿ“ÿ6“ÿB“ÿ’ÿ’~ÿŽ’}ÿ’|ÿŽ’{ÿ’zÿe’yÿ=’xÿx’wÿŒ’vÿe’uÿ‹’tÿŠ’sÿ|’rÿ€’qÿ€’pÿ€’oÿ€’nÿ€’mÿ€’lÿ€’kÿ†’jÿ€’iÿ€’hÿ€’gÿ€’fÿ€’eÿ€’dÿ€’cÿ†’bÿ€’aÿo’`ÿo’_ÿo’^ÿo’]ÿo’\ÿo’[ÿo’Zÿo 9Õ·›‡oF.õæ×ȳ¦tdT9„H mxArray *nlhs[] „G body „F stmt „E n „D str„C Factor &fx „B x„A condition „@ msg „? cod „> cod „= x „< x „; ... „: val0„9 boolusePrimx&„8 3BBPCostFunctionBasepsiT"\t\n"„7 size_tlabelT„6 size_tvs„5 +typename binOp1q„4 /typename binaryOpq(„3 /'typename binaryOpxdai::NORMPROB 7ƒïÞͼ«š‰xgVE4#ðßÏ¿¯ŸŽ}m]M<, úêÚʺªšŠzj[L=.ñáѲ¢’ƒ †m M ]> †l LJ"m †k KJ"d †j IJ"_ †i HL"\ †h GZ„ †g FZ †f E–Zt †e DZq †d CZl †c BZ^ †b AZ[ †a AZ[ †` @ZR †_ @ZR †^ ?0N †] ?0N †\ >0NŠ †[ >0NŠ †Z =0N‡ †Y =0N‡ †X <0N€ †W <0N€ †V <0N€†U <–N€†T <–N€ †S ;:Np †R 9:Nm†Q 8–NÊ †P 8NÊ †O 7N´ †N 7N´†M 65N¢†L 45N› †K 3Nà †J 2"N¾ †I 1Nº †H 1Nº†G 0ý ø†F 0ý ø†E /ý ï†D /ý ï†C .ý â†B - ̆A -ý ̆@ -ý ̆? , Á†> + »†= * ¶†< ) °†; ( ª†: ' ¥†9 &  †8 % •†7 $ ‹ WÀöìâÙÐǾµ¬£š‡}si_VMD:1( øîäÚÐǾ´«¢™‡}si_UKA7-#ýôëâÙÐǾµ¬£š†|rh^TJ@6,"úðçÝÔÊÀ”ÿÀ”ÿê”ÿ`”ÿ¿”ÿu”ÿÑ”ÿÑ“ÿÑ“~ÿÑ“}ÿÑ“|ÿ¾“{ÿ½“zÿ¼“yÿ»“xÿº“wÿê“vÿ¹“uÿ¸“tÿ·“sÿ “rÿ¶“qÿÀ“pÿ“oÿ[“nÿ“mÿ[“lÿ“kÿ[“jÿ“iÿ[“hÿR“gÿ“fÿ"“eÿV“dÿU“cÿµ“bÿ´“aÿ³“`ÿ²“_ÿ±“^ÿ°“]ÿ¯“\ÿ®“[ÿ¯“Zÿ®“Yÿ­“Xÿ¬“Wÿ#“Vÿ“Uÿ"“Tÿ!“Sÿ “Rÿ«“Qÿ “Pÿ“Oÿª“Nÿ©“Mÿ,“Lÿ,“Kÿ©“Jÿ“Iÿ¨“Hÿ“Gÿ¨“Fÿ“Eÿ“DÿÛ“CÿB“Bÿ=“Aÿ5“@ÿ¦“?ÿ¥“>ÿ£“=ÿ¢“<ÿA“;ÿ¡“:ÿY“9ÿ=“8ÿY“7ÿY“6ÿY“5ÿY“4ÿY“3ÿY“2ÿ “1ÿ7“0ÿž \¶y5ç–T¦U§\H;E%?std::basic_string< wchar_t >std::wstringclassstd_1_1basic__string]:S3Mstd::basic_ostringstream< wchar_t >std::wostringstreamclassstd_1_1basic__ostringstreamK9G'Astd::basic_ostream< wchar_t >std::wostreamclassstd_1_1basic__ostreamN8I)Cstd::basic_ofstream< wchar_t >std::wofstreamclassstd_1_1basic__ofstream]7S3Mstd::basic_istringstream< wchar_t >std::wistringstreamclassstd_1_1basic__istringstreamK6G'Astd::basic_istream< wchar_t >std::wistreamclassstd_1_1basic__istream?5?9std::basic_ios< wchar_t >std::wiosclassstd_1_1basic__iosN4I)Cstd::basic_ifstream< wchar_t >std::wifstreamclassstd_1_1basic__ifstreamK3G'Astd::basic_fstream< wchar_t >std::wfstreamclassstd_1_1basic__fstreamA25;+std::map< UEdge, T >dai::WeightedGraph< T >classstd_1_1map:15#5dai::SmallSet< Var >dai::VarSetclassdai_1_1SmallSetG015Astd::runtime_errorstd::underflow_errorclassstd_1_1runtime__error 3Ÿ,Øs´jÇn38ƒI7classstd_1_1vector_1_1iteratorstd::vector::iteratorVƒiSclassstd_1_1vector_1_1const__reverse__iteratorstd::vector::const_reverse_iteratorEƒWCclassstd_1_1vector_1_1const__iteratorstd::vector::const_iteratorXƒkUclassstd_1_1unordered__set_1_1reverse__iteratorstd::unordered_set::reverse_iteratorGƒYEclassstd_1_1unordered__set_1_1iteratorstd::unordered_set::iteratoreƒyaclassstd_1_1unordered__set_1_1const__reverse__iteratorstd::unordered_set::const_reverse_iteratorT‚gQclassstd_1_1unordered__set_1_1const__iteratorstd::unordered_set::const_iteratorb‚~u_classstd_1_1unordered__multiset_1_1reverse__iteratorstd::unordered_multiset::reverse_iteratorQ‚}cOclassstd_1_1unordered__multiset_1_1iteratorstd::unordered_multiset::iteratorp‚|kclassstd_1_1unordered__multiset_1_1const__reverse__iteratorstd::unordered_multiset::const_reverse_iterator^‚{q[classstd_1_1unordered__multiset_1_1const__iteratorstd::unordered_multiset::const_iterator yÂe5Ò“`+ÍŽY&ç¶y:ƒP 1? std::wstringstreamclassclassstd_1_1wstringstream.ƒO %3 std::wstringclassclassstd_1_1wstring<ƒN 3A std::wostringstreamclassclassstd_1_1wostringstream0ƒM '5 std::wostreamclassclassstd_1_1wostream2ƒL )7 std::wofstreamclassclassstd_1_1wofstream<ƒK 3A std::wistringstreamclassclassstd_1_1wistringstream0ƒJ '5 std::wistreamclassclassstd_1_1wistream(ƒI - std::wiosclassclassstd_1_1wios2ƒH )7 std::wifstreamclassclassstd_1_1wifstream0ƒG '5 std::wfstreamclassclassstd_1_1wfstream<ƒF 1? dai::WeightedGraphclassclassdai_1_1WeightedGraph"•1ƒE '7 std::weak_ptrclassclassstd_1_1weak__ptr,ƒD #1 std::vectorclassclassstd_1_1vector-ƒC #1 dai::VarSetclassclassdai_1_1VarSet_^'ƒB + dai::Varclassclassdai_1_1Var]%0ƒA '5 std::valarrayclassclassstd_1_1valarray;ƒ@ 1A std::unordered_setclassclassstd_1_1unordered__set >„ñâÓĵ¦—ˆyj[K=/!öçØÉ»­Ÿ‘ƒugYK<-óå×É»­žseWH:,ôæØʼ® ’„ ‡+  sd ‡*  rI ‡)  q"? ‡(  p 7 ‡'  o. ‡&  o . ‡%  o . ‡$  n& ‡#  n"& ‡"  m ‡!  m  ‡   m  ‡  l ‡  l  ‡  kÓ ‡  j"L ‡  jL ‡  i" ‡  i ‡  h ‡  h ‡  gs ‡  f# ‡  fx# ‡  e:z ‡  d:i ‡  c:^ ‡  b:Y ‡  aÆ ‡  a Æ ‡   aÆ ‡   aÆ ‡   `0w ‡   `0w ‡   `w ‡  _0D ‡  _0D ‡  ^; ‡  ^; ‡  ]2 ‡  ]2 ‡  \Û ‡  \ Û ‡  \Û †  \Û †~  [ †}  Zj †|  Yd †{  X[ †z  X[ †y W"_ †x V _l †w V _l †v U _i †u T _f †t T=_f †s S ]t †r R ]k †q Q ]b †p P ]Y †o O ]P †n N ]G 6´jÒ„L-öÁ¤|],ýÀ¡|Y6 ƒ/!classdai_1_1EMAlgdai::EMAlg ƒ/!classdai_1_1DEdgedai::DEdge"ƒ1#classdai_1_1DAIAlgdai::DAIAlgƒ+classdai_1_1DAGdai::DAG:ƒI;classdai_1_1CondProbEstimationdai::CondProbEstimation,ƒ;-classdai_1_1CobwebGraphdai::CobwebGraph.ƒ=/classdai_1_1ClusterGraphdai::ClusterGraphƒ+classdai_1_1CBPdai::CBP%ƒ5%classdai_1_1BP__dualdai::BP_dualƒ)classdai_1_1BPdai::BP2ƒA3classdai_1_1BipartiteGraphdai::BipartiteGraph4ƒ C5classdai_1_1BBPCostFunctiondai::BBPCostFunctionƒ +classdai_1_1BBPdai::BBP5ƒ E5classdai_1_1__builtinInfAlgsdai::_builtinInfAlgsKƒ ]Iclassstd_1_1wstring_1_1reverse__iteratorstd::wstring::reverse_iterator:ƒ K9classstd_1_1wstring_1_1iteratorstd::wstring::iteratorXƒkUclassstd_1_1wstring_1_1const__reverse__iteratorstd::wstring::const_reverse_iteratorGƒYEclassstd_1_1wstring_1_1const__iteratorstd::wstring::const_iteratorIƒ[Gclassstd_1_1vector_1_1reverse__iteratorstd::vector::reverse_iterator ££Z<Q1Kstd::basic_stringstream< wchar_t >std::wstringstreamclassstd_1_1basic__stringstream S×®ƒT5ß®‡T/ߺ“jCïÈ¡zS$ƒ/3%classdai_1_1GraphELdai::GraphEL$ƒ.3%classdai_1_1GraphALdai::GraphAL$ƒ-3%classdai_1_1FRegiondai::FRegion$ƒ,5#structdai_1_1fo__powdai::fo_pow*ƒ+;)structdai_1_1fo__plog0pdai::fo_plog0p$ƒ*5#structdai_1_1fo__mindai::fo_min$ƒ)5#structdai_1_1fo__maxdai::fo_max&ƒ(7%structdai_1_1fo__log0dai::fo_log0$ƒ'5#structdai_1_1fo__logdai::fo_log"ƒ&3!structdai_1_1fo__KLdai::fo_KL&ƒ%7%structdai_1_1fo__inv0dai::fo_inv0$ƒ$5#structdai_1_1fo__invdai::fo_inv"ƒ#3!structdai_1_1fo__iddai::fo_id0ƒ"A/structdai_1_1fo__Hellingerdai::fo_Hellinger$ƒ!5#structdai_1_1fo__expdai::fo_exp.ƒ ?-structdai_1_1fo__divides0dai::fo_divides0,ƒ=+structdai_1_1fo__absdiffdai::fo_absdiff$ƒ5#structdai_1_1fo__absdai::fo_absƒ+classdai_1_1FBPdai::FBP,ƒ;-classdai_1_1FactorGraphdai::FactorGraph(ƒ7)classdai_1_1Exceptiondai::Exception&ƒ5'classdai_1_1ExactInfdai::ExactInf&ƒ5'classdai_1_1Evidencedai::Evidence Mµ–lCûÞ¥ˆkBÙ²ƒ^/¯vM&ƒD5'classdai_1_1SmallSetdai::SmallSet6ƒCE7classdai_1_1SharedParametersdai::SharedParametersPƒB_Qclassdai_1_1sequentialVariableEliminationdai::sequentialVariableElimination*ƒA9+classdai_1_1RootedTreedai::RootedTree,ƒ@;-classdai_1_1RegionGraphdai::RegionGraph"ƒ?1#classdai_1_1Regiondai::Region,ƒ>;-classdai_1_1PropertySetdai::PropertySet$ƒ=3%classdai_1_1Permutedai::Permute<ƒ<K=classdai_1_1ParameterEstimationdai::ParameterEstimation'ƒ;7'structdai_1_1Neighbordai::Neighbor&ƒ:5'classdai_1_1multifordai::multiforƒ9)classdai_1_1MRdai::MRƒ8)classdai_1_1MFdai::MF6ƒ7E7classdai_1_1MaximizationStepdai::MaximizationStepƒ6)classdai_1_1LCdai::LC ƒ5/!classdai_1_1JTreedai::JTree"ƒ41#classdai_1_1InfAlgdai::InfAlg&ƒ35'classdai_1_1IndexFordai::IndexFor'ƒ27'classdai_1_1hash__mapdai::hash_mapƒ1+classdai_1_1HAKdai::HAKHƒ0WIclassdai_1_1greedyVariableEliminationdai::greedyVariableElimination Aݶ“nK( 䱆c9 ã¯MëµA=ƒZM=classstd_1_1basic__istringstreamstd::basic_istringstream1ƒYA1classstd_1_1basic__istreamstd::basic_istream3ƒXC3classstd_1_1basic__iostreamstd::basic_iostream)ƒW9)classstd_1_1basic__iosstd::basic_ios3ƒVC3classstd_1_1basic__ifstreamstd::basic_ifstream1ƒUA1classstd_1_1basic__fstreamstd::basic_fstream+ƒT;+classstd_1_1bad__typeidstd::bad_typeid1ƒSA1classstd_1_1bad__exceptionstd::bad_exception'ƒR7'classstd_1_1bad__caststd::bad_cast)ƒQ9)classstd_1_1bad__allocstd::bad_alloc'ƒP7'classstd_1_1auto__ptrstd::auto_ptr ƒO/!classstd_1_1arraystd::array(ƒN7)classstd_1_1allocatorstd::allocator0ƒM?1classdai_1_1WeightedGraphdai::WeightedGraph"ƒL1#classdai_1_1VarSetdai::VarSetƒK+classdai_1_1Vardai::Var ƒJ/!classdai_1_1UEdgedai::UEdge ƒI/!classdai_1_1TRWBPdai::TRWBP"ƒH1#classdai_1_1TreeEPdai::TreeEP ƒG/!classdai_1_1TProbdai::TProb$ƒF3%classdai_1_1TFactordai::TFactor ƒE/!classdai_1_1Statedai::State V´÷íãÙÏÅ»²¨ž•‹wmdZPF=3) ùïæÝÓÉ¿µ«¡—ƒyoe[QG=3)  øïåÜÒÈ¿µ¬¢˜Ž„zpf\RH>4*  øîåÛÒȾ´”\ÿæ”[ÿå”Zÿä”YÿB”Xÿã”WÿB”Vÿâ”Uÿá”Tÿ,”SÿÑ”RÿÑ”Qÿà”Pÿß”OÿÝ”NÿÞ”MÿÝ”LÿÜ”KÿÛ”JÿÚ”IÿÙ”HÿÔGÿœ”Fÿ4”EÿŽ”Dÿ3”Cÿ=”BÿØ”Aÿ=”@ÿ×”?ÿÙ”>ÿ”=ÿÓ”<ÿd”;ÿÖ”:ÿÕ”9ÿÔ”8ÿÓ”7ÿd”6ÿÒ”5ÿÑ”4ÿÒ”3ÿÑ”2ÿÏ”1ÿ¸”0ÿ¸”/ÿ¸”.ÿÍ”-ÿΔ,ÿ¼”+ÿ»”*ÿÍ”)ÿ¼”(ÿ»”'ÿ¸”&ÿ”%ÿŽ”$ÿ”#ÿ=”"ÿÌ”!ÿB” ÿÌ”ÿA”ÿË”ÿÊ”ÿÉ”ÿº”ÿB”ÿË”ÿÊ”ÿÉ”ÿ#”ÿÈ”ÿÅ”ÿÇ”ÿÆ”ÿB”ÿÅ”ÿÆ”ÿB” ÿÅ” ÿ ” ÿÄ” ÿÔ ÿ”ÿÁ”ÿu 'µñâÔÆ·¨™‹}o_QB3$ùëÝÎÀ²¤•†vfVF6&öæÖƵ‡R ™wô ‡Q ™ô ‡P —˜*A ‡O •–*< ‡N ”“*9 ‡M ”’*9 ‡L ”‘*9 ‡K “*. ‡J ’*. ‡I ‘*. ‡H Ž* ‡G  Œð ‡F  ‹Œ¯ ‡E  Š„ ‡D  Š„ ‡C  ‰{ ‡B  ˆv ‡A  ‡q ‡@  †óh ‡?  …0 ‡>  „" ‡=  ƒ  ‡<  ƒ" ‡;  ‚O ‡:  O ‡9  ~€L ‡8  ~L ‡7  }, ‡6  |€Ú ‡5  {5 ‡4  z( ‡3  ya ‡2  x|3 ‡1  x3 ‡0  vw ‡/  v0 ‡.  v  ‡-  u$ ‡,  t T½öìâØÎĺ°¦œ’ˆ~tj`VLB8.$üòéßÖÌù°¦œ’ˆ~tj`VLB8.$üòèÞÔÊÀ¶¬¢˜Ž„zqg]SI?5+! ùïåÛÑǽ•0ÿ•/ÿÑ•.ÿH•-ÿÑ•,ÿ•+ÿÑ•*ÿ•)ÿÑ•(ÿ•'ÿÑ•&ÿ•%ÿÑ•$ÿ•#ÿÑ•"ÿ•!ÿÑ• ÿ•ÿç•ÿ•ÿ•ÿ•ÿÑ•ÿ•ÿÑ•ÿG•ÿF•ÿE•ÿD•ÿC•ÿ™•ÿœ•ÿ]•ÿœ•ÿB•ÿA• ÿ@• ÿ?• ÿ>• ÿ=• ÿ<•ÿ;•ÿ:•ÿ9•ÿ•ÿ•ÿ•ÿ•ÿ•ÿ”ÿÿ”~ÿ=”}ÿþ”|ÿ=”{ÿû”zÿ=”yÿú”xÿ=”wÿù”vÿ´”uÿÑ”tÿL”sÿø”rÿÙ”qÿÙ”pÿÙ”oÿÙ”nÿ÷”mÿö”lÿõ”kÿô”jÿó”iÿò”hÿñ”gÿð”fÿï”eÿî”dÿí”cÿì”bÿë”aÿê”`ÿé”_ÿ8”^ÿæ”]ÿç RÊ–V$æÁšwEá©~L%ü£yR$ƒn3%classstd_1_1istreamstd::istream'ƒm7'classstd_1_1ios__basestd::ios_baseƒl+classstd_1_1iosstd::ios7ƒkG7classstd_1_1invalid__argumentstd::invalid_argument&ƒj5'classstd_1_1ifstreamstd::ifstream$ƒi3%classstd_1_1fstreamstd::fstream/ƒh?/classstd_1_1forward__liststd::forward_list(ƒg7)classstd_1_1exceptionstd::exception5ƒfE5classstd_1_1error__conditionstd::error_condition+ƒe;+classstd_1_1error__codestd::error_code3ƒdC3classstd_1_1error__categorystd::error_category/ƒc?/classstd_1_1domain__errorstd::domain_error ƒb/!classstd_1_1dequestd::deque$ƒa3%classstd_1_1complexstd::complex"ƒ`1#classstd_1_1bitsetstd::bitset;ƒ_K;classstd_1_1basic__stringstreamstd::basic_stringstream/ƒ^?/classstd_1_1basic__stringstd::basic_string=ƒ]M=classstd_1_1basic__ostringstreamstd::basic_ostringstream1ƒ\A1classstd_1_1basic__ostreamstd::basic_ostream3ƒ[C3classstd_1_1basic__ofstreamstd::basic_ofstream :Í›zJ+Ù°‰V#í·”d0åÂl:/„?/classstd_1_1system__errorstd::system_error.„=/classstd_1_1stringstreamstd::stringstream"„1#classstd_1_1stringstd::string „/!classstd_1_1stackstd::stack)„9)classstd_1_1smart__ptrstd::smart_ptrƒ+classstd_1_1setstd::set1ƒ~A1classstd_1_1runtime__errorstd::runtime_error-ƒ}=-classstd_1_1range__errorstd::range_error ƒ|/!classstd_1_1queuestd::queue3ƒ{C3classstd_1_1priority__queuestd::priority_queue3ƒzC3classstd_1_1overflow__errorstd::overflow_error0ƒyA/classstd_1_1out__of__rangestd::out_of_range0ƒx?1classstd_1_1ostringstreamstd::ostringstream$ƒw3%classstd_1_1ostreamstd::ostream&ƒv5'classstd_1_1ofstreamstd::ofstream&ƒu5'classstd_1_1multisetstd::multiset&ƒt5'classstd_1_1multimapstd::multimapƒs+classstd_1_1mapstd::map-ƒr=-classstd_1_1logic__errorstd::logic_errorƒq-classstd_1_1liststd::list/ƒp?/classstd_1_1length__errorstd::length_error0ƒo?1classstd_1_1istringstreamstd::istringstream cÛ£uAÅ‘hCðŤ{Fò½–c0„?1classstd_1_1wstringstreamstd::wstringstream$„3%classstd_1_1wstringstd::wstring2„A3classstd_1_1wostringstreamstd::wostringstream&„5'classstd_1_1wostreamstd::wostream(„7)classstd_1_1wofstreamstd::wofstream2„A3classstd_1_1wistringstreamstd::wistringstream&„5'classstd_1_1wistreamstd::wistream„-classstd_1_1wiosstd::wios(„7)classstd_1_1wifstreamstd::wifstream&„5'classstd_1_1wfstreamstd::wfstream'„7'classstd_1_1weak__ptrstd::weak_ptr"„ 1#classstd_1_1vectorstd::vector&„ 5'classstd_1_1valarraystd::valarray1„ A1classstd_1_1unordered__setstd::unordered_set;„ K;classstd_1_1unordered__multisetstd::unordered_multiset;„ K;classstd_1_1unordered__multimapstd::unordered_multimap1„A1classstd_1_1unordered__mapstd::unordered_map+„;+classstd_1_1unique__ptrstd::unique_ptr5„E5classstd_1_1underflow__errorstd::underflow_error"„1#classstd_1_1threadstd::thread Vɪp;ìÏ›c;ú»~_%ô¡VH„)WIclassdai_1_1greedyVariableEliminationdai::greedyVariableEliminationP„(_Qclassdai_1_1sequentialVariableEliminationdai::sequentialVariableElimination.„'=/classdai_1_1ClusterGraphdai::ClusterGraph7„&I5structdai_1_1CBP_1_1Propertiesdai::CBP::Properties„%+classdai_1_1CBPdai::CBP:„$M 7structdai_1_1BP__dual_1_1beliefsdai::BP_dual::beliefs<„#O 9structdai_1_1BP__dual_1_1messagesdai::BP_dual::messages>„"S 9structdai_1_1BP__dual_1_1__edges__tdai::BP_dual::_edges_t%„!5%classdai_1_1BP__dualdai::BP_dual5„ G3structdai_1_1BP_1_1Propertiesdai::BP::Properties1„C /structdai_1_1BP_1_1EdgePropdai::BP::EdgeProp„)classdai_1_1BPdai::BPL„]Istructdai_1_1BipartiteGraph_1_1levelTypedai::BipartiteGraph::levelType2„A3classdai_1_1BipartiteGraphdai::BipartiteGraph7„I5structdai_1_1BBP_1_1Propertiesdai::BBP::Properties„+classdai_1_1BBPdai::BBP4„C5classdai_1_1BBPCostFunctiondai::BBPCostFunction gчhCߢi0 ä»wL%ö×­†g„=+classdai_1_1HAKdai::HAK$„<3%classdai_1_1GraphALdai::GraphAL'„;7'structdai_1_1Neighbordai::Neighbor„:+classdai_1_1FBPdai::FBP,„9;-classdai_1_1FactorGraphdai::FactorGraph$„83%classdai_1_1TFactordai::TFactor(„77)classdai_1_1Exceptiondai::ExceptionA„6S?structdai_1_1ExactInf_1_1Propertiesdai::ExactInf::Properties&„55'classdai_1_1ExactInfdai::ExactInf&„45'classdai_1_1Evidencedai::Evidence „3/!classdai_1_1EMAlgdai::EMAlg6„2E7classdai_1_1MaximizationStepdai::MaximizationStep6„1E7classdai_1_1SharedParametersdai::SharedParameters:„0I;classdai_1_1CondProbEstimationdai::CondProbEstimation<„/K=classdai_1_1ParameterEstimationdai::ParameterEstimation"„.1#classdai_1_1DAIAlgdai::DAIAlg"„-1#classdai_1_1InfAlgdai::InfAlg„,+classdai_1_1DAGdai::DAGG„+YEstructdai_1_1CobwebGraph_1_1Connectiondai::CobwebGraph::Connection,„*;-classdai_1_1CobwebGraphdai::CobwebGraph +uëÖÁ¬—‚mXC.ïÚÅ°›†q\G2óÞÉ´ŸŠu`K6! ÷âÍ·¡‹u%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai~%namespacedaidai}%namespacedaidai|%namespacedaidai{%namespacedaidaiz%namespacedaidaiy%namespacedaidaix%namespacedaidaiw%namespacedaidaiv%namespacedaidaiu%namespacedaidait%namespacedaidais%namespacedaidair%namespacedaidaiq%namespacedaidaip%namespacedaidaio%namespacedaidain%namespacedaidaim%namespacedaidail%namespacedaidaik%namespacedaidaij%namespacedaidaii%namespacedaidaih%namespacedaidaig%namespacedaidaif%namespacedaidaie%namespacedaidaid%namespacedaidaic%namespacedaidaib%namespacedaidaia%namespacedaidai`%namespacedaidai_%namespacedaidai^%namespacedaidai]%namespacedaidai\%namespacedaidai[%namespacedaidaiZ%namespacedaidaiY%namespacedaidai YÆvM*ɬtWÊ¥~W0à·ŠY.„S?-structdai_1_1fo__divides0dai::fo_divides0*„R;)structdai_1_1fo__plog0pdai::fo_plog0p&„Q7%structdai_1_1fo__inv0dai::fo_inv0$„P5#structdai_1_1fo__invdai::fo_inv&„O7%structdai_1_1fo__log0dai::fo_log0$„N5#structdai_1_1fo__logdai::fo_log$„M5#structdai_1_1fo__expdai::fo_exp$„L5#structdai_1_1fo__absdai::fo_abs"„K3!structdai_1_1fo__iddai::fo_id5„JG3structdai_1_1MR_1_1Propertiesdai::MR::Properties„I)classdai_1_1MRdai::MR5„HG3structdai_1_1MF_1_1Propertiesdai::MF::Properties„G)classdai_1_1MFdai::MF5„FG3structdai_1_1LC_1_1Propertiesdai::LC::Properties„E)classdai_1_1LCdai::LC;„DM9structdai_1_1JTree_1_1Propertiesdai::JTree::Properties „C/!classdai_1_1JTreedai::JTree „B/!classdai_1_1Statedai::State&„A5'classdai_1_1multifordai::multifor$„@3%classdai_1_1Permutedai::Permute&„?5'classdai_1_1IndexFordai::IndexFor7„>I5structdai_1_1HAK_1_1Propertiesdai::HAK::Properties _Û¨Z3á²f7å„a>ᾄ_"„l1#classdai_1_1TreeEPdai::TreeEP„k#classFactorFactor„j+!classStateDenseStateDense „i-#classStateSparseStateSparse „h-#classStateFactorStateFactor„g#classFactorFactor„f+!classStateDenseStateDense „e-#classStateSparseStateSparse „d-#classStateFactorStateFactor„c#classFactorFactor"„b/%classSparseFactorSparseFactor „a-#classDenseFactorDenseFactor&„`3)classAbstractFactorAbstractFactor&„_5'classdai_1_1SmallSetdai::SmallSet,„^;-classdai_1_1RegionGraphdai::RegionGraph$„]3%classdai_1_1FRegiondai::FRegion"„\1#classdai_1_1Regiondai::Region,„[;-classdai_1_1PropertySetdai::PropertySet „Z/!classdai_1_1TProbdai::TProb,„Y=+structdai_1_1fo__absdiffdai::fo_absdiff$„X5#structdai_1_1fo__mindai::fo_min$„W5#structdai_1_1fo__maxdai::fo_max$„V5#structdai_1_1fo__powdai::fo_pow0„UA/structdai_1_1fo__Hellingerdai::fo_Hellinger"„T3!structdai_1_1fo__KLdai::fo_KL äÀzW-éÆ£|Iä5„xE5classdai_1_1__builtinInfAlgsdai::_builtinInfAlgs*„w9+classdai_1_1RootedTreedai::RootedTree0„v?1classdai_1_1WeightedGraphdai::WeightedGraph$„u3%classdai_1_1GraphELdai::GraphEL „t/!classdai_1_1UEdgedai::UEdge „s/!classdai_1_1DEdgedai::DEdge"„r1#classdai_1_1VarSetdai::VarSet„q+classdai_1_1Vardai::Var'„p7'classdai_1_1hash__mapdai::hash_map „o/!classdai_1_1TRWBPdai::TRWBPC„nSAclassdai_1_1TreeEP_1_1TreeEPSubTreedai::TreeEP::TreeEPSubTree=„mO;structdai_1_1TreeEP_1_1Propertiesdai::TreeEP::Properties :êÔ¾¨’|fP: %namespacedaidai %namespacedaidai %namespacedaidai %namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidai%namespacedaidailibDAI-0.3.2/doc/html/0000755000175000017500000000000012552201370013676 5ustar jorismjorismlibDAI-0.3.2/doc/html/classdai_1_1SmallSet.html0000644000175000017500000022454212552201370020465 0ustar jorismjorism libDAI: dai::SmallSet< T > Class Template Reference
Public Types | Private Attributes | List of all members
dai::SmallSet< T > Class Template Reference

Represents a set; the implementation is optimized for a small number of elements. More...

#include <dai/smallset.h>

Public Types

typedef std::vector< T >::const_iterator const_iterator
 Constant iterator over the elements. More...
 
typedef std::vector< T >::iterator iterator
 Iterator over the elements. More...
 
typedef std::vector< T >::const_reverse_iterator const_reverse_iterator
 Constant reverse iterator over the elements. More...
 
typedef std::vector< T >::reverse_iterator reverse_iterator
 Reverse iterator over the elements. More...
 

Public Member Functions

Constructors and destructors
 SmallSet ()
 Default constructor (constructs an empty set) More...
 
 SmallSet (const T &t)
 Construct a set consisting of one element. More...
 
 SmallSet (const T &t1, const T &t2)
 Construct a set consisting of two elements. More...
 
template<typename TIterator >
 SmallSet (TIterator begin, TIterator end, size_t sizeHint)
 Construct a SmallSet from a range of elements. More...
 
Operators for set-theoretic operations
SmallSet & insert (const T &t)
 Inserts t into *this. More...
 
SmallSet & erase (const T &t)
 Erases t from *this. More...
 
SmallSet operator/ (const SmallSet &x) const
 Set-minus operator: returns all elements in *this, except those in x. More...
 
SmallSet operator| (const SmallSet &x) const
 Set-union operator: returns all elements in *this, plus those in x. More...
 
SmallSet operator& (const SmallSet &x) const
 Set-intersection operator: returns all elements in *this that are also contained in x. More...
 
SmallSet & operator/= (const SmallSet &x)
 Erases from *this all elements in x. More...
 
SmallSet & operator/= (const T &t)
 Erases one element. More...
 
SmallSet & operator|= (const SmallSet &x)
 Adds to *this all elements in x. More...
 
SmallSet & operator|= (const T &t)
 Adds one element. More...
 
SmallSet & operator&= (const SmallSet &x)
 Erases from *this all elements not in x. More...
 
bool operator<< (const SmallSet &x) const
 Returns true if *this is a subset of x. More...
 
bool operator>> (const SmallSet &x) const
 Returns true if x is a subset of *this. More...
 
Queries
bool intersects (const SmallSet &x) const
 Returns true if *this and x have elements in common. More...
 
bool contains (const T &t) const
 Returns true if *this contains the element t. More...
 
std::vector< T >::size_type size () const
 Returns number of elements. More...
 
bool empty () const
 Returns whether *this is empty. More...
 
std::vector< T > & elements ()
 Returns reference to the elements. More...
 
const std::vector< T > & elements () const
 Returns constant reference to the elements. More...
 
Iterator interface
iterator begin ()
 Returns iterator that points to the first element. More...
 
const_iterator begin () const
 Returns constant iterator that points to the first element. More...
 
iterator end ()
 Returns iterator that points beyond the last element. More...
 
const_iterator end () const
 Returns constant iterator that points beyond the last element. More...
 
reverse_iterator rbegin ()
 Returns reverse iterator that points to the last element. More...
 
const_reverse_iterator rbegin () const
 Returns constant reverse iterator that points to the last element. More...
 
reverse_iterator rend ()
 Returns reverse iterator that points beyond the first element. More...
 
const_reverse_iterator rend () const
 Returns constant reverse iterator that points beyond the first element. More...
 
T & front ()
 Returns reference to first element. More...
 
const T & front () const
 Returns constant reference to first element. More...
 
T & back ()
 Returns reference to last element. More...
 
const T & back () const
 Returns constant reference to last element. More...
 

Private Attributes

std::vector< T > _elements
 The elements in this set. More...
 

Friends

Comparison operators
bool operator== (const SmallSet &a, const SmallSet &b)
 Returns true if a and b are identical. More...
 
bool operator!= (const SmallSet &a, const SmallSet &b)
 Returns true if a and b are not identical. More...
 
bool operator< (const SmallSet &a, const SmallSet &b)
 Lexicographical comparison of elements. More...
 

Input/output

std::string toString () const
 Formats a SmallSet as a string. More...
 
std::ostream & operator<< (std::ostream &os, const SmallSet &x)
 Writes a SmallSet to an output stream. More...
 

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
TShould 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
TIteratorIterates over instances of type T.
Parameters
beginPoints to first element to be added.
endPoints just beyond last element to be added.
sizeHintFor 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.

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.

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.

template<typename T>
std::string dai::SmallSet< T >::toString ( ) const
inline

Formats a SmallSet as a string.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_104.png0000644000175000017500000000275212552200242015736 0ustar jorismjorism‰PNG  IHDR$eŸÕÜ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïYIDATxíÙšê8 „¯Ù€¼ÿÛŽ$;+¡½Ìaδ¿$N¼¨\*Ýüà%2À_‚°EhÛv}ì‘s·<¸|uöøéjPÛ¶«ë=i 5°U|SóyÇl­Çáxÿ¡_?bZû8F”é®eâË8vgðgáB‰¥ñ{¤q¬áO7£$7k)lÐuX;ß„=Å àF-±„¼Ÿhæãcb\°6M–d¥&«ÑtÃí´ 1b^Âõ²zht ›Í5‡èº)ßï>råH-– QÄNéÉÍ*–g‰±¬˜‰ÑyËçÝ~§ßNÌžt?Uw˜ºíKž„r/Ùd®±ÄRrjm%O“×Gæn„Y¯HE^¿–ëÛˆÑçü¼gÁ?Ê祔¤UW31W™GbY‹ÿœ˜fæêäªõFíþybƘf:$]7Ä´°u›vÖªM˜ªmÙÛe€ÑéSôi1’‹ô5½äŽY¯ÏQÆÙì㲋1‘Vëoä»ðô°<“‚Eë:GoYëõL•S/[°žÉAÉÑ_†™C'ã¦QúEæÚfï¤é®&ÖV±<¡˜6^=×F`÷ÈW^"¦qc¤•Ó´}KA2B,À } hÈge§q4J'bôvá¥~Ô^EÖ„ Âð7³Ø‰·øŠvBLè$-…òpH À)N‰ QÒ°×uJ˜·ÔQŽ×/4,#FþŠæë_%Fó:]½5£©mþfÅáÇܼh±V„–$¯Üœà<•Œ|qðšÚóò+G+qwʇ½¶TÒ]éáWw])¦‘dši«šJô çt%·,÷Ybä>É"£$ô¶.s8Á91•ü¾1&ê†Í-ô1×÷Þ[Ùk%ft⪖8euœ¸gjºio½·˜Í£$ôjW¥sã'{c*—inN7¹¼8£ù%b*ù×’æºáPÚU:Rœ\±ðVâŸ! -ÖU¶5—ëÐ('ò¶Ò®‘:…0©;¾¼ªt>¬¦'#£ÕÙ¬"+KS´ÒïÓ¦¬á”å#HŽš(ÅêuÉlí¦=ݶXY¾wÑmñ¿n—æ¥ Á6­Åk±«R¬ÊàÓ#~J{/ðmicÖÎp®˜õÇÙ ¶Ê²Ta`¹b.<™*ŠRŠóùeOÎd)%îh–RQÛŠ`€亄ý¶ö”†ùà=‘úHždÝh|ž™@”R§É=±ÎÝY_a£×ß7'ÆÓ†Všp!A˜Ê¿ sƒÎ`$%Ñ…/¤xëíìÑT•$ÏÞW=Mi*=q @ú>ÃÐIj“#÷:M®¹mbU•²oæð–p9Íbñ&²ïD9N=àEĆ›pÐN™¤âŸdvžT…ZöŠÅ¿dò? g»örIJ婦¦)^@Ê­ d0‹JùSûr…wM5–p1¿yoÉÃR]W~UäÙx^ò«T$¡£YØx÷ªð³È¡$Ú¯W•'1}€ÿ1â§K\mÿº# ±¢`IEND®B`‚libDAI-0.3.2/doc/html/functions_func_v.html0000644000175000017500000001374112552201370020142 0ustar jorismjorism libDAI: Class Members - Functions
 

- v -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1Var.html0000644000175000017500000006540312552201370017470 0ustar jorismjorism libDAI: dai::Var Class Reference
Public Member Functions | Private Attributes | Friends | List of all members
dai::Var Class Reference

Represents a discrete random variable. More...

#include <dai/var.h>

Public Member Functions

 Var ()
 Default constructor (creates a variable with label 0 and 0 states) More...
 
 Var (size_t label, size_t states)
 Constructs a variable with a given label and number of states. More...
 
size_t label () const
 Returns the label. More...
 
size_t & label ()
 Returns reference to label. More...
 
size_t states () const
 Returns the number of states. More...
 
size_t & states ()
 Returns reference to number of states. More...
 
bool operator< (const Var &n) const
 Smaller-than operator (only compares labels) More...
 
bool operator> (const Var &n) const
 Larger-than operator (only compares labels) More...
 
bool operator<= (const Var &n) const
 Smaller-than-or-equal-to operator (only compares labels) More...
 
bool operator>= (const Var &n) const
 Larger-than-or-equal-to operator (only compares labels) More...
 
bool operator!= (const Var &n) const
 Not-equal-to operator (only compares labels) More...
 
bool operator== (const Var &n) const
 Equal-to operator (only compares labels) More...
 
std::string toString () const
 Formats a Var as a string. More...
 

Private Attributes

size_t _label
 Label of the variable (its unique ID) More...
 
size_t _states
 Number of possible values. More...
 

Friends

std::ostream & operator<< (std::ostream &os, const Var &n)
 Writes a Var to an output stream. More...
 

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.

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)

std::string dai::Var::toString ( ) const
inline

Formats a Var as a string.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_122.png0000644000175000017500000000121612552200247015735 0ustar jorismjorism‰PNG  IHDRr$bÔž¥0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïýIDATxíë’â …¿$&öû¿í6gH”ÒĪݪ¡8–­ §¯‡¿¿ø'ásÎí> ¯:ÆûUø,²jcÉœ>ŒY/­9Ä«êˆjlM€Cˆñeu‚ª8¯bÔ+À›†ÐšîIßèÁ«NσoÍi`.?øš™dîÞ'ìîË”NµWq¹8isæ[w™¾=‘ºvQŠ¯ `¸™”M?'¤Mdm5ûÌOOÚPÖqþàlÎì!û­¶Óø=M2ÖuOÕ;zâ{ýãKôÂ4Ü|µRJ™QËŸòゆ—#à®ÝG®‚‹É1–µa“})á,5ć´…n.ÛsûNY=Ö?ý¦§³ð•E€¿ÆòÆÛÒ*Ñ¿N@SÚœðˆ Å=É?AÚyêˆÂÆ-€jX¹|U;Œk'<ªÚl€CDÚ ð €ÿ¡\Lr: pÎ.„mÇ”!µÛÊôÍ9Š_úr3³l*-À¡h_t>›ØtDàÈã%Ùpcd‘MÄ”z9úXè¦S'Æ¢JӵܫBH&s–J#^ EZ¨íº8ÑÚ㦮n1>w£,4Á**¸«2À1”æ0¦RÊK¦f™Fs$†PJyr-K9×ƱŽÝ ¶ñÔéð§OIç@#ª>œ<#?ÀºÈ OŸdOIEND®B`‚libDAI-0.3.2/doc/html/arrowright.png0000644000175000017500000000034512552201363016600 0ustar jorismjorism‰PNG  IHDRɪ|¬IDATxí=QF‘Ø¥D«ÔkÄ:‰F©PK؃=V@§Õ³ Õ8SHxñÌ0bnrróŠ{ò½¿¾’$ ÀÏTŠP  ö¼X¬OÛd6êìòð"°²S´±O¥B€(¡àQé)š+YĈ ÒªËRÉÐ>VtÉsˆm9(ê„䜥k‚-@ȧ-Ü$ó b Ò[he ¿Kp-ôl|CùÿApRG'rÍ­aIEND®B`‚libDAI-0.3.2/doc/html/form_119.png0000644000175000017500000000034412552200246015743 0ustar jorismjorism‰PNG  IHDRãÊF0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïSIDATxíQÀ CŸˆÓ-Îûw¸,ȯ@xM[Â6¨– ¡©«œ¡¶e]\Ör |#VK÷/Ëp9äåö‰w¥=×¥·^Â&€-x/ø!ÅܤIEND®B`‚libDAI-0.3.2/doc/html/dir_218a9e3cb5b25b749a8b0dc29285ef3b.html0000644000175000017500000000736112552201370022072 0ustar jorismjorism libDAI: src/matlab Directory Reference
matlab Directory Reference

Files

file  dai.cpp
 
file  dai_jtree.cpp
 
file  dai_potstrength.cpp
 
file  dai_readfg.cpp
 
file  dai_writefg.cpp
 
file  matlab.cpp
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1InfAlg-members.html0000644000175000017500000002700612552201366021532 0ustar jorismjorism 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::InfAlgpure virtual
backupFactors(const VarSet &vs)=0dai::InfAlgpure virtual
belief(const Var &v) const dai::InfAlginlinevirtual
belief(const VarSet &vs) const =0dai::InfAlgpure virtual
beliefF(size_t I) const dai::InfAlginlinevirtual
beliefs() const =0dai::InfAlgpure virtual
beliefV(size_t i) const dai::InfAlginlinevirtual
clamp(size_t i, size_t x, bool backup=false)=0dai::InfAlgpure virtual
clone() const =0dai::InfAlgpure virtual
construct(const FactorGraph &fg, const PropertySet &opts) const =0dai::InfAlgpure virtual
fg()=0dai::InfAlgpure virtual
fg() const =0dai::InfAlgpure virtual
findMaximum() const dai::InfAlginlinevirtual
getProperties() const =0dai::InfAlgpure virtual
identify() const dai::InfAlginlinevirtual
init()=0dai::InfAlgpure virtual
init(const VarSet &vs)=0dai::InfAlgpure virtual
Iterations() const dai::InfAlginlinevirtual
logZ() const =0dai::InfAlgpure virtual
makeCavity(size_t i, bool backup=false)=0dai::InfAlgpure virtual
makeRegionCavity(std::vector< size_t > facInds, bool backup=false)=0dai::InfAlgpure virtual
maxDiff() const dai::InfAlginlinevirtual
name() const =0dai::InfAlgpure virtual
printProperties() const =0dai::InfAlgpure virtual
restoreFactor(size_t I)=0dai::InfAlgpure virtual
restoreFactors(const VarSet &vs)=0dai::InfAlgpure virtual
run()=0dai::InfAlgpure virtual
setMaxIter(size_t)dai::InfAlginlinevirtual
setProperties(const PropertySet &opts)=0dai::InfAlgpure virtual
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/prob_8h.html0000644000175000017500000003171112552201363016132 0ustar jorismjorism libDAI: include/dai/prob.h File Reference
Classes | Namespaces | Typedefs
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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

Typedefs

typedef TProb< Real > dai::Prob
 Represents a vector with entries of type dai::Real. More...
 

Detailed Description

Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables)

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/dai__config_8h.html0000644000175000017500000000550212552201363017410 0ustar jorismjorism libDAI: include/dai/dai_config.h File Reference
Macros
dai_config.h File Reference

Allows the user to specify which algorithms will be built into libDAI. More...

Go to the source code of this file.

Detailed Description

Allows the user to specify which algorithms will be built into libDAI.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/example_8cpp-example.html0000644000175000017500000007207512552201363020617 0ustar jorismjorism 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/
*
* Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
*/
#include <iostream>
#include <map>
#include <dai/alldai.h> // Include main libDAI header file
#include <dai/jtree.h>
#include <dai/bp.h>
#include <dai/decmap.h>
using namespace dai;
using namespace std;
int main( int argc, char *argv[] ) {
#if defined(DAI_WITH_BP) && defined(DAI_WITH_JTREE)
if ( argc != 2 && argc != 3 ) {
cout << "Usage: " << argv[0] << " <filename.fg> [maxstates]" << endl << endl;
cout << "Reads factor graph <filename.fg> and runs" << endl;
cout << "Belief Propagation, Max-Product and JunctionTree on it." << endl;
cout << "JunctionTree is only run if a junction tree is found with" << endl;
cout << "total number of states less than <maxstates> (where 0 means unlimited)." << endl << endl;
return 1;
} else {
// Report inference algorithms built into libDAI
cout << "Builtin inference algorithms: " << builtinInfAlgNames() << endl << endl;
// Read FactorGraph from the file specified by the first command line argument
FactorGraph fg;
fg.ReadFromFile(argv[1]);
size_t maxstates = 1000000;
if( argc == 3 )
maxstates = fromString<size_t>( argv[2] );
// 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)
// Bound treewidth for junctiontree
bool do_jt = true;
try {
boundTreewidth(fg, &eliminationCost_MinFill, maxstates );
} catch( Exception &e ) {
if( e.getCode() == Exception::OUT_OF_MEMORY ) {
do_jt = false;
cout << "Skipping junction tree (need more than " << maxstates << " states)." << endl;
}
else
throw;
}
JTree jt, jtmap;
vector<size_t> jtmapstate;
if( do_jt ) {
// 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
jt = JTree( 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)
jtmap = JTree( 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
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();
if( do_jt ) {
// 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
if( do_jt ) {
// 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
if( do_jt ) {
// 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;
if( do_jt ) {
// 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;
if( do_jt ) {
// 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;
if( do_jt ) {
// 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;
#else
cout << "libDAI was configured without BP or JunctionTree (this can be changed in include/dai/dai_config.h)." << endl;
#endif
}
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/smallset_8h.html0000644000175000017500000001047512552201363017020 0ustar jorismjorism libDAI: include/dai/smallset.h File Reference
Classes | Namespaces
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>
#include <sstream>

Go to the source code of this file.

Classes

class  dai::SmallSet< T >
 Represents a set; the implementation is optimized for a small number of elements. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines the SmallSet<> class, which represents a set (optimized for a small number of elements).

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1CobwebGraph-members.html0000644000175000017500000007553112552201364022561 0ustar jorismjorism libDAI: Member List
dai::CobwebGraph Member List

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

_cndai::CobwebGraphprotected
_EXRsdai::CobwebGraphprotected
_INRsdai::CobwebGraphprotected
_Mdai::CobwebGraphprotected
_outMdai::CobwebGraphprotected
_Rfsdai::CobwebGraphprotected
_Rifsdai::CobwebGraphprotected
_Rxfsdai::CobwebGraphprotected
_var2CWdai::CobwebGraphprotected
backupFactor(size_t I)dai::FactorGraph
backupFactors(const std::set< size_t > &facs)dai::FactorGraphvirtual
backupFactors(const VarSet &ns)dai::FactorGraph
bipGraph() const dai::FactorGraphinline
checkPartition(const std::vector< SmallSet< size_t > > &regions) const dai::CobwebGraphprotected
clamp(size_t i, size_t x, bool backup=false)dai::FactorGraphvirtual
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::CobwebGraphinlinevirtual
cn(size_t R) const dai::CobwebGraphinline
cn(size_t R)dai::CobwebGraphinline
CobwebGraph()dai::CobwebGraphinline
CobwebGraph(const FactorGraph &fg)dai::CobwebGraphinline
DAI_ENUM(NeighborType, ALL, TOP, CLOSEST)dai::CobwebGraph
Delta(size_t i) const dai::FactorGraph
Delta(const VarSet &vs) const dai::FactorGraph
delta(size_t i) const dai::FactorGraphinline
delta(const VarSet &vs) const dai::FactorGraphinline
Deltai(size_t i) const dai::FactorGraph
deltai(size_t i) const dai::FactorGraphinline
eraseNonMaximal(std::vector< SmallSet< size_t > > &regions)dai::CobwebGraphprotected
EXRs(size_t R) const dai::CobwebGraphinline
EXRs(size_t R)dai::CobwebGraphinline
factor(size_t I) const dai::FactorGraphinline
FactorGraph()dai::FactorGraphinline
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
factors() const dai::FactorGraphinline
findFactor(const VarSet &ns) const dai::FactorGraphinline
findVar(const Var &n) const dai::FactorGraphinline
findVars(const VarSet &ns) const dai::FactorGraphinline
fromString(const std::string &s)dai::FactorGraphinline
inds2vars(const std::vector< size_t > &inds) const dai::FactorGraphinline
INRs(size_t R) const dai::CobwebGraphinline
INRs(size_t R)dai::CobwebGraphinline
isBinary() const dai::FactorGraph
isConnected() const dai::FactorGraphinline
isMaximal(size_t I) const dai::FactorGraph
isPairwise() const dai::FactorGraph
isPartitiondai::CobwebGraphprotected
isTree() const dai::FactorGraphinline
logScore(const std::vector< size_t > &statevec) const dai::FactorGraph
M(size_t R, size_t i) const dai::CobwebGraphinline
M(size_t R, size_t i)dai::CobwebGraphinline
M(size_t R) const dai::CobwebGraphinline
M(size_t R)dai::CobwebGraphinline
makeCavity(size_t i, bool backup=false)dai::FactorGraphvirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::FactorGraphvirtual
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::FactorGraphinline
nbF(size_t I, size_t _i) const dai::FactorGraphinline
nbV(size_t i) const dai::FactorGraphinline
nbV(size_t i, size_t _I) const dai::FactorGraphinline
nrCWs() const dai::CobwebGraphinline
nrEdges() const dai::FactorGraphinline
nrFactors() const dai::FactorGraphinline
nrVars() const dai::FactorGraphinline
operator<<(std::ostream &, const CobwebGraph &)dai::CobwebGraphfriend
outM(size_t R) const dai::CobwebGraphinline
outM(size_t R)dai::CobwebGraphinline
outM(size_t R, size_t j) const dai::CobwebGraphinline
outM(size_t R, size_t j)dai::CobwebGraphinline
printDot(std::ostream &) const dai::CobwebGraphinlinevirtual
ReadFromFile(const char *)dai::CobwebGraphinlinevirtual
restoreFactor(size_t I)dai::FactorGraph
restoreFactors()dai::FactorGraphvirtual
restoreFactors(const VarSet &ns)dai::FactorGraph
Rfs(size_t R) const dai::CobwebGraphinline
Rfs(size_t R)dai::CobwebGraphinline
setCountingNumbers(bool debugging=false)dai::CobwebGraphprotected
setExtnFact()dai::CobwebGraphprotected
setFactor(size_t I, const Factor &newFactor, bool backup=false)dai::FactorGraphinlinevirtual
setFactors(const std::map< size_t, Factor > &facs, bool backup=false)dai::FactorGraphinlinevirtual
setMSGs(NeighborType neighbors)dai::CobwebGraphprotected
setRgn(std::vector< SmallSet< size_t > > regions, NeighborType neighbors, bool debugging=false)dai::CobwebGraph
setVar2CW()dai::CobwebGraphprotected
toString() const dai::CobwebGraphinline
var(size_t i) const dai::FactorGraphinline
var2CW(size_t i) const dai::CobwebGraphinline
vars() const dai::FactorGraphinline
WriteToFile(const char *, size_t=15) const dai::CobwebGraphinlinevirtual
~FactorGraph()dai::FactorGraphinlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/namespacedai.html0000644000175000017500000072760512552201364017222 0ustar jorismjorism libDAI: dai Namespace Reference
Classes | Typedefs | Enumerations | Functions | Variables
dai Namespace Reference

Namespace for libDAI. More...

Classes

class  BBP
 Implements BBP (Back-Belief-Propagation) [EaG09]. More...
 
class  BBPCostFunction
 Predefined cost functions that can be used with BBP. 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  CobwebGraph
 A CobwebGraph is a special type of region graph used by the GLC algorithm. More...
 
class  CondProbEstimation
 Estimates the parameters of a conditional probability table, using pseudocounts. More...
 
class  DAG
 Represents the neighborhood structure of nodes in a directed cyclic graph. More...
 
class  DAIAlg
 Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph). More...
 
class  DEdge
 Represents a directed edge. 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  FactorGraph
 Represents a factor graph. More...
 
class  FBP
 Approximate inference algorithm "Fractional Belief Propagation" [WiH03]. More...
 
struct  fo_abs
 Function object that takes the absolute value. More...
 
struct  fo_absdiff
 Function object that returns the absolute difference of x and y. More...
 
struct  fo_divides0
 Function object similar to std::divides(), but different in that dividing by zero results in zero. More...
 
struct  fo_exp
 Function object that takes the exponent. More...
 
struct  fo_Hellinger
 Function object useful for calculating the Hellinger distance. More...
 
struct  fo_id
 Function object that returns the value itself. 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_KL
 Function object useful for calculating the KL distance. 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_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_plog0p
 Function object that returns p*log0(p) More...
 
struct  fo_pow
 Function object that returns x to the power y. More...
 
class  FRegion
 An FRegion is a factor with a counting number. More...
 
class  GraphAL
 Represents the neighborhood structure of nodes in an undirected graph. More...
 
class  GraphEL
 Represents an undirected graph, implemented as a std::set of undirected edges. More...
 
class  greedyVariableElimination
 Helper object for dai::ClusterGraph::VarElim() 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  hash_map
 hash_map is an alias for std::tr1::unordered_map. More...
 
class  IndexFor
 Tool for looping over the states of several variables. More...
 
class  InfAlg
 InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI. More...
 
class  JTree
 Exact inference algorithm using junction tree. More...
 
class  LC
 Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]. More...
 
class  MaximizationStep
 A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. More...
 
class  MF
 Approximate inference algorithm "Mean Field". More...
 
class  MR
 Approximate inference algorithm by Montanari and Rizzo [MoR05]. More...
 
class  multifor
 multifor makes it easy to perform a dynamic number of nested for loops. More...
 
struct  Neighbor
 Describes the neighbor relationship of two nodes in a graph. More...
 
class  ParameterEstimation
 Base class for parameter estimation methods. More...
 
class  Permute
 Tool for calculating permutations of linear indices of multi-dimensional arrays. 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  RegionGraph
 A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph. More...
 
class  RootedTree
 Represents a rooted tree, implemented as a vector of directed edges. More...
 
class  sequentialVariableElimination
 Helper object for dai::ClusterGraph::VarElim() More...
 
class  SharedParameters
 Represents a single factor or set of factors whose parameters should be estimated. More...
 
class  SmallSet
 Represents a set; the implementation is optimized for a small number of elements. More...
 
class  State
 Makes it easy to iterate over all possible joint states of variables within a VarSet. More...
 
class  TFactor
 Represents a (probability) factor. More...
 
class  TProb
 Represents a vector with entries of type T. More...
 
class  TreeEP
 Approximate inference algorithm "Tree Expectation Propagation" [MiQ04]. More...
 
class  TRWBP
 Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]. More...
 
class  UEdge
 Represents an undirected edge. More...
 
class  Var
 Represents a discrete random variable. More...
 
class  VarSet
 Represents a set of variables. More...
 
class  WeightedGraph
 Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights. More...
 

Typedefs

typedef boost::mt19937 _rnd_gen_type
 Type of global random number generator. More...
 
typedef DAIAlg< FactorGraph > DAIAlgFG
 Base class for inference algorithms that operate on a FactorGraph. More...
 
typedef DAIAlg< RegionGraph > DAIAlgRG
 Base class for inference algorithms that operate on a RegionGraph. More...
 
typedef DAIAlg< CobwebGraph > DAIAlgCG
 Base class for GLC that operates on CobwebGraph. More...
 
typedef TFactor< Real > Factor
 Represents a factor with values of type dai::Real. More...
 
typedef std::vector< Neighbor > Neighbors
 Describes the set of neighbors of some node in a graph. More...
 
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. More...
 
typedef TProb< Real > Prob
 Represents a vector with entries of type dai::Real. More...
 
typedef std::string PropertyKey
 Type of the key of a Property. More...
 
typedef boost::any PropertyValue
 Type of the value of a Property. More...
 
typedef std::pair< PropertyKey, PropertyValue > Property
 A Property is a pair of a key and a corresponding value. More...
 
typedef double Real
 Real number (alias for double, which could be changed to long double if necessary) More...
 
typedef mpz_class BigInt
 Arbitrary precision integer number. More...
 

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

std::map< std::string, InfAlg * > & builtinInfAlgs ()
 Returns a map that contains for each built-in inference algorithm its name and a pointer to an object of that type. More...
 
std::set< std::string > builtinInfAlgNames ()
 Returns a set of names of all available inference algorithms. More...
 
InfAlg * newInfAlg (const std::string &name, const FactorGraph &fg, const PropertySet &opts)
 Constructs a new inference algorithm. More...
 
InfAlg * newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg)
 Constructs a new inference algorithm. More...
 
InfAlg * newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg, const std::map< std::string, std::string > &aliases)
 Constructs a new inference algorithm. More...
 
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". More...
 
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. More...
 
std::map< std::string, std::string > readAliasesFile (const std::string &filename)
 Reads aliases from file named filename. More...
 
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. More...
 
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. More...
 
Real unSoftMax (Real a, Real b)
 Computes $\frac{\exp(a)}{\exp(a)+\exp(b)}$. More...
 
Real logSumExp (Real a, Real b)
 Computes log of sum of exponents, i.e., $\log\left(\exp(a) + \exp(b)\right)$. More...
 
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. More...
 
static vector< Factor > mixBeliefs (Real p, const vector< Factor > &b, const vector< Factor > &c)
 Calculates a vector of mixtures p * b + (1-p) * c. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
FactorGraph createFG (const GraphAL &G, FactorType ft, size_t states, const PropertySet &props)
 Creates a factor graph from a pairwise interactions graph. More...
 
FactorGraph createHOIFG (size_t N, size_t M, size_t k, Real beta)
 Return a random factor graph with higher-order interactions. More...
 
BipartiteGraph createRandomBipartiteGraph (size_t N1, size_t N2, size_t d1, size_t d2)
 Creates a regular random bipartite graph. More...
 
int powmod (int x, int n, int p)
 Returns x**n % p, assuming p is prime. More...
 
size_t order (int x, int p)
 Returns order of x in GF(p) with p prime. More...
 
bool isPrime (size_t n)
 Returns whether n is a prime number. More...
 
BipartiteGraph createSmallLDPCGraph ()
 Constructs a regular LDPC graph with N=6, j=2, K=4, k=3. More...
 
BipartiteGraph createGroupStructuredLDPCGraph (size_t p, size_t j, size_t k)
 Creates group-structured LDPC code. More...
 
void createParityCheck (Real *result, size_t n, Real eps)
 
 DAI_ENUM (LDPCType, SMALL, GROUP, RANDOM)
 Possible LDPC structures. More...
 
Factor calcMarginal (const InfAlg &obj, const VarSet &vs, bool reInit)
 Calculates the marginal probability distribution for vs using inference algorithm obj. More...
 
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. More...
 
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. More...
 
Factor createFactorIsing (const Var &x, Real h)
 Returns a binary unnormalized single-variable factor $ \exp(hx) $ where $ x = \pm 1 $. More...
 
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 $. More...
 
Factor createFactorExpGauss (const VarSet &vs, Real beta)
 Returns a random factor on the variables vs with strength beta. More...
 
Factor createFactorPotts (const Var &x1, const Var &x2, Real J)
 Returns a pairwise Potts factor $ \exp( J \delta_{x_1, x_2} ) $. More...
 
Factor createFactorDelta (const Var &v, size_t state)
 Returns a Kronecker delta point mass. More...
 
Factor createFactorDelta (const VarSet &vs, size_t state)
 Returns a Kronecker delta point mass. More...
 
std::ostream & operator<< (std::ostream &os, const FactorGraph &fg)
 Writes a FactorGraph to an output stream. More...
 
std::istream & operator>> (std::istream &is, FactorGraph &fg)
 Reads a FactorGraph from an input stream. More...
 
GraphAL createGraphFull (size_t N)
 Creates a fully-connected graph with N nodes. More...
 
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. More...
 
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. More...
 
GraphAL createGraphLoop (size_t N)
 Creates a graph consisting of a single loop of N nodes. More...
 
GraphAL createGraphTree (size_t N)
 Creates a random tree-structured graph of N nodes. More...
 
GraphAL createGraphRegular (size_t N, size_t d)
 Creates a random regular graph of N nodes with uniform connectivity d. More...
 
template<class T >
TFactor< T > & makePositive (TFactor< T > &f, T epsilon)
 Sets factor entries that lie between 0 and epsilon to epsilon. More...
 
template<class T >
TFactor< T > & makeZero (TFactor< T > &f, T epsilon)
 Sets factor entries that are smaller (in absolute value) than epsilon to 0. More...
 
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. More...
 
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. More...
 
std::pair< size_t, BigInt > 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. More...
 
std::ostream & operator<< (std::ostream &os, const PropertySet &ps)
 Writes a PropertySet object to an output stream. More...
 
std::istream & operator>> (std::istream &is, PropertySet &ps)
 Reads a PropertySet object from an input stream, storing values as strings. More...
 
ostream & operator<< (ostream &os, const RegionGraph &rg)
 Send RegionGraph to output stream. More...
 
bool isnan (Real x)
 Returns true if argument is NAN (Not A Number) More...
 
double toc ()
 Returns wall clock time in seconds. More...
 
_rnd_gen_type _rnd_gen (42U)
 Global random number generator. More...
 
boost::uniform_real< Real > _uni_dist (0, 1)
 Uniform distribution with values between 0 and 1 (0 inclusive, 1 exclusive). More...
 
boost::variate_generator< _rnd_gen_type &, boost::uniform_real< Real > > _uni_rnd (_rnd_gen, _uni_dist)
 Global uniform random random number. More...
 
boost::variate_generator< _rnd_gen_type &, boost::normal_distribution< Real > > _normal_rnd (_rnd_gen, _normal_dist)
 Global random number generator with standard normal distribution. More...
 
void rnd_seed (size_t seed)
 Sets the random seed. More...
 
Real rnd_uniform ()
 Returns a real number, distributed uniformly on [0,1) More...
 
Real rnd_stdnormal ()
 Returns a real number from a standard-normal distribution. More...
 
int rnd_int (int min, int max)
 Returns a random integer in interval [min, max]. More...
 
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. More...
 
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. More...
 
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. More...
 
mxArray * Factors2mx (const std::vector< Factor > &Ps)
 Convert vector<Factor> structure to a cell vector of CPTAB-like structs. More...
 
vector< Factor > mx2Factors (const mxArray *psi, long verbose)
 Convert cell vector of CPTAB-like structs to vector<Factor> More...
 
Factor mx2Factor (const mxArray *psi)
 Convert CPTAB-like struct to Factor. More...
 
 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. More...
 
 DAI_ENUM (FactorType, ISINGGAUSS, ISINGUNIFORM, EXPGAUSS, POTTS)
 Possible factor types. More...
 
size_t BigInt_size_t (const BigInt &N)
 Safe down-cast of big integer to size_t. More...
 
Real log (Real x)
 Returns logarithm of x. More...
 
Real log0 (Real x)
 Returns logarithm of x, or 0 if x == 0. More...
 
Real exp (Real x)
 Returns exponent of x. More...
 
Real pow (Real x, Real y)
 Returns x to the power y. More...
 
template<class T >
T abs (const T &t)
 Returns absolute value of t. More...
 
int rnd (int n)
 Returns a random integer in the half-open interval [0, n) More...
 
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. More...
 
template<class T >
T fromString (const std::string &x)
 Converts a variable of type std::string to T by using a boost::lexical_cast. More...
 
template<class T >
std::ostream & operator<< (std::ostream &os, const std::vector< T > &x)
 Writes a std::vector<> to a std::ostream. More...
 
template<class T >
std::ostream & operator<< (std::ostream &os, const std::set< T > &x)
 Writes a std::set<> to a std::ostream. More...
 
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. More...
 
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. More...
 
template<class T >
std::vector< T > concat (const std::vector< T > &u, const std::vector< T > &v)
 Concatenates two vectors. More...
 
template<typename T >
RootedTree MinSpanningTree (const WeightedGraph< T > &G, bool usePrim)
 Constructs a minimum spanning tree from the (non-negatively) weighted graph G. More...
 
template<typename T >
RootedTree MaxSpanningTree (const WeightedGraph< T > &G, bool usePrim)
 Constructs a minimum spanning tree from the (non-negatively) weighted graph G. More...
 

Variables

static _builtinInfAlgs allBuiltinInfAlgs
 
const char * FULL_TYPE = "FULL"
 Predefined names of various factor graph types. More...
 
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"
 
boost::normal_distribution< Real > _normal_dist
 Normal distribution with mean 0 and standard deviation 1. More...
 

Detailed Description

Namespace for libDAI.

Typedef Documentation

typedef boost::mt19937 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 DAIAlg<CobwebGraph> dai::DAIAlgCG

Base class for GLC that operates on CobwebGraph.

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)

typedef mpz_class dai::BigInt

Arbitrary precision integer number.

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

std::map< std::string, InfAlg * > & dai::builtinInfAlgs ( )

Returns a map that contains for each built-in inference algorithm its name and a pointer to an object of that type.

This functionality is obsolete and will be removed in future versions of libDAI

std::set< std::string > dai::builtinInfAlgNames ( )

Returns a set of names of all available inference algorithms.

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

Constructs a new inference algorithm.

Parameters
nameThe name of the inference algorithm.
fgThe FactorGraph that the algorithm should be applied to.
optsA 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_ALGORITHMif the requested name is not known/compiled in.
InfAlg * dai::newInfAlgFromString ( const std::string &  nameOpts,
const FactorGraph &  fg 
)

Constructs a new inference algorithm.

Parameters
nameOptsThe name and options of the inference algorithm (should be in the format "name[key1=val1,key2=val2,...,keyn=valn]").
fgThe 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_ALGORITHMif the requested name is not known/compiled in.
Examples:
example_imagesegmentation.cpp.
InfAlg * dai::newInfAlgFromString ( const std::string &  nameOpts,
const FactorGraph &  fg,
const std::map< std::string, std::string > &  aliases 
)

Constructs a new inference algorithm.

Parameters
nameOptsThe name and options of the inference algorithm (should be in the format "name[key1=val1,key2=val2,...,keyn=valn]").
fgThe FactorGraph that the algorithm should be applied to.
aliasesMaps 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
filenameName 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.

Examples:
example.cpp.
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.

FactorGraph dai::createFG ( const GraphAL &  G,
FactorType  ft,
size_t  states,
const PropertySet &  props 
)

Creates a factor graph from a pairwise interactions graph.

Parameters
GGraph describing interactions between variables
ftType of factors to use for interactions
statesNumber of states of the variables
propsAdditional properties for generating the interactions
FactorGraph dai::createHOIFG ( size_t  N,
size_t  M,
size_t  k,
Real  beta 
)

Return a random factor graph with higher-order interactions.

Parameters
Nnumber of variables
Mnumber of factors
knumber of variables that each factor depends on
betastandard-deviation of Gaussian log-factor entries
BipartiteGraph dai::createRandomBipartiteGraph ( size_t  N1,
size_t  N2,
size_t  d1,
size_t  d2 
)

Creates a regular random bipartite graph.

Parameters
N1= number of nodes of type 1
d1= size of neighborhoods of nodes of type 1
N2= number of nodes of type 2
d2= size of neighborhoods of nodes of type 2
Note
asserts that N1 * d1 == N2 * d2
int dai::powmod ( int  x,
int  n,
int  p 
)

Returns x**n % p, assuming p is prime.

size_t dai::order ( int  x,
int  p 
)

Returns order of x in GF(p) with p prime.

bool dai::isPrime ( size_t  n)

Returns whether n is a prime number.

BipartiteGraph dai::createSmallLDPCGraph ( )

Constructs a regular LDPC graph with N=6, j=2, K=4, k=3.

BipartiteGraph dai::createGroupStructuredLDPCGraph ( size_t  p,
size_t  j,
size_t  k 
)

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

dai::DAI_ENUM ( LDPCType  ,
SMALL  ,
GROUP  ,
RANDOM   
)

Possible LDPC structures.

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
objinstance of inference algorithm to be used
vsvariables for which the marginal should be calculated
reInitshould 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
objinstance of inference algorithm to be used
vsvariables for which the pair beliefs should be calculated
reInitshould 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).
accurateif 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
xVariable (should be binary)
hField strength
Examples:
example_imagesegmentation.cpp.
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
x1First variable (should be binary)
x2Second variable (should be binary)
JCoupling 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
vsVariables
betaFactor 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
x1First variable
x2Second variable (should have the same number of states as x1)
JFactor strength
Factor dai::createFactorDelta ( const Var &  v,
size_t  state 
)

Returns a Kronecker delta point mass.

Parameters
vVariable
stateThe state of v that should get value 1
Factor dai::createFactorDelta ( const VarSet &  vs,
size_t  state 
)

Returns a Kronecker delta point mass.

Parameters
vsSet of variables
stateThe 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_FILEif 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 
)

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

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

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]filenameThe filename (usually ends with ".uai")
[in]verboseThe amount of output sent to cout
[out]varsArray of variables read from the file
[out]factorsArray of factors read from the file
[out]permutationsArray 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]filenameThe filename (usually ends with ".uai.evid")
[in]verboseThe 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_TYPEif 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_PROPERTYif the string is not in the expected format
ostream& dai::operator<< ( std::ostream &  os,
const RegionGraph &  rg 
)

Send RegionGraph to output stream.

Writes a region graph to an 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
sthe string to be split into tokens
singleDelimif true, any single delimiter forms a boundary between two tokens; if false, a maximal group of consecutive delimiters forms a boundary between two tokens
delimdelimiter 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
vsSet of variables for which the linear state should be calculated;
stateSpecifies 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
vsSet of variables to which linearState refers
linearStateshould 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.
dai::DAI_ENUM ( FactorType  ,
ISINGGAUSS  ,
ISINGUNIFORM  ,
EXPGAUSS  ,
POTTS   
)

Possible factor types.

size_t dai::BigInt_size_t ( const BigInt &  N)
inline

Safe down-cast of big integer to size_t.

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 x to the power y.

We use the convention that division by zero yields zero; for powers, this means that if x == 0.0 and y < 0.0, we return 0.0 instead of generating an error.

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)

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)

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.

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

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

Parameters
GWeighted graph that should have non-negative weights.
usePrimIf 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 
)

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

Parameters
GWeighted graph that should have non-negative weights.
usePrimIf 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

const char* dai::FULL_TYPE = "FULL"

Predefined names of various factor graph types.

boost::normal_distribution<Real> dai::_normal_dist

Normal distribution with mean 0 and standard deviation 1.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1TreeEP_1_1Properties-members.html0000644000175000017500000001053112552201370024440 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_l.html0000644000175000017500000001120712552201370020143 0ustar jorismjorism libDAI: Class Members - Variables
 

- l -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/factorgraph_8h.html0000644000175000017500000001074412552201363017473 0ustar jorismjorism libDAI: include/dai/factorgraph.h File Reference
Classes | Namespaces
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.

Classes

class  dai::FactorGraph
 Represents a factor graph. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields)

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1MR.html0000644000175000017500000026027512552201367017270 0ustar jorismjorism libDAI: dai::MR Class Reference
Classes | Public Member Functions | Public Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
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

Classes

struct  Properties
 Parameters for MR. More...
 

Public Member Functions

 MR ()
 Default constructor. More...
 
 MR (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
General InfAlg interface
virtual MR * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual MR * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability. More...
 
virtual void setMaxIter (size_t)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 

Public Attributes

struct dai::MR::Properties props
 

Private Types

typedef boost::dynamic_bitset sub_nb
 Type used for managing a subset of neighbors. More...
 

Private Member Functions

Real calcCavityCorrelations ()
 Initialize cors. More...
 
void propagateCavityFields ()
 Iterate update equations for cavity fields. More...
 
void calcMagnetizations ()
 Calculate magnetizations. More...
 
Real _tJ (size_t i, sub_nb A)
 Calculate the product of all tJ[i][_j] for _j in A. More...
 
Real Omega (size_t i, size_t _j, size_t _l)
 Calculate $ \Omega^{(i)}_{j,l} $ as defined in [MoR05] eqn. (2.15) More...
 
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\} $. More...
 
Real T (size_t i, size_t _j)
 Calculates $ T^{(i)}_j $ where j is the _j 'th neighbor of i. More...
 
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) More...
 
Real Gamma (size_t i, size_t _l1, size_t _l2)
 Calculates $ \Gamma^{(i)}_{l_1l_2} $ as defined in [MoK07] on page 1141. More...
 
Real appM (size_t i, sub_nb A)
 Approximates moments of variables in A. More...
 
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) More...
 

Private Attributes

bool supported
 Is the underlying factor graph supported? More...
 
GraphAL G
 The interaction graph (Markov graph) More...
 
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) More...
 
std::vector< Real > theta
 theta[i] is the local field on spin i More...
 
std::vector< std::vector< Real > > M
 M[i][_j] is $ M^{(i)}_j $. More...
 
std::vector< std::vector< std::vector< Real > > > cors
 Cavity correlations. More...
 
std::vector< Real > Mag
 Magnetizations. More...
 
Real _maxdiff
 Maximum difference encountered so far. More...
 
size_t _iters
 Number of iterations needed. 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
fgFactor graph.
optsParameters
See also
Properties
Note
This implementation only deals with binary variables and pairwise interactions.
Exceptions
NOT_IMPLEMENTEDif 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
inlinevirtual

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

Implements dai::InfAlg.

virtual MR* dai::MR::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Implements dai::InfAlg.

virtual std::string dai::MR::name ( ) const
inlinevirtual

Returns the name of the algorithm.

Implements dai::InfAlg.

virtual Factor dai::MR::belief ( const Var &  v) const
inlinevirtual

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_IMPLEMENTEDif not implemented/supported.
BELIEF_NOT_AVAILABLEif 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
inlinevirtual

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_IMPLEMENTEDif not implemented/supported

Implements dai::InfAlg.

virtual void dai::MR::init ( )
inlinevirtual

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)
inlinevirtual

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_IMPLEMENTEDif 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
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::MR::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif 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
ivariable index
Asubset 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
ivariable index
Asubset 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
ivariable index
Asubset 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
jvariable index
Asubset of neighbors of variable j
sum_evenon return, will contain the sum over all even subsets
sum_oddon 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.

The documentation for this class was generated from the following files:
  • include/dai/mr.h
  • src/mr.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1LC_1_1Properties.html0000644000175000017500000004235112552201366022174 0ustar jorismjorism libDAI: dai::LC::Properties Struct Reference
Public Member Functions | Public Attributes | List of all members
dai::LC::Properties Struct Reference

Parameters for LC. More...

#include <dai/lc.h>

Public Member Functions

 DAI_ENUM (CavityType, FULL, PAIR, PAIR2, UNIFORM)
 Enumeration of possible ways to initialize the cavities. More...
 
 DAI_ENUM (UpdateType, SEQFIX, SEQRND)
 Enumeration of different update schedules. More...
 

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr) More...
 
size_t maxiter
 Maximum number of iterations. More...
 
Real tol
 Tolerance for convergence test. More...
 
bool reinit
 Complete or partial reinitialization of cavity graphs? More...
 
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping) More...
 
CavityType cavity
 How to initialize the cavities. More...
 
UpdateType updates
 What update schedule to use. More...
 
std::string cavainame
 Name of the algorithm used to initialize the cavity distributions. More...
 
PropertySet cavaiopts
 Parameters for the algorithm used to initialize the cavity distributions. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/properties_8h.html0000644000175000017500000001712212552201363017364 0ustar jorismjorism libDAI: include/dai/properties.h File Reference
Classes | Namespaces | Typedefs | Functions
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.

Classes

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

Namespaces

 dai
 Namespace for libDAI.
 

Typedefs

typedef std::string dai::PropertyKey
 Type of the key of a Property. More...
 
typedef boost::any dai::PropertyValue
 Type of the value of a Property. More...
 
typedef std::pair< PropertyKey, PropertyValue > dai::Property
 A Property is a pair of a key and a corresponding value. More...
 

Functions

std::ostream & dai::operator<< (std::ostream &os, const Property &p)
 Writes a Property object (key-value pair) to an output stream. More...
 

Detailed Description

Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1BP__dual-members.html0000644000175000017500000002373412552201364022041 0ustar jorismjorism 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_dualprotected
_iadai::BP_dualprotected
_msgsdai::BP_dualprotected
beliefF(size_t I) const dai::BP_dualinline
beliefFZ(size_t I) const dai::BP_dualinline
beliefV(size_t i) const dai::BP_dualinline
beliefVZ(size_t i) const dai::BP_dualinline
BP_dual(const InfAlg *ia)dai::BP_dualinline
calcBeliefF(size_t I)dai::BP_dualprotected
calcBeliefs()dai::BP_dualprotected
calcBeliefV(size_t i)dai::BP_dualprotected
calcMessages()dai::BP_dualprotected
calcNewM(size_t i, size_t _I)dai::BP_dualprotected
calcNewN(size_t i, size_t _I)dai::BP_dualprotected
fg() const dai::BP_dualinline
init()dai::BP_dualprotected
msgM(size_t i, size_t _I)dai::BP_dualinline
msgM(size_t i, size_t _I) const dai::BP_dualinline
msgN(size_t i, size_t _I)dai::BP_dualinline
msgN(size_t i, size_t _I) const dai::BP_dualinline
regenerateBeliefs()dai::BP_dualprotected
regenerateMessages()dai::BP_dualprotected
zM(size_t i, size_t _I)dai::BP_dualinline
zM(size_t i, size_t _I) const dai::BP_dualinline
zN(size_t i, size_t _I)dai::BP_dualinline
zN(size_t i, size_t _I) const dai::BP_dualinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/discussion.html0000644000175000017500000001315712552201364016761 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_22.png0000644000175000017500000000053012552200220015641 0ustar jorismjorism‰PNG  IHDR(S ÍŸ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÇIDATxí][à 3$PB×qÿÛÌsÒ~÷YšÇvCÿß à\áL$½gx €sÉu$؈\€¯m~ÇeEù¨ŽÇOˆ•ä&7mªhØ–-Ä»â$„ÊÖŠ^QB® libDAI: include/dai/varset.h File Reference
Classes | Namespaces | Functions
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.

Classes

class  dai::VarSet
 Represents a set of variables. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

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. More...
 
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. More...
 

Detailed Description

Defines the VarSet class, which represents a set of random variables.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/util_8h.html0000644000175000017500000007103512552201363016150 0ustar jorismjorism libDAI: include/dai/util.h File Reference
Classes | Namespaces | Macros | Typedefs | Enumerations | Functions
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 <gmpxx.h>
#include <dai/exceptions.h>
#include <tr1/unordered_map>

Go to the source code of this file.

Classes

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

Namespaces

 dai
 Namespace for libDAI.
 

Macros

#define bforeach   BOOST_FOREACH
 An alias to the BOOST_FOREACH macro from the boost::bforeach library. More...
 
#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) More...
 
#define DAI_DMSG(str)   do {std::cerr << str << std::endl;} while(0)
 "Debugging message": Prints a message (only if DAI_DEBUG is defined) More...
 
#define DAI_IFVERB(n, stmt)   if(props.verbose>=n) { std::cerr << stmt; }
 Macro to write message stmt to std::cerr if props.verbose >= n. More...
 

Typedefs

typedef double dai::Real
 Real number (alias for double, which could be changed to long double if necessary) More...
 
typedef mpz_class dai::BigInt
 Arbitrary precision integer number. More...
 

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

size_t dai::BigInt_size_t (const BigInt &N)
 Safe down-cast of big integer to size_t. More...
 
bool dai::isnan (Real x)
 Returns true if argument is NAN (Not A Number) More...
 
Real dai::log (Real x)
 Returns logarithm of x. More...
 
Real dai::log0 (Real x)
 Returns logarithm of x, or 0 if x == 0. More...
 
Real dai::exp (Real x)
 Returns exponent of x. More...
 
Real dai::pow (Real x, Real y)
 Returns x to the power y. More...
 
double dai::toc ()
 Returns wall clock time in seconds. More...
 
template<class T >
T dai::abs (const T &t)
 Returns absolute value of t. More...
 
void dai::rnd_seed (size_t seed)
 Sets the random seed. More...
 
Real dai::rnd_uniform ()
 Returns a real number, distributed uniformly on [0,1) More...
 
Real dai::rnd_stdnormal ()
 Returns a real number from a standard-normal distribution. More...
 
int dai::rnd_int (int min, int max)
 Returns a random integer in interval [min, max]. More...
 
int dai::rnd (int n)
 Returns a random integer in the half-open interval [0, n) More...
 
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. More...
 
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. More...
 
template<class T >
std::ostream & dai::operator<< (std::ostream &os, const std::vector< T > &x)
 Writes a std::vector<> to a std::ostream. More...
 
template<class T >
std::ostream & dai::operator<< (std::ostream &os, const std::set< T > &x)
 Writes a std::set<> to a std::ostream. More...
 
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. More...
 
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. More...
 
template<class T >
std::vector< T > dai::concat (const std::vector< T > &u, const std::vector< T > &v)
 Concatenates two vectors. More...
 
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. More...
 

Detailed Description

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

Macro Definition Documentation

#define bforeach   BOOST_FOREACH

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

Examples:
example_bipgraph.cpp.
#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:

1 DAI_PV(3+4)

Output:

1 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/bipgraph_8h.html0000644000175000017500000001243112552201363016762 0ustar jorismjorism libDAI: include/dai/bipgraph.h File Reference
Classes | Namespaces
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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines the BipartiteGraph class, which represents a bipartite graph.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__inv.html0000644000175000017500000001146112552201365020575 0ustar jorismjorism libDAI: dai::fo_inv< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_inv< T > Struct Template Reference

Function object that takes the inverse. More...

#include <dai/prob.h>

Inherits unary_function< T, T >.

Public Member Functions

T operator() (const T &x) const
 Returns 1 / x. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/treeep_8h_source.html0000644000175000017500000017176012552201363020045 0ustar jorismjorism libDAI: include/dai/treeep.h Source File
treeep.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
13 
14 
15 #ifndef __defined_libdai_treeep_h
16 #define __defined_libdai_treeep_h
17 
18 
19 #include <dai/dai_config.h>
20 #ifdef DAI_WITH_TREEEP
21 
22 
23 #include <vector>
24 #include <string>
25 #include <dai/daialg.h>
26 #include <dai/varset.h>
27 #include <dai/regiongraph.h>
28 #include <dai/factorgraph.h>
29 #include <dai/clustergraph.h>
30 #include <dai/weightedgraph.h>
31 #include <dai/jtree.h>
32 #include <dai/properties.h>
33 #include <dai/enum.h>
34 
35 
36 namespace dai {
37 
38 
40 class TreeEP : public JTree {
41  private:
43  Real _maxdiff;
45  size_t _iters;
46 
47  public:
49  struct Properties {
51 
57  DAI_ENUM(TypeType,ORG,ALT);
58 
60  size_t verbose;
61 
63  size_t maxiter;
64 
66  double maxtime;
67 
69  Real tol;
70 
72  TypeType type;
73  } props;
74 
75  private:
77 
81  class TreeEPSubTree {
82  private:
84  std::vector<Factor> _Qa;
86  std::vector<Factor> _Qb;
88  RootedTree _RTree;
90  std::vector<size_t> _a;
92  std::vector<size_t> _b;
94  const Factor * _I;
96  VarSet _ns;
98  VarSet _nsrem;
100  Real _logZ;
101 
102  public:
104 
105  TreeEPSubTree() : _Qa(), _Qb(), _RTree(), _a(), _b(), _I(NULL), _ns(), _nsrem(), _logZ(0.0) {}
107 
109  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) {}
110 
112  TreeEPSubTree & operator=( const TreeEPSubTree& x ) {
113  if( this != &x ) {
114  _Qa = x._Qa;
115  _Qb = x._Qb;
116  _RTree = x._RTree;
117  _a = x._a;
118  _b = x._b;
119  _I = x._I;
120  _ns = x._ns;
121  _nsrem = x._nsrem;
122  _logZ = x._logZ;
123  }
124  return *this;
125  }
126 
128  TreeEPSubTree( const RootedTree &subRTree, const RootedTree &jt_RTree, const std::vector<Factor> &jt_Qa, const std::vector<Factor> &jt_Qb, const Factor *I );
130 
132  void init();
133 
135  void InvertAndMultiply( const std::vector<Factor> &Qa, const std::vector<Factor> &Qb );
136 
138  void HUGIN_with_I( std::vector<Factor> &Qa, std::vector<Factor> &Qb );
139 
141  Real logZ( const std::vector<Factor> &Qa, const std::vector<Factor> &Qb ) const;
142 
144  const Factor *& I() { return _I; }
145  };
146 
148  std::map<size_t, TreeEPSubTree> _Q;
149 
150  public:
152  TreeEP() : JTree(), _maxdiff(0.0), _iters(0), props(), _Q() {}
153 
155  TreeEP( const TreeEP &x ) : JTree(x), _maxdiff(x._maxdiff), _iters(x._iters), props(x.props), _Q(x._Q) {
156  for( size_t I = 0; I < nrFactors(); I++ )
157  if( offtree( I ) )
158  _Q[I].I() = &factor(I);
159  }
160 
162  TreeEP& operator=( const TreeEP &x ) {
163  if( this != &x ) {
164  JTree::operator=( x );
165  _maxdiff = x._maxdiff;
166  _iters = x._iters;
167  props = x.props;
168  _Q = x._Q;
169  for( size_t I = 0; I < nrFactors(); I++ )
170  if( offtree( I ) )
171  _Q[I].I() = &factor(I);
172  }
173  return *this;
174  }
175 
177 
180  TreeEP( const FactorGraph &fg, const PropertySet &opts );
181 
182 
184 
185  virtual TreeEP* clone() const { return new TreeEP(*this); }
186  virtual TreeEP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new TreeEP( fg, opts ); }
187  virtual std::string name() const { return "TREEEP"; }
188  virtual Real logZ() const;
189  virtual void init();
190  virtual void init( const VarSet &/*ns*/ ) { init(); }
191  virtual Real run();
192  virtual Real maxDiff() const { return _maxdiff; }
193  virtual size_t Iterations() const { return _iters; }
194  virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; }
195  virtual void setProperties( const PropertySet &opts );
196  virtual PropertySet getProperties() const;
197  virtual std::string printProperties() const;
199 
200  private:
202  void construct( const FactorGraph& fg, const RootedTree& tree );
204  bool offtree( size_t I ) const { return (fac2OR(I) == -1U); }
205 };
206 
207 
208 } // end of namespace dai
209 
210 
211 #endif
212 
213 
214 #endif
dai::TreeEP::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: treeep.h:187
dai::TreeEP::TreeEPSubTree::_nsrem
VarSet _nsrem
Variables in off-tree factor which are not in the root of this subtree.
Definition: treeep.h:98
dai::TreeEP::run
virtual Real run()
Runs the approximate inference algorithm.
Definition: treeep.cpp:190
dai::TreeEP::setProperties
virtual void setProperties(const PropertySet &opts)
Set parameters of this inference algorithm.
Definition: treeep.cpp:27
dai::TreeEP::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: treeep.cpp:59
dai::TreeEP::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: treeep.h:192
dai::JTree
Exact inference algorithm using junction tree.
Definition: jtree.h:45
dai::TreeEP::TreeEPSubTree::logZ
Real logZ(const std::vector< Factor > &Qa, const std::vector< Factor > &Qb) const
Returns energy (?) of this subtree.
Definition: treeep.cpp:376
dai::TreeEP
Approximate inference algorithm "Tree Expectation Propagation" [MiQ04].
Definition: treeep.h:40
dai::TreeEP::Properties::maxiter
size_t maxiter
Maximum number of iterations.
Definition: treeep.h:63
weightedgraph.h
Defines some utility functions for (weighted) undirected graphs, trees and rooted trees...
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
varset.h
Defines the VarSet class, which represents a set of random variables.
dai::JTree::Qa
std::vector< Factor > Qa
Outer region beliefs.
Definition: jtree.h:58
dai::TreeEP::init
virtual void init(const VarSet &)
Initializes all data structures corresponding to some set of variables.
Definition: treeep.h:190
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::TreeEP::TreeEPSubTree::TreeEPSubTree
TreeEPSubTree(const TreeEPSubTree &x)
Copy constructor.
Definition: treeep.h:109
dai::TreeEP::TreeEPSubTree::HUGIN_with_I
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) junctio...
Definition: treeep.cpp:318
dai::TreeEP::offtree
bool offtree(size_t I) const
Returns true if factor I is not part of the tree.
Definition: treeep.h:204
dai::TreeEP::TreeEP
TreeEP(const TreeEP &x)
Copy constructor.
Definition: treeep.h:155
dai::TreeEP::construct
virtual TreeEP * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: treeep.h:186
dai::TreeEP::TreeEPSubTree::_logZ
Real _logZ
Used for calculating the free energy.
Definition: treeep.h:100
dai::TreeEP::init
virtual void init()
Initializes all data structures of the approximate inference algorithm.
Definition: treeep.cpp:180
dai::TreeEP::TreeEPSubTree::I
const Factor *& I()
Returns constant reference to the pointer to the off-tree factor.
Definition: treeep.h:144
dai::TreeEP::Properties::DAI_ENUM
DAI_ENUM(TypeType, ORG, ALT)
Enumeration of possible choices for the tree.
dai::TreeEP::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: treeep.h:193
dai::TreeEP::TreeEPSubTree::operator=
TreeEPSubTree & operator=(const TreeEPSubTree &x)
Assignment operator.
Definition: treeep.h:112
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::TreeEP::TreeEPSubTree::TreeEPSubTree
TreeEPSubTree()
Default constructor.
Definition: treeep.h:106
dai::TreeEP::TreeEPSubTree::_Qb
std::vector< Factor > _Qb
Inner region pseudomarginals (corresponding with the in [MiQ04])
Definition: treeep.h:86
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::TreeEP::TreeEPSubTree::_Qa
std::vector< Factor > _Qa
Outer region pseudomarginals (corresponding with the in [MiQ04])
Definition: treeep.h:84
dai::TreeEP::TreeEPSubTree::_b
std::vector< size_t > _b
Index conversion table for inner region indices (_Qb[beta] corresponds with Qb[_b[beta]] of the super...
Definition: treeep.h:92
dai::TreeEP::setMaxIter
virtual void setMaxIter(size_t maxiter)
Sets maximum number of iterations (one iteration passes over the complete factorgraph).
Definition: treeep.h:194
jtree.h
Defines class JTree, which implements the junction tree algorithm.
dai::TreeEP::TreeEPSubTree::_RTree
RootedTree _RTree
The junction tree (stored as a rooted tree)
Definition: treeep.h:88
dai::TreeEP::TreeEPSubTree::_I
const Factor * _I
Pointer to off-tree factor.
Definition: treeep.h:94
dai::TreeEP::TreeEPSubTree::_ns
VarSet _ns
Variables in off-tree factor.
Definition: treeep.h:96
dai::JTree::Qb
std::vector< Factor > Qb
Inner region beliefs.
Definition: jtree.h:61
clustergraph.h
Defines class ClusterGraph, which is used by JTree, TreeEP and HAK.
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
regiongraph.h
Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region grap...
dai::TreeEP::Properties::type
TypeType type
How to choose the tree.
Definition: treeep.h:72
dai::TreeEP::_Q
std::map< size_t, TreeEPSubTree > _Q
Stores a TreeEPSubTree object for each off-tree factor.
Definition: treeep.h:148
dai::RootedTree
Represents a rooted tree, implemented as a vector of directed edges.
Definition: weightedgraph.h:157
dai::TreeEP::Properties::maxtime
double maxtime
Maximum time (in seconds)
Definition: treeep.h:66
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::TreeEP::Properties
Parameters for TreeEP.
Definition: treeep.h:49
dai::TreeEP::TreeEPSubTree::_a
std::vector< size_t > _a
Index conversion table for outer region indices (_Qa[alpha] corresponds with Qa[_a[alpha]] of the sup...
Definition: treeep.h:90
dai::TreeEP::TreeEPSubTree::InvertAndMultiply
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...
Definition: treeep.cpp:309
dai::TreeEP::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: treeep.cpp:241
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::TreeEP::operator=
TreeEP & operator=(const TreeEP &x)
Assignment operator.
Definition: treeep.h:162
dai::TreeEP::_maxdiff
Real _maxdiff
Maximum difference encountered so far.
Definition: treeep.h:43
dai::TreeEP::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: treeep.cpp:48
dai::TreeEP::clone
virtual TreeEP * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: treeep.h:185
dai::TreeEP::TreeEPSubTree
Stores the data structures needed to efficiently update the approximation of an off-tree factor...
Definition: treeep.h:81
dai::TreeEP::TreeEPSubTree::init
void init()
Initializes beliefs of this subtree.
Definition: treeep.cpp:301
dai::TreeEP::Properties::tol
Real tol
Tolerance for convergence test.
Definition: treeep.h:69
dai::TreeEP::TreeEP
TreeEP()
Default constructor.
Definition: treeep.h:152
dai::TreeEP::_iters
size_t _iters
Number of iterations needed.
Definition: treeep.h:45
dai::TreeEP::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: treeep.h:60
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1Permute.html0000644000175000017500000004621212552201367020364 0ustar jorismjorism libDAI: dai::Permute Class Reference
Public Member Functions | Private Attributes | List of all members
dai::Permute Class Reference

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

#include <dai/index.h>

Public Member Functions

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

Private Attributes

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

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1BP.html0000644000175000017500000034105212552201364017241 0ustar jorismjorism libDAI: dai::BP Class Reference
Classes | Public Attributes | Protected Types | Protected Member Functions | Protected Attributes | List of all members
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

Classes

struct  EdgeProp
 Type used for storing edge properties. More...
 
struct  Properties
 Parameters for BP. More...
 

Public Member Functions

Constructors/destructors
 BP ()
 Default constructor. More...
 
 BP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
 BP (const BP &x)
 Copy constructor. More...
 
BP & operator= (const BP &x)
 Assignment operator. More...
 
General InfAlg interface
virtual BP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual BP * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
std::vector< size_t > findMaximum () const
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &ns)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
Additional interface specific for BP
const std::vector< std::pair< size_t, size_t > > & getSentMessages () const
 Returns history of which messages have been updated. More...
 
void clearSentMessages ()
 Clears history of which messages have been updated. More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 

Public Attributes

struct dai::BP::Properties props
 
bool recordSentMessages
 Specifies whether the history of message updates should be recorded. More...
 

Protected Types

typedef std::vector< size_t > ind_t
 Type used for index cache. More...
 
typedef std::multimap< Real, std::pair< size_t, size_t > > LutType
 Type of lookup table (only used for maximum-residual BP) More...
 

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. More...
 
Prob & message (size_t i, size_t _I)
 Returns reference to message from the _I 'th neighbor of variable i to variable i. More...
 
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. More...
 
Prob & newMessage (size_t i, size_t _I)
 Returns reference to updated message from the _I 'th neighbor of variable i to variable i. More...
 
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. More...
 
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. More...
 
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. More...
 
Real & residual (size_t i, size_t _I)
 Returns reference to residual for the edge between variable i and its _I 'th neighbor. More...
 
virtual Prob calcIncomingMessageProduct (size_t I, bool without_i, size_t i) const
 Calculate the product of factor I and the incoming messages. More...
 
virtual void calcNewMessage (size_t i, size_t _I)
 Calculate the updated message from the _I 'th neighbor of variable i to variable i. More...
 
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. More...
 
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. More...
 
void findMaxResidual (size_t &i, size_t &_I)
 Finds the edge which has the maximum residual (difference between new and old message) More...
 
virtual void calcBeliefV (size_t i, Prob &p) const
 Calculates unnormalized belief of variable i. More...
 
virtual void calcBeliefF (size_t I, Prob &p) const
 Calculates unnormalized belief of factor I. More...
 
virtual void construct ()
 Helper function for constructors. More...
 

Protected Attributes

std::vector< std::vector< EdgeProp > > _edges
 Stores all edge properties. More...
 
std::vector< std::vector< LutType::iterator > > _edge2lut
 Lookup table (only used for maximum-residual BP) More...
 
LutType _lut
 Lookup table (only used for maximum-residual BP) More...
 
Real _maxdiff
 Maximum difference between variable beliefs encountered so far. More...
 
size_t _iters
 Number of iterations needed. More...
 
std::vector< std::pair< size_t, size_t > > _sentMessages
 The history of message updates (only recorded if recordSentMessages is true) More...
 
std::vector< Factor > _oldBeliefsV
 Stores variable beliefs of previous iteration. More...
 
std::vector< Factor > _oldBeliefsF
 Stores factor beliefs of previous iteration. More...
 
std::vector< Edge > _updateSeq
 Stores the update schedule. 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<size_t, 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
fgFactor graph.
optsParameters
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
inlinevirtual

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

Implements dai::InfAlg.

Reimplemented in dai::TRWBP, and dai::FBP.

virtual BP* dai::BP::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Implements dai::InfAlg.

Reimplemented in dai::TRWBP, and dai::FBP.

virtual std::string dai::BP::name ( ) const
inlinevirtual

Returns the name of the algorithm.

Implements dai::InfAlg.

Reimplemented in dai::TRWBP, and dai::FBP.

virtual Factor dai::BP::belief ( const Var &  v) const
inlinevirtual

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_IMPLEMENTEDif not implemented/supported.
BELIEF_NOT_AVAILABLEif 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_IMPLEMENTEDif not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::TRWBP, and dai::FBP.

Examples:
example.cpp.
std::vector<size_t> dai::BP::findMaximum ( ) const
inlinevirtual
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_IMPLEMENTEDif 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
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::BP::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::BP::setMaxIter ( size_t  )
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

void dai::BP::setProperties ( const PropertySet &  opts)
virtual
Todo:
Make DAI_BP_FAST a compile-time choice, as it is a memory/speed tradeoff

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<size_t, 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
inlineprotected

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 
)
inlineprotected

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
inlineprotected

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 
)
inlineprotected

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
inlineprotected

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 
)
inlineprotected

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
inlineprotected

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 
)
inlineprotected

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
protectedvirtual

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::TRWBP, and dai::FBP.

void dai::BP::calcNewMessage ( size_t  i,
size_t  _I 
)
protectedvirtual

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
protectedvirtual

Calculates unnormalized belief of variable i.

Reimplemented in dai::TRWBP.

virtual void dai::BP::calcBeliefF ( size_t  I,
Prob &  p 
) const
inlineprotectedvirtual

Calculates unnormalized belief of factor I.

Reimplemented in dai::TRWBP, and dai::FBP.

void dai::BP::construct ( )
protectedvirtual

Helper function for constructors.

Reimplemented in dai::TRWBP, and dai::FBP.

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<size_t, 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.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/graph_8h.html0000644000175000017500000002522612552201363016275 0ustar jorismjorism libDAI: include/dai/graph.h File Reference
Classes | Namespaces | Typedefs | Functions
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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

Typedefs

typedef std::vector< Neighbor > dai::Neighbors
 Describes the set of neighbors of some node in a graph. More...
 
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. More...
 

Functions

GraphAL dai::createGraphFull (size_t N)
 Creates a fully-connected graph with N nodes. More...
 
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. More...
 
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. More...
 
GraphAL dai::createGraphLoop (size_t N)
 Creates a graph consisting of a single loop of N nodes. More...
 
GraphAL dai::createGraphTree (size_t N)
 Creates a random tree-structured graph of N nodes. More...
 
GraphAL dai::createGraphRegular (size_t N, size_t d)
 Creates a random regular graph of N nodes with uniform connectivity d. More...
 

Detailed Description

Defines the GraphAL class, which represents an undirected graph as an adjacency list.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1LC.html0000644000175000017500000022232012552201366017234 0ustar jorismjorism libDAI: dai::LC Class Reference
Classes | Public Member Functions | Public Attributes | Private Attributes | List of all members
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

Classes

struct  Properties
 Parameters for LC. More...
 

Public Member Functions

 LC ()
 Default constructor. More...
 
 LC (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
General InfAlg interface
virtual LC * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual LC * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
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. More...
 
Real InitCavityDists (const std::string &name, const PropertySet &opts)
 Approximates all cavity distributions using inference algorithm name with parameters opts. More...
 
long SetCavityDists (std::vector< Factor > &Q)
 Sets approximate cavity distributions to Q. More...
 
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. More...
 
void CalcBelief (size_t i)
 Calculates the belief of variable i. More...
 
const Factor & pancake (size_t i) const
 Returns the belief of the Markov blanket of variable i (including the variable itself) More...
 
const Factor & cavitydist (size_t i) const
 Returns the approximate cavity distribution for variable i. More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability. More...
 

Public Attributes

struct dai::LC::Properties props
 

Private Attributes

std::vector< Factor > _pancakes
 Stores for each variable the approximate cavity distribution multiplied with the omitted factors. More...
 
std::vector< Factor > _cavitydists
 Stores for each variable the approximate cavity distribution. More...
 
std::vector< std::vector< Factor > > _phis
 _phis[i][_I] corresponds to $ \phi^{\setminus i}_I(x_{I \setminus i}) $ in the paper More...
 
std::vector< Factor > _beliefs
 Single variable beliefs. More...
 
Real _maxdiff
 Maximum difference encountered so far. More...
 
size_t _iters
 Number of iterations needed. 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
fgFactor graph.
optsParameters
See also
Properties

Member Function Documentation

virtual LC* dai::LC::clone ( ) const
inlinevirtual

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

Implements dai::InfAlg.

virtual LC* dai::LC::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Implements dai::InfAlg.

virtual std::string dai::LC::name ( ) const
inlinevirtual

Returns the name of the algorithm.

Implements dai::InfAlg.

virtual Factor dai::LC::belief ( const Var &  v) const
inlinevirtual

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_IMPLEMENTEDif not implemented/supported.
BELIEF_NOT_AVAILABLEif the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

virtual Factor dai::LC::beliefV ( size_t  i) const
inlinevirtual

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
inlinevirtual

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
inlinevirtual

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_IMPLEMENTEDif 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)
inlinevirtual

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_IMPLEMENTEDif 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
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::LC::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::LC::setMaxIter ( size_t  )
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif 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.

The documentation for this class was generated from the following files:
  • include/dai/lc.h
  • src/lc.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/glc_8h.html0000644000175000017500000000601312552201363015732 0ustar jorismjorism libDAI: include/dai/glc.h File Reference
glc.h File Reference

Defines classes GLC and Cobweb, which implement the "Generalized Loop Correction method". More...

#include <dai/dai_config.h>

Go to the source code of this file.

Detailed Description

Defines classes GLC and Cobweb, which implement the "Generalized Loop Correction method".

Todo:
Fix the init of GLC
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1FactorGraph-members.html0000644000175000017500000005253412552201365022575 0ustar jorismjorism libDAI: Member List
dai::FactorGraph Member List

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

_backupdai::FactorGraphprivate
_factorsdai::FactorGraphprivate
_Gdai::FactorGraphprivate
_varsdai::FactorGraphprivate
backupFactor(size_t I)dai::FactorGraph
backupFactors(const std::set< size_t > &facs)dai::FactorGraphvirtual
backupFactors(const VarSet &ns)dai::FactorGraph
bipGraph() const dai::FactorGraphinline
clamp(size_t i, size_t x, bool backup=false)dai::FactorGraphvirtual
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::FactorGraphinlinevirtual
constructGraph(size_t nrEdges)dai::FactorGraphprivate
Delta(size_t i) const dai::FactorGraph
Delta(const VarSet &vs) const dai::FactorGraph
delta(size_t i) const dai::FactorGraphinline
delta(const VarSet &vs) const dai::FactorGraphinline
deltai(size_t i) const dai::FactorGraphinline
Deltai(size_t i) const dai::FactorGraph
factor(size_t I) const dai::FactorGraphinline
FactorGraph()dai::FactorGraphinline
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
factors() const dai::FactorGraphinline
findFactor(const VarSet &ns) const dai::FactorGraphinline
findVar(const Var &n) const dai::FactorGraphinline
findVars(const VarSet &ns) const dai::FactorGraphinline
fromString(const std::string &s)dai::FactorGraphinline
inds2vars(const std::vector< size_t > &inds) const dai::FactorGraphinline
isBinary() const dai::FactorGraph
isConnected() const dai::FactorGraphinline
isMaximal(size_t I) const dai::FactorGraph
isPairwise() const dai::FactorGraph
isTree() const dai::FactorGraphinline
logScore(const std::vector< size_t > &statevec) const dai::FactorGraph
makeCavity(size_t i, bool backup=false)dai::FactorGraphvirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::FactorGraphvirtual
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::FactorGraphinline
nbF(size_t I, size_t _i) const dai::FactorGraphinline
nbV(size_t i) const dai::FactorGraphinline
nbV(size_t i, size_t _I) const dai::FactorGraphinline
nrEdges() const dai::FactorGraphinline
nrFactors() const dai::FactorGraphinline
nrVars() const dai::FactorGraphinline
operator<<(std::ostream &os, const FactorGraph &fg)dai::FactorGraphfriend
operator>>(std::istream &is, FactorGraph &fg)dai::FactorGraphfriend
printDot(std::ostream &os) const dai::FactorGraphvirtual
ReadFromFile(const char *filename)dai::FactorGraphvirtual
restoreFactor(size_t I)dai::FactorGraph
restoreFactors()dai::FactorGraphvirtual
restoreFactors(const VarSet &ns)dai::FactorGraph
setFactor(size_t I, const Factor &newFactor, bool backup=false)dai::FactorGraphinlinevirtual
setFactors(const std::map< size_t, Factor > &facs, bool backup=false)dai::FactorGraphinlinevirtual
toString() const dai::FactorGraphinline
var(size_t i) const dai::FactorGraphinline
vars() const dai::FactorGraphinline
WriteToFile(const char *filename, size_t precision=15) const dai::FactorGraphvirtual
~FactorGraph()dai::FactorGraphinlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_113.png0000644000175000017500000000046412552200245015737 0ustar jorismjorism‰PNG  IHDR k ±0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï£IDATxíQà C%0ÊÖrÿÛή-ýÝ·£lùÿÐÌ2ÀÄU Æòî•’Ž(Và^k€\õ]U£Ý2Ùt›F¥?”B³°|úÝ|ÃWAJ±¹IvR‘ÈÐPS|ÿO¿[™&—Ûæì]õD—èxÏiì‡öùuŽ¼Öê!¹j~†qdEÜž\²¥ËÆ n¿Í¶†7=Xõä_¬Œåji|IEND®B`‚libDAI-0.3.2/doc/html/customdoxygen.css0000644000175000017500000002000712552201363017321 0ustar jorismjorismBODY,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.3.2/doc/html/examples.html0000644000175000017500000000522412552201370016405 0ustar jorismjorism libDAI: Examples
Examples
Here is a list of all examples:
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/bipgraph_8h_source.html0000644000175000017500000022005512552201363020345 0ustar jorismjorism libDAI: include/dai/bipgraph.h Source File
bipgraph.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_bipgraph_h
14 #define __defined_libdai_bipgraph_h
15 
16 
17 #include <ostream>
18 #include <vector>
19 #include <algorithm>
20 #include <dai/util.h>
21 #include <dai/smallset.h>
22 #include <dai/exceptions.h>
23 #include <dai/graph.h>
24 
25 
26 namespace dai {
27 
28 
30 
45 class BipartiteGraph {
46  private:
48  std::vector<Neighbors> _nb1;
49 
51  std::vector<Neighbors> _nb2;
52 
54  struct levelType {
56  std::vector<size_t> ind1;
58  std::vector<size_t> ind2;
59  };
60 
61  public:
63 
64  BipartiteGraph() : _nb1(), _nb2() {}
66 
68  BipartiteGraph( size_t nr1, size_t nr2 ) : _nb1(nr1), _nb2(nr2) {}
69 
71 
78  template<typename EdgeInputIterator>
79  BipartiteGraph( size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true ) : _nb1(), _nb2() {
80  construct( nrNodes1, nrNodes2, begin, end, check );
81  }
83 
85 
86  const Neighbor & nb1( size_t i1, size_t _i2 ) const {
88  DAI_DEBASSERT( i1 < _nb1.size() );
89  DAI_DEBASSERT( _i2 < _nb1[i1].size() );
90  return _nb1[i1][_i2];
91  }
93  Neighbor & nb1( size_t i1, size_t _i2 ) {
94  DAI_DEBASSERT( i1 < _nb1.size() );
95  DAI_DEBASSERT( _i2 < _nb1[i1].size() );
96  return _nb1[i1][_i2];
97  }
98 
100  const Neighbor & nb2( size_t i2, size_t _i1 ) const {
101  DAI_DEBASSERT( i2 < _nb2.size() );
102  DAI_DEBASSERT( _i1 < _nb2[i2].size() );
103  return _nb2[i2][_i1];
104  }
106  Neighbor & nb2( size_t i2, size_t _i1 ) {
107  DAI_DEBASSERT( i2 < _nb2.size() );
108  DAI_DEBASSERT( _i1 < _nb2[i2].size() );
109  return _nb2[i2][_i1];
110  }
111 
113  const Neighbors & nb1( size_t i1 ) const {
114  DAI_DEBASSERT( i1 < _nb1.size() );
115  return _nb1[i1];
116  }
118  Neighbors & nb1( size_t i1 ) {
119  DAI_DEBASSERT( i1 < _nb1.size() );
120  return _nb1[i1];
121  }
122 
124  const Neighbors & nb2( size_t i2 ) const {
125  DAI_DEBASSERT( i2 < _nb2.size() );
126  return _nb2[i2];
127  }
129  Neighbors & nb2( size_t i2 ) {
130  DAI_DEBASSERT( i2 < _nb2.size() );
131  return _nb2[i2];
132  }
134 
136 
137 
145  template<typename EdgeInputIterator>
146  void construct( size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true );
147 
149  size_t addNode1() { _nb1.push_back( Neighbors() ); return _nb1.size() - 1; }
150 
152  size_t addNode2() { _nb2.push_back( Neighbors() ); return _nb2.size() - 1; }
153 
154 
156 
162  template <typename NodeInputIterator>
163  size_t addNode1( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) {
164  Neighbors nbs1new;
165  nbs1new.reserve( sizeHint );
166  size_t iter = 0;
167  for( NodeInputIterator it = begin; it != end; ++it ) {
168  DAI_ASSERT( *it < nrNodes2() );
169  Neighbor nb1new( iter, *it, nb2(*it).size() );
170  Neighbor nb2new( nb2(*it).size(), nrNodes1(), iter++ );
171  nbs1new.push_back( nb1new );
172  nb2( *it ).push_back( nb2new );
173  }
174  _nb1.push_back( nbs1new );
175  return _nb1.size() - 1;
176  }
177 
179 
185  template <typename NodeInputIterator>
186  size_t addNode2( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) {
187  Neighbors nbs2new;
188  nbs2new.reserve( sizeHint );
189  size_t iter = 0;
190  for( NodeInputIterator it = begin; it != end; ++it ) {
191  DAI_ASSERT( *it < nrNodes1() );
192  Neighbor nb2new( iter, *it, nb1(*it).size() );
193  Neighbor nb1new( nb1(*it).size(), nrNodes2(), iter++ );
194  nbs2new.push_back( nb2new );
195  nb1( *it ).push_back( nb1new );
196  }
197  _nb2.push_back( nbs2new );
198  return _nb2.size() - 1;
199  }
200 
202 
204  BipartiteGraph& addEdge( size_t n1, size_t n2, bool check = true );
206 
208 
209  void eraseNode1( size_t n1 );
211 
213  void eraseNode2( size_t n2 );
214 
216  void eraseEdge( size_t n1, size_t n2 );
218 
220 
221  size_t nrNodes1() const { return _nb1.size(); }
224  size_t nrNodes2() const { return _nb2.size(); }
225 
227  size_t nrEdges() const {
228  size_t sum = 0;
229  for( size_t i1 = 0; i1 < nrNodes1(); i1++ )
230  sum += nb1(i1).size();
231  return sum;
232  }
233 
235 
237  bool hasEdge( size_t n1, size_t n2 ) const {
238  if( nb1(n1).size() < nb2(n2).size() ) {
239  for( size_t _n2 = 0; _n2 < nb1(n1).size(); _n2++ )
240  if( nb1( n1, _n2 ) == n2 )
241  return true;
242  } else {
243  for( size_t _n1 = 0; _n1 < nb2(n2).size(); _n1++ )
244  if( nb2( n2, _n1 ) == n1 )
245  return true;
246  }
247  return false;
248  }
249 
251 
254  size_t findNb1( size_t n1, size_t n2 ) {
255  for( size_t _n2 = 0; _n2 < nb1(n1).size(); _n2++ )
256  if( nb1( n1, _n2 ) == n2 )
257  return _n2;
258  DAI_THROW(OBJECT_NOT_FOUND);
259  return nb1(n1).size();
260  }
261 
263 
266  size_t findNb2( size_t n1, size_t n2 ) {
267  for( size_t _n1 = 0; _n1 < nb2(n2).size(); _n1++ )
268  if( nb2( n2, _n1 ) == n1 )
269  return _n1;
270  DAI_THROW(OBJECT_NOT_FOUND);
271  return nb2(n2).size();
272  }
273 
275  SmallSet<size_t> nb1Set( size_t n1 ) const;
276 
278  SmallSet<size_t> nb2Set( size_t n2 ) const;
279 
281 
284  SmallSet<size_t> delta1( size_t n1, bool include = false ) const;
285 
287 
290  SmallSet<size_t> delta2( size_t n2, bool include = false ) const;
291 
293  bool isConnected() const;
294 
296  bool isTree() const;
297 
299 
303  bool operator==( const BipartiteGraph& x ) const {
304  if( nrNodes1() != x.nrNodes1() )
305  return false;
306  if( nrNodes2() != x.nrNodes2() )
307  return false;
308  for( size_t n1 = 0; n1 < nrNodes1(); n1++ ) {
309  if( nb1(n1).size() != x.nb1(n1).size() )
310  return false;
311  bforeach( const Neighbor &n2, nb1(n1) )
312  if( !x.hasEdge( n1, n2 ) )
313  return false;
314  bforeach( const Neighbor &n2, x.nb1(n1) )
315  if( !hasEdge( n1, n2 ) )
316  return false;
317  }
318  return true;
319  }
320 
322  void checkConsistency() const;
324 
326 
327  void printDot( std::ostream& os ) const;
329 
331  friend std::ostream& operator<<( std::ostream& os, const BipartiteGraph& g ) {
332  g.printDot( os );
333  return os;
334  }
335 
337  std::string toString() const {
338  std::stringstream ss;
339  ss << *this;
340  return ss.str();
341  }
343 };
344 
345 
346 template<typename EdgeInputIterator>
347 void BipartiteGraph::construct( size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check ) {
348  _nb1.clear();
349  _nb1.resize( nrNodes1 );
350  _nb2.clear();
351  _nb2.resize( nrNodes2 );
352 
353  for( EdgeInputIterator e = begin; e != end; e++ )
354  addEdge( e->first, e->second, check );
355 }
356 
357 
358 } // end of namespace dai
359 
360 
396 #endif
dai::BipartiteGraph::addEdge
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.
Definition: bipgraph.cpp:18
dai::Neighbors
std::vector< Neighbor > Neighbors
Describes the set of neighbors of some node in a graph.
Definition: graph.h:92
dai::BipartiteGraph::delta1
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...
Definition: bipgraph.cpp:135
dai::BipartiteGraph::eraseNode1
void eraseNode1(size_t n1)
Removes node n1 of type 1 and all incident edges; indices of other nodes are changed accordingly...
Definition: bipgraph.cpp:40
dai::BipartiteGraph::isTree
bool isTree() const
Returns true if the graph is a tree, i.e., if it is singly connected and connected.
Definition: bipgraph.cpp:230
dai::BipartiteGraph::addNode2
size_t addNode2()
Adds a node of type 2 without neighbors and returns the index of the added node.
Definition: bipgraph.h:152
dai::BipartiteGraph::_nb1
std::vector< Neighbors > _nb1
Contains for each node of type 1 a vector of its neighbors.
Definition: bipgraph.h:48
dai::BipartiteGraph::nrNodes1
size_t nrNodes1() const
Returns number of nodes of type 1.
Definition: bipgraph.h:222
dai::BipartiteGraph::nb2Set
SmallSet< size_t > nb2Set(size_t n2) const
Returns neighbors of node n2 of type 2 as a SmallSet.
Definition: bipgraph.cpp:127
dai::BipartiteGraph::nb1
const Neighbor & nb1(size_t i1, size_t _i2) const
Returns constant reference to the _i2 'th neighbor of node i1 of type 1.
Definition: bipgraph.h:87
dai::BipartiteGraph::toString
std::string toString() const
Formats a BipartiteGraph as a string.
Definition: bipgraph.h:337
dai::BipartiteGraph::checkConsistency
void checkConsistency() const
Asserts internal consistency.
Definition: bipgraph.cpp:314
dai::BipartiteGraph::nb2
const Neighbors & nb2(size_t i2) const
Returns constant reference to all neighbors of node i2 of type 2.
Definition: bipgraph.h:124
dai::BipartiteGraph::nrEdges
size_t nrEdges() const
Calculates the number of edges, time complexity: O(nrNodes1())
Definition: bipgraph.h:227
dai::BipartiteGraph::printDot
void printDot(std::ostream &os) const
Writes a BipartiteGraph to an output stream in GraphViz .dot syntax.
Definition: bipgraph.cpp:299
dai::BipartiteGraph
Represents the neighborhood structure of nodes in an undirected, bipartite graph. ...
Definition: bipgraph.h:45
dai::BipartiteGraph::nrNodes2
size_t nrNodes2() const
Returns number of nodes of type 2.
Definition: bipgraph.h:224
dai::BipartiteGraph::nb1
Neighbor & nb1(size_t i1, size_t _i2)
Returns reference to the _i2 'th neighbor of node i1 of type 1.
Definition: bipgraph.h:93
dai::BipartiteGraph::addNode1
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.
Definition: bipgraph.h:163
dai::BipartiteGraph::findNb1
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...
Definition: bipgraph.h:254
dai::BipartiteGraph::addNode1
size_t addNode1()
Adds a node of type 1 without neighbors and returns the index of the added node.
Definition: bipgraph.h:149
dai::BipartiteGraph::delta2
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...
Definition: bipgraph.cpp:146
dai::BipartiteGraph::BipartiteGraph
BipartiteGraph()
Default constructor (creates an empty bipartite graph)
Definition: bipgraph.h:65
dai::BipartiteGraph::nb2
Neighbors & nb2(size_t i2)
Returns reference to all neighbors of node i2 of type 2.
Definition: bipgraph.h:129
dai::BipartiteGraph::nb2
const Neighbor & nb2(size_t i2, size_t _i1) const
Returns constant reference to the _i1 'th neighbor of node i2 of type 2.
Definition: bipgraph.h:100
dai::BipartiteGraph::nb2
Neighbor & nb2(size_t i2, size_t _i1)
Returns reference to the _i1 'th neighbor of node i2 of type 2.
Definition: bipgraph.h:106
bforeach
#define bforeach
An alias to the BOOST_FOREACH macro from the boost::bforeach library.
Definition: util.h:48
dai::BipartiteGraph::eraseNode2
void eraseNode2(size_t n2)
Removes node n2 of type 2 and all incident edges; indices of other nodes are changed accordingly...
Definition: bipgraph.cpp:63
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::BipartiteGraph::levelType::ind1
std::vector< size_t > ind1
Indices of nodes of type 1.
Definition: bipgraph.h:56
util.h
Defines general utility functions and adds an abstraction layer for platform-dependent functionality...
dai::BipartiteGraph::BipartiteGraph
BipartiteGraph(size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
Constructs BipartiteGraph from a range of edges.
Definition: bipgraph.h:79
dai::BipartiteGraph::eraseEdge
void eraseEdge(size_t n1, size_t n2)
Removes edge between node n1 of type 1 and node n2 of type 2.
Definition: bipgraph.cpp:86
dai::BipartiteGraph::_nb2
std::vector< Neighbors > _nb2
Contains for each node of type 2 a vector of its neighbors.
Definition: bipgraph.h:51
graph.h
Defines the GraphAL class, which represents an undirected graph as an adjacency list.
dai::BipartiteGraph::levelType
Used internally by isTree()
Definition: bipgraph.h:54
smallset.h
Defines the SmallSet<> class, which represents a set (optimized for a small number of elements)...
dai::Neighbor
Describes the neighbor relationship of two nodes in a graph.
Definition: graph.h:73
dai::BipartiteGraph::addNode2
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.
Definition: bipgraph.h:186
dai::BipartiteGraph::levelType::ind2
std::vector< size_t > ind2
Indices of nodes of type 2.
Definition: bipgraph.h:58
dai::BipartiteGraph::nb1
const Neighbors & nb1(size_t i1) const
Returns constant reference to all neighbors of node i1 of type 1.
Definition: bipgraph.h:113
dai::BipartiteGraph::hasEdge
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...
Definition: bipgraph.h:237
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::BipartiteGraph::operator<<
friend std::ostream & operator<<(std::ostream &os, const BipartiteGraph &g)
Writes a BipartiteGraph to an output stream.
Definition: bipgraph.h:331
dai::BipartiteGraph::operator==
bool operator==(const BipartiteGraph &x) const
Comparison operator which returns true if two graphs are identical.
Definition: bipgraph.h:303
dai::BipartiteGraph::construct
void construct(size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
(Re)constructs BipartiteGraph from a range of edges.
Definition: bipgraph.h:347
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::BipartiteGraph::BipartiteGraph
BipartiteGraph(size_t nr1, size_t nr2)
Constructs BipartiteGraph with nr1 nodes of type 1, nr2 nodes of type 2 and no edges.
Definition: bipgraph.h:68
dai::BipartiteGraph::isConnected
bool isConnected() const
Returns true if the graph is connected.
Definition: bipgraph.cpp:157
dai::BipartiteGraph::nb1
Neighbors & nb1(size_t i1)
Returns reference to all neighbors of node i1 of type 1.
Definition: bipgraph.h:118
dai::BipartiteGraph::findNb2
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...
Definition: bipgraph.h:266
dai::BipartiteGraph::nb1Set
SmallSet< size_t > nb1Set(size_t n1) const
Returns neighbors of node n1 of type 1 as a SmallSet.
Definition: bipgraph.cpp:119
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1greedyVariableElimination.html0000644000175000017500000002616212552201366024062 0ustar jorismjorism libDAI: dai::greedyVariableElimination Class Reference
Public Types | Public Member Functions | Private Attributes | List of all members
dai::greedyVariableElimination Class Reference

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

#include <dai/clustergraph.h>

Public Types

typedef size_t(* eliminationCostFunction) (const ClusterGraph &, size_t)
 Type of cost functions to be used for greedy variable elimination. More...
 

Public Member Functions

 greedyVariableElimination (eliminationCostFunction h)
 Construct from cost function. More...
 
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. More...
 

Private Attributes

eliminationCostFunction heuristic
 Pointer to the cost function used. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1JTree-members.html0000644000175000017500000004254512552201366021410 0ustar jorismjorism libDAI: Member List
dai::JTree Member List

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

_logZdai::JTreeprivate
_mesdai::JTreeprivate
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const VarSet &vs) const dai::JTreevirtual
dai::DAIAlg::belief(const Var &v) const dai::InfAlginlinevirtual
beliefF(size_t I) const dai::InfAlginlinevirtual
beliefs() const dai::JTreevirtual
beliefV(size_t i) const dai::InfAlginlinevirtual
boundTreewidth(const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates=0)dai::JTreerelated
calcMarginal(const VarSet &vs)dai::JTree
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clone() const dai::JTreeinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::JTreeinlinevirtual
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 >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findEfficientTree(const VarSet &vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1) const dai::JTree
findMaximum() const dai::JTreevirtual
GenerateJT(const FactorGraph &fg, const std::vector< VarSet > &cl)dai::JTree
getProperties() const dai::JTreevirtual
identify() const dai::InfAlginlinevirtual
init()dai::JTreeinlinevirtual
init(const VarSet &)dai::JTreeinlinevirtual
Iterations() const dai::JTreeinlinevirtual
JTree()dai::JTreeinline
JTree(const FactorGraph &fg, const PropertySet &opts, bool automatic=true)dai::JTree
logZ() const dai::JTreevirtual
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::JTreeinlinevirtual
message(size_t alpha, size_t _beta) const dai::JTreeinline
message(size_t alpha, size_t _beta)dai::JTreeinline
name() const dai::JTreeinlinevirtual
printProperties() const dai::JTreevirtual
props (defined in dai::JTree)dai::JTree
Qadai::JTree
Qbdai::JTree
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
RTreedai::JTree
run()dai::JTreevirtual
runHUGIN()dai::JTree
runShaferShenoy()dai::JTree
setMaxIter(size_t)dai::InfAlginlinevirtual
setProperties(const PropertySet &opts)dai::JTreevirtual
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/terminology.html0000644000175000017500000003553412552201364017151 0ustar jorismjorism 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:

dot_inline_dotgraph_2.png

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:

dot_inline_dotgraph_3.png

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:

dot_inline_dotgraph_4.png

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/varset_8h_source.html0000644000175000017500000005640512552201363020063 0ustar jorismjorism libDAI: include/dai/varset.h Source File
varset.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_varset_h
14 #define __defined_libdai_varset_h
15 
16 
17 #include <vector>
18 #include <map>
19 #include <ostream>
20 #include <dai/var.h>
21 #include <dai/util.h>
22 #include <dai/smallset.h>
23 
24 
25 namespace dai {
26 
27 
28 // Predefine for definitions of calcLinearState() and calcState()
29 class VarSet;
30 
31 
33 
60 size_t calcLinearState( const VarSet &vs, const std::map<Var, size_t> &state );
61 
62 
64 
85 std::map<Var, size_t> calcState( const VarSet &vs, size_t linearState );
86 
87 
89 
94 class VarSet : public SmallSet<Var> {
95  public:
97 
98  VarSet() : SmallSet<Var>() {}
100 
102  VarSet( const SmallSet<Var> &x ) : SmallSet<Var>(x) {}
103 
105  VarSet( const Var &v ) : SmallSet<Var>(v) {}
106 
108  VarSet( const Var &v1, const Var &v2 ) : SmallSet<Var>(v1,v2) {}
109 
111 
116  template <typename VarIterator>
117  VarSet( VarIterator begin, VarIterator end, size_t sizeHint=0 ) : SmallSet<Var>(begin,end,sizeHint) {}
119 
121 
122 
130  BigInt nrStates() const {
131  BigInt states = 1;
132  for( VarSet::const_iterator n = begin(); n != end(); n++ )
133  states *= (BigInt)n->states();
134  return states;
135  }
137 
139 
140  friend std::ostream& operator<<( std::ostream &os, const VarSet &vs ) {
142  os << "{";
143  for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ )
144  os << (v != vs.begin() ? ", " : "") << *v;
145  os << "}";
146  return( os );
147  }
148 
150  std::string toString() const {
151  std::stringstream ss;
152  ss << *this;
153  return ss.str();
154  }
156 };
157 
158 
159 } // end of namespace dai
160 
161 
172 #endif
dai::VarSet::toString
std::string toString() const
Formats a VarSet as a string.
Definition: varset.h:150
dai::VarSet::VarSet
VarSet()
Default constructor (constructs an empty set)
Definition: varset.h:99
dai::calcLinearState
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 par...
Definition: varset.cpp:18
dai::SmallSet< Var >::end
iterator end()
Returns iterator that points beyond the last element.
Definition: smallset.h:198
dai::VarSet::nrStates
BigInt nrStates() const
Calculates the number of states of this VarSet, which is simply the number of possible joint states o...
Definition: varset.h:130
var.h
Defines class Var, which represents a discrete random variable.
dai::SmallSet< Var >::begin
iterator begin()
Returns iterator that points to the first element.
Definition: smallset.h:193
dai::BigInt
mpz_class BigInt
Arbitrary precision integer number.
Definition: util.h:101
dai::SmallSet< Var >::const_iterator
std::vector< Var >::const_iterator const_iterator
Constant iterator over the elements.
Definition: smallset.h:182
dai::VarSet::VarSet
VarSet(VarIterator begin, VarIterator end, size_t sizeHint=0)
Construct a VarSet from the range between begin and end.
Definition: varset.h:117
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
util.h
Defines general utility functions and adds an abstraction layer for platform-dependent functionality...
dai::VarSet::VarSet
VarSet(const Var &v)
Construct a VarSet with one element, v.
Definition: varset.h:105
smallset.h
Defines the SmallSet<> class, which represents a set (optimized for a small number of elements)...
dai::VarSet::VarSet
VarSet(const SmallSet< Var > &x)
Construct from SmallSet x.
Definition: varset.h:102
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::calcState
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...
Definition: varset.cpp:31
dai::SmallSet
Represents a set; the implementation is optimized for a small number of elements. ...
Definition: smallset.h:32
dai::VarSet::VarSet
VarSet(const Var &v1, const Var &v2)
Construct a VarSet with two elements, v1 and v2.
Definition: varset.h:108
dai::VarSet::operator<<
friend std::ostream & operator<<(std::ostream &os, const VarSet &vs)
Writes a VarSet to an output stream.
Definition: varset.h:141
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__log-members.html0000644000175000017500000000561512552201365022216 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1Evidence-members.html0000644000175000017500000001431212552201365022107 0ustar jorismjorism libDAI: Member List
dai::Evidence Member List

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

_samplesdai::Evidenceprivate
addEvidenceTabFile(std::istream &is, FactorGraph &fg)dai::Evidence
addEvidenceTabFile(std::istream &is, std::map< std::string, Var > &varMap)dai::Evidenceprivate
begin()dai::Evidenceinline
begin() const dai::Evidenceinline
const_iterator typedefdai::Evidence
end()dai::Evidenceinline
end() const dai::Evidenceinline
Evidence()dai::Evidenceinline
Evidence(std::vector< Observation > &samples)dai::Evidenceinline
iterator typedefdai::Evidence
nrSamples() const dai::Evidenceinline
Observation typedefdai::Evidence
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1BBPCostFunction-members.html0000644000175000017500000001025112552201364023324 0ustar jorismjorism libDAI: Member List
dai::BBPCostFunction Member List

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

BBPCostFunction()dai::BBPCostFunctioninline
BBPCostFunction(const BBPCostFunctionBase &x)dai::BBPCostFunctioninline
evaluate(const InfAlg &ia, const std::vector< size_t > *stateP) const dai::BBPCostFunction
needGibbsState() const dai::BBPCostFunction
operator=(const BBPCostFunctionBase &x)dai::BBPCostFunctioninline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_42.png0000644000175000017500000000073412552200224015655 0ustar jorismjorism‰PNG  IHDR€ ’EZ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïKIDATxíÝ’Â …?~ ­Èû¿í&€ δ½Ý ¡ZcrNNrðïÞ;À©› À­ÛàmîÖë©aÏÄ8½LÃ|ÿz`wÅpé‘’â·Í/Ã+Û¨ŸØf½¶Fä™ò°RƒµÄMAœºä*­—øœ5[*þ«ß®…§‹ÎåZ­ÄÝkdÜLXŽ9j zK@N ý1Çäa ”‘ŸvùtÀ/dÜ™øÊÖGN*R {¸šGí´k¢À·»Cz Oú~?¢q+ò¡¹f2Àr¶ˆMؘI}ê¼”(.KN:çbcÔ˜¤Rš¦¢ ÆçÖ¹³ÑJº>ÎŒ –ãµ»£˜öÏ÷¨J‘+édžZv^–u&•£ õÛ ‚fÒðç²+mÇ.ˆÂÚ†“¬af£¶+I€_¸{í=À_=Ð…8÷M£Û\±@!IEND®B`‚libDAI-0.3.2/doc/html/index_8h_source.html0000644000175000017500000024667412552201363017677 0ustar jorismjorism libDAI: include/dai/index.h Source File
index.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_index_h
14 #define __defined_libdai_index_h
15 
16 
17 #include <vector>
18 #include <algorithm>
19 #include <map>
20 #include <dai/varset.h>
21 
22 
23 namespace dai {
24 
25 
27 
48 class IndexFor {
49  private:
51  long _index;
52 
54  std::vector<long> _sum;
55 
57  std::vector<size_t> _state;
58 
60  std::vector<size_t> _ranges;
61 
62  public:
64  IndexFor() : _index(-1) {}
65 
67  IndexFor( const VarSet& indexVars, const VarSet& forVars ) : _state( forVars.size(), 0 ) {
68  long sum = 1;
69 
70  _ranges.reserve( forVars.size() );
71  _sum.reserve( forVars.size() );
72 
73  VarSet::const_iterator j = forVars.begin();
74  for( VarSet::const_iterator i = indexVars.begin(); i != indexVars.end(); ++i ) {
75  for( ; j != forVars.end() && *j <= *i; ++j ) {
76  _ranges.push_back( j->states() );
77  _sum.push_back( (*i == *j) ? sum : 0 );
78  }
79  sum *= i->states();
80  }
81  for( ; j != forVars.end(); ++j ) {
82  _ranges.push_back( j->states() );
83  _sum.push_back( 0 );
84  }
85  _index = 0;
86  }
87 
89  IndexFor& reset() {
90  fill( _state.begin(), _state.end(), 0 );
91  _index = 0;
92  return( *this );
93  }
94 
96  operator size_t() const {
97  DAI_ASSERT( valid() );
98  return( _index );
99  }
100 
102  IndexFor& operator++ () {
103  if( _index >= 0 ) {
104  size_t i = 0;
105 
106  while( i < _state.size() ) {
107  _index += _sum[i];
108  if( ++_state[i] < _ranges[i] )
109  break;
110  _index -= _sum[i] * _ranges[i];
111  _state[i] = 0;
112  i++;
113  }
114 
115  if( i == _state.size() )
116  _index = -1;
117  }
118  return( *this );
119  }
120 
122  void operator++( int ) {
123  operator++();
124  }
125 
127  bool valid() const {
128  return( _index >= 0 );
129  }
130 };
131 
132 
134 
137 class Permute {
138  private:
140  std::vector<size_t> _ranges;
142  std::vector<size_t> _sigma;
143 
144  public:
146  Permute() : _ranges(), _sigma() {}
147 
149  Permute( const std::vector<size_t> &rs, const std::vector<size_t> &sigma ) : _ranges(rs), _sigma(sigma) {
150  DAI_ASSERT( _ranges.size() == _sigma.size() );
151  }
152 
154 
158  Permute( const std::vector<Var> &vars, bool reverse=false ) : _ranges(), _sigma() {
159  size_t N = vars.size();
160 
161  // construct ranges
162  _ranges.reserve( N );
163  for( size_t i = 0; i < N; ++i )
164  if( reverse )
165  _ranges.push_back( vars[N - 1 - i].states() );
166  else
167  _ranges.push_back( vars[i].states() );
168 
169  // construct VarSet out of vars
170  VarSet vs( vars.begin(), vars.end(), N );
171  DAI_ASSERT( vs.size() == N );
172 
173  // construct sigma
174  _sigma.reserve( N );
175  for( VarSet::const_iterator vs_i = vs.begin(); vs_i != vs.end(); ++vs_i ) {
176  size_t ind = find( vars.begin(), vars.end(), *vs_i ) - vars.begin();
177  if( reverse )
178  _sigma.push_back( N - 1 - ind );
179  else
180  _sigma.push_back( ind );
181  }
182  }
183 
185 
188  size_t convertLinearIndex( size_t li ) const {
189  size_t N = _ranges.size();
190 
191  // calculate vector index corresponding to linear index
192  std::vector<size_t> vi;
193  vi.reserve( N );
194  size_t prod = 1;
195  for( size_t k = 0; k < N; k++ ) {
196  vi.push_back( li % _ranges[k] );
197  li /= _ranges[k];
198  prod *= _ranges[k];
199  }
200 
201  // convert permuted vector index to corresponding linear index
202  prod = 1;
203  size_t sigma_li = 0;
204  for( size_t k = 0; k < N; k++ ) {
205  sigma_li += vi[_sigma[k]] * prod;
206  prod *= _ranges[_sigma[k]];
207  }
208 
209  return sigma_li;
210  }
211 
213  const std::vector<size_t>& sigma() const { return _sigma; }
214 
216  std::vector<size_t>& sigma() { return _sigma; }
217 
219  const std::vector<size_t>& ranges() { return _ranges; }
220 
222  size_t operator[]( size_t i ) const {
223 #ifdef DAI_DEBUG
224  return _sigma.at(i);
225 #else
226  return _sigma[i];
227 #endif
228  }
229 
231  Permute inverse() const {
232  size_t N = _ranges.size();
233  std::vector<size_t> invRanges( N, 0 );
234  std::vector<size_t> invSigma( N, 0 );
235  for( size_t i = 0; i < N; i++ ) {
236  invSigma[_sigma[i]] = i;
237  invRanges[i] = _ranges[_sigma[i]];
238  }
239  return Permute( invRanges, invSigma );
240  }
241 };
242 
243 
245 
263 class multifor {
264  private:
266  std::vector<size_t> _ranges;
268  std::vector<size_t> _indices;
270  long _linear_index;
271 
272  public:
274  multifor() : _ranges(), _indices(), _linear_index(0) {}
275 
277  multifor( const std::vector<size_t> &d ) : _ranges(d), _indices(d.size(),0), _linear_index(0) {}
278 
280  operator size_t() const {
281  DAI_DEBASSERT( valid() );
282  return( _linear_index );
283  }
284 
286  size_t operator[]( size_t k ) const {
287  DAI_DEBASSERT( valid() );
288  DAI_DEBASSERT( k < _indices.size() );
289  return _indices[k];
290  }
291 
293  multifor & operator++() {
294  if( valid() ) {
295  _linear_index++;
296  size_t i;
297  for( i = 0; i != _indices.size(); i++ ) {
298  if( ++(_indices[i]) < _ranges[i] )
299  break;
300  _indices[i] = 0;
301  }
302  if( i == _indices.size() )
303  _linear_index = -1;
304  }
305  return *this;
306  }
307 
309  void operator++( int ) {
310  operator++();
311  }
312 
314  multifor& reset() {
315  fill( _indices.begin(), _indices.end(), 0 );
316  _linear_index = 0;
317  return( *this );
318  }
319 
321  bool valid() const {
322  return( _linear_index >= 0 );
323  }
324 };
325 
326 
328 
352 class State {
353  private:
355  typedef std::map<Var, size_t> states_type;
356 
358  BigInt state;
359 
361  states_type states;
362 
363  public:
365  State() : state(0), states() {}
366 
368  State( const VarSet &vs, BigInt linearState=0 ) : state(linearState), states() {
369  if( linearState == 0 )
370  for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ )
371  states[*v] = 0;
372  else {
373  for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) {
374  states[*v] = BigInt_size_t( linearState % (BigInt)v->states() );
375  linearState /= (BigInt)v->states();
376  }
377  DAI_ASSERT( linearState == 0 );
378  }
379  }
380 
382  State( const std::map<Var, size_t> &s ) : state(0), states() {
383  insert( s.begin(), s.end() );
384  }
385 
387  typedef states_type::const_iterator const_iterator;
388 
390  const_iterator begin() const { return states.begin(); }
391 
393  const_iterator end() const { return states.end(); }
394 
396  operator size_t() const {
397  DAI_ASSERT( valid() );
398  return( BigInt_size_t( state ) );
399  }
400 
402  template<typename InputIterator>
403  void insert( InputIterator b, InputIterator e ) {
404  states.insert( b, e );
405  VarSet vars;
406  for( const_iterator it = begin(); it != end(); it++ )
407  vars |= it->first;
408  state = 0;
409  state = this->operator()( vars );
410  }
411 
413  const std::map<Var,size_t>& get() const { return states; }
414 
416  operator const std::map<Var,size_t>& () const { return states; }
417 
419  size_t operator() ( const Var &v ) const {
420  states_type::const_iterator entry = states.find( v );
421  if( entry == states.end() )
422  return 0;
423  else
424  return entry->second;
425  }
426 
428  BigInt operator() ( const VarSet &vs ) const {
429  BigInt vs_state = 0;
430  BigInt prod = 1;
431  for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) {
432  states_type::const_iterator entry = states.find( *v );
433  if( entry != states.end() )
434  vs_state += (BigInt)entry->second * prod;
435  prod *= (BigInt)v->states();
436  }
437  return vs_state;
438  }
439 
441  void operator++( ) {
442  if( valid() ) {
443  state++;
444  states_type::iterator entry = states.begin();
445  while( entry != states.end() ) {
446  if( ++(entry->second) < entry->first.states() )
447  break;
448  entry->second = 0;
449  entry++;
450  }
451  if( entry == states.end() )
452  state = -1;
453  }
454  }
455 
457  void operator++( int ) {
458  operator++();
459  }
460 
462  bool valid() const {
463  return( state >= 0 );
464  }
465 
467  void reset() {
468  state = 0;
469  for( states_type::iterator s = states.begin(); s != states.end(); s++ )
470  s->second = 0;
471  }
472 };
473 
474 
475 } // end of namespace dai
476 
477 
488 #endif
dai::multifor::multifor
multifor()
Default constructor.
Definition: index.h:274
dai::BigInt_size_t
size_t BigInt_size_t(const BigInt &N)
Safe down-cast of big integer to size_t.
Definition: util.h:104
dai::State::state
BigInt state
Current state (represented linearly)
Definition: index.h:358
dai::State::insert
void insert(InputIterator b, InputIterator e)
Inserts a range of variable-state pairs, changing the current state.
Definition: index.h:403
dai::Permute::sigma
const std::vector< size_t > & sigma() const
Returns constant reference to the permutation.
Definition: index.h:213
dai::SmallSet::end
iterator end()
Returns iterator that points beyond the last element.
Definition: smallset.h:198
dai::Permute::operator[]
size_t operator[](size_t i) const
Returns the result of applying the permutation on i.
Definition: index.h:222
dai::Permute::Permute
Permute()
Default constructor.
Definition: index.h:146
dai::IndexFor::_state
std::vector< size_t > _state
For each variable in forVars, the current state.
Definition: index.h:57
dai::Permute::sigma
std::vector< size_t > & sigma()
Returns reference to the permutation.
Definition: index.h:216
dai::State::states_type
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...
Definition: index.h:355
dai::Permute::Permute
Permute(const std::vector< size_t > &rs, const std::vector< size_t > &sigma)
Construct from vector of index ranges and permutation.
Definition: index.h:149
dai::SmallSet::size
std::vector< T >::size_type size() const
Returns number of elements.
Definition: smallset.h:169
dai::SmallSet::begin
iterator begin()
Returns iterator that points to the first element.
Definition: smallset.h:193
varset.h
Defines the VarSet class, which represents a set of random variables.
dai::State::State
State(const std::map< Var, size_t > &s)
Construct from a std::map
Definition: index.h:382
dai::IndexFor::valid
bool valid() const
Returns true if the current state is valid.
Definition: index.h:127
dai::multifor::operator++
void operator++(int)
Increments the current indices (postfix)
Definition: index.h:309
dai::multifor
multifor makes it easy to perform a dynamic number of nested for loops.
Definition: index.h:263
dai::Permute::convertLinearIndex
size_t convertLinearIndex(size_t li) const
Calculates a permuted linear index.
Definition: index.h:188
dai::State
Makes it easy to iterate over all possible joint states of variables within a VarSet.
Definition: index.h:352
dai::multifor::_linear_index
long _linear_index
Stores the current linear index.
Definition: index.h:270
dai::multifor::operator[]
size_t operator[](size_t k) const
Returns k 'th index.
Definition: index.h:286
dai::IndexFor::reset
IndexFor & reset()
Resets the state.
Definition: index.h:89
dai::IndexFor
Tool for looping over the states of several variables.
Definition: index.h:48
dai::Permute::Permute
Permute(const std::vector< Var > &vars, bool reverse=false)
Construct from vector of variables.
Definition: index.h:158
dai::multifor::_indices
std::vector< size_t > _indices
Stores the current values of all indices.
Definition: index.h:268
dai::State::end
const_iterator end() const
Returns constant iterator that points beyond the last item.
Definition: index.h:393
dai::Permute::_sigma
std::vector< size_t > _sigma
Stores the permutation.
Definition: index.h:142
dai::BigInt
mpz_class BigInt
Arbitrary precision integer number.
Definition: util.h:101
dai::State::const_iterator
states_type::const_iterator const_iterator
Constant iterator over the values.
Definition: index.h:387
dai::multifor::multifor
multifor(const std::vector< size_t > &d)
Initialize from vector of index ranges.
Definition: index.h:277
dai::State::operator()
size_t operator()(const Var &v) const
Return current state of variable v, or 0 if v is not in *this.
Definition: index.h:419
dai::State::states
states_type states
Current state (represented as a map)
Definition: index.h:361
dai::IndexFor::operator++
IndexFor & operator++()
Increments the current state of forVars (prefix)
Definition: index.h:102
dai::IndexFor::operator++
void operator++(int)
Increments the current state of forVars (postfix)
Definition: index.h:122
dai::IndexFor::_index
long _index
The current linear index corresponding to the state of indexVars.
Definition: index.h:51
dai::State::valid
bool valid() const
Returns true if the current state is valid.
Definition: index.h:462
dai::SmallSet< Var >::const_iterator
std::vector< Var >::const_iterator const_iterator
Constant iterator over the elements.
Definition: smallset.h:182
dai::State::State
State()
Default constructor.
Definition: index.h:365
dai::IndexFor::_ranges
std::vector< size_t > _ranges
For each variable in forVars, its number of possible values.
Definition: index.h:60
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::IndexFor::IndexFor
IndexFor(const VarSet &indexVars, const VarSet &forVars)
Construct IndexFor object from indexVars and forVars.
Definition: index.h:67
dai::multifor::operator++
multifor & operator++()
Increments the current indices (prefix)
Definition: index.h:293
dai::State::State
State(const VarSet &vs, BigInt linearState=0)
Construct from VarSet vs and corresponding linear state linearState.
Definition: index.h:368
dai::Permute::inverse
Permute inverse() const
Returns the inverse permutation.
Definition: index.h:231
dai::Permute::_ranges
std::vector< size_t > _ranges
Stores the number of possible values of all indices.
Definition: index.h:140
dai::State::operator++
void operator++(int)
Increments the current state (postfix)
Definition: index.h:457
dai::multifor::reset
multifor & reset()
Resets the state.
Definition: index.h:314
dai::State::reset
void reset()
Resets the current state (to the joint state represented by linear state 0)
Definition: index.h:467
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::Permute
Tool for calculating permutations of linear indices of multi-dimensional arrays.
Definition: index.h:137
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
dai::IndexFor::_sum
std::vector< long > _sum
For each variable in forVars, the amount of change in _index.
Definition: index.h:54
dai::State::begin
const_iterator begin() const
Returns constant iterator that points to the first item.
Definition: index.h:390
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::Permute::ranges
const std::vector< size_t > & ranges()
Returns constant reference to the dimensionality vector.
Definition: index.h:219
dai::multifor::_ranges
std::vector< size_t > _ranges
Stores the number of possible values of all indices.
Definition: index.h:266
dai::multifor::valid
bool valid() const
Returns true if the current indices are valid.
Definition: index.h:321
dai::State::operator++
void operator++()
Increments the current state (prefix)
Definition: index.h:441
dai::IndexFor::IndexFor
IndexFor()
Default constructor.
Definition: index.h:64
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/example_sprinkler_8cpp-example.html0000644000175000017500000002604312552201363022702 0ustar jorismjorism 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/
*
* Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
*/
#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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__KL.html0000644000175000017500000001233112552201365020304 0ustar jorismjorism libDAI: dai::fo_KL< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_KL< T > Struct Template Reference

Function object useful for calculating the KL distance. More...

#include <dai/prob.h>

Inherits binary_function< T, T, T >.

Public Member Functions

T operator() (const T &p, const T &q) const
 Returns (p == 0 ? 0 : (p * (log(p) - log(q)))) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_67.png0000644000175000017500000000107012552200232015655 0ustar jorismjorism‰PNG  IHDRˆ·™fE0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï§IDATxíÙš¤ …APpáýßvÀ)(µzºÇË櫆äÍ[€_¼ÃY€oa˜ÿð#7t:w£‹mÙt'Ø´ :Òv/;NnvȧìÞž¢ÎÑŒyÕá}úšI*âux‡_ÙpÂ4—ý­u笪¢ì,ãËÊDö|A€3*Á3‘]vòÃsD†¤Á¾I¿["zèa"l)EÑc¯tU"kKdÓ|J’°OÁÅ´Šc>××ËŸÓó¡ÑZT{[±ʨ.8’x /Ks¨Á óO‰4¡×Z±V»a.™V"azÏ/“ô¿6DrÌØr-åÙä:¨2-‘(·wsÈ·;êµ£aºlxã]²Š¼ÞÄ.ªË‡äO¡r»Ë󠾫2½Gä|í\…¬*%rj5Þ 1­§ "Gê:Àe»!2,¢å°ŸÉ6cíû8Ðü:"cɦÚýÛöpF•iˆ8‘Ü5Åä*o»¶n>}ÈöNtš²÷þÃ’’8¡,ÑzŽì—Ø›w§\Át¹ ðŸÐ¢·Òº|t.~ÿcð¬÷_=ÀÙI ¸º©ÑIEND®B`‚libDAI-0.3.2/doc/html/functions_vars_z.html0000644000175000017500000001124112552201370020157 0ustar jorismjorism libDAI: Class Members - Variables
 

- z -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/folderopen.png0000644000175000017500000000112512552201363016542 0ustar jorismjorism‰PNG  IHDRÚ}\ˆIDATxí]?oÓPÿ9iš4i°;ii“¶‰ZŠ‰‘‰ÀÀ7`bèÔÙ¬Øù,HìU'ô$*Tµ]‚T¡DPÚÄ6wÏ}‰;¡C; a¿ÓߟûÝïîž¼jAÀ­InSþ}€9H“ÓŽ|?íÁ÷ =_ÊÆŠ­†¥Àue*;¯YEäsYäæB¢Ÿ¿þÄ—£sÙ½½ÙŒ† É«›©ÀYÇq !GÇ¿v̇¹ÑØ®š °Œ‚ÔF¹}q¥b]÷7í·0)Úd›¾ÿð-èº}Pfä£ÖY{4™ÑÂ@}úæôñ2ÛüÔ—ñúåNŒI‚ÁǃcçÁº%£¬UŠ°I³mc±ô˜å¼ÔÆüÈ>é¸xþt9Æ$µý OæVE*õU´Ì‚ç#ž×ˆ•ïûr@l$øPÿrHaaÇ¥ ²›dZ®rè‘ãqI„o¼øT\Ž,tªj2FAxv-LŸp׌p TÄI/ \¥sfí½; jViTƒèú¤o^cpÅü¼ûû»Ïb]”€¢¤<†aþÕœ²“ßÓ˜y“£§9:Œîù+À³€ñà,E žf³6éNˆÄE£KU}Ü^;¶ØnZ¢uß­US4— ѬëbížN¶.Úk¦ØjTÄöº%µªâ i¯VÄÊÝò§™ Èù¸)ùÿG€™òºJ@T x”IEND®B`‚libDAI-0.3.2/doc/html/form_44.png0000644000175000017500000000033512552200225015655 0ustar jorismjorism‰PNG  IHDR x[LP0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïLIDATxíÝí € „á—–òQÁýÇTüå—\ÉCn€Ÿ¦˜6¹ÐÆc/Û™ÃÆPz_#GÌêÃ5+ÁueÞ¾xG<|{Jõù°ÑÎIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1multifor-members.html0000644000175000017500000001324212552201367022231 0ustar jorismjorism libDAI: Member List
dai::multifor Member List

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

_indicesdai::multiforprivate
_linear_indexdai::multiforprivate
_rangesdai::multiforprivate
multifor()dai::multiforinline
multifor(const std::vector< size_t > &d)dai::multiforinline
operator size_t() const dai::multiforinline
operator++()dai::multiforinline
operator++(int)dai::multiforinline
operator[](size_t k) const dai::multiforinline
reset()dai::multiforinline
valid() const dai::multiforinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BP__dual_1_1messages-members.html0000644000175000017500000000740112552201364024441 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/files.html0000644000175000017500000004466712552201370015707 0ustar jorismjorism libDAI: File List
File List
Here is a list of all documented files with brief descriptions:
[detail level 1234]
 ▼ include
 ▼ dai
 ▼ matlab
 matlab.hDefines some utility functions for interfacing with MatLab
 alldai.hMain libDAI header file. It #includes all other libDAI headers
 bbp.hDefines class BBP, which implements Back-Belief-Propagation
 bipgraph.hDefines the BipartiteGraph class, which represents a bipartite graph
 bp.hDefines class BP, which implements (Loopy) Belief Propagation
 bp_dual.hDefines class BP_dual, which is used primarily by BBP
 cbp.hDefines class CBP, which implements Conditioned Belief Propagation
 clustergraph.hDefines class ClusterGraph, which is used by JTree, TreeEP and HAK
 cobwebgraph.hDefines class CobwebGraph, which implements a type of region graph used by GLC
 createfg.hProvides functionality for input/output of data structures in various file formats
 dag.hDefines the DAG class, which represents a directed acyclic graph
 dai_config.hAllows the user to specify which algorithms will be built into libDAI
 daialg.hDefines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG)
 decmap.hDefines class DecMAP, which constructs a MAP state by decimation
 doc.hContains additional doxygen documentation
 emalg.hDefines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters)
 enum.hDefines the DAI_ENUM macro, which can be used to define an enum with additional functionality
 evidence.hDefines class Evidence, which stores multiple observations of joint states of variables
 exactinf.hDefines ExactInf class, which can be used for exact inference on small factor graphs
 exceptions.hDefines the Exception class and macros for throwing exceptions and doing assertions
 factor.hDefines TFactor<> and Factor classes which represent factors in probability distributions
 factorgraph.hDefines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields)
 fbp.hDefines class FBP, which implements Fractional Belief Propagation
 gibbs.hDefines class Gibbs, which implements Gibbs sampling
 glc.hDefines classes GLC and Cobweb, which implement the "Generalized Loop Correction method"
 graph.hDefines the GraphAL class, which represents an undirected graph as an adjacency list
 hak.hDefines class HAK, which implements a variant of Generalized Belief Propagation
 index.hDefines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays
 io.hProvides functionality for input/output of data structures in various file formats
 jtree.hDefines class JTree, which implements the junction tree algorithm
 lc.hDefines class LC, which implements loop corrections for approximate inference
 mf.hDefines class MF which implements the Mean Field algorithm
 mr.hDefines class MR, which implements loop corrections as proposed by Montanari and Rizzo
 prob.hDefines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables)
 properties.hDefines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms
 regiongraph.hDefines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs
 smallset.hDefines the SmallSet<> class, which represents a set (optimized for a small number of elements)
 treeep.hDefines class TreeEP, which implements Tree Expectation Propagation
 trwbp.hDefines class TRWBP, which implements Tree-Reweighted Belief Propagation
 util.hDefines general utility functions and adds an abstraction layer for platform-dependent functionality
 var.hDefines class Var, which represents a discrete random variable
 varset.hDefines the VarSet class, which represents a set of random variables
 weightedgraph.hDefines some utility functions for (weighted) undirected graphs, trees and rooted trees
 config.h
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1ParameterEstimation.png0000644000175000017500000000126112552201367022533 0ustar jorismjorism‰PNG  IHDR•P'YÇzPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2@IDATxíË–ë ‹öüÿ7ßÄ$™Ñœ; Ê¡ý! ÊšRJ9N€Ã”T1%@L•=ö§Z?j {ŠÉ7iö½©Æ®ÖLXÛ§ø”بž?‰º>¿ÆzyÖ}µ˜¶ÔûÝ.uÈÙ]ûïèeŠÿf·¶Ï¾ƒ(®õ{M`1wšyÎe“Ÿ¶bù ƨ<àî\y ø6S¹sUgðmîò“wT>Õ|ìûŽ¶˜æ@wQÃRÚœâ*w¨ 0i¿öÅÕ5øÓî©Æsõ;ªÍ~‡¥ò5ØätÀ†r1­†| ºÿ«v™w°ÝX÷ À)J*€˜’ ¦¤ˆéXªRJ9M¤/€ãt$Õ×׉XGR½ Ä:“ àD¥S1¥W1¥W1¥W1¥W1¥W1¥W1¥W1¥W1¥W1¥W1¥W1ý¥W×u]ljK’SRIRLI%I1 Teó¤òúIÒ¢Wï{l|Þï¡>öŽ•¤QûÞÏTSßvnË9 6*IÖ>®K’VÕka墨@¿Hóì~¯ÔèNUß|„exFîð>ÇõN™ª;ª}BEÖ Ïb\ô“xáíSl5Ã'|¾‰Ê™¿ze‰†LÏÙi³§¡ž©H¾Í]ò¹~¦šF·C;ûûWbT»Ïý•TvMEÖ¾£ÏÕTƒË7Kçê×T¾Û‰låbeã6zµt¬ÁvæÚeÞÁ8–ýJ%I§(©$)¦¤’¤˜’J’b:–꺮ë4ý˜j$òIdZIEND®B`‚libDAI-0.3.2/doc/html/example_imagesegmentation_8cpp-example.html0000644000175000017500000010436412552201363024374 0ustar jorismjorism 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/
*
* Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
*/
#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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BP__dual_1_1__edges__t.html0000644000175000017500000000724212552201364023254 0ustar jorismjorism libDAI: dai::BP_dual::_edges_t< T > Struct Template Reference
List of all members
dai::BP_dual::_edges_t< T > Struct Template Reference

Convenience label for storing edge properties. More...

#include <dai/bp_dual.h>

Inheritance diagram for dai::BP_dual::_edges_t< T >:

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_n.html0000644000175000017500000002414112552201370020126 0ustar jorismjorism libDAI: Class Members - Functions
 

- n -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/dot_inline_dotgraph_4.png0000644000175000017500000001012112552201364020641 0ustar jorismjorism‰PNG  IHDR­9Ë:ýôÓ¯¾úÊÚÚEÜÔÔtûöm•JõóÏ?»ººêëÕßߟ‘‘Çã·mÛ¶jÕ*ôZ•——WUUùùùýøã赚•ªªª;wîøûû‡‡‡#6ÄbqAA@ ÿøã§'ÃÿMVV›Í–H$°>455‰ÄgÏžaÏ222B£Ñ®_¿Aö\ݸqƒF£!.Fêëë‰Dâ«W¯°gaX*•ž8qâ·ß~Ó+×åË—“““e2™^¹^¼xÝÐРWõ¨T*—ËÕ«5M^^N›úóÿÄZ­ŽçñxØ Aiii\.‹X DGG æ%‹£££»ºº°ˆ ÏŸ?¯WgM¥²²’Á`¨ÕjJ•JW]]m˜AgÏž½uëqGGGttôðð°a^"‘(**ª»»{ò'ÿ‰6›ÝÒÒbX¹“dee=xð]322­R©Œ1R©TÑÑÑ:;§ï=“ÖÖV6›­S–˜˜ØÑÑa¤×¯¿þZUU…®‘H$D"Kh¢ T*£¢¢&G…âàþýû#Q'T*uttE`ðH0•ááá„„ÁØØ…B1Þ†áâââòòrÁÝ»wKKKMâE¡PÆÇÇQt:]ß÷¬ &&&"·Bf åååaaaèS’ÚÚÚ„„„}ûö¡Ë>œ­-õõë×...NNN(%´µµmܸÝ€¬ô„B¡6‡Ã9pàz!999t:Ãá ËBBB***Pß~û­N¯]»v1 tÙÁƒsssµ¥vuuyxx8::¢211áíí®qvv¶··ïíí†%Éùóçu†B¡èì쌌ŒÔ©<~ü¸¶¤ÌÌ̾¾>ôìJ¥̘ÀΊH$ºxñ¢Õ˜ÄÏϯµµÕ××W§ò—_~Ñ6Œõ÷÷§§§£gW«Õýýý"‘ÈÉÉI§JÍÓÒÒ°L ZZZ°ôaww7òÞ´´··¿÷Þ{è±ÀápüñÇøøxgg'ºÒÊÊJ[ÒÀÀ€››zvì,...b±Ø€jLÒÝݽ|ùòžžÊ•+W¶µµÍš„¥­­­—,YR__O"‘tz¡Ô\*•¢¯­­­—»Ë—/GÆ+Ÿ˜˜Ð™ÇÖÖ666–ÉdÞ¿‹Ç¬àp8‚ Î> †Qv`` [æ+V¬xóæ———NåÄÄÄüùógMÂØ2™ŒÏçÓét,Ó–¼W®\A^Í%%%èJ‚M +€ŸŸ2Œ Ãáp***ššš¾ÿþ{t¥J¥Ò–äåå¥s8éèèüý÷ß:«$<<<´¥j4%P(‡“ SÙÜÜìçç7k’¿¿ss3zvµZ}øðá¾¾¾#GŽèlJ.[¶¬»»=û™3gˆD" $$]ÙÚÚúÏ4yOP©T¥R©óu‚…§OŸÞ¼yS[êÈÈ‹Å2‰ ÃL&eæÌårkjjLb¤V« ŠàèÑ£F.ä&yòä ÊÚM*•ž:uÊ$F0 ;v YÜýóúá‡222Ðc *•*77÷»ï¾Ó&°³³³··×ùô`ÏçÛÙÙ¡Ìœ·oß~ãÆ ”g ;»víBìÞ½ûòåËÆ)•Êüüü­[·j888ØÚÚj›©èEcc£««ë¢E‹˜2¥ÌÏÏ/..6&¸ b0:·ù4 ™L0Æk``€H$j4t™@  Óéo&"”””äææê”egg—••c¤Ñh¨TªP(D—©Õj"‘888hŒWoo/™Lžì™ÿZZdggë\ÿhctt”L&¿xñ‹X.—ÇÆÆêu1•úúú;v`ù¿|ù’D"éu1•ŒŒ ‡ƒQüûï¿_¾|Ù0#©TJ$›šš°ˆGGGcbbô:˜JmmíÑ£G§îVM_bþõ×_$©¶¶{¡&;;›F£é¡eff&%%é•khh()))==‚ ÊÊJ:ž““£óÅ,‹ãââ®^½ªsü˜Jmm-‰Dzüø1ö,0 WWW“H¤ºº:ìYÔjuVVN×뼂 K—.±X,±XŒ=—H$:~üøÌ`åÜ9Ó{õê•Ohh¨³³³¶ ŸÏ/..–ÉdááákÖ¬1à544¬ín‹R©|ôèÑÇ-Z9õ„úùóçÞÞÞ?ýôúÁwIIɵk×>øàƒÐÐP”ã`±X|çÎöööÀÀÀ]»vaÙ„˜AQQQ¶¶¶«W¯Þºu+ÊyzSSSqqñØØØÎ;W¯^­¯ ¿¿ÿСC_|ñņ ´m½( Çãñ"##gNª´ÞCtvv–––ŠÅbDfmm,Æ?ýýý·lÙbðF“°wï^ooo÷øñc¥R‰Ãáp8²¨E_‚æÍ›·~ýúàà`m¿•ÆÆÆ¢¢"—ˆˆ<?S 233ÙlöÛ·oïÞ½‹Ì³Ò&…8.^¼xóæ;¾¾†5 póæMF³{÷¶{÷îI$kkëY;påÊ•[¶l±³³3ÌH©TR©Ô#GŽxzz>|øðÉ“'ȤØÊÊjÞ¼y0 #‡yáñø    6h kìC Ãèk'½P($©³³sÖÔŠŠŠû÷ïë[æ«W¯âãã/^¼8휦¥¥%66VÛ § Ã0‡Ã)**Ò–jB¯‰‰‰ØØØžžžYS …^úÝ 2ÕD…BO&“—/_>«À€«M€€€‹ÕÕÕ•œœL <øÎ;ïðùüëׯ§¤¤h{LxÑ2++ËÉÉ)44T›ÀT^ããã4F£i»{¨¯‘!Ým$:Û`$ÞÞÞ,K(ž;wnppÐÆÆ&55Õ€×¼¾\¸pÁËËKçžñÈårF§Ó—.]jª2ÍÞ;ÓËåT*5..ÎLA0‰§§ç7ß|cmm½xñb6›=<>žÉd¢ßé5€¹‹óµa&•••=š¼ñáââ#‹³²²äryDD„ ?qæÌ™   ®Pë‹D"a±XÉÉÉööö&/|Žâ@"‘0™L3µa<¯®®næµ''' …2::š——×ÕÕuàÀcŒ`f2™_ýõ'Ÿ|bL9X‰DL&óäÉ“/2Ñ™‹80w¦RVVÖÜÜL&“µ ììì<(—Ësrr„BáÞ½{ 3‚a8111$$äÃ?4´²Xéïï?qâÄ©S§þ92z­Y“’’ôÒÃ0Ü××wøðaô›«3yôèò©#½(--ÍÌÌÄ®Ÿ˜˜¸råʺuëš››õ2Òh44­±±QÏ ÒÝÝÝQQQoß¾Õ7£^˜w½ÐÓÓsòäÉÔÔT3ò¿),,|ýúµÎ‹©SÁãñû÷ïß´iS]]™L®««Ã’K£ÑÄÅÅíÙ³'00ÐÐÊbE(ž={öôéÓÚ®B™ 3ÆÁœµÀår'&&"## Èkmm½gÏž3gÎ …R[[‹"Fö‘3C+‹@žžžšš:ëN¹i1W‚ŒŒŒ¹irÙdÏž=Æbeež’’2005ë-u¥RI¡PöïßoÌéFZ[[ÓÓÓOœ8a¦EOÃ,qÐÚÚzéÒ%6›=m¸zõ*ß½{·IJ³²² IKK“Ëåd2yê=O…BÁ`0Èd²ÎÏŸÏÏËËKII1lÝLHNŸ>=mÈÊÊ"Û¶m3m±8.$$äܹs ,ˆ‰‰)))‘Ëå …D"i;1! ×®]KLLœƒ½ðILìÔÐЗ—77m¸pá‚‹‹ Ê¡ŽñlܸñìÙ³ ,øì³Ïüüü̱9ººº¢¢"6›=—ALHX,ÖÜÁœíçß¾}ûÞ½{kÖ¬a0¹¹¹X®ÃFuuuYY‹Å2òk1 ÀdCwMMMEE‹Å2U(¤¦¦®]»vŽ÷󃂂 †ÎëOú2m/|ŽÁÁ0ÜÞÞžŸŸeu×ÒÒ²råÊ™?‡ èÙ³g“ß²ñöíÛÄÄÄYKàr¹]]]:Äb1A...3“z{{Õjõä÷»xzzj»QÎd2±¬V´5 ðüùó÷ß)D¡PìܹQ¾|ù’Ëå.Y²dß¾}óçÏçóù\.×/FS__ÿÑG!ÿT*•X>ZcBlB¡pÓ¦Mëׯ7U¡L&S[ŸÏ?v옩ŒÐ½T*ÕTFOŸ>Èo100000°³³399ÙÁÁÁÛÛ{óæÍk×®5•z£ÌÁ\ß?øÿ„“É -//ÿ¿®‹±XâÀX|}}ç`ºjn,q`KX@°Ä,q`Á°ÄKXÀ,q`KX@°Ä,q`Á°Ä€››[fffqq±© •ÉdÚ’ÜÜÜh4š©Œ(ÿs—H$2¡—\.×ö¸»»s8.—kB/S…´ïɲð¿Ã¿C§<>ÔzQýIEND®B`‚libDAI-0.3.2/doc/html/closed.png0000644000175000017500000000020412552201363015653 0ustar jorismjorism‰PNG  IHDR à‘KIDATxíÝm @!†ÑGk™É7À-`&séts¦Àñþòð@åk}ª2€… P%Á_Ëþ¿N² .:0Dk¥‹Â›x" Ö›)¡xÒ5õIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1TreeEP.html0000644000175000017500000022361612552201370020066 0ustar jorismjorism libDAI: dai::TreeEP Class Reference
Classes | Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
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

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...
 

Public Member Functions

 TreeEP ()
 Default constructor. More...
 
 TreeEP (const TreeEP &x)
 Copy constructor. More...
 
TreeEP & operator= (const TreeEP &x)
 Assignment operator. More...
 
 TreeEP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
General InfAlg interface
virtual TreeEP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual TreeEP * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
- Public Member Functions inherited from dai::JTree
 JTree ()
 Default constructor. More...
 
 JTree (const FactorGraph &fg, const PropertySet &opts, bool automatic=true)
 Construct from FactorGraph fg and PropertySet opts. More...
 
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
std::vector< size_t > findMaximum () const
 
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). More...
 
void GenerateJT (const FactorGraph &fg, const std::vector< VarSet > &cl)
 Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence). More...
 
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. More...
 
Factor & message (size_t alpha, size_t _beta)
 Returns reference to the message from outer region alpha to its _beta 'th neighboring inner region. More...
 
void runHUGIN ()
 Runs junction tree algorithm using HUGIN (message-free) updates. More...
 
void runShaferShenoy ()
 Runs junction tree algorithm using Shafer-Shenoy updates. More...
 
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. More...
 
Factor calcMarginal (const VarSet &vs)
 Calculates the marginal of a set of variables (using cutset conditioning, if necessary) More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 

Public Attributes

struct dai::TreeEP::Properties props
 
- Public Attributes inherited from dai::JTree
RootedTree RTree
 The junction tree (stored as a rooted tree) More...
 
std::vector< Factor > Qa
 Outer region beliefs. More...
 
std::vector< Factor > Qb
 Inner region beliefs. More...
 
struct dai::JTree::Properties props
 

Private Member Functions

void construct (const FactorGraph &fg, const RootedTree &tree)
 Helper function for constructors. More...
 
bool offtree (size_t I) const
 Returns true if factor I is not part of the tree. More...
 

Private Attributes

Real _maxdiff
 Maximum difference encountered so far. More...
 
size_t _iters
 Number of iterations needed. More...
 
std::map< size_t, TreeEPSubTree > _Q
 Stores a TreeEPSubTree object for each off-tree factor. More...
 

Additional Inherited Members

- Related Functions inherited from dai::JTree
std::pair< size_t, BigInt > boundTreewidth (const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates=0)
 Calculates upper bound to the treewidth of a FactorGraph, using the specified heuristic. 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
fgFactor graph.
optsParameters
See also
Properties

Member Function Documentation

TreeEP& dai::TreeEP::operator= ( const TreeEP &  x)
inline

Assignment operator.

virtual TreeEP* dai::TreeEP::clone ( ) const
inlinevirtual

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

Reimplemented from dai::JTree.

virtual TreeEP* dai::TreeEP::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Reimplemented from dai::JTree.

virtual std::string dai::TreeEP::name ( ) const
inlinevirtual

Returns the name of the algorithm.

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_IMPLEMENTEDif 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)
inlinevirtual

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_IMPLEMENTEDif 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
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::JTree.

virtual size_t dai::TreeEP::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::JTree.

virtual void dai::TreeEP::setMaxIter ( size_t  )
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif 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
inlineprivate

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.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/nav_f.png0000644000175000017500000000023112552201363015473 0ustar jorismjorism‰PNG  IHDR8³»`IDATxíÝK€ EÑ–·[†øBÑmkâÄÂH—prÓ¼.‚Žó‚ꎤR6Z VI±E‚5j³„lóš›iI˜¬ÞêçJ0ŒÑÑ/Žû›™uøñóÞ¿6sH ÝõyIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1hash__map.html0000644000175000017500000000705112552201366020657 0ustar jorismjorism 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>

Inherits unordered_map< T, U, 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1State.html0000644000175000017500000010500112552201370020005 0ustar jorismjorism libDAI: dai::State Class Reference
Public Types | Public Member Functions | Private Types | Private Attributes | List of all members
dai::State Class Reference

Makes it easy to iterate over all possible joint states of variables within a VarSet. More...

#include <dai/index.h>

Public Types

typedef states_type::const_iterator const_iterator
 Constant iterator over the values. More...
 

Public Member Functions

 State ()
 Default constructor. More...
 
 State (const VarSet &vs, BigInt linearState=0)
 Construct from VarSet vs and corresponding linear state linearState. More...
 
 State (const std::map< Var, size_t > &s)
 Construct from a std::map<Var, size_t> More...
 
const_iterator begin () const
 Returns constant iterator that points to the first item. More...
 
const_iterator end () const
 Returns constant iterator that points beyond the last item. More...
 
 operator size_t () const
 Return current linear state. More...
 
template<typename InputIterator >
void insert (InputIterator b, InputIterator e)
 Inserts a range of variable-state pairs, changing the current state. More...
 
const std::map< Var, size_t > & get () const
 Return current state represented as a map. More...
 
 operator const std::map< Var, size_t > & () const
 Cast into std::map<Var, size_t> More...
 
size_t operator() (const Var &v) const
 Return current state of variable v, or 0 if v is not in *this. More...
 
BigInt operator() (const VarSet &vs) const
 Return linear state of variables in vs, assuming that variables that are not in *this are in state 0. More...
 
void operator++ ()
 Increments the current state (prefix) More...
 
void operator++ (int)
 Increments the current state (postfix) More...
 
bool valid () const
 Returns true if the current state is valid. More...
 
void reset ()
 Resets the current state (to the joint state represented by linear state 0) More...
 

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. More...
 

Private Attributes

BigInt state
 Current state (represented linearly) More...
 
states_type states
 Current state (represented as a map) More...
 

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,
BigInt  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.

BigInt 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.

Examples:
example_permute.cpp, and example_varset.cpp.
void dai::State::reset ( )
inline

Resets the current state (to the joint state represented by linear state 0)

Member Data Documentation

BigInt 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_15.png0000644000175000017500000000047312552200216015656 0ustar jorismjorism‰PNG  IHDRÙ&TÞ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïªIDATxíKÄ DŸâ*zÿÛ¨Éü²œ}@ìn‹†\àßÖn"‹& ð®Y®úºz€ïhêëÔ—äCvÚ6ÍÓÂôЗlqà»VLŒ)µ´‘\VÞ!½‰Š?ù£Q³œÿ1»& mÄ8ÜSÙÑxÜLÀUûšÞ²ÄiE–ŠåOs„¢’nxàÒêÓKN²~jIEND®B`‚libDAI-0.3.2/doc/html/cbp_8h_source.html0000644000175000017500000017621712552201363017327 0ustar jorismjorism libDAI: include/dai/cbp.h Source File
cbp.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_cbp_h
14 #define __defined_libdai_cbp_h
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_CBP
19 
20 
21 #include <fstream>
22 #include <boost/shared_ptr.hpp>
23 
24 #include <dai/daialg.h>
25 #include <dai/bbp.h>
26 
27 
28 namespace dai {
29 
30 
32 
41 class CBP : public DAIAlgFG {
42  private:
44  std::vector<Factor> _beliefsV;
46  std::vector<Factor> _beliefsF;
48  Real _logZ;
49 
51  size_t _iters;
53  Real _maxdiff;
54 
56  Real _sum_level;
58  size_t _num_leaves;
59 
61  boost::shared_ptr<std::ofstream> _clamp_ofstream;
62 
63 
64  public:
66  CBP() : DAIAlgFG(), _beliefsV(), _beliefsF(), _logZ(0.0), _iters(0), _maxdiff(0.0), _sum_level(0.0), _num_leaves(0), _clamp_ofstream() {}
67 
69 
72  CBP( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg) {
73  props.set( opts );
74  construct();
75  }
76 
78 
79  virtual CBP* clone() const { return new CBP(*this); }
80  virtual CBP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new CBP( fg, opts ); }
81  virtual std::string name() const { return "CBP"; }
82  virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); }
83  virtual Factor belief( const VarSet & ) const { DAI_THROW(NOT_IMPLEMENTED); }
84  virtual Factor beliefV( size_t i ) const { return _beliefsV[i]; }
85  virtual Factor beliefF( size_t I ) const { return _beliefsF[I]; }
86  virtual std::vector<Factor> beliefs() const { return concat(_beliefsV, _beliefsF); }
87  virtual Real logZ() const { return _logZ; }
88  virtual void init() {};
89  virtual void init( const VarSet & ) {};
90  virtual Real run();
91  virtual Real maxDiff() const { return _maxdiff; }
92  virtual size_t Iterations() const { return _iters; }
93  virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; }
94  virtual void setProperties( const PropertySet &opts ) { props.set( opts ); }
95  virtual PropertySet getProperties() const { return props.get(); }
96  virtual std::string printProperties() const { return props.toString(); }
98 
99  //----------------------------------------------------------------
100 
102  /* PROPERTIES(props,CBP) {
104  typedef BP::Properties::UpdateType UpdateType;
106  DAI_ENUM(RecurseType,REC_FIXED,REC_LOGZ,REC_BDIFF);
108  DAI_ENUM(ChooseMethodType,CHOOSE_RANDOM,CHOOSE_MAXENT,CHOOSE_BBP,CHOOSE_BP_L1,CHOOSE_BP_CFN);
110  DAI_ENUM(ClampType,CLAMP_VAR,CLAMP_FACTOR);
111 
113  size_t verbose = 0;
114 
116  Real tol;
118  UpdateType updates;
120  size_t maxiter;
121 
123  Real rec_tol;
125  size_t max_levels = 10;
127  Real min_max_adj;
129  ChooseMethodType choose;
131  RecurseType recursion;
133  ClampType clamp;
135  PropertySet bbp_props;
137  BBPCostFunction bbp_cfn;
139  size_t rand_seed = 0;
140 
142  std::string clamp_outfile = "";
143  }
144  */
145 /* {{{ GENERATED CODE: DO NOT EDIT. Created by
146  ./scripts/regenerate-properties include/dai/cbp.h src/cbp.cpp
147 */
148  struct Properties {
150  typedef BP::Properties::UpdateType UpdateType;
152  DAI_ENUM(RecurseType,REC_FIXED,REC_LOGZ,REC_BDIFF);
154  DAI_ENUM(ChooseMethodType,CHOOSE_RANDOM,CHOOSE_MAXENT,CHOOSE_BBP,CHOOSE_BP_L1,CHOOSE_BP_CFN);
156  DAI_ENUM(ClampType,CLAMP_VAR,CLAMP_FACTOR);
158  size_t verbose;
160  Real tol;
162  UpdateType updates;
164  size_t maxiter;
166  Real rec_tol;
168  size_t max_levels;
170  Real min_max_adj;
172  ChooseMethodType choose;
174  RecurseType recursion;
176  ClampType clamp;
178  PropertySet bbp_props;
180  BBPCostFunction bbp_cfn;
182  size_t rand_seed;
184  std::string clamp_outfile;
185 
187 
190  void set(const PropertySet &opts);
192  PropertySet get() const;
194  std::string toString() const;
195  } props;
196 /* }}} END OF GENERATED CODE */
197 
198  private:
200  void printDebugInfo();
201 
203 
207  void runRecurse( InfAlg *bp, Real orig_logZ, std::vector<size_t> clamped_vars_list, size_t &num_leaves,
208  size_t &choose_count, Real &sum_level, Real &lz_out, std::vector<Factor> &beliefs_out );
209 
211 
218  virtual bool chooseNextClampVar( InfAlg* bp, std::vector<size_t> &clamped_vars_list, size_t &i, std::vector<size_t> &xis, Real *maxVarOut );
219 
221 
224  InfAlg* getInfAlg();
225 
227 
230  void setBeliefs( const std::vector<Factor> &bs, Real logZ );
231 
233  void construct();
234 };
235 
236 
238 
249 std::pair<size_t, size_t> BBPFindClampVar( const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut );
250 
251 
252 } // end of namespace dai
253 
254 
255 #endif
256 
257 
258 #endif
bbp.h
Defines class BBP, which implements Back-Belief-Propagation.
dai::CBP::Properties::DAI_ENUM
DAI_ENUM(RecurseType, REC_FIXED, REC_LOGZ, REC_BDIFF)
Enumeration of possible methods for deciding when to stop recursing.
dai::CBP::chooseNextClampVar
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.
Definition: cbp.cpp:281
dai::CBP::CBP
CBP(const FactorGraph &fg, const PropertySet &opts)
Construct CBP object from FactorGraph fg and PropertySet opts.
Definition: cbp.h:72
dai::CBP::_clamp_ofstream
boost::shared_ptr< std::ofstream > _clamp_ofstream
Output stream where information about the clampings is written.
Definition: cbp.h:61
dai::CBP::_num_leaves
size_t _num_leaves
Number of leaves of recursion tree.
Definition: cbp.h:58
dai::CBP::Properties::UpdateType
BP::Properties::UpdateType UpdateType
Enumeration of possible update schedules.
Definition: cbp.h:150
dai::CBP::Properties
Parameters for CBP.
Definition: cbp.h:148
dai::CBP::construct
virtual CBP * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: cbp.h:80
dai::CBP::_sum_level
Real _sum_level
Number of clampings at each leaf node.
Definition: cbp.h:56
dai::CBP
Class for CBP (Conditioned Belief Propagation) [EaG09].
Definition: cbp.h:41
dai::CBP::belief
virtual Factor belief(const VarSet &) const
Returns the (approximate) marginal probability distribution of a set of variables.
Definition: cbp.h:83
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::CBP::_maxdiff
Real _maxdiff
Maximum difference encountered so far.
Definition: cbp.h:53
dai::CBP::Properties::clamp_outfile
std::string clamp_outfile
If non-empty, write clamping choices to this file.
Definition: cbp.h:184
dai::CBP::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: cbp.h:92
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::CBP::Properties::min_max_adj
Real min_max_adj
If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse. ...
Definition: cbp.h:170
dai::CBP::setProperties
virtual void setProperties(const PropertySet &opts)
Set parameters of this inference algorithm.
Definition: cbp.h:94
dai::CBP::_logZ
Real _logZ
Logarithm of partition sum.
Definition: cbp.h:48
dai::CBP::init
virtual void init()
Initializes all data structures of the approximate inference algorithm.
Definition: cbp.h:88
dai::CBP::Properties::updates
UpdateType updates
Update style for BP.
Definition: cbp.h:162
dai::CBP::beliefV
virtual Factor beliefV(size_t i) const
Returns the (approximate) marginal probability distribution of the variable with index i...
Definition: cbp.h:84
dai::CBP::Properties::bbp_cfn
BBPCostFunction bbp_cfn
Cost function to use for BBP.
Definition: cbp.h:180
dai::CBP::Properties::rand_seed
size_t rand_seed
Random seed.
Definition: cbp.h:182
dai::CBP::_beliefsF
std::vector< Factor > _beliefsF
Factor beliefs.
Definition: cbp.h:46
dai::CBP::Properties::tol
Real tol
Tolerance for BP convergence test.
Definition: cbp.h:160
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::CBP::run
virtual Real run()
Runs the approximate inference algorithm.
Definition: cbp.cpp:131
dai::CBP::runRecurse
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.
Definition: cbp.cpp:168
dai::CBP::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: cbp.h:158
dai::CBP::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: cbp.h:87
dai::CBP::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: cbp.h:91
dai::CBP::Properties::maxiter
size_t maxiter
Maximum number of iterations for BP.
Definition: cbp.h:164
dai::CBP::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: cbp.h:95
dai::CBP::Properties::recursion
RecurseType recursion
Method for deciding when to stop recursing.
Definition: cbp.h:174
dai::CBP::Properties::toString
std::string toString() const
Convert to a string which can be parsed as a PropertySet.
Definition: cbp.cpp:616
dai::CBP::Properties::clamp
ClampType clamp
Whether to clamp variables or factors.
Definition: cbp.h:176
dai::CBP::belief
virtual Factor belief(const Var &v) const
Returns the (approximate) marginal probability distribution of a variable.
Definition: cbp.h:82
dai::CBP::Properties::bbp_props
PropertySet bbp_props
Properties to pass to BBP.
Definition: cbp.h:178
dai::CBP::Properties::rec_tol
Real rec_tol
Tolerance used for controlling recursion depth (recurse is REC_LOGZ or REC_BDIFF) ...
Definition: cbp.h:166
dai::CBP::_beliefsV
std::vector< Factor > _beliefsV
Variable beliefs.
Definition: cbp.h:44
dai::concat
std::vector< T > concat(const std::vector< T > &u, const std::vector< T > &v)
Concatenates two vectors.
Definition: util.h:231
dai::CBP::printDebugInfo
void printDebugInfo()
Prints beliefs, variables and partition sum, in case of a debugging build.
Definition: cbp.cpp:447
dai::InfAlg
InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI...
Definition: daialg.h:35
dai::CBP::setBeliefs
void setBeliefs(const std::vector< Factor > &bs, Real logZ)
Sets variable beliefs, factor beliefs and log partition sum to the specified values.
Definition: cbp.cpp:76
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::CBP::beliefs
virtual std::vector< Factor > beliefs() const
Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm...
Definition: cbp.h:86
dai::CBP::Properties::max_levels
size_t max_levels
Maximum number of levels of recursion (recurse is REC_FIXED)
Definition: cbp.h:168
dai::CBP::setMaxIter
virtual void setMaxIter(size_t maxiter)
Sets maximum number of iterations (one iteration passes over the complete factorgraph).
Definition: cbp.h:93
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::CBP::_iters
size_t _iters
Numer of iterations needed.
Definition: cbp.h:51
dai::CBP::Properties::choose
ChooseMethodType choose
Heuristic for choosing clamping variable.
Definition: cbp.h:172
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai::CBP::beliefF
virtual Factor beliefF(size_t I) const
Returns the (approximate) marginal probability distribution of the variables on which factor I depend...
Definition: cbp.h:85
dai::CBP::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: cbp.h:81
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::CBP::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: cbp.h:96
dai::DAIAlg
Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)...
Definition: daialg.h:207
dai::CBP::getInfAlg
InfAlg * getInfAlg()
Return the InfAlg to use at each step of the recursion.
Definition: cbp.cpp:153
dai::CBP::CBP
CBP()
Default constructor.
Definition: cbp.h:66
dai::CBP::clone
virtual CBP * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: cbp.h:79
dai::CBP::Properties::get
PropertySet get() const
Get members into PropertySet.
Definition: cbp.cpp:598
dai::BBPCostFunction
Predefined cost functions that can be used with BBP.
Definition: bbp.h:42
dai::CBP::Properties::set
void set(const PropertySet &opts)
Set members from PropertySet.
Definition: cbp.cpp:522
dai::CBP::construct
void construct()
Constructor helper function.
Definition: cbp.cpp:90
dai::CBP::init
virtual void init(const VarSet &)
Initializes all data structures corresponding to some set of variables.
Definition: cbp.h:89
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/tab_a.png0000644000175000017500000000021612552201363015453 0ustar jorismjorism‰PNG  IHDR$ÇÇ[UIDATxíK €0C'o¤(Šˆ[Žà%Üxÿ#Ù©­ç ùÁöó¦W¦e# 3t I 3+¼øEã~\D½9¯Ûàè’wM·¿öÿ}Yõ_êA4Yžã}IEND®B`‚libDAI-0.3.2/doc/html/functions_vars_v.html0000644000175000017500000001272512552201370020163 0ustar jorismjorism libDAI: Class Members - Variables
 

- v -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_h.html0000644000175000017500000001105412552201370020137 0ustar jorismjorism libDAI: Class Members - Variables
 

- h -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BipartiteGraph_1_1levelType.html0000644000175000017500000001320512552201364024412 0ustar jorismjorism libDAI: dai::BipartiteGraph::levelType Struct Reference
Public Attributes | List of all members
dai::BipartiteGraph::levelType Struct Reference

Used internally by isTree() More...

Public Attributes

std::vector< size_t > ind1
 Indices of nodes of type 1. More...
 
std::vector< size_t > ind2
 Indices of nodes of type 2. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/index_8h.html0000644000175000017500000001365412552201363016305 0ustar jorismjorism libDAI: include/dai/index.h File Reference
Classes | Namespaces
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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1UEdge.html0000644000175000017500000003656112552201370017734 0ustar jorismjorism libDAI: dai::UEdge Class Reference
Public Member Functions | Public Attributes | Friends | List of all members
dai::UEdge Class Reference

Represents an undirected edge. More...

#include <dai/weightedgraph.h>

Public Member Functions

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

Public Attributes

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

Friends

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

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.

std::string dai::UEdge::toString ( ) const
inline

Formats an undirected edge as a string.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__id-members.html0000644000175000017500000000560512552201365022030 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__plog0p-members.html0000644000175000017500000000564512552201365022641 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_1.png0000644000175000017500000000126112552200213015562 0ustar jorismjorism‰PNG  IHDR{*ðÔ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï IDATxí]Q¶«  PÑýïöM¢Ø¾Ï鮧¹ffH¹¿ðgoÀÔÒdøÕ.Tð÷,;|X*0³å…¿Q騨‰¿ØgÚ+Ì,ëtàÙÜs÷˜¹ ÿ‰v~ {›ï°x4G>TKx)3m­…èUÔ¶¸ø¾rU~¨4ÑšDYá”ÓœLl»Ã}i-•ÈZ#Rèã(Ù%Ó+9È—ï-!l; G0¾Ý¨º@J‡mgá‰u…øq÷„Ý2C…OíÀèV [EN”OTëÓuÙ~ùŽµ&¾_´ï63[›eÉdòqªU¦ŒC;¦”áßéË‚°›šÄ²ž~˜;D"À#a` D K XÀˆ@–@°"€%,` D K XÀˆÃA”RÊŠö¥”²¢ûh‘¤Íˆ@H²"’,û„è–gÝõ5»¸|—¤yÇ_š~yþ$=²wˆù¥iÔü\’æ>»Ç?ÐÄåßïâlFøÈ^BŒ¿÷ì0i büG¤î}_Œs 1~ùþ…‡È.!¦ô>þÙŒè$½èýt¾ÀÜ&Öc˜CØ·÷ 1üï¯ lå³óqˆ>ëï¿3óò¿ú Ø-„–ƒZ{ÌßB¼Ø5¦?òbßÛ§$ý±/(IŸô8oî´$}Ò͈ñÑ‘¤?ôX†$ý±„$K !ɲ'ˆRJÙ®‡hâîÐG"s‡Hx$ ,` D K XÀˆ@–@°"€%,` D K XÀR¢”R6,ÀšV„¤Íˆ@H²"’,-Ct˳îú²£$}Öc@Ì/]Þ¦£$}Öf!.7|¼õ³q:ˆë`Çw’ç|Ó@§qŸs˜ †¿~4$é㮇èû¾¯Ò¿@Øas€*]·FœÂwÛÙ˜i¤¯Ú,„$Õl !ɈÑ!£C F‡@ŒöQJ)Û`MëA4Ü@°"€%,` D K XÀˆ@–@°"€%,` D K XÀˆê¥”²aÖ´"„$mÖ@B’%di¢{q¦îò~”¤ßÛ<ÄÓµËÛóQ’~o‹—û<Þqéüä ×1Žãì$Ïù ¦ñ-Æ?-§X#&ˆaœ¿<’ôQ×Cô}ßWé—vØ@•þyøiפÚø®q;»~¾6B’ª7d D $YI–@좔R¶+ÀšÖƒh¸` D K XÀˆ@–@°"€%,` D K XÀˆ@–@°"€%Õ!J)eìiEIÚ¬„$K !ÉÒD·<ën/IZörÙ>y÷­¶!~ºôâg†– .wô:˜áþ?f„®îûíp}»YL?HÒÛ6qÌ0âNòØÝ|jߘQ’^µ%»ýË5â~ÇŸ.p$é]›ƒÆýühL³Oÿ1Dß÷}•~ñ<¬·Æ‘gÄ|xµX¾\#á»Æ¸ŒÛĸ;Üwû1탤ÿ±„$K !Ɉ@H²b‡¥”²]Ö´@à D K XÀˆ@–@°"€%,` D K XÀˆ@–@°"€%,¨QJ)`M+BHÒf D $YI–F!ºåÙp²x|S’Þ·yˆ§KãàïŸ:4 Ñ í.Ç×3âñ±C‹×ñcì$¤nÖÏ…˜Fè÷ü2A®/‡¸ý$I´aˆaØ/ ù—Fß÷}•~ ñ<Ô;ÄìäÈ‹åbø âÐÛ§í·³§Åry"I¿µEIªÞ@B’%d D $Y±CˆRJÙ®kZ á"€%,` D K XÀˆ@–@°"€%,` D K XÀˆ@–@T‡(¥” °¦!$i³"’,„$KƒÝ‹³ÛÝð’¤ïÛ4„¤Gn—ÿ¨Ð Äå†_;Üø§q¿rûÎ87>"AÜ8Œw8Œ?÷Œ˜½@ô}ßWé_ ì5âÄIwÛÙ˜áQ™Iú°ÍBHRÍ"’,„$K !ɈB”RÊvXÓz 7,` D K XÀˆ@–@°"€%,` D K XÀˆ@–@°¢:D)¥lX€5­!I›5d D $YÚ…è–gÓÉåØÝ^’ôañ¸4\»¾1hâ2ÖëP‡›þ˜§ƒ¸Íýa´d®œ bªÚ!¾\"‡Fë‹å46˜}ß÷Uú=„vP¥kÖˆ§‰rÊ]ÃæÀ !$©nI–@B’%d Ä!J)e»¬i=€†ˆ@–@°"€%,` D K XÀˆ@–@°"€%,` D K XQ¢”R6,ÀšV„¤Íˆ@H²"’,íBt˳éärì®/Iú´G€x\®]·³o$…¸Œõ:Êá®?fÄé nsh'Y†+§‚˜F9 z8@œc˜ †Ñúb9M‡Ù##I¿u=Dß÷}•~a‡WÿöѨÓ5kÄÓD9 „ï6N!Iuˆ@H²"’,„$K vQJ)Ûõ?¦Ô÷]qBÙ­IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1Var-members.html0000644000175000017500000001564212552201370021120 0ustar jorismjorism libDAI: Member List
dai::Var Member List

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

_labeldai::Varprivate
_statesdai::Varprivate
label() const dai::Varinline
label()dai::Varinline
operator!=(const Var &n) const dai::Varinline
operator<(const Var &n) const dai::Varinline
operator<<(std::ostream &os, const Var &n)dai::Varfriend
operator<=(const Var &n) const dai::Varinline
operator==(const Var &n) const dai::Varinline
operator>(const Var &n) const dai::Varinline
operator>=(const Var &n) const dai::Varinline
states() const dai::Varinline
states()dai::Varinline
toString() const dai::Varinline
Var()dai::Varinline
Var(size_t label, size_t states)dai::Varinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/bdwn.png0000644000175000017500000000022312552201363015335 0ustar jorismjorism‰PNG  IHDR5åZIDATxíË € DŸP–1ñlžmÀ r±j².e è†D[ØɾÙÏÔ¼µ¦ã´Þ|陣6€Všë3´Å?Ls'(}¬>+ žKó÷¥¿ch`‚ ^׃ÞnIEND®B`‚libDAI-0.3.2/doc/html/form_79.png0000644000175000017500000000232012552200235015662 0ustar jorismjorism‰PNG  IHDR"º-–»0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï?IDATxíÙ²ã* E£‡8áÿÿöJ€ml“¡ûåVuByŸCl$¤­éà€~øß0Žcûx€ê sJsÌ+¥48€¶•R,›ûºøáÈÉß‘3N/²-ü9®ÅýFQ¿\„â¸ü^’3ÝgÃpŸ @“ÀÆÐ?à€ÏáÆG_êµ¢'_/¯ÓþƼÇëÌIâ||7ùngÌ“L±Úâ”ëÀ ¢«Êž@çvwoþy¸?''&|/i·wâÍ"rs¿$­: ð­ö”«¡—¢‹_]ëíñöØ6JLð…D{M‚7='ÍÝ‚Þ‚%÷«Ü8ï…­jLŒùF-e 6¦LˆÙ®­SíawSR›g´bqh­Šz~õŽBù¦Æ¿]‰]°9( Çã3A{j»q ‚’#ÆmäŒÞ-‚V£Þ/F,%†ÁºdSva³nÓ¤±Õ—ý¹QŒ5Æ”°VE=¿Ž..öîB™ªZeÖ97{ùS¢ï±WV>"ÇŽ)ëˆ%ÀFT–u«MZÉ‘+9Fóì±ä_ªîhžÛë^H"§‰/Ð>;9îzFú9ÀG·U•Û¥BôA8è+Úüj‚ ù«´|vû©$€æùŒ€.íH=<gìVæ‘ìO_Ñvì*ðÇ·\‘R-¹”žŽ{€/Ä’dÝ%ÿ¶ À%3ój7?üðÀghڻŶÕäÊðq: ¾&e>2>ù‘ëŸ1ºÝ^ h€w¥aˆQˆpº'OñQ~ÆÉ aËscga¢Î8Èâˆq àK1D˜,aãž“d'ÇÍx›³ à ±H^¢,Ùk’ 9Öóð 9›¾‹ôà±´•ðÀÌ Äx)¶Éj*Ý¥ï|%¬3N£ô|ÐrÃ(ŒØàq¸¾&p€ÿÁ-…kÏýØIEND®B`‚libDAI-0.3.2/doc/html/form_130.png0000644000175000017500000000036512552200250015732 0ustar jorismjorism‰PNG  IHDRÌÂ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïdIDATxí[ Ä0 'vœWrÿÛ®Cé‡i÷#„Žð‡$­ 2y›6>Ì©Ùš²+@$Ï{‚>r6öqN+}IyRC-i‚ºÏî¤;¶¼( )Ö2õrøà¤ÊyÙÉK;IEND®B`‚libDAI-0.3.2/doc/html/functions_func_o.html0000644000175000017500000003433012552201370020130 0ustar jorismjorism libDAI: Class Members - Functions
 

- o -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/hak_8h.html0000644000175000017500000001363412552201363015737 0ustar jorismjorism libDAI: include/dai/hak.h File Reference
Classes | Namespaces
hak.h File Reference

Defines class HAK, which implements a variant of Generalized Belief Propagation. More...

#include <dai/dai_config.h>
#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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

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.

Optimize this code for large factor graphs.

Implement GBP parent-child algorithm.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func.html0000644000175000017500000001154012552201370017610 0ustar jorismjorism libDAI: Class Members - Functions
 

- _ -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_89.png0000644000175000017500000000174612552200237015700 0ustar jorismjorism‰PNG  IHDRhòKs0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïUIDATxí]Û–¤0¬Ü×ÿÿÛ- ¶Ñ±·g³o“ìÖ„*@^àWàWŽáô™€c¦ß•gøJ‡`˜º©Ë>Ý-8æÇ1 æz]I |7À­„"kñ_vzWà"A !¬ŸH¸ñx’Gà$ÛGB›é·$¬Q°Ÿâ·qBøŠ¦[4·¥ÞÉUø8Àøõgð›ŸÂÚÒý™ƒÞã ÙeïfÁÇù¯> ¾ˆ/³TèsüNœ®Zú!ÈìÇ"ßààðxò‘~èa™WÜRÆ^‘ï}¼ùwïÚh[â<Š©çø=±8þj¬Ù×Q¸Æ6ßs`Fµæ±îu‚Ó"Ú”Íy¬95HßÑ0ö>T -[?fi’=¡qÛØÝZÄÜà74ÝÉ'7mºEh9ß.ƒ(ÅùÂ#G>oWÑhKüHS{­MÏJ¸¨}?Óšf]©U4GýÜÔ«Ä‘Ô™Àiv‹ðíÝʶQËr óµ•דàkÎ²Ï ç¾j'Ù=ħU×rÕ/U’ÑÌé]ÄStSƒ´¼k2õ‚hCŒµV£B²\iñ[|‚Ï“ª¶‡ÿ<ͦ\S$3ƒ*SM¥hðûeÉȨ-êȃ^¬võº9öÂØÍ­.QOÑ_1±ÕiÀž5«òžöº­ ãv (OÞóu&}yŒŒ "-›7ÌQh•žèyÂ̹X¹]Z”ÐOO¢åæáqÈB);ãËÂPÂ<ü¨4‹‘'9[æ* Ž›•ÃŒ)ÄvjÎ2˜¡ÇøÙRHBҼΠ“PY›ÇªBR¢”½=»ËÈ›cd‡Âþä½Ñ¿{ÌŸ$°-‹ºš¦Òîc¥#CKU)W±”ÄpAa$Æj—°]9¬Á7.{×™´h§À8ƒ¡‘$Yf€Ž˜Å@5>wõÍfÑ^€Ñj°¯–V²§A­¡¸”È{MÆä5Ìr›sÙ}~ŠÏ`ëB:º¡w:Ó\e¯œR®ÖÜPƒ˜’8óòØ5ìÆs¹„º[+WÒÚ%ùéîáIÀUÜñùþÓ#¼.àžY÷ÚtÓ7¿ñ¾-ÖµàÿÈÿÆ€_‘ñ‡—. IEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1BP_1_1Properties-members.html0000644000175000017500000001254212552201364023624 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_26.png0000644000175000017500000000055512552200221015655 0ustar jorismjorism‰PNG  IHDR2c…ܾ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÜIDATxí]QnÅ 3iRB åþ· ¬Ð=Ušö±ßZ‚SÛäðoØ”Ìïçž  ¸6x‡ð@Ùà¦0o,ßz~E!F•#ÁJg§øún›K.d)užÐ)­Ý~Dc±Î $¥ÕÊb–q¨zk,£4…!iûI¶Òa¤ÝÑ”.tñç”òŽ½Yò,Ì>…‚íTua”øX‚u 7‚½y&“é‰ÅH¤¡ëjûUx\ßå’›’…‘<öp6±vÏîûs`ê=01¥‘üˆapâä{^ú>b_[«†]žOIEND®B`‚libDAI-0.3.2/doc/html/form_65.png0000644000175000017500000000121212552200232015651 0ustar jorismjorism‰PNG  IHDR†©PVö0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïùIDATxíÛv­ EW¸)xáÿÿ¶IDd÷x:úXGWw·d’„ôþÿÖ|=ð3Ñ`,"×M:QÎ$Ï– ŒägŽBò F²²dì=ÞuÒÛûÅíÐkËí<4ev´:K0B dà!Jí·q^`Pö˜ɪ§d b{³ÀSñÂ#—ïI+%{´(0÷ŒáÄ^²v¾Ñ%²jf¯t˜¸qæ¸ Š¿í\{ƒaòч×ë$Ë…1K&*F K¶Üþ¼|mºAo‚Ùë Ìéò †ËGÀ¥ëR›Ž¸‚!; †l›sµh06åz{áœ?¬G˜Xž”§ŠÑEC­êQ;¡ÁÐ-öÙD-†Ô­&<!„‚­uªôÖó™ÑÚç{u“²”½/ŠnifT:£´‰ÝÚ9F¹›«:G2nô°ævóÎqQþØ ž £Iw\ùè-³1®=Ä;W Æë§m8çÀ-BÑÝï˜8¸M‰oÝîªæN0̬¼GÝ4s$Š‹zó%¯Æë ”ËºYÚ`u¡0ƒY·Ø#¬¦¥ekìê Oš œïNÔbõ"­ÇÑdò›n*Ò§AÚ`”ƒWK¡ঔõ2êGbƒR+i«¤ðì2ˆþ]~࣬ÀÆÉò”r)¸ø¿öðk¢Æÿ¢àçú±t ’\à‹IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1UEdge-members.html0000644000175000017500000001177112552201370021360 0ustar jorismjorism 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::UEdgeinline
operator<<(std::ostream &os, const UEdge &e)dai::UEdgefriend
operator==(const UEdge &x)dai::UEdgeinline
seconddai::UEdge
toString() const dai::UEdgeinline
UEdge()dai::UEdgeinline
UEdge(size_t m1, size_t m2)dai::UEdgeinline
UEdge(const DEdge &e)dai::UEdgeinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_d.html0000644000175000017500000001214312552201370020133 0ustar jorismjorism libDAI: Class Members - Variables
 

- d -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_52.png0000644000175000017500000000050312552200227015653 0ustar jorismjorism‰PNG  IHDR+ Ñ/„Ä0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï²IDATxí]Ià ð„„ÿÿ¶6êµ—-Y²Ï’¼þÕʪ¦ïRÕXÇXL¤O¹bQ·˜‚ˆ6Ëb¢ŠÂ¸M®à”TVË 6mŒqK@· àXñÌ,÷&oÔ;Sm™‡‘AÃÂ^à·•‹£âÏr•Ax-J¦ŒN±ýÖ.›Š5L§µI¾]°Œé~Å͉y¹ž›GX¤~7ò¹åÇ’µñ,‹§ºèù§ðCqKÜLØÑ­IEND®B`‚libDAI-0.3.2/doc/html/functions_m.html0000644000175000017500000002747612552201370017130 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- m -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_140.png0000644000175000017500000000147612552200253015742 0ustar jorismjorism‰PNG  IHDRßìQût0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï­IDATxí]Ûr«0 \c|%àÿÿÛJò‡J3éyè&‚ È–vµ–^à¿À_2íÛ5ÀÛf4üÈÔÛÀ[6§æ’UtÍ)ÀÐ(¾‚å Mmß5ßÛ;¸4Ž­Òzîë¬3gèe•Þ.é$«Ë^L%Oõ‰WÛ¸È{å\}cmú`âeíG‹Ä˜_àÅœOò\/‹BÂÔVÈs† (‡ÌYßôàÜNRÓ|š®²ô>>•öº<‘ûŠo5Å'"èEϬKZòf¥¸·ðaÉÎÓ¡‡„Ö’Ÿ„ë‚}ŸJiejõh¯‚ïÑBê•8/«’ë-|1çj!V€\¶ßÀe—äæ¾ùQ?n„)pÜÁçK.ûÌ¡^[i|ChÑçGñÉÜ»¨0ÒÀòUb|XB‰Äÿ¥‘Ÿà›»îbÔ=­|iDÕÓO_Š ;3 ¦ð=|3óÃg•ÉHòÓ€‚/´Þ@ÍÈÖ¬-w¦>EúSÁ ?®:ª…¯ÌbÇÁs!é+  jÁ—ûÍÊ:ž6áDîŧÇÇ“Àø µ¨<ËjJ´@ÿ+å؉¡ñÔ:‚.¨{|†ÞÕ#ö(çÔD>±.FG,*²G|Ê›@If - €frù51'9”¯¯õ£(%f怷µ¤FNfh!ÄX-÷çQhª|;©î#ût'Á×ï˜û/ûtøX;UîM;MxæBë÷ñ…>æó+†6wÒû)2œ›Í§ÃÇÚÙ¸yÖÎSìã`°ÿ¶cšÏ‰%þ.µØÖ2˜B>pÇœûs;Ù)Q¸üˆÚ¢ëƒÓ±„0²io/pi–hraÖšWÍÔ·à™&–U´š&¹ÆÄ«ŠÀûfì¹à7M[ûýT€Wûçò=þá­fIEND®B`‚libDAI-0.3.2/doc/html/functions_func_r.html0000644000175000017500000002535212552201370020137 0ustar jorismjorism libDAI: Class Members - Functions
 

- r -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_g.html0000644000175000017500000002261512552201370017110 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- g -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/mf_8h_source.html0000644000175000017500000011244712552201363017160 0ustar jorismjorism libDAI: include/dai/mf.h Source File
mf.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_mf_h
14 #define __defined_libdai_mf_h
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_MF
19 
20 
21 #include <string>
22 #include <dai/enum.h>
23 #include <dai/daialg.h>
24 #include <dai/factorgraph.h>
25 #include <dai/properties.h>
26 
27 
28 namespace dai {
29 
30 
32 
41 class MF : public DAIAlgFG {
42  private:
44  std::vector<Factor> _beliefs;
46  Real _maxdiff;
48  size_t _iters;
49 
50  public:
52  struct Properties {
54  DAI_ENUM(InitType,UNIFORM,RANDOM);
55 
57  DAI_ENUM(UpdateType,NAIVE,HARDSPIN);
58 
60  size_t verbose;
61 
63  size_t maxiter;
64 
66  Real tol;
67 
69  Real damping;
70 
72  InitType init;
73 
75  UpdateType updates;
76  } props;
77 
78  public:
80 
81  MF() : DAIAlgFG(), _beliefs(), _maxdiff(0.0), _iters(0U), props() {}
83 
85 
88  MF( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), _beliefs(), _maxdiff(0.0), _iters(0U), props() {
89  setProperties( opts );
90  construct();
91  }
93 
95 
96  virtual MF* clone() const { return new MF(*this); }
97  virtual MF* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new MF( fg, opts ); }
98  virtual std::string name() const { return "MF"; }
99  virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); }
100  virtual Factor belief( const VarSet &vs ) const;
101  virtual Factor beliefV( size_t i ) const;
102  virtual std::vector<Factor> beliefs() const;
103  virtual Real logZ() const;
104  virtual void init();
105  virtual void init( const VarSet &ns );
106  virtual Real run();
107  virtual Real maxDiff() const { return _maxdiff; }
108  virtual size_t Iterations() const { return _iters; }
109  virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; }
110  virtual void setProperties( const PropertySet &opts );
111  virtual PropertySet getProperties() const;
112  virtual std::string printProperties() const;
114 
115  private:
117  void construct();
118 
120  Factor calcNewBelief( size_t i );
121 };
122 
123 
124 } // end of namespace dai
125 
126 
127 #endif
128 
129 
130 #endif
dai::MF::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: mf.cpp:198
dai::MF::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: mf.h:107
dai::MF::construct
void construct()
Helper function for constructors.
Definition: mf.cpp:77
dai::MF::Properties::damping
Real damping
Damping constant (0.0 means no damping, 1.0 is maximum damping)
Definition: mf.h:69
dai::MF::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: mf.cpp:52
dai::MF
Approximate inference algorithm "Mean Field".
Definition: mf.h:41
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::MF::Properties::init
InitType init
How to initialize the messages/beliefs.
Definition: mf.h:72
dai::MF::setProperties
virtual void setProperties(const PropertySet &opts)
Set parameters of this inference algorithm.
Definition: mf.cpp:27
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::MF::_beliefs
std::vector< Factor > _beliefs
Current approximations of single variable marginals.
Definition: mf.h:44
dai::MF::run
virtual Real run()
Runs the approximate inference algorithm.
Definition: mf.cpp:117
dai::MF::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: mf.cpp:64
dai::MF::clone
virtual MF * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: mf.h:96
dai::MF::beliefs
virtual std::vector< Factor > beliefs() const
Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm...
Definition: mf.cpp:190
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::MF::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: mf.h:108
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::MF::calcNewBelief
Factor calcNewBelief(size_t i)
Calculates an updated belief of variable i.
Definition: mf.cpp:96
dai::MF::Properties::DAI_ENUM
DAI_ENUM(InitType, UNIFORM, RANDOM)
Enumeration of possible message initializations.
dai::MF::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: mf.h:60
dai::MF::beliefV
virtual Factor beliefV(size_t i) const
Returns the (approximate) marginal probability distribution of the variable with index i...
Definition: mf.cpp:173
dai::MF::construct
virtual MF * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: mf.h:97
dai::MF::init
virtual void init()
Initializes all data structures of the approximate inference algorithm.
Definition: mf.cpp:86
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::MF::MF
MF()
Default constructor.
Definition: mf.h:82
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai::MF::Properties::tol
Real tol
Tolerance for convergence test.
Definition: mf.h:66
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::MF::Properties::maxiter
size_t maxiter
Maximum number of iterations.
Definition: mf.h:63
dai::MF::Properties
Parameters for MF.
Definition: mf.h:52
dai::MF::_iters
size_t _iters
Number of iterations needed.
Definition: mf.h:48
dai::DAIAlg
Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)...
Definition: daialg.h:207
dai::MF::Properties::updates
UpdateType updates
How to update the messages/beliefs.
Definition: mf.h:75
dai::MF::belief
virtual Factor belief(const Var &v) const
Returns the (approximate) marginal probability distribution of a variable.
Definition: mf.h:99
dai::MF::MF
MF(const FactorGraph &fg, const PropertySet &opts)
Construct from FactorGraph fg and PropertySet opts.
Definition: mf.h:88
dai::MF::setMaxIter
virtual void setMaxIter(size_t maxiter)
Sets maximum number of iterations (one iteration passes over the complete factorgraph).
Definition: mf.h:109
dai::MF::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: mf.h:98
dai::MF::_maxdiff
Real _maxdiff
Maximum difference encountered so far.
Definition: mf.h:46
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1BP__dual.html0000644000175000017500000013565012552201364020412 0ustar jorismjorism libDAI: dai::BP_dual Class Reference
Classes | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
dai::BP_dual Class Reference

Calculates both types of BP messages and their normalizers from an InfAlg. More...

#include <dai/bp_dual.h>

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...
 

Public Member Functions

 BP_dual (const InfAlg *ia)
 Construct BP_dual object from (converged) InfAlg object's beliefs and factors. More...
 
const FactorGraph & fg () const
 Returns the underlying FactorGraph. More...
 
Prob & msgM (size_t i, size_t _I)
 Returns reference to factor->variable message (I -> i) More...
 
const Prob & msgM (size_t i, size_t _I) const
 Returns constant reference to factor->variable message (I -> i) More...
 
Prob & msgN (size_t i, size_t _I)
 Returns reference to variable -> factor message (i -> I) More...
 
const Prob & msgN (size_t i, size_t _I) const
 Returns constant reference to variable -> factor message (i -> I) More...
 
Real & zM (size_t i, size_t _I)
 Returns reference to normalizer for factor->variable message (I -> i) More...
 
const Real & zM (size_t i, size_t _I) const
 Returns constant reference to normalizer for factor->variable message (I -> i) More...
 
Real & zN (size_t i, size_t _I)
 Returns reference to normalizer for variable -> factor message (i -> I) More...
 
const Real & zN (size_t i, size_t _I) const
 Returns constant reference to normalizer for variable -> factor message (i -> I) More...
 
Factor beliefV (size_t i) const
 Returns belief of variable i. More...
 
Factor beliefF (size_t I) const
 Returns belief of factor I. More...
 
Real beliefVZ (size_t i) const
 Returns normalizer for belief of variable i. More...
 
Real beliefFZ (size_t I) const
 Returns normalizer for belief of factor I. More...
 

Protected Member Functions

void init ()
 Does all necessary preprocessing. More...
 
void regenerateMessages ()
 Allocates space for _msgs. More...
 
void regenerateBeliefs ()
 Allocates space for _beliefs. More...
 
void calcMessages ()
 Calculate all messages from InfAlg beliefs. More...
 
void calcNewM (size_t i, size_t _I)
 Update factor->variable message (i -> I) More...
 
void calcNewN (size_t i, size_t _I)
 Update variable->factor message (I -> i) More...
 
void calcBeliefs ()
 Calculate all variable and factor beliefs from messages. More...
 
void calcBeliefV (size_t i)
 Calculate belief of variable i. More...
 
void calcBeliefF (size_t I)
 Calculate belief of factor I. More...
 

Protected Attributes

messages _msgs
 Stores all messages. More...
 
beliefs _beliefs
 Stores all beliefs. More...
 
const InfAlg * _ia
 Pointer to the InfAlg object. 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BBP_1_1Properties.html0000644000175000017500000004054312552201364022300 0ustar jorismjorism libDAI: dai::BBP::Properties Struct Reference
Public Member Functions | Public Attributes | List of all members
dai::BBP::Properties Struct Reference

Parameters for BBP. More...

#include <dai/bbp.h>

Public Member Functions

 DAI_ENUM (UpdateType, SEQ_FIX, SEQ_MAX, SEQ_BP_REV, SEQ_BP_FWD, PAR)
 Enumeration of possible update schedules. More...
 
void set (const PropertySet &opts)
 Set members from PropertySet. More...
 
PropertySet get () const
 Get members into PropertySet. More...
 
std::string toString () const
 Convert to a string which can be parsed as a PropertySet. More...
 

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr) More...
 
size_t maxiter
 Maximum number of iterations. More...
 
Real tol
 Tolerance for convergence test. More...
 
Real damping
 Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [EaG09]. More...
 
UpdateType updates
 Update schedule. More...
 

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_PROPERTYif a Property key is not recognized
NOT_ALL_PROPERTIES_SPECIFIEDif 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_30.png0000644000175000017500000000034012552200222015641 0ustar jorismjorism‰PNG  IHDR —™'n0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïOIDATxíÛ À0/!UÊþÛ–<ÔÇW'°dÄY˜þ¬EÕôÆ’é↋3ô™oŽíÓe×iF†zm.õáxÒ¨ÇÍKb_^º_6Â}2?IEND®B`‚libDAI-0.3.2/doc/html/functions_func_g.html0000644000175000017500000002247212552201370020124 0ustar jorismjorism libDAI: Class Members - Functions
 

- g -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_33.png0000644000175000017500000000106512552200222015651 0ustar jorismjorism‰PNG  IHDR‹f|M0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï¤IDATxíÝ–ƒ „?@À,ïÿ¶›]ÑjÝÓËÍaÐ*™LB°·ÿø+L _‡‡þ§_RÀ¤åm°‡Õ9øri4Ý=ÀÌâ4œÀWf·{–eš.át ‹Œ§€!æ•JJ®e 'ëž&GF€k-QôzÑÓì@pÄ «]Í`‡šß‘&æûê\üfÑÒnjñY¨ À ε˜Zn3V·øÐ VkUüÖø©Öœ“ù%ºÑ¨}×µzvòš5·¤¥Z¥zjÁ†,íR‰k¶Óbß)Öåò¾Ótc˜5nút ©vYÓª´”<¥ÈÁÒc䶆7S³¶në]=wµLšðzâ×=*i¶'³öúœÃØ·Ãöâg†ää^3.rME›Vì9k»¶5eSEÇ“؆‹Ù©Ö.%äÞJå$Ž­gv_Ÿ.¢¾òJ­.ÒØVúYæòÕ©síö²f°“TED6b`Xb^•W>¿gèÚDXzæ ŸÝš7Ä7°Üq÷ÎýŸBo÷Ôcp¦ìÀwaµéŠýÐÓ ÷$88IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1BBP.html0000644000175000017500000044032212552201364017343 0ustar jorismjorism libDAI: dai::BBP Class Reference
Classes | Public Attributes | Private Member Functions | Related Functions | List of all members
dai::BBP Class Reference

Implements BBP (Back-Belief-Propagation) [EaG09]. More...

#include <dai/bbp.h>

Classes

struct  Properties
 Parameters for BBP. More...
 

Public Member Functions

Constructors/destructors
 BBP (const InfAlg *ia, const PropertySet &opts)
 Construct BBP object from a InfAlg ia and a PropertySet opts. More...
 
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. More...
 
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) More...
 
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) More...
 
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) More...
 
void initCostFnAdj (const BBPCostFunction &cfn, const std::vector< size_t > *stateP)
 Initializes with adjoints calculated from cost function cfn, and state stateP. More...
 
BBP Algorithm
void run ()
 Perform iterative updates until change is less than given tolerance. More...
 
Query results
Prob & adj_psi_V (size_t i)
 Returns reference to variable factor adjoint. More...
 
const Prob & adj_psi_V (size_t i) const
 Returns constant reference to variable factor adjoint. More...
 
Prob & adj_psi_F (size_t I)
 Returns reference to factor adjoint. More...
 
const Prob & adj_psi_F (size_t I) const
 Returns constant reference to factor adjoint. More...
 
Prob & adj_b_V (size_t i)
 Returns reference to variable belief adjoint. More...
 
const Prob & adj_b_V (size_t i) const
 Returns constant reference to variable belief adjoint. More...
 
Prob & adj_b_F (size_t I)
 Returns reference to factor belief adjoint. More...
 
const Prob & adj_b_F (size_t I) const
 Returns constant reference to factor belief adjoint. More...
 
size_t Iterations ()
 Return number of iterations done so far. More...
 

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. More...
 
Real getUnMsgMag ()
 Calculates averaged L1 norm of unnormalized message adjoints. More...
 
void getMsgMags (Real &s, Real &new_s)
 Calculates averaged L1 norms of current and new normalized message adjoints. More...
 
void getArgmaxMsgM (size_t &i, size_t &_I, Real &mag)
 Returns indices and magnitude of the largest normalized factor->variable message adjoint. More...
 
Real getMaxMsgM ()
 Returns magnitude of the largest (in L1-norm) normalized factor->variable message adjoint. More...
 
Real getTotalMsgM ()
 Calculates sum of L1 norms of all normalized factor->variable message adjoints. More...
 
Real getTotalNewMsgM ()
 Calculates sum of L1 norms of all updated normalized factor->variable message adjoints. More...
 
Real getTotalMsgN ()
 Calculates sum of L1 norms of all normalized variable->factor message adjoints. More...
 
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. More...
 
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. More...
 
Initialization helper functions
void RegenerateT ()
 Calculate T values; see eqn. (41) in [EaG09]. More...
 
void RegenerateU ()
 Calculate U values; see eqn. (42) in [EaG09]. More...
 
void RegenerateS ()
 Calculate S values; see eqn. (43) in [EaG09]. More...
 
void RegenerateR ()
 Calculate R values; see eqn. (44) in [EaG09]. More...
 
void RegenerateInputs ()
 Calculate _adj_b_V_unnorm and _adj_b_F_unnorm from _adj_b_V and _adj_b_F. More...
 
void RegeneratePsiAdjoints ()
 Initialise members for factor adjoints. More...
 
void RegenerateParMessageAdjoints ()
 Initialise members for message adjoints for parallel algorithm. More...
 
void RegenerateSeqMessageAdjoints ()
 Initialise members for message adjoints for sequential algorithm. More...
 
void Regenerate ()
 Called by init, recalculates intermediate values. More...
 
Accessors/mutators
Prob & T (size_t i, size_t _I)
 Returns reference to T value; see eqn. (41) in [EaG09]. More...
 
const Prob & T (size_t i, size_t _I) const
 Returns constant reference to T value; see eqn. (41) in [EaG09]. More...
 
Prob & U (size_t I, size_t _i)
 Returns reference to U value; see eqn. (42) in [EaG09]. More...
 
const Prob & U (size_t I, size_t _i) const
 Returns constant reference to U value; see eqn. (42) in [EaG09]. More...
 
Prob & S (size_t i, size_t _I, size_t _j)
 Returns reference to S value; see eqn. (43) in [EaG09]. More...
 
const Prob & S (size_t i, size_t _I, size_t _j) const
 Returns constant reference to S value; see eqn. (43) in [EaG09]. More...
 
Prob & R (size_t I, size_t _i, size_t _J)
 Returns reference to R value; see eqn. (44) in [EaG09]. More...
 
const Prob & R (size_t I, size_t _i, size_t _J) const
 Returns constant reference to R value; see eqn. (44) in [EaG09]. More...
 
Prob & adj_n (size_t i, size_t _I)
 Returns reference to variable->factor message adjoint. More...
 
const Prob & adj_n (size_t i, size_t _I) const
 Returns constant reference to variable->factor message adjoint. More...
 
Prob & adj_m (size_t i, size_t _I)
 Returns reference to factor->variable message adjoint. More...
 
const Prob & adj_m (size_t i, size_t _I) const
 Returns constant reference to factor->variable message adjoint. More...
 
Parallel algorithm
void calcNewN (size_t i, size_t _I)
 Calculates new variable->factor message adjoint. More...
 
void calcNewM (size_t i, size_t _I)
 Calculates new factor->variable message adjoint. More...
 
void calcUnnormMsgN (size_t i, size_t _I)
 Calculates unnormalized variable->factor message adjoint from the normalized one. More...
 
void calcUnnormMsgM (size_t i, size_t _I)
 Calculates unnormalized factor->variable message adjoint from the normalized one. More...
 
void upMsgN (size_t i, size_t _I)
 Updates (un)normalized variable->factor message adjoints. More...
 
void upMsgM (size_t i, size_t _I)
 Updates (un)normalized factor->variable message adjoints. More...
 
void doParUpdate ()
 Do one parallel update of all message adjoints. More...
 
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. More...
 
void setSeqMsgM (size_t i, size_t _I, const Prob &p)
 Sets normalized factor->variable message adjoint and calculates the corresponding unnormalized adjoint. More...
 
void sendSeqMsgN (size_t i, size_t _I, const Prob &f)
 Implements routine Send-n in Figure 5 in [EaG09]. More...
 
void sendSeqMsgM (size_t i, size_t _I)
 Implements routine Send-m in Figure 5 in [EaG09]. More...
 

Private Attributes

Input variables
BP_dual _bp_dual
 Stores a BP_dual helper object. More...
 
const FactorGraph * _fg
 Pointer to the factor graph. More...
 
const InfAlg * _ia
 Pointer to the approximate inference algorithm (currently, only BP objects are supported) More...
 
Output variables
std::vector< Prob > _adj_psi_V
 Variable factor adjoints. More...
 
std::vector< Prob > _adj_psi_F
 Factor adjoints. More...
 
std::vector< std::vector< Prob > > _adj_n
 Variable->factor message adjoints (indexed [i][_I]) More...
 
std::vector< std::vector< Prob > > _adj_m
 Factor->variable message adjoints (indexed [i][_I]) More...
 
std::vector< Prob > _adj_b_V
 Normalized variable belief adjoints. More...
 
std::vector< Prob > _adj_b_F
 Normalized factor belief adjoints. More...
 
Internal state variables
std::vector< Prob > _init_adj_psi_V
 Initial variable factor adjoints. More...
 
std::vector< Prob > _init_adj_psi_F
 Initial factor adjoints. More...
 
std::vector< std::vector< Prob > > _adj_n_unnorm
 Unnormalized variable->factor message adjoint (indexed [i][_I]) More...
 
std::vector< std::vector< Prob > > _adj_m_unnorm
 Unnormalized factor->variable message adjoint (indexed [i][_I]) More...
 
std::vector< std::vector< Prob > > _new_adj_n
 Updated normalized variable->factor message adjoint (indexed [i][_I]) More...
 
std::vector< std::vector< Prob > > _new_adj_m
 Updated normalized factor->variable message adjoint (indexed [i][_I]) More...
 
std::vector< Prob > _adj_b_V_unnorm
 Unnormalized variable belief adjoints. More...
 
std::vector< Prob > _adj_b_F_unnorm
 Unnormalized factor belief adjoints. More...
 
std::vector< std::vector< Prob > > _Tmsg
 _Tmsg[i]_I in [EaG09]) More...
 
std::vector< std::vector< Prob > > _Umsg
 _Umsg[I]_i in [EaG09]) More...
 
std::vector< std::vector< std::vector< Prob > > > _Smsg
 _Smsg[i][_I]_j in [EaG09]) More...
 
std::vector< std::vector< std::vector< Prob > > > _Rmsg
 _Rmsg[I][_i]_J in [EaG09]) More...
 
size_t _iters
 Number of iterations done. More...
 

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. More...
 

Index cache management (for performance)

typedef std::vector< size_t > _ind_t
 Index type. More...
 
std::vector< std::vector< _ind_t > > _indices
 Cached indices (indexed [i][_I]) More...
 
void RegenerateInds ()
 Prepares index cache _indices. More...
 
const _ind_t & _index (size_t i, size_t _I) const
 Returns an index from the cache. 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
iashould be a BP object or something compatible
optsParameters
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
inlineprivate

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 
)
inlineprivate

Returns reference to T value; see eqn. (41) in [EaG09].

const Prob& dai::BBP::T ( size_t  i,
size_t  _I 
) const
inlineprivate

Returns constant reference to T value; see eqn. (41) in [EaG09].

Prob& dai::BBP::U ( size_t  I,
size_t  _i 
)
inlineprivate

Returns reference to U value; see eqn. (42) in [EaG09].

const Prob& dai::BBP::U ( size_t  I,
size_t  _i 
) const
inlineprivate

Returns constant reference to U value; see eqn. (42) in [EaG09].

Prob& dai::BBP::S ( size_t  i,
size_t  _I,
size_t  _j 
)
inlineprivate

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
inlineprivate

Returns constant reference to S value; see eqn. (43) in [EaG09].

Prob& dai::BBP::R ( size_t  I,
size_t  _i,
size_t  _J 
)
inlineprivate

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
inlineprivate

Returns constant reference to R value; see eqn. (44) in [EaG09].

Prob& dai::BBP::adj_n ( size_t  i,
size_t  _I 
)
inlineprivate

Returns reference to variable->factor message adjoint.

const Prob& dai::BBP::adj_n ( size_t  i,
size_t  _I 
) const
inlineprivate

Returns constant reference to variable->factor message adjoint.

Prob& dai::BBP::adj_m ( size_t  i,
size_t  _I 
)
inlineprivate

Returns reference to factor->variable message adjoint.

const Prob& dai::BBP::adj_m ( size_t  i,
size_t  _I 
) const
inlineprivate

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
cfnCost function used for initialization;
statePis 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
bpBP object;
stateGlobal state of all variables;
bbp_propsBBP parameters;
cfnCost function to be used;
hSize 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 in [EaG09])

std::vector<std::vector<Prob > > dai::BBP::_Umsg
private

_Umsg[I]_i in [EaG09])

std::vector<std::vector<std::vector<Prob > > > dai::BBP::_Smsg
private

_Smsg[i][_I]_j in [EaG09])

std::vector<std::vector<std::vector<Prob > > > dai::BBP::_Rmsg
private

_Rmsg[I][_i]_J 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/authors.html0000644000175000017500000000631312552201363016256 0ustar jorismjorism 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),
Siamak Ravanbakhsh (contributed the generalized loop corrections code),
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, Laurens van der Maaten, Jerome Maye, Priya, Hynek Urban,
Avneesh Saluja, Thomas Mensink, Julien Rebetez, Kyle Ellrott.

Part of this work was part of the Interactive Collaborative Information Systems (ICIS) 
project, supported by the Dutch Ministry of Economic Affairs, grant BSIK03024. The
Radboud University Nijmegen, The Netherlands, is one of the copyright holders.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BP_1_1EdgeProp-members.html0000644000175000017500000000726412552201364023202 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BP__dual_1_1beliefs.html0000644000175000017500000001762412552201364022623 0ustar jorismjorism libDAI: dai::BP_dual::beliefs Struct Reference
Public Attributes | List of all members
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>

Public Attributes

std::vector< Prob > b1
 Unnormalized variable beliefs. More...
 
std::vector< Real > Zb1
 Normalizers of variable beliefs. More...
 
std::vector< Prob > b2
 Unnormalized factor beliefs. More...
 
std::vector< Real > Zb2
 Normalizers of factor beliefs. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/alldai_8h.html0000644000175000017500000002614712552201363016425 0ustar jorismjorism libDAI: include/dai/alldai.h File Reference
Namespaces | Functions
alldai.h File Reference

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

#include <dai/dai_config.h>
#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

 dai
 Namespace for libDAI.
 

Functions

std::map< std::string, InfAlg * > & dai::builtinInfAlgs ()
 Returns a map that contains for each built-in inference algorithm its name and a pointer to an object of that type. More...
 
std::set< std::string > dai::builtinInfAlgNames ()
 Returns a set of names of all available inference algorithms. More...
 
InfAlg * dai::newInfAlg (const std::string &name, const FactorGraph &fg, const PropertySet &opts)
 Constructs a new inference algorithm. More...
 
InfAlg * dai::newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg)
 Constructs a new inference algorithm. More...
 
InfAlg * dai::newInfAlgFromString (const std::string &nameOpts, const FactorGraph &fg, const std::map< std::string, std::string > &aliases)
 Constructs a new inference algorithm. More...
 
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". More...
 
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. More...
 
std::map< std::string, std::string > dai::readAliasesFile (const std::string &filename)
 Reads aliases from file named filename. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/todo.html0000644000175000017500000001757312552201364015551 0ustar jorismjorism libDAI: Todo List
Todo List
File alldai.h

Replace VarSets by SmallSet<size_t> where appropriate, in order to minimize the use of FactorGraph::findVar().

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.
Member dai::BP::setProperties (const PropertySet &opts)
Make DAI_BP_FAST a compile-time choice, as it is a memory/speed tradeoff
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::CobwebGraph
Implement unit test for Cobwebgraph
Member dai::CobwebGraph::Connection::newmsg
Remove CobwebGraph::Connection::newmsg
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
Author
Frederik Eaton
Class dai::TFactor< T >

Define a better fileformat for .fg files (maybe using XML)?

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 emalg.h
Implement parameter estimation for undirected models / factor graphs.
File glc.h
Fix the init of GLC
File hak.h

Use ClusterGraph instead of a vector<VarSet> for speed.

Optimize this code for large factor graphs.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1PropertySet-members.html0000644000175000017500000002075612552201367022700 0ustar jorismjorism libDAI: Member List
dai::PropertySet Member List

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

clear()dai::PropertySetinline
convertTo(const PropertyKey &key)dai::PropertySetinline
erase(const PropertyKey &key)dai::PropertySetinline
fromString(const std::string &s)dai::PropertySetinline
get(const PropertyKey &key) const dai::PropertySetinline
getAs(const PropertyKey &key) const dai::PropertySetinline
getStringAs(const PropertyKey &key) const dai::PropertySetinline
hasKey(const PropertyKey &key) const dai::PropertySetinline
keys() const dai::PropertySetinline
operator()(const PropertyKey &key, const PropertyValue &val) const dai::PropertySetinline
operator<<(std::ostream &os, const PropertySet &ps)dai::PropertySetfriend
operator>>(std::istream &is, PropertySet &ps)dai::PropertySetfriend
PropertySet()dai::PropertySetinline
PropertySet(const std::string &s)dai::PropertySetinline
set(const PropertyKey &key, const PropertyValue &val)dai::PropertySetinline
set(const PropertySet &newProps)dai::PropertySetinline
setAsString(const PropertyKey &key, const ValueType &val)dai::PropertySetinline
size() const dai::PropertySetinline
toString() const dai::PropertySetinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/exceptions_8h_source.html0000644000175000017500000007615512552201363020744 0ustar jorismjorism libDAI: include/dai/exceptions.h Source File
exceptions.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_exceptions_h
14 #define __defined_libdai_exceptions_h
15 
16 
17 #include <exception>
18 #include <stdexcept>
19 #include <string>
20 #include <iostream>
21 
22 
24 #define DAI_QUOTE(x) #x
25 
27 #define DAI_TOSTRING(x) DAI_QUOTE(x)
28 
30 
39 #if defined __GNUG__ // GNU C++
40  #define FUNCTION_NAME __PRETTY_FUNCTION__
41 #elif defined _MSC_VER // Visual Studio
42  #define FUNCTION_NAME __FUNCTION__
43 #else // other compilers
44  #define FUNCTION_NAME __func__
45 #endif
46 #define DAI_THROW(cod) throw dai::Exception(dai::Exception::cod, __FILE__, FUNCTION_NAME, DAI_TOSTRING(__LINE__), "")
47 
49 
57 #define DAI_THROWE(cod,msg) throw dai::Exception(dai::Exception::cod, __FILE__, FUNCTION_NAME, DAI_TOSTRING(__LINE__), msg)
58 
60 #define DAI_ASSERT(condition) ((condition) ? ((void)0) : DAI_THROWE(ASSERTION_FAILED, std::string("Assertion \"" #condition "\" failed")))
61 
62 // Assertion only if DAI_DEBUG is defined
63 #ifdef DAI_DEBUG
64 #define DAI_DEBASSERT(x) do {DAI_ASSERT(x);} while(0)
66 #else
67 #define DAI_DEBASSERT(x) do {} while(0)
68 #endif
69 
70 
71 namespace dai {
72 
73 
75 
79 class Exception : public std::runtime_error {
80  public:
82  enum Code {NOT_IMPLEMENTED,
83  ASSERTION_FAILED,
84  IMPOSSIBLE_TYPECAST,
85  OBJECT_NOT_FOUND,
86  BELIEF_NOT_AVAILABLE,
87  UNKNOWN_ENUM_VALUE,
88  UNKNOWN_DAI_ALGORITHM,
89  UNKNOWN_PARAMETER_ESTIMATION_METHOD,
90  UNKNOWN_PROPERTY_TYPE,
91  UNKNOWN_PROPERTY,
92  MALFORMED_PROPERTY,
93  NOT_ALL_PROPERTIES_SPECIFIED,
94  INVALID_ALIAS,
95  CANNOT_READ_FILE,
96  CANNOT_WRITE_FILE,
97  INVALID_FACTORGRAPH_FILE,
98  INVALID_EVIDENCE_FILE,
99  INVALID_EMALG_FILE,
100  NOT_NORMALIZABLE,
101  MULTIPLE_UNDO,
102  FACTORGRAPH_NOT_CONNECTED,
103  INTERNAL_ERROR,
104  RUNTIME_ERROR,
105  OUT_OF_MEMORY,
106  NUM_ERRORS}; // NUM_ERRORS should be the last entry
107 
109  Exception( Code code, const char *filename, const char *function, const char *line, const std::string& detailedMsg ) :
110  std::runtime_error(ErrorStrings[code] + (detailedMsg.empty() ? "" : (": " + detailedMsg)) + " [File " + filename + ", line " + line + ", function: " + function + "]"),
111  _errorcode(code), _detailedMsg(detailedMsg), _filename(filename), _function(function), _line(line) {}
112 
114  ~Exception() throw () {}
115 
117  Code getCode() const { return _errorcode; }
118 
120 
122  Code code() const { return getCode(); }
123 
125  const std::string& getMsg() const { return ErrorStrings[_errorcode]; }
126 
128  const std::string& getDetailedMsg() const { return _detailedMsg; }
129 
131  const std::string& getFilename() const { return _filename; }
132 
134  const std::string& getFunction() const { return _function; }
135 
137  const std::string& getLine() const { return _line; }
138 
140  const std::string& message( const Code c ) const { return ErrorStrings[c]; }
141 
142  private:
144  Code _errorcode;
145 
147  std::string _detailedMsg;
148 
150  std::string _filename;
151 
153  std::string _function;
154 
156  std::string _line;
157 
159  static std::string ErrorStrings[NUM_ERRORS];
160 };
161 
162 
163 }
164 
165 
166 #endif
dai::Exception::getCode
Code getCode() const
Returns error code of this exception.
Definition: exceptions.h:117
dai::Exception::code
Code code() const
Returns error code of this exception.
Definition: exceptions.h:122
dai::Exception::ErrorStrings
static std::string ErrorStrings[NUM_ERRORS]
Error messages corresponding to the exceptions enumerated above.
Definition: exceptions.h:159
std
STL namespace.
dai::Exception::~Exception
~Exception()
Destructor.
Definition: exceptions.h:114
dai::Exception
Error handling in libDAI is done by throwing an instance of the Exception class.
Definition: exceptions.h:79
dai::Exception::_detailedMsg
std::string _detailedMsg
Contains the detailed message of this exception, if any.
Definition: exceptions.h:147
dai::Exception::Exception
Exception(Code code, const char *filename, const char *function, const char *line, const std::string &detailedMsg)
Constructor.
Definition: exceptions.h:109
dai::Exception::message
const std::string & message(const Code c) const
Returns error message corresponding to an error code.
Definition: exceptions.h:140
dai::Exception::getFilename
const std::string & getFilename() const
Returns filename where this exception was thrown.
Definition: exceptions.h:131
dai::Exception::_line
std::string _line
Contains the line number where this exception was thrown.
Definition: exceptions.h:156
dai::Exception::_errorcode
Code _errorcode
Contains the error code of this exception.
Definition: exceptions.h:144
dai::Exception::getDetailedMsg
const std::string & getDetailedMsg() const
Returns detailed error message of this exception.
Definition: exceptions.h:128
dai::Exception::_filename
std::string _filename
Contains the filename where this exception was thrown.
Definition: exceptions.h:150
dai::Exception::getFunction
const std::string & getFunction() const
Returns function name in which this exception was thrown.
Definition: exceptions.h:134
dai::Exception::getLine
const std::string & getLine() const
Returns line number where this exception was thrown.
Definition: exceptions.h:137
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::Exception::_function
std::string _function
Contains the function name in which this exception was thrown.
Definition: exceptions.h:153
dai::Exception::Code
Code
Enumeration of exceptions used in libDAI.
Definition: exceptions.h:82
dai::Exception::getMsg
const std::string & getMsg() const
Returns short error message of this exception.
Definition: exceptions.h:125
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__pow.html0000644000175000017500000001215712552201365020611 0ustar jorismjorism libDAI: dai::fo_pow< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_pow< T > Struct Template Reference

Function object that returns x to the power y. More...

#include <dai/prob.h>

Inherits binary_function< T, T, T >.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (x ^ y) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BipartiteGraph_1_1levelType-members.html0000644000175000017500000000647412552201364026054 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1BP.png0000644000175000017500000000267612552201364017067 0ustar jorismjorism‰PNG  IHDR`À ÔI$PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2MIDATxíÝër²Ìᦩòþ/y{ÙIt}¯ÄeÙBPÉø8Bã8n$€í5ªn¢«+°j°«+°j°n÷.‡Žû§‹Ãª¿èÚ§mUÖ~‚؆ãD]ÎàýñÃã<ÏÀÓTÑÇ '9–÷óÞùéÅ3ª¿éç 9k.öïw«~³3Ýq-x|zºÀª?kÍöx¾ÐXõgݬÁßî¬úÝöZӱߺ¼ßžß ú‹>Xõ§X5T×`Õd‡ÅDõwX5XUƒX5XUƒX5ØVÇq·@;Þv SrívˆU`€\{ß ¤*0@´ò+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+ðå6Žã¸‘¶×¨º‰ ¬¬ÀªÁ ¬¬ÀªÁ¶<Üî ‡Ûêàí£ººßsóÔí;/zðÒ¿¼>4k^þXî«®úÞÑŸ`ëÀûétø`§iu™ÁKŒ»ÀÓûîùLSô¸¹<œÞ½üµœŸÙï.6êê¾mà㇜ÈtXÜÕáqÓûNÒkàË+'›¾“%ðâ5—žOryáæçµüøß>£Ý_·×g]µúµ¬¾‹«/àŸpîOlWûw~Ò«+äWÀ‹½ËKo€ÏÄx±Y/w®÷¯gðíñÿ€oÿû_œÁWsh}­ÿøçkðâ¹^¿îO­Á‡O2¯‹§ëúô‘ÏWþûÀóû,Ó9ækÙê\ó¼ü1­5×KÄßVýew0TÞ×'úLà³MõçXõªég¯útVýgX5XUƒX5XUƒmxÇq´ãmÐ2 ×nWa€Xȵ÷­0@ªD+/@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°+0@°_nÃ0  `{mgØV`€`V`€`Ÿ |9Íyo¾òÏ[€g*0°¼íæ-À3}0ð~‚NSu5ƒ üºO~ t—÷¿ì“O§™=»'€O÷—€'ûxàŦÀÙ5¸À/öžwZ"öÛËEn^ƒ^Ðä+0@°+0@°+0@°+0@°­Ã0l#€v¼í@¦äÚí* «À¹ö¾HU`€håV`€`V`€`V`€`V`€`VàÃn·Ûm.€´ÉyV`€`V`€`V`€`V`€`V`€`V`€`V`€`ô8ŽãËÛã8¾¼mzTÝDK`ÕMT`Õ`V V`Õ`V öàávo8Þ¦íü·ê½øv¬§¡—¡^zÁè_ |;úéaÞªþ¶_\u~~ôϾûÓ—¼šÁo |¬ï |ü!-Gt¾¿ðƒ±^?\žxàù_/\oV¯·XƒŒuœ‡x˜æç©þÏ×àóêtMûr‰P}¢—_u=yWÀÏþUÀËEëݯÇúhxàõºöÞÀ÷ÆúÞÀË+óqïê"7¯bªOö4ðƒ±~üüèŸVýozXõ?®ÀªÁ ¬¬ÀªÁ ¬¬ÀªÁ ¬¬ÀªÁöÀã8ŽÛh<Žã¸þEŒâh.€ÚIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1CobwebGraph.html0000644000175000017500000034305112552201364021124 0ustar jorismjorism libDAI: dai::CobwebGraph Class Reference
Classes | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
dai::CobwebGraph Class Reference

A CobwebGraph is a special type of region graph used by the GLC algorithm. More...

#include <dai/cobwebgraph.h>

Inheritance diagram for dai::CobwebGraph:
dai::FactorGraph

Classes

struct  Connection
 The information in connection between two regions. More...
 

Public Member Functions

 DAI_ENUM (NeighborType, ALL, TOP, CLOSEST)
 
Constructors and destructors
 CobwebGraph ()
 Default constructor. More...
 
 CobwebGraph (const FactorGraph &fg)
 Constructs a cobweb graph from a factor graph. More...
 
virtual CobwebGraph * clone () const
 Clone *this (virtual copy constructor) More...
 
Accessors and mutators
size_t nrCWs () const
 Returns the number of regions. More...
 
const std::map< VarSet, std::pair< int, std::vector< size_t > > > & cn (size_t R) const
 Returns constant reference to the _cn for region R. More...
 
std::map< VarSet, std::pair< int, std::vector< size_t > > > & cn (size_t R)
 Returns a reference to the _cn for region R. More...
 
const std::vector< VarSet > & outM (size_t R) const
 Returns constant reference the vector of domain of all outgoing messages from region R. More...
 
std::vector< VarSet > & outM (size_t R)
 Returns reference the vector of domain of all outgoing messages from region R. More...
 
const VarSet & outM (size_t R, size_t j) const
 Returns constant reference to the variables in the outgoing message from region R to its j'th neighbor. More...
 
VarSet & outM (size_t R, size_t j)
 Returns a reference to the variables in the outgoing message from region R to its j'th neighbor. More...
 
const SmallSet< size_t > & Rfs (size_t R) const
 Returns constant reference to the index of factors of region R. More...
 
SmallSet< size_t > & Rfs (size_t R)
 Returns reference to the index of factors of region R. More...
 
const SmallSet< size_t > & EXRs (size_t R) const
 Returns constant reference to the index of variables on the boundary of region R ( r) More...
 
SmallSet< size_t > & EXRs (size_t R)
 Returns reference to the index of variables on the boundary of region R ( r) More...
 
const SmallSet< size_t > & INRs (size_t R) const
 Returns constant reference to the index of variables inside region R (r) More...
 
SmallSet< size_t > & INRs (size_t R)
 Returns reference to the index of variables inside region R (r) More...
 
const Connection & M (size_t R, size_t i) const
 Returns constant reference to the connection structure from region R to its i'th neighbour. More...
 
Connection & M (size_t R, size_t i)
 Returns reference to the connection structure from region R to its i'th neighbour. More...
 
const std::vector< Connection > & M (size_t R) const
 Returns constant reference to the vector of connection structure from region R to all its neighbours. More...
 
std::vector< Connection > & M (size_t R)
 Returns vector of all connections to region R. More...
 
const std::vector< size_t > & var2CW (size_t i) const
 Returns the vector of region indices that contain i as internal variable. More...
 
Operations
void setRgn (std::vector< SmallSet< size_t > > regions, NeighborType neighbors, bool debugging=false)
 Sets up all the regions and messages. More...
 
- Public Member Functions inherited from dai::FactorGraph
 FactorGraph ()
 Default constructor. More...
 
 FactorGraph (const std::vector< Factor > &P)
 Constructs a factor graph from a vector of factors. More...
 
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. More...
 
virtual ~FactorGraph ()
 Destructor. More...
 
const Var & var (size_t i) const
 Returns constant reference the i 'th variable. More...
 
const std::vector< Var > & vars () const
 Returns constant reference to all variables. More...
 
const Factor & factor (size_t I) const
 Returns constant reference to I 'th factor. More...
 
const std::vector< Factor > & factors () const
 Returns constant reference to all factors. More...
 
const Neighbors & nbV (size_t i) const
 Returns constant reference to neighbors of the i 'th variable. More...
 
const Neighbors & nbF (size_t I) const
 Returns constant reference to neighbors of the I 'th factor. More...
 
const Neighbor & nbV (size_t i, size_t _I) const
 Returns constant reference to the _I 'th neighbor of the i 'th variable. More...
 
const Neighbor & nbF (size_t I, size_t _i) const
 Returns constant reference to the _i 'th neighbor of the I 'th factor. More...
 
const BipartiteGraph & bipGraph () const
 Returns neighborhood structure. More...
 
size_t nrVars () const
 Returns number of variables. More...
 
size_t nrFactors () const
 Returns number of factors. More...
 
size_t nrEdges () const
 Calculates number of edges. More...
 
size_t findVar (const Var &n) const
 Returns the index of a particular variable. More...
 
SmallSet< size_t > findVars (const VarSet &ns) const
 Returns a set of indexes corresponding to a set of variables. More...
 
size_t findFactor (const VarSet &ns) const
 Returns index of the first factor that depends on the variables. More...
 
VarSet inds2vars (const std::vector< size_t > &inds) const
 Returns the VarSet corresponding to a vector of variable indices. More...
 
VarSet Delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself included. More...
 
VarSet Delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself included. More...
 
VarSet delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself excluded. More...
 
VarSet delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself excluded. More...
 
SmallSet< size_t > Deltai (size_t i) const
 Return all the indices of variables that occur in a factor involving the i 'th variable, itself included. More...
 
SmallSet< size_t > deltai (size_t i) const
 Return all the indices of variables that occur in a factor involving the i 'th variable, itself excluded. More...
 
bool isConnected () const
 Returns true if the factor graph is connected. More...
 
bool isTree () const
 Returns true if the factor graph is a tree (i.e., has no cycles and is connected) More...
 
bool isPairwise () const
 Returns true if each factor depends on at most two variables. More...
 
bool isBinary () const
 Returns true if each variable has only two possible values. More...
 
GraphAL MarkovGraph () const
 Constructs the corresponding Markov graph. More...
 
bool isMaximal (size_t I) const
 Returns whether the I 'th factor is maximal. More...
 
size_t maximalFactor (size_t I) const
 Returns the index of a maximal factor that contains the I 'th factor. More...
 
std::vector< VarSet > maximalFactorDomains () const
 Returns the maximal factor domains in this factorgraph. More...
 
Real logScore (const std::vector< size_t > &statevec) const
 Evaluates the log score (i.e., minus the energy) of the joint configuration statevec. More...
 
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. More...
 
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. More...
 
void backupFactor (size_t I)
 Makes a backup of the I 'th factor. More...
 
void restoreFactor (size_t I)
 Restores the I 'th factor from the backup (it should be backed up first) More...
 
virtual void backupFactors (const std::set< size_t > &facs)
 Backup the factors specified by indices in facs. More...
 
virtual void restoreFactors ()
 Restore all factors to the backup copies. More...
 
void backupFactors (const VarSet &ns)
 Makes a backup of all factors connected to a set of variables. More...
 
void restoreFactors (const VarSet &ns)
 Restores all factors connected to a set of variables from their backups. More...
 
FactorGraph maximalFactors () const
 Returns a copy of *this, where all factors that are subsumed by some larger factor are merged with the larger factors. More...
 
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. More...
 
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}$) More...
 
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. More...
 
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. More...
 
virtual void makeCavity (size_t i, bool backup=false)
 Set all factors interacting with the i 'th variable to 1. More...
 
virtual void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Set all factors indexed by facInds to 1. More...
 
std::string toString () const
 Formats a factor graph as a string. More...
 
void fromString (const std::string &s)
 Reads a factor graph from a string. More...
 

Protected Member Functions

bool checkPartition (const std::vector< SmallSet< size_t > > &regions) const
 The function to check for partitioning. More...
 
void setVar2CW ()
 Helper function that sets the regions containing each variable using the values in _INRs. More...
 
void setExtnFact ()
 Setup the _INRs, _EXRs and all the factor indices (e.g. Rifs) More...
 
void setMSGs (NeighborType neighbors)
 Helper function that setups the msgs (_M, _outM) using the values in _INRs and _EXRs. More...
 
void setCountingNumbers (bool debugging=false)
 Sets _cn. More...
 
void eraseNonMaximal (std::vector< SmallSet< size_t > > &regions)
 For the given set of variables for each region, removes the regions that are non-maximal. More...
 

Protected Attributes

std::vector< SmallSet< size_t > > _INRs
 Vector of variable indices internal to each region (r) More...
 
std::vector< SmallSet< size_t > > _EXRs
 Vector of variable indices on the boundary of each region ( r) More...
 
std::vector< SmallSet< size_t > > _Rfs
 Index of factors in each region. More...
 
std::vector< SmallSet< size_t > > _Rifs
 Index of factors internal to each region, i.e., all its variables are internal to the region. More...
 
std::vector< SmallSet< size_t > > _Rxfs
 Index of factors that bridge each region, i.e., not all its variables are internal to the region. More...
 
std::vector< std::vector< VarSet > > _outM
 The vector of domain of messages leaving each region ( r_{p,q}) More...
 
std::vector< std::vector< Connection > > _M
 Vector of all connections to each region. More...
 
std::vector< std::vector< size_t > > _var2CW
 For each i the index of (cobweb) regions that contain variable i. More...
 
std::vector< std::map< VarSet, std::pair< int, std::vector< size_t > > > > _cn
 
bool isPartition
 Whether a given set of region vars makes a partitioning or not. More...
 

Input/output

virtual void ReadFromFile (const char *)
 Reads a cobweb graph from a file. More...
 
virtual void WriteToFile (const char *, size_t=15) const
 Writes a cobweb graph to a file. More...
 
std::string toString () const
 Formats a cobweb graph as a string. More...
 
virtual void printDot (std::ostream &) const
 Writes a cobweb graph to a GraphViz .dot file. More...
 
std::ostream & operator<< (std::ostream &, const CobwebGraph &)
 Writes a cobweb graph to an output stream. More...
 

Detailed Description

A CobwebGraph is a special type of region graph used by the GLC algorithm.

Author
Siamak Ravanbakhsh
Todo:
Implement unit test for Cobwebgraph

Constructor & Destructor Documentation

dai::CobwebGraph::CobwebGraph ( )
inline

Default constructor.

dai::CobwebGraph::CobwebGraph ( const FactorGraph &  fg)
inline

Constructs a cobweb graph from a factor graph.

Member Function Documentation

dai::CobwebGraph::DAI_ENUM ( NeighborType  ,
ALL  ,
TOP  ,
CLOSEST   
)

Indicates what happens if a subset of variables in the boundary of a region ( r_p) is shared by some neighbors such that one ( r_{p,q1}) is a subset of another ( r_{p,q2}).

  • ALL all such neighbors are included in the the updates.
  • TOP only ( r_{p,q2}) is included unless ( r_{p,q2} = r_{p,q1}) in which case both are included
  • CLOSEST (default): similar to TOP but in case of a tie the the region r_q with largest r_q r_p is considered
    Note
    Not important in perfomance!
virtual CobwebGraph* dai::CobwebGraph::clone ( ) const
inlinevirtual

Clone *this (virtual copy constructor)

Reimplemented from dai::FactorGraph.

size_t dai::CobwebGraph::nrCWs ( ) const
inline

Returns the number of regions.

const std::map<VarSet, std::pair<int,std::vector<size_t> > >& dai::CobwebGraph::cn ( size_t  R) const
inline

Returns constant reference to the _cn for region R.

std::map<VarSet, std::pair<int,std::vector<size_t> > >& dai::CobwebGraph::cn ( size_t  R)
inline

Returns a reference to the _cn for region R.

const std::vector<VarSet>& dai::CobwebGraph::outM ( size_t  R) const
inline

Returns constant reference the vector of domain of all outgoing messages from region R.

std::vector<VarSet>& dai::CobwebGraph::outM ( size_t  R)
inline

Returns reference the vector of domain of all outgoing messages from region R.

const VarSet& dai::CobwebGraph::outM ( size_t  R,
size_t  j 
) const
inline

Returns constant reference to the variables in the outgoing message from region R to its j'th neighbor.

j corresponds to dual in the connection construct

VarSet& dai::CobwebGraph::outM ( size_t  R,
size_t  j 
)
inline

Returns a reference to the variables in the outgoing message from region R to its j'th neighbor.

j corresponds to dual in the connection construct

const SmallSet<size_t>& dai::CobwebGraph::Rfs ( size_t  R) const
inline

Returns constant reference to the index of factors of region R.

SmallSet<size_t>& dai::CobwebGraph::Rfs ( size_t  R)
inline

Returns reference to the index of factors of region R.

const SmallSet<size_t>& dai::CobwebGraph::EXRs ( size_t  R) const
inline

Returns constant reference to the index of variables on the boundary of region R ( r)

SmallSet<size_t>& dai::CobwebGraph::EXRs ( size_t  R)
inline

Returns reference to the index of variables on the boundary of region R ( r)

const SmallSet<size_t>& dai::CobwebGraph::INRs ( size_t  R) const
inline

Returns constant reference to the index of variables inside region R (r)

SmallSet<size_t>& dai::CobwebGraph::INRs ( size_t  R)
inline

Returns reference to the index of variables inside region R (r)

const Connection& dai::CobwebGraph::M ( size_t  R,
size_t  i 
) const
inline

Returns constant reference to the connection structure from region R to its i'th neighbour.

Connection& dai::CobwebGraph::M ( size_t  R,
size_t  i 
)
inline

Returns reference to the connection structure from region R to its i'th neighbour.

const std::vector<Connection>& dai::CobwebGraph::M ( size_t  R) const
inline

Returns constant reference to the vector of connection structure from region R to all its neighbours.

std::vector<Connection>& dai::CobwebGraph::M ( size_t  R)
inline

Returns vector of all connections to region R.

const std::vector<size_t>& dai::CobwebGraph::var2CW ( size_t  i) const
inline

Returns the vector of region indices that contain i as internal variable.

void dai::CobwebGraph::setRgn ( std::vector< SmallSet< size_t > >  regions,
NeighborType  neighbors,
bool  debugging = false 
)

Sets up all the regions and messages.

virtual void dai::CobwebGraph::ReadFromFile ( const char *  )
inlinevirtual

Reads a cobweb graph from a file.

Note
Not implemented yet

Reimplemented from dai::FactorGraph.

virtual void dai::CobwebGraph::WriteToFile ( const char *  ,
size_t  = 15 
) const
inlinevirtual

Writes a cobweb graph to a file.

Note
Not implemented yet

Reimplemented from dai::FactorGraph.

std::string dai::CobwebGraph::toString ( ) const
inline

Formats a cobweb graph as a string.

virtual void dai::CobwebGraph::printDot ( std::ostream &  ) const
inlinevirtual

Writes a cobweb graph to a GraphViz .dot file.

Note
Not implemented yet

Reimplemented from dai::FactorGraph.

bool dai::CobwebGraph::checkPartition ( const std::vector< SmallSet< size_t > > &  regions) const
protected

The function to check for partitioning.

void dai::CobwebGraph::setVar2CW ( )
protected

Helper function that sets the regions containing each variable using the values in _INRs.

void dai::CobwebGraph::setExtnFact ( )
protected

Setup the _INRs, _EXRs and all the factor indices (e.g. Rifs)

void dai::CobwebGraph::setMSGs ( NeighborType  neighbors)
protected

Helper function that setups the msgs (_M, _outM) using the values in _INRs and _EXRs.

void dai::CobwebGraph::setCountingNumbers ( bool  debugging = false)
protected

Sets _cn.

void dai::CobwebGraph::eraseNonMaximal ( std::vector< SmallSet< size_t > > &  regions)
protected

For the given set of variables for each region, removes the regions that are non-maximal.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  ,
const CobwebGraph &   
)
friend

Writes a cobweb graph to an output stream.

Member Data Documentation

std::vector<SmallSet<size_t> > dai::CobwebGraph::_INRs
protected

Vector of variable indices internal to each region (r)

std::vector<SmallSet<size_t> > dai::CobwebGraph::_EXRs
protected

Vector of variable indices on the boundary of each region ( r)

std::vector<SmallSet<size_t> > dai::CobwebGraph::_Rfs
protected

Index of factors in each region.

std::vector<SmallSet<size_t> > dai::CobwebGraph::_Rifs
protected

Index of factors internal to each region, i.e., all its variables are internal to the region.

std::vector<SmallSet<size_t> > dai::CobwebGraph::_Rxfs
protected

Index of factors that bridge each region, i.e., not all its variables are internal to the region.

std::vector<std::vector<VarSet> > dai::CobwebGraph::_outM
protected

The vector of domain of messages leaving each region ( r_{p,q})

std::vector<std::vector<Connection> > dai::CobwebGraph::_M
protected

Vector of all connections to each region.

std::vector<std::vector<size_t> > dai::CobwebGraph::_var2CW
protected

For each i the index of (cobweb) regions that contain variable i.

std::vector<std::map<VarSet, std::pair<int,std::vector<size_t> > > > dai::CobwebGraph::_cn
protected

For each region r_p a mapping from all variables rho in its msg-region graph to a pair: first: counting number second: the index of top-regions that contain rho

bool dai::CobwebGraph::isPartition
protected

Whether a given set of region vars makes a partitioning or not.

The documentation for this class was generated from the following files:
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1CBP.html0000644000175000017500000025447412552201364017357 0ustar jorismjorism libDAI: dai::CBP Class Reference
Classes | Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | Related Functions | List of all members
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

Classes

struct  Properties
 Parameters for CBP. More...
 

Public Member Functions

 CBP ()
 Default constructor. More...
 
 CBP (const FactorGraph &fg, const PropertySet &opts)
 Construct CBP object from FactorGraph fg and PropertySet opts. More...
 
General InfAlg interface
virtual CBP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual CBP * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual std::vector< size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability. More...
 

Public Attributes

struct dai::CBP::Properties props
 

Private Member Functions

void printDebugInfo ()
 Prints beliefs, variables and partition sum, in case of a debugging build. More...
 
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. More...
 
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. More...
 
InfAlg * getInfAlg ()
 Return the InfAlg to use at each step of the recursion. More...
 
void setBeliefs (const std::vector< Factor > &bs, Real logZ)
 Sets variable beliefs, factor beliefs and log partition sum to the specified values. More...
 
void construct ()
 Constructor helper function. More...
 

Private Attributes

std::vector< Factor > _beliefsV
 Variable beliefs. More...
 
std::vector< Factor > _beliefsF
 Factor beliefs. More...
 
Real _logZ
 Logarithm of partition sum. More...
 
size_t _iters
 Numer of iterations needed. More...
 
Real _maxdiff
 Maximum difference encountered so far. More...
 
Real _sum_level
 Number of clampings at each leaf node. More...
 
size_t _num_leaves
 Number of leaves of recursion tree. More...
 
boost::shared_ptr< std::ofstream > _clamp_ofstream
 Output stream where information about the clampings is written. More...
 

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. 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 ( )
inline

Default constructor.

dai::CBP::CBP ( const FactorGraph &  fg,
const PropertySet &  opts 
)
inline

Construct CBP object from FactorGraph fg and PropertySet opts.

Parameters
fgFactor graph.
optsParameters
See also
Properties

Member Function Documentation

virtual CBP* dai::CBP::clone ( ) const
inlinevirtual

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

Implements dai::InfAlg.

virtual CBP* dai::CBP::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Implements dai::InfAlg.

virtual std::string dai::CBP::name ( ) const
inlinevirtual

Returns the name of the algorithm.

Implements dai::InfAlg.

virtual Factor dai::CBP::belief ( const Var &  v) const
inlinevirtual

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
inlinevirtual

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

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

Implements dai::InfAlg.

virtual Factor dai::CBP::beliefV ( size_t  i) const
inlinevirtual

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
inlinevirtual

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
inlinevirtual

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
inlinevirtual

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_IMPLEMENTEDif not implemented/supported

Implements dai::InfAlg.

virtual void dai::CBP::init ( )
inlinevirtual

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)
inlinevirtual

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_IMPLEMENTEDif 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
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::CBP::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::CBP::setMaxIter ( size_t  )
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::CBP::setProperties ( const PropertySet &  opts)
inlinevirtual

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
inlinevirtual

Returns parameters of this inference algorithm converted into a PropertySet.

Implements dai::InfAlg.

virtual std::string dai::CBP::printProperties ( ) const
inlinevirtual

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 
)
privatevirtual

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
bsshould be a concatenation of the variable beliefs followed by the factor beliefs
logZlog 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_bpinference algorithm (compatible with BP) that should have converged;
clampingVarif true, finds best variable, otherwise, finds best factor;
bbp_propsBBP parameters to use;
cfnBBP cost function to use;
maxVarOutmaximum 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.

The documentation for this class was generated from the following files:
  • include/dai/cbp.h
  • src/cbp.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/bp__dual_8h.html0000644000175000017500000001513412552201363016736 0ustar jorismjorism libDAI: include/dai/bp_dual.h File Reference
Classes | Namespaces
bp_dual.h File Reference

Defines class BP_dual, which is used primarily by BBP. More...

#include <dai/dai_config.h>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/enum.h>

Go to the source code of this file.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_s.html0000644000175000017500000001172612552201370020160 0ustar jorismjorism libDAI: Class Members - Variables
 

- s -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/uai2010-aie-solver_8cpp-example.html0000644000175000017500000016320712552201363022307 0ustar jorismjorism 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/
*
* Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
*/
#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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_n.html0000644000175000017500000002530112552201370017112 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- n -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__exp.html0000644000175000017500000001146312552201365020577 0ustar jorismjorism libDAI: dai::fo_exp< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_exp< T > Struct Template Reference

Function object that takes the exponent. More...

#include <dai/prob.h>

Inherits unary_function< T, T >.

Public Member Functions

T operator() (const T &x) const
 Returns exp(x) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_126.png0000644000175000017500000000354212552200250015737 0ustar jorismjorism‰PNG  IHDR[$i0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÑIDATxíëš²: …ßÒGíýßíNÒ‚àˆÈè|³ O—Š”4YYIþüàøÀ'‘º®[/ðM€=ø®ëÖ à¸ üOÐæܦù®9œƒó}¡6ì¡I9çrL—óxšƒ”Ê)Àf±v)v§œû§ùø—˜ò¸VW>/ܦ¹Ú÷ãØoWœç¿“AüðC®OºM(ŸÆ–œ§Z2Õ‰šÖ·O‹õ^Õºqko†´/œ…Ò¸m¤˜€õÚ嶻q»·e]¨;ú8Âywh)äܬ_6ËwE–ê×½¨}{ã¶+}ÔóÛÇ†Û M ¹Jî¼]âÕg¸ßÔ»ïÔ'ñ>®/lÐ?õRÛ©ÐþÕõÞÒbÜÊ.W M_òs–Û¶9Y%èõ1ÝÖ“Ýwº‡º¬Ö±•ëSŸn< k}×Ú5”[dNN=\¾â·Â£ó2¦6ÃìkhßàvtÖØb)8à¶$‚˜œßcÉG>ÄYôSe$vÚÓƒZ–»Û–}Ÿ»Y†ÆÙƶÑÚtƒ¸c$Çš¸õIÞ÷Nâ“ßAŽè×¾JÌ;­ü˜Ûèa,húåSHx$“Ø\eÏ%0è6 ج Ö¥Uå8Ì•Ü•<¤ÐL#ãW›ú,çÇe¬Ï$Ó8¹Š<ÛõðK}q5ûqxÀ­K½8/ƒ5V†š~.žâ¶u9Ð ×êl4–õj´B£ÇEvBòÝ3"%ÝÅy£wæV‰xL­¼™wêXlhõ4×Öáµ&Û¡h}æ6Þ,kîqÀ­„ÞXÇîNòCn}Ɖãy+²]B“íê,ÅS‰ô+ªê_š†°+ϼ£5esÓ5nÛõkæà‡ýVu#g\õÄî:âþ9Ç=Aõ!¡‡ârÚöñÅtÝ'':)a[Îe·ÓiZz‚–¥< ÷ºm¥+|A»?,…Hë ÕöœØr[u#Ò¸{ì&ÿnkA m©sKÞšúÍ®.iAš˜Ê5ö.¶Â{£Ã4») —ÁÛdŠ“2bǸ™KßívÚL¤r[m/‰Ý`ƒ#n«nü(óЈ®uÝcnkA\\‘ÙrzÜäOêYNÿ51…d×E˜„Ô¥ Ñ«Cƒy5;é[eCžlÐ<éCÁ”^ˆ´ªíê`s¢7q«1©d¢fm¾ù?ܸØà[¥ÔK¾dÏõQèþØ>ˆA§õÌŽ¼ÝLê˜ z./^Æd«å¤ ô6«‹x­ó,D¨ˆ…‚ÝW¶8ì·we,uf×=Þ½Á-°^š¶¶˜žD^ÊØ,o’¶ËmÓ¹´g}j;­–Ö»‘Òhù‹Eª˜òË1ê™ÍÝÀØÅ)nm‡³«31¿Óo×5,mÕô ?µ^ÀJ¸Ê/ÀSŒ›Æ­ÌïÊÖö×{€]œàÖõùV–¿'œâ¶Mé6σ±sbdœÀÒYœ÷qxAQßB7OYFÀ>Üvƒ{FÀ”ëÃqþ°”Û“ö» À8sηuK*À‘.j^‚_~¼ˆk¿[!ýU͉`—/£¹œ'àœ[/€ŸÁbÿÃ-Ö~Ø€?üàÃ\¹eö»òð–†0l~®•ü*Âz”5¸¾+!—/& ]öt=ÀëHímb¹Q^N­ºTÎkF%¹o[9aåÀ?K1îŽ^€@OhÚ¾—XÝ4JðõÿB·/ÙS~¼ˆ¬ä‰]e®Õ›j¸Øéì.Êyõ'À?D"«z¼ˆÉ—RªåËwøDÂÅ:¡j4:á@”Tn,­F©–íYn]V½ÖЦP×$΄úù+ÜÒLFñuN¶(ÙþÖ;m€—¥y| щõJ­Ð*È¡S¬ 9+ø‹œ'x*É9M.ŠŠÍuq¸±{»5mÇ“Ýà]¸Ôvi ½n‰¾j©Qߦ÷¹uš¿k/—Øë9 ­–ª ¬™$….*ùý9 T’£Ú•âŠN’¦®;uX•,Sªm ãç°Y.kÿ‰©ŸâUÂ4J;q×´fa|:M*k"/’†Û)£ª[©9ÚjàˆcWq¹›[‚JT>,GDmeFfívéHÿM¤Ñ€‹ ê¦Å;ˆsÃûºe²^j½pPŽõ”Zzkmv<;ËbêL¦£äDîTüZ®Ø°c$}~²Þû;ý¶ø©*UÌO?‡©y¿ß&JqÊ<7ó%›×:+×”žeÕ~߯ ¾ØP9—Ò(·¿Çí"°™ ñ¦ÄîßC5¬Öœ2µ_›¡ÓÞð’/Õ¯ÓÌy¹nYøøþ ?Œô¹ k£ø.þòœ,ŸÁ¥´IEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1fo__absdiff-members.html0000644000175000017500000000567512552201365023041 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/trwbp_8h_source.html0000644000175000017500000007741412552201363017720 0ustar jorismjorism libDAI: include/dai/trwbp.h Source File
trwbp.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_trwbp_h
14 #define __defined_libdai_trwbp_h
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_TRWBP
19 
20 
21 #include <string>
22 #include <dai/daialg.h>
23 #include <dai/factorgraph.h>
24 #include <dai/properties.h>
25 #include <dai/enum.h>
26 #include <dai/bp.h>
27 
28 
29 namespace dai {
30 
31 
33 
52 class TRWBP : public BP {
53  protected:
55 
60  std::vector<Real> _weight;
61 
62  public:
64 
68  size_t nrtrees;
69 
70  public:
72 
73  TRWBP() : BP(), _weight() {}
75 
77 
82  TRWBP( const FactorGraph &fg, const PropertySet &opts ) : BP(fg, opts), _weight() {
83  setProperties( opts );
84  construct();
85  }
87 
89 
90  virtual TRWBP* clone() const { return new TRWBP(*this); }
91  virtual TRWBP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new TRWBP( fg, opts ); }
92  virtual std::string name() const { return "TRWBP"; }
93  virtual Real logZ() const;
94  virtual void setProperties( const PropertySet &opts );
95  virtual PropertySet getProperties() const;
96  virtual std::string printProperties() const;
98 
100 
101  Real Weight( size_t I ) const { return _weight[I]; }
103 
105  const std::vector<Real>& Weights() const { return _weight; }
106 
108  void setWeight( size_t I, Real c ) { _weight[I] = c; }
109 
111 
113  void setWeights( const std::vector<Real> &c ) { _weight = c; }
114 
116  void addTreeToWeights( const RootedTree &tree );
117 
119  void sampleWeights( size_t nrTrees );
120 
121  protected:
123 
126  virtual Prob calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const;
127 
129  virtual void calcBeliefV( size_t i, Prob &p ) const;
130 
131  // Calculates unnormalized belief of factor \a I
132  virtual void calcBeliefF( size_t I, Prob &p ) const {
133  p = calcIncomingMessageProduct( I, false, 0 );
134  }
135 
136  // Helper function for constructors
137  virtual void construct();
138 };
139 
140 
141 } // end of namespace dai
142 
143 
144 #endif
145 
146 
147 #endif
dai::TRWBP
Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03].
Definition: trwbp.h:52
dai::TRWBP::addTreeToWeights
void addTreeToWeights(const RootedTree &tree)
Increases weights corresponding to pairwise factors in tree with 1.
Definition: trwbp.cpp:151
dai::TRWBP::clone
virtual TRWBP * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: trwbp.h:90
dai::TRWBP::calcIncomingMessageProduct
virtual Prob calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const
Calculate the product of factor I and the incoming messages.
Definition: trwbp.cpp:71
bp.h
Defines class BP, which implements (Loopy) Belief Propagation.
dai::TRWBP::_weight
std::vector< Real > _weight
"Edge weights" (indexed by factor ID)
Definition: trwbp.h:60
dai::TRWBP::sampleWeights
void sampleWeights(size_t nrTrees)
Samples weights from a sample of nrTrees random spanning trees.
Definition: trwbp.cpp:160
dai::TRWBP::construct
virtual TRWBP * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: trwbp.h:91
dai::TRWBP::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: trwbp.h:92
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::TRWBP::TRWBP
TRWBP(const FactorGraph &fg, const PropertySet &opts)
Construct from FactorGraph fg and PropertySet opts.
Definition: trwbp.h:82
dai::TRWBP::setProperties
virtual void setProperties(const PropertySet &opts)
Definition: trwbp.cpp:25
dai::TRWBP::calcBeliefV
virtual void calcBeliefV(size_t i, Prob &p) const
Calculates unnormalized belief of variable i.
Definition: trwbp.cpp:130
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::TRWBP::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: trwbp.cpp:53
dai::TRWBP::nrtrees
size_t nrtrees
Size of sample of trees used to set the weights.
Definition: trwbp.h:68
dai::TRWBP::setWeights
void setWeights(const std::vector< Real > &c)
Sets the weights of all factors simultaenously.
Definition: trwbp.h:113
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::BP
Approximate inference algorithm "(Loopy) Belief Propagation".
Definition: bp.h:63
dai::TRWBP::setWeight
void setWeight(size_t I, Real c)
Sets the weight of the I 'th factor to c.
Definition: trwbp.h:108
dai::RootedTree
Represents a rooted tree, implemented as a vector of directed edges.
Definition: weightedgraph.h:157
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::TRWBP::TRWBP
TRWBP()
Default constructor.
Definition: trwbp.h:74
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::TRWBP::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: trwbp.cpp:42
dai::TRWBP::Weight
Real Weight(size_t I) const
Returns weight corresponding to the I 'th factor.
Definition: trwbp.h:102
dai::TRWBP::construct
virtual void construct()
Helper function for constructors.
Definition: trwbp.cpp:142
dai::TRWBP::Weights
const std::vector< Real > & Weights() const
Returns constant reference to vector of all weights.
Definition: trwbp.h:105
dai::TRWBP::calcBeliefF
virtual void calcBeliefF(size_t I, Prob &p) const
Calculates unnormalized belief of factor I.
Definition: trwbp.h:132
dai::TRWBP::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: trwbp.cpp:35
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/hak_8h_source.html0000644000175000017500000013412612552201363017317 0ustar jorismjorism libDAI: include/dai/hak.h Source File
hak.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_HAK
19 
20 
21 #ifndef __defined_libdai_hak_h
22 #define __defined_libdai_hak_h
23 
24 
25 #include <string>
26 #include <dai/daialg.h>
27 #include <dai/regiongraph.h>
28 #include <dai/enum.h>
29 #include <dai/properties.h>
30 
31 
32 namespace dai {
33 
34 
36 class HAK : public DAIAlgRG {
37  private:
39  std::vector<Factor> _Qa;
41  std::vector<Factor> _Qb;
43  std::vector<std::vector<Factor> > _muab;
45  std::vector<std::vector<Factor> > _muba;
47  Real _maxdiff;
49  size_t _iters;
50 
51  public:
53  struct Properties {
55 
61  DAI_ENUM(ClustersType,MIN,BETHE,DELTA,LOOP);
62 
64  DAI_ENUM(InitType,UNIFORM,RANDOM);
65 
67  size_t verbose;
68 
70  size_t maxiter;
71 
73  double maxtime;
74 
76  Real tol;
77 
79  Real damping;
80 
82  ClustersType clusters;
83 
85  InitType init;
86 
88  bool doubleloop;
89 
91  size_t loopdepth;
92  } props;
93 
94  public:
96 
97  HAK() : DAIAlgRG(), _Qa(), _Qb(), _muab(), _muba(), _maxdiff(0.0), _iters(0U), props() {}
99 
101 
104  HAK( const FactorGraph &fg, const PropertySet &opts );
105 
107  HAK( const RegionGraph &rg, const PropertySet &opts );
109 
110 
112 
113  virtual HAK* clone() const { return new HAK(*this); }
114  virtual HAK* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new HAK( fg, opts ); }
115  virtual std::string name() const { return "HAK"; }
116  virtual Factor belief( const VarSet &vs ) const;
117  virtual std::vector<Factor> beliefs() const;
118  virtual Real logZ() const;
119  virtual void init();
120  virtual void init( const VarSet &vs );
121  virtual Real run();
122  virtual Real maxDiff() const { return _maxdiff; }
123  virtual size_t Iterations() const { return _iters; }
124  virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; }
125  virtual void setProperties( const PropertySet &opts );
126  virtual PropertySet getProperties() const;
127  virtual std::string printProperties() const;
129 
130 
132 
133  Factor & muab( size_t alpha, size_t _beta ) { return _muab[alpha][_beta]; }
136  Factor & muba( size_t alpha, size_t _beta ) { return _muba[alpha][_beta]; }
138  const Factor& Qa( size_t alpha ) const { return _Qa[alpha]; };
140  const Factor& Qb( size_t beta ) const { return _Qb[beta]; };
141 
143  Real doGBP();
145  Real doDoubleLoop();
147 
148  private:
150  void construct();
152 
160  void findLoopClusters( const FactorGraph &fg, std::set<VarSet> &allcl, VarSet newcl, const Var & root, size_t length, VarSet vars );
161 };
162 
163 
164 } // end of namespace dai
165 
166 
167 #endif
168 
169 
170 #endif
dai::HAK::Properties::loopdepth
size_t loopdepth
Depth of loops (only relevant for clusters == ClustersType::LOOP)
Definition: hak.h:91
dai::RegionGraph
A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions...
Definition: regiongraph.h:91
dai::HAK::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: hak.h:123
dai::HAK::findLoopClusters
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...
Definition: hak.cpp:155
dai::HAK::_maxdiff
Real _maxdiff
Maximum difference encountered so far.
Definition: hak.h:47
dai::HAK::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: hak.cpp:605
dai::HAK::construct
virtual HAK * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: hak.h:114
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::HAK::Properties::clusters
ClustersType clusters
How to choose the outer regions.
Definition: hak.h:82
dai::HAK::Qb
const Factor & Qb(size_t beta) const
Returns belief of inner region beta.
Definition: hak.h:140
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::HAK::HAK
HAK()
Default constructor.
Definition: hak.h:98
dai::HAK::_Qa
std::vector< Factor > _Qa
Outer region beliefs.
Definition: hak.h:39
dai::HAK::init
virtual void init()
Initializes all data structures of the approximate inference algorithm.
Definition: hak.cpp:301
dai::HAK::run
virtual Real run()
Runs the approximate inference algorithm.
Definition: hak.cpp:568
dai::HAK::clone
virtual HAK * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: hak.h:113
dai::HAK::Properties::damping
Real damping
Damping constant (0.0 means no damping, 1.0 is maximum damping)
Definition: hak.h:79
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::HAK::_iters
size_t _iters
Number of iterations needed.
Definition: hak.h:49
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::HAK::muab
Factor & muab(size_t alpha, size_t _beta)
Returns reference to message from outer region alpha to its _beta 'th neighboring inner region...
Definition: hak.h:134
dai::HAK::Properties::DAI_ENUM
DAI_ENUM(ClustersType, MIN, BETHE, DELTA, LOOP)
Enumeration of possible cluster choices.
dai::HAK::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: hak.cpp:95
dai::HAK::doDoubleLoop
Real doDoubleLoop()
Runs double-loop algorithm (as described in section 4.2 of [HAK03]), which always convergences...
Definition: hak.cpp:464
dai::HAK::belief
virtual Factor belief(const VarSet &vs) const
Returns the (approximate) marginal probability distribution of a set of variables.
Definition: hak.cpp:576
dai::HAK::setProperties
virtual void setProperties(const PropertySet &opts)
Set parameters of this inference algorithm.
Definition: hak.cpp:44
dai::HAK::Properties::init
InitType init
How to initialize the messages.
Definition: hak.h:85
dai::HAK::_Qb
std::vector< Factor > _Qb
Inner region beliefs.
Definition: hak.h:41
dai::HAK::Properties::doubleloop
bool doubleloop
Use single-loop (GBP) or double-loop (HAK)
Definition: hak.h:88
dai::HAK::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: hak.h:115
dai::HAK::Qa
const Factor & Qa(size_t alpha) const
Returns belief of outer region alpha.
Definition: hak.h:138
dai::HAK::Properties
Parameters for HAK.
Definition: hak.h:53
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
regiongraph.h
Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region grap...
dai::HAK::beliefs
virtual std::vector< Factor > beliefs() const
Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm...
Definition: hak.cpp:595
dai::HAK
Approximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and...
Definition: hak.h:36
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::HAK::doGBP
Real doGBP()
Runs single-loop algorithm (algorithm 1 in [HAK03])
Definition: hak.cpp:331
dai::HAK::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: hak.h:67
dai::HAK::construct
void construct()
Helper function for constructors.
Definition: hak.cpp:111
dai::HAK::setMaxIter
virtual void setMaxIter(size_t maxiter)
Sets maximum number of iterations (one iteration passes over the complete factorgraph).
Definition: hak.h:124
dai::HAK::Properties::maxtime
double maxtime
Maximum time (in seconds)
Definition: hak.h:73
dai::HAK::Properties::tol
Real tol
Tolerance for convergence test.
Definition: hak.h:76
dai::HAK::Properties::maxiter
size_t maxiter
Maximum number of iterations.
Definition: hak.h:70
dai::HAK::_muab
std::vector< std::vector< Factor > > _muab
Messages from outer to inner regions.
Definition: hak.h:43
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::HAK::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: hak.h:122
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::HAK::muba
Factor & muba(size_t alpha, size_t _beta)
Returns reference to message the _beta 'th neighboring inner region of outer region alpha to that out...
Definition: hak.h:136
dai::DAIAlg
Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)...
Definition: daialg.h:207
dai::HAK::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: hak.cpp:80
dai::HAK::_muba
std::vector< std::vector< Factor > > _muba
Messages from inner to outer regions.
Definition: hak.h:45
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1Permute-members.html0000644000175000017500000001334712552201367022017 0ustar jorismjorism libDAI: Member List
dai::Permute Member List

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

_rangesdai::Permuteprivate
_sigmadai::Permuteprivate
convertLinearIndex(size_t li) const dai::Permuteinline
inverse() const dai::Permuteinline
operator[](size_t i) const dai::Permuteinline
Permute()dai::Permuteinline
Permute(const std::vector< size_t > &rs, const std::vector< size_t > &sigma)dai::Permuteinline
Permute(const std::vector< Var > &vars, bool reverse=false)dai::Permuteinline
ranges()dai::Permuteinline
sigma() const dai::Permuteinline
sigma()dai::Permuteinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_j.html0000644000175000017500000001135012552201370017105 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- j -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_59.png0000644000175000017500000000037312552200230015661 0ustar jorismjorism‰PNG  IHDR?Ÿš0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïjIDATxíÝ „ …á_Í™Mmçþ·Í­ a3ˆ.0Šñá ^® øqyÞrmBhUŽìˆl}+gv„)ŸÝQm—ëïÜÜZ–Ò˜, I#|·‚”JýU·)\(K¯EäJÀ9Ïhü½+æ?YFÅ IEND®B`‚libDAI-0.3.2/doc/html/form_4.png0000644000175000017500000000031312552200214015563 0ustar jorismjorism‰PNG  IHDR lµÜ’0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï:IDATxí[ ! §¥>Š¸{ÿÛú!­ x‡!CHîðÀ-µ\ˆÕЦ_¶~¶¿„Ù$Æeä ݱ¨‰ óIEND®B`‚libDAI-0.3.2/doc/html/form_0.png0000644000175000017500000000107612552200213015565 0ustar jorismjorism‰PNG  IHDRGnà¢Ú0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï­IDATxí]Û²›0 \Y²dÌíÿÿ¶+IÏ™p&i;}cÐÄÁ°ö^ägøŸU¾ýÀ”ú…s àóêQx³ÔC´‰†X­®(-·R«q*‡ðFÉ‚2#"¨ÆÆ[*ÙÈŒœœà½²ÕŒK/¹4qâtÇ’*€SV Â´+°ª¤ÌsÁfyJ?Wq+µÃ´{²›ÉË͹ÉÔ>-òJ—¹ù@æ/ÎÕÃçT8¯zD߶mû˺áJ9™~Îœ¡ÐˆûV)‰Óã4*Ui,üèéì¨/2ãu¨~&Ê\DÃ\KwçÃÄ)c„å‰1I™ŽæM‡…}bÓd(òÚMiîkô(‰³Bsz‚¨º©Jtm mâµCv,D'-Þgëî"è–ÏÑ'&´ libDAI: Related Pages
Related Pages
Here is a list of all related documentation pages:
 License
 Citing libDAI
 Authors
 Building libDAI
 Change Log
 Terminology and conventions
 libDAI file formats
 Bibliography
 Ideas not worth exploring
 Ideas worth exploring
 Todo List
 Deprecated List
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions.html0000644000175000017500000005215712552201370016606 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- _ -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/treeep_8h.html0000644000175000017500000001504312552201363016454 0ustar jorismjorism libDAI: include/dai/treeep.h File Reference
Classes | Namespaces
treeep.h File Reference

Defines class TreeEP, which implements Tree Expectation Propagation. More...

#include <dai/dai_config.h>
#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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__absdiff.html0000644000175000017500000001230512552201365021375 0ustar jorismjorism libDAI: dai::fo_absdiff< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_absdiff< T > Struct Template Reference

Function object that returns the absolute difference of x and y. More...

#include <dai/prob.h>

Inherits binary_function< T, T, T >.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns abs( x - y ) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_129.png0000644000175000017500000000034112552200250015734 0ustar jorismjorism‰PNG  IHDR(–Ýã0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïPIDATxíÝÑ À д*%qÿmkÔ#Á„3/*8üJ”eía˜ÕÃ*ßVVêm§³­ìï}PboýP†3·*DX:=ÃÃÓO÷úkÆ)_ ŠiIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1DAG-members.html0000644000175000017500000002760312552201365020767 0ustar jorismjorism libDAI: Member List
dai::DAG Member List

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

_chdai::DAGprivate
_padai::DAGprivate
addEdge(size_t n1, size_t n2, bool check=true)dai::DAG
addNode()dai::DAGinline
addNode(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::DAGinline
ancestors(size_t n, bool inclusive) const dai::DAG
ch(size_t n, size_t _c) const dai::DAGinline
ch(size_t n, size_t _c)dai::DAGinline
ch(size_t n) const dai::DAGinline
ch(size_t n)dai::DAGinline
checkConsistency() const dai::DAG
chSet(size_t n) const dai::DAG
construct(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::DAG
DAG()dai::DAGinline
DAG(size_t nr)dai::DAGinline
DAG(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::DAGinline
descendants(size_t n, bool inclusive) 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::DAGinline
findPa(size_t n, size_t p)dai::DAGinline
hasEdge(size_t n1, size_t n2) const dai::DAGinline
isConnected() const dai::DAG
nrEdges() const dai::DAGinline
nrNodes() const dai::DAGinline
operator<<(std::ostream &os, const DAG &g)dai::DAGfriend
operator==(const DAG &x) const dai::DAGinline
pa(size_t n, size_t _p) const dai::DAGinline
pa(size_t n, size_t _p)dai::DAGinline
pa(size_t n) const dai::DAGinline
pa(size_t n)dai::DAGinline
paSet(size_t n) const dai::DAG
printDot(std::ostream &os) const dai::DAG
toString() const dai::DAGinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_5.png0000644000175000017500000000274012552200214015572 0ustar jorismjorism‰PNG  IHDR $»0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïOIDATxíévó¬…Fã$6÷·G’ÁCë¤é꛶ç[uÙÁ ¤­é/Àþð€_WJÙà‹¥”ýxŒ\JÙ ðKàjrʵÖð5ø\kmk½>an”}M[­cø-µúݴܾŠTë*àc\ê¥)P¯/Ä‘~Aœ·ŸxìÆ=é+/OT6‚Ú À+ÞT‘ü!CóÑgo8бFÕ;ÝïHÿͽ Ð#VÊÐÃ2QWÎÇ}2>’þ‹ JïÚPþ°ìÆZß…ÍÎØieò„sé?HP >eb¼gõÅœœ²«éØÌ’†.4ø|ÂÅXg€SäëÜ9_ÈOÉ¥MH—ìÆ+úÈòVB]aaV½üûaëYš‘_5kÆ—ªàê·Y›¶›F}K>T_EËvù)µ/ èh¹Ü}§úE)˜ñ¤Þë®—Ã.'Ö›¾bDèB7!‰Ü8Ÿóƒ¯r;À få!*%“ªzΕɎ|AËÕ”7µ¤Ÿu‹#š’ÓÊÏj^ÓgûÒM°Óp‚á¾öÅH™–x]Èï?ßEÐÑòÕÐé«?|» º¾]žeŠ`^öú%. kYºÔ÷}h¹îκ×ÊFY’m¦TóÁ·t°|×:ÔtBî%W¶$©‹““Û–gʤ›XyµË˜g¢_ðíÂwñaÖT8`º_ùô¶ÆF–Âì«÷›wºt`7^AÐÞòÅc›é¤ØrÃx³MEskÊöÌwÛ“¬¹|–M¶ÀÐŒwöâôpV‡N`•yaÃI‡‰øÍ…]:°/ è`¹7m¦‹šgzØ—grtÔ–øeá´ÛïU&Í*%…´$Ò¸‹¾Ërè\ú+"è ÕÖ£Ít ,€7ˆycM79›†­ºÛB:o‡û$2VÛû/EÅù”L ·1’åêé/&È­§™~NÀ ±ÈÜmßëþƒìÞ$Þý•vGú‹ Ã_O3 àëðÒzì„2×¥y|¥ó’«tf€p«Í3×þð,âs—|µÖøÛïžCžTع¾<Â8ëF õàwÀ9·_Æ*êi™ë¾§ÀþðŸEO—pø¸ƒ5¿úÖ7]àÿ~+îñ–¥Ú3з¦xÓÏQÆZ±ó°•bwuÁZu–]Ö¹…7Êš›¾!§ô±;žCP†qTóFéñ±¶°ìG ج­íÄ ¡u;QlvÑÿÓO„aŠr»Ä¯?D¿77Š¶ŸÓJ…8uºÆCº¦n-ÉäAd+ANXì'òe¥t´µ… #ñGÓã¶fÁbÒMµ§.>xÑ‹&P9q~Ö‰/JŽ$|i1hz™|Ûu:YI¨°ûå«·ÕQ§J¢„Ñ’t߇èo!ˆ×ó˜bSÙ™bê®ôi‚œFÆu”GŽŠœk¶Üè!—) ê‰ÔƒF³§ŸHŽ|Ñë~Ô›—Z¥$Êéé_Ö€'RÒj袛ՔQÕVýƒªÔë㧴ò79ßóE¦UòÅÇNÅj ÷"Röé|`Ö·Tùgš°è³„U)€€TÉþƆWE4‚Š,»OE%¬»§C'{X’VÙ¶x”ÊÔkPÊÅf9‘4À²PÚ.ÕZƒÒ´5ÀO ©VZ–ÎÑ´ÑŠû©‹ÎÚ¸$ìØj¼Z?-ž²´I{Ó³'Ö&:4vš þ´À+sïb{½¡ g»»]·¶!ZU8AK¿Ð2mek©‹r?†Ô‹ÀkÐ;À=ÄÓbó ÕþM£&ª¥¡Q7IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1Exception.png0000644000175000017500000000132012552201365020506 0ustar jorismjorism‰PNG  IHDRoˆÞZEhPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2_IDATxíѲ« EW^ÜÿÿÇW‹– ´Z›áœ{&ì"1°BŒí+ff…IÒ0%O’âô{x«ÿƒtæÐÓè`ž$½U—gK¦åËmR<ÛA–É6ÌQ«ë1s>IjÔã™TÍOdªæ“¼9Ÿ¤Æ^ðšíª·¤ßû}*’{YÏ#oùìyÅ÷-o·tß?µR‡cÞâ™TmWϵ_.<¿ëùìÏmõInݼù>©§$]×'ïhò$)LÉ“¤8ýÏÌlœîh¨Á¼i Ì›qC£y¾?“¨äÄ)yqJ@œ’§äÄ)yqJ@Gff…IÒ0%O’âôüuò.‡ùÞ)ÞâIÒMUž-‰—/·çr½Ì§ÚBÊdE?ÖÔø2s1Îáy&U{^m—­wMêÉôéÕe~mqìxõát6ðƒIÞúá’©Õ±žwxËÇ—sÛG2µÚ÷ËI¯Ïwl¦sžIÕ<ÿ%kí›z>ûÓoÕt†¿]–tû³®­×ÿïïÙúç&Iï•ÿ’§äIRœfž™Ù8ÜÑ0PƒyÓ48˜7ã†Góþ|& PɈSòâ”<€8% NɈSòâ”<€ŽÌÌ ¦äÄé—ðªóyµ¶À+Íwϲ?å½s] 9­/I9M=Ÿ–ƒ”³nAË°½]Þ4Öá=V– ¼¹¢Õ».¾½Õ­nŸçs|~þØ;l'ÀÛ^Ù~_ϯ}ËsCÃkª{8æ=^›s¯_.<¿«<ߟ«ÕÜÏ{¿?}ð™®ï‘<€8% N?À33§á_§VŸIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1CBP.png0000644000175000017500000000152412552201364017161 0ustar jorismjorism‰PNG  IHDR«ˆ¯ë³PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2ãIDATxíé’ƒ ›ª¼ÿ#¯QÄÁ#‡N6¡j¶èÀb‹Ãø—œsî²$uA¸J’?á*Iþ\uMÛÖÒ¥4¶§Ó-I'ðs=ÔOSýe×aÛîiÜ>»¯CÿýwÞÖêZ.¤\quŠ„”l©­:lF$é ]çmšÅL{ßõ‹û:ÇÀ#×iø7\­ØÖµ&¯»¶ñú‚ë·âÕæ±eËžëó€$½M/®_ŒWIzòu¤ü{ HÒIÂU’ü WIògpÍ9ç>ðçÐ ¹ÞnýÈvä:¨v#Û“kä€O®þ„+€?á àO¸ø®þ„+€?á àO¸ø®þ„+€?á àO¸’sÎ@–¤.WIò'\%ÉŸÆ5m[éþ×tn%5e¼f3´íØ™t0õ¡kÛ5‹-ÿض$5¼ÖûöÆuxÈûœéa—}µëëönU6n¬–ŸéjûëÈÐ4•¤¦T×q~¹»”L‘”Ž)×MÒ­ë2Ã,VϺš9Ë‚u‘e¢uÇíJ¯¸ÖûïÇx»jCó›ÇZ=˾ëtŸ=×b°jï¼³æ`>r5­eêƵڮ]MÕºÚƺ½Þ×m â´œIEND®B`‚libDAI-0.3.2/doc/html/form_138.png0000644000175000017500000000473312552200252015747 0ustar jorismjorism‰PNG  IHDRã@Vïþ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï JIDATxíéšê8¯…_O™ øþïöHvBœ HíÚÝôùœÇ‹‚’¥H^Òò_€ € €3¸Æ\i—¯®¨øZø¾¸óüfí à{¼o’ »Ê±iJ÷Ê1Àw!ømIëeŽ›ÁUŽ¾©’ÔëÓýhŽGé”ä®7yåàË0®˜Äˇ.Ô9ø^Èì¶Iaè-ÀçpÅ}l»áj‹TTTTTTü¯ éº®\à \×uå¨ø´1¶Íü ®À61ÆìÞÅxk*¾÷x+§2^dÂÜîz‡TüM™ÂòçZl=À!BÑ•c€¡óCwN À>F[’¼ºl[€C˜þ%Çm†ç€ €_×9||Œþ|üJV+ÌãÄq/]f®¥PðõÞ¼Ä#{„ó1.àˆãDïÅ4*Þ ÞExWz+O³ýP,¹’—ÛuÖ/“8¨ˆÛàmØÙåÑ7plb'¯|ýV€ €«1ÆÝô …¡›€-š7|´ž›É¢Ð0vÍ$»&m›¸í&±>šãNÒpÓ÷i{eàwà‡ÃëÕLÀCb½Š”Yù3*[^£j‡tØLî+Ž1aïQ¶ôYÞ‰ @À;ˆÀÊØ^?͸™o7F¹n'ÊÒ#¿{ ,P!~ɱ6…•"öYæU¹ëõ ðçHCs4ÇM?=;´P,¡Ïè*5ÆËŒ;‚ÜºË g.ÑuαW‹—¦Ï9ýC~Tü>Êå×Íayœ"l”š›M´ÜT¨C“;YGÒ_ÁÞçVºOr±ç¸—»\7ëì+³!uKž~€ €ÂÑö½Ð ”+)8À1TUbßh£™WÛØ4…:Ì:“iz3ÇóK÷slº^G]g?·Þì•c€æ±ïŠéY$ÜÜt–•këÓŒ&©>ºgw×äN§y¨ü+WÚ.£WèÂòK[ùjE‚ Cº“_sìäŽh5ú2üÿ$n«ËZǵdi5{I´'zý?ç8 @O—îp¿j%€ €Ã<^ƹ0±T„—ã²ôâøͨncñ à[`Œ)À5<ý~     (–_¾†p…¿  à‹`Žc€kXúÂuô à{°bî0€+pËè÷ƒ&¨øKhOS~.sÌ›q®|̸Läí+Ó?=£­|¼ÌqŸž¡{aà´->pmCè*¾¡[.ä¶ àîË}l†ÐTü¿AóƒÉ¨øo`è–1¨¨¨¨¨¨¨¨¨¨¨¨øOÁÀSx€c¼ñ8Æϳøe¼((—y‘7À¿‹à ý«cm_Õ5yº>t] ð>É&t~èÿÜpîBâM>Œkõþr¾G ÀLqæ[FKÀÙjnÊ[8‚Ù¶Ð'ÙøN>[œ[Òc^`ײš<ÀGH›ßÔ ”ëM¾¿‚;À9†……(×ðúÌ’g¯œ·µÛRúI6ýÐÓXáÜ’žîÖo ÆXY™}S/P®7ùü!L&7Þ;•·]X(Ž xÙ<~à9D±mÁq‘| Í¡SŠïÒ\‡æsËUŽ½MMlƒ·á“Áti„_× ”ëM¾ŸÀvÓ³ºvÀ«üYO ösæ‹ /v'8™wž6ÆøBÒ Ž—l‚uÑÆÃcM1ƒÄ<•sËEŽ[ÏÍä1k»æ#=Mçñº^ \oòøfzVp1XK§§,½Si¢ÚÀ^G*òı“ç&Èërß–žFÓ¯gýÓ¬åÔrb®éä#¥¶ÊÆ%‰˜³ ­ÝÄôƒ¼ô ÙÉ¢÷¡ZÌ+/¼|`.0ÛÇ^¿(iªWú?¯ÕȪ¾f*(7BªWwk½.ÈMfŸZ(¦:w•å*êøú§S•d²ðÊË$íbI-•›OÕ4òÜùšGl2Ç¥§ìô©ãÏ”ø½™Í9°Í­k%\7ÈGn¿2›.æ”MgL4Û˜òŸ}²³¥—biZÍ}JÙO,Â+Lö|ÔnŒ4uïüG„KÎ(—iåusARú\¯î–—»Ns™ÌI£¦Ï\禠\eÝçðýôl÷M#LZMßiÇÊ&½z„µNþ¤lŽ´úf ò#iÓâi’=5óÓ3}eS6—×Z½Îæá´þ)±Œ²í3½FÎ}ŸìltƒæÜ—·}¬ÕB‘BFÙoŒ—7H>ÂC.¿:IÝ3½B<æze·Ö;ˆ$ͧ°Á¦#±‹.*ëøt å%VBI/Iïåîë%gIV-Íi»4þóôX%¥³ðôigâøé)²%’ó4Oå:ßr\dã6Z¹ççl¦ sL/ãN'ç¼Kvk™8Îr³æ8ßöéÓé$î›XÓ½©P‡þ¦ÎÚÐß̽l•Ì±~XyÛ\¯ìÖbL÷Ö6ßflMÅÕ ¯éçt.Â5ÉS9–|’HiëÈˤµôØRÉ·%¿çؠ׌vié™õ'q<{Z²€Læ)ðrÖOŽËlo’BMÙH8}ÛÓÑöé»dg‹Ž\rÌ/*¸¼7+rù¹Úi|J H ÛØÔ¼Ú|ÎÜ­¶¸KÒ¨ÿO/JÛ°«W&ZNôc[I’‰“b«Ë³îý] ð9òÙæj;Ÿò‘FUþô„L![µ·éÖ|zs¼õœÍSài:uÓ¶úƒlhÑ©>Š¹Iv¦ÊMŽ[­Þ]§@¹vW_ô®—GªÏè×õ§‚½H»µ^‘í“¥^€æJDÄ‚|}>KÝ„%×z‚¤æz/z“¢/4lÐ>E=•Û=”é­çl.aŸÍðxhãÅÜ$;§ÕØlF=±?8$§‘s3öÒ|¢ܲvX®/ZÑ×üŠPtˆîÖzÍ Âý.ƒ¹A莋ºþ k±Æl¥íÝëÖ_{>é9ö|šØâR6+3°¬s À§p« L·À© íÃz÷’,ëÒ8Âœ‘½|Ï›iÌN¾æºœóËÀ=¾5Ž×/¨‹{ P}Ü¿ÑIEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1fo__plog0p.html0000644000175000017500000001155112552201365021202 0ustar jorismjorism libDAI: dai::fo_plog0p< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_plog0p< T > Struct Template Reference

Function object that returns p*log0(p) More...

#include <dai/prob.h>

Inherits unary_function< T, T >.

Public Member Functions

T operator() (const T &p) const
 Returns p * log0(p) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_121.png0000644000175000017500000000134312552200246015734 0ustar jorismjorism‰PNG  IHDRr#Ñ®0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïRIDATxíË’œ0 Eß6´ñÿÿmä ,šn ©©Êb\¾ ²dIWw ð€oÀ£Ö:n ð¶Ö:îÀ ”ÖÌsÙ8·+öK{ü±q±¶pK›†'³€Ï0­…áÑW€ØÙ›p/©¸¨íN1µà̘̋öc.hª'ˆ^]¬µ p‚¢º¶µ»ÙT.ì}ò·ryTŽT"µõÿio qOí’¹íU(Ý$LãWÇ©|­'…v.æ¦4ûdY‹`hgét•šIŠ+VÖ‘S¾;Ó55uÒ¾Ÿ:é' Cßr¥š5}åžëØå¢ç\ìíèÉ1¦íÃ.±¶Ãî'ZC”|®¿ÖóÎÚeÝÕÝTï‚ ÒÇË–JíÒÒ9©¢“·‡ô‰¥•!áÓ+Gœ„ô”Ô­oµËáÃ3Îþ¦Gx<ÿTY’fÜÆýìÂò¦ïgõ~³ÉÞ­¥x‡ ¢²ãŒ};'eÜœÄ÷6£úi†œáw{mßN°äV/®½œr~´Kzš_m„ªµÝÕË©µ6î—®ØA¼Œë¶¨üà[à:÷®Á‡[¿¼ Ä4]?Åã >§+½ ác\/h„Þ¾¤rax3Æè¹pNHÝGw'ÙÜÅ#ùóËÆPæÕ¹'„e'cðh™ð]iú¨W²+!f##XÖ„ã&/“èÍ*϶PLã|”tÑí÷m°¢A¾»¸ ï­õ˜œ{]¬wƒ¦!D—W!™±S.á¯Úh3€OXÕ"–’$?æŠvü ÞH(Àÿˆ_Sâ-EìMIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1MF-members.html0000644000175000017500000003510712552201367020676 0ustar jorismjorism libDAI: Member List
dai::MF Member List

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

_beliefsdai::MFprivate
_itersdai::MFprivate
_maxdiffdai::MFprivate
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const Var &v) const dai::MFinlinevirtual
belief(const VarSet &vs) const dai::MFvirtual
beliefF(size_t I) const dai::InfAlginlinevirtual
beliefs() const dai::MFvirtual
beliefV(size_t i) const dai::MFvirtual
calcNewBelief(size_t i)dai::MFprivate
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clone() const dai::MFinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::MFinlinevirtual
construct()dai::MFprivate
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findMaximum() const dai::InfAlginlinevirtual
getProperties() const dai::MFvirtual
identify() const dai::InfAlginlinevirtual
init()dai::MFvirtual
init(const VarSet &ns)dai::MFvirtual
Iterations() const dai::MFinlinevirtual
logZ() const dai::MFvirtual
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::MFinlinevirtual
MF()dai::MFinline
MF(const FactorGraph &fg, const PropertySet &opts)dai::MFinline
name() const dai::MFinlinevirtual
printProperties() const dai::MFvirtual
props (defined in dai::MF)dai::MF
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()dai::MFvirtual
setMaxIter(size_t maxiter)dai::MFinlinevirtual
setProperties(const PropertySet &opts)dai::MFvirtual
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_s.html0000644000175000017500000003014112552201370020130 0ustar jorismjorism libDAI: Class Members - Functions
 

- s -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_91.png0000644000175000017500000000160712552200240015657 0ustar jorismjorism‰PNG  IHDR×ÿ†»€0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïöIDATxí]YϤ0 sï–«ÿÿ߮Ӌk†]¤}ØOZD`AbÇNû ÿ~r˜8 'b€/aà}(8Åc¢½âas€çÐ1Í |‰ ”Ñpÿ’˜ Ò%ëà‰L.´<„É5ýþMöÈ$¾ðÖð‡±Ù™W §ó)Ñ+^Ø&Øï~eÈ+ó!À=ìoõ>šNoÅÙŸª w´û;^.»‡1œ.¼V7ÀÕ²¦:§ èXÅóHÇì€uX䣥ƒ?¹»%9µ•Šl@kæ;^È;\"uΉùx[{N#çWOÖ”e­øs¥­‚ZÃTòŽŸ‡`v™äµ*šZ¢gb®•]KDÚªRmèÞñÒëo5Á±/ÖËQz®ä¯§½LØYétðRóe F¾µŠÜz }ç%œÜy_ñÒAµ&Ÿlžú±µBÂK|Ør“µ Bf´ù4B"ÓÈ´û¢4Ò´ÇÖÕÞÜžHº8 <óšJ†ÔEÑöóZº]²>^ñõm«Í×Ö=!wJ-¯ôÚ÷šÔ&kèåF÷ª½Te.  F0œôÚ ëxÁ×IüÂK¥X–s7’Yj#J—ñ´`ÒE»‹?8i*TyÑ3欑Ä_ ÖZ˜u­ÕG¾}3µ§ðš]ärÌcÛïü`¼íëE[rŽ¼¬³Þ8Ç/»WC¿k³8Û$™&™c2Zô­ï£5„¥¨(ù‚ú 7KO{«ÎP &JÍ£‰ö7Vœ2oÞÛPöb9©Õ‰†î² xi“µÞ½<Ê>Øf‚ãÁFmL{Ÿµk»ña¯ú¸À=¬aû®[•ø ôk$ÊÚ¬çÎœô¢Ñ\-âÄÑ•EÌ©Õ(w€Ùë•Ó}Ûï6Ú;ÿ‰5<ź i¯å¼u^÷åóVÆ®yc×ë-zÐ(«¶} ðÍʨÀ‹Xž P>†Ú¥½öljø"OÏ\!Yz\S:{YAàçÅ€?~ø~Ê3‚lHIEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1BBP_1_1Properties-members.html0000644000175000017500000001222512552201364023724 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1CobwebGraph.png0000644000175000017500000000104512552201364020736 0ustar jorismjorism‰PNG  IHDRtPÿy¡5PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2´IDATxíán… F%ñýy*Whñf ¸dÝõ›®ýàèu‰1ÆÕ"Šˆ¬•CED¦éo@CûÎ1Wè˜úÖtêDÏ¿¿³Zè^êaH%—•ªµä[ùuҸ˞3û£ºõ¡§9A‚ˆ¾2¼NŠ4Ç¢<ŸÉ·Ð+©múHK\C3\ï©ïš ÝíBÕS±~ U7µñ!´i­ê»ƒVgš³5Ôú»7õ`s¸ª3u÷ªlÞÞÔÔv'V¼‘n^™&‡ŠˆLÓ[Ðc\,€_jX­7 Ûöõ èÎ\O}úº×¡óäP€ir(À49`š 0M˜&‡L“CB«EX+‡LÓûÐò¨ƒG·õvš®»k¹…V±n5½+÷#ôóíI•–ÊõŠ“¿]–ãQ…Mqm.ïA†žž2•º ={ Ô„M‰Õ© šßVIÐW}3kn,]hê„ï¡ÅŸ‡åé›Ü ÔŒAÓ§3FchS²îG{@ÍÄ:ÜÏõ º{¯5¨=ªZÑl¡nÍë_HÎ]Æš7R p(À49`šÞ‚†ÂbýP ®å¢þIEND®B`‚libDAI-0.3.2/doc/html/arrowdown.png0000644000175000017500000000036612552201363016435 0ustar jorismjorism‰PNG  IHDRɪ|½IDATxíÝ!NAÅñ¤‡à\ ÷à Um@`Ô5iÒ`ëh ‚ÅW7] b§ÝˆŠ&oföÍd¾YÔ4 üšcø ‡€´‹Åòù3v=¼]†§µ\B… I¿‹=B·™B¡®;¸k´µ W°ÍN@vyÍÑÖ4ãß÷]ÈâYìã§|M}]ÔÚx6a }ôdׇØYüú¨>¤||5?Ó>|žB"¡î'¡IEND®B`‚libDAI-0.3.2/doc/html/dir_d44c64559bbebec7f509842c48db8b23.html0000644000175000017500000000477312552201370022110 0ustar jorismjorism libDAI: include Directory Reference
include Directory Reference

Directories

directory  dai
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BP__dual_1_1__edges__t-members.html0000644000175000017500000000532712552201364024706 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1SmallSet-members.html0000644000175000017500000003724112552201370022113 0ustar jorismjorism 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 &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 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
toString() const dai::SmallSet< T >inline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_128.png0000644000175000017500000000267012552200250015742 0ustar jorismjorism‰PNG  IHDR$O/$s0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï'IDATxíëvÂ8 „?_‡@ÞÿmW’ ¹à´[öls˜&P[‘Æ£Ñ_€?üà¿Š°†ëû~ùñoã{£üBŽv/k¸|ž¦\¯iºdpÙµ»ð½hÿ&bÉzóÀnšZÖ·€ìÓñn4€¯QÏs¾À!ü&…X¿÷FGoB¹ t\@—ïtõˆŽ'¢-ÓËû©LË ¶}v¶n,Z¨]°úË©Ò!5ÅbWIÐed99|ÐK7 a j°á.m¥ê¼ÐÜý‚òˆÇ06kØ[SI®)úÓKÔc*²Ý›+|cSê°WÚ|Æ» üŽÖN¸ís«2[$MÊèÐý¸D–ã~¥‘…ð=®X¾ìL©—éèÞ¸Øâ’ãÍ0lAŒ!ê‘^ÿu‘^IÍ×ô—ñZ]²†J‰4׫¥§AdcFês”}ã*ÑýRð%F}—åµ¢#åô ØC:B– ƒK:v¢ôŠ‹{§(û“IP¯¥û(? r¦N®YŸ9úñÄé&7é£í²’éG¯ú¶Ÿ´?m³Î.+ííй)Ò‹H/í·Ô?7(Žèp¹HF“pÒsµû€ÕG­ãœEðC (_Úê-ýnI‡>Îl´EýYNÐV„Ö=hAÇŠ×ya=K8ÂB°(B¢öš¶€I 8 Œ¹µ¦ª)5:T¸q™¸-2 Ε$p»ÝèØÅ~E©ÓÐènÑÆ{„¾æRM’úªû„Ôm´Ñv‰ÝE­Ûj·fQsµ®¬,ÔÑI»ÜdmõZíæ˜^#hö•Äwéhg8tJe²JùñÔ?¤Ãd']0Y’w¡¯f)Æ¥-PkW:&'©¶ÑѤ"^˜zN:÷êè0Û´Ú³,ìK¾Ø4o$®§Àû´3<;Ý?›Í›Ñ–´Ê.œ4ÉEh·`´WÕÚµíå{¶%Uõ·A:ý^Wk<3 «Ý ñ.oÞÔH”) ðv P‚„?¿ ÍÒÓw§a“ú+tèHÒqÕd0‡tŽ¤Íн؛ü<L³Êêžÿr 6u隥Ú-;ì•'º]õíûzÉLðvZ;8ŽÌ jäAœÓ_{à&eN4>¿0™Fü~»ž­iBRÎ¥øÙ­[ ­{8.@õmãÞ¹hoØáÛtäeè^VlQYyüàÛT½|…có›æ£¨3üAίÒ†ëì4X™OœÀ!L:ÞUÓ´o rrÀüq_ä|mµzÓtî«6øiøó$×9Î_"ŸúÑÑ€ùsjþð;¨}»|xß àøeÌr¶9—ã«Ý°kè«7ºß5I€#8n¡ï5ÓnºÎQ€§ûÅ0(2c_ÇróÛQG}V‹ì À§cHÕòºÒÝ >€# Ùê-zK£ü­lÐY¬`¬8¥º>|(ÒÉzz6?%g-éUJ&!óÔ‚tþ"šòL •ƒtúÐá˨·f‰žÒéÁŽ¯Ù‡üÍq:NIUã0:¢q` rg€O†$Xœ\*­Léx1i=ø~(E›Å%üÅzEå?šÖTAòª7'Îç«„ãEµHîNu ð Ü Ö#›FöÄ‹Ùä¢Õ›:Ì:DwŸ —tx9Y)ç:SsB€Cø’k3a”›7•Ø÷,ìªaøbãåý#ëA¬P+x±È\ZL›J·°½ààã' À „fzSÅTr̨þgð+]»àYü8"æfKýˆIEND®B`‚libDAI-0.3.2/doc/html/functions_i.html0000644000175000017500000003157012552201370017112 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- i -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/dir_68267d1309a1af8e8297ef4c3efbcdba.html0000644000175000017500000002577412552201370022252 0ustar jorismjorism libDAI: src Directory Reference
src Directory Reference

Directories

directory  matlab
 

Files

file  alldai.cpp
 
file  bbp.cpp
 
file  bipgraph.cpp
 
file  bp.cpp
 
file  bp_dual.cpp
 
file  cbp.cpp
 
file  clustergraph.cpp
 
file  cobwebgraph.cpp
 
file  createfg.cpp
 
file  dag.cpp
 
file  daialg.cpp
 
file  decmap.cpp
 
file  emalg.cpp
 
file  evidence.cpp
 
file  exactinf.cpp
 
file  exceptions.cpp
 
file  factor.cpp
 
file  factorgraph.cpp
 
file  fbp.cpp
 
file  gibbs.cpp
 
file  glc.cpp
 
file  graph.cpp
 
file  hak.cpp
 
file  io.cpp
 
file  jtree.cpp
 
file  lc.cpp
 
file  mf.cpp
 
file  mr.cpp
 
file  properties.cpp
 
file  regiongraph.cpp
 
file  treeep.cpp
 
file  trwbp.cpp
 
file  util.cpp
 
file  varset.cpp
 
file  weightedgraph.cpp
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/sync_off.png0000644000175000017500000000152512552201363016217 0ustar jorismjorism‰PNG  IHDRàw=øIDATxíÝKhTWÀñÿä1I&3™8M¦Iš™†I3Ú©b$cÌ I1V1±-(Tö±±Ð.* t!‚K[¥Ä¥ˆ„¨´f£`l(øl©"Y”¤6ÆgÌTú}·sgîܹ ±d{8?æ̹÷;çÜuíÚ`:!±F¬¢BäŠ?Å°Äm'yÊÅ>ÑlU¯½üý‰è_‹?€Œê ]€Y(ŠNñ±8fý1°Öqún-eâ¨øtºmâÈ Ó0}b›ù%·©µ×Œ®=Ÿ0´³?Š1sŸ‹0€¯8À‘;_ ‹W|%\ Zð— >舽ln¨p©.aÇ{ )t;Ú b nŸš¯›65°¢¡2çÅÔ?Žž>Oдàuönm¤¢Ì`×­Z¬WjC~>‘Ö¾0+á {{©fÝ×Mæ·æÅ•ìÙ¼˜` Ý›%uA6´½ÅÆö¨Á,]k¢ÄW¼™u±›]‹ˆ7§¯iòh€ ¶¶¬ÏÖu1 ló —Ҷ̺–:ÞÍ\ÄcãÏxøhR²Êè‡Qt$¿ß§¨ ª fdºü<4BÿÙ[•f¸d7=.Mé9/—éªÃëù/ÿO Üaàò}€,‘j?Ÿõ.5Úšm?œÿŸ®ŽXÿ2¬#¸d píæ(£?cÛú¼!½›a1¥Þ—ŽòØ©ܾ7dÔK:‚ùÒ‰ì)Ê3‚Ü™àÌà]€,±H€µ+køöäu<|`·LhC7¹ÔeÍ Ÿ×Ÿ˜tÜ‹ óH$^2%l.êaeÐäýE”ÌÉ|ÅÜìî‰Ýsä }¸ýDû^hzé~ðR›¦Ã¡¿]|#ü¯@×—Ö‡[k¹–<|š(Ç*€Ý¹dÇtMé:Ýñø«Ø,êÅû¢]”' øXÓ_nò¡Æ|Øý /c§fžâOIEND®B`‚libDAI-0.3.2/doc/html/bp__dual_8h_source.html0000644000175000017500000012624112552201363020320 0ustar jorismjorism libDAI: include/dai/bp_dual.h Source File
bp_dual.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
13 
14 
15 #ifndef __defined_libdai_bp_dual_h
16 #define __defined_libdai_bp_dual_h
17 
18 
19 #include <dai/dai_config.h>
20 #ifdef DAI_WITH_CBP
21 
22 
23 #include <dai/daialg.h>
24 #include <dai/factorgraph.h>
25 #include <dai/enum.h>
26 
27 
28 namespace dai {
29 
30 
32 
39 class BP_dual {
40  protected:
42  template<class T>
43  struct _edges_t : public std::vector<std::vector<T> > {};
44 
46  struct messages {
48  _edges_t<Prob> n;
50  _edges_t<Real> Zn;
52  _edges_t<Prob> m;
54  _edges_t<Real> Zm;
55  };
57  messages _msgs;
58 
60  struct beliefs {
62  std::vector<Prob> b1;
64  std::vector<Real> Zb1;
66  std::vector<Prob> b2;
68  std::vector<Real> Zb2;
69  };
71  beliefs _beliefs;
72 
74  const InfAlg *_ia;
75 
77  void init();
79  void regenerateMessages();
81  void regenerateBeliefs();
82 
84  void calcMessages();
86  void calcNewM(size_t i, size_t _I);
88  void calcNewN(size_t i, size_t _I);
89 
91  void calcBeliefs();
93  void calcBeliefV(size_t i);
95  void calcBeliefF(size_t I);
96 
97  public:
99 
102  BP_dual( const InfAlg *ia ) : _ia(ia) { init(); }
103 
105  const FactorGraph& fg() const { return _ia->fg(); }
106 
108  Prob & msgM( size_t i, size_t _I ) { return _msgs.m[i][_I]; }
110  const Prob & msgM( size_t i, size_t _I ) const { return _msgs.m[i][_I]; }
112  Prob & msgN( size_t i, size_t _I ) { return _msgs.n[i][_I]; }
114  const Prob & msgN( size_t i, size_t _I ) const { return _msgs.n[i][_I]; }
116  Real & zM( size_t i, size_t _I ) { return _msgs.Zm[i][_I]; }
118  const Real & zM( size_t i, size_t _I ) const { return _msgs.Zm[i][_I]; }
120  Real & zN( size_t i, size_t _I ) { return _msgs.Zn[i][_I]; }
122  const Real & zN( size_t i, size_t _I ) const { return _msgs.Zn[i][_I]; }
123 
125  Factor beliefV( size_t i ) const { return Factor( _ia->fg().var(i), _beliefs.b1[i] ); }
127  Factor beliefF( size_t I ) const { return Factor( _ia->fg().factor(I).vars(), _beliefs.b2[I] ); }
128 
130  Real beliefVZ( size_t i ) const { return _beliefs.Zb1[i]; }
132  Real beliefFZ( size_t I ) const { return _beliefs.Zb2[I]; }
133 };
134 
135 
136 } // end of namespace dai
137 
138 
139 #endif
140 
141 
142 #endif
dai::BP_dual::messages::n
_edges_t< Prob > n
Unnormalized variable->factor messages.
Definition: bp_dual.h:48
dai::BP_dual::messages::m
_edges_t< Prob > m
Unnormalized Factor->variable messages.
Definition: bp_dual.h:52
dai::Factor
TFactor< Real > Factor
Represents a factor with values of type dai::Real.
Definition: factor.h:640
dai::BP_dual::beliefs::b2
std::vector< Prob > b2
Unnormalized factor beliefs.
Definition: bp_dual.h:66
dai::BP_dual::messages::Zn
_edges_t< Real > Zn
Normalizers of variable->factor messages.
Definition: bp_dual.h:50
dai::TFactor::vars
const VarSet & vars() const
Returns constant reference to variable set (i.e., the variables on which the factor depends) ...
Definition: factor.h:139
dai::BP_dual::msgN
const Prob & msgN(size_t i, size_t _I) const
Returns constant reference to variable -> factor message (i -> I)
Definition: bp_dual.h:114
dai::BP_dual::beliefF
Factor beliefF(size_t I) const
Returns belief of factor I.
Definition: bp_dual.h:127
dai::BP_dual::messages
Groups together the data structures for storing the two types of messages and their normalizers...
Definition: bp_dual.h:46
dai::BP_dual::zM
const Real & zM(size_t i, size_t _I) const
Returns constant reference to normalizer for factor->variable message (I -> i)
Definition: bp_dual.h:118
dai::BP_dual::beliefV
Factor beliefV(size_t i) const
Returns belief of variable i.
Definition: bp_dual.h:125
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::BP_dual::msgM
Prob & msgM(size_t i, size_t _I)
Returns reference to factor->variable message (I -> i)
Definition: bp_dual.h:108
dai::BP_dual::beliefs::Zb2
std::vector< Real > Zb2
Normalizers of factor beliefs.
Definition: bp_dual.h:68
dai::BP_dual::messages::Zm
_edges_t< Real > Zm
Normalizers of factor->variable messages.
Definition: bp_dual.h:54
dai::BP_dual::beliefs::b1
std::vector< Prob > b1
Unnormalized variable beliefs.
Definition: bp_dual.h:62
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::BP_dual::calcMessages
void calcMessages()
Calculate all messages from InfAlg beliefs.
Definition: bp_dual.cpp:68
dai::FactorGraph::var
const Var & var(size_t i) const
Returns constant reference the i 'th variable.
Definition: factorgraph.h:103
dai::BP_dual
Calculates both types of BP messages and their normalizers from an InfAlg.
Definition: bp_dual.h:39
dai::BP_dual::msgN
Prob & msgN(size_t i, size_t _I)
Returns reference to variable -> factor message (i -> I)
Definition: bp_dual.h:112
dai::BP_dual::calcNewM
void calcNewM(size_t i, size_t _I)
Update factor->variable message (i -> I)
Definition: bp_dual.cpp:86
dai::FactorGraph::factor
const Factor & factor(size_t I) const
Returns constant reference to I 'th factor.
Definition: factorgraph.h:112
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::BP_dual::beliefFZ
Real beliefFZ(size_t I) const
Returns normalizer for belief of factor I.
Definition: bp_dual.h:132
dai::BP_dual::BP_dual
BP_dual(const InfAlg *ia)
Construct BP_dual object from (converged) InfAlg object's beliefs and factors.
Definition: bp_dual.h:102
dai::BP_dual::msgM
const Prob & msgM(size_t i, size_t _I) const
Returns constant reference to factor->variable message (I -> i)
Definition: bp_dual.h:110
dai::BP_dual::_msgs
messages _msgs
Stores all messages.
Definition: bp_dual.h:57
dai::BP_dual::regenerateMessages
void regenerateMessages()
Allocates space for _msgs.
Definition: bp_dual.cpp:36
dai::BP_dual::beliefs
Groups together the data structures for storing the two types of beliefs and their normalizers...
Definition: bp_dual.h:60
dai::BP_dual::regenerateBeliefs
void regenerateBeliefs()
Allocates space for _beliefs.
Definition: bp_dual.cpp:53
dai::BP_dual::beliefVZ
Real beliefVZ(size_t i) const
Returns normalizer for belief of variable i.
Definition: bp_dual.h:130
dai::BP_dual::calcNewN
void calcNewN(size_t i, size_t _I)
Update variable->factor message (I -> i)
Definition: bp_dual.cpp:109
dai::BP_dual::_ia
const InfAlg * _ia
Pointer to the InfAlg object.
Definition: bp_dual.h:74
dai::InfAlg
InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI...
Definition: daialg.h:35
dai::BP_dual::fg
const FactorGraph & fg() const
Returns the underlying FactorGraph.
Definition: bp_dual.h:105
dai::BP_dual::calcBeliefV
void calcBeliefV(size_t i)
Calculate belief of variable i.
Definition: bp_dual.cpp:129
dai::BP_dual::zN
const Real & zN(size_t i, size_t _I) const
Returns constant reference to normalizer for variable -> factor message (i -> I)
Definition: bp_dual.h:122
dai::BP_dual::init
void init()
Does all necessary preprocessing.
Definition: bp_dual.cpp:28
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
dai::BP_dual::beliefs::Zb1
std::vector< Real > Zb1
Normalizers of variable beliefs.
Definition: bp_dual.h:64
dai::BP_dual::calcBeliefF
void calcBeliefF(size_t I)
Calculate belief of factor I.
Definition: bp_dual.cpp:138
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::BP_dual::_beliefs
beliefs _beliefs
Stores all beliefs.
Definition: bp_dual.h:71
dai::BP_dual::zN
Real & zN(size_t i, size_t _I)
Returns reference to normalizer for variable -> factor message (i -> I)
Definition: bp_dual.h:120
dai::BP_dual::_edges_t
Convenience label for storing edge properties.
Definition: bp_dual.h:43
dai::BP_dual::zM
Real & zM(size_t i, size_t _I)
Returns reference to normalizer for factor->variable message (I -> i)
Definition: bp_dual.h:116
dai::InfAlg::fg
virtual FactorGraph & fg()=0
Returns reference to underlying FactorGraph.
dai::BP_dual::calcBeliefs
void calcBeliefs()
Calculate all variable and factor beliefs from messages.
Definition: bp_dual.cpp:121
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_50.png0000644000175000017500000000035112552200226015651 0ustar jorismjorism‰PNG  IHDR —™'n0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïXIDATxíË À0CÍ' Hì¿mCUU/‰Ã³YþÖÔÌíAe¤ iÛÌ@Ä,9™ýÖá@ÏIÅÙbHƒ ŠÊU-£¯žx}¥0[WŸ¹oïgsú³¤IEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1fo__exp-members.html0000644000175000017500000000561512552201365022231 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__Hellinger-members.html0000644000175000017500000000571512552201365023347 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_92.png0000644000175000017500000000034112552200240015652 0ustar jorismjorism‰PNG  IHDR ŠœÖ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïPIDATxíQÀ C[7uQ÷¿íp„?¯ÐBà®GÝ¢æMÿA׶=€Ö ` ¾P/T§að\ ·®(SÜ$3Å¿odì²|MÆaà|Y›ØlIEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1fo__log0-members.html0000644000175000017500000000562512552201365022277 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_69.png0000644000175000017500000000060712552200233015665 0ustar jorismjorism‰PNG  IHDR0gp ƒ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïöIDATxí]rà „?„„1ŽÍýo[IvšIãöµOŒ3H»úãÿxƒüŠºø¶W·ØR3÷ïµ À=,ÕF^Ÿ¬W¶K/¥wuHo¢Kq×›ªAQ­jÕg†kGvdV6ÉŸM79‰2•aˆ2m„ú·LßõÈ,Bd¶SËîc¸¶Kĺ¦n> û8=¢„<Ôýà ž±è!2‚&k"YG ¡m…=±¦…¨Jvq7àIEND®B`‚libDAI-0.3.2/doc/html/form_9.png0000644000175000017500000000376112552200215015603 0ustar jorismjorism‰PNG  IHDR†&÷5Ì0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï`IDATxíéš«¬…_@Pãýßí©PÒî${ïó|±YmD©iÕðà€þ+0@¶Ìéà€ÃNmöÔ[ _ý‡€÷cöÇo×Å2à€·bÉ~%ðÀánöôÛ”Óµ¿ÿ”À»Ñ/ÖyÈ›¦™üíèT7€Þ NúR;ÉXè;و϶£ ¿¤Á.ËrÛ.ù½<3ê_* à¨ë³MÝÝàW ¼DÚj´û6nuIèzûe5„%;hûç }©0€ ª[È9ú…i¦|Àü¢C !Æܧ90ylº=Ó”–EĦÎéP…j²%;ûˆª ˯RðUÀªênË’ìbã²uöõ˜·'ÌXÌ1ænŒe! ´,ÃFöôòq|År}ï›6/ImmGÊh¹EOk\8•a{u¸éûhqoÒî=a„£(šÒ“gC~hËîïNŪê–")r!¦¬Ÿ³P›sÉ®ÎTÂuñmŠ¹H6CÛt*4¶)½ñ<×¢7¶FÌ<ê3¿ºKwâ§ko5Ö’Ý¢ÚYJÝfòU˜ ¯ÃÑ5W MúEEÕ÷§€bÕtcÊ"Ù;üA7@Õ™šQã)æCÆæ:vS«4hÔ–{bÇ2a6Yó4´êÈJ¼Ò°ÕbE˜Úéï/ –jwvÀ±¾?P ¢[,.‹$ne ¼BéêLͨmò ) ÝÐiÜ÷¶i0©ÿXgšèŒ•S·»óR¦l™É˯h0êZFÃAþE˜ðo·¬‰‚3²¶Gû¢Ç^*VßZ›ê¾<…³ºòS*º«EÒ»¤5£ÓUf²u$/sÑñ,2šÁ˜ÑHUÙ%¹¤Û; n½ŽI' “Ï%—H¾OƒmÓnw¤áÌI˜n4q¬É¥Yh:3waË£&þM°'ÏfŠí÷tJ´L}¬Áã@‰‹îDãrªžy4{ã!o횃¬=7jx"w‘w£Žð=”á(Wߦ+3¸/¦O)uŸ]b&ù4Ñp|\ “g‰™ì4 NÃ!..FË3vƒD¹œ"É-ªT¿¿œjÄoÄdÙØ ÄYw½Hä?¨ÎÈl£Ï"ØŒƒ2œ‘ÿ—@:çÜ·ØiSÄ¥Ñ3¯±Ž,Ô+yM˜œ”¤r£¡Òý‹4¨S“ú †_i(…Å&oÄYµ)EopIÞFÃM·! ¾œZçjvJ¦x¼òî~Ò½I13t4iqª®cbJÁI·ƒ†s Cá;$sVºY²Ú¯6yua}0«ñ‘÷íR«Žrù®)iœ¼f˜Ñv~¡¡ cô I>‹ûr$5ÛÕf|ï“]—SJžŒ‡¨çn5œu¯#U³ºlºÊVŒù-UH¿IT4x ³EóCtŒÞ¥QèÕŒfåà _4O7¦–|† u¤•nžhÎ^&–&k&¤š°‰x‹OßÇÔ×6,ïû®_‡ÖéÔèµm¬ë)€κל†U U¶bÌ'ÑÖ Ž ¼­N“3bÔ9¡ š¶ëDó rS † ÉîÏ Aa¶îÉ銳BAÔZœÑ/# ‡„³0Lߊ[‘ÛQGBçz¯÷hOô¸ ÁÓt:šex‡YõžNµmÓé4K)’‘ë¢{ëŠ@¶|§;)æ­æU/óRgNlS«3ѨS W-~ãÄž#T©šF›Ts·|³š½¼î—`ª„]k/þ( nïÏa[·pòi“™=kú‘ /+X‡÷OÅË©/uWûÔs“ËJ£áp¦Èf¸m¼^ƒ›&h‘…£7.&.À6–º*¾NƒÛfÃáéUØZ¥ÑôÌÊ.¦ß9n¡µ6›3—Sqãrê+Ý2ôó¯‡.uì£V|êgÚN<ÚŠ¿6[É÷Ðd)k6ºlî60wø±GFìÙý¯ŽUVqEšñ×½ïOÝ×í‹>eO‰í?y8Sä:Ô·ÒòUNß ˜Íí·bÞ à¨ê¶9 ¦_îÔÀc0Ã2li›gß„.ë{áNŽ|aé×kžçeYÎã àa¼TÀPÕm–qÝ qsxNƒoÆÁ'ŠEÍbu¾7S¯%“uT€GBÈ×qðBùzNÀBÈWÒíCùú]ªÇêâ¬ÑaîÒÔ1+·éöK>xCŒ³Æ|mx>Me[Ô‡€?€Y[OŠ¹þ™ZíLt©þ†l˜üWaåà]ˆ½'Å|2‚®¼ö:mSzx©Ñü£IÃà °©¥˜·yJ£Áü3alœý›…éRÇ~Ané5ó}Hd1ïÒøïŸ+ES0 ð[x3µ ©W€?¾òµÔ<¡tµE©™³®&rð;ø®x 1ßÛ î ŽÐšA#À¿ŽùUéÛ˜ þœ'©G_ ¢{U¹¼ vôÏ!ø ¥ù×rÏ߀b%ƒ˜þZ›xþµVºáU´<ë}½ÚÛ_k“ì#ààX87P|FdAIEND®B`‚libDAI-0.3.2/doc/html/functions_vars_r.html0000644000175000017500000001201412552201370020146 0ustar jorismjorism libDAI: Class Members - Variables
 

- r -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1JTree_1_1Properties-members.html0000644000175000017500000001173012552201366024334 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1RootedTree.html0000644000175000017500000001513712552201370021013 0ustar jorismjorism libDAI: dai::RootedTree Class Reference
Public Member Functions | List of all members
dai::RootedTree Class Reference

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

#include <dai/weightedgraph.h>

Inheritance diagram for dai::RootedTree:

Public Member Functions

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

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_109.png0000644000175000017500000000377312552200244015751 0ustar jorismjorism‰PNG  IHDRB3Õzñ~0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïjIDATxíë’£: „?_06üþo{$‚“ëdN&U›¢gÙd©Õjýø€¯Eø:8ð7z€¯ƒ™þløB„à/àà¾Óɼû;óð ü ðy䯡äÞ|Ý·:aqÃ?‘ü!|)LvŸ…Éà[1ŽŸEÿÍsü7&yN_ û&9€ïEþ¸\6ß‹ÃðIÄï¶Â¿PÀáÛ)ìÞY*^¾*žée—Â4y¯Ã'²Y*r uW(”ﯬ,¥P^q™±Sq7¶U qiÍ¡–Qÿy‰Â•$å¥^»o98¡P¾ÒÖ_Phê‹ú¾Øaɦ¥ðpJ¾ Cïâ´Tä—à ;}à …ýDì»U©]ɧð5×x^»UOyÂʇÑC ¤G½ð>…²?NVCcc§£!« ”ÖU剕\h_Ù¥ÐHÕ¶£ Œ".éq©ÊíìÚo€SL–$1„®±sk²©äSÎ;sað3Vy 3´fý…ÊG(TiœlÄ7ÔƒªÒN¼°ë…‘®;µ¶²5«à{µlWô´æäú^¡a‘ŒTÖÑ‹_ÅXŽº±‘ͼ[´ªv¡ïåÄ4 ò•„ו/õ ;Éwmùà÷¼pI²HX)ˆ½ÄÕƒN9h)¬ÉK†ÀÉå·œÆ]æàûÛÕÎÕ>…Óî šË«Y–µêœU¾L›[µB·o«÷(lW|KÁ’ÿñœé¼C«C·Ÿ´MjФTz{¸O¡›šÉߥPEËÀ%ÌØWžKM.õ%l·½Ü %øå\=Caõ‚†‚JêÆÁùÛvØËølé^)êQš&»CaÙƒWOsË:±§]gn^†à PhbXj?R¬ê¯áàfž…¿O!°]ùB#];Šv|( À³HPØ_4PÍØ®¼ï¯À¸9gõúrw·-Ð\éûœbý¦)ç·÷xíô:«Œ7/Àìº9Àkð²%åÓÜÜÂ…ÇaÚë†ï¼Š¾o^€Ë¯Óðs ¿6¨ÿú|æ½ÿ+·S˜>^Àççà˜Úíð#¤á¸úñ³¬Ú”îóóf7¸†fâB4˜PÓÕõ§¿º} vx*£¼Õ ðCôÂ.¦¤¹Dx÷€MŒK½u¿´9¶M¥uQk6Úᾦg4mù_aNîÝ[pÛìïµÂC§ .¡}êy¤A‹“ýØ®%5[‰õïá·‹Öh`ïäØ5½Ja\Å÷…ª€7A£- 0Ys4wKϪYŒ)Æ ;Vòlý^ë12j§ü< ¯-ªlizµÃEú¾§z$ûŒ»ÍkÁ?†u.“|¤xI/%Qå}™×Iv]B^ RȪ†"’" %súéÀ8i’c,ƒÜK‡½4ÆMúS9ã d:M™áqZÌ{ç¸Xa(Ú)jÔðÝp÷«âµ)¤NjL:²~”ò¼†R‡ò$üxítM™cmSÒŽw¥OAJÙ&³M¡à>Ò[÷±KÅžSïd8ú$÷šÓxßÃÆÆ2;Yå%Ö*C§÷S‰üÿxB®ÿð¿…ÿe„3.AùÈIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1multifor.html0000644000175000017500000004617212552201367020611 0ustar jorismjorism libDAI: dai::multifor Class Reference
Public Member Functions | Private Attributes | List of all members
dai::multifor Class Reference

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

#include <dai/index.h>

Public Member Functions

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

Private Attributes

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

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.

Examples:
example_permute.cpp.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__divides0.html0000644000175000017500000001247112552201365021512 0ustar jorismjorism libDAI: dai::fo_divides0< T > Struct Template Reference
Public Member Functions | List of all members
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>

Inherits binary_function< T, T, T >.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (y == 0 ? 0 : (x / y)) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_b.html0000644000175000017500000002566212552201370017110 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- b -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/util_8h_source.html0000644000175000017500000012735012552201363017532 0ustar jorismjorism libDAI: include/dai/util.h Source File
util.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_util_h
14 #define __defined_libdai_util_h
15 
16 
17 #include <string>
18 #include <vector>
19 #include <set>
20 #include <map>
21 #include <iostream>
22 #include <boost/foreach.hpp>
23 #include <boost/functional/hash.hpp>
24 #include <boost/lexical_cast.hpp>
25 #include <algorithm>
26 #include <cerrno>
27 
28 #if defined(WINDOWS)
29 #include <cstdint> // only defined in C++11 and higher, but needed for Win64 builds in order to enable conditional code in MPIR library
30 #endif
31 #include <gmpxx.h>
32 
33 #include <dai/exceptions.h>
34 
35 
36 #if defined(WINDOWS)
37  #include <boost/tr1/unordered_map.hpp> // only present in boost 1.37 and higher
38 #elif defined(CYGWIN)
39  #include <boost/tr1/unordered_map.hpp> // only present in boost 1.37 and higher
40 #elif defined(MACOSX)
41  #include <boost/tr1/unordered_map.hpp> // only present in boost 1.37 and higher
42 #else
43  #include <tr1/unordered_map> // only present in modern GCC distributions
44 #endif
45 
46 
48 #define bforeach BOOST_FOREACH
49 
50 #ifdef DAI_DEBUG
51 
57 #define DAI_PV(x) do {std::cerr << #x "= " << (x) << std::endl;} while(0)
58 #define DAI_DMSG(str) do {std::cerr << str << std::endl;} while(0)
60 #else
61 #define DAI_PV(x) do {} while(0)
62 #define DAI_DMSG(str) do {} while(0)
63 #endif
64 
66 #define DAI_IFVERB(n, stmt) if(props.verbose>=n) { std::cerr << stmt; }
67 
68 
69 #ifdef WINDOWS
70  double atanh( double x );
72 
74  double log1p( double x );
75 
77  #define INFINITY (std::numeric_limits<Real>::infinity())
78 
80  #define NAN (std::numeric_limits<Real>::quiet_NaN())
81 
82  #if defined(_MSC_VER)
83  // Disable unsafe warning (use of the function 'strcpy' instead of
84  // 'strcpy_s' for portability reasons;
85  #pragma warning( disable : 4996 )
86  // Workaround for the char16_t type defined in Matlab and MSVC 2010
87  #if (_MSC_VER >= 1600)
88  #define __STDC_UTF_16__
89  #endif
90  #endif
91 #endif
92 
93 
94 namespace dai {
95 
96 
98 typedef double Real;
99 
101 typedef mpz_class BigInt;
102 
104 inline size_t BigInt_size_t( const BigInt &N ) {
105  DAI_ASSERT( N <= (BigInt)std::numeric_limits<size_t>::max() );
106  return N.get_ui();
107 }
108 
110 bool isnan( Real x );
111 
113 inline Real log( Real x ) {
114  return std::log(x);
115 }
116 
118 inline Real log0( Real x ) {
119  return x ? std::log(x) : 0;
120 }
121 
123 inline Real exp( Real x ) {
124  return std::exp(x);
125 }
126 
128 
132 inline Real pow( Real x, Real y ) {
133  errno = 0;
134  if( x == 0.0 && y < 0.0 )
135  return 0.0;
136  Real result = std::pow(x, y);
137  DAI_DEBASSERT( errno == 0 );
138  return result;
139 }
140 
141 
143 
145 template <typename T, typename U, typename H = boost::hash<T> >
146  class hash_map : public std::tr1::unordered_map<T,U,H> {};
147 
148 
150 double toc();
151 
152 
154 template<class T>
155 inline T abs( const T &t ) {
156  return (t < 0) ? (-t) : t;
157 }
158 
159 
161 void rnd_seed( size_t seed );
162 
164 Real rnd_uniform();
165 
167 Real rnd_stdnormal();
168 
170 int rnd_int( int min, int max );
171 
173 inline int rnd( int n ) {
174  return rnd_int( 0, n-1 );
175 }
176 
177 
179 template<class T>
180 std::string toString( const T& x ) {
181  return boost::lexical_cast<std::string>(x);
182 }
183 
184 
186 template<class T>
187 T fromString( const std::string& x ) {
188  return boost::lexical_cast<T>(x);
189 }
190 
191 
193 template<class T>
194 std::ostream& operator << (std::ostream& os, const std::vector<T> & x) {
195  os << "(";
196  for( typename std::vector<T>::const_iterator it = x.begin(); it != x.end(); it++ )
197  os << (it != x.begin() ? ", " : "") << *it;
198  os << ")";
199  return os;
200 }
201 
203 template<class T>
204 std::ostream& operator << (std::ostream& os, const std::set<T> & x) {
205  os << "{";
206  for( typename std::set<T>::const_iterator it = x.begin(); it != x.end(); it++ )
207  os << (it != x.begin() ? ", " : "") << *it;
208  os << "}";
209  return os;
210 }
211 
213 template<class T1, class T2>
214 std::ostream& operator << (std::ostream& os, const std::map<T1,T2> & x) {
215  os << "{";
216  for( typename std::map<T1,T2>::const_iterator it = x.begin(); it != x.end(); it++ )
217  os << (it != x.begin() ? ", " : "") << it->first << "->" << it->second;
218  os << "}";
219  return os;
220 }
221 
223 template<class T1, class T2>
224 std::ostream& operator << (std::ostream& os, const std::pair<T1,T2> & x) {
225  os << "(" << x.first << ", " << x.second << ")";
226  return os;
227 }
228 
230 template<class T>
231 std::vector<T> concat( const std::vector<T>& u, const std::vector<T>& v ) {
232  std::vector<T> w;
233  w.reserve( u.size() + v.size() );
234  for( size_t i = 0; i < u.size(); i++ )
235  w.push_back( u[i] );
236  for( size_t i = 0; i < v.size(); i++ )
237  w.push_back( v[i] );
238  return w;
239 }
240 
242 
247 std::vector<std::string> tokenizeString( const std::string& s, bool singleDelim, const std::string& delim="\t\n" );
248 
249 
251 
255 typedef enum { NORMPROB, NORMLINF } ProbNormType;
256 
258 
265 typedef enum { DISTL1, DISTLINF, DISTTV, DISTKL, DISTHEL } ProbDistType;
266 
267 
268 } // end of namespace dai
269 
270 
271 #endif
dai::BigInt_size_t
size_t BigInt_size_t(const BigInt &N)
Safe down-cast of big integer to size_t.
Definition: util.h:104
dai::ProbNormType
ProbNormType
Enumerates different ways of normalizing a probability measure.
Definition: util.h:255
dai::pow
Real pow(Real x, Real y)
Returns x to the power y.
Definition: util.h:132
dai::ProbDistType
ProbDistType
Enumerates different distance measures between probability measures.
Definition: util.h:265
dai::log
Real log(Real x)
Returns logarithm of x.
Definition: util.h:113
dai::rnd_stdnormal
Real rnd_stdnormal()
Returns a real number from a standard-normal distribution.
Definition: util.cpp:91
dai::tokenizeString
std::vector< std::string > tokenizeString(const std::string &s, bool singleDelim, const std::string &delim)
Split a string into tokens delimited by one of the characters in delim.
Definition: util.cpp:99
dai::rnd_int
int rnd_int(int min, int max)
Returns a random integer in interval [min, max].
Definition: util.cpp:95
dai::toString
std::string toString(const T &x)
Converts a variable of type T to a std::string by using a boost::lexical_cast.
Definition: util.h:180
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::abs
T abs(const T &t)
Returns absolute value of t.
Definition: util.h:155
dai::rnd_seed
void rnd_seed(size_t seed)
Sets the random seed.
Definition: util.cpp:82
dai::BigInt
mpz_class BigInt
Arbitrary precision integer number.
Definition: util.h:101
dai::isnan
bool isnan(Real x)
Returns true if argument is NAN (Not A Number)
Definition: util.cpp:44
dai::rnd
int rnd(int n)
Returns a random integer in the half-open interval [0, n)
Definition: util.h:173
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::fromString
T fromString(const std::string &x)
Converts a variable of type std::string to T by using a boost::lexical_cast.
Definition: util.h:187
dai::log0
Real log0(Real x)
Returns logarithm of x, or 0 if x == 0.
Definition: util.h:118
dai::concat
std::vector< T > concat(const std::vector< T > &u, const std::vector< T > &v)
Concatenates two vectors.
Definition: util.h:231
dai::toc
double toc()
Returns wall clock time in seconds.
Definition: util.cpp:50
dai::hash_map
hash_map is an alias for std::tr1::unordered_map.
Definition: util.h:146
dai
Namespace for libDAI.
Definition: alldai.cpp:16
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::rnd_uniform
Real rnd_uniform()
Returns a real number, distributed uniformly on [0,1)
Definition: util.cpp:87
dai::exp
Real exp(Real x)
Returns exponent of x.
Definition: util.h:123
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1TreeEP_1_1TreeEPSubTree.html0000644000175000017500000010075312552201370023061 0ustar jorismjorism libDAI: dai::TreeEP::TreeEPSubTree Class Reference
Public Member Functions | Private Attributes | List of all members
dai::TreeEP::TreeEPSubTree Class Reference

Stores the data structures needed to efficiently update the approximation of an off-tree factor. More...

Public Member Functions

void init ()
 Initializes beliefs of this subtree. More...
 
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. More...
 
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. More...
 
Real logZ (const std::vector< Factor > &Qa, const std::vector< Factor > &Qb) const
 Returns energy (?) of this subtree. More...
 
const Factor *& I ()
 Returns constant reference to the pointer to the off-tree factor. More...
 
Constructors/destructors
 TreeEPSubTree ()
 Default constructor. More...
 
 TreeEPSubTree (const TreeEPSubTree &x)
 Copy constructor. More...
 
TreeEPSubTree & operator= (const TreeEPSubTree &x)
 Assignment operator. More...
 
 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. More...
 

Private Attributes

std::vector< Factor > _Qa
 Outer region pseudomarginals (corresponding with the $\tilde f_i(x_j,x_k)$ in [MiQ04]) More...
 
std::vector< Factor > _Qb
 Inner region pseudomarginals (corresponding with the $\tilde f_i(x_s)$ in [MiQ04]) More...
 
RootedTree _RTree
 The junction tree (stored as a rooted tree) More...
 
std::vector< size_t > _a
 Index conversion table for outer region indices (_Qa[alpha] corresponds with Qa[_a[alpha]] of the supertree) More...
 
std::vector< size_t > _b
 Index conversion table for inner region indices (_Qb[beta] corresponds with Qb[_b[beta]] of the supertree) More...
 
const Factor * _I
 Pointer to off-tree factor. More...
 
VarSet _ns
 Variables in off-tree factor. More...
 
VarSet _nsrem
 Variables in off-tree factor which are not in the root of this subtree. More...
 
Real _logZ
 Used for calculating the free energy. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1LC_1_1Properties-members.html0000644000175000017500000001315712552201366023626 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__max.html0000644000175000017500000001220512552201365020563 0ustar jorismjorism libDAI: dai::fo_max< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_max< T > Struct Template Reference

Function object that returns the maximum of two values. More...

#include <dai/prob.h>

Inherits binary_function< T, T, T >.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (x > y ? x : y) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/weightedgraph_8h_source.html0000644000175000017500000015111312552201363021371 0ustar jorismjorism libDAI: include/dai/weightedgraph.h Source File
weightedgraph.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
15 #ifndef __defined_libdai_weightedgraph_h
16 #define __defined_libdai_weightedgraph_h
17 
18 
19 #include <vector>
20 #include <map>
21 #include <iostream>
22 #include <set>
23 #include <limits>
24 #include <climits> // Work-around for bug in boost graph library
25 
26 #include <boost/graph/adjacency_list.hpp>
27 #include <boost/graph/prim_minimum_spanning_tree.hpp>
28 #include <boost/graph/kruskal_min_spanning_tree.hpp>
29 
30 #include <dai/util.h>
31 #include <dai/exceptions.h>
32 #include <dai/graph.h>
33 
34 
35 namespace dai {
36 
37 
39 class DEdge {
40  public:
42  size_t first;
43 
45  size_t second;
46 
48  DEdge() : first(0), second(0) {}
49 
51  DEdge( size_t m1, size_t m2 ) : first(m1), second(m2) {}
52 
54  bool operator==( const DEdge &x ) const { return ((first == x.first) && (second == x.second)); }
55 
57  bool operator<( const DEdge &x ) const {
58  return( (first < x.first) || ((first == x.first) && (second < x.second)) );
59  }
60 
62  friend std::ostream & operator << (std::ostream & os, const DEdge & e) {
63  os << "(" << e.first << "->" << e.second << ")";
64  return os;
65  }
66 
68  std::string toString() const {
69  std::stringstream ss;
70  ss << *this;
71  return ss.str();
72  }
73 };
74 
75 
77 class UEdge {
78  public:
80  size_t first;
81 
83  size_t second;
84 
86  UEdge() : first(0), second(0) {}
87 
89  UEdge( size_t m1, size_t m2 ) : first(m1), second(m2) {}
90 
92  UEdge( const DEdge &e ) : first(e.first), second(e.second) {}
93 
95  bool operator==( const UEdge &x ) {
96  return ((first == x.first) && (second == x.second)) || ((first == x.second) && (second == x.first));
97  }
98 
100  bool operator<( const UEdge &x ) const {
101  size_t s = std::min( first, second );
102  size_t l = std::max( first, second );
103  size_t xs = std::min( x.first, x.second );
104  size_t xl = std::max( x.first, x.second );
105  return( (s < xs) || ((s == xs) && (l < xl)) );
106  }
107 
109  friend std::ostream & operator << (std::ostream & os, const UEdge & e) {
110  if( e.first < e.second )
111  os << "{" << e.first << "--" << e.second << "}";
112  else
113  os << "{" << e.second << "--" << e.first << "}";
114  return os;
115  }
116 
118  std::string toString() const {
119  std::stringstream ss;
120  ss << *this;
121  return ss.str();
122  }
123 };
124 
125 
127 class GraphEL : public std::set<UEdge> {
128  public:
130  GraphEL() {}
131 
133  template <class InputIterator>
134  GraphEL( InputIterator begin, InputIterator end ) {
135  insert( begin, end );
136  }
137 
139  GraphEL( const GraphAL& G ) {
140  for( size_t n1 = 0; n1 < G.nrNodes(); n1++ )
141  bforeach( const Neighbor n2, G.nb(n1) )
142  if( n1 < n2 )
143  insert( UEdge( n1, n2 ) );
144  }
145 };
146 
147 
149 template<class T> class WeightedGraph : public std::map<UEdge, T> {};
150 
151 
153 
157 class RootedTree : public std::vector<DEdge> {
158  public:
160  RootedTree() {}
161 
163 
165  RootedTree( const GraphEL &T, size_t Root );
166 };
167 
168 
170 
175 template<typename T> RootedTree MinSpanningTree( const WeightedGraph<T> &G, bool usePrim ) {
176  RootedTree result;
177  if( G.size() > 0 ) {
178  using namespace boost;
179  using namespace std;
180  typedef adjacency_list< vecS, vecS, undirectedS, no_property, property<edge_weight_t, double> > boostGraph;
181 
182  set<size_t> nodes;
183  vector<UEdge> edges;
184  vector<double> weights;
185  edges.reserve( G.size() );
186  weights.reserve( G.size() );
187  for( typename WeightedGraph<T>::const_iterator e = G.begin(); e != G.end(); e++ ) {
188  weights.push_back( e->second );
189  edges.push_back( e->first );
190  nodes.insert( e->first.first );
191  nodes.insert( e->first.second );
192  }
193 
194  size_t N = nodes.size();
195  for( set<size_t>::const_iterator it = nodes.begin(); it != nodes.end(); it++ )
196  if( *it >= N )
197  DAI_THROWE(RUNTIME_ERROR,"Vertices must be in range [0..N) where N is the number of vertices.");
198 
199  boostGraph g( edges.begin(), edges.end(), weights.begin(), nodes.size() );
200  size_t root = *(nodes.begin());
201  GraphEL tree;
202  if( usePrim ) {
203  // Prim's algorithm
204  vector< graph_traits< boostGraph >::vertex_descriptor > p(N);
205  prim_minimum_spanning_tree( g, &(p[0]) );
206 
207  // Store tree edges in result
208  for( size_t i = 0; i != p.size(); i++ ) {
209  if( p[i] != i )
210  tree.insert( UEdge( p[i], i ) );
211  }
212  } else {
213  // Kruskal's algorithm
214  vector< graph_traits< boostGraph >::edge_descriptor > t;
215  t.reserve( N - 1 );
216  kruskal_minimum_spanning_tree( g, std::back_inserter(t) );
217 
218  // Store tree edges in result
219  for( size_t i = 0; i != t.size(); i++ ) {
220  size_t v1 = source( t[i], g );
221  size_t v2 = target( t[i], g );
222  if( v1 != v2 )
223  tree.insert( UEdge( v1, v2 ) );
224  }
225  }
226 
227  // Direct edges in order to obtain a rooted tree
228  result = RootedTree( tree, root );
229  }
230  return result;
231 }
232 
233 
235 
240 template<typename T> RootedTree MaxSpanningTree( const WeightedGraph<T> &G, bool usePrim ) {
241  if( G.size() == 0 )
242  return RootedTree();
243  else {
244  T maxweight = G.begin()->second;
245  for( typename WeightedGraph<T>::const_iterator it = G.begin(); it != G.end(); it++ )
246  if( it->second > maxweight )
247  maxweight = it->second;
248  // make a copy of the graph
249  WeightedGraph<T> gr( G );
250  // invoke MinSpanningTree with negative weights
251  // (which have to be shifted to satisfy positivity criterion)
252  for( typename WeightedGraph<T>::iterator it = gr.begin(); it != gr.end(); it++ )
253  it->second = maxweight - it->second;
254  return MinSpanningTree( gr, usePrim );
255  }
256 }
257 
258 
259 } // end of namespace dai
260 
261 
262 #endif
dai::MaxSpanningTree
RootedTree MaxSpanningTree(const WeightedGraph< T > &G, bool usePrim)
Constructs a minimum spanning tree from the (non-negatively) weighted graph G.
Definition: weightedgraph.h:240
dai::GraphEL::GraphEL
GraphEL(InputIterator begin, InputIterator end)
Construct from range of objects that can be cast to UEdge.
Definition: weightedgraph.h:134
dai::UEdge::first
size_t first
First node index.
Definition: weightedgraph.h:80
dai::DEdge::second
size_t second
Second node index (target of edge)
Definition: weightedgraph.h:45
DAI_THROWE
#define DAI_THROWE(cod, msg)
Macro that simplifies throwing an exception with a user-defined error message.
Definition: exceptions.h:57
dai::UEdge::operator==
bool operator==(const UEdge &x)
Tests for inequality (disregarding the ordering of the nodes)
Definition: weightedgraph.h:95
dai::UEdge::second
size_t second
Second node index.
Definition: weightedgraph.h:83
dai::GraphAL::nrNodes
size_t nrNodes() const
Returns number of nodes.
Definition: graph.h:224
std
STL namespace.
dai::DEdge::first
size_t first
First node index (source of edge)
Definition: weightedgraph.h:42
dai::GraphEL
Represents an undirected graph, implemented as a std::set of undirected edges.
Definition: weightedgraph.h:127
dai::DEdge::operator<
bool operator<(const DEdge &x) const
Smaller-than operator (performs lexicographical comparison)
Definition: weightedgraph.h:57
dai::DEdge::DEdge
DEdge()
Default constructor.
Definition: weightedgraph.h:48
dai::UEdge::UEdge
UEdge()
Default constructor.
Definition: weightedgraph.h:86
dai::RootedTree::RootedTree
RootedTree()
Default constructor.
Definition: weightedgraph.h:160
bforeach
#define bforeach
An alias to the BOOST_FOREACH macro from the boost::bforeach library.
Definition: util.h:48
dai::UEdge::UEdge
UEdge(const DEdge &e)
Construct from DEdge.
Definition: weightedgraph.h:92
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::GraphEL::GraphEL
GraphEL(const GraphAL &G)
Construct from GraphAL.
Definition: weightedgraph.h:139
dai::WeightedGraph
Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping un...
Definition: weightedgraph.h:149
util.h
Defines general utility functions and adds an abstraction layer for platform-dependent functionality...
dai::UEdge::operator<
bool operator<(const UEdge &x) const
Smaller-than operator.
Definition: weightedgraph.h:100
dai::DEdge
Represents a directed edge.
Definition: weightedgraph.h:39
dai::DEdge::DEdge
DEdge(size_t m1, size_t m2)
Constructs a directed edge pointing from m1 to m2.
Definition: weightedgraph.h:51
dai::UEdge
Represents an undirected edge.
Definition: weightedgraph.h:77
graph.h
Defines the GraphAL class, which represents an undirected graph as an adjacency list.
dai::RootedTree
Represents a rooted tree, implemented as a vector of directed edges.
Definition: weightedgraph.h:157
dai::GraphEL::GraphEL
GraphEL()
Default constructor.
Definition: weightedgraph.h:130
dai::DEdge::operator<<
friend std::ostream & operator<<(std::ostream &os, const DEdge &e)
Writes a directed edge to an output stream.
Definition: weightedgraph.h:62
dai::Neighbor
Describes the neighbor relationship of two nodes in a graph.
Definition: graph.h:73
dai::DEdge::toString
std::string toString() const
Formats a directed edge as a string.
Definition: weightedgraph.h:68
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::GraphAL::nb
const Neighbor & nb(size_t n1, size_t _n2) const
Returns constant reference to the _n2 'th neighbor of node n1.
Definition: graph.h:144
dai::UEdge::toString
std::string toString() const
Formats an undirected edge as a string.
Definition: weightedgraph.h:118
dai::MinSpanningTree
RootedTree MinSpanningTree(const WeightedGraph< T > &G, bool usePrim)
Constructs a minimum spanning tree from the (non-negatively) weighted graph G.
Definition: weightedgraph.h:175
dai::GraphAL
Represents the neighborhood structure of nodes in an undirected graph.
Definition: graph.h:114
dai::UEdge::UEdge
UEdge(size_t m1, size_t m2)
Constructs an undirected edge between m1 and m2.
Definition: weightedgraph.h:89
dai::DEdge::operator==
bool operator==(const DEdge &x) const
Tests for equality.
Definition: weightedgraph.h:54
dai::UEdge::operator<<
friend std::ostream & operator<<(std::ostream &os, const UEdge &e)
Writes an undirected edge to an output stream.
Definition: weightedgraph.h:109
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1WeightedGraph.html0000644000175000017500000000732612552201370021462 0ustar jorismjorism libDAI: dai::WeightedGraph< T > Class Template Reference
List of all members
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>

Inheritance diagram for dai::WeightedGraph< T >:

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_10.png0000644000175000017500000000034212552200215015643 0ustar jorismjorism‰PNG  IHDR —™'n0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïQIDATxíÑ À ¬¶Æý·-ÑÆö¯ïÁÁ åÙ½ø¶91´–Ë'SØ&®9Å<§•`³ö凵ª†Øñà ‘h]xóÜÿ>qW’ üÆ­žIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1EMAlg-members.html0000644000175000017500000002344012552201365021314 0ustar jorismjorism libDAI: Member List
dai::EMAlg Member List

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

_estepdai::EMAlgprivate
_evidencedai::EMAlgprivate
_itersdai::EMAlgprivate
_lastLogZdai::EMAlgprivate
_log_z_toldai::EMAlgprivate
_max_itersdai::EMAlgprivate
_mstepsdai::EMAlgprivate
const_s_iterator typedefdai::EMAlg
EMAlg(const Evidence &evidence, InfAlg &estep, std::vector< MaximizationStep > &msteps, const PropertySet &termconditions)dai::EMAlginline
EMAlg(const Evidence &evidence, InfAlg &estep, std::istream &mstep_file)dai::EMAlg
eStep() const dai::EMAlginline
hasSatisfiedTermConditions() const dai::EMAlg
iterate()dai::EMAlg
iterate(MaximizationStep &mstep)dai::EMAlg
Iterations() const dai::EMAlginline
LOG_Z_TOL_DEFAULTdai::EMAlgstatic
LOG_Z_TOL_KEYdai::EMAlgstatic
logZ() const dai::EMAlginline
MAX_ITERS_DEFAULTdai::EMAlgstatic
MAX_ITERS_KEYdai::EMAlgstatic
run()dai::EMAlg
s_begin()dai::EMAlginline
s_begin() const dai::EMAlginline
s_end()dai::EMAlginline
s_end() const dai::EMAlginline
s_iterator typedefdai::EMAlg
setTermConditions(const PropertySet &p)dai::EMAlg
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_75.png0000644000175000017500000000074612552200234015667 0ustar jorismjorism‰PNG  IHDRPû_©ø0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïUIDATxíÍrà „?Œyÿ·­À?q’¶—4Ú 0Ê"­„Ïÿ ùaà×(Í ¹­/ð峋\+Çr€Là}HÓcyŸJþÔðÍÅu¿jì{'Þz±%À=– \]ýÝr!tÅS„PÜ’:aÔü p ×2pq»¢*nœaI]j$Å5O`…ÅM$™6;µ‰g6ç,Yü!­®=´¹X˜ŒÚ¬ZÍ àgŸíßG¼oHö;¡¥Ö4ë~‹‘¥J°<ža=ÊßâM2E—ƒ0˜VeÊ"ãÈÊgñÞßOn>ÇÆdk©1YÝÒéC1îz3R)¥öšsIјõIû½çiõCÍ.aŸ§ÑÑë8ôŸž•I2örær}YÇTÏVǘ9iÓ¨Ü=‡—è}нaþî%Ìmݬ5“¸Ž÷2é‡Â:(ì鼃ô7_€ã I&ãŠ0€IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1TRWBP-members.html0000644000175000017500000006234612552201370021271 0ustar jorismjorism libDAI: Member List
dai::TRWBP Member List

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

_edge2lutdai::BPprotected
_edgesdai::BPprotected
_itersdai::BPprotected
_lutdai::BPprotected
_maxdiffdai::BPprotected
_oldBeliefsFdai::BPprotected
_oldBeliefsVdai::BPprotected
_sentMessagesdai::BPprotected
_updateSeqdai::BPprotected
_weightdai::TRWBPprotected
addTreeToWeights(const RootedTree &tree)dai::TRWBP
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const Var &v) const dai::BPinlinevirtual
belief(const VarSet &vs) const dai::BPvirtual
beliefF(size_t I) const dai::BPvirtual
beliefs() const dai::BPvirtual
beliefV(size_t i) const dai::BPvirtual
BP()dai::BPinline
BP(const FactorGraph &fg, const PropertySet &opts)dai::BPinline
BP(const BP &x)dai::BPinline
calcBeliefF(size_t I, Prob &p) const dai::TRWBPinlineprotectedvirtual
calcBeliefV(size_t i, Prob &p) const dai::TRWBPprotectedvirtual
calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const dai::TRWBPprotectedvirtual
calcNewMessage(size_t i, size_t _I)dai::BPprotectedvirtual
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clearSentMessages()dai::BPinline
clone() const dai::TRWBPinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::TRWBPinlinevirtual
construct()dai::TRWBPprotectedvirtual
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findMaximum() const dai::BPinlinevirtual
findMaxResidual(size_t &i, size_t &_I)dai::BPprotected
getProperties() const dai::TRWBPvirtual
getSentMessages() const dai::BPinline
identify() const dai::InfAlginlinevirtual
ind_t typedefdai::BPprotected
index(size_t i, size_t _I) const dai::BPinlineprotected
index(size_t i, size_t _I)dai::BPinlineprotected
init()dai::BPvirtual
init(const VarSet &ns)dai::BPvirtual
Iterations() const dai::BPinlinevirtual
logZ() const dai::TRWBPvirtual
LutType typedefdai::BPprotected
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::BPinlinevirtual
message(size_t i, size_t _I) const dai::BPinlineprotected
message(size_t i, size_t _I)dai::BPinlineprotected
name() const dai::TRWBPinlinevirtual
newMessage(size_t i, size_t _I) const dai::BPinlineprotected
newMessage(size_t i, size_t _I)dai::BPinlineprotected
nrtreesdai::TRWBP
operator=(const BP &x)dai::BPinline
printProperties() const dai::TRWBPvirtual
props (defined in dai::BP)dai::BP
recordSentMessagesdai::BP
residual(size_t i, size_t _I) const dai::BPinlineprotected
residual(size_t i, size_t _I)dai::BPinlineprotected
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()dai::BPvirtual
sampleWeights(size_t nrTrees)dai::TRWBP
setMaxIter(size_t maxiter)dai::BPinlinevirtual
setProperties(const PropertySet &opts)dai::TRWBPvirtual
setWeight(size_t I, Real c)dai::TRWBPinline
setWeights(const std::vector< Real > &c)dai::TRWBPinline
TRWBP()dai::TRWBPinline
TRWBP(const FactorGraph &fg, const PropertySet &opts)dai::TRWBPinline
updateMessage(size_t i, size_t _I)dai::BPprotected
updateResidual(size_t i, size_t _I, Real r)dai::BPprotected
Weight(size_t I) const dai::TRWBPinline
Weights() const dai::TRWBPinline
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_102.png0000644000175000017500000000426112552200242015731 0ustar jorismjorism‰PNG  IHDR‡3Kì4›0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï IDATxííºª<¯…ï––/…žÿÙî$Q¬ëÙë•É˜"B“Ž‘Œüøà€ÿM„²ö× 4?¬àÚÇuÑ<±/N‡ë~Ø@UO—÷heû¸pòê?<£Ÿ¬¨ŠxOsM;„_;ì#ôK±%îç#€¶Ñ/ £h.Õñ¡6ÀK” àbôÀ{ø –á“ø`íE#av4¿) ðázcJ?[8@ZLj€“áÓ%Ãà_Bw¸ÕõðÿõÕ4µ?Ž“¸ýÕ pJ€¿âê‘j`~–u]ÏÏàK¼¬¡¢®ëù °ª™Q”÷\¥ÉÕu=?À—Xñp\z.©*¥ª¶O_ùVæÌW{ðeJ)‡©Sº•v½x ·ÿ À Ä6¥6‡XÕŸ”Tj.ÃF¿ÝÓܪŠôyö¡Ì4•PE.ÞP{CÓ¹*_©-Jç‹nUpï£ë>ƲîA„õüqSîùëK6Ÿ[}PõQ®.x€MLô¿«ƒ/ôÐ-€fvó:$š=-&úÿX‡¯|á¹›=!êµ¢Mšs·z ¨3Íq(2!ö€ºw¬XyµÍÁç:˜ÅL:ˆÎ>§’ÇÀNÓáöîÙÌV7^é@óš–®}ycÙÆ$iã¾]éÐÎKÞkÚ6¥Å.¤'wMã4êothW^Ðî4Ħô/§Ò#£u¼i¤ô«{û\¨;4}¢C(ã#˜¥ ErAd˜ `uXåJ‰‰VÏ°}û|§ðè ®®e=_Ž‹nË,#b5¾'òš¤K<â„P„Y&"¯{ gs¥ŽÂ“ßQõH‡¢Ô=º8e b«V­wdÃã‹Ý£é@W6’µð7u”>xC\ê&vôØÒ¡h¤d–ÆC_-ž(ÅMR#nL:Dy4ô3Zvt M»–«Áq·¶˜âä5Bî¡Q‡Y­ å-<½—Övmà%uXp)Y?¹Ú4ð!¿\gÓÜh ÆÏÂÈG¬†ºÙ¶º=cNû­nëÿ!N‘%>¦~xÃù w£Äè5bæƒZ· p„ãù°àrÜĺÝ6uò‡™¿‰r”äìWA~)ò©ôßMäÔ=ÀÕþ Î Ù{Öº%ªÎ;9Q‡ S¾-•&Ù§{&b·P>ÓaÎå´‰ÑFB=Rµ¥Ã½“gõM_ØQݽ÷Ê¢‹ÍMfD¾1Íi1ÂÖ½úÓ‹9MÜu%+žQ}]:¹{)qÆ>ɳàG:˜e8i» l覇 Þš oê°àrhó|tJ^3ÚÔæ|‡õ÷ ¯ê›¾´£•"Ž*¨x·ÜóACÛ l¶ê*}Ñ•¯d–w÷ÜJƒšåºÑ8ÄJgpAÿ—é Õ¢éÚ¨±±44±N¹‡.{8ž3.eŽi1³Ù»/}iUžN½²ªŸOb½áölfsy'ž °Ð4Fº%¹ˆó kv_Xâp><ù¸Ô”m*(Ü9:Ì[Q“U}É62Ó`1ã4¹²ÍUÙ#Œ+½±ë¥›: 3ŽŠE¸›Õ{(s¿>âø5qÿ4Lvñ‘ö„³£¶&9i>Ìm š9žÉ‡«•óq†ÏmmØçn‘Æ n‹—oËüŸ_ÆYØÅ:¸&=ö`Z«'¼ÆG:‹³¬oSÐî;ÞA‘V̵c ¸¢ˆí• ðêqñ2¸¯y÷²&ÇØEJCÛ¤ôÁàš\x&è[6ðܪL„“”Òã|8&À‰(;]^èœ.ÞDß¼Óyw[XÚgºø ioÂœ€u™8çæ'À5˜Ö¿,ЉÒŸˆp€îbþlø7Àyh¯?ÿâÕ4•ÿ FË(ò·üpÆΡ>²©æjš|º`Ó›ð# î¥l¯¶è¾æªþ ^ -€·P7ÃZO!û-Õæ]SE\ð.®·ï”óveŒ[ ¡í«¦ÑZÔ ƒ.y—…}Hùàc8-ÜEž³uA+ú —oàêñ ¹æº(IZ•^ŠGÉÒÍ Î˜?ƒ”)ÀAWC½ºx‹ubÛ4úµeþ@‡xÛ ‘—Ìä'ýÿ‰áz÷ö–”|ÞG›ª3óÎvà5Õà£òX#xYd´è|i°pfDAb…¢“Ѐ/ ¥þ†CiöÔë¥õ í•ÕŠºW¢×´]YÕZ:ÑwSY'ki­ÖûŸëàÞë9d-YýVJ(o[Ô;þ.T¹¨é4_­ªçÖÚN—¬²óYHß½?ÿƵžseÙ¥ö¤3ŒØK`¯[¨¥jÌ&B6X€¯¡=72,Ëù$U&»Söµ¤ï$´õ&Àg¨ƒMßç¥5ˆÝµ®¶ñ@ó~?ÄïûàMô³$©kEe‡Uæ•›BÅhÿ¼¨dÅ¢5Û«n²žFúLY2½ÅÒ¿žUiä>‡È³ÁëvT‡ØYI}`´éŒáð!Ojs!!AÓk¬õ›RâΙÁÝÍ ª&/Ÿ[¤ÏÓH½o¢ÿë9=ä¸ ‘-)K=s×÷7¿lO€Oût~ ͘2OÅ׎ýp s>`qŽlKù§}pÊ<¢mRÇ&oG6ô>¹ÝøÀ…pýSiS¶'xÀqsȾª^•)À(ÌE~X`p5€þ[ø?¡¦5Y–ªAÏIEND®B`‚libDAI-0.3.2/doc/html/functions_k.html0000644000175000017500000001136312552201370017112 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- k -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/doc_8h_source.html0000644000175000017500000000700212552201363017311 0ustar jorismjorism libDAI: include/dai/doc.h Source File
doc.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/mr_8h_source.html0000644000175000017500000014047612552201363017177 0ustar jorismjorism libDAI: include/dai/mr.h Source File
mr.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_mr_h
14 #define __defined_libdai_mr_h
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_MR
19 
20 
21 #include <vector>
22 #include <string>
23 #include <dai/factorgraph.h>
24 #include <dai/daialg.h>
25 #include <dai/enum.h>
26 #include <dai/properties.h>
27 #include <dai/exceptions.h>
28 #include <dai/graph.h>
29 #include <boost/dynamic_bitset.hpp>
30 
31 
32 namespace dai {
33 
34 
36 
38 class MR : public DAIAlgFG {
39  private:
41  bool supported;
42 
44  GraphAL G;
45 
47  std::vector<std::vector<Real> > tJ;
49  std::vector<Real> theta;
50 
52  std::vector<std::vector<Real> > M;
54  std::vector<std::vector<std::vector<Real> > > cors;
55 
57  typedef boost::dynamic_bitset<> sub_nb;
58 
60  std::vector<Real> Mag;
61 
63  Real _maxdiff;
64 
66  size_t _iters;
67 
68  public:
70  struct Properties {
72 
76  DAI_ENUM(UpdateType,FULL,LINEAR);
77 
79 
84  DAI_ENUM(InitType,RESPPROP,CLAMPING,EXACT);
85 
87  size_t verbose;
88 
90  Real tol;
91 
93  UpdateType updates;
94 
96  InitType inits;
97  } props;
98 
99  public:
101  MR() : DAIAlgFG(), supported(), G(), tJ(), theta(), M(), cors(), Mag(), _maxdiff(), _iters(), props() {}
102 
104 
109  MR( const FactorGraph &fg, const PropertySet &opts );
110 
111 
113 
114  virtual MR* clone() const { return new MR(*this); }
115  virtual MR* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new MR( fg, opts ); }
116  virtual std::string name() const { return "MR"; }
117  virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); }
118  virtual Factor belief( const VarSet &/*vs*/ ) const;
119  virtual Factor beliefV( size_t i ) const;
120  virtual std::vector<Factor> beliefs() const;
121  virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; }
122  virtual void init() {}
123  virtual void init( const VarSet &/*ns*/ ) { DAI_THROW(NOT_IMPLEMENTED); }
124  virtual Real run();
125  virtual Real maxDiff() const { return _maxdiff; }
126  virtual size_t Iterations() const { return _iters; }
127  virtual void setProperties( const PropertySet &opts );
128  virtual PropertySet getProperties() const;
129  virtual std::string printProperties() const;
131 
132  private:
134  Real calcCavityCorrelations();
135 
137  void propagateCavityFields();
138 
140  void calcMagnetizations();
141 
143 
146  Real _tJ(size_t i, sub_nb A);
147 
149  Real Omega(size_t i, size_t _j, size_t _l);
150 
152 
155  Real T(size_t i, sub_nb A);
156 
158  Real T(size_t i, size_t _j);
159 
161  Real Gamma(size_t i, size_t _j, size_t _l1, size_t _l2);
162 
164  Real Gamma(size_t i, size_t _l1, size_t _l2);
165 
167 
175  Real appM(size_t i, sub_nb A);
176 
178 
183  void sum_subs(size_t j, sub_nb A, Real *sum_even, Real *sum_odd);
184 };
185 
186 
187 } // end of namespace dai
188 
189 
190 #endif
191 
192 
193 #endif
dai::MR::construct
virtual MR * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: mr.h:115
dai::MR::Properties::DAI_ENUM
DAI_ENUM(UpdateType, FULL, LINEAR)
Enumeration of different types of update equations.
dai::MR::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: mr.h:125
dai::MR::calcMagnetizations
void calcMagnetizations()
Calculate magnetizations.
Definition: mr.cpp:249
dai::MR::M
std::vector< std::vector< Real > > M
M[i][_j] is .
Definition: mr.h:52
dai::MR::calcCavityCorrelations
Real calcCavityCorrelations()
Initialize cors.
Definition: mr.cpp:276
dai::MR::clone
virtual MR * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: mr.h:114
dai::MR::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: mr.h:87
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::MR::init
virtual void init()
Initializes all data structures of the approximate inference algorithm.
Definition: mr.h:122
dai::MR::Properties::inits
InitType inits
How to initialize the cavity correlations.
Definition: mr.h:96
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::MR::cors
std::vector< std::vector< std::vector< Real > > > cors
Cavity correlations.
Definition: mr.h:54
dai::MR::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: mr.cpp:45
dai::MR::Properties::tol
Real tol
Tolerance for convergence test.
Definition: mr.h:90
dai::MR::Omega
Real Omega(size_t i, size_t _j, size_t _l)
Calculate as defined in [MoR05] eqn. (2.15)
Definition: mr.cpp:86
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::MR::sub_nb
boost::dynamic_bitset sub_nb
Type used for managing a subset of neighbors.
Definition: mr.h:57
dai::MR::Gamma
Real Gamma(size_t i, size_t _j, size_t _l1, size_t _l2)
Calculates as defined in [MoR05] eqn. (2.16)
Definition: mr.cpp:95
dai::MR::sum_subs
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)
Definition: mr.cpp:146
dai::MR::theta
std::vector< Real > theta
theta[i] is the local field on spin i
Definition: mr.h:49
dai::MR::_maxdiff
Real _maxdiff
Maximum difference encountered so far.
Definition: mr.h:63
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::MR::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: mr.cpp:55
dai::MR::setProperties
virtual void setProperties(const PropertySet &opts)
Set parameters of this inference algorithm.
Definition: mr.cpp:30
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::MR::Properties::updates
UpdateType updates
Update equations.
Definition: mr.h:93
dai::MR::MR
MR()
Default constructor.
Definition: mr.h:101
dai::MR::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: mr.h:126
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::MR::run
virtual Real run()
Runs the approximate inference algorithm.
Definition: mr.cpp:346
dai::MR::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: mr.h:121
dai::MR::init
virtual void init(const VarSet &)
Initializes all data structures corresponding to some set of variables.
Definition: mr.h:123
dai::MR::supported
bool supported
Is the underlying factor graph supported?
Definition: mr.h:41
dai::MR::appM
Real appM(size_t i, sub_nb A)
Approximates moments of variables in A.
Definition: mr.cpp:127
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::MR::G
GraphAL G
The interaction graph (Markov graph)
Definition: mr.h:44
graph.h
Defines the GraphAL class, which represents an undirected graph as an adjacency list.
dai::MR::_iters
size_t _iters
Number of iterations needed.
Definition: mr.h:66
dai::MR::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: mr.h:116
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::MR::T
Real T(size_t i, sub_nb A)
Calculate as defined in [MoR05] eqn. (2.17) with .
Definition: mr.cpp:66
dai::MR::beliefs
virtual std::vector< Factor > beliefs() const
Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm...
Definition: mr.cpp:397
dai::MR::propagateCavityFields
void propagateCavityFields()
Iterate update equations for cavity fields.
Definition: mr.cpp:172
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::MR::Properties
Parameters for MR.
Definition: mr.h:70
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
dai::MR::Mag
std::vector< Real > Mag
Magnetizations.
Definition: mr.h:60
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai::MR::beliefV
virtual Factor beliefV(size_t i) const
Returns the (approximate) marginal probability distribution of the variable with index i...
Definition: mr.cpp:373
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::MR::belief
virtual Factor belief(const Var &v) const
Returns the (approximate) marginal probability distribution of a variable.
Definition: mr.h:117
dai::GraphAL
Represents the neighborhood structure of nodes in an undirected graph.
Definition: graph.h:114
dai::DAIAlg
Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)...
Definition: daialg.h:207
dai::MR::tJ
std::vector< std::vector< Real > > tJ
tJ[i][_j] is the hyperbolic tangent of the interaction between spin i and its neighbour G...
Definition: mr.h:47
dai::MR::_tJ
Real _tJ(size_t i, sub_nb A)
Calculate the product of all tJ[i][_j] for _j in A.
Definition: mr.cpp:118
dai::MR
Approximate inference algorithm by Montanari and Rizzo [MoR05].
Definition: mr.h:38
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/properties_8h_source.html0000644000175000017500000012632212552201363020747 0ustar jorismjorism libDAI: include/dai/properties.h Source File
properties.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_properties_h
14 #define __defined_libdai_properties_h
15 
16 
17 #include <iostream>
18 #include <sstream>
19 #include <boost/any.hpp>
20 #include <map>
21 #include <vector>
22 #include <typeinfo>
23 #include <dai/exceptions.h>
24 #include <dai/util.h>
25 #include <boost/lexical_cast.hpp>
26 
27 
28 namespace dai {
29 
30 
32 typedef std::string PropertyKey;
33 
35 typedef boost::any PropertyValue;
36 
38 typedef std::pair<PropertyKey, PropertyValue> Property;
39 
40 
42 
46 std::ostream& operator<< ( std::ostream & os, const Property &p );
47 
48 
50 
73 class PropertySet : private std::map<PropertyKey, PropertyValue> {
74  public:
76 
77  PropertySet() {}
79 
81 
83  PropertySet( const std::string& s ) {
84  std::stringstream ss;
85  ss << s;
86  ss >> *this;
87  }
89 
91 
92  PropertySet& set( const PropertyKey& key, const PropertyValue& val ) {
94  this->operator[](key) = val;
95  return *this;
96  }
97 
99  PropertySet& set( const PropertySet& newProps ) {
100  const std::map<PropertyKey, PropertyValue> *m = &newProps;
101  bforeach(value_type i, *m)
102  set( i.first, i.second );
103  return *this;
104  }
105 
107 
112  PropertySet operator()( const PropertyKey& key, const PropertyValue& val ) const {
113  PropertySet copy = *this;
114  return copy.set(key,val);
115  }
116 
118 
122  template<typename ValueType>
123  PropertySet& setAsString( const PropertyKey& key, const ValueType& val ) {
124  try {
125  return set( key, boost::lexical_cast<std::string>(val) );
126  } catch( boost::bad_lexical_cast & ) {
127  DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' to string.");
128  }
129  }
130 
132 
136  template<typename ValueType>
137  void convertTo( const PropertyKey& key ) {
138  PropertyValue val = get(key);
139  if( val.type() != typeid(ValueType) ) {
140  DAI_ASSERT( val.type() == typeid(std::string) );
141  try {
142  set(key, boost::lexical_cast<ValueType>(getAs<std::string>(key)));
143  } catch(boost::bad_lexical_cast &) {
144  DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' from string to desired type.");
145  }
146  }
147  }
149 
151 
153 
154  size_t size() const {
156  return std::map<PropertyKey, PropertyValue>::size();
157  }
158 
160  void clear() {
161  std::map<PropertyKey, PropertyValue>::clear();
162  }
163 
165  size_t erase( const PropertyKey &key ) {
166  return std::map<PropertyKey, PropertyValue>::erase( key );
167  }
168 
170  bool hasKey( const PropertyKey& key ) const {
171  PropertySet::const_iterator x = find(key);
172  return (x != this->end());
173  }
174 
176  std::set<PropertyKey> keys() const {
177  std::set<PropertyKey> res;
178  const_iterator i;
179  for( i = begin(); i != end(); i++ )
180  res.insert( i->first );
181  return res;
182  }
183 
185 
187  const PropertyValue& get( const PropertyKey& key ) const {
188  PropertySet::const_iterator x = find(key);
189  if( x == this->end() )
190  DAI_THROWE(OBJECT_NOT_FOUND,"PropertySet::get cannot find property '" + key + "'");
191  return x->second;
192  }
193 
195 
199  template<typename ValueType>
200  ValueType getAs( const PropertyKey& key ) const {
201  try {
202  return boost::any_cast<ValueType>(get(key));
203  } catch( const boost::bad_any_cast & ) {
204  DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' to desired type.");
205  return ValueType();
206  }
207  }
208 
210 
217  template<typename ValueType>
218  ValueType getStringAs( const PropertyKey& key ) const {
219  PropertyValue val = get(key);
220  if( val.type() == typeid(ValueType) ) {
221  return boost::any_cast<ValueType>(val);
222  } else if( val.type() == typeid(std::string) ) {
223  try {
224  return boost::lexical_cast<ValueType>(getAs<std::string>(key));
225  } catch(boost::bad_lexical_cast &) {
226  DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' from string to desired type.");
227  }
228  } else
229  DAI_THROWE(IMPOSSIBLE_TYPECAST,"Cannot cast value of property '" + key + "' from string to desired type.");
230  return ValueType();
231  }
233 
235 
236 
242  friend std::ostream& operator<< ( std::ostream& os, const PropertySet& ps );
243 
245  std::string toString() const {
246  std::stringstream ss;
247  ss << *this;
248  return ss.str();
249  }
250 
252 
256  friend std::istream& operator>> ( std::istream& is, PropertySet& ps );
257 
259  void fromString( const std::string& s ) {
260  std::stringstream ss( s );
261  ss >> *this;
262  }
264 };
265 
266 
267 } // end of namespace dai
268 
269 
270 #endif
dai::PropertySet::operator<<
friend std::ostream & operator<<(std::ostream &os, const PropertySet &ps)
Writes a PropertySet object to an output stream.
Definition: properties.cpp:40
dai::PropertySet::getStringAs
ValueType getStringAs(const PropertyKey &key) const
Gets the value corresponding to key, cast to ValueType, converting from a string if necessary...
Definition: properties.h:218
DAI_THROWE
#define DAI_THROWE(cod, msg)
Macro that simplifies throwing an exception with a user-defined error message.
Definition: exceptions.h:57
dai::PropertySet::convertTo
void convertTo(const PropertyKey &key)
Converts the type of the property value corresponding with key from string to ValueType (if necessary...
Definition: properties.h:137
dai::PropertySet::keys
std::set< PropertyKey > keys() const
Returns a set containing all keys.
Definition: properties.h:176
dai::Property
std::pair< PropertyKey, PropertyValue > Property
A Property is a pair of a key and a corresponding value.
Definition: properties.h:38
dai::PropertySet::size
size_t size() const
Return number of key-value pairs.
Definition: properties.h:155
dai::PropertySet::hasKey
bool hasKey(const PropertyKey &key) const
Check if a property with the given key is defined.
Definition: properties.h:170
dai::PropertySet::set
PropertySet & set(const PropertySet &newProps)
Set properties according to newProps, overriding properties that already exist with new values...
Definition: properties.h:99
dai::PropertySet::setAsString
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...
Definition: properties.h:123
dai::PropertySet::clear
void clear()
Removes all key-value pairs.
Definition: properties.h:160
dai::operator<<
std::ostream & operator<<(std::ostream &os, const FactorGraph &fg)
Writes a FactorGraph to an output stream.
Definition: factorgraph.cpp:73
dai::PropertySet::set
PropertySet & set(const PropertyKey &key, const PropertyValue &val)
Sets a property (a key key with a corresponding value val)
Definition: properties.h:93
bforeach
#define bforeach
An alias to the BOOST_FOREACH macro from the boost::bforeach library.
Definition: util.h:48
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
util.h
Defines general utility functions and adds an abstraction layer for platform-dependent functionality...
dai::PropertySet::PropertySet
PropertySet()
Default constructor.
Definition: properties.h:78
dai::PropertySet::operator()
PropertySet operator()(const PropertyKey &key, const PropertyValue &val) const
Shorthand for (temporarily) adding properties.
Definition: properties.h:112
dai::PropertySet::erase
size_t erase(const PropertyKey &key)
Removes key-value pair with given key.
Definition: properties.h:165
dai::PropertySet::operator>>
friend std::istream & operator>>(std::istream &is, PropertySet &ps)
Reads a PropertySet object from an input stream.
Definition: properties.cpp:53
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::PropertyValue
boost::any PropertyValue
Type of the value of a Property.
Definition: properties.h:35
dai::PropertySet::fromString
void fromString(const std::string &s)
Reads a PropertySet from a string.
Definition: properties.h:259
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::PropertySet::getAs
ValueType getAs(const PropertyKey &key) const
Gets the value corresponding to key, cast to ValueType.
Definition: properties.h:200
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
dai::PropertySet::PropertySet
PropertySet(const std::string &s)
Construct from a string.
Definition: properties.h:83
dai::PropertyKey
std::string PropertyKey
Type of the key of a Property.
Definition: properties.h:32
dai::PropertySet::toString
std::string toString() const
Formats a PropertySet as a string.
Definition: properties.h:245
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_103.png0000644000175000017500000000131212552200242015724 0ustar jorismjorism‰PNG  IHDRr#Ñ®0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï9IDATxí뎣0 …¿Ü ”æýßvíRè0íj Ò®4(GJg’_Ží¿¿øgçyÞ.€«açRLý|)Ñ\aj·nþÆmâ<–ßü`‡ÎôÊùÖ·Ù›5<ý>‹rLý•Ø­‡5;|BYº+·/*È߇öJSbKˆk:}ŒiÍi\üNù&†¥åÜ Ê]L.†üJÃá.Ž*5FvxKqYb]︱éÈŠ@͸Ëì!e4Åãî–¬F 7ðX«šÊb®½/϶ª ¥ÞŒòØ[JcdŸäÒ]3ž¤WÁªín;á7W/kÎ÷&ØI$$[•¢ su6ŒAó¨ê¶Ç6 ]3Ls“Äâ-å(WG­¸)^+\È}Z½LA4bR*J³ X_ýš`ÌàR’m‹è˜R̲byÔ/ýûо’Åü®>§Æ§¤ŠÔZIˆŒU{Œ[±lõsL©'ôº¢f¨õa#ñÞ8ÝJ2i™«ß=Èד°ÇÛº´óÔ3¡ïXÉ1ÀO¢nª8ÀûVP£uP#Àfí]Ña?kx?ÀT–N9–òj✂x/ò‰6ûàÿ²ô¢ÞËnRYy¸ZAÚ¼±)ש˜¥Fdº\mÞ~é&LáiRœ )kg Fú¸Æù¸¹œ€: ïY>¡¶)Š—Ïí à<ÔTöá'Y•>ä×ߧÃÝÔ;7VÉ$ä:ž®„ÅnJcº^BÀn]šJ€ãU24jÓBIEND®B`‚libDAI-0.3.2/doc/html/form_106.png0000644000175000017500000000100312552200243015725 0ustar jorismjorism‰PNG  IHDRJ#õlÑ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïrIDATxíÙrë †?Âf°±Þÿm+¼CÒ6ÒÞtŽFÿLHÐòK¹øR)¥Õ0'âÌ)>‰ "ÉÚ0ˆUr{Œƒ¸‰¼ pi1?,à bp·‡ùú4*2ôèLÕØ3ë­#þb‰i—¾¸Vtº›šàö_üÞgó´+±gÄeJ>l—tjOZ}hâiºIÎu ¬ÏGôÎàÃ.wùlKwS}ãŒa±6`ËQ«/ù“¢?LqËõMåàòUçκ\÷[gÛXõeŽÓ÷l¶«ºgÜuì{.ßÎÊîÒ1L·À«(­'ûH0€×°¦ƒ~š²¼³¯t–EäÒwv Àß…Iñâ\Ð^šôɺxŽ\GÍM›³Ìê`uŸÃàž†;h*NëHÈ5ª±Eï5%»èV­ ªK Jý'Ãð j©ÌQh£yÒÞ—š\œ¶”¶¥¥nn)À씚ÝgÓýÃü>Œ Júž€gIEND®B`‚libDAI-0.3.2/doc/html/form_24.png0000644000175000017500000000074312552200220015651 0ustar jorismjorism‰PNG  IHDRKiÙrì0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïRIDATxí]Ñrà “6Éÿÿí° iÒízÛÛ^r¸%>YÈÂy€bÀmåಠߗå- ·ÈûØT{ÎÜ à¶YôÀa³ðeVf·•’>Ää’í,|À=Vö[®úا,åF5i= Zê_t=]Kçi¾Ó,G>´³i•ƒ+2ó`ëO‡ñŠ¶aÎîÿéèJ6ö3›ÃÉ393ŬãJ}®µŽŽô9¸xfqØ`7‹‹ 0¸oÅ3¹I fý¥ÇÐÏBó2võWŠ=çPƒÙÉ6¸”—ÇÂÚ²ç#gç]¼÷ßÍmraÚ[|×Eã0y£µ¤êæ°ë~3¯™`fMýñ·s’x¢sYu@jåÆ”GëY.³™˜ÙlR̨Ck䆩]&ž©°‡ŽŒ¶ÖêÒ¯dË÷Oæík"ôe8Üâ ’?¿ Y bIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1LC.png0000644000175000017500000000150112552201366017050 0ustar jorismjorism‰PNG  IHDR«ˆ¯ë³PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2ÐIDATxíá’ƒ —™¾ÿ#ŸUÔ ¶w¶ñÚÌ䆭9@\SHÿRk­A JRÒU’üIWIòç]ײÖ.•1ž:L·$½€ŸëCý2]?ì:¤ínPÆôÙ¼ý÷Ï9­‹k»A’^à×Q§IHŶ%Z†Íˆ$½Â›®sšf1»~0¯óxæ: ‡«Û».Eàã®ý~ýƒë§ö«­cdÛ‘ëë€$&Šë÷«$£ý:HÒ üû¤IWIò']%ÉŸÁµÖZcàÏ \o·8²\Õ0²‘\³\Aºø“®þ¤+€?é àOºø“®þ¤+€?é àOºø“®þ¤+€?éJ­µ*I!HWIò']%ɟεì£rÿë:÷Ÿ’º6Þ³ÚwLz0õ©kß5‹­ÿØX’:þÖ{zã:¼ä}Îô²k^íº‡®í¾£GµÄ—õcºÛ~‡ËÈš‹¤®-®ãüöt©˜&©<¦Ý7I÷®ë ³X{=ëjæ¬ .‹¬­ë libDAI: File Members
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_z.html0000644000175000017500000001155712552201370020151 0ustar jorismjorism libDAI: Class Members - Functions
 

- z -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1sequentialVariableElimination.html0000644000175000017500000002316612552201370024751 0ustar jorismjorism libDAI: dai::sequentialVariableElimination Class Reference
Public Member Functions | Private Attributes | List of all members
dai::sequentialVariableElimination Class Reference

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

#include <dai/clustergraph.h>

Public Member Functions

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

Private Attributes

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

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BP__dual_1_1beliefs-members.html0000644000175000017500000000736412552201364024253 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1CBP_1_1Properties-members.html0000644000175000017500000002071712552201364023732 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_93.png0000644000175000017500000000063612552200240015662 0ustar jorismjorism‰PNG  IHDR` ªpH+0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï IDATxí]ËrÄ “Á<› ÿÿ·µ€Pf'ÛœzèÁ³f",Køàÿ§ª×àl¿"<ç#Ô)Z¨ð²ö"òáš=ülÀ]^PÉÁ^T·Oó°õÎR¨.äÚË™Ú⠿愉UÆã`Nua^,fø?ã5<{&XÐTüî´Ÿ%³óq•sEµÏ ¥™_7MŽH'ÁqPh1oÔMßØ—o´t¬¹{Ú×µ,)QIfì"P+o{5‹1½‹¬?Øœ7ÐýöºÂ* jýIãacSpÅ׸ä]¥¤Æ­ða–v¨žÆRö+põ|›}eÐ_ ½•Sî÷‘¼è~þ4¿f4}$~4»IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1CondProbEstimation.png0000644000175000017500000000126012552201364022315 0ustar jorismjorism‰PNG  IHDR•P'YÇzPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2?IDATxíË–ë Kíüÿ7ßÄ#žhÎ åÐN B Êšã8ŽíÄ!I›)©$)¦¤’¤˜:*›Ùç#Iß5„3[žiü¹÷‘ªïŠaT’Z[§xJܨÞûú•ýù=–ǵï3¨ÆÔ­žïíQ†œÝ¥ÿŒž¦ø5okoª3è̵û»$h1gšqNÕ&_m9¥å«“ libDAI: Class Members - Functions
 

- b -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_101.png0000644000175000017500000000053112552200242015724 0ustar jorismjorism‰PNG  IHDR6jn|Ä0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÈIDATxí]ŽÄ ƒ¿ð[ÚQ¹ÿm'0jW»£>îK$£”ØàÿA2Àc,öbÛºgÀcD—… àrþËù’5±µ¤x©í™¼Sç_=|”%ÛíTŽ §i“úÒ­'Q<îÝRÑåU‘dÔYìæð´À.Íœž´ËÙ§›IÍÇp™ãH•Ú¦GMR—ë´ŸfµGefõ¦†„ žÎuƒ¹Æ±pG.¥¨l^š”bŠu“_!íš÷§ïåö°>‡ 𿼅7yžѬy2IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1BP-members.html0000644000175000017500000005462112552201364020674 0ustar jorismjorism libDAI: Member List
dai::BP Member List

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

_edge2lutdai::BPprotected
_edgesdai::BPprotected
_itersdai::BPprotected
_lutdai::BPprotected
_maxdiffdai::BPprotected
_oldBeliefsFdai::BPprotected
_oldBeliefsVdai::BPprotected
_sentMessagesdai::BPprotected
_updateSeqdai::BPprotected
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const Var &v) const dai::BPinlinevirtual
belief(const VarSet &vs) const dai::BPvirtual
beliefF(size_t I) const dai::BPvirtual
beliefs() const dai::BPvirtual
beliefV(size_t i) const dai::BPvirtual
BP()dai::BPinline
BP(const FactorGraph &fg, const PropertySet &opts)dai::BPinline
BP(const BP &x)dai::BPinline
calcBeliefF(size_t I, Prob &p) const dai::BPinlineprotectedvirtual
calcBeliefV(size_t i, Prob &p) const dai::BPprotectedvirtual
calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const dai::BPprotectedvirtual
calcNewMessage(size_t i, size_t _I)dai::BPprotectedvirtual
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clearSentMessages()dai::BPinline
clone() const dai::BPinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::BPinlinevirtual
construct()dai::BPprotectedvirtual
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findMaximum() const dai::BPinlinevirtual
findMaxResidual(size_t &i, size_t &_I)dai::BPprotected
getProperties() const dai::BPvirtual
getSentMessages() const dai::BPinline
identify() const dai::InfAlginlinevirtual
ind_t typedefdai::BPprotected
index(size_t i, size_t _I) const dai::BPinlineprotected
index(size_t i, size_t _I)dai::BPinlineprotected
init()dai::BPvirtual
init(const VarSet &ns)dai::BPvirtual
Iterations() const dai::BPinlinevirtual
logZ() const dai::BPvirtual
LutType typedefdai::BPprotected
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::BPinlinevirtual
message(size_t i, size_t _I) const dai::BPinlineprotected
message(size_t i, size_t _I)dai::BPinlineprotected
name() const dai::BPinlinevirtual
newMessage(size_t i, size_t _I) const dai::BPinlineprotected
newMessage(size_t i, size_t _I)dai::BPinlineprotected
operator=(const BP &x)dai::BPinline
printProperties() const dai::BPvirtual
props (defined in dai::BP)dai::BP
recordSentMessagesdai::BP
residual(size_t i, size_t _I) const dai::BPinlineprotected
residual(size_t i, size_t _I)dai::BPinlineprotected
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()dai::BPvirtual
setMaxIter(size_t maxiter)dai::BPinlinevirtual
setProperties(const PropertySet &opts)dai::BPvirtual
updateMessage(size_t i, size_t _I)dai::BPprotected
updateResidual(size_t i, size_t _I, Real r)dai::BPprotected
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_21.png0000644000175000017500000000033212552200220015640 0ustar jorismjorism‰PNG  IHDR ŠœÖ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIIDATxíË €0 C_Zå³ÿ¶ôD}c;Rl'^à—žÕUÕþ)ÖkÌ8< èÊ<$f&vˆÇ`ê7ë;¤iûØË ƒŠR*Ù…«IEND®B`‚libDAI-0.3.2/doc/html/fileformats.html0000644000175000017500000002717112552201364017112 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1ParameterEstimation.html0000644000175000017500000006644312552201367022730 0ustar jorismjorism libDAI: dai::ParameterEstimation Class Reference
Public Types | Public Member Functions | Static Public Member Functions | Static Private Member Functions | Static Private Attributes | List of all members
dai::ParameterEstimation Class Referenceabstract

Base class for parameter estimation methods. More...

#include <dai/emalg.h>

Inheritance diagram for dai::ParameterEstimation:
dai::CondProbEstimation

Public Types

typedef ParameterEstimation *(* ParamEstFactory) (const PropertySet &)
 Type of pointer to factory function. More...
 

Public Member Functions

virtual ~ParameterEstimation ()
 Virtual destructor for deleting pointers to derived classes. More...
 
virtual ParameterEstimation * clone () const =0
 Virtual copy constructor. More...
 
virtual Prob estimate (const Prob &p)
 Estimate the factor using the provided expectations. More...
 
virtual Prob parametersToFactor (const Prob &params)=0
 Convert a set of estimated parameters to a factor. More...
 
virtual Prob parameters (const Prob &p)=0
 Return parameters for the estimated factor, in a format specific to the parameter estimation. More...
 
virtual size_t probSize () const =0
 Returns the size of the Prob that should be passed to estimate and parameters. More...
 
virtual const std::string & name () const =0
 
virtual const PropertySet & properties () const =0
 

Static Public Member Functions

static ParameterEstimation * construct (const std::string &method, const PropertySet &p)
 General factory method that constructs the desired ParameterEstimation subclass. More...
 
static void registerMethod (const std::string &method, const ParamEstFactory &f)
 Register a subclass so that it can be used with construct(). More...
 

Static Private Member Functions

static void loadDefaultRegistry ()
 Registers default ParameterEstimation subclasses (currently, only CondProbEstimation). More...
 

Static Private Attributes

static std::map< std::string, ParamEstFactory > * _registry = NULL
 A static registry containing all methods registered so far. More...
 

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 ( )
inlinevirtual

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
methodName of the subclass that should be constructed;
pParameters 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_METHODif the requested method is not registered.
static void dai::ParameterEstimation::registerMethod ( const std::string &  method,
const ParamEstFactory &  f 
)
inlinestatic

Register a subclass so that it can be used with construct().

virtual Prob dai::ParameterEstimation::estimate ( const Prob &  p)
inlinevirtual

Estimate the factor using the provided expectations.

virtual Prob dai::ParameterEstimation::parametersToFactor ( const Prob &  params)
pure virtual

Convert a set of estimated parameters to a factor.

Implemented in dai::CondProbEstimation.

virtual Prob dai::ParameterEstimation::parameters ( const Prob &  p)
pure virtual

Return parameters for the estimated factor, in a format specific to the parameter estimation.

Implemented in dai::CondProbEstimation.

virtual size_t dai::ParameterEstimation::probSize ( ) const
pure virtual

Returns the size of the Prob that should be passed to estimate and parameters.

Implemented in dai::CondProbEstimation.

void dai::ParameterEstimation::loadDefaultRegistry ( )
staticprivate

Registers default ParameterEstimation subclasses (currently, only CondProbEstimation).

Member Data Documentation

std::map< std::string, ParameterEstimation::ParamEstFactory > * dai::ParameterEstimation::_registry = NULL
staticprivate

A static registry containing all methods registered so far.

The documentation for this class was generated from the following files:
  • include/dai/emalg.h
  • src/emalg.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_74.png0000644000175000017500000000054412552200234015662 0ustar jorismjorism‰PNG  IHDR2.M}µ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÓIDATxí[nÄ0E¯ñÛö¿Û^'NjuÒ&_ó‡DP@‡—Y|DS9Eà‰6GQ p©R‚ÿó_Ì-~«TÀ­á{¤ŽuqÜ#–ùYúz€³FBNêAP3î¶=F¶Ý3šÓ˜ì­sâÍ0ÐÏœ+âXÛiÑ‘/O¿ƃÓóu9~änŽŽ{ÜmôªÊg–zY¥ âq6KûeJïk—ʤ Êègš{;á—u.|3®%ÞÓ(ü«‰pæzˆæP& 7ÓßGoÌ<±¤64IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1EMAlg.html0000644000175000017500000013225212552201365017666 0ustar jorismjorism libDAI: dai::EMAlg Class Reference
Public Member Functions | Static Public Attributes | Private Attributes | List of all members
dai::EMAlg Class Reference

EMAlg performs Expectation Maximization to learn factor parameters. More...

#include <dai/emalg.h>

Public Member Functions

 EMAlg (const Evidence &evidence, InfAlg &estep, std::vector< MaximizationStep > &msteps, const PropertySet &termconditions)
 Construct an EMAlg from several objects. More...
 
 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. More...
 
void setTermConditions (const PropertySet &p)
 Change the conditions for termination. More...
 
bool hasSatisfiedTermConditions () const
 Determine if the termination conditions have been met. More...
 
Real logZ () const
 Return the last calculated log likelihood. More...
 
size_t Iterations () const
 Returns number of iterations done so far. More...
 
const InfAlg & eStep () const
 Get the E-step method used. More...
 
Real iterate ()
 Iterate once over all maximization steps. More...
 
Real iterate (MaximizationStep &mstep)
 Iterate over a single MaximizationStep. More...
 
void run ()
 Iterate until termination conditions are satisfied. More...
 

Static Public Attributes

static const std::string MAX_ITERS_KEY
 Key for setting maximum iterations. More...
 
static const size_t MAX_ITERS_DEFAULT = 30
 Default maximum iterations. More...
 
static const std::string LOG_Z_TOL_KEY
 Key for setting likelihood termination condition. More...
 
static const Real LOG_Z_TOL_DEFAULT = 0.01
 Default likelihood tolerance. More...
 

Private Attributes

const Evidence & _evidence
 All the data samples used during learning. More...
 
InfAlg & _estep
 How to do the expectation step. More...
 
std::vector< MaximizationStep > _msteps
 The maximization steps to take. More...
 
size_t _iters
 Number of iterations done. More...
 
std::vector< Real > _lastLogZ
 History of likelihoods. More...
 
size_t _max_iters
 Maximum number of iterations. More...
 
Real _log_z_tol
 Convergence tolerance. More...
 

Iterator interface

typedef std::vector< MaximizationStep >::iterator s_iterator
 Iterator over the maximization steps. More...
 
typedef std::vector< MaximizationStep >::const_iterator const_s_iterator
 Constant iterator over the maximization steps. More...
 
s_iterator s_begin ()
 Returns iterator that points to the first maximization step. More...
 
const_s_iterator s_begin () const
 Returns constant iterator that points to the first maximization step. More...
 
s_iterator s_end ()
 Returns iterator that points beyond the last maximization step. More...
 
const_s_iterator s_end () const
 Returns constant iterator that points beyond the last maximization step. More...
 

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
evidenceSpecifies the observed evidence
estepInference algorithm to be used for the E-step
mstepsVector of maximization steps, each of which is a group of parameter estimation tasks
termconditionsTermination 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:
  • include/dai/emalg.h
  • src/emalg.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1Exception.html0000644000175000017500000007715712552201365020713 0ustar jorismjorism libDAI: dai::Exception Class Reference
Public Types | Public Member Functions | Private Attributes | Static Private Attributes | List of all members
dai::Exception Class Reference

Error handling in libDAI is done by throwing an instance of the Exception class. More...

#include <dai/exceptions.h>

Inheritance diagram for dai::Exception:

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 char *filename, const char *function, const char *line, const std::string &detailedMsg)
 Constructor. More...
 
 ~Exception () throw ()
 Destructor. More...
 
Code getCode () const
 Returns error code of this exception. More...
 
Code code () const
 Returns error code of this exception. More...
 
const std::string & getMsg () const
 Returns short error message of this exception. More...
 
const std::string & getDetailedMsg () const
 Returns detailed error message of this exception. More...
 
const std::string & getFilename () const
 Returns filename where this exception was thrown. More...
 
const std::string & getFunction () const
 Returns function name in which this exception was thrown. More...
 
const std::string & getLine () const
 Returns line number where this exception was thrown. More...
 
const std::string & message (const Code c) const
 Returns error message corresponding to an error code. More...
 

Private Attributes

Code _errorcode
 Contains the error code of this exception. More...
 
std::string _detailedMsg
 Contains the detailed message of this exception, if any. More...
 
std::string _filename
 Contains the filename where this exception was thrown. More...
 
std::string _function
 Contains the function name in which this exception was thrown. More...
 
std::string _line
 Contains the line number where this exception was thrown. More...
 

Static Private Attributes

static std::string ErrorStrings [NUM_ERRORS]
 Error messages corresponding to the exceptions enumerated above. More...
 

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:
example.cpp, and 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 char *  filename,
const char *  function,
const char *  line,
const std::string &  detailedMsg 
)
inline

Constructor.

dai::Exception::~Exception ( )
throw (
)
inline

Destructor.

Member Function Documentation

Code dai::Exception::getCode ( ) const
inline

Returns error code of this exception.

Examples:
example.cpp.
Code dai::Exception::code ( ) const
inline

Returns error code of this exception.

Deprecated:
Please use dai::Exceptions::getCode() instead
const std::string& dai::Exception::getMsg ( ) const
inline

Returns short error message of this exception.

const std::string& dai::Exception::getDetailedMsg ( ) const
inline

Returns detailed error message of this exception.

const std::string& dai::Exception::getFilename ( ) const
inline

Returns filename where this exception was thrown.

const std::string& dai::Exception::getFunction ( ) const
inline

Returns function name in which this exception was thrown.

const std::string& dai::Exception::getLine ( ) const
inline

Returns line number where this exception was thrown.

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::_detailedMsg
private

Contains the detailed message of this exception, if any.

std::string dai::Exception::_filename
private

Contains the filename where this exception was thrown.

std::string dai::Exception::_function
private

Contains the function name in which this exception was thrown.

std::string dai::Exception::_line
private

Contains the line number where this exception was thrown.

std::string dai::Exception::ErrorStrings
staticprivate
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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/deprecated.html0000644000175000017500000000423712552201364016675 0ustar jorismjorism libDAI: Deprecated List
Deprecated List
Member dai::Exception::code () const
Please use dai::Exceptions::getCode() instead
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_i.html0000644000175000017500000001331312552201370020140 0ustar jorismjorism libDAI: Class Members - Variables
 

- i -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/alldai_8h_source.html0000644000175000017500000005755712552201363020016 0ustar jorismjorism libDAI: include/dai/alldai.h Source File
alldai.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
18 #ifndef __defined_libdai_alldai_h
19 #define __defined_libdai_alldai_h
20 
21 
22 #include <dai/dai_config.h>
23 #include <string>
24 #include <dai/daialg.h>
25 #include <dai/properties.h>
26 #include <dai/exactinf.h>
27 #include <dai/evidence.h>
28 #include <dai/emalg.h>
29 #ifdef DAI_WITH_BP
30  #include <dai/bp.h>
31 #endif
32 #ifdef DAI_WITH_FBP
33  #include <dai/fbp.h>
34 #endif
35 #ifdef DAI_WITH_TRWBP
36  #include <dai/trwbp.h>
37 #endif
38 #ifdef DAI_WITH_MF
39  #include <dai/mf.h>
40 #endif
41 #ifdef DAI_WITH_HAK
42  #include <dai/hak.h>
43 #endif
44 #ifdef DAI_WITH_LC
45  #include <dai/lc.h>
46 #endif
47 #ifdef DAI_WITH_TREEEP
48  #include <dai/treeep.h>
49 #endif
50 #ifdef DAI_WITH_JTREE
51  #include <dai/jtree.h>
52 #endif
53 #ifdef DAI_WITH_MR
54  #include <dai/mr.h>
55 #endif
56 #ifdef DAI_WITH_GIBBS
57  #include <dai/gibbs.h>
58 #endif
59 #ifdef DAI_WITH_CBP
60  #include <dai/cbp.h>
61 #endif
62 #ifdef DAI_WITH_DECMAP
63  #include <dai/decmap.h>
64 #endif
65 #ifdef DAI_WITH_GLC
66  #include <dai/glc.h>
67 #endif
68 
69 
71 namespace dai {
72 
73 
75 
77 std::map<std::string, InfAlg *>& builtinInfAlgs();
78 
79 
81 /* These are the names of the algorithms that were compiled in and can be
82  * given to \ref newInfAlg and \ref newInfAlgFromString.
83  * \return A set of strings, each one corresponding with the name of an available inference algorithm.
84  * \note The set is returned by value because it will be reasonably small
85  * enough and this function is expected to be called infrequently.
86  */
87 std::set<std::string> builtinInfAlgNames();
88 
89 
91 
97 InfAlg *newInfAlg( const std::string &name, const FactorGraph &fg, const PropertySet &opts );
98 
99 
101 
106 InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg );
107 
108 
110 
116 InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg, const std::map<std::string,std::string> &aliases );
117 
118 
120 std::pair<std::string, PropertySet> parseNameProperties( const std::string &s );
121 
122 
124 
128 std::pair<std::string, PropertySet> parseNameProperties( const std::string &s, const std::map<std::string,std::string> &aliases );
129 
130 
132 
136 std::map<std::string,std::string> readAliasesFile( const std::string &filename );
137 
138 
139 } // end of namespace dai
140 
141 
167 #endif
evidence.h
Defines class Evidence, which stores multiple observations of joint states of variables.
bp.h
Defines class BP, which implements (Loopy) Belief Propagation.
dai::parseNameProperties
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".
Definition: alldai.cpp:112
lc.h
Defines class LC, which implements loop corrections for approximate inference.
dai::readAliasesFile
std::map< std::string, std::string > readAliasesFile(const std::string &filename)
Reads aliases from file named filename.
Definition: alldai.cpp:152
hak.h
Defines class HAK, which implements a variant of Generalized Belief Propagation.
dai::newInfAlgFromString
InfAlg * newInfAlgFromString(const std::string &nameOpts, const FactorGraph &fg)
Constructs a new inference algorithm.
Definition: alldai.cpp:100
mr.h
Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo.
cbp.h
Defines class CBP, which implements Conditioned Belief Propagation.
emalg.h
Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation a...
jtree.h
Defines class JTree, which implements the junction tree algorithm.
glc.h
Defines classes GLC and Cobweb, which implement the "Generalized Loop Correction method".
dai::builtinInfAlgNames
std::set< std::string > builtinInfAlgNames()
Returns a set of names of all available inference algorithms.
Definition: alldai.cpp:83
decmap.h
Defines class DecMAP, which constructs a MAP state by decimation.
dai::builtinInfAlgs
std::map< std::string, InfAlg * > & builtinInfAlgs()
Returns a map that contains for each built-in inference algorithm its name and a pointer to an object...
Definition: alldai.cpp:78
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
gibbs.h
Defines class Gibbs, which implements Gibbs sampling.
dai
Namespace for libDAI.
Definition: alldai.cpp:16
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
fbp.h
Defines class FBP, which implements Fractional Belief Propagation.
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
mf.h
Defines class MF which implements the Mean Field algorithm.
trwbp.h
Defines class TRWBP, which implements Tree-Reweighted Belief Propagation.
dai::newInfAlg
InfAlg * newInfAlg(const std::string &name, const FactorGraph &fg, const PropertySet &opts)
Constructs a new inference algorithm.
Definition: alldai.cpp:91
exactinf.h
Defines ExactInf class, which can be used for exact inference on small factor graphs.
treeep.h
Defines class TreeEP, which implements Tree Expectation Propagation.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_17.png0000644000175000017500000000033012552200217015651 0ustar jorismjorism‰PNG  IHDR a«¬Õ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïGIDATxíQ À0CS;7§ïÛYjAöÑ"/`ô ð7õ¶ñzÕ5™Ð'WFŒé©Á¥ì…û!D§Y&s‘8¾Þ´àLîïÑXsIEND®B`‚libDAI-0.3.2/doc/html/sync_on.png0000644000175000017500000000151512552201363016060 0ustar jorismjorism‰PNG  IHDRàw=øIDATxíÝ_HTYÀñï8ã¤ó§i§4-g6ÆËÕ&kQ)¨Ô!Š0ÒURKÚ…„ê¡/»PEÁ>ìK-+KÁ²Ñ.Y”¾dEPaA‰ø°¥¶›ZSÓïÜ;3wºŠ–¯—߯gfîïœsçœWKÇñ.€ÉøD­¨a‘'¬âq_ôˆk¢ÀŒ ÀDŽøQ´ÄïC¨¶åñÏÿgÅ ñ 0„Y‚:qZ¦Á)~õâ€èLý0HVñ× žz-¿‰C“%¨g¦˜6€é8%Úõ¬ëwêÙUÏ¿˜ª³Ä }? ?€·3ÀÀž©Š À”K• @hà a±ðaÇæUe‹ sù~ë2²ì“&Ú&B*AÄljæºììi*˨,Ëçí»÷oÆ£T”,d[˜¼3-*ÁÀ…>å‡Ë çLÉŸçfk˜Ò éw#*AEjKUy>ûšËÉõ&{µ¢8—m5Ki¬ jjƒD*¿NŽÖigwÃ7Dª’mz骹úKÛ¾±ˆ¶M!æ¤ÍkÐ?šoý¬_åÓlXí#Ò~–¸¬ê×ÒÑXŠÓ‘ùRÙ*Eû‚ՂדðEÜ;6«e"Q(²Ù=–¿Ezæ5Kؼָ_ 1òzBªJë ±XŒì96åªjL^7{ùãJÑ÷1½i@%8'7M©_\Qœ#ÓUŒËñýÿyõ Wo Éx8¼s¥v¯ªì|×SnÜ q_m Ýé î>bèÕí[JX,½4[Tú{R£ë¼ôˆ¾þa€tÝjjzzÅ'ÅìȶiIžŽòwÏs ¡€—ÕKøõâC^ŽŒ˜Y­¨µÉ%6¨´êˆº]vÛðhâ½iWv–hôëê°Ò¨¾'æÌ‚·ñ|[ßìúÅ^€YrD=<ýDû]äÇ÷s€Ïõ‹8™ºCì? À ¨—t4õá©Ž¡Jã‡W‹É± îr¼cjMɘìx| šE©øNÔ‰œøA¢þ«–€Z¼ñ‡jó î#™§¢¢4gIEND®B`‚libDAI-0.3.2/doc/html/license.html0000644000175000017500000000730212552201363016212 0ustar jorismjorism libDAI: License
License

License

libDAI is free software; you can redistribute it and/or modify it under the terms of the BSD 2-clause license (also known as the FreeBSD license), which can be found in the accompanying LICENSE file.

[Note: up to and including version 0.2.7, libDAI was licensed under the GNU General Public License (GPL) version 2 or higher.]

libDAI license (similar to FreeBSD license)

Copyright (c) 2006-2011, the libDAI authors.  All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_111.png0000644000175000017500000000052612552200244015733 0ustar jorismjorism‰PNG  IHDRà½Üý0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÅIDATxí]ŽÄ ƒ¿ðÿ£nïÛ1Ó.¨‹fžö5ÂÐ&•í„à_‘,ìðY›jÉlhN4€ Êè¡ÿfBIïÓ•lü Ý¢·ºÜœb„2ŽÁy˜„y>‡X¨ƒ¯ê“>lϲÅCìÆ.…ÕßѺr‰KâêÈ­¾3¥áÍŸ;2ñÐ$ÊlXKóó§dßÒØ­=#ÉÄ°~I•[ó¢µU™ e:øçꇫºcŒà¾—ú €'Réßœé/zÄ sQC•¼çIEND®B`‚libDAI-0.3.2/doc/html/functions_v.html0000644000175000017500000001644112552201370017127 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- v -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1BBPCostFunction.html0000644000175000017500000002501312552201364021676 0ustar jorismjorism libDAI: dai::BBPCostFunction Class Reference
Public Member Functions | List of all members
dai::BBPCostFunction Class Reference

Predefined cost functions that can be used with BBP. More...

#include <dai/bbp.h>

Inherits BBPCostFunctionBase.

Public Member Functions

 BBPCostFunction ()
 Default constructor. More...
 
 BBPCostFunction (const BBPCostFunctionBase &x)
 Construct from BBPCostFunctionBase x. More...
 
bool needGibbsState () const
 Returns whether this cost function depends on having a Gibbs state. More...
 
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. More...
 
BBPCostFunction & operator= (const BBPCostFunctionBase &x)
 Assignment operator. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_64.png0000644000175000017500000000055512552200231015660 0ustar jorismjorism‰PNG  IHDR0gp ƒ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÜIDATxí]ÛnÅ0s¹öœüÿߜӮTiÚÃÞPxHƒÁvùø—”®¾Oi3¿ÜNšð˜}À-g€§ü#@U´ÈïY1Ë0ÔJ@¨îÜEUåw†¾âÕ©T> ÷Í $n´‹‰û2Q^U(›WíQXÙ½¯F/J°c¢ê£ÁÔ£îæ33íΓc'·uo£ÑçB€‹ªÎ[ŒJÐÝ3K~7—POçÚå?”¥!Ãy=Élb‹,¯×Õ`›|RÎfaÖgЉø±lbOË÷6w†Á@Ž±IEND®B`‚libDAI-0.3.2/doc/html/namespacemembers_type.html0000644000175000017500000000745112552201370021143 0ustar jorismjorism libDAI: Namespace Members
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1RootedTree.png0000644000175000017500000000107512552201367020635 0ustar jorismjorism‰PNG  IHDR„Pï5-¬PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2ÌIDATxíÝ’ƒ FOnš÷ãµÊOHít·8;™ID%À!|Ñ[DDV;¢ªºÖ" TÕY‘æ`“Þ]ëåæÒl‘/6æ ˆ'÷¿y–ç«û³—gŸ_áxzö×ܤ ì<ªj­@ˆj5û0l*\ÙÀÂÌf†¹1­ä2a”ò3ÈDÒÄp-†?ŽA`Îbž±ƒp eÂBTµZ +LŸiÑÊöu&f©<Í„¨V3ÁVïM´ÓµÕñž&Òq”êÈÜYyµ:jõÕ×'ÞªUÕ¿õó…¾Ñ~¿TÕØ·21>‡ø‹ªªµ€¸„ˆÈbøЫýÇ (î±1¬§¸DTG@xˆ€œD@Î" g€³€ÀÙYíÀZˆ€œM!jW¹;Ä 8óo¶9“è.øEÿª{ßBŒÇ ý"Uﱡš‰|IÝ›z)ÃÒˆýÁ†t~ ±Në+mÛï,D Ðú "wåµ­&&>¿q,êŽc Q[ˆÔs.ÕW¦qšfÂ&Ðgb®Ô뚸1ÐÄgÇa«ãи¦—ü¤:ÚP€Öã³€³€ÀÙ!"²ØULq†ÈÜõIEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1BP_1_1Properties.html0000644000175000017500000003650612552201364022202 0ustar jorismjorism libDAI: dai::BP::Properties Struct Reference
Public Member Functions | Public Attributes | List of all members
dai::BP::Properties Struct Reference

Parameters for BP. More...

#include <dai/bp.h>

Public Member Functions

 DAI_ENUM (UpdateType, SEQFIX, SEQRND, SEQMAX, PARALL)
 Enumeration of possible update schedules. More...
 
 DAI_ENUM (InfType, SUMPROD, MAXPROD)
 Enumeration of inference variants. More...
 

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr) More...
 
size_t maxiter
 Maximum number of iterations. More...
 
double maxtime
 Maximum time (in seconds) More...
 
Real tol
 Tolerance for convergence test. More...
 
bool logdomain
 Whether updates should be done in logarithmic domain or not. More...
 
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping) More...
 
UpdateType updates
 Message update schedule. More...
 
InfType inference
 Inference variant. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_39.png0000644000175000017500000000065712552200224015667 0ustar jorismjorism‰PNG  IHDRgdòY0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIDATxím“ƒ „^TR,þÿ{ Rˆö˜»ÞÌ}sXËL²›d©|ø78€÷0ƒÀÖmÉðÏà3¸mÚò-Ñ©?GÒó<îZ!šc³éÔâ¤<¨dsñéªe‚øº½ZêDn•¶:ò¤}:´¦®ß¦TRÍ<ŸÃábøŠ|ñ©hù9Õ‰}¿%Uðg0 Àš|ñé([먎Jª‰ùçÈE©“Ü¡È»OÎØjãfK¡Z§$Kýhrj‰¹—ÑÙ¸—ßköoMžVçü”l8$MeÓêäg‰G&-YÖövµ–·ß¿5Ù¯³,Hí‡uÖ€\ý¥óð%h´žð¾Ò™Î;À×`n¸š] Ì»YÃwÞ¾ˆÑs7‘V€ÔÝözø QNPC¥ïÃ4 n~Ûà%Þ‹æsŸ¢"à¼Û1À u—dDms§$Tûj©X%s݆&9}u åÂü9juÊlGÔ³íà}ØÕ£Áû#¾DîÞE;™4§†nÚÕ0Å¿wåžÒ?…ra^ôõ"ç‹h€z¶}ì`mVÝÜo §“Û .yw)˜×ÇeÜÑ[Å»³ÏâwAÖ·ªˆSÎ=¿ÏA ëÕ*D OöÀû.Ћh€j^øvs°ÜÒ¢A×Q Ts5x’|æÝ…¤ê|•ÞvÎWØŒ 1Ÿ*ºÂû¬â}V™û%„»B*°"uZ­Å±ü0¥äGùǼ28¡,ß]G; žÙ'ã…rn[M¦,P먵.„}‡ÌjË­ÕW±sG-ûÇ%–ôx[ó72n‚|(Á ‹Þú%û÷AöÉïy'YèGy¤½LpZ3k% ò£­W»EêéÒ`-Ÿf+*Ðêë1š[Š9=UTÿâsz­Gf 9d€¡ð…Á™÷tLòc¼v¬n!î:fÞ•—qäýCšy$Ëåf;H W™jY8ÎòÈ\#ÉñÝcžíµxº6ØÁ®±¬¡å@«Öˆæ–þLOyß|n§p†¤^z¯šÖQ3&i ܼ]‚3ï)ëƒc»íœÂŒ7!:]yßëŒÔŽK?ÂgÜRºeaò ±Æf‰ÖÆ–’qÑåÀm\&ÍðÒ §Žä@Í°¤|¯¢ÊÜ|Ö‡p€d™VFY8Aª(3˜åRßm<¨(nÉñ^£¶+äEð¯x³Ô"{‹¬ŠYÆ÷ZgŸÄI0YZ1‹ãDÿä,´4 ù"HÉiˆ¹ö®ô©Âû=ý™Ÿ±ixÏj?¥P¯¢ÊÜ|žÇT®¤`ìz»·FÔs“à"É@Çújón¦I¾©míö—¥E:&ïÚ%£AK@VOR_­V»"-ïÆ 1Ï ´vù>-±wÄ`¬§x¾b.z]î_1—Þð|–)}3:%õv Pææstgå±Ï0»x‰éâJ Ï»Üì«q¸Xeë]8Ã.¹+ñ,c~,²Ÿˆö.Ó]ç¼_XU±V u«y]¡s€ŽÜÈ]zÈ=ºŠà„Ù=¸x­mue¼†Û5‡µÇçЯûj½$I"@ êEþòíðñe¦öxY“Tí*(7 €oàGÞ÷r£KEç^ÁìzC”P€=®yä}1Wç~¨Ò]źƒþjŸ¥ àx+ÚâÔ¸wЭhŒ1ã#DÙvÓ„KM‡ØÖ€jÚ¡Ù3:Ú!ìæ¹%è%þ¿ØòÐð÷PJÕàˆç—ë%»ÆXkùYÞÿvyø\yoàSx÷à ÐðvÅ<¶xצ>ƒÎ;ÀÇ°fAÛ4T›w«E^!ÐyøÊ?Ô»âÑëà»X”±SRÍm¹C^1tÞ¾‚[ÕWÝ}®Õ~ƒÐ]Ê}±¿ «î³èø-ŒCu!::þ=üÿ‘$+Ä\¸IEND®B`‚libDAI-0.3.2/doc/html/namespacemembers_enum.html0000644000175000017500000000532112552201370021120 0ustar jorismjorism libDAI: Namespace Members
 
  • ProbDistType : dai
  • ProbNormType : dai
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_133.png0000644000175000017500000000113212552200251015727 0ustar jorismjorism‰PNG  IHDR’‡wd0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÉIDATxíËzë „.6àØÉû¿mG7c7Í*]È ÂŒF#A·ÿ à76€šŸðîê>já:pJ À‡m›ûYþ«”\pǼ €wìêO”\r[ZÎõÊnÍó à{…úxÖÒ6Ù¡ƒ›óž”!F™Î€³…öD§Ï\ ^,Ž9d À?öŒ C®ÐN{\;-Ë}â¯uI›‹Z>¢às94‰VPÒ.Ý´É7€l@ú1׃u÷_JÇ)7g*ÈY“rÛäÖŸNrÃö†íêç›ü¢"ªÉÜ÷c0€XÅ.Czµ—nN ¦E©`t?k&¥Z]/“¾œ°D£¤×"4­UéÞ¾^4O¨ó¦Þz¦äjbíSÈ“2Ðf‹¦*%¤òŸç˜¬ŒZ6ÿR¶0U´R“ïÞ®X&O¨N™ŠR*öh^)µÊßK1ÇHýµˆA]é?^c¯R-ÿICõÚQýʤŸ£JG”b§eP_OZ %Z(ÛÒ‡´Ü«ÐI%hËñäÿc¿mG•MåA),Vã–âõqºëî4Þߪ=ù÷#ºðú8Búa"ù±»FÛCù‘ù·Tµ¡ÏKp`' œ© ð7ì 7/ a¸8….IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1ClusterGraph.html0000644000175000017500000013036712552201364021350 0ustar jorismjorism libDAI: dai::ClusterGraph Class Reference
Private Attributes | List of all members
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>

Public Member Functions

Constructors and destructors
 ClusterGraph ()
 Default constructor. More...
 
 ClusterGraph (const std::vector< VarSet > &cls)
 Construct from vector of VarSet 's. More...
 
 ClusterGraph (const FactorGraph &fg, bool onlyMaximal)
 Construct from a factor graph. More...
 
Queries
const BipartiteGraph & bipGraph () const
 Returns a constant reference to the graph structure. More...
 
size_t nrVars () const
 Returns number of variables. More...
 
const std::vector< Var > & vars () const
 Returns a constant reference to the variables. More...
 
const Var & var (size_t i) const
 Returns a constant reference to the i'th variable. More...
 
size_t nrClusters () const
 Returns number of clusters. More...
 
const std::vector< VarSet > & clusters () const
 Returns a constant reference to the clusters. More...
 
const VarSet & cluster (size_t I) const
 Returns a constant reference to the I'th cluster. More...
 
size_t findVar (const Var &n) const
 Returns the index of variable n. More...
 
size_t findCluster (const VarSet &cl) const
 Returns the index of a cluster cl. More...
 
VarSet Delta (size_t i) const
 Returns union of clusters that contain the i 'th variable. More...
 
VarSet delta (size_t i) const
 Returns union of clusters that contain the i 'th (except this variable itself) More...
 
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. More...
 
bool isMaximal (size_t I) const
 Returns true if cluster I is not contained in a larger cluster. More...
 
Operations
size_t insert (const VarSet &cl)
 Inserts a cluster (if it does not already exist) and creates new variables, if necessary. More...
 
ClusterGraph & eraseNonMaximal ()
 Erases all clusters that are not maximal. More...
 
ClusterGraph & eraseSubsuming (size_t i)
 Erases all clusters that contain the i 'th variable. More...
 
VarSet elimVar (size_t i)
 Eliminates variable with index i, without deleting the variable itself. More...
 
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. More...
 

Private Attributes

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

Input/Ouput

std::string toString () const
 Formats a ClusterGraph as a string. More...
 
std::ostream & operator<< (std::ostream &os, const ClusterGraph &cl)
 Writes a ClusterGraph to an output stream. More...
 

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
std::string dai::ClusterGraph::toString ( ) const
inline

Formats a ClusterGraph as a string.

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
EliminationChoiceshould support "size_t operator()( const ClusterGraph &cl, const std::set<size_t> &remainingVars )"
Parameters
ffunction object which returns the next variable index to eliminate; for example, a dai::greedyVariableElimination object.
maxStatesmaximum total number of states of all clusters in the output cluster graph (0 means no limit).
Exceptions
OUT_OF_MEMORYif 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_68.png0000644000175000017500000000032112552200232015654 0ustar jorismjorism‰PNG  IHDR U.T±0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï@IDATxíÁ À ¶H³ÿ¶P¹Ÿ>:‚%Kg[ò ÿ>·D5FWàUõ½çÞÄùäC<¡õ÷¤˜]/1 ÚÅ.DIEND®B`‚libDAI-0.3.2/doc/html/dir_61368b5fb8241c85edf404d1bec8468f.html0000644000175000017500000000552612552201370022025 0ustar jorismjorism libDAI: include/dai/matlab Directory Reference
matlab Directory Reference

Files

file  matlab.h [code]
 Defines some utility functions for interfacing with MatLab.
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_e.html0000644000175000017500000002117312552201370020117 0ustar jorismjorism libDAI: Class Members - Functions
 

- e -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1ClusterGraph-members.html0000644000175000017500000002453412552201364022776 0ustar jorismjorism libDAI: Member List
dai::ClusterGraph Member List

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

_clustersdai::ClusterGraphprivate
_Gdai::ClusterGraphprivate
_varsdai::ClusterGraphprivate
adj(size_t i1, size_t i2) const dai::ClusterGraphinline
bipGraph() const dai::ClusterGraphinline
cluster(size_t I) const dai::ClusterGraphinline
ClusterGraph()dai::ClusterGraphinline
ClusterGraph(const std::vector< VarSet > &cls)dai::ClusterGraph
ClusterGraph(const FactorGraph &fg, bool onlyMaximal)dai::ClusterGraph
clusters() const dai::ClusterGraphinline
Delta(size_t i) const dai::ClusterGraphinline
delta(size_t i) const dai::ClusterGraphinline
elimVar(size_t i)dai::ClusterGraphinline
eraseNonMaximal()dai::ClusterGraphinline
eraseSubsuming(size_t i)dai::ClusterGraphinline
findCluster(const VarSet &cl) const dai::ClusterGraphinline
findVar(const Var &n) const dai::ClusterGraphinline
insert(const VarSet &cl)dai::ClusterGraphinline
isMaximal(size_t I) const dai::ClusterGraphinline
nrClusters() const dai::ClusterGraphinline
nrVars() const dai::ClusterGraphinline
operator<<(std::ostream &os, const ClusterGraph &cl)dai::ClusterGraphfriend
toString() const dai::ClusterGraphinline
var(size_t i) const dai::ClusterGraphinline
VarElim(EliminationChoice f, size_t maxStates=0) const dai::ClusterGraphinline
vars() const dai::ClusterGraphinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1TRWBP.png0000644000175000017500000000204312552201370017445 0ustar jorismjorism‰PNG  IHDR«ÀLc²PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2²IDATxím’ê ;M•÷?ò‹ùwWŸR5[t`ÎdÀ¿”RJ'PT» ]UãIWÕx^uŽ­½ËajÏU·êĹÞÕæúîcخþ:®cÿõº†us]nP}‚W\'EB‡ºl­m¸Q}†]×0­bUûÜõƒq]sà'×yø;\k±£ëv|ܵÍ×?¸~*_ës`jÕåÌõƒç€êÃôâúÁ|U}Œå×Aõ þ{¨>IºªÆ“®ªñŒ®¥”Òñ\:¡#×Ë¥ÙŽ\GÕnd{rÍsà¤+@<é OºÄ“®ñ¤+@<é OºÄ“®ñ¤+@<é OºÄ“®”RJ'PT» ]UãIWÕx×áØ®Mçñª6eºç0tì8™tgê®m×*¶ÿS·UþÖûð•ëø’×9óËîq­×=u]î;{Ô¸©Ú/óÝõ7ÜFÆfU©MÙ\§ùËÓu¨Š:Üg¹o–n]÷ÕbËëÕ®Õœ}Ám‘}bíºŽ×+ýÅu{þyŽ·«64ß°y­›w9wŸsæºÜ´O¾Y³1r­ZûÔƒëf{ëZU­kݸmßÆõ˜¿¹ŸþK\oެݭ?¸>ž¯Õ¾l]Ûy÷òµ>æ¹Ü½íÝs×ßÎ}×ç@5ºåÀ|<´qW÷ò»uçˆçÐ ¹^.ýÈvä:ªv#Û“kžï ]âIW€xÒ žtˆ']âIW€xÒ žtˆ']âIW€xÒ žt¥”R:¢ÚéªOºªÆæ:[Ãõ¯ªU_á ®m×xYkÕWˆqö°‰ë7º^}§Aëò•®«ËªöµùººÎNç9 ú"‘®UõÕ®m¾~±k}L­¥¬ùª@þƪƓ®ªñ¤«j<éªÏèZJ)}Ï :r½\ú‘íÈuTíF¶'×<ÞAºÄ“®ñ¤+@<é OºÄ“®ñ¤+@<é OºÄ“®ñ¤+@<éÊ0 C'0tAºÄ“®ñ¼âºß¹¶¶ý:]çþ…­k©$Æõ¶s½Ô®UדÏ|Úu9íöø}¯ëôUk‘Fc»ìŸu]ï\긮Iy]~ûŸÊ×íëNO>Ë[×ãk<‹®u2žäkûù?èÚæë»ÖçÀÔ:ß[•kuä libDAI: include/dai/cobwebgraph.h File Reference
Classes | Namespaces
cobwebgraph.h File Reference

Defines class CobwebGraph, which implements a type of region graph used by GLC. More...

#include <iostream>
#include <dai/factorgraph.h>
#include <dai/weightedgraph.h>
#include <dai/smallset.h>
#include <dai/enum.h>
#include <algorithm>
#include <map>
#include <set>

Go to the source code of this file.

Classes

class  dai::CobwebGraph
 A CobwebGraph is a special type of region graph used by the GLC algorithm. More...
 
struct  dai::CobwebGraph::Connection
 The information in connection between two regions. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class CobwebGraph, which implements a type of region graph used by GLC.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1TFactor-members.html0000644000175000017500000005762712552201370021743 0ustar jorismjorism 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 >
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 >
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 >
strength(const Var &i, const Var &j) const dai::TFactor< T >
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
toString() const dai::TFactor< T >inline
vars() const dai::TFactor< T >inline
vars()dai::TFactor< T >inline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_120.png0000644000175000017500000000032212552200246015727 0ustar jorismjorism‰PNG  IHDR U.T±0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïAIDATxíÁ €0 /©‡J…ý·¥"T¼Á²¥{œwø›5[-”Mñp‡ËÜ_ÉÏï ƒÒ—0ƒ(Nµì[ß¹&ÕÀÊÚpIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1FRegion-members.html0000644000175000017500000005633512552201366021732 0ustar jorismjorism libDAI: Member List
dai::FRegion Member List

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

_cdai::FRegionprivate
abs() constdai::TFactor< Real >inline
binaryOp(const TFactor< Real > &g, binOp op)dai::TFactor< Real >inline
binaryTr(const TFactor< Real > &g, binOp op) constdai::TFactor< Real >inline
c() const dai::FRegioninline
c()dai::FRegioninline
embed(const VarSet &vars) constdai::TFactor< Real >inline
entropy() constdai::TFactor< Real >inline
exp() constdai::TFactor< Real >inline
fill(Realx)dai::TFactor< Real >inline
FRegion()dai::FRegioninline
FRegion(const Factor &x, Real c)dai::FRegioninline
get(size_t i) constdai::TFactor< Real >inline
hasNaNs() constdai::TFactor< Real >inline
hasNegatives() constdai::TFactor< Real >inline
inverse(bool zero=true) constdai::TFactor< Real >inline
log(bool zero=false) constdai::TFactor< Real >inline
marginal(const VarSet &vars, bool normed=true) constdai::TFactor< Real >
max() constdai::TFactor< Real >inline
maxAbs() constdai::TFactor< Real >inline
maxMarginal(const VarSet &vars, bool normed=true) constdai::TFactor< Real >
min() constdai::TFactor< Real >inline
normalize(ProbNormType norm=NORMPROB)dai::TFactor< Real >inline
normalized(ProbNormType norm=NORMPROB) constdai::TFactor< Real >inline
nrStates() constdai::TFactor< Real >inline
operator*(Realx) constdai::TFactor< Real >inline
operator*(const TFactor< Real > &g) constdai::TFactor< Real >inline
operator*=(Realx)dai::TFactor< Real >inline
operator*=(const TFactor< Real > &g)dai::TFactor< Real >inline
operator+(Realx) constdai::TFactor< Real >inline
operator+(const TFactor< Real > &g) constdai::TFactor< Real >inline
operator+=(Realx)dai::TFactor< Real >inline
operator+=(const TFactor< Real > &g)dai::TFactor< Real >inline
operator-() constdai::TFactor< Real >inline
operator-(Realx) constdai::TFactor< Real >inline
operator-(const TFactor< Real > &g) constdai::TFactor< Real >inline
operator-=(Realx)dai::TFactor< Real >inline
operator-=(const TFactor< Real > &g)dai::TFactor< Real >inline
operator/(Realx) constdai::TFactor< Real >inline
operator/(const TFactor< Real > &g) constdai::TFactor< Real >inline
operator/=(Realx)dai::TFactor< Real >inline
operator/=(const TFactor< Real > &g)dai::TFactor< Real >inline
operator==(const TFactor< Real > &y) constdai::TFactor< Real >inline
operator[](size_t i) constdai::TFactor< Real >inline
operator^(Realx) constdai::TFactor< Real >inline
operator^=(Realx)dai::TFactor< Real >inline
p() constdai::TFactor< Real >inline
p()dai::TFactor< Real >inline
randomize()dai::TFactor< Real >inline
set(size_t i, Realval)dai::TFactor< Real >inline
setUniform()dai::TFactor< Real >inline
slice(const VarSet &vars, size_t varsState) constdai::TFactor< Real >
strength(const Var &i, const Var &j) constdai::TFactor< Real >
sum() constdai::TFactor< Real >inline
sumAbs() constdai::TFactor< Real >inline
takeAbs()dai::TFactor< Real >inline
takeExp()dai::TFactor< Real >inline
takeLog(bool zero=false)dai::TFactor< Real >inline
TFactor(Realp=1)dai::TFactor< Real >inline
TFactor(const Var &v)dai::TFactor< Real >inline
TFactor(const VarSet &vars)dai::TFactor< Real >inline
TFactor(const VarSet &vars, Realp)dai::TFactor< Real >inline
TFactor(const VarSet &vars, const std::vector< S > &x)dai::TFactor< Real >inline
TFactor(const VarSet &vars, const Real *p)dai::TFactor< Real >inline
TFactor(const VarSet &vars, const TProb< Real > &p)dai::TFactor< Real >inline
TFactor(const std::vector< Var > &vars, const std::vector< Real > &p)dai::TFactor< Real >inline
toString() constdai::TFactor< Real >inline
vars() constdai::TFactor< Real >inline
vars()dai::TFactor< Real >inline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_g.html0000644000175000017500000001035012552201370020134 0ustar jorismjorism libDAI: Class Members - Variables
 

- g -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1MF_1_1Properties-members.html0000644000175000017500000001146512552201367023633 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1DAG.html0000644000175000017500000017576512552201365017354 0ustar jorismjorism libDAI: dai::DAG Class Reference
Private Attributes | List of all members
dai::DAG Class Reference

Represents the neighborhood structure of nodes in a directed cyclic graph. More...

#include <dai/dag.h>

Public Member Functions

Constructors and destructors
 DAG ()
 Default constructor (creates an empty DAG). More...
 
 DAG (size_t nr)
 Constructs DAG with nr nodes and no edges. More...
 
template<typename EdgeInputIterator >
 DAG (size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
 Constructs DAG from a range of edges. More...
 
Accessors and mutators
const Neighbor & pa (size_t n, size_t _p) const
 Returns constant reference to the _p 'th parent of node n. More...
 
Neighbor & pa (size_t n, size_t _p)
 Returns reference to the _p 'th parent of node n. More...
 
const Neighbors & pa (size_t n) const
 Returns constant reference to all parents of node n. More...
 
Neighbors & pa (size_t n)
 Returns reference to all parents of node n. More...
 
const Neighbor & ch (size_t n, size_t _c) const
 Returns constant reference to the _c 'th child of node n. More...
 
Neighbor & ch (size_t n, size_t _c)
 Returns reference to the _c 'th child of node n. More...
 
const Neighbors & ch (size_t n) const
 Returns constant reference to all children of node n. More...
 
Neighbors & ch (size_t n)
 Returns reference to all children of node n. More...
 
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. More...
 
size_t addNode ()
 Adds a node without parents and children and returns the index of the added node. More...
 
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. More...
 
DAG & addEdge (size_t n1, size_t n2, bool check=true)
 Adds an edge from node n1 and node n2. More...
 
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. More...
 
void eraseEdge (size_t n1, size_t n2)
 Removes edge from node n1 to node n2. More...
 
Queries
size_t nrNodes () const
 Returns number of nodes. More...
 
size_t nrEdges () const
 Calculates the number of edges, time complexity: O(nrNodes()) More...
 
bool hasEdge (size_t n1, size_t n2) const
 Returns true if the DAG contains an edge from node n1 and n2. More...
 
size_t findPa (size_t n, size_t p)
 Returns the index of a given node p amongst the parents of n. More...
 
size_t findCh (size_t n, size_t c)
 Returns the index of a given node c amongst the children of n. More...
 
SmallSet< size_t > paSet (size_t n) const
 Returns parents of node n as a SmallSet<size_t>. More...
 
SmallSet< size_t > chSet (size_t n) const
 Returns children of node n as a SmallSet<size_t>. More...
 
std::set< size_t > ancestors (size_t n, bool inclusive) 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 (including n itself if inclusive == true) More...
 
std::set< size_t > descendants (size_t n, bool inclusive) 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 if inclusive == true) More...
 
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) More...
 
bool isConnected () const
 Returns true if the DAG is connected. More...
 
void checkConsistency () const
 Asserts internal consistency. More...
 
bool operator== (const DAG &x) const
 Comparison operator which returns true if two DAGs are identical. More...
 

Private Attributes

std::vector< Neighbors > _pa
 Contains for each node a vector of its parent nodes. More...
 
std::vector< Neighbors > _ch
 Contains for each node a vector of its children nodes. More...
 

Input and output

void printDot (std::ostream &os) const
 Writes a DAG to an output stream in GraphViz .dot syntax. More...
 
std::string toString () const
 Formats a DAG as a string. More...
 
std::ostream & operator<< (std::ostream &os, const DAG &g)
 Writes a DAG to an output stream. More...
 

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
EdgeInputIteratorIterator that iterates over instances of Edge.
Parameters
nrThe number of nodes.
beginPoints to the first edge.
endPoints just beyond the last edge.
checkWhether 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 
)

(Re)constructs DAG from a range of edges.

Template Parameters
EdgeInputIteratorIterator that iterates over instances of Edge.
Parameters
nrThe number of nodes.
beginPoints to the first edge.
endPoints just beyond the last edge.
checkWhether 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
NodeInputIteratorIterator that iterates over instances of size_t.
Parameters
beginPoints to the first index of the nodes that should become parents of the added node.
endPoints just beyond the last index of the nodes that should become parents of the added node.
sizeHintFor 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_FOUNDif 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_FOUNDif 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,
bool  inclusive 
) 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 (including n itself if inclusive == true)

std::set< size_t > dai::DAG::descendants ( size_t  n,
bool  inclusive 
) 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 if inclusive == true)

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 a DAG to an output stream in GraphViz .dot syntax.

std::string dai::DAG::toString ( ) const
inline

Formats a DAG as a string.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const DAG &  g 
)
friend

Writes a 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_6.png0000644000175000017500000000275212552200214015576 0ustar jorismjorism‰PNG  IHDR $»0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïYIDATxíkbÛ8 „?>EI–yÿÛ.R/¯“¸I¤iU"•)$ƒÁ_€ðÏþÀ_i¡”r¯[.¥FøÁæs­5ÛSj7ʺ¥í¸Ô:F€m©ÖN¦õà5›êÔ^Jžhgø]ø]æp/yßpy ²Ô_žaa#¡\.[žÓxÁûwèý0cë†ùèNvßû7(ÝH’œÞoaÙ ê÷½!@)ø”‰ñ¥¨'KrJȪ~Ç–+EÄ烌¸coI %âSú­ØQÆò|]1oà§äÒîdõÆ3z+òö ®FŠ pÕ+zù‡ÍgÊÅo7»ö“]ª>`iñ\dJÖNmÈÃB>÷ekÓvÒ¨oɇê«Ü²Þ½‡ñ€Î‘ËÙ/¨_Áœ$“z®›§Ó*'¡Ú}B„>±†Äo¼žñ‘ûËÔ›#{&½Ú<Þ¤èª8D…dÑ«…µæÊbDû,€N‘k(7Z²î[8Ñ.¹lølEÑï³YC°Ë†$¼PSõWoRc ¡›…ÐPîÿ}@çÈ·@¡oùtZƒÎï‡gùŠ`Yöú%¶‰AV.õ\“;@NÎ.Jȇק•ª¡¡+Å÷5Ø¥z>  Sä‡Ö¡¡6]%Itqq2a‹B{–LºHô³\»ŒùJômßp“W-µ×ü<ºP£W€æè…ÄóåÈ!=­£‘¥põÕû=;«wà0žÐ1ò–±=tRìµa¸HØvEKkÊö\#î"±'™s9x‘”66'Ûj/N?l¢•³t±,])K{“ÎçbzXN6fÛ},L'* ÷{ WïÀa< SäÞ2¶‡.×¼wûÒ© [‡Ac9¸owû0À#V²‚Bj…4Ø7µ”Ý÷þ nµ÷h ]ˆpcQr¾)…bl?îî6‘î·C€lÒ‡OÉnávÉjõïOH˜ÉÖ•³pÒØ[‘x¿¹[o/x2@ÀiˆŽÞ­t€÷ZF+@€ßoeÅ%W€·ìR;æõàQ‹ð y.^›ºhr¯É–ƒhJ.úõÊÌK•GâÜ^^³ñª …:Û À×Z1þ K—.Ȳ°è_'|ä’Ξã Àk¶­{tÀ3-‡%¨ðæl}:¨p£º~Nùo‘E€¯1â#U¶h… Úžô%(@Q¡?Ôý~‚M"AŠÍ¤½ÒiÑi‰•Áÿ6­åÒá~õ­¾Ö¥7]àól=»é¨BuéS¿ªA^!î-å"HÅôV·âV?G›bça?ÁÍrt+v²¬²Î-q£Ì¹+Àך›Û¥äN¡KvÞxÓ‚®ÆQÃ¥ÇǾ¿¡ÐàV×{´USÑw úúƺ£õi%5ÀZl à&b&07/.Íi–d€@F² '(®;ò´A:Ú\È@ü|È¢—(Tä ç¯úÃGë–(Å åµ–0IX»îpI 0Dä«·ÙQ*ˆB£Vt¬9eÆ<Ê#ÁH€s¶ÚX á/J°¤z”VÒhõ¬;„ÀyR\œ~T¶5­Re÷òª¿HU¬õ"?«ÔKk„NaQI©H ²N\µ]î;¨òÇ $)cŒ}&A˜JüÉ6Hxn¶LÊth:¤5f$Ê´jPÊÅÓv$%˜v×Zw¨¥ÅªíhPtÖÆÉãØ› F¿´ÌG™j]LŸ›ž}Ú±u0A¤£ûC*Ã1Ê]˜z[Rmî ¢© ÀËÁJÌdÚd˞Ъà'[GëU2Ä»bó üùÎQ%|”e,¨IEND®B`‚libDAI-0.3.2/doc/html/functions_func_f.html0000644000175000017500000002053712552201370020123 0ustar jorismjorism libDAI: Class Members - Functions
 

- f -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1VarSet.html0000644000175000017500000015251512552201370020145 0ustar jorismjorism libDAI: dai::VarSet Class Reference
List of all members
dai::VarSet Class Reference

Represents a set of variables. More...

#include <dai/varset.h>

Inheritance diagram for dai::VarSet:
dai::SmallSet< Var > dai::Region

Public Member Functions

Constructors and destructors
 VarSet ()
 Default constructor (constructs an empty set) More...
 
 VarSet (const SmallSet< Var > &x)
 Construct from SmallSet<Var> x. More...
 
 VarSet (const Var &v)
 Construct a VarSet with one element, v. More...
 
 VarSet (const Var &v1, const Var &v2)
 Construct a VarSet with two elements, v1 and v2. More...
 
template<typename VarIterator >
 VarSet (VarIterator begin, VarIterator end, size_t sizeHint=0)
 Construct a VarSet from the range between begin and end. More...
 
Queries
BigInt nrStates () const
 Calculates the number of states of this VarSet, which is simply the number of possible joint states of the variables in *this. More...
 
- Public Member Functions inherited from dai::SmallSet< Var >
 SmallSet ()
 Default constructor (constructs an empty set) More...
 
 SmallSet (const Var &t)
 Construct a set consisting of one element. More...
 
 SmallSet (const Var &t1, const Var &t2)
 Construct a set consisting of two elements. More...
 
 SmallSet (TIterator begin, TIterator end, size_t sizeHint)
 Construct a SmallSet from a range of elements. More...
 
SmallSet & insert (const Var &t)
 Inserts t into *this. More...
 
SmallSet & erase (const Var &t)
 Erases t from *this. More...
 
SmallSet operator/ (const SmallSet &x) const
 Set-minus operator: returns all elements in *this, except those in x. More...
 
SmallSet operator| (const SmallSet &x) const
 Set-union operator: returns all elements in *this, plus those in x. More...
 
SmallSet operator& (const SmallSet &x) const
 Set-intersection operator: returns all elements in *this that are also contained in x. More...
 
SmallSet & operator/= (const SmallSet &x)
 Erases from *this all elements in x. More...
 
SmallSet & operator/= (const Var &t)
 Erases one element. More...
 
SmallSet & operator|= (const SmallSet &x)
 Adds to *this all elements in x. More...
 
SmallSet & operator|= (const Var &t)
 Adds one element. More...
 
SmallSet & operator&= (const SmallSet &x)
 Erases from *this all elements not in x. More...
 
bool operator<< (const SmallSet &x) const
 Returns true if *this is a subset of x. More...
 
bool operator>> (const SmallSet &x) const
 Returns true if x is a subset of *this. More...
 
bool intersects (const SmallSet &x) const
 Returns true if *this and x have elements in common. More...
 
bool contains (const Var &t) const
 Returns true if *this contains the element t. More...
 
std::vector< Var >::size_type size () const
 Returns number of elements. More...
 
bool empty () const
 Returns whether *this is empty. More...
 
std::vector< Var > & elements ()
 Returns reference to the elements. More...
 
const std::vector< Var > & elements () const
 Returns constant reference to the elements. More...
 
iterator begin ()
 Returns iterator that points to the first element. More...
 
const_iterator begin () const
 Returns constant iterator that points to the first element. More...
 
iterator end ()
 Returns iterator that points beyond the last element. More...
 
const_iterator end () const
 Returns constant iterator that points beyond the last element. More...
 
reverse_iterator rbegin ()
 Returns reverse iterator that points to the last element. More...
 
const_reverse_iterator rbegin () const
 Returns constant reverse iterator that points to the last element. More...
 
reverse_iterator rend ()
 Returns reverse iterator that points beyond the first element. More...
 
const_reverse_iterator rend () const
 Returns constant reverse iterator that points beyond the first element. More...
 
Var & front ()
 Returns reference to first element. More...
 
const Var & front () const
 Returns constant reference to first element. More...
 
Var & back ()
 Returns reference to last element. More...
 
const Var & back () const
 Returns constant reference to last element. More...
 
std::string toString () const
 Formats a SmallSet as a string. More...
 

Input and output

std::string toString () const
 Formats a VarSet as a string. More...
 
std::ostream & operator<< (std::ostream &os, const VarSet &vs)
 Writes a VarSet to an output stream. More...
 

Additional Inherited Members

- Public Types inherited from dai::SmallSet< Var >
typedef std::vector< Var >::const_iterator const_iterator
 Constant iterator over the elements. More...
 
typedef std::vector< Var >::iterator iterator
 Iterator over the elements. More...
 
typedef std::vector< Var >::const_reverse_iterator const_reverse_iterator
 Constant reverse iterator over the elements. More...
 
typedef std::vector< Var >::reverse_iterator reverse_iterator
 Reverse iterator over the elements. More...
 

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
VarIteratorIterates over instances of type Var.
Parameters
beginPoints to first Var to be added.
endPoints just beyond last Var to be added.
sizeHintFor efficiency, the number of elements can be speficied by sizeHint.

Member Function Documentation

BigInt 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.
std::string dai::VarSet::toString ( ) const
inline

Formats a VarSet as a string.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1FRegion.png0000644000175000017500000000100512552201365020101 0ustar jorismjorism‰PNG  IHDR€PæÞÖPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2”IDATxíëŽ!…šôýy·£Ž 8—L6›ÓH ?Ú¿È9çHAN)¥8! €LOR>uO)™5½P*ÏÞsXŒNþQG®þàgA·–6TÍkÛú×ÛÀß½´Ã!À«ú¨5tµ2)ç´,,Àä`Í,@Ó+Ë=”ºÒ®ÖCÜæ° »›NÅñè V¦ét87l3†Z\ÁI¦Z]¨€í3€¡†¸÷{@OÁöä6aU·¦ÖSRRË›‚qRøSL äœs À#y@¤D¼^ÁÑ¿çÇ„p @€ @ü‘H@œ€WºÅþT¸ì`äNN÷¦WÛþ¨†§uPK¢½#@-D±ÖNôu°•¹†D- ôÝ@ù€/š…ŽÕî~ß'ór öœw ä{js{ é 6µ5€Ûô´wšp=à–ÜŒ÷Y€ó„Àȇ+àý0ÀZøoH€¿ "(?)=»T‰yIEND®B`‚libDAI-0.3.2/doc/html/form_112.png0000644000175000017500000000053112552200244015730 0ustar jorismjorism‰PNG  IHDR&ÿ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÈIDATxíkà „?_ó¨÷¿mAÒ‰iú£p„Q—E.ðÅáÀÍšZÎÈ7RŠ§‡˜÷ª–DÝÌ[ï1zXœ+6É˪g‹%Ëv vÓÒ^Nµ&-dYê»Ã™š@L€©Sc€.5AW=_(aÊ#bÂLx·„¶ÜMŒáðß+¹ÚbjB¥~ª†î@ÛŽ@i»ó9çŠ.äñ"Z?Àµ‹çÖSÕ´üÅiÅ°½<eÒYDo| ‹ èwõ5õðÛÞ9Ð Ä%IEND®B`‚libDAI-0.3.2/doc/html/evidence_8h_source.html0000644000175000017500000004252312552201363020335 0ustar jorismjorism libDAI: include/dai/evidence.h Source File
evidence.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_evidence_h
14 #define __defined_libdai_evidence_h
15 
16 
17 #include <istream>
18 #include <dai/daialg.h>
19 
20 
21 namespace dai {
22 
23 
25 
30 class Evidence {
31  public:
33  typedef std::map<Var, size_t> Observation;
34 
35  private:
37  std::vector<Observation> _samples;
38 
39  public:
41  Evidence() : _samples() {}
42 
44  Evidence( std::vector<Observation> &samples ) : _samples(samples) {}
45 
47 
52  void addEvidenceTabFile( std::istream& is, FactorGraph& fg );
53 
55  size_t nrSamples() const { return _samples.size(); }
56 
58 
59  typedef std::vector<Observation>::iterator iterator;
62  typedef std::vector<Observation>::const_iterator const_iterator;
63 
65  iterator begin() { return _samples.begin(); }
67  const_iterator begin() const { return _samples.begin(); }
69  iterator end() { return _samples.end(); }
71  const_iterator end() const { return _samples.end(); }
73 
74  private:
76  void addEvidenceTabFile( std::istream& is, std::map<std::string, Var> &varMap );
77 };
78 
79 
80 } // end of namespace dai
81 
82 
83 #endif
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::Evidence::nrSamples
size_t nrSamples() const
Returns number of stored samples.
Definition: evidence.h:55
dai::Evidence::Evidence
Evidence(std::vector< Observation > &samples)
Construct from samples.
Definition: evidence.h:44
dai::Evidence::addEvidenceTabFile
void addEvidenceTabFile(std::istream &is, FactorGraph &fg)
Read in tabular data from a stream and add the read samples to *this.
Definition: evidence.cpp:21
dai::Evidence::Evidence
Evidence()
Default constructor.
Definition: evidence.h:41
dai::Evidence
Stores a data set consisting of multiple samples, where each sample is the observed joint state of so...
Definition: evidence.h:30
dai::Evidence::end
iterator end()
Returns iterator that points beyond the last sample.
Definition: evidence.h:69
dai::Evidence::Observation
std::map< Var, size_t > Observation
Stores joint state of a set of variables.
Definition: evidence.h:33
dai::Evidence::_samples
std::vector< Observation > _samples
Each sample is an observed joint state of some variables.
Definition: evidence.h:37
dai::Evidence::begin
const_iterator begin() const
Returns constant iterator that points to the first sample.
Definition: evidence.h:67
dai
Namespace for libDAI.
Definition: alldai.cpp:16
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai::Evidence::iterator
std::vector< Observation >::iterator iterator
Iterator over the samples.
Definition: evidence.h:60
dai::Evidence::const_iterator
std::vector< Observation >::const_iterator const_iterator
Constant iterator over the samples.
Definition: evidence.h:62
dai::Evidence::end
const_iterator end() const
Returns constant iterator that points beyond the last sample.
Definition: evidence.h:71
dai::Evidence::begin
iterator begin()
Returns iterator that points to the first sample.
Definition: evidence.h:65
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1MaximizationStep-members.html0000644000175000017500000001472412552201366023702 0ustar jorismjorism libDAI: Member List
dai::MaximizationStep Member List

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

_paramsdai::MaximizationStepprivate
addExpectations(InfAlg &alg)dai::MaximizationStep
begin()dai::MaximizationStepinline
begin() const dai::MaximizationStepinline
clear()dai::MaximizationStep
const_iterator typedefdai::MaximizationStep
end()dai::MaximizationStepinline
end() const dai::MaximizationStepinline
iterator typedefdai::MaximizationStep
MaximizationStep()dai::MaximizationStepinline
MaximizationStep(std::vector< SharedParameters > &maximizations)dai::MaximizationStepinline
MaximizationStep(std::istream &is, const FactorGraph &fg_varlookup)dai::MaximizationStep
maximize(FactorGraph &fg)dai::MaximizationStep
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/citations.html0000644000175000017500000000564112552201363016571 0ustar jorismjorism 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, 11(Aug):2169-2173, 2010.
In BiBTeX format (for your convenience):

@article{Mooij_libDAI_10,
  author    = {Joris M. Mooij},
  title     = {lib{DAI}: A Free and Open Source {C++} Library for Discrete Approximate Inference in Graphical Models},
  journal   = {Journal of Machine Learning Research},
  year      = 2010,
  month     = Aug,
  volume    = 11,
  pages     = {2169-2173},
  url       = "http://www.jmlr.org/papers/volume11/mooij10a/mooij10a.pdf"
}

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_58.png0000644000175000017500000000062212552200230015655 0ustar jorismjorism‰PNG  IHDR2c…ܾ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIDATxí]I²Å lãxÿÛ~Œ¦ê¯ßÖX24Ý¿ÿ؇üiÅý ­Å\“<«\宄|‚Oˆ­KêÕ¨lL¿ø™“Ý´Ç’$2iˆ+K$βš"üO5µ9+yCpZËâÜ€Ô¡á™HkÔ‰PH{¬ËQ$“ïsc¦²ˆëc?ÂjüZ ½ÍIÝ6/wM©aΥ煌UäV^—Ñû Yr^ÈlåðwÆ$4aïœ âŠ©à¹ð°)>lºQÄ)_Åa-¨ò˜’ÍÄr|JœaNq¨\ûð°ö²7æk*ͱÿ@dIàóÑ«Aûü¬¥Æþíh‡u±ì!IEND®B`‚libDAI-0.3.2/doc/html/factorgraph_8h_source.html0000644000175000017500000025137112552201363021056 0ustar jorismjorism libDAI: include/dai/factorgraph.h Source File
factorgraph.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_factorgraph_h
14 #define __defined_libdai_factorgraph_h
15 
16 
17 #include <iostream>
18 #include <map>
19 #include <dai/bipgraph.h>
20 #include <dai/graph.h>
21 #include <dai/factor.h>
22 
23 
24 namespace dai {
25 
26 
28 
65 class FactorGraph {
66  private:
68  BipartiteGraph _G;
70  std::vector<Var> _vars;
72  std::vector<Factor> _factors;
74  std::map<size_t,Factor> _backup;
75 
76  public:
78 
79  FactorGraph() : _G(), _vars(), _factors(), _backup() {}
81 
83  FactorGraph( const std::vector<Factor>& P );
84 
86 
90  template<typename FactorInputIterator, typename VarInputIterator>
91  FactorGraph(FactorInputIterator facBegin, FactorInputIterator facEnd, VarInputIterator varBegin, VarInputIterator varEnd, size_t nrFacHint = 0, size_t nrVarHint = 0 );
92 
94  virtual ~FactorGraph() {}
95 
97  virtual FactorGraph* clone() const { return new FactorGraph(*this); }
99 
101 
102  const Var& var( size_t i ) const {
104  DAI_DEBASSERT( i < nrVars() );
105  return _vars[i];
106  }
107 
109  const std::vector<Var>& vars() const { return _vars; }
110 
112  const Factor& factor( size_t I ) const {
113  DAI_DEBASSERT( I < nrFactors() );
114  return _factors[I];
115  }
117  const std::vector<Factor>& factors() const { return _factors; }
118 
120  const Neighbors& nbV( size_t i ) const { return _G.nb1(i); }
122  const Neighbors& nbF( size_t I ) const { return _G.nb2(I); }
124  const Neighbor& nbV( size_t i, size_t _I ) const { return _G.nb1(i)[_I]; }
126  const Neighbor& nbF( size_t I, size_t _i ) const { return _G.nb2(I)[_i]; }
128 
130 
131  const BipartiteGraph& bipGraph() const { return _G; }
134  size_t nrVars() const { return vars().size(); }
136  size_t nrFactors() const { return factors().size(); }
138 
140  size_t nrEdges() const { return _G.nrEdges(); }
141 
143 
146  size_t findVar( const Var& n ) const {
147  size_t i = find( vars().begin(), vars().end(), n ) - vars().begin();
148  if( i == nrVars() )
149  DAI_THROW(OBJECT_NOT_FOUND);
150  return i;
151  }
152 
154 
157  SmallSet<size_t> findVars( const VarSet& ns ) const {
158  SmallSet<size_t> result;
159  for( VarSet::const_iterator n = ns.begin(); n != ns.end(); n++ )
160  result.insert( findVar( *n ) );
161  return result;
162  }
163 
165 
168  size_t findFactor( const VarSet& ns ) const {
169  size_t I;
170  for( I = 0; I < nrFactors(); I++ )
171  if( factor(I).vars() == ns )
172  break;
173  if( I == nrFactors() )
174  DAI_THROW(OBJECT_NOT_FOUND);
175  return I;
176  }
177 
179  VarSet inds2vars( const std::vector<size_t>& inds ) const {
180  VarSet vs;
181  for( std::vector<size_t>::const_iterator it = inds.begin(); it != inds.end(); it++ )
182  vs.insert( var(*it) );
183  return vs;
184  }
185 
187  VarSet Delta( size_t i ) const;
188 
190  VarSet Delta( const VarSet& vs ) const;
191 
193  VarSet delta( size_t i ) const {
194  return( Delta( i ) / var( i ) );
195  }
196 
198  VarSet delta( const VarSet& vs ) const {
199  return Delta( vs ) / vs;
200  }
201 
203  SmallSet<size_t> Deltai( size_t i ) const;
204 
206  SmallSet<size_t> deltai( size_t i ) const {
207  return( Deltai( i ) / i );
208  }
209 
211  bool isConnected() const { return _G.isConnected(); }
212 
214  bool isTree() const { return _G.isTree(); }
215 
217  bool isPairwise() const;
218 
220  bool isBinary() const;
221 
223 
226  GraphAL MarkovGraph() const;
227 
229 
232  bool isMaximal( size_t I ) const;
233 
235 
238  size_t maximalFactor( size_t I ) const;
239 
241 
244  std::vector<VarSet> maximalFactorDomains() const;
245 
247  Real logScore( const std::vector<size_t>& statevec ) const;
249 
251 
252  virtual void setFactor( size_t I, const Factor& newFactor, bool backup = false ) {
254  DAI_ASSERT( newFactor.vars() == factor(I).vars() );
255  if( backup )
256  backupFactor( I );
257  _factors[I] = newFactor;
258  }
259 
261  virtual void setFactors( const std::map<size_t, Factor>& facs, bool backup = false ) {
262  for( std::map<size_t, Factor>::const_iterator fac = facs.begin(); fac != facs.end(); fac++ ) {
263  if( backup )
264  backupFactor( fac->first );
265  setFactor( fac->first, fac->second );
266  }
267  }
268 
270 
272  void backupFactor( size_t I );
273 
275 
277  void restoreFactor( size_t I );
278 
280 
282  virtual void backupFactors( const std::set<size_t>& facs );
283 
285  virtual void restoreFactors();
286 
288 
290  void backupFactors( const VarSet& ns );
291 
293  void restoreFactors( const VarSet& ns );
295 
297 
298  FactorGraph maximalFactors() const;
300 
302 
305  FactorGraph clamped( size_t i, size_t x ) const;
307 
309 
310 
313  virtual void clamp( size_t i, size_t x, bool backup = false );
314 
316 
318  void clampVar( size_t i, const std::vector<size_t>& xis, bool backup = false );
319 
321 
323  void clampFactor( size_t I, const std::vector<size_t>& xIs, bool backup = false );
324 
326 
328  virtual void makeCavity( size_t i, bool backup = false );
329 
331 
333  virtual void makeRegionCavity( std::vector<size_t> facInds, bool backup );
335 
337 
338 
343  virtual void ReadFromFile( const char *filename );
344 
346 
349  virtual void WriteToFile( const char *filename, size_t precision=15 ) const;
350 
352 
354  friend std::ostream& operator<< (std::ostream& os, const FactorGraph& fg );
355 
357 
360  friend std::istream& operator>> (std::istream& is, FactorGraph& fg );
361 
363  virtual void printDot( std::ostream& os ) const;
364 
366  std::string toString() const {
367  std::stringstream ss;
368  ss << *this;
369  return ss.str();
370  }
371 
373  void fromString( const std::string& s ) {
374  std::stringstream ss( s );
375  ss >> *this;
376  }
378 
379  private:
381  void constructGraph( size_t nrEdges );
382 };
383 
384 
385 template<typename FactorInputIterator, typename VarInputIterator>
386 FactorGraph::FactorGraph(FactorInputIterator facBegin, FactorInputIterator facEnd, VarInputIterator varBegin, VarInputIterator varEnd, size_t nrFacHint, size_t nrVarHint ) : _G(), _backup() {
387  // add factors
388  size_t nrEdges = 0;
389  _factors.reserve( nrFacHint );
390  for( FactorInputIterator p2 = facBegin; p2 != facEnd; ++p2 ) {
391  _factors.push_back( *p2 );
392  nrEdges += p2->vars().size();
393  }
394 
395  // add variables
396  _vars.reserve( nrVarHint );
397  for( VarInputIterator p1 = varBegin; p1 != varEnd; ++p1 )
398  _vars.push_back( *p1 );
399 
400  // create graph structure
401  constructGraph( nrEdges );
402 }
403 
404 
411 } // end of namespace dai
412 
413 
414 #endif
dai::FactorGraph::findVars
SmallSet< size_t > findVars(const VarSet &ns) const
Returns a set of indexes corresponding to a set of variables.
Definition: factorgraph.h:157
dai::FactorGraph::maximalFactorDomains
std::vector< VarSet > maximalFactorDomains() const
Returns the maximal factor domains in this factorgraph.
Definition: factorgraph.cpp:345
dai::Neighbors
std::vector< Neighbor > Neighbors
Describes the set of neighbors of some node in a graph.
Definition: graph.h:92
dai::FactorGraph::nbF
const Neighbor & nbF(size_t I, size_t _i) const
Returns constant reference to the _i 'th neighbor of the I 'th factor.
Definition: factorgraph.h:126
dai::FactorGraph::isBinary
bool isBinary() const
Returns true if each variable has only two possible values.
Definition: factorgraph.cpp:477
dai::TFactor::vars
const VarSet & vars() const
Returns constant reference to variable set (i.e., the variables on which the factor depends) ...
Definition: factor.h:139
dai::FactorGraph::deltai
SmallSet< size_t > deltai(size_t i) const
Return all the indices of variables that occur in a factor involving the i 'th variable, itself excluded.
Definition: factorgraph.h:206
dai::SmallSet::end
iterator end()
Returns iterator that points beyond the last element.
Definition: smallset.h:198
dai::FactorGraph::_vars
std::vector< Var > _vars
Stores the variables.
Definition: factorgraph.h:70
dai::FactorGraph::isTree
bool isTree() const
Returns true if the factor graph is a tree (i.e., has no cycles and is connected) ...
Definition: factorgraph.h:214
dai::FactorGraph::bipGraph
const BipartiteGraph & bipGraph() const
Returns neighborhood structure.
Definition: factorgraph.h:132
dai::BipartiteGraph::isTree
bool isTree() const
Returns true if the graph is a tree, i.e., if it is singly connected and connected.
Definition: bipgraph.cpp:230
dai::FactorGraph::MarkovGraph
GraphAL MarkovGraph() const
Constructs the corresponding Markov graph.
Definition: factorgraph.cpp:288
dai::FactorGraph::makeCavity
virtual void makeCavity(size_t i, bool backup=false)
Set all factors interacting with the i 'th variable to 1.
Definition: factorgraph.cpp:233
dai::FactorGraph::delta
VarSet delta(size_t i) const
Return all variables that occur in a factor involving the i 'th variable, itself excluded.
Definition: factorgraph.h:193
dai::BipartiteGraph::nb1
const Neighbor & nb1(size_t i1, size_t _i2) const
Returns constant reference to the _i2 'th neighbor of node i1 of type 1.
Definition: bipgraph.h:87
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::SmallSet::begin
iterator begin()
Returns iterator that points to the first element.
Definition: smallset.h:193
dai::FactorGraph::maximalFactor
size_t maximalFactor(size_t I) const
Returns the index of a maximal factor that contains the I 'th factor.
Definition: factorgraph.cpp:322
dai::SmallSet::insert
SmallSet & insert(const T &t)
Inserts t into *this.
Definition: smallset.h:80
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::BipartiteGraph::nrEdges
size_t nrEdges() const
Calculates the number of edges, time complexity: O(nrNodes1())
Definition: bipgraph.h:227
dai::FactorGraph::isConnected
bool isConnected() const
Returns true if the factor graph is connected.
Definition: factorgraph.h:211
dai::TFactor
Represents a (probability) factor.
Definition: factor.h:55
dai::FactorGraph::var
const Var & var(size_t i) const
Returns constant reference the i 'th variable.
Definition: factorgraph.h:103
dai::BipartiteGraph
Represents the neighborhood structure of nodes in an undirected, bipartite graph. ...
Definition: bipgraph.h:45
dai::FactorGraph::_G
BipartiteGraph _G
Stores the neighborhood structure.
Definition: factorgraph.h:68
dai::FactorGraph::inds2vars
VarSet inds2vars(const std::vector< size_t > &inds) const
Returns the VarSet corresponding to a vector of variable indices.
Definition: factorgraph.h:179
dai::FactorGraph::~FactorGraph
virtual ~FactorGraph()
Destructor.
Definition: factorgraph.h:94
dai::FactorGraph::ReadFromFile
virtual void ReadFromFile(const char *filename)
Reads a factor graph from a file.
Definition: factorgraph.cpp:250
dai::FactorGraph::Delta
VarSet Delta(size_t i) const
Return all variables that occur in a factor involving the i 'th variable, itself included.
Definition: factorgraph.cpp:203
dai::FactorGraph::findVar
size_t findVar(const Var &n) const
Returns the index of a particular variable.
Definition: factorgraph.h:146
dai::FactorGraph::restoreFactor
void restoreFactor(size_t I)
Restores the I 'th factor from the backup (it should be backed up first)
Definition: factorgraph.cpp:426
dai::FactorGraph::Deltai
SmallSet< size_t > Deltai(size_t i) const
Return all the indices of variables that occur in a factor involving the i 'th variable, itself included.
Definition: factorgraph.cpp:222
dai::FactorGraph::isMaximal
bool isMaximal(size_t I) const
Returns whether the I 'th factor is maximal.
Definition: factorgraph.cpp:299
dai::FactorGraph::clamp
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 )
Definition: factorgraph.cpp:375
dai::SmallSet< Var >::const_iterator
std::vector< Var >::const_iterator const_iterator
Constant iterator over the elements.
Definition: smallset.h:182
dai::FactorGraph::factor
const Factor & factor(size_t I) const
Returns constant reference to I 'th factor.
Definition: factorgraph.h:112
dai::FactorGraph::clampFactor
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.
Definition: factorgraph.cpp:405
dai::FactorGraph::restoreFactors
virtual void restoreFactors()
Restore all factors to the backup copies.
Definition: factorgraph.cpp:456
dai::FactorGraph::operator>>
friend std::istream & operator>>(std::istream &is, FactorGraph &fg)
Reads a factor graph from an input stream.
Definition: factorgraph.cpp:100
dai::BipartiteGraph::nb2
const Neighbor & nb2(size_t i2, size_t _i1) const
Returns constant reference to the _i1 'th neighbor of node i2 of type 2.
Definition: bipgraph.h:100
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::FactorGraph::nrVars
size_t nrVars() const
Returns number of variables.
Definition: factorgraph.h:134
dai::FactorGraph::delta
VarSet delta(const VarSet &vs) const
Return all variables that occur in a factor involving some variable in vs, vs itself excluded...
Definition: factorgraph.h:198
dai::FactorGraph::nbV
const Neighbor & nbV(size_t i, size_t _I) const
Returns constant reference to the _I 'th neighbor of the i 'th variable.
Definition: factorgraph.h:124
dai::FactorGraph::_factors
std::vector< Factor > _factors
Stores the factors.
Definition: factorgraph.h:72
dai::FactorGraph::operator<<
friend std::ostream & operator<<(std::ostream &os, const FactorGraph &fg)
Writes a factor graph to an output stream.
Definition: factorgraph.cpp:73
dai::FactorGraph::clone
virtual FactorGraph * clone() const
Virtual copy constructor.
Definition: factorgraph.h:97
dai::FactorGraph::clampVar
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.
Definition: factorgraph.cpp:389
dai::FactorGraph::_backup
std::map< size_t, Factor > _backup
Stores backups of some factors.
Definition: factorgraph.h:74
dai::FactorGraph::vars
const std::vector< Var > & vars() const
Returns constant reference to all variables.
Definition: factorgraph.h:109
dai::FactorGraph::isPairwise
bool isPairwise() const
Returns true if each factor depends on at most two variables.
Definition: factorgraph.cpp:468
dai::FactorGraph::WriteToFile
virtual void WriteToFile(const char *filename, size_t precision=15) const
Writes a factor graph to a file.
Definition: factorgraph.cpp:261
graph.h
Defines the GraphAL class, which represents an undirected graph as an adjacency list.
dai::FactorGraph::nbV
const Neighbors & nbV(size_t i) const
Returns constant reference to neighbors of the i 'th variable.
Definition: factorgraph.h:120
dai::Neighbor
Describes the neighbor relationship of two nodes in a graph.
Definition: graph.h:73
dai::FactorGraph::findFactor
size_t findFactor(const VarSet &ns) const
Returns index of the first factor that depends on the variables.
Definition: factorgraph.h:168
dai::FactorGraph::maximalFactors
FactorGraph maximalFactors() const
Returns a copy of *this, where all factors that are subsumed by some larger factor are merged with th...
Definition: factorgraph.cpp:518
dai::FactorGraph::backupFactors
virtual void backupFactors(const std::set< size_t > &facs)
Backup the factors specified by indices in facs.
Definition: factorgraph.cpp:462
dai::FactorGraph::makeRegionCavity
virtual void makeRegionCavity(std::vector< size_t > facInds, bool backup)
Set all factors indexed by facInds to 1.
Definition: factorgraph.cpp:242
dai::FactorGraph::clamped
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.
Definition: factorgraph.cpp:486
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::FactorGraph::backupFactor
void backupFactor(size_t I)
Makes a backup of the I 'th factor.
Definition: factorgraph.cpp:418
dai::FactorGraph::nbF
const Neighbors & nbF(size_t I) const
Returns constant reference to neighbors of the I 'th factor.
Definition: factorgraph.h:122
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
factor.h
Defines TFactor<> and Factor classes which represent factors in probability distributions.
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::FactorGraph::setFactors
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 ...
Definition: factorgraph.h:261
dai::GraphAL
Represents the neighborhood structure of nodes in an undirected graph.
Definition: graph.h:114
dai::FactorGraph::toString
std::string toString() const
Formats a factor graph as a string.
Definition: factorgraph.h:366
bipgraph.h
Defines the BipartiteGraph class, which represents a bipartite graph.
dai::FactorGraph::printDot
virtual void printDot(std::ostream &os) const
Writes a factor graph to a GraphViz .dot file.
Definition: factorgraph.cpp:273
dai::FactorGraph::setFactor
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...
Definition: factorgraph.h:253
dai::FactorGraph::constructGraph
void constructGraph(size_t nrEdges)
Part of constructors (creates edges, neighbors and adjacency matrix)
Definition: factorgraph.cpp:51
dai::FactorGraph::nrFactors
size_t nrFactors() const
Returns number of factors.
Definition: factorgraph.h:136
dai::BipartiteGraph::isConnected
bool isConnected() const
Returns true if the graph is connected.
Definition: bipgraph.cpp:157
dai::FactorGraph::FactorGraph
FactorGraph()
Default constructor.
Definition: factorgraph.h:80
dai::FactorGraph::logScore
Real logScore(const std::vector< size_t > &statevec) const
Evaluates the log score (i.e., minus the energy) of the joint configuration statevec.
Definition: factorgraph.cpp:358
dai::FactorGraph::nrEdges
size_t nrEdges() const
Calculates number of edges.
Definition: factorgraph.h:140
dai::FactorGraph::factors
const std::vector< Factor > & factors() const
Returns constant reference to all factors.
Definition: factorgraph.h:117
dai::FactorGraph::fromString
void fromString(const std::string &s)
Reads a factor graph from a string.
Definition: factorgraph.h:373
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1ExactInf.png0000644000175000017500000000160012552201365020252 0ustar jorismjorism‰PNG  IHDR«ˆ¯ë³PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2IDATxí뎫0 '_¤¾ÿ# 8\º…ºåDòŠl®ƒqÒ¿äœs'%© ÂU’ü WIòçS×´-Õ*¥±‡uq-$韸Ž:EBJöZJK³i‘¤+|è:‡i3å}×ã:çÀ+שùÿpµb[×å¸ÝµÍ×7\ïÊW{Œ%{í¹ÞxHÒizq½1_%éå×A’.ð󤋄«$ù®’äÏàšsÎ}àÏ :r}<ú‘íÈuPíF¶'×8¾A¸ø®þ„+€?á àO¸ø®þ„+€?á àO¸ø®þ„+€?áJÎ9wY’º \%ÉŸp•$×´-¥ç_S¹½Kj®q̦i[±Óé ëK׶j«ÿز$5¼W{zã:¼ä³Ïô²5®vÞ]×2no©¸ñQoÓhû —–¡h’škqû—Õ¥d.Ié˜2n’n]k3Yy=ëjúÔ —IjGë:·Û™Þq]ÖßÏñvÖ†æ6¯µz—}×i=×b°*ï|³fc¾r5¥ÚuãºØ®]Í£uµ…uy×müåº]ý¸®Þ¬Ý­/\Ïç«Ù—­kÛï(_í90íÌ2zÙ»û®uÛsÀ´.90mÜ%ÕËåwëà<”¤s¼žèc׃HÒy¾ì:WIú˜o»JÒoWIò'\%ÉŸÁ5çœûÀŸ@'täúxô#Û‘ë ÚlO®q|ƒpð'\ü WÂÀŸpð'\ü WÂÀŸpð'\ü W•”Rê@„+€?á àÏu×:n)•Ý °a¨6-G½ñp}UµïzmÍ‹®å¬›¢XãjO·)z㣜ŽÃ­6œášë¸Þ$•À^&†µÕôh;¼ÏeWÄm¾.q«­€s|æ:©­s`vmZïv]¯|˜7»¶ùº··vóõ÷®ö(û»lü²ß—s`Ùõó9ð{W€Ÿ®þ„+€?á àOg®)¥Ôÿ.ñEt¢­–ÓIEND®B`‚libDAI-0.3.2/doc/html/namespacemembers.html0000644000175000017500000003373012552201370020101 0ustar jorismjorism libDAI: Namespace 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 -

- b -

  • BigInt : dai
  • BigInt_size_t() : dai
  • builtinInfAlgNames() : dai
  • builtinInfAlgs() : dai

- c -

  • calcLinearState() : dai
  • calcMarginal() : dai
  • calcPairBeliefs() : dai
  • calcState() : dai
  • complement() : dai
  • concat() : dai
  • createFactorDelta() : dai
  • createFactorExpGauss() : dai
  • createFactorIsing() : dai
  • createFactorPotts() : dai
  • createFG() : dai
  • createGraphFull() : dai
  • createGraphGrid() : dai
  • createGraphGrid3D() : dai
  • createGraphLoop() : dai
  • createGraphRegular() : dai
  • createGraphTree() : dai
  • createGroupStructuredLDPCGraph() : dai
  • createHOIFG() : dai
  • createRandomBipartiteGraph() : dai
  • createSmallLDPCGraph() : dai

- d -

  • DAI_ENUM() : dai
  • DAIAlgCG : dai
  • DAIAlgFG : dai
  • DAIAlgRG : 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
  • FULL_TYPE : dai

- g -

  • getFactorEntryForState() : dai

- i -

  • isnan() : dai
  • isPrime() : 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
  • order() : dai

- p -

  • parseNameProperties() : dai
  • pow() : dai
  • powmod() : 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_87.png0000644000175000017500000000070312552200237015666 0ustar jorismjorism‰PNG  IHDRKiÙrì0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï2IDATxíÙŽì D› ÂÿÿíØ™l¤¯tßæQj”öR®‚w€¿ŽpCø„ pƒ+O”^¹ðDx ÀC›È7ÖéÖµE(méÄ7Q¢}­^O>EŸ>»ÍöÝzMÀeúV*Gšc±–BŸdÎ=ýé*pÝuÜÑK`ô§+€soµÒl3úiÜ#W!úPQ¶6n{­*¶öZ>3ÏŸÐ`§¤LVçb7v²Hn’W7ö?lvúWšrOu’ºqlž¨ñÍL¥©fÞw¼©=oTò©½K‹ûQ^ Sf¯å¢ØÉ2½x+kg¥3{³ð˜$¶R4ÛDËH"f°‰–ÍìØËq èI#¾ÝÕÃ8sÍÍ·[ûú†¸Ý*€<žÒiø¿ß;À~ux¼Yä³IEND®B`‚libDAI-0.3.2/doc/html/functions_vars_n.html0000644000175000017500000001141412552201370020145 0ustar jorismjorism libDAI: Class Members - Variables
 

- n -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1CobwebGraph_1_1Connection-members.html0000644000175000017500000001244712552201364025455 0ustar jorismjorism libDAI: Member List
dai::CobwebGraph::Connection Member List

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

dualdai::CobwebGraph::Connection
fcdai::CobwebGraph::Connection
hisdai::CobwebGraph::Connection
iterdai::CobwebGraph::Connection
msgdai::CobwebGraph::Connection
mydai::CobwebGraph::Connection
newmsgdai::CobwebGraph::Connection
subregionsdai::CobwebGraph::Connection
varindsdai::CobwebGraph::Connection
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_100.png0000644000175000017500000000033612552200242015726 0ustar jorismjorism‰PNG  IHDR —™'n0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïMIDATxíÑ €0R´Åh÷ßÖRÛÄøã —#3ü¦˜½ñL4%×¢ÝAz·Ñ,mê±O‚“÷ª¹+¾­2þ¬óe]à›YâŠÕ†IEND®B`‚libDAI-0.3.2/doc/html/form_144.png0000644000175000017500000000154512552200254015744 0ustar jorismjorism‰PNG  IHDRìo•ÂO0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÔIDATxíÛ²¬* E‚"¨‹ÿÿÛ“ (ÞÖqwuí—]”êBæÌíàßðoˆñÉÄ &ã>>“¡¸³«ÿÀ¸m,°s¯³µ‡Ç~“’ѱ¤Gƒq¾³n€“äÌú4ÀYlš²þtµ·?Ž«À­\.wIçຩîØáçÿé\òµºœe%ö~{Ö#À­¤u«,™åëJ¶ :Âl¶§ŸÄ‚°#ùØžl}»÷¬%§$²2î<[É`ƒèl¼ð °&é³O1övÿý¬l±öË”¦æ‚_üŠÖÖJ•1.rëË`e+EyÃÞ&õúº?Cq›õoÀ–d0…Q+aï«@íAQ£WÑ},}L³dÖ­®bæÏ™ _ѾëSÖ½VÉSàVü¬¼,ßc…¡*ç5‚rÑaòþ;NÙ+¦ì†0§â„`}óë]9£?.ìÍç´hò8‰‚ÏÀ6ÇÝ\ºÕEk×zõ¬ÏͷɬiÚÛ0o­Fºt—ë‚/Ï‹²¦ÈˆÏŲæl§á>ˆªz}Íþè3¦ÌwžË™lcì‚nWOçÚ#•v ý ”ß`µžU¾ü˜£b3› l.ÒEjì`¼¯¹ ´Ÿ©¬ÑÛ{/¨lîµ.D…¸²4äû!‘çõÌѳŠõÄ¡w”rÞç^§JC̶^Àî!ÒzV)ŸYm1ÛõEµâ\º)À½úþ!|³OŽ²žiÀª15«1{ç·lßz¶m+ÛÒ{L5l¾V[#! ðJ°]«ÊÝ÷Èr¦+Æ0iuXjÌÁó V©Z·Ò€¯Ú¹7}õŒ×¾÷,ý–ò/%¦¤é’—h%Ûk6žíwi³;ESJ‚m]×QNj–ôàH€ïJ.¼Á[Û1ľpð(½icoEïÜ3CIÌ0|%°nøÕ£ÿŒ@‘â9(IEND®B`‚libDAI-0.3.2/doc/html/trwbp_8h.html0000644000175000017500000001133312552201363016324 0ustar jorismjorism libDAI: include/dai/trwbp.h File Reference
Classes | Namespaces
trwbp.h File Reference

Defines class TRWBP, which implements Tree-Reweighted Belief Propagation. More...

#include <dai/dai_config.h>
#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.

Classes

class  dai::TRWBP
 Approximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class TRWBP, which implements Tree-Reweighted Belief Propagation.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_99.png0000644000175000017500000000065412552200241015671 0ustar jorismjorism‰PNG  IHDR7…¬ú0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIDATxí]írÄ \I4¾ÿÛvÁë];ýÝ?Θ ÂÂ.ððOn ë/A¾ëè}g@ÚÉÈxÕýõÚþ“NŒh­ÓŠ¡‡«´<Ð?pH¯ßNyÆy¦½_ißqØéˆûÝrXÖÃ=Yuã’D³P“ÒôYj˜cÔ°DéB¢=p9tEe ʪў¨3|ËkÖÍ‘ÈjàD+Ÿ‰Ù8£Ö×”'‚F2éaW4yž ±Ð…sjyty 4g!ùκ÷D8­‰“Ëbµ›^î*r³fæu¤›8Ê»­%¦Ñç‘Ù%~ijöÿ@1ã°¦œÖ9 óÀï×–gÈ›8“÷1wø¼¾OÙÛä8õ54yðÇ 6ãµÊqïõxý^ûè-C/IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1HAK.html0000644000175000017500000022750212552201366017350 0ustar jorismjorism libDAI: dai::HAK Class Reference
Classes | Public Attributes | Private Member Functions | Private Attributes | List of all members
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

Classes

struct  Properties
 Parameters for HAK. More...
 

Public Member Functions

Constructors/destructors
 HAK ()
 Default constructor. More...
 
 HAK (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
 HAK (const RegionGraph &rg, const PropertySet &opts)
 Construct from RegionGraph rg and PropertySet opts. More...
 
General InfAlg interface
virtual HAK * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual HAK * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &vs)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
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. More...
 
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. More...
 
const Factor & Qa (size_t alpha) const
 Returns belief of outer region alpha. More...
 
const Factor & Qb (size_t beta) const
 Returns belief of inner region beta. More...
 
Real doGBP ()
 Runs single-loop algorithm (algorithm 1 in [HAK03]) More...
 
Real doDoubleLoop ()
 Runs double-loop algorithm (as described in section 4.2 of [HAK03]), which always convergences. More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability. More...
 

Public Attributes

struct dai::HAK::Properties props
 

Private Member Functions

void construct ()
 Helper function for constructors. More...
 
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. More...
 

Private Attributes

std::vector< Factor > _Qa
 Outer region beliefs. More...
 
std::vector< Factor > _Qb
 Inner region beliefs. More...
 
std::vector< std::vector< Factor > > _muab
 Messages from outer to inner regions. More...
 
std::vector< std::vector< Factor > > _muba
 Messages from inner to outer regions. More...
 
Real _maxdiff
 Maximum difference encountered so far. More...
 
size_t _iters
 Number of iterations needed. 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
fgFactor graph.
optsParameters
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
inlinevirtual

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

Implements dai::InfAlg.

virtual HAK* dai::HAK::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Implements dai::InfAlg.

virtual std::string dai::HAK::name ( ) const
inlinevirtual

Returns the name of the algorithm.

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_IMPLEMENTEDif not implemented/supported.
BELIEF_NOT_AVAILABLEif 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_IMPLEMENTEDif 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_IMPLEMENTEDif 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
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::HAK::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::HAK::setMaxIter ( size_t  )
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif 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
fgthe factor graph
allclthe clusters found so far
newclpartial candidate cluster
rootstart (and end) point of the loop
lengthnumber of variables that may be added to newcl
varsneighboring 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.

The documentation for this class was generated from the following files:
  • include/dai/hak.h
  • src/hak.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1MR_1_1Properties-members.html0000644000175000017500000001044612552201367023645 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_h.html0000644000175000017500000001451112552201370017105 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- h -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/formula.repository0000644000175000017500000001710712552201370017512 0ustar jorismjorism\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.3.2/doc/html/classdai_1_1greedyVariableElimination-members.html0000644000175000017500000001001312552201366025476 0ustar jorismjorism 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::greedyVariableEliminationinline
heuristicdai::greedyVariableEliminationprivate
operator()(const ClusterGraph &cl, const std::set< size_t > &remainingVars)dai::greedyVariableElimination
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_72.png0000644000175000017500000000053712552200233015661 0ustar jorismjorism‰PNG  IHDRFn§I0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÎIDATxíݲƒ „?þ‚¡Xßÿml­Go¼éLg2î˜ Y6+ð Ðþ :€èÝ.h¸MÄ´ÑL±äò)-ŠJ^.q¤I°x‰„†-SuŠm_-²öÈ¢ÅsT/5¸õܨ²;¬Xñ€g8Á¿¡Hm»-ìig+0w9Óˆ÷–#̓*6Y§ËböM e¾Á#®ÕÔÜ0[Vµ¾T²ŠU¾{|<æM]½q:χ‹Óï'óäÊ€3¤¢¾uŽ_3—›—«1|vfH|Y¶IEND®B`‚libDAI-0.3.2/doc/html/functions_p.html0000644000175000017500000002135212552201370017116 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- p -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_c.html0000644000175000017500000004306212552201370017103 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- c -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_125.png0000644000175000017500000000053212552200247015740 0ustar jorismjorism‰PNG  IHDR'$–ä¼0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÉIDATxí][à \EQ[ïÛ‚J¦Ói~úÉ„Dd Ërø‡‡äür ç-Üòç¡°Ov6*Üæµpy´Yå.·Ý˜-nuYí=¶*g+ã‡ý.œV¥Å!+û ÊôlD®nÏÓk‡Uå ásr·œ î)GÒÜì6Æòܵ78I{Rz’—X:†˜uoM!tÊ+I:©t1J»â|Êʉã¼VH\\síIîÒ™}P` ÞÊ»D_÷)L> ßüRLÌ‘Y ÆIEND®B`‚libDAI-0.3.2/doc/html/functions_w.html0000644000175000017500000001255312552201370017130 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- w -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/jtree_8h_source.html0000644000175000017500000013426412552201363017670 0ustar jorismjorism libDAI: include/dai/jtree.h Source File
jtree.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_jtree_h
14 #define __defined_libdai_jtree_h
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_JTREE
19 
20 
21 #include <vector>
22 #include <string>
23 #include <dai/daialg.h>
24 #include <dai/varset.h>
25 #include <dai/regiongraph.h>
26 #include <dai/factorgraph.h>
27 #include <dai/clustergraph.h>
28 #include <dai/weightedgraph.h>
29 #include <dai/enum.h>
30 #include <dai/properties.h>
31 
32 
33 namespace dai {
34 
35 
37 
45 class JTree : public DAIAlgRG {
46  private:
48  std::vector<std::vector<Factor> > _mes;
49 
51  Real _logZ;
52 
53  public:
55  RootedTree RTree;
56 
58  std::vector<Factor> Qa;
59 
61  std::vector<Factor> Qb;
62 
64  struct Properties {
66 
70  DAI_ENUM(UpdateType,HUGIN,SHSH);
71 
73 
77  DAI_ENUM(InfType,SUMPROD,MAXPROD);
78 
80 
89  DAI_ENUM(HeuristicType,MINNEIGHBORS,MINWEIGHT,MINFILL,WEIGHTEDMINFILL);
90 
92  size_t verbose;
93 
95  UpdateType updates;
96 
98  InfType inference;
99 
101  HeuristicType heuristic;
102 
104  size_t maxmem;
105  } props;
106 
107  public:
109 
110  JTree() : DAIAlgRG(), _mes(), _logZ(), RTree(), Qa(), Qb(), props() {}
112 
114 
118  JTree( const FactorGraph &fg, const PropertySet &opts, bool automatic=true );
120 
121 
123 
124  virtual JTree* clone() const { return new JTree(*this); }
125  virtual JTree* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new JTree( fg, opts ); }
126  virtual std::string name() const { return "JTREE"; }
127  virtual Factor belief( const VarSet &vs ) const;
128  virtual std::vector<Factor> beliefs() const;
129  virtual Real logZ() const;
132  std::vector<size_t> findMaximum() const;
133  virtual void init() {}
134  virtual void init( const VarSet &/*ns*/ ) {}
135  virtual Real run();
136  virtual Real maxDiff() const { return 0.0; }
137  virtual size_t Iterations() const { return 1UL; }
138  virtual void setProperties( const PropertySet &opts );
139  virtual PropertySet getProperties() const;
140  virtual std::string printProperties() const;
142 
143 
145 
146 
160  void construct( const FactorGraph &fg, const std::vector<VarSet> &cl, bool verify=false );
161 
163 
166  void GenerateJT( const FactorGraph &fg, const std::vector<VarSet> &cl );
167 
169  const Factor & message( size_t alpha, size_t _beta ) const { return _mes[alpha][_beta]; }
171  Factor & message( size_t alpha, size_t _beta ) { return _mes[alpha][_beta]; }
172 
174 
176  void runHUGIN();
177 
179 
181  void runShaferShenoy();
182 
184 
191  size_t findEfficientTree( const VarSet& vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1 ) const;
192 
194 
196  Factor calcMarginal( const VarSet& vs );
198 };
199 
200 
202 
209 std::pair<size_t,BigInt> boundTreewidth( const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates=0 );
210 
211 
212 } // end of namespace dai
213 
214 
215 #endif
216 
217 
218 #endif
dai::JTree::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: jtree.h:126
dai::JTree::Properties
Parameters for JTree.
Definition: jtree.h:64
dai::JTree::message
Factor & message(size_t alpha, size_t _beta)
Returns reference to the message from outer region alpha to its _beta 'th neighboring inner region...
Definition: jtree.h:171
dai::JTree
Exact inference algorithm using junction tree.
Definition: jtree.h:45
dai::JTree::calcMarginal
Factor calcMarginal(const VarSet &vs)
Calculates the marginal of a set of variables (using cutset conditioning, if necessary) ...
Definition: jtree.cpp:466
dai::JTree::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: jtree.cpp:47
dai::JTree::findMaximum
std::vector< size_t > findMaximum() const
Definition: jtree.cpp:585
weightedgraph.h
Defines some utility functions for (weighted) undirected graphs, trees and rooted trees...
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
varset.h
Defines the VarSet class, which represents a set of random variables.
dai::JTree::Qa
std::vector< Factor > Qa
Outer region beliefs.
Definition: jtree.h:58
dai::JTree::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: jtree.h:137
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::JTree::Properties::updates
UpdateType updates
Type of updates.
Definition: jtree.h:95
dai::JTree::runHUGIN
void runHUGIN()
Runs junction tree algorithm using HUGIN (message-free) updates.
Definition: jtree.cpp:265
dai::JTree::JTree
JTree()
Default constructor.
Definition: jtree.h:111
dai::JTree::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: jtree.cpp:58
dai::JTree::setProperties
virtual void setProperties(const PropertySet &opts)
Set parameters of this inference algorithm.
Definition: jtree.cpp:24
dai::JTree::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: jtree.cpp:384
dai::greedyVariableElimination::eliminationCostFunction
size_t(* eliminationCostFunction)(const ClusterGraph &, size_t)
Type of cost functions to be used for greedy variable elimination.
Definition: clustergraph.h:289
dai::JTree::runShaferShenoy
void runShaferShenoy()
Runs junction tree algorithm using Shafer-Shenoy updates.
Definition: jtree.cpp:312
dai::JTree::Properties::maxmem
size_t maxmem
Maximum memory to use in bytes (0 means unlimited)
Definition: jtree.h:104
dai::JTree::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: jtree.h:92
dai::JTree::beliefs
virtual std::vector< Factor > beliefs() const
Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm...
Definition: jtree.cpp:255
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::JTree::Properties::heuristic
HeuristicType heuristic
Heuristic to use for constructing the junction tree.
Definition: jtree.h:101
dai::JTree::Properties::inference
InfType inference
Type of inference.
Definition: jtree.h:98
dai::JTree::init
virtual void init(const VarSet &)
Initializes all data structures corresponding to some set of variables.
Definition: jtree.h:134
dai::JTree::Qb
std::vector< Factor > Qb
Inner region beliefs.
Definition: jtree.h:61
dai::JTree::message
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 ...
Definition: jtree.h:169
dai::JTree::_logZ
Real _logZ
Stores the logarithm of the partition sum.
Definition: jtree.h:51
clustergraph.h
Defines class ClusterGraph, which is used by JTree, TreeEP and HAK.
dai::JTree::Properties::DAI_ENUM
DAI_ENUM(UpdateType, HUGIN, SHSH)
Enumeration of possible JTree updates.
dai::JTree::run
virtual Real run()
Runs the approximate inference algorithm.
Definition: jtree.cpp:375
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
regiongraph.h
Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region grap...
dai::JTree::GenerateJT
void GenerateJT(const FactorGraph &fg, const std::vector< VarSet > &cl)
Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence)...
Definition: jtree.cpp:209
dai::RootedTree
Represents a rooted tree, implemented as a vector of directed edges.
Definition: weightedgraph.h:157
dai::JTree::init
virtual void init()
Initializes all data structures of the approximate inference algorithm.
Definition: jtree.h:133
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
dai::JTree::_mes
std::vector< std::vector< Factor > > _mes
Stores the messages.
Definition: jtree.h:48
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai::JTree::belief
virtual Factor belief(const VarSet &vs) const
Returns the (approximate) marginal probability distribution of a set of variables.
Definition: jtree.cpp:227
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::JTree::clone
virtual JTree * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: jtree.h:124
dai::DAIAlg
Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)...
Definition: daialg.h:207
dai::JTree::findEfficientTree
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.
Definition: jtree.cpp:398
dai::JTree::RTree
RootedTree RTree
The junction tree (stored as a rooted tree)
Definition: jtree.h:55
dai::JTree::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: jtree.h:136
dai::JTree::construct
virtual JTree * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: jtree.h:125
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1TProb-members.html0000644000175000017500000006677712552201370021435 0ustar jorismjorism 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 >
toString() const dai::TProb< T >inline
TProb()dai::TProb< T >inline
TProb(size_t n)dai::TProb< T >inlineexplicit
TProb(size_t n, T p)dai::TProb< T >inlineexplicit
TProb(TIterator begin, TIterator end, size_t sizeHint)dai::TProb< T >inline
TProb(const std::vector< S > &v)dai::TProb< T >inline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__abs-members.html0000644000175000017500000000561512552201365022202 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/fbp_8h.html0000644000175000017500000001127412552201363015741 0ustar jorismjorism libDAI: include/dai/fbp.h File Reference
Classes | Namespaces
fbp.h File Reference

Defines class FBP, which implements Fractional Belief Propagation. More...

#include <dai/dai_config.h>
#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.

Classes

class  dai::FBP
 Approximate inference algorithm "Fractional Belief Propagation" [WiH03]. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class FBP, which implements Fractional Belief Propagation.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_141.png0000644000175000017500000000035512552200253015736 0ustar jorismjorism‰PNG  IHDR&,L0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï\IDATxíÝÍ „0 á/À6¤ÿnù¹¬X‰ž<ü®Þ3À5Áå¥Èó™©ùÈÃÅXÖº.¿}”¸L.,#tlGËUfê)?Ðñeš¡'EüùÜØ÷m€°â IEND®B`‚libDAI-0.3.2/doc/html/form_116.png0000644000175000017500000000056512552200245015744 0ustar jorismjorism‰PNG  IHDR#¶ìÐ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïäIDATxí r… E£ ¶ûßm“ˆ¯àhgº†ûCŽù²€)ÿxÕvjxQ1ª¼<«ªÜ¾<*(³ÄÖa`Ø¥í¥ÔF2Ó&v0ë0£&cG̱œIÉ™U‘`õãvF ÊÇ8€›NF—xû’º˜ôa^tcBê‡x&Æñû ý[_újiœc¼>Y{ º‘ž¬øåÇÔ^À’½Áf«íÐñWãT|à‡2I}Å´›ûÍ™~¸I¨j7FS’˜(XÆ ñòü–ân¡zsd=CÔ2ûÉ?d€wýø„ ΂ÿIEND®B`‚libDAI-0.3.2/doc/html/functions_vars_u.html0000644000175000017500000001171312552201370020156 0ustar jorismjorism libDAI: Class Members - Variables
 

- u -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/cbp_8h.html0000644000175000017500000001217112552201363015733 0ustar jorismjorism libDAI: include/dai/cbp.h File Reference
Classes | Namespaces
cbp.h File Reference

Defines class CBP, which implements Conditioned Belief Propagation. More...

#include <dai/dai_config.h>
#include <fstream>
#include <boost/shared_ptr.hpp>
#include <dai/daialg.h>
#include <dai/bbp.h>

Go to the source code of this file.

Classes

class  dai::CBP
 Class for CBP (Conditioned Belief Propagation) [EaG09]. More...
 
struct  dai::CBP::Properties
 Parameters for CBP. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class CBP, which implements Conditioned Belief Propagation.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_16.png0000644000175000017500000000150312552200217015653 0ustar jorismjorism‰PNG  IHDR„$†b{0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï²IDATxíï’œ ÄòOÀuyÿ·Í *bN7›T­—T…²ï\ıé™i¾ü«À·bà›ÿ“ø[IØcÜ‚ž„ ¥”PG,e ·à˜_Ê*ÊvðçpC»Îa§‡í¾I¢ Þ¦Z3•à“Æ5©sƒîè®A¥‡Ä15}ð]SÓîúç Sÿ||×/IÅ<oC?]Ǭ«ósHõО¼À{Jƒ·‘¶„Ñd(–QÞ yÎÄI¥i~‰3ƒ 8cºÝkp \H-:±ö´-Þú${}½”aªËæ¥Æ´ŒËJ=#1š§1è>LpV2[ƒ{Yì›wÁ×cЮÅyKKýª°ÐõÐ]fnã¥)jIÈ6“(àdmfpK’'!Uîļ¹ÜÚxSY¬$ì6Öðm¼¬ I±&—\³ _Xƒ/‚Î*µÕ½n$¤VIê y ¥®\ Ó/v.›åœ„”„&¤ÍÔàAÉy|S[×å²5°—7 §gQqö•×8%1¦è‚Á¶ Ü–ððÞÒ0qI}'¬î]Õ)wy=òè|-¯-:ŒµêLVâj"‚æ`¨Ÿÿêº<®]íßÝÿ.|bq‰1YéÖŸƒç`}å`Oz.î á.k@ÊÝÎIØÕ IÊ—àØ°ü8U{÷‘þˆºK^Ï}½¼{€uÁ¯gÞÃx0Ó¸};ˆÏܯ>ßR?¢L»ø8œrاæ\G øLuõ½9î†)ÉZÿ\<à;`ï*D:¾k%/{à#0zìϪ‹‹b&õg€û`j7ˆí™dµ(ÅÚ9Ü‚¼YÞòߟ¸0ÀgÑŽ±9Ê]­Üƒ©Vƒ0ÉÕ#&ÄÜçš›SMÞUcI„-cß8·À­ŽáSJVÎÌß×áéª|H IEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1HAK_1_1Properties.html0000644000175000017500000004177512552201366022312 0ustar jorismjorism libDAI: dai::HAK::Properties Struct Reference
Public Member Functions | Public Attributes | List of all members
dai::HAK::Properties Struct Reference

Parameters for HAK. More...

#include <dai/hak.h>

Public Member Functions

 DAI_ENUM (ClustersType, MIN, BETHE, DELTA, LOOP)
 Enumeration of possible cluster choices. More...
 
 DAI_ENUM (InitType, UNIFORM, RANDOM)
 Enumeration of possible message initializations. More...
 

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr) More...
 
size_t maxiter
 Maximum number of iterations. More...
 
double maxtime
 Maximum time (in seconds) More...
 
Real tol
 Tolerance for convergence test. More...
 
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping) More...
 
ClustersType clusters
 How to choose the outer regions. More...
 
InitType init
 How to initialize the messages. More...
 
bool doubleloop
 Use single-loop (GBP) or double-loop (HAK) More...
 
size_t loopdepth
 Depth of loops (only relevant for clusters == ClustersType::LOOP) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_q.html0000644000175000017500000001053312552201370020151 0ustar jorismjorism libDAI: Class Members - Variables
 

- q -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_q.html0000644000175000017500000001201112552201370017107 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- q -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1TreeEP_1_1Properties.html0000644000175000017500000002477312552201370023025 0ustar jorismjorism libDAI: dai::TreeEP::Properties Struct Reference
Public Member Functions | Public Attributes | List of all members
dai::TreeEP::Properties Struct Reference

Parameters for TreeEP. More...

#include <dai/treeep.h>

Public Member Functions

 DAI_ENUM (TypeType, ORG, ALT)
 Enumeration of possible choices for the tree. More...
 

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr) More...
 
size_t maxiter
 Maximum number of iterations. More...
 
double maxtime
 Maximum time (in seconds) More...
 
Real tol
 Tolerance for convergence test. More...
 
TypeType type
 How to choose the tree. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_27.png0000644000175000017500000000174012552200221015653 0ustar jorismjorism‰PNG  IHDR¢'»QcB0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïOIDATxíý–£(Å (Êû¿í*vp’>;îÝ7AðzëVÕ¿ÿs à'ÃÙð£1ü¥ð/ñ_£8­ëÚÎ&•üº®ÍœÞ„ E£Uû0.Æ¡ýc\Ê>Fð.\mbTÍ¥mÅr±^ €—1äQ"pÅ؈´Ó-ÑéæÚÇ­ýÙ¾@qÕq•»há%0kÚß>ðxp+ pÎ8àœñV¢Š~Úã ÔÑ-ÇŸ8¢ºÐ ÀKÐQNxÀ ÅÓþQå|“ÞD‹»œß‘,¼†éjÇçU "ÐNs ë“LA®W9^2nÐqn 8"çØyÖE³ˆÅªÙò]gf;ÄÔyÔæÉ.Ìï4ÄyÞ£UôsSq¿/£Í€ ¤ò´z¢¢KtŒw6í’ÇF=‰ “ˇœÉw”[æ–8TŠ@3õv àœR>¢O1ä““7ê3TÙ\¿Ž“³gŒk-®f(ƪÛ]=ÂÍh»Ê3Š[:?ó™Ê®±¤fý:(ú#’1+KÑubÍ–ôŘ{ã¸ÇÔÏÿ>ŬI擽¸$Y“Éæ"ÃNLúçn=+‹ G˜d5¦â-!xD—âÿ\ø¤e°“ϼDÏt\}©€©ßd;÷«ea±Æ¶­X ÐA¢Î9Rù4Ep·âÜk$Mw1AöÌé£Ûrö楮µzkÿÛZ¢CÑ…¬ˆÝ²ó›î¢}HÇ<ö›²íÑiæ¶*¦ê³]Î9,Sû5Ee/Ýø˜†Ýâð9\.-CžPøz,—ôÃP†qÎoñ(·Ùp{g”ûOjÀoÃ,ixò¢c"]SøêªV"¯j;TÃû 7ÐÌqBO&Id%Þ*%¬²&䬰›ü€u‰·Û’¾ ®0Š*õ»*]Úy©óßävT‰´¸1E÷û ô‘B ð'à ËÁD>‚6IEND®B`‚libDAI-0.3.2/doc/html/var_8h.html0000644000175000017500000001025212552201363015755 0ustar jorismjorism libDAI: include/dai/var.h File Reference
Classes | Namespaces
var.h File Reference

Defines class Var, which represents a discrete random variable. More...

#include <iostream>
#include <sstream>
#include <dai/exceptions.h>

Go to the source code of this file.

Classes

class  dai::Var
 Represents a discrete random variable. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class Var, which represents a discrete random variable.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__pow-members.html0000644000175000017500000000563512552201365022244 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1RootedTree-members.html0000644000175000017500000000621012552201370022433 0ustar jorismjorism libDAI: Member List
dai::RootedTree Member List

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

RootedTree()dai::RootedTreeinline
RootedTree(const GraphEL &T, size_t Root)dai::RootedTree
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1VarSet-members.html0000644000175000017500000004023612552201370021571 0ustar jorismjorism libDAI: Member List
dai::VarSet Member List

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

back()dai::SmallSet< Var >inline
back() constdai::SmallSet< Var >inline
begin()dai::SmallSet< Var >inline
begin() constdai::SmallSet< Var >inline
const_iterator typedefdai::SmallSet< Var >
const_reverse_iterator typedefdai::SmallSet< Var >
contains(const Var &t) constdai::SmallSet< Var >inline
elements()dai::SmallSet< Var >inline
elements() constdai::SmallSet< Var >inline
empty() constdai::SmallSet< Var >inline
end()dai::SmallSet< Var >inline
end() constdai::SmallSet< Var >inline
erase(const Var &t)dai::SmallSet< Var >inline
front()dai::SmallSet< Var >inline
front() constdai::SmallSet< Var >inline
insert(const Var &t)dai::SmallSet< Var >inline
intersects(const SmallSet &x) constdai::SmallSet< Var >inline
iterator typedefdai::SmallSet< Var >
nrStates() const dai::VarSetinline
operator&(const SmallSet &x) constdai::SmallSet< Var >inline
operator&=(const SmallSet &x)dai::SmallSet< Var >inline
operator/(const SmallSet &x) constdai::SmallSet< Var >inline
operator/=(const SmallSet &x)dai::SmallSet< Var >inline
operator/=(const Var &t)dai::SmallSet< Var >inline
operator<<(std::ostream &os, const VarSet &vs)dai::VarSetfriend
SmallSet< Var >::operator<<(const SmallSet &x) constdai::SmallSet< Var >inline
operator>>(const SmallSet &x) constdai::SmallSet< Var >inline
operator|(const SmallSet &x) constdai::SmallSet< Var >inline
operator|=(const SmallSet &x)dai::SmallSet< Var >inline
operator|=(const Var &t)dai::SmallSet< Var >inline
rbegin()dai::SmallSet< Var >inline
rbegin() constdai::SmallSet< Var >inline
rend()dai::SmallSet< Var >inline
rend() constdai::SmallSet< Var >inline
reverse_iterator typedefdai::SmallSet< Var >
size() constdai::SmallSet< Var >inline
SmallSet()dai::SmallSet< Var >inline
SmallSet(const Var &t)dai::SmallSet< Var >inline
SmallSet(const Var &t1, const Var &t2)dai::SmallSet< Var >inline
SmallSet(TIterator begin, TIterator end, size_t sizeHint)dai::SmallSet< Var >inline
toString() const dai::VarSetinline
VarSet()dai::VarSetinline
VarSet(const SmallSet< Var > &x)dai::VarSetinline
VarSet(const Var &v)dai::VarSetinline
VarSet(const Var &v1, const Var &v2)dai::VarSetinline
VarSet(VarIterator begin, VarIterator end, size_t sizeHint=0)dai::VarSetinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_105.png0000644000175000017500000000403512552200243015734 0ustar jorismjorism‰PNG  IHDRÌ"å<ò0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïŒIDATxííšë¦…_¾lâ8áþïöm°ÉÌtï§=én\Ôt(KkIâ/ÀÇ>ð1€| àÿd.ÆØ® »1Æn€?Ŧc»ÀO-ÆØ­·bÆ¥t›¶ïöHIÑ­)í›Ó’ÒðS{«ü`æ”æ#¹gJ?µßbàoµØ%cÖ¨?¹Ù %ßàÞÅŒæ4kM÷®œÿJkþ3³õ©qÛÖ¶ · l{@»Ê€Æ”_ÛYóêðkfO]h¡¿ªy¤èýM ú-ø·Ìôv?€/lìÊ Úu»GïïI®©U‡~úèîcmv.óÅÍe_SŸW[îêù\ ßTÁ(/—Z¥.ˆ&½b½úù^|৽&¾maÌ´8ΊŸ{ jµásì%GFbf·åpµSjõ{ö «74Ô…kaÜ4J½d,fœc½Ê\›AÈ.õA^φƒr=p,Í`ÚQ‡O‚ áìôÌZìlj3ŽK ºÉ|¾ò&$Ñ×ãý–ÔKÞ‹©¥®mÒmÌåÖ ÅXÌÇ¡40Ь GÀ±Fy5)™÷”3°{ 7­ÿL=}#8ÇÍ*IJÝ?`æÀq TüFb|¾òÒ¤§8Ë¿M˜ü¤Aä0j¿©m {¢/ù\ u!ÈÇ¡,à:ÿ÷EL· ¿2lƒ·á f=#4“?¶r^¾tvÁgeüÓ‡íú S¾GäåÎt#æY"¸„8[sÞå¸0ÓàÐ@Þ;¶L‹_æÅÆ9Ç÷~Rô Ÿ¯¼rÒ«ÃÈS‘³©ÇÝ®eˆõkzêZk¹8N ë%„cäÃgõƒ•¨ÙÓÊ?•î’¸ŠyEa•=­¡'q’ÿÒ×ê-¼ÈqDŸE°»cõ$—³¾=Ž·ì|F¤·ìÌ·òÔ ¢—1ôVrrGÁŸ™©8¶@Vð…e»­øIn¹´âÌYb¾¦òù•—$mó‘{tò³!Ö ·ª¬_ŸÀÉRjÓ×/ñìSúMywò®W™5z/æ…ÏÃÙÜq̹KFeîjÈ"¦qõË÷‹$òÚ/=Ç™ù§\#s*‡×ëu r^þ|w±½Ó—´ßÚ³ “@SölP Ä<3SqÈÞ–W¡Síb®¹9Sþ‰ºUù”ûz¯`ÓçMqxúí½09Ýfdt¶Þ@ØÕ©¯iô¢YmïÊ`/æE=ž,påGÅœÊ'g¶G¾^RÅÖ–ÈCs‘³ÄÖëËÎv¸þì©a×w¤M '5ƒ!¥®bž˜©8öÁ¾Òwæ3‡I&<òhøüÂK’ÎUÂc&îOÀ3×H3Ýê×ÊÖMá~ö ›7¹U¯Ô1ksIæ+º¹ïb^QhmVåò…Æø,ÅžÅiÌÎ9Å\µ?DL,®D_IÌ^¯Î;¢êózÌ27Ú”ƒzΔç 8ÖUÌ3‡zêÀÌM'J¨®3…”Ù×®*|~éeŸÁÜfœ´ÚCÆòt<œó÷=p,û5í>¿·¿­Íô*uV»§MV&ýAwæ¨8¹ä9£¨tå2üGd2QµäíPÉA/áKõ漦»¼Â–e‰Q d%äëôúIbˆª¦¼¿ m>Òg1¥_Ììì¹®¥7ô‰›R;3£8|N¶V…è&âêFñ3ËÍZQOîk,U«|Z½¯ñ*õ6?M?KFþ&ƒ"ËTGWOU—ÊHKahWº)—qNÞ”±U©Ë)–ò˜Ší\QNÞMìd½b®ÅpõvÎ °½Ë9Ý1‹ŽÌLÑ|\oZDÕGýuˆœÅ¬óí'{….4Ó·•Ûrâ÷¿ 3Ç’Oå@’”zèFñ“ .ë õ¾Ö«8n«Øó ·~ \ì1:“' ÀÙL}¥ŸPŠù¦ŠÝvfÕ6’7T)j8«!C?e_µ>»6Óp»¾I¿ú(eªSÇçò=à¬n̘Ùkâ3O— ´ÉK7¿½;–ô¾ÖK7.^2m}>_Ù2w ¹M^àXÏA˧åΆ©±%Œï¢5(ìª}-ƒÒTmÈ1TÂy¤Ä¦ËõrÑÙ'è—sŒ‚mâ´ptJœlG÷’¯!š¼tã’Õ§Içv{_ã¥#.^OÖ&•®òçZ]éÚÇ`Ÿ xû{¹\:FqöA"ÀņÍ9B)‘ô{w÷]õøf‚¹=ÌwÌô¿¯Ñïð…½ãó·”J‰ì“×:7¯éÅ`¸Ú;À?cf@Ë>¸saI§çà ûfþN³)¥n•bM)µküšü mJ)µk4‡†öÞÌcÚ5ÜüÉ´ø—˜1¦]?6cL·>ð1€| ``fòà¿dîŒ\f€ÿ”E€?Òžh—›BpÚe„™ð¶–€vYç~‚ÛŸÚ±6¬¿`ÉJW¿o¥ûkf³Êø«¼µY¿üŠY%å}ŸÜKz»:'Å÷ø#mµç—à{3Ó¥;§À;šOg1]“—Ÿ·… ð[ö ¿*¦ŸåÉ4Ë»¶¦1/ÝäqøÐ-ß÷ÑøÀ»ØÿÊ:9;@ŠžIEND®B`‚libDAI-0.3.2/doc/html/clustergraph_8h.html0000644000175000017500000002271312552201363017675 0ustar jorismjorism libDAI: include/dai/clustergraph.h File Reference
Classes | Namespaces | Functions
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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

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. More...
 
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. More...
 
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. More...
 
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. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1JTree.png0000644000175000017500000000212112552201366017562 0ustar jorismjorism‰PNG  IHDR­ÀAõPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2àIDATxíá’« F3¾ÿ#_+ZjÛ­¦^fâxV ²É9çn KR'„­$ù¶’äÃiÛ´m­]JS»t˜nIú† m_ •ëí¶cêiJ¡ÍíØÿø»¤öi;ß IßpÊvš5¤dÏgë9lF$é+ÎÚ.©ZÔL{ßöÖÜ.+á•mþ_l­ÚÖöYþÛzÝ~`{ߺµ5ajÙsÏöÖš I¦Û[×­$ýùÿ…$}ÃïW‚$}KØJ’a+I>Œ¶9çÜ  ÝЕí0ô¤Û•í(Û‘n_¶Q¼[ÂÀ‡°ð!l|[ÂÀ‡°ð!l|[ÂÀ‡°ð!lGÎ9wY’:!l%ɇ°•$*Û´m¥ÇQunÿJªN{ÏÞäU $m9è>°­»µõ‡mKRÅ‹!Iëùn IªYmÇ×|Ä”×]skçݵïÛ³˜SW"ìäõ3ÊlÍØnÖŸ¶Sü<§”Ì))3ßW¤jÛ:ÂtØ©—;›13n¼­í2ngúÄvIq»n눪Õ&»z°™µñÝØ–'íÙZ‡µ½óÝš¨W¶Æ« ®Ö×<k[Ídmm£m·¹­?Ðg¶;yÛæÝšslûçu[忱­sp´nmMXöpÙ©óÆ>°ýª&¬¿ýaêÅNQ¸äÙûÚúAõý$ð´íAþñ;ÛåsKÒï#~g+I¿"l%ɇ°•$FÛœsî€nèÊvzÒíÊv”íH·/Û¨ ^„-€a àCØø¶>„-€a àCØø¶>„-€a àCØø¶#¥”ºÐ a àCØøpÚv½½šhœwÞÅWq¡-°žS÷åŸíœí\K ›Ü>{¦˜9Ë'“}Êv²(Rå2ÿhl«sÙ9ikìŽsûÙ–ÝôÒv9¹ï®°5—:åun/Øv×®Û—¶w¯[ÊÎ~w“J[ î¬ ?%l|[ÂÀ‡îlSJ©º¡+ÛaèI·+ÛQ¶#ݾl£&x¶>„-€a àCØø¶>„-€a àCØø¶>„-€a àCØ>Žœs¾ž!眯‡,I¶’äCØJ’§lÓ¦•Ê!I-ËÈa€$½á"Ûwö…^IÒ ¾·ôxfI”yziNƒsë[l'™òØr™,¶ÕØsðFÛå™FÅävc{çº}ê…]ÛJ¯Ê­$}ÁYÛæ3or»¹ÜfÛ¬Íw+áN[[J¨wÙZ –šÐ¬Iú+ñŸW’|[Iò!l%ɇ°•$FÛœsî…˜FhfÓt€IEND®B`‚libDAI-0.3.2/doc/html/functions_type.html0000644000175000017500000001370612552201370017644 0ustar jorismjorism libDAI: Class Members - Typedefs
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/glc_8h_source.html0000644000175000017500000012444712552201363017326 0ustar jorismjorism libDAI: include/dai/glc.h Source File
glc.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2012, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
12 
13 
14 #ifndef __defined_libdai_glc_h
15 #define __defined_libdai_glc_h
16 
17 
18 #include <dai/dai_config.h>
19 #ifdef DAI_WITH_GLC
20 
21 
22 #include <algorithm>
23 #include <set>
24 #include <string>
25 #include <dai/util.h>
26 #include <dai/daialg.h>
27 #include <dai/enum.h>
28 #include <dai/cobwebgraph.h>
29 #include <dai/properties.h>
30 #include <dai/exceptions.h>
31 
32 
33 namespace dai {
34 
35 
37 
43 class Cobweb {
44  public:
46  DAIAlgFG *cav;
47 
49 
57  std::map<int, size_t> _g2l;
58 
60  Cobweb(){}
61 
63  Cobweb( const std::map<int, size_t>& g2l ): cav(0), _g2l(g2l) {}
64 
66  virtual ~Cobweb(){ delete cav; }
67 
69  void setInfAlg( DAIAlgFG* alg ) {
70  cav = alg;
71  }
72 
74  Factor factor( size_t I ) {
75  return cav->factor( _g2l[I] );
76  }
77 
79  void initialize() {
80  cav->init();
81  }
82 
84  Factor marginal( const VarSet& ns, const std::vector<size_t>& rmgind ) {
85  // Set the factors in rmgind to one
86  VarSet vs;
87  std::vector<size_t> rmlinds; // local index
88  rmlinds.reserve( rmgind.size() );
89  for( std::vector<size_t>::const_iterator it = rmgind.begin(); it != rmgind.end(); it++ ) {
90  vs |= cav->factor( _g2l[*it] ).vars();
91  rmlinds.push_back( _g2l[*it] );
92  }
93  cav->makeRegionCavity( rmlinds, true );
94  // Initialize if necessary
95  cav->init( vs );
96  cav->run();
97  Factor result;
98  result = cav->belief( ns );
99  cav->restoreFactors();
100  return result;
101  }
102 
104 
106  Factor marginal( const int& outmsgind, const std::vector<size_t>& rmgind ) {
107  // set the factors in rmgind to one
108  VarSet vs;
109  std::vector<size_t> rmlinds; // local index
110  rmlinds.reserve( rmgind.size() );
111  for( std::vector<size_t>::const_iterator it = rmgind.begin(); it != rmgind.end(); it++ ) {
112  vs |= cav->factor( _g2l[*it] ).vars();
113  rmlinds.push_back( _g2l[*it] );
114  }
115  cav->makeRegionCavity( rmlinds, true );
116  // Initialize if necessary
117  cav->init( vs );
118  cav->run();
119  Factor result;
120  result = cav->beliefF( _g2l[outmsgind] );
121  cav->restoreFactors();
122  return result;
123  }
124 
126  void updateFactor( int gind, const Factor& msg, bool multiply=false ) {
127  if( !multiply )
128  cav->setFactor( _g2l[gind], msg, false );
129  else
130  cav->setFactor( _g2l[gind], (msg*(cav->factor( _g2l[gind] ))).normalized(), false );
131  }
132 
134  Factor belief( const Var v ) {
135  cav->run();
136  return cav->belief( v );
137  }
138 
140  Factor belief( const VarSet& vs ) {
141  cav->run();
142  return cav->belief( vs );
143  }
144 };
145 
146 
148 
158 class GLC : public DAIAlgCG {
159  private:
161  std::vector<Cobweb> _CWs;
162 
164  std::vector<int> _outOffset;
165 
167 
172  std::vector<std::vector<Factor> > _cavitydists;
173 
175  std::vector<Factor> _beliefs;
176 
178  std::map<VarSet, Factor> _factorBeliefs;
179 
181  Real _maxdiff;
182 
184  size_t _iters;
185 
186  public:
188  struct Properties {
190 
196  DAI_ENUM(CavityType,FULL,PAIR,PAIR2,UNIFORM);
197 
199 
210  DAI_ENUM(RegionType,SINGLE,FACTOR,OVFACTOR,LOOP,OVLOOP,DELTA,OVDELTA)
211 
212 
213 
217  DAI_ENUM(UpdateType,SEQFIX,SEQRND);
218 
220  size_t verbose;
221 
222  // Maximum length of the loops to use in construction of loopy regions
223  size_t loopdepth;
224 
226  size_t maxiter;
227 
229  Real maxtime;
230 
232  Real tol;
233 
235  bool reinit;
236 
238 
241  bool auxfactors;
242 
244  CavityType cavity;
245 
246  // Type of region
247  RegionType rgntype;
248 
250  UpdateType updates;
251 
259  CobwebGraph::NeighborType neighbors;
260 
262  std::string cavainame;
263 
265  PropertySet cavaiopts;
266 
267  // Name of the algorithm used for marginalization over a region (EXACT is fine)
268  std::string inainame;
269 
270  // Parameters for algorithm used for marginalization over a region
271  PropertySet inaiopts;
272  } props;
273 
274 
275  public:
277  GLC() : DAIAlgCG(), _CWs(),_outOffset(), _cavitydists(), _beliefs(), _factorBeliefs(), _maxdiff(), _iters(), props() {}
278 
280 
283  GLC( const FactorGraph &fg, const PropertySet &opts );
284 
286 
287  virtual GLC* clone() const { return new GLC(*this); }
288  virtual GLC* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new GLC( fg, opts ); }
289  virtual std::string name() const { return "GLC"; }
290  virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); }
291  virtual Factor belief( const VarSet &vs ) const;
292  virtual Factor beliefV( size_t i ) const { return _beliefs[i]; }
293  virtual std::vector<Factor> beliefs() const;
294  virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; }
295  virtual void init(){ initCWs(); }
296  virtual void init( const VarSet &/*ns*/ ) { init(); }
297  virtual Real run();
298  virtual Real maxDiff() const { return _maxdiff; }
299  virtual size_t Iterations() const { return _iters; }
300  virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; }
301  virtual void setProperties( const PropertySet &opts );
302  virtual PropertySet getProperties() const;
303  virtual std::string printProperties() const;
305 
307 
308  const Cobweb& CW( size_t alpha ) const {
310  DAI_DEBASSERT( alpha < nrCWs() );
311  return _CWs[alpha];
312  }
313 
315  Cobweb& CW( size_t alpha ) {
316  DAI_DEBASSERT( alpha < nrCWs() );
317  return _CWs[alpha];
318  }
319 
321  Real CalcCavityDist( size_t i, const std::string &name, const PropertySet &opts );
322 
324  Real InitCavityDists( const std::string &name, const PropertySet &opts );
325 
327  void NewPancake( size_t R, size_t _R2 );
328 
330 
332  void OVNewPancake( size_t R );
333 
335  void CalcBelief( size_t i, bool isFinal = false );
336 
338  void CalcFactorBelief( size_t I );
339 
341  std::vector<SmallSet<size_t> > calcRegions();
342 
344  void initCWs();
345 
347 
351  void setCWs( const std::string &name, const PropertySet &opts );
352 
354 
356  void findLoopClusters( SmallSet<size_t>& remaining, std::set<SmallSet<size_t> > &allcl, SmallSet<size_t> newcl, const size_t& root, size_t length, SmallSet<size_t> vars );
357 
359 
361  void findOVLoopClusters( SmallSet<size_t>& remaining, std::set<SmallSet<size_t> > &allcl, SmallSet<size_t> newcl, const size_t& root, size_t length, SmallSet<size_t> vars );
363 };
364 
365 
366 } // end of namespace dai
367 
368 
369 #endif
370 
371 
372 #endif
dai::Factor
TFactor< Real > Factor
Represents a factor with values of type dai::Real.
Definition: factor.h:640
std
STL namespace.
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
cobwebgraph.h
Defines class CobwebGraph, which implements a type of region graph used by GLC.
dai::DAIAlgCG
DAIAlg< CobwebGraph > DAIAlgCG
Base class for GLC that operates on CobwebGraph.
Definition: daialg.h:269
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::DAI_ENUM
DAI_ENUM(LDPCType, SMALL, GROUP, RANDOM)
Possible LDPC structures.
util.h
Defines general utility functions and adds an abstraction layer for platform-dependent functionality...
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::DAIAlgFG
DAIAlg< FactorGraph > DAIAlgFG
Base class for inference algorithms that operate on a FactorGraph.
Definition: daialg.h:263
dai
Namespace for libDAI.
Definition: alldai.cpp:16
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_d.html0000644000175000017500000002063312552201370020116 0ustar jorismjorism libDAI: Class Members - Functions
 

- d -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_b.html0000644000175000017500000001124112552201370020127 0ustar jorismjorism libDAI: Class Members - Variables
 

- b -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1CondProbEstimation.html0000644000175000017500000007152412552201365022510 0ustar jorismjorism libDAI: dai::CondProbEstimation Class Reference
Public Member Functions | Static Public Member Functions | Private Attributes | Static Private Attributes | List of all members
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

Public Member Functions

 CondProbEstimation (size_t target_dimension, const Prob &pseudocounts)
 Constructor. More...
 
virtual ParameterEstimation * clone () const
 Virtual copy constructor. More...
 
virtual ~CondProbEstimation ()
 Virtual destructor. More...
 
virtual Prob parameters (const Prob &p)
 Returns an estimate of the conditional probability distribution. More...
 
virtual Prob parametersToFactor (const Prob &p)
 Convert a set of estimated parameters to a factor. More...
 
virtual size_t probSize () const
 Returns the required size for arguments to estimate(). More...
 
virtual const std::string & name () const
 
virtual const PropertySet & properties () const
 

Static Public Member Functions

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

Private Attributes

size_t _target_dim
 Number of states of the variable of interest. More...
 
Prob _initial_stats
 Initial pseudocounts. More...
 
PropertySet _props
 PropertySet that allows reconstruction of this estimator. More...
 

Static Private Attributes

static std::string _name = "CondProbEstimation"
 

Additional Inherited Members

- Private Types inherited from dai::ParameterEstimation
typedef ParameterEstimation *(* ParamEstFactory) (const PropertySet &)
 Type of pointer to factory function. More...
 
- Private Member Functions inherited from dai::ParameterEstimation
virtual ~ParameterEstimation ()
 Virtual destructor for deleting pointers to derived classes. More...
 
virtual Prob estimate (const Prob &p)
 Estimate the factor using the provided expectations. More...
 
- Static Private Member Functions inherited from dai::ParameterEstimation
static ParameterEstimation * construct (const std::string &method, const PropertySet &p)
 General factory method that constructs the desired ParameterEstimation subclass. More...
 
static void registerMethod (const std::string &method, const ParamEstFactory &f)
 Register a subclass so that it can be used with construct(). More...
 

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_dimensionshould equal $ | X | $
pseudocountsare the initial pseudocounts, of length $ |X| \cdot |Y| $
virtual dai::CondProbEstimation::~CondProbEstimation ( )
inlinevirtual

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
inlinevirtual

Virtual copy constructor.

Implements dai::ParameterEstimation.

Prob dai::CondProbEstimation::parameters ( const Prob &  p)
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.

Prob dai::CondProbEstimation::parametersToFactor ( const Prob &  params)
virtual

Convert a set of estimated parameters to a factor.

Implements dai::ParameterEstimation.

virtual size_t dai::CondProbEstimation::probSize ( ) const
inlinevirtual

Returns the required size for arguments to estimate().

Implements dai::ParameterEstimation.

Member Data Documentation

size_t dai::CondProbEstimation::_target_dim
private

Number of states of the variable of interest.

Prob dai::CondProbEstimation::_initial_stats
private

Initial pseudocounts.

PropertySet dai::CondProbEstimation::_props
private

PropertySet that allows reconstruction of this estimator.

The documentation for this class was generated from the following files:
  • include/dai/emalg.h
  • src/emalg.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_l.html0000644000175000017500000001641112552201370017112 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- l -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/enum_8h.html0000644000175000017500000001277312552201363016143 0ustar jorismjorism libDAI: include/dai/enum.h File Reference
Macros
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.

Macros

#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. More...
 

Detailed Description

Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.

Macro Definition 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:
1 DAI_ENUM(colors,RED,GREEN,BLUE)
defines a class colors encapsulating an
1 enum {RED, GREEN, BLUE};
which offers additional functionality over the plain enum keyword.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1Neighbor.html0000644000175000017500000003574712552201367020732 0ustar jorismjorism libDAI: dai::Neighbor Struct Reference
Public Member Functions | Public Attributes | List of all members
dai::Neighbor Struct Reference

Describes the neighbor relationship of two nodes in a graph. More...

#include <dai/graph.h>

Public Member Functions

 Neighbor ()
 Default constructor. More...
 
 Neighbor (size_t iter, size_t node, size_t dual)
 Constructor that allows setting the values of the member variables. More...
 
 operator size_t () const
 Cast to size_t returns node member. More...
 

Public Attributes

size_t iter
 Corresponds to the index of this Neighbor entry in the vector of neighbors. More...
 
size_t node
 Contains the absolute index of the neighboring node. More...
 
size_t dual
 Contains the "dual" index (i.e., the index of this node in the Neighbors vector of the neighboring node) More...
 

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;
bforeach( 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_90.png0000644000175000017500000000046512552200237015665 0ustar jorismjorism‰PNG  IHDR, .ö¯0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï¤IDATxíIÄ D+§pÿÛ¶†vHzÝËz úåðÇy^W8àwúZî˜5ŒÔ5W]Ä̳6kÿr‘¹­´¬Sÿ˜oó©#Ñ–Ë›·ºŽm—xZŽh\]á°€ê@äêÌÜÈFY^ (é…lo”'3$¹æx"“ÕR°†ïÍcYªŠÄÑ°Ÿ-*àŸ[4¦Ùe‰MíjÛÚã4¹º`PãßIEND®B`‚libDAI-0.3.2/doc/html/matlab_8h.html0000644000175000017500000001332512552201363016431 0ustar jorismjorism libDAI: include/dai/matlab/matlab.h File Reference
Namespaces | Functions
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

 dai
 Namespace for libDAI.
 

Functions

mxArray * dai::Factors2mx (const std::vector< Factor > &Ps)
 Convert vector<Factor> structure to a cell vector of CPTAB-like structs. More...
 
vector< Factor > dai::mx2Factors (const mxArray *psi, long verbose)
 Convert cell vector of CPTAB-like structs to vector<Factor> More...
 
Factor dai::mx2Factor (const mxArray *psi)
 Convert CPTAB-like struct to Factor. More...
 

Detailed Description

Defines some utility functions for interfacing with MatLab.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_77.png0000644000175000017500000000115212552200234015661 0ustar jorismjorism‰PNG  IHDRE ñ¥0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÙIDATxíÑ’¬ Dˆ 8Êÿÿí& :N•uoÕ>-EVH:I÷â+ÀŸœlZÚpÿf~±÷6}š>CöF†ËçåqHnF äÀEÝšÎ@=¹Óúêv Ï)ûáða&/0§ïðhîɺði'Ï Œó>1cÀÅZ\ÁOâ¿ÞS躯ôyª^•±'ø&‡;xZ½‚¿‹ÿÒìTÂWJzÇmÜ*Δßy<Ág}wÍ^ŽG½‚Ÿe¯á‹XDO6¹I˜ƒ­°”…Ò•çõ“ÞÉúgªA_ îøE4/m†ð·çü…\"‡÷±×ÈŠ?ô¿P\#j†~íú=¾ÄSû‡”–ù²óº8Û£™rTyõw¡ÝnëRC°U#¾‘þš¸D]iׄYUJåÔŒ³e(/^jß-^›®ÛUTc‰êÜý¦²]ÂVç•¿*QsJòR ¢§Ký2ü"§UÏ ú®I;¡e½kž—–Güd™‹ôzO(œÿ¦‘áî¼9ÒnöZù·øÒ§%‰¬äµÐsÕê×/DÇ·WŸÓîç¦Ûò.«åaVß$¥ôK;XŒ_îþ à‘é—"D'òµ1¸~UüžÍþ?¾Ä·ö‚ írïWIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1ParameterEstimation-members.html0000644000175000017500000001612412552201367024347 0ustar jorismjorism libDAI: Member List
dai::ParameterEstimation Member List

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

_registrydai::ParameterEstimationprivatestatic
clone() const =0dai::ParameterEstimationpure virtual
construct(const std::string &method, const PropertySet &p)dai::ParameterEstimationstatic
estimate(const Prob &p)dai::ParameterEstimationinlinevirtual
loadDefaultRegistry()dai::ParameterEstimationprivatestatic
name() const =0 (defined in dai::ParameterEstimation)dai::ParameterEstimationpure virtual
ParamEstFactory typedefdai::ParameterEstimation
parameters(const Prob &p)=0dai::ParameterEstimationpure virtual
parametersToFactor(const Prob &params)=0dai::ParameterEstimationpure virtual
probSize() const =0dai::ParameterEstimationpure virtual
properties() const =0 (defined in dai::ParameterEstimation)dai::ParameterEstimationpure virtual
registerMethod(const std::string &method, const ParamEstFactory &f)dai::ParameterEstimationinlinestatic
~ParameterEstimation()dai::ParameterEstimationinlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/nav_h.png0000644000175000017500000000014212552201363015476 0ustar jorismjorism‰PNG  IHDR ,é@)IDATxíÝA @BQ­³šÛ›Ð¢Žáà) )ëý éaÅèÜ¿Æo‡RlÐßIEND®B`‚libDAI-0.3.2/doc/html/form_83.png0000644000175000017500000000047312552200236015665 0ustar jorismjorism‰PNG  IHDR. *80PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïªIDATxíQ… E¯¢)”±ÿÝ>² §ÿ÷Éà˜Ü›jðçUvû¦œà»ò¡=/禗-ñxK‰ˆÂ€7Û(WéQ`±Øüx¶ÕM4L)YÉo«–Ôº˜=Ýktyfsái&¨¨ŽÞ‚bE ¤%#ÐËÇ>Ñ«Û‰Õh;€%':;ù)ÄÊqÄ›¦‹rïê'¥ûßø>Ÿ[<\ûh껂3²ËIEND®B`‚libDAI-0.3.2/doc/html/exactinf_8h.html0000644000175000017500000001220712552201363016770 0ustar jorismjorism libDAI: include/dai/exactinf.h File Reference
Classes | Namespaces
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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines ExactInf class, which can be used for exact inference on small factor graphs.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1ExactInf.html0000644000175000017500000017602712552201365020452 0ustar jorismjorism libDAI: dai::ExactInf Class Reference
Classes | Public Attributes | Private Member Functions | Private Attributes | List of all members
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

Classes

struct  Properties
 Parameters for ExactInf. More...
 

Public Member Functions

Constructors/destructors
 ExactInf ()
 Default constructor. More...
 
 ExactInf (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
General InfAlg interface
virtual ExactInf * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual ExactInf * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
std::vector< size_t > findMaximum () const
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
Additional interface specific for ExactInf
Factor calcMarginal (const VarSet &vs) const
 Calculates marginal probability distribution for variables vs. More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual void setMaxIter (size_t)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 

Public Attributes

struct dai::ExactInf::Properties props
 

Private Member Functions

void construct ()
 Helper function for constructors. More...
 

Private Attributes

std::vector< Factor > _beliefsV
 All single variable marginals. More...
 
std::vector< Factor > _beliefsF
 All factor variable marginals. More...
 
Real _logZ
 Logarithm of partition sum. 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
fgFactor graph.
optsParameters
See also
Properties

Member Function Documentation

virtual ExactInf* dai::ExactInf::clone ( ) const
inlinevirtual

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

Implements dai::InfAlg.

virtual ExactInf* dai::ExactInf::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Implements dai::InfAlg.

virtual std::string dai::ExactInf::name ( ) const
inlinevirtual

Returns the name of the algorithm.

Implements dai::InfAlg.

virtual Factor dai::ExactInf::belief ( const Var &  v) const
inlinevirtual

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_IMPLEMENTEDif not implemented/supported.
BELIEF_NOT_AVAILABLEif the requested belief cannot be calculated with this algorithm.

Implements dai::InfAlg.

virtual Factor dai::ExactInf::beliefV ( size_t  i) const
inlinevirtual

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
inlinevirtual

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
inlinevirtual

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_IMPLEMENTEDif not implemented/supported

Implements dai::InfAlg.

std::vector< 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)
inlinevirtual

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_IMPLEMENTEDif 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
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::ExactInf::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif 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

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_124.png0000644000175000017500000000064512552200247015744 0ustar jorismjorism‰PNG  IHDR;µb0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIDATxíÛr„ D¹(êÿÿmf·*Ù­<$O³bCcwþüg‡øM…T"ÀŸ—u—€ŸË<ׄt6¿axSþA>Œoƒ àm=Vý?,mÁúíÌMrч чý²eLE…­í-®TLu#Z»®:ÛZ…ÜÅ5ä¦é a@¹G9qw¡ÉÕº}òÞ‘;Í íغßÄŠñ»Î‰_ë¼/‚èWTÍ ±;W]ëÚn]¶1Õÿ*»Æ-=AC^ÑeäT3uyD®Ã¼¯‚¨¯ä”—ÔH¾oaY®¿ëôwj'1ŸøŠ‹J»OËõT[ iÜð¤´;ê©Å& àQæú°Ÿ·¦þ àÃú›²`N3IEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1fo__Hellinger.html0000644000175000017500000001235112552201365021711 0ustar jorismjorism libDAI: dai::fo_Hellinger< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_Hellinger< T > Struct Template Reference

Function object useful for calculating the Hellinger distance. More...

#include <dai/prob.h>

Inherits binary_function< T, T, T >.

Public Member Functions

T operator() (const T &p, const T &q) const
 Returns (sqrt(p) - sqrt(q))^2. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_78.png0000644000175000017500000000122512552200235015664 0ustar jorismjorism‰PNG  IHDRŽº‡0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIDATxíÛ’£0 ÛWlðÿÿíJ`³TíÌÓ¦Pœp‘ÚGÇøàü}¸´}<À¿‰”.Â\ÅP£‘¯à>lJƒÖ’/€ë(Œ³çˆw<®ÆÝp®Š„ùû;ej.›á[a¾ŠG8ÌÝÔ­ŒàTùSÎáw˜›„m|†j¸±X9àLakóZÖ­}š·'FëõFq@C†CÝJ"wÔ,ùd˜zΘ’xÓïO]ÆWĬ¦êŽ.Ðäi<'©WÓKËê©Ž£(aÞÇ#;˜º5àí…Ü?s+¤8Ú¬–ÓéÙVA;Ž2—Ϻ÷8e#7ñà8-sL!û˜KÄö×MóÎÜ; £«·¨3cWëUºK“Ó²žÃ(™Ük¥qªëb=/™|Pj{uÉ–^”…P¾ìÈX-Y-­3Z3Fß-ÜVÛÇ]òDoè0èéu% ¥[.RHA^ömÉ·E6#úI¢¸ ŠšŠFÍ€éÙåz8,ŽuÕÚÙ¸‚­òÇ‹¦ÀÇ!ó›%íÙG™$ÀglÛQµn:¼º÷êH7BÒ™§"¾ÔåÌäL8ï’PŽpõz}?à¿Ø¶«ætÕOu–9®CŠˆš“õÝ“Roöj€ñºÛ¿Ýñv7ÊeÞCö²¬ð‡µðë” à‡â=‹ m.]IEND®B`‚libDAI-0.3.2/doc/html/form_55.png0000644000175000017500000000073012552200227015660 0ustar jorismjorism‰PNG  IHDR€7ô0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïGIDATxíM–„ ƒ?ùQïÛ|j3«Ù lèP Ui×ÿx´ Àœ±`“Šà;”ÚFÕ£ø!09l —t`§§‚ /×ZïÜ-5Õ…úDk]À=ªtiF!A_Vifc rµòÓqP¹‡tx0ù¢WbÑs›0í Ê?̤ÁΖÎc’âœ{& ÷Áü؉9ÂEЕ%n .ሰ©ÜÃ@Ÿ QzîÇÀL4¹·§¦²ÚL{‘“kæ2ŸŽëSíU¦äBžÈ^2–—\êVѯóøO@³}\SÄšu+W V€+fm“¸ÎY1ePgéÚI ÙÊoóe4j¨›ÿwR¹7@‰f÷%Ç>N:¤ÈÜ£+bÜ0W‡¿MÏxÚý *Àßâ«äîs̤IEND®B`‚libDAI-0.3.2/doc/html/bp_8h.html0000644000175000017500000001340012552201363015564 0ustar jorismjorism libDAI: include/dai/bp.h File Reference
Classes | Namespaces
bp.h File Reference

Defines class BP, which implements (Loopy) Belief Propagation. More...

#include <dai/dai_config.h>
#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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class BP, which implements (Loopy) Belief Propagation.

Todo:
Consider using a priority_queue for maximum residual schedule
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1RegionGraph.png0000644000175000017500000000105312552201367020762 0ustar jorismjorism‰PNG  IHDRmP$ PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2ºIDATxíÑ’ƒ EaÆÿÿämE!Än˦3;t¼É• úLŒ1º‰("â¤E™¡oÒBÛ ûODÌÕtL­õŠ6êŒî÷÷VE{$÷Œ¤$ËÚTö¹)OCzî´çÈ£«šŠ¶»ÒìAD_™Z‡ìÌ (ÏáSqC;GõóúØʸ¦eªÞ“Ø€–fïîä¦zÅzGS¡Ùñ!­©K«2º¢Uç–£5Íú®k2UVs€ªÞtMªhÞÉTªvíú-é¼~‹&"2C‹&"2Cî´côÀÚÜäJÛ6Oœ+ísÄùÒþuM.À-À -À -À -À -À -À -€U!¸‰à¤E˜¡/ÒJ7÷R%æêdØõÕæ šzaù_—v¼ )Ų¶óïH=¹´ÑúÓ„U,¯:ÓvÏ1uåö){—“®c%®i\Ÿ[¡©4ªÆ¬²±tiiv³“çð MÍ[›¯hæiunkDë¬ûîÜZZ÷ÜÌú+šq^ÖäYwªJ®k²l^}£êµ¡¼¤—è}~E³ïÀ@ÓÎ ¸Õç4€÷µh3äN !/ýöù™¡¶ÚIEND®B`‚libDAI-0.3.2/doc/html/hierarchy.html0000644000175000017500000011561112552201370016547 0ustar jorismjorism libDAI: Class Hierarchy
Class Hierarchy
This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234]
 Cdai::BBPImplements BBP (Back-Belief-Propagation) [EaG09]
 Cdai::BBPCostFunctionPredefined cost functions that can be used with BBP
 Cdai::BP_dual::beliefsGroups together the data structures for storing the two types of beliefs and their normalizers
 Cdai::BipartiteGraphRepresents the neighborhood structure of nodes in an undirected, bipartite graph
 Cdai::BP_dualCalculates both types of BP messages and their normalizers from an InfAlg
 Cdai::ClusterGraphA ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges
 Cdai::CobwebGraph::ConnectionThe information in connection between two regions
 Cdai::DAGRepresents the neighborhood structure of nodes in a directed cyclic graph
 Cdai::DEdgeRepresents a directed edge
 Cdai::BP::EdgePropType used for storing edge properties
 Cdai::EMAlgEMAlg performs Expectation Maximization to learn factor parameters
 Cdai::EvidenceStores a data set consisting of multiple samples, where each sample is the observed joint state of some variables
 ▼Cstd::exceptionSTL class
 ▼Cstd::runtime_errorSTL class
 Cdai::ExceptionError handling in libDAI is done by throwing an instance of the Exception class
 ▼Cdai::FactorGraphRepresents a factor graph
 Cdai::CobwebGraphA CobwebGraph is a special type of region graph used by the GLC algorithm
 Cdai::RegionGraphA RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph
 Cdai::fo_abs< T >Function object that takes the absolute value
 Cdai::fo_absdiff< T >Function object that returns the absolute difference of x and y
 Cdai::fo_divides0< T >Function object similar to std::divides(), but different in that dividing by zero results in zero
 Cdai::fo_exp< T >Function object that takes the exponent
 Cdai::fo_Hellinger< T >Function object useful for calculating the Hellinger distance
 Cdai::fo_id< T >Function object that returns the value itself
 Cdai::fo_inv< T >Function object that takes the inverse
 Cdai::fo_inv0< T >Function object that takes the inverse, except that 1/0 is defined to be 0
 Cdai::fo_KL< T >Function object useful for calculating the KL distance
 Cdai::fo_log< T >Function object that takes the logarithm
 Cdai::fo_log0< T >Function object that takes the logarithm, except that log(0) is defined to be 0
 Cdai::fo_max< T >Function object that returns the maximum of two values
 Cdai::fo_min< T >Function object that returns the minimum of two values
 Cdai::fo_plog0p< T >Function object that returns p*log0(p)
 Cdai::fo_pow< T >Function object that returns x to the power y
 Cdai::GraphALRepresents the neighborhood structure of nodes in an undirected graph
 Cdai::greedyVariableEliminationHelper object for dai::ClusterGraph::VarElim()
 Cdai::hash_map< T, U, H >Hash_map is an alias for std::tr1::unordered_map
 Cdai::IndexForTool for looping over the states of several variables
 ▼Cdai::InfAlgInfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI
 ▼Cdai::DAIAlg< GRM >Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)
 ▼Cdai::BPApproximate inference algorithm "(Loopy) Belief Propagation"
 Cdai::FBPApproximate inference algorithm "Fractional Belief Propagation" [WiH03]
 Cdai::TRWBPApproximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]
 Cdai::CBPClass for CBP (Conditioned Belief Propagation) [EaG09]
 Cdai::ExactInfExact inference algorithm using brute force enumeration (mainly useful for testing purposes)
 Cdai::HAKApproximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]
 ▼Cdai::JTreeExact inference algorithm using junction tree
 Cdai::TreeEPApproximate inference algorithm "Tree Expectation Propagation" [MiQ04]
 Cdai::LCApproximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]
 Cdai::MFApproximate inference algorithm "Mean Field"
 Cdai::MRApproximate inference algorithm by Montanari and Rizzo [MoR05]
 Cdai::BipartiteGraph::levelTypeUsed internally by isTree()
 ▼Cstd::map< K, T >STL class
 Cdai::PropertySetRepresents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue)
 Cdai::WeightedGraph< T >Represents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights
 Cdai::MaximizationStepA MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit
 Cdai::BP_dual::messagesGroups together the data structures for storing the two types of messages and their normalizers
 Cdai::multiforMultifor makes it easy to perform a dynamic number of nested for loops
 Cdai::NeighborDescribes the neighbor relationship of two nodes in a graph
 ▼Cdai::ParameterEstimationBase class for parameter estimation methods
 Cdai::CondProbEstimationEstimates the parameters of a conditional probability table, using pseudocounts
 Cdai::PermuteTool for calculating permutations of linear indices of multi-dimensional arrays
 Cdai::MR::PropertiesParameters for MR
 Cdai::BP::PropertiesParameters for BP
 Cdai::ExactInf::PropertiesParameters for ExactInf
 Cdai::HAK::PropertiesParameters for HAK
 Cdai::JTree::PropertiesParameters for JTree
 Cdai::MF::PropertiesParameters for MF
 Cdai::LC::PropertiesParameters for LC
 Cdai::TreeEP::PropertiesParameters for TreeEP
 Cdai::BBP::PropertiesParameters for BBP
 Cdai::CBP::PropertiesParameters for CBP
 Cdai::sequentialVariableEliminationHelper object for dai::ClusterGraph::VarElim()
 ▼Cstd::set< K >STL class
 Cdai::GraphELRepresents an undirected graph, implemented as a std::set of undirected edges
 Cdai::SharedParametersRepresents a single factor or set of factors whose parameters should be estimated
 Cdai::SmallSet< T >Represents a set; the implementation is optimized for a small number of elements
 Cdai::SmallSet< size_t >
 ▼Cdai::SmallSet< Var >
 ▼Cdai::VarSetRepresents a set of variables
 Cdai::RegionA Region is a set of variables with a counting number
 Cdai::StateMakes it easy to iterate over all possible joint states of variables within a VarSet
 Cdai::TFactor< T >Represents a (probability) factor
 ▼Cdai::TFactor< Real >
 Cdai::FRegionAn FRegion is a factor with a counting number
 Cdai::TProb< T >Represents a vector with entries of type T
 Cdai::TProb< Real >
 Cdai::TreeEP::TreeEPSubTreeStores the data structures needed to efficiently update the approximation of an off-tree factor
 Cdai::UEdgeRepresents an undirected edge
 Cdai::VarRepresents a discrete random variable
 ▼Cstd::vector< T >STL class
 Cdai::BP_dual::_edges_t< dai::TProb >
 Cdai::BP_dual::_edges_t< Real >
 Cdai::BP_dual::_edges_t< T >Convenience label for storing edge properties
 Cdai::RootedTreeRepresents a rooted tree, implemented as a vector of directed edges
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__KL-members.html0000644000175000017500000000562512552201365021744 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_84.png0000644000175000017500000000031112552200236015655 0ustar jorismjorism‰PNG  IHDR ºì?0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï8IDATxíÝÁ CÑÔ6VDéþÛz0'Á>¼ÓŸ>™7)Ò¦¸‰³J GÔå"Ú¸tv>˪ìW¶ÀIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1GraphAL.html0000644000175000017500000013705012552201366020221 0ustar jorismjorism libDAI: dai::GraphAL Class Reference
Private Attributes | List of all members
dai::GraphAL Class Reference

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

#include <dai/graph.h>

Public Member Functions

Constructors and destructors
 GraphAL ()
 Default constructor (creates an empty graph). More...
 
 GraphAL (size_t nr)
 Constructs GraphAL with nr nodes and no edges. More...
 
template<typename EdgeInputIterator >
 GraphAL (size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
 Constructs GraphAL from a range of edges. More...
 
Accessors and mutators
const Neighbor & nb (size_t n1, size_t _n2) const
 Returns constant reference to the _n2 'th neighbor of node n1. More...
 
Neighbor & nb (size_t n1, size_t _n2)
 Returns reference to the _n2 'th neighbor of node n1. More...
 
const Neighbors & nb (size_t n) const
 Returns constant reference to all neighbors of node n. More...
 
Neighbors & nb (size_t n)
 Returns reference to all neighbors of node n. More...
 
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. More...
 
size_t addNode ()
 Adds a node without neighbors and returns the index of the added node. More...
 
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. More...
 
GraphAL & addEdge (size_t n1, size_t n2, bool check=true)
 Adds an edge between node n1 and node n2. More...
 
Erasing nodes and edges
void eraseNode (size_t n)
 Removes node n and all incident edges; indices of other nodes are changed accordingly. More...
 
void eraseEdge (size_t n1, size_t n2)
 Removes edge between node n1 and node n2. More...
 
Queries
size_t nrNodes () const
 Returns number of nodes. More...
 
size_t nrEdges () const
 Calculates the number of edges, time complexity: O(nrNodes()) More...
 
bool hasEdge (size_t n1, size_t n2) const
 Returns true if the graph contains an edge between nodes n1 and n2. More...
 
size_t findNb (size_t n1, size_t n2)
 Returns the index of a given node n2 amongst the neighbors of n1. More...
 
SmallSet< size_t > nbSet (size_t n) const
 Returns neighbors of node n as a SmallSet<size_t>. More...
 
bool isConnected () const
 Returns true if the graph is connected. More...
 
bool isTree () const
 Returns true if the graph is a tree, i.e., if it is singly connected and connected. More...
 
void checkConsistency () const
 Asserts internal consistency. More...
 
bool operator== (const GraphAL &x) const
 Comparison operator which returns true if two graphs are identical. More...
 

Private Attributes

std::vector< Neighbors > _nb
 Contains for each node a vector of its neighbors. More...
 

Input and output

void printDot (std::ostream &os) const
 Writes a GraphAL to an output stream in GraphViz .dot syntax. More...
 
std::string toString () const
 Formats a GraphAL as a string. More...
 
std::ostream & operator<< (std::ostream &os, const GraphAL &g)
 Writes a GraphAL to an output stream. More...
 

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
EdgeInputIteratorIterator that iterates over instances of Edge.
Parameters
nrThe number of nodes.
beginPoints to the first edge.
endPoints just beyond the last edge.
checkWhether 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 
)

(Re)constructs GraphAL from a range of edges.

Template Parameters
EdgeInputIteratorIterator that iterates over instances of Edge.
Parameters
nrThe number of nodes.
beginPoints to the first edge.
endPoints just beyond the last edge.
checkWhether 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
NodeInputIteratorIterator that iterates over instances of size_t.
Parameters
beginPoints to the first index of the nodes that should become neighbors of the added node.
endPoints just beyond the last index of the nodes that should become neighbors of the added node.
sizeHintFor 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_FOUNDif 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 a GraphAL to an output stream in GraphViz .dot syntax.

std::string dai::GraphAL::toString ( ) const
inline

Formats a GraphAL as a string.

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  os,
const GraphAL &  g 
)
friend

Writes a 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:
  • include/dai/graph.h
  • src/graph.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1VarSet.png0000644000175000017500000000136612552201370017762 0ustar jorismjorism‰PNG  IHDR€ˆ³”PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2…IDATxíërë0„WËŒßÿ‘mÝ@VräÆ-o£ „>rÿBDÄS’ôS€H³Ñþ!ÉA»í0ÛÙÁ1ÿœ­þ?€5Íí…aŠý€=•’“^UçdÞ¯:TC3^jÕ"•™¼Iõ4€3@[Óã— ^ƒ¸ÎöCi6’iTK§ƒh€Ê§S«Þ&cý£Ì"1ÍX»]r[ÙR %)*ôa;-Ã!Ôš—^5“Åu0ÅTMhÆ&앱@û ظ 0é}lkOz@ß‚Úmê¦C¿õ=Pœ.M^KÓ˜¤yâU;€ˆˆ£à#mà)o€ms&ðØ÷÷%pˆ[ ¥”<…~ €Xè^m”ãò³±'Ë`¦ûƒi˜8Nh`ª%€rYsn6zÞ0'}xõú6S ¸jàŒÔök`Õþhgx£E€êebêzhõ,@î/Ób%Ýáprñg˜èÀ5©²x< åõ€íÉE˜üOøÞCÚUje¤–™à5¤À[ôëåˆ\ äSjýÄuÿ ‡­-À{ŒK_f j Öͳ¶ØU¦­ñøl]=S¥Ž´I>’ìÅmæut˜¼T¶+/<O?ºÀ*òHfÇ~Úãeù_Êc`¼?Àº¨RŒÖ®Í·F5»?n«v…|Gµz“½WƱìV Ív«h…Ijùî+¥–VîYT’ EQϦd?‹ÛÍOnz@ ‰„KnÐ1y \NÍAÓöγ±Øçl s:‡@jñ^u»R’ã9Ìÿb™$ì"€ßw×iê+©d ëTëSðÀg4+=Vé1”ªÑÌ4*.Å™¼íå•(¹G1¿ÊЬtãtúÑY ^[øcøëŠ;ܹÕpIEND®B`‚libDAI-0.3.2/doc/html/tabs.css0000644000175000017500000000221312552201363015341 0ustar jorismjorism.tabs, .tabs2, .tabs3 { background-image: url('tab_b.png'); width: 100%; z-index: 101; font-size: 13px; font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif; } .tabs2 { font-size: 10px; } .tabs3 { font-size: 9px; } .tablist { margin: 0; padding: 0; display: table; } .tablist li { float: left; display: table-cell; background-image: url('tab_b.png'); line-height: 36px; list-style: none; } .tablist a { display: block; padding: 0 20px; font-weight: bold; background-image:url('tab_s.png'); background-repeat:no-repeat; background-position:right; color: #283A5D; text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9); text-decoration: none; outline: none; } .tabs3 .tablist a { padding: 0 10px; } .tablist a:hover { background-image: url('tab_h.png'); background-repeat:repeat-x; color: #fff; text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); text-decoration: none; } .tablist li.current a { background-image: url('tab_a.png'); background-repeat:repeat-x; color: #fff; text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0); } libDAI-0.3.2/doc/html/classes.html0000644000175000017500000005140012552201370016221 0ustar jorismjorism libDAI: Class Index
Class Index
B | C | D | E | F | G | H | I | J | L | M | N | P | R | S | T | U | V | W | _
  B  
Exception (dai)   MF (dai)   
  S  
  b  
  F  
MR (dai)   
BBP (dai)   
  N  
SharedParameters (dai)   BP_dual::beliefs (dai)   
BBPCostFunction (dai)   FactorGraph (dai)   SmallSet (dai)   
  f  
BipartiteGraph (dai)   FBP (dai)   Neighbor (dai)   State (dai)   
BP (dai)   FRegion (dai)   
  P  
  T  
fo_abs (dai)   
BP_dual (dai)   
  G  
fo_absdiff (dai)   
  C  
ParameterEstimation (dai)   TFactor (dai)   fo_divides0 (dai)   
GraphAL (dai)   Permute (dai)   TProb (dai)   fo_exp (dai)   
CBP (dai)   GraphEL (dai)   MR::Properties (dai)   TreeEP (dai)   fo_Hellinger (dai)   
ClusterGraph (dai)   
  H  
BP::Properties (dai)   TreeEP::TreeEPSubTree (dai)   fo_id (dai)   
CobwebGraph (dai)   ExactInf::Properties (dai)   TRWBP (dai)   fo_inv (dai)   
CondProbEstimation (dai)   HAK (dai)   HAK::Properties (dai)   
  U  
fo_inv0 (dai)   
CobwebGraph::Connection (dai)   
  I  
JTree::Properties (dai)   fo_KL (dai)   
  D  
MF::Properties (dai)   UEdge (dai)   fo_log (dai)   
IndexFor (dai)   LC::Properties (dai)   
  V  
fo_log0 (dai)   
DAG (dai)   InfAlg (dai)   TreeEP::Properties (dai)   fo_max (dai)   
DAIAlg (dai)   
  J  
BBP::Properties (dai)   Var (dai)   fo_min (dai)   
DEdge (dai)   CBP::Properties (dai)   VarSet (dai)   fo_plog0p (dai)   
  E  
JTree (dai)   PropertySet (dai)   
  W  
fo_pow (dai)   
  L  
  R  
  g  
BP::EdgeProp (dai)   WeightedGraph (dai)   
EMAlg (dai)   LC (dai)   Region (dai)   
  _  
greedyVariableElimination (dai)   
Evidence (dai)   
  M  
RegionGraph (dai)   
  h  
ExactInf (dai)   RootedTree (dai)   BP_dual::_edges_t (dai)   
MaximizationStep (dai)   hash_map (dai)   
B | C | D | E | F | G | H | I | J | L | M | N | P | R | S | T | U | V | W | _
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_143.png0000644000175000017500000000322312552200253015735 0ustar jorismjorism‰PNG  IHDR[+áDÛª0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIDATxíë’ª<EW®„›yÿ·ýºPTp¦¾©sŽ¦Ø¢€!YÙÙýà#€?OÎüHà%y€_%üH¯¯ÎøóøÓõs¶1¼¤[€muµ¶ÚjíI~xIoÇ6•Ø•°­Toëí´³:¡M¥4Ïz7¶QKÒ`Oã âšíè·Äõêï¸x7¶ï—%‡m³éõVÞ±íÛ±­ƒ_J¾+1Æ,E*È\½šRÜa ð¬®ÊŸ÷¾ÛTk]|–FÏ tCÀ Nmèê+l½t×-ßïNïXˈ݂*È­CÕy½ÔgÁú [é¤ÔH”'‚ý¯à¯ÿ3¶šuž³±•Õ)J§öÙ®IiŒ,Ý bv)i“}ŵeyðÍضÆví[c;Am̾»loе¾3nÆS’%5x½í4»Ãòà{±U}5›Ž\ƒï[i _¶t½ún7ÚDœVIŒ+\鯾!¥m·ÞŽm iۥظœcÌÙ¥,7ccû;6!åM¶1øhÍ 4ƒè}j[]©Q–eŠ[ýü‹ÙÆÝ!ÇÅ‘wZÕ2€“Z³ N|}ƒfl¯Ñç¹”)N·Ü:Ã6,+ p'½±{à_lð ²7˜o±µ¦Û)IRk¾[2aiYUÊ\ôAÛçØ–ôjäF]@ë¸;dÃíš àK…-Œ›¯¹Ž`Cßb+c׿ͧNæá¬!•ìš,«uu%KöÞjÞ1[Éø]:²L×Íá´_àîˆò¢oÇNѵî¿ÞŒw²ôxÐ÷2a½í5SWóxPã,³Ó•ú ¶_LfÍàI£Ì©\à=l˜¬efªR†ò³uäúλ~ÌöÒj.œ×![××68I™@r3ïÒÔ˜CVlÃæÞ¯ÊöKúV¢Ó}|m³M %!Y'_õÖ8¿pB<ÍcMh綌éÇl^Õ9ß^ä©ÑSz?ùBfætÞ7¶NhO–iMlåGl›$Ûms÷l›ª¥ÊôDKVÝú¢K±É&¶~Çñ74â[›c×®V?„¤ØVl¹lúV舭ë¤Û‰¢Ÿ ñòžÇLèå÷0½¦µtïlϱuµŽ{…`K¶çØâr_Ü OXÅ”ªwT->lO±µë6‰ÝÆ¢AÀf)Ÿ{ú°}fçú¥%,g#YôFà ÛÞªœ^Ö{ú°}f»B² uÿË(x[u­»È§ÝØÖ‡íÛx{Ö N#TrÛ*Ó6Ô­Nïe€}Ø>²MÊ$ZóÊñŽÐÜD´i>™ðLÐí>µ°øvi­ôcI0|òöÛ|©ƒÔüùzœ$€4±°îŽÉvµ±2°­wa[Bl‡Z¯ChÒ3Àâº"W½Ö7€-…Ræ]ðO+vÒU¬JüHç_ð&Jù`§üSúP—,¾CÊ—*IEND®B`‚libDAI-0.3.2/doc/html/form_80.png0000644000175000017500000000226312552200235015660 0ustar jorismjorism‰PNG  IHDR"º-–»0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï"IDATxíÙ£ E«hTþÿo§Y4.Ä$ó2U)n‚J7ôííàÀ €ÿ !„í´7êpCŒƒÏ#ÆØ€ëˆÑ—Å´,nì9ù;rBmà{œ“û¢v58 ù0|KrúiPtS¯šèÚ»öÓ|æ¶Ôµ¢_O¯ã·÷y9QŒ÷W~“ïz@½pI¯>Æd×€.µBfø ×äøˆmíúN¬Enh§¤NƼÆV{ÌÙÐrï•¢¦ÀYÈ?ææFål!QŸƒàM͉C3¡WgÉùI. ÏÄNj”÷ùÄ”&‰Z˜œSÎç\+ÕÓí¦A¾ IPËÝö²U°™Å®¶ÀYèÑt ÑÙ)tç3Þ3A}(»~qB"G.·’¬g\ÊÆDÂTŠÑX|è´‰:f {MÉ·éåœ~Å,°«·e‘ Ý–’,MΛ|—*WòÌÌ:êL_âé¨I®ÔÍtœë™Ü5ÒZm¸ÚµÚ#eg¬¹¸µ¸o7TåL-9êPW/É19|÷’ÚÃ1r¶¶/” J0Ø\$$þ·ÍT.¼U%#š­Ü×:áC{mKÕíiÑlåÕ®@' kkŠ%¡ÅâàsyØAÚÆê€=Þt«ª¢Ø pÀæÒ-ý —°}_yZ_ &ŸŽh)ZíÚ ô)}Rj„†ð슻fýFØÍÈÙøØÎ'9æ¼Gê9ÀGpE•yJ9opÐV´ÚµpÒüå7ÑòÙéçZö59Mt©"´ð² ñ¼enyÀs¶­ÛÎ_ŸpFŒ5åb|Ùî~c”1Iü­ €%2óØ.nܸð6å]£·ÙdJó1©üTÌ|d"ltòŸÓOÈŸ‹ ð?cJ4tÞ &­É]<È£ï­6þ07z&jâ„°#§óe"À¢ó0ÂÆ”ƒäIŽ°:GÀb” libDAI: Member List
dai::GraphEL Member List

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

GraphEL()dai::GraphELinline
GraphEL(InputIterator begin, InputIterator end)dai::GraphELinline
GraphEL(const GraphAL &G)dai::GraphELinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/folderclosed.png0000644000175000017500000000115012552201363017050 0ustar jorismjorism‰PNG  IHDRÚ}\ˆ/IDATxí]MOÔ@~ÚúuØlp]ö¿#›Å]PYECˆ\9ù¼yÑß`ÖÄÿàÿÀÉxóâ¢C &=qÐÄ£—vZçv¶3m؃‡vžLûNç}Þ÷}Þ½ZA@n° OäNp ’xóþK°ññ€xÜj”°8sÑ€“ “€œ_¼[Âíæ§ïD'‚•yye+ø¼û 7#rNŸlïük* ¾0Ь_d«_(àñÖ±àôz=ñxõv§÷h©‰z¹€šØP-äóä’̪uý¼$»\DãJc—B4¯ãÝÖ.:£Ï-ÑÏß}µŠLEíºþ #—ûáºÀÏgN;BŠ€6ïýñ䬜…ö@’Ðåñp&™h>p9¤™EEά¨ÎÊ‘" u¥n€$R"?{¹<˜…ë…%PNtâ$‰߶±úá+^<é"§2 ªDq”q´\¬«Ò™a–Œ‘©Aÿ€"Ôµ ™êŸèP£}#Eàz{û.8i îp³ê(ADwD¦E<ê¬cE¦$ HdÊÄ ”.:Ù GŽ-`ŒL‚ý¾'¢‰Ä<¤CIª½;ÙÇTZd±i};>èôß‚z×;Kק8t ¤Ž q”:uvÿv•Ý›¬²ÙvEân{„M·FXg¼ÌfZÖ¨°¹‰*›ßÌß©±ù©:›j–YqèÜë#3çÏSøWøÿÿÑr'ø Ôùù‚ ©¡IEND®B`‚libDAI-0.3.2/doc/html/form_48.png0000644000175000017500000000546012552200226015666 0ustar jorismjorism‰PNG  IHDRÓŸ½<´0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï ŸIDATxíÛ’ë,¯Egìøðþo»…ÝIláµÒÝ«÷÷WRžUI„ æ-Àÿ˜¢ø=åð{:å àŸè”ïG€¢S¾û¾³å8Hgä9á';‡Mnç›2Iù¾ÿP)›)Çà =d’™ÓXmîƒoo³1S Ãvö·óHX cd8I‘7ÌÁ”• x~î!ïcû¢ ]µfç©É¿•'„ïäKÉͦü퀃öúÛÉê¶Ð ŽÇhË\’kwëqþS0Ò RÌ߯އ ЪÌ$‡N.З“Þ’¶ã¼ôx=ÌòmJ²¹üÅ”l´º‰{+óø÷PJëç`´;tÉoL¾:ÞÿeÏÿý¬4iüÖä;¡š_Ü'oT+÷Ô]9°ÆoM¾ªù“Ü¿Q¢'|ßß¿Ëë¤@mòPÍwÙºÕm‰ÏÎLª½_:tmòÀçS‡Ú󵕳øY½ýà÷ôæ¼$›“Vÿ.ûQ©Í&Ôðco{ÔG?ôë_\\ëÒÂJhÕ„j~Ë›dÞÿ•n h•ÁëiZ“ï„j~q§½ÿSlXÙ½ý}š5ðü|Éÿ¦âÐ’Ý5j½n%KµrI¡ÂoBþ}K涊èŠçø=… ¿ë¿eû›ž0Sßÿðsš¢ Ÿjù¹˜¯|RùQým¯$çÒé#~yÛPü̉ð²ö›p¦y]×r›…Áß”ËÓ„šú“)ׄ-e0Äüîd® uú_7ùß¡·ÿüžÞ|€—d† 9´ Š1—®åǧXËcÞçô1,ýþ_:µÒ¡½QùÒZÜ“¯6üÙ2í¦"î¾y%À¹ bÞš5@#ïºý?|³axZ'@­m¦Y;>¿íIõ¿áSz$Š^ä=þ,sŽ pI³;¿äÿ¯ù[þ5þ$Ž·Ø>I¹]w'-|Í¢4~èžÉÎÎ÷röÛÎUÊC]¡öª‘7ü¬ñ­D‡›T6QîIÿØ›”íÇq•Püó¹6õ—rXçÔâúšCWoúßgôµÙþBoÿø=½ùçº(ã'­ûÙ ¶.—ýøkø!†áí·?¬U»¿ßš3ÀAÒZÜ“¯6ýO¼ÇV}ÕT¾¾öÍ5ÕþïfƒÏßýOð³ì_÷?Ö5ƒÞZñUþ_ã—éu¾ŸÖiÊÿ?Âßò¯ñÝ tÛn‚xÏOðC÷üËÞM9!‚÷~  xo„íg?ǽaö¸Ø¿Ö›Ô @«8®£ÒÂàoVã›1¥l±%^æpß­jWmÿ3ÿÄõßþóæoÜS!Ï~­{Žµ|÷(¹z@#Ýíî•Àó£Ú;b4ÏeÝðooý¿ÐHš¥]µ!½þgÕþ¤÷ÇmOí8€F‹°Wíø4¾ïúÏ îè6whǵ8Hõ¿²'•?ç;¿pÔ¬4ù¿¸«Î—_üfÀAYÅëünþçGþÛq­’8ÕßÞ¿ý\µû—…¿»s; Qsþ(€ZêÒ³Ýòs~¹ñcÜü·ÐhÇQ«ÿa”³±9<¿ÔÔH)IñɈfÀOèí?¿§7à5gÎÔ3ï*Òð½ú –L)V€VóŽ±jM5ß­åó±+sÑ~Kø¼CöÍ»ÃÖwßS½P€Z%|n€}óîðK䎶Ïß|ª&@­¾ywø»©íK ö×ãwͻϟî븲_·åÿœÿjþ+¼¡¤áÎ9½å}óîòïrÞû5t0†í¢´êšw—¿–ßv9¨eÄ¡•Ô1ï8ŒÃSÑö_jÊË^*=à›ôö€ßÓ›ðªÔµN¯Ý*ÒòÝSÉy]..Úâc4£R»±¶Õ†ŸeÒ{O1ýGëþåMÉ@ñ@€ƒ:ü$¿nwª ÐJãïýÿÿ‰Ò´7ó’O°/ósÙû‹þ˲wn®ú‡_¼çE~ø8·té?þ«ù—k3~¡ÜÂ/ž?À™z|+ÛÞÜÑyï×p±µþC(gpP?eù`—ã@€ZbУ, •Ía¿Eµ¢Øú¶Ã3¾åã1åe™~PzÀ7éí?¿§7à5w·J€JÖéµ[EZ¾{¼Ø›b/ÖènJ•ÇhF¥vcm« ?Y;ì›{ë—ÿd°ëé#½×~ø@­ßI?s›X™ÂïmàL‹°×ÓãÛûÿ þãd?qû§X˜S-¤ÔÊeï/ùßm½å݆7þ¥>uòçI‹÷¼ÄOy]÷ó—Q銟Ïñ[ò^âù5íÇD_r )Y)€Vûùœ©ÃŸKhÚ¯‚L£^á½’Æœoç›\ ¡œÀA~¹{vÄÊÅ—åOýúû•ú·9(¢ØúÓ±οüaäåµÓø6½ýà÷ôæ¼&ãöV ЪÓ9«ÐÿˆÚÎì{‡L¿hÕ˜|'tìÿ÷oΞ›kÕÇþ¬ÉOOÿé¹kØmà\eÅ¿/½w4m#g-E_æKïâœS“û1²äÿùÄëó_4‹ü*¿°·œk ˜o¿ÿ¾Ìhü$¿¨2bòJ‹hL¾jøÃ83ȸ”Æ‹ðU½ýà÷ô漨ŽCwZg:ðQC·ýà“jÐÉwB ??<×Þð3@Gj÷ÿ†þ¿Z\èèùnµñ²ýý ?­Á Wwóùå<{1ÀA?È×þû£|{½ãÖ쎲~õÊíiB ߥՙmãc ‹ (²1Fp”—²´&ÔðƒD%=eÚÿEk~ûÀïéÍxMR,§ªLxzªPÃ71ß›ƒ‰¡ßþÄŸòpTcòPÍ7 ³îë³7ü  JÚ¬Jz±ÿæÆ}O2»KªFÉÔÇbj½Æ÷B6¾[­ä §âRG½ê?ÞþIk0ÃÕÝ4‹ºÄ—ùÃn:ùÚÿd¬ž¡Wùåî™-6 )ËÅå^å{¹ÏÛ ìõþÇežLcòPÍ·ë<Ïã¶ñ1÷£8Sñjåú7&ß 5| –k_ª:uºÀ÷èí?¿§ßæügôt¦V‹·ìIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1FRegion.html0000644000175000017500000021176212552201366020277 0ustar jorismjorism libDAI: dai::FRegion Class Reference
Public Member Functions | Private Attributes | List of all members
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< Real >

Public Member Functions

 FRegion ()
 Default constructor. More...
 
 FRegion (const Factor &x, Real c)
 Constructs from a factor and a counting number. More...
 
const Real & c () const
 Returns constant reference to counting number. More...
 
Real & c ()
 Returns reference to counting number. More...
 
- Public Member Functions inherited from dai::TFactor< Real >
 TFactor (Realp=1)
 Constructs factor depending on no variables with value p. More...
 
 TFactor (const Var &v)
 Constructs factor depending on the variable v with uniform distribution. More...
 
 TFactor (const VarSet &vars)
 Constructs factor depending on variables in vars with uniform distribution. More...
 
 TFactor (const VarSet &vars, Realp)
 Constructs factor depending on variables in vars with all values set to p. More...
 
 TFactor (const VarSet &vars, const std::vector< S > &x)
 Constructs factor depending on variables in vars, copying the values from a std::vector<> More...
 
 TFactor (const VarSet &vars, const Real *p)
 Constructs factor depending on variables in vars, copying the values from an array. More...
 
 TFactor (const VarSet &vars, const TProb< Real > &p)
 Constructs factor depending on variables in vars, copying the values from p. More...
 
 TFactor (const std::vector< Var > &vars, const std::vector< Real > &p)
 Constructs factor depending on variables in vars, permuting the values given in p accordingly. More...
 
void set (size_t i, Realval)
 Sets i 'th entry to val. More...
 
Real get (size_t i) const
 Gets i 'th entry. More...
 
const TProb< Real > & p () const
 Returns constant reference to value vector. More...
 
TProb< Real > & p ()
 Returns reference to value vector. More...
 
Real operator[] (size_t i) const
 Returns a copy of the i 'th entry of the value vector. More...
 
const VarSet & vars () const
 Returns constant reference to variable set (i.e., the variables on which the factor depends) More...
 
VarSet & vars ()
 Returns reference to variable set (i.e., the variables on which the factor depends) More...
 
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$. More...
 
Real entropy () const
 Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$. More...
 
Real max () const
 Returns maximum of all values. More...
 
Real min () const
 Returns minimum of all values. More...
 
Real sum () const
 Returns sum of all values. More...
 
Real sumAbs () const
 Returns sum of absolute values. More...
 
Real maxAbs () const
 Returns maximum absolute value of all values. More...
 
bool hasNaNs () const
 Returns true if one or more values are NaN. More...
 
bool hasNegatives () const
 Returns true if one or more values are negative. More...
 
Real 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]. More...
 
bool operator== (const TFactor< Real > &y) const
 Comparison. More...
 
std::string toString () const
 Formats a factor as a string. More...
 
TFactor< Real > operator- () const
 Returns negative of *this. More...
 
TFactor< Real > abs () const
 Returns pointwise absolute value. More...
 
TFactor< Real > exp () const
 Returns pointwise exponent. More...
 
TFactor< Real > log (bool zero=false) const
 Returns pointwise logarithm. More...
 
TFactor< Real > inverse (bool zero=true) const
 Returns pointwise inverse. More...
 
TFactor< Real > normalized (ProbNormType norm=NORMPROB) const
 Returns normalized copy of *this, using the specified norm. More...
 
TFactor< Real > operator- (Realx) const
 Returns difference of *this and scalar x. More...
 
TFactor< Real > operator+ (Realx) const
 Returns sum of *this and scalar x. More...
 
TFactor< Real > operator* (Realx) const
 Returns product of *this with scalar x. More...
 
TFactor< Real > operator/ (Realx) const
 Returns quotient of *this with scalar x. More...
 
TFactor< Real > operator^ (Realx) const
 Returns *this raised to the power x. More...
 
TFactor< Real > operator- (const TFactor< Real > &g) const
 Returns *this minus g. More...
 
TFactor< Real > operator+ (const TFactor< Real > &g) const
 Returns sum of *this and g. More...
 
TFactor< Real > operator* (const TFactor< Real > &g) const
 Returns product of *this with g. More...
 
TFactor< Real > operator/ (const TFactor< Real > &g) const
 Returns quotient of *this by f (where division by zero yields zero) More...
 
TFactor< Real > binaryTr (const TFactor< Real > &g, binOp op) const
 Returns result of applying binary operation op on two factors, *this and g. More...
 
TFactor< Real > & randomize ()
 Draws all values i.i.d. from a uniform distribution on [0,1) More...
 
TFactor< Real > & setUniform ()
 Sets all values to $1/n$ where n is the number of states. More...
 
TFactor< Real > & takeAbs ()
 Applies absolute value pointwise. More...
 
TFactor< Real > & takeExp ()
 Applies exponent pointwise. More...
 
TFactor< Real > & takeLog (bool zero=false)
 Applies logarithm pointwise. More...
 
Real normalize (ProbNormType norm=NORMPROB)
 Normalizes factor using the specified norm. More...
 
TFactor< Real > & fill (Realx)
 Sets all values to x. More...
 
TFactor< Real > & operator+= (Realx)
 Adds scalar x to each value. More...
 
TFactor< Real > & operator-= (Realx)
 Subtracts scalar x from each value. More...
 
TFactor< Real > & operator*= (Realx)
 Multiplies each value with scalar x. More...
 
TFactor< Real > & operator/= (Realx)
 Divides each entry by scalar x. More...
 
TFactor< Real > & operator^= (Realx)
 Raises values to the power x. More...
 
TFactor< Real > & operator+= (const TFactor< Real > &g)
 Adds g to *this. More...
 
TFactor< Real > & operator-= (const TFactor< Real > &g)
 Subtracts g from *this. More...
 
TFactor< Real > & operator*= (const TFactor< Real > &g)
 Multiplies *this with g. More...
 
TFactor< Real > & operator/= (const TFactor< Real > &g)
 Divides *this by g (where division by zero yields zero) More...
 
TFactor< Real > & binaryOp (const TFactor< Real > &g, binOp op)
 Applies binary operation op on two factors, *this and g. More...
 
TFactor< Real > slice (const VarSet &vars, size_t varsState) const
 Returns a slice of *this, where the subset vars is in state varsState. More...
 
TFactor< Real > embed (const VarSet &vars) const
 Embeds this factor in a larger VarSet. More...
 
TFactor< Real > 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. More...
 
TFactor< Real > 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. More...
 

Private Attributes

Real _c
 Counting number. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_41.png0000644000175000017500000000065512552200224015656 0ustar jorismjorism‰PNG  IHDRV»‰x´0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIDATxíÍ’„ „?äÏ?äýßvI`t§Ü­Z/{°lC…t‹I{øopÏÀØ÷2ö%Àß^bfx [‹ëð‚¯1Õþºk‡­o·8qm;î¡ýul¦4dØž‰E×)€hÜ×¥zM=-ÖbâÑ·çä$ã¶på~–µ)KL]Öl9l¸Cãže5Ì#±Ëº¥ø‘pEåúuñûUv›pò±*»Ëv Ls‰“ØO3ìêĬƒÔ§Íòñ•kWWÙJƒ•=ãªëFÔãoYš™Ô‰uèõ©^iÜb¨$2g­–CÕËç(º}HÓ‘RéÆúí‡QìØ]ÞþîYÿy‘:?üß3'ëí¥Ý¿µ=ÀOÐî|é•¡\?3IIEND®B`‚libDAI-0.3.2/doc/html/jtree_8h.html0000644000175000017500000001310412552201363016275 0ustar jorismjorism libDAI: include/dai/jtree.h File Reference
Classes | Namespaces
jtree.h File Reference

Defines class JTree, which implements the junction tree algorithm. More...

#include <dai/dai_config.h>
#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.

Classes

class  dai::JTree
 Exact inference algorithm using junction tree. More...
 
struct  dai::JTree::Properties
 Parameters for JTree. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class JTree, which implements the junction tree algorithm.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_81.png0000644000175000017500000000231712552200235015661 0ustar jorismjorism‰PNG  IHDRü"LAD 0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï>IDATxíÙv³: …? üþo{$™9„æüwMÃòn°%m·_|ð°­¶m÷+ü¤¾”>ÛSJiÀB)¹nÆeðG°rþ7òmw“- àÿã¹øN‚.UFVh'€Ü’ïÆÞьݓÜí„Àçt} 4ï£Z{qëøªxÆ“•cPë^á>òE®ç»Êwßã€gtàmTk'ì¥êÎN)·¸'Ÿ ñj¬ïÄÚAîõ×ùŸ\Ìq³6]¥Ë^Ð G‹‡Ð‡®´úÂ¥X=矃øCÍ—þrü­Ñ£ô^»z=·*Æål碋s•¦äR6ײÝâ<[ÛëE/§½±&(¤àqv#ÆÓ©ö›#üPM~À×hž;ÀäûzÑŸôä%X•c¡öÉ˹vÙëÓ£Z6Å|ìÀ¶Þ"¿‹°_ùð|Fú%À[X¬AÛ­”cÒ‘©‚üÚúer Iù”ôÍ1ÀË™SÊ»õy€K4Ú®ð²Ëœ±Yi#ØV´¾¾”Þϲ­Å–Ùc¥¼‡ˆ¡È3j5-€?gÏ~ðÀŸ„]?•I±ÏöP›÷¿´N€_WŒ¯E‡¤ý¶aiŸ›ð›1*Í&g!tM¹V~æ.ŠC†æî{a:'vkc~%ßä À‡¢ÉÐy„íhAÞȇžè->ƒô¸!Ë#{ r³’÷‘)ÒX6| éqm-ë4áúDâQŠ¡óš £Ô=ÀGÂ+ñ¶k¥îSŠI 4­0ö)9|6Ü~À|þçrL¤”©IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1BipartiteGraph-members.html0000644000175000017500000003462112552201364023276 0ustar jorismjorism libDAI: Member List
dai::BipartiteGraph Member List

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

_nb1dai::BipartiteGraphprivate
_nb2dai::BipartiteGraphprivate
addEdge(size_t n1, size_t n2, bool check=true)dai::BipartiteGraph
addNode1()dai::BipartiteGraphinline
addNode1(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::BipartiteGraphinline
addNode2()dai::BipartiteGraphinline
addNode2(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::BipartiteGraphinline
BipartiteGraph()dai::BipartiteGraphinline
BipartiteGraph(size_t nr1, size_t nr2)dai::BipartiteGraphinline
BipartiteGraph(size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::BipartiteGraphinline
checkConsistency() const dai::BipartiteGraph
construct(size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::BipartiteGraph
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::BipartiteGraphinline
findNb2(size_t n1, size_t n2)dai::BipartiteGraphinline
hasEdge(size_t n1, size_t n2) const dai::BipartiteGraphinline
isConnected() const dai::BipartiteGraph
isTree() const dai::BipartiteGraph
nb1(size_t i1, size_t _i2) const dai::BipartiteGraphinline
nb1(size_t i1, size_t _i2)dai::BipartiteGraphinline
nb1(size_t i1) const dai::BipartiteGraphinline
nb1(size_t i1)dai::BipartiteGraphinline
nb1Set(size_t n1) const dai::BipartiteGraph
nb2(size_t i2, size_t _i1) const dai::BipartiteGraphinline
nb2(size_t i2, size_t _i1)dai::BipartiteGraphinline
nb2(size_t i2) const dai::BipartiteGraphinline
nb2(size_t i2)dai::BipartiteGraphinline
nb2Set(size_t n2) const dai::BipartiteGraph
nrEdges() const dai::BipartiteGraphinline
nrNodes1() const dai::BipartiteGraphinline
nrNodes2() const dai::BipartiteGraphinline
operator<<(std::ostream &os, const BipartiteGraph &g)dai::BipartiteGraphfriend
operator==(const BipartiteGraph &x) const dai::BipartiteGraphinline
printDot(std::ostream &os) const dai::BipartiteGraph
toString() const dai::BipartiteGraphinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_107.png0000644000175000017500000000070312552200243015734 0ustar jorismjorism‰PNG  IHDR7Sõôç0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï2IDATxí]Ùrƒ0 \[øÂþÿo«•h›fú¬‰Â!kwu Ïð_wðÀ×vYàŽK²K€[n„ÞÀ-¢*eÿ\ìXM+ê![‘Þ¹³øÉÅ?ÍÃîQà½Ë5QŒÞkg*û’?5u»ˆîI8CNœþà»çÑq_$Š)cgh/¦%·§µõjËxwx-o¢P5ùôùpœŠ„à»c—ž—V–W.ìOZ² BCµ–Œ¼ [Ñjia×Riš•_òTo—¹ ­Ì;Üm< UEðÁúÚ>ò¦F›ͪ>æ$9ðuá9¯}ëÈ:W¦MoÖ£ÒÈ-J¡›-ï¹]žÖ3Œ²Fð°á,zèEþtnh¿›åã\ÈÑAå×*…õÏe6¤‡ßƒÁ ý ”Ò.õÍ`ýIEND®B`‚libDAI-0.3.2/doc/html/functions_func_h.html0000644000175000017500000001366212552201370020126 0ustar jorismjorism libDAI: Class Members - Functions
 

- h -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1MR-members.html0000644000175000017500000004566612552201367020725 0ustar jorismjorism libDAI: Member List
dai::MR Member List

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

_itersdai::MRprivate
_maxdiffdai::MRprivate
_tJ(size_t i, sub_nb A)dai::MRprivate
appM(size_t i, sub_nb A)dai::MRprivate
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const Var &v) const dai::MRinlinevirtual
belief(const VarSet &) const dai::MRvirtual
beliefF(size_t I) const dai::InfAlginlinevirtual
beliefs() const dai::MRvirtual
beliefV(size_t i) const dai::MRvirtual
calcCavityCorrelations()dai::MRprivate
calcMagnetizations()dai::MRprivate
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clone() const dai::MRinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::MRinlinevirtual
corsdai::MRprivate
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findMaximum() const dai::InfAlginlinevirtual
Gdai::MRprivate
Gamma(size_t i, size_t _j, size_t _l1, size_t _l2)dai::MRprivate
Gamma(size_t i, size_t _l1, size_t _l2)dai::MRprivate
getProperties() const dai::MRvirtual
identify() const dai::InfAlginlinevirtual
init()dai::MRinlinevirtual
init(const VarSet &)dai::MRinlinevirtual
Iterations() const dai::MRinlinevirtual
logZ() const dai::MRinlinevirtual
Mdai::MRprivate
Magdai::MRprivate
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::MRinlinevirtual
MR()dai::MRinline
MR(const FactorGraph &fg, const PropertySet &opts)dai::MR
name() const dai::MRinlinevirtual
Omega(size_t i, size_t _j, size_t _l)dai::MRprivate
printProperties() const dai::MRvirtual
propagateCavityFields()dai::MRprivate
props (defined in dai::MR)dai::MR
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()dai::MRvirtual
setMaxIter(size_t)dai::InfAlginlinevirtual
setProperties(const PropertySet &opts)dai::MRvirtual
sub_nb typedefdai::MRprivate
sum_subs(size_t j, sub_nb A, Real *sum_even, Real *sum_odd)dai::MRprivate
supporteddai::MRprivate
T(size_t i, sub_nb A)dai::MRprivate
T(size_t i, size_t _j)dai::MRprivate
thetadai::MRprivate
tJdai::MRprivate
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_36.png0000644000175000017500000000035212552200223015653 0ustar jorismjorism‰PNG  IHDR XÌŽ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïYIDATxíí € ö#­Á°ÿ¶¾#è/G( Çq]þª¨ÉJ6Å°=áþ ¾KÎÅ“£Î°ù¥öéŒÖìP•¸(¯IsÍV­7Bã|P­NŠ‘OÄ•IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1BipartiteGraph.html0000644000175000017500000022447712552201364021660 0ustar jorismjorism libDAI: dai::BipartiteGraph Class Reference
Classes | Private Attributes | List of all members
dai::BipartiteGraph Class Reference

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

#include <dai/bipgraph.h>

Classes

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

Public Member Functions

Constructors and destructors
 BipartiteGraph ()
 Default constructor (creates an empty bipartite graph) More...
 
 BipartiteGraph (size_t nr1, size_t nr2)
 Constructs BipartiteGraph with nr1 nodes of type 1, nr2 nodes of type 2 and no edges. More...
 
template<typename EdgeInputIterator >
 BipartiteGraph (size_t nrNodes1, size_t nrNodes2, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
 Constructs BipartiteGraph from a range of edges. More...
 
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. More...
 
Neighbor & nb1 (size_t i1, size_t _i2)
 Returns reference to the _i2 'th neighbor of node i1 of type 1. More...
 
const Neighbor & nb2 (size_t i2, size_t _i1) const
 Returns constant reference to the _i1 'th neighbor of node i2 of type 2. More...
 
Neighbor & nb2 (size_t i2, size_t _i1)
 Returns reference to the _i1 'th neighbor of node i2 of type 2. More...
 
const Neighbors & nb1 (size_t i1) const
 Returns constant reference to all neighbors of node i1 of type 1. More...
 
Neighbors & nb1 (size_t i1)
 Returns reference to all neighbors of node i1 of type 1. More...
 
const Neighbors & nb2 (size_t i2) const
 Returns constant reference to all neighbors of node i2 of type 2. More...
 
Neighbors & nb2 (size_t i2)
 Returns reference to all neighbors of node i2 of type 2. More...
 
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. More...
 
size_t addNode1 ()
 Adds a node of type 1 without neighbors and returns the index of the added node. More...
 
size_t addNode2 ()
 Adds a node of type 2 without neighbors and returns the index of the added node. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
void eraseNode2 (size_t n2)
 Removes node n2 of type 2 and all incident edges; indices of other nodes are changed accordingly. More...
 
void eraseEdge (size_t n1, size_t n2)
 Removes edge between node n1 of type 1 and node n2 of type 2. More...
 
Queries
size_t nrNodes1 () const
 Returns number of nodes of type 1. More...
 
size_t nrNodes2 () const
 Returns number of nodes of type 2. More...
 
size_t nrEdges () const
 Calculates the number of edges, time complexity: O(nrNodes1()) More...
 
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. More...
 
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. More...
 
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. More...
 
SmallSet< size_t > nb1Set (size_t n1) const
 Returns neighbors of node n1 of type 1 as a SmallSet<size_t>. More...
 
SmallSet< size_t > nb2Set (size_t n2) const
 Returns neighbors of node n2 of type 2 as a SmallSet<size_t>. More...
 
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. More...
 
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. More...
 
bool isConnected () const
 Returns true if the graph is connected. More...
 
bool isTree () const
 Returns true if the graph is a tree, i.e., if it is singly connected and connected. More...
 
bool operator== (const BipartiteGraph &x) const
 Comparison operator which returns true if two graphs are identical. More...
 
void checkConsistency () const
 Asserts internal consistency. More...
 

Private Attributes

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

Input and output

void printDot (std::ostream &os) const
 Writes a BipartiteGraph to an output stream in GraphViz .dot syntax. More...
 
std::string toString () const
 Formats a BipartiteGraph as a string. More...
 
std::ostream & operator<< (std::ostream &os, const BipartiteGraph &g)
 Writes a BipartiteGraph to an output stream. 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
EdgeInputIteratorIterator that iterates over instances of Edge.
Parameters
nrNodes1The number of nodes of type 1.
nrNodes2The number of nodes of type 2.
beginPoints to the first edge.
endPoints just beyond the last edge.
checkWhether 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 
)

(Re)constructs BipartiteGraph from a range of edges.

Template Parameters
EdgeInputIteratorIterator that iterates over instances of Edge.
Parameters
nrNodes1The number of nodes of type 1.
nrNodes2The number of nodes of type 2.
beginPoints to the first edge.
endPoints just beyond the last edge.
checkWhether 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
NodeInputIteratorIterator that iterates over instances of size_t.
Parameters
beginPoints to the first index of the nodes of type 2 that should become neighbors of the added node.
endPoints just beyond the last index of the nodes of type 2 that should become neighbors of the added node.
sizeHintFor 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
NodeInputIteratorIterator that iterates over instances of size_t.
Parameters
beginPoints to the first index of the nodes of type 1 that should become neighbors of the added node.
endPoints just beyond the last index of the nodes of type 1 that should become neighbors of the added node.
sizeHintFor 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.

Examples:
example_bipgraph.cpp.
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_FOUNDif 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_FOUNDif 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 a BipartiteGraph to an output stream in GraphViz .dot syntax.

std::string dai::BipartiteGraph::toString ( ) const
inline

Formats a BipartiteGraph as a string.

Friends And Related Function Documentation

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

Writes a 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1Region.png0000644000175000017500000000135312552201367020003 0ustar jorismjorism‰PNG  IHDR€ˆ³”PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2zIDATxíms„ „—eÆÿÿ“«ò– ½bÏ–NgoÜŠ!†'!دˆ1Æ•B$Éu€@öIvÚm‡ÙÏvŽéqôö×Þ4¶g†!öwöTrNö­28'ÓzÅ¡ªñR«)ϤHš«œê;-~zàUˆëlÛ”j#zÕtˆ(|6µâí2¶µ`©éÆÖíÚÊ—ª+Iv0¡Ûié6¡Ô<÷ª›Ì®=€+¦iBÏÐ7a«ŒGÈv^UÀ÷À]€A؃à[{Ðö”n3'ÝÚ™(ßìtiòRšÖÀ$Ý¥O± € Æ ÞÒ+µ`Û¬Ø×_K°@§@€ @Àˆ1Æ•B$Éu€fÂu”m"[÷ßè5’é>@gê&ÎÇ-I5°çtDJ¹ùèiÁ”ôáÕêsØ\5Hòª€3R]¯^ ¤WýcIò…&J$ÓÖÃú¨gR¹Ëév›“Šß9“ä@7®Ie€~+Œ×c¾aðXì)8G5rÝõbnß¼+œ’ü1 @ø 1ƸPð–6X©ÕÛ¶˜`5À¾þZ‚å:€ @€þ@!¬¬“0 мê(õ0wÝÍç>€7½]¿)€|XS­åO.Dò²Žƒ€Ó À¶„‚¹ê=[Ú„y>×$@ñ²1K4CÖnðBwÒ‚n ŠùWÌÍõ@+Îø¯Ãx Àž‚Òé¦ ??À”¾ë9€¹„ÀéÁ Œ>ÌðZúo(€¿B õ824°¶ÝS$IEND®B`‚libDAI-0.3.2/doc/html/io_8h_source.html0000644000175000017500000002056712552201363017166 0ustar jorismjorism libDAI: include/dai/io.h Source File
io.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_io_h
14 #define __defined_libdai_io_h
15 
16 
17 #include <dai/factor.h>
18 #include <vector>
19 #include <map>
20 
21 
22 namespace dai {
23 
24 
26 
33 void ReadUaiAieFactorGraphFile( const char *filename, size_t verbose, std::vector<Var>& vars, std::vector<Factor>& factors, std::vector<Permute>& permutations );
34 
35 
37 
41 std::vector<std::map<size_t, size_t> > ReadUaiAieEvidenceFile( const char* filename, size_t verbose );
42 
43 
44 } // end of namespace dai
45 
46 
47 #endif
dai::ReadUaiAieEvidenceFile
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 UA...
Definition: io.cpp:147
dai::ReadUaiAieFactorGraphFile
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 approxim...
Definition: io.cpp:21
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factor.h
Defines TFactor<> and Factor classes which represent factors in probability distributions.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BP_1_1EdgeProp.html0000644000175000017500000001711112552201364021542 0ustar jorismjorism libDAI: dai::BP::EdgeProp Struct Reference
Public Attributes | List of all members
dai::BP::EdgeProp Struct Reference

Type used for storing edge properties. More...

#include <dai/bp.h>

Public Attributes

ind_t index
 Index cached for this edge. More...
 
Prob message
 Old message living on this edge. More...
 
Prob newMessage
 New message living on this edge. More...
 
Real residual
 Residual for this edge. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_2.png0000644000175000017500000000061112552200213015561 0ustar jorismjorism‰PNG  IHDR:pRœJ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïøIDATxíѶ„ E· åؘÿÿ·¬ijV=Þ—@ÈüWÉÀwçðLtNûõ libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- d -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1RegionGraph.html0000644000175000017500000031255112552201367021152 0ustar jorismjorism libDAI: dai::RegionGraph Class Reference
Protected Member Functions | Protected Attributes | List of all members
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

Public Member Functions

Constructors and destructors
 RegionGraph ()
 Default constructor. More...
 
 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. More...
 
 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) More...
 
virtual RegionGraph * clone () const
 Clone *this (virtual copy constructor) More...
 
Accessors and mutators
size_t nrORs () const
 Returns number of outer regions. More...
 
size_t nrIRs () const
 Returns number of inner regions. More...
 
const FRegion & OR (size_t alpha) const
 Returns constant reference to outer region alpha. More...
 
FRegion & OR (size_t alpha)
 Returns reference to outer region alpha. More...
 
const Region & IR (size_t beta) const
 Returns constant reference to inner region beta. More...
 
Region & IR (size_t beta)
 Returns reference to inner region beta. More...
 
size_t fac2OR (size_t I) const
 Returns the index of the outer region to which the I 'th factor corresponds. More...
 
const Neighbors & nbOR (size_t alpha) const
 Returns constant reference to the neighbors of outer region alpha. More...
 
const Neighbors & nbIR (size_t beta) const
 Returns constant reference to the neighbors of inner region beta. More...
 
const BipartiteGraph & DAG () const
 Returns DAG structure of the region graph. More...
 
Queries
bool checkCountingNumbers () const
 Check whether the counting numbers are valid. More...
 
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. More...
 
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. More...
 
- Public Member Functions inherited from dai::FactorGraph
 FactorGraph ()
 Default constructor. More...
 
 FactorGraph (const std::vector< Factor > &P)
 Constructs a factor graph from a vector of factors. More...
 
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. More...
 
virtual ~FactorGraph ()
 Destructor. More...
 
const Var & var (size_t i) const
 Returns constant reference the i 'th variable. More...
 
const std::vector< Var > & vars () const
 Returns constant reference to all variables. More...
 
const Factor & factor (size_t I) const
 Returns constant reference to I 'th factor. More...
 
const std::vector< Factor > & factors () const
 Returns constant reference to all factors. More...
 
const Neighbors & nbV (size_t i) const
 Returns constant reference to neighbors of the i 'th variable. More...
 
const Neighbors & nbF (size_t I) const
 Returns constant reference to neighbors of the I 'th factor. More...
 
const Neighbor & nbV (size_t i, size_t _I) const
 Returns constant reference to the _I 'th neighbor of the i 'th variable. More...
 
const Neighbor & nbF (size_t I, size_t _i) const
 Returns constant reference to the _i 'th neighbor of the I 'th factor. More...
 
const BipartiteGraph & bipGraph () const
 Returns neighborhood structure. More...
 
size_t nrVars () const
 Returns number of variables. More...
 
size_t nrFactors () const
 Returns number of factors. More...
 
size_t nrEdges () const
 Calculates number of edges. More...
 
size_t findVar (const Var &n) const
 Returns the index of a particular variable. More...
 
SmallSet< size_t > findVars (const VarSet &ns) const
 Returns a set of indexes corresponding to a set of variables. More...
 
size_t findFactor (const VarSet &ns) const
 Returns index of the first factor that depends on the variables. More...
 
VarSet inds2vars (const std::vector< size_t > &inds) const
 Returns the VarSet corresponding to a vector of variable indices. More...
 
VarSet Delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself included. More...
 
VarSet Delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself included. More...
 
VarSet delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself excluded. More...
 
VarSet delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself excluded. More...
 
SmallSet< size_t > Deltai (size_t i) const
 Return all the indices of variables that occur in a factor involving the i 'th variable, itself included. More...
 
SmallSet< size_t > deltai (size_t i) const
 Return all the indices of variables that occur in a factor involving the i 'th variable, itself excluded. More...
 
bool isConnected () const
 Returns true if the factor graph is connected. More...
 
bool isTree () const
 Returns true if the factor graph is a tree (i.e., has no cycles and is connected) More...
 
bool isPairwise () const
 Returns true if each factor depends on at most two variables. More...
 
bool isBinary () const
 Returns true if each variable has only two possible values. More...
 
GraphAL MarkovGraph () const
 Constructs the corresponding Markov graph. More...
 
bool isMaximal (size_t I) const
 Returns whether the I 'th factor is maximal. More...
 
size_t maximalFactor (size_t I) const
 Returns the index of a maximal factor that contains the I 'th factor. More...
 
std::vector< VarSet > maximalFactorDomains () const
 Returns the maximal factor domains in this factorgraph. More...
 
Real logScore (const std::vector< size_t > &statevec) const
 Evaluates the log score (i.e., minus the energy) of the joint configuration statevec. More...
 
void backupFactor (size_t I)
 Makes a backup of the I 'th factor. More...
 
void restoreFactor (size_t I)
 Restores the I 'th factor from the backup (it should be backed up first) More...
 
virtual void backupFactors (const std::set< size_t > &facs)
 Backup the factors specified by indices in facs. More...
 
virtual void restoreFactors ()
 Restore all factors to the backup copies. More...
 
void backupFactors (const VarSet &ns)
 Makes a backup of all factors connected to a set of variables. More...
 
void restoreFactors (const VarSet &ns)
 Restores all factors connected to a set of variables from their backups. More...
 
FactorGraph maximalFactors () const
 Returns a copy of *this, where all factors that are subsumed by some larger factor are merged with the larger factors. More...
 
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. More...
 
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}$) More...
 
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. More...
 
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. More...
 
virtual void makeCavity (size_t i, bool backup=false)
 Set all factors interacting with the i 'th variable to 1. More...
 
virtual void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Set all factors indexed by facInds to 1. More...
 
std::string toString () const
 Formats a factor graph as a string. More...
 
void fromString (const std::string &s)
 Reads a factor graph from a string. More...
 

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. More...
 
void constructCVM (const FactorGraph &fg, const std::vector< VarSet > &cl, size_t verbose=0)
 Helper function for constructors (CVM style) More...
 
void recomputeORs ()
 Recompute all outer regions. More...
 
void recomputeORs (const VarSet &vs)
 Recompute all outer regions involving the variables in vs. More...
 
void recomputeOR (size_t I)
 Recompute all outer regions involving factor I. More...
 
void calcCVMCountingNumbers ()
 Calculates counting numbers of inner regions based upon counting numbers of outer regions. More...
 

Protected Attributes

BipartiteGraph _G
 Stores the neighborhood structure. More...
 
std::vector< FRegion > _ORs
 The outer regions (corresponding to nodes of type 1) More...
 
std::vector< Region > _IRs
 The inner regions (corresponding to nodes of type 2) More...
 
std::vector< size_t > _fac2OR
 Stores for each factor index the index of the outer region it belongs to. More...
 

Input/output

virtual void ReadFromFile (const char *)
 Reads a region graph from a file. More...
 
virtual void WriteToFile (const char *, size_t=15) const
 Writes a region graph to a file. More...
 
std::string toString () const
 Formats a region graph as a string. More...
 
virtual void printDot (std::ostream &) const
 Writes a region graph to a GraphViz .dot file. More...
 
std::ostream & operator<< (std::ostream &os, const RegionGraph &rg)
 Writes a region graph to an output stream. More...
 

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.

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
inlinevirtual

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 
)
inlinevirtual

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 
)
inlinevirtual

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 *  )
inlinevirtual

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
inlinevirtual

Writes a region graph to a file.

Note
Not implemented yet

Reimplemented from dai::FactorGraph.

std::string dai::RegionGraph::toString ( ) const
inline

Formats a region graph as a string.

virtual void dai::RegionGraph::printDot ( std::ostream &  ) const
inlinevirtual

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 region graph to an output stream.

Member Data Documentation

BipartiteGraph dai::RegionGraph::_G
protected

Stores the neighborhood structure.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1DEdge-members.html0000644000175000017500000001133312552201365021335 0ustar jorismjorism libDAI: Member List
dai::DEdge Member List

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

DEdge()dai::DEdgeinline
DEdge(size_t m1, size_t m2)dai::DEdgeinline
firstdai::DEdge
operator<(const DEdge &x) const dai::DEdgeinline
operator<<(std::ostream &os, const DEdge &e)dai::DEdgefriend
operator==(const DEdge &x) const dai::DEdgeinline
seconddai::DEdge
toString() const dai::DEdgeinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/example_sprinkler_em_8cpp-example.html0000644000175000017500000002174712552201363023371 0ustar jorismjorism 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/
*
* Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
*/
#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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_123.png0000644000175000017500000000051712552200247015741 0ustar jorismjorism‰PNG  IHDR#«é6h0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï¾IDATxí]A¶Ã И&¹ÿm;hÓ4¿Ýþ¥Ï•d¼üìZ ü@-iµZ,¿IÒ‡ ÎvnÜf×´ž+æÃ/I33zl³ zkéóˆ);b%sS<øÜ}ª×J_f±âˆƒŽ`ÂB:Ê‚É~q´ÇgTøàθžœY+#m¹q|7‰£èÚdrVèëÍâ¡V$‚}… SBÓbCÉ$À([ž—/AàþÅûÇR"øBj libDAI: dai::DAIAlg< GRM > Class Template Reference
List of all members
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::ExactInf dai::HAK dai::JTree dai::LC dai::MF dai::MR

Public Member Functions

Constructors/destructors
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
Queries
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
Backup/restore mechanism for factors
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual InfAlg * clone () const =0
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual InfAlg * construct (const FactorGraph &fg, const PropertySet &opts) const =0
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const =0
 Returns the name of the algorithm. More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual void init ()=0
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &vs)=0
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()=0
 Runs the approximate inference algorithm. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &vs) const =0
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< Factor > beliefs () const =0
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const =0
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
virtual std::vector< size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)=0
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const =0
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
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]". More...
 

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
GRMShould 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 ( )
inlinevirtual

Returns reference to underlying FactorGraph.

Implements dai::InfAlg.

template<class GRM >
const FactorGraph& dai::DAIAlg< GRM >::fg ( ) const
inlinevirtual

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 
)
inlinevirtual

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 
)
inlinevirtual

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 >::makeRegionCavity ( std::vector< size_t >  facInds,
bool  backup 
)
inlinevirtual

Sets all factors indicated by facInds 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)
inlinevirtual

Make a backup copy of factor I.

Implements dai::InfAlg.

template<class GRM >
void dai::DAIAlg< GRM >::backupFactors ( const VarSet &  vs)
inlinevirtual

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)
inlinevirtual

Restore factor I from its backup copy.

Implements dai::InfAlg.

template<class GRM >
void dai::DAIAlg< GRM >::restoreFactors ( const VarSet &  vs)
inlinevirtual

Restore the factors involving the variables in vs from their backup copies.

Implements dai::InfAlg.

template<class GRM >
void dai::DAIAlg< GRM >::restoreFactors ( )
inline

Restore all factors from their backup copies.

The documentation for this class was generated from the following file:
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/decmap_8h_source.html0000644000175000017500000004157212552201363020007 0ustar jorismjorism libDAI: include/dai/decmap.h Source File
decmap.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_decmap_h
14 #define __defined_libdai_decmap_h
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_DECMAP
19 
20 
21 #include <dai/daialg.h>
22 
23 
24 namespace dai {
25 
26 
28 
32 class DecMAP : public DAIAlgFG {
33  private:
35  std::vector<size_t> _state;
37  Real _logp;
39  Real _maxdiff;
41  size_t _iters;
42 
43  public:
45  struct Properties {
47  size_t verbose;
48 
50  bool reinit;
51 
53  std::string ianame;
54 
56  PropertySet iaopts;
57  } props;
58 
59  public:
61  DecMAP() : DAIAlgFG(), _state(), _logp(), _maxdiff(), _iters(), props() {}
62 
64 
67  DecMAP( const FactorGraph &fg, const PropertySet &opts );
68 
69 
71 
72  virtual DecMAP* clone() const { return new DecMAP(*this); }
73  virtual DecMAP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new DecMAP( fg, opts ); }
74  virtual std::string name() const { return "DECMAP"; }
75  virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); }
76  virtual Factor belief( const VarSet &/*vs*/ ) const;
77  virtual Factor beliefV( size_t i ) const;
78  virtual Factor beliefF( size_t I ) const { return belief( factor(I).vars() ); }
79  virtual std::vector<Factor> beliefs() const;
80  virtual Real logZ() const { return _logp; }
81  virtual std::vector<size_t> findMaximum() const { return _state; }
82  virtual void init() { _maxdiff = 0.0; _iters = 0; }
83  virtual void init( const VarSet &/*ns*/ ) { init(); }
84  virtual Real run();
85  virtual Real maxDiff() const { return _maxdiff; }
86  virtual size_t Iterations() const { return _iters; }
87  virtual void setProperties( const PropertySet &opts );
88  virtual PropertySet getProperties() const;
89  virtual std::string printProperties() const;
91 };
92 
93 
94 } // end of namespace dai
95 
96 
97 #endif
98 
99 
100 #endif
dai::Factor
TFactor< Real > Factor
Represents a factor with values of type dai::Real.
Definition: factor.h:640
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::findMaximum
std::vector< size_t > findMaximum(const InfAlg &obj)
Calculates the joint state of all variables that has maximum probability, according to the inference ...
Definition: daialg.cpp:211
dai::DAIAlgFG
DAIAlg< FactorGraph > DAIAlgFG
Base class for inference algorithms that operate on a FactorGraph.
Definition: daialg.h:263
dai
Namespace for libDAI.
Definition: alldai.cpp:16
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1sequentialVariableElimination-members.html0000644000175000017500000001011412552201370026366 0ustar jorismjorism libDAI: Member List
dai::sequentialVariableElimination Member List

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

idai::sequentialVariableEliminationprivate
operator()(const ClusterGraph &cl, const std::set< size_t > &)dai::sequentialVariableElimination
seqdai::sequentialVariableEliminationprivate
sequentialVariableElimination(const std::vector< Var > s)dai::sequentialVariableEliminationinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/lc_8h_source.html0000644000175000017500000013614612552201363017156 0ustar jorismjorism libDAI: include/dai/lc.h Source File
lc.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_lc_h
14 #define __defined_libdai_lc_h
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_LC
19 
20 
21 #include <string>
22 #include <dai/daialg.h>
23 #include <dai/enum.h>
24 #include <dai/factorgraph.h>
25 #include <dai/properties.h>
26 #include <dai/exceptions.h>
27 
28 
29 namespace dai {
30 
31 
33 class LC : public DAIAlgFG {
34  private:
36  std::vector<Factor> _pancakes;
38  std::vector<Factor> _cavitydists;
40  std::vector<std::vector<Factor> > _phis;
42  std::vector<Factor> _beliefs;
44  Real _maxdiff;
46  size_t _iters;
47 
48  public:
50  struct Properties {
52 
58  DAI_ENUM(CavityType,FULL,PAIR,PAIR2,UNIFORM);
59 
61 
65  DAI_ENUM(UpdateType,SEQFIX,SEQRND);
66 
68  size_t verbose;
69 
71  size_t maxiter;
72 
74  Real tol;
75 
77  bool reinit;
78 
80  Real damping;
81 
83  CavityType cavity;
84 
86  UpdateType updates;
87 
89  std::string cavainame;
90 
92  PropertySet cavaiopts;
93  } props;
94 
95  public:
97  LC() : DAIAlgFG(), _pancakes(), _cavitydists(), _phis(), _beliefs(), _maxdiff(), _iters(), props() {}
98 
100 
103  LC( const FactorGraph &fg, const PropertySet &opts );
104 
105 
107 
108  virtual LC* clone() const { return new LC(*this); }
109  virtual LC* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new LC( fg, opts ); }
110  virtual std::string name() const { return "LC"; }
111  virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); }
112  virtual Factor belief( const VarSet &/*vs*/ ) const;
113  virtual Factor beliefV( size_t i ) const { return _beliefs[i]; }
114  virtual std::vector<Factor> beliefs() const { return _beliefs; }
115  virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; }
116  virtual void init();
117  virtual void init( const VarSet &/*ns*/ ) { init(); }
118  virtual Real run();
119  virtual Real maxDiff() const { return _maxdiff; }
120  virtual size_t Iterations() const { return _iters; }
121  virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; }
122  virtual void setProperties( const PropertySet &opts );
123  virtual PropertySet getProperties() const;
124  virtual std::string printProperties() const;
126 
128 
129  Real CalcCavityDist( size_t i, const std::string &name, const PropertySet &opts );
132  Real InitCavityDists( const std::string &name, const PropertySet &opts );
134  long SetCavityDists( std::vector<Factor> &Q );
136  Factor NewPancake (size_t i, size_t _I, bool & hasNaNs);
138  void CalcBelief (size_t i);
140  const Factor &pancake (size_t i) const { return _pancakes[i]; };
142  const Factor &cavitydist (size_t i) const { return _cavitydists[i]; };
144 };
145 
146 
147 } // end of namespace dai
148 
149 
150 #endif
151 
152 
153 #endif
dai::LC::_pancakes
std::vector< Factor > _pancakes
Stores for each variable the approximate cavity distribution multiplied with the omitted factors...
Definition: lc.h:36
dai::LC::run
virtual Real run()
Runs the approximate inference algorithm.
Definition: lc.cpp:249
dai::LC::Properties::cavainame
std::string cavainame
Name of the algorithm used to initialize the cavity distributions.
Definition: lc.h:89
dai::LC::Properties::DAI_ENUM
DAI_ENUM(CavityType, FULL, PAIR, PAIR2, UNIFORM)
Enumeration of possible ways to initialize the cavities.
dai::LC::init
virtual void init()
Initializes all data structures of the approximate inference algorithm.
Definition: lc.cpp:208
dai::LC::clone
virtual LC * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: lc.h:108
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::LC::setProperties
virtual void setProperties(const PropertySet &opts)
Set parameters of this inference algorithm.
Definition: lc.cpp:28
dai::LC::belief
virtual Factor belief(const Var &v) const
Returns the (approximate) marginal probability distribution of a variable.
Definition: lc.h:111
dai::LC::Properties::tol
Real tol
Tolerance for convergence test.
Definition: lc.h:74
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::LC::CalcCavityDist
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 parameter...
Definition: lc.cpp:129
dai::LC::Properties::updates
UpdateType updates
What update schedule to use.
Definition: lc.h:86
dai::LC::Properties::reinit
bool reinit
Complete or partial reinitialization of cavity graphs?
Definition: lc.h:77
dai::LC::cavitydist
const Factor & cavitydist(size_t i) const
Returns the approximate cavity distribution for variable i.
Definition: lc.h:142
dai::LC::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: lc.h:120
dai::LC::_maxdiff
Real _maxdiff
Maximum difference encountered so far.
Definition: lc.h:44
dai::LC::_beliefs
std::vector< Factor > _beliefs
Single variable beliefs.
Definition: lc.h:42
dai::LC::beliefs
virtual std::vector< Factor > beliefs() const
Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm...
Definition: lc.h:114
dai::LC::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: lc.cpp:70
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::LC::init
virtual void init(const VarSet &)
Initializes all data structures corresponding to some set of variables.
Definition: lc.h:117
dai::LC::Properties::maxiter
size_t maxiter
Maximum number of iterations.
Definition: lc.h:71
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::LC::setMaxIter
virtual void setMaxIter(size_t maxiter)
Sets maximum number of iterations (one iteration passes over the complete factorgraph).
Definition: lc.h:121
dai::LC::pancake
const Factor & pancake(size_t i) const
Returns the belief of the Markov blanket of variable i (including the variable itself) ...
Definition: lc.h:140
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::LC::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: lc.h:68
dai::LC::InitCavityDists
Real InitCavityDists(const std::string &name, const PropertySet &opts)
Approximates all cavity distributions using inference algorithm name with parameters opts...
Definition: lc.cpp:163
dai::LC::NewPancake
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 nei...
Definition: lc.cpp:218
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::LC::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: lc.h:110
dai::LC::LC
LC()
Default constructor.
Definition: lc.h:97
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::LC::_iters
size_t _iters
Number of iterations needed.
Definition: lc.h:46
dai::LC::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: lc.h:119
dai::LC::SetCavityDists
long SetCavityDists(std::vector< Factor > &Q)
Sets approximate cavity distributions to Q.
Definition: lc.cpp:193
dai::LC::beliefV
virtual Factor beliefV(size_t i) const
Returns the (approximate) marginal probability distribution of the variable with index i...
Definition: lc.h:113
dai::LC::_cavitydists
std::vector< Factor > _cavitydists
Stores for each variable the approximate cavity distribution.
Definition: lc.h:38
dai::LC::_phis
std::vector< std::vector< Factor > > _phis
_phis[i][_I] corresponds to in the paper
Definition: lc.h:40
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::LC::construct
virtual LC * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: lc.h:109
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
dai::LC::CalcBelief
void CalcBelief(size_t i)
Calculates the belief of variable i.
Definition: lc.cpp:112
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::LC::Properties
Parameters for LC.
Definition: lc.h:50
dai::DAIAlg
Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)...
Definition: daialg.h:207
dai::LC::Properties::cavity
CavityType cavity
How to initialize the cavities.
Definition: lc.h:83
dai::LC::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: lc.cpp:55
dai::LC::Properties::cavaiopts
PropertySet cavaiopts
Parameters for the algorithm used to initialize the cavity distributions.
Definition: lc.h:92
dai::LC
Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07].
Definition: lc.h:33
dai::LC::Properties::damping
Real damping
Damping constant (0.0 means no damping, 1.0 is maximum damping)
Definition: lc.h:80
dai::LC::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: lc.h:115
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_j.html0000644000175000017500000001137212552201370020124 0ustar jorismjorism libDAI: Class Members - Functions
 

- j -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_e.html0000644000175000017500000001040112552201370020127 0ustar jorismjorism libDAI: Class Members - Variables
 

- e -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_76.png0000644000175000017500000000041712552200234015663 0ustar jorismjorism‰PNG  IHDR?Ÿš0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï~IDATxí[Ä EˆNM»ÿÝŽ¶4Vçs¾Íå!'pÿš 0IÌ“ð–äê%Ù&+Žr˜ìA=X$¦ÑÒ‘ˆz$lôtT´aÎÆÐå­B ²ÜýÖüɳMØkížüPBUUR;-î×­giY"ŽÀ¤õ“Þ¯Ö•èaî%IEND®B`‚libDAI-0.3.2/doc/html/functions_t.html0000644000175000017500000002243212552201370017122 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- t -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1TreeEP-members.html0000644000175000017500000004665512552201370021524 0ustar jorismjorism libDAI: Member List
dai::TreeEP Member List

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

_itersdai::TreeEPprivate
_maxdiffdai::TreeEPprivate
_Qdai::TreeEPprivate
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const VarSet &vs) const dai::JTreevirtual
dai::DAIAlg::belief(const Var &v) const dai::InfAlginlinevirtual
beliefF(size_t I) const dai::InfAlginlinevirtual
beliefs() const dai::JTreevirtual
beliefV(size_t i) const dai::InfAlginlinevirtual
boundTreewidth(const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates=0)dai::JTreerelated
calcMarginal(const VarSet &vs)dai::JTree
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clone() const dai::TreeEPinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::TreeEPinlinevirtual
construct(const FactorGraph &fg, const RootedTree &tree)dai::TreeEPprivate
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 >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findEfficientTree(const VarSet &vs, RootedTree &Tree, size_t PreviousRoot=(size_t)-1) const dai::JTree
findMaximum() const dai::JTreevirtual
GenerateJT(const FactorGraph &fg, const std::vector< VarSet > &cl)dai::JTree
getProperties() const dai::TreeEPvirtual
identify() const dai::InfAlginlinevirtual
init()dai::TreeEPvirtual
init(const VarSet &)dai::TreeEPinlinevirtual
Iterations() const dai::TreeEPinlinevirtual
JTree()dai::JTreeinline
JTree(const FactorGraph &fg, const PropertySet &opts, bool automatic=true)dai::JTree
logZ() const dai::TreeEPvirtual
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::TreeEPinlinevirtual
message(size_t alpha, size_t _beta) const dai::JTreeinline
message(size_t alpha, size_t _beta)dai::JTreeinline
name() const dai::TreeEPinlinevirtual
offtree(size_t I) const dai::TreeEPinlineprivate
operator=(const TreeEP &x)dai::TreeEPinline
printProperties() const dai::TreeEPvirtual
props (defined in dai::TreeEP)dai::TreeEP
Qadai::JTree
Qbdai::JTree
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
RTreedai::JTree
run()dai::TreeEPvirtual
runHUGIN()dai::JTree
runShaferShenoy()dai::JTree
setMaxIter(size_t maxiter)dai::TreeEPinlinevirtual
setProperties(const PropertySet &opts)dai::TreeEPvirtual
TreeEP()dai::TreeEPinline
TreeEP(const TreeEP &x)dai::TreeEPinline
TreeEP(const FactorGraph &fg, const PropertySet &opts)dai::TreeEP
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1FBP.html0000644000175000017500000024677512552201365017370 0ustar jorismjorism libDAI: dai::FBP Class Reference
Protected Attributes | List of all members
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

Public Member Functions

Constructors/destructors
 FBP ()
 Default constructor. More...
 
 FBP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
General InfAlg interface
virtual FBP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual FBP * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
- Public Member Functions inherited from dai::BP
 BP ()
 Default constructor. More...
 
 BP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
 BP (const BP &x)
 Copy constructor. More...
 
BP & operator= (const BP &x)
 Assignment operator. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
std::vector< size_t > findMaximum () const
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &ns)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
const std::vector< std::pair< size_t, size_t > > & getSentMessages () const
 Returns history of which messages have been updated. More...
 
void clearSentMessages ()
 Clears history of which messages have been updated. More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 

Protected Attributes

std::vector< Real > _weight
 Factor weights (indexed by factor ID) More...
 
- Protected Attributes inherited from dai::BP
std::vector< std::vector< EdgeProp > > _edges
 Stores all edge properties. More...
 
std::vector< std::vector< LutType::iterator > > _edge2lut
 Lookup table (only used for maximum-residual BP) More...
 
LutType _lut
 Lookup table (only used for maximum-residual BP) More...
 
Real _maxdiff
 Maximum difference between variable beliefs encountered so far. More...
 
size_t _iters
 Number of iterations needed. More...
 
std::vector< std::pair< size_t, size_t > > _sentMessages
 The history of message updates (only recorded if recordSentMessages is true) More...
 
std::vector< Factor > _oldBeliefsV
 Stores variable beliefs of previous iteration. More...
 
std::vector< Factor > _oldBeliefsF
 Stores factor beliefs of previous iteration. More...
 
std::vector< Edge > _updateSeq
 Stores the update schedule. More...
 

FBP accessors/mutators for weights

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

Additional Inherited Members

- Public Attributes inherited from dai::BP
struct dai::BP::Properties props
 
bool recordSentMessages
 Specifies whether the history of message updates should be recorded. More...
 
- Protected Types inherited from dai::BP
typedef std::vector< size_t > ind_t
 Type used for index cache. More...
 
typedef std::multimap< Real, std::pair< size_t, size_t > > LutType
 Type of lookup table (only used for maximum-residual BP) More...
 
- Protected Member Functions inherited from dai::BP
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. More...
 
Prob & message (size_t i, size_t _I)
 Returns reference to message from the _I 'th neighbor of variable i to variable i. More...
 
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. More...
 
Prob & newMessage (size_t i, size_t _I)
 Returns reference to updated message from the _I 'th neighbor of variable i to variable i. More...
 
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. More...
 
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. More...
 
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. More...
 
Real & residual (size_t i, size_t _I)
 Returns reference to residual for the edge between variable i and its _I 'th neighbor. More...
 
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. More...
 
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. More...
 
void findMaxResidual (size_t &i, size_t &_I)
 Finds the edge which has the maximum residual (difference between new and old message) More...
 
virtual void calcBeliefV (size_t i, Prob &p) const
 Calculates unnormalized belief of variable i. More...
 

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
fgFactor graph.
optsParameters
See also
BP::Properties

Member Function Documentation

virtual FBP* dai::FBP::clone ( ) const
inlinevirtual

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

Reimplemented from dai::BP.

virtual FBP* dai::FBP::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Reimplemented from dai::BP.

virtual std::string dai::FBP::name ( ) const
inlinevirtual

Returns the name of the algorithm.

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_IMPLEMENTEDif 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
protectedvirtual

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 
)
protectedvirtual

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
inlineprotectedvirtual

Calculates unnormalized belief of factor I.

Reimplemented from dai::BP.

void dai::FBP::construct ( )
protectedvirtual

Helper function for constructors.

Reimplemented from dai::BP.

Member Data Documentation

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

Factor weights (indexed by factor ID)

The documentation for this class was generated from the following files:
  • include/dai/fbp.h
  • src/fbp.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1HAK.png0000644000175000017500000000154312552201366017163 0ustar jorismjorism‰PNG  IHDR­ˆ¢›ôPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2òIDATxíݲƒ —™¾ÿ#ÿ ¨=­6µÌ¤ã¶) ®â-9çÜ dIj„°•$ÂV’|¸l›¶ÑÚ¤4Äcƒi–¤3|ÐöðÒø{»m—ºÞ! )´¹íÚûï9µ‹ít‚$á’í 4iHÉK´t›I:ÅUÛ9U³š‰÷moÍí¼žÙŽÝ¿bkÕ¶¶KAøÛrݾ`{ߺµ5aˆì±g{kM¤·iÇöÖu+Iï1½/$é ß_ ’t–°•$ÂV’|èlsιx4CS¶GKºMÙv² é¶e5À‹°ð!l|[ÂÀ‡°ð!l|[ÂÀ‡°ð!l|[¶ÿäœs3%©ÂV’|[Iò¡°MÛ(õŸ¢qû-©8ì9{“%iËAómÙ4«­l,IOº$­ÇSHRÉjÛÝf?f¼Ý5·vÞ]Ûé¼=‹)uã;yyq¶ªo7ë‹í0~šSJ攎™Î¥JÛr„i°SÏgV}¦ßx[Û¹ßÎôŠíœâzÝ–#Š¨Nvqa3kå»±¯´gkÖxç¹U£žÙ¯zp±¾¦ùkÛb&kkƒ:®s[> ×lwòþ<·Õ½U;æØöíu[俲-sp´nmM˜÷ð¸S§}`{ª&¬¿þcêÅNQøÈ»ìÿÚúBõ}eàeÛƒ,¼5â{¶óã–¤þñ=[Iúa+I>„­$ùÐÙæœs+8ðh†¦l–t›²ídÒmË6j€a àCØø¶>„-€a àCØø¶>„-€a àCØø¶>„mÿI)¥f 4BØø¶>|Ävb‰Æ`ó}ñb¶­š&ÃEôêµ®ÛNE°/†û¹]m/'æ²m/1‰$° ®?ÅOØÎSØìÍïc;ü8ÏÇlG·•`¬b%Ì"»¶Epû.Û¬Ûg¶÷W0S†¨ÚeÛà$ñæð!l|[ÂÀ‡Î6¥”ZáSÔEô± RxIEND®B`‚libDAI-0.3.2/doc/html/tab_s.png0000644000175000017500000000027012552201363015475 0ustar jorismjorism‰PNG  IHDR$ÇÇ[IDATxíÝ ‚@@Ñ£?Q…¤"š¢%¦I‘—Šf–6[´HÃäQƒ<Þâõþ]ždr Í’s?ˆO=Ñññw'ÌF‡Ž íðö-~rÃ[œèŠ­ì¬mƒÖ¬ƒݯнŠÕF)Yº% §`nÌ,9B ™’©!ÑŒ\ý<Å#üîî•IEND®B`‚libDAI-0.3.2/doc/html/dir_da72ea5b7cdd8cae0fb606fe1079cd0c.html0000644000175000017500000006044212552201370022437 0ustar jorismjorism libDAI: include/dai Directory Reference
dai Directory Reference

Directories

directory  matlab
 

Files

file  alldai.h [code]
 Main libDAI header file. It #includes all other libDAI headers.
 
file  bbp.h [code]
 Defines class BBP, which implements Back-Belief-Propagation.
 
file  bipgraph.h [code]
 Defines the BipartiteGraph class, which represents a bipartite graph.
 
file  bp.h [code]
 Defines class BP, which implements (Loopy) Belief Propagation.
 
file  bp_dual.h [code]
 Defines class BP_dual, which is used primarily by BBP.
 
file  cbp.h [code]
 Defines class CBP, which implements Conditioned Belief Propagation.
 
file  clustergraph.h [code]
 Defines class ClusterGraph, which is used by JTree, TreeEP and HAK.
 
file  cobwebgraph.h [code]
 Defines class CobwebGraph, which implements a type of region graph used by GLC.
 
file  createfg.h [code]
 Provides functionality for input/output of data structures in various file formats.
 
file  dag.h [code]
 Defines the DAG class, which represents a directed acyclic graph.
 
file  dai_config.h [code]
 Allows the user to specify which algorithms will be built into libDAI.
 
file  daialg.h [code]
 Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
 
file  decmap.h [code]
 Defines class DecMAP, which constructs a MAP state by decimation.
 
file  doc.h [code]
 Contains additional doxygen documentation.
 
file  emalg.h [code]
 Defines classes related to Expectation Maximization (EMAlg, ParameterEstimation, CondProbEstimation and SharedParameters)
 
file  enum.h [code]
 Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
 
file  evidence.h [code]
 Defines class Evidence, which stores multiple observations of joint states of variables.
 
file  exactinf.h [code]
 Defines ExactInf class, which can be used for exact inference on small factor graphs.
 
file  exceptions.h [code]
 Defines the Exception class and macros for throwing exceptions and doing assertions.
 
file  factor.h [code]
 Defines TFactor<> and Factor classes which represent factors in probability distributions.
 
file  factorgraph.h [code]
 Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov random fields)
 
file  fbp.h [code]
 Defines class FBP, which implements Fractional Belief Propagation.
 
file  gibbs.h [code]
 Defines class Gibbs, which implements Gibbs sampling.
 
file  glc.h [code]
 Defines classes GLC and Cobweb, which implement the "Generalized Loop Correction method".
 
file  graph.h [code]
 Defines the GraphAL class, which represents an undirected graph as an adjacency list.
 
file  hak.h [code]
 Defines class HAK, which implements a variant of Generalized Belief Propagation.
 
file  index.h [code]
 Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensional arrays.
 
file  io.h [code]
 Provides functionality for input/output of data structures in various file formats.
 
file  jtree.h [code]
 Defines class JTree, which implements the junction tree algorithm.
 
file  lc.h [code]
 Defines class LC, which implements loop corrections for approximate inference.
 
file  mf.h [code]
 Defines class MF which implements the Mean Field algorithm.
 
file  mr.h [code]
 Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo.
 
file  prob.h [code]
 Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributions of discrete random variables)
 
file  properties.h [code]
 Defines the Property and PropertySet classes, which are mainly used for managing parameters of inference algorithms.
 
file  regiongraph.h [code]
 Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs.
 
file  smallset.h [code]
 Defines the SmallSet<> class, which represents a set (optimized for a small number of elements).
 
file  test1.cpp
 
file  test2.cpp
 
file  test3.cpp
 
file  test4.cpp
 
file  treeep.h [code]
 Defines class TreeEP, which implements Tree Expectation Propagation.
 
file  trwbp.h [code]
 Defines class TRWBP, which implements Tree-Reweighted Belief Propagation.
 
file  util.h [code]
 Defines general utility functions and adds an abstraction layer for platform-dependent functionality.
 
file  var.h [code]
 Defines class Var, which represents a discrete random variable.
 
file  varset.h [code]
 Defines the VarSet class, which represents a set of random variables.
 
file  weightedgraph.h [code]
 Defines some utility functions for (weighted) undirected graphs, trees and rooted trees.
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_35.png0000644000175000017500000000046512552200223015657 0ustar jorismjorism‰PNG  IHDR'›Þõù0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï¤IDATxíƒ E?ˆ`e–ûßv-X)˲ì Oúý~ñðwo𽃛Q€ï}½&'Ç–Eeòéø®£†-ÎMÏ=ÓAÉÐE¼?·tÎçv‰rîæÊ)³ªÞ]#RŽx¦[ì4R¨rQÃUh:U’šDÒÙÖ„wÍ6uR¥Ž \Ä<ÒØíïYt¢¼-e2²mǃ°¬‹ùÇø¨7æj*‘£IEND®B`‚libDAI-0.3.2/doc/html/functions_enum.html0000644000175000017500000000535612552201370017631 0ustar jorismjorism libDAI: Class Members - Enumerations
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_t.html0000644000175000017500000001263112552201370020155 0ustar jorismjorism libDAI: Class Members - Variables
 

- t -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1Exception-members.html0000644000175000017500000003475412552201365022337 0ustar jorismjorism libDAI: Member List
dai::Exception Member List

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

_detailedMsgdai::Exceptionprivate
_errorcodedai::Exceptionprivate
_filenamedai::Exceptionprivate
_functiondai::Exceptionprivate
_linedai::Exceptionprivate
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::Exceptioninline
ErrorStringsdai::Exceptionprivatestatic
Exception(Code code, const char *filename, const char *function, const char *line, const std::string &detailedMsg)dai::Exceptioninline
FACTORGRAPH_NOT_CONNECTED enum value (defined in dai::Exception)dai::Exception
getCode() const dai::Exceptioninline
getDetailedMsg() const dai::Exceptioninline
getFilename() const dai::Exceptioninline
getFunction() const dai::Exceptioninline
getLine() const dai::Exceptioninline
getMsg() const dai::Exceptioninline
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::Exceptioninline
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
~Exception()dai::Exceptioninline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/bibliography.html0000644000175000017500000002013612552201364017244 0ustar jorismjorism 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

RYG12 S. Ravanbakhsh, C.-N. Yu, R. Greiner (2012): "A Generalized Loop Correction Method for Approximate Inference in Graphical Models", 29th International Conference on Machine Learning (ICML 2012), http://www.icml.cc/2012/papers/#paper-304

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_47.png0000644000175000017500000000056212552200226015663 0ustar jorismjorism‰PNG  IHDR3Á‹0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïáIDATxímrÄ @Ÿøm’zÿÛ5m´™tÛiÿ2"»à à¯*bœø^Cúª³à…nUŒJ®cw\X5†èÃìHµWÓMŒë€eÑðöÄd!G=\KvÝìc€›†Y?ô’1µQýƒ [Hý9Óݱ ÓÆ]M³aüNÍŸ’6ü™r¹<^7mÝ®1s¶bf–Ž¦ñ'…œÛœÆÜóˆ=×E}'óq­ðå„–<ó´W«ñmÔÞꮦXï´u}aú+º½+%Û}OñE_À?è;0–q™J<{IEND®B`‚libDAI-0.3.2/doc/html/weightedgraph_8h.html0000644000175000017500000002157112552201363020015 0ustar jorismjorism libDAI: include/dai/weightedgraph.h File Reference
Classes | Namespaces | Functions
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 <boost/graph/adjacency_list.hpp>
#include <boost/graph/prim_minimum_spanning_tree.hpp>
#include <boost/graph/kruskal_min_spanning_tree.hpp>
#include <dai/util.h>
#include <dai/exceptions.h>
#include <dai/graph.h>

Go to the source code of this file.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

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. More...
 
template<typename T >
RootedTree dai::MaxSpanningTree (const WeightedGraph< T > &G, bool usePrim)
 Constructs a minimum spanning tree from the (non-negatively) weighted graph G. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_57.png0000644000175000017500000000034712552200230015660 0ustar jorismjorism‰PNG  IHDR —™'n0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïVIDATxí[D!C "bâþw;ÅûúœTi=v ðOnîá¯5ÅP»26/Yȼ‰uNê蘒Ფýž•cö6Çáƒ'F÷<#u¨/¡~m¿^mæg&IEND®B`‚libDAI-0.3.2/doc/html/emalg_8h_source.html0000644000175000017500000026541312552201363017645 0ustar jorismjorism libDAI: include/dai/emalg.h Source File
emalg.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
9 #ifndef __defined_libdai_emalg_h
10 #define __defined_libdai_emalg_h
11 
12 
13 #include <vector>
14 #include <map>
15 
16 #include <dai/factor.h>
17 #include <dai/daialg.h>
18 #include <dai/evidence.h>
19 #include <dai/index.h>
20 #include <dai/properties.h>
21 
22 
26 
27 
28 namespace dai {
29 
30 
32 
50 class ParameterEstimation {
51  public:
53  typedef ParameterEstimation* (*ParamEstFactory)( const PropertySet& );
54 
56  virtual ~ParameterEstimation() {}
57 
59  virtual ParameterEstimation* clone() const = 0;
60 
62 
67  static ParameterEstimation* construct( const std::string &method, const PropertySet &p );
68 
70  static void registerMethod( const std::string &method, const ParamEstFactory &f ) {
71  if( _registry == NULL )
72  loadDefaultRegistry();
73  (*_registry)[method] = f;
74  }
75 
77  virtual Prob estimate(const Prob &p) { return parametersToFactor(parameters(p)); }
78 
80  virtual Prob parametersToFactor(const Prob &params) = 0;
81 
83  virtual Prob parameters(const Prob &p) = 0;
84 
86  virtual size_t probSize() const = 0;
87 
88  // Returns the name of the class of this parameter estimation
89  virtual const std::string& name() const = 0;
90 
91  virtual const PropertySet& properties() const = 0;
92  private:
94  static std::map<std::string, ParamEstFactory> *_registry;
95 
97  static void loadDefaultRegistry();
98 };
99 
100 
102 
104 class CondProbEstimation : private ParameterEstimation {
105  private:
107  size_t _target_dim;
109  Prob _initial_stats;
110 
111  static std::string _name; // = "CondProbEstimation";
112 
114  PropertySet _props;
115 
116  public:
118 
122  CondProbEstimation( size_t target_dimension, const Prob &pseudocounts );
123 
125 
133  static ParameterEstimation* factory( const PropertySet &p );
134 
136  virtual ParameterEstimation* clone() const { return new CondProbEstimation( _target_dim, _initial_stats ); }
137 
139  virtual ~CondProbEstimation() {}
140 
142 
145  virtual Prob parameters(const Prob &p);
146 
147  // For a discrete conditional probability distribution,
148  // the parameters are equivalent to the resulting factor
149  virtual Prob parametersToFactor(const Prob &p);
150 
152  virtual size_t probSize() const { return _initial_stats.size(); }
153 
154  virtual const std::string& name() const { return _name; }
155 
156  virtual const PropertySet& properties() const { return _props; }
157 };
158 
159 
161 
171 class SharedParameters {
172  public:
174  typedef size_t FactorIndex;
176  typedef std::map<FactorIndex, std::vector<Var> > FactorOrientations;
177 
178  private:
180  std::map<FactorIndex, VarSet> _varsets;
182  std::map<FactorIndex, Permute> _perms;
184  FactorOrientations _varorders;
186  ParameterEstimation *_estimation;
188  bool _ownEstimation;
190  Prob* _expectations;
191 
193 
197  static Permute calculatePermutation( const std::vector<Var> &varOrder, VarSet &outVS );
198 
200  void setPermsAndVarSetsFromVarOrders();
201 
202  public:
204 
208  SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE=false );
209 
211 
214  SharedParameters( std::istream &is, const FactorGraph &fg );
215 
217  SharedParameters( const SharedParameters &sp ) : _varsets(sp._varsets), _perms(sp._perms), _varorders(sp._varorders), _estimation(sp._estimation), _ownEstimation(sp._ownEstimation), _expectations(NULL) {
218  // If sp owns its _estimation object, we should clone it instead of copying the pointer
219  if( _ownEstimation )
220  _estimation = _estimation->clone();
221  _expectations = new Prob(*sp._expectations);
222  }
223 
225  ~SharedParameters() {
226  // If we own the _estimation object, we should delete it now
227  if( _ownEstimation )
228  delete _estimation;
229  if( _expectations != NULL)
230  delete _expectations;
231  }
232 
234 
238  void collectExpectations( InfAlg &alg );
239 
241  const Prob& currentExpectations() const { return *_expectations; }
242 
243  ParameterEstimation& getPEst() const { return *_estimation; }
244 
246 
251  void setParameters( FactorGraph &fg );
252 
254 
258  const FactorOrientations& getFactorOrientations() const { return _varorders; }
259 
261  void clear( ) { _expectations->fill(0); }
262 };
263 
264 
266 
268 class MaximizationStep {
269  private:
271  std::vector<SharedParameters> _params;
272 
273  public:
275  MaximizationStep() : _params() {}
276 
278  MaximizationStep( std::vector<SharedParameters> &maximizations ) : _params(maximizations) {}
279 
281 
283  MaximizationStep( std::istream &is, const FactorGraph &fg_varlookup );
284 
286  void addExpectations( InfAlg &alg );
287 
289  void maximize( FactorGraph &fg );
290 
292  void clear( );
293 
295 
296  typedef std::vector<SharedParameters>::iterator iterator;
299  typedef std::vector<SharedParameters>::const_iterator const_iterator;
300 
302  iterator begin() { return _params.begin(); }
304  const_iterator begin() const { return _params.begin(); }
306  iterator end() { return _params.end(); }
308  const_iterator end() const { return _params.end(); }
310 };
311 
312 
314 
331 class EMAlg {
332  private:
334  const Evidence &_evidence;
335 
337  InfAlg &_estep;
338 
340  std::vector<MaximizationStep> _msteps;
341 
343  size_t _iters;
344 
346  std::vector<Real> _lastLogZ;
347 
349  size_t _max_iters;
350 
352  Real _log_z_tol;
353 
354  public:
356  static const std::string MAX_ITERS_KEY;
358  static const size_t MAX_ITERS_DEFAULT;
360  static const std::string LOG_Z_TOL_KEY;
362  static const Real LOG_Z_TOL_DEFAULT;
363 
365 
370  EMAlg( const Evidence &evidence, InfAlg &estep, std::vector<MaximizationStep> &msteps, const PropertySet &termconditions )
371  : _evidence(evidence), _estep(estep), _msteps(msteps), _iters(0), _lastLogZ(), _max_iters(MAX_ITERS_DEFAULT), _log_z_tol(LOG_Z_TOL_DEFAULT)
372  {
373  setTermConditions( termconditions );
374  }
375 
377 
379  EMAlg( const Evidence &evidence, InfAlg &estep, std::istream &mstep_file );
380 
382 
388  void setTermConditions( const PropertySet &p );
389 
391 
397  bool hasSatisfiedTermConditions() const;
398 
400  Real logZ() const { return _lastLogZ.back(); }
401 
403  size_t Iterations() const { return _iters; }
404 
406  const InfAlg& eStep() const { return _estep; }
407 
409 
411  Real iterate();
412 
414  Real iterate( MaximizationStep &mstep );
415 
417  void run();
418 
420 
421  typedef std::vector<MaximizationStep>::iterator s_iterator;
424  typedef std::vector<MaximizationStep>::const_iterator const_s_iterator;
425 
427  s_iterator s_begin() { return _msteps.begin(); }
429  const_s_iterator s_begin() const { return _msteps.begin(); }
431  s_iterator s_end() { return _msteps.end(); }
433  const_s_iterator s_end() const { return _msteps.end(); }
435 };
436 
437 
438 } // end of namespace dai
439 
440 
446 #endif
dai::ParameterEstimation::ParamEstFactory
ParameterEstimation *(* ParamEstFactory)(const PropertySet &)
Type of pointer to factory function.
Definition: emalg.h:53
dai::MaximizationStep::addExpectations
void addExpectations(InfAlg &alg)
Collect the beliefs from this InfAlg as expectations for the next Maximization step.
Definition: emalg.cpp:209
dai::MaximizationStep::begin
const_iterator begin() const
Returns constant iterator that points to the first parameter estimation task.
Definition: emalg.h:304
dai::SharedParameters::_varorders
FactorOrientations _varorders
Maps factor indices to the corresponding desired variable orderings.
Definition: emalg.h:184
dai::MaximizationStep::const_iterator
std::vector< SharedParameters >::const_iterator const_iterator
Constant iterator over the parameter estimation tasks.
Definition: emalg.h:299
dai::ParameterEstimation::parametersToFactor
virtual Prob parametersToFactor(const Prob &params)=0
Convert a set of estimated parameters to a factor.
dai::TProb::fill
this_type & fill(T x)
Sets all entries to x.
Definition: prob.h:544
evidence.h
Defines class Evidence, which stores multiple observations of joint states of variables.
dai::CondProbEstimation::probSize
virtual size_t probSize() const
Returns the required size for arguments to estimate().
Definition: emalg.h:152
dai::EMAlg::_estep
InfAlg & _estep
How to do the expectation step.
Definition: emalg.h:337
dai::MaximizationStep::iterator
std::vector< SharedParameters >::iterator iterator
Iterator over the parameter estimation tasks.
Definition: emalg.h:297
index.h
Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensi...
dai::SharedParameters::collectExpectations
void collectExpectations(InfAlg &alg)
Collect the expected values (beliefs) according to alg.
Definition: emalg.cpp:171
dai::CondProbEstimation::_props
PropertySet _props
PropertySet that allows reconstruction of this estimator.
Definition: emalg.h:114
dai::MaximizationStep::clear
void clear()
Clear the step, to be called at the begining of each step.
Definition: emalg.cpp:221
dai::SharedParameters::SharedParameters
SharedParameters(const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE=false)
Constructor.
Definition: emalg.cpp:106
dai::SharedParameters::_estimation
ParameterEstimation * _estimation
Parameter estimation method to be used.
Definition: emalg.h:186
dai::SharedParameters::setParameters
void setParameters(FactorGraph &fg)
Estimate and set the shared parameters.
Definition: emalg.cpp:185
dai::MaximizationStep::end
const_iterator end() const
Returns constant iterator that points beyond the last parameter estimation task.
Definition: emalg.h:308
dai::CondProbEstimation::_target_dim
size_t _target_dim
Number of states of the variable of interest.
Definition: emalg.h:107
dai::Prob
TProb< Real > Prob
Represents a vector with entries of type dai::Real.
Definition: prob.h:766
dai::EMAlg::LOG_Z_TOL_KEY
static const std::string LOG_Z_TOL_KEY
Key for setting likelihood termination condition.
Definition: emalg.h:360
dai::EMAlg::MAX_ITERS_KEY
static const std::string MAX_ITERS_KEY
Key for setting maximum iterations.
Definition: emalg.h:356
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::ParameterEstimation::estimate
virtual Prob estimate(const Prob &p)
Estimate the factor using the provided expectations.
Definition: emalg.h:77
dai::EMAlg::_msteps
std::vector< MaximizationStep > _msteps
The maximization steps to take.
Definition: emalg.h:340
dai::MaximizationStep::_params
std::vector< SharedParameters > _params
Vector of parameter estimation tasks of which this maximization step consists.
Definition: emalg.h:271
dai::SharedParameters::getFactorOrientations
const FactorOrientations & getFactorOrientations() const
Return a reference to the vector of factor orientations.
Definition: emalg.h:258
dai::CondProbEstimation::clone
virtual ParameterEstimation * clone() const
Virtual copy constructor.
Definition: emalg.h:136
dai::ParameterEstimation::registerMethod
static void registerMethod(const std::string &method, const ParamEstFactory &f)
Register a subclass so that it can be used with construct().
Definition: emalg.h:70
dai::ParameterEstimation::_registry
static std::map< std::string, ParamEstFactory > * _registry
A static registry containing all methods registered so far.
Definition: emalg.h:94
dai::EMAlg::_log_z_tol
Real _log_z_tol
Convergence tolerance.
Definition: emalg.h:352
dai::EMAlg::MAX_ITERS_DEFAULT
static const size_t MAX_ITERS_DEFAULT
Default maximum iterations.
Definition: emalg.h:358
dai::EMAlg::_max_iters
size_t _max_iters
Maximum number of iterations.
Definition: emalg.h:349
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::SharedParameters::FactorOrientations
std::map< FactorIndex, std::vector< Var > > FactorOrientations
Convenience label for a grouping of factor orientations.
Definition: emalg.h:176
dai::ParameterEstimation::probSize
virtual size_t probSize() const =0
Returns the size of the Prob that should be passed to estimate and parameters.
dai::CondProbEstimation::~CondProbEstimation
virtual ~CondProbEstimation()
Virtual destructor.
Definition: emalg.h:139
dai::SharedParameters::_varsets
std::map< FactorIndex, VarSet > _varsets
Maps factor indices to the corresponding VarSets.
Definition: emalg.h:180
dai::CondProbEstimation::parametersToFactor
virtual Prob parametersToFactor(const Prob &p)
Convert a set of estimated parameters to a factor.
Definition: emalg.cpp:58
dai::ParameterEstimation
Base class for parameter estimation methods.
Definition: emalg.h:50
dai::EMAlg::LOG_Z_TOL_DEFAULT
static const Real LOG_Z_TOL_DEFAULT
Default likelihood tolerance.
Definition: emalg.h:362
dai::EMAlg
EMAlg performs Expectation Maximization to learn factor parameters.
Definition: emalg.h:331
dai::EMAlg::EMAlg
EMAlg(const Evidence &evidence, InfAlg &estep, std::vector< MaximizationStep > &msteps, const PropertySet &termconditions)
Construct an EMAlg from several objects.
Definition: emalg.h:370
dai::EMAlg::logZ
Real logZ() const
Return the last calculated log likelihood.
Definition: emalg.h:400
dai::Evidence
Stores a data set consisting of multiple samples, where each sample is the observed joint state of so...
Definition: evidence.h:30
dai::ParameterEstimation::construct
static ParameterEstimation * construct(const std::string &method, const PropertySet &p)
General factory method that constructs the desired ParameterEstimation subclass.
Definition: emalg.cpp:26
dai::SharedParameters::_expectations
Prob * _expectations
The accumulated expectations.
Definition: emalg.h:190
dai::SharedParameters
Represents a single factor or set of factors whose parameters should be estimated.
Definition: emalg.h:171
dai::SharedParameters::~SharedParameters
~SharedParameters()
Destructor.
Definition: emalg.h:225
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::SharedParameters::calculatePermutation
static Permute calculatePermutation(const std::vector< Var > &varOrder, VarSet &outVS)
Calculates the permutation that permutes the canonical ordering into the desired ordering.
Definition: emalg.cpp:84
dai::EMAlg::s_end
const_s_iterator s_end() const
Returns constant iterator that points beyond the last maximization step.
Definition: emalg.h:433
dai::EMAlg::s_end
s_iterator s_end()
Returns iterator that points beyond the last maximization step.
Definition: emalg.h:431
dai::EMAlg::Iterations
size_t Iterations() const
Returns number of iterations done so far.
Definition: emalg.h:403
dai::EMAlg::const_s_iterator
std::vector< MaximizationStep >::const_iterator const_s_iterator
Constant iterator over the maximization steps.
Definition: emalg.h:424
dai::EMAlg::_evidence
const Evidence & _evidence
All the data samples used during learning.
Definition: emalg.h:334
dai::EMAlg::_lastLogZ
std::vector< Real > _lastLogZ
History of likelihoods.
Definition: emalg.h:346
dai::SharedParameters::_perms
std::map< FactorIndex, Permute > _perms
Maps factor indices to the corresponding Permute objects that permute the canonical ordering into the...
Definition: emalg.h:182
dai::CondProbEstimation::_initial_stats
Prob _initial_stats
Initial pseudocounts.
Definition: emalg.h:109
dai::EMAlg::run
void run()
Iterate until termination conditions are satisfied.
Definition: emalg.cpp:317
dai::ParameterEstimation::parameters
virtual Prob parameters(const Prob &p)=0
Return parameters for the estimated factor, in a format specific to the parameter estimation...
dai::MaximizationStep::MaximizationStep
MaximizationStep()
Default constructor.
Definition: emalg.h:275
dai::ParameterEstimation::loadDefaultRegistry
static void loadDefaultRegistry()
Registers default ParameterEstimation subclasses (currently, only CondProbEstimation).
Definition: emalg.cpp:20
dai::MaximizationStep::maximize
void maximize(FactorGraph &fg)
Using all of the currently added expectations, make new factors with maximized parameters and set the...
Definition: emalg.cpp:215
dai::EMAlg::s_iterator
std::vector< MaximizationStep >::iterator s_iterator
Iterator over the maximization steps.
Definition: emalg.h:422
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::SharedParameters::_ownEstimation
bool _ownEstimation
Indicates whether *this gets ownership of _estimation.
Definition: emalg.h:188
dai::TProb::size
size_t size() const
Returns length of the vector (i.e., the number of entries)
Definition: prob.h:311
dai::InfAlg
InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI...
Definition: daialg.h:35
dai::CondProbEstimation::parameters
virtual Prob parameters(const Prob &p)
Returns an estimate of the conditional probability distribution.
Definition: emalg.cpp:65
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::EMAlg::eStep
const InfAlg & eStep() const
Get the E-step method used.
Definition: emalg.h:406
dai::SharedParameters::clear
void clear()
Reset the current expectations.
Definition: emalg.h:261
dai::EMAlg::s_begin
const_s_iterator s_begin() const
Returns constant iterator that points to the first maximization step.
Definition: emalg.h:429
dai::EMAlg::s_begin
s_iterator s_begin()
Returns iterator that points to the first maximization step.
Definition: emalg.h:427
dai::ParameterEstimation::~ParameterEstimation
virtual ~ParameterEstimation()
Virtual destructor for deleting pointers to derived classes.
Definition: emalg.h:56
dai::MaximizationStep::begin
iterator begin()
Returns iterator that points to the first parameter estimation task.
Definition: emalg.h:302
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::CondProbEstimation::factory
static ParameterEstimation * factory(const PropertySet &p)
Virtual constructor, using a PropertySet.
Definition: emalg.cpp:39
dai::Permute
Tool for calculating permutations of linear indices of multi-dimensional arrays.
Definition: index.h:137
dai::MaximizationStep
A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into...
Definition: emalg.h:268
dai::CondProbEstimation::CondProbEstimation
CondProbEstimation(size_t target_dimension, const Prob &pseudocounts)
Constructor.
Definition: emalg.cpp:48
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai::EMAlg::setTermConditions
void setTermConditions(const PropertySet &p)
Change the conditions for termination.
Definition: emalg.cpp:244
dai::SharedParameters::FactorIndex
size_t FactorIndex
Convenience label for an index of a factor in a FactorGraph.
Definition: emalg.h:174
dai::CondProbEstimation
Estimates the parameters of a conditional probability table, using pseudocounts.
Definition: emalg.h:104
factor.h
Defines TFactor<> and Factor classes which represent factors in probability distributions.
dai::SharedParameters::currentExpectations
const Prob & currentExpectations() const
Return the current accumulated expectations.
Definition: emalg.h:241
dai::EMAlg::_iters
size_t _iters
Number of iterations done.
Definition: emalg.h:343
dai::EMAlg::iterate
Real iterate()
Iterate once over all maximization steps.
Definition: emalg.cpp:307
dai::MaximizationStep::MaximizationStep
MaximizationStep(std::vector< SharedParameters > &maximizations)
Construct MaximizationStep from a vector of parameter estimation tasks.
Definition: emalg.h:278
dai::MaximizationStep::end
iterator end()
Returns iterator that points beyond the last parameter estimation task.
Definition: emalg.h:306
dai::SharedParameters::SharedParameters
SharedParameters(const SharedParameters &sp)
Copy constructor.
Definition: emalg.h:217
dai::EMAlg::hasSatisfiedTermConditions
bool hasSatisfiedTermConditions() const
Determine if the termination conditions have been met.
Definition: emalg.cpp:252
dai::ParameterEstimation::clone
virtual ParameterEstimation * clone() const =0
Virtual copy constructor.
dai::SharedParameters::setPermsAndVarSetsFromVarOrders
void setPermsAndVarSetsFromVarOrders()
Initializes _varsets and _perms from _varorders and checks whether their state spaces correspond with...
Definition: emalg.cpp:90
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_32.png0000644000175000017500000000036212552200222015647 0ustar jorismjorism‰PNG  IHDRñl¸0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïaIDATxíÄ G[<þÿÛbÚ¦˜Ü„dÇÝ Oø7"%Ëb­Ž™À¯ÆJ øÚGrøÔ­u÷CsmÄL±>j€·VÞCE Z°;Bë+mÒ€ôŽ¾îØæ´ô•Uˆ ”IEND®B`‚libDAI-0.3.2/doc/html/form_60.png0000644000175000017500000000050312552200231015645 0ustar jorismjorism‰PNG  IHDR6jn|Ä0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï²IDATxí]„ „‡[´÷¿­Ì.H÷a“;v¾@'þ<ýôhƮު2ÁåD·îLÎ)”*¥ˆÕ=0,R–ý­;3Z­:' ÂÕ1° å4WtÆX5c ì?`NJ_6ÆB•2o;Ž^Çö©«—;ÐcD{a5ž&‚Æebúö³;9˜k¶±°'_¢nÏIž{kí‰-TâðDda®ì·ç[‘Øz4€}ÿ+_‘Í‚eU:IEND®B`‚libDAI-0.3.2/doc/html/evidence_8h.html0000644000175000017500000001042112552201363016745 0ustar jorismjorism libDAI: include/dai/evidence.h File Reference
Classes | Namespaces
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.

Classes

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

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

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

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_117.png0000644000175000017500000000051312552200245015736 0ustar jorismjorism‰PNG  IHDR”¹0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïºIDATxí] Ã0 ƒ?ç¯kBØýo;ÛK²´ìa°gS•bKV/ð7Š„d€Ž /%J¸¢)‚ñàŠS7Æ>††Š×AÔqɦ©C£¤7‘ÐÅ[]TlÛÙí;_ÕÌäÓù’6¿;çÊbï°ß·8€~ázÆŸÁÉÕÙ²ûGµžžàlÉ'—•¶Üc>ôÜâžgYËÏÖÝ'áb°Fõâ¹iF›\mŸqYóIÆÛÛ;·Òšý€ïxÙkûf.jIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1Region-members.html0000644000175000017500000004227712552201367021625 0ustar jorismjorism libDAI: Member List
dai::Region Member List

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

_cdai::Regionprivate
back()dai::SmallSet< Var >inline
back() constdai::SmallSet< Var >inline
begin()dai::SmallSet< Var >inline
begin() constdai::SmallSet< Var >inline
c() const dai::Regioninline
c()dai::Regioninline
const_iterator typedefdai::SmallSet< Var >
const_reverse_iterator typedefdai::SmallSet< Var >
contains(const Var &t) constdai::SmallSet< Var >inline
elements()dai::SmallSet< Var >inline
elements() constdai::SmallSet< Var >inline
empty() constdai::SmallSet< Var >inline
end()dai::SmallSet< Var >inline
end() constdai::SmallSet< Var >inline
erase(const Var &t)dai::SmallSet< Var >inline
front()dai::SmallSet< Var >inline
front() constdai::SmallSet< Var >inline
insert(const Var &t)dai::SmallSet< Var >inline
intersects(const SmallSet &x) constdai::SmallSet< Var >inline
iterator typedefdai::SmallSet< Var >
nrStates() const dai::VarSetinline
operator&(const SmallSet &x) constdai::SmallSet< Var >inline
operator&=(const SmallSet &x)dai::SmallSet< Var >inline
operator/(const SmallSet &x) constdai::SmallSet< Var >inline
operator/=(const SmallSet &x)dai::SmallSet< Var >inline
operator/=(const Var &t)dai::SmallSet< Var >inline
SmallSet< Var >::operator<<(const SmallSet &x) constdai::SmallSet< Var >inline
operator>>(const SmallSet &x) constdai::SmallSet< Var >inline
operator|(const SmallSet &x) constdai::SmallSet< Var >inline
operator|=(const SmallSet &x)dai::SmallSet< Var >inline
operator|=(const Var &t)dai::SmallSet< Var >inline
rbegin()dai::SmallSet< Var >inline
rbegin() constdai::SmallSet< Var >inline
Region()dai::Regioninline
Region(const VarSet &x, Real c)dai::Regioninline
rend()dai::SmallSet< Var >inline
rend() constdai::SmallSet< Var >inline
reverse_iterator typedefdai::SmallSet< Var >
size() constdai::SmallSet< Var >inline
SmallSet()dai::SmallSet< Var >inline
SmallSet(const Var &t)dai::SmallSet< Var >inline
SmallSet(const Var &t1, const Var &t2)dai::SmallSet< Var >inline
SmallSet(TIterator begin, TIterator end, size_t sizeHint)dai::SmallSet< Var >inline
toString() const dai::VarSetinline
VarSet()dai::VarSetinline
VarSet(const SmallSet< Var > &x)dai::VarSetinline
VarSet(const Var &v)dai::VarSetinline
VarSet(const Var &v1, const Var &v2)dai::VarSetinline
VarSet(VarIterator begin, VarIterator end, size_t sizeHint=0)dai::VarSetinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/nav_g.png0000644000175000017500000000013712552201363015501 0ustar jorismjorism‰PNG  IHDRô1&IDATxíÝ1 ÁOHf„á_ ->~¸åM iËMèÀƒS½ü‚<IEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1BP__dual_1_1messages.html0000644000175000017500000002077412552201364023021 0ustar jorismjorism libDAI: dai::BP_dual::messages Struct Reference
Public Attributes | List of all members
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>

Public Attributes

_edges_t< Prob > n
 Unnormalized variable->factor messages. More...
 
_edges_t< Real > Zn
 Normalizers of variable->factor messages. More...
 
_edges_t< Prob > m
 Unnormalized Factor->variable messages. More...
 
_edges_t< Real > Zm
 Normalizers of factor->variable messages. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_63.png0000644000175000017500000000105112552200231015647 0ustar jorismjorism‰PNG  IHDR‡ ZœÃ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï˜IDATxíݲ« …?ZÞÿmO¤b«¶ÎœË!ή$f±²È¾øs€[>$€ÿïihõó2à–y÷²µ¹70!´I_¼OaJmRc¾ÓçwñY_{vºß5ðSÒ€ ÊâàÃCÌö­´¯š#WÌ+ŽN »­¸ÿÇSáŸ}÷q„#æK(ã̈ùG^„ûWЮC®°äRÉŠ©Xmƒ–OËm}ÎB4ɼ{Á1ÌÀ¶âãQ6+®båG7ŽŠ\÷îáL6IûÕv8˜Óë £óÙö+`[]Rñv_ì¢H†©ì fõžUÍ…‰é©òZPl\­Æhy-|O§ö1 ;<ÜŠ£ßúâ'ý{ÊÁ‘N†‚Ñ°¹­vµ4)f/ñæói1!ËñDõpÀ¶œÏ&›F§Â—p/Œ ƒÝ±ºK;†^Ê9,¾èÚYKÛ§Åxâ8*”þ@§ZOûöv_V“± ðá›,¤R;Oâw1ÓŽ×<¼˜ž{_š~µƒØŸÌìÝ°8õV¦_<þòßà¦ÇJè?—s ¬[ëDµIEND®B`‚libDAI-0.3.2/doc/html/regiongraph_8h_source.html0000644000175000017500000017343012552201363021062 0ustar jorismjorism libDAI: include/dai/regiongraph.h Source File
regiongraph.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_regiongraph_h
14 #define __defined_libdai_regiongraph_h
15 
16 
17 #include <iostream>
18 #include <dai/bipgraph.h>
19 #include <dai/factorgraph.h>
20 #include <dai/weightedgraph.h>
21 
22 
23 namespace dai {
24 
25 
27 class Region : public VarSet {
28  private:
30  Real _c;
31 
32  public:
34  Region() : VarSet(), _c(1.0) {}
35 
37  Region( const VarSet& x, Real c ) : VarSet(x), _c(c) {}
38 
40  const Real& c() const { return _c; }
41 
43  Real& c() { return _c; }
44 };
45 
46 
48 class FRegion : public Factor {
49  private:
51  Real _c;
52 
53  public:
55  FRegion() : Factor(), _c(1.0) {}
56 
58  FRegion( const Factor& x, Real c ) : Factor(x), _c(c) {}
59 
61  const Real& c() const { return _c; }
62 
64  Real& c() { return _c; }
65 };
66 
67 
69 
91 class RegionGraph : public FactorGraph {
92  protected:
94  BipartiteGraph _G;
95 
97  std::vector<FRegion> _ORs;
98 
100  std::vector<Region> _IRs;
101 
103  std::vector<size_t> _fac2OR;
104 
105 
106  public:
108 
109  RegionGraph() : FactorGraph(), _G(), _ORs(), _IRs(), _fac2OR() {}
111 
113 
115  RegionGraph( const FactorGraph& fg, const std::vector<VarSet>& ors, const std::vector<Region>& irs, const std::vector<std::pair<size_t,size_t> >& edges ) : FactorGraph(), _G(), _ORs(), _IRs(), _fac2OR() {
116  construct( fg, ors, irs, edges );
117 
118  // Check counting numbers
119 #ifdef DAI_DEBUG
120  checkCountingNumbers();
121 #endif
122  }
123 
125 
136  RegionGraph( const FactorGraph& fg, const std::vector<VarSet>& cl ) : FactorGraph(), _G(), _ORs(), _IRs(), _fac2OR() {
137  constructCVM( fg, cl );
138 
139  // Check counting numbers
140 #ifdef DAI_DEBUG
141  checkCountingNumbers();
142 #endif
143  }
144 
146  virtual RegionGraph* clone() const { return new RegionGraph(*this); }
148 
150 
151  size_t nrORs() const { return _ORs.size(); }
154  size_t nrIRs() const { return _IRs.size(); }
155 
157  const FRegion& OR( size_t alpha ) const {
158  DAI_DEBASSERT( alpha < nrORs() );
159  return _ORs[alpha];
160  }
162  FRegion& OR( size_t alpha ) {
163  DAI_DEBASSERT( alpha < nrORs() );
164  return _ORs[alpha];
165  }
166 
168  const Region& IR( size_t beta ) const {
169  DAI_DEBASSERT( beta < nrIRs() );
170  return _IRs[beta];
171  }
173  Region& IR( size_t beta ) {
174  DAI_DEBASSERT( beta < nrIRs() );
175  return _IRs[beta];
176  }
177 
179  size_t fac2OR( size_t I ) const {
180  DAI_DEBASSERT( I < nrFactors() );
181  DAI_DEBASSERT( I < _fac2OR.size() );
182  return _fac2OR[I];
183  }
184 
186  const Neighbors& nbOR( size_t alpha ) const { return _G.nb1(alpha); }
187 
189  const Neighbors& nbIR( size_t beta ) const { return _G.nb2(beta); }
190 
192 
196  const BipartiteGraph& DAG() const { return _G; }
198 
200 
201 
207  bool checkCountingNumbers() const;
209 
211 
212  virtual void setFactor( size_t I, const Factor& newFactor, bool backup = false ) {
214  FactorGraph::setFactor( I, newFactor, backup );
215  recomputeOR( I );
216  }
217 
219  virtual void setFactors( const std::map<size_t, Factor>& facs, bool backup = false ) {
220  FactorGraph::setFactors( facs, backup );
221  VarSet ns;
222  for( std::map<size_t, Factor>::const_iterator fac = facs.begin(); fac != facs.end(); fac++ )
223  ns |= fac->second.vars();
224  recomputeORs( ns );
225  }
227 
229 
230 
233  virtual void ReadFromFile( const char* /*filename*/ ) {
234  DAI_THROW(NOT_IMPLEMENTED);
235  }
236 
238 
240  virtual void WriteToFile( const char* /*filename*/, size_t /*precision*/=15 ) const {
241  DAI_THROW(NOT_IMPLEMENTED);
242  }
243 
245  friend std::ostream& operator<< ( std::ostream& os, const RegionGraph& rg );
246 
248  std::string toString() const {
249  std::stringstream ss;
250  ss << *this;
251  return ss.str();
252  }
253 
255 
257  virtual void printDot( std::ostream& /*os*/ ) const {
258  DAI_THROW(NOT_IMPLEMENTED);
259  }
261 
262  protected:
264  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 );
265 
267  void constructCVM( const FactorGraph& fg, const std::vector<VarSet>& cl, size_t verbose=0 );
268 
270 
272  void recomputeORs();
273 
275 
277  void recomputeORs( const VarSet& vs );
278 
280 
282  void recomputeOR( size_t I );
283 
285 
291  void calcCVMCountingNumbers();
292 
293 };
294 
295 
296 } // end of namespace dai
297 
298 
299 #endif
dai::RegionGraph
A RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions...
Definition: regiongraph.h:91
dai::Neighbors
std::vector< Neighbor > Neighbors
Describes the set of neighbors of some node in a graph.
Definition: graph.h:92
dai::RegionGraph::_fac2OR
std::vector< size_t > _fac2OR
Stores for each factor index the index of the outer region it belongs to.
Definition: regiongraph.h:103
dai::RegionGraph::nbIR
const Neighbors & nbIR(size_t beta) const
Returns constant reference to the neighbors of inner region beta.
Definition: regiongraph.h:189
dai::Region
A Region is a set of variables with a counting number.
Definition: regiongraph.h:27
dai::Region::c
const Real & c() const
Returns constant reference to counting number.
Definition: regiongraph.h:40
dai::RegionGraph::IR
const Region & IR(size_t beta) const
Returns constant reference to inner region beta.
Definition: regiongraph.h:168
dai::RegionGraph::ReadFromFile
virtual void ReadFromFile(const char *)
Reads a region graph from a file.
Definition: regiongraph.h:233
dai::RegionGraph::operator<<
friend std::ostream & operator<<(std::ostream &os, const RegionGraph &rg)
Writes a region graph to an output stream.
Definition: regiongraph.cpp:218
dai::BipartiteGraph::nb1
const Neighbor & nb1(size_t i1, size_t _i2) const
Returns constant reference to the _i2 'th neighbor of node i1 of type 1.
Definition: bipgraph.h:87
weightedgraph.h
Defines some utility functions for (weighted) undirected graphs, trees and rooted trees...
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::RegionGraph::IR
Region & IR(size_t beta)
Returns reference to inner region beta.
Definition: regiongraph.h:173
dai::RegionGraph::_ORs
std::vector< FRegion > _ORs
The outer regions (corresponding to nodes of type 1)
Definition: regiongraph.h:97
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::RegionGraph::clone
virtual RegionGraph * clone() const
Clone *this (virtual copy constructor)
Definition: regiongraph.h:146
dai::RegionGraph::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)
Constructs a region graph from a factor graph, a vector of outer regions, a vector of inner regions a...
Definition: regiongraph.h:115
dai::RegionGraph::DAG
const BipartiteGraph & DAG() const
Returns DAG structure of the region graph.
Definition: regiongraph.h:196
dai::BipartiteGraph
Represents the neighborhood structure of nodes in an undirected, bipartite graph. ...
Definition: bipgraph.h:45
dai::RegionGraph::fac2OR
size_t fac2OR(size_t I) const
Returns the index of the outer region to which the I 'th factor corresponds.
Definition: regiongraph.h:179
dai::FRegion::FRegion
FRegion(const Factor &x, Real c)
Constructs from a factor and a counting number.
Definition: regiongraph.h:58
dai::RegionGraph::constructCVM
void constructCVM(const FactorGraph &fg, const std::vector< VarSet > &cl, size_t verbose=0)
Helper function for constructors (CVM style)
Definition: regiongraph.cpp:56
dai::FRegion::FRegion
FRegion()
Default constructor.
Definition: regiongraph.h:55
dai::Region::c
Real & c()
Returns reference to counting number.
Definition: regiongraph.h:43
dai::RegionGraph::nrORs
size_t nrORs() const
Returns number of outer regions.
Definition: regiongraph.h:152
dai::RegionGraph::RegionGraph
RegionGraph()
Default constructor.
Definition: regiongraph.h:110
dai::RegionGraph::RegionGraph
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) ...
Definition: regiongraph.h:136
dai::BipartiteGraph::nb2
const Neighbor & nb2(size_t i2, size_t _i1) const
Returns constant reference to the _i1 'th neighbor of node i2 of type 2.
Definition: bipgraph.h:100
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::Region::Region
Region()
Default constructor.
Definition: regiongraph.h:34
dai::RegionGraph::_IRs
std::vector< Region > _IRs
The inner regions (corresponding to nodes of type 2)
Definition: regiongraph.h:100
dai::RegionGraph::toString
std::string toString() const
Formats a region graph as a string.
Definition: regiongraph.h:248
dai::RegionGraph::setFactors
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 ...
Definition: regiongraph.h:219
dai::RegionGraph::recomputeOR
void recomputeOR(size_t I)
Recompute all outer regions involving factor I.
Definition: regiongraph.cpp:205
dai::Region::_c
Real _c
Counting number.
Definition: regiongraph.h:30
dai::RegionGraph::setFactor
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...
Definition: regiongraph.h:213
dai::FRegion::_c
Real _c
Counting number.
Definition: regiongraph.h:51
dai::RegionGraph::nrIRs
size_t nrIRs() const
Returns number of inner regions.
Definition: regiongraph.h:154
dai::RegionGraph::OR
const FRegion & OR(size_t alpha) const
Returns constant reference to outer region alpha.
Definition: regiongraph.h:157
dai::Region::Region
Region(const VarSet &x, Real c)
Construct from a set of variables and a counting number.
Definition: regiongraph.h:37
dai::RegionGraph::OR
FRegion & OR(size_t alpha)
Returns reference to outer region alpha.
Definition: regiongraph.h:162
dai::RegionGraph::calcCVMCountingNumbers
void calcCVMCountingNumbers()
Calculates counting numbers of inner regions based upon counting numbers of outer regions...
Definition: regiongraph.cpp:126
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::FactorGraph::setFactors
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 ...
Definition: factorgraph.h:261
dai::FRegion
An FRegion is a factor with a counting number.
Definition: regiongraph.h:48
dai::FRegion::c
Real & c()
Returns reference to counting number.
Definition: regiongraph.h:64
bipgraph.h
Defines the BipartiteGraph class, which represents a bipartite graph.
dai::FactorGraph::setFactor
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...
Definition: factorgraph.h:253
dai::FactorGraph::nrFactors
size_t nrFactors() const
Returns number of factors.
Definition: factorgraph.h:136
dai::RegionGraph::_G
BipartiteGraph _G
Stores the neighborhood structure.
Definition: regiongraph.h:94
dai::RegionGraph::WriteToFile
virtual void WriteToFile(const char *, size_t=15) const
Writes a region graph to a file.
Definition: regiongraph.h:240
dai::RegionGraph::recomputeORs
void recomputeORs()
Recompute all outer regions.
Definition: regiongraph.cpp:185
dai::RegionGraph::nbOR
const Neighbors & nbOR(size_t alpha) const
Returns constant reference to the neighbors of outer region alpha.
Definition: regiongraph.h:186
dai::RegionGraph::construct
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.
Definition: regiongraph.cpp:23
dai::RegionGraph::printDot
virtual void printDot(std::ostream &) const
Writes a region graph to a GraphViz .dot file.
Definition: regiongraph.h:257
dai::RegionGraph::checkCountingNumbers
bool checkCountingNumbers() const
Check whether the counting numbers are valid.
Definition: regiongraph.cpp:163
dai::FRegion::c
const Real & c() const
Returns constant reference to counting number.
Definition: regiongraph.h:61
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/graph_8h_source.html0000644000175000017500000016505612552201363017663 0ustar jorismjorism libDAI: include/dai/graph.h Source File
graph.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_graph_h
14 #define __defined_libdai_graph_h
15 
16 
17 #include <ostream>
18 #include <vector>
19 #include <algorithm>
20 #include <dai/util.h>
21 #include <dai/exceptions.h>
22 #include <dai/smallset.h>
23 
24 
25 namespace dai {
26 
27 
29 
73 struct Neighbor {
75  size_t iter;
77  size_t node;
79  size_t dual;
80 
82  Neighbor() {}
84  Neighbor( size_t iter, size_t node, size_t dual ) : iter(iter), node(node), dual(dual) {}
85 
87  operator size_t () const { return node; }
88 };
89 
90 
92 typedef std::vector<Neighbor> Neighbors;
93 
94 
96 
100 typedef std::pair<size_t,size_t> Edge;
101 
102 
104 
114 class GraphAL {
115  private:
117  std::vector<Neighbors> _nb;
118 
119  public:
121 
122  GraphAL() : _nb() {}
124 
126  GraphAL( size_t nr ) : _nb( nr ) {}
127 
129 
135  template<typename EdgeInputIterator>
136  GraphAL( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true ) : _nb() {
137  construct( nr, begin, end, check );
138  }
140 
142 
143  const Neighbor & nb( size_t n1, size_t _n2 ) const {
145  DAI_DEBASSERT( n1 < _nb.size() );
146  DAI_DEBASSERT( _n2 < _nb[n1].size() );
147  return _nb[n1][_n2];
148  }
150  Neighbor & nb( size_t n1, size_t _n2 ) {
151  DAI_DEBASSERT( n1 < _nb.size() );
152  DAI_DEBASSERT( _n2 < _nb[n1].size() );
153  return _nb[n1][_n2];
154  }
155 
157  const Neighbors & nb( size_t n ) const {
158  DAI_DEBASSERT( n < _nb.size() );
159  return _nb[n];
160  }
162  Neighbors & nb( size_t n ) {
163  DAI_DEBASSERT( n < _nb.size() );
164  return _nb[n];
165  }
167 
169 
170 
177  template<typename EdgeInputIterator>
178  void construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true );
179 
181  size_t addNode() { _nb.push_back( Neighbors() ); return _nb.size() - 1; }
182 
184 
190  template <typename NodeInputIterator>
191  size_t addNode( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint = 0 ) {
192  Neighbors nbsnew;
193  nbsnew.reserve( sizeHint );
194  size_t iter = 0;
195  for( NodeInputIterator it = begin; it != end; ++it ) {
196  DAI_ASSERT( *it < nrNodes() );
197  Neighbor nb1new( iter, *it, nb(*it).size() );
198  Neighbor nb2new( nb(*it).size(), nrNodes(), iter++ );
199  nbsnew.push_back( nb1new );
200  nb( *it ).push_back( nb2new );
201  }
202  _nb.push_back( nbsnew );
203  return _nb.size() - 1;
204  }
205 
207 
209  GraphAL& addEdge( size_t n1, size_t n2, bool check = true );
211 
213 
214  void eraseNode( size_t n );
216 
218  void eraseEdge( size_t n1, size_t n2 );
220 
222 
223  size_t nrNodes() const { return _nb.size(); }
225 
227  size_t nrEdges() const {
228  size_t sum = 0;
229  for( size_t i = 0; i < nrNodes(); i++ )
230  sum += nb(i).size();
231  return sum / 2;
232  }
233 
235 
237  bool hasEdge( size_t n1, size_t n2 ) const {
238  if( nb(n1).size() < nb(n2).size() ) {
239  for( size_t _n2 = 0; _n2 < nb(n1).size(); _n2++ )
240  if( nb( n1, _n2 ) == n2 )
241  return true;
242  } else {
243  for( size_t _n1 = 0; _n1 < nb(n2).size(); _n1++ )
244  if( nb( n2, _n1 ) == n1 )
245  return true;
246  }
247  return false;
248  }
249 
251 
254  size_t findNb( size_t n1, size_t n2 ) {
255  for( size_t _n2 = 0; _n2 < nb(n1).size(); _n2++ )
256  if( nb( n1, _n2 ) == n2 )
257  return _n2;
258  DAI_THROW(OBJECT_NOT_FOUND);
259  return nb(n1).size();
260  }
261 
263  SmallSet<size_t> nbSet( size_t n ) const;
264 
266  bool isConnected() const;
267 
269  bool isTree() const;
270 
272  void checkConsistency() const;
273 
275 
279  bool operator==( const GraphAL& x ) const {
280  if( nrNodes() != x.nrNodes() )
281  return false;
282  for( size_t n1 = 0; n1 < nrNodes(); n1++ ) {
283  if( nb(n1).size() != x.nb(n1).size() )
284  return false;
285  bforeach( const Neighbor &n2, nb(n1) )
286  if( !x.hasEdge( n1, n2 ) )
287  return false;
288  bforeach( const Neighbor &n2, x.nb(n1) )
289  if( !hasEdge( n1, n2 ) )
290  return false;
291  }
292  return true;
293  }
295 
297 
298  void printDot( std::ostream& os ) const;
300 
302  friend std::ostream& operator<<( std::ostream& os, const GraphAL& g ) {
303  g.printDot( os );
304  return os;
305  }
306 
308  std::string toString() const {
309  std::stringstream ss;
310  ss << *this;
311  return ss.str();
312  }
314 };
315 
316 
317 template<typename EdgeInputIterator>
318 void GraphAL::construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check ) {
319  _nb.clear();
320  _nb.resize( nr );
321 
322  for( EdgeInputIterator e = begin; e != end; e++ )
323  addEdge( e->first, e->second, check );
324 }
325 
326 
328 GraphAL createGraphFull( size_t N );
330 GraphAL createGraphGrid( size_t N1, size_t N2, bool periodic );
332 GraphAL createGraphGrid3D( size_t N1, size_t N2, size_t N3, bool periodic );
334 GraphAL createGraphLoop( size_t N );
336 GraphAL createGraphTree( size_t N );
338 
344 GraphAL createGraphRegular( size_t N, size_t d );
345 
346 
347 } // end of namespace dai
348 
349 
350 #endif
dai::GraphAL::checkConsistency
void checkConsistency() const
Asserts internal consistency.
Definition: graph.cpp:218
dai::Neighbors
std::vector< Neighbor > Neighbors
Describes the set of neighbors of some node in a graph.
Definition: graph.h:92
dai::GraphAL::eraseEdge
void eraseEdge(size_t n1, size_t n2)
Removes edge between node n1 and node n2.
Definition: graph.cpp:63
dai::GraphAL::printDot
void printDot(std::ostream &os) const
Writes a GraphAL to an output stream in GraphViz .dot syntax.
Definition: graph.cpp:205
dai::createGraphFull
GraphAL createGraphFull(size_t N)
Creates a fully-connected graph with N nodes.
Definition: graph.cpp:233
dai::GraphAL::findNb
size_t findNb(size_t n1, size_t n2)
Returns the index of a given node n2 amongst the neighbors of n1.
Definition: graph.h:254
dai::GraphAL::nrNodes
size_t nrNodes() const
Returns number of nodes.
Definition: graph.h:224
dai::GraphAL::operator<<
friend std::ostream & operator<<(std::ostream &os, const GraphAL &g)
Writes a GraphAL to an output stream.
Definition: graph.h:302
dai::GraphAL::addEdge
GraphAL & addEdge(size_t n1, size_t n2, bool check=true)
Adds an edge between node n1 and node n2.
Definition: graph.cpp:18
dai::GraphAL::isConnected
bool isConnected() const
Returns true if the graph is connected.
Definition: graph.cpp:104
dai::createGraphGrid
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.
Definition: graph.cpp:242
dai::Neighbor::iter
size_t iter
Corresponds to the index of this Neighbor entry in the vector of neighbors.
Definition: graph.h:75
dai::GraphAL::toString
std::string toString() const
Formats a GraphAL as a string.
Definition: graph.h:308
dai::Neighbor::dual
size_t dual
Contains the "dual" index (i.e., the index of this node in the Neighbors vector of the neighboring no...
Definition: graph.h:79
dai::createGraphRegular
GraphAL createGraphRegular(size_t N, size_t d)
Creates a random regular graph of N nodes with uniform connectivity d.
Definition: graph.cpp:291
dai::GraphAL::eraseNode
void eraseNode(size_t n)
Removes node n and all incident edges; indices of other nodes are changed accordingly.
Definition: graph.cpp:40
dai::GraphAL::construct
void construct(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
(Re)constructs GraphAL from a range of edges.
Definition: graph.h:318
dai::GraphAL::nb
Neighbor & nb(size_t n1, size_t _n2)
Returns reference to the _n2 'th neighbor of node n1.
Definition: graph.h:150
dai::createGraphGrid3D
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...
Definition: graph.cpp:257
dai::GraphAL::addNode
size_t addNode()
Adds a node without neighbors and returns the index of the added node.
Definition: graph.h:181
bforeach
#define bforeach
An alias to the BOOST_FOREACH macro from the boost::bforeach library.
Definition: util.h:48
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::createGraphTree
GraphAL createGraphTree(size_t N)
Creates a random tree-structured graph of N nodes.
Definition: graph.cpp:281
dai::GraphAL::nb
Neighbors & nb(size_t n)
Returns reference to all neighbors of node n.
Definition: graph.h:162
util.h
Defines general utility functions and adds an abstraction layer for platform-dependent functionality...
dai::Neighbor::Neighbor
Neighbor(size_t iter, size_t node, size_t dual)
Constructor that allows setting the values of the member variables.
Definition: graph.h:84
dai::GraphAL::hasEdge
bool hasEdge(size_t n1, size_t n2) const
Returns true if the graph contains an edge between nodes n1 and n2.
Definition: graph.h:237
dai::Neighbor::node
size_t node
Contains the absolute index of the neighboring node.
Definition: graph.h:77
dai::GraphAL::_nb
std::vector< Neighbors > _nb
Contains for each node a vector of its neighbors.
Definition: graph.h:117
dai::GraphAL::addNode
size_t addNode(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
Adds a node, with neighbors specified by a range of nodes.
Definition: graph.h:191
smallset.h
Defines the SmallSet<> class, which represents a set (optimized for a small number of elements)...
dai::createGraphLoop
GraphAL createGraphLoop(size_t N)
Creates a graph consisting of a single loop of N nodes.
Definition: graph.cpp:273
dai::Neighbor
Describes the neighbor relationship of two nodes in a graph.
Definition: graph.h:73
dai::GraphAL::nb
const Neighbors & nb(size_t n) const
Returns constant reference to all neighbors of node n.
Definition: graph.h:157
dai::GraphAL::operator==
bool operator==(const GraphAL &x) const
Comparison operator which returns true if two graphs are identical.
Definition: graph.h:279
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::GraphAL::nb
const Neighbor & nb(size_t n1, size_t _n2) const
Returns constant reference to the _n2 'th neighbor of node n1.
Definition: graph.h:144
dai::GraphAL::nrEdges
size_t nrEdges() const
Calculates the number of edges, time complexity: O(nrNodes())
Definition: graph.h:227
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::GraphAL
Represents the neighborhood structure of nodes in an undirected graph.
Definition: graph.h:114
dai::Edge
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...
Definition: graph.h:100
dai::GraphAL::GraphAL
GraphAL(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
Constructs GraphAL from a range of edges.
Definition: graph.h:136
dai::GraphAL::nbSet
SmallSet< size_t > nbSet(size_t n) const
Returns neighbors of node n as a SmallSet.
Definition: graph.cpp:96
dai::Neighbor::Neighbor
Neighbor()
Default constructor.
Definition: graph.h:82
dai::GraphAL::GraphAL
GraphAL(size_t nr)
Constructs GraphAL with nr nodes and no edges.
Definition: graph.h:126
dai::GraphAL::isTree
bool isTree() const
Returns true if the graph is a tree, i.e., if it is singly connected and connected.
Definition: graph.cpp:160
dai::GraphAL::GraphAL
GraphAL()
Default constructor (creates an empty graph).
Definition: graph.h:123
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_62.png0000644000175000017500000000130412552200231015647 0ustar jorismjorism‰PNG  IHDR~ú (0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï3IDATxí]Û’¬ l$ à,þÿßnqŒºŽžª³UûB™)FÛtn´¯ð·ÌØ®.ìò™€‡V €íÕé\ò«¶¿b¢‰Ë­wœq‡Ü9€gæwô.ó'†ÚsÓÿëÚóè{i–xdJñc¨Ù:ã3™ôI¿!‡t@Ú5À##}ÊPðåPZߟN÷¢%~Ódh ²'Þ¢Ù7NÖ£&}uð³{yÆüRGêSXwݳÃ!ëâj‘£Ò[d§oQÙ–ÀÙ¦!é‹@2²ÐIbPê“3à¿è¸'¹fo:y;¤ȫ⛑XG.2ôÈY¦R&xmL’ȳTÐä!ŤRä \Œ½Ñ; Ã:-á±kÏb.n¶»Câ÷ÃêH-”A®§S±{i̽€¾Î™ùcâï‘2F:t¦ØW'xA^Ÿn¿EƒÔ3g\È]âJk­õl!/ÉB9³:¡ž³ÿ(¦{)> ìåSŒ&y¥”F/ó5}žÏR|lϧs6jµßô 3cÍå†þFŠûù˜‡©ÏÓ0ì_ \™÷Cv¦‘… 1ü ŽSUê­¯^f„€¹Vzº-ÚÆzŸ¤x©Éâ”Þ‹<³•ž´©„D•;Kqÿ¶-Ÿÿ=?+Y¼6à,ÅýL7úÅ€§Öè)^.Š R`ÓQŠ½ ¬~ Z)°ÿ~]Úõ³÷mSÓ»ƒÿbV2y®T R|D_Ê/ü]û®ß 3¶ú‰IEND®B`‚libDAI-0.3.2/doc/html/form_23.png0000644000175000017500000000056112552200220015646 0ustar jorismjorism‰PNG  IHDR0gp ƒ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïàIDATxí]íŽÄ (¬Xµ¾ÿÛh?¶»ir¹÷ÏHZ‘aäà_l1píÏ3€Ûæ n¶-ðd¶ÀÍÚ žì‘Eô`ò º® p• ÿñ#Ù¤q(ô :õà(Hj T‹Çõ¯5ioÂUÝ/)â"ÙIsRB6/ÃZõƥzç8›"Pº:Õ—ç` DÓL K1sJîP\Z€xx¼oå 8TJ‰Ùh0r@™Äc¥÷wØôTä]š6˜£ó=ý”sôñ1lé*74²§QúA4”•T…€IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1SharedParameters-members.html0000644000175000017500000002151012552201370023611 0ustar jorismjorism libDAI: Member List
dai::SharedParameters Member List

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

_estimationdai::SharedParametersprivate
_expectationsdai::SharedParametersprivate
_ownEstimationdai::SharedParametersprivate
_permsdai::SharedParametersprivate
_varordersdai::SharedParametersprivate
_varsetsdai::SharedParametersprivate
calculatePermutation(const std::vector< Var > &varOrder, VarSet &outVS)dai::SharedParametersprivatestatic
clear()dai::SharedParametersinline
collectExpectations(InfAlg &alg)dai::SharedParameters
currentExpectations() const dai::SharedParametersinline
FactorIndex typedefdai::SharedParameters
FactorOrientations typedefdai::SharedParameters
getFactorOrientations() const dai::SharedParametersinline
getPEst() const (defined in dai::SharedParameters)dai::SharedParametersinline
setParameters(FactorGraph &fg)dai::SharedParameters
setPermsAndVarSetsFromVarOrders()dai::SharedParametersprivate
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::SharedParametersinline
~SharedParameters()dai::SharedParametersinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_131.png0000644000175000017500000000124212552200251015727 0ustar jorismjorism‰PNG  IHDRz£ :á0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIDATxí]Ù’œ0 lIøÀþÿ¿Ý– Xf6IUž’r¡)Æ´Ô:Ú~€ÿÒb+Àøk&#\¬*¾,nž–©ÀoÛœà“åÁ½ìç[zëa™?¿´éÇLe|•:^'øn‹ÿüµýܤÙ°>(Å ç÷õ¤ÖÔpf½e&þÀÃuh(1Õ®!<à—Ìrý"–¢¡·¿ãHM²‘²I^&edÝ£´´ànô‘¢(FYS£.Q·s —®€Ë£ºMlñdløsq`Ì¥} µÑi —€ëCêB7·z8œè]ô…ZÚæFè€~ävLŽÉEùÖkÍŒRÃèÜWë©ww«Ë!wÿ?X.Ô3xN¹½¢5K$> oµr¯ø¦¯z¨ÔÿË÷Z5ËõÏ!‡žgÊ”ô‹:ÜÏû#/ÐÁO›5…“—3`Ël5ë¬f@XßQ/˜˜|ž‘²YgS¬é@K ÙŽÔ˜5Ød‰-µÚ6ÿã:˜ËìÇ>)uSÊ⮶ÅÄd}ª\fNzJ.¯DxS—fÞ]ú07Gš(íVRŸŠ®ÞŽ×)GÍSòQ·kèÓõ{?™=hGÂóÅfO«i}®.´Šn÷;(‘-°Ú%×aÀÝx¤Xo¿Ã<¼£íL6Õ½¯Z™"eq»á›Ó½®Ðºcà­I8ï«áð¡MÖg ÿ®}*e 3˜³ÎIEND®B`‚libDAI-0.3.2/doc/html/functions_func_k.html0000644000175000017500000001140512552201370020122 0ustar jorismjorism libDAI: Class Members - Functions
 

- k -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/dot_inline_dotgraph_3.png0000644000175000017500000001171512552201364020652 0ustar jorismjorism‰PNG  IHDRQÿYpbKGDÿÿÿ ½§“‚IDATxœå]yPSWûÎD$Dˤ(Š,Š¸+mmÇ­*NmE«Õi;YBPY1€¢ˆ¢¥Õ‚Á…ÎNu¨Ëˆ," › b‘(H€€A1% Ü„¬÷÷ÇõËG!ËIr¿™ßóÜóœ÷=ÏÍMÎ9ïyϹX†1ÿÏ€³°?¡P¨R©,ìt ¬Ìj½¥¥¥ººšÅbápïo®­­íÈÈ ÃX,V¡PL:uùòåkÖ¬±²2oKFkŽg[ dgg³X¬ øúúzxxhc <~ü¸²²ÒÖÖ6((hÎœ9¨7f*Ö`Ž‹‹{öìZÖÆÍÇïèè@Ź\¬R©P´© =„P(äóùžžžz™=êìì …K–,Yµj•¦••Õ–-[ŠŠŠüüüLoáX˜~Û®]»ø«³dÉ&“ÙÞÞ¾hÑ"½d•Jerë4…qXkkëâÅ‹A˜L&súôé...zÉX,Ç›Ü: @áÙ–Éd„éååÕÓÓð··7‹ÅšÖ4Í@A³‹‹Ë›7oÜÝÝõ2OŸ>]TTäàà––bY©TšÜ:M0ýëÁd2Ïœ9cº˘…Qù>Ïž=»««K*•šnj4._¾‚®MèÌ%#""Ž9‚Š)%%%nnn(Úü/Ðz`òóóÓÓÓQ1ÕØ؃Š)@sŽQ\\|ðàA©TjŠ‘¿þúkß¾}2™ ­Vššanmm¥P(wïÞ5¢n{{{XXØõë×ÑmÒx˜%fpûöí²²²Å‹ÿý÷$I7Y.——–––••‘Éäèèh;;;ÔÛ3fÑŒàåË—7oÞ …ÖÖÖÞÞÞÎÎÎ$ÉÑÑQ$ òx<:.‘H°Xìúõë7lØ`±ð5«!—Ë êëë—.]* 'L˜@"‘H$RuuõŽ; § syœ;w®³³sÌE‚âãã-ӀѰP¬·££c|$H$Êåò¡¡!Ë´A KhV*•Ú&!AAAW¯^µ@FÚ—.]ª±hÞ¼y---Žò[BsEEÅ—_~©­tãÆ¥¥¥h†–ÐÌáp¦M›¦­ÔÏϯ¨¨ÈÍPÃ욥R©wsskoo7wKÔ0»æºººÏ?ÿ\7‡B¡äææš»%j˜]sUU•î'Æâ–Ù5C4uêT½4KvZæÕ, çý–ì´Ì«¹¦¦fåÊ•€ä7Þ¿߬íA`^Í=Z±b yóæÍÅÅÅfmój–H$àóag™NËŒšy<ÞG}dPËtZfÔ¬{È©–é´Ì¨ùéÓ§Ÿ~ú©¡µ,Ði™Q³B¡\Ç tZæÒüöíÛ™3gWWÝiAÔÕÕÅ`08ŽD"A«mæ »=xð`íÚµ†ÖêëëËÏÏokkëíí­®®ž]7p ÒС«··7“ÉÔKCY³L&ÓÙ5+ðx<È@eÍOž>~ûöí·oß6Âj±¡ÊÊJð±ñàñøׯ_'&&Z[[§¥¥ 7cÆ $¥ÊÆƆÏçCÄf³…B!ƒ™?~\\œ½½}ddä²eË ¼qŸ4"&&ÙiŽ=Z]]=úŠR©ìîî~ñâEeeåo¿ý–ÝÖÖ6þ‰D åƒ=Û‘‘‘ÆUd¨àãããççwèСððð¹s皨S¡P”——WVV"™„j¿8¹éoß¾‹Åx<~åÊ•_ýµÞ%[‹u÷î]õ*‡æÏY,Ÿ?¾»»{ÅŠIII¶¶¶:,Â0üäÉ“øøøááa#’G‚ ³gÏBäëë{êÔ)kkkd¥RYQQA£Ñ&Nœ¥ãÛäîîÞÕÕõ¯Áµk×öìÙÓÚÚ UC ’““:„$ì•J•‘‘ýöí[Cë"‰b©©©r¹\'%%…Ãá ÿK³L&£ÑhÆÊÕèêê |ýú5x@°wïÞššSüÒét …Âãñ4–666^¹rùû¿š•Jåž={ ZøÑ‘HÒÝÝ B‹Ål6Ût¿ýýýWB”J¥:5ñ¿š?nÄ¢‘6 €<äQQQã·F .—K¥R•Jåø"µæ÷ý3‹ÅÂãñ i€°³³£ÑhzÖkjj–-[žI d2yÛ¶m·oßÖXÔ×ׇÁüç7ŒF£ ê¾… …"%%eÆ ÇŽ¼ëáááºs9ÃÂÂå(((ˆŠŠ !S©Ôñ‹‹‹ËËËaõç,•Jõf%ô÷÷ â󟣈´•²ÙlWWW;8Éžœ´xzz²X¬1§L™‚LTpˆEÀýG(îÛ·pqH¥R鈦s!°··¿xñ"àö•J¥c‡Á`Èn‡ÞÞ^*•ZSSãïÕÒÒ¢# >>ºc %;;]¿yyy[·nýåË—óçÏǨ5“ÉdWW×[·n¡å˜Çã]½z5((H7mñâÅ|>ÿéÓ§hùe2™ ¾¾¾ã‹º»»ß?È£{°„„¤3\.7 @o‡@©TîÝ»—N§›î—ÉdkLñ}ræØyUzzzZZšÆ± êêê¨T*Hú …"11ñêÕ«F;…a¸  `ÿþýÚrZš››/]º„ü­a.ùèÑ£ààà’’C½vuuEFFfdd( CëÂ0\PP`\¢XSSShhèŸþ©ƒ“’’¢Þ›£9NÃðÍ›7«««]\\vìØ¡{<Ìçó‹ŠŠ çÏŸeÊ!~r¹üÊ•+/^¼˜3gÎwß}§;÷Ùt×ÔÔäååª;Š®þ‘Ö³ŽÍfççç#½('‰$ÉÊÊ IØBNÿ"‰¾¾¾.\øý÷ß^” &“YXXˆ|2ÖÖÖŽŽŽ$ ‹ÅB488ˆŒ@œœ6mÚ´páB½ÖZZZ>|öþƒž¢W¯^µ¶¶öööŽŸ<Ô××Óh4ƒ ‚@©Tö÷÷wtt´··¿{÷NG0D<8:–€òþ*d¨„®M!bccG_A9g}Ó¦Mvvv–º‘˜˜Èb±Æ_7ã666çΣÑh–?åƒÁ455‰D777 eæ¾Ù===F§v¹\¨-ºh‰ó= Fxx¸)óCqêÔ©††m¥–8ÐÛÛÛßß?!!Á¾0Lmm-@ðññÑʰؽ·Ì ‚ …¢û™²œf†³³³sssÍg_©TR©Tõú£6Xô=e!!!===æ¢%''S(”?þX7ÍÒïfKHH¨ªªª¯¯GÝòõë×=<<>ûì3ýTó=iÚ`Ž!ZUUÕÉ“'É@3Œö­¥¥%""ü›£†a>Ÿïïïoú+¯˜Lfhh¨Aïø`šaîéé 2eˆÖÑÑA¡P =oÈgËë@kkkVVÖè(Zww7‹ÅBr¢T*’æêêêîî>&ß½³³355533ÓÐÚ¬ƒÁÔÖÖÍš5‹Á`àp¸™3gzzz"RÕ a]]]ȪàÌ™3øá2™l´`Ì×Ìb±222¬¬¬üýýAö8tttäååq¹ÜÁÁÁÜÜ\㲤?˜f™LvêÔ),»ÿþÉ“'TW*•fffr8œ¤¤$Àþ£?LÁ»wï¨Tª‰yY===þþþmmm†Vüš! 4hAK$ •J54uÐÒšU*•JE1`$  êð,ý}.))‘H$Û¶mCÑæ³gÏÁ7`ZzŽQPPðí·ß‚0A˜>>>ÏŸ?ÿð,ªY$‘H$E¼ááa.—Ëår-/X°ü(&‹jær¹zÃ`0J¥òï¿ÿž7o¸åY³fuww’-ª™@ €¼ªÍf¯[·i¦ ŽŒŒ€O,ªyúôéoÞ¼ÑKsuuE~`1 `t¡©© ð= kÆáp&Làñx€|ÀŸ%¹\AÞ¢ýË®%ñúõë#GŽ k3++Ë —‹[º¯ruuuvvÖ½Ý Ðét÷Å_PÝ[ˆÄÄÄÂÂBÓíÔÕÕEDDºBòÁæU.\€ (66Ö¸íI*•êÒ¥K‡28kÇô›m4ž?N¥R¯_¿nPZŒJ¥*..s,8>|œ¤¼¼¼°°ÐÎÎî›o¾Y¶l™¶ýk2™¬©©éÞ½{ïÞ½[·nÝÖ­[~;ô‡×Œ`hh¨¼¼œN§‹Åb‡Åb ‡Á`0*•ÊÚÚzáÂ…6lprr2Ñ×ÿŠæñÉd*•Ê§Âþïj6þeþßÕò:IEND®B`‚libDAI-0.3.2/doc/html/functions_f.html0000644000175000017500000002171312552201370017105 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- f -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_53.png0000644000175000017500000000546212552200227015665 0ustar jorismjorism‰PNG  IHDRÓŸ½<´0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï ¡IDATxíëv£<³„9sÿw»[`#h1/IÆ{¾e/jÅq#•Ô‡ª¿ÿcˆà}h"ÀûpÊß&€¿‚S~ßüœò»?àw6?è!ãŒ<'üÆÉÏÎa“[ùMÞ$_Ø¡1Cg€ôIfLÝîr~ÛÆ )´Kí…ߎa6t‘ö$EÞ0“OÖàõÙB£|Š£Ë«³±–àŸ—ÚòoåÀ áwò%ç¿Œ&ÿì&€ÖúþätK(Óì`ó^¶•c—õ‚)H±ÙñûÙûpÜ汓9œ4Ð#ÄÉÉR‹”îãÖÏåa”oC’ûK#<ø'“³P¢÷V(ü[w˜âÙ‰¼ß´ó¶êkù,¯Ï?;ãz9©ôàl™rRöˆÑ§èÑí®ŸŸ¡“ΠI® –ä1Ã?§Ä%YìMÛ%éÕ˜/"kê 9©Z5ûjCYr¨?À ¸T€SH‚þ_ë?À_Âå§iš~óüï÷øm@ “¯„ ~7Ii›æbþ}œ´Ã&_ íù­xＯŸÎµ½´+€¥ÉWBGþ±Yïp¿4ùJèP›m%ó{!¿:iò•ÐA·=[K«õÐ%aò•Ð±ÿ§5ÿ[­4hü¥ÉWB{þì>ÍÂj¥OÝ•kü¥ÉWB{þAú¯“¨Ç ¿¯ßß5ó `oò•Ðžß5ÖÍnI|ãÌ Úû¥CïMøzö¡²þáy¶\ €ßÅÇÞ‡?À-Ø&ióïß)³Y„ þ˜º~úèÛúü‹‹k )–  DÚó±¼Aö}ø¯¨!€‚Y^žOPš|%´çÏî´ê?Ù†•+lò÷eÖÀëó-ÿ²CKvçÔ©º}úœ%€=šœB…¿ø·+™~'ÐÏé×*üUÿÍ×\zÀ uÿÃ{ÌiŠ‚^ÿ2Tò7Ù|å“òï“êoë$9—Nß0BàÏ›· ü­—=1-^ÂÚ gçyÎÝP ´¾Wš§ó'[Î ›Ç Í7¸’¹]¨¢Õäü>þð>|øÎq1¦ šCÛ sV-ß½Äöüvå³…Õ=¾”ZQhoÔµ"-îÅW÷ü>ÊgS=ý_DZ( ­uUýÏéLÛw_ç_vµòik›¬Ø5ÿ ÛÒEþoòwWþ»yûUýÝ’ÿÿÌ¿ä_çù|¹% uþ¥ÅFÍ¢´µ¡Z¹þ£üÁ{?‡ê&é¥ÿu~#+ü¨óOùÓþÉüÙÞ·Êõc7wJ(´¾—ÁÕøç¼Ìæ&õ²‡"/ßsèݪþ¼~€÷¡Æ1^ÆšúYÝ;]ã»—XÁS×?£WúcUõ÷‹8 Òâ69ðgó R}¥/*¿~öÅ5UýÏî¼8T~Óÿf¨ú/C¿þMWù¿ÇŸ³[ã·óêòû¯ð/ù¯ð+½•Nø þP­¿ü/Í»v¢÷s¸8À ~#Ü~Tù[ï\´2¾ûpDïV´!´¾_S|6³|67©—=ÀOcw«þ¼~€{0îe€×G]ë^c%¿{F÷ïðÑõ«P죪1š×±.ø“µíz©®µ}}ü#f¡½RÓ?«êŸh.;”ì,Ì2pŽI¸g­|¿¯ú“ûÄå—ìSîÅ'ŽXv8@õ¿|wÝÿú¹zø”»6@Eä+ü}•?5ó¼Ö_ÞIWüJ¯óWóä¿aíýâÕ ’•!8A½þZÿyÕ°¶ÂÞ§ Ä®iz-Cjê&CÈ58åϽg»ÅåŒC}þÚ®ë´ùo»V©mÂë¢CýóFÞhb¥º?ƒÿ¼~€{0n•J€5óÞEünz«ïþx³5Iü DaòûÐNš ~ÛÛÇ/ÉYÕ\¿$î\¡K“^ž¿,l×;Íaõ €sä}Î °4yàå©ð§ñYI_×hp™dÿÝüùoXÇË)¾Y€3TøÇç•NðÞÏáâêüM†kp@…?÷ží°«ñ_Üß·]'U(a› p@l»6TêŸ0y±lß*ðCøøÀûðá¸ã6«ØÁ¾Ø8°{v‘’ß=G®¶Å:ÿÑõÊ”Çh:evãÞV þÖÛ~ W¶x|ƒ¿(`D{í"ã%jú/¢—;Õ·XEV¸çÓò­úÃÚN*°G}‹ÀM>øþQÌå¯oñ|ÿEÉ_7ÍÞs‹_þ{ðW·ØŸÓÓÜÍÿøÌ}‹‡YY€kñÎPáo„ß/]Wßb®iÃìžÉ,­ pD…?w|±ÓÅfí:eþm”ˆŒW×¾”­˜ÿR’á“Å•-~ ÿx>ü÷`œ8EE¹v¡ÿ3j+»/ך<¬% “¯„ þ´èîòÍÙssÝéØŸ‰,ðòÔøêŸß «œ#ï£àð‹±tâçXÞ̆ pÀ·ùE€«ô¿ÎS“ûx3çÿù‰×õŸ¤L|—?s/78G0?Þÿ>ïh'ü ?¨0âЊD&_ üm×µ#ÎSê.à»øøÀûðḉŠCW¤s:ð?£&†ªüà“jÐ…ÉWBóô\ÛãG€ TõÿýŸ-.Tð‹ün¶ñRþ~‘?ÍÁ´W½ù‹ü¹^½à€_ä×þû«üöúþÆÍ8ÂúÙ+ÝS„ ~—fg–‹wFl@1z€#¼„”£¡‚?HTÒ“·MñoHóÇÞ‡?À=È°œbgòÀ˳ ü&6›8˜êò'þÔLG&_ íùMÂÌëùlTˆC›Y ›úÛtЭw’Ý]PÑI¦‡Øã¿Æváw³•üÔ] àˆ»þ#áå—4Ó^õ¦™Ô#ÞæoWÓi®ýOÞÕ3t—?W`Ël¶A ¼¢¸Ü]~/ý¼œÀ^ß¿›ÆQ¡)L¾ÚóÛyÇn¹xhÖRœ!{µÒþ…ÉWB¿sÛç©Nuø|üà}x7?À?ƒÿV•–KÆ¿IEND®B`‚libDAI-0.3.2/doc/html/regiongraph_8h.html0000644000175000017500000001425112552201363017475 0ustar jorismjorism libDAI: include/dai/regiongraph.h File Reference
Classes | Namespaces
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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region graphs.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/factor_8h.html0000644000175000017500000002365112552201363016452 0ustar jorismjorism libDAI: include/dai/factor.h File Reference
Classes | Namespaces | Typedefs | Functions
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.

Classes

class  dai::TFactor< T >
 Represents a (probability) factor. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Typedefs

typedef TFactor< Real > dai::Factor
 Represents a factor with values of type dai::Real. More...
 

Functions

Factor dai::createFactorIsing (const Var &x, Real h)
 Returns a binary unnormalized single-variable factor $ \exp(hx) $ where $ x = \pm 1 $. More...
 
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 $. More...
 
Factor dai::createFactorExpGauss (const VarSet &vs, Real beta)
 Returns a random factor on the variables vs with strength beta. More...
 
Factor dai::createFactorPotts (const Var &x1, const Var &x2, Real J)
 Returns a pairwise Potts factor $ \exp( J \delta_{x_1, x_2} ) $. More...
 
Factor dai::createFactorDelta (const Var &v, size_t state)
 Returns a Kronecker delta point mass. More...
 
Factor dai::createFactorDelta (const VarSet &vs, size_t state)
 Returns a Kronecker delta point mass. More...
 

Detailed Description

Defines TFactor<> and Factor classes which represent factors in probability distributions.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_96.png0000644000175000017500000000035112552200241015660 0ustar jorismjorism‰PNG  IHDRÚ­¿0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïXIDATxí[À Ç7V«÷¿mcFI¯@v8À¿CåØEÝ«Tß—ž÷É#®â¾ Fŵئv¦Á=åΛ›¿Ù$Û ©å&ÿ&ÍkÊ®è{ 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::Neighborinline
Neighbor(size_t iter, size_t node, size_t dual)dai::Neighborinline
nodedai::Neighbor
operator size_t() const dai::Neighborinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/dag_8h_source.html0000644000175000017500000016757212552201363017322 0ustar jorismjorism libDAI: include/dai/dag.h Source File
dag.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_dag_h
14 #define __defined_libdai_dag_h
15 
16 
17 #include <ostream>
18 #include <vector>
19 #include <algorithm>
20 #include <dai/util.h>
21 #include <dai/exceptions.h>
22 #include <dai/smallset.h>
23 #include <dai/graph.h>
24 
25 
26 namespace dai {
27 
28 
30 
41 class DAG {
42  private:
44  std::vector<Neighbors> _pa;
45 
47  std::vector<Neighbors> _ch;
48 
49  public:
51 
52  DAG() : _pa(), _ch() {}
54 
56  DAG( size_t nr ) : _pa( nr ), _ch( nr ) {}
57 
59 
66  template<typename EdgeInputIterator>
67  DAG( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true ) : _pa(), _ch() {
68  construct( nr, begin, end, check );
69  }
71 
73 
74  const Neighbor& pa( size_t n, size_t _p ) const {
76  DAI_DEBASSERT( n < _pa.size() );
77  DAI_DEBASSERT( _p < _pa[n].size() );
78  return _pa[n][_p];
79  }
81  Neighbor& pa( size_t n, size_t _p ) {
82  DAI_DEBASSERT( n < _pa.size() );
83  DAI_DEBASSERT( _p < _pa[n].size() );
84  return _pa[n][_p];
85  }
86 
88  const Neighbors& pa( size_t n ) const {
89  DAI_DEBASSERT( n < _pa.size() );
90  return _pa[n];
91  }
93  Neighbors& pa( size_t n ) {
94  DAI_DEBASSERT( n < _pa.size() );
95  return _pa[n];
96  }
97 
99  const Neighbor& ch( size_t n, size_t _c ) const {
100  DAI_DEBASSERT( n < _ch.size() );
101  DAI_DEBASSERT( _c < _ch[n].size() );
102  return _ch[n][_c];
103  }
105  Neighbor& ch( size_t n, size_t _c ) {
106  DAI_DEBASSERT( n < _ch.size() );
107  DAI_DEBASSERT( _c < _ch[n].size() );
108  return _ch[n][_c];
109  }
110 
112  const Neighbors& ch( size_t n ) const {
113  DAI_DEBASSERT( n < _ch.size() );
114  return _ch[n];
115  }
117  Neighbors& ch( size_t n ) {
118  DAI_DEBASSERT( n < _ch.size() );
119  return _ch[n];
120  }
122 
124 
125 
132  template<typename EdgeInputIterator>
133  void construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true );
134 
136  size_t addNode() {
137  _pa.push_back( Neighbors() );
138  _ch.push_back( Neighbors() );
139  return _pa.size() - 1;
140  }
141 
143 
149  template <typename NodeInputIterator>
150  size_t addNode( NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0 ) {
151  Neighbors newparents;
152  newparents.reserve( sizeHint );
153  size_t iter = 0;
154  for( NodeInputIterator it = begin; it != end; ++it ) {
155  DAI_ASSERT( *it < nrNodes() );
156  Neighbor newparent( iter, *it, ch(*it).size() );
157  Neighbor newchild( ch(*it).size(), nrNodes(), iter++ );
158  newparents.push_back( newparent );
159  ch( *it ).push_back( newchild );
160  }
161  _pa.push_back( newparents );
162  _ch.push_back( Neighbors() );
163  return _pa.size() - 1;
164  }
165 
167 
169  DAG& addEdge( size_t n1, size_t n2, bool check=true );
171 
173 
174  void eraseNode( size_t n );
176 
178  void eraseEdge( size_t n1, size_t n2 );
180 
182 
183  size_t nrNodes() const {
185  DAI_DEBASSERT( _pa.size() == _ch.size() );
186  return _pa.size();
187  }
188 
190  size_t nrEdges() const {
191  size_t sum = 0;
192  for( size_t i = 0; i < _pa.size(); i++ )
193  sum += _pa[i].size();
194  return sum;
195  }
196 
198 
200  bool hasEdge( size_t n1, size_t n2 ) const {
201  if( ch(n1).size() < pa(n2).size() ) {
202  for( size_t _n2 = 0; _n2 < ch(n1).size(); _n2++ )
203  if( ch( n1, _n2 ) == n2 )
204  return true;
205  } else {
206  for( size_t _n1 = 0; _n1 < pa(n2).size(); _n1++ )
207  if( pa( n2, _n1 ) == n1 )
208  return true;
209  }
210  return false;
211  }
212 
214 
217  size_t findPa( size_t n, size_t p ) {
218  for( size_t _p = 0; _p < pa(n).size(); _p++ )
219  if( pa( n, _p ) == p )
220  return _p;
221  DAI_THROW(OBJECT_NOT_FOUND);
222  return pa(n).size();
223  }
224 
226 
229  size_t findCh( size_t n, size_t c ) {
230  for( size_t _c = 0; _c < ch(n).size(); _c++ )
231  if( ch( n, _c ) == c )
232  return _c;
233  DAI_THROW(OBJECT_NOT_FOUND);
234  return ch(n).size();
235  }
236 
238  SmallSet<size_t> paSet( size_t n ) const;
239 
241  SmallSet<size_t> chSet( size_t n ) const;
242 
244  std::set<size_t> ancestors( size_t n, bool inclusive ) const;
245 
247  std::set<size_t> descendants( size_t n, bool inclusive ) const;
248 
250  bool existsDirectedPath( size_t n1, size_t n2 ) const;
251 
253  bool isConnected() const;
254 
256  void checkConsistency() const;
257 
259 
263  bool operator==( const DAG& x ) const {
264  if( nrNodes() != x.nrNodes() )
265  return false;
266  for( size_t n1 = 0; n1 < nrNodes(); n1++ ) {
267  if( pa(n1).size() != x.pa(n1).size() )
268  return false;
269  bforeach( const Neighbor &n2, pa(n1) )
270  if( !x.hasEdge( n2, n1 ) )
271  return false;
272  bforeach( const Neighbor &n2, x.pa(n1) )
273  if( !hasEdge( n2, n1 ) )
274  return false;
275  }
276  return true;
277  }
279 
281 
282  void printDot( std::ostream& os ) const;
284 
286  friend std::ostream& operator<<( std::ostream& os, const DAG& g ) {
287  g.printDot( os );
288  return os;
289  }
290 
292  std::string toString() const {
293  std::stringstream ss;
294  ss << *this;
295  return ss.str();
296  }
298 };
299 
300 
301 template<typename EdgeInputIterator>
302 void DAG::construct( size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check ) {
303  _pa.clear();
304  _pa.resize( nr );
305  _ch.clear();
306  _ch.resize( nr );
307 
308  for( EdgeInputIterator e = begin; e != end; e++ )
309  addEdge( e->first, e->second, check );
310 }
311 
312 
313 } // end of namespace dai
314 
315 
316 #endif
dai::DAG
Represents the neighborhood structure of nodes in a directed cyclic graph.
Definition: dag.h:41
dai::Neighbors
std::vector< Neighbor > Neighbors
Describes the set of neighbors of some node in a graph.
Definition: graph.h:92
dai::DAG::isConnected
bool isConnected() const
Returns true if the DAG is connected.
Definition: dag.cpp:199
dai::DAG::hasEdge
bool hasEdge(size_t n1, size_t n2) const
Returns true if the DAG contains an edge from node n1 and n2.
Definition: dag.h:200
dai::DAG::eraseEdge
void eraseEdge(size_t n1, size_t n2)
Removes edge from node n1 to node n2.
Definition: dag.cpp:83
dai::DAG::pa
const Neighbors & pa(size_t n) const
Returns constant reference to all parents of node n.
Definition: dag.h:88
dai::DAG::chSet
SmallSet< size_t > chSet(size_t n) const
Returns children of node n as a SmallSet.
Definition: dag.cpp:124
dai::DAG::ancestors
std::set< size_t > ancestors(size_t n, bool inclusive) const
Returns the set of ancestors of node n, i.e., all nodes a such that there exists a directed path from...
Definition: dag.cpp:133
dai::DAG::pa
Neighbors & pa(size_t n)
Returns reference to all parents of node n.
Definition: dag.h:93
dai::DAG::addNode
size_t addNode(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)
Adds a node with parents specified by a range of nodes.
Definition: dag.h:150
dai::DAG::construct
void construct(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
(Re)constructs DAG from a range of edges.
Definition: dag.h:302
dai::DAG::ch
const Neighbors & ch(size_t n) const
Returns constant reference to all children of node n.
Definition: dag.h:112
dai::DAG::_pa
std::vector< Neighbors > _pa
Contains for each node a vector of its parent nodes.
Definition: dag.h:44
dai::DAG::DAG
DAG(size_t nr)
Constructs DAG with nr nodes and no edges.
Definition: dag.h:56
dai::DAG::findCh
size_t findCh(size_t n, size_t c)
Returns the index of a given node c amongst the children of n.
Definition: dag.h:229
dai::DAG::checkConsistency
void checkConsistency() const
Asserts internal consistency.
Definition: dag.cpp:254
dai::DAG::nrEdges
size_t nrEdges() const
Calculates the number of edges, time complexity: O(nrNodes())
Definition: dag.h:190
dai::DAG::paSet
SmallSet< size_t > paSet(size_t n) const
Returns parents of node n as a SmallSet.
Definition: dag.cpp:116
dai::DAG::addEdge
DAG & addEdge(size_t n1, size_t n2, bool check=true)
Adds an edge from node n1 and node n2.
Definition: dag.cpp:18
dai::DAG::pa
Neighbor & pa(size_t n, size_t _p)
Returns reference to the _p 'th parent of node n.
Definition: dag.h:81
dai::DAG::operator==
bool operator==(const DAG &x) const
Comparison operator which returns true if two DAGs are identical.
Definition: dag.h:263
dai::DAG::toString
std::string toString() const
Formats a DAG as a string.
Definition: dag.h:292
bforeach
#define bforeach
An alias to the BOOST_FOREACH macro from the boost::bforeach library.
Definition: util.h:48
dai::DAG::findPa
size_t findPa(size_t n, size_t p)
Returns the index of a given node p amongst the parents of n.
Definition: dag.h:217
dai::DAG::_ch
std::vector< Neighbors > _ch
Contains for each node a vector of its children nodes.
Definition: dag.h:47
dai::DAG::existsDirectedPath
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...
Definition: dag.cpp:180
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::DAG::ch
Neighbors & ch(size_t n)
Returns reference to all children of node n.
Definition: dag.h:117
util.h
Defines general utility functions and adds an abstraction layer for platform-dependent functionality...
dai::DAG::eraseNode
void eraseNode(size_t n)
Removes node n and all ingoing and outgoing edges; indices of other nodes are changed accordingly...
Definition: dag.cpp:43
graph.h
Defines the GraphAL class, which represents an undirected graph as an adjacency list.
smallset.h
Defines the SmallSet<> class, which represents a set (optimized for a small number of elements)...
dai::Neighbor
Describes the neighbor relationship of two nodes in a graph.
Definition: graph.h:73
dai::DAG::DAG
DAG()
Default constructor (creates an empty DAG).
Definition: dag.h:53
dai::DAG::addNode
size_t addNode()
Adds a node without parents and children and returns the index of the added node. ...
Definition: dag.h:136
dai::DAG::operator<<
friend std::ostream & operator<<(std::ostream &os, const DAG &g)
Writes a DAG to an output stream.
Definition: dag.h:286
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::DAG::printDot
void printDot(std::ostream &os) const
Writes a DAG to an output stream in GraphViz .dot syntax.
Definition: dag.cpp:242
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::DAG::ch
Neighbor & ch(size_t n, size_t _c)
Returns reference to the _c 'th child of node n.
Definition: dag.h:105
dai::DAG::ch
const Neighbor & ch(size_t n, size_t _c) const
Returns constant reference to the _c 'th child of node n.
Definition: dag.h:99
dai::DAG::nrNodes
size_t nrNodes() const
Returns number of nodes.
Definition: dag.h:184
dai::DAG::pa
const Neighbor & pa(size_t n, size_t _p) const
Returns constant reference to the _p 'th parent of node n.
Definition: dag.h:75
dai::DAG::descendants
std::set< size_t > descendants(size_t n, bool inclusive) const
Returns the set of descendants of node n, i.e., all nodes d such that there exists a directed path fr...
Definition: dag.cpp:157
dai::DAG::DAG
DAG(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)
Constructs DAG from a range of edges.
Definition: dag.h:67
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_z.html0000644000175000017500000001257312552201370017135 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- z -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/annotated.html0000644000175000017500000010722612552201370016551 0ustar jorismjorism libDAI: Class List
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 123]
 ▼NdaiNamespace for libDAI
 ▼CBBPImplements BBP (Back-Belief-Propagation) [EaG09]
 CPropertiesParameters for BBP
 CBBPCostFunctionPredefined cost functions that can be used with BBP
 ▼CBipartiteGraphRepresents the neighborhood structure of nodes in an undirected, bipartite graph
 ClevelTypeUsed internally by isTree()
 ▼CBPApproximate inference algorithm "(Loopy) Belief Propagation"
 CEdgePropType used for storing edge properties
 CPropertiesParameters for BP
 ▼CBP_dualCalculates both types of BP messages and their normalizers from an InfAlg
 C_edges_tConvenience label for storing edge properties
 CbeliefsGroups together the data structures for storing the two types of beliefs and their normalizers
 CmessagesGroups together the data structures for storing the two types of messages and their normalizers
 ▼CCBPClass for CBP (Conditioned Belief Propagation) [EaG09]
 CPropertiesParameters for CBP
 CClusterGraphA ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hyperedges
 ▼CCobwebGraphA CobwebGraph is a special type of region graph used by the GLC algorithm
 CConnectionThe information in connection between two regions
 CCondProbEstimationEstimates the parameters of a conditional probability table, using pseudocounts
 CDAGRepresents the neighborhood structure of nodes in a directed cyclic graph
 CDAIAlgCombines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)
 CDEdgeRepresents a directed edge
 CEMAlgEMAlg performs Expectation Maximization to learn factor parameters
 CEvidenceStores a data set consisting of multiple samples, where each sample is the observed joint state of some variables
 ▼CExactInfExact inference algorithm using brute force enumeration (mainly useful for testing purposes)
 CPropertiesParameters for ExactInf
 CExceptionError handling in libDAI is done by throwing an instance of the Exception class
 CFactorGraphRepresents a factor graph
 CFBPApproximate inference algorithm "Fractional Belief Propagation" [WiH03]
 Cfo_absFunction object that takes the absolute value
 Cfo_absdiffFunction object that returns the absolute difference of x and y
 Cfo_divides0Function object similar to std::divides(), but different in that dividing by zero results in zero
 Cfo_expFunction object that takes the exponent
 Cfo_HellingerFunction object useful for calculating the Hellinger distance
 Cfo_idFunction object that returns the value itself
 Cfo_invFunction object that takes the inverse
 Cfo_inv0Function object that takes the inverse, except that 1/0 is defined to be 0
 Cfo_KLFunction object useful for calculating the KL distance
 Cfo_logFunction object that takes the logarithm
 Cfo_log0Function object that takes the logarithm, except that log(0) is defined to be 0
 Cfo_maxFunction object that returns the maximum of two values
 Cfo_minFunction object that returns the minimum of two values
 Cfo_plog0pFunction object that returns p*log0(p)
 Cfo_powFunction object that returns x to the power y
 CFRegionAn FRegion is a factor with a counting number
 CGraphALRepresents the neighborhood structure of nodes in an undirected graph
 CGraphELRepresents an undirected graph, implemented as a std::set of undirected edges
 CgreedyVariableEliminationHelper object for dai::ClusterGraph::VarElim()
 ▼CHAKApproximate inference algorithm: implementation of single-loop ("Generalized Belief Propagation") and double-loop algorithms by Heskes, Albers and Kappen [HAK03]
 CPropertiesParameters for HAK
 Chash_mapHash_map is an alias for std::tr1::unordered_map
 CIndexForTool for looping over the states of several variables
 CInfAlgInfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI
 ▼CJTreeExact inference algorithm using junction tree
 CPropertiesParameters for JTree
 ▼CLCApproximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]
 CPropertiesParameters for LC
 CMaximizationStepA MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit
 ▼CMFApproximate inference algorithm "Mean Field"
 CPropertiesParameters for MF
 ▼CMRApproximate inference algorithm by Montanari and Rizzo [MoR05]
 CPropertiesParameters for MR
 CmultiforMultifor makes it easy to perform a dynamic number of nested for loops
 CNeighborDescribes the neighbor relationship of two nodes in a graph
 CParameterEstimationBase class for parameter estimation methods
 CPermuteTool for calculating permutations of linear indices of multi-dimensional arrays
 CPropertySetRepresents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue)
 CRegionA Region is a set of variables with a counting number
 CRegionGraphA RegionGraph combines a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region) with a FactorGraph
 CRootedTreeRepresents a rooted tree, implemented as a vector of directed edges
 CsequentialVariableEliminationHelper object for dai::ClusterGraph::VarElim()
 CSharedParametersRepresents a single factor or set of factors whose parameters should be estimated
 CSmallSetRepresents a set; the implementation is optimized for a small number of elements
 CStateMakes it easy to iterate over all possible joint states of variables within a VarSet
 CTFactorRepresents a (probability) factor
 CTProbRepresents a vector with entries of type T
 ▼CTreeEPApproximate inference algorithm "Tree Expectation Propagation" [MiQ04]
 CPropertiesParameters for TreeEP
 CTreeEPSubTreeStores the data structures needed to efficiently update the approximation of an off-tree factor
 CTRWBPApproximate inference algorithm "Tree-Reweighted Belief Propagation" [WJW03]
 CUEdgeRepresents an undirected edge
 CVarRepresents a discrete random variable
 CVarSetRepresents a set of variables
 CWeightedGraphRepresents an undirected weighted graph, with weights of type T, implemented as a std::map mapping undirected edges to weights
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__inv0-members.html0000644000175000017500000000562512552201365022312 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_c.html0000644000175000017500000001224412552201370020134 0ustar jorismjorism libDAI: Class Members - Variables
 

- c -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1BP__dual_1_1__edges__t.png0000644000175000017500000000122112552201364023063 0ustar jorismjorism‰PNG  IHDR·Plñ—PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2 IDATxíݲë F7åýßx7»&‚1¿Íæg˜ñ«‰\"Ò[DD¢ª:œ’[U5NÉ­ª§†»¼ìïåp§_z)CUuSÿ#÷©%îiƒ¿»|kùlzøÕgûe~þ™æšžñr[Tk³/Ý®’,´z±Ü6_¬ávn]¤LçJüšõ¾õâãÝ%÷y²Z±a¹'ÝýzÆK“'r{/ýá¹Ûû¶©g¼œ·¨Öf-»íVÜÉï{^®äw9á¥Ì:_™Z jÍèÜûg¼\©ƒªªã(¹UUã”ܪªqJnUÕ8 Ì-"2žþJ/€5(÷ë5&ø Üoì!ÁGåÎz©äˆSrÄ)¹â”ÜqJn€8%7@œ’ NÉ §äˆSrÄ)¹â”ÜDD0œ’ NÉ §wXž>7¸ö]ë­SS«Ù¹lt´Ëí‡Þ?sÀ}`Þr—ÂXÂ{Äý±žM›Läœgc;½5f÷¸'ŠJb[{eP›Y½Œ¹®kèwbãض枬ÏüöÀíG]£uç íˆ{^]«.÷‡¯Ÿ'›ÜÍG~Ï ð‡²wuüdŸ» Ç)î^ ÝItš„ºï&8ÜÝœj Éo{ÝçZa°m]#ÌGëÉîJøk=±â-îƒÿ²=£Î©ò¸ïË„ký‹<øVÉ §äˆÓ›[Dd<ý[NkA!ÅIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1MF.html0000644000175000017500000017227512552201367017256 0ustar jorismjorism libDAI: dai::MF Class Reference
Classes | Public Attributes | Private Member Functions | Private Attributes | List of all members
dai::MF Class Reference

Approximate inference algorithm "Mean Field". More...

#include <dai/mf.h>

Inheritance diagram for dai::MF:
dai::DAIAlg< GRM > dai::InfAlg

Classes

struct  Properties
 Parameters for MF. More...
 

Public Member Functions

Constructors/destructors
 MF ()
 Default constructor. More...
 
 MF (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
General InfAlg interface
virtual MF * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual MF * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &ns)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability. More...
 

Public Attributes

struct dai::MF::Properties props
 

Private Member Functions

void construct ()
 Helper function for constructors. More...
 
Factor calcNewBelief (size_t i)
 Calculates an updated belief of variable i. More...
 

Private Attributes

std::vector< Factor > _beliefs
 Current approximations of single variable marginals. More...
 
Real _maxdiff
 Maximum difference encountered so far. More...
 
size_t _iters
 Number of iterations needed. 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
fgFactor graph.
optsParameters
See also
Properties

Member Function Documentation

virtual MF* dai::MF::clone ( ) const
inlinevirtual

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

Implements dai::InfAlg.

virtual MF* dai::MF::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Implements dai::InfAlg.

virtual std::string dai::MF::name ( ) const
inlinevirtual

Returns the name of the algorithm.

Implements dai::InfAlg.

virtual Factor dai::MF::belief ( const Var &  v) const
inlinevirtual

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_IMPLEMENTEDif not implemented/supported.
BELIEF_NOT_AVAILABLEif 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_IMPLEMENTEDif 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_IMPLEMENTEDif 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
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual size_t dai::MF::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

virtual void dai::MF::setMaxIter ( size_t  )
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif 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.

The documentation for this class was generated from the following files:
  • include/dai/mf.h
  • src/mf.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_132.png0000644000175000017500000000116112552200251015730 0ustar jorismjorism‰PNG  IHDRjOÒh¬0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïàIDATxí]ÙŽä0,ß¹ÿÿß.‡MìVfFZí¾Œ„št'ª€r?À¯ô/øîrvýçÝ1·Ç¦8øk|Ù;Ä€ò-;6ŸÏGì1'Õly`úÄ'*fÂr'Ð:ãYÆz« “,)1øÂÏ9êÈ0v4 pÚ/iœŸ,5àGOyi±ð¼ö~ç­צ%Ià|Ï5Ü`o΄\°¾‰½ËPxŸr²fž%‰m3CZON5ú”’wŒ¨êPï[è›Õ¶5Îχ‚jl4 É+£Ù(À5ú¢Á‰tÊXlvÛ–ùLq=‘&H…:ø®6·b§ŽîAr.±LÞ)íéàѺ‹¯AÖF0¥"Ž5/rMñÜ*i|p?¡rÌõá9å¯ÂÑ~ã÷2û@P—÷Þ”:‡ó@„µ¹]H…Å«­©]|ØLì‰\%ਈ6µ%ƒô!Ô¾%ڽƗrŒôó”ìh}°§©`GÎ\OÑ ZÛL³ó"ZPBZÑËÜ·I÷Ľ/Í—F¤.Æõ’ë›°Ô4Ò¿ ð4y>4‰»Z·Z¼ #¶[­5Ò³»¤^멪ûþ‰¦,NÖõˆø®÷KW&aú5ÞüM˜K͸À¿ð?»; ଀ÓþIEND®B`‚libDAI-0.3.2/doc/html/functions_vars.html0000644000175000017500000005051112552201370017631 0ustar jorismjorism libDAI: Class Members - Variables
 

- _ -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/enum_8h_source.html0000644000175000017500000004636112552201363017523 0ustar jorismjorism libDAI: include/dai/enum.h Source File
enum.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_enum_h
14 #define __defined_libdai_enum_h
15 
16 
17 #include <cstring>
18 #include <iostream>
19 #include <dai/exceptions.h>
20 
21 
23 
35 #define DAI_ENUM(x,val0,...) class x {\
36  public:\
37  enum value {val0,__VA_ARGS__};\
38 \
39  x() : v(val0) {}\
40 \
41  x(value w) : v(w) {}\
42 \
43  x(char const *w) {\
44  static char const* labelstring = #val0 "," #__VA_ARGS__;\
45  size_t pos_begin = 0;\
46  size_t i = 0;\
47  for( size_t pos_end = 0; ; pos_end++ ) {\
48  if( (labelstring[pos_end] == ',') || (labelstring[pos_end] == '\0') ) {\
49  if( (strlen( w ) == pos_end - pos_begin) && (strncmp( labelstring + pos_begin, w, pos_end - pos_begin ) == 0) ) {\
50  v = (value)i;\
51  return;\
52  } else {\
53  i++;\
54  pos_begin = pos_end + 1;\
55  }\
56  }\
57  if( labelstring[pos_end] == '\0' )\
58  break;\
59  }\
60  DAI_THROWE(UNKNOWN_ENUM_VALUE,"'" + std::string(w) + "' is not in [" + std::string(labelstring) + "]");\
61  }\
62 \
63  operator value() const { return v; }\
64 \
65  operator size_t() const { return (size_t)v; }\
66 \
67  operator char const*() const {\
68  static char labelstring[] = #val0 "," #__VA_ARGS__;\
69  size_t pos_begin = 0;\
70  size_t i = 0;\
71  for( size_t pos_end = 0; ; pos_end++ )\
72  if( (labelstring[pos_end] == ',') || (labelstring[pos_end] == '\0') ) {\
73  if( (size_t)v == i ) {\
74  labelstring[pos_end] = '\0';\
75  return labelstring + pos_begin;\
76  } else {\
77  i++;\
78  pos_begin = pos_end + 1;\
79  }\
80  }\
81  }\
82 \
83  operator wchar_t const*() const {\
84  static wchar_t labelstring[] = #val0 L"," #__VA_ARGS__;\
85  size_t pos_begin = 0;\
86  size_t i = 0;\
87  for( size_t pos_end = 0; ; pos_end++ )\
88  if( (labelstring[pos_end] == L',') || (labelstring[pos_end] == L'\0') ) {\
89  if( (size_t)v == i ) {\
90  labelstring[pos_end] = L'\0';\
91  return labelstring + pos_begin;\
92  } else {\
93  i++;\
94  pos_begin = pos_end + 1;\
95  }\
96  }\
97  }\
98 \
99  friend std::istream& operator >> (std::istream& is, x& y) {\
100  std::string s;\
101  is >> s;\
102  y = x(s.c_str());\
103  return is;\
104  }\
105 \
106  friend std::wistream& operator >> (std::wistream& wis, x& y) {\
107  std::wstring s;\
108  wis >> s;\
109  y = x((const char *)s.c_str());\
110  return wis;\
111  }\
112 \
113  friend std::ostream& operator << (std::ostream& os, const x& y) {\
114  os << (const char *)y;\
115  return os;\
116  }\
117 \
118  friend std::wostream& operator << (std::wostream& wos, const x& y) {\
119  wos << (const wchar_t *)y;\
120  return wos;\
121  }\
122 \
123  protected:\
124  value v;\
125 };
126 
127 
128 #endif
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1MF_1_1Properties.html0000644000175000017500000003131412552201367022176 0ustar jorismjorism libDAI: dai::MF::Properties Struct Reference
Public Member Functions | Public Attributes | List of all members
dai::MF::Properties Struct Reference

Parameters for MF. More...

#include <dai/mf.h>

Public Member Functions

 DAI_ENUM (InitType, UNIFORM, RANDOM)
 Enumeration of possible message initializations. More...
 
 DAI_ENUM (UpdateType, NAIVE, HARDSPIN)
 Enumeration of possible update types. More...
 

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr) More...
 
size_t maxiter
 Maximum number of iterations. More...
 
Real tol
 Tolerance for convergence test. More...
 
Real damping
 Damping constant (0.0 means no damping, 1.0 is maximum damping) More...
 
InitType init
 How to initialize the messages/beliefs. More...
 
UpdateType updates
 How to update the messages/beliefs. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/cobwebgraph_8h_source.html0000644000175000017500000020632512552201363021040 0ustar jorismjorism libDAI: include/dai/cobwebgraph.h Source File
cobwebgraph.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2012, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_cobwebgraph_h
14 #define __defined_libdai_cobwebgraph_h
15 
16 
17 #include <iostream>
18 #include <dai/factorgraph.h>
19 #include <dai/weightedgraph.h>
20 #include <dai/smallset.h>
21 #include <dai/enum.h>
22 #include <algorithm>
23 #include <map>
24 #include <set>
25 
26 
27 namespace dai {
28 
29 
31 
34 class CobwebGraph : public FactorGraph {
35  public:
37  struct Connection {
39  size_t my;
41  size_t his;
43  size_t iter;
45  size_t dual;
47  Factor msg;
49  std::vector<size_t> varinds;
51 
53  Factor newmsg;
55  std::vector<size_t> fc;
57  std::vector<VarSet> subregions;
58  };
59 
67  DAI_ENUM(NeighborType,ALL,TOP,CLOSEST);
68 
69  protected:
71  std::vector<SmallSet<size_t> > _INRs;
73  std::vector<SmallSet<size_t> > _EXRs;
75  std::vector<SmallSet<size_t> > _Rfs;
77  std::vector<SmallSet<size_t> > _Rifs;
79  std::vector<SmallSet<size_t> > _Rxfs;
81  std::vector<std::vector<VarSet> > _outM;
83  std::vector<std::vector<Connection> > _M;
84 
86  std::vector<std::vector<size_t> > _var2CW;
87 
92  std::vector<std::map<VarSet, std::pair<int,std::vector<size_t> > > > _cn;
93 
95  bool isPartition;
96 
97  public:
99 
100  CobwebGraph() : FactorGraph(), _INRs(), _EXRs(),_Rfs(),_Rifs(),_Rxfs(), _M(), _var2CW(), _cn(), isPartition(true) {}
102 
104  CobwebGraph( const FactorGraph& fg ): FactorGraph(), _INRs(), _EXRs(),_Rfs(), _M(), _var2CW(), _cn(), isPartition(true) {
105  // Copy factor graph structure
106  FactorGraph::operator=( fg );
107  }
108 
110  virtual CobwebGraph* clone() const { return new CobwebGraph(*this); }
112 
114 
115  size_t nrCWs() const { return _INRs.size(); }
117 
119  const std::map<VarSet, std::pair<int,std::vector<size_t> > >& cn( size_t R ) const {
120  DAI_DEBASSERT( R < nrCWs() );
121  return _cn[R];
122  }
123 
125  std::map<VarSet, std::pair<int,std::vector<size_t> > >& cn( size_t R ) {
126  DAI_DEBASSERT( R < nrCWs() );
127  return _cn[R];
128  }
129 
131  const std::vector<VarSet>& outM( size_t R ) const {
132  DAI_DEBASSERT( R < _outM.size() );
133  return _outM[R];
134  }
135 
137  std::vector<VarSet>& outM( size_t R ) {
138  DAI_DEBASSERT( R < _outM.size() );
139  return _outM[R];
140  }
141 
143 
145  const VarSet& outM( size_t R, size_t j ) const {
146  DAI_DEBASSERT( R < _outM.size() );
147  DAI_DEBASSERT( j < _outM[R].size() );
148  return _outM[R][j];
149  }
150 
152 
154  VarSet& outM( size_t R, size_t j ) {
155  DAI_DEBASSERT( R < _outM.size() );
156  DAI_DEBASSERT( j < _outM[R].size() );
157  return _outM[R][j];
158  }
159 
161  const SmallSet<size_t>& Rfs( size_t R ) const {
162  DAI_DEBASSERT( R < _Rfs.size() );
163  return _Rfs[R];
164  }
165 
167  SmallSet<size_t>& Rfs( size_t R ) {
168  DAI_DEBASSERT( R < _Rfs.size() );
169  return _Rfs[R];
170  }
171 
173  const SmallSet<size_t>& EXRs( size_t R ) const {
174  DAI_DEBASSERT( R < _EXRs.size() );
175  return _EXRs[R];
176  }
177 
179  SmallSet<size_t>& EXRs( size_t R ) {
180  DAI_DEBASSERT( R < _EXRs.size() );
181  return _EXRs[R];
182  }
183 
185  const SmallSet<size_t>& INRs( size_t R ) const {
186  DAI_DEBASSERT( R < _INRs.size() );
187  return _INRs[R];
188  }
189 
191  SmallSet<size_t>& INRs( size_t R ) {
192  DAI_DEBASSERT( R < _INRs.size() );
193  return _INRs[R];
194  }
195 
197  const Connection& M( size_t R, size_t i ) const {
198  DAI_DEBASSERT(R < _M.size());
199  DAI_DEBASSERT(i < _M[R].size());
200  return _M[R][i]; }
201 
203  Connection& M( size_t R, size_t i ) {
204  DAI_DEBASSERT(R < _M.size());
205  DAI_DEBASSERT(i < _M[R].size());
206  return _M[R][i]; }
207 
209  const std::vector<Connection>& M( size_t R ) const {
210  DAI_DEBASSERT(R < _M.size());
211  return _M[R];
212  }
213 
215  std::vector<Connection>& M( size_t R ) { return _M[R]; }
216 
218  const std::vector<size_t>& var2CW( size_t i ) const { return _var2CW[i]; }
220 
222 
223  void setRgn( std::vector<SmallSet<size_t> > regions, NeighborType neighbors, bool debugging = false );
226 
228 
229 
232  virtual void ReadFromFile( const char* /*filename*/ ) {
233  DAI_THROW(NOT_IMPLEMENTED);
234  }
235 
237 
239  virtual void WriteToFile( const char* /*filename*/, size_t /*precision*/=15 ) const {
240  DAI_THROW(NOT_IMPLEMENTED);
241  }
242 
244  friend std::ostream& operator<< ( std::ostream& /*os*/, const CobwebGraph& /*rg*/ ) {
245  DAI_THROW(NOT_IMPLEMENTED);
246  }
247 
249  std::string toString() const {
250  std::stringstream ss;
251  ss << *this;
252  return ss.str();
253  }
254 
256 
258  virtual void printDot( std::ostream& /*os*/ ) const {
259  DAI_THROW(NOT_IMPLEMENTED);
260  }
262 
263 
264  protected:
266  bool checkPartition( const std::vector<SmallSet<size_t> >& regions ) const;
267 
269  void setVar2CW();
270 
272  void setExtnFact();
273 
275  void setMSGs( NeighborType neighbors );
276 
278  void setCountingNumbers( bool debugging = false );
279 
281  void eraseNonMaximal( std::vector<SmallSet<size_t> >& regions );
282 };
283 
284 
285 } // end of namespace dai
286 
287 
288 #endif
dai::CobwebGraph::Connection::dual
size_t dual
Index of the mirror of this connection in the connections of the second region. (reference of this me...
Definition: cobwebgraph.h:45
dai::CobwebGraph::M
const std::vector< Connection > & M(size_t R) const
Returns constant reference to the vector of connection structure from region R to all its neighbours...
Definition: cobwebgraph.h:209
dai::CobwebGraph::outM
const VarSet & outM(size_t R, size_t j) const
Returns constant reference to the variables in the outgoing message from region R to its j'th neighbo...
Definition: cobwebgraph.h:145
dai::CobwebGraph::M
const Connection & M(size_t R, size_t i) const
Returns constant reference to the connection structure from region R to its i'th neighbour.
Definition: cobwebgraph.h:197
dai::CobwebGraph::_Rifs
std::vector< SmallSet< size_t > > _Rifs
Index of factors internal to each region, i.e., all its variables are internal to the region...
Definition: cobwebgraph.h:77
dai::CobwebGraph::setCountingNumbers
void setCountingNumbers(bool debugging=false)
Sets _cn.
Definition: cobwebgraph.cpp:65
dai::CobwebGraph::eraseNonMaximal
void eraseNonMaximal(std::vector< SmallSet< size_t > > &regions)
For the given set of variables for each region, removes the regions that are non-maximal.
Definition: cobwebgraph.cpp:48
dai::CobwebGraph::outM
const std::vector< VarSet > & outM(size_t R) const
Returns constant reference the vector of domain of all outgoing messages from region R...
Definition: cobwebgraph.h:131
dai::CobwebGraph::Rfs
const SmallSet< size_t > & Rfs(size_t R) const
Returns constant reference to the index of factors of region R.
Definition: cobwebgraph.h:161
dai::CobwebGraph::setExtnFact
void setExtnFact()
Setup the _INRs, _EXRs and all the factor indices (e.g. Rifs)
Definition: cobwebgraph.cpp:239
dai::CobwebGraph::cn
const std::map< VarSet, std::pair< int, std::vector< size_t > > > & cn(size_t R) const
Returns constant reference to the _cn for region R.
Definition: cobwebgraph.h:119
weightedgraph.h
Defines some utility functions for (weighted) undirected graphs, trees and rooted trees...
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::CobwebGraph::_EXRs
std::vector< SmallSet< size_t > > _EXRs
Vector of variable indices on the boundary of each region ( r)
Definition: cobwebgraph.h:73
dai::CobwebGraph::_INRs
std::vector< SmallSet< size_t > > _INRs
Vector of variable indices internal to each region (r)
Definition: cobwebgraph.h:71
dai::CobwebGraph::_cn
std::vector< std::map< VarSet, std::pair< int, std::vector< size_t > > > > _cn
Definition: cobwebgraph.h:92
dai::CobwebGraph::clone
virtual CobwebGraph * clone() const
Clone *this (virtual copy constructor)
Definition: cobwebgraph.h:110
dai::CobwebGraph::Connection::iter
size_t iter
Index of this connection in the connections of the first region.
Definition: cobwebgraph.h:43
dai::CobwebGraph::outM
std::vector< VarSet > & outM(size_t R)
Returns reference the vector of domain of all outgoing messages from region R.
Definition: cobwebgraph.h:137
dai::CobwebGraph::_var2CW
std::vector< std::vector< size_t > > _var2CW
For each i the index of (cobweb) regions that contain variable i.
Definition: cobwebgraph.h:86
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::CobwebGraph::_outM
std::vector< std::vector< VarSet > > _outM
The vector of domain of messages leaving each region ( r_{p,q})
Definition: cobwebgraph.h:81
dai::CobwebGraph::DAI_ENUM
DAI_ENUM(NeighborType, ALL, TOP, CLOSEST)
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::CobwebGraph::setMSGs
void setMSGs(NeighborType neighbors)
Helper function that setups the msgs (_M, _outM) using the values in _INRs and _EXRs.
Definition: cobwebgraph.cpp:177
dai::CobwebGraph::_Rfs
std::vector< SmallSet< size_t > > _Rfs
Index of factors in each region.
Definition: cobwebgraph.h:75
dai::CobwebGraph::EXRs
SmallSet< size_t > & EXRs(size_t R)
Returns reference to the index of variables on the boundary of region R ( r)
Definition: cobwebgraph.h:179
dai::CobwebGraph::_Rxfs
std::vector< SmallSet< size_t > > _Rxfs
Index of factors that bridge each region, i.e., not all its variables are internal to the region...
Definition: cobwebgraph.h:79
dai::CobwebGraph::Connection::my
size_t my
Index of the first region (p)
Definition: cobwebgraph.h:39
dai::CobwebGraph::checkPartition
bool checkPartition(const std::vector< SmallSet< size_t > > &regions) const
The function to check for partitioning.
Definition: cobwebgraph.cpp:154
dai::CobwebGraph::Connection::his
size_t his
Index of the second region (q)
Definition: cobwebgraph.h:41
dai::CobwebGraph::_M
std::vector< std::vector< Connection > > _M
Vector of all connections to each region.
Definition: cobwebgraph.h:83
dai::CobwebGraph::Connection::msg
Factor msg
The message sent from region q (his) to p (my)
Definition: cobwebgraph.h:47
dai::CobwebGraph::operator<<
friend std::ostream & operator<<(std::ostream &, const CobwebGraph &)
Writes a cobweb graph to an output stream.
Definition: cobwebgraph.h:244
dai::CobwebGraph::setVar2CW
void setVar2CW()
Helper function that sets the regions containing each variable using the values in _INRs...
Definition: cobwebgraph.cpp:166
dai::CobwebGraph::M
std::vector< Connection > & M(size_t R)
Returns vector of all connections to region R.
Definition: cobwebgraph.h:215
dai::CobwebGraph::Connection::newmsg
Factor newmsg
Used as a temporary factor only.
Definition: cobwebgraph.h:53
smallset.h
Defines the SmallSet<> class, which represents a set (optimized for a small number of elements)...
dai::CobwebGraph
A CobwebGraph is a special type of region graph used by the GLC algorithm.
Definition: cobwebgraph.h:34
dai::CobwebGraph::INRs
SmallSet< size_t > & INRs(size_t R)
Returns reference to the index of variables inside region R (r)
Definition: cobwebgraph.h:191
dai::CobwebGraph::outM
VarSet & outM(size_t R, size_t j)
Returns a reference to the variables in the outgoing message from region R to its j'th neighbor...
Definition: cobwebgraph.h:154
dai::CobwebGraph::WriteToFile
virtual void WriteToFile(const char *, size_t=15) const
Writes a cobweb graph to a file.
Definition: cobwebgraph.h:239
dai::CobwebGraph::isPartition
bool isPartition
Whether a given set of region vars makes a partitioning or not.
Definition: cobwebgraph.h:95
dai::CobwebGraph::Connection::subregions
std::vector< VarSet > subregions
Regions rho that are descendents of msg from q to p in p's msg-region graph (not used in partitioning...
Definition: cobwebgraph.h:57
dai::CobwebGraph::ReadFromFile
virtual void ReadFromFile(const char *)
Reads a cobweb graph from a file.
Definition: cobwebgraph.h:232
dai::CobwebGraph::setRgn
void setRgn(std::vector< SmallSet< size_t > > regions, NeighborType neighbors, bool debugging=false)
Sets up all the regions and messages.
Definition: cobwebgraph.cpp:21
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::CobwebGraph::var2CW
const std::vector< size_t > & var2CW(size_t i) const
Returns the vector of region indices that contain i as internal variable.
Definition: cobwebgraph.h:218
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
dai::CobwebGraph::Connection::fc
std::vector< size_t > fc
Index of factors in common.
Definition: cobwebgraph.h:55
dai::CobwebGraph::nrCWs
size_t nrCWs() const
Returns the number of regions.
Definition: cobwebgraph.h:116
dai::CobwebGraph::Connection::varinds
std::vector< size_t > varinds
"Index" of variables in the message
Definition: cobwebgraph.h:49
dai::CobwebGraph::CobwebGraph
CobwebGraph(const FactorGraph &fg)
Constructs a cobweb graph from a factor graph.
Definition: cobwebgraph.h:104
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::CobwebGraph::toString
std::string toString() const
Formats a cobweb graph as a string.
Definition: cobwebgraph.h:249
dai::CobwebGraph::Rfs
SmallSet< size_t > & Rfs(size_t R)
Returns reference to the index of factors of region R.
Definition: cobwebgraph.h:167
dai::CobwebGraph::M
Connection & M(size_t R, size_t i)
Returns reference to the connection structure from region R to its i'th neighbour.
Definition: cobwebgraph.h:203
dai::CobwebGraph::cn
std::map< VarSet, std::pair< int, std::vector< size_t > > > & cn(size_t R)
Returns a reference to the _cn for region R.
Definition: cobwebgraph.h:125
dai::CobwebGraph::INRs
const SmallSet< size_t > & INRs(size_t R) const
Returns constant reference to the index of variables inside region R (r)
Definition: cobwebgraph.h:185
dai::CobwebGraph::EXRs
const SmallSet< size_t > & EXRs(size_t R) const
Returns constant reference to the index of variables on the boundary of region R ( r) ...
Definition: cobwebgraph.h:173
dai::CobwebGraph::Connection
The information in connection between two regions.
Definition: cobwebgraph.h:37
dai::CobwebGraph::printDot
virtual void printDot(std::ostream &) const
Writes a cobweb graph to a GraphViz .dot file.
Definition: cobwebgraph.h:258
dai::CobwebGraph::CobwebGraph
CobwebGraph()
Default constructor.
Definition: cobwebgraph.h:101
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__inv0.html0000644000175000017500000001166512552201365020663 0ustar jorismjorism libDAI: dai::fo_inv0< T > Struct Template Reference
Public Member Functions | List of all members
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>

Inherits unary_function< T, T >.

Public Member Functions

T operator() (const T &x) const
 Returns (x == 0 ? 0 : (1 / x)) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_7.png0000644000175000017500000000144712552200215015600 0ustar jorismjorism‰PNG  IHDR‡#‰´éÀ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï–IDATxíWn#1 †?uMÕýo»¤4M‰ã N¼v#ˆ6‡j?û+À/ü+4/Ër™ àdB)ÑÔ±”żˆ–ß0ß gÖŸ¬Ž»Ö~G¿Ù» å°ª€Ë4o¾s>ˆ#à2óþº)‡lº™<ÀmzÇ»7æÝ;ƒnšc  §Çp¤w{‡Í3ãäS ‹¶'F‡ÝXëî°IbÅ¥k^ÜÄá“~°1~Z³>åC a÷yÌí¿²°²>ªë®°ÆŠmÙÊ£ÛÜÑÂ"Ù® ¸ú„–ËTn¼l ê ½Ý5/hxda^}Ôâ›3*ކêéʯÝÄaFá‹Á yôH†ò©8ÜZª`ÇáäÕµYqndž‹MŽšÙéŒç;ñ!¬¼5Ö;ÎÇŽMt¹kÇ1ªI|õ³îŽH‡&؃Y ©qÔä¶=ä=YŒøx3lÍNQQ]VóVrCî¬\ 3¸ÑʇœÓÐq%ÎAìUrl³¨ÓtMã›8Ô볜\µ>©amn£Dkô²Q®˜Sž]¤ È{A©Þ¨SüF {üš¦Êdí3{lÔ’MµäEŤéVµ—]ª‚£~´ÄT%®e« Þ”¯ÔPÎ0U}æPÝ{êR®Ïð¶šÏM5Ïï”ÓÏqtÖ;¥}öW„=õùÞ§pö¹^ÿ ÀÉ–ÒZ…0wª?À3i)2V1êÁüÀO~Ð:½A¢Ôçú<ÀóHº™t¢ libDAI: Change Log
Change Log 
libDAI-0.3.2 (2015-07-17)
-------------------------

Miscellaneous improvements:
* [Charles Vaske] Various improvements to EM code, including interface changes
* Added 'inclusive' argument to DAG::ancestors() and DAG::descendants()
* [Julien Rebetez] added FactorGraph::printDot() to SWIG interface
* Extended SWIG python interface (inspired by Kyle Ellrott): inference is possible in Python now!
* Added toString() formatting functions to the classes that had an output streaming operator<<
* Merged Generalized Loop Correction code kindly provided by Siamak Ravanbakhsh

Build system improvements:
* Build system: optional compilation targets are now set in include/dai/dai_config.h instead of Makefile.ALL

Bug fixes:
* Disabled debugging output in src/cobwebgraph.cpp to fix compilation issue under OSX
* [Lee C Baker] patch in include/dai/enum.h to fix compilation issues on OSX related to std::wistream and std::wostream (another workaround would be to specify -std=c++11)
* Fixed regression in SWIG interface caused by new build system (thanks to Benjamin Mumm for reporting this)
* Workaround for bug in Boost Graph Library version 1.54 ("The graph may not contain an edge with negative weight") by not using Prim's minimum spanning tree algorithm anymore
* Removed conversion script FastInf->libDAI because it is buggy (uses wrong permutation of factor entries)
* Replaced all occurrences of std::size_t by size_t to avoid SWIG problems
* Fixed division-by-zero issue in pow() which caused problems for GLC+ with sparse factors
* Fixed bugs in unit test prob_test.cpp: replaced all occurences of
  BOOST_CHECK_CLOSE(...,(Real)0.0,tol) with BOOST_CHECK_SMALL(...,tol)


libDAI-0.3.1 (2012-09-17)
-------------------------

Miscellaneous improvements:
* Full 64-bit support on all supported platforms (Linux, OSX, Windows)
* Added special MatLab interface for junction tree algorithm (dai_jtree)
* Optimized ClusterGraph( const FactorGraph&, bool) constructor

Build system improvements:
* Added Makefile.WINDOWS64, kindly provided by Lin Ming
* [Arman Aksoy] Added Makefile.MACOSX64
* Added VC10 build files, kindly provided by Sameh Khamis

Bug fixes:
* Fixed bug (found by Sameh Khamis): define NAN (Windows)
* Fixed bug (found by Sameh Khamis): add some necessary casts of size_t to BigInt (Windows)
* Fixed bug (found by Yan): replaced GNU extension __PRETTY_FUNCTION__ by __FUNCTION__ (Visual Studio) or __func__ (other compilers)
* Fixed bug (found by Andy Mueller): added GMP library invocations to swig Makefile
* Fixed bug (found by cax): when building MatLab MEX files, GMP/MPIR libraries were not linked
* Fixed bug in findMaximum (it only considered a single connected component of the factor graph)
* [Benjamin Piwowarski] Renamed "foreach" macro into "bforeach" to avoid conflicts with newer Boost library versions
* Fixed "typename" bug in src/alldai.cpp which resulted in FTBFS with older g++ compilers
* Fixed memory leak in alldai.cpp and removed the function builtinInfAlgs()
* Fixed memory leak in CBP::run()
* Fixed typo in Priya's name


libDAI-0.3.0 (2011-07-12)
-------------------------

New license:
* Changed license from GPL v2+ to FreeBSD (BSD 2-clause)

Miscellaneous improvements:
* Improved Exception class 
  (it now stores more information and doesn't print to stderr by default)
* Added builtinInfAlgs() and builtinInfAlgNames()

Bug fixes:
* [Laurens van der Maaten] src/matlab/dai.cpp now correctly handles missing logZ() 
  and maxDiff() implementations
* Now uses GMP big integer type to represent linear states and the number of
  states of VarSets (in some cases). This fixes a bug Jerome Maye and Priya 
  found in the State class. Unfortunately, the supplied Makefile.WINDOWS now 
  no longer works out-of-the-box.
* Fixed numerical issues in MF, FBP and TRWBP (discovered in sparse branch)
* Fixed bug in findMaximum(): inconsistent max-beliefs are now detected,
  instead of returning a MAP state with zero joint probability
  (reported by Hynek Urban)
* Fixed a Boost-related bug in src/util.cpp (reported by Avneesh Saluja)
  (the random seed needs to be an unsigned int on some platforms)
* Fixed two bugs in examples/example_sprinkler_gibbs (reported by Priya)
* Fixed bug in tokenizeString() and Evidence::addEvidenceTabFile()
  (a tab character at the end of a line was incorrectly discarded - bug reported by Priya)
* Replaced all Name members by name() virtual functions and removed global variable DAINames
  (this fixes a bug in matlab/dai.cpp reported by Thomas Mensink)


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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1GraphEL.html0000644000175000017500000002052512552201366020223 0ustar jorismjorism libDAI: dai::GraphEL Class Reference
Public Member Functions | List of all members
dai::GraphEL Class Reference

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

#include <dai/weightedgraph.h>

Inheritance diagram for dai::GraphEL:

Public Member Functions

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

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__id.html0000644000175000017500000001145512552201365020400 0ustar jorismjorism libDAI: dai::fo_id< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_id< T > Struct Template Reference

Function object that returns the value itself. More...

#include <dai/prob.h>

Inherits unary_function< T, T >.

Public Member Functions

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

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_t.html0000644000175000017500000001763012552201370020141 0ustar jorismjorism libDAI: Class Members - Functions
 

- t -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1MR.png0000644000175000017500000000152312552201367017075 0ustar jorismjorism‰PNG  IHDR«ˆ¯ë³PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2âIDATxíárƒ —™¼ÿ#׈¡&m⥑™ë°rÄõò—œs²$ A¸J’?á*IþœuMû¨5)Íqi0Í’ô~®õS©¿ì:¥ínæôÙ¼Ní÷ëšÖêºÜ IopÆuÖY$¤dKj·é‘¤w8麦i3ñ±ëóº®g®¥û®VlïZ¯»öëõ®ßZ¯ö˜#[Ž\¿xHÒËŒâúÅõ*I¯±ü:HÒüû¤7 WIò'\%ÉŸÉ5çœÇÀŸÀ äz»#;ë¤:ŒìH®q|‚pð'\ü WÂÀŸpð'\ü WÂÀŸpð'\ü W•œs²$ A¸J’?á*Iþt®i¥û_׸¿JêÊ|Ï®kßp0èÁЧ®}Ó*Öþ±±$uü­õå Œëô’÷1åe[^í¼‡®Ë}GZ7WíRî¶ß°öL¡©$u¥ºÎã—§KÉIé1Ë}Eºwm#ÌdËëYW3¦MX'i­ëÚogú‹k}þñïgíè¾a÷Z›w9v-Ï9r] 6ñÁ7ë6æ3Wµ¡;×j»u5Uïjƒm¼Íë~ üæºú/yݼY¿[Ÿ¸¾¾^;ì]ûqÖ«=ÊÎ\î®{÷Øõ·s íq{˜ÞºÊñÐç]R+.¿[ÎCIzçv}Iz»®ßU’NóiWIúÂU’ü WIògrÍ9ç1ðç0¹ÞnãÈä:©#;’kœŸ \ü WÂÀŸpð'\ü WÂÀŸpð'\ü WÂÀŸp%¥”0á àO¸øãäÚ&©ÑLuÙħpw5ga­æèüs<\—ƒ¯ä®åõŠ®óG.. L)-Ws]'Y½ÚÌÅõ2ëuu-Bvo­IíÖÀ{ø¹šêÈõ¢ëu“î«ž&“×tøÂÀŸpð'\üÌ5¥”Æà&ÒE6È+D0IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1InfAlg.html0000644000175000017500000023141112552201366020077 0ustar jorismjorism libDAI: dai::InfAlg Class Reference
List of all members
dai::InfAlg Class Referenceabstract

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::BP dai::CBP dai::ExactInf dai::HAK dai::JTree dai::LC dai::MF dai::MR

Public Member Functions

Constructors/destructors
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual InfAlg * clone () const =0
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual InfAlg * construct (const FactorGraph &fg, const PropertySet &opts) const =0
 Returns a pointer to a newly constructed inference algorithm. More...
 
Queries
virtual std::string name () const =0
 Returns the name of the algorithm. More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual FactorGraph & fg ()=0
 Returns reference to underlying FactorGraph. More...
 
virtual const FactorGraph & fg () const =0
 Returns constant reference to underlying FactorGraph. More...
 
Inference interface
virtual void init ()=0
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &vs)=0
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()=0
 Runs the approximate inference algorithm. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &vs) const =0
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< Factor > beliefs () const =0
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const =0
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
virtual std::vector< size_t > findMaximum () const
 Calculates the joint state of all variables that has maximum probability. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
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}$) More...
 
virtual void makeCavity (size_t i, bool backup=false)=0
 Sets all factors interacting with variable with index i to one. More...
 
virtual void makeRegionCavity (std::vector< size_t > facInds, bool backup=false)=0
 Sets all factors indicated by facInds to one. More...
 
Backup/restore mechanism for factors
virtual void backupFactor (size_t I)=0
 Make a backup copy of factor I. More...
 
virtual void backupFactors (const VarSet &vs)=0
 Make backup copies of all factors involving the variables in vs. More...
 
virtual void restoreFactor (size_t I)=0
 Restore factor I from its backup copy. More...
 
virtual void restoreFactors (const VarSet &vs)=0
 Restore the factors involving the variables in vs from their backup copies. More...
 
Managing parameters
virtual void setProperties (const PropertySet &opts)=0
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const =0
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
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]". More...
 

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.

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 ( )
inlinevirtual

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::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::TRWBP, dai::FBP, dai::CBP, and dai::ExactInf.

virtual InfAlg* dai::InfAlg::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
pure virtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Implemented in dai::BP, dai::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::TRWBP, dai::FBP, dai::CBP, and dai::ExactInf.

virtual std::string dai::InfAlg::name ( ) const
pure virtual

Returns the name of the algorithm.

Implemented in dai::BP, dai::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::TRWBP, dai::FBP, dai::CBP, and dai::ExactInf.

virtual std::string dai::InfAlg::identify ( ) const
inlinevirtual

Identifies itself for logging purposes.

virtual FactorGraph& dai::InfAlg::fg ( )
pure virtual

Returns reference to underlying FactorGraph.

Implemented in dai::DAIAlg< GRM >.

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 >.

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::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, and dai::ExactInf.

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_IMPLEMENTEDif not implemented/supported

Implemented in dai::BP, dai::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, and dai::ExactInf.

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::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, and dai::ExactInf.

Examples:
example_imagesegmentation.cpp, and uai2010-aie-solver.cpp.
virtual Factor dai::InfAlg::belief ( const Var &  v) const
inlinevirtual

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::MR, dai::LC, dai::MF, dai::CBP, and dai::ExactInf.

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_IMPLEMENTEDif not implemented/supported.
BELIEF_NOT_AVAILABLEif the requested belief cannot be calculated with this algorithm.

Implemented in dai::BP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, and dai::ExactInf.

virtual Factor dai::InfAlg::beliefV ( size_t  i) const
inlinevirtual

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::MR, dai::LC, dai::MF, dai::CBP, and dai::ExactInf.

Examples:
example_imagesegmentation.cpp, and uai2010-aie-solver.cpp.
virtual Factor dai::InfAlg::beliefF ( size_t  I) const
inlinevirtual

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, and dai::ExactInf.

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::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, and dai::ExactInf.

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_IMPLEMENTEDif not implemented/supported

Implemented in dai::BP, dai::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::TRWBP, dai::CBP, dai::FBP, and dai::ExactInf.

Examples:
uai2010-aie-solver.cpp.
virtual std::vector<size_t> dai::InfAlg::findMaximum ( ) const
inlinevirtual

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

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

Reimplemented in dai::BP, dai::JTree, and dai::ExactInf.

Examples:
uai2010-aie-solver.cpp.
virtual Real dai::InfAlg::maxDiff ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented in dai::BP, dai::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, and dai::ExactInf.

Examples:
uai2010-aie-solver.cpp.
virtual size_t dai::InfAlg::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented in dai::BP, dai::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, and dai::ExactInf.

Examples:
uai2010-aie-solver.cpp.
virtual void dai::InfAlg::setMaxIter ( size_t  )
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented in dai::BP, dai::TreeEP, dai::HAK, dai::LC, dai::MF, and dai::CBP.

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 >.

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 >.

virtual void dai::InfAlg::makeRegionCavity ( std::vector< size_t >  facInds,
bool  backup = false 
)
pure virtual

Sets all factors indicated by facInds to one.

If backup == true, make a backup of all factors that are changed.

Implemented in dai::DAIAlg< GRM >.

virtual void dai::InfAlg::backupFactor ( size_t  I)
pure virtual

Make a backup copy of factor I.

Exceptions
MULTIPLE_UNDOif a backup already exists

Implemented in dai::DAIAlg< GRM >.

virtual void dai::InfAlg::backupFactors ( const VarSet &  vs)
pure virtual

Make backup copies of all factors involving the variables in vs.

Exceptions
MULTIPLE_UNDOif a backup already exists

Implemented in dai::DAIAlg< GRM >.

virtual void dai::InfAlg::restoreFactor ( size_t  I)
pure virtual

Restore factor I from its backup copy.

Implemented in dai::DAIAlg< GRM >.

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 >.

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::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, dai::TRWBP, and dai::ExactInf.

virtual PropertySet dai::InfAlg::getProperties ( ) const
pure virtual

Returns parameters of this inference algorithm converted into a PropertySet.

Implemented in dai::BP, dai::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, dai::TRWBP, and dai::ExactInf.

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::TreeEP, dai::JTree, dai::MR, dai::HAK, dai::LC, dai::MF, dai::CBP, dai::TRWBP, and dai::ExactInf.

The documentation for this class was generated from the following file:
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_o.html0000644000175000017500000004004312552201370017113 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- o -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1ExactInf-members.html0000644000175000017500000003615112552201365022073 0ustar jorismjorism libDAI: Member List
dai::ExactInf Member List

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

_beliefsFdai::ExactInfprivate
_beliefsVdai::ExactInfprivate
_logZdai::ExactInfprivate
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const Var &v) const dai::ExactInfinlinevirtual
belief(const VarSet &vs) const dai::ExactInfvirtual
beliefF(size_t I) const dai::ExactInfinlinevirtual
beliefs() const dai::ExactInfvirtual
beliefV(size_t i) const dai::ExactInfinlinevirtual
calcMarginal(const VarSet &vs) const dai::ExactInf
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clone() const dai::ExactInfinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::ExactInfinlinevirtual
construct()dai::ExactInfprivate
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
ExactInf()dai::ExactInfinline
ExactInf(const FactorGraph &fg, const PropertySet &opts)dai::ExactInfinline
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findMaximum() const dai::ExactInfvirtual
getProperties() const dai::ExactInfvirtual
identify() const dai::InfAlginlinevirtual
init()dai::ExactInfvirtual
init(const VarSet &)dai::ExactInfinlinevirtual
Iterations() const dai::ExactInfinlinevirtual
logZ() const dai::ExactInfinlinevirtual
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::ExactInfinlinevirtual
name() const dai::ExactInfinlinevirtual
printProperties() const dai::ExactInfvirtual
props (defined in dai::ExactInf)dai::ExactInf
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()dai::ExactInfvirtual
setMaxIter(size_t)dai::InfAlginlinevirtual
setProperties(const PropertySet &opts)dai::ExactInfvirtual
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_q.html0000644000175000017500000001153512552201370020134 0ustar jorismjorism libDAI: Class Members - Functions
 

- q -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1CBP-members.html0000644000175000017500000004413712552201364021000 0ustar jorismjorism libDAI: Member List
dai::CBP Member List

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

_beliefsFdai::CBPprivate
_beliefsVdai::CBPprivate
_clamp_ofstreamdai::CBPprivate
_itersdai::CBPprivate
_logZdai::CBPprivate
_maxdiffdai::CBPprivate
_num_leavesdai::CBPprivate
_sum_leveldai::CBPprivate
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
BBPFindClampVar(const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real *maxVarOut)dai::CBPrelated
belief(const Var &v) const dai::CBPinlinevirtual
belief(const VarSet &) const dai::CBPinlinevirtual
beliefF(size_t I) const dai::CBPinlinevirtual
beliefs() const dai::CBPinlinevirtual
beliefV(size_t i) const dai::CBPinlinevirtual
CBP()dai::CBPinline
CBP(const FactorGraph &fg, const PropertySet &opts)dai::CBPinline
chooseNextClampVar(InfAlg *bp, std::vector< size_t > &clamped_vars_list, size_t &i, std::vector< size_t > &xis, Real *maxVarOut)dai::CBPprivatevirtual
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clone() const dai::CBPinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::CBPinlinevirtual
construct()dai::CBPprivate
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findMaximum() const dai::InfAlginlinevirtual
getInfAlg()dai::CBPprivate
getProperties() const dai::CBPinlinevirtual
identify() const dai::InfAlginlinevirtual
init()dai::CBPinlinevirtual
init(const VarSet &)dai::CBPinlinevirtual
Iterations() const dai::CBPinlinevirtual
logZ() const dai::CBPinlinevirtual
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::CBPinlinevirtual
name() const dai::CBPinlinevirtual
printDebugInfo()dai::CBPprivate
printProperties() const dai::CBPinlinevirtual
props (defined in dai::CBP)dai::CBP
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()dai::CBPvirtual
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::CBPprivate
setBeliefs(const std::vector< Factor > &bs, Real logZ)dai::CBPprivate
setMaxIter(size_t maxiter)dai::CBPinlinevirtual
setProperties(const PropertySet &opts)dai::CBPinlinevirtual
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/io_8h.html0000644000175000017500000001260112552201363015574 0ustar jorismjorism libDAI: include/dai/io.h File Reference
Namespaces | Functions
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

 dai
 Namespace for libDAI.
 

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. More...
 
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. More...
 

Detailed Description

Provides functionality for input/output of data structures in various file formats.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1HAK_1_1Properties-members.html0000644000175000017500000001322512552201366023727 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1FBP.png0000644000175000017500000000201112552201365017155 0ustar jorismjorism‰PNG  IHDR«ÀLc²PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2˜IDATxím’« ›¦*÷?ò3ñ c’ݬ“©š-ÛqÀ¿ÔZk'PU» ]UãIWÕxŽº–}kí²ÜÚcGÓ­úâ\Ÿê—±þ²ë¶«A¹…¯ëÐ=Îa]\§ TÿÀ×›Î$¡¥-Kk9ÝœQý ]ç0ÍbMû±ëã:çÀ+×ñô9\[±½ë² |Ýu›¯¿pýV¾¶ûÀ­Õ–G®_ÜTߦ×/æ«ê{L_Õ?ðßs@õ¤«j<éªÏàZk­}Ï :r½\ú‘íÈuPíF¶'×Ü>AºÄ“®ñ¤+@<é OºÄ“®ñ¤+@<é OºÄ“®ñ¤+@<éJ­µvUµ ÒU5žtUgãZö­rým:÷GuSn×ìNí; z2ô¥ë¶k[ÿ´mÕ ¿ë}{‚ÆuxÈë˜ña׸¶ó>t®{t«)p·j=ŒW·ïp934›JÝ”Åõ6~º»–¦¨å9Óu£ôÖuÑL6=^ëÚŒY'\&Y¶®óùv¦ß¸.÷œãÛY7lÞáæ±îžå±ëxŸG®“Á]ûÁ;Û,ÌW®Mkºs]lï]›jëÚ6îÛ÷qÝçÀO®û»ÿ×»'Û®Ö®ïçk³.·®ÛqÏòµÝÆ•9]½¬ÝÇ®?íëo÷æì’ãö°»º–ïÖ“ýPõ=^OtØõI Tßçîó{U=̧]UÿéªOºªÆ3¸ÖZkÄsè„Ž\/—~d;rT»‘íÉ5÷€O®ñ¤+@<é OºÄ“®ñ¤+@<é OºÄ“®ñ¤+@<é OºRk­@Uí‚tU']Uã s-ûV¹þšZõpÝv ‡¹V=BŒë¶)€›¸žÑõê39mË)]g—Yí´ù:»ŽNs@õ ‘®Muj×m¾žØµÝn­©Ìùª@~cUãIWÕxÒU5žtUgp­µÖ>ˆçÐ ¹^.ýÈvä:¨v#Û“kîŸ ]âIW€xÒ žtˆ']âIW€xÒ žtˆ']âIW€xÒ žt¥”R:Ðé OºÄâºN±´¦…;Öó€»îºnõÕùÉ8€ßrÜuÚö¦ðÚõöžGm9¥ëÏÅÉ·^‡Å½'SÊaÇÙƒ©íl1r´)NeZëôµ†×îE[åa¥|hlÒK5©«qDmCòA¸î9ËuvŸ2™0Y͸d_õÒ„„¸©ôum[§Ûšÿv?:f0Ë,qÉ‚zÝûôè»3crN|–þ|’¾ÑÙ¾/9·-ÊðMSm=3´˜/µâ¿f:°²öÇU; ÿm¦ïúføYŽ¦À0·}‰¼”øö^<É?x ‡ÆgyIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1CondProbEstimation-members.html0000644000175000017500000002162712552201365024137 0ustar jorismjorism libDAI: Member List
dai::CondProbEstimation Member List

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

_initial_statsdai::CondProbEstimationprivate
_name (defined in dai::CondProbEstimation)dai::CondProbEstimationprivatestatic
_propsdai::CondProbEstimationprivate
_target_dimdai::CondProbEstimationprivate
clone() const dai::CondProbEstimationinlinevirtual
CondProbEstimation(size_t target_dimension, const Prob &pseudocounts)dai::CondProbEstimation
construct(const std::string &method, const PropertySet &p)dai::ParameterEstimationprivatestatic
estimate(const Prob &p)dai::ParameterEstimationinlineprivatevirtual
factory(const PropertySet &p)dai::CondProbEstimationstatic
name() const (defined in dai::CondProbEstimation)dai::CondProbEstimationinlinevirtual
ParamEstFactory typedefdai::ParameterEstimationprivate
parameters(const Prob &p)dai::CondProbEstimationvirtual
parametersToFactor(const Prob &p)dai::CondProbEstimationvirtual
probSize() const dai::CondProbEstimationinlinevirtual
properties() const (defined in dai::CondProbEstimation)dai::CondProbEstimationinlinevirtual
registerMethod(const std::string &method, const ParamEstFactory &f)dai::ParameterEstimationinlineprivatestatic
~CondProbEstimation()dai::CondProbEstimationinlinevirtual
~ParameterEstimation()dai::ParameterEstimationinlineprivatevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_rela.html0000644000175000017500000001111412552201370017575 0ustar jorismjorism libDAI: Class Members - Related Functions
 
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1State-members.html0000644000175000017500000001746712552201370021457 0ustar jorismjorism libDAI: Member List
dai::State Member List

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

begin() const dai::Stateinline
const_iterator typedefdai::State
end() const dai::Stateinline
get() const dai::Stateinline
insert(InputIterator b, InputIterator e)dai::Stateinline
operator const std::map< Var, size_t > &() const dai::Stateinline
operator size_t() const dai::Stateinline
operator()(const Var &v) const dai::Stateinline
operator()(const VarSet &vs) const dai::Stateinline
operator++()dai::Stateinline
operator++(int)dai::Stateinline
reset()dai::Stateinline
State()dai::Stateinline
State(const VarSet &vs, BigInt linearState=0)dai::Stateinline
State(const std::map< Var, size_t > &s)dai::Stateinline
statedai::Stateprivate
statesdai::Stateprivate
states_type typedefdai::Stateprivate
valid() const dai::Stateinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1WeightedGraph.png0000644000175000017500000000125712552201370021277 0ustar jorismjorism‰PNG  IHDR™P=e'ôPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2>IDATxí[r+! [?>ûßqìy@ØQ'ܺ”9chb~13›R˜$M¨E&I9-2IÊiDv´f°·±÷ÇžY/ìü“¤ÞAÖ»‘¤N/|d•l˹ëêܪûÜÛJïï­aGvØ_AšÌ¤RêÚ>ÃŽuö É*ûb’…»’•ª˜U“V•Óöœk¼u1 Ø»ù„¬žÖ9 bæ‚ÜngóÖE(Ê€ #ÚãW1‹É$É)3“J“ýÁ9;vóÊM“ê²åØö Ó«äfcIŠõÕo@ΪýiÃ÷“ùmLؽ?fÏ?B’êßû¢KÒßj‘IRNS“™™Í(€Ó `JMKv»ÍŠ6-ÙlR´yÉVndµÈrZd9-2€œ@N‹ §EÓ"Èi‘ä´ÈrZd9-2€œþ23³)…L¨EÓ"ÈÉ‘•êU{TN ù¥mo[jtê›ÏL\¹&OÖ ïÉv:€Naë ñl>.?ŒYéÚÇÞçõ(íÎûiVÿUyN¶¹¸(®âkUWïz²ª¯í¯½A@VCºG4[Î' Mè»!>r®^l²ý4†dWWOV¬JL|:8›fG›·ÓÞ“9çá‘ÅÌûÃé[1ë–Ý“ùsìf$žÌØÄ9«sóÌ°(ÌÍ*ªÜ<”ÝÜOÄðzqk$”5KOó%²ÑÕ 0Òï›ðYýÀ»µÈrZd9=.@3³ õäÍYå˜ã½rIEND®B`‚libDAI-0.3.2/doc/html/globals.html0000644000175000017500000000675012552201370016217 0ustar jorismjorism libDAI: File Members
Here is a list of all documented file members with links to the documentation:
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1WeightedGraph-members.html0000644000175000017500000000515512552201370023110 0ustar jorismjorism libDAI: Member List
dai::WeightedGraph< T > Member List

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

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_51.png0000644000175000017500000000034312552200227015654 0ustar jorismjorism‰PNG  IHDR —™'n0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïRIDATxíÑ À OAŒÄÖý·­bÓ4ýé„p0ÀŸLͪ=­f†´Š‰Èê3ŒY¤»7Ñ÷¸LÍs¼¢‹(±Å[Øž6žIáNàëË7.j•2†¶OÒIEND®B`‚libDAI-0.3.2/doc/html/mr_8h.html0000644000175000017500000001277712552201363015621 0ustar jorismjorism libDAI: include/dai/mr.h File Reference
Classes | Namespaces
mr.h File Reference

Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo. More...

#include <dai/dai_config.h>
#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.

Classes

class  dai::MR
 Approximate inference algorithm by Montanari and Rizzo [MoR05]. More...
 
struct  dai::MR::Properties
 Parameters for MR. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class MR, which implements loop corrections as proposed by Montanari and Rizzo.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/emalg_8h.html0000644000175000017500000001664212552201363016263 0ustar jorismjorism libDAI: include/dai/emalg.h File Reference
Classes | Namespaces
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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

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

Todo:
Implement parameter estimation for undirected models / factor graphs.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_20.png0000644000175000017500000000144012552200220015640 0ustar jorismjorism‰PNG  IHDR|$|®0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIDATxíé’Û „?@t`Þÿm3œBi­¬½•ªPjËÍô =þ5¨ àG Ü¾üür€wc$7Þûñx)Fr=Çç<|ŒÛ ðRœe·1VÚàëÐÇv×0ÛnƯ7äêøÓG=fÕ·8Û%¯7D¤€+¨$ñsr½í¶qµI‘ßÓí!Ëý©Ý/s_`8Áô IâUÈÃ)À´%€g¸!º‡qQ…}ñ(SÑ EŒy +~KšËnžâ’\-qm‘ï)ÓuÖ©ÜjA˜h'·Èòo*FµåM‡Rn)㶯#×yîŒD¢^œýµiu_ÕðMíò@ØK}Tr`¸tèãsòD$÷$o"ÂGÉÃ#ÇÜÈCK¾+“-–Z¬ä¦ªgŸ“û¬TÖ«>=}4rÉv}9“®nŽùÅZ¶Ø×Q»Àéº&Y¾mŠbÒ"‚hÏT–õùçi­ ”(9ÙË#& Nµpƒkò2Í÷Ty»ó{ÊÑ¢G6˜Ò”¾åGÓmØW7ÙÐýëºÚóY)ašHs^3ÿû9>ŽþÙí€ášò9ò:œÈUý31ù¶0òÅcŠJk·"Ý_s$’¥¦³ì'ßJ‡‰^õ¿ö9ºÒŠ^óyÏõ„®÷ø[x§ì2ȾIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1TRWBP.html0000644000175000017500000026436112552201370017642 0ustar jorismjorism libDAI: dai::TRWBP Class Reference
Public Attributes | Protected Attributes | List of all members
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

Public Member Functions

Constructors/destructors
 TRWBP ()
 Default constructor. More...
 
 TRWBP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
General InfAlg interface
virtual TRWBP * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual TRWBP * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
virtual void setProperties (const PropertySet &opts)
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
- Public Member Functions inherited from dai::BP
 BP ()
 Default constructor. More...
 
 BP (const FactorGraph &fg, const PropertySet &opts)
 Construct from FactorGraph fg and PropertySet opts. More...
 
 BP (const BP &x)
 Copy constructor. More...
 
BP & operator= (const BP &x)
 Assignment operator. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
std::vector< size_t > findMaximum () const
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &ns)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setMaxIter (size_t maxiter)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 
const std::vector< std::pair< size_t, size_t > > & getSentMessages () const
 Returns history of which messages have been updated. More...
 
void clearSentMessages ()
 Clears history of which messages have been updated. More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 

Public Attributes

size_t nrtrees
 Size of sample of trees used to set the weights. More...
 
- Public Attributes inherited from dai::BP
struct dai::BP::Properties props
 
bool recordSentMessages
 Specifies whether the history of message updates should be recorded. More...
 

Protected Attributes

std::vector< Real > _weight
 "Edge weights" (indexed by factor ID) More...
 
- Protected Attributes inherited from dai::BP
std::vector< std::vector< EdgeProp > > _edges
 Stores all edge properties. More...
 
std::vector< std::vector< LutType::iterator > > _edge2lut
 Lookup table (only used for maximum-residual BP) More...
 
LutType _lut
 Lookup table (only used for maximum-residual BP) More...
 
Real _maxdiff
 Maximum difference between variable beliefs encountered so far. More...
 
size_t _iters
 Number of iterations needed. More...
 
std::vector< std::pair< size_t, size_t > > _sentMessages
 The history of message updates (only recorded if recordSentMessages is true) More...
 
std::vector< Factor > _oldBeliefsV
 Stores variable beliefs of previous iteration. More...
 
std::vector< Factor > _oldBeliefsF
 Stores factor beliefs of previous iteration. More...
 
std::vector< Edge > _updateSeq
 Stores the update schedule. More...
 

TRWBP accessors/mutators for scale parameters

Real Weight (size_t I) const
 Returns weight corresponding to the I 'th factor. More...
 
const std::vector< Real > & Weights () const
 Returns constant reference to vector of all weights. More...
 
void setWeight (size_t I, Real c)
 Sets the weight of the I 'th factor to c. More...
 
void setWeights (const std::vector< Real > &c)
 Sets the weights of all factors simultaenously. More...
 
void addTreeToWeights (const RootedTree &tree)
 Increases weights corresponding to pairwise factors in tree with 1. More...
 
void sampleWeights (size_t nrTrees)
 Samples weights from a sample of nrTrees random spanning trees. More...
 
virtual Prob calcIncomingMessageProduct (size_t I, bool without_i, size_t i) const
 Calculate the product of factor I and the incoming messages. More...
 
virtual void calcBeliefV (size_t i, Prob &p) const
 Calculates unnormalized belief of variable i. More...
 
virtual void calcBeliefF (size_t I, Prob &p) const
 Calculates unnormalized belief of factor I. More...
 
virtual void construct ()
 Helper function for constructors. More...
 

Additional Inherited Members

- Protected Types inherited from dai::BP
typedef std::vector< size_t > ind_t
 Type used for index cache. More...
 
typedef std::multimap< Real, std::pair< size_t, size_t > > LutType
 Type of lookup table (only used for maximum-residual BP) More...
 
- Protected Member Functions inherited from dai::BP
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. More...
 
Prob & message (size_t i, size_t _I)
 Returns reference to message from the _I 'th neighbor of variable i to variable i. More...
 
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. More...
 
Prob & newMessage (size_t i, size_t _I)
 Returns reference to updated message from the _I 'th neighbor of variable i to variable i. More...
 
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. More...
 
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. More...
 
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. More...
 
Real & residual (size_t i, size_t _I)
 Returns reference to residual for the edge between variable i and its _I 'th neighbor. More...
 
virtual void calcNewMessage (size_t i, size_t _I)
 Calculate the updated message from the _I 'th neighbor of variable i to variable i. More...
 
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. More...
 
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. More...
 
void findMaxResidual (size_t &i, size_t &_I)
 Finds the edge which has the maximum residual (difference between new and old message) More...
 

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
fgFactor graph.
optsParameters
See also
BP::Properties.

Member Function Documentation

virtual TRWBP* dai::TRWBP::clone ( ) const
inlinevirtual

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

Reimplemented from dai::BP.

virtual TRWBP* dai::TRWBP::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Reimplemented from dai::BP.

virtual std::string dai::TRWBP::name ( ) const
inlinevirtual

Returns the name of the algorithm.

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_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::BP.

void dai::TRWBP::setProperties ( const PropertySet &  opts)
virtual
Todo:
Make DAI_BP_FAST a compile-time choice, as it is a memory/speed tradeoff

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
protectedvirtual

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
protectedvirtual

Calculates unnormalized belief of variable i.

Reimplemented from dai::BP.

virtual void dai::TRWBP::calcBeliefF ( size_t  I,
Prob &  p 
) const
inlineprotectedvirtual

Calculates unnormalized belief of factor I.

Reimplemented from dai::BP.

void dai::TRWBP::construct ( )
protectedvirtual

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)
The documentation for this class was generated from the following files:
  • include/dai/trwbp.h
  • src/trwbp.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1DAIAlg-members.html0000644000175000017500000003137312552201365021414 0ustar jorismjorism 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 >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const Var &v) const dai::InfAlginlinevirtual
belief(const VarSet &vs) const =0dai::InfAlgpure virtual
beliefF(size_t I) const dai::InfAlginlinevirtual
beliefs() const =0dai::InfAlgpure virtual
beliefV(size_t i) const dai::InfAlginlinevirtual
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clone() const =0dai::InfAlgpure virtual
construct(const FactorGraph &fg, const PropertySet &opts) const =0dai::InfAlgpure virtual
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findMaximum() const dai::InfAlginlinevirtual
getProperties() const =0dai::InfAlgpure virtual
identify() const dai::InfAlginlinevirtual
init()=0dai::InfAlgpure virtual
init(const VarSet &vs)=0dai::InfAlgpure virtual
Iterations() const dai::InfAlginlinevirtual
logZ() const =0dai::InfAlgpure virtual
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::InfAlginlinevirtual
name() const =0dai::InfAlgpure virtual
printProperties() const =0dai::InfAlgpure virtual
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()=0dai::InfAlgpure virtual
setMaxIter(size_t)dai::InfAlginlinevirtual
setProperties(const PropertySet &opts)=0dai::InfAlgpure virtual
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1MF.png0000644000175000017500000000151312552201366017057 0ustar jorismjorism‰PNG  IHDR«ˆ¯ë³PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2ÚIDATxíᎃ ‡¤ïÿÈgEqQÛ^ë¶J²Föq\þ%çœ;,I]®’äO¸J’?G]Ó6Zš”Ƹ4˜fIú?ׇú©Ô'»i»¤1}6¯Cûý:§µºN7HÒqu& )ÙR£Úmz$éºÎišÅL¼ïzb^ç5ð̵t_ÃÕŠm]ë!pºk»^ÿázÖzµçÀÙ²çzâ9 IoÓ‹ë‰ëU’Þcúu¤øù¤ WIò'\%ÉŸÁ5çœûÀŸ@'täz»õ#Û‘ë ÚlO®q|ƒpð'\ü WÂÀŸpð'\ü WÂÀŸpð'\ü W•œsî²$uA¸J’?á*Iþ4®i¥û_Ó¸½JjÊxϦkÛ°3èÁЧ®mÓ,¶üccIjø_ëÛ×á%ïcÊË.yµóîºN÷í=jJÜX-—r·ý†µgM%©)Õu?=]J¦HJ™î+Ò­ë2ÂL6½žu5c– ë$Ë@ë:÷Û™þãZŸ¿¿ÆÛYšoؼÖê]ö]Ësö\'ƒU¼óÍšùÌÕDËÐkµ]»šªuµÁ:^çu»^¹nŸþ"¯«7kwë×÷׫ٗ­k;îÑzµç@Ù™ÓÝuï:–=nÏÓ[×@9Ú¼KZŠËïÖƒóP’ÞãùD‡]ä@’ÞçË®ów•¤Ã|ÛU’~C¸J’?á*Iþ ®9çÜþÜ:¡#×Û­ÙŽ\Õnd{rsà„+€?á àO¸ø®þ„+€?á àO¸ø®þ„+€?á àO¸ø®¤”R'º \ü Wœ\—Ij4C=íb€#¸»š³°VNŸÎÃu:øJê–¼^ÑuüÈE()¥åj®ó$Ö˺º,WO×"d÷ÖœÔËåÕT—vm×ë*ÝW=L&¯é ð ÂÀŸpð'\üéÌ5¥”úàö(E0¯˜Ì+IEND®B`‚libDAI-0.3.2/doc/html/functions_s.html0000644000175000017500000003234212552201370017122 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- s -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1GraphAL-members.html0000644000175000017500000002351712552201366021653 0ustar jorismjorism libDAI: Member List
dai::GraphAL Member List

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

_nbdai::GraphALprivate
addEdge(size_t n1, size_t n2, bool check=true)dai::GraphAL
addNode()dai::GraphALinline
addNode(NodeInputIterator begin, NodeInputIterator end, size_t sizeHint=0)dai::GraphALinline
checkConsistency() const dai::GraphAL
construct(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::GraphAL
eraseEdge(size_t n1, size_t n2)dai::GraphAL
eraseNode(size_t n)dai::GraphAL
findNb(size_t n1, size_t n2)dai::GraphALinline
GraphAL()dai::GraphALinline
GraphAL(size_t nr)dai::GraphALinline
GraphAL(size_t nr, EdgeInputIterator begin, EdgeInputIterator end, bool check=true)dai::GraphALinline
hasEdge(size_t n1, size_t n2) const dai::GraphALinline
isConnected() const dai::GraphAL
isTree() const dai::GraphAL
nb(size_t n1, size_t _n2) const dai::GraphALinline
nb(size_t n1, size_t _n2)dai::GraphALinline
nb(size_t n) const dai::GraphALinline
nb(size_t n)dai::GraphALinline
nbSet(size_t n) const dai::GraphAL
nrEdges() const dai::GraphALinline
nrNodes() const dai::GraphALinline
operator<<(std::ostream &os, const GraphAL &g)dai::GraphALfriend
operator==(const GraphAL &x) const dai::GraphALinline
printDot(std::ostream &os) const dai::GraphAL
toString() const dai::GraphALinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_86.png0000644000175000017500000000050312552200236015662 0ustar jorismjorism‰PNG  IHDR. *80PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï²IDATxíKÄ D[D dÔûßvÀßd‘ý¬¨P 4ðÌ àÎwgîàÕc<µÒý¤À›³ˆj<òÊžÓkW 'ʹÌ8íÂÚS³i¨ïþ’lO5m›ñ à÷e\jò0_àXjíÈ“ŽÚåæcŠ"ÁG.3)Ùd]0wp;èˆ ¾§ˆw¥ëó‡Åê–?èHû±Lã™ :ÛySBE”.´§/ libDAI: Class Members - Functions
 

- ~ -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_3.png0000644000175000017500000000030612552200214015564 0ustar jorismjorism‰PNG  IHDR ƒw·¬0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï5IDATxíÁ â*èuÿmw~Ä …´d€g‹Yõq!Êá(î>‚ÿz›r'íX8qÞ tIEND®B`‚libDAI-0.3.2/doc/html/createfg_8h.html0000644000175000017500000002465712552201363016763 0ustar jorismjorism libDAI: include/dai/createfg.h File Reference
Namespaces | Functions
createfg.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

 dai
 Namespace for libDAI.
 

Functions

 dai::DAI_ENUM (FactorType, ISINGGAUSS, ISINGUNIFORM, EXPGAUSS, POTTS)
 Possible factor types. More...
 
FactorGraph dai::createFG (const GraphAL &G, FactorType ft, size_t states, const PropertySet &props)
 Creates a factor graph from a pairwise interactions graph. More...
 
FactorGraph dai::createHOIFG (size_t N, size_t M, size_t k, Real beta)
 Return a random factor graph with higher-order interactions. More...
 
BipartiteGraph dai::createRandomBipartiteGraph (size_t N1, size_t N2, size_t d1, size_t d2)
 Creates a regular random bipartite graph. More...
 
int dai::powmod (int x, int n, int p)
 Returns x**n % p, assuming p is prime. More...
 
size_t dai::order (int x, int p)
 Returns order of x in GF(p) with p prime. More...
 
bool dai::isPrime (size_t n)
 Returns whether n is a prime number. More...
 
BipartiteGraph dai::createSmallLDPCGraph ()
 Constructs a regular LDPC graph with N=6, j=2, K=4, k=3. More...
 
BipartiteGraph dai::createGroupStructuredLDPCGraph (size_t p, size_t j, size_t k)
 Creates group-structured LDPC code. More...
 
void dai::createParityCheck (Real *result, size_t n, Real eps)
 

Detailed Description

Provides functionality for input/output of data structures in various file formats.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_49.png0000644000175000017500000000034212552200226015661 0ustar jorismjorism‰PNG  IHDR —™'n0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïQIDATxík €0 ƒ³õņ’ûßÖuÅ_ž ¤Òô ð·®îájeDºÍ`¶;qÔݹÙ1#£†bÚbYS¼ Ú2¢JðʘO¾se&F÷r÷˜IEND®B`‚libDAI-0.3.2/doc/html/gibbs_8h.html0000644000175000017500000000552112552201363016256 0ustar jorismjorism libDAI: include/dai/gibbs.h File Reference
gibbs.h File Reference

Defines class Gibbs, which implements Gibbs sampling. More...

#include <dai/dai_config.h>

Go to the source code of this file.

Detailed Description

Defines class Gibbs, which implements Gibbs sampling.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/exceptions_8h.html0000644000175000017500000003664112552201363017360 0ustar jorismjorism libDAI: include/dai/exceptions.h File Reference
Classes | Namespaces | Macros
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.

Classes

class  dai::Exception
 Error handling in libDAI is done by throwing an instance of the Exception class. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Macros

#define DAI_QUOTE(x)   #x
 Used by DAI_THROW. More...
 
#define DAI_TOSTRING(x)   DAI_QUOTE(x)
 Used by DAI_THROW. More...
 
#define FUNCTION_NAME   __func__
 Macro that simplifies throwing an exception with a useful default error message. More...
 
#define DAI_THROW(cod)   throw dai::Exception(dai::Exception::cod, __FILE__, FUNCTION_NAME, DAI_TOSTRING(__LINE__), "")
 
#define DAI_THROWE(cod, msg)   throw dai::Exception(dai::Exception::cod, __FILE__, FUNCTION_NAME, DAI_TOSTRING(__LINE__), msg)
 Macro that simplifies throwing an exception with a user-defined error message. More...
 
#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. More...
 
#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. More...
 

Detailed Description

Defines the Exception class and macros for throwing exceptions and doing assertions.

Macro Definition Documentation

#define DAI_QUOTE (   x)    #x

Used by DAI_THROW.

#define DAI_TOSTRING (   x)    DAI_QUOTE(x)

Used by DAI_THROW.

#define FUNCTION_NAME   __func__

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
codCorresponds to one of the enum values of dai::Exception::Code
Example:
1 DAI_THROW(NOT_IMPLEMENTED);
#define DAI_THROWE (   cod,
  msg 
)    throw dai::Exception(dai::Exception::cod, __FILE__, FUNCTION_NAME, DAI_TOSTRING(__LINE__), msg)

Macro that simplifies throwing an exception with a user-defined error message.

Parameters
codCorresponds to one of the enum values of dai::Exception::Code
msgDetailed error message that will be written to std::cerr.
Example:
1 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/dot_inline_dotgraph_2.png0000644000175000017500000000731312552201363020647 0ustar jorismjorism‰PNG  IHDRD`+LCÅbKGDÿÿÿ ½§“€IDATxœÝ\kPW>†»$Úp+‚†K±¥ÑqZJêL™±¥„ÚÃС •@[d¸Û逽¹ÔX‹`@+ÅV¥P) -„BcÂ%`¸$P ·ÝïÇZäSØl²¿™ïùEvßó¼ç9{Îîûž ›`ÿ/07)ûòòòüü¼\.W©T …L&“ÉdÓ¹#^ÌÂÂBCCƒP(ØØØ8::R( ‹……¹\.“Éë‘‘‘Ï=÷±®7Ø͆‡‡Ïž=kooíçç‡b¹¸¸ØØØØßßôöÛo“H$bjååå‚‚‚’’’••ƒ vuu¥§§÷ôôR ÄŒ§¤¤ŒW‚ “'OÖÖÖ⯠^1 ©©©ËËË8yÎ;÷ã?â$Á+&++kff' ‚ãÇ‹D"< ¸FÞÐп¿¿““ŠÍï¿ÿ^]]}êÔ©öövt¶ÌÌÌï¾ûO}p=™‚‚½#~çÎÃÃÃ|>?00P/ann®V«5º>¸ž AVVVè6ÃÃÃîîî###z étºX,6º>¦~~~‰†ágŸ}V¯1…B‘ËåFû2¹˜âââŸþÙÞÞþ‹/¾Ðk,BBBŒö…KŒ··w?ƒÁ@± ÃH855…'xÃ5f99i4Odd¤ €F£MMM̓«›!Ë`4Íf»¸¸ÍSQQáïïb™øÜF7 Ã>>>4Ù¹\¾wï^À—_~i4‰þ1A@  …ÈR«¥¥%™Lvvv¦Ñh³³³•••QQQÆ·å¿ “É×®]‹ˆˆèééáñx‰d~~^©TÚØØP(Æ`0¶lÙ‚N²aÚ,—Ë/^¼(‰ÌÌÌ|}}ét:…B¡P(F.—ÏÌÌtuu »¹¹½üòËáááfffxĈD¢úúú¹¹9©TùÌ3Ï î”J¥\.Ÿœœìëë[\\´°°xã7‚‚‚°Š™™™)))±¶¶Ž¥Óéè•Ðét­­­¿üòK@@@BB‚’«ªªètzll¬Þi¥¥¥K—.uwwGFF®3ëûH·ûþûïóóóçææ í¯<Åb c/¢Ñh8NYY™Z­6Ô]CCCffæÂÂÂÚ‹Å@TXXøÓO?Ê»¶rùùù---XŒ Ejj*ŸÏ7ÚÝìì,‹ÅZ»røPÌW_}ÕÕÕe4õ*8Îàà ºN§;|øðôô4N_jµšÅb) äç1½½½gÎœÁI@«Õ²X,N‡bsæÌ™ÞÞ^BÜMOOçææ"?øhž?þÝwßE|CCCXVZÌÌÌbcc›šš62Ðjµ"‘hçÎè>Žt+@,{yyémr ½6«@ ¢‡‡‡ÑwÖ¬­­©T*Çc³Ùz}¹»»OMMSÌ›™L&‹³³³a̳á$ÀÖ­[E"‘^S@Àb € h£[¾¾¾|>½øÊÊJrr²P(LII¹wïºñÄÄă0évl6[¥RazÑÖÖvåÊ•îjµÚ>úˆ(_0 !«óºÙ;ï¼söìY,M®:ŽËåîß¿#333//¯ÞÞ^BÜMOO+•JWWWÖ¼JJJ:::ð·SAAÁ_ý…nAÐáÇ¥R)N_*•*%%E©T"?ÿëUËápPº‡^¨ÕêÜÜÜÖÖV,ÆJ¥’Åbé•‚éééÔÔT±X¼zåÑïÆ?ü——7;;k(uww7‹ÅÁ^D«Õ~òÉ'ß|ó¡Ã‚ úúz6›½È X'˜---577?pà€Þ‚N§»~ýzmmmxxx||¼s4CCC•••^^^qqqO=õº1²¹³§§'***44ô‘»&g \.÷ï¿ÿ633£Óé>>> …J¥ªÕj™L633Ó×ׇd áááÈ•ÔÔTC•¬bll¬®®N&“YYYíرÃÓÓq§P(d2™D"éïï_ZZ²´´ŒŠŠÚhÛ­þZ†GFF„B¡L&ëììôóósuuuvvÞ±c‡££ãªYss3ŸÏÏÌÌ4ZFs÷î]‰D"“ÉnÞ¼ùâ‹/R©Ô§Ÿ~šÁ`ØÚÚê)lPg-))A‰Û¯^½ZTTd!:òòò ²'2œ‰ˆˆØ½{÷‰'ä4Çf¡¡¡¡¡¡‡XZŒ >Ð ûøãá'~dÂ$Qó /¼sìØ1”pÓ0U ›““ó$õ˜0Ÿ JHHÈÊÊÒjµ¦ó²¦MÎüýý:”­ÑhLêÉ3M__ßôôô£GªT*Sûzi³——›Íf³Ù+++&uô„æ<==³³³322MçåÉMhxxx?~<;;[©TšÊÆ°gbbÂ×××ÏÏÁ`ìÛ·Ïà0ë_H¥Ò”””G&¼Gmm­ŸŸŸƒÁ8räFrÍ]»v!ú:„½ÔãÉdÉÉÉHú0??¿®T*ussXYYa?$d€ds•JÀ^j]Èåòää䦦&WWW@°®ÍK/½ð÷÷×h4i #œœœöìÙƒ½ ÚÚÚ¶ŠŠZ× ¸¸˜D"ÅÅÅaç4,Ÿa0l6Û "ëbeeÅÃÃé´4m݇#—Ë)Êo¿ý†VO¦©Õjy<žX,Þ´iSww·ŸŸŸ½½=‰D d2™îîîƽx¤R)‡Ã¹qãÆÈÈÈ›o¾‰l‹XZZº}û6Ç›››´¶¶"ë›7of2™èg8ÖAPKKKkk«¹¹9ƒÁxþùç½½½×¨Õêþþþ[·n‰D"2™|àÀ½«Ÿëb~~¾°°°®®.;;{rrÒÞÞ~×®]L&ó‘]Ï …¢··÷Ö­[333žžžqqqë®~®#¦µµõòåËû÷ïǸ†àr¹è–:Ù¸kpqqÁ²3²¼¼ÜÎÎîóÏ?×k‰¶Þèn@@À;wÐINŸ> ÈÊÊŠ‰‰A·Ú¶mÿ~4 ;Ë·.Î;‡þ)ÄžoaANNr,òÁÛ,))éäÉ“z› d2ÙíÛ·ƒƒƒQl""".\¸@ˆ»ÞÞ^—««ú®]»V^^Ž³‘–——Y,–‡\TTôÇàt7>>~äÈ‘Õs·ÿ›566ž8q}C $ öÿ AÐgŸ}VWWgœ/†»ºº233—––V¯<šœ ¤§§”Á0¬R©JKKóòòÖRcASSSff¦A˺0 ÏÌÌäçç—••=r}†a.—ûçŸúûûÇÄÄ888 tY>ŸßÐРP(õ®æ®‹•••òòr‰Dòꫯ¢l7‚a¸³³óêÕ«ÖÖÖ,ëñ=Z¦Éçó/]º„LÛ‘Éd*•êàà Õje2™L&[^^lÛ¶-::]0À0ÜÑÑÑÒÒ¢ÕjI$•J¥R©¶¶¶+++ˆ;F³iӦݻwGDDl$ë Z¥R)“É}ÍÈ:0öãXFñ5??ogg‡¸ÃF™ê8ðÿÿÅ ¶3ª‡‚sIEND®B`‚libDAI-0.3.2/doc/html/factor_8h_source.html0000644000175000017500000044335012552201363020034 0ustar jorismjorism libDAI: include/dai/factor.h Source File
factor.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_factor_h
14 #define __defined_libdai_factor_h
15 
16 
17 #include <iostream>
18 #include <functional>
19 #include <cmath>
20 #include <dai/prob.h>
21 #include <dai/varset.h>
22 #include <dai/index.h>
23 #include <dai/util.h>
24 
25 
26 namespace dai {
27 
28 
30 
54 template <typename T>
55 class TFactor {
56  private:
58  VarSet _vs;
60  TProb<T> _p;
61 
62  public:
64 
65  TFactor ( T p = 1 ) : _vs(), _p(1,p) {}
67 
69  TFactor( const Var &v ) : _vs(v), _p(v.states()) {}
70 
72  TFactor( const VarSet& vars ) : _vs(vars), _p() {
73  _p = TProb<T>( BigInt_size_t( _vs.nrStates() ) );
74  }
75 
77  TFactor( const VarSet& vars, T p ) : _vs(vars), _p() {
78  _p = TProb<T>( BigInt_size_t( _vs.nrStates() ), p );
79  }
80 
82 
86  template<typename S>
87  TFactor( const VarSet& vars, const std::vector<S> &x ) : _vs(vars), _p() {
88  DAI_ASSERT( (BigInt)x.size() == vars.nrStates() );
89  _p = TProb<T>( x.begin(), x.end(), x.size() );
90  }
91 
93 
96  TFactor( const VarSet& vars, const T* p ) : _vs(vars), _p() {
97  size_t N = BigInt_size_t( _vs.nrStates() );
98  _p = TProb<T>( p, p + N, N );
99  }
100 
102  TFactor( const VarSet& vars, const TProb<T> &p ) : _vs(vars), _p(p) {
103  DAI_ASSERT( _vs.nrStates() == (BigInt)_p.size() );
104  }
105 
107  TFactor( const std::vector<Var> &vars, const std::vector<T> &p ) : _vs(vars.begin(), vars.end(), vars.size()), _p(p.size()) {
108  BigInt nrStates = 1;
109  for( size_t i = 0; i < vars.size(); i++ )
110  nrStates *= vars[i].states();
111  DAI_ASSERT( nrStates == p.size() );
112  Permute permindex(vars);
113  for( size_t li = 0; li < p.size(); ++li )
114  _p.set( permindex.convertLinearIndex(li), p[li] );
115  }
117 
119 
120  void set( size_t i, T val ) { _p.set( i, val ); }
122 
124  T get( size_t i ) const { return _p[i]; }
126 
128 
129  const TProb<T>& p() const { return _p; }
131 
133  TProb<T>& p() { return _p; }
134 
136  T operator[] (size_t i) const { return _p[i]; }
137 
139  const VarSet& vars() const { return _vs; }
140 
142  VarSet& vars() { return _vs; }
143 
145 
147  size_t nrStates() const { return _p.size(); }
148 
150  T entropy() const { return _p.entropy(); }
151 
153  T max() const { return _p.max(); }
154 
156  T min() const { return _p.min(); }
157 
159  T sum() const { return _p.sum(); }
160 
162  T sumAbs() const { return _p.sumAbs(); }
163 
165  T maxAbs() const { return _p.maxAbs(); }
166 
168  bool hasNaNs() const { return _p.hasNaNs(); }
169 
171  bool hasNegatives() const { return _p.hasNegatives(); }
172 
174  T strength( const Var &i, const Var &j ) const;
175 
177  bool operator==( const TFactor<T>& y ) const {
178  return (_vs == y._vs) && (_p == y._p);
179  }
180 
182  std::string toString() const {
183  std::stringstream ss;
184  ss << *this;
185  return ss.str();
186  }
188 
190 
191  TFactor<T> operator- () const {
193  // Note: the alternative (shorter) way of implementing this,
194  // return TFactor<T>( _vs, _p.abs() );
195  // is slower because it invokes the copy constructor of TProb<T>
196  TFactor<T> x;
197  x._vs = _vs;
198  x._p = -_p;
199  return x;
200  }
201 
203  TFactor<T> abs() const {
204  TFactor<T> x;
205  x._vs = _vs;
206  x._p = _p.abs();
207  return x;
208  }
209 
211  TFactor<T> exp() const {
212  TFactor<T> x;
213  x._vs = _vs;
214  x._p = _p.exp();
215  return x;
216  }
217 
219 
221  TFactor<T> log(bool zero=false) const {
222  TFactor<T> x;
223  x._vs = _vs;
224  x._p = _p.log(zero);
225  return x;
226  }
227 
229 
231  TFactor<T> inverse(bool zero=true) const {
232  TFactor<T> x;
233  x._vs = _vs;
234  x._p = _p.inverse(zero);
235  return x;
236  }
237 
239 
241  TFactor<T> normalized( ProbNormType norm=NORMPROB ) const {
242  TFactor<T> x;
243  x._vs = _vs;
244  x._p = _p.normalized( norm );
245  return x;
246  }
248 
250 
251  TFactor<T>& randomize() { _p.randomize(); return *this; }
253 
255  TFactor<T>& setUniform() { _p.setUniform(); return *this; }
256 
258  TFactor<T>& takeAbs() { _p.takeAbs(); return *this; }
259 
261  TFactor<T>& takeExp() { _p.takeExp(); return *this; }
262 
264 
266  TFactor<T>& takeLog( bool zero = false ) { _p.takeLog(zero); return *this; }
267 
269 
271  T normalize( ProbNormType norm=NORMPROB ) { return _p.normalize( norm ); }
273 
275 
276  TFactor<T>& fill (T x) { _p.fill( x ); return *this; }
278 
280  TFactor<T>& operator+= (T x) { _p += x; return *this; }
281 
283  TFactor<T>& operator-= (T x) { _p -= x; return *this; }
284 
286  TFactor<T>& operator*= (T x) { _p *= x; return *this; }
287 
289  TFactor<T>& operator/= (T x) { _p /= x; return *this; }
290 
292  TFactor<T>& operator^= (T x) { _p ^= x; return *this; }
294 
296 
297  TFactor<T> operator+ (T x) const {
299  // Note: the alternative (shorter) way of implementing this,
300  // TFactor<T> result(*this);
301  // result._p += x;
302  // is slower because it invokes the copy constructor of TFactor<T>
303  TFactor<T> result;
304  result._vs = _vs;
305  result._p = p() + x;
306  return result;
307  }
308 
310  TFactor<T> operator- (T x) const {
311  TFactor<T> result;
312  result._vs = _vs;
313  result._p = p() - x;
314  return result;
315  }
316 
318  TFactor<T> operator* (T x) const {
319  TFactor<T> result;
320  result._vs = _vs;
321  result._p = p() * x;
322  return result;
323  }
324 
326  TFactor<T> operator/ (T x) const {
327  TFactor<T> result;
328  result._vs = _vs;
329  result._p = p() / x;
330  return result;
331  }
332 
334  TFactor<T> operator^ (T x) const {
335  TFactor<T> result;
336  result._vs = _vs;
337  result._p = p() ^ x;
338  return result;
339  }
341 
343 
344 
349  template<typename binOp> TFactor<T>& binaryOp( const TFactor<T> &g, binOp op ) {
350  if( _vs == g._vs ) // optimize special case
351  _p.pwBinaryOp( g._p, op );
352  else {
353  TFactor<T> f(*this); // make a copy
354  _vs |= g._vs;
355  size_t N = BigInt_size_t( _vs.nrStates() );
356 
357  IndexFor i_f( f._vs, _vs );
358  IndexFor i_g( g._vs, _vs );
359 
360  _p.p().clear();
361  _p.p().reserve( N );
362  for( size_t i = 0; i < N; i++, ++i_f, ++i_g )
363  _p.p().push_back( op( f._p[i_f], g._p[i_g] ) );
364  }
365  return *this;
366  }
367 
369 
373  TFactor<T>& operator+= (const TFactor<T>& g) { return binaryOp( g, std::plus<T>() ); }
374 
376 
380  TFactor<T>& operator-= (const TFactor<T>& g) { return binaryOp( g, std::minus<T>() ); }
381 
383 
387  TFactor<T>& operator*= (const TFactor<T>& g) { return binaryOp( g, std::multiplies<T>() ); }
388 
390 
394  TFactor<T>& operator/= (const TFactor<T>& g) { return binaryOp( g, fo_divides0<T>() ); }
396 
398 
399 
404  template<typename binOp> TFactor<T> binaryTr( const TFactor<T> &g, binOp op ) const {
405  // Note that to prevent a copy to be made, it is crucial
406  // that the result is declared outside the if-else construct.
407  TFactor<T> result;
408  if( _vs == g._vs ) { // optimize special case
409  result._vs = _vs;
410  result._p = _p.pwBinaryTr( g._p, op );
411  } else {
412  result._vs = _vs | g._vs;
413  size_t N = BigInt_size_t( result._vs.nrStates() );
414 
415  IndexFor i_f( _vs, result.vars() );
416  IndexFor i_g( g._vs, result.vars() );
417 
418  result._p.p().clear();
419  result._p.p().reserve( N );
420  for( size_t i = 0; i < N; i++, ++i_f, ++i_g )
421  result._p.p().push_back( op( _p[i_f], g[i_g] ) );
422  }
423  return result;
424  }
425 
427 
431  TFactor<T> operator+ (const TFactor<T>& g) const {
432  return binaryTr(g,std::plus<T>());
433  }
434 
436 
440  TFactor<T> operator- (const TFactor<T>& g) const {
441  return binaryTr(g,std::minus<T>());
442  }
443 
445 
449  TFactor<T> operator* (const TFactor<T>& g) const {
450  return binaryTr(g,std::multiplies<T>());
451  }
452 
454 
458  TFactor<T> operator/ (const TFactor<T>& g) const {
459  return binaryTr(g,fo_divides0<T>());
460  }
462 
464 
465 
477  TFactor<T> slice( const VarSet& vars, size_t varsState ) const;
478 
480 
485  TFactor<T> embed(const VarSet & vars) const {
486  DAI_ASSERT( vars >> _vs );
487  if( _vs == vars )
488  return *this;
489  else
490  return (*this) * TFactor<T>(vars / _vs, (T)1);
491  }
492 
494  TFactor<T> marginal(const VarSet &vars, bool normed=true) const;
495 
497  TFactor<T> maxMarginal(const VarSet &vars, bool normed=true) const;
499 };
500 
501 
502 template<typename T> TFactor<T> TFactor<T>::slice( const VarSet& vars, size_t varsState ) const {
503  DAI_ASSERT( vars << _vs );
504  VarSet varsrem = _vs / vars;
505  TFactor<T> result( varsrem, T(0) );
506 
507  // OPTIMIZE ME
508  IndexFor i_vars (vars, _vs);
509  IndexFor i_varsrem (varsrem, _vs);
510  for( size_t i = 0; i < nrStates(); i++, ++i_vars, ++i_varsrem )
511  if( (size_t)i_vars == varsState )
512  result.set( i_varsrem, _p[i] );
513 
514  return result;
515 }
516 
517 
518 template<typename T> TFactor<T> TFactor<T>::marginal(const VarSet &vars, bool normed) const {
519  VarSet res_vars = vars & _vs;
520 
521  TFactor<T> res( res_vars, 0.0 );
522 
523  IndexFor i_res( res_vars, _vs );
524  for( size_t i = 0; i < _p.size(); i++, ++i_res )
525  res.set( i_res, res[i_res] + _p[i] );
526 
527  if( normed )
528  res.normalize( NORMPROB );
529 
530  return res;
531 }
532 
533 
534 template<typename T> TFactor<T> TFactor<T>::maxMarginal(const VarSet &vars, bool normed) const {
535  VarSet res_vars = vars & _vs;
536 
537  TFactor<T> res( res_vars, 0.0 );
538 
539  IndexFor i_res( res_vars, _vs );
540  for( size_t i = 0; i < _p.size(); i++, ++i_res )
541  if( _p[i] > res._p[i_res] )
542  res.set( i_res, _p[i] );
543 
544  if( normed )
545  res.normalize( NORMPROB );
546 
547  return res;
548 }
549 
550 
551 template<typename T> T TFactor<T>::strength( const Var &i, const Var &j ) const {
552  DAI_DEBASSERT( _vs.contains( i ) );
553  DAI_DEBASSERT( _vs.contains( j ) );
554  DAI_DEBASSERT( i != j );
555  VarSet ij(i, j);
556 
557  T max = 0.0;
558  for( size_t alpha1 = 0; alpha1 < i.states(); alpha1++ )
559  for( size_t alpha2 = 0; alpha2 < i.states(); alpha2++ )
560  if( alpha2 != alpha1 )
561  for( size_t beta1 = 0; beta1 < j.states(); beta1++ )
562  for( size_t beta2 = 0; beta2 < j.states(); beta2++ )
563  if( beta2 != beta1 ) {
564  size_t as = 1, bs = 1;
565  if( i < j )
566  bs = i.states();
567  else
568  as = j.states();
569  T f1 = slice( ij, alpha1 * as + beta1 * bs ).p().divide( slice( ij, alpha2 * as + beta1 * bs ).p() ).max();
570  T f2 = slice( ij, alpha2 * as + beta2 * bs ).p().divide( slice( ij, alpha1 * as + beta2 * bs ).p() ).max();
571  T f = f1 * f2;
572  if( f > max )
573  max = f;
574  }
575 
576  return std::tanh( 0.25 * std::log( max ) );
577 }
578 
579 
581 
583 template<typename T> std::ostream& operator<< (std::ostream& os, const TFactor<T>& f) {
584  os << "(" << f.vars() << ", (";
585  for( size_t i = 0; i < f.nrStates(); i++ )
586  os << (i == 0 ? "" : ", ") << f[i];
587  os << "))";
588  return os;
589 }
590 
591 
593 
596 template<typename T> T dist( const TFactor<T> &f, const TFactor<T> &g, ProbDistType dt ) {
597  if( f.vars().empty() || g.vars().empty() )
598  return -1;
599  else {
600  DAI_DEBASSERT( f.vars() == g.vars() );
601  return dist( f.p(), g.p(), dt );
602  }
603 }
604 
605 
607 
610 template<typename T> TFactor<T> max( const TFactor<T> &f, const TFactor<T> &g ) {
611  DAI_ASSERT( f.vars() == g.vars() );
612  return TFactor<T>( f.vars(), max( f.p(), g.p() ) );
613 }
614 
615 
617 
620 template<typename T> TFactor<T> min( const TFactor<T> &f, const TFactor<T> &g ) {
621  DAI_ASSERT( f.vars() == g.vars() );
622  return TFactor<T>( f.vars(), min( f.p(), g.p() ) );
623 }
624 
625 
627 
630 template<typename T> T MutualInfo(const TFactor<T> &f) {
631  DAI_ASSERT( f.vars().size() == 2 );
632  VarSet::const_iterator it = f.vars().begin();
633  Var i = *it; it++; Var j = *it;
634  TFactor<T> projection = f.marginal(i) * f.marginal(j);
635  return dist( f.normalized(), projection, DISTKL );
636 }
637 
638 
640 typedef TFactor<Real> Factor;
641 
642 
644 
647 Factor createFactorIsing( const Var &x, Real h );
648 
649 
651 
655 Factor createFactorIsing( const Var &x1, const Var &x2, Real J );
656 
657 
659 
664 Factor createFactorExpGauss( const VarSet &vs, Real beta );
665 
666 
668 
672 Factor createFactorPotts( const Var &x1, const Var &x2, Real J );
673 
674 
676 
679 Factor createFactorDelta( const Var &v, size_t state );
680 
681 
683 
686 Factor createFactorDelta( const VarSet& vs, size_t state );
687 
688 
689 } // end of namespace dai
690 
691 
692 #endif
dai::TProb::pwBinaryTr
this_type pwBinaryTr(const this_type &q, binaryOp op) const
Returns the result of applying binary operation op pointwise on *this and q.
Definition: prob.h:661
dai::TFactor::TFactor
TFactor(const VarSet &vars, const T *p)
Constructs factor depending on variables in vars, copying the values from an array.
Definition: factor.h:96
dai::Factor
TFactor< Real > Factor
Represents a factor with values of type dai::Real.
Definition: factor.h:640
dai::BigInt_size_t
size_t BigInt_size_t(const BigInt &N)
Safe down-cast of big integer to size_t.
Definition: util.h:104
dai::TFactor::vars
const VarSet & vars() const
Returns constant reference to variable set (i.e., the variables on which the factor depends) ...
Definition: factor.h:139
dai::TFactor::entropy
T entropy() const
Returns the Shannon entropy of *this, .
Definition: factor.h:150
dai::TProb::fill
this_type & fill(T x)
Sets all entries to x.
Definition: prob.h:544
dai::TFactor::operator^
TFactor< T > operator^(T x) const
Returns *this raised to the power x.
Definition: factor.h:334
dai::VarSet::nrStates
BigInt nrStates() const
Calculates the number of states of this VarSet, which is simply the number of possible joint states o...
Definition: varset.h:130
dai::TFactor::TFactor
TFactor(const VarSet &vars)
Constructs factor depending on variables in vars with uniform distribution.
Definition: factor.h:72
dai::TFactor::operator-=
TFactor< T > & operator-=(T x)
Subtracts scalar x from each value.
Definition: factor.h:283
dai::ProbNormType
ProbNormType
Enumerates different ways of normalizing a probability measure.
Definition: util.h:255
index.h
Defines the IndexFor, multifor, Permute and State classes, which all deal with indexing multi-dimensi...
dai::ProbDistType
ProbDistType
Enumerates different distance measures between probability measures.
Definition: util.h:265
dai::TFactor::abs
TFactor< T > abs() const
Returns pointwise absolute value.
Definition: factor.h:203
dai::TProb::normalized
this_type normalized(ProbNormType norm=dai::NORMPROB) const
Returns normalized copy of *this, using the specified norm.
Definition: prob.h:474
dai::log
Real log(Real x)
Returns logarithm of x.
Definition: util.h:113
dai::TProb::exp
this_type exp() const
Returns pointwise exponent.
Definition: prob.h:449
dai::TFactor::binaryOp
TFactor< T > & binaryOp(const TFactor< T > &g, binOp op)
Applies binary operation op on two factors, *this and g.
Definition: factor.h:349
dai::TFactor::marginal
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.
Definition: factor.h:518
dai::TFactor::hasNegatives
bool hasNegatives() const
Returns true if one or more values are negative.
Definition: factor.h:171
dai::SmallSet::size
std::vector< T >::size_type size() const
Returns number of elements.
Definition: smallset.h:169
dai::SmallSet::begin
iterator begin()
Returns iterator that points to the first element.
Definition: smallset.h:193
varset.h
Defines the VarSet class, which represents a set of random variables.
dai::TFactor::takeLog
TFactor< T > & takeLog(bool zero=false)
Applies logarithm pointwise.
Definition: factor.h:266
dai::TProb::takeAbs
this_type & takeAbs()
Applies absolute value pointwise.
Definition: prob.h:509
dai::TFactor::dist
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.
Definition: factor.h:596
dai::TProb::log
this_type log(bool zero=false) const
Returns pointwise logarithm.
Definition: prob.h:454
dai::TProb::set
void set(size_t i, T val)
Sets i 'th entry to val.
Definition: prob.h:293
dai::TProb::maxAbs
T maxAbs() const
Returns maximum absolute value of all entries.
Definition: prob.h:366
dai::TFactor::toString
std::string toString() const
Formats a factor as a string.
Definition: factor.h:182
dai::TFactor::embed
TFactor< T > embed(const VarSet &vars) const
Embeds this factor in a larger VarSet.
Definition: factor.h:485
dai::TProb::hasNaNs
bool hasNaNs() const
Returns true if one or more entries are NaN.
Definition: prob.h:369
dai::TFactor::min
TFactor< T > min(const TFactor< T > &f, const TFactor< T > &g)
Returns the pointwise minimum of two factors.
Definition: factor.h:620
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::TProb::hasNegatives
bool hasNegatives() const
Returns true if one or more entries are negative.
Definition: prob.h:380
dai::TFactor::fill
TFactor< T > & fill(T x)
Sets all values to x.
Definition: factor.h:277
dai::createFactorDelta
Factor createFactorDelta(const Var &v, size_t state)
Returns a Kronecker delta point mass.
Definition: factor.cpp:55
dai::TProb::abs
this_type abs() const
Returns pointwise absolute value.
Definition: prob.h:446
dai::TFactor::setUniform
TFactor< T > & setUniform()
Sets all values to where n is the number of states.
Definition: factor.h:255
dai::TFactor::min
T min() const
Returns minimum of all values.
Definition: factor.h:156
dai::TFactor::TFactor
TFactor(const VarSet &vars, T p)
Constructs factor depending on variables in vars with all values set to p.
Definition: factor.h:77
dai::TProb::max
T max() const
Returns maximum value of all entries.
Definition: prob.h:354
dai::TFactor
Represents a (probability) factor.
Definition: factor.h:55
dai::TProb::pwBinaryOp
this_type & pwBinaryOp(const this_type &q, binaryOp op)
Applies binary operation pointwise on two vectors.
Definition: prob.h:615
prob.h
Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributio...
dai::TFactor::TFactor
TFactor(const VarSet &vars, const std::vector< S > &x)
Constructs factor depending on variables in vars, copying the values from a std::vector<> ...
Definition: factor.h:87
dai::TFactor::operator[]
T operator[](size_t i) const
Returns a copy of the i 'th entry of the value vector.
Definition: factor.h:136
dai::TProb::randomize
this_type & randomize()
Draws all entries i.i.d. from a uniform distribution on [0,1)
Definition: prob.h:497
dai::TProb
Represents a vector with entries of type T.
Definition: prob.h:194
dai::IndexFor
Tool for looping over the states of several variables.
Definition: index.h:48
dai::TFactor::max
T max() const
Returns maximum of all values.
Definition: factor.h:153
dai::TFactor::randomize
TFactor< T > & randomize()
Draws all values i.i.d. from a uniform distribution on [0,1)
Definition: factor.h:252
dai::createFactorPotts
Factor createFactorPotts(const Var &n1, const Var &n2, Real J)
Returns a pairwise Potts factor .
Definition: factor.cpp:46
dai::TFactor::set
void set(size_t i, T val)
Sets i 'th entry to val.
Definition: factor.h:121
dai::TProb::sum
T sum() const
Returns sum of all entries.
Definition: prob.h:360
dai::BigInt
mpz_class BigInt
Arbitrary precision integer number.
Definition: util.h:101
dai::TFactor::vars
VarSet & vars()
Returns reference to variable set (i.e., the variables on which the factor depends) ...
Definition: factor.h:142
dai::SmallSet::contains
bool contains(const T &t) const
Returns true if *this contains the element t.
Definition: smallset.h:164
dai::TFactor::_p
TProb< T > _p
Stores the factor values.
Definition: factor.h:60
dai::SmallSet< Var >::const_iterator
std::vector< Var >::const_iterator const_iterator
Constant iterator over the elements.
Definition: smallset.h:182
dai::TProb::p
const container_type & p() const
Returns a const reference to the wrapped container.
Definition: prob.h:302
dai::TFactor::binaryTr
TFactor< T > binaryTr(const TFactor< T > &g, binOp op) const
Returns result of applying binary operation op on two factors, *this and g.
Definition: factor.h:404
dai::fo_divides0
Function object similar to std::divides(), but different in that dividing by zero results in zero...
Definition: prob.h:112
dai::dist
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.
Definition: cbp.cpp:68
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::TProb::normalize
T normalize(ProbNormType norm=dai::NORMPROB)
Normalizes vector using the specified norm.
Definition: prob.h:527
dai::TProb::setUniform
this_type & setUniform()
Sets all entries to where n is the length of the vector.
Definition: prob.h:503
dai::createFactorExpGauss
Factor createFactorExpGauss(const VarSet &ns, Real beta)
Returns a random factor on the variables vs with strength beta.
Definition: factor.cpp:38
dai::TFactor::inverse
TFactor< T > inverse(bool zero=true) const
Returns pointwise inverse.
Definition: factor.h:231
dai::TFactor::operator/=
TFactor< T > & operator/=(T x)
Divides each entry by scalar x.
Definition: factor.h:289
util.h
Defines general utility functions and adds an abstraction layer for platform-dependent functionality...
dai::TFactor::operator*=
TFactor< T > & operator*=(T x)
Multiplies each value with scalar x.
Definition: factor.h:286
dai::TFactor::max
TFactor< T > max(const TFactor< T > &f, const TFactor< T > &g)
Returns the pointwise maximum of two factors.
Definition: factor.h:610
dai::TFactor::MutualInfo
T MutualInfo(const TFactor< T > &f)
Calculates the mutual information between the two variables that f depends on, under the distribution...
Definition: factor.h:630
dai::createFactorIsing
Factor createFactorIsing(const Var &n, Real h)
Returns a binary unnormalized single-variable factor where .
Definition: factor.cpp:18
dai::TFactor::nrStates
size_t nrStates() const
Returns the number of possible joint states of the variables on which the factor depends, .
Definition: factor.h:147
dai::TFactor::TFactor
TFactor(T p=1)
Constructs factor depending on no variables with value p.
Definition: factor.h:66
dai::TFactor::exp
TFactor< T > exp() const
Returns pointwise exponent.
Definition: factor.h:211
dai::TFactor::operator/
TFactor< T > operator/(T x) const
Returns quotient of *this with scalar x.
Definition: factor.h:326
dai::TFactor::slice
TFactor< T > slice(const VarSet &vars, size_t varsState) const
Returns a slice of *this, where the subset vars is in state varsState.
Definition: factor.h:502
dai::TProb::sumAbs
T sumAbs() const
Return sum of absolute value of all entries.
Definition: prob.h:363
dai::TProb::size
size_t size() const
Returns length of the vector (i.e., the number of entries)
Definition: prob.h:311
dai::TFactor::maxMarginal
TFactor< T > maxMarginal(const VarSet &vars, bool normed=true) const
Returns max-marginal on vars, obtained by maximizing all variables except those in vars...
Definition: factor.h:534
dai::TProb::takeLog
this_type & takeLog(bool zero=false)
Applies logarithm pointwise.
Definition: prob.h:517
dai::TFactor::maxAbs
T maxAbs() const
Returns maximum absolute value of all values.
Definition: factor.h:165
dai::TFactor::p
TProb< T > & p()
Returns reference to value vector.
Definition: factor.h:133
dai::Var::states
size_t states() const
Returns the number of states.
Definition: var.h:57
dai::TFactor::normalized
TFactor< T > normalized(ProbNormType norm=NORMPROB) const
Returns normalized copy of *this, using the specified norm.
Definition: factor.h:241
dai::TProb::min
T min() const
Returns minimum value of all entries.
Definition: prob.h:357
dai::TFactor::operator==
bool operator==(const TFactor< T > &y) const
Comparison.
Definition: factor.h:177
dai::TFactor::sum
T sum() const
Returns sum of all values.
Definition: factor.h:159
dai::TFactor::sumAbs
T sumAbs() const
Returns sum of absolute values.
Definition: factor.h:162
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::Permute
Tool for calculating permutations of linear indices of multi-dimensional arrays.
Definition: index.h:137
dai::TProb::inverse
this_type inverse(bool zero=true) const
Returns pointwise inverse.
Definition: prob.h:464
dai::TFactor::operator+
TFactor< T > operator+(T x) const
Returns sum of *this and scalar x.
Definition: factor.h:298
dai::TFactor::takeAbs
TFactor< T > & takeAbs()
Applies absolute value pointwise.
Definition: factor.h:258
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
dai::TFactor::_vs
VarSet _vs
Stores the variables on which the factor depends.
Definition: factor.h:58
dai::TFactor::operator+=
TFactor< T > & operator+=(T x)
Adds scalar x to each value.
Definition: factor.h:280
dai::TFactor::p
const TProb< T > & p() const
Returns constant reference to value vector.
Definition: factor.h:130
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::TFactor::TFactor
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...
Definition: factor.h:107
dai::TFactor::strength
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]...
Definition: factor.h:551
dai::TFactor::operator^=
TFactor< T > & operator^=(T x)
Raises values to the power x.
Definition: factor.h:292
dai::TFactor::hasNaNs
bool hasNaNs() const
Returns true if one or more values are NaN.
Definition: factor.h:168
dai::TFactor::log
TFactor< T > log(bool zero=false) const
Returns pointwise logarithm.
Definition: factor.h:221
dai::TFactor::TFactor
TFactor(const Var &v)
Constructs factor depending on the variable v with uniform distribution.
Definition: factor.h:69
dai::TFactor::takeExp
TFactor< T > & takeExp()
Applies exponent pointwise.
Definition: factor.h:261
dai::TFactor::TFactor
TFactor(const VarSet &vars, const TProb< T > &p)
Constructs factor depending on variables in vars, copying the values from p.
Definition: factor.h:102
dai::TFactor::operator-
TFactor< T > operator-() const
Returns negative of *this.
Definition: factor.h:192
dai::TFactor::normalize
T normalize(ProbNormType norm=NORMPROB)
Normalizes factor using the specified norm.
Definition: factor.h:271
dai::SmallSet::empty
bool empty() const
Returns whether *this is empty.
Definition: smallset.h:172
dai::TProb::entropy
T entropy() const
Returns the Shannon entropy of *this, .
Definition: prob.h:351
dai::TFactor::operator*
TFactor< T > operator*(T x) const
Returns product of *this with scalar x.
Definition: factor.h:318
dai::TProb::takeExp
this_type & takeExp()
Applies exponent pointwise.
Definition: prob.h:512
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_r.html0000644000175000017500000002750112552201370017122 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- r -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1MaximizationStep.html0000644000175000017500000005753612552201366022262 0ustar jorismjorism libDAI: dai::MaximizationStep Class Reference
Public Member Functions | Private Attributes | List of all members
dai::MaximizationStep Class Reference

A MaximizationStep groups together several parameter estimation tasks (SharedParameters objects) into a single unit. More...

#include <dai/emalg.h>

Public Member Functions

 MaximizationStep ()
 Default constructor. More...
 
 MaximizationStep (std::vector< SharedParameters > &maximizations)
 Construct MaximizationStep from a vector of parameter estimation tasks. More...
 
 MaximizationStep (std::istream &is, const FactorGraph &fg_varlookup)
 Constructor from an input stream and a corresponding factor graph. More...
 
void addExpectations (InfAlg &alg)
 Collect the beliefs from this InfAlg as expectations for the next Maximization step. More...
 
void maximize (FactorGraph &fg)
 Using all of the currently added expectations, make new factors with maximized parameters and set them in the FactorGraph. More...
 
void clear ()
 Clear the step, to be called at the begining of each step. More...
 

Private Attributes

std::vector< SharedParameters > _params
 Vector of parameter estimation tasks of which this maximization step consists. More...
 

Iterator interface

typedef std::vector< SharedParameters >::iterator iterator
 Iterator over the parameter estimation tasks. More...
 
typedef std::vector< SharedParameters >::const_iterator const_iterator
 Constant iterator over the parameter estimation tasks. More...
 
iterator begin ()
 Returns iterator that points to the first parameter estimation task. More...
 
const_iterator begin () const
 Returns constant iterator that points to the first parameter estimation task. More...
 
iterator end ()
 Returns iterator that points beyond the last parameter estimation task. More...
 
const_iterator end () const
 Returns constant iterator that points beyond the last parameter estimation task. More...
 

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.

void dai::MaximizationStep::clear ( )

Clear the step, to be called at the begining of each step.

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:
  • include/dai/emalg.h
  • src/emalg.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1BBP-members.html0000644000175000017500000006533212552201364020777 0ustar jorismjorism libDAI: Member List
dai::BBP Member List

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

_adj_b_Fdai::BBPprivate
_adj_b_F_unnormdai::BBPprivate
_adj_b_Vdai::BBPprivate
_adj_b_V_unnormdai::BBPprivate
_adj_mdai::BBPprivate
_adj_m_unnormdai::BBPprivate
_adj_ndai::BBPprivate
_adj_n_unnormdai::BBPprivate
_adj_psi_Fdai::BBPprivate
_adj_psi_Vdai::BBPprivate
_bp_dualdai::BBPprivate
_fgdai::BBPprivate
_iadai::BBPprivate
_ind_t typedefdai::BBPprivate
_index(size_t i, size_t _I) const dai::BBPinlineprivate
_indicesdai::BBPprivate
_init_adj_psi_Fdai::BBPprivate
_init_adj_psi_Vdai::BBPprivate
_itersdai::BBPprivate
_new_adj_mdai::BBPprivate
_new_adj_ndai::BBPprivate
_Rmsgdai::BBPprivate
_Smsgdai::BBPprivate
_Tmsgdai::BBPprivate
_Umsgdai::BBPprivate
adj_b_F(size_t I)dai::BBPinline
adj_b_F(size_t I) const dai::BBPinline
adj_b_V(size_t i)dai::BBPinline
adj_b_V(size_t i) const dai::BBPinline
adj_m(size_t i, size_t _I)dai::BBPinlineprivate
adj_m(size_t i, size_t _I) const dai::BBPinlineprivate
adj_n(size_t i, size_t _I)dai::BBPinlineprivate
adj_n(size_t i, size_t _I) const dai::BBPinlineprivate
adj_psi_F(size_t I)dai::BBPinline
adj_psi_F(size_t I) const dai::BBPinline
adj_psi_V(size_t i)dai::BBPinline
adj_psi_V(size_t i) const dai::BBPinline
BBP(const InfAlg *ia, const PropertySet &opts)dai::BBPinline
calcNewM(size_t i, size_t _I)dai::BBPprivate
calcNewN(size_t i, size_t _I)dai::BBPprivate
calcUnnormMsgM(size_t i, size_t _I)dai::BBPprivate
calcUnnormMsgN(size_t i, size_t _I)dai::BBPprivate
doParUpdate()dai::BBPprivate
getArgmaxMsgM(size_t &i, size_t &_I, Real &mag)dai::BBPprivate
getMaxMsgM()dai::BBPprivate
getMsgMags(Real &s, Real &new_s)dai::BBPprivate
getTotalMsgM()dai::BBPprivate
getTotalMsgN()dai::BBPprivate
getTotalNewMsgM()dai::BBPprivate
getUnMsgMag()dai::BBPprivate
getZeroAdjF(const FactorGraph &fg)dai::BBPprivate
getZeroAdjV(const FactorGraph &fg)dai::BBPprivate
incrSeqMsgM(size_t i, size_t _I, const Prob &p)dai::BBPprivate
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::BBPinline
init(const std::vector< Prob > &adj_b_V, const std::vector< Prob > &adj_b_F)dai::BBPinline
init_F(const std::vector< Prob > &adj_b_F)dai::BBPinline
init_V(const std::vector< Prob > &adj_b_V)dai::BBPinline
initCostFnAdj(const BBPCostFunction &cfn, const std::vector< size_t > *stateP)dai::BBP
Iterations()dai::BBPinline
numericBBPTest(const InfAlg &bp, const std::vector< size_t > *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h)dai::BBPrelated
props (defined in dai::BBP)dai::BBP
R(size_t I, size_t _i, size_t _J)dai::BBPinlineprivate
R(size_t I, size_t _i, size_t _J) const dai::BBPinlineprivate
Regenerate()dai::BBPprivate
RegenerateInds()dai::BBPprivate
RegenerateInputs()dai::BBPprivate
RegenerateParMessageAdjoints()dai::BBPprivate
RegeneratePsiAdjoints()dai::BBPprivate
RegenerateR()dai::BBPprivate
RegenerateS()dai::BBPprivate
RegenerateSeqMessageAdjoints()dai::BBPprivate
RegenerateT()dai::BBPprivate
RegenerateU()dai::BBPprivate
run()dai::BBP
S(size_t i, size_t _I, size_t _j)dai::BBPinlineprivate
S(size_t i, size_t _I, size_t _j) const dai::BBPinlineprivate
sendSeqMsgM(size_t i, size_t _I)dai::BBPprivate
sendSeqMsgN(size_t i, size_t _I, const Prob &f)dai::BBPprivate
setSeqMsgM(size_t i, size_t _I, const Prob &p)dai::BBPprivate
T(size_t i, size_t _I)dai::BBPinlineprivate
T(size_t i, size_t _I) const dai::BBPinlineprivate
U(size_t I, size_t _i)dai::BBPinlineprivate
U(size_t I, size_t _i) const dai::BBPinlineprivate
unnormAdjoint(const Prob &w, Real Z_w, const Prob &adj_w)dai::BBPprivate
upMsgM(size_t i, size_t _I)dai::BBPprivate
upMsgN(size_t i, size_t _I)dai::BBPprivate
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1Region.html0000644000175000017500000014516512552201367020175 0ustar jorismjorism libDAI: dai::Region Class Reference
Public Member Functions | Private Attributes | List of all members
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< Var >

Public Member Functions

 Region ()
 Default constructor. More...
 
 Region (const VarSet &x, Real c)
 Construct from a set of variables and a counting number. More...
 
const Real & c () const
 Returns constant reference to counting number. More...
 
Real & c ()
 Returns reference to counting number. More...
 
- Public Member Functions inherited from dai::VarSet
 VarSet ()
 Default constructor (constructs an empty set) More...
 
 VarSet (const SmallSet< Var > &x)
 Construct from SmallSet<Var> x. More...
 
 VarSet (const Var &v)
 Construct a VarSet with one element, v. More...
 
 VarSet (const Var &v1, const Var &v2)
 Construct a VarSet with two elements, v1 and v2. More...
 
template<typename VarIterator >
 VarSet (VarIterator begin, VarIterator end, size_t sizeHint=0)
 Construct a VarSet from the range between begin and end. More...
 
BigInt nrStates () const
 Calculates the number of states of this VarSet, which is simply the number of possible joint states of the variables in *this. More...
 
std::string toString () const
 Formats a VarSet as a string. More...
 
- Public Member Functions inherited from dai::SmallSet< Var >
 SmallSet ()
 Default constructor (constructs an empty set) More...
 
 SmallSet (const Var &t)
 Construct a set consisting of one element. More...
 
 SmallSet (const Var &t1, const Var &t2)
 Construct a set consisting of two elements. More...
 
 SmallSet (TIterator begin, TIterator end, size_t sizeHint)
 Construct a SmallSet from a range of elements. More...
 
SmallSet & insert (const Var &t)
 Inserts t into *this. More...
 
SmallSet & erase (const Var &t)
 Erases t from *this. More...
 
SmallSet operator/ (const SmallSet &x) const
 Set-minus operator: returns all elements in *this, except those in x. More...
 
SmallSet operator| (const SmallSet &x) const
 Set-union operator: returns all elements in *this, plus those in x. More...
 
SmallSet operator& (const SmallSet &x) const
 Set-intersection operator: returns all elements in *this that are also contained in x. More...
 
SmallSet & operator/= (const SmallSet &x)
 Erases from *this all elements in x. More...
 
SmallSet & operator/= (const Var &t)
 Erases one element. More...
 
SmallSet & operator|= (const SmallSet &x)
 Adds to *this all elements in x. More...
 
SmallSet & operator|= (const Var &t)
 Adds one element. More...
 
SmallSet & operator&= (const SmallSet &x)
 Erases from *this all elements not in x. More...
 
bool operator<< (const SmallSet &x) const
 Returns true if *this is a subset of x. More...
 
bool operator>> (const SmallSet &x) const
 Returns true if x is a subset of *this. More...
 
bool intersects (const SmallSet &x) const
 Returns true if *this and x have elements in common. More...
 
bool contains (const Var &t) const
 Returns true if *this contains the element t. More...
 
std::vector< Var >::size_type size () const
 Returns number of elements. More...
 
bool empty () const
 Returns whether *this is empty. More...
 
std::vector< Var > & elements ()
 Returns reference to the elements. More...
 
const std::vector< Var > & elements () const
 Returns constant reference to the elements. More...
 
iterator begin ()
 Returns iterator that points to the first element. More...
 
const_iterator begin () const
 Returns constant iterator that points to the first element. More...
 
iterator end ()
 Returns iterator that points beyond the last element. More...
 
const_iterator end () const
 Returns constant iterator that points beyond the last element. More...
 
reverse_iterator rbegin ()
 Returns reverse iterator that points to the last element. More...
 
const_reverse_iterator rbegin () const
 Returns constant reverse iterator that points to the last element. More...
 
reverse_iterator rend ()
 Returns reverse iterator that points beyond the first element. More...
 
const_reverse_iterator rend () const
 Returns constant reverse iterator that points beyond the first element. More...
 
Var & front ()
 Returns reference to first element. More...
 
const Var & front () const
 Returns constant reference to first element. More...
 
Var & back ()
 Returns reference to last element. More...
 
const Var & back () const
 Returns constant reference to last element. More...
 
std::string toString () const
 Formats a SmallSet as a string. More...
 

Private Attributes

Real _c
 Counting number. More...
 

Additional Inherited Members

- Public Types inherited from dai::SmallSet< Var >
typedef std::vector< Var >::const_iterator const_iterator
 Constant iterator over the elements. More...
 
typedef std::vector< Var >::iterator iterator
 Iterator over the elements. More...
 
typedef std::vector< Var >::const_reverse_iterator const_reverse_iterator
 Constant reverse iterator over the elements. More...
 
typedef std::vector< Var >::reverse_iterator reverse_iterator
 Reverse iterator over the elements. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_a.html0000644000175000017500000001663212552201370020117 0ustar jorismjorism libDAI: Class Members - Functions
 

- a -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_p.html0000644000175000017500000002114712552201370020133 0ustar jorismjorism libDAI: Class Members - Functions
 

- p -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/example_bipgraph_8cpp-example.html0000644000175000017500000002114612552201363022464 0ustar jorismjorism libDAI: example_bipgraph.cpp
example_bipgraph.cpp

This example deals with the following bipartite graph:

dot_inline_dotgraph_1.png

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/
*
* Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
*/
#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
bforeach( 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_8.png0000644000175000017500000000236212552200215015576 0ustar jorismjorism‰PNG  IHDRê$°¨V¸0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïaIDATxíýr£: ÅþÄ¿ÿÛ®$0IÚÙÛô63¥ˆP¶ŽÎ‘ô/À¯üÀ¯Ü[)e<#À ¥”ñx7KK­K¶£Ö:€'æõms+µ^2Àû™@h7ëvð`©ÖNðvð2óN÷ ÀpÞ«2ǹ#üêŽð¿A½‹eD°^‡ p:ó‡XC¹m·ª Óÿõ¼õÁT_ÅÑËßô$ó@{¾(RóQ©i.ûWëÐß¾ jò·L\#‹Ápj´ú(³–|${»ÓR­›\‹/Œ&Š,º;:¹wuå¬ p—EÜ¿ðÙâ‹š¥×@5N’tÑÕ¶ð—å U£Óh%–µé+ì¡×•ÕÖ¦ÎÒUÿiŽAW--ÛwýÚÒÔ^•(0Y¢¿îx$ãG³è¯N ìPE·«EX4¯J³ÑWjŽ"PÙF´¯iXlI°ÊC?è z TU’ì›® ÛÐMwʪîë\4Œ=9 .Þ++a–K¸ùê X[É÷I"ª$wÛÚ’³·B]ªºk–Ù4ðÿuPoÞö-­§êæ>Ø1]=Éö¼¨z“';Åņ@úéÙ"t"Ñ·³©Û•8m,ÊdÞ²Œ©¶Q(õJ öª'è%ÃF¾¶ž‘„:o›ûlÇ¢hŒÃd½„³'|G0’Ä<ÈNÛéÓ‘l«Î­àíê›f[BšZæqÔ¾b®JƒŽ·Ã˜ ÒNáþAj”¸ƒŒ ãU_£rt¿˜cìÓyÚdœÙ`; òW@%o¥dq5†­ üsMÀqÞÿ?®=@ÆóüÿK §sÕF³Ï c3Ÿ øz«µGQÇÁ p²²!̵µw€¿¶0–L£ã:^c×*Ç*²Úo,¯öz¸x/svŒ7ö·~¿ðk/¶AˆEÊ4¤ÏzðýG[_ùþð¯¦-×OÅ\•¾ß{qde90ÌW}`MËw§«6Õ\ä¿òYçø!V¦Ödr4§¼(ŹÌú“®río—Æ©ý8@íàÇZšfü&Ù‰5¡1ìC^Çç¥ÏÃÉßvÿLEÐñ¥Ë{@ ©ˆøJ)FQ™Cà÷¢ˆº'â’¢ÂÖ<˜G4|Ƽ{ƒ1+Řc›’ŠcÕè—ΣV–yV»„¿©~Íw–‹¿Z!+óòà竲q±`ý*ªŒÚpCnaÑ'¦U­Z–Dˆ ô¥^U+UéP?ÙœÓ]™gák+P§Å'ÐçÜÚêò*?ZÕ’­qkúÙÚð¯U¿Î›VÇ£Žÿ["Éw§¾7hKÿd9ô™ª´*ÓMÓiF¼¿í ¹Aøû~8 &äIEND®B`‚libDAI-0.3.2/doc/html/mf_8h.html0000644000175000017500000001211612552201363015570 0ustar jorismjorism libDAI: include/dai/mf.h File Reference
Classes | Namespaces
mf.h File Reference

Defines class MF which implements the Mean Field algorithm. More...

#include <dai/dai_config.h>
#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.

Classes

class  dai::MF
 Approximate inference algorithm "Mean Field". More...
 
struct  dai::MF::Properties
 Parameters for MF. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class MF which implements the Mean Field algorithm.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1DEdge.html0000644000175000017500000003370212552201365017711 0ustar jorismjorism libDAI: dai::DEdge Class Reference
Public Member Functions | Public Attributes | Friends | List of all members
dai::DEdge Class Reference

Represents a directed edge. More...

#include <dai/weightedgraph.h>

Public Member Functions

 DEdge ()
 Default constructor. More...
 
 DEdge (size_t m1, size_t m2)
 Constructs a directed edge pointing from m1 to m2. More...
 
bool operator== (const DEdge &x) const
 Tests for equality. More...
 
bool operator< (const DEdge &x) const
 Smaller-than operator (performs lexicographical comparison) More...
 
std::string toString () const
 Formats a directed edge as a string. More...
 

Public Attributes

size_t first
 First node index (source of edge) More...
 
size_t second
 Second node index (target of edge) More...
 

Friends

std::ostream & operator<< (std::ostream &os, const DEdge &e)
 Writes a directed edge to an output stream. More...
 

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)

std::string dai::DEdge::toString ( ) const
inline

Formats a directed edge as a string.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_34.png0000644000175000017500000000105412552200223015651 0ustar jorismjorism‰PNG  IHDRˆúQÇN0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï›IDATxíÙ²ã D`¼$þÿ¿!<1^rkòªy¸MÅŽÒjmäà€7о‚’~?àòø¦ØwZÏÊ:ÑÀ·pbÿ‡Çö, à€f£Æt­_J!åŸ Ø÷ ÉAˆyŸ·çÁ¢lkkQ7•Èš¦‘|Ì\]eM”÷-Öû¹!És¯Juzt´­-Š‡ÔÉÕŸF`ߊúÇk"N¸%™såo®r΋[œ‘–fØ<–³ÇRê¹ünHæ}l꧸ ã¶6óVÆR#:y”:÷VÂ.ŸopG’^¥ÑňB^[G”kf\È–Œ•Ö<ŠçÀ õ)«XåÕr=á‹;Y¼ãÚid†km¢Žä¦YS6 bÕié¸v›Fc0;íûR»'ø™cÈõMÒP˜íx¢Å«ÙÎ`ªr:’ Ò<}p9 iªåu 5²ýz¬3)n÷æ>J݈W]¤Õä!Ú_ñ•Ï…èùÿ'ÆtzÐíƒ>û}™<%]¯üì2ÜF=ŸÜÀV˜¡†ò—ëÀ=ñžy—IEND®B`‚libDAI-0.3.2/doc/html/form_82.png0000644000175000017500000000232712552200236015664 0ustar jorismjorism‰PNG  IHDRØ&‘f¥¶0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïFIDATxíý’ã( Ä0˜8ñû¿íI€¿±gvîj6©:—{ÖK0VKêÖ¿ÿà}`€ÝmN+º€€ Qþº`‡Ø`öp/€ÀË=4b€=LØcø t¹Ñ0X`{7ÙVƒ¼º0jøcŽÛ¹7Mz,Y7<Ï ð†pcòÚÙÌ3¤-™“ž¢ÊàðÔ‚Y­˜œL×A?ÆÒ„'bOMÀÝkš¦W¹ô©ÕÛ¿†lµéŠÞæĦ;…ùiþyš®ð0™˜)dHihˬ:¸Ä†ØO,æ®Ï›Cà.ÛF¦0±5‡±æÛg@îX€6îˆù{Œþh"ÉKÆŠŽh U€KÄP¯œƒ^ÏÕº(7_~[TäïÂúªbA×Æ;åIŸØÁ„ýGï†*ÀœK†Üæ8•˜W ‡‚…t_°{bFtZåX¶ 1}ï¢ÝOC`ÍGÇ0'bXWãàò²=Ög箿×Xz5yÙ%¥•Ø꼶 U›)ÍCu>£³zoù¬'ÉÚÚç¸ï»ç¹7î‰uSûÀǼwÀjµDè³JyÅ]i§êdÕps£åçÙêÖ“þ¶^5Îsú©´öøœ\Õwƒ˜“e;e‡vúÍJ¬–Âëæò¼[N²ÖÚ/±f<•ëÚ”o‰9çËj*_ï‡ùšj하¶b%–«§¼[gÏ2”§“RJé+ÜÌ€îˆ9‰mʇ=íígMU½j.órÿR>Y1Gb2”JŠ–Š-'üé,Êb^¿µÓNÃq‰K’÷¬þaä>š×hÐBÌï=sÿ‰sË7Jm:ËIß@ßtùþ<’®‰ Ib³)‰g†cõ¼—‰âò”÷t!ÏÍðÐ¥å½üÌлp(ÐF6ç¬ë]§ýÖF.qos¥OS¤Dc˱Ð_"¶Œð}|‹˜½ÂJ¬‘ÉËt\Á\èÿì´ohc¼ÓÈOx/“xt°äû›*þKbÿ|pÉñÔ0\?ôAm놘8’k:In–4MÉÊQú0êÀß“À_™Ž'ŽFé™ÙŒõ˜LyÝ.‹aPç·]þ^Ò¹l}©ôqPbÊáD,Š3IÞ"m­Ú€Uaìèl!»'&úêŽÍ ð~*i- ßY\Äx‹Î‡:jðñRboÝ$­¥#ܧ0dw÷ÆNì¯E¬!1£ÌãFY;±ü.´µºíTt¢£Ò‰~7=¤¤]•ãÁ8C¢nÈ¿æZ럭X~ž¤׬;±3/jrÙN€ÍÝ»ó˜4’”T_ §Bl#V€ßC×÷µMbsê„o8 ˜™î˜ûw&¶+ÀgAªeÇaÈ­¨]çb;±|ž®›;V%&ªLRýNˆmÅ ðað"F›¼•žŽƒ ÂÑD¹bøH¸<)> ÿúêT>s~ŠIEND®B`‚libDAI-0.3.2/doc/html/form_135.png0000644000175000017500000000117312552200252015737 0ustar jorismjorism‰PNG  IHDR“%½Q0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïêIDATxí]Û²¤ lî "ÿÿ·›„x„æ”S»KQÒt’Ž¼À€çæÜ3ÀÂLŠðÏÍåyÿþ0¸§)ðn§åk rSÏá7¬Ì”˜ÊHÿt0Ù`œa™×tí~ñ©=ÈÜÁˆkN9 &êL˜Ó4’te?«8¥Öß1¼ƒÀdžW»zèqÎ0ÞS)7ŽÛoÃåyh&B~õ߈“=ä¡jX0Ù‚SòØ Nöˆ¨9ž*­Ü×"ðâ_éýwœP[; L^ñR¨}€©Å‘ºN~IDhuà²ãÑÁÜÁY¬”¹/9ÁÆFr`A¤1q²{øaìj£jërs"Æ‹Óyôå~ã‡Ç·µ“ÍY…ÊIc|á$ñvÙGJ‹ØONY^^µ›òÖ8wÒSN…#*Qƒ0Må$áj{Yxú·sáBÙISÒ¸tÕL¦7ßáè7j\Ët?ĉ3x]YÖºFŠM|z°ÆéRe ¡/9äî²Ñ2=ÕO"ü^J™òlbÞÂR¨o­ô…•^í×þ]–5ÞÊ·òBãA•±H÷Ý^F:à·oæ…6îð¡€Óšã·*/8½œ-+6Œ6ì1‚Œ‡Í8žŸŽReãÔv_žÈã¼p€¿4Ë¢”ñ :±nàIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1PropertySet.html0000644000175000017500000012371012552201367021242 0ustar jorismjorism libDAI: dai::PropertySet Class Reference
List of all members
dai::PropertySet Class Reference

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

#include <dai/properties.h>

Inheritance diagram for dai::PropertySet:

Public Member Functions

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

Input/output

std::string toString () const
 Formats a PropertySet as a string. More...
 
void fromString (const std::string &s)
 Reads a PropertySet from a string. More...
 
std::ostream & operator<< (std::ostream &os, const PropertySet &ps)
 Writes a PropertySet object to an output stream. More...
 
std::istream & operator>> (std::istream &is, PropertySet &ps)
 Reads a PropertySet object from an input stream. More...
 

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, and example_sprinkler_em.cpp.

Constructor & Destructor Documentation

dai::PropertySet::PropertySet ( )
inline

Default constructor.

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

Construct from a string.

Parameters
sstring 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, and example_sprinkler_em.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
ValueTypeType from which the value should be cast
Exceptions
IMPOSSIBLE_TYPECASTif 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
ValueTypeType to which the value should be cast
Exceptions
IMPOSSIBLE_TYPECASTif 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_FOUNDif 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
ValueTypeType to which the value should be cast
Exceptions
OBJECT_NOT_FOUNDif the key cannot be found in *this
IMPOSSIBLE_TYPECASTif 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
ValueTypeType to which the value should be cast/converted
Exceptions
OBJECT_NOT_FOUNDif the key cannot be found in *this
IMPOSSIBLE_TYPECASTif the type cast cannot be done
std::string dai::PropertySet::toString ( ) const
inline

Formats a PropertySet as a string.

void dai::PropertySet::fromString ( const std::string &  s)
inline

Reads a PropertySet from a string.

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_TYPEif 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_PROPERTYif the string is not in the expected format
The documentation for this class was generated from the following file:
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_40.png0000644000175000017500000000057312552200224015654 0ustar jorismjorism‰PNG  IHDR6'¦ÝÏ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïêIDATxíanà FØ@’qÿÛÎd5[¥vRÿ~Â`6à|Àb ^ZZdLS©¯mk1˜JS‚ìh˜,¯« ½sZÛHk 9SE&Û{Íc%RòìîRó­€oxf­þ¦ÞÂÒé îtï`¹¥ñ>í_XŽuÑ=΄éã%Ýß)Zœž_1Ÿ`.¢–kQY¬;6ëvsßÇó˜¸íXÇ”~‹K­V‡-¹7vX”ƒ¨C6wbN¡&Ò]DS´žÊÍK‚¡g¸ôÕvË÷ª,Z†lê/Öɹ2¯;맿´T+5€Ù74¿ŸôuvIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1TreeEP_1_1TreeEPSubTree-members.html0000644000175000017500000002122312552201370024503 0ustar jorismjorism 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::TreeEPSubTreeprivate
_bdai::TreeEP::TreeEPSubTreeprivate
_Idai::TreeEP::TreeEPSubTreeprivate
_logZdai::TreeEP::TreeEPSubTreeprivate
_nsdai::TreeEP::TreeEPSubTreeprivate
_nsremdai::TreeEP::TreeEPSubTreeprivate
_Qadai::TreeEP::TreeEPSubTreeprivate
_Qbdai::TreeEP::TreeEPSubTreeprivate
_RTreedai::TreeEP::TreeEPSubTreeprivate
HUGIN_with_I(std::vector< Factor > &Qa, std::vector< Factor > &Qb)dai::TreeEP::TreeEPSubTree
I()dai::TreeEP::TreeEPSubTreeinline
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::TreeEPSubTreeinline
TreeEPSubTree()dai::TreeEP::TreeEPSubTreeinline
TreeEPSubTree(const TreeEPSubTree &x)dai::TreeEP::TreeEPSubTreeinline
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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/tab_h.png0000644000175000017500000000026112552201363015462 0ustar jorismjorism‰PNG  IHDR$ÇÇ[xIDATxíÝMÁ@†áž~¥ÜÆÎ’Evˆ¿"!•²‘d*×rGq=Š{¼ßSݧçë­ÓÉHÇ uO^õø[À_‡¢ãXvyËþÒ±=·VCffææ{°öŠó´Rçœ%_õçÿŽ¢ö·°Çrug¶(?gh\i>|sIEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1LC-members.html0000644000175000017500000004144212552201366020670 0ustar jorismjorism libDAI: Member List
dai::LC Member List

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

_beliefsdai::LCprivate
_cavitydistsdai::LCprivate
_itersdai::LCprivate
_maxdiffdai::LCprivate
_pancakesdai::LCprivate
_phisdai::LCprivate
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const Var &v) const dai::LCinlinevirtual
belief(const VarSet &) const dai::LCvirtual
beliefF(size_t I) const dai::InfAlginlinevirtual
beliefs() const dai::LCinlinevirtual
beliefV(size_t i) const dai::LCinlinevirtual
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::LCinline
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clone() const dai::LCinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::LCinlinevirtual
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findMaximum() const dai::InfAlginlinevirtual
getProperties() const dai::LCvirtual
identify() const dai::InfAlginlinevirtual
init()dai::LCvirtual
init(const VarSet &)dai::LCinlinevirtual
InitCavityDists(const std::string &name, const PropertySet &opts)dai::LC
Iterations() const dai::LCinlinevirtual
LC()dai::LCinline
LC(const FactorGraph &fg, const PropertySet &opts)dai::LC
logZ() const dai::LCinlinevirtual
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::LCinlinevirtual
name() const dai::LCinlinevirtual
NewPancake(size_t i, size_t _I, bool &hasNaNs)dai::LC
pancake(size_t i) const dai::LCinline
printProperties() const dai::LCvirtual
props (defined in dai::LC)dai::LC
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()dai::LCvirtual
SetCavityDists(std::vector< Factor > &Q)dai::LC
setMaxIter(size_t maxiter)dai::LCinlinevirtual
setProperties(const PropertySet &opts)dai::LCvirtual
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_u.html0000644000175000017500000001453412552201370017127 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- u -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1TFactor.html0000644000175000017500000040635212552201370020304 0ustar jorismjorism libDAI: dai::TFactor< T > Class Template Reference
Private Attributes | Related Functions | List of all members
dai::TFactor< T > Class Template Reference

Represents a (probability) factor. More...

#include <dai/factor.h>

Public Member Functions

Constructors and destructors
 TFactor (T p=1)
 Constructs factor depending on no variables with value p. More...
 
 TFactor (const Var &v)
 Constructs factor depending on the variable v with uniform distribution. More...
 
 TFactor (const VarSet &vars)
 Constructs factor depending on variables in vars with uniform distribution. More...
 
 TFactor (const VarSet &vars, T p)
 Constructs factor depending on variables in vars with all values set to p. More...
 
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<> More...
 
 TFactor (const VarSet &vars, const T *p)
 Constructs factor depending on variables in vars, copying the values from an array. More...
 
 TFactor (const VarSet &vars, const TProb< T > &p)
 Constructs factor depending on variables in vars, copying the values from p. More...
 
 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. More...
 
Get/set individual entries
void set (size_t i, T val)
 Sets i 'th entry to val. More...
 
T get (size_t i) const
 Gets i 'th entry. More...
 
Queries
const TProb< T > & p () const
 Returns constant reference to value vector. More...
 
TProb< T > & p ()
 Returns reference to value vector. More...
 
T operator[] (size_t i) const
 Returns a copy of the i 'th entry of the value vector. More...
 
const VarSet & vars () const
 Returns constant reference to variable set (i.e., the variables on which the factor depends) More...
 
VarSet & vars ()
 Returns reference to variable set (i.e., the variables on which the factor depends) More...
 
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$. More...
 
T entropy () const
 Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$. More...
 
T max () const
 Returns maximum of all values. More...
 
T min () const
 Returns minimum of all values. More...
 
T sum () const
 Returns sum of all values. More...
 
T sumAbs () const
 Returns sum of absolute values. More...
 
T maxAbs () const
 Returns maximum absolute value of all values. More...
 
bool hasNaNs () const
 Returns true if one or more values are NaN. More...
 
bool hasNegatives () const
 Returns true if one or more values are negative. More...
 
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]. More...
 
bool operator== (const TFactor< T > &y) const
 Comparison. More...
 
std::string toString () const
 Formats a factor as a string. More...
 
Unary transformations
TFactor< T > operator- () const
 Returns negative of *this. More...
 
TFactor< T > abs () const
 Returns pointwise absolute value. More...
 
TFactor< T > exp () const
 Returns pointwise exponent. More...
 
TFactor< T > log (bool zero=false) const
 Returns pointwise logarithm. More...
 
TFactor< T > inverse (bool zero=true) const
 Returns pointwise inverse. More...
 
TFactor< T > normalized (ProbNormType norm=NORMPROB) const
 Returns normalized copy of *this, using the specified norm. More...
 
Unary operations
TFactor< T > & randomize ()
 Draws all values i.i.d. from a uniform distribution on [0,1) More...
 
TFactor< T > & setUniform ()
 Sets all values to $1/n$ where n is the number of states. More...
 
TFactor< T > & takeAbs ()
 Applies absolute value pointwise. More...
 
TFactor< T > & takeExp ()
 Applies exponent pointwise. More...
 
TFactor< T > & takeLog (bool zero=false)
 Applies logarithm pointwise. More...
 
T normalize (ProbNormType norm=NORMPROB)
 Normalizes factor using the specified norm. More...
 
Operations with scalars
TFactor< T > & fill (T x)
 Sets all values to x. More...
 
TFactor< T > & operator+= (T x)
 Adds scalar x to each value. More...
 
TFactor< T > & operator-= (T x)
 Subtracts scalar x from each value. More...
 
TFactor< T > & operator*= (T x)
 Multiplies each value with scalar x. More...
 
TFactor< T > & operator/= (T x)
 Divides each entry by scalar x. More...
 
TFactor< T > & operator^= (T x)
 Raises values to the power x. More...
 
Transformations with scalars
TFactor< T > operator+ (T x) const
 Returns sum of *this and scalar x. More...
 
TFactor< T > operator- (T x) const
 Returns difference of *this and scalar x. More...
 
TFactor< T > operator* (T x) const
 Returns product of *this with scalar x. More...
 
TFactor< T > operator/ (T x) const
 Returns quotient of *this with scalar x. More...
 
TFactor< T > operator^ (T x) const
 Returns *this raised to the power x. More...
 
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. More...
 
TFactor< T > & operator+= (const TFactor< T > &g)
 Adds g to *this. More...
 
TFactor< T > & operator-= (const TFactor< T > &g)
 Subtracts g from *this. More...
 
TFactor< T > & operator*= (const TFactor< T > &g)
 Multiplies *this with g. More...
 
TFactor< T > & operator/= (const TFactor< T > &g)
 Divides *this by g (where division by zero yields zero) More...
 
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. More...
 
TFactor< T > operator+ (const TFactor< T > &g) const
 Returns sum of *this and g. More...
 
TFactor< T > operator- (const TFactor< T > &g) const
 Returns *this minus g. More...
 
TFactor< T > operator* (const TFactor< T > &g) const
 Returns product of *this with g. More...
 
TFactor< T > operator/ (const TFactor< T > &g) const
 Returns quotient of *this by f (where division by zero yields zero) More...
 
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. More...
 
TFactor< T > embed (const VarSet &vars) const
 Embeds this factor in a larger VarSet. More...
 
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. More...
 
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. More...
 

Private Attributes

VarSet _vs
 Stores the variables on which the factor depends. More...
 
TProb< T > _p
 Stores the factor values. More...
 

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. More...
 
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. More...
 
template<typename T >
TFactor< T > max (const TFactor< T > &f, const TFactor< T > &g)
 Returns the pointwise maximum of two factors. More...
 
template<typename T >
TFactor< T > min (const TFactor< T > &f, const TFactor< T > &g)
 Returns the pointwise minimum of two factors. More...
 
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. More...
 

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
TShould 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)?

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
SType of values of x
Parameters
varscontains the variables that the new factor should depend on.
xVector 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
varscontains the variables that the new factor should depend on.
pPoints 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

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>
std::string dai::TFactor< T >::toString ( ) const
inline

Formats a factor as a string.

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_NORMALIZABLEif 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_NORMALIZABLEif 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
binOpType of function object that accepts two arguments of type T and outputs a type T
Parameters
gRight operand
opOperation 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
binOpType of function object that accepts two arguments of type T and outputs a type T
Parameters
gRight operand
opOperation 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

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

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

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_vars_f.html0000644000175000017500000001074412552201370020142 0ustar jorismjorism libDAI: Class Members - Variables
 

- f -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__min.html0000644000175000017500000001220512552201365020561 0ustar jorismjorism libDAI: dai::fo_min< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_min< T > Struct Template Reference

Function object that returns the minimum of two values. More...

#include <dai/prob.h>

Inherits binary_function< T, T, T >.

Public Member Functions

T operator() (const T &x, const T &y) const
 Returns (x > y ? y : x) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1TProb.html0000644000175000017500000045652112552201370017773 0ustar jorismjorism libDAI: dai::TProb< T > Class Template Reference
Public Types | Public Member Functions | Private Attributes | Related Functions | List of all members
dai::TProb< T > Class Template Reference

Represents a vector with entries of type T. More...

#include <dai/prob.h>

Public Types

typedef std::vector< T > container_type
 Type of data structure used for storing the values. More...
 
typedef TProb< T > this_type
 Shorthand. More...
 
typedef container_type::const_iterator const_iterator
 Constant iterator over the elements. More...
 
typedef container_type::iterator iterator
 Iterator over the elements. More...
 
typedef container_type::const_reverse_iterator const_reverse_iterator
 Constant reverse iterator over the elements. More...
 
typedef container_type::reverse_iterator reverse_iterator
 Reverse iterator over the elements. More...
 

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. More...
 
Constructors and destructors
 TProb ()
 Default constructor (constructs empty vector) More...
 
 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$) More...
 
 TProb (size_t n, T p)
 Construct vector of length n with each entry set to p. More...
 
template<typename TIterator >
 TProb (TIterator begin, TIterator end, size_t sizeHint)
 Construct vector from a range. More...
 
template<typename S >
 TProb (const std::vector< S > &v)
 Construct vector from another vector. More...
 
Iterator interface
iterator begin ()
 Returns iterator that points to the first element. More...
 
const_iterator begin () const
 Returns constant iterator that points to the first element. More...
 
iterator end ()
 Returns iterator that points beyond the last element. More...
 
const_iterator end () const
 Returns constant iterator that points beyond the last element. More...
 
reverse_iterator rbegin ()
 Returns reverse iterator that points to the last element. More...
 
const_reverse_iterator rbegin () const
 Returns constant reverse iterator that points to the last element. More...
 
reverse_iterator rend ()
 Returns reverse iterator that points beyond the first element. More...
 
const_reverse_iterator rend () const
 Returns constant reverse iterator that points beyond the first element. More...
 
Miscellaneous operations
void resize (size_t sz)
 
Get/set individual entries
T get (size_t i) const
 Gets i 'th entry. More...
 
void set (size_t i, T val)
 Sets i 'th entry to val. More...
 
Queries
const container_type & p () const
 Returns a const reference to the wrapped container. More...
 
container_type & p ()
 Returns a reference to the wrapped container. More...
 
T operator[] (size_t i) const
 Returns a copy of the i 'th entry. More...
 
size_t size () const
 Returns length of the vector (i.e., the number of entries) More...
 
template<typename unOp >
T accumulateSum (T init, unOp op) const
 Accumulate all values (similar to std::accumulate) by summing. More...
 
template<typename unOp >
T accumulateMax (T init, unOp op, bool minimize) const
 Accumulate all values (similar to std::accumulate) by maximization/minimization. More...
 
T entropy () const
 Returns the Shannon entropy of *this, $-\sum_i p_i \log p_i$. More...
 
T max () const
 Returns maximum value of all entries. More...
 
T min () const
 Returns minimum value of all entries. More...
 
T sum () const
 Returns sum of all entries. More...
 
T sumAbs () const
 Return sum of absolute value of all entries. More...
 
T maxAbs () const
 Returns maximum absolute value of all entries. More...
 
bool hasNaNs () const
 Returns true if one or more entries are NaN. More...
 
bool hasNegatives () const
 Returns true if one or more entries are negative. More...
 
std::pair< size_t, T > argmax () const
 Returns a pair consisting of the index of the maximum value and the maximum value itself. More...
 
size_t draw ()
 Returns a random index, according to the (normalized) distribution described by *this. More...
 
bool operator< (const this_type &q) const
 Lexicographical comparison. More...
 
bool operator== (const this_type &q) const
 Comparison. More...
 
std::string toString () const
 Formats a TProb as a string. More...
 
Unary transformations
template<typename unaryOp >
this_type pwUnaryTr (unaryOp op) const
 Returns the result of applying operation op pointwise on *this. More...
 
this_type operator- () const
 Returns negative of *this. More...
 
this_type abs () const
 Returns pointwise absolute value. More...
 
this_type exp () const
 Returns pointwise exponent. More...
 
this_type log (bool zero=false) const
 Returns pointwise logarithm. More...
 
this_type inverse (bool zero=true) const
 Returns pointwise inverse. More...
 
this_type normalized (ProbNormType norm=dai::NORMPROB) const
 Returns normalized copy of *this, using the specified norm. More...
 
Unary operations
template<typename unaryOp >
this_type & pwUnaryOp (unaryOp op)
 Applies unary operation op pointwise. More...
 
this_type & randomize ()
 Draws all entries i.i.d. from a uniform distribution on [0,1) More...
 
this_type & setUniform ()
 Sets all entries to $1/n$ where n is the length of the vector. More...
 
this_type & takeAbs ()
 Applies absolute value pointwise. More...
 
this_type & takeExp ()
 Applies exponent pointwise. More...
 
this_type & takeLog (bool zero=false)
 Applies logarithm pointwise. More...
 
T normalize (ProbNormType norm=dai::NORMPROB)
 Normalizes vector using the specified norm. More...
 
Operations with scalars
this_type & fill (T x)
 Sets all entries to x. More...
 
this_type & operator+= (T x)
 Adds scalar x to each entry. More...
 
this_type & operator-= (T x)
 Subtracts scalar x from each entry. More...
 
this_type & operator*= (T x)
 Multiplies each entry with scalar x. More...
 
this_type & operator/= (T x)
 Divides each entry by scalar x, where division by 0 yields 0. More...
 
this_type & operator^= (T x)
 Raises entries to the power x. More...
 
Transformations with scalars
this_type operator+ (T x) const
 Returns sum of *this and scalar x. More...
 
this_type operator- (T x) const
 Returns difference of *this and scalar x. More...
 
this_type operator* (T x) const
 Returns product of *this with scalar x. More...
 
this_type operator/ (T x) const
 Returns quotient of *this and scalar x, where division by 0 yields 0. More...
 
this_type operator^ (T x) const
 Returns *this raised to the power x. More...
 
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. More...
 
this_type & operator+= (const this_type &q)
 Pointwise addition with q. More...
 
this_type & operator-= (const this_type &q)
 Pointwise subtraction of q. More...
 
this_type & operator*= (const this_type &q)
 Pointwise multiplication with q. More...
 
this_type & operator/= (const this_type &q)
 Pointwise division by q, where division by 0 yields 0. More...
 
this_type & divide (const this_type &q)
 Pointwise division by q, where division by 0 yields +Inf. More...
 
this_type & operator^= (const this_type &q)
 Pointwise power. More...
 
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. More...
 
this_type operator+ (const this_type &q) const
 Returns sum of *this and q. More...
 
this_type operator- (const this_type &q) const
 Return *this minus q. More...
 
this_type operator* (const this_type &q) const
 Return product of *this with q. More...
 
this_type operator/ (const this_type &q) const
 Returns quotient of *this with q, where division by 0 yields 0. More...
 
this_type divided_by (const this_type &q) const
 Pointwise division by q, where division by 0 yields +Inf. More...
 
this_type operator^ (const this_type &q) const
 Returns *this to the power q. More...
 

Private Attributes

container_type _p
 The data structure that stores the values. More...
 

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. More...
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const TProb< T > &p)
 Writes a TProb<T> to an output stream. More...
 
template<typename T >
TProb< T > min (const TProb< T > &a, const TProb< T > &b)
 Returns the pointwise minimum of a and b. More...
 
template<typename T >
TProb< T > max (const TProb< T > &a, const TProb< T > &b)
 Returns the pointwise maximum of a and b. More...
 

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
TShould 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)
inlineexplicit

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 
)
inlineexplicit

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
TIteratorIterates over instances that can be cast to T
Parameters
beginPoints to first instance to be added.
endPoints just beyond last instance to be added.
sizeHintFor 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
Stype of elements in v (should be castable to type T)
Parameters
vvector 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>
std::string dai::TProb< T >::toString ( ) const
inline

Formats a TProb as a string.

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_NORMALIZABLEif 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_NORMALIZABLEif 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
binaryOpType of function object that accepts two arguments of type T and outputs a type T
Parameters
qRight operand
opOperation 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
binaryOpType of function object that accepts two arguments of type T and outputs a type T
Parameters
qRight operand
opOperation 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_38.png0000644000175000017500000000053512552200224015661 0ustar jorismjorism‰PNG  IHDR'¢–0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÌIDATxí]]š„ K QGïÛm*‚îÏÛ¾ö¦¥!†0€ÿŸyd’àY½ÙÎ+/fËñ à1dõ%}zµšNUnxŒU}iK¯Šù¡ v×3‚鸿ã,{*^ãàò¤—ÕiÀH€LRñ~?ßfà†¼ §”ÜcälÉ`køÈ2MÜ²Ý Ø8¥¸5ÔGC^nû¥º/¾«^èN–jªÍ¾3pÚµÕÅ­£Ï¢ûo|ñn·-ƼY–á''äyþ%šÍ{ØÎ÷úɯÙàJ؇IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1GraphEL.png0000644000175000017500000000102112552201366020031 0ustar jorismjorism‰PNG  IHDRoP 7Û*PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2 IDATxíÛrë E—^²ÿÿ›Ú ‚s&ŽJ:=Ì°ã–nn^13›(L’¦iñ$)Oæ•/ãºÝíëýcŸ»g†É¼ó+’ÔÊyß!nqÞåf{àe¿õöÀ+†õ1‚WžI¾Lê–;®nz^0t›Ö¤å¹¹‡\?“`Úõ/ÞêÜ„ ›zž\¬› ò‹<¢HŒóÒ¯Û­ùy’|=æg’¯XÏêßQ¹c¾š~í¥é®T¬¾/ͧ$¥éÜg>¯ï¿¤°~ ¿q!×ï‘$¥ë?à™™ÍÀÝ&j2ïv› œÌ»ã¦góþü|.@¢ O‹§ÅÈÓâäiñò´xyZ<€ÌÌ& ˜¦ÅÈÓïáù~¸±MÀƒÊvÂ'^ÿÍëöÆï‰õ^yOölê˜òwå´}\ámÎv#ƒ¸<žzZÎÚ+/óBšüÚ”› JÎúw¸ìl÷?*ÏOÛÇåü:ïñÒ;¼.ôXÐŽç»Ì‹ó¹¢—°©çv#¨ý;ySßÿÿòšýâäiñòôž™Ù<}ÀÓ@O ·M¦IEND®B`‚libDAI-0.3.2/doc/html/ideas.html0000644000175000017500000002642512552201364015665 0ustar jorismjorism libDAI: Ideas worth exploring
Ideas worth exploring
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?
Author
Frederik Eaton
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.

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.

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 doc.h

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

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

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.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1IndexFor-members.html0000644000175000017500000001322112552201366022102 0ustar jorismjorism libDAI: Member List
dai::IndexFor Member List

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

_indexdai::IndexForprivate
_rangesdai::IndexForprivate
_statedai::IndexForprivate
_sumdai::IndexForprivate
IndexFor()dai::IndexForinline
IndexFor(const VarSet &indexVars, const VarSet &forVars)dai::IndexForinline
operator size_t() const dai::IndexForinline
operator++()dai::IndexForinline
operator++(int)dai::IndexForinline
reset()dai::IndexForinline
valid() const dai::IndexForinline
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/smallset_8h_source.html0000644000175000017500000016425312552201363020404 0ustar jorismjorism libDAI: include/dai/smallset.h Source File
smallset.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_smallset_h
14 #define __defined_libdai_smallset_h
15 
16 
17 #include <vector>
18 #include <algorithm>
19 #include <iostream>
20 #include <sstream>
21 
22 
23 namespace dai {
24 
25 
27 
31 template <typename T>
32 class SmallSet {
33  private:
35  std::vector<T> _elements;
36 
37  public:
39 
40  SmallSet() : _elements() {}
42 
44  SmallSet( const T &t ) : _elements() {
45  _elements.push_back( t );
46  }
47 
49  SmallSet( const T &t1, const T &t2 ) {
50  if( t1 < t2 ) {
51  _elements.push_back( t1 );
52  _elements.push_back( t2 );
53  } else if( t2 < t1 ) {
54  _elements.push_back( t2 );
55  _elements.push_back( t1 );
56  } else
57  _elements.push_back( t1 );
58  }
59 
61 
67  template <typename TIterator>
68  SmallSet( TIterator begin, TIterator end, size_t sizeHint ) {
69  _elements.reserve( sizeHint );
70  _elements.insert( _elements.begin(), begin, end );
71  std::sort( _elements.begin(), _elements.end() );
72  typename std::vector<T>::iterator new_end = std::unique( _elements.begin(), _elements.end() );
73  _elements.erase( new_end, _elements.end() );
74  }
76 
78 
79  SmallSet& insert( const T& t ) {
81  typename SmallSet<T>::iterator it = std::lower_bound( _elements.begin(), _elements.end(), t );
82  if( (it == _elements.end()) || (*it != t) )
83  _elements.insert( it, t );
84  return *this;
85  }
86 
88  SmallSet& erase( const T& t ) {
89  return (*this /= t);
90  }
91 
93  SmallSet operator/ ( const SmallSet& x ) const {
94  SmallSet res;
95  std::set_difference( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
96  return res;
97  }
98 
100  SmallSet operator| ( const SmallSet& x ) const {
101  SmallSet res;
102  std::set_union( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
103  return res;
104  }
105 
107  SmallSet operator& ( const SmallSet& x ) const {
108  SmallSet res;
109  std::set_intersection( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end(), inserter( res._elements, res._elements.begin() ) );
110  return res;
111  }
112 
114  SmallSet& operator/= ( const SmallSet& x ) {
115  return (*this = (*this / x));
116  }
117 
119  SmallSet& operator/= ( const T &t ) {
120  typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
121  if( pos != _elements.end() )
122  if( *pos == t ) // found element, delete it
123  _elements.erase( pos );
124  return *this;
125  }
126 
128  SmallSet& operator|= ( const SmallSet& x ) {
129  return( *this = (*this | x) );
130  }
131 
133  SmallSet& operator|= ( const T& t ) {
134  typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
135  if( pos == _elements.end() || *pos != t ) // insert it
136  _elements.insert( pos, t );
137  return *this;
138  }
139 
141  SmallSet& operator&= ( const SmallSet& x ) {
142  return (*this = (*this & x));
143  }
144 
146  bool operator<< ( const SmallSet& x ) const {
147  return std::includes( x._elements.begin(), x._elements.end(), _elements.begin(), _elements.end() );
148  }
149 
151  bool operator>> ( const SmallSet& x ) const {
152  return std::includes( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end() );
153  }
155 
157 
158  bool intersects( const SmallSet& x ) const {
160  return( (*this & x).size() > 0 );
161  }
162 
164  bool contains( const T &t ) const {
165  return std::binary_search( _elements.begin(), _elements.end(), t );
166  }
167 
169  typename std::vector<T>::size_type size() const { return _elements.size(); }
170 
172  bool empty() const { return _elements.size() == 0; }
173 
175  std::vector<T>& elements() { return _elements; }
176 
178  const std::vector<T>& elements() const { return _elements; }
180 
182  typedef typename std::vector<T>::const_iterator const_iterator;
184  typedef typename std::vector<T>::iterator iterator;
186  typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
188  typedef typename std::vector<T>::reverse_iterator reverse_iterator;
189 
191 
192  iterator begin() { return _elements.begin(); }
195  const_iterator begin() const { return _elements.begin(); }
196 
198  iterator end() { return _elements.end(); }
200  const_iterator end() const { return _elements.end(); }
201 
203  reverse_iterator rbegin() { return _elements.rbegin(); }
205  const_reverse_iterator rbegin() const { return _elements.rbegin(); }
206 
208  reverse_iterator rend() { return _elements.rend(); }
210  const_reverse_iterator rend() const { return _elements.rend(); }
211 
213  T& front() { return _elements.front(); }
215  const T& front() const { return _elements.front(); }
216 
218  T& back() { return _elements.back(); }
220  const T& back() const { return _elements.back(); }
222 
224 
225  friend bool operator==( const SmallSet &a, const SmallSet &b ) {
227  return (a._elements == b._elements);
228  }
229 
231  friend bool operator!=( const SmallSet &a, const SmallSet &b ) {
232  return !(a._elements == b._elements);
233  }
234 
236  friend bool operator<( const SmallSet &a, const SmallSet &b ) {
237  return a._elements < b._elements;
238  }
240 
242 
243  friend std::ostream& operator << ( std::ostream& os, const SmallSet& x ) {
245  os << "{";
246  for( typename std::vector<T>::const_iterator it = x.begin(); it != x.end(); it++ )
247  os << (it != x.begin() ? ", " : "") << *it;
248  os << "}";
249  return os;
250  }
251 
253  std::string toString() const {
254  std::stringstream ss;
255  ss << *this;
256  return ss.str();
257  }
259 };
260 
261 
262 } // end of namespace dai
263 
264 
265 #endif
dai::SmallSet::back
const T & back() const
Returns constant reference to last element.
Definition: smallset.h:220
dai::SmallSet::end
iterator end()
Returns iterator that points beyond the last element.
Definition: smallset.h:198
dai::SmallSet::operator|=
SmallSet & operator|=(const SmallSet &x)
Adds to *this all elements in x.
Definition: smallset.h:128
dai::SmallSet::operator!=
friend bool operator!=(const SmallSet &a, const SmallSet &b)
Returns true if a and b are not identical.
Definition: smallset.h:231
dai::SmallSet::SmallSet
SmallSet(const T &t)
Construct a set consisting of one element.
Definition: smallset.h:44
dai::SmallSet::operator==
friend bool operator==(const SmallSet &a, const SmallSet &b)
Returns true if a and b are identical.
Definition: smallset.h:226
dai::SmallSet::SmallSet
SmallSet()
Default constructor (constructs an empty set)
Definition: smallset.h:41
dai::SmallSet::_elements
std::vector< T > _elements
The elements in this set.
Definition: smallset.h:35
dai::SmallSet::intersects
bool intersects(const SmallSet &x) const
Returns true if *this and x have elements in common.
Definition: smallset.h:159
dai::SmallSet::size
std::vector< T >::size_type size() const
Returns number of elements.
Definition: smallset.h:169
dai::SmallSet::begin
iterator begin()
Returns iterator that points to the first element.
Definition: smallset.h:193
dai::SmallSet::insert
SmallSet & insert(const T &t)
Inserts t into *this.
Definition: smallset.h:80
dai::SmallSet::iterator
std::vector< T >::iterator iterator
Iterator over the elements.
Definition: smallset.h:184
dai::SmallSet::operator&
SmallSet operator&(const SmallSet &x) const
Set-intersection operator: returns all elements in *this that are also contained in x...
Definition: smallset.h:107
dai::SmallSet::begin
const_iterator begin() const
Returns constant iterator that points to the first element.
Definition: smallset.h:195
dai::SmallSet::SmallSet
SmallSet(TIterator begin, TIterator end, size_t sizeHint)
Construct a SmallSet from a range of elements.
Definition: smallset.h:68
dai::SmallSet::rend
const_reverse_iterator rend() const
Returns constant reverse iterator that points beyond the first element.
Definition: smallset.h:210
dai::SmallSet::rend
reverse_iterator rend()
Returns reverse iterator that points beyond the first element.
Definition: smallset.h:208
dai::SmallSet::contains
bool contains(const T &t) const
Returns true if *this contains the element t.
Definition: smallset.h:164
dai::SmallSet::end
const_iterator end() const
Returns constant iterator that points beyond the last element.
Definition: smallset.h:200
dai::SmallSet::const_iterator
std::vector< T >::const_iterator const_iterator
Constant iterator over the elements.
Definition: smallset.h:182
dai::SmallSet::operator/=
SmallSet & operator/=(const SmallSet &x)
Erases from *this all elements in x.
Definition: smallset.h:114
dai::SmallSet::back
T & back()
Returns reference to last element.
Definition: smallset.h:218
dai::SmallSet::const_reverse_iterator
std::vector< T >::const_reverse_iterator const_reverse_iterator
Constant reverse iterator over the elements.
Definition: smallset.h:186
dai::SmallSet::operator<
friend bool operator<(const SmallSet &a, const SmallSet &b)
Lexicographical comparison of elements.
Definition: smallset.h:236
dai::SmallSet::reverse_iterator
std::vector< T >::reverse_iterator reverse_iterator
Reverse iterator over the elements.
Definition: smallset.h:188
dai::SmallSet::rbegin
const_reverse_iterator rbegin() const
Returns constant reverse iterator that points to the last element.
Definition: smallset.h:205
dai::SmallSet::operator|
SmallSet operator|(const SmallSet &x) const
Set-union operator: returns all elements in *this, plus those in x.
Definition: smallset.h:100
dai::SmallSet::operator&=
SmallSet & operator&=(const SmallSet &x)
Erases from *this all elements not in x.
Definition: smallset.h:141
dai::SmallSet::front
const T & front() const
Returns constant reference to first element.
Definition: smallset.h:215
dai::SmallSet::elements
const std::vector< T > & elements() const
Returns constant reference to the elements.
Definition: smallset.h:178
dai::SmallSet::erase
SmallSet & erase(const T &t)
Erases t from *this.
Definition: smallset.h:88
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::SmallSet::elements
std::vector< T > & elements()
Returns reference to the elements.
Definition: smallset.h:175
dai::SmallSet::front
T & front()
Returns reference to first element.
Definition: smallset.h:213
dai::SmallSet::operator/
SmallSet operator/(const SmallSet &x) const
Set-minus operator: returns all elements in *this, except those in x.
Definition: smallset.h:93
dai::SmallSet::toString
std::string toString() const
Formats a SmallSet as a string.
Definition: smallset.h:253
dai::SmallSet
Represents a set; the implementation is optimized for a small number of elements. ...
Definition: smallset.h:32
dai::SmallSet::rbegin
reverse_iterator rbegin()
Returns reverse iterator that points to the last element.
Definition: smallset.h:203
dai::SmallSet::SmallSet
SmallSet(const T &t1, const T &t2)
Construct a set consisting of two elements.
Definition: smallset.h:49
dai::SmallSet::operator<<
bool operator<<(const SmallSet &x) const
Returns true if *this is a subset of x.
Definition: smallset.h:146
dai::SmallSet::empty
bool empty() const
Returns whether *this is empty.
Definition: smallset.h:172
dai::SmallSet::operator>>
bool operator>>(const SmallSet &x) const
Returns true if x is a subset of *this.
Definition: smallset.h:151
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_e.html0000644000175000017500000002162012552201370017101 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- e -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/gibbs_8h_source.html0000644000175000017500000005453312552201363017645 0ustar jorismjorism libDAI: include/dai/gibbs.h Source File
gibbs.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_gibbs_h
14 #define __defined_libdai_gibbs_h
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_GIBBS
19 
20 
21 #include <dai/daialg.h>
22 #include <dai/factorgraph.h>
23 #include <dai/properties.h>
24 
25 
26 namespace dai {
27 
28 
30 
32 class Gibbs : public DAIAlgFG {
33  private:
35  typedef std::vector<size_t> _count_t;
37  typedef std::vector<size_t> _state_t;
39  size_t _sample_count;
41  std::vector<_count_t> _var_counts;
43  std::vector<_count_t> _factor_counts;
45  size_t _iters;
47  _state_t _state;
49  _state_t _max_state;
51  Real _max_score;
52 
53  public:
55  struct Properties {
57  size_t maxiter;
58 
60  double maxtime;
61 
63  size_t restart;
64 
66  size_t burnin;
67 
69  size_t verbose;
70  } props;
71 
72  public:
74  Gibbs() : DAIAlgFG(), _sample_count(0), _var_counts(), _factor_counts(), _iters(0), _state(), _max_state(), _max_score(-INFINITY) {}
75 
77 
80  Gibbs( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), _sample_count(0), _var_counts(), _factor_counts(), _iters(0), _state(), _max_state(), _max_score(-INFINITY) {
81  setProperties( opts );
82  construct();
83  }
84 
85 
87 
88  virtual Gibbs* clone() const { return new Gibbs(*this); }
89  virtual Gibbs* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new Gibbs( fg, opts ); }
90  virtual std::string name() const { return "GIBBS"; }
91  virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); }
92  virtual Factor belief( const VarSet &vs ) const;
93  virtual Factor beliefV( size_t i ) const;
94  virtual Factor beliefF( size_t I ) const;
95  virtual std::vector<Factor> beliefs() const;
96  virtual Real logZ() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; }
97  std::vector<size_t> findMaximum() const { return _max_state; }
98  virtual void init();
99  virtual void init( const VarSet &/*ns*/ ) { init(); }
100  virtual Real run();
101  virtual Real maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; }
102  virtual size_t Iterations() const { return _iters; }
103  virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; }
104  virtual void setProperties( const PropertySet &opts );
105  virtual PropertySet getProperties() const;
106  virtual std::string printProperties() const;
108 
109 
111 
112  void randomizeState();
115  std::vector<size_t>& state() { return _state; }
117  const std::vector<size_t>& state() const { return _state; }
119 
120  private:
122  void construct();
124  void updateCounts();
126  Prob getVarDist( size_t i );
128  void resampleVar( size_t i );
130  size_t getFactorEntry( size_t I );
132  size_t getFactorEntryDiff( size_t I, size_t i );
133 };
134 
135 
137 
139 std::vector<size_t> getGibbsState( const FactorGraph &fg, size_t maxiter );
140 
141 
142 } // end of namespace dai
143 
144 
150 #endif
151 
152 
153 #endif
dai::Factor
TFactor< Real > Factor
Represents a factor with values of type dai::Real.
Definition: factor.h:640
dai::Prob
TProb< Real > Prob
Represents a vector with entries of type dai::Real.
Definition: prob.h:766
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::findMaximum
std::vector< size_t > findMaximum(const InfAlg &obj)
Calculates the joint state of all variables that has maximum probability, according to the inference ...
Definition: daialg.cpp:211
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::DAIAlgFG
DAIAlg< FactorGraph > DAIAlgFG
Base class for inference algorithms that operate on a FactorGraph.
Definition: daialg.h:263
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1DAIAlg.png0000644000175000017500000000474312552201365017605 0ustar jorismjorism‰PNG  IHDRJE¦PLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2 rIDATxíÝír²<„á›Í çȯò!‹h«…÷À:»’¢í4!ü¥”Rv,À1Z$i·"’,„$K…Ír4RÓûvZ’~lÕomšþxfˆÛ¿O¯é.¼¯ˆÛùûû¸ Ã/HÒ­ ¢›ë0C©ñAôÿû+Ûùlë9 æ§noãQ’>kµ· >\úÙŠ¸Ä}²Ã„És=ˆq¢ã¼¯¹GŒý„_ß’ôq×C´mÛnÒ¿@Øaw€Mºn¸*„?5ºÑq¤¯Z-„$mÙ@B’%ƒC ‡@ 18 ¢”Rö+ÀšnPqÀˆ@–@°"€%,` D K XÀˆ@–@°"€%,` D K 6‡(¥” °¦BHÒn D $YI–J!š#5·×pð£$ýÞê!žÎÝÞž’ô{k„¸]çáŠûLçƒ+@Üç8̳‘<׃ç·˜ÿ¸U\b!úyþrkHÒG]Ѷm»I¿„°Ã1 6éŸ÷ˆŸž’ôQ+jt£Çäç{Ãù!$ió"’,„$K !ɈB”RÊ~XÓí *n XÀˆ@–@°"€%,` D K XÀˆ@–@°"€%,` Ä楔²cÖtCIÚ­„$K !ÉRD³5ÝK’–½¶OÞ}«nˆŸN½†ø™¡&ˆÛ½O¦¿þÓŠ°Ã}âýuï÷·ÎbüA’Þ¶ˆn2ýŒÉcWúÔ¾1ÿ¢$½jMvù—{ÄãŠOŸ.p$é]«ƒèçý|kŒ³Oÿ1DÛ¶í&ýâyZoo3¯ˆùñj³|¹Gœ ŸÃÓ`xL O‡ÇSãñŒŸ'ƒ¤ÿ±„$K !Ɉ@H²â€¥”²_Öt;€Šˆ@–@°"€%,` D K XÀˆ@–@°"€%,` D K X±9D)¥ìX€5ÝB’vk !Ɉ@H²T Ñ,Gý`ñ>}S’Þ·zˆ§SÃäŸ:T ÑômnÇ×+b‚øØ¡Fˆûü†96’GR3ëç•BŒ3ôk~[ ÷—Ct?IÒ­¢Ÿö‹[Ã@þå­Ñ¶m»I¿„xžêb68óf¹Ø#~‚8õãÓžÝèi³\$é·Ö!I›7d D $YI–@¢”Rö+ÀšnPqÀˆ@–@°"€%,` D K XÀˆ@–@°"€%,` D K 6‡(¥” °¦BHÒn D $YI– !š£î‡¦IÒ÷­BÒ”îô*„¸]ðûdû ÿ´"gºï kãÓ%RD7Á~¾ýaøá bö•Ï–I}6ñ÷+â2ý¦ø#Äð•O·ÏõmÛ¶›ô ;ÌÊ|E|³{Ö¾Güqâ[ßý³áq#ØðÇÅIŸ’ôÿ4d ÄàˆÁ!ƒC ‡@ G‚(¥”ý °¦ÛATÜ@°"€%,` D K XÀˆ@–@°"€%,` D K XÀˆÍ!J)eǬ醒´[I–@B’¥fˆf9š·—$}Üs@,Nuǯ$ª…¸]ðûDû ÿ¼"¾[ UCܦz'<׃°Y_{EŒ·ÆQ Ú¶m7é_ ì=âÄEŸÝhH«Œ·Œ$}Øj!$iË"’,„$K !ɈB”RÊ~XÓí *n XÀˆ@–@°"€%,` D K XÀˆ@–@°"€%,` Ä楔²cÖtCIÚ­„$K !ÉR/D³ƒÛ±é^’ôaÏ1êÏÝßÔ q›ë}ªýEŸVÄå ºµß϶‘,ý™KAŒSõI;Ä—[Dåýl}³—Ã+¢mÛv“~a‡@lÒ5{ÄÓB¹äSÃÖÀ!$iÛ"’,„$K !ɈB”RÊ~XÓí *n XÀˆ@–@°"€%,` D K XÀˆ@–@°"€%,` Ä楔²cÖtCIÚ­„$K !ÉR/D³ƒÛ±¹¿$éÓžb:ÕŸ»ºÑ7•BÜæzŸeÕ§q9ˆní÷m$KæRã,ÇI÷ã â{ÄÑÏÖ7Ëq9ÌnIú­ë!Ú¶m7é÷vxñoo €mºfxZ(—𧆭 BHÒ¶ D $YI–@B’%„(¥”ýúŸ=ø@ÂØíIEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1MR_1_1Properties.html0000644000175000017500000002660212552201367022216 0ustar jorismjorism libDAI: dai::MR::Properties Struct Reference
Public Member Functions | Public Attributes | List of all members
dai::MR::Properties Struct Reference

Parameters for MR. More...

#include <dai/mr.h>

Public Member Functions

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

Public Attributes

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

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/bc_s.png0000644000175000017500000000124412552201363015315 0ustar jorismjorism‰PNG  IHDR€_ kIDATxíËkQÆϹÉ̤I&“¦mš&156*nÄ…”ܸR,4 +Hµ(U­b”ª1‚ŠˆJ.º(E·mßúhëJmKS'C›(‚èäÑ…¤ï &äÖþ ‡ïrÎåü3gö(z÷ýÒ&_9ó}’ÕŸ@‰mÚu ` Øh`ñ÷Ô¯  „ú&·ññ×Ù~“½—Üò‡ÎÝÑM4¸%‰3²§?Êêh)€ÿù™\ÄYi>Jb @gûßiÞˆú²Ñkg§ãê\è½­šEUæv+?E€î"pæÖÛB\ƒY&ðØó$vM+ê’Dn¼)}òþ:§Xoâ ƒ3ŠÚ¯'¯¿.‚fÁ0ìuŠ9òLýj€f6¸%«3Gf”Ô#Ôsm(,ùÃk*Ê’³Jª…¯¼JË¢o䆔¼u_~ °r]%%mnu]z°r5[ÍÆ°«Úò•Xeµ’†Iù<ÈèÐÅg@IÔÚÞàµë3‚:/<JÇ’ÐQ) ñ¹…tÚß÷(Mû\63éCgl!ýí;ÿ¸4Ùhâñ=÷Zë29­w’ÝÒ´·ˆV;ÊL3ƒj&7©·º½÷a!I†)ëë$-öÇÓú³›‹7tIV¾VàñÔübf¨8¡ÈƒB<﫵imnÿœÈ‡„ lߣù‡ÛD —#É5“­'Æ4?쬲øM’™›°»g¬‚|5Åçµ½GNdÓÐr|ô”Ã&„ì"7+'³@ 5‡Gâž‘Ç…âɬ^;õã–.3Òr"ý_R³¿Â@²oI¾å$IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1HAK-members.html0000644000175000017500000004261612552201366021001 0ustar jorismjorism libDAI: Member List
dai::HAK Member List

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

_itersdai::HAKprivate
_maxdiffdai::HAKprivate
_muabdai::HAKprivate
_mubadai::HAKprivate
_Qadai::HAKprivate
_Qbdai::HAKprivate
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const VarSet &vs) const dai::HAKvirtual
dai::DAIAlg::belief(const Var &v) const dai::InfAlginlinevirtual
beliefF(size_t I) const dai::InfAlginlinevirtual
beliefs() const dai::HAKvirtual
beliefV(size_t i) const dai::InfAlginlinevirtual
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clone() const dai::HAKinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::HAKinlinevirtual
construct()dai::HAKprivate
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
doDoubleLoop()dai::HAK
doGBP()dai::HAK
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findLoopClusters(const FactorGraph &fg, std::set< VarSet > &allcl, VarSet newcl, const Var &root, size_t length, VarSet vars)dai::HAKprivate
findMaximum() const dai::InfAlginlinevirtual
getProperties() const dai::HAKvirtual
HAK()dai::HAKinline
HAK(const FactorGraph &fg, const PropertySet &opts)dai::HAK
HAK(const RegionGraph &rg, const PropertySet &opts)dai::HAK
identify() const dai::InfAlginlinevirtual
init()dai::HAKvirtual
init(const VarSet &vs)dai::HAKvirtual
Iterations() const dai::HAKinlinevirtual
logZ() const dai::HAKvirtual
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::HAKinlinevirtual
muab(size_t alpha, size_t _beta)dai::HAKinline
muba(size_t alpha, size_t _beta)dai::HAKinline
name() const dai::HAKinlinevirtual
printProperties() const dai::HAKvirtual
props (defined in dai::HAK)dai::HAK
Qa(size_t alpha) const dai::HAKinline
Qb(size_t beta) const dai::HAKinline
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()dai::HAKvirtual
setMaxIter(size_t maxiter)dai::HAKinlinevirtual
setProperties(const PropertySet &opts)dai::HAKvirtual
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1TreeEP.png0000644000175000017500000000211012552201370017666 0ustar jorismjorism‰PNG  IHDR­ÀAõPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2×IDATxíݲƒ —ßÿ‘­µ6õ0Ç­"]#¤·äœs7%©ÂV’|[Iòá´mÚ¶Ö.¥©]:L·$}Âm •ëå¶cêniJ¡ÍíØû\R{·o¤O8e; ÍR²ç½u6#’ôgm—T-j¦½o{in—•ðȶ ÿ[«¶µ½„`[¯Ûl¯[·¶&L-{îÙ^Z$émú±½tÝJÒ{Ìÿ’ô ¿_ ’ô)a+I>„­$ù0Úæœs/80tCW¶ÃГnW¶£lGº}ÙFMð"l|[ÂÀ‡°ð!l|[ÂÀ‡°ð!l|[ÂÀ‡°½9çÜ dIê„°•$ÂV’|¨lÓ¶•nGÕ¹ý”Töž½É«@IÚrÐ}`[w-jëÛ–¤ŠC’ÖóÙ’T³ÚŽy‹)»æÖλk;ß·g1§®DØÉëß(³5c»Y¿ÛNñóœR2§¤tÌ|_‘ªmëÓa§^îlÆ̸ñ¶¶Ë¸éÛ%Åíº­#ªV›ìê‡Í¬ïƶüÒž­uXÛ;ï­‰zdk¼Úàj}Íó·¶ÕLÖÖ6Úv›Ûú½f»“÷ǹmž­Ù1Ƕo¯Û*ÿmƒ£ukk²‡ËN7öíG5a}ùíS/vŠÂWþËž×Öªï+§m²ðVÄïl—×-I<ø­$ýŠ°•$ÂV’|msιº¡+ÛaèI·+ÛQ¶#ݾl£&x¶>„-€a àCØø¶>„-€a àCØø¶>„-€a àCØÞŽœsî²$uBØJ’a+I>œ¶M;­éK*‡$}/ÚJZÏ©û»ª§mÇÔÝŒJ ›ÜÞ{¦˜9Ë'“}Êv²(Rå2il«S ?kkìŽsû¿lËnzh;‡œÜwß°5—:åun¿°í¾»nÚ^½lM(;ÿþÞM*m1¸²&HÒO [Iò!l%ɇ°•$º³Í9ç^p`膮l‡¡'Ý®lGÙŽtû²šàEØø¶>„-€a àCØø¶>„-€a àCØø¶>„-€a{;RJ©H¶>„-€§l×[—Ö²u–‘À'|ÉöY§} GAøÜv.~%Qf’Òœç$Ö!—ØN2ågËeþ²ØVc÷Á m—[ŠÉíÆöÊu{×) »¶•^•[€8kÛ¼æMn7—Ël›µùl%\ikkB)õ.[‹ÁRšð.ñÏ àCØø¶>„-€£mJ)õÂ)`h¡á¾©^IEND®B`‚libDAI-0.3.2/doc/html/config_8h_source.html0000644000175000017500000001000012552201363020001 0ustar jorismjorism libDAI: config.h Source File
config.h
1 # DO NOT EDIT
2 # Automatically generated by running ./configure
3 
4 #define DAI_WITH_BP
5 #define DAI_WITH_FBP
6 #define DAI_WITH_TRWBP
7 #define DAI_WITH_MF
8 #define DAI_WITH_HAK
9 #define DAI_WITH_LC
10 #define DAI_WITH_TREEEP
11 #define DAI_WITH_JTREE
12 #define DAI_WITH_MR
13 #define DAI_WITH_GIBBS
14 #define DAI_WITH_CBP
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_11.png0000644000175000017500000000036112552200216015646 0ustar jorismjorism‰PNG  IHDRÚ­¿0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï`IDATxíQÅ Ç h©©÷¿m}öµêG°$Ër€Ï ÀŒæ À@«oÀÀ=¥{ÊâÉw°Ç u3Yâ+0£Goíªë ØïîUI¶k‹Çñ—ÄÌøò¨éŒ˜¾_®}llœÏIEND®B`‚libDAI-0.3.2/doc/html/form_45.png0000644000175000017500000000035612552200225015661 0ustar jorismjorism‰PNG  IHDR XÌŽ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï]IDATxíÁ Ä0Ç|&Jäþ»=ˆ¢˜g@€Ð2°-|+UQ“ªteÙáŒñJ±_7ì…“+û´}ˆÏDÏͬvâO¢ú†£¸Ð;°Óâ—U‡ˆ?‹”Ô4ýˆUF)ŽÜ IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1JTree.html0000644000175000017500000023627612552201366017766 0ustar jorismjorism libDAI: dai::JTree Class Reference
Classes | Public Attributes | Private Attributes | Related Functions | List of all members
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

Classes

struct  Properties
 Parameters for JTree. More...
 

Public Member Functions

Constructors/destructors
 JTree ()
 Default constructor. More...
 
 JTree (const FactorGraph &fg, const PropertySet &opts, bool automatic=true)
 Construct from FactorGraph fg and PropertySet opts. More...
 
General InfAlg interface
virtual JTree * clone () const
 Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) More...
 
virtual JTree * construct (const FactorGraph &fg, const PropertySet &opts) const
 Returns a pointer to a newly constructed inference algorithm. More...
 
virtual std::string name () const
 Returns the name of the algorithm. More...
 
virtual Factor belief (const VarSet &vs) const
 Returns the (approximate) marginal probability distribution of a set of variables. More...
 
virtual std::vector< Factor > beliefs () const
 Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm. More...
 
virtual Real logZ () const
 Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph). More...
 
std::vector< size_t > findMaximum () const
 
virtual void init ()
 Initializes all data structures of the approximate inference algorithm. More...
 
virtual void init (const VarSet &)
 Initializes all data structures corresponding to some set of variables. More...
 
virtual Real run ()
 Runs the approximate inference algorithm. More...
 
virtual Real maxDiff () const
 Returns maximum difference between single variable beliefs in the last iteration. More...
 
virtual size_t Iterations () const
 Returns number of iterations done (one iteration passes over the complete factorgraph). More...
 
virtual void setProperties (const PropertySet &opts)
 Set parameters of this inference algorithm. More...
 
virtual PropertySet getProperties () const
 Returns parameters of this inference algorithm converted into a PropertySet. More...
 
virtual std::string printProperties () const
 Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1,key2=val2,...,keyn=valn]". More...
 
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). More...
 
void GenerateJT (const FactorGraph &fg, const std::vector< VarSet > &cl)
 Constructs a junction tree based on the cliques cl (corresponding to some elimination sequence). More...
 
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. More...
 
Factor & message (size_t alpha, size_t _beta)
 Returns reference to the message from outer region alpha to its _beta 'th neighboring inner region. More...
 
void runHUGIN ()
 Runs junction tree algorithm using HUGIN (message-free) updates. More...
 
void runShaferShenoy ()
 Runs junction tree algorithm using Shafer-Shenoy updates. More...
 
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. More...
 
Factor calcMarginal (const VarSet &vs)
 Calculates the marginal of a set of variables (using cutset conditioning, if necessary) More...
 
- Public Member Functions inherited from dai::DAIAlg< GRM >
 DAIAlg ()
 Default constructor. More...
 
 DAIAlg (const GRM &grm)
 Construct from GRM. More...
 
FactorGraph & fg ()
 Returns reference to underlying FactorGraph. More...
 
const FactorGraph & fg () const
 Returns constant reference to underlying FactorGraph. More...
 
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}$) More...
 
void makeCavity (size_t i, bool backup=false)
 Sets all factors interacting with variable with index i to one. More...
 
void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Sets all factors indicated by facInds to one. More...
 
void backupFactor (size_t I)
 Make a backup copy of factor I. More...
 
void backupFactors (const VarSet &vs)
 Make backup copies of all factors involving the variables in vs. More...
 
void restoreFactor (size_t I)
 Restore factor I from its backup copy. More...
 
void restoreFactors (const VarSet &vs)
 Restore the factors involving the variables in vs from their backup copies. More...
 
void restoreFactors ()
 Restore all factors from their backup copies. More...
 
- Public Member Functions inherited from dai::InfAlg
virtual ~InfAlg ()
 Virtual destructor (needed because this class contains virtual functions) More...
 
virtual std::string identify () const
 Identifies itself for logging purposes. More...
 
virtual Factor belief (const Var &v) const
 Returns the (approximate) marginal probability distribution of a variable. More...
 
virtual Factor beliefV (size_t i) const
 Returns the (approximate) marginal probability distribution of the variable with index i. More...
 
virtual Factor beliefF (size_t I) const
 Returns the (approximate) marginal probability distribution of the variables on which factor I depends. More...
 
virtual void setMaxIter (size_t)
 Sets maximum number of iterations (one iteration passes over the complete factorgraph). More...
 

Public Attributes

RootedTree RTree
 The junction tree (stored as a rooted tree) More...
 
std::vector< Factor > Qa
 Outer region beliefs. More...
 
std::vector< Factor > Qb
 Inner region beliefs. More...
 
struct dai::JTree::Properties props
 

Private Attributes

std::vector< std::vector< Factor > > _mes
 Stores the messages. More...
 
Real _logZ
 Stores the logarithm of the partition sum. More...
 

Related Functions

(Note that these are not member functions.)

std::pair< size_t, BigInt > boundTreewidth (const FactorGraph &fg, greedyVariableElimination::eliminationCostFunction fn, size_t maxStates=0)
 Calculates upper bound to the treewidth of a FactorGraph, using the specified heuristic. 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
fgfactor graph
optsParameters
See also
Properties
Parameters
automaticif true, construct the junction tree automatically, using the heuristic in opts['heuristic'].

Member Function Documentation

virtual JTree* dai::JTree::clone ( ) const
inlinevirtual

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

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

virtual JTree* dai::JTree::construct ( const FactorGraph &  fg,
const PropertySet &  opts 
) const
inlinevirtual

Returns a pointer to a newly constructed inference algorithm.

Parameters
fgFactor graph on which to perform the inference algorithm;
optsParameters passed to constructor of inference algorithm;

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

virtual std::string dai::JTree::name ( ) const
inlinevirtual

Returns the name of the algorithm.

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_IMPLEMENTEDif not implemented/supported.
BELIEF_NOT_AVAILABLEif 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_IMPLEMENTEDif not implemented/supported

Implements dai::InfAlg.

Reimplemented in dai::TreeEP.

Examples:
example.cpp.
std::vector< size_t > dai::JTree::findMaximum ( ) const
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 ( )
inlinevirtual

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)
inlinevirtual

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_IMPLEMENTEDif 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
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif not implemented/supported

Reimplemented from dai::InfAlg.

Reimplemented in dai::TreeEP.

virtual size_t dai::JTree::Iterations ( ) const
inlinevirtual

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

Exceptions
NOT_IMPLEMENTEDif 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, BigInt > 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
fgthe factor graph for which the treewidth should be bounded
fnthe heuristic cost function used for greedy variable elimination
maxStatesmaximum total number of states in outer regions of junction tree (0 means no limit)
Exceptions
OUT_OF_MEMORYif 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.

The documentation for this class was generated from the following files:
  • include/dai/jtree.h
  • src/jtree.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__log0.html0000644000175000017500000001167512552201365020651 0ustar jorismjorism libDAI: dai::fo_log0< T > Struct Template Reference
Public Member Functions | List of all members
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>

Inherits unary_function< T, T >.

Public Member Functions

T operator() (const T &x) const
 Returns (x == 0 ? 0 : log(x)) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_134.png0000644000175000017500000000116112552200251015732 0ustar jorismjorism‰PNG  IHDRŸ?#]ß0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïàIDATxíÛ¶£ †?OÕêû¿í$A@,¶ÓÎí°VØnMó怷ÿ à_-ä‹àβ[ð»å8-+ó.›e‚þln>×äflÝ ðƒ9€¦Ù»g ÿ”m{8¦A”/6M‡Û4©½¸|kY eð+ZƘE¸—÷q"Û©ô£J qÉÚ|tã«5ºùSÁSœ$pcÆ—1TXRG¯²úh,™éÆ%uŠ‘‹[æ[í[nŠOšvŠ“ä½Ô ÙK‘/a¨Ú&w&m0}äSf»¹È-‹ºe>í…X±åH @ËÎq²\ï¶Ðì¥Èw`DaÕÓ‹_W%EËbnW>ÿøDWÅÉrNIû(åÕâ3aUS}ßù­­,ævåsËÍÀ7³WäR¯5vm?ØJ-\ñm^n?+ÍG³¾»N½ºµêûa–c–!Ù›aÅ·w¢³hvÖ‡ì4¤¾v»fßÜü¸{ °¨à-v<â^Ç9Ém¿ºTÓ²\؃F;0œþé­‡†x¦-U6ÆxË´nZ ãkž/†Ñ™jÜ/qŠœ^ ¯x‰¯·+ŒÓÝœÏW·_Ïçk€–Õ§λqüK7€·öþûÖŠo-eoOÚìöñpo9@Ë"Æl ¯šg74IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1IndexFor.html0000644000175000017500000004747712552201366020476 0ustar jorismjorism libDAI: dai::IndexFor Class Reference
Public Member Functions | Private Attributes | List of all members
dai::IndexFor Class Reference

Tool for looping over the states of several variables. More...

#include <dai/index.h>

Public Member Functions

 IndexFor ()
 Default constructor. More...
 
 IndexFor (const VarSet &indexVars, const VarSet &forVars)
 Construct IndexFor object from indexVars and forVars. More...
 
IndexFor & reset ()
 Resets the state. More...
 
 operator size_t () const
 Conversion to size_t: returns linear index of the current state of indexVars. More...
 
IndexFor & operator++ ()
 Increments the current state of forVars (prefix) More...
 
void operator++ (int)
 Increments the current state of forVars (postfix) More...
 
bool valid () const
 Returns true if the current state is valid. More...
 

Private Attributes

long _index
 The current linear index corresponding to the state of indexVars. More...
 
std::vector< long > _sum
 For each variable in forVars, the amount of change in _index. More...
 
std::vector< size_t > _state
 For each variable in forVars, the current state. More...
 
std::vector< size_t > _ranges
 For each variable in forVars, its number of possible values. More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/doxygen.png0000644000175000017500000000730312552201363016066 0ustar jorismjorism‰PNG  IHDRh ;ˆØŠIDATxí]y\•Õº~45%TL Q”PE"q–Û11±]8a„w*©¨(*â" ˆzÀè`8 ¨‰¢mÅ,’òà„p$%”œBó(8k†Ü÷ýÜû6lòö»§k÷Ç÷[ÏÞß·Ö;?k½ëßÕÕÕPxÑêÏ't´ÏùÈ€zÀÇÅ3_€Q4€g@œmÿ ¾ò‰âci‰ôçÿ{ ðÇð¬ù~½Á€4:õHcÂü ðŸÁ³„ª'ÕPÆæ P7^h،♠zb„cóP¨„ 3‚† Ò}çÿO²qÁºNkÝTÛ(É?d Ç~z<’«4ÓÇ¡ØžÞv­zµÙ¦õ¬ZâdÛ,Ë6Ók±]Fz< ¾ZçƒsÕ?ìƒsUø2SÉåwê1”c`[ì—}%ѽ.Ô¼6‚BLZ˜û!F8[ ¹…×TéÛ— »Þ#gó]å:vžu?‡vèbÙR˜?wùŽŸ¾ÊÐgbÑÉÌÕ$kF~Ê;عÆ•¢ïX®?ÉèlÆÙôõà»Nʪ¼­,ìHC§gAz•ÆlÓº­gÑú ]œjÎñåM…3ÓÚæoÒ³'=‘$Ò÷f}G•ŸS_‡öèco.Êȹ :ó£ Ãds®Ù:1=¼{ƒå9?÷ý…zqÛvîÓi‰D’p¿Ë šmÙíoÛâýaÖüEqÒµwÌ}¿~{òj€ç{ôºŸFNëí[ëOq·ÇOSúXO]°>‚‚muæľe¤“5Ë{¨JÕ¯£(›´«bÂçû’ÍlÓÅ}žïú`éUÞy„ac§Á†ÔCºŠóAkl‘±y¥†ô¢ùôs÷Aø¬7ÄõôoJ±äÄ ù.¥Be. Z¬Ð×ÇÈöå¹­ù'Ù-PëìŠyF.ž‚žÝÚ€lp&.êˆð•jò7’re’z19»ã§HGíø%œüq°ïüz׈c¬_k_")ŸHJnÐÑ~ˆÐÖ˜á´äÕ5 µÁq€ÿ5#¸·îà¶+9T‘‚ ðŽ÷Rܸrz“Ï´Ì =Ï…{ðáO£Èf ¡Íwg|Ž’Ü/¢Þ$÷¯¢ëðúÀ;¿à¨Ö™âÒÆ­]¯ÜW"Þ/< ‡÷DÏà°½üB}çyIEc^—ƒ=[V“Ýh²ëMä$l];Kû®¸ýr¦È*Åò ÿtÒõ$]•MŸ÷´;×I€1èó!‚œõ¸M õ¨(fÌæ<ÁÎÎò5~z¿ù¶ž mÌêÕ >–âÚ©âëˆIÎÞçz;ãu[i·eç^ÆÜÙÓ³NÞëF6B\}7†»+üŽÓ,Ã'a ½˜-yHY¿,‘^—ñfú~ß?Hcø¸…¸ñó{Z+4\såƒû·¯Ù·nߣð«íFÆ¡sغëû§D¾?ò<–Ævkx0ÅM±ælØ°ÁIÓxÿd”žÜÉ÷EE»AªM«g*È£YEí7Û™^[uíý®v[wGå†=Ed¼n׶ÆæÖÅl¡'¨pGÚk+‹æ¢À¬¨C8ªâš2 dz3H£ß ¡¨BÒûSÃÅù[wŘ ~xpçútÁæmö¤Å£¥iQæ­‰AB1ÉfÙ‰›4u¹ïìIÒ]Ë6äò%ÿ†† 1t.’NJph¬zÌ ÎR1Ž"3-"¸‡‹&ìó°1âüžìó[:‡ï„¼‘……N m–“W0®_èÜÂœ ×õ6ùò&»)Æìꦬýæ}¬ñ~»{múù]z½£M•ºP~^Îá:eQTÙ_*7ÕÄ9É8—·Ëï 3°¶47E•î¿u÷“SÉ»U¯ _ NíºôW¬e¸ÄNÓ|»;™¿;ŒæÅd"ȉôøòÞµõï¾®½"èÄ´ÖMM+bYµ‘_ÉæEÝüÎ]P»¹XKÐI½Þ¥oE<_¹(„EP±Œ|mÇÁ¡‘Ý,ŠÓ©ººZ±Îߺ§×kÝ,kÍMš`Äø…jzeU»æ ™Át3ÓÀ½˜6—ÒöùË·r¨¹Ñ}““wö:Χùë¼ ¿|‚TܵÉQˆKßç_ÁâÀ™œ”pÑÐóໃ¼Ydâ0!®àa –øöçW$ÃÁ‘Á$/\¬$ð 2ÞímÞLH‹Ÿ èd£HVÜ,:ò½»RÍZšJ­a„z*>‹_…NT(ù‚^SVF­U¹8ñEþôñ܈óùnd;«®8™\C]ø=Èêm¬Æ:‚´ÆbãDd=Áãßžˆ‹UU5O‹|]þð®Pèêv‰á\]2ßìÿ"yÈ[ïyʧz£g{Y«{„Ùø5©ÿ;w{N3é­nâĨw§Á¢ÍK¢Ý­ûÏ29Id¿’ì y)ìPÞò8ŒÅ©¯‰±@mPÔñwjl,6 áhWÕ˜d öà uõmÁp®.™á£Ç…twöR x­BδYcŒxg*vo  yò‘•“[¬?ÜVœ˜0ÒN¡Oë‚œ~Žó’¯·h#´Hkýœ±8kÓß^Àq@]àÓ“ø,56´¯÷Í-κU»n…[>]@nîøÏœp›[œ6# €4tën¯:ŽÒþ}…—8äT9_žY$/´G’K™©ù†•(óÑ’Mø©`ŸÉdѺ;ùO‹B Ó&P{qöhJÉ+Úé–§¦l2«MïöÝ_1ÑÓ«’t¸½±l€ëØya ¦ô©«®½ÆL^¬žêñš¸ùy.¾Û½Š[ u/]½‹iS}øN>²e1™q‡jfÚ&¢©iT\=kÏ›ÀXô-.84V5ðu!TE˜ þ.ŒOH´¶4—zwTr.ï‰¦Ë xõµ·œÖ„HÆù£žÈHùg Ñhñ’T$ßyq¸zþ¨p¿´ë< q•ró÷š‰wÿÍÑð–I]´–æI²é²˜sÂ"×:Õ–bÕ¦“ÈÙL6¢9VÊÓWž§<æ;”3?ý©Mê3AV#µ±ËÞ¯‘ž K£UrÝ9!›qát¦H£Ù+6ÇV…/TS^pÃùqgLP'Ú5E ‚–ÀÞºîÄ Ën"2|Ÿ;®W»Îý"Ö¬TwÖâµtúŽO'› á+W Ã+¦âZÌ–<ÕÆ&nOÝ,IŠ£06.ÁZ.Çñúøh*INÚ’Oe½ÉgBXÐÔZóäøä9èü“hÒíDSš¥¡Ê µA¯/Ôc¸ö“`A§¯"zå|‘ €ÅŸ¨ú;HÍ#‚Î|%ÄOˆƒ«OàÌÉÐÜD ž mÜðâc–ƤÉÂqm¶uË&~÷núÒË £ÇÏ€ZÕj =«_n[‡‡÷nN§ÏÝ$_¾bE˜‚€Õ)ù8¾?6‘lú“ÍÙæÖ}#bW( œ³d-®•p&¡ý’œÖa”"9öõņÐ$’Ú›AÜ!ä;ÐÑõè{~á¹8‘ÛÞ£1ÛÓÉ0ž`²#´kÒuäNÅÖ Q¹bhæ ”8ûÓMáŽa›•¿”w±h²¢®qŠæ°(bK ‚’Z¾Ò%ÐÆémáãÖË(Éý‚ÛJ)@> þ›7% ï{y Á“¾ÆÒîohfòô>{pÿ.­_Î%±ÉèägëlZØ\B2B #™¸ÚüÒºp‚hÝšü®[¥Ü<‹#SpñÌA7’ãØHƒt4:Ÿ|g¨tÓL¶*($Æ©»ì…®ù’ó÷$;b›ÔÙ`=¶£¦M„MÌÄ5ò«·Ç¾“H·ÌH.¼žHeAîº5}r­dõ¨±)ÀT};€Q5iÖ2…O0ü…0óñÃ;óæ,Š´²µ냔}g‘£]‹7å9ˆà©_{üèîêžC>úhê{Ž .ÈìðIIð€?[Kswz6Òuíý¬;µ€ç§OåâJÉa˶zv°éd† ¤µâ‚l´é舊«Åüy¾c÷ÁèÖÍ'ràúÅ™TWÕôÓ°¡L €|ʽŒ¼ì­høBã ÝTëî'ò]Kø£ìâÏ(=¹Kx €¿ LÌ,Pý¤Êµu‡¹…׈ §Å¾÷à1Ý«Äý;¿pGDäxZYÛ kfæ6¸ùóæ7®œ®þ6·ÕoÚ¾ÔH~ò®Þ¸â 8Uø“p<ºw3¡a£ÏÑ’‘3èÏ"€bˆ-ÎܺÏ_ªÅ]+ËM©zü°s“f-êçhÇãÑýÊãôÿ5}ZQNb{Ó?å%ÿ\SUõعIÓæ}~}p[œoÔÄ„êÐMMZáNÅå@>Œ„²á6(?¡Åé âK½+ü?À%ÝÝ·/Ç1‚9áUø?B)”ÕèâÞlÈÒêÏ @=àùÄÞžk­®ÅIEND®B`‚libDAI-0.3.2/doc/html/matlab_8h_source.html0000644000175000017500000002262512552201363020014 0ustar jorismjorism libDAI: include/dai/matlab/matlab.h Source File
matlab.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_matlab_h
14 #define __defined_libdai_matlab_h
15 
16 
17 #include "mex.h"
18 #include <dai/factor.h>
19 
20 
21 namespace dai {
22 
23 
24 #ifdef SMALLMEM
25  typedef int mwSize;
26  typedef int mwIndex;
27 #endif
28 
29 
31 mxArray *Factors2mx(const std::vector<Factor> &Ps);
32 
34 std::vector<Factor> mx2Factors(const mxArray *psi, long verbose);
35 
37 Factor mx2Factor(const mxArray *psi);
38 
39 
40 } // end of namespace dai
41 
42 
43 #endif
dai::Factor
TFactor< Real > Factor
Represents a factor with values of type dai::Real.
Definition: factor.h:640
dai::mx2Factor
Factor mx2Factor(const mxArray *psi)
Convert CPTAB-like struct to Factor.
Definition: matlab.cpp:134
dai::Factors2mx
mxArray * Factors2mx(const vector< Factor > &Ps)
Convert vector structure to a cell vector of CPTAB-like structs.
Definition: matlab.cpp:20
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factor.h
Defines TFactor<> and Factor classes which represent factors in probability distributions.
dai::mx2Factors
vector< Factor > mx2Factors(const mxArray *psi, long verbose)
Convert cell vector of CPTAB-like structs to vector
Definition: matlab.cpp:59
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_func_c.html0000644000175000017500000003665612552201370020131 0ustar jorismjorism libDAI: Class Members - Functions
 

- c -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/namespacemembers_func.html0000644000175000017500000003022112552201370021104 0ustar jorismjorism libDAI: Namespace Members
 

- _ -

  • _normal_rnd() : dai
  • _rnd_gen() : dai
  • _uni_dist() : dai
  • _uni_rnd() : dai

- a -

- b -

  • BigInt_size_t() : dai
  • builtinInfAlgNames() : dai
  • builtinInfAlgs() : dai

- c -

  • calcLinearState() : dai
  • calcMarginal() : dai
  • calcPairBeliefs() : dai
  • calcState() : dai
  • complement() : dai
  • concat() : dai
  • createFactorDelta() : dai
  • createFactorExpGauss() : dai
  • createFactorIsing() : dai
  • createFactorPotts() : dai
  • createFG() : dai
  • createGraphFull() : dai
  • createGraphGrid() : dai
  • createGraphGrid3D() : dai
  • createGraphLoop() : dai
  • createGraphRegular() : dai
  • createGraphTree() : dai
  • createGroupStructuredLDPCGraph() : dai
  • createHOIFG() : dai
  • createRandomBipartiteGraph() : dai
  • createSmallLDPCGraph() : 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
  • isPrime() : 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
  • order() : dai

- p -

  • parseNameProperties() : dai
  • pow() : dai
  • powmod() : 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/example_permute_8cpp-example.html0000644000175000017500000003231112552201363022345 0ustar jorismjorism 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/
*
* Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
*/
#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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_139.png0000644000175000017500000000042412552200252015741 0ustar jorismjorism‰PNG  IHDR# ßýôˆ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïƒIDATxí] Ã03MRŽEËÿ»6ÒmÒ´XA‚ùü~‡ø VWU{¦TR³¾1=a5S Å<06ï¶{÷̩X/˜ÍE¹Ë ÿºìÄ\Ø©L'îvhOQz|ÙѬš{-–‡&Ò×iiŽXU¯¹¹Ö÷¾ÇL¢²ÉIEND®B`‚libDAI-0.3.2/doc/html/var_8h_source.html0000644000175000017500000007045012552201363017343 0ustar jorismjorism libDAI: include/dai/var.h Source File
var.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_var_h
14 #define __defined_libdai_var_h
15 
16 
17 #include <iostream>
18 #include <sstream>
19 #include <dai/exceptions.h>
20 
21 
22 namespace dai {
23 
24 
26 
37 class Var {
38  private:
40  size_t _label;
41 
43  size_t _states;
44 
45  public:
47  Var() : _label(0), _states(0) {}
49  Var( size_t label, size_t states ) : _label(label), _states(states) {}
50 
52  size_t label() const { return _label; }
54  size_t& label() { return _label; }
55 
57  size_t states() const { return _states; }
59  size_t& states() { return _states; }
60 
62  bool operator< ( const Var& n ) const {
63 #ifdef DAI_DEBUG
64  if( _label == n._label )
65  DAI_ASSERT( _states == n._states );
66 #endif
67  return( _label < n._label );
68  }
69 
71  bool operator> ( const Var& n ) const {
72 #ifdef DAI_DEBUG
73  if( _label == n._label )
74  DAI_ASSERT( _states == n._states );
75 #endif
76  return( _label > n._label );
77  }
78 
80  bool operator<= ( const Var& n ) const {
81 #ifdef DAI_DEBUG
82  if( _label == n._label )
83  DAI_ASSERT( _states == n._states );
84 #endif
85  return( _label <= n._label );
86  }
87 
89  bool operator>= ( const Var& n ) const {
90 #ifdef DAI_DEBUG
91  if( _label == n._label )
92  DAI_ASSERT( _states == n._states );
93 #endif
94  return( _label >= n._label );
95  }
96 
98  bool operator!= ( const Var& n ) const {
99 #ifdef DAI_DEBUG
100  if( _label == n._label )
101  DAI_ASSERT( _states == n._states );
102 #endif
103  return( _label != n._label );
104  }
105 
107  bool operator== ( const Var& n ) const {
108 #ifdef DAI_DEBUG
109  if( _label == n._label )
110  DAI_ASSERT( _states == n._states );
111 #endif
112  return( _label == n._label );
113  }
114 
116  friend std::ostream& operator << ( std::ostream& os, const Var& n ) {
117  return( os << "x" << n.label() );
118  }
119 
121  std::string toString() const {
122  std::stringstream ss;
123  ss << *this;
124  return ss.str();
125  }
126 };
127 
128 
129 } // end of namespace dai
130 
131 
132 #endif
dai::Var::states
size_t & states()
Returns reference to number of states.
Definition: var.h:59
dai::Var::_states
size_t _states
Number of possible values.
Definition: var.h:43
dai::Var::operator==
bool operator==(const Var &n) const
Equal-to operator (only compares labels)
Definition: var.h:107
dai::Var::operator>
bool operator>(const Var &n) const
Larger-than operator (only compares labels)
Definition: var.h:71
dai::Var::operator<
bool operator<(const Var &n) const
Smaller-than operator (only compares labels)
Definition: var.h:62
dai::Var::operator<<
friend std::ostream & operator<<(std::ostream &os, const Var &n)
Writes a Var to an output stream.
Definition: var.h:116
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::Var::label
size_t & label()
Returns reference to label.
Definition: var.h:54
dai::Var::states
size_t states() const
Returns the number of states.
Definition: var.h:57
dai::Var::Var
Var(size_t label, size_t states)
Constructs a variable with a given label and number of states.
Definition: var.h:49
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::Var::toString
std::string toString() const
Formats a Var as a string.
Definition: var.h:121
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
dai::Var::operator<=
bool operator<=(const Var &n) const
Smaller-than-or-equal-to operator (only compares labels)
Definition: var.h:80
dai::Var::operator>=
bool operator>=(const Var &n) const
Larger-than-or-equal-to operator (only compares labels)
Definition: var.h:89
dai::Var::label
size_t label() const
Returns the label.
Definition: var.h:52
dai::Var::Var
Var()
Default constructor (creates a variable with label 0 and 0 states)
Definition: var.h:47
dai::Var::operator!=
bool operator!=(const Var &n) const
Not-equal-to operator (only compares labels)
Definition: var.h:98
dai::Var::_label
size_t _label
Label of the variable (its unique ID)
Definition: var.h:40
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/dot_inline_dotgraph_1.png0000644000175000017500000002053712552201363020651 0ustar jorismjorism‰PNG  IHDRÛ³$iwbKGDÿÿÿ ½§“ IDATxœíÝ}\÷ÿðW:%•)­¤57ùš"œˆÑdÈLtoÝPjèeÓ DnF% Ir³:1Œ0Òµè»/"vZ¥„å¦û»óûÃ#¿Q×9×çêÌçùxøÃÑõy¿ÓëÜ]Ÿëó‘‹ÅbPÅ6a®; ¨÷ EBÃFQ„аQ!4lE EBÃFQ„аQ!4lE EBÃFQ„аQ!4lE E“ä`¡P¡P(­^(ªÓ’——Çúõ롧§Çx ‰^Ù„B!233%‚¢dBbb"rrr$C¢W6;v,¤ÃPT§&'''ñô3EBÃFQ„аQ!4lE EBÃFQ„аQ!4lEˆÄ'µÙöìÙ3\¼x.\@~~>nß¾gÏžáÉ“'PVV†ªª*>úè# :¦¦¦077—hJMgòÇ ==¸qãîÝ»‡êêjÔÔÔ gÏžèÑ£ „aÆÁÌÌ fffèÞ½;×mK¬¥¥9998þºtéܯr’,?ngg¬Ì ¹pábbbššŠ†† 4C† žžÔÔÔн{wÔÖÖ¢¦¦EEE¸{÷.òóóQ[[‹1cÆ`þüùpvvF×®]¥Þ›êêꀸ¸8dgg£[·n022ÂÇ ]]](++£[·nxþü9ž>} ‘H„›7oâÎ;èÚµ+,--±hÑ"L˜0ë»ÒaÅÅÅؾ};öïßû÷ïCCCÇGÿþý¡¥¥eee@MM ÊÊÊ ‰pýúuTTT@[[ÎÎÎðòò‚ŽŽŽÔ{“““CRRÒËßy„î•-++ ~~~ÈÌÌ„±±1`nnŽž={¾óØÆÆF\½zLJ——V­Z…àà`xxxtúg½––ìܹkÖ¬Aee%¦L™‚]»vaÔ¨QPPPxçñ•••8wîŽ;†‰'bܸqزe ø|>î%óèÑ#!>>êêê°´´„……>þøãv_XXˆŸ~ú {÷îÅ–-[àæ憵k×¢wïÞ,wÞ1æ•­¶¶Ë–-CLL ø|>¼½½addÄx¼ŠŠ ìÝ»‰‰‰1b8€AƒIÜ' àää„k×®aÎœ9puuEŸ>}———‡¨¨(üúë¯ðôôĦM› ¤¤$ÅŽ¥çÇ„··7àåå…3f´ëÉåMqìØ1DGG£©© ÑÑÑ°··—JŸÒxeëO÷÷î݃‰‰ <ˆõë×c÷îÝ 444°|ùr…BÔÖÖbäÈ‘8r䈔:–¡Pˆ‘#G¢¡¡‡Æ·ß~+QÐ`ĈˆEhh(`bb‘H$†¥¤±± .„££#¦NŠÔÔTÌž=›qÐ@AAÖÖÖHMMÅ”)SàààOOO455I±sæ8Ûõë×1nÜ8477C `úôéRÀ€HHHÀŒ3`gg‡¨¨(©Ž/‰mÛ¶ÁÁÁ3gÎD|||»ß6µ‡œœf̘@€††Œ;ùùùR_555°´´ÄþýûŽÀÀ@¨¨¨Hm|UUUaëÖ­Ø·o,--_~¹Â%NÃvûömLž<ºººˆ‹‹Ã‡~ÈJÁ××¾¾¾Ø½{7+u:b×®]X¼x1/^ŒÀÀ@‰žÑßF[[{÷î…®®.&OžŒ;wî°R§½accƒÌÌLìÙ³“&Mb­ÖäÉ“‹+W®ÀÖÖ–óW8ÎÂVYY‰iÓ¦A[[QQQR}fkËüùó±hÑ",Z´?ÿü3ëõÚrúôixzzÂÓÓnnn¬×SUUŶmÛ ¥¥…iÓ¦áÉ“'¬×l‹.^¼ˆ;và“O>a½Þ°aË/Â××—õzoÃYØÜÜÜPSSƒmÛ¶¡[·nÄê.Z´S§N…££#ÊÊʈÕmuÿþ}899Á .$VWYYÛ¶mCUU‘€¿É?þˆ]»vaýúõD‚ÖjØ°aX»v-bbb””D¬î?q¶ÄÄD;v aaaèÕ«ñú«V­‚’’–,YB¼¶¯¯/TTT°råJâµÕÕÕ†””>|˜hí‡ÂËË ¬¾ulËäÉ“aoo///<~ü˜x}€ƒ°ÕÖÖÂÏϳgÏƨQ£H—¨¨¨ 00.\ V÷ìÙ³8rä_ž %môèј5k–,Y‚ºº:buW¬XEEE,^¼˜XÍZ¼x1äåå±jÕ*Nê[ll,žŸœ:uŠñ“„¢¢"f̘ýû÷£¥¥…ÑL [rr2ÈxÚÔÎ;±sçNÃ××þþþˆˆˆÀ÷4uêT=z”ññí•œœŒ/¾øB¢1444`nnŽ3gÎàÙ³g5dÈèëë#99Y¢qÞ%''%%%°°°`tüÆqãÆ ØÛÛ¿|‚øæ›o$z̦OŸŽââbäææ2ƒ ¢aKOOǘ1c{ÿþ}ÄÄÄÀÖÖjjj555X[[#""‚ñ¹#SSSáÞ½{ŒŽo;wî ¤¤&&&Õzߥa̘18wîœÔÆ{“óçÏCCCƒÑì˜û÷²aaa˜3g ˆgÜÓÀѧO¤§§3ƒ bakhhÀï¿ÿÎxÎã‰'ÐÜÜüÚ/¬‰‰ êêê?Ó}òÉ'àñxøõ×_ß¹¹¹àñxDÏ-µÇðáÑŸŸÆÆFÖjäææ2~ÌËËËñÍ7ß¼rÛرcÑ«W/TTT0îINN†††ÿÞW¶ÂÂB4773¾°ó·ß~hjj¾r{ß¾}¼˜9Ï„¢¢"´µµßèׯkS²˜ÒÓÓCSSîÞ½ËZ[·ná£>bt¬±±1>øàƒ×nollÄðáÃ%êë£>­[·$££ˆ…­u¶Æ?ÃÒ^>ôèÑã•Û[ÿ^RR¸7MMMVg“”——CCCƒµñ™j}¢bó¾—••1~Ìß$//õõõðòò’hMMMÜ¿_J]µ±°=þŸgië¸Ö5Ø%y+¤¢¢ò²?6<þœÓóKmiíIÒ/[Þ¦ªªJj'ð›››Žàà`J4–ŠŠ ªªª¤ÒW{q~‰M{éëëÀk¡xúô)tÊWJº¢¢¢0jÔ(XZZrÝ #ÄÂÖºMuu5£ã[ÃÖúv²Uëß÷V]]ÍêB9Ý»wg|¿ÙÔÚ“4¿áü'UUU©Ü÷ôôttíÚ>>>RèŠýÇüMˆ…MKK ðàÁFÇO™2]ºtAvvö+·çää€ÇãItÑéƒX»–xqß%ùöŒ-åååþÿ±aƒ––ãǼÕåË—ñàÁ,\¸ð•­›Z¿4c¢¼¼œÕûý&Äü0`x<D"Üáã555áîî¡P¨ªª¢ªª B¡ ,xùa¿£PRR¨§öã_š¼¼<²zJbäÈ‘gtìµk×àããƒúúz\½zõµÿ駟+‹‘ŸŸeË–1:ž)¢KÙ™››ãøñ㌗““ƒ••¬¬¬¤ÖSVVôôôŸ j@GGYYY…ÏçƒÏçcÍš5Ré+++ ¶¶¶R«-“&MB`` 1`À€;|øpV&ܹs>$~]Ño#gÍš…;wîàöíÛ$˾ÕéÓ§¥Þ¶XYYáäÉ“DfÙ·ÇÍ›7ñÇ`öìÙ¬Ö=z4tttpêÔ)Vëtĉ'Я_?‰¾Tc‚hØÆ}}}âW ·%;;"‘ÎÎάך;w.D"ñ)Bm9rä  •ùšoÓ¥K899!%%…ÕiaíÕÐЀ´´48;;_¸—h5999øùù!99™³KÓÿ.66Ÿ}ö™ÄSÚÃØØ&L@ll,ëµÞ¥¢¢)))ð÷÷—ÊÆìïâåå…ÊÊJ;vŒõZï’ššŠ§OŸJ<… â'µÝÜÜ ®®ŽˆˆÒ¥_ñË/¿ ++ ßÿ=±šÁÁÁÈÈÈÀåË—‰Õ|“ÈÈHhhhÀÕÕ•H=ÌŸ?ÑÑÑÄgmü]UUvìØVOõ´…xغuë†ððp¤¤¤ ''‡ty/þÓׯ_¢PLš4 ¶¶¶X·ng'¹³³³qìØ1lݺ•è¦#!!!hjjâôI¶õÊt’Kaü'Óµlmm1{öl|÷Ýwø믿ˆ×_½z5°uëVâµ#""PWW'µo;âñãÇøî»ï`ee%Ñé&z÷îèèh$%%áìÙ³DkÀ™3g  ÍÙ’œÍܳgTUUáããCtièíÛ·ãìÙ³8tèãá’ÐÒÒÂÁƒqúôi¢ë`ÔÔÔÀÇÇjjjسg±ºgoo… "((ÿýï‰ÕÍÏÏÇÊ•+áééÉú©Ž·á,l={öÄ©S§PVV"ïåwïÞ;w"&&æææ¬×kË矎˜˜ÄÄÄùůªª‚··7ÊËËqêÔ©×.S")22fffðôô$¸üü|xyyá³Ï>c|r]Z8õ?pà@œ={þù'\]]Y[^¬¡¡!!!ˆŠŠBTTæÏŸÏJŽpwwGdd$"##ÊÚ×â%%%puuEII Î;×áËÒÆãñ  ajj VßRž9s7nxtuu¡¢¢‚nݺ¡ªª •••(**Â7PXX%%%XYYaáÂ…?~<€¿ŒÖÖÖÈÉÉÁµk×Þ¸€æ΋´´4äååAWWÀ‹+¶oߎ ¸¸}úô‘‘ôôôзoß—Ë8TWW¿²ý£GЯ_?¸¸¸ÀÓÓ“•ÖÒØæ·Ó†­UUU.^¼ˆ . ??………ø믿ðôéS(++£{÷îÐ××Ç!C0~üx˜››£_¿~okþüùHNNÆo¿ýÆx•/’Š‹‹qöìYdddàÆøã?ðôéSÔÕÕ¡GPWWÇÀahh333Lœ8ñk_\__Ïu;Œ$%%‰Ž?lÙÙÙbEEEñ† Xèªý~ÿýw±²²²xùòå>–Ëß7⤤$I†tšÏl$())A àæÍ›X±b×íÅçóŠ   dddpÒCuu5ììì0lØ0„„„pÒ—Þ«°/¾ŒˆŒŒÄæÍ›‘ššÊu;Dùûûã‹/¾€ƒƒ=zD¼¾··7ÊÊʘ˜Øé¬%á½ Ì›7...puuEQQ×í#''‡½{÷B^^sçÎ%z!kbb"öíÛ‡½{÷ÊÄçe6¼—a^Ì‘ÔÒÒ‚ƒƒC§¸¨‘”^½z!)) ?ÿü3±‰ØwîÜÁ×_ ???™]óQÞÛ°©¨¨@  ??ÁÁÁ\·C”‰‰ Ö¬Yƒ€€\¹r…ÕZuuu°³³ƒÖ­[Çj­Îî½  :Ø°aNŸ>Íu;D-_¾Ó¦Mƒƒƒ«WÍûøø@$!))éå9Ï÷Õ{6àÅ„`GGG8;;s²Ï2Wäää°gÏ´´´`Þ¼y¬|~سgâââX]½LV¼÷a€èèhôîÝ_}õš››¹n‡˜>}úàСC8uê¶mÛ&Õ± ááá___ÖWð’ÏÐÌÌÌ”ä¬z§¡««‹sçÎÁÐÐC‡åº6€TÿÏ °téR¤¦¦¢wïÞ×ÒÒ‚sçÎA^^%%%Rë533€tï;I½²ÙÚÚbìرÒê…S=zô€‘‘nÞ¼)ñÚô²ÆÀÀ}úôAvv¶T¾™½víª««1vìXΧ†I‹ƒƒø|¾dƒHg2Ë¿‡£££XCCC\ZZÊu+oÄtºÖ»¿ihhàСCHNNf¼6ÊÝ»wááá///Ì™3GÊÊ>¶PUU…@ @vv6BCC¹n‡¨‰'bÅŠðóóëðÅ»õõõ°··Gÿþý±iÓ&–:”m4lo`hhˆ7bõêÕœ,»Æ¥U«VáÓO?…½½}‡¶ÿ]¶l Э[7;”]4lmðööÆìÙ³áääôrÓÀ÷A—.]pàÀTWWÃÃã]Ç?~Û·oGLL «ûÜÉ:¶·ˆ…ŠŠÊ{wþMSSÄ‘#G°k×®·þìŸþ‰yóæá믿†££#¡e Û[ôìÙIIIÈÈÈÀ† ¸n‡¨Ï>û X¼x1òòòÞø3pppÀ‡~ÈÉêÒ²††íF…°°0¬ZµªÓ-šÃ¶Õ«WÃÔÔ´ÍÏoß~û-òóóéç´v¢ak‡%K–àË/¿„‹‹ ']rE^^ ¨¬¬Ä×_ýÊ¿8qرc† ÂQ‡²…†­ää丸¸ ¥¥…ë–ˆÑÖÖFBB„B!ââ⼘26wî\¸¹¹ÙHòß‚†­Z/ºk×®E`` ƇqãÆqÝ1¡¡¡ÈÈÈÀäÉ“Q__«W¯vŠ%½e }eë eË–qºhWx<,X€ÊÊJã?ÿù×-ɶârÑ.•””ÀÏÏ'NDFF¸nIæа1ЫW/$&&âçŸæ|Ï/ššš0gΨ««ãøñãXºt)<==qóæM®[“)4l 3«W¯ÆòåË_^ÔøoµråJüúë¯èÞ½;ÂÂÂ`dd;;;¢»ÆÊ:6 ¼\4‡‹½ÁIHOOÇÆ###€‚‚QVV†%K–pÜ¡ì a“@ë¢9ÍÍÍÿÊÏo<€££#lmm_Û­µ_¿~ˆGll,8ÀQ‡²…†MB­‹æüôÓOˆŠŠâº©iii££#TUUÛœŒ}Êu;9þ<Ö¯_ððpŒ1â­?Ûúù­´´þþþ„:”M4lRÒzÑeMM ÜÝݹn‡±ÖÏiVVVX°`A»Žéß¿?vî܉;vàСC,w(»hؤèï‹æìرƒëv:¬¥¥ÎÎÎPVVÆîÝ»;t¬ <==±`Á°Ô¡l£a“2333aéÒ¥^4‡k!!!øå—_ УG¿eË 4vvv¨««c¡CÙFÃÆ‚àà`F‹æpéâÅ‹ Á?ücccFctíÚIII‰DøöÛo¥Ü¡ì“hû÷Y¿~ýPRRÂu!<éééøôÓO™!¤—Ø0TRR‚¥K—¾uùõÿýï ‡‡ÌÍÍ¥R733[·n…@ Êxb±ëÖ­Cii)6nÜUUU©Œ»k×.dffbÆ ÐÐÐʘ­ëœ,]ºT*ãu„ÊÊÊ$„Ó™eqRRÒ;.00P¬¤¤$ÎËË“J]i/?¾víZ±‚‚‚øÊ•+RS,‹kkkÅ#FŒ=Z\__/•1¹\~¼½÷[ÐåÇÙ¶f͘ššÂÎÎÏŸ?çºW\ºt ßÿ=6mÚ$õ R”””””„‚‚HulYEÃƲ·-šÃ¥¿þú NNN˜6m|}}Y©1pà@ìÚµ áááHIIa¥†,¡a# uÑ@€½{÷rÝÄb1\]]!‹999ÖjÙÛÛÃÕÕnnn‰D¬Õ‘4l„´.šãéé‰ëׯsÚËÆqòäI$&&JeóÃwÙ¾};tuuaoo††ÖëuV4l…††bäÈ‘øꫯ8»è2;;+W®DXXLMM‰ÔTRR‚@ ÀÍ›7±bÅ "5;#6‚x<QQQoooâõ+++áàà€Ï?ÿ~~~Dk4‘‘‘ؼy3RSS‰Öî,hØÓÑÑÁ¾}ûOtÑœÖÏiMMMØ·o«ŸÓÚ2oÞ<¸¸¸ÀÕÕEEEÄësžÔ&@$áêÕ«¯ÜöÅ_ **ªÃkä·^/' ;tÜÇqùòe,Y²çÏŸy»¼¼<¦OŸ%%¥×^—.]zeË­É“'#==›7oÆ„ :4V댎Þ÷¶ôíÛW’!'•3~ï!tà$§ƒƒƒ@§ýsäÈÖþŸx<ç÷¯­?<¯Ý÷£#wô•€ææfL™2?üð×­¼fØ°ahjjbmü¦¦&lÞ¼S§Ne­§OŸÆ²eˈ֤ŸÙ(Š6Š"„†¢¡a£(BhØ(Š6Š"„†¢¡a£(BhØ(Š6Š"„†¢¡s#e„X,Frr2222п<~ü&&&˜>}:×­±®¢¢¸|ù2ÊËËqðàA®[b„†MFìܹÉÉÉ …PSSógÏ`kkûráž3 ˜››cÕªUÐÓÓãºÆèÛHpÿþ}ÄÄÄÀÖÖöå^ijjj°¶¶FDDž|¯mãÔúwºÁ‡l a“***o¼½uÑžÆÆF’íP Ñ°É}}}xm¯€Ö½»¥µK Å.6жַ“­ZÿÎtóBŠ,60eÊtéÒÙÙٯܞ““÷^œØþ7 a“šššpww‡P(DUU ªª B¡ ,xù­ä¿Ymm-€3idA"#¼½½¡­­ÐÐPhii¡¨¨nnn°¶¶æº5Öåää -- PZZŠ„„ðù|pÜYÇаÉ999XYYÁÊÊŠëVˆãóùàóùX³f ×­H„¾¤(BhØ(Š6Š"„†¢¡a£(BhØ(Š6Š"„†¢¡a£(Bh«ßqIIDATØ(Š6Š"„†¢¡‘ ¹~ý:üýý¹nƒ 8sæ ×m¼¢¼¼œxM6lmm¹n¡Màóù¬¿téÒN¹ Q=`nnN´& ¶¶¶:plÚ²e ×-tô3EBÃFQ„аQ!4lE EBÃFQ„аQ!4lE=©Íǃ½½=ìíí¹n…"„Ç“,.4l ¥§§s2¿Žâ†¼¼¼Ä{*ȉeyñtŠ’Bú™¢¡a£(BhØ(Š6Š"„†¢¡a£(BhØ(Š6Š"„†¢¡a£(BhØ(Š6Š"„†¢árÝE½²þF·±–Ý Ó‡IEND®B`‚libDAI-0.3.2/doc/html/form_136.png0000644000175000017500000000057512552200252015745 0ustar jorismjorism‰PNG  IHDR7…¬ú0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïìIDATxíYŽÄ Dk²Üÿ¶S€[4é–fþæ˲£°TÙes€ÿŠ O‰°ÃÝð>' /À»§ ð ¿ãŽéÚœî Q³Cl»1Æ(i»¯l)úôRvÔ`ò[˜uo¿K¤8®Zuæ\óeR×N›V³Ž™áÎ-¸jk´Pèû†Ã™uœÎ Î[Rn«£í´^¾pÀðQ§Ž’âs.*S`m —7³Ñ—&£x¢¥™¶"ôFóœlÊ"®’”$æª)I·Ï¾R˜ÈiL˜—¹Ï]lc*ü}îs<Þ½ï¿D˜ô̯üi?MCÍp™ƒjIEND®B`‚libDAI-0.3.2/doc/html/form_71.png0000644000175000017500000000072612552200233015660 0ustar jorismjorism‰PNG  IHDRD˜Ò)a0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïEIDATxíK’ë0EúÄŽ¤ýïöŽ~UNzÚ3ßR"Ãå€ä9À_—ü*MŸ”[,ÒŸ[ø¤Ç7—ýü±à£Òp¯r€Ñø¢í@ÑÖSê]MÒ«h³íí¬ßŸ¡YËÕU)©Ô«‹V£«Ž dev‰¥Xñy Ce•íáðî!yÉ*y F?ËÞ˜òŒ¦ïÔX®‘Xt4Õw¯šÉÃéªÇ}™UóesðÈÛ‘ôI¤™K Ó»‡+Ýó_&VÈ,EwG ’ÂpðQy¸³xË&ÂÌÇ-Ú,Lêžhè$­’ܲØñîž3’L'^éYñ7ÉS–Ø”¬!z i…T«+1¥y@ñ€\Z’šE”’ª©z U| †ðŸÎ‰ÞÝ!v~×A¯1Ìäî²õyÐ×x?)ý¬zü‹–n•¿~ZW”£ý® ?¸ú!IEND®B`‚libDAI-0.3.2/doc/html/lc_8h.html0000644000175000017500000001251312552201363015565 0ustar jorismjorism libDAI: include/dai/lc.h File Reference
Classes | Namespaces
lc.h File Reference

Defines class LC, which implements loop corrections for approximate inference. More...

#include <dai/dai_config.h>
#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.

Classes

class  dai::LC
 Approximate inference algorithm "Loop Corrected Belief Propagation" [MoK07]. More...
 
struct  dai::LC::Properties
 Parameters for LC. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines class LC, which implements loop corrections for approximate inference.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/clustergraph_8h_source.html0000644000175000017500000022272012552201363021255 0ustar jorismjorism libDAI: include/dai/clustergraph.h Source File
clustergraph.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
13 
14 
15 #ifndef __defined_libdai_clustergraph_h
16 #define __defined_libdai_clustergraph_h
17 
18 
19 #include <set>
20 #include <vector>
21 #include <dai/varset.h>
22 #include <dai/bipgraph.h>
23 #include <dai/factorgraph.h>
24 
25 
26 namespace dai {
27 
28 
30 
34  class ClusterGraph {
35  private:
37  BipartiteGraph _G;
38 
40  std::vector<Var> _vars;
41 
43  std::vector<VarSet> _clusters;
44 
45  public:
47 
48  ClusterGraph() : _G(), _vars(), _clusters() {}
50 
52  ClusterGraph( const std::vector<VarSet>& cls );
53 
55 
58  ClusterGraph( const FactorGraph& fg, bool onlyMaximal );
60 
62 
63  const BipartiteGraph& bipGraph() const { return _G; }
65 
67  size_t nrVars() const { return _vars.size(); }
68 
70  const std::vector<Var>& vars() const { return _vars; }
71 
73  const Var& var( size_t i ) const {
74  DAI_DEBASSERT( i < nrVars() );
75  return _vars[i];
76  }
77 
79  size_t nrClusters() const { return _clusters.size(); }
80 
82  const std::vector<VarSet>& clusters() const { return _clusters; }
83 
85  const VarSet& cluster( size_t I ) const {
86  DAI_DEBASSERT( I < nrClusters() );
87  return _clusters[I];
88  }
89 
91  size_t findVar( const Var& n ) const {
92  return find( _vars.begin(), _vars.end(), n ) - _vars.begin();
93  }
94 
96  size_t findCluster( const VarSet& cl ) const {
97  return find( _clusters.begin(), _clusters.end(), cl ) - _clusters.begin();
98  }
99 
101  VarSet Delta( size_t i ) const {
102  VarSet result;
103  bforeach( const Neighbor& I, _G.nb1(i) )
104  result |= _clusters[I];
105  return result;
106  }
107 
109  VarSet delta( size_t i ) const {
110  return Delta( i ) / _vars[i];
111  }
112 
114  bool adj( size_t i1, size_t i2 ) const {
115  if( i1 == i2 )
116  return false;
117  bool result = false;
118  bforeach( const Neighbor& I, _G.nb1(i1) )
119  if( find( _G.nb2(I).begin(), _G.nb2(I).end(), i2 ) != _G.nb2(I).end() ) {
120  result = true;
121  break;
122  }
123  return result;
124  }
125 
127  bool isMaximal( size_t I ) const {
128  DAI_DEBASSERT( I < _G.nrNodes2() );
129  const VarSet & clI = _clusters[I];
130  bool maximal = true;
131  // The following may not be optimal, since it may repeatedly test the same cluster *J
132  bforeach( const Neighbor& i, _G.nb2(I) ) {
133  bforeach( const Neighbor& J, _G.nb1(i) )
134  if( (J != I) && (clI << _clusters[J]) ) {
135  maximal = false;
136  break;
137  }
138  if( !maximal )
139  break;
140  }
141  return maximal;
142  }
144 
146 
147 
151  size_t insert( const VarSet& cl ) {
152  size_t index = findCluster( cl ); // OPTIMIZE ME
153  if( index == _clusters.size() ) {
154  _clusters.push_back( cl );
155  // add variables (if necessary) and calculate neighborhood of new cluster
156  std::vector<size_t> nbs;
157  for( VarSet::const_iterator n = cl.begin(); n != cl.end(); n++ ) {
158  size_t iter = findVar( *n ); // OPTIMIZE ME
159  nbs.push_back( iter );
160  if( iter == _vars.size() ) {
161  _G.addNode1();
162  _vars.push_back( *n );
163  }
164  }
165  _G.addNode2( nbs.begin(), nbs.end(), nbs.size() );
166  }
167  return index;
168  }
169 
171  ClusterGraph& eraseNonMaximal() {
172  for( size_t I = 0; I < _G.nrNodes2(); ) {
173  if( !isMaximal(I) ) {
174  _clusters.erase( _clusters.begin() + I );
175  _G.eraseNode2(I);
176  } else
177  I++;
178  }
179  return *this;
180  }
181 
183  ClusterGraph& eraseSubsuming( size_t i ) {
184  DAI_ASSERT( i < nrVars() );
185  while( _G.nb1(i).size() ) {
186  _clusters.erase( _clusters.begin() + _G.nb1(i)[0] );
187  _G.eraseNode2( _G.nb1(i)[0] );
188  }
189  return *this;
190  }
191 
193 
195  VarSet elimVar( size_t i ) {
196  DAI_ASSERT( i < nrVars() );
197  VarSet Di = Delta( i );
198  insert( Di / var(i) );
199  eraseSubsuming( i );
200  eraseNonMaximal();
201  return Di;
202  }
204 
206 
207  friend std::ostream& operator << ( std::ostream& os, const ClusterGraph& cl ) {
209  os << cl.clusters();
210  return os;
211  }
212 
214  std::string toString() const {
215  std::stringstream ss;
216  ss << *this;
217  return ss.str();
218  }
220 
222 
223 
230  template<class EliminationChoice>
231  ClusterGraph VarElim( EliminationChoice f, size_t maxStates=0 ) const {
232  // Make a copy
233  ClusterGraph cl(*this);
234  cl.eraseNonMaximal();
235 
236  ClusterGraph result;
237 
238  // Construct set of variable indices
239  std::set<size_t> varindices;
240  for( size_t i = 0; i < _vars.size(); ++i )
241  varindices.insert( i );
242 
243  // Do variable elimination
244  BigInt totalStates = 0;
245  while( !varindices.empty() ) {
246  size_t i = f( cl, varindices );
247  VarSet Di = cl.elimVar( i );
248  result.insert( Di );
249  if( maxStates ) {
250  totalStates += Di.nrStates();
251  if( totalStates > (BigInt)maxStates )
252  DAI_THROW(OUT_OF_MEMORY);
253  }
254  varindices.erase( i );
255  }
256 
257  return result;
258  }
260  };
261 
262 
264 
266  class sequentialVariableElimination {
267  private:
269  std::vector<Var> seq;
271  size_t i;
272 
273  public:
275  sequentialVariableElimination( const std::vector<Var> s ) : seq(s), i(0) {}
276 
278  size_t operator()( const ClusterGraph &cl, const std::set<size_t> &/*remainingVars*/ );
279  };
280 
281 
283 
286  class greedyVariableElimination {
287  public:
289  typedef size_t (*eliminationCostFunction)(const ClusterGraph &, size_t);
290 
291  private:
293  eliminationCostFunction heuristic;
294 
295  public:
297 
299  greedyVariableElimination( eliminationCostFunction h ) : heuristic(h) {}
300 
302 
304  size_t operator()( const ClusterGraph &cl, const std::set<size_t>& remainingVars );
305  };
306 
307 
309 
313  size_t eliminationCost_MinNeighbors( const ClusterGraph& cl, size_t i );
314 
315 
317 
322  size_t eliminationCost_MinWeight( const ClusterGraph& cl, size_t i );
323 
324 
326 
330  size_t eliminationCost_MinFill( const ClusterGraph& cl, size_t i );
331 
332 
334 
339  size_t eliminationCost_WeightedMinFill( const ClusterGraph& cl, size_t i );
340 
341 
342 } // end of namespace dai
343 
344 
345 #endif
dai::ClusterGraph::operator<<
friend std::ostream & operator<<(std::ostream &os, const ClusterGraph &cl)
Writes a ClusterGraph to an output stream.
Definition: clustergraph.h:208
dai::ClusterGraph::isMaximal
bool isMaximal(size_t I) const
Returns true if cluster I is not contained in a larger cluster.
Definition: clustergraph.h:127
dai::SmallSet::end
iterator end()
Returns iterator that points beyond the last element.
Definition: smallset.h:198
dai::ClusterGraph::clusters
const std::vector< VarSet > & clusters() const
Returns a constant reference to the clusters.
Definition: clustergraph.h:82
dai::VarSet::nrStates
BigInt nrStates() const
Calculates the number of states of this VarSet, which is simply the number of possible joint states o...
Definition: varset.h:130
dai::eliminationCost_WeightedMinFill
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 "WeightedMin...
Definition: clustergraph.cpp:122
dai::ClusterGraph::vars
const std::vector< Var > & vars() const
Returns a constant reference to the variables.
Definition: clustergraph.h:70
dai::BipartiteGraph::addNode2
size_t addNode2()
Adds a node of type 2 without neighbors and returns the index of the added node.
Definition: bipgraph.h:152
dai::ClusterGraph::eraseSubsuming
ClusterGraph & eraseSubsuming(size_t i)
Erases all clusters that contain the i 'th variable.
Definition: clustergraph.h:183
dai::ClusterGraph::ClusterGraph
ClusterGraph()
Default constructor.
Definition: clustergraph.h:49
dai::ClusterGraph::_G
BipartiteGraph _G
Stores the neighborhood structure.
Definition: clustergraph.h:37
dai::BipartiteGraph::nb1
const Neighbor & nb1(size_t i1, size_t _i2) const
Returns constant reference to the _i2 'th neighbor of node i1 of type 1.
Definition: bipgraph.h:87
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::SmallSet::begin
iterator begin()
Returns iterator that points to the first element.
Definition: smallset.h:193
varset.h
Defines the VarSet class, which represents a set of random variables.
dai::eliminationCost_MinNeighbors
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 "MinNeighbor...
Definition: clustergraph.cpp:89
dai::ClusterGraph::bipGraph
const BipartiteGraph & bipGraph() const
Returns a constant reference to the graph structure.
Definition: clustergraph.h:64
dai::sequentialVariableElimination::i
size_t i
Counter.
Definition: clustergraph.h:271
dai::BipartiteGraph
Represents the neighborhood structure of nodes in an undirected, bipartite graph. ...
Definition: bipgraph.h:45
dai::ClusterGraph::var
const Var & var(size_t i) const
Returns a constant reference to the i'th variable.
Definition: clustergraph.h:73
dai::sequentialVariableElimination::sequentialVariableElimination
sequentialVariableElimination(const std::vector< Var > s)
Construct from vector of variables.
Definition: clustergraph.h:275
dai::BipartiteGraph::nrNodes2
size_t nrNodes2() const
Returns number of nodes of type 2.
Definition: bipgraph.h:224
dai::greedyVariableElimination::eliminationCostFunction
size_t(* eliminationCostFunction)(const ClusterGraph &, size_t)
Type of cost functions to be used for greedy variable elimination.
Definition: clustergraph.h:289
dai::BipartiteGraph::addNode1
size_t addNode1()
Adds a node of type 1 without neighbors and returns the index of the added node.
Definition: bipgraph.h:149
dai::BigInt
mpz_class BigInt
Arbitrary precision integer number.
Definition: util.h:101
dai::ClusterGraph::insert
size_t insert(const VarSet &cl)
Inserts a cluster (if it does not already exist) and creates new variables, if necessary.
Definition: clustergraph.h:151
dai::greedyVariableElimination
Helper object for dai::ClusterGraph::VarElim()
Definition: clustergraph.h:286
dai::ClusterGraph::eraseNonMaximal
ClusterGraph & eraseNonMaximal()
Erases all clusters that are not maximal.
Definition: clustergraph.h:171
dai::ClusterGraph::elimVar
VarSet elimVar(size_t i)
Eliminates variable with index i, without deleting the variable itself.
Definition: clustergraph.h:195
dai::SmallSet< Var >::const_iterator
std::vector< Var >::const_iterator const_iterator
Constant iterator over the elements.
Definition: smallset.h:182
dai::ClusterGraph::toString
std::string toString() const
Formats a ClusterGraph as a string.
Definition: clustergraph.h:214
dai::ClusterGraph::cluster
const VarSet & cluster(size_t I) const
Returns a constant reference to the I'th cluster.
Definition: clustergraph.h:85
dai::BipartiteGraph::nb2
const Neighbor & nb2(size_t i2, size_t _i1) const
Returns constant reference to the _i1 'th neighbor of node i2 of type 2.
Definition: bipgraph.h:100
dai::ClusterGraph
A ClusterGraph is a hypergraph with variables as nodes, and "clusters" (sets of variables) as hypered...
Definition: clustergraph.h:34
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::ClusterGraph::adj
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 clust...
Definition: clustergraph.h:114
bforeach
#define bforeach
An alias to the BOOST_FOREACH macro from the boost::bforeach library.
Definition: util.h:48
dai::sequentialVariableElimination
Helper object for dai::ClusterGraph::VarElim()
Definition: clustergraph.h:266
dai::BipartiteGraph::eraseNode2
void eraseNode2(size_t n2)
Removes node n2 of type 2 and all incident edges; indices of other nodes are changed accordingly...
Definition: bipgraph.cpp:63
dai::eliminationCost_MinWeight
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" ...
Definition: clustergraph.cpp:94
dai::eliminationCost_MinFill
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" cr...
Definition: clustergraph.cpp:105
dai::ClusterGraph::findVar
size_t findVar(const Var &n) const
Returns the index of variable n.
Definition: clustergraph.h:91
dai::greedyVariableElimination::operator()
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 minimiz...
Definition: clustergraph.cpp:75
dai::ClusterGraph::nrClusters
size_t nrClusters() const
Returns number of clusters.
Definition: clustergraph.h:79
dai::Neighbor
Describes the neighbor relationship of two nodes in a graph.
Definition: graph.h:73
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::ClusterGraph::findCluster
size_t findCluster(const VarSet &cl) const
Returns the index of a cluster cl.
Definition: clustergraph.h:96
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
dai::greedyVariableElimination::heuristic
eliminationCostFunction heuristic
Pointer to the cost function used.
Definition: clustergraph.h:293
dai::ClusterGraph::VarElim
ClusterGraph VarElim(EliminationChoice f, size_t maxStates=0) const
Performs Variable Elimination, keeping track of the interactions that are created along the way...
Definition: clustergraph.h:231
DAI_ASSERT
#define DAI_ASSERT(condition)
Assertion mechanism, similar to the standard assert() macro. It is always active, even if NDEBUG is d...
Definition: exceptions.h:60
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::sequentialVariableElimination::operator()
size_t operator()(const ClusterGraph &cl, const std::set< size_t > &)
Returns next variable in sequence.
Definition: clustergraph.cpp:70
bipgraph.h
Defines the BipartiteGraph class, which represents a bipartite graph.
dai::ClusterGraph::_vars
std::vector< Var > _vars
Stores the variables corresponding to the nodes.
Definition: clustergraph.h:40
dai::ClusterGraph::delta
VarSet delta(size_t i) const
Returns union of clusters that contain the i 'th (except this variable itself)
Definition: clustergraph.h:109
dai::ClusterGraph::Delta
VarSet Delta(size_t i) const
Returns union of clusters that contain the i 'th variable.
Definition: clustergraph.h:101
dai::greedyVariableElimination::greedyVariableElimination
greedyVariableElimination(eliminationCostFunction h)
Construct from cost function.
Definition: clustergraph.h:299
dai::sequentialVariableElimination::seq
std::vector< Var > seq
The variable elimination sequence.
Definition: clustergraph.h:269
dai::ClusterGraph::nrVars
size_t nrVars() const
Returns number of variables.
Definition: clustergraph.h:67
dai::ClusterGraph::_clusters
std::vector< VarSet > _clusters
Stores the clusters corresponding to the hyperedges.
Definition: clustergraph.h:43
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_115.png0000644000175000017500000000046112552200245015736 0ustar jorismjorism‰PNG  IHDRí£¬º0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï IDATxíAƒ E_(`­÷¿mÐQ°ãªëL^Â$?äÿ‚À@˜^@ï1*Ì¢½ƒTÕ®ê Ú¼[bÕÝV¥r{ÈÑl 6½Û=x…—‚”æ͈'f‰ì:d¯?Ìç¼k2×´›Ïp£IÜi²äéísH½§R«/‰Ð"ÀHàè0òôðÔŠâ[Yâð‹¿ÿ6¤íÓIEND®B`‚libDAI-0.3.2/doc/html/form_28.png0000644000175000017500000000136712552200221015661 0ustar jorismjorism‰PNG  IHDRv"½fÝÂ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïfIDATxíÙrã E[ ÐÂÿÿít£År"W¦j,WFÑ•;æ@o¼üÀ/UÎù|G€(ÕÖªô«µ6€¨5Yy7n×A{‰õ8Ýî>y•<ífžny÷¶…a³ŠxÒðoºÆ†ùpéCÒž‘YrLºÆ%Ÿ£~“9D'9«¾•È%VÆe߬ͨÏä’1ÛR¤êH}¹ø…!Ss Íž)«·48¨S3ò=k®wkãñúG1+ùÐ|Óµ÷¯`Ùð Ñùƒ¥Á$dÍ‚ ÿg]isˆ§Z^ŒewÎØÅfšma÷zž»»6¬×’7¬MžfªïXH±±¦bo\»HÁk¬þx °:mmgç «ËR/¬Ø!FùÀ:%çªD‰Ë—|…õÛ6‡zv Ø>çuálZ¢&ý6MÙ†J ~,.´è ;F_Æ) ³ø¹ü€M=g:C”ß¼7l_Ž:wËò$>/¢¯¬Å–Ñ©Eô…à5á“‹ZåšãLËSˆ/±=V†³|‘èzØ"l…<ݽ»eðEmsÑKl–>GZÇ•S`êꦫv!YD àR%MGß»ÆV«|J=›Ü#"AË×Ös=û÷¼9S«föÞ þê(p_[Ì;NåÖÖšPã”h7jÒýͺùø]®_gà¿Þ%‰§húl×'míZyC¶¶£§‰VüÚùîS´Æ‘‡-—ü¹Ü¥¢>öG—(S?nî•æ¹hD;n–Þïî•1zº¬NN[»¸S®4K ±C§áS‘ÕÖÔŸ¹hŒ!ø½úK{pAÒ†%IEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1fo__divides0-members.html0000644000175000017500000000570512552201365023144 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/index.html0000644000175000017500000001730212552201370015676 0ustar jorismjorism 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.3.2
Date
July 17, 2015

About libDAI

libDAI is a free/open source C++ library 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.7 (both 32 and 64 bits).

libDAI has also been successfully compiled with MS Visual Studio 2008 under Windows, MS Visual Studio 2010 under Windows 64, and with Cygwin under Windows.

Finally, libDAI has been compiled successfully on MacOS X (both 32 and 64 bits).

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_108.png0000644000175000017500000000034712552200243015741 0ustar jorismjorism‰PNG  IHDR(–Ýã0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïVIDATxí À 'ÑxQëÿ[K¥©ýƒŒ…]æ ¿/pú8-ÎÐm:’™G;gtuîéŠ]‰Ãm]hEb_1[*ˆ¾ò óT‹_]µÍþ¼ €SQêþýIEND®B`‚libDAI-0.3.2/doc/html/namespaces.html0000644000175000017500000000510612552201370016705 0ustar jorismjorism libDAI: Namespace List
Namespace List
Here is a list of all documented namespaces with brief descriptions:
 NdaiNamespace for libDAI
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1FactorGraph.html0000644000175000017500000032522512552201365021145 0ustar jorismjorism libDAI: dai::FactorGraph Class Reference
Private Member Functions | Private Attributes | List of all members
dai::FactorGraph Class Reference

Represents a factor graph. More...

#include <dai/factorgraph.h>

Inheritance diagram for dai::FactorGraph:
dai::CobwebGraph dai::RegionGraph

Public Member Functions

Constructors and destructors
 FactorGraph ()
 Default constructor. More...
 
 FactorGraph (const std::vector< Factor > &P)
 Constructs a factor graph from a vector of factors. More...
 
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. More...
 
virtual ~FactorGraph ()
 Destructor. More...
 
virtual FactorGraph * clone () const
 Virtual copy constructor. More...
 
Accessors and mutators
const Var & var (size_t i) const
 Returns constant reference the i 'th variable. More...
 
const std::vector< Var > & vars () const
 Returns constant reference to all variables. More...
 
const Factor & factor (size_t I) const
 Returns constant reference to I 'th factor. More...
 
const std::vector< Factor > & factors () const
 Returns constant reference to all factors. More...
 
const Neighbors & nbV (size_t i) const
 Returns constant reference to neighbors of the i 'th variable. More...
 
const Neighbors & nbF (size_t I) const
 Returns constant reference to neighbors of the I 'th factor. More...
 
const Neighbor & nbV (size_t i, size_t _I) const
 Returns constant reference to the _I 'th neighbor of the i 'th variable. More...
 
const Neighbor & nbF (size_t I, size_t _i) const
 Returns constant reference to the _i 'th neighbor of the I 'th factor. More...
 
Queries
const BipartiteGraph & bipGraph () const
 Returns neighborhood structure. More...
 
size_t nrVars () const
 Returns number of variables. More...
 
size_t nrFactors () const
 Returns number of factors. More...
 
size_t nrEdges () const
 Calculates number of edges. More...
 
size_t findVar (const Var &n) const
 Returns the index of a particular variable. More...
 
SmallSet< size_t > findVars (const VarSet &ns) const
 Returns a set of indexes corresponding to a set of variables. More...
 
size_t findFactor (const VarSet &ns) const
 Returns index of the first factor that depends on the variables. More...
 
VarSet inds2vars (const std::vector< size_t > &inds) const
 Returns the VarSet corresponding to a vector of variable indices. More...
 
VarSet Delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself included. More...
 
VarSet Delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself included. More...
 
VarSet delta (size_t i) const
 Return all variables that occur in a factor involving the i 'th variable, itself excluded. More...
 
VarSet delta (const VarSet &vs) const
 Return all variables that occur in a factor involving some variable in vs, vs itself excluded. More...
 
SmallSet< size_t > Deltai (size_t i) const
 Return all the indices of variables that occur in a factor involving the i 'th variable, itself included. More...
 
SmallSet< size_t > deltai (size_t i) const
 Return all the indices of variables that occur in a factor involving the i 'th variable, itself excluded. More...
 
bool isConnected () const
 Returns true if the factor graph is connected. More...
 
bool isTree () const
 Returns true if the factor graph is a tree (i.e., has no cycles and is connected) More...
 
bool isPairwise () const
 Returns true if each factor depends on at most two variables. More...
 
bool isBinary () const
 Returns true if each variable has only two possible values. More...
 
GraphAL MarkovGraph () const
 Constructs the corresponding Markov graph. More...
 
bool isMaximal (size_t I) const
 Returns whether the I 'th factor is maximal. More...
 
size_t maximalFactor (size_t I) const
 Returns the index of a maximal factor that contains the I 'th factor. More...
 
std::vector< VarSet > maximalFactorDomains () const
 Returns the maximal factor domains in this factorgraph. More...
 
Real logScore (const std::vector< size_t > &statevec) const
 Evaluates the log score (i.e., minus the energy) of the joint configuration statevec. More...
 
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. More...
 
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. More...
 
void backupFactor (size_t I)
 Makes a backup of the I 'th factor. More...
 
void restoreFactor (size_t I)
 Restores the I 'th factor from the backup (it should be backed up first) More...
 
virtual void backupFactors (const std::set< size_t > &facs)
 Backup the factors specified by indices in facs. More...
 
virtual void restoreFactors ()
 Restore all factors to the backup copies. More...
 
void backupFactors (const VarSet &ns)
 Makes a backup of all factors connected to a set of variables. More...
 
void restoreFactors (const VarSet &ns)
 Restores all factors connected to a set of variables from their backups. More...
 
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. More...
 
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. More...
 
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}$) More...
 
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. More...
 
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. More...
 
virtual void makeCavity (size_t i, bool backup=false)
 Set all factors interacting with the i 'th variable to 1. More...
 
virtual void makeRegionCavity (std::vector< size_t > facInds, bool backup)
 Set all factors indexed by facInds to 1. More...
 

Private Member Functions

void constructGraph (size_t nrEdges)
 Part of constructors (creates edges, neighbors and adjacency matrix) More...
 

Private Attributes

BipartiteGraph _G
 Stores the neighborhood structure. More...
 
std::vector< Var > _vars
 Stores the variables. More...
 
std::vector< Factor > _factors
 Stores the factors. More...
 
std::map< size_t, Factor > _backup
 Stores backups of some factors. More...
 

Input/Output

virtual void ReadFromFile (const char *filename)
 Reads a factor graph from a file. More...
 
virtual void WriteToFile (const char *filename, size_t precision=15) const
 Writes a factor graph to a file. More...
 
virtual void printDot (std::ostream &os) const
 Writes a factor graph to a GraphViz .dot file. More...
 
std::string toString () const
 Formats a factor graph as a string. More...
 
void fromString (const std::string &s)
 Reads a factor graph from a string. More...
 
std::ostream & operator<< (std::ostream &os, const FactorGraph &fg)
 Writes a factor graph to an output stream. More...
 
std::istream & operator>> (std::istream &is, FactorGraph &fg)
 Reads a factor graph from an input stream. More...
 

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, 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 
)

Constructs a factor graph from given factor and variable iterators.

Template Parameters
FactorInputIteratorIterates over instances of type dai::Factor
VarInputIteratorIterates 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 ( )
inlinevirtual

Destructor.

Member Function Documentation

virtual FactorGraph* dai::FactorGraph::clone ( ) const
inlinevirtual

Virtual copy constructor.

Reimplemented in dai::RegionGraph, and dai::CobwebGraph.

const Var& dai::FactorGraph::var ( size_t  i) const
inline

Returns constant reference the i 'th variable.

Examples:
example.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, and example_sprinkler.cpp.
size_t dai::FactorGraph::nrFactors ( ) const
inline

Returns number of factors.

Examples:
example.cpp, and example_sprinkler.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_FOUNDif 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_FOUNDif 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_FOUNDif no factor in this factor graph depends on those variables
VarSet dai::FactorGraph::inds2vars ( const std::vector< size_t > &  inds) const
inline

Returns the VarSet corresponding to a vector of variable indices.

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.

SmallSet< size_t > dai::FactorGraph::Deltai ( size_t  i) const

Return all the indices of variables that occur in a factor involving the i 'th variable, itself included.

SmallSet<size_t> dai::FactorGraph::deltai ( size_t  i) const
inline

Return all the indices of variables that occur in a factor involving the i 'th variable, 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) const

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 
)
inlinevirtual

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 
)
inlinevirtual

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_UNDOif a backup already exists
void dai::FactorGraph::restoreFactor ( size_t  I)

Restores the I 'th factor from the backup (it should be backed up first)

Exceptions
OBJECT_NOT_FOUNDif a backup does not exist
void dai::FactorGraph::backupFactors ( const std::set< size_t > &  facs)
virtual

Backup the factors specified by indices in facs.

Exceptions
MULTIPLE_UNDOif 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_UNDOif a backup already exists
void dai::FactorGraph::restoreFactors ( const VarSet &  ns)

Restores all factors connected to a set of variables from their backups.

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

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

void dai::FactorGraph::makeRegionCavity ( std::vector< size_t >  facInds,
bool  backup 
)
virtual

Set all factors indexed by facInds to 1.

If backup == true, make a backup of all factors that are changed

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_FILEif the file cannot be opened
INVALID_FACTORGRAPH_FILEif the file is not valid

Reimplemented in dai::RegionGraph, and dai::CobwebGraph.

Examples:
example.cpp, and example_sprinkler_em.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_FILEif the file cannot be written

Reimplemented in dai::RegionGraph, and dai::CobwebGraph.

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::CobwebGraph, and dai::RegionGraph.

std::string dai::FactorGraph::toString ( ) const
inline

Formats a factor graph as a string.

void dai::FactorGraph::fromString ( const std::string &  s)
inline

Reads a factor graph from a string.

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_FILEif the input stream is not valid

Member Data Documentation

BipartiteGraph dai::FactorGraph::_G
private

Stores the neighborhood structure.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_46.png0000644000175000017500000000167212552200225015664 0ustar jorismjorism‰PNG  IHDR—+BIêE0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï)IDATxíÛÖ£ …7çCKyÿ·P«ÖÖÒYsÁúóÛV%›Mr ÿiH¸NÅ{™p!NgSNÇE.£àLŒæ·üŽá2ÙÌŸsÍP.÷í}TÁxï,ƒôJv‹KÜ5¬CÜè_\Vò{.·é¯Àÿ-×Ç\F×ÊKc4´<·/‹¦¶¹`#b¦¹øýë\QàÞ>Ñä&H$šŽ¶„–/ò;\2g¾«zÉ>äÊV¶-ñ4A’PŽm’•È»û›¡|&çѺ®rÙǤHáÌxªdéÓW¿]ís9 wK§ò2×M´Y®ª—”‡\Kná¬Ü É«9/q‘â¾–"ïR‘¿,y7)8Êë<9ÆÏÂìï#-§Ü!Á y«v*$ŸqÑlRZ«ŒµÂÚ2{1vôÓ&—!n¥Ë˜¹¤4!ð{´,è©ðŽï=—2}#jzÍÕ•,&§}ÎeòƒÅh—¨`}O\gªÃû¶-;Ü.¥ˆ2Õ=5×þb{HÑŠqû¶Æ’qÞæ'.mÍfû—La’cÍE½½Ô·ºê˜;Ä5½àd¬¹TŽìƒ=Í*WH)¥aQJØó>F®så4Vz !Ä°ØÒ‹›ˆW0­…RÅ,c&=¿²·Ò²R83W}UF¥©ˆ¾µæ{µpY÷ޡ﹨ï¶u²ŽÎíœÓ\¢7è›Åhÿ•»ÙQþˆKÕBÎC Ý+þ5.ØŒC½\¶ì[„¤ Z« éß%ÑÎx/â›\*ÛùzÅ—$–nÍ–€½ǵ8TÅZ“¦÷ϤÅÏ!2‡ƒ>÷¸rŽl¸—}òÇ\01Ó‰¸<ñ/¸X&¶ý½6؉q\z9R»úWE•m¯ü‚«“DëšÅó%Jêv|ÿÐcøt¿™-‹ÓTg ÇY‚>¶þ(.ƒ$H'°ÊrS–lǸ}ì]el½ãÄ_äÒ)?ÈØí¢n¥?þ²‘å«\Y©×5±z¼ó— ±ë–eî”°ÞûøW¤ñ²&òÌ’ª'|g³À{aì9Uàeühó ¹ü IEND®B`‚libDAI-0.3.2/doc/html/functions_vars_m.html0000644000175000017500000001532712552201370020153 0ustar jorismjorism libDAI: Class Members - Variables
 

- m -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__log.html0000644000175000017500000001146512552201365020566 0ustar jorismjorism libDAI: dai::fo_log< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_log< T > Struct Template Reference

Function object that takes the logarithm. More...

#include <dai/prob.h>

Inherits unary_function< T, T >.

Public Member Functions

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

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/fbp_8h_source.html0000644000175000017500000006567412552201363017336 0ustar jorismjorism libDAI: include/dai/fbp.h Source File
fbp.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_fbp_h
14 #define __defined_libdai_fbp_h
15 
16 
17 #include <dai/dai_config.h>
18 #ifdef DAI_WITH_FBP
19 
20 
21 #include <string>
22 #include <dai/daialg.h>
23 #include <dai/factorgraph.h>
24 #include <dai/properties.h>
25 #include <dai/enum.h>
26 #include <dai/bp.h>
27 
28 
29 namespace dai {
30 
31 
33 
59 class FBP : public BP {
60  protected:
62  std::vector<Real> _weight;
63 
64  public:
66 
67  FBP() : BP(), _weight() {}
69 
71 
74  FBP( const FactorGraph &fg, const PropertySet &opts ) : BP(fg, opts), _weight() {
75  setProperties( opts );
76  construct();
77  }
79 
81 
82  virtual FBP* clone() const { return new FBP(*this); }
83  virtual FBP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new FBP( fg, opts ); }
84  virtual std::string name() const { return "FBP"; }
85  virtual Real logZ() const;
87 
89 
90  Real Weight( size_t I ) const { return _weight[I]; }
92 
94  const std::vector<Real>& Weights() const { return _weight; }
95 
97  void setWeight( size_t I, Real c ) { _weight[I] = c; }
98 
100 
102  void setWeights( const std::vector<Real> &c ) { _weight = c; }
103 
104  protected:
106 
109  virtual Prob calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const;
110 
111  // Calculate the updated message from the \a _I 'th neighbor of variable \a i to variable \a i
112  virtual void calcNewMessage( size_t i, size_t _I );
113 
114  // Calculates unnormalized belief of factor \a I
115  virtual void calcBeliefF( size_t I, Prob &p ) const {
116  p = calcIncomingMessageProduct( I, false, 0 );
117  }
118 
119  // Helper function for constructors
120  virtual void construct();
121 };
122 
123 
124 } // end of namespace dai
125 
126 
127 #endif
128 
129 
130 #endif
dai::FBP::FBP
FBP(const FactorGraph &fg, const PropertySet &opts)
Construct from FactorGraph fg and PropertySet opts.
Definition: fbp.h:74
dai::FBP::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: fbp.h:84
bp.h
Defines class BP, which implements (Loopy) Belief Propagation.
dai::FBP::construct
virtual void construct()
Helper function for constructors.
Definition: fbp.cpp:154
dai::FBP::setWeights
void setWeights(const std::vector< Real > &c)
Sets the weights of all factors simultaenously.
Definition: fbp.h:102
dai::FBP
Approximate inference algorithm "Fractional Belief Propagation" [WiH03].
Definition: fbp.h:59
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::FBP::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: fbp.cpp:26
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::FBP::Weights
const std::vector< Real > & Weights() const
Returns constant reference to vector of all factor weights.
Definition: fbp.h:94
dai::FBP::calcNewMessage
virtual void calcNewMessage(size_t i, size_t _I)
Calculate the updated message from the _I 'th neighbor of variable i to variable i.
Definition: fbp.cpp:101
dai::BP::setProperties
virtual void setProperties(const PropertySet &opts)
Definition: bp.cpp:33
dai::FBP::calcIncomingMessageProduct
virtual Prob calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const
Calculate the product of factor I and the incoming messages.
Definition: fbp.cpp:44
dai::FBP::setWeight
void setWeight(size_t I, Real c)
Sets the weight of the I 'th factor to c.
Definition: fbp.h:97
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::BP
Approximate inference algorithm "(Loopy) Belief Propagation".
Definition: bp.h:63
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::FBP::FBP
FBP()
Default constructor.
Definition: fbp.h:68
dai::FBP::calcBeliefF
virtual void calcBeliefF(size_t I, Prob &p) const
Calculates unnormalized belief of factor I.
Definition: fbp.h:115
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::FBP::_weight
std::vector< Real > _weight
Factor weights (indexed by factor ID)
Definition: fbp.h:62
dai::FBP::construct
virtual FBP * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: fbp.h:83
dai::FBP::clone
virtual FBP * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: fbp.h:82
dai::FBP::Weight
Real Weight(size_t I) const
Returns weight of the I 'th factor.
Definition: fbp.h:91
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_61.png0000644000175000017500000000073212552200231015652 0ustar jorismjorism‰PNG  IHDRKiÙrì0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïIIDATxíÍvÄ …?5šh~|ÿ·-(6¦3í¬»ð‚\àböÿA¼îÏ€ouÙ÷¸–¤jÑ-ŸÅ±žÙq?ôêv4?À«„õÖM¶*†ìÛ¹fHŠ X¤ª¦µ{ވŵXmå*¸½Ÿ%|YZB-¦*àŸPxInšfvÕG­µ4¨Žµ_† ð…_½s ËZCXw©-NJëË°B]nr7[<ÅB8E9ÇÌŽâ\Ó‡Åo­kÃ’*§Jlõ{È\6%û«Ž´ggůÇŒõ;YRÿ©i¿«°†¤ꄵ¥6§õ8••mõôAR6¯aùl IûR®‹—}ÍjT¬PÔð*‚•”.Ú&6¥1%'iBJjFÅšüOYÒ®tÝobzsÏ_Èøx/Âd{ Ó[è¦ïÖ7E‘aü÷lÇú·{}_Bó* ¬c¹IEND®B`‚libDAI-0.3.2/doc/html/dag_8h.html0000644000175000017500000001103412552201363015717 0ustar jorismjorism libDAI: include/dai/dag.h File Reference
Classes | Namespaces
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.

Classes

class  dai::DAG
 Represents the neighborhood structure of nodes in a directed cyclic graph. More...
 

Namespaces

 dai
 Namespace for libDAI.
 

Detailed Description

Defines the DAG class, which represents a directed acyclic graph.

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/prob_8h_source.html0000644000175000017500000045426712552201363017531 0ustar jorismjorism libDAI: include/dai/prob.h Source File
prob.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_prob_h
14 #define __defined_libdai_prob_h
15 
16 
17 #include <cmath>
18 #include <vector>
19 #include <ostream>
20 #include <algorithm>
21 #include <numeric>
22 #include <functional>
23 #include <dai/util.h>
24 #include <dai/exceptions.h>
25 
26 
27 namespace dai {
28 
29 
31 template<typename T> struct fo_id : public std::unary_function<T, T> {
33  T operator()( const T &x ) const {
34  return x;
35  }
36 };
37 
38 
40 template<typename T> struct fo_abs : public std::unary_function<T, T> {
42  T operator()( const T &x ) const {
43  if( x < (T)0 )
44  return -x;
45  else
46  return x;
47  }
48 };
49 
50 
52 template<typename T> struct fo_exp : public std::unary_function<T, T> {
54  T operator()( const T &x ) const {
55  return exp( x );
56  }
57 };
58 
59 
61 template<typename T> struct fo_log : public std::unary_function<T, T> {
63  T operator()( const T &x ) const {
64  return log( x );
65  }
66 };
67 
68 
70 template<typename T> struct fo_log0 : public std::unary_function<T, T> {
72  T operator()( const T &x ) const {
73  if( x )
74  return log( x );
75  else
76  return 0;
77  }
78 };
79 
80 
82 template<typename T> struct fo_inv : public std::unary_function<T, T> {
84  T operator()( const T &x ) const {
85  return 1 / x;
86  }
87 };
88 
89 
91 template<typename T> struct fo_inv0 : public std::unary_function<T, T> {
93  T operator()( const T &x ) const {
94  if( x )
95  return 1 / x;
96  else
97  return 0;
98  }
99 };
100 
101 
103 template<typename T> struct fo_plog0p : public std::unary_function<T, T> {
105  T operator()( const T &p ) const {
106  return p * dai::log0(p);
107  }
108 };
109 
110 
112 template<typename T> struct fo_divides0 : public std::binary_function<T, T, T> {
114  T operator()( const T &x, const T &y ) const {
115  if( y == (T)0 )
116  return (T)0;
117  else
118  return x / y;
119  }
120 };
121 
122 
124 template<typename T> struct fo_KL : public std::binary_function<T, T, T> {
126  T operator()( const T &p, const T &q ) const {
127  if( p == (T)0 )
128  return (T)0;
129  else
130  return p * (log(p) - log(q));
131  }
132 };
133 
134 
136 template<typename T> struct fo_Hellinger : public std::binary_function<T, T, T> {
138  T operator()( const T &p, const T &q ) const {
139  T x = sqrt(p) - sqrt(q);
140  return x * x;
141  }
142 };
143 
144 
146 template<typename T> struct fo_pow : public std::binary_function<T, T, T> {
148  T operator()( const T &x, const T &y ) const {
149  if( y != 1 )
150  return pow( x, y );
151  else
152  return x;
153  }
154 };
155 
156 
158 template<typename T> struct fo_max : public std::binary_function<T, T, T> {
160  T operator()( const T &x, const T &y ) const {
161  return (x > y) ? x : y;
162  }
163 };
164 
165 
167 template<typename T> struct fo_min : public std::binary_function<T, T, T> {
169  T operator()( const T &x, const T &y ) const {
170  return (x > y) ? y : x;
171  }
172 };
173 
174 
176 template<typename T> struct fo_absdiff : public std::binary_function<T, T, T> {
178  T operator()( const T &x, const T &y ) const {
179  return dai::abs( x - y );
180  }
181 };
182 
183 
185 
193 template <typename T>
194 class TProb {
195  public:
197  typedef std::vector<T> container_type;
198 
200  typedef TProb<T> this_type;
201 
202  private:
204  container_type _p;
205 
206  public:
208 
209  TProb() : _p() {}
211 
213  explicit TProb( size_t n ) : _p( n, (T)1 / n ) {}
214 
216  explicit TProb( size_t n, T p ) : _p( n, p ) {}
217 
219 
225  template <typename TIterator>
226  TProb( TIterator begin, TIterator end, size_t sizeHint ) : _p() {
227  _p.reserve( sizeHint );
228  _p.insert( _p.begin(), begin, end );
229  }
230 
232 
235  template <typename S>
236  TProb( const std::vector<S> &v ) : _p() {
237  _p.reserve( v.size() );
238  _p.insert( _p.begin(), v.begin(), v.end() );
239  }
241 
243  typedef typename container_type::const_iterator const_iterator;
245  typedef typename container_type::iterator iterator;
247  typedef typename container_type::const_reverse_iterator const_reverse_iterator;
249  typedef typename container_type::reverse_iterator reverse_iterator;
250 
252 
253  iterator begin() { return _p.begin(); }
256  const_iterator begin() const { return _p.begin(); }
257 
259  iterator end() { return _p.end(); }
261  const_iterator end() const { return _p.end(); }
262 
264  reverse_iterator rbegin() { return _p.rbegin(); }
266  const_reverse_iterator rbegin() const { return _p.rbegin(); }
267 
269  reverse_iterator rend() { return _p.rend(); }
271  const_reverse_iterator rend() const { return _p.rend(); }
273 
275 
276  void resize( size_t sz ) {
277  _p.resize( sz );
278  }
280 
282 
283  T get( size_t i ) const {
285 #ifdef DAI_DEBUG
286  return _p.at(i);
287 #else
288  return _p[i];
289 #endif
290  }
291 
293  void set( size_t i, T val ) {
294  DAI_DEBASSERT( i < _p.size() );
295  _p[i] = val;
296  }
298 
300 
301  const container_type& p() const { return _p; }
303 
305  container_type& p() { return _p; }
306 
308  T operator[]( size_t i ) const { return get(i); }
309 
311  size_t size() const { return _p.size(); }
312 
314 
322  template<typename unOp> T accumulateSum( T init, unOp op ) const {
323  T t = op(init);
324  for( const_iterator it = begin(); it != end(); it++ )
325  t += op(*it);
326  return t;
327  }
328 
330 
338  template<typename unOp> T accumulateMax( T init, unOp op, bool minimize ) const {
339  T t = op(init);
340  if( minimize ) {
341  for( const_iterator it = begin(); it != end(); it++ )
342  t = std::min( t, op(*it) );
343  } else {
344  for( const_iterator it = begin(); it != end(); it++ )
345  t = std::max( t, op(*it) );
346  }
347  return t;
348  }
349 
351  T entropy() const { return -accumulateSum( (T)0, fo_plog0p<T>() ); }
352 
354  T max() const { return accumulateMax( (T)(-INFINITY), fo_id<T>(), false ); }
355 
357  T min() const { return accumulateMax( (T)INFINITY, fo_id<T>(), true ); }
358 
360  T sum() const { return accumulateSum( (T)0, fo_id<T>() ); }
361 
363  T sumAbs() const { return accumulateSum( (T)0, fo_abs<T>() ); }
364 
366  T maxAbs() const { return accumulateMax( (T)0, fo_abs<T>(), false ); }
367 
369  bool hasNaNs() const {
370  bool foundnan = false;
371  for( const_iterator x = _p.begin(); x != _p.end(); x++ )
372  if( dai::isnan( *x ) ) {
373  foundnan = true;
374  break;
375  }
376  return foundnan;
377  }
378 
380  bool hasNegatives() const {
381  return (std::find_if( _p.begin(), _p.end(), std::bind2nd( std::less<T>(), (T)0 ) ) != _p.end());
382  }
383 
385  std::pair<size_t,T> argmax() const {
386  T max = _p[0];
387  size_t arg = 0;
388  for( size_t i = 1; i < size(); i++ ) {
389  if( _p[i] > max ) {
390  max = _p[i];
391  arg = i;
392  }
393  }
394  return std::make_pair( arg, max );
395  }
396 
398  size_t draw() {
399  Real x = rnd_uniform() * sum();
400  T s = 0;
401  for( size_t i = 0; i < size(); i++ ) {
402  s += get(i);
403  if( s > x )
404  return i;
405  }
406  return( size() - 1 );
407  }
408 
410 
412  bool operator<( const this_type& q ) const {
413  DAI_DEBASSERT( size() == q.size() );
414  return lexicographical_compare( begin(), end(), q.begin(), q.end() );
415  }
416 
418  bool operator==( const this_type& q ) const {
419  if( size() != q.size() )
420  return false;
421  return p() == q.p();
422  }
423 
425  std::string toString() const {
426  std::stringstream ss;
427  ss << *this;
428  return ss.str();
429  }
431 
433 
434  template<typename unaryOp> this_type pwUnaryTr( unaryOp op ) const {
436  this_type r;
437  r._p.reserve( size() );
438  std::transform( _p.begin(), _p.end(), back_inserter( r._p ), op );
439  return r;
440  }
441 
443  this_type operator- () const { return pwUnaryTr( std::negate<T>() ); }
444 
446  this_type abs() const { return pwUnaryTr( fo_abs<T>() ); }
447 
449  this_type exp() const { return pwUnaryTr( fo_exp<T>() ); }
450 
452 
454  this_type log(bool zero=false) const {
455  if( zero )
456  return pwUnaryTr( fo_log0<T>() );
457  else
458  return pwUnaryTr( fo_log<T>() );
459  }
460 
462 
464  this_type inverse(bool zero=true) const {
465  if( zero )
466  return pwUnaryTr( fo_inv0<T>() );
467  else
468  return pwUnaryTr( fo_inv<T>() );
469  }
470 
472 
474  this_type normalized( ProbNormType norm = dai::NORMPROB ) const {
475  T Z = 0;
476  if( norm == dai::NORMPROB )
477  Z = sum();
478  else if( norm == dai::NORMLINF )
479  Z = maxAbs();
480  if( Z == (T)0 ) {
481  DAI_THROW(NOT_NORMALIZABLE);
482  return *this;
483  } else
484  return pwUnaryTr( std::bind2nd( std::divides<T>(), Z ) );
485  }
487 
489 
490  template<typename unaryOp> this_type& pwUnaryOp( unaryOp op ) {
492  std::transform( _p.begin(), _p.end(), _p.begin(), op );
493  return *this;
494  }
495 
497  this_type& randomize() {
498  std::generate( _p.begin(), _p.end(), rnd_uniform );
499  return *this;
500  }
501 
503  this_type& setUniform () {
504  fill( (T)1 / size() );
505  return *this;
506  }
507 
509  this_type& takeAbs() { return pwUnaryOp( fo_abs<T>() ); }
510 
512  this_type& takeExp() { return pwUnaryOp( fo_exp<T>() ); }
513 
515 
517  this_type& takeLog(bool zero=false) {
518  if( zero ) {
519  return pwUnaryOp( fo_log0<T>() );
520  } else
521  return pwUnaryOp( fo_log<T>() );
522  }
523 
525 
527  T normalize( ProbNormType norm=dai::NORMPROB ) {
528  T Z = 0;
529  if( norm == dai::NORMPROB )
530  Z = sum();
531  else if( norm == dai::NORMLINF )
532  Z = maxAbs();
533  if( Z == (T)0 )
534  DAI_THROW(NOT_NORMALIZABLE);
535  else
536  *this /= Z;
537  return Z;
538  }
540 
542 
543  this_type& fill( T x ) {
545  std::fill( _p.begin(), _p.end(), x );
546  return *this;
547  }
548 
550  this_type& operator+= (T x) {
551  if( x != 0 )
552  return pwUnaryOp( std::bind2nd( std::plus<T>(), x ) );
553  else
554  return *this;
555  }
556 
558  this_type& operator-= (T x) {
559  if( x != 0 )
560  return pwUnaryOp( std::bind2nd( std::minus<T>(), x ) );
561  else
562  return *this;
563  }
564 
566  this_type& operator*= (T x) {
567  if( x != 1 )
568  return pwUnaryOp( std::bind2nd( std::multiplies<T>(), x ) );
569  else
570  return *this;
571  }
572 
574  this_type& operator/= (T x) {
575  if( x != 1 )
576  return pwUnaryOp( std::bind2nd( fo_divides0<T>(), x ) );
577  else
578  return *this;
579  }
580 
582  this_type& operator^= (T x) {
583  if( x != (T)1 )
584  return pwUnaryOp( std::bind2nd( fo_pow<T>(), x) );
585  else
586  return *this;
587  }
589 
591 
592  this_type operator+ (T x) const { return pwUnaryTr( std::bind2nd( std::plus<T>(), x ) ); }
594 
596  this_type operator- (T x) const { return pwUnaryTr( std::bind2nd( std::minus<T>(), x ) ); }
597 
599  this_type operator* (T x) const { return pwUnaryTr( std::bind2nd( std::multiplies<T>(), x ) ); }
600 
602  this_type operator/ (T x) const { return pwUnaryTr( std::bind2nd( fo_divides0<T>(), x ) ); }
603 
605  this_type operator^ (T x) const { return pwUnaryTr( std::bind2nd( fo_pow<T>(), x ) ); }
607 
609 
610 
615  template<typename binaryOp> this_type& pwBinaryOp( const this_type &q, binaryOp op ) {
616  DAI_DEBASSERT( size() == q.size() );
617  std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), op );
618  return *this;
619  }
620 
622 
624  this_type& operator+= (const this_type & q) { return pwBinaryOp( q, std::plus<T>() ); }
625 
627 
629  this_type& operator-= (const this_type & q) { return pwBinaryOp( q, std::minus<T>() ); }
630 
632 
634  this_type& operator*= (const this_type & q) { return pwBinaryOp( q, std::multiplies<T>() ); }
635 
637 
640  this_type& operator/= (const this_type & q) { return pwBinaryOp( q, fo_divides0<T>() ); }
641 
643 
646  this_type& divide (const this_type & q) { return pwBinaryOp( q, std::divides<T>() ); }
647 
649 
651  this_type& operator^= (const this_type & q) { return pwBinaryOp( q, fo_pow<T>() ); }
653 
655 
656 
661  template<typename binaryOp> this_type pwBinaryTr( const this_type &q, binaryOp op ) const {
662  DAI_DEBASSERT( size() == q.size() );
663  TProb<T> r;
664  r._p.reserve( size() );
665  std::transform( _p.begin(), _p.end(), q._p.begin(), back_inserter( r._p ), op );
666  return r;
667  }
668 
670 
672  this_type operator+ ( const this_type& q ) const { return pwBinaryTr( q, std::plus<T>() ); }
673 
675 
677  this_type operator- ( const this_type& q ) const { return pwBinaryTr( q, std::minus<T>() ); }
678 
680 
682  this_type operator* ( const this_type &q ) const { return pwBinaryTr( q, std::multiplies<T>() ); }
683 
685 
688  this_type operator/ ( const this_type &q ) const { return pwBinaryTr( q, fo_divides0<T>() ); }
689 
691 
694  this_type divided_by( const this_type &q ) const { return pwBinaryTr( q, std::divides<T>() ); }
695 
697 
699  this_type operator^ ( const this_type &q ) const { return pwBinaryTr( q, fo_pow<T>() ); }
701 
703 
705  template<typename binOp1, typename binOp2> T innerProduct( const this_type &q, T init, binOp1 binaryOp1, binOp2 binaryOp2 ) const {
706  DAI_DEBASSERT( size() == q.size() );
707  return std::inner_product( begin(), end(), q.begin(), init, binaryOp1, binaryOp2 );
708  }
709 };
710 
711 
713 
716 template<typename T> T dist( const TProb<T> &p, const TProb<T> &q, ProbDistType dt ) {
717  switch( dt ) {
718  case DISTL1:
719  return p.innerProduct( q, (T)0, std::plus<T>(), fo_absdiff<T>() );
720  case DISTLINF:
721  return p.innerProduct( q, (T)0, fo_max<T>(), fo_absdiff<T>() );
722  case DISTTV:
723  return p.innerProduct( q, (T)0, std::plus<T>(), fo_absdiff<T>() ) / 2;
724  case DISTKL:
725  return p.innerProduct( q, (T)0, std::plus<T>(), fo_KL<T>() );
726  case DISTHEL:
727  return p.innerProduct( q, (T)0, std::plus<T>(), fo_Hellinger<T>() ) / 2;
728  default:
729  DAI_THROW(UNKNOWN_ENUM_VALUE);
730  return INFINITY;
731  }
732 }
733 
734 
736 
738 template<typename T> std::ostream& operator<< (std::ostream& os, const TProb<T>& p) {
739  os << "(";
740  for( size_t i = 0; i < p.size(); i++ )
741  os << ((i != 0) ? ", " : "") << p.get(i);
742  os << ")";
743  return os;
744 }
745 
746 
748 
751 template<typename T> TProb<T> min( const TProb<T> &a, const TProb<T> &b ) {
752  return a.pwBinaryTr( b, fo_min<T>() );
753 }
754 
755 
757 
760 template<typename T> TProb<T> max( const TProb<T> &a, const TProb<T> &b ) {
761  return a.pwBinaryTr( b, fo_max<T>() );
762 }
763 
764 
766 typedef TProb<Real> Prob;
767 
768 
769 } // end of namespace dai
770 
771 
772 #endif
dai::fo_log
Function object that takes the logarithm.
Definition: prob.h:61
dai::fo_id::operator()
T operator()(const T &x) const
Returns x.
Definition: prob.h:33
dai::TProb::pwBinaryTr
this_type pwBinaryTr(const this_type &q, binaryOp op) const
Returns the result of applying binary operation op pointwise on *this and q.
Definition: prob.h:661
dai::fo_plog0p
Function object that returns p*log0(p)
Definition: prob.h:103
dai::TProb::TProb
TProb()
Default constructor (constructs empty vector)
Definition: prob.h:210
dai::TProb::TProb
TProb(size_t n, T p)
Construct vector of length n with each entry set to p.
Definition: prob.h:216
dai::fo_max::operator()
T operator()(const T &x, const T &y) const
Returns (x > y ? x : y)
Definition: prob.h:160
dai::TProb::fill
this_type & fill(T x)
Sets all entries to x.
Definition: prob.h:544
dai::ProbNormType
ProbNormType
Enumerates different ways of normalizing a probability measure.
Definition: util.h:255
dai::pow
Real pow(Real x, Real y)
Returns x to the power y.
Definition: util.h:132
dai::TProb::TProb
TProb(const std::vector< S > &v)
Construct vector from another vector.
Definition: prob.h:236
dai::ProbDistType
ProbDistType
Enumerates different distance measures between probability measures.
Definition: util.h:265
dai::TProb::accumulateMax
T accumulateMax(T init, unOp op, bool minimize) const
Accumulate all values (similar to std::accumulate) by maximization/minimization.
Definition: prob.h:338
dai::TProb::normalized
this_type normalized(ProbNormType norm=dai::NORMPROB) const
Returns normalized copy of *this, using the specified norm.
Definition: prob.h:474
dai::TProb::container_type
std::vector< T > container_type
Type of data structure used for storing the values.
Definition: prob.h:197
dai::log
Real log(Real x)
Returns logarithm of x.
Definition: util.h:113
dai::TProb::exp
this_type exp() const
Returns pointwise exponent.
Definition: prob.h:449
dai::TProb::TProb
TProb(TIterator begin, TIterator end, size_t sizeHint)
Construct vector from a range.
Definition: prob.h:226
dai::Prob
TProb< Real > Prob
Represents a vector with entries of type dai::Real.
Definition: prob.h:766
dai::fo_exp
Function object that takes the exponent.
Definition: prob.h:52
dai::fo_KL
Function object useful for calculating the KL distance.
Definition: prob.h:124
dai::fo_min
Function object that returns the minimum of two values.
Definition: prob.h:167
dai::TProb::divided_by
this_type divided_by(const this_type &q) const
Pointwise division by q, where division by 0 yields +Inf.
Definition: prob.h:694
dai::TProb::takeAbs
this_type & takeAbs()
Applies absolute value pointwise.
Definition: prob.h:509
dai::TProb::pwUnaryOp
this_type & pwUnaryOp(unaryOp op)
Applies unary operation op pointwise.
Definition: prob.h:491
dai::TProb::iterator
container_type::iterator iterator
Iterator over the elements.
Definition: prob.h:245
dai::fo_inv0::operator()
T operator()(const T &x) const
Returns (x == 0 ? 0 : (1 / x))
Definition: prob.h:93
dai::TProb::pwUnaryTr
this_type pwUnaryTr(unaryOp op) const
Returns the result of applying operation op pointwise on *this.
Definition: prob.h:435
dai::TProb::log
this_type log(bool zero=false) const
Returns pointwise logarithm.
Definition: prob.h:454
dai::TProb::set
void set(size_t i, T val)
Sets i 'th entry to val.
Definition: prob.h:293
dai::TProb::maxAbs
T maxAbs() const
Returns maximum absolute value of all entries.
Definition: prob.h:366
dai::fo_inv::operator()
T operator()(const T &x) const
Returns 1 / x.
Definition: prob.h:84
dai::TProb::hasNaNs
bool hasNaNs() const
Returns true if one or more entries are NaN.
Definition: prob.h:369
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::TProb::hasNegatives
bool hasNegatives() const
Returns true if one or more entries are negative.
Definition: prob.h:380
dai::abs
T abs(const T &t)
Returns absolute value of t.
Definition: util.h:155
dai::TProb::abs
this_type abs() const
Returns pointwise absolute value.
Definition: prob.h:446
dai::TProb::operator^
this_type operator^(T x) const
Returns *this raised to the power x.
Definition: prob.h:605
dai::TProb::max
T max() const
Returns maximum value of all entries.
Definition: prob.h:354
dai::TProb::operator+
this_type operator+(T x) const
Returns sum of *this and scalar x.
Definition: prob.h:593
dai::TProb::argmax
std::pair< size_t, T > argmax() const
Returns a pair consisting of the index of the maximum value and the maximum value itself...
Definition: prob.h:385
dai::TProb::pwBinaryOp
this_type & pwBinaryOp(const this_type &q, binaryOp op)
Applies binary operation pointwise on two vectors.
Definition: prob.h:615
dai::TProb::randomize
this_type & randomize()
Draws all entries i.i.d. from a uniform distribution on [0,1)
Definition: prob.h:497
dai::TProb::const_reverse_iterator
container_type::const_reverse_iterator const_reverse_iterator
Constant reverse iterator over the elements.
Definition: prob.h:247
dai::TProb
Represents a vector with entries of type T.
Definition: prob.h:194
dai::fo_max
Function object that returns the maximum of two values.
Definition: prob.h:158
dai::TProb::rend
reverse_iterator rend()
Returns reverse iterator that points beyond the first element.
Definition: prob.h:269
dai::fo_min::operator()
T operator()(const T &x, const T &y) const
Returns (x > y ? y : x)
Definition: prob.h:169
dai::TProb::sum
T sum() const
Returns sum of all entries.
Definition: prob.h:360
dai::TProb::dist
T dist(const TProb< T > &p, const TProb< T > &q, ProbDistType dt)
Returns distance between p and q, measured using distance measure dt.
Definition: prob.h:716
dai::fo_pow
Function object that returns x to the power y.
Definition: prob.h:146
dai::isnan
bool isnan(Real x)
Returns true if argument is NAN (Not A Number)
Definition: util.cpp:44
dai::fo_log::operator()
T operator()(const T &x) const
Returns log(x)
Definition: prob.h:63
dai::fo_abs
Function object that takes the absolute value.
Definition: prob.h:40
dai::fo_exp::operator()
T operator()(const T &x) const
Returns exp(x)
Definition: prob.h:54
dai::TProb::toString
std::string toString() const
Formats a TProb as a string.
Definition: prob.h:425
dai::TProb::end
const_iterator end() const
Returns constant iterator that points beyond the last element.
Definition: prob.h:261
dai::TProb::p
const container_type & p() const
Returns a const reference to the wrapped container.
Definition: prob.h:302
dai::fo_abs::operator()
T operator()(const T &x) const
Returns abs(x)
Definition: prob.h:42
dai::TProb::operator^=
this_type & operator^=(T x)
Raises entries to the power x.
Definition: prob.h:582
dai::fo_divides0
Function object similar to std::divides(), but different in that dividing by zero results in zero...
Definition: prob.h:112
dai::TProb::operator<
bool operator<(const this_type &q) const
Lexicographical comparison.
Definition: prob.h:412
dai::TProb::innerProduct
T innerProduct(const this_type &q, T init, binOp1 binaryOp1, binOp2 binaryOp2) const
Performs a generalized inner product, similar to std::inner_product.
Definition: prob.h:705
dai::fo_pow::operator()
T operator()(const T &x, const T &y) const
Returns (x ^ y)
Definition: prob.h:148
dai::fo_divides0::operator()
T operator()(const T &x, const T &y) const
Returns (y == 0 ? 0 : (x / y))
Definition: prob.h:114
dai::TProb::operator/=
this_type & operator/=(T x)
Divides each entry by scalar x, where division by 0 yields 0.
Definition: prob.h:574
dai::TProb::normalize
T normalize(ProbNormType norm=dai::NORMPROB)
Normalizes vector using the specified norm.
Definition: prob.h:527
dai::TProb::setUniform
this_type & setUniform()
Sets all entries to where n is the length of the vector.
Definition: prob.h:503
dai::TProb::reverse_iterator
container_type::reverse_iterator reverse_iterator
Reverse iterator over the elements.
Definition: prob.h:249
dai::TProb::operator+=
this_type & operator+=(T x)
Adds scalar x to each entry.
Definition: prob.h:550
dai::TProb::TProb
TProb(size_t n)
Construct uniform probability distribution over n outcomes (i.e., a vector of length n with each entr...
Definition: prob.h:213
exceptions.h
Defines the Exception class and macros for throwing exceptions and doing assertions.
dai::TProb::const_iterator
container_type::const_iterator const_iterator
Constant iterator over the elements.
Definition: prob.h:243
dai::fo_Hellinger
Function object useful for calculating the Hellinger distance.
Definition: prob.h:136
util.h
Defines general utility functions and adds an abstraction layer for platform-dependent functionality...
dai::TProb::min
TProb< T > min(const TProb< T > &a, const TProb< T > &b)
Returns the pointwise minimum of a and b.
Definition: prob.h:751
dai::fo_absdiff
Function object that returns the absolute difference of x and y.
Definition: prob.h:176
dai::TProb::accumulateSum
T accumulateSum(T init, unOp op) const
Accumulate all values (similar to std::accumulate) by summing.
Definition: prob.h:322
dai::fo_inv
Function object that takes the inverse.
Definition: prob.h:82
dai::log0
Real log0(Real x)
Returns logarithm of x, or 0 if x == 0.
Definition: util.h:118
dai::TProb::operator*
this_type operator*(T x) const
Returns product of *this with scalar x.
Definition: prob.h:599
dai::TProb::begin
const_iterator begin() const
Returns constant iterator that points to the first element.
Definition: prob.h:256
dai::fo_inv0
Function object that takes the inverse, except that 1/0 is defined to be 0.
Definition: prob.h:91
dai::fo_Hellinger::operator()
T operator()(const T &p, const T &q) const
Returns (sqrt(p) - sqrt(q))^2.
Definition: prob.h:138
dai::fo_absdiff::operator()
T operator()(const T &x, const T &y) const
Returns abs( x - y )
Definition: prob.h:178
dai::TProb::operator[]
T operator[](size_t i) const
Returns a copy of the i 'th entry.
Definition: prob.h:308
dai::TProb::sumAbs
T sumAbs() const
Return sum of absolute value of all entries.
Definition: prob.h:363
dai::TProb::_p
container_type _p
The data structure that stores the values.
Definition: prob.h:204
dai::TProb::size
size_t size() const
Returns length of the vector (i.e., the number of entries)
Definition: prob.h:311
dai::TProb::divide
this_type & divide(const this_type &q)
Pointwise division by q, where division by 0 yields +Inf.
Definition: prob.h:646
dai::TProb::takeLog
this_type & takeLog(bool zero=false)
Applies logarithm pointwise.
Definition: prob.h:517
dai::TProb::operator==
bool operator==(const this_type &q) const
Comparison.
Definition: prob.h:418
dai::fo_log0
Function object that takes the logarithm, except that log(0) is defined to be 0.
Definition: prob.h:70
dai::fo_plog0p::operator()
T operator()(const T &p) const
Returns p * log0(p)
Definition: prob.h:105
dai::TProb::end
iterator end()
Returns iterator that points beyond the last element.
Definition: prob.h:259
dai::TProb::max
TProb< T > max(const TProb< T > &a, const TProb< T > &b)
Returns the pointwise maximum of a and b.
Definition: prob.h:760
dai::TProb::min
T min() const
Returns minimum value of all entries.
Definition: prob.h:357
dai::TProb::operator-
this_type operator-() const
Returns negative of *this.
Definition: prob.h:443
dai::TProb::operator/
this_type operator/(T x) const
Returns quotient of *this and scalar x, where division by 0 yields 0.
Definition: prob.h:602
dai::TProb::operator-=
this_type & operator-=(T x)
Subtracts scalar x from each entry.
Definition: prob.h:558
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::TProb::inverse
this_type inverse(bool zero=true) const
Returns pointwise inverse.
Definition: prob.h:464
dai::TProb::rbegin
reverse_iterator rbegin()
Returns reverse iterator that points to the last element.
Definition: prob.h:264
dai::TProb::draw
size_t draw()
Returns a random index, according to the (normalized) distribution described by *this.
Definition: prob.h:398
dai::TProb::rend
const_reverse_iterator rend() const
Returns constant reverse iterator that points beyond the first element.
Definition: prob.h:271
DAI_DEBASSERT
#define DAI_DEBASSERT(x)
Assertion mechanism similar to DAI_ASSERT which is only active if DAI_DEBUG is defined.
Definition: exceptions.h:65
dai::fo_log0::operator()
T operator()(const T &x) const
Returns (x == 0 ? 0 : log(x))
Definition: prob.h:72
dai::TProb::operator*=
this_type & operator*=(T x)
Multiplies each entry with scalar x.
Definition: prob.h:566
dai::TProb::rbegin
const_reverse_iterator rbegin() const
Returns constant reverse iterator that points to the last element.
Definition: prob.h:266
dai::fo_id
Function object that returns the value itself.
Definition: prob.h:31
dai::rnd_uniform
Real rnd_uniform()
Returns a real number, distributed uniformly on [0,1)
Definition: util.cpp:87
dai::TProb::p
container_type & p()
Returns a reference to the wrapped container.
Definition: prob.h:305
dai::fo_KL::operator()
T operator()(const T &p, const T &q) const
Returns (p == 0 ? 0 : (p * (log(p) - log(q))))
Definition: prob.h:126
dai::TProb::begin
iterator begin()
Returns iterator that points to the first element.
Definition: prob.h:254
dai::TProb::this_type
TProb< T > this_type
Shorthand.
Definition: prob.h:200
dai::exp
Real exp(Real x)
Returns exponent of x.
Definition: util.h:123
dai::TProb::entropy
T entropy() const
Returns the Shannon entropy of *this, .
Definition: prob.h:351
dai::TProb::takeExp
this_type & takeExp()
Applies exponent pointwise.
Definition: prob.h:512
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/doc_8h.html0000644000175000017500000001042212552201363015731 0ustar jorismjorism libDAI: include/dai/doc.h File Reference
doc.h File Reference

Contains additional doxygen documentation. More...

Go to the source code of this file.

Detailed Description

Contains additional doxygen documentation.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/daialg_8h.html0000644000175000017500000002521112552201363016407 0ustar jorismjorism libDAI: include/dai/daialg.h File Reference
Classes | Namespaces | Typedefs | Functions
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/cobwebgraph.h>
#include <dai/properties.h>

Go to the source code of this file.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

Typedefs

typedef DAIAlg< FactorGraph > dai::DAIAlgFG
 Base class for inference algorithms that operate on a FactorGraph. More...
 
typedef DAIAlg< RegionGraph > dai::DAIAlgRG
 Base class for inference algorithms that operate on a RegionGraph. More...
 
typedef DAIAlg< CobwebGraph > dai::DAIAlgCG
 Base class for GLC that operates on CobwebGraph. More...
 

Functions

Factor dai::calcMarginal (const InfAlg &obj, const VarSet &vs, bool reInit)
 Calculates the marginal probability distribution for vs using inference algorithm obj. More...
 
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. More...
 
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. More...
 

Detailed Description

Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/bbp_8h.html0000644000175000017500000001621212552201363015732 0ustar jorismjorism libDAI: include/dai/bbp.h File Reference
Classes | Namespaces | Functions
bbp.h File Reference

Defines class BBP, which implements Back-Belief-Propagation. More...

#include <dai/dai_config.h>
#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.

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...
 

Namespaces

 dai
 Namespace for libDAI.
 

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. More...
 

Detailed Description

Defines class BBP, which implements Back-Belief-Propagation.

Todo:
Clean up code
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1Evidence.html0000644000175000017500000005746112552201365020473 0ustar jorismjorism libDAI: dai::Evidence Class Reference
Public Types | Public Member Functions | Private Member Functions | Private Attributes | List of all members
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>

Public Types

typedef std::map< Var, size_t > Observation
 Stores joint state of a set of variables. More...
 

Public Member Functions

 Evidence ()
 Default constructor. More...
 
 Evidence (std::vector< Observation > &samples)
 Construct from samples. More...
 
void addEvidenceTabFile (std::istream &is, FactorGraph &fg)
 Read in tabular data from a stream and add the read samples to *this. More...
 
size_t nrSamples () const
 Returns number of stored samples. More...
 

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. More...
 

Private Attributes

std::vector< Observation > _samples
 Each sample is an observed joint state of some variables. More...
 

Iterator interface

typedef std::vector< Observation >::iterator iterator
 Iterator over the samples. More...
 
typedef std::vector< Observation >::const_iterator const_iterator
 Constant iterator over the samples. More...
 
iterator begin ()
 Returns iterator that points to the first sample. More...
 
const_iterator begin () const
 Returns constant iterator that points to the first sample. More...
 
iterator end ()
 Returns iterator that points beyond the last sample. More...
 
const_iterator end () const
 Returns constant iterator that points beyond the last sample. More...
 

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
isInput stream in .tab file format, describing joint observations of variables in fg
fgFactor graph describing the corresponding variables
See also
Evidence (.tab) file format
Exceptions
INVALID_EVIDENCE_FILEif 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_31.png0000644000175000017500000000041012552200222015640 0ustar jorismjorism‰PNG  IHDR׳ÏZ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïwIDATxí‹ Ã0DŸ?œ&eÿm‹ÓV*‰:‚Å;Y`8¼À_Ê^m‚>Ç’¢x €„ûvOÆó- 7Äu ¨±H×>–Ëû¨…˜„§™6ô“ž:mŽuÛ×—~LÎVʼnêÕ[ú†œ} ýθò6 ä'šÙIEND®B`‚libDAI-0.3.2/doc/html/form_98.png0000644000175000017500000000102412552200241015660 0ustar jorismjorism‰PNG  IHDRTò´ ‚0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïƒIDATxí]ËnÄ 0ï%›ÿÿÛŽÁäÑvs®*¡Xë0xlΞà¿›[Ž§ÉõÀí9ÀËò¥$2”¢`.%ŒÝr„‚õHUàfy€ï6w_ƒEöY¡œÁ7Ò+­3Ä'K𞿯¾“¢OnÑÇ +á/Ä÷²öˆ0{ž V¨x¤ÊÂר~Ú£kUÜæéÂÕÜûª­ß]›ég‚ß4°5óAÚCØYMPˆÂlìÍ ,Ö¬Išd·,ÞD/™¾ß‚ž6ÒFStä¤ê}"íÄÔNI£àÉø^¤Zš6ôHbf9Öq° ‡¤Q5RØ^/FªaUNÒÀÛTR"MŠÍr(©ž™“¢ „õˆÞ~yÁÓŸ¤Žõ¨¤ Ê\µÕÐZ¤ìR[v4u{Ħl‰ð¸­—~­Ms±Hl9©kíÇÌkæj¿}T¶86’ðÃ*on]Ú©!éu‚àn!= ÕFb‘ÊÖéå‡B5ìñƒsÉÙ_ŠJ0tÔ Y_ üb+þ€} ]ž”¨IEND®B`‚libDAI-0.3.2/doc/html/build.html0000644000175000017500000002477212552201363015701 0ustar jorismjorism 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)
  • GMP library (or the Windows port called MPIR, for 64 bits builds MPIR 2.5.0 or higher is needed)
  • 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 libgmp-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 gmp 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)
  • GMP or MPIR library (for 64-bits builds, MPIR 2.5.0 or higher is needed)
  • 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 GMP or MPIR under Windows

Information about how to build GPR or MPIR under Windows can be found on the internet. The user has to update Makefile.WINDOWS in order to link with the GPR/MPIR libraries. Note that for 64-bit builds, MPIR 2.5.0 or higher is needed.

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1FBP-members.html0000644000175000017500000006055712552201365021010 0ustar jorismjorism libDAI: Member List
dai::FBP Member List

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

_edge2lutdai::BPprotected
_edgesdai::BPprotected
_itersdai::BPprotected
_lutdai::BPprotected
_maxdiffdai::BPprotected
_oldBeliefsFdai::BPprotected
_oldBeliefsVdai::BPprotected
_sentMessagesdai::BPprotected
_updateSeqdai::BPprotected
_weightdai::FBPprotected
backupFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
backupFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
belief(const Var &v) const dai::BPinlinevirtual
belief(const VarSet &vs) const dai::BPvirtual
beliefF(size_t I) const dai::BPvirtual
beliefs() const dai::BPvirtual
beliefV(size_t i) const dai::BPvirtual
BP()dai::BPinline
BP(const FactorGraph &fg, const PropertySet &opts)dai::BPinline
BP(const BP &x)dai::BPinline
calcBeliefF(size_t I, Prob &p) const dai::FBPinlineprotectedvirtual
calcBeliefV(size_t i, Prob &p) const dai::BPprotectedvirtual
calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const dai::FBPprotectedvirtual
calcNewMessage(size_t i, size_t _I)dai::FBPprotectedvirtual
clamp(size_t i, size_t x, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
clearSentMessages()dai::BPinline
clone() const dai::FBPinlinevirtual
construct(const FactorGraph &fg, const PropertySet &opts) const dai::FBPinlinevirtual
construct()dai::FBPprotectedvirtual
DAIAlg()dai::DAIAlg< GRM >inline
DAIAlg(const GRM &grm)dai::DAIAlg< GRM >inline
FBP()dai::FBPinline
FBP(const FactorGraph &fg, const PropertySet &opts)dai::FBPinline
fg()dai::DAIAlg< GRM >inlinevirtual
fg() const dai::DAIAlg< GRM >inlinevirtual
findMaximum() const dai::BPinlinevirtual
findMaxResidual(size_t &i, size_t &_I)dai::BPprotected
getProperties() const dai::BPvirtual
getSentMessages() const dai::BPinline
identify() const dai::InfAlginlinevirtual
ind_t typedefdai::BPprotected
index(size_t i, size_t _I) const dai::BPinlineprotected
index(size_t i, size_t _I)dai::BPinlineprotected
init()dai::BPvirtual
init(const VarSet &ns)dai::BPvirtual
Iterations() const dai::BPinlinevirtual
logZ() const dai::FBPvirtual
LutType typedefdai::BPprotected
makeCavity(size_t i, bool backup=false)dai::DAIAlg< GRM >inlinevirtual
makeRegionCavity(std::vector< size_t > facInds, bool backup)dai::DAIAlg< GRM >inlinevirtual
maxDiff() const dai::BPinlinevirtual
message(size_t i, size_t _I) const dai::BPinlineprotected
message(size_t i, size_t _I)dai::BPinlineprotected
name() const dai::FBPinlinevirtual
newMessage(size_t i, size_t _I) const dai::BPinlineprotected
newMessage(size_t i, size_t _I)dai::BPinlineprotected
operator=(const BP &x)dai::BPinline
printProperties() const dai::BPvirtual
props (defined in dai::BP)dai::BP
recordSentMessagesdai::BP
residual(size_t i, size_t _I) const dai::BPinlineprotected
residual(size_t i, size_t _I)dai::BPinlineprotected
restoreFactor(size_t I)dai::DAIAlg< GRM >inlinevirtual
restoreFactors(const VarSet &vs)dai::DAIAlg< GRM >inlinevirtual
restoreFactors()dai::DAIAlg< GRM >inline
run()dai::BPvirtual
setMaxIter(size_t maxiter)dai::BPinlinevirtual
setProperties(const PropertySet &opts)dai::BPvirtual
setWeight(size_t I, Real c)dai::FBPinline
setWeights(const std::vector< Real > &c)dai::FBPinline
updateMessage(size_t i, size_t _I)dai::BPprotected
updateResidual(size_t i, size_t _I, Real r)dai::BPprotected
Weight(size_t I) const dai::FBPinline
Weights() const dai::FBPinline
~InfAlg()dai::InfAlginlinevirtual
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1CobwebGraph_1_1Connection.html0000644000175000017500000003201612552201364024017 0ustar jorismjorism libDAI: dai::CobwebGraph::Connection Struct Reference
Public Attributes | List of all members
dai::CobwebGraph::Connection Struct Reference

The information in connection between two regions. More...

#include <dai/cobwebgraph.h>

Public Attributes

size_t my
 Index of the first region (p) More...
 
size_t his
 Index of the second region (q) More...
 
size_t iter
 Index of this connection in the connections of the first region. More...
 
size_t dual
 Index of the mirror of this connection in the connections of the second region. (reference of this message in _outM) More...
 
Factor msg
 The message sent from region q (his) to p (my) More...
 
std::vector< size_t > varinds
 "Index" of variables in the message More...
 
Factor newmsg
 Used as a temporary factor only. More...
 
std::vector< size_t > fc
 Index of factors in common. More...
 
std::vector< VarSet > subregions
 Regions rho that are descendents of msg from q to p in p's msg-region graph (not used in partitioning case) More...
 

Detailed Description

The information in connection between two regions.

Member Data Documentation

size_t dai::CobwebGraph::Connection::my

Index of the first region (p)

size_t dai::CobwebGraph::Connection::his

Index of the second region (q)

size_t dai::CobwebGraph::Connection::iter

Index of this connection in the connections of the first region.

size_t dai::CobwebGraph::Connection::dual

Index of the mirror of this connection in the connections of the second region. (reference of this message in _outM)

Factor dai::CobwebGraph::Connection::msg

The message sent from region q (his) to p (my)

std::vector<size_t> dai::CobwebGraph::Connection::varinds

"Index" of variables in the message

Factor dai::CobwebGraph::Connection::newmsg

Used as a temporary factor only.

Todo:
Remove CobwebGraph::Connection::newmsg
std::vector<size_t> dai::CobwebGraph::Connection::fc

Index of factors in common.

std::vector<VarSet> dai::CobwebGraph::Connection::subregions

Regions rho that are descendents of msg from q to p in p's msg-region graph (not used in partitioning case)

The documentation for this struct was generated from the following file:
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_25.png0000644000175000017500000000135712552200221015655 0ustar jorismjorism‰PNG  IHDRp"°x­…0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï^IDATxíÙ’›0EV„XôÿmH†‰3¡Ry¹oÀã¾½÷+Àþœs'åµrÎð Öl;>_^KŽ/\‹x"êMè·zUÇàD}r|<èÏ=¡F1ý*·ÙêixÃ|VX“xKè—ƒgRÀ(bî¥Ée,πܺÉÕ€ˆšîÑÅ–Teû]©Å4^˜rC¸5·ü˜‰zšå1N{÷8‰áäo… óÁ¸å\-M7wíF¬-Sm­¡8}ØN¸öPfÓdübÙœ7OŠdSê³=ÕÌrFí!¼ùM¨Sá‰Å+T _ô¶ÄXîÓ‰pN|À5Tx­¸Â2sI&L¶ŽB“ZMU¹ž‘}¯škÂ5kÌ/RH…ÐÑ•D_"X M°JM…Ñ~QPׄYIÑž73/1‡ç¬…Cç™ø:ú±Ÿ÷a¾í1qäJªÝr=Z€“¤¨œqA(V“C±gÛåÐ×¢üKo|€;ÈsK|1Keé-mKƇÑfJü>Ûbû81äv<}0¼_+í>iãÙŽŸÉXXkhák°º|5‡¾‡%„0J¨ÝÒCdo€' „8ÉùýxøÀ· ¬JΤår³½ž€Ï“V;³§íê­ýbôüô6³¾Î¤ÔœrVµZ†½ ð·˜Â'Ö·jL=ØçFpîQÊ%wvìµ–¸¼g·”ºô‰x ÆåÕåt›£äeé|°íóPñJø8•­mqÓ!š\'jsÏÕ ÐE÷Ò¨ž™yž¦/€ÿ¿{Ë*ÂÃ[OIEND®B`‚libDAI-0.3.2/doc/html/splitbar.png0000644000175000017500000000047212552201363016231 0ustar jorismjorism‰PNG  IHDRM¸¿IDATxíÝ¡JCa‡ñç(˜ ëƒ%±Ø4 b±È˜Í¶3˜v^Á±˜…ãó–ŽELƒõ…¥•³ ,ÿb;íç{Ã/¼ðÞÀaYÕ¯åóøq:¼º¹›\òIIIIIIIIIIIIIIIIII-Òçl¹›«õ抢è_t/Ï»ã£ÑíYQVõðêäíã÷´×ùY¬Úÿµ§¦ivók¾_íåýÛ£I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$I@$ýC[Vì=ü[„fÆIEND®B`‚libDAI-0.3.2/doc/html/functions_func_w.html0000644000175000017500000001257512552201370020147 0ustar jorismjorism libDAI: Class Members - Functions
 

- w -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/example_varset_8cpp-example.html0000644000175000017500000002730012552201363022172 0ustar jorismjorism 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/
*
* Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
*
* Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
*/
#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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/functions_~.html0000644000175000017500000001266612552201370017144 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- ~ -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1ExactInf_1_1Properties-members.html0000644000175000017500000000575612552201365025036 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_66.png0000644000175000017500000000055512552200232015663 0ustar jorismjorism‰PNG  IHDR4#S ò0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÜIDATxí[ŽÃ EæMÒ°ÿÝŽPÑNGåkþ¬É1×7,àß2¤gÀ^UŒF®àSJJú0#U³L¿Ò¶‚9,;WÁ½Ù|õ¯âw j:§W;<ê0möµI4Õ·Å9¿Y!7 öÈ%ß+£^¶êÃ;dÍœº»q2V7µœ¾–ÑÙä[Í{ÿì‚.Ŷs‹'†OòŠà§A‹Òçå±ÓøRÍ©äÜäÉÕþ° 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/daialg_8h_source.html0000644000175000017500000015504612552201363020001 0ustar jorismjorism libDAI: include/dai/daialg.h Source File
daialg.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_daialg_h
14 #define __defined_libdai_daialg_h
15 
16 
17 #include <string>
18 #include <iostream>
19 #include <vector>
20 #include <dai/factorgraph.h>
21 #include <dai/regiongraph.h>
22 #include <dai/cobwebgraph.h>
23 #include <dai/properties.h>
24 
25 
26 namespace dai {
27 
28 
30 
35 class InfAlg {
36  public:
38 
39  virtual ~InfAlg() {}
41 
43  virtual InfAlg* clone() const = 0;
44 
46 
49  virtual InfAlg* construct( const FactorGraph &fg, const PropertySet &opts ) const = 0;
51 
53 
54  virtual std::string name() const = 0;
56 
58  virtual std::string identify() const {
59  return name() + printProperties();
60  }
61 
63  virtual FactorGraph &fg() = 0;
64 
66  virtual const FactorGraph &fg() const = 0;
68 
70 
71 
74  virtual void init() = 0;
75 
77 
81  virtual void init( const VarSet &vs ) = 0;
82 
84 
86  virtual Real run() = 0;
87 
89 
91  virtual Factor belief( const Var &v ) const { return belief( VarSet(v) ); }
92 
94 
98  virtual Factor belief( const VarSet &vs ) const = 0;
99 
101 
104  virtual Factor beliefV( size_t i ) const { return belief( fg().var(i) ); }
105 
107 
110  virtual Factor beliefF( size_t I ) const { return belief( fg().factor(I).vars() ); }
111 
113 
115  virtual std::vector<Factor> beliefs() const = 0;
116 
118 
121  virtual Real logZ() const = 0;
122 
124 
127  virtual std::vector<size_t> findMaximum() const { DAI_THROW(NOT_IMPLEMENTED); }
128 
130 
132  virtual Real maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); };
133 
135 
137  virtual size_t Iterations() const { DAI_THROW(NOT_IMPLEMENTED); };
138 
140 
142  virtual void setMaxIter( size_t /*maxiter*/ ) { DAI_THROW(NOT_IMPLEMENTED); }
144 
146 
147 
150  virtual void clamp( size_t i, size_t x, bool backup = false ) = 0;
151 
153 
155  virtual void makeCavity( size_t i, bool backup = false ) = 0;
156 
158 
160  virtual void makeRegionCavity( std::vector<size_t> facInds, bool backup = false ) = 0;
162 
164 
165 
168  virtual void backupFactor( size_t I ) = 0;
170 
172  virtual void backupFactors( const VarSet &vs ) = 0;
173 
175  virtual void restoreFactor( size_t I ) = 0;
177  virtual void restoreFactors( const VarSet &vs ) = 0;
179 
181 
182 
186  virtual void setProperties( const PropertySet &opts ) = 0;
188  virtual PropertySet getProperties() const = 0;
190  virtual std::string printProperties() const = 0;
192 };
193 
194 
196 
206 template <class GRM>
207 class DAIAlg : public InfAlg, public GRM {
208  public:
210 
211  DAIAlg() : InfAlg(), GRM() {}
213 
215  DAIAlg( const GRM &grm ) : InfAlg(), GRM(grm) {}
217 
219 
220  FactorGraph &fg() { return (FactorGraph &)(*this); }
222 
224  const FactorGraph &fg() const { return (const FactorGraph &)(*this); }
226 
228 
229 
232  void clamp( size_t i, size_t x, bool backup = false ) { GRM::clamp( i, x, backup ); }
233 
235 
237  void makeCavity( size_t i, bool backup = false ) { GRM::makeCavity( i, backup ); }
238 
240 
242  void makeRegionCavity( std::vector<size_t> facInds, bool backup ){ GRM::makeRegionCavity( facInds, backup ); }
244 
246 
247  void backupFactor( size_t I ) { GRM::backupFactor( I ); }
250  void backupFactors( const VarSet &vs ) { GRM::backupFactors( vs ); }
251 
253  void restoreFactor( size_t I ) { GRM::restoreFactor( I ); }
255  void restoreFactors( const VarSet &vs ) { GRM::restoreFactors( vs ); }
257  void restoreFactors() { GRM::restoreFactors(); }
259 };
260 
261 
263 typedef DAIAlg<FactorGraph> DAIAlgFG;
264 
266 typedef DAIAlg<RegionGraph> DAIAlgRG;
267 
269 typedef DAIAlg<CobwebGraph> DAIAlgCG;
270 
271 
273 
279 Factor calcMarginal( const InfAlg& obj, const VarSet& vs, bool reInit );
280 
281 
283 
294 std::vector<Factor> calcPairBeliefs( const InfAlg& obj, const VarSet& vs, bool reInit, bool accurate=false );
295 
296 
298 
300 std::vector<size_t> findMaximum( const InfAlg& obj );
301 
302 
303 } // end of namespace dai
304 
305 
306 #endif
dai::DAIAlg::restoreFactors
void restoreFactors()
Restore all factors from their backup copies.
Definition: daialg.h:257
dai::InfAlg::backupFactors
virtual void backupFactors(const VarSet &vs)=0
Make backup copies of all factors involving the variables in vs.
dai::calcPairBeliefs
vector< Factor > calcPairBeliefs(const InfAlg &obj, const VarSet &vs, bool reInit, bool accurate)
Calculates beliefs for all pairs of variables in vs using inference algorithm obj.
Definition: daialg.cpp:76
dai::InfAlg::~InfAlg
virtual ~InfAlg()
Virtual destructor (needed because this class contains virtual functions)
Definition: daialg.h:40
dai::InfAlg::belief
virtual Factor belief(const Var &v) const
Returns the (approximate) marginal probability distribution of a variable.
Definition: daialg.h:91
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::DAIAlg::backupFactor
void backupFactor(size_t I)
Make a backup copy of factor I.
Definition: daialg.h:248
dai::InfAlg::printProperties
virtual std::string printProperties() const =0
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::InfAlg::setProperties
virtual void setProperties(const PropertySet &opts)=0
Set parameters of this inference algorithm.
dai::InfAlg::init
virtual void init()=0
Initializes all data structures of the approximate inference algorithm.
dai::InfAlg::identify
virtual std::string identify() const
Identifies itself for logging purposes.
Definition: daialg.h:58
dai::InfAlg::restoreFactors
virtual void restoreFactors(const VarSet &vs)=0
Restore the factors involving the variables in vs from their backup copies.
dai::InfAlg::clone
virtual InfAlg * clone() const =0
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
dai::InfAlg::restoreFactor
virtual void restoreFactor(size_t I)=0
Restore factor I from its backup copy.
dai::InfAlg::beliefV
virtual Factor beliefV(size_t i) const
Returns the (approximate) marginal probability distribution of the variable with index i...
Definition: daialg.h:104
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
cobwebgraph.h
Defines class CobwebGraph, which implements a type of region graph used by GLC.
dai::DAIAlg::makeRegionCavity
void makeRegionCavity(std::vector< size_t > facInds, bool backup)
Sets all factors indicated by facInds to one.
Definition: daialg.h:242
dai::InfAlg::beliefs
virtual std::vector< Factor > beliefs() const =0
Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm...
dai::DAIAlg::backupFactors
void backupFactors(const VarSet &vs)
Make backup copies of all factors involving the variables in vs.
Definition: daialg.h:250
dai::DAIAlg::restoreFactors
void restoreFactors(const VarSet &vs)
Restore the factors involving the variables in vs from their backup copies.
Definition: daialg.h:255
dai::DAIAlgCG
DAIAlg< CobwebGraph > DAIAlgCG
Base class for GLC that operates on CobwebGraph.
Definition: daialg.h:269
dai::findMaximum
std::vector< size_t > findMaximum(const InfAlg &obj)
Calculates the joint state of all variables that has maximum probability, according to the inference ...
Definition: daialg.cpp:211
dai::InfAlg::getProperties
virtual PropertySet getProperties() const =0
Returns parameters of this inference algorithm converted into a PropertySet.
dai::InfAlg::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: daialg.h:132
dai::DAIAlg::fg
const FactorGraph & fg() const
Returns constant reference to underlying FactorGraph.
Definition: daialg.h:224
dai::InfAlg::logZ
virtual Real logZ() const =0
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
dai::InfAlg::setMaxIter
virtual void setMaxIter(size_t)
Sets maximum number of iterations (one iteration passes over the complete factorgraph).
Definition: daialg.h:142
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::InfAlg::name
virtual std::string name() const =0
Returns the name of the algorithm.
regiongraph.h
Defines classes Region, FRegion and RegionGraph, which implement a particular subclass of region grap...
dai::DAIAlgRG
DAIAlg< RegionGraph > DAIAlgRG
Base class for inference algorithms that operate on a RegionGraph.
Definition: daialg.h:266
dai::InfAlg
InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI...
Definition: daialg.h:35
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::DAIAlgFG
DAIAlg< FactorGraph > DAIAlgFG
Base class for inference algorithms that operate on a FactorGraph.
Definition: daialg.h:263
dai::InfAlg::construct
virtual InfAlg * construct(const FactorGraph &fg, const PropertySet &opts) const =0
Returns a pointer to a newly constructed inference algorithm.
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
dai::calcMarginal
Factor calcMarginal(const InfAlg &obj, const VarSet &vs, bool reInit)
Calculates the marginal probability distribution for vs using inference algorithm obj...
Definition: daialg.cpp:20
dai::DAIAlg::DAIAlg
DAIAlg(const GRM &grm)
Construct from GRM.
Definition: daialg.h:215
dai::DAIAlg::restoreFactor
void restoreFactor(size_t I)
Restore factor I from its backup copy.
Definition: daialg.h:253
dai::InfAlg::makeRegionCavity
virtual void makeRegionCavity(std::vector< size_t > facInds, bool backup=false)=0
Sets all factors indicated by facInds to one.
dai::InfAlg::beliefF
virtual Factor beliefF(size_t I) const
Returns the (approximate) marginal probability distribution of the variables on which factor I depend...
Definition: daialg.h:110
dai::InfAlg::run
virtual Real run()=0
Runs the approximate inference algorithm.
dai::DAIAlg::DAIAlg
DAIAlg()
Default constructor.
Definition: daialg.h:212
dai::DAIAlg
Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)...
Definition: daialg.h:207
dai::DAIAlg::clamp
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 )
Definition: daialg.h:232
dai::InfAlg::clamp
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 )
dai::InfAlg::makeCavity
virtual void makeCavity(size_t i, bool backup=false)=0
Sets all factors interacting with variable with index i to one.
dai::InfAlg::backupFactor
virtual void backupFactor(size_t I)=0
Make a backup copy of factor I.
dai::InfAlg::fg
virtual FactorGraph & fg()=0
Returns reference to underlying FactorGraph.
dai::DAIAlg::makeCavity
void makeCavity(size_t i, bool backup=false)
Sets all factors interacting with variable with index i to one.
Definition: daialg.h:237
dai::InfAlg::findMaximum
virtual std::vector< size_t > findMaximum() const
Calculates the joint state of all variables that has maximum probability.
Definition: daialg.h:127
dai::InfAlg::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: daialg.h:137
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__max-members.html0000644000175000017500000000563512552201365022224 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/doc.png0000644000175000017500000000135212552201363015154 0ustar jorismjorism‰PNG  IHDRÚ}\ˆ±IDATxíMOS[…Ÿžsúa?-XZ(PD4‚ AWbu`b 77wäHFÆCËÔÂÿà/`vo„ˆAPòq‹P @ ­ûÝè980 îà¤+»§Ýy×^ïZï9SW¹\83g‰3'°Nâçl¹¸_b¯p ïåûÆVÜÖ¡€Ÿ×"¬Ö†X€d]Ðà3“ÉÃÄÌ™xŸ ßMàœ[<çSPkvc—hÈ'…™˜^Åm™hØ7 `Û™¦ èÀåráq›‘œ¾!daeKŸþÆÕ˜:Ì*³_דâèi?I–eP*B7Ÿ¿åô!¹Ýgr6Ër6oKbëþãðôrI”ËTˆüªŒ¨xóö=›ù¢&‰(e+ßóÄkýÇ`ëÁÜb.“¸ÐW×w0¥°jÑzN™¬|©WEãµ¢a¯6[öX†AkÓù*/œ¨‰€ÉY­ ÿV’§–u²jÂ>1W *½·°PGŽzÿ¨/Eg{ ŸÇâaoŠÁVú:è¿™¤1$ôR§W,–ªà¨@ŠË56¾ÀÔÜ-¾,mê¸Î/æè¹– òr5¥T*S(Vf8ö9u’ Õ£w›ùóa=Í<{Ò¡UŒ÷r¯+ÉådDÏF$è°…£é¿`zþ»ÎúöN‘µÜ®0Q3£~_^Ëóâ¯N=ˆvpTà±LžT}ˆîkq†Òm<¼ÎÓ?Zh¿X£ï_þÝ¥[)ƒ `gêÃa_Ô*äÔ2`'=õ´Fÿ2EâÁPú ÷»›l=8‹Wv°%THqÉ¿<"¤ïG¾ÆxH{#ÆÖ«aÔJÕÞ‡—m‹„ çñKsÿàñVŠØ¡°·MâÒ^ TÁ– Ý›r¥ß½ømüÿ_™?ªWÄ°÷#uIEND®B`‚libDAI-0.3.2/doc/html/namespacemembers_vars.html0000644000175000017500000000531612552201370021133 0ustar jorismjorism libDAI: Namespace Members
 
  • _normal_dist : dai
  • FULL_TYPE : dai
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_70.png0000644000175000017500000000042112552200233015647 0ustar jorismjorism‰PNG  IHDR,c>0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï€IDATxíÛ! D-[.¢üÿßJ «É*ƧIé@¾à?–èOØXmnÑ ¶ö0Ü,š¥ÍÅk8 ]Kš­âÒÙpk~ò°@øê1ˆÍ!¨+ìÂFM¬smÃý¨E€‹5ç\ÛXd`oçÐáõð®àZð+?MÆrœ’IEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1JTree_1_1Properties.html0000644000175000017500000003547712552201366022722 0ustar jorismjorism libDAI: dai::JTree::Properties Struct Reference
Public Member Functions | Public Attributes | List of all members
dai::JTree::Properties Struct Reference

Parameters for JTree. More...

#include <dai/jtree.h>

Public Member Functions

 DAI_ENUM (UpdateType, HUGIN, SHSH)
 Enumeration of possible JTree updates. More...
 
 DAI_ENUM (InfType, SUMPROD, MAXPROD)
 Enumeration of inference variants. More...
 
 DAI_ENUM (HeuristicType, MINNEIGHBORS, MINWEIGHT, MINFILL, WEIGHTEDMINFILL)
 Enumeration of elimination cost functions used for constructing the junction tree. More...
 

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr) More...
 
UpdateType updates
 Type of updates. More...
 
InfType inference
 Type of inference. More...
 
HeuristicType heuristic
 Heuristic to use for constructing the junction tree. More...
 
size_t maxmem
 Maximum memory to use in bytes (0 means unlimited) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__abs.html0000644000175000017500000001147712552201365020555 0ustar jorismjorism libDAI: dai::fo_abs< T > Struct Template Reference
Public Member Functions | List of all members
dai::fo_abs< T > Struct Template Reference

Function object that takes the absolute value. More...

#include <dai/prob.h>

Inherits unary_function< T, T >.

Public Member Functions

T operator() (const T &x) const
 Returns abs(x) More...
 

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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_29.png0000644000175000017500000000030612552200222015653 0ustar jorismjorism‰PNG  IHDR h@ ¯0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï5IDATxíë !Ãê£È‰øí¿­ üq;Jºƒ¤'…þ¨è ˆ|:]Å? 4m¦}Z"M²WGd3IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1PropertySet.png0000644000175000017500000000142412552201367021057 0ustar jorismjorism‰PNG  IHDRóPû ³MPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2£IDATxíí’« DU©ê÷ã›(€@¢7.P±wEp˜CÃøçœL8IJ“Y’ú×d–¤þ•1ûÆ‘uX*¡$µ‡,wõ7ÎÅÛµ%©¢70¿öBšScü©x'™‹»¬ð]áµåvÍbYü{;r\Ç&üc¦º†óiú±iš‡ãÅ!`xZÜ1ÙIñ²wkð-˜Ix—ãnXœÚ6·%ÍòÛ3¿/—)†6ô–¹ƒµ%Ÿ5?é´…¤@›ùh¼­Æl]Jövƒyͤ°¿íØ=ݾi2[o\Ó“ñÌαÍøŒÚÖ°tÇìv|ÍçFŽ»ž²5/3ã…ÿå¥møì¤xÕ™+ç9ϱvàb¹Ùg~6^RºóšÔ<Ï~o‡ºí${-§pùëv,>å:Ž­æ`§&Šg>±>ÇðíyR·%é¹^\V~ž`%)Õ±x’ÔÒW™Ï"‹'IM}“ùÈSIæ:ÿ¦$å:È,I^“Y’ú×d–¤þugvι±ðÝӀ̷ÛxÐ2ß‘‡ƒ‘`Ûº½Öè|¥n›#¿Ï~ì•ë6À‹ªÍûù|.Çü…t®Æül~Ç ðMf€þ5™ú×Ù9çÆÒ?÷…Š¢Æ¾ ÝIEND®B`‚libDAI-0.3.2/doc/html/functions_func_l.html0000644000175000017500000001525412552201370020131 0ustar jorismjorism libDAI: Class Members - Functions
 

- l -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_85.png0000644000175000017500000000036112552200236015663 0ustar jorismjorism‰PNG  IHDR H×]q0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï`IDATxíË Ã0 CŸþµ“Ôûo[§ñ!í) |"$€œà9陕ÀM® kܤ0þðýÜ&꘭Jzáx¼õµióïsDoH-ØgÛU*2mž+¿f;%ýŠüò‘Äê´…MIEND®B`‚libDAI-0.3.2/doc/html/structdai_1_1CBP_1_1Properties.html0000644000175000017500000007537212552201364022311 0ustar jorismjorism libDAI: dai::CBP::Properties Struct Reference
Public Types | Public Member Functions | Public Attributes | List of all members
dai::CBP::Properties Struct Reference

Parameters for CBP. More...

#include <dai/cbp.h>

Public Types

typedef BP::Properties::UpdateType UpdateType
 Enumeration of possible update schedules. More...
 

Public Member Functions

 DAI_ENUM (RecurseType, REC_FIXED, REC_LOGZ, REC_BDIFF)
 Enumeration of possible methods for deciding when to stop recursing. More...
 
 DAI_ENUM (ChooseMethodType, CHOOSE_RANDOM, CHOOSE_MAXENT, CHOOSE_BBP, CHOOSE_BP_L1, CHOOSE_BP_CFN)
 Enumeration of possible heuristics for choosing clamping variable. More...
 
 DAI_ENUM (ClampType, CLAMP_VAR, CLAMP_FACTOR)
 Enumeration of possible clampings: variables or factors. More...
 
void set (const PropertySet &opts)
 Set members from PropertySet. More...
 
PropertySet get () const
 Get members into PropertySet. More...
 
std::string toString () const
 Convert to a string which can be parsed as a PropertySet. More...
 

Public Attributes

size_t verbose
 Verbosity (amount of output sent to stderr) More...
 
Real tol
 Tolerance for BP convergence test. More...
 
UpdateType updates
 Update style for BP. More...
 
size_t maxiter
 Maximum number of iterations for BP. More...
 
Real rec_tol
 Tolerance used for controlling recursion depth (recurse is REC_LOGZ or REC_BDIFF) More...
 
size_t max_levels
 Maximum number of levels of recursion (recurse is REC_FIXED) More...
 
Real min_max_adj
 If choose==CHOOSE_BBP and maximum adjoint is less than this value, don't recurse. More...
 
ChooseMethodType choose
 Heuristic for choosing clamping variable. More...
 
RecurseType recursion
 Method for deciding when to stop recursing. More...
 
ClampType clamp
 Whether to clamp variables or factors. More...
 
PropertySet bbp_props
 Properties to pass to BBP. More...
 
BBPCostFunction bbp_cfn
 Cost function to use for BBP. More...
 
size_t rand_seed
 Random seed. More...
 
std::string clamp_outfile
 If non-empty, write clamping choices to this file. More...
 

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_PROPERTYif a Property key is not recognized
NOT_ALL_PROPERTIES_SPECIFIEDif 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_19.png0000644000175000017500000000033512552200217015660 0ustar jorismjorism‰PNG  IHDR e^|è0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïLIDATxíí À D_­¥B´ì¿m5Dcu‚K¸Ü#|¬ðSÙM²ùDM£Õ-tCòkÿ.;= ç¢jq d­›Ìeu-¥®¯C_i(SÔÝ]ˆIEND®B`‚libDAI-0.3.2/doc/html/bp_8h_source.html0000644000175000017500000021656512552201363017165 0ustar jorismjorism libDAI: include/dai/bp.h Source File
bp.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
12 
13 
14 #ifndef __defined_libdai_bp_h
15 #define __defined_libdai_bp_h
16 
17 
18 #include <dai/dai_config.h>
19 #ifdef DAI_WITH_BP
20 
21 
22 #include <string>
23 #include <dai/daialg.h>
24 #include <dai/factorgraph.h>
25 #include <dai/properties.h>
26 #include <dai/enum.h>
27 
28 
29 namespace dai {
30 
31 
33 
63 class BP : public DAIAlgFG {
64  protected:
66  typedef std::vector<size_t> ind_t;
68  struct EdgeProp {
70  ind_t index;
72  Prob message;
74  Prob newMessage;
76  Real residual;
77  };
79  std::vector<std::vector<EdgeProp> > _edges;
81  typedef std::multimap<Real, std::pair<size_t, size_t> > LutType;
83  std::vector<std::vector<LutType::iterator> > _edge2lut;
85  LutType _lut;
87  Real _maxdiff;
89  size_t _iters;
91  std::vector<std::pair<size_t, size_t> > _sentMessages;
93  std::vector<Factor> _oldBeliefsV;
95  std::vector<Factor> _oldBeliefsF;
97  std::vector<Edge> _updateSeq;
98 
99  public:
101  struct Properties {
103 
109  DAI_ENUM(UpdateType,SEQFIX,SEQRND,SEQMAX,PARALL);
110 
112 
116  DAI_ENUM(InfType,SUMPROD,MAXPROD);
117 
119  size_t verbose;
120 
122  size_t maxiter;
123 
125  double maxtime;
126 
128  Real tol;
129 
131  bool logdomain;
132 
134  Real damping;
135 
137  UpdateType updates;
138 
140  InfType inference;
141  } props;
142 
144  bool recordSentMessages;
145 
146  public:
148 
149  BP() : DAIAlgFG(), _edges(), _edge2lut(), _lut(), _maxdiff(0.0), _iters(0U), _sentMessages(), _oldBeliefsV(), _oldBeliefsF(), _updateSeq(), props(), recordSentMessages(false) {}
151 
153 
156  BP( const FactorGraph & fg, const PropertySet &opts ) : DAIAlgFG(fg), _edges(), _maxdiff(0.0), _iters(0U), _sentMessages(), _oldBeliefsV(), _oldBeliefsF(), _updateSeq(), props(), recordSentMessages(false) {
157  setProperties( opts );
158  construct();
159  }
160 
162  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) {
163  for( LutType::iterator l = _lut.begin(); l != _lut.end(); ++l )
164  _edge2lut[l->second.first][l->second.second] = l;
165  }
166 
168  BP& operator=( const BP &x ) {
169  if( this != &x ) {
170  DAIAlgFG::operator=( x );
171  _edges = x._edges;
172  _lut = x._lut;
173  for( LutType::iterator l = _lut.begin(); l != _lut.end(); ++l )
174  _edge2lut[l->second.first][l->second.second] = l;
175  _maxdiff = x._maxdiff;
176  _iters = x._iters;
177  _sentMessages = x._sentMessages;
178  _oldBeliefsV = x._oldBeliefsV;
179  _oldBeliefsF = x._oldBeliefsF;
180  _updateSeq = x._updateSeq;
181  props = x.props;
182  recordSentMessages = x.recordSentMessages;
183  }
184  return *this;
185  }
187 
189 
190  virtual BP* clone() const { return new BP(*this); }
191  virtual BP* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new BP( fg, opts ); }
192  virtual std::string name() const { return "BP"; }
193  virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); }
194  virtual Factor belief( const VarSet &vs ) const;
195  virtual Factor beliefV( size_t i ) const;
196  virtual Factor beliefF( size_t I ) const;
197  virtual std::vector<Factor> beliefs() const;
198  virtual Real logZ() const;
201  std::vector<size_t> findMaximum() const { return dai::findMaximum( *this ); }
202  virtual void init();
203  virtual void init( const VarSet &ns );
204  virtual Real run();
205  virtual Real maxDiff() const { return _maxdiff; }
206  virtual size_t Iterations() const { return _iters; }
207  virtual void setMaxIter( size_t maxiter ) { props.maxiter = maxiter; }
208  virtual void setProperties( const PropertySet &opts );
209  virtual PropertySet getProperties() const;
210  virtual std::string printProperties() const;
212 
214 
215  const std::vector<std::pair<size_t, size_t> >& getSentMessages() const {
217  return _sentMessages;
218  }
219 
221  void clearSentMessages() { _sentMessages.clear(); }
223 
224  protected:
226  const Prob & message(size_t i, size_t _I) const { return _edges[i][_I].message; }
228  Prob & message(size_t i, size_t _I) { return _edges[i][_I].message; }
230  const Prob & newMessage(size_t i, size_t _I) const { return _edges[i][_I].newMessage; }
232  Prob & newMessage(size_t i, size_t _I) { return _edges[i][_I].newMessage; }
234  const ind_t & index(size_t i, size_t _I) const { return _edges[i][_I].index; }
236  ind_t & index(size_t i, size_t _I) { return _edges[i][_I].index; }
238  const Real & residual(size_t i, size_t _I) const { return _edges[i][_I].residual; }
240  Real & residual(size_t i, size_t _I) { return _edges[i][_I].residual; }
241 
243 
246  virtual Prob calcIncomingMessageProduct( size_t I, bool without_i, size_t i ) const;
248  virtual void calcNewMessage( size_t i, size_t _I );
250  void updateMessage( size_t i, size_t _I );
252  void updateResidual( size_t i, size_t _I, Real r );
254  void findMaxResidual( size_t &i, size_t &_I );
256  virtual void calcBeliefV( size_t i, Prob &p ) const;
258  virtual void calcBeliefF( size_t I, Prob &p ) const {
259  p = calcIncomingMessageProduct( I, false, 0 );
260  }
261 
263  virtual void construct();
264 };
265 
266 
267 } // end of namespace dai
268 
269 
270 #endif
271 
272 
273 #endif
dai::BP::Properties::damping
Real damping
Damping constant (0.0 means no damping, 1.0 is maximum damping)
Definition: bp.h:134
dai::BP::Properties::maxiter
size_t maxiter
Maximum number of iterations.
Definition: bp.h:122
dai::BP::init
virtual void init()
Initializes all data structures of the approximate inference algorithm.
Definition: bp.cpp:145
dai::BP::Properties::inference
InfType inference
Inference variant.
Definition: bp.h:140
dai::BP::clearSentMessages
void clearSentMessages()
Clears history of which messages have been updated.
Definition: bp.h:221
dai::BP::construct
virtual void construct()
Helper function for constructors.
Definition: bp.cpp:94
dai::BP::construct
virtual BP * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: bp.h:191
dai::BP::Properties::maxtime
double maxtime
Maximum time (in seconds)
Definition: bp.h:125
dai::BP::_oldBeliefsV
std::vector< Factor > _oldBeliefsV
Stores variable beliefs of previous iteration.
Definition: bp.h:93
dai::BP::_updateSeq
std::vector< Edge > _updateSeq
Stores the update schedule.
Definition: bp.h:97
dai::BP::operator=
BP & operator=(const BP &x)
Assignment operator.
Definition: bp.h:168
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::BP::index
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.
Definition: bp.h:236
dai::BP::_maxdiff
Real _maxdiff
Maximum difference between variable beliefs encountered so far.
Definition: bp.h:87
dai::BP::updateMessage
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)...
Definition: bp.cpp:449
dai::BP::EdgeProp
Type used for storing edge properties.
Definition: bp.h:68
dai::BP::calcBeliefV
virtual void calcBeliefV(size_t i, Prob &p) const
Calculates unnormalized belief of variable i.
Definition: bp.cpp:359
dai::BP::Properties::updates
UpdateType updates
Message update schedule.
Definition: bp.h:137
dai::BP::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: bp.cpp:79
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::BP::Properties::tol
Real tol
Tolerance for convergence test.
Definition: bp.h:128
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::BP::message
Prob & message(size_t i, size_t _I)
Returns reference to message from the _I 'th neighbor of variable i to variable i.
Definition: bp.h:228
dai::BP::_edge2lut
std::vector< std::vector< LutType::iterator > > _edge2lut
Lookup table (only used for maximum-residual BP)
Definition: bp.h:83
dai::BP::calcIncomingMessageProduct
virtual Prob calcIncomingMessageProduct(size_t I, bool without_i, size_t i) const
Calculate the product of factor I and the incoming messages.
Definition: bp.cpp:168
dai::BP::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: bp.cpp:65
dai::BP::beliefF
virtual Factor beliefF(size_t I) const
Returns the (approximate) marginal probability distribution of the variables on which factor I depend...
Definition: bp.cpp:383
dai::BP::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: bp.h:205
dai::BP::ind_t
std::vector< size_t > ind_t
Type used for index cache.
Definition: bp.h:66
dai::BP::_sentMessages
std::vector< std::pair< size_t, size_t > > _sentMessages
The history of message updates (only recorded if recordSentMessages is true)
Definition: bp.h:91
dai::BP::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: bp.h:119
dai::BP::setMaxIter
virtual void setMaxIter(size_t maxiter)
Sets maximum number of iterations (one iteration passes over the complete factorgraph).
Definition: bp.h:207
dai::BP::recordSentMessages
bool recordSentMessages
Specifies whether the history of message updates should be recorded.
Definition: bp.h:144
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::BP::Properties
Parameters for BP.
Definition: bp.h:101
dai::BP::_iters
size_t _iters
Number of iterations needed.
Definition: bp.h:89
dai::BP::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: bp.h:192
dai::BP::updateResidual
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 ...
Definition: bp.cpp:467
dai::BP::LutType
std::multimap< Real, std::pair< size_t, size_t > > LutType
Type of lookup table (only used for maximum-residual BP)
Definition: bp.h:81
dai::BP::setProperties
virtual void setProperties(const PropertySet &opts)
Definition: bp.cpp:33
dai::findMaximum
std::vector< size_t > findMaximum(const InfAlg &obj)
Calculates the joint state of all variables that has maximum probability, according to the inference ...
Definition: daialg.cpp:211
dai::BP::message
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...
Definition: bp.h:226
dai::BP::BP
BP()
Default constructor.
Definition: bp.h:150
dai::BP::residual
Real & residual(size_t i, size_t _I)
Returns reference to residual for the edge between variable i and its _I 'th neighbor.
Definition: bp.h:240
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::BP::residual
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...
Definition: bp.h:238
dai::BP
Approximate inference algorithm "(Loopy) Belief Propagation".
Definition: bp.h:63
dai::BP::BP
BP(const FactorGraph &fg, const PropertySet &opts)
Construct from FactorGraph fg and PropertySet opts.
Definition: bp.h:156
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::BP::beliefV
virtual Factor beliefV(size_t i) const
Returns the (approximate) marginal probability distribution of the variable with index i...
Definition: bp.cpp:369
dai::BP::beliefs
virtual std::vector< Factor > beliefs() const
Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm...
Definition: bp.cpp:397
dai::BP::calcBeliefF
virtual void calcBeliefF(size_t I, Prob &p) const
Calculates unnormalized belief of factor I.
Definition: bp.h:258
dai::BP::run
virtual Real run()
Runs the approximate inference algorithm.
Definition: bp.cpp:265
dai::BP::EdgeProp::residual
Real residual
Residual for this edge.
Definition: bp.h:76
dai::BP::EdgeProp::message
Prob message
Old message living on this edge.
Definition: bp.h:72
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::BP::_edges
std::vector< std::vector< EdgeProp > > _edges
Stores all edge properties.
Definition: bp.h:79
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
dai::BP::belief
virtual Factor belief(const Var &v) const
Returns the (approximate) marginal probability distribution of a variable.
Definition: bp.h:193
dai::BP::EdgeProp::index
ind_t index
Index cached for this edge.
Definition: bp.h:70
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai::BP::BP
BP(const BP &x)
Copy constructor.
Definition: bp.h:162
dai::BP::_oldBeliefsF
std::vector< Factor > _oldBeliefsF
Stores factor beliefs of previous iteration.
Definition: bp.h:95
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::BP::findMaximum
std::vector< size_t > findMaximum() const
Definition: bp.h:201
dai::BP::newMessage
Prob & newMessage(size_t i, size_t _I)
Returns reference to updated message from the _I 'th neighbor of variable i to variable i...
Definition: bp.h:232
dai::BP::findMaxResidual
void findMaxResidual(size_t &i, size_t &_I)
Finds the edge which has the maximum residual (difference between new and old message) ...
Definition: bp.cpp:159
dai::BP::Properties::DAI_ENUM
DAI_ENUM(UpdateType, SEQFIX, SEQRND, SEQMAX, PARALL)
Enumeration of possible update schedules.
dai::BP::newMessage
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...
Definition: bp.h:230
dai::BP::Properties::logdomain
bool logdomain
Whether updates should be done in logarithmic domain or not.
Definition: bp.h:131
dai::BP::calcNewMessage
virtual void calcNewMessage(size_t i, size_t _I)
Calculate the updated message from the _I 'th neighbor of variable i to variable i.
Definition: bp.cpp:211
dai::DAIAlg
Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)...
Definition: daialg.h:207
dai::BP::clone
virtual BP * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: bp.h:190
dai::BP::EdgeProp::newMessage
Prob newMessage
New message living on this edge.
Definition: bp.h:74
dai::BP::_lut
LutType _lut
Lookup table (only used for maximum-residual BP)
Definition: bp.h:85
dai::BP::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: bp.h:206
dai::BP::getSentMessages
const std::vector< std::pair< size_t, size_t > > & getSentMessages() const
Returns history of which messages have been updated.
Definition: bp.h:216
dai::BP::index
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...
Definition: bp.h:234
dai::BP::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: bp.cpp:424
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_114.png0000644000175000017500000000070212552200245015733 0ustar jorismjorism‰PNG  IHDR^¨^8@0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï1IDATxíÙŽ­ E—2:Ðüÿß6”¢xúÜ×›w%,jÒg€ÿ@ÀHÖü“œëh?  ×f’Qñy‡‰/»ËúÔ‰ WGBƒ‹ïRíº ñÍvÞÕâaè%ø·üQ?¶ïü1J0‚?pw½¤PÒ??ñ^©µ88ãÜ·,ç·;}é´¶:ÌCy_]®­µû°Z³¼¬]I®VÉgw©®vùȉ_Αߕä$?³û~ñ¹[Y_º!e òUí:½°1Y€Fo$ø˜¯Ý¬8” "s%ªl]ZcxNùè$glΤàu6“M¡kMŠAæžÝ¶ë{€¡Ž¾—„o :•M !á¯9p?ßãwIóÑQg™ÆóǪý)Œå à;™ë«ûç|À½ëIEND®B`‚libDAI-0.3.2/doc/html/exactinf_8h_source.html0000644000175000017500000010354712552201363020360 0ustar jorismjorism libDAI: include/dai/exactinf.h Source File
exactinf.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_exactinf_h
14 #define __defined_libdai_exactinf_h
15 
16 
17 #include <dai/daialg.h>
18 #include <dai/properties.h>
19 #include <dai/factorgraph.h>
20 #include <dai/enum.h>
21 
22 
23 namespace dai {
24 
25 
27 
32 class ExactInf : public DAIAlgFG {
33  public:
35  struct Properties {
37  size_t verbose;
38  } props;
39 
40  private:
42  std::vector<Factor> _beliefsV;
44  std::vector<Factor> _beliefsF;
46  Real _logZ;
47 
48  public:
50 
51  ExactInf() : DAIAlgFG(), props(), _beliefsV(), _beliefsF(), _logZ(0) {}
53 
55 
58  ExactInf( const FactorGraph &fg, const PropertySet &opts ) : DAIAlgFG(fg), props(), _beliefsV(), _beliefsF(), _logZ() {
59  setProperties( opts );
60  construct();
61  }
63 
65 
66  virtual ExactInf* clone() const { return new ExactInf(*this); }
67  virtual ExactInf* construct( const FactorGraph &fg, const PropertySet &opts ) const { return new ExactInf( fg, opts ); }
68  virtual std::string name() const { return "EXACT"; }
69  virtual Factor belief( const Var &v ) const { return beliefV( findVar( v ) ); }
70  virtual Factor belief( const VarSet &vs ) const;
71  virtual Factor beliefV( size_t i ) const { return _beliefsV[i]; }
72  virtual Factor beliefF( size_t I ) const { return _beliefsF[I]; }
73  virtual std::vector<Factor> beliefs() const;
74  virtual Real logZ() const { return _logZ; }
77  std::vector<size_t> findMaximum() const;
78  virtual void init();
79  virtual void init( const VarSet &/*ns*/ ) {}
80  virtual Real run();
81  virtual Real maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; }
82  virtual size_t Iterations() const { DAI_THROW(NOT_IMPLEMENTED); return 0; }
83  virtual void setProperties( const PropertySet &opts );
84  virtual PropertySet getProperties() const;
85  virtual std::string printProperties() const;
87 
89 
90 
93  Factor calcMarginal( const VarSet &vs ) const;
95 
96  private:
98  void construct();
99 };
100 
101 
102 } // end of namespace dai
103 
104 
105 #endif
dai::ExactInf::construct
virtual ExactInf * construct(const FactorGraph &fg, const PropertySet &opts) const
Returns a pointer to a newly constructed inference algorithm.
Definition: exactinf.h:67
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::ExactInf::belief
virtual Factor belief(const Var &v) const
Returns the (approximate) marginal probability distribution of a variable.
Definition: exactinf.h:69
dai::ExactInf::logZ
virtual Real logZ() const
Returns the logarithm of the (approximated) partition sum (normalizing constant of the factor graph)...
Definition: exactinf.h:74
dai::ExactInf::beliefs
virtual std::vector< Factor > beliefs() const
Returns all beliefs (approximate marginal probability distributions) calculated by the algorithm...
Definition: exactinf.cpp:114
dai::ExactInf::clone
virtual ExactInf * clone() const
Returns a pointer to a new, cloned copy of *this (i.e., virtual copy constructor) ...
Definition: exactinf.h:66
dai::DAIAlg::fg
FactorGraph & fg()
Returns reference to underlying FactorGraph.
Definition: daialg.h:221
dai::ExactInf::findMaximum
std::vector< size_t > findMaximum() const
Definition: exactinf.cpp:95
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::ExactInf::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: exactinf.h:37
dai::ExactInf::setProperties
virtual void setProperties(const PropertySet &opts)
Set parameters of this inference algorithm.
Definition: exactinf.cpp:19
dai::ExactInf::getProperties
virtual PropertySet getProperties() const
Returns parameters of this inference algorithm converted into a PropertySet.
Definition: exactinf.cpp:27
dai::ExactInf::maxDiff
virtual Real maxDiff() const
Returns maximum difference between single variable beliefs in the last iteration. ...
Definition: exactinf.h:81
dai::ExactInf::construct
void construct()
Helper function for constructors.
Definition: exactinf.cpp:42
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::VarSet
Represents a set of variables.
Definition: varset.h:94
dai::ExactInf::beliefV
virtual Factor beliefV(size_t i) const
Returns the (approximate) marginal probability distribution of the variable with index i...
Definition: exactinf.h:71
dai::ExactInf::_logZ
Real _logZ
Logarithm of partition sum.
Definition: exactinf.h:46
dai::ExactInf::_beliefsF
std::vector< Factor > _beliefsF
All factor variable marginals.
Definition: exactinf.h:44
dai::ExactInf::Iterations
virtual size_t Iterations() const
Returns number of iterations done (one iteration passes over the complete factorgraph).
Definition: exactinf.h:82
dai::ExactInf::init
virtual void init()
Initializes all data structures of the approximate inference algorithm.
Definition: exactinf.cpp:57
dai::ExactInf::ExactInf
ExactInf(const FactorGraph &fg, const PropertySet &opts)
Construct from FactorGraph fg and PropertySet opts.
Definition: exactinf.h:58
dai::ExactInf::run
virtual Real run()
Runs the approximate inference algorithm.
Definition: exactinf.cpp:65
properties.h
Defines the Property and PropertySet classes, which are mainly used for managing parameters of infere...
dai::ExactInf::printProperties
virtual std::string printProperties() const
Returns parameters of this inference algorithm formatted as a string in the format "[key1=val1...
Definition: exactinf.cpp:34
dai::ExactInf::Properties
Parameters for ExactInf.
Definition: exactinf.h:35
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::ExactInf
Exact inference algorithm using brute force enumeration (mainly useful for testing purposes) ...
Definition: exactinf.h:32
dai::ExactInf::init
virtual void init(const VarSet &)
Initializes all data structures corresponding to some set of variables.
Definition: exactinf.h:79
dai::ExactInf::ExactInf
ExactInf()
Default constructor.
Definition: exactinf.h:52
dai::ExactInf::calcMarginal
Factor calcMarginal(const VarSet &vs) const
Calculates marginal probability distribution for variables vs.
Definition: exactinf.cpp:87
dai::ExactInf::_beliefsV
std::vector< Factor > _beliefsV
All single variable marginals.
Definition: exactinf.h:42
dai::Var
Represents a discrete random variable.
Definition: var.h:37
dai
Namespace for libDAI.
Definition: alldai.cpp:16
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai::DAIAlg
Combines the abstract base class InfAlg with a graphical model (e.g., a FactorGraph or RegionGraph)...
Definition: daialg.h:207
dai::ExactInf::beliefF
virtual Factor beliefF(size_t I) const
Returns the (approximate) marginal probability distribution of the variables on which factor I depend...
Definition: exactinf.h:72
dai::ExactInf::name
virtual std::string name() const
Returns the name of the algorithm.
Definition: exactinf.h:68
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_14.png0000644000175000017500000000152112552200216015650 0ustar jorismjorism‰PNG  IHDR"Q?z‘0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïÀIDATxíérä „?Nã“÷ÛÂ3±7NMm&µŠvˆä–hI~ðß"¦”šÞ Ÿrž£Ž)çÞ¼Cê"åà_âp×€3¤ƒÏºŽù!bÆ|‚ÐJbê}Š×oû+Bg|ü8†n(bjMÔáîhÌôÍ?Y<0åÑÆßœ9Ÿ);ÂåãÞâC8vÙ¬¤"áÁ·á"@§|Š7,Ó‰/ðiéæÂOH V’³y}a猺d²Ub,4þ®|B0!^ŠR"¬'u5:—Š¡E¶›!{;•s®~MÈÕ±í?ãÓeçºQœ(&ˆ¤©ýà¬Ë6·²•o)½•ãQÊr¨?°Tz¹þ]ùÈ©:þŸiX7èQG*rÂè³òq¸r À1ËÏ‚zÅ;ŸÃ“º0¹þÝøóŒÏîøjknr|ÓOåØ Í`×Ã;Ÿ®†£XQgŸ§†ï×±}â„Ïá’š°…–ÇÕ+®|,‹“w>„è°±“}å´rQ)o|ܼ+© Î’$¹—W÷õl{M¯ÍDêã‚·„jXù¸Åfk¥Æ‰ó‹é™µ [\W3ªYM|!¼.%¢!z¡_^·ó]LlU¹˜0ÑÙ(TLýDOôòº lŠ>…¥Æ_£¢µPïhg«˜¯ÕÃ3]ðcý‘›”PÉÃëֹĬÜWSé5ÕìY}7ù4&LùŸØYbð¬rº:š†çŸsû¹½<ó“~z˜ØÄþÐO÷ä-¯D‹º0À=Ly-$㶸 ºµ\»¸ˆö–,C³/Þˆ½V?m€_ü4Xth/Óà;PŠ©íR¦%ùššüx R§Bv…KSA¾¾ë¥½µÍ¿T<^ƒëƒôï”´fcµ¼ ‹t¿žJ'xì$Mr\s,_ö\€ïA¡bRß¿Ø~>þ —Ù IEND®B`‚libDAI-0.3.2/doc/html/classdai_1_1SharedParameters.html0000644000175000017500000010702612552201370022170 0ustar jorismjorism libDAI: dai::SharedParameters Class Reference
Public Types | Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
dai::SharedParameters Class Reference

Represents a single factor or set of factors whose parameters should be estimated. More...

#include <dai/emalg.h>

Public Types

typedef size_t FactorIndex
 Convenience label for an index of a factor in a FactorGraph. More...
 
typedef std::map< FactorIndex, std::vector< Var > > FactorOrientations
 Convenience label for a grouping of factor orientations. More...
 

Public Member Functions

 SharedParameters (const FactorOrientations &varorders, ParameterEstimation *estimation, bool ownPE=false)
 Constructor. More...
 
 SharedParameters (std::istream &is, const FactorGraph &fg)
 Construct a SharedParameters object from an input stream is and a factor graph fg. More...
 
 SharedParameters (const SharedParameters &sp)
 Copy constructor. More...
 
 ~SharedParameters ()
 Destructor. More...
 
void collectExpectations (InfAlg &alg)
 Collect the expected values (beliefs) according to alg. More...
 
const Prob & currentExpectations () const
 Return the current accumulated expectations. More...
 
ParameterEstimation & getPEst () const
 
void setParameters (FactorGraph &fg)
 Estimate and set the shared parameters. More...
 
const FactorOrientations & getFactorOrientations () const
 Return a reference to the vector of factor orientations. More...
 
void clear ()
 Reset the current expectations. More...
 

Private Member Functions

void setPermsAndVarSetsFromVarOrders ()
 Initializes _varsets and _perms from _varorders and checks whether their state spaces correspond with _estimation.probSize() More...
 

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. More...
 

Private Attributes

std::map< FactorIndex, VarSet > _varsets
 Maps factor indices to the corresponding VarSets. More...
 
std::map< FactorIndex, Permute > _perms
 Maps factor indices to the corresponding Permute objects that permute the canonical ordering into the desired ordering. More...
 
FactorOrientations _varorders
 Maps factor indices to the corresponding desired variable orderings. More...
 
ParameterEstimation * _estimation
 Parameter estimation method to be used. More...
 
bool _ownEstimation
 Indicates whether *this gets ownership of _estimation. More...
 
Prob * _expectations
 The accumulated expectations. More...
 

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
varordersall the factor orientations for this parameter
estimationa pointer to the parameter estimation method
ownPEwhether 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_FILEif 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 
)
staticprivate

Calculates the permutation that permutes the canonical ordering into the desired ordering.

Parameters
varOrderDesired ordering of variables
outVSContains 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::collectExpectations ( InfAlg &  alg)

Collect the 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.

const Prob& dai::SharedParameters::currentExpectations ( ) const
inline

Return the current accumulated expectations.

void dai::SharedParameters::setParameters ( FactorGraph &  fg)

Estimate and set the shared parameters.

Based on the expectation 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).

const FactorOrientations& dai::SharedParameters::getFactorOrientations ( ) const
inline

Return a reference to the vector of factor orientations.

This is necessary for determing which variables were used to estimate parameters, and analysis of expectations after an Estimation step has been performed.

void dai::SharedParameters::clear ( )
inline

Reset the current expectations.

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.

Prob* dai::SharedParameters::_expectations
private

The accumulated expectations.

The documentation for this class was generated from the following files:
  • include/dai/emalg.h
  • src/emalg.cpp
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/dai__config_8h_source.html0000644000175000017500000001433212552201363020771 0ustar jorismjorism libDAI: include/dai/dai_config.h Source File
dai_config.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
11 
12 
13 #ifndef __defined_libdai_config_h
14 #define __defined_libdai_config_h
15 
16 
17 #define DAI_WITH_BP
18 #define DAI_WITH_FBP
19 #define DAI_WITH_TRWBP
20 #define DAI_WITH_MF
21 #define DAI_WITH_HAK
22 #define DAI_WITH_LC
23 #define DAI_WITH_TREEEP
24 #define DAI_WITH_JTREE
25 #define DAI_WITH_MR
26 #define DAI_WITH_GIBBS
27 #define DAI_WITH_CBP
28 #define DAI_WITH_DECMAP
29 #define DAI_WITH_GLC
30 
31 
32 #endif
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/form_110.png0000644000175000017500000000340412552200244015730 0ustar jorismjorism‰PNG  IHDR3ŠG¼r0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïsIDATxíý–«* Å(~•÷Û› *¶uZ{<ÞéZ§ËÌX !ÙÙÙùàŸüOVünó[Ýüns=À¥VE€ßnýåŒÀo7 ÀuæG€ßompů Ëå„ñ_¡.Ia.%̾ÁÜ•4±ø ‹5À5Ö|MI#]8!n-ÀwX}a ¯ä&ÀŸXuÝè´×?€?°xÙŒ_$/0^&0ÃWáÒmåsK}ëË ”_’æÏ;óî3dyÜÞÿy3„³»þ»Ùó XŸy½Ð¶è—/ÆÃ'gy.x×üs\ªíêö›س°â²+6Àæ©ãæòæaÃ~ûAŒ+.oÌ¿;¯«S»Ö¬S"‡ÁwŽÎ†ÚEÓ=*`}ìOîáR= ³‹u[Ù³@µÜìîOïñ ?ˆÞ%V8µëéVq±Éè|Ç`›ýÕÞ·ióÃpßÃ¥¸¨$ý P‡aNâ^œvƒxÉ—¢]+œ®§G­×„‹Dað}ݧ>Äd£üYŒ?@Ì°0(¯q©åx­øhbâ^ &;ÓJát‰ÞU¹z¥òª$26ø…{3õëF¾š6ñƒy¤Ý ðÔR»L ôZíšZQÌãûyÿ½Ò?éaÊCÛ£¯E,N·ÑcžÜÖ%+ÁÍn[XŸc¸¤Vx´&ñ4ƒàJqžäe'ˆW¸”ó¸LlZYÞɃ{Šýy?™ƒ¸ÔÛQ¾HåˆhÀt¬]Õ©™BÜ âM\&‰*¯O+‹SswÚ§”¹Û³«”?àR= ÓoÈYm+d··ÜOó½ ÞÁE$cr·$–WV§;mð™µ;¸ \•°˜°?˜ÞµÛ;¸$Öÿ¸²7&>°ÊÅuâ-/+.[˜”ª}˜>Ý8ÊîI6>7[ÇxÓ™¥/Q_>0/S à$k:ýHC,/+ÁïÝw]W>O„ àMž„(Ë ÀΨÀKë.» àOm¸,Úú«p¹õWØÉJðíÌqä†bÈ×ÑcúR`Ξ|‹~ª ÃÖúéž<þ\Pñ5ØáˆÛs†ãœy’ÞÐ*U;È{ùkŸ©élu*sã™""Þ¹ÞOB¡°ù1)KsfÓW7•× tÍh·¸dñf¨·£)¼šN~2\}¨Œz©]QŒ‰0ãL§C¸ŒÀIÖH$f¾½‘¶2R²‚ZLE!¡â¢!æjZ×PŒl—ÔÞ4¯·æž‘KGkÅ…µ‚F›Q\¼^TÁåT-†¡mSIÕF¬èþ©‘œ¹!a:× §æt´¥Eh©0ÀK³>`ûRÕR uªXQ¥0ôN«.†ð†ùSggr– XINê¹”º6mêiùè¤PõºQáhä›ë$C…V0©´SLÍœ®VrVª¹ÕÖ¸9"šÔ¶óÊäVË'ßfº¦Ð›“4?5UÒLM£—£Í1«ƒ6©FÅXY2é—S‚(Uš oôÅžJ—e\—·Åè΄ÉãSÐßSQ½j‚ÖS19ÔGÆ$9j¤{מ5yò©ïäMí.©®²¤<Àúh%õßʬ)Q€7¬Û'ãËùÉU£\™slß–{LùþÔnw\¨†i$óúêìÛ":šìûÝ9>à/ÚÿP €Cö>±þÀ?›>ÿm].z}`¼[IEND®B`‚libDAI-0.3.2/doc/html/functions_a.html0000644000175000017500000001661012552201370017100 0ustar jorismjorism libDAI: Class Members
Here is a list of all documented class members with links to the class documentation for each member:

- a -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/structdai_1_1fo__inv-members.html0000644000175000017500000000561512552201365022231 0ustar jorismjorism 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 by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/open.png0000644000175000017500000000017312552201363015350 0ustar jorismjorism‰PNG  IHDR à‘BIDATxíÝÁ €0 Ð׬ՙ\Àº€39—b!©9{|ðI>$#Àß´ý8/¨ÄØzƒ/Ï>2À[ÎgiU,/¬~¼Ï\ Ä9Ù¸IEND®B`‚libDAI-0.3.2/doc/html/bbp_8h_source.html0000644000175000017500000030465112552201363017321 0ustar jorismjorism libDAI: include/dai/bbp.h Source File
bbp.h
Go to the documentation of this file.
1 /* This file is part of libDAI - http://www.libdai.org/
2  *
3  * Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
4  *
5  * Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
6  */
7 
8 
12 
13 
14 #ifndef ___defined_libdai_bbp_h
15 #define ___defined_libdai_bbp_h
16 
17 
18 #include <dai/dai_config.h>
19 #ifdef DAI_WITH_CBP
20 
21 
22 #include <vector>
23 #include <utility>
24 
25 #include <dai/prob.h>
26 #include <dai/daialg.h>
27 #include <dai/factorgraph.h>
28 #include <dai/enum.h>
29 #include <dai/bp_dual.h>
30 
31 
32 namespace dai {
33 
34 
36 
38 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);
39 
40 
42 class BBPCostFunction : public BBPCostFunctionBase {
43  public:
45  BBPCostFunction() : BBPCostFunctionBase() {}
46 
48  BBPCostFunction( const BBPCostFunctionBase &x ) : BBPCostFunctionBase(x) {}
49 
51  bool needGibbsState() const;
52 
54  Real evaluate( const InfAlg &ia, const std::vector<size_t> *stateP ) const;
55 
57  BBPCostFunction& operator=( const BBPCostFunctionBase &x ) {
58  BBPCostFunctionBase::operator=( x );
59  return *this;
60  }
61 };
62 
63 
65 
67 class BBP {
68  private:
70 
71  BP_dual _bp_dual;
74  const FactorGraph *_fg;
76  const InfAlg *_ia;
78 
80 
81  std::vector<Prob> _adj_psi_V;
84  std::vector<Prob> _adj_psi_F;
86  std::vector<std::vector<Prob> > _adj_n;
88  std::vector<std::vector<Prob> > _adj_m;
90  std::vector<Prob> _adj_b_V;
92  std::vector<Prob> _adj_b_F;
94 
96 
97  std::vector<Prob> _init_adj_psi_V;
100  std::vector<Prob> _init_adj_psi_F;
101 
103  std::vector<std::vector<Prob> > _adj_n_unnorm;
105  std::vector<std::vector<Prob> > _adj_m_unnorm;
107  std::vector<std::vector<Prob> > _new_adj_n;
109  std::vector<std::vector<Prob> > _new_adj_m;
111  std::vector<Prob> _adj_b_V_unnorm;
113  std::vector<Prob> _adj_b_F_unnorm;
114 
116  std::vector<std::vector<Prob > > _Tmsg;
118  std::vector<std::vector<Prob > > _Umsg;
120  std::vector<std::vector<std::vector<Prob > > > _Smsg;
122  std::vector<std::vector<std::vector<Prob > > > _Rmsg;
123 
125  size_t _iters;
127 
129 
130  typedef std::vector<size_t> _ind_t;
133  std::vector<std::vector<_ind_t> > _indices;
135 
137  void RegenerateInds();
139  const _ind_t& _index(size_t i, size_t _I) const { return _indices[i][_I]; }
141 
143 
144  void RegenerateT();
147  void RegenerateU();
149  void RegenerateS();
151  void RegenerateR();
153  void RegenerateInputs();
155 
157  void RegeneratePsiAdjoints();
159 
161  void RegenerateParMessageAdjoints();
163 
167  void RegenerateSeqMessageAdjoints();
169  void Regenerate();
171 
173 
174  Prob & T(size_t i, size_t _I) { return _Tmsg[i][_I]; }
177  const Prob & T(size_t i, size_t _I) const { return _Tmsg[i][_I]; }
179  Prob & U(size_t I, size_t _i) { return _Umsg[I][_i]; }
181  const Prob & U(size_t I, size_t _i) const { return _Umsg[I][_i]; }
183  Prob & S(size_t i, size_t _I, size_t _j) { return _Smsg[i][_I][_j]; }
185  const Prob & S(size_t i, size_t _I, size_t _j) const { return _Smsg[i][_I][_j]; }
187  Prob & R(size_t I, size_t _i, size_t _J) { return _Rmsg[I][_i][_J]; }
189  const Prob & R(size_t I, size_t _i, size_t _J) const { return _Rmsg[I][_i][_J]; }
190 
192  Prob& adj_n(size_t i, size_t _I) { return _adj_n[i][_I]; }
194  const Prob& adj_n(size_t i, size_t _I) const { return _adj_n[i][_I]; }
196  Prob& adj_m(size_t i, size_t _I) { return _adj_m[i][_I]; }
198  const Prob& adj_m(size_t i, size_t _I) const { return _adj_m[i][_I]; }
200 
202 
203 
207  void calcNewN( size_t i, size_t _I );
209 
212  void calcNewM( size_t i, size_t _I );
214  void calcUnnormMsgN( size_t i, size_t _I );
216  void calcUnnormMsgM( size_t i, size_t _I );
218  void upMsgN( size_t i, size_t _I );
220  void upMsgM( size_t i, size_t _I );
222  void doParUpdate();
224 
226 
227  void incrSeqMsgM( size_t i, size_t _I, const Prob& p );
229  // DISABLED BECAUSE IT IS BUGGY:
230  // void updateSeqMsgM( size_t i, size_t _I );
232  void setSeqMsgM( size_t i, size_t _I, const Prob &p );
234  void sendSeqMsgN( size_t i, size_t _I, const Prob &f );
236  void sendSeqMsgM( size_t i, size_t _I );
238 
240 
242  Prob unnormAdjoint( const Prob &w, Real Z_w, const Prob &adj_w );
243 
245  Real getUnMsgMag();
247  void getMsgMags( Real &s, Real &new_s );
249  void getArgmaxMsgM( size_t &i, size_t &_I, Real &mag );
251  Real getMaxMsgM();
252 
254  Real getTotalMsgM();
256  Real getTotalNewMsgM();
258  Real getTotalMsgN();
259 
261  std::vector<Prob> getZeroAdjF( const FactorGraph &fg );
263  std::vector<Prob> getZeroAdjV( const FactorGraph &fg );
264 
265  public:
267 
268 
272  BBP( const InfAlg *ia, const PropertySet &opts ) : _bp_dual(ia), _fg(&(ia->fg())), _ia(ia) {
273  props.set(opts);
274  }
276 
278 
279  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 ) {
281  _adj_b_V = adj_b_V;
282  _adj_b_F = adj_b_F;
283  _init_adj_psi_V = adj_psi_V;
284  _init_adj_psi_F = adj_psi_F;
285  Regenerate();
286  }
287 
289  void init( const std::vector<Prob> &adj_b_V, const std::vector<Prob> &adj_b_F ) {
290  init( adj_b_V, adj_b_F, getZeroAdjV(*_fg), getZeroAdjF(*_fg) );
291  }
292 
294  void init_V( const std::vector<Prob> &adj_b_V ) {
295  init( adj_b_V, getZeroAdjF(*_fg) );
296  }
297 
299  void init_F( const std::vector<Prob> &adj_b_F ) {
300  init( getZeroAdjV(*_fg), adj_b_F );
301  }
302 
304 
308  void initCostFnAdj( const BBPCostFunction &cfn, const std::vector<size_t> *stateP );
310 
312 
313  void run();
316 
318 
319  Prob& adj_psi_V(size_t i) { return _adj_psi_V[i]; }
322  const Prob& adj_psi_V(size_t i) const { return _adj_psi_V[i]; }
324  Prob& adj_psi_F(size_t I) { return _adj_psi_F[I]; }
326  const Prob& adj_psi_F(size_t I) const { return _adj_psi_F[I]; }
328  Prob& adj_b_V(size_t i) { return _adj_b_V[i]; }
330  const Prob& adj_b_V(size_t i) const { return _adj_b_V[i]; }
332  Prob& adj_b_F(size_t I) { return _adj_b_F[I]; }
334  const Prob& adj_b_F(size_t I) const { return _adj_b_F[I]; }
336  size_t Iterations() { return _iters; }
338 
339  public:
341  /* PROPERTIES(props,BBP) {
349  DAI_ENUM(UpdateType,SEQ_FIX,SEQ_MAX,SEQ_BP_REV,SEQ_BP_FWD,PAR);
350 
352  size_t verbose = 0;
353 
355  size_t maxiter;
356 
359  Real tol;
360 
362  Real damping;
363 
365  UpdateType updates;
366 
367  // DISABLED BECAUSE IT IS BUGGY:
368  // bool clean_updates;
369  }
370  */
371 /* {{{ GENERATED CODE: DO NOT EDIT. Created by
372  ./scripts/regenerate-properties include/dai/bbp.h src/bbp.cpp
373 */
374  struct Properties {
376 
383  DAI_ENUM(UpdateType,SEQ_FIX,SEQ_MAX,SEQ_BP_REV,SEQ_BP_FWD,PAR);
385  size_t verbose;
387  size_t maxiter;
389 
391  Real tol;
393  Real damping;
395  UpdateType updates;
396 
398 
401  void set(const PropertySet &opts);
403  PropertySet get() const;
405  std::string toString() const;
406  } props;
407 /* }}} END OF GENERATED CODE */
408 };
409 
410 
412 
420 Real numericBBPTest( const InfAlg &bp, const std::vector<size_t> *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h );
421 
422 
423 } // end of namespace dai
424 
425 
426 #endif
427 
428 
429 #endif
dai::BBP::R
const Prob & R(size_t I, size_t _i, size_t _J) const
Returns constant reference to R value; see eqn. (44) in [EaG09].
Definition: bbp.h:189
dai::BBP::_adj_b_F_unnorm
std::vector< Prob > _adj_b_F_unnorm
Unnormalized factor belief adjoints.
Definition: bbp.h:113
dai::BBP::_adj_psi_F
std::vector< Prob > _adj_psi_F
Factor adjoints.
Definition: bbp.h:84
dai::BBP::_indices
std::vector< std::vector< _ind_t > > _indices
Cached indices (indexed [i][_I])
Definition: bbp.h:133
dai::BBP::T
Prob & T(size_t i, size_t _I)
Returns reference to T value; see eqn. (41) in [EaG09].
Definition: bbp.h:175
dai::BBP::_Smsg
std::vector< std::vector< std::vector< Prob > > > _Smsg
_Smsg[i][_I]_j in [EaG09])
Definition: bbp.h:120
dai::BBP::Properties::DAI_ENUM
DAI_ENUM(UpdateType, SEQ_FIX, SEQ_MAX, SEQ_BP_REV, SEQ_BP_FWD, PAR)
Enumeration of possible update schedules.
dai::BBP::_init_adj_psi_V
std::vector< Prob > _init_adj_psi_V
Initial variable factor adjoints.
Definition: bbp.h:98
dai::BBP::init_V
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 adjo...
Definition: bbp.h:294
dai::BBP::Properties::damping
Real damping
Damping constant (0 for none); damping = 1 - lambda where lambda is the damping constant used in [EaG...
Definition: bbp.h:393
dai::BBP::adj_b_V
const Prob & adj_b_V(size_t i) const
Returns constant reference to variable belief adjoint.
Definition: bbp.h:330
dai::BBP::getZeroAdjV
std::vector< Prob > getZeroAdjV(const FactorGraph &fg)
Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the variables in th...
Definition: bbp.cpp:743
dai::BBP::Properties::toString
std::string toString() const
Convert to a string which can be parsed as a PropertySet.
Definition: bbp.cpp:1183
dai::BBP::init_F
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 adjo...
Definition: bbp.h:299
dai::BBP::_Rmsg
std::vector< std::vector< std::vector< Prob > > > _Rmsg
_Rmsg[I][_i]_J in [EaG09])
Definition: bbp.h:122
dai::BBP::calcNewN
void calcNewN(size_t i, size_t _I)
Calculates new variable->factor message adjoint.
Definition: bbp.cpp:405
dai::BBP::adj_psi_F
Prob & adj_psi_F(size_t I)
Returns reference to factor adjoint.
Definition: bbp.h:324
dai::BBP::upMsgM
void upMsgM(size_t i, size_t _I)
Updates (un)normalized factor->variable message adjoints.
Definition: bbp.cpp:461
dai::BBP::init
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) ...
Definition: bbp.h:289
dai::BBP::_adj_n_unnorm
std::vector< std::vector< Prob > > _adj_n_unnorm
Unnormalized variable->factor message adjoint (indexed [i][_I])
Definition: bbp.h:103
dai::BBP
Implements BBP (Back-Belief-Propagation) [EaG09].
Definition: bbp.h:67
dai::BBP::getTotalMsgM
Real getTotalMsgM()
Calculates sum of L1 norms of all normalized factor->variable message adjoints.
Definition: bbp.cpp:707
dai::BBP::Properties::set
void set(const PropertySet &opts)
Set members from PropertySet.
Definition: bbp.cpp:1140
dai::BBPCostFunction::needGibbsState
bool needGibbsState() const
Returns whether this cost function depends on having a Gibbs state.
Definition: bbp.cpp:40
dai::FactorGraph
Represents a factor graph.
Definition: factorgraph.h:65
dai::BBP::unnormAdjoint
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 no...
Definition: bbp.cpp:623
dai::BBP::Properties::maxiter
size_t maxiter
Maximum number of iterations.
Definition: bbp.h:387
dai::BBP::BBP
BBP(const InfAlg *ia, const PropertySet &opts)
Construct BBP object from a InfAlg ia and a PropertySet opts.
Definition: bbp.h:272
dai::BBP::_init_adj_psi_F
std::vector< Prob > _init_adj_psi_F
Initial factor adjoints.
Definition: bbp.h:100
dai::BBP::getMaxMsgM
Real getMaxMsgM()
Returns magnitude of the largest (in L1-norm) normalized factor->variable message adjoint...
Definition: bbp.cpp:699
dai::BBP::_iters
size_t _iters
Number of iterations done.
Definition: bbp.h:125
dai::Real
double Real
Real number (alias for double, which could be changed to long double if necessary) ...
Definition: util.h:98
dai::BBP::init
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...
Definition: bbp.h:280
dai::BBPCostFunction::BBPCostFunction
BBPCostFunction()
Default constructor.
Definition: bbp.h:45
dai::BBP::initCostFnAdj
void initCostFnAdj(const BBPCostFunction &cfn, const std::vector< size_t > *stateP)
Initializes with adjoints calculated from cost function cfn, and state stateP.
Definition: bbp.cpp:752
prob.h
Defines TProb<> and Prob classes which represent (probability) vectors (e.g., probability distributio...
dai::BBP::RegenerateSeqMessageAdjoints
void RegenerateSeqMessageAdjoints()
Initialise members for message adjoints for sequential algorithm.
Definition: bbp.cpp:344
dai::BBP::getArgmaxMsgM
void getArgmaxMsgM(size_t &i, size_t &_I, Real &mag)
Returns indices and magnitude of the largest normalized factor->variable message adjoint.
Definition: bbp.cpp:683
dai::BBP::Properties::updates
UpdateType updates
Update schedule.
Definition: bbp.h:395
dai::BBP::Iterations
size_t Iterations()
Return number of iterations done so far.
Definition: bbp.h:336
dai::BBP::RegenerateT
void RegenerateT()
Calculate T values; see eqn. (41) in [EaG09].
Definition: bbp.cpp:167
dai::BBP::doParUpdate
void doParUpdate()
Do one parallel update of all message adjoints.
Definition: bbp.cpp:467
dai::BP_dual
Calculates both types of BP messages and their normalizers from an InfAlg.
Definition: bp_dual.h:39
dai::BBP::adj_m
const Prob & adj_m(size_t i, size_t _I) const
Returns constant reference to factor->variable message adjoint.
Definition: bbp.h:198
dai::BBP::RegenerateR
void RegenerateR()
Calculate R values; see eqn. (44) in [EaG09].
Definition: bbp.cpp:232
dai::BBP::getUnMsgMag
Real getUnMsgMag()
Calculates averaged L1 norm of unnormalized message adjoints.
Definition: bbp.cpp:636
dai::BBP::calcNewM
void calcNewM(size_t i, size_t _I)
Calculates new factor->variable message adjoint.
Definition: bbp.cpp:426
dai::BBP::_new_adj_m
std::vector< std::vector< Prob > > _new_adj_m
Updated normalized factor->variable message adjoint (indexed [i][_I])
Definition: bbp.h:109
dai::BBP::_ia
const InfAlg * _ia
Pointer to the approximate inference algorithm (currently, only BP objects are supported) ...
Definition: bbp.h:76
enum.h
Defines the DAI_ENUM macro, which can be used to define an enum with additional functionality.
dai::BBP::sendSeqMsgM
void sendSeqMsgM(size_t i, size_t _I)
Implements routine Send-m in Figure 5 in [EaG09].
Definition: bbp.cpp:558
dai::BBP::_adj_n
std::vector< std::vector< Prob > > _adj_n
Variable->factor message adjoints (indexed [i][_I])
Definition: bbp.h:86
dai::BBP::incrSeqMsgM
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...
Definition: bbp.cpp:481
dai::BBP::_adj_m
std::vector< std::vector< Prob > > _adj_m
Factor->variable message adjoints (indexed [i][_I])
Definition: bbp.h:88
dai::BBPCostFunction::operator=
BBPCostFunction & operator=(const BBPCostFunctionBase &x)
Assignment operator.
Definition: bbp.h:57
dai::BBP::_new_adj_n
std::vector< std::vector< Prob > > _new_adj_n
Updated normalized variable->factor message adjoint (indexed [i][_I])
Definition: bbp.h:107
dai::BBP::Properties::verbose
size_t verbose
Verbosity (amount of output sent to stderr)
Definition: bbp.h:385
dai::BBP::getTotalNewMsgM
Real getTotalNewMsgM()
Calculates sum of L1 norms of all updated normalized factor->variable message adjoints.
Definition: bbp.cpp:716
dai::BBP::RegenerateParMessageAdjoints
void RegenerateParMessageAdjoints()
Initialise members for message adjoints for parallel algorithm.
Definition: bbp.cpp:294
dai::BBP::RegenerateS
void RegenerateS()
Calculate S values; see eqn. (43) in [EaG09].
Definition: bbp.cpp:204
dai::BBP::Regenerate
void Regenerate()
Called by init, recalculates intermediate values.
Definition: bbp.cpp:389
dai::BBP::S
Prob & S(size_t i, size_t _I, size_t _j)
Returns reference to S value; see eqn. (43) in [EaG09].
Definition: bbp.h:183
dai::BBP::adj_b_F
Prob & adj_b_F(size_t I)
Returns reference to factor belief adjoint.
Definition: bbp.h:332
dai::BBP::adj_n
Prob & adj_n(size_t i, size_t _I)
Returns reference to variable->factor message adjoint.
Definition: bbp.h:192
dai::BBP::RegeneratePsiAdjoints
void RegeneratePsiAdjoints()
Initialise members for factor adjoints.
Definition: bbp.cpp:265
dai::BBP::setSeqMsgM
void setSeqMsgM(size_t i, size_t _I, const Prob &p)
Sets normalized factor->variable message adjoint and calculates the corresponding unnormalized adjoin...
Definition: bbp.cpp:517
dai::BBP::_Umsg
std::vector< std::vector< Prob > > _Umsg
_Umsg[I]_i in [EaG09])
Definition: bbp.h:118
dai::BBP::RegenerateU
void RegenerateU()
Calculate U values; see eqn. (42) in [EaG09].
Definition: bbp.cpp:183
dai::BBP::_adj_psi_V
std::vector< Prob > _adj_psi_V
Variable factor adjoints.
Definition: bbp.h:82
dai::DAI_ENUM
DAI_ENUM(LDPCType, SMALL, GROUP, RANDOM)
Possible LDPC structures.
dai::BBP::upMsgN
void upMsgN(size_t i, size_t _I)
Updates (un)normalized variable->factor message adjoints.
Definition: bbp.cpp:455
dai::BBP::_index
const _ind_t & _index(size_t i, size_t _I) const
Returns an index from the cache.
Definition: bbp.h:139
dai::BBP::_adj_b_F
std::vector< Prob > _adj_b_F
Normalized factor belief adjoints.
Definition: bbp.h:92
dai::BBP::U
Prob & U(size_t I, size_t _i)
Returns reference to U value; see eqn. (42) in [EaG09].
Definition: bbp.h:179
dai::InfAlg
InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI...
Definition: daialg.h:35
dai::BBP::U
const Prob & U(size_t I, size_t _i) const
Returns constant reference to U value; see eqn. (42) in [EaG09].
Definition: bbp.h:181
dai::BBP::adj_b_V
Prob & adj_b_V(size_t i)
Returns reference to variable belief adjoint.
Definition: bbp.h:328
dai::BBP::Properties
Parameters for BBP.
Definition: bbp.h:374
dai::BBP::S
const Prob & S(size_t i, size_t _I, size_t _j) const
Returns constant reference to S value; see eqn. (43) in [EaG09].
Definition: bbp.h:185
dai::BBP::_adj_b_V_unnorm
std::vector< Prob > _adj_b_V_unnorm
Unnormalized variable belief adjoints.
Definition: bbp.h:111
dai::BBP::_adj_m_unnorm
std::vector< std::vector< Prob > > _adj_m_unnorm
Unnormalized factor->variable message adjoint (indexed [i][_I])
Definition: bbp.h:105
dai::BBPCostFunction::BBPCostFunction
BBPCostFunction(const BBPCostFunctionBase &x)
Construct from BBPCostFunctionBase x.
Definition: bbp.h:48
dai::BBP::calcUnnormMsgN
void calcUnnormMsgN(size_t i, size_t _I)
Calculates unnormalized variable->factor message adjoint from the normalized one. ...
Definition: bbp.cpp:445
dai::PropertySet
Represents a set of properties, mapping keys (of type PropertyKey) to values (of type PropertyValue) ...
Definition: properties.h:73
dai::BBP::RegenerateInputs
void RegenerateInputs()
Calculate _adj_b_V_unnorm and _adj_b_F_unnorm from _adj_b_V and _adj_b_F.
Definition: bbp.cpp:253
dai::BBP::RegenerateInds
void RegenerateInds()
Prepares index cache _indices.
Definition: bbp.cpp:148
dai::BBP::_Tmsg
std::vector< std::vector< Prob > > _Tmsg
_Tmsg[i]_I in [EaG09])
Definition: bbp.h:116
dai::BBP::getZeroAdjF
std::vector< Prob > getZeroAdjF(const FactorGraph &fg)
Returns a vector of Probs (filled with zeroes) with state spaces corresponding to the factors in the ...
Definition: bbp.cpp:734
dai
Namespace for libDAI.
Definition: alldai.cpp:16
dai::BBP::getTotalMsgN
Real getTotalMsgN()
Calculates sum of L1 norms of all normalized variable->factor message adjoints.
Definition: bbp.cpp:725
dai::BBP::run
void run()
Perform iterative updates until change is less than given tolerance.
Definition: bbp.cpp:903
dai::BBP::adj_b_F
const Prob & adj_b_F(size_t I) const
Returns constant reference to factor belief adjoint.
Definition: bbp.h:334
dai::BBP::adj_m
Prob & adj_m(size_t i, size_t _I)
Returns reference to factor->variable message adjoint.
Definition: bbp.h:196
factorgraph.h
Defines the FactorGraph class, which represents factor graphs (e.g., Bayesian networks or Markov rand...
daialg.h
Defines the general interface for inference methods in libDAI (classes InfAlg, DaiAlg<>, DaiAlgFG and DaiAlgRG).
dai::BBP::calcUnnormMsgM
void calcUnnormMsgM(size_t i, size_t _I)
Calculates unnormalized factor->variable message adjoint from the normalized one. ...
Definition: bbp.cpp:450
dai_config.h
Allows the user to specify which algorithms will be built into libDAI.
dai::BBP::T
const Prob & T(size_t i, size_t _I) const
Returns constant reference to T value; see eqn. (41) in [EaG09].
Definition: bbp.h:177
dai::BBP::adj_psi_V
Prob & adj_psi_V(size_t i)
Returns reference to variable factor adjoint.
Definition: bbp.h:320
dai::BBP::_ind_t
std::vector< size_t > _ind_t
Index type.
Definition: bbp.h:131
dai::BBP::_adj_b_V
std::vector< Prob > _adj_b_V
Normalized variable belief adjoints.
Definition: bbp.h:90
dai::BBP::getMsgMags
void getMsgMags(Real &s, Real &new_s)
Calculates averaged L1 norms of current and new normalized message adjoints.
Definition: bbp.cpp:649
dai::BBPCostFunction::evaluate
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...
Definition: bbp.cpp:55
dai::BBP::adj_n
const Prob & adj_n(size_t i, size_t _I) const
Returns constant reference to variable->factor message adjoint.
Definition: bbp.h:194
dai::BBP::Properties::tol
Real tol
Tolerance for convergence test.
Definition: bbp.h:391
dai::BBP::_bp_dual
BP_dual _bp_dual
Stores a BP_dual helper object.
Definition: bbp.h:72
dai::BBP::R
Prob & R(size_t I, size_t _i, size_t _J)
Returns reference to R value; see eqn. (44) in [EaG09].
Definition: bbp.h:187
dai::BBP::sendSeqMsgN
void sendSeqMsgN(size_t i, size_t _I, const Prob &f)
Implements routine Send-n in Figure 5 in [EaG09].
Definition: bbp.cpp:523
dai::BBPCostFunction
Predefined cost functions that can be used with BBP.
Definition: bbp.h:42
dai::BBP::_fg
const FactorGraph * _fg
Pointer to the factor graph.
Definition: bbp.h:74
dai::BBP::adj_psi_V
const Prob & adj_psi_V(size_t i) const
Returns constant reference to variable factor adjoint.
Definition: bbp.h:322
dai::BBP::adj_psi_F
const Prob & adj_psi_F(size_t I) const
Returns constant reference to factor adjoint.
Definition: bbp.h:326
bp_dual.h
Defines class BP_dual, which is used primarily by BBP.
Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/classdai_1_1FactorGraph.png0000644000175000017500000000143312552201365020755 0ustar jorismjorism‰PNG  IHDRòPbØsPLTEÿÿÿèìõuÂÀÀÀ‰ÜtRNSÿÿÿÿÿÿÿÕÊT2ªIDATxíí–ƒ D¯Ã9¾ÿ#o[+Ķ+Úš­³jˆ&—@ü ð‰º®ëZ à@ß‘šÊ‘ö–#4U?ÝÆ«z—f[qi>-òJ†UŽ\’+Óýv(Wª²©c<¥w‡á¹Ñ=ŽÜ.ÍéŒÈTKöˆžåðsŠ² a|ž~ÙøÙÇ[›¤ÝÊÉn‘#º]Ùìœy@¬.ìEds•\¿Ùœ2ܾˆ<}Óy‘‹ÚÌ!{9Ž–ȹßÉ;öÐw'›ÚtcÛ±Íh\ØC#ÏWÁ)¿Ëÿ¦™w;2@S92ÀÞrd€¦rd€½åÈMÕu]×Z_©àZºrß_ŽùzÈ7â«1_Ù;6ÀïË‘~]Ž ðërd€_—#œ^}ß÷  µŽ-“#ì/Gh(GØ_Ž ÐPŽ °¿ ¡`92@C92ÀþúZäBxO}!¼¥ƒ£Ij+‹,ImåÈ’´¿Y’êêÈ]åJÝí¯æ")Ñœ{W]+ Ü_8}c%Æ¦È È…­:µ·Þï#ÏÅ—¤ª¶EΑostæ*M²ÅÇýý4ºÜ/9›šéX¬By!dzYÇW"gÈ¿bŽ:ú$äÌœMPñH´Ì!/%ÛÓÀË‘KäÑ^’fÈ•ŒŠS6ë—%äjÏ=Z‹ÿzä*òa;ròÅ“±-È•Fó ò†È5äì KÈÃÏÔe¸R‡uäjµ@Kȳ‘—÷r%dî“71[êØäZ«{9[ k‘g;öX?³FŠ&˜-!Û‡ÇÍØãgSÙÒ±Më; ¶yò]–¤ÿ×ôc9û]–¤umøJ/9~rQ1Iš×o ë[’Vu²$åúpaKÒrdIÚ_Ž,I uMäBh,ƒBõ<ò2 Ö¸aÔIEND®B`‚libDAI-0.3.2/doc/html/form_127.png0000644000175000017500000000133012552200250015731 0ustar jorismjorism‰PNG  IHDRr#Ñ®0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ïGIDATxíé®Ý „? @ÈÆû¿mmHrÃ-giu"µÒEŒ„`¼ŒÍ_€ü3ëº^'ÀÝ°kΦŒ!ç`n‡0Õ…;ïÁ¸K¼€¯9\þ48™RŽ! XgZ¬Ë¹Lß~íoSú9îzižâyË4óË€/)—#Þ~ùteùMéqhßðÒ –©(“ƒ÷{ˆK:‡â‘Ó°ûÓ"Gã¾ï ¥O.D|R뽸úM-ÿ¬òKâ±›ªŽ¬Ô´w)ƒÉn³¤Ýhç;^j*³Á»z¿ì¨7ÿvJ=ä²—”ÆÈ:Ê¡í™ØWõ ž­b.š9¼,9o+èA`g‘„—l%ÄV;G^VÃ4â5æØ nK9ùBìÒ¹7D‰ÅKÊIì*ŽZqSù{”Ñ‹F¬QJEöSr;ÿƺˌN vÛµˆú”b–Ëã¨!Qþ½ÀËÆÓ䲊Q©´’-«y?c\Ss•BŸRwbUþã³8à} ÙY’^èLÍ\›JÍõêøí†WšêÈ“ÜÞ“”kRãÐÁkÊK*­Þ´vUÜÑ“û¥[J?8«ÌNm•üæ¼wÊ)çgEð„-Ëmž €ü_¸6Ïa9¦ñn•Š³1•*HR#òºÜmžÃÞ'ŒŸ}©;€û ÍóèLÞH×87ï À'Qšç¦­Sh„mâey nAIåñ,¥•>4´ÏÀQ›§›Šdâ\ƒl¾=LJÅ^Jc¾_B@3oM%À_ã:„É·­`?IEND®B`‚libDAI-0.3.2/doc/html/form_94.png0000644000175000017500000000036012552200240015655 0ustar jorismjorism‰PNG  IHDR XÌŽ0PLTEZ? tRNS.H]o€ž¬¹ÅÒÝéôÿªg°ï_IDATxíQ€ DPTâþ·-³´þ:³Ì›å G€Ÿ“¶¸R£ÑÃJô•š¯ZñÔËV'q= ‡L¤¨v"Æq‡bÈÈo$ã£G–Jwc8¤Eãÿž<º¡Þf {IEND®B`‚libDAI-0.3.2/doc/html/functions_func_i.html0000644000175000017500000002546312552201370020131 0ustar jorismjorism libDAI: Class Members - Functions
 

- i -

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/decmap_8h.html0000644000175000017500000000555412552201363016427 0ustar jorismjorism libDAI: include/dai/decmap.h File Reference
decmap.h File Reference

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

#include <dai/dai_config.h>

Go to the source code of this file.

Detailed Description

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

Generated by   doxygen 1.8.9.1
libDAI-0.3.2/doc/html/jquery.js0000644000175000017500000043563312552201363015573 0ustar jorismjorism/* * jQuery JavaScript Library v1.7.1 * http://jquery.com/ * * Copyright 2011, John Resig * Dual licensed under the MIT or GPL Version 2 licenses. * http://jquery.org/license * * Includes Sizzle.js * http://sizzlejs.com/ * Copyright 2011, The Dojo Foundation * Released under the MIT, BSD, and GPL Licenses. * * Date: Mon Nov 21 21:11:03 2011 -0500 */ (function(bb,L){var av=bb.document,bu=bb.navigator,bl=bb.location;var b=(function(){var bF=function(b0,b1){return new bF.fn.init(b0,b1,bD)},bU=bb.jQuery,bH=bb.$,bD,bY=/^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,bM=/\S/,bI=/^\s+/,bE=/\s+$/,bA=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,bN=/^[\],:{}\s]*$/,bW=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,bP=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,bJ=/(?:^|:|,)(?:\s*\[)+/g,by=/(webkit)[ \/]([\w.]+)/,bR=/(opera)(?:.*version)?[ \/]([\w.]+)/,bQ=/(msie) ([\w.]+)/,bS=/(mozilla)(?:.*? rv:([\w.]+))?/,bB=/-([a-z]|[0-9])/ig,bZ=/^-ms-/,bT=function(b0,b1){return(b1+"").toUpperCase()},bX=bu.userAgent,bV,bC,e,bL=Object.prototype.toString,bG=Object.prototype.hasOwnProperty,bz=Array.prototype.push,bK=Array.prototype.slice,bO=String.prototype.trim,bv=Array.prototype.indexOf,bx={};bF.fn=bF.prototype={constructor:bF,init:function(b0,b4,b3){var b2,b5,b1,b6;if(!b0){return this}if(b0.nodeType){this.context=this[0]=b0;this.length=1;return this}if(b0==="body"&&!b4&&av.body){this.context=av;this[0]=av.body;this.selector=b0;this.length=1;return this}if(typeof b0==="string"){if(b0.charAt(0)==="<"&&b0.charAt(b0.length-1)===">"&&b0.length>=3){b2=[null,b0,null]}else{b2=bY.exec(b0)}if(b2&&(b2[1]||!b4)){if(b2[1]){b4=b4 instanceof bF?b4[0]:b4;b6=(b4?b4.ownerDocument||b4:av);b1=bA.exec(b0);if(b1){if(bF.isPlainObject(b4)){b0=[av.createElement(b1[1])];bF.fn.attr.call(b0,b4,true)}else{b0=[b6.createElement(b1[1])]}}else{b1=bF.buildFragment([b2[1]],[b6]);b0=(b1.cacheable?bF.clone(b1.fragment):b1.fragment).childNodes}return bF.merge(this,b0)}else{b5=av.getElementById(b2[2]);if(b5&&b5.parentNode){if(b5.id!==b2[2]){return b3.find(b0)}this.length=1;this[0]=b5}this.context=av;this.selector=b0;return this}}else{if(!b4||b4.jquery){return(b4||b3).find(b0)}else{return this.constructor(b4).find(b0)}}}else{if(bF.isFunction(b0)){return b3.ready(b0)}}if(b0.selector!==L){this.selector=b0.selector;this.context=b0.context}return bF.makeArray(b0,this)},selector:"",jquery:"1.7.1",length:0,size:function(){return this.length},toArray:function(){return bK.call(this,0)},get:function(b0){return b0==null?this.toArray():(b0<0?this[this.length+b0]:this[b0])},pushStack:function(b1,b3,b0){var b2=this.constructor();if(bF.isArray(b1)){bz.apply(b2,b1)}else{bF.merge(b2,b1)}b2.prevObject=this;b2.context=this.context;if(b3==="find"){b2.selector=this.selector+(this.selector?" ":"")+b0}else{if(b3){b2.selector=this.selector+"."+b3+"("+b0+")"}}return b2},each:function(b1,b0){return bF.each(this,b1,b0)},ready:function(b0){bF.bindReady();bC.add(b0);return this},eq:function(b0){b0=+b0;return b0===-1?this.slice(b0):this.slice(b0,b0+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(bK.apply(this,arguments),"slice",bK.call(arguments).join(","))},map:function(b0){return this.pushStack(bF.map(this,function(b2,b1){return b0.call(b2,b1,b2)}))},end:function(){return this.prevObject||this.constructor(null)},push:bz,sort:[].sort,splice:[].splice};bF.fn.init.prototype=bF.fn;bF.extend=bF.fn.extend=function(){var b9,b2,b0,b1,b6,b7,b5=arguments[0]||{},b4=1,b3=arguments.length,b8=false;if(typeof b5==="boolean"){b8=b5;b5=arguments[1]||{};b4=2}if(typeof b5!=="object"&&!bF.isFunction(b5)){b5={}}if(b3===b4){b5=this;--b4}for(;b40){return}bC.fireWith(av,[bF]);if(bF.fn.trigger){bF(av).trigger("ready").off("ready")}}},bindReady:function(){if(bC){return}bC=bF.Callbacks("once memory");if(av.readyState==="complete"){return setTimeout(bF.ready,1)}if(av.addEventListener){av.addEventListener("DOMContentLoaded",e,false);bb.addEventListener("load",bF.ready,false)}else{if(av.attachEvent){av.attachEvent("onreadystatechange",e);bb.attachEvent("onload",bF.ready);var b0=false;try{b0=bb.frameElement==null}catch(b1){}if(av.documentElement.doScroll&&b0){bw()}}}},isFunction:function(b0){return bF.type(b0)==="function"},isArray:Array.isArray||function(b0){return bF.type(b0)==="array"},isWindow:function(b0){return b0&&typeof b0==="object"&&"setInterval" in b0},isNumeric:function(b0){return !isNaN(parseFloat(b0))&&isFinite(b0)},type:function(b0){return b0==null?String(b0):bx[bL.call(b0)]||"object"},isPlainObject:function(b2){if(!b2||bF.type(b2)!=="object"||b2.nodeType||bF.isWindow(b2)){return false}try{if(b2.constructor&&!bG.call(b2,"constructor")&&!bG.call(b2.constructor.prototype,"isPrototypeOf")){return false}}catch(b1){return false}var b0;for(b0 in b2){}return b0===L||bG.call(b2,b0)},isEmptyObject:function(b1){for(var b0 in b1){return false}return true},error:function(b0){throw new Error(b0)},parseJSON:function(b0){if(typeof b0!=="string"||!b0){return null}b0=bF.trim(b0);if(bb.JSON&&bb.JSON.parse){return bb.JSON.parse(b0)}if(bN.test(b0.replace(bW,"@").replace(bP,"]").replace(bJ,""))){return(new Function("return "+b0))()}bF.error("Invalid JSON: "+b0)},parseXML:function(b2){var b0,b1;try{if(bb.DOMParser){b1=new DOMParser();b0=b1.parseFromString(b2,"text/xml")}else{b0=new ActiveXObject("Microsoft.XMLDOM");b0.async="false";b0.loadXML(b2)}}catch(b3){b0=L}if(!b0||!b0.documentElement||b0.getElementsByTagName("parsererror").length){bF.error("Invalid XML: "+b2)}return b0},noop:function(){},globalEval:function(b0){if(b0&&bM.test(b0)){(bb.execScript||function(b1){bb["eval"].call(bb,b1)})(b0)}},camelCase:function(b0){return b0.replace(bZ,"ms-").replace(bB,bT)},nodeName:function(b1,b0){return b1.nodeName&&b1.nodeName.toUpperCase()===b0.toUpperCase()},each:function(b3,b6,b2){var b1,b4=0,b5=b3.length,b0=b5===L||bF.isFunction(b3);if(b2){if(b0){for(b1 in b3){if(b6.apply(b3[b1],b2)===false){break}}}else{for(;b40&&b0[0]&&b0[b1-1])||b1===0||bF.isArray(b0));if(b3){for(;b21?aJ.call(arguments,0):bG;if(!(--bw)){bC.resolveWith(bC,bx)}}}function bz(bF){return function(bG){bB[bF]=arguments.length>1?aJ.call(arguments,0):bG;bC.notifyWith(bE,bB)}}if(e>1){for(;bv
a";bI=bv.getElementsByTagName("*");bF=bv.getElementsByTagName("a")[0];if(!bI||!bI.length||!bF){return{}}bG=av.createElement("select");bx=bG.appendChild(av.createElement("option"));bE=bv.getElementsByTagName("input")[0];bJ={leadingWhitespace:(bv.firstChild.nodeType===3),tbody:!bv.getElementsByTagName("tbody").length,htmlSerialize:!!bv.getElementsByTagName("link").length,style:/top/.test(bF.getAttribute("style")),hrefNormalized:(bF.getAttribute("href")==="/a"),opacity:/^0.55/.test(bF.style.opacity),cssFloat:!!bF.style.cssFloat,checkOn:(bE.value==="on"),optSelected:bx.selected,getSetAttribute:bv.className!=="t",enctype:!!av.createElement("form").enctype,html5Clone:av.createElement("nav").cloneNode(true).outerHTML!=="<:nav>",submitBubbles:true,changeBubbles:true,focusinBubbles:false,deleteExpando:true,noCloneEvent:true,inlineBlockNeedsLayout:false,shrinkWrapBlocks:false,reliableMarginRight:true};bE.checked=true;bJ.noCloneChecked=bE.cloneNode(true).checked;bG.disabled=true;bJ.optDisabled=!bx.disabled;try{delete bv.test}catch(bC){bJ.deleteExpando=false}if(!bv.addEventListener&&bv.attachEvent&&bv.fireEvent){bv.attachEvent("onclick",function(){bJ.noCloneEvent=false});bv.cloneNode(true).fireEvent("onclick")}bE=av.createElement("input");bE.value="t";bE.setAttribute("type","radio");bJ.radioValue=bE.value==="t";bE.setAttribute("checked","checked");bv.appendChild(bE);bD=av.createDocumentFragment();bD.appendChild(bv.lastChild);bJ.checkClone=bD.cloneNode(true).cloneNode(true).lastChild.checked;bJ.appendChecked=bE.checked;bD.removeChild(bE);bD.appendChild(bv);bv.innerHTML="";if(bb.getComputedStyle){bA=av.createElement("div");bA.style.width="0";bA.style.marginRight="0";bv.style.width="2px";bv.appendChild(bA);bJ.reliableMarginRight=(parseInt((bb.getComputedStyle(bA,null)||{marginRight:0}).marginRight,10)||0)===0}if(bv.attachEvent){for(by in {submit:1,change:1,focusin:1}){bB="on"+by;bw=(bB in bv);if(!bw){bv.setAttribute(bB,"return;");bw=(typeof bv[bB]==="function")}bJ[by+"Bubbles"]=bw}}bD.removeChild(bv);bD=bG=bx=bA=bv=bE=null;b(function(){var bM,bU,bV,bT,bN,bO,bL,bS,bR,e,bP,bQ=av.getElementsByTagName("body")[0];if(!bQ){return}bL=1;bS="position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";bR="visibility:hidden;border:0;";e="style='"+bS+"border:5px solid #000;padding:0;'";bP="
";bM=av.createElement("div");bM.style.cssText=bR+"width:0;height:0;position:static;top:0;margin-top:"+bL+"px";bQ.insertBefore(bM,bQ.firstChild);bv=av.createElement("div");bM.appendChild(bv);bv.innerHTML="
t
";bz=bv.getElementsByTagName("td");bw=(bz[0].offsetHeight===0);bz[0].style.display="";bz[1].style.display="none";bJ.reliableHiddenOffsets=bw&&(bz[0].offsetHeight===0);bv.innerHTML="";bv.style.width=bv.style.paddingLeft="1px";b.boxModel=bJ.boxModel=bv.offsetWidth===2;if(typeof bv.style.zoom!=="undefined"){bv.style.display="inline";bv.style.zoom=1;bJ.inlineBlockNeedsLayout=(bv.offsetWidth===2);bv.style.display="";bv.innerHTML="
";bJ.shrinkWrapBlocks=(bv.offsetWidth!==2)}bv.style.cssText=bS+bR;bv.innerHTML=bP;bU=bv.firstChild;bV=bU.firstChild;bN=bU.nextSibling.firstChild.firstChild;bO={doesNotAddBorder:(bV.offsetTop!==5),doesAddBorderForTableAndCells:(bN.offsetTop===5)};bV.style.position="fixed";bV.style.top="20px";bO.fixedPosition=(bV.offsetTop===20||bV.offsetTop===15);bV.style.position=bV.style.top="";bU.style.overflow="hidden";bU.style.position="relative";bO.subtractsBorderForOverflowNotVisible=(bV.offsetTop===-5);bO.doesNotIncludeMarginInBodyOffset=(bQ.offsetTop!==bL);bQ.removeChild(bM);bv=bM=null;b.extend(bJ,bO)});return bJ})();var aS=/^(?:\{.*\}|\[.*\])$/,aA=/([A-Z])/g;b.extend({cache:{},uuid:0,expando:"jQuery"+(b.fn.jquery+Math.random()).replace(/\D/g,""),noData:{embed:true,object:"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",applet:true},hasData:function(e){e=e.nodeType?b.cache[e[b.expando]]:e[b.expando];return !!e&&!S(e)},data:function(bx,bv,bz,by){if(!b.acceptData(bx)){return}var bG,bA,bD,bE=b.expando,bC=typeof bv==="string",bF=bx.nodeType,e=bF?b.cache:bx,bw=bF?bx[bE]:bx[bE]&&bE,bB=bv==="events";if((!bw||!e[bw]||(!bB&&!by&&!e[bw].data))&&bC&&bz===L){return}if(!bw){if(bF){bx[bE]=bw=++b.uuid}else{bw=bE}}if(!e[bw]){e[bw]={};if(!bF){e[bw].toJSON=b.noop}}if(typeof bv==="object"||typeof bv==="function"){if(by){e[bw]=b.extend(e[bw],bv)}else{e[bw].data=b.extend(e[bw].data,bv)}}bG=bA=e[bw];if(!by){if(!bA.data){bA.data={}}bA=bA.data}if(bz!==L){bA[b.camelCase(bv)]=bz}if(bB&&!bA[bv]){return bG.events}if(bC){bD=bA[bv];if(bD==null){bD=bA[b.camelCase(bv)]}}else{bD=bA}return bD},removeData:function(bx,bv,by){if(!b.acceptData(bx)){return}var bB,bA,bz,bC=b.expando,bD=bx.nodeType,e=bD?b.cache:bx,bw=bD?bx[bC]:bC;if(!e[bw]){return}if(bv){bB=by?e[bw]:e[bw].data;if(bB){if(!b.isArray(bv)){if(bv in bB){bv=[bv]}else{bv=b.camelCase(bv);if(bv in bB){bv=[bv]}else{bv=bv.split(" ")}}}for(bA=0,bz=bv.length;bA-1){return true}}return false},val:function(bx){var e,bv,by,bw=this[0];if(!arguments.length){if(bw){e=b.valHooks[bw.nodeName.toLowerCase()]||b.valHooks[bw.type];if(e&&"get" in e&&(bv=e.get(bw,"value"))!==L){return bv}bv=bw.value;return typeof bv==="string"?bv.replace(aU,""):bv==null?"":bv}return}by=b.isFunction(bx);return this.each(function(bA){var bz=b(this),bB;if(this.nodeType!==1){return}if(by){bB=bx.call(this,bA,bz.val())}else{bB=bx}if(bB==null){bB=""}else{if(typeof bB==="number"){bB+=""}else{if(b.isArray(bB)){bB=b.map(bB,function(bC){return bC==null?"":bC+""})}}}e=b.valHooks[this.nodeName.toLowerCase()]||b.valHooks[this.type];if(!e||!("set" in e)||e.set(this,bB,"value")===L){this.value=bB}})}});b.extend({valHooks:{option:{get:function(e){var bv=e.attributes.value;return !bv||bv.specified?e.value:e.text}},select:{get:function(e){var bA,bv,bz,bx,by=e.selectedIndex,bB=[],bC=e.options,bw=e.type==="select-one";if(by<0){return null}bv=bw?by:0;bz=bw?by+1:bC.length;for(;bv=0});if(!e.length){bv.selectedIndex=-1}return e}}},attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(bA,bx,bB,bz){var bw,e,by,bv=bA.nodeType;if(!bA||bv===3||bv===8||bv===2){return}if(bz&&bx in b.attrFn){return b(bA)[bx](bB)}if(typeof bA.getAttribute==="undefined"){return b.prop(bA,bx,bB)}by=bv!==1||!b.isXMLDoc(bA);if(by){bx=bx.toLowerCase();e=b.attrHooks[bx]||(ao.test(bx)?aY:be)}if(bB!==L){if(bB===null){b.removeAttr(bA,bx);return}else{if(e&&"set" in e&&by&&(bw=e.set(bA,bB,bx))!==L){return bw}else{bA.setAttribute(bx,""+bB);return bB}}}else{if(e&&"get" in e&&by&&(bw=e.get(bA,bx))!==null){return bw}else{bw=bA.getAttribute(bx);return bw===null?L:bw}}},removeAttr:function(bx,bz){var by,bA,bv,e,bw=0;if(bz&&bx.nodeType===1){bA=bz.toLowerCase().split(af);e=bA.length;for(;bw=0)}}})});var bd=/^(?:textarea|input|select)$/i,n=/^([^\.]*)?(?:\.(.+))?$/,J=/\bhover(\.\S+)?\b/,aO=/^key/,bf=/^(?:mouse|contextmenu)|click/,T=/^(?:focusinfocus|focusoutblur)$/,U=/^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,Y=function(e){var bv=U.exec(e);if(bv){bv[1]=(bv[1]||"").toLowerCase();bv[3]=bv[3]&&new RegExp("(?:^|\\s)"+bv[3]+"(?:\\s|$)")}return bv},j=function(bw,e){var bv=bw.attributes||{};return((!e[1]||bw.nodeName.toLowerCase()===e[1])&&(!e[2]||(bv.id||{}).value===e[2])&&(!e[3]||e[3].test((bv["class"]||{}).value)))},bt=function(e){return b.event.special.hover?e:e.replace(J,"mouseenter$1 mouseleave$1")};b.event={add:function(bx,bC,bJ,bA,by){var bD,bB,bK,bI,bH,bF,e,bG,bv,bz,bw,bE;if(bx.nodeType===3||bx.nodeType===8||!bC||!bJ||!(bD=b._data(bx))){return}if(bJ.handler){bv=bJ;bJ=bv.handler}if(!bJ.guid){bJ.guid=b.guid++}bK=bD.events;if(!bK){bD.events=bK={}}bB=bD.handle;if(!bB){bD.handle=bB=function(bL){return typeof b!=="undefined"&&(!bL||b.event.triggered!==bL.type)?b.event.dispatch.apply(bB.elem,arguments):L};bB.elem=bx}bC=b.trim(bt(bC)).split(" ");for(bI=0;bI=0){bG=bG.slice(0,-1);bw=true}if(bG.indexOf(".")>=0){bx=bG.split(".");bG=bx.shift();bx.sort()}if((!bA||b.event.customEvent[bG])&&!b.event.global[bG]){return}bv=typeof bv==="object"?bv[b.expando]?bv:new b.Event(bG,bv):new b.Event(bG);bv.type=bG;bv.isTrigger=true;bv.exclusive=bw;bv.namespace=bx.join(".");bv.namespace_re=bv.namespace?new RegExp("(^|\\.)"+bx.join("\\.(?:.*\\.)?")+"(\\.|$)"):null;by=bG.indexOf(":")<0?"on"+bG:"";if(!bA){e=b.cache;for(bC in e){if(e[bC].events&&e[bC].events[bG]){b.event.trigger(bv,bD,e[bC].handle.elem,true)}}return}bv.result=L;if(!bv.target){bv.target=bA}bD=bD!=null?b.makeArray(bD):[];bD.unshift(bv);bF=b.event.special[bG]||{};if(bF.trigger&&bF.trigger.apply(bA,bD)===false){return}bB=[[bA,bF.bindType||bG]];if(!bJ&&!bF.noBubble&&!b.isWindow(bA)){bI=bF.delegateType||bG;bH=T.test(bI+bG)?bA:bA.parentNode;bz=null;for(;bH;bH=bH.parentNode){bB.push([bH,bI]);bz=bH}if(bz&&bz===bA.ownerDocument){bB.push([bz.defaultView||bz.parentWindow||bb,bI])}}for(bC=0;bCbA){bH.push({elem:this,matches:bz.slice(bA)})}for(bC=0;bC0?this.on(e,null,bx,bw):this.trigger(e)};if(b.attrFn){b.attrFn[e]=true}if(aO.test(e)){b.event.fixHooks[e]=b.event.keyHooks}if(bf.test(e)){b.event.fixHooks[e]=b.event.mouseHooks}}); /* * Sizzle CSS Selector Engine * Copyright 2011, The Dojo Foundation * Released under the MIT, BSD, and GPL Licenses. * More information: http://sizzlejs.com/ */ (function(){var bH=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,bC="sizcache"+(Math.random()+"").replace(".",""),bI=0,bL=Object.prototype.toString,bB=false,bA=true,bK=/\\/g,bO=/\r\n/g,bQ=/\W/;[0,0].sort(function(){bA=false;return 0});var by=function(bV,e,bY,bZ){bY=bY||[];e=e||av;var b1=e;if(e.nodeType!==1&&e.nodeType!==9){return[]}if(!bV||typeof bV!=="string"){return bY}var bS,b3,b6,bR,b2,b5,b4,bX,bU=true,bT=by.isXML(e),bW=[],b0=bV;do{bH.exec("");bS=bH.exec(b0);if(bS){b0=bS[3];bW.push(bS[1]);if(bS[2]){bR=bS[3];break}}}while(bS);if(bW.length>1&&bD.exec(bV)){if(bW.length===2&&bE.relative[bW[0]]){b3=bM(bW[0]+bW[1],e,bZ)}else{b3=bE.relative[bW[0]]?[e]:by(bW.shift(),e);while(bW.length){bV=bW.shift();if(bE.relative[bV]){bV+=bW.shift()}b3=bM(bV,b3,bZ)}}}else{if(!bZ&&bW.length>1&&e.nodeType===9&&!bT&&bE.match.ID.test(bW[0])&&!bE.match.ID.test(bW[bW.length-1])){b2=by.find(bW.shift(),e,bT);e=b2.expr?by.filter(b2.expr,b2.set)[0]:b2.set[0]}if(e){b2=bZ?{expr:bW.pop(),set:bF(bZ)}:by.find(bW.pop(),bW.length===1&&(bW[0]==="~"||bW[0]==="+")&&e.parentNode?e.parentNode:e,bT);b3=b2.expr?by.filter(b2.expr,b2.set):b2.set;if(bW.length>0){b6=bF(b3)}else{bU=false}while(bW.length){b5=bW.pop();b4=b5;if(!bE.relative[b5]){b5=""}else{b4=bW.pop()}if(b4==null){b4=e}bE.relative[b5](b6,b4,bT)}}else{b6=bW=[]}}if(!b6){b6=b3}if(!b6){by.error(b5||bV)}if(bL.call(b6)==="[object Array]"){if(!bU){bY.push.apply(bY,b6)}else{if(e&&e.nodeType===1){for(bX=0;b6[bX]!=null;bX++){if(b6[bX]&&(b6[bX]===true||b6[bX].nodeType===1&&by.contains(e,b6[bX]))){bY.push(b3[bX])}}}else{for(bX=0;b6[bX]!=null;bX++){if(b6[bX]&&b6[bX].nodeType===1){bY.push(b3[bX])}}}}}else{bF(b6,bY)}if(bR){by(bR,b1,bY,bZ);by.uniqueSort(bY)}return bY};by.uniqueSort=function(bR){if(bJ){bB=bA;bR.sort(bJ);if(bB){for(var e=1;e0};by.find=function(bX,e,bY){var bW,bS,bU,bT,bV,bR;if(!bX){return[]}for(bS=0,bU=bE.order.length;bS":function(bW,bR){var bV,bU=typeof bR==="string",bS=0,e=bW.length;if(bU&&!bQ.test(bR)){bR=bR.toLowerCase();for(;bS=0)){if(!bS){e.push(bV)}}else{if(bS){bR[bU]=false}}}}return false},ID:function(e){return e[1].replace(bK,"")},TAG:function(bR,e){return bR[1].replace(bK,"").toLowerCase()},CHILD:function(e){if(e[1]==="nth"){if(!e[2]){by.error(e[0])}e[2]=e[2].replace(/^\+|\s*/g,"");var bR=/(-?)(\d*)(?:n([+\-]?\d*))?/.exec(e[2]==="even"&&"2n"||e[2]==="odd"&&"2n+1"||!/\D/.test(e[2])&&"0n+"+e[2]||e[2]);e[2]=(bR[1]+(bR[2]||1))-0;e[3]=bR[3]-0}else{if(e[2]){by.error(e[0])}}e[0]=bI++;return e},ATTR:function(bU,bR,bS,e,bV,bW){var bT=bU[1]=bU[1].replace(bK,"");if(!bW&&bE.attrMap[bT]){bU[1]=bE.attrMap[bT]}bU[4]=(bU[4]||bU[5]||"").replace(bK,"");if(bU[2]==="~="){bU[4]=" "+bU[4]+" "}return bU},PSEUDO:function(bU,bR,bS,e,bV){if(bU[1]==="not"){if((bH.exec(bU[3])||"").length>1||/^\w/.test(bU[3])){bU[3]=by(bU[3],null,null,bR)}else{var bT=by.filter(bU[3],bR,bS,true^bV);if(!bS){e.push.apply(e,bT)}return false}}else{if(bE.match.POS.test(bU[0])||bE.match.CHILD.test(bU[0])){return true}}return bU},POS:function(e){e.unshift(true);return e}},filters:{enabled:function(e){return e.disabled===false&&e.type!=="hidden"},disabled:function(e){return e.disabled===true},checked:function(e){return e.checked===true},selected:function(e){if(e.parentNode){e.parentNode.selectedIndex}return e.selected===true},parent:function(e){return !!e.firstChild},empty:function(e){return !e.firstChild},has:function(bS,bR,e){return !!by(e[3],bS).length},header:function(e){return(/h\d/i).test(e.nodeName)},text:function(bS){var e=bS.getAttribute("type"),bR=bS.type;return bS.nodeName.toLowerCase()==="input"&&"text"===bR&&(e===bR||e===null)},radio:function(e){return e.nodeName.toLowerCase()==="input"&&"radio"===e.type},checkbox:function(e){return e.nodeName.toLowerCase()==="input"&&"checkbox"===e.type},file:function(e){return e.nodeName.toLowerCase()==="input"&&"file"===e.type},password:function(e){return e.nodeName.toLowerCase()==="input"&&"password"===e.type},submit:function(bR){var e=bR.nodeName.toLowerCase();return(e==="input"||e==="button")&&"submit"===bR.type},image:function(e){return e.nodeName.toLowerCase()==="input"&&"image"===e.type},reset:function(bR){var e=bR.nodeName.toLowerCase();return(e==="input"||e==="button")&&"reset"===bR.type},button:function(bR){var e=bR.nodeName.toLowerCase();return e==="input"&&"button"===bR.type||e==="button"},input:function(e){return(/input|select|textarea|button/i).test(e.nodeName)},focus:function(e){return e===e.ownerDocument.activeElement}},setFilters:{first:function(bR,e){return e===0},last:function(bS,bR,e,bT){return bR===bT.length-1},even:function(bR,e){return e%2===0},odd:function(bR,e){return e%2===1},lt:function(bS,bR,e){return bRe[3]-0},nth:function(bS,bR,e){return e[3]-0===bR},eq:function(bS,bR,e){return e[3]-0===bR}},filter:{PSEUDO:function(bS,bX,bW,bY){var e=bX[1],bR=bE.filters[e];if(bR){return bR(bS,bW,bX,bY)}else{if(e==="contains"){return(bS.textContent||bS.innerText||bw([bS])||"").indexOf(bX[3])>=0}else{if(e==="not"){var bT=bX[3];for(var bV=0,bU=bT.length;bV=0)}}},ID:function(bR,e){return bR.nodeType===1&&bR.getAttribute("id")===e},TAG:function(bR,e){return(e==="*"&&bR.nodeType===1)||!!bR.nodeName&&bR.nodeName.toLowerCase()===e},CLASS:function(bR,e){return(" "+(bR.className||bR.getAttribute("class"))+" ").indexOf(e)>-1},ATTR:function(bV,bT){var bS=bT[1],e=by.attr?by.attr(bV,bS):bE.attrHandle[bS]?bE.attrHandle[bS](bV):bV[bS]!=null?bV[bS]:bV.getAttribute(bS),bW=e+"",bU=bT[2],bR=bT[4];return e==null?bU==="!=":!bU&&by.attr?e!=null:bU==="="?bW===bR:bU==="*="?bW.indexOf(bR)>=0:bU==="~="?(" "+bW+" ").indexOf(bR)>=0:!bR?bW&&e!==false:bU==="!="?bW!==bR:bU==="^="?bW.indexOf(bR)===0:bU==="$="?bW.substr(bW.length-bR.length)===bR:bU==="|="?bW===bR||bW.substr(0,bR.length+1)===bR+"-":false},POS:function(bU,bR,bS,bV){var e=bR[2],bT=bE.setFilters[e];if(bT){return bT(bU,bS,bR,bV)}}}};var bD=bE.match.POS,bx=function(bR,e){return"\\"+(e-0+1)};for(var bz in bE.match){bE.match[bz]=new RegExp(bE.match[bz].source+(/(?![^\[]*\])(?![^\(]*\))/.source));bE.leftMatch[bz]=new RegExp(/(^(?:.|\r|\n)*?)/.source+bE.match[bz].source.replace(/\\(\d+)/g,bx))}var bF=function(bR,e){bR=Array.prototype.slice.call(bR,0);if(e){e.push.apply(e,bR);return e}return bR};try{Array.prototype.slice.call(av.documentElement.childNodes,0)[0].nodeType}catch(bP){bF=function(bU,bT){var bS=0,bR=bT||[];if(bL.call(bU)==="[object Array]"){Array.prototype.push.apply(bR,bU)}else{if(typeof bU.length==="number"){for(var e=bU.length;bS";e.insertBefore(bR,e.firstChild);if(av.getElementById(bS)){bE.find.ID=function(bU,bV,bW){if(typeof bV.getElementById!=="undefined"&&!bW){var bT=bV.getElementById(bU[1]);return bT?bT.id===bU[1]||typeof bT.getAttributeNode!=="undefined"&&bT.getAttributeNode("id").nodeValue===bU[1]?[bT]:L:[]}};bE.filter.ID=function(bV,bT){var bU=typeof bV.getAttributeNode!=="undefined"&&bV.getAttributeNode("id");return bV.nodeType===1&&bU&&bU.nodeValue===bT}}e.removeChild(bR);e=bR=null})();(function(){var e=av.createElement("div");e.appendChild(av.createComment(""));if(e.getElementsByTagName("*").length>0){bE.find.TAG=function(bR,bV){var bU=bV.getElementsByTagName(bR[1]);if(bR[1]==="*"){var bT=[];for(var bS=0;bU[bS];bS++){if(bU[bS].nodeType===1){bT.push(bU[bS])}}bU=bT}return bU}}e.innerHTML="";if(e.firstChild&&typeof e.firstChild.getAttribute!=="undefined"&&e.firstChild.getAttribute("href")!=="#"){bE.attrHandle.href=function(bR){return bR.getAttribute("href",2)}}e=null})();if(av.querySelectorAll){(function(){var e=by,bT=av.createElement("div"),bS="__sizzle__";bT.innerHTML="

";if(bT.querySelectorAll&&bT.querySelectorAll(".TEST").length===0){return}by=function(b4,bV,bZ,b3){bV=bV||av;if(!b3&&!by.isXML(bV)){var b2=/^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec(b4);if(b2&&(bV.nodeType===1||bV.nodeType===9)){if(b2[1]){return bF(bV.getElementsByTagName(b4),bZ)}else{if(b2[2]&&bE.find.CLASS&&bV.getElementsByClassName){return bF(bV.getElementsByClassName(b2[2]),bZ)}}}if(bV.nodeType===9){if(b4==="body"&&bV.body){return bF([bV.body],bZ)}else{if(b2&&b2[3]){var bY=bV.getElementById(b2[3]);if(bY&&bY.parentNode){if(bY.id===b2[3]){return bF([bY],bZ)}}else{return bF([],bZ)}}}try{return bF(bV.querySelectorAll(b4),bZ)}catch(b0){}}else{if(bV.nodeType===1&&bV.nodeName.toLowerCase()!=="object"){var bW=bV,bX=bV.getAttribute("id"),bU=bX||bS,b6=bV.parentNode,b5=/^\s*[+~]/.test(b4);if(!bX){bV.setAttribute("id",bU)}else{bU=bU.replace(/'/g,"\\$&")}if(b5&&b6){bV=bV.parentNode}try{if(!b5||b6){return bF(bV.querySelectorAll("[id='"+bU+"'] "+b4),bZ)}}catch(b1){}finally{if(!bX){bW.removeAttribute("id")}}}}}return e(b4,bV,bZ,b3)};for(var bR in e){by[bR]=e[bR]}bT=null})()}(function(){var e=av.documentElement,bS=e.matchesSelector||e.mozMatchesSelector||e.webkitMatchesSelector||e.msMatchesSelector;if(bS){var bU=!bS.call(av.createElement("div"),"div"),bR=false;try{bS.call(av.documentElement,"[test!='']:sizzle")}catch(bT){bR=true}by.matchesSelector=function(bW,bY){bY=bY.replace(/\=\s*([^'"\]]*)\s*\]/g,"='$1']");if(!by.isXML(bW)){try{if(bR||!bE.match.PSEUDO.test(bY)&&!/!=/.test(bY)){var bV=bS.call(bW,bY);if(bV||!bU||bW.document&&bW.document.nodeType!==11){return bV}}}catch(bX){}}return by(bY,null,null,[bW]).length>0}}})();(function(){var e=av.createElement("div");e.innerHTML="
";if(!e.getElementsByClassName||e.getElementsByClassName("e").length===0){return}e.lastChild.className="e";if(e.getElementsByClassName("e").length===1){return}bE.order.splice(1,0,"CLASS");bE.find.CLASS=function(bR,bS,bT){if(typeof bS.getElementsByClassName!=="undefined"&&!bT){return bS.getElementsByClassName(bR[1])}};e=null})();function bv(bR,bW,bV,bZ,bX,bY){for(var bT=0,bS=bZ.length;bT0){bU=e;break}}}e=e[bR]}bZ[bT]=bU}}}if(av.documentElement.contains){by.contains=function(bR,e){return bR!==e&&(bR.contains?bR.contains(e):true)}}else{if(av.documentElement.compareDocumentPosition){by.contains=function(bR,e){return !!(bR.compareDocumentPosition(e)&16)}}else{by.contains=function(){return false}}}by.isXML=function(e){var bR=(e?e.ownerDocument||e:0).documentElement;return bR?bR.nodeName!=="HTML":false};var bM=function(bS,e,bW){var bV,bX=[],bU="",bY=e.nodeType?[e]:e;while((bV=bE.match.PSEUDO.exec(bS))){bU+=bV[0];bS=bS.replace(bE.match.PSEUDO,"")}bS=bE.relative[bS]?bS+"*":bS;for(var bT=0,bR=bY.length;bT0){for(bB=bA;bB=0:b.filter(e,this).length>0:this.filter(e).length>0)},closest:function(by,bx){var bv=[],bw,e,bz=this[0];if(b.isArray(by)){var bB=1;while(bz&&bz.ownerDocument&&bz!==bx){for(bw=0;bw-1:b.find.matchesSelector(bz,by)){bv.push(bz);break}else{bz=bz.parentNode;if(!bz||!bz.ownerDocument||bz===bx||bz.nodeType===11){break}}}}bv=bv.length>1?b.unique(bv):bv;return this.pushStack(bv,"closest",by)},index:function(e){if(!e){return(this[0]&&this[0].parentNode)?this.prevAll().length:-1}if(typeof e==="string"){return b.inArray(this[0],b(e))}return b.inArray(e.jquery?e[0]:e,this)},add:function(e,bv){var bx=typeof e==="string"?b(e,bv):b.makeArray(e&&e.nodeType?[e]:e),bw=b.merge(this.get(),bx);return this.pushStack(C(bx[0])||C(bw[0])?bw:b.unique(bw))},andSelf:function(){return this.add(this.prevObject)}});function C(e){return !e||!e.parentNode||e.parentNode.nodeType===11}b.each({parent:function(bv){var e=bv.parentNode;return e&&e.nodeType!==11?e:null},parents:function(e){return b.dir(e,"parentNode")},parentsUntil:function(bv,e,bw){return b.dir(bv,"parentNode",bw)},next:function(e){return b.nth(e,2,"nextSibling")},prev:function(e){return b.nth(e,2,"previousSibling")},nextAll:function(e){return b.dir(e,"nextSibling")},prevAll:function(e){return b.dir(e,"previousSibling")},nextUntil:function(bv,e,bw){return b.dir(bv,"nextSibling",bw)},prevUntil:function(bv,e,bw){return b.dir(bv,"previousSibling",bw)},siblings:function(e){return b.sibling(e.parentNode.firstChild,e)},children:function(e){return b.sibling(e.firstChild)},contents:function(e){return b.nodeName(e,"iframe")?e.contentDocument||e.contentWindow.document:b.makeArray(e.childNodes)}},function(e,bv){b.fn[e]=function(by,bw){var bx=b.map(this,bv,by);if(!ab.test(e)){bw=by}if(bw&&typeof bw==="string"){bx=b.filter(bw,bx)}bx=this.length>1&&!ay[e]?b.unique(bx):bx;if((this.length>1||a9.test(bw))&&aq.test(e)){bx=bx.reverse()}return this.pushStack(bx,e,P.call(arguments).join(","))}});b.extend({filter:function(bw,e,bv){if(bv){bw=":not("+bw+")"}return e.length===1?b.find.matchesSelector(e[0],bw)?[e[0]]:[]:b.find.matches(bw,e)},dir:function(bw,bv,by){var e=[],bx=bw[bv];while(bx&&bx.nodeType!==9&&(by===L||bx.nodeType!==1||!b(bx).is(by))){if(bx.nodeType===1){e.push(bx)}bx=bx[bv]}return e},nth:function(by,e,bw,bx){e=e||1;var bv=0;for(;by;by=by[bw]){if(by.nodeType===1&&++bv===e){break}}return by},sibling:function(bw,bv){var e=[];for(;bw;bw=bw.nextSibling){if(bw.nodeType===1&&bw!==bv){e.push(bw)}}return e}});function aG(bx,bw,e){bw=bw||0;if(b.isFunction(bw)){return b.grep(bx,function(bz,by){var bA=!!bw.call(bz,by,bz);return bA===e})}else{if(bw.nodeType){return b.grep(bx,function(bz,by){return(bz===bw)===e})}else{if(typeof bw==="string"){var bv=b.grep(bx,function(by){return by.nodeType===1});if(bp.test(bw)){return b.filter(bw,bv,!e)}else{bw=b.filter(bw,bv)}}}}return b.grep(bx,function(bz,by){return(b.inArray(bz,bw)>=0)===e})}function a(e){var bw=aR.split("|"),bv=e.createDocumentFragment();if(bv.createElement){while(bw.length){bv.createElement(bw.pop())}}return bv}var aR="abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",ag=/ jQuery\d+="(?:\d+|null)"/g,ar=/^\s+/,R=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,d=/<([\w:]+)/,w=/",""],legend:[1,"
","
"],thead:[1,"","
"],tr:[2,"","
"],td:[3,"","
"],col:[2,"","
"],area:[1,"",""],_default:[0,"",""]},ac=a(av);ax.optgroup=ax.option;ax.tbody=ax.tfoot=ax.colgroup=ax.caption=ax.thead;ax.th=ax.td;if(!b.support.htmlSerialize){ax._default=[1,"div
","
"]}b.fn.extend({text:function(e){if(b.isFunction(e)){return this.each(function(bw){var bv=b(this);bv.text(e.call(this,bw,bv.text()))})}if(typeof e!=="object"&&e!==L){return this.empty().append((this[0]&&this[0].ownerDocument||av).createTextNode(e))}return b.text(this)},wrapAll:function(e){if(b.isFunction(e)){return this.each(function(bw){b(this).wrapAll(e.call(this,bw))})}if(this[0]){var bv=b(e,this[0].ownerDocument).eq(0).clone(true);if(this[0].parentNode){bv.insertBefore(this[0])}bv.map(function(){var bw=this;while(bw.firstChild&&bw.firstChild.nodeType===1){bw=bw.firstChild}return bw}).append(this)}return this},wrapInner:function(e){if(b.isFunction(e)){return this.each(function(bv){b(this).wrapInner(e.call(this,bv))})}return this.each(function(){var bv=b(this),bw=bv.contents();if(bw.length){bw.wrapAll(e)}else{bv.append(e)}})},wrap:function(e){var bv=b.isFunction(e);return this.each(function(bw){b(this).wrapAll(bv?e.call(this,bw):e)})},unwrap:function(){return this.parent().each(function(){if(!b.nodeName(this,"body")){b(this).replaceWith(this.childNodes)}}).end()},append:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1){this.appendChild(e)}})},prepend:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1){this.insertBefore(e,this.firstChild)}})},before:function(){if(this[0]&&this[0].parentNode){return this.domManip(arguments,false,function(bv){this.parentNode.insertBefore(bv,this)})}else{if(arguments.length){var e=b.clean(arguments);e.push.apply(e,this.toArray());return this.pushStack(e,"before",arguments)}}},after:function(){if(this[0]&&this[0].parentNode){return this.domManip(arguments,false,function(bv){this.parentNode.insertBefore(bv,this.nextSibling)})}else{if(arguments.length){var e=this.pushStack(this,"after",arguments);e.push.apply(e,b.clean(arguments));return e}}},remove:function(e,bx){for(var bv=0,bw;(bw=this[bv])!=null;bv++){if(!e||b.filter(e,[bw]).length){if(!bx&&bw.nodeType===1){b.cleanData(bw.getElementsByTagName("*"));b.cleanData([bw])}if(bw.parentNode){bw.parentNode.removeChild(bw)}}}return this},empty:function(){for(var e=0,bv;(bv=this[e])!=null;e++){if(bv.nodeType===1){b.cleanData(bv.getElementsByTagName("*"))}while(bv.firstChild){bv.removeChild(bv.firstChild)}}return this},clone:function(bv,e){bv=bv==null?false:bv;e=e==null?bv:e;return this.map(function(){return b.clone(this,bv,e)})},html:function(bx){if(bx===L){return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(ag,""):null}else{if(typeof bx==="string"&&!ae.test(bx)&&(b.support.leadingWhitespace||!ar.test(bx))&&!ax[(d.exec(bx)||["",""])[1].toLowerCase()]){bx=bx.replace(R,"<$1>");try{for(var bw=0,bv=this.length;bw1&&bw0?this.clone(true):this).get();b(bC[bA])[bv](by);bz=bz.concat(by)}return this.pushStack(bz,e,bC.selector)}}});function bg(e){if(typeof e.getElementsByTagName!=="undefined"){return e.getElementsByTagName("*")}else{if(typeof e.querySelectorAll!=="undefined"){return e.querySelectorAll("*")}else{return[]}}}function az(e){if(e.type==="checkbox"||e.type==="radio"){e.defaultChecked=e.checked}}function E(e){var bv=(e.nodeName||"").toLowerCase();if(bv==="input"){az(e)}else{if(bv!=="script"&&typeof e.getElementsByTagName!=="undefined"){b.grep(e.getElementsByTagName("input"),az)}}}function al(e){var bv=av.createElement("div");ac.appendChild(bv);bv.innerHTML=e.outerHTML;return bv.firstChild}b.extend({clone:function(by,bA,bw){var e,bv,bx,bz=b.support.html5Clone||!ah.test("<"+by.nodeName)?by.cloneNode(true):al(by);if((!b.support.noCloneEvent||!b.support.noCloneChecked)&&(by.nodeType===1||by.nodeType===11)&&!b.isXMLDoc(by)){ai(by,bz);e=bg(by);bv=bg(bz);for(bx=0;e[bx];++bx){if(bv[bx]){ai(e[bx],bv[bx])}}}if(bA){t(by,bz);if(bw){e=bg(by);bv=bg(bz);for(bx=0;e[bx];++bx){t(e[bx],bv[bx])}}}e=bv=null;return bz},clean:function(bw,by,bH,bA){var bF;by=by||av;if(typeof by.createElement==="undefined"){by=by.ownerDocument||by[0]&&by[0].ownerDocument||av}var bI=[],bB;for(var bE=0,bz;(bz=bw[bE])!=null;bE++){if(typeof bz==="number"){bz+=""}if(!bz){continue}if(typeof bz==="string"){if(!W.test(bz)){bz=by.createTextNode(bz)}else{bz=bz.replace(R,"<$1>");var bK=(d.exec(bz)||["",""])[1].toLowerCase(),bx=ax[bK]||ax._default,bD=bx[0],bv=by.createElement("div");if(by===av){ac.appendChild(bv)}else{a(by).appendChild(bv)}bv.innerHTML=bx[1]+bz+bx[2];while(bD--){bv=bv.lastChild}if(!b.support.tbody){var e=w.test(bz),bC=bK==="table"&&!e?bv.firstChild&&bv.firstChild.childNodes:bx[1]===""&&!e?bv.childNodes:[];for(bB=bC.length-1;bB>=0;--bB){if(b.nodeName(bC[bB],"tbody")&&!bC[bB].childNodes.length){bC[bB].parentNode.removeChild(bC[bB])}}}if(!b.support.leadingWhitespace&&ar.test(bz)){bv.insertBefore(by.createTextNode(ar.exec(bz)[0]),bv.firstChild)}bz=bv.childNodes}}var bG;if(!b.support.appendChecked){if(bz[0]&&typeof(bG=bz.length)==="number"){for(bB=0;bB=0){return bx+"px"}}else{return bx}}}});if(!b.support.opacity){b.cssHooks.opacity={get:function(bv,e){return au.test((e&&bv.currentStyle?bv.currentStyle.filter:bv.style.filter)||"")?(parseFloat(RegExp.$1)/100)+"":e?"1":""},set:function(by,bz){var bx=by.style,bv=by.currentStyle,e=b.isNumeric(bz)?"alpha(opacity="+bz*100+")":"",bw=bv&&bv.filter||bx.filter||"";bx.zoom=1;if(bz>=1&&b.trim(bw.replace(ak,""))===""){bx.removeAttribute("filter");if(bv&&!bv.filter){return}}bx.filter=ak.test(bw)?bw.replace(ak,e):bw+" "+e}}}b(function(){if(!b.support.reliableMarginRight){b.cssHooks.marginRight={get:function(bw,bv){var e;b.swap(bw,{display:"inline-block"},function(){if(bv){e=Z(bw,"margin-right","marginRight")}else{e=bw.style.marginRight}});return e}}}});if(av.defaultView&&av.defaultView.getComputedStyle){aI=function(by,bw){var bv,bx,e;bw=bw.replace(z,"-$1").toLowerCase();if((bx=by.ownerDocument.defaultView)&&(e=bx.getComputedStyle(by,null))){bv=e.getPropertyValue(bw);if(bv===""&&!b.contains(by.ownerDocument.documentElement,by)){bv=b.style(by,bw)}}return bv}}if(av.documentElement.currentStyle){aX=function(bz,bw){var bA,e,by,bv=bz.currentStyle&&bz.currentStyle[bw],bx=bz.style;if(bv===null&&bx&&(by=bx[bw])){bv=by}if(!bc.test(bv)&&bn.test(bv)){bA=bx.left;e=bz.runtimeStyle&&bz.runtimeStyle.left;if(e){bz.runtimeStyle.left=bz.currentStyle.left}bx.left=bw==="fontSize"?"1em":(bv||0);bv=bx.pixelLeft+"px";bx.left=bA;if(e){bz.runtimeStyle.left=e}}return bv===""?"auto":bv}}Z=aI||aX;function p(by,bw,bv){var bA=bw==="width"?by.offsetWidth:by.offsetHeight,bz=bw==="width"?an:a1,bx=0,e=bz.length;if(bA>0){if(bv!=="border"){for(;bx)<[^<]*)*<\/script>/gi,q=/^(?:select|textarea)/i,h=/\s+/,br=/([?&])_=[^&]*/,K=/^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,A=b.fn.load,aa={},r={},aE,s,aV=["*/"]+["*"];try{aE=bl.href}catch(aw){aE=av.createElement("a");aE.href="";aE=aE.href}s=K.exec(aE.toLowerCase())||[];function f(e){return function(by,bA){if(typeof by!=="string"){bA=by;by="*"}if(b.isFunction(bA)){var bx=by.toLowerCase().split(h),bw=0,bz=bx.length,bv,bB,bC;for(;bw=0){var e=bw.slice(by,bw.length);bw=bw.slice(0,by)}var bx="GET";if(bz){if(b.isFunction(bz)){bA=bz;bz=L}else{if(typeof bz==="object"){bz=b.param(bz,b.ajaxSettings.traditional);bx="POST"}}}var bv=this;b.ajax({url:bw,type:bx,dataType:"html",data:bz,complete:function(bC,bB,bD){bD=bC.responseText;if(bC.isResolved()){bC.done(function(bE){bD=bE});bv.html(e?b("
").append(bD.replace(a6,"")).find(e):bD)}if(bA){bv.each(bA,[bD,bB,bC])}}});return this},serialize:function(){return b.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?b.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||q.test(this.nodeName)||aZ.test(this.type))}).map(function(e,bv){var bw=b(this).val();return bw==null?null:b.isArray(bw)?b.map(bw,function(by,bx){return{name:bv.name,value:by.replace(bs,"\r\n")}}):{name:bv.name,value:bw.replace(bs,"\r\n")}}).get()}});b.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(e,bv){b.fn[bv]=function(bw){return this.on(bv,bw)}});b.each(["get","post"],function(e,bv){b[bv]=function(bw,by,bz,bx){if(b.isFunction(by)){bx=bx||bz;bz=by;by=L}return b.ajax({type:bv,url:bw,data:by,success:bz,dataType:bx})}});b.extend({getScript:function(e,bv){return b.get(e,L,bv,"script")},getJSON:function(e,bv,bw){return b.get(e,bv,bw,"json")},ajaxSetup:function(bv,e){if(e){am(bv,b.ajaxSettings)}else{e=bv;bv=b.ajaxSettings}am(bv,e);return bv},ajaxSettings:{url:aE,isLocal:aM.test(s[1]),global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,accepts:{xml:"application/xml, text/xml",html:"text/html",text:"text/plain",json:"application/json, text/javascript","*":aV},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText"},converters:{"* text":bb.String,"text html":true,"text json":b.parseJSON,"text xml":b.parseXML},flatOptions:{context:true,url:true}},ajaxPrefilter:f(aa),ajaxTransport:f(r),ajax:function(bz,bx){if(typeof bz==="object"){bx=bz;bz=L}bx=bx||{};var bD=b.ajaxSetup({},bx),bS=bD.context||bD,bG=bS!==bD&&(bS.nodeType||bS instanceof b)?b(bS):b.event,bR=b.Deferred(),bN=b.Callbacks("once memory"),bB=bD.statusCode||{},bC,bH={},bO={},bQ,by,bL,bE,bI,bA=0,bw,bK,bJ={readyState:0,setRequestHeader:function(bT,bU){if(!bA){var e=bT.toLowerCase();bT=bO[e]=bO[e]||bT;bH[bT]=bU}return this},getAllResponseHeaders:function(){return bA===2?bQ:null},getResponseHeader:function(bT){var e;if(bA===2){if(!by){by={};while((e=aD.exec(bQ))){by[e[1].toLowerCase()]=e[2]}}e=by[bT.toLowerCase()]}return e===L?null:e},overrideMimeType:function(e){if(!bA){bD.mimeType=e}return this},abort:function(e){e=e||"abort";if(bL){bL.abort(e)}bF(0,e);return this}};function bF(bZ,bU,b0,bW){if(bA===2){return}bA=2;if(bE){clearTimeout(bE)}bL=L;bQ=bW||"";bJ.readyState=bZ>0?4:0;var bT,b4,b3,bX=bU,bY=b0?bj(bD,bJ,b0):L,bV,b2;if(bZ>=200&&bZ<300||bZ===304){if(bD.ifModified){if((bV=bJ.getResponseHeader("Last-Modified"))){b.lastModified[bC]=bV}if((b2=bJ.getResponseHeader("Etag"))){b.etag[bC]=b2}}if(bZ===304){bX="notmodified";bT=true}else{try{b4=G(bD,bY);bX="success";bT=true}catch(b1){bX="parsererror";b3=b1}}}else{b3=bX;if(!bX||bZ){bX="error";if(bZ<0){bZ=0}}}bJ.status=bZ;bJ.statusText=""+(bU||bX);if(bT){bR.resolveWith(bS,[b4,bX,bJ])}else{bR.rejectWith(bS,[bJ,bX,b3])}bJ.statusCode(bB);bB=L;if(bw){bG.trigger("ajax"+(bT?"Success":"Error"),[bJ,bD,bT?b4:b3])}bN.fireWith(bS,[bJ,bX]);if(bw){bG.trigger("ajaxComplete",[bJ,bD]);if(!(--b.active)){b.event.trigger("ajaxStop")}}}bR.promise(bJ);bJ.success=bJ.done;bJ.error=bJ.fail;bJ.complete=bN.add;bJ.statusCode=function(bT){if(bT){var e;if(bA<2){for(e in bT){bB[e]=[bB[e],bT[e]]}}else{e=bT[bJ.status];bJ.then(e,e)}}return this};bD.url=((bz||bD.url)+"").replace(bq,"").replace(c,s[1]+"//");bD.dataTypes=b.trim(bD.dataType||"*").toLowerCase().split(h);if(bD.crossDomain==null){bI=K.exec(bD.url.toLowerCase());bD.crossDomain=!!(bI&&(bI[1]!=s[1]||bI[2]!=s[2]||(bI[3]||(bI[1]==="http:"?80:443))!=(s[3]||(s[1]==="http:"?80:443))))}if(bD.data&&bD.processData&&typeof bD.data!=="string"){bD.data=b.param(bD.data,bD.traditional)}aW(aa,bD,bx,bJ);if(bA===2){return false}bw=bD.global;bD.type=bD.type.toUpperCase();bD.hasContent=!aQ.test(bD.type);if(bw&&b.active++===0){b.event.trigger("ajaxStart")}if(!bD.hasContent){if(bD.data){bD.url+=(M.test(bD.url)?"&":"?")+bD.data;delete bD.data}bC=bD.url;if(bD.cache===false){var bv=b.now(),bP=bD.url.replace(br,"$1_="+bv);bD.url=bP+((bP===bD.url)?(M.test(bD.url)?"&":"?")+"_="+bv:"")}}if(bD.data&&bD.hasContent&&bD.contentType!==false||bx.contentType){bJ.setRequestHeader("Content-Type",bD.contentType)}if(bD.ifModified){bC=bC||bD.url;if(b.lastModified[bC]){bJ.setRequestHeader("If-Modified-Since",b.lastModified[bC])}if(b.etag[bC]){bJ.setRequestHeader("If-None-Match",b.etag[bC])}}bJ.setRequestHeader("Accept",bD.dataTypes[0]&&bD.accepts[bD.dataTypes[0]]?bD.accepts[bD.dataTypes[0]]+(bD.dataTypes[0]!=="*"?", "+aV+"; q=0.01":""):bD.accepts["*"]);for(bK in bD.headers){bJ.setRequestHeader(bK,bD.headers[bK])}if(bD.beforeSend&&(bD.beforeSend.call(bS,bJ,bD)===false||bA===2)){bJ.abort();return false}for(bK in {success:1,error:1,complete:1}){bJ[bK](bD[bK])}bL=aW(r,bD,bx,bJ);if(!bL){bF(-1,"No Transport")}else{bJ.readyState=1;if(bw){bG.trigger("ajaxSend",[bJ,bD])}if(bD.async&&bD.timeout>0){bE=setTimeout(function(){bJ.abort("timeout")},bD.timeout)}try{bA=1;bL.send(bH,bF)}catch(bM){if(bA<2){bF(-1,bM)}else{throw bM}}}return bJ},param:function(e,bw){var bv=[],by=function(bz,bA){bA=b.isFunction(bA)?bA():bA;bv[bv.length]=encodeURIComponent(bz)+"="+encodeURIComponent(bA)};if(bw===L){bw=b.ajaxSettings.traditional}if(b.isArray(e)||(e.jquery&&!b.isPlainObject(e))){b.each(e,function(){by(this.name,this.value)})}else{for(var bx in e){v(bx,e[bx],bw,by)}}return bv.join("&").replace(k,"+")}});function v(bw,by,bv,bx){if(b.isArray(by)){b.each(by,function(bA,bz){if(bv||ap.test(bw)){bx(bw,bz)}else{v(bw+"["+(typeof bz==="object"||b.isArray(bz)?bA:"")+"]",bz,bv,bx)}})}else{if(!bv&&by!=null&&typeof by==="object"){for(var e in by){v(bw+"["+e+"]",by[e],bv,bx)}}else{bx(bw,by)}}}b.extend({active:0,lastModified:{},etag:{}});function bj(bD,bC,bz){var bv=bD.contents,bB=bD.dataTypes,bw=bD.responseFields,by,bA,bx,e;for(bA in bw){if(bA in bz){bC[bw[bA]]=bz[bA]}}while(bB[0]==="*"){bB.shift();if(by===L){by=bD.mimeType||bC.getResponseHeader("content-type")}}if(by){for(bA in bv){if(bv[bA]&&bv[bA].test(by)){bB.unshift(bA);break}}}if(bB[0] in bz){bx=bB[0]}else{for(bA in bz){if(!bB[0]||bD.converters[bA+" "+bB[0]]){bx=bA;break}if(!e){e=bA}}bx=bx||e}if(bx){if(bx!==bB[0]){bB.unshift(bx)}return bz[bx]}}function G(bH,bz){if(bH.dataFilter){bz=bH.dataFilter(bz,bH.dataType)}var bD=bH.dataTypes,bG={},bA,bE,bw=bD.length,bB,bC=bD[0],bx,by,bF,bv,e;for(bA=1;bA=bw.duration+this.startTime){this.now=this.end;this.pos=this.state=1;this.update();bw.animatedProperties[this.prop]=true;for(bA in bw.animatedProperties){if(bw.animatedProperties[bA]!==true){e=false}}if(e){if(bw.overflow!=null&&!b.support.shrinkWrapBlocks){b.each(["","X","Y"],function(bC,bD){bz.style["overflow"+bD]=bw.overflow[bC]})}if(bw.hide){b(bz).hide()}if(bw.hide||bw.show){for(bA in bw.animatedProperties){b.style(bz,bA,bw.orig[bA]);b.removeData(bz,"fxshow"+bA,true);b.removeData(bz,"toggle"+bA,true)}}bv=bw.complete;if(bv){bw.complete=false;bv.call(bz)}}return false}else{if(bw.duration==Infinity){this.now=bx}else{bB=bx-this.startTime;this.state=bB/bw.duration;this.pos=b.easing[bw.animatedProperties[this.prop]](this.state,bB,0,1,bw.duration);this.now=this.start+((this.end-this.start)*this.pos)}this.update()}return true}};b.extend(b.fx,{tick:function(){var bw,bv=b.timers,e=0;for(;e").appendTo(e),bw=bv.css("display");bv.remove();if(bw==="none"||bw===""){if(!a8){a8=av.createElement("iframe");a8.frameBorder=a8.width=a8.height=0}e.appendChild(a8);if(!m||!a8.createElement){m=(a8.contentWindow||a8.contentDocument).document;m.write((av.compatMode==="CSS1Compat"?"":"")+"");m.close()}bv=m.createElement(bx);m.body.appendChild(bv);bw=b.css(bv,"display");e.removeChild(a8)}Q[bx]=bw}return Q[bx]}var V=/^t(?:able|d|h)$/i,ad=/^(?:body|html)$/i;if("getBoundingClientRect" in av.documentElement){b.fn.offset=function(bI){var by=this[0],bB;if(bI){return this.each(function(e){b.offset.setOffset(this,bI,e)})}if(!by||!by.ownerDocument){return null}if(by===by.ownerDocument.body){return b.offset.bodyOffset(by)}try{bB=by.getBoundingClientRect()}catch(bF){}var bH=by.ownerDocument,bw=bH.documentElement;if(!bB||!b.contains(bw,by)){return bB?{top:bB.top,left:bB.left}:{top:0,left:0}}var bC=bH.body,bD=aK(bH),bA=bw.clientTop||bC.clientTop||0,bE=bw.clientLeft||bC.clientLeft||0,bv=bD.pageYOffset||b.support.boxModel&&bw.scrollTop||bC.scrollTop,bz=bD.pageXOffset||b.support.boxModel&&bw.scrollLeft||bC.scrollLeft,bG=bB.top+bv-bA,bx=bB.left+bz-bE;return{top:bG,left:bx}}}else{b.fn.offset=function(bF){var bz=this[0];if(bF){return this.each(function(bG){b.offset.setOffset(this,bF,bG)})}if(!bz||!bz.ownerDocument){return null}if(bz===bz.ownerDocument.body){return b.offset.bodyOffset(bz)}var bC,bw=bz.offsetParent,bv=bz,bE=bz.ownerDocument,bx=bE.documentElement,bA=bE.body,bB=bE.defaultView,e=bB?bB.getComputedStyle(bz,null):bz.currentStyle,bD=bz.offsetTop,by=bz.offsetLeft;while((bz=bz.parentNode)&&bz!==bA&&bz!==bx){if(b.support.fixedPosition&&e.position==="fixed"){break}bC=bB?bB.getComputedStyle(bz,null):bz.currentStyle;bD-=bz.scrollTop;by-=bz.scrollLeft;if(bz===bw){bD+=bz.offsetTop;by+=bz.offsetLeft;if(b.support.doesNotAddBorder&&!(b.support.doesAddBorderForTableAndCells&&V.test(bz.nodeName))){bD+=parseFloat(bC.borderTopWidth)||0;by+=parseFloat(bC.borderLeftWidth)||0}bv=bw;bw=bz.offsetParent}if(b.support.subtractsBorderForOverflowNotVisible&&bC.overflow!=="visible"){bD+=parseFloat(bC.borderTopWidth)||0;by+=parseFloat(bC.borderLeftWidth)||0}e=bC}if(e.position==="relative"||e.position==="static"){bD+=bA.offsetTop;by+=bA.offsetLeft}if(b.support.fixedPosition&&e.position==="fixed"){bD+=Math.max(bx.scrollTop,bA.scrollTop);by+=Math.max(bx.scrollLeft,bA.scrollLeft)}return{top:bD,left:by}}}b.offset={bodyOffset:function(e){var bw=e.offsetTop,bv=e.offsetLeft;if(b.support.doesNotIncludeMarginInBodyOffset){bw+=parseFloat(b.css(e,"marginTop"))||0;bv+=parseFloat(b.css(e,"marginLeft"))||0}return{top:bw,left:bv}},setOffset:function(bx,bG,bA){var bB=b.css(bx,"position");if(bB==="static"){bx.style.position="relative"}var bz=b(bx),bv=bz.offset(),e=b.css(bx,"top"),bE=b.css(bx,"left"),bF=(bB==="absolute"||bB==="fixed")&&b.inArray("auto",[e,bE])>-1,bD={},bC={},bw,by;if(bF){bC=bz.position();bw=bC.top;by=bC.left}else{bw=parseFloat(e)||0;by=parseFloat(bE)||0}if(b.isFunction(bG)){bG=bG.call(bx,bA,bv)}if(bG.top!=null){bD.top=(bG.top-bv.top)+bw}if(bG.left!=null){bD.left=(bG.left-bv.left)+by}if("using" in bG){bG.using.call(bx,bD)}else{bz.css(bD)}}};b.fn.extend({position:function(){if(!this[0]){return null}var bw=this[0],bv=this.offsetParent(),bx=this.offset(),e=ad.test(bv[0].nodeName)?{top:0,left:0}:bv.offset();bx.top-=parseFloat(b.css(bw,"marginTop"))||0;bx.left-=parseFloat(b.css(bw,"marginLeft"))||0;e.top+=parseFloat(b.css(bv[0],"borderTopWidth"))||0;e.left+=parseFloat(b.css(bv[0],"borderLeftWidth"))||0;return{top:bx.top-e.top,left:bx.left-e.left}},offsetParent:function(){return this.map(function(){var e=this.offsetParent||av.body;while(e&&(!ad.test(e.nodeName)&&b.css(e,"position")==="static")){e=e.offsetParent}return e})}});b.each(["Left","Top"],function(bv,e){var bw="scroll"+e;b.fn[bw]=function(bz){var bx,by;if(bz===L){bx=this[0];if(!bx){return null}by=aK(bx);return by?("pageXOffset" in by)?by[bv?"pageYOffset":"pageXOffset"]:b.support.boxModel&&by.document.documentElement[bw]||by.document.body[bw]:bx[bw]}return this.each(function(){by=aK(this);if(by){by.scrollTo(!bv?bz:b(by).scrollLeft(),bv?bz:b(by).scrollTop())}else{this[bw]=bz}})}});function aK(e){return b.isWindow(e)?e:e.nodeType===9?e.defaultView||e.parentWindow:false}b.each(["Height","Width"],function(bv,e){var bw=e.toLowerCase();b.fn["inner"+e]=function(){var bx=this[0];return bx?bx.style?parseFloat(b.css(bx,bw,"padding")):this[bw]():null};b.fn["outer"+e]=function(by){var bx=this[0];return bx?bx.style?parseFloat(b.css(bx,bw,by?"margin":"border")):this[bw]():null};b.fn[bw]=function(bz){var bA=this[0];if(!bA){return bz==null?null:this}if(b.isFunction(bz)){return this.each(function(bE){var bD=b(this);bD[bw](bz.call(this,bE,bD[bw]()))})}if(b.isWindow(bA)){var bB=bA.document.documentElement["client"+e],bx=bA.document.body;return bA.document.compatMode==="CSS1Compat"&&bB||bx&&bx["client"+e]||bB}else{if(bA.nodeType===9){return Math.max(bA.documentElement["client"+e],bA.body["scroll"+e],bA.documentElement["scroll"+e],bA.body["offset"+e],bA.documentElement["offset"+e])}else{if(bz===L){var bC=b.css(bA,bw),by=parseFloat(bC);return b.isNumeric(by)?by:bC}else{return this.css(bw,typeof bz==="string"?bz:bz+"px")}}}}});bb.jQuery=bb.$=b;if(typeof define==="function"&&define.amd&&define.amd.jQuery){define("jquery",[],function(){return b})}})(window);/* * jQuery UI 1.8.18 * * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about) * Dual licensed under the MIT or GPL Version 2 licenses. * http://jquery.org/license * * http://docs.jquery.com/UI */ (function(a,d){a.ui=a.ui||{};if(a.ui.version){return}a.extend(a.ui,{version:"1.8.18",keyCode:{ALT:18,BACKSPACE:8,CAPS_LOCK:20,COMMA:188,COMMAND:91,COMMAND_LEFT:91,COMMAND_RIGHT:93,CONTROL:17,DELETE:46,DOWN:40,END:35,ENTER:13,ESCAPE:27,HOME:36,INSERT:45,LEFT:37,MENU:93,NUMPAD_ADD:107,NUMPAD_DECIMAL:110,NUMPAD_DIVIDE:111,NUMPAD_ENTER:108,NUMPAD_MULTIPLY:106,NUMPAD_SUBTRACT:109,PAGE_DOWN:34,PAGE_UP:33,PERIOD:190,RIGHT:39,SHIFT:16,SPACE:32,TAB:9,UP:38,WINDOWS:91}});a.fn.extend({propAttr:a.fn.prop||a.fn.attr,_focus:a.fn.focus,focus:function(e,f){return typeof e==="number"?this.each(function(){var g=this;setTimeout(function(){a(g).focus();if(f){f.call(g)}},e)}):this._focus.apply(this,arguments)},scrollParent:function(){var e;if((a.browser.msie&&(/(static|relative)/).test(this.css("position")))||(/absolute/).test(this.css("position"))){e=this.parents().filter(function(){return(/(relative|absolute|fixed)/).test(a.curCSS(this,"position",1))&&(/(auto|scroll)/).test(a.curCSS(this,"overflow",1)+a.curCSS(this,"overflow-y",1)+a.curCSS(this,"overflow-x",1))}).eq(0)}else{e=this.parents().filter(function(){return(/(auto|scroll)/).test(a.curCSS(this,"overflow",1)+a.curCSS(this,"overflow-y",1)+a.curCSS(this,"overflow-x",1))}).eq(0)}return(/fixed/).test(this.css("position"))||!e.length?a(document):e},zIndex:function(h){if(h!==d){return this.css("zIndex",h)}if(this.length){var f=a(this[0]),e,g;while(f.length&&f[0]!==document){e=f.css("position");if(e==="absolute"||e==="relative"||e==="fixed"){g=parseInt(f.css("zIndex"),10);if(!isNaN(g)&&g!==0){return g}}f=f.parent()}}return 0},disableSelection:function(){return this.bind((a.support.selectstart?"selectstart":"mousedown")+".ui-disableSelection",function(e){e.preventDefault()})},enableSelection:function(){return this.unbind(".ui-disableSelection")}});a.each(["Width","Height"],function(g,e){var f=e==="Width"?["Left","Right"]:["Top","Bottom"],h=e.toLowerCase(),k={innerWidth:a.fn.innerWidth,innerHeight:a.fn.innerHeight,outerWidth:a.fn.outerWidth,outerHeight:a.fn.outerHeight};function j(m,l,i,n){a.each(f,function(){l-=parseFloat(a.curCSS(m,"padding"+this,true))||0;if(i){l-=parseFloat(a.curCSS(m,"border"+this+"Width",true))||0}if(n){l-=parseFloat(a.curCSS(m,"margin"+this,true))||0}});return l}a.fn["inner"+e]=function(i){if(i===d){return k["inner"+e].call(this)}return this.each(function(){a(this).css(h,j(this,i)+"px")})};a.fn["outer"+e]=function(i,l){if(typeof i!=="number"){return k["outer"+e].call(this,i)}return this.each(function(){a(this).css(h,j(this,i,true,l)+"px")})}});function c(g,e){var j=g.nodeName.toLowerCase();if("area"===j){var i=g.parentNode,h=i.name,f;if(!g.href||!h||i.nodeName.toLowerCase()!=="map"){return false}f=a("img[usemap=#"+h+"]")[0];return !!f&&b(f)}return(/input|select|textarea|button|object/.test(j)?!g.disabled:"a"==j?g.href||e:e)&&b(g)}function b(e){return !a(e).parents().andSelf().filter(function(){return a.curCSS(this,"visibility")==="hidden"||a.expr.filters.hidden(this)}).length}a.extend(a.expr[":"],{data:function(g,f,e){return !!a.data(g,e[3])},focusable:function(e){return c(e,!isNaN(a.attr(e,"tabindex")))},tabbable:function(g){var e=a.attr(g,"tabindex"),f=isNaN(e);return(f||e>=0)&&c(g,!f)}});a(function(){var e=document.body,f=e.appendChild(f=document.createElement("div"));f.offsetHeight;a.extend(f.style,{minHeight:"100px",height:"auto",padding:0,borderWidth:0});a.support.minHeight=f.offsetHeight===100;a.support.selectstart="onselectstart" in f;e.removeChild(f).style.display="none"});a.extend(a.ui,{plugin:{add:function(f,g,j){var h=a.ui[f].prototype;for(var e in j){h.plugins[e]=h.plugins[e]||[];h.plugins[e].push([g,j[e]])}},call:function(e,g,f){var j=e.plugins[g];if(!j||!e.element[0].parentNode){return}for(var h=0;h0){return true}h[e]=1;g=(h[e]>0);h[e]=0;return g},isOverAxis:function(f,e,g){return(f>e)&&(f<(e+g))},isOver:function(j,f,i,h,e,g){return a.ui.isOverAxis(j,i,e)&&a.ui.isOverAxis(f,h,g)}})})(jQuery);/* * jQuery UI Widget 1.8.18 * * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about) * Dual licensed under the MIT or GPL Version 2 licenses. * http://jquery.org/license * * http://docs.jquery.com/UI/Widget */ (function(b,d){if(b.cleanData){var c=b.cleanData;b.cleanData=function(f){for(var g=0,h;(h=f[g])!=null;g++){try{b(h).triggerHandler("remove")}catch(j){}}c(f)}}else{var a=b.fn.remove;b.fn.remove=function(e,f){return this.each(function(){if(!f){if(!e||b.filter(e,[this]).length){b("*",this).add([this]).each(function(){try{b(this).triggerHandler("remove")}catch(g){}})}}return a.call(b(this),e,f)})}}b.widget=function(f,h,e){var g=f.split(".")[0],j;f=f.split(".")[1];j=g+"-"+f;if(!e){e=h;h=b.Widget}b.expr[":"][j]=function(k){return !!b.data(k,f)};b[g]=b[g]||{};b[g][f]=function(k,l){if(arguments.length){this._createWidget(k,l)}};var i=new h();i.options=b.extend(true,{},i.options);b[g][f].prototype=b.extend(true,i,{namespace:g,widgetName:f,widgetEventPrefix:b[g][f].prototype.widgetEventPrefix||f,widgetBaseClass:j},e);b.widget.bridge(f,b[g][f])};b.widget.bridge=function(f,e){b.fn[f]=function(i){var g=typeof i==="string",h=Array.prototype.slice.call(arguments,1),j=this;i=!g&&h.length?b.extend.apply(null,[true,i].concat(h)):i;if(g&&i.charAt(0)==="_"){return j}if(g){this.each(function(){var k=b.data(this,f),l=k&&b.isFunction(k[i])?k[i].apply(k,h):k;if(l!==k&&l!==d){j=l;return false}})}else{this.each(function(){var k=b.data(this,f);if(k){k.option(i||{})._init()}else{b.data(this,f,new e(i,this))}})}return j}};b.Widget=function(e,f){if(arguments.length){this._createWidget(e,f)}};b.Widget.prototype={widgetName:"widget",widgetEventPrefix:"",options:{disabled:false},_createWidget:function(f,g){b.data(g,this.widgetName,this);this.element=b(g);this.options=b.extend(true,{},this.options,this._getCreateOptions(),f);var e=this;this.element.bind("remove."+this.widgetName,function(){e.destroy()});this._create();this._trigger("create");this._init()},_getCreateOptions:function(){return b.metadata&&b.metadata.get(this.element[0])[this.widgetName]},_create:function(){},_init:function(){},destroy:function(){this.element.unbind("."+this.widgetName).removeData(this.widgetName);this.widget().unbind("."+this.widgetName).removeAttr("aria-disabled").removeClass(this.widgetBaseClass+"-disabled ui-state-disabled")},widget:function(){return this.element},option:function(f,g){var e=f;if(arguments.length===0){return b.extend({},this.options)}if(typeof f==="string"){if(g===d){return this.options[f]}e={};e[f]=g}this._setOptions(e);return this},_setOptions:function(f){var e=this;b.each(f,function(g,h){e._setOption(g,h)});return this},_setOption:function(e,f){this.options[e]=f;if(e==="disabled"){this.widget()[f?"addClass":"removeClass"](this.widgetBaseClass+"-disabled ui-state-disabled").attr("aria-disabled",f)}return this},enable:function(){return this._setOption("disabled",false)},disable:function(){return this._setOption("disabled",true)},_trigger:function(e,f,g){var j,i,h=this.options[e];g=g||{};f=b.Event(f);f.type=(e===this.widgetEventPrefix?e:this.widgetEventPrefix+e).toLowerCase();f.target=this.element[0];i=f.originalEvent;if(i){for(j in i){if(!(j in f)){f[j]=i[j]}}}this.element.trigger(f,g);return !(b.isFunction(h)&&h.call(this.element[0],f,g)===false||f.isDefaultPrevented())}}})(jQuery);/* * jQuery UI Mouse 1.8.18 * * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about) * Dual licensed under the MIT or GPL Version 2 licenses. * http://jquery.org/license * * http://docs.jquery.com/UI/Mouse * * Depends: * jquery.ui.widget.js */ (function(b,c){var a=false;b(document).mouseup(function(d){a=false});b.widget("ui.mouse",{options:{cancel:":input,option",distance:1,delay:0},_mouseInit:function(){var d=this;this.element.bind("mousedown."+this.widgetName,function(e){return d._mouseDown(e)}).bind("click."+this.widgetName,function(e){if(true===b.data(e.target,d.widgetName+".preventClickEvent")){b.removeData(e.target,d.widgetName+".preventClickEvent");e.stopImmediatePropagation();return false}});this.started=false},_mouseDestroy:function(){this.element.unbind("."+this.widgetName)},_mouseDown:function(f){if(a){return}(this._mouseStarted&&this._mouseUp(f));this._mouseDownEvent=f;var e=this,g=(f.which==1),d=(typeof this.options.cancel=="string"&&f.target.nodeName?b(f.target).closest(this.options.cancel).length:false);if(!g||d||!this._mouseCapture(f)){return true}this.mouseDelayMet=!this.options.delay;if(!this.mouseDelayMet){this._mouseDelayTimer=setTimeout(function(){e.mouseDelayMet=true},this.options.delay)}if(this._mouseDistanceMet(f)&&this._mouseDelayMet(f)){this._mouseStarted=(this._mouseStart(f)!==false);if(!this._mouseStarted){f.preventDefault();return true}}if(true===b.data(f.target,this.widgetName+".preventClickEvent")){b.removeData(f.target,this.widgetName+".preventClickEvent")}this._mouseMoveDelegate=function(h){return e._mouseMove(h)};this._mouseUpDelegate=function(h){return e._mouseUp(h)};b(document).bind("mousemove."+this.widgetName,this._mouseMoveDelegate).bind("mouseup."+this.widgetName,this._mouseUpDelegate);f.preventDefault();a=true;return true},_mouseMove:function(d){if(b.browser.msie&&!(document.documentMode>=9)&&!d.button){return this._mouseUp(d)}if(this._mouseStarted){this._mouseDrag(d);return d.preventDefault()}if(this._mouseDistanceMet(d)&&this._mouseDelayMet(d)){this._mouseStarted=(this._mouseStart(this._mouseDownEvent,d)!==false);(this._mouseStarted?this._mouseDrag(d):this._mouseUp(d))}return !this._mouseStarted},_mouseUp:function(d){b(document).unbind("mousemove."+this.widgetName,this._mouseMoveDelegate).unbind("mouseup."+this.widgetName,this._mouseUpDelegate);if(this._mouseStarted){this._mouseStarted=false;if(d.target==this._mouseDownEvent.target){b.data(d.target,this.widgetName+".preventClickEvent",true)}this._mouseStop(d)}return false},_mouseDistanceMet:function(d){return(Math.max(Math.abs(this._mouseDownEvent.pageX-d.pageX),Math.abs(this._mouseDownEvent.pageY-d.pageY))>=this.options.distance)},_mouseDelayMet:function(d){return this.mouseDelayMet},_mouseStart:function(d){},_mouseDrag:function(d){},_mouseStop:function(d){},_mouseCapture:function(d){return true}})})(jQuery);(function(c,d){c.widget("ui.resizable",c.ui.mouse,{widgetEventPrefix:"resize",options:{alsoResize:false,animate:false,animateDuration:"slow",animateEasing:"swing",aspectRatio:false,autoHide:false,containment:false,ghost:false,grid:false,handles:"e,s,se",helper:false,maxHeight:null,maxWidth:null,minHeight:10,minWidth:10,zIndex:1000},_create:function(){var f=this,k=this.options;this.element.addClass("ui-resizable");c.extend(this,{_aspectRatio:!!(k.aspectRatio),aspectRatio:k.aspectRatio,originalElement:this.element,_proportionallyResizeElements:[],_helper:k.helper||k.ghost||k.animate?k.helper||"ui-resizable-helper":null});if(this.element[0].nodeName.match(/canvas|textarea|input|select|button|img/i)){this.element.wrap(c('
').css({position:this.element.css("position"),width:this.element.outerWidth(),height:this.element.outerHeight(),top:this.element.css("top"),left:this.element.css("left")}));this.element=this.element.parent().data("resizable",this.element.data("resizable"));this.elementIsWrapper=true;this.element.css({marginLeft:this.originalElement.css("marginLeft"),marginTop:this.originalElement.css("marginTop"),marginRight:this.originalElement.css("marginRight"),marginBottom:this.originalElement.css("marginBottom")});this.originalElement.css({marginLeft:0,marginTop:0,marginRight:0,marginBottom:0});this.originalResizeStyle=this.originalElement.css("resize");this.originalElement.css("resize","none");this._proportionallyResizeElements.push(this.originalElement.css({position:"static",zoom:1,display:"block"}));this.originalElement.css({margin:this.originalElement.css("margin")});this._proportionallyResize()}this.handles=k.handles||(!c(".ui-resizable-handle",this.element).length?"e,s,se":{n:".ui-resizable-n",e:".ui-resizable-e",s:".ui-resizable-s",w:".ui-resizable-w",se:".ui-resizable-se",sw:".ui-resizable-sw",ne:".ui-resizable-ne",nw:".ui-resizable-nw"});if(this.handles.constructor==String){if(this.handles=="all"){this.handles="n,e,s,w,se,sw,ne,nw"}var l=this.handles.split(",");this.handles={};for(var g=0;g
');if(/sw|se|ne|nw/.test(j)){h.css({zIndex:++k.zIndex})}if("se"==j){h.addClass("ui-icon ui-icon-gripsmall-diagonal-se")}this.handles[j]=".ui-resizable-"+j;this.element.append(h)}}this._renderAxis=function(q){q=q||this.element;for(var n in this.handles){if(this.handles[n].constructor==String){this.handles[n]=c(this.handles[n],this.element).show()}if(this.elementIsWrapper&&this.originalElement[0].nodeName.match(/textarea|input|select|button/i)){var o=c(this.handles[n],this.element),p=0;p=/sw|ne|nw|se|n|s/.test(n)?o.outerHeight():o.outerWidth();var m=["padding",/ne|nw|n/.test(n)?"Top":/se|sw|s/.test(n)?"Bottom":/^e$/.test(n)?"Right":"Left"].join("");q.css(m,p);this._proportionallyResize()}if(!c(this.handles[n]).length){continue}}};this._renderAxis(this.element);this._handles=c(".ui-resizable-handle",this.element).disableSelection();this._handles.mouseover(function(){if(!f.resizing){if(this.className){var i=this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i)}f.axis=i&&i[1]?i[1]:"se"}});if(k.autoHide){this._handles.hide();c(this.element).addClass("ui-resizable-autohide").hover(function(){if(k.disabled){return}c(this).removeClass("ui-resizable-autohide");f._handles.show()},function(){if(k.disabled){return}if(!f.resizing){c(this).addClass("ui-resizable-autohide");f._handles.hide()}})}this._mouseInit()},destroy:function(){this._mouseDestroy();var e=function(g){c(g).removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing").removeData("resizable").unbind(".resizable").find(".ui-resizable-handle").remove()};if(this.elementIsWrapper){e(this.element);var f=this.element;f.after(this.originalElement.css({position:f.css("position"),width:f.outerWidth(),height:f.outerHeight(),top:f.css("top"),left:f.css("left")})).remove()}this.originalElement.css("resize",this.originalResizeStyle);e(this.originalElement);return this},_mouseCapture:function(f){var g=false;for(var e in this.handles){if(c(this.handles[e])[0]==f.target){g=true}}return !this.options.disabled&&g},_mouseStart:function(g){var j=this.options,f=this.element.position(),e=this.element;this.resizing=true;this.documentScroll={top:c(document).scrollTop(),left:c(document).scrollLeft()};if(e.is(".ui-draggable")||(/absolute/).test(e.css("position"))){e.css({position:"absolute",top:f.top,left:f.left})}this._renderProxy();var k=b(this.helper.css("left")),h=b(this.helper.css("top"));if(j.containment){k+=c(j.containment).scrollLeft()||0;h+=c(j.containment).scrollTop()||0}this.offset=this.helper.offset();this.position={left:k,top:h};this.size=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalSize=this._helper?{width:e.outerWidth(),height:e.outerHeight()}:{width:e.width(),height:e.height()};this.originalPosition={left:k,top:h};this.sizeDiff={width:e.outerWidth()-e.width(),height:e.outerHeight()-e.height()};this.originalMousePosition={left:g.pageX,top:g.pageY};this.aspectRatio=(typeof j.aspectRatio=="number")?j.aspectRatio:((this.originalSize.width/this.originalSize.height)||1);var i=c(".ui-resizable-"+this.axis).css("cursor");c("body").css("cursor",i=="auto"?this.axis+"-resize":i);e.addClass("ui-resizable-resizing");this._propagate("start",g);return true},_mouseDrag:function(e){var h=this.helper,g=this.options,m={},q=this,j=this.originalMousePosition,n=this.axis;var r=(e.pageX-j.left)||0,p=(e.pageY-j.top)||0;var i=this._change[n];if(!i){return false}var l=i.apply(this,[e,r,p]),k=c.browser.msie&&c.browser.version<7,f=this.sizeDiff;this._updateVirtualBoundaries(e.shiftKey);if(this._aspectRatio||e.shiftKey){l=this._updateRatio(l,e)}l=this._respectSize(l,e);this._propagate("resize",e);h.css({top:this.position.top+"px",left:this.position.left+"px",width:this.size.width+"px",height:this.size.height+"px"});if(!this._helper&&this._proportionallyResizeElements.length){this._proportionallyResize()}this._updateCache(l);this._trigger("resize",e,this.ui());return false},_mouseStop:function(h){this.resizing=false;var i=this.options,m=this;if(this._helper){var g=this._proportionallyResizeElements,e=g.length&&(/textarea/i).test(g[0].nodeName),f=e&&c.ui.hasScroll(g[0],"left")?0:m.sizeDiff.height,k=e?0:m.sizeDiff.width;var n={width:(m.helper.width()-k),height:(m.helper.height()-f)},j=(parseInt(m.element.css("left"),10)+(m.position.left-m.originalPosition.left))||null,l=(parseInt(m.element.css("top"),10)+(m.position.top-m.originalPosition.top))||null;if(!i.animate){this.element.css(c.extend(n,{top:l,left:j}))}m.helper.height(m.size.height);m.helper.width(m.size.width);if(this._helper&&!i.animate){this._proportionallyResize()}}c("body").css("cursor","auto");this.element.removeClass("ui-resizable-resizing");this._propagate("stop",h);if(this._helper){this.helper.remove()}return false},_updateVirtualBoundaries:function(g){var j=this.options,i,h,f,k,e;e={minWidth:a(j.minWidth)?j.minWidth:0,maxWidth:a(j.maxWidth)?j.maxWidth:Infinity,minHeight:a(j.minHeight)?j.minHeight:0,maxHeight:a(j.maxHeight)?j.maxHeight:Infinity};if(this._aspectRatio||g){i=e.minHeight*this.aspectRatio;f=e.minWidth/this.aspectRatio;h=e.maxHeight*this.aspectRatio;k=e.maxWidth/this.aspectRatio;if(i>e.minWidth){e.minWidth=i}if(f>e.minHeight){e.minHeight=f}if(hl.width),s=a(l.height)&&i.minHeight&&(i.minHeight>l.height);if(h){l.width=i.minWidth}if(s){l.height=i.minHeight}if(t){l.width=i.maxWidth}if(m){l.height=i.maxHeight}var f=this.originalPosition.left+this.originalSize.width,p=this.position.top+this.size.height;var k=/sw|nw|w/.test(q),e=/nw|ne|n/.test(q);if(h&&k){l.left=f-i.minWidth}if(t&&k){l.left=f-i.maxWidth}if(s&&e){l.top=p-i.minHeight}if(m&&e){l.top=p-i.maxHeight}var n=!l.width&&!l.height;if(n&&!l.left&&l.top){l.top=null}else{if(n&&!l.top&&l.left){l.left=null}}return l},_proportionallyResize:function(){var k=this.options;if(!this._proportionallyResizeElements.length){return}var g=this.helper||this.element;for(var f=0;f');var e=c.browser.msie&&c.browser.version<7,g=(e?1:0),h=(e?2:-1);this.helper.addClass(this._helper).css({width:this.element.outerWidth()+h,height:this.element.outerHeight()+h,position:"absolute",left:this.elementOffset.left-g+"px",top:this.elementOffset.top-g+"px",zIndex:++i.zIndex});this.helper.appendTo("body").disableSelection()}else{this.helper=this.element}},_change:{e:function(g,f,e){return{width:this.originalSize.width+f}},w:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{left:i.left+f,width:g.width-f}},n:function(h,f,e){var j=this.options,g=this.originalSize,i=this.originalPosition;return{top:i.top+e,height:g.height-e}},s:function(g,f,e){return{height:this.originalSize.height+e}},se:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},sw:function(g,f,e){return c.extend(this._change.s.apply(this,arguments),this._change.w.apply(this,[g,f,e]))},ne:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.e.apply(this,[g,f,e]))},nw:function(g,f,e){return c.extend(this._change.n.apply(this,arguments),this._change.w.apply(this,[g,f,e]))}},_propagate:function(f,e){c.ui.plugin.call(this,f,[e,this.ui()]);(f!="resize"&&this._trigger(f,e,this.ui()))},plugins:{},ui:function(){return{originalElement:this.originalElement,element:this.element,helper:this.helper,position:this.position,size:this.size,originalSize:this.originalSize,originalPosition:this.originalPosition}}});c.extend(c.ui.resizable,{version:"1.8.18"});c.ui.plugin.add("resizable","alsoResize",{start:function(f,g){var e=c(this).data("resizable"),i=e.options;var h=function(j){c(j).each(function(){var k=c(this);k.data("resizable-alsoresize",{width:parseInt(k.width(),10),height:parseInt(k.height(),10),left:parseInt(k.css("left"),10),top:parseInt(k.css("top"),10)})})};if(typeof(i.alsoResize)=="object"&&!i.alsoResize.parentNode){if(i.alsoResize.length){i.alsoResize=i.alsoResize[0];h(i.alsoResize)}else{c.each(i.alsoResize,function(j){h(j)})}}else{h(i.alsoResize)}},resize:function(g,i){var f=c(this).data("resizable"),j=f.options,h=f.originalSize,l=f.originalPosition;var k={height:(f.size.height-h.height)||0,width:(f.size.width-h.width)||0,top:(f.position.top-l.top)||0,left:(f.position.left-l.left)||0},e=function(m,n){c(m).each(function(){var q=c(this),r=c(this).data("resizable-alsoresize"),p={},o=n&&n.length?n:q.parents(i.originalElement[0]).length?["width","height"]:["width","height","top","left"];c.each(o,function(s,u){var t=(r[u]||0)+(k[u]||0);if(t&&t>=0){p[u]=t||null}});q.css(p)})};if(typeof(j.alsoResize)=="object"&&!j.alsoResize.nodeType){c.each(j.alsoResize,function(m,n){e(m,n)})}else{e(j.alsoResize)}},stop:function(e,f){c(this).removeData("resizable-alsoresize")}});c.ui.plugin.add("resizable","animate",{stop:function(i,n){var p=c(this).data("resizable"),j=p.options;var h=p._proportionallyResizeElements,e=h.length&&(/textarea/i).test(h[0].nodeName),f=e&&c.ui.hasScroll(h[0],"left")?0:p.sizeDiff.height,l=e?0:p.sizeDiff.width;var g={width:(p.size.width-l),height:(p.size.height-f)},k=(parseInt(p.element.css("left"),10)+(p.position.left-p.originalPosition.left))||null,m=(parseInt(p.element.css("top"),10)+(p.position.top-p.originalPosition.top))||null;p.element.animate(c.extend(g,m&&k?{top:m,left:k}:{}),{duration:j.animateDuration,easing:j.animateEasing,step:function(){var o={width:parseInt(p.element.css("width"),10),height:parseInt(p.element.css("height"),10),top:parseInt(p.element.css("top"),10),left:parseInt(p.element.css("left"),10)};if(h&&h.length){c(h[0]).css({width:o.width,height:o.height})}p._updateCache(o);p._propagate("resize",i)}})}});c.ui.plugin.add("resizable","containment",{start:function(f,r){var t=c(this).data("resizable"),j=t.options,l=t.element;var g=j.containment,k=(g instanceof c)?g.get(0):(/parent/.test(g))?l.parent().get(0):g;if(!k){return}t.containerElement=c(k);if(/document/.test(g)||g==document){t.containerOffset={left:0,top:0};t.containerPosition={left:0,top:0};t.parentData={element:c(document),left:0,top:0,width:c(document).width(),height:c(document).height()||document.body.parentNode.scrollHeight}}else{var n=c(k),i=[];c(["Top","Right","Left","Bottom"]).each(function(p,o){i[p]=b(n.css("padding"+o))});t.containerOffset=n.offset();t.containerPosition=n.position();t.containerSize={height:(n.innerHeight()-i[3]),width:(n.innerWidth()-i[1])};var q=t.containerOffset,e=t.containerSize.height,m=t.containerSize.width,h=(c.ui.hasScroll(k,"left")?k.scrollWidth:m),s=(c.ui.hasScroll(k)?k.scrollHeight:e);t.parentData={element:k,left:q.left,top:q.top,width:h,height:s}}},resize:function(g,q){var t=c(this).data("resizable"),i=t.options,f=t.containerSize,p=t.containerOffset,m=t.size,n=t.position,r=t._aspectRatio||g.shiftKey,e={top:0,left:0},h=t.containerElement;if(h[0]!=document&&(/static/).test(h.css("position"))){e=p}if(n.left<(t._helper?p.left:0)){t.size.width=t.size.width+(t._helper?(t.position.left-p.left):(t.position.left-e.left));if(r){t.size.height=t.size.width/i.aspectRatio}t.position.left=i.helper?p.left:0}if(n.top<(t._helper?p.top:0)){t.size.height=t.size.height+(t._helper?(t.position.top-p.top):t.position.top);if(r){t.size.width=t.size.height*i.aspectRatio}t.position.top=t._helper?p.top:0}t.offset.left=t.parentData.left+t.position.left;t.offset.top=t.parentData.top+t.position.top;var l=Math.abs((t._helper?t.offset.left-e.left:(t.offset.left-e.left))+t.sizeDiff.width),s=Math.abs((t._helper?t.offset.top-e.top:(t.offset.top-p.top))+t.sizeDiff.height);var k=t.containerElement.get(0)==t.element.parent().get(0),j=/relative|absolute/.test(t.containerElement.css("position"));if(k&&j){l-=t.parentData.left}if(l+t.size.width>=t.parentData.width){t.size.width=t.parentData.width-l;if(r){t.size.height=t.size.width/t.aspectRatio}}if(s+t.size.height>=t.parentData.height){t.size.height=t.parentData.height-s;if(r){t.size.width=t.size.height*t.aspectRatio}}},stop:function(f,n){var q=c(this).data("resizable"),g=q.options,l=q.position,m=q.containerOffset,e=q.containerPosition,i=q.containerElement;var j=c(q.helper),r=j.offset(),p=j.outerWidth()-q.sizeDiff.width,k=j.outerHeight()-q.sizeDiff.height;if(q._helper&&!g.animate&&(/relative/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}if(q._helper&&!g.animate&&(/static/).test(i.css("position"))){c(this).css({left:r.left-e.left-m.left,width:p,height:k})}}});c.ui.plugin.add("resizable","ghost",{start:function(g,h){var e=c(this).data("resizable"),i=e.options,f=e.size;e.ghost=e.originalElement.clone();e.ghost.css({opacity:0.25,display:"block",position:"relative",height:f.height,width:f.width,margin:0,left:0,top:0}).addClass("ui-resizable-ghost").addClass(typeof i.ghost=="string"?i.ghost:"");e.ghost.appendTo(e.helper)},resize:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost){e.ghost.css({position:"relative",height:e.size.height,width:e.size.width})}},stop:function(f,g){var e=c(this).data("resizable"),h=e.options;if(e.ghost&&e.helper){e.helper.get(0).removeChild(e.ghost.get(0))}}});c.ui.plugin.add("resizable","grid",{resize:function(e,m){var p=c(this).data("resizable"),h=p.options,k=p.size,i=p.originalSize,j=p.originalPosition,n=p.axis,l=h._aspectRatio||e.shiftKey;h.grid=typeof h.grid=="number"?[h.grid,h.grid]:h.grid;var g=Math.round((k.width-i.width)/(h.grid[0]||1))*(h.grid[0]||1),f=Math.round((k.height-i.height)/(h.grid[1]||1))*(h.grid[1]||1);if(/^(se|s|e)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f}else{if(/^(ne)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f}else{if(/^(sw)$/.test(n)){p.size.width=i.width+g;p.size.height=i.height+f;p.position.left=j.left-g}else{p.size.width=i.width+g;p.size.height=i.height+f;p.position.top=j.top-f;p.position.left=j.left-g}}}}});var b=function(e){return parseInt(e,10)||0};var a=function(e){return !isNaN(parseInt(e,10))}})(jQuery);/* * jQuery hashchange event - v1.3 - 7/21/2010 * http://benalman.com/projects/jquery-hashchange-plugin/ * * Copyright (c) 2010 "Cowboy" Ben Alman * Dual licensed under the MIT and GPL licenses. * http://benalman.com/about/license/ */ (function($,e,b){var c="hashchange",h=document,f,g=$.event.special,i=h.documentMode,d="on"+c in e&&(i===b||i>7);function a(j){j=j||location.href;return"#"+j.replace(/^[^#]*#?(.*)$/,"$1")}$.fn[c]=function(j){return j?this.bind(c,j):this.trigger(c)};$.fn[c].delay=50;g[c]=$.extend(g[c],{setup:function(){if(d){return false}$(f.start)},teardown:function(){if(d){return false}$(f.stop)}});f=(function(){var j={},p,m=a(),k=function(q){return q},l=k,o=k;j.start=function(){p||n()};j.stop=function(){p&&clearTimeout(p);p=b};function n(){var r=a(),q=o(m);if(r!==m){l(m=r,q);$(e).trigger(c)}else{if(q!==m){location.href=location.href.replace(/#.*/,"")+q}}p=setTimeout(n,$.fn[c].delay)}$.browser.msie&&!d&&(function(){var q,r;j.start=function(){if(!q){r=$.fn[c].src;r=r&&r+a();q=$('