Documented all exceptions and did some general cleanups
[libdai.git] / src / factorgraph.cpp
index b5a0ae6..41088f5 100644 (file)
@@ -87,11 +87,11 @@ std::ostream& operator<< ( std::ostream &os, const FactorGraph &fg ) {
         os << endl;
         size_t nr_nonzeros = 0;
         for( size_t k = 0; k < fg.factor(I).states(); k++ )
         os << endl;
         size_t nr_nonzeros = 0;
         for( size_t k = 0; k < fg.factor(I).states(); k++ )
-            if( fg.factor(I)[k] != 0.0 )
+            if( fg.factor(I)[k] != (Real)0 )
                 nr_nonzeros++;
         os << nr_nonzeros << endl;
         for( size_t k = 0; k < fg.factor(I).states(); k++ )
                 nr_nonzeros++;
         os << nr_nonzeros << endl;
         for( size_t k = 0; k < fg.factor(I).states(); k++ )
-            if( fg.factor(I)[k] != 0.0 )
+            if( fg.factor(I)[k] != (Real)0 )
                 os << k << " " << setw(os.precision()+4) << fg.factor(I)[k] << endl;
     }
 
                 os << k << " " << setw(os.precision()+4) << fg.factor(I)[k] << endl;
     }
 
@@ -117,7 +117,7 @@ std::istream& operator>> ( std::istream& is, FactorGraph &fg ) {
 
     getline (is,line);
     if( is.fail() )
 
     getline (is,line);
     if( is.fail() )
-        DAI_THROW(INVALID_FACTORGRAPH_FILE);
+        DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Expecting empty line");
 
     map<long,size_t> vardims;
     for( size_t I = 0; I < nr_Factors; I++ ) {
 
     map<long,size_t> vardims;
     for( size_t I = 0; I < nr_Factors; I++ ) {
@@ -153,7 +153,8 @@ std::istream& operator>> ( std::istream& is, FactorGraph &fg ) {
             cerr << "  dimensions: " << dims << endl;
 
         // add the Factor
             cerr << "  dimensions: " << dims << endl;
 
         // add the Factor
-        VarSet I_vars;
+        vector<Var> Ivars;
+        Ivars.reserve( nr_members );
         for( size_t mi = 0; mi < nr_members; mi++ ) {
             map<long,size_t>::iterator vdi = vardims.find( labels[mi] );
             if( vdi != vardims.end() ) {
         for( size_t mi = 0; mi < nr_members; mi++ ) {
             map<long,size_t>::iterator vdi = vardims.find( labels[mi] );
             if( vdi != vardims.end() ) {
@@ -162,23 +163,12 @@ std::istream& operator>> ( std::istream& is, FactorGraph &fg ) {
                     DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Variable with label " + boost::lexical_cast<string>(labels[mi]) + " has inconsistent dimensions.");
             } else
                 vardims[labels[mi]] = dims[mi];
                     DAI_THROWE(INVALID_FACTORGRAPH_FILE,"Variable with label " + boost::lexical_cast<string>(labels[mi]) + " has inconsistent dimensions.");
             } else
                 vardims[labels[mi]] = dims[mi];
-            I_vars |= Var(labels[mi], dims[mi]);
+            Ivars.push_back( 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();
-        for( size_t mi = 0; mi < nr_members; mi++,j++ ) {
-            long search_for = j->label();
-            vector<long>::iterator j_loc = find(labels.begin(),labels.end(),search_for);
-            sigma[mi] = j_loc - labels.begin();
-        }
-        if( verbose >= 3 )
-            cerr << "  sigma: " << sigma << endl;
+        facs.push_back( Factor( VarSet( Ivars.begin(), Ivars.end(), Ivars.size() ), (Real)0 ) );
 
 
-        // calculate multindices
-        Permute permindex( dims, sigma );
+        // calculate permutation object
+        Permute permindex( Ivars );
 
         // read values
         size_t nr_nonzeros;
 
         // read values
         size_t nr_nonzeros;
@@ -189,7 +179,7 @@ std::istream& operator>> ( std::istream& is, FactorGraph &fg ) {
             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;
-            double val;
+            Real val;
             while( (is.peek()) == '#' )
                 getline(is,line);
             is >> li;
             while( (is.peek()) == '#' )
                 getline(is,line);
             is >> li;
@@ -197,8 +187,7 @@ std::istream& operator>> ( std::istream& is, FactorGraph &fg ) {
                 getline(is,line);
             is >> val;
 
                 getline(is,line);
             is >> val;
 
-            // store value, but permute indices first according
-            // to internal representation
+            // store value, but permute indices first according to internal representation
             facs.back()[permindex.convertLinearIndex( li )] = val;
         }
     }
             facs.back()[permindex.convertLinearIndex( li )] = val;
         }
     }
@@ -212,12 +201,12 @@ std::istream& operator>> ( std::istream& is, FactorGraph &fg ) {
 }
 
 
 }
 
 
-VarSet FactorGraph::delta( unsigned i ) const {
+VarSet FactorGraph::delta( size_t i ) const {
     return( Delta(i) / var(i) );
 }
 
 
     return( Delta(i) / var(i) );
 }
 
 
-VarSet FactorGraph::Delta( unsigned i ) const {
+VarSet FactorGraph::Delta( size_t i ) const {
     // calculate Markov Blanket
     VarSet Del;
     foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i
     // calculate Markov Blanket
     VarSet Del;
     foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i
@@ -236,11 +225,11 @@ VarSet FactorGraph::Delta( const VarSet &ns ) const {
 }
 
 
 }
 
 
-void FactorGraph::makeCavity( unsigned i, bool backup ) {
+void FactorGraph::makeCavity( size_t i, bool backup ) {
     // fills all Factors that include var(i) with ones
     map<size_t,Factor> newFacs;
     foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i
     // fills all Factors that include var(i) with ones
     map<size_t,Factor> newFacs;
     foreach( const Neighbor &I, nbV(i) ) // for all neighboring factors I of i
-        newFacs[I] = Factor(factor(I).vars(), 1.0);
+        newFacs[I] = Factor( factor(I).vars(), (Real)1 );
     setFactors( newFacs, backup );
 }
 
     setFactors( newFacs, backup );
 }
 
@@ -302,11 +291,11 @@ vector<VarSet> FactorGraph::Cliques() const {
 
 void FactorGraph::clamp( size_t i, size_t x, bool backup ) {
     DAI_ASSERT( x <= var(i).states() );
 
 void FactorGraph::clamp( size_t i, size_t x, bool backup ) {
     DAI_ASSERT( x <= var(i).states() );
-    Factor mask( var(i), 0.0 );
-    mask[x] = 1.0;
+    Factor mask( var(i), (Real)0 );
+    mask[x] = (Real)1;
 
     map<size_t, Factor> newFacs;
 
     map<size_t, Factor> newFacs;
-    foreach( const BipartiteGraph::Neighbor &I, nbV(i) )
+    foreach( const Neighbor &I, nbV(i) )
         newFacs[I] = factor(I) * mask;
     setFactors( newFacs, backup );
 
         newFacs[I] = factor(I) * mask;
     setFactors( newFacs, backup );
 
@@ -316,15 +305,15 @@ void FactorGraph::clamp( size_t i, size_t x, bool backup ) {
 
 void FactorGraph::clampVar( size_t i, const vector<size_t> &is, bool backup ) {
     Var n = var(i);
 
 void FactorGraph::clampVar( size_t i, const vector<size_t> &is, bool backup ) {
     Var n = var(i);
-    Factor mask_n( n, 0.0 );
+    Factor mask_n( n, (Real)0 );
 
     foreach( size_t i, is ) {
         DAI_ASSERT( i <= n.states() );
 
     foreach( size_t i, is ) {
         DAI_ASSERT( i <= n.states() );
-        mask_n[i] = 1.0;
+        mask_n[i] = (Real)1;
     }
 
     map<size_t, Factor> newFacs;
     }
 
     map<size_t, Factor> newFacs;
-    foreach( const BipartiteGraph::Neighbor &I, nbV(i) )
+    foreach( const Neighbor &I, nbV(i) )
         newFacs[I] = factor(I) * mask_n;
     setFactors( newFacs, backup );
 }
         newFacs[I] = factor(I) * mask_n;
     setFactors( newFacs, backup );
 }
@@ -332,7 +321,7 @@ void FactorGraph::clampVar( size_t i, const vector<size_t> &is, bool backup ) {
 
 void FactorGraph::clampFactor( size_t I, const vector<size_t> &is, bool backup ) {
     size_t st = factor(I).states();
 
 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 );
+    Factor newF( factor(I).vars(), (Real)0 );
 
     foreach( size_t i, is ) {
         DAI_ASSERT( i <= st );
 
     foreach( size_t i, is ) {
         DAI_ASSERT( i <= st );
@@ -410,8 +399,9 @@ bool FactorGraph::isBinary() const {
 }
 
 
 }
 
 
-FactorGraph FactorGraph::clamped( const Var &v, size_t state ) const {
-    Real zeroth_order = 1.0;
+FactorGraph FactorGraph::clamped( size_t i, size_t state ) const {
+    Var v = var( i );
+    Real zeroth_order = (Real)1;
     vector<Factor> clamped_facs;
     for( size_t I = 0; I < nrFactors(); I++ ) {
         VarSet v_I = factor(I).vars();
     vector<Factor> clamped_facs;
     for( size_t I = 0; I < nrFactors(); I++ ) {
         VarSet v_I = factor(I).vars();