2 * Copyright 2011 INRIA Saclay
3 * Copyright 2011 Sven Verdoolaege
4 * Copyright 2012 Ecole Normale Superieure
6 * Use of this software is governed by the GNU LGPLv2.1 license
8 * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
9 * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
11 * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
14 #include <isl_ctx_private.h>
16 #include <isl_map_private.h>
17 #include <isl_union_map_private.h>
18 #include <isl_aff_private.h>
19 #include <isl_space_private.h>
20 #include <isl_local_space_private.h>
21 #include <isl_mat_private.h>
22 #include <isl_list_private.h>
23 #include <isl/constraint.h>
26 #include <isl_config.h>
28 __isl_give isl_aff
*isl_aff_alloc_vec(__isl_take isl_local_space
*ls
,
29 __isl_take isl_vec
*v
)
36 aff
= isl_calloc_type(v
->ctx
, struct isl_aff
);
46 isl_local_space_free(ls
);
51 __isl_give isl_aff
*isl_aff_alloc(__isl_take isl_local_space
*ls
)
60 ctx
= isl_local_space_get_ctx(ls
);
61 if (!isl_local_space_divs_known(ls
))
62 isl_die(ctx
, isl_error_invalid
, "local space has unknown divs",
64 if (!isl_local_space_is_set(ls
))
65 isl_die(ctx
, isl_error_invalid
,
66 "domain of affine expression should be a set",
69 total
= isl_local_space_dim(ls
, isl_dim_all
);
70 v
= isl_vec_alloc(ctx
, 1 + 1 + total
);
71 return isl_aff_alloc_vec(ls
, v
);
73 isl_local_space_free(ls
);
77 __isl_give isl_aff
*isl_aff_zero_on_domain(__isl_take isl_local_space
*ls
)
81 aff
= isl_aff_alloc(ls
);
85 isl_int_set_si(aff
->v
->el
[0], 1);
86 isl_seq_clr(aff
->v
->el
+ 1, aff
->v
->size
- 1);
91 __isl_give isl_aff
*isl_aff_copy(__isl_keep isl_aff
*aff
)
100 __isl_give isl_aff
*isl_aff_dup(__isl_keep isl_aff
*aff
)
105 return isl_aff_alloc_vec(isl_local_space_copy(aff
->ls
),
106 isl_vec_copy(aff
->v
));
109 __isl_give isl_aff
*isl_aff_cow(__isl_take isl_aff
*aff
)
117 return isl_aff_dup(aff
);
120 void *isl_aff_free(__isl_take isl_aff
*aff
)
128 isl_local_space_free(aff
->ls
);
129 isl_vec_free(aff
->v
);
136 isl_ctx
*isl_aff_get_ctx(__isl_keep isl_aff
*aff
)
138 return aff
? isl_local_space_get_ctx(aff
->ls
) : NULL
;
141 /* Externally, an isl_aff has a map space, but internally, the
142 * ls field corresponds to the domain of that space.
144 int isl_aff_dim(__isl_keep isl_aff
*aff
, enum isl_dim_type type
)
148 if (type
== isl_dim_out
)
150 if (type
== isl_dim_in
)
152 return isl_local_space_dim(aff
->ls
, type
);
155 __isl_give isl_space
*isl_aff_get_domain_space(__isl_keep isl_aff
*aff
)
157 return aff
? isl_local_space_get_space(aff
->ls
) : NULL
;
160 __isl_give isl_space
*isl_aff_get_space(__isl_keep isl_aff
*aff
)
165 space
= isl_local_space_get_space(aff
->ls
);
166 space
= isl_space_from_domain(space
);
167 space
= isl_space_add_dims(space
, isl_dim_out
, 1);
171 __isl_give isl_local_space
*isl_aff_get_domain_local_space(
172 __isl_keep isl_aff
*aff
)
174 return aff
? isl_local_space_copy(aff
->ls
) : NULL
;
177 __isl_give isl_local_space
*isl_aff_get_local_space(__isl_keep isl_aff
*aff
)
182 ls
= isl_local_space_copy(aff
->ls
);
183 ls
= isl_local_space_from_domain(ls
);
184 ls
= isl_local_space_add_dims(ls
, isl_dim_out
, 1);
188 /* Externally, an isl_aff has a map space, but internally, the
189 * ls field corresponds to the domain of that space.
191 const char *isl_aff_get_dim_name(__isl_keep isl_aff
*aff
,
192 enum isl_dim_type type
, unsigned pos
)
196 if (type
== isl_dim_out
)
198 if (type
== isl_dim_in
)
200 return isl_local_space_get_dim_name(aff
->ls
, type
, pos
);
203 __isl_give isl_aff
*isl_aff_reset_domain_space(__isl_take isl_aff
*aff
,
204 __isl_take isl_space
*dim
)
206 aff
= isl_aff_cow(aff
);
210 aff
->ls
= isl_local_space_reset_space(aff
->ls
, dim
);
212 return isl_aff_free(aff
);
221 /* Reset the space of "aff". This function is called from isl_pw_templ.c
222 * and doesn't know if the space of an element object is represented
223 * directly or through its domain. It therefore passes along both.
225 __isl_give isl_aff
*isl_aff_reset_space_and_domain(__isl_take isl_aff
*aff
,
226 __isl_take isl_space
*space
, __isl_take isl_space
*domain
)
228 isl_space_free(space
);
229 return isl_aff_reset_domain_space(aff
, domain
);
232 /* Reorder the coefficients of the affine expression based
233 * on the given reodering.
234 * The reordering r is assumed to have been extended with the local
237 static __isl_give isl_vec
*vec_reorder(__isl_take isl_vec
*vec
,
238 __isl_take isl_reordering
*r
, int n_div
)
246 res
= isl_vec_alloc(vec
->ctx
,
247 2 + isl_space_dim(r
->dim
, isl_dim_all
) + n_div
);
248 isl_seq_cpy(res
->el
, vec
->el
, 2);
249 isl_seq_clr(res
->el
+ 2, res
->size
- 2);
250 for (i
= 0; i
< r
->len
; ++i
)
251 isl_int_set(res
->el
[2 + r
->pos
[i
]], vec
->el
[2 + i
]);
253 isl_reordering_free(r
);
258 isl_reordering_free(r
);
262 /* Reorder the dimensions of the domain of "aff" according
263 * to the given reordering.
265 __isl_give isl_aff
*isl_aff_realign_domain(__isl_take isl_aff
*aff
,
266 __isl_take isl_reordering
*r
)
268 aff
= isl_aff_cow(aff
);
272 r
= isl_reordering_extend(r
, aff
->ls
->div
->n_row
);
273 aff
->v
= vec_reorder(aff
->v
, isl_reordering_copy(r
),
274 aff
->ls
->div
->n_row
);
275 aff
->ls
= isl_local_space_realign(aff
->ls
, r
);
277 if (!aff
->v
|| !aff
->ls
)
278 return isl_aff_free(aff
);
283 isl_reordering_free(r
);
287 __isl_give isl_aff
*isl_aff_align_params(__isl_take isl_aff
*aff
,
288 __isl_take isl_space
*model
)
293 if (!isl_space_match(aff
->ls
->dim
, isl_dim_param
,
294 model
, isl_dim_param
)) {
297 model
= isl_space_drop_dims(model
, isl_dim_in
,
298 0, isl_space_dim(model
, isl_dim_in
));
299 model
= isl_space_drop_dims(model
, isl_dim_out
,
300 0, isl_space_dim(model
, isl_dim_out
));
301 exp
= isl_parameter_alignment_reordering(aff
->ls
->dim
, model
);
302 exp
= isl_reordering_extend_space(exp
,
303 isl_aff_get_domain_space(aff
));
304 aff
= isl_aff_realign_domain(aff
, exp
);
307 isl_space_free(model
);
310 isl_space_free(model
);
315 int isl_aff_plain_is_zero(__isl_keep isl_aff
*aff
)
320 return isl_seq_first_non_zero(aff
->v
->el
+ 1, aff
->v
->size
- 1) < 0;
323 int isl_aff_plain_is_equal(__isl_keep isl_aff
*aff1
, __isl_keep isl_aff
*aff2
)
330 equal
= isl_local_space_is_equal(aff1
->ls
, aff2
->ls
);
331 if (equal
< 0 || !equal
)
334 return isl_vec_is_equal(aff1
->v
, aff2
->v
);
337 int isl_aff_get_denominator(__isl_keep isl_aff
*aff
, isl_int
*v
)
341 isl_int_set(*v
, aff
->v
->el
[0]);
345 int isl_aff_get_constant(__isl_keep isl_aff
*aff
, isl_int
*v
)
349 isl_int_set(*v
, aff
->v
->el
[1]);
353 int isl_aff_get_coefficient(__isl_keep isl_aff
*aff
,
354 enum isl_dim_type type
, int pos
, isl_int
*v
)
359 if (type
== isl_dim_out
)
360 isl_die(aff
->v
->ctx
, isl_error_invalid
,
361 "output/set dimension does not have a coefficient",
363 if (type
== isl_dim_in
)
366 if (pos
>= isl_local_space_dim(aff
->ls
, type
))
367 isl_die(aff
->v
->ctx
, isl_error_invalid
,
368 "position out of bounds", return -1);
370 pos
+= isl_local_space_offset(aff
->ls
, type
);
371 isl_int_set(*v
, aff
->v
->el
[1 + pos
]);
376 __isl_give isl_aff
*isl_aff_set_denominator(__isl_take isl_aff
*aff
, isl_int v
)
378 aff
= isl_aff_cow(aff
);
382 aff
->v
= isl_vec_cow(aff
->v
);
384 return isl_aff_free(aff
);
386 isl_int_set(aff
->v
->el
[0], v
);
391 __isl_give isl_aff
*isl_aff_set_constant(__isl_take isl_aff
*aff
, isl_int v
)
393 aff
= isl_aff_cow(aff
);
397 aff
->v
= isl_vec_cow(aff
->v
);
399 return isl_aff_free(aff
);
401 isl_int_set(aff
->v
->el
[1], v
);
406 __isl_give isl_aff
*isl_aff_add_constant(__isl_take isl_aff
*aff
, isl_int v
)
408 if (isl_int_is_zero(v
))
411 aff
= isl_aff_cow(aff
);
415 aff
->v
= isl_vec_cow(aff
->v
);
417 return isl_aff_free(aff
);
419 isl_int_addmul(aff
->v
->el
[1], aff
->v
->el
[0], v
);
424 __isl_give isl_aff
*isl_aff_add_constant_si(__isl_take isl_aff
*aff
, int v
)
429 isl_int_set_si(t
, v
);
430 aff
= isl_aff_add_constant(aff
, t
);
436 __isl_give isl_aff
*isl_aff_set_constant_si(__isl_take isl_aff
*aff
, int v
)
438 aff
= isl_aff_cow(aff
);
442 aff
->v
= isl_vec_cow(aff
->v
);
444 return isl_aff_free(aff
);
446 isl_int_set_si(aff
->v
->el
[1], v
);
451 __isl_give isl_aff
*isl_aff_set_coefficient(__isl_take isl_aff
*aff
,
452 enum isl_dim_type type
, int pos
, isl_int v
)
457 if (type
== isl_dim_out
)
458 isl_die(aff
->v
->ctx
, isl_error_invalid
,
459 "output/set dimension does not have a coefficient",
460 return isl_aff_free(aff
));
461 if (type
== isl_dim_in
)
464 if (pos
>= isl_local_space_dim(aff
->ls
, type
))
465 isl_die(aff
->v
->ctx
, isl_error_invalid
,
466 "position out of bounds", return isl_aff_free(aff
));
468 aff
= isl_aff_cow(aff
);
472 aff
->v
= isl_vec_cow(aff
->v
);
474 return isl_aff_free(aff
);
476 pos
+= isl_local_space_offset(aff
->ls
, type
);
477 isl_int_set(aff
->v
->el
[1 + pos
], v
);
482 __isl_give isl_aff
*isl_aff_set_coefficient_si(__isl_take isl_aff
*aff
,
483 enum isl_dim_type type
, int pos
, int v
)
488 if (type
== isl_dim_out
)
489 isl_die(aff
->v
->ctx
, isl_error_invalid
,
490 "output/set dimension does not have a coefficient",
491 return isl_aff_free(aff
));
492 if (type
== isl_dim_in
)
495 if (pos
>= isl_local_space_dim(aff
->ls
, type
))
496 isl_die(aff
->v
->ctx
, isl_error_invalid
,
497 "position out of bounds", return isl_aff_free(aff
));
499 aff
= isl_aff_cow(aff
);
503 aff
->v
= isl_vec_cow(aff
->v
);
505 return isl_aff_free(aff
);
507 pos
+= isl_local_space_offset(aff
->ls
, type
);
508 isl_int_set_si(aff
->v
->el
[1 + pos
], v
);
513 __isl_give isl_aff
*isl_aff_add_coefficient(__isl_take isl_aff
*aff
,
514 enum isl_dim_type type
, int pos
, isl_int v
)
519 if (type
== isl_dim_out
)
520 isl_die(aff
->v
->ctx
, isl_error_invalid
,
521 "output/set dimension does not have a coefficient",
522 return isl_aff_free(aff
));
523 if (type
== isl_dim_in
)
526 if (pos
>= isl_local_space_dim(aff
->ls
, type
))
527 isl_die(aff
->v
->ctx
, isl_error_invalid
,
528 "position out of bounds", return isl_aff_free(aff
));
530 aff
= isl_aff_cow(aff
);
534 aff
->v
= isl_vec_cow(aff
->v
);
536 return isl_aff_free(aff
);
538 pos
+= isl_local_space_offset(aff
->ls
, type
);
539 isl_int_addmul(aff
->v
->el
[1 + pos
], aff
->v
->el
[0], v
);
544 __isl_give isl_aff
*isl_aff_add_coefficient_si(__isl_take isl_aff
*aff
,
545 enum isl_dim_type type
, int pos
, int v
)
550 isl_int_set_si(t
, v
);
551 aff
= isl_aff_add_coefficient(aff
, type
, pos
, t
);
557 __isl_give isl_aff
*isl_aff_get_div(__isl_keep isl_aff
*aff
, int pos
)
562 return isl_local_space_get_div(aff
->ls
, pos
);
565 __isl_give isl_aff
*isl_aff_neg(__isl_take isl_aff
*aff
)
567 aff
= isl_aff_cow(aff
);
570 aff
->v
= isl_vec_cow(aff
->v
);
572 return isl_aff_free(aff
);
574 isl_seq_neg(aff
->v
->el
+ 1, aff
->v
->el
+ 1, aff
->v
->size
- 1);
579 /* Remove divs from the local space that do not appear in the affine
581 * We currently only remove divs at the end.
582 * Some intermediate divs may also not appear directly in the affine
583 * expression, but we would also need to check that no other divs are
584 * defined in terms of them.
586 __isl_give isl_aff
*isl_aff_remove_unused_divs( __isl_take isl_aff
*aff
)
595 n
= isl_local_space_dim(aff
->ls
, isl_dim_div
);
596 off
= isl_local_space_offset(aff
->ls
, isl_dim_div
);
598 pos
= isl_seq_last_non_zero(aff
->v
->el
+ 1 + off
, n
) + 1;
602 aff
= isl_aff_cow(aff
);
606 aff
->ls
= isl_local_space_drop_dims(aff
->ls
, isl_dim_div
, pos
, n
- pos
);
607 aff
->v
= isl_vec_drop_els(aff
->v
, 1 + off
+ pos
, n
- pos
);
608 if (!aff
->ls
|| !aff
->v
)
609 return isl_aff_free(aff
);
614 __isl_give isl_aff
*isl_aff_normalize(__isl_take isl_aff
*aff
)
618 aff
->v
= isl_vec_normalize(aff
->v
);
620 return isl_aff_free(aff
);
621 aff
= isl_aff_remove_unused_divs(aff
);
625 /* Given f, return floor(f).
626 * If f is an integer expression, then just return f.
627 * If f is a constant, then return the constant floor(f).
628 * Otherwise, if f = g/m, write g = q m + r,
629 * create a new div d = [r/m] and return the expression q + d.
630 * The coefficients in r are taken to lie between -m/2 and m/2.
632 __isl_give isl_aff
*isl_aff_floor(__isl_take isl_aff
*aff
)
642 if (isl_int_is_one(aff
->v
->el
[0]))
645 aff
= isl_aff_cow(aff
);
649 aff
->v
= isl_vec_cow(aff
->v
);
651 return isl_aff_free(aff
);
653 if (isl_aff_is_cst(aff
)) {
654 isl_int_fdiv_q(aff
->v
->el
[1], aff
->v
->el
[1], aff
->v
->el
[0]);
655 isl_int_set_si(aff
->v
->el
[0], 1);
659 div
= isl_vec_copy(aff
->v
);
660 div
= isl_vec_cow(div
);
662 return isl_aff_free(aff
);
664 ctx
= isl_aff_get_ctx(aff
);
665 isl_int_fdiv_q(aff
->v
->el
[0], aff
->v
->el
[0], ctx
->two
);
666 for (i
= 1; i
< aff
->v
->size
; ++i
) {
667 isl_int_fdiv_r(div
->el
[i
], div
->el
[i
], div
->el
[0]);
668 isl_int_fdiv_q(aff
->v
->el
[i
], aff
->v
->el
[i
], div
->el
[0]);
669 if (isl_int_gt(div
->el
[i
], aff
->v
->el
[0])) {
670 isl_int_sub(div
->el
[i
], div
->el
[i
], div
->el
[0]);
671 isl_int_add_ui(aff
->v
->el
[i
], aff
->v
->el
[i
], 1);
675 aff
->ls
= isl_local_space_add_div(aff
->ls
, div
);
677 return isl_aff_free(aff
);
680 aff
->v
= isl_vec_extend(aff
->v
, size
+ 1);
682 return isl_aff_free(aff
);
683 isl_int_set_si(aff
->v
->el
[0], 1);
684 isl_int_set_si(aff
->v
->el
[size
], 1);
691 * aff mod m = aff - m * floor(aff/m)
693 __isl_give isl_aff
*isl_aff_mod(__isl_take isl_aff
*aff
, isl_int m
)
697 res
= isl_aff_copy(aff
);
698 aff
= isl_aff_scale_down(aff
, m
);
699 aff
= isl_aff_floor(aff
);
700 aff
= isl_aff_scale(aff
, m
);
701 res
= isl_aff_sub(res
, aff
);
708 * pwaff mod m = pwaff - m * floor(pwaff/m)
710 __isl_give isl_pw_aff
*isl_pw_aff_mod(__isl_take isl_pw_aff
*pwaff
, isl_int m
)
714 res
= isl_pw_aff_copy(pwaff
);
715 pwaff
= isl_pw_aff_scale_down(pwaff
, m
);
716 pwaff
= isl_pw_aff_floor(pwaff
);
717 pwaff
= isl_pw_aff_scale(pwaff
, m
);
718 res
= isl_pw_aff_sub(res
, pwaff
);
723 /* Given f, return ceil(f).
724 * If f is an integer expression, then just return f.
725 * Otherwise, create a new div d = [-f] and return the expression -d.
727 __isl_give isl_aff
*isl_aff_ceil(__isl_take isl_aff
*aff
)
732 if (isl_int_is_one(aff
->v
->el
[0]))
735 aff
= isl_aff_neg(aff
);
736 aff
= isl_aff_floor(aff
);
737 aff
= isl_aff_neg(aff
);
742 /* Apply the expansion computed by isl_merge_divs.
743 * The expansion itself is given by "exp" while the resulting
744 * list of divs is given by "div".
746 __isl_give isl_aff
*isl_aff_expand_divs( __isl_take isl_aff
*aff
,
747 __isl_take isl_mat
*div
, int *exp
)
754 aff
= isl_aff_cow(aff
);
758 old_n_div
= isl_local_space_dim(aff
->ls
, isl_dim_div
);
759 new_n_div
= isl_mat_rows(div
);
760 if (new_n_div
< old_n_div
)
761 isl_die(isl_mat_get_ctx(div
), isl_error_invalid
,
762 "not an expansion", goto error
);
764 aff
->v
= isl_vec_extend(aff
->v
, aff
->v
->size
+ new_n_div
- old_n_div
);
768 offset
= 1 + isl_local_space_offset(aff
->ls
, isl_dim_div
);
770 for (i
= new_n_div
- 1; i
>= 0; --i
) {
771 if (j
>= 0 && exp
[j
] == i
) {
773 isl_int_swap(aff
->v
->el
[offset
+ i
],
774 aff
->v
->el
[offset
+ j
]);
777 isl_int_set_si(aff
->v
->el
[offset
+ i
], 0);
780 aff
->ls
= isl_local_space_replace_divs(aff
->ls
, isl_mat_copy(div
));
791 /* Add two affine expressions that live in the same local space.
793 static __isl_give isl_aff
*add_expanded(__isl_take isl_aff
*aff1
,
794 __isl_take isl_aff
*aff2
)
798 aff1
= isl_aff_cow(aff1
);
802 aff1
->v
= isl_vec_cow(aff1
->v
);
808 isl_int_gcd(gcd
, aff1
->v
->el
[0], aff2
->v
->el
[0]);
809 isl_int_divexact(f
, aff2
->v
->el
[0], gcd
);
810 isl_seq_scale(aff1
->v
->el
+ 1, aff1
->v
->el
+ 1, f
, aff1
->v
->size
- 1);
811 isl_int_divexact(f
, aff1
->v
->el
[0], gcd
);
812 isl_seq_addmul(aff1
->v
->el
+ 1, f
, aff2
->v
->el
+ 1, aff1
->v
->size
- 1);
813 isl_int_divexact(f
, aff2
->v
->el
[0], gcd
);
814 isl_int_mul(aff1
->v
->el
[0], aff1
->v
->el
[0], f
);
826 __isl_give isl_aff
*isl_aff_add(__isl_take isl_aff
*aff1
,
827 __isl_take isl_aff
*aff2
)
837 ctx
= isl_aff_get_ctx(aff1
);
838 if (!isl_space_is_equal(aff1
->ls
->dim
, aff2
->ls
->dim
))
839 isl_die(ctx
, isl_error_invalid
,
840 "spaces don't match", goto error
);
842 if (aff1
->ls
->div
->n_row
== 0 && aff2
->ls
->div
->n_row
== 0)
843 return add_expanded(aff1
, aff2
);
845 exp1
= isl_alloc_array(ctx
, int, aff1
->ls
->div
->n_row
);
846 exp2
= isl_alloc_array(ctx
, int, aff2
->ls
->div
->n_row
);
850 div
= isl_merge_divs(aff1
->ls
->div
, aff2
->ls
->div
, exp1
, exp2
);
851 aff1
= isl_aff_expand_divs(aff1
, isl_mat_copy(div
), exp1
);
852 aff2
= isl_aff_expand_divs(aff2
, div
, exp2
);
856 return add_expanded(aff1
, aff2
);
865 __isl_give isl_aff
*isl_aff_sub(__isl_take isl_aff
*aff1
,
866 __isl_take isl_aff
*aff2
)
868 return isl_aff_add(aff1
, isl_aff_neg(aff2
));
871 __isl_give isl_aff
*isl_aff_scale(__isl_take isl_aff
*aff
, isl_int f
)
875 if (isl_int_is_one(f
))
878 aff
= isl_aff_cow(aff
);
881 aff
->v
= isl_vec_cow(aff
->v
);
883 return isl_aff_free(aff
);
886 isl_int_gcd(gcd
, aff
->v
->el
[0], f
);
887 isl_int_divexact(aff
->v
->el
[0], aff
->v
->el
[0], gcd
);
888 isl_int_divexact(gcd
, f
, gcd
);
889 isl_seq_scale(aff
->v
->el
+ 1, aff
->v
->el
+ 1, gcd
, aff
->v
->size
- 1);
895 __isl_give isl_aff
*isl_aff_scale_down(__isl_take isl_aff
*aff
, isl_int f
)
899 if (isl_int_is_one(f
))
902 aff
= isl_aff_cow(aff
);
905 aff
->v
= isl_vec_cow(aff
->v
);
907 return isl_aff_free(aff
);
910 isl_seq_gcd(aff
->v
->el
+ 1, aff
->v
->size
- 1, &gcd
);
911 isl_int_gcd(gcd
, gcd
, f
);
912 isl_seq_scale_down(aff
->v
->el
+ 1, aff
->v
->el
+ 1, gcd
, aff
->v
->size
- 1);
913 isl_int_divexact(gcd
, f
, gcd
);
914 isl_int_mul(aff
->v
->el
[0], aff
->v
->el
[0], gcd
);
920 __isl_give isl_aff
*isl_aff_scale_down_ui(__isl_take isl_aff
*aff
, unsigned f
)
928 isl_int_set_ui(v
, f
);
929 aff
= isl_aff_scale_down(aff
, v
);
935 __isl_give isl_aff
*isl_aff_set_dim_name(__isl_take isl_aff
*aff
,
936 enum isl_dim_type type
, unsigned pos
, const char *s
)
938 aff
= isl_aff_cow(aff
);
941 if (type
== isl_dim_out
)
942 isl_die(aff
->v
->ctx
, isl_error_invalid
,
943 "cannot set name of output/set dimension",
944 return isl_aff_free(aff
));
945 if (type
== isl_dim_in
)
947 aff
->ls
= isl_local_space_set_dim_name(aff
->ls
, type
, pos
, s
);
949 return isl_aff_free(aff
);
954 __isl_give isl_aff
*isl_aff_set_dim_id(__isl_take isl_aff
*aff
,
955 enum isl_dim_type type
, unsigned pos
, __isl_take isl_id
*id
)
957 aff
= isl_aff_cow(aff
);
959 return isl_id_free(id
);
960 if (type
== isl_dim_out
)
961 isl_die(aff
->v
->ctx
, isl_error_invalid
,
962 "cannot set name of output/set dimension",
964 if (type
== isl_dim_in
)
966 aff
->ls
= isl_local_space_set_dim_id(aff
->ls
, type
, pos
, id
);
968 return isl_aff_free(aff
);
977 /* Exploit the equalities in "eq" to simplify the affine expression
978 * and the expressions of the integer divisions in the local space.
979 * The integer divisions in this local space are assumed to appear
980 * as regular dimensions in "eq".
982 static __isl_give isl_aff
*isl_aff_substitute_equalities_lifted(
983 __isl_take isl_aff
*aff
, __isl_take isl_basic_set
*eq
)
992 isl_basic_set_free(eq
);
996 aff
= isl_aff_cow(aff
);
1000 aff
->ls
= isl_local_space_substitute_equalities(aff
->ls
,
1001 isl_basic_set_copy(eq
));
1005 total
= 1 + isl_space_dim(eq
->dim
, isl_dim_all
);
1007 for (i
= 0; i
< eq
->n_eq
; ++i
) {
1008 j
= isl_seq_last_non_zero(eq
->eq
[i
], total
+ n_div
);
1009 if (j
< 0 || j
== 0 || j
>= total
)
1012 isl_seq_elim(aff
->v
->el
+ 1, eq
->eq
[i
], j
, total
,
1016 isl_basic_set_free(eq
);
1017 aff
= isl_aff_normalize(aff
);
1020 isl_basic_set_free(eq
);
1025 /* Exploit the equalities in "eq" to simplify the affine expression
1026 * and the expressions of the integer divisions in the local space.
1028 static __isl_give isl_aff
*isl_aff_substitute_equalities(
1029 __isl_take isl_aff
*aff
, __isl_take isl_basic_set
*eq
)
1035 n_div
= isl_local_space_dim(aff
->ls
, isl_dim_div
);
1037 eq
= isl_basic_set_add(eq
, isl_dim_set
, n_div
);
1038 return isl_aff_substitute_equalities_lifted(aff
, eq
);
1040 isl_basic_set_free(eq
);
1045 /* Look for equalities among the variables shared by context and aff
1046 * and the integer divisions of aff, if any.
1047 * The equalities are then used to eliminate coefficients and/or integer
1048 * divisions from aff.
1050 __isl_give isl_aff
*isl_aff_gist(__isl_take isl_aff
*aff
,
1051 __isl_take isl_set
*context
)
1053 isl_basic_set
*hull
;
1058 n_div
= isl_local_space_dim(aff
->ls
, isl_dim_div
);
1060 isl_basic_set
*bset
;
1061 isl_local_space
*ls
;
1062 context
= isl_set_add_dims(context
, isl_dim_set
, n_div
);
1063 ls
= isl_aff_get_domain_local_space(aff
);
1064 bset
= isl_basic_set_from_local_space(ls
);
1065 bset
= isl_basic_set_lift(bset
);
1066 bset
= isl_basic_set_flatten(bset
);
1067 context
= isl_set_intersect(context
,
1068 isl_set_from_basic_set(bset
));
1071 hull
= isl_set_affine_hull(context
);
1072 return isl_aff_substitute_equalities_lifted(aff
, hull
);
1075 isl_set_free(context
);
1079 __isl_give isl_aff
*isl_aff_gist_params(__isl_take isl_aff
*aff
,
1080 __isl_take isl_set
*context
)
1082 isl_set
*dom_context
= isl_set_universe(isl_aff_get_domain_space(aff
));
1083 dom_context
= isl_set_intersect_params(dom_context
, context
);
1084 return isl_aff_gist(aff
, dom_context
);
1087 /* Return a basic set containing those elements in the space
1088 * of aff where it is non-negative.
1090 __isl_give isl_basic_set
*isl_aff_nonneg_basic_set(__isl_take isl_aff
*aff
)
1092 isl_constraint
*ineq
;
1093 isl_basic_set
*bset
;
1095 ineq
= isl_inequality_from_aff(aff
);
1097 bset
= isl_basic_set_from_constraint(ineq
);
1098 bset
= isl_basic_set_simplify(bset
);
1102 /* Return a basic set containing those elements in the space
1103 * of aff where it is zero.
1105 __isl_give isl_basic_set
*isl_aff_zero_basic_set(__isl_take isl_aff
*aff
)
1107 isl_constraint
*ineq
;
1108 isl_basic_set
*bset
;
1110 ineq
= isl_equality_from_aff(aff
);
1112 bset
= isl_basic_set_from_constraint(ineq
);
1113 bset
= isl_basic_set_simplify(bset
);
1117 /* Return a basic set containing those elements in the shared space
1118 * of aff1 and aff2 where aff1 is greater than or equal to aff2.
1120 __isl_give isl_basic_set
*isl_aff_ge_basic_set(__isl_take isl_aff
*aff1
,
1121 __isl_take isl_aff
*aff2
)
1123 aff1
= isl_aff_sub(aff1
, aff2
);
1125 return isl_aff_nonneg_basic_set(aff1
);
1128 /* Return a basic set containing those elements in the shared space
1129 * of aff1 and aff2 where aff1 is smaller than or equal to aff2.
1131 __isl_give isl_basic_set
*isl_aff_le_basic_set(__isl_take isl_aff
*aff1
,
1132 __isl_take isl_aff
*aff2
)
1134 return isl_aff_ge_basic_set(aff2
, aff1
);
1137 __isl_give isl_aff
*isl_aff_add_on_domain(__isl_keep isl_set
*dom
,
1138 __isl_take isl_aff
*aff1
, __isl_take isl_aff
*aff2
)
1140 aff1
= isl_aff_add(aff1
, aff2
);
1141 aff1
= isl_aff_gist(aff1
, isl_set_copy(dom
));
1145 int isl_aff_is_empty(__isl_keep isl_aff
*aff
)
1153 /* Check whether the given affine expression has non-zero coefficient
1154 * for any dimension in the given range or if any of these dimensions
1155 * appear with non-zero coefficients in any of the integer divisions
1156 * involved in the affine expression.
1158 int isl_aff_involves_dims(__isl_keep isl_aff
*aff
,
1159 enum isl_dim_type type
, unsigned first
, unsigned n
)
1171 ctx
= isl_aff_get_ctx(aff
);
1172 if (first
+ n
> isl_aff_dim(aff
, type
))
1173 isl_die(ctx
, isl_error_invalid
,
1174 "range out of bounds", return -1);
1176 active
= isl_local_space_get_active(aff
->ls
, aff
->v
->el
+ 2);
1180 first
+= isl_local_space_offset(aff
->ls
, type
) - 1;
1181 for (i
= 0; i
< n
; ++i
)
1182 if (active
[first
+ i
]) {
1195 __isl_give isl_aff
*isl_aff_drop_dims(__isl_take isl_aff
*aff
,
1196 enum isl_dim_type type
, unsigned first
, unsigned n
)
1202 if (type
== isl_dim_out
)
1203 isl_die(aff
->v
->ctx
, isl_error_invalid
,
1204 "cannot drop output/set dimension",
1205 return isl_aff_free(aff
));
1206 if (type
== isl_dim_in
)
1208 if (n
== 0 && !isl_local_space_is_named_or_nested(aff
->ls
, type
))
1211 ctx
= isl_aff_get_ctx(aff
);
1212 if (first
+ n
> isl_local_space_dim(aff
->ls
, type
))
1213 isl_die(ctx
, isl_error_invalid
, "range out of bounds",
1214 return isl_aff_free(aff
));
1216 aff
= isl_aff_cow(aff
);
1220 aff
->ls
= isl_local_space_drop_dims(aff
->ls
, type
, first
, n
);
1222 return isl_aff_free(aff
);
1224 first
+= 1 + isl_local_space_offset(aff
->ls
, type
);
1225 aff
->v
= isl_vec_drop_els(aff
->v
, first
, n
);
1227 return isl_aff_free(aff
);
1232 /* Project the domain of the affine expression onto its parameter space.
1233 * The affine expression may not involve any of the domain dimensions.
1235 __isl_give isl_aff
*isl_aff_project_domain_on_params(__isl_take isl_aff
*aff
)
1241 n
= isl_aff_dim(aff
, isl_dim_in
);
1242 involves
= isl_aff_involves_dims(aff
, isl_dim_in
, 0, n
);
1244 return isl_aff_free(aff
);
1246 isl_die(isl_aff_get_ctx(aff
), isl_error_invalid
,
1247 "affine expression involves some of the domain dimensions",
1248 return isl_aff_free(aff
));
1249 aff
= isl_aff_drop_dims(aff
, isl_dim_in
, 0, n
);
1250 space
= isl_aff_get_domain_space(aff
);
1251 space
= isl_space_params(space
);
1252 aff
= isl_aff_reset_domain_space(aff
, space
);
1256 __isl_give isl_aff
*isl_aff_insert_dims(__isl_take isl_aff
*aff
,
1257 enum isl_dim_type type
, unsigned first
, unsigned n
)
1263 if (type
== isl_dim_out
)
1264 isl_die(aff
->v
->ctx
, isl_error_invalid
,
1265 "cannot insert output/set dimensions",
1266 return isl_aff_free(aff
));
1267 if (type
== isl_dim_in
)
1269 if (n
== 0 && !isl_local_space_is_named_or_nested(aff
->ls
, type
))
1272 ctx
= isl_aff_get_ctx(aff
);
1273 if (first
> isl_local_space_dim(aff
->ls
, type
))
1274 isl_die(ctx
, isl_error_invalid
, "position out of bounds",
1275 return isl_aff_free(aff
));
1277 aff
= isl_aff_cow(aff
);
1281 aff
->ls
= isl_local_space_insert_dims(aff
->ls
, type
, first
, n
);
1283 return isl_aff_free(aff
);
1285 first
+= 1 + isl_local_space_offset(aff
->ls
, type
);
1286 aff
->v
= isl_vec_insert_zero_els(aff
->v
, first
, n
);
1288 return isl_aff_free(aff
);
1293 __isl_give isl_aff
*isl_aff_add_dims(__isl_take isl_aff
*aff
,
1294 enum isl_dim_type type
, unsigned n
)
1298 pos
= isl_aff_dim(aff
, type
);
1300 return isl_aff_insert_dims(aff
, type
, pos
, n
);
1303 __isl_give isl_pw_aff
*isl_pw_aff_add_dims(__isl_take isl_pw_aff
*pwaff
,
1304 enum isl_dim_type type
, unsigned n
)
1308 pos
= isl_pw_aff_dim(pwaff
, type
);
1310 return isl_pw_aff_insert_dims(pwaff
, type
, pos
, n
);
1313 __isl_give isl_pw_aff
*isl_pw_aff_from_aff(__isl_take isl_aff
*aff
)
1315 isl_set
*dom
= isl_set_universe(isl_aff_get_domain_space(aff
));
1316 return isl_pw_aff_alloc(dom
, aff
);
1320 #define PW isl_pw_aff
1324 #define EL_IS_ZERO is_empty
1328 #define IS_ZERO is_empty
1331 #undef DEFAULT_IS_ZERO
1332 #define DEFAULT_IS_ZERO 0
1336 #define NO_MOVE_DIMS
1340 #include <isl_pw_templ.c>
1342 static __isl_give isl_set
*align_params_pw_pw_set_and(
1343 __isl_take isl_pw_aff
*pwaff1
, __isl_take isl_pw_aff
*pwaff2
,
1344 __isl_give isl_set
*(*fn
)(__isl_take isl_pw_aff
*pwaff1
,
1345 __isl_take isl_pw_aff
*pwaff2
))
1347 if (!pwaff1
|| !pwaff2
)
1349 if (isl_space_match(pwaff1
->dim
, isl_dim_param
,
1350 pwaff2
->dim
, isl_dim_param
))
1351 return fn(pwaff1
, pwaff2
);
1352 if (!isl_space_has_named_params(pwaff1
->dim
) ||
1353 !isl_space_has_named_params(pwaff2
->dim
))
1354 isl_die(isl_pw_aff_get_ctx(pwaff1
), isl_error_invalid
,
1355 "unaligned unnamed parameters", goto error
);
1356 pwaff1
= isl_pw_aff_align_params(pwaff1
, isl_pw_aff_get_space(pwaff2
));
1357 pwaff2
= isl_pw_aff_align_params(pwaff2
, isl_pw_aff_get_space(pwaff1
));
1358 return fn(pwaff1
, pwaff2
);
1360 isl_pw_aff_free(pwaff1
);
1361 isl_pw_aff_free(pwaff2
);
1365 /* Compute a piecewise quasi-affine expression with a domain that
1366 * is the union of those of pwaff1 and pwaff2 and such that on each
1367 * cell, the quasi-affine expression is the better (according to cmp)
1368 * of those of pwaff1 and pwaff2. If only one of pwaff1 or pwaff2
1369 * is defined on a given cell, then the associated expression
1370 * is the defined one.
1372 static __isl_give isl_pw_aff
*pw_aff_union_opt(__isl_take isl_pw_aff
*pwaff1
,
1373 __isl_take isl_pw_aff
*pwaff2
,
1374 __isl_give isl_basic_set
*(*cmp
)(__isl_take isl_aff
*aff1
,
1375 __isl_take isl_aff
*aff2
))
1382 if (!pwaff1
|| !pwaff2
)
1385 ctx
= isl_space_get_ctx(pwaff1
->dim
);
1386 if (!isl_space_is_equal(pwaff1
->dim
, pwaff2
->dim
))
1387 isl_die(ctx
, isl_error_invalid
,
1388 "arguments should live in same space", goto error
);
1390 if (isl_pw_aff_is_empty(pwaff1
)) {
1391 isl_pw_aff_free(pwaff1
);
1395 if (isl_pw_aff_is_empty(pwaff2
)) {
1396 isl_pw_aff_free(pwaff2
);
1400 n
= 2 * (pwaff1
->n
+ 1) * (pwaff2
->n
+ 1);
1401 res
= isl_pw_aff_alloc_size(isl_space_copy(pwaff1
->dim
), n
);
1403 for (i
= 0; i
< pwaff1
->n
; ++i
) {
1404 set
= isl_set_copy(pwaff1
->p
[i
].set
);
1405 for (j
= 0; j
< pwaff2
->n
; ++j
) {
1406 struct isl_set
*common
;
1409 common
= isl_set_intersect(
1410 isl_set_copy(pwaff1
->p
[i
].set
),
1411 isl_set_copy(pwaff2
->p
[j
].set
));
1412 better
= isl_set_from_basic_set(cmp(
1413 isl_aff_copy(pwaff2
->p
[j
].aff
),
1414 isl_aff_copy(pwaff1
->p
[i
].aff
)));
1415 better
= isl_set_intersect(common
, better
);
1416 if (isl_set_plain_is_empty(better
)) {
1417 isl_set_free(better
);
1420 set
= isl_set_subtract(set
, isl_set_copy(better
));
1422 res
= isl_pw_aff_add_piece(res
, better
,
1423 isl_aff_copy(pwaff2
->p
[j
].aff
));
1425 res
= isl_pw_aff_add_piece(res
, set
,
1426 isl_aff_copy(pwaff1
->p
[i
].aff
));
1429 for (j
= 0; j
< pwaff2
->n
; ++j
) {
1430 set
= isl_set_copy(pwaff2
->p
[j
].set
);
1431 for (i
= 0; i
< pwaff1
->n
; ++i
)
1432 set
= isl_set_subtract(set
,
1433 isl_set_copy(pwaff1
->p
[i
].set
));
1434 res
= isl_pw_aff_add_piece(res
, set
,
1435 isl_aff_copy(pwaff2
->p
[j
].aff
));
1438 isl_pw_aff_free(pwaff1
);
1439 isl_pw_aff_free(pwaff2
);
1443 isl_pw_aff_free(pwaff1
);
1444 isl_pw_aff_free(pwaff2
);
1448 /* Compute a piecewise quasi-affine expression with a domain that
1449 * is the union of those of pwaff1 and pwaff2 and such that on each
1450 * cell, the quasi-affine expression is the maximum of those of pwaff1
1451 * and pwaff2. If only one of pwaff1 or pwaff2 is defined on a given
1452 * cell, then the associated expression is the defined one.
1454 static __isl_give isl_pw_aff
*pw_aff_union_max(__isl_take isl_pw_aff
*pwaff1
,
1455 __isl_take isl_pw_aff
*pwaff2
)
1457 return pw_aff_union_opt(pwaff1
, pwaff2
, &isl_aff_ge_basic_set
);
1460 __isl_give isl_pw_aff
*isl_pw_aff_union_max(__isl_take isl_pw_aff
*pwaff1
,
1461 __isl_take isl_pw_aff
*pwaff2
)
1463 return isl_pw_aff_align_params_pw_pw_and(pwaff1
, pwaff2
,
1467 /* Compute a piecewise quasi-affine expression with a domain that
1468 * is the union of those of pwaff1 and pwaff2 and such that on each
1469 * cell, the quasi-affine expression is the minimum of those of pwaff1
1470 * and pwaff2. If only one of pwaff1 or pwaff2 is defined on a given
1471 * cell, then the associated expression is the defined one.
1473 static __isl_give isl_pw_aff
*pw_aff_union_min(__isl_take isl_pw_aff
*pwaff1
,
1474 __isl_take isl_pw_aff
*pwaff2
)
1476 return pw_aff_union_opt(pwaff1
, pwaff2
, &isl_aff_le_basic_set
);
1479 __isl_give isl_pw_aff
*isl_pw_aff_union_min(__isl_take isl_pw_aff
*pwaff1
,
1480 __isl_take isl_pw_aff
*pwaff2
)
1482 return isl_pw_aff_align_params_pw_pw_and(pwaff1
, pwaff2
,
1486 __isl_give isl_pw_aff
*isl_pw_aff_union_opt(__isl_take isl_pw_aff
*pwaff1
,
1487 __isl_take isl_pw_aff
*pwaff2
, int max
)
1490 return isl_pw_aff_union_max(pwaff1
, pwaff2
);
1492 return isl_pw_aff_union_min(pwaff1
, pwaff2
);
1495 /* Construct a map with as domain the domain of pwaff and
1496 * one-dimensional range corresponding to the affine expressions.
1498 static __isl_give isl_map
*map_from_pw_aff(__isl_take isl_pw_aff
*pwaff
)
1507 dim
= isl_pw_aff_get_space(pwaff
);
1508 map
= isl_map_empty(dim
);
1510 for (i
= 0; i
< pwaff
->n
; ++i
) {
1511 isl_basic_map
*bmap
;
1514 bmap
= isl_basic_map_from_aff(isl_aff_copy(pwaff
->p
[i
].aff
));
1515 map_i
= isl_map_from_basic_map(bmap
);
1516 map_i
= isl_map_intersect_domain(map_i
,
1517 isl_set_copy(pwaff
->p
[i
].set
));
1518 map
= isl_map_union_disjoint(map
, map_i
);
1521 isl_pw_aff_free(pwaff
);
1526 /* Construct a map with as domain the domain of pwaff and
1527 * one-dimensional range corresponding to the affine expressions.
1529 __isl_give isl_map
*isl_map_from_pw_aff(__isl_take isl_pw_aff
*pwaff
)
1533 if (isl_space_is_set(pwaff
->dim
))
1534 isl_die(isl_pw_aff_get_ctx(pwaff
), isl_error_invalid
,
1535 "space of input is not a map",
1536 return isl_pw_aff_free(pwaff
));
1537 return map_from_pw_aff(pwaff
);
1540 /* Construct a one-dimensional set with as parameter domain
1541 * the domain of pwaff and the single set dimension
1542 * corresponding to the affine expressions.
1544 __isl_give isl_set
*isl_set_from_pw_aff(__isl_take isl_pw_aff
*pwaff
)
1548 if (!isl_space_is_set(pwaff
->dim
))
1549 isl_die(isl_pw_aff_get_ctx(pwaff
), isl_error_invalid
,
1550 "space of input is not a set",
1551 return isl_pw_aff_free(pwaff
));
1552 return map_from_pw_aff(pwaff
);
1555 /* Return a set containing those elements in the domain
1556 * of pwaff where it is non-negative.
1558 __isl_give isl_set
*isl_pw_aff_nonneg_set(__isl_take isl_pw_aff
*pwaff
)
1566 set
= isl_set_empty(isl_pw_aff_get_domain_space(pwaff
));
1568 for (i
= 0; i
< pwaff
->n
; ++i
) {
1569 isl_basic_set
*bset
;
1572 bset
= isl_aff_nonneg_basic_set(isl_aff_copy(pwaff
->p
[i
].aff
));
1573 set_i
= isl_set_from_basic_set(bset
);
1574 set_i
= isl_set_intersect(set_i
, isl_set_copy(pwaff
->p
[i
].set
));
1575 set
= isl_set_union_disjoint(set
, set_i
);
1578 isl_pw_aff_free(pwaff
);
1583 /* Return a set containing those elements in the domain
1584 * of pwaff where it is zero (if complement is 0) or not zero
1585 * (if complement is 1).
1587 static __isl_give isl_set
*pw_aff_zero_set(__isl_take isl_pw_aff
*pwaff
,
1596 set
= isl_set_empty(isl_pw_aff_get_domain_space(pwaff
));
1598 for (i
= 0; i
< pwaff
->n
; ++i
) {
1599 isl_basic_set
*bset
;
1600 isl_set
*set_i
, *zero
;
1602 bset
= isl_aff_zero_basic_set(isl_aff_copy(pwaff
->p
[i
].aff
));
1603 zero
= isl_set_from_basic_set(bset
);
1604 set_i
= isl_set_copy(pwaff
->p
[i
].set
);
1606 set_i
= isl_set_subtract(set_i
, zero
);
1608 set_i
= isl_set_intersect(set_i
, zero
);
1609 set
= isl_set_union_disjoint(set
, set_i
);
1612 isl_pw_aff_free(pwaff
);
1617 /* Return a set containing those elements in the domain
1618 * of pwaff where it is zero.
1620 __isl_give isl_set
*isl_pw_aff_zero_set(__isl_take isl_pw_aff
*pwaff
)
1622 return pw_aff_zero_set(pwaff
, 0);
1625 /* Return a set containing those elements in the domain
1626 * of pwaff where it is not zero.
1628 __isl_give isl_set
*isl_pw_aff_non_zero_set(__isl_take isl_pw_aff
*pwaff
)
1630 return pw_aff_zero_set(pwaff
, 1);
1633 /* Return a set containing those elements in the shared domain
1634 * of pwaff1 and pwaff2 where pwaff1 is greater than (or equal) to pwaff2.
1636 * We compute the difference on the shared domain and then construct
1637 * the set of values where this difference is non-negative.
1638 * If strict is set, we first subtract 1 from the difference.
1639 * If equal is set, we only return the elements where pwaff1 and pwaff2
1642 static __isl_give isl_set
*pw_aff_gte_set(__isl_take isl_pw_aff
*pwaff1
,
1643 __isl_take isl_pw_aff
*pwaff2
, int strict
, int equal
)
1645 isl_set
*set1
, *set2
;
1647 set1
= isl_pw_aff_domain(isl_pw_aff_copy(pwaff1
));
1648 set2
= isl_pw_aff_domain(isl_pw_aff_copy(pwaff2
));
1649 set1
= isl_set_intersect(set1
, set2
);
1650 pwaff1
= isl_pw_aff_intersect_domain(pwaff1
, isl_set_copy(set1
));
1651 pwaff2
= isl_pw_aff_intersect_domain(pwaff2
, isl_set_copy(set1
));
1652 pwaff1
= isl_pw_aff_add(pwaff1
, isl_pw_aff_neg(pwaff2
));
1655 isl_space
*dim
= isl_set_get_space(set1
);
1657 aff
= isl_aff_zero_on_domain(isl_local_space_from_space(dim
));
1658 aff
= isl_aff_add_constant_si(aff
, -1);
1659 pwaff1
= isl_pw_aff_add(pwaff1
, isl_pw_aff_alloc(set1
, aff
));
1664 return isl_pw_aff_zero_set(pwaff1
);
1665 return isl_pw_aff_nonneg_set(pwaff1
);
1668 /* Return a set containing those elements in the shared domain
1669 * of pwaff1 and pwaff2 where pwaff1 is equal to pwaff2.
1671 static __isl_give isl_set
*pw_aff_eq_set(__isl_take isl_pw_aff
*pwaff1
,
1672 __isl_take isl_pw_aff
*pwaff2
)
1674 return pw_aff_gte_set(pwaff1
, pwaff2
, 0, 1);
1677 __isl_give isl_set
*isl_pw_aff_eq_set(__isl_take isl_pw_aff
*pwaff1
,
1678 __isl_take isl_pw_aff
*pwaff2
)
1680 return align_params_pw_pw_set_and(pwaff1
, pwaff2
, &pw_aff_eq_set
);
1683 /* Return a set containing those elements in the shared domain
1684 * of pwaff1 and pwaff2 where pwaff1 is greater than or equal to pwaff2.
1686 static __isl_give isl_set
*pw_aff_ge_set(__isl_take isl_pw_aff
*pwaff1
,
1687 __isl_take isl_pw_aff
*pwaff2
)
1689 return pw_aff_gte_set(pwaff1
, pwaff2
, 0, 0);
1692 __isl_give isl_set
*isl_pw_aff_ge_set(__isl_take isl_pw_aff
*pwaff1
,
1693 __isl_take isl_pw_aff
*pwaff2
)
1695 return align_params_pw_pw_set_and(pwaff1
, pwaff2
, &pw_aff_ge_set
);
1698 /* Return a set containing those elements in the shared domain
1699 * of pwaff1 and pwaff2 where pwaff1 is strictly greater than pwaff2.
1701 static __isl_give isl_set
*pw_aff_gt_set(__isl_take isl_pw_aff
*pwaff1
,
1702 __isl_take isl_pw_aff
*pwaff2
)
1704 return pw_aff_gte_set(pwaff1
, pwaff2
, 1, 0);
1707 __isl_give isl_set
*isl_pw_aff_gt_set(__isl_take isl_pw_aff
*pwaff1
,
1708 __isl_take isl_pw_aff
*pwaff2
)
1710 return align_params_pw_pw_set_and(pwaff1
, pwaff2
, &pw_aff_gt_set
);
1713 __isl_give isl_set
*isl_pw_aff_le_set(__isl_take isl_pw_aff
*pwaff1
,
1714 __isl_take isl_pw_aff
*pwaff2
)
1716 return isl_pw_aff_ge_set(pwaff2
, pwaff1
);
1719 __isl_give isl_set
*isl_pw_aff_lt_set(__isl_take isl_pw_aff
*pwaff1
,
1720 __isl_take isl_pw_aff
*pwaff2
)
1722 return isl_pw_aff_gt_set(pwaff2
, pwaff1
);
1725 /* Return a set containing those elements in the shared domain
1726 * of the elements of list1 and list2 where each element in list1
1727 * has the relation specified by "fn" with each element in list2.
1729 static __isl_give isl_set
*pw_aff_list_set(__isl_take isl_pw_aff_list
*list1
,
1730 __isl_take isl_pw_aff_list
*list2
,
1731 __isl_give isl_set
*(*fn
)(__isl_take isl_pw_aff
*pwaff1
,
1732 __isl_take isl_pw_aff
*pwaff2
))
1738 if (!list1
|| !list2
)
1741 ctx
= isl_pw_aff_list_get_ctx(list1
);
1742 if (list1
->n
< 1 || list2
->n
< 1)
1743 isl_die(ctx
, isl_error_invalid
,
1744 "list should contain at least one element", goto error
);
1746 set
= isl_set_universe(isl_pw_aff_get_domain_space(list1
->p
[0]));
1747 for (i
= 0; i
< list1
->n
; ++i
)
1748 for (j
= 0; j
< list2
->n
; ++j
) {
1751 set_ij
= fn(isl_pw_aff_copy(list1
->p
[i
]),
1752 isl_pw_aff_copy(list2
->p
[j
]));
1753 set
= isl_set_intersect(set
, set_ij
);
1756 isl_pw_aff_list_free(list1
);
1757 isl_pw_aff_list_free(list2
);
1760 isl_pw_aff_list_free(list1
);
1761 isl_pw_aff_list_free(list2
);
1765 /* Return a set containing those elements in the shared domain
1766 * of the elements of list1 and list2 where each element in list1
1767 * is equal to each element in list2.
1769 __isl_give isl_set
*isl_pw_aff_list_eq_set(__isl_take isl_pw_aff_list
*list1
,
1770 __isl_take isl_pw_aff_list
*list2
)
1772 return pw_aff_list_set(list1
, list2
, &isl_pw_aff_eq_set
);
1775 __isl_give isl_set
*isl_pw_aff_list_ne_set(__isl_take isl_pw_aff_list
*list1
,
1776 __isl_take isl_pw_aff_list
*list2
)
1778 return pw_aff_list_set(list1
, list2
, &isl_pw_aff_ne_set
);
1781 /* Return a set containing those elements in the shared domain
1782 * of the elements of list1 and list2 where each element in list1
1783 * is less than or equal to each element in list2.
1785 __isl_give isl_set
*isl_pw_aff_list_le_set(__isl_take isl_pw_aff_list
*list1
,
1786 __isl_take isl_pw_aff_list
*list2
)
1788 return pw_aff_list_set(list1
, list2
, &isl_pw_aff_le_set
);
1791 __isl_give isl_set
*isl_pw_aff_list_lt_set(__isl_take isl_pw_aff_list
*list1
,
1792 __isl_take isl_pw_aff_list
*list2
)
1794 return pw_aff_list_set(list1
, list2
, &isl_pw_aff_lt_set
);
1797 __isl_give isl_set
*isl_pw_aff_list_ge_set(__isl_take isl_pw_aff_list
*list1
,
1798 __isl_take isl_pw_aff_list
*list2
)
1800 return pw_aff_list_set(list1
, list2
, &isl_pw_aff_ge_set
);
1803 __isl_give isl_set
*isl_pw_aff_list_gt_set(__isl_take isl_pw_aff_list
*list1
,
1804 __isl_take isl_pw_aff_list
*list2
)
1806 return pw_aff_list_set(list1
, list2
, &isl_pw_aff_gt_set
);
1810 /* Return a set containing those elements in the shared domain
1811 * of pwaff1 and pwaff2 where pwaff1 is not equal to pwaff2.
1813 static __isl_give isl_set
*pw_aff_ne_set(__isl_take isl_pw_aff
*pwaff1
,
1814 __isl_take isl_pw_aff
*pwaff2
)
1816 isl_set
*set_lt
, *set_gt
;
1818 set_lt
= isl_pw_aff_lt_set(isl_pw_aff_copy(pwaff1
),
1819 isl_pw_aff_copy(pwaff2
));
1820 set_gt
= isl_pw_aff_gt_set(pwaff1
, pwaff2
);
1821 return isl_set_union_disjoint(set_lt
, set_gt
);
1824 __isl_give isl_set
*isl_pw_aff_ne_set(__isl_take isl_pw_aff
*pwaff1
,
1825 __isl_take isl_pw_aff
*pwaff2
)
1827 return align_params_pw_pw_set_and(pwaff1
, pwaff2
, &pw_aff_ne_set
);
1830 __isl_give isl_pw_aff
*isl_pw_aff_scale_down(__isl_take isl_pw_aff
*pwaff
,
1835 if (isl_int_is_one(v
))
1837 if (!isl_int_is_pos(v
))
1838 isl_die(isl_pw_aff_get_ctx(pwaff
), isl_error_invalid
,
1839 "factor needs to be positive",
1840 return isl_pw_aff_free(pwaff
));
1841 pwaff
= isl_pw_aff_cow(pwaff
);
1847 for (i
= 0; i
< pwaff
->n
; ++i
) {
1848 pwaff
->p
[i
].aff
= isl_aff_scale_down(pwaff
->p
[i
].aff
, v
);
1849 if (!pwaff
->p
[i
].aff
)
1850 return isl_pw_aff_free(pwaff
);
1856 __isl_give isl_pw_aff
*isl_pw_aff_floor(__isl_take isl_pw_aff
*pwaff
)
1860 pwaff
= isl_pw_aff_cow(pwaff
);
1866 for (i
= 0; i
< pwaff
->n
; ++i
) {
1867 pwaff
->p
[i
].aff
= isl_aff_floor(pwaff
->p
[i
].aff
);
1868 if (!pwaff
->p
[i
].aff
)
1869 return isl_pw_aff_free(pwaff
);
1875 __isl_give isl_pw_aff
*isl_pw_aff_ceil(__isl_take isl_pw_aff
*pwaff
)
1879 pwaff
= isl_pw_aff_cow(pwaff
);
1885 for (i
= 0; i
< pwaff
->n
; ++i
) {
1886 pwaff
->p
[i
].aff
= isl_aff_ceil(pwaff
->p
[i
].aff
);
1887 if (!pwaff
->p
[i
].aff
)
1888 return isl_pw_aff_free(pwaff
);
1894 /* Assuming that "cond1" and "cond2" are disjoint,
1895 * return an affine expression that is equal to pwaff1 on cond1
1896 * and to pwaff2 on cond2.
1898 static __isl_give isl_pw_aff
*isl_pw_aff_select(
1899 __isl_take isl_set
*cond1
, __isl_take isl_pw_aff
*pwaff1
,
1900 __isl_take isl_set
*cond2
, __isl_take isl_pw_aff
*pwaff2
)
1902 pwaff1
= isl_pw_aff_intersect_domain(pwaff1
, cond1
);
1903 pwaff2
= isl_pw_aff_intersect_domain(pwaff2
, cond2
);
1905 return isl_pw_aff_add_disjoint(pwaff1
, pwaff2
);
1908 /* Return an affine expression that is equal to pwaff_true for elements
1909 * where "cond" is non-zero and to pwaff_false for elements where "cond"
1911 * That is, return cond ? pwaff_true : pwaff_false;
1913 __isl_give isl_pw_aff
*isl_pw_aff_cond(__isl_take isl_pw_aff
*cond
,
1914 __isl_take isl_pw_aff
*pwaff_true
, __isl_take isl_pw_aff
*pwaff_false
)
1916 isl_set
*cond_true
, *cond_false
;
1918 cond_true
= isl_pw_aff_non_zero_set(isl_pw_aff_copy(cond
));
1919 cond_false
= isl_pw_aff_zero_set(cond
);
1920 return isl_pw_aff_select(cond_true
, pwaff_true
,
1921 cond_false
, pwaff_false
);
1924 int isl_aff_is_cst(__isl_keep isl_aff
*aff
)
1929 return isl_seq_first_non_zero(aff
->v
->el
+ 2, aff
->v
->size
- 2) == -1;
1932 /* Check whether pwaff is a piecewise constant.
1934 int isl_pw_aff_is_cst(__isl_keep isl_pw_aff
*pwaff
)
1941 for (i
= 0; i
< pwaff
->n
; ++i
) {
1942 int is_cst
= isl_aff_is_cst(pwaff
->p
[i
].aff
);
1943 if (is_cst
< 0 || !is_cst
)
1950 __isl_give isl_aff
*isl_aff_mul(__isl_take isl_aff
*aff1
,
1951 __isl_take isl_aff
*aff2
)
1953 if (!isl_aff_is_cst(aff2
) && isl_aff_is_cst(aff1
))
1954 return isl_aff_mul(aff2
, aff1
);
1956 if (!isl_aff_is_cst(aff2
))
1957 isl_die(isl_aff_get_ctx(aff1
), isl_error_invalid
,
1958 "at least one affine expression should be constant",
1961 aff1
= isl_aff_cow(aff1
);
1965 aff1
= isl_aff_scale(aff1
, aff2
->v
->el
[1]);
1966 aff1
= isl_aff_scale_down(aff1
, aff2
->v
->el
[0]);
1976 static __isl_give isl_pw_aff
*pw_aff_add(__isl_take isl_pw_aff
*pwaff1
,
1977 __isl_take isl_pw_aff
*pwaff2
)
1979 return isl_pw_aff_on_shared_domain(pwaff1
, pwaff2
, &isl_aff_add
);
1982 __isl_give isl_pw_aff
*isl_pw_aff_add(__isl_take isl_pw_aff
*pwaff1
,
1983 __isl_take isl_pw_aff
*pwaff2
)
1985 return isl_pw_aff_align_params_pw_pw_and(pwaff1
, pwaff2
, &pw_aff_add
);
1988 __isl_give isl_pw_aff
*isl_pw_aff_union_add(__isl_take isl_pw_aff
*pwaff1
,
1989 __isl_take isl_pw_aff
*pwaff2
)
1991 return isl_pw_aff_union_add_(pwaff1
, pwaff2
);
1994 static __isl_give isl_pw_aff
*pw_aff_mul(__isl_take isl_pw_aff
*pwaff1
,
1995 __isl_take isl_pw_aff
*pwaff2
)
1997 return isl_pw_aff_on_shared_domain(pwaff1
, pwaff2
, &isl_aff_mul
);
2000 __isl_give isl_pw_aff
*isl_pw_aff_mul(__isl_take isl_pw_aff
*pwaff1
,
2001 __isl_take isl_pw_aff
*pwaff2
)
2003 return isl_pw_aff_align_params_pw_pw_and(pwaff1
, pwaff2
, &pw_aff_mul
);
2006 static __isl_give isl_pw_aff
*pw_aff_min(__isl_take isl_pw_aff
*pwaff1
,
2007 __isl_take isl_pw_aff
*pwaff2
)
2012 dom
= isl_set_intersect(isl_pw_aff_domain(isl_pw_aff_copy(pwaff1
)),
2013 isl_pw_aff_domain(isl_pw_aff_copy(pwaff2
)));
2014 le
= isl_pw_aff_le_set(isl_pw_aff_copy(pwaff1
),
2015 isl_pw_aff_copy(pwaff2
));
2016 dom
= isl_set_subtract(dom
, isl_set_copy(le
));
2017 return isl_pw_aff_select(le
, pwaff1
, dom
, pwaff2
);
2020 __isl_give isl_pw_aff
*isl_pw_aff_min(__isl_take isl_pw_aff
*pwaff1
,
2021 __isl_take isl_pw_aff
*pwaff2
)
2023 return isl_pw_aff_align_params_pw_pw_and(pwaff1
, pwaff2
, &pw_aff_min
);
2026 static __isl_give isl_pw_aff
*pw_aff_max(__isl_take isl_pw_aff
*pwaff1
,
2027 __isl_take isl_pw_aff
*pwaff2
)
2032 dom
= isl_set_intersect(isl_pw_aff_domain(isl_pw_aff_copy(pwaff1
)),
2033 isl_pw_aff_domain(isl_pw_aff_copy(pwaff2
)));
2034 ge
= isl_pw_aff_ge_set(isl_pw_aff_copy(pwaff1
),
2035 isl_pw_aff_copy(pwaff2
));
2036 dom
= isl_set_subtract(dom
, isl_set_copy(ge
));
2037 return isl_pw_aff_select(ge
, pwaff1
, dom
, pwaff2
);
2040 __isl_give isl_pw_aff
*isl_pw_aff_max(__isl_take isl_pw_aff
*pwaff1
,
2041 __isl_take isl_pw_aff
*pwaff2
)
2043 return isl_pw_aff_align_params_pw_pw_and(pwaff1
, pwaff2
, &pw_aff_max
);
2046 static __isl_give isl_pw_aff
*pw_aff_list_reduce(
2047 __isl_take isl_pw_aff_list
*list
,
2048 __isl_give isl_pw_aff
*(*fn
)(__isl_take isl_pw_aff
*pwaff1
,
2049 __isl_take isl_pw_aff
*pwaff2
))
2058 ctx
= isl_pw_aff_list_get_ctx(list
);
2060 isl_die(ctx
, isl_error_invalid
,
2061 "list should contain at least one element",
2062 return isl_pw_aff_list_free(list
));
2064 res
= isl_pw_aff_copy(list
->p
[0]);
2065 for (i
= 1; i
< list
->n
; ++i
)
2066 res
= fn(res
, isl_pw_aff_copy(list
->p
[i
]));
2068 isl_pw_aff_list_free(list
);
2072 /* Return an isl_pw_aff that maps each element in the intersection of the
2073 * domains of the elements of list to the minimal corresponding affine
2076 __isl_give isl_pw_aff
*isl_pw_aff_list_min(__isl_take isl_pw_aff_list
*list
)
2078 return pw_aff_list_reduce(list
, &isl_pw_aff_min
);
2081 /* Return an isl_pw_aff that maps each element in the intersection of the
2082 * domains of the elements of list to the maximal corresponding affine
2085 __isl_give isl_pw_aff
*isl_pw_aff_list_max(__isl_take isl_pw_aff_list
*list
)
2087 return pw_aff_list_reduce(list
, &isl_pw_aff_max
);
2093 #include <isl_multi_templ.c>
2095 /* Construct an isl_multi_aff in the given space with value zero in
2096 * each of the output dimensions.
2098 __isl_give isl_multi_aff
*isl_multi_aff_zero(__isl_take isl_space
*space
)
2106 n
= isl_space_dim(space
, isl_dim_out
);
2107 ma
= isl_multi_aff_alloc(isl_space_copy(space
));
2110 isl_space_free(space
);
2113 isl_local_space
*ls
;
2116 space
= isl_space_domain(space
);
2117 ls
= isl_local_space_from_space(space
);
2118 aff
= isl_aff_zero_on_domain(ls
);
2120 for (i
= 0; i
< n
; ++i
)
2121 ma
= isl_multi_aff_set_aff(ma
, i
, isl_aff_copy(aff
));
2129 /* Create an isl_pw_multi_aff with the given isl_multi_aff on a universe
2132 __isl_give isl_pw_multi_aff
*isl_pw_multi_aff_from_multi_aff(
2133 __isl_take isl_multi_aff
*ma
)
2135 isl_set
*dom
= isl_set_universe(isl_multi_aff_get_domain_space(ma
));
2136 return isl_pw_multi_aff_alloc(dom
, ma
);
2139 __isl_give isl_multi_aff
*isl_multi_aff_add(__isl_take isl_multi_aff
*maff1
,
2140 __isl_take isl_multi_aff
*maff2
)
2145 maff1
= isl_multi_aff_cow(maff1
);
2146 if (!maff1
|| !maff2
)
2149 ctx
= isl_multi_aff_get_ctx(maff1
);
2150 if (!isl_space_is_equal(maff1
->space
, maff2
->space
))
2151 isl_die(ctx
, isl_error_invalid
,
2152 "spaces don't match", goto error
);
2154 for (i
= 0; i
< maff1
->n
; ++i
) {
2155 maff1
->p
[i
] = isl_aff_add(maff1
->p
[i
],
2156 isl_aff_copy(maff2
->p
[i
]));
2161 isl_multi_aff_free(maff2
);
2164 isl_multi_aff_free(maff1
);
2165 isl_multi_aff_free(maff2
);
2169 /* Exploit the equalities in "eq" to simplify the affine expressions.
2171 static __isl_give isl_multi_aff
*isl_multi_aff_substitute_equalities(
2172 __isl_take isl_multi_aff
*maff
, __isl_take isl_basic_set
*eq
)
2176 maff
= isl_multi_aff_cow(maff
);
2180 for (i
= 0; i
< maff
->n
; ++i
) {
2181 maff
->p
[i
] = isl_aff_substitute_equalities(maff
->p
[i
],
2182 isl_basic_set_copy(eq
));
2187 isl_basic_set_free(eq
);
2190 isl_basic_set_free(eq
);
2191 isl_multi_aff_free(maff
);
2195 __isl_give isl_multi_aff
*isl_multi_aff_scale(__isl_take isl_multi_aff
*maff
,
2200 maff
= isl_multi_aff_cow(maff
);
2204 for (i
= 0; i
< maff
->n
; ++i
) {
2205 maff
->p
[i
] = isl_aff_scale(maff
->p
[i
], f
);
2207 return isl_multi_aff_free(maff
);
2213 __isl_give isl_multi_aff
*isl_multi_aff_add_on_domain(__isl_keep isl_set
*dom
,
2214 __isl_take isl_multi_aff
*maff1
, __isl_take isl_multi_aff
*maff2
)
2216 maff1
= isl_multi_aff_add(maff1
, maff2
);
2217 maff1
= isl_multi_aff_gist(maff1
, isl_set_copy(dom
));
2221 int isl_multi_aff_is_empty(__isl_keep isl_multi_aff
*maff
)
2229 int isl_multi_aff_plain_is_equal(__isl_keep isl_multi_aff
*maff1
,
2230 __isl_keep isl_multi_aff
*maff2
)
2235 if (!maff1
|| !maff2
)
2237 if (maff1
->n
!= maff2
->n
)
2239 equal
= isl_space_is_equal(maff1
->space
, maff2
->space
);
2240 if (equal
< 0 || !equal
)
2243 for (i
= 0; i
< maff1
->n
; ++i
) {
2244 equal
= isl_aff_plain_is_equal(maff1
->p
[i
], maff2
->p
[i
]);
2245 if (equal
< 0 || !equal
)
2252 __isl_give isl_multi_aff
*isl_multi_aff_set_dim_name(
2253 __isl_take isl_multi_aff
*maff
,
2254 enum isl_dim_type type
, unsigned pos
, const char *s
)
2258 maff
= isl_multi_aff_cow(maff
);
2262 maff
->space
= isl_space_set_dim_name(maff
->space
, type
, pos
, s
);
2264 return isl_multi_aff_free(maff
);
2265 for (i
= 0; i
< maff
->n
; ++i
) {
2266 maff
->p
[i
] = isl_aff_set_dim_name(maff
->p
[i
], type
, pos
, s
);
2268 return isl_multi_aff_free(maff
);
2274 __isl_give isl_multi_aff
*isl_multi_aff_drop_dims(__isl_take isl_multi_aff
*maff
,
2275 enum isl_dim_type type
, unsigned first
, unsigned n
)
2279 maff
= isl_multi_aff_cow(maff
);
2283 maff
->space
= isl_space_drop_dims(maff
->space
, type
, first
, n
);
2285 return isl_multi_aff_free(maff
);
2287 if (type
== isl_dim_out
) {
2288 for (i
= 0; i
< n
; ++i
)
2289 isl_aff_free(maff
->p
[first
+ i
]);
2290 for (i
= first
; i
+ n
< maff
->n
; ++i
)
2291 maff
->p
[i
] = maff
->p
[i
+ n
];
2296 for (i
= 0; i
< maff
->n
; ++i
) {
2297 maff
->p
[i
] = isl_aff_drop_dims(maff
->p
[i
], type
, first
, n
);
2299 return isl_multi_aff_free(maff
);
2306 #define PW isl_pw_multi_aff
2308 #define EL isl_multi_aff
2310 #define EL_IS_ZERO is_empty
2314 #define IS_ZERO is_empty
2317 #undef DEFAULT_IS_ZERO
2318 #define DEFAULT_IS_ZERO 0
2323 #define NO_INVOLVES_DIMS
2324 #define NO_MOVE_DIMS
2325 #define NO_INSERT_DIMS
2329 #include <isl_pw_templ.c>
2332 #define UNION isl_union_pw_multi_aff
2334 #define PART isl_pw_multi_aff
2336 #define PARTS pw_multi_aff
2337 #define ALIGN_DOMAIN
2341 #include <isl_union_templ.c>
2343 static __isl_give isl_pw_multi_aff
*pw_multi_aff_add(
2344 __isl_take isl_pw_multi_aff
*pma1
, __isl_take isl_pw_multi_aff
*pma2
)
2346 return isl_pw_multi_aff_on_shared_domain(pma1
, pma2
,
2347 &isl_multi_aff_add
);
2350 __isl_give isl_pw_multi_aff
*isl_pw_multi_aff_add(
2351 __isl_take isl_pw_multi_aff
*pma1
, __isl_take isl_pw_multi_aff
*pma2
)
2353 return isl_pw_multi_aff_align_params_pw_pw_and(pma1
, pma2
,
2357 __isl_give isl_pw_multi_aff
*isl_pw_multi_aff_union_add(
2358 __isl_take isl_pw_multi_aff
*pma1
, __isl_take isl_pw_multi_aff
*pma2
)
2360 return isl_pw_multi_aff_union_add_(pma1
, pma2
);
2363 /* Construct a map mapping the domain of the piecewise multi-affine expression
2364 * to its range, with each dimension in the range equated to the
2365 * corresponding affine expression on its cell.
2367 __isl_give isl_map
*isl_map_from_pw_multi_aff(__isl_take isl_pw_multi_aff
*pma
)
2375 map
= isl_map_empty(isl_pw_multi_aff_get_space(pma
));
2377 for (i
= 0; i
< pma
->n
; ++i
) {
2378 isl_multi_aff
*maff
;
2379 isl_basic_map
*bmap
;
2382 maff
= isl_multi_aff_copy(pma
->p
[i
].maff
);
2383 bmap
= isl_basic_map_from_multi_aff(maff
);
2384 map_i
= isl_map_from_basic_map(bmap
);
2385 map_i
= isl_map_intersect_domain(map_i
,
2386 isl_set_copy(pma
->p
[i
].set
));
2387 map
= isl_map_union_disjoint(map
, map_i
);
2390 isl_pw_multi_aff_free(pma
);
2394 __isl_give isl_set
*isl_set_from_pw_multi_aff(__isl_take isl_pw_multi_aff
*pma
)
2396 if (!isl_space_is_set(pma
->dim
))
2397 isl_die(isl_pw_multi_aff_get_ctx(pma
), isl_error_invalid
,
2398 "isl_pw_multi_aff cannot be converted into an isl_set",
2399 return isl_pw_multi_aff_free(pma
));
2401 return isl_map_from_pw_multi_aff(pma
);
2404 /* Given a basic map with a single output dimension that is defined
2405 * in terms of the parameters and input dimensions using an equality,
2406 * extract an isl_aff that expresses the output dimension in terms
2407 * of the parameters and input dimensions.
2409 * Since some applications expect the result of isl_pw_multi_aff_from_map
2410 * to only contain integer affine expressions, we compute the floor
2411 * of the expression before returning.
2413 * This function shares some similarities with
2414 * isl_basic_map_has_defining_equality and isl_constraint_get_bound.
2416 static __isl_give isl_aff
*extract_isl_aff_from_basic_map(
2417 __isl_take isl_basic_map
*bmap
)
2422 isl_local_space
*ls
;
2427 if (isl_basic_map_dim(bmap
, isl_dim_out
) != 1)
2428 isl_die(isl_basic_map_get_ctx(bmap
), isl_error_invalid
,
2429 "basic map should have a single output dimension",
2431 offset
= isl_basic_map_offset(bmap
, isl_dim_out
);
2432 total
= isl_basic_map_total_dim(bmap
);
2433 for (i
= 0; i
< bmap
->n_eq
; ++i
) {
2434 if (isl_int_is_zero(bmap
->eq
[i
][offset
]))
2436 if (isl_seq_first_non_zero(bmap
->eq
[i
] + offset
+ 1,
2437 1 + total
- (offset
+ 1)) != -1)
2441 if (i
>= bmap
->n_eq
)
2442 isl_die(isl_basic_map_get_ctx(bmap
), isl_error_invalid
,
2443 "unable to find suitable equality", goto error
);
2444 ls
= isl_basic_map_get_local_space(bmap
);
2445 aff
= isl_aff_alloc(isl_local_space_domain(ls
));
2448 if (isl_int_is_neg(bmap
->eq
[i
][offset
]))
2449 isl_seq_cpy(aff
->v
->el
+ 1, bmap
->eq
[i
], offset
);
2451 isl_seq_neg(aff
->v
->el
+ 1, bmap
->eq
[i
], offset
);
2452 isl_seq_clr(aff
->v
->el
+ 1 + offset
, aff
->v
->size
- (1 + offset
));
2453 isl_int_abs(aff
->v
->el
[0], bmap
->eq
[i
][offset
]);
2454 isl_basic_map_free(bmap
);
2456 aff
= isl_aff_remove_unused_divs(aff
);
2457 aff
= isl_aff_floor(aff
);
2460 isl_basic_map_free(bmap
);
2464 /* Given a basic map where each output dimension is defined
2465 * in terms of the parameters and input dimensions using an equality,
2466 * extract an isl_multi_aff that expresses the output dimensions in terms
2467 * of the parameters and input dimensions.
2469 static __isl_give isl_multi_aff
*extract_isl_multi_aff_from_basic_map(
2470 __isl_take isl_basic_map
*bmap
)
2479 ma
= isl_multi_aff_alloc(isl_basic_map_get_space(bmap
));
2480 n_out
= isl_basic_map_dim(bmap
, isl_dim_out
);
2482 for (i
= 0; i
< n_out
; ++i
) {
2483 isl_basic_map
*bmap_i
;
2486 bmap_i
= isl_basic_map_copy(bmap
);
2487 bmap_i
= isl_basic_map_project_out(bmap_i
, isl_dim_out
,
2488 i
+ 1, n_out
- (1 + i
));
2489 bmap_i
= isl_basic_map_project_out(bmap_i
, isl_dim_out
, 0, i
);
2490 aff
= extract_isl_aff_from_basic_map(bmap_i
);
2491 ma
= isl_multi_aff_set_aff(ma
, i
, aff
);
2494 isl_basic_map_free(bmap
);
2499 /* Create an isl_pw_multi_aff that is equivalent to
2500 * isl_map_intersect_domain(isl_map_from_basic_map(bmap), domain).
2501 * The given basic map is such that each output dimension is defined
2502 * in terms of the parameters and input dimensions using an equality.
2504 static __isl_give isl_pw_multi_aff
*plain_pw_multi_aff_from_map(
2505 __isl_take isl_set
*domain
, __isl_take isl_basic_map
*bmap
)
2509 ma
= extract_isl_multi_aff_from_basic_map(bmap
);
2510 return isl_pw_multi_aff_alloc(domain
, ma
);
2513 /* Try and create an isl_pw_multi_aff that is equivalent to the given isl_map.
2514 * This obivously only works if the input "map" is single-valued.
2515 * If so, we compute the lexicographic minimum of the image in the form
2516 * of an isl_pw_multi_aff. Since the image is unique, it is equal
2517 * to its lexicographic minimum.
2518 * If the input is not single-valued, we produce an error.
2520 * As a special case, we first check if all output dimensions are uniquely
2521 * defined in terms of the parameters and input dimensions over the entire
2522 * domain. If so, we extract the desired isl_pw_multi_aff directly
2523 * from the affine hull of "map" and its domain.
2525 __isl_give isl_pw_multi_aff
*isl_pw_multi_aff_from_map(__isl_take isl_map
*map
)
2529 isl_pw_multi_aff
*pma
;
2530 isl_basic_map
*hull
;
2535 hull
= isl_map_affine_hull(isl_map_copy(map
));
2536 sv
= isl_basic_map_plain_is_single_valued(hull
);
2538 return plain_pw_multi_aff_from_map(isl_map_domain(map
), hull
);
2539 isl_basic_map_free(hull
);
2543 sv
= isl_map_is_single_valued(map
);
2547 isl_die(isl_map_get_ctx(map
), isl_error_invalid
,
2548 "map is not single-valued", goto error
);
2549 map
= isl_map_make_disjoint(map
);
2553 pma
= isl_pw_multi_aff_empty(isl_map_get_space(map
));
2555 for (i
= 0; i
< map
->n
; ++i
) {
2556 isl_pw_multi_aff
*pma_i
;
2557 isl_basic_map
*bmap
;
2558 bmap
= isl_basic_map_copy(map
->p
[i
]);
2559 pma_i
= isl_basic_map_lexmin_pw_multi_aff(bmap
);
2560 pma
= isl_pw_multi_aff_add_disjoint(pma
, pma_i
);
2570 __isl_give isl_pw_multi_aff
*isl_pw_multi_aff_from_set(__isl_take isl_set
*set
)
2572 return isl_pw_multi_aff_from_map(set
);
2575 /* Return the piecewise affine expression "set ? 1 : 0".
2577 __isl_give isl_pw_aff
*isl_set_indicator_function(__isl_take isl_set
*set
)
2580 isl_space
*space
= isl_set_get_space(set
);
2581 isl_local_space
*ls
= isl_local_space_from_space(space
);
2582 isl_aff
*zero
= isl_aff_zero_on_domain(isl_local_space_copy(ls
));
2583 isl_aff
*one
= isl_aff_zero_on_domain(ls
);
2585 one
= isl_aff_add_constant_si(one
, 1);
2586 pa
= isl_pw_aff_alloc(isl_set_copy(set
), one
);
2587 set
= isl_set_complement(set
);
2588 pa
= isl_pw_aff_add_disjoint(pa
, isl_pw_aff_alloc(set
, zero
));
2593 /* Plug in "subs" for dimension "type", "pos" of "aff".
2595 * Let i be the dimension to replace and let "subs" be of the form
2599 * and "aff" of the form
2605 * floor((a f + d g')/(m d))
2607 * where g' is the result of plugging in "subs" in each of the integer
2610 __isl_give isl_aff
*isl_aff_substitute(__isl_take isl_aff
*aff
,
2611 enum isl_dim_type type
, unsigned pos
, __isl_keep isl_aff
*subs
)
2616 aff
= isl_aff_cow(aff
);
2618 return isl_aff_free(aff
);
2620 ctx
= isl_aff_get_ctx(aff
);
2621 if (!isl_space_is_equal(aff
->ls
->dim
, subs
->ls
->dim
))
2622 isl_die(ctx
, isl_error_invalid
,
2623 "spaces don't match", return isl_aff_free(aff
));
2624 if (isl_local_space_dim(subs
->ls
, isl_dim_div
) != 0)
2625 isl_die(ctx
, isl_error_unsupported
,
2626 "cannot handle divs yet", return isl_aff_free(aff
));
2628 aff
->ls
= isl_local_space_substitute(aff
->ls
, type
, pos
, subs
);
2630 return isl_aff_free(aff
);
2632 aff
->v
= isl_vec_cow(aff
->v
);
2634 return isl_aff_free(aff
);
2636 pos
+= isl_local_space_offset(aff
->ls
, type
);
2639 isl_int_set(v
, aff
->v
->el
[1 + pos
]);
2640 isl_int_set_si(aff
->v
->el
[1 + pos
], 0);
2641 isl_seq_combine(aff
->v
->el
+ 1, subs
->v
->el
[0], aff
->v
->el
+ 1,
2642 v
, subs
->v
->el
+ 1, subs
->v
->size
- 1);
2643 isl_int_mul(aff
->v
->el
[0], aff
->v
->el
[0], subs
->v
->el
[0]);
2649 /* Plug in "subs" for dimension "type", "pos" in each of the affine
2650 * expressions in "maff".
2652 __isl_give isl_multi_aff
*isl_multi_aff_substitute(
2653 __isl_take isl_multi_aff
*maff
, enum isl_dim_type type
, unsigned pos
,
2654 __isl_keep isl_aff
*subs
)
2658 maff
= isl_multi_aff_cow(maff
);
2660 return isl_multi_aff_free(maff
);
2662 if (type
== isl_dim_in
)
2665 for (i
= 0; i
< maff
->n
; ++i
) {
2666 maff
->p
[i
] = isl_aff_substitute(maff
->p
[i
], type
, pos
, subs
);
2668 return isl_multi_aff_free(maff
);
2674 /* Plug in "subs" for dimension "type", "pos" of "pma".
2676 * pma is of the form
2680 * while subs is of the form
2682 * v' = B_j(v) -> S_j
2684 * Each pair i,j such that C_ij = A_i \cap B_i is non-empty
2685 * has a contribution in the result, in particular
2687 * C_ij(S_j) -> M_i(S_j)
2689 * Note that plugging in S_j in C_ij may also result in an empty set
2690 * and this contribution should simply be discarded.
2692 __isl_give isl_pw_multi_aff
*isl_pw_multi_aff_substitute(
2693 __isl_take isl_pw_multi_aff
*pma
, enum isl_dim_type type
, unsigned pos
,
2694 __isl_keep isl_pw_aff
*subs
)
2697 isl_pw_multi_aff
*res
;
2700 return isl_pw_multi_aff_free(pma
);
2702 n
= pma
->n
* subs
->n
;
2703 res
= isl_pw_multi_aff_alloc_size(isl_space_copy(pma
->dim
), n
);
2705 for (i
= 0; i
< pma
->n
; ++i
) {
2706 for (j
= 0; j
< subs
->n
; ++j
) {
2708 isl_multi_aff
*res_ij
;
2709 common
= isl_set_intersect(
2710 isl_set_copy(pma
->p
[i
].set
),
2711 isl_set_copy(subs
->p
[j
].set
));
2712 common
= isl_set_substitute(common
,
2713 type
, pos
, subs
->p
[j
].aff
);
2714 if (isl_set_plain_is_empty(common
)) {
2715 isl_set_free(common
);
2719 res_ij
= isl_multi_aff_substitute(
2720 isl_multi_aff_copy(pma
->p
[i
].maff
),
2721 type
, pos
, subs
->p
[j
].aff
);
2723 res
= isl_pw_multi_aff_add_piece(res
, common
, res_ij
);
2727 isl_pw_multi_aff_free(pma
);
2731 /* Extend the local space of "dst" to include the divs
2732 * in the local space of "src".
2734 __isl_give isl_aff
*isl_aff_align_divs(__isl_take isl_aff
*dst
,
2735 __isl_keep isl_aff
*src
)
2743 return isl_aff_free(dst
);
2745 ctx
= isl_aff_get_ctx(src
);
2746 if (!isl_space_is_equal(src
->ls
->dim
, dst
->ls
->dim
))
2747 isl_die(ctx
, isl_error_invalid
,
2748 "spaces don't match", goto error
);
2750 if (src
->ls
->div
->n_row
== 0)
2753 exp1
= isl_alloc_array(ctx
, int, src
->ls
->div
->n_row
);
2754 exp2
= isl_alloc_array(ctx
, int, dst
->ls
->div
->n_row
);
2758 div
= isl_merge_divs(src
->ls
->div
, dst
->ls
->div
, exp1
, exp2
);
2759 dst
= isl_aff_expand_divs(dst
, div
, exp2
);
2767 return isl_aff_free(dst
);
2770 /* Adjust the local spaces of the affine expressions in "maff"
2771 * such that they all have the save divs.
2773 __isl_give isl_multi_aff
*isl_multi_aff_align_divs(
2774 __isl_take isl_multi_aff
*maff
)
2782 maff
= isl_multi_aff_cow(maff
);
2786 for (i
= 1; i
< maff
->n
; ++i
)
2787 maff
->p
[0] = isl_aff_align_divs(maff
->p
[0], maff
->p
[i
]);
2788 for (i
= 1; i
< maff
->n
; ++i
) {
2789 maff
->p
[i
] = isl_aff_align_divs(maff
->p
[i
], maff
->p
[0]);
2791 return isl_multi_aff_free(maff
);
2797 __isl_give isl_aff
*isl_aff_lift(__isl_take isl_aff
*aff
)
2799 aff
= isl_aff_cow(aff
);
2803 aff
->ls
= isl_local_space_lift(aff
->ls
);
2805 return isl_aff_free(aff
);
2810 /* Lift "maff" to a space with extra dimensions such that the result
2811 * has no more existentially quantified variables.
2812 * If "ls" is not NULL, then *ls is assigned the local space that lies
2813 * at the basis of the lifting applied to "maff".
2815 __isl_give isl_multi_aff
*isl_multi_aff_lift(__isl_take isl_multi_aff
*maff
,
2816 __isl_give isl_local_space
**ls
)
2830 isl_space
*space
= isl_multi_aff_get_domain_space(maff
);
2831 *ls
= isl_local_space_from_space(space
);
2833 return isl_multi_aff_free(maff
);
2838 maff
= isl_multi_aff_cow(maff
);
2839 maff
= isl_multi_aff_align_divs(maff
);
2843 n_div
= isl_aff_dim(maff
->p
[0], isl_dim_div
);
2844 space
= isl_multi_aff_get_space(maff
);
2845 space
= isl_space_lift(isl_space_domain(space
), n_div
);
2846 space
= isl_space_extend_domain_with_range(space
,
2847 isl_multi_aff_get_space(maff
));
2849 return isl_multi_aff_free(maff
);
2850 isl_space_free(maff
->space
);
2851 maff
->space
= space
;
2854 *ls
= isl_aff_get_domain_local_space(maff
->p
[0]);
2856 return isl_multi_aff_free(maff
);
2859 for (i
= 0; i
< maff
->n
; ++i
) {
2860 maff
->p
[i
] = isl_aff_lift(maff
->p
[i
]);
2868 isl_local_space_free(*ls
);
2869 return isl_multi_aff_free(maff
);
2873 /* Extract an isl_pw_aff corresponding to output dimension "pos" of "pma".
2875 __isl_give isl_pw_aff
*isl_pw_multi_aff_get_pw_aff(
2876 __isl_keep isl_pw_multi_aff
*pma
, int pos
)
2886 n_out
= isl_pw_multi_aff_dim(pma
, isl_dim_out
);
2887 if (pos
< 0 || pos
>= n_out
)
2888 isl_die(isl_pw_multi_aff_get_ctx(pma
), isl_error_invalid
,
2889 "index out of bounds", return NULL
);
2891 space
= isl_pw_multi_aff_get_space(pma
);
2892 space
= isl_space_drop_dims(space
, isl_dim_out
,
2893 pos
+ 1, n_out
- pos
- 1);
2894 space
= isl_space_drop_dims(space
, isl_dim_out
, 0, pos
);
2896 pa
= isl_pw_aff_alloc_size(space
, pma
->n
);
2897 for (i
= 0; i
< pma
->n
; ++i
) {
2899 aff
= isl_multi_aff_get_aff(pma
->p
[i
].maff
, pos
);
2900 pa
= isl_pw_aff_add_piece(pa
, isl_set_copy(pma
->p
[i
].set
), aff
);
2906 /* Return an isl_pw_multi_aff with the given "set" as domain and
2907 * an unnamed zero-dimensional range.
2909 __isl_give isl_pw_multi_aff
*isl_pw_multi_aff_from_domain(
2910 __isl_take isl_set
*set
)
2915 space
= isl_set_get_space(set
);
2916 space
= isl_space_from_domain(space
);
2917 ma
= isl_multi_aff_zero(space
);
2918 return isl_pw_multi_aff_alloc(set
, ma
);
2921 /* Add an isl_pw_multi_aff with the given "set" as domain and
2922 * an unnamed zero-dimensional range to *user.
2924 static int add_pw_multi_aff_from_domain(__isl_take isl_set
*set
, void *user
)
2926 isl_union_pw_multi_aff
**upma
= user
;
2927 isl_pw_multi_aff
*pma
;
2929 pma
= isl_pw_multi_aff_from_domain(set
);
2930 *upma
= isl_union_pw_multi_aff_add_pw_multi_aff(*upma
, pma
);
2935 /* Return an isl_union_pw_multi_aff with the given "uset" as domain and
2936 * an unnamed zero-dimensional range.
2938 __isl_give isl_union_pw_multi_aff
*isl_union_pw_multi_aff_from_domain(
2939 __isl_take isl_union_set
*uset
)
2942 isl_union_pw_multi_aff
*upma
;
2947 space
= isl_union_set_get_space(uset
);
2948 upma
= isl_union_pw_multi_aff_empty(space
);
2950 if (isl_union_set_foreach_set(uset
,
2951 &add_pw_multi_aff_from_domain
, &upma
) < 0)
2954 isl_union_set_free(uset
);
2957 isl_union_set_free(uset
);
2958 isl_union_pw_multi_aff_free(upma
);
2962 /* Convert "pma" to an isl_map and add it to *umap.
2964 static int map_from_pw_multi_aff(__isl_take isl_pw_multi_aff
*pma
, void *user
)
2966 isl_union_map
**umap
= user
;
2969 map
= isl_map_from_pw_multi_aff(pma
);
2970 *umap
= isl_union_map_add_map(*umap
, map
);
2975 /* Construct a union map mapping the domain of the union
2976 * piecewise multi-affine expression to its range, with each dimension
2977 * in the range equated to the corresponding affine expression on its cell.
2979 __isl_give isl_union_map
*isl_union_map_from_union_pw_multi_aff(
2980 __isl_take isl_union_pw_multi_aff
*upma
)
2983 isl_union_map
*umap
;
2988 space
= isl_union_pw_multi_aff_get_space(upma
);
2989 umap
= isl_union_map_empty(space
);
2991 if (isl_union_pw_multi_aff_foreach_pw_multi_aff(upma
,
2992 &map_from_pw_multi_aff
, &umap
) < 0)
2995 isl_union_pw_multi_aff_free(upma
);
2998 isl_union_pw_multi_aff_free(upma
);
2999 isl_union_map_free(umap
);
3003 /* Local data for bin_entry and the callback "fn".
3005 struct isl_union_pw_multi_aff_bin_data
{
3006 isl_union_pw_multi_aff
*upma2
;
3007 isl_union_pw_multi_aff
*res
;
3008 isl_pw_multi_aff
*pma
;
3009 int (*fn
)(void **entry
, void *user
);
3012 /* Given an isl_pw_multi_aff from upma1, store it in data->pma
3013 * and call data->fn for each isl_pw_multi_aff in data->upma2.
3015 static int bin_entry(void **entry
, void *user
)
3017 struct isl_union_pw_multi_aff_bin_data
*data
= user
;
3018 isl_pw_multi_aff
*pma
= *entry
;
3021 if (isl_hash_table_foreach(data
->upma2
->dim
->ctx
, &data
->upma2
->table
,
3022 data
->fn
, data
) < 0)
3028 /* Call "fn" on each pair of isl_pw_multi_affs in "upma1" and "upma2".
3029 * The isl_pw_multi_aff from upma1 is stored in data->pma (where data is
3030 * passed as user field) and the isl_pw_multi_aff from upma2 is available
3031 * as *entry. The callback should adjust data->res if desired.
3033 static __isl_give isl_union_pw_multi_aff
*bin_op(
3034 __isl_take isl_union_pw_multi_aff
*upma1
,
3035 __isl_take isl_union_pw_multi_aff
*upma2
,
3036 int (*fn
)(void **entry
, void *user
))
3039 struct isl_union_pw_multi_aff_bin_data data
= { NULL
, NULL
, NULL
, fn
};
3041 space
= isl_union_pw_multi_aff_get_space(upma2
);
3042 upma1
= isl_union_pw_multi_aff_align_params(upma1
, space
);
3043 space
= isl_union_pw_multi_aff_get_space(upma1
);
3044 upma2
= isl_union_pw_multi_aff_align_params(upma2
, space
);
3046 if (!upma1
|| !upma2
)
3050 data
.res
= isl_union_pw_multi_aff_alloc(isl_space_copy(upma1
->dim
),
3052 if (isl_hash_table_foreach(upma1
->dim
->ctx
, &upma1
->table
,
3053 &bin_entry
, &data
) < 0)
3056 isl_union_pw_multi_aff_free(upma1
);
3057 isl_union_pw_multi_aff_free(upma2
);
3060 isl_union_pw_multi_aff_free(upma1
);
3061 isl_union_pw_multi_aff_free(upma2
);
3062 isl_union_pw_multi_aff_free(data
.res
);
3066 /* Given two isl_multi_affs A -> B and C -> D,
3067 * construct an isl_multi_aff (A * C) -> (B, D).
3069 __isl_give isl_multi_aff
*isl_multi_aff_flat_range_product(
3070 __isl_take isl_multi_aff
*ma1
, __isl_take isl_multi_aff
*ma2
)
3080 space
= isl_space_range_product(isl_multi_aff_get_space(ma1
),
3081 isl_multi_aff_get_space(ma2
));
3082 space
= isl_space_flatten_range(space
);
3083 res
= isl_multi_aff_alloc(space
);
3085 n1
= isl_multi_aff_dim(ma1
, isl_dim_out
);
3086 n2
= isl_multi_aff_dim(ma2
, isl_dim_out
);
3088 for (i
= 0; i
< n1
; ++i
) {
3089 aff
= isl_multi_aff_get_aff(ma1
, i
);
3090 res
= isl_multi_aff_set_aff(res
, i
, aff
);
3093 for (i
= 0; i
< n2
; ++i
) {
3094 aff
= isl_multi_aff_get_aff(ma2
, i
);
3095 res
= isl_multi_aff_set_aff(res
, n1
+ i
, aff
);
3098 isl_multi_aff_free(ma1
);
3099 isl_multi_aff_free(ma2
);
3102 isl_multi_aff_free(ma1
);
3103 isl_multi_aff_free(ma2
);
3107 /* Given two aligned isl_pw_multi_affs A -> B and C -> D,
3108 * construct an isl_pw_multi_aff (A * C) -> (B, D).
3110 static __isl_give isl_pw_multi_aff
*pw_multi_aff_flat_range_product(
3111 __isl_take isl_pw_multi_aff
*pma1
, __isl_take isl_pw_multi_aff
*pma2
)
3115 space
= isl_space_range_product(isl_pw_multi_aff_get_space(pma1
),
3116 isl_pw_multi_aff_get_space(pma2
));
3117 space
= isl_space_flatten_range(space
);
3118 return isl_pw_multi_aff_on_shared_domain_in(pma1
, pma2
, space
,
3119 &isl_multi_aff_flat_range_product
);
3122 /* Given two isl_pw_multi_affs A -> B and C -> D,
3123 * construct an isl_pw_multi_aff (A * C) -> (B, D).
3125 __isl_give isl_pw_multi_aff
*isl_pw_multi_aff_flat_range_product(
3126 __isl_take isl_pw_multi_aff
*pma1
, __isl_take isl_pw_multi_aff
*pma2
)
3128 return isl_pw_multi_aff_align_params_pw_pw_and(pma1
, pma2
,
3129 &pw_multi_aff_flat_range_product
);
3132 /* If data->pma and *entry have the same domain space, then compute
3133 * their flat range product and the result to data->res.
3135 static int flat_range_product_entry(void **entry
, void *user
)
3137 struct isl_union_pw_multi_aff_bin_data
*data
= user
;
3138 isl_pw_multi_aff
*pma2
= *entry
;
3140 if (!isl_space_tuple_match(data
->pma
->dim
, isl_dim_in
,
3141 pma2
->dim
, isl_dim_in
))
3144 pma2
= isl_pw_multi_aff_flat_range_product(
3145 isl_pw_multi_aff_copy(data
->pma
),
3146 isl_pw_multi_aff_copy(pma2
));
3148 data
->res
= isl_union_pw_multi_aff_add_pw_multi_aff(data
->res
, pma2
);
3153 /* Given two isl_union_pw_multi_affs A -> B and C -> D,
3154 * construct an isl_union_pw_multi_aff (A * C) -> (B, D).
3156 __isl_give isl_union_pw_multi_aff
*isl_union_pw_multi_aff_flat_range_product(
3157 __isl_take isl_union_pw_multi_aff
*upma1
,
3158 __isl_take isl_union_pw_multi_aff
*upma2
)
3160 return bin_op(upma1
, upma2
, &flat_range_product_entry
);