From 84037b07483c1970b915b7e829598a3cbd2c5d7f Mon Sep 17 00:00:00 2001 From: Sven Verdoolaege Date: Thu, 6 Nov 2008 17:50:04 +0100 Subject: [PATCH] introduce isl_dim structure for representing shared dimension information All of isl_basic_set, isl_set, isl_basic_map and isl_map stored information about the dimension directly. This information is now shared in a common isl_dim structure. Direct accesses to the removed fields have been replaced by calls to getters. --- Makefile.am | 2 + include/isl_dim.h | 37 ++ include/isl_map.h | 31 +- include/isl_set.h | 20 +- isl_affine_hull.c | 32 +- isl_constraint.c | 97 +++-- isl_convex_hull.c | 112 +++--- isl_dim.c | 123 ++++++ isl_equalities.c | 18 +- isl_input.c | 7 +- isl_input_omega.c | 14 +- isl_lp_piplib.c | 2 +- isl_map.c | 1061 +++++++++++++++++++++++++++++++++------------------ isl_map_piplib.c | 87 +++-- isl_map_polylib.c | 36 +- isl_map_private.h | 19 + isl_mat.c | 21 +- isl_output.c | 12 +- isl_sample.c | 20 +- isl_sample_piplib.c | 23 +- 20 files changed, 1209 insertions(+), 565 deletions(-) create mode 100644 include/isl_dim.h create mode 100644 isl_dim.c diff --git a/Makefile.am b/Makefile.am index 78ab76a..df2318f 100644 --- a/Makefile.am +++ b/Makefile.am @@ -46,6 +46,7 @@ libisl_la_SOURCES = \ isl_constraint.c \ isl_convex_hull.c \ isl_ctx.c \ + isl_dim.c \ isl_equalities.c \ isl_equalities.h \ isl_gmp.c \ @@ -90,6 +91,7 @@ nodist_pkginclude_HEADERS = \ pkginclude_HEADERS = \ include/isl_blk.h \ include/isl_constraint.h \ + include/isl_dim.h \ include/isl_int.h \ include/isl_list.h \ include/isl_lp.h \ diff --git a/include/isl_dim.h b/include/isl_dim.h new file mode 100644 index 0000000..b43c909 --- /dev/null +++ b/include/isl_dim.h @@ -0,0 +1,37 @@ +#ifndef ISL_DIM_H +#define ISL_DIM_H + +#include + +#if defined(__cplusplus) +extern "C" { +#endif + +struct isl_dim { + int ref; + + struct isl_ctx *ctx; + + unsigned nparam; + unsigned n_in; /* zero for sets */ + unsigned n_out; /* dim for sets */ +}; + +struct isl_dim *isl_dim_alloc(struct isl_ctx *ctx, + unsigned nparam, unsigned n_in, unsigned n_out); +struct isl_dim *isl_dim_copy(struct isl_dim *dim); +struct isl_dim *isl_dim_cow(struct isl_dim *dim); +void isl_dim_free(struct isl_dim *dim); + +struct isl_dim *isl_dim_join(struct isl_dim *left, struct isl_dim *right); +struct isl_dim *isl_dim_reverse(struct isl_dim *dim); + +int isl_dim_equal(struct isl_dim *dim1, struct isl_dim *dim2); +int isl_dim_compatible(struct isl_dim *dim1, struct isl_dim *dim2); +unsigned isl_dim_total(struct isl_dim *dim); + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/include/isl_map.h b/include/isl_map.h index adce6a4..3c66e8d 100644 --- a/include/isl_map.h +++ b/include/isl_map.h @@ -6,6 +6,7 @@ #include #include #include +#include #if defined(__cplusplus) extern "C" { @@ -34,6 +35,7 @@ extern "C" { * n_in + n_out should be equal to set.dim */ struct isl_vec; +struct isl_dim; struct isl_basic_map { int ref; #define ISL_BASIC_MAP_FINAL (1 << 0) @@ -46,9 +48,7 @@ struct isl_basic_map { struct isl_ctx *ctx; - unsigned nparam; - unsigned n_in; - unsigned n_out; + struct isl_dim *dim; unsigned extra; unsigned n_eq; @@ -83,9 +83,7 @@ struct isl_map { struct isl_ctx *ctx; - unsigned nparam; - unsigned n_in; - unsigned n_out; + struct isl_dim *dim; int n; @@ -94,6 +92,16 @@ struct isl_map { }; struct isl_set; +unsigned isl_basic_map_n_in(const struct isl_basic_map *bmap); +unsigned isl_basic_map_n_out(const struct isl_basic_map *bmap); +unsigned isl_basic_map_n_param(const struct isl_basic_map *bmap); +unsigned isl_basic_map_n_div(const struct isl_basic_map *bmap); +unsigned isl_basic_map_total_dim(const struct isl_basic_map *bmap); + +unsigned isl_map_n_in(const struct isl_map *map); +unsigned isl_map_n_out(const struct isl_map *map); +unsigned isl_map_n_param(const struct isl_map *map); + struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out, unsigned extra, unsigned n_eq, unsigned n_ineq); @@ -105,6 +113,8 @@ struct isl_basic_map *isl_basic_map_copy(struct isl_basic_map *bmap); struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base, unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra, unsigned n_eq, unsigned n_ineq); +struct isl_basic_map *isl_basic_map_extend_constraints( + struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq); struct isl_basic_map *isl_basic_map_equal(struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out, unsigned n_equal); struct isl_basic_map *isl_basic_map_less_at(struct isl_ctx *ctx, @@ -113,6 +123,8 @@ struct isl_basic_map *isl_basic_map_more_at(struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out, unsigned pos); struct isl_basic_map *isl_basic_map_empty(struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out); +struct isl_basic_map *isl_basic_map_empty_like(struct isl_basic_map *model); +struct isl_basic_map *isl_basic_map_empty_like_map(struct isl_map *model); struct isl_basic_map *isl_basic_map_universe(struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out); struct isl_basic_map *isl_basic_map_convex_hull(struct isl_basic_map *bmap); @@ -136,7 +148,7 @@ struct isl_basic_map *isl_basic_map_reverse(struct isl_basic_map *bmap); struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap); struct isl_basic_set *isl_basic_map_range(struct isl_basic_map *bmap); struct isl_basic_map *isl_basic_map_from_basic_set(struct isl_basic_set *bset, - unsigned n_in, unsigned n_out); + struct isl_dim *dim); struct isl_basic_set *isl_basic_set_from_basic_map(struct isl_basic_map *bmap); struct isl_basic_map *isl_basic_map_simplify(struct isl_basic_map *bmap); #define ISL_FORMAT_POLYLIB 1 @@ -165,6 +177,8 @@ struct isl_map *isl_map_alloc(struct isl_ctx *ctx, unsigned flags); struct isl_map *isl_map_empty(struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out); +struct isl_map *isl_map_empty_like(struct isl_map *model); +struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model); struct isl_map *isl_map_dup(struct isl_map *map); struct isl_map *isl_map_add(struct isl_map *map, struct isl_basic_map *bmap); struct isl_map *isl_map_identity(struct isl_ctx *ctx, @@ -203,8 +217,7 @@ struct isl_map *isl_map_remove_inputs(struct isl_map *map, struct isl_set *isl_map_domain(struct isl_map *bmap); struct isl_map *isl_map_from_basic_map(struct isl_basic_map *bmap); -struct isl_map *isl_map_from_set(struct isl_set *set, - unsigned n_in, unsigned n_out); +struct isl_map *isl_map_from_set(struct isl_set *set, struct isl_dim *dim); struct isl_set *isl_set_from_map(struct isl_map *map); int isl_map_is_empty(struct isl_map *map); diff --git a/include/isl_set.h b/include/isl_set.h index 245cc51..36558d3 100644 --- a/include/isl_set.h +++ b/include/isl_set.h @@ -20,9 +20,7 @@ struct isl_basic_set { struct isl_ctx *ctx; - unsigned nparam; - unsigned zero; - unsigned dim; + struct isl_dim *dim; unsigned extra; unsigned n_eq; @@ -54,9 +52,7 @@ struct isl_set { struct isl_ctx *ctx; - unsigned nparam; - unsigned zero; - unsigned dim; + struct isl_dim *dim; int n; @@ -64,20 +60,31 @@ struct isl_set { struct isl_basic_set *p[0]; }; +unsigned isl_basic_set_n_dim(const struct isl_basic_set *bset); +unsigned isl_basic_set_n_param(const struct isl_basic_set *bset); +unsigned isl_basic_set_total_dim(const struct isl_basic_set *bset); + +unsigned isl_set_n_dim(const struct isl_set *set); +unsigned isl_set_n_param(const struct isl_set *set); + struct isl_basic_set *isl_basic_set_alloc(struct isl_ctx *ctx, unsigned nparam, unsigned dim, unsigned extra, unsigned n_eq, unsigned n_ineq); struct isl_basic_set *isl_basic_set_extend(struct isl_basic_set *base, unsigned nparam, unsigned dim, unsigned extra, unsigned n_eq, unsigned n_ineq); +struct isl_basic_set *isl_basic_set_extend_constraints( + struct isl_basic_set *base, unsigned n_eq, unsigned n_ineq); struct isl_basic_set *isl_basic_set_finalize(struct isl_basic_set *bset); void isl_basic_set_free(struct isl_basic_set *bset); struct isl_basic_set *isl_basic_set_copy(struct isl_basic_set *bset); struct isl_basic_set *isl_basic_set_dup(struct isl_basic_set *bset); struct isl_basic_set *isl_basic_set_empty(struct isl_ctx *ctx, unsigned nparam, unsigned dim); +struct isl_basic_set *isl_basic_set_empty_like(struct isl_basic_set *bset); struct isl_basic_set *isl_basic_set_universe(struct isl_ctx *ctx, unsigned nparam, unsigned dim); +struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *bset); struct isl_basic_set *isl_basic_set_interval(struct isl_ctx *ctx, isl_int min, isl_int max); void isl_basic_set_dump(struct isl_basic_set *bset, @@ -129,6 +136,7 @@ struct isl_set *isl_set_extend(struct isl_set *base, unsigned nparam, unsigned dim); struct isl_set *isl_set_empty(struct isl_ctx *ctx, unsigned nparam, unsigned dim); +struct isl_set *isl_set_empty_like(struct isl_set *set); struct isl_set *isl_set_add(struct isl_set *set, struct isl_basic_set *bset); struct isl_set *isl_set_finalize(struct isl_set *set); struct isl_set *isl_set_copy(struct isl_set *set); diff --git a/isl_affine_hull.c b/isl_affine_hull.c index ea08d02..ef37303 100644 --- a/isl_affine_hull.c +++ b/isl_affine_hull.c @@ -120,7 +120,7 @@ static void construct_column( isl_int_init(a); isl_int_init(b); - total = 1 + bset1->dim; + total = 1 + isl_basic_set_n_dim(bset1); for (r = 0; r < row; ++r) { if (isl_int_is_zero(bset2->eq[r][col])) continue; @@ -159,7 +159,7 @@ static int transform_column( if (t < 0) return 0; - total = 1 + bset1->dim; + total = 1 + isl_basic_set_n_dim(bset1); isl_int_init(a); isl_int_init(b); isl_int_init(g); @@ -194,7 +194,7 @@ static struct isl_basic_set *affine_hull( int col; int row; - total = 1 + bset1->dim; + total = 1 + isl_basic_set_n_dim(bset1); row = 0; for (col = total-1; col >= 0; --col) { @@ -228,17 +228,21 @@ static struct isl_basic_set *isl_basic_set_from_vec(struct isl_ctx *ctx, int i; int k; struct isl_basic_set *bset = NULL; + unsigned dim; if (!vec) return NULL; isl_assert(ctx, vec->size != 0, goto error); bset = isl_basic_set_alloc(ctx, 0, vec->size - 1, 0, vec->size - 1, 0); - for (i = bset->dim - 1; i >= 0; --i) { + if (!bset) + goto error; + dim = isl_basic_set_n_dim(bset); + for (i = dim - 1; i >= 0; --i) { k = isl_basic_set_alloc_equality(bset); if (k < 0) goto error; - isl_seq_clr(bset->eq[k], 1 + bset->dim); + isl_seq_clr(bset->eq[k], 1 + dim); isl_int_neg(bset->eq[k][0], vec->block.data[1 + i]); isl_int_set(bset->eq[k][1 + i], vec->block.data[0]); } @@ -257,16 +261,18 @@ static struct isl_basic_set *outside_point(struct isl_ctx *ctx, struct isl_basic_set *slice = NULL; struct isl_vec *sample; struct isl_basic_set *point; + unsigned dim; int k; slice = isl_basic_set_copy(bset); if (!slice) goto error; - slice = isl_basic_set_extend(slice, 0, slice->dim, 0, 1, 0); + dim = isl_basic_set_n_dim(slice); + slice = isl_basic_set_extend(slice, 0, dim, 0, 1, 0); k = isl_basic_set_alloc_equality(slice); if (k < 0) goto error; - isl_seq_cpy(slice->eq[k], eq, 1 + slice->dim); + isl_seq_cpy(slice->eq[k], eq, 1 + dim); if (up) isl_int_add_ui(slice->eq[k][0], slice->eq[k][0], 1); else @@ -277,7 +283,7 @@ static struct isl_basic_set *outside_point(struct isl_ctx *ctx, goto error; if (sample->size == 0) { isl_vec_free(ctx, sample); - point = isl_basic_set_empty(ctx, 0, bset->dim); + point = isl_basic_set_empty_like(bset); } else point = isl_basic_set_from_vec(ctx, sample); @@ -306,6 +312,7 @@ struct isl_basic_map *isl_basic_map_affine_hull(struct isl_basic_map *bmap) struct isl_basic_set *hull = NULL; struct isl_vec *sample; struct isl_ctx *ctx; + unsigned dim; bmap = isl_basic_map_implicit_equalities(bmap); if (!bmap) @@ -326,7 +333,8 @@ struct isl_basic_map *isl_basic_map_affine_hull(struct isl_basic_map *bmap) sample = isl_basic_set_sample(isl_basic_set_copy(bset)); hull = isl_basic_set_from_vec(ctx, sample); - for (i = 0; i < bset->dim; ++i) { + dim = isl_basic_set_n_dim(bset); + for (i = 0; i < dim; ++i) { struct isl_basic_set *point; for (j = 0; j < hull->n_eq; ++j) { point = outside_point(ctx, bset, hull->eq[j], 1); @@ -385,8 +393,7 @@ struct isl_basic_map *isl_map_affine_hull(struct isl_map *map) return NULL; if (map->n == 0) { - hull = isl_basic_map_empty(map->ctx, - map->nparam, map->n_in, map->n_out); + hull = isl_basic_map_empty_like_map(map); isl_map_free(map); return hull; } @@ -407,8 +414,7 @@ struct isl_basic_map *isl_map_affine_hull(struct isl_map *map) } set = isl_set_remove_empty_parts(set); if (set->n == 0) { - hull = isl_basic_map_empty(set->ctx, - model->nparam, model->n_in, model->n_out); + hull = isl_basic_map_empty_like(model); isl_basic_map_free(model); } else { struct isl_basic_set *bset; diff --git a/isl_constraint.c b/isl_constraint.c index 349f62d..65d7f90 100644 --- a/isl_constraint.c +++ b/isl_constraint.c @@ -70,7 +70,7 @@ int isl_basic_set_constraint_nparam( { if (!isl_basic_set_constraint_is_valid(constraint)) return -1; - return constraint.bset->nparam; + return isl_basic_set_n_param(constraint.bset); } int isl_basic_set_constraint_dim( @@ -78,7 +78,7 @@ int isl_basic_set_constraint_dim( { if (!isl_basic_set_constraint_is_valid(constraint)) return -1; - return constraint.bset->dim; + return isl_basic_set_n_dim(constraint.bset); } int isl_basic_set_constraint_n_div( @@ -100,48 +100,63 @@ void isl_basic_set_constraint_get_constant( void isl_basic_set_constraint_get_dim( struct isl_basic_set_constraint constraint, int pos, isl_int *v) { + unsigned dim; + unsigned nparam; if (!isl_basic_set_constraint_is_valid(constraint)) return; - isl_assert(constraint.bset->ctx, pos < constraint.bset->dim, return); - isl_int_set(*v, constraint.line[0][1 + constraint.bset->nparam + pos]); + nparam = isl_basic_set_n_param(constraint.bset); + dim = isl_basic_set_n_dim(constraint.bset); + isl_assert(constraint.bset->ctx, pos < dim, return); + isl_int_set(*v, constraint.line[0][1 + nparam + pos]); } void isl_basic_set_constraint_get_div( struct isl_basic_set_constraint constraint, int pos, isl_int *v) { + unsigned dim; + unsigned nparam; if (!isl_basic_set_constraint_is_valid(constraint)) return; + nparam = isl_basic_set_n_param(constraint.bset); + dim = isl_basic_set_n_dim(constraint.bset); isl_assert(constraint.bset->ctx, pos < constraint.bset->n_div, return); - isl_int_set(*v, constraint.line[0][1 + constraint.bset->nparam + - constraint.bset->dim + pos]); + isl_int_set(*v, constraint.line[0][1 + nparam + dim + pos]); } void isl_basic_set_constraint_get_param( struct isl_basic_set_constraint constraint, int pos, isl_int *v) { + unsigned nparam; if (!isl_basic_set_constraint_is_valid(constraint)) return; - isl_assert(constraint.bset->ctx, pos < constraint.bset->nparam, return); + nparam = isl_basic_set_n_param(constraint.bset); + isl_assert(constraint.bset->ctx, pos < nparam, return); isl_int_set(*v, constraint.line[0][1 + pos]); } void isl_basic_set_constraint_set_dim( struct isl_basic_set_constraint constraint, int pos, isl_int v) { + unsigned dim; + unsigned nparam; if (!isl_basic_set_constraint_is_valid(constraint)) return; isl_assert(constraint.bset->ctx, constraint.bset->ref == 1, return); - isl_assert(constraint.bset->ctx, pos < constraint.bset->dim, return); - isl_int_set(constraint.line[0][1 + constraint.bset->nparam + pos], v); + nparam = isl_basic_set_n_param(constraint.bset); + dim = isl_basic_set_n_dim(constraint.bset); + isl_assert(constraint.bset->ctx, pos < dim, return); + isl_int_set(constraint.line[0][1 + nparam + pos], v); } void isl_basic_set_constraint_set_param( struct isl_basic_set_constraint constraint, int pos, isl_int v) { + unsigned nparam; if (!isl_basic_set_constraint_is_valid(constraint)) return; isl_assert(constraint.bset->ctx, constraint.bset->ref == 1, return); - isl_assert(constraint.bset->ctx, pos < constraint.bset->nparam, return); + nparam = isl_basic_set_n_param(constraint.bset); + isl_assert(constraint.bset->ctx, pos < nparam, return); isl_int_set(constraint.line[0][1 + pos], v); } @@ -152,7 +167,7 @@ void isl_basic_set_constraint_clear(struct isl_basic_set_constraint constraint) if (!isl_basic_set_constraint_is_valid(constraint)) return; - total = bset->nparam + bset->dim + bset->n_div; + total = isl_basic_set_total_dim(bset); isl_seq_clr(constraint.line[0], 1 + total); } @@ -167,19 +182,27 @@ int isl_basic_set_constraint_is_equality( int isl_basic_set_constraint_is_dim_lower_bound( struct isl_basic_set_constraint constraint, int pos) { + unsigned dim; + unsigned nparam; if (!isl_basic_set_constraint_is_valid(constraint)) return -1; - isl_assert(constraint.bset->ctx, pos < constraint.bset->dim, return -1); - return isl_int_is_pos(constraint.line[0][1+constraint.bset->nparam+pos]); + nparam = isl_basic_set_n_param(constraint.bset); + dim = isl_basic_set_n_dim(constraint.bset); + isl_assert(constraint.bset->ctx, pos < dim, return -1); + return isl_int_is_pos(constraint.line[0][1+nparam+pos]); } int isl_basic_set_constraint_is_dim_upper_bound( struct isl_basic_set_constraint constraint, int pos) { + unsigned dim; + unsigned nparam; if (!isl_basic_set_constraint_is_valid(constraint)) return -1; - isl_assert(constraint.bset->ctx, pos < constraint.bset->dim, return -1); - return isl_int_is_neg(constraint.line[0][1+constraint.bset->nparam+pos]); + nparam = isl_basic_set_n_param(constraint.bset); + dim = isl_basic_set_n_dim(constraint.bset); + isl_assert(constraint.bset->ctx, pos < dim, return -1); + return isl_int_is_neg(constraint.line[0][1+nparam+pos]); } @@ -189,15 +212,18 @@ struct isl_basic_set *isl_basic_set_from_constraint( int k; struct isl_basic_set *bset; isl_int *c; + unsigned dim; + unsigned nparam; unsigned total; if (!isl_basic_set_constraint_is_valid(constraint)) return NULL; - bset = isl_basic_set_universe(constraint.bset->ctx, - constraint.bset->nparam, constraint.bset->dim); + bset = isl_basic_set_universe_like(constraint.bset); bset = isl_basic_set_align_divs(bset, constraint.bset); - bset = isl_basic_set_extend(bset, bset->nparam, bset->dim, 0, 1, 1); + nparam = isl_basic_set_n_param(bset); + dim = isl_basic_set_n_dim(bset); + bset = isl_basic_set_extend(bset, nparam, dim, 0, 1, 1); if (isl_basic_set_constraint_is_equality(constraint)) { k = isl_basic_set_alloc_equality(bset); if (k < 0) @@ -210,7 +236,7 @@ struct isl_basic_set *isl_basic_set_from_constraint( goto error; c = bset->ineq[k]; } - total = bset->nparam + bset->dim + bset->n_div; + total = isl_basic_set_total_dim(bset); isl_seq_cpy(c, constraint.line[0], 1 + total); return bset; error: @@ -223,14 +249,17 @@ int isl_basic_set_has_defining_equality( struct isl_basic_set_constraint *constraint) { int i; + unsigned dim, nparam; if (!bset) return -1; - isl_assert(bset->ctx, pos < bset->dim, return -1); + nparam = isl_basic_set_n_param(bset); + dim = isl_basic_set_n_dim(bset); + isl_assert(bset->ctx, pos < dim, return -1); for (i = 0; i < bset->n_eq; ++i) - if (!isl_int_is_zero(bset->eq[i][1 + bset->nparam + pos]) && - isl_seq_first_non_zero(bset->eq[i]+1+bset->nparam+pos+1, - bset->dim-pos-1) == -1) { + if (!isl_int_is_zero(bset->eq[i][1 + nparam + pos]) && + isl_seq_first_non_zero(bset->eq[i]+1+nparam+pos+1, + dim-pos-1) == -1) { constraint->bset = bset; constraint->line = &bset->eq[i]; return 1; @@ -244,35 +273,39 @@ int isl_basic_set_has_defining_inequalities( struct isl_basic_set_constraint *upper) { int i, j; + unsigned dim; + unsigned nparam; unsigned total; isl_int m; if (!bset) return -1; - isl_assert(bset->ctx, pos < bset->dim, return -1); - total = bset->nparam + bset->dim + bset->n_div; + nparam = isl_basic_set_n_param(bset); + dim = isl_basic_set_n_dim(bset); + total = isl_basic_set_total_dim(bset); + isl_assert(bset->ctx, pos < dim, return -1); isl_int_init(m); for (i = 0; i < bset->n_ineq; ++i) { - if (isl_int_is_zero(bset->ineq[i][1 + bset->nparam + pos])) + if (isl_int_is_zero(bset->ineq[i][1 + nparam + pos])) continue; - if (isl_int_is_one(bset->ineq[i][1 + bset->nparam + pos])) + if (isl_int_is_one(bset->ineq[i][1 + nparam + pos])) continue; - if (isl_int_is_negone(bset->ineq[i][1 + bset->nparam + pos])) + if (isl_int_is_negone(bset->ineq[i][1 + nparam + pos])) continue; - if (isl_seq_first_non_zero(bset->ineq[i]+1+bset->nparam+pos+1, - bset->dim-pos-1) != -1) + if (isl_seq_first_non_zero(bset->ineq[i]+1+nparam+pos+1, + dim-pos-1) != -1) continue; for (j = i + i; j < bset->n_ineq; ++j) { if (!isl_seq_is_neg(bset->ineq[i]+1, bset->ineq[j]+1, total)) continue; isl_int_add(m, bset->ineq[i][0], bset->ineq[j][0]); - if (isl_int_abs_ge(m, bset->ineq[i][1+bset->nparam+pos])) + if (isl_int_abs_ge(m, bset->ineq[i][1+nparam+pos])) continue; lower->bset = bset; upper->bset = bset; - if (isl_int_is_pos(bset->ineq[i][1+bset->nparam+pos])) { + if (isl_int_is_pos(bset->ineq[i][1+nparam+pos])) { lower->line = &bset->ineq[i]; upper->line = &bset->ineq[j]; } else { diff --git a/isl_convex_hull.c b/isl_convex_hull.c index 8e6c5d7..4d09999 100644 --- a/isl_convex_hull.c +++ b/isl_convex_hull.c @@ -34,7 +34,7 @@ int isl_basic_map_constraint_is_redundant(struct isl_basic_map **bmap, if (!bmap) return -1; - total = (*bmap)->nparam + (*bmap)->n_in + (*bmap)->n_out + (*bmap)->n_div; + total = isl_basic_map_total_dim(*bmap); for (i = 0; i < total; ++i) { int sign; if (isl_int_is_zero(c[1+i])) @@ -242,17 +242,18 @@ static struct isl_mat *independent_bounds(struct isl_ctx *ctx, { int i, j, n; struct isl_mat *dirs = NULL; + unsigned dim = isl_set_n_dim(set); - dirs = isl_mat_alloc(ctx, set->dim, 1+set->dim); + dirs = isl_mat_alloc(ctx, dim, 1+dim); if (!dirs) goto error; n = 0; - for (i = 0; n < set->dim && i < set->n; ++i) { + for (i = 0; n < dim && i < set->n; ++i) { int f; struct isl_basic_set *bset = set->p[i]; - for (j = 0; n < set->dim && j < bset->n_eq; ++j) { + for (j = 0; n < dim && j < bset->n_eq; ++j) { f = is_independent_bound(ctx, set, bset->eq[j], dirs, n); if (f < 0) @@ -260,7 +261,7 @@ static struct isl_mat *independent_bounds(struct isl_ctx *ctx, if (f) ++n; } - for (j = 0; n < set->dim && j < bset->n_ineq; ++j) { + for (j = 0; n < dim && j < bset->n_ineq; ++j) { f = is_independent_bound(ctx, set, bset->ineq[j], dirs, n); if (f < 0) @@ -317,17 +318,19 @@ static struct isl_basic_set *isl_basic_set_add_equality(struct isl_ctx *ctx, { int i; unsigned total; + unsigned dim; if (F_ISSET(bset, ISL_BASIC_SET_EMPTY)) return bset; - isl_assert(ctx, bset->nparam == 0, goto error); + isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error); isl_assert(ctx, bset->n_div == 0, goto error); - bset = isl_basic_set_extend(bset, 0, bset->dim, 0, 1, 0); + dim = isl_basic_set_n_dim(bset); + bset = isl_basic_set_extend(bset, 0, dim, 0, 1, 0); i = isl_basic_set_alloc_equality(bset); if (i < 0) goto error; - isl_seq_cpy(bset->eq[i], c, 1 + bset->dim); + isl_seq_cpy(bset->eq[i], c, 1 + dim); return bset; error: isl_basic_set_free(bset); @@ -377,12 +380,12 @@ static struct isl_basic_set *wrap_constraints(struct isl_ctx *ctx, unsigned n_eq; unsigned n_ineq; int i, j, k; - unsigned dim; + unsigned dim, lp_dim; if (!set) return NULL; - dim = 1 + set->dim; + dim = 1 + isl_set_n_dim(set); n_eq = 1; n_ineq = set->n; for (i = 0; i < set->n; ++i) { @@ -392,6 +395,7 @@ static struct isl_basic_set *wrap_constraints(struct isl_ctx *ctx, lp = isl_basic_set_alloc(ctx, 0, dim * set->n, 0, n_eq, n_ineq); if (!lp) return NULL; + lp_dim = isl_basic_set_n_dim(lp); k = isl_basic_set_alloc_equality(lp); isl_int_set_si(lp->eq[k][0], -1); for (i = 0; i < set->n; ++i) { @@ -401,7 +405,7 @@ static struct isl_basic_set *wrap_constraints(struct isl_ctx *ctx, } for (i = 0; i < set->n; ++i) { k = isl_basic_set_alloc_inequality(lp); - isl_seq_clr(lp->ineq[k], 1+lp->dim); + isl_seq_clr(lp->ineq[k], 1+lp_dim); isl_int_set_si(lp->ineq[k][1+dim*i], 1); for (j = 0; j < set->p[i]->n_eq; ++j) { @@ -491,14 +495,14 @@ static isl_int *wrap_facet(struct isl_ctx *ctx, struct isl_set *set, set = isl_set_copy(set); - dim = 1 + set->dim; - T = isl_mat_alloc(ctx, 3, 1 + set->dim); + dim = 1 + isl_set_n_dim(set); + T = isl_mat_alloc(ctx, 3, dim); if (!T) goto error; isl_int_set_si(T->row[0][0], 1); - isl_seq_clr(T->row[0]+1, set->dim); - isl_seq_cpy(T->row[1], facet, 1+set->dim); - isl_seq_cpy(T->row[2], ridge, 1+set->dim); + isl_seq_clr(T->row[0]+1, dim - 1); + isl_seq_cpy(T->row[1], facet, dim); + isl_seq_cpy(T->row[2], ridge, dim); T = isl_mat_right_inverse(ctx, T); set = isl_set_preimage(ctx, set, T); T = NULL; @@ -555,9 +559,10 @@ static struct isl_mat *initial_facet_constraint(struct isl_ctx *ctx, struct isl_basic_set *face = NULL; struct isl_mat *m, *U, *Q; int i; + unsigned dim = isl_set_n_dim(set); isl_assert(ctx, set->n > 0, goto error); - isl_assert(ctx, bounds->n_row == set->dim, goto error); + isl_assert(ctx, bounds->n_row == dim, goto error); while (bounds->n_row > 1) { slice = isl_set_copy(set); @@ -569,19 +574,19 @@ static struct isl_mat *initial_facet_constraint(struct isl_ctx *ctx, isl_basic_set_free(face); break; } - m = isl_mat_alloc(ctx, 1 + face->n_eq, 1 + face->dim); + m = isl_mat_alloc(ctx, 1 + face->n_eq, 1 + dim); if (!m) goto error; isl_int_set_si(m->row[0][0], 1); - isl_seq_clr(m->row[0]+1, face->dim); + isl_seq_clr(m->row[0]+1, dim); for (i = 0; i < face->n_eq; ++i) - isl_seq_cpy(m->row[1 + i], face->eq[i], 1 + face->dim); + isl_seq_cpy(m->row[1 + i], face->eq[i], 1 + dim); U = isl_mat_right_inverse(ctx, m); Q = isl_mat_right_inverse(ctx, isl_mat_copy(ctx, U)); U = isl_mat_drop_cols(ctx, U, 1 + face->n_eq, - face->dim - face->n_eq); + dim - face->n_eq); Q = isl_mat_drop_rows(ctx, Q, 1 + face->n_eq, - face->dim - face->n_eq); + dim - face->n_eq); U = isl_mat_drop_cols(ctx, U, 0, 1); Q = isl_mat_drop_rows(ctx, Q, 0, 1); bounds = isl_mat_product(ctx, bounds, U); @@ -648,14 +653,16 @@ static struct isl_basic_set *compute_facet(struct isl_ctx *ctx, { struct isl_mat *m, *U, *Q; struct isl_basic_set *facet; + unsigned dim; set = isl_set_copy(set); - m = isl_mat_alloc(ctx, 2, 1 + set->dim); + dim = isl_set_n_dim(set); + m = isl_mat_alloc(ctx, 2, 1 + dim); if (!m) goto error; isl_int_set_si(m->row[0][0], 1); - isl_seq_clr(m->row[0]+1, set->dim); - isl_seq_cpy(m->row[1], c, 1+set->dim); + isl_seq_clr(m->row[0]+1, dim); + isl_seq_cpy(m->row[1], c, 1+dim); U = isl_mat_right_inverse(ctx, m); Q = isl_mat_right_inverse(ctx, isl_mat_copy(ctx, U)); U = isl_mat_drop_cols(ctx, U, 1, 1); @@ -691,6 +698,7 @@ static struct isl_basic_set *extend(struct isl_ctx *ctx, struct isl_set *set, struct isl_basic_set *facet = NULL; unsigned n_ineq; unsigned total; + unsigned dim; isl_assert(ctx, set->n > 0, goto error); @@ -699,8 +707,9 @@ static struct isl_basic_set *extend(struct isl_ctx *ctx, struct isl_set *set, n_ineq += set->p[i]->n_eq; n_ineq += set->p[i]->n_ineq; } - isl_assert(ctx, 1 + set->dim == initial->n_col, goto error); - hull = isl_basic_set_alloc(ctx, 0, set->dim, 0, 0, n_ineq); + dim = isl_set_n_dim(set); + isl_assert(ctx, 1 + dim == initial->n_col, goto error); + hull = isl_basic_set_alloc(ctx, 0, dim, 0, 0, n_ineq); hull = isl_basic_set_set_rational(hull); if (!hull) goto error; @@ -714,19 +723,19 @@ static struct isl_basic_set *extend(struct isl_ctx *ctx, struct isl_set *set, goto error; if (facet->n_ineq + hull->n_ineq > n_ineq) { hull = isl_basic_set_extend(hull, - hull->nparam, hull->dim, 0, 0, facet->n_ineq); + 0, dim, 0, 0, facet->n_ineq); n_ineq = hull->n_ineq + facet->n_ineq; } for (j = 0; j < facet->n_ineq; ++j) { k = isl_basic_set_alloc_inequality(hull); if (k < 0) goto error; - isl_seq_cpy(hull->ineq[k], hull->ineq[i], 1+hull->dim); + isl_seq_cpy(hull->ineq[k], hull->ineq[i], 1+dim); if (!wrap_facet(ctx, set, hull->ineq[k], facet->ineq[j])) goto error; for (f = 0; f < k; ++f) if (isl_seq_eq(hull->ineq[f], hull->ineq[k], - 1+hull->dim)) + 1+dim)) break; if (f < k) isl_basic_set_free_inequality(hull, 1); @@ -871,7 +880,7 @@ error: static struct isl_set *set_project_out(struct isl_ctx *ctx, struct isl_set *set, unsigned n) { - return isl_set_remove_dims(set, set->dim - n, n); + return isl_set_remove_dims(set, isl_set_n_dim(set) - n, n); } static struct isl_basic_set *convex_hull_0d(struct isl_set *set) @@ -909,9 +918,9 @@ static struct isl_basic_set *convex_hull_pair(struct isl_basic_set *bset1, if (!bset1 || !bset2) goto error; - dim = bset1->dim; - hull = isl_basic_set_alloc(bset1->ctx, 0, 2 + 3 * bset1->dim, 0, - 1 + bset1->dim + bset1->n_eq + bset2->n_eq, + dim = isl_basic_set_n_dim(bset1); + hull = isl_basic_set_alloc(bset1->ctx, 0, 2 + 3 * dim, 0, + 1 + dim + bset1->n_eq + bset2->n_eq, 2 + bset1->n_ineq + bset2->n_ineq); bset[0] = bset1; bset[1] = bset2; @@ -937,14 +946,14 @@ static struct isl_basic_set *convex_hull_pair(struct isl_basic_set *bset1, k = isl_basic_set_alloc_inequality(hull); if (k < 0) goto error; - isl_seq_clr(hull->ineq[k], 1+hull->dim); + isl_seq_clr(hull->ineq[k], 1+2+3*dim); isl_int_set_si(hull->ineq[k][(i+1)*(1+dim)], 1); } for (j = 0; j < 1+dim; ++j) { k = isl_basic_set_alloc_equality(hull); if (k < 0) goto error; - isl_seq_clr(hull->eq[k], 1+hull->dim); + isl_seq_clr(hull->eq[k], 1+2+3*dim); isl_int_set_si(hull->eq[k][j], -1); isl_int_set_si(hull->eq[k][1+dim+j], 1); isl_int_set_si(hull->eq[k][2*(1+dim)+j], 1); @@ -998,7 +1007,7 @@ static struct isl_basic_set *uset_convex_hull_wrap_with_bounds( { struct isl_basic_set *convex_hull = NULL; - isl_assert(set->ctx, bounds->n_row == set->dim, goto error); + isl_assert(set->ctx, bounds->n_row == isl_set_n_dim(set), goto error); bounds = initial_facet_constraint(set->ctx, set, bounds); if (!bounds) goto error; @@ -1024,7 +1033,7 @@ static struct isl_basic_set *uset_convex_hull(struct isl_set *set) struct isl_basic_set *convex_hull = NULL; struct isl_mat *bounds; - if (set->dim == 0) + if (isl_set_n_dim(set) == 0) return convex_hull_0d(set); set = isl_set_set_rational(set); @@ -1039,7 +1048,7 @@ static struct isl_basic_set *uset_convex_hull(struct isl_set *set) set = isl_set_remove_empty_parts(set); if (!set) return NULL; - if (set->n == 0) { + if (isl_set_n_dim(set) == 0) { convex_hull = isl_basic_set_empty(set->ctx, 0, 0); isl_set_free(set); return convex_hull; @@ -1049,13 +1058,13 @@ static struct isl_basic_set *uset_convex_hull(struct isl_set *set) isl_set_free(set); return convex_hull; } - if (set->dim == 1) + if (isl_set_n_dim(set) == 1) return convex_hull_1d(set->ctx, set); bounds = independent_bounds(set->ctx, set); if (!bounds) goto error; - if (bounds->n_row == set->dim) + if (bounds->n_row == isl_set_n_dim(set)) return uset_convex_hull_wrap_with_bounds(set, bounds); isl_mat_free(set->ctx, bounds); @@ -1076,7 +1085,7 @@ static struct isl_basic_set *uset_convex_hull_wrap(struct isl_set *set) struct isl_basic_set *convex_hull = NULL; struct isl_mat *bounds; - if (set->dim == 0) { + if (isl_set_n_dim(set) == 0) { convex_hull = isl_basic_set_universe(set->ctx, 0, 0); isl_set_free(set); convex_hull = isl_basic_set_set_rational(convex_hull); @@ -1100,7 +1109,7 @@ static struct isl_basic_set *uset_convex_hull_wrap(struct isl_set *set) isl_set_free(set); return convex_hull; } - if (set->dim == 1) + if (isl_set_n_dim(set) == 1) return convex_hull_1d(set->ctx, set); bounds = independent_bounds(set->ctx, set); @@ -1159,8 +1168,7 @@ struct isl_basic_map *isl_map_convex_hull(struct isl_map *map) ctx = map->ctx; if (map->n == 0) { - convex_hull = isl_basic_map_empty(ctx, - map->nparam, map->n_in, map->n_out); + convex_hull = isl_basic_map_empty_like_map(map); isl_map_free(map); return convex_hull; } @@ -1207,10 +1215,12 @@ struct isl_basic_map *isl_map_simple_hull(struct isl_map *map) struct isl_basic_set *bset = NULL; int i, j; unsigned n_ineq; + unsigned dim; + if (!map) + return NULL; if (map->n == 0) { - hull = isl_basic_map_empty(map->ctx, - map->nparam, map->n_in, map->n_out); + hull = isl_basic_map_empty_like_map(map); isl_map_free(map); return hull; } @@ -1234,7 +1244,8 @@ struct isl_basic_map *isl_map_simple_hull(struct isl_map *map) bset = isl_set_affine_hull(isl_set_copy(set)); if (!bset) goto error; - bset = isl_basic_set_extend(bset, 0, bset->dim, 0, 0, n_ineq); + dim = isl_basic_set_n_dim(bset); + bset = isl_basic_set_extend(bset, 0, dim, 0, 0, n_ineq); if (!bset) goto error; @@ -1246,10 +1257,9 @@ struct isl_basic_map *isl_map_simple_hull(struct isl_map *map) k = isl_basic_set_alloc_inequality(bset); if (k < 0) goto error; - isl_seq_cpy(bset->ineq[k], set->p[i]->ineq[j], - 1 + bset->dim); + isl_seq_cpy(bset->ineq[k], set->p[i]->ineq[j], 1 + dim); is_bound = uset_is_bound(set->ctx, set, bset->ineq[k], - 1 + bset->dim); + 1 + dim); if (is_bound < 0) goto error; if (!is_bound) diff --git a/isl_dim.c b/isl_dim.c new file mode 100644 index 0000000..060c005 --- /dev/null +++ b/isl_dim.c @@ -0,0 +1,123 @@ +#include "isl_dim.h" + +struct isl_dim *isl_dim_alloc(struct isl_ctx *ctx, + unsigned nparam, unsigned n_in, unsigned n_out) +{ + struct isl_dim *dim; + + dim = isl_alloc_type(ctx, struct isl_dim); + if (!dim) + return NULL; + + dim->ctx = ctx; + isl_ctx_ref(ctx); + dim->ref = 1; + dim->nparam = nparam; + dim->n_in = n_in; + dim->n_out = n_out; + + return dim; +} + +struct isl_dim *isl_dim_dup(struct isl_dim *dim) +{ + return isl_dim_alloc(dim->ctx, dim->nparam, dim->n_in, dim->n_out); +} + +struct isl_dim *isl_dim_cow(struct isl_dim *dim) +{ + if (!dim) + return NULL; + + if (dim->ref == 1) + return dim; + dim->ref--; + return isl_dim_dup(dim); +} + +struct isl_dim *isl_dim_copy(struct isl_dim *dim) +{ + if (!dim) + return NULL; + + dim->ref++; + return dim; +} + +void isl_dim_free(struct isl_dim *dim) +{ + if (!dim) + return; + + if (--dim->ref > 0) + return; + + isl_ctx_deref(dim->ctx); + + free(dim); +} + +struct isl_dim *isl_dim_join(struct isl_dim *left, struct isl_dim *right) +{ + struct isl_dim *dim; + + if (!left || !right) + goto error; + + isl_assert(left->ctx, left->nparam == right->nparam, goto error); + isl_assert(left->ctx, left->n_out == right->n_in, goto error); + + dim = isl_dim_alloc(left->ctx, left->nparam, left->n_in, right->n_out); + if (!dim) + goto error; + + isl_dim_free(left); + isl_dim_free(right); + + return dim; +error: + isl_dim_free(left); + isl_dim_free(right); + return NULL; +} + +struct isl_dim *isl_dim_reverse(struct isl_dim *dim) +{ + unsigned t; + + if (!dim) + return NULL; + if (dim->n_in == dim->n_out) + return dim; + + dim = isl_dim_cow(dim); + if (!dim) + return NULL; + + t = dim->n_in; + dim->n_in = dim->n_out; + dim->n_out = t; + + return dim; +error: + isl_dim_free(dim); + return NULL; +} + +unsigned isl_dim_total(struct isl_dim *dim) +{ + return dim->nparam + dim->n_in + dim->n_out; +} + +int isl_dim_equal(struct isl_dim *dim1, struct isl_dim *dim2) +{ + return dim1->nparam == dim2->nparam && + dim1->n_in == dim2->n_in && + dim1->n_out == dim2->n_out; +} + +int isl_dim_compatible(struct isl_dim *dim1, struct isl_dim *dim2) +{ + return dim1->nparam == dim2->nparam && + dim1->n_in + dim1->n_out == dim2->n_in + dim2->n_out; +} diff --git a/isl_equalities.c b/isl_equalities.c index 69b919e..8835fdf 100644 --- a/isl_equalities.c +++ b/isl_equalities.c @@ -47,6 +47,7 @@ static struct isl_basic_set *compress_variables(struct isl_ctx *ctx, { int i; struct isl_mat *H = NULL, *C = NULL, *H1, *U = NULL, *U1, *U2, *TC; + unsigned dim; if (T) *T = NULL; @@ -54,13 +55,14 @@ static struct isl_basic_set *compress_variables(struct isl_ctx *ctx, *T2 = NULL; if (!bset) goto error; - isl_assert(ctx, bset->nparam == 0, goto error); + isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error); isl_assert(ctx, bset->n_div == 0, goto error); - isl_assert(ctx, bset->n_eq <= bset->dim, goto error); + dim = isl_basic_set_n_dim(bset); + isl_assert(ctx, bset->n_eq <= dim, goto error); if (bset->n_eq == 0) return bset; - H = isl_mat_sub_alloc(ctx, bset->eq, 0, bset->n_eq, 1, bset->dim); + H = isl_mat_sub_alloc(ctx, bset->eq, 0, bset->n_eq, 1, dim); H = isl_mat_left_hermite(ctx, H, 0, &U, T2); if (!H || !U || (T2 && !*T2)) goto error; @@ -130,7 +132,7 @@ struct isl_basic_set *isl_basic_set_remove_equalities( *T2 = NULL; if (!bset) return NULL; - isl_assert(bset->ctx, bset->nparam == 0, goto error); + isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error); bset = isl_basic_set_gauss(bset, NULL); if (F_ISSET(bset, ISL_BASIC_SET_EMPTY)) return bset; @@ -152,18 +154,20 @@ int isl_basic_set_dim_residue_class(struct isl_basic_set *bset, struct isl_ctx *ctx; struct isl_mat *H = NULL, *U = NULL, *C, *H1, *U1; unsigned total; + unsigned nparam; if (!bset || !modulo || !residue) return -1; ctx = bset->ctx; - total = bset->nparam + bset->dim + bset->n_div; + total = isl_basic_set_total_dim(bset); + nparam = isl_basic_set_n_param(bset); H = isl_mat_sub_alloc(ctx, bset->eq, 0, bset->n_eq, 1, total); H = isl_mat_left_hermite(ctx, H, 0, &U, NULL); if (!H) return -1; - isl_seq_gcd(U->row[bset->nparam + pos]+bset->n_eq, + isl_seq_gcd(U->row[nparam + pos]+bset->n_eq, total-bset->n_eq, modulo); if (isl_int_is_zero(*modulo) || isl_int_is_one(*modulo)) { isl_int_set_si(*residue, 0); @@ -181,7 +185,7 @@ int isl_basic_set_dim_residue_class(struct isl_basic_set *bset, H1 = isl_mat_lin_to_aff(ctx, H1); C = isl_mat_inverse_product(ctx, H1, C); isl_mat_free(ctx, H); - U1 = isl_mat_sub_alloc(ctx, U->row, bset->nparam+pos, 1, 0, bset->n_eq); + U1 = isl_mat_sub_alloc(ctx, U->row, nparam+pos, 1, 0, bset->n_eq); U1 = isl_mat_lin_to_aff(ctx, U1); isl_mat_free(ctx, U); C = isl_mat_product(ctx, U1, C); diff --git a/isl_input.c b/isl_input.c index 1606dcd..81d54d0 100644 --- a/isl_input.c +++ b/isl_input.c @@ -1,6 +1,7 @@ #include #include #include +#include "isl_dim.h" #include "isl_map_private.h" #include "isl_input_omega.h" @@ -104,9 +105,11 @@ static struct isl_set *isl_set_read_from_file_polylib( goto error; } set->n = n; - set->dim = set->p[0]->dim; + isl_dim_free(set->dim); + set->dim = isl_dim_copy(set->p[0]->dim); for (i = 1; i < n; ++i) - isl_assert(ctx, set->dim == set->p[i]->dim, goto error); + isl_assert(ctx, isl_dim_equal(set->dim, set->p[i]->dim), + goto error); return set; error: isl_set_free(set); diff --git a/isl_input_omega.c b/isl_input_omega.c index 3492478..34e3385 100644 --- a/isl_input_omega.c +++ b/isl_input_omega.c @@ -497,9 +497,10 @@ static struct isl_basic_map *add_exists(struct stream *s, if (!*v) goto error; extra = (*v)->n - n; - bmap = isl_basic_map_extend(bmap, bmap->nparam, - bmap->n_in, bmap->n_out, extra, 0, 0); - total = bmap->nparam+bmap->n_in+bmap->n_out+bmap->extra; + bmap = isl_basic_map_extend(bmap, isl_basic_map_n_param(bmap), + isl_basic_map_n_in(bmap), isl_basic_map_n_out(bmap), + extra, 0, 0); + total = isl_basic_map_total_dim(bmap); for (i = 0; i < extra; ++i) { int k; if ((k = isl_basic_map_alloc_div(bmap)) < 0) @@ -522,7 +523,7 @@ error: static struct isl_basic_map *add_constraint(struct stream *s, struct vars **v, struct isl_basic_map *bmap) { - unsigned total = bmap->nparam+bmap->n_in+bmap->n_out+bmap->extra; + unsigned total = isl_basic_map_total_dim(bmap); int k; int sign = 1; int equality = 0; @@ -538,8 +539,7 @@ static struct isl_basic_map *add_constraint(struct stream *s, } stream_push_token(s, tok); - bmap = isl_basic_map_extend(bmap, bmap->nparam, - bmap->n_in, bmap->n_out, 0, 0, 1); + bmap = isl_basic_map_extend_constraints(bmap, 0, 1); k = isl_basic_map_alloc_inequality(bmap); if (k < 0) goto error; @@ -731,7 +731,7 @@ struct isl_basic_set *isl_basic_set_read_from_file_omega( bmap = isl_basic_map_read_from_file_omega(ctx, input); if (!bmap) return NULL; - isl_assert(ctx, bmap->n_in == 0, goto error); + isl_assert(ctx, isl_basic_map_n_in(bmap) == 0, goto error); return (struct isl_basic_set *)bmap; error: isl_basic_map_free(bmap); diff --git a/isl_lp_piplib.c b/isl_lp_piplib.c index 8289e79..609093a 100644 --- a/isl_lp_piplib.c +++ b/isl_lp_piplib.c @@ -13,7 +13,7 @@ enum isl_lp_result isl_pip_solve_lp(struct isl_basic_map *bmap, int maximize, PipQuast *sol; unsigned total; - total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + total = isl_basic_map_total_dim(bmap); domain = isl_basic_map_to_pip(bmap, 0, 1, 0); if (!domain) goto error; diff --git a/isl_map.c b/isl_map.c index 5abfe3b..dfcbf50 100644 --- a/isl_map.c +++ b/isl_map.c @@ -2,6 +2,7 @@ #include #include "isl_ctx.h" #include "isl_blk.h" +#include "isl_dim.h" #include "isl_equalities.h" #include "isl_list.h" #include "isl_lp.h" @@ -13,13 +14,97 @@ #include "isl_sample.h" #include "isl_vec.h" +unsigned isl_basic_set_n_dim(const struct isl_basic_set *bset) +{ + return bset->dim->n_out; +} + +unsigned isl_basic_set_n_param(const struct isl_basic_set *bset) +{ + return bset->dim->nparam; +} + +unsigned isl_basic_set_total_dim(const struct isl_basic_set *bset) +{ + return isl_dim_total(bset->dim) + bset->n_div; +} + +unsigned isl_set_n_dim(const struct isl_set *set) +{ + return set->dim->n_out; +} + +unsigned isl_set_n_param(const struct isl_set *set) +{ + return set->dim->nparam; +} + +unsigned isl_basic_map_n_in(const struct isl_basic_map *bmap) +{ + return bmap->dim->n_in; +} + +unsigned isl_basic_map_n_out(const struct isl_basic_map *bmap) +{ + return bmap->dim->n_out; +} + +unsigned isl_basic_map_n_param(const struct isl_basic_map *bmap) +{ + return bmap->dim->nparam; +} + +unsigned isl_basic_map_n_div(const struct isl_basic_map *bmap) +{ + return bmap->n_div; +} + +unsigned isl_basic_map_total_dim(const struct isl_basic_map *bmap) +{ + return isl_dim_total(bmap->dim) + bmap->n_div; +} + +unsigned isl_map_n_in(const struct isl_map *map) +{ + return map->dim->n_in; +} + +unsigned isl_map_n_out(const struct isl_map *map) +{ + return map->dim->n_out; +} + +unsigned isl_map_n_param(const struct isl_map *map) +{ + return map->dim->nparam; +} + +int isl_map_compatible_domain(struct isl_map *map, struct isl_set *set) +{ + return map->dim->n_in == set->dim->n_out && + map->dim->nparam == set->dim->nparam; +} + +int isl_basic_map_compatible_domain(struct isl_basic_map *bmap, + struct isl_basic_set *bset) +{ + return bmap->dim->n_in == bset->dim->n_out && + bmap->dim->nparam == bset->dim->nparam; +} + +int isl_basic_map_compatible_range(struct isl_basic_map *bmap, + struct isl_basic_set *bset) +{ + return bmap->dim->n_out == bset->dim->n_out && + bmap->dim->nparam == bset->dim->nparam; +} + static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx, - struct isl_basic_map *bmap, - unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra, + struct isl_basic_map *bmap, unsigned extra, unsigned n_eq, unsigned n_ineq) { int i; - size_t row_size = 1 + nparam + n_in + n_out + extra; + size_t row_size = 1 + isl_dim_total(bmap->dim) + extra; bmap->block = isl_blk_alloc(ctx, (n_eq + n_ineq) * row_size); if (isl_blk_is_error(bmap->block)) { @@ -68,9 +153,6 @@ static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx, bmap->flags = 0; bmap->c_size = n_eq + n_ineq; bmap->ineq = bmap->eq + n_eq; - bmap->nparam = nparam; - bmap->n_in = n_in; - bmap->n_out = n_out; bmap->extra = extra; bmap->n_eq = 0; bmap->n_ineq = 0; @@ -78,6 +160,9 @@ static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx, bmap->sample = NULL; return bmap; +error: + isl_basic_map_free(bmap); + return NULL; } struct isl_basic_set *isl_basic_set_alloc(struct isl_ctx *ctx, @@ -89,25 +174,57 @@ struct isl_basic_set *isl_basic_set_alloc(struct isl_ctx *ctx, return (struct isl_basic_set *)bmap; } -struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx, - unsigned nparam, unsigned in, unsigned out, unsigned extra, +struct isl_basic_set *isl_basic_set_alloc_dim(struct isl_ctx *ctx, + struct isl_dim *dim, unsigned extra, unsigned n_eq, unsigned n_ineq) { struct isl_basic_map *bmap; + if (!dim) + return NULL; + isl_assert(ctx, dim->n_in == 0, return NULL); + bmap = isl_basic_map_alloc_dim(ctx, dim, extra, n_eq, n_ineq); + return (struct isl_basic_set *)bmap; +} +struct isl_basic_map *isl_basic_map_alloc_dim(struct isl_ctx *ctx, + struct isl_dim *dim, unsigned extra, + unsigned n_eq, unsigned n_ineq) +{ + struct isl_basic_map *bmap; + + if (!dim) + return NULL; bmap = isl_alloc_type(ctx, struct isl_basic_map); if (!bmap) + goto error; + bmap->dim = dim; + + return basic_map_init(ctx, bmap, extra, n_eq, n_ineq); +error: + isl_dim_free(dim); + return NULL; +} + +struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx, + unsigned nparam, unsigned in, unsigned out, unsigned extra, + unsigned n_eq, unsigned n_ineq) +{ + struct isl_basic_map *bmap; + struct isl_dim *dim; + + dim = isl_dim_alloc(ctx, nparam, in, out); + if (!dim) return NULL; - return basic_map_init(ctx, bmap, - nparam, in, out, extra, n_eq, n_ineq); + bmap = isl_basic_map_alloc_dim(ctx, dim, extra, n_eq, n_ineq); + return bmap; } static void dup_constraints( struct isl_basic_map *dst, struct isl_basic_map *src) { int i; - unsigned total = src->nparam + src->n_in + src->n_out + src->n_div; + unsigned total = isl_basic_map_total_dim(src); for (i = 0; i < src->n_eq; ++i) { int j = isl_basic_map_alloc_equality(dst); @@ -132,8 +249,7 @@ struct isl_basic_map *isl_basic_map_dup(struct isl_basic_map *bmap) if (!bmap) return NULL; - dup = isl_basic_map_alloc(bmap->ctx, bmap->nparam, - bmap->n_in, bmap->n_out, + dup = isl_basic_map_alloc_dim(bmap->ctx, isl_dim_copy(bmap->dim), bmap->n_div, bmap->n_eq, bmap->n_ineq); if (!dup) return NULL; @@ -207,6 +323,7 @@ void isl_basic_map_free(struct isl_basic_map *bmap) free(bmap->eq); isl_blk_free(bmap->ctx, bmap->block); isl_vec_free(bmap->ctx, bmap->sample); + isl_dim_free(bmap->dim); free(bmap); } @@ -235,7 +352,7 @@ int isl_basic_map_alloc_equality(struct isl_basic_map *bmap) bmap->ineq++; } else isl_seq_clr(bmap->eq[bmap->n_eq] + - 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div, + 1 + isl_basic_map_total_dim(bmap), bmap->extra - bmap->n_div); return bmap->n_eq++; } @@ -302,7 +419,7 @@ int isl_basic_map_alloc_inequality(struct isl_basic_map *bmap) F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT); F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED); isl_seq_clr(bmap->ineq[bmap->n_ineq] + - 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div, + 1 + isl_basic_map_total_dim(bmap), bmap->extra - bmap->n_div); return bmap->n_ineq++; } @@ -354,7 +471,7 @@ int isl_basic_map_alloc_div(struct isl_basic_map *bmap) return -1; isl_assert(bmap->ctx, bmap->n_div < bmap->extra, return -1); isl_seq_clr(bmap->div[bmap->n_div] + - 1 + 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div, + 1 + 1 + isl_basic_map_total_dim(bmap), bmap->extra - bmap->n_div); return bmap->n_div++; } @@ -377,31 +494,37 @@ static void copy_constraint(struct isl_basic_map *dst_map, isl_int *dst, struct isl_basic_map *src_map, isl_int *src, unsigned in_off, unsigned out_off, unsigned div_off) { + unsigned src_nparam = isl_basic_map_n_param(src_map); + unsigned dst_nparam = isl_basic_map_n_param(dst_map); + unsigned src_in = isl_basic_map_n_in(src_map); + unsigned dst_in = isl_basic_map_n_in(dst_map); + unsigned src_out = isl_basic_map_n_out(src_map); + unsigned dst_out = isl_basic_map_n_out(dst_map); isl_int_set(dst[0], src[0]); - isl_seq_cpy(dst+1, src+1, isl_min(dst_map->nparam, src_map->nparam)); - if (dst_map->nparam > src_map->nparam) - isl_seq_clr(dst+1+src_map->nparam, - dst_map->nparam - src_map->nparam); - isl_seq_clr(dst+1+dst_map->nparam, in_off); - isl_seq_cpy(dst+1+dst_map->nparam+in_off, - src+1+src_map->nparam, - isl_min(dst_map->n_in-in_off, src_map->n_in)); - if (dst_map->n_in-in_off > src_map->n_in) - isl_seq_clr(dst+1+dst_map->nparam+in_off+src_map->n_in, - dst_map->n_in - in_off - src_map->n_in); - isl_seq_clr(dst+1+dst_map->nparam+dst_map->n_in, out_off); - isl_seq_cpy(dst+1+dst_map->nparam+dst_map->n_in+out_off, - src+1+src_map->nparam+src_map->n_in, - isl_min(dst_map->n_out-out_off, src_map->n_out)); - if (dst_map->n_out-out_off > src_map->n_out) - isl_seq_clr(dst+1+dst_map->nparam+dst_map->n_in+out_off+src_map->n_out, - dst_map->n_out - out_off - src_map->n_out); - isl_seq_clr(dst+1+dst_map->nparam+dst_map->n_in+dst_map->n_out, div_off); - isl_seq_cpy(dst+1+dst_map->nparam+dst_map->n_in+dst_map->n_out+div_off, - src+1+src_map->nparam+src_map->n_in+src_map->n_out, + isl_seq_cpy(dst+1, src+1, isl_min(dst_nparam, src_nparam)); + if (dst_nparam > src_nparam) + isl_seq_clr(dst+1+src_nparam, + dst_nparam - src_nparam); + isl_seq_clr(dst+1+dst_nparam, in_off); + isl_seq_cpy(dst+1+dst_nparam+in_off, + src+1+src_nparam, + isl_min(dst_in-in_off, src_in)); + if (dst_in-in_off > src_in) + isl_seq_clr(dst+1+dst_nparam+in_off+src_in, + dst_in - in_off - src_in); + isl_seq_clr(dst+1+dst_nparam+dst_in, out_off); + isl_seq_cpy(dst+1+dst_nparam+dst_in+out_off, + src+1+src_nparam+src_in, + isl_min(dst_out-out_off, src_out)); + if (dst_out-out_off > src_out) + isl_seq_clr(dst+1+dst_nparam+dst_in+out_off+src_out, + dst_out - out_off - src_out); + isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out, div_off); + isl_seq_cpy(dst+1+dst_nparam+dst_in+dst_out+div_off, + src+1+src_nparam+src_in+src_out, isl_min(dst_map->extra-div_off, src_map->n_div)); if (dst_map->n_div-div_off > src_map->n_div) - isl_seq_clr(dst+1+dst_map->nparam+dst_map->n_in+dst_map->n_out+ + isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out+ div_off+src_map->n_div, dst_map->n_div - div_off - src_map->n_div); } @@ -467,36 +590,38 @@ static struct isl_basic_set *set_add_constraints(struct isl_basic_set *bset1, (struct isl_basic_map *)bset2, 0, pos); } -struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base, - unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra, +struct isl_basic_map *isl_basic_map_extend_dim(struct isl_basic_map *base, + struct isl_dim *dim, unsigned extra, unsigned n_eq, unsigned n_ineq) { struct isl_basic_map *ext; unsigned flags; int dims_ok; + if (!dim) + goto error; + base = isl_basic_map_cow(base); if (!base) goto error; - dims_ok = base && base->nparam == nparam && - base->n_in == n_in && base->n_out == n_out && + dims_ok = isl_dim_equal(base->dim, dim) && base->extra >= base->n_div + extra; - if (dims_ok && n_eq == 0 && n_ineq == 0) + if (dims_ok && n_eq == 0 && n_ineq == 0) { + isl_dim_free(dim); return base; + } - isl_assert(base->ctx, base->nparam <= nparam, goto error); - isl_assert(base->ctx, base->n_in <= n_in, goto error); - isl_assert(base->ctx, base->n_out <= n_out, goto error); + isl_assert(base->ctx, base->dim->nparam <= dim->nparam, goto error); + isl_assert(base->ctx, base->dim->n_in <= dim->n_in, goto error); + isl_assert(base->ctx, base->dim->n_out <= dim->n_out, goto error); extra += base->extra; n_eq += base->n_eq; n_ineq += base->n_ineq; - ext = isl_basic_map_alloc(base->ctx, nparam, n_in, n_out, - extra, n_eq, n_ineq); - if (!base) - return ext; + ext = isl_basic_map_alloc_dim(base->ctx, dim, extra, n_eq, n_ineq); + dim = NULL; if (!ext) goto error; @@ -510,10 +635,37 @@ struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base, return ext; error: + isl_dim_free(dim); isl_basic_map_free(base); return NULL; } +struct isl_basic_map *isl_basic_map_extend_constraints( + struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq) +{ + if (!base) + return NULL; + return isl_basic_map_extend_dim(base, isl_dim_copy(base->dim), + 0, n_eq, n_ineq); +} + +struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base, + unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra, + unsigned n_eq, unsigned n_ineq) +{ + struct isl_basic_map *bmap; + struct isl_dim *dim; + + if (!base) + return NULL; + dim = isl_dim_alloc(base->ctx, nparam, n_in, n_out); + if (!dim) + return NULL; + + bmap = isl_basic_map_extend_dim(base, dim, extra, n_eq, n_ineq); + return bmap; +} + struct isl_basic_set *isl_basic_set_extend(struct isl_basic_set *base, unsigned nparam, unsigned dim, unsigned extra, unsigned n_eq, unsigned n_ineq) @@ -523,6 +675,14 @@ struct isl_basic_set *isl_basic_set_extend(struct isl_basic_set *base, nparam, 0, dim, extra, n_eq, n_ineq); } +struct isl_basic_set *isl_basic_set_extend_constraints( + struct isl_basic_set *base, unsigned n_eq, unsigned n_ineq) +{ + return (struct isl_basic_set *) + isl_basic_map_extend_constraints((struct isl_basic_map *)base, + n_eq, n_ineq); +} + struct isl_basic_set *isl_basic_set_cow(struct isl_basic_set *bset) { return (struct isl_basic_set *) @@ -577,34 +737,38 @@ struct isl_basic_set *isl_basic_set_swap_vars( { int i; struct isl_blk blk; + unsigned dim; + unsigned nparam; if (!bset) goto error; - isl_assert(bset->ctx, n <= bset->dim, goto error); + nparam = isl_basic_set_n_param(bset); + dim = isl_basic_set_n_dim(bset); + isl_assert(bset->ctx, n <= dim, goto error); - if (n == bset->dim) + if (n == dim) return bset; bset = isl_basic_set_cow(bset); if (!bset) return NULL; - blk = isl_blk_alloc(bset->ctx, bset->dim); + blk = isl_blk_alloc(bset->ctx, dim); if (isl_blk_is_error(blk)) goto error; for (i = 0; i < bset->n_eq; ++i) swap_vars(blk, - bset->eq[i]+1+bset->nparam, n, bset->dim - n); + bset->eq[i]+1+nparam, n, dim - n); for (i = 0; i < bset->n_ineq; ++i) swap_vars(blk, - bset->ineq[i]+1+bset->nparam, n, bset->dim - n); + bset->ineq[i]+1+nparam, n, dim - n); for (i = 0; i < bset->n_div; ++i) swap_vars(blk, - bset->div[i]+1+1+bset->nparam, n, bset->dim - n); + bset->div[i]+1+1+nparam, n, dim - n); isl_blk_free(bset->ctx, blk); @@ -648,7 +812,7 @@ struct isl_basic_set *isl_basic_set_drop_dims( if (!bset) goto error; - isl_assert(bset->ctx, first + n <= bset->dim, goto error); + isl_assert(bset->ctx, first + n <= bset->dim->n_out, goto error); if (n == 0) return bset; @@ -656,20 +820,23 @@ struct isl_basic_set *isl_basic_set_drop_dims( bset = isl_basic_set_cow(bset); if (!bset) return NULL; + bset->dim = isl_dim_cow(bset->dim); + if (!bset->dim) + goto error; for (i = 0; i < bset->n_eq; ++i) - constraint_drop_vars(bset->eq[i]+1+bset->nparam+first, n, - (bset->dim-first-n)+bset->extra); + constraint_drop_vars(bset->eq[i]+1+bset->dim->nparam+first, n, + (bset->dim->n_out-first-n)+bset->extra); for (i = 0; i < bset->n_ineq; ++i) - constraint_drop_vars(bset->ineq[i]+1+bset->nparam+first, n, - (bset->dim-first-n)+bset->extra); + constraint_drop_vars(bset->ineq[i]+1+bset->dim->nparam+first, n, + (bset->dim->n_out-first-n)+bset->extra); for (i = 0; i < bset->n_div; ++i) - constraint_drop_vars(bset->div[i]+1+1+bset->nparam+first, n, - (bset->dim-first-n)+bset->extra); + constraint_drop_vars(bset->div[i]+1+1+bset->dim->nparam+first, n, + (bset->dim->n_out-first-n)+bset->extra); - bset->dim -= n; + bset->dim->n_out -= n; bset->extra += n; F_CLR(bset, ISL_BASIC_SET_NORMALIZED); @@ -688,20 +855,23 @@ static struct isl_set *isl_set_drop_dims( if (!set) goto error; - isl_assert(set->ctx, first + n <= set->dim, goto error); + isl_assert(set->ctx, first + n <= set->dim->n_out, goto error); if (n == 0) return set; set = isl_set_cow(set); if (!set) goto error; + set->dim = isl_dim_cow(set->dim); + if (!set->dim) + goto error; for (i = 0; i < set->n; ++i) { set->p[i] = isl_basic_set_drop_dims(set->p[i], first, n); if (!set->p[i]) goto error; } - set->dim -= n; + set->dim->n_out -= n; F_CLR(set, ISL_SET_NORMALIZED); return set; @@ -714,11 +884,17 @@ struct isl_basic_map *isl_basic_map_drop_inputs( struct isl_basic_map *bmap, unsigned first, unsigned n) { int i; + unsigned nparam; + unsigned n_in; + unsigned n_out; if (!bmap) goto error; - isl_assert(bmap->ctx, first + n <= bmap->n_in, goto error); + nparam = isl_basic_map_n_param(bmap); + n_in = isl_basic_map_n_in(bmap); + n_out = isl_basic_map_n_out(bmap); + isl_assert(bmap->ctx, first + n <= n_in, goto error); if (n == 0) return bmap; @@ -726,20 +902,23 @@ struct isl_basic_map *isl_basic_map_drop_inputs( bmap = isl_basic_map_cow(bmap); if (!bmap) return NULL; + bmap->dim = isl_dim_cow(bmap->dim); + if (!bmap->dim) + goto error; for (i = 0; i < bmap->n_eq; ++i) - constraint_drop_vars(bmap->eq[i]+1+bmap->nparam+first, n, - (bmap->n_in-first-n)+bmap->n_out+bmap->extra); + constraint_drop_vars(bmap->eq[i]+1+nparam+first, n, + (n_in-first-n)+n_out+bmap->extra); for (i = 0; i < bmap->n_ineq; ++i) - constraint_drop_vars(bmap->ineq[i]+1+bmap->nparam+first, n, - (bmap->n_in-first-n)+bmap->n_out+bmap->extra); + constraint_drop_vars(bmap->ineq[i]+1+nparam+first, n, + (n_in-first-n)+n_out+bmap->extra); for (i = 0; i < bmap->n_div; ++i) - constraint_drop_vars(bmap->div[i]+1+1+bmap->nparam+first, n, - (bmap->n_in-first-n)+bmap->n_out+bmap->extra); + constraint_drop_vars(bmap->div[i]+1+1+nparam+first, n, + (n_in-first-n)+n_out+bmap->extra); - bmap->n_in -= n; + bmap->dim->n_in -= n; bmap->extra += n; F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED); @@ -758,20 +937,23 @@ static struct isl_map *isl_map_drop_inputs( if (!map) goto error; - isl_assert(map->ctx, first + n <= map->n_in, goto error); + isl_assert(map->ctx, first + n <= map->dim->n_in, goto error); if (n == 0) return map; map = isl_map_cow(map); if (!map) goto error; + map->dim = isl_dim_cow(map->dim); + if (!map->dim) + goto error; for (i = 0; i < map->n; ++i) { map->p[i] = isl_basic_map_drop_inputs(map->p[i], first, n); if (!map->p[i]) goto error; } - map->n_in -= n; + map->dim->n_in -= n; F_CLR(map, ISL_MAP_NORMALIZED); return map; @@ -792,7 +974,7 @@ static struct isl_basic_map *isl_basic_map_drop_div( if (!bmap) goto error; - pos = 1 + bmap->nparam + bmap->n_in + bmap->n_out + div; + pos = 1 + isl_dim_total(bmap->dim) + div; isl_assert(bmap->ctx, div < bmap->n_div, goto error); @@ -832,9 +1014,9 @@ error: static void eliminate_div(struct isl_basic_map *bmap, isl_int *eq, unsigned div) { int i; - unsigned pos = 1 + bmap->nparam + bmap->n_in + bmap->n_out + div; + unsigned pos = 1 + isl_dim_total(bmap->dim) + div; unsigned len; - len = 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + len = 1 + isl_basic_map_total_dim(bmap); for (i = 0; i < bmap->n_eq; ++i) if (bmap->eq[i] != eq) @@ -861,7 +1043,7 @@ struct isl_basic_map *isl_basic_map_set_to_empty(struct isl_basic_map *bmap) unsigned total; if (!bmap) goto error; - total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + total = isl_basic_map_total_dim(bmap); isl_basic_map_free_div(bmap, bmap->n_div); isl_basic_map_free_inequality(bmap, bmap->n_ineq); if (bmap->n_eq > 0) @@ -910,7 +1092,7 @@ static void set_swap_inequality(struct isl_basic_set *bset, int a, int b) static void swap_div(struct isl_basic_map *bmap, int a, int b) { int i; - unsigned off = bmap->nparam + bmap->n_in + bmap->n_out; + unsigned off = isl_dim_total(bmap->dim); isl_int *t = bmap->div[a]; bmap->div[a] = bmap->div[b]; bmap->div[b] = t; @@ -932,7 +1114,7 @@ static void eliminate_var_using_equality(struct isl_basic_map *bmap, unsigned total; int k; - total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + total = isl_basic_map_total_dim(bmap); for (k = 0; k < bmap->n_eq; ++k) { if (bmap->eq[k] == eq) continue; @@ -978,8 +1160,8 @@ struct isl_basic_map *isl_basic_map_gauss( if (!bmap) return NULL; - total_var = bmap->nparam + bmap->n_in + bmap->n_out; - total = total_var + bmap->n_div; + total = isl_basic_map_total_dim(bmap); + total_var = total - bmap->n_div; last_var = total - 1; for (done = 0; done < bmap->n_eq; ++done) { @@ -1043,7 +1225,7 @@ static int hash_index(isl_int ***index, unsigned int size, int bits, struct isl_basic_map *bmap, int k) { int h; - unsigned total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + unsigned total = isl_basic_map_total_dim(bmap); uint32_t hash = isl_seq_get_hash_bits(bmap->ineq[k]+1, total, bits); for (h = hash; index[h]; h = (h+1) % size) if (&bmap->ineq[k] != index[h] && @@ -1065,7 +1247,7 @@ static struct isl_basic_map *remove_duplicate_constraints( isl_int ***index; int k, l, h; int bits; - unsigned total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + unsigned total = isl_basic_map_total_dim(bmap); isl_int sum; if (bmap->n_ineq <= 1) @@ -1126,7 +1308,7 @@ static void compute_elimination_index(struct isl_basic_map *bmap, int *elim) int d, i; unsigned total; - total = bmap->nparam + bmap->n_in + bmap->n_out; + total = isl_dim_total(bmap->dim); for (d = 0; d < total; ++d) elim[d] = -1; for (d = total - 1, i = 0; d >= 0 && i < bmap->n_eq; ++i) { @@ -1151,7 +1333,7 @@ static int reduced_using_equalities(isl_int *dst, isl_int *src, int copied = 0; unsigned total; - total = bmap->nparam + bmap->n_in + bmap->n_out; + total = isl_dim_total(bmap->dim); for (d = total - 1; d >= 0; --d) { if (isl_int_is_zero(src[1+d])) continue; @@ -1188,15 +1370,14 @@ int isl_basic_map_fast_is_disjoint(struct isl_basic_map *bmap1, if (!bmap1 || !bmap2) return -1; - isl_assert(bmap1->ctx, bmap1->nparam == bmap2->nparam, return -1); - isl_assert(bmap1->ctx, bmap1->n_in == bmap2->n_in, return -1); - isl_assert(bmap1->ctx, bmap1->n_out == bmap2->n_out, return -1); + isl_assert(bmap1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), + return -1); if (bmap1->n_div || bmap2->n_div) return 0; if (!bmap1->n_eq && !bmap2->n_eq) return 0; - total = bmap1->nparam + bmap1->n_in + bmap1->n_out; + total = isl_dim_total(bmap1->dim); if (total == 0) return 0; v = isl_vec_alloc(bmap1->ctx, 1 + total); @@ -1286,7 +1467,7 @@ static struct isl_basic_map *remove_duplicate_divs( int k, l, h; int bits; struct isl_blk eq; - unsigned total_var = bmap->nparam + bmap->n_in + bmap->n_out; + unsigned total_var = isl_dim_total(bmap->dim); unsigned total = total_var + bmap->n_div; struct isl_ctx *ctx; @@ -1353,7 +1534,7 @@ static struct isl_basic_map *eliminate_divs_eq( if (!bmap) return NULL; - off = 1 + bmap->nparam + bmap->n_in + bmap->n_out; + off = 1 + isl_dim_total(bmap->dim); for (d = bmap->n_div - 1; d >= 0 ; --d) { for (i = 0; i < bmap->n_eq; ++i) { @@ -1376,7 +1557,7 @@ static struct isl_basic_map *normalize_constraints(struct isl_basic_map *bmap) { int i; isl_int gcd; - unsigned total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + unsigned total = isl_basic_map_total_dim(bmap); isl_int_init(gcd); for (i = bmap->n_eq - 1; i >= 0; --i) { @@ -1437,7 +1618,7 @@ struct isl_basic_map *isl_basic_map_eliminate_vars( return bmap; if (!bmap) return NULL; - total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + total = isl_basic_map_total_dim(bmap); bmap = isl_basic_map_cow(bmap); for (d = pos + n - 1; d >= pos; --d) { @@ -1461,8 +1642,7 @@ struct isl_basic_map *isl_basic_map_eliminate_vars( else if (isl_int_is_neg(bmap->ineq[i][1+d])) n_upper++; } - bmap = isl_basic_map_extend(bmap, - bmap->nparam, bmap->n_in, bmap->n_out, 0, + bmap = isl_basic_map_extend_constraints(bmap, 0, n_lower * n_upper); for (i = bmap->n_ineq - 1; i >= 0; --i) { int last; @@ -1520,6 +1700,7 @@ struct isl_set *isl_set_eliminate_dims(struct isl_set *set, unsigned first, unsigned n) { int i; + unsigned nparam; if (!set) return NULL; @@ -1529,11 +1710,12 @@ struct isl_set *isl_set_eliminate_dims(struct isl_set *set, set = isl_set_cow(set); if (!set) return NULL; - isl_assert(set->ctx, first+n <= set->dim, goto error); + isl_assert(set->ctx, first+n <= isl_set_n_dim(set), goto error); + nparam = isl_set_n_param(set); for (i = 0; i < set->n; ++i) { set->p[i] = isl_basic_set_eliminate_vars(set->p[i], - set->nparam + first, n); + nparam + first, n); if (!set->p[i]) goto error; } @@ -1554,7 +1736,7 @@ struct isl_set *isl_set_remove_dims(struct isl_set *set, struct isl_basic_set *isl_basic_set_remove_divs(struct isl_basic_set *bset) { - bset = isl_basic_set_eliminate_vars(bset, bset->nparam + bset->dim, + bset = isl_basic_set_eliminate_vars(bset, isl_dim_total(bset->dim), bset->n_div); if (!bset) return NULL; @@ -1591,6 +1773,7 @@ struct isl_map *isl_map_remove_inputs(struct isl_map *map, unsigned first, unsigned n) { int i; + unsigned nparam; if (n == 0) return map; @@ -1598,11 +1781,12 @@ struct isl_map *isl_map_remove_inputs(struct isl_map *map, map = isl_map_cow(map); if (!map) return NULL; - isl_assert(map->ctx, first+n <= map->n_in, goto error); + nparam = isl_map_n_param(map); + isl_assert(map->ctx, first+n <= isl_map_n_in(map), goto error); for (i = 0; i < map->n; ++i) { map->p[i] = isl_basic_map_eliminate_vars(map->p[i], - map->nparam + first, n); + nparam + first, n); if (!map->p[i]) goto error; } @@ -1617,7 +1801,8 @@ error: struct isl_basic_set *isl_basic_set_remove_dims(struct isl_basic_set *bset, unsigned first, unsigned n) { - bset = isl_basic_set_eliminate_vars(bset, bset->nparam + first, n); + unsigned nparam = isl_basic_set_n_param(bset); + bset = isl_basic_set_eliminate_vars(bset, nparam + first, n); bset = isl_basic_set_drop_dims(bset, first, n); return bset; } @@ -1636,7 +1821,7 @@ static struct isl_basic_map *eliminate_divs_ineq( return NULL; ctx = bmap->ctx; - off = 1 + bmap->nparam + bmap->n_in + bmap->n_out; + off = 1 + isl_dim_total(bmap->dim); for (d = bmap->n_div - 1; d >= 0 ; --d) { for (i = 0; i < bmap->n_eq; ++i) @@ -1686,21 +1871,22 @@ struct isl_basic_set *isl_basic_set_simplify(struct isl_basic_set *bset) static void dump_term(struct isl_basic_map *bmap, isl_int c, int pos, FILE *out) { - unsigned in = bmap->n_in; - unsigned dim = bmap->n_in + bmap->n_out; + unsigned in = isl_basic_map_n_in(bmap); + unsigned dim = in + isl_basic_map_n_out(bmap); + unsigned nparam = isl_basic_map_n_param(bmap); if (!pos) isl_int_print(out, c, 0); else { if (!isl_int_is_one(c)) isl_int_print(out, c, 0); - if (pos < 1 + bmap->nparam) + if (pos < 1 + nparam) fprintf(out, "p%d", pos - 1); - else if (pos < 1 + bmap->nparam + in) - fprintf(out, "i%d", pos - 1 - bmap->nparam); - else if (pos < 1 + bmap->nparam + dim) - fprintf(out, "o%d", pos - 1 - bmap->nparam - in); + else if (pos < 1 + nparam + in) + fprintf(out, "i%d", pos - 1 - nparam); + else if (pos < 1 + nparam + dim) + fprintf(out, "o%d", pos - 1 - nparam - in); else - fprintf(out, "e%d", pos - 1 - bmap->nparam - dim); + fprintf(out, "e%d", pos - 1 - nparam - dim); } } @@ -1709,7 +1895,7 @@ static void dump_constraint_sign(struct isl_basic_map *bmap, isl_int *c, { int i; int first; - unsigned len = 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + unsigned len = 1 + isl_basic_map_total_dim(bmap); isl_int v; isl_int_init(v); @@ -1741,10 +1927,11 @@ 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+bmap->nparam+bmap->n_in+bmap->n_out+i])) + if (isl_int_is_zero(c[1+isl_dim_total(bmap->dim)+i])) continue; fprintf(out, "%*s", indent, ""); fprintf(out, "ERROR: unused div coefficient not zero\n"); + abort(); } } @@ -1762,7 +1949,7 @@ static void dump_affine(struct isl_basic_map *bmap, isl_int *exp, FILE *out) { int j; int first = 1; - unsigned total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + unsigned total = isl_basic_map_total_dim(bmap); for (j = 0; j < 1 + total; ++j) { if (isl_int_is_zero(exp[j])) @@ -1800,8 +1987,8 @@ void isl_basic_set_dump(struct isl_basic_set *bset, FILE *out, int indent) fprintf(out, "%*s", indent, ""); fprintf(out, "ref: %d, nparam: %d, dim: %d, extra: %d, flags: %x\n", - bset->ref, bset->nparam, bset->dim, bset->extra, - bset->flags); + bset->ref, bset->dim->nparam, bset->dim->n_out, + bset->extra, bset->flags); dump((struct isl_basic_map *)bset, out, indent); } @@ -1815,15 +2002,17 @@ void isl_basic_map_dump(struct isl_basic_map *bmap, FILE *out, int indent) fprintf(out, "%*s", indent, ""); fprintf(out, "ref: %d, nparam: %d, in: %d, out: %d, extra: %d, flags: %x\n", bmap->ref, - bmap->nparam, bmap->n_in, bmap->n_out, bmap->extra, bmap->flags); + bmap->dim->nparam, bmap->dim->n_in, bmap->dim->n_out, + bmap->extra, bmap->flags); dump(bmap, out, indent); } int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos) { - unsigned total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + unsigned total; if (!bmap) return -1; + total = isl_basic_map_total_dim(bmap); isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1); isl_seq_neg(bmap->ineq[pos], bmap->ineq[pos], 1 + total); isl_int_sub_ui(bmap->ineq[pos][0], bmap->ineq[pos][0], 1); @@ -1831,28 +2020,46 @@ int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos) return 0; } -struct isl_set *isl_set_alloc(struct isl_ctx *ctx, - unsigned nparam, unsigned dim, int n, unsigned flags) +struct isl_set *isl_set_alloc_dim(struct isl_ctx *ctx, + struct isl_dim *dim, int n, unsigned flags) { struct isl_set *set; + if (!dim) + return NULL; + isl_assert(ctx, dim->n_in == 0, return NULL); isl_assert(ctx, n >= 0, return NULL); set = isl_alloc(ctx, struct isl_set, sizeof(struct isl_set) + n * sizeof(struct isl_basic_set *)); if (!set) - return NULL; + goto error; set->ctx = ctx; isl_ctx_ref(ctx); set->ref = 1; set->size = n; set->n = 0; - set->nparam = nparam; - set->zero = 0; set->dim = dim; set->flags = flags; return set; +error: + isl_dim_free(dim); + return NULL; +} + +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; + + dims = isl_dim_alloc(ctx, nparam, 0, dim); + if (!dims) + return NULL; + + set = isl_set_alloc_dim(ctx, dims, n, flags); + return set; } struct isl_set *isl_set_dup(struct isl_set *set) @@ -1863,7 +2070,8 @@ struct isl_set *isl_set_dup(struct isl_set *set) if (!set) return NULL; - dup = isl_set_alloc(set->ctx, set->nparam, set->dim, set->n, set->flags); + dup = isl_set_alloc_dim(set->ctx, isl_dim_copy(set->dim), + set->n, set->flags); if (!dup) return NULL; for (i = 0; i < set->n; ++i) @@ -1878,7 +2086,8 @@ struct isl_set *isl_set_from_basic_set(struct isl_basic_set *bset) if (!bset) return NULL; - set = isl_set_alloc(bset->ctx, bset->nparam, bset->dim, 1, ISL_MAP_DISJOINT); + set = isl_set_alloc_dim(bset->ctx, isl_dim_copy(bset->dim), + 1, ISL_MAP_DISJOINT); if (!set) { isl_basic_set_free(bset); return NULL; @@ -1893,8 +2102,8 @@ struct isl_map *isl_map_from_basic_map(struct isl_basic_map *bmap) if (!bmap) return NULL; - map = isl_map_alloc(bmap->ctx, bmap->nparam, bmap->n_in, bmap->n_out, 1, - ISL_MAP_DISJOINT); + map = isl_map_alloc_dim(bmap->ctx, isl_dim_copy(bmap->dim), + 1, ISL_MAP_DISJOINT); if (!map) { isl_basic_map_free(bmap); return NULL; @@ -1906,8 +2115,7 @@ struct isl_set *isl_set_add(struct isl_set *set, struct isl_basic_set *bset) { if (!bset || !set) goto error; - isl_assert(set->ctx, set->nparam == bset->nparam, goto error); - isl_assert(set->ctx, set->dim == bset->dim, goto error); + isl_assert(set->ctx, isl_dim_equal(set->dim, bset->dim), goto error); isl_assert(set->ctx, set->n < set->size, goto error); set->p[set->n] = bset; set->n++; @@ -1933,6 +2141,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); free(set); } @@ -1947,7 +2156,8 @@ void isl_set_dump(struct isl_set *set, FILE *out, int indent) fprintf(out, "%*s", indent, ""); fprintf(out, "ref: %d, n: %d, nparam: %d, dim: %d, flags: %x\n", - set->ref, set->n, set->nparam, set->dim, set->flags); + set->ref, set->n, set->dim->nparam, set->dim->n_out, + set->flags); for (i = 0; i < set->n; ++i) { fprintf(out, "%*s", indent, ""); fprintf(out, "basic set %d:\n", i); @@ -1966,8 +2176,8 @@ void isl_map_dump(struct isl_map *map, FILE *out, int indent) fprintf(out, "%*s", indent, ""); fprintf(out, "ref: %d, n: %d, nparam: %d, in: %d, out: %d, flags: %x\n", - map->ref, map->n, map->nparam, map->n_in, map->n_out, - map->flags); + map->ref, map->n, map->dim->nparam, map->dim->n_in, + map->dim->n_out, map->flags); for (i = 0; i < map->n; ++i) { fprintf(out, "%*s", indent, ""); fprintf(out, "basic map %d:\n", i); @@ -1979,20 +2189,22 @@ struct isl_basic_map *isl_basic_map_intersect_domain( struct isl_basic_map *bmap, struct isl_basic_set *bset) { struct isl_basic_map *bmap_domain; + struct isl_dim *dim; if (!bmap || !bset) goto error; - isl_assert(bset->ctx, bset->dim == bmap->n_in, goto error); - isl_assert(bset->ctx, bset->nparam == bmap->nparam, goto error); + isl_assert(set->ctx, isl_basic_map_compatible_domain(bmap, bset), + goto error); bmap = isl_basic_map_extend(bmap, - bset->nparam, bmap->n_in, bmap->n_out, + isl_basic_map_n_param(bmap), isl_basic_map_n_in(bmap), + isl_basic_map_n_out(bmap), bset->n_div, bset->n_eq, bset->n_ineq); if (!bmap) goto error; - bmap_domain = isl_basic_map_from_basic_set(bset, - bset->dim, 0); + dim = isl_dim_reverse(isl_dim_copy(bset->dim)); + bmap_domain = isl_basic_map_from_basic_set(bset, dim); bmap = add_constraints(bmap, bmap_domain, 0, 0); bmap = isl_basic_map_simplify(bmap); @@ -2011,16 +2223,16 @@ struct isl_basic_map *isl_basic_map_intersect_range( if (!bmap || !bset) goto error; - isl_assert(bset->ctx, bset->dim == bmap->n_out, goto error); - isl_assert(bset->ctx, bset->nparam == bmap->nparam, goto error); + isl_assert(bset->ctx, isl_basic_map_compatible_range(bmap, bset), + goto error); bmap = isl_basic_map_extend(bmap, - bset->nparam, bmap->n_in, bmap->n_out, + isl_basic_map_n_param(bmap), isl_basic_map_n_in(bmap), + isl_basic_map_n_out(bmap), bset->n_div, bset->n_eq, bset->n_ineq); if (!bmap) goto error; - bmap_range = isl_basic_map_from_basic_set(bset, - 0, bset->dim); + bmap_range = isl_basic_map_from_basic_set(bset, isl_dim_copy(bset->dim)); bmap = add_constraints(bmap, bmap_range, 0, 0); bmap = isl_basic_map_simplify(bmap); @@ -2037,12 +2249,10 @@ struct isl_basic_map *isl_basic_map_intersect( if (!bmap1 || !bmap2) goto error; - isl_assert(bmap1->ctx, bmap1->nparam == bmap2->nparam, goto error); - isl_assert(bmap1->ctx, bmap1->n_in == bmap2->n_in, goto error); - isl_assert(bmap1->ctx, bmap1->n_out == bmap2->n_out, goto error); + isl_assert(map1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), goto error); - bmap1 = isl_basic_map_extend(bmap1, - bmap1->nparam, bmap1->n_in, bmap1->n_out, + bmap1 = isl_basic_map_extend(bmap1, isl_basic_map_n_param(bmap1), + isl_basic_map_n_in(bmap1), isl_basic_map_n_out(bmap1), bmap2->n_div, bmap2->n_eq, bmap2->n_ineq); if (!bmap1) goto error; @@ -2078,7 +2288,7 @@ struct isl_map *isl_map_intersect(struct isl_map *map1, struct isl_map *map2) F_ISSET(map2, ISL_MAP_DISJOINT)) FL_SET(flags, ISL_MAP_DISJOINT); - result = isl_map_alloc(map1->ctx, map1->nparam, map1->n_in, map1->n_out, + result = isl_map_alloc_dim(map1->ctx, isl_dim_copy(map1->dim), map1->n * map2->n, flags); if (!result) goto error; @@ -2113,6 +2323,7 @@ struct isl_set *isl_set_intersect(struct isl_set *set1, struct isl_set *set2) struct isl_basic_map *isl_basic_map_reverse(struct isl_basic_map *bmap) { + struct isl_dim *dim; struct isl_basic_set *bset; unsigned in; @@ -2121,10 +2332,11 @@ struct isl_basic_map *isl_basic_map_reverse(struct isl_basic_map *bmap) bmap = isl_basic_map_cow(bmap); if (!bmap) return NULL; - in = bmap->n_in; + dim = isl_dim_reverse(isl_dim_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, bset->dim-in, in); + return isl_basic_map_from_basic_set(bset, dim); } /* Turn final n dimensions into existentially quantified variables. @@ -2140,14 +2352,14 @@ struct isl_basic_set *isl_basic_set_project_out( if (!bset) return NULL; - isl_assert(bset->ctx, n <= bset->dim, goto error); + isl_assert(bset->ctx, n <= isl_basic_set_n_dim(bset), goto error); if (n == 0) return bset; bset = isl_basic_set_cow(bset); - row_size = 1 + bset->nparam + bset->dim + bset->extra; + row_size = 1 + isl_dim_total(bset->dim) + bset->extra; old = bset->block2.data; bset->block2 = isl_blk_extend(bset->ctx, bset->block2, (bset->extra + n) * (1 + row_size)); @@ -2167,7 +2379,10 @@ struct isl_basic_set *isl_basic_set_project_out( bset->div = new_div; bset->n_div += n; bset->extra += n; - bset->dim -= n; + bset->dim = isl_dim_cow(bset->dim); + if (!bset->dim) + goto error; + bset->dim->n_out -= n; bset = isl_basic_set_simplify(bset); return isl_basic_set_finalize(bset); error: @@ -2178,33 +2393,38 @@ 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; struct isl_basic_set *bset; - unsigned n_in, n_out; + unsigned n_in, n_out, n, nparam; if (!bmap1 || !bmap2) goto error; - isl_assert(bmap->ctx, bmap1->n_out == bmap2->n_in, goto error); - isl_assert(bmap->ctx, bmap1->nparam == bmap2->nparam, goto error); + dim_result = isl_dim_join(isl_dim_copy(bmap1->dim), + isl_dim_copy(bmap2->dim)); - n_in = bmap1->n_in; - n_out = bmap2->n_out; + n_in = isl_basic_map_n_in(bmap1); + n_out = isl_basic_map_n_out(bmap2); + n = isl_basic_map_n_out(bmap1); + nparam = isl_basic_map_n_param(bmap1); + + isl_assert(bmap->ctx, n == isl_basic_map_n_in(bmap2), goto error); + isl_assert(bmap->ctx, nparam == isl_basic_map_n_param(bmap2), goto error); bmap2 = isl_basic_map_reverse(bmap2); if (!bmap2) goto error; - bmap1 = isl_basic_map_extend(bmap1, bmap1->nparam, - bmap1->n_in + bmap2->n_in, bmap1->n_out, + bmap1 = isl_basic_map_extend(bmap1, nparam, n_in + n_out, n, bmap2->extra, bmap2->n_eq, bmap2->n_ineq); if (!bmap1) goto error; - bmap1 = add_constraints(bmap1, bmap2, bmap1->n_in - bmap2->n_in, 0); + bmap1 = add_constraints(bmap1, bmap2, n_in, 0); bmap1 = isl_basic_map_simplify(bmap1); bset = isl_basic_set_from_basic_map(bmap1); - bset = isl_basic_set_project_out(bset, - bset->dim - (n_in + n_out), 0); - return isl_basic_map_from_basic_set(bset, n_in, n_out); + bset = isl_basic_set_project_out(bset, n, 0); + return isl_basic_map_from_basic_set(bset, dim_result); error: + isl_dim_free(dim_result); isl_basic_map_free(bmap1); isl_basic_map_free(bmap2); return NULL; @@ -2216,7 +2436,8 @@ struct isl_basic_set *isl_basic_set_apply( if (!bset || !bmap) goto error; - isl_assert(bset->ctx, bset->dim == bmap->n_in, goto error); + isl_assert(set->ctx, isl_basic_map_compatible_domain(bmap, bset), + goto error); return (struct isl_basic_set *) isl_basic_map_apply_range((struct isl_basic_map *)bset, bmap); @@ -2232,8 +2453,11 @@ struct isl_basic_map *isl_basic_map_apply_domain( if (!bmap1 || !bmap2) goto error; - isl_assert(ctx, bmap1->n_in == bmap2->n_in, goto error); - isl_assert(ctx, bmap1->nparam == bmap2->nparam, goto error); + isl_assert(ctx, + isl_basic_map_n_in(bmap1) == isl_basic_map_n_in(bmap2), goto error); + isl_assert(ctx, + isl_basic_map_n_param(bmap1) == isl_basic_map_n_param(bmap2), + goto error); bmap1 = isl_basic_map_reverse(bmap1); bmap1 = isl_basic_map_apply_range(bmap1, bmap2); @@ -2248,13 +2472,17 @@ static struct isl_basic_map *var_equal(struct isl_ctx *ctx, struct isl_basic_map *bmap, unsigned pos) { int i; + unsigned nparam; + unsigned n_in; + i = isl_basic_map_alloc_equality(bmap); if (i < 0) goto error; - isl_seq_clr(bmap->eq[i], - 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div); - isl_int_set_si(bmap->eq[i][1+bmap->nparam+pos], -1); - isl_int_set_si(bmap->eq[i][1+bmap->nparam+bmap->n_in+pos], 1); + nparam = isl_basic_map_n_param(bmap); + n_in = isl_basic_map_n_in(bmap); + isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap)); + isl_int_set_si(bmap->eq[i][1+nparam+pos], -1); + isl_int_set_si(bmap->eq[i][1+nparam+n_in+pos], 1); return isl_basic_map_finalize(bmap); error: isl_basic_map_free(bmap); @@ -2265,14 +2493,18 @@ static struct isl_basic_map *var_more(struct isl_ctx *ctx, struct isl_basic_map *bmap, unsigned pos) { int i; + unsigned nparam; + unsigned n_in; + i = isl_basic_map_alloc_inequality(bmap); if (i < 0) goto error; - isl_seq_clr(bmap->ineq[i], - 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div); + nparam = isl_basic_map_n_param(bmap); + n_in = isl_basic_map_n_in(bmap); + isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap)); isl_int_set_si(bmap->ineq[i][0], -1); - isl_int_set_si(bmap->ineq[i][1+bmap->nparam+pos], -1); - isl_int_set_si(bmap->ineq[i][1+bmap->nparam+bmap->n_in+pos], 1); + isl_int_set_si(bmap->ineq[i][1+nparam+pos], -1); + isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], 1); return isl_basic_map_finalize(bmap); error: isl_basic_map_free(bmap); @@ -2283,14 +2515,18 @@ static struct isl_basic_map *var_less(struct isl_ctx *ctx, struct isl_basic_map *bmap, unsigned pos) { int i; + unsigned nparam; + unsigned n_in; + i = isl_basic_map_alloc_inequality(bmap); if (i < 0) goto error; - isl_seq_clr(bmap->ineq[i], - 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div); + nparam = isl_basic_map_n_param(bmap); + n_in = isl_basic_map_n_in(bmap); + isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap)); isl_int_set_si(bmap->ineq[i][0], -1); - isl_int_set_si(bmap->ineq[i][1+bmap->nparam+pos], 1); - isl_int_set_si(bmap->ineq[i][1+bmap->nparam+bmap->n_in+pos], -1); + isl_int_set_si(bmap->ineq[i][1+nparam+pos], 1); + isl_int_set_si(bmap->ineq[i][1+nparam+n_in+pos], -1); return isl_basic_map_finalize(bmap); error: isl_basic_map_free(bmap); @@ -2341,21 +2577,22 @@ struct isl_basic_map *isl_basic_map_more_at(struct isl_ctx *ctx, } struct isl_basic_map *isl_basic_map_from_basic_set( - struct isl_basic_set *bset, unsigned n_in, unsigned n_out) + struct isl_basic_set *bset, struct isl_dim *dim) { struct isl_basic_map *bmap; bset = isl_basic_set_cow(bset); - if (!bset) - return NULL; + if (!bset || !dim) + goto error; - isl_assert(ctx, bset->dim == n_in + n_out, goto error); + isl_assert(bset->ctx, isl_dim_compatible(bset->dim, dim), goto error); + isl_dim_free(bset->dim); bmap = (struct isl_basic_map *) bset; - bmap->n_in = n_in; - bmap->n_out = n_out; + bmap->dim = dim; return isl_basic_map_finalize(bmap); error: isl_basic_set_free(bset); + isl_dim_free(dim); return NULL; } @@ -2363,16 +2600,20 @@ struct isl_basic_set *isl_basic_set_from_basic_map(struct isl_basic_map *bmap) { if (!bmap) goto error; - if (bmap->n_in == 0) + if (bmap->dim->n_in == 0) return (struct isl_basic_set *)bmap; bmap = isl_basic_map_cow(bmap); if (!bmap) goto error; - bmap->n_out += bmap->n_in; - bmap->n_in = 0; + bmap->dim = isl_dim_cow(bmap->dim); + if (!bmap->dim) + goto error; + bmap->dim->n_out += bmap->dim->n_in; + bmap->dim->n_in = 0; bmap = isl_basic_map_finalize(bmap); return (struct isl_basic_set *)bmap; error: + isl_basic_map_free(bmap); return NULL; } @@ -2388,8 +2629,8 @@ error: static int add_div_constraints(struct isl_basic_map *bmap, unsigned div) { int i, j; - unsigned div_pos = 1 + bmap->nparam + bmap->n_in + bmap->n_out + div; - unsigned total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + unsigned total = isl_basic_map_total_dim(bmap); + unsigned div_pos = 1 + total - bmap->n_div + div; i = isl_basic_map_alloc_inequality(bmap); if (i < 0) @@ -2411,14 +2652,17 @@ struct isl_basic_set *isl_basic_map_underlying_set( { if (!bmap) goto error; - if (bmap->nparam == 0 && bmap->n_in == 0 && bmap->n_div == 0) + if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 && bmap->n_div == 0) return (struct isl_basic_set *)bmap; bmap = isl_basic_map_cow(bmap); if (!bmap) goto error; - bmap->n_out += bmap->nparam + bmap->n_in + bmap->n_div; - bmap->nparam = 0; - bmap->n_in = 0; + bmap->dim = isl_dim_cow(bmap->dim); + if (!bmap->dim) + goto error; + bmap->dim->n_out += bmap->dim->nparam + bmap->dim->n_in + bmap->n_div; + bmap->dim->nparam = 0; + bmap->dim->n_in = 0; bmap->extra -= bmap->n_div; bmap->n_div = 0; bmap = isl_basic_map_finalize(bmap); @@ -2438,21 +2682,21 @@ struct isl_basic_map *isl_basic_map_overlying_set( if (!bset || !like) goto error; ctx = bset->ctx; - isl_assert(ctx, bset->dim == - like->nparam + like->n_in + like->n_out + like->n_div, + isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like), goto error); - if (like->nparam == 0 && like->n_in == 0 && like->n_div == 0) { + if (like->dim->nparam == 0 && like->dim->n_in == 0 && like->n_div == 0) { isl_basic_map_free(like); return (struct isl_basic_map *)bset; } bset = isl_basic_set_cow(bset); if (!bset) goto error; - total = bset->dim + bset->extra; + total = bset->dim->n_out + bset->extra; bmap = (struct isl_basic_map *)bset; - bmap->nparam = like->nparam; - bmap->n_in = like->n_in; - bmap->n_out = like->n_out; + isl_dim_free(bmap->dim); + bmap->dim = isl_dim_copy(like->dim); + if (!bmap->dim) + goto error; bmap->extra += like->n_div; if (bmap->extra) { unsigned ltotal; @@ -2467,8 +2711,8 @@ struct isl_basic_map *isl_basic_map_overlying_set( bmap->extra); if (!bmap->div) goto error; - bmap = isl_basic_map_extend(bmap, bmap->nparam, - bmap->n_in, bmap->n_out, 0, 0, 2 * like->n_div); + bmap = isl_basic_map_extend_constraints(bmap, + 0, 2 * like->n_div); for (i = 0; i < like->n_div; ++i) { k = isl_basic_map_alloc_div(bmap); if (k < 0) @@ -2502,9 +2746,9 @@ struct isl_set *isl_set_from_underlying_set( if (!set || !like) goto error; - isl_assert(set->ctx, set->dim == like->nparam + like->dim + like->n_div, + isl_assert(set->ctx, set->dim->n_out == isl_basic_set_total_dim(like), goto error); - if (like->nparam == 0 && like->n_div == 0) { + if (like->dim->nparam == 0 && like->n_div == 0) { isl_basic_set_free(like); return set; } @@ -2517,8 +2761,10 @@ struct isl_set *isl_set_from_underlying_set( if (!set->p[i]) goto error; } - set->nparam = like->nparam; - set->dim = like->dim; + isl_dim_free(set->dim); + set->dim = isl_dim_copy(like->dim); + if (!set->dim) + goto error; isl_basic_set_free(like); return set; error: @@ -2535,6 +2781,9 @@ 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); + if (!map->dim) + goto error; for (i = 0; i < map->n; ++i) { map->p[i] = (struct isl_basic_map *) @@ -2543,11 +2792,11 @@ struct isl_set *isl_map_underlying_set(struct isl_map *map) goto error; } if (map->n == 0) - map->n_out += map->nparam + map->n_in; + map->dim->n_out += map->dim->nparam + map->dim->n_in; else - map->n_out = map->p[0]->n_out; - map->nparam = 0; - map->n_in = 0; + map->dim->n_out = map->p[0]->dim->n_out; + map->dim->nparam = 0; + map->dim->n_in = 0; return (struct isl_set *)map; error: isl_map_free(map); @@ -2565,7 +2814,7 @@ struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap) unsigned n_out; if (!bmap) return NULL; - n_out = bmap->n_out; + n_out = isl_basic_map_n_out(bmap); domain = isl_basic_set_from_basic_map(bmap); return isl_basic_set_project_out(domain, n_out, 0); } @@ -2587,7 +2836,12 @@ struct isl_set *isl_map_range(struct isl_map *map) goto error; set = (struct isl_set *) map; - set->zero = 0; + if (set->dim->n_in != 0) { + set->dim = isl_dim_cow(set->dim); + if (!set->dim) + goto error; + set->dim->n_in = 0; + } for (i = 0; i < map->n; ++i) { set->p[i] = isl_basic_map_range(map->p[i]); if (!set->p[i]) @@ -2601,29 +2855,27 @@ error: return NULL; } -struct isl_map *isl_map_from_set(struct isl_set *set, - unsigned n_in, unsigned n_out) +struct isl_map *isl_map_from_set(struct isl_set *set, struct isl_dim *dim) { int i; struct isl_map *map = NULL; - if (!set) - return NULL; - isl_assert(set->ctx, set->dim == n_in + n_out, goto error); set = isl_set_cow(set); - if (!set) - return NULL; + if (!set || !dim) + goto error; + isl_assert(set->ctx, isl_dim_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], n_in, n_out); + set->p[i], isl_dim_copy(dim)); if (!map->p[i]) goto error; } - map->n_in = n_in; - map->n_out = n_out; + isl_dim_free(map->dim); + map->dim = dim; return map; error: + isl_dim_free(dim); isl_set_free(set); return NULL; } @@ -2638,8 +2890,11 @@ struct isl_set *isl_set_from_map(struct isl_map *map) map = isl_map_cow(map); if (!map) return NULL; - map->n_out += map->n_in; - map->n_in = 0; + map->dim = isl_dim_cow(map->dim); + if (!map->dim) + goto error; + map->dim->n_out += map->dim->n_in; + map->dim->n_in = 0; set = (struct isl_set *)map; for (i = 0; i < map->n; ++i) { set->p[i] = isl_basic_set_from_basic_map(map->p[i]); @@ -2652,28 +2907,46 @@ error: return NULL; } -struct isl_map *isl_map_alloc(struct isl_ctx *ctx, - unsigned nparam, unsigned in, unsigned out, int n, - unsigned flags) +struct isl_map *isl_map_alloc_dim(struct isl_ctx *ctx, + struct isl_dim *dim, int n, unsigned flags) { struct isl_map *map; + if (!dim) + return NULL; + isl_assert(ctx, n >= 0, return NULL); map = isl_alloc(ctx, struct isl_map, sizeof(struct isl_map) + n * sizeof(struct isl_basic_map *)); if (!map) - return NULL; + goto error; map->ctx = ctx; isl_ctx_ref(ctx); map->ref = 1; map->size = n; map->n = 0; - map->nparam = nparam; - map->n_in = in; - map->n_out = out; + map->dim = dim; map->flags = flags; return map; +error: + isl_dim_free(dim); + return NULL; +} + +struct isl_map *isl_map_alloc(struct isl_ctx *ctx, + unsigned nparam, unsigned in, unsigned out, int n, + unsigned flags) +{ + struct isl_map *map; + struct isl_dim *dims; + + dims = isl_dim_alloc(ctx, nparam, in, out); + if (!dims) + return NULL; + + map = isl_map_alloc_dim(ctx, dims, n, flags); + return map; } struct isl_basic_map *isl_basic_map_empty(struct isl_ctx *ctx, @@ -2694,6 +2967,39 @@ struct isl_basic_set *isl_basic_set_empty(struct isl_ctx *ctx, return bset; } +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(model->ctx, isl_dim_copy(model->dim), + 0, 1, 0); + bmap = isl_basic_map_set_to_empty(bmap); + return bmap; +} + +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(model->ctx, isl_dim_copy(model->dim), + 0, 1, 0); + bmap = isl_basic_map_set_to_empty(bmap); + return bmap; +} + +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(model->ctx, isl_dim_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_ctx *ctx, unsigned nparam, unsigned in, unsigned out) { @@ -2710,18 +3016,41 @@ struct isl_basic_set *isl_basic_set_universe(struct isl_ctx *ctx, return bset; } +struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *model) +{ + if (!model) + return NULL; + return isl_basic_set_alloc_dim(model->ctx, isl_dim_copy(model->dim), + 0, 0, 0); +} + struct isl_map *isl_map_empty(struct isl_ctx *ctx, unsigned nparam, unsigned in, unsigned out) { return isl_map_alloc(ctx, nparam, in, out, 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(model->ctx, isl_dim_copy(model->dim), + 0, ISL_MAP_DISJOINT); +} + struct isl_set *isl_set_empty(struct isl_ctx *ctx, unsigned nparam, unsigned dim) { return isl_set_alloc(ctx, nparam, dim, 0, ISL_MAP_DISJOINT); } +struct isl_set *isl_set_empty_like(struct isl_set *model) +{ + if (!model) + return NULL; + return isl_set_alloc_dim(model->ctx, model->dim, 0, ISL_MAP_DISJOINT); +} + struct isl_map *isl_map_dup(struct isl_map *map) { int i; @@ -2729,8 +3058,8 @@ struct isl_map *isl_map_dup(struct isl_map *map) if (!map) return NULL; - dup = isl_map_alloc(map->ctx, map->nparam, map->n_in, map->n_out, map->n, - map->flags); + dup = isl_map_alloc_dim(map->ctx, isl_dim_copy(map->dim), + map->n, map->flags); for (i = 0; i < map->n; ++i) dup = isl_map_add(dup, isl_basic_map_copy(map->p[i])); return dup; @@ -2740,9 +3069,7 @@ struct isl_map *isl_map_add(struct isl_map *map, struct isl_basic_map *bmap) { if (!bmap || !map) goto error; - isl_assert(map->ctx, map->nparam == bmap->nparam, goto error); - isl_assert(map->ctx, map->n_in == bmap->n_in, goto error); - isl_assert(map->ctx, map->n_out == bmap->n_out, goto error); + isl_assert(map->ctx, isl_dim_equal(map->dim, bmap->dim), goto error); isl_assert(map->ctx, map->n < map->size, goto error); map->p[map->n] = bmap; map->n++; @@ -2769,6 +3096,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); free(map); } @@ -2781,12 +3109,15 @@ struct isl_map *isl_map_extend(struct isl_map *base, if (!base) return NULL; - isl_assert(base->ctx, base->nparam <= nparam, goto error); - isl_assert(base->ctx, base->n_in <= n_in, goto error); - isl_assert(base->ctx, base->n_out <= n_out, goto error); - base->nparam = nparam; - base->n_in = n_in; - base->n_out = n_out; + isl_assert(base->ctx, base->dim->nparam <= nparam, goto error); + isl_assert(base->ctx, base->dim->n_in <= n_in, goto error); + isl_assert(base->ctx, base->dim->n_out <= n_out, goto error); + base->dim = isl_dim_cow(base->dim); + if (!base->dim) + goto error; + base->dim->nparam = nparam; + base->dim->n_in = n_in; + base->dim->n_out = n_out; for (i = 0; i < base->n; ++i) { base->p[i] = isl_basic_map_extend(base->p[i], nparam, n_in, n_out, 0, 0, 0); @@ -2812,13 +3143,11 @@ static struct isl_basic_map *isl_basic_map_fix_var(struct isl_basic_map *bmap, int j; bmap = isl_basic_map_cow(bmap); - bmap = isl_basic_map_extend(bmap, - bmap->nparam, bmap->n_in, bmap->n_out, 0, 1, 0); + bmap = isl_basic_map_extend_constraints(bmap, 1, 0); j = isl_basic_map_alloc_equality(bmap); if (j < 0) goto error; - isl_seq_clr(bmap->eq[j], - 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div); + isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap)); isl_int_set_si(bmap->eq[j][1 + var], -1); isl_int_set_si(bmap->eq[j][0], value); bmap = isl_basic_map_simplify(bmap); @@ -2833,8 +3162,9 @@ struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap, { if (!bmap) return NULL; - isl_assert(bmap->ctx, input < bmap->n_in, goto error); - return isl_basic_map_fix_var(bmap, bmap->nparam + input, value); + isl_assert(bmap->ctx, input < isl_basic_map_n_in(bmap), goto error); + return isl_basic_map_fix_var(bmap, isl_basic_map_n_param(bmap) + input, + value); error: isl_basic_map_free(bmap); return NULL; @@ -2845,10 +3175,10 @@ struct isl_basic_set *isl_basic_set_fix_dim_si(struct isl_basic_set *bset, { if (!bset) return NULL; - isl_assert(bset->ctx, dim < bset->dim, goto error); + isl_assert(bset->ctx, dim < isl_basic_set_n_dim(bset), goto error); return (struct isl_basic_set *) isl_basic_map_fix_var((struct isl_basic_map *)bset, - bset->nparam + dim, value); + isl_basic_set_n_param(bset) + dim, value); error: isl_basic_set_free(bset); return NULL; @@ -2863,7 +3193,7 @@ struct isl_map *isl_map_fix_input_si(struct isl_map *map, if (!map) return NULL; - isl_assert(ctx, input < map->n_in, goto error); + isl_assert(ctx, input < isl_map_n_in(map), goto error); for (i = 0; i < map->n; ++i) { map->p[i] = isl_basic_map_fix_input_si(map->p[i], input, value); if (!map->p[i]) @@ -2884,7 +3214,7 @@ struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value) if (!set) return NULL; - isl_assert(set->ctx, dim < set->dim, goto error); + isl_assert(set->ctx, dim < isl_set_n_dim(set), goto error); for (i = 0; i < set->n; ++i) { set->p[i] = isl_basic_set_fix_dim_si(set->p[i], dim, value); if (!set->p[i]) @@ -2900,14 +3230,15 @@ struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset, unsigned dim, isl_int value) { int j; + unsigned nparam; bset = isl_basic_set_cow(bset); - bset = isl_basic_set_extend(bset, bset->nparam, bset->dim, 0, 0, 1); + bset = isl_basic_set_extend_constraints(bset, 0, 1); j = isl_basic_set_alloc_inequality(bset); if (j < 0) goto error; - isl_seq_clr(bset->ineq[j], 1 + bset->nparam + bset->dim + bset->n_div); - isl_int_set_si(bset->ineq[j][1 + bset->nparam + dim], 1); + isl_seq_clr(bset->ineq[j], 1 + isl_basic_set_total_dim(bset)); + isl_int_set_si(bset->ineq[j][1 + isl_basic_set_n_param(bset) + dim], 1); isl_int_neg(bset->ineq[j][0], value); bset = isl_basic_set_simplify(bset); return isl_basic_set_finalize(bset); @@ -2925,7 +3256,7 @@ struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim, if (!set) return NULL; - isl_assert(set->ctx, dim < set->dim, goto error); + isl_assert(set->ctx, dim < isl_set_n_dim(set), goto error); for (i = 0; i < set->n; ++i) { set->p[i] = isl_basic_set_lower_bound_dim(set->p[i], dim, value); if (!set->p[i]) @@ -2946,9 +3277,9 @@ struct isl_map *isl_map_reverse(struct isl_map *map) if (!map) return NULL; - t = map->n_in; - map->n_in = map->n_out; - map->n_out = t; + map->dim = isl_dim_reverse(map->dim); + if (!map->dim) + goto error; for (i = 0; i < map->n; ++i) { map->p[i] = isl_basic_map_reverse(map->p[i]); if (!map->p[i]) @@ -2983,10 +3314,10 @@ struct isl_set *isl_basic_set_lexmin(struct isl_basic_set *bset) if (!bset) goto error; - bmap = isl_basic_map_from_basic_set(bset, 0, bset->dim); + bmap = isl_basic_map_from_basic_set(bset, isl_dim_copy(bset->dim)); if (!bmap) goto error; - dom = isl_basic_set_alloc(bmap->ctx, bmap->nparam, 0, 0, 0, 0); + dom = isl_basic_set_universe(bmap->ctx, isl_basic_map_n_param(bmap), 0); if (!dom) goto error; min = isl_basic_map_lexmin(bmap, dom, NULL); @@ -3053,8 +3384,11 @@ struct isl_set *isl_map_domain(struct isl_map *map) return NULL; set = (struct isl_set *)map; - set->dim = map->n_in; - set->zero = 0; + set->dim = isl_dim_cow(set->dim); + if (!set->dim) + goto error; + set->dim->n_out = map->dim->n_in; + set->dim->n_in = 0; for (i = 0; i < map->n; ++i) { set->p[i] = isl_basic_map_domain(map->p[i]); if (!set->p[i]) @@ -3087,15 +3421,13 @@ struct isl_map *isl_map_union_disjoint( return map1; } - isl_assert(map1->ctx, map1->nparam == map2->nparam, goto error); - isl_assert(map1->ctx, map1->n_in == map2->n_in, goto error); - isl_assert(map1->ctx, map1->n_out == map2->n_out, goto error); + isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error); if (F_ISSET(map1, ISL_MAP_DISJOINT) && F_ISSET(map2, ISL_MAP_DISJOINT)) FL_SET(flags, ISL_MAP_DISJOINT); - map = isl_map_alloc(map1->ctx, map1->nparam, map1->n_in, map1->n_out, + map = isl_map_alloc_dim(map1->ctx, isl_dim_copy(map1->dim), map1->n + map2->n, flags); if (!map) goto error; @@ -3159,8 +3491,8 @@ struct isl_map *isl_map_intersect_range( F_ISSET(set, ISL_MAP_DISJOINT)) FL_SET(flags, ISL_MAP_DISJOINT); - result = isl_map_alloc(map->ctx, map->nparam, map->n_in, map->n_out, - map->n * set->n, flags); + result = isl_map_alloc_dim(map->ctx, isl_dim_copy(map->dim), + map->n * set->n, flags); if (!result) goto error; for (i = 0; i < map->n; ++i) @@ -3205,17 +3537,20 @@ error: struct isl_map *isl_map_apply_range( struct isl_map *map1, struct isl_map *map2) { + struct isl_dim *dim_result; struct isl_map *result; int i, j; + unsigned nparam; + unsigned n_in; + unsigned n_out; if (!map1 || !map2) goto error; - isl_assert(map1->ctx, map1->nparam == map2->nparam, goto error); - isl_assert(map1->ctx, map1->n_out == map2->n_in, goto error); + dim_result = isl_dim_join(isl_dim_copy(map1->dim), + isl_dim_copy(map2->dim)); - result = isl_map_alloc(map1->ctx, map1->nparam, map1->n_in, map2->n_out, - map1->n * map2->n, 0); + result = isl_map_alloc_dim(map1->ctx, dim_result, map1->n * map2->n, 0); if (!result) goto error; for (i = 0; i < map1->n; ++i) @@ -3245,26 +3580,26 @@ struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap) { struct isl_basic_set *bset; unsigned dim; + unsigned nparam; int i; if (!bmap) goto error; - isl_assert(bmap->ctx, bmap->n_in == bmap->n_out, goto error); - dim = bmap->n_in; + dim = isl_basic_map_n_in(bmap); + nparam = isl_basic_map_n_param(bmap); + isl_assert(bmap->ctx, dim == isl_basic_map_n_out(bmap), goto error); bset = isl_basic_set_from_basic_map(bmap); - bset = isl_basic_set_extend(bset, bset->nparam, 3*dim, 0, - dim, 0); + bset = isl_basic_set_extend(bset, nparam, 3*dim, 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( (struct isl_basic_map *)bset); if (j < 0) goto error; - isl_seq_clr(bset->eq[j], - 1 + bset->nparam + bset->dim + bset->n_div); - isl_int_set_si(bset->eq[j][1+bset->nparam+i], 1); - isl_int_set_si(bset->eq[j][1+bset->nparam+dim+i], 1); - isl_int_set_si(bset->eq[j][1+bset->nparam+2*dim+i], -1); + isl_seq_clr(bset->eq[j], 1 + isl_basic_set_total_dim(bset)); + isl_int_set_si(bset->eq[j][1+nparam+i], 1); + isl_int_set_si(bset->eq[j][1+nparam+dim+i], 1); + isl_int_set_si(bset->eq[j][1+nparam+2*dim+i], -1); } return isl_basic_set_project_out(bset, 2*dim, 0); error: @@ -3283,8 +3618,9 @@ struct isl_set *isl_map_deltas(struct isl_map *map) if (!map) return NULL; - isl_assert(map->ctx, map->n_in == map->n_out, goto error); - result = isl_set_alloc(map->ctx, map->nparam, map->n_in, map->n, map->flags); + isl_assert(map->ctx, isl_map_n_in(map) == isl_map_n_out(map), goto error); + result = isl_set_alloc(map->ctx, isl_map_n_param(map), + isl_map_n_in(map), map->n, map->flags); if (!result) goto error; for (i = 0; i < map->n; ++i) @@ -3308,7 +3644,7 @@ error: static int div_is_redundant(struct isl_basic_map *bmap, int div) { int i; - unsigned pos = 1 + bmap->nparam + bmap->n_in + bmap->n_out + div; + unsigned pos = 1 + isl_dim_total(bmap->dim) + div; for (i = 0; i < bmap->n_eq; ++i) if (!isl_int_is_zero(bmap->eq[i][pos])) @@ -3432,8 +3768,7 @@ struct isl_basic_map *isl_basic_map_identity(struct isl_ctx *ctx, int j = isl_basic_map_alloc_equality(bmap); if (j < 0) goto error; - isl_seq_clr(bmap->eq[j], - 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div); + isl_seq_clr(bmap->eq[j], 1 + isl_basic_map_total_dim(bmap)); isl_int_set_si(bmap->eq[j][1+nparam+i], 1); isl_int_set_si(bmap->eq[j][1+nparam+dim+i], -1); } @@ -3593,7 +3928,7 @@ static int basic_map_contains(struct isl_basic_map *bmap, struct isl_vec *vec) unsigned total; isl_int s; - total = 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + total = 1 + isl_basic_map_total_dim(bmap); if (total != vec->size) return -1; @@ -3648,7 +3983,7 @@ int isl_basic_map_is_empty(struct isl_basic_map *bmap) return empty; } - total = 1 + bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + total = 1 + isl_basic_map_total_dim(bmap); if (bmap->sample && bmap->sample->size == total) { int contains = basic_map_contains(bmap, bmap->sample); if (contains < 0) @@ -3677,12 +4012,9 @@ struct isl_map *isl_basic_map_union( if (!bmap1 || !bmap2) return NULL; - isl_assert(bmap1->ctx, bmap1->nparam == bmap2->nparam, goto error); - isl_assert(bmap1->ctx, bmap1->n_in == bmap2->n_in, goto error); - isl_assert(bmap1->ctx, bmap1->n_out == bmap2->n_out, goto error); + isl_assert(map1->ctx, isl_dim_equal(bmap1->dim, bmap2->dim), goto error); - map = isl_map_alloc(bmap1->ctx, bmap1->nparam, - bmap1->n_in, bmap1->n_out, 2, 0); + map = isl_map_alloc_dim(bmap1->ctx, isl_dim_copy(bmap1->dim), 2, 0); if (!map) goto error; map = isl_map_add(map, bmap1); @@ -3706,7 +4038,7 @@ struct isl_set *isl_basic_set_union( static struct isl_basic_map *order_divs(struct isl_basic_map *bmap) { int i; - unsigned off = bmap->nparam + bmap->n_in + bmap->n_out; + unsigned off = isl_dim_total(bmap->dim); for (i = 0; i < bmap->n_div; ++i) { int pos; @@ -3725,7 +4057,7 @@ static int find_div(struct isl_basic_map *dst, { int i; - unsigned total = src->nparam + src->n_in + src->n_out + src->n_div; + unsigned total = isl_basic_map_total_dim(src); for (i = 0; i < dst->n_div; ++i) if (isl_seq_eq(dst->div[i], src->div[div], 1+1+total) && @@ -3739,7 +4071,7 @@ struct isl_basic_map *isl_basic_map_align_divs( struct isl_basic_map *dst, struct isl_basic_map *src) { int i; - unsigned total = src->nparam + src->n_in + src->n_out + src->n_div; + unsigned total = isl_basic_map_total_dim(src); if (!dst || !src) goto error; @@ -3748,8 +4080,9 @@ struct isl_basic_map *isl_basic_map_align_divs( return dst; src = order_divs(src); - dst = isl_basic_map_extend(dst, dst->nparam, dst->n_in, - dst->n_out, src->n_div, 0, 2 * src->n_div); + dst = isl_basic_map_extend(dst, isl_basic_map_n_param(dst), + isl_basic_map_n_in(dst), isl_basic_map_n_out(dst), + src->n_div, 0, 2 * src->n_div); if (!dst) return NULL; for (i = 0; i < src->n_div; ++i) { @@ -3811,8 +4144,7 @@ static struct isl_map *add_cut_constraint(struct isl_map *dst, copy = isl_basic_map_cow(copy); if (!copy) goto error; - copy = isl_basic_map_extend(copy, - copy->nparam, copy->n_in, copy->n_out, 0, 0, 1); + copy = isl_basic_map_extend_constraints(copy, 0, 1); k = isl_basic_map_alloc_inequality(copy); if (k < 0) goto error; @@ -3820,7 +4152,7 @@ static struct isl_map *add_cut_constraint(struct isl_map *dst, isl_seq_neg(copy->ineq[k], c, len); else isl_seq_cpy(copy->ineq[k], c, len); - total = 1 + copy->nparam + copy->n_in + copy->n_out + copy->n_div; + total = 1 + isl_basic_map_total_dim(copy); isl_seq_clr(copy->ineq[k]+len, total - len); isl_inequality_negate(copy, k); copy = isl_basic_map_simplify(copy); @@ -3845,7 +4177,7 @@ static struct isl_map *subtract(struct isl_map *map, struct isl_basic_map *bmap) unsigned flags = 0; struct isl_map *rest = NULL; unsigned max; - unsigned total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + unsigned total = isl_basic_map_total_dim(bmap); assert(bmap); @@ -3856,8 +4188,7 @@ static struct isl_map *subtract(struct isl_map *map, struct isl_basic_map *bmap) FL_SET(flags, ISL_MAP_DISJOINT); max = map->n * (2 * bmap->n_eq + bmap->n_ineq); - rest = isl_map_alloc(map->ctx, map->nparam, map->n_in, map->n_out, - max, flags); + rest = isl_map_alloc_dim(map->ctx, isl_dim_copy(map->dim), max, flags); if (!rest) goto error; @@ -3882,9 +4213,8 @@ static struct isl_map *subtract(struct isl_map *map, struct isl_basic_map *bmap) if (!rest) goto error; - map->p[j] = isl_basic_map_extend(map->p[j], - map->p[j]->nparam, map->p[j]->n_in, - map->p[j]->n_out, 0, 1, 0); + map->p[j] = isl_basic_map_extend_constraints(map->p[j], + 1, 0); if (!map->p[j]) goto error; k = isl_basic_map_alloc_equality(map->p[j]); @@ -3903,9 +4233,8 @@ static struct isl_map *subtract(struct isl_map *map, struct isl_basic_map *bmap) if (!rest) goto error; - map->p[j] = isl_basic_map_extend(map->p[j], - map->p[j]->nparam, map->p[j]->n_in, - map->p[j]->n_out, 0, 0, 1); + map->p[j] = isl_basic_map_extend_constraints(map->p[j], + 0, 1); if (!map->p[j]) goto error; k = isl_basic_map_alloc_inequality(map->p[j]); @@ -3931,9 +4260,7 @@ struct isl_map *isl_map_subtract(struct isl_map *map1, struct isl_map *map2) if (!map1 || !map2) goto error; - isl_assert(map1->ctx, map1->nparam == map2->nparam, goto error); - isl_assert(map1->ctx, map1->n_in == map2->n_in, goto error); - isl_assert(map1->ctx, map1->n_out == map2->n_out, goto error); + isl_assert(map1->ctx, isl_dim_equal(map1->dim, map2->dim), goto error); if (isl_map_is_empty(map2)) { isl_map_free(map2); @@ -3967,7 +4294,7 @@ struct isl_set *isl_set_apply(struct isl_set *set, struct isl_map *map) { if (!set || !map) goto error; - isl_assert(set->ctx, set->dim == map->n_in, goto error); + isl_assert(set->ctx, isl_map_compatible_domain(map, set), goto error); map = isl_map_intersect_domain(map, set); set = isl_map_range(map); return set; @@ -4060,11 +4387,14 @@ error: int isl_basic_set_compare_at(struct isl_basic_set *bset1, struct isl_basic_set *bset2, int pos) { + struct isl_dim *dims; struct isl_basic_map *bmap1 = NULL; struct isl_basic_map *bmap2 = NULL; struct isl_ctx *ctx; struct isl_vec *obj; unsigned total; + unsigned nparam; + unsigned dim1, dim2; isl_int num, den; enum isl_lp_result res; int cmp; @@ -4072,27 +4402,29 @@ int isl_basic_set_compare_at(struct isl_basic_set *bset1, if (!bset1 || !bset2) return -2; - bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), - pos, bset1->dim - pos); - bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), - pos, bset2->dim - pos); + 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); + bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), dims); + dims = isl_dim_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; - bmap1 = isl_basic_map_extend(bmap1, bmap1->nparam, - bmap1->n_in, bmap1->n_out + bmap2->n_out, + bmap1 = isl_basic_map_extend(bmap1, nparam, + pos, (dim1 - pos) + (dim2 - pos), bmap2->n_div, bmap2->n_eq, bmap2->n_ineq); if (!bmap1) goto error; - total = bmap1->nparam + bmap1->n_in + bmap1->n_out + bmap1->n_div; + total = isl_basic_map_total_dim(bmap1); ctx = bmap1->ctx; obj = isl_vec_alloc(ctx, total); isl_seq_clr(obj->block.data, total); - isl_int_set_si(obj->block.data[bmap1->nparam+bmap1->n_in], 1); - isl_int_set_si(obj->block.data[bmap1->nparam+bmap1->n_in+ - bmap1->n_out-bmap2->n_out], -1); + isl_int_set_si(obj->block.data[nparam+pos], 1); + isl_int_set_si(obj->block.data[nparam+pos+(dim1-pos)], -1); if (!obj) goto error; - bmap1 = add_constraints(bmap1, bmap2, 0, bmap1->n_out - bmap2->n_out); + bmap1 = add_constraints(bmap1, bmap2, 0, dim1 - pos); isl_int_init(num); isl_int_init(den); res = isl_solve_lp(bmap1, 0, obj->block.data, ctx->one, &num, &den); @@ -4125,7 +4457,7 @@ static int isl_basic_map_fast_has_fixed_var(struct isl_basic_map *bmap, if (!bmap) return -1; - total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + total = isl_basic_map_total_dim(bmap); for (i = 0, d = total-1; i < bmap->n_eq && d+1 > pos; ++i) { for (; d+1 > pos; --d) if (!isl_int_is_zero(bmap->eq[i][1+d])) @@ -4185,7 +4517,7 @@ static int isl_set_fast_has_fixed_var(struct isl_set *set, unsigned pos, */ int isl_set_fast_dim_is_fixed(struct isl_set *set, unsigned dim, isl_int *val) { - return isl_set_fast_has_fixed_var(set, set->nparam + dim, val); + return isl_set_fast_has_fixed_var(set, isl_set_n_param(set) + dim, val); } /* Check if input variable in has fixed value and if so and if val is not NULL, @@ -4193,7 +4525,7 @@ int isl_set_fast_dim_is_fixed(struct isl_set *set, unsigned dim, isl_int *val) */ int isl_map_fast_input_is_fixed(struct isl_map *map, unsigned in, isl_int *val) { - return isl_map_fast_has_fixed_var(map, map->nparam + in, val); + return isl_map_fast_has_fixed_var(map, isl_map_n_param(map) + in, val); } /* Check if dimension dim has an (obvious) fixed lower bound and if so @@ -4205,19 +4537,21 @@ int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset, int i, i_eq = -1, i_ineq = -1; isl_int *c; unsigned total; + unsigned nparam; if (!bset) return -1; - total = bset->nparam + bset->dim + bset->n_div; + total = isl_basic_set_total_dim(bset); + nparam = isl_basic_set_n_param(bset); for (i = 0; i < bset->n_eq; ++i) { - if (isl_int_is_zero(bset->eq[i][1+bset->nparam+dim])) + if (isl_int_is_zero(bset->eq[i][1+nparam+dim])) continue; if (i_eq != -1) return 0; i_eq = i; } for (i = 0; i < bset->n_ineq; ++i) { - if (!isl_int_is_pos(bset->ineq[i][1+bset->nparam+dim])) + if (!isl_int_is_pos(bset->ineq[i][1+nparam+dim])) continue; if (i_eq != -1 || i_ineq != -1) return 0; @@ -4227,12 +4561,12 @@ int isl_basic_set_fast_dim_has_fixed_lower_bound(struct isl_basic_set *bset, return 0; c = i_eq != -1 ? bset->eq[i_eq] : bset->ineq[i_ineq]; /* The coefficient should always be one due to normalization. */ - if (!isl_int_is_one(c[1+bset->nparam+dim])) + if (!isl_int_is_one(c[1+nparam+dim])) return 0; - if (isl_seq_first_non_zero(c+1, bset->nparam+dim) != -1) + if (isl_seq_first_non_zero(c+1, nparam+dim) != -1) return 0; - if (isl_seq_first_non_zero(c+1+bset->nparam+dim+1, - total - bset->nparam - dim - 1) != -1) + if (isl_seq_first_non_zero(c+1+nparam+dim+1, + total - nparam - dim - 1) != -1) return 0; if (val) isl_int_neg(*val, c[0]); @@ -4284,7 +4618,7 @@ static struct isl_basic_set *isl_basic_set_reduce_using_equalities( if (!bset) goto error; - elim = isl_alloc_array(ctx, int, bset->dim); + elim = isl_alloc_array(ctx, int, isl_basic_set_n_dim(bset)); if (!elim) goto error; set_compute_elimination_index(context, elim); @@ -4381,8 +4715,8 @@ static struct isl_basic_set *uset_gist(struct isl_basic_set *bset, if (!context->n_ineq) goto done; bset = remove_shifted_constraints(bset, context); - combined = isl_basic_set_extend(isl_basic_set_copy(bset), - 0, bset->dim, 0, context->n_eq, context->n_ineq); + combined = isl_basic_set_extend_constraints(isl_basic_set_copy(bset), + context->n_eq, context->n_ineq); context = set_add_constraints(combined, context, 0); if (!context) goto error; @@ -4447,9 +4781,7 @@ struct isl_map *isl_map_gist(struct isl_map *map, struct isl_basic_map *context) map = isl_map_cow(map); if (!map || !context) return NULL; - isl_assert(map->ctx, map->nparam == context->nparam, goto error); - isl_assert(map->ctx, map->n_in == context->n_in, goto error); - isl_assert(map->ctx, map->n_out == context->n_out, goto error); + isl_assert(map->ctx, isl_dim_equal(map->dim, context->dim), goto error); for (i = 0; i < map->n; ++i) context = isl_basic_map_align_divs(context, map->p[i]); for (i = 0; i < map->n; ++i) { @@ -4502,7 +4834,7 @@ static struct isl_basic_map *isl_basic_map_sort_constraints( if (!bmap) return NULL; - total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->n_div; + total = isl_basic_map_total_dim(bmap); c = isl_alloc_array(bmap->ctx, struct constraint, bmap->n_ineq); if (!c) goto error; @@ -4546,12 +4878,12 @@ static int isl_basic_map_fast_cmp(const struct isl_basic_map *bmap1, if (bmap1 == bmap2) return 0; - if (bmap1->nparam != bmap2->nparam) - return bmap1->nparam - bmap2->nparam; - if (bmap1->n_in != bmap2->n_in) - return bmap1->n_in - bmap2->n_in; - if (bmap1->n_out != bmap2->n_out) - return bmap1->n_out - bmap2->n_out; + if (isl_basic_map_n_param(bmap1) != isl_basic_map_n_param(bmap2)) + return isl_basic_map_n_param(bmap1) - isl_basic_map_n_param(bmap2); + if (isl_basic_map_n_in(bmap1) != isl_basic_map_n_in(bmap2)) + return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2); + if (isl_basic_map_n_out(bmap1) != isl_basic_map_n_out(bmap2)) + return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2); if (F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) && F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY)) return 0; @@ -4565,7 +4897,7 @@ static int isl_basic_map_fast_cmp(const struct isl_basic_map *bmap1, return bmap1->n_ineq - bmap2->n_ineq; if (bmap1->n_div != bmap2->n_div) return bmap1->n_div - bmap2->n_div; - total = bmap1->nparam + bmap1->n_in + bmap1->n_out + bmap1->n_div; + total = isl_basic_map_total_dim(bmap1); for (i = 0; i < bmap1->n_eq; ++i) { cmp = isl_seq_cmp(bmap1->eq[i], bmap2->eq[i], 1+total); if (cmp) @@ -4653,11 +4985,7 @@ int isl_map_fast_is_equal(struct isl_map *map1, struct isl_map *map2) if (map1 == map2) return 1; - if (map1->nparam != map2->nparam) - return 0; - if (map1->n_in != map2->n_in) - return 0; - if (map1->n_out != map2->n_out) + if (!isl_dim_equal(map1->dim, map2->dim)) return 0; map1 = isl_map_copy(map1); @@ -4733,15 +5061,16 @@ struct isl_basic_set *isl_basic_set_product(struct isl_basic_set_list *list) goto error; isl_assert(list->ctx, list->n > 0, goto error); isl_assert(list->ctx, list->p[0], goto error); - nparam = list->p[0]->nparam; - dim = list->p[0]->dim; + nparam = isl_basic_set_n_param(list->p[0]); + dim = isl_basic_set_n_dim(list->p[0]); extra = list->p[0]->n_div; n_eq = list->p[0]->n_eq; n_ineq = list->p[0]->n_ineq; for (i = 1; i < list->n; ++i) { isl_assert(list->ctx, list->p[i], goto error); - isl_assert(list->ctx, nparam == list->p[i]->nparam, goto error); - dim += list->p[i]->dim; + isl_assert(list->ctx, + nparam == isl_basic_set_n_param(list->p[i]), goto error); + dim += isl_basic_set_n_dim(list->p[i]); extra += list->p[i]->n_div; n_eq += list->p[i]->n_eq; n_ineq += list->p[i]->n_ineq; @@ -4754,7 +5083,7 @@ struct isl_basic_set *isl_basic_set_product(struct isl_basic_set_list *list) for (i = 0; i < list->n; ++i) { set_add_constraints(product, isl_basic_set_copy(list->p[i]), dim); - dim += list->p[i]->dim; + dim += isl_basic_set_n_dim(list->p[i]); } isl_basic_set_list_free(list); return product; @@ -4776,7 +5105,7 @@ uint32_t isl_basic_set_get_hash(struct isl_basic_set *bset) bset = isl_basic_set_normalize(bset); if (!bset) return 0; - total = bset->nparam + bset->dim + bset->n_div; + total = isl_basic_set_total_dim(bset); isl_hash_byte(hash, bset->n_eq & 0xFF); for (i = 0; i < bset->n_eq; ++i) { uint32_t c_hash; @@ -4833,11 +5162,13 @@ uint32_t isl_set_get_hash(struct isl_set *set) int isl_basic_set_dim_is_unique(struct isl_basic_set *bset, unsigned dim) { int i; + unsigned nparam; if (!bset) return -1; + nparam = isl_basic_set_n_param(bset); for (i = 0; i < bset->n_eq; ++i) - if (!isl_int_is_zero(bset->eq[i][1 + bset->nparam + dim])) + if (!isl_int_is_zero(bset->eq[i][1 + nparam + dim])) return 1; return 0; } diff --git a/isl_map_piplib.c b/isl_map_piplib.c index b43c42f..0c9a113 100644 --- a/isl_map_piplib.c +++ b/isl_map_piplib.c @@ -38,11 +38,15 @@ static void copy_constraint_from(isl_int *dst, PipVector *src, static int add_inequality(struct isl_ctx *ctx, struct isl_basic_map *bmap, int *pos, PipVector *vec) { + unsigned nparam = isl_basic_map_n_param(bmap); + unsigned n_in = isl_basic_map_n_in(bmap); + unsigned n_out = isl_basic_map_n_out(bmap); + unsigned n_div = isl_basic_map_n_div(bmap); int i = isl_basic_map_alloc_inequality(bmap); if (i < 0) return -1; copy_constraint_from(bmap->ineq[i], vec, - bmap->nparam, bmap->n_in, bmap->n_out, bmap->n_div, pos); + nparam, n_in, n_out, n_div, pos); return i; } @@ -60,8 +64,8 @@ static int add_div_constraints(struct isl_ctx *ctx, struct isl_basic_map *bmap, int *pos, PipNewparm *p, unsigned div) { int i, j; - unsigned div_pos = 1 + bmap->nparam + bmap->n_in + bmap->n_out + div; - unsigned total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->extra; + unsigned total = isl_basic_map_total_dim(bmap); + unsigned div_pos = 1 + total - bmap->n_div + div; i = add_inequality(ctx, bmap, pos, p->vector); if (i < 0) @@ -83,15 +87,18 @@ static int add_equality(struct isl_ctx *ctx, unsigned var, PipVector *vec) { int i; + unsigned nparam = isl_basic_map_n_param(bmap); + unsigned n_in = isl_basic_map_n_in(bmap); + unsigned n_out = isl_basic_map_n_out(bmap); - isl_assert(ctx, var < bmap->n_out, return -1); + isl_assert(ctx, var < n_out, return -1); i = isl_basic_map_alloc_equality(bmap); if (i < 0) return -1; copy_constraint_from(bmap->eq[i], vec, - bmap->nparam, bmap->n_in, bmap->n_out, bmap->extra, pos); - isl_int_set_si(bmap->eq[i][1+bmap->nparam+bmap->n_in+var], -1); + nparam, n_in, n_out, bmap->extra, pos); + isl_int_set_si(bmap->eq[i][1+nparam+n_in+var], -1); return i; } @@ -100,18 +107,21 @@ static int find_div(struct isl_ctx *ctx, struct isl_basic_map *bmap, int *pos, PipNewparm *p) { int i, j; + unsigned nparam = isl_basic_map_n_param(bmap); + unsigned n_in = isl_basic_map_n_in(bmap); + unsigned n_out = isl_basic_map_n_out(bmap); i = isl_basic_map_alloc_div(bmap); if (i < 0) return -1; copy_constraint_from(bmap->div[i]+1, p->vector, - bmap->nparam, bmap->n_in, bmap->n_out, bmap->extra, pos); + nparam, n_in, n_out, bmap->extra, pos); copy_values_from(bmap->div[i], &p->deno, 1); for (j = 0; j < i; ++j) if (isl_seq_eq(bmap->div[i], bmap->div[j], - 1+1+bmap->nparam+bmap->n_in+bmap->n_out+j)) { + 1+1+isl_basic_map_total_dim(bmap)+j)) { isl_basic_map_free_div(bmap, 1); return j; } @@ -171,13 +181,16 @@ static struct isl_map *scan_quast_r(struct scan_data *data, PipQuast *q, PipNewparm *p; struct isl_basic_map *bmap = data->bmap; unsigned old_n_div = bmap->n_div; + unsigned nparam = isl_basic_map_n_param(bmap); + unsigned n_in = isl_basic_map_n_in(bmap); + unsigned n_out = isl_basic_map_n_out(bmap); if (!map) goto error; for (p = q->newparm; p; p = p->next) { int pos; - unsigned pip_param = bmap->nparam + bmap->n_in; + unsigned pip_param = nparam + n_in; pos = find_div(data->ctx, bmap, data->pos, p); if (pos < 0) @@ -204,18 +217,18 @@ static struct isl_map *scan_quast_r(struct scan_data *data, PipQuast *q, /* if bmap->n_out is zero, we are only interested in the domains * where a solution exists and not in the actual solution */ - for (j = 0, l = q->list; j < bmap->n_out && l; ++j, l = l->next) + for (j = 0, l = q->list; j < n_out && l; ++j, l = l->next) if (add_equality(data->ctx, bmap, data->pos, j, l->vector) < 0) goto error; map = isl_map_add(map, isl_basic_map_copy(bmap)); - if (isl_basic_map_free_equality(bmap, bmap->n_out)) + if (isl_basic_map_free_equality(bmap, n_out)) goto error; } else if (map->n && data->rest) { /* not interested in rest if no sol */ struct isl_basic_set *bset; bset = isl_basic_set_from_basic_map(isl_basic_map_copy(bmap)); - bset = isl_basic_set_drop_dims(bset, bmap->n_in, bmap->n_out); + bset = isl_basic_set_drop_dims(bset, n_in, n_out); if (!bset) goto error; *data->rest = isl_set_add(*data->rest, bset); @@ -246,7 +259,9 @@ static struct isl_map *isl_map_from_quast(struct isl_ctx *ctx, PipQuast *q, int n_sol, n_nosol; struct scan_data data; struct isl_map *map; + struct isl_dim *dims; unsigned nparam; + unsigned dim; data.ctx = ctx; data.rest = rest; @@ -256,8 +271,9 @@ static struct isl_map *isl_map_from_quast(struct isl_ctx *ctx, PipQuast *q, if (!context) goto error; - nparam = context->nparam; - pip_param = nparam + context->dim; + dim = isl_basic_set_n_dim(context); + nparam = isl_basic_set_n_param(context); + pip_param = nparam + dim; max_depth = 0; n_sol = 0; @@ -267,20 +283,20 @@ static struct isl_map *isl_map_from_quast(struct isl_ctx *ctx, PipQuast *q, nexist -= pip_param-1; if (rest) { - *rest = isl_set_alloc(data.ctx, nparam, context->dim, n_nosol, + *rest = isl_set_alloc(data.ctx, nparam, dim, n_nosol, ISL_MAP_DISJOINT); if (!*rest) goto error; } - map = isl_map_alloc(data.ctx, nparam, context->dim, keep, n_sol, + map = isl_map_alloc(data.ctx, nparam, dim, keep, n_sol, ISL_MAP_DISJOINT); if (!map) goto error; - data.bmap = isl_basic_map_from_basic_set(context, - context->dim, 0); + dims = isl_dim_reverse(isl_dim_copy(context->dim)); + data.bmap = isl_basic_map_from_basic_set(context, dims); data.bmap = isl_basic_map_extend(data.bmap, - nparam, data.bmap->n_in, keep, nexist, keep, max_depth+2*nexist); + nparam, dim, keep, nexist, keep, max_depth+2*nexist); if (!data.bmap) goto error; @@ -343,8 +359,7 @@ PipMatrix *isl_basic_map_to_pip(struct isl_basic_map *bmap, unsigned pip_param, unsigned ncol; PipMatrix *M; unsigned off; - unsigned pip_var = bmap->nparam + bmap->n_in + bmap->n_out - + bmap->n_div - pip_param; + unsigned pip_var = isl_basic_map_total_dim(bmap) - pip_param; nrow = extra_front + bmap->n_eq + bmap->n_ineq; ncol = 1 + extra_front + pip_var + pip_param + extra_back + 1; @@ -376,16 +391,18 @@ static struct isl_map *extremum_on( struct isl_map *map; struct isl_ctx *ctx; PipMatrix *domain = NULL, *context = NULL; + unsigned nparam, n_in, n_out; if (!bmap || !dom) goto error; ctx = bmap->ctx; - isl_assert(ctx, bmap->nparam == dom->nparam, goto error); - isl_assert(ctx, bmap->n_in == dom->dim, goto error); + isl_assert(ctx, isl_basic_map_compatible_domain(bmap, dom), goto error); + nparam = isl_basic_map_n_param(bmap); + n_in = isl_basic_map_n_in(bmap); + n_out = isl_basic_map_n_out(bmap); - domain = isl_basic_map_to_pip(bmap, bmap->nparam + bmap->n_in, - 0, dom->n_div); + domain = isl_basic_map_to_pip(bmap, nparam + n_in, 0, dom->n_div); if (!domain) goto error; context = isl_basic_map_to_pip((struct isl_basic_map *)dom, 0, 0, 0); @@ -402,9 +419,9 @@ static struct isl_map *extremum_on( if (sol) { struct isl_basic_set *copy; copy = isl_basic_set_copy(dom); - map = isl_map_from_quast(ctx, sol, bmap->n_out, copy, empty); + map = isl_map_from_quast(ctx, sol, n_out, copy, empty); } else { - map = isl_map_empty(ctx, bmap->nparam, bmap->n_in, bmap->n_out); + map = isl_map_empty_like_basic_map(bmap); if (empty) *empty = NULL; } @@ -453,9 +470,11 @@ struct isl_map *isl_pip_basic_map_compute_divs(struct isl_basic_map *bmap) PipOptions *options; PipQuast *sol; struct isl_ctx *ctx; + struct isl_dim *dim; struct isl_map *map; struct isl_set *set; struct isl_basic_set *dom; + unsigned nparam; unsigned n_in; unsigned n_out; @@ -463,13 +482,14 @@ struct isl_map *isl_pip_basic_map_compute_divs(struct isl_basic_map *bmap) goto error; ctx = bmap->ctx; - n_in = bmap->n_in; - n_out = bmap->n_out; + nparam = isl_basic_map_n_param(bmap); + n_in = isl_basic_map_n_in(bmap); + n_out = isl_basic_map_n_out(bmap); - domain = isl_basic_map_to_pip(bmap, bmap->nparam + n_in + n_out, 0, 0); + domain = isl_basic_map_to_pip(bmap, nparam + n_in + n_out, 0, 0); if (!domain) goto error; - context = pip_matrix_alloc(0, bmap->nparam + n_in + n_out + 2); + context = pip_matrix_alloc(0, nparam + n_in + n_out + 2); if (!context) goto error; @@ -479,7 +499,7 @@ struct isl_map *isl_pip_basic_map_compute_divs(struct isl_basic_map *bmap) options->Urs_parms = -1; sol = pip_solve(domain, context, -1, options); - dom = isl_basic_set_alloc(ctx, bmap->nparam, n_in + n_out, 0, 0, 0); + dom = isl_basic_set_alloc(ctx, nparam, n_in + n_out, 0, 0, 0); map = isl_map_from_quast(ctx, sol, 0, dom, NULL); pip_quast_free(sol); @@ -487,11 +507,12 @@ struct isl_map *isl_pip_basic_map_compute_divs(struct isl_basic_map *bmap) pip_matrix_free(domain); pip_matrix_free(context); + dim = isl_dim_copy(bmap->dim); isl_basic_map_free(bmap); set = isl_map_domain(map); - return isl_map_from_set(set, n_in, n_out); + return isl_map_from_set(set, dim); error: if (domain) pip_matrix_free(domain); diff --git a/isl_map_polylib.c b/isl_map_polylib.c index d93f1d6..efce50c 100644 --- a/isl_map_polylib.c +++ b/isl_map_polylib.c @@ -41,22 +41,34 @@ static void copy_constraint_to(Value *dst, isl_int *src, static int add_equality(struct isl_ctx *ctx, struct isl_basic_map *bmap, Value *constraint) { + unsigned nparam; + unsigned n_in; + unsigned n_out; int i = isl_basic_map_alloc_equality(bmap); if (i < 0) return -1; - copy_constraint_from(bmap->eq[i], constraint, bmap->nparam, - bmap->n_in + bmap->n_out, bmap->extra); + nparam = isl_basic_map_n_param(bmap); + n_in = isl_basic_map_n_in(bmap); + n_out = isl_basic_map_n_out(bmap); + copy_constraint_from(bmap->eq[i], constraint, nparam, + n_in + n_out, bmap->extra); return 0; } static int add_inequality(struct isl_ctx *ctx, struct isl_basic_map *bmap, Value *constraint) { + unsigned nparam; + unsigned n_in; + unsigned n_out; int i = isl_basic_map_alloc_inequality(bmap); if (i < 0) return -1; - copy_constraint_from(bmap->ineq[i], constraint, bmap->nparam, - bmap->n_in + bmap->n_out, bmap->extra); + nparam = isl_basic_map_n_param(bmap); + n_in = isl_basic_map_n_in(bmap); + n_out = isl_basic_map_n_out(bmap); + copy_constraint_from(bmap->ineq[i], constraint, nparam, + n_in + n_out, bmap->extra); return 0; } @@ -65,7 +77,7 @@ static struct isl_basic_map *copy_constraints( Polyhedron *P) { int i; - unsigned total = bmap->nparam + bmap->n_in + bmap->n_out + bmap->extra; + unsigned total = isl_basic_map_total_dim(bmap); for (i = 0; i < P->NbConstraints; ++i) { if (value_zero_p(P->Constraint[i][0])) { @@ -166,22 +178,28 @@ Polyhedron *isl_basic_map_to_polylib(struct isl_basic_map *bmap) Matrix *M; Polyhedron *P; unsigned off; + unsigned nparam; + unsigned n_in; + unsigned n_out; if (!bmap) return NULL; + nparam = isl_basic_map_n_param(bmap); + n_in = isl_basic_map_n_in(bmap); + n_out = isl_basic_map_n_out(bmap); M = Matrix_Alloc(bmap->n_eq + bmap->n_ineq, - 1 + bmap->n_in + bmap->n_out + bmap->n_div + bmap->nparam + 1); + 1 + n_in + n_out + bmap->n_div + nparam + 1); for (i = 0; i < bmap->n_eq; ++i) { value_set_si(M->p[i][0], 0); copy_constraint_to(M->p[i], bmap->eq[i], - bmap->nparam, bmap->n_in + bmap->n_out, bmap->n_div); + nparam, n_in + n_out, bmap->n_div); } off = bmap->n_eq; for (i = 0; i < bmap->n_ineq; ++i) { value_set_si(M->p[off+i][0], 1); copy_constraint_to(M->p[off+i], bmap->ineq[i], - bmap->nparam, bmap->n_in + bmap->n_out, bmap->n_div); + nparam, n_in + n_out, bmap->n_div); } P = Constraints2Polyhedron(M, bmap->ctx->MaxRays); Matrix_Free(M); @@ -203,7 +221,7 @@ Polyhedron *isl_map_to_polylib(struct isl_map *map) next = &(*next)->next; } - return R ? R : Empty_Polyhedron(map->nparam + map->n_in + map->n_out); + return R ? R : Empty_Polyhedron(isl_dim_total(map->dim)); } Polyhedron *isl_basic_set_to_polylib(struct isl_basic_set *bset) diff --git a/isl_map_private.h b/isl_map_private.h index e90c83d..7e7a93a 100644 --- a/isl_map_private.h +++ b/isl_map_private.h @@ -1,6 +1,25 @@ #include "isl_set.h" #include "isl_map.h" +int isl_map_compatible_domain(struct isl_map *map, struct isl_set *set); +int isl_basic_map_compatible_domain(struct isl_basic_map *bmap, + struct isl_basic_set *bset); +int isl_basic_map_compatible_range(struct isl_basic_map *bmap, + struct isl_basic_set *bset); + +struct isl_basic_set *isl_basic_set_alloc_dim(struct isl_ctx *ctx, + struct isl_dim *dim, unsigned extra, + unsigned n_eq, unsigned n_ineq); +struct isl_set *isl_set_alloc_dim(struct isl_ctx *ctx, + struct isl_dim *dim, int n, unsigned flags); +struct isl_basic_map *isl_basic_map_alloc_dim(struct isl_ctx *ctx, + struct isl_dim *dim, unsigned extra, + unsigned n_eq, unsigned n_ineq); +struct isl_map *isl_map_alloc_dim(struct isl_ctx *ctx, + struct isl_dim *dim, int n, unsigned flags); + +unsigned isl_basic_map_total_dim(const struct isl_basic_map *bmap); + int isl_basic_map_alloc_equality(struct isl_basic_map *bmap); int isl_basic_set_alloc_equality(struct isl_basic_set *bset); int isl_basic_set_free_inequality(struct isl_basic_set *bset, unsigned n); diff --git a/isl_mat.c b/isl_mat.c index 0a26e72..e663838 100644 --- a/isl_mat.c +++ b/isl_mat.c @@ -1,3 +1,4 @@ +#include "isl_dim.h" #include "isl_seq.h" #include "isl_mat.h" #include "isl_map_private.h" @@ -687,15 +688,18 @@ struct isl_basic_set *isl_basic_set_preimage(struct isl_ctx *ctx, if (!bset) goto error; - isl_assert(ctx, bset->nparam == 0, goto error); + isl_assert(ctx, bset->dim->nparam == 0, goto error); isl_assert(ctx, bset->n_div == 0, goto error); - isl_assert(ctx, 1+bset->dim == mat->n_row, goto error); + isl_assert(ctx, 1+bset->dim->n_out == mat->n_row, goto error); if (mat->n_col > mat->n_row) bset = isl_basic_set_extend(bset, 0, mat->n_col-1, 0, 0, 0); - else { - bset->dim -= mat->n_row - mat->n_col; + else if (mat->n_col < mat->n_row) { + bset->dim = isl_dim_cow(bset->dim); + if (!bset->dim) + goto error; + bset->dim->n_out -= mat->n_row - mat->n_col; bset->extra += mat->n_row - mat->n_col; } @@ -746,8 +750,13 @@ struct isl_set *isl_set_preimage(struct isl_ctx *ctx, if (!set->p[i]) goto error; } - set->dim += mat->n_col; - set->dim -= mat->n_row; + if (mat->n_col != mat->n_row) { + set->dim = isl_dim_cow(set->dim); + if (!set->dim) + goto error; + set->dim->n_out += mat->n_col; + set->dim->n_out -= mat->n_row; + } isl_mat_free(ctx, mat); return set; error: diff --git a/isl_output.c b/isl_output.c index bffa5ba..4406a04 100644 --- a/isl_output.c +++ b/isl_output.c @@ -5,19 +5,21 @@ static void print_constraint_polylib(struct isl_basic_set *bset, FILE *out, int indent, const char *prefix, const char *suffix) { int i; + unsigned dim = isl_basic_set_n_dim(bset); + unsigned nparam = isl_basic_set_n_param(bset); isl_int *c = ineq ? bset->ineq[n] : bset->eq[n]; fprintf(out, "%*s%s", indent, "", prefix ? prefix : ""); fprintf(out, "%d", ineq); - for (i = 0; i < bset->dim; ++i) { + for (i = 0; i < dim; ++i) { fprintf(out, " "); - isl_int_print(out, c[1+bset->nparam+i], 5); + isl_int_print(out, c[1+nparam+i], 5); } for (i = 0; i < bset->n_div; ++i) { fprintf(out, " "); - isl_int_print(out, c[1+bset->nparam+bset->dim+i], 5); + isl_int_print(out, c[1+nparam+dim+i], 5); } - for (i = 0; i < bset->nparam; ++i) { + for (i = 0; i < nparam; ++i) { fprintf(out, " "); isl_int_print(out, c[1+i], 5); } @@ -42,7 +44,7 @@ static void print_constraints_polylib(struct isl_basic_set *bset, static void isl_basic_set_print_polylib(struct isl_basic_set *bset, FILE *out, int indent, const char *prefix, const char *suffix) { - unsigned total = bset->nparam + bset->dim + bset->n_div; + unsigned total = isl_basic_set_total_dim(bset); fprintf(out, "%*s%s", indent, "", prefix ? prefix : ""); fprintf(out, "%d %d", bset->n_eq + bset->n_ineq, 1 + total + 1); fprintf(out, "%s\n", suffix ? suffix : ""); diff --git a/isl_sample.c b/isl_sample.c index 2a62368..1a4c5a7 100644 --- a/isl_sample.c +++ b/isl_sample.c @@ -61,18 +61,20 @@ static struct isl_mat *independent_bounds(struct isl_ctx *ctx, { int i, j, n; struct isl_mat *dirs = NULL; + unsigned dim; if (!bset) return NULL; + dim = isl_basic_set_n_dim(bset); if (bset->n_ineq == 0) - return isl_mat_alloc(ctx, 0, bset->dim); + return isl_mat_alloc(ctx, 0, dim); - dirs = isl_mat_alloc(ctx, bset->dim, bset->dim); + dirs = isl_mat_alloc(ctx, dim, dim); if (!dirs) return NULL; isl_seq_cpy(dirs->row[0], bset->ineq[0]+1, dirs->n_col); - for (j = 1, n = 1; n < bset->dim && j < bset->n_ineq; ++j) { + for (j = 1, n = 1; n < dim && j < bset->n_ineq; ++j) { int pos; isl_seq_cpy(dirs->row[n], bset->ineq[j]+1, dirs->n_col); @@ -114,7 +116,7 @@ static struct isl_basic_set *remove_lineality(struct isl_ctx *ctx, struct isl_mat *U = NULL; unsigned old_dim, new_dim; - old_dim = bset->dim; + old_dim = isl_basic_set_n_dim(bset); new_dim = bounds->n_row; *T = NULL; bounds = isl_mat_left_hermite(ctx, bounds, 0, &U, NULL); @@ -139,6 +141,7 @@ struct isl_vec *isl_basic_set_sample(struct isl_basic_set *bset) { struct isl_ctx *ctx; struct isl_mat *bounds; + unsigned dim; if (!bset) return NULL; @@ -148,7 +151,8 @@ struct isl_vec *isl_basic_set_sample(struct isl_basic_set *bset) return isl_vec_alloc(ctx, 0); } - isl_assert(ctx, bset->nparam == 0, goto error); + dim = isl_basic_set_n_dim(bset); + isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error); isl_assert(ctx, bset->n_div == 0, goto error); if (bset->n_eq > 0) { @@ -163,14 +167,14 @@ struct isl_vec *isl_basic_set_sample(struct isl_basic_set *bset) isl_mat_free(ctx, T); return sample; } - if (bset->dim == 0) + if (dim == 0) return point_sample(ctx, bset); - if (bset->dim == 1) + if (dim == 1) return interval_sample(ctx, bset); bounds = independent_bounds(ctx, bset); if (!bounds) goto error; - if (bounds->n_row == bset->dim) + if (bounds->n_row == dim) isl_mat_free(ctx, bounds); else { struct isl_mat *T; diff --git a/isl_sample_piplib.c b/isl_sample_piplib.c index 3d4c700..a514ea7 100644 --- a/isl_sample_piplib.c +++ b/isl_sample_piplib.c @@ -17,29 +17,31 @@ static struct isl_mat *independent_bounds(struct isl_ctx *ctx, int i, j, n; struct isl_mat *dirs = NULL; struct isl_mat *bounds = NULL; + unsigned dim; if (!bset) return NULL; - bounds = isl_mat_alloc(ctx, 1+bset->dim, 1+bset->dim); + dim = isl_basic_set_n_dim(bset); + bounds = isl_mat_alloc(ctx, 1+dim, 1+dim); if (!bounds) return NULL; isl_int_set_si(bounds->row[0][0], 1); - isl_seq_clr(bounds->row[0]+1, bset->dim); + isl_seq_clr(bounds->row[0]+1, dim); bounds->n_row = 1; if (bset->n_ineq == 0) return bounds; - dirs = isl_mat_alloc(ctx, bset->dim, bset->dim); + dirs = isl_mat_alloc(ctx, dim, dim); if (!dirs) { isl_mat_free(ctx, bounds); return NULL; } isl_seq_cpy(dirs->row[0], bset->ineq[0]+1, dirs->n_col); isl_seq_cpy(bounds->row[1], bset->ineq[0], bounds->n_col); - for (j = 1, n = 1; n < bset->dim && j < bset->n_ineq; ++j) { + for (j = 1, n = 1; n < dim && j < bset->n_ineq; ++j) { int pos; isl_seq_cpy(dirs->row[n], bset->ineq[j]+1, dirs->n_col); @@ -92,18 +94,18 @@ static struct isl_basic_set *isl_basic_set_skew_to_positive_orthant( return NULL; ctx = bset->ctx; - isl_assert(ctx, bset->nparam == 0, goto error); + isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error); isl_assert(ctx, bset->n_div == 0, goto error); isl_assert(ctx, bset->n_eq == 0, goto error); + old_dim = isl_basic_set_n_dim(bset); /* Try to move (multiples of) unit rows up. */ for (i = 0, j = 0; i < bset->n_ineq; ++i) { - int pos = isl_seq_first_non_zero(bset->ineq[i]+1, - bset->dim); + int pos = isl_seq_first_non_zero(bset->ineq[i]+1, old_dim); if (pos < 0) continue; if (isl_seq_first_non_zero(bset->ineq[i]+1+pos+1, - bset->dim-pos-1) >= 0) + old_dim-pos-1) >= 0) continue; if (i != j) swap_inequality(bset, i, j); @@ -112,7 +114,6 @@ static struct isl_basic_set *isl_basic_set_skew_to_positive_orthant( bounds = independent_bounds(ctx, bset); if (!bounds) goto error; - old_dim = bset->dim; new_dim = bounds->n_row - 1; bounds = isl_mat_left_hermite(ctx, bounds, 1, &U, NULL); if (!bounds) @@ -144,12 +145,12 @@ struct isl_vec *isl_pip_basic_set_sample(struct isl_basic_set *bset) if (!bset) goto error; ctx = bset->ctx; - isl_assert(ctx, bset->nparam == 0, goto error); + isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error); isl_assert(ctx, bset->n_div == 0, goto error); bset = isl_basic_set_skew_to_positive_orthant(bset, &T); if (!bset) goto error; - dim = bset->dim; + dim = isl_basic_set_n_dim(bset); domain = isl_basic_map_to_pip((struct isl_basic_map *)bset, 0, 0, 0); if (!domain) goto error; -- 2.7.4