X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=isl_map.c;h=8c205b0c632ff48a9328be3348fa481cb2de94e4;hb=11927df08e42876dd1d2df20c1c436f40551afaa;hp=9d0ffbf9cb2593233c22da0c7be830bf14a19167;hpb=f600853f2f7dd332a98d1a4ca58d30567d36e04a;p=platform%2Fupstream%2Fisl.git diff --git a/isl_map.c b/isl_map.c index 9d0ffbf..8c205b0 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 @@ -30,8 +29,10 @@ #include #include #include +#include +#include -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; @@ -42,7 +43,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; @@ -52,7 +53,7 @@ static unsigned pos(struct isl_dim *dim, enum isl_dim_type type) } } -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) @@ -61,19 +62,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; } @@ -81,7 +82,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; @@ -103,33 +104,35 @@ 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; + if (!bset) + return 0; + 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); } @@ -156,22 +159,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) @@ -179,10 +182,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, @@ -191,10 +194,10 @@ 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_dim_tuple_match(bmap->dim, isl_dim_in, bset->dim, isl_dim_set); + 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) @@ -202,10 +205,10 @@ int isl_map_compatible_range(__isl_keep isl_map *map, __isl_keep 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_out, set->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, @@ -214,10 +217,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) @@ -240,18 +243,18 @@ 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( @@ -265,7 +268,7 @@ __isl_give isl_local_space *isl_basic_map_get_local_space( return NULL; total = isl_basic_map_total_dim(bmap); - ls = isl_local_space_alloc(isl_dim_copy(bmap->dim), bmap->n_div); + ls = isl_local_space_alloc(isl_space_copy(bmap->dim), bmap->n_div); if (!ls) return NULL; @@ -292,7 +295,7 @@ __isl_give isl_basic_map *isl_basic_map_from_local_space( return NULL; n_div = isl_local_space_dim(ls, isl_dim_div); - bmap = isl_basic_map_alloc_dim(isl_local_space_get_dim(ls), + 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) @@ -319,18 +322,18 @@ __isl_give isl_basic_set *isl_basic_set_from_local_space( 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( @@ -339,7 +342,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); @@ -349,10 +352,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, @@ -364,7 +373,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; @@ -383,7 +392,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, @@ -392,47 +401,104 @@ __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( __isl_take isl_basic_map *bmap, enum isl_dim_type type, unsigned pos, const char *s) { + bmap = isl_basic_map_cow(bmap); 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; @@ -446,10 +512,11 @@ __isl_give isl_map *isl_map_set_dim_name(__isl_take isl_map *map, { int i; + map = isl_map_cow(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; @@ -479,6 +546,82 @@ __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_set_find_dim_by_name(__isl_keep isl_set *set, enum isl_dim_type type, + const char *name) +{ + return isl_map_find_dim_by_name(set, type, name); +} + int isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap) { if (!bmap) @@ -491,12 +634,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); @@ -549,25 +721,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; @@ -581,7 +759,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; } @@ -590,13 +768,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; } @@ -629,7 +807,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; @@ -706,7 +884,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); } @@ -720,6 +898,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; +} + +int isl_map_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; @@ -1060,8 +1284,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; @@ -1074,12 +1298,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; } @@ -1090,7 +1314,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; @@ -1107,17 +1331,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); } @@ -1126,7 +1350,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); } @@ -1135,15 +1359,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); @@ -1314,7 +1538,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; @@ -1347,11 +1571,9 @@ __isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map, map = isl_map_cow(map); if (!map) return NULL; - isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error); - first += pos(map->dim, type) - 1; - + for (i = 0; i < map->n; ++i) { - map->p[i] = isl_basic_map_eliminate_vars(map->p[i], first, n); + map->p[i] = isl_basic_map_eliminate(map->p[i], type, first, n); if (!map->p[i]) goto error; } @@ -1384,8 +1606,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; @@ -1435,7 +1659,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); @@ -1493,6 +1717,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; @@ -1534,49 +1761,73 @@ __isl_give isl_set *isl_set_remove_divs_involving_dims(__isl_take isl_set *set, type, first, n); } -int isl_basic_set_involves_dims(__isl_keep isl_basic_set *bset, +/* Does the desciption of "bmap" depend on the specified dimensions? + * We also check whether the dimensions appear in any of the div definitions. + * In principle there is no need for this check. If the dimensions appear + * in a div definition, they also appear in the defining constraints of that + * div. + */ +int isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap, enum isl_dim_type type, unsigned first, unsigned n) { int i; - if (!bset) + if (!bmap) return -1; - if (first + n > isl_basic_set_dim(bset, type)) - isl_die(bset->ctx, isl_error_invalid, + 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_set_offset(bset, type); - for (i = 0; i < bset->n_eq; ++i) - if (isl_seq_first_non_zero(bset->eq[i] + first, n) >= 0) + 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; - for (i = 0; i < bset->n_ineq; ++i) - if (isl_seq_first_non_zero(bset->ineq[i] + first, n) >= 0) + for (i = 0; i < bmap->n_div; ++i) { + if (isl_int_is_zero(bmap->div[i][0])) + continue; + if (isl_seq_first_non_zero(bmap->div[i] + 1 + first, n) >= 0) return 1; + } return 0; } -int isl_set_involves_dims(__isl_keep isl_set *set, +int isl_map_involves_dims(__isl_keep isl_map *map, enum isl_dim_type type, unsigned first, unsigned n) { int i; - if (!set) + if (!map) return -1; - if (first + n > isl_set_dim(set, type)) - isl_die(set->ctx, isl_error_invalid, + 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 < set->n; ++i) { - int involves = isl_basic_set_involves_dims(set->p[i], + for (i = 0; i < map->n; ++i) { + int involves = isl_basic_map_involves_dims(map->p[i], type, first, n); - if (involves < 0 || !involves) + if (involves < 0 || involves) return involves; } - return 1; + 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 @@ -1614,6 +1865,9 @@ __isl_give isl_basic_map *isl_basic_map_remove_unknown_divs( if (!div_is_unknown(bmap, i)) continue; bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1); + if (!bmap) + return NULL; + i = bmap->n_div; } return bmap; @@ -1708,7 +1962,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); @@ -1760,7 +2014,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"); @@ -1839,7 +2093,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); } @@ -1856,7 +2110,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; @@ -1879,7 +2134,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; } @@ -1887,13 +2142,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; } @@ -1909,7 +2164,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) { @@ -1941,7 +2196,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) @@ -1961,7 +2216,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); } @@ -1985,7 +2240,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); } @@ -2022,7 +2277,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); @@ -2038,17 +2293,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); @@ -2069,10 +2324,10 @@ 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); @@ -2084,9 +2339,9 @@ struct isl_basic_map *isl_basic_map_intersect_range( 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); @@ -2143,18 +2398,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 && @@ -2168,7 +2423,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); @@ -2198,6 +2453,12 @@ struct isl_basic_set *isl_basic_set_intersect( (struct isl_basic_map *)bset2); } +__isl_give isl_basic_set *isl_basic_set_intersect_params( + __isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2) +{ + return isl_basic_set_intersect(bset1, bset2); +} + /* Special case of isl_map_intersect, where both map1 and map2 * are convex, without any divs and such that either map1 or map2 * contains a single constraint. This constraint is then simply @@ -2250,7 +2511,11 @@ error: return NULL; } -struct isl_map *isl_map_intersect(struct isl_map *map1, struct isl_map *map2) +/* map2 may be either a parameter domain or a map living in the same + * space as map1. + */ +static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1, + __isl_take isl_map *map2) { unsigned flags = 0; struct isl_map *result; @@ -2259,37 +2524,34 @@ struct isl_map *isl_map_intersect(struct isl_map *map1, struct isl_map *map2) if (!map1 || !map2) goto error; - if (isl_map_plain_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_plain_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)) - 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; @@ -2315,6 +2577,27 @@ error: return NULL; } +static __isl_give isl_map *map_intersect(__isl_take isl_map *map1, + __isl_take isl_map *map2) +{ + if (!map1 || !map2) + goto error; + if (!isl_space_is_equal(map1->dim, map2->dim)) + isl_die(isl_map_get_ctx(map1), isl_error_invalid, + "spaces don't match", goto error); + return map_intersect_internal(map1, map2); +error: + isl_map_free(map1); + isl_map_free(map2); + 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 *) @@ -2322,9 +2605,30 @@ struct isl_set *isl_set_intersect(struct isl_set *set1, struct isl_set *set2) (struct isl_map *)set2); } +/* map_intersect_internal accepts intersections + * with parameter domains, so we can just call that function. + */ +static __isl_give isl_map *map_intersect_params(__isl_take isl_map *map, + __isl_take isl_set *params) +{ + return map_intersect_internal(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; @@ -2333,29 +2637,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); @@ -2370,14 +2688,18 @@ __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); + if (isl_basic_map_plain_is_empty(bmap)) { + isl_basic_map_free(bmap); + return isl_basic_map_set_to_empty(res); + } res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map); return isl_basic_map_finalize(res); } @@ -2403,19 +2725,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 (!map || !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; @@ -2431,10 +2767,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, @@ -2442,7 +2778,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, @@ -2487,7 +2823,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; @@ -2502,7 +2838,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); @@ -2527,11 +2863,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 = 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; @@ -2591,7 +2927,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; @@ -2623,7 +2959,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); @@ -2631,7 +2968,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); @@ -2648,7 +2985,7 @@ 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 = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map); return res; @@ -2667,7 +3004,7 @@ __isl_give isl_basic_map *isl_basic_map_project_out( isl_int *old; if (n == 0) - return bmap; + return basic_map_space_reset(bmap, type); if (!bmap) return NULL; @@ -2683,7 +3020,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)); @@ -2704,7 +3041,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); @@ -2737,7 +3074,7 @@ __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map, return NULL; if (n == 0) - return map; + return map_space_reset(map, type); isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error); @@ -2745,7 +3082,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; @@ -2789,7 +3126,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; @@ -2797,8 +3134,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); @@ -2817,7 +3154,7 @@ 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); @@ -2885,7 +3222,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); @@ -2904,7 +3241,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); @@ -2941,9 +3278,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; @@ -2997,6 +3334,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); } @@ -3057,7 +3395,7 @@ 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 = isl_basic_map_add_constraints_dim_map(result, bmap, dim_map); @@ -3223,11 +3561,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) @@ -3237,11 +3576,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) @@ -3254,12 +3594,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); @@ -3268,11 +3608,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) @@ -3285,19 +3626,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; @@ -3306,11 +3647,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, @@ -3319,39 +3660,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; @@ -3360,11 +3701,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, @@ -3373,43 +3714,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; @@ -3419,7 +3760,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; @@ -3429,7 +3770,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; @@ -3439,7 +3780,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; @@ -3449,7 +3790,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; @@ -3459,7 +3800,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; @@ -3469,7 +3810,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; @@ -3479,14 +3820,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; @@ -3494,14 +3835,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; } @@ -3514,7 +3855,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); @@ -3577,13 +3918,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; @@ -3615,7 +3956,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; } @@ -3624,8 +3965,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; @@ -3685,7 +4026,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; } @@ -3698,8 +4039,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); @@ -3717,7 +4058,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; @@ -3731,10 +4072,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; @@ -3749,14 +4090,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); @@ -3764,19 +4105,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; @@ -3785,44 +4126,108 @@ __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; } @@ -3831,14 +4236,25 @@ int isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap) { if (!bmap) return -1; - return isl_dim_may_be_set(bmap->dim); + 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_may_be_set(bmap)) + if (isl_basic_map_is_set(bmap)) return bmap; return isl_basic_map_domain(isl_basic_map_reverse(bmap)); } @@ -3847,7 +4263,7 @@ __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; int nparam, n_in, n_out; unsigned total; @@ -3856,7 +4272,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)); @@ -3885,7 +4301,7 @@ __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; int nparam, n_in, n_out; unsigned total; @@ -3894,7 +4310,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)); @@ -3923,7 +4339,18 @@ int isl_map_may_be_set(__isl_keep isl_map *map) { if (!map) return -1; - return isl_dim_may_be_set(map->dim); + 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) @@ -3933,7 +4360,7 @@ struct isl_set *isl_map_range(struct isl_map *map) if (!map) goto error; - if (isl_map_may_be_set(map)) + if (isl_map_is_set(map)) return (isl_set *)map; map = isl_map_cow(map); @@ -3941,7 +4368,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) { @@ -3960,15 +4387,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) { @@ -3987,15 +4414,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) { @@ -4011,7 +4439,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; @@ -4019,19 +4448,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; } @@ -4045,11 +4474,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; } @@ -4061,15 +4498,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) @@ -4082,7 +4517,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; @@ -4097,13 +4532,16 @@ 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; if (!dim) return NULL; - isl_assert(dim->ctx, n >= 0, return NULL); + if (n < 0) + isl_die(dim->ctx, isl_error_internal, + "negative number of basic maps", goto error); map = isl_alloc(dim->ctx, struct isl_map, sizeof(struct isl_map) + (n - 1) * sizeof(struct isl_basic_map *)); @@ -4119,7 +4557,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; } @@ -4128,28 +4566,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; } @@ -4159,7 +4597,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; } @@ -4169,7 +4607,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; } @@ -4179,34 +4617,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) @@ -4220,17 +4658,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); } @@ -4240,14 +4678,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( @@ -4255,56 +4693,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; } @@ -4313,7 +4751,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) @@ -4323,7 +4761,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; @@ -4338,7 +4776,7 @@ __isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map, 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++; @@ -4365,7 +4803,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); } @@ -4378,12 +4816,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; } @@ -4565,9 +5003,9 @@ struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value) isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value); } -__isl_give isl_basic_map *isl_basic_map_lower_bound_si( - __isl_take isl_basic_map *bmap, - enum isl_dim_type type, unsigned pos, int value) +static __isl_give isl_basic_map *basic_map_bound_si( + __isl_take isl_basic_map *bmap, + enum isl_dim_type type, unsigned pos, int value, int upper) { int j; @@ -4581,8 +5019,13 @@ __isl_give isl_basic_map *isl_basic_map_lower_bound_si( if (j < 0) goto error; isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap)); - isl_int_set_si(bmap->ineq[j][pos], 1); - isl_int_set_si(bmap->ineq[j][0], -value); + if (upper) { + isl_int_set_si(bmap->ineq[j][pos], -1); + isl_int_set_si(bmap->ineq[j][0], value); + } else { + isl_int_set_si(bmap->ineq[j][pos], 1); + isl_int_set_si(bmap->ineq[j][0], -value); + } bmap = isl_basic_map_simplify(bmap); return isl_basic_map_finalize(bmap); error: @@ -4590,6 +5033,13 @@ error: return NULL; } +__isl_give isl_basic_map *isl_basic_map_lower_bound_si( + __isl_take isl_basic_map *bmap, + enum isl_dim_type type, unsigned pos, int value) +{ + return basic_map_bound_si(bmap, type, pos, value, 0); +} + struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset, unsigned dim, isl_int value) { @@ -4610,8 +5060,8 @@ error: return NULL; } -__isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map, - enum isl_dim_type type, unsigned pos, int value) +static __isl_give isl_map *map_bound_si(__isl_take isl_map *map, + enum isl_dim_type type, unsigned pos, int value, int upper) { int i; @@ -4621,8 +5071,8 @@ __isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map, isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error); for (i = 0; i < map->n; ++i) { - map->p[i] = isl_basic_map_lower_bound_si(map->p[i], - type, pos, value); + map->p[i] = basic_map_bound_si(map->p[i], + type, pos, value, upper); if (!map->p[i]) goto error; } @@ -4633,6 +5083,18 @@ error: return NULL; } +__isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map, + enum isl_dim_type type, unsigned pos, int value) +{ + return map_bound_si(map, type, pos, value, 0); +} + +__isl_give isl_map *isl_map_upper_bound_si(__isl_take isl_map *map, + enum isl_dim_type type, unsigned pos, int value) +{ + return map_bound_si(map, type, pos, value, 1); +} + __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set, enum isl_dim_type type, unsigned pos, int value) { @@ -4640,6 +5102,12 @@ __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set, isl_map_lower_bound_si((struct isl_map *)set, type, pos, value); } +__isl_give isl_set *isl_set_upper_bound_si(__isl_take isl_set *set, + enum isl_dim_type type, unsigned pos, int value) +{ + return isl_map_upper_bound_si(set, type, pos, value); +} + struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim, isl_int value) { @@ -4669,7 +5137,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) { @@ -4734,6 +5202,56 @@ struct isl_set *isl_basic_set_partial_lexmax( dom, empty); } +__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexmin_pw_multi_aff( + __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom, + __isl_give isl_set **empty) +{ + return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, empty, 0); +} + +__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexmax_pw_multi_aff( + __isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom, + __isl_give isl_set **empty) +{ + return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, empty, 1); +} + +__isl_give isl_pw_multi_aff *isl_basic_set_partial_lexmin_pw_multi_aff( + __isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom, + __isl_give isl_set **empty) +{ + return isl_basic_map_partial_lexmin_pw_multi_aff(bset, dom, empty); +} + +__isl_give isl_pw_multi_aff *isl_basic_set_partial_lexmax_pw_multi_aff( + __isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom, + __isl_give isl_set **empty) +{ + return isl_basic_map_partial_lexmax_pw_multi_aff(bset, dom, empty); +} + +__isl_give isl_pw_multi_aff *isl_basic_map_lexopt_pw_multi_aff( + __isl_take isl_basic_map *bmap, int max) +{ + isl_basic_set *dom = NULL; + isl_space *dom_space; + + if (!bmap) + goto error; + dom_space = isl_space_domain(isl_space_copy(bmap->dim)); + dom = isl_basic_set_universe(dom_space); + return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, NULL, max); +error: + isl_basic_map_free(bmap); + return NULL; +} + +__isl_give isl_pw_multi_aff *isl_basic_map_lexmin_pw_multi_aff( + __isl_take isl_basic_map *bmap) +{ + return isl_basic_map_lexopt_pw_multi_aff(bmap, 0); +} + /* Given a basic map "bmap", compute the lexicographically minimal * (or maximal) image element for each domain element in dom. * Set *empty to those elements in dom that do not have an image element. @@ -4839,7 +5357,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) { @@ -4865,16 +5383,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); @@ -4913,6 +5431,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) @@ -4948,11 +5495,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: @@ -4983,11 +5530,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: @@ -5015,6 +5562,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. */ @@ -5026,7 +5704,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; @@ -5054,14 +5732,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; @@ -5071,20 +5749,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); @@ -5103,12 +5781,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) @@ -5223,7 +5901,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; @@ -5235,7 +5913,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; @@ -5245,7 +5923,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: @@ -5253,7 +5931,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; @@ -5261,7 +5939,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; @@ -5279,7 +5957,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; } @@ -5297,7 +5975,7 @@ struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap) 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) @@ -5305,7 +5983,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) @@ -5376,7 +6054,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) { @@ -5392,8 +6070,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; @@ -5411,13 +6089,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; @@ -5443,6 +6121,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); @@ -5467,8 +6151,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; @@ -5477,11 +6161,11 @@ struct isl_map *isl_map_intersect_range( if (!map || !set) goto error; - if (!isl_dim_match(map->dim, isl_dim_param, set->dim, isl_dim_param)) + 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_dim_size(set->dim, isl_dim_set) != 0 && + 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); @@ -5495,7 +6179,7 @@ struct isl_map *isl_map_intersect_range( 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; @@ -5517,6 +6201,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) { @@ -5524,8 +6214,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; @@ -5538,20 +6228,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) @@ -5574,12 +6270,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; @@ -5587,17 +6289,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( @@ -5610,7 +6312,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); @@ -5623,18 +6325,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) @@ -5654,19 +6356,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; 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)); @@ -5698,12 +6400,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); @@ -5711,9 +6413,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) { @@ -5728,7 +6430,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; @@ -5740,7 +6442,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; @@ -5758,7 +6460,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; @@ -5768,7 +6470,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; } @@ -5776,10 +6478,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)); } @@ -5788,39 +6490,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) { @@ -5838,13 +6541,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; @@ -5859,12 +6562,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; @@ -5893,9 +6596,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)); @@ -5923,14 +6626,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); @@ -6060,23 +6763,23 @@ 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; @@ -6089,6 +6792,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 isl_map_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) { @@ -6245,11 +6953,11 @@ struct isl_map *isl_basic_map_union( { struct isl_map *map; if (!bmap1 || !bmap2) - return NULL; + goto error; - 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); @@ -6278,7 +6986,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; @@ -6337,7 +7045,7 @@ __isl_give isl_basic_set *isl_basic_set_expand_divs( isl_die(isl_mat_get_ctx(div), isl_error_invalid, "not an expansion", goto error); - bset = isl_basic_map_extend_dim(bset, isl_dim_copy(bset->dim), + 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)); @@ -6378,7 +7086,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) @@ -6393,7 +7101,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; @@ -6406,7 +7114,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; @@ -6464,7 +7172,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; @@ -6478,6 +7187,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. */ @@ -6566,7 +7281,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; @@ -6582,9 +7297,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; @@ -6810,6 +7525,12 @@ int isl_map_plain_is_fixed(__isl_keep isl_map *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) { @@ -7052,6 +7773,31 @@ int isl_basic_map_plain_cmp(const __isl_keep isl_basic_map *bmap1, return 0; } +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) { @@ -7128,7 +7874,7 @@ int isl_map_plain_is_equal(__isl_keep isl_map *map1, __isl_keep 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); @@ -7250,7 +7996,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; @@ -7258,10 +8004,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); @@ -7281,7 +8027,7 @@ 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); @@ -7308,13 +8054,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; @@ -7322,8 +8113,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); @@ -7342,7 +8133,7 @@ __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); @@ -7356,10 +8147,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)) { @@ -7370,15 +8171,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; @@ -7405,9 +8206,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) @@ -7426,43 +8234,89 @@ __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); } -uint32_t isl_basic_map_get_hash(__isl_keep isl_basic_map *bmap) +__isl_give isl_map *isl_map_domain_product(__isl_take isl_map *map1, + __isl_take isl_map *map2) { - int i; - uint32_t hash = isl_hash_init(); - unsigned total; + return isl_map_align_params_map_map_and(map1, map2, + &map_domain_product_aligned); +} - if (!bmap) - return 0; - bmap = isl_basic_map_copy(bmap); - bmap = isl_basic_map_normalize(bmap); - if (!bmap) - return 0; - total = isl_basic_map_total_dim(bmap); - isl_hash_byte(hash, bmap->n_eq & 0xFF); - for (i = 0; i < bmap->n_eq; ++i) { - uint32_t c_hash; - c_hash = isl_seq_get_hash(bmap->eq[i], 1 + total); - isl_hash_hash(hash, c_hash); +__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; + uint32_t hash = isl_hash_init(); + unsigned total; + + if (!bmap) + return 0; + bmap = isl_basic_map_copy(bmap); + bmap = isl_basic_map_normalize(bmap); + if (!bmap) + return 0; + total = isl_basic_map_total_dim(bmap); + isl_hash_byte(hash, bmap->n_eq & 0xFF); + for (i = 0; i < bmap->n_eq; ++i) { + uint32_t c_hash; + c_hash = isl_seq_get_hash(bmap->eq[i], 1 + total); + isl_hash_hash(hash, c_hash); } isl_hash_byte(hash, bmap->n_ineq & 0xFF); for (i = 0; i < bmap->n_ineq; ++i) { @@ -7592,7 +8446,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; @@ -7601,11 +8455,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; @@ -7621,7 +8475,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); @@ -7634,11 +8488,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) { @@ -7655,7 +8509,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; @@ -7668,18 +8522,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); @@ -7744,11 +8598,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; @@ -7757,11 +8613,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) @@ -7773,6 +8635,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) { @@ -7800,6 +8680,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". @@ -7820,7 +8736,7 @@ int isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset, return -1; bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset)); - tab = isl_tab_from_basic_set(bset); + tab = isl_tab_from_basic_set(bset, 0); if (!bound || !tab) goto error; @@ -7933,7 +8849,7 @@ int isl_map_plain_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; @@ -7945,7 +8861,7 @@ int isl_map_is_single_valued(__isl_keep isl_map *map) 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); @@ -8032,7 +8948,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) { @@ -8076,7 +8992,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) @@ -8084,7 +9000,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) @@ -8093,7 +9009,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; @@ -8118,7 +9034,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; @@ -8134,7 +9050,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; @@ -8167,7 +9083,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; @@ -8183,14 +9099,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; @@ -8210,7 +9126,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); @@ -8222,7 +9138,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; @@ -8244,7 +9160,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; @@ -8261,6 +9177,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; @@ -8280,7 +9246,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; @@ -8297,38 +9263,103 @@ __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; } +__isl_give isl_map *isl_map_flatten_domain(__isl_take isl_map *map) +{ + int i; + + if (!map) + return NULL; + + if (!map->dim->nested[0]) + return map; + + map = isl_map_cow(map); + if (!map) + return NULL; + + 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 map; +error: + isl_map_free(map); + return NULL; +} + +__isl_give isl_map *isl_map_flatten_range(__isl_take isl_map *map) +{ + int i; + + if (!map) + return NULL; + + if (!map->dim->nested[1]) + return map; + + map = isl_map_cow(map); + if (!map) + return NULL; + + 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 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; + unsigned flags; bmap = isl_basic_map_cow(bmap); if (!bmap || !dim || !dim_map) goto error; - res = isl_basic_map_alloc_dim(dim, + flags = bmap->flags; + ISL_FL_CLR(flags, ISL_BASIC_MAP_FINAL); + ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED); + ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED_DIVS); + res = isl_basic_map_alloc_space(dim, bmap->n_div, bmap->n_eq, bmap->n_ineq); res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map); + if (res) + res->flags = flags; 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; } @@ -8351,13 +9382,13 @@ __isl_give isl_map *isl_map_realign(__isl_take isl_map *map, 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); @@ -8376,42 +9407,42 @@ __isl_give isl_set *isl_set_realign(__isl_take isl_set *set, } __isl_give isl_map *isl_map_align_params(__isl_take isl_map *map, - __isl_take isl_dim *model) + __isl_take isl_space *model) { isl_ctx *ctx; if (!map || !model) goto error; - ctx = isl_dim_get_ctx(model); - if (!isl_dim_has_named_params(model)) + 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_dim_has_named_params(map->dim)) + if (!isl_space_has_named_params(map->dim)) isl_die(ctx, isl_error_invalid, "relation has unnamed parameters", goto error); - if (!isl_dim_match(map->dim, isl_dim_param, model, isl_dim_param)) { + if (!isl_space_match(map->dim, isl_dim_param, model, isl_dim_param)) { isl_reordering *exp; - model = isl_dim_drop(model, isl_dim_in, - 0, isl_dim_size(model, isl_dim_in)); - model = isl_dim_drop(model, isl_dim_out, - 0, isl_dim_size(model, isl_dim_out)); + 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_dim(exp, isl_map_get_dim(map)); + exp = isl_reordering_extend_space(exp, isl_map_get_space(map)); map = isl_map_realign(map, exp); } - isl_dim_free(model); + isl_space_free(model); return map; error: - isl_dim_free(model); + 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_dim *model) + __isl_take isl_space *model) { return isl_map_align_params(set, model); } @@ -8475,7 +9506,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) @@ -8495,7 +9526,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, @@ -8503,7 +9534,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; @@ -8540,13 +9571,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; @@ -8569,7 +9600,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) { @@ -8583,7 +9614,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) @@ -8591,7 +9622,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 @@ -8610,13 +9641,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; @@ -8649,7 +9680,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; @@ -8658,3 +9689,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; +}