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