isl_{in,}equality_alloc: take isl_local_space intead of isl_space

This makes it easier to construct constraints involving existentially
quantified variables.

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

diff --git a/doc/user.pod b/doc/user.pod
index 1447ab2..6376f6e 100644 (file)
--- a/doc/user.pod
+++ b/doc/user.pod
@@ -121,6 +121,11 @@ 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.
 
+=item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>
+now take an C<isl_local_space> instead of an C<isl_space>.
+An C<isl_local_space> can be created from an C<isl_space>
+using C<isl_local_space_from_space>.
+
 =back
 
 =head1 Installation
@@ -1076,9 +1081,9 @@ using the following functions.
 
        #include <isl/constraint.h>
        __isl_give isl_constraint *isl_equality_alloc(
-               __isl_take isl_space *space);
+               __isl_take isl_local_space *ls);
        __isl_give isl_constraint *isl_inequality_alloc(
-               __isl_take isl_space *space);
+               __isl_take isl_local_space *ls);
        __isl_give isl_constraint *isl_constraint_set_constant(
                __isl_take isl_constraint *constraint, isl_int v);
        __isl_give isl_constraint *isl_constraint_set_constant_si(
@@ -1109,23 +1114,25 @@ For example, to create a set containing the even integers
 between 10 and 42, you would use the following code.
 
        isl_space *space;
+       isl_local_space *ls;
        isl_constraint *c;
        isl_basic_set *bset;
 
        space = isl_space_set_alloc(ctx, 0, 2);
        bset = isl_basic_set_universe(isl_space_copy(space));
+       ls = isl_local_space_from_space(space);
 
-       c = isl_equality_alloc(isl_space_copy(space));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
        c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_inequality_alloc(isl_space_copy(space));
+       c = isl_inequality_alloc(isl_local_space_copy(ls));
        c = isl_constraint_set_constant_si(c, -10);
        c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_inequality_alloc(space);
+       c = isl_inequality_alloc(ls);
        c = isl_constraint_set_constant_si(c, 42);
        c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
        bset = isl_basic_set_add_constraint(bset, c);

diff --git a/include/isl/constraint.h b/include/isl/constraint.h
index 50d071f..a701a51 100644 (file)
--- a/include/isl/constraint.h
+++ b/include/isl/constraint.h
@@ -10,6 +10,7 @@
 #ifndef ISL_CONSTRAINT_H
 #define ISL_CONSTRAINT_H
 
+#include <isl/local_space.h>
 #include <isl/aff_type.h>
 #include <isl/div.h>
 #include <isl/set_type.h>
@@ -24,8 +25,8 @@ typedef struct isl_constraint isl_constraint;
 
 isl_ctx *isl_constraint_get_ctx(__isl_keep isl_constraint *c);
 
-__isl_give isl_constraint *isl_equality_alloc(__isl_take isl_space *dim);
-__isl_give isl_constraint *isl_inequality_alloc(__isl_take isl_space *dim);
+__isl_give isl_constraint *isl_equality_alloc(__isl_take isl_local_space *ls);
+__isl_give isl_constraint *isl_inequality_alloc(__isl_take isl_local_space *ls);
 
 struct isl_constraint *isl_constraint_cow(struct isl_constraint *c);
 struct isl_constraint *isl_constraint_copy(struct isl_constraint *c);

diff --git a/isl_constraint.c b/isl_constraint.c
index a64a00d..428b0f3 100644 (file)
--- a/isl_constraint.c
+++ b/isl_constraint.c
@@ -53,7 +53,7 @@ static unsigned basic_set_offset(struct isl_basic_set *bset,
        }
 }
 
