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 <skimo@kotnet.org>
directly using C<isl_space_params_alloc> or from other spaces using
C<isl_space_params>.
+=item * The space in which C<isl_aff>, C<isl_pw_aff>, C<isl_qpolynomial>,
+C<isl_pw_qpolynomial>, C<isl_qpolynomial_fold> and C<isl_pw_qpolynomial_fold>
+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<isl_aff> are now considered to be of type
+C<isl_dim_in> instead of C<isl_dim_set>. 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
__isl_keep isl_constraint *constraint);
#include <isl/polynomial.h>
+ __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/aff.h>
+ __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);
=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<isl_div>:
#include <isl/div.h>
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,
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<domain> 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
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);
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,
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);
#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,
__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);
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);
__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);
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(
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);
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;
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);
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
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);
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);
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));
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));
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));
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);
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,
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));
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));
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);
}
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) {
*/
__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));
*/
__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));
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;
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;
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
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;
#include <isl/mat.h>
#include <isl/local_space.h>
+/* ls represents the domain space.
+ */
struct isl_aff {
int ref;
__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,
__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);
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);
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]);
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];
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;
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);
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);
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));
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));
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;
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);
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);
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);
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,
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);
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);
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)
__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)
__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)
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);
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;
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;
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)
{
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;
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,
#define PART isl_pw_qpolynomial_fold
#undef PARTS
#define PARTS pw_qpolynomial_fold
+#define ALIGN_DOMAIN
#include <isl_union_templ.c>
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]),
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]),
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;
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;
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
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)
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);
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);
/* 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;
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);
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);
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);
}
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));
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;
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;
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;
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);
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);
} 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;
}
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;
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);
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);
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);
}
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, " -> ");
}
}
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");
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, " -> ");
}
}
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");
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);
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)
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);
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;
}
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;
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;
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)
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;
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;
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]) {
{
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;
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;
}
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);
}
#define PART isl_pw_qpolynomial
#undef PARTS
#define PARTS pw_qpolynomial
+#define ALIGN_DOMAIN
#include <isl_union_templ.c>
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;
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);
{
struct isl_upoly *up;
+ dim = isl_space_domain(dim);
if (!dim)
return NULL;
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;
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;
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);
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;
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);
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;
/* 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);
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;
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);
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);
}
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);
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:
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);
struct isl_upoly *p[];
};
+/* dim represents the domain space.
+ */
struct isl_qpolynomial {
int ref;
struct isl_pw_qpolynomial_piece p[1];
};
+/* dim represents the domain space.
+ */
struct isl_qpolynomial_fold {
int ref;
__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);
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,
__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);
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);
}
#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;
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;
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);
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);
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);
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));
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;
}
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);
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;
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);
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;
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);
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
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;
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,
if (!pw)
return NULL;
+ if (type == isl_dim_in)
+ type = isl_dim_set;
+
pw = FN(PW,cow)(pw);
if (!pw)
return NULL;
if (n == 0)
return pw;
+ if (type == isl_dim_in)
+ type = isl_dim_set;
+
pw = FN(PW,cow)(pw);
if (!pw)
return NULL;
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),
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)
}
#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;
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;
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;
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;
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;
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);
{
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);
__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;
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);
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];
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);
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);
}
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);
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);
}
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);
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;
return 0;
}
+#endif
__isl_give UNION *FN(UNION,align_params)(__isl_take UNION *u,
__isl_take isl_space *model)
{
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);
projects / platform / upstream / isl.git / commitdiff