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