1 /* Test Grid::generators().
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 grid.
29 bool
test01()30 test01() {
31 Grid gr1(7, EMPTY);
32
33 Grid known_gr = gr1;
34
35 Grid_Generator_System gs = gr1.grid_generators();
36
37 Grid gr2(gs);
38
39 bool ok = (gr2 == known_gr);
40
41 print_generators(gr2, "*** gr2 ***");
42
43 return ok;
44 }
45
46 // Universe grid.
47 bool
test02()48 test02() {
49 Grid gr1(7);
50
51 Grid known_gr = gr1;
52
53 Grid_Generator_System gs = gr1.grid_generators();
54
55 Grid gr2(gs);
56
57 bool ok = (gr2 == known_gr);
58
59 print_generators(gr2, "*** gr2 ***");
60
61 return ok;
62 }
63
64 // Zero dimension empty grid.
65 bool
test03()66 test03() {
67 Grid gr1(0, EMPTY);
68
69 Grid known_gr = gr1;
70
71 Grid_Generator_System gs = gr1.grid_generators();
72
73 Grid gr2(gs);
74
75 bool ok = (gr2 == known_gr);
76
77 print_generators(gr2, "*** gr2 ***");
78
79 return ok;
80 }
81
82 // Zero dimension universe grid.
83 bool
test04()84 test04() {
85 Grid gr1(0);
86
87 Grid known_gr = gr1;
88
89 Grid_Generator_System gs = gr1.grid_generators();
90
91 Grid gr2(gs);
92
93 bool ok = (gr2 == known_gr);
94
95 print_generators(gr2, "*** gr2 ***");
96
97 return ok;
98 }
99
100 // Skew grid in 3D.
101 bool
test05()102 test05() {
103 Variable A(0);
104 Variable B(1);
105 Variable C(2);
106
107 Grid gr1(3, EMPTY);
108 gr1.add_grid_generator(grid_point(3*B));
109 gr1.add_grid_generator(grid_point(5*A + 2*B));
110 gr1.add_grid_generator(grid_point(7*B));
111 gr1.add_grid_generator(grid_line(C));
112
113 Grid known_gr = gr1;
114
115 Grid_Generator_System gs = gr1.grid_generators();
116
117 Grid gr2(gs);
118
119 bool ok = (gr2 == known_gr);
120
121 print_generators(gr2, "*** gr2 ***");
122
123 return ok;
124 }
125
126 // 3D rectilinear grid defined by congruences.
127 bool
test06()128 test06() {
129 Variable A(0);
130 Variable B(1);
131
132 Grid gr1(3);
133 gr1.add_congruence((A %= 0) / 10);
134 gr1.add_congruence((B %= 10) / 0);
135
136 Grid known_gr = gr1;
137
138 Grid_Generator_System gs = gr1.grid_generators();
139
140 Grid gr2(gs);
141
142 bool ok = (gr2 == known_gr);
143
144 print_generators(gr2, "*** gr2 ***");
145
146 return ok;
147 }
148
149 // Get a reference to the empty generators, add a point, use the
150 // reference to create a new grid.
151 bool
test07()152 test07() {
153 Grid gr1(3, EMPTY);
154
155 const Grid_Generator_System& gs = gr1.grid_generators();
156
157 // Add a point. The idea is to check that `gs' still refers to a
158 // generator system that matches the grid.
159 gr1.add_grid_generator(grid_point());
160
161 Grid known_gr = gr1;
162
163 Grid gr2(gs);
164
165 bool ok = (gr2 == known_gr);
166
167 print_generators(gr2, "*** gr2 ***");
168
169 return ok;
170 }
171
172 // In zero dimensions get a reference to the universe generators,
173 // empty the grid, and then use the reference to create a new grid.
174 bool
test08()175 test08() {
176 Grid gr1(0);
177
178 const Grid_Generator_System& gs = gr1.grid_generators();
179
180 // Empty the grid. The idea is to check that `gs' still refers to a
181 // generator system that matches the grid.
182 gr1.add_congruence(Congruence::zero_dim_false());
183
184 Grid known_gr = gr1;
185
186 Grid gr2(gs);
187
188 bool ok = (gr2 == known_gr);
189
190 print_generators(gr2, "*** gr2 ***");
191
192 return ok;
193 }
194
195 // Empty grid, where updating the generators finds the grid empty.
196 bool
test09()197 test09() {
198 Variable A(0);
199
200 Grid gr1(7);
201 gr1.add_constraint(A == 1);
202 gr1.add_constraint(A == 0);
203
204 Grid known_gr = gr1;
205
206 Grid_Generator_System gs = gr1.grid_generators();
207
208 Grid gr2(gs);
209
210 bool ok = (gr2 == known_gr);
211
212 print_generators(gr2, "*** gr2 ***");
213
214 return ok;
215 }
216
217 // Skew grid in 3D defined with generators with a non-integral parameter.
218 bool
test10()219 test10() {
220 Variable A(0);
221 Variable B(1);
222 Variable C(2);
223
224 Grid gr1(3, EMPTY);
225 gr1.add_grid_generator(grid_point(3*B, 2));
226 gr1.add_grid_generator(grid_point(5*A + 2*B));
227 gr1.add_grid_generator(parameter(11*B, 2));
228 gr1.add_grid_generator(grid_line(C));
229
230 Grid known_gr = gr1;
231
232 Grid_Generator_System gs = gr1.grid_generators();
233
234 Grid gr2(gs);
235
236 bool ok = (gr2 == known_gr);
237
238 print_generators(gr2, "*** gr2 ***");
239
240 return ok;
241 }
242
243 // Grid defined with an integral point but non-integral parameter.
244 bool
test11()245 test11() {
246 Variable A(0);
247 Variable B(1);
248 Variable C(2);
249
250 Grid gr1(3, EMPTY);
251 gr1.add_grid_generator(grid_point(3*B));
252 gr1.add_grid_generator(grid_point(5*A + 2*B));
253 gr1.add_grid_generator(parameter(11*B, 2));
254 gr1.add_grid_generator(grid_line(C));
255
256 Grid known_gr = gr1;
257
258 Grid_Generator_System gs = gr1.grid_generators();
259
260 Grid gr2(gs);
261
262 bool ok = (gr2 == known_gr);
263
264 print_generators(gr2, "*** gr2 ***");
265
266 return ok;
267 }
268
269 // Grid defined with an integral point and parameter.
270 bool
test12()271 test12() {
272 Variable A(0);
273 Variable B(1);
274 Variable C(2);
275
276 Grid gr1(3, EMPTY);
277 gr1.add_grid_generator(grid_point(3*B));
278 gr1.add_grid_generator(grid_point(5*A + 2*B));
279 gr1.add_grid_generator(parameter(11*B));
280 gr1.add_grid_generator(grid_line(C));
281
282 Grid known_gr = gr1;
283
284 Grid_Generator_System gs = gr1.grid_generators();
285
286 Grid gr2(gs);
287
288 bool ok = (gr2 == known_gr);
289
290 print_generators(gr2, "*** gr2 ***");
291
292 return ok;
293 }
294
295 // inserted generator system has more space dimensions that
296 // the old generator system.
297 bool
test13()298 test13() {
299 Variable A(0);
300 Variable B(1);
301 Variable C(2);
302
303 Grid_Generator_System gs;
304 gs.insert(grid_point(3*A, 2));
305
306 Grid_Generator_System gs1;
307 gs1.insert(grid_point(5*A + 2*B, 3));
308 gs1.insert(parameter(11*C, 2));
309
310 gs.insert(gs1, Recycle_Input());
311
312 Grid gr(gs);
313
314 Grid known_gr(3, EMPTY);
315 known_gr.add_grid_generator(grid_point(3*A, 2));
316 known_gr.add_grid_generator(grid_point(5*A + 2*B, 3));
317 known_gr.add_grid_generator(parameter(11*C, 2));
318
319 bool ok = (gr == known_gr);
320
321 print_generators(gr, "*** gr ***");
322
323 return ok;
324 }
325
326 // test clear() for nonempty generator system.
327 bool
test14()328 test14() {
329 Variable A(0);
330 Variable B(1);
331 Variable C(2);
332
333 Grid_Generator_System gs;
334 gs.insert(grid_point(3*A, 2));
335 gs.insert(grid_point(5*A + 2*B, 3));
336 gs.insert(parameter(11*C, 2));
337
338 print_generators(gs, "*** gs ***");
339
340 gs.clear();
341
342 Grid gr(gs);
343
344 Grid known_gr(0, EMPTY);
345
346 bool ok = (gr == known_gr);
347
348 print_generators(gr, "*** gr ***");
349 nout << "gr.space_dimension = " << gr.space_dimension() << endl;
350
351 return ok;
352 }
353
354 // test clear() for empty generator system.
355 // This test showed a bug in the code for clear() in
356 // Grid_Generator_System_inlines.hh which is now corrected.
357 bool
test15()358 test15() {
359 Grid_Generator_System gs;
360
361 print_generators(gs, "*** gs ***");
362
363 gs.clear();
364
365 Grid gr(gs);
366
367 Grid known_gr(0, EMPTY);
368
369 bool ok = (gr == known_gr);
370
371 print_generators(gr, "*** gr ***");
372 nout << "gr.space_dimension = " << gr.space_dimension() << endl;
373
374 return ok;
375 }
376
377 // space_dimension
378 bool
test16()379 test16() {
380 Variable A(3);
381 Variable B(7);
382 Variable C(4);
383
384 Grid_Generator_System ggs(grid_point(A - 3*B + 21*C, 21));
385
386 bool ok = (ggs.space_dimension() == 8);
387
388 print_generators(ggs, "*** ggs ***");
389
390 return ok;
391 }
392
393 // Recycling_insert
394 bool
test17()395 test17() {
396 Variable A(0);
397 Variable B(1);
398 Variable C(2);
399
400 Grid_Generator_System ggs1;
401 ggs1.insert(parameter(11*B));
402 ggs1.insert(grid_line(C));
403 ggs1.insert(grid_point(3*B));
404
405 Grid_Generator_System ggs;
406 ggs.insert(ggs1, Recycle_Input());
407 print_generators(ggs, "*** ggs ***");
408
409 Grid gr(ggs);
410
411 Grid known_gr(3, EMPTY);
412 known_gr.add_grid_generator(grid_point(3*B));
413 known_gr.add_grid_generator(parameter(11*B));
414 known_gr.add_grid_generator(grid_line(C));
415
416 bool ok = (gr == known_gr);
417
418 print_generators(gr, "*** gr(ggs} ***");
419
420 return ok;
421 }
422
423 // Comparing Systems with different space dimensions
424 bool
test18()425 test18() {
426 Variable A(0);
427 Variable B(1);
428 Variable C(2);
429 Variable E(4);
430
431 Grid_Generator_System ggs;
432 ggs.insert(grid_point(3*B));
433 ggs.insert(grid_line(E));
434 print_generators(ggs, "*** ggs ***");
435
436 Grid gr(ggs);
437
438 Grid known_gr(3, EMPTY);
439 known_gr.add_grid_generator(grid_point(3*B));
440 known_gr.add_grid_generator(parameter(11*B));
441 known_gr.add_grid_generator(grid_line(C));
442
443 bool ok = (gr != known_gr);
444
445 print_generators(gr, "*** gr(ggs} ***");
446
447 return ok;
448 }
449
450 } // namespace
451
452 BEGIN_MAIN
453 DO_TEST(test01);
454 DO_TEST(test02);
455 DO_TEST(test03);
456 DO_TEST(test04);
457 DO_TEST(test05);
458 DO_TEST(test06);
459 DO_TEST(test07);
460 DO_TEST(test08);
461 DO_TEST(test09);
462 DO_TEST(test10);
463 DO_TEST(test11);
464 DO_TEST(test12);
465 DO_TEST_F8(test13);
466 DO_TEST(test14);
467 DO_TEST(test15);
468 DO_TEST(test16);
469 DO_TEST(test17);
470 DO_TEST(test18);
471 END_MAIN
472