X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=isl_map.c;h=c4636c146c83c2d370d27650c9c734d6eb9313cd;hb=de51a9bc4da5dd3f1f9f57c2362da6f9752c44e0;hp=8023814564b721d29b0591b168e469b981189f47;hpb=747237f4a946ad88d45822eb281dc70665b81a76;p=platform%2Fupstream%2Fisl.git diff --git a/isl_map.c b/isl_map.c index 8023814..c4636c1 100644 --- a/isl_map.c +++ b/isl_map.c @@ -1,13 +1,15 @@ /* * Copyright 2008-2009 Katholieke Universiteit Leuven * Copyright 2010 INRIA Saclay + * Copyright 2012 Ecole Normale Superieure * - * Use of this software is governed by the GNU LGPLv2.1 license + * Use of this software is governed by the MIT license * * Written by Sven Verdoolaege, K.U.Leuven, Departement * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite, * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France + * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France */ #include @@ -122,6 +124,8 @@ unsigned isl_basic_set_n_param(__isl_keep isl_basic_set *bset) unsigned isl_basic_set_total_dim(const struct isl_basic_set *bset) { + if (!bset) + return 0; return isl_space_dim(bset->dim, isl_dim_all) + bset->n_div; } @@ -255,25 +259,42 @@ __isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_set *bset) return isl_space_copy(bset->dim); } -__isl_give isl_local_space *isl_basic_map_get_local_space( - __isl_keep isl_basic_map *bmap) +/* Extract the divs in "bmap" as a matrix. + */ +__isl_give isl_mat *isl_basic_map_get_divs(__isl_keep isl_basic_map *bmap) { int i; - isl_local_space *ls; + isl_ctx *ctx; + isl_mat *div; unsigned total; + unsigned cols; if (!bmap) return NULL; - total = isl_basic_map_total_dim(bmap); - ls = isl_local_space_alloc(isl_space_copy(bmap->dim), bmap->n_div); - if (!ls) + ctx = isl_basic_map_get_ctx(bmap); + total = isl_space_dim(bmap->dim, isl_dim_all); + cols = 1 + 1 + total + bmap->n_div; + div = isl_mat_alloc(ctx, bmap->n_div, cols); + if (!div) return NULL; for (i = 0; i < bmap->n_div; ++i) - isl_seq_cpy(ls->div->row[i], bmap->div[i], 2 + total); + isl_seq_cpy(div->row[i], bmap->div[i], cols); + + return div; +} + +__isl_give isl_local_space *isl_basic_map_get_local_space( + __isl_keep isl_basic_map *bmap) +{ + isl_mat *div; - return ls; + if (!bmap) + return NULL; + + div = isl_basic_map_get_divs(bmap); + return isl_local_space_alloc_div(isl_space_copy(bmap->dim), div); } __isl_give isl_local_space *isl_basic_set_get_local_space( @@ -387,6 +408,13 @@ error: return NULL; } +/* Does the input or output tuple have a name? + */ +int isl_map_has_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type) +{ + return map ? isl_space_has_tuple_name(map->dim, type) : -1; +} + const char *isl_map_get_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type) { @@ -455,6 +483,14 @@ __isl_give isl_id *isl_set_get_tuple_id(__isl_keep isl_set *set) return isl_map_get_tuple_id(set, isl_dim_set); } +/* Does the set tuple have a name? + */ +int isl_set_has_tuple_name(__isl_keep isl_set *set) +{ + return set ? isl_space_has_tuple_name(set->dim, isl_dim_set) : -1; +} + + const char *isl_basic_set_get_tuple_name(__isl_keep isl_basic_set *bset) { return bset ? isl_space_get_tuple_name(bset->dim, isl_dim_set) : NULL; @@ -477,6 +513,14 @@ const char *isl_basic_set_get_dim_name(__isl_keep isl_basic_set *bset, return bset ? isl_space_get_dim_name(bset->dim, type, pos) : NULL; } +/* Does the given dimension have a name? + */ +int isl_map_has_dim_name(__isl_keep isl_map *map, + enum isl_dim_type type, unsigned pos) +{ + return map ? isl_space_has_dim_name(map->dim, type, pos) : -1; +} + const char *isl_map_get_dim_name(__isl_keep isl_map *map, enum isl_dim_type type, unsigned pos) { @@ -507,7 +551,7 @@ __isl_give isl_basic_map *isl_basic_map_set_dim_name( bmap->dim = isl_space_set_dim_name(bmap->dim, type, pos, s); if (!bmap->dim) goto error; - return bmap; + return isl_basic_map_finalize(bmap); error: isl_basic_map_free(bmap); return NULL; @@ -558,6 +602,12 @@ int isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap, return bmap ? isl_space_has_dim_id(bmap->dim, type, pos) : -1; } +__isl_give isl_id *isl_basic_set_get_dim_id(__isl_keep isl_basic_set *bset, + enum isl_dim_type type, unsigned pos) +{ + return bset ? isl_space_get_dim_id(bset->dim, type, pos) : NULL; +} + int isl_map_has_dim_id(__isl_keep isl_map *map, enum isl_dim_type type, unsigned pos) { @@ -640,6 +690,76 @@ int isl_basic_set_is_rational(__isl_keep isl_basic_set *bset) return isl_basic_map_is_rational(bset); } +/* Does "bmap" contain any rational points? + * + * If "bmap" has an equality for each dimension, equating the dimension + * to an integer constant, then it has no rational points, even if it + * is marked as rational. + */ +int isl_basic_map_has_rational(__isl_keep isl_basic_map *bmap) +{ + int has_rational = 1; + unsigned total; + + if (!bmap) + return -1; + if (isl_basic_map_plain_is_empty(bmap)) + return 0; + if (!isl_basic_map_is_rational(bmap)) + return 0; + bmap = isl_basic_map_copy(bmap); + bmap = isl_basic_map_implicit_equalities(bmap); + if (!bmap) + return -1; + total = isl_basic_map_total_dim(bmap); + if (bmap->n_eq == total) { + int i, j; + for (i = 0; i < bmap->n_eq; ++i) { + j = isl_seq_first_non_zero(bmap->eq[i] + 1, total); + if (j < 0) + break; + if (!isl_int_is_one(bmap->eq[i][1 + j]) && + !isl_int_is_negone(bmap->eq[i][1 + j])) + break; + j = isl_seq_first_non_zero(bmap->eq[i] + 1 + j + 1, + total - j - 1); + if (j >= 0) + break; + } + if (i == bmap->n_eq) + has_rational = 0; + } + isl_basic_map_free(bmap); + + return has_rational; +} + +/* Does "map" contain any rational points? + */ +int isl_map_has_rational(__isl_keep isl_map *map) +{ + int i; + int has_rational; + + if (!map) + return -1; + for (i = 0; i < map->n; ++i) { + has_rational = isl_basic_map_has_rational(map->p[i]); + if (has_rational < 0) + return -1; + if (has_rational) + return 1; + } + return 0; +} + +/* Does "set" contain any rational points? + */ +int isl_set_has_rational(__isl_keep isl_set *set) +{ + return isl_map_has_rational(set); +} + /* Is this basic set a parameter domain? */ int isl_basic_set_is_params(__isl_keep isl_basic_set *bset) @@ -876,13 +996,13 @@ struct isl_map *isl_map_copy(struct isl_map *map) return map; } -void isl_basic_map_free(struct isl_basic_map *bmap) +void *isl_basic_map_free(__isl_take isl_basic_map *bmap) { if (!bmap) - return; + return NULL; if (--bmap->ref > 0) - return; + return NULL; isl_ctx_deref(bmap->ctx); free(bmap->div); @@ -892,11 +1012,13 @@ void isl_basic_map_free(struct isl_basic_map *bmap) isl_vec_free(bmap->sample); isl_space_free(bmap->dim); free(bmap); + + return NULL; } -void isl_basic_set_free(struct isl_basic_set *bset) +void *isl_basic_set_free(struct isl_basic_set *bset) { - isl_basic_map_free((struct isl_basic_map *)bset); + return isl_basic_map_free((struct isl_basic_map *)bset); } static int room_for_con(struct isl_basic_map *bmap, unsigned n) @@ -1023,6 +1145,13 @@ int isl_basic_set_drop_equality(struct isl_basic_set *bset, unsigned pos) return isl_basic_map_drop_equality((struct isl_basic_map *)bset, pos); } +/* Turn inequality "pos" of "bmap" into an equality. + * + * In particular, we move the inequality in front of the equalities + * and move the last inequality in the position of the moved inequality. + * Note that isl_tab_make_equalities_explicit depends on this particular + * change in the ordering of the constraints. + */ void isl_basic_map_inequality_to_equality( struct isl_basic_map *bmap, unsigned pos) { @@ -1498,6 +1627,9 @@ static __isl_give isl_basic_set *isl_basic_set_swap_vars( unsigned dim; unsigned nparam; + if (!bset) + return NULL; + nparam = isl_basic_set_n_param(bset); dim = isl_basic_set_n_dim(bset); isl_assert(bset->ctx, n <= dim, goto error); @@ -1561,8 +1693,8 @@ void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b) } /* Eliminate the specified n dimensions starting at first from the - * constraints using Fourier-Motzkin. The dimensions themselves - * are not removed. + * constraints, without removing the dimensions from the space. + * If the set is rational, the dimensions are eliminated using Fourier-Motzkin. */ __isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map, enum isl_dim_type type, unsigned first, unsigned n) @@ -1574,6 +1706,10 @@ __isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map, if (n == 0) return map; + if (first + n > isl_map_dim(map, type) || first + n < first) + isl_die(map->ctx, isl_error_invalid, + "index out of bounds", goto error); + map = isl_map_cow(map); if (!map) return NULL; @@ -1590,8 +1726,8 @@ error: } /* Eliminate the specified n dimensions starting at first from the - * constraints using Fourier-Motzkin. The dimensions themselves - * are not removed. + * constraints, without removing the dimensions from the space. + * If the set is rational, the dimensions are eliminated using Fourier-Motzkin. */ __isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set, enum isl_dim_type type, unsigned first, unsigned n) @@ -1600,8 +1736,8 @@ __isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set, } /* Eliminate the specified n dimensions starting at first from the - * constraints using Fourier-Motzkin. The dimensions themselves - * are not removed. + * constraints, without removing the dimensions from the space. + * If the set is rational, the dimensions are eliminated using Fourier-Motzkin. */ __isl_give isl_set *isl_set_eliminate_dims(__isl_take isl_set *set, unsigned first, unsigned n) @@ -1704,6 +1840,196 @@ static int div_involves_vars(__isl_keep isl_basic_map *bmap, int div, return 0; } +/* Try and add a lower and/or upper bound on "div" to "bmap" + * based on inequality "i". + * "total" is the total number of variables (excluding the divs). + * "v" is a temporary object that can be used during the calculations. + * If "lb" is set, then a lower bound should be constructed. + * If "ub" is set, then an upper bound should be constructed. + * + * The calling function has already checked that the inequality does not + * reference "div", but we still need to check that the inequality is + * of the right form. We'll consider the case where we want to construct + * a lower bound. The construction of upper bounds is similar. + * + * Let "div" be of the form + * + * q = floor((a + f(x))/d) + * + * We essentially check if constraint "i" is of the form + * + * b + f(x) >= 0 + * + * so that we can use it to derive a lower bound on "div". + * However, we allow a slightly more general form + * + * b + g(x) >= 0 + * + * with the condition that the coefficients of g(x) - f(x) are all + * divisible by d. + * Rewriting this constraint as + * + * 0 >= -b - g(x) + * + * adding a + f(x) to both sides and dividing by d, we obtain + * + * (a + f(x))/d >= (a-b)/d + (f(x)-g(x))/d + * + * Taking the floor on both sides, we obtain + * + * q >= floor((a-b)/d) + (f(x)-g(x))/d + * + * or + * + * (g(x)-f(x))/d + ceil((b-a)/d) + q >= 0 + * + * In the case of an upper bound, we construct the constraint + * + * (g(x)+f(x))/d + floor((b+a)/d) - q >= 0 + * + */ +static __isl_give isl_basic_map *insert_bounds_on_div_from_ineq( + __isl_take isl_basic_map *bmap, int div, int i, + unsigned total, isl_int v, int lb, int ub) +{ + int j; + + for (j = 0; (lb || ub) && j < total + bmap->n_div; ++j) { + if (lb) { + isl_int_sub(v, bmap->ineq[i][1 + j], + bmap->div[div][1 + 1 + j]); + lb = isl_int_is_divisible_by(v, bmap->div[div][0]); + } + if (ub) { + isl_int_add(v, bmap->ineq[i][1 + j], + bmap->div[div][1 + 1 + j]); + ub = isl_int_is_divisible_by(v, bmap->div[div][0]); + } + } + if (!lb && !ub) + return bmap; + + bmap = isl_basic_map_extend_constraints(bmap, 0, lb + ub); + if (lb) { + int k = isl_basic_map_alloc_inequality(bmap); + if (k < 0) + goto error; + for (j = 0; j < 1 + total + bmap->n_div; ++j) { + isl_int_sub(bmap->ineq[k][j], bmap->ineq[i][j], + bmap->div[div][1 + j]); + isl_int_cdiv_q(bmap->ineq[k][j], + bmap->ineq[k][j], bmap->div[div][0]); + } + isl_int_set_si(bmap->ineq[k][1 + total + div], 1); + } + if (ub) { + int k = isl_basic_map_alloc_inequality(bmap); + if (k < 0) + goto error; + for (j = 0; j < 1 + total + bmap->n_div; ++j) { + isl_int_add(bmap->ineq[k][j], bmap->ineq[i][j], + bmap->div[div][1 + j]); + isl_int_fdiv_q(bmap->ineq[k][j], + bmap->ineq[k][j], bmap->div[div][0]); + } + isl_int_set_si(bmap->ineq[k][1 + total + div], -1); + } + + return bmap; +error: + isl_basic_map_free(bmap); + return NULL; +} + +/* This function is called right before "div" is eliminated from "bmap" + * using Fourier-Motzkin. + * Look through the constraints of "bmap" for constraints on the argument + * of the integer division and use them to construct constraints on the + * integer division itself. These constraints can then be combined + * during the Fourier-Motzkin elimination. + * Note that it is only useful to introduce lower bounds on "div" + * if "bmap" already contains upper bounds on "div" as the newly + * introduce lower bounds can then be combined with the pre-existing + * upper bounds. Similarly for upper bounds. + * We therefore first check if "bmap" contains any lower and/or upper bounds + * on "div". + * + * It is interesting to note that the introduction of these constraints + * can indeed lead to more accurate results, even when compared to + * deriving constraints on the argument of "div" from constraints on "div". + * Consider, for example, the set + * + * { [i,j,k] : 3 + i + 2j >= 0 and 2 * [(i+2j)/4] <= k } + * + * The second constraint can be rewritten as + * + * 2 * [(-i-2j+3)/4] + k >= 0 + * + * from which we can derive + * + * -i - 2j + 3 >= -2k + * + * or + * + * i + 2j <= 3 + 2k + * + * Combined with the first constraint, we obtain + * + * -3 <= 3 + 2k or k >= -3 + * + * If, on the other hand we derive a constraint on [(i+2j)/4] from + * the first constraint, we obtain + * + * [(i + 2j)/4] >= [-3/4] = -1 + * + * Combining this constraint with the second constraint, we obtain + * + * k >= -2 + */ +static __isl_give isl_basic_map *insert_bounds_on_div( + __isl_take isl_basic_map *bmap, int div) +{ + int i; + int check_lb, check_ub; + isl_int v; + unsigned total; + + if (!bmap) + return NULL; + + if (isl_int_is_zero(bmap->div[div][0])) + return bmap; + + total = isl_space_dim(bmap->dim, isl_dim_all); + + check_lb = 0; + check_ub = 0; + for (i = 0; (!check_lb || !check_ub) && i < bmap->n_ineq; ++i) { + int s = isl_int_sgn(bmap->ineq[i][1 + total + div]); + if (s > 0) + check_ub = 1; + if (s < 0) + check_lb = 1; + } + + if (!check_lb && !check_ub) + return bmap; + + isl_int_init(v); + + for (i = 0; bmap && i < bmap->n_ineq; ++i) { + if (!isl_int_is_zero(bmap->ineq[i][1 + total + div])) + continue; + + bmap = insert_bounds_on_div_from_ineq(bmap, div, i, total, v, + check_lb, check_ub); + } + + isl_int_clear(v); + + return bmap; +} + /* Remove all divs (recursively) involving any of the given dimensions * in their definitions. */ @@ -1722,6 +2048,7 @@ __isl_give isl_basic_map *isl_basic_map_remove_divs_involving_dims( for (i = bmap->n_div - 1; i >= 0; --i) { if (!div_involves_vars(bmap, i, first, n)) continue; + bmap = insert_bounds_on_div(bmap, i); bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1); if (!bmap) return NULL; @@ -1734,6 +2061,13 @@ error: return NULL; } +__isl_give isl_basic_set *isl_basic_set_remove_divs_involving_dims( + __isl_take isl_basic_set *bset, + enum isl_dim_type type, unsigned first, unsigned n) +{ + return isl_basic_map_remove_divs_involving_dims(bset, type, first, n); +} + __isl_give isl_map *isl_map_remove_divs_involving_dims(__isl_take isl_map *map, enum isl_dim_type type, unsigned first, unsigned n) { @@ -1879,6 +2213,14 @@ __isl_give isl_basic_map *isl_basic_map_remove_unknown_divs( return bmap; } +/* Remove all divs that are unknown or defined in terms of unknown divs. + */ +__isl_give isl_basic_set *isl_basic_set_remove_unknown_divs( + __isl_take isl_basic_set *bset) +{ + return isl_basic_map_remove_unknown_divs(bset); +} + __isl_give isl_map *isl_map_remove_unknown_divs(__isl_take isl_map *map) { int i; @@ -2233,21 +2575,23 @@ __isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set, (struct isl_basic_map *)bset); } -void isl_set_free(struct isl_set *set) +void *isl_set_free(__isl_take isl_set *set) { int i; if (!set) - return; + return NULL; if (--set->ref > 0) - return; + return NULL; isl_ctx_deref(set->ctx); for (i = 0; i < set->n; ++i) isl_basic_set_free(set->p[i]); isl_space_free(set->dim); free(set); + + return NULL; } void isl_set_print_internal(struct isl_set *set, FILE *out, int indent) @@ -2524,18 +2868,20 @@ static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1, __isl_take isl_map *map2) { unsigned flags = 0; - struct isl_map *result; + isl_map *result; int i, j; if (!map1 || !map2) goto error; - if (isl_map_plain_is_empty(map1) && + if ((isl_map_plain_is_empty(map1) || + isl_map_plain_is_universe(map2)) && isl_space_is_equal(map1->dim, map2->dim)) { isl_map_free(map2); return map1; } - if (isl_map_plain_is_empty(map2) && + if ((isl_map_plain_is_empty(map2) || + isl_map_plain_is_universe(map1)) && isl_space_is_equal(map1->dim, map2->dim)) { isl_map_free(map1); return map2; @@ -2567,10 +2913,9 @@ static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1, part = isl_basic_map_intersect( isl_basic_map_copy(map1->p[i]), isl_basic_map_copy(map2->p[j])); - if (isl_basic_map_is_empty(part)) - isl_basic_map_free(part); - else - result = isl_map_add_basic_map(result, part); + if (isl_basic_map_is_empty(part) < 0) + part = isl_basic_map_free(part); + result = isl_map_add_basic_map(result, part); if (!result) goto error; } @@ -2655,6 +3000,8 @@ static __isl_give isl_basic_map *basic_map_space_reset( { isl_space *space; + if (!bmap) + return NULL; if (!isl_space_is_named_or_nested(bmap->dim, type)) return bmap; @@ -2664,8 +3011,9 @@ static __isl_give isl_basic_map *basic_map_space_reset( return bmap; } -__isl_give isl_basic_map *isl_basic_map_insert(__isl_take isl_basic_map *bmap, - enum isl_dim_type type, unsigned pos, unsigned n) +__isl_give isl_basic_map *isl_basic_map_insert_dims( + __isl_take isl_basic_map *bmap, enum isl_dim_type type, + unsigned pos, unsigned n) { isl_space *res_dim; struct isl_basic_map *res; @@ -2702,20 +3050,32 @@ __isl_give isl_basic_map *isl_basic_map_insert(__isl_take isl_basic_map *bmap, bmap->n_div, bmap->n_eq, bmap->n_ineq); if (isl_basic_map_is_rational(bmap)) res = isl_basic_map_set_rational(res); + if (isl_basic_map_plain_is_empty(bmap)) { + isl_basic_map_free(bmap); + free(dim_map); + return isl_basic_map_set_to_empty(res); + } res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map); return isl_basic_map_finalize(res); } +__isl_give isl_basic_set *isl_basic_set_insert_dims( + __isl_take isl_basic_set *bset, + enum isl_dim_type type, unsigned pos, unsigned n) +{ + return isl_basic_map_insert_dims(bset, type, pos, n); +} + __isl_give isl_basic_map *isl_basic_map_add(__isl_take isl_basic_map *bmap, enum isl_dim_type type, unsigned n) { if (!bmap) return NULL; - return isl_basic_map_insert(bmap, type, + return isl_basic_map_insert_dims(bmap, type, isl_basic_map_dim(bmap, type), n); } -__isl_give isl_basic_set *isl_basic_set_add(__isl_take isl_basic_set *bset, +__isl_give isl_basic_set *isl_basic_set_add_dims(__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned n) { if (!bset) @@ -2758,7 +3118,7 @@ __isl_give isl_map *isl_map_insert_dims(__isl_take isl_map *map, goto error; for (i = 0; i < map->n; ++i) { - map->p[i] = isl_basic_map_insert(map->p[i], type, pos, n); + map->p[i] = isl_basic_map_insert_dims(map->p[i], type, pos, n); if (!map->p[i]) goto error; } @@ -2868,6 +3228,8 @@ __isl_give isl_basic_map *isl_basic_map_move_dims( res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap), bmap->n_div, bmap->n_eq, bmap->n_ineq); bmap = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map); + if (!bmap) + goto error; bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos, src_type, src_pos, n); @@ -3913,6 +4275,11 @@ int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div) bmap->div[div]); } +int isl_basic_set_add_div_constraints(struct isl_basic_set *bset, unsigned div) +{ + return isl_basic_map_add_div_constraints(bset, div); +} + struct isl_basic_set *isl_basic_map_underlying_set( struct isl_basic_map *bmap) { @@ -3934,6 +4301,7 @@ struct isl_basic_set *isl_basic_map_underlying_set( bmap = isl_basic_map_finalize(bmap); return (struct isl_basic_set *)bmap; error: + isl_basic_map_free(bmap); return NULL; } @@ -3996,10 +4364,12 @@ struct isl_basic_map *isl_basic_map_overlying_set( bmap = isl_basic_map_extend_constraints(bmap, 0, 2 * like->n_div); for (i = 0; i < like->n_div; ++i) { + if (!bmap) + break; if (isl_int_is_zero(bmap->div[i][0])) continue; if (isl_basic_map_add_div_constraints(bmap, i) < 0) - goto error; + bmap = isl_basic_map_free(bmap); } } isl_basic_map_free(like); @@ -4167,6 +4537,18 @@ __isl_give isl_basic_set *isl_basic_set_params(__isl_take isl_basic_set *bset) return bset; } +/* Construct a zero-dimensional basic set with the given parameter domain. + */ +__isl_give isl_basic_set *isl_basic_set_from_params( + __isl_take isl_basic_set *bset) +{ + isl_space *space; + space = isl_basic_set_get_space(bset); + space = isl_space_set_from_params(space); + bset = isl_basic_set_reset_space(bset, space); + return bset; +} + /* Compute the parameter domain of the given set. */ __isl_give isl_set *isl_set_params(__isl_take isl_set *set) @@ -4792,21 +5174,23 @@ error: return NULL; } -void isl_map_free(struct isl_map *map) +void *isl_map_free(struct isl_map *map) { int i; if (!map) - return; + return NULL; if (--map->ref > 0) - return; + return NULL; isl_ctx_deref(map->ctx); for (i = 0; i < map->n; ++i) isl_basic_map_free(map->p[i]); isl_space_free(map->dim); free(map); + + return NULL; } struct isl_map *isl_map_extend(struct isl_map *base, @@ -5061,6 +5445,15 @@ __isl_give isl_basic_map *isl_basic_map_lower_bound_si( return basic_map_bound_si(bmap, type, pos, value, 0); } +/* Constrain the values of the given dimension to be no greater than "value". + */ +__isl_give isl_basic_map *isl_basic_map_upper_bound_si( + __isl_take isl_basic_map *bmap, + enum isl_dim_type type, unsigned pos, int value) +{ + return basic_map_bound_si(bmap, type, pos, value, 1); +} + struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset, unsigned dim, isl_int value) { @@ -5359,58 +5752,93 @@ __isl_give isl_pw_multi_aff *isl_basic_map_lexmin_pw_multi_aff( return isl_basic_map_lexopt_pw_multi_aff(bmap, 0); } -/* Given a basic map "bmap", compute the lexicographically minimal - * (or maximal) image element for each domain element in dom. +#undef TYPE +#define TYPE isl_pw_multi_aff +#undef SUFFIX +#define SUFFIX _pw_multi_aff +#undef EMPTY +#define EMPTY isl_pw_multi_aff_empty +#undef ADD +#define ADD isl_pw_multi_aff_union_add +#include "isl_map_lexopt_templ.c" + +/* Given a map "map", compute the lexicographically minimal + * (or maximal) image element for each domain element in dom, + * in the form of an isl_pw_multi_aff. * Set *empty to those elements in dom that do not have an image element. * - * We first make sure the basic sets in dom are disjoint and then - * simply collect the results over each of the basic sets separately. - * We could probably improve the efficiency a bit by moving the union - * domain down into the parametric integer programming. + * We first compute the lexicographically minimal or maximal element + * in the first basic map. This results in a partial solution "res" + * and a subset "todo" of dom that still need to be handled. + * We then consider each of the remaining maps in "map" and successively + * update both "res" and "todo". */ -static __isl_give isl_map *basic_map_partial_lexopt( - __isl_take isl_basic_map *bmap, __isl_take isl_set *dom, - __isl_give isl_set **empty, int max) +static __isl_give isl_pw_multi_aff *isl_map_partial_lexopt_aligned_pw_multi_aff( + __isl_take isl_map *map, __isl_take isl_set *dom, + __isl_give isl_set **empty, int max) { int i; - struct isl_map *res; + isl_pw_multi_aff *res; + isl_set *todo; - dom = isl_set_make_disjoint(dom); - if (!dom) + if (!map || !dom) goto error; - if (isl_set_plain_is_empty(dom)) { - res = isl_map_empty_like_basic_map(bmap); - *empty = isl_set_empty_like(dom); - isl_set_free(dom); - isl_basic_map_free(bmap); - return res; - } - - res = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap), - isl_basic_set_copy(dom->p[0]), empty, max); - - for (i = 1; i < dom->n; ++i) { - struct isl_map *res_i; - struct isl_set *empty_i; + if (isl_map_plain_is_empty(map)) { + if (empty) + *empty = dom; + else + isl_set_free(dom); + return isl_pw_multi_aff_from_map(map); + } - res_i = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap), - isl_basic_set_copy(dom->p[i]), &empty_i, max); + res = basic_map_partial_lexopt_pw_multi_aff( + isl_basic_map_copy(map->p[0]), + isl_set_copy(dom), &todo, max); - res = isl_map_union_disjoint(res, res_i); - *empty = isl_set_union_disjoint(*empty, empty_i); + for (i = 1; i < map->n; ++i) { + isl_pw_multi_aff *res_i; + isl_set *todo_i; + + res_i = basic_map_partial_lexopt_pw_multi_aff( + isl_basic_map_copy(map->p[i]), + isl_set_copy(dom), &todo_i, max); + + if (max) + res = isl_pw_multi_aff_union_lexmax(res, res_i); + else + res = isl_pw_multi_aff_union_lexmin(res, res_i); + + todo = isl_set_intersect(todo, todo_i); } isl_set_free(dom); - isl_basic_map_free(bmap); + isl_map_free(map); + + if (empty) + *empty = todo; + else + isl_set_free(todo); + return res; error: - *empty = NULL; + if (empty) + *empty = NULL; isl_set_free(dom); - isl_basic_map_free(bmap); + isl_map_free(map); return NULL; } +#undef TYPE +#define TYPE isl_map +#undef SUFFIX +#define SUFFIX +#undef EMPTY +#define EMPTY isl_map_empty +#undef ADD +#define ADD isl_map_union_disjoint +#include "isl_map_lexopt_templ.c" + /* Given a map "map", compute the lexicographically minimal * (or maximal) image element for each domain element in dom. * Set *empty to those elements in dom that do not have an image element. @@ -5419,7 +5847,7 @@ error: * in the first basic map. This results in a partial solution "res" * and a subset "todo" of dom that still need to be handled. * We then consider each of the remaining maps in "map" and successively - * improve both "res" and "todo". + * update both "res" and "todo". * * Let res^k and todo^k be the results after k steps and let i = k + 1. * Assume we are computing the lexicographical maximum. @@ -5538,35 +5966,6 @@ error: return NULL; } -/* Given a map "map", compute the lexicographically minimal - * (or maximal) image element for each domain element in dom. - * Set *empty to those elements in dom that do not have an image element. - * - * Align parameters if needed and then call isl_map_partial_lexopt_aligned. - */ -static __isl_give isl_map *isl_map_partial_lexopt( - __isl_take isl_map *map, __isl_take isl_set *dom, - __isl_give isl_set **empty, int max) -{ - if (!map || !dom) - goto error; - if (isl_space_match(map->dim, isl_dim_param, dom->dim, isl_dim_param)) - return isl_map_partial_lexopt_aligned(map, dom, empty, max); - if (!isl_space_has_named_params(map->dim) || - !isl_space_has_named_params(dom->dim)) - isl_die(map->ctx, isl_error_invalid, - "unaligned unnamed parameters", goto error); - map = isl_map_align_params(map, isl_map_get_space(dom)); - dom = isl_map_align_params(dom, isl_map_get_space(map)); - return isl_map_partial_lexopt_aligned(map, dom, empty, max); -error: - if (empty) - *empty = NULL; - isl_set_free(dom); - isl_map_free(map); - return NULL; -} - __isl_give isl_map *isl_map_partial_lexmax( __isl_take isl_map *map, __isl_take isl_set *dom, __isl_give isl_set **empty) @@ -5634,31 +6033,6 @@ __isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset) return (isl_set *)isl_basic_map_lexmax((isl_basic_map *)bset); } -__isl_give isl_map *isl_map_lexopt(__isl_take isl_map *map, int max) -{ - struct isl_set *dom = NULL; - isl_space *dom_dim; - - if (!map) - goto error; - dom_dim = isl_space_domain(isl_space_copy(map->dim)); - dom = isl_set_universe(dom_dim); - return isl_map_partial_lexopt(map, dom, NULL, max); -error: - isl_map_free(map); - return NULL; -} - -__isl_give isl_map *isl_map_lexmin(__isl_take isl_map *map) -{ - return isl_map_lexopt(map, 0); -} - -__isl_give isl_map *isl_map_lexmax(__isl_take isl_map *map) -{ - return isl_map_lexopt(map, 1); -} - __isl_give isl_set *isl_set_lexmin(__isl_take isl_set *set) { return (isl_set *)isl_map_lexmin((isl_map *)set); @@ -5682,6 +6056,8 @@ static int update_dim_opt(__isl_take isl_basic_set *dom, isl_pw_aff **pwaff = user; isl_pw_aff *pwaff_i; + if (!list) + goto error; if (isl_aff_list_n_aff(list) != 1) isl_die(ctx, isl_error_internal, "expecting single element list", goto error); @@ -5965,7 +6341,11 @@ static struct isl_set *parameter_compute_divs(struct isl_basic_set *bset) if (bset->n_eq == 0) return isl_basic_set_lexmin(bset); - isl_basic_set_gauss(bset, NULL); + bset = isl_basic_set_gauss(bset, NULL); + if (!bset) + return NULL; + if (isl_basic_set_plain_is_empty(bset)) + return isl_set_from_basic_set(bset); nparam = isl_basic_set_dim(bset, isl_dim_param); n_div = isl_basic_set_dim(bset, isl_dim_div); @@ -6177,12 +6557,23 @@ error: return NULL; } +/* Return the union of "map1" and "map2", where we assume for now that + * "map1" and "map2" are disjoint. Note that the basic maps inside + * "map1" or "map2" may not be disjoint from each other. + * Also note that this function is also called from isl_map_union, + * which takes care of handling the situation where "map1" and "map2" + * may not be disjoint. + * + * If one of the inputs is empty, we can simply return the other input. + * Similarly, if one of the inputs is universal, then it is equal to the union. + */ static __isl_give isl_map *map_union_disjoint(__isl_take isl_map *map1, __isl_take isl_map *map2) { int i; unsigned flags = 0; struct isl_map *map = NULL; + int is_universe; if (!map1 || !map2) goto error; @@ -6196,6 +6587,22 @@ static __isl_give isl_map *map_union_disjoint(__isl_take isl_map *map1, return map1; } + is_universe = isl_map_plain_is_universe(map1); + if (is_universe < 0) + goto error; + if (is_universe) { + isl_map_free(map2); + return map1; + } + + is_universe = isl_map_plain_is_universe(map2); + if (is_universe < 0) + goto error; + if (is_universe) { + isl_map_free(map1); + return map2; + } + isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error); if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) && @@ -6258,25 +6665,20 @@ struct isl_set *isl_set_union(struct isl_set *set1, struct isl_set *set2) isl_map_union((struct isl_map *)set1, (struct isl_map *)set2); } -static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map, - __isl_take isl_set *set) +/* Apply "fn" to pairs of elements from "map" and "set" and collect + * the results. + * + * "map" and "set" are assumed to be compatible and non-NULL. + */ +static __isl_give isl_map *map_intersect_set(__isl_take isl_map *map, + __isl_take isl_set *set, + __isl_give isl_basic_map *fn(__isl_take isl_basic_map *bmap, + __isl_take isl_basic_set *bset)) { unsigned flags = 0; struct isl_map *result; int i, j; - if (!map || !set) - goto error; - - if (!isl_space_match(map->dim, isl_dim_param, set->dim, isl_dim_param)) - isl_die(set->ctx, isl_error_invalid, - "parameters don't match", goto error); - - if (isl_space_dim(set->dim, isl_dim_set) != 0 && - !isl_map_compatible_range(map, set)) - isl_die(set->ctx, isl_error_invalid, - "incompatible spaces", goto error); - if (isl_set_plain_is_universe(set)) { isl_set_free(set); return map; @@ -6288,20 +6690,31 @@ static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map, result = isl_map_alloc_space(isl_space_copy(map->dim), map->n * set->n, flags); - if (!result) - goto error; - for (i = 0; i < map->n; ++i) + for (i = 0; result && i < map->n; ++i) for (j = 0; j < set->n; ++j) { result = isl_map_add_basic_map(result, - isl_basic_map_intersect_range( - isl_basic_map_copy(map->p[i]), - isl_basic_set_copy(set->p[j]))); + fn(isl_basic_map_copy(map->p[i]), + isl_basic_set_copy(set->p[j]))); if (!result) - goto error; + break; } + isl_map_free(map); isl_set_free(set); return result; +} + +static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map, + __isl_take isl_set *set) +{ + if (!map || !set) + goto error; + + if (!isl_map_compatible_range(map, set)) + isl_die(set->ctx, isl_error_invalid, + "incompatible spaces", goto error); + + return map_intersect_set(map, set, &isl_basic_map_intersect_range); error: isl_map_free(map); isl_set_free(set); @@ -6314,11 +6727,28 @@ __isl_give isl_map *isl_map_intersect_range(__isl_take isl_map *map, return isl_map_align_params_map_map_and(map, set, &map_intersect_range); } -struct isl_map *isl_map_intersect_domain( - struct isl_map *map, struct isl_set *set) +static __isl_give isl_map *map_intersect_domain(__isl_take isl_map *map, + __isl_take isl_set *set) +{ + if (!map || !set) + goto error; + + if (!isl_map_compatible_domain(map, set)) + isl_die(set->ctx, isl_error_invalid, + "incompatible spaces", goto error); + + return map_intersect_set(map, set, &isl_basic_map_intersect_domain); +error: + isl_map_free(map); + isl_set_free(set); + return NULL; +} + +__isl_give isl_map *isl_map_intersect_domain(__isl_take isl_map *map, + __isl_take isl_set *set) { - return isl_map_reverse( - isl_map_intersect_range(isl_map_reverse(map), set)); + return isl_map_align_params_map_map_and(map, set, + &map_intersect_domain); } static __isl_give isl_map *map_apply_domain(__isl_take isl_map *map1, @@ -6411,8 +6841,10 @@ struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap) for (i = 0; i < dim; ++i) { int j = isl_basic_map_alloc_equality( (struct isl_basic_map *)bset); - if (j < 0) - goto error; + if (j < 0) { + bset = isl_basic_set_free(bset); + break; + } isl_seq_clr(bset->eq[j], 1 + isl_basic_set_total_dim(bset)); isl_int_set_si(bset->eq[j][1+nparam+i], 1); isl_int_set_si(bset->eq[j][1+nparam+dim+i], 1); @@ -6429,7 +6861,7 @@ error: /* * returns range - domain */ -struct isl_set *isl_map_deltas(struct isl_map *map) +__isl_give isl_set *isl_map_deltas(__isl_take isl_map *map) { int i; isl_space *dim; @@ -6537,7 +6969,7 @@ error: return NULL; } -__isl_give struct isl_basic_map *basic_map_identity(__isl_take isl_space *dims) +static __isl_give isl_basic_map *basic_map_identity(__isl_take isl_space *dims) { struct isl_basic_map *bmap; unsigned nparam; @@ -6999,10 +7431,13 @@ int isl_basic_map_is_empty(struct isl_basic_map *bmap) if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY)) return 1; + if (isl_basic_map_is_universe(bmap)) + return 0; + if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) { struct isl_basic_map *copy = isl_basic_map_copy(bmap); copy = isl_basic_map_remove_redundancies(copy); - empty = ISL_F_ISSET(copy, ISL_BASIC_MAP_EMPTY); + empty = isl_basic_map_plain_is_empty(copy); isl_basic_map_free(copy); return empty; } @@ -7158,11 +7593,11 @@ __isl_give isl_basic_set *isl_basic_set_expand_divs( isl_die(isl_mat_get_ctx(div), isl_error_invalid, "not an expansion", goto error); + n_div = bset->n_div; bset = isl_basic_map_extend_space(bset, isl_space_copy(bset->dim), - div->n_row - bset->n_div, 0, - 2 * (div->n_row - bset->n_div)); + div->n_row - n_div, 0, + 2 * (div->n_row - n_div)); - n_div = bset->n_div; for (i = n_div; i < div->n_row; ++i) if (isl_basic_set_alloc_div(bset) < 0) goto error; @@ -7214,7 +7649,7 @@ struct isl_basic_map *isl_basic_map_align_divs( struct isl_basic_map *dst, struct isl_basic_map *src) { int i; - unsigned total = isl_space_dim(src->dim, isl_dim_all); + unsigned total; if (!dst || !src) goto error; @@ -7231,6 +7666,7 @@ struct isl_basic_map *isl_basic_map_align_divs( src->n_div, 0, 2 * src->n_div); if (!dst) return NULL; + total = isl_space_dim(src->dim, isl_dim_all); for (i = 0; i < src->n_div; ++i) { int j = find_div(dst, src, i); if (j < 0) { @@ -7418,19 +7854,20 @@ static enum isl_lp_result basic_set_maximal_difference_at( total = isl_basic_map_total_dim(bmap1); ctx = bmap1->ctx; obj = isl_vec_alloc(ctx, 1 + total); + if (!obj) + goto error2; isl_seq_clr(obj->block.data, 1 + total); isl_int_set_si(obj->block.data[1+nparam+pos], 1); isl_int_set_si(obj->block.data[1+nparam+pos+(dim1-pos)], -1); - if (!obj) - goto error; res = isl_basic_map_solve_lp(bmap1, 1, obj->block.data, ctx->one, opt, NULL, NULL); isl_basic_map_free(bmap1); isl_vec_free(obj); return res; error: - isl_basic_map_free(bmap1); isl_basic_map_free(bmap2); +error2: + isl_basic_map_free(bmap1); return isl_lp_error; } @@ -7768,13 +8205,13 @@ static int qsort_constraint_cmp(const void *p1, const void *p2) int l1, l2; unsigned size = isl_min(c1->size, c2->size); - l1 = isl_seq_last_non_zero(c1->c, size); - l2 = isl_seq_last_non_zero(c2->c, size); + l1 = isl_seq_last_non_zero(c1->c + 1, size); + l2 = isl_seq_last_non_zero(c2->c + 1, size); if (l1 != l2) return l1 - l2; - return isl_seq_cmp(c1->c, c2->c, size); + return isl_seq_cmp(c1->c + 1, c2->c + 1, size); } static struct isl_basic_map *isl_basic_map_sort_constraints( @@ -7819,7 +8256,8 @@ struct isl_basic_map *isl_basic_map_normalize(struct isl_basic_map *bmap) return bmap; bmap = isl_basic_map_remove_redundancies(bmap); bmap = isl_basic_map_sort_constraints(bmap); - ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED); + if (bmap) + ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED); return bmap; } @@ -7884,8 +8322,7 @@ int isl_basic_set_plain_cmp(const __isl_keep isl_basic_set *bset1, return isl_basic_map_plain_cmp(bset1, bset2); } -int isl_set_plain_cmp(const __isl_keep isl_set *set1, - const __isl_keep isl_set *set2) +int isl_set_plain_cmp(__isl_keep isl_set *set1, __isl_keep isl_set *set2) { int i, cmp; @@ -8218,6 +8655,11 @@ __isl_give isl_basic_map *isl_basic_map_range_product( if (!bmap1 || !bmap2) goto error; + if (!isl_space_match(bmap1->dim, isl_dim_param, + bmap2->dim, isl_dim_param)) + isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid, + "parameters don't match", goto error); + dim_result = isl_space_range_product(isl_space_copy(bmap1->dim), isl_space_copy(bmap2->dim)); @@ -8785,7 +9227,9 @@ int isl_set_dim_is_bounded(__isl_keep isl_set *set, return isl_map_dim_is_bounded((isl_map *)set, type, pos); } -static int has_bound(__isl_keep isl_map *map, +/* Does "map" have a bound (according to "fn") for any of its basic maps? + */ +static int has_any_bound(__isl_keep isl_map *map, enum isl_dim_type type, unsigned pos, int (*fn)(__isl_keep isl_basic_map *bmap, enum isl_dim_type type, unsigned pos)) @@ -8807,13 +9251,53 @@ static int has_bound(__isl_keep isl_map *map, /* Return 1 if the specified dim is involved in any lower bound. */ +int isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set, + enum isl_dim_type type, unsigned pos) +{ + return has_any_bound(set, type, pos, + &isl_basic_map_dim_has_lower_bound); +} + +/* Return 1 if the specified dim is involved in any upper bound. + */ +int isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set, + enum isl_dim_type type, unsigned pos) +{ + return has_any_bound(set, type, pos, + &isl_basic_map_dim_has_upper_bound); +} + +/* Does "map" have a bound (according to "fn") for all of its basic maps? + */ +static int has_bound(__isl_keep isl_map *map, + enum isl_dim_type type, unsigned pos, + int (*fn)(__isl_keep isl_basic_map *bmap, + enum isl_dim_type type, unsigned pos)) +{ + int i; + + if (!map) + return -1; + + for (i = 0; i < map->n; ++i) { + int bounded; + bounded = fn(map->p[i], type, pos); + if (bounded < 0 || !bounded) + return bounded; + } + + return 1; +} + +/* Return 1 if the specified dim has a lower bound (in each of its basic sets). + */ int isl_set_dim_has_lower_bound(__isl_keep isl_set *set, enum isl_dim_type type, unsigned pos) { return has_bound(set, type, pos, &isl_basic_map_dim_has_lower_bound); } -/* Return 1 if the specified dim is involved in any upper bound. +/* Return 1 if the specified dim has an upper bound (in each of its basic sets). */ int isl_set_dim_has_upper_bound(__isl_keep isl_set *set, enum isl_dim_type type, unsigned pos) @@ -8931,6 +9415,39 @@ int isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap) return 1; } +/* Check if the given basic map is single-valued. + * We simply compute + * + * M \circ M^-1 + * + * and check if the result is a subset of the identity mapping. + */ +int isl_basic_map_is_single_valued(__isl_keep isl_basic_map *bmap) +{ + isl_space *space; + isl_basic_map *test; + isl_basic_map *id; + int sv; + + sv = isl_basic_map_plain_is_single_valued(bmap); + if (sv < 0 || sv) + return sv; + + test = isl_basic_map_reverse(isl_basic_map_copy(bmap)); + test = isl_basic_map_apply_range(test, isl_basic_map_copy(bmap)); + + space = isl_basic_map_get_space(bmap); + space = isl_space_map_from_set(isl_space_range(space)); + id = isl_basic_map_identity(space); + + sv = isl_basic_map_is_subset(test, id); + + isl_basic_map_free(test); + isl_basic_map_free(id); + + return sv; +} + /* Check if the given map is obviously single-valued. */ int isl_map_plain_is_single_valued(__isl_keep isl_map *map) @@ -9552,6 +10069,60 @@ __isl_give isl_set *isl_set_align_params(__isl_take isl_set *set, return isl_map_align_params(set, model); } +/* Align the parameters of "bmap" to those of "model", introducing + * additional parameters if needed. + */ +__isl_give isl_basic_map *isl_basic_map_align_params( + __isl_take isl_basic_map *bmap, __isl_take isl_space *model) +{ + isl_ctx *ctx; + + if (!bmap || !model) + goto error; + + ctx = isl_space_get_ctx(model); + if (!isl_space_has_named_params(model)) + isl_die(ctx, isl_error_invalid, + "model has unnamed parameters", goto error); + if (!isl_space_has_named_params(bmap->dim)) + isl_die(ctx, isl_error_invalid, + "relation has unnamed parameters", goto error); + if (!isl_space_match(bmap->dim, isl_dim_param, model, isl_dim_param)) { + isl_reordering *exp; + struct isl_dim_map *dim_map; + + model = isl_space_drop_dims(model, isl_dim_in, + 0, isl_space_dim(model, isl_dim_in)); + model = isl_space_drop_dims(model, isl_dim_out, + 0, isl_space_dim(model, isl_dim_out)); + exp = isl_parameter_alignment_reordering(bmap->dim, model); + exp = isl_reordering_extend_space(exp, + isl_basic_map_get_space(bmap)); + dim_map = isl_dim_map_from_reordering(exp); + bmap = isl_basic_map_realign(bmap, + exp ? isl_space_copy(exp->dim) : NULL, + isl_dim_map_extend(dim_map, bmap)); + isl_reordering_free(exp); + free(dim_map); + } + + isl_space_free(model); + return bmap; +error: + isl_space_free(model); + isl_basic_map_free(bmap); + return NULL; +} + +/* Align the parameters of "bset" to those of "model", introducing + * additional parameters if needed. + */ +__isl_give isl_basic_set *isl_basic_set_align_params( + __isl_take isl_basic_set *bset, __isl_take isl_space *model) +{ + return isl_basic_map_align_params(bset, model); +} + __isl_give isl_mat *isl_basic_map_equalities_matrix( __isl_keep isl_basic_map *bmap, enum isl_dim_type c1, enum isl_dim_type c2, enum isl_dim_type c3, @@ -9749,6 +10320,7 @@ __isl_give isl_basic_map *isl_basic_map_zip(__isl_take isl_basic_map *bmap) isl_space_dim(bmap->dim->nested[0], isl_dim_in); n1 = isl_space_dim(bmap->dim->nested[0], isl_dim_out); n2 = isl_space_dim(bmap->dim->nested[1], isl_dim_in); + bmap = isl_basic_map_cow(bmap); bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2); if (!bmap) return NULL; @@ -9795,25 +10367,180 @@ error: return NULL; } -/* Construct a basic map mapping the domain of the affine expression - * to a one-dimensional range prescribed by the affine expression. +/* Can we apply isl_basic_map_curry to "bmap"? + * That is, does it have a nested relation in its domain? */ -__isl_give isl_basic_map *isl_basic_map_from_aff(__isl_take isl_aff *aff) +int isl_basic_map_can_curry(__isl_keep isl_basic_map *bmap) { - int k; - int pos; - isl_local_space *ls; - isl_basic_map *bmap; - - if (!aff) - return NULL; + if (!bmap) + return -1; - ls = isl_aff_get_local_space(aff); - bmap = isl_basic_map_from_local_space(ls); - bmap = isl_basic_map_extend_constraints(bmap, 1, 0); - k = isl_basic_map_alloc_equality(bmap); - if (k < 0) - goto error; + return isl_space_can_curry(bmap->dim); +} + +/* Can we apply isl_map_curry to "map"? + * That is, does it have a nested relation in its domain? + */ +int isl_map_can_curry(__isl_keep isl_map *map) +{ + if (!map) + return -1; + + return isl_space_can_curry(map->dim); +} + +/* Given a basic map (A -> B) -> C, return the corresponding basic map + * A -> (B -> C). + */ +__isl_give isl_basic_map *isl_basic_map_curry(__isl_take isl_basic_map *bmap) +{ + + if (!bmap) + return NULL; + + if (!isl_basic_map_can_curry(bmap)) + isl_die(bmap->ctx, isl_error_invalid, + "basic map cannot be curried", goto error); + bmap = isl_basic_map_cow(bmap); + if (!bmap) + return NULL; + bmap->dim = isl_space_curry(bmap->dim); + if (!bmap->dim) + goto error; + return bmap; +error: + isl_basic_map_free(bmap); + return NULL; +} + +/* Given a map (A -> B) -> C, return the corresponding map + * A -> (B -> C). + */ +__isl_give isl_map *isl_map_curry(__isl_take isl_map *map) +{ + int i; + + if (!map) + return NULL; + + if (!isl_map_can_curry(map)) + isl_die(map->ctx, isl_error_invalid, "map cannot be curried", + goto error); + + map = isl_map_cow(map); + if (!map) + return NULL; + + for (i = 0; i < map->n; ++i) { + map->p[i] = isl_basic_map_curry(map->p[i]); + if (!map->p[i]) + goto error; + } + + map->dim = isl_space_curry(map->dim); + if (!map->dim) + goto error; + + return map; +error: + isl_map_free(map); + return NULL; +} + +/* Can we apply isl_basic_map_uncurry to "bmap"? + * That is, does it have a nested relation in its domain? + */ +int isl_basic_map_can_uncurry(__isl_keep isl_basic_map *bmap) +{ + if (!bmap) + return -1; + + return isl_space_can_uncurry(bmap->dim); +} + +/* Can we apply isl_map_uncurry to "map"? + * That is, does it have a nested relation in its domain? + */ +int isl_map_can_uncurry(__isl_keep isl_map *map) +{ + if (!map) + return -1; + + return isl_space_can_uncurry(map->dim); +} + +/* Given a basic map A -> (B -> C), return the corresponding basic map + * (A -> B) -> C. + */ +__isl_give isl_basic_map *isl_basic_map_uncurry(__isl_take isl_basic_map *bmap) +{ + + if (!bmap) + return NULL; + + if (!isl_basic_map_can_uncurry(bmap)) + isl_die(bmap->ctx, isl_error_invalid, + "basic map cannot be uncurried", + return isl_basic_map_free(bmap)); + bmap = isl_basic_map_cow(bmap); + if (!bmap) + return NULL; + bmap->dim = isl_space_uncurry(bmap->dim); + if (!bmap->dim) + return isl_basic_map_free(bmap); + return bmap; +} + +/* Given a map A -> (B -> C), return the corresponding map + * (A -> B) -> C. + */ +__isl_give isl_map *isl_map_uncurry(__isl_take isl_map *map) +{ + int i; + + if (!map) + return NULL; + + if (!isl_map_can_uncurry(map)) + isl_die(map->ctx, isl_error_invalid, "map cannot be uncurried", + return isl_map_free(map)); + + map = isl_map_cow(map); + if (!map) + return NULL; + + for (i = 0; i < map->n; ++i) { + map->p[i] = isl_basic_map_uncurry(map->p[i]); + if (!map->p[i]) + return isl_map_free(map); + } + + map->dim = isl_space_uncurry(map->dim); + if (!map->dim) + return isl_map_free(map); + + return map; +} + +/* Construct a basic map mapping the domain of the affine expression + * to a one-dimensional range prescribed by the affine expression. + */ +__isl_give isl_basic_map *isl_basic_map_from_aff(__isl_take isl_aff *aff) +{ + int k; + int pos; + isl_local_space *ls; + isl_basic_map *bmap; + + if (!aff) + return NULL; + + ls = isl_aff_get_local_space(aff); + bmap = isl_basic_map_from_local_space(ls); + bmap = isl_basic_map_extend_constraints(bmap, 1, 0); + k = isl_basic_map_alloc_equality(bmap); + if (k < 0) + goto error; pos = isl_basic_map_offset(bmap, isl_dim_out); isl_seq_cpy(bmap->eq[k], aff->v->el + 1, pos); @@ -9830,6 +10557,17 @@ error: return NULL; } +/* Construct a map mapping the domain of the affine expression + * to a one-dimensional range prescribed by the affine expression. + */ +__isl_give isl_map *isl_map_from_aff(__isl_take isl_aff *aff) +{ + isl_basic_map *bmap; + + bmap = isl_basic_map_from_aff(aff); + return isl_map_from_basic_map(bmap); +} + /* Construct a basic map mapping the domain the multi-affine expression * to its range, with each dimension in the range equated to the * corresponding affine expression. @@ -9867,6 +10605,18 @@ __isl_give isl_basic_map *isl_basic_map_from_multi_aff( return bmap; } +/* Construct a map mapping the domain the multi-affine expression + * to its range, with each dimension in the range equated to the + * corresponding affine expression. + */ +__isl_give isl_map *isl_map_from_multi_aff(__isl_take isl_multi_aff *maff) +{ + isl_basic_map *bmap; + + bmap = isl_basic_map_from_multi_aff(maff); + return isl_map_from_basic_map(bmap); +} + /* Construct a basic map mapping a domain in the given space to * to an n-dimensional range, with n the number of elements in the list, * where each coordinate in the range is prescribed by the @@ -9907,11 +10657,78 @@ __isl_give isl_set *isl_set_equate(__isl_take isl_set *set, return isl_map_equate(set, type1, pos1, type2, pos2); } +/* Construct a basic map where the given dimensions are equal to each other. + */ +static __isl_give isl_basic_map *equator(__isl_take isl_space *space, + enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2) +{ + isl_basic_map *bmap = NULL; + int i; + + if (!space) + return NULL; + + if (pos1 >= isl_space_dim(space, type1)) + isl_die(isl_space_get_ctx(space), isl_error_invalid, + "index out of bounds", goto error); + if (pos2 >= isl_space_dim(space, type2)) + isl_die(isl_space_get_ctx(space), isl_error_invalid, + "index out of bounds", goto error); + + if (type1 == type2 && pos1 == pos2) + return isl_basic_map_universe(space); + + bmap = isl_basic_map_alloc_space(isl_space_copy(space), 0, 1, 0); + i = isl_basic_map_alloc_equality(bmap); + if (i < 0) + goto error; + isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap)); + pos1 += isl_basic_map_offset(bmap, type1); + pos2 += isl_basic_map_offset(bmap, type2); + isl_int_set_si(bmap->eq[i][pos1], -1); + isl_int_set_si(bmap->eq[i][pos2], 1); + bmap = isl_basic_map_finalize(bmap); + isl_space_free(space); + return bmap; +error: + isl_space_free(space); + isl_basic_map_free(bmap); + return NULL; +} + +/* Add a constraint imposing that the given two dimensions are equal. + */ +__isl_give isl_basic_map *isl_basic_map_equate(__isl_take isl_basic_map *bmap, + enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2) +{ + isl_basic_map *eq; + + eq = equator(isl_basic_map_get_space(bmap), type1, pos1, type2, pos2); + + bmap = isl_basic_map_intersect(bmap, eq); + + return bmap; +} + /* Add a constraint imposing that the given two dimensions are equal. */ __isl_give isl_map *isl_map_equate(__isl_take isl_map *map, enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2) { + isl_basic_map *bmap; + + bmap = equator(isl_map_get_space(map), type1, pos1, type2, pos2); + + map = isl_map_intersect(map, isl_map_from_basic_map(bmap)); + + return map; +} + +/* Add a constraint imposing that the given two dimensions have opposite values. + */ +__isl_give isl_map *isl_map_oppose(__isl_take isl_map *map, + enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2) +{ isl_basic_map *bmap = NULL; int i; @@ -9932,7 +10749,7 @@ __isl_give isl_map *isl_map_equate(__isl_take isl_map *map, isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap)); pos1 += isl_basic_map_offset(bmap, type1); pos2 += isl_basic_map_offset(bmap, type2); - isl_int_set_si(bmap->eq[i][pos1], -1); + isl_int_set_si(bmap->eq[i][pos1], 1); isl_int_set_si(bmap->eq[i][pos2], 1); bmap = isl_basic_map_finalize(bmap); @@ -9945,9 +10762,41 @@ error: return NULL; } -/* Add a constraint imposing that the given two dimensions have opposite values. +/* Add a constraint imposing that the value of the first dimension is + * greater than or equal to that of the second. */ -__isl_give isl_map *isl_map_oppose(__isl_take isl_map *map, +__isl_give isl_basic_map *isl_basic_map_order_ge(__isl_take isl_basic_map *bmap, + enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2) +{ + isl_constraint *c; + isl_local_space *ls; + + if (!bmap) + return NULL; + + if (pos1 >= isl_basic_map_dim(bmap, type1)) + isl_die(bmap->ctx, isl_error_invalid, + "index out of bounds", return isl_basic_map_free(bmap)); + if (pos2 >= isl_basic_map_dim(bmap, type2)) + isl_die(bmap->ctx, isl_error_invalid, + "index out of bounds", return isl_basic_map_free(bmap)); + + if (type1 == type2 && pos1 == pos2) + return bmap; + + ls = isl_local_space_from_space(isl_basic_map_get_space(bmap)); + c = isl_inequality_alloc(ls); + c = isl_constraint_set_coefficient_si(c, type1, pos1, 1); + c = isl_constraint_set_coefficient_si(c, type2, pos2, -1); + bmap = isl_basic_map_add_constraint(bmap, c); + + return bmap; +} + +/* Add a constraint imposing that the value of the first dimension is + * greater than that of the second. + */ +__isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map, enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2) { isl_basic_map *bmap = NULL; @@ -9963,15 +10812,22 @@ __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map, isl_die(map->ctx, isl_error_invalid, "index out of bounds", goto error); - bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 1, 0); - i = isl_basic_map_alloc_equality(bmap); + if (type1 == type2 && pos1 == pos2) { + isl_space *space = isl_map_get_space(map); + isl_map_free(map); + return isl_map_empty(space); + } + + bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 0, 1); + i = isl_basic_map_alloc_inequality(bmap); if (i < 0) goto error; - isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap)); + isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap)); pos1 += isl_basic_map_offset(bmap, type1); pos2 += isl_basic_map_offset(bmap, type2); - isl_int_set_si(bmap->eq[i][pos1], 1); - isl_int_set_si(bmap->eq[i][pos2], 1); + isl_int_set_si(bmap->ineq[i][pos1], 1); + isl_int_set_si(bmap->ineq[i][pos2], -1); + isl_int_set_si(bmap->ineq[i][0], -1); bmap = isl_basic_map_finalize(bmap); map = isl_map_intersect(map, isl_map_from_basic_map(bmap)); @@ -9983,6 +10839,15 @@ error: return NULL; } +/* Add a constraint imposing that the value of the first dimension is + * smaller than that of the second. + */ +__isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map, + enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2) +{ + return isl_map_order_gt(map, type2, pos2, type1, pos1); +} + __isl_give isl_aff *isl_basic_map_get_div(__isl_keep isl_basic_map *bmap, int pos) { @@ -10030,6 +10895,10 @@ __isl_give isl_aff *isl_basic_set_get_div(__isl_keep isl_basic_set *bset, * are replaced by * * a f + d g + * + * We currently require that "subs" is an integral expression. + * Handling rational expressions may require us to add stride constraints + * as we do in isl_basic_set_preimage_multi_aff. */ __isl_give isl_basic_set *isl_basic_set_substitute( __isl_take isl_basic_set *bset, @@ -10053,6 +10922,9 @@ __isl_give isl_basic_set *isl_basic_set_substitute( if (isl_local_space_dim(subs->ls, isl_dim_div) != 0) isl_die(ctx, isl_error_unsupported, "cannot handle divs yet", goto error); + if (!isl_int_is_one(subs->v->el[0])) + isl_die(ctx, isl_error_invalid, + "can only substitute integer expressions", goto error); pos += isl_basic_set_offset(bset, type); @@ -10121,3 +10993,378 @@ error: isl_set_free(set); return NULL; } + +/* Check if the range of "ma" is compatible with "space". + * Return -1 if anything is wrong. + */ +static int check_space_compatible_range_multi_aff( + __isl_keep isl_space *space, __isl_keep isl_multi_aff *ma) +{ + int m; + isl_space *ma_space; + + ma_space = isl_multi_aff_get_space(ma); + m = isl_space_is_range_internal(space, ma_space); + isl_space_free(ma_space); + if (m >= 0 && !m) + isl_die(isl_space_get_ctx(space), isl_error_invalid, + "spaces don't match", return -1); + return m; +} + +/* Check if the range of "ma" is compatible with "bset". + * Return -1 if anything is wrong. + */ +static int check_basic_set_compatible_range_multi_aff( + __isl_keep isl_basic_set *bset, __isl_keep isl_multi_aff *ma) +{ + return check_space_compatible_range_multi_aff(bset->dim, ma); +} + +/* Copy the divs from "ma" to "bset", adding zeros for the coefficients + * of the other divs in "bset". + */ +static int set_ma_divs(__isl_keep isl_basic_set *bset, + __isl_keep isl_multi_aff *ma, int n_div) +{ + int i; + isl_local_space *ls; + + if (n_div == 0) + return 0; + + ls = isl_aff_get_domain_local_space(ma->p[0]); + if (!ls) + return -1; + + for (i = 0; i < n_div; ++i) { + isl_seq_cpy(bset->div[i], ls->div->row[i], ls->div->n_col); + isl_seq_clr(bset->div[i] + ls->div->n_col, bset->n_div - n_div); + if (isl_basic_set_add_div_constraints(bset, i) < 0) + goto error; + } + + isl_local_space_free(ls); + return 0; +error: + isl_local_space_free(ls); + return -1; +} + +/* How many stride constraints does "ma" enforce? + * That is, how many of the affine expressions have a denominator + * different from one? + */ +static int multi_aff_strides(__isl_keep isl_multi_aff *ma) +{ + int i; + int strides = 0; + + for (i = 0; i < ma->n; ++i) + if (!isl_int_is_one(ma->p[i]->v->el[0])) + strides++; + + return strides; +} + +/* For each affine expression in ma of the form + * + * x_i = (f_i y + h_i)/m_i + * + * with m_i different from one, add a constraint to "bset" + * of the form + * + * f_i y + h_i = m_i alpha_i + * + * with alpha_i an additional existentially quantified variable. + */ +static __isl_give isl_basic_set *add_ma_strides( + __isl_take isl_basic_set *bset, __isl_keep isl_multi_aff *ma) +{ + int i, k; + int div; + int total; + + total = isl_basic_set_total_dim(bset); + for (i = 0; i < ma->n; ++i) { + int len; + + if (isl_int_is_one(ma->p[i]->v->el[0])) + continue; + div = isl_basic_set_alloc_div(bset); + k = isl_basic_set_alloc_equality(bset); + if (div < 0 || k < 0) + goto error; + isl_int_set_si(bset->div[div][0], 0); + len = ma->p[i]->v->size; + isl_seq_cpy(bset->eq[k], ma->p[i]->v->el + 1, len - 1); + isl_seq_clr(bset->eq[k] + len - 1, 1 + total - (len - 1)); + isl_int_neg(bset->eq[k][1 + total], ma->p[i]->v->el[0]); + total++; + } + + return bset; +error: + isl_basic_set_free(bset); + return NULL; +} + +/* Compute the preimage of "bset" under the function represented by "ma". + * In other words, plug in "ma" in "bset". The result is a basic set + * that lives in the domain space of "ma". + * + * If bset is represented by + * + * A(p) + B x + C(divs) >= 0 + * + * and ma is represented by + * + * x = D(p) + F(y) + G(divs') + * + * then the result is + * + * A(p) + B D(p) + B F(y) + B G(divs') + C(divs) >= 0 + * + * The divs in the input set are similarly adjusted. + * In particular + * + * floor((a_i(p) + b_i x + c_i(divs))/n_i) + * + * becomes + * + * floor((a_i(p) + b_i D(p) + b_i F(y) + B_i G(divs') + c_i(divs))/n_i) + * + * If bset is not a rational set and if F(y) involves any denominators + * + * x_i = (f_i y + h_i)/m_i + * + * the additional constraints are added to ensure that we only + * map back integer points. That is we enforce + * + * f_i y + h_i = m_i alpha_i + * + * with alpha_i an additional existentially quantified variable. + * + * We first copy over the divs from "ma". + * Then we add the modified constraints and divs from "bset". + * Finally, we add the stride constraints, if needed. + */ +__isl_give isl_basic_set *isl_basic_set_preimage_multi_aff( + __isl_take isl_basic_set *bset, __isl_take isl_multi_aff *ma) +{ + int i, k; + isl_space *space; + isl_basic_set *res = NULL; + int n_div_bset, n_div_ma; + isl_int f, c1, c2, g; + int rational, strides; + + isl_int_init(f); + isl_int_init(c1); + isl_int_init(c2); + isl_int_init(g); + + ma = isl_multi_aff_align_divs(ma); + if (!bset || !ma) + goto error; + if (check_basic_set_compatible_range_multi_aff(bset, ma) < 0) + goto error; + + n_div_bset = isl_basic_set_dim(bset, isl_dim_div); + n_div_ma = ma->n ? isl_aff_dim(ma->p[0], isl_dim_div) : 0; + + space = isl_space_domain(isl_multi_aff_get_space(ma)); + rational = isl_basic_set_is_rational(bset); + strides = rational ? 0 : multi_aff_strides(ma); + res = isl_basic_set_alloc_space(space, n_div_ma + n_div_bset + strides, + bset->n_eq + strides, bset->n_ineq + 2 * n_div_ma); + if (rational) + res = isl_basic_set_set_rational(res); + + for (i = 0; i < n_div_ma + n_div_bset; ++i) + if (isl_basic_set_alloc_div(res) < 0) + goto error; + + if (set_ma_divs(res, ma, n_div_ma) < 0) + goto error; + + for (i = 0; i < bset->n_eq; ++i) { + k = isl_basic_set_alloc_equality(res); + if (k < 0) + goto error; + isl_seq_preimage(res->eq[k], bset->eq[i], ma, n_div_ma, + n_div_bset, f, c1, c2, g, 0); + } + + for (i = 0; i < bset->n_ineq; ++i) { + k = isl_basic_set_alloc_inequality(res); + if (k < 0) + goto error; + isl_seq_preimage(res->ineq[k], bset->ineq[i], ma, n_div_ma, + n_div_bset, f, c1, c2, g, 0); + } + + for (i = 0; i < bset->n_div; ++i) { + if (isl_int_is_zero(bset->div[i][0])) { + isl_int_set_si(res->div[n_div_ma + i][0], 0); + continue; + } + isl_seq_preimage(res->div[n_div_ma + i], bset->div[i], + ma, n_div_ma, n_div_bset, f, c1, c2, g, 1); + } + + if (strides) + res = add_ma_strides(res, ma); + + isl_int_clear(f); + isl_int_clear(c1); + isl_int_clear(c2); + isl_int_clear(g); + isl_basic_set_free(bset); + isl_multi_aff_free(ma); + res = isl_basic_set_simplify(res); + return isl_basic_set_finalize(res); +error: + isl_int_clear(f); + isl_int_clear(c1); + isl_int_clear(c2); + isl_int_clear(g); + isl_basic_set_free(bset); + isl_multi_aff_free(ma); + isl_basic_set_free(res); + return NULL; +} + +/* Check if the range of "ma" is compatible with "set". + * Return -1 if anything is wrong. + */ +static int check_set_compatible_range_multi_aff( + __isl_keep isl_set *set, __isl_keep isl_multi_aff *ma) +{ + return check_space_compatible_range_multi_aff(set->dim, ma); +} + +/* Compute the preimage of "set" under the function represented by "ma". + * In other words, plug in "ma" in "set. The result is a set + * that lives in the domain space of "ma". + */ +static __isl_give isl_set *set_preimage_multi_aff(__isl_take isl_set *set, + __isl_take isl_multi_aff *ma) +{ + int i; + + set = isl_set_cow(set); + ma = isl_multi_aff_align_divs(ma); + if (!set || !ma) + goto error; + if (check_set_compatible_range_multi_aff(set, ma) < 0) + goto error; + + for (i = 0; i < set->n; ++i) { + set->p[i] = isl_basic_set_preimage_multi_aff(set->p[i], + isl_multi_aff_copy(ma)); + if (!set->p[i]) + goto error; + } + + isl_space_free(set->dim); + set->dim = isl_multi_aff_get_domain_space(ma); + if (!set->dim) + goto error; + + isl_multi_aff_free(ma); + if (set->n > 1) + ISL_F_CLR(set, ISL_MAP_DISJOINT); + ISL_F_CLR(set, ISL_SET_NORMALIZED); + return set; +error: + isl_multi_aff_free(ma); + isl_set_free(set); + return NULL; +} + +__isl_give isl_set *isl_set_preimage_multi_aff(__isl_take isl_set *set, + __isl_take isl_multi_aff *ma) +{ + if (!set || !ma) + goto error; + + if (isl_space_match(set->dim, isl_dim_param, ma->space, isl_dim_param)) + return set_preimage_multi_aff(set, ma); + + if (!isl_space_has_named_params(set->dim) || + !isl_space_has_named_params(ma->space)) + isl_die(set->ctx, isl_error_invalid, + "unaligned unnamed parameters", goto error); + set = isl_set_align_params(set, isl_multi_aff_get_space(ma)); + ma = isl_multi_aff_align_params(ma, isl_set_get_space(set)); + + return set_preimage_multi_aff(set, ma); +error: + isl_multi_aff_free(ma); + return isl_set_free(set); +} + +/* Compute the preimage of "set" under the function represented by "pma". + * In other words, plug in "pma" in "set. The result is a set + * that lives in the domain space of "pma". + */ +static __isl_give isl_set *set_preimage_pw_multi_aff(__isl_take isl_set *set, + __isl_take isl_pw_multi_aff *pma) +{ + int i; + isl_set *res; + + if (!pma) + goto error; + + if (pma->n == 0) { + isl_pw_multi_aff_free(pma); + res = isl_set_empty(isl_set_get_space(set)); + isl_set_free(set); + return res; + } + + res = isl_set_preimage_multi_aff(isl_set_copy(set), + isl_multi_aff_copy(pma->p[0].maff)); + res = isl_set_intersect(res, isl_set_copy(pma->p[0].set)); + + for (i = 1; i < pma->n; ++i) { + isl_set *res_i; + + res_i = isl_set_preimage_multi_aff(isl_set_copy(set), + isl_multi_aff_copy(pma->p[i].maff)); + res_i = isl_set_intersect(res_i, isl_set_copy(pma->p[i].set)); + res = isl_set_union(res, res_i); + } + + isl_pw_multi_aff_free(pma); + isl_set_free(set); + return res; +error: + isl_pw_multi_aff_free(pma); + isl_set_free(set); + return NULL; +} + +__isl_give isl_set *isl_set_preimage_pw_multi_aff(__isl_take isl_set *set, + __isl_take isl_pw_multi_aff *pma) +{ + if (!set || !pma) + goto error; + + if (isl_space_match(set->dim, isl_dim_param, pma->dim, isl_dim_param)) + return set_preimage_pw_multi_aff(set, pma); + + if (!isl_space_has_named_params(set->dim) || + !isl_space_has_named_params(pma->dim)) + isl_die(set->ctx, isl_error_invalid, + "unaligned unnamed parameters", goto error); + set = isl_set_align_params(set, isl_pw_multi_aff_get_space(pma)); + pma = isl_pw_multi_aff_align_params(pma, isl_set_get_space(set)); + + return set_preimage_pw_multi_aff(set, pma); +error: + isl_pw_multi_aff_free(pma); + return isl_set_free(set); +}