Fixed tabs and trailing whitespaces
authorJoris Mooij <joris.mooij@tuebingen.mpg.de>
Tue, 8 Sep 2009 09:18:33 +0000 (11:18 +0200)
committerJoris Mooij <joris.mooij@tuebingen.mpg.de>
Tue, 8 Sep 2009 09:18:33 +0000 (11:18 +0200)
75 files changed:
ChangeLog
Makefile
Makefile.CYGWIN
Makefile.LINUX
Makefile.MACOSX
Makefile.WINDOWS
README
examples/example_sprinkler.cpp
examples/example_varset.cpp
include/dai/alldai.h
include/dai/bbp.h
include/dai/bipgraph.h
include/dai/bp.h
include/dai/bp_dual.h
include/dai/cbp.h
include/dai/clustergraph.h
include/dai/daialg.h
include/dai/doc.h
include/dai/emalg.h
include/dai/evidence.h
include/dai/exactinf.h
include/dai/exceptions.h
include/dai/factor.h
include/dai/factorgraph.h
include/dai/hak.h
include/dai/index.h
include/dai/jtree.h
include/dai/lc.h
include/dai/mf.h
include/dai/mr.h
include/dai/prob.h
include/dai/properties.h
include/dai/regiongraph.h
include/dai/smallset.h
include/dai/treeep.h
include/dai/util.h
include/dai/var.h
include/dai/varset.h
include/dai/weightedgraph.h
matlab/dai_potstrength.m
scripts/regenerate-properties
src/alldai.cpp
src/bbp.cpp
src/bipgraph.cpp
src/bp.cpp
src/bp_dual.cpp
src/cbp.cpp
src/clustergraph.cpp
src/daialg.cpp
src/emalg.cpp
src/evidence.cpp
src/exactinf.cpp
src/exceptions.cpp
src/factorgraph.cpp
src/gibbs.cpp
src/hak.cpp
src/jtree.cpp
src/lc.cpp
src/matlab/dai.cpp
src/matlab/dai_potstrength.cpp
src/matlab/dai_readfg.cpp
src/matlab/dai_writefg.cpp
src/matlab/matlab.cpp
src/mf.cpp
src/mr.cpp
src/regiongraph.cpp
src/treeep.cpp
src/util.cpp
src/weightedgraph.cpp
tests/testbbp.cpp
tests/testdai.cpp
tests/testem/runtests
tests/testem/testem.cpp
utils/createfg.cpp
utils/fginfo.cpp

index dbe384d..0222b02 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -39,7 +39,7 @@ git ae0fc30e10be6683cbfc209dcee56f34234a6cb8
   BipartiteGraph and FactorGraph (which will be obsoleted soon)
 * [Frederik Eaton] Added BP_dual, BBP and CBP algorithms
 * [Frederik Eaton] Added Gibbs::state() accessors/mutators
   BipartiteGraph and FactorGraph (which will be obsoleted soon)
 * [Frederik Eaton] Added BP_dual, BBP and CBP algorithms
 * [Frederik Eaton] Added Gibbs::state() accessors/mutators
-* [Frederik Eaton] Fixed Gibbs::getVarDist(size_t) to return uniform 
+* [Frederik Eaton] Fixed Gibbs::getVarDist(size_t) to return uniform
   distribution if no state is allowed
 * [Frederik Eaton] Improved parsing code in tests/testdai to allow recursive
   alias substitutions
   distribution if no state is allowed
 * [Frederik Eaton] Improved parsing code in tests/testdai to allow recursive
   alias substitutions
@@ -57,18 +57,18 @@ git ae0fc30e10be6683cbfc209dcee56f34234a6cb8
   operators
 * [Frederik Eaton] Change cout to cerr in warnings and error messages
 * [Giuseppe Passino] Optimised maximum-residual BP by using a reversed ordered
   operators
 * [Frederik Eaton] Change cout to cerr in warnings and error messages
 * [Giuseppe Passino] Optimised maximum-residual BP by using a reversed ordered
-  set instead of the linear search (which can yield enormous speedups - a 
+  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!)
   factor 500 has been measured on a binary Ising grid with 128x128 variables!)
-* Added debug assertions to Var which check for inconsistent dimensions of 
+* Added debug assertions to Var which check for inconsistent dimensions of
   variables with the same labels
 * [Giuseppe Passino] Added prefix ++ operator to State (State::operator++())
   variables with the same labels
 * [Giuseppe Passino] Added prefix ++ operator to State (State::operator++())
-* [Giuseppe Passino] Added iterators to FactorGraph (FactorGraph::begin, 
+* [Giuseppe Passino] Added iterators to FactorGraph (FactorGraph::begin,
   FactorGraph::end)
 * [Giuseppe Passino] Added iterators to TFactor (TFactor::begin, TFactor::end)
 * [Giuseppe Passino] Added iterators to TProb (TProb::begin, TProb::end)
 * [Giuseppe Passino] Added BP::findMaximum(), which can be used after running
   max-product BP to construct a global state with maximum probability
   FactorGraph::end)
 * [Giuseppe Passino] Added iterators to TFactor (TFactor::begin, TFactor::end)
 * [Giuseppe Passino] Added iterators to TProb (TProb::begin, TProb::end)
 * [Giuseppe Passino] Added BP::findMaximum(), which can be used after running
   max-product BP to construct a global state with maximum probability
-* Improved Makefile (libDAI now also builds out-of-the-box on MacOSX, 
+* Improved Makefile (libDAI now also builds out-of-the-box on MacOSX,
   thanks to Dan Preston; merged Makefile.win and Makefile.shared into Makefile)
 * Fixed bug in calcMarginal, calcPairBeliefs, calcPairBeliefsNew where
   states with zero probability mass were clamped, leading to NaNs or assertion
   thanks to Dan Preston; merged Makefile.win and Makefile.shared into Makefile)
 * Fixed bug in calcMarginal, calcPairBeliefs, calcPairBeliefsNew where
   states with zero probability mass were clamped, leading to NaNs or assertion
@@ -82,7 +82,7 @@ git ae0fc30e10be6683cbfc209dcee56f34234a6cb8
   var.h, varset.h, factor.h, enum.h} and of examples/example.cpp
   Merged TODO and FILEFORMAT into doxygen documentation
 * examples/
   var.h, varset.h, factor.h, enum.h} and of examples/example.cpp
   Merged TODO and FILEFORMAT into doxygen documentation
 * examples/
-  - Moved example.cpp to examples/ 
+  - Moved example.cpp to examples/
   - Added examples/example_bipgraph.cpp
   - Added examples/example_varset.cpp
 * Interface changes:
   - Added examples/example_bipgraph.cpp
   - Added examples/example_varset.cpp
 * Interface changes:
@@ -113,7 +113,7 @@ New features:
 * 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.
 * 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 
+* [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.
   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.
@@ -123,10 +123,10 @@ New features:
 Improved architecture:
 * Added Exceptions framework.
 * Pervasive change of BipartiteGraph implementation (based on an idea by
 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 
+  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.
   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.
@@ -146,24 +146,24 @@ Code cleanup:
 * Replaced sub_nb class in mr.h by boost::dynamic_bitset.
 * Improved index.h:
   - Renamed Index -> IndexFor
 * 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 
+  - 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
     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 
+  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
   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 
+  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:
   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 
+* 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.
   GCC under cygwin.
 * Contributions by Peter Gober:
   - Renamed variable _N in mr.* for compatibility with g++ under cygwin.
@@ -172,7 +172,7 @@ Miscellaneous improvements:
   - 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;
   - 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: 
+  - 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 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;
@@ -183,7 +183,7 @@ Miscellaneous improvements:
     and variables;
   - Optimization of FactorGraph constructors using tr1::unordered_map.
 * FactorGraph constructors no longer check for short loops (huge speed
     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 
+  increase for large factor graphs), nor for negative entries. Also, the
   normtype is now Prob::NORMPROB by default.
 * Improved MaxSpanningTreePrims algorithm (uses boost::graph).
 
   normtype is now Prob::NORMPROB by default.
 * Improved MaxSpanningTreePrims algorithm (uses boost::graph).
 
@@ -262,7 +262,7 @@ Regressions
 
 General framework
 
 
 General framework
 
-- DAIAlg is now a template class; typedefs for DAIAlg<FactorGraph> and for 
+- 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
   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
@@ -281,12 +281,12 @@ General framework
   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
   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). 
+  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,
   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 
+  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
   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
@@ -302,10 +302,10 @@ Bugfixes
 - 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).
 - 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: 
+- 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.
   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 
+- 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).
   that consists of one outer region only.
 - Fixed INIT bug in LCBP2::UpdatePancake().
 - Fixed MaxDiffs flow (except for MR).
@@ -326,13 +326,13 @@ New functionality
   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).
   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 
+- 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).
   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 
+- 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
   marginals.
 - Now there are several LCBP variants (LCBP, LCBPI, LCBPJ, LCBPK, LCBPL);
   LCBPJ works only for pairwise, LCBPK is LCBP improved for higher order
@@ -342,7 +342,7 @@ New functionality
 - 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.
 - 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 
+- 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.
   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.
@@ -352,10 +352,10 @@ New functionality
 
 Improvements of existing code
 
 
 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 
+- 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.
   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.
@@ -363,14 +363,14 @@ Improvements of existing code
 - 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.
 - 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); 
+- Marginal2ndO now optionally divides by the single node beliefs (to the power n-2);
   hopefully this will give more accurate approximations.
   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() 
+- 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
   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 
+  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
   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
@@ -388,7 +388,7 @@ Improvements of existing code
   makeFacCavity -> makeFactorCavity
 - LCBP_SEQMAXRES has been removed because it did strange things.
 - Implemented RandomDRegularGraph
   makeFacCavity -> makeFactorCavity
 - LCBP_SEQMAXRES has been removed because it did strange things.
 - Implemented RandomDRegularGraph
-- Implemented JTree::calcMarginal for marginals that are not confined 
+- 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).
   within one cluster (using cut-set conditioning).
 - Added isConnected() method to FactorGraph (some methods do not work with
   disconnected factor graphs).
@@ -405,17 +405,17 @@ 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
 - 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(). 
+  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/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 
+- 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
   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 
+  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
   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
@@ -436,11 +436,11 @@ revision 252
 
 Functionality
 - Added RegionGraph, GBP, CVM and HAK (double-loop).
 
 Functionality
 - Added RegionGraph, GBP, CVM and HAK (double-loop).
-- Added JunctionTree (with two update algorithms, HUGIN and Shafer-Shenoy), which is a 
+- 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,
   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 
+  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 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,
@@ -458,7 +458,7 @@ Implementation / code
 - 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.
 - 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 
+- 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
   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
@@ -541,8 +541,8 @@ the output arguments Q, Q0 of ai).
 0.1.1   (2006-02-28)
 --------------------
 - The constructors of (Log)FactorGraph and LogFactorGraph from a
 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 
+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
 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
index 749847b..aefca87 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 # Copyright (C) 2006-2009  Joris Mooij  [joris dot mooij at tuebingen dot mpg dot de]
 # Radboud University Nijmegen, The Netherlands /
 # Max Planck Institute for Biological Cybernetics, Germany
 # Copyright (C) 2006-2009  Joris Mooij  [joris dot mooij at tuebingen dot mpg dot de]
 # Radboud University Nijmegen, The Netherlands /
 # Max Planck Institute for Biological Cybernetics, Germany
-#   
+#
 # This file is part of libDAI.
 #
 # libDAI is free software; you can redistribute it and/or modify
 # This file is part of libDAI.
 #
 # libDAI is free software; you can redistribute it and/or modify
@@ -33,7 +33,7 @@ LIB=lib
 # Define build targets
 TARGETS=tests utils lib examples testregression testem
 ifdef WITH_DOC
 # Define build targets
 TARGETS=tests utils lib examples testregression testem
 ifdef WITH_DOC
-  TARGETS:=$(TARGETS) doc 
+  TARGETS:=$(TARGETS) doc
 endif
 ifdef WITH_MATLAB
   TARGETS:=$(TARGETS) matlabs
 endif
 ifdef WITH_MATLAB
   TARGETS:=$(TARGETS) matlabs
@@ -113,7 +113,7 @@ tests : tests/testdai$(EE) tests/testem/testem$(EE) tests/testbbp$(EE)
 
 utils : utils/createfg$(EE) utils/fg2dot$(EE) utils/fginfo$(EE)
 
 
 utils : utils/createfg$(EE) utils/fg2dot$(EE) utils/fginfo$(EE)
 
-lib: $(LIB)/libdai$(LE) 
+lib: $(LIB)/libdai$(LE)
 
 
 # OBJECTS
 
 
 # OBJECTS
index 3a11de9..09771ae 100644 (file)
@@ -1,5 +1,5 @@
 # This template contains configurations for compiling libDAI under CygWin
 # This template contains configurations for compiling libDAI under CygWin
-# 
+#
 # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf'
 # to your local setup
 #
 # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf'
 # to your local setup
 #
index 2bc8b2f..dc9896e 100644 (file)
@@ -1,6 +1,6 @@
 # This template contains configurations for compiling libDAI under GNU/Linux
 # and other UNIX variants
 # This template contains configurations for compiling libDAI under GNU/Linux
 # and other UNIX variants
-# 
+#
 # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf'
 # to your local setup
 #
 # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf'
 # to your local setup
 #
index b176114..e9488a7 100644 (file)
@@ -1,5 +1,5 @@
 # This template contains configurations for compiling libDAI under Mac OS X
 # 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
 #
 # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf'
 # to your local setup
 #
index 9728988..83389ee 100644 (file)
@@ -1,6 +1,6 @@
 # This template contains configurations for compiling libDAI with Visual C++
 # under Windows (and GNU Make)
 # This template contains configurations for compiling libDAI with Visual C++
 # under Windows (and GNU Make)
-# 
+#
 # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf'
 # to your local setup
 #
 # To use it, simply copy this file to 'Makefile.conf' and adapt 'Makefile.conf'
 # to your local setup
 #
@@ -54,7 +54,7 @@ CCINC=/Iinclude /IC:\boost_1_36_0
 
 # LINKER
 # Standard libraries to include
 
 # LINKER
 # Standard libraries to include
-LIBS=/link $(LIB)/libdai$(LE) 
+LIBS=/link $(LIB)/libdai$(LE)
 # For linking with the BOOST Program Options library
 BOOSTLIBS=/LIBPATH:C:\boost_1_36_0\stage\lib
 # Additional library search paths for linker
 # For linking with the BOOST Program Options library
 BOOSTLIBS=/LIBPATH:C:\boost_1_36_0\stage\lib
 # Additional library search paths for linker
diff --git a/README b/README
index e9bd79b..91670dd 100644 (file)
--- a/README
+++ b/README
@@ -110,7 +110,7 @@ License: GNU Public License v2 (or higher).
 
 libDAI-0.2      December 1, 2006
 libDAI-0.2.1    May 26, 2008
 
 libDAI-0.2      December 1, 2006
 libDAI-0.2.1    May 26, 2008
-libDAI-0.2.2   September 30, 2008
+libDAI-0.2.2    September 30, 2008
 
 
 Acknowledgments
 
 
 Acknowledgments
index 84c62e4..6c567de 100644 (file)
@@ -13,7 +13,7 @@ int main() {
     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)
     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[0] = 0.5;   // C = 0
     // Define probability distribution for C
     Factor P_C( C );
     P_C[0] = 0.5;   // C = 0
@@ -75,5 +75,5 @@ int main() {
     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;
 
     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;
+    return 0;
 }
 }
index fc2145f..08e11af 100644 (file)
@@ -7,7 +7,7 @@ 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)
 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}
     // Define set X = {x0, x1}
     VarSet X; // empty
     X |= x1;  // X = {x1}
@@ -48,5 +48,5 @@ int main() {
         assert( X.calcState(X.calcStates(S)) == S );
     }
 
         assert( X.calcState(X.calcStates(S)) == S );
     }
 
-       return 0;
+    return 0;
 }
 }
