isl_tab_detect_redundant: return status instead of isl_tab *

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

diff --git a/isl_convex_hull.c b/isl_convex_hull.c
index 8e594da..c6f2806 100644 (file)
--- a/isl_convex_hull.c
+++ b/isl_convex_hull.c
@@ -50,7 +50,8 @@ int isl_basic_map_constraint_is_redundant(struct isl_basic_map **bmap,
        if (i < total)
                return 0;
 
-       res = isl_solve_lp(*bmap, 0, c, (*bmap)->ctx->one, opt_n, opt_d);
+       res = isl_basic_map_solve_lp(*bmap, 0, c, (*bmap)->ctx->one,
+                                       opt_n, opt_d, NULL);
        if (res == isl_lp_unbounded)
                return 0;
        if (res == isl_lp_error)
@@ -93,13 +94,18 @@ struct isl_basic_map *isl_basic_map_convex_hull(struct isl_basic_map *bmap)
                return bmap;
 
        tab = isl_tab_from_basic_map(bmap);
-       tab = isl_tab_detect_equalities(bmap->ctx, tab);
-       tab = isl_tab_detect_redundant(bmap->ctx, tab);
+       tab = isl_tab_detect_implicit_equalities(tab);
+       if (isl_tab_detect_redundant(tab) < 0)
+               goto error;
        bmap = isl_basic_map_update_from_tab(bmap, tab);
-       isl_tab_free(bmap->ctx, tab);
+       isl_tab_free(tab);
        ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
        ISL_F_SET(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
        return bmap;
+error:
+       isl_tab_free(tab);
+       isl_basic_map_free(bmap);
+       return NULL;
 }
 
 struct isl_basic_set *isl_basic_set_convex_hull(struct isl_basic_set *bset)
@@ -128,8 +134,8 @@ static int uset_is_bound(struct isl_set *set, isl_int *c, unsigned len)
                if (ISL_F_ISSET(set->p[j], ISL_BASIC_SET_EMPTY))
                        continue;
 
-               res = isl_solve_lp((struct isl_basic_map*)set->p[j],
-                               0, c, set->ctx->one, &opt, &opt_denom);
+               res = isl_basic_set_solve_lp(set->p[j],
+                               0, c, set->ctx->one, &opt, &opt_denom, NULL);
                if (res == isl_lp_unbounded)
                        break;
                if (res == isl_lp_error)
@@ -242,8 +248,7 @@ error:
        return NULL;
 }
 
-static struct isl_basic_set *isl_basic_set_set_rational(
-       struct isl_basic_set *bset)
+struct isl_basic_set *isl_basic_set_set_rational(struct isl_basic_set *bset)
 {
        if (!bset)
                return NULL;
@@ -282,14 +287,13 @@ static struct isl_basic_set *isl_basic_set_add_equality(
        struct isl_basic_set *bset, isl_int *c)
 {
        int i;
-       unsigned total;
        unsigned dim;
 
        if (ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY))
                return bset;
 
-       isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
-       isl_assert(ctx, bset->n_div == 0, goto error);
+       isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
+       isl_assert(bset->ctx, bset->n_div == 0, goto error);
        dim = isl_basic_set_n_dim(bset);
        bset = isl_basic_set_cow(bset);
        bset = isl_basic_set_extend(bset, 0, dim, 0, 1, 0);
@@ -482,8 +486,8 @@ static isl_int *wrap_facet(struct isl_set *set, isl_int *facet, isl_int *ridge)
        }
        isl_int_init(num);
        isl_int_init(den);
