include/dai/regiongraph.h

   1 /*  Copyright (C) 2006-2008  Joris Mooij  [j dot mooij at science dot ru dot nl]
   2     Radboud University Nijmegen, The Netherlands
   3
   4     This file is part of libDAI.
   5
   6     libDAI is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     libDAI is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with libDAI; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19 */
  20
  21
  22 #ifndef __defined_libdai_regiongraph_h
  23 #define __defined_libdai_regiongraph_h
  24
  25
  26 #include <iostream>
  27 #include <dai/bipgraph.h>
  28 #include <dai/factorgraph.h>
  29 #include <dai/weightedgraph.h>
  30
  31
  32 namespace dai {
  33
  34
  35 /// A Region is a set of variables with a counting number
  36 class Region : public VarSet {
  37     protected:
  38         /// Counting number
  39         double          _c;
  40
  41     public:
  42         /// Default constructor
  43         Region() : VarSet(), _c(1.0) {}
  44
  45         /// Construct Region from a VarSet and a counting number
  46         Region(const VarSet & x, double c) : VarSet(x), _c(c) {}
  47
  48         /// Copy constructor
  49         Region(const Region & x) : VarSet(x), _c(x._c) {}
  50
  51         /// Assignment operator
  52         Region & operator=(const Region & x) {
  53             if( this != &x ) {
  54                 VarSet::operator=(x);
  55                 _c          = x._c;
  56             }
  57             return *this;
  58         }
  59
  60         /// Provide read access to counting number
  61         const double & c() const { return _c; }
  62         /// Provide full access to counting number
  63         double & c() { return _c; }
  64 };
  65
  66
  67 /// A FRegion is a factor with a counting number
  68 class FRegion : public Factor {
  69     protected:
  70         /// Counting number
  71         double _c;
  72
  73     public:
  74         /// Default constructor
  75         FRegion() : Factor(), _c(1.0) {}
  76
  77         /// Constructs FRegion from a Factor and a counting number
  78         FRegion( const Factor & x, double c ) : Factor(x), _c(c) {}
  79
  80         /// Copy constructor
  81         FRegion( const FRegion & x ) : Factor(x), _c(x._c) {}
  82
  83         /// Assignment operator
  84         FRegion & operator=(const FRegion & x) {
  85             if( this != &x ) {
  86                 Factor::operator=(x);
  87                 _c = x._c;
  88             }
  89             return *this;
  90         }
  91
  92         /// Provide read access to counting number
  93         const double & c() const { return _c; }
  94         /// Provide full access to counting number
  95         double & c() { return _c; }
  96 };
  97
  98
  99 /// A RegionGraph is a bipartite graph consisting of outer regions (type FRegion) and inner regions (type Region)
 100 class RegionGraph : public FactorGraph {
 101     public:
 102         BipartiteGraph          G;
 103         std::vector<FRegion>    ORs;
 104         std::vector<Region>     IRs;
 105
 106     protected:
 107         /// Give back the OR index that corresponds to a factor index
 108         std::vector<size_t>     fac2OR;
 109
 110
 111     public:
 112         /// Default constructor
 113         RegionGraph() : FactorGraph(), G(), ORs(), IRs(), fac2OR() {}
 114
 115         /// Constructs a RegionGraph from a FactorGraph
 116         RegionGraph( const FactorGraph &fg ) : FactorGraph(fg), G(), ORs(), IRs(), fac2OR() {}
 117
 118         /// Constructs a RegionGraph from a FactorGraph, a vector of outer regions, a vector of inner regions and a vector of edges
 119         RegionGraph( const FactorGraph &fg, const std::vector<Region> &ors, const std::vector<Region> &irs, const std::vector<std::pair<size_t,size_t> > &edges );
 120
 121         /// Constructs a RegionGraph from a FactorGraph and a vector of outer VarSets (CVM style)
 122         RegionGraph( const FactorGraph &fg, const std::vector<VarSet> &cl );
 123
 124         /// Copy constructor
 125         RegionGraph( const RegionGraph &x ) : FactorGraph(x), G(x.G), ORs(x.ORs), IRs(x.IRs), fac2OR(x.fac2OR) {}
 126
 127         /// Assignment operator
 128         RegionGraph & operator=( const RegionGraph &x ) {
 129             if( this != &x ) {
 130                 FactorGraph::operator=( x );
 131                 G = x.G;
 132                 ORs = x.ORs;
 133                 IRs = x.IRs;
 134                 fac2OR = x.fac2OR;
 135             }
 136             return *this;
 137         }
 138
 139         /// Create (virtual default constructor)
 140         virtual RegionGraph* create() const {
 141             return new RegionGraph();
 142         }
 143
 144         /// Clone (virtual copy constructor)
 145         virtual RegionGraph* clone() const {
 146             return new RegionGraph(*this);
 147         }
 148
 149         /// Set the content of the I'th factor and make a backup of its old content if backup == true
 150         virtual void setFactor( size_t I, const Factor &newFactor, bool backup = false ) {
 151             FactorGraph::setFactor( I, newFactor, backup );
 152             RecomputeOR( I );
 153         }
 154
 155         /// Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true
 156         virtual void setFactors( const std::map<size_t, Factor> & facs, bool backup = false ) {
 157             FactorGraph::setFactors( facs, backup );
 158             VarSet ns;
 159             for( std::map<size_t, Factor>::const_iterator fac = facs.begin(); fac != facs.end(); fac++ )
 160                 ns |= fac->second.vars();
 161             RecomputeORs( ns );
 162         }
 163
 164
 165         /// Provides read access to outer region
 166         const FRegion & OR(size_t alpha) const { return ORs[alpha]; }
 167         /// Provides access to outer region
 168         FRegion & OR(size_t alpha) { return ORs[alpha]; }
 169
 170         /// Provides read access to inner region
 171         const Region & IR(size_t beta) const { return IRs[beta]; }
 172         /// Provides access to inner region
 173         Region & IR(size_t beta) { return IRs[beta]; }
 174
 175         /// Returns number of outer regions
 176         size_t nrORs() const { return ORs.size(); }
 177         /// Returns number of inner regions
 178         size_t nrIRs() const { return IRs.size(); }
 179
 180
 181         /// Provides read access to neighbors of outer region
 182         const Neighbors & nbOR( size_t alpha ) const { return G.nb1(alpha); }
 183         /// Provides full access to neighbors of outer region
 184         Neighbors & nbOR( size_t alpha ) { return G.nb1(alpha); }
 185
 186         /// Provides read access to neighbors of inner region
 187         const Neighbors & nbIR( size_t beta ) const { return G.nb2(beta); }
 188         /// Provides full access to neighbors of inner region
 189         Neighbors & nbIR( size_t beta ) { return G.nb2(beta); }
 190
 191
 192         /// Calculates counting numbers of inner regions based upon counting numbers of outer regions
 193         void Calc_Counting_Numbers();
 194         /// Check whether the counting numbers are valid
 195         bool Check_Counting_Numbers();
 196
 197         /// Recompute all outer regions
 198         void RecomputeORs();
 199
 200         /// Recompute all outer regions involving the variables in ns
 201         void RecomputeORs( const VarSet & ns );
 202
 203         /// Recompute all outer regions involving factor I
 204         void RecomputeOR( size_t I );
 205
 206         /// Send RegionGraph to output stream
 207         friend std::ostream & operator << ( std::ostream & os, const RegionGraph & rg );
 208 };
 209
 210
 211 } // end of namespace dai
 212
 213
 214 #endif