1 /* Test BD_Shape::drop_some_non_integer_points().
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 bool
test01()29 test01() {
30 Variable A(0);
31 Variable B(1);
32
33 BD_Shape<mpq_class> bds(2);
34
35 bds.add_constraint(2*A >= 1);
36 bds.add_constraint(2*B >= -1);
37 bds.add_constraint(2*A - 2*B >= 1);
38
39 print_constraints(bds, "*** bds ***");
40
41 bds.drop_some_non_integer_points();
42
43 BD_Shape<mpq_class> known_result(2);
44 known_result.add_constraint(A >= 1);
45 known_result.add_constraint(B >= 0);
46 known_result.add_constraint(A - B >= 1);
47
48 bool ok = (bds == known_result);
49
50 print_constraints(bds, "*** after bds.drop_some_non_integer_points() ***");
51
52 return ok;
53 }
54
55 bool
test02()56 test02() {
57 BD_Shape<mpq_class> bds1;
58 BD_Shape<mpq_class> bds2(0, EMPTY);
59 BD_Shape<mpq_class> bds3(2, EMPTY);
60 BD_Shape<mpq_class> bds4(2);
61
62 print_constraints(bds1, "*** bds1 ***");
63 print_constraints(bds2, "*** bds2 ***");
64
65 BD_Shape<mpq_class> known_result1(bds1);
66 BD_Shape<mpq_class> known_result2(bds2);
67 BD_Shape<mpq_class> known_result3(bds3);
68 BD_Shape<mpq_class> known_result4(bds4);
69
70 bds1.drop_some_non_integer_points();
71 bds2.drop_some_non_integer_points();
72 bds3.drop_some_non_integer_points();
73 bds4.drop_some_non_integer_points();
74
75 bool ok = (bds1 == known_result1 && bds2 == known_result2
76 && bds3 == known_result3 && bds4 == known_result4);
77
78 print_constraints(bds1, "*** after bds1.drop_some_non_integer_points() ***");
79 print_constraints(bds2, "*** after bds2.drop_some_non_integer_points() ***");
80
81 return ok;
82 }
83
84 bool
test03()85 test03() {
86 Variable A(0);
87 Variable B(1);
88
89 BD_Shape<mpq_class> bds(2);
90 bds.add_constraint(A - B == 0);
91 bds.add_constraint(A >= 0);
92
93 BD_Shape<mpq_class> known_result(bds);
94
95 print_constraints(bds, "*** bds ***");
96
97 bds.drop_some_non_integer_points();
98
99 bool ok = (bds == known_result);
100
101 print_constraints(bds, "*** after bds.drop_some_non_integer_points() ***");
102
103 return ok;
104 }
105
106 bool
test04()107 test04() {
108 Variable A(0);
109 Variable B(1);
110
111 BD_Shape<mpq_class> bds(2);
112 bds.add_constraint(A >= 0);
113 bds.add_constraint(A == B);
114
115 print_constraints(bds, "*** bds ***");
116
117 bds.drop_some_non_integer_points();
118
119 BD_Shape<mpq_class> known_result(2);
120 known_result.add_constraint(A >= 0);
121 known_result.add_constraint(A == B);
122
123 bool ok = (bds == known_result);
124
125 print_constraints(bds, "*** after bds.drop_some_non_integer_points() ***");
126
127 return ok;
128 }
129
130 bool
test05()131 test05() {
132 Variable A(0);
133 Variable B(1);
134
135 BD_Shape<mpq_class> bds(2);
136 bds.add_constraint(2*A == 1);
137
138 print_constraints(bds, "*** bds ***");
139
140 bds.drop_some_non_integer_points();
141
142 BD_Shape<mpq_class> known_result(2, EMPTY);
143
144 bool ok = (bds == known_result);
145
146 print_constraints(bds, "*** after bds.drop_some_non_integer_points() ***");
147
148 return ok;
149 }
150
151 bool
test06()152 test06() {
153 Variable A(0);
154 Variable B(1);
155
156 BD_Shape<mpq_class> bds(2);
157 bds.add_constraint(2*A <= 1);
158 bds.add_constraint(2*B <= -1);
159 bds.add_constraint(4*A - 4*B <= 7);
160
161 print_constraints(bds, "*** bds ***");
162
163 bds.drop_some_non_integer_points();
164
165 BD_Shape<mpq_class> known_result(2);
166 known_result.add_constraint(A <= 0);
167 known_result.add_constraint(B <= -1);
168 known_result.add_constraint(A - B <= 1);
169
170 bool ok = (bds == known_result);
171
172 print_constraints(bds, "*** after bds.drop_some_non_integer_points() ***");
173
174 return ok;
175 }
176
177 bool
test07()178 test07() {
179 Variable A(0);
180 Variable B(1);
181 Variables_Set varset_A;
182 varset_A.insert(A);
183
184 BD_Shape<mpq_class> bds(2);
185
186 bds.add_constraint(2*A >= 1);
187 bds.add_constraint(2*B >= -1);
188 bds.add_constraint(2*A - 2*B >= 1);
189
190 print_constraints(bds, "*** bds ***");
191
192 bds.drop_some_non_integer_points(varset_A);
193
194 BD_Shape<mpq_class> known_result(2);
195 known_result.add_constraint(A >= 1);
196 known_result.add_constraint(2*B >= -1);
197 known_result.add_constraint(2*A - 2*B >= 1);
198
199 bool ok = (bds == known_result);
200
201 print_constraints(bds,
202 "*** after bds.drop_some_non_integer_points(varset_A) ***");
203
204 return ok;
205 }
206
207 bool
test08()208 test08() {
209 Variable A(0);
210 Variables_Set varset_A;
211 varset_A.insert(A);
212
213 BD_Shape<mpq_class> bds1(2, EMPTY);
214 BD_Shape<mpq_class> bds2(2);
215
216 print_constraints(bds1, "*** bds1 ***");
217 print_constraints(bds2, "*** bds2 ***");
218
219 BD_Shape<mpq_class> known_result1(bds1);
220 BD_Shape<mpq_class> known_result2(bds2);
221
222 bds1.drop_some_non_integer_points(varset_A);
223 bds2.drop_some_non_integer_points(varset_A);
224
225 bool ok = (bds1 == known_result1 && bds2 == known_result2);
226
227 print_constraints(bds1,
228 "*** after bds1.drop_some_non_integer_points(varset_A) ***");
229 print_constraints(bds2,
230 "*** after bds2.drop_some_non_integer_points(varset_A) ***");
231
232 return ok;
233 }
234
235 bool
test09()236 test09() {
237 Variable A(0);
238 Variable B(1);
239 Variables_Set varset_A;
240 varset_A.insert(A);
241
242 BD_Shape<mpq_class> bds(2);
243 bds.add_constraint(2*A - 2*B == 1);
244 bds.add_constraint(A >= 0);
245
246 BD_Shape<mpq_class> known_result(bds);
247
248 print_constraints(bds, "*** bds ***");
249
250 bds.drop_some_non_integer_points(varset_A);
251
252 bool ok = (bds == known_result);
253
254 print_constraints(bds,
255 "*** after bds.drop_some_non_integer_points(varset_A) ***");
256
257 return ok;
258 }
259
260 bool
test10()261 test10() {
262 Variable A(0);
263 Variable B(1);
264 Variables_Set varset_A;
265 varset_A.insert(A);
266
267 BD_Shape<mpq_class> bds(2);
268 bds.add_constraint(A >= 0);
269 bds.add_constraint(A == B);
270
271 print_constraints(bds, "*** bds ***");
272
273 bds.drop_some_non_integer_points(varset_A);
274
275 BD_Shape<mpq_class> known_result(2);
276 known_result.add_constraint(A >= 0);
277 known_result.add_constraint(A == B);
278
279 bool ok = (bds == known_result);
280
281 print_constraints(bds,
282 "*** after bds.drop_some_non_integer_points(varset_A) ***");
283
284 return ok;
285 }
286
287 bool
test11()288 test11() {
289 Variable A(0);
290 Variable B(1);
291 Variables_Set varset_B;
292 varset_B.insert(B);
293
294 BD_Shape<mpq_class> bds(2);
295 bds.add_constraint(2*A == 1);
296
297 print_constraints(bds, "*** bds ***");
298
299 bds.drop_some_non_integer_points(varset_B);
300
301 BD_Shape<mpq_class> known_result(2);
302 known_result.add_constraint(2*A == 1);
303
304 bool ok = (bds == known_result);
305
306 print_constraints(bds,
307 "*** after bds.drop_some_non_integer_points(varset_B) ***");
308
309 return ok;
310 }
311
312 bool
test12()313 test12() {
314 Variable A(0);
315 Variable B(1);
316 Variables_Set varset_A;
317 varset_A.insert(A);
318
319 BD_Shape<mpq_class> bds(2);
320 bds.add_constraint(2*A <= 1);
321 bds.add_constraint(2*B <= -1);
322 bds.add_constraint(4*A - 4*B <= 7);
323
324 print_constraints(bds, "*** bds ***");
325
326 bds.drop_some_non_integer_points(varset_A);
327
328 BD_Shape<mpq_class> known_result(2);
329 known_result.add_constraint(A <= 0);
330 known_result.add_constraint(2*B <= -1);
331 known_result.add_constraint(4*A - 4*B <= 7);
332
333 bool ok = (bds == known_result);
334
335 print_constraints(bds,
336 "*** after bds.drop_some_non_integer_points(varset_A) ***");
337
338 return ok;
339 }
340
341 } // namespace
342
343 BEGIN_MAIN
344 DO_TEST(test01);
345 DO_TEST(test02);
346 DO_TEST(test03);
347 DO_TEST(test04);
348 DO_TEST(test05);
349 DO_TEST(test06);
350 DO_TEST(test07);
351 DO_TEST(test08);
352 DO_TEST(test09);
353 DO_TEST(test10);
354 DO_TEST(test11);
355 DO_TEST(test12);
356 END_MAIN
357