return NULL;
}
-static struct isl_basic_set *isl_basic_set_from_vec(struct isl_ctx *ctx,
- struct isl_vec *vec)
+static struct isl_basic_set *isl_basic_set_from_vec(struct isl_vec *vec)
{
int i;
int k;
struct isl_basic_set *bset = NULL;
+ struct isl_ctx *ctx;
unsigned dim;
if (!vec)
return NULL;
+ ctx = vec->ctx;
isl_assert(ctx, vec->size != 0, goto error);
bset = isl_basic_set_alloc(ctx, 0, vec->size - 1, 0, vec->size - 1, 0);
if (k < 0)
goto error;
isl_seq_clr(bset->eq[k], 1 + dim);
- isl_int_neg(bset->eq[k][0], vec->block.data[1 + i]);
- isl_int_set(bset->eq[k][1 + i], vec->block.data[0]);
+ isl_int_neg(bset->eq[k][0], vec->el[1 + i]);
+ isl_int_set(bset->eq[k][1 + i], vec->el[0]);
}
- isl_vec_free(ctx, vec);
+ isl_vec_free(vec);
return bset;
error:
isl_basic_set_free(bset);
- isl_vec_free(ctx, vec);
+ isl_vec_free(vec);
return NULL;
}
ctx->one, bset->sample->block.data + 1,
up ? ctx->one : ctx->negone, eq + 1, dim);
if (isl_basic_set_contains(bset, sample))
- return isl_basic_set_from_vec(ctx, sample);
- isl_vec_free(ctx, sample);
+ return isl_basic_set_from_vec(sample);
+ isl_vec_free(sample);
sample = NULL;
slice = isl_basic_set_copy(bset);
if (!sample)
goto error;
if (sample->size == 0) {
- isl_vec_free(ctx, sample);
+ isl_vec_free(sample);
point = isl_basic_set_empty_like(bset);
} else
- point = isl_basic_set_from_vec(ctx, sample);
+ point = isl_basic_set_from_vec(sample);
return point;
error:
if (!sample)
goto error;
if (sample->size == 0) {
- isl_vec_free(ctx, sample);
+ isl_vec_free(sample);
hull = isl_basic_set_empty_like(bset);
isl_basic_set_free(bset);
return hull;
} else
- hull = isl_basic_set_from_vec(ctx, sample);
+ hull = isl_basic_set_from_vec(sample);
if (hull->n_eq > 0) {
struct isl_basic_set *cone;
}
isl_int_clear(num);
isl_int_clear(den);
- isl_vec_free(set->ctx, obj);
+ isl_vec_free(obj);
isl_basic_set_free(lp);
isl_set_free(set);
isl_assert(set->ctx, res == isl_lp_ok, return NULL);
isl_seq_combine(dir->block.data,
bset1->ctx->one, dir->block.data,
sample->block.data[n++], bset1->ineq[i], 1 + d);
- isl_vec_free(ctx, sample);
+ isl_vec_free(sample);
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(ctx, sample);
+ isl_vec_free(sample);
isl_basic_set_free(bset1);
isl_basic_set_free(bset2);
return NULL;
hull = uset_convex_hull(set);
hull = isl_basic_set_preimage(hull, T);
- isl_vec_free(ctx, dir);
+ isl_vec_free(dir);
return hull;
error:
- isl_vec_free(ctx, dir);
+ isl_vec_free(dir);
isl_basic_set_free(bset1);
isl_basic_set_free(bset2);
return NULL;
isl_int_init(D);
- isl_vec_lcm(ctx, d, &D);
+ isl_vec_lcm(d, &D);
size = B->n_col - 1;
A = isl_mat_alloc(ctx, size, B->n_row * size);
T = isl_mat_alloc(ctx, B->n_col, 0);
isl_mat_free(ctx, cst);
isl_mat_free(ctx, B);
- isl_vec_free(ctx, d);
+ isl_vec_free(d);
return T;
}
isl_int_init(D);
continue;
if (isl_int_is_zero(D)) {
B = isl_mat_drop_rows(ctx, B, i, 1);
- d = isl_vec_cow(ctx, d);
+ d = isl_vec_cow(d);
if (!B || !d)
goto error2;
isl_seq_cpy(d->block.data+i, d->block.data+i+1,
goto error2;
isl_seq_scale_down(B->row[i] + 1, B->row[i] + 1, D, B->n_col-1);
isl_int_gcd(D, D, d->block.data[i]);
- d = isl_vec_cow(ctx, d);
+ d = isl_vec_cow(d);
if (!d)
goto error2;
isl_int_divexact(d->block.data[i], d->block.data[i], D);
isl_mat_sub_copy(ctx, T->row + 1, cst->row, cst->n_row, 0, 0, 1);
isl_mat_free(ctx, cst);
isl_mat_free(ctx, B);
- isl_vec_free(ctx, d);
+ isl_vec_free(d);
return T;
error2:
isl_int_clear(D);
error:
isl_mat_free(ctx, cst);
isl_mat_free(ctx, B);
- isl_vec_free(ctx, d);
+ isl_vec_free(d);
return NULL;
}
return NULL;
dup_constraints(dup, bmap);
dup->flags = bmap->flags;
- dup->sample = isl_vec_copy(bmap->ctx, bmap->sample);
+ dup->sample = isl_vec_copy(bmap->sample);
return dup;
}
isl_blk_free(bmap->ctx, bmap->block2);
free(bmap->ineq);
isl_blk_free(bmap->ctx, bmap->block);
- isl_vec_free(bmap->ctx, bmap->sample);
+ isl_vec_free(bmap->sample);
isl_dim_free(bmap->dim);
free(bmap);
}
isl_int_init(s);
for (i = 0; i < bmap->n_eq; ++i) {
- isl_seq_inner_product(vec->block.data, bmap->eq[i], total, &s);
+ isl_seq_inner_product(vec->el, bmap->eq[i], total, &s);
if (!isl_int_is_zero(s)) {
isl_int_clear(s);
return 0;
}
for (i = 0; i < bmap->n_ineq; ++i) {
- isl_seq_inner_product(vec->block.data, bmap->ineq[i], total, &s);
+ isl_seq_inner_product(vec->el, bmap->ineq[i], total, &s);
if (isl_int_is_neg(s)) {
isl_int_clear(s);
return 0;
if (bmap1->sample &&
basic_map_contains(bmap1, bmap1->sample) > 0 &&
basic_map_contains(bmap2, bmap1->sample) > 0)
- sample = isl_vec_copy(bmap1->ctx, bmap1->sample);
+ sample = isl_vec_copy(bmap1->sample);
else if (bmap2->sample &&
basic_map_contains(bmap1, bmap2->sample) > 0 &&
basic_map_contains(bmap2, bmap2->sample) > 0)
- sample = isl_vec_copy(bmap2->ctx, bmap2->sample);
+ sample = isl_vec_copy(bmap2->sample);
bmap1 = isl_basic_map_cow(bmap1);
bmap1 = isl_basic_map_extend_dim(bmap1, isl_dim_copy(bmap1->dim),
bmap1 = add_constraints(bmap1, bmap2, 0, 0);
if (sample) {
- isl_vec_free(bmap1->ctx, bmap1->sample);
+ isl_vec_free(bmap1->sample);
bmap1->sample = sample;
}
return isl_basic_map_finalize(bmap1);
error:
if (sample)
- isl_vec_free(bmap1->ctx, sample);
+ isl_vec_free(sample);
isl_basic_map_free(bmap1);
isl_basic_map_free(bmap2);
return NULL;
return -1;
empty = sample->size == 0;
if (bmap->sample)
- isl_vec_free(bmap->ctx, bmap->sample);
+ isl_vec_free(bmap->sample);
bmap->sample = sample;
if (empty)
ISL_F_SET(bmap, ISL_BASIC_MAP_EMPTY);
isl_int_clear(num);
isl_int_clear(den);
isl_basic_map_free(bmap1);
- isl_vec_free(ctx, obj);
+ isl_vec_free(obj);
return cmp;
error:
isl_basic_map_free(bmap1);
isl_seq_first_non_zero(v->block.data + 1, total) == -1)
goto disjoint;
}
- isl_vec_free(bmap1->ctx, v);
+ isl_vec_free(v);
free(elim);
return 0;
disjoint:
- isl_vec_free(bmap1->ctx, v);
+ isl_vec_free(v);
free(elim);
return 1;
error:
- isl_vec_free(bmap1->ctx, v);
+ isl_vec_free(v);
free(elim);
return -1;
}
if (!isl_int_is_neg(bmap->ineq[u][1 + dim + i]))
continue;
construct_test_ineq(bmap, i, l, u,
- vec->block.data, g, fl, fu);
- res = isl_tab_min(ctx, tab, vec->block.data,
+ vec->el, g, fl, fu);
+ res = isl_tab_min(ctx, tab, vec->el,
ctx->one, &g, NULL);
if (res == isl_lp_error)
goto error;
}
isl_tab_free(ctx, tab);
- isl_vec_free(ctx, vec);
+ isl_vec_free(vec);
isl_int_clear(g);
isl_int_clear(fl);
isl_basic_map_free(bmap);
if (ctx) {
isl_tab_free(ctx, tab);
- isl_vec_free(ctx, vec);
+ isl_vec_free(vec);
}
isl_int_clear(g);
isl_int_clear(fl);
goto error;
for (i = 0; i < prod->size; ++i)
- isl_seq_inner_product(mat->row[i], vec->block.data, vec->size,
+ isl_seq_inner_product(mat->row[i], vec->el, vec->size,
&prod->block.data[i]);
isl_mat_free(ctx, mat);
- isl_vec_free(ctx, vec);
+ isl_vec_free(vec);
return prod;
error:
isl_mat_free(ctx, mat);
- isl_vec_free(ctx, vec);
+ isl_vec_free(vec);
return NULL;
}
}
isl_int_clear(t);
if (i < bset->n_ineq) {
- isl_vec_free(ctx, sample);
+ isl_vec_free(sample);
sample = isl_vec_alloc(ctx, 0);
}
}
isl_basic_set_free(bset);
return vec;
error:
- isl_vec_free(ctx, vec);
+ isl_vec_free(vec);
isl_basic_set_free(bset);
if (sol)
pip_quast_free(sol);
if (isl_blk_is_error(vec->block))
goto error;
+ vec->ctx = ctx;
+ isl_ctx_ref(ctx);
vec->ref = 1;
vec->size = size;
+ vec->el = vec->block.data;
return vec;
error:
return NULL;
}
-struct isl_vec *isl_vec_copy(struct isl_ctx *ctx, struct isl_vec *vec)
+struct isl_vec *isl_vec_copy(struct isl_vec *vec)
{
if (!vec)
return NULL;
return vec;
}
-struct isl_vec *isl_vec_dup(struct isl_ctx *ctx, struct isl_vec *vec)
+struct isl_vec *isl_vec_dup(struct isl_vec *vec)
{
struct isl_vec *vec2;
if (!vec)
return NULL;
- vec2 = isl_vec_alloc(ctx, vec->size);
- isl_seq_cpy(vec2->block.data, vec->block.data, vec->size);
+ vec2 = isl_vec_alloc(vec->ctx, vec->size);
+ isl_seq_cpy(vec2->el, vec->el, vec->size);
return vec2;
}
-struct isl_vec *isl_vec_cow(struct isl_ctx *ctx, struct isl_vec *vec)
+struct isl_vec *isl_vec_cow(struct isl_vec *vec)
{
struct isl_vec *vec2;
if (!vec)
if (vec->ref == 1)
return vec;
- vec2 = isl_vec_dup(ctx, vec);
- isl_vec_free(ctx, vec);
+ vec2 = isl_vec_dup(vec);
+ isl_vec_free( vec);
return vec2;
}
-void isl_vec_free(struct isl_ctx *ctx, struct isl_vec *vec)
+void isl_vec_free(struct isl_vec *vec)
{
if (!vec)
return;
if (--vec->ref > 0)
return;
- isl_blk_free(ctx, vec->block);
+ isl_ctx_deref(vec->ctx);
+ isl_blk_free(vec->ctx, vec->block);
free(vec);
}
-void isl_vec_dump(struct isl_ctx *ctx, struct isl_vec *vec,
- FILE *out, int indent)
+void isl_vec_dump(struct isl_vec *vec, FILE *out, int indent)
{
int i;
for (i = 0; i < vec->size; ++i) {
if (i)
fprintf(out, ",");
- isl_int_print(out, vec->block.data[i], 0);
+ isl_int_print(out, vec->el[i], 0);
}
fprintf(out, "]\n");
}
-void isl_vec_lcm(struct isl_ctx *ctx, struct isl_vec *vec, isl_int *lcm)
+void isl_vec_lcm(struct isl_vec *vec, isl_int *lcm)
{
isl_seq_lcm(vec->block.data, vec->size, lcm);
}
struct isl_vec {
int ref;
+ struct isl_ctx *ctx;
+
unsigned size;
+ isl_int *el;
struct isl_blk block;
};
struct isl_vec *isl_vec_alloc(struct isl_ctx *ctx, unsigned size);
-struct isl_vec *isl_vec_copy(struct isl_ctx *ctx, struct isl_vec *vec);
-struct isl_vec *isl_vec_cow(struct isl_ctx *ctx, struct isl_vec *vec);
-void isl_vec_free(struct isl_ctx *ctx, struct isl_vec *vec);
+struct isl_vec *isl_vec_copy(struct isl_vec *vec);
+struct isl_vec *isl_vec_cow(struct isl_vec *vec);
+void isl_vec_free(struct isl_vec *vec);
-void isl_vec_dump(struct isl_ctx *ctx, struct isl_vec *vec,
- FILE *out, int indent);
+void isl_vec_dump(struct isl_vec *vec, FILE *out, int indent);
-void isl_vec_lcm(struct isl_ctx *ctx, struct isl_vec *vec, isl_int *lcm);
+void isl_vec_lcm(struct isl_vec *vec, isl_int *lcm);
#if defined(__cplusplus)
}