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