add type to isl_{union_,}pw_qpolynomial_fold

The inner isl_qpolynomial_folds should all be of the same type,
so we need to keep track of the type at the outer level.

Signed-off-by: Sven Verdoolaege <skimo@kotnet.org>

diff --git a/include/isl_polynomial.h b/include/isl_polynomial.h
index 66c9241..b71df15 100644 (file)
--- a/include/isl_polynomial.h
+++ b/include/isl_polynomial.h
@@ -264,6 +264,7 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_from_pw_qpolynomial(
        enum isl_fold type, __isl_take isl_pw_qpolynomial *pwqp);
 
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_alloc(
+       enum isl_fold type,
        __isl_take isl_set *set, __isl_take isl_qpolynomial_fold *fold);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_copy(
        __isl_keep isl_pw_qpolynomial_fold *pwf);
@@ -284,7 +285,7 @@ int isl_pw_qpolynomial_fold_has_equal_dim(
 size_t isl_pw_qpolynomial_fold_size(__isl_keep isl_pw_qpolynomial_fold *pwf);
 
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_zero(
-       __isl_take isl_dim *dim);
+       __isl_take isl_dim *dim, enum isl_fold type);
 
 __isl_give isl_set *isl_pw_qpolynomial_fold_domain(
        __isl_take isl_pw_qpolynomial_fold *pwf);
@@ -397,7 +398,7 @@ isl_ctx *isl_union_pw_qpolynomial_fold_get_ctx(
 
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold(__isl_take isl_pw_qpolynomial_fold *pwf);
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_zero(
-       __isl_take isl_dim *dim);
+       __isl_take isl_dim *dim, enum isl_fold type);
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold_pw_qpolynomial_fold(
        __isl_take isl_union_pw_qpolynomial_fold *upwqp,
        __isl_take isl_pw_qpolynomial_fold *pwqp);

diff --git a/isl_bernstein.c b/isl_bernstein.c
index 12c1615..58fc7c9 100644 (file)
--- a/isl_bernstein.c
+++ b/isl_bernstein.c
@@ -297,9 +297,10 @@ static int bernstein_coefficients_cell(__isl_take isl_cell *cell, void *user)
        data->fold_tight = isl_qpolynomial_fold_empty(data->type, dim_param);
        extract_coefficients(poly, dom, data);
 
-       pwf = isl_pw_qpolynomial_fold_alloc(isl_set_copy(dom), data->fold);
+       pwf = isl_pw_qpolynomial_fold_alloc(data->type, isl_set_copy(dom),
+                                           data->fold);
        data->pwf = isl_pw_qpolynomial_fold_fold(data->pwf, pwf);
-       pwf = isl_pw_qpolynomial_fold_alloc(dom, data->fold_tight);
+       pwf = isl_pw_qpolynomial_fold_alloc(data->type, dom, data->fold_tight);
        data->pwf_tight = isl_pw_qpolynomial_fold_fold(data->pwf_tight, pwf);
 
        isl_qpolynomial_free(poly);
@@ -337,7 +338,7 @@ static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_base(
                dom = isl_set_from_basic_set(bset);
                if (tight)
                        *tight = 1;
-               return isl_pw_qpolynomial_fold_alloc(dom, fold);
+               return isl_pw_qpolynomial_fold_alloc(data->type, dom, fold);
        }
 
        if (isl_qpolynomial_is_zero(poly)) {
@@ -345,7 +346,7 @@ static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_base(
                isl_qpolynomial_fold *fold;
                fold = isl_qpolynomial_fold_alloc(data->type, poly);
                dom = isl_set_from_basic_set(bset);
-               pwf = isl_pw_qpolynomial_fold_alloc(dom, fold);
+               pwf = isl_pw_qpolynomial_fold_alloc(data->type, dom, fold);
                if (tight)
                        *tight = 1;
                return isl_pw_qpolynomial_fold_drop_dims(pwf,
@@ -354,8 +355,8 @@ static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_base(
 
        dim = isl_basic_set_get_dim(bset);
        dim = isl_dim_drop(dim, isl_dim_set, 0, nvar);
-       data->pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim));
-       data->pwf_tight = isl_pw_qpolynomial_fold_zero(dim);
+       data->pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim), data->type);
+       data->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, data->type);
        data->poly = isl_qpolynomial_homogenize(isl_qpolynomial_copy(poly));
        vertices = isl_basic_set_compute_vertices(bset);
        isl_vertices_foreach_disjoint_cell(vertices,

diff --git a/isl_bound.c b/isl_bound.c
index cbd2e8d..bdddfad 100644 (file)
--- a/isl_bound.c
+++ b/isl_bound.c
@@ -79,8 +79,9 @@ static int unwrapped_guarded_poly_bound(__isl_take isl_basic_set *bset,
        top_pwf = bound->pwf;
        top_pwf_tight = bound->pwf_tight;
 
-       bound->pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim));
-       bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim);
+       bound->pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim),
+                                                 bound->type);
+       bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, bound->type);
 
        r = compressed_guarded_poly_bound(bset, poly, user);
 
