1 /* Test Grid::is_topologically_closed().
2 Copyright (C) 2001-2010 Roberto Bagnara <bagnara@cs.unipr.it>
3 Copyright (C) 2010-2016 BUGSENG srl (http://bugseng.com)
4
5 This file is part of the Parma Polyhedra Library (PPL).
6
7 The PPL is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 3 of the License, or (at your
10 option) any later version.
11
12 The PPL is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software Foundation,
19 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.
20
21 For the most up-to-date information see the Parma Polyhedra Library
22 site: http://bugseng.com/products/ppl/ . */
23
24 #include "ppl_test.hh"
25
26 namespace {
27
28 // Empty.
29 bool
test01()30 test01() {
31 Grid gr(7, EMPTY);
32
33 bool ok = (gr.is_topologically_closed());
34
35 print_congruences(gr, "*** gr ***");
36
37 return ok;
38 }
39
40 // Zero dimension empty.
41
42 bool
test02()43 test02() {
44 Grid gr(0, EMPTY);
45
46 bool ok = (gr.is_topologically_closed());
47
48 print_congruences(gr, "*** gr ***");
49
50 return ok;
51 }
52
53 // Zero dimension universe.
54
55 bool
test03()56 test03() {
57 Grid gr(0);
58
59 bool ok = (gr.is_topologically_closed());
60
61 print_congruences(gr, "*** gr ***");
62
63 return ok;
64 }
65
66 // Point.
67
68 bool
test04()69 test04() {
70 Variable A(0);
71 Variable B(1);
72
73 Grid gr_gs_min(2, EMPTY);
74 gr_gs_min.add_grid_generator(grid_point(3*A + 2*B));
75
76 Grid gr_gs_needs_min(2, EMPTY);
77 gr_gs_needs_min.add_grid_generator(grid_point(3*A + 2*B));
78
79 Grid gr_cgs_needs_min(2);
80 gr_cgs_needs_min.add_constraint(A == 3);
81 gr_cgs_needs_min.add_constraint(B == 2);
82
83 // Grids gr_gs_min, gr_gs_needs_min and gr_cgs_needs_min are the
84 // same grids.
85
86 bool ok = (gr_gs_min.is_topologically_closed())
87 && (gr_gs_needs_min.is_topologically_closed())
88 && (gr_cgs_needs_min.is_topologically_closed());
89
90 print_generators(gr_gs_min, "*** gr_gs_min ***");
91 print_generators(gr_gs_needs_min, "*** gr_gs_needs_min ***");
92 print_congruences(gr_cgs_needs_min, "*** gr_cgs_needs_min ***");
93
94 return ok;
95 }
96
97 // Line.
98
99 bool
test05()100 test05() {
101 Variable A(0);
102 Variable B(1);
103 Variable C(2);
104
105 Grid gr_gs_min(3, EMPTY);
106 gr_gs_min.add_grid_generator(grid_point(3*A + 2*B));
107 gr_gs_min.add_grid_generator(grid_line(C));
108
109 Grid gr_gs_needs_min(3, EMPTY);
110 gr_gs_needs_min.add_grid_generator(grid_point(3*A + 2*B));
111 gr_gs_needs_min.add_grid_generator(grid_line(C));
112
113 Grid gr_cgs_needs_min(3);
114 gr_cgs_needs_min.add_constraint(A == 3);
115 gr_cgs_needs_min.add_constraint(B == 2);
116
117 // Grids gr_gs_min, gr_gs_needs_min and gr_cgs_needs_min are the
118 // same grids.
119
120 bool ok = (gr_gs_min.is_topologically_closed())
121 && (gr_gs_needs_min.is_topologically_closed())
122 && (gr_cgs_needs_min.is_topologically_closed());
123
124 print_generators(gr_gs_min, "*** gr_gs_min ***");
125 print_generators(gr_gs_needs_min, "*** gr_gs_needs_min ***");
126 print_congruences(gr_cgs_needs_min, "*** gr_cgs_needs_min ***");
127
128 return ok;
129 }
130
131 // Rectilinear.
132 bool
test06()133 test06() {
134 Variable A(0);
135 Variable B(1);
136 Variable C(2);
137
138 Grid gr_gs_min(3, EMPTY);
139 gr_gs_min.add_grid_generator(grid_point(3*A + 2*B));
140 gr_gs_min.add_grid_generator(grid_point(3*A + B));
141
142 Grid gr_gs_needs_min(3, EMPTY);
143 gr_gs_needs_min.add_grid_generator(grid_point(3*A + 2*B));
144 gr_gs_needs_min.add_grid_generator(grid_point(3*A + B));
145
146 Grid gr_cgs_needs_min(3);
147 gr_cgs_needs_min.add_constraint(A == 3);
148 gr_cgs_needs_min.add_congruence(B %= 0);
149 gr_cgs_needs_min.add_constraint(C == 0);
150
151 // Grids gr_gs_min, gr_gs_needs_min and gr_cgs_needs_min are the
152 // same grids.
153
154 bool ok = (gr_gs_min.is_topologically_closed())
155 && (gr_gs_needs_min.is_topologically_closed())
156 && (gr_cgs_needs_min.is_topologically_closed());
157
158 print_generators(gr_gs_min, "*** gr_gs_min ***");
159 print_generators(gr_gs_needs_min, "*** gr_gs_needs_min ***");
160 print_congruences(gr_cgs_needs_min, "*** gr_cgs_needs_min ***");
161
162 return ok;
163 }
164
165 // Rectilinear with lines.
166 bool
test07()167 test07() {
168 Variable A(0);
169 Variable B(1);
170 Variable C(2);
171
172 Grid gr_gs_min(3, EMPTY);
173 gr_gs_min.add_grid_generator(grid_point(3*A + 2*B));
174 gr_gs_min.add_grid_generator(grid_point(3*A + B));
175 gr_gs_min.add_grid_generator(grid_line(C));
176
177 Grid gr_gs_needs_min(3, EMPTY);
178 gr_gs_needs_min.add_grid_generator(grid_point(3*A + 2*B));
179 gr_gs_needs_min.add_grid_generator(grid_point(3*A + B));
180 gr_gs_needs_min.add_grid_generator(grid_line(C));
181
182 Grid gr_cgs_needs_min(3);
183 gr_cgs_needs_min.add_constraint(A == 3);
184 gr_cgs_needs_min.add_congruence(B %= 0);
185
186 // Grids gr_gs_min, gr_gs_needs_min and gr_cgs_needs_min are the
187 // same grids.
188
189 bool ok = (gr_gs_min.is_topologically_closed())
190 && (gr_gs_needs_min.is_topologically_closed())
191 && (gr_cgs_needs_min.is_topologically_closed());
192
193 print_generators(gr_gs_min, "*** gr_gs_min ***");
194 print_generators(gr_gs_needs_min, "*** gr_gs_needs_min ***");
195 print_congruences(gr_cgs_needs_min, "*** gr_cgs_needs_min ***");
196
197 return ok;
198 }
199
200 // Skew.
201 bool
test08()202 test08() {
203 Variable A(0);
204 Variable B(1);
205
206 Grid gr_gs_min(2, EMPTY);
207 gr_gs_min.add_grid_generator(grid_point());
208 gr_gs_min.add_grid_generator(grid_point(A));
209 gr_gs_min.add_grid_generator(grid_point(3*A + 3*B, 4));
210
211 Grid gr_gs_needs_min(2, EMPTY);
212 gr_gs_needs_min.add_grid_generator(grid_point());
213 gr_gs_needs_min.add_grid_generator(grid_point(A));
214 gr_gs_needs_min.add_grid_generator(grid_point(3*A + 3*B, 4));
215
216 Grid gr_cgs_needs_min(2);
217 gr_cgs_needs_min.add_congruence((4*B %= 0) / 3);
218 gr_cgs_needs_min.add_congruence(A - B %= 0);
219
220 // Grids gr_gs_min, gr_gs_needs_min and gr_cgs_needs_min are the
221 // same grids.
222
223 bool ok = (gr_gs_min.is_topologically_closed())
224 && (gr_gs_needs_min.is_topologically_closed())
225 && (gr_cgs_needs_min.is_topologically_closed());
226
227 print_generators(gr_gs_min, "*** gr_gs_min ***");
228 print_generators(gr_gs_needs_min, "*** gr_gs_needs_min ***");
229 print_congruences(gr_cgs_needs_min, "*** gr_cgs_needs_min ***");
230
231 return ok;
232 }
233
234 // Skew with lines.
235 bool
test09()236 test09() {
237 Variable A(0);
238 Variable B(1);
239 Variable C(2);
240
241 Grid gr_gs_min(3, EMPTY);
242 gr_gs_min.add_grid_generator(grid_point());
243 gr_gs_min.add_grid_generator(grid_point(A));
244 gr_gs_min.add_grid_generator(grid_line(C));
245 gr_gs_min.add_grid_generator(grid_point(3*A + 3*B, 4));
246
247 Grid gr_gs_needs_min(3, EMPTY);
248 gr_gs_needs_min.add_grid_generator(grid_point());
249 gr_gs_needs_min.add_grid_generator(grid_point(A));
250 gr_gs_needs_min.add_grid_generator(grid_line(C));
251 gr_gs_needs_min.add_grid_generator(grid_point(3*A + 3*B, 4));
252
253 Grid gr_cgs_needs_min(3);
254 gr_cgs_needs_min.add_congruence((4*B %= 0) / 3);
255 gr_cgs_needs_min.add_congruence(A - B %= 0);
256
257 // Grids gr_gs_min, gr_gs_needs_min and gr_cgs_needs_min are the
258 // same grids.
259
260 bool ok = (gr_gs_min.is_topologically_closed())
261 && (gr_gs_needs_min.is_topologically_closed())
262 && (gr_cgs_needs_min.is_topologically_closed());
263
264 print_generators(gr_gs_min, "*** gr_gs_min ***");
265 print_generators(gr_gs_needs_min, "*** gr_gs_needs_min ***");
266 print_congruences(gr_cgs_needs_min, "*** gr_cgs_needs_min ***");
267
268 return ok;
269 }
270
271 // Plane.
272 bool
test10()273 test10() {
274 Variable A(0);
275 Variable B(1);
276 Variable C(2);
277 Variable D(3);
278
279 Grid gr_gs_min(4, EMPTY);
280 gr_gs_min.add_grid_generator(grid_point());
281 gr_gs_min.add_grid_generator(grid_line(B));
282 gr_gs_min.add_grid_generator(grid_line(C));
283
284 Grid gr_gs_needs_min(4, EMPTY);
285 gr_gs_needs_min.add_grid_generator(grid_point());
286 gr_gs_needs_min.add_grid_generator(grid_line(B));
287 gr_gs_needs_min.add_grid_generator(grid_line(C));
288
289 Grid gr_cgs_needs_min(4);
290 gr_cgs_needs_min.add_constraint(A == 0);
291 gr_cgs_needs_min.add_constraint(D == 0);
292
293 // Grids gr_gs_min, gr_gs_needs_min and gr_cgs_needs_min are the
294 // same grids.
295
296 bool ok = (gr_gs_min.is_topologically_closed())
297 && (gr_gs_needs_min.is_topologically_closed())
298 && (gr_cgs_needs_min.is_topologically_closed());
299
300 print_generators(gr_gs_min, "*** gr_gs_min ***");
301 print_generators(gr_gs_needs_min, "*** gr_gs_needs_min ***");
302 print_congruences(gr_cgs_needs_min, "*** gr_cgs_needs_min ***");
303
304 return ok;
305 }
306
307 // Empty.
308 bool
test11()309 test11() {
310 Variable A(0);
311
312 Grid gr(3);
313 gr.add_constraint(A == 1);
314 gr.add_constraint(A == 2);
315
316 print_congruences(gr, "*** gr ***");
317
318 bool ok = (gr.is_topologically_closed());
319
320 return ok;
321 }
322
323 } // namespace
324
325 BEGIN_MAIN
326 DO_TEST(test01);
327 DO_TEST(test02);
328 DO_TEST(test03);
329 DO_TEST(test04);
330 DO_TEST(test05);
331 DO_TEST(test06);
332 DO_TEST(test07);
333 DO_TEST(test08);
334 DO_TEST(test09);
335 DO_TEST(test10);
336 DO_TEST(test11);
337 END_MAIN
338