add generic isl_map_project_out
[platform/upstream/isl.git] / isl_test.c
1 /*
2  * Copyright 2008-2009 Katholieke Universiteit Leuven
3  *
4  * Use of this software is governed by the GNU LGPLv2.1 license
5  *
6  * Written by Sven Verdoolaege, K.U.Leuven, Departement
7  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
8  */
9
10 #include <assert.h>
11 #include <stdio.h>
12 #include <limits.h>
13 #include <isl_ctx.h>
14 #include <isl_set.h>
15 #include <isl_constraint.h>
16
17 static char *srcdir;
18
19 void test_read(struct isl_ctx *ctx)
20 {
21         char filename[PATH_MAX];
22         FILE *input;
23         int n;
24         struct isl_basic_set *bset1, *bset2;
25         const char *str = "{[y]: Exists ( alpha : 2alpha = y)}";
26
27         n = snprintf(filename, sizeof(filename),
28                         "%s/test_inputs/set.omega", srcdir);
29         assert(n < sizeof(filename));
30         input = fopen(filename, "r");
31         assert(input);
32
33         bset1 = isl_basic_set_read_from_file(ctx, input, 0);
34         bset2 = isl_basic_set_read_from_str(ctx, str, 0);
35
36         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
37
38         isl_basic_set_free(bset1);
39         isl_basic_set_free(bset2);
40
41         fclose(input);
42 }
43
44 /* Construct the basic set { [i] : 5 <= i <= N } */
45 void test_construction(struct isl_ctx *ctx)
46 {
47         isl_int v;
48         struct isl_dim *dim;
49         struct isl_basic_set *bset;
50         struct isl_constraint *c;
51
52         isl_int_init(v);
53
54         dim = isl_dim_set_alloc(ctx, 1, 1);
55         bset = isl_basic_set_universe(dim);
56
57         c = isl_inequality_alloc(isl_dim_copy(bset->dim));
58         isl_int_set_si(v, -1);
59         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
60         isl_int_set_si(v, 1);
61         isl_constraint_set_coefficient(c, isl_dim_param, 0, v);
62         bset = isl_basic_set_add_constraint(bset, c);
63
64         c = isl_inequality_alloc(isl_dim_copy(bset->dim));
65         isl_int_set_si(v, 1);
66         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
67         isl_int_set_si(v, -5);
68         isl_constraint_set_constant(c, v);
69         bset = isl_basic_set_add_constraint(bset, c);
70
71         isl_basic_set_free(bset);
72
73         isl_int_clear(v);
74 }
75
76 void test_dim(struct isl_ctx *ctx)
77 {
78         isl_map *map1, *map2;
79
80         map1 = isl_map_read_from_str(ctx,
81             "[n] -> { [i] -> [j] : exists (a = [i/10] : i - 10a <= n ) }", -1);
82         map1 = isl_map_add(map1, isl_dim_in, 1);
83         map2 = isl_map_read_from_str(ctx,
84             "[n] -> { [i,k] -> [j] : exists (a = [i/10] : i - 10a <= n ) }", -1);
85         assert(isl_map_is_equal(map1, map2));
86         isl_map_free(map2);
87
88         map1 = isl_map_project_out(map1, isl_dim_in, 0, 1);
89         map2 = isl_map_read_from_str(ctx, "[n] -> { [i] -> [j] : n >= 0 }", -1);
90         assert(isl_map_is_equal(map1, map2));
91
92         isl_map_free(map1);
93         isl_map_free(map2);
94 }
95
96 void test_div(struct isl_ctx *ctx)
97 {
98         isl_int v;
99         int pos;
100         struct isl_dim *dim;
101         struct isl_div *div;
102         struct isl_basic_set *bset;
103         struct isl_constraint *c;
104
105         isl_int_init(v);
106
107         /* test 1 */
108         dim = isl_dim_set_alloc(ctx, 0, 1);
109         bset = isl_basic_set_universe(dim);
110
111         c = isl_equality_alloc(isl_dim_copy(bset->dim));
112         isl_int_set_si(v, -1);
113         isl_constraint_set_constant(c, v);
114         isl_int_set_si(v, 1);
115         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
116         div = isl_div_alloc(isl_dim_copy(bset->dim));
117         c = isl_constraint_add_div(c, div, &pos);
118         isl_int_set_si(v, 3);
119         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
120         bset = isl_basic_set_add_constraint(bset, c);
121
122         c = isl_equality_alloc(isl_dim_copy(bset->dim));
123         isl_int_set_si(v, 1);
124         isl_constraint_set_constant(c, v);
125         isl_int_set_si(v, -1);
126         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
127         div = isl_div_alloc(isl_dim_copy(bset->dim));
128         c = isl_constraint_add_div(c, div, &pos);
129         isl_int_set_si(v, 3);
130         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
131         bset = isl_basic_set_add_constraint(bset, c);
132
133         assert(bset->n_div == 1);
134         isl_basic_set_free(bset);
135
136         /* test 2 */
137         dim = isl_dim_set_alloc(ctx, 0, 1);
138         bset = isl_basic_set_universe(dim);
139
140         c = isl_equality_alloc(isl_dim_copy(bset->dim));
141         isl_int_set_si(v, 1);
142         isl_constraint_set_constant(c, v);
143         isl_int_set_si(v, -1);
144         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
145         div = isl_div_alloc(isl_dim_copy(bset->dim));
146         c = isl_constraint_add_div(c, div, &pos);
147         isl_int_set_si(v, 3);
148         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
149         bset = isl_basic_set_add_constraint(bset, c);
150
151         c = isl_equality_alloc(isl_dim_copy(bset->dim));
152         isl_int_set_si(v, -1);
153         isl_constraint_set_constant(c, v);
154         isl_int_set_si(v, 1);
155         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
156         div = isl_div_alloc(isl_dim_copy(bset->dim));
157         c = isl_constraint_add_div(c, div, &pos);
158         isl_int_set_si(v, 3);
159         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
160         bset = isl_basic_set_add_constraint(bset, c);
161
162         assert(bset->n_div == 1);
163         isl_basic_set_free(bset);
164
165         /* test 3 */
166         dim = isl_dim_set_alloc(ctx, 0, 1);
167         bset = isl_basic_set_universe(dim);
168
169         c = isl_equality_alloc(isl_dim_copy(bset->dim));
170         isl_int_set_si(v, 1);
171         isl_constraint_set_constant(c, v);
172         isl_int_set_si(v, -1);
173         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
174         div = isl_div_alloc(isl_dim_copy(bset->dim));
175         c = isl_constraint_add_div(c, div, &pos);
176         isl_int_set_si(v, 3);
177         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
178         bset = isl_basic_set_add_constraint(bset, c);
179
180         c = isl_equality_alloc(isl_dim_copy(bset->dim));
181         isl_int_set_si(v, -3);
182         isl_constraint_set_constant(c, v);
183         isl_int_set_si(v, 1);
184         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
185         div = isl_div_alloc(isl_dim_copy(bset->dim));
186         c = isl_constraint_add_div(c, div, &pos);
187         isl_int_set_si(v, 4);
188         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
189         bset = isl_basic_set_add_constraint(bset, c);
190
191         assert(bset->n_div == 1);
192         isl_basic_set_free(bset);
193
194         /* test 4 */
195         dim = isl_dim_set_alloc(ctx, 0, 1);
196         bset = isl_basic_set_universe(dim);
197
198         c = isl_equality_alloc(isl_dim_copy(bset->dim));
199         isl_int_set_si(v, 2);
200         isl_constraint_set_constant(c, v);
201         isl_int_set_si(v, -1);
202         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
203         div = isl_div_alloc(isl_dim_copy(bset->dim));
204         c = isl_constraint_add_div(c, div, &pos);
205         isl_int_set_si(v, 3);
206         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
207         bset = isl_basic_set_add_constraint(bset, c);
208
209         c = isl_equality_alloc(isl_dim_copy(bset->dim));
210         isl_int_set_si(v, -1);
211         isl_constraint_set_constant(c, v);
212         isl_int_set_si(v, 1);
213         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
214         div = isl_div_alloc(isl_dim_copy(bset->dim));
215         c = isl_constraint_add_div(c, div, &pos);
216         isl_int_set_si(v, 6);
217         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
218         bset = isl_basic_set_add_constraint(bset, c);
219
220         assert(isl_basic_set_is_empty(bset));
221         isl_basic_set_free(bset);
222
223         /* test 5 */
224         dim = isl_dim_set_alloc(ctx, 0, 2);
225         bset = isl_basic_set_universe(dim);
226
227         c = isl_equality_alloc(isl_dim_copy(bset->dim));
228         isl_int_set_si(v, -1);
229         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
230         div = isl_div_alloc(isl_dim_copy(bset->dim));
231         c = isl_constraint_add_div(c, div, &pos);
232         isl_int_set_si(v, 3);
233         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
234         bset = isl_basic_set_add_constraint(bset, c);
235
236         c = isl_equality_alloc(isl_dim_copy(bset->dim));
237         isl_int_set_si(v, 1);
238         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
239         isl_int_set_si(v, -3);
240         isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
241         bset = isl_basic_set_add_constraint(bset, c);
242
243         assert(bset->n_div == 0);
244         isl_basic_set_free(bset);
245
246         /* test 6 */
247         dim = isl_dim_set_alloc(ctx, 0, 2);
248         bset = isl_basic_set_universe(dim);
249
250         c = isl_equality_alloc(isl_dim_copy(bset->dim));
251         isl_int_set_si(v, -1);
252         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
253         div = isl_div_alloc(isl_dim_copy(bset->dim));
254         c = isl_constraint_add_div(c, div, &pos);
255         isl_int_set_si(v, 6);
256         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
257         bset = isl_basic_set_add_constraint(bset, c);
258
259         c = isl_equality_alloc(isl_dim_copy(bset->dim));
260         isl_int_set_si(v, 1);
261         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
262         isl_int_set_si(v, -3);
263         isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
264         bset = isl_basic_set_add_constraint(bset, c);
265
266         assert(bset->n_div == 1);
267         isl_basic_set_free(bset);
268
269         /* test 7 */
270         /* This test is a bit tricky.  We set up an equality
271          *              a + 3b + 3c = 6 e0
272          * Normalization of divs creates _two_ divs
273          *              a = 3 e0
274          *              c - b - e0 = 2 e1
275          * Afterwards e0 is removed again because it has coefficient -1
276          * and we end up with the original equality and div again.
277          * Perhaps we can avoid the introduction of this temporary div.
278          */
279         dim = isl_dim_set_alloc(ctx, 0, 3);
280         bset = isl_basic_set_universe(dim);
281
282         c = isl_equality_alloc(isl_dim_copy(bset->dim));
283         isl_int_set_si(v, -1);
284         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
285         isl_int_set_si(v, -3);
286         isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
287         isl_int_set_si(v, -3);
288         isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
289         div = isl_div_alloc(isl_dim_copy(bset->dim));
290         c = isl_constraint_add_div(c, div, &pos);
291         isl_int_set_si(v, 6);
292         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
293         bset = isl_basic_set_add_constraint(bset, c);
294
295         assert(bset->n_div == 1);
296         isl_basic_set_free(bset);
297
298         /* test 8 */
299         dim = isl_dim_set_alloc(ctx, 0, 4);
300         bset = isl_basic_set_universe(dim);
301
302         c = isl_equality_alloc(isl_dim_copy(bset->dim));
303         isl_int_set_si(v, -1);
304         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
305         isl_int_set_si(v, -3);
306         isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
307         isl_int_set_si(v, -3);
308         isl_constraint_set_coefficient(c, isl_dim_set, 3, v);
309         div = isl_div_alloc(isl_dim_copy(bset->dim));
310         c = isl_constraint_add_div(c, div, &pos);
311         isl_int_set_si(v, 6);
312         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
313         bset = isl_basic_set_add_constraint(bset, c);
314
315         c = isl_equality_alloc(isl_dim_copy(bset->dim));
316         isl_int_set_si(v, -1);
317         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
318         isl_int_set_si(v, 1);
319         isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
320         isl_int_set_si(v, 1);
321         isl_constraint_set_constant(c, v);
322         bset = isl_basic_set_add_constraint(bset, c);
323
324         assert(bset->n_div == 1);
325         isl_basic_set_free(bset);
326
327         /* test 9 */
328         dim = isl_dim_set_alloc(ctx, 0, 2);
329         bset = isl_basic_set_universe(dim);
330
331         c = isl_equality_alloc(isl_dim_copy(bset->dim));
332         isl_int_set_si(v, 1);
333         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
334         isl_int_set_si(v, -1);
335         isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
336         div = isl_div_alloc(isl_dim_copy(bset->dim));
337         c = isl_constraint_add_div(c, div, &pos);
338         isl_int_set_si(v, -2);
339         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
340         bset = isl_basic_set_add_constraint(bset, c);
341
342         c = isl_equality_alloc(isl_dim_copy(bset->dim));
343         isl_int_set_si(v, -1);
344         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
345         div = isl_div_alloc(isl_dim_copy(bset->dim));
346         c = isl_constraint_add_div(c, div, &pos);
347         isl_int_set_si(v, 3);
348         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
349         isl_int_set_si(v, 2);
350         isl_constraint_set_constant(c, v);
351         bset = isl_basic_set_add_constraint(bset, c);
352
353         bset = isl_basic_set_fix_si(bset, isl_dim_set, 0, 2);
354
355         assert(!isl_basic_set_is_empty(bset));
356
357         isl_basic_set_free(bset);
358
359         /* test 10 */
360         dim = isl_dim_set_alloc(ctx, 0, 2);
361         bset = isl_basic_set_universe(dim);
362
363         c = isl_equality_alloc(isl_dim_copy(bset->dim));
364         isl_int_set_si(v, 1);
365         isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
366         div = isl_div_alloc(isl_dim_copy(bset->dim));
367         c = isl_constraint_add_div(c, div, &pos);
368         isl_int_set_si(v, -2);
369         isl_constraint_set_coefficient(c, isl_dim_div, pos, v);
370         bset = isl_basic_set_add_constraint(bset, c);
371
372         bset = isl_basic_set_fix_si(bset, isl_dim_set, 0, 2);
373
374         isl_basic_set_free(bset);
375
376         isl_int_clear(v);
377 }
378
379 void test_application_case(struct isl_ctx *ctx, const char *name)
380 {
381         char filename[PATH_MAX];
382         FILE *input;
383         int n;
384         struct isl_basic_set *bset1, *bset2;
385         struct isl_basic_map *bmap;
386
387         n = snprintf(filename, sizeof(filename),
388                         "%s/test_inputs/%s.omega", srcdir, name);
389         assert(n < sizeof(filename));
390         input = fopen(filename, "r");
391         assert(input);
392
393         bset1 = isl_basic_set_read_from_file(ctx, input, 0);
394         bmap = isl_basic_map_read_from_file(ctx, input, 0);
395
396         bset1 = isl_basic_set_apply(bset1, bmap);
397
398         bset2 = isl_basic_set_read_from_file(ctx, input, 0);
399
400         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
401
402         isl_basic_set_free(bset1);
403         isl_basic_set_free(bset2);
404
405         fclose(input);
406 }
407
408 void test_application(struct isl_ctx *ctx)
409 {
410         test_application_case(ctx, "application");
411         test_application_case(ctx, "application2");
412 }
413
414 void test_affine_hull_case(struct isl_ctx *ctx, const char *name)
415 {
416         char filename[PATH_MAX];
417         FILE *input;
418         int n;
419         struct isl_basic_set *bset1, *bset2;
420
421         n = snprintf(filename, sizeof(filename),
422                         "%s/test_inputs/%s.polylib", srcdir, name);
423         assert(n < sizeof(filename));
424         input = fopen(filename, "r");
425         assert(input);
426
427         bset1 = isl_basic_set_read_from_file(ctx, input, 0);
428         bset2 = isl_basic_set_read_from_file(ctx, input, 0);
429
430         bset1 = isl_basic_set_affine_hull(bset1);
431
432         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
433
434         isl_basic_set_free(bset1);
435         isl_basic_set_free(bset2);
436
437         fclose(input);
438 }
439
440 void test_affine_hull(struct isl_ctx *ctx)
441 {
442         test_affine_hull_case(ctx, "affine2");
443         test_affine_hull_case(ctx, "affine");
444         test_affine_hull_case(ctx, "affine3");
445 }
446
447 void test_convex_hull_case(struct isl_ctx *ctx, const char *name)
448 {
449         char filename[PATH_MAX];
450         FILE *input;
451         int n;
452         struct isl_basic_set *bset1, *bset2;
453         struct isl_set *set;
454
455         n = snprintf(filename, sizeof(filename),
456                         "%s/test_inputs/%s.polylib", srcdir, name);
457         assert(n < sizeof(filename));
458         input = fopen(filename, "r");
459         assert(input);
460
461         bset1 = isl_basic_set_read_from_file(ctx, input, 0);
462         bset2 = isl_basic_set_read_from_file(ctx, input, 0);
463
464         set = isl_basic_set_union(bset1, bset2);
465         bset1 = isl_set_convex_hull(set);
466
467         bset2 = isl_basic_set_read_from_file(ctx, input, 0);
468
469         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
470
471         isl_basic_set_free(bset1);
472         isl_basic_set_free(bset2);
473
474         fclose(input);
475 }
476
477 void test_convex_hull(struct isl_ctx *ctx)
478 {
479         test_convex_hull_case(ctx, "convex0");
480         test_convex_hull_case(ctx, "convex1");
481         test_convex_hull_case(ctx, "convex2");
482         test_convex_hull_case(ctx, "convex3");
483         test_convex_hull_case(ctx, "convex4");
484         test_convex_hull_case(ctx, "convex5");
485         test_convex_hull_case(ctx, "convex6");
486         test_convex_hull_case(ctx, "convex7");
487         test_convex_hull_case(ctx, "convex8");
488         test_convex_hull_case(ctx, "convex9");
489         test_convex_hull_case(ctx, "convex10");
490         test_convex_hull_case(ctx, "convex11");
491         test_convex_hull_case(ctx, "convex12");
492         test_convex_hull_case(ctx, "convex13");
493         test_convex_hull_case(ctx, "convex14");
494 }
495
496 void test_gist_case(struct isl_ctx *ctx, const char *name)
497 {
498         char filename[PATH_MAX];
499         FILE *input;
500         int n;
501         struct isl_basic_set *bset1, *bset2;
502
503         n = snprintf(filename, sizeof(filename),
504                         "%s/test_inputs/%s.polylib", srcdir, name);
505         assert(n < sizeof(filename));
506         input = fopen(filename, "r");
507         assert(input);
508
509         bset1 = isl_basic_set_read_from_file(ctx, input, 0);
510         bset2 = isl_basic_set_read_from_file(ctx, input, 0);
511
512         bset1 = isl_basic_set_gist(bset1, bset2);
513
514         bset2 = isl_basic_set_read_from_file(ctx, input, 0);
515
516         assert(isl_basic_set_is_equal(bset1, bset2) == 1);
517
518         isl_basic_set_free(bset1);
519         isl_basic_set_free(bset2);
520
521         fclose(input);
522 }
523
524 void test_gist(struct isl_ctx *ctx)
525 {
526         test_gist_case(ctx, "gist1");
527 }
528
529 void test_coalesce(struct isl_ctx *ctx)
530 {
531         struct isl_set *set;
532
533         set = isl_set_read_from_str(ctx,
534                 "{[x,y]: x >= 0 & x <= 10 & y >= 0 & y <= 10 or "
535                        "y >= x & x >= 2 & 5 >= y }", -1);
536         set = isl_set_coalesce(set);
537         assert(set && set->n == 1);
538         isl_set_free(set);
539
540         set = isl_set_read_from_str(ctx,
541                 "{[x,y]: y >= 0 & 2x + y <= 30 & y <= 10 & x >= 0 or "
542                        "x + y >= 10 & y <= x & x + y <= 20 & y >= 0}", -1);
543         set = isl_set_coalesce(set);
544         assert(set && set->n == 1);
545         isl_set_free(set);
546
547         set = isl_set_read_from_str(ctx,
548                 "{[x,y]: y >= 0 & 2x + y <= 30 & y <= 10 & x >= 0 or "
549                        "x + y >= 10 & y <= x & x + y <= 19 & y >= 0}", -1);
550         set = isl_set_coalesce(set);
551         assert(set && set->n == 2);
552         isl_set_free(set);
553
554         set = isl_set_read_from_str(ctx,
555                 "{[x,y]: y >= 0 & x <= 5 & y <= x or "
556                        "y >= 0 & x >= 6 & x <= 10 & y <= x}", -1);
557         set = isl_set_coalesce(set);
558         assert(set && set->n == 1);
559         isl_set_free(set);
560
561         set = isl_set_read_from_str(ctx,
562                 "{[x,y]: y >= 0 & x <= 5 & y <= x or "
563                        "y >= 0 & x >= 7 & x <= 10 & y <= x}", -1);
564         set = isl_set_coalesce(set);
565         assert(set && set->n == 2);
566         isl_set_free(set);
567
568         set = isl_set_read_from_str(ctx,
569                 "{[x,y]: y >= 0 & x <= 5 & y <= x or "
570                        "y >= 0 & x >= 6 & x <= 10 & y + 1 <= x}", -1);
571         set = isl_set_coalesce(set);
572         assert(set && set->n == 2);
573         isl_set_free(set);
574
575         set = isl_set_read_from_str(ctx,
576                 "{[x,y]: y >= 0 & x <= 5 & y <= x or "
577                        "y >= 0 & x = 6 & y <= 6}", -1);
578         set = isl_set_coalesce(set);
579         assert(set && set->n == 1);
580         isl_set_free(set);
581
582         set = isl_set_read_from_str(ctx,
583                 "{[x,y]: y >= 0 & x <= 5 & y <= x or "
584                        "y >= 0 & x = 7 & y <= 6}", -1);
585         set = isl_set_coalesce(set);
586         assert(set && set->n == 2);
587         isl_set_free(set);
588
589         set = isl_set_read_from_str(ctx,
590                 "{[x,y]: y >= 0 & x <= 5 & y <= x or "
591                        "y >= 0 & x = 6 & y <= 5}", -1);
592         set = isl_set_coalesce(set);
593         assert(set && set->n == 2);
594         isl_set_free(set);
595
596         set = isl_set_read_from_str(ctx,
597                 "{[x,y]: y >= 0 & x <= 5 & y <= x or "
598                        "y >= 0 & x = 6 & y <= 7}", -1);
599         set = isl_set_coalesce(set);
600         assert(set && set->n == 2);
601         isl_set_free(set);
602 }
603
604 int main()
605 {
606         struct isl_ctx *ctx;
607
608         srcdir = getenv("srcdir");
609         assert(srcdir);
610
611         ctx = isl_ctx_alloc();
612         test_read(ctx);
613         test_construction(ctx);
614         test_dim(ctx);
615         test_div(ctx);
616         test_application(ctx);
617         test_affine_hull(ctx);
618         test_convex_hull(ctx);
619         test_gist(ctx);
620         test_coalesce(ctx);
621         isl_ctx_free(ctx);
622         return 0;
623 }