X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=isl_map.c;h=602b2c0aa54d0ce2ea308d810747333ceb4ce1dd;hb=d7276caf78702c11e9448c67d46bb362de734357;hp=0b3f7cc36a2e91c80a53c316696d50253fbc05ae;hpb=53c2cef7bf02c9d4a9af1168b2e81aacc3ea2049;p=platform%2Fupstream%2Fisl.git diff --git a/isl_map.c b/isl_map.c index 0b3f7cc..602b2c0 100644 --- a/isl_map.c +++ b/isl_map.c @@ -11,13 +11,12 @@ */ #include -#include #include #include #include -#include "isl_dim_private.h" +#include "isl_space_private.h" #include "isl_equalities.h" -#include +#include #include #include #include @@ -28,29 +27,11 @@ #include "isl_tab.h" #include #include +#include +#include +#include -/* Maps dst positions to src positions */ -struct isl_dim_map { - unsigned len; - int pos[1]; -}; - -static struct isl_dim_map *isl_dim_map_alloc(struct isl_ctx *ctx, unsigned len) -{ - int i; - struct isl_dim_map *dim_map; - dim_map = isl_alloc(ctx, struct isl_dim_map, - sizeof(struct isl_dim_map) + len * sizeof(int)); - if (!dim_map) - return NULL; - dim_map->len = 1 + len; - dim_map->pos[0] = 0; - for (i = 0; i < len; ++i) - dim_map->pos[1 + i] = -1; - return dim_map; -} - -static unsigned n(struct isl_dim *dim, enum isl_dim_type type) +static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type) { switch (type) { case isl_dim_param: return dim->nparam; @@ -61,7 +42,7 @@ static unsigned n(struct isl_dim *dim, enum isl_dim_type type) } } -static unsigned pos(struct isl_dim *dim, enum isl_dim_type type) +static unsigned pos(__isl_keep isl_space *dim, enum isl_dim_type type) { switch (type) { case isl_dim_param: return 1; @@ -71,51 +52,7 @@ static unsigned pos(struct isl_dim *dim, enum isl_dim_type type) } } -static void isl_dim_map_dim_range(struct isl_dim_map *dim_map, - struct isl_dim *dim, enum isl_dim_type type, - unsigned first, unsigned n, unsigned dst_pos) -{ - int i; - unsigned src_pos; - - if (!dim_map || !dim) - return; - - src_pos = pos(dim, type); - for (i = 0; i < n; ++i) - dim_map->pos[1 + dst_pos + i] = src_pos + first + i; -} - -static void isl_dim_map_dim(struct isl_dim_map *dim_map, struct isl_dim *dim, - enum isl_dim_type type, unsigned dst_pos) -{ - isl_dim_map_dim_range(dim_map, dim, type, 0, n(dim, type), dst_pos); -} - -static void isl_dim_map_div(struct isl_dim_map *dim_map, - struct isl_basic_map *bmap, unsigned dst_pos) -{ - int i; - unsigned src_pos; - - if (!dim_map || !bmap) - return; - - src_pos = 1 + isl_dim_total(bmap->dim); - for (i = 0; i < bmap->n_div; ++i) - dim_map->pos[1 + dst_pos + i] = src_pos + i; -} - -static void isl_dim_map_dump(struct isl_dim_map *dim_map) -{ - int i; - - for (i = 0; i < dim_map->len; ++i) - fprintf(stderr, "%d -> %d; ", i, dim_map->pos[i]); - fprintf(stderr, "\n"); -} - -unsigned isl_basic_map_dim(const struct isl_basic_map *bmap, +unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap, enum isl_dim_type type) { if (!bmap) @@ -124,19 +61,19 @@ unsigned isl_basic_map_dim(const struct isl_basic_map *bmap, case isl_dim_cst: return 1; case isl_dim_param: case isl_dim_in: - case isl_dim_out: return isl_dim_size(bmap->dim, type); + case isl_dim_out: return isl_space_dim(bmap->dim, type); case isl_dim_div: return bmap->n_div; case isl_dim_all: return isl_basic_map_total_dim(bmap); default: return 0; } } -unsigned isl_map_dim(const struct isl_map *map, enum isl_dim_type type) +unsigned isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type) { return map ? n(map->dim, type) : 0; } -unsigned isl_set_dim(const struct isl_set *set, enum isl_dim_type type) +unsigned isl_set_dim(__isl_keep isl_set *set, enum isl_dim_type type) { return set ? n(set->dim, type) : 0; } @@ -144,7 +81,7 @@ unsigned isl_set_dim(const struct isl_set *set, enum isl_dim_type type) unsigned isl_basic_map_offset(struct isl_basic_map *bmap, enum isl_dim_type type) { - struct isl_dim *dim = bmap->dim; + isl_space *dim = bmap->dim; switch (type) { case isl_dim_cst: return 0; case isl_dim_param: return 1; @@ -155,38 +92,44 @@ unsigned isl_basic_map_offset(struct isl_basic_map *bmap, } } +unsigned isl_basic_set_offset(struct isl_basic_set *bset, + enum isl_dim_type type) +{ + return isl_basic_map_offset(bset, type); +} + static unsigned map_offset(struct isl_map *map, enum isl_dim_type type) { return pos(map->dim, type); } -unsigned isl_basic_set_dim(const struct isl_basic_set *bset, +unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset, enum isl_dim_type type) { - return isl_basic_map_dim((const struct isl_basic_map*)bset, type); + return isl_basic_map_dim(bset, type); } -unsigned isl_basic_set_n_dim(const struct isl_basic_set *bset) +unsigned isl_basic_set_n_dim(__isl_keep isl_basic_set *bset) { return isl_basic_set_dim(bset, isl_dim_set); } -unsigned isl_basic_set_n_param(const struct isl_basic_set *bset) +unsigned isl_basic_set_n_param(__isl_keep isl_basic_set *bset) { return isl_basic_set_dim(bset, isl_dim_param); } unsigned isl_basic_set_total_dim(const struct isl_basic_set *bset) { - return isl_dim_total(bset->dim) + bset->n_div; + return isl_space_dim(bset->dim, isl_dim_all) + bset->n_div; } -unsigned isl_set_n_dim(const struct isl_set *set) +unsigned isl_set_n_dim(__isl_keep isl_set *set) { return isl_set_dim(set, isl_dim_set); } -unsigned isl_set_n_param(const struct isl_set *set) +unsigned isl_set_n_param(__isl_keep isl_set *set) { return isl_set_dim(set, isl_dim_param); } @@ -213,22 +156,22 @@ unsigned isl_basic_map_n_div(const struct isl_basic_map *bmap) unsigned isl_basic_map_total_dim(const struct isl_basic_map *bmap) { - return bmap ? isl_dim_total(bmap->dim) + bmap->n_div : 0; + return bmap ? isl_space_dim(bmap->dim, isl_dim_all) + bmap->n_div : 0; } unsigned isl_map_n_in(const struct isl_map *map) { - return map->dim->n_in; + return map ? map->dim->n_in : 0; } unsigned isl_map_n_out(const struct isl_map *map) { - return map->dim->n_out; + return map ? map->dim->n_out : 0; } unsigned isl_map_n_param(const struct isl_map *map) { - return map->dim->nparam; + return map ? map->dim->nparam : 0; } int isl_map_compatible_domain(struct isl_map *map, struct isl_set *set) @@ -236,10 +179,10 @@ int isl_map_compatible_domain(struct isl_map *map, struct isl_set *set) int m; if (!map || !set) return -1; - m = isl_dim_match(map->dim, isl_dim_param, set->dim, isl_dim_param); + m = isl_space_match(map->dim, isl_dim_param, set->dim, isl_dim_param); if (m < 0 || !m) return m; - return isl_dim_tuple_match(map->dim, isl_dim_in, set->dim, isl_dim_set); + return isl_space_tuple_match(map->dim, isl_dim_in, set->dim, isl_dim_set); } int isl_basic_map_compatible_domain(struct isl_basic_map *bmap, @@ -248,10 +191,21 @@ int isl_basic_map_compatible_domain(struct isl_basic_map *bmap, int m; if (!bmap || !bset) return -1; - m = isl_dim_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param); + m = isl_space_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param); + if (m < 0 || !m) + return m; + return isl_space_tuple_match(bmap->dim, isl_dim_in, bset->dim, isl_dim_set); +} + +int isl_map_compatible_range(__isl_keep isl_map *map, __isl_keep isl_set *set) +{ + int m; + if (!map || !set) + return -1; + m = isl_space_match(map->dim, isl_dim_param, set->dim, isl_dim_param); if (m < 0 || !m) return m; - return isl_dim_tuple_match(bmap->dim, isl_dim_in, bset->dim, isl_dim_set); + return isl_space_tuple_match(map->dim, isl_dim_out, set->dim, isl_dim_set); } int isl_basic_map_compatible_range(struct isl_basic_map *bmap, @@ -260,10 +214,10 @@ int isl_basic_map_compatible_range(struct isl_basic_map *bmap, int m; if (!bmap || !bset) return -1; - m = isl_dim_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param); + m = isl_space_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param); if (m < 0 || !m) return m; - return isl_dim_tuple_match(bmap->dim, isl_dim_out, bset->dim, isl_dim_set); + return isl_space_tuple_match(bmap->dim, isl_dim_out, bset->dim, isl_dim_set); } isl_ctx *isl_basic_map_get_ctx(__isl_keep isl_basic_map *bmap) @@ -286,32 +240,97 @@ isl_ctx *isl_set_get_ctx(__isl_keep isl_set *set) return set ? set->ctx : NULL; } -struct isl_dim *isl_basic_map_get_dim(struct isl_basic_map *bmap) +__isl_give isl_space *isl_basic_map_get_space(__isl_keep isl_basic_map *bmap) { if (!bmap) return NULL; - return isl_dim_copy(bmap->dim); + return isl_space_copy(bmap->dim); } -struct isl_dim *isl_basic_set_get_dim(struct isl_basic_set *bset) +__isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_set *bset) { if (!bset) return NULL; - return isl_dim_copy(bset->dim); + return isl_space_copy(bset->dim); +} + +__isl_give isl_local_space *isl_basic_map_get_local_space( + __isl_keep isl_basic_map *bmap) +{ + int i; + isl_local_space *ls; + unsigned total; + + 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) + return NULL; + + for (i = 0; i < bmap->n_div; ++i) + isl_seq_cpy(ls->div->row[i], bmap->div[i], 2 + total); + + return ls; +} + +__isl_give isl_local_space *isl_basic_set_get_local_space( + __isl_keep isl_basic_set *bset) +{ + return isl_basic_map_get_local_space(bset); +} + +__isl_give isl_basic_map *isl_basic_map_from_local_space( + __isl_take isl_local_space *ls) +{ + int i; + int n_div; + isl_basic_map *bmap; + + if (!ls) + return NULL; + + n_div = isl_local_space_dim(ls, isl_dim_div); + bmap = isl_basic_map_alloc_space(isl_local_space_get_space(ls), + n_div, 0, 2 * n_div); + + for (i = 0; i < n_div; ++i) + if (isl_basic_map_alloc_div(bmap) < 0) + goto error; + + for (i = 0; i < n_div; ++i) { + isl_seq_cpy(bmap->div[i], ls->div->row[i], ls->div->n_col); + if (isl_basic_map_add_div_constraints(bmap, i) < 0) + goto error; + } + + isl_local_space_free(ls); + return bmap; +error: + isl_local_space_free(ls); + isl_basic_map_free(bmap); + return NULL; +} + +__isl_give isl_basic_set *isl_basic_set_from_local_space( + __isl_take isl_local_space *ls) +{ + return isl_basic_map_from_local_space(ls); } -struct isl_dim *isl_map_get_dim(struct isl_map *map) +__isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map) { if (!map) return NULL; - return isl_dim_copy(map->dim); + return isl_space_copy(map->dim); } -struct isl_dim *isl_set_get_dim(struct isl_set *set) +__isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set) { if (!set) return NULL; - return isl_dim_copy(set->dim); + return isl_space_copy(set->dim); } __isl_give isl_basic_map *isl_basic_map_set_tuple_name( @@ -320,7 +339,7 @@ __isl_give isl_basic_map *isl_basic_map_set_tuple_name( bmap = isl_basic_map_cow(bmap); if (!bmap) return NULL; - bmap->dim = isl_dim_set_tuple_name(bmap->dim, type, s); + bmap->dim = isl_space_set_tuple_name(bmap->dim, type, s); if (!bmap->dim) goto error; bmap = isl_basic_map_finalize(bmap); @@ -330,10 +349,16 @@ error: return NULL; } +__isl_give isl_basic_set *isl_basic_set_set_tuple_name( + __isl_take isl_basic_set *bset, const char *s) +{ + return isl_basic_map_set_tuple_name(bset, isl_dim_set, s); +} + const char *isl_basic_map_get_tuple_name(__isl_keep isl_basic_map *bmap, enum isl_dim_type type) { - return bmap ? isl_dim_get_tuple_name(bmap->dim, type) : NULL; + return bmap ? isl_space_get_tuple_name(bmap->dim, type) : NULL; } __isl_give isl_map *isl_map_set_tuple_name(__isl_take isl_map *map, @@ -345,7 +370,7 @@ __isl_give isl_map *isl_map_set_tuple_name(__isl_take isl_map *map, if (!map) return NULL; - map->dim = isl_dim_set_tuple_name(map->dim, type, s); + map->dim = isl_space_set_tuple_name(map->dim, type, s); if (!map->dim) goto error; @@ -364,7 +389,7 @@ error: const char *isl_map_get_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type) { - return map ? isl_dim_get_tuple_name(map->dim, type) : NULL; + return map ? isl_space_get_tuple_name(map->dim, type) : NULL; } __isl_give isl_set *isl_set_set_tuple_name(__isl_take isl_set *set, @@ -373,38 +398,94 @@ __isl_give isl_set *isl_set_set_tuple_name(__isl_take isl_set *set, return (isl_set *)isl_map_set_tuple_name((isl_map *)set, isl_dim_set, s); } +__isl_give isl_map *isl_map_set_tuple_id(__isl_take isl_map *map, + enum isl_dim_type type, __isl_take isl_id *id) +{ + map = isl_map_cow(map); + if (!map) + return isl_id_free(id); + + map->dim = isl_space_set_tuple_id(map->dim, type, id); + + return isl_map_reset_space(map, isl_space_copy(map->dim)); +} + +__isl_give isl_set *isl_set_set_tuple_id(__isl_take isl_set *set, + __isl_take isl_id *id) +{ + return isl_map_set_tuple_id(set, isl_dim_set, id); +} + +__isl_give isl_map *isl_map_reset_tuple_id(__isl_take isl_map *map, + enum isl_dim_type type) +{ + map = isl_map_cow(map); + if (!map) + return NULL; + + map->dim = isl_space_reset_tuple_id(map->dim, type); + + return isl_map_reset_space(map, isl_space_copy(map->dim)); +} + +__isl_give isl_set *isl_set_reset_tuple_id(__isl_take isl_set *set) +{ + return isl_map_reset_tuple_id(set, isl_dim_set); +} + +int isl_map_has_tuple_id(__isl_keep isl_map *map, enum isl_dim_type type) +{ + return map ? isl_space_has_tuple_id(map->dim, type) : -1; +} + +__isl_give isl_id *isl_map_get_tuple_id(__isl_keep isl_map *map, + enum isl_dim_type type) +{ + return map ? isl_space_get_tuple_id(map->dim, type) : NULL; +} + +int isl_set_has_tuple_id(__isl_keep isl_set *set) +{ + return isl_map_has_tuple_id(set, isl_dim_set); +} + +__isl_give isl_id *isl_set_get_tuple_id(__isl_keep isl_set *set) +{ + return isl_map_get_tuple_id(set, isl_dim_set); +} + const char *isl_basic_set_get_tuple_name(__isl_keep isl_basic_set *bset) { - return bset ? isl_dim_get_tuple_name(bset->dim, isl_dim_set) : NULL; + return bset ? isl_space_get_tuple_name(bset->dim, isl_dim_set) : NULL; } const char *isl_set_get_tuple_name(__isl_keep isl_set *set) { - return set ? isl_dim_get_tuple_name(set->dim, isl_dim_set) : NULL; + return set ? isl_space_get_tuple_name(set->dim, isl_dim_set) : NULL; } const char *isl_basic_map_get_dim_name(__isl_keep isl_basic_map *bmap, enum isl_dim_type type, unsigned pos) { - return bmap ? isl_dim_get_name(bmap->dim, type, pos) : NULL; + return bmap ? isl_space_get_dim_name(bmap->dim, type, pos) : NULL; } const char *isl_basic_set_get_dim_name(__isl_keep isl_basic_set *bset, enum isl_dim_type type, unsigned pos) { - return bset ? isl_dim_get_name(bset->dim, type, pos) : NULL; + return bset ? isl_space_get_dim_name(bset->dim, type, pos) : NULL; } const char *isl_map_get_dim_name(__isl_keep isl_map *map, enum isl_dim_type type, unsigned pos) { - return map ? isl_dim_get_name(map->dim, type, pos) : NULL; + return map ? isl_space_get_dim_name(map->dim, type, pos) : NULL; } const char *isl_set_get_dim_name(__isl_keep isl_set *set, enum isl_dim_type type, unsigned pos) { - return set ? isl_dim_get_name(set->dim, type, pos) : NULL; + return set ? isl_space_get_dim_name(set->dim, type, pos) : NULL; } __isl_give isl_basic_map *isl_basic_map_set_dim_name( @@ -413,7 +494,7 @@ __isl_give isl_basic_map *isl_basic_map_set_dim_name( { if (!bmap) return NULL; - bmap->dim = isl_dim_set_name(bmap->dim, type, pos, s); + bmap->dim = isl_space_set_dim_name(bmap->dim, type, pos, s); if (!bmap->dim) goto error; return bmap; @@ -430,7 +511,7 @@ __isl_give isl_map *isl_map_set_dim_name(__isl_take isl_map *map, if (!map) return NULL; - map->dim = isl_dim_set_name(map->dim, type, pos, s); + map->dim = isl_space_set_dim_name(map->dim, type, pos, s); if (!map->dim) goto error; @@ -460,6 +541,76 @@ __isl_give isl_set *isl_set_set_dim_name(__isl_take isl_set *set, return (isl_set *)isl_map_set_dim_name((isl_map *)set, type, pos, s); } +int isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap, + enum isl_dim_type type, unsigned pos) +{ + return bmap ? isl_space_has_dim_id(bmap->dim, type, pos) : -1; +} + +int isl_map_has_dim_id(__isl_keep isl_map *map, + enum isl_dim_type type, unsigned pos) +{ + return map ? isl_space_has_dim_id(map->dim, type, pos) : -1; +} + +__isl_give isl_id *isl_map_get_dim_id(__isl_keep isl_map *map, + enum isl_dim_type type, unsigned pos) +{ + return map ? isl_space_get_dim_id(map->dim, type, pos) : NULL; +} + +int isl_set_has_dim_id(__isl_keep isl_set *set, + enum isl_dim_type type, unsigned pos) +{ + return isl_map_has_dim_id(set, type, pos); +} + +__isl_give isl_id *isl_set_get_dim_id(__isl_keep isl_set *set, + enum isl_dim_type type, unsigned pos) +{ + return isl_map_get_dim_id(set, type, pos); +} + +__isl_give isl_map *isl_map_set_dim_id(__isl_take isl_map *map, + enum isl_dim_type type, unsigned pos, __isl_take isl_id *id) +{ + map = isl_map_cow(map); + if (!map) + return isl_id_free(id); + + map->dim = isl_space_set_dim_id(map->dim, type, pos, id); + + return isl_map_reset_space(map, isl_space_copy(map->dim)); +} + +__isl_give isl_set *isl_set_set_dim_id(__isl_take isl_set *set, + enum isl_dim_type type, unsigned pos, __isl_take isl_id *id) +{ + return isl_map_set_dim_id(set, type, pos, id); +} + +int isl_map_find_dim_by_id(__isl_keep isl_map *map, enum isl_dim_type type, + __isl_keep isl_id *id) +{ + if (!map) + return -1; + return isl_space_find_dim_by_id(map->dim, type, id); +} + +int isl_set_find_dim_by_id(__isl_keep isl_set *set, enum isl_dim_type type, + __isl_keep isl_id *id) +{ + return isl_map_find_dim_by_id(set, type, id); +} + +int isl_map_find_dim_by_name(__isl_keep isl_map *map, enum isl_dim_type type, + const char *name) +{ + if (!map) + return -1; + return isl_space_find_dim_by_name(map->dim, type, name); +} + int isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap) { if (!bmap) @@ -472,12 +623,41 @@ int isl_basic_set_is_rational(__isl_keep isl_basic_set *bset) return isl_basic_map_is_rational(bset); } +/* Is this basic set a parameter domain? + */ +int isl_basic_set_is_params(__isl_keep isl_basic_set *bset) +{ + if (!bset) + return -1; + return isl_space_is_params(bset->dim); +} + +/* Is this set a parameter domain? + */ +int isl_set_is_params(__isl_keep isl_set *set) +{ + if (!set) + return -1; + return isl_space_is_params(set->dim); +} + +/* Is this map actually a parameter domain? + * Users should never call this function. Outside of isl, + * a map can never be a parameter domain. + */ +int isl_map_is_params(__isl_keep isl_map *map) +{ + if (!map) + return -1; + return isl_space_is_params(map->dim); +} + static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx, struct isl_basic_map *bmap, unsigned extra, unsigned n_eq, unsigned n_ineq) { int i; - size_t row_size = 1 + isl_dim_total(bmap->dim) + extra; + size_t row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + extra; bmap->ctx = ctx; isl_ctx_ref(ctx); @@ -530,25 +710,31 @@ struct isl_basic_set *isl_basic_set_alloc(struct isl_ctx *ctx, unsigned n_eq, unsigned n_ineq) { struct isl_basic_map *bmap; - bmap = isl_basic_map_alloc(ctx, nparam, 0, dim, extra, n_eq, n_ineq); + isl_space *space; + + space = isl_space_set_alloc(ctx, nparam, dim); + if (!space) + return NULL; + + bmap = isl_basic_map_alloc_space(space, extra, n_eq, n_ineq); return (struct isl_basic_set *)bmap; } -struct isl_basic_set *isl_basic_set_alloc_dim(struct isl_dim *dim, +struct isl_basic_set *isl_basic_set_alloc_space(__isl_take isl_space *dim, unsigned extra, unsigned n_eq, unsigned n_ineq) { struct isl_basic_map *bmap; if (!dim) return NULL; isl_assert(dim->ctx, dim->n_in == 0, goto error); - bmap = isl_basic_map_alloc_dim(dim, extra, n_eq, n_ineq); + bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq); return (struct isl_basic_set *)bmap; error: - isl_dim_free(dim); + isl_space_free(dim); return NULL; } -struct isl_basic_map *isl_basic_map_alloc_dim(struct isl_dim *dim, +struct isl_basic_map *isl_basic_map_alloc_space(__isl_take isl_space *dim, unsigned extra, unsigned n_eq, unsigned n_ineq) { struct isl_basic_map *bmap; @@ -562,7 +748,7 @@ struct isl_basic_map *isl_basic_map_alloc_dim(struct isl_dim *dim, return basic_map_init(dim->ctx, bmap, extra, n_eq, n_ineq); error: - isl_dim_free(dim); + isl_space_free(dim); return NULL; } @@ -571,13 +757,13 @@ struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx, unsigned n_eq, unsigned n_ineq) { struct isl_basic_map *bmap; - struct isl_dim *dim; + isl_space *dim; - dim = isl_dim_alloc(ctx, nparam, in, out); + dim = isl_space_alloc(ctx, nparam, in, out); if (!dim) return NULL; - bmap = isl_basic_map_alloc_dim(dim, extra, n_eq, n_ineq); + bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq); return bmap; } @@ -610,7 +796,7 @@ struct isl_basic_map *isl_basic_map_dup(struct isl_basic_map *bmap) if (!bmap) return NULL; - dup = isl_basic_map_alloc_dim(isl_dim_copy(bmap->dim), + dup = isl_basic_map_alloc_space(isl_space_copy(bmap->dim), bmap->n_div, bmap->n_eq, bmap->n_ineq); if (!dup) return NULL; @@ -687,7 +873,7 @@ void isl_basic_map_free(struct isl_basic_map *bmap) free(bmap->ineq); isl_blk_free(bmap->ctx, bmap->block); isl_vec_free(bmap->sample); - isl_dim_free(bmap->dim); + isl_space_free(bmap->dim); free(bmap); } @@ -701,6 +887,52 @@ static int room_for_con(struct isl_basic_map *bmap, unsigned n) return bmap->n_eq + bmap->n_ineq + n <= bmap->c_size; } +__isl_give isl_map *isl_map_align_params_map_map_and( + __isl_take isl_map *map1, __isl_take isl_map *map2, + __isl_give isl_map *(*fn)(__isl_take isl_map *map1, + __isl_take isl_map *map2)) +{ + if (!map1 || !map2) + goto error; + if (isl_space_match(map1->dim, isl_dim_param, map2->dim, isl_dim_param)) + return fn(map1, map2); + if (!isl_space_has_named_params(map1->dim) || + !isl_space_has_named_params(map2->dim)) + isl_die(map1->ctx, isl_error_invalid, + "unaligned unnamed parameters", goto error); + map1 = isl_map_align_params(map1, isl_map_get_space(map2)); + map2 = isl_map_align_params(map2, isl_map_get_space(map1)); + return fn(map1, map2); +error: + isl_map_free(map1); + isl_map_free(map2); + return NULL; +} + +static int align_params_map_map_and_test(__isl_keep isl_map *map1, + __isl_keep isl_map *map2, + int (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2)) +{ + int r; + + if (!map1 || !map2) + return -1; + if (isl_space_match(map1->dim, isl_dim_param, map2->dim, isl_dim_param)) + return fn(map1, map2); + if (!isl_space_has_named_params(map1->dim) || + !isl_space_has_named_params(map2->dim)) + isl_die(map1->ctx, isl_error_invalid, + "unaligned unnamed parameters", return -1); + map1 = isl_map_copy(map1); + map2 = isl_map_copy(map2); + map1 = isl_map_align_params(map1, isl_map_get_space(map2)); + map2 = isl_map_align_params(map2, isl_map_get_space(map1)); + r = fn(map1, map2); + isl_map_free(map1); + isl_map_free(map2); + return r; +} + int isl_basic_map_alloc_equality(struct isl_basic_map *bmap) { struct isl_ctx *ctx; @@ -1033,66 +1265,6 @@ error: return NULL; } -static void copy_constraint_dim_map(isl_int *dst, isl_int *src, - struct isl_dim_map *dim_map) -{ - int i; - - for (i = 0; i < dim_map->len; ++i) { - if (dim_map->pos[i] < 0) - isl_int_set_si(dst[i], 0); - else - isl_int_set(dst[i], src[dim_map->pos[i]]); - } -} - -static void copy_div_dim_map(isl_int *dst, isl_int *src, - struct isl_dim_map *dim_map) -{ - isl_int_set(dst[0], src[0]); - copy_constraint_dim_map(dst+1, src+1, dim_map); -} - -static struct isl_basic_map *add_constraints_dim_map(struct isl_basic_map *dst, - struct isl_basic_map *src, struct isl_dim_map *dim_map) -{ - int i; - - if (!src || !dst || !dim_map) - goto error; - - for (i = 0; i < src->n_eq; ++i) { - int i1 = isl_basic_map_alloc_equality(dst); - if (i1 < 0) - goto error; - copy_constraint_dim_map(dst->eq[i1], src->eq[i], dim_map); - } - - for (i = 0; i < src->n_ineq; ++i) { - int i1 = isl_basic_map_alloc_inequality(dst); - if (i1 < 0) - goto error; - copy_constraint_dim_map(dst->ineq[i1], src->ineq[i], dim_map); - } - - for (i = 0; i < src->n_div; ++i) { - int i1 = isl_basic_map_alloc_div(dst); - if (i1 < 0) - goto error; - copy_div_dim_map(dst->div[i1], src->div[i], dim_map); - } - - free(dim_map); - isl_basic_map_free(src); - - return dst; -error: - free(dim_map); - isl_basic_map_free(src); - isl_basic_map_free(dst); - return NULL; -} - struct isl_basic_set *isl_basic_set_add_constraints(struct isl_basic_set *bset1, struct isl_basic_set *bset2, unsigned pos) { @@ -1101,8 +1273,8 @@ struct isl_basic_set *isl_basic_set_add_constraints(struct isl_basic_set *bset1, (struct isl_basic_map *)bset2, 0, pos); } -struct isl_basic_map *isl_basic_map_extend_dim(struct isl_basic_map *base, - struct isl_dim *dim, unsigned extra, +struct isl_basic_map *isl_basic_map_extend_space(struct isl_basic_map *base, + __isl_take isl_space *dim, unsigned extra, unsigned n_eq, unsigned n_ineq) { struct isl_basic_map *ext; @@ -1115,12 +1287,12 @@ struct isl_basic_map *isl_basic_map_extend_dim(struct isl_basic_map *base, if (!base) goto error; - dims_ok = isl_dim_equal(base->dim, dim) && + dims_ok = isl_space_is_equal(base->dim, dim) && base->extra >= base->n_div + extra; if (dims_ok && room_for_con(base, n_eq + n_ineq) && room_for_ineq(base, n_ineq)) { - isl_dim_free(dim); + isl_space_free(dim); return base; } @@ -1131,7 +1303,7 @@ struct isl_basic_map *isl_basic_map_extend_dim(struct isl_basic_map *base, n_eq += base->n_eq; n_ineq += base->n_ineq; - ext = isl_basic_map_alloc_dim(dim, extra, n_eq, n_ineq); + ext = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq); dim = NULL; if (!ext) goto error; @@ -1148,17 +1320,17 @@ struct isl_basic_map *isl_basic_map_extend_dim(struct isl_basic_map *base, return ext; error: - isl_dim_free(dim); + isl_space_free(dim); isl_basic_map_free(base); return NULL; } -struct isl_basic_set *isl_basic_set_extend_dim(struct isl_basic_set *base, - struct isl_dim *dim, unsigned extra, +struct isl_basic_set *isl_basic_set_extend_space(struct isl_basic_set *base, + __isl_take isl_space *dim, unsigned extra, unsigned n_eq, unsigned n_ineq) { return (struct isl_basic_set *) - isl_basic_map_extend_dim((struct isl_basic_map *)base, dim, + isl_basic_map_extend_space((struct isl_basic_map *)base, dim, extra, n_eq, n_ineq); } @@ -1167,7 +1339,7 @@ struct isl_basic_map *isl_basic_map_extend_constraints( { if (!base) return NULL; - return isl_basic_map_extend_dim(base, isl_dim_copy(base->dim), + return isl_basic_map_extend_space(base, isl_space_copy(base->dim), 0, n_eq, n_ineq); } @@ -1176,15 +1348,15 @@ struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq) { struct isl_basic_map *bmap; - struct isl_dim *dim; + isl_space *dim; if (!base) return NULL; - dim = isl_dim_alloc(base->ctx, nparam, n_in, n_out); + dim = isl_space_alloc(base->ctx, nparam, n_in, n_out); if (!dim) goto error; - bmap = isl_basic_map_extend_dim(base, dim, extra, n_eq, n_ineq); + bmap = isl_basic_map_extend_space(base, dim, extra, n_eq, n_ineq); return bmap; error: isl_basic_map_free(base); @@ -1319,26 +1491,7 @@ error: return NULL; } -static __isl_give isl_set *isl_set_swap_vars(__isl_take isl_set *set, - unsigned n) -{ - int i; - set = isl_set_cow(set); - if (!set) - return NULL; - - for (i = 0; i < set->n; ++i) { - set->p[i] = isl_basic_set_swap_vars(set->p[i], n); - if (!set->p[i]) { - isl_set_free(set); - return NULL; - } - } - ISL_F_CLR(set, ISL_SET_NORMALIZED); - return set; -} - -struct isl_basic_map *isl_basic_map_set_to_empty(struct isl_basic_map *bmap) +struct isl_basic_map *isl_basic_map_set_to_empty(struct isl_basic_map *bmap) { int i = 0; unsigned total; @@ -1374,7 +1527,7 @@ struct isl_basic_set *isl_basic_set_set_to_empty(struct isl_basic_set *bset) void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b) { int i; - unsigned off = isl_dim_total(bmap->dim); + unsigned off = isl_space_dim(bmap->dim, isl_dim_all); isl_int *t = bmap->div[a]; bmap->div[a] = bmap->div[b]; bmap->div[b] = t; @@ -1444,8 +1597,10 @@ __isl_give isl_set *isl_set_eliminate_dims(__isl_take isl_set *set, __isl_give isl_basic_map *isl_basic_map_remove_divs( __isl_take isl_basic_map *bmap) { - bmap = isl_basic_map_eliminate_vars(bmap, isl_dim_total(bmap->dim), - bmap->n_div); + if (!bmap) + return NULL; + bmap = isl_basic_map_eliminate_vars(bmap, + isl_space_dim(bmap->dim, isl_dim_all), bmap->n_div); if (!bmap) return NULL; bmap->n_div = 0; @@ -1495,7 +1650,7 @@ struct isl_basic_map *isl_basic_map_remove_dims(struct isl_basic_map *bmap, return NULL; isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type), goto error); - if (n == 0) + if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type)) return bmap; bmap = isl_basic_map_eliminate_vars(bmap, isl_basic_map_offset(bmap, type) - 1 + first, n); @@ -1553,6 +1708,9 @@ __isl_give isl_basic_map *isl_basic_map_remove_divs_involving_dims( if (!div_involves_vars(bmap, i, first, n)) continue; bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1); + if (!bmap) + return NULL; + i = bmap->n_div; } return bmap; @@ -1594,6 +1752,63 @@ __isl_give isl_set *isl_set_remove_divs_involving_dims(__isl_take isl_set *set, type, first, n); } +int isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap, + enum isl_dim_type type, unsigned first, unsigned n) +{ + int i; + + if (!bmap) + return -1; + + if (first + n > isl_basic_map_dim(bmap, type)) + isl_die(bmap->ctx, isl_error_invalid, + "index out of bounds", return -1); + + first += isl_basic_map_offset(bmap, type); + for (i = 0; i < bmap->n_eq; ++i) + if (isl_seq_first_non_zero(bmap->eq[i] + first, n) >= 0) + return 1; + for (i = 0; i < bmap->n_ineq; ++i) + if (isl_seq_first_non_zero(bmap->ineq[i] + first, n) >= 0) + return 1; + + return 0; +} + +int isl_map_involves_dims(__isl_keep isl_map *map, + enum isl_dim_type type, unsigned first, unsigned n) +{ + int i; + + if (!map) + return -1; + + if (first + n > isl_map_dim(map, type)) + isl_die(map->ctx, isl_error_invalid, + "index out of bounds", return -1); + + for (i = 0; i < map->n; ++i) { + int involves = isl_basic_map_involves_dims(map->p[i], + type, first, n); + if (involves < 0 || involves) + return involves; + } + + return 0; +} + +int isl_basic_set_involves_dims(__isl_keep isl_basic_set *bset, + enum isl_dim_type type, unsigned first, unsigned n) +{ + return isl_basic_map_involves_dims(bset, type, first, n); +} + +int isl_set_involves_dims(__isl_keep isl_set *set, + enum isl_dim_type type, unsigned first, unsigned n) +{ + return isl_map_involves_dims(set, type, first, n); +} + /* Return true if the definition of the given div is unknown or depends * on unknown divs. */ @@ -1723,7 +1938,7 @@ static void dump_term(struct isl_basic_map *bmap, if (!isl_int_is_one(c)) isl_int_print(out, c, 0); if (pos < 1 + nparam) { - name = isl_dim_get_name(bmap->dim, + name = isl_space_get_dim_name(bmap->dim, isl_dim_param, pos - 1); if (name) fprintf(out, "%s", name); @@ -1775,7 +1990,7 @@ static void dump_constraint(struct isl_basic_map *bmap, isl_int *c, fprintf(out, "\n"); for (i = bmap->n_div; i < bmap->extra; ++i) { - if (isl_int_is_zero(c[1+isl_dim_total(bmap->dim)+i])) + if (isl_int_is_zero(c[1+isl_space_dim(bmap->dim, isl_dim_all)+i])) continue; fprintf(out, "%*s", indent, ""); fprintf(out, "ERROR: unused div coefficient not zero\n"); @@ -1854,7 +2069,7 @@ void isl_basic_map_print_internal(struct isl_basic_map *bmap, "flags: %x, n_name: %d\n", bmap->ref, bmap->dim->nparam, bmap->dim->n_in, bmap->dim->n_out, - bmap->extra, bmap->flags, bmap->dim->n_name); + bmap->extra, bmap->flags, bmap->dim->n_id); dump(bmap, out, indent); } @@ -1871,7 +2086,8 @@ int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos) return 0; } -struct isl_set *isl_set_alloc_dim(struct isl_dim *dim, int n, unsigned flags) +__isl_give isl_set *isl_set_alloc_space(__isl_take isl_space *dim, int n, + unsigned flags) { struct isl_set *set; @@ -1894,7 +2110,7 @@ struct isl_set *isl_set_alloc_dim(struct isl_dim *dim, int n, unsigned flags) set->flags = flags; return set; error: - isl_dim_free(dim); + isl_space_free(dim); return NULL; } @@ -1902,13 +2118,13 @@ struct isl_set *isl_set_alloc(struct isl_ctx *ctx, unsigned nparam, unsigned dim, int n, unsigned flags) { struct isl_set *set; - struct isl_dim *dims; + isl_space *dims; - dims = isl_dim_alloc(ctx, nparam, 0, dim); + dims = isl_space_alloc(ctx, nparam, 0, dim); if (!dims) return NULL; - set = isl_set_alloc_dim(dims, n, flags); + set = isl_set_alloc_space(dims, n, flags); return set; } @@ -1924,7 +2140,7 @@ struct isl_map *isl_map_grow(struct isl_map *map, int n) isl_assert(map->ctx, n >= 0, goto error); if (map->n + n <= map->size) return map; - grown = isl_map_alloc_dim(isl_map_get_dim(map), map->n + n, map->flags); + grown = isl_map_alloc_space(isl_map_get_space(map), map->n + n, map->flags); if (!grown) goto error; for (i = 0; i < map->n; ++i) { @@ -1956,7 +2172,7 @@ struct isl_set *isl_set_dup(struct isl_set *set) if (!set) return NULL; - dup = isl_set_alloc_dim(isl_dim_copy(set->dim), set->n, set->flags); + dup = isl_set_alloc_space(isl_space_copy(set->dim), set->n, set->flags); if (!dup) return NULL; for (i = 0; i < set->n; ++i) @@ -1976,7 +2192,7 @@ struct isl_map *isl_map_from_basic_map(struct isl_basic_map *bmap) if (!bmap) return NULL; - map = isl_map_alloc_dim(isl_dim_copy(bmap->dim), 1, ISL_MAP_DISJOINT); + map = isl_map_alloc_space(isl_space_copy(bmap->dim), 1, ISL_MAP_DISJOINT); return isl_map_add_basic_map(map, bmap); } @@ -2000,7 +2216,7 @@ void isl_set_free(struct isl_set *set) isl_ctx_deref(set->ctx); for (i = 0; i < set->n; ++i) isl_basic_set_free(set->p[i]); - isl_dim_free(set->dim); + isl_space_free(set->dim); free(set); } @@ -2037,7 +2253,7 @@ void isl_map_print_internal(struct isl_map *map, FILE *out, int indent) fprintf(out, "ref: %d, n: %d, nparam: %d, in: %d, out: %d, " "flags: %x, n_name: %d\n", map->ref, map->n, map->dim->nparam, map->dim->n_in, - map->dim->n_out, map->flags, map->dim->n_name); + map->dim->n_out, map->flags, map->dim->n_id); for (i = 0; i < map->n; ++i) { fprintf(out, "%*s", indent, ""); fprintf(out, "basic map %d:\n", i); @@ -2053,17 +2269,17 @@ struct isl_basic_map *isl_basic_map_intersect_domain( if (!bmap || !bset) goto error; - isl_assert(bset->ctx, isl_dim_match(bmap->dim, isl_dim_param, + isl_assert(bset->ctx, isl_space_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param), goto error); - if (isl_dim_size(bset->dim, isl_dim_set) != 0) + if (isl_space_dim(bset->dim, isl_dim_set) != 0) isl_assert(bset->ctx, isl_basic_map_compatible_domain(bmap, bset), goto error); bmap = isl_basic_map_cow(bmap); if (!bmap) goto error; - bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim), + bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim), bset->n_div, bset->n_eq, bset->n_ineq); bmap_domain = isl_basic_map_from_domain(bset); bmap = add_constraints(bmap, bmap_domain, 0, 0); @@ -2084,19 +2300,24 @@ struct isl_basic_map *isl_basic_map_intersect_range( if (!bmap || !bset) goto error; - isl_assert(bset->ctx, isl_dim_match(bmap->dim, isl_dim_param, + isl_assert(bset->ctx, isl_space_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param), goto error); - if (isl_dim_size(bset->dim, isl_dim_set) != 0) + if (isl_space_dim(bset->dim, isl_dim_set) != 0) isl_assert(bset->ctx, isl_basic_map_compatible_range(bmap, bset), goto error); + if (isl_basic_set_is_universe(bset)) { + isl_basic_set_free(bset); + return bmap; + } + bmap = isl_basic_map_cow(bmap); if (!bmap) goto error; - bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim), + bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim), bset->n_div, bset->n_eq, bset->n_ineq); - bmap_range = isl_basic_map_from_basic_set(bset, isl_dim_copy(bset->dim)); + bmap_range = isl_basic_map_from_basic_set(bset, isl_space_copy(bset->dim)); bmap = add_constraints(bmap, bmap_range, 0, 0); bmap = isl_basic_map_simplify(bmap); @@ -2153,18 +2374,18 @@ struct isl_basic_map *isl_basic_map_intersect( if (!bmap1 || !bmap2) goto error; - isl_assert(bmap1->ctx, isl_dim_match(bmap1->dim, isl_dim_param, + isl_assert(bmap1->ctx, isl_space_match(bmap1->dim, isl_dim_param, bmap2->dim, isl_dim_param), goto error); - if (isl_dim_total(bmap1->dim) == - isl_dim_size(bmap1->dim, isl_dim_param) && - isl_dim_total(bmap2->dim) != - isl_dim_size(bmap2->dim, isl_dim_param)) + if (isl_space_dim(bmap1->dim, isl_dim_all) == + isl_space_dim(bmap1->dim, isl_dim_param) && + isl_space_dim(bmap2->dim, isl_dim_all) != + isl_space_dim(bmap2->dim, isl_dim_param)) return isl_basic_map_intersect(bmap2, bmap1); - if (isl_dim_total(bmap2->dim) != - isl_dim_size(bmap2->dim, isl_dim_param)) + if (isl_space_dim(bmap2->dim, isl_dim_all) != + isl_space_dim(bmap2->dim, isl_dim_param)) isl_assert(bmap1->ctx, - isl_dim_equal(bmap1->dim, bmap2->dim), goto error); + isl_space_is_equal(bmap1->dim, bmap2->dim), goto error); if (bmap1->sample && isl_basic_map_contains(bmap1, bmap1->sample) > 0 && @@ -2178,7 +2399,7 @@ struct isl_basic_map *isl_basic_map_intersect( bmap1 = isl_basic_map_cow(bmap1); if (!bmap1) goto error; - bmap1 = isl_basic_map_extend_dim(bmap1, isl_dim_copy(bmap1->dim), + bmap1 = isl_basic_map_extend_space(bmap1, isl_space_copy(bmap1->dim), bmap2->n_div, bmap2->n_eq, bmap2->n_ineq); bmap1 = add_constraints(bmap1, bmap2, 0, 0); @@ -2216,9 +2437,6 @@ struct isl_basic_set *isl_basic_set_intersect( static __isl_give isl_map *map_intersect_add_constraint( __isl_take isl_map *map1, __isl_take isl_map *map2) { - struct isl_basic_map *bmap1; - struct isl_basic_map *bmap2; - isl_assert(map1->ctx, map1->n == 1, goto error); isl_assert(map2->ctx, map1->n == 1, goto error); isl_assert(map1->ctx, map1->p[0]->n_div == 0, goto error); @@ -2233,7 +2451,7 @@ static __isl_give isl_map *map_intersect_add_constraint( map1 = isl_map_cow(map1); if (!map1) goto error; - if (isl_map_fast_is_empty(map1)) { + if (isl_map_plain_is_empty(map1)) { isl_map_free(map2); return map1; } @@ -2249,7 +2467,7 @@ static __isl_give isl_map *map_intersect_add_constraint( if (!map1->p[0]) goto error; - if (isl_basic_map_fast_is_empty(map1->p[0])) { + if (isl_basic_map_plain_is_empty(map1->p[0])) { isl_basic_map_free(map1->p[0]); map1->n = 0; } @@ -2263,7 +2481,8 @@ error: return NULL; } -struct isl_map *isl_map_intersect(struct isl_map *map1, struct isl_map *map2) +static __isl_give isl_map *map_intersect(__isl_take isl_map *map1, + __isl_take isl_map *map2) { unsigned flags = 0; struct isl_map *result; @@ -2272,37 +2491,41 @@ struct isl_map *isl_map_intersect(struct isl_map *map1, struct isl_map *map2) if (!map1 || !map2) goto error; - if (isl_map_fast_is_empty(map1)) { + if (isl_map_plain_is_empty(map1) && + isl_space_is_equal(map1->dim, map2->dim)) { isl_map_free(map2); return map1; } - if (isl_map_fast_is_empty(map2)) { + if (isl_map_plain_is_empty(map2) && + isl_space_is_equal(map1->dim, map2->dim)) { isl_map_free(map1); return map2; } if (map1->n == 1 && map2->n == 1 && map1->p[0]->n_div == 0 && map2->p[0]->n_div == 0 && - isl_dim_equal(map1->dim, map2->dim) && + isl_space_is_equal(map1->dim, map2->dim) && (map1->p[0]->n_eq + map1->p[0]->n_ineq == 1 || map2->p[0]->n_eq + map2->p[0]->n_ineq == 1)) return map_intersect_add_constraint(map1, map2); - isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param, - map2->dim, isl_dim_param), goto error); - if (isl_dim_total(map1->dim) == - isl_dim_size(map1->dim, isl_dim_param) && - isl_dim_total(map2->dim) != isl_dim_size(map2->dim, isl_dim_param)) + if (isl_map_is_params(map1) && !isl_map_is_params(map2)) + return isl_map_intersect(map2, map1); + if (isl_space_dim(map1->dim, isl_dim_all) == + isl_space_dim(map1->dim, isl_dim_param) && + isl_space_dim(map2->dim, isl_dim_all) != + isl_space_dim(map2->dim, isl_dim_param)) return isl_map_intersect(map2, map1); - if (isl_dim_total(map2->dim) != isl_dim_size(map2->dim, isl_dim_param)) + if (isl_space_dim(map2->dim, isl_dim_all) != + isl_space_dim(map2->dim, isl_dim_param)) isl_assert(map1->ctx, - isl_dim_equal(map1->dim, map2->dim), goto error); + isl_space_is_equal(map1->dim, map2->dim), goto error); if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) && ISL_F_ISSET(map2, ISL_MAP_DISJOINT)) ISL_FL_SET(flags, ISL_MAP_DISJOINT); - result = isl_map_alloc_dim(isl_dim_copy(map1->dim), + result = isl_map_alloc_space(isl_space_copy(map1->dim), map1->n * map2->n, flags); if (!result) goto error; @@ -2328,6 +2551,12 @@ error: return NULL; } +__isl_give isl_map *isl_map_intersect(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + return isl_map_align_params_map_map_and(map1, map2, &map_intersect); +} + struct isl_set *isl_set_intersect(struct isl_set *set1, struct isl_set *set2) { return (struct isl_set *) @@ -2335,9 +2564,30 @@ struct isl_set *isl_set_intersect(struct isl_set *set1, struct isl_set *set2) (struct isl_map *)set2); } +/* The current implementation of isl_map_intersect accepts intersections + * with parameter domains, so we can just call that for now. + */ +static __isl_give isl_map *map_intersect_params(__isl_take isl_map *map, + __isl_take isl_set *params) +{ + return isl_map_intersect(map, params); +} + +__isl_give isl_map *isl_map_intersect_params(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + return isl_map_align_params_map_map_and(map1, map2, &map_intersect_params); +} + +__isl_give isl_set *isl_set_intersect_params(__isl_take isl_set *set, + __isl_take isl_set *params) +{ + return isl_map_intersect_params(set, params); +} + struct isl_basic_map *isl_basic_map_reverse(struct isl_basic_map *bmap) { - struct isl_dim *dim; + isl_space *dim; struct isl_basic_set *bset; unsigned in; @@ -2346,29 +2596,43 @@ struct isl_basic_map *isl_basic_map_reverse(struct isl_basic_map *bmap) bmap = isl_basic_map_cow(bmap); if (!bmap) return NULL; - dim = isl_dim_reverse(isl_dim_copy(bmap->dim)); + dim = isl_space_reverse(isl_space_copy(bmap->dim)); in = isl_basic_map_n_in(bmap); bset = isl_basic_set_from_basic_map(bmap); bset = isl_basic_set_swap_vars(bset, in); return isl_basic_map_from_basic_set(bset, dim); } +static __isl_give isl_basic_map *basic_map_space_reset( + __isl_take isl_basic_map *bmap, enum isl_dim_type type) +{ + isl_space *space; + + if (!isl_space_is_named_or_nested(bmap->dim, type)) + return bmap; + + space = isl_basic_map_get_space(bmap); + space = isl_space_reset(space, type); + bmap = isl_basic_map_reset_space(bmap, space); + 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) { - struct isl_dim *res_dim; + isl_space *res_dim; struct isl_basic_map *res; struct isl_dim_map *dim_map; unsigned total, off; enum isl_dim_type t; if (n == 0) - return bmap; + return basic_map_space_reset(bmap, type); if (!bmap) return NULL; - res_dim = isl_dim_insert(isl_basic_map_get_dim(bmap), type, pos, n); + res_dim = isl_space_insert_dims(isl_basic_map_get_space(bmap), type, pos, n); total = isl_basic_map_total_dim(bmap) + n; dim_map = isl_dim_map_alloc(bmap->ctx, total); @@ -2383,15 +2647,15 @@ __isl_give isl_basic_map *isl_basic_map_insert(__isl_take isl_basic_map *bmap, isl_dim_map_dim_range(dim_map, bmap->dim, t, pos, size - pos, off + pos + n); } - off += isl_dim_size(res_dim, t); + off += isl_space_dim(res_dim, t); } isl_dim_map_div(dim_map, bmap, off); - res = isl_basic_map_alloc_dim(res_dim, + res = isl_basic_map_alloc_space(res_dim, bmap->n_div, bmap->n_eq, bmap->n_ineq); if (isl_basic_map_is_rational(bmap)) res = isl_basic_map_set_rational(res); - res = add_constraints_dim_map(res, bmap, dim_map); + res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map); return isl_basic_map_finalize(res); } @@ -2416,19 +2680,33 @@ error: return NULL; } -__isl_give isl_map *isl_map_insert(__isl_take isl_map *map, +static __isl_give isl_map *map_space_reset(__isl_take isl_map *map, + enum isl_dim_type type) +{ + isl_space *space; + + if (!isl_space_is_named_or_nested(map->dim, type)) + return map; + + space = isl_map_get_space(map); + space = isl_space_reset(space, type); + map = isl_map_reset_space(map, space); + return map; +} + +__isl_give isl_map *isl_map_insert_dims(__isl_take isl_map *map, enum isl_dim_type type, unsigned pos, unsigned n) { int i; if (n == 0) - return map; + return map_space_reset(map, type); map = isl_map_cow(map); if (!map) return NULL; - map->dim = isl_dim_insert(map->dim, type, pos, n); + map->dim = isl_space_insert_dims(map->dim, type, pos, n); if (!map->dim) goto error; @@ -2444,10 +2722,10 @@ error: return NULL; } -__isl_give isl_set *isl_set_insert(__isl_take isl_set *set, +__isl_give isl_set *isl_set_insert_dims(__isl_take isl_set *set, enum isl_dim_type type, unsigned pos, unsigned n) { - return (isl_set *)isl_map_insert((isl_map *)set, type, pos, n); + return isl_map_insert_dims(set, type, pos, n); } __isl_give isl_map *isl_map_add_dims(__isl_take isl_map *map, @@ -2455,7 +2733,7 @@ __isl_give isl_map *isl_map_add_dims(__isl_take isl_map *map, { if (!map) return NULL; - return isl_map_insert(map, type, isl_map_dim(map, type), n); + return isl_map_insert_dims(map, type, isl_map_dim(map, type), n); } __isl_give isl_set *isl_set_add_dims(__isl_take isl_set *set, @@ -2475,7 +2753,6 @@ __isl_give isl_basic_map *isl_basic_map_move_dims( enum isl_dim_type dst_type, unsigned dst_pos, enum isl_dim_type src_type, unsigned src_pos, unsigned n) { - int i; struct isl_dim_map *dim_map; struct isl_basic_map *res; enum isl_dim_type t; @@ -2501,7 +2778,7 @@ __isl_give isl_basic_map *isl_basic_map_move_dims( if (!bmap) return NULL; - bmap->dim = isl_dim_move(bmap->dim, dst_type, dst_pos, + bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos, src_type, src_pos, n); if (!bmap->dim) goto error; @@ -2516,7 +2793,7 @@ __isl_give isl_basic_map *isl_basic_map_move_dims( off = 0; for (t = isl_dim_param; t <= isl_dim_out; ++t) { - unsigned size = isl_dim_size(bmap->dim, t); + unsigned size = isl_space_dim(bmap->dim, t); if (t == dst_type) { isl_dim_map_dim_range(dim_map, bmap->dim, t, 0, dst_pos, off); @@ -2541,11 +2818,11 @@ __isl_give isl_basic_map *isl_basic_map_move_dims( } isl_dim_map_div(dim_map, bmap, off); - res = isl_basic_map_alloc_dim(isl_basic_map_get_dim(bmap), + res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap), bmap->n_div, bmap->n_eq, bmap->n_ineq); - bmap = add_constraints_dim_map(res, bmap, dim_map); + bmap = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map); - bmap->dim = isl_dim_move(bmap->dim, dst_type, dst_pos, + bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos, src_type, src_pos, n); if (!bmap->dim) goto error; @@ -2605,7 +2882,7 @@ __isl_give isl_map *isl_map_move_dims(__isl_take isl_map *map, if (!map) return NULL; - map->dim = isl_dim_move(map->dim, dst_type, dst_pos, src_type, src_pos, n); + map->dim = isl_space_move_dims(map->dim, dst_type, dst_pos, src_type, src_pos, n); if (!map->dim) goto error; @@ -2637,7 +2914,8 @@ static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap, if (!bmap) return NULL; - if (pos(bmap->dim, type) + first + n == 1 + isl_dim_total(bmap->dim)) + if (pos(bmap->dim, type) + first + n == + 1 + isl_space_dim(bmap->dim, isl_dim_all)) return bmap; total = isl_basic_map_total_dim(bmap); @@ -2645,7 +2923,7 @@ static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap, off = 0; for (t = isl_dim_param; t <= isl_dim_out; ++t) { - unsigned size = isl_dim_size(bmap->dim, t); + unsigned size = isl_space_dim(bmap->dim, t); if (t == type) { isl_dim_map_dim_range(dim_map, bmap->dim, t, 0, first, off); @@ -2662,9 +2940,9 @@ static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap, } isl_dim_map_div(dim_map, bmap, off + n); - res = isl_basic_map_alloc_dim(isl_basic_map_get_dim(bmap), + res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap), bmap->n_div, bmap->n_eq, bmap->n_ineq); - res = add_constraints_dim_map(res, bmap, dim_map); + res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map); return res; } @@ -2697,7 +2975,7 @@ __isl_give isl_basic_map *isl_basic_map_project_out( if (!bmap) return NULL; - row_size = 1 + isl_dim_total(bmap->dim) + bmap->extra; + row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + bmap->extra; old = bmap->block2.data; bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2, (bmap->extra + n) * (1 + row_size)); @@ -2718,7 +2996,7 @@ __isl_give isl_basic_map *isl_basic_map_project_out( bmap->n_div += n; bmap->extra += n; - bmap->dim = isl_dim_drop(bmap->dim, type, first, n); + bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n); if (!bmap->dim) goto error; bmap = isl_basic_map_simplify(bmap); @@ -2759,7 +3037,7 @@ __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map, if (!map) return NULL; - map->dim = isl_dim_drop(map->dim, type, first, n); + map->dim = isl_space_drop_dims(map->dim, type, first, n); if (!map->dim) goto error; @@ -2803,7 +3081,7 @@ error: struct isl_basic_map *isl_basic_map_apply_range( struct isl_basic_map *bmap1, struct isl_basic_map *bmap2) { - struct isl_dim *dim_result = NULL; + isl_space *dim_result = NULL; struct isl_basic_map *bmap; unsigned n_in, n_out, n, nparam, total, pos; struct isl_dim_map *dim_map1, *dim_map2; @@ -2811,8 +3089,8 @@ struct isl_basic_map *isl_basic_map_apply_range( if (!bmap1 || !bmap2) goto error; - dim_result = isl_dim_join(isl_dim_copy(bmap1->dim), - isl_dim_copy(bmap2->dim)); + dim_result = isl_space_join(isl_space_copy(bmap1->dim), + isl_space_copy(bmap2->dim)); n_in = isl_basic_map_n_in(bmap1); n_out = isl_basic_map_n_out(bmap2); @@ -2831,12 +3109,12 @@ struct isl_basic_map *isl_basic_map_apply_range( isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div); isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos); - bmap = isl_basic_map_alloc_dim(dim_result, + bmap = isl_basic_map_alloc_space(dim_result, bmap1->n_div + bmap2->n_div + n, bmap1->n_eq + bmap2->n_eq, bmap1->n_ineq + bmap2->n_ineq); - bmap = add_constraints_dim_map(bmap, bmap1, dim_map1); - bmap = add_constraints_dim_map(bmap, bmap2, dim_map2); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2); bmap = add_divs(bmap, n); bmap = isl_basic_map_simplify(bmap); bmap = isl_basic_map_drop_redundant_divs(bmap); @@ -2899,7 +3177,7 @@ struct isl_basic_map *isl_basic_map_sum( if (!bmap1 || !bmap2) goto error; - isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), + isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim), goto error); nparam = isl_basic_map_n_param(bmap1); @@ -2918,7 +3196,7 @@ struct isl_basic_map *isl_basic_map_sum( isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div); isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos += n_out); - bmap = isl_basic_map_alloc_dim(isl_dim_copy(bmap1->dim), + bmap = isl_basic_map_alloc_space(isl_space_copy(bmap1->dim), bmap1->n_div + bmap2->n_div + 2 * n_out, bmap1->n_eq + bmap2->n_eq + n_out, bmap1->n_ineq + bmap2->n_ineq); @@ -2931,8 +3209,8 @@ struct isl_basic_map *isl_basic_map_sum( isl_int_set_si(bmap->eq[j][1+pos+i], 1); isl_int_set_si(bmap->eq[j][1+pos-n_out+i], 1); } - bmap = add_constraints_dim_map(bmap, bmap1, dim_map1); - bmap = add_constraints_dim_map(bmap, bmap2, dim_map2); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2); bmap = add_divs(bmap, 2 * n_out); bmap = isl_basic_map_simplify(bmap); @@ -2955,9 +3233,9 @@ struct isl_map *isl_map_sum(struct isl_map *map1, struct isl_map *map2) if (!map1 || !map2) goto error; - isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error); + isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error); - result = isl_map_alloc_dim(isl_dim_copy(map1->dim), + result = isl_map_alloc_space(isl_space_copy(map1->dim), map1->n * map2->n, 0); if (!result) goto error; @@ -3011,6 +3289,7 @@ struct isl_basic_map *isl_basic_map_neg(struct isl_basic_map *bmap) for (i = 0; i < bmap->n_div; ++i) for (j = 0; j < n; ++j) isl_int_neg(bmap->div[i][1+off+j], bmap->div[i][1+off+j]); + bmap = isl_basic_map_gauss(bmap, NULL); return isl_basic_map_finalize(bmap); } @@ -3071,10 +3350,10 @@ struct isl_basic_map *isl_basic_map_floordiv(struct isl_basic_map *bmap, isl_dim_map_div(dim_map, bmap, pos += n_in + n_out); isl_dim_map_dim(dim_map, bmap->dim, isl_dim_out, pos += bmap->n_div); - result = isl_basic_map_alloc_dim(isl_dim_copy(bmap->dim), + result = isl_basic_map_alloc_space(isl_space_copy(bmap->dim), bmap->n_div + n_out, bmap->n_eq, bmap->n_ineq + 2 * n_out); - result = add_constraints_dim_map(result, bmap, dim_map); + result = isl_basic_map_add_constraints_dim_map(result, bmap, dim_map); result = add_divs(result, n_out); for (i = 0; i < n_out; ++i) { int j; @@ -3237,11 +3516,12 @@ error: return NULL; } -struct isl_basic_map *isl_basic_map_equal(struct isl_dim *dim, unsigned n_equal) +__isl_give isl_basic_map *isl_basic_map_equal( + __isl_take isl_space *dim, unsigned n_equal) { int i; struct isl_basic_map *bmap; - bmap = isl_basic_map_alloc_dim(dim, 0, n_equal, 0); + bmap = isl_basic_map_alloc_space(dim, 0, n_equal, 0); if (!bmap) return NULL; for (i = 0; i < n_equal && bmap; ++i) @@ -3251,11 +3531,12 @@ struct isl_basic_map *isl_basic_map_equal(struct isl_dim *dim, unsigned n_equal) /* Return a relation on of dimension "dim" expressing i_[0..pos] << o_[0..pos] */ -struct isl_basic_map *isl_basic_map_less_at(struct isl_dim *dim, unsigned pos) +__isl_give isl_basic_map *isl_basic_map_less_at(__isl_take isl_space *dim, + unsigned pos) { int i; struct isl_basic_map *bmap; - bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1); + bmap = isl_basic_map_alloc_space(dim, 0, pos, 1); if (!bmap) return NULL; for (i = 0; i < pos && bmap; ++i) @@ -3268,12 +3549,12 @@ struct isl_basic_map *isl_basic_map_less_at(struct isl_dim *dim, unsigned pos) /* Return a relation on of dimension "dim" expressing i_[0..pos] <<= o_[0..pos] */ __isl_give isl_basic_map *isl_basic_map_less_or_equal_at( - __isl_take isl_dim *dim, unsigned pos) + __isl_take isl_space *dim, unsigned pos) { int i; isl_basic_map *bmap; - bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1); + bmap = isl_basic_map_alloc_space(dim, 0, pos, 1); for (i = 0; i < pos; ++i) bmap = var_equal(bmap, i); bmap = var_less_or_equal(bmap, pos); @@ -3282,11 +3563,12 @@ __isl_give isl_basic_map *isl_basic_map_less_or_equal_at( /* Return a relation on pairs of sets of dimension "dim" expressing i_pos > o_pos */ -struct isl_basic_map *isl_basic_map_more_at(struct isl_dim *dim, unsigned pos) +__isl_give isl_basic_map *isl_basic_map_more_at(__isl_take isl_space *dim, + unsigned pos) { int i; struct isl_basic_map *bmap; - bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1); + bmap = isl_basic_map_alloc_space(dim, 0, pos, 1); if (!bmap) return NULL; for (i = 0; i < pos && bmap; ++i) @@ -3299,19 +3581,19 @@ struct isl_basic_map *isl_basic_map_more_at(struct isl_dim *dim, unsigned pos) /* Return a relation on of dimension "dim" expressing i_[0..pos] >>= o_[0..pos] */ __isl_give isl_basic_map *isl_basic_map_more_or_equal_at( - __isl_take isl_dim *dim, unsigned pos) + __isl_take isl_space *dim, unsigned pos) { int i; isl_basic_map *bmap; - bmap = isl_basic_map_alloc_dim(dim, 0, pos, 1); + bmap = isl_basic_map_alloc_space(dim, 0, pos, 1); for (i = 0; i < pos; ++i) bmap = var_equal(bmap, i); bmap = var_more_or_equal(bmap, pos); return isl_basic_map_finalize(bmap); } -static __isl_give isl_map *map_lex_lte_first(__isl_take isl_dim *dims, +static __isl_give isl_map *map_lex_lte_first(__isl_take isl_space *dims, unsigned n, int equal) { struct isl_map *map; @@ -3320,11 +3602,11 @@ static __isl_give isl_map *map_lex_lte_first(__isl_take isl_dim *dims, if (n == 0 && equal) return isl_map_universe(dims); - map = isl_map_alloc_dim(isl_dim_copy(dims), n, ISL_MAP_DISJOINT); + map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT); for (i = 0; i + 1 < n; ++i) map = isl_map_add_basic_map(map, - isl_basic_map_less_at(isl_dim_copy(dims), i)); + isl_basic_map_less_at(isl_space_copy(dims), i)); if (n > 0) { if (equal) map = isl_map_add_basic_map(map, @@ -3333,39 +3615,39 @@ static __isl_give isl_map *map_lex_lte_first(__isl_take isl_dim *dims, map = isl_map_add_basic_map(map, isl_basic_map_less_at(dims, n - 1)); } else - isl_dim_free(dims); + isl_space_free(dims); return map; } -static __isl_give isl_map *map_lex_lte(__isl_take isl_dim *dims, int equal) +static __isl_give isl_map *map_lex_lte(__isl_take isl_space *dims, int equal) { if (!dims) return NULL; return map_lex_lte_first(dims, dims->n_out, equal); } -__isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_dim *dim, unsigned n) +__isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_space *dim, unsigned n) { return map_lex_lte_first(dim, n, 0); } -__isl_give isl_map *isl_map_lex_le_first(__isl_take isl_dim *dim, unsigned n) +__isl_give isl_map *isl_map_lex_le_first(__isl_take isl_space *dim, unsigned n) { return map_lex_lte_first(dim, n, 1); } -__isl_give isl_map *isl_map_lex_lt(__isl_take isl_dim *set_dim) +__isl_give isl_map *isl_map_lex_lt(__isl_take isl_space *set_dim) { - return map_lex_lte(isl_dim_map_from_set(set_dim), 0); + return map_lex_lte(isl_space_map_from_set(set_dim), 0); } -__isl_give isl_map *isl_map_lex_le(__isl_take isl_dim *set_dim) +__isl_give isl_map *isl_map_lex_le(__isl_take isl_space *set_dim) { - return map_lex_lte(isl_dim_map_from_set(set_dim), 1); + return map_lex_lte(isl_space_map_from_set(set_dim), 1); } -static __isl_give isl_map *map_lex_gte_first(__isl_take isl_dim *dims, +static __isl_give isl_map *map_lex_gte_first(__isl_take isl_space *dims, unsigned n, int equal) { struct isl_map *map; @@ -3374,11 +3656,11 @@ static __isl_give isl_map *map_lex_gte_first(__isl_take isl_dim *dims, if (n == 0 && equal) return isl_map_universe(dims); - map = isl_map_alloc_dim(isl_dim_copy(dims), n, ISL_MAP_DISJOINT); + map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT); for (i = 0; i + 1 < n; ++i) map = isl_map_add_basic_map(map, - isl_basic_map_more_at(isl_dim_copy(dims), i)); + isl_basic_map_more_at(isl_space_copy(dims), i)); if (n > 0) { if (equal) map = isl_map_add_basic_map(map, @@ -3387,43 +3669,43 @@ static __isl_give isl_map *map_lex_gte_first(__isl_take isl_dim *dims, map = isl_map_add_basic_map(map, isl_basic_map_more_at(dims, n - 1)); } else - isl_dim_free(dims); + isl_space_free(dims); return map; } -static __isl_give isl_map *map_lex_gte(__isl_take isl_dim *dims, int equal) +static __isl_give isl_map *map_lex_gte(__isl_take isl_space *dims, int equal) { if (!dims) return NULL; return map_lex_gte_first(dims, dims->n_out, equal); } -__isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_dim *dim, unsigned n) +__isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_space *dim, unsigned n) { return map_lex_gte_first(dim, n, 0); } -__isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_dim *dim, unsigned n) +__isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_space *dim, unsigned n) { return map_lex_gte_first(dim, n, 1); } -__isl_give isl_map *isl_map_lex_gt(__isl_take isl_dim *set_dim) +__isl_give isl_map *isl_map_lex_gt(__isl_take isl_space *set_dim) { - return map_lex_gte(isl_dim_map_from_set(set_dim), 0); + return map_lex_gte(isl_space_map_from_set(set_dim), 0); } -__isl_give isl_map *isl_map_lex_ge(__isl_take isl_dim *set_dim) +__isl_give isl_map *isl_map_lex_ge(__isl_take isl_space *set_dim) { - return map_lex_gte(isl_dim_map_from_set(set_dim), 1); + return map_lex_gte(isl_space_map_from_set(set_dim), 1); } __isl_give isl_map *isl_set_lex_le_set(__isl_take isl_set *set1, __isl_take isl_set *set2) { isl_map *map; - map = isl_map_lex_le(isl_set_get_dim(set1)); + map = isl_map_lex_le(isl_set_get_space(set1)); map = isl_map_intersect_domain(map, set1); map = isl_map_intersect_range(map, set2); return map; @@ -3433,7 +3715,7 @@ __isl_give isl_map *isl_set_lex_lt_set(__isl_take isl_set *set1, __isl_take isl_set *set2) { isl_map *map; - map = isl_map_lex_lt(isl_set_get_dim(set1)); + map = isl_map_lex_lt(isl_set_get_space(set1)); map = isl_map_intersect_domain(map, set1); map = isl_map_intersect_range(map, set2); return map; @@ -3443,7 +3725,7 @@ __isl_give isl_map *isl_set_lex_ge_set(__isl_take isl_set *set1, __isl_take isl_set *set2) { isl_map *map; - map = isl_map_lex_ge(isl_set_get_dim(set1)); + map = isl_map_lex_ge(isl_set_get_space(set1)); map = isl_map_intersect_domain(map, set1); map = isl_map_intersect_range(map, set2); return map; @@ -3453,7 +3735,7 @@ __isl_give isl_map *isl_set_lex_gt_set(__isl_take isl_set *set1, __isl_take isl_set *set2) { isl_map *map; - map = isl_map_lex_gt(isl_set_get_dim(set1)); + map = isl_map_lex_gt(isl_set_get_space(set1)); map = isl_map_intersect_domain(map, set1); map = isl_map_intersect_range(map, set2); return map; @@ -3463,7 +3745,7 @@ __isl_give isl_map *isl_map_lex_le_map(__isl_take isl_map *map1, __isl_take isl_map *map2) { isl_map *map; - map = isl_map_lex_le(isl_dim_range(isl_map_get_dim(map1))); + map = isl_map_lex_le(isl_space_range(isl_map_get_space(map1))); map = isl_map_apply_domain(map, isl_map_reverse(map1)); map = isl_map_apply_range(map, isl_map_reverse(map2)); return map; @@ -3473,7 +3755,7 @@ __isl_give isl_map *isl_map_lex_lt_map(__isl_take isl_map *map1, __isl_take isl_map *map2) { isl_map *map; - map = isl_map_lex_lt(isl_dim_range(isl_map_get_dim(map1))); + map = isl_map_lex_lt(isl_space_range(isl_map_get_space(map1))); map = isl_map_apply_domain(map, isl_map_reverse(map1)); map = isl_map_apply_range(map, isl_map_reverse(map2)); return map; @@ -3483,7 +3765,7 @@ __isl_give isl_map *isl_map_lex_ge_map(__isl_take isl_map *map1, __isl_take isl_map *map2) { isl_map *map; - map = isl_map_lex_ge(isl_dim_range(isl_map_get_dim(map1))); + map = isl_map_lex_ge(isl_space_range(isl_map_get_space(map1))); map = isl_map_apply_domain(map, isl_map_reverse(map1)); map = isl_map_apply_range(map, isl_map_reverse(map2)); return map; @@ -3493,14 +3775,14 @@ __isl_give isl_map *isl_map_lex_gt_map(__isl_take isl_map *map1, __isl_take isl_map *map2) { isl_map *map; - map = isl_map_lex_gt(isl_dim_range(isl_map_get_dim(map1))); + map = isl_map_lex_gt(isl_space_range(isl_map_get_space(map1))); map = isl_map_apply_domain(map, isl_map_reverse(map1)); map = isl_map_apply_range(map, isl_map_reverse(map2)); return map; } -struct isl_basic_map *isl_basic_map_from_basic_set( - struct isl_basic_set *bset, struct isl_dim *dim) +__isl_give isl_basic_map *isl_basic_map_from_basic_set( + __isl_take isl_basic_set *bset, __isl_take isl_space *dim) { struct isl_basic_map *bmap; @@ -3508,14 +3790,14 @@ struct isl_basic_map *isl_basic_map_from_basic_set( if (!bset || !dim) goto error; - isl_assert(bset->ctx, isl_dim_compatible(bset->dim, dim), goto error); - isl_dim_free(bset->dim); + isl_assert(bset->ctx, isl_space_compatible(bset->dim, dim), goto error); + isl_space_free(bset->dim); bmap = (struct isl_basic_map *) bset; bmap->dim = dim; return isl_basic_map_finalize(bmap); error: isl_basic_set_free(bset); - isl_dim_free(dim); + isl_space_free(dim); return NULL; } @@ -3528,7 +3810,7 @@ struct isl_basic_set *isl_basic_set_from_basic_map(struct isl_basic_map *bmap) bmap = isl_basic_map_cow(bmap); if (!bmap) goto error; - bmap->dim = isl_dim_as_set_dim(bmap->dim); + bmap->dim = isl_space_as_set_space(bmap->dim); if (!bmap->dim) goto error; bmap = isl_basic_map_finalize(bmap); @@ -3591,13 +3873,13 @@ struct isl_basic_set *isl_basic_map_underlying_set( goto error; if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 && bmap->n_div == 0 && - !isl_dim_is_named_or_nested(bmap->dim, isl_dim_in) && - !isl_dim_is_named_or_nested(bmap->dim, isl_dim_out)) + !isl_space_is_named_or_nested(bmap->dim, isl_dim_in) && + !isl_space_is_named_or_nested(bmap->dim, isl_dim_out)) return (struct isl_basic_set *)bmap; bmap = isl_basic_map_cow(bmap); if (!bmap) goto error; - bmap->dim = isl_dim_underlying(bmap->dim, bmap->n_div); + bmap->dim = isl_space_underlying(bmap->dim, bmap->n_div); if (!bmap->dim) goto error; bmap->extra -= bmap->n_div; @@ -3629,7 +3911,7 @@ struct isl_basic_map *isl_basic_map_overlying_set( isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error); isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like), goto error); - if (isl_dim_equal(bset->dim, like->dim) && like->n_div == 0) { + if (isl_space_is_equal(bset->dim, like->dim) && like->n_div == 0) { isl_basic_map_free(like); return (struct isl_basic_map *)bset; } @@ -3638,8 +3920,8 @@ struct isl_basic_map *isl_basic_map_overlying_set( goto error; total = bset->dim->n_out + bset->extra; bmap = (struct isl_basic_map *)bset; - isl_dim_free(bmap->dim); - bmap->dim = isl_dim_copy(like->dim); + isl_space_free(bmap->dim); + bmap->dim = isl_space_copy(like->dim); if (!bmap->dim) goto error; bmap->n_div = like->n_div; @@ -3699,7 +3981,7 @@ struct isl_set *isl_set_from_underlying_set( goto error; isl_assert(set->ctx, set->dim->n_out == isl_basic_set_total_dim(like), goto error); - if (isl_dim_equal(set->dim, like->dim) && like->n_div == 0) { + if (isl_space_is_equal(set->dim, like->dim) && like->n_div == 0) { isl_basic_set_free(like); return set; } @@ -3712,8 +3994,8 @@ struct isl_set *isl_set_from_underlying_set( if (!set->p[i]) goto error; } - isl_dim_free(set->dim); - set->dim = isl_dim_copy(like->dim); + isl_space_free(set->dim); + set->dim = isl_space_copy(like->dim); if (!set->dim) goto error; isl_basic_set_free(like); @@ -3731,7 +4013,7 @@ struct isl_set *isl_map_underlying_set(struct isl_map *map) map = isl_map_cow(map); if (!map) return NULL; - map->dim = isl_dim_cow(map->dim); + map->dim = isl_space_cow(map->dim); if (!map->dim) goto error; @@ -3745,10 +4027,10 @@ struct isl_set *isl_map_underlying_set(struct isl_map *map) goto error; } if (map->n == 0) - map->dim = isl_dim_underlying(map->dim, 0); + map->dim = isl_space_underlying(map->dim, 0); else { - isl_dim_free(map->dim); - map->dim = isl_dim_copy(map->p[0]->dim); + isl_space_free(map->dim); + map->dim = isl_space_copy(map->p[0]->dim); } if (!map->dim) goto error; @@ -3763,14 +4045,14 @@ struct isl_set *isl_set_to_underlying_set(struct isl_set *set) return (struct isl_set *)isl_map_underlying_set((struct isl_map *)set); } -__isl_give isl_basic_map *isl_basic_map_reset_dim( - __isl_take isl_basic_map *bmap, __isl_take isl_dim *dim) +__isl_give isl_basic_map *isl_basic_map_reset_space( + __isl_take isl_basic_map *bmap, __isl_take isl_space *dim) { bmap = isl_basic_map_cow(bmap); if (!bmap || !dim) goto error; - isl_dim_free(bmap->dim); + isl_space_free(bmap->dim); bmap->dim = dim; bmap = isl_basic_map_finalize(bmap); @@ -3778,19 +4060,19 @@ __isl_give isl_basic_map *isl_basic_map_reset_dim( return bmap; error: isl_basic_map_free(bmap); - isl_dim_free(dim); + isl_space_free(dim); return NULL; } -__isl_give isl_basic_set *isl_basic_set_reset_dim( - __isl_take isl_basic_set *bset, __isl_take isl_dim *dim) +__isl_give isl_basic_set *isl_basic_set_reset_space( + __isl_take isl_basic_set *bset, __isl_take isl_space *dim) { - return (isl_basic_set *)isl_basic_map_reset_dim((isl_basic_map *)bset, + return (isl_basic_set *)isl_basic_map_reset_space((isl_basic_map *)bset, dim); } -__isl_give isl_map *isl_map_reset_dim(__isl_take isl_map *map, - __isl_take isl_dim *dim) +__isl_give isl_map *isl_map_reset_space(__isl_take isl_map *map, + __isl_take isl_space *dim) { int i; @@ -3799,50 +4081,136 @@ __isl_give isl_map *isl_map_reset_dim(__isl_take isl_map *map, goto error; for (i = 0; i < map->n; ++i) { - map->p[i] = isl_basic_map_reset_dim(map->p[i], - isl_dim_copy(dim)); + map->p[i] = isl_basic_map_reset_space(map->p[i], + isl_space_copy(dim)); if (!map->p[i]) goto error; } - isl_dim_free(map->dim); + isl_space_free(map->dim); map->dim = dim; return map; error: isl_map_free(map); - isl_dim_free(dim); + isl_space_free(dim); return NULL; } -__isl_give isl_set *isl_set_reset_dim(__isl_take isl_set *set, - __isl_take isl_dim *dim) +__isl_give isl_set *isl_set_reset_space(__isl_take isl_set *set, + __isl_take isl_space *dim) +{ + return (struct isl_set *) isl_map_reset_space((struct isl_map *)set, dim); +} + +/* Compute the parameter domain of the given basic set. + */ +__isl_give isl_basic_set *isl_basic_set_params(__isl_take isl_basic_set *bset) +{ + isl_space *space; + unsigned n; + + if (isl_basic_set_is_params(bset)) + return bset; + + n = isl_basic_set_dim(bset, isl_dim_set); + bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n); + space = isl_basic_set_get_space(bset); + space = isl_space_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) +{ + isl_space *space; + unsigned n; + + if (isl_set_is_params(set)) + return set; + + n = isl_set_dim(set, isl_dim_set); + set = isl_set_project_out(set, isl_dim_set, 0, n); + space = isl_set_get_space(set); + space = isl_space_params(space); + set = isl_set_reset_space(set, space); + return set; +} + +/* Construct a zero-dimensional set with the given parameter domain. + */ +__isl_give isl_set *isl_set_from_params(__isl_take isl_set *set) { - return (struct isl_set *) isl_map_reset_dim((struct isl_map *)set, dim); + isl_space *space; + space = isl_set_get_space(set); + space = isl_space_set_from_params(space); + set = isl_set_reset_space(set, space); + return set; +} + +/* Compute the parameter domain of the given map. + */ +__isl_give isl_set *isl_map_params(__isl_take isl_map *map) +{ + isl_space *space; + unsigned n; + + n = isl_map_dim(map, isl_dim_in); + map = isl_map_project_out(map, isl_dim_in, 0, n); + n = isl_map_dim(map, isl_dim_out); + map = isl_map_project_out(map, isl_dim_out, 0, n); + space = isl_map_get_space(map); + space = isl_space_params(space); + map = isl_map_reset_space(map, space); + return map; } struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap) { - isl_dim *dim; + isl_space *dim; struct isl_basic_set *domain; unsigned n_in; unsigned n_out; if (!bmap) return NULL; - dim = isl_dim_domain(isl_basic_map_get_dim(bmap)); + dim = isl_space_domain(isl_basic_map_get_space(bmap)); n_in = isl_basic_map_n_in(bmap); n_out = isl_basic_map_n_out(bmap); domain = isl_basic_set_from_basic_map(bmap); domain = isl_basic_set_project_out(domain, isl_dim_set, n_in, n_out); - domain = isl_basic_set_reset_dim(domain, dim); + domain = isl_basic_set_reset_space(domain, dim); return domain; } +int isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap) +{ + if (!bmap) + return -1; + return isl_space_may_be_set(bmap->dim); +} + +/* Is this basic map actually a set? + * Users should never call this function. Outside of isl, + * the type should indicate whether something is a set or a map. + */ +int isl_basic_map_is_set(__isl_keep isl_basic_map *bmap) +{ + if (!bmap) + return -1; + return isl_space_is_set(bmap->dim); +} + struct isl_basic_set *isl_basic_map_range(struct isl_basic_map *bmap) { + if (!bmap) + return NULL; + if (isl_basic_map_is_set(bmap)) + return bmap; return isl_basic_map_domain(isl_basic_map_reverse(bmap)); } @@ -3850,9 +4218,8 @@ __isl_give isl_basic_map *isl_basic_map_domain_map( __isl_take isl_basic_map *bmap) { int i, k; - isl_dim *dim; + isl_space *dim; isl_basic_map *domain; - isl_basic_set *bset; int nparam, n_in, n_out; unsigned total; @@ -3860,7 +4227,7 @@ __isl_give isl_basic_map *isl_basic_map_domain_map( n_in = isl_basic_map_dim(bmap, isl_dim_in); n_out = isl_basic_map_dim(bmap, isl_dim_out); - dim = isl_dim_from_range(isl_dim_domain(isl_basic_map_get_dim(bmap))); + dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap))); domain = isl_basic_map_universe(dim); bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap)); @@ -3889,9 +4256,8 @@ __isl_give isl_basic_map *isl_basic_map_range_map( __isl_take isl_basic_map *bmap) { int i, k; - isl_dim *dim; + isl_space *dim; isl_basic_map *range; - isl_basic_set *bset; int nparam, n_in, n_out; unsigned total; @@ -3899,7 +4265,7 @@ __isl_give isl_basic_map *isl_basic_map_range_map( n_in = isl_basic_map_dim(bmap, isl_dim_in); n_out = isl_basic_map_dim(bmap, isl_dim_out); - dim = isl_dim_from_range(isl_dim_range(isl_basic_map_get_dim(bmap))); + dim = isl_space_from_range(isl_space_range(isl_basic_map_get_space(bmap))); range = isl_basic_map_universe(dim); bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap)); @@ -3924,6 +4290,24 @@ error: return NULL; } +int isl_map_may_be_set(__isl_keep isl_map *map) +{ + if (!map) + return -1; + return isl_space_may_be_set(map->dim); +} + +/* Is this map actually a set? + * Users should never call this function. Outside of isl, + * the type should indicate whether something is a set or a map. + */ +int isl_map_is_set(__isl_keep isl_map *map) +{ + if (!map) + return -1; + return isl_space_is_set(map->dim); +} + struct isl_set *isl_map_range(struct isl_map *map) { int i; @@ -3931,7 +4315,7 @@ struct isl_set *isl_map_range(struct isl_map *map) if (!map) goto error; - if (isl_map_dim(map, isl_dim_in) == 0) + if (isl_map_is_set(map)) return (isl_set *)map; map = isl_map_cow(map); @@ -3939,7 +4323,7 @@ struct isl_set *isl_map_range(struct isl_map *map) goto error; set = (struct isl_set *) map; - set->dim = isl_dim_drop_inputs(set->dim, 0, set->dim->n_in); + set->dim = isl_space_range(set->dim); if (!set->dim) goto error; for (i = 0; i < map->n; ++i) { @@ -3958,15 +4342,15 @@ error: __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map) { int i; - isl_dim *domain_dim; + isl_space *domain_dim; map = isl_map_cow(map); if (!map) return NULL; - domain_dim = isl_dim_from_range(isl_dim_domain(isl_map_get_dim(map))); - map->dim = isl_dim_from_domain(isl_dim_wrap(map->dim)); - map->dim = isl_dim_join(map->dim, domain_dim); + domain_dim = isl_space_from_range(isl_space_domain(isl_map_get_space(map))); + map->dim = isl_space_from_domain(isl_space_wrap(map->dim)); + map->dim = isl_space_join(map->dim, domain_dim); if (!map->dim) goto error; for (i = 0; i < map->n; ++i) { @@ -3985,15 +4369,16 @@ error: __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map) { int i; - isl_dim *range_dim; + isl_space *range_dim; map = isl_map_cow(map); if (!map) return NULL; - range_dim = isl_dim_range(isl_map_get_dim(map)); - map->dim = isl_dim_from_domain(isl_dim_wrap(map->dim)); - map->dim = isl_dim_join(map->dim, range_dim); + range_dim = isl_space_range(isl_map_get_space(map)); + range_dim = isl_space_from_range(range_dim); + map->dim = isl_space_from_domain(isl_space_wrap(map->dim)); + map->dim = isl_space_join(map->dim, range_dim); if (!map->dim) goto error; for (i = 0; i < map->n; ++i) { @@ -4009,7 +4394,8 @@ error: return NULL; } -struct isl_map *isl_map_from_set(struct isl_set *set, struct isl_dim *dim) +__isl_give isl_map *isl_map_from_set(__isl_take isl_set *set, + __isl_take isl_space *dim) { int i; struct isl_map *map = NULL; @@ -4017,19 +4403,19 @@ struct isl_map *isl_map_from_set(struct isl_set *set, struct isl_dim *dim) set = isl_set_cow(set); if (!set || !dim) goto error; - isl_assert(set->ctx, isl_dim_compatible(set->dim, dim), goto error); + isl_assert(set->ctx, isl_space_compatible(set->dim, dim), goto error); map = (struct isl_map *)set; for (i = 0; i < set->n; ++i) { map->p[i] = isl_basic_map_from_basic_set( - set->p[i], isl_dim_copy(dim)); + set->p[i], isl_space_copy(dim)); if (!map->p[i]) goto error; } - isl_dim_free(map->dim); + isl_space_free(map->dim); map->dim = dim; return map; error: - isl_dim_free(dim); + isl_space_free(dim); isl_set_free(set); return NULL; } @@ -4043,11 +4429,19 @@ __isl_give isl_basic_map *isl_basic_map_from_domain( __isl_give isl_basic_map *isl_basic_map_from_range( __isl_take isl_basic_set *bset) { + isl_space *space; + space = isl_basic_set_get_space(bset); + space = isl_space_from_range(space); + bset = isl_basic_set_reset_space(bset, space); return (isl_basic_map *)bset; } struct isl_map *isl_map_from_range(struct isl_set *set) { + isl_space *space; + space = isl_set_get_space(set); + space = isl_space_from_range(space); + set = isl_set_reset_space(set, space); return (struct isl_map *)set; } @@ -4059,15 +4453,13 @@ __isl_give isl_map *isl_map_from_domain(__isl_take isl_set *set) __isl_give isl_basic_map *isl_basic_map_from_domain_and_range( __isl_take isl_basic_set *domain, __isl_take isl_basic_set *range) { - return isl_basic_map_apply_range(isl_basic_map_from_domain(domain), - isl_basic_map_from_range(range)); + return isl_basic_map_apply_range(isl_basic_map_reverse(domain), range); } __isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_set *domain, __isl_take isl_set *range) { - return isl_map_apply_range(isl_map_from_domain(domain), - isl_map_from_range(range)); + return isl_map_apply_range(isl_map_reverse(domain), range); } struct isl_set *isl_set_from_map(struct isl_map *map) @@ -4080,7 +4472,7 @@ struct isl_set *isl_set_from_map(struct isl_map *map) map = isl_map_cow(map); if (!map) return NULL; - map->dim = isl_dim_as_set_dim(map->dim); + map->dim = isl_space_as_set_space(map->dim); if (!map->dim) goto error; set = (struct isl_set *)map; @@ -4095,7 +4487,8 @@ error: return NULL; } -struct isl_map *isl_map_alloc_dim(struct isl_dim *dim, int n, unsigned flags) +__isl_give isl_map *isl_map_alloc_space(__isl_take isl_space *dim, int n, + unsigned flags) { struct isl_map *map; @@ -4117,7 +4510,7 @@ struct isl_map *isl_map_alloc_dim(struct isl_dim *dim, int n, unsigned flags) map->flags = flags; return map; error: - isl_dim_free(dim); + isl_space_free(dim); return NULL; } @@ -4126,28 +4519,28 @@ struct isl_map *isl_map_alloc(struct isl_ctx *ctx, unsigned flags) { struct isl_map *map; - struct isl_dim *dims; + isl_space *dims; - dims = isl_dim_alloc(ctx, nparam, in, out); + dims = isl_space_alloc(ctx, nparam, in, out); if (!dims) return NULL; - map = isl_map_alloc_dim(dims, n, flags); + map = isl_map_alloc_space(dims, n, flags); return map; } -struct isl_basic_map *isl_basic_map_empty(struct isl_dim *dim) +__isl_give isl_basic_map *isl_basic_map_empty(__isl_take isl_space *dim) { struct isl_basic_map *bmap; - bmap = isl_basic_map_alloc_dim(dim, 0, 1, 0); + bmap = isl_basic_map_alloc_space(dim, 0, 1, 0); bmap = isl_basic_map_set_to_empty(bmap); return bmap; } -struct isl_basic_set *isl_basic_set_empty(struct isl_dim *dim) +__isl_give isl_basic_set *isl_basic_set_empty(__isl_take isl_space *dim) { struct isl_basic_set *bset; - bset = isl_basic_set_alloc_dim(dim, 0, 1, 0); + bset = isl_basic_set_alloc_space(dim, 0, 1, 0); bset = isl_basic_set_set_to_empty(bset); return bset; } @@ -4157,7 +4550,7 @@ struct isl_basic_map *isl_basic_map_empty_like(struct isl_basic_map *model) struct isl_basic_map *bmap; if (!model) return NULL; - bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0); + bmap = isl_basic_map_alloc_space(isl_space_copy(model->dim), 0, 1, 0); bmap = isl_basic_map_set_to_empty(bmap); return bmap; } @@ -4167,7 +4560,7 @@ struct isl_basic_map *isl_basic_map_empty_like_map(struct isl_map *model) struct isl_basic_map *bmap; if (!model) return NULL; - bmap = isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0); + bmap = isl_basic_map_alloc_space(isl_space_copy(model->dim), 0, 1, 0); bmap = isl_basic_map_set_to_empty(bmap); return bmap; } @@ -4177,34 +4570,34 @@ struct isl_basic_set *isl_basic_set_empty_like(struct isl_basic_set *model) struct isl_basic_set *bset; if (!model) return NULL; - bset = isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 1, 0); + bset = isl_basic_set_alloc_space(isl_space_copy(model->dim), 0, 1, 0); bset = isl_basic_set_set_to_empty(bset); return bset; } -struct isl_basic_map *isl_basic_map_universe(struct isl_dim *dim) +__isl_give isl_basic_map *isl_basic_map_universe(__isl_take isl_space *dim) { struct isl_basic_map *bmap; - bmap = isl_basic_map_alloc_dim(dim, 0, 0, 0); + bmap = isl_basic_map_alloc_space(dim, 0, 0, 0); bmap = isl_basic_map_finalize(bmap); return bmap; } -struct isl_basic_set *isl_basic_set_universe(struct isl_dim *dim) +__isl_give isl_basic_set *isl_basic_set_universe(__isl_take isl_space *dim) { struct isl_basic_set *bset; - bset = isl_basic_set_alloc_dim(dim, 0, 0, 0); + bset = isl_basic_set_alloc_space(dim, 0, 0, 0); bset = isl_basic_set_finalize(bset); return bset; } -__isl_give isl_basic_map *isl_basic_map_nat_universe(__isl_take isl_dim *dim) +__isl_give isl_basic_map *isl_basic_map_nat_universe(__isl_take isl_space *dim) { int i; - unsigned total = isl_dim_total(dim); + unsigned total = isl_space_dim(dim, isl_dim_all); isl_basic_map *bmap; - bmap= isl_basic_map_alloc_dim(dim, 0, 0, total); + bmap= isl_basic_map_alloc_space(dim, 0, 0, total); for (i = 0; i < total; ++i) { int k = isl_basic_map_alloc_inequality(bmap); if (k < 0) @@ -4218,17 +4611,17 @@ error: return NULL; } -__isl_give isl_basic_set *isl_basic_set_nat_universe(__isl_take isl_dim *dim) +__isl_give isl_basic_set *isl_basic_set_nat_universe(__isl_take isl_space *dim) { return isl_basic_map_nat_universe(dim); } -__isl_give isl_map *isl_map_nat_universe(__isl_take isl_dim *dim) +__isl_give isl_map *isl_map_nat_universe(__isl_take isl_space *dim) { return isl_map_from_basic_map(isl_basic_map_nat_universe(dim)); } -__isl_give isl_set *isl_set_nat_universe(__isl_take isl_dim *dim) +__isl_give isl_set *isl_set_nat_universe(__isl_take isl_space *dim) { return isl_map_nat_universe(dim); } @@ -4238,14 +4631,14 @@ __isl_give isl_basic_map *isl_basic_map_universe_like( { if (!model) return NULL; - return isl_basic_map_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0); + return isl_basic_map_alloc_space(isl_space_copy(model->dim), 0, 0, 0); } struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *model) { if (!model) return NULL; - return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0); + return isl_basic_set_alloc_space(isl_space_copy(model->dim), 0, 0, 0); } __isl_give isl_basic_set *isl_basic_set_universe_like_set( @@ -4253,56 +4646,56 @@ __isl_give isl_basic_set *isl_basic_set_universe_like_set( { if (!model) return NULL; - return isl_basic_set_alloc_dim(isl_dim_copy(model->dim), 0, 0, 0); + return isl_basic_set_alloc_space(isl_space_copy(model->dim), 0, 0, 0); } -struct isl_map *isl_map_empty(struct isl_dim *dim) +__isl_give isl_map *isl_map_empty(__isl_take isl_space *dim) { - return isl_map_alloc_dim(dim, 0, ISL_MAP_DISJOINT); + return isl_map_alloc_space(dim, 0, ISL_MAP_DISJOINT); } struct isl_map *isl_map_empty_like(struct isl_map *model) { if (!model) return NULL; - return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT); + return isl_map_alloc_space(isl_space_copy(model->dim), 0, ISL_MAP_DISJOINT); } struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model) { if (!model) return NULL; - return isl_map_alloc_dim(isl_dim_copy(model->dim), 0, ISL_MAP_DISJOINT); + return isl_map_alloc_space(isl_space_copy(model->dim), 0, ISL_MAP_DISJOINT); } -struct isl_set *isl_set_empty(struct isl_dim *dim) +__isl_give isl_set *isl_set_empty(__isl_take isl_space *dim) { - return isl_set_alloc_dim(dim, 0, ISL_MAP_DISJOINT); + return isl_set_alloc_space(dim, 0, ISL_MAP_DISJOINT); } struct isl_set *isl_set_empty_like(struct isl_set *model) { if (!model) return NULL; - return isl_set_empty(isl_dim_copy(model->dim)); + return isl_set_empty(isl_space_copy(model->dim)); } -struct isl_map *isl_map_universe(struct isl_dim *dim) +__isl_give isl_map *isl_map_universe(__isl_take isl_space *dim) { struct isl_map *map; if (!dim) return NULL; - map = isl_map_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT); + map = isl_map_alloc_space(isl_space_copy(dim), 1, ISL_MAP_DISJOINT); map = isl_map_add_basic_map(map, isl_basic_map_universe(dim)); return map; } -struct isl_set *isl_set_universe(struct isl_dim *dim) +__isl_give isl_set *isl_set_universe(__isl_take isl_space *dim) { struct isl_set *set; if (!dim) return NULL; - set = isl_set_alloc_dim(isl_dim_copy(dim), 1, ISL_MAP_DISJOINT); + set = isl_set_alloc_space(isl_space_copy(dim), 1, ISL_MAP_DISJOINT); set = isl_set_add_basic_set(set, isl_basic_set_universe(dim)); return set; } @@ -4311,7 +4704,7 @@ __isl_give isl_set *isl_set_universe_like(__isl_keep isl_set *model) { if (!model) return NULL; - return isl_set_universe(isl_dim_copy(model->dim)); + return isl_set_universe(isl_space_copy(model->dim)); } struct isl_map *isl_map_dup(struct isl_map *map) @@ -4321,7 +4714,7 @@ struct isl_map *isl_map_dup(struct isl_map *map) if (!map) return NULL; - dup = isl_map_alloc_dim(isl_dim_copy(map->dim), map->n, map->flags); + dup = isl_map_alloc_space(isl_space_copy(map->dim), map->n, map->flags); for (i = 0; i < map->n; ++i) dup = isl_map_add_basic_map(dup, isl_basic_map_copy(map->p[i])); return dup; @@ -4332,11 +4725,11 @@ __isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map, { if (!bmap || !map) goto error; - if (isl_basic_map_fast_is_empty(bmap)) { + if (isl_basic_map_plain_is_empty(bmap)) { isl_basic_map_free(bmap); return map; } - isl_assert(map->ctx, isl_dim_equal(map->dim, bmap->dim), goto error); + isl_assert(map->ctx, isl_space_is_equal(map->dim, bmap->dim), goto error); isl_assert(map->ctx, map->n < map->size, goto error); map->p[map->n] = bmap; map->n++; @@ -4363,7 +4756,7 @@ void isl_map_free(struct isl_map *map) isl_ctx_deref(map->ctx); for (i = 0; i < map->n; ++i) isl_basic_map_free(map->p[i]); - isl_dim_free(map->dim); + isl_space_free(map->dim); free(map); } @@ -4376,12 +4769,12 @@ struct isl_map *isl_map_extend(struct isl_map *base, if (!base) return NULL; - base->dim = isl_dim_extend(base->dim, nparam, n_in, n_out); + base->dim = isl_space_extend(base->dim, nparam, n_in, n_out); if (!base->dim) goto error; for (i = 0; i < base->n; ++i) { - base->p[i] = isl_basic_map_extend_dim(base->p[i], - isl_dim_copy(base->dim), 0, 0, 0); + base->p[i] = isl_basic_map_extend_space(base->p[i], + isl_space_copy(base->dim), 0, 0, 0); if (!base->p[i]) goto error; } @@ -4667,7 +5060,7 @@ struct isl_map *isl_map_reverse(struct isl_map *map) if (!map) return NULL; - map->dim = isl_dim_reverse(map->dim); + map->dim = isl_space_reverse(map->dim); if (!map->dim) goto error; for (i = 0; i < map->n; ++i) { @@ -4752,7 +5145,7 @@ static __isl_give isl_map *basic_map_partial_lexopt( if (!dom) goto error; - if (isl_set_fast_is_empty(dom)) { + 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); @@ -4837,7 +5230,7 @@ error: * even when the domain of basic map i is disjoint from the domains of * the previous basic maps. */ -static __isl_give isl_map *isl_map_partial_lexopt( +static __isl_give isl_map *isl_map_partial_lexopt_aligned( __isl_take isl_map *map, __isl_take isl_set *dom, __isl_give isl_set **empty, int max) { @@ -4848,7 +5241,7 @@ static __isl_give isl_map *isl_map_partial_lexopt( if (!map || !dom) goto error; - if (isl_map_fast_is_empty(map)) { + if (isl_map_plain_is_empty(map)) { if (empty) *empty = dom; else @@ -4863,16 +5256,16 @@ static __isl_give isl_map *isl_map_partial_lexopt( isl_map *lt, *le; isl_map *res_i; isl_set *todo_i; - isl_dim *dim = isl_dim_range(isl_map_get_dim(res)); + isl_space *dim = isl_space_range(isl_map_get_space(res)); res_i = basic_map_partial_lexopt(isl_basic_map_copy(map->p[i]), isl_set_copy(dom), &todo_i, max); if (max) { - lt = isl_map_lex_lt(isl_dim_copy(dim)); + lt = isl_map_lex_lt(isl_space_copy(dim)); le = isl_map_lex_le(dim); } else { - lt = isl_map_lex_gt(isl_dim_copy(dim)); + lt = isl_map_lex_gt(isl_space_copy(dim)); le = isl_map_lex_ge(dim); } lt = isl_map_apply_range(isl_map_copy(res), lt); @@ -4911,6 +5304,35 @@ 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) @@ -4946,11 +5368,11 @@ __isl_give isl_set *isl_set_partial_lexmax( __isl_give isl_map *isl_basic_map_lexopt(__isl_take isl_basic_map *bmap, int max) { struct isl_basic_set *dom = NULL; - struct isl_dim *dom_dim; + isl_space *dom_dim; if (!bmap) goto error; - dom_dim = isl_dim_domain(isl_dim_copy(bmap->dim)); + dom_dim = isl_space_domain(isl_space_copy(bmap->dim)); dom = isl_basic_set_universe(dom_dim); return isl_basic_map_partial_lexopt(bmap, dom, NULL, max); error: @@ -4981,11 +5403,11 @@ __isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset) __isl_give isl_map *isl_map_lexopt(__isl_take isl_map *map, int max) { struct isl_set *dom = NULL; - struct isl_dim *dom_dim; + isl_space *dom_dim; if (!map) goto error; - dom_dim = isl_dim_domain(isl_dim_copy(map->dim)); + 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: @@ -5013,6 +5435,137 @@ __isl_give isl_set *isl_set_lexmax(__isl_take isl_set *set) return (isl_set *)isl_map_lexmax((isl_map *)set); } +/* Extract the first and only affine expression from list + * and then add it to *pwaff with the given dom. + * This domain is known to be disjoint from other domains + * because of the way isl_basic_map_foreach_lexmax works. + */ +static int update_dim_opt(__isl_take isl_basic_set *dom, + __isl_take isl_aff_list *list, void *user) +{ + isl_ctx *ctx = isl_basic_set_get_ctx(dom); + isl_aff *aff; + isl_pw_aff **pwaff = user; + isl_pw_aff *pwaff_i; + + if (isl_aff_list_n_aff(list) != 1) + isl_die(ctx, isl_error_internal, + "expecting single element list", goto error); + + aff = isl_aff_list_get_aff(list, 0); + pwaff_i = isl_pw_aff_alloc(isl_set_from_basic_set(dom), aff); + + *pwaff = isl_pw_aff_add_disjoint(*pwaff, pwaff_i); + + isl_aff_list_free(list); + + return 0; +error: + isl_basic_set_free(dom); + isl_aff_list_free(list); + return -1; +} + +/* Given a basic map with one output dimension, compute the minimum or + * maximum of that dimension as an isl_pw_aff. + * + * The isl_pw_aff is constructed by having isl_basic_map_foreach_lexopt + * call update_dim_opt on each leaf of the result. + */ +static __isl_give isl_pw_aff *basic_map_dim_opt(__isl_keep isl_basic_map *bmap, + int max) +{ + isl_space *dim = isl_basic_map_get_space(bmap); + isl_pw_aff *pwaff; + int r; + + dim = isl_space_from_domain(isl_space_domain(dim)); + dim = isl_space_add_dims(dim, isl_dim_out, 1); + pwaff = isl_pw_aff_empty(dim); + + r = isl_basic_map_foreach_lexopt(bmap, max, &update_dim_opt, &pwaff); + if (r < 0) + return isl_pw_aff_free(pwaff); + + return pwaff; +} + +/* Compute the minimum or maximum of the given output dimension + * as a function of the parameters and the input dimensions, + * but independently of the other output dimensions. + * + * We first project out the other output dimension and then compute + * the "lexicographic" maximum in each basic map, combining the results + * using isl_pw_aff_union_max. + */ +static __isl_give isl_pw_aff *map_dim_opt(__isl_take isl_map *map, int pos, + int max) +{ + int i; + isl_pw_aff *pwaff; + unsigned n_out; + + n_out = isl_map_dim(map, isl_dim_out); + map = isl_map_project_out(map, isl_dim_out, pos + 1, n_out - (pos + 1)); + map = isl_map_project_out(map, isl_dim_out, 0, pos); + if (!map) + return NULL; + + if (map->n == 0) { + isl_space *dim = isl_map_get_space(map); + dim = isl_space_domain(isl_space_from_range(dim)); + isl_map_free(map); + return isl_pw_aff_empty(dim); + } + + pwaff = basic_map_dim_opt(map->p[0], max); + for (i = 1; i < map->n; ++i) { + isl_pw_aff *pwaff_i; + + pwaff_i = basic_map_dim_opt(map->p[i], max); + pwaff = isl_pw_aff_union_opt(pwaff, pwaff_i, max); + } + + isl_map_free(map); + + return pwaff; +} + +/* Compute the maximum of the given output dimension as a function of the + * parameters and input dimensions, but independently of + * the other output dimensions. + */ +__isl_give isl_pw_aff *isl_map_dim_max(__isl_take isl_map *map, int pos) +{ + return map_dim_opt(map, pos, 1); +} + +/* Compute the minimum or maximum of the given set dimension + * as a function of the parameters, + * but independently of the other set dimensions. + */ +static __isl_give isl_pw_aff *set_dim_opt(__isl_take isl_set *set, int pos, + int max) +{ + return map_dim_opt(set, pos, max); +} + +/* Compute the maximum of the given set dimension as a function of the + * parameters, but independently of the other set dimensions. + */ +__isl_give isl_pw_aff *isl_set_dim_max(__isl_take isl_set *set, int pos) +{ + return set_dim_opt(set, pos, 1); +} + +/* Compute the minimum of the given set dimension as a function of the + * parameters, but independently of the other set dimensions. + */ +__isl_give isl_pw_aff *isl_set_dim_min(__isl_take isl_set *set, int pos) +{ + return set_dim_opt(set, pos, 0); +} + /* Apply a preimage specified by "mat" on the parameters of "bset". * bset is assumed to have only parameters and divs. */ @@ -5024,7 +5577,7 @@ static struct isl_basic_set *basic_set_parameter_preimage( if (!bset || !mat) goto error; - bset->dim = isl_dim_cow(bset->dim); + bset->dim = isl_space_cow(bset->dim); if (!bset->dim) goto error; @@ -5052,14 +5605,14 @@ error: static struct isl_set *set_parameter_preimage( struct isl_set *set, struct isl_mat *mat) { - struct isl_dim *dim = NULL; + isl_space *dim = NULL; unsigned nparam; if (!set || !mat) goto error; - dim = isl_dim_copy(set->dim); - dim = isl_dim_cow(dim); + dim = isl_space_copy(set->dim); + dim = isl_space_cow(dim); if (!dim) goto error; @@ -5069,20 +5622,20 @@ static struct isl_set *set_parameter_preimage( dim->nparam = 0; dim->n_out = nparam; - isl_set_reset_dim(set, dim); + isl_set_reset_space(set, dim); set = isl_set_preimage(set, mat); if (!set) goto error2; - dim = isl_dim_copy(set->dim); - dim = isl_dim_cow(dim); + dim = isl_space_copy(set->dim); + dim = isl_space_cow(dim); if (!dim) goto error2; dim->nparam = dim->n_out; dim->n_out = 0; - isl_set_reset_dim(set, dim); + isl_set_reset_space(set, dim); return set; error: - isl_dim_free(dim); + isl_space_free(dim); isl_mat_free(mat); error2: isl_set_free(set); @@ -5101,12 +5654,12 @@ static struct isl_basic_set *basic_set_append_equalities( if (!bset || !eq) goto error; - bset = isl_basic_set_extend_dim(bset, isl_dim_copy(bset->dim), 0, + bset = isl_basic_set_extend_space(bset, isl_space_copy(bset->dim), 0, eq->n_row, 0); if (!bset) goto error; - len = 1 + isl_dim_total(bset->dim) + bset->extra; + len = 1 + isl_space_dim(bset->dim, isl_dim_all) + bset->extra; for (i = 0; i < eq->n_row; ++i) { k = isl_basic_set_alloc_equality(bset); if (k < 0) @@ -5190,7 +5743,7 @@ static struct isl_set *parameter_compute_divs(struct isl_basic_set *bset) if (i == bset->n_eq) return isl_basic_set_lexmin(bset); - eq = isl_mat_sub_alloc(bset->ctx, bset->eq, i, bset->n_eq - i, + eq = isl_mat_sub_alloc6(bset->ctx, bset->eq, i, bset->n_eq - i, 0, 1 + nparam); eq = isl_mat_cow(eq); T = isl_mat_variable_compression(isl_mat_copy(eq), &T2); @@ -5221,7 +5774,7 @@ static struct isl_map *compute_divs(struct isl_basic_map *bmap) struct isl_basic_set *bset; struct isl_set *set; struct isl_map *map; - struct isl_dim *dim, *orig_dim = NULL; + isl_space *dim, *orig_dim = NULL; unsigned nparam; unsigned n_in; unsigned n_out; @@ -5233,7 +5786,7 @@ static struct isl_map *compute_divs(struct isl_basic_map *bmap) nparam = isl_basic_map_dim(bmap, isl_dim_param); n_in = isl_basic_map_dim(bmap, isl_dim_in); n_out = isl_basic_map_dim(bmap, isl_dim_out); - dim = isl_dim_set_alloc(bmap->ctx, nparam + n_in + n_out, 0); + dim = isl_space_set_alloc(bmap->ctx, nparam + n_in + n_out, 0); if (!dim) goto error; @@ -5243,7 +5796,7 @@ static struct isl_map *compute_divs(struct isl_basic_map *bmap) set = parameter_compute_divs(bset); map = (struct isl_map *)set; - map = isl_map_reset_dim(map, orig_dim); + map = isl_map_reset_space(map, orig_dim); return map; error: @@ -5251,7 +5804,7 @@ error: return NULL; } -static int basic_map_divs_known(__isl_keep isl_basic_map *bmap) +int isl_basic_map_divs_known(__isl_keep isl_basic_map *bmap) { int i; unsigned off; @@ -5259,7 +5812,7 @@ static int basic_map_divs_known(__isl_keep isl_basic_map *bmap) if (!bmap) return -1; - off = isl_dim_total(bmap->dim); + off = isl_space_dim(bmap->dim, isl_dim_all); for (i = 0; i < bmap->n_div; ++i) { if (isl_int_is_zero(bmap->div[i][0])) return 0; @@ -5277,7 +5830,7 @@ static int map_divs_known(__isl_keep isl_map *map) return -1; for (i = 0; i < map->n; ++i) { - int known = basic_map_divs_known(map->p[i]); + int known = isl_basic_map_divs_known(map->p[i]); if (known <= 0) return known; } @@ -5292,11 +5845,10 @@ static int map_divs_known(__isl_keep isl_map *map) */ struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap) { - int i; int known; struct isl_map *map; - known = basic_map_divs_known(bmap); + known = isl_basic_map_divs_known(bmap); if (known < 0) goto error; if (known) @@ -5304,7 +5856,7 @@ struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap) bmap = isl_basic_map_drop_redundant_divs(bmap); - known = basic_map_divs_known(bmap); + known = isl_basic_map_divs_known(bmap); if (known < 0) goto error; if (known) @@ -5375,7 +5927,7 @@ struct isl_set *isl_map_domain(struct isl_map *map) return NULL; set = (struct isl_set *)map; - set->dim = isl_dim_domain(set->dim); + set->dim = isl_space_domain(set->dim); if (!set->dim) goto error; for (i = 0; i < map->n; ++i) { @@ -5391,8 +5943,8 @@ error: return NULL; } -struct isl_map *isl_map_union_disjoint( - struct isl_map *map1, struct isl_map *map2) +static __isl_give isl_map *map_union_disjoint(__isl_take isl_map *map1, + __isl_take isl_map *map2) { int i; unsigned flags = 0; @@ -5410,13 +5962,13 @@ struct isl_map *isl_map_union_disjoint( return map1; } - isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error); + isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error); if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) && ISL_F_ISSET(map2, ISL_MAP_DISJOINT)) ISL_FL_SET(flags, ISL_MAP_DISJOINT); - map = isl_map_alloc_dim(isl_dim_copy(map1->dim), + map = isl_map_alloc_space(isl_space_copy(map1->dim), map1->n + map2->n, flags); if (!map) goto error; @@ -5442,6 +5994,12 @@ error: return NULL; } +__isl_give isl_map *isl_map_union_disjoint(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + return isl_map_align_params_map_map_and(map1, map2, &map_union_disjoint); +} + struct isl_map *isl_map_union(struct isl_map *map1, struct isl_map *map2) { map1 = isl_map_union_disjoint(map1, map2); @@ -5466,8 +6024,8 @@ 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); } -struct isl_map *isl_map_intersect_range( - struct isl_map *map, struct isl_set *set) +static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map, + __isl_take isl_set *set) { unsigned flags = 0; struct isl_map *result; @@ -5476,11 +6034,25 @@ struct isl_map *isl_map_intersect_range( 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; + } + if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) && ISL_F_ISSET(set, ISL_MAP_DISJOINT)) ISL_FL_SET(flags, ISL_MAP_DISJOINT); - result = isl_map_alloc_dim(isl_dim_copy(map->dim), + result = isl_map_alloc_space(isl_space_copy(map->dim), map->n * set->n, flags); if (!result) goto error; @@ -5502,6 +6074,12 @@ error: return NULL; } +__isl_give isl_map *isl_map_intersect_range(__isl_take isl_map *map, + __isl_take isl_set *set) +{ + 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) { @@ -5509,8 +6087,8 @@ struct isl_map *isl_map_intersect_domain( isl_map_intersect_range(isl_map_reverse(map), set)); } -struct isl_map *isl_map_apply_domain( - struct isl_map *map1, struct isl_map *map2) +static __isl_give isl_map *map_apply_domain(__isl_take isl_map *map1, + __isl_take isl_map *map2) { if (!map1 || !map2) goto error; @@ -5523,20 +6101,26 @@ error: return NULL; } -struct isl_map *isl_map_apply_range( - struct isl_map *map1, struct isl_map *map2) +__isl_give isl_map *isl_map_apply_domain(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + return isl_map_align_params_map_map_and(map1, map2, &map_apply_domain); +} + +static __isl_give isl_map *map_apply_range(__isl_take isl_map *map1, + __isl_take isl_map *map2) { - struct isl_dim *dim_result; + isl_space *dim_result; struct isl_map *result; int i, j; if (!map1 || !map2) goto error; - dim_result = isl_dim_join(isl_dim_copy(map1->dim), - isl_dim_copy(map2->dim)); + dim_result = isl_space_join(isl_space_copy(map1->dim), + isl_space_copy(map2->dim)); - result = isl_map_alloc_dim(dim_result, map1->n * map2->n, 0); + result = isl_map_alloc_space(dim_result, map1->n * map2->n, 0); if (!result) goto error; for (i = 0; i < map1->n; ++i) @@ -5559,12 +6143,18 @@ error: return NULL; } +__isl_give isl_map *isl_map_apply_range(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + return isl_map_align_params_map_map_and(map1, map2, &map_apply_range); +} + /* * returns range - domain */ struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap) { - isl_dim *dims, *target_dim; + isl_space *dims, *target_dim; struct isl_basic_set *bset; unsigned dim; unsigned nparam; @@ -5572,17 +6162,17 @@ struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap) if (!bmap) goto error; - isl_assert(bmap->ctx, isl_dim_tuple_match(bmap->dim, isl_dim_in, + isl_assert(bmap->ctx, isl_space_tuple_match(bmap->dim, isl_dim_in, bmap->dim, isl_dim_out), goto error); - target_dim = isl_dim_domain(isl_basic_map_get_dim(bmap)); + target_dim = isl_space_domain(isl_basic_map_get_space(bmap)); dim = isl_basic_map_n_in(bmap); nparam = isl_basic_map_n_param(bmap); bset = isl_basic_set_from_basic_map(bmap); bset = isl_basic_set_cow(bset); - dims = isl_basic_set_get_dim(bset); - dims = isl_dim_add(dims, isl_dim_set, dim); - bset = isl_basic_set_extend_dim(bset, dims, 0, dim, 0); + dims = isl_basic_set_get_space(bset); + dims = isl_space_add_dims(dims, isl_dim_set, dim); + bset = isl_basic_set_extend_space(bset, dims, 0, dim, 0); bset = isl_basic_set_swap_vars(bset, 2*dim); for (i = 0; i < dim; ++i) { int j = isl_basic_map_alloc_equality( @@ -5595,7 +6185,7 @@ struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap) isl_int_set_si(bset->eq[j][1+nparam+2*dim+i], -1); } bset = isl_basic_set_project_out(bset, isl_dim_set, dim, 2*dim); - bset = isl_basic_set_reset_dim(bset, target_dim); + bset = isl_basic_set_reset_space(bset, target_dim); return bset; error: isl_basic_map_free(bmap); @@ -5608,18 +6198,18 @@ error: struct isl_set *isl_map_deltas(struct isl_map *map) { int i; - isl_dim *dim; + isl_space *dim; struct isl_set *result; if (!map) return NULL; - isl_assert(map->ctx, isl_dim_tuple_match(map->dim, isl_dim_in, + isl_assert(map->ctx, isl_space_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out), goto error); - dim = isl_map_get_dim(map); - dim = isl_dim_domain(dim); - result = isl_set_alloc_dim(dim, map->n, 0); + dim = isl_map_get_space(map); + dim = isl_space_domain(dim); + result = isl_set_alloc_space(dim, map->n, 0); if (!result) goto error; for (i = 0; i < map->n; ++i) @@ -5639,20 +6229,19 @@ __isl_give isl_basic_map *isl_basic_map_deltas_map( __isl_take isl_basic_map *bmap) { int i, k; - isl_dim *dim; + isl_space *dim; isl_basic_map *domain; - isl_basic_set *bset; int nparam, n; unsigned total; - if (!isl_dim_tuple_match(bmap->dim, isl_dim_in, bmap->dim, isl_dim_out)) + if (!isl_space_tuple_match(bmap->dim, isl_dim_in, bmap->dim, isl_dim_out)) isl_die(bmap->ctx, isl_error_invalid, "domain and range don't match", goto error); nparam = isl_basic_map_dim(bmap, isl_dim_param); n = isl_basic_map_dim(bmap, isl_dim_in); - dim = isl_dim_from_range(isl_dim_domain(isl_basic_map_get_dim(bmap))); + dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap))); domain = isl_basic_map_universe(dim); bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap)); @@ -5684,12 +6273,12 @@ error: __isl_give isl_map *isl_map_deltas_map(__isl_take isl_map *map) { int i; - isl_dim *domain_dim; + isl_space *domain_dim; if (!map) return NULL; - if (!isl_dim_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out)) + if (!isl_space_tuple_match(map->dim, isl_dim_in, map->dim, isl_dim_out)) isl_die(map->ctx, isl_error_invalid, "domain and range don't match", goto error); @@ -5697,9 +6286,9 @@ __isl_give isl_map *isl_map_deltas_map(__isl_take isl_map *map) if (!map) return NULL; - domain_dim = isl_dim_from_range(isl_dim_domain(isl_map_get_dim(map))); - map->dim = isl_dim_from_domain(isl_dim_wrap(map->dim)); - map->dim = isl_dim_join(map->dim, domain_dim); + domain_dim = isl_space_from_range(isl_space_domain(isl_map_get_space(map))); + map->dim = isl_space_from_domain(isl_space_wrap(map->dim)); + map->dim = isl_space_join(map->dim, domain_dim); if (!map->dim) goto error; for (i = 0; i < map->n; ++i) { @@ -5714,7 +6303,7 @@ error: return NULL; } -static struct isl_basic_map *basic_map_identity(struct isl_dim *dims) +__isl_give struct isl_basic_map *basic_map_identity(__isl_take isl_space *dims) { struct isl_basic_map *bmap; unsigned nparam; @@ -5726,7 +6315,7 @@ static struct isl_basic_map *basic_map_identity(struct isl_dim *dims) nparam = dims->nparam; dim = dims->n_out; - bmap = isl_basic_map_alloc_dim(dims, 0, dim, 0); + bmap = isl_basic_map_alloc_space(dims, 0, dim, 0); if (!bmap) goto error; @@ -5744,7 +6333,7 @@ error: return NULL; } -__isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_dim *dim) +__isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_space *dim) { if (!dim) return NULL; @@ -5754,7 +6343,7 @@ __isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_dim *dim) "the same", goto error); return basic_map_identity(dim); error: - isl_dim_free(dim); + isl_space_free(dim); return NULL; } @@ -5762,10 +6351,10 @@ struct isl_basic_map *isl_basic_map_identity_like(struct isl_basic_map *model) { if (!model || !model->dim) return NULL; - return isl_basic_map_identity(isl_dim_copy(model->dim)); + return isl_basic_map_identity(isl_space_copy(model->dim)); } -__isl_give isl_map *isl_map_identity(__isl_take isl_dim *dim) +__isl_give isl_map *isl_map_identity(__isl_take isl_space *dim) { return isl_map_from_basic_map(isl_basic_map_identity(dim)); } @@ -5774,39 +6363,40 @@ struct isl_map *isl_map_identity_like(struct isl_map *model) { if (!model || !model->dim) return NULL; - return isl_map_identity(isl_dim_copy(model->dim)); + return isl_map_identity(isl_space_copy(model->dim)); } struct isl_map *isl_map_identity_like_basic_map(struct isl_basic_map *model) { if (!model || !model->dim) return NULL; - return isl_map_identity(isl_dim_copy(model->dim)); + return isl_map_identity(isl_space_copy(model->dim)); } __isl_give isl_map *isl_set_identity(__isl_take isl_set *set) { - isl_dim *dim = isl_set_get_dim(set); + isl_space *dim = isl_set_get_space(set); isl_map *id; - id = isl_map_identity(isl_dim_map_from_set(dim)); + id = isl_map_identity(isl_space_map_from_set(dim)); return isl_map_intersect_range(id, set); } /* Construct a basic set with all set dimensions having only non-negative * values. */ -struct isl_basic_set *isl_basic_set_positive_orthant(struct isl_dim *dims) +__isl_give isl_basic_set *isl_basic_set_positive_orthant( + __isl_take isl_space *space) { int i; unsigned nparam; unsigned dim; struct isl_basic_set *bset; - if (!dims) + if (!space) return NULL; - nparam = dims->nparam; - dim = dims->n_out; - bset = isl_basic_set_alloc_dim(dims, 0, 0, dim); + nparam = space->nparam; + dim = space->n_out; + bset = isl_basic_set_alloc_space(space, 0, 0, dim); if (!bset) return NULL; for (i = 0; i < dim; ++i) { @@ -5824,13 +6414,13 @@ error: /* Construct the half-space x_pos >= 0. */ -static __isl_give isl_basic_set *nonneg_halfspace(__isl_take isl_dim *dim, +static __isl_give isl_basic_set *nonneg_halfspace(__isl_take isl_space *dim, int pos) { int k; isl_basic_set *nonneg; - nonneg = isl_basic_set_alloc_dim(dim, 0, 0, 1); + nonneg = isl_basic_set_alloc_space(dim, 0, 0, 1); k = isl_basic_set_alloc_inequality(nonneg); if (k < 0) goto error; @@ -5845,12 +6435,12 @@ error: /* Construct the half-space x_pos <= -1. */ -static __isl_give isl_basic_set *neg_halfspace(__isl_take isl_dim *dim, int pos) +static __isl_give isl_basic_set *neg_halfspace(__isl_take isl_space *dim, int pos) { int k; isl_basic_set *neg; - neg = isl_basic_set_alloc_dim(dim, 0, 0, 1); + neg = isl_basic_set_alloc_space(dim, 0, 0, 1); k = isl_basic_set_alloc_inequality(neg); if (k < 0) goto error; @@ -5879,9 +6469,9 @@ __isl_give isl_set *isl_set_split_dims(__isl_take isl_set *set, isl_assert(set->ctx, first + n <= isl_set_dim(set, type), goto error); for (i = 0; i < n; ++i) { - nonneg = nonneg_halfspace(isl_set_get_dim(set), + nonneg = nonneg_halfspace(isl_set_get_space(set), pos(set->dim, type) + first + i); - neg = neg_halfspace(isl_set_get_dim(set), + neg = neg_halfspace(isl_set_get_space(set), pos(set->dim, type) + first + i); set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg)); @@ -5901,7 +6491,7 @@ static int foreach_orthant(__isl_take isl_set *set, int *signs, int first, if (!set) return -1; - if (isl_set_fast_is_empty(set)) { + if (isl_set_plain_is_empty(set)) { isl_set_free(set); return 0; } @@ -5909,14 +6499,14 @@ static int foreach_orthant(__isl_take isl_set *set, int *signs, int first, return fn(set, signs, user); signs[first] = 1; - half = isl_set_from_basic_set(nonneg_halfspace(isl_set_get_dim(set), + half = isl_set_from_basic_set(nonneg_halfspace(isl_set_get_space(set), 1 + first)); half = isl_set_intersect(half, isl_set_copy(set)); if (foreach_orthant(half, signs, first + 1, len, fn, user) < 0) goto error; signs[first] = -1; - half = isl_set_from_basic_set(neg_halfspace(isl_set_get_dim(set), + half = isl_set_from_basic_set(neg_halfspace(isl_set_get_space(set), 1 + first)); half = isl_set_intersect(half, set); return foreach_orthant(half, signs, first + 1, len, fn, user); @@ -5941,7 +6531,7 @@ int isl_set_foreach_orthant(__isl_keep isl_set *set, if (!set) return -1; - if (isl_set_fast_is_empty(set)) + if (isl_set_plain_is_empty(set)) return 0; nparam = isl_set_dim(set, isl_dim_param); @@ -6021,38 +6611,48 @@ int isl_map_is_empty(struct isl_map *map) return 1; } -int isl_map_fast_is_empty(struct isl_map *map) +int isl_map_plain_is_empty(__isl_keep isl_map *map) { return map ? map->n == 0 : -1; } -int isl_set_fast_is_empty(struct isl_set *set) +int isl_map_fast_is_empty(__isl_keep isl_map *map) { - return set ? set->n == 0 : -1; + return isl_map_plain_is_empty(map); } -int isl_set_is_empty(struct isl_set *set) +int isl_set_plain_is_empty(struct isl_set *set) { - return isl_map_is_empty((struct isl_map *)set); + return set ? set->n == 0 : -1; +} + +int isl_set_fast_is_empty(__isl_keep isl_set *set) +{ + return isl_set_plain_is_empty(set); +} + +int isl_set_is_empty(struct isl_set *set) +{ + return isl_map_is_empty((struct isl_map *)set); } -int isl_map_has_equal_dim(__isl_keep isl_map *map1, __isl_keep isl_map *map2) +int isl_map_has_equal_space(__isl_keep isl_map *map1, __isl_keep isl_map *map2) { if (!map1 || !map2) return -1; - return isl_dim_equal(map1->dim, map2->dim); + return isl_space_is_equal(map1->dim, map2->dim); } -int isl_set_has_equal_dim(__isl_keep isl_set *set1, __isl_keep isl_set *set2) +int isl_set_has_equal_space(__isl_keep isl_set *set1, __isl_keep isl_set *set2) { if (!set1 || !set2) return -1; - return isl_dim_equal(set1->dim, set2->dim); + return isl_space_is_equal(set1->dim, set2->dim); } -int isl_map_is_equal(struct isl_map *map1, struct isl_map *map2) +static int map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2) { int is_subset; @@ -6065,6 +6665,11 @@ int isl_map_is_equal(struct isl_map *map1, struct isl_map *map2) return is_subset; } +int isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2) +{ + return align_params_map_map_and_test(map1, map2, &map_is_equal); +} + int isl_basic_map_is_strict_subset( struct isl_basic_map *bmap1, struct isl_basic_map *bmap2) { @@ -6115,7 +6720,7 @@ int isl_basic_set_is_universe(struct isl_basic_set *bset) return bset->n_eq == 0 && bset->n_ineq == 0; } -int isl_map_fast_is_universe(__isl_keep isl_map *map) +int isl_map_plain_is_universe(__isl_keep isl_map *map) { int i; @@ -6131,9 +6736,14 @@ int isl_map_fast_is_universe(__isl_keep isl_map *map) return 0; } +int isl_set_plain_is_universe(__isl_keep isl_set *set) +{ + return isl_map_plain_is_universe((isl_map *) set); +} + int isl_set_fast_is_universe(__isl_keep isl_set *set) { - return isl_map_fast_is_universe((isl_map *) set); + return isl_set_plain_is_universe(set); } int isl_basic_map_is_empty(struct isl_basic_map *bmap) @@ -6182,20 +6792,30 @@ int isl_basic_map_is_empty(struct isl_basic_map *bmap) return empty; } -int isl_basic_map_fast_is_empty(struct isl_basic_map *bmap) +int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap) { if (!bmap) return -1; return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY); } -int isl_basic_set_fast_is_empty(struct isl_basic_set *bset) +int isl_basic_map_fast_is_empty(__isl_keep isl_basic_map *bmap) +{ + return isl_basic_map_plain_is_empty(bmap); +} + +int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset) { if (!bset) return -1; return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY); } +int isl_basic_set_fast_is_empty(__isl_keep isl_basic_set *bset) +{ + return isl_basic_set_plain_is_empty(bset); +} + int isl_basic_set_is_empty(struct isl_basic_set *bset) { return isl_basic_map_is_empty((struct isl_basic_map *)bset); @@ -6208,9 +6828,9 @@ struct isl_map *isl_basic_map_union( if (!bmap1 || !bmap2) return NULL; - isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), goto error); + isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim), goto error); - map = isl_map_alloc_dim(isl_dim_copy(bmap1->dim), 2, 0); + map = isl_map_alloc_space(isl_space_copy(bmap1->dim), 2, 0); if (!map) goto error; map = isl_map_add_basic_map(map, bmap1); @@ -6239,7 +6859,7 @@ struct isl_basic_map *isl_basic_map_order_divs(struct isl_basic_map *bmap) if (!bmap) return NULL; - off = isl_dim_total(bmap->dim); + off = isl_space_dim(bmap->dim, isl_dim_all); for (i = 0; i < bmap->n_div; ++i) { int pos; @@ -6280,6 +6900,54 @@ error: return NULL; } +/* Apply the expansion computed by isl_merge_divs. + * The expansion itself is given by "exp" while the resulting + * list of divs is given by "div". + */ +__isl_give isl_basic_set *isl_basic_set_expand_divs( + __isl_take isl_basic_set *bset, __isl_take isl_mat *div, int *exp) +{ + int i, j; + int n_div; + + bset = isl_basic_set_cow(bset); + if (!bset || !div) + goto error; + + if (div->n_row < bset->n_div) + isl_die(isl_mat_get_ctx(div), isl_error_invalid, + "not an expansion", goto error); + + 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)); + + n_div = bset->n_div; + for (i = n_div; i < div->n_row; ++i) + if (isl_basic_set_alloc_div(bset) < 0) + goto error; + + j = n_div - 1; + for (i = div->n_row - 1; i >= 0; --i) { + if (j >= 0 && exp[j] == i) { + if (i != j) + isl_basic_map_swap_div(bset, i, j); + j--; + } else { + isl_seq_cpy(bset->div[i], div->row[i], div->n_col); + if (isl_basic_map_add_div_constraints(bset, i) < 0) + goto error; + } + } + + isl_mat_free(div); + return bset; +error: + isl_basic_set_free(bset); + isl_mat_free(div); + return NULL; +} + /* Look for a div in dst that corresponds to the div "div" in src. * The divs before "div" in src and dst are assumed to be the same. * @@ -6291,7 +6959,7 @@ static int find_div(struct isl_basic_map *dst, { int i; - unsigned total = isl_dim_total(src->dim); + unsigned total = isl_space_dim(src->dim, isl_dim_all); isl_assert(dst->ctx, div <= dst->n_div, return -1); for (i = div; i < dst->n_div; ++i) @@ -6306,7 +6974,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_dim_total(src->dim); + unsigned total = isl_space_dim(src->dim, isl_dim_all); if (!dst || !src) goto error; @@ -6319,7 +6987,7 @@ struct isl_basic_map *isl_basic_map_align_divs( src = isl_basic_map_order_divs(src); dst = isl_basic_map_cow(dst); - dst = isl_basic_map_extend_dim(dst, isl_dim_copy(dst->dim), + dst = isl_basic_map_extend_space(dst, isl_space_copy(dst->dim), src->n_div, 0, 2 * src->n_div); if (!dst) return NULL; @@ -6377,7 +7045,8 @@ struct isl_set *isl_set_align_divs(struct isl_set *set) return (struct isl_set *)isl_map_align_divs((struct isl_map *)set); } -struct isl_set *isl_set_apply(struct isl_set *set, struct isl_map *map) +static __isl_give isl_set *set_apply( __isl_take isl_set *set, + __isl_take isl_map *map) { if (!set || !map) goto error; @@ -6391,6 +7060,12 @@ error: return NULL; } +__isl_give isl_set *isl_set_apply( __isl_take isl_set *set, + __isl_take isl_map *map) +{ + return isl_map_align_params_map_map_and(set, map, &set_apply); +} + /* There is no need to cow as removing empty parts doesn't change * the meaning of the set. */ @@ -6479,7 +7154,7 @@ static enum isl_lp_result basic_set_maximal_difference_at( __isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2, int pos, isl_int *opt) { - struct isl_dim *dims; + isl_space *dims; struct isl_basic_map *bmap1 = NULL; struct isl_basic_map *bmap2 = NULL; struct isl_ctx *ctx; @@ -6495,9 +7170,9 @@ static enum isl_lp_result basic_set_maximal_difference_at( nparam = isl_basic_set_n_param(bset1); dim1 = isl_basic_set_n_dim(bset1); dim2 = isl_basic_set_n_dim(bset2); - dims = isl_dim_alloc(bset1->ctx, nparam, pos, dim1 - pos); + dims = isl_space_alloc(bset1->ctx, nparam, pos, dim1 - pos); bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), dims); - dims = isl_dim_alloc(bset2->ctx, nparam, pos, dim2 - pos); + dims = isl_space_alloc(bset2->ctx, nparam, pos, dim2 - pos); bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), dims); if (!bmap1 || !bmap2) goto error; @@ -6634,7 +7309,7 @@ int isl_set_follows_at(__isl_keep isl_set *set1, return follows; } -static int isl_basic_map_fast_has_fixed_var(struct isl_basic_map *bmap, +static int isl_basic_map_plain_has_fixed_var(__isl_keep isl_basic_map *bmap, unsigned pos, isl_int *val) { int i; @@ -6663,7 +7338,7 @@ static int isl_basic_map_fast_has_fixed_var(struct isl_basic_map *bmap, return 0; } -static int isl_map_fast_has_fixed_var(struct isl_map *map, +static int isl_map_plain_has_fixed_var(__isl_keep isl_map *map, unsigned pos, isl_int *val) { int i; @@ -6676,12 +7351,12 @@ static int isl_map_fast_has_fixed_var(struct isl_map *map, if (map->n == 0) return 0; if (map->n == 1) - return isl_basic_map_fast_has_fixed_var(map->p[0], pos, val); + return isl_basic_map_plain_has_fixed_var(map->p[0], pos, val); isl_int_init(v); isl_int_init(tmp); - fixed = isl_basic_map_fast_has_fixed_var(map->p[0], pos, &v); + fixed = isl_basic_map_plain_has_fixed_var(map->p[0], pos, &v); for (i = 1; fixed == 1 && i < map->n; ++i) { - fixed = isl_basic_map_fast_has_fixed_var(map->p[i], pos, &tmp); + fixed = isl_basic_map_plain_has_fixed_var(map->p[i], pos, &tmp); if (fixed == 1 && isl_int_ne(tmp, v)) fixed = 0; } @@ -6692,68 +7367,88 @@ static int isl_map_fast_has_fixed_var(struct isl_map *map, return fixed; } -static int isl_basic_set_fast_has_fixed_var(struct isl_basic_set *bset, +static int isl_basic_set_plain_has_fixed_var(__isl_keep isl_basic_set *bset, unsigned pos, isl_int *val) { - return isl_basic_map_fast_has_fixed_var((struct isl_basic_map *)bset, + return isl_basic_map_plain_has_fixed_var((struct isl_basic_map *)bset, pos, val); } -static int isl_set_fast_has_fixed_var(struct isl_set *set, unsigned pos, +static int isl_set_plain_has_fixed_var(__isl_keep isl_set *set, unsigned pos, isl_int *val) { - return isl_map_fast_has_fixed_var((struct isl_map *)set, pos, val); + return isl_map_plain_has_fixed_var((struct isl_map *)set, pos, val); } -int isl_basic_map_fast_is_fixed(struct isl_basic_map *bmap, +int isl_basic_map_plain_is_fixed(__isl_keep isl_basic_map *bmap, enum isl_dim_type type, unsigned pos, isl_int *val) { if (pos >= isl_basic_map_dim(bmap, type)) return -1; - return isl_basic_map_fast_has_fixed_var(bmap, + return isl_basic_map_plain_has_fixed_var(bmap, isl_basic_map_offset(bmap, type) - 1 + pos, val); } -int isl_map_fast_is_fixed(struct isl_map *map, +int isl_map_plain_is_fixed(__isl_keep isl_map *map, enum isl_dim_type type, unsigned pos, isl_int *val) { if (pos >= isl_map_dim(map, type)) return -1; - return isl_map_fast_has_fixed_var(map, + return isl_map_plain_has_fixed_var(map, map_offset(map, type) - 1 + pos, val); } +int isl_set_plain_is_fixed(__isl_keep isl_set *set, + enum isl_dim_type type, unsigned pos, isl_int *val) +{ + return isl_map_plain_is_fixed(set, type, pos, val); +} + +int isl_map_fast_is_fixed(__isl_keep isl_map *map, + enum isl_dim_type type, unsigned pos, isl_int *val) +{ + return isl_map_plain_is_fixed(map, type, pos, val); +} + /* Check if dimension dim has fixed value and if so and if val is not NULL, * then return this fixed value in *val. */ -int isl_basic_set_fast_dim_is_fixed(struct isl_basic_set *bset, unsigned dim, - isl_int *val) +int isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset, + unsigned dim, isl_int *val) { - return isl_basic_set_fast_has_fixed_var(bset, + return isl_basic_set_plain_has_fixed_var(bset, isl_basic_set_n_param(bset) + dim, val); } /* Check if dimension dim has fixed value and if so and if val is not NULL, * then return this fixed value in *val. */ -int isl_set_fast_dim_is_fixed(struct isl_set *set, unsigned dim, isl_int *val) +int isl_set_plain_dim_is_fixed(__isl_keep isl_set *set, + unsigned dim, isl_int *val) +{ + return isl_set_plain_has_fixed_var(set, isl_set_n_param(set) + dim, val); +} + +int isl_set_fast_dim_is_fixed(__isl_keep isl_set *set, + unsigned dim, isl_int *val) { - return isl_set_fast_has_fixed_var(set, isl_set_n_param(set) + dim, val); + return isl_set_plain_dim_is_fixed(set, dim, val); } /* Check if input variable in has fixed value and if so and if val is not NULL, * then return this fixed value in *val. */ -int isl_map_fast_input_is_fixed(struct isl_map *map, unsigned in, isl_int *val) +int isl_map_plain_input_is_fixed(__isl_keep isl_map *map, + unsigned in, isl_int *val) { - return isl_map_fast_has_fixed_var(map, isl_map_n_param(map) + in, val); + return isl_map_plain_has_fixed_var(map, isl_map_n_param(map) + in, val); } /* Check if dimension dim has an (obvious) fixed lower bound and if so * and if val is not NULL, then return this lower bound in *val. */ -int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset, - unsigned dim, isl_int *val) +int isl_basic_set_plain_dim_has_fixed_lower_bound( + __isl_keep isl_basic_set *bset, unsigned dim, isl_int *val) { int i, i_eq = -1, i_ineq = -1; isl_int *c; @@ -6794,7 +7489,7 @@ int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset, return 1; } -int isl_set_fast_dim_has_fixed_lower_bound(struct isl_set *set, +int isl_set_plain_dim_has_fixed_lower_bound(__isl_keep isl_set *set, unsigned dim, isl_int *val) { int i; @@ -6807,14 +7502,14 @@ int isl_set_fast_dim_has_fixed_lower_bound(struct isl_set *set, if (set->n == 0) return 0; if (set->n == 1) - return isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0], + return isl_basic_set_plain_dim_has_fixed_lower_bound(set->p[0], dim, val); isl_int_init(v); isl_int_init(tmp); - fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[0], + fixed = isl_basic_set_plain_dim_has_fixed_lower_bound(set->p[0], dim, &v); for (i = 1; fixed == 1 && i < set->n; ++i) { - fixed = isl_basic_set_fast_dim_has_fixed_lower_bound(set->p[i], + fixed = isl_basic_set_plain_dim_has_fixed_lower_bound(set->p[i], dim, &tmp); if (fixed == 1 && isl_int_ne(tmp, v)) fixed = 0; @@ -6902,7 +7597,7 @@ struct isl_basic_set *isl_basic_set_normalize(struct isl_basic_set *bset) (struct isl_basic_map *)bset); } -int isl_basic_map_fast_cmp(const __isl_keep isl_basic_map *bmap1, +int isl_basic_map_plain_cmp(const __isl_keep isl_basic_map *bmap1, const __isl_keep isl_basic_map *bmap2) { int i, cmp; @@ -6951,16 +7646,41 @@ int isl_basic_map_fast_cmp(const __isl_keep isl_basic_map *bmap1, return 0; } -int isl_basic_map_fast_is_equal(__isl_keep isl_basic_map *bmap1, +int isl_basic_set_plain_cmp(const __isl_keep isl_basic_set *bset1, + const __isl_keep isl_basic_set *bset2) +{ + 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 i, cmp; + + if (set1 == set2) + return 0; + if (set1->n != set2->n) + return set1->n - set2->n; + + for (i = 0; i < set1->n; ++i) { + cmp = isl_basic_set_plain_cmp(set1->p[i], set2->p[i]); + if (cmp) + return cmp; + } + + return 0; +} + +int isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2) { - return isl_basic_map_fast_cmp(bmap1, bmap2) == 0; + return isl_basic_map_plain_cmp(bmap1, bmap2) == 0; } -int isl_basic_set_fast_is_equal(__isl_keep isl_basic_set *bset1, +int isl_basic_set_plain_is_equal(__isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2) { - return isl_basic_map_fast_is_equal((isl_basic_map *)bset1, + return isl_basic_map_plain_is_equal((isl_basic_map *)bset1, (isl_basic_map *)bset2); } @@ -6969,7 +7689,7 @@ static int qsort_bmap_cmp(const void *p1, const void *p2) const struct isl_basic_map *bmap1 = *(const struct isl_basic_map **)p1; const struct isl_basic_map *bmap2 = *(const struct isl_basic_map **)p2; - return isl_basic_map_fast_cmp(bmap1, bmap2); + return isl_basic_map_plain_cmp(bmap1, bmap2); } /* We normalize in place, but if anything goes wrong we need @@ -6998,7 +7718,7 @@ struct isl_map *isl_map_normalize(struct isl_map *map) if (!map) return NULL; for (i = map->n - 1; i >= 1; --i) { - if (!isl_basic_map_fast_is_equal(map->p[i-1], map->p[i])) + if (!isl_basic_map_plain_is_equal(map->p[i-1], map->p[i])) continue; isl_basic_map_free(map->p[i-1]); for (j = i; j < map->n; ++j) @@ -7017,7 +7737,7 @@ struct isl_set *isl_set_normalize(struct isl_set *set) return (struct isl_set *)isl_map_normalize((struct isl_map *)set); } -int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2) +int isl_map_plain_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2) { int i; int equal; @@ -7027,7 +7747,7 @@ int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2) if (map1 == map2) return 1; - if (!isl_dim_equal(map1->dim, map2->dim)) + if (!isl_space_is_equal(map1->dim, map2->dim)) return 0; map1 = isl_map_copy(map1); @@ -7038,7 +7758,7 @@ int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2) goto error; equal = map1->n == map2->n; for (i = 0; equal && i < map1->n; ++i) { - equal = isl_basic_map_fast_is_equal(map1->p[i], map2->p[i]); + equal = isl_basic_map_plain_is_equal(map1->p[i], map2->p[i]); if (equal < 0) goto error; } @@ -7051,12 +7771,22 @@ error: return -1; } -int isl_set_fast_is_equal(struct isl_set *set1, struct isl_set *set2) +int isl_map_fast_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2) +{ + return isl_map_plain_is_equal(map1, map2); +} + +int isl_set_plain_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2) { - return isl_map_fast_is_equal((struct isl_map *)set1, + return isl_map_plain_is_equal((struct isl_map *)set1, (struct isl_map *)set2); } +int isl_set_fast_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2) +{ + return isl_set_plain_is_equal(set1, set2); +} + /* Return an interval that ranges from min to max (inclusive) */ struct isl_basic_set *isl_basic_set_interval(struct isl_ctx *ctx, @@ -7139,7 +7869,7 @@ error: struct isl_basic_map *isl_basic_map_product( struct isl_basic_map *bmap1, struct isl_basic_map *bmap2) { - struct isl_dim *dim_result = NULL; + isl_space *dim_result = NULL; struct isl_basic_map *bmap; unsigned in1, in2, out1, out2, nparam, total, pos; struct isl_dim_map *dim_map1, *dim_map2; @@ -7147,10 +7877,10 @@ struct isl_basic_map *isl_basic_map_product( if (!bmap1 || !bmap2) goto error; - isl_assert(bmap1->ctx, isl_dim_match(bmap1->dim, isl_dim_param, + isl_assert(bmap1->ctx, isl_space_match(bmap1->dim, isl_dim_param, bmap2->dim, isl_dim_param), goto error); - dim_result = isl_dim_product(isl_dim_copy(bmap1->dim), - isl_dim_copy(bmap2->dim)); + dim_result = isl_space_product(isl_space_copy(bmap1->dim), + isl_space_copy(bmap2->dim)); in1 = isl_basic_map_n_in(bmap1); in2 = isl_basic_map_n_in(bmap2); @@ -7170,12 +7900,12 @@ struct isl_basic_map *isl_basic_map_product( isl_dim_map_div(dim_map1, bmap1, pos += out2); isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div); - bmap = isl_basic_map_alloc_dim(dim_result, + bmap = isl_basic_map_alloc_space(dim_result, bmap1->n_div + bmap2->n_div, bmap1->n_eq + bmap2->n_eq, bmap1->n_ineq + bmap2->n_ineq); - bmap = add_constraints_dim_map(bmap, bmap1, dim_map1); - bmap = add_constraints_dim_map(bmap, bmap2, dim_map2); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2); bmap = isl_basic_map_simplify(bmap); return isl_basic_map_finalize(bmap); error: @@ -7197,13 +7927,58 @@ __isl_give isl_basic_map *isl_basic_map_flat_product( __isl_give isl_basic_set *isl_basic_set_flat_product( __isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2) { - return isl_basic_map_flat_product(bset1, bset2); + return isl_basic_map_flat_range_product(bset1, bset2); +} + +__isl_give isl_basic_map *isl_basic_map_domain_product( + __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2) +{ + isl_space *space_result = NULL; + isl_basic_map *bmap; + unsigned in1, in2, out, nparam, total, pos; + struct isl_dim_map *dim_map1, *dim_map2; + + if (!bmap1 || !bmap2) + goto error; + + space_result = isl_space_domain_product(isl_space_copy(bmap1->dim), + isl_space_copy(bmap2->dim)); + + in1 = isl_basic_map_dim(bmap1, isl_dim_in); + in2 = isl_basic_map_dim(bmap2, isl_dim_in); + out = isl_basic_map_dim(bmap1, isl_dim_out); + nparam = isl_basic_map_dim(bmap1, isl_dim_param); + + total = nparam + in1 + in2 + out + bmap1->n_div + bmap2->n_div; + dim_map1 = isl_dim_map_alloc(bmap1->ctx, total); + dim_map2 = isl_dim_map_alloc(bmap1->ctx, total); + isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_param, pos = 0); + isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_param, pos = 0); + isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_in, pos += nparam); + isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos += in1); + isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += in2); + isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_out, pos); + isl_dim_map_div(dim_map1, bmap1, pos += out); + isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div); + + bmap = isl_basic_map_alloc_space(space_result, + bmap1->n_div + bmap2->n_div, + bmap1->n_eq + bmap2->n_eq, + bmap1->n_ineq + bmap2->n_ineq); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2); + bmap = isl_basic_map_simplify(bmap); + return isl_basic_map_finalize(bmap); +error: + isl_basic_map_free(bmap1); + isl_basic_map_free(bmap2); + return NULL; } __isl_give isl_basic_map *isl_basic_map_range_product( __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2) { - isl_dim *dim_result = NULL; + isl_space *dim_result = NULL; isl_basic_map *bmap; unsigned in, out1, out2, nparam, total, pos; struct isl_dim_map *dim_map1, *dim_map2; @@ -7211,8 +7986,8 @@ __isl_give isl_basic_map *isl_basic_map_range_product( if (!bmap1 || !bmap2) goto error; - dim_result = isl_dim_range_product(isl_dim_copy(bmap1->dim), - isl_dim_copy(bmap2->dim)); + dim_result = isl_space_range_product(isl_space_copy(bmap1->dim), + isl_space_copy(bmap2->dim)); in = isl_basic_map_dim(bmap1, isl_dim_in); out1 = isl_basic_map_n_out(bmap1); @@ -7231,12 +8006,12 @@ __isl_give isl_basic_map *isl_basic_map_range_product( isl_dim_map_div(dim_map1, bmap1, pos += out2); isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div); - bmap = isl_basic_map_alloc_dim(dim_result, + bmap = isl_basic_map_alloc_space(dim_result, bmap1->n_div + bmap2->n_div, bmap1->n_eq + bmap2->n_eq, bmap1->n_ineq + bmap2->n_ineq); - bmap = add_constraints_dim_map(bmap, bmap1, dim_map1); - bmap = add_constraints_dim_map(bmap, bmap2, dim_map2); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1); + bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2); bmap = isl_basic_map_simplify(bmap); return isl_basic_map_finalize(bmap); error: @@ -7245,10 +8020,20 @@ error: return NULL; } +__isl_give isl_basic_map *isl_basic_map_flat_range_product( + __isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2) +{ + isl_basic_map *prod; + + prod = isl_basic_map_range_product(bmap1, bmap2); + prod = isl_basic_map_flatten_range(prod); + return prod; +} + static __isl_give isl_map *map_product(__isl_take isl_map *map1, __isl_take isl_map *map2, - __isl_give isl_dim *(*dim_product)(__isl_take isl_dim *left, - __isl_take isl_dim *right), + __isl_give isl_space *(*dim_product)(__isl_take isl_space *left, + __isl_take isl_space *right), __isl_give isl_basic_map *(*basic_map_product)( __isl_take isl_basic_map *left, __isl_take isl_basic_map *right)) { @@ -7259,15 +8044,15 @@ static __isl_give isl_map *map_product(__isl_take isl_map *map1, if (!map1 || !map2) goto error; - isl_assert(map1->ctx, isl_dim_match(map1->dim, isl_dim_param, + isl_assert(map1->ctx, isl_space_match(map1->dim, isl_dim_param, map2->dim, isl_dim_param), goto error); if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) && ISL_F_ISSET(map2, ISL_MAP_DISJOINT)) ISL_FL_SET(flags, ISL_MAP_DISJOINT); - result = isl_map_alloc_dim(dim_product(isl_dim_copy(map1->dim), - isl_dim_copy(map2->dim)), + result = isl_map_alloc_space(dim_product(isl_space_copy(map1->dim), + isl_space_copy(map2->dim)), map1->n * map2->n, flags); if (!result) goto error; @@ -7294,9 +8079,16 @@ error: /* Given two maps A -> B and C -> D, construct a map [A -> C] -> [B -> D] */ -struct isl_map *isl_map_product(struct isl_map *map1, struct isl_map *map2) +static __isl_give isl_map *map_product_aligned(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + return map_product(map1, map2, &isl_space_product, &isl_basic_map_product); +} + +__isl_give isl_map *isl_map_product(__isl_take isl_map *map1, + __isl_take isl_map *map2) { - return map_product(map1, map2, &isl_dim_product, &isl_basic_map_product); + return isl_map_align_params_map_map_and(map1, map2, &map_product_aligned); } /* Given two maps A -> B and C -> D, construct a map (A, C) -> (B, D) @@ -7315,25 +8107,71 @@ __isl_give isl_map *isl_map_flat_product(__isl_take isl_map *map1, */ struct isl_set *isl_set_product(struct isl_set *set1, struct isl_set *set2) { - return (struct isl_set *)isl_map_product((struct isl_map *)set1, - (struct isl_map *)set2); + return isl_map_range_product(set1, set2); } __isl_give isl_set *isl_set_flat_product(__isl_take isl_set *set1, __isl_take isl_set *set2) { - return (isl_set *)isl_map_flat_product((isl_map *)set1, (isl_map *)set2); + return isl_map_flat_range_product(set1, set2); +} + +/* Given two maps A -> B and C -> D, construct a map [A -> C] -> (B * D) + */ +static __isl_give isl_map *map_domain_product_aligned(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + return map_product(map1, map2, &isl_space_domain_product, + &isl_basic_map_domain_product); } /* Given two maps A -> B and C -> D, construct a map (A * C) -> [B -> D] */ -__isl_give isl_map *isl_map_range_product(__isl_take isl_map *map1, +static __isl_give isl_map *map_range_product_aligned(__isl_take isl_map *map1, __isl_take isl_map *map2) { - return map_product(map1, map2, &isl_dim_range_product, + return map_product(map1, map2, &isl_space_range_product, &isl_basic_map_range_product); } +__isl_give isl_map *isl_map_domain_product(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + return isl_map_align_params_map_map_and(map1, map2, + &map_domain_product_aligned); +} + +__isl_give isl_map *isl_map_range_product(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + return isl_map_align_params_map_map_and(map1, map2, + &map_range_product_aligned); +} + +/* Given two maps A -> B and C -> D, construct a map (A, C) -> (B * D) + */ +__isl_give isl_map *isl_map_flat_domain_product(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + isl_map *prod; + + prod = isl_map_domain_product(map1, map2); + prod = isl_map_flatten_domain(prod); + return prod; +} + +/* Given two maps A -> B and C -> D, construct a map (A * C) -> (B, D) + */ +__isl_give isl_map *isl_map_flat_range_product(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + isl_map *prod; + + prod = isl_map_range_product(map1, map2); + prod = isl_map_flatten_range(prod); + return prod; +} + uint32_t isl_basic_map_get_hash(__isl_keep isl_basic_map *bmap) { int i; @@ -7481,7 +8319,7 @@ int isl_set_foreach_basic_set(__isl_keep isl_set *set, __isl_give isl_basic_set *isl_basic_set_lift(__isl_take isl_basic_set *bset) { - struct isl_dim *dim; + isl_space *dim; if (!bset) return NULL; @@ -7490,11 +8328,11 @@ __isl_give isl_basic_set *isl_basic_set_lift(__isl_take isl_basic_set *bset) if (!bset) return NULL; - dim = isl_basic_set_get_dim(bset); - dim = isl_dim_lift(dim, bset->n_div); + dim = isl_basic_set_get_space(bset); + dim = isl_space_lift(dim, bset->n_div); if (!dim) goto error; - isl_dim_free(bset->dim); + isl_space_free(bset->dim); bset->dim = dim; bset->extra -= bset->n_div; bset->n_div = 0; @@ -7510,7 +8348,7 @@ error: __isl_give isl_set *isl_set_lift(__isl_take isl_set *set) { int i; - struct isl_dim *dim; + isl_space *dim; unsigned n_div; set = isl_set_align_divs(set); @@ -7523,11 +8361,11 @@ __isl_give isl_set *isl_set_lift(__isl_take isl_set *set) return NULL; n_div = set->p[0]->n_div; - dim = isl_set_get_dim(set); - dim = isl_dim_lift(dim, n_div); + dim = isl_set_get_space(set); + dim = isl_space_lift(dim, n_div); if (!dim) goto error; - isl_dim_free(set->dim); + isl_space_free(set->dim); set->dim = dim; for (i = 0; i < set->n; ++i) { @@ -7544,7 +8382,7 @@ error: __isl_give isl_map *isl_set_lifting(__isl_take isl_set *set) { - struct isl_dim *dim; + isl_space *dim; struct isl_basic_map *bmap; unsigned n_set; unsigned n_div; @@ -7557,18 +8395,18 @@ __isl_give isl_map *isl_set_lifting(__isl_take isl_set *set) if (!set) return NULL; - dim = isl_set_get_dim(set); + dim = isl_set_get_space(set); if (set->n == 0 || set->p[0]->n_div == 0) { isl_set_free(set); - return isl_map_identity(isl_dim_map_from_set(dim)); + return isl_map_identity(isl_space_map_from_set(dim)); } n_div = set->p[0]->n_div; - dim = isl_dim_map_from_set(dim); - n_param = isl_dim_size(dim, isl_dim_param); - n_set = isl_dim_size(dim, isl_dim_in); - dim = isl_dim_extend(dim, n_param, n_set, n_set + n_div); - bmap = isl_basic_map_alloc_dim(dim, 0, n_set, 2 * n_div); + dim = isl_space_map_from_set(dim); + n_param = isl_space_dim(dim, isl_dim_param); + n_set = isl_space_dim(dim, isl_dim_in); + dim = isl_space_extend(dim, n_param, n_set, n_set + n_div); + bmap = isl_basic_map_alloc_space(dim, 0, n_set, 2 * n_div); for (i = 0; i < n_set; ++i) bmap = var_equal(bmap, i); @@ -7633,11 +8471,13 @@ int isl_set_size(__isl_keep isl_set *set) return size; } -int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap, - enum isl_dim_type type, unsigned pos) +/* Check if there is any lower bound (if lower == 0) and/or upper + * bound (if upper == 0) on the specified dim. + */ +static int basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap, + enum isl_dim_type type, unsigned pos, int lower, int upper) { int i; - int lower, upper; if (!bmap) return -1; @@ -7646,11 +8486,17 @@ int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap, pos += isl_basic_map_offset(bmap, type); + for (i = 0; i < bmap->n_div; ++i) { + if (isl_int_is_zero(bmap->div[i][0])) + continue; + if (!isl_int_is_zero(bmap->div[i][1 + pos])) + return 1; + } + for (i = 0; i < bmap->n_eq; ++i) if (!isl_int_is_zero(bmap->eq[i][pos])) return 1; - lower = upper = 0; for (i = 0; i < bmap->n_ineq; ++i) { int sgn = isl_int_sgn(bmap->ineq[i][pos]); if (sgn > 0) @@ -7662,6 +8508,24 @@ int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap, return lower && upper; } +int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap, + enum isl_dim_type type, unsigned pos) +{ + return basic_map_dim_is_bounded(bmap, type, pos, 0, 0); +} + +int isl_basic_map_dim_has_lower_bound(__isl_keep isl_basic_map *bmap, + enum isl_dim_type type, unsigned pos) +{ + return basic_map_dim_is_bounded(bmap, type, pos, 0, 1); +} + +int isl_basic_map_dim_has_upper_bound(__isl_keep isl_basic_map *bmap, + enum isl_dim_type type, unsigned pos) +{ + return basic_map_dim_is_bounded(bmap, type, pos, 1, 0); +} + int isl_map_dim_is_bounded(__isl_keep isl_map *map, enum isl_dim_type type, unsigned pos) { @@ -7689,6 +8553,42 @@ 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, + 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 0; +} + +/* Return 1 if the specified dim is involved in any lower bound. + */ +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. + */ +int isl_set_dim_has_upper_bound(__isl_keep isl_set *set, + enum isl_dim_type type, unsigned pos) +{ + return has_bound(set, type, pos, &isl_basic_map_dim_has_upper_bound); +} + /* For each of the "n" variables starting at "first", determine * the sign of the variable and put the results in the first "n" * elements of the array "signs". @@ -7770,7 +8670,7 @@ int isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset, * an equality that defines the output dimension in terms of * earlier dimensions. */ -int isl_basic_map_fast_is_single_valued(__isl_keep isl_basic_map *bmap) +int isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap) { int i, j; unsigned total; @@ -7801,10 +8701,8 @@ int isl_basic_map_fast_is_single_valued(__isl_keep isl_basic_map *bmap) /* Check if the given map is obviously single-valued. */ -int isl_map_fast_is_single_valued(__isl_keep isl_map *map) +int isl_map_plain_is_single_valued(__isl_keep isl_map *map) { - int sv; - if (!map) return -1; if (map->n == 0) @@ -7812,7 +8710,7 @@ int isl_map_fast_is_single_valued(__isl_keep isl_map *map) if (map->n >= 2) return 0; - return isl_basic_map_fast_is_single_valued(map->p[0]); + return isl_basic_map_plain_is_single_valued(map->p[0]); } /* Check if the given map is single-valued. @@ -7824,19 +8722,19 @@ int isl_map_fast_is_single_valued(__isl_keep isl_map *map) */ int isl_map_is_single_valued(__isl_keep isl_map *map) { - isl_dim *dim; + isl_space *dim; isl_map *test; isl_map *id; int sv; - sv = isl_map_fast_is_single_valued(map); + sv = isl_map_plain_is_single_valued(map); if (sv < 0 || sv) return sv; test = isl_map_reverse(isl_map_copy(map)); test = isl_map_apply_range(test, isl_map_copy(map)); - dim = isl_dim_map_from_set(isl_dim_range(isl_map_get_dim(map))); + dim = isl_space_map_from_set(isl_space_range(isl_map_get_space(map))); id = isl_map_identity(dim); sv = isl_map_is_subset(test, id); @@ -7847,6 +8745,32 @@ int isl_map_is_single_valued(__isl_keep isl_map *map) return sv; } +int isl_map_is_injective(__isl_keep isl_map *map) +{ + int in; + + map = isl_map_copy(map); + map = isl_map_reverse(map); + in = isl_map_is_single_valued(map); + isl_map_free(map); + + return in; +} + +/* Check if the given map is obviously injective. + */ +int isl_map_plain_is_injective(__isl_keep isl_map *map) +{ + int in; + + map = isl_map_copy(map); + map = isl_map_reverse(map); + in = isl_map_plain_is_single_valued(map); + isl_map_free(map); + + return in; +} + int isl_map_is_bijective(__isl_keep isl_map *map) { int sv; @@ -7855,12 +8779,7 @@ int isl_map_is_bijective(__isl_keep isl_map *map) if (sv < 0 || !sv) return sv; - map = isl_map_copy(map); - map = isl_map_reverse(map); - sv = isl_map_is_single_valued(map); - isl_map_free(map); - - return sv; + return isl_map_is_injective(map); } int isl_set_is_singleton(__isl_keep isl_set *set) @@ -7902,7 +8821,7 @@ int isl_basic_set_is_box(__isl_keep isl_basic_set *bset) return 0; nvar = isl_basic_set_dim(bset, isl_dim_set); - ovar = isl_dim_offset(bset->dim, isl_dim_set); + ovar = isl_space_offset(bset->dim, isl_dim_set); for (j = 0; j < nvar; ++j) { int lower = 0, upper = 0; for (i = 0; i < bset->n_eq; ++i) { @@ -7946,7 +8865,7 @@ int isl_basic_set_is_wrapping(__isl_keep isl_basic_set *bset) if (!bset) return -1; - return isl_dim_is_wrapping(bset->dim); + return isl_space_is_wrapping(bset->dim); } int isl_set_is_wrapping(__isl_keep isl_set *set) @@ -7954,7 +8873,7 @@ int isl_set_is_wrapping(__isl_keep isl_set *set) if (!set) return -1; - return isl_dim_is_wrapping(set->dim); + return isl_space_is_wrapping(set->dim); } __isl_give isl_basic_set *isl_basic_map_wrap(__isl_take isl_basic_map *bmap) @@ -7963,7 +8882,7 @@ __isl_give isl_basic_set *isl_basic_map_wrap(__isl_take isl_basic_map *bmap) if (!bmap) return NULL; - bmap->dim = isl_dim_wrap(bmap->dim); + bmap->dim = isl_space_wrap(bmap->dim); if (!bmap->dim) goto error; @@ -7988,7 +8907,7 @@ __isl_give isl_set *isl_map_wrap(__isl_take isl_map *map) if (!map->p[i]) goto error; } - map->dim = isl_dim_wrap(map->dim); + map->dim = isl_space_wrap(map->dim); if (!map->dim) goto error; @@ -8004,7 +8923,7 @@ __isl_give isl_basic_map *isl_basic_set_unwrap(__isl_take isl_basic_set *bset) if (!bset) return NULL; - bset->dim = isl_dim_unwrap(bset->dim); + bset->dim = isl_space_unwrap(bset->dim); if (!bset->dim) goto error; @@ -8037,7 +8956,7 @@ __isl_give isl_map *isl_set_unwrap(__isl_take isl_set *set) goto error; } - set->dim = isl_dim_unwrap(set->dim); + set->dim = isl_space_unwrap(set->dim); if (!set->dim) goto error; @@ -8053,14 +8972,14 @@ __isl_give isl_basic_map *isl_basic_map_reset(__isl_take isl_basic_map *bmap, if (!bmap) return NULL; - if (!isl_dim_is_named_or_nested(bmap->dim, type)) + if (!isl_space_is_named_or_nested(bmap->dim, type)) return bmap; bmap = isl_basic_map_cow(bmap); if (!bmap) return NULL; - bmap->dim = isl_dim_reset(bmap->dim, type); + bmap->dim = isl_space_reset(bmap->dim, type); if (!bmap->dim) goto error; @@ -8080,7 +8999,7 @@ __isl_give isl_map *isl_map_reset(__isl_take isl_map *map, if (!map) return NULL; - if (!isl_dim_is_named_or_nested(map->dim, type)) + if (!isl_space_is_named_or_nested(map->dim, type)) return map; map = isl_map_cow(map); @@ -8092,7 +9011,7 @@ __isl_give isl_map *isl_map_reset(__isl_take isl_map *map, if (!map->p[i]) goto error; } - map->dim = isl_dim_reset(map->dim, type); + map->dim = isl_space_reset(map->dim, type); if (!map->dim) goto error; @@ -8114,7 +9033,7 @@ __isl_give isl_basic_map *isl_basic_map_flatten(__isl_take isl_basic_map *bmap) if (!bmap) return NULL; - bmap->dim = isl_dim_flatten(bmap->dim); + bmap->dim = isl_space_flatten(bmap->dim); if (!bmap->dim) goto error; @@ -8131,6 +9050,56 @@ __isl_give isl_basic_set *isl_basic_set_flatten(__isl_take isl_basic_set *bset) return (isl_basic_set *)isl_basic_map_flatten((isl_basic_map *)bset); } +__isl_give isl_basic_map *isl_basic_map_flatten_domain( + __isl_take isl_basic_map *bmap) +{ + if (!bmap) + return NULL; + + if (!bmap->dim->nested[0]) + return bmap; + + bmap = isl_basic_map_cow(bmap); + if (!bmap) + return NULL; + + bmap->dim = isl_space_flatten_domain(bmap->dim); + if (!bmap->dim) + goto error; + + bmap = isl_basic_map_finalize(bmap); + + return bmap; +error: + isl_basic_map_free(bmap); + return NULL; +} + +__isl_give isl_basic_map *isl_basic_map_flatten_range( + __isl_take isl_basic_map *bmap) +{ + if (!bmap) + return NULL; + + if (!bmap->dim->nested[1]) + return bmap; + + bmap = isl_basic_map_cow(bmap); + if (!bmap) + return NULL; + + bmap->dim = isl_space_flatten_range(bmap->dim); + if (!bmap->dim) + goto error; + + bmap = isl_basic_map_finalize(bmap); + + return bmap; +error: + isl_basic_map_free(bmap); + return NULL; +} + __isl_give isl_map *isl_map_flatten(__isl_take isl_map *map) { int i; @@ -8150,7 +9119,7 @@ __isl_give isl_map *isl_map_flatten(__isl_take isl_map *map) if (!map->p[i]) goto error; } - map->dim = isl_dim_flatten(map->dim); + map->dim = isl_space_flatten(map->dim); if (!map->dim) goto error; @@ -8167,69 +9136,80 @@ __isl_give isl_set *isl_set_flatten(__isl_take isl_set *set) __isl_give isl_map *isl_set_flatten_map(__isl_take isl_set *set) { - isl_dim *dim, *flat_dim; + isl_space *dim, *flat_dim; isl_map *map; - dim = isl_set_get_dim(set); - flat_dim = isl_dim_flatten(isl_dim_copy(dim)); - map = isl_map_identity(isl_dim_join(isl_dim_reverse(dim), flat_dim)); + dim = isl_set_get_space(set); + flat_dim = isl_space_flatten(isl_space_copy(dim)); + map = isl_map_identity(isl_space_join(isl_space_reverse(dim), flat_dim)); map = isl_map_intersect_domain(map, set); return map; } -/* Extend the given dim_map with mappings for the divs in bmap. - */ -static __isl_give struct isl_dim_map *extend_dim_map( - __isl_keep struct isl_dim_map *dim_map, - __isl_keep isl_basic_map *bmap) +__isl_give isl_map *isl_map_flatten_domain(__isl_take isl_map *map) { int i; - struct isl_dim_map *res; - int offset; - offset = isl_basic_map_offset(bmap, isl_dim_div); + if (!map) + return NULL; + + if (!map->dim->nested[0]) + return map; - res = isl_dim_map_alloc(bmap->ctx, dim_map->len - 1 + bmap->n_div); - if (!res) + map = isl_map_cow(map); + if (!map) return NULL; - for (i = 0; i < dim_map->len; ++i) - res->pos[i] = dim_map->pos[i]; - for (i = 0; i < bmap->n_div; ++i) - res->pos[dim_map->len + i] = offset + i; + for (i = 0; i < map->n; ++i) { + map->p[i] = isl_basic_map_flatten_domain(map->p[i]); + if (!map->p[i]) + goto error; + } + map->dim = isl_space_flatten_domain(map->dim); + if (!map->dim) + goto error; - return res; + return map; +error: + isl_map_free(map); + return NULL; } -/* Extract a dim_map from a reordering. - * We essentially need to reverse the mapping, and add an offset - * of 1 for the constant term. - */ -__isl_give struct isl_dim_map *isl_dim_map_from_reordering( - __isl_keep isl_reordering *exp) +__isl_give isl_map *isl_map_flatten_range(__isl_take isl_map *map) { int i; - struct isl_dim_map *dim_map; - if (!exp) + if (!map) return NULL; - dim_map = isl_dim_map_alloc(exp->dim->ctx, isl_dim_total(exp->dim)); - if (!dim_map) + if (!map->dim->nested[1]) + return map; + + map = isl_map_cow(map); + if (!map) return NULL; - for (i = 0; i < exp->len; ++i) - dim_map->pos[1 + exp->pos[i]] = 1 + i; + for (i = 0; i < map->n; ++i) { + map->p[i] = isl_basic_map_flatten_range(map->p[i]); + if (!map->p[i]) + goto error; + } + map->dim = isl_space_flatten_range(map->dim); + if (!map->dim) + goto error; - return dim_map; + return map; +error: + isl_map_free(map); + return NULL; } /* Reorder the dimensions of "bmap" according to the given dim_map * and set the dimension specification to "dim". */ __isl_give isl_basic_map *isl_basic_map_realign(__isl_take isl_basic_map *bmap, - __isl_take isl_dim *dim, __isl_take struct isl_dim_map *dim_map) + __isl_take isl_space *dim, __isl_take struct isl_dim_map *dim_map) { isl_basic_map *res; @@ -8237,15 +9217,15 @@ __isl_give isl_basic_map *isl_basic_map_realign(__isl_take isl_basic_map *bmap, if (!bmap || !dim || !dim_map) goto error; - res = isl_basic_map_alloc_dim(dim, + res = isl_basic_map_alloc_space(dim, bmap->n_div, bmap->n_eq, bmap->n_ineq); - res = add_constraints_dim_map(res, bmap, dim_map); + res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map); res = isl_basic_map_finalize(res); return res; error: free(dim_map); isl_basic_map_free(bmap); - isl_dim_free(dim); + isl_space_free(dim); return NULL; } @@ -8265,16 +9245,16 @@ __isl_give isl_map *isl_map_realign(__isl_take isl_map *map, for (i = 0; i < map->n; ++i) { struct isl_dim_map *dim_map_i; - dim_map_i = extend_dim_map(dim_map, map->p[i]); + dim_map_i = isl_dim_map_extend(dim_map, map->p[i]); map->p[i] = isl_basic_map_realign(map->p[i], - isl_dim_copy(r->dim), dim_map_i); + isl_space_copy(r->dim), dim_map_i); if (!map->p[i]) goto error; } - map = isl_map_reset_dim(map, isl_dim_copy(r->dim)); + map = isl_map_reset_space(map, isl_space_copy(r->dim)); isl_reordering_free(r); free(dim_map); @@ -8292,6 +9272,47 @@ __isl_give isl_set *isl_set_realign(__isl_take isl_set *set, return (isl_set *)isl_map_realign((isl_map *)set, r); } +__isl_give isl_map *isl_map_align_params(__isl_take isl_map *map, + __isl_take isl_space *model) +{ + isl_ctx *ctx; + + if (!map || !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(map->dim)) + isl_die(ctx, isl_error_invalid, + "relation has unnamed parameters", goto error); + if (!isl_space_match(map->dim, isl_dim_param, model, isl_dim_param)) { + isl_reordering *exp; + + 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(map->dim, model); + exp = isl_reordering_extend_space(exp, isl_map_get_space(map)); + map = isl_map_realign(map, exp); + } + + isl_space_free(model); + return map; +error: + isl_space_free(model); + isl_map_free(map); + return NULL; +} + +__isl_give isl_set *isl_set_align_params(__isl_take isl_set *set, + __isl_take isl_space *model) +{ + return isl_map_align_params(set, 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, @@ -8351,7 +9372,7 @@ __isl_give isl_mat *isl_basic_map_inequalities_matrix( } __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices( - __isl_take isl_dim *dim, + __isl_take isl_space *dim, __isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1, enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4, enum isl_dim_type c5) @@ -8371,7 +9392,7 @@ __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices( "equalities and inequalities matrices should have " "same number of columns", goto error); - total = 1 + isl_dim_total(dim); + total = 1 + isl_space_dim(dim, isl_dim_all); if (eq->n_col < total) isl_die(dim->ctx, isl_error_invalid, @@ -8379,7 +9400,7 @@ __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices( extra = eq->n_col - total; - bmap = isl_basic_map_alloc_dim(isl_dim_copy(dim), extra, + bmap = isl_basic_map_alloc_space(isl_space_copy(dim), extra, eq->n_row, ineq->n_row); if (!bmap) goto error; @@ -8416,13 +9437,13 @@ __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices( } } - isl_dim_free(dim); + isl_space_free(dim); isl_mat_free(eq); isl_mat_free(ineq); return bmap; error: - isl_dim_free(dim); + isl_space_free(dim); isl_mat_free(eq); isl_mat_free(ineq); return NULL; @@ -8445,7 +9466,7 @@ __isl_give isl_mat *isl_basic_set_inequalities_matrix( } __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices( - __isl_take isl_dim *dim, + __isl_take isl_space *dim, __isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1, enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4) { @@ -8459,7 +9480,7 @@ int isl_basic_map_can_zip(__isl_keep isl_basic_map *bmap) if (!bmap) return -1; - return isl_dim_can_zip(bmap->dim); + return isl_space_can_zip(bmap->dim); } int isl_map_can_zip(__isl_keep isl_map *map) @@ -8467,7 +9488,7 @@ int isl_map_can_zip(__isl_keep isl_map *map) if (!map) return -1; - return isl_dim_can_zip(map->dim); + return isl_space_can_zip(map->dim); } /* Given a basic map (A -> B) -> (C -> D), return the corresponding basic map @@ -8486,13 +9507,13 @@ __isl_give isl_basic_map *isl_basic_map_zip(__isl_take isl_basic_map *bmap) isl_die(bmap->ctx, isl_error_invalid, "basic map cannot be zipped", goto error); pos = isl_basic_map_offset(bmap, isl_dim_in) + - isl_dim_size(bmap->dim->nested[0], isl_dim_in); - n1 = isl_dim_size(bmap->dim->nested[0], isl_dim_out); - n2 = isl_dim_size(bmap->dim->nested[1], isl_dim_in); + 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_swap_vars(bmap, pos, n1, n2); if (!bmap) return NULL; - bmap->dim = isl_dim_zip(bmap->dim); + bmap->dim = isl_space_zip(bmap->dim); if (!bmap->dim) goto error; return bmap; @@ -8525,7 +9546,7 @@ __isl_give isl_map *isl_map_zip(__isl_take isl_map *map) goto error; } - map->dim = isl_dim_zip(map->dim); + map->dim = isl_space_zip(map->dim); if (!map->dim) goto error; @@ -8534,3 +9555,336 @@ error: isl_map_free(map); return NULL; } + +/* 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); + isl_int_neg(bmap->eq[k][pos], aff->v->el[0]); + isl_seq_cpy(bmap->eq[k] + pos + 1, aff->v->el + 1 + pos, + aff->v->size - (pos + 1)); + + isl_aff_free(aff); + bmap = isl_basic_map_finalize(bmap); + return bmap; +error: + isl_aff_free(aff); + isl_basic_map_free(bmap); + return NULL; +} + +/* 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. + */ +__isl_give isl_basic_map *isl_basic_map_from_multi_aff( + __isl_take isl_multi_aff *maff) +{ + int i; + isl_space *space; + isl_basic_map *bmap; + + if (!maff) + return NULL; + + if (isl_space_dim(maff->space, isl_dim_out) != maff->n) + isl_die(isl_multi_aff_get_ctx(maff), isl_error_internal, + "invalid space", return isl_multi_aff_free(maff)); + + space = isl_space_domain(isl_multi_aff_get_space(maff)); + bmap = isl_basic_map_universe(isl_space_from_domain(space)); + + for (i = 0; i < maff->n; ++i) { + isl_aff *aff; + isl_basic_map *bmap_i; + + aff = isl_aff_copy(maff->p[i]); + bmap_i = isl_basic_map_from_aff(aff); + + bmap = isl_basic_map_flat_range_product(bmap, bmap_i); + } + + bmap = isl_basic_map_reset_space(bmap, isl_multi_aff_get_space(maff)); + + isl_multi_aff_free(maff); + return 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 + * corresponding affine expression. + * The domains of all affine expressions in the list are assumed to match + * domain_dim. + */ +__isl_give isl_basic_map *isl_basic_map_from_aff_list( + __isl_take isl_space *domain_dim, __isl_take isl_aff_list *list) +{ + int i; + isl_space *dim; + isl_basic_map *bmap; + + if (!list) + return NULL; + + dim = isl_space_from_domain(domain_dim); + bmap = isl_basic_map_universe(dim); + + for (i = 0; i < list->n; ++i) { + isl_aff *aff; + isl_basic_map *bmap_i; + + aff = isl_aff_copy(list->p[i]); + bmap_i = isl_basic_map_from_aff(aff); + + bmap = isl_basic_map_flat_range_product(bmap, bmap_i); + } + + isl_aff_list_free(list); + return bmap; +} + +__isl_give isl_set *isl_set_equate(__isl_take isl_set *set, + enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2) +{ + return isl_map_equate(set, type1, pos1, type2, pos2); +} + +/* 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 = NULL; + int i; + + if (!map) + return NULL; + + if (pos1 >= isl_map_dim(map, type1)) + isl_die(map->ctx, isl_error_invalid, + "index out of bounds", goto error); + if (pos2 >= isl_map_dim(map, type2)) + 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 (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); + + map = isl_map_intersect(map, isl_map_from_basic_map(bmap)); + + return map; +error: + isl_basic_map_free(bmap); + isl_map_free(map); + return NULL; +} + +/* 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; + + if (!map) + return NULL; + + if (pos1 >= isl_map_dim(map, type1)) + isl_die(map->ctx, isl_error_invalid, + "index out of bounds", goto error); + if (pos2 >= isl_map_dim(map, type2)) + 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 (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); + + map = isl_map_intersect(map, isl_map_from_basic_map(bmap)); + + return map; +error: + isl_basic_map_free(bmap); + isl_map_free(map); + return NULL; +} + +__isl_give isl_aff *isl_basic_map_get_div(__isl_keep isl_basic_map *bmap, + int pos) +{ + isl_aff *div; + isl_local_space *ls; + + if (!bmap) + return NULL; + + if (!isl_basic_map_divs_known(bmap)) + isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid, + "some divs are unknown", return NULL); + + ls = isl_basic_map_get_local_space(bmap); + div = isl_local_space_get_div(ls, pos); + isl_local_space_free(ls); + + return div; +} + +__isl_give isl_aff *isl_basic_set_get_div(__isl_keep isl_basic_set *bset, + int pos) +{ + return isl_basic_map_get_div(bset, pos); +} + +/* Plug in "subs" for dimension "type", "pos" of "bset". + * + * Let i be the dimension to replace and let "subs" be of the form + * + * f/d + * + * Any integer division with a non-zero coefficient for i, + * + * floor((a i + g)/m) + * + * is replaced by + * + * floor((a f + d g)/(m d)) + * + * Constraints of the form + * + * a i + g + * + * are replaced by + * + * a f + d g + */ +__isl_give isl_basic_set *isl_basic_set_substitute( + __isl_take isl_basic_set *bset, + enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs) +{ + int i; + isl_int v; + isl_ctx *ctx; + + if (bset && isl_basic_set_plain_is_empty(bset)) + return bset; + + bset = isl_basic_set_cow(bset); + if (!bset || !subs) + goto error; + + ctx = isl_basic_set_get_ctx(bset); + if (!isl_space_is_equal(bset->dim, subs->ls->dim)) + isl_die(ctx, isl_error_invalid, + "spaces don't match", goto error); + if (isl_local_space_dim(subs->ls, isl_dim_div) != 0) + isl_die(ctx, isl_error_unsupported, + "cannot handle divs yet", goto error); + + pos += isl_basic_set_offset(bset, type); + + isl_int_init(v); + + for (i = 0; i < bset->n_eq; ++i) { + if (isl_int_is_zero(bset->eq[i][pos])) + continue; + isl_int_set(v, bset->eq[i][pos]); + isl_int_set_si(bset->eq[i][pos], 0); + isl_seq_combine(bset->eq[i], subs->v->el[0], bset->eq[i], + v, subs->v->el + 1, subs->v->size - 1); + } + + for (i = 0; i < bset->n_ineq; ++i) { + if (isl_int_is_zero(bset->ineq[i][pos])) + continue; + isl_int_set(v, bset->ineq[i][pos]); + isl_int_set_si(bset->ineq[i][pos], 0); + isl_seq_combine(bset->ineq[i], subs->v->el[0], bset->ineq[i], + v, subs->v->el + 1, subs->v->size - 1); + } + + for (i = 0; i < bset->n_div; ++i) { + if (isl_int_is_zero(bset->div[i][1 + pos])) + continue; + isl_int_set(v, bset->div[i][1 + pos]); + isl_int_set_si(bset->div[i][1 + pos], 0); + isl_seq_combine(bset->div[i] + 1, + subs->v->el[0], bset->div[i] + 1, + v, subs->v->el + 1, subs->v->size - 1); + isl_int_mul(bset->div[i][0], bset->div[i][0], subs->v->el[0]); + } + + isl_int_clear(v); + + bset = isl_basic_set_simplify(bset); + return isl_basic_set_finalize(bset); +error: + isl_basic_set_free(bset); + return NULL; +} + +/* Plug in "subs" for dimension "type", "pos" of "set". + */ +__isl_give isl_set *isl_set_substitute(__isl_take isl_set *set, + enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs) +{ + int i; + + if (set && isl_set_plain_is_empty(set)) + return set; + + set = isl_set_cow(set); + if (!set || !subs) + goto error; + + for (i = set->n - 1; i >= 0; --i) { + set->p[i] = isl_basic_set_substitute(set->p[i], type, pos, subs); + if (!set->p[i]) + goto error; + if (isl_basic_set_plain_is_empty(set->p[i])) { + isl_basic_set_free(set->p[i]); + if (i != set->n - 1) + set->p[i] = set->p[set->n - 1]; + set->n--; + } + } + + return set; +error: + isl_set_free(set); + return NULL; +}