From 3280c051ef3dc4b05fbe855340547ace629071c6 Mon Sep 17 00:00:00 2001 From: Sven Verdoolaege Date: Tue, 30 Aug 2011 16:47:59 +0200 Subject: [PATCH] make isl_pw_* object live in a map space Before, the space of an isl_pw_* object was that of the cells. Conceptually, however, they map elements from these cells to something and so their space should be that of a map. This is especially useful for isl_pw_multi_aff objects that will be introduced later. Since we want to be able to convert back and forth between such objects and isl_maps, we need to keep track of the complete map space. isl_aff, isl_qpolynomial and isl_qpolynomial_fold objects now also live in a map space, although internally, they still keep track of the domain space. Signed-off-by: Sven Verdoolaege --- doc/user.pod | 62 ++++++++++++----- include/isl/aff.h | 6 +- include/isl/polynomial.h | 27 ++++---- isl_aff.c | 146 ++++++++++++++++++++++++++++++++++------ isl_aff_private.h | 10 ++- isl_bernstein.c | 38 ++++++----- isl_bound.c | 19 ++++-- isl_constraint.c | 8 ++- isl_div.c | 2 +- isl_fold.c | 68 +++++++++++++------ isl_input.c | 27 +++++--- isl_map.c | 3 +- isl_output.c | 14 ++-- isl_polynomial.c | 169 +++++++++++++++++++++++++++++++++++------------ isl_polynomial_private.h | 39 ++++++++--- isl_pw_templ.c | 140 +++++++++++++++++++++++++++++---------- isl_range.c | 37 ++++++----- isl_test.c | 14 ++-- isl_union_templ.c | 29 +++++++- 19 files changed, 622 insertions(+), 236 deletions(-) diff --git a/doc/user.pod b/doc/user.pod index 5031e204..b5be80f2 100644 --- a/doc/user.pod +++ b/doc/user.pod @@ -112,6 +112,15 @@ of explicitly creating a parameter space. These can now be created directly using C or from other spaces using C. +=item * The space in which C, C, C, +C, C and C +objects live is now a map space +instead of a set space. This means, for example, that the dimensions +of the domain of an C are now considered to be of type +C instead of C. Extra functions have been +added to obtain the domain space. Some of the constructors still +take a domain space and have therefore been renamed. + =back =head1 Installation @@ -533,20 +542,32 @@ of the original object. __isl_keep isl_constraint *constraint); #include + __isl_give isl_space *isl_qpolynomial_get_domain_space( + __isl_keep isl_qpolynomial *qp); __isl_give isl_space *isl_qpolynomial_get_space( __isl_keep isl_qpolynomial *qp); __isl_give isl_space *isl_qpolynomial_fold_get_space( __isl_keep isl_qpolynomial_fold *fold); + __isl_give isl_space *isl_pw_qpolynomial_get_domain_space( + __isl_keep isl_pw_qpolynomial *pwqp); __isl_give isl_space *isl_pw_qpolynomial_get_space( __isl_keep isl_pw_qpolynomial *pwqp); + __isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space( + __isl_keep isl_pw_qpolynomial_fold *pwf); + __isl_give isl_space *isl_pw_qpolynomial_fold_get_space( + __isl_keep isl_pw_qpolynomial_fold *pwf); __isl_give isl_space *isl_union_pw_qpolynomial_get_space( __isl_keep isl_union_pw_qpolynomial *upwqp); __isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space( __isl_keep isl_union_pw_qpolynomial_fold *upwf); #include + __isl_give isl_space *isl_aff_get_domain_space( + __isl_keep isl_aff *aff); __isl_give isl_space *isl_aff_get_space( __isl_keep isl_aff *aff); + __isl_give isl_space *isl_pw_aff_get_domain_space( + __isl_keep isl_pw_aff *pwaff); __isl_give isl_space *isl_pw_aff_get_space( __isl_keep isl_pw_aff *pwaff); @@ -2449,11 +2470,14 @@ the original and the kernel (in that order) is the zero matrix. =head2 Piecewise Quasi Affine Expressions -The zero quasi affine expression can be created using +The zero quasi affine expression on a given domain can be created using - __isl_give isl_aff *isl_aff_zero( + __isl_give isl_aff *isl_aff_zero_on_domain( __isl_take isl_local_space *ls); +Note that the space in which the resulting object lives is a map space +with the given space as domain and a one-dimensional range. + A quasi affine expression can also be initialized from an C: #include @@ -2512,6 +2536,8 @@ The expression can be inspected using isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff); int isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type); + __isl_give isl_local_space *isl_aff_get_domain_local_space( + __isl_keep isl_aff *aff); __isl_give isl_local_space *isl_aff_get_local_space( __isl_keep isl_aff *aff); const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff, @@ -2932,27 +2958,31 @@ More complicated quasipolynomials can be created by applying operations such as addition and multiplication on the resulting quasipolynomials - __isl_give isl_qpolynomial *isl_qpolynomial_zero( - __isl_take isl_space *dim); - __isl_give isl_qpolynomial *isl_qpolynomial_one( - __isl_take isl_space *dim); - __isl_give isl_qpolynomial *isl_qpolynomial_infty( - __isl_take isl_space *dim); - __isl_give isl_qpolynomial *isl_qpolynomial_neginfty( - __isl_take isl_space *dim); - __isl_give isl_qpolynomial *isl_qpolynomial_nan( - __isl_take isl_space *dim); - __isl_give isl_qpolynomial *isl_qpolynomial_rat_cst( - __isl_take isl_space *dim, + __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain( + __isl_take isl_space *domain); + __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain( + __isl_take isl_space *domain); + __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain( + __isl_take isl_space *domain); + __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain( + __isl_take isl_space *domain); + __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain( + __isl_take isl_space *domain); + __isl_give isl_qpolynomial *isl_qpolynomial_rat_cst_on_domain( + __isl_take isl_space *domain, const isl_int n, const isl_int d); __isl_give isl_qpolynomial *isl_qpolynomial_div( __isl_take isl_div *div); - __isl_give isl_qpolynomial *isl_qpolynomial_var( - __isl_take isl_space *dim, + __isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain( + __isl_take isl_space *domain, enum isl_dim_type type, unsigned pos); __isl_give isl_qpolynomial *isl_qpolynomial_from_aff( __isl_take isl_aff *aff); +Note that the space in which a quasipolynomial lives is a map space +with a one-dimensional range. The C argument in some of +the functions above corresponds to the domain of this map space. + The zero piecewise quasipolynomial or a piecewise quasipolynomial with a single cell can be created using the following functions. Multiple of these single cell piecewise quasipolynomials can diff --git a/include/isl/aff.h b/include/isl/aff.h index 84a33f55..058b062d 100644 --- a/include/isl/aff.h +++ b/include/isl/aff.h @@ -12,7 +12,7 @@ extern "C" { #endif -__isl_give isl_aff *isl_aff_zero(__isl_take isl_local_space *ls); +__isl_give isl_aff *isl_aff_zero_on_domain(__isl_take isl_local_space *ls); __isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff); void *isl_aff_free(__isl_take isl_aff *aff); @@ -23,7 +23,10 @@ int isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type); int isl_aff_involves_dims(__isl_keep isl_aff *aff, enum isl_dim_type type, unsigned first, unsigned n); +__isl_give isl_space *isl_aff_get_domain_space(__isl_keep isl_aff *aff); __isl_give isl_space *isl_aff_get_space(__isl_keep isl_aff *aff); +__isl_give isl_local_space *isl_aff_get_domain_local_space( + __isl_keep isl_aff *aff); __isl_give isl_local_space *isl_aff_get_local_space(__isl_keep isl_aff *aff); const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff, @@ -92,6 +95,7 @@ __isl_give isl_printer *isl_printer_print_aff(__isl_take isl_printer *p, void isl_aff_dump(__isl_keep isl_aff *aff); isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pwaff); +__isl_give isl_space *isl_pw_aff_get_domain_space(__isl_keep isl_pw_aff *pwaff); __isl_give isl_space *isl_pw_aff_get_space(__isl_keep isl_pw_aff *pwaff); __isl_give isl_pw_aff *isl_pw_aff_from_aff(__isl_take isl_aff *aff); diff --git a/include/isl/polynomial.h b/include/isl/polynomial.h index 0f3c0ab5..a4688452 100644 --- a/include/isl/polynomial.h +++ b/include/isl/polynomial.h @@ -17,9 +17,9 @@ extern "C" { #endif isl_ctx *isl_qpolynomial_get_ctx(__isl_keep isl_qpolynomial *qp); +__isl_give isl_space *isl_qpolynomial_get_domain_space( + __isl_keep isl_qpolynomial *qp); __isl_give isl_space *isl_qpolynomial_get_space(__isl_keep isl_qpolynomial *qp); -__isl_give isl_qpolynomial *isl_qpolynomial_reset_space( - __isl_take isl_qpolynomial *qp, __isl_take isl_space *dim); unsigned isl_qpolynomial_dim(__isl_keep isl_qpolynomial *qp, enum isl_dim_type type); int isl_qpolynomial_involves_dims(__isl_keep isl_qpolynomial *qp, @@ -29,15 +29,15 @@ __isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name( __isl_take isl_qpolynomial *qp, enum isl_dim_type type, unsigned pos, const char *s); -__isl_give isl_qpolynomial *isl_qpolynomial_zero(__isl_take isl_space *dim); -__isl_give isl_qpolynomial *isl_qpolynomial_one(__isl_take isl_space *dim); -__isl_give isl_qpolynomial *isl_qpolynomial_infty(__isl_take isl_space *dim); -__isl_give isl_qpolynomial *isl_qpolynomial_neginfty(__isl_take isl_space *dim); -__isl_give isl_qpolynomial *isl_qpolynomial_nan(__isl_take isl_space *dim); -__isl_give isl_qpolynomial *isl_qpolynomial_rat_cst(__isl_take isl_space *dim, +__isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(__isl_take isl_space *dim); +__isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(__isl_take isl_space *dim); +__isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(__isl_take isl_space *dim); +__isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(__isl_take isl_space *dim); +__isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(__isl_take isl_space *dim); +__isl_give isl_qpolynomial *isl_qpolynomial_rat_cst_on_domain(__isl_take isl_space *dim, const isl_int n, const isl_int d); __isl_give isl_qpolynomial *isl_qpolynomial_div(__isl_take isl_div *div); -__isl_give isl_qpolynomial *isl_qpolynomial_var(__isl_take isl_space *dim, +__isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(__isl_take isl_space *dim, enum isl_dim_type type, unsigned pos); __isl_give isl_qpolynomial *isl_qpolynomial_copy(__isl_keep isl_qpolynomial *qp); void *isl_qpolynomial_free(__isl_take isl_qpolynomial *qp); @@ -147,9 +147,11 @@ void *isl_pw_qpolynomial_free(__isl_take isl_pw_qpolynomial *pwqp); int isl_pw_qpolynomial_is_zero(__isl_keep isl_pw_qpolynomial *pwqp); +__isl_give isl_space *isl_pw_qpolynomial_get_domain_space( + __isl_keep isl_pw_qpolynomial *pwqp); __isl_give isl_space *isl_pw_qpolynomial_get_space( __isl_keep isl_pw_qpolynomial *pwqp); -__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_reset_space( +__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_reset_domain_space( __isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_space *dim); unsigned isl_pw_qpolynomial_dim(__isl_keep isl_pw_qpolynomial *pwqp, enum isl_dim_type type); @@ -260,9 +262,6 @@ __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy( __isl_keep isl_qpolynomial_fold *fold); void isl_qpolynomial_fold_free(__isl_take isl_qpolynomial_fold *fold); -__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_space( - __isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *dim); - int isl_qpolynomial_fold_is_empty(__isl_keep isl_qpolynomial_fold *fold); int isl_qpolynomial_fold_plain_is_equal(__isl_keep isl_qpolynomial_fold *fold1, __isl_keep isl_qpolynomial_fold *fold2); @@ -316,6 +315,8 @@ void *isl_pw_qpolynomial_fold_free(__isl_take isl_pw_qpolynomial_fold *pwf); int isl_pw_qpolynomial_fold_is_zero(__isl_keep isl_pw_qpolynomial_fold *pwf); +__isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space( + __isl_keep isl_pw_qpolynomial_fold *pwf); __isl_give isl_space *isl_pw_qpolynomial_fold_get_space( __isl_keep isl_pw_qpolynomial_fold *pwf); __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_reset_space( diff --git a/isl_aff.c b/isl_aff.c index 26095b2b..437e44fb 100644 --- a/isl_aff.c +++ b/isl_aff.c @@ -56,6 +56,10 @@ __isl_give isl_aff *isl_aff_alloc(__isl_take isl_local_space *ls) if (!isl_local_space_divs_known(ls)) isl_die(ctx, isl_error_invalid, "local space has unknown divs", goto error); + if (!isl_local_space_is_set(ls)) + isl_die(ctx, isl_error_invalid, + "domain of affine expression should be a set", + goto error); total = isl_local_space_dim(ls, isl_dim_all); v = isl_vec_alloc(ctx, 1 + 1 + total); @@ -65,7 +69,7 @@ error: return NULL; } -__isl_give isl_aff *isl_aff_zero(__isl_take isl_local_space *ls) +__isl_give isl_aff *isl_aff_zero_on_domain(__isl_take isl_local_space *ls) { isl_aff *aff; @@ -129,28 +133,69 @@ isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff) return aff ? isl_local_space_get_ctx(aff->ls) : NULL; } +/* Externally, an isl_aff has a map space, but internally, the + * ls field corresponds to the domain of that space. + */ int isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type) { - return aff ? isl_local_space_dim(aff->ls, type) : 0; + if (!aff) + return 0; + if (type == isl_dim_out) + return 1; + if (type == isl_dim_in) + type = isl_dim_set; + return isl_local_space_dim(aff->ls, type); } -__isl_give isl_space *isl_aff_get_space(__isl_keep isl_aff *aff) +__isl_give isl_space *isl_aff_get_domain_space(__isl_keep isl_aff *aff) { return aff ? isl_local_space_get_space(aff->ls) : NULL; } -__isl_give isl_local_space *isl_aff_get_local_space(__isl_keep isl_aff *aff) +__isl_give isl_space *isl_aff_get_space(__isl_keep isl_aff *aff) +{ + isl_space *space; + if (!aff) + return NULL; + space = isl_local_space_get_space(aff->ls); + space = isl_space_from_domain(space); + space = isl_space_add_dims(space, isl_dim_out, 1); + return space; +} + +__isl_give isl_local_space *isl_aff_get_domain_local_space( + __isl_keep isl_aff *aff) { return aff ? isl_local_space_copy(aff->ls) : NULL; } +__isl_give isl_local_space *isl_aff_get_local_space(__isl_keep isl_aff *aff) +{ + isl_local_space *ls; + if (!aff) + return NULL; + ls = isl_local_space_copy(aff->ls); + ls = isl_local_space_from_domain(ls); + ls = isl_local_space_add_dims(ls, isl_dim_out, 1); + return ls; +} + +/* Externally, an isl_aff has a map space, but internally, the + * ls field corresponds to the domain of that space. + */ const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff, enum isl_dim_type type, unsigned pos) { - return aff ? isl_local_space_get_dim_name(aff->ls, type, pos) : 0; + if (!aff) + return NULL; + if (type == isl_dim_out) + return NULL; + if (type == isl_dim_in) + type = isl_dim_set; + return isl_local_space_get_dim_name(aff->ls, type, pos); } -__isl_give isl_aff *isl_aff_reset_space(__isl_take isl_aff *aff, +__isl_give isl_aff *isl_aff_reset_domain_space(__isl_take isl_aff *aff, __isl_take isl_space *dim) { aff = isl_aff_cow(aff); @@ -168,6 +213,17 @@ error: return NULL; } +/* Reset the space of "aff". This function is called from isl_pw_templ.c + * and doesn't know if the space of an element object is represented + * directly or through its domain. It therefore passes along both. + */ +__isl_give isl_aff *isl_aff_reset_space_and_domain(__isl_take isl_aff *aff, + __isl_take isl_space *space, __isl_take isl_space *domain) +{ + isl_space_free(space); + return isl_aff_reset_domain_space(aff, domain); +} + /* Reorder the coefficients of the affine expression based * on the given reodering. * The reordering r is assumed to have been extended with the local @@ -198,9 +254,10 @@ error: return NULL; } -/* Reorder the dimensions of "aff" according to the given reordering. +/* Reorder the dimensions of the domain of "aff" according + * to the given reordering. */ -__isl_give isl_aff *isl_aff_realign(__isl_take isl_aff *aff, +__isl_give isl_aff *isl_aff_realign_domain(__isl_take isl_aff *aff, __isl_take isl_reordering *r) { aff = isl_aff_cow(aff); @@ -266,6 +323,13 @@ int isl_aff_get_coefficient(__isl_keep isl_aff *aff, if (!aff) return -1; + if (type == isl_dim_out) + isl_die(aff->v->ctx, isl_error_invalid, + "output/set dimension does not have a coefficient", + return -1); + if (type == isl_dim_in) + type = isl_dim_set; + if (pos >= isl_local_space_dim(aff->ls, type)) isl_die(aff->v->ctx, isl_error_invalid, "position out of bounds", return -1); @@ -357,6 +421,13 @@ __isl_give isl_aff *isl_aff_set_coefficient(__isl_take isl_aff *aff, if (!aff) return NULL; + if (type == isl_dim_out) + isl_die(aff->v->ctx, isl_error_invalid, + "output/set dimension does not have a coefficient", + return isl_aff_free(aff)); + if (type == isl_dim_in) + type = isl_dim_set; + if (pos >= isl_local_space_dim(aff->ls, type)) isl_die(aff->v->ctx, isl_error_invalid, "position out of bounds", return isl_aff_free(aff)); @@ -381,6 +452,13 @@ __isl_give isl_aff *isl_aff_set_coefficient_si(__isl_take isl_aff *aff, if (!aff) return NULL; + if (type == isl_dim_out) + isl_die(aff->v->ctx, isl_error_invalid, + "output/set dimension does not have a coefficient", + return isl_aff_free(aff)); + if (type == isl_dim_in) + type = isl_dim_set; + if (pos >= isl_local_space_dim(aff->ls, type)) isl_die(aff->v->ctx, isl_error_invalid, "position out of bounds", return isl_aff_free(aff)); @@ -405,6 +483,13 @@ __isl_give isl_aff *isl_aff_add_coefficient(__isl_take isl_aff *aff, if (!aff) return NULL; + if (type == isl_dim_out) + isl_die(aff->v->ctx, isl_error_invalid, + "output/set dimension does not have a coefficient", + return isl_aff_free(aff)); + if (type == isl_dim_in) + type = isl_dim_set; + if (pos >= isl_local_space_dim(aff->ls, type)) isl_die(aff->v->ctx, isl_error_invalid, "position out of bounds", return isl_aff_free(aff)); @@ -764,6 +849,12 @@ __isl_give isl_aff *isl_aff_set_dim_name(__isl_take isl_aff *aff, aff = isl_aff_cow(aff); if (!aff) return NULL; + if (type == isl_dim_out) + isl_die(aff->v->ctx, isl_error_invalid, + "cannot set name of output/set dimension", + return isl_aff_free(aff)); + if (type == isl_dim_in) + type = isl_dim_set; aff->ls = isl_local_space_set_dim_name(aff->ls, type, pos, s); if (!aff->ls) return isl_aff_free(aff); @@ -854,9 +945,10 @@ __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff, n_div = isl_local_space_dim(aff->ls, isl_dim_div); if (n_div > 0) { isl_basic_set *bset; + isl_local_space *ls; context = isl_set_add_dims(context, isl_dim_set, n_div); - bset = isl_basic_set_from_local_space( - isl_aff_get_local_space(aff)); + ls = isl_aff_get_domain_local_space(aff); + bset = isl_basic_set_from_local_space(ls); bset = isl_basic_set_lift(bset); bset = isl_basic_set_flatten(bset); context = isl_set_intersect(context, @@ -980,11 +1072,17 @@ __isl_give isl_aff *isl_aff_drop_dims(__isl_take isl_aff *aff, if (!aff) return NULL; + if (type == isl_dim_out) + isl_die(aff->v->ctx, isl_error_invalid, + "cannot drop output/set dimension", + return isl_aff_free(aff)); + if (type == isl_dim_in) + type = isl_dim_set; if (n == 0 && !isl_local_space_is_named_or_nested(aff->ls, type)) return aff; ctx = isl_aff_get_ctx(aff); - if (first + n > isl_aff_dim(aff, type)) + if (first + n > isl_local_space_dim(aff->ls, type)) isl_die(ctx, isl_error_invalid, "range out of bounds", return isl_aff_free(aff)); @@ -1011,11 +1109,17 @@ __isl_give isl_aff *isl_aff_insert_dims(__isl_take isl_aff *aff, if (!aff) return NULL; + if (type == isl_dim_out) + isl_die(aff->v->ctx, isl_error_invalid, + "cannot insert output/set dimensions", + return isl_aff_free(aff)); + if (type == isl_dim_in) + type = isl_dim_set; if (n == 0 && !isl_local_space_is_named_or_nested(aff->ls, type)) return aff; ctx = isl_aff_get_ctx(aff); - if (first > isl_aff_dim(aff, type)) + if (first > isl_local_space_dim(aff->ls, type)) isl_die(ctx, isl_error_invalid, "position out of bounds", return isl_aff_free(aff)); @@ -1061,14 +1165,14 @@ __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(__isl_take isl_pw_aff *pwaff, isl_space *dim; dim = isl_pw_aff_get_space(pwaff); - dim = isl_space_set_tuple_id(dim, isl_dim_set, id); + dim = isl_space_set_tuple_id(dim, isl_dim_in, id); return isl_pw_aff_reset_space(pwaff, dim); } __isl_give isl_pw_aff *isl_pw_aff_from_aff(__isl_take isl_aff *aff) { - isl_set *dom = isl_set_universe(isl_aff_get_space(aff)); + isl_set *dom = isl_set_universe(isl_aff_get_domain_space(aff)); return isl_pw_aff_alloc(dom, aff); } @@ -1257,8 +1361,6 @@ static __isl_give isl_map *map_from_pw_aff(__isl_take isl_pw_aff *pwaff) return NULL; dim = isl_pw_aff_get_space(pwaff); - dim = isl_space_from_domain(dim); - dim = isl_space_add_dims(dim, isl_dim_out, 1); map = isl_map_empty(dim); for (i = 0; i < pwaff->n; ++i) { @@ -1282,7 +1384,7 @@ static __isl_give isl_map *map_from_pw_aff(__isl_take isl_pw_aff *pwaff) */ __isl_give isl_map *isl_map_from_pw_aff(__isl_take isl_pw_aff *pwaff) { - if (isl_space_is_params(pwaff->dim)) + if (isl_space_is_set(pwaff->dim)) isl_die(isl_pw_aff_get_ctx(pwaff), isl_error_invalid, "space of input is not a map", return isl_pw_aff_free(pwaff)); @@ -1295,7 +1397,7 @@ __isl_give isl_map *isl_map_from_pw_aff(__isl_take isl_pw_aff *pwaff) */ __isl_give isl_set *isl_set_from_pw_aff(__isl_take isl_pw_aff *pwaff) { - if (!isl_space_is_params(pwaff->dim)) + if (!isl_space_is_set(pwaff->dim)) isl_die(isl_pw_aff_get_ctx(pwaff), isl_error_invalid, "space of input is not a set", return isl_pw_aff_free(pwaff)); @@ -1313,7 +1415,7 @@ __isl_give isl_set *isl_pw_aff_nonneg_set(__isl_take isl_pw_aff *pwaff) if (!pwaff) return NULL; - set = isl_set_empty(isl_pw_aff_get_space(pwaff)); + set = isl_set_empty(isl_pw_aff_get_domain_space(pwaff)); for (i = 0; i < pwaff->n; ++i) { isl_basic_set *bset; @@ -1341,7 +1443,7 @@ __isl_give isl_set *isl_pw_aff_zero_set(__isl_take isl_pw_aff *pwaff) if (!pwaff) return NULL; - set = isl_set_empty(isl_pw_aff_get_space(pwaff)); + set = isl_set_empty(isl_pw_aff_get_domain_space(pwaff)); for (i = 0; i < pwaff->n; ++i) { isl_basic_set *bset; @@ -1390,7 +1492,7 @@ static __isl_give isl_set *pw_aff_gte_set(__isl_take isl_pw_aff *pwaff1, if (strict) { isl_space *dim = isl_set_get_space(set1); isl_aff *aff; - aff = isl_aff_zero(isl_local_space_from_space(dim)); + aff = isl_aff_zero_on_domain(isl_local_space_from_space(dim)); aff = isl_aff_add_constant_si(aff, -1); pwaff1 = isl_pw_aff_add(pwaff1, isl_pw_aff_alloc(set1, aff)); } else @@ -1479,7 +1581,7 @@ static __isl_give isl_set *pw_aff_list_set(__isl_take isl_pw_aff_list *list1, isl_die(ctx, isl_error_invalid, "list should contain at least one element", goto error); - set = isl_set_universe(isl_pw_aff_get_space(list1->p[0])); + set = isl_set_universe(isl_pw_aff_get_domain_space(list1->p[0])); for (i = 0; i < list1->n; ++i) for (j = 0; j < list2->n; ++j) { isl_set *set_ij; diff --git a/isl_aff_private.h b/isl_aff_private.h index a6951e9a..54705f68 100644 --- a/isl_aff_private.h +++ b/isl_aff_private.h @@ -6,6 +6,8 @@ #include #include +/* ls represents the domain space. + */ struct isl_aff { int ref; @@ -31,9 +33,11 @@ struct isl_pw_aff { __isl_give isl_aff *isl_aff_alloc(__isl_take isl_local_space *ls); -__isl_give isl_aff *isl_aff_reset_space(__isl_take isl_aff *aff, +__isl_give isl_aff *isl_aff_reset_space_and_domain(__isl_take isl_aff *aff, + __isl_take isl_space *space, __isl_take isl_space *domain); +__isl_give isl_aff *isl_aff_reset_domain_space(__isl_take isl_aff *aff, __isl_take isl_space *dim); -__isl_give isl_aff *isl_aff_realign(__isl_take isl_aff *aff, +__isl_give isl_aff *isl_aff_realign_domain(__isl_take isl_aff *aff, __isl_take isl_reordering *r); __isl_give isl_aff *isl_aff_expand_divs( __isl_take isl_aff *aff, @@ -41,6 +45,8 @@ __isl_give isl_aff *isl_aff_expand_divs( __isl_take isl_aff *aff, __isl_give isl_pw_aff *isl_pw_aff_reset_space(__isl_take isl_pw_aff *pwaff, __isl_take isl_space *dim); +__isl_give isl_pw_aff *isl_pw_aff_reset_domain_space( + __isl_take isl_pw_aff *pwaff, __isl_take isl_space *space); __isl_give isl_pw_aff *isl_pw_aff_add_disjoint( __isl_take isl_pw_aff *pwaff1, __isl_take isl_pw_aff *pwaff2); diff --git a/isl_bernstein.c b/isl_bernstein.c index 7527f8d9..43045fac 100644 --- a/isl_bernstein.c +++ b/isl_bernstein.c @@ -150,7 +150,7 @@ static void extract_coefficients(isl_qpolynomial *poly, return; ctx = isl_qpolynomial_get_ctx(poly); - n = isl_qpolynomial_dim(poly, isl_dim_set); + n = isl_qpolynomial_dim(poly, isl_dim_in); d = isl_qpolynomial_degree(poly); isl_assert(ctx, n >= 2, return); @@ -165,7 +165,7 @@ static void extract_coefficients(isl_qpolynomial *poly, for (k[0] = d; k[0] >= 0; --k[0]) { int i = 1; isl_qpolynomial_free(c[0]); - c[0] = isl_qpolynomial_coeff(poly, isl_dim_set, n - 1, k[0]); + c[0] = isl_qpolynomial_coeff(poly, isl_dim_in, n - 1, k[0]); left[0] = d - k[0]; k[1] = -1; isl_int_set(multinom->el[1], multinom->el[0]); @@ -178,11 +178,11 @@ static void extract_coefficients(isl_qpolynomial *poly, for (j = 2; j <= left[i - 1]; ++j) isl_int_divexact_ui(multinom->el[i], multinom->el[i], j); - b = isl_qpolynomial_coeff(c[i - 1], isl_dim_set, + b = isl_qpolynomial_coeff(c[i - 1], isl_dim_in, n - 1 - i, left[i - 1]); b = isl_qpolynomial_project_domain_on_params(b); - dim = isl_qpolynomial_get_space(b); - f = isl_qpolynomial_rat_cst(dim, ctx->one, + dim = isl_qpolynomial_get_domain_space(b); + f = isl_qpolynomial_rat_cst_on_domain(dim, ctx->one, multinom->el[i]); b = isl_qpolynomial_mul(b, f); k[n - 1] = left[n - 2]; @@ -199,7 +199,7 @@ static void extract_coefficients(isl_qpolynomial *poly, isl_int_divexact_ui(multinom->el[i], multinom->el[i], k[i]); isl_qpolynomial_free(c[i]); - c[i] = isl_qpolynomial_coeff(c[i - 1], isl_dim_set, + c[i] = isl_qpolynomial_coeff(c[i - 1], isl_dim_in, n - 1 - i, k[i]); left[i] = left[i - 1] - k[i]; k[i + 1] = -1; @@ -257,7 +257,7 @@ static int bernstein_coefficients_cell(__isl_take isl_cell *cell, void *user) if (!poly) goto error; - nvar = isl_qpolynomial_dim(poly, isl_dim_set) - 1; + nvar = isl_qpolynomial_dim(poly, isl_dim_in) - 1; n_vertices = cell->n_vertices; ctx = isl_qpolynomial_get_ctx(poly); @@ -270,22 +270,22 @@ static int bernstein_coefficients_cell(__isl_take isl_cell *cell, void *user) goto error; dim_param = isl_basic_set_get_space(cell->dom); - dim_dst = isl_qpolynomial_get_space(poly); + dim_dst = isl_qpolynomial_get_domain_space(poly); dim_dst = isl_space_add_dims(dim_dst, isl_dim_set, n_vertices); for (i = 0; i < 1 + nvar; ++i) - subs[i] = isl_qpolynomial_zero(isl_space_copy(dim_dst)); + subs[i] = isl_qpolynomial_zero_on_domain(isl_space_copy(dim_dst)); for (i = 0; i < n_vertices; ++i) { isl_qpolynomial *c; - c = isl_qpolynomial_var(isl_space_copy(dim_dst), isl_dim_set, + c = isl_qpolynomial_var_on_domain(isl_space_copy(dim_dst), isl_dim_set, 1 + nvar + i); for (j = 0; j < nvar; ++j) { int k = cell->ids[i]; isl_qpolynomial *v; v = vertex_coordinate(cell->vertices->v[k].vertex, j, isl_space_copy(dim_param)); - v = isl_qpolynomial_add_dims(v, isl_dim_set, + v = isl_qpolynomial_add_dims(v, isl_dim_in, 1 + nvar + n_vertices); v = isl_qpolynomial_mul(v, isl_qpolynomial_copy(c)); subs[1 + j] = isl_qpolynomial_add(subs[1 + j], v); @@ -296,9 +296,9 @@ static int bernstein_coefficients_cell(__isl_take isl_cell *cell, void *user) poly = isl_qpolynomial_copy(poly); - poly = isl_qpolynomial_add_dims(poly, isl_dim_set, n_vertices); - poly = isl_qpolynomial_substitute(poly, isl_dim_set, 0, 1 + nvar, subs); - poly = isl_qpolynomial_drop_dims(poly, isl_dim_set, 0, 1 + nvar); + poly = isl_qpolynomial_add_dims(poly, isl_dim_in, n_vertices); + poly = isl_qpolynomial_substitute(poly, isl_dim_in, 0, 1 + nvar, subs); + poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, 0, 1 + nvar); data->cell = cell; dom = isl_set_from_basic_set(isl_basic_set_copy(cell->dom)); @@ -365,6 +365,8 @@ static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_base( dim = isl_basic_set_get_space(bset); dim = isl_space_params(dim); + dim = isl_space_from_domain(dim); + dim = isl_space_add_dims(dim, isl_dim_set, 1); data->pwf = isl_pw_qpolynomial_fold_zero(isl_space_copy(dim), data->type); data->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, data->type); data->poly = isl_qpolynomial_homogenize(isl_qpolynomial_copy(poly)); @@ -414,15 +416,15 @@ static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_recursive( return NULL; nparam = isl_pw_qpolynomial_dim(pwqp, isl_dim_param); - nvar = isl_pw_qpolynomial_dim(pwqp, isl_dim_set); + nvar = isl_pw_qpolynomial_dim(pwqp, isl_dim_in); pwqp = isl_pw_qpolynomial_move_dims(pwqp, isl_dim_param, nparam, - isl_dim_set, 0, nvar - len[n_group - 1]); + isl_dim_in, 0, nvar - len[n_group - 1]); pwf = isl_pw_qpolynomial_bound(pwqp, data->type, tight); for (i = n_group - 2; i >= 0; --i) { nparam = isl_pw_qpolynomial_fold_dim(pwf, isl_dim_param); - pwf = isl_pw_qpolynomial_fold_move_dims(pwf, isl_dim_set, 0, + pwf = isl_pw_qpolynomial_fold_move_dims(pwf, isl_dim_in, 0, isl_dim_param, nparam - len[i], len[i]); if (tight && !*tight) tight = NULL; @@ -451,7 +453,7 @@ static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_factors( set = isl_set_from_basic_set(bset); pwqp = isl_pw_qpolynomial_alloc(set, poly); - pwqp = isl_pw_qpolynomial_morph(pwqp, isl_morph_copy(f->morph)); + pwqp = isl_pw_qpolynomial_morph_domain(pwqp, isl_morph_copy(f->morph)); pwf = bernstein_coefficients_recursive(pwqp, f->n_group, f->len, data, tight); diff --git a/isl_bound.c b/isl_bound.c index 2a69f06a..a2fd0672 100644 --- a/isl_bound.c +++ b/isl_bound.c @@ -68,7 +68,7 @@ static int unwrapped_guarded_poly_bound(__isl_take isl_basic_set *bset, morph = isl_basic_set_full_compression(bset); bset = isl_morph_basic_set(isl_morph_copy(morph), bset); - poly = isl_qpolynomial_morph(poly, isl_morph_copy(morph)); + poly = isl_qpolynomial_morph_domain(poly, isl_morph_copy(morph)); dim = isl_morph_get_ran_space(morph); dim = isl_space_params(dim); @@ -76,6 +76,8 @@ static int unwrapped_guarded_poly_bound(__isl_take isl_basic_set *bset, top_pwf = bound->pwf; top_pwf_tight = bound->pwf_tight; + dim = isl_space_from_domain(dim); + dim = isl_space_add_dims(dim, isl_dim_out, 1); bound->pwf = isl_pw_qpolynomial_fold_zero(isl_space_copy(dim), bound->type); bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, bound->type); @@ -86,9 +88,10 @@ static int unwrapped_guarded_poly_bound(__isl_take isl_basic_set *bset, morph = isl_morph_ran_params(morph); morph = isl_morph_inverse(morph); - bound->pwf = isl_pw_qpolynomial_fold_morph(bound->pwf, + bound->pwf = isl_pw_qpolynomial_fold_morph_domain(bound->pwf, isl_morph_copy(morph)); - bound->pwf_tight = isl_pw_qpolynomial_fold_morph(bound->pwf_tight, morph); + bound->pwf_tight = isl_pw_qpolynomial_fold_morph_domain( + bound->pwf_tight, morph); bound->pwf = isl_pw_qpolynomial_fold_fold(top_pwf, bound->pwf); bound->pwf_tight = isl_pw_qpolynomial_fold_fold(top_pwf_tight, @@ -116,12 +119,12 @@ static int guarded_poly_bound(__isl_take isl_basic_set *bset, return unwrapped_guarded_poly_bound(bset, poly, user); nparam = isl_space_dim(bound->dim, isl_dim_param); - n_in = isl_space_dim(bound->dim, isl_dim_set); + n_in = isl_space_dim(bound->dim, isl_dim_in); bset = isl_basic_set_move_dims(bset, isl_dim_param, nparam, isl_dim_set, 0, n_in); poly = isl_qpolynomial_move_dims(poly, isl_dim_param, nparam, - isl_dim_set, 0, n_in); + isl_dim_in, 0, n_in); dim = isl_basic_set_get_space(bset); dim = isl_space_params(dim); @@ -129,6 +132,8 @@ static int guarded_poly_bound(__isl_take isl_basic_set *bset, top_pwf = bound->pwf; top_pwf_tight = bound->pwf_tight; + dim = isl_space_from_domain(dim); + dim = isl_space_add_dims(dim, isl_dim_out, 1); bound->pwf = isl_pw_qpolynomial_fold_zero(isl_space_copy(dim), bound->type); bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, bound->type); @@ -206,13 +211,15 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_bound( if (!pwf) return NULL; - bound.dim = isl_pw_qpolynomial_fold_get_space(pwf); + bound.dim = isl_pw_qpolynomial_fold_get_domain_space(pwf); bound.wrapping = isl_space_is_wrapping(bound.dim); if (bound.wrapping) bound.dim = isl_space_unwrap(bound.dim); nvar = isl_space_dim(bound.dim, isl_dim_out); bound.dim = isl_space_domain(bound.dim); + bound.dim = isl_space_from_domain(bound.dim); + bound.dim = isl_space_add_dims(bound.dim, isl_dim_out, 1); if (nvar == 0) { if (tight) diff --git a/isl_constraint.c b/isl_constraint.c index 0371268c..a64a00dc 100644 --- a/isl_constraint.c +++ b/isl_constraint.c @@ -1124,12 +1124,14 @@ __isl_give isl_aff *isl_constraint_get_aff( __isl_give isl_constraint *isl_equality_from_aff(__isl_take isl_aff *aff) { int k; + isl_local_space *ls; isl_basic_set *bset; if (!aff) return NULL; - bset = isl_basic_set_from_local_space(isl_aff_get_local_space(aff)); + ls = isl_aff_get_domain_local_space(aff); + bset = isl_basic_set_from_local_space(ls); bset = isl_basic_set_extend_constraints(bset, 1, 0); k = isl_basic_set_alloc_equality(bset); if (k < 0) @@ -1151,12 +1153,14 @@ error: __isl_give isl_constraint *isl_inequality_from_aff(__isl_take isl_aff *aff) { int k; + isl_local_space *ls; isl_basic_set *bset; if (!aff) return NULL; - bset = isl_basic_set_from_local_space(isl_aff_get_local_space(aff)); + ls = isl_aff_get_domain_local_space(aff); + bset = isl_basic_set_from_local_space(ls); bset = isl_basic_set_extend_constraints(bset, 0, 1); k = isl_basic_set_alloc_inequality(bset); if (k < 0) diff --git a/isl_div.c b/isl_div.c index 62a453e6..84913afa 100644 --- a/isl_div.c +++ b/isl_div.c @@ -183,7 +183,7 @@ __isl_give isl_aff *isl_aff_from_div(__isl_take isl_div *div) return NULL; pos = div->line - div->bmap->div; - aff = isl_aff_zero(isl_basic_map_get_local_space(div->bmap)); + aff = isl_aff_zero_on_domain(isl_basic_map_get_local_space(div->bmap)); aff = isl_aff_set_coefficient_si(aff, isl_dim_div, pos, 1); isl_div_free(div); diff --git a/isl_fold.c b/isl_fold.c index a8aee6fc..98a91ae0 100644 --- a/isl_fold.c +++ b/isl_fold.c @@ -65,13 +65,25 @@ isl_ctx *isl_qpolynomial_fold_get_ctx(__isl_keep isl_qpolynomial_fold *fold) return fold ? fold->dim->ctx : NULL; } -__isl_give isl_space *isl_qpolynomial_fold_get_space( +__isl_give isl_space *isl_qpolynomial_fold_get_domain_space( __isl_keep isl_qpolynomial_fold *fold) { return fold ? isl_space_copy(fold->dim) : NULL; } -__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_space( +__isl_give isl_space *isl_qpolynomial_fold_get_space( + __isl_keep isl_qpolynomial_fold *fold) +{ + isl_space *space; + if (!fold) + return NULL; + space = isl_space_copy(fold->dim); + space = isl_space_from_domain(space); + space = isl_space_add_dims(space, isl_dim_out, 1); + return space; +} + +__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_domain_space( __isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *dim) { int i; @@ -81,7 +93,7 @@ __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_space( goto error; for (i = 0; i < fold->n; ++i) { - fold->qp[i] = isl_qpolynomial_reset_space(fold->qp[i], + fold->qp[i] = isl_qpolynomial_reset_domain_space(fold->qp[i], isl_space_copy(dim)); if (!fold->qp[i]) goto error; @@ -97,6 +109,18 @@ error: return NULL; } +/* Reset the space of "fold". This function is called from isl_pw_templ.c + * and doesn't know if the space of an element object is represented + * directly or through its domain. It therefore passes along both. + */ +__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_space_and_domain( + __isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space, + __isl_take isl_space *domain) +{ + isl_space_free(space); + return isl_qpolynomial_fold_reset_domain_space(fold, domain); +} + int isl_qpolynomial_fold_involves_dims(__isl_keep isl_qpolynomial_fold *fold, enum isl_dim_type type, unsigned first, unsigned n) { @@ -147,16 +171,19 @@ __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_drop_dims( enum isl_dim_type type, unsigned first, unsigned n) { int i; + enum isl_dim_type set_type; if (!fold) return NULL; if (n == 0) return fold; + set_type = type == isl_dim_in ? isl_dim_set : type; + fold = isl_qpolynomial_fold_cow(fold); if (!fold) return NULL; - fold->dim = isl_space_drop_dims(fold->dim, type, first, n); + fold->dim = isl_space_drop_dims(fold->dim, set_type, first, n); if (!fold->dim) goto error; @@ -319,8 +346,8 @@ static int isl_qpolynomial_sign(__isl_keep isl_set *set, isl_qpolynomial *r, *q; isl_qpolynomial *t; - min = isl_qpolynomial_cst(isl_space_copy(qp->dim), l); - base = isl_qpolynomial_var_pow(isl_space_copy(qp->dim), + min = isl_qpolynomial_cst_on_domain(isl_space_copy(qp->dim), l); + base = isl_qpolynomial_var_pow_on_domain(isl_space_copy(qp->dim), qp->upoly->var, 1); r = isl_qpolynomial_alloc(isl_space_copy(qp->dim), 0, @@ -609,6 +636,7 @@ error: #define PART isl_pw_qpolynomial_fold #undef PARTS #define PARTS pw_qpolynomial_fold +#define ALIGN_DOMAIN #include @@ -965,7 +993,7 @@ __isl_give isl_qpolynomial *isl_qpolynomial_fold_eval( goto error); if (fold->n == 0) - qp = isl_qpolynomial_zero(isl_space_copy(fold->dim)); + qp = isl_qpolynomial_zero_on_domain(isl_space_copy(fold->dim)); else { int i; qp = isl_qpolynomial_eval(isl_qpolynomial_copy(fold->qp[0]), @@ -1015,7 +1043,7 @@ __isl_give isl_qpolynomial *isl_qpolynomial_fold_opt_on_domain( isl_space *dim = isl_space_copy(fold->dim); isl_set_free(set); isl_qpolynomial_fold_free(fold); - return isl_qpolynomial_zero(dim); + return isl_qpolynomial_zero_on_domain(dim); } opt = isl_qpolynomial_opt_on_domain(isl_qpolynomial_copy(fold->qp[0]), @@ -1130,7 +1158,7 @@ int isl_pw_qpolynomial_fold_covers(__isl_keep isl_pw_qpolynomial_fold *pwf1, return 1; } -__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_morph( +__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_morph_domain( __isl_take isl_qpolynomial_fold *fold, __isl_take isl_morph *morph) { int i; @@ -1152,7 +1180,7 @@ __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_morph( goto error; for (i = 0; i < fold->n; ++i) { - fold->qp[i] = isl_qpolynomial_morph(fold->qp[i], + fold->qp[i] = isl_qpolynomial_morph_domain(fold->qp[i], isl_morph_copy(morph)); if (!fold->qp[i]) goto error; @@ -1360,13 +1388,13 @@ error: return NULL; } -static int compatible_range(__isl_keep isl_space *dim1, __isl_keep isl_space *dim2) +static int join_compatible(__isl_keep isl_space *dim1, __isl_keep isl_space *dim2) { int m; m = isl_space_match(dim1, isl_dim_param, dim2, isl_dim_param); if (m < 0 || !m) return m; - return isl_space_tuple_match(dim1, isl_dim_out, dim2, isl_dim_set); + return isl_space_tuple_match(dim1, isl_dim_out, dim2, isl_dim_in); } /* Compute the intersection of the range of the map and the domain @@ -1395,7 +1423,7 @@ __isl_give isl_pw_qpolynomial_fold *isl_map_apply_pw_qpolynomial_fold( map_dim = isl_map_get_space(map); pwf_dim = isl_pw_qpolynomial_fold_get_space(pwf); - ok = compatible_range(map_dim, pwf_dim); + ok = join_compatible(map_dim, pwf_dim); isl_space_free(map_dim); isl_space_free(pwf_dim); if (!ok) @@ -1403,10 +1431,11 @@ __isl_give isl_pw_qpolynomial_fold *isl_map_apply_pw_qpolynomial_fold( goto error); n_in = isl_map_dim(map, isl_dim_in); - pwf = isl_pw_qpolynomial_fold_insert_dims(pwf, isl_dim_set, 0, n_in); + pwf = isl_pw_qpolynomial_fold_insert_dims(pwf, isl_dim_in, 0, n_in); dom = isl_map_wrap(map); - pwf = isl_pw_qpolynomial_fold_reset_space(pwf, isl_set_get_space(dom)); + pwf = isl_pw_qpolynomial_fold_reset_domain_space(pwf, + isl_set_get_space(dom)); pwf = isl_pw_qpolynomial_fold_intersect_domain(pwf, dom); pwf = isl_pw_qpolynomial_fold_bound(pwf, tight); @@ -1442,7 +1471,7 @@ static int pw_qpolynomial_fold_apply(__isl_take isl_pw_qpolynomial_fold *pwf, map_dim = isl_map_get_space(data->map); pwf_dim = isl_pw_qpolynomial_fold_get_space(pwf); - ok = compatible_range(map_dim, pwf_dim); + ok = join_compatible(map_dim, pwf_dim); isl_space_free(map_dim); isl_space_free(pwf_dim); @@ -1514,7 +1543,7 @@ __isl_give isl_union_pw_qpolynomial_fold *isl_union_set_apply_union_pw_qpolynomi /* Reorder the dimension of "fold" according to the given reordering. */ -__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_realign( +__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_realign_domain( __isl_take isl_qpolynomial_fold *fold, __isl_take isl_reordering *r) { int i; @@ -1524,13 +1553,14 @@ __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_realign( goto error; for (i = 0; i < fold->n; ++i) { - fold->qp[i] = isl_qpolynomial_realign(fold->qp[i], + fold->qp[i] = isl_qpolynomial_realign_domain(fold->qp[i], isl_reordering_copy(r)); if (!fold->qp[i]) goto error; } - fold = isl_qpolynomial_fold_reset_space(fold, isl_space_copy(r->dim)); + fold = isl_qpolynomial_fold_reset_domain_space(fold, + isl_space_copy(r->dim)); isl_reordering_free(r); diff --git a/isl_input.c b/isl_input.c index 7f190ccc..031bf119 100644 --- a/isl_input.c +++ b/isl_input.c @@ -374,7 +374,7 @@ static __isl_give isl_pw_aff *accept_affine_factor(struct isl_stream *s, goto error; } - aff = isl_aff_zero(isl_local_space_from_space(isl_space_copy(dim))); + aff = isl_aff_zero_on_domain(isl_local_space_from_space(isl_space_copy(dim))); if (!aff) goto error; isl_int_set_si(aff->v->el[2 + pos], 1); @@ -388,7 +388,7 @@ static __isl_give isl_pw_aff *accept_affine_factor(struct isl_stream *s, isl_local_space *ls; isl_aff *aff; ls = isl_local_space_from_space(isl_space_copy(dim)); - aff = isl_aff_zero(ls); + aff = isl_aff_zero_on_domain(ls); aff = isl_aff_add_constant(aff, tok->u.v); res = isl_pw_aff_from_aff(aff); } @@ -445,8 +445,10 @@ error2: static __isl_give isl_pw_aff *add_cst(__isl_take isl_pw_aff *pwaff, isl_int v) { isl_aff *aff; + isl_space *space; - aff = isl_aff_zero(isl_local_space_from_space(isl_pw_aff_get_space(pwaff))); + space = isl_pw_aff_get_domain_space(pwaff); + aff = isl_aff_zero_on_domain(isl_local_space_from_space(space)); aff = isl_aff_add_constant(aff, v); return isl_pw_aff_add(pwaff, isl_pw_aff_from_aff(aff)); @@ -461,7 +463,7 @@ static __isl_give isl_pw_aff *accept_affine(struct isl_stream *s, int sign = 1; ls = isl_local_space_from_space(isl_space_copy(dim)); - res = isl_pw_aff_from_aff(isl_aff_zero(ls)); + res = isl_pw_aff_from_aff(isl_aff_zero_on_domain(ls)); if (!res) goto error; @@ -589,7 +591,8 @@ static __isl_give isl_pw_aff *accept_ternary(struct isl_stream *s, if (isl_stream_eat(s, ':')) goto error; - pwaff2 = accept_extended_affine(s, isl_pw_aff_get_space(pwaff1), v); + dim = isl_pw_aff_get_domain_space(pwaff1); + pwaff2 = accept_extended_affine(s, dim, v); if (!pwaff1) goto error; @@ -610,6 +613,7 @@ error: static __isl_give isl_pw_aff *accept_extended_affine(struct isl_stream *s, __isl_take isl_space *dim, struct vars *v) { + isl_space *space; isl_map *cond; isl_pw_aff *pwaff; struct isl_token *tok; @@ -642,7 +646,8 @@ static __isl_give isl_pw_aff *accept_extended_affine(struct isl_stream *s, tok->type = ISL_TOKEN_AFF; tok->u.pwaff = pwaff; - cond = isl_map_universe(isl_space_unwrap(isl_pw_aff_get_space(pwaff))); + space = isl_pw_aff_get_domain_space(pwaff); + cond = isl_map_universe(isl_space_unwrap(space)); isl_stream_push_token(s, tok); @@ -1507,12 +1512,12 @@ static __isl_give isl_pw_qpolynomial *read_factor(struct isl_stream *s, isl_token_free(tok2); return NULL; } - qp = isl_qpolynomial_rat_cst(isl_map_get_space(map), + qp = isl_qpolynomial_rat_cst_on_domain(isl_map_get_space(map), tok->u.v, tok2->u.v); isl_token_free(tok2); } else { isl_stream_push_token(s, tok2); - qp = isl_qpolynomial_cst(isl_map_get_space(map), + qp = isl_qpolynomial_cst_on_domain(isl_map_get_space(map), tok->u.v); } isl_token_free(tok); @@ -1520,12 +1525,12 @@ static __isl_give isl_pw_qpolynomial *read_factor(struct isl_stream *s, } else if (tok->type == ISL_TOKEN_INFTY) { isl_qpolynomial *qp; isl_token_free(tok); - qp = isl_qpolynomial_infty(isl_map_get_space(map)); + qp = isl_qpolynomial_infty_on_domain(isl_map_get_space(map)); pwqp = isl_pw_qpolynomial_from_qpolynomial(qp); } else if (tok->type == ISL_TOKEN_NAN) { isl_qpolynomial *qp; isl_token_free(tok); - qp = isl_qpolynomial_nan(isl_map_get_space(map)); + qp = isl_qpolynomial_nan_on_domain(isl_map_get_space(map)); pwqp = isl_pw_qpolynomial_from_qpolynomial(qp); } else if (tok->type == ISL_TOKEN_IDENT) { int n = v->n; @@ -1544,7 +1549,7 @@ static __isl_give isl_pw_qpolynomial *read_factor(struct isl_stream *s, } isl_token_free(tok); pow = optional_power(s); - qp = isl_qpolynomial_var_pow(isl_map_get_space(map), pos, pow); + qp = isl_qpolynomial_var_pow_on_domain(isl_map_get_space(map), pos, pow); pwqp = isl_pw_qpolynomial_from_qpolynomial(qp); } else if (tok->type == '[') { isl_pw_aff *pwaff; diff --git a/isl_map.c b/isl_map.c index 19d0d5b4..f86458c3 100644 --- a/isl_map.c +++ b/isl_map.c @@ -5450,6 +5450,7 @@ static __isl_give isl_pw_aff *basic_set_dim_opt(__isl_keep isl_basic_set *bset, int r; dim = isl_space_params(dim); + dim = isl_space_add_dims(dim, isl_dim_set, 1); pwaff = isl_pw_aff_empty(dim); r = isl_basic_set_foreach_lexopt(bset, max, &update_dim_opt, &pwaff); @@ -9492,8 +9493,6 @@ __isl_give isl_basic_map *isl_basic_map_from_aff(__isl_take isl_aff *aff) return NULL; ls = isl_aff_get_local_space(aff); - ls = isl_local_space_from_domain(ls); - ls = isl_local_space_add_dims(ls, isl_dim_out, 1); bmap = isl_basic_map_from_local_space(ls); bmap = isl_basic_map_extend_constraints(bmap, 1, 0); k = isl_basic_map_alloc_equality(bmap); diff --git a/isl_output.c b/isl_output.c index 2ea85eca..c2541cf0 100644 --- a/isl_output.c +++ b/isl_output.c @@ -1371,7 +1371,7 @@ static __isl_give isl_printer *print_qpolynomial_c(__isl_take isl_printer *p, isl_qpolynomial *f; p = isl_printer_print_str(p, "("); qp = isl_qpolynomial_copy(qp); - f = isl_qpolynomial_rat_cst(isl_space_copy(qp->dim), + f = isl_qpolynomial_rat_cst_on_domain(isl_space_copy(qp->dim), den, qp->dim->ctx->one); qp = isl_qpolynomial_mul(qp, f); } @@ -1462,7 +1462,7 @@ static __isl_give isl_printer *isl_pwqp_print_isl_body( for (i = 0; i < pwqp->n; ++i) { if (i) p = isl_printer_print_str(p, "; "); - if (!isl_space_is_params(pwqp->dim)) { + if (!isl_space_is_params(pwqp->p[i].set->dim)) { p = print_space(pwqp->p[i].set->dim, p, 0, 0, NULL); p = isl_printer_print_str(p, " -> "); } @@ -1485,8 +1485,8 @@ static __isl_give isl_printer *print_pw_qpolynomial_isl( } p = isl_printer_print_str(p, "{ "); if (pwqp->n == 0) { - if (!isl_space_is_params(pwqp->dim)) { - p = print_space(pwqp->dim, p, 0, 0, NULL); + if (!isl_space_is_set(pwqp->dim)) { + p = print_tuple(pwqp->dim, p, isl_dim_in, 0, NULL); p = isl_printer_print_str(p, " -> "); } p = isl_printer_print_str(p, "0"); @@ -1522,7 +1522,7 @@ static __isl_give isl_printer *isl_pwf_print_isl_body( for (i = 0; i < pwf->n; ++i) { if (i) p = isl_printer_print_str(p, "; "); - if (!isl_space_is_params(pwf->dim)) { + if (!isl_space_is_params(pwf->p[i].set->dim)) { p = print_space(pwf->p[i].set->dim, p, 0, 0, NULL); p = isl_printer_print_str(p, " -> "); } @@ -1542,8 +1542,8 @@ static __isl_give isl_printer *print_pw_qpolynomial_fold_isl( } p = isl_printer_print_str(p, "{ "); if (pwf->n == 0) { - if (!isl_space_is_params(pwf->dim)) { - p = print_space(pwf->dim, p, 0, 0, NULL); + if (!isl_space_is_set(pwf->dim)) { + p = print_tuple(pwf->dim, p, isl_dim_in, 0, NULL); p = isl_printer_print_str(p, " -> "); } p = isl_printer_print_str(p, "0"); diff --git a/isl_polynomial.c b/isl_polynomial.c index 78296097..2341bab0 100644 --- a/isl_polynomial.c +++ b/isl_polynomial.c @@ -344,7 +344,7 @@ __isl_give struct isl_upoly_rec *isl_upoly_alloc_rec(struct isl_ctx *ctx, return rec; } -__isl_give isl_qpolynomial *isl_qpolynomial_reset_space( +__isl_give isl_qpolynomial *isl_qpolynomial_reset_domain_space( __isl_take isl_qpolynomial *qp, __isl_take isl_space *dim) { qp = isl_qpolynomial_cow(qp); @@ -361,20 +361,53 @@ error: return NULL; } +/* Reset the space of "qp". This function is called from isl_pw_templ.c + * and doesn't know if the space of an element object is represented + * directly or through its domain. It therefore passes along both. + */ +__isl_give isl_qpolynomial *isl_qpolynomial_reset_space_and_domain( + __isl_take isl_qpolynomial *qp, __isl_take isl_space *space, + __isl_take isl_space *domain) +{ + isl_space_free(space); + return isl_qpolynomial_reset_domain_space(qp, domain); +} + isl_ctx *isl_qpolynomial_get_ctx(__isl_keep isl_qpolynomial *qp) { return qp ? qp->dim->ctx : NULL; } -__isl_give isl_space *isl_qpolynomial_get_space(__isl_keep isl_qpolynomial *qp) +__isl_give isl_space *isl_qpolynomial_get_domain_space( + __isl_keep isl_qpolynomial *qp) { return qp ? isl_space_copy(qp->dim) : NULL; } +__isl_give isl_space *isl_qpolynomial_get_space(__isl_keep isl_qpolynomial *qp) +{ + isl_space *space; + if (!qp) + return NULL; + space = isl_space_copy(qp->dim); + space = isl_space_from_domain(space); + space = isl_space_add_dims(space, isl_dim_out, 1); + return space; +} + +/* Externally, an isl_qpolynomial has a map space, but internally, the + * ls field corresponds to the domain of that space. + */ unsigned isl_qpolynomial_dim(__isl_keep isl_qpolynomial *qp, enum isl_dim_type type) { - return qp ? isl_space_dim(qp->dim, type) : 0; + if (!qp) + return 0; + if (type == isl_dim_out) + return 1; + if (type == isl_dim_in) + type = isl_dim_set; + return isl_space_dim(qp->dim, type); } int isl_qpolynomial_is_zero(__isl_keep isl_qpolynomial *qp) @@ -955,6 +988,10 @@ __isl_give isl_qpolynomial *isl_qpolynomial_alloc(__isl_take isl_space *dim, if (!dim || !up) goto error; + if (!isl_space_is_set(dim)) + isl_die(isl_space_get_ctx(dim), isl_error_invalid, + "domain of polynomial should be a set", goto error); + total = isl_space_dim(dim, isl_dim_all); qp = isl_calloc_type(dim->ctx, struct isl_qpolynomial); @@ -1402,7 +1439,7 @@ __isl_give isl_qpolynomial *isl_qpolynomial_mul_isl_int( if (qp && isl_int_is_zero(v)) { isl_qpolynomial *zero; - zero = isl_qpolynomial_zero(isl_space_copy(qp->dim)); + zero = isl_qpolynomial_zero_on_domain(isl_space_copy(qp->dim)); isl_qpolynomial_free(qp); return zero; } @@ -1494,42 +1531,48 @@ __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow( return pwqp; } -__isl_give isl_qpolynomial *isl_qpolynomial_zero(__isl_take isl_space *dim) +__isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain( + __isl_take isl_space *dim) { if (!dim) return NULL; return isl_qpolynomial_alloc(dim, 0, isl_upoly_zero(dim->ctx)); } -__isl_give isl_qpolynomial *isl_qpolynomial_one(__isl_take isl_space *dim) +__isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain( + __isl_take isl_space *dim) { if (!dim) return NULL; return isl_qpolynomial_alloc(dim, 0, isl_upoly_one(dim->ctx)); } -__isl_give isl_qpolynomial *isl_qpolynomial_infty(__isl_take isl_space *dim) +__isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain( + __isl_take isl_space *dim) { if (!dim) return NULL; return isl_qpolynomial_alloc(dim, 0, isl_upoly_infty(dim->ctx)); } -__isl_give isl_qpolynomial *isl_qpolynomial_neginfty(__isl_take isl_space *dim) +__isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain( + __isl_take isl_space *dim) { if (!dim) return NULL; return isl_qpolynomial_alloc(dim, 0, isl_upoly_neginfty(dim->ctx)); } -__isl_give isl_qpolynomial *isl_qpolynomial_nan(__isl_take isl_space *dim) +__isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain( + __isl_take isl_space *dim) { if (!dim) return NULL; return isl_qpolynomial_alloc(dim, 0, isl_upoly_nan(dim->ctx)); } -__isl_give isl_qpolynomial *isl_qpolynomial_cst(__isl_take isl_space *dim, +__isl_give isl_qpolynomial *isl_qpolynomial_cst_on_domain( + __isl_take isl_space *dim, isl_int v) { struct isl_qpolynomial *qp; @@ -1738,8 +1781,8 @@ void isl_qpolynomial_get_den(__isl_keep isl_qpolynomial *qp, isl_int *d) upoly_update_den(qp->upoly, d); } -__isl_give isl_qpolynomial *isl_qpolynomial_var_pow(__isl_take isl_space *dim, - int pos, int power) +__isl_give isl_qpolynomial *isl_qpolynomial_var_pow_on_domain( + __isl_take isl_space *dim, int pos, int power) { struct isl_ctx *ctx; @@ -1751,7 +1794,7 @@ __isl_give isl_qpolynomial *isl_qpolynomial_var_pow(__isl_take isl_space *dim, return isl_qpolynomial_alloc(dim, 0, isl_upoly_var_pow(ctx, pos, power)); } -__isl_give isl_qpolynomial *isl_qpolynomial_var(__isl_take isl_space *dim, +__isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(__isl_take isl_space *dim, enum isl_dim_type type, unsigned pos) { if (!dim) @@ -1763,7 +1806,7 @@ __isl_give isl_qpolynomial *isl_qpolynomial_var(__isl_take isl_space *dim, if (type == isl_dim_set) pos += isl_space_dim(dim, isl_dim_param); - return isl_qpolynomial_var_pow(dim, pos, 1); + return isl_qpolynomial_var_pow_on_domain(dim, pos, 1); error: isl_space_free(dim); return NULL; @@ -2135,8 +2178,8 @@ __isl_give isl_qpolynomial *isl_qpolynomial_div(__isl_take isl_div *div) return isl_qpolynomial_div_pow(div, 1); } -__isl_give isl_qpolynomial *isl_qpolynomial_rat_cst(__isl_take isl_space *dim, - const isl_int n, const isl_int d) +__isl_give isl_qpolynomial *isl_qpolynomial_rat_cst_on_domain( + __isl_take isl_space *dim, const isl_int n, const isl_int d) { struct isl_qpolynomial *qp; struct isl_upoly_cst *cst; @@ -2208,17 +2251,17 @@ int isl_qpolynomial_involves_dims(__isl_keep isl_qpolynomial *qp, if (n == 0) return 0; - isl_assert(qp->dim->ctx, first + n <= isl_space_dim(qp->dim, type), - return -1); + isl_assert(qp->dim->ctx, + first + n <= isl_qpolynomial_dim(qp, type), return -1); isl_assert(qp->dim->ctx, type == isl_dim_param || - type == isl_dim_set, return -1); + type == isl_dim_in, return -1); active = isl_calloc_array(qp->dim->ctx, int, isl_space_dim(qp->dim, isl_dim_all)); if (set_active(qp, active) < 0) goto error; - if (type == isl_dim_set) + if (type == isl_dim_in) first += isl_space_dim(qp->dim, isl_dim_param); for (i = 0; i < n; ++i) if (active[first + i]) { @@ -2374,6 +2417,12 @@ __isl_give isl_qpolynomial *isl_qpolynomial_drop_dims( { if (!qp) return NULL; + if (type == isl_dim_out) + isl_die(qp->dim->ctx, isl_error_invalid, + "cannot drop output/set dimension", + goto error); + if (type == isl_dim_in) + type = isl_dim_set; if (n == 0 && !isl_space_is_named_or_nested(qp->dim, type)) return qp; @@ -2417,18 +2466,18 @@ __isl_give isl_qpolynomial *isl_qpolynomial_project_domain_on_params( unsigned n; int involves; - n = isl_qpolynomial_dim(qp, isl_dim_set); - involves = isl_qpolynomial_involves_dims(qp, isl_dim_set, 0, n); + n = isl_qpolynomial_dim(qp, isl_dim_in); + involves = isl_qpolynomial_involves_dims(qp, isl_dim_in, 0, n); if (involves < 0) return isl_qpolynomial_free(qp); if (involves) isl_die(isl_qpolynomial_get_ctx(qp), isl_error_invalid, "polynomial involves some of the domain dimensions", return isl_qpolynomial_free(qp)); - qp = isl_qpolynomial_drop_dims(qp, isl_dim_set, 0, n); - space = isl_qpolynomial_get_space(qp); + qp = isl_qpolynomial_drop_dims(qp, isl_dim_in, 0, n); + space = isl_qpolynomial_get_domain_space(qp); space = isl_space_params(space); - qp = isl_qpolynomial_reset_space(qp, space); + qp = isl_qpolynomial_reset_domain_space(qp, space); return qp; } @@ -2583,7 +2632,7 @@ __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial( return isl_pw_qpolynomial_zero(dim); } - dom = isl_set_universe(isl_qpolynomial_get_space(qp)); + dom = isl_set_universe(isl_qpolynomial_get_domain_space(qp)); return isl_pw_qpolynomial_alloc(dom, qp); } @@ -2608,6 +2657,7 @@ __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial( #define PART isl_pw_qpolynomial #undef PARTS #define PARTS pw_qpolynomial +#define ALIGN_DOMAIN #include @@ -2869,6 +2919,14 @@ __isl_give isl_qpolynomial *isl_qpolynomial_insert_dims( unsigned g_pos; int *exp; + if (!qp) + return NULL; + if (type == isl_dim_out) + isl_die(qp->div->ctx, isl_error_invalid, + "cannot insert output/set dimensions", + goto error); + if (type == isl_dim_in) + type = isl_dim_set; if (n == 0 && !isl_space_is_named_or_nested(qp->dim, type)) return qp; @@ -2976,6 +3034,15 @@ __isl_give isl_qpolynomial *isl_qpolynomial_move_dims( if (!qp) return NULL; + if (dst_type == isl_dim_out || src_type == isl_dim_out) + isl_die(qp->dim->ctx, isl_error_invalid, + "cannot move output/set dimension", + goto error); + if (dst_type == isl_dim_in) + dst_type = isl_dim_set; + if (src_type == isl_dim_in) + src_type = isl_dim_set; + isl_assert(qp->dim->ctx, src_pos + n <= isl_space_dim(qp->dim, src_type), goto error); @@ -3016,6 +3083,7 @@ __isl_give isl_qpolynomial *isl_qpolynomial_from_affine(__isl_take isl_space *di { struct isl_upoly *up; + dim = isl_space_domain(dim); if (!dim) return NULL; @@ -3038,7 +3106,7 @@ __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(__isl_take isl_aff *aff) up = isl_upoly_from_affine(ctx, aff->v->el + 1, aff->v->el[0], aff->v->size - 1); - qp = isl_qpolynomial_alloc(isl_aff_get_space(aff), + qp = isl_qpolynomial_alloc(isl_aff_get_domain_space(aff), aff->ls->div->n_row, up); if (!qp) goto error; @@ -3110,6 +3178,14 @@ __isl_give isl_qpolynomial *isl_qpolynomial_substitute( qp = isl_qpolynomial_cow(qp); if (!qp) return NULL; + + if (type == isl_dim_out) + isl_die(qp->dim->ctx, isl_error_invalid, + "cannot substitute output/set dimension", + goto error); + if (type == isl_dim_in) + type = isl_dim_set; + for (i = 0; i < n; ++i) if (!subs[i]) goto error; @@ -3289,6 +3365,13 @@ __isl_give isl_qpolynomial *isl_qpolynomial_coeff( if (!qp) return NULL; + if (type == isl_dim_out) + isl_die(qp->div->ctx, isl_error_invalid, + "output/set dimension does not have a coefficient", + return NULL); + if (type == isl_dim_in) + type = isl_dim_set; + isl_assert(qp->div->ctx, t_pos < isl_space_dim(qp->dim, type), return NULL); @@ -3371,7 +3454,7 @@ __isl_give isl_qpolynomial *isl_qpolynomial_homogenize( if (deg < -1) goto error; - poly = isl_qpolynomial_insert_dims(poly, isl_dim_set, 0, 1); + poly = isl_qpolynomial_insert_dims(poly, isl_dim_in, 0, 1); poly = isl_qpolynomial_cow(poly); if (!poly) goto error; @@ -3814,8 +3897,10 @@ __isl_give isl_qpolynomial *isl_qpolynomial_opt_on_domain( if (isl_set_foreach_point(set, opt_fn, &data) < 0) goto error; - if (data.first) - data.opt = isl_qpolynomial_zero(isl_qpolynomial_get_space(qp)); + if (data.first) { + isl_space *space = isl_qpolynomial_get_domain_space(qp); + data.opt = isl_qpolynomial_zero_on_domain(space); + } isl_set_free(set); isl_qpolynomial_free(qp); @@ -3827,8 +3912,8 @@ error: return NULL; } -__isl_give isl_qpolynomial *isl_qpolynomial_morph(__isl_take isl_qpolynomial *qp, - __isl_take isl_morph *morph) +__isl_give isl_qpolynomial *isl_qpolynomial_morph_domain( + __isl_take isl_qpolynomial *qp, __isl_take isl_morph *morph) { int i; int n_sub; @@ -3993,7 +4078,7 @@ error: /* Reorder the dimension of "qp" according to the given reordering. */ -__isl_give isl_qpolynomial *isl_qpolynomial_realign( +__isl_give isl_qpolynomial *isl_qpolynomial_realign_domain( __isl_take isl_qpolynomial *qp, __isl_take isl_reordering *r) { qp = isl_qpolynomial_cow(qp); @@ -4012,7 +4097,7 @@ __isl_give isl_qpolynomial *isl_qpolynomial_realign( if (!qp->upoly) goto error; - qp = isl_qpolynomial_reset_space(qp, isl_space_copy(r->dim)); + qp = isl_qpolynomial_reset_domain_space(qp, isl_space_copy(r->dim)); isl_reordering_free(r); return qp; @@ -4037,8 +4122,8 @@ __isl_give isl_qpolynomial *isl_qpolynomial_align_params( 0, isl_space_dim(model, isl_dim_out)); exp = isl_parameter_alignment_reordering(qp->dim, model); exp = isl_reordering_extend_space(exp, - isl_qpolynomial_get_space(qp)); - qp = isl_qpolynomial_realign(qp, exp); + isl_qpolynomial_get_domain_space(qp)); + qp = isl_qpolynomial_realign_domain(qp, exp); } isl_space_free(model); @@ -4287,11 +4372,11 @@ static __isl_give isl_pw_qpolynomial *constant_on_domain( bset = isl_basic_set_params(bset); dim = isl_basic_set_get_space(bset); if (cst < 0) - qp = isl_qpolynomial_infty(dim); + qp = isl_qpolynomial_infty_on_domain(dim); else if (cst == 0) - qp = isl_qpolynomial_zero(dim); + qp = isl_qpolynomial_zero_on_domain(dim); else - qp = isl_qpolynomial_one(dim); + qp = isl_qpolynomial_one_on_domain(dim); return isl_pw_qpolynomial_alloc(isl_set_from_basic_set(bset), qp); } @@ -4328,7 +4413,7 @@ static __isl_give isl_pw_qpolynomial *compressed_multiplicative_call( dim = isl_basic_set_get_space(bset); dim = isl_space_domain(dim); set = isl_set_universe(isl_space_copy(dim)); - qp = isl_qpolynomial_one(dim); + qp = isl_qpolynomial_one_on_domain(dim); pwqp = isl_pw_qpolynomial_alloc(set, qp); bset = isl_morph_basic_set(isl_morph_copy(f->morph), bset); @@ -4404,7 +4489,7 @@ __isl_give isl_pw_qpolynomial *isl_basic_set_multiplicative_call( morph = isl_morph_ran_params(morph); morph = isl_morph_inverse(morph); - pwqp = isl_pw_qpolynomial_morph(pwqp, morph); + pwqp = isl_pw_qpolynomial_morph_domain(pwqp, morph); return pwqp; error: @@ -4697,9 +4782,7 @@ __isl_give isl_basic_map *isl_basic_map_from_qpolynomial( if (!aff) goto error; dim = isl_qpolynomial_get_space(qp); - dim = isl_space_from_domain(dim); pos = 1 + isl_space_offset(dim, isl_dim_out); - dim = isl_space_add_dims(dim, isl_dim_out, 1); n_div = qp->div->n_row; bmap = isl_basic_map_alloc_space(dim, n_div, 1, 2 * n_div); diff --git a/isl_polynomial_private.h b/isl_polynomial_private.h index eb0a268a..54d5fe84 100644 --- a/isl_polynomial_private.h +++ b/isl_polynomial_private.h @@ -27,6 +27,8 @@ struct isl_upoly_rec { struct isl_upoly *p[]; }; +/* dim represents the domain space. + */ struct isl_qpolynomial { int ref; @@ -63,6 +65,8 @@ struct isl_pw_qpolynomial { struct isl_pw_qpolynomial_piece p[1]; }; +/* dim represents the domain space. + */ struct isl_qpolynomial_fold { int ref; @@ -117,9 +121,9 @@ __isl_give isl_qpolynomial *isl_qpolynomial_alloc(__isl_take isl_space *dim, __isl_give isl_qpolynomial *isl_qpolynomial_cow(__isl_take isl_qpolynomial *qp); __isl_give isl_qpolynomial *isl_qpolynomial_dup(__isl_keep isl_qpolynomial *qp); -__isl_give isl_qpolynomial *isl_qpolynomial_cst(__isl_take isl_space *dim, +__isl_give isl_qpolynomial *isl_qpolynomial_cst_on_domain(__isl_take isl_space *dim, isl_int v); -__isl_give isl_qpolynomial *isl_qpolynomial_var_pow(__isl_take isl_space *dim, +__isl_give isl_qpolynomial *isl_qpolynomial_var_pow_on_domain(__isl_take isl_space *dim, int pos, int power); __isl_give isl_qpolynomial *isl_qpolynomial_div_pow(__isl_take isl_div *div, int power); @@ -188,13 +192,13 @@ __isl_give isl_qpolynomial *isl_qpolynomial_fold_opt_on_domain( int isl_pw_qpolynomial_fold_covers(__isl_keep isl_pw_qpolynomial_fold *pwf1, __isl_keep isl_pw_qpolynomial_fold *pwf2); -__isl_give isl_qpolynomial *isl_qpolynomial_morph(__isl_take isl_qpolynomial *qp, - __isl_take isl_morph *morph); -__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_morph( +__isl_give isl_qpolynomial *isl_qpolynomial_morph_domain( + __isl_take isl_qpolynomial *qp, __isl_take isl_morph *morph); +__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_morph_domain( __isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_morph *morph); -__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_morph( +__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_morph_domain( __isl_take isl_qpolynomial_fold *fold, __isl_take isl_morph *morph); -__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_morph( +__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_morph_domain( __isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_morph *morph); __isl_give isl_qpolynomial *isl_qpolynomial_lift(__isl_take isl_qpolynomial *qp, @@ -209,11 +213,24 @@ __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_substitute_equalities( __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist( __isl_take isl_qpolynomial_fold *fold, __isl_take isl_set *context); -__isl_give isl_qpolynomial *isl_qpolynomial_realign( +__isl_give isl_qpolynomial *isl_qpolynomial_realign_domain( __isl_take isl_qpolynomial *qp, __isl_take isl_reordering *r); -__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_realign( +__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_realign_domain( __isl_take isl_qpolynomial_fold *fold, __isl_take isl_reordering *r); -__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_realign( +__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_realign_domain( __isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_reordering *r); -__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_realign( +__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_realign_domain( __isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_reordering *r); + +__isl_give isl_qpolynomial *isl_qpolynomial_reset_domain_space( + __isl_take isl_qpolynomial *qp, __isl_take isl_space *dim); +__isl_give isl_qpolynomial *isl_qpolynomial_reset_space_and_domain( + __isl_take isl_qpolynomial *qp, __isl_take isl_space *space, + __isl_take isl_space *domain); +__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_domain_space( + __isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *dim); +__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_space_and_domain( + __isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space, + __isl_take isl_space *domain); +__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_reset_domain_space( + __isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_space *dim); diff --git a/isl_pw_templ.c b/isl_pw_templ.c index b1bdf0a2..ae9328d6 100644 --- a/isl_pw_templ.c +++ b/isl_pw_templ.c @@ -99,9 +99,9 @@ __isl_give PW *FN(PW,alloc)(__isl_take isl_set *set, __isl_take EL *el) goto error; #ifdef HAS_TYPE - pw = FN(PW,alloc_size)(isl_set_get_space(set), type, 1); + pw = FN(PW,alloc_size)(FN(EL,get_space)(el), type, 1); #else - pw = FN(PW,alloc_size)(isl_set_get_space(set), 1); + pw = FN(PW,alloc_size)(FN(EL,get_space)(el), 1); #endif return FN(PW,add_piece)(pw, set, el); @@ -182,7 +182,8 @@ int FN(PW,IS_ZERO)(__isl_keep PW *pw) } #ifndef NO_REALIGN -__isl_give PW *FN(PW,realign)(__isl_take PW *pw, __isl_take isl_reordering *exp) +__isl_give PW *FN(PW,realign_domain)(__isl_take PW *pw, + __isl_take isl_reordering *exp) { int i; @@ -195,13 +196,13 @@ __isl_give PW *FN(PW,realign)(__isl_take PW *pw, __isl_take isl_reordering *exp) isl_reordering_copy(exp)); if (!pw->p[i].set) goto error; - pw->p[i].FIELD = FN(EL,realign)(pw->p[i].FIELD, + pw->p[i].FIELD = FN(EL,realign_domain)(pw->p[i].FIELD, isl_reordering_copy(exp)); if (!pw->p[i].FIELD) goto error; } - pw = FN(PW,reset_space)(pw, isl_space_copy(exp->dim)); + pw = FN(PW,reset_domain_space)(pw, isl_space_copy(exp->dim)); isl_reordering_free(exp); return pw; @@ -235,8 +236,9 @@ __isl_give PW *FN(PW,align_params)(__isl_take PW *pw, __isl_take isl_space *mode model = isl_space_drop_dims(model, isl_dim_out, 0, isl_space_dim(model, isl_dim_out)); exp = isl_parameter_alignment_reordering(pw->dim, model); - exp = isl_reordering_extend_space(exp, FN(PW,get_space)(pw)); - pw = FN(PW,realign)(pw, exp); + exp = isl_reordering_extend_space(exp, + FN(PW,get_domain_space)(pw)); + pw = FN(PW,realign_domain)(pw, exp); } isl_space_free(model); @@ -513,7 +515,7 @@ __isl_give isl_qpolynomial *FN(PW,eval)(__isl_take PW *pw, goto error; ctx = isl_point_get_ctx(pnt); pnt_dim = isl_point_get_space(pnt); - isl_assert(ctx, isl_space_is_equal(pnt_dim, pw->dim), goto error); + isl_assert(ctx, isl_space_is_domain(pnt_dim, pw->dim), goto error); for (i = 0; i < pw->n; ++i) { found = isl_set_contains_point(pw->p[i].set, pnt); @@ -526,7 +528,7 @@ __isl_give isl_qpolynomial *FN(PW,eval)(__isl_take PW *pw, qp = FN(EL,eval)(FN(EL,copy)(pw->p[i].FIELD), isl_point_copy(pnt)); else - qp = isl_qpolynomial_zero(isl_space_copy(pw->dim)); + qp = isl_qpolynomial_zero_on_domain(FN(PW,get_domain_space)(pw)); FN(PW,free)(pw); isl_space_free(pnt_dim); isl_point_free(pnt); @@ -547,7 +549,7 @@ __isl_give isl_set *FN(PW,domain)(__isl_take PW *pw) if (!pw) return NULL; - dom = isl_set_empty(isl_space_copy(pw->dim)); + dom = isl_set_empty(FN(PW,get_domain_space)(pw)); for (i = 0; i < pw->n; ++i) dom = isl_set_union_disjoint(dom, isl_set_copy(pw->p[i].set)); @@ -713,17 +715,22 @@ int FN(PW,involves_dims)(__isl_keep PW *pw, enum isl_dim_type type, unsigned first, unsigned n) { int i; + enum isl_dim_type set_type; if (!pw) return -1; if (pw->n == 0 || n == 0) return 0; + + set_type = type == isl_dim_in ? isl_dim_set : type; + for (i = 0; i < pw->n; ++i) { int involves = FN(EL,involves_dims)(pw->p[i].FIELD, type, first, n); if (involves < 0 || involves) return involves; - involves = isl_set_involves_dims(pw->p[i].set, type, first, n); + involves = isl_set_involves_dims(pw->p[i].set, + set_type, first, n); if (involves < 0 || involves) return involves; } @@ -735,17 +742,21 @@ __isl_give PW *FN(PW,set_dim_name)(__isl_take PW *pw, enum isl_dim_type type, unsigned pos, const char *s) { int i; + enum isl_dim_type set_type; pw = FN(PW,cow)(pw); if (!pw) return NULL; + set_type = type == isl_dim_in ? isl_dim_set : type; + pw->dim = isl_space_set_dim_name(pw->dim, type, pos, s); if (!pw->dim) goto error; for (i = 0; i < pw->n; ++i) { - pw->p[i].set = isl_set_set_dim_name(pw->p[i].set, type, pos, s); + pw->p[i].set = isl_set_set_dim_name(pw->p[i].set, + set_type, pos, s); if (!pw->p[i].set) goto error; pw->p[i].FIELD = FN(EL,set_dim_name)(pw->p[i].FIELD, type, pos, s); @@ -764,12 +775,15 @@ __isl_give PW *FN(PW,drop_dims)(__isl_take PW *pw, enum isl_dim_type type, unsigned first, unsigned n) { int i; + enum isl_dim_type set_type; if (!pw) return NULL; if (n == 0 && !isl_space_get_tuple_name(pw->dim, type)) return pw; + set_type = type == isl_dim_in ? isl_dim_set : type; + pw = FN(PW,cow)(pw); if (!pw) return NULL; @@ -777,7 +791,7 @@ __isl_give PW *FN(PW,drop_dims)(__isl_take PW *pw, if (!pw->dim) goto error; for (i = 0; i < pw->n; ++i) { - pw->p[i].set = isl_set_drop(pw->p[i].set, type, first, n); + pw->p[i].set = isl_set_drop(pw->p[i].set, set_type, first, n); if (!pw->p[i].set) goto error; pw->p[i].FIELD = FN(EL,drop_dims)(pw->p[i].FIELD, type, first, n); @@ -800,12 +814,15 @@ __isl_give PW *FN(PW,project_out)(__isl_take PW *pw, enum isl_dim_type type, unsigned first, unsigned n) { int i; + enum isl_dim_type set_type; if (!pw) return NULL; if (n == 0 && !isl_space_get_tuple_name(pw->dim, type)) return pw; + set_type = type == isl_dim_in ? isl_dim_set : type; + pw = FN(PW,cow)(pw); if (!pw) return NULL; @@ -813,7 +830,8 @@ __isl_give PW *FN(PW,project_out)(__isl_take PW *pw, if (!pw->dim) goto error; for (i = 0; i < pw->n; ++i) { - pw->p[i].set = isl_set_project_out(pw->p[i].set, type, first, n); + pw->p[i].set = isl_set_project_out(pw->p[i].set, + set_type, first, n); if (!pw->p[i].set) goto error; pw->p[i].FIELD = FN(EL,drop_dims)(pw->p[i].FIELD, type, first, n); @@ -834,11 +852,11 @@ __isl_give PW *FN(PW,project_domain_on_params)(__isl_take PW *pw) isl_space *space; unsigned n; - n = FN(PW,dim)(pw, isl_dim_set); - pw = FN(PW,project_out)(pw, isl_dim_set, 0, n); - space = FN(PW,get_space)(pw); + n = FN(PW,dim)(pw, isl_dim_in); + pw = FN(PW,project_out)(pw, isl_dim_in, 0, n); + space = FN(PW,get_domain_space)(pw); space = isl_space_params(space); - pw = FN(PW,reset_space)(pw, space); + pw = FN(PW,reset_domain_space)(pw, space); return pw; } #endif @@ -848,12 +866,15 @@ __isl_give PW *FN(PW,insert_dims)(__isl_take PW *pw, enum isl_dim_type type, unsigned first, unsigned n) { int i; + enum isl_dim_type set_type; if (!pw) return NULL; if (n == 0 && !isl_space_is_named_or_nested(pw->dim, type)) return pw; + set_type = type == isl_dim_in ? isl_dim_set : type; + pw = FN(PW,cow)(pw); if (!pw) return NULL; @@ -864,7 +885,7 @@ __isl_give PW *FN(PW,insert_dims)(__isl_take PW *pw, enum isl_dim_type type, for (i = 0; i < pw->n; ++i) { pw->p[i].set = isl_set_insert_dims(pw->p[i].set, - type, first, n); + set_type, first, n); if (!pw->p[i].set) goto error; pw->p[i].FIELD = FN(EL,insert_dims)(pw->p[i].FIELD, @@ -888,6 +909,9 @@ __isl_give PW *FN(PW,fix_dim)(__isl_take PW *pw, if (!pw) return NULL; + if (type == isl_dim_in) + type = isl_dim_set; + pw = FN(PW,cow)(pw); if (!pw) return NULL; @@ -918,6 +942,9 @@ __isl_give PW *FN(PW,split_dims)(__isl_take PW *pw, if (n == 0) return pw; + if (type == isl_dim_in) + type = isl_dim_set; + pw = FN(PW,cow)(pw); if (!pw) return NULL; @@ -952,7 +979,7 @@ __isl_give isl_qpolynomial *FN(PW,opt)(__isl_take PW *pw, int max) if (pw->n == 0) { isl_space *dim = isl_space_copy(pw->dim); FN(PW,free)(pw); - return isl_qpolynomial_zero(dim); + return isl_qpolynomial_zero_on_domain(dim); } opt = FN(EL,opt_on_domain)(FN(EL,copy)(pw->p[0].FIELD), @@ -987,34 +1014,66 @@ __isl_give isl_space *FN(PW,get_space)(__isl_keep PW *pw) return pw ? isl_space_copy(pw->dim) : NULL; } +__isl_give isl_space *FN(PW,get_domain_space)(__isl_keep PW *pw) +{ + return pw ? isl_space_domain(isl_space_copy(pw->dim)) : NULL; +} + #ifndef NO_RESET_DIM -__isl_give PW *FN(PW,reset_space)(__isl_take PW *pw, __isl_take isl_space *dim) +/* Reset the space of "pw". Since we don't know if the elements + * represent the spaces themselves or their domains, we pass along + * both when we call their reset_space_and_domain. + */ +static __isl_give PW *FN(PW,reset_space_and_domain)(__isl_take PW *pw, + __isl_take isl_space *space, __isl_take isl_space *domain) { int i; pw = FN(PW,cow)(pw); - if (!pw || !dim) + if (!pw || !space || !domain) goto error; for (i = 0; i < pw->n; ++i) { pw->p[i].set = isl_set_reset_space(pw->p[i].set, - isl_space_copy(dim)); + isl_space_copy(domain)); if (!pw->p[i].set) goto error; - pw->p[i].FIELD = FN(EL,reset_space)(pw->p[i].FIELD, - isl_space_copy(dim)); + pw->p[i].FIELD = FN(EL,reset_space_and_domain)(pw->p[i].FIELD, + isl_space_copy(space), isl_space_copy(domain)); if (!pw->p[i].FIELD) goto error; } + + isl_space_free(domain); + isl_space_free(pw->dim); - pw->dim = dim; + pw->dim = space; return pw; error: - isl_space_free(dim); + isl_space_free(domain); + isl_space_free(space); FN(PW,free)(pw); return NULL; } + +__isl_give PW *FN(PW,reset_domain_space)(__isl_take PW *pw, + __isl_take isl_space *domain) +{ + isl_space *space; + + space = isl_space_extend_domain_with_range(isl_space_copy(domain), + FN(PW,get_space)(pw)); + return FN(PW,reset_space_and_domain)(pw, space, domain); +} + +__isl_give PW *FN(PW,reset_space)(__isl_take PW *pw, __isl_take isl_space *dim) +{ + isl_space *domain; + + domain = isl_space_domain(isl_space_copy(dim)); + return FN(PW,reset_space_and_domain)(pw, dim, domain); +} #endif int FN(PW,has_equal_space)(__isl_keep PW *pw1, __isl_keep PW *pw2) @@ -1026,7 +1085,8 @@ int FN(PW,has_equal_space)(__isl_keep PW *pw1, __isl_keep PW *pw2) } #ifndef NO_MORPH -__isl_give PW *FN(PW,morph)(__isl_take PW *pw, __isl_take isl_morph *morph) +__isl_give PW *FN(PW,morph_domain)(__isl_take PW *pw, + __isl_take isl_morph *morph) { int i; isl_ctx *ctx; @@ -1035,14 +1095,14 @@ __isl_give PW *FN(PW,morph)(__isl_take PW *pw, __isl_take isl_morph *morph) goto error; ctx = isl_space_get_ctx(pw->dim); - isl_assert(ctx, isl_space_is_equal(pw->dim, morph->dom->dim), + isl_assert(ctx, isl_space_is_domain(morph->dom->dim, pw->dim), goto error); pw = FN(PW,cow)(pw); if (!pw) goto error; - isl_space_free(pw->dim); - pw->dim = isl_space_copy(morph->ran->dim); + pw->dim = isl_space_extend_domain_with_range( + isl_space_copy(morph->ran->dim), pw->dim); if (!pw->dim) goto error; @@ -1050,7 +1110,7 @@ __isl_give PW *FN(PW,morph)(__isl_take PW *pw, __isl_take isl_morph *morph) pw->p[i].set = isl_morph_set(isl_morph_copy(morph), pw->p[i].set); if (!pw->p[i].set) goto error; - pw->p[i].FIELD = FN(EL,morph)(pw->p[i].FIELD, + pw->p[i].FIELD = FN(EL,morph_domain)(pw->p[i].FIELD, isl_morph_copy(morph)); if (!pw->p[i].FIELD) goto error; @@ -1175,15 +1235,23 @@ __isl_give PW *FN(PW,move_dims)(__isl_take PW *pw, goto error; for (i = 0; i < pw->n; ++i) { + pw->p[i].FIELD = FN(EL,move_dims)(pw->p[i].FIELD, + dst_type, dst_pos, src_type, src_pos, n); + if (!pw->p[i].FIELD) + goto error; + } + + if (dst_type == isl_dim_in) + dst_type = isl_dim_set; + if (src_type == isl_dim_in) + src_type = isl_dim_set; + + for (i = 0; i < pw->n; ++i) { pw->p[i].set = isl_set_move_dims(pw->p[i].set, dst_type, dst_pos, src_type, src_pos, n); if (!pw->p[i].set) goto error; - pw->p[i].FIELD = FN(EL,move_dims)(pw->p[i].FIELD, - dst_type, dst_pos, src_type, src_pos, n); - if (!pw->p[i].FIELD) - goto error; } return pw; diff --git a/isl_range.c b/isl_range.c index 123b6263..2653fc4e 100644 --- a/isl_range.c +++ b/isl_range.c @@ -44,11 +44,13 @@ static int has_sign(__isl_keep isl_basic_set *bset, bset = isl_basic_set_move_dims(bset, isl_dim_set, 0, isl_dim_param, 0, nparam); - poly = isl_qpolynomial_move_dims(poly, isl_dim_set, 0, + poly = isl_qpolynomial_move_dims(poly, isl_dim_in, 0, isl_dim_param, 0, nparam); dim = isl_qpolynomial_get_space(poly); dim = isl_space_params(dim); + dim = isl_space_from_domain(dim); + dim = isl_space_add_dims(dim, isl_dim_out, 1); data_m.test_monotonicity = 0; data_m.signs = signs; @@ -102,16 +104,16 @@ static int monotonicity(__isl_keep isl_basic_set *bset, unsigned nvar; ctx = isl_qpolynomial_get_ctx(poly); - dim = isl_qpolynomial_get_space(poly); + dim = isl_qpolynomial_get_domain_space(poly); nvar = isl_basic_set_dim(bset, isl_dim_set); - sub = isl_qpolynomial_var(isl_space_copy(dim), isl_dim_set, nvar - 1); + sub = isl_qpolynomial_var_on_domain(isl_space_copy(dim), isl_dim_set, nvar - 1); sub = isl_qpolynomial_add(sub, - isl_qpolynomial_rat_cst(dim, ctx->one, ctx->one)); + isl_qpolynomial_rat_cst_on_domain(dim, ctx->one, ctx->one)); diff = isl_qpolynomial_substitute(isl_qpolynomial_copy(poly), - isl_dim_set, nvar - 1, 1, &sub); + isl_dim_in, nvar - 1, 1, &sub); diff = isl_qpolynomial_sub(diff, isl_qpolynomial_copy(poly)); s = has_sign(bset, diff, 1, data->signs); @@ -142,9 +144,9 @@ static __isl_give isl_qpolynomial *bound2poly(__isl_take isl_constraint *bound, { if (!bound) { if (sign > 0) - return isl_qpolynomial_infty(dim); + return isl_qpolynomial_infty_on_domain(dim); else - return isl_qpolynomial_neginfty(dim); + return isl_qpolynomial_neginfty_on_domain(dim); } isl_space_free(dim); return isl_qpolynomial_from_constraint(bound, isl_dim_set, pos); @@ -229,8 +231,11 @@ static int collect_fixed_sign_terms(__isl_take isl_term *term, void *user) __isl_give isl_qpolynomial *isl_qpolynomial_terms_of_sign( __isl_keep isl_qpolynomial *poly, int *signs, int sign) { + isl_space *space; struct isl_fixed_sign_data data = { signs, sign }; - data.poly = isl_qpolynomial_zero(isl_qpolynomial_get_space(poly)); + + space = isl_qpolynomial_get_domain_space(poly); + data.poly = isl_qpolynomial_zero_on_domain(space); if (isl_qpolynomial_foreach_term(poly, collect_fixed_sign_terms, &data) < 0) goto error; @@ -296,7 +301,7 @@ static int propagate_on_bound_pair(__isl_take isl_constraint *lower, if (data->monotonicity) { isl_qpolynomial *sub; - isl_space *dim = isl_qpolynomial_get_space(data->poly); + isl_space *dim = isl_qpolynomial_get_domain_space(data->poly); if (data->monotonicity * data->sign > 0) { if (data->tight) data->tight = bound_is_integer(upper, nvar); @@ -309,14 +314,14 @@ static int propagate_on_bound_pair(__isl_take isl_constraint *lower, isl_constraint_free(upper); } poly = isl_qpolynomial_copy(data->poly); - poly = isl_qpolynomial_substitute(poly, isl_dim_set, nvar, 1, &sub); - poly = isl_qpolynomial_drop_dims(poly, isl_dim_set, nvar, 1); + poly = isl_qpolynomial_substitute(poly, isl_dim_in, nvar, 1, &sub); + poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, nvar, 1); isl_qpolynomial_free(sub); } else { isl_qpolynomial *l, *u; isl_qpolynomial *pos, *neg; - isl_space *dim = isl_qpolynomial_get_space(data->poly); + isl_space *dim = isl_qpolynomial_get_domain_space(data->poly); unsigned nparam = isl_basic_set_dim(bset, isl_dim_param); int sign = data->sign * data->signs[nparam + nvar]; @@ -328,11 +333,11 @@ static int propagate_on_bound_pair(__isl_take isl_constraint *lower, pos = isl_qpolynomial_terms_of_sign(data->poly, data->signs, sign); neg = isl_qpolynomial_terms_of_sign(data->poly, data->signs, -sign); - pos = isl_qpolynomial_substitute(pos, isl_dim_set, nvar, 1, &u); - neg = isl_qpolynomial_substitute(neg, isl_dim_set, nvar, 1, &l); + pos = isl_qpolynomial_substitute(pos, isl_dim_in, nvar, 1, &u); + neg = isl_qpolynomial_substitute(neg, isl_dim_in, nvar, 1, &l); poly = isl_qpolynomial_add(pos, neg); - poly = isl_qpolynomial_drop_dims(poly, isl_dim_set, nvar, 1); + poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, nvar, 1); isl_qpolynomial_free(u); isl_qpolynomial_free(l); @@ -368,7 +373,7 @@ static int propagate_on_domain(__isl_take isl_basic_set *bset, if (isl_qpolynomial_is_cst(poly, NULL, NULL)) { bset = isl_basic_set_project_out(bset, isl_dim_set, 0, d); - poly = isl_qpolynomial_drop_dims(poly, isl_dim_set, 0, d); + poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, 0, d); return add_guarded_poly(bset, poly, data); } diff --git a/isl_test.c b/isl_test.c index 73de7ca4..411a4e2a 100644 --- a/isl_test.c +++ b/isl_test.c @@ -1644,7 +1644,7 @@ void test_pwqp(struct isl_ctx *ctx) pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str); pwqp1 = isl_pw_qpolynomial_move_dims(pwqp1, isl_dim_param, 0, - isl_dim_set, 1, 1); + isl_dim_in, 1, 1); str = "[j] -> { [i,k] -> 1 + 9 * [i/5] + 7 * [j/11] + 4 * [k/13] }"; pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str); @@ -1783,13 +1783,13 @@ void test_bound(isl_ctx *ctx) str = "{ [[a, b, c, d] -> [e]] -> 0 }"; pwqp = isl_pw_qpolynomial_read_from_str(ctx, str); pwf = isl_pw_qpolynomial_bound(pwqp, isl_fold_max, NULL); - assert(isl_pw_qpolynomial_fold_dim(pwf, isl_dim_set) == 4); + assert(isl_pw_qpolynomial_fold_dim(pwf, isl_dim_in) == 4); isl_pw_qpolynomial_fold_free(pwf); str = "{ [[x]->[x]] -> 1 : exists a : x = 2 a }"; pwqp = isl_pw_qpolynomial_read_from_str(ctx, str); pwf = isl_pw_qpolynomial_bound(pwqp, isl_fold_max, NULL); - assert(isl_pw_qpolynomial_fold_dim(pwf, isl_dim_set) == 1); + assert(isl_pw_qpolynomial_fold_dim(pwf, isl_dim_in) == 1); isl_pw_qpolynomial_fold_free(pwf); } @@ -2264,15 +2264,15 @@ int test_aff(isl_ctx *ctx) dim = isl_space_set_alloc(ctx, 0, 1); ls = isl_local_space_from_space(dim); - aff = isl_aff_zero(ls); + aff = isl_aff_zero_on_domain(ls); - aff = isl_aff_add_coefficient_si(aff, isl_dim_set, 0, 1); + aff = isl_aff_add_coefficient_si(aff, isl_dim_in, 0, 1); aff = isl_aff_scale_down_ui(aff, 3); aff = isl_aff_floor(aff); - aff = isl_aff_add_coefficient_si(aff, isl_dim_set, 0, 1); + aff = isl_aff_add_coefficient_si(aff, isl_dim_in, 0, 1); aff = isl_aff_scale_down_ui(aff, 2); aff = isl_aff_floor(aff); - aff = isl_aff_add_coefficient_si(aff, isl_dim_set, 0, 1); + aff = isl_aff_add_coefficient_si(aff, isl_dim_in, 0, 1); str = "{ [10] }"; set = isl_set_read_from_str(ctx, str, 0); diff --git a/isl_union_templ.c b/isl_union_templ.c index 9b54e1cd..1ee7d05b 100644 --- a/isl_union_templ.c +++ b/isl_union_templ.c @@ -263,6 +263,21 @@ S(UNION,align) { UNION *res; }; +#ifdef ALIGN_DOMAIN +static int align_entry(__isl_take PART *part, void *user) +{ + isl_reordering *exp; + S(UNION,align) *data = user; + + exp = isl_reordering_extend_space(isl_reordering_copy(data->exp), + FN(PART,get_domain_space)(part)); + + data->res = FN(FN(UNION,add),PARTS)(data->res, + FN(PART,realign_domain)(part, exp)); + + return 0; +} +#else static int align_entry(__isl_take PART *part, void *user) { isl_reordering *exp; @@ -276,6 +291,7 @@ static int align_entry(__isl_take PART *part, void *user) return 0; } +#endif __isl_give UNION *FN(UNION,align_params)(__isl_take UNION *u, __isl_take isl_space *model) @@ -494,16 +510,23 @@ __isl_give isl_qpolynomial *FN(UNION,eval)(__isl_take UNION *u, { uint32_t hash; struct isl_hash_table_entry *entry; + isl_space *space; isl_qpolynomial *qp; if (!u || !pnt) goto error; - hash = isl_space_get_hash(pnt->dim); + space = isl_space_copy(pnt->dim); + space = isl_space_from_domain(space); + space = isl_space_add_dims(space, isl_dim_out, 1); + if (!space) + goto error; + hash = isl_space_get_hash(space); entry = isl_hash_table_find(u->dim->ctx, &u->table, - hash, &has_dim, pnt->dim, 0); + hash, &has_dim, space, 0); + isl_space_free(space); if (!entry) { - qp = isl_qpolynomial_zero(isl_space_copy(pnt->dim)); + qp = isl_qpolynomial_zero_on_domain(isl_space_copy(pnt->dim)); isl_point_free(pnt); } else { qp = FN(PART,eval)(FN(PART,copy)(entry->data), pnt); -- 2.11.4.GIT