-__isl_give isl_constraint *isl_constraint_alloc(int eq,
+__isl_give isl_constraint *isl_constraint_alloc_vec(int eq,
        __isl_take isl_local_space *ls, __isl_take isl_vec *v)
 {
        isl_constraint *constraint;
@@ -77,6 +77,21 @@ error:
        return NULL;
 }
 
+__isl_give isl_constraint *isl_constraint_alloc(int eq,
+       __isl_take isl_local_space *ls)
+{
+       isl_ctx *ctx;
+       isl_vec *v;
+
+       if (!ls)
+               return NULL;
+
+       ctx = isl_local_space_get_ctx(ls);
+       v = isl_vec_alloc(ctx, 1 + isl_local_space_dim(ls, isl_dim_all));
+       v = isl_vec_clr(v);
+       return isl_constraint_alloc_vec(eq, ls, v);
+}
+
 struct isl_constraint *isl_basic_map_constraint(struct isl_basic_map *bmap,
        isl_int **line)
 {
@@ -97,7 +112,7 @@ struct isl_constraint *isl_basic_map_constraint(struct isl_basic_map *bmap,
        if (!v)
                goto error;
        isl_seq_cpy(v->el, line[0], v->size);
-       constraint = isl_constraint_alloc(eq, ls, v);
+       constraint = isl_constraint_alloc_vec(eq, ls, v);
 
        isl_basic_map_free(bmap);
        return constraint;
@@ -113,36 +128,14 @@ struct isl_constraint *isl_basic_set_constraint(struct isl_basic_set *bset,
        return isl_basic_map_constraint((struct isl_basic_map *)bset, line);
 }
 
-struct isl_constraint *isl_equality_alloc(__isl_take isl_space *dim)
+__isl_give isl_constraint *isl_equality_alloc(__isl_take isl_local_space *ls)
 {
-       struct isl_basic_map *bmap;
-
-       if (!dim)
-               return NULL;
-
-       bmap = isl_basic_map_alloc_space(dim, 0, 1, 0);
-       if (!bmap)
-               return NULL;
-
-       isl_basic_map_alloc_equality(bmap);
-       isl_seq_clr(bmap->eq[0], 1 + isl_basic_map_total_dim(bmap));
-       return isl_basic_map_constraint(bmap, &bmap->eq[0]);
+       return isl_constraint_alloc(1, ls);
 }
 
-struct isl_constraint *isl_inequality_alloc(__isl_take isl_space *dim)
+__isl_give isl_constraint *isl_inequality_alloc(__isl_take isl_local_space *ls)
 {
-       struct isl_basic_map *bmap;
-
-       if (!dim)
-               return NULL;
-
-       bmap = isl_basic_map_alloc_space(dim, 0, 0, 1);
-       if (!bmap)
-               return NULL;
-
-       isl_basic_map_alloc_inequality(bmap);
-       isl_seq_clr(bmap->ineq[0], 1 + isl_basic_map_total_dim(bmap));
-       return isl_basic_map_constraint(bmap, &bmap->ineq[0]);
+       return isl_constraint_alloc(0, ls);
 }
 
 struct isl_constraint *isl_constraint_dup(struct isl_constraint *c)
@@ -150,7 +143,7 @@ struct isl_constraint *isl_constraint_dup(struct isl_constraint *c)
        if (!c)
                return NULL;
 
-       return isl_constraint_alloc(c->eq, isl_local_space_copy(c->ls),
+       return isl_constraint_alloc_vec(c->eq, isl_local_space_copy(c->ls),
                                                isl_vec_copy(c->v));
 }
 

diff --git a/isl_schedule.c b/isl_schedule.c
index f14fbd9..b279281 100644 (file)
--- a/isl_schedule.c
+++ b/isl_schedule.c
@@ -1388,6 +1388,7 @@ static __isl_give isl_map *node_extract_schedule(struct isl_sched_node *node)
 {
        int i, j;
        isl_space *dim;
+       isl_local_space *ls;
        isl_basic_map *bmap;
        isl_constraint *c;
        int nrow, ncol;
@@ -1401,11 +1402,12 @@ static __isl_give isl_map *node_extract_schedule(struct isl_sched_node *node)
        dim = isl_space_from_domain(isl_space_copy(node->dim));
        dim = isl_space_add_dims(dim, isl_dim_out, nrow);
        bmap = isl_basic_map_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
        isl_int_init(v);
 
        for (i = 0; i < nrow; ++i) {
-               c = isl_equality_alloc(isl_space_copy(dim));
+               c = isl_equality_alloc(isl_local_space_copy(ls));
                isl_constraint_set_coefficient_si(c, isl_dim_out, i, -1);
                isl_mat_get_element(node->sched, i, 0, &v);
                isl_constraint_set_constant(c, v);
@@ -1423,7 +1425,7 @@ static __isl_give isl_map *node_extract_schedule(struct isl_sched_node *node)
 
        isl_int_clear(v);
 
-       isl_space_free(dim);
+       isl_local_space_free(ls);
 
        node->sched_map = isl_map_from_basic_map(bmap);
        return isl_map_copy(node->sched_map);

diff --git a/isl_test.c b/isl_test.c
index 411a4e2..2084343 100644 (file)
--- a/isl_test.c
+++ b/isl_test.c
@@ -194,28 +194,31 @@ void test_construction(struct isl_ctx *ctx)
 {
        isl_int v;
        isl_space *dim;
+       isl_local_space *ls;
        struct isl_basic_set *bset;
        struct isl_constraint *c;
 
        isl_int_init(v);
 
        dim = isl_space_set_alloc(ctx, 1, 1);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_inequality_alloc(isl_basic_set_get_space(bset));
+       c = isl_inequality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, 1);
        isl_constraint_set_coefficient(c, isl_dim_param, 0, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_inequality_alloc(isl_basic_set_get_space(bset));
+       c = isl_inequality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, 1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, -5);
        isl_constraint_set_constant(c, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
+       isl_local_space_free(ls);
        isl_basic_set_free(bset);
 
        isl_int_clear(v);
@@ -256,6 +259,7 @@ void test_div(struct isl_ctx *ctx)
 {
        isl_int v;
        isl_space *dim;
+       isl_local_space *ls;
        struct isl_basic_set *bset;
        struct isl_constraint *c;
 
@@ -263,9 +267,10 @@ void test_div(struct isl_ctx *ctx)
 
        /* test 1 */
        dim = isl_space_set_alloc(ctx, 0, 3);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_constant(c, v);
        isl_int_set_si(v, 1);
@@ -274,7 +279,7 @@ void test_div(struct isl_ctx *ctx)
        isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, 1);
        isl_constraint_set_constant(c, v);
        isl_int_set_si(v, -1);
@@ -286,13 +291,15 @@ void test_div(struct isl_ctx *ctx)
        bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
 
        assert(bset && bset->n_div == 1);
+       isl_local_space_free(ls);
        isl_basic_set_free(bset);
 
        /* test 2 */
        dim = isl_space_set_alloc(ctx, 0, 3);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, 1);
        isl_constraint_set_constant(c, v);
        isl_int_set_si(v, -1);
@@ -301,7 +308,7 @@ void test_div(struct isl_ctx *ctx)
        isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_constant(c, v);
        isl_int_set_si(v, 1);
@@ -313,13 +320,15 @@ void test_div(struct isl_ctx *ctx)
        bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
 
        assert(bset && bset->n_div == 1);
+       isl_local_space_free(ls);
        isl_basic_set_free(bset);
 
        /* test 3 */
        dim = isl_space_set_alloc(ctx, 0, 3);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, 1);
        isl_constraint_set_constant(c, v);
        isl_int_set_si(v, -1);
@@ -328,7 +337,7 @@ void test_div(struct isl_ctx *ctx)
        isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -3);
        isl_constraint_set_constant(c, v);
        isl_int_set_si(v, 1);
@@ -340,13 +349,15 @@ void test_div(struct isl_ctx *ctx)
        bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
 
        assert(bset && bset->n_div == 1);
+       isl_local_space_free(ls);
        isl_basic_set_free(bset);
 
        /* test 4 */
        dim = isl_space_set_alloc(ctx, 0, 3);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, 2);
        isl_constraint_set_constant(c, v);
        isl_int_set_si(v, -1);
@@ -355,7 +366,7 @@ void test_div(struct isl_ctx *ctx)
        isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_constant(c, v);
        isl_int_set_si(v, 1);
@@ -367,20 +378,22 @@ void test_div(struct isl_ctx *ctx)
        bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
 
        assert(isl_basic_set_is_empty(bset));
+       isl_local_space_free(ls);
        isl_basic_set_free(bset);
 
        /* test 5 */
        dim = isl_space_set_alloc(ctx, 0, 3);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, 3);
        isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, 1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, -3);
