?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
isl_union_map_is_single_valued: look at domain spaces individually
[isl.git] / isl_pw_templ.c
blobd28ca52cae5f59fb3e64637dfc0d21f699ee0a1e
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 #ifndef NO_RESET_DIM
1397 /* Reset the space of "pw". Since we don't know if the elements
1398 * represent the spaces themselves or their domains, we pass along
1399 * both when we call their reset_space_and_domain.
1400 */
1401 static __isl_give PW *FN(PW,reset_space_and_domain)(__isl_take PW *pw,
1402 __isl_take isl_space *space, __isl_take isl_space *domain)
1403 {
1404 int i;
1405
1406 pw = FN(PW,cow)(pw);
1407 if (!pw || !space || !domain)
1408 goto error;
1409
1410 for (i = 0; i < pw->n; ++i) {
1411 pw->p[i].set = isl_set_reset_space(pw->p[i].set,
1412 isl_space_copy(domain));
1413 if (!pw->p[i].set)
1414 goto error;
1415 pw->p[i].FIELD = FN(EL,reset_space_and_domain)(pw->p[i].FIELD,
1416 isl_space_copy(space), isl_space_copy(domain));
1417 if (!pw->p[i].FIELD)
1418 goto error;
1419 }
1420
1421 isl_space_free(domain);
1422
1423 isl_space_free(pw->dim);
1424 pw->dim = space;
1425
1426 return pw;
1427 error:
1428 isl_space_free(domain);
1429 isl_space_free(space);
1430 FN(PW,free)(pw);
1431 return NULL;
1432 }
1433
1434 __isl_give PW *FN(PW,reset_domain_space)(__isl_take PW *pw,
1435 __isl_take isl_space *domain)
1436 {
1437 isl_space *space;
1438
1439 space = isl_space_extend_domain_with_range(isl_space_copy(domain),
1440 FN(PW,get_space)(pw));
1441 return FN(PW,reset_space_and_domain)(pw, space, domain);
1442 }
1443
1444 __isl_give PW *FN(PW,reset_space)(__isl_take PW *pw, __isl_take isl_space *dim)
1445 {
1446 isl_space *domain;
1447
1448 domain = isl_space_domain(isl_space_copy(dim));
1449 return FN(PW,reset_space_and_domain)(pw, dim, domain);
1450 }
1451
1452 __isl_give PW *FN(PW,set_tuple_id)(__isl_take PW *pw, enum isl_dim_type type,
1453 __isl_take isl_id *id)
1454 {
1455 isl_space *space;
1456
1457 pw = FN(PW,cow)(pw);
1458 if (!pw)
1459 goto error;
1460
1461 space = FN(PW,get_space)(pw);
1462 space = isl_space_set_tuple_id(space, type, id);
1463
1464 return FN(PW,reset_space)(pw, space);
1465 error:
1466 isl_id_free(id);
1467 return FN(PW,free)(pw);
1468 }
1469
1470 /* Drop the id on the specified tuple.
1471 */
1472 __isl_give PW *FN(PW,reset_tuple_id)(__isl_take PW *pw, enum isl_dim_type type)
1473 {
1474 isl_space *space;
1475
1476 if (!pw)
1477 return NULL;
1478 if (!FN(PW,has_tuple_id)(pw, type))
1479 return pw;
1480
1481 pw = FN(PW,cow)(pw);
1482 if (!pw)
1483 return NULL;
1484
1485 space = FN(PW,get_space)(pw);
1486 space = isl_space_reset_tuple_id(space, type);
1487
1488 return FN(PW,reset_space)(pw, space);
1489 }
1490
1491 __isl_give PW *FN(PW,set_dim_id)(__isl_take PW *pw,
1492 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
1493 {
1494 pw = FN(PW,cow)(pw);
1495 if (!pw)
1496 goto error;
1497 pw->dim = isl_space_set_dim_id(pw->dim, type, pos, id);
1498 return FN(PW,reset_space)(pw, isl_space_copy(pw->dim));
1499 error:
1500 isl_id_free(id);
1501 return FN(PW,free)(pw);
1502 }
1503 #endif
1504
1505 int FN(PW,has_equal_space)(__isl_keep PW *pw1, __isl_keep PW *pw2)
1506 {
1507 if (!pw1 || !pw2)
1508 return -1;
1509
1510 return isl_space_is_equal(pw1->dim, pw2->dim);
1511 }
1512
1513 #ifndef NO_MORPH
1514 __isl_give PW *FN(PW,morph_domain)(__isl_take PW *pw,
1515 __isl_take isl_morph *morph)
1516 {
1517 int i;
1518 isl_ctx *ctx;
1519
1520 if (!pw || !morph)
1521 goto error;
1522
1523 ctx = isl_space_get_ctx(pw->dim);
1524 isl_assert(ctx, isl_space_is_domain_internal(morph->dom->dim, pw->dim),
1525 goto error);
1526
1527 pw = FN(PW,cow)(pw);
1528 if (!pw)
1529 goto error;
1530 pw->dim = isl_space_extend_domain_with_range(
1531 isl_space_copy(morph->ran->dim), pw->dim);
1532 if (!pw->dim)
1533 goto error;
1534
1535 for (i = 0; i < pw->n; ++i) {
1536 pw->p[i].set = isl_morph_set(isl_morph_copy(morph), pw->p[i].set);
1537 if (!pw->p[i].set)
1538 goto error;
1539 pw->p[i].FIELD = FN(EL,morph_domain)(pw->p[i].FIELD,
1540 isl_morph_copy(morph));
1541 if (!pw->p[i].FIELD)
1542 goto error;
1543 }
1544
1545 isl_morph_free(morph);
1546
1547 return pw;
1548 error:
1549 FN(PW,free)(pw);
1550 isl_morph_free(morph);
1551 return NULL;
1552 }
1553 #endif
1554
1555 int FN(PW,n_piece)(__isl_keep PW *pw)
1556 {
1557 return pw ? pw->n : 0;
1558 }
1559
1560 int FN(PW,foreach_piece)(__isl_keep PW *pw,
1561 int (*fn)(__isl_take isl_set *set, __isl_take EL *el, void *user),
1562 void *user)
1563 {
1564 int i;
1565
1566 if (!pw)
1567 return -1;
1568
1569 for (i = 0; i < pw->n; ++i)
1570 if (fn(isl_set_copy(pw->p[i].set),
1571 FN(EL,copy)(pw->p[i].FIELD), user) < 0)
1572 return -1;
1573
1574 return 0;
1575 }
1576
1577 #ifndef NO_LIFT
1578 static int any_divs(__isl_keep isl_set *set)
1579 {
1580 int i;
1581
1582 if (!set)
1583 return -1;
1584
1585 for (i = 0; i < set->n; ++i)
1586 if (set->p[i]->n_div > 0)
1587 return 1;
1588
1589 return 0;
1590 }
1591
1592 static int foreach_lifted_subset(__isl_take isl_set *set, __isl_take EL *el,
1593 int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
1594 void *user), void *user)
1595 {
1596 int i;
1597
1598 if (!set || !el)
1599 goto error;
1600
1601 for (i = 0; i < set->n; ++i) {
1602 isl_set *lift;
1603 EL *copy;
1604
1605 lift = isl_set_from_basic_set(isl_basic_set_copy(set->p[i]));
1606 lift = isl_set_lift(lift);
1607
1608 copy = FN(EL,copy)(el);
1609 copy = FN(EL,lift)(copy, isl_set_get_space(lift));
1610
1611 if (fn(lift, copy, user) < 0)
1612 goto error;
1613 }
1614
1615 isl_set_free(set);
1616 FN(EL,free)(el);
1617
1618 return 0;
1619 error:
1620 isl_set_free(set);
1621 FN(EL,free)(el);
1622 return -1;
1623 }
1624
1625 int FN(PW,foreach_lifted_piece)(__isl_keep PW *pw,
1626 int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
1627 void *user), void *user)
1628 {
1629 int i;
1630
1631 if (!pw)
1632 return -1;
1633
1634 for (i = 0; i < pw->n; ++i) {
1635 isl_set *set;
1636 EL *el;
1637
1638 set = isl_set_copy(pw->p[i].set);
1639 el = FN(EL,copy)(pw->p[i].FIELD);
1640 if (!any_divs(set)) {
1641 if (fn(set, el, user) < 0)
1642 return -1;
1643 continue;
1644 }
1645 if (foreach_lifted_subset(set, el, fn, user) < 0)
1646 return -1;
1647 }
1648
1649 return 0;
1650 }
1651 #endif
1652
1653 #ifndef NO_MOVE_DIMS
1654 __isl_give PW *FN(PW,move_dims)(__isl_take PW *pw,
1655 enum isl_dim_type dst_type, unsigned dst_pos,
1656 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
1657 {
1658 int i;
1659
1660 pw = FN(PW,cow)(pw);
1661 if (!pw)
1662 return NULL;
1663
1664 pw->dim = isl_space_move_dims(pw->dim, dst_type, dst_pos, src_type, src_pos, n);
1665 if (!pw->dim)
1666 goto error;
1667
1668 for (i = 0; i < pw->n; ++i) {
1669 pw->p[i].FIELD = FN(EL,move_dims)(pw->p[i].FIELD,
1670 dst_type, dst_pos, src_type, src_pos, n);
1671 if (!pw->p[i].FIELD)
1672 goto error;
1673 }
1674
1675 if (dst_type == isl_dim_in)
1676 dst_type = isl_dim_set;
1677 if (src_type == isl_dim_in)
1678 src_type = isl_dim_set;
1679
1680 for (i = 0; i < pw->n; ++i) {
1681 pw->p[i].set = isl_set_move_dims(pw->p[i].set,
1682 dst_type, dst_pos,
1683 src_type, src_pos, n);
1684 if (!pw->p[i].set)
1685 goto error;
1686 }
1687
1688 return pw;
1689 error:
1690 FN(PW,free)(pw);
1691 return NULL;
1692 }
1693 #endif
1694
1695 __isl_give PW *FN(PW,mul_isl_int)(__isl_take PW *pw, isl_int v)
1696 {
1697 int i;
1698
1699 if (isl_int_is_one(v))
1700 return pw;
1701 if (pw && DEFAULT_IS_ZERO && isl_int_is_zero(v)) {
1702 PW *zero;
1703 isl_space *dim = FN(PW,get_space)(pw);
1704 #ifdef HAS_TYPE
1705 zero = FN(PW,ZERO)(dim, pw->type);
1706 #else
1707 zero = FN(PW,ZERO)(dim);
1708 #endif
1709 FN(PW,free)(pw);
1710 return zero;
1711 }
1712 pw = FN(PW,cow)(pw);
1713 if (!pw)
1714 return NULL;
1715 if (pw->n == 0)
1716 return pw;
1717
1718 #ifdef HAS_TYPE
1719 if (isl_int_is_neg(v))
1720 pw->type = isl_fold_type_negate(pw->type);
1721 #endif
1722 for (i = 0; i < pw->n; ++i) {
1723 pw->p[i].FIELD = FN(EL,scale)(pw->p[i].FIELD, v);
1724 if (!pw->p[i].FIELD)
1725 goto error;
1726 }
1727
1728 return pw;
1729 error:
1730 FN(PW,free)(pw);
1731 return NULL;
1732 }
1733
1734 /* Multiply the pieces of "pw" by "v" and return the result.
1735 */
1736 __isl_give PW *FN(PW,scale_val)(__isl_take PW *pw, __isl_take isl_val *v)
1737 {
1738 int i;
1739
1740 if (!pw || !v)
1741 goto error;
1742
1743 if (isl_val_is_one(v)) {
1744 isl_val_free(v);
1745 return pw;
1746 }
1747 if (pw && DEFAULT_IS_ZERO && isl_val_is_zero(v)) {
1748 PW *zero;
1749 isl_space *space = FN(PW,get_space)(pw);
1750 #ifdef HAS_TYPE
1751 zero = FN(PW,ZERO)(space, pw->type);
1752 #else
1753 zero = FN(PW,ZERO)(space);
1754 #endif
1755 FN(PW,free)(pw);
1756 isl_val_free(v);
1757 return zero;
1758 }
1759 if (pw->n == 0) {
1760 isl_val_free(v);
1761 return pw;
1762 }
1763 pw = FN(PW,cow)(pw);
1764 if (!pw)
1765 goto error;
1766
1767 #ifdef HAS_TYPE
1768 if (isl_val_is_neg(v))
1769 pw->type = isl_fold_type_negate(pw->type);
1770 #endif
1771 for (i = 0; i < pw->n; ++i) {
1772 pw->p[i].FIELD = FN(EL,scale_val)(pw->p[i].FIELD,
1773 isl_val_copy(v));
1774 if (!pw->p[i].FIELD)
1775 goto error;
1776 }
1777
1778 isl_val_free(v);
1779 return pw;
1780 error:
1781 isl_val_free(v);
1782 FN(PW,free)(pw);
1783 return NULL;
1784 }
1785
1786 __isl_give PW *FN(PW,scale)(__isl_take PW *pw, isl_int v)
1787 {
1788 return FN(PW,mul_isl_int)(pw, v);
1789 }
1790
1791 static int FN(PW,qsort_set_cmp)(const void *p1, const void *p2)
1792 {
1793 isl_set *set1 = *(isl_set * const *)p1;
1794 isl_set *set2 = *(isl_set * const *)p2;
1795
1796 return isl_set_plain_cmp(set1, set2);
1797 }
1798
1799 /* We normalize in place, but if anything goes wrong we need
1800 * to return NULL, so we need to make sure we don't change the
1801 * meaning of any possible other copies of map.
1802 */
1803 __isl_give PW *FN(PW,normalize)(__isl_take PW *pw)
1804 {
1805 int i, j;
1806 isl_set *set;
1807
1808 if (!pw)
1809 return NULL;
1810 for (i = 0; i < pw->n; ++i) {
1811 set = isl_set_normalize(isl_set_copy(pw->p[i].set));
1812 if (!set)
1813 return FN(PW,free)(pw);
1814 isl_set_free(pw->p[i].set);
1815 pw->p[i].set = set;
1816 }
1817 qsort(pw->p, pw->n, sizeof(pw->p[0]), &FN(PW,qsort_set_cmp));
1818 for (i = pw->n - 1; i >= 1; --i) {
1819 if (!isl_set_plain_is_equal(pw->p[i - 1].set, pw->p[i].set))
1820 continue;
1821 if (!FN(EL,plain_is_equal)(pw->p[i - 1].FIELD, pw->p[i].FIELD))
1822 continue;
1823 set = isl_set_union(isl_set_copy(pw->p[i - 1].set),
1824 isl_set_copy(pw->p[i].set));
1825 if (!set)
1826 return FN(PW,free)(pw);
1827 isl_set_free(pw->p[i].set);
1828 FN(EL,free)(pw->p[i].FIELD);
1829 isl_set_free(pw->p[i - 1].set);
1830 pw->p[i - 1].set = set;
1831 for (j = i + 1; j < pw->n; ++j)
1832 pw->p[j - 1] = pw->p[j];
1833 pw->n--;
1834 }
1835
1836 return pw;
1837 }
1838
1839 /* Is pw1 obviously equal to pw2?
1840 * That is, do they have obviously identical cells and obviously identical
1841 * elements on each cell?
1842 */
1843 int FN(PW,plain_is_equal)(__isl_keep PW *pw1, __isl_keep PW *pw2)
1844 {
1845 int i;
1846 int equal;
1847
1848 if (!pw1 || !pw2)
1849 return -1;
1850
1851 if (pw1 == pw2)
1852 return 1;
1853 if (!isl_space_is_equal(pw1->dim, pw2->dim))
1854 return 0;
1855
1856 pw1 = FN(PW,copy)(pw1);
1857 pw2 = FN(PW,copy)(pw2);
1858 pw1 = FN(PW,normalize)(pw1);
1859 pw2 = FN(PW,normalize)(pw2);
1860 if (!pw1 || !pw2)
1861 goto error;
1862
1863 equal = pw1->n == pw2->n;
1864 for (i = 0; equal && i < pw1->n; ++i) {
1865 equal = isl_set_plain_is_equal(pw1->p[i].set, pw2->p[i].set);
1866 if (equal < 0)
1867 goto error;
1868 if (!equal)
1869 break;
1870 equal = FN(EL,plain_is_equal)(pw1->p[i].FIELD, pw2->p[i].FIELD);
1871 if (equal < 0)
1872 goto error;
1873 }
1874
1875 FN(PW,free)(pw1);
1876 FN(PW,free)(pw2);
1877 return equal;
1878 error:
1879 FN(PW,free)(pw1);
1880 FN(PW,free)(pw2);
1881 return -1;
1882 }
1883
1884 #ifndef NO_PULLBACK
1885 static __isl_give PW *FN(PW,align_params_pw_multi_aff_and)(__isl_take PW *pw,
1886 __isl_take isl_multi_aff *ma,
1887 __isl_give PW *(*fn)(__isl_take PW *pw, __isl_take isl_multi_aff *ma))
1888 {
1889 isl_ctx *ctx;
1890 isl_space *ma_space;
1891
1892 ma_space = isl_multi_aff_get_space(ma);
1893 if (!pw || !ma || !ma_space)
1894 goto error;
1895 if (isl_space_match(pw->dim, isl_dim_param, ma_space, isl_dim_param)) {
1896 isl_space_free(ma_space);
1897 return fn(pw, ma);
1898 }
1899 ctx = FN(PW,get_ctx)(pw);
1900 if (!isl_space_has_named_params(pw->dim) ||
1901 !isl_space_has_named_params(ma_space))
1902 isl_die(ctx, isl_error_invalid,
1903 "unaligned unnamed parameters", goto error);
1904 pw = FN(PW,align_params)(pw, ma_space);
1905 ma = isl_multi_aff_align_params(ma, FN(PW,get_space)(pw));
1906 return fn(pw, ma);
1907 error:
1908 isl_space_free(ma_space);
1909 FN(PW,free)(pw);
1910 isl_multi_aff_free(ma);
1911 return NULL;
1912 }
1913
1914 static __isl_give PW *FN(PW,align_params_pw_pw_multi_aff_and)(__isl_take PW *pw,
1915 __isl_take isl_pw_multi_aff *pma,
1916 __isl_give PW *(*fn)(__isl_take PW *pw,
1917 __isl_take isl_pw_multi_aff *ma))
1918 {
1919 isl_ctx *ctx;
1920 isl_space *pma_space;
1921
1922 pma_space = isl_pw_multi_aff_get_space(pma);
1923 if (!pw || !pma || !pma_space)
1924 goto error;
1925 if (isl_space_match(pw->dim, isl_dim_param, pma_space, isl_dim_param)) {
1926 isl_space_free(pma_space);
1927 return fn(pw, pma);
1928 }
1929 ctx = FN(PW,get_ctx)(pw);
1930 if (!isl_space_has_named_params(pw->dim) ||
1931 !isl_space_has_named_params(pma_space))
1932 isl_die(ctx, isl_error_invalid,
1933 "unaligned unnamed parameters", goto error);
1934 pw = FN(PW,align_params)(pw, pma_space);
1935 pma = isl_pw_multi_aff_align_params(pma, FN(PW,get_space)(pw));
1936 return fn(pw, pma);
1937 error:
1938 isl_space_free(pma_space);
1939 FN(PW,free)(pw);
1940 isl_pw_multi_aff_free(pma);
1941 return NULL;
1942 }
1943
1944 /* Compute the pullback of "pw" by the function represented by "ma".
1945 * In other words, plug in "ma" in "pw".
1946 */
1947 static __isl_give PW *FN(PW,pullback_multi_aff_aligned)(__isl_take PW *pw,
1948 __isl_take isl_multi_aff *ma)
1949 {
1950 int i;
1951 isl_space *space = NULL;
1952
1953 ma = isl_multi_aff_align_divs(ma);
1954 pw = FN(PW,cow)(pw);
1955 if (!pw || !ma)
1956 goto error;
1957
1958 space = isl_space_join(isl_multi_aff_get_space(ma),
1959 FN(PW,get_space)(pw));
1960
1961 for (i = 0; i < pw->n; ++i) {
1962 pw->p[i].set = isl_set_preimage_multi_aff(pw->p[i].set,
1963 isl_multi_aff_copy(ma));
1964 if (!pw->p[i].set)
1965 goto error;
1966 pw->p[i].FIELD = FN(EL,pullback_multi_aff)(pw->p[i].FIELD,
1967 isl_multi_aff_copy(ma));
1968 if (!pw->p[i].FIELD)
1969 goto error;
1970 }
1971
1972 pw = FN(PW,reset_space)(pw, space);
1973 isl_multi_aff_free(ma);
1974 return pw;
1975 error:
1976 isl_space_free(space);
1977 isl_multi_aff_free(ma);
1978 FN(PW,free)(pw);
1979 return NULL;
1980 }
1981
1982 __isl_give PW *FN(PW,pullback_multi_aff)(__isl_take PW *pw,
1983 __isl_take isl_multi_aff *ma)
1984 {
1985 return FN(PW,align_params_pw_multi_aff_and)(pw, ma,
1986 &FN(PW,pullback_multi_aff_aligned));
1987 }
1988
1989 /* Compute the pullback of "pw" by the function represented by "pma".
1990 * In other words, plug in "pma" in "pw".
1991 */
1992 static __isl_give PW *FN(PW,pullback_pw_multi_aff_aligned)(__isl_take PW *pw,
1993 __isl_take isl_pw_multi_aff *pma)
1994 {
1995 int i;
1996 PW *res;
1997
1998 if (!pma)
1999 goto error;
2000
2001 if (pma->n == 0) {
2002 isl_space *space;
2003 space = isl_space_join(isl_pw_multi_aff_get_space(pma),
2004 FN(PW,get_space)(pw));
2005 isl_pw_multi_aff_free(pma);
2006 res = FN(PW,empty)(space);
2007 FN(PW,free)(pw);
2008 return res;
2009 }
2010
2011 res = FN(PW,pullback_multi_aff)(FN(PW,copy)(pw),
2012 isl_multi_aff_copy(pma->p[0].maff));
2013 res = FN(PW,intersect_domain)(res, isl_set_copy(pma->p[0].set));
2014
2015 for (i = 1; i < pma->n; ++i) {
2016 PW *res_i;
2017
2018 res_i = FN(PW,pullback_multi_aff)(FN(PW,copy)(pw),
2019 isl_multi_aff_copy(pma->p[i].maff));
2020 res_i = FN(PW,intersect_domain)(res_i,
2021 isl_set_copy(pma->p[i].set));
2022 res = FN(PW,add_disjoint)(res, res_i);
2023 }
2024
2025 isl_pw_multi_aff_free(pma);
2026 FN(PW,free)(pw);
2027 return res;
2028 error:
2029 isl_pw_multi_aff_free(pma);
2030 FN(PW,free)(pw);
2031 return NULL;
2032 }
2033
2034 __isl_give PW *FN(PW,pullback_pw_multi_aff)(__isl_take PW *pw,
2035 __isl_take isl_pw_multi_aff *pma)
2036 {
2037 return FN(PW,align_params_pw_pw_multi_aff_and)(pw, pma,
2038 &FN(PW,pullback_pw_multi_aff_aligned));
2039 }
2040 #endif
Integer set library