1/*
2 * Copyright 2008-2009 Katholieke Universiteit Leuven
3 * Copyright 2010 INRIA Saclay
4 * Copyright 2012-2013 Ecole Normale Superieure
5 * Copyright 2014 INRIA Rocquencourt
6 * Copyright 2022 Cerebras Systems
7 *
8 * Use of this software is governed by the MIT license
9 *
10 * Written by Sven Verdoolaege, K.U.Leuven, Departement
11 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
12 * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
13 * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
14 * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
15 * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
16 * B.P. 105 - 78153 Le Chesnay, France
17 * and Cerebras Systems, 1237 E Arques Ave, Sunnyvale, CA, USA
18 */
19
20#include <assert.h>
21#include <stdio.h>
22#include <limits.h>
23#include <isl_ctx_private.h>
24#include <isl_map_private.h>
25#include <isl_aff_private.h>
26#include <isl_space_private.h>
27#include <isl/id.h>
28#include <isl/set.h>
29#include <isl/flow.h>
30#include <isl_constraint_private.h>
31#include <isl/polynomial.h>
32#include <isl/union_set.h>
33#include <isl/union_map.h>
34#include <isl_factorization.h>
35#include <isl/schedule.h>
36#include <isl/schedule_node.h>
37#include <isl_options_private.h>
38#include <isl_vertices_private.h>
39#include <isl/ast_build.h>
40#include <isl/val.h>
41#include <isl/ilp.h>
42#include <isl_ast_build_expr.h>
43#include <isl/options.h>
44
45#include "isl_srcdir.c"
46
47#define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
48
49static char *get_filename(isl_ctx *ctx, const char *name, const char *suffix) {
50 char *filename;
51 int length;
52 char *pattern = "%s/test_inputs/%s.%s";
53
54 length = strlen(s: pattern) - 6 + strlen(s: srcdir) + strlen(s: name)
55 + strlen(s: suffix) + 1;
56 filename = isl_alloc_array(ctx, char, length);
57
58 if (!filename)
59 return NULL;
60
61 sprintf(s: filename, format: pattern, srcdir, name, suffix);
62
63 return filename;
64}
65
66void test_parse_map(isl_ctx *ctx, const char *str)
67{
68 isl_map *map;
69
70 map = isl_map_read_from_str(ctx, str);
71 assert(map);
72 isl_map_free(map);
73}
74
75int test_parse_map_equal(isl_ctx *ctx, const char *str, const char *str2)
76{
77 isl_map *map, *map2;
78 int equal;
79
80 map = isl_map_read_from_str(ctx, str);
81 map2 = isl_map_read_from_str(ctx, str: str2);
82 equal = isl_map_is_equal(map1: map, map2);
83 isl_map_free(map);
84 isl_map_free(map: map2);
85
86 if (equal < 0)
87 return -1;
88 if (!equal)
89 isl_die(ctx, isl_error_unknown, "maps not equal",
90 return -1);
91
92 return 0;
93}
94
95void test_parse_pwqp(isl_ctx *ctx, const char *str)
96{
97 isl_pw_qpolynomial *pwqp;
98
99 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
100 assert(pwqp);
101 isl_pw_qpolynomial_free(pwqp);
102}
103
104static void test_parse_pwaff(isl_ctx *ctx, const char *str)
105{
106 isl_pw_aff *pwaff;
107
108 pwaff = isl_pw_aff_read_from_str(ctx, str);
109 assert(pwaff);
110 isl_pw_aff_free(pwaff);
111}
112
113/* Check that we can read an isl_multi_val from "str" without errors.
114 */
115static int test_parse_multi_val(isl_ctx *ctx, const char *str)
116{
117 isl_multi_val *mv;
118
119 mv = isl_multi_val_read_from_str(ctx, str);
120 isl_multi_val_free(multi: mv);
121
122 return mv ? 0 : -1;
123}
124
125/* String descriptions of multi piecewise affine expressions
126 * that are used for testing printing and parsing.
127 */
128static const char *reparse_multi_pw_aff_tests[] = {
129 "{ A[x, y] -> [] : x + y >= 0 }",
130 "{ A[x, y] -> B[] : x + y >= 0 }",
131 "{ A[x, y] -> [x] : x + y >= 0 }",
132 "[N] -> { A[x, y] -> [x] : x + y <= N }",
133 "{ A[x, y] -> [x, y] : x + y >= 0 }",
134 "{ A[x, y] -> [(x : x >= 0), (y : y >= 0)] : x + y >= 0 }",
135 "[N] -> { [] : N >= 0 }",
136 "[N] -> { [] : N >= 0 }",
137 "[N] -> { [N] : N >= 0 }",
138 "[N] -> { [N, N + 1] : N >= 0 }",
139 "[N, M] -> { [(N : N >= 0), (M : M >= 0)] : N + M >= 0 }",
140 "{ [a] -> [b = a] }",
141 "{ [a] -> [b = a] : a >= 0 }",
142};
143
144#undef BASE
145#define BASE multi_pw_aff
146
147#include "check_reparse_templ.c"
148#include "check_reparse_test_templ.c"
149
150/* String descriptions that cannot be parsed
151 * as multi piecewise affine expressions.
152 */
153static const char *parse_multi_pw_aff_fail_tests[] = {
154 "{ [a] -> [b] : b = a }",
155 "{ [a] -> [b = a] : b >= 0 }",
156};
157
158#include "check_parse_fail_test_templ.c"
159
160/* String descriptions of piecewise multi affine expressions
161 * that are used for testing printing and parsing.
162 */
163static const char *reparse_pw_multi_aff_tests[] = {
164 "{ [x] -> [x] }",
165 "{ [x] -> [x % 4] }",
166 "{ [x] -> [x % 4] : x mod 3 = 1 }",
167 "{ [x, x] -> [x % 4] }",
168 "{ [x, x + 1] -> [x % 4] : x mod 3 = 1 }",
169 "{ [x, x mod 2] -> [x % 4] }",
170 "{ [a] -> [a//2] : exists (e0: 8*floor((-a + e0)/8) <= -8 - a + 8e0) }",
171};
172
173#undef BASE
174#define BASE pw_multi_aff
175
176#include "check_reparse_templ.c"
177#include "check_reparse_test_templ.c"
178
179/* Test parsing of piecewise multi affine expressions by printing
180 * the expressions and checking that parsing the output results
181 * in the same expression.
182 * Do this for an expression converted from a map with an output
183 * dimension name that is equal to an automatically generated name, and
184 * a set of expressions parsed from strings.
185 */
186static isl_stat test_parse_pma(isl_ctx *ctx)
187{
188 isl_map *map;
189 isl_pw_multi_aff *pma;
190
191 map = isl_map_read_from_str(ctx, str: "{ [a, a] -> [i1 = a + 1] }");
192 pma = isl_pw_multi_aff_from_map(map);
193 if (check_reparse_pw_multi_aff(ctx, obj: pma) < 0)
194 return isl_stat_error;
195
196 if (check_reparse_pw_multi_aff_tests(ctx) < 0)
197 return isl_stat_error;
198
199 return isl_stat_ok;
200}
201
202/* String descriptions that cannot be parsed
203 * as union piecewise multi affine expressions.
204 */
205static const char *parse_union_pw_multi_aff_fail_tests[] = {
206 "{ [a] -> [b] : b = a }",
207 "{ [a] -> [b = a] : b >= 0 }",
208};
209
210#undef BASE
211#define BASE union_pw_multi_aff
212
213#include "check_parse_fail_test_templ.c"
214
215/* Test parsing of union piecewise multi affine expressions.
216 *
217 * In particular, check some cases where parsing is supposed to fail.
218 */
219static isl_stat test_parse_upma(isl_ctx *ctx)
220{
221 if (check_parse_union_pw_multi_aff_fail_tests(ctx) < 0)
222 return isl_stat_error;
223
224 return isl_stat_ok;
225}
226
227/* Test parsing of multi piecewise affine expressions by printing
228 * the expressions and checking that parsing the output results
229 * in the same expression.
230 * Do this for a couple of manually constructed expressions,
231 * an expression converted from a map with an output dimension name
232 * that is equal to an automatically generated name, and
233 * a set of expressions parsed from strings.
234 *
235 * Additionally, check some cases where parsing is supposed to fail.
236 */
237static int test_parse_mpa(isl_ctx *ctx)
238{
239 isl_space *space;
240 isl_set *dom;
241 isl_map *map;
242 isl_pw_multi_aff *pma;
243 isl_multi_pw_aff *mpa;
244 isl_stat r;
245
246 space = isl_space_set_alloc(ctx, nparam: 0, dim: 0);
247 space = isl_space_set_tuple_name(space, type: isl_dim_set, s: "A");
248 mpa = isl_multi_pw_aff_zero(space);
249 r = check_reparse_multi_pw_aff(ctx, obj: mpa);
250 if (r < 0)
251 return -1;
252
253 space = isl_space_set_alloc(ctx, nparam: 1, dim: 0);
254 space = isl_space_set_dim_name(space, type: isl_dim_param, pos: 0, name: "N");
255 space = isl_space_set_tuple_name(space, type: isl_dim_set, s: "A");
256 dom = isl_set_universe(space: isl_space_params(space: isl_space_copy(space)));
257 dom = isl_set_lower_bound_si(set: dom, type: isl_dim_param, pos: 0, value: 5);
258 mpa = isl_multi_pw_aff_zero(space);
259 mpa = isl_multi_pw_aff_intersect_domain(mpa, domain: dom);
260 r = check_reparse_multi_pw_aff(ctx, obj: mpa);
261 if (r < 0)
262 return -1;
263
264 map = isl_map_read_from_str(ctx, str: "{ [a, a] -> [i1 = a + 1] }");
265 pma = isl_pw_multi_aff_from_map(map);
266 mpa = isl_multi_pw_aff_from_pw_multi_aff(pma);
267 if (check_reparse_multi_pw_aff(ctx, obj: mpa) < 0)
268 return -1;
269
270 if (check_reparse_multi_pw_aff_tests(ctx) < 0)
271 return -1;
272 if (check_parse_multi_pw_aff_fail_tests(ctx) < 0)
273 return -1;
274
275 return 0;
276}
277
278/* String descriptions of multi union piecewise affine expressions
279 * that are used for testing printing and parsing.
280 */
281static const char *reparse_multi_union_pw_aff_tests[] = {
282 "[]",
283 "A[]",
284 "A[B[] -> C[]]",
285 "(A[] : { S[x] : x > 0; T[y] : y >= 0 })",
286 "(A[] : { })",
287 "[N] -> (A[] : { })",
288 "[N] -> (A[] : { : N >= 0 })",
289 "[N] -> (A[] : { S[x] : x > N; T[y] : y >= 0 })",
290 "(A[] : [N] -> { S[x] : x > N; T[y] : y >= 0 })",
291 "A[{ S[x] -> [x + 1]; T[x] -> [x] }]",
292 "(A[{ S[x] -> [x + 1]; T[x] -> [x] }] : "
293 "{ S[x] : x > 0; T[y] : y >= 0 })",
294};
295
296#undef BASE
297#define BASE multi_union_pw_aff
298
299#include "check_reparse_templ.c"
300#include "check_reparse_test_templ.c"
301
302/* Test parsing of multi union piecewise affine expressions by printing
303 * the expressions and checking that parsing the output results
304 * in the same expression.
305 * Do this for a couple of manually constructed expressions and
306 * a set of expressions parsed from strings.
307 */
308static int test_parse_mupa(isl_ctx *ctx)
309{
310 isl_space *space;
311 isl_multi_union_pw_aff *mupa;
312 isl_set *dom;
313 isl_union_set *uset;
314 isl_stat r;
315
316 space = isl_space_set_alloc(ctx, nparam: 0, dim: 0);
317 space = isl_space_set_tuple_name(space, type: isl_dim_set, s: "A");
318 mupa = isl_multi_union_pw_aff_zero(space);
319 r = check_reparse_multi_union_pw_aff(ctx, obj: mupa);
320 if (r < 0)
321 return -1;
322
323 space = isl_space_set_alloc(ctx, nparam: 1, dim: 0);
324 space = isl_space_set_dim_name(space, type: isl_dim_param, pos: 0, name: "N");
325 space = isl_space_set_tuple_name(space, type: isl_dim_set, s: "A");
326 dom = isl_set_universe(space);
327 dom = isl_set_lower_bound_si(set: dom, type: isl_dim_param, pos: 0, value: 5);
328 uset = isl_union_set_from_set(set: dom);
329 space = isl_space_set_alloc(ctx, nparam: 1, dim: 0);
330 space = isl_space_set_dim_name(space, type: isl_dim_param, pos: 0, name: "N");
331 space = isl_space_set_tuple_name(space, type: isl_dim_set, s: "B");
332 mupa = isl_multi_union_pw_aff_zero(space);
333 mupa = isl_multi_union_pw_aff_intersect_domain(mupa, uset);
334 r = check_reparse_multi_union_pw_aff(ctx, obj: mupa);
335 if (r < 0)
336 return -1;
337
338 if (check_reparse_multi_union_pw_aff_tests(ctx) < 0)
339 return -1;
340
341 return 0;
342}
343
344/* Test parsing of multi expressions.
345 */
346static int test_parse_multi(isl_ctx *ctx)
347{
348 if (test_parse_mpa(ctx) < 0)
349 return -1;
350 if (test_parse_mupa(ctx) < 0)
351 return -1;
352
353 return 0;
354}
355
356/* Pairs of binary relation representations that should represent
357 * the same binary relations.
358 */
359struct {
360 const char *map1;
361 const char *map2;
362} parse_map_equal_tests[] = {
363 { "{ [x,y] : [([x/2]+y)/3] >= 1 }",
364 "{ [x, y] : 2y >= 6 - x }" },
365 { "{ [x,y] : x <= min(y, 2*y+3) }",
366 "{ [x,y] : x <= y, 2*y + 3 }" },
367 { "{ [x,y] : x >= min(y, 2*y+3) }",
368 "{ [x, y] : (y <= x and y >= -3) or (2y <= -3 + x and y <= -4) }" },
369 { "[n] -> { [c1] : c1>=0 and c1<=floord(n-4,3) }",
370 "[n] -> { [c1] : c1 >= 0 and 3c1 <= -4 + n }" },
371 { "{ [i,j] -> [i] : i < j; [i,j] -> [j] : j <= i }",
372 "{ [i,j] -> [min(i,j)] }" },
373 { "{ [i,j] : i != j }",
374 "{ [i,j] : i < j or i > j }" },
375 { "{ [i,j] : (i+1)*2 >= j }",
376 "{ [i, j] : j <= 2 + 2i }" },
377 { "{ [i] -> [i > 0 ? 4 : 5] }",
378 "{ [i] -> [5] : i <= 0; [i] -> [4] : i >= 1 }" },
379 { "[N=2,M] -> { [i=[(M+N)/4]] }",
380 "[N, M] -> { [i] : N = 2 and 4i <= 2 + M and 4i >= -1 + M }" },
381 { "{ [x] : x >= 0 }",
382 "{ [x] : x-0 >= 0 }" },
383 { "{ [i] : ((i > 10)) }",
384 "{ [i] : i >= 11 }" },
385 { "{ [i] -> [0] }",
386 "{ [i] -> [0 * i] }" },
387 { "{ [a] -> [b] : (not false) }",
388 "{ [a] -> [b] : true }" },
389 { "{ [i] : i/2 <= 5 }",
390 "{ [i] : i <= 10 }" },
391 { "{Sym=[n] [i] : i <= n }",
392 "[n] -> { [i] : i <= n }" },
393 { "{ [*] }",
394 "{ [a] }" },
395 { "{ [i] : 2*floor(i/2) = i }",
396 "{ [i] : exists a : i = 2 a }" },
397 { "{ [a] -> [b] : a = 5 implies b = 5 }",
398 "{ [a] -> [b] : a != 5 or b = 5 }" },
399 { "{ [a] -> [a - 1 : a > 0] }",
400 "{ [a] -> [a - 1] : a > 0 }" },
401 { "{ [a] -> [a - 1 : a > 0; a : a <= 0] }",
402 "{ [a] -> [a - 1] : a > 0; [a] -> [a] : a <= 0 }" },
403 { "{ [a] -> [(a) * 2 : a >= 0; 0 : a < 0] }",
404 "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" },
405 { "{ [a] -> [(a * 2) : a >= 0; 0 : a < 0] }",
406 "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" },
407 { "{ [a] -> [(a * 2 : a >= 0); 0 : a < 0] }",
408 "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" },
409 { "{ [a] -> [(a * 2 : a >= 0; 0 : a < 0)] }",
410 "{ [a] -> [2a] : a >= 0; [a] -> [0] : a < 0 }" },
411 { "{ [a,b] -> [i,j] : a,b << i,j }",
412 "{ [a,b] -> [i,j] : a < i or (a = i and b < j) }" },
413 { "{ [a,b] -> [i,j] : a,b <<= i,j }",
414 "{ [a,b] -> [i,j] : a < i or (a = i and b <= j) }" },
415 { "{ [a,b] -> [i,j] : a,b >> i,j }",
416 "{ [a,b] -> [i,j] : a > i or (a = i and b > j) }" },
417 { "{ [a,b] -> [i,j] : a,b >>= i,j }",
418 "{ [a,b] -> [i,j] : a > i or (a = i and b >= j) }" },
419 { "{ [n] -> [i] : exists (a, b, c: 8b <= i - 32a and "
420 "8b >= -7 + i - 32 a and b >= 0 and b <= 3 and "
421 "8c < n - 32a and i < n and c >= 0 and "
422 "c <= 3 and c >= -4a) }",
423 "{ [n] -> [i] : 0 <= i < n }" },
424 { "{ [x] -> [] : exists (a, b: 0 <= a <= 1 and 0 <= b <= 3 and "
425 "2b <= x - 8a and 2b >= -1 + x - 8a) }",
426 "{ [x] -> [] : 0 <= x <= 15 }" },
427 { "{ [x] -> [x] : }",
428 "{ [x] -> [x] }" },
429 { "{ [x=4:5] -> [x + 1] }",
430 "{ [x] -> [x + 1] : 4 <= x <= 5 }" },
431 { "{ [x=4:5] -> [x + 1 : x + 1] }",
432 "{ [x=4:5] -> [x + 1] }" },
433 { "{ [x] -> [x - 1 : x + 1] }",
434 "{ [x] -> [y] : x - 1 <= y <= x + 1 }" },
435 { "{ [x=4:] -> [x + 1] }",
436 "{ [x] -> [x + 1] : 4 <= x }" },
437 { "{ [x=:5] -> [x + 1] }",
438 "{ [x] -> [x + 1] : x <= 5 }" },
439 { "{ [x=:] -> [x + 1] }",
440 "{ [x] -> [x + 1] }" },
441 { "{ [:] -> [:] }",
442 "{ [x] -> [y] }" },
443 { "{ [x, x//4] }",
444 "{ [x, floor(x/4)] }" },
445 { "{ [10//4] }",
446 "{ [2] }" },
447 { "{ [-1//4] }",
448 "{ [-1] }" },
449 { "{ [0-1//4] }",
450 "{ [0] }" },
451 { "{ [- 1//4] }",
452 "{ [-1] }" },
453 { "{ [0 - 1//4] }",
454 "{ [0] }" },
455 { "{ [0--1//4] }",
456 "{ [1] }" },
457 { "{ [0 - -1//4] }",
458 "{ [1] }" },
459 { "{ [-2^2:2^2-1] }",
460 "{ [-4:3] }" },
461 { "{ [2*-2] }",
462 "{ [-4] }" },
463 { "{ [i,i*-2] }",
464 "{ [i,-2i] }" },
465 { "[a, b, c, d] -> { [max(a,b,c,d)] }",
466 "[a, b, c, d] -> { [a] : b < a and c < a and d < a; "
467 "[b] : b >= a and c < b and d < b; "
468 "[c] : c >= a and c >= b and d < c; "
469 "[d] : d >= a and d >= b and d >= c }" },
470 { "[a, b, c, d] -> { [min(a,b,c,d)] }",
471 "[a, b, c, d] -> { [a] : b >= a and c >= a and d >= a; "
472 "[b] : b < a and c >= b and d >= b; "
473 "[c] : c < b and c < a and d >= c; "
474 "[d] : d < c and d < b and d < a }" },
475};
476
477int test_parse(struct isl_ctx *ctx)
478{
479 int i;
480 isl_map *map, *map2;
481 const char *str, *str2;
482
483 if (test_parse_multi_val(ctx, str: "{ A[B[2] -> C[5, 7]] }") < 0)
484 return -1;
485 if (test_parse_multi_val(ctx, str: "[n] -> { [2] }") < 0)
486 return -1;
487 if (test_parse_multi_val(ctx, str: "{ A[4, infty, NaN, -1/2, 2/3] }") < 0)
488 return -1;
489 if (test_parse_multi(ctx) < 0)
490 return -1;
491 if (test_parse_pma(ctx) < 0)
492 return -1;
493 if (test_parse_upma(ctx) < 0)
494 return -1;
495
496 str = "{ [i] -> [-i] }";
497 map = isl_map_read_from_str(ctx, str);
498 assert(map);
499 isl_map_free(map);
500
501 str = "{ A[i] -> L[([i/3])] }";
502 map = isl_map_read_from_str(ctx, str);
503 assert(map);
504 isl_map_free(map);
505
506 test_parse_map(ctx, str: "{[[s] -> A[i]] -> [[s+1] -> A[i]]}");
507 test_parse_map(ctx, str: "{ [p1, y1, y2] -> [2, y1, y2] : "
508 "p1 = 1 && (y1 <= y2 || y2 = 0) }");
509
510 for (i = 0; i < ARRAY_SIZE(parse_map_equal_tests); ++i) {
511 str = parse_map_equal_tests[i].map1;
512 str2 = parse_map_equal_tests[i].map2;
513 if (test_parse_map_equal(ctx, str, str2) < 0)
514 return -1;
515 }
516
517 str = "{[new,old] -> [new+1-2*[(new+1)/2],old+1-2*[(old+1)/2]]}";
518 map = isl_map_read_from_str(ctx, str);
519 str = "{ [new, old] -> [o0, o1] : "
520 "exists (e0 = [(-1 - new + o0)/2], e1 = [(-1 - old + o1)/2]: "
521 "2e0 = -1 - new + o0 and 2e1 = -1 - old + o1 and o0 >= 0 and "
522 "o0 <= 1 and o1 >= 0 and o1 <= 1) }";
523 map2 = isl_map_read_from_str(ctx, str);
524 assert(isl_map_is_equal(map, map2));
525 isl_map_free(map);
526 isl_map_free(map: map2);
527
528 str = "{[new,old] -> [new+1-2*[(new+1)/2],old+1-2*[(old+1)/2]]}";
529 map = isl_map_read_from_str(ctx, str);
530 str = "{[new,old] -> [(new+1)%2,(old+1)%2]}";
531 map2 = isl_map_read_from_str(ctx, str);
532 assert(isl_map_is_equal(map, map2));
533 isl_map_free(map);
534 isl_map_free(map: map2);
535
536 test_parse_pwqp(ctx, str: "{ [i] -> i + [ (i + [i/3])/2 ] }");
537 test_parse_map(ctx, str: "{ S1[i] -> [([i/10]),i%10] : 0 <= i <= 45 }");
538 test_parse_pwaff(ctx, str: "{ [i] -> [i + 1] : i > 0; [a] -> [a] : a < 0 }");
539 test_parse_pwqp(ctx, str: "{ [x] -> ([(x)/2] * [(x)/3]) }");
540 test_parse_pwaff(ctx, str: "{ [] -> [(100)] }");
541
542 return 0;
543}
544
545static int test_read(isl_ctx *ctx)
546{
547 char *filename;
548 FILE *input;
549 isl_basic_set *bset1, *bset2;
550 const char *str = "{[y]: Exists ( alpha : 2alpha = y)}";
551 int equal;
552
553 filename = get_filename(ctx, name: "set", suffix: "omega");
554 assert(filename);
555 input = fopen(filename: filename, modes: "r");
556 assert(input);
557
558 bset1 = isl_basic_set_read_from_file(ctx, input);
559 bset2 = isl_basic_set_read_from_str(ctx, str);
560
561 equal = isl_basic_set_is_equal(bset1, bset2);
562
563 isl_basic_set_free(bset: bset1);
564 isl_basic_set_free(bset: bset2);
565 free(ptr: filename);
566
567 fclose(stream: input);
568
569 if (equal < 0)
570 return -1;
571 if (!equal)
572 isl_die(ctx, isl_error_unknown,
573 "read sets not equal", return -1);
574
575 return 0;
576}
577
578static int test_bounded(isl_ctx *ctx)
579{
580 isl_set *set;
581 isl_bool bounded;
582
583 set = isl_set_read_from_str(ctx, str: "[n] -> {[i] : 0 <= i <= n }");
584 bounded = isl_set_is_bounded(set);
585 isl_set_free(set);
586
587 if (bounded < 0)
588 return -1;
589 if (!bounded)
590 isl_die(ctx, isl_error_unknown,
591 "set not considered bounded", return -1);
592
593 set = isl_set_read_from_str(ctx, str: "{[n, i] : 0 <= i <= n }");
594 bounded = isl_set_is_bounded(set);
595 assert(!bounded);
596 isl_set_free(set);
597
598 if (bounded < 0)
599 return -1;
600 if (bounded)
601 isl_die(ctx, isl_error_unknown,
602 "set considered bounded", return -1);
603
604 set = isl_set_read_from_str(ctx, str: "[n] -> {[i] : i <= n }");
605 bounded = isl_set_is_bounded(set);
606 isl_set_free(set);
607
608 if (bounded < 0)
609 return -1;
610 if (bounded)
611 isl_die(ctx, isl_error_unknown,
612 "set considered bounded", return -1);
613
614 return 0;
615}
616
617/* Construct the basic set { [i] : 5 <= i <= N } */
618static int test_construction_1(isl_ctx *ctx)
619{
620 isl_space *space;
621 isl_local_space *ls;
622 isl_basic_set *bset;
623 isl_constraint *c;
624
625 space = isl_space_set_alloc(ctx, nparam: 1, dim: 1);
626 bset = isl_basic_set_universe(space: isl_space_copy(space));
627 ls = isl_local_space_from_space(space);
628
629 c = isl_constraint_alloc_inequality(ls: isl_local_space_copy(ls));
630 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
631 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_param, pos: 0, v: 1);
632 bset = isl_basic_set_add_constraint(bset, constraint: c);
633
634 c = isl_constraint_alloc_inequality(ls: isl_local_space_copy(ls));
635 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: 1);
636 c = isl_constraint_set_constant_si(constraint: c, v: -5);
637 bset = isl_basic_set_add_constraint(bset, constraint: c);
638
639 isl_local_space_free(ls);
640 isl_basic_set_free(bset);
641
642 return 0;
643}
644
645/* Construct the basic set { [x] : -100 <= x <= 100 }
646 * using isl_basic_set_{lower,upper}_bound_val and
647 * check that it is equal the same basic set parsed from a string.
648 */
649static int test_construction_2(isl_ctx *ctx)
650{
651 isl_bool equal;
652 isl_val *v;
653 isl_space *space;
654 isl_basic_set *bset1, *bset2;
655
656 v = isl_val_int_from_si(ctx, i: 100);
657 space = isl_space_set_alloc(ctx, nparam: 0, dim: 1);
658 bset1 = isl_basic_set_universe(space);
659 bset1 = isl_basic_set_upper_bound_val(bset: bset1, type: isl_dim_set, pos: 0,
660 value: isl_val_copy(v));
661 bset1 = isl_basic_set_lower_bound_val(bset: bset1, type: isl_dim_set, pos: 0,
662 value: isl_val_neg(v));
663 bset2 = isl_basic_set_read_from_str(ctx, str: "{ [x] : -100 <= x <= 100 }");
664 equal = isl_basic_set_is_equal(bset1, bset2);
665 isl_basic_set_free(bset: bset1);
666 isl_basic_set_free(bset: bset2);
667
668 if (equal < 0)
669 return -1;
670 if (!equal)
671 isl_die(ctx, isl_error_unknown,
672 "failed construction", return -1);
673
674 return 0;
675}
676
677/* Basic tests for constructing basic sets.
678 */
679static int test_construction(isl_ctx *ctx)
680{
681 if (test_construction_1(ctx) < 0)
682 return -1;
683 if (test_construction_2(ctx) < 0)
684 return -1;
685 return 0;
686}
687
688static int test_dim(isl_ctx *ctx)
689{
690 const char *str;
691 isl_map *map1, *map2;
692 int equal;
693
694 map1 = isl_map_read_from_str(ctx,
695 str: "[n] -> { [i] -> [j] : exists (a = [i/10] : i - 10a <= n ) }");
696 map1 = isl_map_add_dims(map: map1, type: isl_dim_in, n: 1);
697 map2 = isl_map_read_from_str(ctx,
698 str: "[n] -> { [i,k] -> [j] : exists (a = [i/10] : i - 10a <= n ) }");
699 equal = isl_map_is_equal(map1, map2);
700 isl_map_free(map: map2);
701
702 map1 = isl_map_project_out(map: map1, type: isl_dim_in, first: 0, n: 1);
703 map2 = isl_map_read_from_str(ctx, str: "[n] -> { [i] -> [j] : n >= 0 }");
704 if (equal >= 0 && equal)
705 equal = isl_map_is_equal(map1, map2);
706
707 isl_map_free(map: map1);
708 isl_map_free(map: map2);
709
710 if (equal < 0)
711 return -1;
712 if (!equal)
713 isl_die(ctx, isl_error_unknown,
714 "unexpected result", return -1);
715
716 str = "[n] -> { [i] -> [] : exists a : 0 <= i <= n and i = 2 a }";
717 map1 = isl_map_read_from_str(ctx, str);
718 str = "{ [i] -> [j] : exists a : 0 <= i <= j and i = 2 a }";
719 map2 = isl_map_read_from_str(ctx, str);
720 map1 = isl_map_move_dims(map: map1, dst_type: isl_dim_out, dst_pos: 0, src_type: isl_dim_param, src_pos: 0, n: 1);
721 equal = isl_map_is_equal(map1, map2);
722 isl_map_free(map: map1);
723 isl_map_free(map: map2);
724
725 if (equal < 0)
726 return -1;
727 if (!equal)
728 isl_die(ctx, isl_error_unknown,
729 "unexpected result", return -1);
730
731 return 0;
732}
733
734#undef BASE
735#define BASE multi_val
736#include "isl_test_plain_equal_templ.c"
737
738#undef BASE
739#define BASE multi_aff
740#include "isl_test_plain_equal_templ.c"
741
742/* Check that "val" is equal to the value described by "str".
743 * If "str" is "NaN", then check for a NaN value explicitly.
744 */
745static isl_stat val_check_equal(__isl_keep isl_val *val, const char *str)
746{
747 isl_bool ok, is_nan;
748 isl_ctx *ctx;
749 isl_val *res;
750
751 if (!val)
752 return isl_stat_error;
753
754 ctx = isl_val_get_ctx(val);
755 res = isl_val_read_from_str(ctx, str);
756 is_nan = isl_val_is_nan(v: res);
757 if (is_nan < 0)
758 ok = isl_bool_error;
759 else if (is_nan)
760 ok = isl_val_is_nan(v: val);
761 else
762 ok = isl_val_eq(v1: val, v2: res);
763 isl_val_free(v: res);
764 if (ok < 0)
765 return isl_stat_error;
766 if (!ok)
767 isl_die(ctx, isl_error_unknown,
768 "unexpected result", return isl_stat_error);
769 return isl_stat_ok;
770}
771
772struct {
773 __isl_give isl_val *(*op)(__isl_take isl_val *v);
774 const char *arg;
775 const char *res;
776} val_un_tests[] = {
777 { &isl_val_neg, "0", "0" },
778 { &isl_val_abs, "0", "0" },
779 { &isl_val_pow2, "0", "1" },
780 { &isl_val_floor, "0", "0" },
781 { &isl_val_ceil, "0", "0" },
782 { &isl_val_neg, "1", "-1" },
783 { &isl_val_neg, "-1", "1" },
784 { &isl_val_neg, "1/2", "-1/2" },
785 { &isl_val_neg, "-1/2", "1/2" },
786 { &isl_val_neg, "infty", "-infty" },
787 { &isl_val_neg, "-infty", "infty" },
788 { &isl_val_neg, "NaN", "NaN" },
789 { &isl_val_abs, "1", "1" },
790 { &isl_val_abs, "-1", "1" },
791 { &isl_val_abs, "1/2", "1/2" },
792 { &isl_val_abs, "-1/2", "1/2" },
793 { &isl_val_abs, "infty", "infty" },
794 { &isl_val_abs, "-infty", "infty" },
795 { &isl_val_abs, "NaN", "NaN" },
796 { &isl_val_floor, "1", "1" },
797 { &isl_val_floor, "-1", "-1" },
798 { &isl_val_floor, "1/2", "0" },
799 { &isl_val_floor, "-1/2", "-1" },
800 { &isl_val_floor, "infty", "infty" },
801 { &isl_val_floor, "-infty", "-infty" },
802 { &isl_val_floor, "NaN", "NaN" },
803 { &isl_val_ceil, "1", "1" },
804 { &isl_val_ceil, "-1", "-1" },
805 { &isl_val_ceil, "1/2", "1" },
806 { &isl_val_ceil, "-1/2", "0" },
807 { &isl_val_ceil, "infty", "infty" },
808 { &isl_val_ceil, "-infty", "-infty" },
809 { &isl_val_ceil, "NaN", "NaN" },
810 { &isl_val_pow2, "-3", "1/8" },
811 { &isl_val_pow2, "-1", "1/2" },
812 { &isl_val_pow2, "1", "2" },
813 { &isl_val_pow2, "2", "4" },
814 { &isl_val_pow2, "3", "8" },
815 { &isl_val_inv, "1", "1" },
816 { &isl_val_inv, "2", "1/2" },
817 { &isl_val_inv, "1/2", "2" },
818 { &isl_val_inv, "-2", "-1/2" },
819 { &isl_val_inv, "-1/2", "-2" },
820 { &isl_val_inv, "0", "NaN" },
821 { &isl_val_inv, "NaN", "NaN" },
822 { &isl_val_inv, "infty", "0" },
823 { &isl_val_inv, "-infty", "0" },
824};
825
826/* Perform some basic tests of unary operations on isl_val objects.
827 */
828static int test_un_val(isl_ctx *ctx)
829{
830 int i;
831 isl_val *v;
832 __isl_give isl_val *(*fn)(__isl_take isl_val *v);
833
834 for (i = 0; i < ARRAY_SIZE(val_un_tests); ++i) {
835 isl_stat r;
836
837 v = isl_val_read_from_str(ctx, str: val_un_tests[i].arg);
838 fn = val_un_tests[i].op;
839 v = fn(v);
840 r = val_check_equal(val: v, str: val_un_tests[i].res);
841 isl_val_free(v);
842 if (r < 0)
843 return -1;
844 }
845
846 return 0;
847}
848
849struct {
850 __isl_give isl_val *(*fn)(__isl_take isl_val *v1,
851 __isl_take isl_val *v2);
852} val_bin_op[] = {
853 ['+'] = { &isl_val_add },
854 ['-'] = { .fn: &isl_val_sub },
855 ['*'] = { .fn: &isl_val_mul },
856 ['/'] = { .fn: &isl_val_div },
857 ['g'] = { .fn: &isl_val_gcd },
858 ['m'] = { .fn: &isl_val_min },
859 ['M'] = { .fn: &isl_val_max },
860};
861
862struct {
863 const char *arg1;
864 unsigned char op;
865 const char *arg2;
866 const char *res;
867} val_bin_tests[] = {
868 { "0", '+', "0", "0" },
869 { "1", '+', "0", "1" },
870 { "1", '+', "1", "2" },
871 { "1", '-', "1", "0" },
872 { "1", '*', "1", "1" },
873 { "1", '/', "1", "1" },
874 { "2", '*', "3", "6" },
875 { "2", '*', "1/2", "1" },
876 { "2", '*', "1/3", "2/3" },
877 { "2/3", '*', "3/5", "2/5" },
878 { "2/3", '*', "7/5", "14/15" },
879 { "2", '/', "1/2", "4" },
880 { "-2", '/', "-1/2", "4" },
881 { "-2", '/', "1/2", "-4" },
882 { "2", '/', "-1/2", "-4" },
883 { "2", '/', "2", "1" },
884 { "2", '/', "3", "2/3" },
885 { "2/3", '/', "5/3", "2/5" },
886 { "2/3", '/', "5/7", "14/15" },
887 { "0", '/', "0", "NaN" },
888 { "42", '/', "0", "NaN" },
889 { "-42", '/', "0", "NaN" },
890 { "infty", '/', "0", "NaN" },
891 { "-infty", '/', "0", "NaN" },
892 { "NaN", '/', "0", "NaN" },
893 { "0", '/', "NaN", "NaN" },
894 { "42", '/', "NaN", "NaN" },
895 { "-42", '/', "NaN", "NaN" },
896 { "infty", '/', "NaN", "NaN" },
897 { "-infty", '/', "NaN", "NaN" },
898 { "NaN", '/', "NaN", "NaN" },
899 { "0", '/', "infty", "0" },
900 { "42", '/', "infty", "0" },
901 { "-42", '/', "infty", "0" },
902 { "infty", '/', "infty", "NaN" },
903 { "-infty", '/', "infty", "NaN" },
904 { "NaN", '/', "infty", "NaN" },
905 { "0", '/', "-infty", "0" },
906 { "42", '/', "-infty", "0" },
907 { "-42", '/', "-infty", "0" },
908 { "infty", '/', "-infty", "NaN" },
909 { "-infty", '/', "-infty", "NaN" },
910 { "NaN", '/', "-infty", "NaN" },
911 { "1", '-', "1/3", "2/3" },
912 { "1/3", '+', "1/2", "5/6" },
913 { "1/2", '+', "1/2", "1" },
914 { "3/4", '-', "1/4", "1/2" },
915 { "1/2", '-', "1/3", "1/6" },
916 { "infty", '+', "42", "infty" },
917 { "infty", '+', "infty", "infty" },
918 { "42", '+', "infty", "infty" },
919 { "infty", '-', "infty", "NaN" },
920 { "infty", '*', "infty", "infty" },
921 { "infty", '*', "-infty", "-infty" },
922 { "-infty", '*', "infty", "-infty" },
923 { "-infty", '*', "-infty", "infty" },
924 { "0", '*', "infty", "NaN" },
925 { "1", '*', "infty", "infty" },
926 { "infty", '*', "0", "NaN" },
927 { "infty", '*', "42", "infty" },
928 { "42", '-', "infty", "-infty" },
929 { "infty", '+', "-infty", "NaN" },
930 { "4", 'g', "6", "2" },
931 { "5", 'g', "6", "1" },
932 { "42", 'm', "3", "3" },
933 { "42", 'M', "3", "42" },
934 { "3", 'm', "42", "3" },
935 { "3", 'M', "42", "42" },
936 { "42", 'm', "infty", "42" },
937 { "42", 'M', "infty", "infty" },
938 { "42", 'm', "-infty", "-infty" },
939 { "42", 'M', "-infty", "42" },
940 { "42", 'm', "NaN", "NaN" },
941 { "42", 'M', "NaN", "NaN" },
942 { "infty", 'm', "-infty", "-infty" },
943 { "infty", 'M', "-infty", "infty" },
944};
945
946/* Perform some basic tests of binary operations on isl_val objects.
947 */
948static int test_bin_val(isl_ctx *ctx)
949{
950 int i;
951 isl_val *v1, *v2, *res;
952 __isl_give isl_val *(*fn)(__isl_take isl_val *v1,
953 __isl_take isl_val *v2);
954 int ok;
955
956 for (i = 0; i < ARRAY_SIZE(val_bin_tests); ++i) {
957 v1 = isl_val_read_from_str(ctx, str: val_bin_tests[i].arg1);
958 v2 = isl_val_read_from_str(ctx, str: val_bin_tests[i].arg2);
959 res = isl_val_read_from_str(ctx, str: val_bin_tests[i].res);
960 fn = val_bin_op[val_bin_tests[i].op].fn;
961 v1 = fn(v1, v2);
962 if (isl_val_is_nan(v: res))
963 ok = isl_val_is_nan(v: v1);
964 else
965 ok = isl_val_eq(v1, v2: res);
966 isl_val_free(v: v1);
967 isl_val_free(v: res);
968 if (ok < 0)
969 return -1;
970 if (!ok)
971 isl_die(ctx, isl_error_unknown,
972 "unexpected result", return -1);
973 }
974
975 return 0;
976}
977
978/* Perform some basic tests on isl_val objects.
979 */
980static int test_val(isl_ctx *ctx)
981{
982 if (test_un_val(ctx) < 0)
983 return -1;
984 if (test_bin_val(ctx) < 0)
985 return -1;
986 return 0;
987}
988
989/* Sets described using existentially quantified variables that
990 * can also be described without.
991 */
992static const char *elimination_tests[] = {
993 "{ [i,j] : 2 * [i/2] + 3 * [j/4] <= 10 and 2 i = j }",
994 "{ [m, w] : exists a : w - 2m - 5 <= 3a <= m - 2w }",
995 "{ [m, w] : exists a : w >= 0 and a < m and -1 + w <= a <= 2m - w }",
996};
997
998/* Check that redundant existentially quantified variables are
999 * getting removed.
1000 */
1001static int test_elimination(isl_ctx *ctx)
1002{
1003 int i;
1004 isl_size n;
1005 isl_basic_set *bset;
1006
1007 for (i = 0; i < ARRAY_SIZE(elimination_tests); ++i) {
1008 bset = isl_basic_set_read_from_str(ctx, str: elimination_tests[i]);
1009 n = isl_basic_set_dim(bset, type: isl_dim_div);
1010 isl_basic_set_free(bset);
1011 if (n < 0)
1012 return -1;
1013 if (n != 0)
1014 isl_die(ctx, isl_error_unknown,
1015 "expecting no existentials", return -1);
1016 }
1017
1018 return 0;
1019}
1020
1021static int test_div(isl_ctx *ctx)
1022{
1023 const char *str;
1024 int empty;
1025 isl_space *space;
1026 isl_set *set;
1027 isl_local_space *ls;
1028 struct isl_basic_set *bset;
1029 struct isl_constraint *c;
1030
1031 /* test 1 */
1032 space = isl_space_set_alloc(ctx, nparam: 0, dim: 3);
1033 bset = isl_basic_set_universe(space: isl_space_copy(space));
1034 ls = isl_local_space_from_space(space);
1035
1036 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1037 c = isl_constraint_set_constant_si(constraint: c, v: -1);
1038 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: 1);
1039 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 1, v: 3);
1040 bset = isl_basic_set_add_constraint(bset, constraint: c);
1041
1042 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1043 c = isl_constraint_set_constant_si(constraint: c, v: 1);
1044 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1045 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: 3);
1046 bset = isl_basic_set_add_constraint(bset, constraint: c);
1047
1048 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 1, n: 2);
1049
1050 assert(bset && bset->n_div == 1);
1051 isl_local_space_free(ls);
1052 isl_basic_set_free(bset);
1053
1054 /* test 2 */
1055 space = isl_space_set_alloc(ctx, nparam: 0, dim: 3);
1056 bset = isl_basic_set_universe(space: isl_space_copy(space));
1057 ls = isl_local_space_from_space(space);
1058
1059 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1060 c = isl_constraint_set_constant_si(constraint: c, v: 1);
1061 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1062 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 1, v: 3);
1063 bset = isl_basic_set_add_constraint(bset, constraint: c);
1064
1065 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1066 c = isl_constraint_set_constant_si(constraint: c, v: -1);
1067 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: 1);
1068 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: 3);
1069 bset = isl_basic_set_add_constraint(bset, constraint: c);
1070
1071 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 1, n: 2);
1072
1073 assert(bset && bset->n_div == 1);
1074 isl_local_space_free(ls);
1075 isl_basic_set_free(bset);
1076
1077 /* test 3 */
1078 space = isl_space_set_alloc(ctx, nparam: 0, dim: 3);
1079 bset = isl_basic_set_universe(space: isl_space_copy(space));
1080 ls = isl_local_space_from_space(space);
1081
1082 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1083 c = isl_constraint_set_constant_si(constraint: c, v: 1);
1084 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1085 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 1, v: 3);
1086 bset = isl_basic_set_add_constraint(bset, constraint: c);
1087
1088 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1089 c = isl_constraint_set_constant_si(constraint: c, v: -3);
1090 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: 1);
1091 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: 4);
1092 bset = isl_basic_set_add_constraint(bset, constraint: c);
1093
1094 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 1, n: 2);
1095
1096 assert(bset && bset->n_div == 1);
1097 isl_local_space_free(ls);
1098 isl_basic_set_free(bset);
1099
1100 /* test 4 */
1101 space = isl_space_set_alloc(ctx, nparam: 0, dim: 3);
1102 bset = isl_basic_set_universe(space: isl_space_copy(space));
1103 ls = isl_local_space_from_space(space);
1104
1105 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1106 c = isl_constraint_set_constant_si(constraint: c, v: 2);
1107 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1108 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 1, v: 3);
1109 bset = isl_basic_set_add_constraint(bset, constraint: c);
1110
1111 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1112 c = isl_constraint_set_constant_si(constraint: c, v: -1);
1113 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: 1);
1114 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: 6);
1115 bset = isl_basic_set_add_constraint(bset, constraint: c);
1116
1117 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 1, n: 2);
1118
1119 assert(isl_basic_set_is_empty(bset));
1120 isl_local_space_free(ls);
1121 isl_basic_set_free(bset);
1122
1123 /* test 5 */
1124 space = isl_space_set_alloc(ctx, nparam: 0, dim: 3);
1125 bset = isl_basic_set_universe(space: isl_space_copy(space));
1126 ls = isl_local_space_from_space(space);
1127
1128 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1129 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1130 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: 3);
1131 bset = isl_basic_set_add_constraint(bset, constraint: c);
1132
1133 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1134 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: 1);
1135 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 1, v: -3);
1136 bset = isl_basic_set_add_constraint(bset, constraint: c);
1137
1138 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 2, n: 1);
1139
1140 assert(bset && bset->n_div == 0);
1141 isl_basic_set_free(bset);
1142 isl_local_space_free(ls);
1143
1144 /* test 6 */
1145 space = isl_space_set_alloc(ctx, nparam: 0, dim: 3);
1146 bset = isl_basic_set_universe(space: isl_space_copy(space));
1147 ls = isl_local_space_from_space(space);
1148
1149 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1150 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1151 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: 6);
1152 bset = isl_basic_set_add_constraint(bset, constraint: c);
1153
1154 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1155 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: 1);
1156 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 1, v: -3);
1157 bset = isl_basic_set_add_constraint(bset, constraint: c);
1158
1159 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 2, n: 1);
1160
1161 assert(bset && bset->n_div == 1);
1162 isl_basic_set_free(bset);
1163 isl_local_space_free(ls);
1164
1165 /* test 7 */
1166 /* This test is a bit tricky. We set up an equality
1167 * a + 3b + 3c = 6 e0
1168 * Normalization of divs creates _two_ divs
1169 * a = 3 e0
1170 * c - b - e0 = 2 e1
1171 * Afterwards e0 is removed again because it has coefficient -1
1172 * and we end up with the original equality and div again.
1173 * Perhaps we can avoid the introduction of this temporary div.
1174 */
1175 space = isl_space_set_alloc(ctx, nparam: 0, dim: 4);
1176 bset = isl_basic_set_universe(space: isl_space_copy(space));
1177 ls = isl_local_space_from_space(space);
1178
1179 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1180 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1181 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 1, v: -3);
1182 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: -3);
1183 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 3, v: 6);
1184 bset = isl_basic_set_add_constraint(bset, constraint: c);
1185
1186 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 3, n: 1);
1187
1188 /* Test disabled for now */
1189 /*
1190 assert(bset && bset->n_div == 1);
1191 */
1192 isl_local_space_free(ls);
1193 isl_basic_set_free(bset);
1194
1195 /* test 8 */
1196 space = isl_space_set_alloc(ctx, nparam: 0, dim: 5);
1197 bset = isl_basic_set_universe(space: isl_space_copy(space));
1198 ls = isl_local_space_from_space(space);
1199
1200 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1201 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1202 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 1, v: -3);
1203 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 3, v: -3);
1204 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 4, v: 6);
1205 bset = isl_basic_set_add_constraint(bset, constraint: c);
1206
1207 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1208 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1209 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: 1);
1210 c = isl_constraint_set_constant_si(constraint: c, v: 1);
1211 bset = isl_basic_set_add_constraint(bset, constraint: c);
1212
1213 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 4, n: 1);
1214
1215 /* Test disabled for now */
1216 /*
1217 assert(bset && bset->n_div == 1);
1218 */
1219 isl_local_space_free(ls);
1220 isl_basic_set_free(bset);
1221
1222 /* test 9 */
1223 space = isl_space_set_alloc(ctx, nparam: 0, dim: 4);
1224 bset = isl_basic_set_universe(space: isl_space_copy(space));
1225 ls = isl_local_space_from_space(space);
1226
1227 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1228 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: 1);
1229 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 1, v: -1);
1230 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: -2);
1231 bset = isl_basic_set_add_constraint(bset, constraint: c);
1232
1233 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1234 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: -1);
1235 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 3, v: 3);
1236 c = isl_constraint_set_constant_si(constraint: c, v: 2);
1237 bset = isl_basic_set_add_constraint(bset, constraint: c);
1238
1239 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 2, n: 2);
1240
1241 bset = isl_basic_set_fix_si(bset, type: isl_dim_set, pos: 0, value: 2);
1242
1243 assert(!isl_basic_set_is_empty(bset));
1244
1245 isl_local_space_free(ls);
1246 isl_basic_set_free(bset);
1247
1248 /* test 10 */
1249 space = isl_space_set_alloc(ctx, nparam: 0, dim: 3);
1250 bset = isl_basic_set_universe(space: isl_space_copy(space));
1251 ls = isl_local_space_from_space(space);
1252
1253 c = isl_constraint_alloc_equality(ls: isl_local_space_copy(ls));
1254 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 0, v: 1);
1255 c = isl_constraint_set_coefficient_si(constraint: c, type: isl_dim_set, pos: 2, v: -2);
1256 bset = isl_basic_set_add_constraint(bset, constraint: c);
1257
1258 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 2, n: 1);
1259
1260 bset = isl_basic_set_fix_si(bset, type: isl_dim_set, pos: 0, value: 2);
1261
1262 isl_local_space_free(ls);
1263 isl_basic_set_free(bset);
1264
1265 str = "{ [i] : exists (e0, e1: 3e1 >= 1 + 2e0 and "
1266 "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }";
1267 set = isl_set_read_from_str(ctx, str);
1268 set = isl_set_compute_divs(set);
1269 isl_set_free(set);
1270 if (!set)
1271 return -1;
1272
1273 if (test_elimination(ctx) < 0)
1274 return -1;
1275
1276 str = "{ [i,j,k] : 3 + i + 2j >= 0 and 2 * [(i+2j)/4] <= k }";
1277 set = isl_set_read_from_str(ctx, str);
1278 set = isl_set_remove_divs_involving_dims(set, type: isl_dim_set, first: 0, n: 2);
1279 set = isl_set_fix_si(set, type: isl_dim_set, pos: 2, value: -3);
1280 empty = isl_set_is_empty(set);
1281 isl_set_free(set);
1282 if (empty < 0)
1283 return -1;
1284 if (!empty)
1285 isl_die(ctx, isl_error_unknown,
1286 "result not as accurate as expected", return -1);
1287
1288 return 0;
1289}
1290
1291void test_application_case(struct isl_ctx *ctx, const char *name)
1292{
1293 char *filename;
1294 FILE *input;
1295 struct isl_basic_set *bset1, *bset2;
1296 struct isl_basic_map *bmap;
1297
1298 filename = get_filename(ctx, name, suffix: "omega");
1299 assert(filename);
1300 input = fopen(filename: filename, modes: "r");
1301 assert(input);
1302
1303 bset1 = isl_basic_set_read_from_file(ctx, input);
1304 bmap = isl_basic_map_read_from_file(ctx, input);
1305
1306 bset1 = isl_basic_set_apply(bset: bset1, bmap);
1307
1308 bset2 = isl_basic_set_read_from_file(ctx, input);
1309
1310 assert(isl_basic_set_is_equal(bset1, bset2) == 1);
1311
1312 isl_basic_set_free(bset: bset1);
1313 isl_basic_set_free(bset: bset2);
1314 free(ptr: filename);
1315
1316 fclose(stream: input);
1317}
1318
1319static int test_application(isl_ctx *ctx)
1320{
1321 test_application_case(ctx, name: "application");
1322 test_application_case(ctx, name: "application2");
1323
1324 return 0;
1325}
1326
1327void test_affine_hull_case(struct isl_ctx *ctx, const char *name)
1328{
1329 char *filename;
1330 FILE *input;
1331 struct isl_basic_set *bset1, *bset2;
1332
1333 filename = get_filename(ctx, name, suffix: "polylib");
1334 assert(filename);
1335 input = fopen(filename: filename, modes: "r");
1336 assert(input);
1337
1338 bset1 = isl_basic_set_read_from_file(ctx, input);
1339 bset2 = isl_basic_set_read_from_file(ctx, input);
1340
1341 bset1 = isl_basic_set_affine_hull(bset: bset1);
1342
1343 assert(isl_basic_set_is_equal(bset1, bset2) == 1);
1344
1345 isl_basic_set_free(bset: bset1);
1346 isl_basic_set_free(bset: bset2);
1347 free(ptr: filename);
1348
1349 fclose(stream: input);
1350}
1351
1352/* Pairs of sets and the corresponding expected results of
1353 * isl_basic_set_recession_cone.
1354 */
1355struct {
1356 const char *set;
1357 const char *cone;
1358} recession_cone_tests[] = {
1359 { "{ [i] : 0 <= i <= 10 }", "{ [0] }" },
1360 { "{ [i] : 0 <= i }", "{ [i] : 0 <= i }" },
1361 { "{ [i] : i <= 10 }", "{ [i] : i <= 0 }" },
1362 { "{ [i] : false }", "{ [i] : false }" },
1363};
1364
1365/* Perform some basic isl_basic_set_recession_cone tests.
1366 */
1367static int test_recession_cone(struct isl_ctx *ctx)
1368{
1369 int i;
1370
1371 for (i = 0; i < ARRAY_SIZE(recession_cone_tests); ++i) {
1372 const char *str;
1373 isl_basic_set *bset;
1374 isl_basic_set *cone, *expected;
1375 isl_bool equal;
1376
1377 str = recession_cone_tests[i].set;
1378 bset = isl_basic_set_read_from_str(ctx, str);
1379 str = recession_cone_tests[i].cone;
1380 expected = isl_basic_set_read_from_str(ctx, str);
1381 cone = isl_basic_set_recession_cone(bset);
1382 equal = isl_basic_set_is_equal(bset1: cone, bset2: expected);
1383 isl_basic_set_free(bset: cone);
1384 isl_basic_set_free(bset: expected);
1385 if (equal < 0)
1386 return -1;
1387 if (!equal)
1388 isl_die(ctx, isl_error_unknown, "unexpected cone",
1389 return -1);
1390 }
1391
1392 return 0;
1393}
1394
1395int test_affine_hull(struct isl_ctx *ctx)
1396{
1397 const char *str;
1398 isl_set *set;
1399 isl_basic_set *bset, *bset2;
1400 isl_size n;
1401 isl_bool subset;
1402
1403 test_affine_hull_case(ctx, name: "affine2");
1404 test_affine_hull_case(ctx, name: "affine");
1405 test_affine_hull_case(ctx, name: "affine3");
1406
1407 str = "[m] -> { [i0] : exists (e0, e1: e1 <= 1 + i0 and "
1408 "m >= 3 and 4i0 <= 2 + m and e1 >= i0 and "
1409 "e1 >= 0 and e1 <= 2 and e1 >= 1 + 2e0 and "
1410 "2e1 <= 1 + m + 4e0 and 2e1 >= 2 - m + 4i0 - 4e0) }";
1411 set = isl_set_read_from_str(ctx, str);
1412 bset = isl_set_affine_hull(set);
1413 n = isl_basic_set_dim(bset, type: isl_dim_div);
1414 isl_basic_set_free(bset);
1415 if (n < 0)
1416 return -1;
1417 if (n != 0)
1418 isl_die(ctx, isl_error_unknown, "not expecting any divs",
1419 return -1);
1420
1421 /* Check that isl_map_affine_hull is not confused by
1422 * the reordering of divs in isl_map_align_divs.
1423 */
1424 str = "{ [a, b, c, 0] : exists (e0 = [(b)/32], e1 = [(c)/32]: "
1425 "32e0 = b and 32e1 = c); "
1426 "[a, 0, c, 0] : exists (e0 = [(c)/32]: 32e0 = c) }";
1427 set = isl_set_read_from_str(ctx, str);
1428 bset = isl_set_affine_hull(set);
1429 isl_basic_set_free(bset);
1430 if (!bset)
1431 return -1;
1432
1433 str = "{ [a] : exists e0, e1, e2: 32e1 = 31 + 31a + 31e0 and "
1434 "32e2 = 31 + 31e0 }";
1435 set = isl_set_read_from_str(ctx, str);
1436 bset = isl_set_affine_hull(set);
1437 str = "{ [a] : exists e : a = 32 e }";
1438 bset2 = isl_basic_set_read_from_str(ctx, str);
1439 subset = isl_basic_set_is_subset(bset1: bset, bset2);
1440 isl_basic_set_free(bset);
1441 isl_basic_set_free(bset: bset2);
1442 if (subset < 0)
1443 return -1;
1444 if (!subset)
1445 isl_die(ctx, isl_error_unknown, "not as accurate as expected",
1446 return -1);
1447
1448 return 0;
1449}
1450
1451/* Test a special case of isl_set_plain_unshifted_simple_hull
1452 * where older versions of isl would include a redundant constraint
1453 * in the result.
1454 * Check that the result does not have any constraints.
1455 */
1456static isl_stat test_plain_unshifted_simple_hull_special(isl_ctx *ctx)
1457{
1458 const char *str;
1459 isl_bool is_universe;
1460 isl_set *set;
1461 isl_basic_set *bset;
1462
1463 str = "{[x, y] : x = 0 or 2*((x+y)//2) <= y + 2 }";
1464 set = isl_set_read_from_str(ctx, str);
1465 bset = isl_set_plain_unshifted_simple_hull(set);
1466 is_universe = isl_basic_set_plain_is_universe(bset);
1467 isl_basic_set_free(bset);
1468
1469 if (is_universe < 0)
1470 return isl_stat_error;
1471 if (!is_universe)
1472 isl_die(ctx, isl_error_unknown,
1473 "hull should not have any constraints",
1474 return isl_stat_error);
1475
1476 return isl_stat_ok;
1477}
1478
1479/* Inputs for simple hull tests, consisting of
1480 * the specific simple hull function, the input set and the expected result.
1481 */
1482struct {
1483 __isl_give isl_basic_set *(*fn)(__isl_take isl_set *set);
1484 const char *set;
1485 const char *hull;
1486} simple_hull_tests[] = {
1487 { &isl_set_plain_unshifted_simple_hull,
1488 "{ [i,j] : i >= 1 and j >= 1 or i >= 2 and j <= 10 }",
1489 "{ [i,j] : i >= 1 }" },
1490 { &isl_set_plain_unshifted_simple_hull,
1491 "{ [n,i,j,k] : (i mod 3 = 2 and j mod 4 = 2) or "
1492 "(j mod 4 = 2 and k mod 6 = n) }",
1493 "{ [n,i,j,k] : j mod 4 = 2 }" },
1494 { &isl_set_unshifted_simple_hull,
1495 "{ [0,x,y] : x <= -1; [1,x,y] : x <= y <= -x; [2,x,y] : x <= 1 }",
1496 "{ [t,x,y] : 0 <= t <= 2 and x <= 1 }" },
1497 { &isl_set_simple_hull,
1498 "{ [a, b] : b <= 0 and "
1499 "2*floor((-2*floor((b)/2))/5) >= a - floor((b)/2); "
1500 "[a, b] : a mod 2 = 0 }",
1501 "{ [a, b] }" },
1502};
1503
1504/* Basic tests for various simple hull functions.
1505 */
1506static int test_various_simple_hull(isl_ctx *ctx)
1507{
1508 int i;
1509 isl_set *set;
1510 isl_basic_set *hull, *expected;
1511 isl_bool equal;
1512
1513 for (i = 0; i < ARRAY_SIZE(simple_hull_tests); ++i) {
1514 const char *str;
1515 str = simple_hull_tests[i].set;
1516 set = isl_set_read_from_str(ctx, str);
1517 str = simple_hull_tests[i].hull;
1518 expected = isl_basic_set_read_from_str(ctx, str);
1519 hull = simple_hull_tests[i].fn(set);
1520 equal = isl_basic_set_is_equal(bset1: hull, bset2: expected);
1521 isl_basic_set_free(bset: hull);
1522 isl_basic_set_free(bset: expected);
1523 if (equal < 0)
1524 return -1;
1525 if (!equal)
1526 isl_die(ctx, isl_error_unknown, "unexpected hull",
1527 return -1);
1528 }
1529
1530 return 0;
1531}
1532
1533static int test_simple_hull(struct isl_ctx *ctx)
1534{
1535 const char *str;
1536 isl_set *set;
1537 isl_basic_set *bset;
1538 isl_bool is_empty;
1539
1540 str = "{ [x, y] : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x;"
1541 "[y, x] : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x }";
1542 set = isl_set_read_from_str(ctx, str);
1543 bset = isl_set_simple_hull(set);
1544 is_empty = isl_basic_set_is_empty(bset);
1545 isl_basic_set_free(bset);
1546
1547 if (is_empty == isl_bool_error)
1548 return -1;
1549
1550 if (is_empty == isl_bool_false)
1551 isl_die(ctx, isl_error_unknown, "Empty set should be detected",
1552 return -1);
1553
1554 if (test_plain_unshifted_simple_hull_special(ctx) < 0)
1555 return -1;
1556 if (test_various_simple_hull(ctx) < 0)
1557 return -1;
1558
1559 return 0;
1560}
1561
1562/* Inputs for isl_set_get_simple_fixed_box_hull tests.
1563 * "set" is the input set.
1564 * "offset" is the expected box offset.
1565 * "size" is the expected box size.
1566 */
1567static struct {
1568 const char *set;
1569 const char *offset;
1570 const char *size;
1571} box_hull_tests[] = {
1572 { "{ S[x, y] : 0 <= x, y < 10 }", "{ S[0, 0] }", "{ S[10, 10] }" },
1573 { "[N] -> { S[x, y] : N <= x, y < N + 10 }",
1574 "[N] -> { S[N, N] }", "{ S[10, 10] }" },
1575 { "{ S[x, y] : 0 <= x + y, x - y < 10 }",
1576 "{ S[0, -4] }", "{ S[10, 9] }" },
1577 { "{ [i=0:10] : exists (e0, e1: 3e1 >= 1 + 2e0 and "
1578 "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }",
1579 "{ [3] }", "{ [8] }" },
1580 { "[N] -> { [w = 0:17] : exists (e0: w < 2N and "
1581 "-1 + w <= e0 <= w and 2e0 >= N + w and w <= 2e0 <= 15 + w) }",
1582 "[N] -> { [N] }", "{ [9] }" },
1583};
1584
1585/* Perform basic isl_set_get_simple_fixed_box_hull tests.
1586 */
1587static int test_box_hull(struct isl_ctx *ctx)
1588{
1589 int i;
1590
1591 for (i = 0; i < ARRAY_SIZE(box_hull_tests); ++i) {
1592 const char *str;
1593 isl_stat r;
1594 isl_set *set;
1595 isl_multi_aff *offset;
1596 isl_multi_val *size;
1597 isl_fixed_box *box;
1598
1599 set = isl_set_read_from_str(ctx, str: box_hull_tests[i].set);
1600 box = isl_set_get_simple_fixed_box_hull(set);
1601 offset = isl_fixed_box_get_offset(box);
1602 size = isl_fixed_box_get_size(box);
1603 str = box_hull_tests[i].offset;
1604 r = multi_aff_check_plain_equal(obj: offset, str);
1605 str = box_hull_tests[i].size;
1606 if (r >= 0)
1607 r = multi_val_check_plain_equal(obj: size, str);
1608 isl_multi_aff_free(multi: offset);
1609 isl_multi_val_free(multi: size);
1610 isl_fixed_box_free(box);
1611 isl_set_free(set);
1612 if (r < 0)
1613 return -1;
1614 }
1615
1616 return 0;
1617}
1618
1619void test_convex_hull_case(struct isl_ctx *ctx, const char *name)
1620{
1621 char *filename;
1622 FILE *input;
1623 struct isl_basic_set *bset1, *bset2;
1624 struct isl_set *set;
1625
1626 filename = get_filename(ctx, name, suffix: "polylib");
1627 assert(filename);
1628 input = fopen(filename: filename, modes: "r");
1629 assert(input);
1630
1631 bset1 = isl_basic_set_read_from_file(ctx, input);
1632 bset2 = isl_basic_set_read_from_file(ctx, input);
1633
1634 set = isl_basic_set_union(bset1, bset2);
1635 bset1 = isl_set_convex_hull(set);
1636
1637 bset2 = isl_basic_set_read_from_file(ctx, input);
1638
1639 assert(isl_basic_set_is_equal(bset1, bset2) == 1);
1640
1641 isl_basic_set_free(bset: bset1);
1642 isl_basic_set_free(bset: bset2);
1643 free(ptr: filename);
1644
1645 fclose(stream: input);
1646}
1647
1648struct {
1649 const char *set;
1650 const char *hull;
1651} convex_hull_tests[] = {
1652 { "{ [i0, i1, i2] : (i2 = 1 and i0 = 0 and i1 >= 0) or "
1653 "(i0 = 1 and i1 = 0 and i2 = 1) or "
1654 "(i0 = 0 and i1 = 0 and i2 = 0) }",
1655 "{ [i0, i1, i2] : i0 >= 0 and i2 >= i0 and i2 <= 1 and i1 >= 0 }" },
1656 { "[n] -> { [i0, i1, i0] : i0 <= -4 + n; "
1657 "[i0, i0, i2] : n = 6 and i0 >= 0 and i2 <= 7 - i0 and "
1658 "i2 <= 5 and i2 >= 4; "
1659 "[3, i1, 3] : n = 5 and i1 <= 2 and i1 >= 0 }",
1660 "[n] -> { [i0, i1, i2] : i2 <= -1 + n and 2i2 <= -6 + 3n - i0 and "
1661 "i2 <= 5 + i0 and i2 >= i0 }" },
1662 { "{ [x, y] : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x }",
1663 "{ [x, y] : 1 = 0 }" },
1664 { "{ [x, y, z] : 0 <= x, y, z <= 10; [x, y, 0] : x >= 0 and y > 0; "
1665 "[x, y, 0] : x >= 0 and y < 0 }",
1666 "{ [x, y, z] : x >= 0 and 0 <= z <= 10 }" },
1667 { "{ [a, b, c] : a <= 1 and -a < b <= 1 and 0 <= c <= 2 - a - b and "
1668 "c <= a; "
1669 "[0, 2, 0]; [3, 1, 0] }",
1670 "{ [a, b, c] : b > -a and 2b >= -1 + a and 0 <= c <= a and "
1671 "5c <= 6 - a - 3b }" },
1672};
1673
1674static int test_convex_hull_algo(isl_ctx *ctx, int convex)
1675{
1676 int i;
1677 int orig_convex = ctx->opt->convex;
1678 ctx->opt->convex = convex;
1679
1680 test_convex_hull_case(ctx, name: "convex0");
1681 test_convex_hull_case(ctx, name: "convex1");
1682 test_convex_hull_case(ctx, name: "convex2");
1683 test_convex_hull_case(ctx, name: "convex3");
1684 test_convex_hull_case(ctx, name: "convex4");
1685 test_convex_hull_case(ctx, name: "convex5");
1686 test_convex_hull_case(ctx, name: "convex6");
1687 test_convex_hull_case(ctx, name: "convex7");
1688 test_convex_hull_case(ctx, name: "convex8");
1689 test_convex_hull_case(ctx, name: "convex9");
1690 test_convex_hull_case(ctx, name: "convex10");
1691 test_convex_hull_case(ctx, name: "convex11");
1692 test_convex_hull_case(ctx, name: "convex12");
1693 test_convex_hull_case(ctx, name: "convex13");
1694 test_convex_hull_case(ctx, name: "convex14");
1695 test_convex_hull_case(ctx, name: "convex15");
1696
1697 for (i = 0; i < ARRAY_SIZE(convex_hull_tests); ++i) {
1698 isl_set *set1, *set2;
1699 int equal;
1700
1701 set1 = isl_set_read_from_str(ctx, str: convex_hull_tests[i].set);
1702 set2 = isl_set_read_from_str(ctx, str: convex_hull_tests[i].hull);
1703 set1 = isl_set_from_basic_set(bset: isl_set_convex_hull(set: set1));
1704 equal = isl_set_is_equal(set1, set2);
1705 isl_set_free(set: set1);
1706 isl_set_free(set: set2);
1707
1708 if (equal < 0)
1709 return -1;
1710 if (!equal)
1711 isl_die(ctx, isl_error_unknown,
1712 "unexpected convex hull", return -1);
1713 }
1714
1715 ctx->opt->convex = orig_convex;
1716
1717 return 0;
1718}
1719
1720static int test_convex_hull(isl_ctx *ctx)
1721{
1722 if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_FM) < 0)
1723 return -1;
1724 if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_WRAP) < 0)
1725 return -1;
1726 return 0;
1727}
1728
1729/* Check that computing the gist of "map" with respect to "context"
1730 * does not make any copy of "map" get marked empty.
1731 * Earlier versions of isl would end up doing that.
1732 */
1733static isl_stat test_gist_empty_pair(isl_ctx *ctx, const char *map,
1734 const char *context)
1735{
1736 isl_map *m1, *m2, *m3;
1737 isl_bool empty_before, empty_after;
1738
1739 m1 = isl_map_read_from_str(ctx, str: map);
1740 m2 = isl_map_read_from_str(ctx, str: context);
1741 m3 = isl_map_copy(map: m1);
1742 empty_before = isl_map_is_empty(map: m3);
1743 m1 = isl_map_gist(map: m1, context: m2);
1744 empty_after = isl_map_is_empty(map: m3);
1745 isl_map_free(map: m1);
1746 isl_map_free(map: m3);
1747
1748 if (empty_before < 0 || empty_after < 0)
1749 return isl_stat_error;
1750 if (empty_before)
1751 isl_die(ctx, isl_error_unknown, "map should not be empty",
1752 return isl_stat_error);
1753 if (empty_after)
1754 isl_die(ctx, isl_error_unknown, "map should still not be empty",
1755 return isl_stat_error);
1756
1757 return isl_stat_ok;
1758}
1759
1760/* Check that computing a gist does not make any copy of the input
1761 * get marked empty.
1762 * Earlier versions of isl would end up doing that on some pairs of inputs.
1763 */
1764static isl_stat test_gist_empty(isl_ctx *ctx)
1765{
1766 const char *map, *context;
1767
1768 map = "{ [] -> [a, b, c] : 2b = 1 + a }";
1769 context = "{ [] -> [a, b, c] : 2c = 2 + a }";
1770 if (test_gist_empty_pair(ctx, map, context) < 0)
1771 return isl_stat_error;
1772 map = "{ [] -> [0, 0] }";
1773 context = "{ [] -> [a, b] : a > b }";
1774 if (test_gist_empty_pair(ctx, map, context) < 0)
1775 return isl_stat_error;
1776
1777 return isl_stat_ok;
1778}
1779
1780/* Inputs to isl_map_plain_gist_basic_map, along with the expected output.
1781 */
1782struct {
1783 const char *map;
1784 const char *context;
1785 const char *gist;
1786} plain_gist_tests[] = {
1787 { "{ [i] -> [j] : i >= 1 and j >= 1 or i >= 2 and j <= 10 }",
1788 "{ [i] -> [j] : i >= 1 }",
1789 "{ [i] -> [j] : j >= 1 or i >= 2 and j <= 10 }" },
1790 { "{ [n] -> [i,j,k] : (i mod 3 = 2 and j mod 4 = 2) or "
1791 "(j mod 4 = 2 and k mod 6 = n) }",
1792 "{ [n] -> [i,j,k] : j mod 4 = 2 }",
1793 "{ [n] -> [i,j,k] : (i mod 3 = 2) or (k mod 6 = n) }" },
1794 { "{ [i] -> [j] : i > j and (exists a,b : i <= 2a + 5b <= 2) }",
1795 "{ [i] -> [j] : i > j }",
1796 "{ [i] -> [j] : exists a,b : i <= 2a + 5b <= 2 }" },
1797};
1798
1799/* Basic tests for isl_map_plain_gist_basic_map.
1800 */
1801static int test_plain_gist(isl_ctx *ctx)
1802{
1803 int i;
1804
1805 for (i = 0; i < ARRAY_SIZE(plain_gist_tests); ++i) {
1806 const char *str;
1807 int equal;
1808 isl_map *map, *gist;
1809 isl_basic_map *context;
1810
1811 map = isl_map_read_from_str(ctx, str: plain_gist_tests[i].map);
1812 str = plain_gist_tests[i].context;
1813 context = isl_basic_map_read_from_str(ctx, str);
1814 map = isl_map_plain_gist_basic_map(map, context);
1815 gist = isl_map_read_from_str(ctx, str: plain_gist_tests[i].gist);
1816 equal = isl_map_is_equal(map1: map, map2: gist);
1817 isl_map_free(map);
1818 isl_map_free(map: gist);
1819 if (equal < 0)
1820 return -1;
1821 if (!equal)
1822 isl_die(ctx, isl_error_unknown,
1823 "incorrect gist result", return -1);
1824 }
1825
1826 return 0;
1827}
1828
1829/* Inputs for isl_basic_set_gist tests that are expected to fail.
1830 */
1831struct {
1832 const char *set;
1833 const char *context;
1834} gist_fail_tests[] = {
1835 { "{ [i] : exists (e0, e1: 3e1 >= 1 + 2e0 and "
1836 "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }",
1837 "{ [i] : i >= 0 }" },
1838};
1839
1840/* Check that isl_basic_set_gist fails (gracefully) when expected.
1841 * In particular, the user should be able to recover from the failure.
1842 */
1843static isl_stat test_gist_fail(struct isl_ctx *ctx)
1844{
1845 int i, n;
1846 int on_error;
1847
1848 on_error = isl_options_get_on_error(ctx);
1849 isl_options_set_on_error(ctx, ISL_ON_ERROR_CONTINUE);
1850 n = ARRAY_SIZE(gist_fail_tests);
1851 for (i = 0; i < n; ++i) {
1852 const char *str;
1853 isl_basic_set *bset, *context;
1854
1855 bset = isl_basic_set_read_from_str(ctx, str: gist_fail_tests[i].set);
1856 str = gist_fail_tests[i].context;
1857 context = isl_basic_set_read_from_str(ctx, str);
1858 bset = isl_basic_set_gist(bset, context);
1859 isl_basic_set_free(bset);
1860 if (bset)
1861 break;
1862 }
1863 isl_options_set_on_error(ctx, val: on_error);
1864 if (i < n)
1865 isl_die(ctx, isl_error_unknown,
1866 "operation not expected to succeed",
1867 return isl_stat_error);
1868
1869 return isl_stat_ok;
1870}
1871
1872struct {
1873 const char *set;
1874 const char *context;
1875 const char *gist;
1876} gist_tests[] = {
1877 { "{ [1, -1, 3] }",
1878 "{ [1, b, 2 - b] : -1 <= b <= 2 }",
1879 "{ [a, -1, c] }" },
1880 { "{ [a, b, c] : a <= 15 and a >= 1 }",
1881 "{ [a, b, c] : exists (e0 = floor((-1 + a)/16): a >= 1 and "
1882 "c <= 30 and 32e0 >= -62 + 2a + 2b - c and b >= 0) }",
1883 "{ [a, b, c] : a <= 15 }" },
1884 { "{ : }", "{ : 1 = 0 }", "{ : }" },
1885 { "{ : 1 = 0 }", "{ : 1 = 0 }", "{ : }" },
1886 { "[M] -> { [x] : exists (e0 = floor((-2 + x)/3): 3e0 = -2 + x) }",
1887 "[M] -> { [3M] }" , "[M] -> { [x] : 1 = 0 }" },
1888 { "{ [m, n, a, b] : a <= 2147 + n }",
1889 "{ [m, n, a, b] : (m >= 1 and n >= 1 and a <= 2148 - m and "
1890 "b <= 2148 - n and b >= 0 and b >= 2149 - n - a) or "
1891 "(n >= 1 and a >= 0 and b <= 2148 - n - a and "
1892 "b >= 0) }",
1893 "{ [m, n, ku, kl] }" },
1894 { "{ [a, a, b] : a >= 10 }",
1895 "{ [a, b, c] : c >= a and c <= b and c >= 2 }",
1896 "{ [a, a, b] : a >= 10 }" },
1897 { "{ [i, j] : i >= 0 and i + j >= 0 }", "{ [i, j] : i <= 0 }",
1898 "{ [0, j] : j >= 0 }" },
1899 /* Check that no constraints on i6 are introduced in the gist */
1900 { "[t1] -> { [i4, i6] : exists (e0 = floor((1530 - 4t1 - 5i4)/20): "
1901 "20e0 <= 1530 - 4t1 - 5i4 and 20e0 >= 1511 - 4t1 - 5i4 and "
1902 "5e0 <= 381 - t1 and i4 <= 1) }",
1903 "[t1] -> { [i4, i6] : exists (e0 = floor((-t1 + i6)/5): "
1904 "5e0 = -t1 + i6 and i6 <= 6 and i6 >= 3) }",
1905 "[t1] -> { [i4, i6] : exists (e0 = floor((1530 - 4t1 - 5i4)/20): "
1906 "i4 <= 1 and 5e0 <= 381 - t1 and 20e0 <= 1530 - 4t1 - 5i4 and "
1907 "20e0 >= 1511 - 4t1 - 5i4) }" },
1908 /* Check that no constraints on i6 are introduced in the gist */
1909 { "[t1, t2] -> { [i4, i5, i6] : exists (e0 = floor((1 + i4)/2), "
1910 "e1 = floor((1530 - 4t1 - 5i4)/20), "
1911 "e2 = floor((-4t1 - 5i4 + 10*floor((1 + i4)/2))/20), "
1912 "e3 = floor((-1 + i4)/2): t2 = 0 and 2e3 = -1 + i4 and "
1913 "20e2 >= -19 - 4t1 - 5i4 + 10e0 and 5e2 <= 1 - t1 and "
1914 "2e0 <= 1 + i4 and 2e0 >= i4 and "
1915 "20e1 <= 1530 - 4t1 - 5i4 and "
1916 "20e1 >= 1511 - 4t1 - 5i4 and i4 <= 1 and "
1917 "5e1 <= 381 - t1 and 20e2 <= -4t1 - 5i4 + 10e0) }",
1918 "[t1, t2] -> { [i4, i5, i6] : exists (e0 = floor((-17 + i4)/2), "
1919 "e1 = floor((-t1 + i6)/5): 5e1 = -t1 + i6 and "
1920 "2e0 <= -17 + i4 and 2e0 >= -18 + i4 and "
1921 "10e0 <= -91 + 5i4 + 4i6 and "
1922 "10e0 >= -105 + 5i4 + 4i6) }",
1923 "[t1, t2] -> { [i4, i5, i6] : exists (e0 = floor((381 - t1)/5), "
1924 "e1 = floor((-1 + i4)/2): t2 = 0 and 2e1 = -1 + i4 and "
1925 "i4 <= 1 and 5e0 <= 381 - t1 and 20e0 >= 1511 - 4t1 - 5i4) }" },
1926 { "{ [0, 0, q, p] : -5 <= q <= 5 and p >= 0 }",
1927 "{ [a, b, q, p] : b >= 1 + a }",
1928 "{ [a, b, q, p] : false }" },
1929 { "[n] -> { [x] : x = n && x mod 32 = 0 }",
1930 "[n] -> { [x] : x mod 32 = 0 }",
1931 "[n] -> { [x = n] }" },
1932 { "{ [x] : x mod 6 = 0 }", "{ [x] : x mod 3 = 0 }",
1933 "{ [x] : x mod 2 = 0 }" },
1934 { "{ [x] : x mod 3200 = 0 }", "{ [x] : x mod 10000 = 0 }",
1935 "{ [x] : x mod 128 = 0 }" },
1936 { "{ [x] : x mod 3200 = 0 }", "{ [x] : x mod 10 = 0 }",
1937 "{ [x] : x mod 3200 = 0 }" },
1938 { "{ [a, b, c] : a mod 2 = 0 and a = c }",
1939 "{ [a, b, c] : b mod 2 = 0 and b = c }",
1940 "{ [a, b, c = a] }" },
1941 { "{ [a, b, c] : a mod 6 = 0 and a = c }",
1942 "{ [a, b, c] : b mod 2 = 0 and b = c }",
1943 "{ [a, b, c = a] : a mod 3 = 0 }" },
1944 { "{ [x] : 0 <= x <= 4 or 6 <= x <= 9 }",
1945 "{ [x] : 1 <= x <= 3 or 7 <= x <= 8 }",
1946 "{ [x] }" },
1947 { "{ [x,y] : x < 0 and 0 <= y <= 4 or x >= -2 and -x <= y <= 10 + x }",
1948 "{ [x,y] : 1 <= y <= 3 }",
1949 "{ [x,y] }" },
1950};
1951
1952/* Check that isl_set_gist behaves as expected.
1953 *
1954 * For the test cases in gist_tests, besides checking that the result
1955 * is as expected, also check that applying the gist operation does
1956 * not modify the input set (an earlier version of isl would do that) and
1957 * that the test case is consistent, i.e., that the gist has the same
1958 * intersection with the context as the input set.
1959 */
1960static int test_gist(struct isl_ctx *ctx)
1961{
1962 int i;
1963 const char *str;
1964 isl_basic_set *bset1, *bset2;
1965 isl_map *map1, *map2;
1966 isl_bool equal;
1967 isl_size n_div;
1968
1969 for (i = 0; i < ARRAY_SIZE(gist_tests); ++i) {
1970 isl_bool equal_input, equal_intersection;
1971 isl_set *set1, *set2, *copy, *context;
1972
1973 set1 = isl_set_read_from_str(ctx, str: gist_tests[i].set);
1974 context = isl_set_read_from_str(ctx, str: gist_tests[i].context);
1975 copy = isl_set_copy(set: set1);
1976 set1 = isl_set_gist(set: set1, context: isl_set_copy(set: context));
1977 set2 = isl_set_read_from_str(ctx, str: gist_tests[i].gist);
1978 equal = isl_set_is_equal(set1, set2);
1979 isl_set_free(set: set1);
1980 set1 = isl_set_read_from_str(ctx, str: gist_tests[i].set);
1981 equal_input = isl_set_is_equal(set1, set2: copy);
1982 isl_set_free(set: copy);
1983 set1 = isl_set_intersect(set1, set2: isl_set_copy(set: context));
1984 set2 = isl_set_intersect(set1: set2, set2: context);
1985 equal_intersection = isl_set_is_equal(set1, set2);
1986 isl_set_free(set: set2);
1987 isl_set_free(set: set1);
1988 if (equal < 0 || equal_input < 0 || equal_intersection < 0)
1989 return -1;
1990 if (!equal)
1991 isl_die(ctx, isl_error_unknown,
1992 "incorrect gist result", return -1);
1993 if (!equal_input)
1994 isl_die(ctx, isl_error_unknown,
1995 "gist modified input", return -1);
1996 if (!equal_input)
1997 isl_die(ctx, isl_error_unknown,
1998 "inconsistent gist test case", return -1);
1999 }
2000
2001 if (test_gist_fail(ctx) < 0)
2002 return -1;
2003
2004 str = "[p0, p2, p3, p5, p6, p10] -> { [] : "
2005 "exists (e0 = [(15 + p0 + 15p6 + 15p10)/16], e1 = [(p5)/8], "
2006 "e2 = [(p6)/128], e3 = [(8p2 - p5)/128], "
2007 "e4 = [(128p3 - p6)/4096]: 8e1 = p5 and 128e2 = p6 and "
2008 "128e3 = 8p2 - p5 and 4096e4 = 128p3 - p6 and p2 >= 0 and "
2009 "16e0 >= 16 + 16p6 + 15p10 and p2 <= 15 and p3 >= 0 and "
2010 "p3 <= 31 and p6 >= 128p3 and p5 >= 8p2 and p10 >= 0 and "
2011 "16e0 <= 15 + p0 + 15p6 + 15p10 and 16e0 >= p0 + 15p6 + 15p10 and "
2012 "p10 <= 15 and p10 <= -1 + p0 - p6) }";
2013 bset1 = isl_basic_set_read_from_str(ctx, str);
2014 str = "[p0, p2, p3, p5, p6, p10] -> { [] : exists (e0 = [(p5)/8], "
2015 "e1 = [(p6)/128], e2 = [(8p2 - p5)/128], "
2016 "e3 = [(128p3 - p6)/4096]: 8e0 = p5 and 128e1 = p6 and "
2017 "128e2 = 8p2 - p5 and 4096e3 = 128p3 - p6 and p5 >= -7 and "
2018 "p2 >= 0 and 8p2 <= -1 + p0 and p2 <= 15 and p3 >= 0 and "
2019 "p3 <= 31 and 128p3 <= -1 + p0 and p6 >= -127 and "
2020 "p5 <= -1 + p0 and p6 <= -1 + p0 and p6 >= 128p3 and "
2021 "p0 >= 1 and p5 >= 8p2 and p10 >= 0 and p10 <= 15 ) }";
2022 bset2 = isl_basic_set_read_from_str(ctx, str);
2023 bset1 = isl_basic_set_gist(bset: bset1, context: bset2);
2024 assert(bset1 && bset1->n_div == 0);
2025 isl_basic_set_free(bset: bset1);
2026
2027 /* Check that the integer divisions of the second disjunct
2028 * do not spread to the first disjunct.
2029 */
2030 str = "[t1] -> { S_0[] -> A[o0] : (exists (e0 = [(-t1 + o0)/16]: "
2031 "16e0 = -t1 + o0 and o0 >= 0 and o0 <= 15 and t1 >= 0)) or "
2032 "(exists (e0 = [(-1 + t1)/16], "
2033 "e1 = [(-16 + t1 - 16e0)/4294967296]: "
2034 "4294967296e1 = -16 + t1 - o0 - 16e0 and "
2035 "16e0 <= -1 + t1 and 16e0 >= -16 + t1 and o0 >= 0 and "
2036 "o0 <= 4294967295 and t1 <= -1)) }";
2037 map1 = isl_map_read_from_str(ctx, str);
2038 str = "[t1] -> { S_0[] -> A[o0] : t1 >= 0 and t1 <= 4294967295 }";
2039 map2 = isl_map_read_from_str(ctx, str);
2040 map1 = isl_map_gist(map: map1, context: map2);
2041 if (!map1)
2042 return -1;
2043 if (map1->n != 1)
2044 isl_die(ctx, isl_error_unknown, "expecting single disjunct",
2045 isl_map_free(map1); return -1);
2046 n_div = isl_basic_map_dim(bmap: map1->p[0], type: isl_dim_div);
2047 isl_map_free(map: map1);
2048 if (n_div < 0)
2049 return -1;
2050 if (n_div != 1)
2051 isl_die(ctx, isl_error_unknown, "expecting single div",
2052 return -1);
2053
2054 if (test_gist_empty(ctx) < 0)
2055 return -1;
2056 if (test_plain_gist(ctx) < 0)
2057 return -1;
2058
2059 return 0;
2060}
2061
2062int test_coalesce_set(isl_ctx *ctx, const char *str, int check_one)
2063{
2064 isl_set *set, *set2;
2065 int equal;
2066 int one;
2067
2068 set = isl_set_read_from_str(ctx, str);
2069 set = isl_set_coalesce(set);
2070 set2 = isl_set_read_from_str(ctx, str);
2071 equal = isl_set_is_equal(set1: set, set2);
2072 one = set && set->n == 1;
2073 isl_set_free(set);
2074 isl_set_free(set: set2);
2075
2076 if (equal < 0)
2077 return -1;
2078 if (!equal)
2079 isl_die(ctx, isl_error_unknown,
2080 "coalesced set not equal to input", return -1);
2081 if (check_one && !one)
2082 isl_die(ctx, isl_error_unknown,
2083 "coalesced set should not be a union", return -1);
2084
2085 return 0;
2086}
2087
2088/* Inputs for coalescing tests with unbounded wrapping.
2089 * "str" is a string representation of the input set.
2090 * "single_disjunct" is set if we expect the result to consist of
2091 * a single disjunct.
2092 */
2093struct {
2094 int single_disjunct;
2095 const char *str;
2096} coalesce_unbounded_tests[] = {
2097 { 1, "{ [x,y,z] : y + 2 >= 0 and x - y + 1 >= 0 and "
2098 "-x - y + 1 >= 0 and -3 <= z <= 3;"
2099 "[x,y,z] : -x+z + 20 >= 0 and -x-z + 20 >= 0 and "
2100 "x-z + 20 >= 0 and x+z + 20 >= 0 and "
2101 "-10 <= y <= 0}" },
2102 { 1, "{ [x,y] : 0 <= x,y <= 10; [5,y]: 4 <= y <= 11 }" },
2103 { 1, "{ [x,0,0] : -5 <= x <= 5; [0,y,1] : -5 <= y <= 5 }" },
2104 { 1, "{ [x,y] : 0 <= x <= 10 and 0 >= y >= -1 and x+y >= 0; [0,1] }" },
2105 { 1, "{ [x,y] : (0 <= x,y <= 4) or (2 <= x,y <= 5 and x + y <= 9) }" },
2106 { 0, "{ [x, y, z] : 0 <= x,y,z <= 100 and 0 < z <= 2 + 2x + 2y; "
2107 "[x, y, 0] : x,y <= 100 and y <= 9 + 11x and x <= 9 + 11y }" },
2108 { 1, "{ [0:1, 0:1]; [0, 2:3] }" },
2109 { 1, "{ [0:1, 0:1]; [0, 2:3]; [1, -2:-1] }" },
2110 { 1, "{ [0:3, 0:1]; [1:2, 2:5] }" },
2111 { 1, "{ [0:3, 0:1]; [0:2, 2:5] }" },
2112 { 1, "{ [0:3, 0:1]; [1:3, 2:5] }" },
2113 { 0, "{ [0:3, 0:1]; [1:4, 2:5] }" },
2114 { 0, "{ [0:3, 0:1]; [1:5, 2:5] }" },
2115};
2116
2117/* Test the functionality of isl_set_coalesce with the bounded wrapping
2118 * option turned off.
2119 */
2120int test_coalesce_unbounded_wrapping(isl_ctx *ctx)
2121{
2122 int i;
2123 int r = 0;
2124 int bounded;
2125
2126 bounded = isl_options_get_coalesce_bounded_wrapping(ctx);
2127 isl_options_set_coalesce_bounded_wrapping(ctx, val: 0);
2128
2129 for (i = 0; i < ARRAY_SIZE(coalesce_unbounded_tests); ++i) {
2130 const char *str = coalesce_unbounded_tests[i].str;
2131 int check_one = coalesce_unbounded_tests[i].single_disjunct;
2132 if (test_coalesce_set(ctx, str, check_one) >= 0)
2133 continue;
2134 r = -1;
2135 break;
2136 }
2137
2138 isl_options_set_coalesce_bounded_wrapping(ctx, val: bounded);
2139
2140 return r;
2141}
2142
2143/* Inputs for coalescing tests.
2144 * "str" is a string representation of the input set.
2145 * "single_disjunct" is set if we expect the result to consist of
2146 * a single disjunct.
2147 */
2148struct {
2149 int single_disjunct;
2150 const char *str;
2151} coalesce_tests[] = {
2152 { 1, "{[x,y]: x >= 0 & x <= 10 & y >= 0 & y <= 10 or "
2153 "y >= x & x >= 2 & 5 >= y }" },
2154 { 1, "{[x,y]: y >= 0 & 2x + y <= 30 & y <= 10 & x >= 0 or "
2155 "x + y >= 10 & y <= x & x + y <= 20 & y >= 0}" },
2156 { 0, "{[x,y]: y >= 0 & 2x + y <= 30 & y <= 10 & x >= 0 or "
2157 "x + y >= 10 & y <= x & x + y <= 19 & y >= 0}" },
2158 { 1, "{[x,y]: y >= 0 & x <= 5 & y <= x or "
2159 "y >= 0 & x >= 6 & x <= 10 & y <= x}" },
2160 { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or "
2161 "y >= 0 & x >= 7 & x <= 10 & y <= x}" },
2162 { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or "
2163 "y >= 0 & x >= 6 & x <= 10 & y + 1 <= x}" },
2164 { 1, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 6 & y <= 6}" },
2165 { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 7 & y <= 6}" },
2166 { 1, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 6 & y <= 5}" },
2167 { 0, "{[x,y]: y >= 0 & x <= 5 & y <= x or y >= 0 & x = 6 & y <= 7}" },
2168 { 1, "[n] -> { [i] : i = 1 and n >= 2 or 2 <= i and i <= n }" },
2169 { 0, "{[x,y] : x >= 0 and y >= 0 or 0 <= y and y <= 5 and x = -1}" },
2170 { 1, "[n] -> { [i] : 1 <= i and i <= n - 1 or 2 <= i and i <= n }" },
2171 { 0, "[n] -> { [[i0] -> [o0]] : exists (e0 = [(i0)/4], e1 = [(o0)/4], "
2172 "e2 = [(n)/2], e3 = [(-2 + i0)/4], e4 = [(-2 + o0)/4], "
2173 "e5 = [(-2n + i0)/4]: 2e2 = n and 4e3 = -2 + i0 and "
2174 "4e4 = -2 + o0 and i0 >= 8 + 2n and o0 >= 2 + i0 and "
2175 "o0 <= 56 + 2n and o0 <= -12 + 4n and i0 <= 57 + 2n and "
2176 "i0 <= -11 + 4n and o0 >= 6 + 2n and 4e0 <= i0 and "
2177 "4e0 >= -3 + i0 and 4e1 <= o0 and 4e1 >= -3 + o0 and "
2178 "4e5 <= -2n + i0 and 4e5 >= -3 - 2n + i0);"
2179 "[[i0] -> [o0]] : exists (e0 = [(i0)/4], e1 = [(o0)/4], "
2180 "e2 = [(n)/2], e3 = [(-2 + i0)/4], e4 = [(-2 + o0)/4], "
2181 "e5 = [(-2n + i0)/4]: 2e2 = n and 4e3 = -2 + i0 and "
2182 "4e4 = -2 + o0 and 2e0 >= 3 + n and e0 <= -4 + n and "
2183 "2e0 <= 27 + n and e1 <= -4 + n and 2e1 <= 27 + n and "
2184 "2e1 >= 2 + n and e1 >= 1 + e0 and i0 >= 7 + 2n and "
2185 "i0 <= -11 + 4n and i0 <= 57 + 2n and 4e0 <= -2 + i0 and "
2186 "4e0 >= -3 + i0 and o0 >= 6 + 2n and o0 <= -11 + 4n and "
2187 "o0 <= 57 + 2n and 4e1 <= -2 + o0 and 4e1 >= -3 + o0 and "
2188 "4e5 <= -2n + i0 and 4e5 >= -3 - 2n + i0 ) }" },
2189 { 0, "[n, m] -> { [o0, o2, o3] : (o3 = 1 and o0 >= 1 + m and "
2190 "o0 <= n + m and o2 <= m and o0 >= 2 + n and o2 >= 3) or "
2191 "(o0 >= 2 + n and o0 >= 1 + m and o0 <= n + m and n >= 1 and "
2192 "o3 <= -1 + o2 and o3 >= 1 - m + o2 and o3 >= 2 and o3 <= n) }" },
2193 { 0, "[M, N] -> { [[i0, i1, i2, i3, i4, i5, i6] -> "
2194 "[o0, o1, o2, o3, o4, o5, o6]] : "
2195 "(o6 <= -4 + 2M - 2N + i0 + i1 - i2 + i6 - o0 - o1 + o2 and "
2196 "o3 <= -2 + i3 and o6 >= 2 + i0 + i3 + i6 - o0 - o3 and "
2197 "o6 >= 2 - M + N + i3 + i4 + i6 - o3 - o4 and o0 <= -1 + i0 and "
2198 "o4 >= 4 - 3M + 3N - i0 - i1 + i2 + 2i3 + i4 + o0 + o1 - o2 - 2o3 "
2199 "and o6 <= -3 + 2M - 2N + i3 + i4 - i5 + i6 - o3 - o4 + o5 and "
2200 "2o6 <= -5 + 5M - 5N + 2i0 + i1 - i2 - i5 + 2i6 - 2o0 - o1 + o2 + o5 "
2201 "and o6 >= 2i0 + i1 + i6 - 2o0 - o1 and "
2202 "3o6 <= -5 + 4M - 4N + 2i0 + i1 - i2 + 2i3 + i4 - i5 + 3i6 "
2203 "- 2o0 - o1 + o2 - 2o3 - o4 + o5) or "
2204 "(N >= 2 and o3 <= -1 + i3 and o0 <= -1 + i0 and "
2205 "o6 >= i3 + i6 - o3 and M >= 0 and "
2206 "2o6 >= 1 + i0 + i3 + 2i6 - o0 - o3 and "
2207 "o6 >= 1 - M + i0 + i6 - o0 and N >= 2M and o6 >= i0 + i6 - o0) }" },
2208 { 0, "[M, N] -> { [o0] : (o0 = 0 and M >= 1 and N >= 2) or "
2209 "(o0 = 0 and M >= 1 and N >= 2M and N >= 2 + M) or "
2210 "(o0 = 0 and M >= 2 and N >= 3) or "
2211 "(M = 0 and o0 = 0 and N >= 3) }" },
2212 { 0, "{ [i0, i1, i2, i3] : (i1 = 10i0 and i0 >= 1 and 10i0 <= 100 and "
2213 "i3 <= 9 + 10 i2 and i3 >= 1 + 10i2 and i3 >= 0) or "
2214 "(i1 <= 9 + 10i0 and i1 >= 1 + 10i0 and i2 >= 0 and "
2215 "i0 >= 0 and i1 <= 100 and i3 <= 9 + 10i2 and i3 >= 1 + 10i2) }" },
2216 { 0, "[M] -> { [i1] : (i1 >= 2 and i1 <= M) or (i1 = M and M >= 1) }" },
2217 { 0, "{[x,y] : x,y >= 0; [x,y] : 10 <= x <= 20 and y >= -1 }" },
2218 { 1, "{ [x, y] : (x >= 1 and y >= 1 and x <= 2 and y <= 2) or "
2219 "(y = 3 and x = 1) }" },
2220 { 1, "[M] -> { [i0, i1, i2, i3, i4] : (i1 >= 3 and i4 >= 2 + i2 and "
2221 "i2 >= 2 and i0 >= 2 and i3 >= 1 + i2 and i0 <= M and "
2222 "i1 <= M and i3 <= M and i4 <= M) or "
2223 "(i1 >= 2 and i4 >= 1 + i2 and i2 >= 2 and i0 >= 2 and "
2224 "i3 >= 1 + i2 and i0 <= M and i1 <= -1 + M and i3 <= M and "
2225 "i4 <= -1 + M) }" },
2226 { 1, "{ [x, y] : (x >= 0 and y >= 0 and x <= 10 and y <= 10) or "
2227 "(x >= 1 and y >= 1 and x <= 11 and y <= 11) }" },
2228 { 0, "{[x,0] : x >= 0; [x,1] : x <= 20}" },
2229 { 1, "{ [x, 1 - x] : 0 <= x <= 1; [0,0] }" },
2230 { 1, "{ [0,0]; [i,i] : 1 <= i <= 10 }" },
2231 { 0, "{ [0,0]; [i,j] : 1 <= i,j <= 10 }" },
2232 { 1, "{ [0,0]; [i,2i] : 1 <= i <= 10 }" },
2233 { 0, "{ [0,0]; [i,2i] : 2 <= i <= 10 }" },
2234 { 0, "{ [1,0]; [i,2i] : 1 <= i <= 10 }" },
2235 { 0, "{ [0,1]; [i,2i] : 1 <= i <= 10 }" },
2236 { 0, "{ [a, b] : exists e : 2e = a and "
2237 "a >= 0 and (a <= 3 or (b <= 0 and b >= -4 + a)) }" },
2238 { 0, "{ [i, j, i', j'] : i <= 2 and j <= 2 and "
2239 "j' >= -1 + 2i + j - 2i' and i' <= -1 + i and "
2240 "j >= 1 and j' <= i + j - i' and i >= 1; "
2241 "[1, 1, 1, 1] }" },
2242 { 1, "{ [i,j] : exists a,b : i = 2a and j = 3b; "
2243 "[i,j] : exists a : j = 3a }" },
2244 { 1, "{ [a, b, c] : (c <= 7 - b and b <= 1 and b >= 0 and "
2245 "c >= 3 + b and b <= 3 + 8a and b >= -26 + 8a and "
2246 "a >= 3) or "
2247 "(b <= 1 and c <= 7 and b >= 0 and c >= 4 + b and "
2248 "b <= 3 + 8a and b >= -26 + 8a and a >= 3) }" },
2249 { 1, "{ [a, 0, c] : c >= 1 and c <= 29 and c >= -1 + 8a and "
2250 "c <= 6 + 8a and a >= 3; "
2251 "[a, -1, c] : c >= 1 and c <= 30 and c >= 8a and "
2252 "c <= 7 + 8a and a >= 3 and a <= 4 }" },
2253 { 1, "{ [x,y] : 0 <= x <= 2 and y >= 0 and x + 2y <= 4; "
2254 "[x,0] : 3 <= x <= 4 }" },
2255 { 1, "{ [x,y] : 0 <= x <= 3 and y >= 0 and x + 3y <= 6; "
2256 "[x,0] : 4 <= x <= 5 }" },
2257 { 0, "{ [x,y] : 0 <= x <= 2 and y >= 0 and x + 2y <= 4; "
2258 "[x,0] : 3 <= x <= 5 }" },
2259 { 0, "{ [x,y] : 0 <= x <= 2 and y >= 0 and x + y <= 4; "
2260 "[x,0] : 3 <= x <= 4 }" },
2261 { 1, "{ [i0, i1] : i0 <= 122 and i0 >= 1 and 128i1 >= -249 + i0 and "
2262 "i1 <= 0; "
2263 "[i0, 0] : i0 >= 123 and i0 <= 124 }" },
2264 { 1, "{ [0,0]; [1,1] }" },
2265 { 1, "[n] -> { [k] : 16k <= -1 + n and k >= 1; [0] : n >= 2 }" },
2266 { 1, "{ [k, ii, k - ii] : ii >= -6 + k and ii <= 6 and ii >= 1 and "
2267 "ii <= k;"
2268 "[k, 0, k] : k <= 6 and k >= 1 }" },
2269 { 1, "{ [i,j] : i = 4 j and 0 <= i <= 100;"
2270 "[i,j] : 1 <= i <= 100 and i >= 4j + 1 and i <= 4j + 2 }" },
2271 { 1, "{ [x,y] : x % 2 = 0 and y % 2 = 0; [x,x] : x % 2 = 0 }" },
2272 { 1, "[n] -> { [1] : n >= 0;"
2273 "[x] : exists (e0 = floor((x)/2): x >= 2 and "
2274 "2e0 >= -1 + x and 2e0 <= x and 2e0 <= n) }" },
2275 { 1, "[n] -> { [x, y] : exists (e0 = floor((x)/2), e1 = floor((y)/3): "
2276 "3e1 = y and x >= 2 and 2e0 >= -1 + x and "
2277 "2e0 <= x and 2e0 <= n);"
2278 "[1, y] : exists (e0 = floor((y)/3): 3e0 = y and "
2279 "n >= 0) }" },
2280 { 1, "[t1] -> { [i0] : (exists (e0 = floor((63t1)/64): "
2281 "128e0 >= -134 + 127t1 and t1 >= 2 and "
2282 "64e0 <= 63t1 and 64e0 >= -63 + 63t1)) or "
2283 "t1 = 1 }" },
2284 { 1, "{ [i, i] : exists (e0 = floor((1 + 2i)/3): 3e0 <= 2i and "
2285 "3e0 >= -1 + 2i and i <= 9 and i >= 1);"
2286 "[0, 0] }" },
2287 { 1, "{ [t1] : exists (e0 = floor((-11 + t1)/2): 2e0 = -11 + t1 and "
2288 "t1 >= 13 and t1 <= 16);"
2289 "[t1] : t1 <= 15 and t1 >= 12 }" },
2290 { 1, "{ [x,y] : x = 3y and 0 <= y <= 2; [-3,-1] }" },
2291 { 1, "{ [x,y] : 2x = 3y and 0 <= y <= 4; [-3,-2] }" },
2292 { 0, "{ [x,y] : 2x = 3y and 0 <= y <= 4; [-2,-2] }" },
2293 { 0, "{ [x,y] : 2x = 3y and 0 <= y <= 4; [-3,-1] }" },
2294 { 1, "{ [i] : exists j : i = 4 j and 0 <= i <= 100;"
2295 "[i] : exists j : 1 <= i <= 100 and i >= 4j + 1 and "
2296 "i <= 4j + 2 }" },
2297 { 1, "{ [c0] : (exists (e0 : c0 - 1 <= 3e0 <= c0)) or "
2298 "(exists (e0 : 3e0 = -2 + c0)) }" },
2299 { 0, "[n, b0, t0] -> "
2300 "{ [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] : "
2301 "(exists (e0 = floor((-32b0 + i4)/1048576), "
2302 "e1 = floor((i8)/32): 1048576e0 = -32b0 + i4 and 32e1 = i8 and "
2303 "n <= 2147483647 and b0 <= 32767 and b0 >= 0 and "
2304 "32b0 <= -2 + n and t0 <= 31 and t0 >= 0 and i0 >= 8 + n and "
2305 "3i4 <= -96 + 3t0 + i0 and 3i4 >= -95 - n + 3t0 + i0 and "
2306 "i8 >= -157 + i0 - 4i4 and i8 >= 0 and "
2307 "i8 <= -33 + i0 - 4i4 and 3i8 <= -91 + 4n - i0)) or "
2308 "(exists (e0 = floor((-32b0 + i4)/1048576), "
2309 "e1 = floor((i8)/32): 1048576e0 = -32b0 + i4 and 32e1 = i8 and "
2310 "n <= 2147483647 and b0 <= 32767 and b0 >= 0 and "
2311 "32b0 <= -2 + n and t0 <= 31 and t0 >= 0 and i0 <= 7 + n and "
2312 "4i4 <= -3 + i0 and 3i4 <= -96 + 3t0 + i0 and "
2313 "3i4 >= -95 - n + 3t0 + i0 and i8 >= -157 + i0 - 4i4 and "
2314 "i8 >= 0 and i8 <= -4 + i0 - 3i4 and i8 <= -41 + i0));"
2315 "[i0, i1, i2, i3, 0, i5, i6, i7, i8, i9, i10, i11, i12] : "
2316 "(exists (e0 = floor((i8)/32): b0 = 0 and 32e0 = i8 and "
2317 "n <= 2147483647 and t0 <= 31 and t0 >= 0 and i0 >= 11 and "
2318 "i0 >= 96 - 3t0 and i0 <= 95 + n - 3t0 and i0 <= 7 + n and "
2319 "i8 >= -40 + i0 and i8 <= -10 + i0)) }" },
2320 { 0, "{ [i0, i1, i2] : "
2321 "(exists (e0, e1 = floor((i0)/32), e2 = floor((i1)/32): "
2322 "32e1 = i0 and 32e2 = i1 and i1 >= -31 + i0 and "
2323 "i1 <= 31 + i0 and i2 >= -30 + i0 and i2 >= -30 + i1 and "
2324 "32e0 >= -30 + i0 and 32e0 >= -30 + i1 and "
2325 "32e0 >= -31 + i2 and 32e0 <= 30 + i2 and 32e0 <= 31 + i1 and "
2326 "32e0 <= 31 + i0)) or "
2327 "i0 >= 0 }" },
2328 { 1, "{ [a, b, c] : 2b = 1 + a and 2c = 2 + a; [0, 0, 0] }" },
2329 { 1, "{ [a, a, b, c] : 32*floor((a)/32) = a and 2*floor((b)/2) = b and "
2330 "2*floor((c)/2) = c and 0 <= a <= 192;"
2331 "[224, 224, b, c] : 2*floor((b)/2) = b and 2*floor((c)/2) = c }"
2332 },
2333 { 1, "[n] -> { [a,b] : (exists e : 1 <= a <= 7e and 9e <= b <= n) or "
2334 "(0 <= a <= b <= n) }" },
2335 { 1, "{ [a, b] : 0 <= a <= 2 and b >= 0 and "
2336 "((0 < b <= 13) or (2*floor((a + b)/2) >= -5 + a + 2b)) }" },
2337 { 1, "{ [a] : (2 <= a <= 5) or (a mod 2 = 1 and 1 <= a <= 5) }" },
2338 { 1, "{ [a, b, c] : (b = -1 + a and 0 < a <= 3 and "
2339 "9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or "
2340 "(exists (e0 = floor((-16 + 2c)/9): a = 4 and "
2341 "b = 3 and 9e0 <= -19 + 2c)) }" },
2342 { 1, "{ [a, b, c] : (b = -1 + a and 0 < a <= 3 and "
2343 "9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or "
2344 "(a = 4 and b = 3 and "
2345 "9*floor((-16 + 2c)/9) <= -19 + 2c) }" },
2346 { 0, "{ [a, b, c] : (b <= 2 and b <= -2 + a) or "
2347 "(b = -1 + a and 0 < a <= 3 and "
2348 "9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or "
2349 "(exists (e0 = floor((-16 + 2c)/9): a = 4 and "
2350 "b = 3 and 9e0 <= -19 + 2c)) }" },
2351 { 1, "{ [y, x] : (x - y) mod 3 = 2 and 2 <= y <= 200 and 0 <= x <= 2;"
2352 "[1, 0] }" },
2353 { 1, "{ [x, y] : (x - y) mod 3 = 2 and 2 <= y <= 200 and 0 <= x <= 2;"
2354 "[0, 1] }" },
2355 { 1, "{ [1, y] : -1 <= y <= 1; [x, -x] : 0 <= x <= 1 }" },
2356 { 1, "{ [1, y] : 0 <= y <= 1; [x, -x] : 0 <= x <= 1 }" },
2357 { 1, "{ [x, y] : 0 <= x <= 10 and x - 4*floor(x/4) <= 1 and y <= 0; "
2358 "[x, y] : 0 <= x <= 10 and x - 4*floor(x/4) > 1 and y <= 0; "
2359 "[x, y] : 0 <= x <= 10 and x - 5*floor(x/5) <= 1 and 0 < y; "
2360 "[x, y] : 0 <= x <= 10 and x - 5*floor(x/5) > 1 and 0 < y }" },
2361 { 1, "{ [x, 0] : 0 <= x <= 10 and x mod 2 = 0; "
2362 "[x, 0] : 0 <= x <= 10 and x mod 2 = 1; "
2363 "[x, y] : 0 <= x <= 10 and 1 <= y <= 10 }" },
2364 { 1, "{ [a] : a <= 8 and "
2365 "(a mod 10 = 7 or a mod 10 = 8 or a mod 10 = 9) }" },
2366 { 1, "{ [x, y] : 2y = -x and x <= 0 or "
2367 "x <= -1 and 2y <= -x - 1 and 2y >= x - 1 }" },
2368 { 0, "{ [x, y] : 2y = -x and x <= 0 or "
2369 "x <= -2 and 2y <= -x - 1 and 2y >= x - 1 }" },
2370 { 1, "{ [a] : (a <= 0 and 3*floor((a)/3) = a) or "
2371 "(a < 0 and 3*floor((a)/3) < a) }" },
2372 { 1, "{ [a] : (a <= 0 and 3*floor((a)/3) = a) or "
2373 "(a < -1 and 3*floor((a)/3) < a) }" },
2374 { 1, "{ [a, b] : a <= 1024 and b >= 0 and "
2375 "((-31 - a + b <= 32*floor((-1 - a)/32) <= -33 + b and "
2376 "32*floor((-1 - a)/32) <= -16 + b + 16*floor((-1 - a)/16))"
2377 "or (2 <= a <= 15 and b < a)) }" },
2378 { 1, "{ [a] : a > 0 and ((16*floor((a)/16) < a and "
2379 "32*floor((a)/32) < a) or a <= 15) }" },
2380 { 1, "{ [a, b, c, d] : (-a + d) mod 64 = 0 and a <= 8 and b <= 1 and "
2381 "10 - a <= c <= 3 and d >= 5 and 9 - 64b <= d <= 70;"
2382 "[a, b = 1, c, d] : (-a + d) mod 64 = 0 and a <= 8 and c >= 4 and "
2383 "10 - a <= c <= 5 and 5 <= d <= 73 - c }" },
2384 { 1, "[n, m] -> { S_0[i] : (-n + i) mod 3 = 0 and m >= 3 + n and "
2385 "i >= n and 3*floor((2 + n + 2m)/3) <= n + 3m - i; "
2386 "S_0[n] : n <= m <= 2 + n }" },
2387 { 1, "{ [a, b] : exists (e0: 0 <= a <= 1 and b >= 0 and "
2388 "2e0 >= -5 + a + 2b and 2e0 >= -1 + a + b and "
2389 "2e0 <= a + b); "
2390 "[a, b] : exists (e0: 0 <= a <= 1 and 2e0 >= -5 + a + 2b and "
2391 "2e0 >= -1 - a + b and 2e0 <= -a + b and "
2392 "2e0 < -a + 2b) }" },
2393 { 1, "{ [i, j, i - 8j] : 8 <= i <= 63 and -7 + i <= 8j <= i; "
2394 "[i, 0, i] : 0 <= i <= 7 }" },
2395 { 1, "{ [a, b] : a >= 0 and 0 <= b <= 1 - a; [1, 1] }" },
2396 { 0, "{ [a, b] : a >= 0 and 0 <= b <= 1 - a; [0, 2] }" },
2397 { 0, "{ [a, b] : a >= 0 and 0 <= b <= 1 - a; [-1, 3] }" },
2398 { 1, "{ [a, b] : a, b >= 0 and a + 2b <= 2; [1, 1] }" },
2399 { 0, "{ [a, b] : a, b >= 0 and a + 2b <= 2; [2, 1] }" },
2400 { 0, "{ [a, c] : (2 + a) mod 4 = 0 or "
2401 "(c = 4 + a and 4 * floor((a)/4) = a and a >= 0 and a <= 4) or "
2402 "(c = 3 + a and 4 * floor((-1 + a)/4) = -1 + a and "
2403 "a > 0 and a <= 5) }" },
2404 { 1, "{ [1, 0, 0]; [a, b, c] : -1 <= -a < b <= 0 and 2c > b }" },
2405 { 0, "{ [j, a, l] : a mod 2 = 0 and j <= 29 and a >= 2 and "
2406 "2a <= -5 + j and 32j + 2a + 2 <= 4l < 33j; "
2407 "[j, 0, l] : 4 <= j <= 29 and -3 + 33j <= 4l <= 33j }" },
2408 { 0, "{ [0:1, 0:1]; [0, 2:3] }" },
2409 { 1, "{ [a] : (a = 0 or ((1 + a) mod 2 = 0 and 0 < a <= 15) or "
2410 "((a) mod 2 = 0 and 0 < a <= 15)) }" },
2411 { 1, "{ rat: [0:2]; rat: [1:3] }" },
2412};
2413
2414/* A specialized coalescing test case that would result
2415 * in a segmentation fault or a failed assertion in earlier versions of isl.
2416 */
2417static int test_coalesce_special(struct isl_ctx *ctx)
2418{
2419 const char *str;
2420 isl_map *map1, *map2;
2421
2422 str = "[y] -> { [S_L220_OUT[] -> T7[]] -> "
2423 "[[S_L309_IN[] -> T11[]] -> ce_imag2[1, o1]] : "
2424 "(y = 201 and o1 <= 239 and o1 >= 212) or "
2425 "(exists (e0 = [(y)/3]: 3e0 = y and y <= 198 and y >= 3 and "
2426 "o1 <= 239 and o1 >= 212)) or "
2427 "(exists (e0 = [(y)/3]: 3e0 = y and y <= 201 and y >= 3 and "
2428 "o1 <= 241 and o1 >= 240));"
2429 "[S_L220_OUT[] -> T7[]] -> "
2430 "[[S_L309_IN[] -> T11[]] -> ce_imag2[0, o1]] : "
2431 "(y = 2 and o1 <= 241 and o1 >= 212) or "
2432 "(exists (e0 = [(-2 + y)/3]: 3e0 = -2 + y and y <= 200 and "
2433 "y >= 5 and o1 <= 241 and o1 >= 212)) }";
2434 map1 = isl_map_read_from_str(ctx, str);
2435 map1 = isl_map_align_divs_internal(map: map1);
2436 map1 = isl_map_coalesce(map: map1);
2437 str = "[y] -> { [S_L220_OUT[] -> T7[]] -> "
2438 "[[S_L309_IN[] -> T11[]] -> ce_imag2[o0, o1]] : "
2439 "exists (e0 = [(-1 - y + o0)/3]: 3e0 = -1 - y + o0 and "
2440 "y <= 201 and o0 <= 2 and o1 >= 212 and o1 <= 241 and "
2441 "o0 >= 3 - y and o0 <= -2 + y and o0 >= 0) }";
2442 map2 = isl_map_read_from_str(ctx, str);
2443 map2 = isl_map_union(map1: map2, map2: map1);
2444 map2 = isl_map_align_divs_internal(map: map2);
2445 map2 = isl_map_coalesce(map: map2);
2446 isl_map_free(map: map2);
2447 if (!map2)
2448 return -1;
2449
2450 return 0;
2451}
2452
2453/* Check that the union of the basic sets described by "str1" and "str2"
2454 * can be coalesced and that the result is equal to the union.
2455 * The explicit call to isl_basic_set_union prevents the implicit
2456 * equality constraints in the basic maps from being detected prior
2457 * to the call to isl_set_coalesce, at least at the point
2458 * where this function was introduced.
2459 */
2460static isl_stat test_coalesce_union(isl_ctx *ctx, const char *str1,
2461 const char *str2)
2462{
2463 isl_basic_set *bset1, *bset2;
2464 isl_set *set, *set2;
2465 isl_bool equal;
2466
2467 bset1 = isl_basic_set_read_from_str(ctx, str: str1);
2468 bset2 = isl_basic_set_read_from_str(ctx, str: str2);
2469 set = isl_basic_set_union(bset1, bset2);
2470 set = isl_set_coalesce(set);
2471
2472 bset1 = isl_basic_set_read_from_str(ctx, str: str1);
2473 bset2 = isl_basic_set_read_from_str(ctx, str: str2);
2474 set2 = isl_basic_set_union(bset1, bset2);
2475
2476 equal = isl_set_is_equal(set1: set, set2);
2477 isl_set_free(set);
2478 isl_set_free(set: set2);
2479
2480 if (equal < 0)
2481 return isl_stat_error;
2482 if (!equal)
2483 isl_die(ctx, isl_error_unknown,
2484 "coalesced set not equal to input",
2485 return isl_stat_error);
2486
2487 return isl_stat_non_null(obj: set);
2488}
2489
2490/* A specialized coalescing test case that would result in an assertion
2491 * in an earlier version of isl. Use test_coalesce_union with
2492 * an explicit call to isl_basic_set_union to prevent the implicit
2493 * equality constraints in the first basic map from being detected prior
2494 * to the call to isl_set_coalesce, at least at the point
2495 * where this test case was introduced.
2496 */
2497static isl_stat test_coalesce_special2(struct isl_ctx *ctx)
2498{
2499 const char *str1;
2500 const char *str2;
2501
2502 str1 = "{ [x, y] : x, y >= 0 and x + 2y <= 1 and 2x + y <= 1 }";
2503 str2 = "{ [x,0] : -1 <= x <= 1 and x mod 2 = 1 }";
2504 return test_coalesce_union(ctx, str1, str2);
2505}
2506
2507/* Check that calling isl_set_coalesce does not leave other sets
2508 * that may share some information with the input to isl_set_coalesce
2509 * in an inconsistent state.
2510 * In particular, older versions of isl would modify all copies
2511 * of the basic sets in the isl_set_coalesce input in a way
2512 * that could leave them in an inconsistent state.
2513 * The result of printing any other set containing one of these
2514 * basic sets would then result in an invalid set description.
2515 */
2516static int test_coalesce_special3(isl_ctx *ctx)
2517{
2518 const char *str;
2519 char *s;
2520 isl_set *set1, *set2;
2521 isl_printer *p;
2522
2523 set1 = isl_set_read_from_str(ctx, str: "{ [0, 0, 0] }");
2524 str = "{ [a, b, a + b] : a >= 0 and b >= 0 and 0 < a + b }";
2525 set2 = isl_set_read_from_str(ctx, str);
2526 set1 = isl_set_union(set1, set2: isl_set_copy(set: set2));
2527 set1 = isl_set_coalesce(set: set1);
2528 isl_set_free(set: set1);
2529
2530 p = isl_printer_to_str(ctx);
2531 p = isl_printer_print_set(printer: p, map: set2);
2532 isl_set_free(set: set2);
2533 s = isl_printer_get_str(printer: p);
2534 isl_printer_free(printer: p);
2535 set1 = isl_set_read_from_str(ctx, str: s);
2536 free(ptr: s);
2537 isl_set_free(set: set1);
2538
2539 if (!set1)
2540 return -1;
2541
2542 return 0;
2543}
2544
2545/* Check that calling isl_set_coalesce on the intersection of
2546 * the sets described by "s1" and "s2" does not leave other sets
2547 * that may share some information with the input to isl_set_coalesce
2548 * in an inconsistent state.
2549 * In particular, when isl_set_coalesce detects equality constraints,
2550 * it does not immediately perform Gaussian elimination on them,
2551 * but then it needs to ensure that it is performed at some point.
2552 * The input set has implicit equality constraints in the first disjunct.
2553 * It is constructed as an intersection, because otherwise
2554 * those equality constraints would already be detected during parsing.
2555 */
2556static isl_stat test_coalesce_intersection(isl_ctx *ctx,
2557 const char *s1, const char *s2)
2558{
2559 isl_set *set1, *set2;
2560
2561 set1 = isl_set_read_from_str(ctx, str: s1);
2562 set2 = isl_set_read_from_str(ctx, str: s2);
2563 set1 = isl_set_intersect(set1, set2);
2564 isl_set_free(set: isl_set_coalesce(set: isl_set_copy(set: set1)));
2565 set1 = isl_set_coalesce(set: set1);
2566 isl_set_free(set: set1);
2567
2568 if (!set1)
2569 return isl_stat_error;
2570
2571 return isl_stat_ok;
2572}
2573
2574/* Check that calling isl_set_coalesce does not leave other sets
2575 * that may share some information with the input to isl_set_coalesce
2576 * in an inconsistent state, for the case where one disjunct
2577 * is a subset of the other.
2578 */
2579static isl_stat test_coalesce_special4(isl_ctx *ctx)
2580{
2581 const char *s1, *s2;
2582
2583 s1 = "{ [a, b] : b <= 0 or a <= 1 }";
2584 s2 = "{ [a, b] : -1 <= -a < b }";
2585 return test_coalesce_intersection(ctx, s1, s2);
2586}
2587
2588/* Check that calling isl_set_coalesce does not leave other sets
2589 * that may share some information with the input to isl_set_coalesce
2590 * in an inconsistent state, for the case where two disjuncts
2591 * can be fused.
2592 */
2593static isl_stat test_coalesce_special5(isl_ctx *ctx)
2594{
2595 const char *s1, *s2;
2596
2597 s1 = "{ [a, b, c] : b <= 0 }";
2598 s2 = "{ [a, b, c] : -1 <= -a < b and (c >= 0 or c < 0) }";
2599 return test_coalesce_intersection(ctx, s1, s2);
2600}
2601
2602/* Check that calling isl_set_coalesce does not leave other sets
2603 * that may share some information with the input to isl_set_coalesce
2604 * in an inconsistent state, for the case where two disjuncts
2605 * can be fused and where both disjuncts have implicit equality constraints.
2606 */
2607static isl_stat test_coalesce_special6(isl_ctx *ctx)
2608{
2609 const char *s1, *s2;
2610
2611 s1 = "{ [a, b, c] : c <= 0 }";
2612 s2 = "{ [a, b, c] : 0 <= a <= b <= c or (0 <= b <= c and a > 0) }";
2613 return test_coalesce_intersection(ctx, s1, s2);
2614}
2615
2616/* A specialized coalescing test case that would result in an assertion failure
2617 * in an earlier version of isl. Use test_coalesce_union with
2618 * an explicit call to isl_basic_set_union to prevent the implicit
2619 * equality constraints in the basic maps from being detected prior
2620 * to the call to isl_set_coalesce, at least at the point
2621 * where this test case was introduced.
2622 */
2623static isl_stat test_coalesce_special7(isl_ctx *ctx)
2624{
2625 const char *str1;
2626 const char *str2;
2627
2628 str1 = "{ [a, b, c=0:17] : a <= 7 and 2b <= 11 - a and "
2629 "c <= -7 + 2a and 2c >= - 3 + 3a - 2b }";
2630 str2 = "{ [a, b, c] : c > -15a and c >= -7 + 2a and c < 0 and "
2631 "3c <= -5 + 5a - 3b and 2b >= 11 - a }";
2632 return test_coalesce_union(ctx, str1, str2);
2633}
2634
2635/* A specialized coalescing test case that would result in a disjunct
2636 * getting dropped in an earlier version of isl. Use test_coalesce_union with
2637 * an explicit call to isl_basic_set_union to prevent the implicit
2638 * equality constraints in the basic maps from being detected prior
2639 * to the call to isl_set_coalesce, at least at the point
2640 * where this test case was introduced.
2641 */
2642static isl_stat test_coalesce_special8(isl_ctx *ctx)
2643{
2644 const char *str1;
2645 const char *str2;
2646
2647 str1 = "{ [a, b, c] : 2c <= -a and b >= -a and b <= 5 and "
2648 "6c > -7a and 11c >= -5a - b and a <= 3 }";
2649 str2 = "{ [a, b, c] : 6c > -7a and b >= -a and b <= 5 and "
2650 "11c >= -5a - b and a >= 4 and 2b <= a and 2c <= -a }";
2651 return test_coalesce_union(ctx, str1, str2);
2652}
2653
2654/* Test the functionality of isl_set_coalesce.
2655 * That is, check that the output is always equal to the input
2656 * and in some cases that the result consists of a single disjunct.
2657 */
2658static int test_coalesce(struct isl_ctx *ctx)
2659{
2660 int i;
2661
2662 for (i = 0; i < ARRAY_SIZE(coalesce_tests); ++i) {
2663 const char *str = coalesce_tests[i].str;
2664 int check_one = coalesce_tests[i].single_disjunct;
2665 if (test_coalesce_set(ctx, str, check_one) < 0)
2666 return -1;
2667 }
2668
2669 if (test_coalesce_unbounded_wrapping(ctx) < 0)
2670 return -1;
2671 if (test_coalesce_special(ctx) < 0)
2672 return -1;
2673 if (test_coalesce_special2(ctx) < 0)
2674 return -1;
2675 if (test_coalesce_special3(ctx) < 0)
2676 return -1;
2677 if (test_coalesce_special4(ctx) < 0)
2678 return -1;
2679 if (test_coalesce_special5(ctx) < 0)
2680 return -1;
2681 if (test_coalesce_special6(ctx) < 0)
2682 return -1;
2683 if (test_coalesce_special7(ctx) < 0)
2684 return -1;
2685 if (test_coalesce_special8(ctx) < 0)
2686 return -1;
2687
2688 return 0;
2689}
2690
2691/* Construct a representation of the graph on the right of Figure 1
2692 * in "Computing the Transitive Closure of a Union of
2693 * Affine Integer Tuple Relations".
2694 */
2695static __isl_give isl_map *cocoa_fig_1_right_graph(isl_ctx *ctx)
2696{
2697 isl_set *dom;
2698 isl_map *up, *right;
2699
2700 dom = isl_set_read_from_str(ctx,
2701 str: "{ [x,y] : x >= 0 and -2 x + 3 y >= 0 and x <= 3 and "
2702 "2 x - 3 y + 3 >= 0 }");
2703 right = isl_map_read_from_str(ctx,
2704 str: "{ [x,y] -> [x2,y2] : x2 = x + 1 and y2 = y }");
2705 up = isl_map_read_from_str(ctx,
2706 str: "{ [x,y] -> [x2,y2] : x2 = x and y2 = y + 1 }");
2707 right = isl_map_intersect_domain(map: right, set: isl_set_copy(set: dom));
2708 right = isl_map_intersect_range(map: right, set: isl_set_copy(set: dom));
2709 up = isl_map_intersect_domain(map: up, set: isl_set_copy(set: dom));
2710 up = isl_map_intersect_range(map: up, set: dom);
2711 return isl_map_union(map1: up, map2: right);
2712}
2713
2714/* Construct a representation of the power of the graph
2715 * on the right of Figure 1 in "Computing the Transitive Closure of
2716 * a Union of Affine Integer Tuple Relations".
2717 */
2718static __isl_give isl_map *cocoa_fig_1_right_power(isl_ctx *ctx)
2719{
2720 return isl_map_read_from_str(ctx,
2721 str: "{ [1] -> [[0,0] -> [0,1]]; [2] -> [[0,0] -> [1,1]]; "
2722 " [1] -> [[0,1] -> [1,1]]; [1] -> [[2,2] -> [3,2]]; "
2723 " [2] -> [[2,2] -> [3,3]]; [1] -> [[3,2] -> [3,3]] }");
2724}
2725
2726/* Construct a representation of the transitive closure of the graph
2727 * on the right of Figure 1 in "Computing the Transitive Closure of
2728 * a Union of Affine Integer Tuple Relations".
2729 */
2730static __isl_give isl_map *cocoa_fig_1_right_tc(isl_ctx *ctx)
2731{
2732 return isl_set_unwrap(set: isl_map_range(map: cocoa_fig_1_right_power(ctx)));
2733}
2734
2735static int test_closure(isl_ctx *ctx)
2736{
2737 const char *str;
2738 isl_map *map, *map2;
2739 isl_bool exact, equal;
2740
2741 /* COCOA example 1 */
2742 map = isl_map_read_from_str(ctx,
2743 str: "[n] -> { [i,j] -> [i2,j2] : i2 = i + 1 and j2 = j + 1 and "
2744 "1 <= i and i < n and 1 <= j and j < n or "
2745 "i2 = i + 1 and j2 = j - 1 and "
2746 "1 <= i and i < n and 2 <= j and j <= n }");
2747 map = isl_map_power(map, exact: &exact);
2748 assert(exact);
2749 isl_map_free(map);
2750
2751 /* COCOA example 1 */
2752 map = isl_map_read_from_str(ctx,
2753 str: "[n] -> { [i,j] -> [i2,j2] : i2 = i + 1 and j2 = j + 1 and "
2754 "1 <= i and i < n and 1 <= j and j < n or "
2755 "i2 = i + 1 and j2 = j - 1 and "
2756 "1 <= i and i < n and 2 <= j and j <= n }");
2757 map = isl_map_transitive_closure(map, exact: &exact);
2758 assert(exact);
2759 map2 = isl_map_read_from_str(ctx,
2760 str: "[n] -> { [i,j] -> [i2,j2] : exists (k1,k2,k : "
2761 "1 <= i and i < n and 1 <= j and j <= n and "
2762 "2 <= i2 and i2 <= n and 1 <= j2 and j2 <= n and "
2763 "i2 = i + k1 + k2 and j2 = j + k1 - k2 and "
2764 "k1 >= 0 and k2 >= 0 and k1 + k2 = k and k >= 1 )}");
2765 assert(isl_map_is_equal(map, map2));
2766 isl_map_free(map: map2);
2767 isl_map_free(map);
2768
2769 map = isl_map_read_from_str(ctx,
2770 str: "[n] -> { [x] -> [y] : y = x + 1 and 0 <= x and x <= n and "
2771 " 0 <= y and y <= n }");
2772 map = isl_map_transitive_closure(map, exact: &exact);
2773 map2 = isl_map_read_from_str(ctx,
2774 str: "[n] -> { [x] -> [y] : y > x and 0 <= x and x <= n and "
2775 " 0 <= y and y <= n }");
2776 assert(isl_map_is_equal(map, map2));
2777 isl_map_free(map: map2);
2778 isl_map_free(map);
2779
2780 /* COCOA example 2 */
2781 map = isl_map_read_from_str(ctx,
2782 str: "[n] -> { [i,j] -> [i2,j2] : i2 = i + 2 and j2 = j + 2 and "
2783 "1 <= i and i < n - 1 and 1 <= j and j < n - 1 or "
2784 "i2 = i + 2 and j2 = j - 2 and "
2785 "1 <= i and i < n - 1 and 3 <= j and j <= n }");
2786 map = isl_map_transitive_closure(map, exact: &exact);
2787 assert(exact);
2788 map2 = isl_map_read_from_str(ctx,
2789 str: "[n] -> { [i,j] -> [i2,j2] : exists (k1,k2,k : "
2790 "1 <= i and i < n - 1 and 1 <= j and j <= n and "
2791 "3 <= i2 and i2 <= n and 1 <= j2 and j2 <= n and "
2792 "i2 = i + 2 k1 + 2 k2 and j2 = j + 2 k1 - 2 k2 and "
2793 "k1 >= 0 and k2 >= 0 and k1 + k2 = k and k >= 1) }");
2794 assert(isl_map_is_equal(map, map2));
2795 isl_map_free(map);
2796 isl_map_free(map: map2);
2797
2798 /* COCOA Fig.2 left */
2799 map = isl_map_read_from_str(ctx,
2800 str: "[n] -> { [i,j] -> [i2,j2] : i2 = i + 2 and j2 = j and "
2801 "i <= 2 j - 3 and i <= n - 2 and j <= 2 i - 1 and "
2802 "j <= n or "
2803 "i2 = i and j2 = j + 2 and i <= 2 j - 1 and i <= n and "
2804 "j <= 2 i - 3 and j <= n - 2 or "
2805 "i2 = i + 1 and j2 = j + 1 and i <= 2 j - 1 and "
2806 "i <= n - 1 and j <= 2 i - 1 and j <= n - 1 }");
2807 map = isl_map_transitive_closure(map, exact: &exact);
2808 assert(exact);
2809 isl_map_free(map);
2810
2811 /* COCOA Fig.2 right */
2812 map = isl_map_read_from_str(ctx,
2813 str: "[n] -> { [i,j] -> [i2,j2] : i2 = i + 3 and j2 = j and "
2814 "i <= 2 j - 4 and i <= n - 3 and j <= 2 i - 1 and "
2815 "j <= n or "
2816 "i2 = i and j2 = j + 3 and i <= 2 j - 1 and i <= n and "
2817 "j <= 2 i - 4 and j <= n - 3 or "
2818 "i2 = i + 1 and j2 = j + 1 and i <= 2 j - 1 and "
2819 "i <= n - 1 and j <= 2 i - 1 and j <= n - 1 }");
2820 map = isl_map_power(map, exact: &exact);
2821 assert(exact);
2822 isl_map_free(map);
2823
2824 /* COCOA Fig.2 right */
2825 map = isl_map_read_from_str(ctx,
2826 str: "[n] -> { [i,j] -> [i2,j2] : i2 = i + 3 and j2 = j and "
2827 "i <= 2 j - 4 and i <= n - 3 and j <= 2 i - 1 and "
2828 "j <= n or "
2829 "i2 = i and j2 = j + 3 and i <= 2 j - 1 and i <= n and "
2830 "j <= 2 i - 4 and j <= n - 3 or "
2831 "i2 = i + 1 and j2 = j + 1 and i <= 2 j - 1 and "
2832 "i <= n - 1 and j <= 2 i - 1 and j <= n - 1 }");
2833 map = isl_map_transitive_closure(map, exact: &exact);
2834 assert(exact);
2835 map2 = isl_map_read_from_str(ctx,
2836 str: "[n] -> { [i,j] -> [i2,j2] : exists (k1,k2,k3,k : "
2837 "i <= 2 j - 1 and i <= n and j <= 2 i - 1 and "
2838 "j <= n and 3 + i + 2 j <= 3 n and "
2839 "3 + 2 i + j <= 3n and i2 <= 2 j2 -1 and i2 <= n and "
2840 "i2 <= 3 j2 - 4 and j2 <= 2 i2 -1 and j2 <= n and "
2841 "13 + 4 j2 <= 11 i2 and i2 = i + 3 k1 + k3 and "
2842 "j2 = j + 3 k2 + k3 and k1 >= 0 and k2 >= 0 and "
2843 "k3 >= 0 and k1 + k2 + k3 = k and k > 0) }");
2844 assert(isl_map_is_equal(map, map2));
2845 isl_map_free(map: map2);
2846 isl_map_free(map);
2847
2848 map = cocoa_fig_1_right_graph(ctx);
2849 map = isl_map_transitive_closure(map, exact: &exact);
2850 assert(exact);
2851 map2 = cocoa_fig_1_right_tc(ctx);
2852 assert(isl_map_is_equal(map, map2));
2853 isl_map_free(map: map2);
2854 isl_map_free(map);
2855
2856 map = cocoa_fig_1_right_graph(ctx);
2857 map = isl_map_power(map, exact: &exact);
2858 map2 = cocoa_fig_1_right_power(ctx);
2859 equal = isl_map_is_equal(map1: map, map2);
2860 isl_map_free(map: map2);
2861 isl_map_free(map);
2862 if (equal < 0)
2863 return -1;
2864 if (!exact)
2865 isl_die(ctx, isl_error_unknown, "power not exact", return -1);
2866 if (!equal)
2867 isl_die(ctx, isl_error_unknown, "unexpected power", return -1);
2868
2869 /* COCOA Theorem 1 counter example */
2870 map = isl_map_read_from_str(ctx,
2871 str: "{ [i,j] -> [i2,j2] : i = 0 and 0 <= j and j <= 1 and "
2872 "i2 = 1 and j2 = j or "
2873 "i = 0 and j = 0 and i2 = 0 and j2 = 1 }");
2874 map = isl_map_transitive_closure(map, exact: &exact);
2875 assert(exact);
2876 isl_map_free(map);
2877
2878 map = isl_map_read_from_str(ctx,
2879 str: "[m,n] -> { [i,j] -> [i2,j2] : i2 = i and j2 = j + 2 and "
2880 "1 <= i,i2 <= n and 1 <= j,j2 <= m or "
2881 "i2 = i + 1 and 3 <= j2 - j <= 4 and "
2882 "1 <= i,i2 <= n and 1 <= j,j2 <= m }");
2883 map = isl_map_transitive_closure(map, exact: &exact);
2884 assert(exact);
2885 isl_map_free(map);
2886
2887 /* Kelly et al 1996, fig 12 */
2888 map = isl_map_read_from_str(ctx,
2889 str: "[n] -> { [i,j] -> [i2,j2] : i2 = i and j2 = j + 1 and "
2890 "1 <= i,j,j+1 <= n or "
2891 "j = n and j2 = 1 and i2 = i + 1 and "
2892 "1 <= i,i+1 <= n }");
2893 map = isl_map_transitive_closure(map, exact: &exact);
2894 assert(exact);
2895 map2 = isl_map_read_from_str(ctx,
2896 str: "[n] -> { [i,j] -> [i2,j2] : 1 <= j < j2 <= n and "
2897 "1 <= i <= n and i = i2 or "
2898 "1 <= i < i2 <= n and 1 <= j <= n and "
2899 "1 <= j2 <= n }");
2900 assert(isl_map_is_equal(map, map2));
2901 isl_map_free(map: map2);
2902 isl_map_free(map);
2903
2904 /* Omega's closure4 */
2905 map = isl_map_read_from_str(ctx,
2906 str: "[m,n] -> { [x,y] -> [x2,y2] : x2 = x and y2 = y + 1 and "
2907 "1 <= x,y <= 10 or "
2908 "x2 = x + 1 and y2 = y and "
2909 "1 <= x <= 20 && 5 <= y <= 15 }");
2910 map = isl_map_transitive_closure(map, exact: &exact);
2911 assert(exact);
2912 isl_map_free(map);
2913
2914 map = isl_map_read_from_str(ctx,
2915 str: "[n] -> { [x] -> [y]: 1 <= n <= y - x <= 10 }");
2916 map = isl_map_transitive_closure(map, exact: &exact);
2917 assert(!exact);
2918 map2 = isl_map_read_from_str(ctx,
2919 str: "[n] -> { [x] -> [y] : 1 <= n <= 10 and y >= n + x }");
2920 assert(isl_map_is_equal(map, map2));
2921 isl_map_free(map);
2922 isl_map_free(map: map2);
2923
2924 str = "[n, m] -> { [i0, i1, i2, i3] -> [o0, o1, o2, o3] : "
2925 "i3 = 1 and o0 = i0 and o1 = -1 + i1 and o2 = -1 + i2 and "
2926 "o3 = -2 + i2 and i1 <= -1 + i0 and i1 >= 1 - m + i0 and "
2927 "i1 >= 2 and i1 <= n and i2 >= 3 and i2 <= 1 + n and i2 <= m }";
2928 map = isl_map_read_from_str(ctx, str);
2929 map = isl_map_transitive_closure(map, exact: &exact);
2930 assert(exact);
2931 map2 = isl_map_read_from_str(ctx, str);
2932 assert(isl_map_is_equal(map, map2));
2933 isl_map_free(map);
2934 isl_map_free(map: map2);
2935
2936 str = "{[0] -> [1]; [2] -> [3]}";
2937 map = isl_map_read_from_str(ctx, str);
2938 map = isl_map_transitive_closure(map, exact: &exact);
2939 assert(exact);
2940 map2 = isl_map_read_from_str(ctx, str);
2941 assert(isl_map_is_equal(map, map2));
2942 isl_map_free(map);
2943 isl_map_free(map: map2);
2944
2945 str = "[n] -> { [[i0, i1, 1, 0, i0] -> [i5, 1]] -> "
2946 "[[i0, -1 + i1, 2, 0, i0] -> [-1 + i5, 2]] : "
2947 "exists (e0 = [(3 - n)/3]: i5 >= 2 and i1 >= 2 and "
2948 "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and "
2949 "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n); "
2950 "[[i0, i1, 2, 0, i0] -> [i5, 1]] -> "
2951 "[[i0, i1, 1, 0, i0] -> [-1 + i5, 2]] : "
2952 "exists (e0 = [(3 - n)/3]: i5 >= 2 and i1 >= 1 and "
2953 "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and "
2954 "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n); "
2955 "[[i0, i1, 1, 0, i0] -> [i5, 2]] -> "
2956 "[[i0, -1 + i1, 2, 0, i0] -> [i5, 1]] : "
2957 "exists (e0 = [(3 - n)/3]: i1 >= 2 and i5 >= 1 and "
2958 "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and "
2959 "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n); "
2960 "[[i0, i1, 2, 0, i0] -> [i5, 2]] -> "
2961 "[[i0, i1, 1, 0, i0] -> [i5, 1]] : "
2962 "exists (e0 = [(3 - n)/3]: i5 >= 1 and i1 >= 1 and "
2963 "3i0 <= -1 + n and i1 <= -1 + n and i5 <= -1 + n and "
2964 "3e0 >= 1 - n and 3e0 <= 2 - n and 3i0 >= -2 + n) }";
2965 map = isl_map_read_from_str(ctx, str);
2966 map = isl_map_transitive_closure(map, NULL);
2967 assert(map);
2968 isl_map_free(map);
2969
2970 return 0;
2971}
2972
2973/* Check that the actual result of a boolean operation is equal
2974 * to the expected result.
2975 */
2976static isl_stat check_bool(isl_ctx *ctx, isl_bool actual, isl_bool expected)
2977{
2978 if (actual != expected)
2979 isl_die(ctx, isl_error_unknown,
2980 "incorrect boolean operation", return isl_stat_error);
2981 return isl_stat_ok;
2982}
2983
2984/* Test operations on isl_bool values.
2985 *
2986 * This tests:
2987 *
2988 * isl_bool_not
2989 * isl_bool_ok
2990 */
2991static int test_isl_bool(isl_ctx *ctx)
2992{
2993 if (check_bool(ctx, actual: isl_bool_not(b: isl_bool_true), expected: isl_bool_false) < 0)
2994 return -1;
2995 if (check_bool(ctx, actual: isl_bool_not(b: isl_bool_false), expected: isl_bool_true) < 0)
2996 return -1;
2997 if (check_bool(ctx, actual: isl_bool_not(b: isl_bool_error), expected: isl_bool_error) < 0)
2998 return -1;
2999 if (check_bool(ctx, actual: isl_bool_ok(b: 0), expected: isl_bool_false) < 0)
3000 return -1;
3001 if (check_bool(ctx, actual: isl_bool_ok(b: 1), expected: isl_bool_true) < 0)
3002 return -1;
3003 if (check_bool(ctx, actual: isl_bool_ok(b: -1), expected: isl_bool_true) < 0)
3004 return -1;
3005 if (check_bool(ctx, actual: isl_bool_ok(b: 2), expected: isl_bool_true) < 0)
3006 return -1;
3007 if (check_bool(ctx, actual: isl_bool_ok(b: -2), expected: isl_bool_true) < 0)
3008 return -1;
3009
3010 return 0;
3011}
3012
3013static int test_lex(struct isl_ctx *ctx)
3014{
3015 isl_space *space;
3016 isl_map *map;
3017 int empty;
3018
3019 space = isl_space_set_alloc(ctx, nparam: 0, dim: 0);
3020 map = isl_map_lex_le(set_space: space);
3021 empty = isl_map_is_empty(map);
3022 isl_map_free(map);
3023
3024 if (empty < 0)
3025 return -1;
3026 if (empty)
3027 isl_die(ctx, isl_error_unknown,
3028 "expecting non-empty result", return -1);
3029
3030 return 0;
3031}
3032
3033/* Inputs for isl_map_lexmin tests.
3034 * "map" is the input and "lexmin" is the expected result.
3035 */
3036struct {
3037 const char *map;
3038 const char *lexmin;
3039} lexmin_tests [] = {
3040 { "{ [x] -> [y] : x <= y <= 10; [x] -> [5] : -8 <= x <= 8 }",
3041 "{ [x] -> [5] : 6 <= x <= 8; "
3042 "[x] -> [x] : x <= 5 or (9 <= x <= 10) }" },
3043 { "{ [x] -> [y] : 4y = x or 4y = -1 + x or 4y = -2 + x }",
3044 "{ [x] -> [y] : 4y = x or 4y = -1 + x or 4y = -2 + x }" },
3045 { "{ [x] -> [y] : x = 4y; [x] -> [y] : x = 2y }",
3046 "{ [x] -> [y] : (4y = x and x >= 0) or "
3047 "(exists (e0 = [(x)/4], e1 = [(-2 + x)/4]: 2y = x and "
3048 "4e1 = -2 + x and 4e0 <= -1 + x and 4e0 >= -3 + x)) or "
3049 "(exists (e0 = [(x)/4]: 2y = x and 4e0 = x and x <= -4)) }" },
3050 { "{ T[a] -> S[b, c] : a = 4b-2c and c >= b }",
3051 "{ T[a] -> S[b, c] : 2b = a and 2c = a }" },
3052 /* Check that empty pieces are properly combined. */
3053 { "[K, N] -> { [x, y] -> [a, b] : K+2<=N<=K+4 and x>=4 and "
3054 "2N-6<=x<K+N and N-1<=a<=K+N-1 and N+b-6<=a<=2N-4 and "
3055 "b<=2N-3K+a and 3b<=4N-K+1 and b>=N and a>=x+1 }",
3056 "[K, N] -> { [x, y] -> [1 + x, N] : x >= -6 + 2N and "
3057 "x <= -5 + 2N and x >= -1 + 3K - N and x <= -2 + K + N and "
3058 "x >= 4 }" },
3059 { "{ [i, k, j] -> [a, b, c, d] : 8*floor((b)/8) = b and k <= 255 and "
3060 "a <= 255 and c <= 255 and d <= 255 - j and "
3061 "255 - j <= 7d <= 7 - i and 240d <= 239 + a and "
3062 "247d <= 247 + k - j and 247d <= 247 + k - b and "
3063 "247d <= 247 + i and 248 - b <= 248d <= c and "
3064 "254d >= i - a + b and 254d >= -a + b and "
3065 "255d >= -i + a - b and 1792d >= -63736 + 257b }",
3066 "{ [i, k, j] -> "
3067 "[-127762 + i + 502j, -62992 + 248j, 63240 - 248j, 255 - j] : "
3068 "k <= 255 and 7j >= 1778 + i and 246j >= 62738 - k and "
3069 "247j >= 62738 - i and 509j <= 129795 + i and "
3070 "742j >= 188724 - i; "
3071 "[0, k, j] -> [1, 0, 248, 1] : k <= 255 and 248 <= j <= 254, k }" },
3072 { "{ [a] -> [b] : 0 <= b <= 255 and -509 + a <= 512b < a and "
3073 "16*floor((8 + b)/16) <= 7 + b; "
3074 "[a] -> [1] }",
3075 "{ [a] -> [b = 1] : a >= 510 or a <= 0; "
3076 "[a] -> [b = 0] : 0 < a <= 509 }" },
3077 { "{ rat: [i] : 1 <= 2i <= 9 }", "{ rat: [i] : 2i = 1 }" },
3078 { "{ rat: [i] : 1 <= 2i <= 9 or i >= 10 }", "{ rat: [i] : 2i = 1 }" },
3079 { "{ rat: [i] : 21 <= 2i <= 29 or i = 5 }", "{ rat: [5] }" },
3080};
3081
3082static int test_lexmin(struct isl_ctx *ctx)
3083{
3084 int i;
3085 int equal;
3086 const char *str;
3087 isl_basic_map *bmap;
3088 isl_map *map, *map2;
3089 isl_set *set;
3090 isl_set *set2;
3091 isl_pw_multi_aff *pma;
3092
3093 str = "[p0, p1] -> { [] -> [] : "
3094 "exists (e0 = [(2p1)/3], e1, e2, e3 = [(3 - p1 + 3e0)/3], "
3095 "e4 = [(p1)/3], e5 = [(p1 + 3e4)/3]: "
3096 "3e0 >= -2 + 2p1 and 3e0 >= p1 and 3e3 >= 1 - p1 + 3e0 and "
3097 "3e0 <= 2p1 and 3e3 >= -2 + p1 and 3e3 <= -1 + p1 and p1 >= 3 and "
3098 "3e5 >= -2 + 2p1 and 3e5 >= p1 and 3e5 <= -1 + p1 + 3e4 and "
3099 "3e4 <= p1 and 3e4 >= -2 + p1 and e3 <= -1 + e0 and "
3100 "3e4 >= 6 - p1 + 3e1 and 3e1 >= p1 and 3e5 >= -2 + p1 + 3e4 and "
3101 "2e4 >= 3 - p1 + 2e1 and e4 <= e1 and 3e3 <= 2 - p1 + 3e0 and "
3102 "e5 >= 1 + e1 and 3e4 >= 6 - 2p1 + 3e1 and "
3103 "p0 >= 2 and p1 >= p0 and 3e2 >= p1 and 3e4 >= 6 - p1 + 3e2 and "
3104 "e2 <= e1 and e3 >= 1 and e4 <= e2) }";
3105 map = isl_map_read_from_str(ctx, str);
3106 map = isl_map_lexmin(map);
3107 isl_map_free(map);
3108 if (!map)
3109 return -1;
3110
3111 str = "[C] -> { [obj,a,b,c] : obj <= 38 a + 7 b + 10 c and "
3112 "a + b <= 1 and c <= 10 b and c <= C and a,b,c,C >= 0 }";
3113 set = isl_set_read_from_str(ctx, str);
3114 set = isl_set_lexmax(set);
3115 str = "[C] -> { [obj,a,b,c] : C = 8 }";
3116 set2 = isl_set_read_from_str(ctx, str);
3117 set = isl_set_intersect(set1: set, set2);
3118 assert(!isl_set_is_empty(set));
3119 isl_set_free(set);
3120
3121 for (i = 0; i < ARRAY_SIZE(lexmin_tests); ++i) {
3122 map = isl_map_read_from_str(ctx, str: lexmin_tests[i].map);
3123 map = isl_map_lexmin(map);
3124 map2 = isl_map_read_from_str(ctx, str: lexmin_tests[i].lexmin);
3125 equal = isl_map_is_equal(map1: map, map2);
3126 isl_map_free(map);
3127 isl_map_free(map: map2);
3128
3129 if (equal < 0)
3130 return -1;
3131 if (!equal)
3132 isl_die(ctx, isl_error_unknown,
3133 "unexpected result", return -1);
3134 }
3135
3136 str = "{ [i] -> [i', j] : j = i - 8i' and i' >= 0 and i' <= 7 and "
3137 " 8i' <= i and 8i' >= -7 + i }";
3138 bmap = isl_basic_map_read_from_str(ctx, str);
3139 pma = isl_basic_map_lexmin_pw_multi_aff(bmap: isl_basic_map_copy(bmap));
3140 map2 = isl_map_from_pw_multi_aff(pma);
3141 map = isl_map_from_basic_map(bmap);
3142 assert(isl_map_is_equal(map, map2));
3143 isl_map_free(map);
3144 isl_map_free(map: map2);
3145
3146 str = "[i] -> { [i', j] : j = i - 8i' and i' >= 0 and i' <= 7 and "
3147 " 8i' <= i and 8i' >= -7 + i }";
3148 set = isl_set_read_from_str(ctx, str);
3149 pma = isl_set_lexmin_pw_multi_aff(set: isl_set_copy(set));
3150 set2 = isl_set_from_pw_multi_aff(pma);
3151 equal = isl_set_is_equal(set1: set, set2);
3152 isl_set_free(set);
3153 isl_set_free(set: set2);
3154 if (equal < 0)
3155 return -1;
3156 if (!equal)
3157 isl_die(ctx, isl_error_unknown,
3158 "unexpected difference between set and "
3159 "piecewise affine expression", return -1);
3160
3161 return 0;
3162}
3163
3164/* Inputs for isl_pw_multi_aff_max_multi_val tests.
3165 * "pma" is the input.
3166 * "res" is the expected result.
3167 */
3168static struct {
3169 const char *pma;
3170 const char *res;
3171} opt_pw_tests[] = {
3172 { "{ [-1] -> [-1]; [1] -> [1] }", "{ [1] }" },
3173 { "{ [a, b] -> [floor((b - 2*floor((-a)/4))/5)] : "
3174 "0 <= a, b <= 100 and b mod 2 = 0}", "{ [30] }" },
3175 { "[N] -> { [i,j] -> A[i, -i, i + j] : 0 <= i,j <= N <= 10 }",
3176 "{ A[10, 0, 20] }" },
3177 { "[N] -> {A[N, -N, 2N] : 0 <= N }", "{ A[infty, 0, infty] }" },
3178};
3179
3180/* Perform basic isl_pw_multi_aff_max_multi_val tests.
3181 */
3182static isl_stat test_pw_max(struct isl_ctx *ctx)
3183{
3184 int i;
3185 isl_pw_multi_aff *pma;
3186 isl_multi_val *mv;
3187 isl_stat r;
3188
3189 for (i = 0; i < ARRAY_SIZE(opt_pw_tests); ++i) {
3190 pma = isl_pw_multi_aff_read_from_str(ctx, str: opt_pw_tests[i].pma);
3191 mv = isl_pw_multi_aff_max_multi_val(pma);
3192 r = multi_val_check_plain_equal(obj: mv, str: opt_pw_tests[i].res);
3193 isl_multi_val_free(multi: mv);
3194
3195 if (r < 0)
3196 return isl_stat_error;
3197 }
3198
3199 return isl_stat_ok;
3200}
3201
3202/* A specialized isl_set_min_val test case that would return the wrong result
3203 * in earlier versions of isl.
3204 * The explicit call to isl_basic_set_union prevents the second basic set
3205 * from being determined to be empty prior to the call to isl_set_min_val,
3206 * at least at the point where this test case was introduced.
3207 */
3208static int test_min_special(isl_ctx *ctx)
3209{
3210 const char *str;
3211 isl_basic_set *bset1, *bset2;
3212 isl_set *set;
3213 isl_aff *obj;
3214 isl_val *res;
3215 int ok;
3216
3217 str = "{ [a, b] : a >= 2 and b >= 0 and 14 - a <= b <= 9 }";
3218 bset1 = isl_basic_set_read_from_str(ctx, str);
3219 str = "{ [a, b] : 1 <= a, b and a + b <= 1 }";
3220 bset2 = isl_basic_set_read_from_str(ctx, str);
3221 set = isl_basic_set_union(bset1, bset2);
3222 obj = isl_aff_read_from_str(ctx, str: "{ [a, b] -> [a] }");
3223
3224 res = isl_set_min_val(set, obj);
3225 ok = isl_val_cmp_si(v: res, i: 5) == 0;
3226
3227 isl_aff_free(aff: obj);
3228 isl_set_free(set);
3229 isl_val_free(v: res);
3230
3231 if (!res)
3232 return -1;
3233 if (!ok)
3234 isl_die(ctx, isl_error_unknown, "unexpected minimum",
3235 return -1);
3236
3237 return 0;
3238}
3239
3240/* A specialized isl_set_min_val test case that would return an error
3241 * in earlier versions of isl.
3242 */
3243static int test_min_special2(isl_ctx *ctx)
3244{
3245 const char *str;
3246 isl_basic_set *bset;
3247 isl_aff *obj;
3248 isl_val *res;
3249
3250 str = "{ [i, j, k] : 2j = i and 2k = i + 1 and i >= 2 }";
3251 bset = isl_basic_set_read_from_str(ctx, str);
3252
3253 obj = isl_aff_read_from_str(ctx, str: "{ [i, j, k] -> [i] }");
3254
3255 res = isl_basic_set_max_val(bset, obj);
3256
3257 isl_basic_set_free(bset);
3258 isl_aff_free(aff: obj);
3259 isl_val_free(v: res);
3260
3261 if (!res)
3262 return -1;
3263
3264 return 0;
3265}
3266
3267/* Check that the result of isl_set_min_multi_pw_aff
3268 * on the union of the sets with string descriptions "s1" and "s2"
3269 * consists of a single expression (on a single cell).
3270 */
3271static isl_stat check_single_expr_min(isl_ctx *ctx, const char *s1,
3272 const char *s2)
3273{
3274 isl_size n;
3275 isl_set *set1, *set2;
3276 isl_multi_pw_aff *mpa;
3277 isl_pw_multi_aff *pma;
3278
3279 set1 = isl_set_read_from_str(ctx, str: s1);
3280 set2 = isl_set_read_from_str(ctx, str: s2);
3281 set1 = isl_set_union(set1, set2);
3282 mpa = isl_set_min_multi_pw_aff(set: set1);
3283 pma = isl_pw_multi_aff_from_multi_pw_aff(mpa);
3284 n = isl_pw_multi_aff_n_piece(pma);
3285 isl_pw_multi_aff_free(pma);
3286
3287 if (n < 0)
3288 return isl_stat_error;
3289 if (n != 1)
3290 isl_die(ctx, isl_error_unknown, "expecting single expression",
3291 return isl_stat_error);
3292 return isl_stat_ok;
3293}
3294
3295/* A specialized isl_set_min_multi_pw_aff test that checks
3296 * that the minimum of 2N and 3N for N >= 0 is represented
3297 * by a single expression, without splitting off the special case N = 0.
3298 * Do this for both orderings.
3299 */
3300static int test_min_mpa(isl_ctx *ctx)
3301{
3302 const char *s1, *s2;
3303
3304 s1 = "[N=0:] -> { [1, 3N:] }";
3305 s2 = "[N=0:] -> { [10, 2N:] }";
3306 if (check_single_expr_min(ctx, s1, s2) < 0)
3307 return -1;
3308 if (check_single_expr_min(ctx, s1: s2, s2: s1) < 0)
3309 return -1;
3310
3311 return 0;
3312}
3313
3314struct {
3315 const char *set;
3316 const char *obj;
3317 __isl_give isl_val *(*fn)(__isl_keep isl_set *set,
3318 __isl_keep isl_aff *obj);
3319 const char *res;
3320} opt_tests[] = {
3321 { "{ [-1]; [1] }", "{ [x] -> [x] }", &isl_set_min_val, "-1" },
3322 { "{ [-1]; [1] }", "{ [x] -> [x] }", &isl_set_max_val, "1" },
3323 { "{ [a, b] : 0 <= a, b <= 100 and b mod 2 = 0}",
3324 "{ [a, b] -> [floor((b - 2*floor((-a)/4))/5)] }",
3325 &isl_set_max_val, "30" },
3326
3327};
3328
3329/* Perform basic isl_set_min_val and isl_set_max_val tests.
3330 * In particular, check the results on non-convex inputs.
3331 */
3332static int test_min(struct isl_ctx *ctx)
3333{
3334 int i;
3335 isl_set *set;
3336 isl_aff *obj;
3337 isl_val *val, *res;
3338 isl_bool ok;
3339
3340 for (i = 0; i < ARRAY_SIZE(opt_tests); ++i) {
3341 set = isl_set_read_from_str(ctx, str: opt_tests[i].set);
3342 obj = isl_aff_read_from_str(ctx, str: opt_tests[i].obj);
3343 res = isl_val_read_from_str(ctx, str: opt_tests[i].res);
3344 val = opt_tests[i].fn(set, obj);
3345 ok = isl_val_eq(v1: res, v2: val);
3346 isl_val_free(v: res);
3347 isl_val_free(v: val);
3348 isl_aff_free(aff: obj);
3349 isl_set_free(set);
3350
3351 if (ok < 0)
3352 return -1;
3353 if (!ok)
3354 isl_die(ctx, isl_error_unknown,
3355 "unexpected optimum", return -1);
3356 }
3357
3358 if (test_pw_max(ctx) < 0)
3359 return -1;
3360 if (test_min_special(ctx) < 0)
3361 return -1;
3362 if (test_min_special2(ctx) < 0)
3363 return -1;
3364
3365 return 0;
3366}
3367
3368struct must_may {
3369 isl_map *must;
3370 isl_map *may;
3371};
3372
3373static isl_stat collect_must_may(__isl_take isl_map *dep, int must,
3374 void *dep_user, void *user)
3375{
3376 struct must_may *mm = (struct must_may *)user;
3377
3378 if (must)
3379 mm->must = isl_map_union(map1: mm->must, map2: dep);
3380 else
3381 mm->may = isl_map_union(map1: mm->may, map2: dep);
3382
3383 return isl_stat_ok;
3384}
3385
3386static int common_space(void *first, void *second)
3387{
3388 int depth = *(int *)first;
3389 return 2 * depth;
3390}
3391
3392static int map_is_equal(__isl_keep isl_map *map, const char *str)
3393{
3394 isl_map *map2;
3395 int equal;
3396
3397 if (!map)
3398 return -1;
3399
3400 map2 = isl_map_read_from_str(ctx: map->ctx, str);
3401 equal = isl_map_is_equal(map1: map, map2);
3402 isl_map_free(map: map2);
3403
3404 return equal;
3405}
3406
3407static int map_check_equal(__isl_keep isl_map *map, const char *str)
3408{
3409 int equal;
3410
3411 equal = map_is_equal(map, str);
3412 if (equal < 0)
3413 return -1;
3414 if (!equal)
3415 isl_die(isl_map_get_ctx(map), isl_error_unknown,
3416 "result not as expected", return -1);
3417 return 0;
3418}
3419
3420/* Is "set" equal to the set described by "str"?
3421 */
3422static isl_bool set_is_equal(__isl_keep isl_set *set, const char *str)
3423{
3424 isl_set *set2;
3425 isl_bool equal;
3426
3427 if (!set)
3428 return isl_bool_error;
3429
3430 set2 = isl_set_read_from_str(ctx: isl_set_get_ctx(set), str);
3431 equal = isl_set_is_equal(set1: set, set2);
3432 isl_set_free(set: set2);
3433
3434 return equal;
3435}
3436
3437/* Check that "set" is equal to the set described by "str".
3438 */
3439static isl_stat set_check_equal(__isl_keep isl_set *set, const char *str)
3440{
3441 isl_bool equal;
3442
3443 equal = set_is_equal(set, str);
3444 if (equal < 0)
3445 return isl_stat_error;
3446 if (!equal)
3447 isl_die(isl_set_get_ctx(set), isl_error_unknown,
3448 "result not as expected", return isl_stat_error);
3449 return isl_stat_ok;
3450}
3451
3452/* Is "uset" equal to the union set described by "str"?
3453 */
3454static isl_bool uset_is_equal(__isl_keep isl_union_set *uset, const char *str)
3455{
3456 isl_union_set *uset2;
3457 isl_bool equal;
3458
3459 if (!uset)
3460 return isl_bool_error;
3461
3462 uset2 = isl_union_set_read_from_str(ctx: isl_union_set_get_ctx(uset), str);
3463 equal = isl_union_set_is_equal(uset1: uset, uset2);
3464 isl_union_set_free(uset: uset2);
3465
3466 return equal;
3467}
3468
3469/* Check that "uset" is equal to the union set described by "str".
3470 */
3471static isl_stat uset_check_equal(__isl_keep isl_union_set *uset,
3472 const char *str)
3473{
3474 isl_bool equal;
3475
3476 equal = uset_is_equal(uset, str);
3477 if (equal < 0)
3478 return isl_stat_error;
3479 if (!equal)
3480 isl_die(isl_union_set_get_ctx(uset), isl_error_unknown,
3481 "result not as expected", return isl_stat_error);
3482 return isl_stat_ok;
3483}
3484
3485static int test_dep(struct isl_ctx *ctx)
3486{
3487 const char *str;
3488 isl_space *space;
3489 isl_map *map;
3490 isl_access_info *ai;
3491 isl_flow *flow;
3492 int depth;
3493 struct must_may mm;
3494
3495 depth = 3;
3496
3497 str = "{ [2,i,0] -> [i] : 0 <= i <= 10 }";
3498 map = isl_map_read_from_str(ctx, str);
3499 ai = isl_access_info_alloc(sink: map, sink_user: &depth, fn: &common_space, max_source: 2);
3500
3501 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3502 map = isl_map_read_from_str(ctx, str);
3503 ai = isl_access_info_add_source(acc: ai, source: map, must: 1, source_user: &depth);
3504
3505 str = "{ [1,i,0] -> [5] : 0 <= i <= 10 }";
3506 map = isl_map_read_from_str(ctx, str);
3507 ai = isl_access_info_add_source(acc: ai, source: map, must: 1, source_user: &depth);
3508
3509 flow = isl_access_info_compute_flow(acc: ai);
3510 space = isl_space_alloc(ctx, nparam: 0, n_in: 3, n_out: 3);
3511 mm.must = isl_map_empty(space: isl_space_copy(space));
3512 mm.may = isl_map_empty(space);
3513
3514 isl_flow_foreach(deps: flow, fn: collect_must_may, user: &mm);
3515
3516 str = "{ [0,i,0] -> [2,i,0] : (0 <= i <= 4) or (6 <= i <= 10); "
3517 " [1,10,0] -> [2,5,0] }";
3518 assert(map_is_equal(mm.must, str));
3519 str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }";
3520 assert(map_is_equal(mm.may, str));
3521
3522 isl_map_free(map: mm.must);
3523 isl_map_free(map: mm.may);
3524 isl_flow_free(deps: flow);
3525
3526
3527 str = "{ [2,i,0] -> [i] : 0 <= i <= 10 }";
3528 map = isl_map_read_from_str(ctx, str);
3529 ai = isl_access_info_alloc(sink: map, sink_user: &depth, fn: &common_space, max_source: 2);
3530
3531 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3532 map = isl_map_read_from_str(ctx, str);
3533 ai = isl_access_info_add_source(acc: ai, source: map, must: 1, source_user: &depth);
3534
3535 str = "{ [1,i,0] -> [5] : 0 <= i <= 10 }";
3536 map = isl_map_read_from_str(ctx, str);
3537 ai = isl_access_info_add_source(acc: ai, source: map, must: 0, source_user: &depth);
3538
3539 flow = isl_access_info_compute_flow(acc: ai);
3540 space = isl_space_alloc(ctx, nparam: 0, n_in: 3, n_out: 3);
3541 mm.must = isl_map_empty(space: isl_space_copy(space));
3542 mm.may = isl_map_empty(space);
3543
3544 isl_flow_foreach(deps: flow, fn: collect_must_may, user: &mm);
3545
3546 str = "{ [0,i,0] -> [2,i,0] : (0 <= i <= 4) or (6 <= i <= 10) }";
3547 assert(map_is_equal(mm.must, str));
3548 str = "{ [0,5,0] -> [2,5,0]; [1,i,0] -> [2,5,0] : 0 <= i <= 10 }";
3549 assert(map_is_equal(mm.may, str));
3550
3551 isl_map_free(map: mm.must);
3552 isl_map_free(map: mm.may);
3553 isl_flow_free(deps: flow);
3554
3555
3556 str = "{ [2,i,0] -> [i] : 0 <= i <= 10 }";
3557 map = isl_map_read_from_str(ctx, str);
3558 ai = isl_access_info_alloc(sink: map, sink_user: &depth, fn: &common_space, max_source: 2);
3559
3560 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3561 map = isl_map_read_from_str(ctx, str);
3562 ai = isl_access_info_add_source(acc: ai, source: map, must: 0, source_user: &depth);
3563
3564 str = "{ [1,i,0] -> [5] : 0 <= i <= 10 }";
3565 map = isl_map_read_from_str(ctx, str);
3566 ai = isl_access_info_add_source(acc: ai, source: map, must: 0, source_user: &depth);
3567
3568 flow = isl_access_info_compute_flow(acc: ai);
3569 space = isl_space_alloc(ctx, nparam: 0, n_in: 3, n_out: 3);
3570 mm.must = isl_map_empty(space: isl_space_copy(space));
3571 mm.may = isl_map_empty(space);
3572
3573 isl_flow_foreach(deps: flow, fn: collect_must_may, user: &mm);
3574
3575 str = "{ [0,i,0] -> [2,i,0] : 0 <= i <= 10; "
3576 " [1,i,0] -> [2,5,0] : 0 <= i <= 10 }";
3577 assert(map_is_equal(mm.may, str));
3578 str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }";
3579 assert(map_is_equal(mm.must, str));
3580
3581 isl_map_free(map: mm.must);
3582 isl_map_free(map: mm.may);
3583 isl_flow_free(deps: flow);
3584
3585
3586 str = "{ [0,i,2] -> [i] : 0 <= i <= 10 }";
3587 map = isl_map_read_from_str(ctx, str);
3588 ai = isl_access_info_alloc(sink: map, sink_user: &depth, fn: &common_space, max_source: 2);
3589
3590 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3591 map = isl_map_read_from_str(ctx, str);
3592 ai = isl_access_info_add_source(acc: ai, source: map, must: 0, source_user: &depth);
3593
3594 str = "{ [0,i,1] -> [5] : 0 <= i <= 10 }";
3595 map = isl_map_read_from_str(ctx, str);
3596 ai = isl_access_info_add_source(acc: ai, source: map, must: 0, source_user: &depth);
3597
3598 flow = isl_access_info_compute_flow(acc: ai);
3599 space = isl_space_alloc(ctx, nparam: 0, n_in: 3, n_out: 3);
3600 mm.must = isl_map_empty(space: isl_space_copy(space));
3601 mm.may = isl_map_empty(space);
3602
3603 isl_flow_foreach(deps: flow, fn: collect_must_may, user: &mm);
3604
3605 str = "{ [0,i,0] -> [0,i,2] : 0 <= i <= 10; "
3606 " [0,i,1] -> [0,5,2] : 0 <= i <= 5 }";
3607 assert(map_is_equal(mm.may, str));
3608 str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }";
3609 assert(map_is_equal(mm.must, str));
3610
3611 isl_map_free(map: mm.must);
3612 isl_map_free(map: mm.may);
3613 isl_flow_free(deps: flow);
3614
3615
3616 str = "{ [0,i,1] -> [i] : 0 <= i <= 10 }";
3617 map = isl_map_read_from_str(ctx, str);
3618 ai = isl_access_info_alloc(sink: map, sink_user: &depth, fn: &common_space, max_source: 2);
3619
3620 str = "{ [0,i,0] -> [i] : 0 <= i <= 10 }";
3621 map = isl_map_read_from_str(ctx, str);
3622 ai = isl_access_info_add_source(acc: ai, source: map, must: 0, source_user: &depth);
3623
3624 str = "{ [0,i,2] -> [5] : 0 <= i <= 10 }";
3625 map = isl_map_read_from_str(ctx, str);
3626 ai = isl_access_info_add_source(acc: ai, source: map, must: 0, source_user: &depth);
3627
3628 flow = isl_access_info_compute_flow(acc: ai);
3629 space = isl_space_alloc(ctx, nparam: 0, n_in: 3, n_out: 3);
3630 mm.must = isl_map_empty(space: isl_space_copy(space));
3631 mm.may = isl_map_empty(space);
3632
3633 isl_flow_foreach(deps: flow, fn: collect_must_may, user: &mm);
3634
3635 str = "{ [0,i,0] -> [0,i,1] : 0 <= i <= 10; "
3636 " [0,i,2] -> [0,5,1] : 0 <= i <= 4 }";
3637 assert(map_is_equal(mm.may, str));
3638 str = "{ [i,j,k] -> [l,m,n] : 1 = 0 }";
3639 assert(map_is_equal(mm.must, str));
3640
3641 isl_map_free(map: mm.must);
3642 isl_map_free(map: mm.may);
3643 isl_flow_free(deps: flow);
3644
3645
3646 depth = 5;
3647
3648 str = "{ [1,i,0,0,0] -> [i,j] : 0 <= i <= 10 and 0 <= j <= 10 }";
3649 map = isl_map_read_from_str(ctx, str);
3650 ai = isl_access_info_alloc(sink: map, sink_user: &depth, fn: &common_space, max_source: 1);
3651
3652 str = "{ [0,i,0,j,0] -> [i,j] : 0 <= i <= 10 and 0 <= j <= 10 }";
3653 map = isl_map_read_from_str(ctx, str);
3654 ai = isl_access_info_add_source(acc: ai, source: map, must: 1, source_user: &depth);
3655
3656 flow = isl_access_info_compute_flow(acc: ai);
3657 space = isl_space_alloc(ctx, nparam: 0, n_in: 5, n_out: 5);
3658 mm.must = isl_map_empty(space: isl_space_copy(space));
3659 mm.may = isl_map_empty(space);
3660
3661 isl_flow_foreach(deps: flow, fn: collect_must_may, user: &mm);
3662
3663 str = "{ [0,i,0,j,0] -> [1,i,0,0,0] : 0 <= i,j <= 10 }";
3664 assert(map_is_equal(mm.must, str));
3665 str = "{ [0,0,0,0,0] -> [0,0,0,0,0] : 1 = 0 }";
3666 assert(map_is_equal(mm.may, str));
3667
3668 isl_map_free(map: mm.must);
3669 isl_map_free(map: mm.may);
3670 isl_flow_free(deps: flow);
3671
3672 return 0;
3673}
3674
3675/* Check that the dependence analysis proceeds without errors.
3676 * Earlier versions of isl would break down during the analysis
3677 * due to the use of the wrong spaces.
3678 */
3679static int test_flow(isl_ctx *ctx)
3680{
3681 const char *str;
3682 isl_union_map *access, *schedule;
3683 isl_union_map *must_dep, *may_dep;
3684 int r;
3685
3686 str = "{ S0[j] -> i[]; S1[j,i] -> i[]; S2[] -> i[]; S3[] -> i[] }";
3687 access = isl_union_map_read_from_str(ctx, str);
3688 str = "{ S0[j] -> [0,j,0,0] : 0 <= j < 10; "
3689 "S1[j,i] -> [0,j,1,i] : 0 <= j < i < 10; "
3690 "S2[] -> [1,0,0,0]; "
3691 "S3[] -> [-1,0,0,0] }";
3692 schedule = isl_union_map_read_from_str(ctx, str);
3693 r = isl_union_map_compute_flow(sink: access, must_source: isl_union_map_copy(umap: access),
3694 may_source: isl_union_map_copy(umap: access), schedule,
3695 must_dep: &must_dep, may_dep: &may_dep, NULL, NULL);
3696 isl_union_map_free(umap: may_dep);
3697 isl_union_map_free(umap: must_dep);
3698
3699 return r;
3700}
3701
3702struct {
3703 const char *map;
3704 int sv;
3705} sv_tests[] = {
3706 { "[N] -> { [i] -> [f] : 0 <= i <= N and 0 <= i - 10 f <= 9 }", 1 },
3707 { "[N] -> { [i] -> [f] : 0 <= i <= N and 0 <= i - 10 f <= 10 }", 0 },
3708 { "{ [i] -> [3*floor(i/2) + 5*floor(i/3)] }", 1 },
3709 { "{ S1[i] -> [i] : 0 <= i <= 9; S2[i] -> [i] : 0 <= i <= 9 }", 1 },
3710 { "{ [i] -> S1[i] : 0 <= i <= 9; [i] -> S2[i] : 0 <= i <= 9 }", 0 },
3711 { "{ A[i] -> [i]; B[i] -> [i]; B[i] -> [i + 1] }", 0 },
3712 { "{ A[i] -> [i]; B[i] -> [i] : i < 0; B[i] -> [i + 1] : i > 0 }", 1 },
3713 { "{ A[i] -> [i]; B[i] -> A[i] : i < 0; B[i] -> [i + 1] : i > 0 }", 1 },
3714 { "{ A[i] -> [i]; B[i] -> [j] : i - 1 <= j <= i }", 0 },
3715};
3716
3717int test_sv(isl_ctx *ctx)
3718{
3719 isl_union_map *umap;
3720 int i;
3721 int sv;
3722
3723 for (i = 0; i < ARRAY_SIZE(sv_tests); ++i) {
3724 umap = isl_union_map_read_from_str(ctx, str: sv_tests[i].map);
3725 sv = isl_union_map_is_single_valued(umap);
3726 isl_union_map_free(umap);
3727 if (sv < 0)
3728 return -1;
3729 if (sv_tests[i].sv && !sv)
3730 isl_die(ctx, isl_error_internal,
3731 "map not detected as single valued", return -1);
3732 if (!sv_tests[i].sv && sv)
3733 isl_die(ctx, isl_error_internal,
3734 "map detected as single valued", return -1);
3735 }
3736
3737 return 0;
3738}
3739
3740struct {
3741 const char *str;
3742 int bijective;
3743} bijective_tests[] = {
3744 { "[N,M]->{[i,j] -> [i]}", 0 },
3745 { "[N,M]->{[i,j] -> [i] : j=i}", 1 },
3746 { "[N,M]->{[i,j] -> [i] : j=0}", 1 },
3747 { "[N,M]->{[i,j] -> [i] : j=N}", 1 },
3748 { "[N,M]->{[i,j] -> [j,i]}", 1 },
3749 { "[N,M]->{[i,j] -> [i+j]}", 0 },
3750 { "[N,M]->{[i,j] -> []}", 0 },
3751 { "[N,M]->{[i,j] -> [i,j,N]}", 1 },
3752 { "[N,M]->{[i,j] -> [2i]}", 0 },
3753 { "[N,M]->{[i,j] -> [i,i]}", 0 },
3754 { "[N,M]->{[i,j] -> [2i,i]}", 0 },
3755 { "[N,M]->{[i,j] -> [2i,j]}", 1 },
3756 { "[N,M]->{[i,j] -> [x,y] : 2x=i & y =j}", 1 },
3757};
3758
3759static int test_bijective(struct isl_ctx *ctx)
3760{
3761 isl_map *map;
3762 int i;
3763 int bijective;
3764
3765 for (i = 0; i < ARRAY_SIZE(bijective_tests); ++i) {
3766 map = isl_map_read_from_str(ctx, str: bijective_tests[i].str);
3767 bijective = isl_map_is_bijective(map);
3768 isl_map_free(map);
3769 if (bijective < 0)
3770 return -1;
3771 if (bijective_tests[i].bijective && !bijective)
3772 isl_die(ctx, isl_error_internal,
3773 "map not detected as bijective", return -1);
3774 if (!bijective_tests[i].bijective && bijective)
3775 isl_die(ctx, isl_error_internal,
3776 "map detected as bijective", return -1);
3777 }
3778
3779 return 0;
3780}
3781
3782/* Inputs for isl_pw_qpolynomial_gist tests.
3783 * "pwqp" is the input, "set" is the context and "gist" is the expected result.
3784 */
3785struct {
3786 const char *pwqp;
3787 const char *set;
3788 const char *gist;
3789} pwqp_gist_tests[] = {
3790 { "{ [i] -> i }", "{ [k] : exists a : k = 2a }", "{ [i] -> i }" },
3791 { "{ [i] -> i + [ (i + [i/3])/2 ] }", "{ [10] }", "{ [i] -> 16 }" },
3792 { "{ [i] -> ([(i)/2]) }", "{ [k] : exists a : k = 2a+1 }",
3793 "{ [i] -> -1/2 + 1/2 * i }" },
3794 { "{ [i] -> i^2 : i != 0 }", "{ [i] : i != 0 }", "{ [i] -> i^2 }" },
3795 { "{ [i] -> i^2 : i > 0; [i] -> i^2 : i < 0 }", "{ [i] : i != 0 }",
3796 "{ [i] -> i^2 }" },
3797};
3798
3799/* Perform some basic isl_pw_qpolynomial_gist tests.
3800 */
3801static isl_stat test_pwqp_gist(isl_ctx *ctx)
3802{
3803 int i;
3804 const char *str;
3805 isl_set *set;
3806 isl_pw_qpolynomial *pwqp1, *pwqp2;
3807 isl_bool equal;
3808
3809 for (i = 0; i < ARRAY_SIZE(pwqp_gist_tests); ++i) {
3810 str = pwqp_gist_tests[i].pwqp;
3811 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3812 str = pwqp_gist_tests[i].set;
3813 set = isl_set_read_from_str(ctx, str);
3814 pwqp1 = isl_pw_qpolynomial_gist(pwqp: pwqp1, context: set);
3815 str = pwqp_gist_tests[i].gist;
3816 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3817 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3818 equal = isl_pw_qpolynomial_is_zero(pwqp: pwqp1);
3819 isl_pw_qpolynomial_free(pwqp: pwqp1);
3820
3821 if (equal < 0)
3822 return isl_stat_error;
3823 if (!equal)
3824 isl_die(ctx, isl_error_unknown,
3825 "unexpected result", return isl_stat_error);
3826 }
3827
3828 return isl_stat_ok;
3829}
3830
3831/* Perform a basic isl_pw_qpolynomial_max test.
3832 */
3833static isl_stat test_pwqp_max(isl_ctx *ctx)
3834{
3835 const char *str;
3836 isl_pw_qpolynomial *pwqp;
3837 isl_val *v;
3838 int ok;
3839
3840 str = "{ [x=2:9, y] -> floor((x + 1)/4)^3 - floor((2x)/3)^2 }";
3841 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
3842 v = isl_pw_qpolynomial_max(pwqp);
3843 ok = isl_val_cmp_si(v, i: -1) == 0;
3844 isl_val_free(v);
3845
3846 if (!v)
3847 return isl_stat_error;
3848 if (!ok)
3849 isl_die(ctx, isl_error_unknown, "unexpected maximum",
3850 return isl_stat_error);
3851
3852 return isl_stat_ok;
3853}
3854
3855static int test_pwqp(struct isl_ctx *ctx)
3856{
3857 const char *str;
3858 isl_set *set;
3859 isl_pw_qpolynomial *pwqp1, *pwqp2;
3860 int equal;
3861
3862 str = "{ [i,j,k] -> 1 + 9 * [i/5] + 7 * [j/11] + 4 * [k/13] }";
3863 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3864
3865 pwqp1 = isl_pw_qpolynomial_move_dims(pwqp: pwqp1, dst_type: isl_dim_param, dst_pos: 0,
3866 src_type: isl_dim_in, src_pos: 1, n: 1);
3867
3868 str = "[j] -> { [i,k] -> 1 + 9 * [i/5] + 7 * [j/11] + 4 * [k/13] }";
3869 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3870
3871 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3872
3873 assert(isl_pw_qpolynomial_is_zero(pwqp1));
3874
3875 isl_pw_qpolynomial_free(pwqp: pwqp1);
3876
3877 if (test_pwqp_gist(ctx) < 0)
3878 return -1;
3879
3880 str = "{ [i] -> ([([i/2] + [i/2])/5]) }";
3881 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3882 str = "{ [i] -> ([(2 * [i/2])/5]) }";
3883 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3884
3885 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3886
3887 assert(isl_pw_qpolynomial_is_zero(pwqp1));
3888
3889 isl_pw_qpolynomial_free(pwqp: pwqp1);
3890
3891 str = "{ [x] -> ([x/2] + [(x+1)/2]) }";
3892 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3893 str = "{ [x] -> x }";
3894 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3895
3896 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3897
3898 assert(isl_pw_qpolynomial_is_zero(pwqp1));
3899
3900 isl_pw_qpolynomial_free(pwqp: pwqp1);
3901
3902 str = "{ [i] -> ([i/2]) : i >= 0; [i] -> ([i/3]) : i < 0 }";
3903 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3904 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3905 pwqp1 = isl_pw_qpolynomial_coalesce(pwqp: pwqp1);
3906 pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
3907 assert(isl_pw_qpolynomial_is_zero(pwqp1));
3908 isl_pw_qpolynomial_free(pwqp: pwqp1);
3909
3910 str = "{ [a,b,a] -> (([(2*[a/3]+b)/5]) * ([(2*[a/3]+b)/5])) }";
3911 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3912 str = "{ [a,b,c] -> (([(2*[a/3]+b)/5]) * ([(2*[c/3]+b)/5])) }";
3913 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3914 set = isl_set_read_from_str(ctx, str: "{ [a,b,a] }");
3915 pwqp1 = isl_pw_qpolynomial_intersect_domain(pwpq: pwqp1, set);
3916 equal = isl_pw_qpolynomial_plain_is_equal(pwqp1, pwqp2);
3917 isl_pw_qpolynomial_free(pwqp: pwqp1);
3918 isl_pw_qpolynomial_free(pwqp: pwqp2);
3919 if (equal < 0)
3920 return -1;
3921 if (!equal)
3922 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
3923
3924 str = "{ [a,b,c] -> (([(2*[a/3]+1)/5]) * ([(2*[c/3]+1)/5])) : b = 1 }";
3925 pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
3926 str = "{ [a,b,c] -> (([(2*[a/3]+b)/5]) * ([(2*[c/3]+b)/5])) }";
3927 pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
3928 pwqp1 = isl_pw_qpolynomial_fix_val(pwqp: pwqp1, type: isl_dim_set, n: 1,
3929 v: isl_val_one(ctx));
3930 equal = isl_pw_qpolynomial_plain_is_equal(pwqp1, pwqp2);
3931 isl_pw_qpolynomial_free(pwqp: pwqp1);
3932 isl_pw_qpolynomial_free(pwqp: pwqp2);
3933 if (equal < 0)
3934 return -1;
3935 if (!equal)
3936 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
3937
3938 if (test_pwqp_max(ctx) < 0)
3939 return -1;
3940
3941 return 0;
3942}
3943
3944static int test_split_periods(isl_ctx *ctx)
3945{
3946 const char *str;
3947 isl_pw_qpolynomial *pwqp;
3948
3949 str = "{ [U,V] -> 1/3 * U + 2/3 * V - [(U + 2V)/3] + [U/2] : "
3950 "U + 2V + 3 >= 0 and - U -2V >= 0 and - U + 10 >= 0 and "
3951 "U >= 0; [U,V] -> U^2 : U >= 100 }";
3952 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
3953
3954 pwqp = isl_pw_qpolynomial_split_periods(pwqp, max_periods: 2);
3955
3956 isl_pw_qpolynomial_free(pwqp);
3957
3958 if (!pwqp)
3959 return -1;
3960
3961 return 0;
3962}
3963
3964static int test_union(isl_ctx *ctx)
3965{
3966 const char *str;
3967 isl_union_set *uset1, *uset2;
3968 isl_union_map *umap1, *umap2;
3969 int equal;
3970
3971 str = "{ [i] : 0 <= i <= 1 }";
3972 uset1 = isl_union_set_read_from_str(ctx, str);
3973 str = "{ [1] -> [0] }";
3974 umap1 = isl_union_map_read_from_str(ctx, str);
3975
3976 umap2 = isl_union_set_lex_gt_union_set(uset1: isl_union_set_copy(uset: uset1), uset2: uset1);
3977 equal = isl_union_map_is_equal(umap1, umap2);
3978
3979 isl_union_map_free(umap: umap1);
3980 isl_union_map_free(umap: umap2);
3981
3982 if (equal < 0)
3983 return -1;
3984 if (!equal)
3985 isl_die(ctx, isl_error_unknown, "union maps not equal",
3986 return -1);
3987
3988 str = "{ A[i] -> B[i]; B[i] -> C[i]; A[0] -> C[1] }";
3989 umap1 = isl_union_map_read_from_str(ctx, str);
3990 str = "{ A[i]; B[i] }";
3991 uset1 = isl_union_set_read_from_str(ctx, str);
3992
3993 uset2 = isl_union_map_domain(umap: umap1);
3994
3995 equal = isl_union_set_is_equal(uset1, uset2);
3996
3997 isl_union_set_free(uset: uset1);
3998 isl_union_set_free(uset: uset2);
3999
4000 if (equal < 0)
4001 return -1;
4002 if (!equal)
4003 isl_die(ctx, isl_error_unknown, "union sets not equal",
4004 return -1);
4005
4006 return 0;
4007}
4008
4009/* Inputs for basic isl_pw_qpolynomial_bound tests.
4010 * "type" is the type of bound that should be computed.
4011 * "poly" is a string representation of the input.
4012 * "bound" is a string representation of the expected result.
4013 * "tight" is set if the result is expected to be tight.
4014 */
4015static struct {
4016 int tight;
4017 enum isl_fold type;
4018 const char *poly;
4019 const char *bound;
4020} bound_tests[] = {
4021 /* Check that computing a bound of a non-zero polynomial
4022 * over an unbounded domain does not produce a rational value.
4023 * In particular, check that the upper bound is infinity.
4024 */
4025 { 0, isl_fold_max, "{ [m, n] -> -m * n }", "{ max(infty) }" },
4026 { 1, isl_fold_max, "{ [[a, b, c, d] -> [e]] -> 0 }",
4027 "{ [a, b, c, d] -> max(0) }" },
4028 { 1, isl_fold_max, "{ [[x] -> [x]] -> 1 : exists a : x = 2 a }",
4029 "{ [x] -> max(1) : x mod 2 = 0 }" },
4030 { 1, isl_fold_min, "{ [x=5:10] -> (x + 2)^2 }", "{ min(49) }" },
4031 { 1, isl_fold_max, "{ [0:10] -> 1 }", "{ max(1) }" },
4032 { 1, isl_fold_max, "{ [[m] -> [0:m]] -> m^2 }",
4033 "{ [m] -> max(m^2) : m >= 0 }" },
4034};
4035
4036/* Check that the bound computation can handle differences
4037 * in domain dimension names of the input polynomial and its domain.
4038 */
4039static isl_stat test_bound_space(isl_ctx *ctx)
4040{
4041 const char *str;
4042 isl_set *set;
4043 isl_pw_qpolynomial *pwqp;
4044 isl_pw_qpolynomial_fold *pwf;
4045
4046 str = "{ [[c] -> [c]] }";
4047 set = isl_set_read_from_str(ctx, str);
4048 str = "{ [[a] -> [b]] -> 1 }";
4049 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
4050 pwqp = isl_pw_qpolynomial_intersect_domain(pwpq: pwqp, set);
4051 pwf = isl_pw_qpolynomial_bound(pwqp, type: isl_fold_max, NULL);
4052 isl_pw_qpolynomial_fold_free(pwf);
4053
4054 return isl_stat_non_null(obj: pwf);
4055}
4056
4057/* Perform basic isl_pw_qpolynomial_bound tests.
4058 */
4059static int test_bound(isl_ctx *ctx)
4060{
4061 int i;
4062
4063 if (test_bound_space(ctx) < 0)
4064 return -1;
4065
4066 for (i = 0; i < ARRAY_SIZE(bound_tests); ++i) {
4067 const char *str;
4068 enum isl_fold type;
4069 isl_bool equal, tight;
4070 isl_pw_qpolynomial *pwqp;
4071 isl_pw_qpolynomial_fold *pwf1, *pwf2;
4072
4073 str = bound_tests[i].poly;
4074 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
4075 type = bound_tests[i].type;
4076 pwf1 = isl_pw_qpolynomial_bound(pwqp, type, tight: &tight);
4077 str = bound_tests[i].bound;
4078 pwf2 = isl_pw_qpolynomial_fold_read_from_str(ctx, str);
4079 equal = isl_pw_qpolynomial_fold_plain_is_equal(pwf1, pwf2);
4080 isl_pw_qpolynomial_fold_free(pwf: pwf2);
4081 isl_pw_qpolynomial_fold_free(pwf: pwf1);
4082 if (equal < 0)
4083 return -1;
4084 if (!equal)
4085 isl_die(ctx, isl_error_unknown,
4086 "incorrect bound result", return -1);
4087 if (bound_tests[i].tight && !tight)
4088 isl_die(ctx, isl_error_unknown,
4089 "bound unexpectedly not tight", return -1);
4090 }
4091
4092 return 0;
4093}
4094
4095/* isl_set is defined to isl_map internally, so the corresponding elements
4096 * are isl_basic_map objects.
4097 */
4098#undef EL_BASE
4099#undef SET_BASE
4100#define EL_BASE basic_map
4101#define SET_BASE set
4102#include "isl_test_list_templ.c"
4103
4104#undef EL_BASE
4105#undef SET_BASE
4106#define EL_BASE basic_set
4107#define SET_BASE union_set
4108#include "isl_test_list_templ.c"
4109
4110#undef EL_BASE
4111#undef SET_BASE
4112#define EL_BASE set
4113#define SET_BASE union_set
4114#include "isl_test_list_templ.c"
4115
4116#undef EL_BASE
4117#undef SET_BASE
4118#define EL_BASE basic_map
4119#define SET_BASE map
4120#include "isl_test_list_templ.c"
4121
4122#undef EL_BASE
4123#undef SET_BASE
4124#define EL_BASE map
4125#define SET_BASE union_map
4126#include "isl_test_list_templ.c"
4127
4128/* Check that the conversion from isl objects to lists works as expected.
4129 */
4130static int test_get_list(isl_ctx *ctx)
4131{
4132 if (test_get_list_basic_map_from_set(ctx, str: "{ [0]; [2]; [3] }"))
4133 return -1;
4134 if (test_get_list_basic_set_from_union_set(ctx, str: "{ A[0]; B[2]; B[3] }"))
4135 return -1;
4136 if (test_get_list_set_from_union_set(ctx, str: "{ A[0]; A[2]; B[3] }"))
4137 return -1;
4138 if (test_get_list_basic_map_from_map(ctx,
4139 str: "{ [0] -> [0]; [2] -> [0]; [3] -> [0] }"))
4140 return -1;
4141 if (test_get_list_map_from_union_map(ctx,
4142 str: "{ A[0] -> [0]; A[2] -> [0]; B[3] -> [0] }"))
4143 return -1;
4144
4145 return 0;
4146}
4147
4148static int test_lift(isl_ctx *ctx)
4149{
4150 const char *str;
4151 isl_basic_map *bmap;
4152 isl_basic_set *bset;
4153
4154 str = "{ [i0] : exists e0 : i0 = 4e0 }";
4155 bset = isl_basic_set_read_from_str(ctx, str);
4156 bset = isl_basic_set_lift(bset);
4157 bmap = isl_basic_map_from_range(bset);
4158 bset = isl_basic_map_domain(bmap);
4159 isl_basic_set_free(bset);
4160
4161 return 0;
4162}
4163
4164/* Check that isl_set_is_subset is not confused by identical
4165 * integer divisions.
4166 * The call to isl_set_normalize ensures that the equality constraints
4167 * a = b = 0 are discovered, turning e0 and e1 into identical
4168 * integer divisions. Any further simplification would remove
4169 * the duplicate integer divisions.
4170 */
4171static isl_stat test_subset_duplicate_integer_divisions(isl_ctx *ctx)
4172{
4173 const char *str;
4174 isl_bool is_subset;
4175 isl_set *set1, *set2;
4176
4177 str = "{ [a, b, c, d] : "
4178 "exists (e0 = floor((a + d)/4), e1 = floor((d)/4), "
4179 "e2 = floor((-a - d + 4 *floor((a + d)/4))/10), "
4180 "e3 = floor((-d + 4*floor((d)/4))/10): "
4181 "10e2 = -a - 2c - d + 4e0 and 10e3 = -2c - d + 4e1 and "
4182 "b >= 0 and a <= 0 and b <= a) }";
4183 set1 = isl_set_read_from_str(ctx, str);
4184 set2 = isl_set_read_from_str(ctx, str);
4185 set2 = isl_set_normalize(set: set2);
4186
4187 is_subset = isl_set_is_subset(set1, set2);
4188
4189 isl_set_free(set: set1);
4190 isl_set_free(set: set2);
4191
4192 if (is_subset < 0)
4193 return isl_stat_error;
4194 if (!is_subset)
4195 isl_die(ctx, isl_error_unknown,
4196 "set is not considered to be a subset of itself",
4197 return isl_stat_error);
4198
4199 return isl_stat_ok;
4200}
4201
4202struct {
4203 const char *set1;
4204 const char *set2;
4205 int subset;
4206} subset_tests[] = {
4207 { "{ [112, 0] }",
4208 "{ [i0, i1] : exists (e0 = [(i0 - i1)/16], e1: "
4209 "16e0 <= i0 - i1 and 16e0 >= -15 + i0 - i1 and "
4210 "16e1 <= i1 and 16e0 >= -i1 and 16e1 >= -i0 + i1) }", 1 },
4211 { "{ [65] }",
4212 "{ [i] : exists (e0 = [(255i)/256], e1 = [(127i + 65e0)/191], "
4213 "e2 = [(3i + 61e1)/65], e3 = [(52i + 12e2)/61], "
4214 "e4 = [(2i + e3)/3], e5 = [(4i + e3)/4], e6 = [(8i + e3)/12]: "
4215 "3e4 = 2i + e3 and 4e5 = 4i + e3 and 12e6 = 8i + e3 and "
4216 "i <= 255 and 64e3 >= -45 + 67i and i >= 0 and "
4217 "256e0 <= 255i and 256e0 >= -255 + 255i and "
4218 "191e1 <= 127i + 65e0 and 191e1 >= -190 + 127i + 65e0 and "
4219 "65e2 <= 3i + 61e1 and 65e2 >= -64 + 3i + 61e1 and "
4220 "61e3 <= 52i + 12e2 and 61e3 >= -60 + 52i + 12e2) }", 1 },
4221 { "{ [i] : 0 <= i <= 10 }", "{ rat: [i] : 0 <= i <= 10 }", 1 },
4222 { "{ rat: [i] : 0 <= i <= 10 }", "{ [i] : 0 <= i <= 10 }", 0 },
4223 { "{ rat: [0] }", "{ [i] : 0 <= i <= 10 }", 1 },
4224 { "{ rat: [(1)/2] }", "{ [i] : 0 <= i <= 10 }", 0 },
4225 { "{ [t, i] : (exists (e0 = [(2 + t)/4]: 4e0 <= 2 + t and "
4226 "4e0 >= -1 + t and i >= 57 and i <= 62 and "
4227 "4e0 <= 62 + t - i and 4e0 >= -61 + t + i and "
4228 "t >= 0 and t <= 511 and 4e0 <= -57 + t + i and "
4229 "4e0 >= 58 + t - i and i >= 58 + t and i >= 62 - t)) }",
4230 "{ [i0, i1] : (exists (e0 = [(4 + i0)/4]: 4e0 <= 62 + i0 - i1 and "
4231 "4e0 >= 1 + i0 and i0 >= 0 and i0 <= 511 and "
4232 "4e0 <= -57 + i0 + i1)) or "
4233 "(exists (e0 = [(2 + i0)/4]: 4e0 <= i0 and "
4234 "4e0 >= 58 + i0 - i1 and i0 >= 2 and i0 <= 511 and "
4235 "4e0 >= -61 + i0 + i1)) or "
4236 "(i1 <= 66 - i0 and i0 >= 2 and i1 >= 59 + i0) }", 1 },
4237 { "[a, b] -> { : a = 0 and b = -1 }", "[b, a] -> { : b >= -10 }", 1 },
4238};
4239
4240static int test_subset(isl_ctx *ctx)
4241{
4242 int i;
4243 isl_set *set1, *set2;
4244 int subset;
4245
4246 if (test_subset_duplicate_integer_divisions(ctx) < 0)
4247 return -1;
4248
4249 for (i = 0; i < ARRAY_SIZE(subset_tests); ++i) {
4250 set1 = isl_set_read_from_str(ctx, str: subset_tests[i].set1);
4251 set2 = isl_set_read_from_str(ctx, str: subset_tests[i].set2);
4252 subset = isl_set_is_subset(set1, set2);
4253 isl_set_free(set: set1);
4254 isl_set_free(set: set2);
4255 if (subset < 0)
4256 return -1;
4257 if (subset != subset_tests[i].subset)
4258 isl_die(ctx, isl_error_unknown,
4259 "incorrect subset result", return -1);
4260 }
4261
4262 return 0;
4263}
4264
4265/* Perform a set subtraction with a set that has a non-obviously empty disjunct.
4266 * Older versions of isl would fail on such cases.
4267 */
4268static isl_stat test_subtract_empty(isl_ctx *ctx)
4269{
4270 const char *str;
4271 isl_set *s1, *s2;
4272
4273 s1 = isl_set_read_from_str(ctx, str: "{ [0] }");
4274 str = "{ [a] : (exists (e0, e1, e2: 1056e1 <= 32 + a - 33e0 and "
4275 "1089e1 >= a - 33e0 and 1089e1 <= 1 + a - 33e0 and "
4276 "33e2 >= -a + 33e0 + 1056e1 and "
4277 "33e2 < -2a + 66e0 + 2112e1)) or a = 0 }";
4278 s2 = isl_set_read_from_str(ctx, str);
4279 s1 = isl_set_subtract(set1: s1, set2: s2);
4280 isl_set_free(set: s1);
4281
4282 return isl_stat_non_null(obj: s1);
4283}
4284
4285struct {
4286 const char *minuend;
4287 const char *subtrahend;
4288 const char *difference;
4289} subtract_domain_tests[] = {
4290 { "{ A[i] -> B[i] }", "{ A[i] }", "{ }" },
4291 { "{ A[i] -> B[i] }", "{ B[i] }", "{ A[i] -> B[i] }" },
4292 { "{ A[i] -> B[i] }", "{ A[i] : i > 0 }", "{ A[i] -> B[i] : i <= 0 }" },
4293};
4294
4295static int test_subtract(isl_ctx *ctx)
4296{
4297 int i;
4298 isl_union_map *umap1, *umap2;
4299 isl_union_pw_multi_aff *upma1, *upma2;
4300 isl_union_set *uset;
4301 int equal;
4302
4303 if (test_subtract_empty(ctx) < 0)
4304 return -1;
4305
4306 for (i = 0; i < ARRAY_SIZE(subtract_domain_tests); ++i) {
4307 umap1 = isl_union_map_read_from_str(ctx,
4308 str: subtract_domain_tests[i].minuend);
4309 uset = isl_union_set_read_from_str(ctx,
4310 str: subtract_domain_tests[i].subtrahend);
4311 umap2 = isl_union_map_read_from_str(ctx,
4312 str: subtract_domain_tests[i].difference);
4313 umap1 = isl_union_map_subtract_domain(umap: umap1, dom: uset);
4314 equal = isl_union_map_is_equal(umap1, umap2);
4315 isl_union_map_free(umap: umap1);
4316 isl_union_map_free(umap: umap2);
4317 if (equal < 0)
4318 return -1;
4319 if (!equal)
4320 isl_die(ctx, isl_error_unknown,
4321 "incorrect subtract domain result", return -1);
4322 }
4323
4324 for (i = 0; i < ARRAY_SIZE(subtract_domain_tests); ++i) {
4325 upma1 = isl_union_pw_multi_aff_read_from_str(ctx,
4326 str: subtract_domain_tests[i].minuend);
4327 uset = isl_union_set_read_from_str(ctx,
4328 str: subtract_domain_tests[i].subtrahend);
4329 upma2 = isl_union_pw_multi_aff_read_from_str(ctx,
4330 str: subtract_domain_tests[i].difference);
4331 upma1 = isl_union_pw_multi_aff_subtract_domain(upma: upma1, uset);
4332 equal = isl_union_pw_multi_aff_plain_is_equal(upma1, upma2);
4333 isl_union_pw_multi_aff_free(upma: upma1);
4334 isl_union_pw_multi_aff_free(upma: upma2);
4335 if (equal < 0)
4336 return -1;
4337 if (!equal)
4338 isl_die(ctx, isl_error_unknown,
4339 "incorrect subtract domain result", return -1);
4340 }
4341
4342 return 0;
4343}
4344
4345/* Check that intersecting the empty basic set with another basic set
4346 * does not increase the number of constraints. In particular,
4347 * the empty basic set should maintain its canonical representation.
4348 */
4349static int test_intersect_1(isl_ctx *ctx)
4350{
4351 isl_size n1, n2;
4352 isl_basic_set *bset1, *bset2;
4353
4354 bset1 = isl_basic_set_read_from_str(ctx, str: "{ [a,b,c] : 1 = 0 }");
4355 bset2 = isl_basic_set_read_from_str(ctx, str: "{ [1,2,3] }");
4356 n1 = isl_basic_set_n_constraint(bset: bset1);
4357 bset1 = isl_basic_set_intersect(bset1, bset2);
4358 n2 = isl_basic_set_n_constraint(bset: bset1);
4359 isl_basic_set_free(bset: bset1);
4360 if (n1 < 0 || n2 < 0)
4361 return -1;
4362 if (n1 != n2)
4363 isl_die(ctx, isl_error_unknown,
4364 "number of constraints of empty set changed",
4365 return -1);
4366
4367 return 0;
4368}
4369
4370/* Check that intersecting a set with itself does not cause
4371 * an explosion in the number of disjuncts.
4372 */
4373static isl_stat test_intersect_2(isl_ctx *ctx)
4374{
4375 int i;
4376 isl_set *set;
4377
4378 set = isl_set_read_from_str(ctx, str: "{ [x,y] : x >= 0 or y >= 0 }");
4379 for (i = 0; i < 100; ++i)
4380 set = isl_set_intersect(set1: set, set2: isl_set_copy(set));
4381 isl_set_free(set);
4382 if (!set)
4383 return isl_stat_error;
4384 return isl_stat_ok;
4385}
4386
4387/* Perform some intersection tests.
4388 */
4389static int test_intersect(isl_ctx *ctx)
4390{
4391 if (test_intersect_1(ctx) < 0)
4392 return -1;
4393 if (test_intersect_2(ctx) < 0)
4394 return -1;
4395
4396 return 0;
4397}
4398
4399int test_factorize(isl_ctx *ctx)
4400{
4401 const char *str;
4402 isl_basic_set *bset;
4403 isl_factorizer *f;
4404
4405 str = "{ [i0, i1, i2, i3, i4, i5, i6, i7] : 3i5 <= 2 - 2i0 and "
4406 "i0 >= -2 and i6 >= 1 + i3 and i7 >= 0 and 3i5 >= -2i0 and "
4407 "2i4 <= i2 and i6 >= 1 + 2i0 + 3i1 and i4 <= -1 and "
4408 "i6 >= 1 + 2i0 + 3i5 and i6 <= 2 + 2i0 + 3i5 and "
4409 "3i5 <= 2 - 2i0 - i2 + 3i4 and i6 <= 2 + 2i0 + 3i1 and "
4410 "i0 <= -1 and i7 <= i2 + i3 - 3i4 - i6 and "
4411 "3i5 >= -2i0 - i2 + 3i4 }";
4412 bset = isl_basic_set_read_from_str(ctx, str);
4413 f = isl_basic_set_factorizer(bset);
4414 isl_basic_set_free(bset);
4415 isl_factorizer_free(f);
4416 if (!f)
4417 isl_die(ctx, isl_error_unknown,
4418 "failed to construct factorizer", return -1);
4419
4420 str = "{ [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12] : "
4421 "i12 <= 2 + i0 - i11 and 2i8 >= -i4 and i11 >= i1 and "
4422 "3i5 <= -i2 and 2i11 >= -i4 - 2i7 and i11 <= 3 + i0 + 3i9 and "
4423 "i11 <= -i4 - 2i7 and i12 >= -i10 and i2 >= -2 and "
4424 "i11 >= i1 + 3i10 and i11 >= 1 + i0 + 3i9 and "
4425 "i11 <= 1 - i4 - 2i8 and 6i6 <= 6 - i2 and 3i6 >= 1 - i2 and "
4426 "i11 <= 2 + i1 and i12 <= i4 + i11 and i12 >= i0 - i11 and "
4427 "3i5 >= -2 - i2 and i12 >= -1 + i4 + i11 and 3i3 <= 3 - i2 and "
4428 "9i6 <= 11 - i2 + 6i5 and 3i3 >= 1 - i2 and "
4429 "9i6 <= 5 - i2 + 6i3 and i12 <= -1 and i2 <= 0 }";
4430 bset = isl_basic_set_read_from_str(ctx, str);
4431 f = isl_basic_set_factorizer(bset);
4432 isl_basic_set_free(bset);
4433 isl_factorizer_free(f);
4434 if (!f)
4435 isl_die(ctx, isl_error_unknown,
4436 "failed to construct factorizer", return -1);
4437
4438 return 0;
4439}
4440
4441static isl_stat check_injective(__isl_take isl_map *map, void *user)
4442{
4443 int *injective = user;
4444
4445 *injective = isl_map_is_injective(map);
4446 isl_map_free(map);
4447
4448 if (*injective < 0 || !*injective)
4449 return isl_stat_error;
4450
4451 return isl_stat_ok;
4452}
4453
4454int test_one_schedule(isl_ctx *ctx, const char *d, const char *w,
4455 const char *r, const char *s, int tilable, int parallel)
4456{
4457 int i;
4458 isl_union_set *D;
4459 isl_union_map *W, *R, *S;
4460 isl_union_map *empty;
4461 isl_union_map *dep_raw, *dep_war, *dep_waw, *dep;
4462 isl_union_map *validity, *proximity, *coincidence;
4463 isl_union_map *schedule;
4464 isl_union_map *test;
4465 isl_union_set *delta;
4466 isl_union_set *domain;
4467 isl_set *delta_set;
4468 isl_set *slice;
4469 isl_set *origin;
4470 isl_schedule_constraints *sc;
4471 isl_schedule *sched;
4472 int is_nonneg, is_parallel, is_tilable, is_injection, is_complete;
4473 isl_size n;
4474
4475 D = isl_union_set_read_from_str(ctx, str: d);
4476 W = isl_union_map_read_from_str(ctx, str: w);
4477 R = isl_union_map_read_from_str(ctx, str: r);
4478 S = isl_union_map_read_from_str(ctx, str: s);
4479
4480 W = isl_union_map_intersect_domain(umap: W, uset: isl_union_set_copy(uset: D));
4481 R = isl_union_map_intersect_domain(umap: R, uset: isl_union_set_copy(uset: D));
4482
4483 empty = isl_union_map_empty(space: isl_union_map_get_space(umap: S));
4484 isl_union_map_compute_flow(sink: isl_union_map_copy(umap: R),
4485 must_source: isl_union_map_copy(umap: W), may_source: empty,
4486 schedule: isl_union_map_copy(umap: S),
4487 must_dep: &dep_raw, NULL, NULL, NULL);
4488 isl_union_map_compute_flow(sink: isl_union_map_copy(umap: W),
4489 must_source: isl_union_map_copy(umap: W),
4490 may_source: isl_union_map_copy(umap: R),
4491 schedule: isl_union_map_copy(umap: S),
4492 must_dep: &dep_waw, may_dep: &dep_war, NULL, NULL);
4493
4494 dep = isl_union_map_union(umap1: dep_waw, umap2: dep_war);
4495 dep = isl_union_map_union(umap1: dep, umap2: dep_raw);
4496 validity = isl_union_map_copy(umap: dep);
4497 coincidence = isl_union_map_copy(umap: dep);
4498 proximity = isl_union_map_copy(umap: dep);
4499
4500 sc = isl_schedule_constraints_on_domain(domain: isl_union_set_copy(uset: D));
4501 sc = isl_schedule_constraints_set_validity(sc, validity);
4502 sc = isl_schedule_constraints_set_coincidence(sc, coincidence);
4503 sc = isl_schedule_constraints_set_proximity(sc, proximity);
4504 sched = isl_schedule_constraints_compute_schedule(sc);
4505 schedule = isl_schedule_get_map(sched);
4506 isl_schedule_free(sched);
4507 isl_union_map_free(umap: W);
4508 isl_union_map_free(umap: R);
4509 isl_union_map_free(umap: S);
4510
4511 is_injection = 1;
4512 isl_union_map_foreach_map(umap: schedule, fn: &check_injective, user: &is_injection);
4513
4514 domain = isl_union_map_domain(umap: isl_union_map_copy(umap: schedule));
4515 is_complete = isl_union_set_is_subset(uset1: D, uset2: domain);
4516 isl_union_set_free(uset: D);
4517 isl_union_set_free(uset: domain);
4518
4519 test = isl_union_map_reverse(umap: isl_union_map_copy(umap: schedule));
4520 test = isl_union_map_apply_range(umap1: test, umap2: dep);
4521 test = isl_union_map_apply_range(umap1: test, umap2: schedule);
4522
4523 delta = isl_union_map_deltas(umap: test);
4524 n = isl_union_set_n_set(uset: delta);
4525 if (n < 0) {
4526 isl_union_set_free(uset: delta);
4527 return -1;
4528 }
4529 if (n == 0) {
4530 is_tilable = 1;
4531 is_parallel = 1;
4532 is_nonneg = 1;
4533 isl_union_set_free(uset: delta);
4534 } else {
4535 isl_size dim;
4536
4537 delta_set = isl_set_from_union_set(uset: delta);
4538
4539 slice = isl_set_universe(space: isl_set_get_space(set: delta_set));
4540 for (i = 0; i < tilable; ++i)
4541 slice = isl_set_lower_bound_si(set: slice, type: isl_dim_set, pos: i, value: 0);
4542 is_tilable = isl_set_is_subset(set1: delta_set, set2: slice);
4543 isl_set_free(set: slice);
4544
4545 slice = isl_set_universe(space: isl_set_get_space(set: delta_set));
4546 for (i = 0; i < parallel; ++i)
4547 slice = isl_set_fix_si(set: slice, type: isl_dim_set, pos: i, value: 0);
4548 is_parallel = isl_set_is_subset(set1: delta_set, set2: slice);
4549 isl_set_free(set: slice);
4550
4551 origin = isl_set_universe(space: isl_set_get_space(set: delta_set));
4552 dim = isl_set_dim(set: origin, type: isl_dim_set);
4553 if (dim < 0)
4554 origin = isl_set_free(set: origin);
4555 for (i = 0; i < dim; ++i)
4556 origin = isl_set_fix_si(set: origin, type: isl_dim_set, pos: i, value: 0);
4557
4558 delta_set = isl_set_union(set1: delta_set, set2: isl_set_copy(set: origin));
4559 delta_set = isl_set_lexmin(set: delta_set);
4560
4561 is_nonneg = isl_set_is_equal(set1: delta_set, set2: origin);
4562
4563 isl_set_free(set: origin);
4564 isl_set_free(set: delta_set);
4565 }
4566
4567 if (is_nonneg < 0 || is_parallel < 0 || is_tilable < 0 ||
4568 is_injection < 0 || is_complete < 0)
4569 return -1;
4570 if (!is_complete)
4571 isl_die(ctx, isl_error_unknown,
4572 "generated schedule incomplete", return -1);
4573 if (!is_injection)
4574 isl_die(ctx, isl_error_unknown,
4575 "generated schedule not injective on each statement",
4576 return -1);
4577 if (!is_nonneg)
4578 isl_die(ctx, isl_error_unknown,
4579 "negative dependences in generated schedule",
4580 return -1);
4581 if (!is_tilable)
4582 isl_die(ctx, isl_error_unknown,
4583 "generated schedule not as tilable as expected",
4584 return -1);
4585 if (!is_parallel)
4586 isl_die(ctx, isl_error_unknown,
4587 "generated schedule not as parallel as expected",
4588 return -1);
4589
4590 return 0;
4591}
4592
4593/* Compute a schedule for the given instance set, validity constraints,
4594 * proximity constraints and context and return a corresponding union map
4595 * representation.
4596 */
4597static __isl_give isl_union_map *compute_schedule_with_context(isl_ctx *ctx,
4598 const char *domain, const char *validity, const char *proximity,
4599 const char *context)
4600{
4601 isl_set *con;
4602 isl_union_set *dom;
4603 isl_union_map *dep;
4604 isl_union_map *prox;
4605 isl_schedule_constraints *sc;
4606 isl_schedule *schedule;
4607 isl_union_map *sched;
4608
4609 con = isl_set_read_from_str(ctx, str: context);
4610 dom = isl_union_set_read_from_str(ctx, str: domain);
4611 dep = isl_union_map_read_from_str(ctx, str: validity);
4612 prox = isl_union_map_read_from_str(ctx, str: proximity);
4613 sc = isl_schedule_constraints_on_domain(domain: dom);
4614 sc = isl_schedule_constraints_set_context(sc, context: con);
4615 sc = isl_schedule_constraints_set_validity(sc, validity: dep);
4616 sc = isl_schedule_constraints_set_proximity(sc, proximity: prox);
4617 schedule = isl_schedule_constraints_compute_schedule(sc);
4618 sched = isl_schedule_get_map(sched: schedule);
4619 isl_schedule_free(sched: schedule);
4620
4621 return sched;
4622}
4623
4624/* Compute a schedule for the given instance set, validity constraints and
4625 * proximity constraints and return a corresponding union map representation.
4626 */
4627static __isl_give isl_union_map *compute_schedule(isl_ctx *ctx,
4628 const char *domain, const char *validity, const char *proximity)
4629{
4630 return compute_schedule_with_context(ctx, domain, validity, proximity,
4631 context: "{ : }");
4632}
4633
4634/* Check that a schedule can be constructed on the given domain
4635 * with the given validity and proximity constraints.
4636 */
4637static int test_has_schedule(isl_ctx *ctx, const char *domain,
4638 const char *validity, const char *proximity)
4639{
4640 isl_union_map *sched;
4641
4642 sched = compute_schedule(ctx, domain, validity, proximity);
4643 if (!sched)
4644 return -1;
4645
4646 isl_union_map_free(umap: sched);
4647 return 0;
4648}
4649
4650int test_special_schedule(isl_ctx *ctx, const char *domain,
4651 const char *validity, const char *proximity, const char *expected_sched)
4652{
4653 isl_union_map *sched1, *sched2;
4654 int equal;
4655
4656 sched1 = compute_schedule(ctx, domain, validity, proximity);
4657 sched2 = isl_union_map_read_from_str(ctx, str: expected_sched);
4658
4659 equal = isl_union_map_is_equal(umap1: sched1, umap2: sched2);
4660 isl_union_map_free(umap: sched1);
4661 isl_union_map_free(umap: sched2);
4662
4663 if (equal < 0)
4664 return -1;
4665 if (!equal)
4666 isl_die(ctx, isl_error_unknown, "unexpected schedule",
4667 return -1);
4668
4669 return 0;
4670}
4671
4672/* Check that the schedule map is properly padded, i.e., that the range
4673 * lives in a single space.
4674 */
4675static int test_padded_schedule(isl_ctx *ctx)
4676{
4677 const char *str;
4678 isl_union_set *D;
4679 isl_union_map *validity, *proximity;
4680 isl_schedule_constraints *sc;
4681 isl_schedule *sched;
4682 isl_union_map *umap;
4683 isl_union_set *range;
4684 isl_set *set;
4685
4686 str = "[N] -> { S0[i] : 0 <= i <= N; S1[i, j] : 0 <= i, j <= N }";
4687 D = isl_union_set_read_from_str(ctx, str);
4688 validity = isl_union_map_empty(space: isl_union_set_get_space(uset: D));
4689 proximity = isl_union_map_copy(umap: validity);
4690 sc = isl_schedule_constraints_on_domain(domain: D);
4691 sc = isl_schedule_constraints_set_validity(sc, validity);
4692 sc = isl_schedule_constraints_set_proximity(sc, proximity);
4693 sched = isl_schedule_constraints_compute_schedule(sc);
4694 umap = isl_schedule_get_map(sched);
4695 isl_schedule_free(sched);
4696 range = isl_union_map_range(umap);
4697 set = isl_set_from_union_set(uset: range);
4698 isl_set_free(set);
4699
4700 if (!set)
4701 return -1;
4702
4703 return 0;
4704}
4705
4706/* Check that conditional validity constraints are also taken into
4707 * account across bands.
4708 * In particular, try to make sure that live ranges D[1,0]->C[2,1] and
4709 * D[2,0]->C[3,0] are not local in the outer band of the generated schedule
4710 * and then check that the adjacent order constraint C[2,1]->D[2,0]
4711 * is enforced by the rest of the schedule.
4712 */
4713static int test_special_conditional_schedule_constraints(isl_ctx *ctx)
4714{
4715 const char *str;
4716 isl_union_set *domain;
4717 isl_union_map *validity, *proximity, *condition;
4718 isl_union_map *sink, *source, *dep;
4719 isl_schedule_constraints *sc;
4720 isl_schedule *schedule;
4721 isl_union_access_info *access;
4722 isl_union_flow *flow;
4723 int empty;
4724
4725 str = "[n] -> { C[k, i] : k <= -1 + n and i >= 0 and i <= -1 + k; "
4726 "A[k] : k >= 1 and k <= -1 + n; "
4727 "B[k, i] : k <= -1 + n and i >= 0 and i <= -1 + k; "
4728 "D[k, i] : k <= -1 + n and i >= 0 and i <= -1 + k }";
4729 domain = isl_union_set_read_from_str(ctx, str);
4730 sc = isl_schedule_constraints_on_domain(domain);
4731 str = "[n] -> { D[k, i] -> C[1 + k, k - i] : "
4732 "k <= -2 + n and i >= 1 and i <= -1 + k; "
4733 "D[k, i] -> C[1 + k, i] : "
4734 "k <= -2 + n and i >= 1 and i <= -1 + k; "
4735 "D[k, 0] -> C[1 + k, k] : k >= 1 and k <= -2 + n; "
4736 "D[k, 0] -> C[1 + k, 0] : k >= 1 and k <= -2 + n }";
4737 validity = isl_union_map_read_from_str(ctx, str);
4738 sc = isl_schedule_constraints_set_validity(sc, validity);
4739 str = "[n] -> { C[k, i] -> D[k, i] : "
4740 "0 <= i <= -1 + k and k <= -1 + n }";
4741 proximity = isl_union_map_read_from_str(ctx, str);
4742 sc = isl_schedule_constraints_set_proximity(sc, proximity);
4743 str = "[n] -> { [D[k, i] -> a[]] -> [C[1 + k, k - i] -> b[]] : "
4744 "i <= -1 + k and i >= 1 and k <= -2 + n; "
4745 "[B[k, i] -> c[]] -> [B[k, 1 + i] -> c[]] : "
4746 "k <= -1 + n and i >= 0 and i <= -2 + k }";
4747 condition = isl_union_map_read_from_str(ctx, str);
4748 str = "[n] -> { [B[k, i] -> e[]] -> [D[k, i] -> a[]] : "
4749 "i >= 0 and i <= -1 + k and k <= -1 + n; "
4750 "[C[k, i] -> b[]] -> [D[k', -1 + k - i] -> a[]] : "
4751 "i >= 0 and i <= -1 + k and k <= -1 + n and "
4752 "k' <= -1 + n and k' >= k - i and k' >= 1 + k; "
4753 "[C[k, i] -> b[]] -> [D[k, -1 + k - i] -> a[]] : "
4754 "i >= 0 and i <= -1 + k and k <= -1 + n; "
4755 "[B[k, i] -> c[]] -> [A[k'] -> d[]] : "
4756 "k <= -1 + n and i >= 0 and i <= -1 + k and "
4757 "k' >= 1 and k' <= -1 + n and k' >= 1 + k }";
4758 validity = isl_union_map_read_from_str(ctx, str);
4759 sc = isl_schedule_constraints_set_conditional_validity(sc, condition,
4760 validity);
4761 schedule = isl_schedule_constraints_compute_schedule(sc);
4762 str = "{ D[2,0] -> [] }";
4763 sink = isl_union_map_read_from_str(ctx, str);
4764 access = isl_union_access_info_from_sink(sink);
4765 str = "{ C[2,1] -> [] }";
4766 source = isl_union_map_read_from_str(ctx, str);
4767 access = isl_union_access_info_set_must_source(access, must_source: source);
4768 access = isl_union_access_info_set_schedule(access, schedule);
4769 flow = isl_union_access_info_compute_flow(access);
4770 dep = isl_union_flow_get_must_dependence(flow);
4771 isl_union_flow_free(flow);
4772 empty = isl_union_map_is_empty(umap: dep);
4773 isl_union_map_free(umap: dep);
4774
4775 if (empty < 0)
4776 return -1;
4777 if (empty)
4778 isl_die(ctx, isl_error_unknown,
4779 "conditional validity not respected", return -1);
4780
4781 return 0;
4782}
4783
4784/* Check that the test for violated conditional validity constraints
4785 * is not confused by domain compression.
4786 * In particular, earlier versions of isl would apply
4787 * a schedule on the compressed domains to the original domains,
4788 * resulting in a failure to detect that the default schedule
4789 * violates the conditional validity constraints.
4790 */
4791static int test_special_conditional_schedule_constraints_2(isl_ctx *ctx)
4792{
4793 const char *str;
4794 isl_bool empty;
4795 isl_union_set *domain;
4796 isl_union_map *validity, *condition;
4797 isl_schedule_constraints *sc;
4798 isl_schedule *schedule;
4799 isl_union_map *umap;
4800 isl_map *map, *ge;
4801
4802 str = "{ A[0, i] : 0 <= i <= 10; B[1, i] : 0 <= i <= 10 }";
4803 domain = isl_union_set_read_from_str(ctx, str);
4804 sc = isl_schedule_constraints_on_domain(domain);
4805 str = "{ B[1, i] -> A[0, i + 1] }";
4806 condition = isl_union_map_read_from_str(ctx, str);
4807 str = "{ A[0, i] -> B[1, i - 1] }";
4808 validity = isl_union_map_read_from_str(ctx, str);
4809 sc = isl_schedule_constraints_set_conditional_validity(sc, condition,
4810 validity: isl_union_map_copy(umap: validity));
4811 schedule = isl_schedule_constraints_compute_schedule(sc);
4812 umap = isl_schedule_get_map(sched: schedule);
4813 isl_schedule_free(sched: schedule);
4814 validity = isl_union_map_apply_domain(umap1: validity,
4815 umap2: isl_union_map_copy(umap));
4816 validity = isl_union_map_apply_range(umap1: validity, umap2: umap);
4817 map = isl_map_from_union_map(umap: validity);
4818 ge = isl_map_lex_ge(set_space: isl_space_domain(space: isl_map_get_space(map)));
4819 map = isl_map_intersect(map1: map, map2: ge);
4820 empty = isl_map_is_empty(map);
4821 isl_map_free(map);
4822
4823 if (empty < 0)
4824 return -1;
4825 if (!empty)
4826 isl_die(ctx, isl_error_unknown,
4827 "conditional validity constraints not satisfied",
4828 return -1);
4829
4830 return 0;
4831}
4832
4833/* Input for testing of schedule construction based on
4834 * conditional constraints.
4835 *
4836 * domain is the iteration domain
4837 * flow are the flow dependences, which determine the validity and
4838 * proximity constraints
4839 * condition are the conditions on the conditional validity constraints
4840 * conditional_validity are the conditional validity constraints
4841 * outer_band_n is the expected number of members in the outer band
4842 */
4843struct {
4844 const char *domain;
4845 const char *flow;
4846 const char *condition;
4847 const char *conditional_validity;
4848 int outer_band_n;
4849} live_range_tests[] = {
4850 /* Contrived example that illustrates that we need to keep
4851 * track of tagged condition dependences and
4852 * tagged conditional validity dependences
4853 * in isl_sched_edge separately.
4854 * In particular, the conditional validity constraints on A
4855 * cannot be satisfied,
4856 * but they can be ignored because there are no corresponding
4857 * condition constraints. However, we do have an additional
4858 * conditional validity constraint that maps to the same
4859 * dependence relation
4860 * as the condition constraint on B. If we did not make a distinction
4861 * between tagged condition and tagged conditional validity
4862 * dependences, then we
4863 * could end up treating this shared dependence as an condition
4864 * constraint on A, forcing a localization of the conditions,
4865 * which is impossible.
4866 */
4867 { "{ S[i] : 0 <= 1 < 100; T[i] : 0 <= 1 < 100 }",
4868 "{ S[i] -> S[i+1] : 0 <= i < 99 }",
4869 "{ [S[i] -> B[]] -> [S[i+1] -> B[]] : 0 <= i < 99 }",
4870 "{ [S[i] -> A[]] -> [T[i'] -> A[]] : 0 <= i', i < 100 and i != i';"
4871 "[T[i] -> A[]] -> [S[i'] -> A[]] : 0 <= i', i < 100 and i != i';"
4872 "[S[i] -> A[]] -> [S[i+1] -> A[]] : 0 <= i < 99 }",
4873 1
4874 },
4875 /* TACO 2013 Fig. 7 */
4876 { "[n] -> { S1[i,j] : 0 <= i,j < n; S2[i,j] : 0 <= i,j < n }",
4877 "[n] -> { S1[i,j] -> S2[i,j] : 0 <= i,j < n;"
4878 "S2[i,j] -> S2[i,j+1] : 0 <= i < n and 0 <= j < n - 1 }",
4879 "[n] -> { [S1[i,j] -> t[]] -> [S2[i,j] -> t[]] : 0 <= i,j < n;"
4880 "[S2[i,j] -> x1[]] -> [S2[i,j+1] -> x1[]] : "
4881 "0 <= i < n and 0 <= j < n - 1 }",
4882 "[n] -> { [S2[i,j] -> t[]] -> [S1[i,j'] -> t[]] : "
4883 "0 <= i < n and 0 <= j < j' < n;"
4884 "[S2[i,j] -> t[]] -> [S1[i',j'] -> t[]] : "
4885 "0 <= i < i' < n and 0 <= j,j' < n;"
4886 "[S2[i,j] -> x1[]] -> [S2[i,j'] -> x1[]] : "
4887 "0 <= i,j,j' < n and j < j' }",
4888 2
4889 },
4890 /* TACO 2013 Fig. 7, without tags */
4891 { "[n] -> { S1[i,j] : 0 <= i,j < n; S2[i,j] : 0 <= i,j < n }",
4892 "[n] -> { S1[i,j] -> S2[i,j] : 0 <= i,j < n;"
4893 "S2[i,j] -> S2[i,j+1] : 0 <= i < n and 0 <= j < n - 1 }",
4894 "[n] -> { S1[i,j] -> S2[i,j] : 0 <= i,j < n;"
4895 "S2[i,j] -> S2[i,j+1] : 0 <= i < n and 0 <= j < n - 1 }",
4896 "[n] -> { S2[i,j] -> S1[i,j'] : 0 <= i < n and 0 <= j < j' < n;"
4897 "S2[i,j] -> S1[i',j'] : 0 <= i < i' < n and 0 <= j,j' < n;"
4898 "S2[i,j] -> S2[i,j'] : 0 <= i,j,j' < n and j < j' }",
4899 1
4900 },
4901 /* TACO 2013 Fig. 12 */
4902 { "{ S1[i,0] : 0 <= i <= 1; S2[i,j] : 0 <= i <= 1 and 1 <= j <= 2;"
4903 "S3[i,3] : 0 <= i <= 1 }",
4904 "{ S1[i,0] -> S2[i,1] : 0 <= i <= 1;"
4905 "S2[i,1] -> S2[i,2] : 0 <= i <= 1;"
4906 "S2[i,2] -> S3[i,3] : 0 <= i <= 1 }",
4907 "{ [S1[i,0]->t[]] -> [S2[i,1]->t[]] : 0 <= i <= 1;"
4908 "[S2[i,1]->t[]] -> [S2[i,2]->t[]] : 0 <= i <= 1;"
4909 "[S2[i,2]->t[]] -> [S3[i,3]->t[]] : 0 <= i <= 1 }",
4910 "{ [S2[i,1]->t[]] -> [S2[i,2]->t[]] : 0 <= i <= 1;"
4911 "[S2[0,j]->t[]] -> [S2[1,j']->t[]] : 1 <= j,j' <= 2;"
4912 "[S2[0,j]->t[]] -> [S1[1,0]->t[]] : 1 <= j <= 2;"
4913 "[S3[0,3]->t[]] -> [S2[1,j]->t[]] : 1 <= j <= 2;"
4914 "[S3[0,3]->t[]] -> [S1[1,0]->t[]] }",
4915 1
4916 }
4917};
4918
4919/* Test schedule construction based on conditional constraints.
4920 * In particular, check the number of members in the outer band node
4921 * as an indication of whether tiling is possible or not.
4922 */
4923static int test_conditional_schedule_constraints(isl_ctx *ctx)
4924{
4925 int i;
4926 isl_union_set *domain;
4927 isl_union_map *condition;
4928 isl_union_map *flow;
4929 isl_union_map *validity;
4930 isl_schedule_constraints *sc;
4931 isl_schedule *schedule;
4932 isl_schedule_node *node;
4933 isl_size n_member;
4934
4935 if (test_special_conditional_schedule_constraints(ctx) < 0)
4936 return -1;
4937 if (test_special_conditional_schedule_constraints_2(ctx) < 0)
4938 return -1;
4939
4940 for (i = 0; i < ARRAY_SIZE(live_range_tests); ++i) {
4941 domain = isl_union_set_read_from_str(ctx,
4942 str: live_range_tests[i].domain);
4943 flow = isl_union_map_read_from_str(ctx,
4944 str: live_range_tests[i].flow);
4945 condition = isl_union_map_read_from_str(ctx,
4946 str: live_range_tests[i].condition);
4947 validity = isl_union_map_read_from_str(ctx,
4948 str: live_range_tests[i].conditional_validity);
4949 sc = isl_schedule_constraints_on_domain(domain);
4950 sc = isl_schedule_constraints_set_validity(sc,
4951 validity: isl_union_map_copy(umap: flow));
4952 sc = isl_schedule_constraints_set_proximity(sc, proximity: flow);
4953 sc = isl_schedule_constraints_set_conditional_validity(sc,
4954 condition, validity);
4955 schedule = isl_schedule_constraints_compute_schedule(sc);
4956 node = isl_schedule_get_root(schedule);
4957 while (node &&
4958 isl_schedule_node_get_type(node) != isl_schedule_node_band)
4959 node = isl_schedule_node_first_child(node);
4960 n_member = isl_schedule_node_band_n_member(node);
4961 isl_schedule_node_free(node);
4962 isl_schedule_free(sched: schedule);
4963
4964 if (!schedule || n_member < 0)
4965 return -1;
4966 if (n_member != live_range_tests[i].outer_band_n)
4967 isl_die(ctx, isl_error_unknown,
4968 "unexpected number of members in outer band",
4969 return -1);
4970 }
4971 return 0;
4972}
4973
4974/* Check that the schedule computed for the given instance set and
4975 * dependence relation strongly satisfies the dependences.
4976 * In particular, check that no instance is scheduled before
4977 * or together with an instance on which it depends.
4978 * Earlier versions of isl would produce a schedule that
4979 * only weakly satisfies the dependences.
4980 */
4981static int test_strongly_satisfying_schedule(isl_ctx *ctx)
4982{
4983 const char *domain, *dep;
4984 isl_union_map *D, *schedule;
4985 isl_map *map, *ge;
4986 int empty;
4987
4988 domain = "{ B[i0, i1] : 0 <= i0 <= 1 and 0 <= i1 <= 11; "
4989 "A[i0] : 0 <= i0 <= 1 }";
4990 dep = "{ B[i0, i1] -> B[i0, 1 + i1] : 0 <= i0 <= 1 and 0 <= i1 <= 10; "
4991 "B[0, 11] -> A[1]; A[i0] -> B[i0, 0] : 0 <= i0 <= 1 }";
4992 schedule = compute_schedule(ctx, domain, validity: dep, proximity: dep);
4993 D = isl_union_map_read_from_str(ctx, str: dep);
4994 D = isl_union_map_apply_domain(umap1: D, umap2: isl_union_map_copy(umap: schedule));
4995 D = isl_union_map_apply_range(umap1: D, umap2: schedule);
4996 map = isl_map_from_union_map(umap: D);
4997 ge = isl_map_lex_ge(set_space: isl_space_domain(space: isl_map_get_space(map)));
4998 map = isl_map_intersect(map1: map, map2: ge);
4999 empty = isl_map_is_empty(map);
5000 isl_map_free(map);
5001
5002 if (empty < 0)
5003 return -1;
5004 if (!empty)
5005 isl_die(ctx, isl_error_unknown,
5006 "dependences not strongly satisfied", return -1);
5007
5008 return 0;
5009}
5010
5011/* Compute a schedule for input where the instance set constraints
5012 * conflict with the context constraints.
5013 * Earlier versions of isl did not properly handle this situation.
5014 */
5015static int test_conflicting_context_schedule(isl_ctx *ctx)
5016{
5017 isl_union_map *schedule;
5018 const char *domain, *context;
5019
5020 domain = "[n] -> { A[] : n >= 0 }";
5021 context = "[n] -> { : n < 0 }";
5022 schedule = compute_schedule_with_context(ctx,
5023 domain, validity: "{}", proximity: "{}", context);
5024 isl_union_map_free(umap: schedule);
5025
5026 if (!schedule)
5027 return -1;
5028
5029 return 0;
5030}
5031
5032/* Check that a set of schedule constraints that only allow for
5033 * a coalescing schedule still produces a schedule even if the user
5034 * request a non-coalescing schedule. Earlier versions of isl
5035 * would not handle this case correctly.
5036 */
5037static int test_coalescing_schedule(isl_ctx *ctx)
5038{
5039 const char *domain, *dep;
5040 isl_union_set *I;
5041 isl_union_map *D;
5042 isl_schedule_constraints *sc;
5043 isl_schedule *schedule;
5044 int treat_coalescing;
5045
5046 domain = "{ S[a, b] : 0 <= a <= 1 and 0 <= b <= 1 }";
5047 dep = "{ S[a, b] -> S[a + b, 1 - b] }";
5048 I = isl_union_set_read_from_str(ctx, str: domain);
5049 D = isl_union_map_read_from_str(ctx, str: dep);
5050 sc = isl_schedule_constraints_on_domain(domain: I);
5051 sc = isl_schedule_constraints_set_validity(sc, validity: D);
5052 treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx);
5053 isl_options_set_schedule_treat_coalescing(ctx, val: 1);
5054 schedule = isl_schedule_constraints_compute_schedule(sc);
5055 isl_options_set_schedule_treat_coalescing(ctx, val: treat_coalescing);
5056 isl_schedule_free(sched: schedule);
5057 if (!schedule)
5058 return -1;
5059 return 0;
5060}
5061
5062/* Check that the scheduler does not perform any needless
5063 * compound skewing. Earlier versions of isl would compute
5064 * schedules in terms of transformed schedule coefficients and
5065 * would not accurately keep track of the sum of the original
5066 * schedule coefficients. It could then produce the schedule
5067 * S[t,i,j,k] -> [t, 2t + i, 2t + i + j, 2t + i + j + k]
5068 * for the input below instead of the schedule below.
5069 */
5070static int test_skewing_schedule(isl_ctx *ctx)
5071{
5072 const char *D, *V, *P, *S;
5073
5074 D = "[n] -> { S[t,i,j,k] : 0 <= t,i,j,k < n }";
5075 V = "[n] -> { S[t,i,j,k] -> S[t+1,a,b,c] : 0 <= t,i,j,k,a,b,c < n and "
5076 "-2 <= a-i <= 2 and -1 <= a-i + b-j <= 1 and "
5077 "-1 <= a-i + b-j + c-k <= 1 }";
5078 P = "{ }";
5079 S = "{ S[t,i,j,k] -> [t, 2t + i, t + i + j, 2t + k] }";
5080
5081 return test_special_schedule(ctx, domain: D, validity: V, proximity: P, expected_sched: S);
5082}
5083
5084int test_schedule(isl_ctx *ctx)
5085{
5086 const char *D, *W, *R, *V, *P, *S;
5087 int max_coincidence;
5088 int treat_coalescing;
5089
5090 /* Handle resulting schedule with zero bands. */
5091 if (test_one_schedule(ctx, d: "{[]}", w: "{}", r: "{}", s: "{[] -> []}", tilable: 0, parallel: 0) < 0)
5092 return -1;
5093
5094 /* Jacobi */
5095 D = "[T,N] -> { S1[t,i] : 1 <= t <= T and 2 <= i <= N - 1 }";
5096 W = "{ S1[t,i] -> a[t,i] }";
5097 R = "{ S1[t,i] -> a[t-1,i]; S1[t,i] -> a[t-1,i-1]; "
5098 "S1[t,i] -> a[t-1,i+1] }";
5099 S = "{ S1[t,i] -> [t,i] }";
5100 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 2, parallel: 0) < 0)
5101 return -1;
5102
5103 /* Fig. 5 of CC2008 */
5104 D = "[N] -> { S_0[i, j] : i >= 0 and i <= -1 + N and j >= 2 and "
5105 "j <= -1 + N }";
5106 W = "[N] -> { S_0[i, j] -> a[i, j] : i >= 0 and i <= -1 + N and "
5107 "j >= 2 and j <= -1 + N }";
5108 R = "[N] -> { S_0[i, j] -> a[j, i] : i >= 0 and i <= -1 + N and "
5109 "j >= 2 and j <= -1 + N; "
5110 "S_0[i, j] -> a[i, -1 + j] : i >= 0 and i <= -1 + N and "
5111 "j >= 2 and j <= -1 + N }";
5112 S = "[N] -> { S_0[i, j] -> [0, i, 0, j, 0] }";
5113 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 2, parallel: 0) < 0)
5114 return -1;
5115
5116 D = "{ S1[i] : 0 <= i <= 10; S2[i] : 0 <= i <= 9 }";
5117 W = "{ S1[i] -> a[i] }";
5118 R = "{ S2[i] -> a[i+1] }";
5119 S = "{ S1[i] -> [0,i]; S2[i] -> [1,i] }";
5120 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 1, parallel: 1) < 0)
5121 return -1;
5122
5123 D = "{ S1[i] : 0 <= i < 10; S2[i] : 0 <= i < 10 }";
5124 W = "{ S1[i] -> a[i] }";
5125 R = "{ S2[i] -> a[9-i] }";
5126 S = "{ S1[i] -> [0,i]; S2[i] -> [1,i] }";
5127 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 1, parallel: 1) < 0)
5128 return -1;
5129
5130 D = "[N] -> { S1[i] : 0 <= i < N; S2[i] : 0 <= i < N }";
5131 W = "{ S1[i] -> a[i] }";
5132 R = "[N] -> { S2[i] -> a[N-1-i] }";
5133 S = "{ S1[i] -> [0,i]; S2[i] -> [1,i] }";
5134 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 1, parallel: 1) < 0)
5135 return -1;
5136
5137 D = "{ S1[i] : 0 < i < 10; S2[i] : 0 <= i < 10 }";
5138 W = "{ S1[i] -> a[i]; S2[i] -> b[i] }";
5139 R = "{ S2[i] -> a[i]; S1[i] -> b[i-1] }";
5140 S = "{ S1[i] -> [i,0]; S2[i] -> [i,1] }";
5141 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 0, parallel: 0) < 0)
5142 return -1;
5143
5144 D = "[N] -> { S1[i] : 1 <= i <= N; S2[i,j] : 1 <= i,j <= N }";
5145 W = "{ S1[i] -> a[0,i]; S2[i,j] -> a[i,j] }";
5146 R = "{ S2[i,j] -> a[i-1,j] }";
5147 S = "{ S1[i] -> [0,i,0]; S2[i,j] -> [1,i,j] }";
5148 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 2, parallel: 1) < 0)
5149 return -1;
5150
5151 D = "[N] -> { S1[i] : 1 <= i <= N; S2[i,j] : 1 <= i,j <= N }";
5152 W = "{ S1[i] -> a[i,0]; S2[i,j] -> a[i,j] }";
5153 R = "{ S2[i,j] -> a[i,j-1] }";
5154 S = "{ S1[i] -> [0,i,0]; S2[i,j] -> [1,i,j] }";
5155 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 2, parallel: 1) < 0)
5156 return -1;
5157
5158 D = "[N] -> { S_0[]; S_1[i] : i >= 0 and i <= -1 + N; S_2[] }";
5159 W = "[N] -> { S_0[] -> a[0]; S_2[] -> b[0]; "
5160 "S_1[i] -> a[1 + i] : i >= 0 and i <= -1 + N }";
5161 R = "[N] -> { S_2[] -> a[N]; S_1[i] -> a[i] : i >= 0 and i <= -1 + N }";
5162 S = "[N] -> { S_1[i] -> [1, i, 0]; S_2[] -> [2, 0, 1]; "
5163 "S_0[] -> [0, 0, 0] }";
5164 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 1, parallel: 0) < 0)
5165 return -1;
5166 ctx->opt->schedule_parametric = 0;
5167 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 0, parallel: 0) < 0)
5168 return -1;
5169 ctx->opt->schedule_parametric = 1;
5170
5171 D = "[N] -> { S1[i] : 1 <= i <= N; S2[i] : 1 <= i <= N; "
5172 "S3[i,j] : 1 <= i,j <= N; S4[i] : 1 <= i <= N }";
5173 W = "{ S1[i] -> a[i,0]; S2[i] -> a[0,i]; S3[i,j] -> a[i,j] }";
5174 R = "[N] -> { S3[i,j] -> a[i-1,j]; S3[i,j] -> a[i,j-1]; "
5175 "S4[i] -> a[i,N] }";
5176 S = "{ S1[i] -> [0,i,0]; S2[i] -> [1,i,0]; S3[i,j] -> [2,i,j]; "
5177 "S4[i] -> [4,i,0] }";
5178 max_coincidence = isl_options_get_schedule_maximize_coincidence(ctx);
5179 isl_options_set_schedule_maximize_coincidence(ctx, val: 0);
5180 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 2, parallel: 0) < 0)
5181 return -1;
5182 isl_options_set_schedule_maximize_coincidence(ctx, val: max_coincidence);
5183
5184 D = "[N] -> { S_0[i, j] : i >= 1 and i <= N and j >= 1 and j <= N }";
5185 W = "[N] -> { S_0[i, j] -> s[0] : i >= 1 and i <= N and j >= 1 and "
5186 "j <= N }";
5187 R = "[N] -> { S_0[i, j] -> s[0] : i >= 1 and i <= N and j >= 1 and "
5188 "j <= N; "
5189 "S_0[i, j] -> a[i, j] : i >= 1 and i <= N and j >= 1 and "
5190 "j <= N }";
5191 S = "[N] -> { S_0[i, j] -> [0, i, 0, j, 0] }";
5192 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 0, parallel: 0) < 0)
5193 return -1;
5194
5195 D = "[N] -> { S_0[t] : t >= 0 and t <= -1 + N; "
5196 " S_2[t] : t >= 0 and t <= -1 + N; "
5197 " S_1[t, i] : t >= 0 and t <= -1 + N and i >= 0 and "
5198 "i <= -1 + N }";
5199 W = "[N] -> { S_0[t] -> a[t, 0] : t >= 0 and t <= -1 + N; "
5200 " S_2[t] -> b[t] : t >= 0 and t <= -1 + N; "
5201 " S_1[t, i] -> a[t, 1 + i] : t >= 0 and t <= -1 + N and "
5202 "i >= 0 and i <= -1 + N }";
5203 R = "[N] -> { S_1[t, i] -> a[t, i] : t >= 0 and t <= -1 + N and "
5204 "i >= 0 and i <= -1 + N; "
5205 " S_2[t] -> a[t, N] : t >= 0 and t <= -1 + N }";
5206 S = "[N] -> { S_2[t] -> [0, t, 2]; S_1[t, i] -> [0, t, 1, i, 0]; "
5207 " S_0[t] -> [0, t, 0] }";
5208
5209 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 2, parallel: 1) < 0)
5210 return -1;
5211 ctx->opt->schedule_parametric = 0;
5212 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 0, parallel: 0) < 0)
5213 return -1;
5214 ctx->opt->schedule_parametric = 1;
5215
5216 D = "[N] -> { S1[i,j] : 0 <= i,j < N; S2[i,j] : 0 <= i,j < N }";
5217 S = "{ S1[i,j] -> [0,i,j]; S2[i,j] -> [1,i,j] }";
5218 if (test_one_schedule(ctx, d: D, w: "{}", r: "{}", s: S, tilable: 2, parallel: 2) < 0)
5219 return -1;
5220
5221 D = "[M, N] -> { S_1[i] : i >= 0 and i <= -1 + M; "
5222 "S_0[i, j] : i >= 0 and i <= -1 + M and j >= 0 and j <= -1 + N }";
5223 W = "[M, N] -> { S_0[i, j] -> a[j] : i >= 0 and i <= -1 + M and "
5224 "j >= 0 and j <= -1 + N; "
5225 "S_1[i] -> b[0] : i >= 0 and i <= -1 + M }";
5226 R = "[M, N] -> { S_0[i, j] -> a[0] : i >= 0 and i <= -1 + M and "
5227 "j >= 0 and j <= -1 + N; "
5228 "S_1[i] -> b[0] : i >= 0 and i <= -1 + M }";
5229 S = "[M, N] -> { S_1[i] -> [1, i, 0]; S_0[i, j] -> [0, i, 0, j, 0] }";
5230 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 0, parallel: 0) < 0)
5231 return -1;
5232
5233 D = "{ S_0[i] : i >= 0 }";
5234 W = "{ S_0[i] -> a[i] : i >= 0 }";
5235 R = "{ S_0[i] -> a[0] : i >= 0 }";
5236 S = "{ S_0[i] -> [0, i, 0] }";
5237 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 0, parallel: 0) < 0)
5238 return -1;
5239
5240 D = "{ S_0[i] : i >= 0; S_1[i] : i >= 0 }";
5241 W = "{ S_0[i] -> a[i] : i >= 0; S_1[i] -> b[i] : i >= 0 }";
5242 R = "{ S_0[i] -> b[0] : i >= 0; S_1[i] -> a[i] : i >= 0 }";
5243 S = "{ S_1[i] -> [0, i, 1]; S_0[i] -> [0, i, 0] }";
5244 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 0, parallel: 0) < 0)
5245 return -1;
5246
5247 D = "[n] -> { S_0[j, k] : j <= -1 + n and j >= 0 and "
5248 "k <= -1 + n and k >= 0 }";
5249 W = "[n] -> { S_0[j, k] -> B[j] : j <= -1 + n and j >= 0 and " "k <= -1 + n and k >= 0 }";
5250 R = "[n] -> { S_0[j, k] -> B[j] : j <= -1 + n and j >= 0 and "
5251 "k <= -1 + n and k >= 0; "
5252 "S_0[j, k] -> B[k] : j <= -1 + n and j >= 0 and "
5253 "k <= -1 + n and k >= 0; "
5254 "S_0[j, k] -> A[k] : j <= -1 + n and j >= 0 and "
5255 "k <= -1 + n and k >= 0 }";
5256 S = "[n] -> { S_0[j, k] -> [2, j, k] }";
5257 ctx->opt->schedule_outer_coincidence = 1;
5258 if (test_one_schedule(ctx, d: D, w: W, r: R, s: S, tilable: 0, parallel: 0) < 0)
5259 return -1;
5260 ctx->opt->schedule_outer_coincidence = 0;
5261
5262 D = "{Stmt_for_body24[i0, i1, i2, i3]:"
5263 "i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 6 and i2 >= 2 and "
5264 "i2 <= 6 - i1 and i3 >= 0 and i3 <= -1 + i2;"
5265 "Stmt_for_body24[i0, i1, 1, 0]:"
5266 "i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 5;"
5267 "Stmt_for_body7[i0, i1, i2]:"
5268 "i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 7 and i2 >= 0 and "
5269 "i2 <= 7 }";
5270
5271 V = "{Stmt_for_body24[0, i1, i2, i3] -> "
5272 "Stmt_for_body24[1, i1, i2, i3]:"
5273 "i3 >= 0 and i3 <= -1 + i2 and i1 >= 0 and i2 <= 6 - i1 and "
5274 "i2 >= 1;"
5275 "Stmt_for_body24[0, i1, i2, i3] -> "
5276 "Stmt_for_body7[1, 1 + i1 + i3, 1 + i1 + i2]:"
5277 "i3 <= -1 + i2 and i2 <= 6 - i1 and i2 >= 1 and i1 >= 0 and "
5278 "i3 >= 0;"
5279 "Stmt_for_body24[0, i1, i2, i3] ->"
5280 "Stmt_for_body7[1, i1, 1 + i1 + i3]:"
5281 "i3 >= 0 and i2 <= 6 - i1 and i1 >= 0 and i3 <= -1 + i2;"
5282 "Stmt_for_body7[0, i1, i2] -> Stmt_for_body7[1, i1, i2]:"
5283 "(i2 >= 1 + i1 and i2 <= 6 and i1 >= 0 and i1 <= 4) or "
5284 "(i2 >= 3 and i2 <= 7 and i1 >= 1 and i2 >= 1 + i1) or "
5285 "(i2 >= 0 and i2 <= i1 and i2 >= -7 + i1 and i1 <= 7);"
5286 "Stmt_for_body7[0, i1, 1 + i1] -> Stmt_for_body7[1, i1, 1 + i1]:"
5287 "i1 <= 6 and i1 >= 0;"
5288 "Stmt_for_body7[0, 0, 7] -> Stmt_for_body7[1, 0, 7];"
5289 "Stmt_for_body7[i0, i1, i2] -> "
5290 "Stmt_for_body24[i0, o1, -1 + i2 - o1, -1 + i1 - o1]:"
5291 "i0 >= 0 and i0 <= 1 and o1 >= 0 and i2 >= 1 + i1 and "
5292 "o1 <= -2 + i2 and i2 <= 7 and o1 <= -1 + i1;"
5293 "Stmt_for_body7[i0, i1, i2] -> "
5294 "Stmt_for_body24[i0, i1, o2, -1 - i1 + i2]:"
5295 "i0 >= 0 and i0 <= 1 and i1 >= 0 and o2 >= -i1 + i2 and "
5296 "o2 >= 1 and o2 <= 6 - i1 and i2 >= 1 + i1 }";
5297 P = V;
5298
5299 treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx);
5300 isl_options_set_schedule_treat_coalescing(ctx, val: 0);
5301 if (test_has_schedule(ctx, domain: D, validity: V, proximity: P) < 0)
5302 return -1;
5303 isl_options_set_schedule_treat_coalescing(ctx, val: treat_coalescing);
5304
5305 D = "{ S_0[i, j] : i >= 1 and i <= 10 and j >= 1 and j <= 8 }";
5306 V = "{ S_0[i, j] -> S_0[i, 1 + j] : i >= 1 and i <= 10 and "
5307 "j >= 1 and j <= 7;"
5308 "S_0[i, j] -> S_0[1 + i, j] : i >= 1 and i <= 9 and "
5309 "j >= 1 and j <= 8 }";
5310 P = "{ }";
5311 S = "{ S_0[i, j] -> [i + j, i] }";
5312 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER;
5313 if (test_special_schedule(ctx, domain: D, validity: V, proximity: P, expected_sched: S) < 0)
5314 return -1;
5315 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL;
5316
5317 /* Fig. 1 from Feautrier's "Some Efficient Solutions..." pt. 2, 1992 */
5318 D = "[N] -> { S_0[i, j] : i >= 0 and i <= -1 + N and "
5319 "j >= 0 and j <= -1 + i }";
5320 V = "[N] -> { S_0[i, j] -> S_0[i, 1 + j] : j <= -2 + i and "
5321 "i <= -1 + N and j >= 0;"
5322 "S_0[i, -1 + i] -> S_0[1 + i, 0] : i >= 1 and "
5323 "i <= -2 + N }";
5324 P = "{ }";
5325 S = "{ S_0[i, j] -> [i, j] }";
5326 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER;
5327 if (test_special_schedule(ctx, domain: D, validity: V, proximity: P, expected_sched: S) < 0)
5328 return -1;
5329 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL;
5330
5331 /* Test both algorithms on a case with only proximity dependences. */
5332 D = "{ S[i,j] : 0 <= i <= 10 }";
5333 V = "{ }";
5334 P = "{ S[i,j] -> S[i+1,j] : 0 <= i,j <= 10 }";
5335 S = "{ S[i, j] -> [j, i] }";
5336 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER;
5337 if (test_special_schedule(ctx, domain: D, validity: V, proximity: P, expected_sched: S) < 0)
5338 return -1;
5339 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL;
5340 if (test_special_schedule(ctx, domain: D, validity: V, proximity: P, expected_sched: S) < 0)
5341 return -1;
5342
5343 D = "{ A[a]; B[] }";
5344 V = "{}";
5345 P = "{ A[a] -> B[] }";
5346 if (test_has_schedule(ctx, domain: D, validity: V, proximity: P) < 0)
5347 return -1;
5348
5349 if (test_padded_schedule(ctx) < 0)
5350 return -1;
5351
5352 /* Check that check for progress is not confused by rational
5353 * solution.
5354 */
5355 D = "[N] -> { S0[i, j] : i >= 0 and i <= N and j >= 0 and j <= N }";
5356 V = "[N] -> { S0[i0, -1 + N] -> S0[2 + i0, 0] : i0 >= 0 and "
5357 "i0 <= -2 + N; "
5358 "S0[i0, i1] -> S0[i0, 1 + i1] : i0 >= 0 and "
5359 "i0 <= N and i1 >= 0 and i1 <= -1 + N }";
5360 P = "{}";
5361 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER;
5362 if (test_has_schedule(ctx, domain: D, validity: V, proximity: P) < 0)
5363 return -1;
5364 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL;
5365
5366 /* Check that we allow schedule rows that are only non-trivial
5367 * on some full-dimensional domains.
5368 */
5369 D = "{ S1[j] : 0 <= j <= 1; S0[]; S2[k] : 0 <= k <= 1 }";
5370 V = "{ S0[] -> S1[j] : 0 <= j <= 1; S2[0] -> S0[];"
5371 "S1[j] -> S2[1] : 0 <= j <= 1 }";
5372 P = "{}";
5373 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER;
5374 if (test_has_schedule(ctx, domain: D, validity: V, proximity: P) < 0)
5375 return -1;
5376 ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_ISL;
5377
5378 if (test_conditional_schedule_constraints(ctx) < 0)
5379 return -1;
5380
5381 if (test_strongly_satisfying_schedule(ctx) < 0)
5382 return -1;
5383
5384 if (test_conflicting_context_schedule(ctx) < 0)
5385 return -1;
5386
5387 if (test_coalescing_schedule(ctx) < 0)
5388 return -1;
5389 if (test_skewing_schedule(ctx) < 0)
5390 return -1;
5391
5392 return 0;
5393}
5394
5395/* Perform scheduling tests using the whole component scheduler.
5396 */
5397static int test_schedule_whole(isl_ctx *ctx)
5398{
5399 int whole;
5400 int r;
5401
5402 whole = isl_options_get_schedule_whole_component(ctx);
5403 isl_options_set_schedule_whole_component(ctx, val: 1);
5404 r = test_schedule(ctx);
5405 isl_options_set_schedule_whole_component(ctx, val: whole);
5406
5407 return r;
5408}
5409
5410/* Perform scheduling tests using the incremental scheduler.
5411 */
5412static int test_schedule_incremental(isl_ctx *ctx)
5413{
5414 int whole;
5415 int r;
5416
5417 whole = isl_options_get_schedule_whole_component(ctx);
5418 isl_options_set_schedule_whole_component(ctx, val: 0);
5419 r = test_schedule(ctx);
5420 isl_options_set_schedule_whole_component(ctx, val: whole);
5421
5422 return r;
5423}
5424
5425int test_plain_injective(isl_ctx *ctx, const char *str, int injective)
5426{
5427 isl_union_map *umap;
5428 int test;
5429
5430 umap = isl_union_map_read_from_str(ctx, str);
5431 test = isl_union_map_plain_is_injective(umap);
5432 isl_union_map_free(umap);
5433 if (test < 0)
5434 return -1;
5435 if (test == injective)
5436 return 0;
5437 if (injective)
5438 isl_die(ctx, isl_error_unknown,
5439 "map not detected as injective", return -1);
5440 else
5441 isl_die(ctx, isl_error_unknown,
5442 "map detected as injective", return -1);
5443}
5444
5445int test_injective(isl_ctx *ctx)
5446{
5447 const char *str;
5448
5449 if (test_plain_injective(ctx, str: "{S[i,j] -> A[0]; T[i,j] -> B[1]}", injective: 0))
5450 return -1;
5451 if (test_plain_injective(ctx, str: "{S[] -> A[0]; T[] -> B[0]}", injective: 1))
5452 return -1;
5453 if (test_plain_injective(ctx, str: "{S[] -> A[0]; T[] -> A[1]}", injective: 1))
5454 return -1;
5455 if (test_plain_injective(ctx, str: "{S[] -> A[0]; T[] -> A[0]}", injective: 0))
5456 return -1;
5457 if (test_plain_injective(ctx, str: "{S[i] -> A[i,0]; T[i] -> A[i,1]}", injective: 1))
5458 return -1;
5459 if (test_plain_injective(ctx, str: "{S[i] -> A[i]; T[i] -> A[i]}", injective: 0))
5460 return -1;
5461 if (test_plain_injective(ctx, str: "{S[] -> A[0,0]; T[] -> A[0,1]}", injective: 1))
5462 return -1;
5463 if (test_plain_injective(ctx, str: "{S[] -> A[0,0]; T[] -> A[1,0]}", injective: 1))
5464 return -1;
5465
5466 str = "{S[] -> A[0,0]; T[] -> A[0,1]; U[] -> A[1,0]}";
5467 if (test_plain_injective(ctx, str, injective: 1))
5468 return -1;
5469 str = "{S[] -> A[0,0]; T[] -> A[0,1]; U[] -> A[0,0]}";
5470 if (test_plain_injective(ctx, str, injective: 0))
5471 return -1;
5472
5473 return 0;
5474}
5475
5476#undef BASE
5477#define BASE aff
5478#include "isl_test_plain_equal_templ.c"
5479
5480#undef BASE
5481#define BASE pw_multi_aff
5482#include "isl_test_plain_equal_templ.c"
5483
5484#undef BASE
5485#define BASE union_pw_aff
5486#include "isl_test_plain_equal_templ.c"
5487
5488/* Basic tests on isl_union_pw_aff.
5489 *
5490 * In particular, check that isl_union_pw_aff_aff_on_domain
5491 * aligns the parameters of the input objects and
5492 * that isl_union_pw_aff_param_on_domain_id properly
5493 * introduces the parameter.
5494 */
5495static int test_upa(isl_ctx *ctx)
5496{
5497 const char *str;
5498 isl_id *id;
5499 isl_aff *aff;
5500 isl_union_set *domain;
5501 isl_union_pw_aff *upa;
5502 isl_stat ok;
5503
5504 aff = isl_aff_read_from_str(ctx, str: "[N] -> { [N] }");
5505 str = "[M] -> { A[i] : 0 <= i < M; B[] }";
5506 domain = isl_union_set_read_from_str(ctx, str);
5507 upa = isl_union_pw_aff_aff_on_domain(domain, aff);
5508 str = "[N, M] -> { A[i] -> [N] : 0 <= i < M; B[] -> [N] }";
5509 ok = union_pw_aff_check_plain_equal(obj: upa, str);
5510 isl_union_pw_aff_free(upa);
5511 if (ok < 0)
5512 return -1;
5513
5514 id = isl_id_alloc(ctx, name: "N", NULL);
5515 str = "[M] -> { A[i] : 0 <= i < M; B[] }";
5516 domain = isl_union_set_read_from_str(ctx, str);
5517 upa = isl_union_pw_aff_param_on_domain_id(domain, id);
5518 str = "[N, M] -> { A[i] -> [N] : 0 <= i < M; B[] -> [N] }";
5519 ok = union_pw_aff_check_plain_equal(obj: upa, str);
5520 isl_union_pw_aff_free(upa);
5521 if (ok < 0)
5522 return -1;
5523
5524 return 0;
5525}
5526
5527struct {
5528 __isl_give isl_aff *(*fn)(__isl_take isl_aff *aff1,
5529 __isl_take isl_aff *aff2);
5530} aff_bin_op[] = {
5531 ['+'] = { &isl_aff_add },
5532 ['-'] = { .fn: &isl_aff_sub },
5533 ['*'] = { .fn: &isl_aff_mul },
5534 ['/'] = { .fn: &isl_aff_div },
5535};
5536
5537struct {
5538 const char *arg1;
5539 unsigned char op;
5540 const char *arg2;
5541 const char *res;
5542} aff_bin_tests[] = {
5543 { "{ [i] -> [i] }", '+', "{ [i] -> [i] }",
5544 "{ [i] -> [2i] }" },
5545 { "{ [i] -> [i] }", '-', "{ [i] -> [i] }",
5546 "{ [i] -> [0] }" },
5547 { "{ [i] -> [i] }", '*', "{ [i] -> [2] }",
5548 "{ [i] -> [2i] }" },
5549 { "{ [i] -> [2] }", '*', "{ [i] -> [i] }",
5550 "{ [i] -> [2i] }" },
5551 { "{ [i] -> [i] }", '/', "{ [i] -> [2] }",
5552 "{ [i] -> [i/2] }" },
5553 { "{ [i] -> [2i] }", '/', "{ [i] -> [2] }",
5554 "{ [i] -> [i] }" },
5555 { "{ [i] -> [i] }", '+', "{ [i] -> [NaN] }",
5556 "{ [i] -> [NaN] }" },
5557 { "{ [i] -> [i] }", '-', "{ [i] -> [NaN] }",
5558 "{ [i] -> [NaN] }" },
5559 { "{ [i] -> [i] }", '*', "{ [i] -> [NaN] }",
5560 "{ [i] -> [NaN] }" },
5561 { "{ [i] -> [2] }", '*', "{ [i] -> [NaN] }",
5562 "{ [i] -> [NaN] }" },
5563 { "{ [i] -> [i] }", '/', "{ [i] -> [NaN] }",
5564 "{ [i] -> [NaN] }" },
5565 { "{ [i] -> [2] }", '/', "{ [i] -> [NaN] }",
5566 "{ [i] -> [NaN] }" },
5567 { "{ [i] -> [NaN] }", '+', "{ [i] -> [i] }",
5568 "{ [i] -> [NaN] }" },
5569 { "{ [i] -> [NaN] }", '-', "{ [i] -> [i] }",
5570 "{ [i] -> [NaN] }" },
5571 { "{ [i] -> [NaN] }", '*', "{ [i] -> [2] }",
5572 "{ [i] -> [NaN] }" },
5573 { "{ [i] -> [NaN] }", '*', "{ [i] -> [i] }",
5574 "{ [i] -> [NaN] }" },
5575 { "{ [i] -> [NaN] }", '/', "{ [i] -> [2] }",
5576 "{ [i] -> [NaN] }" },
5577 { "{ [i] -> [NaN] }", '/', "{ [i] -> [i] }",
5578 "{ [i] -> [NaN] }" },
5579 { "{ [i] -> [i] }", '/', "{ [i] -> [0] }",
5580 "{ [i] -> [NaN] }" },
5581};
5582
5583/* Perform some basic tests of binary operations on isl_aff objects.
5584 */
5585static int test_bin_aff(isl_ctx *ctx)
5586{
5587 int i;
5588 isl_aff *aff1, *aff2, *res;
5589 __isl_give isl_aff *(*fn)(__isl_take isl_aff *aff1,
5590 __isl_take isl_aff *aff2);
5591 int ok;
5592
5593 for (i = 0; i < ARRAY_SIZE(aff_bin_tests); ++i) {
5594 aff1 = isl_aff_read_from_str(ctx, str: aff_bin_tests[i].arg1);
5595 aff2 = isl_aff_read_from_str(ctx, str: aff_bin_tests[i].arg2);
5596 res = isl_aff_read_from_str(ctx, str: aff_bin_tests[i].res);
5597 fn = aff_bin_op[aff_bin_tests[i].op].fn;
5598 aff1 = fn(aff1, aff2);
5599 if (isl_aff_is_nan(aff: res))
5600 ok = isl_aff_is_nan(aff: aff1);
5601 else
5602 ok = isl_aff_plain_is_equal(aff1, aff2: res);
5603 isl_aff_free(aff: aff1);
5604 isl_aff_free(aff: res);
5605 if (ok < 0)
5606 return -1;
5607 if (!ok)
5608 isl_die(ctx, isl_error_unknown,
5609 "unexpected result", return -1);
5610 }
5611
5612 return 0;
5613}
5614
5615struct {
5616 __isl_give isl_pw_aff *(*fn)(__isl_take isl_pw_aff *pa1,
5617 __isl_take isl_pw_aff *pa2);
5618} pw_aff_bin_op[] = {
5619 ['m'] = { &isl_pw_aff_min },
5620 ['M'] = { .fn: &isl_pw_aff_max },
5621};
5622
5623/* Inputs for binary isl_pw_aff operation tests.
5624 * "arg1" and "arg2" are the two arguments, "op" identifies the operation
5625 * defined by pw_aff_bin_op, and "res" is the expected result.
5626 */
5627struct {
5628 const char *arg1;
5629 unsigned char op;
5630 const char *arg2;
5631 const char *res;
5632} pw_aff_bin_tests[] = {
5633 { "{ [i] -> [i] }", 'm', "{ [i] -> [i] }",
5634 "{ [i] -> [i] }" },
5635 { "{ [i] -> [i] }", 'M', "{ [i] -> [i] }",
5636 "{ [i] -> [i] }" },
5637 { "{ [i] -> [i] }", 'm', "{ [i] -> [0] }",
5638 "{ [i] -> [i] : i <= 0; [i] -> [0] : i > 0 }" },
5639 { "{ [i] -> [i] }", 'M', "{ [i] -> [0] }",
5640 "{ [i] -> [i] : i >= 0; [i] -> [0] : i < 0 }" },
5641 { "{ [i] -> [i] }", 'm', "{ [i] -> [NaN] }",
5642 "{ [i] -> [NaN] }" },
5643 { "{ [i] -> [NaN] }", 'm', "{ [i] -> [i] }",
5644 "{ [i] -> [NaN] }" },
5645};
5646
5647/* Perform some basic tests of binary operations on isl_pw_aff objects.
5648 */
5649static int test_bin_pw_aff(isl_ctx *ctx)
5650{
5651 int i;
5652 isl_bool ok;
5653 isl_pw_aff *pa1, *pa2, *res;
5654
5655 for (i = 0; i < ARRAY_SIZE(pw_aff_bin_tests); ++i) {
5656 pa1 = isl_pw_aff_read_from_str(ctx, str: pw_aff_bin_tests[i].arg1);
5657 pa2 = isl_pw_aff_read_from_str(ctx, str: pw_aff_bin_tests[i].arg2);
5658 res = isl_pw_aff_read_from_str(ctx, str: pw_aff_bin_tests[i].res);
5659 pa1 = pw_aff_bin_op[pw_aff_bin_tests[i].op].fn(pa1, pa2);
5660 if (isl_pw_aff_involves_nan(pa: res))
5661 ok = isl_pw_aff_involves_nan(pa: pa1);
5662 else
5663 ok = isl_pw_aff_plain_is_equal(pwaff1: pa1, pwaff2: res);
5664 isl_pw_aff_free(pwaff: pa1);
5665 isl_pw_aff_free(pwaff: res);
5666 if (ok < 0)
5667 return -1;
5668 if (!ok)
5669 isl_die(ctx, isl_error_unknown,
5670 "unexpected result", return -1);
5671 }
5672
5673 return 0;
5674}
5675
5676/* Inputs for basic tests of test operations on
5677 * isl_union_pw_multi_aff objects.
5678 * "fn" is the function that is being tested.
5679 * "arg" is a string description of the input.
5680 * "res" is the expected result.
5681 */
5682static struct {
5683 isl_bool (*fn)(__isl_keep isl_union_pw_multi_aff *upma1);
5684 const char *arg;
5685 isl_bool res;
5686} upma_test_tests[] = {
5687 { &isl_union_pw_multi_aff_involves_nan, "{ A[] -> [0]; B[0] -> [1] }",
5688 isl_bool_false },
5689 { &isl_union_pw_multi_aff_involves_nan, "{ A[] -> [NaN]; B[0] -> [1] }",
5690 isl_bool_true },
5691 { &isl_union_pw_multi_aff_involves_nan, "{ A[] -> [0]; B[0] -> [NaN] }",
5692 isl_bool_true },
5693 { &isl_union_pw_multi_aff_involves_nan,
5694 "{ A[] -> [0]; B[0] -> [1, NaN, 5] }",
5695 isl_bool_true },
5696 { &isl_union_pw_multi_aff_involves_locals,
5697 "{ A[] -> [0]; B[0] -> [1] }",
5698 isl_bool_false },
5699 { &isl_union_pw_multi_aff_involves_locals,
5700 "{ A[] -> [0]; B[x] -> [1] : x mod 2 = 0 }",
5701 isl_bool_true },
5702 { &isl_union_pw_multi_aff_involves_locals,
5703 "{ A[] -> [0]; B[x] -> [x // 2] }",
5704 isl_bool_true },
5705 { &isl_union_pw_multi_aff_involves_locals,
5706 "{ A[i] -> [i // 2]; B[0] -> [1] }",
5707 isl_bool_true },
5708};
5709
5710/* Perform some basic tests of test operations on
5711 * isl_union_pw_multi_aff objects.
5712 */
5713static isl_stat test_upma_test(isl_ctx *ctx)
5714{
5715 int i;
5716 isl_union_pw_multi_aff *upma;
5717 isl_bool res;
5718
5719 for (i = 0; i < ARRAY_SIZE(upma_test_tests); ++i) {
5720 const char *str;
5721
5722 str = upma_test_tests[i].arg;
5723 upma = isl_union_pw_multi_aff_read_from_str(ctx, str);
5724 res = upma_test_tests[i].fn(upma);
5725 isl_union_pw_multi_aff_free(upma);
5726 if (res < 0)
5727 return isl_stat_error;
5728 if (res != upma_test_tests[i].res)
5729 isl_die(ctx, isl_error_unknown,
5730 "unexpected result", return isl_stat_error);
5731 }
5732
5733 return isl_stat_ok;
5734}
5735
5736struct {
5737 __isl_give isl_union_pw_multi_aff *(*fn)(
5738 __isl_take isl_union_pw_multi_aff *upma1,
5739 __isl_take isl_union_pw_multi_aff *upma2);
5740 const char *arg1;
5741 const char *arg2;
5742 const char *res;
5743} upma_bin_tests[] = {
5744 { &isl_union_pw_multi_aff_add, "{ A[] -> [0]; B[0] -> [1] }",
5745 "{ B[x] -> [2] : x >= 0 }", "{ B[0] -> [3] }" },
5746 { &isl_union_pw_multi_aff_union_add, "{ A[] -> [0]; B[0] -> [1] }",
5747 "{ B[x] -> [2] : x >= 0 }",
5748 "{ A[] -> [0]; B[0] -> [3]; B[x] -> [2] : x >= 1 }" },
5749 { &isl_union_pw_multi_aff_pullback_union_pw_multi_aff,
5750 "{ A[] -> B[0]; C[x] -> B[1] : x < 10; C[y] -> B[2] : y >= 10 }",
5751 "{ D[i] -> A[] : i < 0; D[i] -> C[i + 5] : i >= 0 }",
5752 "{ D[i] -> B[0] : i < 0; D[i] -> B[1] : 0 <= i < 5; "
5753 "D[i] -> B[2] : i >= 5 }" },
5754 { &isl_union_pw_multi_aff_union_add, "{ B[x] -> A[1] : x <= 0 }",
5755 "{ B[x] -> C[2] : x > 0 }",
5756 "{ B[x] -> A[1] : x <= 0; B[x] -> C[2] : x > 0 }" },
5757 { &isl_union_pw_multi_aff_union_add, "{ B[x] -> A[1] : x <= 0 }",
5758 "{ B[x] -> A[2] : x >= 0 }",
5759 "{ B[x] -> A[1] : x < 0; B[x] -> A[2] : x > 0; B[0] -> A[3] }" },
5760 {
5761 &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
5762 "{ B[x] -> C[x + 2] }",
5763 "{ D[y] -> B[2y] }",
5764 "{ }" },
5765 {
5766 &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
5767 "{ [A[x] -> B[x + 1]] -> C[x + 2] }",
5768 "{ D[y] -> B[2y] }",
5769 "{ }" },
5770 {
5771 &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
5772 "{ [A[x] -> B[x + 1]] -> C[x + 2]; B[x] -> C[x + 2] }",
5773 "{ D[y] -> A[2y] }",
5774 "{ [D[y] -> B[2y + 1]] -> C[2y + 2] }" },
5775 {
5776 &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
5777 "{ T[A[x] -> B[x + 1]] -> C[x + 2]; B[x] -> C[x + 2] }",
5778 "{ D[y] -> A[2y] }",
5779 "{ T[D[y] -> B[2y + 1]] -> C[2y + 2] }" },
5780};
5781
5782/* Perform some basic tests of binary operations on
5783 * isl_union_pw_multi_aff objects.
5784 */
5785static int test_bin_upma(isl_ctx *ctx)
5786{
5787 int i;
5788 isl_union_pw_multi_aff *upma1, *upma2, *res;
5789 int ok;
5790
5791 for (i = 0; i < ARRAY_SIZE(upma_bin_tests); ++i) {
5792 upma1 = isl_union_pw_multi_aff_read_from_str(ctx,
5793 str: upma_bin_tests[i].arg1);
5794 upma2 = isl_union_pw_multi_aff_read_from_str(ctx,
5795 str: upma_bin_tests[i].arg2);
5796 res = isl_union_pw_multi_aff_read_from_str(ctx,
5797 str: upma_bin_tests[i].res);
5798 upma1 = upma_bin_tests[i].fn(upma1, upma2);
5799 ok = isl_union_pw_multi_aff_plain_is_equal(upma1, upma2: res);
5800 isl_union_pw_multi_aff_free(upma: upma1);
5801 isl_union_pw_multi_aff_free(upma: res);
5802 if (ok < 0)
5803 return -1;
5804 if (!ok)
5805 isl_die(ctx, isl_error_unknown,
5806 "unexpected result", return -1);
5807 }
5808
5809 return 0;
5810}
5811
5812struct {
5813 __isl_give isl_union_pw_multi_aff *(*fn)(
5814 __isl_take isl_union_pw_multi_aff *upma1,
5815 __isl_take isl_union_pw_multi_aff *upma2);
5816 const char *arg1;
5817 const char *arg2;
5818} upma_bin_fail_tests[] = {
5819 { &isl_union_pw_multi_aff_union_add, "{ B[x] -> A[1] : x <= 0 }",
5820 "{ B[x] -> C[2] : x >= 0 }" },
5821};
5822
5823/* Perform some basic tests of binary operations on
5824 * isl_union_pw_multi_aff objects that are expected to fail.
5825 */
5826static int test_bin_upma_fail(isl_ctx *ctx)
5827{
5828 int i, n;
5829 isl_union_pw_multi_aff *upma1, *upma2;
5830 int on_error;
5831
5832 on_error = isl_options_get_on_error(ctx);
5833 isl_options_set_on_error(ctx, ISL_ON_ERROR_CONTINUE);
5834 n = ARRAY_SIZE(upma_bin_fail_tests);
5835 for (i = 0; i < n; ++i) {
5836 upma1 = isl_union_pw_multi_aff_read_from_str(ctx,
5837 str: upma_bin_fail_tests[i].arg1);
5838 upma2 = isl_union_pw_multi_aff_read_from_str(ctx,
5839 str: upma_bin_fail_tests[i].arg2);
5840 upma1 = upma_bin_fail_tests[i].fn(upma1, upma2);
5841 isl_union_pw_multi_aff_free(upma: upma1);
5842 if (upma1)
5843 break;
5844 }
5845 isl_options_set_on_error(ctx, val: on_error);
5846 if (i < n)
5847 isl_die(ctx, isl_error_unknown,
5848 "operation not expected to succeed", return -1);
5849
5850 return 0;
5851}
5852
5853/* Inputs for basic tests of binary operations on
5854 * pairs of isl_union_pw_multi_aff and isl_union_set objects.
5855 * "fn" is the function that is being tested.
5856 * "arg1" and "arg2" are string descriptions of the inputs.
5857 * "res" is a string description of the expected result.
5858 */
5859struct {
5860 __isl_give isl_union_pw_multi_aff *(*fn)(
5861 __isl_take isl_union_pw_multi_aff *upma,
5862 __isl_take isl_union_set *uset);
5863 const char *arg1;
5864 const char *arg2;
5865 const char *res;
5866} upma_uset_tests[] = {
5867 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5868 "{ A[i] -> B[i] }", "{ B[0] }",
5869 "{ }" },
5870 { &isl_union_pw_multi_aff_intersect_domain_wrapped_domain,
5871 "{ [A[i] -> B[i]] -> C[i + 1] }", "{ A[1]; B[0] }",
5872 "{ [A[1] -> B[1]] -> C[2] }" },
5873 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5874 "{ [A[i] -> B[i]] -> C[i + 1] }", "{ A[1]; B[0] }",
5875 "{ [A[0] -> B[0]] -> C[1] }" },
5876 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5877 "{ [A[i] -> B[i]] -> C[i + 1] }", "[N] -> { B[N] }",
5878 "[N] -> { [A[N] -> B[N]] -> C[N + 1] }" },
5879 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5880 "[M] -> { [A[M] -> B[M]] -> C[M + 1] }", "[N] -> { B[N] }",
5881 "[N, M] -> { [A[N] -> B[N]] -> C[N + 1] : N = M }" },
5882 { &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
5883 "{ [A[] -> B[]] -> C[]; N[A[] -> B[]] -> D[]; [B[] -> A[]] -> E[] }",
5884 "{ B[] }",
5885 "{ [A[] -> B[]] -> C[]; N[A[] -> B[]] -> D[] }" },
5886};
5887
5888/* Perform some basic tests of binary operations on
5889 * pairs of isl_union_pw_multi_aff and isl_union_set objects.
5890 */
5891static isl_stat test_upma_uset(isl_ctx *ctx)
5892{
5893 int i;
5894 isl_bool ok;
5895 isl_union_pw_multi_aff *upma, *res;
5896 isl_union_set *uset;
5897
5898 for (i = 0; i < ARRAY_SIZE(upma_uset_tests); ++i) {
5899 upma = isl_union_pw_multi_aff_read_from_str(ctx,
5900 str: upma_uset_tests[i].arg1);
5901 uset = isl_union_set_read_from_str(ctx,
5902 str: upma_uset_tests[i].arg2);
5903 res = isl_union_pw_multi_aff_read_from_str(ctx,
5904 str: upma_uset_tests[i].res);
5905 upma = upma_uset_tests[i].fn(upma, uset);
5906 ok = isl_union_pw_multi_aff_plain_is_equal(upma1: upma, upma2: res);
5907 isl_union_pw_multi_aff_free(upma);
5908 isl_union_pw_multi_aff_free(upma: res);
5909 if (ok < 0)
5910 return isl_stat_error;
5911 if (!ok)
5912 isl_die(ctx, isl_error_unknown,
5913 "unexpected result", return isl_stat_error);
5914 }
5915
5916 return isl_stat_ok;
5917}
5918
5919/* Inputs for basic tests of unary operations on isl_multi_pw_aff objects.
5920 * "fn" is the function that is tested.
5921 * "arg" is a string description of the input.
5922 * "res" is a string description of the expected result.
5923 */
5924struct {
5925 __isl_give isl_multi_pw_aff *(*fn)(__isl_take isl_multi_pw_aff *mpa);
5926 const char *arg;
5927 const char *res;
5928} mpa_un_tests[] = {
5929 { &isl_multi_pw_aff_range_factor_domain,
5930 "{ A[x] -> [B[(1 : x >= 5)] -> C[(2 : x <= 10)]] }",
5931 "{ A[x] -> B[(1 : x >= 5)] }" },
5932 { &isl_multi_pw_aff_range_factor_range,
5933 "{ A[x] -> [B[(1 : x >= 5)] -> C[(2 : x <= 10)]] }",
5934 "{ A[y] -> C[(2 : y <= 10)] }" },
5935 { &isl_multi_pw_aff_range_factor_domain,
5936 "{ A[x] -> [B[(1 : x >= 5)] -> C[]] }",
5937 "{ A[x] -> B[(1 : x >= 5)] }" },
5938 { &isl_multi_pw_aff_range_factor_range,
5939 "{ A[x] -> [B[(1 : x >= 5)] -> C[]] }",
5940 "{ A[y] -> C[] }" },
5941 { &isl_multi_pw_aff_range_factor_domain,
5942 "{ A[x] -> [B[] -> C[(2 : x <= 10)]] }",
5943 "{ A[x] -> B[] }" },
5944 { &isl_multi_pw_aff_range_factor_range,
5945 "{ A[x] -> [B[] -> C[(2 : x <= 10)]] }",
5946 "{ A[y] -> C[(2 : y <= 10)] }" },
5947 { &isl_multi_pw_aff_range_factor_domain,
5948 "{ A[x] -> [B[] -> C[]] }",
5949 "{ A[x] -> B[] }" },
5950 { &isl_multi_pw_aff_range_factor_range,
5951 "{ A[x] -> [B[] -> C[]] }",
5952 "{ A[y] -> C[] }" },
5953 { &isl_multi_pw_aff_factor_range,
5954 "{ [B[] -> C[]] }",
5955 "{ C[] }" },
5956 { &isl_multi_pw_aff_range_factor_domain,
5957 "{ A[x] -> [B[] -> C[]] : x >= 0 }",
5958 "{ A[x] -> B[] : x >= 0 }" },
5959 { &isl_multi_pw_aff_range_factor_range,
5960 "{ A[x] -> [B[] -> C[]] : x >= 0 }",
5961 "{ A[y] -> C[] : y >= 0 }" },
5962 { &isl_multi_pw_aff_factor_range,
5963 "[N] -> { [B[] -> C[]] : N >= 0 }",
5964 "[N] -> { C[] : N >= 0 }" },
5965};
5966
5967/* Perform some basic tests of unary operations on isl_multi_pw_aff objects.
5968 */
5969static int test_un_mpa(isl_ctx *ctx)
5970{
5971 int i;
5972 isl_bool ok;
5973 isl_multi_pw_aff *mpa, *res;
5974
5975 for (i = 0; i < ARRAY_SIZE(mpa_un_tests); ++i) {
5976 mpa = isl_multi_pw_aff_read_from_str(ctx, str: mpa_un_tests[i].arg);
5977 res = isl_multi_pw_aff_read_from_str(ctx, str: mpa_un_tests[i].res);
5978 mpa = mpa_un_tests[i].fn(mpa);
5979 ok = isl_multi_pw_aff_plain_is_equal(multi1: mpa, multi2: res);
5980 isl_multi_pw_aff_free(multi: mpa);
5981 isl_multi_pw_aff_free(multi: res);
5982 if (ok < 0)
5983 return -1;
5984 if (!ok)
5985 isl_die(ctx, isl_error_unknown,
5986 "unexpected result", return -1);
5987 }
5988
5989 return 0;
5990}
5991
5992/* Inputs for basic tests of binary operations on isl_multi_pw_aff objects.
5993 * "fn" is the function that is tested.
5994 * "arg1" and "arg2" are string descriptions of the inputs.
5995 * "res" is a string description of the expected result.
5996 */
5997struct {
5998 __isl_give isl_multi_pw_aff *(*fn)(
5999 __isl_take isl_multi_pw_aff *mpa1,
6000 __isl_take isl_multi_pw_aff *mpa2);
6001 const char *arg1;
6002 const char *arg2;
6003 const char *res;
6004} mpa_bin_tests[] = {
6005 { &isl_multi_pw_aff_add, "{ A[] -> [1] }", "{ A[] -> [2] }",
6006 "{ A[] -> [3] }" },
6007 { &isl_multi_pw_aff_add, "{ A[x] -> [(1 : x >= 5)] }",
6008 "{ A[x] -> [(x : x <= 10)] }",
6009 "{ A[x] -> [(1 + x : 5 <= x <= 10)] }" },
6010 { &isl_multi_pw_aff_add, "{ A[x] -> [] : x >= 5 }",
6011 "{ A[x] -> [] : x <= 10 }",
6012 "{ A[x] -> [] : 5 <= x <= 10 }" },
6013 { &isl_multi_pw_aff_add, "{ A[x] -> [] : x >= 5 }",
6014 "[N] -> { A[x] -> [] : x <= N }",
6015 "[N] -> { A[x] -> [] : 5 <= x <= N }" },
6016 { &isl_multi_pw_aff_add,
6017 "[N] -> { A[x] -> [] : x <= N }",
6018 "{ A[x] -> [] : x >= 5 }",
6019 "[N] -> { A[x] -> [] : 5 <= x <= N }" },
6020 { &isl_multi_pw_aff_range_product, "{ A[x] -> B[(1 : x >= 5)] }",
6021 "{ A[y] -> C[(2 : y <= 10)] }",
6022 "{ A[x] -> [B[(1 : x >= 5)] -> C[(2 : x <= 10)]] }" },
6023 { &isl_multi_pw_aff_range_product, "{ A[x] -> B[1] : x >= 5 }",
6024 "{ A[y] -> C[2] : y <= 10 }",
6025 "{ A[x] -> [B[(1 : x >= 5)] -> C[(2 : x <= 10)]] }" },
6026 { &isl_multi_pw_aff_range_product, "{ A[x] -> B[1] : x >= 5 }",
6027 "[N] -> { A[y] -> C[2] : y <= N }",
6028 "[N] -> { A[x] -> [B[(1 : x >= 5)] -> C[(2 : x <= N)]] }" },
6029 { &isl_multi_pw_aff_range_product, "[N] -> { A[x] -> B[1] : x >= N }",
6030 "{ A[y] -> C[2] : y <= 10 }",
6031 "[N] -> { A[x] -> [B[(1 : x >= N)] -> C[(2 : x <= 10)]] }" },
6032 { &isl_multi_pw_aff_range_product, "{ A[] -> B[1] }", "{ A[] -> C[2] }",
6033 "{ A[] -> [B[1] -> C[2]] }" },
6034 { &isl_multi_pw_aff_range_product, "{ A[] -> B[] }", "{ A[] -> C[] }",
6035 "{ A[] -> [B[] -> C[]] }" },
6036 { &isl_multi_pw_aff_range_product, "{ A[x] -> B[(1 : x >= 5)] }",
6037 "{ A[y] -> C[] : y <= 10 }",
6038 "{ A[x] -> [B[(1 : x >= 5)] -> C[]] : x <= 10 }" },
6039 { &isl_multi_pw_aff_range_product, "{ A[y] -> C[] : y <= 10 }",
6040 "{ A[x] -> B[(1 : x >= 5)] }",
6041 "{ A[x] -> [C[] -> B[(1 : x >= 5)]] : x <= 10 }" },
6042 { &isl_multi_pw_aff_product, "{ A[x] -> B[(1 : x >= 5)] }",
6043 "{ A[y] -> C[(2 : y <= 10)] }",
6044 "{ [A[x] -> A[y]] -> [B[(1 : x >= 5)] -> C[(2 : y <= 10)]] }" },
6045 { &isl_multi_pw_aff_product, "{ A[x] -> B[(1 : x >= 5)] }",
6046 "{ A[y] -> C[] : y <= 10 }",
6047 "{ [A[x] -> A[y]] -> [B[(1 : x >= 5)] -> C[]] : y <= 10 }" },
6048 { &isl_multi_pw_aff_product, "{ A[y] -> C[] : y <= 10 }",
6049 "{ A[x] -> B[(1 : x >= 5)] }",
6050 "{ [A[y] -> A[x]] -> [C[] -> B[(1 : x >= 5)]] : y <= 10 }" },
6051 { &isl_multi_pw_aff_product, "{ A[x] -> B[(1 : x >= 5)] }",
6052 "[N] -> { A[y] -> C[] : y <= N }",
6053 "[N] -> { [A[x] -> A[y]] -> [B[(1 : x >= 5)] -> C[]] : y <= N }" },
6054 { &isl_multi_pw_aff_product, "[N] -> { A[y] -> C[] : y <= N }",
6055 "{ A[x] -> B[(1 : x >= 5)] }",
6056 "[N] -> { [A[y] -> A[x]] -> [C[] -> B[(1 : x >= 5)]] : y <= N }" },
6057 { &isl_multi_pw_aff_product, "{ A[x] -> B[] : x >= 5 }",
6058 "{ A[y] -> C[] : y <= 10 }",
6059 "{ [A[x] -> A[y]] -> [B[] -> C[]] : x >= 5 and y <= 10 }" },
6060 { &isl_multi_pw_aff_product, "{ A[] -> B[1] }", "{ A[] -> C[2] }",
6061 "{ [A[] -> A[]] -> [B[1] -> C[2]] }" },
6062 { &isl_multi_pw_aff_product, "{ A[] -> B[] }", "{ A[] -> C[] }",
6063 "{ [A[] -> A[]] -> [B[] -> C[]] }" },
6064 { &isl_multi_pw_aff_pullback_multi_pw_aff,
6065 "{ B[i,j] -> C[i + 2j] }", "{ A[a,b] -> B[b,a] }",
6066 "{ A[a,b] -> C[b + 2a] }" },
6067 { &isl_multi_pw_aff_pullback_multi_pw_aff,
6068 "{ B[i,j] -> C[i + 2j] }",
6069 "{ A[a,b] -> B[(b : b > a),(a : b > a)] }",
6070 "{ A[a,b] -> C[(b + 2a : b > a)] }" },
6071 { &isl_multi_pw_aff_pullback_multi_pw_aff,
6072 "{ B[i,j] -> C[(i + 2j : j > 4)] }",
6073 "{ A[a,b] -> B[(b : b > a),(a : b > a)] }",
6074 "{ A[a,b] -> C[(b + 2a : b > a > 4)] }" },
6075 { &isl_multi_pw_aff_pullback_multi_pw_aff,
6076 "{ B[i,j] -> C[] }",
6077 "{ A[a,b] -> B[(b : b > a),(a : b > a)] }",
6078 "{ A[a,b] -> C[] }" },
6079 { &isl_multi_pw_aff_pullback_multi_pw_aff,
6080 "{ B[i,j] -> C[] : i > j }",
6081 "{ A[a,b] -> B[b,a] }",
6082 "{ A[a,b] -> C[] : b > a }" },
6083 { &isl_multi_pw_aff_pullback_multi_pw_aff,
6084 "{ B[i,j] -> C[] : j > 5 }",
6085 "{ A[a,b] -> B[(b : b > a),(a : b > a)] }",
6086 "{ A[a,b] -> C[] : b > a > 5 }" },
6087 { &isl_multi_pw_aff_pullback_multi_pw_aff,
6088 "[N] -> { B[i,j] -> C[] : j > N }",
6089 "{ A[a,b] -> B[(b : b > a),(a : b > a)] }",
6090 "[N] -> { A[a,b] -> C[] : b > a > N }" },
6091 { &isl_multi_pw_aff_pullback_multi_pw_aff,
6092 "[M,N] -> { B[] -> C[] : N > 5 }",
6093 "[M,N] -> { A[] -> B[] : M > N }",
6094 "[M,N] -> { A[] -> C[] : M > N > 5 }" },
6095};
6096
6097/* Perform some basic tests of binary operations on isl_multi_pw_aff objects.
6098 */
6099static int test_bin_mpa(isl_ctx *ctx)
6100{
6101 int i;
6102 isl_bool ok;
6103 isl_multi_pw_aff *mpa1, *mpa2, *res;
6104
6105 for (i = 0; i < ARRAY_SIZE(mpa_bin_tests); ++i) {
6106 mpa1 = isl_multi_pw_aff_read_from_str(ctx,
6107 str: mpa_bin_tests[i].arg1);
6108 mpa2 = isl_multi_pw_aff_read_from_str(ctx,
6109 str: mpa_bin_tests[i].arg2);
6110 res = isl_multi_pw_aff_read_from_str(ctx,
6111 str: mpa_bin_tests[i].res);
6112 mpa1 = mpa_bin_tests[i].fn(mpa1, mpa2);
6113 ok = isl_multi_pw_aff_plain_is_equal(multi1: mpa1, multi2: res);
6114 isl_multi_pw_aff_free(multi: mpa1);
6115 isl_multi_pw_aff_free(multi: res);
6116 if (ok < 0)
6117 return -1;
6118 if (!ok)
6119 isl_die(ctx, isl_error_unknown,
6120 "unexpected result", return -1);
6121 }
6122
6123 return 0;
6124}
6125
6126/* Inputs for basic tests of unary operations on
6127 * isl_multi_union_pw_aff objects.
6128 * "fn" is the function that is tested.
6129 * "arg" is a string description of the input.
6130 * "res" is a string description of the expected result.
6131 */
6132struct {
6133 __isl_give isl_multi_union_pw_aff *(*fn)(
6134 __isl_take isl_multi_union_pw_aff *mupa);
6135 const char *arg;
6136 const char *res;
6137} mupa_un_tests[] = {
6138 { &isl_multi_union_pw_aff_factor_range,
6139 "[B[{ A[] -> [1] }] -> C[{ A[] -> [2] }]]",
6140 "C[{ A[] -> [2] }]" },
6141 { &isl_multi_union_pw_aff_factor_range,
6142 "[B[] -> C[{ A[] -> [2] }]]",
6143 "C[{ A[] -> [2] }]" },
6144 { &isl_multi_union_pw_aff_factor_range,
6145 "[B[{ A[] -> [1] }] -> C[]]",
6146 "C[]" },
6147 { &isl_multi_union_pw_aff_factor_range,
6148 "[B[] -> C[]]",
6149 "C[]" },
6150 { &isl_multi_union_pw_aff_factor_range,
6151 "([B[] -> C[]] : { A[x] : x >= 0 })",
6152 "(C[] : { A[x] : x >= 0 })" },
6153 { &isl_multi_union_pw_aff_factor_range,
6154 "[N] -> ([B[] -> C[]] : { A[x] : x <= N })",
6155 "[N] -> (C[] : { A[x] : x <= N })" },
6156 { &isl_multi_union_pw_aff_factor_range,
6157 "[N] -> ([B[] -> C[]] : { : N >= 0 })",
6158 "[N] -> (C[] : { : N >= 0 })" },
6159};
6160
6161/* Perform some basic tests of unary operations on
6162 * isl_multi_union_pw_aff objects.
6163 */
6164static int test_un_mupa(isl_ctx *ctx)
6165{
6166 int i;
6167 isl_bool ok;
6168 isl_multi_union_pw_aff *mupa, *res;
6169
6170 for (i = 0; i < ARRAY_SIZE(mupa_un_tests); ++i) {
6171 mupa = isl_multi_union_pw_aff_read_from_str(ctx,
6172 str: mupa_un_tests[i].arg);
6173 res = isl_multi_union_pw_aff_read_from_str(ctx,
6174 str: mupa_un_tests[i].res);
6175 mupa = mupa_un_tests[i].fn(mupa);
6176 ok = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa, multi2: res);
6177 isl_multi_union_pw_aff_free(multi: mupa);
6178 isl_multi_union_pw_aff_free(multi: res);
6179 if (ok < 0)
6180 return -1;
6181 if (!ok)
6182 isl_die(ctx, isl_error_unknown,
6183 "unexpected result", return -1);
6184 }
6185
6186 return 0;
6187}
6188
6189/* Inputs for basic tests of binary operations on
6190 * isl_multi_union_pw_aff objects.
6191 * "fn" is the function that is tested.
6192 * "arg1" and "arg2" are string descriptions of the inputs.
6193 * "res" is a string description of the expected result.
6194 */
6195struct {
6196 __isl_give isl_multi_union_pw_aff *(*fn)(
6197 __isl_take isl_multi_union_pw_aff *mupa1,
6198 __isl_take isl_multi_union_pw_aff *mupa2);
6199 const char *arg1;
6200 const char *arg2;
6201 const char *res;
6202} mupa_bin_tests[] = {
6203 { &isl_multi_union_pw_aff_add, "[{ A[] -> [1] }]", "[{ A[] -> [2] }]",
6204 "[{ A[] -> [3] }]" },
6205 { &isl_multi_union_pw_aff_sub, "[{ A[] -> [1] }]", "[{ A[] -> [2] }]",
6206 "[{ A[] -> [-1] }]" },
6207 { &isl_multi_union_pw_aff_add,
6208 "[{ A[] -> [1]; B[] -> [4] }]",
6209 "[{ A[] -> [2]; C[] -> [5] }]",
6210 "[{ A[] -> [3] }]" },
6211 { &isl_multi_union_pw_aff_union_add,
6212 "[{ A[] -> [1]; B[] -> [4] }]",
6213 "[{ A[] -> [2]; C[] -> [5] }]",
6214 "[{ A[] -> [3]; B[] -> [4]; C[] -> [5] }]" },
6215 { &isl_multi_union_pw_aff_add, "[{ A[x] -> [(1)] : x >= 5 }]",
6216 "[{ A[x] -> [(x)] : x <= 10 }]",
6217 "[{ A[x] -> [(1 + x)] : 5 <= x <= 10 }]" },
6218 { &isl_multi_union_pw_aff_add, "([] : { A[x] : x >= 5 })",
6219 "([] : { A[x] : x <= 10 })",
6220 "([] : { A[x] : 5 <= x <= 10 })" },
6221 { &isl_multi_union_pw_aff_add, "([] : { A[x] : x >= 5 })",
6222 "[N] -> ([] : { A[x] : x <= N })",
6223 "[N] -> ([] : { A[x] : 5 <= x <= N })" },
6224 { &isl_multi_union_pw_aff_add, "[N] -> ([] : { A[x] : x >= N })",
6225 "([] : { A[x] : x <= 10 })",
6226 "[N] -> ([] : { A[x] : N <= x <= 10 })" },
6227 { &isl_multi_union_pw_aff_union_add, "[{ A[x] -> [(1)] : x >= 5 }]",
6228 "[{ A[x] -> [(x)] : x <= 10 }]",
6229 "[{ A[x] -> [(1 + x)] : 5 <= x <= 10; "
6230 "A[x] -> [(1)] : x > 10; A[x] -> [(x)] : x < 5 }]" },
6231 { &isl_multi_union_pw_aff_union_add, "([] : { A[x] : x >= 5 })",
6232 "([] : { A[x] : x <= 10 })",
6233 "([] : { A[x] })" },
6234 { &isl_multi_union_pw_aff_union_add, "([] : { A[x] : x >= 0 })",
6235 "[N] -> ([] : { A[x] : x >= N })",
6236 "[N] -> ([] : { A[x] : x >= 0 or x >= N })" },
6237 { &isl_multi_union_pw_aff_union_add,
6238 "[N] -> ([] : { A[] : N >= 0})",
6239 "[N] -> ([] : { A[] : N <= 0})",
6240 "[N] -> ([] : { A[] })" },
6241 { &isl_multi_union_pw_aff_union_add,
6242 "[N] -> ([] : { A[] })",
6243 "[N] -> ([] : { : })",
6244 "[N] -> ([] : { : })" },
6245 { &isl_multi_union_pw_aff_union_add,
6246 "[N] -> ([] : { : })",
6247 "[N] -> ([] : { A[] })",
6248 "[N] -> ([] : { : })" },
6249 { &isl_multi_union_pw_aff_union_add,
6250 "[N] -> ([] : { : N >= 0})",
6251 "[N] -> ([] : { : N <= 0})",
6252 "[N] -> ([] : { : })" },
6253 { &isl_multi_union_pw_aff_range_product,
6254 "B[{ A[] -> [1] }]",
6255 "C[{ A[] -> [2] }]",
6256 "[B[{ A[] -> [1] }] -> C[{ A[] -> [2] }]]" },
6257 { &isl_multi_union_pw_aff_range_product,
6258 "(B[] : { A[x] : x >= 5 })",
6259 "(C[] : { A[x] : x <= 10 })",
6260 "([B[] -> C[]] : { A[x] : 5 <= x <= 10 })" },
6261 { &isl_multi_union_pw_aff_range_product,
6262 "B[{ A[x] -> [x + 1] : x >= 5 }]",
6263 "(C[] : { A[x] : x <= 10 })",
6264 "[B[{ A[x] -> [x + 1] : 5 <= x <= 10 }] -> C[]]" },
6265 { &isl_multi_union_pw_aff_range_product,
6266 "(C[] : { A[x] : x <= 10 })",
6267 "B[{ A[x] -> [x + 1] : x >= 5 }]",
6268 "[C[] -> B[{ A[x] -> [x + 1] : 5 <= x <= 10 }]]" },
6269 { &isl_multi_union_pw_aff_range_product,
6270 "B[{ A[x] -> [x + 1] : x >= 5 }]",
6271 "[N] -> (C[] : { A[x] : x <= N })",
6272 "[N] -> [B[{ A[x] -> [x + 1] : 5 <= x <= N }] -> C[]]" },
6273 { &isl_multi_union_pw_aff_range_product,
6274 "[N] -> (C[] : { A[x] : x <= N })",
6275 "B[{ A[x] -> [x + 1] : x >= 5 }]",
6276 "[N] -> [C[] -> B[{ A[x] -> [x + 1] : 5 <= x <= N }]]" },
6277 { &isl_multi_union_pw_aff_range_product,
6278 "B[{ A[] -> [1]; D[] -> [3] }]",
6279 "C[{ A[] -> [2] }]",
6280 "[B[{ A[] -> [1]; D[] -> [3] }] -> C[{ A[] -> [2] }]]" },
6281 { &isl_multi_union_pw_aff_range_product,
6282 "B[] }]",
6283 "(C[] : { A[x] })",
6284 "([B[] -> C[]] : { A[x] })" },
6285 { &isl_multi_union_pw_aff_range_product,
6286 "(B[] : { A[x] })",
6287 "C[] }]",
6288 "([B[] -> C[]] : { A[x] })" },
6289};
6290
6291/* Perform some basic tests of binary operations on
6292 * isl_multi_union_pw_aff objects.
6293 */
6294static int test_bin_mupa(isl_ctx *ctx)
6295{
6296 int i;
6297 isl_bool ok;
6298 isl_multi_union_pw_aff *mupa1, *mupa2, *res;
6299
6300 for (i = 0; i < ARRAY_SIZE(mupa_bin_tests); ++i) {
6301 mupa1 = isl_multi_union_pw_aff_read_from_str(ctx,
6302 str: mupa_bin_tests[i].arg1);
6303 mupa2 = isl_multi_union_pw_aff_read_from_str(ctx,
6304 str: mupa_bin_tests[i].arg2);
6305 res = isl_multi_union_pw_aff_read_from_str(ctx,
6306 str: mupa_bin_tests[i].res);
6307 mupa1 = mupa_bin_tests[i].fn(mupa1, mupa2);
6308 ok = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa1, multi2: res);
6309 isl_multi_union_pw_aff_free(multi: mupa1);
6310 isl_multi_union_pw_aff_free(multi: res);
6311 if (ok < 0)
6312 return -1;
6313 if (!ok)
6314 isl_die(ctx, isl_error_unknown,
6315 "unexpected result", return -1);
6316 }
6317
6318 return 0;
6319}
6320
6321/* Inputs for basic tests of binary operations on
6322 * pairs of isl_multi_union_pw_aff and isl_set objects.
6323 * "fn" is the function that is tested.
6324 * "arg1" and "arg2" are string descriptions of the inputs.
6325 * "res" is a string description of the expected result.
6326 */
6327struct {
6328 __isl_give isl_multi_union_pw_aff *(*fn)(
6329 __isl_take isl_multi_union_pw_aff *mupa,
6330 __isl_take isl_set *set);
6331 const char *arg1;
6332 const char *arg2;
6333 const char *res;
6334} mupa_set_tests[] = {
6335 { &isl_multi_union_pw_aff_intersect_range,
6336 "C[{ B[i,j] -> [i + 2j] }]", "{ C[1] }",
6337 "C[{ B[i,j] -> [i + 2j] : i + 2j = 1 }]" },
6338 { &isl_multi_union_pw_aff_intersect_range,
6339 "C[{ B[i,j] -> [i + 2j] }]", "[N] -> { C[N] }",
6340 "[N] -> C[{ B[i,j] -> [i + 2j] : i + 2j = N }]" },
6341 { &isl_multi_union_pw_aff_intersect_range,
6342 "[N] -> C[{ B[i,j] -> [i + 2j + N] }]", "{ C[1] }",
6343 "[N] -> C[{ B[i,j] -> [i + 2j + N] : i + 2j + N = 1 }]" },
6344 { &isl_multi_union_pw_aff_intersect_range,
6345 "C[{ B[i,j] -> [i + 2j] }]", "[N] -> { C[x] : N >= 0 }",
6346 "[N] -> C[{ B[i,j] -> [i + 2j] : N >= 0 }]" },
6347 { &isl_multi_union_pw_aff_intersect_range,
6348 "C[]", "{ C[] }", "C[]" },
6349 { &isl_multi_union_pw_aff_intersect_range,
6350 "[N] -> (C[] : { : N >= 0 })",
6351 "{ C[] }",
6352 "[N] -> (C[] : { : N >= 0 })" },
6353 { &isl_multi_union_pw_aff_intersect_range,
6354 "(C[] : { A[a,b] })",
6355 "{ C[] }",
6356 "(C[] : { A[a,b] })" },
6357 { &isl_multi_union_pw_aff_intersect_range,
6358 "[N] -> (C[] : { A[a,b] : a,b <= N })",
6359 "{ C[] }",
6360 "[N] -> (C[] : { A[a,b] : a,b <= N })" },
6361 { &isl_multi_union_pw_aff_intersect_range,
6362 "C[]",
6363 "[N] -> { C[] : N >= 0 }",
6364 "[N] -> (C[] : { : N >= 0 })" },
6365 { &isl_multi_union_pw_aff_intersect_range,
6366 "(C[] : { A[a,b] })",
6367 "[N] -> { C[] : N >= 0 }",
6368 "[N] -> (C[] : { A[a,b] : N >= 0 })" },
6369 { &isl_multi_union_pw_aff_intersect_range,
6370 "[N] -> (C[] : { : N >= 0 })",
6371 "[N] -> { C[] : N < 1024 }",
6372 "[N] -> (C[] : { : 0 <= N < 1024 })" },
6373 { &isl_multi_union_pw_aff_intersect_params,
6374 "C[{ B[i,j] -> [i + 2j] }]", "[N] -> { : N >= 0 }",
6375 "[N] -> C[{ B[i,j] -> [i + 2j] : N >= 0}]" },
6376 { &isl_multi_union_pw_aff_intersect_params,
6377 "[N] -> C[{ B[i,j] -> [i + 2j] : N <= 256 }]", "[N] -> { : N >= 0 }",
6378 "[N] -> C[{ B[i,j] -> [i + 2j] : 0 <= N <= 256 }]" },
6379 { &isl_multi_union_pw_aff_intersect_params,
6380 "[N] -> C[{ B[i,j] -> [i + 2j] : N <= 256 }]", "{ : }",
6381 "[N] -> C[{ B[i,j] -> [i + 2j] : N <= 256 }]" },
6382 { &isl_multi_union_pw_aff_intersect_params,
6383 "C[]", "[N] -> { : N >= 0 }",
6384 "[N] -> (C[] : { : N >= 0 })" },
6385 { &isl_multi_union_pw_aff_intersect_params,
6386 "(C[] : { A[a,b] })", "[N] -> { : N >= 0 }",
6387 "[N] -> (C[] : { A[a,b] : N >= 0 })" },
6388 { &isl_multi_union_pw_aff_intersect_params,
6389 "[N] -> (C[] : { A[a,N] })", "{ : }",
6390 "[N] -> (C[] : { A[a,N] })" },
6391 { &isl_multi_union_pw_aff_intersect_params,
6392 "[N] -> (C[] : { A[a,b] : N <= 256 })", "[N] -> { : N >= 0 }",
6393 "[N] -> (C[] : { A[a,b] : 0 <= N <= 256 })" },
6394};
6395
6396/* Perform some basic tests of binary operations on
6397 * pairs of isl_multi_union_pw_aff and isl_set objects.
6398 */
6399static int test_mupa_set(isl_ctx *ctx)
6400{
6401 int i;
6402 isl_bool ok;
6403 isl_multi_union_pw_aff *mupa, *res;
6404 isl_set *set;
6405
6406 for (i = 0; i < ARRAY_SIZE(mupa_set_tests); ++i) {
6407 mupa = isl_multi_union_pw_aff_read_from_str(ctx,
6408 str: mupa_set_tests[i].arg1);
6409 set = isl_set_read_from_str(ctx, str: mupa_set_tests[i].arg2);
6410 res = isl_multi_union_pw_aff_read_from_str(ctx,
6411 str: mupa_set_tests[i].res);
6412 mupa = mupa_set_tests[i].fn(mupa, set);
6413 ok = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa, multi2: res);
6414 isl_multi_union_pw_aff_free(multi: mupa);
6415 isl_multi_union_pw_aff_free(multi: res);
6416 if (ok < 0)
6417 return -1;
6418 if (!ok)
6419 isl_die(ctx, isl_error_unknown,
6420 "unexpected result", return -1);
6421 }
6422
6423 return 0;
6424}
6425
6426/* Inputs for basic tests of binary operations on
6427 * pairs of isl_multi_union_pw_aff and isl_union_set objects.
6428 * "fn" is the function that is tested.
6429 * "arg1" and "arg2" are string descriptions of the inputs.
6430 * "res" is a string description of the expected result.
6431 */
6432struct {
6433 __isl_give isl_multi_union_pw_aff *(*fn)(
6434 __isl_take isl_multi_union_pw_aff *mupa,
6435 __isl_take isl_union_set *uset);
6436 const char *arg1;
6437 const char *arg2;
6438 const char *res;
6439} mupa_uset_tests[] = {
6440 { &isl_multi_union_pw_aff_intersect_domain,
6441 "C[{ B[i,j] -> [i + 2j] }]", "{ B[i,i] }",
6442 "C[{ B[i,i] -> [3i] }]" },
6443 { &isl_multi_union_pw_aff_intersect_domain,
6444 "(C[] : { B[i,j] })", "{ B[i,i] }",
6445 "(C[] : { B[i,i] })" },
6446 { &isl_multi_union_pw_aff_intersect_domain,
6447 "(C[] : { B[i,j] })", "[N] -> { B[N,N] }",
6448 "[N] -> (C[] : { B[N,N] })" },
6449 { &isl_multi_union_pw_aff_intersect_domain,
6450 "C[]", "{ B[i,i] }",
6451 "(C[] : { B[i,i] })" },
6452 { &isl_multi_union_pw_aff_intersect_domain,
6453 "[N] -> (C[] : { : N >= 0 })", "{ B[i,i] }",
6454 "[N] -> (C[] : { B[i,i] : N >= 0 })" },
6455};
6456
6457/* Perform some basic tests of binary operations on
6458 * pairs of isl_multi_union_pw_aff and isl_union_set objects.
6459 */
6460static int test_mupa_uset(isl_ctx *ctx)
6461{
6462 int i;
6463 isl_bool ok;
6464 isl_multi_union_pw_aff *mupa, *res;
6465 isl_union_set *uset;
6466
6467 for (i = 0; i < ARRAY_SIZE(mupa_uset_tests); ++i) {
6468 mupa = isl_multi_union_pw_aff_read_from_str(ctx,
6469 str: mupa_uset_tests[i].arg1);
6470 uset = isl_union_set_read_from_str(ctx,
6471 str: mupa_uset_tests[i].arg2);
6472 res = isl_multi_union_pw_aff_read_from_str(ctx,
6473 str: mupa_uset_tests[i].res);
6474 mupa = mupa_uset_tests[i].fn(mupa, uset);
6475 ok = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa, multi2: res);
6476 isl_multi_union_pw_aff_free(multi: mupa);
6477 isl_multi_union_pw_aff_free(multi: res);
6478 if (ok < 0)
6479 return -1;
6480 if (!ok)
6481 isl_die(ctx, isl_error_unknown,
6482 "unexpected result", return -1);
6483 }
6484
6485 return 0;
6486}
6487
6488/* Inputs for basic tests of binary operations on
6489 * pairs of isl_multi_union_pw_aff and isl_multi_aff objects.
6490 * "fn" is the function that is tested.
6491 * "arg1" and "arg2" are string descriptions of the inputs.
6492 * "res" is a string description of the expected result.
6493 */
6494struct {
6495 __isl_give isl_multi_union_pw_aff *(*fn)(
6496 __isl_take isl_multi_union_pw_aff *mupa,
6497 __isl_take isl_multi_aff *ma);
6498 const char *arg1;
6499 const char *arg2;
6500 const char *res;
6501} mupa_ma_tests[] = {
6502 { &isl_multi_union_pw_aff_apply_multi_aff,
6503 "C[{ A[i,j] -> [i]; B[i,j] -> [j] }, "
6504 "{ A[i,j] -> [j]; B[i,j] -> [i] }]",
6505 "{ C[a,b] -> D[b,a] }",
6506 "D[{ A[i,j] -> [j]; B[i,j] -> [i] }, "
6507 "{ A[i,j] -> [i]; B[i,j] -> [j] }]" },
6508 { &isl_multi_union_pw_aff_apply_multi_aff,
6509 "C[{ A[i,j] -> [i] : i >= 0; B[i,j] -> [j] }, "
6510 "{ A[i,j] -> [j]; B[i,j] -> [i] }]",
6511 "{ C[a,b] -> D[b,a] }",
6512 "D[{ A[i,j] -> [j] : i >= 0; B[i,j] -> [i] }, "
6513 "{ A[i,j] -> [i] : i >= 0; B[i,j] -> [j] }]" },
6514 { &isl_multi_union_pw_aff_apply_multi_aff,
6515 "C[{ A[i,j] -> [i]; B[i,j] -> [j] }]",
6516 "[N] -> { C[a] -> D[a + N] }",
6517 "[N] -> D[{ A[i,j] -> [i + N]; B[i,j] -> [j + N] }] " },
6518 { &isl_multi_union_pw_aff_apply_multi_aff,
6519 "C[]",
6520 "{ C[] -> D[] }",
6521 "D[]" },
6522 { &isl_multi_union_pw_aff_apply_multi_aff,
6523 "[N] -> (C[] : { : N >= 0 })",
6524 "{ C[] -> D[] }",
6525 "[N] -> (D[] : { : N >= 0 })" },
6526 { &isl_multi_union_pw_aff_apply_multi_aff,
6527 "C[]",
6528 "[N] -> { C[] -> D[N] }",
6529 "[N] -> D[{ [N] }]" },
6530 { &isl_multi_union_pw_aff_apply_multi_aff,
6531 "(C[] : { A[i,j] : i >= j })",
6532 "{ C[] -> D[] }",
6533 "(D[] : { A[i,j] : i >= j })" },
6534 { &isl_multi_union_pw_aff_apply_multi_aff,
6535 "[N] -> (C[] : { A[i,j] : N >= 0 })",
6536 "{ C[] -> D[] }",
6537 "[N] -> (D[] : { A[i,j] : N >= 0 })" },
6538 { &isl_multi_union_pw_aff_apply_multi_aff,
6539 "(C[] : { A[i,j] : i >= j })",
6540 "[N] -> { C[] -> D[N] }",
6541 "[N] -> (D[{ A[i,j] -> [N] : i >= j }])" },
6542};
6543
6544/* Perform some basic tests of binary operations on
6545 * pairs of isl_multi_union_pw_aff and isl_multi_aff objects.
6546 */
6547static int test_mupa_ma(isl_ctx *ctx)
6548{
6549 int i;
6550 isl_bool ok;
6551 isl_multi_union_pw_aff *mupa, *res;
6552 isl_multi_aff *ma;
6553
6554 for (i = 0; i < ARRAY_SIZE(mupa_ma_tests); ++i) {
6555 mupa = isl_multi_union_pw_aff_read_from_str(ctx,
6556 str: mupa_ma_tests[i].arg1);
6557 ma = isl_multi_aff_read_from_str(ctx, str: mupa_ma_tests[i].arg2);
6558 res = isl_multi_union_pw_aff_read_from_str(ctx,
6559 str: mupa_ma_tests[i].res);
6560 mupa = mupa_ma_tests[i].fn(mupa, ma);
6561 ok = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa, multi2: res);
6562 isl_multi_union_pw_aff_free(multi: mupa);
6563 isl_multi_union_pw_aff_free(multi: res);
6564 if (ok < 0)
6565 return -1;
6566 if (!ok)
6567 isl_die(ctx, isl_error_unknown,
6568 "unexpected result", return -1);
6569 }
6570
6571 return 0;
6572}
6573
6574/* Inputs for basic tests of binary operations on
6575 * pairs of isl_multi_union_pw_aff and isl_pw_aff objects.
6576 * "fn" is the function that is tested.
6577 * "arg1" and "arg2" are string descriptions of the inputs.
6578 * "res" is a string description of the expected result.
6579 */
6580struct {
6581 __isl_give isl_union_pw_aff *(*fn)(
6582 __isl_take isl_multi_union_pw_aff *mupa,
6583 __isl_take isl_pw_aff *pa);
6584 const char *arg1;
6585 const char *arg2;
6586 const char *res;
6587} mupa_pa_tests[] = {
6588 { &isl_multi_union_pw_aff_apply_pw_aff,
6589 "C[{ A[i,j] -> [i]; B[i,j] -> [j] }]",
6590 "[N] -> { C[a] -> [a + N] }",
6591 "[N] -> { A[i,j] -> [i + N]; B[i,j] -> [j + N] }" },
6592 { &isl_multi_union_pw_aff_apply_pw_aff,
6593 "C[{ A[i,j] -> [i]; B[i,j] -> [j] }]",
6594 "{ C[a] -> [a] : a >= 0; C[a] -> [-a] : a < 0 }",
6595 "{ A[i,j] -> [i] : i >= 0; A[i,j] -> [-i] : i < 0; "
6596 "B[i,j] -> [j] : j >= 0; B[i,j] -> [-j] : j < 0 }" },
6597 { &isl_multi_union_pw_aff_apply_pw_aff,
6598 "C[]",
6599 "[N] -> { C[] -> [N] }",
6600 "[N] -> { [N] }" },
6601 { &isl_multi_union_pw_aff_apply_pw_aff,
6602 "C[]",
6603 "[N] -> { C[] -> [N] : N >= 0; C[] -> [-N] : N < 0 }",
6604 "[N] -> { [N] : N >= 0; [-N] : N < 0 }" },
6605 { &isl_multi_union_pw_aff_apply_pw_aff,
6606 "[N] -> (C[] : { : N >= 0 })",
6607 "[N] -> { C[] -> [N] }",
6608 "[N] -> { [N] : N >= 0 }" },
6609 { &isl_multi_union_pw_aff_apply_pw_aff,
6610 "[N] -> (C[] : { : N >= 0 })",
6611 "[N] -> { C[] -> [N] : N >= 0; C[] -> [-N] : N < 0 }",
6612 "[N] -> { [N] : N >= 0 }" },
6613 { &isl_multi_union_pw_aff_apply_pw_aff,
6614 "[N] -> (C[] : { : N >= 0 })",
6615 "{ C[] -> [0] }",
6616 "[N] -> { [0] : N >= 0 }" },
6617 { &isl_multi_union_pw_aff_apply_pw_aff,
6618 "(C[] : { A[i,j] : i >= j })",
6619 "[N] -> { C[] -> [N] }",
6620 "[N] -> { A[i,j] -> [N] : i >= j }" },
6621 { &isl_multi_union_pw_aff_apply_pw_aff,
6622 "(C[] : { A[i,j] : i >= j })",
6623 "[N] -> { C[] -> [N] : N >= 0 }",
6624 "[N] -> { A[i,j] -> [N] : i >= j and N >= 0 }" },
6625};
6626
6627/* Perform some basic tests of binary operations on
6628 * pairs of isl_multi_union_pw_aff and isl_pw_aff objects.
6629 */
6630static int test_mupa_pa(isl_ctx *ctx)
6631{
6632 int i;
6633 isl_bool ok;
6634 isl_multi_union_pw_aff *mupa;
6635 isl_union_pw_aff *upa, *res;
6636 isl_pw_aff *pa;
6637
6638 for (i = 0; i < ARRAY_SIZE(mupa_pa_tests); ++i) {
6639 mupa = isl_multi_union_pw_aff_read_from_str(ctx,
6640 str: mupa_pa_tests[i].arg1);
6641 pa = isl_pw_aff_read_from_str(ctx, str: mupa_pa_tests[i].arg2);
6642 res = isl_union_pw_aff_read_from_str(ctx,
6643 str: mupa_pa_tests[i].res);
6644 upa = mupa_pa_tests[i].fn(mupa, pa);
6645 ok = isl_union_pw_aff_plain_is_equal(upa1: upa, upa2: res);
6646 isl_union_pw_aff_free(upa);
6647 isl_union_pw_aff_free(upa: res);
6648 if (ok < 0)
6649 return -1;
6650 if (!ok)
6651 isl_die(ctx, isl_error_unknown,
6652 "unexpected result", return -1);
6653 }
6654
6655 return 0;
6656}
6657
6658/* Inputs for basic tests of binary operations on
6659 * pairs of isl_multi_union_pw_aff and isl_pw_multi_aff objects.
6660 * "fn" is the function that is tested.
6661 * "arg1" and "arg2" are string descriptions of the inputs.
6662 * "res" is a string description of the expected result.
6663 */
6664struct {
6665 __isl_give isl_multi_union_pw_aff *(*fn)(
6666 __isl_take isl_multi_union_pw_aff *mupa,
6667 __isl_take isl_pw_multi_aff *pma);
6668 const char *arg1;
6669 const char *arg2;
6670 const char *res;
6671} mupa_pma_tests[] = {
6672 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6673 "C[{ A[i,j] -> [i]; B[i,j] -> [j] }, "
6674 "{ A[i,j] -> [j]; B[i,j] -> [i] }]",
6675 "{ C[a,b] -> D[b,a] }",
6676 "D[{ A[i,j] -> [j]; B[i,j] -> [i] }, "
6677 "{ A[i,j] -> [i]; B[i,j] -> [j] }]" },
6678 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6679 "C[{ A[i,j] -> [i] : i >= 0; B[i,j] -> [j] }, "
6680 "{ A[i,j] -> [j]; B[i,j] -> [i] }]",
6681 "{ C[a,b] -> D[b,a] }",
6682 "D[{ A[i,j] -> [j] : i >= 0; B[i,j] -> [i] }, "
6683 "{ A[i,j] -> [i] : i >= 0; B[i,j] -> [j] }]" },
6684 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6685 "C[{ A[i,j] -> [i]; B[i,j] -> [j] }]",
6686 "[N] -> { C[a] -> D[a + N] }",
6687 "[N] -> D[{ A[i,j] -> [i + N]; B[i,j] -> [j + N] }]" },
6688 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6689 "C[{ A[i,j] -> [i]; B[i,j] -> [j] }]",
6690 "{ C[a] -> D[a] : a >= 0; C[a] -> D[-a] : a < 0 }",
6691 "D[{ A[i,j] -> [i] : i >= 0; A[i,j] -> [-i] : i < 0; "
6692 "B[i,j] -> [j] : j >= 0; B[i,j] -> [-j] : j < 0 }]" },
6693 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6694 "C[{ A[i,j] -> [i]; B[i,j] -> [j] }, "
6695 "{ A[i,j] -> [j]; B[i,j] -> [i] }]",
6696 "{ C[a,b] -> D[a,b] : a >= b; C[a,b] -> D[b,a] : a < b }",
6697 "D[{ A[i,j] -> [i] : i >= j; A[i,j] -> [j] : i < j; "
6698 "B[i,j] -> [j] : i <= j; B[i,j] -> [i] : i > j }, "
6699 "{ A[i,j] -> [j] : i >= j; A[i,j] -> [i] : i < j; "
6700 "B[i,j] -> [i] : i <= j; B[i,j] -> [j] : i > j }]" },
6701 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6702 "C[]",
6703 "{ C[] -> D[] }",
6704 "D[]" },
6705 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6706 "[N] -> (C[] : { : N >= 0 })",
6707 "{ C[] -> D[] }",
6708 "[N] -> (D[] : { : N >= 0 })" },
6709 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6710 "C[]",
6711 "[N] -> { C[] -> D[N] }",
6712 "[N] -> D[{ [N] }]" },
6713 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6714 "(C[] : { A[i,j] : i >= j })",
6715 "{ C[] -> D[] }",
6716 "(D[] : { A[i,j] : i >= j })" },
6717 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6718 "[N] -> (C[] : { A[i,j] : N >= 0 })",
6719 "{ C[] -> D[] }",
6720 "[N] -> (D[] : { A[i,j] : N >= 0 })" },
6721 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6722 "(C[] : { A[i,j] : i >= j })",
6723 "[N] -> { C[] -> D[N] }",
6724 "[N] -> (D[{ A[i,j] -> [N] : i >= j }])" },
6725 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6726 "C[]",
6727 "[N] -> { C[] -> D[N] : N >= 0; C[] -> D[-N] : N < 0 }",
6728 "[N] -> D[{ [N] : N >= 0; [-N] : N < 0 }]" },
6729 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6730 "[N] -> (C[] : { : N >= 0 })",
6731 "[N] -> { C[] -> D[N] }",
6732 "[N] -> D[{ [N] : N >= 0 }]" },
6733 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6734 "[N] -> (C[] : { : N >= 0 })",
6735 "[N] -> { C[] -> D[N] : N >= 0; C[] -> D[-N] : N < 0 }",
6736 "[N] -> D[{ [N] : N >= 0 }]" },
6737 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6738 "[N] -> (C[] : { : N >= 0 })",
6739 "{ C[] -> D[0] }",
6740 "[N] -> D[{ [0] : N >= 0 }]" },
6741 { &isl_multi_union_pw_aff_apply_pw_multi_aff,
6742 "(C[] : { A[i,j] : i >= j })",
6743 "[N] -> { C[] -> D[N] : N >= 0 }",
6744 "[N] -> D[{ A[i,j] -> [N] : i >= j and N >= 0 }]" },
6745};
6746
6747/* Perform some basic tests of binary operations on
6748 * pairs of isl_multi_union_pw_aff and isl_pw_multi_aff objects.
6749 */
6750static int test_mupa_pma(isl_ctx *ctx)
6751{
6752 int i;
6753 isl_bool ok;
6754 isl_multi_union_pw_aff *mupa, *res;
6755 isl_pw_multi_aff *pma;
6756
6757 for (i = 0; i < ARRAY_SIZE(mupa_pma_tests); ++i) {
6758 mupa = isl_multi_union_pw_aff_read_from_str(ctx,
6759 str: mupa_pma_tests[i].arg1);
6760 pma = isl_pw_multi_aff_read_from_str(ctx,
6761 str: mupa_pma_tests[i].arg2);
6762 res = isl_multi_union_pw_aff_read_from_str(ctx,
6763 str: mupa_pma_tests[i].res);
6764 mupa = mupa_pma_tests[i].fn(mupa, pma);
6765 ok = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa, multi2: res);
6766 isl_multi_union_pw_aff_free(multi: mupa);
6767 isl_multi_union_pw_aff_free(multi: res);
6768 if (ok < 0)
6769 return -1;
6770 if (!ok)
6771 isl_die(ctx, isl_error_unknown,
6772 "unexpected result", return -1);
6773 }
6774
6775 return 0;
6776}
6777
6778/* Inputs for basic tests of binary operations on
6779 * pairs of isl_multi_union_pw_aff and isl_union_pw_multi_aff objects.
6780 * "fn" is the function that is tested.
6781 * "arg1" and "arg2" are string descriptions of the inputs.
6782 * "res" is a string description of the expected result.
6783 */
6784struct {
6785 __isl_give isl_multi_union_pw_aff *(*fn)(
6786 __isl_take isl_multi_union_pw_aff *mupa,
6787 __isl_take isl_union_pw_multi_aff *upma);
6788 const char *arg1;
6789 const char *arg2;
6790 const char *res;
6791} mupa_upma_tests[] = {
6792 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6793 "C[{ B[i,j] -> [i + 2j] }]", "{ A[a,b] -> B[b,a] }",
6794 "C[{ A[a,b] -> [b + 2a] }]" },
6795 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6796 "C[{ B[i,j] -> [i + 2j] }]",
6797 "{ A[a,b] -> B[b,a] : b > a }",
6798 "C[{ A[a,b] -> [b + 2a] : b > a }]" },
6799 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6800 "C[{ B[i,j] -> [i + 2j] : j > 4 }]",
6801 "{ A[a,b] -> B[b,a] : b > a }",
6802 "C[{ A[a,b] -> [b + 2a] : b > a > 4 }]" },
6803 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6804 "C[{ B[i,j] -> [i + 2j] }]",
6805 "{ A[a,b] -> B[b,a] : a > b; A[a,b] -> B[a,b] : a <= b }",
6806 "C[{ A[a,b] -> [b + 2a] : a > b; A[a,b] -> [a + 2b] : a <= b }]" },
6807 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6808 "(C[] : { B[a,b] })",
6809 "{ A[a,b] -> B[b,a] }",
6810 "(C[] : { A[a,b] })" },
6811 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6812 "(C[] : { B[a,b] })",
6813 "{ B[a,b] -> A[b,a] }",
6814 "(C[] : { })" },
6815 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6816 "(C[] : { B[a,b] })",
6817 "{ A[a,b] -> B[b,a] : a > b }",
6818 "(C[] : { A[a,b] : a > b })" },
6819 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6820 "(C[] : { B[a,b] : a > b })",
6821 "{ A[a,b] -> B[b,a] }",
6822 "(C[] : { A[a,b] : b > a })" },
6823 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6824 "[N] -> (C[] : { B[a,b] : a > N })",
6825 "{ A[a,b] -> B[b,a] : a > b }",
6826 "[N] -> (C[] : { A[a,b] : a > b > N })" },
6827 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6828 "(C[] : { B[a,b] : a > b })",
6829 "[N] -> { A[a,b] -> B[b,a] : a > N }",
6830 "[N] -> (C[] : { A[a,b] : b > a > N })" },
6831 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6832 "C[]",
6833 "{ A[a,b] -> B[b,a] }",
6834 "C[]" },
6835 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6836 "[N] -> (C[] : { : N >= 0 })",
6837 "{ A[a,b] -> B[b,a] }",
6838 "[N] -> (C[] : { : N >= 0 })" },
6839 { &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
6840 "C[]",
6841 "[N] -> { A[a,b] -> B[b,a] : N >= 0 }",
6842 "[N] -> (C[] : { : N >= 0 })" },
6843};
6844
6845/* Perform some basic tests of binary operations on
6846 * pairs of isl_multi_union_pw_aff and isl_union_pw_multi_aff objects.
6847 */
6848static int test_mupa_upma(isl_ctx *ctx)
6849{
6850 int i;
6851 isl_bool ok;
6852 isl_multi_union_pw_aff *mupa, *res;
6853 isl_union_pw_multi_aff *upma;
6854
6855 for (i = 0; i < ARRAY_SIZE(mupa_upma_tests); ++i) {
6856 mupa = isl_multi_union_pw_aff_read_from_str(ctx,
6857 str: mupa_upma_tests[i].arg1);
6858 upma = isl_union_pw_multi_aff_read_from_str(ctx,
6859 str: mupa_upma_tests[i].arg2);
6860 res = isl_multi_union_pw_aff_read_from_str(ctx,
6861 str: mupa_upma_tests[i].res);
6862 mupa = mupa_upma_tests[i].fn(mupa, upma);
6863 ok = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa, multi2: res);
6864 isl_multi_union_pw_aff_free(multi: mupa);
6865 isl_multi_union_pw_aff_free(multi: res);
6866 if (ok < 0)
6867 return -1;
6868 if (!ok)
6869 isl_die(ctx, isl_error_unknown,
6870 "unexpected result", return -1);
6871 }
6872
6873 return 0;
6874}
6875
6876/* Check that the input tuple of an isl_aff can be set properly.
6877 */
6878static isl_stat test_aff_set_tuple_id(isl_ctx *ctx)
6879{
6880 isl_id *id;
6881 isl_aff *aff;
6882 isl_stat equal;
6883
6884 aff = isl_aff_read_from_str(ctx, str: "{ [x] -> [x + 1] }");
6885 id = isl_id_alloc(ctx, name: "A", NULL);
6886 aff = isl_aff_set_tuple_id(aff, type: isl_dim_in, id);
6887 equal = aff_check_plain_equal(obj: aff, str: "{ A[x] -> [x + 1] }");
6888 isl_aff_free(aff);
6889 if (equal < 0)
6890 return isl_stat_error;
6891
6892 return isl_stat_ok;
6893}
6894
6895/* Check that affine expressions get normalized on addition/subtraction.
6896 * In particular, check that (final) unused integer divisions get removed
6897 * such that an expression derived from expressions with integer divisions
6898 * is found to be obviously equal to one that is created directly.
6899 */
6900static isl_stat test_aff_normalize(isl_ctx *ctx)
6901{
6902 isl_aff *aff, *aff2;
6903 isl_stat ok;
6904
6905 aff = isl_aff_read_from_str(ctx, str: "{ [x] -> [x//2] }");
6906 aff2 = isl_aff_read_from_str(ctx, str: "{ [x] -> [1 + x//2] }");
6907 aff = isl_aff_sub(aff1: aff2, aff2: aff);
6908 ok = aff_check_plain_equal(obj: aff, str: "{ [x] -> [1] }");
6909 isl_aff_free(aff);
6910
6911 return ok;
6912}
6913
6914int test_aff(isl_ctx *ctx)
6915{
6916 const char *str;
6917 isl_set *set;
6918 isl_space *space;
6919 isl_local_space *ls;
6920 isl_aff *aff;
6921 int zero;
6922 isl_stat equal;
6923
6924 if (test_upa(ctx) < 0)
6925 return -1;
6926 if (test_bin_aff(ctx) < 0)
6927 return -1;
6928 if (test_bin_pw_aff(ctx) < 0)
6929 return -1;
6930 if (test_upma_test(ctx) < 0)
6931 return -1;
6932 if (test_bin_upma(ctx) < 0)
6933 return -1;
6934 if (test_bin_upma_fail(ctx) < 0)
6935 return -1;
6936 if (test_upma_uset(ctx) < 0)
6937 return -1;
6938 if (test_un_mpa(ctx) < 0)
6939 return -1;
6940 if (test_bin_mpa(ctx) < 0)
6941 return -1;
6942 if (test_un_mupa(ctx) < 0)
6943 return -1;
6944 if (test_bin_mupa(ctx) < 0)
6945 return -1;
6946 if (test_mupa_set(ctx) < 0)
6947 return -1;
6948 if (test_mupa_uset(ctx) < 0)
6949 return -1;
6950 if (test_mupa_ma(ctx) < 0)
6951 return -1;
6952 if (test_mupa_pa(ctx) < 0)
6953 return -1;
6954 if (test_mupa_pma(ctx) < 0)
6955 return -1;
6956 if (test_mupa_upma(ctx) < 0)
6957 return -1;
6958
6959 space = isl_space_set_alloc(ctx, nparam: 0, dim: 1);
6960 ls = isl_local_space_from_space(space);
6961 aff = isl_aff_zero_on_domain(ls);
6962
6963 aff = isl_aff_add_coefficient_si(aff, type: isl_dim_in, pos: 0, v: 1);
6964 aff = isl_aff_scale_down_ui(aff, f: 3);
6965 aff = isl_aff_floor(aff);
6966 aff = isl_aff_add_coefficient_si(aff, type: isl_dim_in, pos: 0, v: 1);
6967 aff = isl_aff_scale_down_ui(aff, f: 2);
6968 aff = isl_aff_floor(aff);
6969 aff = isl_aff_add_coefficient_si(aff, type: isl_dim_in, pos: 0, v: 1);
6970
6971 str = "{ [10] }";
6972 set = isl_set_read_from_str(ctx, str);
6973 aff = isl_aff_gist(aff, context: set);
6974
6975 aff = isl_aff_add_constant_si(aff, v: -16);
6976 zero = isl_aff_plain_is_zero(aff);
6977 isl_aff_free(aff);
6978
6979 if (zero < 0)
6980 return -1;
6981 if (!zero)
6982 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
6983
6984 aff = isl_aff_read_from_str(ctx, str: "{ [-1] }");
6985 aff = isl_aff_scale_down_ui(aff, f: 64);
6986 aff = isl_aff_floor(aff);
6987 equal = aff_check_plain_equal(obj: aff, str: "{ [-1] }");
6988 isl_aff_free(aff);
6989 if (equal < 0)
6990 return -1;
6991
6992 if (test_aff_set_tuple_id(ctx) < 0)
6993 return -1;
6994 if (test_aff_normalize(ctx) < 0)
6995 return -1;
6996
6997 return 0;
6998}
6999
7000/* Inputs for isl_set_bind tests.
7001 * "set" is the input set.
7002 * "tuple" is the binding tuple.
7003 * "res" is the expected result.
7004 */
7005static
7006struct {
7007 const char *set;
7008 const char *tuple;
7009 const char *res;
7010} bind_set_tests[] = {
7011 { "{ A[M, N] : M mod 2 = 0 and N mod 8 = 3 }",
7012 "{ A[M, N] }",
7013 "[M, N] -> { : M mod 2 = 0 and N mod 8 = 3 }" },
7014 { "{ B[N, M] : M mod 2 = 0 and N mod 8 = 3 }",
7015 "{ B[N, M] }",
7016 "[M, N] -> { : M mod 2 = 0 and N mod 8 = 3 }" },
7017 { "[M] -> { C[N] : M mod 2 = 0 and N mod 8 = 3 }",
7018 "{ C[N] }",
7019 "[M, N] -> { : M mod 2 = 0 and N mod 8 = 3 }" },
7020 { "[M] -> { D[x, N] : x mod 2 = 0 and N mod 8 = 3 and M >= 0 }",
7021 "{ D[M, N] }",
7022 "[M, N] -> { : M mod 2 = 0 and N mod 8 = 3 and M >= 0 }" },
7023};
7024
7025/* Perform basic isl_set_bind tests.
7026 */
7027static isl_stat test_bind_set(isl_ctx *ctx)
7028{
7029 int i;
7030
7031 for (i = 0; i < ARRAY_SIZE(bind_set_tests); ++i) {
7032 const char *str;
7033 isl_set *set;
7034 isl_multi_id *tuple;
7035 isl_stat r;
7036
7037 set = isl_set_read_from_str(ctx, str: bind_set_tests[i].set);
7038 str = bind_set_tests[i].tuple;
7039 tuple = isl_multi_id_read_from_str(ctx, str);
7040 set = isl_set_bind(set, tuple);
7041 r = set_check_equal(set, str: bind_set_tests[i].res);
7042 isl_set_free(set);
7043 if (r < 0)
7044 return isl_stat_error;
7045 }
7046
7047 return isl_stat_ok;
7048}
7049
7050/* Inputs for isl_map_bind_domain tests.
7051 * "map" is the input map.
7052 * "tuple" is the binding tuple.
7053 * "res" is the expected result.
7054 */
7055struct {
7056 const char *map;
7057 const char *tuple;
7058 const char *res;
7059} bind_map_domain_tests[] = {
7060 { "{ A[M, N] -> [M + floor(N/2)] }",
7061 "{ A[M, N] }",
7062 "[M, N] -> { [M + floor(N/2)] }" },
7063 { "{ B[N, M] -> [M + floor(N/2)] }",
7064 "{ B[N, M] }",
7065 "[N, M] -> { [M + floor(N/2)] }" },
7066 { "[M] -> { C[N] -> [M + floor(N/2)] }",
7067 "{ C[N] }",
7068 "[M, N] -> { [M + floor(N/2)] }" },
7069 { "[M] -> { C[x, N] -> [x + floor(N/2)] }",
7070 "{ C[M, N] }",
7071 "[M, N] -> { [M + floor(N/2)] }" },
7072 { "[M] -> { C[x, N] -> [M + floor(N/2)] }",
7073 "{ C[M, N] }",
7074 "[M, N] -> { [M + floor(N/2)] }" },
7075 { "[A, M] -> { C[N, x] -> [x + floor(N/2)] }",
7076 "{ C[N, M] }",
7077 "[A, N, M] -> { [M + floor(N/2)] }" },
7078};
7079
7080/* Perform basic isl_map_bind_domain tests.
7081 */
7082static isl_stat test_bind_map_domain(isl_ctx *ctx)
7083{
7084 int i;
7085
7086 for (i = 0; i < ARRAY_SIZE(bind_map_domain_tests); ++i) {
7087 const char *str;
7088 isl_map *map;
7089 isl_set *set;
7090 isl_multi_id *tuple;
7091 isl_stat r;
7092
7093 str = bind_map_domain_tests[i].map;
7094 map = isl_map_read_from_str(ctx, str);
7095 str = bind_map_domain_tests[i].tuple;
7096 tuple = isl_multi_id_read_from_str(ctx, str);
7097 set = isl_map_bind_domain(map, tuple);
7098 str = bind_map_domain_tests[i].res;
7099 r = set_check_equal(set, str);
7100 isl_set_free(set);
7101 if (r < 0)
7102 return isl_stat_error;
7103 }
7104
7105 return isl_stat_ok;
7106}
7107
7108/* Inputs for isl_union_map_bind_range tests.
7109 * "map" is the input union map.
7110 * "tuple" is the binding tuple.
7111 * "res" is the expected result.
7112 */
7113struct {
7114 const char *map;
7115 const char *tuple;
7116 const char *res;
7117} bind_umap_range_tests[] = {
7118 { "{ B[N, M] -> A[M, N] : M mod 2 = 0 and N mod 8 = 3 }",
7119 "{ A[M, N] }",
7120 "[M, N] -> { B[N, M] : M mod 2 = 0 and N mod 8 = 3 }" },
7121 { "{ B[N, M] -> A[M, N] : M mod 2 = 0 and N mod 8 = 3 }",
7122 "{ B[M, N] }",
7123 "{ }" },
7124 { "{ A[] -> B[]; C[] -> D[]; E[] -> B[] }",
7125 "{ B[] }",
7126 "{ A[]; E[] }" },
7127};
7128
7129/* Perform basic isl_union_map_bind_range tests.
7130 */
7131static isl_stat test_bind_umap_range(isl_ctx *ctx)
7132{
7133 int i;
7134
7135 for (i = 0; i < ARRAY_SIZE(bind_umap_range_tests); ++i) {
7136 const char *str;
7137 isl_union_map *umap;
7138 isl_union_set *uset;
7139 isl_multi_id *tuple;
7140 isl_stat r;
7141
7142 str = bind_umap_range_tests[i].map;
7143 umap = isl_union_map_read_from_str(ctx, str);
7144 str = bind_umap_range_tests[i].tuple;
7145 tuple = isl_multi_id_read_from_str(ctx, str);
7146 uset = isl_union_map_bind_range(umap, tuple);
7147 str = bind_umap_range_tests[i].res;
7148 r = uset_check_equal(uset, str);
7149 isl_union_set_free(uset);
7150 if (r < 0)
7151 return isl_stat_error;
7152 }
7153
7154 return isl_stat_ok;
7155}
7156
7157/* Inputs for isl_pw_multi_aff_bind_domain tests.
7158 * "pma" is the input expression.
7159 * "tuple" is the binding tuple.
7160 * "res" is the expected result.
7161 */
7162struct {
7163 const char *pma;
7164 const char *tuple;
7165 const char *res;
7166} bind_pma_domain_tests[] = {
7167 { "{ A[M, N] -> [M + floor(N/2)] }",
7168 "{ A[M, N] }",
7169 "[M, N] -> { [M + floor(N/2)] }" },
7170 { "{ B[N, M] -> [M + floor(N/2)] }",
7171 "{ B[N, M] }",
7172 "[N, M] -> { [M + floor(N/2)] }" },
7173 { "[M] -> { C[N] -> [M + floor(N/2)] }",
7174 "{ C[N] }",
7175 "[M, N] -> { [M + floor(N/2)] }" },
7176 { "[M] -> { C[x, N] -> [x + floor(N/2)] }",
7177 "{ C[M, N] }",
7178 "[M, N] -> { [M + floor(N/2)] }" },
7179 { "[M] -> { C[x, N] -> [M + floor(N/2)] }",
7180 "{ C[M, N] }",
7181 "[M, N] -> { [M + floor(N/2)] }" },
7182 { "[A, M] -> { C[N, x] -> [x + floor(N/2)] }",
7183 "{ C[N, M] }",
7184 "[A, N, M] -> { [M + floor(N/2)] }" },
7185};
7186
7187/* Perform basic isl_pw_multi_aff_bind_domain tests.
7188 */
7189static isl_stat test_bind_pma_domain(isl_ctx *ctx)
7190{
7191 int i;
7192
7193 for (i = 0; i < ARRAY_SIZE(bind_pma_domain_tests); ++i) {
7194 const char *str;
7195 isl_pw_multi_aff *pma;
7196 isl_multi_id *tuple;
7197 isl_stat r;
7198
7199 str = bind_pma_domain_tests[i].pma;
7200 pma = isl_pw_multi_aff_read_from_str(ctx, str);
7201 str = bind_pma_domain_tests[i].tuple;
7202 tuple = isl_multi_id_read_from_str(ctx, str);
7203 pma = isl_pw_multi_aff_bind_domain(pma, tuple);
7204 str = bind_pma_domain_tests[i].res;
7205 r = pw_multi_aff_check_plain_equal(obj: pma, str);
7206 isl_pw_multi_aff_free(pma);
7207 if (r < 0)
7208 return isl_stat_error;
7209 }
7210
7211 return isl_stat_ok;
7212}
7213
7214/* Inputs for isl_pw_multi_aff_bind_domain_wrapped_domain tests.
7215 * "pma" is the input expression.
7216 * "tuple" is the binding tuple.
7217 * "res" is the expected result.
7218 */
7219struct {
7220 const char *pma;
7221 const char *tuple;
7222 const char *res;
7223} bind_pma_domain_wrapped_tests[] = {
7224 { "{ [A[M, N] -> B[]] -> [M + floor(N/2)] }",
7225 "{ A[M, N] }",
7226 "[M, N] -> { B[] -> [M + floor(N/2)] }" },
7227 { "{ [B[N, M] -> D[]] -> [M + floor(N/2)] }",
7228 "{ B[N, M] }",
7229 "[N, M] -> { D[] -> [M + floor(N/2)] }" },
7230 { "[M] -> { [C[N] -> B[x]] -> [x + M + floor(N/2)] }",
7231 "{ C[N] }",
7232 "[M, N] -> { B[x] -> [x + M + floor(N/2)] }" },
7233 { "[M] -> { [C[x, N] -> B[]] -> [x + floor(N/2)] }",
7234 "{ C[M, N] }",
7235 "[M, N] -> { B[] -> [M + floor(N/2)] }" },
7236 { "[M] -> { [C[x, N] -> B[]] -> [M + floor(N/2)] }",
7237 "{ C[M, N] }",
7238 "[M, N] -> { B[] -> [M + floor(N/2)] }" },
7239 { "[A, M] -> { [C[N, x] -> B[]] -> [x + floor(N/2)] }",
7240 "{ C[N, M] }",
7241 "[A, N, M] -> { B[] -> [M + floor(N/2)] }" },
7242};
7243
7244/* Perform basic isl_pw_multi_aff_bind_domain_wrapped_domain tests.
7245 */
7246static isl_stat test_bind_pma_domain_wrapped(isl_ctx *ctx)
7247{
7248 int i;
7249
7250 for (i = 0; i < ARRAY_SIZE(bind_pma_domain_wrapped_tests); ++i) {
7251 const char *str;
7252 isl_pw_multi_aff *pma;
7253 isl_multi_id *tuple;
7254 isl_stat r;
7255
7256 str = bind_pma_domain_wrapped_tests[i].pma;
7257 pma = isl_pw_multi_aff_read_from_str(ctx, str);
7258 str = bind_pma_domain_wrapped_tests[i].tuple;
7259 tuple = isl_multi_id_read_from_str(ctx, str);
7260 pma = isl_pw_multi_aff_bind_domain_wrapped_domain(pma, tuple);
7261 str = bind_pma_domain_wrapped_tests[i].res;
7262 r = pw_multi_aff_check_plain_equal(obj: pma, str);
7263 isl_pw_multi_aff_free(pma);
7264 if (r < 0)
7265 return isl_stat_error;
7266 }
7267
7268 return isl_stat_ok;
7269}
7270
7271/* Inputs for isl_aff_bind_id tests.
7272 * "aff" is the input expression.
7273 * "id" is the binding id.
7274 * "res" is the expected result.
7275 */
7276static
7277struct {
7278 const char *aff;
7279 const char *id;
7280 const char *res;
7281} bind_aff_tests[] = {
7282 { "{ [4] }", "M", "[M = 4] -> { : }" },
7283 { "{ B[x] -> [floor(x/2)] }", "M", "[M] -> { B[x] : M = floor(x/2) }" },
7284 { "[M] -> { [4] }", "M", "[M = 4] -> { : }" },
7285 { "[M] -> { [floor(M/2)] }", "M", "[M] -> { : floor(M/2) = M }" },
7286 { "{ [NaN] }", "M", "{ : false }" },
7287 { "{ A[x] -> [NaN] }", "M", "{ A[x] : false }" },
7288};
7289
7290/* Perform basic isl_aff_bind_id tests.
7291 */
7292static isl_stat test_bind_aff(isl_ctx *ctx)
7293{
7294 int i;
7295
7296 for (i = 0; i < ARRAY_SIZE(bind_aff_tests); ++i) {
7297 isl_aff *aff;
7298 isl_set *res;
7299 isl_id *id;
7300 isl_stat r;
7301
7302 aff = isl_aff_read_from_str(ctx, str: bind_aff_tests[i].aff);
7303 id = isl_id_read_from_str(ctx, str: bind_aff_tests[i].id);
7304 res = isl_set_from_basic_set(bset: isl_aff_bind_id(aff, id));
7305 r = set_check_equal(set: res, str: bind_aff_tests[i].res);
7306 isl_set_free(set: res);
7307 if (r < 0)
7308 return isl_stat_error;
7309 }
7310
7311 return isl_stat_ok;
7312}
7313
7314/* Inputs for isl_pw_aff_bind_id tests.
7315 * "pa" is the input expression.
7316 * "id" is the binding id.
7317 * "res" is the expected result.
7318 */
7319static
7320struct {
7321 const char *pa;
7322 const char *id;
7323 const char *res;
7324} bind_pa_tests[] = {
7325 { "{ [4] }", "M", "[M = 4] -> { : }" },
7326 { "{ B[x] -> [floor(x/2)] }", "M", "[M] -> { B[x] : M = floor(x/2) }" },
7327 { "[M] -> { [4] }", "M", "[M = 4] -> { : }" },
7328 { "[M] -> { [floor(M/2)] }", "M", "[M] -> { : floor(M/2) = M }" },
7329 { "[M] -> { [M] : M >= 0; [-M] : M < 0 }", "M", "[M] -> { : M >= 0 }" },
7330 { "{ [NaN] }", "M", "{ : false }" },
7331 { "{ A[x] -> [NaN] }", "M", "{ A[x] : false }" },
7332};
7333
7334/* Perform basic isl_pw_aff_bind_id tests.
7335 */
7336static isl_stat test_bind_pa(isl_ctx *ctx)
7337{
7338 int i;
7339
7340 for (i = 0; i < ARRAY_SIZE(bind_pa_tests); ++i) {
7341 isl_pw_aff *pa;
7342 isl_set *res;
7343 isl_id *id;
7344 isl_stat r;
7345
7346 pa = isl_pw_aff_read_from_str(ctx, str: bind_pa_tests[i].pa);
7347 id = isl_id_read_from_str(ctx, str: bind_pa_tests[i].id);
7348 res = isl_pw_aff_bind_id(pa, id);
7349 r = set_check_equal(set: res, str: bind_pa_tests[i].res);
7350 isl_set_free(set: res);
7351 if (r < 0)
7352 return isl_stat_error;
7353 }
7354
7355 return isl_stat_ok;
7356}
7357
7358/* Inputs for isl_multi_union_pw_aff_bind tests.
7359 * "mupa" is the input expression.
7360 * "tuple" is the binding tuple.
7361 * "res" is the expected result.
7362 */
7363static
7364struct {
7365 const char *mupa;
7366 const char *tuple;
7367 const char *res;
7368} bind_mupa_tests[] = {
7369 { "A[{ [4] }, { [5] }]",
7370 "{ A[M, N] }",
7371 "[M = 4, N = 5] -> { : }" },
7372 { "A[{ B[x] -> [floor(x/2)] }, { B[y] -> [y + 5] }]",
7373 "{ A[M, N] }",
7374 "[M, N] -> { B[x] : M = floor(x/2) and N = x + 5 }" },
7375 { "[M] -> A[{ [4] }, { [M + 1] }]",
7376 "{ A[M, N] }",
7377 "[M = 4, N = 5] -> { : }" },
7378};
7379
7380/* Perform basic isl_multi_union_pw_aff_bind tests.
7381 */
7382static isl_stat test_bind_mupa(isl_ctx *ctx)
7383{
7384 int i;
7385
7386 for (i = 0; i < ARRAY_SIZE(bind_mupa_tests); ++i) {
7387 const char *str;
7388 isl_multi_union_pw_aff *mupa;
7389 isl_union_set *res;
7390 isl_multi_id *tuple;
7391 isl_stat r;
7392
7393 str = bind_mupa_tests[i].mupa;
7394 mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
7395 str = bind_mupa_tests[i].tuple;
7396 tuple = isl_multi_id_read_from_str(ctx, str);
7397 res = isl_multi_union_pw_aff_bind(mupa, tuple);
7398 r = uset_check_equal(uset: res, str: bind_mupa_tests[i].res);
7399 isl_union_set_free(uset: res);
7400 if (r < 0)
7401 return isl_stat_error;
7402 }
7403
7404 return isl_stat_ok;
7405}
7406
7407/* Perform tests that reinterpret dimensions as parameters.
7408 */
7409static int test_bind(isl_ctx *ctx)
7410{
7411 if (test_bind_set(ctx) < 0)
7412 return -1;
7413 if (test_bind_map_domain(ctx) < 0)
7414 return -1;
7415 if (test_bind_umap_range(ctx) < 0)
7416 return -1;
7417 if (test_bind_pma_domain(ctx) < 0)
7418 return -1;
7419 if (test_bind_pma_domain_wrapped(ctx) < 0)
7420 return -1;
7421 if (test_bind_aff(ctx) < 0)
7422 return -1;
7423 if (test_bind_pa(ctx) < 0)
7424 return -1;
7425 if (test_bind_mupa(ctx) < 0)
7426 return -1;
7427
7428 return 0;
7429}
7430
7431/* Inputs for isl_set_unbind_params tests.
7432 * "set" is the input parameter domain.
7433 * "tuple" is the tuple of the constructed set.
7434 * "res" is the expected result.
7435 */
7436struct {
7437 const char *set;
7438 const char *tuple;
7439 const char *res;
7440} unbind_set_tests[] = {
7441 { "[M, N] -> { : M mod 2 = 0 and N mod 8 = 3 }",
7442 "{ A[M, N] }",
7443 "{ A[M, N] : M mod 2 = 0 and N mod 8 = 3 }" },
7444 { "[M, N] -> { : M mod 2 = 0 and N mod 8 = 3 }",
7445 "{ B[N, M] }",
7446 "{ B[N, M] : M mod 2 = 0 and N mod 8 = 3 }" },
7447 { "[M, N] -> { : M mod 2 = 0 and N mod 8 = 3 }",
7448 "{ C[N] }",
7449 "[M] -> { C[N] : M mod 2 = 0 and N mod 8 = 3 }" },
7450 { "[M, N] -> { : M mod 2 = 0 and N mod 8 = 3 }",
7451 "{ D[T, N] }",
7452 "[M] -> { D[x, N] : M mod 2 = 0 and N mod 8 = 3 }" },
7453};
7454
7455/* Perform basic isl_set_unbind_params tests.
7456 */
7457static isl_stat test_unbind_set(isl_ctx *ctx)
7458{
7459 int i;
7460
7461 for (i = 0; i < ARRAY_SIZE(unbind_set_tests); ++i) {
7462 const char *str;
7463 isl_set *set;
7464 isl_multi_id *tuple;
7465 isl_stat r;
7466
7467 set = isl_set_read_from_str(ctx, str: unbind_set_tests[i].set);
7468 str = unbind_set_tests[i].tuple;
7469 tuple = isl_multi_id_read_from_str(ctx, str);
7470 set = isl_set_unbind_params(set, tuple);
7471 r = set_check_equal(set, str: unbind_set_tests[i].res);
7472 isl_set_free(set);
7473 if (r < 0)
7474 return isl_stat_error;
7475 }
7476
7477 return isl_stat_ok;
7478}
7479
7480/* Inputs for isl_aff_unbind_params_insert_domain tests.
7481 * "aff" is the input affine expression defined over a parameter domain.
7482 * "tuple" is the tuple of the domain that gets introduced.
7483 * "res" is the expected result.
7484 */
7485struct {
7486 const char *aff;
7487 const char *tuple;
7488 const char *res;
7489} unbind_aff_tests[] = {
7490 { "[M, N] -> { [M + floor(N/2)] }",
7491 "{ A[M, N] }",
7492 "{ A[M, N] -> [M + floor(N/2)] }" },
7493 { "[M, N] -> { [M + floor(N/2)] }",
7494 "{ B[N, M] }",
7495 "{ B[N, M] -> [M + floor(N/2)] }" },
7496 { "[M, N] -> { [M + floor(N/2)] }",
7497 "{ C[N] }",
7498 "[M] -> { C[N] -> [M + floor(N/2)] }" },
7499 { "[M, N] -> { [M + floor(N/2)] }",
7500 "{ D[A, B, C, N, Z] }",
7501 "[M] -> { D[A, B, C, N, Z] -> [M + floor(N/2)] }" },
7502};
7503
7504/* Perform basic isl_aff_unbind_params_insert_domain tests.
7505 */
7506static isl_stat test_unbind_aff(isl_ctx *ctx)
7507{
7508 int i;
7509
7510 for (i = 0; i < ARRAY_SIZE(unbind_aff_tests); ++i) {
7511 const char *str;
7512 isl_aff *aff;
7513 isl_multi_id *tuple;
7514 isl_stat r;
7515
7516 aff = isl_aff_read_from_str(ctx, str: unbind_aff_tests[i].aff);
7517 str = unbind_aff_tests[i].tuple;
7518 tuple = isl_multi_id_read_from_str(ctx, str);
7519 aff = isl_aff_unbind_params_insert_domain(aff, domain: tuple);
7520 r = aff_check_plain_equal(obj: aff, str: unbind_aff_tests[i].res);
7521 isl_aff_free(aff);
7522 if (r < 0)
7523 return isl_stat_error;
7524 }
7525
7526 return isl_stat_ok;
7527}
7528
7529/* Inputs for isl_multi_aff_unbind_params_insert_domain tests.
7530 * "ma" is the input multi affine expression defined over a parameter domain.
7531 * "tuple" is the tuple of the domain that gets introduced.
7532 * "res" is the expected result.
7533 */
7534static struct {
7535 const char *ma;
7536 const char *tuple;
7537 const char *res;
7538} unbind_multi_aff_tests[] = {
7539 { "[M, N] -> { T[M + floor(N/2)] }",
7540 "{ A[M, N] }",
7541 "{ A[M, N] -> T[M + floor(N/2)] }" },
7542 { "[M, N] -> { [M + floor(N/2)] }",
7543 "{ B[N, M] }",
7544 "{ B[N, M] -> [M + floor(N/2)] }" },
7545 { "[M, N] -> { [M + floor(N/2)] }",
7546 "{ C[N] }",
7547 "[M] -> { C[N] -> [M + floor(N/2)] }" },
7548 { "[M, N] -> { [M + floor(N/2)] }",
7549 "{ D[A, B, C, N, Z] }",
7550 "[M] -> { D[A, B, C, N, Z] -> [M + floor(N/2)] }" },
7551 { "[M, N] -> { T[M + floor(N/2), N + floor(M/3)] }",
7552 "{ A[M, N] }",
7553 "{ A[M, N] -> T[M + floor(N/2), N + floor(M/3)] }" },
7554};
7555
7556/* Perform basic isl_multi_aff_unbind_params_insert_domain tests.
7557 */
7558static isl_stat test_unbind_multi_aff(isl_ctx *ctx)
7559{
7560 int i;
7561
7562 for (i = 0; i < ARRAY_SIZE(unbind_multi_aff_tests); ++i) {
7563 const char *str;
7564 isl_multi_aff *ma;
7565 isl_multi_id *tuple;
7566 isl_stat r;
7567
7568 str = unbind_multi_aff_tests[i].ma;
7569 ma = isl_multi_aff_read_from_str(ctx, str);
7570 str = unbind_multi_aff_tests[i].tuple;
7571 tuple = isl_multi_id_read_from_str(ctx, str);
7572 ma = isl_multi_aff_unbind_params_insert_domain(multi: ma, domain: tuple);
7573 str = unbind_multi_aff_tests[i].res;
7574 r = multi_aff_check_plain_equal(obj: ma, str);
7575 isl_multi_aff_free(multi: ma);
7576 if (r < 0)
7577 return isl_stat_error;
7578 }
7579
7580 return isl_stat_ok;
7581}
7582
7583/* Perform tests that reinterpret parameters.
7584 */
7585static int test_unbind(isl_ctx *ctx)
7586{
7587 if (test_unbind_set(ctx) < 0)
7588 return -1;
7589 if (test_unbind_aff(ctx) < 0)
7590 return -1;
7591 if (test_unbind_multi_aff(ctx) < 0)
7592 return -1;
7593
7594 return 0;
7595}
7596
7597/* Check that "pa" consists of a single expression.
7598 */
7599static int check_single_piece(isl_ctx *ctx, __isl_take isl_pw_aff *pa)
7600{
7601 isl_size n;
7602
7603 n = isl_pw_aff_n_piece(pwaff: pa);
7604 isl_pw_aff_free(pwaff: pa);
7605
7606 if (n < 0)
7607 return -1;
7608 if (n != 1)
7609 isl_die(ctx, isl_error_unknown, "expecting single expression",
7610 return -1);
7611
7612 return 0;
7613}
7614
7615/* Check that the computation below results in a single expression.
7616 * One or two expressions may result depending on which constraint
7617 * ends up being considered as redundant with respect to the other
7618 * constraints after the projection that is performed internally
7619 * by isl_set_dim_min.
7620 */
7621static int test_dim_max_1(isl_ctx *ctx)
7622{
7623 const char *str;
7624 isl_set *set;
7625 isl_pw_aff *pa;
7626
7627 str = "[n] -> { [a, b] : n >= 0 and 4a >= -4 + n and b >= 0 and "
7628 "-4a <= b <= 3 and b < n - 4a }";
7629 set = isl_set_read_from_str(ctx, str);
7630 pa = isl_set_dim_min(set, pos: 0);
7631 return check_single_piece(ctx, pa);
7632}
7633
7634/* Check that the computation below results in a single expression.
7635 * The PIP problem corresponding to these constraints has a row
7636 * that causes a split of the solution domain. The solver should
7637 * first pick rows that split off empty parts such that the actual
7638 * solution domain does not get split.
7639 * Note that the description contains some redundant constraints.
7640 * If these constraints get removed first, then the row mentioned
7641 * above does not appear in the PIP problem.
7642 */
7643static int test_dim_max_2(isl_ctx *ctx)
7644{
7645 const char *str;
7646 isl_set *set;
7647 isl_pw_aff *pa;
7648
7649 str = "[P, N] -> { [a] : a < N and a >= 0 and N > P and a <= P and "
7650 "N > 0 and P >= 0 }";
7651 set = isl_set_read_from_str(ctx, str);
7652 pa = isl_set_dim_max(set, pos: 0);
7653 return check_single_piece(ctx, pa);
7654}
7655
7656int test_dim_max(isl_ctx *ctx)
7657{
7658 int equal;
7659 const char *str;
7660 isl_set *set1, *set2;
7661 isl_set *set;
7662 isl_map *map;
7663 isl_pw_aff *pwaff;
7664
7665 if (test_dim_max_1(ctx) < 0)
7666 return -1;
7667 if (test_dim_max_2(ctx) < 0)
7668 return -1;
7669
7670 str = "[N] -> { [i] : 0 <= i <= min(N,10) }";
7671 set = isl_set_read_from_str(ctx, str);
7672 pwaff = isl_set_dim_max(set, pos: 0);
7673 set1 = isl_set_from_pw_aff(pwaff);
7674 str = "[N] -> { [10] : N >= 10; [N] : N <= 9 and N >= 0 }";
7675 set2 = isl_set_read_from_str(ctx, str);
7676 equal = isl_set_is_equal(set1, set2);
7677 isl_set_free(set: set1);
7678 isl_set_free(set: set2);
7679 if (equal < 0)
7680 return -1;
7681 if (!equal)
7682 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7683
7684 str = "[N] -> { [i] : 0 <= i <= max(2N,N+6) }";
7685 set = isl_set_read_from_str(ctx, str);
7686 pwaff = isl_set_dim_max(set, pos: 0);
7687 set1 = isl_set_from_pw_aff(pwaff);
7688 str = "[N] -> { [6 + N] : -6 <= N <= 5; [2N] : N >= 6 }";
7689 set2 = isl_set_read_from_str(ctx, str);
7690 equal = isl_set_is_equal(set1, set2);
7691 isl_set_free(set: set1);
7692 isl_set_free(set: set2);
7693 if (equal < 0)
7694 return -1;
7695 if (!equal)
7696 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7697
7698 str = "[N] -> { [i] : 0 <= i <= 2N or 0 <= i <= N+6 }";
7699 set = isl_set_read_from_str(ctx, str);
7700 pwaff = isl_set_dim_max(set, pos: 0);
7701 set1 = isl_set_from_pw_aff(pwaff);
7702 str = "[N] -> { [6 + N] : -6 <= N <= 5; [2N] : N >= 6 }";
7703 set2 = isl_set_read_from_str(ctx, str);
7704 equal = isl_set_is_equal(set1, set2);
7705 isl_set_free(set: set1);
7706 isl_set_free(set: set2);
7707 if (equal < 0)
7708 return -1;
7709 if (!equal)
7710 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7711
7712 str = "[N,M] -> { [i,j] -> [([i/16]), i%16, ([j/16]), j%16] : "
7713 "0 <= i < N and 0 <= j < M }";
7714 map = isl_map_read_from_str(ctx, str);
7715 set = isl_map_range(map);
7716
7717 pwaff = isl_set_dim_max(set: isl_set_copy(set), pos: 0);
7718 set1 = isl_set_from_pw_aff(pwaff);
7719 str = "[N,M] -> { [([(N-1)/16])] : M,N > 0 }";
7720 set2 = isl_set_read_from_str(ctx, str);
7721 equal = isl_set_is_equal(set1, set2);
7722 isl_set_free(set: set1);
7723 isl_set_free(set: set2);
7724
7725 pwaff = isl_set_dim_max(set: isl_set_copy(set), pos: 3);
7726 set1 = isl_set_from_pw_aff(pwaff);
7727 str = "[N,M] -> { [t] : t = min(M-1,15) and M,N > 0 }";
7728 set2 = isl_set_read_from_str(ctx, str);
7729 if (equal >= 0 && equal)
7730 equal = isl_set_is_equal(set1, set2);
7731 isl_set_free(set: set1);
7732 isl_set_free(set: set2);
7733
7734 isl_set_free(set);
7735
7736 if (equal < 0)
7737 return -1;
7738 if (!equal)
7739 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7740
7741 /* Check that solutions are properly merged. */
7742 str = "[n] -> { [a, b, c] : c >= -4a - 2b and "
7743 "c <= -1 + n - 4a - 2b and c >= -2b and "
7744 "4a >= -4 + n and c >= 0 }";
7745 set = isl_set_read_from_str(ctx, str);
7746 pwaff = isl_set_dim_min(set, pos: 2);
7747 set1 = isl_set_from_pw_aff(pwaff);
7748 str = "[n] -> { [(0)] : n >= 1 }";
7749 set2 = isl_set_read_from_str(ctx, str);
7750 equal = isl_set_is_equal(set1, set2);
7751 isl_set_free(set: set1);
7752 isl_set_free(set: set2);
7753
7754 if (equal < 0)
7755 return -1;
7756 if (!equal)
7757 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7758
7759 /* Check that empty solution lie in the right space. */
7760 str = "[n] -> { [t,a] : 1 = 0 }";
7761 set = isl_set_read_from_str(ctx, str);
7762 pwaff = isl_set_dim_max(set, pos: 0);
7763 set1 = isl_set_from_pw_aff(pwaff);
7764 str = "[n] -> { [t] : 1 = 0 }";
7765 set2 = isl_set_read_from_str(ctx, str);
7766 equal = isl_set_is_equal(set1, set2);
7767 isl_set_free(set: set1);
7768 isl_set_free(set: set2);
7769
7770 if (equal < 0)
7771 return -1;
7772 if (!equal)
7773 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7774
7775 return 0;
7776}
7777
7778/* Basic test for isl_pw_multi_aff_product.
7779 *
7780 * Check that multiple pieces are properly handled.
7781 */
7782static int test_product_pma(isl_ctx *ctx)
7783{
7784 isl_stat equal;
7785 const char *str;
7786 isl_pw_multi_aff *pma1, *pma2;
7787
7788 str = "{ A[i] -> B[1] : i < 0; A[i] -> B[2] : i >= 0 }";
7789 pma1 = isl_pw_multi_aff_read_from_str(ctx, str);
7790 str = "{ C[] -> D[] }";
7791 pma2 = isl_pw_multi_aff_read_from_str(ctx, str);
7792 pma1 = isl_pw_multi_aff_product(pma1, pma2);
7793 str = "{ [A[i] -> C[]] -> [B[(1)] -> D[]] : i < 0;"
7794 "[A[i] -> C[]] -> [B[(2)] -> D[]] : i >= 0 }";
7795 equal = pw_multi_aff_check_plain_equal(obj: pma1, str);
7796 isl_pw_multi_aff_free(pma: pma1);
7797 if (equal < 0)
7798 return -1;
7799
7800 return 0;
7801}
7802
7803int test_product(isl_ctx *ctx)
7804{
7805 const char *str;
7806 isl_set *set;
7807 isl_union_set *uset1, *uset2;
7808 int ok;
7809
7810 str = "{ A[i] }";
7811 set = isl_set_read_from_str(ctx, str);
7812 set = isl_set_product(set1: set, set2: isl_set_copy(set));
7813 ok = isl_set_is_wrapping(set);
7814 isl_set_free(set);
7815 if (ok < 0)
7816 return -1;
7817 if (!ok)
7818 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7819
7820 str = "{ [] }";
7821 uset1 = isl_union_set_read_from_str(ctx, str);
7822 uset1 = isl_union_set_product(uset1, uset2: isl_union_set_copy(uset: uset1));
7823 str = "{ [[] -> []] }";
7824 uset2 = isl_union_set_read_from_str(ctx, str);
7825 ok = isl_union_set_is_equal(uset1, uset2);
7826 isl_union_set_free(uset: uset1);
7827 isl_union_set_free(uset: uset2);
7828 if (ok < 0)
7829 return -1;
7830 if (!ok)
7831 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7832
7833 if (test_product_pma(ctx) < 0)
7834 return -1;
7835
7836 return 0;
7837}
7838
7839/* Check that two sets are not considered disjoint just because
7840 * they have a different set of (named) parameters.
7841 */
7842static int test_disjoint(isl_ctx *ctx)
7843{
7844 const char *str;
7845 isl_set *set, *set2;
7846 int disjoint;
7847
7848 str = "[n] -> { [[]->[]] }";
7849 set = isl_set_read_from_str(ctx, str);
7850 str = "{ [[]->[]] }";
7851 set2 = isl_set_read_from_str(ctx, str);
7852 disjoint = isl_set_is_disjoint(set1: set, set2);
7853 isl_set_free(set);
7854 isl_set_free(set: set2);
7855 if (disjoint < 0)
7856 return -1;
7857 if (disjoint)
7858 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7859
7860 return 0;
7861}
7862
7863/* Inputs for isl_pw_multi_aff_is_equal tests.
7864 * "f1" and "f2" are the two function that need to be compared.
7865 * "equal" is the expected result.
7866 */
7867struct {
7868 int equal;
7869 const char *f1;
7870 const char *f2;
7871} pma_equal_tests[] = {
7872 { 1, "[N] -> { [floor(N/2)] : 0 <= N <= 1 }",
7873 "[N] -> { [0] : 0 <= N <= 1 }" },
7874 { 1, "[N] -> { [floor(N/2)] : 0 <= N <= 2 }",
7875 "[N] -> { [0] : 0 <= N <= 1; [1] : N = 2 }" },
7876 { 0, "[N] -> { [floor(N/2)] : 0 <= N <= 2 }",
7877 "[N] -> { [0] : 0 <= N <= 1 }" },
7878 { 0, "{ [NaN] }", "{ [NaN] }" },
7879};
7880
7881int test_equal(isl_ctx *ctx)
7882{
7883 int i;
7884 const char *str;
7885 isl_set *set, *set2;
7886 int equal;
7887
7888 str = "{ S_6[i] }";
7889 set = isl_set_read_from_str(ctx, str);
7890 str = "{ S_7[i] }";
7891 set2 = isl_set_read_from_str(ctx, str);
7892 equal = isl_set_is_equal(set1: set, set2);
7893 isl_set_free(set);
7894 isl_set_free(set: set2);
7895 if (equal < 0)
7896 return -1;
7897 if (equal)
7898 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
7899
7900 for (i = 0; i < ARRAY_SIZE(pma_equal_tests); ++i) {
7901 int expected = pma_equal_tests[i].equal;
7902 isl_pw_multi_aff *f1, *f2;
7903
7904 f1 = isl_pw_multi_aff_read_from_str(ctx, str: pma_equal_tests[i].f1);
7905 f2 = isl_pw_multi_aff_read_from_str(ctx, str: pma_equal_tests[i].f2);
7906 equal = isl_pw_multi_aff_is_equal(pma1: f1, pma2: f2);
7907 isl_pw_multi_aff_free(pma: f1);
7908 isl_pw_multi_aff_free(pma: f2);
7909 if (equal < 0)
7910 return -1;
7911 if (equal != expected)
7912 isl_die(ctx, isl_error_unknown,
7913 "unexpected equality result", return -1);
7914 }
7915
7916 return 0;
7917}
7918
7919static int test_plain_fixed(isl_ctx *ctx, __isl_take isl_map *map,
7920 enum isl_dim_type type, unsigned pos, int fixed)
7921{
7922 isl_bool test;
7923
7924 test = isl_map_plain_is_fixed(map, type, pos, NULL);
7925 isl_map_free(map);
7926 if (test < 0)
7927 return -1;
7928 if (test == fixed)
7929 return 0;
7930 if (fixed)
7931 isl_die(ctx, isl_error_unknown,
7932 "map not detected as fixed", return -1);
7933 else
7934 isl_die(ctx, isl_error_unknown,
7935 "map detected as fixed", return -1);
7936}
7937
7938int test_fixed(isl_ctx *ctx)
7939{
7940 const char *str;
7941 isl_map *map;
7942
7943 str = "{ [i] -> [i] }";
7944 map = isl_map_read_from_str(ctx, str);
7945 if (test_plain_fixed(ctx, map, type: isl_dim_out, pos: 0, fixed: 0))
7946 return -1;
7947 str = "{ [i] -> [1] }";
7948 map = isl_map_read_from_str(ctx, str);
7949 if (test_plain_fixed(ctx, map, type: isl_dim_out, pos: 0, fixed: 1))
7950 return -1;
7951 str = "{ S_1[p1] -> [o0] : o0 = -2 and p1 >= 1 and p1 <= 7 }";
7952 map = isl_map_read_from_str(ctx, str);
7953 if (test_plain_fixed(ctx, map, type: isl_dim_out, pos: 0, fixed: 1))
7954 return -1;
7955 map = isl_map_read_from_str(ctx, str);
7956 map = isl_map_neg(map);
7957 if (test_plain_fixed(ctx, map, type: isl_dim_out, pos: 0, fixed: 1))
7958 return -1;
7959
7960 return 0;
7961}
7962
7963struct isl_vertices_test_data {
7964 const char *set;
7965 int n;
7966 const char *vertex[6];
7967} vertices_tests[] = {
7968 { "{ A[t, i] : t = 12 and i >= 4 and i <= 12 }",
7969 2, { "{ A[12, 4] }", "{ A[12, 12] }" } },
7970 { "{ A[t, i] : t = 14 and i = 1 }",
7971 1, { "{ A[14, 1] }" } },
7972 { "[n, m] -> { [a, b, c] : b <= a and a <= n and b > 0 and c >= b and "
7973 "c <= m and m <= n and m > 0 }",
7974 6, {
7975 "[n, m] -> { [n, m, m] : 0 < m <= n }",
7976 "[n, m] -> { [n, 1, m] : 0 < m <= n }",
7977 "[n, m] -> { [n, 1, 1] : 0 < m <= n }",
7978 "[n, m] -> { [m, m, m] : 0 < m <= n }",
7979 "[n, m] -> { [1, 1, m] : 0 < m <= n }",
7980 "[n, m] -> { [1, 1, 1] : 0 < m <= n }"
7981 } },
7982 /* An input with implicit equality constraints among the parameters. */
7983 { "[N, M] -> { [a, b] : M >= 3 and 9 + 3M <= a <= 29 + 2N + 11M and "
7984 "2b >= M + a and 5 - 2N - M + a <= 2b <= 3 + a and "
7985 "3b >= 15 + a }",
7986 2, {
7987 "[N, M] -> { [(21), (12)] : M = 3 and N >= 0 }",
7988 "[N, M] -> { [(61 + 2N), (32 + N)] : M = 3 and N >= 0 }",
7989 }
7990 },
7991};
7992
7993/* Check that "vertex" corresponds to one of the vertices in data->vertex.
7994 */
7995static isl_stat find_vertex(__isl_take isl_vertex *vertex, void *user)
7996{
7997 struct isl_vertices_test_data *data = user;
7998 isl_ctx *ctx;
7999 isl_multi_aff *ma;
8000 isl_basic_set *bset;
8001 isl_pw_multi_aff *pma;
8002 int i;
8003 isl_bool equal;
8004
8005 ctx = isl_vertex_get_ctx(vertex);
8006 bset = isl_vertex_get_domain(vertex);
8007 ma = isl_vertex_get_expr(vertex);
8008 pma = isl_pw_multi_aff_alloc(set: isl_set_from_basic_set(bset), maff: ma);
8009
8010 for (i = 0; i < data->n; ++i) {
8011 isl_pw_multi_aff *pma_i;
8012
8013 pma_i = isl_pw_multi_aff_read_from_str(ctx, str: data->vertex[i]);
8014 equal = isl_pw_multi_aff_plain_is_equal(pma1: pma, pma2: pma_i);
8015 isl_pw_multi_aff_free(pma: pma_i);
8016
8017 if (equal < 0 || equal)
8018 break;
8019 }
8020
8021 isl_pw_multi_aff_free(pma);
8022 isl_vertex_free(vertex);
8023
8024 if (equal < 0)
8025 return isl_stat_error;
8026
8027 return equal ? isl_stat_ok : isl_stat_error;
8028}
8029
8030int test_vertices(isl_ctx *ctx)
8031{
8032 int i;
8033
8034 for (i = 0; i < ARRAY_SIZE(vertices_tests); ++i) {
8035 isl_basic_set *bset;
8036 isl_vertices *vertices;
8037 int ok = 1;
8038 isl_size n;
8039
8040 bset = isl_basic_set_read_from_str(ctx, str: vertices_tests[i].set);
8041 vertices = isl_basic_set_compute_vertices(bset);
8042 n = isl_vertices_get_n_vertices(vertices);
8043 if (vertices_tests[i].n != n)
8044 ok = 0;
8045 if (isl_vertices_foreach_vertex(vertices, fn: &find_vertex,
8046 user: &vertices_tests[i]) < 0)
8047 ok = 0;
8048 isl_vertices_free(vertices);
8049 isl_basic_set_free(bset);
8050
8051 if (n < 0)
8052 return -1;
8053 if (!ok)
8054 isl_die(ctx, isl_error_unknown, "unexpected vertices",
8055 return -1);
8056 }
8057
8058 return 0;
8059}
8060
8061/* Inputs for basic tests of unary operations on isl_union_map.
8062 * "fn" is the function that is being tested.
8063 * "arg" is a string description of the input.
8064 * "res" is a string description of the expected result.
8065 */
8066static struct {
8067 __isl_give isl_union_map *(*fn)(__isl_take isl_union_map *umap);
8068 const char *arg;
8069 const char *res;
8070} umap_un_tests[] = {
8071 { &isl_union_map_range_reverse,
8072 "{ A[] -> [B[] -> C[]]; A[] -> B[]; A[0] -> N[B[1] -> B[2]] }",
8073 "{ A[] -> [C[] -> B[]]; A[0] -> N[B[2] -> B[1]] }" },
8074 { &isl_union_map_range_reverse,
8075 "{ A[] -> N[B[] -> C[]] }",
8076 "{ A[] -> [C[] -> B[]] }" },
8077 { &isl_union_map_range_reverse,
8078 "{ A[] -> N[B[x] -> B[y]] }",
8079 "{ A[] -> N[B[*] -> B[*]] }" },
8080};
8081
8082/* Perform basic tests of unary operations on isl_union_map.
8083 */
8084static isl_stat test_un_union_map(isl_ctx *ctx)
8085{
8086 int i;
8087
8088 for (i = 0; i < ARRAY_SIZE(umap_un_tests); ++i) {
8089 const char *str;
8090 isl_union_map *umap, *res;
8091 isl_bool equal;
8092
8093 str = umap_un_tests[i].arg;
8094 umap = isl_union_map_read_from_str(ctx, str);
8095 str = umap_un_tests[i].res;
8096 res = isl_union_map_read_from_str(ctx, str);
8097 umap = umap_un_tests[i].fn(umap);
8098 equal = isl_union_map_is_equal(umap1: umap, umap2: res);
8099 isl_union_map_free(umap);
8100 isl_union_map_free(umap: res);
8101 if (equal < 0)
8102 return isl_stat_error;
8103 if (!equal)
8104 isl_die(ctx, isl_error_unknown,
8105 "unexpected result", return isl_stat_error);
8106 }
8107
8108 return isl_stat_ok;
8109}
8110
8111/* Inputs for basic tests of binary operations on isl_union_map.
8112 * "fn" is the function that is being tested.
8113 * "arg1" and "arg2" are string descriptions of the inputs.
8114 * "res" is a string description of the expected result.
8115 */
8116static struct {
8117 __isl_give isl_union_map *(*fn)(__isl_take isl_union_map *umap1,
8118 __isl_take isl_union_map *umap2);
8119 const char *arg1;
8120 const char *arg2;
8121 const char *res;
8122} umap_bin_tests[] = {
8123 { &isl_union_map_intersect,
8124 "[n] -> { A[i] -> [] : 0 <= i <= n; B[] -> [] }",
8125 "[m] -> { A[i] -> [] : 0 <= i <= m; C[] -> [] }",
8126 "[m, n] -> { A[i] -> [] : 0 <= i <= n and i <= m }" },
8127 { &isl_union_map_intersect_domain_factor_domain,
8128 "{ [A[i] -> B[i + 1]] -> C[i + 2] }",
8129 "[N] -> { B[i] -> C[N] }",
8130 "{ }" },
8131 { &isl_union_map_intersect_domain_factor_domain,
8132 "{ [A[i] -> B[i + 1]] -> C[i + 2] }",
8133 "[N] -> { A[i] -> C[N] }",
8134 "[N] -> { [A[N - 2] -> B[N - 1]] -> C[N] }" },
8135 { &isl_union_map_intersect_domain_factor_domain,
8136 "{ T[A[i] -> B[i + 1]] -> C[i + 2] }",
8137 "[N] -> { A[i] -> C[N] }",
8138 "[N] -> { T[A[N - 2] -> B[N - 1]] -> C[N] }" },
8139 { &isl_union_map_intersect_domain_factor_range,
8140 "{ [A[i] -> B[i + 1]] -> C[i + 2] }",
8141 "[N] -> { B[i] -> C[N] }",
8142 "[N] -> { [A[N - 2] -> B[N - 1]] -> C[N] }" },
8143 { &isl_union_map_intersect_domain_factor_range,
8144 "{ T[A[i] -> B[i + 1]] -> C[i + 2] }",
8145 "[N] -> { B[i] -> C[N] }",
8146 "[N] -> { T[A[N - 2] -> B[N - 1]] -> C[N] }" },
8147 { &isl_union_map_intersect_domain_factor_range,
8148 "{ [A[i] -> B[i + 1]] -> C[i + 2] }",
8149 "[N] -> { A[i] -> C[N] }",
8150 "{ }" },
8151 { &isl_union_map_intersect_range_factor_domain,
8152 "{ A[i] -> [B[i + 1] -> C[i + 2]] }",
8153 "[N] -> { A[i] -> B[N] }",
8154 "[N] -> { A[N - 1] -> [B[N] -> C[N + 1]] }" },
8155 { &isl_union_map_intersect_range_factor_domain,
8156 "{ A[i] -> T[B[i + 1] -> C[i + 2]] }",
8157 "[N] -> { A[i] -> B[N] }",
8158 "[N] -> { A[N - 1] -> T[B[N] -> C[N + 1]] }" },
8159 { &isl_union_map_intersect_range_factor_domain,
8160 "{ A[i] -> [B[i + 1] -> C[i + 2]] }",
8161 "[N] -> { A[i] -> C[N] }",
8162 "{ }" },
8163 { &isl_union_map_intersect_range_factor_range,
8164 "{ A[i] -> [B[i + 1] -> C[i + 2]] }",
8165 "[N] -> { A[i] -> C[N] }",
8166 "[N] -> { A[N - 2] -> [B[N - 1] -> C[N]] }" },
8167 { &isl_union_map_intersect_range_factor_range,
8168 "{ A[i] -> T[B[i + 1] -> C[i + 2]] }",
8169 "[N] -> { A[i] -> C[N] }",
8170 "[N] -> { A[N - 2] -> T[B[N - 1] -> C[N]] }" },
8171 { &isl_union_map_intersect_range_factor_range,
8172 "{ A[i] -> [B[i + 1] -> C[i + 2]] }",
8173 "[N] -> { A[i] -> B[N] }",
8174 "{ }" },
8175};
8176
8177/* Perform basic tests of binary operations on isl_union_map.
8178 */
8179static isl_stat test_bin_union_map(isl_ctx *ctx)
8180{
8181 int i;
8182
8183 for (i = 0; i < ARRAY_SIZE(umap_bin_tests); ++i) {
8184 const char *str;
8185 isl_union_map *umap1, *umap2, *res;
8186 isl_bool equal;
8187
8188 str = umap_bin_tests[i].arg1;
8189 umap1 = isl_union_map_read_from_str(ctx, str);
8190 str = umap_bin_tests[i].arg2;
8191 umap2 = isl_union_map_read_from_str(ctx, str);
8192 str = umap_bin_tests[i].res;
8193 res = isl_union_map_read_from_str(ctx, str);
8194 umap1 = umap_bin_tests[i].fn(umap1, umap2);
8195 equal = isl_union_map_is_equal(umap1, umap2: res);
8196 isl_union_map_free(umap: umap1);
8197 isl_union_map_free(umap: res);
8198 if (equal < 0)
8199 return isl_stat_error;
8200 if (!equal)
8201 isl_die(ctx, isl_error_unknown,
8202 "unexpected result", return isl_stat_error);
8203 }
8204
8205 return isl_stat_ok;
8206}
8207
8208/* Check that isl_union_set_contains finds space independently
8209 * of the parameters.
8210 */
8211static isl_stat test_union_set_contains(isl_ctx *ctx)
8212{
8213 const char *str;
8214 isl_bool ok;
8215 isl_space *space;
8216 isl_id *id;
8217 isl_union_set *uset;
8218
8219 str = "[N] -> { A[0:N]; B[*,*] }";
8220 uset = isl_union_set_read_from_str(ctx, str);
8221 space = isl_space_unit(ctx);
8222 id = isl_id_alloc(ctx, name: "A", NULL);
8223 space = isl_space_add_named_tuple_id_ui(space, tuple_id: id, dim: 1);
8224 ok = isl_union_set_contains(uset, space);
8225 isl_space_free(space);
8226 isl_union_set_free(uset);
8227
8228 if (ok < 0)
8229 return isl_stat_error;
8230 if (!ok)
8231 isl_die(ctx, isl_error_unknown,
8232 "unexpected result", return isl_stat_error);
8233
8234 return isl_stat_ok;
8235}
8236
8237/* Perform basic tests of operations on isl_union_map or isl_union_set.
8238 */
8239static int test_union_map(isl_ctx *ctx)
8240{
8241 if (test_un_union_map(ctx) < 0)
8242 return -1;
8243 if (test_bin_union_map(ctx) < 0)
8244 return -1;
8245 if (test_union_set_contains(ctx) < 0)
8246 return -1;
8247 return 0;
8248}
8249
8250#undef BASE
8251#define BASE union_pw_qpolynomial
8252#include "isl_test_plain_equal_templ.c"
8253
8254/* Check that the result of applying "fn" to "a" and "b"
8255 * in (obviously) equal to "res".
8256 */
8257static isl_stat test_union_pw_op(isl_ctx *ctx, const char *a, const char *b,
8258 __isl_give isl_union_pw_qpolynomial *(*fn)(
8259 __isl_take isl_union_pw_qpolynomial *upwqp1,
8260 __isl_take isl_union_pw_qpolynomial *upwqp2),
8261 const char *res)
8262{
8263 isl_stat r;
8264 isl_union_pw_qpolynomial *upwqp1, *upwqp2;
8265
8266 upwqp1 = isl_union_pw_qpolynomial_read_from_str(ctx, str: a);
8267 upwqp2 = isl_union_pw_qpolynomial_read_from_str(ctx, str: b);
8268 upwqp1 = fn(upwqp1, upwqp2);
8269 r = union_pw_qpolynomial_check_plain_equal(obj: upwqp1, str: res);
8270 isl_union_pw_qpolynomial_free(upwqp: upwqp1);
8271
8272 return r;
8273}
8274
8275int test_union_pw(isl_ctx *ctx)
8276{
8277 int equal;
8278 const char *str;
8279 isl_union_set *uset;
8280 isl_union_pw_qpolynomial *upwqp1, *upwqp2;
8281 const char *a, *b;
8282
8283 str = "{ [x] -> x^2 }";
8284 upwqp1 = isl_union_pw_qpolynomial_read_from_str(ctx, str);
8285 upwqp2 = isl_union_pw_qpolynomial_copy(upwqp: upwqp1);
8286 uset = isl_union_pw_qpolynomial_domain(upwqp: upwqp1);
8287 upwqp1 = isl_union_pw_qpolynomial_copy(upwqp: upwqp2);
8288 upwqp1 = isl_union_pw_qpolynomial_intersect_domain(upwpq: upwqp1, uset);
8289 equal = isl_union_pw_qpolynomial_plain_is_equal(upwqp1, upwqp2);
8290 isl_union_pw_qpolynomial_free(upwqp: upwqp1);
8291 isl_union_pw_qpolynomial_free(upwqp: upwqp2);
8292 if (equal < 0)
8293 return -1;
8294 if (!equal)
8295 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
8296
8297 a = "{ A[x] -> x^2 : x >= 0; B[x] -> x }";
8298 b = "{ A[x] -> x }";
8299 str = "{ A[x] -> x^2 + x : x >= 0; A[x] -> x : x < 0; B[x] -> x }";
8300 if (test_union_pw_op(ctx, a, b, fn: &isl_union_pw_qpolynomial_add, res: str) < 0)
8301 return -1;
8302 str = "{ A[x] -> x^2 - x : x >= 0; A[x] -> -x : x < 0; B[x] -> x }";
8303 if (test_union_pw_op(ctx, a, b, fn: &isl_union_pw_qpolynomial_sub, res: str) < 0)
8304 return -1;
8305
8306 str = "{ A[x] -> 0 }";
8307 a = "{ A[x] -> 1 }";
8308 b = "{ A[x] -> -1 }";
8309 if (test_union_pw_op(ctx, a, b, fn: &isl_union_pw_qpolynomial_add, res: str) < 0)
8310 return -1;
8311 a = "{ A[x] -> 1 }";
8312 b = "{ A[x] -> 1 }";
8313 if (test_union_pw_op(ctx, a, b, fn: &isl_union_pw_qpolynomial_sub, res: str) < 0)
8314 return -1;
8315
8316 return 0;
8317}
8318
8319/* Inputs for basic tests of functions that select
8320 * subparts of the domain of an isl_multi_union_pw_aff.
8321 * "fn" is the function that is tested.
8322 * "arg" is a string description of the input.
8323 * "res" is a string description of the expected result.
8324 */
8325struct {
8326 __isl_give isl_union_set *(*fn)(
8327 __isl_take isl_multi_union_pw_aff *mupa);
8328 const char *arg;
8329 const char *res;
8330} un_locus_tests[] = {
8331 { &isl_multi_union_pw_aff_zero_union_set,
8332 "F[{ A[i,j] -> [i]; B[i,j] -> [i] }]",
8333 "{ A[0,j]; B[0,j] }" },
8334 { &isl_multi_union_pw_aff_zero_union_set,
8335 "F[{ A[i,j] -> [i-j]; B[i,j] -> [i-j] : i >= 0 }]",
8336 "{ A[i,i]; B[i,i] : i >= 0 }" },
8337 { &isl_multi_union_pw_aff_zero_union_set,
8338 "(F[] : { A[i,j]; B[i,i] : i >= 0 })",
8339 "{ A[i,j]; B[i,i] : i >= 0 }" },
8340};
8341
8342/* Perform some basic tests of functions that select
8343 * subparts of the domain of an isl_multi_union_pw_aff.
8344 */
8345static int test_un_locus(isl_ctx *ctx)
8346{
8347 int i;
8348 isl_bool ok;
8349 isl_union_set *uset, *res;
8350 isl_multi_union_pw_aff *mupa;
8351
8352 for (i = 0; i < ARRAY_SIZE(un_locus_tests); ++i) {
8353 mupa = isl_multi_union_pw_aff_read_from_str(ctx,
8354 str: un_locus_tests[i].arg);
8355 res = isl_union_set_read_from_str(ctx, str: un_locus_tests[i].res);
8356 uset = un_locus_tests[i].fn(mupa);
8357 ok = isl_union_set_is_equal(uset1: uset, uset2: res);
8358 isl_union_set_free(uset);
8359 isl_union_set_free(uset: res);
8360 if (ok < 0)
8361 return -1;
8362 if (!ok)
8363 isl_die(ctx, isl_error_unknown,
8364 "unexpected result", return -1);
8365 }
8366
8367 return 0;
8368}
8369
8370/* Inputs for basic tests of functions that select
8371 * subparts of an isl_union_map based on a relation
8372 * specified by an isl_multi_union_pw_aff.
8373 * "fn" is the function that is tested.
8374 * "arg1" and "arg2" are string descriptions of the inputs.
8375 * "res" is a string description of the expected result.
8376 */
8377struct {
8378 __isl_give isl_union_map *(*fn)(
8379 __isl_take isl_union_map *umap,
8380 __isl_take isl_multi_union_pw_aff *mupa);
8381 const char *arg1;
8382 const char *arg2;
8383 const char *res;
8384} bin_locus_tests[] = {
8385 { &isl_union_map_eq_at_multi_union_pw_aff,
8386 "{ A[i,j] -> B[i',j'] }",
8387 "F[{ A[i,j] -> [i]; B[i,j] -> [i] }]",
8388 "{ A[i,j] -> B[i,j'] }" },
8389 { &isl_union_map_eq_at_multi_union_pw_aff,
8390 "{ A[i,j] -> B[i',j'] }",
8391 "F[{ A[i,j] -> [i]; B[i,j] -> [i] }, "
8392 "{ A[i,j] -> [j]; B[i,j] -> [j] }]",
8393 "{ A[i,j] -> B[i,j] }" },
8394 { &isl_union_map_eq_at_multi_union_pw_aff,
8395 "{ A[i,j] -> B[i',j']; A[i,j] -> C[i',j'] }",
8396 "F[{ A[i,j] -> [i]; B[i,j] -> [i] }]",
8397 "{ A[i,j] -> B[i,j'] }" },
8398 { &isl_union_map_eq_at_multi_union_pw_aff,
8399 "{ A[i,j] -> B[i',j']; A[i,j] -> C[i',j'] }",
8400 "F[{ A[i,j] -> [i]; B[i,j] -> [i]; C[i,j] -> [0] }]",
8401 "{ A[i,j] -> B[i,j']; A[0,j] -> C[i',j'] }" },
8402 { &isl_union_map_eq_at_multi_union_pw_aff,
8403 "{ A[i,j] -> B[i',j'] }",
8404 "F[{ A[i,j] -> [i] : i > j; B[i,j] -> [i] }]",
8405 "{ A[i,j] -> B[i,j'] : i > j }" },
8406 { &isl_union_map_lex_le_at_multi_union_pw_aff,
8407 "{ A[i,j] -> B[i',j'] }",
8408 "F[{ A[i,j] -> [i]; B[i,j] -> [i] }, "
8409 "{ A[i,j] -> [j]; B[i,j] -> [j] }]",
8410 "{ A[i,j] -> B[i',j'] : i,j <<= i',j' }" },
8411 { &isl_union_map_lex_lt_at_multi_union_pw_aff,
8412 "{ A[i,j] -> B[i',j'] }",
8413 "F[{ A[i,j] -> [i]; B[i,j] -> [i] }, "
8414 "{ A[i,j] -> [j]; B[i,j] -> [j] }]",
8415 "{ A[i,j] -> B[i',j'] : i,j << i',j' }" },
8416 { &isl_union_map_lex_ge_at_multi_union_pw_aff,
8417 "{ A[i,j] -> B[i',j'] }",
8418 "F[{ A[i,j] -> [i]; B[i,j] -> [i] }, "
8419 "{ A[i,j] -> [j]; B[i,j] -> [j] }]",
8420 "{ A[i,j] -> B[i',j'] : i,j >>= i',j' }" },
8421 { &isl_union_map_lex_gt_at_multi_union_pw_aff,
8422 "{ A[i,j] -> B[i',j'] }",
8423 "F[{ A[i,j] -> [i]; B[i,j] -> [i] }, "
8424 "{ A[i,j] -> [j]; B[i,j] -> [j] }]",
8425 "{ A[i,j] -> B[i',j'] : i,j >> i',j' }" },
8426 { &isl_union_map_eq_at_multi_union_pw_aff,
8427 "{ A[i,j] -> B[i',j']; A[i,j] -> C[i',j'] }",
8428 "(F[] : { A[i,j]; B[i,j] })",
8429 "{ A[i,j] -> B[i',j'] }" },
8430 { &isl_union_map_eq_at_multi_union_pw_aff,
8431 "{ A[i,j] -> B[i',j'] }",
8432 "(F[] : { A[i,j] : i > j; B[i,j] : i < j })",
8433 "{ A[i,j] -> B[i',j'] : i > j and i' < j' }" },
8434 { &isl_union_map_eq_at_multi_union_pw_aff,
8435 "[N] -> { A[i,j] -> B[i',j'] : i,i' <= N }",
8436 "(F[] : { A[i,j] : i > j; B[i,j] : i < j })",
8437 "[N] -> { A[i,j] -> B[i',j'] : i > j and i' < j' and i,i' <= N }" },
8438 { &isl_union_map_eq_at_multi_union_pw_aff,
8439 "{ A[i,j] -> B[i',j'] }",
8440 "[N] -> (F[] : { A[i,j] : i < N; B[i,j] : i < N })",
8441 "[N] -> { A[i,j] -> B[i',j'] : i,i' < N }" },
8442 { &isl_union_map_eq_at_multi_union_pw_aff,
8443 "{ A[i,j] -> B[i',j'] }",
8444 "[N] -> (F[] : { : N >= 0 })",
8445 "[N] -> { A[i,j] -> B[i',j'] : N >= 0 }" },
8446};
8447
8448/* Perform some basic tests of functions that select
8449 * subparts of an isl_union_map based on a relation
8450 * specified by an isl_multi_union_pw_aff.
8451 */
8452static int test_bin_locus(isl_ctx *ctx)
8453{
8454 int i;
8455 isl_bool ok;
8456 isl_union_map *umap, *res;
8457 isl_multi_union_pw_aff *mupa;
8458
8459 for (i = 0; i < ARRAY_SIZE(bin_locus_tests); ++i) {
8460 umap = isl_union_map_read_from_str(ctx,
8461 str: bin_locus_tests[i].arg1);
8462 mupa = isl_multi_union_pw_aff_read_from_str(ctx,
8463 str: bin_locus_tests[i].arg2);
8464 res = isl_union_map_read_from_str(ctx, str: bin_locus_tests[i].res);
8465 umap = bin_locus_tests[i].fn(umap, mupa);
8466 ok = isl_union_map_is_equal(umap1: umap, umap2: res);
8467 isl_union_map_free(umap);
8468 isl_union_map_free(umap: res);
8469 if (ok < 0)
8470 return -1;
8471 if (!ok)
8472 isl_die(ctx, isl_error_unknown,
8473 "unexpected result", return -1);
8474 }
8475
8476 return 0;
8477}
8478
8479/* Inputs for basic tests of functions that determine
8480 * the part of the domain where two isl_multi_aff objects
8481 * related to each other in a specific way.
8482 * "fn" is the function that is being tested.
8483 * "arg1" and "arg2" are string descriptions of the inputs.
8484 * "res" is a string description of the expected result.
8485 */
8486static struct {
8487 __isl_give isl_set *(*fn)(__isl_take isl_multi_aff *ma1,
8488 __isl_take isl_multi_aff *ma2);
8489 const char *arg1;
8490 const char *arg2;
8491 const char *res;
8492} bin_locus_ma_tests[] = {
8493 { &isl_multi_aff_lex_le_set, "{ [] }", "{ [] }", "{ : }" },
8494 { &isl_multi_aff_lex_lt_set, "{ [] }", "{ [] }", "{ : false }" },
8495 { &isl_multi_aff_lex_le_set,
8496 "{ A[i] -> [i] }", "{ A[i] -> [0] }",
8497 "{ A[i] : i <= 0 }" },
8498 { &isl_multi_aff_lex_lt_set,
8499 "{ A[i] -> [i] }", "{ A[i] -> [0] }",
8500 "{ A[i] : i < 0 }" },
8501 { &isl_multi_aff_lex_le_set,
8502 "{ A[i] -> [i, i] }", "{ A[i] -> [0, 0] }",
8503 "{ A[i] : i <= 0 }" },
8504 { &isl_multi_aff_lex_le_set,
8505 "{ A[i] -> [i, 0] }", "{ A[i] -> [0, 0] }",
8506 "{ A[i] : i <= 0 }" },
8507 { &isl_multi_aff_lex_le_set,
8508 "{ A[i] -> [i, 1] }", "{ A[i] -> [0, 0] }",
8509 "{ A[i] : i < 0 }" },
8510};
8511
8512/* Perform some basic tests of functions that determine
8513 * the part of the domain where two isl_multi_aff objects
8514 * related to each other in a specific way.
8515 */
8516static isl_stat test_bin_locus_ma(isl_ctx *ctx)
8517{
8518 int i;
8519
8520 for (i = 0; i < ARRAY_SIZE(bin_locus_ma_tests); ++i) {
8521 const char *str;
8522 isl_bool ok;
8523 isl_multi_aff *ma1, *ma2;
8524 isl_set *set, *res;
8525
8526 str = bin_locus_ma_tests[i].arg1;
8527 ma1 = isl_multi_aff_read_from_str(ctx, str);
8528 str = bin_locus_ma_tests[i].arg2;
8529 ma2 = isl_multi_aff_read_from_str(ctx, str);
8530 res = isl_set_read_from_str(ctx, str: bin_locus_ma_tests[i].res);
8531 set = bin_locus_ma_tests[i].fn(ma1, ma2);
8532 ok = isl_set_is_equal(set1: set, set2: res);
8533 isl_set_free(set);
8534 isl_set_free(set: res);
8535 if (ok < 0)
8536 return isl_stat_error;
8537 if (!ok)
8538 isl_die(ctx, isl_error_unknown,
8539 "unexpected result", return isl_stat_error);
8540 }
8541
8542 return isl_stat_ok;
8543}
8544
8545/* Perform basic locus tests.
8546 */
8547static int test_locus(isl_ctx *ctx)
8548{
8549 if (test_un_locus(ctx) < 0)
8550 return -1;
8551 if (test_bin_locus(ctx) < 0)
8552 return -1;
8553 if (test_bin_locus_ma(ctx) < 0)
8554 return -1;
8555 return 0;
8556}
8557
8558/* Test that isl_union_pw_qpolynomial_eval picks up the function
8559 * defined over the correct domain space.
8560 */
8561static int test_eval_1(isl_ctx *ctx)
8562{
8563 const char *str;
8564 isl_point *pnt;
8565 isl_set *set;
8566 isl_union_pw_qpolynomial *upwqp;
8567 isl_val *v;
8568 int cmp;
8569
8570 str = "{ A[x] -> x^2; B[x] -> -x^2 }";
8571 upwqp = isl_union_pw_qpolynomial_read_from_str(ctx, str);
8572 str = "{ A[6] }";
8573 set = isl_set_read_from_str(ctx, str);
8574 pnt = isl_set_sample_point(set);
8575 v = isl_union_pw_qpolynomial_eval(upwqp, pnt);
8576 cmp = isl_val_cmp_si(v, i: 36);
8577 isl_val_free(v);
8578
8579 if (!v)
8580 return -1;
8581 if (cmp != 0)
8582 isl_die(ctx, isl_error_unknown, "unexpected value", return -1);
8583
8584 return 0;
8585}
8586
8587/* Check that isl_qpolynomial_eval handles getting called on a void point.
8588 */
8589static int test_eval_2(isl_ctx *ctx)
8590{
8591 const char *str;
8592 isl_point *pnt;
8593 isl_set *set;
8594 isl_qpolynomial *qp;
8595 isl_val *v;
8596 isl_bool ok;
8597
8598 str = "{ A[x] -> [x] }";
8599 qp = isl_qpolynomial_from_aff(aff: isl_aff_read_from_str(ctx, str));
8600 str = "{ A[x] : false }";
8601 set = isl_set_read_from_str(ctx, str);
8602 pnt = isl_set_sample_point(set);
8603 v = isl_qpolynomial_eval(qp, pnt);
8604 ok = isl_val_is_nan(v);
8605 isl_val_free(v);
8606
8607 if (ok < 0)
8608 return -1;
8609 if (!ok)
8610 isl_die(ctx, isl_error_unknown, "expecting NaN", return -1);
8611
8612 return 0;
8613}
8614
8615/* Check that a polynomial (without local variables) can be evaluated
8616 * in a rational point.
8617 */
8618static isl_stat test_eval_3(isl_ctx *ctx)
8619{
8620 isl_pw_qpolynomial *pwqp;
8621 isl_point *pnt;
8622 isl_val *v;
8623 isl_stat r;
8624
8625 pwqp = isl_pw_qpolynomial_read_from_str(ctx, str: "{ [x] -> x^2 }");
8626 pnt = isl_point_zero(space: isl_pw_qpolynomial_get_domain_space(pwqp));
8627 v = isl_val_read_from_str(ctx, str: "1/2");
8628 pnt = isl_point_set_coordinate_val(pnt, type: isl_dim_set, pos: 0, v);
8629 v = isl_pw_qpolynomial_eval(pwqp, pnt);
8630 r = val_check_equal(val: v, str: "1/4");
8631 isl_val_free(v);
8632
8633 return r;
8634}
8635
8636/* Inputs for isl_pw_aff_eval test.
8637 * "f" is the affine function.
8638 * "p" is the point where the function should be evaluated.
8639 * "res" is the expected result.
8640 */
8641struct {
8642 const char *f;
8643 const char *p;
8644 const char *res;
8645} aff_eval_tests[] = {
8646 { "{ [i] -> [2 * i] }", "{ [4] }", "8" },
8647 { "{ [i] -> [2 * i] }", "{ [x] : false }", "NaN" },
8648 { "{ [i] -> [i + floor(i/2) + floor(i/3)] }", "{ [0] }", "0" },
8649 { "{ [i] -> [i + floor(i/2) + floor(i/3)] }", "{ [1] }", "1" },
8650 { "{ [i] -> [i + floor(i/2) + floor(i/3)] }", "{ [2] }", "3" },
8651 { "{ [i] -> [i + floor(i/2) + floor(i/3)] }", "{ [3] }", "5" },
8652 { "{ [i] -> [i + floor(i/2) + floor(i/3)] }", "{ [4] }", "7" },
8653 { "{ [i] -> [floor((3 * floor(i/2))/5)] }", "{ [0] }", "0" },
8654 { "{ [i] -> [floor((3 * floor(i/2))/5)] }", "{ [1] }", "0" },
8655 { "{ [i] -> [floor((3 * floor(i/2))/5)] }", "{ [2] }", "0" },
8656 { "{ [i] -> [floor((3 * floor(i/2))/5)] }", "{ [3] }", "0" },
8657 { "{ [i] -> [floor((3 * floor(i/2))/5)] }", "{ [4] }", "1" },
8658 { "{ [i] -> [floor((3 * floor(i/2))/5)] }", "{ [6] }", "1" },
8659 { "{ [i] -> [floor((3 * floor(i/2))/5)] }", "{ [8] }", "2" },
8660 { "{ [i] -> [i] : i > 0; [i] -> [-i] : i < 0 }", "{ [4] }", "4" },
8661 { "{ [i] -> [i] : i > 0; [i] -> [-i] : i < 0 }", "{ [-2] }", "2" },
8662 { "{ [i] -> [i] : i > 0; [i] -> [-i] : i < 0 }", "{ [0] }", "NaN" },
8663 { "[N] -> { [2 * N] }", "[N] -> { : N = 4 }", "8" },
8664 { "{ [i, j] -> [(i + j)/2] }", "{ [1, 1] }", "1" },
8665 { "{ [i, j] -> [(i + j)/2] }", "{ [1, 2] }", "3/2" },
8666 { "{ [i] -> [i] : i mod 2 = 0 }", "{ [4] }", "4" },
8667 { "{ [i] -> [i] : i mod 2 = 0 }", "{ [3] }", "NaN" },
8668 { "{ [i] -> [i] : i mod 2 = 0 }", "{ [x] : false }", "NaN" },
8669 { "[m, n] -> { [2m + 3n] }", "[n=1, m=10] -> { : }", "23" },
8670};
8671
8672/* Perform basic isl_pw_aff_eval tests.
8673 */
8674static int test_eval_aff(isl_ctx *ctx)
8675{
8676 int i;
8677
8678 for (i = 0; i < ARRAY_SIZE(aff_eval_tests); ++i) {
8679 isl_stat r;
8680 isl_pw_aff *pa;
8681 isl_set *set;
8682 isl_point *pnt;
8683 isl_val *v;
8684
8685 pa = isl_pw_aff_read_from_str(ctx, str: aff_eval_tests[i].f);
8686 set = isl_set_read_from_str(ctx, str: aff_eval_tests[i].p);
8687 pnt = isl_set_sample_point(set);
8688 v = isl_pw_aff_eval(pa, pnt);
8689 r = val_check_equal(val: v, str: aff_eval_tests[i].res);
8690 isl_val_free(v);
8691 if (r < 0)
8692 return -1;
8693 }
8694 return 0;
8695}
8696
8697/* Perform basic evaluation tests.
8698 */
8699static int test_eval(isl_ctx *ctx)
8700{
8701 if (test_eval_1(ctx) < 0)
8702 return -1;
8703 if (test_eval_2(ctx) < 0)
8704 return -1;
8705 if (test_eval_3(ctx) < 0)
8706 return -1;
8707 if (test_eval_aff(ctx) < 0)
8708 return -1;
8709 return 0;
8710}
8711
8712/* Descriptions of sets that are tested for reparsing after printing.
8713 */
8714const char *output_tests[] = {
8715 "{ [1, y] : 0 <= y <= 1; [x, -x] : 0 <= x <= 1 }",
8716 "{ [x] : 1 = 0 }",
8717 "{ [x] : false }",
8718 "{ [x] : x mod 2 = 0 }",
8719 "{ [x] : x mod 2 = 1 }",
8720 "{ [x, y] : x mod 2 = 0 and 3*floor(y/2) < x }",
8721 "{ [y, x] : x mod 2 = 0 and 3*floor(y/2) < x }",
8722 "{ [x, y] : x mod 2 = 0 and 3*floor(y/2) = x + y }",
8723 "{ [y, x] : x mod 2 = 0 and 3*floor(y/2) = x + y }",
8724 "[n] -> { [y, x] : 2*((x + 2y) mod 3) = n }",
8725 "{ [x, y] : (2*floor(x/3) + 3*floor(y/4)) mod 5 = x }",
8726};
8727
8728/* Check that printing a set and reparsing a set from the printed output
8729 * results in the same set.
8730 */
8731static int test_output_set(isl_ctx *ctx)
8732{
8733 int i;
8734 char *str;
8735 isl_set *set1, *set2;
8736 isl_bool equal;
8737
8738 for (i = 0; i < ARRAY_SIZE(output_tests); ++i) {
8739 set1 = isl_set_read_from_str(ctx, str: output_tests[i]);
8740 str = isl_set_to_str(set: set1);
8741 set2 = isl_set_read_from_str(ctx, str);
8742 free(ptr: str);
8743 equal = isl_set_is_equal(set1, set2);
8744 isl_set_free(set: set1);
8745 isl_set_free(set: set2);
8746 if (equal < 0)
8747 return -1;
8748 if (!equal)
8749 isl_die(ctx, isl_error_unknown,
8750 "parsed output not the same", return -1);
8751 }
8752
8753 return 0;
8754}
8755
8756/* Check that an isl_multi_aff is printed using a consistent space.
8757 */
8758static isl_stat test_output_ma(isl_ctx *ctx)
8759{
8760 char *str;
8761 isl_bool equal;
8762 isl_aff *aff;
8763 isl_multi_aff *ma, *ma2;
8764
8765 ma = isl_multi_aff_read_from_str(ctx, str: "{ [a, b] -> [a + b] }");
8766 aff = isl_aff_read_from_str(ctx, str: "{ [c, d] -> [c + d] }");
8767 ma = isl_multi_aff_set_aff(multi: ma, pos: 0, el: aff);
8768 str = isl_multi_aff_to_str(ma);
8769 ma2 = isl_multi_aff_read_from_str(ctx, str);
8770 free(ptr: str);
8771 equal = isl_multi_aff_plain_is_equal(multi1: ma, multi2: ma2);
8772 isl_multi_aff_free(multi: ma2);
8773 isl_multi_aff_free(multi: ma);
8774
8775 if (equal < 0)
8776 return isl_stat_error;
8777 if (!equal)
8778 isl_die(ctx, isl_error_unknown, "bad conversion",
8779 return isl_stat_error);
8780
8781 return isl_stat_ok;
8782}
8783
8784/* Check that an isl_multi_pw_aff is printed using a consistent space.
8785 */
8786static isl_stat test_output_mpa(isl_ctx *ctx)
8787{
8788 char *str;
8789 isl_bool equal;
8790 isl_pw_aff *pa;
8791 isl_multi_pw_aff *mpa, *mpa2;
8792
8793 mpa = isl_multi_pw_aff_read_from_str(ctx, str: "{ [a, b] -> [a + b] }");
8794 pa = isl_pw_aff_read_from_str(ctx, str: "{ [c, d] -> [c + d] }");
8795 mpa = isl_multi_pw_aff_set_pw_aff(multi: mpa, pos: 0, el: pa);
8796 str = isl_multi_pw_aff_to_str(mpa);
8797 mpa2 = isl_multi_pw_aff_read_from_str(ctx, str);
8798 free(ptr: str);
8799 equal = isl_multi_pw_aff_plain_is_equal(multi1: mpa, multi2: mpa2);
8800 isl_multi_pw_aff_free(multi: mpa2);
8801 isl_multi_pw_aff_free(multi: mpa);
8802
8803 if (equal < 0)
8804 return isl_stat_error;
8805 if (!equal)
8806 isl_die(ctx, isl_error_unknown, "bad conversion",
8807 return isl_stat_error);
8808
8809 return isl_stat_ok;
8810}
8811
8812int test_output(isl_ctx *ctx)
8813{
8814 char *s;
8815 const char *str;
8816 isl_pw_aff *pa;
8817 isl_printer *p;
8818 int equal;
8819
8820 if (test_output_set(ctx) < 0)
8821 return -1;
8822 if (test_output_ma(ctx) < 0)
8823 return -1;
8824 if (test_output_mpa(ctx) < 0)
8825 return -1;
8826
8827 str = "[x] -> { [1] : x % 4 <= 2; [2] : x = 3 }";
8828 pa = isl_pw_aff_read_from_str(ctx, str);
8829
8830 p = isl_printer_to_str(ctx);
8831 p = isl_printer_set_output_format(p, ISL_FORMAT_C);
8832 p = isl_printer_print_pw_aff(p, pwaff: pa);
8833 s = isl_printer_get_str(printer: p);
8834 isl_printer_free(printer: p);
8835 isl_pw_aff_free(pwaff: pa);
8836 if (!s)
8837 equal = -1;
8838 else
8839 equal = !strcmp(s1: s, s2: "4 * floord(x, 4) + 2 >= x ? 1 : 2");
8840 free(ptr: s);
8841 if (equal < 0)
8842 return -1;
8843 if (!equal)
8844 isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
8845
8846 return 0;
8847}
8848
8849int test_sample(isl_ctx *ctx)
8850{
8851 const char *str;
8852 isl_basic_set *bset1, *bset2;
8853 int empty, subset;
8854
8855 str = "{ [a, b, c, d, e, f, g, h, i, j, k] : "
8856 "3i >= 1073741823b - c - 1073741823e + f and c >= 0 and "
8857 "3i >= -1 + 3221225466b + c + d - 3221225466e - f and "
8858 "2e >= a - b and 3e <= 2a and 3k <= -a and f <= -1 + a and "
8859 "3i <= 4 - a + 4b + 2c - e - 2f and 3k <= -a + c - f and "
8860 "3h >= -2 + a and 3g >= -3 - a and 3k >= -2 - a and "
8861 "3i >= -2 - a - 2c + 3e + 2f and 3h <= a + c - f and "
8862 "3h >= a + 2147483646b + 2c - 2147483646e - 2f and "
8863 "3g <= -1 - a and 3i <= 1 + c + d - f and a <= 1073741823 and "
8864 "f >= 1 - a + 1073741822b + c + d - 1073741822e and "
8865 "3i >= 1 + 2b - 2c + e + 2f + 3g and "
8866 "1073741822f <= 1073741822 - a + 1073741821b + 1073741822c +"
8867 "d - 1073741821e and "
8868 "3j <= 3 - a + 3b and 3g <= -2 - 2b + c + d - e - f and "
8869 "3j >= 1 - a + b + 2e and "
8870 "3f >= -3 + a + 3221225462b + 3c + d - 3221225465e and "
8871 "3i <= 4 - a + 4b - e and "
8872 "f <= 1073741822 + 1073741822b - 1073741822e and 3h <= a and "
8873 "f >= 0 and 2e <= 4 - a + 5b - d and 2e <= a - b + d and "
8874 "c <= -1 + a and 3i >= -2 - a + 3e and "
8875 "1073741822e <= 1073741823 - a + 1073741822b + c and "
8876 "3g >= -4 + 3221225464b + 3c + d - 3221225467e - 3f and "
8877 "3i >= -1 + 3221225466b + 3c + d - 3221225466e - 3f and "
8878 "1073741823e >= 1 + 1073741823b - d and "
8879 "3i >= 1073741823b + c - 1073741823e - f and "
8880 "3i >= 1 + 2b + e + 3g }";
8881 bset1 = isl_basic_set_read_from_str(ctx, str);
8882 bset2 = isl_basic_set_sample(bset: isl_basic_set_copy(bset: bset1));
8883 empty = isl_basic_set_is_empty(bset: bset2);
8884 subset = isl_basic_set_is_subset(bset1: bset2, bset2: bset1);
8885 isl_basic_set_free(bset: bset1);
8886 isl_basic_set_free(bset: bset2);
8887 if (empty < 0 || subset < 0)
8888 return -1;
8889 if (empty)
8890 isl_die(ctx, isl_error_unknown, "point not found", return -1);
8891 if (!subset)
8892 isl_die(ctx, isl_error_unknown, "bad point found", return -1);
8893
8894 return 0;
8895}
8896
8897/* Perform a projection on a basic set that is known to be empty
8898 * but that has not been assigned a canonical representation.
8899 * Earlier versions of isl would run into a stack overflow
8900 * on this example.
8901 */
8902static int test_empty_projection(isl_ctx *ctx)
8903{
8904 const char *str;
8905 isl_bool empty;
8906 isl_basic_set *bset;
8907
8908 str = "{ [a, b, c, d, e, f, g, h] : 5f = 1 + 4a - b + 5c - d - 2e and "
8909 "3h = 2 + b + c and 14c >= 9 - 3a + 25b and "
8910 "4c <= 50 - 3a + 23b and 6b <= -39 + a and "
8911 "9g >= -6 + 3a + b + c and e < a + b - 2d and "
8912 "7d >= -5 + 2a + 2b and 5g >= -14 + a - 4b + d + 2e and "
8913 "9g <= -28 - 5b - 2c + 3d + 6e }";
8914 bset = isl_basic_set_read_from_str(ctx, str);
8915 empty = isl_basic_set_is_empty(bset);
8916 bset = isl_basic_set_params(bset);
8917 isl_basic_set_free(bset);
8918
8919 if (empty < 0)
8920 return -1;
8921
8922 return 0;
8923}
8924
8925int test_slice(isl_ctx *ctx)
8926{
8927 const char *str;
8928 isl_map *map;
8929 int equal;
8930
8931 str = "{ [i] -> [j] }";
8932 map = isl_map_read_from_str(ctx, str);
8933 map = isl_map_equate(map, type1: isl_dim_in, pos1: 0, type2: isl_dim_out, pos2: 0);
8934 equal = map_check_equal(map, str: "{ [i] -> [i] }");
8935 isl_map_free(map);
8936 if (equal < 0)
8937 return -1;
8938
8939 str = "{ [i] -> [j] }";
8940 map = isl_map_read_from_str(ctx, str);
8941 map = isl_map_equate(map, type1: isl_dim_in, pos1: 0, type2: isl_dim_in, pos2: 0);
8942 equal = map_check_equal(map, str: "{ [i] -> [j] }");
8943 isl_map_free(map);
8944 if (equal < 0)
8945 return -1;
8946
8947 str = "{ [i] -> [j] }";
8948 map = isl_map_read_from_str(ctx, str);
8949 map = isl_map_oppose(map, type1: isl_dim_in, pos1: 0, type2: isl_dim_out, pos2: 0);
8950 equal = map_check_equal(map, str: "{ [i] -> [-i] }");
8951 isl_map_free(map);
8952 if (equal < 0)
8953 return -1;
8954
8955 str = "{ [i] -> [j] }";
8956 map = isl_map_read_from_str(ctx, str);
8957 map = isl_map_oppose(map, type1: isl_dim_in, pos1: 0, type2: isl_dim_in, pos2: 0);
8958 equal = map_check_equal(map, str: "{ [0] -> [j] }");
8959 isl_map_free(map);
8960 if (equal < 0)
8961 return -1;
8962
8963 str = "{ [i] -> [j] }";
8964 map = isl_map_read_from_str(ctx, str);
8965 map = isl_map_order_gt(map, type1: isl_dim_in, pos1: 0, type2: isl_dim_out, pos2: 0);
8966 equal = map_check_equal(map, str: "{ [i] -> [j] : i > j }");
8967 isl_map_free(map);
8968 if (equal < 0)
8969 return -1;
8970
8971 str = "{ [i] -> [j] }";
8972 map = isl_map_read_from_str(ctx, str);
8973 map = isl_map_order_gt(map, type1: isl_dim_in, pos1: 0, type2: isl_dim_in, pos2: 0);
8974 equal = map_check_equal(map, str: "{ [i] -> [j] : false }");
8975 isl_map_free(map);
8976 if (equal < 0)
8977 return -1;
8978
8979 return 0;
8980}
8981
8982int test_eliminate(isl_ctx *ctx)
8983{
8984 const char *str;
8985 isl_map *map;
8986 int equal;
8987
8988 str = "{ [i] -> [j] : i = 2j }";
8989 map = isl_map_read_from_str(ctx, str);
8990 map = isl_map_eliminate(map, type: isl_dim_out, first: 0, n: 1);
8991 equal = map_check_equal(map, str: "{ [i] -> [j] : exists a : i = 2a }");
8992 isl_map_free(map);
8993 if (equal < 0)
8994 return -1;
8995
8996 return 0;
8997}
8998
8999/* Check basic functionality of isl_map_deltas_map.
9000 */
9001static int test_deltas_map(isl_ctx *ctx)
9002{
9003 const char *str;
9004 isl_map *map;
9005 int equal;
9006
9007 str = "{ A[i] -> A[i + 1] }";
9008 map = isl_map_read_from_str(ctx, str);
9009 map = isl_map_deltas_map(map);
9010 equal = map_check_equal(map, str: "{ [A[i] -> A[i + 1]] -> A[1] }");
9011 isl_map_free(map);
9012 if (equal < 0)
9013 return -1;
9014
9015 return 0;
9016}
9017
9018/* Check that isl_set_dim_residue_class detects that the values of j
9019 * in the set below are all odd and that it does not detect any spurious
9020 * strides.
9021 */
9022static int test_residue_class(isl_ctx *ctx)
9023{
9024 const char *str;
9025 isl_set *set;
9026 isl_int m, r;
9027 isl_stat res;
9028
9029 str = "{ [i,j] : j = 4 i + 1 and 0 <= i <= 100; "
9030 "[i,j] : j = 4 i + 3 and 500 <= i <= 600 }";
9031 set = isl_set_read_from_str(ctx, str);
9032 isl_int_init(m);
9033 isl_int_init(r);
9034 res = isl_set_dim_residue_class(set, pos: 1, modulo: &m, residue: &r);
9035 if (res >= 0 &&
9036 (isl_int_cmp_si(m, 2) != 0 || isl_int_cmp_si(r, 1) != 0))
9037 isl_die(ctx, isl_error_unknown, "incorrect residue class",
9038 res = isl_stat_error);
9039 isl_int_clear(r);
9040 isl_int_clear(m);
9041 isl_set_free(set);
9042
9043 return res;
9044}
9045
9046static int test_align_parameters_1(isl_ctx *ctx)
9047{
9048 const char *str;
9049 isl_space *space;
9050 isl_multi_aff *ma1, *ma2;
9051 int equal;
9052
9053 str = "{ A[B[] -> C[]] -> D[E[] -> F[]] }";
9054 ma1 = isl_multi_aff_read_from_str(ctx, str);
9055
9056 space = isl_space_params_alloc(ctx, nparam: 1);
9057 space = isl_space_set_dim_name(space, type: isl_dim_param, pos: 0, name: "N");
9058 ma1 = isl_multi_aff_align_params(multi: ma1, model: space);
9059
9060 str = "[N] -> { A[B[] -> C[]] -> D[E[] -> F[]] }";
9061 ma2 = isl_multi_aff_read_from_str(ctx, str);
9062
9063 equal = isl_multi_aff_plain_is_equal(multi1: ma1, multi2: ma2);
9064
9065 isl_multi_aff_free(multi: ma1);
9066 isl_multi_aff_free(multi: ma2);
9067
9068 if (equal < 0)
9069 return -1;
9070 if (!equal)
9071 isl_die(ctx, isl_error_unknown,
9072 "result not as expected", return -1);
9073
9074 return 0;
9075}
9076
9077/* Check the isl_multi_*_from_*_list operation in case inputs
9078 * have unaligned parameters.
9079 * In particular, older versions of isl would simply fail
9080 * (without printing any error message).
9081 */
9082static isl_stat test_align_parameters_2(isl_ctx *ctx)
9083{
9084 isl_space *space;
9085 isl_map *map;
9086 isl_aff *aff;
9087 isl_multi_aff *ma;
9088
9089 map = isl_map_read_from_str(ctx, str: "{ A[] -> M[x] }");
9090 space = isl_map_get_space(map);
9091 isl_map_free(map);
9092
9093 aff = isl_aff_read_from_str(ctx, str: "[N] -> { A[] -> [N] }");
9094 ma = isl_multi_aff_from_aff_list(space, list: isl_aff_list_from_aff(el: aff));
9095 isl_multi_aff_free(multi: ma);
9096
9097 if (!ma)
9098 return isl_stat_error;
9099 return isl_stat_ok;
9100}
9101
9102/* Perform basic parameter alignment tests.
9103 */
9104static int test_align_parameters(isl_ctx *ctx)
9105{
9106 if (test_align_parameters_1(ctx) < 0)
9107 return -1;
9108 if (test_align_parameters_2(ctx) < 0)
9109 return -1;
9110
9111 return 0;
9112}
9113
9114/* Check that isl_*_drop_unused_params actually drops the unused parameters
9115 * by comparing the result using isl_*_plain_is_equal.
9116 * Note that this assumes that isl_*_plain_is_equal does not consider
9117 * objects that only differ by unused parameters to be equal.
9118 */
9119int test_drop_unused_parameters(isl_ctx *ctx)
9120{
9121 const char *str_with, *str_without;
9122 isl_basic_set *bset1, *bset2;
9123 isl_set *set1, *set2;
9124 isl_pw_aff *pwa1, *pwa2;
9125 int equal;
9126
9127 str_with = "[n, m, o] -> { [m] }";
9128 str_without = "[m] -> { [m] }";
9129
9130 bset1 = isl_basic_set_read_from_str(ctx, str: str_with);
9131 bset2 = isl_basic_set_read_from_str(ctx, str: str_without);
9132 bset1 = isl_basic_set_drop_unused_params(bset: bset1);
9133 equal = isl_basic_set_plain_is_equal(bset1, bset2);
9134 isl_basic_set_free(bset: bset1);
9135 isl_basic_set_free(bset: bset2);
9136
9137 if (equal < 0)
9138 return -1;
9139 if (!equal)
9140 isl_die(ctx, isl_error_unknown,
9141 "result not as expected", return -1);
9142
9143 set1 = isl_set_read_from_str(ctx, str: str_with);
9144 set2 = isl_set_read_from_str(ctx, str: str_without);
9145 set1 = isl_set_drop_unused_params(set: set1);
9146 equal = isl_set_plain_is_equal(set1, set2);
9147 isl_set_free(set: set1);
9148 isl_set_free(set: set2);
9149
9150 if (equal < 0)
9151 return -1;
9152 if (!equal)
9153 isl_die(ctx, isl_error_unknown,
9154 "result not as expected", return -1);
9155
9156 pwa1 = isl_pw_aff_read_from_str(ctx, str: str_with);
9157 pwa2 = isl_pw_aff_read_from_str(ctx, str: str_without);
9158 pwa1 = isl_pw_aff_drop_unused_params(pa: pwa1);
9159 equal = isl_pw_aff_plain_is_equal(pwaff1: pwa1, pwaff2: pwa2);
9160 isl_pw_aff_free(pwaff: pwa1);
9161 isl_pw_aff_free(pwaff: pwa2);
9162
9163 if (equal < 0)
9164 return -1;
9165 if (!equal)
9166 isl_die(ctx, isl_error_unknown,
9167 "result not as expected", return -1);
9168
9169 return 0;
9170}
9171
9172static int test_list(isl_ctx *ctx)
9173{
9174 isl_id *a, *b, *c, *d, *id;
9175 isl_id_list *list;
9176 isl_size n;
9177 int ok;
9178
9179 a = isl_id_alloc(ctx, name: "a", NULL);
9180 b = isl_id_alloc(ctx, name: "b", NULL);
9181 c = isl_id_alloc(ctx, name: "c", NULL);
9182 d = isl_id_alloc(ctx, name: "d", NULL);
9183
9184 list = isl_id_list_alloc(ctx, n: 4);
9185 list = isl_id_list_add(list, el: b);
9186 list = isl_id_list_insert(list, pos: 0, el: a);
9187 list = isl_id_list_add(list, el: c);
9188 list = isl_id_list_add(list, el: d);
9189 list = isl_id_list_drop(list, first: 1, n: 1);
9190
9191 n = isl_id_list_n_id(list);
9192 if (n < 0)
9193 return -1;
9194 if (n != 3) {
9195 isl_id_list_free(list);
9196 isl_die(ctx, isl_error_unknown,
9197 "unexpected number of elements in list", return -1);
9198 }
9199
9200 id = isl_id_list_get_id(list, index: 0);
9201 ok = id == a;
9202 isl_id_free(id);
9203 id = isl_id_list_get_id(list, index: 1);
9204 ok = ok && id == c;
9205 isl_id_free(id);
9206 id = isl_id_list_get_id(list, index: 2);
9207 ok = ok && id == d;
9208 isl_id_free(id);
9209
9210 isl_id_list_free(list);
9211
9212 if (!ok)
9213 isl_die(ctx, isl_error_unknown,
9214 "unexpected elements in list", return -1);
9215
9216 return 0;
9217}
9218
9219/* Check the conversion from an isl_multi_aff to an isl_basic_set.
9220 */
9221static isl_stat test_ma_conversion(isl_ctx *ctx)
9222{
9223 const char *str;
9224 isl_bool equal;
9225 isl_multi_aff *ma;
9226 isl_basic_set *bset1, *bset2;
9227
9228 str = "[N] -> { A[0, N + 1] }";
9229 ma = isl_multi_aff_read_from_str(ctx, str);
9230 bset1 = isl_basic_set_read_from_str(ctx, str);
9231 bset2 = isl_basic_set_from_multi_aff(ma);
9232 equal = isl_basic_set_is_equal(bset1, bset2);
9233 isl_basic_set_free(bset: bset1);
9234 isl_basic_set_free(bset: bset2);
9235 if (equal < 0)
9236 return isl_stat_error;
9237 if (!equal)
9238 isl_die(ctx, isl_error_unknown, "bad conversion",
9239 return isl_stat_error);
9240 return isl_stat_ok;
9241}
9242
9243const char *set_conversion_tests[] = {
9244 "[N] -> { [i] : N - 1 <= 2 i <= N }",
9245 "[N] -> { [i] : exists a : i = 4 a and N - 1 <= i <= N }",
9246 "[N] -> { [i,j] : exists a : i = 4 a and N - 1 <= i, 2j <= N }",
9247 "[N] -> { [[i]->[j]] : exists a : i = 4 a and N - 1 <= i, 2j <= N }",
9248 "[N] -> { [3*floor(N/2) + 5*floor(N/3)] }",
9249 "[a, b] -> { [c, d] : (4*floor((-a + c)/4) = -a + c and "
9250 "32*floor((-b + d)/32) = -b + d and 5 <= c <= 8 and "
9251 "-3 + c <= d <= 28 + c) }",
9252};
9253
9254/* Check that converting from isl_set to isl_pw_multi_aff and back
9255 * to isl_set produces the original isl_set.
9256 */
9257static int test_set_conversion(isl_ctx *ctx)
9258{
9259 int i;
9260 const char *str;
9261 isl_set *set1, *set2;
9262 isl_pw_multi_aff *pma;
9263 int equal;
9264
9265 for (i = 0; i < ARRAY_SIZE(set_conversion_tests); ++i) {
9266 str = set_conversion_tests[i];
9267 set1 = isl_set_read_from_str(ctx, str);
9268 pma = isl_pw_multi_aff_from_set(set: isl_set_copy(set: set1));
9269 set2 = isl_set_from_pw_multi_aff(pma);
9270 equal = isl_set_is_equal(set1, set2);
9271 isl_set_free(set: set1);
9272 isl_set_free(set: set2);
9273
9274 if (equal < 0)
9275 return -1;
9276 if (!equal)
9277 isl_die(ctx, isl_error_unknown, "bad conversion",
9278 return -1);
9279 }
9280
9281 return 0;
9282}
9283
9284const char *conversion_tests[] = {
9285 "{ [a, b, c, d] -> s0[a, b, e, f] : "
9286 "exists (e0 = [(a - 2c)/3], e1 = [(-4 + b - 5d)/9], "
9287 "e2 = [(-d + f)/9]: 3e0 = a - 2c and 9e1 = -4 + b - 5d and "
9288 "9e2 = -d + f and f >= 0 and f <= 8 and 9e >= -5 - 2a and "
9289 "9e <= -2 - 2a) }",
9290 "{ [a, b] -> [c] : exists (e0 = floor((-a - b + c)/5): "
9291 "5e0 = -a - b + c and c >= -a and c <= 4 - a) }",
9292 "{ [a, b] -> [c] : exists d : 18 * d = -3 - a + 2c and 1 <= c <= 3 }",
9293};
9294
9295/* Check that converting from isl_map to isl_pw_multi_aff and back
9296 * to isl_map produces the original isl_map.
9297 */
9298static int test_map_conversion(isl_ctx *ctx)
9299{
9300 int i;
9301 isl_map *map1, *map2;
9302 isl_pw_multi_aff *pma;
9303 int equal;
9304
9305 for (i = 0; i < ARRAY_SIZE(conversion_tests); ++i) {
9306 map1 = isl_map_read_from_str(ctx, str: conversion_tests[i]);
9307 pma = isl_pw_multi_aff_from_map(map: isl_map_copy(map: map1));
9308 map2 = isl_map_from_pw_multi_aff(pma);
9309 equal = isl_map_is_equal(map1, map2);
9310 isl_map_free(map: map1);
9311 isl_map_free(map: map2);
9312
9313 if (equal < 0)
9314 return -1;
9315 if (!equal)
9316 isl_die(ctx, isl_error_unknown, "bad conversion",
9317 return -1);
9318 }
9319
9320 return 0;
9321}
9322
9323/* Descriptions of isl_pw_multi_aff objects for testing conversion
9324 * to isl_multi_pw_aff and back.
9325 */
9326const char *mpa_conversion_tests[] = {
9327 "{ [x] -> A[x] }",
9328 "{ [x] -> A[x] : x >= 0 }",
9329 "{ [x] -> A[x] : x >= 0; [x] -> A[-x] : x < 0 }",
9330 "{ [x] -> A[x, x + 1] }",
9331 "{ [x] -> A[] }",
9332 "{ [x] -> A[] : x >= 0 }",
9333};
9334
9335/* Check that conversion from isl_pw_multi_aff to isl_multi_pw_aff and
9336 * back to isl_pw_multi_aff preserves the original meaning.
9337 */
9338static int test_mpa_conversion(isl_ctx *ctx)
9339{
9340 int i;
9341 isl_pw_multi_aff *pma1, *pma2;
9342 isl_multi_pw_aff *mpa;
9343 int equal;
9344
9345 for (i = 0; i < ARRAY_SIZE(mpa_conversion_tests); ++i) {
9346 const char *str;
9347 str = mpa_conversion_tests[i];
9348 pma1 = isl_pw_multi_aff_read_from_str(ctx, str);
9349 pma2 = isl_pw_multi_aff_copy(pma: pma1);
9350 mpa = isl_multi_pw_aff_from_pw_multi_aff(pma: pma1);
9351 pma1 = isl_pw_multi_aff_from_multi_pw_aff(mpa);
9352 equal = isl_pw_multi_aff_plain_is_equal(pma1, pma2);
9353 isl_pw_multi_aff_free(pma: pma1);
9354 isl_pw_multi_aff_free(pma: pma2);
9355
9356 if (equal < 0)
9357 return -1;
9358 if (!equal)
9359 isl_die(ctx, isl_error_unknown, "bad conversion",
9360 return -1);
9361 }
9362
9363 return 0;
9364}
9365
9366/* Descriptions of union maps that should be convertible
9367 * to an isl_multi_union_pw_aff.
9368 */
9369const char *umap_mupa_conversion_tests[] = {
9370 "{ [a, b, c, d] -> s0[a, b, e, f] : "
9371 "exists (e0 = [(a - 2c)/3], e1 = [(-4 + b - 5d)/9], "
9372 "e2 = [(-d + f)/9]: 3e0 = a - 2c and 9e1 = -4 + b - 5d and "
9373 "9e2 = -d + f and f >= 0 and f <= 8 and 9e >= -5 - 2a and "
9374 "9e <= -2 - 2a) }",
9375 "{ [a, b] -> [c] : exists (e0 = floor((-a - b + c)/5): "
9376 "5e0 = -a - b + c and c >= -a and c <= 4 - a) }",
9377 "{ [a, b] -> [c] : exists d : 18 * d = -3 - a + 2c and 1 <= c <= 3 }",
9378 "{ A[] -> B[0]; C[] -> B[1] }",
9379 "{ A[] -> B[]; C[] -> B[] }",
9380};
9381
9382/* Check that converting from isl_union_map to isl_multi_union_pw_aff and back
9383 * to isl_union_map produces the original isl_union_map.
9384 */
9385static int test_union_map_mupa_conversion(isl_ctx *ctx)
9386{
9387 int i;
9388 isl_union_map *umap1, *umap2;
9389 isl_multi_union_pw_aff *mupa;
9390 int equal;
9391
9392 for (i = 0; i < ARRAY_SIZE(umap_mupa_conversion_tests); ++i) {
9393 const char *str;
9394 str = umap_mupa_conversion_tests[i];
9395 umap1 = isl_union_map_read_from_str(ctx, str);
9396 umap2 = isl_union_map_copy(umap: umap1);
9397 mupa = isl_multi_union_pw_aff_from_union_map(umap: umap2);
9398 umap2 = isl_union_map_from_multi_union_pw_aff(mupa);
9399 equal = isl_union_map_is_equal(umap1, umap2);
9400 isl_union_map_free(umap: umap1);
9401 isl_union_map_free(umap: umap2);
9402
9403 if (equal < 0)
9404 return -1;
9405 if (!equal)
9406 isl_die(ctx, isl_error_unknown, "bad conversion",
9407 return -1);
9408 }
9409
9410 return 0;
9411}
9412
9413static int test_conversion(isl_ctx *ctx)
9414{
9415 if (test_ma_conversion(ctx) < 0)
9416 return -1;
9417 if (test_set_conversion(ctx) < 0)
9418 return -1;
9419 if (test_map_conversion(ctx) < 0)
9420 return -1;
9421 if (test_mpa_conversion(ctx) < 0)
9422 return -1;
9423 if (test_union_map_mupa_conversion(ctx) < 0)
9424 return -1;
9425 return 0;
9426}
9427
9428/* Check that isl_basic_map_curry does not modify input.
9429 */
9430static int test_curry(isl_ctx *ctx)
9431{
9432 const char *str;
9433 isl_basic_map *bmap1, *bmap2;
9434 int equal;
9435
9436 str = "{ [A[] -> B[]] -> C[] }";
9437 bmap1 = isl_basic_map_read_from_str(ctx, str);
9438 bmap2 = isl_basic_map_curry(bmap: isl_basic_map_copy(bmap: bmap1));
9439 equal = isl_basic_map_is_equal(bmap1, bmap2);
9440 isl_basic_map_free(bmap: bmap1);
9441 isl_basic_map_free(bmap: bmap2);
9442
9443 if (equal < 0)
9444 return -1;
9445 if (equal)
9446 isl_die(ctx, isl_error_unknown,
9447 "curried map should not be equal to original",
9448 return -1);
9449
9450 return 0;
9451}
9452
9453struct {
9454 const char *ma1;
9455 const char *ma;
9456 const char *res;
9457} pullback_tests[] = {
9458 { "{ B[i,j] -> C[i + 2j] }" , "{ A[a,b] -> B[b,a] }",
9459 "{ A[a,b] -> C[b + 2a] }" },
9460 { "{ B[i] -> C[2i] }", "{ A[a] -> B[(a)/2] }", "{ A[a] -> C[a] }" },
9461 { "{ B[i] -> C[(i)/2] }", "{ A[a] -> B[2a] }", "{ A[a] -> C[a] }" },
9462 { "{ B[i] -> C[(i)/2] }", "{ A[a] -> B[(a)/3] }",
9463 "{ A[a] -> C[(a)/6] }" },
9464 { "{ B[i] -> C[2i] }", "{ A[a] -> B[5a] }", "{ A[a] -> C[10a] }" },
9465 { "{ B[i] -> C[2i] }", "{ A[a] -> B[(a)/3] }",
9466 "{ A[a] -> C[(2a)/3] }" },
9467 { "{ B[i,j] -> C[i + j] }", "{ A[a] -> B[a,a] }", "{ A[a] -> C[2a] }"},
9468 { "{ B[a] -> C[a,a] }", "{ A[i,j] -> B[i + j] }",
9469 "{ A[i,j] -> C[i + j, i + j] }"},
9470 { "{ B[i] -> C[([i/2])] }", "{ B[5] }", "{ C[2] }" },
9471 { "[n] -> { B[i,j] -> C[([i/2]) + 2j] }",
9472 "[n] -> { B[n,[n/3]] }", "[n] -> { C[([n/2]) + 2*[n/3]] }", },
9473 { "{ [i, j] -> [floor((i)/4) + floor((2*i+j)/5)] }",
9474 "{ [i, j] -> [floor((i)/3), j] }",
9475 "{ [i, j] -> [(floor((i)/12) + floor((j + 2*floor((i)/3))/5))] }" },
9476};
9477
9478static int test_pullback(isl_ctx *ctx)
9479{
9480 int i;
9481 isl_multi_aff *ma1, *ma2;
9482 isl_multi_aff *ma;
9483 int equal;
9484
9485 for (i = 0; i < ARRAY_SIZE(pullback_tests); ++i) {
9486 ma1 = isl_multi_aff_read_from_str(ctx, str: pullback_tests[i].ma1);
9487 ma = isl_multi_aff_read_from_str(ctx, str: pullback_tests[i].ma);
9488 ma2 = isl_multi_aff_read_from_str(ctx, str: pullback_tests[i].res);
9489 ma1 = isl_multi_aff_pullback_multi_aff(ma1, ma2: ma);
9490 equal = isl_multi_aff_plain_is_equal(multi1: ma1, multi2: ma2);
9491 isl_multi_aff_free(multi: ma1);
9492 isl_multi_aff_free(multi: ma2);
9493 if (equal < 0)
9494 return -1;
9495 if (!equal)
9496 isl_die(ctx, isl_error_unknown, "bad pullback",
9497 return -1);
9498 }
9499
9500 return 0;
9501}
9502
9503/* Check that negation is printed correctly and that equal expressions
9504 * are correctly identified.
9505 */
9506static int test_ast(isl_ctx *ctx)
9507{
9508 isl_ast_expr *expr, *expr1, *expr2, *expr3;
9509 char *str;
9510 int ok, equal;
9511
9512 expr1 = isl_ast_expr_from_id(id: isl_id_alloc(ctx, name: "A", NULL));
9513 expr2 = isl_ast_expr_from_id(id: isl_id_alloc(ctx, name: "B", NULL));
9514 expr = isl_ast_expr_add(expr1, expr2);
9515 expr2 = isl_ast_expr_copy(expr);
9516 expr = isl_ast_expr_neg(expr);
9517 expr2 = isl_ast_expr_neg(expr: expr2);
9518 equal = isl_ast_expr_is_equal(expr1: expr, expr2);
9519 str = isl_ast_expr_to_C_str(expr);
9520 ok = str ? !strcmp(s1: str, s2: "-(A + B)") : -1;
9521 free(ptr: str);
9522 isl_ast_expr_free(expr);
9523 isl_ast_expr_free(expr: expr2);
9524
9525 if (ok < 0 || equal < 0)
9526 return -1;
9527 if (!equal)
9528 isl_die(ctx, isl_error_unknown,
9529 "equal expressions not considered equal", return -1);
9530 if (!ok)
9531 isl_die(ctx, isl_error_unknown,
9532 "isl_ast_expr printed incorrectly", return -1);
9533
9534 expr1 = isl_ast_expr_from_id(id: isl_id_alloc(ctx, name: "A", NULL));
9535 expr2 = isl_ast_expr_from_id(id: isl_id_alloc(ctx, name: "B", NULL));
9536 expr = isl_ast_expr_add(expr1, expr2);
9537 expr3 = isl_ast_expr_from_id(id: isl_id_alloc(ctx, name: "C", NULL));
9538 expr = isl_ast_expr_sub(expr1: expr3, expr2: expr);
9539 str = isl_ast_expr_to_C_str(expr);
9540 ok = str ? !strcmp(s1: str, s2: "C - (A + B)") : -1;
9541 free(ptr: str);
9542 isl_ast_expr_free(expr);
9543
9544 if (ok < 0)
9545 return -1;
9546 if (!ok)
9547 isl_die(ctx, isl_error_unknown,
9548 "isl_ast_expr printed incorrectly", return -1);
9549
9550 return 0;
9551}
9552
9553/* Check that isl_ast_build_expr_from_set returns a valid expression
9554 * for an empty set. Note that isl_ast_build_expr_from_set getting
9555 * called on an empty set probably indicates a bug in the caller.
9556 */
9557static int test_ast_build(isl_ctx *ctx)
9558{
9559 isl_set *set;
9560 isl_ast_build *build;
9561 isl_ast_expr *expr;
9562
9563 set = isl_set_universe(space: isl_space_params_alloc(ctx, nparam: 0));
9564 build = isl_ast_build_from_context(set);
9565
9566 set = isl_set_empty(space: isl_space_params_alloc(ctx, nparam: 0));
9567 expr = isl_ast_build_expr_from_set(build, set);
9568
9569 isl_ast_expr_free(expr);
9570 isl_ast_build_free(build);
9571
9572 if (!expr)
9573 return -1;
9574
9575 return 0;
9576}
9577
9578/* Internal data structure for before_for and after_for callbacks.
9579 *
9580 * depth is the current depth
9581 * before is the number of times before_for has been called
9582 * after is the number of times after_for has been called
9583 */
9584struct isl_test_codegen_data {
9585 int depth;
9586 int before;
9587 int after;
9588};
9589
9590/* This function is called before each for loop in the AST generated
9591 * from test_ast_gen1.
9592 *
9593 * Increment the number of calls and the depth.
9594 * Check that the space returned by isl_ast_build_get_schedule_space
9595 * matches the target space of the schedule returned by
9596 * isl_ast_build_get_schedule.
9597 * Return an isl_id that is checked by the corresponding call
9598 * to after_for.
9599 */
9600static __isl_give isl_id *before_for(__isl_keep isl_ast_build *build,
9601 void *user)
9602{
9603 struct isl_test_codegen_data *data = user;
9604 isl_ctx *ctx;
9605 isl_space *space;
9606 isl_union_map *schedule;
9607 isl_union_set *uset;
9608 isl_set *set;
9609 isl_bool empty;
9610 isl_size n;
9611 char name[] = "d0";
9612
9613 ctx = isl_ast_build_get_ctx(build);
9614
9615 if (data->before >= 3)
9616 isl_die(ctx, isl_error_unknown,
9617 "unexpected number of for nodes", return NULL);
9618 if (data->depth < 0 || data->depth >= 2)
9619 isl_die(ctx, isl_error_unknown,
9620 "unexpected depth", return NULL);
9621
9622 snprintf(s: name, maxlen: sizeof(name), format: "d%d", data->depth);
9623 data->before++;
9624 data->depth++;
9625
9626 schedule = isl_ast_build_get_schedule(build);
9627 uset = isl_union_map_range(umap: schedule);
9628 n = isl_union_set_n_set(uset);
9629 if (n != 1) {
9630 isl_union_set_free(uset);
9631 if (n < 0)
9632 return NULL;
9633 isl_die(ctx, isl_error_unknown,
9634 "expecting single range space", return NULL);
9635 }
9636
9637 space = isl_ast_build_get_schedule_space(build);
9638 set = isl_union_set_extract_set(uset, space);
9639 isl_union_set_free(uset);
9640 empty = isl_set_is_empty(set);
9641 isl_set_free(set);
9642
9643 if (empty < 0)
9644 return NULL;
9645 if (empty)
9646 isl_die(ctx, isl_error_unknown,
9647 "spaces don't match", return NULL);
9648
9649 return isl_id_alloc(ctx, name, NULL);
9650}
9651
9652/* This function is called after each for loop in the AST generated
9653 * from test_ast_gen1.
9654 *
9655 * Increment the number of calls and decrement the depth.
9656 * Check that the annotation attached to the node matches
9657 * the isl_id returned by the corresponding call to before_for.
9658 */
9659static __isl_give isl_ast_node *after_for(__isl_take isl_ast_node *node,
9660 __isl_keep isl_ast_build *build, void *user)
9661{
9662 struct isl_test_codegen_data *data = user;
9663 isl_id *id;
9664 const char *name;
9665 int valid;
9666
9667 data->after++;
9668 data->depth--;
9669
9670 if (data->after > data->before)
9671 isl_die(isl_ast_node_get_ctx(node), isl_error_unknown,
9672 "mismatch in number of for nodes",
9673 return isl_ast_node_free(node));
9674
9675 id = isl_ast_node_get_annotation(node);
9676 if (!id)
9677 isl_die(isl_ast_node_get_ctx(node), isl_error_unknown,
9678 "missing annotation", return isl_ast_node_free(node));
9679
9680 name = isl_id_get_name(id);
9681 valid = name && atoi(nptr: name + 1) == data->depth;
9682 isl_id_free(id);
9683
9684 if (!valid)
9685 isl_die(isl_ast_node_get_ctx(node), isl_error_unknown,
9686 "wrong annotation", return isl_ast_node_free(node));
9687
9688 return node;
9689}
9690
9691/* This function is called after node in the AST generated
9692 * from test_ast_gen1.
9693 *
9694 * Increment the count in "user" if this is a for node and
9695 * return true to indicate that descendant should also be visited.
9696 */
9697static isl_bool count_for(__isl_keep isl_ast_node *node, void *user)
9698{
9699 int *count = user;
9700
9701 if (isl_ast_node_get_type(node) == isl_ast_node_for)
9702 ++*count;
9703
9704 return isl_bool_true;
9705}
9706
9707/* If "node" is a block node, then replace it by its first child.
9708 */
9709static __isl_give isl_ast_node *select_first(__isl_take isl_ast_node *node,
9710 void *user)
9711{
9712 isl_ast_node_list *children;
9713 isl_ast_node *child;
9714
9715 if (isl_ast_node_get_type(node) != isl_ast_node_block)
9716 return node;
9717
9718 children = isl_ast_node_block_get_children(node);
9719 child = isl_ast_node_list_get_at(list: children, index: 0);
9720 isl_ast_node_list_free(list: children);
9721 isl_ast_node_free(node);
9722
9723 return child;
9724}
9725
9726/* Check that the before_each_for and after_each_for callbacks
9727 * are called for each for loop in the generated code,
9728 * that they are called in the right order and that the isl_id
9729 * returned from the before_each_for callback is attached to
9730 * the isl_ast_node passed to the corresponding after_each_for call.
9731 *
9732 * Additionally, check the basic functionality of
9733 * isl_ast_node_foreach_descendant_top_down by counting the number
9734 * of for loops in the resulting AST,
9735 * as well as that of isl_ast_node_map_descendant_bottom_up
9736 * by replacing the block node by its first child and
9737 * counting the number of for loops again.
9738 */
9739static isl_stat test_ast_gen1(isl_ctx *ctx)
9740{
9741 int count = 0;
9742 int modified_count = 0;
9743 const char *str;
9744 isl_set *set;
9745 isl_union_map *schedule;
9746 isl_ast_build *build;
9747 isl_ast_node *tree;
9748 struct isl_test_codegen_data data;
9749
9750 str = "[N] -> { : N >= 10 }";
9751 set = isl_set_read_from_str(ctx, str);
9752 str = "[N] -> { A[i,j] -> S[8,i,3,j] : 0 <= i,j <= N; "
9753 "B[i,j] -> S[8,j,9,i] : 0 <= i,j <= N }";
9754 schedule = isl_union_map_read_from_str(ctx, str);
9755
9756 data.before = 0;
9757 data.after = 0;
9758 data.depth = 0;
9759 build = isl_ast_build_from_context(set);
9760 build = isl_ast_build_set_before_each_for(build,
9761 fn: &before_for, user: &data);
9762 build = isl_ast_build_set_after_each_for(build,
9763 fn: &after_for, user: &data);
9764 tree = isl_ast_build_node_from_schedule_map(build, schedule);
9765 isl_ast_build_free(build);
9766
9767 if (isl_ast_node_foreach_descendant_top_down(node: tree,
9768 fn: &count_for, user: &count) < 0)
9769 tree = isl_ast_node_free(node: tree);
9770
9771 tree = isl_ast_node_map_descendant_bottom_up(node: tree, fn: &select_first, NULL);
9772
9773 if (isl_ast_node_foreach_descendant_top_down(node: tree, fn: &count_for,
9774 user: &modified_count) < 0)
9775 tree = isl_ast_node_free(node: tree);
9776
9777 if (!tree)
9778 return isl_stat_error;
9779
9780 isl_ast_node_free(node: tree);
9781
9782 if (data.before != 3 || data.after != 3 || count != 3)
9783 isl_die(ctx, isl_error_unknown,
9784 "unexpected number of for nodes",
9785 return isl_stat_error);
9786
9787 if (modified_count != 2)
9788 isl_die(ctx, isl_error_unknown,
9789 "unexpected number of for nodes after changes",
9790 return isl_stat_error);
9791
9792 return isl_stat_ok;
9793}
9794
9795/* Check that the AST generator handles domains that are integrally disjoint
9796 * but not rationally disjoint.
9797 */
9798static int test_ast_gen2(isl_ctx *ctx)
9799{
9800 const char *str;
9801 isl_set *set;
9802 isl_union_map *schedule;
9803 isl_union_map *options;
9804 isl_ast_build *build;
9805 isl_ast_node *tree;
9806
9807 str = "{ A[i,j] -> [i,j] : 0 <= i,j <= 1 }";
9808 schedule = isl_union_map_read_from_str(ctx, str);
9809 set = isl_set_universe(space: isl_space_params_alloc(ctx, nparam: 0));
9810 build = isl_ast_build_from_context(set);
9811
9812 str = "{ [i,j] -> atomic[1] : i + j = 1; [i,j] -> unroll[1] : i = j }";
9813 options = isl_union_map_read_from_str(ctx, str);
9814 build = isl_ast_build_set_options(build, options);
9815 tree = isl_ast_build_node_from_schedule_map(build, schedule);
9816 isl_ast_build_free(build);
9817 if (!tree)
9818 return -1;
9819 isl_ast_node_free(node: tree);
9820
9821 return 0;
9822}
9823
9824/* Increment *user on each call.
9825 */
9826static __isl_give isl_ast_node *count_domains(__isl_take isl_ast_node *node,
9827 __isl_keep isl_ast_build *build, void *user)
9828{
9829 int *n = user;
9830
9831 (*n)++;
9832
9833 return node;
9834}
9835
9836/* Test that unrolling tries to minimize the number of instances.
9837 * In particular, for the schedule given below, make sure it generates
9838 * 3 nodes (rather than 101).
9839 */
9840static int test_ast_gen3(isl_ctx *ctx)
9841{
9842 const char *str;
9843 isl_set *set;
9844 isl_union_map *schedule;
9845 isl_union_map *options;
9846 isl_ast_build *build;
9847 isl_ast_node *tree;
9848 int n_domain = 0;
9849
9850 str = "[n] -> { A[i] -> [i] : 0 <= i <= 100 and n <= i <= n + 2 }";
9851 schedule = isl_union_map_read_from_str(ctx, str);
9852 set = isl_set_universe(space: isl_space_params_alloc(ctx, nparam: 0));
9853
9854 str = "{ [i] -> unroll[0] }";
9855 options = isl_union_map_read_from_str(ctx, str);
9856
9857 build = isl_ast_build_from_context(set);
9858 build = isl_ast_build_set_options(build, options);
9859 build = isl_ast_build_set_at_each_domain(build,
9860 fn: &count_domains, user: &n_domain);
9861 tree = isl_ast_build_node_from_schedule_map(build, schedule);
9862 isl_ast_build_free(build);
9863 if (!tree)
9864 return -1;
9865
9866 isl_ast_node_free(node: tree);
9867
9868 if (n_domain != 3)
9869 isl_die(ctx, isl_error_unknown,
9870 "unexpected number of for nodes", return -1);
9871
9872 return 0;
9873}
9874
9875/* Check that if the ast_build_exploit_nested_bounds options is set,
9876 * we do not get an outer if node in the generated AST,
9877 * while we do get such an outer if node if the options is not set.
9878 */
9879static int test_ast_gen4(isl_ctx *ctx)
9880{
9881 const char *str;
9882 isl_set *set;
9883 isl_union_map *schedule;
9884 isl_ast_build *build;
9885 isl_ast_node *tree;
9886 enum isl_ast_node_type type;
9887 int enb;
9888
9889 enb = isl_options_get_ast_build_exploit_nested_bounds(ctx);
9890 str = "[N,M] -> { A[i,j] -> [i,j] : 0 <= i <= N and 0 <= j <= M }";
9891
9892 isl_options_set_ast_build_exploit_nested_bounds(ctx, val: 1);
9893
9894 schedule = isl_union_map_read_from_str(ctx, str);
9895 set = isl_set_universe(space: isl_space_params_alloc(ctx, nparam: 0));
9896 build = isl_ast_build_from_context(set);
9897 tree = isl_ast_build_node_from_schedule_map(build, schedule);
9898 isl_ast_build_free(build);
9899 if (!tree)
9900 return -1;
9901
9902 type = isl_ast_node_get_type(node: tree);
9903 isl_ast_node_free(node: tree);
9904
9905 if (type == isl_ast_node_if)
9906 isl_die(ctx, isl_error_unknown,
9907 "not expecting if node", return -1);
9908
9909 isl_options_set_ast_build_exploit_nested_bounds(ctx, val: 0);
9910
9911 schedule = isl_union_map_read_from_str(ctx, str);
9912 set = isl_set_universe(space: isl_space_params_alloc(ctx, nparam: 0));
9913 build = isl_ast_build_from_context(set);
9914 tree = isl_ast_build_node_from_schedule_map(build, schedule);
9915 isl_ast_build_free(build);
9916 if (!tree)
9917 return -1;
9918
9919 type = isl_ast_node_get_type(node: tree);
9920 isl_ast_node_free(node: tree);
9921
9922 if (type != isl_ast_node_if)
9923 isl_die(ctx, isl_error_unknown,
9924 "expecting if node", return -1);
9925
9926 isl_options_set_ast_build_exploit_nested_bounds(ctx, val: enb);
9927
9928 return 0;
9929}
9930
9931/* This function is called for each leaf in the AST generated
9932 * from test_ast_gen5.
9933 *
9934 * We finalize the AST generation by extending the outer schedule
9935 * with a zero-dimensional schedule. If this results in any for loops,
9936 * then this means that we did not pass along enough information
9937 * about the outer schedule to the inner AST generation.
9938 */
9939static __isl_give isl_ast_node *create_leaf(__isl_take isl_ast_build *build,
9940 void *user)
9941{
9942 isl_union_map *schedule, *extra;
9943 isl_ast_node *tree;
9944
9945 schedule = isl_ast_build_get_schedule(build);
9946 extra = isl_union_map_copy(umap: schedule);
9947 extra = isl_union_map_from_domain(uset: isl_union_map_domain(umap: extra));
9948 schedule = isl_union_map_range_product(umap1: schedule, umap2: extra);
9949 tree = isl_ast_build_node_from_schedule_map(build, schedule);
9950 isl_ast_build_free(build);
9951
9952 if (!tree)
9953 return NULL;
9954
9955 if (isl_ast_node_get_type(node: tree) == isl_ast_node_for)
9956 isl_die(isl_ast_node_get_ctx(tree), isl_error_unknown,
9957 "code should not contain any for loop",
9958 return isl_ast_node_free(tree));
9959
9960 return tree;
9961}
9962
9963/* Check that we do not lose any information when going back and
9964 * forth between internal and external schedule.
9965 *
9966 * In particular, we create an AST where we unroll the only
9967 * non-constant dimension in the schedule. We therefore do
9968 * not expect any for loops in the AST. However, older versions
9969 * of isl would not pass along enough information about the outer
9970 * schedule when performing an inner code generation from a create_leaf
9971 * callback, resulting in the inner code generation producing a for loop.
9972 */
9973static int test_ast_gen5(isl_ctx *ctx)
9974{
9975 const char *str;
9976 isl_set *set;
9977 isl_union_map *schedule, *options;
9978 isl_ast_build *build;
9979 isl_ast_node *tree;
9980
9981 str = "{ A[] -> [1, 1, 2]; B[i] -> [1, i, 0] : i >= 1 and i <= 2 }";
9982 schedule = isl_union_map_read_from_str(ctx, str);
9983
9984 str = "{ [a, b, c] -> unroll[1] : exists (e0 = [(a)/4]: "
9985 "4e0 >= -1 + a - b and 4e0 <= -2 + a + b) }";
9986 options = isl_union_map_read_from_str(ctx, str);
9987
9988 set = isl_set_universe(space: isl_space_params_alloc(ctx, nparam: 0));
9989 build = isl_ast_build_from_context(set);
9990 build = isl_ast_build_set_options(build, options);
9991 build = isl_ast_build_set_create_leaf(build, fn: &create_leaf, NULL);
9992 tree = isl_ast_build_node_from_schedule_map(build, schedule);
9993 isl_ast_build_free(build);
9994 isl_ast_node_free(node: tree);
9995 if (!tree)
9996 return -1;
9997
9998 return 0;
9999}
10000
10001/* Check that the expression
10002 *
10003 * [n] -> { [n/2] : n <= 0 and n % 2 = 0; [0] : n > 0 }
10004 *
10005 * is not combined into
10006 *
10007 * min(n/2, 0)
10008 *
10009 * as this would result in n/2 being evaluated in parts of
10010 * the definition domain where n is not a multiple of 2.
10011 */
10012static int test_ast_expr(isl_ctx *ctx)
10013{
10014 const char *str;
10015 isl_pw_aff *pa;
10016 isl_ast_build *build;
10017 isl_ast_expr *expr;
10018 int min_max;
10019 int is_min;
10020
10021 min_max = isl_options_get_ast_build_detect_min_max(ctx);
10022 isl_options_set_ast_build_detect_min_max(ctx, val: 1);
10023
10024 str = "[n] -> { [n/2] : n <= 0 and n % 2 = 0; [0] : n > 0 }";
10025 pa = isl_pw_aff_read_from_str(ctx, str);
10026 build = isl_ast_build_alloc(ctx);
10027 expr = isl_ast_build_expr_from_pw_aff(build, pa);
10028 is_min = isl_ast_expr_get_type(expr) == isl_ast_expr_op &&
10029 isl_ast_expr_get_op_type(expr) == isl_ast_expr_op_min;
10030 isl_ast_build_free(build);
10031 isl_ast_expr_free(expr);
10032
10033 isl_options_set_ast_build_detect_min_max(ctx, val: min_max);
10034
10035 if (!expr)
10036 return -1;
10037 if (is_min)
10038 isl_die(ctx, isl_error_unknown,
10039 "expressions should not be combined", return -1);
10040
10041 return 0;
10042}
10043
10044static int test_ast_gen(isl_ctx *ctx)
10045{
10046 if (test_ast_gen1(ctx) < 0)
10047 return -1;
10048 if (test_ast_gen2(ctx) < 0)
10049 return -1;
10050 if (test_ast_gen3(ctx) < 0)
10051 return -1;
10052 if (test_ast_gen4(ctx) < 0)
10053 return -1;
10054 if (test_ast_gen5(ctx) < 0)
10055 return -1;
10056 if (test_ast_expr(ctx) < 0)
10057 return -1;
10058 return 0;
10059}
10060
10061/* Check if dropping output dimensions from an isl_pw_multi_aff
10062 * works properly.
10063 */
10064static int test_pw_multi_aff(isl_ctx *ctx)
10065{
10066 const char *str;
10067 isl_pw_multi_aff *pma1, *pma2;
10068 int equal;
10069
10070 str = "{ [i,j] -> [i+j, 4i-j] }";
10071 pma1 = isl_pw_multi_aff_read_from_str(ctx, str);
10072 str = "{ [i,j] -> [4i-j] }";
10073 pma2 = isl_pw_multi_aff_read_from_str(ctx, str);
10074
10075 pma1 = isl_pw_multi_aff_drop_dims(pma: pma1, type: isl_dim_out, first: 0, n: 1);
10076
10077 equal = isl_pw_multi_aff_plain_is_equal(pma1, pma2);
10078
10079 isl_pw_multi_aff_free(pma: pma1);
10080 isl_pw_multi_aff_free(pma: pma2);
10081 if (equal < 0)
10082 return -1;
10083 if (!equal)
10084 isl_die(ctx, isl_error_unknown,
10085 "expressions not equal", return -1);
10086
10087 return 0;
10088}
10089
10090/* Check that we can properly parse multi piecewise affine expressions
10091 * where the piecewise affine expressions have different domains.
10092 */
10093static int test_multi_pw_aff_1(isl_ctx *ctx)
10094{
10095 const char *str;
10096 isl_set *dom, *dom2;
10097 isl_multi_pw_aff *mpa1, *mpa2;
10098 isl_pw_aff *pa;
10099 int equal;
10100 int equal_domain;
10101
10102 mpa1 = isl_multi_pw_aff_read_from_str(ctx, str: "{ [i] -> [i] }");
10103 dom = isl_set_read_from_str(ctx, str: "{ [i] : i > 0 }");
10104 mpa1 = isl_multi_pw_aff_intersect_domain(mpa: mpa1, domain: dom);
10105 mpa2 = isl_multi_pw_aff_read_from_str(ctx, str: "{ [i] -> [2i] }");
10106 mpa2 = isl_multi_pw_aff_flat_range_product(multi1: mpa1, multi2: mpa2);
10107 str = "{ [i] -> [(i : i > 0), 2i] }";
10108 mpa1 = isl_multi_pw_aff_read_from_str(ctx, str);
10109
10110 equal = isl_multi_pw_aff_plain_is_equal(multi1: mpa1, multi2: mpa2);
10111
10112 pa = isl_multi_pw_aff_get_pw_aff(multi: mpa1, pos: 0);
10113 dom = isl_pw_aff_domain(pwaff: pa);
10114 pa = isl_multi_pw_aff_get_pw_aff(multi: mpa1, pos: 1);
10115 dom2 = isl_pw_aff_domain(pwaff: pa);
10116 equal_domain = isl_set_is_equal(set1: dom, set2: dom2);
10117
10118 isl_set_free(set: dom);
10119 isl_set_free(set: dom2);
10120 isl_multi_pw_aff_free(multi: mpa1);
10121 isl_multi_pw_aff_free(multi: mpa2);
10122
10123 if (equal < 0)
10124 return -1;
10125 if (!equal)
10126 isl_die(ctx, isl_error_unknown,
10127 "expressions not equal", return -1);
10128
10129 if (equal_domain < 0)
10130 return -1;
10131 if (equal_domain)
10132 isl_die(ctx, isl_error_unknown,
10133 "domains unexpectedly equal", return -1);
10134
10135 return 0;
10136}
10137
10138/* Check that the dimensions in the explicit domain
10139 * of a multi piecewise affine expression are properly
10140 * taken into account.
10141 */
10142static int test_multi_pw_aff_2(isl_ctx *ctx)
10143{
10144 const char *str;
10145 isl_bool involves1, involves2, involves3, equal;
10146 isl_multi_pw_aff *mpa, *mpa1, *mpa2;
10147
10148 str = "{ A[x,y] -> B[] : x >= y }";
10149 mpa = isl_multi_pw_aff_read_from_str(ctx, str);
10150 involves1 = isl_multi_pw_aff_involves_dims(multi: mpa, type: isl_dim_in, first: 0, n: 2);
10151 mpa1 = isl_multi_pw_aff_copy(multi: mpa);
10152
10153 mpa = isl_multi_pw_aff_insert_dims(multi: mpa, type: isl_dim_in, first: 0, n: 1);
10154 involves2 = isl_multi_pw_aff_involves_dims(multi: mpa, type: isl_dim_in, first: 0, n: 1);
10155 involves3 = isl_multi_pw_aff_involves_dims(multi: mpa, type: isl_dim_in, first: 1, n: 2);
10156 str = "{ [a,x,y] -> B[] : x >= y }";
10157 mpa2 = isl_multi_pw_aff_read_from_str(ctx, str);
10158 equal = isl_multi_pw_aff_plain_is_equal(multi1: mpa, multi2: mpa2);
10159 isl_multi_pw_aff_free(multi: mpa2);
10160
10161 mpa = isl_multi_pw_aff_drop_dims(multi: mpa, type: isl_dim_in, first: 0, n: 1);
10162 mpa = isl_multi_pw_aff_set_tuple_name(multi: mpa, type: isl_dim_in, s: "A");
10163 if (equal >= 0 && equal)
10164 equal = isl_multi_pw_aff_plain_is_equal(multi1: mpa, multi2: mpa1);
10165 isl_multi_pw_aff_free(multi: mpa1);
10166 isl_multi_pw_aff_free(multi: mpa);
10167
10168 if (involves1 < 0 || involves2 < 0 || involves3 < 0 || equal < 0)
10169 return -1;
10170 if (!equal)
10171 isl_die(ctx, isl_error_unknown,
10172 "incorrect result of dimension insertion/removal",
10173 return isl_stat_error);
10174 if (!involves1 || involves2 || !involves3)
10175 isl_die(ctx, isl_error_unknown,
10176 "incorrect characterization of involved dimensions",
10177 return isl_stat_error);
10178
10179 return 0;
10180}
10181
10182/* Check that isl_multi_union_pw_aff_multi_val_on_domain
10183 * sets the explicit domain of a zero-dimensional result,
10184 * such that it can be converted to an isl_union_map.
10185 */
10186static isl_stat test_multi_pw_aff_3(isl_ctx *ctx)
10187{
10188 isl_space *space;
10189 isl_union_set *dom;
10190 isl_multi_val *mv;
10191 isl_multi_union_pw_aff *mupa;
10192 isl_union_map *umap;
10193
10194 dom = isl_union_set_read_from_str(ctx, str: "{ A[]; B[] }");
10195 space = isl_union_set_get_space(uset: dom);
10196 mv = isl_multi_val_zero(space: isl_space_set_from_params(space));
10197 mupa = isl_multi_union_pw_aff_multi_val_on_domain(domain: dom, mv);
10198 umap = isl_union_map_from_multi_union_pw_aff(mupa);
10199 isl_union_map_free(umap);
10200 if (!umap)
10201 return isl_stat_error;
10202
10203 return isl_stat_ok;
10204}
10205
10206/* String descriptions of boxes that
10207 * are used for reconstructing box maps from their lower and upper bounds.
10208 */
10209static const char *multi_pw_aff_box_tests[] = {
10210 "{ A[x, y] -> [] : x + y >= 0 }",
10211 "[N] -> { A[x, y] -> [x] : x + y <= N }",
10212 "[N] -> { A[x, y] -> [x : y] : x + y <= N }",
10213};
10214
10215/* Check that map representations of boxes can be reconstructed
10216 * from their lower and upper bounds.
10217 */
10218static isl_stat test_multi_pw_aff_box(isl_ctx *ctx)
10219{
10220 int i;
10221
10222 for (i = 0; i < ARRAY_SIZE(multi_pw_aff_box_tests); ++i) {
10223 const char *str;
10224 isl_bool equal;
10225 isl_map *map, *box;
10226 isl_multi_pw_aff *min, *max;
10227
10228 str = multi_pw_aff_box_tests[i];
10229 map = isl_map_read_from_str(ctx, str);
10230 min = isl_map_min_multi_pw_aff(map: isl_map_copy(map));
10231 max = isl_map_max_multi_pw_aff(map: isl_map_copy(map));
10232 box = isl_map_universe(space: isl_map_get_space(map));
10233 box = isl_map_lower_bound_multi_pw_aff(map: box, lower: min);
10234 box = isl_map_upper_bound_multi_pw_aff(map: box, upper: max);
10235 equal = isl_map_is_equal(map1: map, map2: box);
10236 isl_map_free(map);
10237 isl_map_free(map: box);
10238 if (equal < 0)
10239 return isl_stat_error;
10240 if (!equal)
10241 isl_die(ctx, isl_error_unknown,
10242 "unexpected result", return isl_stat_error);
10243 }
10244
10245 return isl_stat_ok;
10246}
10247
10248/* Perform some tests on multi piecewise affine expressions.
10249 */
10250static int test_multi_pw_aff(isl_ctx *ctx)
10251{
10252 if (test_multi_pw_aff_1(ctx) < 0)
10253 return -1;
10254 if (test_multi_pw_aff_2(ctx) < 0)
10255 return -1;
10256 if (test_multi_pw_aff_3(ctx) < 0)
10257 return -1;
10258 if (test_multi_pw_aff_box(ctx) < 0)
10259 return -1;
10260 return 0;
10261}
10262
10263/* This is a regression test for a bug where isl_basic_map_simplify
10264 * would end up in an infinite loop. In particular, we construct
10265 * an empty basic set that is not obviously empty.
10266 * isl_basic_set_is_empty marks the basic set as empty.
10267 * After projecting out i3, the variable can be dropped completely,
10268 * but isl_basic_map_simplify refrains from doing so if the basic set
10269 * is empty and would end up in an infinite loop if it didn't test
10270 * explicitly for empty basic maps in the outer loop.
10271 */
10272static int test_simplify_1(isl_ctx *ctx)
10273{
10274 const char *str;
10275 isl_basic_set *bset;
10276 int empty;
10277
10278 str = "{ [i0, i1, i2, i3] : i0 >= -2 and 6i2 <= 4 + i0 + 5i1 and "
10279 "i2 <= 22 and 75i2 <= 111 + 13i0 + 60i1 and "
10280 "25i2 >= 38 + 6i0 + 20i1 and i0 <= -1 and i2 >= 20 and "
10281 "i3 >= i2 }";
10282 bset = isl_basic_set_read_from_str(ctx, str);
10283 empty = isl_basic_set_is_empty(bset);
10284 bset = isl_basic_set_project_out(bset, type: isl_dim_set, first: 3, n: 1);
10285 isl_basic_set_free(bset);
10286 if (!bset)
10287 return -1;
10288 if (!empty)
10289 isl_die(ctx, isl_error_unknown,
10290 "basic set should be empty", return -1);
10291
10292 return 0;
10293}
10294
10295/* Check that the equality in the set description below
10296 * is simplified away.
10297 */
10298static int test_simplify_2(isl_ctx *ctx)
10299{
10300 const char *str;
10301 isl_basic_set *bset;
10302 isl_bool universe;
10303
10304 str = "{ [a] : exists e0, e1: 32e1 = 31 + 31a + 31e0 }";
10305 bset = isl_basic_set_read_from_str(ctx, str);
10306 universe = isl_basic_set_plain_is_universe(bset);
10307 isl_basic_set_free(bset);
10308
10309 if (universe < 0)
10310 return -1;
10311 if (!universe)
10312 isl_die(ctx, isl_error_unknown,
10313 "equality not simplified away", return -1);
10314 return 0;
10315}
10316
10317/* Some simplification tests.
10318 */
10319static int test_simplify(isl_ctx *ctx)
10320{
10321 if (test_simplify_1(ctx) < 0)
10322 return -1;
10323 if (test_simplify_2(ctx) < 0)
10324 return -1;
10325 return 0;
10326}
10327
10328/* This is a regression test for a bug where isl_tab_basic_map_partial_lexopt
10329 * with gbr context would fail to disable the use of the shifted tableau
10330 * when transferring equalities for the input to the context, resulting
10331 * in invalid sample values.
10332 */
10333static int test_partial_lexmin(isl_ctx *ctx)
10334{
10335 const char *str;
10336 isl_basic_set *bset;
10337 isl_basic_map *bmap;
10338 isl_map *map;
10339
10340 str = "{ [1, b, c, 1 - c] -> [e] : 2e <= -c and 2e >= -3 + c }";
10341 bmap = isl_basic_map_read_from_str(ctx, str);
10342 str = "{ [a, b, c, d] : c <= 1 and 2d >= 6 - 4b - c }";
10343 bset = isl_basic_set_read_from_str(ctx, str);
10344 map = isl_basic_map_partial_lexmin(bmap, dom: bset, NULL);
10345 isl_map_free(map);
10346
10347 if (!map)
10348 return -1;
10349
10350 return 0;
10351}
10352
10353/* Check that the variable compression performed on the existentially
10354 * quantified variables inside isl_basic_set_compute_divs is not confused
10355 * by the implicit equalities among the parameters.
10356 */
10357static int test_compute_divs(isl_ctx *ctx)
10358{
10359 const char *str;
10360 isl_basic_set *bset;
10361 isl_set *set;
10362
10363 str = "[a, b, c, d, e] -> { [] : exists (e0: 2d = b and a <= 124 and "
10364 "b <= 2046 and b >= 0 and b <= 60 + 64a and 2e >= b + 2c and "
10365 "2e >= b and 2e <= 1 + b and 2e <= 1 + b + 2c and "
10366 "32768e0 >= -124 + a and 2097152e0 <= 60 + 64a - b) }";
10367 bset = isl_basic_set_read_from_str(ctx, str);
10368 set = isl_basic_set_compute_divs(bset);
10369 isl_set_free(set);
10370 if (!set)
10371 return -1;
10372
10373 return 0;
10374}
10375
10376/* Check that isl_schedule_get_map is not confused by a schedule tree
10377 * with divergent filter node parameters, as can result from a call
10378 * to isl_schedule_intersect_domain.
10379 */
10380static int test_schedule_tree(isl_ctx *ctx)
10381{
10382 const char *str;
10383 isl_union_set *uset;
10384 isl_schedule *sched1, *sched2;
10385 isl_union_map *umap;
10386
10387 uset = isl_union_set_read_from_str(ctx, str: "{ A[i] }");
10388 sched1 = isl_schedule_from_domain(domain: uset);
10389 uset = isl_union_set_read_from_str(ctx, str: "{ B[] }");
10390 sched2 = isl_schedule_from_domain(domain: uset);
10391
10392 sched1 = isl_schedule_sequence(schedule1: sched1, schedule2: sched2);
10393 str = "[n] -> { A[i] : 0 <= i < n; B[] }";
10394 uset = isl_union_set_read_from_str(ctx, str);
10395 sched1 = isl_schedule_intersect_domain(schedule: sched1, domain: uset);
10396 umap = isl_schedule_get_map(sched: sched1);
10397 isl_schedule_free(sched: sched1);
10398 isl_union_map_free(umap);
10399 if (!umap)
10400 return -1;
10401
10402 return 0;
10403}
10404
10405/* Check that a zero-dimensional prefix schedule keeps track
10406 * of the domain and outer filters.
10407 */
10408static int test_schedule_tree_prefix(isl_ctx *ctx)
10409{
10410 const char *str;
10411 isl_bool equal;
10412 isl_union_set *uset;
10413 isl_union_set_list *filters;
10414 isl_multi_union_pw_aff *mupa, *mupa2;
10415 isl_schedule_node *node;
10416
10417 str = "{ S1[i,j] : 0 <= i,j < 10; S2[i,j] : 0 <= i,j < 10 }";
10418 uset = isl_union_set_read_from_str(ctx, str);
10419 node = isl_schedule_node_from_domain(domain: uset);
10420 node = isl_schedule_node_child(node, pos: 0);
10421
10422 str = "{ S1[i,j] : i > j }";
10423 uset = isl_union_set_read_from_str(ctx, str);
10424 filters = isl_union_set_list_from_union_set(el: uset);
10425 str = "{ S1[i,j] : i <= j; S2[i,j] }";
10426 uset = isl_union_set_read_from_str(ctx, str);
10427 filters = isl_union_set_list_add(list: filters, el: uset);
10428 node = isl_schedule_node_insert_sequence(node, filters);
10429
10430 node = isl_schedule_node_grandchild(node, pos1: 0, pos2: 0);
10431 mupa = isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(node);
10432 str = "([] : { S1[i,j] : i > j })";
10433 mupa2 = isl_multi_union_pw_aff_read_from_str(ctx, str);
10434 equal = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa, multi2: mupa2);
10435 isl_multi_union_pw_aff_free(multi: mupa2);
10436 isl_multi_union_pw_aff_free(multi: mupa);
10437 isl_schedule_node_free(node);
10438
10439 if (equal < 0)
10440 return -1;
10441 if (!equal)
10442 isl_die(ctx, isl_error_unknown, "unexpected prefix schedule",
10443 return -1);
10444
10445 return 0;
10446}
10447
10448/* Check that the reaching domain elements and the prefix schedule
10449 * at a leaf node are the same before and after grouping.
10450 */
10451static int test_schedule_tree_group_1(isl_ctx *ctx)
10452{
10453 int equal;
10454 const char *str;
10455 isl_id *id;
10456 isl_union_set *uset;
10457 isl_multi_union_pw_aff *mupa;
10458 isl_union_pw_multi_aff *upma1, *upma2;
10459 isl_union_set *domain1, *domain2;
10460 isl_union_map *umap1, *umap2;
10461 isl_schedule_node *node;
10462
10463 str = "{ S1[i,j] : 0 <= i,j < 10; S2[i,j] : 0 <= i,j < 10 }";
10464 uset = isl_union_set_read_from_str(ctx, str);
10465 node = isl_schedule_node_from_domain(domain: uset);
10466 node = isl_schedule_node_child(node, pos: 0);
10467 str = "[{ S1[i,j] -> [i]; S2[i,j] -> [9 - i] }]";
10468 mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
10469 node = isl_schedule_node_insert_partial_schedule(node, schedule: mupa);
10470 node = isl_schedule_node_child(node, pos: 0);
10471 str = "[{ S1[i,j] -> [j]; S2[i,j] -> [j] }]";
10472 mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
10473 node = isl_schedule_node_insert_partial_schedule(node, schedule: mupa);
10474 node = isl_schedule_node_child(node, pos: 0);
10475 umap1 = isl_schedule_node_get_prefix_schedule_union_map(node);
10476 upma1 = isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(node);
10477 domain1 = isl_schedule_node_get_domain(node);
10478 id = isl_id_alloc(ctx, name: "group", NULL);
10479 node = isl_schedule_node_parent(node);
10480 node = isl_schedule_node_group(node, group_id: id);
10481 node = isl_schedule_node_child(node, pos: 0);
10482 umap2 = isl_schedule_node_get_prefix_schedule_union_map(node);
10483 upma2 = isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(node);
10484 domain2 = isl_schedule_node_get_domain(node);
10485 equal = isl_union_pw_multi_aff_plain_is_equal(upma1, upma2);
10486 if (equal >= 0 && equal)
10487 equal = isl_union_set_is_equal(uset1: domain1, uset2: domain2);
10488 if (equal >= 0 && equal)
10489 equal = isl_union_map_is_equal(umap1, umap2);
10490 isl_union_map_free(umap: umap1);
10491 isl_union_map_free(umap: umap2);
10492 isl_union_set_free(uset: domain1);
10493 isl_union_set_free(uset: domain2);
10494 isl_union_pw_multi_aff_free(upma: upma1);
10495 isl_union_pw_multi_aff_free(upma: upma2);
10496 isl_schedule_node_free(node);
10497
10498 if (equal < 0)
10499 return -1;
10500 if (!equal)
10501 isl_die(ctx, isl_error_unknown,
10502 "expressions not equal", return -1);
10503
10504 return 0;
10505}
10506
10507/* Check that we can have nested groupings and that the union map
10508 * schedule representation is the same before and after the grouping.
10509 * Note that after the grouping, the union map representation contains
10510 * the domain constraints from the ranges of the expansion nodes,
10511 * while they are missing from the union map representation of
10512 * the tree without expansion nodes.
10513 *
10514 * Also check that the global expansion is as expected.
10515 */
10516static int test_schedule_tree_group_2(isl_ctx *ctx)
10517{
10518 int equal, equal_expansion;
10519 const char *str;
10520 isl_id *id;
10521 isl_union_set *uset;
10522 isl_union_map *umap1, *umap2;
10523 isl_union_map *expansion1, *expansion2;
10524 isl_union_set_list *filters;
10525 isl_multi_union_pw_aff *mupa;
10526 isl_schedule *schedule;
10527 isl_schedule_node *node;
10528
10529 str = "{ S1[i,j] : 0 <= i,j < 10; S2[i,j] : 0 <= i,j < 10; "
10530 "S3[i,j] : 0 <= i,j < 10 }";
10531 uset = isl_union_set_read_from_str(ctx, str);
10532 node = isl_schedule_node_from_domain(domain: uset);
10533 node = isl_schedule_node_child(node, pos: 0);
10534 str = "[{ S1[i,j] -> [i]; S2[i,j] -> [i]; S3[i,j] -> [i] }]";
10535 mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
10536 node = isl_schedule_node_insert_partial_schedule(node, schedule: mupa);
10537 node = isl_schedule_node_child(node, pos: 0);
10538 str = "{ S1[i,j] }";
10539 uset = isl_union_set_read_from_str(ctx, str);
10540 filters = isl_union_set_list_from_union_set(el: uset);
10541 str = "{ S2[i,j]; S3[i,j] }";
10542 uset = isl_union_set_read_from_str(ctx, str);
10543 filters = isl_union_set_list_add(list: filters, el: uset);
10544 node = isl_schedule_node_insert_sequence(node, filters);
10545 node = isl_schedule_node_grandchild(node, pos1: 1, pos2: 0);
10546 str = "{ S2[i,j] }";
10547 uset = isl_union_set_read_from_str(ctx, str);
10548 filters = isl_union_set_list_from_union_set(el: uset);
10549 str = "{ S3[i,j] }";
10550 uset = isl_union_set_read_from_str(ctx, str);
10551 filters = isl_union_set_list_add(list: filters, el: uset);
10552 node = isl_schedule_node_insert_sequence(node, filters);
10553
10554 schedule = isl_schedule_node_get_schedule(node);
10555 umap1 = isl_schedule_get_map(sched: schedule);
10556 uset = isl_schedule_get_domain(schedule);
10557 umap1 = isl_union_map_intersect_domain(umap: umap1, uset);
10558 isl_schedule_free(sched: schedule);
10559
10560 node = isl_schedule_node_grandparent(node);
10561 id = isl_id_alloc(ctx, name: "group1", NULL);
10562 node = isl_schedule_node_group(node, group_id: id);
10563 node = isl_schedule_node_grandchild(node, pos1: 1, pos2: 0);
10564 id = isl_id_alloc(ctx, name: "group2", NULL);
10565 node = isl_schedule_node_group(node, group_id: id);
10566
10567 schedule = isl_schedule_node_get_schedule(node);
10568 umap2 = isl_schedule_get_map(sched: schedule);
10569 isl_schedule_free(sched: schedule);
10570
10571 node = isl_schedule_node_root(node);
10572 node = isl_schedule_node_child(node, pos: 0);
10573 expansion1 = isl_schedule_node_get_subtree_expansion(node);
10574 isl_schedule_node_free(node);
10575
10576 str = "{ group1[i] -> S1[i,j] : 0 <= i,j < 10; "
10577 "group1[i] -> S2[i,j] : 0 <= i,j < 10; "
10578 "group1[i] -> S3[i,j] : 0 <= i,j < 10 }";
10579
10580 expansion2 = isl_union_map_read_from_str(ctx, str);
10581
10582 equal = isl_union_map_is_equal(umap1, umap2);
10583 equal_expansion = isl_union_map_is_equal(umap1: expansion1, umap2: expansion2);
10584
10585 isl_union_map_free(umap: umap1);
10586 isl_union_map_free(umap: umap2);
10587 isl_union_map_free(umap: expansion1);
10588 isl_union_map_free(umap: expansion2);
10589
10590 if (equal < 0 || equal_expansion < 0)
10591 return -1;
10592 if (!equal)
10593 isl_die(ctx, isl_error_unknown,
10594 "expressions not equal", return -1);
10595 if (!equal_expansion)
10596 isl_die(ctx, isl_error_unknown,
10597 "unexpected expansion", return -1);
10598
10599 return 0;
10600}
10601
10602/* Some tests for the isl_schedule_node_group function.
10603 */
10604static int test_schedule_tree_group(isl_ctx *ctx)
10605{
10606 if (test_schedule_tree_group_1(ctx) < 0)
10607 return -1;
10608 if (test_schedule_tree_group_2(ctx) < 0)
10609 return -1;
10610 return 0;
10611}
10612
10613struct {
10614 const char *set;
10615 const char *dual;
10616} coef_tests[] = {
10617 { "{ rat: [i] : 0 <= i <= 10 }",
10618 "{ rat: coefficients[[cst] -> [a]] : cst >= 0 and 10a + cst >= 0 }" },
10619 { "{ rat: [i] : FALSE }",
10620 "{ rat: coefficients[[cst] -> [a]] }" },
10621 { "{ rat: [i] : }",
10622 "{ rat: coefficients[[cst] -> [0]] : cst >= 0 }" },
10623 { "{ [0:,1,2:3] }",
10624 "{ rat: coefficients[[c_cst] -> [a, b, c]] : "
10625 "a >= 0 and 2c >= -c_cst - b and 3c >= -c_cst - b }" },
10626 { "[M, N] -> { [x = (1 - N):-1, -4x:(M - 4x)] }",
10627 "{ rat: coefficients[[c_cst, c_M = 0:, c_N = 0:] -> [a, b = -c_M:]] :"
10628 "4b >= -c_N + a and 4b >= -c_cst - 2c_N + a }" },
10629 { "{ rat : [x, y] : 1 <= 2x <= 9 and 2 <= 3y <= 16 }",
10630 "{ rat: coefficients[[c_cst] -> [c_x, c_y]] : "
10631 "4c_y >= -6c_cst - 3c_x and 4c_y >= -6c_cst - 27c_x and "
10632 "32c_y >= -6c_cst - 3c_x and 32c_y >= -6c_cst - 27c_x }" },
10633 { "{ [x, y, z] : 3y <= 2x - 2 and y >= -2 + 2x and 2y >= 2 - x }",
10634 "{ rat: coefficients[[cst] -> [a, b, c]] }" },
10635};
10636
10637struct {
10638 const char *set;
10639 const char *dual;
10640} sol_tests[] = {
10641 { "{ rat: coefficients[[cst] -> [a]] : cst >= 0 and 10a + cst >= 0 }",
10642 "{ rat: [i] : 0 <= i <= 10 }" },
10643 { "{ rat: coefficients[[cst] -> [a]] : FALSE }",
10644 "{ rat: [i] }" },
10645 { "{ rat: coefficients[[cst] -> [a]] }",
10646 "{ rat: [i] : FALSE }" },
10647};
10648
10649/* Test the basic functionality of isl_basic_set_coefficients and
10650 * isl_basic_set_solutions.
10651 */
10652static int test_dual(isl_ctx *ctx)
10653{
10654 int i;
10655
10656 for (i = 0; i < ARRAY_SIZE(coef_tests); ++i) {
10657 int equal;
10658 isl_basic_set *bset1, *bset2;
10659
10660 bset1 = isl_basic_set_read_from_str(ctx, str: coef_tests[i].set);
10661 bset2 = isl_basic_set_read_from_str(ctx, str: coef_tests[i].dual);
10662 bset1 = isl_basic_set_coefficients(bset: bset1);
10663 equal = isl_basic_set_is_equal(bset1, bset2);
10664 isl_basic_set_free(bset: bset1);
10665 isl_basic_set_free(bset: bset2);
10666 if (equal < 0)
10667 return -1;
10668 if (!equal)
10669 isl_die(ctx, isl_error_unknown,
10670 "incorrect dual", return -1);
10671 }
10672
10673 for (i = 0; i < ARRAY_SIZE(sol_tests); ++i) {
10674 int equal;
10675 isl_basic_set *bset1, *bset2;
10676
10677 bset1 = isl_basic_set_read_from_str(ctx, str: sol_tests[i].set);
10678 bset2 = isl_basic_set_read_from_str(ctx, str: sol_tests[i].dual);
10679 bset1 = isl_basic_set_solutions(bset: bset1);
10680 equal = isl_basic_set_is_equal(bset1, bset2);
10681 isl_basic_set_free(bset: bset1);
10682 isl_basic_set_free(bset: bset2);
10683 if (equal < 0)
10684 return -1;
10685 if (!equal)
10686 isl_die(ctx, isl_error_unknown,
10687 "incorrect dual", return -1);
10688 }
10689
10690 return 0;
10691}
10692
10693struct {
10694 int scale_tile;
10695 int shift_point;
10696 const char *domain;
10697 const char *schedule;
10698 const char *sizes;
10699 const char *tile;
10700 const char *point;
10701} tile_tests[] = {
10702 { 0, 0, "[n] -> { S[i,j] : 0 <= i,j < n }",
10703 "[{ S[i,j] -> [i] }, { S[i,j] -> [j] }]",
10704 "{ [32,32] }",
10705 "[{ S[i,j] -> [floor(i/32)] }, { S[i,j] -> [floor(j/32)] }]",
10706 "[{ S[i,j] -> [i] }, { S[i,j] -> [j] }]",
10707 },
10708 { 1, 0, "[n] -> { S[i,j] : 0 <= i,j < n }",
10709 "[{ S[i,j] -> [i] }, { S[i,j] -> [j] }]",
10710 "{ [32,32] }",
10711 "[{ S[i,j] -> [32*floor(i/32)] }, { S[i,j] -> [32*floor(j/32)] }]",
10712 "[{ S[i,j] -> [i] }, { S[i,j] -> [j] }]",
10713 },
10714 { 0, 1, "[n] -> { S[i,j] : 0 <= i,j < n }",
10715 "[{ S[i,j] -> [i] }, { S[i,j] -> [j] }]",
10716 "{ [32,32] }",
10717 "[{ S[i,j] -> [floor(i/32)] }, { S[i,j] -> [floor(j/32)] }]",
10718 "[{ S[i,j] -> [i%32] }, { S[i,j] -> [j%32] }]",
10719 },
10720 { 1, 1, "[n] -> { S[i,j] : 0 <= i,j < n }",
10721 "[{ S[i,j] -> [i] }, { S[i,j] -> [j] }]",
10722 "{ [32,32] }",
10723 "[{ S[i,j] -> [32*floor(i/32)] }, { S[i,j] -> [32*floor(j/32)] }]",
10724 "[{ S[i,j] -> [i%32] }, { S[i,j] -> [j%32] }]",
10725 },
10726};
10727
10728/* Basic tiling tests. Create a schedule tree with a domain and a band node,
10729 * tile the band and then check if the tile and point bands have the
10730 * expected partial schedule.
10731 */
10732static int test_tile(isl_ctx *ctx)
10733{
10734 int i;
10735 int scale;
10736 int shift;
10737
10738 scale = isl_options_get_tile_scale_tile_loops(ctx);
10739 shift = isl_options_get_tile_shift_point_loops(ctx);
10740
10741 for (i = 0; i < ARRAY_SIZE(tile_tests); ++i) {
10742 int opt;
10743 int equal;
10744 const char *str;
10745 isl_union_set *domain;
10746 isl_multi_union_pw_aff *mupa, *mupa2;
10747 isl_schedule_node *node;
10748 isl_multi_val *sizes;
10749
10750 opt = tile_tests[i].scale_tile;
10751 isl_options_set_tile_scale_tile_loops(ctx, val: opt);
10752 opt = tile_tests[i].shift_point;
10753 isl_options_set_tile_shift_point_loops(ctx, val: opt);
10754
10755 str = tile_tests[i].domain;
10756 domain = isl_union_set_read_from_str(ctx, str);
10757 node = isl_schedule_node_from_domain(domain);
10758 node = isl_schedule_node_child(node, pos: 0);
10759 str = tile_tests[i].schedule;
10760 mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
10761 node = isl_schedule_node_insert_partial_schedule(node, schedule: mupa);
10762 str = tile_tests[i].sizes;
10763 sizes = isl_multi_val_read_from_str(ctx, str);
10764 node = isl_schedule_node_band_tile(node, sizes);
10765
10766 str = tile_tests[i].tile;
10767 mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
10768 mupa2 = isl_schedule_node_band_get_partial_schedule(node);
10769 equal = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa, multi2: mupa2);
10770 isl_multi_union_pw_aff_free(multi: mupa);
10771 isl_multi_union_pw_aff_free(multi: mupa2);
10772
10773 node = isl_schedule_node_child(node, pos: 0);
10774
10775 str = tile_tests[i].point;
10776 mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
10777 mupa2 = isl_schedule_node_band_get_partial_schedule(node);
10778 if (equal >= 0 && equal)
10779 equal = isl_multi_union_pw_aff_plain_is_equal(multi1: mupa,
10780 multi2: mupa2);
10781 isl_multi_union_pw_aff_free(multi: mupa);
10782 isl_multi_union_pw_aff_free(multi: mupa2);
10783
10784 isl_schedule_node_free(node);
10785
10786 if (equal < 0)
10787 return -1;
10788 if (!equal)
10789 isl_die(ctx, isl_error_unknown,
10790 "unexpected result", return -1);
10791 }
10792
10793 isl_options_set_tile_scale_tile_loops(ctx, val: scale);
10794 isl_options_set_tile_shift_point_loops(ctx, val: shift);
10795
10796 return 0;
10797}
10798
10799/* Check that the domain hash of a space is equal to the hash
10800 * of the domain of the space, both ignoring parameters.
10801 */
10802static int test_domain_hash(isl_ctx *ctx)
10803{
10804 isl_map *map;
10805 isl_space *space;
10806 uint32_t hash1, hash2;
10807
10808 map = isl_map_read_from_str(ctx, str: "[n] -> { A[B[x] -> C[]] -> D[] }");
10809 space = isl_map_get_space(map);
10810 isl_map_free(map);
10811 hash1 = isl_space_get_tuple_domain_hash(space);
10812 space = isl_space_domain(space);
10813 hash2 = isl_space_get_tuple_hash(space);
10814 isl_space_free(space);
10815
10816 if (!space)
10817 return -1;
10818 if (hash1 != hash2)
10819 isl_die(ctx, isl_error_unknown,
10820 "domain hash not equal to hash of domain", return -1);
10821
10822 return 0;
10823}
10824
10825/* Check that a universe basic set that is not obviously equal to the universe
10826 * is still recognized as being equal to the universe.
10827 */
10828static int test_universe(isl_ctx *ctx)
10829{
10830 const char *s;
10831 isl_basic_set *bset;
10832 isl_bool is_univ;
10833
10834 s = "{ [] : exists x, y : 3y <= 2x and y >= -3 + 2x and 2y >= 2 - x }";
10835 bset = isl_basic_set_read_from_str(ctx, str: s);
10836 is_univ = isl_basic_set_is_universe(bset);
10837 isl_basic_set_free(bset);
10838
10839 if (is_univ < 0)
10840 return -1;
10841 if (!is_univ)
10842 isl_die(ctx, isl_error_unknown,
10843 "not recognized as universe set", return -1);
10844
10845 return 0;
10846}
10847
10848/* Sets for which chambers are computed and checked.
10849 */
10850const char *chambers_tests[] = {
10851 "[A, B, C] -> { [x, y, z] : x >= 0 and y >= 0 and y <= A - x and "
10852 "z >= 0 and z <= C - y and z <= B - x - y }",
10853};
10854
10855/* Add the domain of "cell" to "cells".
10856 */
10857static isl_stat add_cell(__isl_take isl_cell *cell, void *user)
10858{
10859 isl_basic_set_list **cells = user;
10860 isl_basic_set *dom;
10861
10862 dom = isl_cell_get_domain(cell);
10863 isl_cell_free(cell);
10864 *cells = isl_basic_set_list_add(list: *cells, el: dom);
10865
10866 return *cells ? isl_stat_ok : isl_stat_error;
10867}
10868
10869/* Check that the elements of "list" are pairwise disjoint.
10870 */
10871static isl_stat check_pairwise_disjoint(__isl_keep isl_basic_set_list *list)
10872{
10873 int i, j;
10874 isl_size n;
10875
10876 n = isl_basic_set_list_n_basic_set(list);
10877 if (n < 0)
10878 return isl_stat_error;
10879
10880 for (i = 0; i < n; ++i) {
10881 isl_basic_set *bset_i;
10882
10883 bset_i = isl_basic_set_list_get_basic_set(list, index: i);
10884 for (j = i + 1; j < n; ++j) {
10885 isl_basic_set *bset_j;
10886 isl_bool disjoint;
10887
10888 bset_j = isl_basic_set_list_get_basic_set(list, index: j);
10889 disjoint = isl_basic_set_is_disjoint(bset1: bset_i, bset2: bset_j);
10890 isl_basic_set_free(bset: bset_j);
10891 if (!disjoint)
10892 isl_die(isl_basic_set_list_get_ctx(list),
10893 isl_error_unknown, "not disjoint",
10894 break);
10895 if (disjoint < 0 || !disjoint)
10896 break;
10897 }
10898 isl_basic_set_free(bset: bset_i);
10899 if (j < n)
10900 return isl_stat_error;
10901 }
10902
10903 return isl_stat_ok;
10904}
10905
10906/* Check that the chambers computed by isl_vertices_foreach_disjoint_cell
10907 * are pairwise disjoint.
10908 */
10909static int test_chambers(isl_ctx *ctx)
10910{
10911 int i;
10912
10913 for (i = 0; i < ARRAY_SIZE(chambers_tests); ++i) {
10914 isl_basic_set *bset;
10915 isl_vertices *vertices;
10916 isl_basic_set_list *cells;
10917 isl_stat ok;
10918
10919 bset = isl_basic_set_read_from_str(ctx, str: chambers_tests[i]);
10920 vertices = isl_basic_set_compute_vertices(bset);
10921 cells = isl_basic_set_list_alloc(ctx, n: 0);
10922 if (isl_vertices_foreach_disjoint_cell(vertices, fn: &add_cell,
10923 user: &cells) < 0)
10924 cells = isl_basic_set_list_free(list: cells);
10925 ok = check_pairwise_disjoint(list: cells);
10926 isl_basic_set_list_free(list: cells);
10927 isl_vertices_free(vertices);
10928 isl_basic_set_free(bset);
10929
10930 if (ok < 0)
10931 return -1;
10932 }
10933
10934 return 0;
10935}
10936
10937struct {
10938 const char *name;
10939 int (*fn)(isl_ctx *ctx);
10940} tests [] = {
10941 { "universe", &test_universe },
10942 { "domain hash", &test_domain_hash },
10943 { "dual", &test_dual },
10944 { "dependence analysis", &test_flow },
10945 { "val", &test_val },
10946 { "compute divs", &test_compute_divs },
10947 { "partial lexmin", &test_partial_lexmin },
10948 { "simplify", &test_simplify },
10949 { "curry", &test_curry },
10950 { "piecewise multi affine expressions", &test_pw_multi_aff },
10951 { "multi piecewise affine expressions", &test_multi_pw_aff },
10952 { "conversion", &test_conversion },
10953 { "list", &test_list },
10954 { "align parameters", &test_align_parameters },
10955 { "drop unused parameters", &test_drop_unused_parameters },
10956 { "pullback", &test_pullback },
10957 { "AST", &test_ast },
10958 { "AST build", &test_ast_build },
10959 { "AST generation", &test_ast_gen },
10960 { "eliminate", &test_eliminate },
10961 { "deltas_map", &test_deltas_map },
10962 { "residue class", &test_residue_class },
10963 { "div", &test_div },
10964 { "slice", &test_slice },
10965 { "sample", &test_sample },
10966 { "empty projection", &test_empty_projection },
10967 { "output", &test_output },
10968 { "vertices", &test_vertices },
10969 { "chambers", &test_chambers },
10970 { "fixed", &test_fixed },
10971 { "equal", &test_equal },
10972 { "disjoint", &test_disjoint },
10973 { "product", &test_product },
10974 { "dim_max", &test_dim_max },
10975 { "affine", &test_aff },
10976 { "injective", &test_injective },
10977 { "schedule (whole component)", &test_schedule_whole },
10978 { "schedule (incremental)", &test_schedule_incremental },
10979 { "schedule tree", &test_schedule_tree },
10980 { "schedule tree prefix", &test_schedule_tree_prefix },
10981 { "schedule tree grouping", &test_schedule_tree_group },
10982 { "tile", &test_tile },
10983 { "union map", &test_union_map },
10984 { "union_pw", &test_union_pw },
10985 { "locus", &test_locus },
10986 { "eval", &test_eval },
10987 { "parse", &test_parse },
10988 { "single-valued", &test_sv },
10989 { "recession cone", &test_recession_cone },
10990 { "affine hull", &test_affine_hull },
10991 { "simple_hull", &test_simple_hull },
10992 { "box hull", &test_box_hull },
10993 { "coalesce", &test_coalesce },
10994 { "factorize", &test_factorize },
10995 { "subset", &test_subset },
10996 { "subtract", &test_subtract },
10997 { "intersect", &test_intersect },
10998 { "lexmin", &test_lexmin },
10999 { "min", &test_min },
11000 { "set lower bounds", &test_min_mpa },
11001 { "gist", &test_gist },
11002 { "piecewise quasi-polynomials", &test_pwqp },
11003 { "lift", &test_lift },
11004 { "bind parameters", &test_bind },
11005 { "unbind parameters", &test_unbind },
11006 { "bound", &test_bound },
11007 { "get lists", &test_get_list },
11008 { "union", &test_union },
11009 { "split periods", &test_split_periods },
11010 { "lexicographic order", &test_lex },
11011 { "bijectivity", &test_bijective },
11012 { "dataflow analysis", &test_dep },
11013 { "reading", &test_read },
11014 { "bounded", &test_bounded },
11015 { "construction", &test_construction },
11016 { "dimension manipulation", &test_dim },
11017 { "map application", &test_application },
11018 { "convex hull", &test_convex_hull },
11019 { "transitive closure", &test_closure },
11020 { "isl_bool", &test_isl_bool},
11021};
11022
11023int main(int argc, char **argv)
11024{
11025 int i;
11026 struct isl_ctx *ctx;
11027 struct isl_options *options;
11028
11029 options = isl_options_new_with_defaults();
11030 assert(options);
11031 argc = isl_options_parse(opt: options, argc, argv, ISL_ARG_ALL);
11032
11033 ctx = isl_ctx_alloc_with_options(args: &isl_options_args, opt: options);
11034 for (i = 0; i < ARRAY_SIZE(tests); ++i) {
11035 printf(format: "%s\n", tests[i].name);
11036 if (tests[i].fn(ctx) < 0)
11037 goto error;
11038 }
11039 isl_ctx_free(ctx);
11040 return 0;
11041error:
11042 isl_ctx_free(ctx);
11043 return -1;
11044}
11045

source code of polly/lib/External/isl/isl_test.c