index 862bf8d..c3a2bfc 100644 (file)
@@ -89,7 +89,7 @@ InfAlg *newInfAlgFromString( const std::string &nameOpts, const FactorGraph &fg
 static const char* DAINames[] = {
     ExactInf::Name,
 #ifdef DAI_WITH_BP
 static const char* DAINames[] = {
     ExactInf::Name,
 #ifdef DAI_WITH_BP
-    BP::Name, 
+    BP::Name,
 #endif
 #ifdef DAI_WITH_MF
     MF::Name,
 #endif
 #ifdef DAI_WITH_MF
     MF::Name,
index 736ffcd..538a1d7 100644 (file)
@@ -111,11 +111,11 @@ class BBP {
         //@{
         /// Calculates _indices, which is a cache of IndexFor @see bp.cpp
         void RegenerateInds();
         //@{
         /// Calculates _indices, which is a cache of IndexFor @see bp.cpp
         void RegenerateInds();
-        
+
         /// Index type
         typedef std::vector<size_t>  _ind_t;
         /// Cached indices (indexed [i][_I])
         /// Index type
         typedef std::vector<size_t>  _ind_t;
         /// Cached indices (indexed [i][_I])
-        std::vector<std::vector<_ind_t> >  _indices; 
+        std::vector<std::vector<_ind_t> >  _indices;
         /// Returns an index from the cache
         const _ind_t& _index(size_t i, size_t _I) const { return _indices[i][_I]; }
         //@}
         /// Returns an index from the cache
         const _ind_t& _index(size_t i, size_t _I) const { return _indices[i][_I]; }
         //@}
@@ -183,7 +183,7 @@ class BBP {
         //  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
         //  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 ); 
+        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]
         /// 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]
@@ -234,7 +234,7 @@ class BBP {
             _adj_b_F = adj_b_F;
             _init_adj_psi_V = adj_psi_V;
             _init_adj_psi_F = adj_psi_F;
             _adj_b_F = adj_b_F;
             _init_adj_psi_V = adj_psi_V;
             _init_adj_psi_F = adj_psi_F;
-            Regenerate(); 
+            Regenerate();
         }
 
         /// Initializes belief adjoints and with zero initial factor adjoints and regenerates
         }
 
         /// Initializes belief adjoints and with zero initial factor adjoints and regenerates
@@ -268,7 +268,7 @@ class BBP {
         /// Returns factor->variable message adjoint
         DAI_ACCMUT(Prob& adj_m(size_t i, size_t _I), { return _adj_m[i][_I]; });
 
         /// Returns factor->variable message adjoint
         DAI_ACCMUT(Prob& adj_m(size_t i, size_t _I), { return _adj_m[i][_I]; });
 
-     public: 
+     public:
         /// Parameters of this algorithm
         /* PROPERTIES(props,BBP) {
            /// Enumeration of possible update schedules
         /// Parameters of this algorithm
         /* PROPERTIES(props,BBP) {
            /// Enumeration of possible update schedules
@@ -291,10 +291,10 @@ class BBP {
 
            // DISABLED BECAUSE IT IS BUGGY:
            // bool clean_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 
+/* {{{ GENERATED CODE: DO NOT EDIT. Created by
+    ./scripts/regenerate-properties include/dai/bbp.h src/bbp.cpp
 */
         struct Properties {
             /// Enumeration of possible update schedules
 */
         struct Properties {
             /// Enumeration of possible update schedules
index 83053d4..da22994 100644 (file)
@@ -41,15 +41,15 @@ namespace dai {
 /// Represents the neighborhood structure of nodes in a 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 nr1()
 /// Represents the neighborhood structure of nodes in a 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 nr1()
- *  nodes of type 1 and nr2() nodes of type 2, the nodes of type 1 are numbered 
+ *  nodes of type 1 and nr2() nodes of type 2, the nodes of type 1 are numbered
  *  0,1,2,...,nr1()-1 and the nodes of type 2 are numbered 0,1,2,...,nr2()-1. An edge
  *  between node \a n1 of type 1 and node \a n2 of type 2 is represented by a BipartiteGraph::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. In particular, it stores for each node of type 1 a vector of Neighbor structures
  *  0,1,2,...,nr1()-1 and the nodes of type 2 are numbered 0,1,2,...,nr2()-1. An edge
  *  between node \a n1 of type 1 and node \a n2 of type 2 is represented by a BipartiteGraph::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. In particular, 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. 
+ *  (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.
  *  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.
@@ -70,7 +70,7 @@ class BipartiteGraph {
          *  a node as a neighbor of its neighbor (the \a dual member).
          *
          *  By convention, variable identifiers naming indices into a
          *  a node as a neighbor of its neighbor (the \a dual member).
          *
          *  By convention, variable identifiers naming indices into a
-         *  vector of neighbors are prefixed with an underscore ("_"). 
+         *  vector of neighbors are prefixed with an underscore ("_").
          *  The neighbor list which they point into is then understood
          *  from context. For example:
          *
          *  The neighbor list which they point into is then understood
          *  from context. For example:
          *
@@ -164,7 +164,7 @@ class BipartiteGraph {
         /// Constructs BipartiteGraph from a range of edges.
         /** \tparam EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge.
          *  \param nr1 The number of nodes of type 1.
         /// Constructs BipartiteGraph from a range of edges.
         /** \tparam EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge.
          *  \param nr1 The number of nodes of type 1.
-         *  \param nr2 The number of nodes of type 2. 
+         *  \param nr2 The number of nodes of type 2.
          *  \param begin Points to the first edge.
          *  \param end Points just beyond the last edge.
          */
          *  \param begin Points to the first edge.
          *  \param end Points just beyond the last edge.
          */
@@ -176,7 +176,7 @@ class BipartiteGraph {
         /// (Re)constructs BipartiteGraph from a range of edges.
         /** \tparam EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge.
          *  \param nr1 The number of nodes of type 1.
         /// (Re)constructs BipartiteGraph from a range of edges.
         /** \tparam EdgeInputIterator Iterator that iterates over instances of BipartiteGraph::Edge.
          *  \param nr1 The number of nodes of type 1.
-         *  \param nr2 The number of nodes of type 2. 
+         *  \param nr2 The number of nodes of type 2.
          *  \param begin Points to the first edge.
          *  \param end Points just beyond the last edge.
          */
          *  \param begin Points to the first edge.
          *  \param end Points just beyond the last edge.
          */
@@ -184,58 +184,58 @@ class BipartiteGraph {
         void construct( size_t nr1, size_t nr2, EdgeInputIterator begin, EdgeInputIterator end );
 
         /// Returns constant reference to the _i2'th neighbor of node i1 of type 1
         void construct( size_t nr1, size_t nr2, EdgeInputIterator begin, EdgeInputIterator end );
 
         /// Returns constant reference to the _i2'th neighbor of node i1 of type 1
-        const Neighbor & nb1( size_t i1, size_t _i2 ) const { 
+        const Neighbor & nb1( size_t i1, size_t _i2 ) const {
             DAI_DEBASSERT( i1 < _nb1.size() );
             DAI_DEBASSERT( _i2 < _nb1[i1].size() );
             DAI_DEBASSERT( i1 < _nb1.size() );
             DAI_DEBASSERT( _i2 < _nb1[i1].size() );
-            return _nb1[i1][_i2]; 
+            return _nb1[i1][_i2];
         }
         /// Returns reference to the _i2'th neighbor of node i1 of type 1
         Neighbor & nb1( size_t i1, size_t _i2 ) {
             DAI_DEBASSERT( i1 < _nb1.size() );
             DAI_DEBASSERT( _i2 < _nb1[i1].size() );
         }
         /// Returns reference to the _i2'th neighbor of node 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]; 
+            return _nb1[i1][_i2];
         }
 
         /// Returns constant reference to the _i1'th neighbor of node i2 of type 2
         }
 
         /// Returns constant reference to the _i1'th neighbor of node i2 of type 2
-        const Neighbor & nb2( size_t i2, size_t _i1 ) const { 
+        const Neighbor & nb2( size_t i2, size_t _i1 ) const {
             DAI_DEBASSERT( i2 < _nb2.size() );
             DAI_DEBASSERT( _i1 < _nb2[i2].size() );
             DAI_DEBASSERT( i2 < _nb2.size() );
             DAI_DEBASSERT( _i1 < _nb2[i2].size() );
-            return _nb2[i2][_i1]; 
+            return _nb2[i2][_i1];
         }
         /// Returns reference to the _i1'th neighbor of node i2 of type 2
         }
         /// Returns reference to the _i1'th neighbor of node i2 of type 2
-        Neighbor & nb2( size_t i2, size_t _i1 ) { 
+        Neighbor & nb2( size_t i2, size_t _i1 ) {
             DAI_DEBASSERT( i2 < _nb2.size() );
             DAI_DEBASSERT( _i1 < _nb2[i2].size() );
             DAI_DEBASSERT( i2 < _nb2.size() );
             DAI_DEBASSERT( _i1 < _nb2[i2].size() );
-            return _nb2[i2][_i1]; 
+            return _nb2[i2][_i1];
         }
 
         /// Returns constant reference to all neighbors of node i1 of type 1
         }
 
         /// Returns constant reference to all neighbors of node i1 of type 1
-        const Neighbors & nb1( size_t i1 ) const { 
+        const Neighbors & nb1( size_t i1 ) const {
             DAI_DEBASSERT( i1 < _nb1.size() );
             DAI_DEBASSERT( i1 < _nb1.size() );
-            return _nb1[i1]; 
+            return _nb1[i1];
         }
         /// Returns reference to all neighbors of node of i1 type 1
         }
         /// Returns reference to all neighbors of node of i1 type 1
-        Neighbors & nb1( size_t i1 ) { 
+        Neighbors & nb1( size_t i1 ) {
             DAI_DEBASSERT( i1 < _nb1.size() );
             DAI_DEBASSERT( i1 < _nb1.size() );
-            return _nb1[i1]; 
+            return _nb1[i1];
         }
 
         /// Returns constant reference to all neighbors of node i2 of type 2
         }
 
         /// Returns constant reference to all neighbors of node i2 of type 2
-        const Neighbors & nb2( size_t i2 ) const { 
+        const Neighbors & nb2( size_t i2 ) const {
             DAI_DEBASSERT( i2 < _nb2.size() );
             DAI_DEBASSERT( i2 < _nb2.size() );
-            return _nb2[i2]; 
+            return _nb2[i2];
         }
         /// Returns reference to all neighbors of node i2 of type 2
         }
         /// Returns reference to all neighbors of node i2 of type 2
-        Neighbors & nb2( size_t i2 ) { 
+        Neighbors & nb2( size_t i2 ) {
             DAI_DEBASSERT( i2 < _nb2.size() );
             DAI_DEBASSERT( i2 < _nb2.size() );
-            return _nb2[i2]; 
+            return _nb2[i2];
         }
 
         /// Returns number of nodes of type 1
         size_t nr1() const { return _nb1.size(); }
         /// Returns number of nodes of type 2
         size_t nr2() const { return _nb2.size(); }
         }
 
         /// Returns number of nodes of type 1
         size_t nr1() const { return _nb1.size(); }
         /// Returns number of nodes of type 2
         size_t nr2() const { return _nb2.size(); }
-        
+
         /// Calculates the number of edges, time complexity: O(nr1())
         size_t nrEdges() const {
             size_t sum = 0;
         /// Calculates the number of edges, time complexity: O(nr1())
         size_t nrEdges() const {
             size_t sum = 0;
@@ -243,10 +243,10 @@ class BipartiteGraph {
                 sum += nb1(i1).size();
             return sum;
         }
                 sum += nb1(i1).size();
             return sum;
         }
-        
+
         /// Adds a node of type 1 without neighbors.
         void add1() { _nb1.push_back( Neighbors() ); }
         /// Adds a node of type 1 without neighbors.
         void add1() { _nb1.push_back( Neighbors() ); }
-        
+
         /// Adds a node of type 2 without neighbors.
         void add2() { _nb2.push_back( Neighbors() ); }
 
         /// Adds a node of type 2 without neighbors.
         void add2() { _nb2.push_back( Neighbors() ); }
 
@@ -382,16 +382,16 @@ class BipartiteGraph {
 
             _edge_indexed = true;
         }
 
             _edge_indexed = true;
         }
-        
+
         const Edge& edge(size_t e) const {
             assert(_edge_indexed);
             return _edges[e];
         }
         const Edge& edge(size_t e) const {
             assert(_edge_indexed);
             return _edges[e];
         }
-        
+
         const std::vector<Edge>& edges() const {
             return _edges;
         }
         const std::vector<Edge>& edges() const {
             return _edges;
         }
-        
+
         size_t VV2E(size_t n1, size_t n2) const {
             assert(_edge_indexed);
             Edge e(n1,n2);
         size_t VV2E(size_t n1, size_t n2) const {
             assert(_edge_indexed);
             Edge e(n1,n2);
@@ -455,7 +455,7 @@ void BipartiteGraph::construct( size_t nr1, size_t nr2, EdgeInputIterator begin,
  *    12 -- 21;
  *  }
  *  \enddot
  *    12 -- 21;
  *  }
  *  \enddot
- *  It has three nodes of type 1 (drawn as circles) and two nodes of type 2 (drawn as rectangles). 
+ *  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.
  *  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.
index 9117f9b..6ce1fbc 100644 (file)
@@ -43,7 +43,7 @@ namespace dai {
 class BP : public DAIAlgFG {
     private:
         typedef std::vector<size_t> ind_t;
 class BP : public DAIAlgFG {
     private:
         typedef std::vector<size_t> ind_t;
-           typedef std::multimap<double, std::pair<std::size_t, std::size_t> > LutType;
+        typedef std::multimap<double, std::pair<std::size_t, std::size_t> > LutType;
         struct EdgeProp {
             ind_t  index;
             Prob   message;
         struct EdgeProp {
             ind_t  index;
             Prob   message;
@@ -59,7 +59,7 @@ class BP : public DAIAlgFG {
         size_t _iters;
         /// The history of message updates (only recorded if recordSentMessages is true)
         std::vector<std::pair<std::size_t, std::size_t> > _sentMessages;
         size_t _iters;
         /// The history of message updates (only recorded if recordSentMessages is true)
         std::vector<std::pair<std::size_t, std::size_t> > _sentMessages;
-    
+
     public:
         /// Parameters of this inference algorithm
         struct Properties {
     public:
         /// Parameters of this inference algorithm
         struct Properties {
@@ -68,7 +68,7 @@ class BP : public DAIAlgFG {
 
             /// Enumeration of inference variants
             DAI_ENUM(InfType,SUMPROD,MAXPROD);
 
             /// Enumeration of inference variants
             DAI_ENUM(InfType,SUMPROD,MAXPROD);
-        
+
             /// Verbosity
             size_t verbose;
 
             /// Verbosity
             size_t verbose;
 
@@ -103,8 +103,8 @@ class BP : public DAIAlgFG {
 
         /// Copy constructor
         BP( const BP &x ) : DAIAlgFG(x), _edges(x._edges), _edge2lut(x._edge2lut),
 
         /// 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), 
-            props(x.props), recordSentMessages(x.recordSentMessages) 
+            _lut(x._lut), _maxdiff(x._maxdiff), _iters(x._iters), _sentMessages(x._sentMessages),
+            props(x.props), recordSentMessages(x.recordSentMessages)
         {
             for( LutType::iterator l = _lut.begin(); l != _lut.end(); ++l )
                 _edge2lut[l->second.first][l->second.second] = l;
         {
             for( LutType::iterator l = _lut.begin(); l != _lut.end(); ++l )
                 _edge2lut[l->second.first][l->second.second] = l;
index 0164635..0cd2e45 100644 (file)
@@ -37,7 +37,7 @@ 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
 
 /// 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. 
+ *  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.
  */
  *  These are computed from the variable and factor beliefs of the InfAlg.
  *  This class is used primarily by BBP.
  */
@@ -49,7 +49,7 @@ class BP_dual {
         struct _edges_t : public std::vector<std::vector<T> > {};
 
         /// Groups together the data structures for storing the two types of messages and their normalizers
         struct _edges_t : public std::vector<std::vector<T> > {};
 
         /// Groups together the data structures for storing the two types of messages and their normalizers
-        struct messages {            
+        struct messages {
             /// Unnormalized variable->factor messages
             _edges_t<Prob> n;
             /// Normalizers of variable->factor messages
             /// Unnormalized variable->factor messages
             _edges_t<Prob> n;
             /// Normalizers of variable->factor messages
@@ -78,7 +78,7 @@ class BP_dual {
 
         /// Pointer to the InfAlg object
         const InfAlg *_ia;
 
         /// Pointer to the InfAlg object
         const InfAlg *_ia;
-        
+
         /// Does all necessary preprocessing
         void init();
         /// Allocates space for _msgs
         /// Does all necessary preprocessing
         void init();
         /// Allocates space for _msgs
@@ -101,8 +101,8 @@ class BP_dual {
         void calcBeliefF(size_t I);
 
     public:
         void calcBeliefF(size_t I);
 
     public:
-        /// Construct BP_dual object from (converged) InfAlg object's beliefs and factors. 
-        /*  A pointer to the the InfAlg object is stored, 
+        /// Construct BP_dual object from (converged) InfAlg object's beliefs and factors.
+        /*  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(); }
          *  so the object must not be destroyed before the BP_dual is destroyed.
          */
         BP_dual( const InfAlg *ia ) : _ia(ia) { init(); }
index d0a03d7..75da497 100644 (file)
@@ -38,7 +38,7 @@
 namespace dai {
 
 
 namespace dai {
 
 
-/// Find a variable to clamp using BBP (goes with maximum adjoint) 
+/// Find a variable to clamp using BBP (goes with maximum adjoint)
 /// \see BBP
 std::pair<size_t, size_t> bbpFindClampVar( const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, bbp_cfn_t cfn, Real *maxVarOut );
 
 /// \see BBP
 std::pair<size_t, size_t> bbpFindClampVar( const InfAlg &in_bp, bool clampingVar, const PropertySet &bbp_props, bbp_cfn_t cfn, Real *maxVarOut );
 
@@ -76,7 +76,7 @@ class CBP : public DAIAlgFG {
         /// Prints beliefs, variables and partition sum, in case of a debugging build
         void printDebugInfo();
 
         /// Prints beliefs, variables and partition sum, in case of a debugging build
         void printDebugInfo();
 
-        /// Called by 'run', and by itself. Implements the main algorithm. 
+        /// Called by 'run', and by itself. Implements the main algorithm.
         /** Chooses a variable to clamp, recurses, combines the logZ and
          *  beliefs estimates of the children, and returns the improved
          *  estimates in \a lz_out and \a beliefs_out to its parent
         /** Chooses a variable to clamp, recurses, combines the logZ and
          *  beliefs estimates of the children, and returns the improved
          *  estimates in \a lz_out and \a beliefs_out to its parent
@@ -94,7 +94,7 @@ class CBP : public DAIAlgFG {
          */
         virtual bool chooseNextClampVar( InfAlg* bp, std::vector<size_t> &clamped_vars_list, size_t &i, std::vector<size_t> &xis, Real *maxVarOut );
 
          */
         virtual bool chooseNextClampVar( InfAlg* bp, std::vector<size_t> &clamped_vars_list, size_t &i, std::vector<size_t> &xis, Real *maxVarOut );
 
-        /// Return the InfAlg to use at each step of the recursion. 
+        /// Return the InfAlg to use at each step of the recursion.
         /// \todo At present, only returns a BP instance
         InfAlg* getInfAlg();
 
         /// \todo At present, only returns a BP instance
         InfAlg* getInfAlg();
 
@@ -151,7 +151,7 @@ class CBP : public DAIAlgFG {
             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);
             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
             size_t verbose = 0;
 
             /// Verbosity
             size_t verbose = 0;
 
@@ -185,8 +185,8 @@ class CBP : public DAIAlgFG {
             std::string clamp_outfile = "";
         }
         */
             std::string clamp_outfile = "";
         }
         */
-/* {{{ GENERATED CODE: DO NOT EDIT. Created by 
-    ./scripts/regenerate-properties include/dai/cbp.h src/cbp.cpp 
+/* {{{ GENERATED CODE: DO NOT EDIT. Created by
+    ./scripts/regenerate-properties include/dai/cbp.h src/cbp.cpp
 */
         struct Properties {
             /// Enumeration of possible update schedules
 */
         struct Properties {
             /// Enumeration of possible update schedules
index cbea8ca..4d63941 100644 (file)
@@ -40,7 +40,7 @@ namespace dai {
 
     /// A ClusterGraph is a hypergraph with VarSets as nodes.
     /** It is implemented as bipartite graph with variable (Var) nodes
 
     /// A ClusterGraph is a hypergraph with VarSets as nodes.
     /** It is implemented as bipartite graph with variable (Var) nodes
-     *  and cluster (VarSet) nodes. 
+     *  and cluster (VarSet) nodes.
      */
     class ClusterGraph {
         public:
      */
     class ClusterGraph {
         public:
@@ -65,7 +65,7 @@ namespace dai {
 
             /// Construct from vector<VarSet>
             ClusterGraph( const std::vector<VarSet> & cls );
 
             /// Construct from vector<VarSet>
             ClusterGraph( const std::vector<VarSet> & cls );
-            
+
             /// Returns true if cluster I is not contained in a larger cluster
             bool isMaximal( size_t I ) const {
                 DAI_DEBASSERT( I < G.nr2() );
             /// Returns true if cluster I is not contained in a larger cluster
             bool isMaximal( size_t I ) const {
                 DAI_DEBASSERT( I < G.nr2() );
@@ -116,7 +116,7 @@ namespace dai {
                     }
                 return result;
             }
                     }
                 return result;
             }
-            
+
             /// Returns union of clusters that contain the variable with index i
             VarSet Delta( size_t i ) const {
                 VarSet result;
             /// Returns union of clusters that contain the variable with index i
             VarSet Delta( size_t i ) const {
                 VarSet result;
@@ -147,7 +147,7 @@ namespace dai {
             VarSet delta( size_t i ) const {
                 return Delta( i ) / vars[i];
             }
             VarSet delta( size_t i ) const {
                 return Delta( i ) / vars[i];
             }
-            
+
             /// Erases all clusters that contain n where n is the variable with index i
             ClusterGraph& eraseSubsuming( size_t i ) {
                 while( G.nb1(i).size() ) {
             /// Erases all clusters that contain n where n is the variable with index i
             ClusterGraph& eraseSubsuming( size_t i ) {
                 while( G.nb1(i).size() ) {
@@ -156,7 +156,7 @@ namespace dai {
                 }
                 return *this;
             }
                 }
                 return *this;
             }
-            
+
             /// Returns a const reference to the clusters
             const std::vector<VarSet> & toVector() const { return clusters; }
 
             /// Returns a const reference to the clusters
             const std::vector<VarSet> & toVector() const { return clusters; }
 
index 2d5274f..8f454ce 100644 (file)
@@ -40,8 +40,8 @@ namespace dai {
 
 
 /// InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI.
 
 
 /// InfAlg is an abstract base class, defining the common interface of all inference algorithms in libDAI.
-/** \todo 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. 
+/** \todo 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().
  */
  *  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().
  */
@@ -140,18 +140,18 @@ class InfAlg {
 /// Combines an InfAlg and a graphical model, e.g., a FactorGraph or RegionGraph
 /** \tparam GRM Should be castable to FactorGraph
  *  \todo A DAIAlg should not inherit from a FactorGraph or RegionGraph, but should
 /// Combines an InfAlg and a graphical model, e.g., a FactorGraph or RegionGraph
 /** \tparam GRM Should be castable to FactorGraph
  *  \todo 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?). 
+ *  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 GRM>
 class DAIAlg : public InfAlg, public GRM {
     public:
         /// Default constructor
         DAIAlg() : InfAlg(), GRM() {}
  */
 template <class GRM>
 class DAIAlg : public InfAlg, public GRM {
     public:
         /// Default constructor
         DAIAlg() : InfAlg(), GRM() {}
-        
-        /// Construct from GRM 
+
+        /// Construct from GRM
         DAIAlg( const GRM &grm ) : InfAlg(), GRM(grm) {}
 
         /// Save factor I
         DAIAlg( const GRM &grm ) : InfAlg(), GRM(grm) {}
 
         /// Save factor I
@@ -169,7 +169,7 @@ class DAIAlg : public InfAlg, public GRM {
 
         // OBSOLETE
         /// Only for backwards compatibility (to be removed soon)
 
         // OBSOLETE
         /// Only for backwards compatibility (to be removed soon)
-        void clamp( const Var &v, size_t x, bool backup = false ) { 
+        void clamp( const Var &v, size_t x, bool backup = false ) {
             GRM::clamp( v, x, backup );
             std::cerr << "Warning: this DAIAlg<...>::clamp(const Var&,...) interface is obsolete!" << std::endl;
         }
             GRM::clamp( v, x, backup );
             std::cerr << "Warning: this DAIAlg<...>::clamp(const Var&,...) interface is obsolete!" << std::endl;
         }
index 1e5686b..5ce7188 100644 (file)
@@ -46,7 +46,7 @@
  *  some sparse factors, some noisy-OR factors, some dense factors, some arbitrary
  *  precision factors, etc.
  *
  *  some sparse factors, some noisy-OR factors, some dense factors, some arbitrary
  *  precision factors, etc.
  *
- *  \idea Use Boost::uBLAS framework to deal with matrices, especially, with 2D sparse matrices. 
+ *  \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
  *
  *  \idea Introduce naming scheme:
  *  See http://www.boost.org/libs/numeric/ublas/doc/matrix_sparse.htm
  *
  *  \idea Introduce naming scheme:
  *  \code
  *  template <typename Node1Properties, typename Node2Properties, typename EdgeProperties>
  *  class ExtFactorGraph : public FactorGraph {
  *  \code
  *  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;
- *         // ...
+ *      public:
+ *          std::vector<Node1Properties>              node1Props;
+ *          std::vector<Node2Properties>              node2Props;
+ *          std::vector<std::vector<EdgeProperties> > edgeProps;
+ *         // ...
  *  }
  *  \endcode
  *
  *  }
  *  \endcode
  *
- *  Advantages: 
+ *  Advantages:
  *  - Less code duplication.
  *  - Easier maintainability.
  *  - Easier to write new inference algorithms.
  *  - Less code duplication.
  *  - Easier maintainability.
  *  - Easier to write new inference algorithms.
  *  - 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?
  *  - 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 
+ *    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
  *    (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. 
+ *  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<typename InfAlg>
  *  Factor calcMarginal( const InfAlg &obj, const VarSet &ns, bool reInit );
  *  \endcode
  *  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<typename InfAlg>
  *  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, 
+ *  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
  *  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, 
+ *  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.
  */
  *  this is compile-time polymorphism, whereas tests/testdai needs runtime polymorphism.
  *  Therefore this is probably a bad idea.
  */
  *
  *  \section about About libDAI
  *  libDAI is a free/open source C++ library (licensed under GPLv2+) that provides
  *
  *  \section about About libDAI
  *  libDAI is a free/open source C++ library (licensed under GPLv2+) 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 
+ *  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.
  *
  *  Networks.
  *
- *  The library is targeted at researchers. To be able to use the library, a 
- *  good understanding of graphical models is needed. 
+ *  The library is targeted at researchers. To be able to use the library, a
+ *  good understanding of graphical models is needed.
  *
  *  \section limitations Limitations
  *
  *  \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 
+ *  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 EM for learning factor parameters.
  *  for standard file formats may be added later), and provides very limited
  *  visualization functionalities. The only learning method supported currently
  *  is EM for learning factor parameters.
  *  \section language Why C++?
  *  Because libDAI is implemented in C++, it is very fast compared with
  *  implementations in MatLab (a factor 1000 faster is not uncommon).
  *  \section language Why C++?
  *  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 MatLab interface for easy integration with MatLab. 
+ *  libDAI does provide a MatLab interface for easy integration with MatLab.
  */
 
 
  */
 
 
 
 
 /** \page fileformat libDAI factorgraph file format
 
 
 /** \page fileformat libDAI factorgraph file format
- *  
+ *
  *  This page describes the .fg fileformat 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
  *  This page describes the .fg fileformat 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
  *  empty lines. Each variable occurring in the factor graph has a unique
  *  identifier, its index (which should be a nonnegative integer). Comment lines
  *  start with #.
  *  empty lines. Each variable occurring in the factor graph has a unique
  *  identifier, its index (which should be a nonnegative integer). Comment lines
  *  start with #.
- *  
+ *
  *  Each block starts with a line containing the number of variables in that
  *  factor. The second line contains the indices of these variables, seperated by
  *  spaces (indices are nonnegative integers and to avoid confusion, it is
  *  Each block starts with a line containing the number of variables in that
  *  factor. The second line contains the indices of these variables, seperated by
  *  spaces (indices are nonnegative integers and to avoid confusion, it is
  *  convention that is used is that the left-most variables cycle through their
  *  values the fastest (similar to MATLAB indexing of multidimensional arrays). An
  *  example block describing one factor is:
  *  convention that is used is that the left-most variables cycle through their
  *  values the fastest (similar to MATLAB indexing of multidimensional arrays). An
  *  example block describing one factor is:
- *  
+ *
  *  3\n
  *  4 8 7\n
  *  3 2 2\n
  *  3\n
  *  4 8 7\n
  *  3 2 2\n
  *  10 1.6\n
  *  12 6.4\n
  *  11 2.6\n
  *  10 1.6\n
  *  12 6.4\n
  *  11 2.6\n
- *  
+ *
  *  which corresponds to the following factor:
  *  which corresponds to the following factor:
- *  
+ *
  *  \f[
  *  \begin{array}{ccc|c}
  *  x_4 & x_8 & x_7 & \mbox{value}\\
  *  \f[
  *  \begin{array}{ccc|c}
  *  x_4 & x_8 & x_7 & \mbox{value}\\
  *  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.
  *  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:
  *  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:
- *  
+ *
  *  \f[
  *  \begin{array}{ccc|c}
  *  x_4 & x_7 & x_8 & \mbox{value}\\
  *  \f[
  *  \begin{array}{ccc|c}
  *  x_4 & x_7 & x_8 & \mbox{value}\\
index 4146717..6aea876 100644 (file)
@@ -41,9 +41,9 @@
 namespace dai {
 
 
 namespace dai {
 
 
-/// Interface for a parameter estimation method. 
-/** This parameter estimation interface is based on sufficient statistics. 
- *  Implementations are responsible for collecting data from a probability 
+/// Interface for a parameter estimation method.
+/** This parameter estimation interface is based on sufficient statistics.
+ *  Implementations are responsible for collecting data from a probability
  *  vector passed to it from a SharedParameters container object.
  *
  *  Implementations of this interface should register a factory function
  *  vector passed to it from a SharedParameters container object.
  *
  *  Implementations of this interface should register a factory function
@@ -52,7 +52,7 @@ namespace dai {
  *  "ConditionalProbEstimation".
  */
 class ParameterEstimation {
  *  "ConditionalProbEstimation".
  */
 class ParameterEstimation {
-    public:  
+    public:
         /// A pointer to a factory function.
         typedef ParameterEstimation* (*ParamEstFactory)( const PropertySet& );
 
         /// A pointer to a factory function.
         typedef ParameterEstimation* (*ParamEstFactory)( const PropertySet& );
 
@@ -101,7 +101,7 @@ class CondProbEstimation : private ParameterEstimation {
 
     public:
         /// Constructor
 
     public:
         /// Constructor
-        /** For a conditional probability \f$ P( X | Y ) \f$, 
+        /** For a conditional probability \f$ P( X | Y ) \f$,
          *  \param target_dimension should equal \f$ | X | \f$
          *  \param pseudocounts has length \f$ |X| \cdot |Y| \f$
          */
          *  \param target_dimension should equal \f$ | X | \f$
          *  \param pseudocounts has length \f$ |X| \cdot |Y| \f$
          */
@@ -109,30 +109,30 @@ class CondProbEstimation : private ParameterEstimation {
 
         /// Virtual constructor, using a PropertySet.
         /** Some keys in the PropertySet are required.
 
         /// Virtual constructor, using a PropertySet.
         /** Some keys in the PropertySet are required.
-         *  For a conditional probability \f$ P( X | Y ) \f$, 
+         *  For a conditional probability \f$ P( X | Y ) \f$,
          *     - target_dimension should be equal to \f$ | X | \f$
          *     - total_dimension should be equal to \f$ |X| \cdot |Y| \f$
          *     - target_dimension should be equal to \f$ | X | \f$
          *     - total_dimension should be equal to \f$ |X| \cdot |Y| \f$
-         *  
+         *
          *  An optional key is:
          *     - pseudo_count, which specifies the initial counts (defaults to 1)
          */
         static ParameterEstimation* factory( const PropertySet &p );
          *  An optional key is:
          *     - 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() {}
         /// 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.
         /// Returns an estimate of the conditional probability distribution.
-        /** The format of the resulting Prob keeps all the values for 
+        /** The format of the resulting Prob keeps all the values for
          *  \f$ P(X | Y=y) \f$ in sequential order in the array.
          */
         virtual Prob estimate();
          *  \f$ P(X | Y=y) \f$ in sequential order in the array.
          */
         virtual Prob estimate();
-        
+
         /// Accumulate sufficient statistics from the expectations in p.
         virtual void addSufficientStatistics( const Prob &p );
         /// Accumulate sufficient statistics from the expectations in p.
         virtual void addSufficientStatistics( const Prob &p );
-        
+
         /// Returns the required size for arguments to addSufficientStatistics.
         virtual size_t probSize() const { return _stats.size(); }
 };
         /// Returns the required size for arguments to addSufficientStatistics.
         virtual size_t probSize() const { return _stats.size(); }
 };
@@ -140,8 +140,8 @@ class CondProbEstimation : private ParameterEstimation {
 
 /// A single factor or set of factors whose parameters should be estimated.
 /** To ensure that parameters can be shared between different factors during
 
 /// 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 
+ *  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 couples one or more factors (together with the specified orderings
  *  of the variables) with a ParameterEstimation object, taking care of the
  *  from the canonical ordering used in libDAI. The SharedParameters
  *  class couples one or more factors (together with the specified orderings
  *  of the variables) with a ParameterEstimation object, taking care of the
@@ -176,18 +176,18 @@ class SharedParameters {
         /// Copy constructor
         SharedParameters( const SharedParameters &sp );
 
         /// Copy constructor
         SharedParameters( const SharedParameters &sp );
 
-        /// Constructor 
+        /// Constructor
         /** \param varorders  all the factor orientations for this parameter
          *  \param estimation a pointer to the parameter estimation method
          *  \param deletePE whether the parameter estimation object should be deleted in the destructor
         /** \param varorders  all the factor orientations for this parameter
          *  \param estimation a pointer to the parameter estimation method
          *  \param deletePE whether the parameter estimation object should be deleted in the destructor
-         */ 
+         */
         SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool deletePE=false );
 
         /// Constructor for making an object from a stream and a factor graph
         SharedParameters( std::istream &is, const FactorGraph &fg_varlookup );
 
         /// Destructor
         SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool deletePE=false );
 
         /// Constructor for making an object from a stream and a factor graph
         SharedParameters( std::istream &is, const FactorGraph &fg_varlookup );
 
         /// Destructor
-        ~SharedParameters() { 
+        ~SharedParameters() {
             if( _deleteEstimation )
                 delete _estimation;
         }
             if( _deleteEstimation )
                 delete _estimation;
         }
@@ -204,7 +204,7 @@ class SharedParameters {
 
 
 /// A MaximizationStep groups together several parameter estimation tasks into a single unit.
 
 
 /// A MaximizationStep groups together several parameter estimation tasks into a single unit.
-class MaximizationStep { 
+class MaximizationStep {
     private:
         std::vector<SharedParameters> _params;
 
     private:
         std::vector<SharedParameters> _params;
 
@@ -213,7 +213,7 @@ class MaximizationStep {
         MaximizationStep() : _params() {}
 
         /// Constructor from a vector of SharedParameters objects
         MaximizationStep() : _params() {}
 
         /// Constructor from a vector of SharedParameters objects
-        MaximizationStep( std::vector<SharedParameters> &maximizations ) : _params(maximizations) {}  
+        MaximizationStep( std::vector<SharedParameters> &maximizations ) : _params(maximizations) {}
 
         /// Constructor from an input stream and a corresponding factor graph
         MaximizationStep( std::istream &is, const FactorGraph &fg_varlookup );
 
         /// Constructor from an input stream and a corresponding factor graph
         MaximizationStep( std::istream &is, const FactorGraph &fg_varlookup );
@@ -242,7 +242,7 @@ class MaximizationStep {
  *     - InfAlg for performing the E-step, which includes the factor graph,
  *     - a vector of MaximizationSteps steps to be performed.
  *
  *     - InfAlg for performing the E-step, which includes the factor graph,
  *     - a vector of MaximizationSteps steps to be performed.
  *
- *  This implementation can perform incremental EM by using multiple 
+ *  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
  *  MaximizationSteps.
  *  MaximizationSteps.  An expectation step is performed between execution
  *  of each MaximizationStep.  A call to iterate() will cycle through all
  *  MaximizationSteps.
@@ -250,7 +250,7 @@ class MaximizationStep {
  *  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.
  *  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.
- */  
+ */
 class EMAlg {
     private:
         /// All the data samples used during learning
 class EMAlg {
     private:
         /// All the data samples used during learning
@@ -285,12 +285,12 @@ class EMAlg {
         static const Real LOG_Z_TOL_DEFAULT;
 
         /// Construct an EMAlg from all these objects
         static const Real LOG_Z_TOL_DEFAULT;
 
         /// Construct an EMAlg from all these objects
-        EMAlg( const Evidence &evidence, InfAlg &estep, std::vector<MaximizationStep> &msteps, const PropertySet &termconditions ) 
+        EMAlg( const Evidence &evidence, InfAlg &estep, std::vector<MaximizationStep> &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)
           : _evidence(evidence), _estep(estep), _msteps(msteps), _iters(0), _lastLogZ(), _max_iters(MAX_ITERS_DEFAULT), _log_z_tol(LOG_Z_TOL_DEFAULT)
-        { 
+        {
               setTermConditions( termconditions );
         }
               setTermConditions( termconditions );
         }
-  
+
         /// Construct an EMAlg from an Evidence object, an InfAlg object, and an input stream
         EMAlg( const Evidence &evidence, InfAlg &estep, std::istream &mstep_file );
 
         /// Construct an EMAlg from an Evidence object, an InfAlg object, and an input stream
         EMAlg( const Evidence &evidence, InfAlg &estep, std::istream &mstep_file );
 
@@ -306,7 +306,7 @@ class EMAlg {
         /// Determine if the termination conditions have been met.
         /** There are two sufficient termination conditions:
          *    -# the maximum number of iterations has been performed
         /// 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 
+         *    -# 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$.
          */
          *       tolerance, i.e.,
          *       \f$ \frac{\log(Z_t) - \log(Z_{t-1})}{| \log(Z_{t-1}) | } < \mathrm{tol} \f$.
          */
index eeb620d..60a3281 100644 (file)
@@ -47,10 +47,10 @@ class Observation {
 
         /// Get all observations
         const std::map<Var, size_t>& observations() const { return _obs; }
 
         /// Get all observations
         const std::map<Var, size_t>& observations() const { return _obs; }
-        
+
         /// Add an observation
         void addObservation( Var node, size_t setting );
         /// Add an observation
         void addObservation( Var node, size_t setting );
-        
+
         /// Clamp variables in the graphical model to their observed values
         void applyEvidence( InfAlg& alg ) const;
 };
         /// Clamp variables in the graphical model to their observed values
         void applyEvidence( InfAlg& alg ) const;
 };
@@ -68,21 +68,21 @@ class Evidence {
     public:
         /// Default constructor
         Evidence() : _samples() {}
     public:
         /// Default constructor
         Evidence() : _samples() {}
-      
+
         /// Construct from existing samples
         Evidence( std::vector<Observation> &samples ) : _samples(samples) {}
 
         /// Construct from existing samples
         Evidence( std::vector<Observation> &samples ) : _samples(samples) {}
 
-        /// Read in tabular data from a stream. 
+        /// Read in tabular data from a stream.
         /** Each line contains one sample, and the first line is a header line with names.
          */
         void addEvidenceTabFile( std::istream& is, std::map<std::string, Var> &varMap );
         /** Each line contains one sample, and the first line is a header line with names.
          */
         void addEvidenceTabFile( std::istream& is, std::map<std::string, Var> &varMap );
-    
-        /// Read in tabular data from a stream. 
-        /** Each line contains one sample, and the first line is a header line with 
+
+        /// Read in tabular data from a stream.
+        /** Each line contains one sample, and the first line is a header line with
          *  variable labels which should correspond with a subset of the variables in fg.
          */
         void addEvidenceTabFile( std::istream& is, FactorGraph& fg );
          *  variable labels which should correspond with a subset of the variables in fg.
          */
         void addEvidenceTabFile( std::istream& is, FactorGraph& fg );
-      
+
         /// Returns number of stored samples
         size_t nrSamples() const { return _samples.size(); }
 
         /// Returns number of stored samples
         size_t nrSamples() const { return _samples.size(); }
 
index 6094478..b405316 100644 (file)
@@ -65,7 +65,7 @@ class ExactInf : public DAIAlgFG {
             construct();
         }
 
             construct();
         }
 
-        
+
         /// @name General InfAlg interface
         //@{
         virtual ExactInf* clone() const { return new ExactInf(*this); }
         /// @name General InfAlg interface
         //@{
         virtual ExactInf* clone() const { return new ExactInf(*this); }
@@ -80,10 +80,10 @@ class ExactInf : public DAIAlgFG {
         virtual double maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; }
         virtual size_t Iterations() const { DAI_THROW(NOT_IMPLEMENTED); return 0; }
         //@}
         virtual double maxDiff() const { DAI_THROW(NOT_IMPLEMENTED); return 0.0; }
         virtual size_t Iterations() const { DAI_THROW(NOT_IMPLEMENTED); return 0; }
         //@}
-        
+
 
         /// @name Additional interface specific for ExactInf
 
         /// @name Additional interface specific for ExactInf
-        //@{ 
+        //@{
         Factor beliefV( size_t i ) const { return _beliefsV[i]; }
         Factor beliefF( size_t I ) const { return _beliefsF[I]; }
         //@}
         Factor beliefV( size_t i ) const { return _beliefsV[i]; }
         Factor beliefF( size_t I ) const { return _beliefsF[I]; }
         //@}
index bf5c338..87f8876 100644 (file)
@@ -92,11 +92,11 @@ class Exception : public std::runtime_error {
                    NUM_ERRORS};  // NUM_ERRORS should be the last entry
 
         /// Constructor
                    NUM_ERRORS};  // NUM_ERRORS should be the last entry
 
         /// Constructor
-        Exception( Code _code, const std::string& msg="", const std::string& detailedMsg="" ) : std::runtime_error(ErrorStrings[_code] + " [" +  msg + "]"), errorcode(_code) { 
-            if( !detailedMsg.empty() ) 
-                std::cerr << "ERROR: " << detailedMsg << std::endl; 
+        Exception( Code _code, const std::string& msg="", const std::string& detailedMsg="" ) : std::runtime_error(ErrorStrings[_code] + " [" +  msg + "]"), errorcode(_code) {
+            if( !detailedMsg.empty() )
+                std::cerr << "ERROR: " << detailedMsg << std::endl;
         }
         }
-        
+
         /// Copy constructor
         Exception( const Exception &e ) : std::runtime_error(e), errorcode(e.errorcode) {}
 
         /// Copy constructor
         Exception( const Exception &e ) : std::runtime_error(e), errorcode(e.errorcode) {}
 
index 0889bb5..d44e6f5 100644 (file)
@@ -60,19 +60,19 @@ template<typename T> struct divides0 : public std::binary_function<T, T, T> {
  *  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$,
  *  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$,
- *  then a factor depending on the variables \f$\{x_l\}_{l\in L}\f$ is 
+ *  then 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$.
  *  a function \f$f_L : \prod_{l\in L} X_l \to [0,\infty)\f$.
- *  
+ *
  *  In libDAI, a factor is represented by a TFactor<\a T> object, which has two
  *  In libDAI, a factor is represented by a TFactor<\a T> object, which has two
- *  components: 
- *  \arg a VarSet, corresponding with the set of variables \f$\{x_l\}_{l\in L}\f$ 
+ *  components:
+ *  \arg a VarSet, corresponding with the set of variables \f$\{x_l\}_{l\in L}\f$
  *  that the factor depends on;
  *  that the factor depends on;
- *  \arg a TProb<\a T>, a vector containing the value of the factor for each possible 
+ *  \arg a TProb<\a T>, 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<\a T> in a particular
  *  joint state of the variables.
  *
  *  The factor values are stored in the entries of the TProb<\a T> 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 
+ *  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 VarSet::calcState(const std::map<Var,size_t> &).
  *
  *  \f$\{0,1,\dots,\prod_{l\in L} S_l-1\}\f$ according to the mapping \f$\sigma\f$
  *  induced by VarSet::calcState(const std::map<Var,size_t> &).
  *
@@ -87,20 +87,20 @@ template <typename T> class TFactor {
 
     public:
         /// Iterator over factor entries
 
     public:
         /// Iterator over factor entries
-               typedef typename TProb<T>::iterator iterator;
+        typedef typename TProb<T>::iterator iterator;
 
         /// Const iterator over factor entries
 
         /// Const iterator over factor entries
-               typedef typename TProb<T>::const_iterator const_iterator;
+        typedef typename TProb<T>::const_iterator const_iterator;
 
         /// Constructs TFactor depending on no variables, with value p
         TFactor ( Real p = 1.0 ) : _vs(), _p(1,p) {}
 
         /// Constructs TFactor depending on variables in vars, with uniform distribution
         TFactor( const VarSet& vars ) : _vs(vars), _p(_vs.nrStates()) {}
 
         /// Constructs TFactor depending on no variables, with value p
         TFactor ( Real p = 1.0 ) : _vs(), _p(1,p) {}
 
         /// Constructs TFactor depending on variables in vars, with uniform distribution
         TFactor( const VarSet& vars ) : _vs(vars), _p(_vs.nrStates()) {}
-        
+
         /// Constructs TFactor depending on variables in vars, with all values set to p
         TFactor( const VarSet& vars, Real p ) : _vs(vars), _p(_vs.nrStates(),p) {}
         /// Constructs TFactor depending on variables in vars, with all values set to p
         TFactor( const VarSet& vars, Real p ) : _vs(vars), _p(_vs.nrStates(),p) {}
-        
+
         /// Constructs TFactor depending on variables in vars, copying the values from the range starting at begin
         /** \param vars contains the variables that the new TFactor should depend on.
          *  \tparam Iterator Iterates over instances of type T; should support addition of size_t.
         /// Constructs TFactor depending on variables in vars, copying the values from the range starting at begin
         /** \param vars contains the variables that the new TFactor should depend on.
          *  \tparam Iterator Iterates over instances of type T; should support addition of size_t.
@@ -120,7 +120,7 @@ template <typename T> class TFactor {
             for( size_t li = 0; li < p.size(); ++li )
                 _p[permindex.convert_linear_index(li)] = p[li];
         }
             for( size_t li = 0; li < p.size(); ++li )
                 _p[permindex.convert_linear_index(li)] = p[li];
         }
-        
+
         /// Constructs TFactor depending on the variable v, with uniform distribution
         TFactor( const Var &v ) : _vs(v), _p(v.states()) {}
 
         /// Constructs TFactor depending on the variable v, with uniform distribution
         TFactor( const Var &v ) : _vs(v), _p(v.states()) {}
 
@@ -142,15 +142,15 @@ template <typename T> class TFactor {
 
         /// Returns a reference to the i'th entry of the value vector
         T& operator[] (size_t i) { return _p[i]; }
 
         /// Returns a reference to the i'th entry of the value vector
         T& operator[] (size_t i) { return _p[i]; }
-        
+
         /// Returns iterator pointing to first entry
         iterator begin() { return _p.begin(); }
         /// Returns const iterator pointing to first entry
         /// Returns iterator pointing to first entry
         iterator begin() { return _p.begin(); }
         /// Returns const iterator pointing to first entry
-               const_iterator begin() const { return _p.begin(); }
-               /// Returns iterator pointing beyond last entry
-               iterator end() { return _p.end(); }
-               /// Returns const iterator pointing beyond last entry
-               const_iterator end() const { return _p.end(); }
+        const_iterator begin() const { return _p.begin(); }
+        /// Returns iterator pointing beyond last entry
+        iterator end() { return _p.end(); }
+        /// Returns const iterator pointing beyond last entry
+        const_iterator end() const { return _p.end(); }
 
         /// Sets all values to p
         TFactor<T> & fill (T p) { _p.fill( p ); return(*this); }
 
         /// Sets all values to p
         TFactor<T> & fill (T p) { _p.fill( p ); return(*this); }
@@ -172,13 +172,13 @@ template <typename T> class TFactor {
         }
 
         /// Adds scalar t to *this
         }
 
         /// Adds scalar t to *this
-        TFactor<T>& operator+= (T t) { 
+        TFactor<T>& operator+= (T t) {
             _p += t;
             return *this;
         }
 
         /// Subtracts scalar t from *this
             _p += t;
             return *this;
         }
 
         /// Subtracts scalar t from *this
-        TFactor<T>& operator-= (T t) { 
+        TFactor<T>& operator-= (T t) {
             _p -= t;
             return *this;
         }
             _p -= t;
             return *this;
         }
@@ -203,64 +203,64 @@ template <typename T> class TFactor {
 
         /// Returns sum of *this and scalar t
         TFactor<T> operator+ (T t) const {
 
         /// Returns sum of *this and scalar t
         TFactor<T> operator+ (T t) const {
-            TFactor<T> result(*this); 
-            result._p += t; 
-            return result; 
+            TFactor<T> result(*this);
+            result._p += t;
+            return result;
         }
 
         /// Returns *this minus scalar t
         TFactor<T> operator- (T t) const {
         }
 
         /// Returns *this minus scalar t
         TFactor<T> operator- (T t) const {
-            TFactor<T> result(*this); 
-            result._p -= t; 
-            return result; 
+            TFactor<T> result(*this);
+            result._p -= t;
+            return result;
         }
 
         /// Returns *this raised to the power a
         }
 
         /// Returns *this raised to the power a
-        TFactor<T> operator^ (Real a) const { 
-            TFactor<T> x; 
-            x._vs = _vs; 
-            x._p = _p^a; 
-            return x; 
+        TFactor<T> operator^ (Real a) const {
+            TFactor<T> x;
+            x._vs = _vs;
+            x._p = _p^a;
+            return x;
         }
 
         /// Multiplies *this with the TFactor f
         }
 
         /// Multiplies *this with the TFactor f
-        TFactor<T>& operator*= (const TFactor<T>& f) { 
+        TFactor<T>& operator*= (const TFactor<T>& f) {
             if( f._vs == _vs ) // optimize special case
                 _p *= f._p;
             else
             if( f._vs == _vs ) // optimize special case
                 _p *= f._p;
             else
-                *this = (*this * f); 
+                *this = (*this * f);
             return *this;
         }
 
         /// Divides *this by the TFactor f
             return *this;
         }
 
         /// Divides *this by the TFactor f
-        TFactor<T>& operator/= (const TFactor<T>& f) { 
+        TFactor<T>& operator/= (const TFactor<T>& f) {
             if( f._vs == _vs ) // optimize special case
                 _p /= f._p;
             else
             if( f._vs == _vs ) // optimize special case
                 _p /= f._p;
             else
-                *this = (*this / f); 
+                *this = (*this / f);
             return *this;
         }
 
         /// Adds the TFactor f to *this
             return *this;
         }
 
         /// Adds the TFactor f to *this
-        TFactor<T>& operator+= (const TFactor<T>& f) { 
+        TFactor<T>& operator+= (const TFactor<T>& f) {
             if( f._vs == _vs ) // optimize special case
                 _p += f._p;
             else
             if( f._vs == _vs ) // optimize special case
                 _p += f._p;
             else
-                *this = (*this + f); 
+                *this = (*this + f);
             return *this;
         }
 
         /// Subtracts the TFactor f from *this
             return *this;
         }
 
         /// Subtracts the TFactor f from *this
-        TFactor<T>& operator-= (const TFactor<T>& f) { 
+        TFactor<T>& operator-= (const TFactor<T>& f) {
             if( f._vs == _vs ) // optimize special case
                 _p -= f._p;
             else
             if( f._vs == _vs ) // optimize special case
                 _p -= f._p;
             else
-                *this = (*this - f); 
+                *this = (*this - f);
             return *this;
         }
 
         /// Returns product of *this with the TFactor f
             return *this;
         }
 
         /// Returns product of *this with the TFactor f
-        /** The product of two factors is defined as follows: if 
+        /** 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]
          */
          *  \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]
          */
@@ -269,7 +269,7 @@ template <typename T> class TFactor {
         }
 
         /// Returns quotient of *this by the TFactor f
         }
 
         /// Returns quotient of *this by the TFactor f
-        /** The quotient of two factors is defined as follows: if 
+        /** 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]
          */
          *  \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]
          */
@@ -278,7 +278,7 @@ template <typename T> class TFactor {
         }
 
         /// Returns sum of *this and the TFactor f
         }
 
         /// Returns sum of *this and the TFactor f
-        /** The sum of two factors is defined as follows: if 
+        /** 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]
          */
          *  \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]
          */
@@ -287,7 +287,7 @@ template <typename T> class TFactor {
         }
 
         /// Returns *this minus the TFactor f
         }
 
         /// Returns *this minus the TFactor f
-        /** The difference of two factors is defined as follows: if 
+        /** 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]
          */
          *  \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]
          */
@@ -307,48 +307,48 @@ template <typename T> class TFactor {
             _p.makePositive( epsilon );
             return *this;
         }
             _p.makePositive( epsilon );
             return *this;
         }
-            
+
         /// Returns pointwise inverse of *this.
         /** If zero == true, uses 1 / 0 == 0; otherwise 1 / 0 == Inf.
          */
         /// Returns pointwise inverse of *this.
         /** If zero == true, uses 1 / 0 == 0; otherwise 1 / 0 == Inf.
          */
-        TFactor<T> inverse(bool zero=true) const { 
-            TFactor<T> inv; 
-            inv._vs = _vs; 
+        TFactor<T> inverse(bool zero=true) const {
+            TFactor<T> inv;
+            inv._vs = _vs;
             inv._p = _p.inverse(zero);
             inv._p = _p.inverse(zero);
-            return inv; 
+            return inv;
         }
 
         /// Returns pointwise exp of *this
         }
 
         /// Returns pointwise exp of *this
-        TFactor<T> exp() const { 
-            TFactor<T> e; 
-            e._vs = _vs; 
-            e._p = _p.exp(); 
-            return e; 
+        TFactor<T> exp() const {
+            TFactor<T> e;
+            e._vs = _vs;
+            e._p = _p.exp();
+            return e;
         }
 
         /// Returns pointwise logarithm of *this
         /** If zero==true, uses log(0)==0; otherwise, log(0)=-Inf.
          */
         TFactor<T> log(bool zero=false) const {
         }
 
         /// Returns pointwise logarithm of *this
         /** If zero==true, uses log(0)==0; otherwise, log(0)=-Inf.
          */
         TFactor<T> log(bool zero=false) const {
-            TFactor<T> l; 
-            l._vs = _vs; 
-            l._p = _p.log(zero); 
-            return l; 
+            TFactor<T> l;
+            l._vs = _vs;
+            l._p = _p.log(zero);
+            return l;
         }
 
         /// Returns pointwise absolute value of *this
         }
 
         /// Returns pointwise absolute value of *this
-        TFactor<T> abs() const { 
-            TFactor<T> e; 
-            e._vs = _vs; 
-            e._p = _p.abs(); 
-            return e; 
+        TFactor<T> abs() const {
+            TFactor<T> e;
+            e._vs = _vs;
+            e._p = _p.abs();
+            return e;
         }
 
         /// Normalizes *this TFactor according to the specified norm
         T normalize( typename Prob::NormType norm=Prob::NORMPROB ) { return _p.normalize( norm ); }
 
         /// Returns a normalized copy of *this, according to the specified norm
         }
 
         /// Normalizes *this TFactor according to the specified norm
         T normalize( typename Prob::NormType norm=Prob::NORMPROB ) { return _p.normalize( norm ); }
 
         /// Returns a normalized copy of *this, according to the specified norm
-        TFactor<T> normalized( typename Prob::NormType norm=Prob::NORMPROB ) const { 
+        TFactor<T> normalized( typename Prob::NormType norm=Prob::NORMPROB ) const {
             TFactor<T> result;
             result._vs = _vs;
             result._p = _p.normalized( norm );
             TFactor<T> result;
             result._vs = _vs;
             result._p = _p.normalized( norm );
@@ -360,10 +360,10 @@ template <typename T> class TFactor {
          *  \pre \a nsState < ns.states()
          *
          *  The result is a TFactor that depends on the variables in this->vars() except those in \a ns,
          *  \pre \a nsState < ns.states()
          *
          *  The result is a TFactor that depends on the variables in this->vars() except those in \a ns,
-         *  obtained by setting the variables in \a ns to the joint state specified by the linear index 
+         *  obtained by setting the variables in \a ns to the joint state specified by the linear index
          *  \a nsState. Formally, if *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 ns and \a nsState corresponds with a mapping \f$s\f$ that
          *  \a nsState. Formally, if *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 ns and \a nsState 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 
+         *  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$.
          */
          *  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$.
          */
@@ -371,7 +371,7 @@ template <typename T> class TFactor {
             assert( ns << _vs );
             VarSet nsrem = _vs / ns;
             TFactor<T> result( nsrem, T(0) );
             assert( ns << _vs );
             VarSet nsrem = _vs / ns;
             TFactor<T> result( nsrem, T(0) );
-            
+
             // OPTIMIZE ME
             IndexFor i_ns (ns, _vs);
             IndexFor i_nsrem (nsrem, _vs);
             // OPTIMIZE ME
             IndexFor i_ns (ns, _vs);
             IndexFor i_nsrem (nsrem, _vs);
@@ -394,7 +394,7 @@ template <typename T> class TFactor {
          *  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$.
          */
          *  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<T> embed(const VarSet & ns) const { 
+        TFactor<T> embed(const VarSet & ns) const {
             assert( ns >> _vs );
             if( _vs == ns )
                 return *this;
             assert( ns >> _vs );
             if( _vs == ns )
                 return *this;
@@ -464,10 +464,10 @@ template<typename T> TFactor<T> TFactor<T>::maxMarginal(const VarSet & ns, bool
 /// Apply binary operator pointwise on two factors
 template<typename T, typename binaryOp> TFactor<T> pointwiseOp( const TFactor<T> &f, const TFactor<T> &g, binaryOp op ) {
     if( f.vars() == g.vars() ) { // optimizate special case
 /// Apply binary operator pointwise on two factors
 template<typename T, typename binaryOp> TFactor<T> pointwiseOp( const TFactor<T> &f, const TFactor<T> &g, binaryOp op ) {
     if( f.vars() == g.vars() ) { // optimizate special case
-        TFactor<T> result(f); 
+        TFactor<T> result(f);
         for( size_t i = 0; i < result.states(); i++ )
             result[i] = op( result[i], g[i] );
         for( size_t i = 0; i < result.states(); i++ )
             result[i] = op( result[i], g[i] );
-        return result; 
+        return result;
     } else {
         TFactor<T> result( f.vars() | g.vars(), 0.0 );
 
     } else {
         TFactor<T> result( f.vars() | g.vars(), 0.0 );
 
@@ -492,7 +492,7 @@ template<typename T> T TFactor<T>::strength( const Var &i, const Var &j ) const
     for( size_t alpha1 = 0; alpha1 < i.states(); alpha1++ )
         for( size_t alpha2 = 0; alpha2 < i.states(); alpha2++ )
             if( alpha2 != alpha1 )
     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 beta1 = 0; beta1 < j.states(); beta1++ )
                     for( size_t beta2 = 0; beta2 < j.states(); beta2++ )
                         if( beta2 != beta1 ) {
                             size_t as = 1, bs = 1;
                     for( size_t beta2 = 0; beta2 < j.states(); beta2++ )
                         if( beta2 != beta1 ) {
                             size_t as = 1, bs = 1;
@@ -506,7 +506,7 @@ template<typename T> T TFactor<T>::strength( const Var &i, const Var &j ) const
                             if( f > max )
                                 max = f;
                         }
                             if( f > max )
                                 max = f;
                         }
-    
+
     return std::tanh( 0.25 * std::log( max ) );
 }
 
     return std::tanh( 0.25 * std::log( max ) );
 }
 
@@ -560,7 +560,7 @@ template<typename T> TFactor<T> min( const TFactor<T> &f, const TFactor<T> &g )
 /// Calculates the mutual information between the two variables that f depends on, under the distribution given by f
 /** \relates TFactor
  *  \pre f.vars().size() == 2
 /// Calculates the mutual information between the two variables that f depends on, under the distribution given by f
 /** \relates TFactor
  *  \pre f.vars().size() == 2
- */ 
+ */
 template<typename T> Real MutualInfo(const TFactor<T> &f) {
     assert( f.vars().size() == 2 );
     VarSet::const_iterator it = f.vars().begin();
 template<typename T> Real MutualInfo(const TFactor<T> &f) {
     assert( f.vars().size() == 2 );
     VarSet::const_iterator it = f.vars().begin();
index 4e53ae4..2d634e6 100644 (file)
@@ -39,11 +39,11 @@ namespace dai {
 
 
 /// Represents a factor graph.
 
 
 /// Represents a factor graph.
-/** Both Bayesian Networks and Markov random fields can be represented in a 
- *  unifying representation, called <em>factor graph</em> [\ref KFL01], 
+/** Both Bayesian Networks and Markov random fields can be represented in a
+ *  unifying representation, called <em>factor graph</em> [\ref KFL01],
  *  implemented in libDAI by the FactorGraph class.
  *  
  *  implemented in libDAI by the FactorGraph class.
  *  
- *  Consider a probability distribution over \f$N\f$ discrete random variables 
+ *  Consider a probability distribution over \f$N\f$ discrete random variables
  *  \f$x_0,x_1,\dots,x_N\f$ that factorizes as a product of factors, each of
  *  which depends on some subset of the variables:
  *  \f[
  *  \f$x_0,x_1,\dots,x_N\f$ that factorizes as a product of factors, each of
  *  which depends on some subset of the variables:
  *  \f[
@@ -54,8 +54,8 @@ namespace dai {
  *  of variables \f$X_I \subset \{x_0,x_1,\dots,x_N\}\f$ to the nonnegative
  *  real numbers.
  * 
  *  of variables \f$X_I \subset \{x_0,x_1,\dots,x_N\}\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 
+ *  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
  *  corresponds to a maximal clique of the undirected graph.
  *
  *  Factor graphs explicitly express the factorization structure of the
@@ -63,7 +63,7 @@ namespace dai {
  *
  *  \todo 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
  *
  *  \todo 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 
+ *  could also be implemented in the TFactor itself, which could maintain its state
  *  (ones/delta/full) and act accordingly.
  */ 
 class FactorGraph {
  *  (ones/delta/full) and act accordingly.
  */ 
 class FactorGraph {
@@ -79,13 +79,13 @@ class FactorGraph {
 
         /// Shorthand for BipartiteGraph::Edge
         typedef BipartiteGraph::Edge      Edge;
 
         /// Shorthand for BipartiteGraph::Edge
         typedef BipartiteGraph::Edge      Edge;
-        
+
         /// Iterator over factors
         typedef std::vector<Factor>::iterator iterator;
         /// Iterator over factors
         typedef std::vector<Factor>::iterator iterator;
-        
+
         /// Const iterator over factors
         typedef std::vector<Factor>::const_iterator const_iterator;
         /// Const iterator over factors
         typedef std::vector<Factor>::const_iterator const_iterator;
-        
+
 
     private:
         std::vector<Var>         _vars;
 
     private:
         std::vector<Var>         _vars;
@@ -107,7 +107,7 @@ class FactorGraph {
         template<typename FactorInputIterator, typename VarInputIterator>
         FactorGraph(FactorInputIterator fact_begin, FactorInputIterator fact_end, VarInputIterator var_begin, VarInputIterator var_end, size_t nr_fact_hint = 0, size_t nr_var_hint = 0 );
 
         template<typename FactorInputIterator, typename VarInputIterator>
         FactorGraph(FactorInputIterator fact_begin, FactorInputIterator fact_end, VarInputIterator var_begin, VarInputIterator var_end, size_t nr_fact_hint = 0, size_t nr_var_hint = 0 );
 
-        /// Destructor        
+        /// Destructor
         virtual ~FactorGraph() {}
 
         /// Clone *this (virtual copy constructor)
         virtual ~FactorGraph() {}
 
         /// Clone *this (virtual copy constructor)
@@ -199,10 +199,10 @@ class FactorGraph {
 
         /// Set the content of the I'th factor and make a backup of its old content if backup == true
         virtual void setFactor( size_t I, const Factor &newFactor, bool backup = false ) {
 
         /// Set the content of the I'th factor and make a backup of its old content if backup == true
         virtual void setFactor( size_t I, const Factor &newFactor, bool backup = false ) {
-            assert( newFactor.vars() == factor(I).vars() ); 
+            assert( newFactor.vars() == factor(I).vars() );
             if( backup )
                 backupFactor( I );
             if( backup )
                 backupFactor( I );
-            _factors[I] = newFactor; 
+            _factors[I] = newFactor;
         }
 
         /// Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true
         }
 
         /// Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true
@@ -221,7 +221,7 @@ class FactorGraph {
 
         // OBSOLETE
         /// Only for backwards compatibility (to be removed soon)
 
         // OBSOLETE
         /// Only for backwards compatibility (to be removed soon)
-        virtual void clamp( const Var &v, size_t x, bool backup = false ) { 
+        virtual void clamp( const Var &v, size_t x, bool backup = false ) {
             std::cerr << "Warning: this FactorGraph::clamp(const Var&,...) interface is obsolete!" << std::endl;
             clamp( findVar(v), x, backup );
         }
             std::cerr << "Warning: this FactorGraph::clamp(const Var&,...) interface is obsolete!" << std::endl;
             clamp( findVar(v), x, backup );
         }
@@ -265,7 +265,7 @@ class FactorGraph {
 
         /// Writes a FactorGraph to a GraphViz .dot file
         void printDot( std::ostream& os ) const;
 
         /// Writes a FactorGraph to a GraphViz .dot file
         void printDot( std::ostream& os ) const;
-        
+
         /// Returns the cliques in this FactorGraph
         std::vector<VarSet> Cliques() const;
 
         /// Returns the cliques in this FactorGraph
         std::vector<VarSet> Cliques() const;
 
index caa09f2..881c559 100644 (file)
@@ -112,7 +112,7 @@ class HAK : public DAIAlgRG {
 
 
         /// @name Additional interface specific for HAK
 
 
         /// @name Additional interface specific for HAK
-        //@{ 
+        //@{
         Factor & muab( size_t alpha, size_t _beta ) { return _muab[alpha][_beta]; }
         Factor & muba( size_t alpha, size_t _beta ) { return _muba[alpha][_beta]; }
         const Factor& Qa( size_t alpha ) const { return _Qa[alpha]; };
         Factor & muab( size_t alpha, size_t _beta ) { return _muab[alpha][_beta]; }
         Factor & muba( size_t alpha, size_t _beta ) { return _muba[alpha][_beta]; }
         const Factor& Qa( size_t alpha ) const { return _Qa[alpha]; };
index 0b30d10..65a6d14 100644 (file)
@@ -57,8 +57,8 @@ namespace dai {
  *  and (long)i is equal to the linear index of the corresponding
  *  state of indexVars, where the variables in indexVars that are
  *  not in forVars assume their zero'th value.
  *  and (long)i is equal to 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, 
+ *  \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.
  */
 class IndexFor {
  *  instead of computing on the fly, use the precomputed ones.
  */
 class IndexFor {
@@ -71,14 +71,14 @@ class IndexFor {
 
         /// For each variable in forVars, the current state
         std::vector<size_t> _count;
 
         /// For each variable in forVars, the current state
         std::vector<size_t> _count;
-        
+
         /// For each variable in forVars, its number of possible values
         std::vector<size_t> _dims;
 
     public:
         /// Default constructor
         /// For each variable in forVars, its number of possible values
         std::vector<size_t> _dims;
 
     public:
         /// Default constructor
-        IndexFor() { 
-            _index = -1; 
+        IndexFor() {
+            _index = -1;
         }
 
         /// Constructor
         }
 
         /// Constructor
@@ -111,8 +111,8 @@ class IndexFor {
         }
 
         /// Conversion to long
         }
 
         /// Conversion to long
-        operator long () const { 
-            return( _index ); 
+        operator long () const {
+            return( _index );
         }
 
         /// Pre-increment operator
         }
 
         /// Pre-increment operator
@@ -129,7 +129,7 @@ class IndexFor {
                     i++;
                 }
 
                     i++;
                 }
 
-                if( i == _count.size() ) 
+                if( i == _count.size() )
                     _index = -1;
             }
             return( *this );
                     _index = -1;
             }
             return( *this );
@@ -170,7 +170,7 @@ class MultiFor {
         MultiFor( const std::vector<size_t> &d ) : _dims(d), _states(d.size(),0), _state(0) {}
 
         /// Return linear state
         MultiFor( const std::vector<size_t> &d ) : _dims(d), _states(d.size(),0), _state(0) {}
 
         /// Return linear state
-        operator size_t() const { 
+        operator size_t() const {
             assert( valid() );
             return( _state );
         }
             assert( valid() );
             return( _state );
         }
@@ -224,7 +224,7 @@ class Permute {
         Permute( const std::vector<size_t> &d, const std::vector<size_t> &sigma ) : _dims(d), _sigma(sigma) {
             assert( _dims.size() == _sigma.size() );
         }
         Permute( const std::vector<size_t> &d, const std::vector<size_t> &sigma ) : _dims(d), _sigma(sigma) {
             assert( _dims.size() == _sigma.size() );
         }
-  
+
         /// Construct from vector of variables
         Permute( const std::vector<Var> &vars ) : _dims(vars.size()), _sigma(vars.size()) {
             VarSet vs( vars.begin(), vars.end(), vars.size() );
         /// Construct from vector of variables
         Permute( const std::vector<Var> &vars ) : _dims(vars.size()), _sigma(vars.size()) {
             VarSet vs( vars.begin(), vars.end(), vars.size() );
@@ -237,7 +237,7 @@ class Permute {
 
         /// Calculates a permuted linear index.
         /** Converts the linear index li to a vector index
 
         /// Calculates a permuted linear index.
         /** Converts the linear index li to a vector index
-         *  corresponding with the dimensions in _dims, permutes it according to sigma, 
+         *  corresponding with the dimensions in _dims, permutes it according to sigma,
          *  and converts it back to a linear index  according to the permuted dimensions.
          */
         size_t convert_linear_index( size_t li ) const {
          *  and converts it back to a linear index  according to the permuted dimensions.
          */
         size_t convert_linear_index( size_t li ) const {
@@ -275,7 +275,7 @@ class State {
 
         long                          state;
         states_type                   states;
 
         long                          state;
         states_type                   states;
-        
+
     public:
         /// Default constructor
         State() : state(0), states() {}
     public:
         /// Default constructor
         State() : state(0), states() {}
@@ -287,7 +287,7 @@ class State {
         }
 
         /// Return linear state
         }
 
         /// Return linear state
-        operator size_t() const { 
+        operator size_t() const {
             assert( valid() );
             return( state );
         }
             assert( valid() );
             return( state );
         }
@@ -310,7 +310,7 @@ class State {
             for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) {
                 states_type::const_iterator entry = states.find( *v );
                 if( entry != states.end() )
             for( VarSet::const_iterator v = vs.begin(); v != vs.end(); v++ ) {
                 states_type::const_iterator entry = states.find( *v );
                 if( entry != states.end() )
-                    vs_state += entry->second * prod; 
+                    vs_state += entry->second * prod;
                 prod *= v->states();
             }
             return vs_state;
                 prod *= v->states();
             }
             return vs_state;
@@ -331,10 +331,10 @@ class State {
                     state = -1;
             }
         }
                     state = -1;
             }
         }
-        
+
         /// Postfix increment operator
         void operator++( int ) {
         /// Postfix increment operator
         void operator++( int ) {
-               operator++();
+            operator++();
         }
 
         /// Returns true if the current state is valid
         }
 
         /// Returns true if the current state is valid
index 5bcc096..f46e194 100644 (file)
@@ -53,10 +53,10 @@ class JTree : public DAIAlgRG {
     public:
         /// Rooted tree
         DEdgeVec             RTree;
     public:
         /// Rooted tree
         DEdgeVec             RTree;
-        
+
         /// Outer region beliefs
         std::vector<Factor>  Qa;
         /// Outer region beliefs
         std::vector<Factor>  Qa;
-        
+
         /// Inner region beliefs
         std::vector<Factor>  Qb;
 
         /// Inner region beliefs
         std::vector<Factor>  Qb;
 
@@ -100,13 +100,13 @@ class JTree : public DAIAlgRG {
 
 
         /// @name Additional interface specific for JTree
 
 
         /// @name Additional interface specific for JTree
-        //@{ 
+        //@{
         void GenerateJT( const std::vector<VarSet> &Cliques );
 
         /// Returns reference the message from outer region alpha to its _beta'th neighboring inner region
         void GenerateJT( const std::vector<VarSet> &Cliques );
 
         /// Returns reference the message from outer region alpha to its _beta'th neighboring inner region
-        Factor & message( size_t alpha, size_t _beta ) { return _mes[alpha][_beta]; }   
+        Factor & message( size_t alpha, size_t _beta ) { return _mes[alpha][_beta]; }
         /// Returns const reference to the message from outer region alpha to its _beta'th neighboring inner region
         /// Returns const reference to the message from outer region alpha to its _beta'th neighboring inner region
-        const Factor & message( size_t alpha, size_t _beta ) const { return _mes[alpha][_beta]; }   
+        const Factor & message( size_t alpha, size_t _beta ) const { return _mes[alpha][_beta]; }
 
         /// Runs junction-tree with HUGIN updates
         void runHUGIN();
 
         /// Runs junction-tree with HUGIN updates
         void runHUGIN();
index 1acdab6..80263a4 100644 (file)
@@ -122,7 +122,7 @@ class LC : public DAIAlgFG {
         Factor beliefV( size_t i ) const { return _beliefs[i]; }
 
         /// @name Additional interface specific for LC
         Factor beliefV( size_t i ) const { return _beliefs[i]; }
 
         /// @name Additional interface specific for LC
-        //@{ 
+        //@{
         double CalcCavityDist( size_t i, const std::string &name, const PropertySet &opts );
         double InitCavityDists( const std::string &name, const PropertySet &opts );
         long SetCavityDists( std::vector<Factor> &Q );
         double CalcCavityDist( size_t i, const std::string &name, const PropertySet &opts );
         double InitCavityDists( const std::string &name, const PropertySet &opts );
         long SetCavityDists( std::vector<Factor> &Q );
index e983ce7..e0a659a 100644 (file)
@@ -94,10 +94,10 @@ class MF : public DAIAlgFG {
 
 
         /// @name Additional interface specific for MF
 
 
         /// @name Additional interface specific for MF
-        //@{ 
+        //@{
         Factor beliefV( size_t i ) const;
         //@}
         Factor beliefV( size_t i ) const;
         //@}
-        
+
     private:
         void construct();
         void setProperties( const PropertySet &opts );
     private:
         void construct();
         void setProperties( const PropertySet &opts );
index fa6b7ca..b4f47bb 100644 (file)
@@ -57,10 +57,10 @@ class MR : public DAIAlgFG {
         std::vector<std::vector<double> >               M;         // M[i][_j] is M^{(i)}_j
         std::vector<std::vector<size_t> >               kindex;    // the _j'th neighbour of spin i has spin i as its kindex[i][_j]'th neighbour
         std::vector<std::vector<std::vector<double> > > cors;
         std::vector<std::vector<double> >               M;         // M[i][_j] is M^{(i)}_j
         std::vector<std::vector<size_t> >               kindex;    // the _j'th neighbour of spin i has spin i as its kindex[i][_j]'th neighbour
         std::vector<std::vector<std::vector<double> > > cors;
-    
+
         static const size_t kmax = 31;
         typedef boost::dynamic_bitset<> sub_nb;
         static const size_t kmax = 31;
         typedef boost::dynamic_bitset<> sub_nb;
-        
+
         size_t N;
 
         std::vector<double> Mag;
         size_t N;
 
         std::vector<double> Mag;
@@ -118,9 +118,9 @@ class MR : public DAIAlgFG {
 
 
         /// @name Additional interface specific for MR
 
 
         /// @name Additional interface specific for MR
-        //@{ 
+        //@{
         //@}
         //@}
-        
+
     private:
         void init(size_t Nin, double *_w, double *_th);
         void makekindex();
     private:
         void init(size_t Nin, double *_w, double *_th);
         void makekindex();
@@ -141,11 +141,11 @@ class MR : public DAIAlgFG {
         void sum_subs(size_t j, sub_nb A, double *sum_even, double *sum_odd);
 
         double sign(double a) { return (a >= 0) ? 1.0 : -1.0; }
         void sum_subs(size_t j, sub_nb A, double *sum_even, double *sum_odd);
 
         double sign(double a) { return (a >= 0) ? 1.0 : -1.0; }
-        
+
         void setProperties( const PropertySet &opts );
         PropertySet getProperties() const;
         std::string printProperties() const;
         void setProperties( const PropertySet &opts );
         PropertySet getProperties() const;
         std::string printProperties() const;
-}; 
+};
 
 
 } // end of namespace dai
 
 
 } // end of namespace dai
index f2b3156..e66d1c1 100644 (file)
@@ -45,7 +45,7 @@ namespace dai {
 
 /// Represents a vector with entries of type \a T.
 /** A TProb<T> is a std::vector<T> with an interface designed for dealing with probability mass functions.
 
 /// Represents a vector with entries of type \a T.
 /** A TProb<T> is 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, e.g., the probability 
+ *  It is mainly used for representing measures on a finite outcome space, e.g., the probability
  *  distribution of a discrete random variable.
  *  \tparam T Should be a scalar that is castable from and to double and should support elementary arithmetic operations.
  */
  *  distribution of a discrete random variable.
  *  \tparam T Should be a scalar that is castable from and to double and should support elementary arithmetic operations.
  */
@@ -56,34 +56,34 @@ template <typename T> class TProb {
 
     public:
         /// Iterator over entries
 
     public:
         /// Iterator over entries
-       typedef typename std::vector<T>::iterator iterator;
+        typedef typename std::vector<T>::iterator iterator;
         /// Const iterator over entries
         /// Const iterator over entries
-       typedef typename std::vector<T>::const_iterator const_iterator;
+        typedef typename std::vector<T>::const_iterator const_iterator;
 
         /// Enumerates different ways of normalizing a probability measure.
 
         /// 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 } NormType;
         /// Enumerates different distance measures between probability measures.
          *  - 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 } NormType;
         /// Enumerates different distance measures between probability measures.
-        /** 
+        /**
          *  - DISTL1 is the L-1 distance (sum of absolute values of pointwise difference);
          *  - DISTLINF is the L-inf distance (maximum absolute value of pointwise difference);
          *  - DISTTV is the Total Variation distance;
          *  - DISTKL is the Kullback-Leibler distance.
          */
         typedef enum { DISTL1, DISTLINF, DISTTV, DISTKL } DistType;
          *  - DISTL1 is the L-1 distance (sum of absolute values of pointwise difference);
          *  - DISTLINF is the L-inf distance (maximum absolute value of pointwise difference);
          *  - DISTTV is the Total Variation distance;
          *  - DISTKL is the Kullback-Leibler distance.
          */
         typedef enum { DISTL1, DISTLINF, DISTTV, DISTKL } DistType;
-        
+
         /// Default constructor
         TProb() : _p() {}
         /// Default constructor
         TProb() : _p() {}
-        
+
         /// Construct uniform distribution over n outcomes, i.e., a vector of length n with each entry set to 1/n
         explicit TProb( size_t n ) : _p(std::vector<T>(n, 1.0 / n)) {}
         /// Construct uniform distribution over n outcomes, i.e., a vector of length n with each entry set to 1/n
         explicit TProb( size_t n ) : _p(std::vector<T>(n, 1.0 / n)) {}
-        
+
         /// Construct vector of length n with each entry set to p
         explicit TProb( size_t n, Real p ) : _p(n, (T)p) {}
         /// Construct vector of length n with each entry set to p
         explicit TProb( size_t n, Real p ) : _p(n, (T)p) {}
-        
+
         /// Construct vector from a range
         /** \tparam Iterator Iterates over instances that can be cast to T.
          *  \param begin Points to first instance to be added.
         /// Construct vector from a range
         /** \tparam Iterator Iterates over instances that can be cast to T.
          *  \param begin Points to first instance to be added.
@@ -95,25 +95,25 @@ template <typename T> class TProb {
             _p.reserve( sizeHint );
             _p.insert( _p.begin(), begin, end );
         }
             _p.reserve( sizeHint );
             _p.insert( _p.begin(), begin, end );
         }
-        
+
         /// Returns a const reference to the vector
         const std::vector<T> & p() const { return _p; }
 
         /// Returns a reference to the vector
         std::vector<T> & p() { return _p; }
         /// Returns a const reference to the vector
         const std::vector<T> & p() const { return _p; }
 
         /// Returns a reference to the vector
         std::vector<T> & p() { return _p; }
-        
+
         /// Returns a copy of the i'th entry
         /// Returns a copy of the i'th entry
-        T operator[]( size_t i ) const { 
+        T operator[]( size_t i ) const {
 #ifdef DAI_DEBUG
             return _p.at(i);
 #else
             return _p[i];
 #endif
         }
 #ifdef DAI_DEBUG
             return _p.at(i);
 #else
             return _p[i];
 #endif
         }
-        
+
         /// Returns reference to the i'th entry
         T& operator[]( size_t i ) { return _p[i]; }
         /// Returns reference to the i'th entry
         T& operator[]( size_t i ) { return _p[i]; }
-        
+
         /// Returns iterator pointing to first entry
         iterator begin() { return _p.begin(); }
 
         /// Returns iterator pointing to first entry
         iterator begin() { return _p.begin(); }
 
@@ -127,13 +127,13 @@ template <typename T> class TProb {
         const_iterator end() const { return _p.end(); }
 
         /// Sets all entries to x
         const_iterator end() const { return _p.end(); }
 
         /// Sets all entries to x
-        TProb<T> & fill(T x) { 
+        TProb<T> & fill(T x) {
             std::fill( _p.begin(), _p.end(), x );
             return *this;
         }
 
         /// Draws all entries i.i.d. from a uniform distribution on [0,1)
             std::fill( _p.begin(), _p.end(), x );
             return *this;
         }
 
         /// Draws all entries i.i.d. from a uniform distribution on [0,1)
-        TProb<T> & randomize() { 
+        TProb<T> & randomize() {
             std::generate(_p.begin(), _p.end(), rnd_uniform);
             return *this;
         }
             std::generate(_p.begin(), _p.end(), rnd_uniform);
             return *this;
         }
@@ -150,7 +150,7 @@ template <typename T> class TProb {
                     _p[i] = 0;
             return *this;
         }
                     _p[i] = 0;
             return *this;
         }
-        
+
         /// Set all entries to 1.0/size()
         TProb<T>& setUniform () {
             fill(1.0/size());
         /// Set all entries to 1.0/size()
         TProb<T>& setUniform () {
             fill(1.0/size());
@@ -233,7 +233,7 @@ template <typename T> class TProb {
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::multiplies<T>() );
             return *this;
         }
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::multiplies<T>() );
             return *this;
         }
-        
+
         /// Return product of *this with q (sizes should be identical)
         TProb<T> operator* (const TProb<T> & q) const {
             DAI_DEBASSERT( size() == q.size() );
         /// Return product of *this with q (sizes should be identical)
         TProb<T> operator* (const TProb<T> & q) const {
             DAI_DEBASSERT( size() == q.size() );
@@ -248,7 +248,7 @@ template <typename T> class TProb {
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::plus<T>() );
             return *this;
         }
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::plus<T>() );
             return *this;
         }
-        
+
         /// Returns sum of *this and q (sizes should be identical)
         TProb<T> operator+ (const TProb<T> & q) const {
             DAI_DEBASSERT( size() == q.size() );
         /// Returns sum of *this and q (sizes should be identical)
         TProb<T> operator+ (const TProb<T> & q) const {
             DAI_DEBASSERT( size() == q.size() );
@@ -256,7 +256,7 @@ template <typename T> class TProb {
             sum += q;
             return sum;
         }
             sum += q;
             return sum;
         }
-        
+
         /// Pointwise subtraction of q (sizes should be identical)
         TProb<T>& operator-= (const TProb<T> & q) {
             DAI_DEBASSERT( size() == q.size() );
         /// Pointwise subtraction of q (sizes should be identical)
         TProb<T>& operator-= (const TProb<T> & q) {
             DAI_DEBASSERT( size() == q.size() );
@@ -283,14 +283,14 @@ template <typename T> class TProb {
             }
             return *this;
         }
             }
             return *this;
         }
-        
+
         /// Pointwise division by q, where division by 0 yields +Inf (sizes should be identical)
         TProb<T>& divide (const TProb<T> & q) {
             DAI_DEBASSERT( size() == q.size() );
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::divides<T>() );
             return *this;
         }
         /// Pointwise division by q, where division by 0 yields +Inf (sizes should be identical)
         TProb<T>& divide (const TProb<T> & q) {
             DAI_DEBASSERT( size() == q.size() );
             std::transform( _p.begin(), _p.end(), q._p.begin(), _p.begin(), std::divides<T>() );
             return *this;
         }
-        
+
         /// Returns quotient of *this with q (sizes should be identical)
         TProb<T> operator/ (const TProb<T> & q) const {
             DAI_DEBASSERT( size() == q.size() );
         /// Returns quotient of *this with q (sizes should be identical)
         TProb<T> operator/ (const TProb<T> & q) const {
             DAI_DEBASSERT( size() == q.size() );
@@ -456,7 +456,7 @@ template <typename T> class TProb {
             result.normalize( norm );
             return result;
         }
             result.normalize( norm );
             return result;
         }
-    
+
         /// Returns true if one or more entries are NaN
         bool hasNaNs() const {
             bool foundnan = false;
         /// Returns true if one or more entries are NaN
         bool hasNaNs() const {
             bool foundnan = false;
@@ -472,7 +472,7 @@ template <typename T> class TProb {
         bool hasNegatives() const {
             return (std::find_if( _p.begin(), _p.end(), std::bind2nd( std::less<Real>(), 0.0 ) ) != _p.end());
         }
         bool hasNegatives() const {
             return (std::find_if( _p.begin(), _p.end(), std::bind2nd( std::less<Real>(), 0.0 ) ) != _p.end());
         }
-        
+
         /// Returns entropy of *this
         Real entropy() const {
             Real S = 0.0;
         /// Returns entropy of *this
         Real entropy() const {
             Real S = 0.0;
@@ -487,7 +487,7 @@ template <typename T> class TProb {
             T s = 0;
             for( size_t i = 0; i < size(); i++ ) {
                 s += _p[i];
             T s = 0;
             for( size_t i = 0; i < size(); i++ ) {
                 s += _p[i];
-                if( s > x ) 
+                if( s > x )
                     return i;
             }
             return( size() - 1 );
                     return i;
             }
             return( size() - 1 );
@@ -506,7 +506,7 @@ template<typename T> Real dist( const TProb<T> &p, const TProb<T> &q, typename T
             for( size_t i = 0; i < p.size(); i++ )
                 result += fabs((Real)p[i] - (Real)q[i]);
             break;
             for( size_t i = 0; i < p.size(); i++ )
                 result += fabs((Real)p[i] - (Real)q[i]);
             break;
-            
+
         case TProb<T>::DISTLINF:
             for( size_t i = 0; i < p.size(); i++ ) {
                 Real z = fabs((Real)p[i] - (Real)q[i]);
         case TProb<T>::DISTLINF:
             for( size_t i = 0; i < p.size(); i++ ) {
                 Real z = fabs((Real)p[i] - (Real)q[i]);
index 4e661dc..0aa02da 100644 (file)
@@ -72,14 +72,11 @@ class PropertySet : private std::map<PropertyKey, PropertyValue> {
         }
 
         /// Gets a property
         }
 
         /// Gets a property
-        const PropertyValue & Get(const PropertyKey &key) const { 
-            PropertySet::const_iterator x = find(key); 
-#ifdef DAI_DEBUG            
+        const PropertyValue & Get(const PropertyKey &key) const {
+            PropertySet::const_iterator x = find(key);
             if( x == this->end() )
             if( x == this->end() )
-                std::cerr << "PropertySet::Get cannot find property " << key << std::endl;
-#endif
-            assert( x != this->end() ); 
-            return x->second; 
+                DAI_THROWE(NOT_FOUND,"PropertySet::Get cannot find property '" + key + "'");
+            return x->second;
         }
 
         /// Sets a property
         }
 
         /// Sets a property
@@ -137,7 +134,7 @@ class PropertySet : private std::map<PropertyKey, PropertyValue> {
 
         /// Converts a property from ValueType to string (if necessary)
         template<typename ValueType>
 
         /// Converts a property from ValueType to string (if necessary)
         template<typename ValueType>
-        PropertySet & setAsString(const PropertyKey &key, ValueType &val) { 
+        PropertySet & setAsString(const PropertyKey &key, ValueType &val) {
             try {
                 return Set( key, boost::lexical_cast<std::string>(val) );
             } catch( boost::bad_lexical_cast & ) {
             try {
                 return Set( key, boost::lexical_cast<std::string>(val) );
             } catch( boost::bad_lexical_cast & ) {
@@ -147,7 +144,7 @@ class PropertySet : private std::map<PropertyKey, PropertyValue> {
 
         /// Shorthand for (temporarily) adding properties, e.g. PropertySet p()("method","BP")("verbose",1)("tol",1e-9)
         PropertySet operator()(const PropertyKey &key, const PropertyValue &val) const { PropertySet copy = *this; return copy.Set(key,val); }
 
         /// Shorthand for (temporarily) adding properties, e.g. PropertySet p()("method","BP")("verbose",1)("tol",1e-9)
         PropertySet operator()(const PropertyKey &key, const PropertyValue &val) const { PropertySet copy = *this; return copy.Set(key,val); }
-               
+
         /// Check if a property with the given key exists
         bool hasKey(const PropertyKey &key) const { PropertySet::const_iterator x = find(key); return (x != this->end()); }
 
         /// Check if a property with the given key exists
         bool hasKey(const PropertyKey &key) const { PropertySet::const_iterator x = find(key); return (x != this->end()); }
 
index 979915d..316f3ff 100644 (file)
@@ -50,7 +50,7 @@ class Region : public VarSet {
 
         /// Construct Region from a VarSet and a counting number
         Region(const VarSet & x, double c) : VarSet(x), _c(c) {}
 
         /// Construct Region from a VarSet and a counting number
         Region(const VarSet & x, double c) : VarSet(x), _c(c) {}
-        
+
         /// Provide read access to counting number
         const double & c() const { return _c; }
         /// Provide full access to counting number
         /// Provide read access to counting number
         const double & c() const { return _c; }
         /// Provide full access to counting number
@@ -70,7 +70,7 @@ class FRegion : public Factor {
 
         /// Constructs FRegion from a Factor and a counting number
         FRegion( const Factor & x, double c ) : Factor(x), _c(c) {}
 
         /// Constructs FRegion from a Factor and a counting number
         FRegion( const Factor & x, double c ) : Factor(x), _c(c) {}
-        
+
         /// Provide read access to counting number
         const double & c() const { return _c; }
         /// Provide full access to counting number
         /// Provide read access to counting number
         const double & c() const { return _c; }
         /// Provide full access to counting number
@@ -103,7 +103,7 @@ class RegionGraph : public FactorGraph {
 
         /// Constructs a RegionGraph from a FactorGraph, a vector of outer regions, a vector of inner regions and a vector of edges
         RegionGraph( const FactorGraph &fg, const std::vector<Region> &ors, const std::vector<Region> &irs, const std::vector<std::pair<size_t,size_t> > &edges );
 
         /// Constructs a RegionGraph from a FactorGraph, a vector of outer regions, a vector of inner regions and a vector of edges
         RegionGraph( const FactorGraph &fg, const std::vector<Region> &ors, const std::vector<Region> &irs, const std::vector<std::pair<size_t,size_t> > &edges );
-        
+
         /// Constructs a RegionGraph from a FactorGraph and a vector of outer VarSets (CVM style)
         RegionGraph( const FactorGraph &fg, const std::vector<VarSet> &cl );
 
         /// Constructs a RegionGraph from a FactorGraph and a vector of outer VarSets (CVM style)
         RegionGraph( const FactorGraph &fg, const std::vector<VarSet> &cl );
 
@@ -112,8 +112,8 @@ class RegionGraph : public FactorGraph {
 
         /// Set the content of the I'th factor and make a backup of its old content if backup == true
         virtual void setFactor( size_t I, const Factor &newFactor, bool backup = false ) {
 
         /// Set the content of the I'th factor and make a backup of its old content if backup == true
         virtual void setFactor( size_t I, const Factor &newFactor, bool backup = false ) {
-            FactorGraph::setFactor( I, newFactor, backup ); 
-            RecomputeOR( I ); 
+            FactorGraph::setFactor( I, newFactor, backup );
+            RecomputeOR( I );
         }
 
         /// Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true
         }
 
         /// Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true
@@ -122,7 +122,7 @@ class RegionGraph : public FactorGraph {
             VarSet ns;
             for( std::map<size_t, Factor>::const_iterator fac = facs.begin(); fac != facs.end(); fac++ )
                 ns |= fac->second.vars();
             VarSet ns;
             for( std::map<size_t, Factor>::const_iterator fac = facs.begin(); fac != facs.end(); fac++ )
                 ns |= fac->second.vars();
-            RecomputeORs( ns ); 
+            RecomputeORs( ns );
         }
 
 
         }
 
 
index b3f9daa..0d3cdc7 100644 (file)
@@ -54,12 +54,12 @@ class SmallSet {
         SmallSet() : _elements() {}
 
         /// Construct a set with one element
         SmallSet() : _elements() {}
 
         /// Construct a set with one element
-        SmallSet( const T &t ) : _elements() { 
+        SmallSet( const T &t ) : _elements() {
             _elements.push_back( t );
         }
 
         /// Construct a set with two elements
             _elements.push_back( t );
         }
 
         /// Construct a set with two elements
-        SmallSet( const T &t1, const T &t2 ) { 
+        SmallSet( const T &t1, const T &t2 ) {
             if( t1 < t2 ) {
                 _elements.push_back( t1 );
                 _elements.push_back( t2 );
             if( t1 < t2 ) {
                 _elements.push_back( t1 );
                 _elements.push_back( t2 );
@@ -99,25 +99,25 @@ class SmallSet {
             return res;
         }
 
             return res;
         }
 
-        /// Set-intersection operator: returns all elements in *this that are also contained in x 
+        /// Set-intersection operator: returns all elements in *this that are also contained in 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;
         }
         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 *this all elements in x
         SmallSet& operator/= ( const SmallSet& x ) {
             return (*this = (*this / x));
         }
 
         /// Erases one element
         /// Erases from *this all elements in x
         SmallSet& operator/= ( const SmallSet& x ) {
             return (*this = (*this / x));
         }
 
         /// Erases one element
-        SmallSet& operator/= ( const T &t ) { 
+        SmallSet& operator/= ( const T &t ) {
             typename std::vector<T>::iterator pos = lower_bound( _elements.begin(), _elements.end(), t );
             if( pos != _elements.end() )
                 if( *pos == t ) // found element, delete it
             typename std::vector<T>::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; 
+                    _elements.erase( pos );
+            return *this;
         }
 
         /// Adds to *this all elements in x
         }
 
         /// Adds to *this all elements in x
@@ -134,27 +134,27 @@ class SmallSet {
         }
 
         /// Erases from *this all elements not in x
         }
 
         /// Erases from *this all elements not in x
-        SmallSet& operator&= ( const SmallSet& x ) { 
+        SmallSet& operator&= ( const SmallSet& x ) {
             return (*this = (*this & x));
         }
 
         /// Returns true if *this is a subset of x
             return (*this = (*this & x));
         }
 
         /// Returns true if *this is a subset of x
-        bool operator<< ( const SmallSet& x ) const { 
+        bool operator<< ( const SmallSet& x ) const {
             return std::includes( x._elements.begin(), x._elements.end(), _elements.begin(), _elements.end() );
         }
 
         /// Returns true if x is a subset of *this
             return std::includes( x._elements.begin(), x._elements.end(), _elements.begin(), _elements.end() );
         }
 
         /// Returns true if x is a subset of *this
-        bool operator>> ( const SmallSet& x ) const { 
+        bool operator>> ( const SmallSet& x ) const {
             return std::includes( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end() );
         }
 
         /// Returns true if *this and x have elements in common
             return std::includes( _elements.begin(), _elements.end(), x._elements.begin(), x._elements.end() );
         }
 
         /// Returns true if *this and x have elements in common
-        bool intersects( const SmallSet& x ) const { 
-            return( (*this & x).size() > 0 ); 
+        bool intersects( const SmallSet& x ) const {
+            return( (*this & x).size() > 0 );
         }
 
         /// Returns true if *this contains the element t
         }
 
         /// Returns true if *this contains the element t
-        bool contains( const T &t ) const { 
+        bool contains( const T &t ) const {
             return std::binary_search( _elements.begin(), _elements.end(), t );
         }
 
             return std::binary_search( _elements.begin(), _elements.end(), t );
         }
 
@@ -166,7 +166,7 @@ class SmallSet {
         typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
         /// Reverse iterator over the elements
         typedef typename std::vector<T>::reverse_iterator reverse_iterator;
         typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
         /// Reverse iterator over the elements
         typedef typename std::vector<T>::reverse_iterator reverse_iterator;
-        
+
         /// Returns iterator that points to the first element
         iterator begin() { return _elements.begin(); }
         /// Returns constant iterator that points to the first element
         /// Returns iterator that points to the first element
         iterator begin() { return _elements.begin(); }
         /// Returns constant iterator that points to the first element
index 832e382..338b400 100644 (file)
@@ -83,13 +83,13 @@ class TreeEP : public JTree {
                 DEdgeVec             _RTree;
                 std::vector<size_t>  _a;        // _Qa[alpha]  <->  superTree.Qa[_a[alpha]]
                 std::vector<size_t>  _b;        // _Qb[beta]   <->  superTree.Qb[_b[beta]]
                 DEdgeVec             _RTree;
                 std::vector<size_t>  _a;        // _Qa[alpha]  <->  superTree.Qa[_a[alpha]]
                 std::vector<size_t>  _b;        // _Qb[beta]   <->  superTree.Qb[_b[beta]]
-                                                // _Qb[beta]   <->  _RTree[beta]    
+                                                // _Qb[beta]   <->  _RTree[beta]
                 const Factor *       _I;
                 VarSet               _ns;
                 VarSet               _nsrem;
                 double               _logZ;
                 const Factor *       _I;
                 VarSet               _ns;
                 VarSet               _nsrem;
                 double               _logZ;
-                
-                
+
+
             public:
                 TreeEPSubTree() : _Qa(), _Qb(), _RTree(), _a(), _b(), _I(NULL), _ns(), _nsrem(), _logZ(0.0) {}
                 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) {}
             public:
                 TreeEPSubTree() : _Qa(), _Qb(), _RTree(), _a(), _b(), _I(NULL), _ns(), _nsrem(), _logZ(0.0) {}
                 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) {}
@@ -162,7 +162,7 @@ class TreeEP : public JTree {
 
 
         /// @name Additional interface specific for TreeEP
 
 
         /// @name Additional interface specific for TreeEP
-        //@{ 
+        //@{
         //@}
 
     private:
         //@}
 
     private:
index 3f61623..accc90c 100644 (file)
@@ -54,7 +54,7 @@
 #ifdef DAI_DEBUG
 /// \brief "Print variable". Prints the text of an expression, followed by its value (only if DAI_DEBUG is defined)
 /**
 #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. 
+ *  Useful debugging macro to see what your code is doing.
  *  Example: \code DAI_PV(3+4) \endcode
  *  Output: \code 3+4= 7 \endcode
  */
  *  Example: \code DAI_PV(3+4) \endcode
  *  Output: \code 3+4= 7 \endcode
  */
@@ -142,7 +142,7 @@ inline int rnd( int n) {
 
 
 /// Writes a std::vector to a std::ostream
 
 
 /// Writes a std::vector to a std::ostream
-template<class T> 
+template<class T>
 std::ostream& operator << (std::ostream& os, const std::vector<T> & x) {
     os << "(";
     for( typename std::vector<T>::const_iterator it = x.begin(); it != x.end(); it++ )
 std::ostream& operator << (std::ostream& os, const std::vector<T> & x) {
     os << "(";
     for( typename std::vector<T>::const_iterator it = x.begin(); it != x.end(); it++ )
@@ -152,7 +152,7 @@ std::ostream& operator << (std::ostream& os, const std::vector<T> & x) {
 }
 
 /// Writes a std::set to a std::ostream
 }
 
 /// Writes a std::set to a std::ostream
-template<class T> 
+template<class T>
 std::ostream& operator << (std::ostream& os, const std::set<T> & x) {
     os << "{";
    for( typename std::set<T>::const_iterator it = x.begin(); it != x.end(); it++ )
 std::ostream& operator << (std::ostream& os, const std::set<T> & x) {
     os << "{";
    for( typename std::set<T>::const_iterator it = x.begin(); it != x.end(); it++ )
@@ -202,17 +202,17 @@ class Diffs : public std::vector<double> {
         std::vector<double>::iterator _maxpos;
     public:
         /// Constructor
         std::vector<double>::iterator _maxpos;
     public:
         /// Constructor
-        Diffs(long maxsize, double def) : std::vector<double>(), _maxsize(maxsize), _def(def) { 
-            this->reserve(_maxsize); 
-            _pos = begin(); 
-            _maxpos = begin(); 
+        Diffs(long maxsize, double def) : std::vector<double>(), _maxsize(maxsize), _def(def) {
+            this->reserve(_maxsize);
+            _pos = begin();
+            _maxpos = begin();
         }
         /// Returns maximum difference encountered
         }
         /// Returns maximum difference encountered
-        double maxDiff() { 
+        double maxDiff() {
             if( size() < _maxsize )
                 return _def;
             else
             if( size() < _maxsize )
                 return _def;
             else
-                return( *_maxpos ); 
+                return( *_maxpos );
         }
         /// Register new difference x
         void push(double x) {
         }
         /// Register new difference x
         void push(double x) {
@@ -231,7 +231,7 @@ class Diffs : public std::vector<double> {
                 if( _pos == end() )
                     _pos = begin();
                 if( _maxpos == _pos ) {
                 if( _pos == end() )
                     _pos = begin();
                 if( _maxpos == _pos ) {
-                    *_pos++ = x; 
+                    *_pos++ = x;
                     _maxpos = max_element(begin(),end());
                 } else {
                     if( x > *_maxpos )
                     _maxpos = max_element(begin(),end());
                 } else {
                     if( x > *_maxpos )
index 510c94b..481c6bf 100644 (file)
@@ -39,13 +39,13 @@ namespace dai {
 
 
 /// Represents a discrete random variable.
 
 
 /// Represents a discrete random variable.
-/** A Var stores the \a label of the variable (an integer-valued unique ID) 
+/** A Var stores the \a label of the variable (an integer-valued unique ID)
  *  and the number of possible values (\a states) of that variable. Two
  *  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 
+ *  Var objects with the same label are assumed to be identical (i.e., it
  *  is assumed that their states are also the same).
  *
  *  In this manual, we use the following notational conventions. The discrete
  *  is assumed that their states are also the same).
  *
  *  In this manual, 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 
+ *  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$.
  *  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$.
@@ -57,7 +57,7 @@ class Var {
 
         /// Number of possible values
         size_t  _states;
 
         /// Number of possible values
         size_t  _states;
-        
+
     public:
         /// Default constructor
         Var() : _label(-1), _states(0) {}
     public:
         /// Default constructor
         Var() : _label(-1), _states(0) {}
@@ -79,36 +79,36 @@ class Var {
         /// Larger-than operator (compares only labels)
         bool operator > ( const Var& n ) const { return( _label >  n._label ); }
         /// Smaller-than-or-equal-to operator (only compares labels)
         /// Larger-than operator (compares only labels)
         bool operator > ( const Var& n ) const { return( _label >  n._label ); }
         /// Smaller-than-or-equal-to operator (only compares labels)
-        bool operator <= ( const Var& n ) const { 
+        bool operator <= ( const Var& n ) const {
 #ifdef DAI_DEBUG
             if( _label == n._label )
                 assert( _states == n._states );
 #endif
 #ifdef DAI_DEBUG
             if( _label == n._label )
                 assert( _states == n._states );
 #endif
-            return( _label <= n._label ); 
+            return( _label <= n._label );
         }
         /// Larger-than-or-equal-to operator (only compares labels)
         }
         /// Larger-than-or-equal-to operator (only compares labels)
-        bool operator >= ( const Var& n ) const { 
+        bool operator >= ( const Var& n ) const {
 #ifdef DAI_DEBUG
             if( _label == n._label )
                 assert( _states == n._states );
 #endif
 #ifdef DAI_DEBUG
             if( _label == n._label )
                 assert( _states == n._states );
 #endif
-            return( _label >= n._label ); 
+            return( _label >= n._label );
         }
         /// Not-equal-to operator (only compares labels)
         }
         /// Not-equal-to operator (only compares labels)
-        bool operator != ( const Var& n ) const { 
+        bool operator != ( const Var& n ) const {
 #ifdef DAI_DEBUG
             if( _label == n._label )
                 assert( _states == n._states );
 #endif
 #ifdef DAI_DEBUG
             if( _label == n._label )
                 assert( _states == n._states );
 #endif
-            return( _label != n._label ); 
+            return( _label != n._label );
         }
         /// Equal-to operator (only compares labels)
         }
         /// Equal-to operator (only compares labels)
-        bool operator == ( const Var& n ) const { 
+        bool operator == ( const Var& n ) const {
 #ifdef DAI_DEBUG
             if( _label == n._label )
                 assert( _states == n._states );
 #ifdef DAI_DEBUG
             if( _label == n._label )
                 assert( _states == n._states );
-#endif            
-            return( _label == n._label ); 
+#endif
+            return( _label == n._label );
         }
 
         /// Writes a Var to an output stream
         }
 
         /// Writes a Var to an output stream
index e45e40d..5fa87ae 100644 (file)
@@ -46,10 +46,10 @@ namespace dai {
 /// 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.
 /// 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 according 
- *  to their labels: the set of variables \f$\{x_l\}_{l\in L}\f$ is 
- *  represented as a vector \f$(x_{l(0)},x_{l(1)},\dots,x_{l(|L|-1)})\f$ 
- *  where \f$l(0) < l(1) < \dots < l(|L|-1)\f$ 
+ *  That is, internally, the variables in the set are sorted according
+ *  to their labels: the set of variables \f$\{x_l\}_{l\in L}\f$ is
+ *  represented as a vector \f$(x_{l(0)},x_{l(1)},\dots,x_{l(|L|-1)})\f$
+ *  where \f$l(0) < l(1) < \dots < l(|L|-1)\f$
  *  and \f$L = \{l(0),l(1),\dots,l(|L|-1)\}\f$.
  */
 class VarSet : public SmallSet<Var> {
  *  and \f$L = \{l(0),l(1),\dots,l(|L|-1)\}\f$.
  */
 class VarSet : public SmallSet<Var> {
@@ -64,8 +64,8 @@ class VarSet : public SmallSet<Var> {
         /** 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 \f$\{x_l\}_{l\in L}\f$,
         /** 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 \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 
+         *  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$.
          */
         size_t nrStates() {
          *  joint configurations of the variables in \f$\{x_l\}_{l\in L}\f$ is given by \f$\prod_{l\in L} S_l\f$.
          */
         size_t nrStates() {
@@ -79,7 +79,7 @@ class VarSet : public SmallSet<Var> {
         VarSet( const Var &n ) : SmallSet<Var>(n) {}
 
         /// Construct a VarSet with two elements
         VarSet( const Var &n ) : SmallSet<Var>(n) {}
 
         /// Construct a VarSet with two elements
-        VarSet( const Var &n1, const Var &n2 ) : SmallSet<Var>(n1,n2) {} 
+        VarSet( const Var &n1, const Var &n2 ) : SmallSet<Var>(n1,n2) {}
 
         /// Construct a VarSet from a range.
         /** \tparam VarIterator Iterates over instances of type Var.
 
         /// Construct a VarSet from a range.
         /** \tparam VarIterator Iterates over instances of type Var.
@@ -95,7 +95,7 @@ class VarSet : public SmallSet<Var> {
          *  \return The linear index in the Cartesian product of the variables in *this
          *  corresponding with the joint assignment specified by \a states, where it is
          *  assumed that \a states[\a m]==0 for all \a m in *this which are not in \a states.
          *  \return The linear index in the Cartesian product of the variables in *this
          *  corresponding with the joint assignment specified by \a states, where it is
          *  assumed that \a states[\a m]==0 for all \a m in *this which are not in \a states.
-         *  
+         *
          *  The linear index is calculated as follows. The variables in *this are
          *  ordered according to their label (in ascending order); say *this 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$,
          *  The linear index is calculated as follows. The variables in *this are
          *  ordered according to their label (in ascending order); say *this 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$,
@@ -110,9 +110,9 @@ class VarSet : public SmallSet<Var> {
          *  \f}
          *
          *  \note If *this corresponds with \f$\{x_l\}_{l\in L}\f$, and \a states specifies a state
          *  \f}
          *
          *  \note If *this corresponds with \f$\{x_l\}_{l\in L}\f$, and \a states specifies a state
-         *  for each variable \f$x_l\f$ for \f$l\in L\f$, calcState(const std::map<Var,size_t> &) induces a mapping 
+         *  for each variable \f$x_l\f$ for \f$l\in L\f$, calcState(const std::map<Var,size_t> &) induces a mapping
          *  \f$\sigma : \prod_{l\in L} X_l \to \{0,1,\dots,\prod_{l\in L} S_l-1\}\f$ that
          *  \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 
+         *  maps a joint state to a linear index; this is the inverse of the mapping
          *  \f$\sigma^{-1}\f$ induced by calcStates(size_t).
          */
         size_t calcState( const std::map<Var, size_t> &states ) {
          *  \f$\sigma^{-1}\f$ induced by calcStates(size_t).
          */
         size_t calcState( const std::map<Var, size_t> &states ) {
@@ -134,16 +134,16 @@ class VarSet : public SmallSet<Var> {
          *  The variables in *this are ordered according to their label (in ascending order); say *this 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
          *  The variables in *this are ordered according to their label (in ascending order); say *this 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. 
+         *  ("states") of variable \f$x_l\f$ with label \a l.
          *  The mapping \a s 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.
          *
          *  The mapping \a s 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 *this corresponds with \f$\{x_l\}_{l\in L}\f$, calcStates(size_t) induces a mapping 
+         *  \note If *this corresponds with \f$\{x_l\}_{l\in L}\f$, calcStates(size_t) 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
          *  \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$ 
+         *  maps a linear index to a joint state; this is the inverse of the mapping \f$\sigma\f$
          *  induced by calcState(const std::map<Var,size_t> &).
          */
         std::map<Var, size_t> calcStates( size_t linearState ) {
          *  induced by calcState(const std::map<Var,size_t> &).
          */
         std::map<Var, size_t> calcStates( size_t linearState ) {
index 6cff0bb..bee160d 100644 (file)
@@ -51,7 +51,7 @@ class DEdge {
     public:
         size_t n1;  ///< First node index
         size_t n2;  ///< Second node index
     public:
         size_t n1;  ///< First node index
         size_t n2;  ///< Second node index
-    
+
         /// Default constructor
         DEdge() {}
 
         /// Default constructor
         DEdge() {}
 
@@ -82,7 +82,7 @@ class UEdge {
     public:
         size_t  n1;  ///< First node index
         size_t  n2;  ///< Second node index
     public:
         size_t  n1;  ///< First node index
         size_t  n2;  ///< Second node index
-    
+
         /// Default constructor
         UEdge() {}
 
         /// Default constructor
         UEdge() {}
 
@@ -172,7 +172,7 @@ template<typename T> DEdgeVec MinSpanningTreePrims( const WeightedGraph<T> &G )
         // order, such that for all (i1, j1), (i2, j2) in result,
         // if j1 == i2 then (i1, j1) comes before (i2, j2) in result.
         // We do this by reordering the contents of result, effectively
         // order, such that for all (i1, j1), (i2, j2) in result,
         // if j1 == i2 then (i1, j1) comes before (i2, j2) in result.
         // We do this by reordering the contents of result, effectively
-        // growing the tree starting at the root. At each step, 
+        // growing the tree starting at the root. At each step,
         // result[0..N-1] are the edges already added to the tree,
         // whereas the other elements of result still have to be added.
         // The elements of nodes are the vertices that still have to
         // result[0..N-1] are the edges already added to the tree,
         // whereas the other elements of result still have to be added.
         // The elements of nodes are the vertices that still have to
index 04e9c2b..b15b049 100644 (file)
@@ -1,5 +1,5 @@
 % N = dai_potstrength (psi, i, j)
 % 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.
 %    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.
index f3601b9..8c355c8 100755 (executable)
@@ -21,8 +21,8 @@ my ($gen_code_start_pat, $gen_code_end_pat, $props_start_pat) =
    qr(/\*.*PROPERTIES));
 # Actual delimiters to use for generated code blocks
 my ($gen_code_start, $gen_code_end) =
    qr(/\*.*PROPERTIES));
 # Actual delimiters to use for generated code blocks
 my ($gen_code_start, $gen_code_end) =
-  ("/* {{{ GENERATED CODE: DO NOT EDIT. Created by \n".
-   "    $0 $header_file $source_file \n*/\n",
+  ("/* {{{ GENERATED CODE: DO NOT EDIT. Created by\n".
+   "    $0 $header_file $source_file\n*/\n",
    "/* }}} END OF GENERATED CODE */\n");
 
 # Strings to hold text of files
    "/* }}} END OF GENERATED CODE */\n");
 
 # Strings to hold text of files
@@ -155,7 +155,7 @@ sub process_properties ($$$) {
       push @vars, [$type, $name, $default, $cmt];
     }
   }
       push @vars, [$type, $name, $default, $cmt];
     }
   }
-  
+
   my ($stext) = "";
   my ($text) = <<EOF;
         struct Properties {
   my ($stext) = "";
   my ($text) = <<EOF;
         struct Properties {
@@ -282,7 +282,7 @@ EOF
 $source_buffer = process_file { return 0; } $source_file;
 $source_buffer =~ s/\n+$//s;
 
 $source_buffer = process_file { return 0; } $source_file;
 $source_buffer =~ s/\n+$//s;
 
-$header_buffer = process_file { 
+$header_buffer = process_file {
   if (/$props_start_pat/) {
     # when we see something resembling properties, record it, and when we
     # get to the end, process and emit the generated code
   if (/$props_start_pat/) {
     # when we see something resembling properties, record it, and when we
     # get to the end, process and emit the generated code
index 1e8733f..cd68413 100644 (file)
@@ -36,15 +36,15 @@ InfAlg *newInfAlg( const std::string &name, const FactorGraph &fg, const Propert
     if( name == ExactInf::Name )
         return new ExactInf (fg, opts);
 #ifdef DAI_WITH_BP
     if( name == ExactInf::Name )
         return new ExactInf (fg, opts);
 #ifdef DAI_WITH_BP
-    if( name == BP::Name ) 
+    if( name == BP::Name )
         return new BP (fg, opts);
 #endif
 #ifdef DAI_WITH_MF
         return new BP (fg, opts);
 #endif
 #ifdef DAI_WITH_MF
-    if( name == MF::Name ) 
+    if( name == MF::Name )
         return new MF (fg, opts);
 #endif
 #ifdef DAI_WITH_HAK
         return new MF (fg, opts);
 #endif
 #ifdef DAI_WITH_HAK
-    if( name == HAK::Name ) 
+    if( name == HAK::Name )
         return new HAK (fg, opts);
 #endif
 #ifdef DAI_WITH_LC
         return new HAK (fg, opts);
 #endif
 #ifdef DAI_WITH_LC
index 15e3672..eb03614 100644 (file)
@@ -98,7 +98,7 @@ size_t getFactorEntryForState( const FactorGraph &fg, size_t I, const vector<siz
 void BBP::RegenerateInds() {
     // initialise _indices
     //     typedef std::vector<size_t>        _ind_t;
 void BBP::RegenerateInds() {
     // initialise _indices
     //     typedef std::vector<size_t>        _ind_t;
-    //     std::vector<std::vector<_ind_t> >  _indices; 
+    //     std::vector<std::vector<_ind_t> >  _indices;
     _indices.resize( _fg->nrVars() );
     for( size_t i = 0; i < _fg->nrVars(); i++ ) {
         _indices[i].clear();
     _indices.resize( _fg->nrVars() );
     for( size_t i = 0; i < _fg->nrVars(); i++ ) {
         _indices[i].clear();
@@ -190,7 +190,7 @@ void BBP::RegenerateR() {
                 if( I != J ) {
                     Prob prod( _fg->var(i).states(), 1.0 );
                     foreach( const Neighbor &K, _fg->nbV(i) )
                 if( I != J ) {
                     Prob prod( _fg->var(i).states(), 1.0 );
                     foreach( const Neighbor &K, _fg->nbV(i) )
-                        if( K.node != I && K.node != J.node ) 
+                        if( K.node != I && K.node != J.node )
                             prod *= _bp_dual.msgM( i, K.iter );
                     _R[I][i.iter][J.iter] = prod;
                 }
                             prod *= _bp_dual.msgM( i, K.iter );
                     _R[I][i.iter][J.iter] = prod;
                 }
@@ -506,7 +506,7 @@ void BBP::sendSeqMsgM( size_t j, size_t _I ) {
         um[x_I] *= _adj_m_unnorm_jI[ind[x_I]];
     um *= 1 - props.damping;
     _adj_psi_F[I] += um;
         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);
     */
     /* 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);
     */
@@ -568,7 +568,7 @@ Real BBP::getUnMsgMag() {
 
 
 void BBP::getMsgMags( Real &s, Real &new_s ) {
 
 
 void BBP::getMsgMags( Real &s, Real &new_s ) {
-    s = 0.0; 
+    s = 0.0;
     new_s = 0.0;
     size_t e = 0;
     for( size_t i = 0; i < _fg->nrVars(); i++ )
     new_s = 0.0;
     size_t e = 0;
     for( size_t i = 0; i < _fg->nrVars(); i++ )
@@ -579,7 +579,7 @@ void BBP::getMsgMags( Real &s, Real &new_s ) {
             new_s += _new_adj_n[i][I.iter].sumAbs();
             e++;
         }
             new_s += _new_adj_n[i][I.iter].sumAbs();
             e++;
         }
-    s /= e; 
+    s /= e;
     new_s /= e;
 }
 
     new_s /= e;
 }
 
@@ -711,7 +711,7 @@ void BBP::run() {
             do {
                 _iters++;
                 mag = getTotalMsgM();
             do {
                 _iters++;
                 mag = getTotalMsgM();
-                if( mag < tol ) 
+                if( mag < tol )
                     break;
 
                 for( size_t i = 0; i < _fg->nrVars(); i++ )
                     break;
 
                 for( size_t i = 0; i < _fg->nrVars(); i++ )
@@ -800,10 +800,10 @@ double numericBBPTest( const InfAlg &bp, const vector<size_t> *state, const Prop
 //                 psi_1_prb.normalize();
                 size_t I = bp_prb->fg().nbV(i)[0]; // use first factor in list of neighbors of i
                 bp_prb->fg().factor(I) *= Factor( bp_prb->fg().var(i), psi_1_prb );
 //                 psi_1_prb.normalize();
                 size_t I = bp_prb->fg().nbV(i)[0]; // use first factor in list of neighbors of i
                 bp_prb->fg().factor(I) *= Factor( bp_prb->fg().var(i), psi_1_prb );
-                
+
                 // call 'init' on the perturbed variables
                 bp_prb->init( bp_prb->fg().var(i) );
                 // call 'init' on the perturbed variables
                 bp_prb->init( bp_prb->fg().var(i) );
-                
+
                 // run copy to convergence
                 bp_prb->run();
 
                 // run copy to convergence
                 bp_prb->run();
 
@@ -812,7 +812,7 @@ double numericBBPTest( const InfAlg &bp, const vector<size_t> *state, const Prop
 
                 // use to estimate adjoint for i
                 adj_est.push_back( (cf_prb - cf0) / h );
 
                 // use to estimate adjoint for i
                 adj_est.push_back( (cf_prb - cf0) / h );
-                
+
                 // free cloned InfAlg
                 delete bp_prb;
             }
                 // free cloned InfAlg
                 delete bp_prb;
             }
@@ -851,7 +851,7 @@ double numericBBPTest( const InfAlg &bp, const vector<size_t> *state, const Prop
                     // add it to list of adjoints
                     adj_n_est.push_back((cf_prb-cf0)/h);
                 }
                     // add it to list of adjoints
                     adj_n_est.push_back((cf_prb-cf0)/h);
                 }
-        
+
                 vector<double> adj_m_est;
                 // for each value xi
                 for(size_t xi=0; xi<bp_dual.var(i).states(); xi++) {
                 vector<double> adj_m_est;
                 // for each value xi
                 for(size_t xi=0; xi<bp_dual.var(i).states(); xi++) {
@@ -932,7 +932,7 @@ bool needGibbsState( bbp_cfn_t cfn ) {
 
 void initBBPCostFnAdj( BBP &bbp, const InfAlg &ia, bbp_cfn_t cfn_type, const vector<size_t> *stateP ) {
     const FactorGraph &fg = ia.fg();
 
 void initBBPCostFnAdj( BBP &bbp, const InfAlg &ia, bbp_cfn_t cfn_type, const vector<size_t> *stateP ) {
     const FactorGraph &fg = ia.fg();
-    
+
     switch( (size_t)cfn_type ) {
         case bbp_cfn_t::CFN_BETHE_ENT: {
             vector<Prob> b1_adj;
     switch( (size_t)cfn_type ) {
         case bbp_cfn_t::CFN_BETHE_ENT: {
             vector<Prob> b1_adj;
@@ -1022,15 +1022,15 @@ void initBBPCostFnAdj( BBP &bbp, const InfAlg &ia, bbp_cfn_t cfn_type, const vec
                 double b = ia.beliefV(i)[state[i]];
                 switch( (size_t)cfn_type ) {
                     case bbp_cfn_t::CFN_GIBBS_B:
                 double b = ia.beliefV(i)[state[i]];
                 switch( (size_t)cfn_type ) {
                     case bbp_cfn_t::CFN_GIBBS_B:
-                        delta[state[i]] = 1.0; 
+                        delta[state[i]] = 1.0;
                         break;
                     case bbp_cfn_t::CFN_GIBBS_B2:
                         break;
                     case bbp_cfn_t::CFN_GIBBS_B2:
-                        delta[state[i]] = b; 
+                        delta[state[i]] = b;
                         break;
                     case bbp_cfn_t::CFN_GIBBS_EXP:
                         break;
                     case bbp_cfn_t::CFN_GIBBS_EXP:
-                        delta[state[i]] = exp(b); 
+                        delta[state[i]] = exp(b);
                         break;
                         break;
-                    default: 
+                    default:
                         DAI_THROW(UNKNOWN_ENUM_VALUE);
                 }
                 b1_adj.push_back( delta );
                         DAI_THROW(UNKNOWN_ENUM_VALUE);
                 }
                 b1_adj.push_back( delta );
@@ -1060,22 +1060,22 @@ void initBBPCostFnAdj( BBP &bbp, const InfAlg &ia, bbp_cfn_t cfn_type, const vec
                 double b = ia.beliefF(I)[x_I];
                 switch( (size_t)cfn_type ) {
                     case bbp_cfn_t::CFN_GIBBS_B_FACTOR:
                 double b = ia.beliefF(I)[x_I];
                 switch( (size_t)cfn_type ) {
                     case bbp_cfn_t::CFN_GIBBS_B_FACTOR:
-                        delta[x_I] = 1.0; 
+                        delta[x_I] = 1.0;
                         break;
                     case bbp_cfn_t::CFN_GIBBS_B2_FACTOR:
                         break;
                     case bbp_cfn_t::CFN_GIBBS_B2_FACTOR:
-                        delta[x_I] = b; 
+                        delta[x_I] = b;
                         break;
                     case bbp_cfn_t::CFN_GIBBS_EXP_FACTOR:
                         delta[x_I] = exp( b );
                         break;
                         break;
                     case bbp_cfn_t::CFN_GIBBS_EXP_FACTOR:
                         delta[x_I] = exp( b );
                         break;
-                    default: 
+                    default:
                         DAI_THROW(UNKNOWN_ENUM_VALUE);
                 }
                 b2_adj.push_back( delta );
             }
             bbp.init( bbp.getZeroAdjV(fg), b2_adj );
             break;
                         DAI_THROW(UNKNOWN_ENUM_VALUE);
                 }
                 b2_adj.push_back( delta );
             }
             bbp.init( bbp.getZeroAdjV(fg), b2_adj );
             break;
-        } default: 
+        } default:
             DAI_THROW(UNKNOWN_ENUM_VALUE);
     }
 }
             DAI_THROW(UNKNOWN_ENUM_VALUE);
     }
 }
@@ -1144,7 +1144,7 @@ Real getCostFn( const InfAlg &ia, bbp_cfn_t cfn_type, const vector<size_t> *stat
                 }
             }
             break;
                 }
             }
             break;
-        } default: 
+        } default:
             DAI_THROWE(UNKNOWN_ENUM_VALUE, "Unknown cost function " + std::string(cfn_type));
     }
     return cf;
             DAI_THROWE(UNKNOWN_ENUM_VALUE, "Unknown cost function " + std::string(cfn_type));
     }
     return cf;
@@ -1154,8 +1154,8 @@ Real getCostFn( const InfAlg &ia, bbp_cfn_t cfn_type, const vector<size_t> *stat
 } // end of namespace dai
 
 
 } // end of namespace dai
 
 
-/* {{{ GENERATED CODE: DO NOT EDIT. Created by 
-    ./scripts/regenerate-properties include/dai/bbp.h src/bbp.cpp 
+/* {{{ GENERATED CODE: DO NOT EDIT. Created by
+    ./scripts/regenerate-properties include/dai/bbp.h src/bbp.cpp
 */
 namespace dai {
 
 */
 namespace dai {
 
index 4a12326..d1eeffa 100644 (file)
@@ -217,7 +217,7 @@ bool BipartiteGraph::isTree() const {
                     }
                     if( foundCycle )
                         break;
                     }
                     if( foundCycle )
                         break;
-                } 
+                }
             }
             levels.push_back( newLevel );
             nr_1 += newLevel.ind1.size();
             }
             levels.push_back( newLevel );
             nr_1 += newLevel.ind1.size();
index 7e11658..07c54bc 100644 (file)
@@ -49,7 +49,7 @@ void BP::setProperties( const PropertySet &opts ) {
     assert( opts.hasKey("maxiter") );
     assert( opts.hasKey("logdomain") );
     assert( opts.hasKey("updates") );
     assert( opts.hasKey("maxiter") );
     assert( opts.hasKey("logdomain") );
     assert( opts.hasKey("updates") );
-    
+
     props.tol = opts.getStringAs<double>("tol");
     props.maxiter = opts.getStringAs<size_t>("maxiter");
     props.logdomain = opts.getStringAs<bool>("logdomain");
     props.tol = opts.getStringAs<double>("tol");
     props.maxiter = opts.getStringAs<size_t>("maxiter");
     props.logdomain = opts.getStringAs<bool>("logdomain");
@@ -106,7 +106,7 @@ void BP::construct() {
         _edge2lut.reserve( nrVars() );
     for( size_t i = 0; i < nrVars(); ++i ) {
         _edges.push_back( vector<EdgeProp>() );
         _edge2lut.reserve( nrVars() );
     for( size_t i = 0; i < nrVars(); ++i ) {
         _edges.push_back( vector<EdgeProp>() );
-        _edges[i].reserve( nbV(i).size() ); 
+        _edges[i].reserve( nbV(i).size() );
         if( props.updates == Properties::UpdateType::SEQMAX ) {
             _edge2lut.push_back( vector<LutType::iterator>() );
             _edge2lut[i].reserve( nbV(i).size() );
         if( props.updates == Properties::UpdateType::SEQMAX ) {
             _edge2lut.push_back( vector<LutType::iterator>() );
             _edge2lut[i].reserve( nbV(i).size() );
@@ -138,7 +138,7 @@ void BP::init() {
             message( i, I.iter ).fill( c );
             newMessage( i, I.iter ).fill( c );
             if( props.updates == Properties::UpdateType::SEQMAX )
             message( i, I.iter ).fill( c );
             newMessage( i, I.iter ).fill( c );
             if( props.updates == Properties::UpdateType::SEQMAX )
-                               updateResidual( i, I.iter, 0.0 );
+                updateResidual( i, I.iter, 0.0 );
         }
     }
 }
         }
     }
 }
@@ -159,16 +159,16 @@ void BP::calcNewMessage( size_t i, size_t _I ) {
 
     Factor Fprod( factor(I) );
     Prob &prod = Fprod.p();
 
     Factor Fprod( factor(I) );
     Prob &prod = Fprod.p();
-    if( props.logdomain ) 
+    if( props.logdomain )
         prod.takeLog();
 
     // Calculate product of incoming messages and factor I
     foreach( const Neighbor &j, nbF(I) )
         if( j != i ) { // for all j in I \ i
             // prod_j will be the product of messages coming into j
         prod.takeLog();
 
     // Calculate product of incoming messages and factor I
     foreach( const Neighbor &j, nbF(I) )
         if( j != i ) { // for all j in I \ i
             // prod_j will be the product of messages coming into j
-            Prob prod_j( var(j).states(), props.logdomain ? 0.0 : 1.0 ); 
+            Prob prod_j( var(j).states(), props.logdomain ? 0.0 : 1.0 );
             foreach( const Neighbor &J, nbV(j) )
             foreach( const Neighbor &J, nbV(j) )
-                if( J != I ) { // for all J in nb(j) \ I 
+                if( J != I ) { // for all J in nb(j) \ I
                     if( props.logdomain )
                         prod_j += message( j, J.iter );
                     else
                     if( props.logdomain )
                         prod_j += message( j, J.iter );
                     else
@@ -204,7 +204,7 @@ void BP::calcNewMessage( size_t i, size_t _I ) {
     Prob marg;
     if( !DAI_BP_FAST ) {
         /* UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION */
     Prob marg;
     if( !DAI_BP_FAST ) {
         /* UNOPTIMIZED (SIMPLE TO READ, BUT SLOW) VERSION */
-        if( props.inference == Properties::InfType::SUMPROD ) 
+        if( props.inference == Properties::InfType::SUMPROD )
             marg = Fprod.marginal( var(i) ).p();
         else
             marg = Fprod.maxMarginal( var(i) ).p();
             marg = Fprod.marginal( var(i) ).p();
         else
             marg = Fprod.maxMarginal( var(i) ).p();
@@ -213,12 +213,12 @@ void BP::calcNewMessage( size_t i, size_t _I ) {
         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);
         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 ) 
+        if( props.inference == Properties::InfType::SUMPROD )
             for( size_t r = 0; r < prod.size(); ++r )
                 marg[ind[r]] += prod[r];
         else
             for( size_t r = 0; r < prod.size(); ++r )
             for( size_t r = 0; r < prod.size(); ++r )
                 marg[ind[r]] += prod[r];
         else
             for( size_t r = 0; r < prod.size(); ++r )
-                if( prod[r] > marg[ind[r]] ) 
+                if( prod[r] > marg[ind[r]] )
                     marg[ind[r]] = prod[r];
         marg.normalize();
     }
                     marg[ind[r]] = prod[r];
         marg.normalize();
     }
@@ -245,7 +245,7 @@ double BP::run() {
 
     double tic = toc();
     Diffs diffs(nrVars(), 1.0);
 
     double tic = toc();
     Diffs diffs(nrVars(), 1.0);
-    
+
     vector<Edge> update_seq;
 
     vector<Factor> old_beliefs;
     vector<Edge> update_seq;
 
     vector<Factor> old_beliefs;
@@ -293,7 +293,7 @@ double BP::run() {
                 }
             }
         } else if( props.updates == Properties::UpdateType::PARALL ) {
                 }
             }
         } else if( props.updates == Properties::UpdateType::PARALL ) {
-            // Parallel updates 
+            // Parallel updates
             for( size_t i = 0; i < nrVars(); ++i )
                 foreach( const Neighbor &I, nbV(i) )
                     calcNewMessage( i, I.iter );
             for( size_t i = 0; i < nrVars(); ++i )
                 foreach( const Neighbor &I, nbV(i) )
                     calcNewMessage( i, I.iter );
@@ -305,7 +305,7 @@ double BP::run() {
             // Sequential updates
             if( props.updates == Properties::UpdateType::SEQRND )
                 random_shuffle( update_seq.begin(), update_seq.end() );
             // Sequential updates
             if( props.updates == Properties::UpdateType::SEQRND )
                 random_shuffle( update_seq.begin(), update_seq.end() );
-            
+
             foreach( const Edge &e, update_seq ) {
                 calcNewMessage( e.first, e.second );
                 updateMessage( e.first, e.second );
             foreach( const Edge &e, update_seq ) {
                 calcNewMessage( e.first, e.second );
                 updateMessage( e.first, e.second );
@@ -343,7 +343,7 @@ double BP::run() {
 
 
 void BP::calcBeliefV( size_t i, Prob &p ) const {
 
 
 void BP::calcBeliefV( size_t i, Prob &p ) const {
-    p = Prob( var(i).states(), props.logdomain ? 0.0 : 1.0 ); 
+    p = Prob( var(i).states(), props.logdomain ? 0.0 : 1.0 );
     foreach( const Neighbor &I, nbV(i) )
         if( props.logdomain )
             p += newMessage( i, I.iter );
     foreach( const Neighbor &I, nbV(i) )
         if( props.logdomain )
             p += newMessage( i, I.iter );
@@ -356,14 +356,14 @@ void BP::calcBeliefF( size_t I, Prob &p ) const {
     Factor Fprod( factor( I ) );
     Prob &prod = Fprod.p();
 
     Factor Fprod( factor( I ) );
     Prob &prod = Fprod.p();
 
-    if( props.logdomain ) 
+    if( props.logdomain )
         prod.takeLog();
 
     foreach( const Neighbor &j, nbF(I) ) {
         // prod_j will be the product of messages coming into j
         Prob prod_j( var(j).states(), props.logdomain ? 0.0 : 1.0 );
         foreach( const Neighbor &J, nbV(j) )
         prod.takeLog();
 
     foreach( const Neighbor &j, nbF(I) ) {
         // prod_j will be the product of messages coming into j
         Prob prod_j( var(j).states(), props.logdomain ? 0.0 : 1.0 );
         foreach( const Neighbor &J, nbV(j) )
-            if( J != I ) { // for all J in nb(j) \ I 
+            if( J != I ) { // for all J in nb(j) \ I
                 if( props.logdomain )
                     prod_j += newMessage( j, J.iter );
                 else
                 if( props.logdomain )
                     prod_j += newMessage( j, J.iter );
                 else
@@ -463,7 +463,7 @@ Real BP::logZ() const {
 }
 
 
 }
 
 
-string BP::identify() const { 
+string BP::identify() const {
     return string(Name) + printProperties();
 }
 
     return string(Name) + printProperties();
 }
 
@@ -498,12 +498,12 @@ void BP::updateMessage( size_t i, size_t _I ) {
 
 
 void BP::updateResidual( size_t i, size_t _I, double r ) {
 
 
 void BP::updateResidual( size_t i, size_t _I, double 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) ) );
+    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) ) );
 }
 
 
 }
 
 
@@ -516,14 +516,14 @@ std::vector<size_t> BP::findMaximum() const {
         if( visitedVars[i] )
             continue;
         visitedVars[i] = true;
         if( visitedVars[i] )
             continue;
         visitedVars[i] = true;
-        
+
         // Maximise with respect to variable i
         Prob prod;
         calcBeliefV( i, prod );
         maximum[i] = max_element( prod.begin(), prod.end() ) - prod.begin();
         // Maximise with respect to variable i
         Prob prod;
         calcBeliefV( i, prod );
         maximum[i] = max_element( prod.begin(), prod.end() ) - prod.begin();
-        
+
         foreach( const Neighbor &I, nbV(i) )
         foreach( const Neighbor &I, nbV(i) )
-            if( !visitedFactors[I] ) 
+            if( !visitedFactors[I] )
                 scheduledFactors.push(I);
 
         while( !scheduledFactors.empty() ){
                 scheduledFactors.push(I);
 
         while( !scheduledFactors.empty() ){
@@ -532,17 +532,17 @@ std::vector<size_t> BP::findMaximum() const {
             if( visitedFactors[I] )
                 continue;
             visitedFactors[I] = true;
             if( visitedFactors[I] )
                 continue;
             visitedFactors[I] = true;
-            
+
             // Evaluate if some neighboring variables still need to be fixed; if not, we're done
             bool allDetermined = true;
             // Evaluate if some neighboring variables still need to be fixed; if not, we're done
             bool allDetermined = true;
-            foreach( const Neighbor &j, nbF(I) ) 
+            foreach( const Neighbor &j, nbF(I) )
                 if( !visitedVars[j.node] ) {
                     allDetermined = false;
                     break;
                 }
             if( allDetermined )
                 continue;
                 if( !visitedVars[j.node] ) {
                     allDetermined = false;
                     break;
                 }
             if( allDetermined )
                 continue;
-            
+
             // Calculate product of incoming messages on factor I
             Prob prod2;
             calcBeliefF( I, prod2 );
             // Calculate product of incoming messages on factor I
             Prob prod2;
             calcBeliefF( I, prod2 );
@@ -566,7 +566,7 @@ std::vector<size_t> BP::findMaximum() const {
                     maxProb = prod2[s];
                 }
             }
                     maxProb = prod2[s];
                 }
             }
-            
+
             // Decode the argmax
             foreach( const Neighbor &j, nbF(I) ) {
                 if( visitedVars[j.node] ) {
             // Decode the argmax
             foreach( const Neighbor &j, nbF(I) ) {
                 if( visitedVars[j.node] ) {
@@ -578,7 +578,7 @@ std::vector<size_t> BP::findMaximum() const {
                     visitedVars[j.node] = true;
                     maximum[j.node] = maxState( var(j.node) );
                     foreach( const Neighbor &J, nbV(j) )
                     visitedVars[j.node] = true;
                     maximum[j.node] = maxState( var(j.node) );
                     foreach( const Neighbor &J, nbV(j) )
-                        if( !visitedFactors[J] ) 
+                        if( !visitedFactors[J] )
                             scheduledFactors.push(J);
                 }
             }
                             scheduledFactors.push(J);
                 }
             }
index 44014fe..8e67da9 100644 (file)
@@ -111,7 +111,7 @@ void BP_dual::calcNewM( size_t i, size_t _I ) {
     IndexFor ind( fg().var(i), fg().factor(I).vars() );
     for( size_t x = 0; ind >= 0; x++, ++ind )
         marg[ind] += prod[x];
     IndexFor ind( fg().var(i), fg().factor(I).vars() );
     for( size_t x = 0; ind >= 0; x++, ++ind )
         marg[ind] += prod[x];
-    
+
     _msgs.Zm[i][_I] = marg.normalize();
     _msgs.m[i][_I] = marg;
 }
     _msgs.Zm[i][_I] = marg.normalize();
     _msgs.m[i][_I] = marg;
 }
index a4a5511..9d4f64f 100644 (file)
@@ -44,13 +44,13 @@ const char *CBP::Name = "CBP";
 
 void CBP::setBeliefs( const std::vector<Factor> &bs, double logZ ) {
     size_t i = 0;
 
 void CBP::setBeliefs( const std::vector<Factor> &bs, double logZ ) {
     size_t i = 0;
-    _beliefsV.clear(); 
+    _beliefsV.clear();
     _beliefsV.reserve( nrVars() );
     _beliefsV.reserve( nrVars() );
-    _beliefsF.clear(); 
+    _beliefsF.clear();
     _beliefsF.reserve( nrFactors() );
     _beliefsF.reserve( nrFactors() );
-    for( i = 0; i < nrVars(); i++ ) 
+    for( i = 0; i < nrVars(); i++ )
         _beliefsV.push_back( bs[i] );
         _beliefsV.push_back( bs[i] );
-    for( ; i < nrVars() + nrFactors(); i++ ) 
+    for( ; i < nrVars() + nrFactors(); i++ )
         _beliefsF.push_back( bs[i] );
     _logZ = logZ;
 }
         _beliefsF.push_back( bs[i] );
     _logZ = logZ;
 }
@@ -99,7 +99,7 @@ static vector<Factor> mixBeliefs( Real p, const vector<Factor> &b, const vector<
 
 double CBP::run() {
     size_t seed = props.rand_seed;
 
 double CBP::run() {
     size_t seed = props.rand_seed;
-    if( seed > 0) 
+    if( seed > 0)
         rnd_seed( seed );
 
     InfAlg *bp = getInfAlg();
         rnd_seed( seed );
 
     InfAlg *bp = getInfAlg();
@@ -159,12 +159,12 @@ void CBP::runRecurse( InfAlg *bp, double orig_logZ, vector<size_t> clamped_vars_
     choose_count++;
     if( props.clamp_outfile.length() > 0 )
         *_clamp_ofstream << choose_count << "\t" << clamped_vars_list.size() << "\t" << i << "\t" << xis[0] << endl;
     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 )
     if( clampingVar )
-        foreach( size_t xi, xis ) 
+        foreach( size_t xi, xis )
             assert(/*0<=xi &&*/ xi < var(i).states() );
     else
             assert(/*0<=xi &&*/ xi < var(i).states() );
     else
-        foreach( size_t xI, xis ) 
+        foreach( size_t xI, xis )
             assert(/*0<=xI &&*/ xI < factor(i).states() );
     // - otherwise, clamp and recurse, saving margin estimates for each
     // clamp setting. afterwards, combine estimates.
             assert(/*0<=xI &&*/ xI < factor(i).states() );
     // - otherwise, clamp and recurse, saving margin estimates for each
     // clamp setting. afterwards, combine estimates.
@@ -173,7 +173,7 @@ void CBP::runRecurse( InfAlg *bp, double orig_logZ, vector<size_t> clamped_vars_
     vector<size_t> cmp_xis = complement( xis, clampingVar ? var(i).states() : factor(i).states() );
 
     /// \todo could do this more efficiently with a nesting version of saveProbs/undoProbs
     vector<size_t> cmp_xis = complement( xis, clampingVar ? var(i).states() : factor(i).states() );
 
     /// \todo could do this more efficiently with a nesting version of saveProbs/undoProbs
-    Real lz; 
+    Real lz;
     vector<Factor> b;
     InfAlg *bp_c = bp->clone();
     if( clampingVar ) {
     vector<Factor> b;
     InfAlg *bp_c = bp->clone();
     if( clampingVar ) {
@@ -189,7 +189,7 @@ void CBP::runRecurse( InfAlg *bp, double orig_logZ, vector<size_t> clamped_vars_
     lz = bp_c->logZ();
     b = bp_c->beliefs();
 
     lz = bp_c->logZ();
     b = bp_c->beliefs();
 
-    Real cmp_lz; 
+    Real cmp_lz;
     vector<Factor> cmp_b;
     InfAlg *cmp_bp_c = bp->clone();
     if( clampingVar ) {
     vector<Factor> cmp_b;
     InfAlg *cmp_bp_c = bp->clone();
     if( clampingVar ) {
@@ -207,7 +207,7 @@ void CBP::runRecurse( InfAlg *bp, double orig_logZ, vector<size_t> clamped_vars_
 
     double p = unSoftMax( lz, cmp_lz );
     Real bp__d = 0.0;
 
     double p = unSoftMax( lz, cmp_lz );
     Real bp__d = 0.0;
-    
+
     if( Recursion() == Properties::RecurseType::REC_BDIFF && recTol() > 0 ) {
         vector<Factor> combined_b( mixBeliefs( p, b, cmp_b ) );
         Real new_lz = logSumExp( lz,cmp_lz );
     if( Recursion() == Properties::RecurseType::REC_BDIFF && recTol() > 0 ) {
         vector<Factor> combined_b( mixBeliefs( p, b, cmp_b ) );
         Real new_lz = logSumExp( lz,cmp_lz );
@@ -304,9 +304,9 @@ bool CBP::chooseNextClampVar( InfAlg *bp, vector<size_t> &clamped_vars_list, siz
                     win_xk = bp->beliefV(k).p().argmax().first;
                 }
             }
                     win_xk = bp->beliefV(k).p().argmax().first;
                 }
             }
-            assert( win_k >= 0 ); 
+            assert( win_k >= 0 );
             assert( win_xk >= 0 );
             assert( win_xk >= 0 );
-            i = win_k; 
+            i = win_k;
             xis.resize( 1, win_xk );
             DAI_IFVERB(2, endl<<"CHOOSE_MAXENT chose variable "<<i<<" state "<<xis[0]<<endl);
             if( bp->beliefV(i).p()[xis[0]] < tiny ) {
             xis.resize( 1, win_xk );
             DAI_IFVERB(2, endl<<"CHOOSE_MAXENT chose variable "<<i<<" state "<<xis[0]<<endl);
             if( bp->beliefV(i).p()[xis[0]] < tiny ) {
@@ -324,9 +324,9 @@ bool CBP::chooseNextClampVar( InfAlg *bp, vector<size_t> &clamped_vars_list, siz
                     win_xk = bp->beliefF(k).p().argmax().first;
                 }
             }
                     win_xk = bp->beliefF(k).p().argmax().first;
                 }
             }
-            assert( win_k >= 0 ); 
+            assert( win_k >= 0 );
             assert( win_xk >= 0 );
             assert( win_xk >= 0 );
-            i = win_k; 
+            i = win_k;
             xis.resize( 1, win_xk );
             DAI_IFVERB(2, endl<<"CHOOSE_MAXENT chose factor "<<i<<" state "<<xis[0]<<endl);
             if( bp->beliefF(i).p()[xis[0]] < tiny ) {
             xis.resize( 1, win_xk );
             DAI_IFVERB(2, endl<<"CHOOSE_MAXENT chose factor "<<i<<" state "<<xis[0]<<endl);
             if( bp->beliefF(i).p()[xis[0]] < tiny ) {
@@ -346,7 +346,7 @@ bool CBP::chooseNextClampVar( InfAlg *bp, vector<size_t> &clamped_vars_list, siz
         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++ ) {
         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 ) 
+                if( bp->beliefV(k)[xk] < tiny )
                     continue;
                 InfAlg *bp1 = bp->clone();
                 bp1->clamp( k, xk );
                     continue;
                 InfAlg *bp1 = bp->clone();
                 bp1->clamp( k, xk );
@@ -366,13 +366,13 @@ bool CBP::chooseNextClampVar( InfAlg *bp, vector<size_t> &clamped_vars_list, siz
                 delete bp1;
             }
         }
                 delete bp1;
             }
         }
-        assert( win_k >= 0 ); 
+        assert( win_k >= 0 );
         assert( win_xk >= 0 );
         assert( win_xk >= 0 );
-        i = win_k; 
+        i = win_k;
         xis.resize( 1, win_xk );
     } else if( ChooseMethod() == Properties::ChooseMethodType::CHOOSE_BBP ) {
         xis.resize( 1, win_xk );
     } else if( ChooseMethod() == Properties::ChooseMethodType::CHOOSE_BBP ) {
-        Real mvo; 
-        if( !maxVarOut ) 
+        Real mvo;
+        if( !maxVarOut )
             maxVarOut = &mvo;
         bool clampingVar = (Clamping() == Properties::ClampType::CLAMP_VAR);
         pair<size_t, size_t> cv = bbpFindClampVar( *bp, clampingVar, props.bbp_props, BBP_cost_function(), &mvo );
             maxVarOut = &mvo;
         bool clampingVar = (Clamping() == Properties::ClampType::CLAMP_VAR);
         pair<size_t, size_t> cv = bbpFindClampVar( *bp, clampingVar, props.bbp_props, BBP_cost_function(), &mvo );
@@ -387,7 +387,7 @@ bool CBP::chooseNextClampVar( InfAlg *bp, vector<size_t> &clamped_vars_list, siz
             << i << " state " << xi                                     \
             << " (p=" << (clampingVar?bp->beliefV(i)[xi]:bp->beliefF(i)[xi]) \
             << ", entropy = " << (clampingVar?bp->beliefV(i):bp->beliefF(i)).entropy() \
             << i << " state " << xi                                     \
             << " (p=" << (clampingVar?bp->beliefV(i)[xi]:bp->beliefF(i)[xi]) \
             << ", entropy = " << (clampingVar?bp->beliefV(i):bp->beliefF(i)).entropy() \
-            << ", maxVar = "<< mvo << ")" 
+            << ", 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;
         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;
@@ -429,7 +429,7 @@ pair<size_t, size_t> bbpFindClampVar( const InfAlg &in_bp, bool clampingVar, con
     BBP bbp( &in_bp, bbp_props );
     initBBPCostFnAdj( bbp, in_bp, cfn, NULL );
     bbp.run();
     BBP bbp( &in_bp, bbp_props );
     initBBPCostFnAdj( bbp, in_bp, 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;
     // find and return the (variable,state) with the largest adj_psi_V
     size_t argmax_var = 0;
     size_t argmax_var_state = 0;
@@ -479,7 +479,7 @@ pair<size_t, size_t> bbpFindClampVar( const InfAlg &in_bp, bool clampingVar, con
         assert(/*0 <= argmax_var_state &&*/
                argmax_var_state < in_bp.fg().factor(argmax_var).states() );
     }
         assert(/*0 <= argmax_var_state &&*/
                argmax_var_state < in_bp.fg().factor(argmax_var).states() );
     }
-    if( maxVarOut ) 
+    if( maxVarOut )
         *maxVarOut = max_var;
     return make_pair( argmax_var, argmax_var_state );
 }
         *maxVarOut = max_var;
     return make_pair( argmax_var, argmax_var_state );
 }
@@ -526,8 +526,8 @@ Real dist( const vector<Factor> &b1, const vector<Factor> &b2, size_t nv ) {
 } // end of namespace dai
 
 
 } // end of namespace dai
 
 
-/* {{{ GENERATED CODE: DO NOT EDIT. Created by 
-    ./scripts/regenerate-properties include/dai/cbp.h src/cbp.cpp 
+/* {{{ GENERATED CODE: DO NOT EDIT. Created by
+    ./scripts/regenerate-properties include/dai/cbp.h src/cbp.cpp
 */
 namespace dai {
 
 */
 namespace dai {
 
index 6446fe4..c7fad49 100644 (file)
@@ -67,7 +67,7 @@ ClusterGraph ClusterGraph::VarElim_MinFill() const {
     set<size_t> varindices;
     for( size_t i = 0; i < vars.size(); ++i )
         varindices.insert( i );
     set<size_t> varindices;
     for( size_t i = 0; i < vars.size(); ++i )
         varindices.insert( i );
-    
+
     // Do variable elimination
     while( !varindices.empty() ) {
         set<size_t>::const_iterator lowest = varindices.end();
     // Do variable elimination
     while( !varindices.empty() ) {
         set<size_t>::const_iterator lowest = varindices.end();
@@ -100,7 +100,7 @@ ClusterGraph ClusterGraph::VarElim( const std::vector<Var> & ElimSeq ) const {
     cl.eraseNonMaximal();
 
     ClusterGraph result;
     cl.eraseNonMaximal();
 
     ClusterGraph result;
-    
+
     // Do variable elimination
     for( vector<Var>::const_iterator n = ElimSeq.begin(); n != ElimSeq.end(); n++ ) {
         size_t i = cl.findVar( *n );
     // Do variable elimination
     for( vector<Var>::const_iterator n = ElimSeq.begin(); n != ElimSeq.end(); n++ ) {
         size_t i = cl.findVar( *n );
index 47f61eb..efb1588 100644 (file)
@@ -35,7 +35,7 @@ using namespace std;
  */
 Factor calcMarginal( const InfAlg &obj, const VarSet &ns, bool reInit ) {
     Factor Pns (ns);
  */
 Factor calcMarginal( const InfAlg &obj, const VarSet &ns, bool reInit ) {
     Factor Pns (ns);
-    
+
     InfAlg *clamped = obj.clone();
     if( !reInit )
         clamped->init();
     InfAlg *clamped = obj.clone();
     if( !reInit )
         clamped->init();
@@ -52,7 +52,7 @@ Factor calcMarginal( const InfAlg &obj, const VarSet &ns, bool reInit ) {
         // set clamping Factors to delta functions
         for( VarSet::const_iterator n = ns.begin(); n != ns.end(); n++ )
             clamped->clamp( varindices[*n], s(*n) );
         // set clamping Factors to delta functions
         for( VarSet::const_iterator n = ns.begin(); n != ns.end(); n++ )
             clamped->clamp( varindices[*n], s(*n) );
-        
+
         // run DAIAlg, calc logZ, store in Pns
         if( reInit )
             clamped->init();
         // run DAIAlg, calc logZ, store in Pns
         if( reInit )
             clamped->init();
@@ -78,7 +78,7 @@ Factor calcMarginal( const InfAlg &obj, const VarSet &ns, bool reInit ) {
             Pns[s] = 0;
         else
             Pns[s] = exp(logZ - logZ0); // subtract logZ0 to avoid very large numbers
             Pns[s] = 0;
         else
             Pns[s] = exp(logZ - logZ0); // subtract logZ0 to avoid very large numbers
-        
+
         // restore clamped factors
         clamped->restoreFactors( ns );
     }
         // restore clamped factors
         clamped->restoreFactors( ns );
     }
@@ -147,10 +147,10 @@ vector<Factor> calcPairBeliefs( const InfAlg & obj, const VarSet& ns, bool reIni
             else
                 Z_xj = exp(logZ - logZ0); // subtract logZ0 to avoid very large numbers
 
             else
                 Z_xj = exp(logZ - logZ0); // subtract logZ0 to avoid very large numbers
 
-            for( size_t k = 0; k < N; k++ ) 
+            for( size_t k = 0; k < N; k++ )
                 if( k != j ) {
                     Factor b_k = clamped->belief(vns[k]);
                 if( k != j ) {
                     Factor b_k = clamped->belief(vns[k]);
-                    for( size_t k_val = 0; k_val < vns[k].states(); k_val++ ) 
+                    for( size_t k_val = 0; k_val < vns[k].states(); k_val++ )
                         if( vns[j].label() < vns[k].label() )
                             pairbeliefs[j * N + k][j_val + (k_val * vns[j].states())] = Z_xj * b_k[k_val];
                         else
                         if( vns[j].label() < vns[k].label() )
                             pairbeliefs[j * N + k][j_val + (k_val * vns[j].states())] = Z_xj * b_k[k_val];
                         else
@@ -161,7 +161,7 @@ vector<Factor> calcPairBeliefs( const InfAlg & obj, const VarSet& ns, bool reIni
             clamped->restoreFactors( ns );
         }
     }
             clamped->restoreFactors( ns );
         }
     }
-    
+
     delete clamped;
 
     // Calculate result by taking the geometric average
     delete clamped;
 
     // Calculate result by taking the geometric average
@@ -180,7 +180,7 @@ vector<Factor> calcPairBeliefs( const InfAlg & obj, const VarSet& ns, bool reIni
  */
 Factor calcMarginal2ndO( const InfAlg & obj, const VarSet& ns, bool reInit ) {
     // returns a a probability distribution whose 1st order interactions
  */
 Factor calcMarginal2ndO( const InfAlg & obj, const VarSet& ns, bool reInit ) {
     // returns a a probability distribution whose 1st order interactions
-    // are unspecified, whose 2nd order interactions approximate those of 
+    // are unspecified, whose 2nd order interactions approximate those of
     // the marginal on ns, and whose higher order interactions are absent.
 
     vector<Factor> pairbeliefs = calcPairBeliefs( obj, ns, reInit );
     // the marginal on ns, and whose higher order interactions are absent.
 
     vector<Factor> pairbeliefs = calcPairBeliefs( obj, ns, reInit );
@@ -188,7 +188,7 @@ Factor calcMarginal2ndO( const InfAlg & obj, const VarSet& ns, bool reInit ) {
     Factor Pns (ns);
     for( size_t ij = 0; ij < pairbeliefs.size(); ij++ )
         Pns *= pairbeliefs[ij];
     Factor Pns (ns);
     for( size_t ij = 0; ij < pairbeliefs.size(); ij++ )
         Pns *= pairbeliefs[ij];
-    
+
     return( Pns.normalized() );
 }
 
     return( Pns.normalized() );
 }
 
@@ -214,7 +214,7 @@ vector<Factor> calcPairBeliefsNew( const InfAlg & obj, const VarSet& ns, bool re
             Factor pairbelief( VarSet(*nj, *nk) );
 
             // clamp Vars j and k to their possible values
             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 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 ns
                     clamped->backupFactors( ns );
                 for( size_t k_val = 0; k_val < nk->states(); k_val++ ) {
                     // save unclamped factors connected to ns
                     clamped->backupFactors( ns );
@@ -254,11 +254,11 @@ vector<Factor> calcPairBeliefsNew( const InfAlg & obj, const VarSet& ns, bool re
                     // restore clamped factors
                     clamped->restoreFactors( ns );
                 }
                     // restore clamped factors
                     clamped->restoreFactors( ns );
                 }
-        
+
             result.push_back( pairbelief.normalized() );
         }
     }
             result.push_back( pairbelief.normalized() );
         }
     }
-    
+
     delete clamped;
 
     assert( result.size() == (ns.size() * (ns.size() - 1) / 2) );
     delete clamped;
 
     assert( result.size() == (ns.size() * (ns.size() - 1) / 2) );
index 811ca6e..5acc9cf 100644 (file)
@@ -56,8 +56,8 @@ ParameterEstimation* CondProbEstimation::factory( const PropertySet &p ) {
 }
 
 
 }
 
 
-CondProbEstimation::CondProbEstimation( size_t target_dimension, const Prob &pseudocounts ) 
-  : _target_dim(target_dimension), _stats(pseudocounts), _initial_stats(pseudocounts) 
+CondProbEstimation::CondProbEstimation( size_t target_dimension, const Prob &pseudocounts )
+  : _target_dim(target_dimension), _stats(pseudocounts), _initial_stats(pseudocounts)
 {
     assert( !(_stats.size() % _target_dim) );
 }
 {
     assert( !(_stats.size() % _target_dim) );
 }
@@ -100,13 +100,13 @@ Permute SharedParameters::calculatePermutation( const std::vector<Var> &varorder
         labels.push_back( varorder[i].label() );
         outVS |= varorder[i];
     }
         labels.push_back( varorder[i].label() );
         outVS |= varorder[i];
     }
-  
+
     // Construct the sigma array for the permutation object
     std::vector<size_t> sigma;
     sigma.reserve( dims.size() );
     for( VarSet::iterator set_iterator = outVS.begin(); sigma.size() < dims.size(); ++set_iterator )
         sigma.push_back( find(labels.begin(), labels.end(), set_iterator->label()) - labels.begin() );
     // Construct the sigma array for the permutation object
     std::vector<size_t> sigma;
     sigma.reserve( dims.size() );
     for( VarSet::iterator set_iterator = outVS.begin(); sigma.size() < dims.size(); ++set_iterator )
         sigma.push_back( find(labels.begin(), labels.end(), set_iterator->label()) - labels.begin() );
-  
+
     return Permute( dims, sigma );
 }
 
     return Permute( dims, sigma );
 }
 
@@ -127,7 +127,7 @@ void SharedParameters::setPermsAndVarSetsFromVarOrders() {
 
 
 SharedParameters::SharedParameters( std::istream &is, const FactorGraph &fg_varlookup )
 
 
 SharedParameters::SharedParameters( std::istream &is, const FactorGraph &fg_varlookup )
-  : _varsets(), _perms(), _varorders(), _estimation(NULL), _deleteEstimation(true) 
+  : _varsets(), _perms(), _varorders(), _estimation(NULL), _deleteEstimation(true)
 {
     // Read the desired parameter estimation method from the stream
     std::string est_method;
 {
     // Read the desired parameter estimation method from the stream
     std::string est_method;
@@ -170,7 +170,7 @@ SharedParameters::SharedParameters( std::istream &is, const FactorGraph &fg_varl
             labelparse >> label;
             VarSet::const_iterator vsi = vs.begin();
             for( ; vsi != vs.end(); ++vsi )
             labelparse >> label;
             VarSet::const_iterator vsi = vs.begin();
             for( ; vsi != vs.end(); ++vsi )
-                if( vsi->label() == label ) 
+                if( vsi->label() == label )
                     break;
             if( vsi == vs.end() )
                 DAI_THROW(INVALID_EMALG_FILE);
                     break;
             if( vsi == vs.end() )
                 DAI_THROW(INVALID_EMALG_FILE);
@@ -184,7 +184,7 @@ SharedParameters::SharedParameters( std::istream &is, const FactorGraph &fg_varl
 }
 
 
 }
 
 
-SharedParameters::SharedParameters( const SharedParameters &sp ) 
+SharedParameters::SharedParameters( const SharedParameters &sp )
   : _varsets(sp._varsets), _perms(sp._perms), _varorders(sp._varorders), _estimation(sp._estimation), _deleteEstimation(sp._deleteEstimation)
 {
     // If sp owns its _estimation object, we should clone it instead
   : _varsets(sp._varsets), _perms(sp._perms), _varorders(sp._varorders), _estimation(sp._estimation), _deleteEstimation(sp._deleteEstimation)
 {
     // If sp owns its _estimation object, we should clone it instead
@@ -205,7 +205,7 @@ void SharedParameters::collectSufficientStatistics( InfAlg &alg ) {
     for( std::map< FactorIndex, Permute >::iterator i = _perms.begin(); i != _perms.end(); ++i ) {
         Permute &perm = i->second;
         VarSet &vs = _varsets[i->first];
     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.states(), 0.0 );
         for( size_t entry = 0; entry < b.states(); ++entry )
         Factor b = alg.belief(vs);
         Prob p( b.states(), 0.0 );
         for( size_t entry = 0; entry < b.states(); ++entry )
@@ -220,7 +220,7 @@ void SharedParameters::setParameters( FactorGraph &fg ) {
     for( std::map<FactorIndex, Permute>::iterator i = _perms.begin(); i != _perms.end(); ++i ) {
         Permute &perm = i->second;
         VarSet &vs = _varsets[i->first];
     for( std::map<FactorIndex, Permute>::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.states(); ++entry )
             f[perm.convert_linear_index(entry)] = p[entry];
         Factor f( vs, 0.0 );
         for( size_t entry = 0; entry < f.states(); ++entry )
             f[perm.convert_linear_index(entry)] = p[entry];
@@ -282,7 +282,7 @@ EMAlg::EMAlg( const Evidence &evidence, InfAlg &estep, std::istream &msteps_file
     _msteps.reserve(num_msteps);
     for( size_t i = 0; i < num_msteps; ++i )
         _msteps.push_back( MaximizationStep( msteps_file, estep.fg() ) );
     _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 ) {
 
 
 void EMAlg::setTermConditions( const PropertySet &p ) {
index 69fe9ae..075ee38 100644 (file)
@@ -39,7 +39,7 @@ void Observation::applyEvidence( InfAlg &alg ) const {
     for( std::map<Var, size_t>::const_iterator i = _obs.begin(); i != _obs.end(); ++i )
         alg.clamp( alg.fg().findVar(i->first), i->second );
 }
     for( std::map<Var, size_t>::const_iterator i = _obs.begin(); i != _obs.end(); ++i )
         alg.clamp( alg.fg().findVar(i->first), i->second );
 }
-  
+
 
 void Evidence::addEvidenceTabFile( std::istream &is, FactorGraph &fg ) {
     std::map<std::string, Var> varMap;
 
 void Evidence::addEvidenceTabFile( std::istream &is, FactorGraph &fg ) {
     std::map<std::string, Var> varMap;
@@ -56,12 +56,12 @@ void Evidence::addEvidenceTabFile( std::istream &is, FactorGraph &fg ) {
 void Evidence::addEvidenceTabFile( std::istream &is, std::map<std::string, Var> &varMap ) {
     std::string line;
     getline( is, line );
 void Evidence::addEvidenceTabFile( std::istream &is, std::map<std::string, Var> &varMap ) {
     std::string line;
     getline( is, line );
-    
+
     // Parse header
     std::vector<std::string> header_fields;
     tokenizeString( line, header_fields );
     std::vector<std::string>::const_iterator p_field = header_fields.begin();
     // Parse header
     std::vector<std::string> header_fields;
     tokenizeString( line, header_fields );
     std::vector<std::string>::const_iterator p_field = header_fields.begin();
-    if( p_field == header_fields.end() ) 
+    if( p_field == header_fields.end() )
         DAI_THROW(INVALID_EVIDENCE_FILE);
 
     std::vector<Var> vars;
         DAI_THROW(INVALID_EVIDENCE_FILE);
 
     std::vector<Var> vars;
@@ -71,14 +71,14 @@ void Evidence::addEvidenceTabFile( std::istream &is, std::map<std::string, Var>
             DAI_THROW(INVALID_EVIDENCE_FILE);
         vars.push_back( elem->second );
     }
             DAI_THROW(INVALID_EVIDENCE_FILE);
         vars.push_back( elem->second );
     }
-    
+
     // Read samples
     while( getline(is, line) ) {
         std::vector<std::string> fields;
         tokenizeString( line, fields );
     // Read samples
     while( getline(is, line) ) {
         std::vector<std::string> fields;
         tokenizeString( line, fields );
-        if( fields.size() != vars.size() ) 
+        if( fields.size() != vars.size() )
             DAI_THROW(INVALID_EVIDENCE_FILE);
             DAI_THROW(INVALID_EVIDENCE_FILE);
-        
+
         Observation sampleData;
         for( size_t i = 0; i < vars.size(); ++i ) {
             if( fields[i].size() > 0 ) { // skip if missing observation
         Observation sampleData;
         for( size_t i = 0; i < vars.size(); ++i ) {
             if( fields[i].size() > 0 ) { // skip if missing observation
index b4b970a..9ae4834 100644 (file)
@@ -35,7 +35,7 @@ const char *ExactInf::Name = "EXACT";
 
 void ExactInf::setProperties( const PropertySet &opts ) {
     assert( opts.hasKey("verbose") );
 
 void ExactInf::setProperties( const PropertySet &opts ) {
     assert( opts.hasKey("verbose") );
-    
+
     props.verbose = opts.getStringAs<size_t>("verbose");
 }
 
     props.verbose = opts.getStringAs<size_t>("verbose");
 }
 
@@ -123,7 +123,7 @@ Factor ExactInf::belief( const VarSet &ns ) const {
 }
 
 
 }
 
 
-string ExactInf::identify() const { 
+string ExactInf::identify() const {
     return string(Name) + printProperties();
 }
 
     return string(Name) + printProperties();
 }
 
index b39353e..55bc7d1 100644 (file)
@@ -46,7 +46,7 @@ namespace dai {
         "Invalid Expectation-Maximization file",
         "Unrecognized parameter estimation method",
         "Requested object not found"
         "Invalid Expectation-Maximization file",
         "Unrecognized parameter estimation method",
         "Requested object not found"
-    }; 
+    };
 
 
 }
 
 
 }
index b41e577..8813e6d 100644 (file)
@@ -65,10 +65,10 @@ FactorGraph::FactorGraph( const std::vector<Factor> &P ) : G(), _backup() {
 void FactorGraph::constructGraph( size_t nrEdges ) {
     // create a mapping for indices
     hash_map<size_t, size_t> hashmap;
 void FactorGraph::constructGraph( size_t nrEdges ) {
     // create a mapping for indices
     hash_map<size_t, size_t> hashmap;
-    
+
     for( size_t i = 0; i < vars().size(); i++ )
         hashmap[var(i).label()] = i;
     for( size_t i = 0; i < vars().size(); i++ )
         hashmap[var(i).label()] = i;
-    
+
     // create edge list
     vector<Edge> edges;
     edges.reserve( nrEdges );
     // create edge list
     vector<Edge> edges;
     edges.reserve( nrEdges );
@@ -117,7 +117,7 @@ std::istream& operator>> ( std::istream& is, FactorGraph &fg ) {
     vector<Factor> facs;
     size_t nr_Factors;
     string line;
     vector<Factor> facs;
     size_t nr_Factors;
     string line;
-    
+
     while( (is.peek()) == '#' )
         getline(is,line);
     is >> nr_Factors;
     while( (is.peek()) == '#' )
         getline(is,line);
     is >> nr_Factors;
@@ -176,7 +176,7 @@ std::istream& operator>> ( std::istream& is, FactorGraph &fg ) {
             I_vars |= Var(labels[mi], dims[mi]);
         }
         facs.push_back( Factor( I_vars, 0.0 ) );
             I_vars |= Var(labels[mi], dims[mi]);
         }
         facs.push_back( Factor( I_vars, 0.0 ) );
-        
+
         // calculate permutation sigma (internally, members are sorted)
         vector<size_t> sigma(nr_members,0);
         VarSet::iterator j = I_vars.begin();
         // calculate permutation sigma (internally, members are sorted)
         vector<size_t> sigma(nr_members,0);
         VarSet::iterator j = I_vars.begin();
@@ -190,13 +190,13 @@ std::istream& operator>> ( std::istream& is, FactorGraph &fg ) {
 
         // calculate multindices
         Permute permindex( dims, sigma );
 
         // calculate multindices
         Permute permindex( dims, sigma );
-        
+
         // read values
         size_t nr_nonzeros;
         while( (is.peek()) == '#' )
             getline(is,line);
         is >> nr_nonzeros;
         // read values
         size_t nr_nonzeros;
         while( (is.peek()) == '#' )
             getline(is,line);
         is >> nr_nonzeros;
-        if( verbose >= 3 ) 
+        if( verbose >= 3 )
             cerr << "  nonzeroes: " << nr_nonzeros << endl;
         for( size_t k = 0; k < nr_nonzeros; k++ ) {
             size_t li;
             cerr << "  nonzeroes: " << nr_nonzeros << endl;
         for( size_t k = 0; k < nr_nonzeros; k++ ) {
             size_t li;
@@ -241,7 +241,7 @@ VarSet FactorGraph::Delta( unsigned i ) const {
 
 VarSet FactorGraph::Delta( const VarSet &ns ) const {
     VarSet result;
 
 VarSet FactorGraph::Delta( const VarSet &ns ) const {
     VarSet result;
-    for( VarSet::const_iterator n = ns.begin(); n != ns.end(); n++ ) 
+    for( VarSet::const_iterator n = ns.begin(); n != ns.end(); n++ )
         result |= Delta(findVar(*n));
     return result;
 }
         result |= Delta(findVar(*n));
     return result;
 }
@@ -296,13 +296,13 @@ void FactorGraph::printDot( std::ostream &os ) const {
 
 vector<VarSet> FactorGraph::Cliques() const {
     vector<VarSet> result;
 
 vector<VarSet> FactorGraph::Cliques() const {
     vector<VarSet> result;
-    
+
     for( size_t I = 0; I < nrFactors(); I++ ) {
         bool maximal = true;
         for( size_t J = 0; (J < nrFactors()) && maximal; J++ )
             if( (factor(J).vars() >> factor(I).vars()) && (factor(J).vars() != factor(I).vars()) )
                 maximal = false;
     for( size_t I = 0; I < nrFactors(); I++ ) {
         bool maximal = true;
         for( size_t J = 0; (J < nrFactors()) && maximal; J++ )
             if( (factor(J).vars() >> factor(I).vars()) && (factor(J).vars() != factor(I).vars()) )
                 maximal = false;
-        
+
         if( maximal )
             result.push_back( factor(I).vars() );
     }
         if( maximal )
             result.push_back( factor(I).vars() );
     }
@@ -317,7 +317,7 @@ void FactorGraph::clamp( size_t i, size_t x, bool backup ) {
     mask[x] = 1.0;
 
     map<size_t, Factor> newFacs;
     mask[x] = 1.0;
 
     map<size_t, Factor> newFacs;
-       foreach( const BipartiteGraph::Neighbor &I, nbV(i) )
+    foreach( const BipartiteGraph::Neighbor &I, nbV(i) )
         newFacs[I] = factor(I) * mask;
     setFactors( newFacs, backup );
 
         newFacs[I] = factor(I) * mask;
     setFactors( newFacs, backup );
 
@@ -335,7 +335,7 @@ void FactorGraph::clampVar( size_t i, const vector<size_t> &is, bool backup ) {
     }
 
     map<size_t, Factor> newFacs;
     }
 
     map<size_t, Factor> newFacs;
-       foreach( const BipartiteGraph::Neighbor &I, nbV(i) )
+    foreach( const BipartiteGraph::Neighbor &I, nbV(i) )
         newFacs[I] = factor(I) * mask_n;
     setFactors( newFacs, backup );
 }
         newFacs[I] = factor(I) * mask_n;
     setFactors( newFacs, backup );
 }
@@ -345,8 +345,8 @@ void FactorGraph::clampFactor( size_t I, const vector<size_t> &is, bool backup )
     size_t st = factor(I).states();
     Factor newF( factor(I).vars(), 0.0 );
 
     size_t st = factor(I).states();
     Factor newF( factor(I).vars(), 0.0 );
 
-    foreach( size_t i, is ) { 
-        assert( i <= st ); 
+    foreach( size_t i, is ) {
+        assert( i <= st );
         newF[i] = factor(I)[i];
     }
 
         newF[i] = factor(I)[i];
     }
 
index 3bb07fd..9b79c72 100644 (file)
@@ -71,7 +71,7 @@