-       res = isl_solve_lp((struct isl_basic_map *)lp, 0,
-                                   obj->block.data, set->ctx->one, &num, &den);
+       res = isl_basic_set_solve_lp(lp, 0,
+                           obj->block.data, set->ctx->one, &num, &den, NULL);
        if (res == isl_lp_ok) {
                isl_int_neg(num, num);
                isl_seq_combine(facet, num, facet, den, ridge, dim);
@@ -523,8 +527,8 @@ static struct isl_mat *initial_facet_constraint(struct isl_set *set,
        int i;
        unsigned dim = isl_set_n_dim(set);
 
-       isl_assert(ctx, set->n > 0, goto error);
-       isl_assert(ctx, bounds->n_row == dim, goto error);
+       isl_assert(set->ctx, set->n > 0, goto error);
+       isl_assert(set->ctx, bounds->n_row == dim, goto error);
 
        while (bounds->n_row > 1) {
                slice = isl_set_copy(set);
@@ -554,7 +558,7 @@ static struct isl_mat *initial_facet_constraint(struct isl_set *set,
                while (isl_seq_first_non_zero(bounds->row[bounds->n_row-1],
                                              bounds->n_col) == -1) {
                        bounds->n_row--;
-                       isl_assert(ctx, bounds->n_row > 1, goto error);
+                       isl_assert(set->ctx, bounds->n_row > 1, goto error);
                }
                if (!wrap_facet(set, bounds->row[0],
                                          bounds->row[bounds->n_row-1]))
@@ -667,7 +671,6 @@ static struct isl_basic_set *extend(struct isl_basic_set *hull,
        int k;
        struct isl_basic_set *facet = NULL;
        struct isl_basic_set *hull_facet = NULL;
-       unsigned total;
        unsigned dim;
 
        isl_assert(set->ctx, set->n > 0, goto error);
@@ -939,9 +942,9 @@ static int isl_basic_set_is_bounded(struct isl_basic_set *bset)
        struct isl_tab *tab;
        int bounded;
 
-       tab = isl_tab_from_recession_cone((struct isl_basic_map *)bset);
-       bounded = isl_tab_cone_is_bounded(bset->ctx, tab);
-       isl_tab_free(bset->ctx, tab);
+       tab = isl_tab_from_recession_cone(bset);
+       bounded = isl_tab_cone_is_bounded(tab);
+       isl_tab_free(tab);
        return bounded;
 }
 
@@ -1167,7 +1170,6 @@ error:
 static struct isl_vec *valid_direction(
        struct isl_basic_set *bset1, struct isl_basic_set *bset2)
 {
-       struct isl_ctx *ctx = NULL;
        struct isl_basic_set *lp;
        struct isl_tab *tab;
        struct isl_vec *sample = NULL;
@@ -1178,17 +1180,16 @@ static struct isl_vec *valid_direction(
 
        if (!bset1 || !bset2)
                goto error;
-       ctx = bset1->ctx;
        lp = valid_direction_lp(isl_basic_set_copy(bset1),
                                isl_basic_set_copy(bset2));
        tab = isl_tab_from_basic_set(lp);
-       sample = isl_tab_get_sample_value(ctx, tab);
-       isl_tab_free(ctx, tab);
+       sample = isl_tab_get_sample_value(tab);
+       isl_tab_free(tab);
        isl_basic_set_free(lp);
        if (!sample)
                goto error;
        d = isl_basic_set_total_dim(bset1);
-       dir = isl_vec_alloc(ctx, 1 + d);
+       dir = isl_vec_alloc(bset1->ctx, 1 + d);
        if (!dir)
                goto error;
        isl_seq_clr(dir->block.data + 1, dir->size - 1);
@@ -1209,9 +1210,9 @@ static struct isl_vec *valid_direction(
                                bset1->ctx->one, dir->block.data,
                                sample->block.data[n++], bset1->ineq[i], 1 + d);
        isl_vec_free(sample);
+       isl_seq_normalize(bset1->ctx, dir->block.data + 1, dir->size - 1);
        isl_basic_set_free(bset1);
        isl_basic_set_free(bset2);
-       isl_seq_normalize(dir->block.data + 1, dir->size - 1);
        return dir;
 error:
        isl_vec_free(sample);
@@ -1571,7 +1572,7 @@ static void update_constraint(struct isl_ctx *ctx, struct isl_hash_table *table,
        struct max_constraint *c;
        uint32_t c_hash;
 
-       c_hash = isl_seq_hash(con + 1, len, isl_hash_init());
+       c_hash = isl_seq_get_hash(con + 1, len);
        entry = isl_hash_table_find(ctx, table, c_hash, max_constraint_equal,
                        con + 1, 0);
        if (!entry)
@@ -1604,7 +1605,7 @@ static int has_constraint(struct isl_ctx *ctx, struct isl_hash_table *table,
        struct max_constraint *c;
        uint32_t c_hash;
 
-       c_hash = isl_seq_hash(con + 1, len, isl_hash_init());
+       c_hash = isl_seq_get_hash(con + 1, len);
        entry = isl_hash_table_find(ctx, table, c_hash, max_constraint_equal,
                        con + 1, 0);
        if (!entry)
@@ -1671,8 +1672,7 @@ static struct isl_basic_set *common_constraints(struct isl_basic_set *hull,
        for (i = 0; i < min_constraints; ++i) {
                struct isl_hash_table_entry *entry;
                uint32_t c_hash;
-               c_hash = isl_seq_hash(constraints[i].c->row[0] + 1, total,
-                                       isl_hash_init());
+               c_hash = isl_seq_get_hash(constraints[i].c->row[0] + 1, total);
                entry = isl_hash_table_find(hull->ctx, table, c_hash,
                        max_constraint_equal, constraints[i].c->row[0] + 1, 1);
                if (!entry)
@@ -1789,7 +1789,6 @@ static struct isl_basic_set *uset_convex_hull_wrap(struct isl_set *set)
  */
 static struct isl_basic_set *uset_convex_hull(struct isl_set *set)
 {
-       int i;
        struct isl_basic_set *convex_hull = NULL;
        struct isl_basic_set *lin;
 
@@ -1838,7 +1837,6 @@ error:
  */
 static struct isl_basic_set *uset_convex_hull_wrap_bounded(struct isl_set *set)
 {
-       int i;
        struct isl_basic_set *convex_hull = NULL;
 
        if (isl_set_n_dim(set) == 0) {
@@ -1852,7 +1850,7 @@ static struct isl_basic_set *uset_convex_hull_wrap_bounded(struct isl_set *set)
 
        if (!set)
                goto error;
-       set = isl_set_normalize(set);
+       set = isl_set_coalesce(set);
        if (!set)
                goto error;
        if (set->n == 1) {
@@ -1975,7 +1973,7 @@ struct sh_data {
        struct isl_ctx          *ctx;
        unsigned                n;
        struct isl_hash_table   *hull_table;
-       struct sh_data_entry    p[0];
+       struct sh_data_entry    p[1];
 };
 
 static void sh_data_free(struct sh_data *data)
@@ -1987,7 +1985,7 @@ static void sh_data_free(struct sh_data *data)
        isl_hash_table_free(data->ctx, data->hull_table);
        for (i = 0; i < data->n; ++i) {
                isl_hash_table_free(data->ctx, data->p[i].table);
-               isl_tab_free(data->ctx, data->p[i].tab);
+               isl_tab_free(data->p[i].tab);
        }
        free(data);
 }
@@ -2015,7 +2013,7 @@ static int hash_ineq(struct isl_ctx *ctx, struct isl_hash_table *table,
 
        v.len = len;
        v.p = ineq;
-       c_hash = isl_seq_hash(ineq + 1, len, isl_hash_init());
+       c_hash = isl_seq_get_hash(ineq + 1, len);
        entry = isl_hash_table_find(ctx, table, c_hash, has_ineq, &v, 1);
        if (!entry)
                return - 1;
@@ -2053,7 +2051,8 @@ static struct sh_data *sh_data_alloc(struct isl_set *set, unsigned n_ineq)
        int i;
 
        data = isl_calloc(set->ctx, struct sh_data,
-               sizeof(struct sh_data) + set->n * sizeof(struct sh_data_entry));
+               sizeof(struct sh_data) +
+               (set->n - 1) * sizeof(struct sh_data_entry));
        if (!data)
                return NULL;
        data->ctx = set->ctx;
@@ -2097,7 +2096,7 @@ static int is_bound(struct sh_data *data, struct isl_set *set, int j,
 
        isl_int_init(opt);
 
-       res = isl_tab_min(data->ctx, data->p[j].tab, ineq, data->ctx->one,
+       res = isl_tab_min(data->p[j].tab, ineq, data->ctx->one,
                                &opt, NULL, 0);
        if (res == isl_lp_ok && isl_int_is_neg(opt))
                isl_int_sub(ineq[0], ineq[0], opt);
@@ -2138,7 +2137,7 @@ static struct isl_basic_set *add_bound(struct isl_basic_set *hull,
 
        v.len = isl_basic_set_total_dim(hull);
        v.p = ineq;
-       c_hash = isl_seq_hash(ineq + 1, v.len, isl_hash_init());
+       c_hash = isl_seq_get_hash(ineq + 1, v.len);
 
        entry = isl_hash_table_find(hull->ctx, data->hull_table, c_hash,
                                        has_ineq, &v, 0);
@@ -2241,7 +2240,7 @@ static struct isl_basic_set *uset_simple_hull(struct isl_set *set)
        struct sh_data *data = NULL;
        struct isl_basic_set *hull = NULL;
        unsigned n_ineq;
-       int i, j;
+       int i;
 
        if (!set)
                return NULL;