?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add isl_union_map_involves_dims
[isl.git] / isl_pw_templ.c
blob594f6b73cc631c2c661a41f282933bb98f25ddc4
1 /*
2 * Copyright 2010-2011 INRIA Saclay
3 * Copyright 2011 Sven Verdoolaege
4 * Copyright 2012-2014 Ecole Normale Superieure
5 *
6 * Use of this software is governed by the MIT license
7 *
8 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
9 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
10 * 91893 Orsay, France
11 * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
12 */
13
14 #include <isl/aff.h>
15 #include <isl_val_private.h>
16
17 #define xFN(TYPE,NAME) TYPE ## _ ## NAME
18 #define FN(TYPE,NAME) xFN(TYPE,NAME)
19 #define xS(TYPE,NAME) struct TYPE ## _ ## NAME
20 #define S(TYPE,NAME) xS(TYPE,NAME)
21
22 #ifdef HAS_TYPE
23 __isl_give PW *FN(PW,alloc_size)(__isl_take isl_space *dim,
24 enum isl_fold type, int n)
25 #else
26 __isl_give PW *FN(PW,alloc_size)(__isl_take isl_space *dim, int n)
27 #endif
28 {
29 isl_ctx *ctx;
30 struct PW *pw;
31
32 if (!dim)
33 return NULL;
34 ctx = isl_space_get_ctx(dim);
35 isl_assert(ctx, n >= 0, goto error);
36 pw = isl_alloc(ctx, struct PW,
37 sizeof(struct PW) + (n - 1) * sizeof(S(PW,piece)));
38 if (!pw)
39 goto error;
40
41 pw->ref = 1;
42 #ifdef HAS_TYPE
43 pw->type = type;
44 #endif
45 pw->size = n;
46 pw->n = 0;
47 pw->dim = dim;
48 return pw;
49 error:
50 isl_space_free(dim);
51 return NULL;
52 }
53
54 #ifdef HAS_TYPE
55 __isl_give PW *FN(PW,ZERO)(__isl_take isl_space *dim, enum isl_fold type)
56 {
57 return FN(PW,alloc_size)(dim, type, 0);
58 }
59 #else
60 __isl_give PW *FN(PW,ZERO)(__isl_take isl_space *dim)
61 {
62 return FN(PW,alloc_size)(dim, 0);
63 }
64 #endif
65
66 __isl_give PW *FN(PW,add_piece)(__isl_take PW *pw,
67 __isl_take isl_set *set, __isl_take EL *el)
68 {
69 isl_ctx *ctx;
70 isl_space *el_dim = NULL;
71
72 if (!pw || !set || !el)
73 goto error;
74
75 if (isl_set_plain_is_empty(set) || FN(EL,EL_IS_ZERO)(el)) {
76 isl_set_free(set);
77 FN(EL,free)(el);
78 return pw;
79 }
80
81 ctx = isl_set_get_ctx(set);
82 #ifdef HAS_TYPE
83 if (pw->type != el->type)
84 isl_die(ctx, isl_error_invalid, "fold types don't match",
85 goto error);
86 #endif
87 el_dim = FN(EL,get_space(el));
88 isl_assert(ctx, isl_space_is_equal(pw->dim, el_dim), goto error);
89 isl_assert(ctx, pw->n < pw->size, goto error);
90
91 pw->p[pw->n].set = set;
92 pw->p[pw->n].FIELD = el;
93 pw->n++;
94
95 isl_space_free(el_dim);
96 return pw;
97 error:
98 isl_space_free(el_dim);
99 FN(PW,free)(pw);
100 isl_set_free(set);
101 FN(EL,free)(el);
102 return NULL;
103 }
104
105 #ifdef HAS_TYPE
106 __isl_give PW *FN(PW,alloc)(enum isl_fold type,
107 __isl_take isl_set *set, __isl_take EL *el)
108 #else
109 __isl_give PW *FN(PW,alloc)(__isl_take isl_set *set, __isl_take EL *el)
110 #endif
111 {
112 PW *pw;
113
114 if (!set || !el)
115 goto error;
116
117 #ifdef HAS_TYPE
118 pw = FN(PW,alloc_size)(FN(EL,get_space)(el), type, 1);
119 #else
120 pw = FN(PW,alloc_size)(FN(EL,get_space)(el), 1);
121 #endif
122
123 return FN(PW,add_piece)(pw, set, el);
124 error:
125 isl_set_free(set);
126 FN(EL,free)(el);
127 return NULL;
128 }
129
130 __isl_give PW *FN(PW,dup)(__isl_keep PW *pw)
131 {
132 int i;
133 PW *dup;
134
135 if (!pw)
136 return NULL;
137
138 #ifdef HAS_TYPE
139 dup = FN(PW,alloc_size)(isl_space_copy(pw->dim), pw->type, pw->n);
140 #else
141 dup = FN(PW,alloc_size)(isl_space_copy(pw->dim), pw->n);
142 #endif
143 if (!dup)
144 return NULL;
145
146 for (i = 0; i < pw->n; ++i)
147 dup = FN(PW,add_piece)(dup, isl_set_copy(pw->p[i].set),
148 FN(EL,copy)(pw->p[i].FIELD));
149
150 return dup;
151 }
152
153 __isl_give PW *FN(PW,cow)(__isl_take PW *pw)
154 {
155 if (!pw)
156 return NULL;
157
158 if (pw->ref == 1)
159 return pw;
160 pw->ref--;
161 return FN(PW,dup)(pw);
162 }
163
164 __isl_give PW *FN(PW,copy)(__isl_keep PW *pw)
165 {
166 if (!pw)
167 return NULL;
168
169 pw->ref++;
170 return pw;
171 }
172
173 __isl_null PW *FN(PW,free)(__isl_take PW *pw)
174 {
175 int i;
176
177 if (!pw)
178 return NULL;
179 if (--pw->ref > 0)
180 return NULL;
181
182 for (i = 0; i < pw->n; ++i) {
183 isl_set_free(pw->p[i].set);
184 FN(EL,free)(pw->p[i].FIELD);
185 }
186 isl_space_free(pw->dim);
187 free(pw);
188
189 return NULL;
190 }
191
192 const char *FN(PW,get_dim_name)(__isl_keep PW *pw, enum isl_dim_type type,
193 unsigned pos)
194 {
195 return pw ? isl_space_get_dim_name(pw->dim, type, pos) : NULL;
196 }
197
198 int FN(PW,has_dim_id)(__isl_keep PW *pw, enum isl_dim_type type, unsigned pos)
199 {
200 return pw ? isl_space_has_dim_id(pw->dim, type, pos) : -1;
201 }
202
203 __isl_give isl_id *FN(PW,get_dim_id)(__isl_keep PW *pw, enum isl_dim_type type,
204 unsigned pos)
205 {
206 return pw ? isl_space_get_dim_id(pw->dim, type, pos) : NULL;
207 }
208
209 int FN(PW,has_tuple_name)(__isl_keep PW *pw, enum isl_dim_type type)
210 {
211 return pw ? isl_space_has_tuple_name(pw->dim, type) : -1;
212 }
213
214 const char *FN(PW,get_tuple_name)(__isl_keep PW *pw, enum isl_dim_type type)
215 {
216 return pw ? isl_space_get_tuple_name(pw->dim, type) : NULL;
217 }
218
219 int FN(PW,has_tuple_id)(__isl_keep PW *pw, enum isl_dim_type type)
220 {
221 return pw ? isl_space_has_tuple_id(pw->dim, type) : -1;
222 }
223
224 __isl_give isl_id *FN(PW,get_tuple_id)(__isl_keep PW *pw, enum isl_dim_type type)
225 {
226 return pw ? isl_space_get_tuple_id(pw->dim, type) : NULL;
227 }
228
229 int FN(PW,IS_ZERO)(__isl_keep PW *pw)
230 {
231 if (!pw)
232 return -1;
233
234 return pw->n == 0;
235 }
236
237 #ifndef NO_REALIGN
238 __isl_give PW *FN(PW,realign_domain)(__isl_take PW *pw,
239 __isl_take isl_reordering *exp)
240 {
241 int i;
242
243 pw = FN(PW,cow)(pw);
244 if (!pw || !exp)
245 goto error;
246
247 for (i = 0; i < pw->n; ++i) {
248 pw->p[i].set = isl_set_realign(pw->p[i].set,
249 isl_reordering_copy(exp));
250 if (!pw->p[i].set)
251 goto error;
252 pw->p[i].FIELD = FN(EL,realign_domain)(pw->p[i].FIELD,
253 isl_reordering_copy(exp));
254 if (!pw->p[i].FIELD)
255 goto error;
256 }
257
258 pw = FN(PW,reset_domain_space)(pw, isl_space_copy(exp->dim));
259
260 isl_reordering_free(exp);
261 return pw;
262 error:
263 isl_reordering_free(exp);
264 FN(PW,free)(pw);
265 return NULL;
266 }
267
268 /* Align the parameters of "pw" to those of "model".
269 */
270 __isl_give PW *FN(PW,align_params)(__isl_take PW *pw, __isl_take isl_space *model)
271 {
272 isl_ctx *ctx;
273
274 if (!pw || !model)
275 goto error;
276
277 ctx = isl_space_get_ctx(model);
278 if (!isl_space_has_named_params(model))
279 isl_die(ctx, isl_error_invalid,
280 "model has unnamed parameters", goto error);
281 if (!isl_space_has_named_params(pw->dim))
282 isl_die(ctx, isl_error_invalid,
283 "input has unnamed parameters", goto error);
284 if (!isl_space_match(pw->dim, isl_dim_param, model, isl_dim_param)) {
285 isl_reordering *exp;
286
287 model = isl_space_drop_dims(model, isl_dim_in,
288 0, isl_space_dim(model, isl_dim_in));
289 model = isl_space_drop_dims(model, isl_dim_out,
290 0, isl_space_dim(model, isl_dim_out));
291 exp = isl_parameter_alignment_reordering(pw->dim, model);
292 exp = isl_reordering_extend_space(exp,
293 FN(PW,get_domain_space)(pw));
294 pw = FN(PW,realign_domain)(pw, exp);
295 }
296
297 isl_space_free(model);
298 return pw;
299 error:
300 isl_space_free(model);
301 FN(PW,free)(pw);
302 return NULL;
303 }
304
305 static __isl_give PW *FN(PW,align_params_pw_pw_and)(__isl_take PW *pw1,
306 __isl_take PW *pw2,
307 __isl_give PW *(*fn)(__isl_take PW *pw1, __isl_take PW *pw2))
308 {
309 isl_ctx *ctx;
310
311 if (!pw1 || !pw2)
312 goto error;
313 if (isl_space_match(pw1->dim, isl_dim_param, pw2->dim, isl_dim_param))
314 return fn(pw1, pw2);
315 ctx = FN(PW,get_ctx)(pw1);
316 if (!isl_space_has_named_params(pw1->dim) ||
317 !isl_space_has_named_params(pw2->dim))
318 isl_die(ctx, isl_error_invalid,
319 "unaligned unnamed parameters", goto error);
320 pw1 = FN(PW,align_params)(pw1, FN(PW,get_space)(pw2));
321 pw2 = FN(PW,align_params)(pw2, FN(PW,get_space)(pw1));
322 return fn(pw1, pw2);
323 error:
324 FN(PW,free)(pw1);
325 FN(PW,free)(pw2);
326 return NULL;
327 }
328
329 static __isl_give PW *FN(PW,align_params_pw_set_and)(__isl_take PW *pw,
330 __isl_take isl_set *set,
331 __isl_give PW *(*fn)(__isl_take PW *pw, __isl_take isl_set *set))
332 {
333 isl_ctx *ctx;
334
335 if (!pw || !set)
336 goto error;
337 if (isl_space_match(pw->dim, isl_dim_param, set->dim, isl_dim_param))
338 return fn(pw, set);
339 ctx = FN(PW,get_ctx)(pw);
340 if (!isl_space_has_named_params(pw->dim) ||
341 !isl_space_has_named_params(set->dim))
342 isl_die(ctx, isl_error_invalid,
343 "unaligned unnamed parameters", goto error);
344 pw = FN(PW,align_params)(pw, isl_set_get_space(set));
345 set = isl_set_align_params(set, FN(PW,get_space)(pw));
346 return fn(pw, set);
347 error:
348 FN(PW,free)(pw);
349 isl_set_free(set);
350 return NULL;
351 }
352 #endif
353
354 static __isl_give PW *FN(PW,union_add_aligned)(__isl_take PW *pw1,
355 __isl_take PW *pw2)
356 {
357 int i, j, n;
358 struct PW *res;
359 isl_ctx *ctx;
360 isl_set *set;
361
362 if (!pw1 || !pw2)
363 goto error;
364
365 ctx = isl_space_get_ctx(pw1->dim);
366 #ifdef HAS_TYPE
367 if (pw1->type != pw2->type)
368 isl_die(ctx, isl_error_invalid,
369 "fold types don't match", goto error);
370 #endif
371 isl_assert(ctx, isl_space_is_equal(pw1->dim, pw2->dim), goto error);
372
373 if (FN(PW,IS_ZERO)(pw1)) {
374 FN(PW,free)(pw1);
375 return pw2;
376 }
377
378 if (FN(PW,IS_ZERO)(pw2)) {
379 FN(PW,free)(pw2);
380 return pw1;
381 }
382
383 n = (pw1->n + 1) * (pw2->n + 1);
384 #ifdef HAS_TYPE
385 res = FN(PW,alloc_size)(isl_space_copy(pw1->dim), pw1->type, n);
386 #else
387 res = FN(PW,alloc_size)(isl_space_copy(pw1->dim), n);
388 #endif
389
390 for (i = 0; i < pw1->n; ++i) {
391 set = isl_set_copy(pw1->p[i].set);
392 for (j = 0; j < pw2->n; ++j) {
393 struct isl_set *common;
394 EL *sum;
395 common = isl_set_intersect(isl_set_copy(pw1->p[i].set),
396 isl_set_copy(pw2->p[j].set));
397 if (isl_set_plain_is_empty(common)) {
398 isl_set_free(common);
399 continue;
400 }
401 set = isl_set_subtract(set,
402 isl_set_copy(pw2->p[j].set));
403
404 sum = FN(EL,add_on_domain)(common,
405 FN(EL,copy)(pw1->p[i].FIELD),
406 FN(EL,copy)(pw2->p[j].FIELD));
407
408 res = FN(PW,add_piece)(res, common, sum);
409 }
410 res = FN(PW,add_piece)(res, set, FN(EL,copy)(pw1->p[i].FIELD));
411 }
412
413 for (j = 0; j < pw2->n; ++j) {
414 set = isl_set_copy(pw2->p[j].set);
415 for (i = 0; i < pw1->n; ++i)
416 set = isl_set_subtract(set,
417 isl_set_copy(pw1->p[i].set));
418 res = FN(PW,add_piece)(res, set, FN(EL,copy)(pw2->p[j].FIELD));
419 }
420
421 FN(PW,free)(pw1);
422 FN(PW,free)(pw2);
423
424 return res;
425 error:
426 FN(PW,free)(pw1);
427 FN(PW,free)(pw2);
428 return NULL;
429 }
430
431 /* Private version of "union_add". For isl_pw_qpolynomial and
432 * isl_pw_qpolynomial_fold, we prefer to simply call it "add".
433 */
434 static __isl_give PW *FN(PW,union_add_)(__isl_take PW *pw1, __isl_take PW *pw2)
435 {
436 return FN(PW,align_params_pw_pw_and)(pw1, pw2,
437 &FN(PW,union_add_aligned));
438 }
439
440 /* Make sure "pw" has room for at least "n" more pieces.
441 *
442 * If there is only one reference to pw, we extend it in place.
443 * Otherwise, we create a new PW and copy the pieces.
444 */
445 static __isl_give PW *FN(PW,grow)(__isl_take PW *pw, int n)
446 {
447 int i;
448 isl_ctx *ctx;
449 PW *res;
450
451 if (!pw)
452 return NULL;
453 if (pw->n + n <= pw->size)
454 return pw;
455 ctx = FN(PW,get_ctx)(pw);
456 n += pw->n;
457 if (pw->ref == 1) {
458 res = isl_realloc(ctx, pw, struct PW,
459 sizeof(struct PW) + (n - 1) * sizeof(S(PW,piece)));
460 if (!res)
461 return FN(PW,free)(pw);
462 res->size = n;
463 return res;
464 }
465 #ifdef HAS_TYPE
466 res = FN(PW,alloc_size)(isl_space_copy(pw->dim), pw->type, n);
467 #else
468 res = FN(PW,alloc_size)(isl_space_copy(pw->dim), n);
469 #endif
470 if (!res)
471 return FN(PW,free)(pw);
472 for (i = 0; i < pw->n; ++i)
473 res = FN(PW,add_piece)(res, isl_set_copy(pw->p[i].set),
474 FN(EL,copy)(pw->p[i].FIELD));
475 FN(PW,free)(pw);
476 return res;
477 }
478
479 static __isl_give PW *FN(PW,add_disjoint_aligned)(__isl_take PW *pw1,
480 __isl_take PW *pw2)
481 {
482 int i;
483 isl_ctx *ctx;
484
485 if (!pw1 || !pw2)
486 goto error;
487
488 if (pw1->size < pw1->n + pw2->n && pw1->n < pw2->n)
489 return FN(PW,add_disjoint_aligned)(pw2, pw1);
490
491 ctx = isl_space_get_ctx(pw1->dim);
492 #ifdef HAS_TYPE
493 if (pw1->type != pw2->type)
494 isl_die(ctx, isl_error_invalid,
495 "fold types don't match", goto error);
496 #endif
497 isl_assert(ctx, isl_space_is_equal(pw1->dim, pw2->dim), goto error);
498
499 if (FN(PW,IS_ZERO)(pw1)) {
500 FN(PW,free)(pw1);
501 return pw2;
502 }
503
504 if (FN(PW,IS_ZERO)(pw2)) {
505 FN(PW,free)(pw2);
506 return pw1;
507 }
508
509 pw1 = FN(PW,grow)(pw1, pw2->n);
510 if (!pw1)
511 goto error;
512
513 for (i = 0; i < pw2->n; ++i)
514 pw1 = FN(PW,add_piece)(pw1,
515 isl_set_copy(pw2->p[i].set),
516 FN(EL,copy)(pw2->p[i].FIELD));
517
518 FN(PW,free)(pw2);
519
520 return pw1;
521 error:
522 FN(PW,free)(pw1);
523 FN(PW,free)(pw2);
524 return NULL;
525 }
526
527 __isl_give PW *FN(PW,add_disjoint)(__isl_take PW *pw1, __isl_take PW *pw2)
528 {
529 return FN(PW,align_params_pw_pw_and)(pw1, pw2,
530 &FN(PW,add_disjoint_aligned));
531 }
532
533 /* This function is currently only used from isl_aff.c
534 */
535 static __isl_give PW *FN(PW,on_shared_domain_in)(__isl_take PW *pw1,
536 __isl_take PW *pw2, __isl_take isl_space *space,
537 __isl_give EL *(*fn)(__isl_take EL *el1, __isl_take EL *el2))
538 __attribute__ ((unused));
539
540 /* Apply "fn" to pairs of elements from pw1 and pw2 on shared domains.
541 * The result of "fn" (and therefore also of this function) lives in "space".
542 */
543 static __isl_give PW *FN(PW,on_shared_domain_in)(__isl_take PW *pw1,
544 __isl_take PW *pw2, __isl_take isl_space *space,
545 __isl_give EL *(*fn)(__isl_take EL *el1, __isl_take EL *el2))
546 {
547 int i, j, n;
548 PW *res = NULL;
549
550 if (!pw1 || !pw2)
551 goto error;
552
553 n = pw1->n * pw2->n;
554 #ifdef HAS_TYPE
555 res = FN(PW,alloc_size)(isl_space_copy(space), pw1->type, n);
556 #else
557 res = FN(PW,alloc_size)(isl_space_copy(space), n);
558 #endif
559
560 for (i = 0; i < pw1->n; ++i) {
561 for (j = 0; j < pw2->n; ++j) {
562 isl_set *common;
563 EL *res_ij;
564 int empty;
565
566 common = isl_set_intersect(
567 isl_set_copy(pw1->p[i].set),
568 isl_set_copy(pw2->p[j].set));
569 empty = isl_set_plain_is_empty(common);
570 if (empty < 0 || empty) {
571 isl_set_free(common);
572 if (empty < 0)
573 goto error;
574 continue;
575 }
576
577 res_ij = fn(FN(EL,copy)(pw1->p[i].FIELD),
578 FN(EL,copy)(pw2->p[j].FIELD));
579 res_ij = FN(EL,gist)(res_ij, isl_set_copy(common));
580
581 res = FN(PW,add_piece)(res, common, res_ij);
582 }
583 }
584
585 isl_space_free(space);
586 FN(PW,free)(pw1);
587 FN(PW,free)(pw2);
588 return res;
589 error:
590 isl_space_free(space);
591 FN(PW,free)(pw1);
592 FN(PW,free)(pw2);
593 FN(PW,free)(res);
594 return NULL;
595 }
596
597 /* This function is currently only used from isl_aff.c
598 */
599 static __isl_give PW *FN(PW,on_shared_domain)(__isl_take PW *pw1,
600 __isl_take PW *pw2,
601 __isl_give EL *(*fn)(__isl_take EL *el1, __isl_take EL *el2))
602 __attribute__ ((unused));
603
604 /* Apply "fn" to pairs of elements from pw1 and pw2 on shared domains.
605 * The result of "fn" is assumed to live in the same space as "pw1" and "pw2".
606 */
607 static __isl_give PW *FN(PW,on_shared_domain)(__isl_take PW *pw1,
608 __isl_take PW *pw2,
609 __isl_give EL *(*fn)(__isl_take EL *el1, __isl_take EL *el2))
610 {
611 isl_space *space;
612
613 if (!pw1 || !pw2)
614 goto error;
615
616 space = isl_space_copy(pw1->dim);
617 return FN(PW,on_shared_domain_in)(pw1, pw2, space, fn);
618 error:
619 FN(PW,free)(pw1);
620 FN(PW,free)(pw2);
621 return NULL;
622 }
623
624 #ifndef NO_NEG
625 __isl_give PW *FN(PW,neg)(__isl_take PW *pw)
626 {
627 int i;
628
629 if (!pw)
630 return NULL;
631
632 if (FN(PW,IS_ZERO)(pw))
633 return pw;
634
635 pw = FN(PW,cow)(pw);
636 if (!pw)
637 return NULL;
638
639 for (i = 0; i < pw->n; ++i) {
640 pw->p[i].FIELD = FN(EL,neg)(pw->p[i].FIELD);
641 if (!pw->p[i].FIELD)
642 return FN(PW,free)(pw);
643 }
644
645 return pw;
646 }
647
648 __isl_give PW *FN(PW,sub)(__isl_take PW *pw1, __isl_take PW *pw2)
649 {
650 return FN(PW,add)(pw1, FN(PW,neg)(pw2));
651 }
652 #endif
653
654 #ifndef NO_EVAL
655 __isl_give isl_val *FN(PW,eval)(__isl_take PW *pw, __isl_take isl_point *pnt)
656 {
657 int i;
658 int found = 0;
659 isl_ctx *ctx;
660 isl_space *pnt_dim = NULL;
661 isl_val *v;
662
663 if (!pw || !pnt)
664 goto error;
665 ctx = isl_point_get_ctx(pnt);
666 pnt_dim = isl_point_get_space(pnt);
667 isl_assert(ctx, isl_space_is_domain_internal(pnt_dim, pw->dim),
668 goto error);
669
670 for (i = 0; i < pw->n; ++i) {
671 found = isl_set_contains_point(pw->p[i].set, pnt);
672 if (found < 0)
673 goto error;
674 if (found)
675 break;
676 }
677 if (found)
678 v = FN(EL,eval)(FN(EL,copy)(pw->p[i].FIELD),
679 isl_point_copy(pnt));
680 else
681 v = isl_val_zero(ctx);
682 FN(PW,free)(pw);
683 isl_space_free(pnt_dim);
684 isl_point_free(pnt);
685 return v;
686 error:
687 FN(PW,free)(pw);
688 isl_space_free(pnt_dim);
689 isl_point_free(pnt);
690 return NULL;
691 }
692 #endif
693
694 /* Return the parameter domain of "pw".
695 */
696 __isl_give isl_set *FN(PW,params)(__isl_take PW *pw)
697 {
698 return isl_set_params(FN(PW,domain)(pw));
699 }
700
701 __isl_give isl_set *FN(PW,domain)(__isl_take PW *pw)
702 {
703 int i;
704 isl_set *dom;
705
706 if (!pw)
707 return NULL;
708
709 dom = isl_set_empty(FN(PW,get_domain_space)(pw));
710 for (i = 0; i < pw->n; ++i)
711 dom = isl_set_union_disjoint(dom, isl_set_copy(pw->p[i].set));
712
713 FN(PW,free)(pw);
714
715 return dom;
716 }
717
718 /* Exploit the equalities in the domain of piece "i" of "pw"
719 * to simplify the associated function.
720 * If the domain of piece "i" is empty, then remove it entirely,
721 * replacing it with the final piece.
722 */
723 static int FN(PW,exploit_equalities_and_remove_if_empty)(__isl_keep PW *pw,
724 int i)
725 {
726 isl_basic_set *aff;
727 int empty = isl_set_plain_is_empty(pw->p[i].set);
728
729 if (empty < 0)
730 return -1;
731 if (empty) {
732 isl_set_free(pw->p[i].set);
733 FN(EL,free)(pw->p[i].FIELD);
734 if (i != pw->n - 1)
735 pw->p[i] = pw->p[pw->n - 1];
736 pw->n--;
737
738 return 0;
739 }
740
741 aff = isl_set_affine_hull(isl_set_copy(pw->p[i].set));
742 pw->p[i].FIELD = FN(EL,substitute_equalities)(pw->p[i].FIELD, aff);
743 if (!pw->p[i].FIELD)
744 return -1;
745
746 return 0;
747 }
748
749 /* Convert a piecewise expression defined over a parameter domain
750 * into one that is defined over a zero-dimensional set.
751 */
752 __isl_give PW *FN(PW,from_range)(__isl_take PW *pw)
753 {
754 isl_space *space;
755
756 if (!pw)
757 return NULL;
758 if (!isl_space_is_set(pw->dim))
759 isl_die(FN(PW,get_ctx)(pw), isl_error_invalid,
760 "not living in a set space", return FN(PW,free)(pw));
761
762 space = FN(PW,get_space)(pw);
763 space = isl_space_from_range(space);
764 pw = FN(PW,reset_space)(pw, space);
765
766 return pw;
767 }
768
769 /* Fix the value of the given parameter or domain dimension of "pw"
770 * to be equal to "value".
771 */
772 __isl_give PW *FN(PW,fix_si)(__isl_take PW *pw, enum isl_dim_type type,
773 unsigned pos, int value)
774 {
775 int i;
776
777 if (!pw)
778 return NULL;
779
780 if (type == isl_dim_out)
781 isl_die(FN(PW,get_ctx)(pw), isl_error_invalid,
782 "cannot fix output dimension", return FN(PW,free)(pw));
783
784 if (pw->n == 0)
785 return pw;
786
787 if (type == isl_dim_in)
788 type = isl_dim_set;
789
790 pw = FN(PW,cow)(pw);
791 if (!pw)
792 return FN(PW,free)(pw);
793
794 for (i = pw->n - 1; i >= 0; --i) {
795 pw->p[i].set = isl_set_fix_si(pw->p[i].set, type, pos, value);
796 if (FN(PW,exploit_equalities_and_remove_if_empty)(pw, i) < 0)
797 return FN(PW,free)(pw);
798 }
799
800 return pw;
801 }
802
803 /* Restrict the domain of "pw" by combining each cell
804 * with "set" through a call to "fn", where "fn" may be
805 * isl_set_intersect or isl_set_intersect_params.
806 */
807 static __isl_give PW *FN(PW,intersect_aligned)(__isl_take PW *pw,
808 __isl_take isl_set *set,
809 __isl_give isl_set *(*fn)(__isl_take isl_set *set1,
810 __isl_take isl_set *set2))
811 {
812 int i;
813
814 if (!pw || !set)
815 goto error;
816
817 if (pw->n == 0) {
818 isl_set_free(set);
819 return pw;
820 }
821
822 pw = FN(PW,cow)(pw);
823 if (!pw)
824 goto error;
825
826 for (i = pw->n - 1; i >= 0; --i) {
827 pw->p[i].set = fn(pw->p[i].set, isl_set_copy(set));
828 if (FN(PW,exploit_equalities_and_remove_if_empty)(pw, i) < 0)
829 goto error;
830 }
831
832 isl_set_free(set);
833 return pw;
834 error:
835 isl_set_free(set);
836 FN(PW,free)(pw);
837 return NULL;
838 }
839
840 static __isl_give PW *FN(PW,intersect_domain_aligned)(__isl_take PW *pw,
841 __isl_take isl_set *set)
842 {
843 return FN(PW,intersect_aligned)(pw, set, &isl_set_intersect);
844 }
845
846 __isl_give PW *FN(PW,intersect_domain)(__isl_take PW *pw,
847 __isl_take isl_set *context)
848 {
849 return FN(PW,align_params_pw_set_and)(pw, context,
850 &FN(PW,intersect_domain_aligned));
851 }
852
853 static __isl_give PW *FN(PW,intersect_params_aligned)(__isl_take PW *pw,
854 __isl_take isl_set *set)
855 {
856 return FN(PW,intersect_aligned)(pw, set, &isl_set_intersect_params);
857 }
858
859 /* Intersect the domain of "pw" with the parameter domain "context".
860 */
861 __isl_give PW *FN(PW,intersect_params)(__isl_take PW *pw,
862 __isl_take isl_set *context)
863 {
864 return FN(PW,align_params_pw_set_and)(pw, context,
865 &FN(PW,intersect_params_aligned));
866 }
867
868 /* Compute the gist of "pw" with respect to the domain constraints
869 * of "context" for the case where the domain of the last element
870 * of "pw" is equal to "context".
871 * Call "fn_el" to compute the gist of this element, replace
872 * its domain by the universe and drop all other elements
873 * as their domains are necessarily disjoint from "context".
874 */
875 static __isl_give PW *FN(PW,gist_last)(__isl_take PW *pw,
876 __isl_take isl_set *context,
877 __isl_give EL *(*fn_el)(__isl_take EL *el, __isl_take isl_set *set))
878 {
879 int i;
880 isl_space *space;
881
882 for (i = 0; i < pw->n - 1; ++i) {
883 isl_set_free(pw->p[i].set);
884 FN(EL,free)(pw->p[i].FIELD);
885 }
886 pw->p[0].FIELD = pw->p[pw->n - 1].FIELD;
887 pw->p[0].set = pw->p[pw->n - 1].set;
888 pw->n = 1;
889
890 space = isl_set_get_space(context);
891 pw->p[0].FIELD = fn_el(pw->p[0].FIELD, context);
892 context = isl_set_universe(space);
893 isl_set_free(pw->p[0].set);
894 pw->p[0].set = context;
895
896 if (!pw->p[0].FIELD || !pw->p[0].set)
897 return FN(PW,free)(pw);
898
899 return pw;
900 }
901
902 /* Compute the gist of "pw" with respect to the domain constraints
903 * of "context". Call "fn_el" to compute the gist of the elements
904 * and "fn_dom" to compute the gist of the domains.
905 *
906 * If the piecewise expression is empty or the context is the universe,
907 * then nothing can be simplified.
908 */
909 static __isl_give PW *FN(PW,gist_aligned)(__isl_take PW *pw,
910 __isl_take isl_set *context,
911 __isl_give EL *(*fn_el)(__isl_take EL *el,
912 __isl_take isl_set *set),
913 __isl_give isl_set *(*fn_dom)(__isl_take isl_set *set,
914 __isl_take isl_basic_set *bset))
915 {
916 int i;
917 int is_universe;
918 isl_basic_set *hull = NULL;
919
920 if (!pw || !context)
921 goto error;
922
923 if (pw->n == 0) {
924 isl_set_free(context);
925 return pw;
926 }
927
928 is_universe = isl_set_plain_is_universe(context);
929 if (is_universe < 0)
930 goto error;
931 if (is_universe) {
932 isl_set_free(context);
933 return pw;
934 }
935
936 if (!isl_space_match(pw->dim, isl_dim_param,
937 context->dim, isl_dim_param)) {
938 pw = FN(PW,align_params)(pw, isl_set_get_space(context));
939 context = isl_set_align_params(context, FN(PW,get_space)(pw));
940 }
941
942 pw = FN(PW,cow)(pw);
943 if (!pw)
944 goto error;
945
946 if (pw->n == 1) {
947 int equal;
948
949 equal = isl_set_plain_is_equal(pw->p[0].set, context);
950 if (equal < 0)
951 goto error;
952 if (equal)
953 return FN(PW,gist_last)(pw, context, fn_el);
954 }
955
956 context = isl_set_compute_divs(context);
957 hull = isl_set_simple_hull(isl_set_copy(context));
958
959 for (i = pw->n - 1; i >= 0; --i) {
960 isl_set *set_i;
961 int empty;
962
963 if (i == pw->n - 1) {
964 int equal;
965 equal = isl_set_plain_is_equal(pw->p[i].set, context);
966 if (equal < 0)
967 goto error;
968 if (equal) {
969 isl_basic_set_free(hull);
970 return FN(PW,gist_last)(pw, context, fn_el);
971 }
972 }
973 set_i = isl_set_intersect(isl_set_copy(pw->p[i].set),
974 isl_set_copy(context));
975 empty = isl_set_plain_is_empty(set_i);
976 pw->p[i].FIELD = fn_el(pw->p[i].FIELD, set_i);
977 pw->p[i].set = fn_dom(pw->p[i].set, isl_basic_set_copy(hull));
978 if (empty < 0 || !pw->p[i].FIELD || !pw->p[i].set)
979 goto error;
980 if (empty) {
981 isl_set_free(pw->p[i].set);
982 FN(EL,free)(pw->p[i].FIELD);
983 if (i != pw->n - 1)
984 pw->p[i] = pw->p[pw->n - 1];
985 pw->n--;
986 }
987 }
988
989 isl_basic_set_free(hull);
990 isl_set_free(context);
991
992 return pw;
993 error:
994 FN(PW,free)(pw);
995 isl_basic_set_free(hull);
996 isl_set_free(context);
997 return NULL;
998 }
999
1000 static __isl_give PW *FN(PW,gist_domain_aligned)(__isl_take PW *pw,
1001 __isl_take isl_set *set)
1002 {
1003 return FN(PW,gist_aligned)(pw, set, &FN(EL,gist),
1004 &isl_set_gist_basic_set);
1005 }
1006
1007 __isl_give PW *FN(PW,gist)(__isl_take PW *pw, __isl_take isl_set *context)
1008 {
1009 return FN(PW,align_params_pw_set_and)(pw, context,
1010 &FN(PW,gist_domain_aligned));
1011 }
1012
1013 static __isl_give PW *FN(PW,gist_params_aligned)(__isl_take PW *pw,
1014 __isl_take isl_set *set)
1015 {
1016 return FN(PW,gist_aligned)(pw, set, &FN(EL,gist_params),
1017 &isl_set_gist_params_basic_set);
1018 }
1019
1020 __isl_give PW *FN(PW,gist_params)(__isl_take PW *pw,
1021 __isl_take isl_set *context)
1022 {
1023 return FN(PW,align_params_pw_set_and)(pw, context,
1024 &FN(PW,gist_params_aligned));
1025 }
1026
1027 __isl_give PW *FN(PW,coalesce)(__isl_take PW *pw)
1028 {
1029 int i, j;
1030
1031 if (!pw)
1032 return NULL;
1033 if (pw->n == 0)
1034 return pw;
1035
1036 for (i = pw->n - 1; i >= 0; --i) {
1037 for (j = i - 1; j >= 0; --j) {
1038 if (!FN(EL,plain_is_equal)(pw->p[i].FIELD,
1039 pw->p[j].FIELD))
1040 continue;
1041 pw->p[j].set = isl_set_union(pw->p[j].set,
1042 pw->p[i].set);
1043 FN(EL,free)(pw->p[i].FIELD);
1044 if (i != pw->n - 1)
1045 pw->p[i] = pw->p[pw->n - 1];
1046 pw->n--;
1047 break;
1048 }
1049 if (j >= 0)
1050 continue;
1051 pw->p[i].set = isl_set_coalesce(pw->p[i].set);
1052 if (!pw->p[i].set)
1053 goto error;
1054 }
1055
1056 return pw;
1057 error:
1058 FN(PW,free)(pw);
1059 return NULL;
1060 }
1061
1062 isl_ctx *FN(PW,get_ctx)(__isl_keep PW *pw)
1063 {
1064 return pw ? isl_space_get_ctx(pw->dim) : NULL;
1065 }
1066
1067 #ifndef NO_INVOLVES_DIMS
1068 int FN(PW,involves_dims)(__isl_keep PW *pw, enum isl_dim_type type,
1069 unsigned first, unsigned n)
1070 {
1071 int i;
1072 enum isl_dim_type set_type;
1073
1074 if (!pw)
1075 return -1;
1076 if (pw->n == 0 || n == 0)
1077 return 0;
1078
1079 set_type = type == isl_dim_in ? isl_dim_set : type;
1080
1081 for (i = 0; i < pw->n; ++i) {
1082 int involves = FN(EL,involves_dims)(pw->p[i].FIELD,
1083 type, first, n);
1084 if (involves < 0 || involves)
1085 return involves;
1086 involves = isl_set_involves_dims(pw->p[i].set,
1087 set_type, first, n);
1088 if (involves < 0 || involves)
1089 return involves;
1090 }
1091 return 0;
1092 }
1093 #endif
1094
1095 __isl_give PW *FN(PW,set_dim_name)(__isl_take PW *pw,
1096 enum isl_dim_type type, unsigned pos, const char *s)
1097 {
1098 int i;
1099 enum isl_dim_type set_type;
1100
1101 pw = FN(PW,cow)(pw);
1102 if (!pw)
1103 return NULL;
1104
1105 set_type = type == isl_dim_in ? isl_dim_set : type;
1106
1107 pw->dim = isl_space_set_dim_name(pw->dim, type, pos, s);
1108 if (!pw->dim)
1109 goto error;
1110
1111 for (i = 0; i < pw->n; ++i) {
1112 pw->p[i].set = isl_set_set_dim_name(pw->p[i].set,
1113 set_type, pos, s);
1114 if (!pw->p[i].set)
1115 goto error;
1116 pw->p[i].FIELD = FN(EL,set_dim_name)(pw->p[i].FIELD, type, pos, s);
1117 if (!pw->p[i].FIELD)
1118 goto error;
1119 }
1120
1121 return pw;
1122 error:
1123 FN(PW,free)(pw);
1124 return NULL;
1125 }
1126
1127 #ifndef NO_DROP_DIMS
1128 __isl_give PW *FN(PW,drop_dims)(__isl_take PW *pw,
1129 enum isl_dim_type type, unsigned first, unsigned n)
1130 {
1131 int i;
1132 enum isl_dim_type set_type;
1133
1134 if (!pw)
1135 return NULL;
1136 if (n == 0 && !isl_space_get_tuple_name(pw->dim, type))
1137 return pw;
1138
1139 set_type = type == isl_dim_in ? isl_dim_set : type;
1140
1141 pw = FN(PW,cow)(pw);
1142 if (!pw)
1143 return NULL;
1144 pw->dim = isl_space_drop_dims(pw->dim, type, first, n);
1145 if (!pw->dim)
1146 goto error;
1147 for (i = 0; i < pw->n; ++i) {
1148 pw->p[i].FIELD = FN(EL,drop_dims)(pw->p[i].FIELD, type, first, n);
1149 if (!pw->p[i].FIELD)
1150 goto error;
1151 if (type == isl_dim_out)
1152 continue;
1153 pw->p[i].set = isl_set_drop(pw->p[i].set, set_type, first, n);
1154 if (!pw->p[i].set)
1155 goto error;
1156 }
1157
1158 return pw;
1159 error:
1160 FN(PW,free)(pw);
1161 return NULL;
1162 }
1163
1164 /* This function is very similar to drop_dims.
1165 * The only difference is that the cells may still involve
1166 * the specified dimensions. They are removed using
1167 * isl_set_project_out instead of isl_set_drop.
1168 */
1169 __isl_give PW *FN(PW,project_out)(__isl_take PW *pw,
1170 enum isl_dim_type type, unsigned first, unsigned n)
1171 {
1172 int i;
1173 enum isl_dim_type set_type;
1174
1175 if (!pw)
1176 return NULL;
1177 if (n == 0 && !isl_space_get_tuple_name(pw->dim, type))
1178 return pw;
1179
1180 set_type = type == isl_dim_in ? isl_dim_set : type;
1181
1182 pw = FN(PW,cow)(pw);
1183 if (!pw)
1184 return NULL;
1185 pw->dim = isl_space_drop_dims(pw->dim, type, first, n);
1186 if (!pw->dim)
1187 goto error;
1188 for (i = 0; i < pw->n; ++i) {
1189 pw->p[i].set = isl_set_project_out(pw->p[i].set,
1190 set_type, first, n);
1191 if (!pw->p[i].set)
1192 goto error;
1193 pw->p[i].FIELD = FN(EL,drop_dims)(pw->p[i].FIELD, type, first, n);
1194 if (!pw->p[i].FIELD)
1195 goto error;
1196 }
1197
1198 return pw;
1199 error:
1200 FN(PW,free)(pw);
1201 return NULL;
1202 }
1203
1204 /* Project the domain of pw onto its parameter space.
1205 */
1206 __isl_give PW *FN(PW,project_domain_on_params)(__isl_take PW *pw)
1207 {
1208 isl_space *space;
1209 unsigned n;
1210
1211 n = FN(PW,dim)(pw, isl_dim_in);
1212 pw = FN(PW,project_out)(pw, isl_dim_in, 0, n);
1213 space = FN(PW,get_domain_space)(pw);
1214 space = isl_space_params(space);
1215 pw = FN(PW,reset_domain_space)(pw, space);
1216 return pw;
1217 }
1218 #endif
1219
1220 #ifndef NO_INSERT_DIMS
1221 __isl_give PW *FN(PW,insert_dims)(__isl_take PW *pw, enum isl_dim_type type,
1222 unsigned first, unsigned n)
1223 {
1224 int i;
1225 enum isl_dim_type set_type;
1226
1227 if (!pw)
1228 return NULL;
1229 if (n == 0 && !isl_space_is_named_or_nested(pw->dim, type))
1230 return pw;
1231
1232 set_type = type == isl_dim_in ? isl_dim_set : type;
1233
1234 pw = FN(PW,cow)(pw);
1235 if (!pw)
1236 return NULL;
1237
1238 pw->dim = isl_space_insert_dims(pw->dim, type, first, n);
1239 if (!pw->dim)
1240 goto error;
1241
1242 for (i = 0; i < pw->n; ++i) {
1243 pw->p[i].set = isl_set_insert_dims(pw->p[i].set,
1244 set_type, first, n);
1245 if (!pw->p[i].set)
1246 goto error;
1247 pw->p[i].FIELD = FN(EL,insert_dims)(pw->p[i].FIELD,
1248 type, first, n);
1249 if (!pw->p[i].FIELD)
1250 goto error;
1251 }
1252
1253 return pw;
1254 error:
1255 FN(PW,free)(pw);
1256 return NULL;
1257 }
1258 #endif
1259
1260 __isl_give PW *FN(PW,fix_dim)(__isl_take PW *pw,
1261 enum isl_dim_type type, unsigned pos, isl_int v)
1262 {
1263 int i;
1264
1265 if (!pw)
1266 return NULL;
1267
1268 if (type == isl_dim_in)
1269 type = isl_dim_set;
1270
1271 pw = FN(PW,cow)(pw);
1272 if (!pw)
1273 return NULL;
1274 for (i = 0; i < pw->n; ++i) {
1275 pw->p[i].set = isl_set_fix(pw->p[i].set, type, pos, v);
1276 if (FN(PW,exploit_equalities_and_remove_if_empty)(pw, i) < 0)
1277 return FN(PW,free)(pw);
1278 }
1279
1280 return pw;
1281 }
1282
1283 /* Fix the value of the variable at position "pos" of type "type" of "pw"
1284 * to be equal to "v".
1285 */
1286 __isl_give PW *FN(PW,fix_val)(__isl_take PW *pw,
1287 enum isl_dim_type type, unsigned pos, __isl_take isl_val *v)
1288 {
1289 if (!v)
1290 return FN(PW,free)(pw);
1291 if (!isl_val_is_int(v))
1292 isl_die(FN(PW,get_ctx)(pw), isl_error_invalid,
1293 "expecting integer value", goto error);
1294
1295 pw = FN(PW,fix_dim)(pw, type, pos, v->n);
1296 isl_val_free(v);
1297
1298 return pw;
1299 error:
1300 isl_val_free(v);
1301 return FN(PW,free)(pw);
1302 }
1303
1304 unsigned FN(PW,dim)(__isl_keep PW *pw, enum isl_dim_type type)
1305 {
1306 return pw ? isl_space_dim(pw->dim, type) : 0;
1307 }
1308
1309 __isl_give PW *FN(PW,split_dims)(__isl_take PW *pw,
1310 enum isl_dim_type type, unsigned first, unsigned n)
1311 {
1312 int i;
1313
1314 if (!pw)
1315 return NULL;
1316 if (n == 0)
1317 return pw;
1318
1319 if (type == isl_dim_in)
1320 type = isl_dim_set;
1321
1322 pw = FN(PW,cow)(pw);
1323 if (!pw)
1324 return NULL;
1325 if (!pw->dim)
1326 goto error;
1327 for (i = 0; i < pw->n; ++i) {
1328 pw->p[i].set = isl_set_split_dims(pw->p[i].set, type, first, n);
1329 if (!pw->p[i].set)
1330 goto error;
1331 }
1332
1333 return pw;
1334 error:
1335 FN(PW,free)(pw);
1336 return NULL;
1337 }
1338
1339 #ifndef NO_OPT
1340 /* Compute the maximal value attained by the piecewise quasipolynomial
1341 * on its domain or zero if the domain is empty.
1342 * In the worst case, the domain is scanned completely,
1343 * so the domain is assumed to be bounded.
1344 */
1345 __isl_give isl_val *FN(PW,opt)(__isl_take PW *pw, int max)
1346 {
1347 int i;
1348 isl_val *opt;
1349
1350 if (!pw)
1351 return NULL;
1352
1353 if (pw->n == 0) {
1354 opt = isl_val_zero(FN(PW,get_ctx)(pw));
1355 FN(PW,free)(pw);
1356 return opt;
1357 }
1358
1359 opt = FN(EL,opt_on_domain)(FN(EL,copy)(pw->p[0].FIELD),
1360 isl_set_copy(pw->p[0].set), max);
1361 for (i = 1; i < pw->n; ++i) {
1362 isl_val *opt_i;
1363 opt_i = FN(EL,opt_on_domain)(FN(EL,copy)(pw->p[i].FIELD),
1364 isl_set_copy(pw->p[i].set), max);
1365 if (max)
1366 opt = isl_val_max(opt, opt_i);
1367 else
1368 opt = isl_val_min(opt, opt_i);
1369 }
1370
1371 FN(PW,free)(pw);
1372 return opt;
1373 }
1374
1375 __isl_give isl_val *FN(PW,max)(__isl_take PW *pw)
1376 {
1377 return FN(PW,opt)(pw, 1);
1378 }
1379
1380 __isl_give isl_val *FN(PW,min)(__isl_take PW *pw)
1381 {
1382 return FN(PW,opt)(pw, 0);
1383 }
1384 #endif
1385
1386 __isl_give isl_space *FN(PW,get_space)(__isl_keep PW *pw)
1387 {
1388 return pw ? isl_space_copy(pw->dim) : NULL;
1389 }
1390
1391 __isl_give isl_space *FN(PW,get_domain_space)(__isl_keep PW *pw)
1392 {
1393 return pw ? isl_space_domain(isl_space_copy(pw->dim)) : NULL;
1394 }
1395
1396 /* Return the position of the dimension of the given type and name
1397 * in "pw".
1398 * Return -1 if no such dimension can be found.
1399 */
1400 int FN(PW,find_dim_by_name)(__isl_keep PW *pw,
1401 enum isl_dim_type type, const char *name)
1402 {
1403 if (!pw)
1404 return -1;
1405 return isl_space_find_dim_by_name(pw->dim, type, name);
1406 }
1407
1408 #ifndef NO_RESET_DIM
1409 /* Reset the space of "pw". Since we don't know if the elements
1410 * represent the spaces themselves or their domains, we pass along
1411 * both when we call their reset_space_and_domain.
1412 */
1413 static __isl_give PW *FN(PW,reset_space_and_domain)(__isl_take PW *pw,
1414 __isl_take isl_space *space, __isl_take isl_space *domain)
1415 {
1416 int i;
1417
1418 pw = FN(PW,cow)(pw);
1419 if (!pw || !space || !domain)
1420 goto error;
1421
1422 for (i = 0; i < pw->n; ++i) {
1423 pw->p[i].set = isl_set_reset_space(pw->p[i].set,
1424 isl_space_copy(domain));
1425 if (!pw->p[i].set)
1426 goto error;
1427 pw->p[i].FIELD = FN(EL,reset_space_and_domain)(pw->p[i].FIELD,
1428 isl_space_copy(space), isl_space_copy(domain));
1429 if (!pw->p[i].FIELD)
1430 goto error;
1431 }
1432
1433 isl_space_free(domain);
1434
1435 isl_space_free(pw->dim);
1436 pw->dim = space;
1437
1438 return pw;
1439 error:
1440 isl_space_free(domain);
1441 isl_space_free(space);
1442 FN(PW,free)(pw);
1443 return NULL;
1444 }
1445
1446 __isl_give PW *FN(PW,reset_domain_space)(__isl_take PW *pw,
1447 __isl_take isl_space *domain)
1448 {
1449 isl_space *space;
1450
1451 space = isl_space_extend_domain_with_range(isl_space_copy(domain),
1452 FN(PW,get_space)(pw));
1453 return FN(PW,reset_space_and_domain)(pw, space, domain);
1454 }
1455
1456 __isl_give PW *FN(PW,reset_space)(__isl_take PW *pw, __isl_take isl_space *dim)
1457 {
1458 isl_space *domain;
1459
1460 domain = isl_space_domain(isl_space_copy(dim));
1461 return FN(PW,reset_space_and_domain)(pw, dim, domain);
1462 }
1463
1464 __isl_give PW *FN(PW,set_tuple_id)(__isl_take PW *pw, enum isl_dim_type type,
1465 __isl_take isl_id *id)
1466 {
1467 isl_space *space;
1468
1469 pw = FN(PW,cow)(pw);
1470 if (!pw)
1471 goto error;
1472
1473 space = FN(PW,get_space)(pw);
1474 space = isl_space_set_tuple_id(space, type, id);
1475
1476 return FN(PW,reset_space)(pw, space);
1477 error:
1478 isl_id_free(id);
1479 return FN(PW,free)(pw);
1480 }
1481
1482 /* Drop the id on the specified tuple.
1483 */
1484 __isl_give PW *FN(PW,reset_tuple_id)(__isl_take PW *pw, enum isl_dim_type type)
1485 {
1486 isl_space *space;
1487
1488 if (!pw)
1489 return NULL;
1490 if (!FN(PW,has_tuple_id)(pw, type))
1491 return pw;
1492
1493 pw = FN(PW,cow)(pw);
1494 if (!pw)
1495 return NULL;
1496
1497 space = FN(PW,get_space)(pw);
1498 space = isl_space_reset_tuple_id(space, type);
1499
1500 return FN(PW,reset_space)(pw, space);
1501 }
1502
1503 __isl_give PW *FN(PW,set_dim_id)(__isl_take PW *pw,
1504 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
1505 {
1506 pw = FN(PW,cow)(pw);
1507 if (!pw)
1508 goto error;
1509 pw->dim = isl_space_set_dim_id(pw->dim, type, pos, id);
1510 return FN(PW,reset_space)(pw, isl_space_copy(pw->dim));
1511 error:
1512 isl_id_free(id);
1513 return FN(PW,free)(pw);
1514 }
1515 #endif
1516
1517 int FN(PW,has_equal_space)(__isl_keep PW *pw1, __isl_keep PW *pw2)
1518 {
1519 if (!pw1 || !pw2)
1520 return -1;
1521
1522 return isl_space_is_equal(pw1->dim, pw2->dim);
1523 }
1524
1525 #ifndef NO_MORPH
1526 __isl_give PW *FN(PW,morph_domain)(__isl_take PW *pw,
1527 __isl_take isl_morph *morph)
1528 {
1529 int i;
1530 isl_ctx *ctx;
1531
1532 if (!pw || !morph)
1533 goto error;
1534
1535 ctx = isl_space_get_ctx(pw->dim);
1536 isl_assert(ctx, isl_space_is_domain_internal(morph->dom->dim, pw->dim),
1537 goto error);
1538
1539 pw = FN(PW,cow)(pw);
1540 if (!pw)
1541 goto error;
1542 pw->dim = isl_space_extend_domain_with_range(
1543 isl_space_copy(morph->ran->dim), pw->dim);
1544 if (!pw->dim)
1545 goto error;
1546
1547 for (i = 0; i < pw->n; ++i) {
1548 pw->p[i].set = isl_morph_set(isl_morph_copy(morph), pw->p[i].set);
1549 if (!pw->p[i].set)
1550 goto error;
1551 pw->p[i].FIELD = FN(EL,morph_domain)(pw->p[i].FIELD,
1552 isl_morph_copy(morph));
1553 if (!pw->p[i].FIELD)
1554 goto error;
1555 }
1556
1557 isl_morph_free(morph);
1558
1559 return pw;
1560 error:
1561 FN(PW,free)(pw);
1562 isl_morph_free(morph);
1563 return NULL;
1564 }
1565 #endif
1566
1567 int FN(PW,n_piece)(__isl_keep PW *pw)
1568 {
1569 return pw ? pw->n : 0;
1570 }
1571
1572 int FN(PW,foreach_piece)(__isl_keep PW *pw,
1573 int (*fn)(__isl_take isl_set *set, __isl_take EL *el, void *user),
1574 void *user)
1575 {
1576 int i;
1577
1578 if (!pw)
1579 return -1;
1580
1581 for (i = 0; i < pw->n; ++i)
1582 if (fn(isl_set_copy(pw->p[i].set),
1583 FN(EL,copy)(pw->p[i].FIELD), user) < 0)
1584 return -1;
1585
1586 return 0;
1587 }
1588
1589 #ifndef NO_LIFT
1590 static int any_divs(__isl_keep isl_set *set)
1591 {
1592 int i;
1593
1594 if (!set)
1595 return -1;
1596
1597 for (i = 0; i < set->n; ++i)
1598 if (set->p[i]->n_div > 0)
1599 return 1;
1600
1601 return 0;
1602 }
1603
1604 static int foreach_lifted_subset(__isl_take isl_set *set, __isl_take EL *el,
1605 int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
1606 void *user), void *user)
1607 {
1608 int i;
1609
1610 if (!set || !el)
1611 goto error;
1612
1613 for (i = 0; i < set->n; ++i) {
1614 isl_set *lift;
1615 EL *copy;
1616
1617 lift = isl_set_from_basic_set(isl_basic_set_copy(set->p[i]));
1618 lift = isl_set_lift(lift);
1619
1620 copy = FN(EL,copy)(el);
1621 copy = FN(EL,lift)(copy, isl_set_get_space(lift));
1622
1623 if (fn(lift, copy, user) < 0)
1624 goto error;
1625 }
1626
1627 isl_set_free(set);
1628 FN(EL,free)(el);
1629
1630 return 0;
1631 error:
1632 isl_set_free(set);
1633 FN(EL,free)(el);
1634 return -1;
1635 }
1636
1637 int FN(PW,foreach_lifted_piece)(__isl_keep PW *pw,
1638 int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
1639 void *user), void *user)
1640 {
1641 int i;
1642
1643 if (!pw)
1644 return -1;
1645
1646 for (i = 0; i < pw->n; ++i) {
1647 isl_set *set;
1648 EL *el;
1649
1650 set = isl_set_copy(pw->p[i].set);
1651 el = FN(EL,copy)(pw->p[i].FIELD);
1652 if (!any_divs(set)) {
1653 if (fn(set, el, user) < 0)
1654 return -1;
1655 continue;
1656 }
1657 if (foreach_lifted_subset(set, el, fn, user) < 0)
1658 return -1;
1659 }
1660
1661 return 0;
1662 }
1663 #endif
1664
1665 #ifndef NO_MOVE_DIMS
1666 __isl_give PW *FN(PW,move_dims)(__isl_take PW *pw,
1667 enum isl_dim_type dst_type, unsigned dst_pos,
1668 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
1669 {
1670 int i;
1671
1672 pw = FN(PW,cow)(pw);
1673 if (!pw)
1674 return NULL;
1675
1676 pw->dim = isl_space_move_dims(pw->dim, dst_type, dst_pos, src_type, src_pos, n);
1677 if (!pw->dim)
1678 goto error;
1679
1680 for (i = 0; i < pw->n; ++i) {
1681 pw->p[i].FIELD = FN(EL,move_dims)(pw->p[i].FIELD,
1682 dst_type, dst_pos, src_type, src_pos, n);
1683 if (!pw->p[i].FIELD)
1684 goto error;
1685 }
1686
1687 if (dst_type == isl_dim_in)
1688 dst_type = isl_dim_set;
1689 if (src_type == isl_dim_in)
1690 src_type = isl_dim_set;
1691
1692 for (i = 0; i < pw->n; ++i) {
1693 pw->p[i].set = isl_set_move_dims(pw->p[i].set,
1694 dst_type, dst_pos,
1695 src_type, src_pos, n);
1696 if (!pw->p[i].set)
1697 goto error;
1698 }
1699
1700 return pw;
1701 error:
1702 FN(PW,free)(pw);
1703 return NULL;
1704 }
1705 #endif
1706
1707 __isl_give PW *FN(PW,mul_isl_int)(__isl_take PW *pw, isl_int v)
1708 {
1709 int i;
1710
1711 if (isl_int_is_one(v))
1712 return pw;
1713 if (pw && DEFAULT_IS_ZERO && isl_int_is_zero(v)) {
1714 PW *zero;
1715 isl_space *dim = FN(PW,get_space)(pw);
1716 #ifdef HAS_TYPE
1717 zero = FN(PW,ZERO)(dim, pw->type);
1718 #else
1719 zero = FN(PW,ZERO)(dim);
1720 #endif
1721 FN(PW,free)(pw);
1722 return zero;
1723 }
1724 pw = FN(PW,cow)(pw);
1725 if (!pw)
1726 return NULL;
1727 if (pw->n == 0)
1728 return pw;
1729
1730 #ifdef HAS_TYPE
1731 if (isl_int_is_neg(v))
1732 pw->type = isl_fold_type_negate(pw->type);
1733 #endif
1734 for (i = 0; i < pw->n; ++i) {
1735 pw->p[i].FIELD = FN(EL,scale)(pw->p[i].FIELD, v);
1736 if (!pw->p[i].FIELD)
1737 goto error;
1738 }
1739
1740 return pw;
1741 error:
1742 FN(PW,free)(pw);
1743 return NULL;
1744 }
1745
1746 /* Multiply the pieces of "pw" by "v" and return the result.
1747 */
1748 __isl_give PW *FN(PW,scale_val)(__isl_take PW *pw, __isl_take isl_val *v)
1749 {
1750 int i;
1751
1752 if (!pw || !v)
1753 goto error;
1754
1755 if (isl_val_is_one(v)) {
1756 isl_val_free(v);
1757 return pw;
1758 }
1759 if (pw && DEFAULT_IS_ZERO && isl_val_is_zero(v)) {
1760 PW *zero;
1761 isl_space *space = FN(PW,get_space)(pw);
1762 #ifdef HAS_TYPE
1763 zero = FN(PW,ZERO)(space, pw->type);
1764 #else
1765 zero = FN(PW,ZERO)(space);
1766 #endif
1767 FN(PW,free)(pw);
1768 isl_val_free(v);
1769 return zero;
1770 }
1771 if (pw->n == 0) {
1772 isl_val_free(v);
1773 return pw;
1774 }
1775 pw = FN(PW,cow)(pw);
1776 if (!pw)
1777 goto error;
1778
1779 #ifdef HAS_TYPE
1780 if (isl_val_is_neg(v))
1781 pw->type = isl_fold_type_negate(pw->type);
1782 #endif
1783 for (i = 0; i < pw->n; ++i) {
1784 pw->p[i].FIELD = FN(EL,scale_val)(pw->p[i].FIELD,
1785 isl_val_copy(v));
1786 if (!pw->p[i].FIELD)
1787 goto error;
1788 }
1789
1790 isl_val_free(v);
1791 return pw;
1792 error:
1793 isl_val_free(v);
1794 FN(PW,free)(pw);
1795 return NULL;
1796 }
1797
1798 /* Divide the pieces of "pw" by "v" and return the result.
1799 */
1800 __isl_give PW *FN(PW,scale_down_val)(__isl_take PW *pw, __isl_take isl_val *v)
1801 {
1802 int i;
1803
1804 if (!pw || !v)
1805 goto error;
1806
1807 if (isl_val_is_one(v)) {
1808 isl_val_free(v);
1809 return pw;
1810 }
1811
1812 if (!isl_val_is_rat(v))
1813 isl_die(isl_val_get_ctx(v), isl_error_invalid,
1814 "expecting rational factor", goto error);
1815 if (isl_val_is_zero(v))
1816 isl_die(isl_val_get_ctx(v), isl_error_invalid,
1817 "cannot scale down by zero", goto error);
1818
1819 if (pw->n == 0) {
1820 isl_val_free(v);
1821 return pw;
1822 }
1823 pw = FN(PW,cow)(pw);
1824 if (!pw)
1825 goto error;
1826
1827 #ifdef HAS_TYPE
1828 if (isl_val_is_neg(v))
1829 pw->type = isl_fold_type_negate(pw->type);
1830 #endif
1831 for (i = 0; i < pw->n; ++i) {
1832 pw->p[i].FIELD = FN(EL,scale_down_val)(pw->p[i].FIELD,
1833 isl_val_copy(v));
1834 if (!pw->p[i].FIELD)
1835 goto error;
1836 }
1837
1838 isl_val_free(v);
1839 return pw;
1840 error:
1841 isl_val_free(v);
1842 FN(PW,free)(pw);
1843 return NULL;
1844 }
1845
1846 __isl_give PW *FN(PW,scale)(__isl_take PW *pw, isl_int v)
1847 {
1848 return FN(PW,mul_isl_int)(pw, v);
1849 }
1850
1851 static int FN(PW,qsort_set_cmp)(const void *p1, const void *p2)
1852 {
1853 isl_set *set1 = *(isl_set * const *)p1;
1854 isl_set *set2 = *(isl_set * const *)p2;
1855
1856 return isl_set_plain_cmp(set1, set2);
1857 }
1858
1859 /* We normalize in place, but if anything goes wrong we need
1860 * to return NULL, so we need to make sure we don't change the
1861 * meaning of any possible other copies of map.
1862 */
1863 __isl_give PW *FN(PW,normalize)(__isl_take PW *pw)
1864 {
1865 int i, j;
1866 isl_set *set;
1867
1868 if (!pw)
1869 return NULL;
1870 for (i = 0; i < pw->n; ++i) {
1871 set = isl_set_normalize(isl_set_copy(pw->p[i].set));
1872 if (!set)
1873 return FN(PW,free)(pw);
1874 isl_set_free(pw->p[i].set);
1875 pw->p[i].set = set;
1876 }
1877 qsort(pw->p, pw->n, sizeof(pw->p[0]), &FN(PW,qsort_set_cmp));
1878 for (i = pw->n - 1; i >= 1; --i) {
1879 if (!isl_set_plain_is_equal(pw->p[i - 1].set, pw->p[i].set))
1880 continue;
1881 if (!FN(EL,plain_is_equal)(pw->p[i - 1].FIELD, pw->p[i].FIELD))
1882 continue;
1883 set = isl_set_union(isl_set_copy(pw->p[i - 1].set),
1884 isl_set_copy(pw->p[i].set));
1885 if (!set)
1886 return FN(PW,free)(pw);
1887 isl_set_free(pw->p[i].set);
1888 FN(EL,free)(pw->p[i].FIELD);
1889 isl_set_free(pw->p[i - 1].set);
1890 pw->p[i - 1].set = set;
1891 for (j = i + 1; j < pw->n; ++j)
1892 pw->p[j - 1] = pw->p[j];
1893 pw->n--;
1894 }
1895
1896 return pw;
1897 }
1898
1899 /* Is pw1 obviously equal to pw2?
1900 * That is, do they have obviously identical cells and obviously identical
1901 * elements on each cell?
1902 */
1903 int FN(PW,plain_is_equal)(__isl_keep PW *pw1, __isl_keep PW *pw2)
1904 {
1905 int i;
1906 int equal;
1907
1908 if (!pw1 || !pw2)
1909 return -1;
1910
1911 if (pw1 == pw2)
1912 return 1;
1913 if (!isl_space_is_equal(pw1->dim, pw2->dim))
1914 return 0;
1915
1916 pw1 = FN(PW,copy)(pw1);
1917 pw2 = FN(PW,copy)(pw2);
1918 pw1 = FN(PW,normalize)(pw1);
1919 pw2 = FN(PW,normalize)(pw2);
1920 if (!pw1 || !pw2)
1921 goto error;
1922
1923 equal = pw1->n == pw2->n;
1924 for (i = 0; equal && i < pw1->n; ++i) {
1925 equal = isl_set_plain_is_equal(pw1->p[i].set, pw2->p[i].set);
1926 if (equal < 0)
1927 goto error;
1928 if (!equal)
1929 break;
1930 equal = FN(EL,plain_is_equal)(pw1->p[i].FIELD, pw2->p[i].FIELD);
1931 if (equal < 0)
1932 goto error;
1933 }
1934
1935 FN(PW,free)(pw1);
1936 FN(PW,free)(pw2);
1937 return equal;
1938 error:
1939 FN(PW,free)(pw1);
1940 FN(PW,free)(pw2);
1941 return -1;
1942 }
1943
1944 #ifndef NO_PULLBACK
1945 static __isl_give PW *FN(PW,align_params_pw_multi_aff_and)(__isl_take PW *pw,
1946 __isl_take isl_multi_aff *ma,
1947 __isl_give PW *(*fn)(__isl_take PW *pw, __isl_take isl_multi_aff *ma))
1948 {
1949 isl_ctx *ctx;
1950 isl_space *ma_space;
1951
1952 ma_space = isl_multi_aff_get_space(ma);
1953 if (!pw || !ma || !ma_space)
1954 goto error;
1955 if (isl_space_match(pw->dim, isl_dim_param, ma_space, isl_dim_param)) {
1956 isl_space_free(ma_space);
1957 return fn(pw, ma);
1958 }
1959 ctx = FN(PW,get_ctx)(pw);
1960 if (!isl_space_has_named_params(pw->dim) ||
1961 !isl_space_has_named_params(ma_space))
1962 isl_die(ctx, isl_error_invalid,
1963 "unaligned unnamed parameters", goto error);
1964 pw = FN(PW,align_params)(pw, ma_space);
1965 ma = isl_multi_aff_align_params(ma, FN(PW,get_space)(pw));
1966 return fn(pw, ma);
1967 error:
1968 isl_space_free(ma_space);
1969 FN(PW,free)(pw);
1970 isl_multi_aff_free(ma);
1971 return NULL;
1972 }
1973
1974 static __isl_give PW *FN(PW,align_params_pw_pw_multi_aff_and)(__isl_take PW *pw,
1975 __isl_take isl_pw_multi_aff *pma,
1976 __isl_give PW *(*fn)(__isl_take PW *pw,
1977 __isl_take isl_pw_multi_aff *ma))
1978 {
1979 isl_ctx *ctx;
1980 isl_space *pma_space;
1981
1982 pma_space = isl_pw_multi_aff_get_space(pma);
1983 if (!pw || !pma || !pma_space)
1984 goto error;
1985 if (isl_space_match(pw->dim, isl_dim_param, pma_space, isl_dim_param)) {
1986 isl_space_free(pma_space);
1987 return fn(pw, pma);
1988 }
1989 ctx = FN(PW,get_ctx)(pw);
1990 if (!isl_space_has_named_params(pw->dim) ||
1991 !isl_space_has_named_params(pma_space))
1992 isl_die(ctx, isl_error_invalid,
1993 "unaligned unnamed parameters", goto error);
1994 pw = FN(PW,align_params)(pw, pma_space);
1995 pma = isl_pw_multi_aff_align_params(pma, FN(PW,get_space)(pw));
1996 return fn(pw, pma);
1997 error:
1998 isl_space_free(pma_space);
1999 FN(PW,free)(pw);
2000 isl_pw_multi_aff_free(pma);
2001 return NULL;
2002 }
2003
2004 /* Compute the pullback of "pw" by the function represented by "ma".
2005 * In other words, plug in "ma" in "pw".
2006 */
2007 static __isl_give PW *FN(PW,pullback_multi_aff_aligned)(__isl_take PW *pw,
2008 __isl_take isl_multi_aff *ma)
2009 {
2010 int i;
2011 isl_space *space = NULL;
2012
2013 ma = isl_multi_aff_align_divs(ma);
2014 pw = FN(PW,cow)(pw);
2015 if (!pw || !ma)
2016 goto error;
2017
2018 space = isl_space_join(isl_multi_aff_get_space(ma),
2019 FN(PW,get_space)(pw));
2020
2021 for (i = 0; i < pw->n; ++i) {
2022 pw->p[i].set = isl_set_preimage_multi_aff(pw->p[i].set,
2023 isl_multi_aff_copy(ma));
2024 if (!pw->p[i].set)
2025 goto error;
2026 pw->p[i].FIELD = FN(EL,pullback_multi_aff)(pw->p[i].FIELD,
2027 isl_multi_aff_copy(ma));
2028 if (!pw->p[i].FIELD)
2029 goto error;
2030 }
2031
2032 pw = FN(PW,reset_space)(pw, space);
2033 isl_multi_aff_free(ma);
2034 return pw;
2035 error:
2036 isl_space_free(space);
2037 isl_multi_aff_free(ma);
2038 FN(PW,free)(pw);
2039 return NULL;
2040 }
2041
2042 __isl_give PW *FN(PW,pullback_multi_aff)(__isl_take PW *pw,
2043 __isl_take isl_multi_aff *ma)
2044 {
2045 return FN(PW,align_params_pw_multi_aff_and)(pw, ma,
2046 &FN(PW,pullback_multi_aff_aligned));
2047 }
2048
2049 /* Compute the pullback of "pw" by the function represented by "pma".
2050 * In other words, plug in "pma" in "pw".
2051 */
2052 static __isl_give PW *FN(PW,pullback_pw_multi_aff_aligned)(__isl_take PW *pw,
2053 __isl_take isl_pw_multi_aff *pma)
2054 {
2055 int i;
2056 PW *res;
2057
2058 if (!pma)
2059 goto error;
2060
2061 if (pma->n == 0) {
2062 isl_space *space;
2063 space = isl_space_join(isl_pw_multi_aff_get_space(pma),
2064 FN(PW,get_space)(pw));
2065 isl_pw_multi_aff_free(pma);
2066 res = FN(PW,empty)(space);
2067 FN(PW,free)(pw);
2068 return res;
2069 }
2070
2071 res = FN(PW,pullback_multi_aff)(FN(PW,copy)(pw),
2072 isl_multi_aff_copy(pma->p[0].maff));
2073 res = FN(PW,intersect_domain)(res, isl_set_copy(pma->p[0].set));
2074
2075 for (i = 1; i < pma->n; ++i) {
2076 PW *res_i;
2077
2078 res_i = FN(PW,pullback_multi_aff)(FN(PW,copy)(pw),
2079 isl_multi_aff_copy(pma->p[i].maff));
2080 res_i = FN(PW,intersect_domain)(res_i,
2081 isl_set_copy(pma->p[i].set));
2082 res = FN(PW,add_disjoint)(res, res_i);
2083 }
2084
2085 isl_pw_multi_aff_free(pma);
2086 FN(PW,free)(pw);
2087 return res;
2088 error:
2089 isl_pw_multi_aff_free(pma);
2090 FN(PW,free)(pw);
2091 return NULL;
2092 }
2093
2094 __isl_give PW *FN(PW,pullback_pw_multi_aff)(__isl_take PW *pw,
2095 __isl_take isl_pw_multi_aff *pma)
2096 {
2097 return FN(PW,align_params_pw_pw_multi_aff_and)(pw, pma,
2098 &FN(PW,pullback_pw_multi_aff_aligned));
2099 }
2100 #endif
Integer set library