add isl_aff_mod_val

[platform/upstream/isl.git] / isl_range.c

diff --git a/isl_range.c b/isl_range.c
index 359ae28..865cb79 100644 (file)
--- a/isl_range.c
+++ b/isl_range.c
@@ -1,3 +1,4 @@
+#include <isl_ctx_private.h>
 #include <isl/constraint.h>
 #include <isl/set.h>
 #include <isl_polynomial_private.h>
@@ -30,7 +31,7 @@ static int has_sign(__isl_keep isl_basic_set *bset,
        struct range_data data_m;
        unsigned nvar;
        unsigned nparam;
-       isl_dim *dim;
+       isl_space *dim;
        isl_qpolynomial *opt;
        int r;
        enum isl_fold type;
@@ -43,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_dim(poly);
-       dim = isl_dim_drop(dim, isl_dim_set, 0, isl_dim_size(dim, isl_dim_set));
+       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;
@@ -93,7 +96,7 @@ static int monotonicity(__isl_keep isl_basic_set *bset,
        __isl_keep isl_qpolynomial *poly, struct range_data *data)
 {
        isl_ctx *ctx;
-       isl_dim *dim;
+       isl_space *dim;
        isl_qpolynomial *sub = NULL;
        isl_qpolynomial *diff = NULL;
        int result = 0;
@@ -101,16 +104,16 @@ static int monotonicity(__isl_keep isl_basic_set *bset,
        unsigned nvar;
 
        ctx = isl_qpolynomial_get_ctx(poly);
-       dim = isl_qpolynomial_get_dim(poly);
+       dim = isl_qpolynomial_get_domain_space(poly);
 
        nvar = isl_basic_set_dim(bset, isl_dim_set);
 
-       sub = isl_qpolynomial_var(isl_dim_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);
@@ -137,15 +140,15 @@ error:
 }
 
 static __isl_give isl_qpolynomial *bound2poly(__isl_take isl_constraint *bound,
-       __isl_take isl_dim *dim, unsigned pos, int sign)
+       __isl_take isl_space *dim, unsigned pos, int sign)
 {
        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_dim_free(dim);
+       isl_space_free(dim);
        return isl_qpolynomial_from_constraint(bound, isl_dim_set, pos);
 }
 
@@ -228,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_dim(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;
@@ -251,6 +257,9 @@ static int add_guarded_poly(__isl_take isl_basic_set *bset,
        isl_qpolynomial_fold *fold;
        isl_pw_qpolynomial_fold *pwf;
 
+       bset = isl_basic_set_params(bset);
+       poly = isl_qpolynomial_project_domain_on_params(poly);
+
        fold = isl_qpolynomial_fold_alloc(type, poly);
        set = isl_set_from_basic_set(bset);
        pwf = isl_pw_qpolynomial_fold_alloc(type, set, fold);
@@ -292,7 +301,7 @@ static int propagate_on_bound_pair(__isl_take isl_constraint *lower,
 
        if (data->monotonicity) {
                isl_qpolynomial *sub;
-               isl_dim *dim = isl_qpolynomial_get_dim(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);
@@ -305,30 +314,30 @@ 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_dim *dim = isl_qpolynomial_get_dim(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];
 
                data->tight = 0;
 
-               u = bound2poly(upper, isl_dim_copy(dim), nvar, 1);
+               u = bound2poly(upper, isl_space_copy(dim), nvar, 1);
                l = bound2poly(lower, dim, nvar, -1);
 
                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);
@@ -364,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);
        }
 
@@ -431,7 +440,7 @@ static int qpolynomial_bound_on_domain_range(__isl_take isl_basic_set *bset,
 {
        unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
        unsigned nvar = isl_basic_set_dim(bset, isl_dim_set);
-       isl_set *set;
+       isl_set *set = NULL;
 
        if (!bset)
                goto error;