Improved coding style of recent changes by Charlie Vaske
authorJoris Mooij <joris.mooij@tuebingen.mpg.de>
Tue, 8 Sep 2009 08:39:22 +0000 (10:39 +0200)
committerJoris Mooij <joris.mooij@tuebingen.mpg.de>
Tue, 8 Sep 2009 08:39:22 +0000 (10:39 +0200)
include/dai/emalg.h
include/dai/evidence.h
include/dai/factor.h
include/dai/index.h
include/dai/properties.h
src/bp.cpp
src/emalg.cpp

index 622a25b..4146717 100644 (file)
@@ -179,8 +179,9 @@ class SharedParameters {
         /// Constructor 
         /** \param varorders  all the factor orientations for this parameter
          *  \param estimation a pointer to the parameter estimation method
         /// 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
          */ 
          */ 
-        SharedParameters( const FactorOrientations &varorders, ParameterEstimation *estimation, bool deleteParameterEstimationInDestructor=0);
+        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 );
 
         /// Constructor for making an object from a stream and a factor graph
         SharedParameters( std::istream &is, const FactorGraph &fg_varlookup );
@@ -197,7 +198,8 @@ class SharedParameters {
         /// Estimate and set the shared parameters
         void setParameters( FactorGraph &fg );
 
         /// Estimate and set the shared parameters
         void setParameters( FactorGraph &fg );
 
-       void collectParameters( const FactorGraph& fg, std::vector< Real >& outVals, std::vector< Var >& outVarOrder );
+        /// Returns the parameters
+        void collectParameters( const FactorGraph &fg, std::vector<Real> &outVals, std::vector<Var> &outVarOrder );
 };
 
 
 };
 
 
@@ -222,15 +224,15 @@ class MaximizationStep {
         /// Using all of the currently added expectations, make new factors with maximized parameters and set them in the FactorGraph.
         void maximize( FactorGraph &fg );
 
         /// Using all of the currently added expectations, make new factors with maximized parameters and set them in the FactorGraph.
         void maximize( FactorGraph &fg );
 
-       /// @name iterator interface
-       //@{
-       typedef std::vector< SharedParameters >::iterator iterator;
-       typedef std::vector< SharedParameters >::const_iterator const_iterator;
-       iterator begin() { return _params.begin(); }
-       const_iterator begin() const { return _params.begin(); }
-       iterator end() { return _params.end(); }
-       const_iterator end() const { return _params.end(); }
-       //@}
+        /// @name Iterator interface
+        //@{
+        typedef std::vector<SharedParameters>::iterator iterator;
+        typedef std::vector<SharedParameters>::const_iterator const_iterator;
+        iterator begin() { return _params.begin(); }
+        const_iterator begin() const { return _params.begin(); }
+        iterator end() { return _params.end(); }
+        const_iterator end() const { return _params.end(); }
+        //@}
 };
 
 
 };
 
 
@@ -310,14 +312,14 @@ class EMAlg {
          */
         bool hasSatisfiedTermConditions() const;
 
          */
         bool hasSatisfiedTermConditions() const;
 
-       /// Return the last calculated log likelihood
-       Real getLogZ() const { return _lastLogZ.back(); }
+        /// Return the last calculated log likelihood
+        Real getLogZ() const { return _lastLogZ.back(); }
 
         /// Returns number of iterations done so far
         size_t getCurrentIters() const { return _iters; }
 
 
         /// Returns number of iterations done so far
         size_t getCurrentIters() const { return _iters; }
 
-       /// Get the iteration method used
-       const InfAlg& eStep() const { return _estep; }
+        /// Get the iteration method used
+        const InfAlg& eStep() const { return _estep; }
 
         /// Perform an iteration over all maximization steps
         Real iterate();
 
         /// Perform an iteration over all maximization steps
         Real iterate();
@@ -328,15 +330,15 @@ class EMAlg {
         /// Iterate until termination conditions are satisfied
         void run();
 
         /// Iterate until termination conditions are satisfied
         void run();
 
-       /// @name iterator interface
-       //@{ !!!
-       typedef std::vector< MaximizationStep >::iterator s_iterator;
-       typedef std::vector< MaximizationStep >::const_iterator const_s_iterator;
-       s_iterator s_begin() { return _msteps.begin(); }
-       const_s_iterator s_begin() const { return _msteps.begin(); }
-       s_iterator s_end() { return _msteps.end(); }
-       const_s_iterator s_end() const { return _msteps.end(); }
-       //@}
+        /// @name Iterator interface
+        //@{
+        typedef std::vector<MaximizationStep>::iterator s_iterator;
+        typedef std::vector<MaximizationStep>::const_iterator const_s_iterator;
+        s_iterator s_begin() { return _msteps.begin(); }
+        const_s_iterator s_begin() const { return _msteps.begin(); }
+        s_iterator s_end() { return _msteps.end(); }
+        const_s_iterator s_end() const { return _msteps.end(); }
+        //@}
 };
 
 
 };
 
 