@@ -136,8 +137,9 @@ static int guarded_poly_bound(__isl_take isl_basic_set *bset,
        top_pwf = bound->pwf;
        top_pwf_tight = bound->pwf_tight;
 
-       bound->pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim));
-       bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim);
+       bound->pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim),
+                                                 bound->type);
+       bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, bound->type);
 
        r = unwrapped_guarded_poly_bound(bset, poly, user);
 
@@ -221,7 +223,7 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_bound(
                dim = isl_dim_drop(dim, isl_dim_set, 0, nvar);
                if (tight)
                        *tight = 1;
-               return isl_pw_qpolynomial_fold_zero(dim);
+               return isl_pw_qpolynomial_fold_zero(dim, pwf->type);
        }
 
        if (nvar == 0) {
@@ -243,8 +245,9 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_bound(
        } else
                dim = isl_dim_drop(dim, isl_dim_set, 0, nvar);
 
-       bound.pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim));
-       bound.pwf_tight = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim));
+       bound.pwf = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim), pwf->type);
+       bound.pwf_tight = isl_pw_qpolynomial_fold_zero(isl_dim_copy(dim),
+                                                       pwf->type);
        bound.check_tight = !!tight;
 
        if (isl_pw_qpolynomial_fold_foreach_lifted_piece(pwf,
@@ -319,7 +322,7 @@ __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
                data.tight = 0;
 
        dim = isl_union_pw_qpolynomial_get_dim(upwqp);
-       data.res = isl_union_pw_qpolynomial_fold_zero(dim);
+       data.res = isl_union_pw_qpolynomial_fold_zero(dim, type);
        if (isl_union_pw_qpolynomial_foreach_pw_qpolynomial(upwqp,
                                                    &bound_pw, &data) < 0)
                goto error;

diff --git a/isl_fold.c b/isl_fold.c
index 6d30d1c..c43606c 100644 (file)
--- a/isl_fold.c
+++ b/isl_fold.c
@@ -472,6 +472,8 @@ error:
        return NULL;
 }
 
+#define HAS_TYPE
+
 #undef PW
 #define PW isl_pw_qpolynomial_fold
 #undef EL
@@ -668,8 +670,13 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
                return pw1;
        }
 
+       if (pw1->type != pw2->type)
+               isl_die(set->ctx, isl_error_invalid, "fold types don't match",
+                       goto error);
+
        n = (pw1->n + 1) * (pw2->n + 1);