@@ -391,19 +404,21 @@ void test_div(struct isl_ctx *ctx)
 
        assert(bset && bset->n_div == 0);
        isl_basic_set_free(bset);
+       isl_local_space_free(ls);
 
        /* test 6 */
        dim = isl_space_set_alloc(ctx, 0, 3);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, 6);
        isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, 1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, -3);
@@ -414,6 +429,7 @@ void test_div(struct isl_ctx *ctx)
 
        assert(bset && bset->n_div == 1);
        isl_basic_set_free(bset);
+       isl_local_space_free(ls);
 
        /* test 7 */
        /* This test is a bit tricky.  We set up an equality
@@ -426,9 +442,10 @@ void test_div(struct isl_ctx *ctx)
         * Perhaps we can avoid the introduction of this temporary div.
         */
        dim = isl_space_set_alloc(ctx, 0, 4);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, -3);
@@ -445,13 +462,15 @@ void test_div(struct isl_ctx *ctx)
        /*
        assert(bset && bset->n_div == 1);
        */
+       isl_local_space_free(ls);
        isl_basic_set_free(bset);
 
        /* test 8 */
        dim = isl_space_set_alloc(ctx, 0, 5);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, -3);
@@ -462,7 +481,7 @@ void test_div(struct isl_ctx *ctx)
        isl_constraint_set_coefficient(c, isl_dim_set, 4, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, 1);
@@ -477,13 +496,15 @@ void test_div(struct isl_ctx *ctx)
        /*
        assert(bset && bset->n_div == 1);
        */
+       isl_local_space_free(ls);
        isl_basic_set_free(bset);
 
        /* test 9 */
        dim = isl_space_set_alloc(ctx, 0, 4);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, 1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, -1);
@@ -492,7 +513,7 @@ void test_div(struct isl_ctx *ctx)
        isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
        bset = isl_basic_set_add_constraint(bset, c);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, -1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, 3);
@@ -507,13 +528,15 @@ void test_div(struct isl_ctx *ctx)
 
        assert(!isl_basic_set_is_empty(bset));
 
+       isl_local_space_free(ls);
        isl_basic_set_free(bset);
 
        /* test 10 */
        dim = isl_space_set_alloc(ctx, 0, 3);
-       bset = isl_basic_set_universe(dim);
+       bset = isl_basic_set_universe(isl_space_copy(dim));
+       ls = isl_local_space_from_space(dim);
 
-       c = isl_equality_alloc(isl_basic_set_get_space(bset));
+       c = isl_equality_alloc(isl_local_space_copy(ls));
        isl_int_set_si(v, 1);
        isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
        isl_int_set_si(v, -2);
@@ -524,6 +547,7 @@ void test_div(struct isl_ctx *ctx)
 
        bset = isl_basic_set_fix_si(bset, isl_dim_set, 0, 2);
 
+       isl_local_space_free(ls);
        isl_basic_set_free(bset);
 
        isl_int_clear(v);