Cleanup of BBP code
[libdai.git] / include / dai / regiongraph.h
index b7ab9e7..8100120 100644 (file)
@@ -1,6 +1,7 @@
-/*  Copyright (C) 2006-2008  Joris Mooij  [j dot mooij at science dot ru dot nl]
-    Radboud University Nijmegen, The Netherlands
-    
+/*  Copyright (C) 2006-2008  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
 */
 
 
+/// \file
+/// \brief Defines classes Region, FRegion and RegionGraph
+/// \todo Improve documentation
+
+
 #ifndef __defined_libdai_regiongraph_h
 #define __defined_libdai_regiongraph_h
 
@@ -34,7 +40,7 @@ namespace dai {
 
 /// A Region is a set of variables with a counting number
 class Region : public VarSet {
-    protected:
+    private:
         /// Counting number
         double          _c;
 
@@ -45,18 +51,6 @@ class Region : public VarSet {
         /// Construct Region from a VarSet and a counting number
         Region(const VarSet & x, double c) : VarSet(x), _c(c) {}
         
-        /// Copy constructor
-        Region(const Region & x) : VarSet(x), _c(x._c) {}
-
-        /// Assignment operator
-        Region & operator=(const Region & x) {
-            if( this != &x ) {
-                VarSet::operator=(x);
-                _c          = x._c;
-            }
-            return *this;
-        }
-
         /// Provide read access to counting number
         const double & c() const { return _c; }
         /// Provide full access to counting number
@@ -66,7 +60,7 @@ class Region : public VarSet {
 
 /// A FRegion is a factor with a counting number
 class FRegion : public Factor {
-    protected:
+    private:
         /// Counting number
         double _c;
 
@@ -77,18 +71,6 @@ class FRegion : public Factor {
         /// Constructs FRegion from a Factor and a counting number
         FRegion( const Factor & x, double c ) : Factor(x), _c(c) {}
         
-        /// Copy constructor
-        FRegion( const FRegion & x ) : Factor(x), _c(x._c) {}
-
-        /// Assignment operator
-        FRegion & operator=(const FRegion & x) {
-            if( this != &x ) {
-                Factor::operator=(x);
-                _c = x._c;
-            }
-            return *this;
-        }
-
         /// Provide read access to counting number
         const double & c() const { return _c; }
         /// Provide full access to counting number
@@ -96,98 +78,84 @@ class FRegion : public Factor {
 };
 
 
-typedef BipartiteGraph<FRegion,Region> BipRegGraph;
-
-
 /// A RegionGraph is a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region)
-class RegionGraph : public FactorGraph, BipRegGraph {
+class RegionGraph : public FactorGraph {
     public:
-        typedef BipRegGraph::_nb_t      R_nb_t;
-        typedef R_nb_t::const_iterator  R_nb_cit;
-        typedef BipRegGraph::_edge_t    R_edge_t;
+        /// Stores the neighborhood structure
+        BipartiteGraph          G;
 
-        
-    protected:
-        /// Give back the OR index that corresponds to a factor index
-        typedef std::map<size_t,size_t>::const_iterator fac2OR_cit;
-        std::map<size_t,size_t>         _fac2OR;
+        /// The outer regions (corresponding to nodes of type 1)
+        std::vector<FRegion>    ORs;
+
+        /// The inner regions (corresponding to nodes of type 2)
+        std::vector<Region>     IRs;
+
+        /// Stores for each factor index the index of the outer region it belongs to
+        std::vector<size_t>     fac2OR;
 
 
     public:
         /// Default constructor
-        RegionGraph() : FactorGraph(), BipRegGraph(), _fac2OR() {}
+        RegionGraph() : FactorGraph(), G(), ORs(), IRs(), fac2OR() {}
 
         /// Constructs a RegionGraph from a FactorGraph
-        RegionGraph(const FactorGraph & fg) : FactorGraph(fg), BipRegGraph(), _fac2OR() {}
+        RegionGraph( const FactorGraph &fg ) : FactorGraph(fg), G(), ORs(), IRs(), fac2OR() {}
 
         /// 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<R_edge_t> & 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);
-
-        /// Copy constructor
-        RegionGraph(const RegionGraph & x) : FactorGraph(x), BipRegGraph(x), _fac2OR(x._fac2OR) {}
-
-        /// Assignment operator
-        RegionGraph & operator=(const RegionGraph & x) {
-            if( this != &x ) {
-                FactorGraph::operator=(x);
-                BipRegGraph::operator=(x);
-                _fac2OR = x._fac2OR;
-            }
-            return *this;
+        RegionGraph( const FactorGraph &fg, const std::vector<VarSet> &cl );
+
+        /// Clone *this (virtual copy constructor)
+        virtual RegionGraph* clone() const { return new RegionGraph(*this); }
+
+        /// Create (virtual default constructor)
+        virtual RegionGraph* create() const { return new RegionGraph(); }
+
+        /// 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 ); 
+        }
+
+        /// Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true
+        virtual void setFactors( const std::map<size_t, Factor> & facs, bool backup = false ) {
+            FactorGraph::setFactors( facs, backup );
+            VarSet ns;
+            for( std::map<size_t, Factor>::const_iterator fac = facs.begin(); fac != facs.end(); fac++ )
+                ns |= fac->second.vars();
+            RecomputeORs( ns ); 
         }
 
+
         /// Provides read access to outer region
-        const FRegion & OR(long alpha) const { return BipRegGraph::V1(alpha); }
+        const FRegion & OR(size_t alpha) const { return ORs[alpha]; }
         /// Provides access to outer region
-        FRegion & OR(long alpha) { return BipRegGraph::V1(alpha); }
-        /// Provides read access to all outer regions
-        const std::vector<FRegion> & ORs() const { return BipRegGraph::V1s(); }
-        /// Provides access to all outer regions
-        std::vector<FRegion> &ORs() { return BipRegGraph::V1s(); }
-        /// Returns number of outer regions
-        size_t nr_ORs() const { return BipRegGraph::V1s().size(); }
+        FRegion & OR(size_t alpha) { return ORs[alpha]; }
 
         /// Provides read access to inner region
-        const Region & IR(long beta) const { return BipRegGraph::V2(beta); }
+        const Region & IR(size_t beta) const { return IRs[beta]; }
         /// Provides access to inner region
-        Region & IR(long beta) { return BipRegGraph::V2(beta); }
-        /// Provides read access to all inner regions
-        const std::vector<Region> & IRs() const { return BipRegGraph::V2s(); }
-        /// Provides access to all inner regions
-        std::vector<Region> & IRs() { return BipRegGraph::V2s(); }
+        Region & IR(size_t beta) { return IRs[beta]; }
+
+        /// Returns number of outer regions
+        size_t nrORs() const { return ORs.size(); }
         /// Returns number of inner regions
-        size_t nr_IRs() const { return BipRegGraph::V2s().size(); }
-
-        /// Provides read access to edge
-        const R_edge_t & Redge(size_t ind) const { return BipRegGraph::edge(ind); }
-        /// Provides full access to edge
-        R_edge_t & Redge(size_t ind) { return BipRegGraph::edge(ind); }
-        /// Provides read access to all edges
-        const std::vector<R_edge_t> & Redges() const { return BipRegGraph::edges(); }
-        /// Provides full access to all edges
-        std::vector<R_edge_t> & Redges() { return BipRegGraph::edges(); }
-        /// Returns number of edges
-        size_t nr_Redges() const { return BipRegGraph::edges().size(); }
-
-        /// Provides read access to neighbours of outer region
-        const R_nb_t & nbOR( size_t i1 ) const { return BipRegGraph::nb1(i1); }
-        /// Provides full access to neighbours of outer region
-        R_nb_t & nbOR( size_t i1 ) { return BipRegGraph::nb1(i1); }
-
-        /// Provides read access to neighbours of inner region
-        const R_nb_t & nbIR( size_t i2 ) const { return BipRegGraph::nb2(i2); }
-        /// Provides full access to neighbours of inner region
-        R_nb_t & nbIR( size_t i2 ) { return BipRegGraph::nb2(i2); }
-
-        /// Converts the pair of outer/inner region indices (i1,i2) to the corresponding edge index
-        size_t ORIR2E( const size_t i1, const size_t i2 ) const { return BipRegGraph::VV2E(i1, i2); }
-
-        void Regenerate() { BipRegGraph::Regenerate(); }
-        
-        
+        size_t nrIRs() const { return IRs.size(); }
+
+
+        /// Provides read access to neighbors of outer region
+        const Neighbors & nbOR( size_t alpha ) const { return G.nb1(alpha); }
+        /// Provides full access to neighbors of outer region
+        Neighbors & nbOR( size_t alpha ) { return G.nb1(alpha); }
+
+        /// Provides read access to neighbors of inner region
+        const Neighbors & nbIR( size_t beta ) const { return G.nb2(beta); }
+        /// Provides full access to neighbors of inner region
+        Neighbors & nbIR( size_t beta ) { return G.nb2(beta); }
+
+
         /// Calculates counting numbers of inner regions based upon counting numbers of outer regions
         void Calc_Counting_Numbers();
         /// Check whether the counting numbers are valid
@@ -202,25 +170,7 @@ class RegionGraph : public FactorGraph, BipRegGraph {
         /// Recompute all outer regions involving factor I
         void RecomputeOR( size_t I );
 
-        /// We have to overload FactorGraph::clamp because the corresponding outer regions have to be recomputed
-        void clamp( const Var &n, size_t i ) { FactorGraph::clamp( n, i ); RecomputeORs( n ); }
-
-        /// We have to overload FactorGraph::makeCavity because the corresponding outer regions have to be recomputed
-        void makeCavity( const Var &n ) { FactorGraph::makeCavity( n ); RecomputeORs( n ); }
-
-        /// We have to overload FactorGraph::makeFactorCavity because the corresponding outer regions have to be recomputed
-        void makeFactorCavity( size_t I ) { FactorGraph::makeFactorCavity( I ); RecomputeOR( I ); }
-
-        /// We have to overload FactorGraph::undoProbs because the corresponding outer regions have to be recomputed
-        void undoProbs( const VarSet &ns ) { FactorGraph::undoProbs( ns ); RecomputeORs( ns ); }
-
-        /// We have to overload FactorGraph::undoProb because the corresponding outer regions have to be recomputed
-        void undoProb( size_t I ) { FactorGraph::undoProb( I ); RecomputeOR( I ); }
-
-        /// If updateFactor is called, we know that factor I has been changed and we should recompute the outer regions involving I
-        void updatedFactor( size_t I ) { RecomputeOR( I ); }
-
-        /// Send RegionGraph to output stream
+        // Friends
         friend std::ostream & operator << ( std::ostream & os, const RegionGraph & rg );
 };