add isl_qpolynomial_as_polynomial_on_domain

diff --git a/include/isl_polynomial.h b/include/isl_polynomial.h
index d07541d..71115fc 100644 (file)
--- a/include/isl_polynomial.h
+++ b/include/isl_polynomial.h
@@ -61,6 +61,11 @@ __isl_give isl_qpolynomial *isl_qpolynomial_substitute(
        enum isl_dim_type type, unsigned first, unsigned n,
        __isl_keep isl_qpolynomial **subs);
 
+int isl_qpolynomial_as_polynomial_on_domain(__isl_keep isl_qpolynomial *qp,
+       __isl_keep isl_basic_set *bset,
+       int (*fn)(__isl_take isl_basic_set *bset,
+                 __isl_take isl_qpolynomial *poly, void *user), void *user);
+
 struct isl_term;
 typedef struct isl_term isl_term;
 

diff --git a/isl_map.c b/isl_map.c
index 02c3f0b..793b061 100644 (file)
--- a/isl_map.c
+++ b/isl_map.c
@@ -3096,27 +3096,43 @@ error:
  *
  *             f - m d >= n
  */
-int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
+int isl_basic_map_add_div_constraints_var(__isl_keep isl_basic_map *bmap,
+       unsigned pos, isl_int *div)
 {
        int i, j;
        unsigned total = isl_basic_map_total_dim(bmap);
-       unsigned div_pos = 1 + total - bmap->n_div + div;
 
        i = isl_basic_map_alloc_inequality(bmap);
        if (i < 0)
                return -1;
-       isl_seq_cpy(bmap->ineq[i], bmap->div[div]+1, 1+total);
-       isl_int_neg(bmap->ineq[i][div_pos], bmap->div[div][0]);
+       isl_seq_cpy(bmap->ineq[i], div + 1, 1 + total);
+       isl_int_neg(bmap->ineq[i][1 + pos], div[0]);
 
        j = isl_basic_map_alloc_inequality(bmap);
        if (j < 0)
                return -1;
        isl_seq_neg(bmap->ineq[j], bmap->ineq[i], 1 + total);
-       isl_int_add(bmap->ineq[j][0], bmap->ineq[j][0], bmap->ineq[j][div_pos]);
+       isl_int_add(bmap->ineq[j][0], bmap->ineq[j][0], bmap->ineq[j][1 + pos]);
        isl_int_sub_ui(bmap->ineq[j][0], bmap->ineq[j][0], 1);
        return j;
 }
 
+int isl_basic_set_add_div_constraints_var(__isl_keep isl_basic_set *bset,
+       unsigned pos, isl_int *div)
+{
+       return isl_basic_map_add_div_constraints_var((isl_basic_map *)bset,
+                                                       pos, div);
+}
+
+int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
+{
+       unsigned total = isl_basic_map_total_dim(bmap);
+       unsigned div_pos = total - bmap->n_div + div;
+
+       return isl_basic_map_add_div_constraints_var(bmap, div_pos,
+                                                       bmap->div[div]);
+}
+
 struct isl_basic_set *isl_basic_map_underlying_set(
                struct isl_basic_map *bmap)
 {

diff --git a/isl_map_private.h b/isl_map_private.h
index bf39e98..4b2b39a 100644 (file)
--- a/isl_map_private.h
+++ b/isl_map_private.h
@@ -166,3 +166,6 @@ int isl_set_contains_point(__isl_keep isl_set *set, __isl_keep isl_point *point)
 
 int isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
        unsigned first, unsigned n, int *signs);
+
+int isl_basic_set_add_div_constraints_var(__isl_keep isl_basic_set *bset,
+       unsigned pos, isl_int *div);

diff --git a/isl_polynomial.c b/isl_polynomial.c
index 252eeec..18c8ea3 100644 (file)
--- a/isl_polynomial.c
+++ b/isl_polynomial.c
@@ -2237,6 +2237,32 @@ error:
        return NULL;
 }
 
+
+__isl_give struct isl_upoly *isl_upoly_from_affine(isl_ctx *ctx, isl_int *f,
+       isl_int denom, unsigned len)
+{
+       int i;
+       struct isl_upoly *up;
+
+       isl_assert(ctx, len >= 1, return NULL);
+
+       up = isl_upoly_rat_cst(ctx, f[0], denom);
+       for (i = 0; i < len - 1; ++i) {
+               struct isl_upoly *t;
+               struct isl_upoly *c;
+
+               if (isl_int_is_zero(f[1 + i]))
+                       continue;
+
+               c = isl_upoly_rat_cst(ctx, f[1 + i], denom);
+               t = isl_upoly_pow(ctx, i, 1);
+               t = isl_upoly_mul(c, t);
+               up = isl_upoly_sum(up, t);
+       }
+
+       return up;
+}
+
 __isl_give struct isl_upoly *isl_upoly_subs(__isl_take struct isl_upoly *up,
        unsigned first, unsigned n, __isl_keep struct isl_upoly **subs)
 {
@@ -2334,6 +2360,65 @@ error:
        return NULL;
 }
 
+__isl_give isl_basic_set *add_div_constraints(__isl_take isl_basic_set *bset,
+       __isl_take isl_mat *div)
+{
+       int i;
+       unsigned total;
+
+       if (!bset || !div)
+               goto error;
+
+       bset = isl_basic_set_extend_constraints(bset, 0, 2 * div->n_row);
+       if (!bset)
+               goto error;
+       total = isl_basic_set_total_dim(bset);
+       for (i = 0; i < div->n_row; ++i)
+               if (isl_basic_set_add_div_constraints_var(bset,
+                                   total - div->n_row + i, div->row[i]) < 0)
+                       goto error;
+
+       isl_mat_free(div);
+       return bset;
+error:
+       isl_mat_free(div);
+       isl_basic_set_free(bset);
+       return NULL;
+}
+
+/* Extend "bset" with extra set dimensions for each integer division
+ * in "qp" and then call "fn" with the extended bset and the polynomial
+ * that results from replacing each of the integer divisions by the
+ * corresponding extra set dimension.
+ */
+int isl_qpolynomial_as_polynomial_on_domain(__isl_keep isl_qpolynomial *qp,
+       __isl_keep isl_basic_set *bset,
+       int (*fn)(__isl_take isl_basic_set *bset,
+                 __isl_take isl_qpolynomial *poly, void *user), void *user)
+{
+       isl_dim *dim;
+       isl_mat *div;
+       isl_qpolynomial *poly;
+
+       if (!qp || !bset)
+               goto error;
+       if (qp->div->n_row == 0)
+               return fn(isl_basic_set_copy(bset), isl_qpolynomial_copy(qp),
+                         user);
+
+       div = isl_mat_copy(qp->div);
+       dim = isl_dim_copy(qp->dim);
+       dim = isl_dim_add(dim, isl_dim_set, qp->div->n_row);
+       poly = isl_qpolynomial_alloc(dim, 0, isl_upoly_copy(qp->upoly));
+       bset = isl_basic_set_copy(bset);
+       bset = isl_basic_set_add(bset, isl_dim_set, qp->div->n_row);
+       bset = add_div_constraints(bset, div);
+
+       return fn(bset, poly, user);
+error:
+       return -1;
+}
+
 __isl_give isl_term *isl_term_alloc(__isl_take isl_dim *dim,
        __isl_take isl_mat *div)
 {