Generalized VarSet to "template<typename T> small_set<T>"
[libdai.git] / src / factorgraph.cpp
index 1a25f8d..c28e864 100644 (file)
@@ -38,13 +38,13 @@ namespace dai {
 using namespace std;
 
 
-FactorGraph::FactorGraph( const std::vector<Factor> &P ) : G(), _undoProbs() {
+FactorGraph::FactorGraph( const std::vector<Factor> &P ) : G(), _backup() {
     // add factors, obtain variables
     set<Var> _vars;
-    factors.reserve( P.size() );
+    _factors.reserve( P.size() );
     size_t nrEdges = 0;
     for( vector<Factor>::const_iterator p2 = P.begin(); p2 != P.end(); p2++ ) {
-        factors.push_back( *p2 );
+        _factors.push_back( *p2 );
         copy( p2->vars().begin(), p2->vars().end(), inserter( _vars, _vars.begin() ) );
         nrEdges += p2->vars().size();
     }
@@ -55,12 +55,12 @@ FactorGraph::FactorGraph( const std::vector<Factor> &P ) : G(), _undoProbs() {
         vars.push_back( *p1 );
 
     // create graph structure
-    createGraph( nrEdges );
+    constructGraph( nrEdges );
 }
 
 
 /// Part of constructors (creates edges, neighbours and adjacency matrix)
-void FactorGraph::createGraph( size_t nrEdges ) {
+void FactorGraph::constructGraph( size_t nrEdges ) {
     // create a mapping for indices
     hash_map<size_t, size_t> hashmap;
     
@@ -77,7 +77,7 @@ void FactorGraph::createGraph( size_t nrEdges ) {
     }
 
     // create bipartite graph
-    G.create( nrVars(), nrFactors(), edges.begin(), edges.end() );
+    G.construct( nrVars(), nrFactors(), edges.begin(), edges.end() );
 }
 
 
@@ -114,7 +114,7 @@ istream& operator >> (istream& is, FactorGraph& fg) {
     long verbose = 0;
 
     try {
-        vector<Factor> factors;
+        vector<Factor> facs;
         size_t nr_Factors;
         string line;
         
@@ -175,7 +175,7 @@ istream& operator >> (istream& is, FactorGraph& fg) {
                     vardims[labels[mi]] = dims[mi];
                 I_vars |= Var(labels[mi], dims[mi]);
             }
-            factors.push_back( Factor( I_vars, 0.0 ) );
+            facs.push_back( Factor( I_vars, 0.0 ) );
             
             // calculate permutation sigma (internally, members are sorted)
             vector<size_t> sigma(nr_members,0);
@@ -210,14 +210,14 @@ istream& operator >> (istream& is, FactorGraph& fg) {
 
                 // store value, but permute indices first according
                 // to internal representation
-                factors.back()[permindex.convert_linear_index( li  )] = val;
+                facs.back()[permindex.convert_linear_index( li  )] = val;
             }
         }
 
         if( verbose >= 3 )
-            cout << "factors:" << factors << endl;
+            cout << "factors:" << facs << endl;
 
-        fg = FactorGraph(factors);
+        fg = FactorGraph(facs);
     } catch (char *e) {
         cout << e << endl;
     }
@@ -281,7 +281,7 @@ void FactorGraph::WriteToFile( const char *filename ) const {
 }
 
 
-void FactorGraph::display( ostream &os ) const {
+void FactorGraph::printDot( std::ostream &os ) const {
     os << "graph G {" << endl;
     os << "node[shape=circle,width=0.4,fixedsize=true];" << endl;
     for( size_t i = 0; i < nrVars(); i++ )
@@ -334,18 +334,18 @@ void FactorGraph::clamp( const Var & n, size_t i, bool backup ) {
 
 
 void FactorGraph::backupFactor( size_t I ) {
-    map<size_t,Factor>::iterator it = _backupFactors.find( I );
-    if( it != _backupFactors.end() )
+    map<size_t,Factor>::iterator it = _backup.find( I );
+    if( it != _backup.end() )
         DAI_THROW( MULTIPLE_UNDO );
-    _backupFactors[I] = factor(I);
+    _backup[I] = factor(I);
 }
 
 
 void FactorGraph::restoreFactor( size_t I ) {
-    map<size_t,Factor>::iterator it = _backupFactors.find( I );
-    if( it != _backupFactors.end() ) {
+    map<size_t,Factor>::iterator it = _backup.find( I );
+    if( it != _backup.end() ) {
         setFactor(I, it->second);
-        _backupFactors.erase(it);
+        _backup.erase(it);
     }
 }
 
@@ -359,10 +359,10 @@ void FactorGraph::backupFactors( const VarSet &ns ) {
 
 void FactorGraph::restoreFactors( const VarSet &ns ) {
     map<size_t,Factor> facs;
-    for( map<size_t,Factor>::iterator uI = _backupFactors.begin(); uI != _backupFactors.end(); ) {
+    for( map<size_t,Factor>::iterator uI = _backup.begin(); uI != _backup.end(); ) {
         if( factor(uI->first).vars().intersects( ns ) ) {
             facs.insert( *uI );
-            _backupFactors.erase(uI++);
+            _backup.erase(uI++);
         } else
             uI++;
     }
@@ -371,8 +371,8 @@ void FactorGraph::restoreFactors( const VarSet &ns ) {
 
 
 void FactorGraph::restoreFactors() {
-    setFactors( _backupFactors );
-    _backupFactors.clear();
+    setFactors( _backup );
+    _backup.clear();
 }
 
 void FactorGraph::backupFactors( const std::set<size_t> & facs ) {
@@ -451,7 +451,7 @@ FactorGraph FactorGraph::maximalFactors() const {
     for( size_t I = 0; I < nrFactors(); I++ )
         facs[newindex[maxfac[I]]] *= factor(I);
 
-    return FactorGraph( facs.begin(), facs.end(), vars().begin(), vars().end(), facs.size(), nrVars() );
+    return FactorGraph( facs.begin(), facs.end(), vars.begin(), vars.end(), facs.size(), nrVars() );
 }