Replaced all "protected:" by "private:" or "public:"
[libdai.git] / 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 private:
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 private:
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 /// Give back the OR index that corresponds to a factor index
107 std::vector<size_t> fac2OR;
108
109
110 public:
111 /// Default constructor
112 RegionGraph() : FactorGraph(), G(), ORs(), IRs(), fac2OR() {}
113
114 /// Constructs a RegionGraph from a FactorGraph
115 RegionGraph( const FactorGraph &fg ) : FactorGraph(fg), G(), ORs(), IRs(), fac2OR() {}
116
117 /// Constructs a RegionGraph from a FactorGraph, a vector of outer regions, a vector of inner regions and a vector of edges
118 RegionGraph( const FactorGraph &fg, const std::vector<Region> &ors, const std::vector<Region> &irs, const std::vector<std::pair<size_t,size_t> > &edges );
119
120 /// Constructs a RegionGraph from a FactorGraph and a vector of outer VarSets (CVM style)
121 RegionGraph( const FactorGraph &fg, const std::vector<VarSet> &cl );
122
123 /// Copy constructor
124 RegionGraph( const RegionGraph &x ) : FactorGraph(x), G(x.G), ORs(x.ORs), IRs(x.IRs), fac2OR(x.fac2OR) {}
125
126 /// Assignment operator
127 RegionGraph & operator=( const RegionGraph &x ) {
128 if( this != &x ) {
129 FactorGraph::operator=( x );
130 G = x.G;
131 ORs = x.ORs;
132 IRs = x.IRs;
133 fac2OR = x.fac2OR;
134 }
135 return *this;
136 }
137
138 /// Clone *this (virtual copy constructor)
139 virtual RegionGraph* clone() const { return new RegionGraph(*this); }
140
141 /// Create (virtual default constructor)
142 virtual RegionGraph* create() const { return new RegionGraph(); }
143
144 /// Set the content of the I'th factor and make a backup of its old content if backup == true
145 virtual void setFactor( size_t I, const Factor &newFactor, bool backup = false ) {
146 FactorGraph::setFactor( I, newFactor, backup );
147 RecomputeOR( I );
148 }
149
150 /// Set the contents of all factors as specified by facs and make a backup of the old contents if backup == true
151 virtual void setFactors( const std::map<size_t, Factor> & facs, bool backup = false ) {
152 FactorGraph::setFactors( facs, backup );
153 VarSet ns;
154 for( std::map<size_t, Factor>::const_iterator fac = facs.begin(); fac != facs.end(); fac++ )
155 ns |= fac->second.vars();
156 RecomputeORs( ns );
157 }
158
159
160 /// Provides read access to outer region
161 const FRegion & OR(size_t alpha) const { return ORs[alpha]; }
162 /// Provides access to outer region
163 FRegion & OR(size_t alpha) { return ORs[alpha]; }
164
165 /// Provides read access to inner region
166 const Region & IR(size_t beta) const { return IRs[beta]; }
167 /// Provides access to inner region
168 Region & IR(size_t beta) { return IRs[beta]; }
169
170 /// Returns number of outer regions
171 size_t nrORs() const { return ORs.size(); }
172 /// Returns number of inner regions
173 size_t nrIRs() const { return IRs.size(); }
174
175
176 /// Provides read access to neighbors of outer region
177 const Neighbors & nbOR( size_t alpha ) const { return G.nb1(alpha); }
178 /// Provides full access to neighbors of outer region
179 Neighbors & nbOR( size_t alpha ) { return G.nb1(alpha); }
180
181 /// Provides read access to neighbors of inner region
182 const Neighbors & nbIR( size_t beta ) const { return G.nb2(beta); }
183 /// Provides full access to neighbors of inner region
184 Neighbors & nbIR( size_t beta ) { return G.nb2(beta); }
185
186
187 /// Calculates counting numbers of inner regions based upon counting numbers of outer regions
188 void Calc_Counting_Numbers();
189 /// Check whether the counting numbers are valid
190 bool Check_Counting_Numbers();
191
192 /// Recompute all outer regions
193 void RecomputeORs();
194
195 /// Recompute all outer regions involving the variables in ns
196 void RecomputeORs( const VarSet & ns );
197
198 /// Recompute all outer regions involving factor I
199 void RecomputeOR( size_t I );
200
201 /// Send RegionGraph to output stream
202 friend std::ostream & operator << ( std::ostream & os, const RegionGraph & rg );
203 };
204
205
206 } // end of namespace dai
207
208
209 #endif