index 1738732..eeb620d 100644 (file)
@@ -69,14 +69,13 @@ class Evidence {
         /// Default constructor
         Evidence() : _samples() {}
       
         /// Default constructor
         Evidence() : _samples() {}
       
-        /// Constructor with 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 
index 6b04966..0889bb5 100644 (file)
@@ -46,7 +46,7 @@ namespace dai {
 // Function object similar to std::divides(), but different in that dividing by zero results in zero
 template<typename T> struct divides0 : public std::binary_function<T, T, T> {
     // Returns (j == 0 ? 0 : (i/j))
 // Function object similar to std::divides(), but different in that dividing by zero results in zero
 template<typename T> struct divides0 : public std::binary_function<T, T, T> {
     // Returns (j == 0 ? 0 : (i/j))
-    T operator()(const T& i, const T& j) const {
+    T operator()( const T &i, const T &j ) const {
         if( j == (T)0 )
             return (T)0;
         else
         if( j == (T)0 )
             return (T)0;
         else
@@ -95,41 +95,42 @@ template <typename T> class TFactor {
         /// Constructs TFactor depending on no variables, with value p
         TFactor ( Real p = 1.0 ) : _vs(), _p(1,p) {}
 
         /// Constructs TFactor depending on no variables, with value p
         TFactor ( Real p = 1.0 ) : _vs(), _p(1,p) {}
 
-        /// Constructs TFactor depending on variables in ns, with uniform distribution
-        TFactor( const VarSet& ns ) : _vs(ns), _p(_vs.nrStates()) {}
+        /// 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 ns, with all values set to p
-        TFactor( const VarSet& ns, Real p ) : _vs(ns), _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 ns, copying the values from the range starting at begin
-        /** \param ns contains the variables that the new TFactor should depend on.
+        /// 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.
          *  \param begin Points to first element to be added.
          */
         template<typename TIterator>
          *  \tparam Iterator Iterates over instances of type T; should support addition of size_t.
          *  \param begin Points to first element to be added.
          */
         template<typename TIterator>
-        TFactor( const VarSet& ns, TIterator begin ) : _vs(ns), _p(begin, begin + _vs.nrStates(), _vs.nrStates()) {}
+        TFactor( const VarSet& vars, TIterator begin ) : _vs(vars), _p(begin, begin + _vs.nrStates(), _vs.nrStates()) {}
 
 
-        /// Constructs TFactor depending on variables in ns, with values set to the TProb p
-        TFactor( const VarSet& ns, const TProb<T>& p ) : _vs(ns), _p(p) {
+        /// Constructs TFactor depending on variables in vars, with values set to the TProb p
+        TFactor( const VarSet& vars, const TProb<T> &p ) : _vs(vars), _p(p) {
             DAI_DEBASSERT( _vs.nrStates() == _p.size() );
         }
             DAI_DEBASSERT( _vs.nrStates() == _p.size() );
         }
-        TFactor( const std::vector< Var >& vars, const std::vector< T >& p ) : _vs(vars.begin(), vars.end(), vars.size()), _p(p.size()) {
+
+        /// Constructs TFactor depending on variables in vars, permuting the values given in TProb p
+        TFactor( const std::vector<Var> &vars, const std::vector<T> &p ) : _vs(vars.begin(), vars.end(), vars.size()), _p(p.size()) {
             Permute permindex(vars);
             Permute permindex(vars);
-            for (size_t li = 0; li < p.size(); ++li) {
+            for( size_t li = 0; li < p.size(); ++li )
                 _p[permindex.convert_linear_index(li)] = p[li];
                 _p[permindex.convert_linear_index(li)] = p[li];
-            }
         }
         
         }
         
-        /// Constructs TFactor depending on the variable n, with uniform distribution
-        TFactor( const Var& n ) : _vs(n), _p(n.states()) {}
+        /// Constructs TFactor depending on the variable v, with uniform distribution
+        TFactor( const Var &v ) : _vs(v), _p(v.states()) {}
 
         /// Returns const reference to value vector
 
         /// Returns const reference to value vector
-        const TProb<T> & p() const { return _p; }
+        const TProb<T>& p() const { return _p; }
         /// Returns reference to value vector
         /// Returns reference to value vector
-        TProb<T> & p() { return _p; }
+        TProb<T>& p() { return _p; }
 
         /// Returns const reference to variable set
 
         /// Returns const reference to variable set
-        const VarSet & vars() const { return _vs; }
+        const VarSet& vars() const { return _vs; }
 
         /// Returns the number of possible joint states of the variables
         /** \note This is equal to the length of the value vector.
 
         /// Returns the number of possible joint states of the variables
         /** \note This is equal to the length of the value vector.
index 94b9325..0b30d10 100644 (file)
@@ -65,7 +65,7 @@ class IndexFor {
     private:
         /// The current linear index corresponding to the state of indexVars
         long                _index;
     private:
         /// The current linear index corresponding to the state of indexVars
         long                _index;
-       
+
         /// For each variable in forVars, the amount of change in _index
         std::vector<long>   _sum;
 
         /// For each variable in forVars, the amount of change in _index
         std::vector<long>   _sum;
 
@@ -74,7 +74,7 @@ class IndexFor {
         
         /// For each variable in forVars, its number of possible values
         std::vector<size_t> _dims;
         
         /// For each variable in forVars, its number of possible values
         std::vector<size_t> _dims;
-       
+
     public:
         /// Default constructor
         IndexFor() { 
     public:
         /// Default constructor
         IndexFor() { 
@@ -220,24 +220,21 @@ class Permute {
         /// Default constructor
         Permute() : _dims(), _sigma() {}
 
         /// Default constructor
         Permute() : _dims(), _sigma() {}
 
-        /// Initialize from vector of index dimensions and permutation sigma
+        /// Construct from vector of index dimensions and permutation sigma
         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() );
         }
   
-       Permute(const std::vector< Var >& vars) : _dims(vars.size()), _sigma(vars.size()) {
-           VarSet vs(vars.begin(), vars.end(), vars.size());
-           for (size_t i = 0; i < vars.size(); ++i) {
-               _dims[i] = vars[i].states();
-           }
-           VarSet::iterator set_iter = vs.begin();
-           for (size_t i = 0; i < vs.size(); ++i, ++set_iter) {
-               std::vector< Var >::const_iterator j;
-               j = find(vars.begin(), vars.end(), *set_iter);
-               _sigma[i] = j - vars.begin();
-           }
-       }
-       
+        /// 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() );
+            for( size_t i = 0; i < vars.size(); ++i )
+                _dims[i] = vars[i].states();
+            VarSet::const_iterator set_iter = vs.begin();
+            for( size_t i = 0; i < vs.size(); ++i, ++set_iter )
+                _sigma[i] = find( vars.begin(), vars.end(), *set_iter ) - vars.begin();
+        }
+
         /// 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, 
         /// 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, 
index 8db7907..4e661dc 100644 (file)
@@ -146,18 +146,8 @@ class PropertySet : private std::map<PropertyKey, PropertyValue> {
         }
 
         /// Shorthand for (temporarily) adding properties, e.g. PropertySet p()("method","BP")("verbose",1)("tol",1e-9)
         }
 
         /// 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); }
+        PropertySet operator()(const PropertyKey &key, const PropertyValue &val) const { PropertySet copy = *this; return copy.Set(key,val); }
                
                
-               std::vector< PropertyKey > keys() const {
-                       std::vector< PropertyKey > result;
-                       result.reserve(size());
-                       PropertySet::const_iterator i = begin();
-                       for ( ; i != end(); ++i) {
-                               result.push_back(i->first);
-                       }
-                       return result;
-               }
-
         /// 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()); }
 
@@ -170,6 +160,15 @@ class PropertySet : private std::map<PropertyKey, PropertyValue> {
             return res;
         }
 
             return res;
         }
 
+        /// Returns a vector containing all keys
+        std::vector<PropertyKey> keys() const {
+            std::vector<PropertyKey> result;
+            result.reserve( size() );
+            for( PropertySet::const_iterator i = begin(); i != end(); ++i )
+                result.push_back( i->first );
+            return result;
+        }
+
         /// Writes a PropertySet object to an output stream
         friend std::ostream& operator<< (std::ostream & os, const PropertySet & ps);
 
         /// Writes a PropertySet object to an output stream
         friend std::ostream& operator<< (std::ostream & os, const PropertySet & ps);
 
index 938fa09..7e11658 100644 (file)
@@ -125,7 +125,7 @@ void BP::construct() {
             newEP.residual = 0.0;
             _edges[i].push_back( newEP );
             if( props.updates == Properties::UpdateType::SEQMAX )
             newEP.residual = 0.0;
             _edges[i].push_back( newEP );
             if( props.updates == Properties::UpdateType::SEQMAX )
-                _edge2lut[i].push_back( _lut.insert( std::make_pair( newEP.residual, std::make_pair( i, _edges[i].size() - 1 ))) );
+                _edge2lut[i].push_back( _lut.insert( make_pair( newEP.residual, make_pair( i, _edges[i].size() - 1 ))) );
         }
     }
 }
         }
     }
 }
@@ -503,15 +503,15 @@ void BP::updateResidual( size_t i, size_t _I, double r ) {
        
        // rearrange look-up table (delete and reinsert new key)
        _lut.erase( _edge2lut[i][_I] );
        
        // rearrange look-up table (delete and reinsert new key)
        _lut.erase( _edge2lut[i][_I] );
-       _edge2lut[i][_I] = _lut.insert( std::make_pair( r, std::make_pair(i, _I) ) );
+       _edge2lut[i][_I] = _lut.insert( make_pair( r, make_pair(i, _I) ) );
 }
 
 
 std::vector<size_t> BP::findMaximum() const {
 }
 
 
 std::vector<size_t> BP::findMaximum() const {
-    std::vector<size_t> maximum( nrVars() );
-    std::vector<bool> visitedVars( nrVars(), false );
-    std::vector<bool> visitedFactors( nrFactors(), false );
-    std::stack<size_t> scheduledFactors;
+    vector<size_t> maximum( nrVars() );
+    vector<bool> visitedVars( nrVars(), false );
+    vector<bool> visitedFactors( nrFactors(), false );
+    stack<size_t> scheduledFactors;
     for( size_t i = 0; i < nrVars(); ++i ) {
         if( visitedVars[i] )
             continue;
     for( size_t i = 0; i < nrVars(); ++i ) {
         if( visitedVars[i] )
             continue;
@@ -520,7 +520,7 @@ std::vector<size_t> BP::findMaximum() const {
         // Maximise with respect to variable i
         Prob prod;
         calcBeliefV( i, prod );
         // Maximise with respect to variable i
         Prob prod;
         calcBeliefV( i, prod );
-        maximum[i] = std::max_element( prod.begin(), prod.end() ) - prod.begin();
+        maximum[i] = max_element( prod.begin(), prod.end() ) - prod.begin();
         
         foreach( const Neighbor &I, nbV(i) )
             if( !visitedFactors[I] ) 
         
         foreach( const Neighbor &I, nbV(i) )
             if( !visitedFactors[I] ) 
@@ -549,7 +549,7 @@ std::vector<size_t> BP::findMaximum() const {
 
             // The allowed configuration is restrained according to the variables assigned so far:
             // pick the argmax amongst the allowed states
 
             // The allowed configuration is restrained according to the variables assigned so far:
             // pick the argmax amongst the allowed states
-            Real maxProb = std::numeric_limits<Real>::min();
+            Real maxProb = numeric_limits<Real>::min();
             State maxState( factor(I).vars() );
             for( State s( factor(I).vars() ); s.valid(); ++s ){
                 // First, calculate whether this state is consistent with variables that
             State maxState( factor(I).vars() );
             for( State s( factor(I).vars() ); s.valid(); ++s ){
                 // First, calculate whether this state is consistent with variables that
@@ -572,7 +572,7 @@ std::vector<size_t> BP::findMaximum() const {
                 if( visitedVars[j.node] ) {
                     // We have already visited j earlier - hopefully our state is consistent
                     if( maximum[j.node] != maxState(var(j.node)) && props.verbose >= 1 )
                 if( visitedVars[j.node] ) {
                     // We have already visited j earlier - hopefully our state is consistent
                     if( maximum[j.node] != maxState(var(j.node)) && props.verbose >= 1 )
-                        std::cerr << "BP::findMaximum - warning: maximum not consistent due to loops." << std::endl;
+                        cerr << "BP::findMaximum - warning: maximum not consistent due to loops." << endl;
                 } else {
                     // We found a consistent state for variable j
                     visitedVars[j.node] = true;
                 } else {
                     // We found a consistent state for variable j
                     visitedVars[j.node] = true;
index 62102ef..811ca6e 100644 (file)
@@ -193,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();
 {
     // Calculate the necessary permutations
     setPermsAndVarSetsFromVarOrders();
@@ -230,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();
     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)] );
 }
 
 
 }
 
 
@@ -286,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 ) {
@@ -322,29 +318,29 @@ bool EMAlg::hasSatisfiedTermConditions() const {
 
 Real EMAlg::iterate( MaximizationStep &mstep ) {
     Real logZ = 0;
 
 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();
     // 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 );
         mstep.addExpectations( *clamped );
-               
+
         delete clamped;
     }
         delete clamped;
     }
-    
+
     // Maximization of parameters
     mstep.maximize( _estep.fg() );
     // Maximization of parameters
     mstep.maximize( _estep.fg() );
-       
-       return likelihood;
+
+    return likelihood;
 }
 
 
 }