-       res = isl_pw_qpolynomial_fold_alloc_(isl_dim_copy(pw1->dim), n);
+       res = isl_pw_qpolynomial_fold_alloc_(isl_dim_copy(pw1->dim),
+                                               pw1->type, n);
 
        for (i = 0; i < pw1->n; ++i) {
                set = isl_set_copy(pw1->p[i].set);
@@ -792,7 +799,8 @@ __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_from_pw_qpolynomial(
        if (!pwqp)
                return NULL;
        
-       pwf = isl_pw_qpolynomial_fold_alloc_(isl_dim_copy(pwqp->dim), pwqp->n);
+       pwf = isl_pw_qpolynomial_fold_alloc_(isl_dim_copy(pwqp->dim), type,
+                                               pwqp->n);
 
        for (i = 0; i < pwqp->n; ++i)
                pwf = isl_pw_qpolynomial_fold_add_piece(pwf,

diff --git a/isl_input.c b/isl_input.c
index 10c4820..a6c5572 100644 (file)
--- a/isl_input.c
+++ b/isl_input.c
@@ -1411,7 +1411,7 @@ static struct isl_obj obj_read_poly_or_fold(struct isl_stream *s,
 
        map = read_optional_disjuncts(s, bmap, v);
        set = isl_map_range(map);
-       pwf = isl_pw_qpolynomial_fold_alloc(set, fold);
+       pwf = isl_pw_qpolynomial_fold_alloc(isl_fold_max, set, fold);
 
        vars_drop(v, v->n - n);
 

diff --git a/isl_polynomial_private.h b/isl_polynomial_private.h
index 0c41c1b..4e420ae 100644 (file)
--- a/isl_polynomial_private.h
+++ b/isl_polynomial_private.h
@@ -82,6 +82,7 @@ struct isl_pw_qpolynomial_fold_piece {
 struct isl_pw_qpolynomial_fold {
        int ref;
 
+       enum isl_fold type;
        struct isl_dim *dim;
 
        int n;

diff --git a/isl_pw_templ.c b/isl_pw_templ.c
index b176693..103353d 100644 (file)
--- a/isl_pw_templ.c
+++ b/isl_pw_templ.c
@@ -3,7 +3,12 @@
 #define xS(TYPE,NAME) struct TYPE ## _ ## NAME
 #define S(TYPE,NAME) xS(TYPE,NAME)
 
+#ifdef HAS_TYPE
+static __isl_give PW *FN(PW,alloc_)(__isl_take isl_dim *dim,
+       enum isl_fold type, int n)
+#else
 static __isl_give PW *FN(PW,alloc_)(__isl_take isl_dim *dim, int n)
+#endif
 {
        struct PW *pw;
 
@@ -16,6 +21,9 @@ static __isl_give PW *FN(PW,alloc_)(__isl_take isl_dim *dim, int n)
                goto error;
 
        pw->ref = 1;
+#ifdef HAS_TYPE
+       pw->type = type;
+#endif
        pw->size = n;
        pw->n = 0;
        pw->dim = dim;
@@ -25,10 +33,17 @@ error:
        return NULL;
 }
 
+#ifdef HAS_TYPE
+__isl_give PW *FN(PW,zero)(__isl_take isl_dim *dim, enum isl_fold type)
+{
+       return FN(PW,alloc_)(dim, type, 0);
+}
+#else
 __isl_give PW *FN(PW,zero)(__isl_take isl_dim *dim)
 {
        return FN(PW,alloc_)(dim, 0);
 }
+#endif
 
 __isl_give PW *FN(PW,add_piece)(__isl_take PW *pw,
        __isl_take isl_set *set, __isl_take EL *el)
@@ -42,6 +57,11 @@ __isl_give PW *FN(PW,add_piece)(__isl_take PW *pw,
                return pw;
        }
 
+#ifdef HAS_TYPE
+       if (pw->type != el->type)
+               isl_die(set->ctx, isl_error_invalid, "fold types don't match",
+                       goto error);
+#endif
        isl_assert(set->ctx, isl_dim_equal(pw->dim, el->dim), goto error);
        isl_assert(set->ctx, pw->n < pw->size, goto error);
 
@@ -57,14 +77,23 @@ error:
        return NULL;
 }
 
+#ifdef HAS_TYPE
+__isl_give PW *FN(PW,alloc)(enum isl_fold type,
+       __isl_take isl_set *set, __isl_take EL *el)
+#else
 __isl_give PW *FN(PW,alloc)(__isl_take isl_set *set, __isl_take EL *el)
+#endif
 {
        PW *pw;
 
        if (!set || !el)
                goto error;
 
+#ifdef HAS_TYPE
+       pw = FN(PW,alloc_)(isl_set_get_dim(set), type, 1);
+#else
        pw = FN(PW,alloc_)(isl_set_get_dim(set), 1);
+#endif
 
        return FN(PW,add_piece)(pw, set, el);
 error:
@@ -81,7 +110,11 @@ __isl_give PW *FN(PW,dup)(__isl_keep PW *pw)
        if (!pw)
                return NULL;
 
+#ifdef HAS_TYPE
+       dup = FN(PW,alloc_)(isl_dim_copy(pw->dim), pw->type, pw->n);
+#else
        dup = FN(PW,alloc_)(isl_dim_copy(pw->dim), pw->n);
+#endif
        if (!dup)
                return NULL;
 
@@ -149,6 +182,11 @@ __isl_give PW *FN(PW,add)(__isl_take PW *pw1, __isl_take PW *pw2)
        if (!pw1 || !pw2)
                goto error;
 
+#ifdef HAS_TYPE
+       if (pw1->type != pw2->type)
+               isl_die(pw1->dim->ctx, isl_error_invalid,
+                       "fold types don't match", goto error);
+#endif
        isl_assert(pw1->dim->ctx, isl_dim_equal(pw1->dim, pw2->dim), goto error);
 
        if (FN(PW,is_zero)(pw1)) {
@@ -162,7 +200,11 @@ __isl_give PW *FN(PW,add)(__isl_take PW *pw1, __isl_take PW *pw2)
        }
 
        n = (pw1->n + 1) * (pw2->n + 1);
+#ifdef HAS_TYPE
+       res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), pw1->type, n);
+#else
        res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), n);
+#endif
 
        for (i = 0; i < pw1->n; ++i) {
                set = isl_set_copy(pw1->p[i].set);
@@ -213,6 +255,11 @@ __isl_give PW *FN(PW,add_disjoint)(__isl_take PW *pw1, __isl_take PW *pw2)
        if (!pw1 || !pw2)
                goto error;
 
+#ifdef HAS_TYPE
+       if (pw1->type != pw2->type)
+               isl_die(pw1->dim->ctx, isl_error_invalid,
+                       "fold types don't match", goto error);
+#endif
        isl_assert(pw1->dim->ctx, isl_dim_equal(pw1->dim, pw2->dim), goto error);
 
        if (FN(PW,is_zero)(pw1)) {
@@ -225,7 +272,11 @@ __isl_give PW *FN(PW,add_disjoint)(__isl_take PW *pw1, __isl_take PW *pw2)
                return pw1;
        }
 
+#ifdef HAS_TYPE
+       res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), pw1->type, pw1->n + pw2->n);
+#else
        res = FN(PW,alloc_)(isl_dim_copy(pw1->dim), pw1->n + pw2->n);
+#endif
 
        for (i = 0; i < pw1->n; ++i)
                res = FN(PW,add_piece)(res,

diff --git a/isl_range.c b/isl_range.c
index 1658805..538a236 100644 (file)
--- a/isl_range.c
+++ b/isl_range.c
@@ -33,6 +33,7 @@ static int has_sign(__isl_keep isl_basic_set *bset,
        isl_dim *dim;
        isl_qpolynomial *opt;
        int r;
+       enum isl_fold type;
 
        nparam = isl_basic_set_dim(bset, isl_dim_param);
        nvar = isl_basic_set_dim(bset, isl_dim_set);
@@ -50,8 +51,9 @@ static int has_sign(__isl_keep isl_basic_set *bset,
 
        data_m.test_monotonicity = 0;
        data_m.signs = signs;
-       data_m.pwf = isl_pw_qpolynomial_fold_zero(dim);
        data_m.sign = -sign;
+       type = data_m.sign < 0 ? isl_fold_min : isl_fold_max;
+       data_m.pwf = isl_pw_qpolynomial_fold_zero(dim, type);
        data_m.tight = 0;
        data_m.pwf_tight = NULL;
 
@@ -255,7 +257,7 @@ static int add_guarded_poly(__isl_take isl_basic_set *bset,
 
        fold = isl_qpolynomial_fold_alloc(type, poly);
        set = isl_set_from_basic_set(bset);
-       pwf = isl_pw_qpolynomial_fold_alloc(set, fold);
+       pwf = isl_pw_qpolynomial_fold_alloc(type, set, fold);
        if (data->tight)
                data->pwf_tight = isl_pw_qpolynomial_fold_fold(
                                                data->pwf_tight, pwf);

diff --git a/isl_union_templ.c b/isl_union_templ.c
index 5f50ffe..ff3c6ae 100644 (file)
--- a/isl_union_templ.c
+++ b/isl_union_templ.c
@@ -15,6 +15,9 @@
 
 struct UNION {
        int ref;
+#ifdef HAS_TYPE
+       enum isl_fold type;
+#endif
        isl_dim *dim;
 
        struct isl_hash_table   table;
@@ -34,7 +37,12 @@ __isl_give isl_dim *FN(UNION,get_dim)(__isl_keep UNION *u)
        return isl_dim_copy(u->dim);
 }
 
+#ifdef HAS_TYPE
+static __isl_give UNION *FN(UNION,alloc)(__isl_take isl_dim *dim,
+       enum isl_fold type, int size)
+#else
 static __isl_give UNION *FN(UNION,alloc)(__isl_take isl_dim *dim, int size)
+#endif
 {
        UNION *u;
 
@@ -43,6 +51,9 @@ static __isl_give UNION *FN(UNION,alloc)(__isl_take isl_dim *dim, int size)
                return NULL;
 
        u->ref = 1;
+#ifdef HAS_TYPE
+       u->type = type;
+#endif
        u->dim = dim;
        if (isl_hash_table_init(dim->ctx, &u->table, size) < 0)
                goto error;
@@ -54,10 +65,17 @@ error:
        return NULL;
 }
 
+#ifdef HAS_TYPE
+__isl_give UNION *FN(UNION,zero)(__isl_take isl_dim *dim, enum isl_fold type)
+{
+       return FN(UNION,alloc)(dim, type, 16);
+}
+#else
 __isl_give UNION *FN(UNION,zero)(__isl_take isl_dim *dim)
 {
        return FN(UNION,alloc)(dim, 16);
 }
+#endif
 
 __isl_give UNION *FN(UNION,copy)(__isl_keep UNION *u)
 {
@@ -166,7 +184,11 @@ __isl_give UNION *FN(UNION,dup)(__isl_keep UNION *u)
        if (!u)
                return NULL;
 
+#ifdef HAS_TYPE
+       dup = FN(UNION,zero)(isl_dim_copy(u->dim), u->type);
+#else
        dup = FN(UNION,zero)(isl_dim_copy(u->dim));
+#endif
        if (FN(FN(UNION,foreach),PARTS)(u, &add_part, &dup) < 0)
                goto error;
        return dup;
@@ -237,7 +259,11 @@ __isl_give UNION *FN(FN(UNION,from),PARTS)(__isl_take PART *part)
        dim = FN(PART,get_dim)(part);
        dim = isl_dim_drop(dim, isl_dim_in, 0, isl_dim_size(dim, isl_dim_in));
        dim = isl_dim_drop(dim, isl_dim_out, 0, isl_dim_size(dim, isl_dim_out));
+#ifdef HAS_TYPE
+       u = FN(UNION,zero)(dim, part->type);
+#else
        u = FN(UNION,zero)(dim);
+#endif
        u = FN(FN(UNION,add),PARTS)(u, part);
 
        return u;
@@ -256,7 +282,11 @@ static __isl_give UNION *match_bin_op(__isl_take UNION *u1,
        if (!u1 || !u2)
                goto error;
 
+#ifdef HAS_TYPE
+       data.res = FN(UNION,alloc)(isl_dim_copy(u1->dim), u1->type, u1->table.n);
+#else
        data.res = FN(UNION,alloc)(isl_dim_copy(u1->dim), u1->table.n);
+#endif
        if (isl_hash_table_foreach(u1->dim->ctx, &u1->table, fn, &data) < 0)
                goto error;
 
@@ -326,7 +356,11 @@ static __isl_give UNION *match_set_op(__isl_take UNION *u,
        if (!u || !uset)
                goto error;
 
+#ifdef HAS_TYPE
+       data.res = FN(UNION,alloc)(isl_dim_copy(u->dim), u->type, u->table.n);
+#else
        data.res = FN(UNION,alloc)(isl_dim_copy(u->dim), u->table.n);
+#endif
        if (isl_hash_table_foreach(u->dim->ctx, &u->table,
                                   &match_set_entry, &data) < 0)
                goto error;