?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update isl to isl-0.19-185-g8e9f55ce
[polly-mirror.git] / lib / External / isl / isl_multi_templ.c
blob076936008ce62070669ad19bab020b3104b518b5
1 /*
2 * Copyright 2011 Sven Verdoolaege
3 * Copyright 2012-2013 Ecole Normale Superieure
4 *
5 * Use of this software is governed by the MIT license
6 *
7 * Written by Sven Verdoolaege,
8 * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
9 */
10
11 #include <isl/id.h>
12 #include <isl_space_private.h>
13 #include <isl_val_private.h>
14 #include <isl/set.h>
15 #include <isl_reordering.h>
16
17 #include <isl_multi_macro.h>
18
19 #define MULTI_NAME(BASE) "isl_multi_" #BASE
20 #define xLIST(EL) EL ## _list
21 #define LIST(EL) xLIST(EL)
22
23 isl_ctx *FN(MULTI(BASE),get_ctx)(__isl_keep MULTI(BASE) *multi)
24 {
25 return multi ? isl_space_get_ctx(multi->space) : NULL;
26 }
27
28 /* Return the space of "multi".
29 */
30 static __isl_keep isl_space *FN(MULTI(BASE),peek_space)(
31 __isl_keep MULTI(BASE) *multi)
32 {
33 return multi ? multi->space : NULL;
34 }
35
36 __isl_give isl_space *FN(MULTI(BASE),get_space)(__isl_keep MULTI(BASE) *multi)
37 {
38 return isl_space_copy(FN(MULTI(BASE),peek_space)(multi));
39 }
40
41 /* Return the position of the dimension of the given type and name
42 * in "multi".
43 * Return -1 if no such dimension can be found.
44 */
45 int FN(MULTI(BASE),find_dim_by_name)(__isl_keep MULTI(BASE) *multi,
46 enum isl_dim_type type, const char *name)
47 {
48 if (!multi)
49 return -1;
50 return isl_space_find_dim_by_name(multi->space, type, name);
51 }
52
53 __isl_give isl_space *FN(MULTI(BASE),get_domain_space)(
54 __isl_keep MULTI(BASE) *multi)
55 {
56 return multi ? isl_space_domain(isl_space_copy(multi->space)) : NULL;
57 }
58
59 /* Allocate a multi expression living in "space".
60 *
61 * If the number of base expressions is zero, then make sure
62 * there is enough room in the structure for the explicit domain,
63 * in case the type supports such an explicit domain.
64 */
65 __isl_give MULTI(BASE) *FN(MULTI(BASE),alloc)(__isl_take isl_space *space)
66 {
67 isl_ctx *ctx;
68 int n;
69 MULTI(BASE) *multi;
70
71 if (!space)
72 return NULL;
73
74 ctx = isl_space_get_ctx(space);
75 n = isl_space_dim(space, isl_dim_out);
76 if (n > 0)
77 multi = isl_calloc(ctx, MULTI(BASE),
78 sizeof(MULTI(BASE)) + (n - 1) * sizeof(struct EL *));
79 else
80 multi = isl_calloc(ctx, MULTI(BASE), sizeof(MULTI(BASE)));
81 if (!multi)
82 goto error;
83
84 multi->space = space;
85 multi->n = n;
86 multi->ref = 1;
87 if (FN(MULTI(BASE),has_explicit_domain)(multi))
88 multi = FN(MULTI(BASE),init_explicit_domain)(multi);
89 return multi;
90 error:
91 isl_space_free(space);
92 return NULL;
93 }
94
95 __isl_give MULTI(BASE) *FN(MULTI(BASE),dup)(__isl_keep MULTI(BASE) *multi)
96 {
97 int i;
98 MULTI(BASE) *dup;
99
100 if (!multi)
101 return NULL;
102
103 dup = FN(MULTI(BASE),alloc)(isl_space_copy(multi->space));
104 if (!dup)
105 return NULL;
106
107 for (i = 0; i < multi->n; ++i)
108 dup = FN(FN(MULTI(BASE),set),BASE)(dup, i,
109 FN(EL,copy)(multi->u.p[i]));
110 if (FN(MULTI(BASE),has_explicit_domain)(multi))
111 dup = FN(MULTI(BASE),copy_explicit_domain)(dup, multi);
112
113 return dup;
114 }
115
116 __isl_give MULTI(BASE) *FN(MULTI(BASE),cow)(__isl_take MULTI(BASE) *multi)
117 {
118 if (!multi)
119 return NULL;
120
121 if (multi->ref == 1)
122 return multi;
123
124 multi->ref--;
125 return FN(MULTI(BASE),dup)(multi);
126 }
127
128 __isl_give MULTI(BASE) *FN(MULTI(BASE),copy)(__isl_keep MULTI(BASE) *multi)
129 {
130 if (!multi)
131 return NULL;
132
133 multi->ref++;
134 return multi;
135 }
136
137 __isl_null MULTI(BASE) *FN(MULTI(BASE),free)(__isl_take MULTI(BASE) *multi)
138 {
139 int i;
140
141 if (!multi)
142 return NULL;
143
144 if (--multi->ref > 0)
145 return NULL;
146
147 isl_space_free(multi->space);
148 for (i = 0; i < multi->n; ++i)
149 FN(EL,free)(multi->u.p[i]);
150 if (FN(MULTI(BASE),has_explicit_domain)(multi))
151 FN(MULTI(BASE),free_explicit_domain)(multi);
152 free(multi);
153
154 return NULL;
155 }
156
157 unsigned FN(MULTI(BASE),dim)(__isl_keep MULTI(BASE) *multi,
158 enum isl_dim_type type)
159 {
160 return multi ? isl_space_dim(multi->space, type) : 0;
161 }
162
163 /* Return the position of the first dimension of "type" with id "id".
164 * Return -1 if there is no such dimension.
165 */
166 int FN(MULTI(BASE),find_dim_by_id)(__isl_keep MULTI(BASE) *multi,
167 enum isl_dim_type type, __isl_keep isl_id *id)
168 {
169 if (!multi)
170 return -1;
171 return isl_space_find_dim_by_id(multi->space, type, id);
172 }
173
174 /* Return the id of the given dimension.
175 */
176 __isl_give isl_id *FN(MULTI(BASE),get_dim_id)(__isl_keep MULTI(BASE) *multi,
177 enum isl_dim_type type, unsigned pos)
178 {
179 return multi ? isl_space_get_dim_id(multi->space, type, pos) : NULL;
180 }
181
182 __isl_give MULTI(BASE) *FN(MULTI(BASE),set_dim_name)(
183 __isl_take MULTI(BASE) *multi,
184 enum isl_dim_type type, unsigned pos, const char *s)
185 {
186 int i;
187
188 multi = FN(MULTI(BASE),cow)(multi);
189 if (!multi)
190 return NULL;
191
192 multi->space = isl_space_set_dim_name(multi->space, type, pos, s);
193 if (!multi->space)
194 return FN(MULTI(BASE),free)(multi);
195
196 if (type == isl_dim_out)
197 return multi;
198 for (i = 0; i < multi->n; ++i) {
199 multi->u.p[i] = FN(EL,set_dim_name)(multi->u.p[i],
200 type, pos, s);
201 if (!multi->u.p[i])
202 return FN(MULTI(BASE),free)(multi);
203 }
204
205 return multi;
206 }
207
208 const char *FN(MULTI(BASE),get_tuple_name)(__isl_keep MULTI(BASE) *multi,
209 enum isl_dim_type type)
210 {
211 return multi ? isl_space_get_tuple_name(multi->space, type) : NULL;
212 }
213
214 /* Does the specified tuple have an id?
215 */
216 isl_bool FN(MULTI(BASE),has_tuple_id)(__isl_keep MULTI(BASE) *multi,
217 enum isl_dim_type type)
218 {
219 if (!multi)
220 return isl_bool_error;
221 return isl_space_has_tuple_id(multi->space, type);
222 }
223
224 /* Return the id of the specified tuple.
225 */
226 __isl_give isl_id *FN(MULTI(BASE),get_tuple_id)(__isl_keep MULTI(BASE) *multi,
227 enum isl_dim_type type)
228 {
229 return multi ? isl_space_get_tuple_id(multi->space, type) : NULL;
230 }
231
232 __isl_give EL *FN(FN(MULTI(BASE),get),BASE)(__isl_keep MULTI(BASE) *multi,
233 int pos)
234 {
235 isl_ctx *ctx;
236
237 if (!multi)
238 return NULL;
239 ctx = FN(MULTI(BASE),get_ctx)(multi);
240 if (pos < 0 || pos >= multi->n)
241 isl_die(ctx, isl_error_invalid,
242 "index out of bounds", return NULL);
243 return FN(EL,copy)(multi->u.p[pos]);
244 }
245
246 /* Set the element at position "pos" of "multi" to "el",
247 * where the position may be empty if "multi" has only a single reference.
248 */
249 static __isl_give MULTI(BASE) *FN(MULTI(BASE),restore)(
250 __isl_take MULTI(BASE) *multi, int pos, __isl_take EL *el)
251 {
252 multi = FN(MULTI(BASE),cow)(multi);
253 if (!multi || !el)
254 goto error;
255
256 if (pos < 0 || pos >= multi->n)
257 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
258 "index out of bounds", goto error);
259
260 FN(EL,free)(multi->u.p[pos]);
261 multi->u.p[pos] = el;
262
263 return multi;
264 error:
265 FN(MULTI(BASE),free)(multi);
266 FN(EL,free)(el);
267 return NULL;
268 }
269
270 /* Set the element at position "pos" of "multi" to "el",
271 * where the position may be empty if "multi" has only a single reference.
272 * However, the space of "multi" is available and is checked
273 * for compatibility with "el".
274 */
275 static __isl_give MULTI(BASE) *FN(MULTI(BASE),restore_check_space)(
276 __isl_take MULTI(BASE) *multi, int pos, __isl_take EL *el)
277 {
278 isl_space *space;
279
280 space = FN(MULTI(BASE),peek_space)(multi);
281 if (FN(EL,check_match_domain_space)(el, space) < 0)
282 multi = FN(MULTI(BASE),free)(multi);
283 return FN(MULTI(BASE),restore)(multi, pos, el);
284 }
285
286 __isl_give MULTI(BASE) *FN(FN(MULTI(BASE),set),BASE)(
287 __isl_take MULTI(BASE) *multi, int pos, __isl_take EL *el)
288 {
289 isl_space *multi_space = NULL;
290 isl_space *el_space = NULL;
291 isl_bool match;
292
293 multi_space = FN(MULTI(BASE),get_space)(multi);
294 match = FN(EL,matching_params)(el, multi_space);
295 if (match < 0)
296 goto error;
297 if (!match) {
298 multi = FN(MULTI(BASE),align_params)(multi,
299 FN(EL,get_space)(el));
300 isl_space_free(multi_space);
301 multi_space = FN(MULTI(BASE),get_space)(multi);
302 el = FN(EL,align_params)(el, isl_space_copy(multi_space));
303 }
304
305 multi = FN(MULTI(BASE),restore_check_space)(multi, pos, el);
306
307 isl_space_free(multi_space);
308 isl_space_free(el_space);
309
310 return multi;
311 error:
312 FN(MULTI(BASE),free)(multi);
313 FN(EL,free)(el);
314 isl_space_free(multi_space);
315 isl_space_free(el_space);
316 return NULL;
317 }
318
319 /* Reset the space of "multi". This function is called from isl_pw_templ.c
320 * and doesn't know if the space of an element object is represented
321 * directly or through its domain. It therefore passes along both,
322 * which we pass along to the element function since we don't know how
323 * that is represented either.
324 *
325 * If "multi" has an explicit domain, then the caller is expected
326 * to make sure that any modification that would change the dimensions
327 * of the explicit domain has bee applied before this function is called.
328 */
329 __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_space_and_domain)(
330 __isl_take MULTI(BASE) *multi, __isl_take isl_space *space,
331 __isl_take isl_space *domain)
332 {
333 int i;
334
335 multi = FN(MULTI(BASE),cow)(multi);
336 if (!multi || !space || !domain)
337 goto error;
338
339 for (i = 0; i < multi->n; ++i) {
340 multi->u.p[i] = FN(EL,reset_domain_space)(multi->u.p[i],
341 isl_space_copy(domain));
342 if (!multi->u.p[i])
343 goto error;
344 }
345 if (FN(MULTI(BASE),has_explicit_domain)(multi)) {
346 multi = FN(MULTI(BASE),reset_explicit_domain_space)(multi,
347 isl_space_copy(domain));
348 if (!multi)
349 goto error;
350 }
351 isl_space_free(domain);
352 isl_space_free(multi->space);
353 multi->space = space;
354
355 return multi;
356 error:
357 isl_space_free(domain);
358 isl_space_free(space);
359 FN(MULTI(BASE),free)(multi);
360 return NULL;
361 }
362
363 __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_domain_space)(
364 __isl_take MULTI(BASE) *multi, __isl_take isl_space *domain)
365 {
366 isl_space *space;
367
368 space = isl_space_extend_domain_with_range(isl_space_copy(domain),
369 isl_space_copy(multi->space));
370 return FN(MULTI(BASE),reset_space_and_domain)(multi, space, domain);
371 }
372
373 __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_space)(
374 __isl_take MULTI(BASE) *multi, __isl_take isl_space *space)
375 {
376 isl_space *domain;
377
378 domain = isl_space_domain(isl_space_copy(space));
379 return FN(MULTI(BASE),reset_space_and_domain)(multi, space, domain);
380 }
381
382 /* Set the id of the given dimension of "multi" to "id".
383 */
384 __isl_give MULTI(BASE) *FN(MULTI(BASE),set_dim_id)(
385 __isl_take MULTI(BASE) *multi,
386 enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
387 {
388 isl_space *space;
389
390 multi = FN(MULTI(BASE),cow)(multi);
391 if (!multi || !id)
392 goto error;
393
394 space = FN(MULTI(BASE),get_space)(multi);
395 space = isl_space_set_dim_id(space, type, pos, id);
396
397 return FN(MULTI(BASE),reset_space)(multi, space);
398 error:
399 isl_id_free(id);
400 FN(MULTI(BASE),free)(multi);
401 return NULL;
402 }
403
404 __isl_give MULTI(BASE) *FN(MULTI(BASE),set_tuple_name)(
405 __isl_keep MULTI(BASE) *multi, enum isl_dim_type type,
406 const char *s)
407 {
408 isl_space *space;
409
410 multi = FN(MULTI(BASE),cow)(multi);
411 if (!multi)
412 return NULL;
413
414 space = FN(MULTI(BASE),get_space)(multi);
415 space = isl_space_set_tuple_name(space, type, s);
416
417 return FN(MULTI(BASE),reset_space)(multi, space);
418 }
419
420 __isl_give MULTI(BASE) *FN(MULTI(BASE),set_tuple_id)(
421 __isl_take MULTI(BASE) *multi, enum isl_dim_type type,
422 __isl_take isl_id *id)
423 {
424 isl_space *space;
425
426 multi = FN(MULTI(BASE),cow)(multi);
427 if (!multi)
428 goto error;
429
430 space = FN(MULTI(BASE),get_space)(multi);
431 space = isl_space_set_tuple_id(space, type, id);
432
433 return FN(MULTI(BASE),reset_space)(multi, space);
434 error:
435 isl_id_free(id);
436 return NULL;
437 }
438
439 /* Drop the id on the specified tuple.
440 */
441 __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_tuple_id)(
442 __isl_take MULTI(BASE) *multi, enum isl_dim_type type)
443 {
444 isl_space *space;
445
446 if (!multi)
447 return NULL;
448 if (!FN(MULTI(BASE),has_tuple_id)(multi, type))
449 return multi;
450
451 multi = FN(MULTI(BASE),cow)(multi);
452 if (!multi)
453 return NULL;
454
455 space = FN(MULTI(BASE),get_space)(multi);
456 space = isl_space_reset_tuple_id(space, type);
457
458 return FN(MULTI(BASE),reset_space)(multi, space);
459 }
460
461 /* Reset the user pointer on all identifiers of parameters and tuples
462 * of the space of "multi".
463 */
464 __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_user)(
465 __isl_take MULTI(BASE) *multi)
466 {
467 isl_space *space;
468
469 space = FN(MULTI(BASE),get_space)(multi);
470 space = isl_space_reset_user(space);
471
472 return FN(MULTI(BASE),reset_space)(multi, space);
473 }
474
475 __isl_give MULTI(BASE) *FN(MULTI(BASE),realign_domain)(
476 __isl_take MULTI(BASE) *multi, __isl_take isl_reordering *exp)
477 {
478 int i;
479 isl_space *space;
480
481 multi = FN(MULTI(BASE),cow)(multi);
482 if (!multi || !exp)
483 goto error;
484
485 for (i = 0; i < multi->n; ++i) {
486 multi->u.p[i] = FN(EL,realign_domain)(multi->u.p[i],
487 isl_reordering_copy(exp));
488 if (!multi->u.p[i])
489 goto error;
490 }
491
492 space = isl_reordering_get_space(exp);
493 multi = FN(MULTI(BASE),reset_domain_space)(multi, space);
494
495 isl_reordering_free(exp);
496 return multi;
497 error:
498 isl_reordering_free(exp);
499 FN(MULTI(BASE),free)(multi);
500 return NULL;
501 }
502
503 /* Align the parameters of "multi" to those of "model".
504 *
505 * If "multi" has an explicit domain, then align the parameters
506 * of the domain first.
507 */
508 __isl_give MULTI(BASE) *FN(MULTI(BASE),align_params)(
509 __isl_take MULTI(BASE) *multi, __isl_take isl_space *model)
510 {
511 isl_ctx *ctx;
512 isl_bool equal_params;
513 isl_reordering *exp;
514
515 if (!multi || !model)
516 goto error;
517
518 equal_params = isl_space_has_equal_params(multi->space, model);
519 if (equal_params < 0)
520 goto error;
521 if (equal_params) {
522 isl_space_free(model);
523 return multi;
524 }
525
526 ctx = isl_space_get_ctx(model);
527 if (!isl_space_has_named_params(model))
528 isl_die(ctx, isl_error_invalid,
529 "model has unnamed parameters", goto error);
530 if (!isl_space_has_named_params(multi->space))
531 isl_die(ctx, isl_error_invalid,
532 "input has unnamed parameters", goto error);
533
534 if (FN(MULTI(BASE),has_explicit_domain)(multi)) {
535 multi = FN(MULTI(BASE),align_explicit_domain_params)(multi,
536 isl_space_copy(model));
537 if (!multi)
538 goto error;
539 }
540 exp = isl_parameter_alignment_reordering(multi->space, model);
541 exp = isl_reordering_extend_space(exp,
542 FN(MULTI(BASE),get_domain_space)(multi));
543 multi = FN(MULTI(BASE),realign_domain)(multi, exp);
544
545 isl_space_free(model);
546 return multi;
547 error:
548 isl_space_free(model);
549 FN(MULTI(BASE),free)(multi);
550 return NULL;
551 }
552
553 /* Create a multi expression in the given space with the elements of "list"
554 * as base expressions.
555 *
556 * Since isl_multi_*_restore_* assumes that the element and
557 * the multi expression have matching spaces, the alignment
558 * (if any) needs to be performed beforehand.
559 */
560 __isl_give MULTI(BASE) *FN(FN(MULTI(BASE),from),LIST(BASE))(
561 __isl_take isl_space *space, __isl_take LIST(EL) *list)
562 {
563 int i;
564 int n;
565 isl_ctx *ctx;
566 MULTI(BASE) *multi;
567
568 if (!space || !list)
569 goto error;
570
571 ctx = isl_space_get_ctx(space);
572 n = FN(FN(LIST(EL),n),BASE)(list);
573 if (n != isl_space_dim(space, isl_dim_out))
574 isl_die(ctx, isl_error_invalid,
575 "invalid number of elements in list", goto error);
576
577 for (i = 0; i < n; ++i) {
578 EL *el = FN(LIST(EL),peek)(list, i);
579 space = isl_space_align_params(space, FN(EL,get_space)(el));
580 }
581 multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
582 for (i = 0; i < n; ++i) {
583 EL *el = FN(FN(LIST(EL),get),BASE)(list, i);
584 el = FN(EL,align_params)(el, isl_space_copy(space));
585 multi = FN(MULTI(BASE),restore_check_space)(multi, i, el);
586 }
587
588 isl_space_free(space);
589 FN(LIST(EL),free)(list);
590 return multi;
591 error:
592 isl_space_free(space);
593 FN(LIST(EL),free)(list);
594 return NULL;
595 }
596
597 #ifndef NO_IDENTITY
598 /* Create a multi expression in the given space that maps each
599 * input dimension to the corresponding output dimension.
600 */
601 __isl_give MULTI(BASE) *FN(MULTI(BASE),identity)(__isl_take isl_space *space)
602 {
603 int i, n;
604 isl_local_space *ls;
605 MULTI(BASE) *multi;
606
607 if (!space)
608 return NULL;
609
610 if (isl_space_is_set(space))
611 isl_die(isl_space_get_ctx(space), isl_error_invalid,
612 "expecting map space", goto error);
613
614 n = isl_space_dim(space, isl_dim_out);
615 if (n != isl_space_dim(space, isl_dim_in))
616 isl_die(isl_space_get_ctx(space), isl_error_invalid,
617 "number of input and output dimensions needs to be "
618 "the same", goto error);
619
620 multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
621
622 if (!n) {
623 isl_space_free(space);
624 return multi;
625 }
626
627 space = isl_space_domain(space);
628 ls = isl_local_space_from_space(space);
629
630 for (i = 0; i < n; ++i) {
631 EL *el;
632 el = FN(EL,var_on_domain)(isl_local_space_copy(ls),
633 isl_dim_set, i);
634 multi = FN(FN(MULTI(BASE),set),BASE)(multi, i, el);
635 }
636
637 isl_local_space_free(ls);
638
639 return multi;
640 error:
641 isl_space_free(space);
642 return NULL;
643 }
644 #endif
645
646 #ifndef NO_ZERO
647 /* Construct a multi expression in the given space with value zero in
648 * each of the output dimensions.
649 */
650 __isl_give MULTI(BASE) *FN(MULTI(BASE),zero)(__isl_take isl_space *space)
651 {
652 int n;
653 MULTI(BASE) *multi;
654
655 if (!space)
656 return NULL;
657
658 n = isl_space_dim(space , isl_dim_out);
659 multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
660
661 if (!n)
662 isl_space_free(space);
663 else {
664 int i;
665 isl_local_space *ls;
666 EL *el;
667
668 space = isl_space_domain(space);
669 ls = isl_local_space_from_space(space);
670 el = FN(EL,zero_on_domain)(ls);
671
672 for (i = 0; i < n; ++i)
673 multi = FN(FN(MULTI(BASE),set),BASE)(multi, i,
674 FN(EL,copy)(el));
675
676 FN(EL,free)(el);
677 }
678
679 return multi;
680 }
681 #endif
682
683 #ifndef NO_FROM_BASE
684 /* Create a multiple expression with a single output/set dimension
685 * equal to "el".
686 * For most multiple expression types, the base type has a single
687 * output/set dimension and the space of the result is therefore
688 * the same as the space of the input.
689 * In the case of isl_multi_union_pw_aff, however, the base type
690 * lives in a parameter space and we therefore need to add
691 * a single set dimension.
692 */
693 __isl_give MULTI(BASE) *FN(FN(MULTI(BASE),from),BASE)(__isl_take EL *el)
694 {
695 isl_space *space;
696 MULTI(BASE) *multi;
697
698 space = FN(EL,get_space(el));
699 if (isl_space_is_params(space)) {
700 space = isl_space_set_from_params(space);
701 space = isl_space_add_dims(space, isl_dim_set, 1);
702 }
703 multi = FN(MULTI(BASE),alloc)(space);
704 multi = FN(FN(MULTI(BASE),set),BASE)(multi, 0, el);
705
706 return multi;
707 }
708 #endif
709
710 __isl_give MULTI(BASE) *FN(MULTI(BASE),drop_dims)(
711 __isl_take MULTI(BASE) *multi,
712 enum isl_dim_type type, unsigned first, unsigned n)
713 {
714 int i;
715 unsigned dim;
716
717 multi = FN(MULTI(BASE),cow)(multi);
718 if (!multi)
719 return NULL;
720
721 dim = FN(MULTI(BASE),dim)(multi, type);
722 if (first + n > dim || first + n < first)
723 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
724 "index out of bounds",
725 return FN(MULTI(BASE),free)(multi));
726
727 multi->space = isl_space_drop_dims(multi->space, type, first, n);
728 if (!multi->space)
729 return FN(MULTI(BASE),free)(multi);
730
731 if (type == isl_dim_out) {
732 for (i = 0; i < n; ++i)
733 FN(EL,free)(multi->u.p[first + i]);
734 for (i = first; i + n < multi->n; ++i)
735 multi->u.p[i] = multi->u.p[i + n];
736 multi->n -= n;
737 if (n > 0 && FN(MULTI(BASE),has_explicit_domain)(multi))
738 multi = FN(MULTI(BASE),init_explicit_domain)(multi);
739
740 return multi;
741 }
742
743 if (FN(MULTI(BASE),has_explicit_domain)(multi))
744 multi = FN(MULTI(BASE),drop_explicit_domain_dims)(multi,
745 type, first, n);
746 if (!multi)
747 return NULL;
748
749 for (i = 0; i < multi->n; ++i) {
750 multi->u.p[i] = FN(EL,drop_dims)(multi->u.p[i], type, first, n);
751 if (!multi->u.p[i])
752 return FN(MULTI(BASE),free)(multi);
753 }
754
755 return multi;
756 }
757
758 /* Align the parameters of "multi1" and "multi2" (if needed) and call "fn".
759 */
760 static __isl_give MULTI(BASE) *FN(MULTI(BASE),align_params_multi_multi_and)(
761 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2,
762 __isl_give MULTI(BASE) *(*fn)(__isl_take MULTI(BASE) *multi1,
763 __isl_take MULTI(BASE) *multi2))
764 {
765 isl_ctx *ctx;
766 isl_bool equal_params;
767
768 if (!multi1 || !multi2)
769 goto error;
770 equal_params = isl_space_has_equal_params(multi1->space, multi2->space);
771 if (equal_params < 0)
772 goto error;
773 if (equal_params)
774 return fn(multi1, multi2);
775 ctx = FN(MULTI(BASE),get_ctx)(multi1);
776 if (!isl_space_has_named_params(multi1->space) ||
777 !isl_space_has_named_params(multi2->space))
778 isl_die(ctx, isl_error_invalid,
779 "unaligned unnamed parameters", goto error);
780 multi1 = FN(MULTI(BASE),align_params)(multi1,
781 FN(MULTI(BASE),get_space)(multi2));
782 multi2 = FN(MULTI(BASE),align_params)(multi2,
783 FN(MULTI(BASE),get_space)(multi1));
784 return fn(multi1, multi2);
785 error:
786 FN(MULTI(BASE),free)(multi1);
787 FN(MULTI(BASE),free)(multi2);
788 return NULL;
789 }
790
791 /* Given two MULTI(BASE)s A -> B and C -> D,
792 * construct a MULTI(BASE) (A * C) -> [B -> D].
793 *
794 * The parameters are assumed to have been aligned.
795 *
796 * If "multi1" and/or "multi2" has an explicit domain, then
797 * intersect the domain of the result with these explicit domains.
798 */
799 static __isl_give MULTI(BASE) *FN(MULTI(BASE),range_product_aligned)(
800 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
801 {
802 int i, n1, n2;
803 EL *el;
804 isl_space *space;
805 MULTI(BASE) *res;
806
807 if (!multi1 || !multi2)
808 goto error;
809
810 space = isl_space_range_product(FN(MULTI(BASE),get_space)(multi1),
811 FN(MULTI(BASE),get_space)(multi2));
812 res = FN(MULTI(BASE),alloc)(space);
813
814 n1 = FN(MULTI(BASE),dim)(multi1, isl_dim_out);
815 n2 = FN(MULTI(BASE),dim)(multi2, isl_dim_out);
816
817 for (i = 0; i < n1; ++i) {
818 el = FN(FN(MULTI(BASE),get),BASE)(multi1, i);
819 res = FN(FN(MULTI(BASE),set),BASE)(res, i, el);
820 }
821
822 for (i = 0; i < n2; ++i) {
823 el = FN(FN(MULTI(BASE),get),BASE)(multi2, i);
824 res = FN(FN(MULTI(BASE),set),BASE)(res, n1 + i, el);
825 }
826
827 if (FN(MULTI(BASE),has_explicit_domain)(multi1))
828 res = FN(MULTI(BASE),intersect_explicit_domain)(res, multi1);
829 if (FN(MULTI(BASE),has_explicit_domain)(multi2))
830 res = FN(MULTI(BASE),intersect_explicit_domain)(res, multi2);
831
832 FN(MULTI(BASE),free)(multi1);
833 FN(MULTI(BASE),free)(multi2);
834 return res;
835 error:
836 FN(MULTI(BASE),free)(multi1);
837 FN(MULTI(BASE),free)(multi2);
838 return NULL;
839 }
840
841 /* Given two MULTI(BASE)s A -> B and C -> D,
842 * construct a MULTI(BASE) (A * C) -> [B -> D].
843 */
844 __isl_give MULTI(BASE) *FN(MULTI(BASE),range_product)(
845 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
846 {
847 return FN(MULTI(BASE),align_params_multi_multi_and)(multi1, multi2,
848 &FN(MULTI(BASE),range_product_aligned));
849 }
850
851 /* Is the range of "multi" a wrapped relation?
852 */
853 isl_bool FN(MULTI(BASE),range_is_wrapping)(__isl_keep MULTI(BASE) *multi)
854 {
855 if (!multi)
856 return isl_bool_error;
857 return isl_space_range_is_wrapping(multi->space);
858 }
859
860 /* Given a function A -> [B -> C], extract the function A -> B.
861 */
862 __isl_give MULTI(BASE) *FN(MULTI(BASE),range_factor_domain)(
863 __isl_take MULTI(BASE) *multi)
864 {
865 isl_space *space;
866 int total, keep;
867
868 if (!multi)
869 return NULL;
870 if (!isl_space_range_is_wrapping(multi->space))
871 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
872 "range is not a product",
873 return FN(MULTI(BASE),free)(multi));
874
875 space = FN(MULTI(BASE),get_space)(multi);
876 total = isl_space_dim(space, isl_dim_out);
877 space = isl_space_range_factor_domain(space);
878 keep = isl_space_dim(space, isl_dim_out);
879 multi = FN(MULTI(BASE),drop_dims)(multi,
880 isl_dim_out, keep, total - keep);
881 multi = FN(MULTI(BASE),reset_space)(multi, space);
882
883 return multi;
884 }
885
886 /* Given a function A -> [B -> C], extract the function A -> C.
887 */
888 __isl_give MULTI(BASE) *FN(MULTI(BASE),range_factor_range)(
889 __isl_take MULTI(BASE) *multi)
890 {
891 isl_space *space;
892 int total, keep;
893
894 if (!multi)
895 return NULL;
896 if (!isl_space_range_is_wrapping(multi->space))
897 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
898 "range is not a product",
899 return FN(MULTI(BASE),free)(multi));
900
901 space = FN(MULTI(BASE),get_space)(multi);
902 total = isl_space_dim(space, isl_dim_out);
903 space = isl_space_range_factor_range(space);
904 keep = isl_space_dim(space, isl_dim_out);
905 multi = FN(MULTI(BASE),drop_dims)(multi, isl_dim_out, 0, total - keep);
906 multi = FN(MULTI(BASE),reset_space)(multi, space);
907
908 return multi;
909 }
910
911 /* Given a function [B -> C], extract the function C.
912 */
913 __isl_give MULTI(BASE) *FN(MULTI(BASE),factor_range)(
914 __isl_take MULTI(BASE) *multi)
915 {
916 isl_space *space;
917 int total, keep;
918
919 if (!multi)
920 return NULL;
921 if (!isl_space_is_wrapping(multi->space))
922 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
923 "not a product", return FN(MULTI(BASE),free)(multi));
924
925 space = FN(MULTI(BASE),get_space)(multi);
926 total = isl_space_dim(space, isl_dim_out);
927 space = isl_space_factor_range(space);
928 keep = isl_space_dim(space, isl_dim_out);
929 multi = FN(MULTI(BASE),drop_dims)(multi, isl_dim_out, 0, total - keep);
930 multi = FN(MULTI(BASE),reset_space)(multi, space);
931
932 return multi;
933 }
934
935 #ifndef NO_PRODUCT
936 /* Given two MULTI(BASE)s A -> B and C -> D,
937 * construct a MULTI(BASE) [A -> C] -> [B -> D].
938 *
939 * The parameters are assumed to have been aligned.
940 *
941 * If "multi1" and/or "multi2" has an explicit domain, then
942 * intersect the domain of the result with these explicit domains.
943 */
944 __isl_give MULTI(BASE) *FN(MULTI(BASE),product_aligned)(
945 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
946 {
947 int i;
948 EL *el;
949 isl_space *space;
950 MULTI(BASE) *res;
951 int in1, in2, out1, out2;
952
953 in1 = FN(MULTI(BASE),dim)(multi1, isl_dim_in);
954 in2 = FN(MULTI(BASE),dim)(multi2, isl_dim_in);
955 out1 = FN(MULTI(BASE),dim)(multi1, isl_dim_out);
956 out2 = FN(MULTI(BASE),dim)(multi2, isl_dim_out);
957 space = isl_space_product(FN(MULTI(BASE),get_space)(multi1),
958 FN(MULTI(BASE),get_space)(multi2));
959 res = FN(MULTI(BASE),alloc)(isl_space_copy(space));
960 space = isl_space_domain(space);
961
962 for (i = 0; i < out1; ++i) {
963 el = FN(FN(MULTI(BASE),get),BASE)(multi1, i);
964 el = FN(EL,insert_dims)(el, isl_dim_in, in1, in2);
965 el = FN(EL,reset_domain_space)(el, isl_space_copy(space));
966 res = FN(FN(MULTI(BASE),set),BASE)(res, i, el);
967 }
968
969 for (i = 0; i < out2; ++i) {
970 el = FN(FN(MULTI(BASE),get),BASE)(multi2, i);
971 el = FN(EL,insert_dims)(el, isl_dim_in, 0, in1);
972 el = FN(EL,reset_domain_space)(el, isl_space_copy(space));
973 res = FN(FN(MULTI(BASE),set),BASE)(res, out1 + i, el);
974 }
975
976 if (FN(MULTI(BASE),has_explicit_domain)(multi1) ||
977 FN(MULTI(BASE),has_explicit_domain)(multi2))
978 res = FN(MULTI(BASE),intersect_explicit_domain_product)(res,
979 multi1, multi2);
980
981 isl_space_free(space);
982 FN(MULTI(BASE),free)(multi1);
983 FN(MULTI(BASE),free)(multi2);
984 return res;
985 }
986
987 /* Given two MULTI(BASE)s A -> B and C -> D,
988 * construct a MULTI(BASE) [A -> C] -> [B -> D].
989 */
990 __isl_give MULTI(BASE) *FN(MULTI(BASE),product)(
991 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
992 {
993 return FN(MULTI(BASE),align_params_multi_multi_and)(multi1, multi2,
994 &FN(MULTI(BASE),product_aligned));
995 }
996 #endif
997
998 __isl_give MULTI(BASE) *FN(MULTI(BASE),flatten_range)(
999 __isl_take MULTI(BASE) *multi)
1000 {
1001 if (!multi)
1002 return NULL;
1003
1004 if (!multi->space->nested[1])
1005 return multi;
1006
1007 multi = FN(MULTI(BASE),cow)(multi);
1008 if (!multi)
1009 return NULL;
1010
1011 multi->space = isl_space_flatten_range(multi->space);
1012 if (!multi->space)
1013 return FN(MULTI(BASE),free)(multi);
1014
1015 return multi;
1016 }
1017
1018 /* Given two MULTI(BASE)s A -> B and C -> D,
1019 * construct a MULTI(BASE) (A * C) -> (B, D).
1020 */
1021 __isl_give MULTI(BASE) *FN(MULTI(BASE),flat_range_product)(
1022 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
1023 {
1024 MULTI(BASE) *multi;
1025
1026 multi = FN(MULTI(BASE),range_product)(multi1, multi2);
1027 multi = FN(MULTI(BASE),flatten_range)(multi);
1028 return multi;
1029 }
1030
1031 /* Given two multi expressions, "multi1"
1032 *
1033 * [A] -> [B1 B2]
1034 *
1035 * where B2 starts at position "pos", and "multi2"
1036 *
1037 * [A] -> [D]
1038 *
1039 * return the multi expression
1040 *
1041 * [A] -> [B1 D B2]
1042 */
1043 __isl_give MULTI(BASE) *FN(MULTI(BASE),range_splice)(
1044 __isl_take MULTI(BASE) *multi1, unsigned pos,
1045 __isl_take MULTI(BASE) *multi2)
1046 {
1047 MULTI(BASE) *res;
1048 unsigned dim;
1049
1050 if (!multi1 || !multi2)
1051 goto error;
1052
1053 dim = FN(MULTI(BASE),dim)(multi1, isl_dim_out);
1054 if (pos > dim)
1055 isl_die(FN(MULTI(BASE),get_ctx)(multi1), isl_error_invalid,
1056 "index out of bounds", goto error);
1057
1058 res = FN(MULTI(BASE),copy)(multi1);
1059 res = FN(MULTI(BASE),drop_dims)(res, isl_dim_out, pos, dim - pos);
1060 multi1 = FN(MULTI(BASE),drop_dims)(multi1, isl_dim_out, 0, pos);
1061
1062 res = FN(MULTI(BASE),flat_range_product)(res, multi2);
1063 res = FN(MULTI(BASE),flat_range_product)(res, multi1);
1064
1065 return res;
1066 error:
1067 FN(MULTI(BASE),free)(multi1);
1068 FN(MULTI(BASE),free)(multi2);
1069 return NULL;
1070 }
1071
1072 #ifndef NO_SPLICE
1073 /* Given two multi expressions, "multi1"
1074 *
1075 * [A1 A2] -> [B1 B2]
1076 *
1077 * where A2 starts at position "in_pos" and B2 starts at position "out_pos",
1078 * and "multi2"
1079 *
1080 * [C] -> [D]
1081 *
1082 * return the multi expression
1083 *
1084 * [A1 C A2] -> [B1 D B2]
1085 *
1086 * We first insert input dimensions to obtain
1087 *
1088 * [A1 C A2] -> [B1 B2]
1089 *
1090 * and
1091 *
1092 * [A1 C A2] -> [D]
1093 *
1094 * and then apply range_splice.
1095 */
1096 __isl_give MULTI(BASE) *FN(MULTI(BASE),splice)(
1097 __isl_take MULTI(BASE) *multi1, unsigned in_pos, unsigned out_pos,
1098 __isl_take MULTI(BASE) *multi2)
1099 {
1100 unsigned n_in1;
1101 unsigned n_in2;
1102
1103 if (!multi1 || !multi2)
1104 goto error;
1105
1106 n_in1 = FN(MULTI(BASE),dim)(multi1, isl_dim_in);
1107 if (in_pos > n_in1)
1108 isl_die(FN(MULTI(BASE),get_ctx)(multi1), isl_error_invalid,
1109 "index out of bounds", goto error);
1110
1111 n_in2 = FN(MULTI(BASE),dim)(multi2, isl_dim_in);
1112
1113 multi1 = FN(MULTI(BASE),insert_dims)(multi1, isl_dim_in, in_pos, n_in2);
1114 multi2 = FN(MULTI(BASE),insert_dims)(multi2, isl_dim_in, n_in2,
1115 n_in1 - in_pos);
1116 multi2 = FN(MULTI(BASE),insert_dims)(multi2, isl_dim_in, 0, in_pos);
1117
1118 return FN(MULTI(BASE),range_splice)(multi1, out_pos, multi2);
1119 error:
1120 FN(MULTI(BASE),free)(multi1);
1121 FN(MULTI(BASE),free)(multi2);
1122 return NULL;
1123 }
1124 #endif
1125
1126 /* Check that "multi1" and "multi2" live in the same space,
1127 * reporting an error if they do not.
1128 */
1129 static isl_stat FN(MULTI(BASE),check_equal_space)(
1130 __isl_keep MULTI(BASE) *multi1, __isl_keep MULTI(BASE) *multi2)
1131 {
1132 isl_bool equal;
1133
1134 if (!multi1 || !multi2)
1135 return isl_stat_error;
1136
1137 equal = isl_space_is_equal(multi1->space, multi2->space);
1138 if (equal < 0)
1139 return isl_stat_error;
1140 if (!equal)
1141 isl_die(FN(MULTI(BASE),get_ctx)(multi1), isl_error_invalid,
1142 "spaces don't match", return isl_stat_error);
1143
1144 return isl_stat_ok;
1145 }
1146
1147 /* This function is currently only used from isl_aff.c
1148 */
1149 static __isl_give MULTI(BASE) *FN(MULTI(BASE),bin_op)(
1150 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2,
1151 __isl_give EL *(*fn)(__isl_take EL *, __isl_take EL *))
1152 __attribute__ ((unused));
1153
1154 /* Pairwise perform "fn" to the elements of "multi1" and "multi2" and
1155 * return the result.
1156 *
1157 * If "multi2" has an explicit domain, then
1158 * intersect the domain of the result with this explicit domain.
1159 */
1160 static __isl_give MULTI(BASE) *FN(MULTI(BASE),bin_op)(
1161 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2,
1162 __isl_give EL *(*fn)(__isl_take EL *, __isl_take EL *))
1163 {
1164 int i;
1165
1166 multi1 = FN(MULTI(BASE),cow)(multi1);
1167 if (FN(MULTI(BASE),check_equal_space)(multi1, multi2) < 0)
1168 goto error;
1169
1170 for (i = 0; i < multi1->n; ++i) {
1171 multi1->u.p[i] = fn(multi1->u.p[i],
1172 FN(EL,copy)(multi2->u.p[i]));
1173 if (!multi1->u.p[i])
1174 goto error;
1175 }
1176
1177 if (FN(MULTI(BASE),has_explicit_domain)(multi2))
1178 multi1 = FN(MULTI(BASE),intersect_explicit_domain)(multi1,
1179 multi2);
1180
1181 FN(MULTI(BASE),free)(multi2);
1182 return multi1;
1183 error:
1184 FN(MULTI(BASE),free)(multi1);
1185 FN(MULTI(BASE),free)(multi2);
1186 return NULL;
1187 }
1188
1189 /* Add "multi2" from "multi1" and return the result.
1190 *
1191 * The parameters of "multi1" and "multi2" are assumed to have been aligned.
1192 */
1193 static __isl_give MULTI(BASE) *FN(MULTI(BASE),add_aligned)(
1194 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
1195 {
1196 return FN(MULTI(BASE),bin_op)(multi1, multi2, &FN(EL,add));
1197 }
1198
1199 /* Add "multi2" from "multi1" and return the result.
1200 */
1201 __isl_give MULTI(BASE) *FN(MULTI(BASE),add)(__isl_take MULTI(BASE) *multi1,
1202 __isl_take MULTI(BASE) *multi2)
1203 {
1204 return FN(MULTI(BASE),align_params_multi_multi_and)(multi1, multi2,
1205 &FN(MULTI(BASE),add_aligned));
1206 }
1207
1208 /* Subtract "multi2" from "multi1" and return the result.
1209 *
1210 * The parameters of "multi1" and "multi2" are assumed to have been aligned.
1211 */
1212 static __isl_give MULTI(BASE) *FN(MULTI(BASE),sub_aligned)(
1213 __isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
1214 {
1215 return FN(MULTI(BASE),bin_op)(multi1, multi2, &FN(EL,sub));
1216 }
1217
1218 /* Subtract "multi2" from "multi1" and return the result.
1219 */
1220 __isl_give MULTI(BASE) *FN(MULTI(BASE),sub)(__isl_take MULTI(BASE) *multi1,
1221 __isl_take MULTI(BASE) *multi2)
1222 {
1223 return FN(MULTI(BASE),align_params_multi_multi_and)(multi1, multi2,
1224 &FN(MULTI(BASE),sub_aligned));
1225 }
1226
1227 /* Multiply the elements of "multi" by "v" and return the result.
1228 */
1229 __isl_give MULTI(BASE) *FN(MULTI(BASE),scale_val)(__isl_take MULTI(BASE) *multi,
1230 __isl_take isl_val *v)
1231 {
1232 int i;
1233
1234 if (!multi || !v)
1235 goto error;
1236
1237 if (isl_val_is_one(v)) {
1238 isl_val_free(v);
1239 return multi;
1240 }
1241
1242 if (!isl_val_is_rat(v))
1243 isl_die(isl_val_get_ctx(v), isl_error_invalid,
1244 "expecting rational factor", goto error);
1245
1246 multi = FN(MULTI(BASE),cow)(multi);
1247 if (!multi)
1248 return NULL;
1249
1250 for (i = 0; i < multi->n; ++i) {
1251 multi->u.p[i] = FN(EL,scale_val)(multi->u.p[i],
1252 isl_val_copy(v));
1253 if (!multi->u.p[i])
1254 goto error;
1255 }
1256
1257 isl_val_free(v);
1258 return multi;
1259 error:
1260 isl_val_free(v);
1261 return FN(MULTI(BASE),free)(multi);
1262 }
1263
1264 /* Divide the elements of "multi" by "v" and return the result.
1265 */
1266 __isl_give MULTI(BASE) *FN(MULTI(BASE),scale_down_val)(
1267 __isl_take MULTI(BASE) *multi, __isl_take isl_val *v)
1268 {
1269 int i;
1270
1271 if (!multi || !v)
1272 goto error;
1273
1274 if (isl_val_is_one(v)) {
1275 isl_val_free(v);
1276 return multi;
1277 }
1278
1279 if (!isl_val_is_rat(v))
1280 isl_die(isl_val_get_ctx(v), isl_error_invalid,
1281 "expecting rational factor", goto error);
1282 if (isl_val_is_zero(v))
1283 isl_die(isl_val_get_ctx(v), isl_error_invalid,
1284 "cannot scale down by zero", goto error);
1285
1286 multi = FN(MULTI(BASE),cow)(multi);
1287 if (!multi)
1288 return NULL;
1289
1290 for (i = 0; i < multi->n; ++i) {
1291 multi->u.p[i] = FN(EL,scale_down_val)(multi->u.p[i],
1292 isl_val_copy(v));
1293 if (!multi->u.p[i])
1294 goto error;
1295 }
1296
1297 isl_val_free(v);
1298 return multi;
1299 error:
1300 isl_val_free(v);
1301 return FN(MULTI(BASE),free)(multi);
1302 }
1303
1304 /* Multiply the elements of "multi" by the corresponding element of "mv"
1305 * and return the result.
1306 */
1307 __isl_give MULTI(BASE) *FN(MULTI(BASE),scale_multi_val)(
1308 __isl_take MULTI(BASE) *multi, __isl_take isl_multi_val *mv)
1309 {
1310 int i;
1311
1312 if (!multi || !mv)
1313 goto error;
1314
1315 if (!isl_space_tuple_is_equal(multi->space, isl_dim_out,
1316 mv->space, isl_dim_set))
1317 isl_die(isl_multi_val_get_ctx(mv), isl_error_invalid,
1318 "spaces don't match", goto error);
1319
1320 multi = FN(MULTI(BASE),cow)(multi);
1321 if (!multi)
1322 goto error;
1323
1324 for (i = 0; i < multi->n; ++i) {
1325 isl_val *v;
1326
1327 v = isl_multi_val_get_val(mv, i);
1328 multi->u.p[i] = FN(EL,scale_val)(multi->u.p[i], v);
1329 if (!multi->u.p[i])
1330 goto error;
1331 }
1332
1333 isl_multi_val_free(mv);
1334 return multi;
1335 error:
1336 isl_multi_val_free(mv);
1337 return FN(MULTI(BASE),free)(multi);
1338 }
1339
1340 /* Divide the elements of "multi" by the corresponding element of "mv"
1341 * and return the result.
1342 */
1343 __isl_give MULTI(BASE) *FN(MULTI(BASE),scale_down_multi_val)(
1344 __isl_take MULTI(BASE) *multi, __isl_take isl_multi_val *mv)
1345 {
1346 int i;
1347
1348 if (!multi || !mv)
1349 goto error;
1350
1351 if (!isl_space_tuple_is_equal(multi->space, isl_dim_out,
1352 mv->space, isl_dim_set))
1353 isl_die(isl_multi_val_get_ctx(mv), isl_error_invalid,
1354 "spaces don't match", goto error);
1355
1356 multi = FN(MULTI(BASE),cow)(multi);
1357 if (!multi)
1358 return NULL;
1359
1360 for (i = 0; i < multi->n; ++i) {
1361 isl_val *v;
1362
1363 v = isl_multi_val_get_val(mv, i);
1364 multi->u.p[i] = FN(EL,scale_down_val)(multi->u.p[i], v);
1365 if (!multi->u.p[i])
1366 goto error;
1367 }
1368
1369 isl_multi_val_free(mv);
1370 return multi;
1371 error:
1372 isl_multi_val_free(mv);
1373 return FN(MULTI(BASE),free)(multi);
1374 }
1375
1376 /* Compute the residues of the elements of "multi" modulo
1377 * the corresponding element of "mv" and return the result.
1378 */
1379 __isl_give MULTI(BASE) *FN(MULTI(BASE),mod_multi_val)(
1380 __isl_take MULTI(BASE) *multi, __isl_take isl_multi_val *mv)
1381 {
1382 int i;
1383
1384 if (!multi || !mv)
1385 goto error;
1386
1387 if (!isl_space_tuple_is_equal(multi->space, isl_dim_out,
1388 mv->space, isl_dim_set))
1389 isl_die(isl_multi_val_get_ctx(mv), isl_error_invalid,
1390 "spaces don't match", goto error);
1391
1392 multi = FN(MULTI(BASE),cow)(multi);
1393 if (!multi)
1394 goto error;
1395
1396 for (i = 0; i < multi->n; ++i) {
1397 isl_val *v;
1398
1399 v = isl_multi_val_get_val(mv, i);
1400 multi->u.p[i] = FN(EL,mod_val)(multi->u.p[i], v);
1401 if (!multi->u.p[i])
1402 goto error;
1403 }
1404
1405 isl_multi_val_free(mv);
1406 return multi;
1407 error:
1408 isl_multi_val_free(mv);
1409 return FN(MULTI(BASE),free)(multi);
1410 }
1411
1412 #ifndef NO_MOVE_DIMS
1413 /* Move the "n" dimensions of "src_type" starting at "src_pos" of "multi"
1414 * to dimensions of "dst_type" at "dst_pos".
1415 *
1416 * We only support moving input dimensions to parameters and vice versa.
1417 */
1418 __isl_give MULTI(BASE) *FN(MULTI(BASE),move_dims)(__isl_take MULTI(BASE) *multi,
1419 enum isl_dim_type dst_type, unsigned dst_pos,
1420 enum isl_dim_type src_type, unsigned src_pos, unsigned n)
1421 {
1422 int i;
1423
1424 if (!multi)
1425 return NULL;
1426
1427 if (n == 0 &&
1428 !isl_space_is_named_or_nested(multi->space, src_type) &&
1429 !isl_space_is_named_or_nested(multi->space, dst_type))
1430 return multi;
1431
1432 if (dst_type == isl_dim_out || src_type == isl_dim_out)
1433 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
1434 "cannot move output/set dimension",
1435 return FN(MULTI(BASE),free)(multi));
1436 if (dst_type == isl_dim_div || src_type == isl_dim_div)
1437 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
1438 "cannot move divs",
1439 return FN(MULTI(BASE),free)(multi));
1440 if (src_pos + n > isl_space_dim(multi->space, src_type))
1441 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
1442 "range out of bounds",
1443 return FN(MULTI(BASE),free)(multi));
1444 if (dst_type == src_type)
1445 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_unsupported,
1446 "moving dims within the same type not supported",
1447 return FN(MULTI(BASE),free)(multi));
1448
1449 multi = FN(MULTI(BASE),cow)(multi);
1450 if (!multi)
1451 return NULL;
1452
1453 multi->space = isl_space_move_dims(multi->space, dst_type, dst_pos,
1454 src_type, src_pos, n);
1455 if (!multi->space)
1456 return FN(MULTI(BASE),free)(multi);
1457 if (FN(MULTI(BASE),has_explicit_domain)(multi))
1458 multi = FN(MULTI(BASE),move_explicit_domain_dims)(multi,
1459 dst_type, dst_pos, src_type, src_pos, n);
1460 if (!multi)
1461 return NULL;
1462
1463 for (i = 0; i < multi->n; ++i) {
1464 multi->u.p[i] = FN(EL,move_dims)(multi->u.p[i],
1465 dst_type, dst_pos,
1466 src_type, src_pos, n);
1467 if (!multi->u.p[i])
1468 return FN(MULTI(BASE),free)(multi);
1469 }
1470
1471 return multi;
1472 }
1473 #endif
1474
1475 /* Convert a multiple expression defined over a parameter domain
1476 * into one that is defined over a zero-dimensional set.
1477 */
1478 __isl_give MULTI(BASE) *FN(MULTI(BASE),from_range)(
1479 __isl_take MULTI(BASE) *multi)
1480 {
1481 isl_space *space;
1482
1483 if (!multi)
1484 return NULL;
1485 if (!isl_space_is_set(multi->space))
1486 isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
1487 "not living in a set space",
1488 return FN(MULTI(BASE),free)(multi));
1489
1490 space = FN(MULTI(BASE),get_space)(multi);
1491 space = isl_space_from_range(space);
1492 multi = FN(MULTI(BASE),reset_space)(multi, space);
1493
1494 return multi;
1495 }
1496
1497 /* Are "multi1" and "multi2" obviously equal?
1498 */
1499 isl_bool FN(MULTI(BASE),plain_is_equal)(__isl_keep MULTI(BASE) *multi1,
1500 __isl_keep MULTI(BASE) *multi2)
1501 {
1502 int i;
1503 isl_bool equal;
1504
1505 if (!multi1 || !multi2)
1506 return isl_bool_error;
1507 if (multi1->n != multi2->n)
1508 return isl_bool_false;
1509 equal = isl_space_is_equal(multi1->space, multi2->space);
1510 if (equal < 0 || !equal)
1511 return equal;
1512
1513 for (i = 0; i < multi1->n; ++i) {
1514 equal = FN(EL,plain_is_equal)(multi1->u.p[i], multi2->u.p[i]);
1515 if (equal < 0 || !equal)
1516 return equal;
1517 }
1518
1519 if (FN(MULTI(BASE),has_explicit_domain)(multi1) ||
1520 FN(MULTI(BASE),has_explicit_domain)(multi2)) {
1521 equal = FN(MULTI(BASE),equal_explicit_domain)(multi1, multi2);
1522 if (equal < 0 || !equal)
1523 return equal;
1524 }
1525
1526 return isl_bool_true;
1527 }
1528
1529 /* Does "multi" involve any NaNs?
1530 */
1531 isl_bool FN(MULTI(BASE),involves_nan)(__isl_keep MULTI(BASE) *multi)
1532 {
1533 int i;
1534
1535 if (!multi)
1536 return isl_bool_error;
1537 if (multi->n == 0)
1538 return isl_bool_false;
1539
1540 for (i = 0; i < multi->n; ++i) {
1541 isl_bool has_nan = FN(EL,involves_nan)(multi->u.p[i]);
1542 if (has_nan < 0 || has_nan)
1543 return has_nan;
1544 }
1545
1546 return isl_bool_false;
1547 }
1548
1549 #ifndef NO_DOMAIN
1550 /* Return the shared domain of the elements of "multi".
1551 *
1552 * If "multi" has an explicit domain, then return this domain.
1553 */
1554 __isl_give isl_set *FN(MULTI(BASE),domain)(__isl_take MULTI(BASE) *multi)
1555 {
1556 int i;
1557 isl_set *dom;
1558
1559 if (!multi)
1560 return NULL;
1561
1562 if (FN(MULTI(BASE),has_explicit_domain)(multi)) {
1563 dom = FN(MULTI(BASE),get_explicit_domain)(multi);
1564 FN(MULTI(BASE),free)(multi);
1565 return dom;
1566 }
1567
1568 dom = isl_set_universe(FN(MULTI(BASE),get_domain_space)(multi));
1569 for (i = 0; i < multi->n; ++i) {
1570 isl_set *dom_i;
1571
1572 dom_i = FN(EL,domain)(FN(FN(MULTI(BASE),get),BASE)(multi, i));
1573 dom = isl_set_intersect(dom, dom_i);
1574 }
1575
1576 FN(MULTI(BASE),free)(multi);
1577 return dom;
1578 }
1579 #endif
1580
1581 #ifndef NO_NEG
1582 /* Return the opposite of "multi".
1583 */
1584 __isl_give MULTI(BASE) *FN(MULTI(BASE),neg)(__isl_take MULTI(BASE) *multi)
1585 {
1586 int i;
1587
1588 multi = FN(MULTI(BASE),cow)(multi);
1589 if (!multi)
1590 return NULL;
1591
1592 for (i = 0; i < multi->n; ++i) {
1593 multi->u.p[i] = FN(EL,neg)(multi->u.p[i]);
1594 if (!multi->u.p[i])
1595 return FN(MULTI(BASE),free)(multi);
1596 }
1597
1598 return multi;
1599 }
1600 #endif