Improved coding style of recent changes by Charlie Vaske
[libdai.git] / src / emalg.cpp
index e0fcab3..811ca6e 100644 (file)
@@ -40,7 +40,7 @@ ParameterEstimation* ParameterEstimation::construct( const std::string &method,
         loadDefaultRegistry();
     std::map<std::string, ParamEstFactory>::iterator i = _registry->find(method);
     if( i == _registry->end() )
-        DAI_THROW(UNKNOWN_PARAMETER_ESTIMATION_METHOD);
+        DAI_THROWE(UNKNOWN_PARAMETER_ESTIMATION_METHOD, "Unknown parameter estimation method: " + method);
     ParamEstFactory factory = i->second;
     return factory(p);
 }
@@ -59,8 +59,7 @@ ParameterEstimation* CondProbEstimation::factory( const PropertySet &p ) {
 CondProbEstimation::CondProbEstimation( size_t target_dimension, const Prob &pseudocounts ) 
   : _target_dim(target_dimension), _stats(pseudocounts), _initial_stats(pseudocounts) 
 {
-    if( _stats.size() % _target_dim )
-        DAI_THROW(MALFORMED_PROPERTY);
+    assert( !(_stats.size() % _target_dim) );
 }
 
 
@@ -115,16 +114,14 @@ Permute SharedParameters::calculatePermutation( const std::vector<Var> &varorder
 void SharedParameters::setPermsAndVarSetsFromVarOrders() {
     if( _varorders.size() == 0 )
         return;
-    if( _estimation == NULL )
-        DAI_THROW(INVALID_SHARED_PARAMETERS_ORDER);
+    assert( _estimation != NULL );
 
     // Construct the permutation objects and the varsets
     for( FactorOrientations::const_iterator foi = _varorders.begin(); foi != _varorders.end(); ++foi ) {
         VarSet vs;
         _perms[foi->first] = calculatePermutation( foi->second, vs );
         _varsets[foi->first] = vs;
-        if( _estimation->probSize() != vs.nrStates() )
-            DAI_THROW(INVALID_SHARED_PARAMETERS_ORDER);
+        assert( _estimation->probSize() == vs.nrStates() );
     }
 }
 
@@ -154,14 +151,14 @@ SharedParameters::SharedParameters( std::istream &is, const FactorGraph &fg_varl
 
         // Lookup the factor in the factorgraph
         if( fields.size() < 1 )
-            DAI_THROW(INVALID_SHARED_PARAMETERS_INPUT_LINE);
+            DAI_THROW(INVALID_EMALG_FILE);
         std::istringstream iss;
         iss.str( fields[0] );
         size_t factor;
         iss >> factor;
         const VarSet &vs = fg_varlookup.factor(factor).vars();
         if( fields.size() != vs.size() + 1 )
-            DAI_THROW(INVALID_SHARED_PARAMETERS_INPUT_LINE);
+            DAI_THROW(INVALID_EMALG_FILE);
 
         // Construct the vector of Vars
         std::vector<Var> var_order;
@@ -176,7 +173,7 @@ SharedParameters::SharedParameters( std::istream &is, const FactorGraph &fg_varl
                 if( vsi->label() == label ) 
                     break;
             if( vsi == vs.end() )
-                DAI_THROW(INVALID_SHARED_PARAMETERS_INPUT_LINE);
+                DAI_THROW(INVALID_EMALG_FILE);
             var_order.push_back( *vsi );
         }
         _varorders[factor] = var_order;
@@ -196,8 +193,8 @@ SharedParameters::SharedParameters( const SharedParameters &sp )
 }
 
 
-SharedParameters::SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool deleteParameterEstimationInDestructor )
-  : _varsets(), _perms(), _varorders(varorders), _estimation(estimation), _deleteEstimation(deleteParameterEstimationInDestructor) 
+SharedParameters::SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool deletePE )
+  : _varsets(), _perms(), _varorders(varorders), _estimation(estimation), _deleteEstimation(deletePE)
 {
     // Calculate the necessary permutations
     setPermsAndVarSetsFromVarOrders();
@@ -233,23 +230,19 @@ void SharedParameters::setParameters( FactorGraph &fg ) {
 }
 
 
-void SharedParameters::collectParameters( const FactorGraph& fg, std::vector< Real >& outVals, std::vector< Var >& outVarOrder ) {
+void SharedParameters::collectParameters( const FactorGraph &fg, std::vector<Real> &outVals, std::vector<Var> &outVarOrder ) {
     FactorOrientations::iterator it = _varorders.begin();
-    if (it == _varorders.end()) {
-       return;
-    }
-    FactorIndex i = it->first;
-    std::vector< Var >::iterator var_it = _varorders[i].begin();
-    std::vector< Var >::iterator var_stop = _varorders[i].end();
-    for ( ; var_it != var_stop; ++var_it) {
-       outVarOrder.push_back(*var_it);
-    }
-    const Factor& f = fg.factor(i);
-    assert(f.vars() == _varsets[i]);
-    const Permute& perm = _perms[i];
-    for (size_t val_index = 0; val_index < f.states(); ++val_index) {
-       outVals.push_back(f[perm.convert_linear_index(val_index)]);
-    }
+    if( it == _varorders.end() )
+        return;
+    FactorIndex I = it->first;
+    for( std::vector<Var>::const_iterator var_it = _varorders[I].begin(); var_it != _varorders[I].end(); ++var_it )
+        outVarOrder.push_back( *var_it );
+
+    const Factor &f = fg.factor(I);
+    assert( f.vars() == _varsets[I] );
+    const Permute &perm = _perms[I];
+    for( size_t val_index = 0; val_index < f.states(); ++val_index )
+        outVals.push_back( f[perm.convert_linear_index(val_index)] );
 }
 
 
@@ -289,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() ) );
-}      
+}    
 
 
 void EMAlg::setTermConditions( const PropertySet &p ) {
@@ -325,29 +318,29 @@ bool EMAlg::hasSatisfiedTermConditions() const {
 
 Real EMAlg::iterate( MaximizationStep &mstep ) {
     Real logZ = 0;
-       Real likelihood = 0;
-       
-       _estep.run();
-       logZ = _estep.logZ();
-       
+    Real likelihood = 0;
+
+    _estep.run();
+    logZ = _estep.logZ();
+
     // Expectation calculation
     for( Evidence::const_iterator e = _evidence.begin(); e != _evidence.end(); ++e ) {
         InfAlg* clamped = _estep.clone();
         e->applyEvidence( *clamped );
         clamped->init();
         clamped->run();
-               
-               likelihood += clamped->logZ() - logZ;
-               
+
+        likelihood += clamped->logZ() - logZ;
+
         mstep.addExpectations( *clamped );
-               
+
         delete clamped;
     }
-    
+
     // Maximization of parameters
     mstep.maximize( _estep.fg() );
-       
-       return likelihood;
+
+    return likelihood;
 }