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)
return bmap;
tab = isl_tab_from_basic_map(bmap);
- tab = isl_tab_detect_equalities(tab);
- tab = isl_tab_detect_redundant(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(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)
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)
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);
}
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);
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);
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]))
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);
struct isl_tab *tab;
int bounded;
- tab = isl_tab_from_recession_cone((struct isl_basic_map *)bset);
+ tab = isl_tab_from_recession_cone(bset);
bounded = isl_tab_cone_is_bounded(tab);
isl_tab_free(tab);
return bounded;
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);
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)
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)
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)
*/
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;
*/
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) {
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)
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;
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;
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);
struct sh_data *data = NULL;
struct isl_basic_set *hull = NULL;
unsigned n_ineq;
- int i, j;
+ int i;
if (!set)
return NULL;