/* Look for all equalities satisfied by the integer points in bset,
* which is assumed not to have any explicit equalities.
*
* The equalities are obtained by successively looking for
* a point that is affinely independent of the points found so far.
* In particular, for each equality satisfied by the points so far,
* we check if there is any point on a hyperplane parallel to the
* corresponding hyperplane shifted by at least one (in either direction).
*
* Before looking for any outside points, we first compute the recession
* cone. The directions of this recession cone will always be part
* of the affine hull, so there is no need for looking for any points
* in these directions.
* In particular, if the recession cone is full-dimensional, then
* the affine hull is simply the whole universe.
*/
static struct isl_basic_set *uset_affine_hull(struct isl_basic_set *bset)
{
struct isl_basic_set *cone;
if (isl_basic_set_plain_is_empty(bset))
return bset;
cone = isl_basic_set_recession_cone(isl_basic_set_copy(bset));
if (!cone)
goto error;
if (cone->n_eq == 0) {
struct isl_basic_set *hull;
isl_basic_set_free(cone);
hull = isl_basic_set_universe_like(bset);
isl_basic_set_free(bset);
return hull;
}
if (cone->n_eq < isl_basic_set_total_dim(cone))
return affine_hull_with_cone(bset, cone);
isl_basic_set_free(cone);
return uset_affine_hull_bounded(bset);
error:
isl_basic_set_free(bset);
return NULL;
}
/* Compute the affine hull of "bset", where "cone" is the recession cone
* of "bset".
*
* We first compute a unimodular transformation that puts the unbounded
* directions in the last dimensions. In particular, we take a transformation
* that maps all equalities to equalities (in HNF) on the first dimensions.
* Let x be the original dimensions and y the transformed, with y_1 bounded
* and y_2 unbounded.
*
* [ y_1 ] [ y_1 ] [ Q_1 ]
* x = U [ y_2 ] [ y_2 ] = [ Q_2 ] x
*
* Let's call the input basic set S. We compute S' = preimage(S, U)
* and drop the final dimensions including any constraints involving them.
* This results in set S''.
* Then we compute the affine hull A'' of S''.
* Let F y_1 >= g be the constraint system of A''. In the transformed
* space the y_2 are unbounded, so we can add them back without any constraints,
* resulting in
*
* [ y_1 ]
* [ F 0 ] [ y_2 ] >= g
* or
* [ Q_1 ]
* [ F 0 ] [ Q_2 ] x >= g
* or
* F Q_1 x >= g
*
* The affine hull in the original space is then obtained as
* A = preimage(A'', Q_1).
*/
static struct isl_basic_set *affine_hull_with_cone(struct isl_basic_set *bset,
struct isl_basic_set *cone)
{
unsigned total;
unsigned cone_dim;
struct isl_basic_set *hull;
struct isl_mat *M, *U, *Q;
if (!bset || !cone)
goto error;
total = isl_basic_set_total_dim(cone);
cone_dim = total - cone->n_eq;
M = isl_mat_sub_alloc6(bset->ctx, cone->eq, 0, cone->n_eq, 1, total);
M = isl_mat_left_hermite(M, 0, &U, &Q);
if (!M)
goto error;
isl_mat_free(M);
U = isl_mat_lin_to_aff(U);
bset = isl_basic_set_preimage(bset, isl_mat_copy(U));
bset = isl_basic_set_drop_constraints_involving(bset, total - cone_dim,
cone_dim);
bset = isl_basic_set_drop_dims(bset, total - cone_dim, cone_dim);
Q = isl_mat_lin_to_aff(Q);
Q = isl_mat_drop_rows(Q, 1 + total - cone_dim, cone_dim);
if (bset && bset->sample && bset->sample->size == 1 + total)
bset->sample = isl_mat_vec_product(isl_mat_copy(Q), bset->sample);
hull = uset_affine_hull_bounded(bset);
if (!hull)
isl_mat_free(U);
else {
struct isl_vec *sample = isl_vec_copy(hull->sample);
U = isl_mat_drop_cols(U, 1 + total - cone_dim, cone_dim);
if (sample && sample->size > 0)
sample = isl_mat_vec_product(U, sample);
else
isl_mat_free(U);
hull = isl_basic_set_preimage(hull, Q);
if (hull) {
isl_vec_free(hull->sample);
hull->sample = sample;
} else
isl_vec_free(sample);
}
isl_basic_set_free(cone);
return hull;
error:
isl_basic_set_free(bset);
isl_basic_set_free(cone);
return NULL;
}
__isl_give isl_morph *isl_morph_alloc(
__isl_take isl_basic_set *dom, __isl_take isl_basic_set *ran,
__isl_take isl_mat *map, __isl_take isl_mat *inv)
{
isl_morph *morph;
if (!dom || !ran || !map || !inv)
goto error;
morph = isl_alloc_type(dom->ctx, struct isl_morph);
if (!morph)
goto error;
morph->ref = 1;
morph->dom = dom;
morph->ran = ran;
morph->map = map;
morph->inv = inv;
return morph;
error:
isl_basic_set_free(dom);
isl_basic_set_free(ran);
isl_mat_free(map);
isl_mat_free(inv);
return NULL;
}
/* Check if the constraints in "set" imply any stride on set dimension "pos" and
* store the results in data->stride and data->offset.
*
* In particular, compute the affine hull and then check if
* any of the constraints in the hull impose any stride on the dimension.
* If no such constraint can be found, then the offset is taken
* to be the zero expression and the stride is taken to be one.
*/
static void set_detect_stride(__isl_keep isl_set *set, int pos,
struct isl_detect_stride_data *data)
{
isl_basic_set *hull;
hull = isl_set_affine_hull(isl_set_copy(set));
data->pos = pos;
data->found = 0;
data->stride = NULL;
data->offset = NULL;
if (isl_basic_set_foreach_constraint(hull, &detect_stride, data) < 0)
goto error;
if (!data->found) {
data->stride = isl_val_one(isl_set_get_ctx(set));
if (data->want_offset) {
isl_space *space;
isl_local_space *ls;
space = isl_set_get_space(set);
ls = isl_local_space_from_space(space);
data->offset = isl_aff_zero_on_domain(ls);
}
}
isl_basic_set_free(hull);
return;
error:
isl_basic_set_free(hull);
data->stride = isl_val_free(data->stride);
data->offset = isl_aff_free(data->offset);
}
void isl_morph_free(__isl_take isl_morph *morph)
{
if (!morph)
return;
if (--morph->ref > 0)
return;
isl_basic_set_free(morph->dom);
isl_basic_set_free(morph->ran);
isl_mat_free(morph->map);
isl_mat_free(morph->inv);
free(morph);
}
/* Replace graft->enforced by "enforced".
*/
__isl_give isl_ast_graft *isl_ast_graft_set_enforced(
__isl_take isl_ast_graft *graft, __isl_take isl_basic_set *enforced)
{
if (!graft || !enforced)
goto error;
isl_basic_set_free(graft->enforced);
graft->enforced = enforced;
return graft;
error:
isl_basic_set_free(enforced);
return isl_ast_graft_free(graft);
}
static __isl_give isl_mat *isl_basic_set_scan_samples(
__isl_take isl_basic_set *bset)
{
isl_ctx *ctx;
isl_size dim;
struct scan_samples ss;
ctx = isl_basic_set_get_ctx(bset);
dim = isl_basic_set_dim(bset, isl_dim_all);
if (dim < 0)
goto error;
ss.callback.add = scan_samples_add_sample;
ss.samples = isl_mat_alloc(ctx, 0, 1 + dim);
if (!ss.samples)
goto error;
if (isl_basic_set_scan(bset, &ss.callback) < 0) {
isl_mat_free(ss.samples);
return NULL;
}
return ss.samples;
error:
isl_basic_set_free(bset);
return NULL;
}
static isl_stat add_vertex(__isl_take isl_vertex *vertex, void *user)
{
Param_Vertices ***next_V = (Param_Vertices ***) user;
Param_Vertices *V;
Polyhedron *D;
isl_basic_set *dom;
isl_multi_aff *expr;
isl_ctx *ctx;
ctx = isl_vertex_get_ctx(vertex);
dom = isl_vertex_get_domain(vertex);
D = isl_basic_set_to_polylib(dom);
isl_basic_set_free(dom);
expr = isl_vertex_get_expr(vertex);
V = isl_alloc_type(ctx, Param_Vertices);
V->Vertex = isl_multi_aff_to_polylib(expr);
V->Domain = Polyhedron2Constraints(D);
V->Facets = NULL;
V->next = NULL;
Polyhedron_Free(D);
isl_multi_aff_free(expr);
**next_V = V;
*next_V = &V->next;
isl_vertex_free(vertex);
return isl_stat_ok;
}
static struct isl_vec *interval_sample(struct isl_basic_set *bset)
{
int i;
isl_int t;
struct isl_vec *sample;
bset = isl_basic_set_simplify(bset);
if (!bset)
return NULL;
if (isl_basic_set_plain_is_empty(bset))
return empty_sample(bset);
if (bset->n_eq == 0 && bset->n_ineq == 0)
return zero_sample(bset);
sample = isl_vec_alloc(bset->ctx, 2);
if (!sample)
goto error;
if (!bset)
return NULL;
isl_int_set_si(sample->block.data[0], 1);
if (bset->n_eq > 0) {
isl_assert(bset->ctx, bset->n_eq == 1, goto error);
isl_assert(bset->ctx, bset->n_ineq == 0, goto error);
if (isl_int_is_one(bset->eq[0][1]))
isl_int_neg(sample->el[1], bset->eq[0][0]);
else {
isl_assert(bset->ctx, isl_int_is_negone(bset->eq[0][1]),
goto error);
isl_int_set(sample->el[1], bset->eq[0][0]);
}
isl_basic_set_free(bset);
return sample;
}
static isl_stat add_chamber(__isl_take isl_cell *cell, void *user)
{
struct bv_add_chamber_data *data = (struct bv_add_chamber_data *)user;
isl_ctx *ctx;
isl_basic_set *domain;
ctx = isl_cell_get_ctx(cell);
domain = isl_cell_get_domain(cell);
data->dom = isl_alloc_type(ctx, Param_Domain);
data->dom->Domain = isl_basic_set_to_polylib(domain);
data->dom->F = isl_calloc_array(ctx, unsigned, data->vertex_len);
data->dom->next = NULL;
isl_basic_set_free(domain);
*data->next_D = data->dom;
data->next_D = &data->dom->next;
isl_cell_foreach_vertex(cell, &add_chamber_vertex, data);
isl_cell_free(cell);
return isl_stat_ok;
}
/* Construct a basic set described by the "n" equalities of "bset" starting
* at "first".
*/
static __isl_give isl_basic_set *copy_equalities(__isl_keep isl_basic_set *bset,
unsigned first, unsigned n)
{
int i, k;
isl_basic_set *eq;
unsigned total;
isl_assert(bset->ctx, bset->n_div == 0, return NULL);
total = isl_basic_set_total_dim(bset);
eq = isl_basic_set_alloc_space(isl_space_copy(bset->dim), 0, n, 0);
if (!eq)
return NULL;
for (i = 0; i < n; ++i) {
k = isl_basic_set_alloc_equality(eq);
if (k < 0)
goto error;
isl_seq_cpy(eq->eq[k], bset->eq[first + k], 1 + total);
}
return eq;
error:
isl_basic_set_free(eq);
return NULL;
}
static isl_stat basic_guarded_poly_bound(__isl_take isl_basic_set *bset,
void *user)
{
struct range_data *data = (struct range_data *)user;
isl_ctx *ctx;
unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
unsigned dim = isl_basic_set_dim(bset, isl_dim_set);
isl_stat r;
data->signs = NULL;
ctx = isl_basic_set_get_ctx(bset);
data->signs = isl_alloc_array(ctx, int,
isl_basic_set_dim(bset, isl_dim_all));
if (isl_basic_set_dims_get_sign(bset, isl_dim_set, 0, dim,
data->signs + nparam) < 0)
goto error;
if (isl_basic_set_dims_get_sign(bset, isl_dim_param, 0, nparam,
data->signs) < 0)
goto error;
r = propagate_on_domain(bset, isl_qpolynomial_copy(data->poly), data);
free(data->signs);
return r;
error:
free(data->signs);
isl_basic_set_free(bset);
return isl_stat_error;
}
/* Recursively perform range propagation on the polynomial "poly"
* defined over the basic set "bset" and collect the results in "data".
*/
static isl_stat propagate_on_domain(__isl_take isl_basic_set *bset,
__isl_take isl_qpolynomial *poly, struct range_data *data)
{
isl_ctx *ctx;
isl_qpolynomial *save_poly = data->poly;
int save_monotonicity = data->monotonicity;
unsigned d;
if (!bset || !poly)
goto error;
ctx = isl_basic_set_get_ctx(bset);
d = isl_basic_set_dim(bset, isl_dim_set);
isl_assert(ctx, d >= 1, goto error);
if (isl_qpolynomial_is_cst(poly, NULL, NULL)) {
bset = isl_basic_set_project_out(bset, isl_dim_set, 0, d);
poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, 0, d);
return add_guarded_poly(bset, poly, data);
}
if (data->test_monotonicity)
data->monotonicity = monotonicity(bset, poly, data);
else
data->monotonicity = 0;
if (data->monotonicity < -1)
goto error;
data->poly = poly;
if (isl_basic_set_foreach_bound_pair(bset, isl_dim_set, d - 1,
&propagate_on_bound_pair, data) < 0)
goto error;
isl_basic_set_free(bset);
isl_qpolynomial_free(poly);
data->monotonicity = save_monotonicity;
data->poly = save_poly;
return isl_stat_ok;
error:
isl_basic_set_free(bset);
isl_qpolynomial_free(poly);
data->monotonicity = save_monotonicity;
data->poly = save_poly;
return isl_stat_error;
}
/// Add an isl basic set to a ScopLib matrix_list
///
/// @param bset The basic set to add
/// @param user The matrix list we should add the basic set to
///
/// XXX: At the moment this function expects just a matrix, as support
/// for matrix lists is currently not available in ScopLib. So union of
/// polyhedron are not yet supported
int ScopLib::domainToMatrix_basic_set(isl_basic_set *bset, void *user) {
scoplib_matrix_p m = (scoplib_matrix_p) user;
assert(!m->NbRows && "Union of polyhedron not yet supported");
isl_basic_set_foreach_constraint(bset, &domainToMatrix_constraint, user);
isl_basic_set_free(bset);
return 0;
}
static struct isl_vec *empty_sample(struct isl_basic_set *bset)
{
struct isl_vec *vec;
vec = isl_vec_alloc(bset->ctx, 0);
isl_basic_set_free(bset);
return vec;
}
struct isl_map *isl_pip_basic_map_lexopt(
struct isl_basic_map *bmap, struct isl_basic_set *dom,
struct isl_set **empty, int max)
{
isl_basic_map_free(bmap);
isl_basic_set_free(dom);
return NULL;
}
/* Look for all equalities satisfied by the integer points in bmap
* that are independent of the equalities already explicitly available
* in bmap.
*
* We first remove all equalities already explicitly available,
* then look for additional equalities in the reduced space
* and then transform the result to the original space.
* The original equalities are _not_ added to this set. This is
* the responsibility of the calling function.
* The resulting basic set has all meaning about the dimensions removed.
* In particular, dimensions that correspond to existential variables
* in bmap and that are found to be fixed are not removed.
*/
static struct isl_basic_set *equalities_in_underlying_set(
struct isl_basic_map *bmap)
{
struct isl_mat *T1 = NULL;
struct isl_mat *T2 = NULL;
struct isl_basic_set *bset = NULL;
struct isl_basic_set *hull = NULL;
bset = isl_basic_map_underlying_set(bmap);
if (!bset)
return NULL;
if (bset->n_eq)
bset = isl_basic_set_remove_equalities(bset, &T1, &T2);
if (!bset)
goto error;
hull = uset_affine_hull(bset);
if (!T2)
return hull;
if (!hull) {
isl_mat_free(T1);
isl_mat_free(T2);
} else {
struct isl_vec *sample = isl_vec_copy(hull->sample);
if (sample && sample->size > 0)
sample = isl_mat_vec_product(T1, sample);
else
isl_mat_free(T1);
hull = isl_basic_set_preimage(hull, T2);
if (hull) {
isl_vec_free(hull->sample);
hull->sample = sample;
} else
isl_vec_free(sample);
}
return hull;
error:
isl_mat_free(T2);
isl_basic_set_free(bset);
isl_basic_set_free(hull);
return NULL;
}
/* Detect and make explicit all equalities satisfied by the (integer)
* points in bmap.
*/
struct isl_basic_map *isl_basic_map_detect_equalities(
struct isl_basic_map *bmap)
{
int i, j;
struct isl_basic_set *hull = NULL;
if (!bmap)
return NULL;
if (bmap->n_ineq == 0)
return bmap;
if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
return bmap;
if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_ALL_EQUALITIES))
return bmap;
if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
return isl_basic_map_implicit_equalities(bmap);
hull = equalities_in_underlying_set(isl_basic_map_copy(bmap));
if (!hull)
goto error;
if (ISL_F_ISSET(hull, ISL_BASIC_SET_EMPTY)) {
isl_basic_set_free(hull);
return isl_basic_map_set_to_empty(bmap);
}
bmap = isl_basic_map_extend_dim(bmap, isl_dim_copy(bmap->dim), 0,
hull->n_eq, 0);
for (i = 0; i < hull->n_eq; ++i) {
j = isl_basic_map_alloc_equality(bmap);
if (j < 0)
goto error;
isl_seq_cpy(bmap->eq[j], hull->eq[i],
1 + isl_basic_set_total_dim(hull));
}
isl_vec_free(bmap->sample);
bmap->sample = isl_vec_copy(hull->sample);
isl_basic_set_free(hull);
ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT | ISL_BASIC_MAP_ALL_EQUALITIES);
bmap = isl_basic_map_simplify(bmap);
return isl_basic_map_finalize(bmap);
error:
isl_basic_set_free(hull);
isl_basic_map_free(bmap);
return NULL;
}
enum lp_result isl_constraints_opt(Matrix *C, Value *obj, Value denom,
enum lp_dir dir, Value *opt)
{
int i;
isl_ctx *ctx = isl_ctx_alloc();
isl_space *dim;
isl_local_space *ls;
isl_mat *eq, *ineq;
isl_basic_set *bset;
isl_aff *aff;
isl_val *v;
enum isl_lp_result res;
int max = dir == lp_max;
eq = extract_equalities(ctx, C);
ineq = extract_inequalities(ctx, C);
dim = isl_space_set_alloc(ctx, 0, C->NbColumns - 2);
ls = isl_local_space_from_space(isl_space_copy(dim));
bset = isl_basic_set_from_constraint_matrices(dim, eq, ineq,
isl_dim_set, isl_dim_div, isl_dim_param, isl_dim_cst);
aff = isl_aff_zero_on_domain(ls);
for (i = 0; i < C->NbColumns - 2; ++i) {
v = isl_val_int_from_gmp(ctx, obj[i]);
aff = isl_aff_set_coefficient_val(aff, isl_dim_in, i, v);
}
v = isl_val_int_from_gmp(ctx, obj[C->NbColumns - 2]);
aff = isl_aff_set_constant_val(aff, v);
v = isl_val_int_from_gmp(ctx, denom);
aff = isl_aff_scale_down_val(aff, v);
if (max)
v = isl_val_floor(isl_basic_set_max_lp_val(bset, aff));
else
v = isl_val_ceil(isl_basic_set_min_lp_val(bset, aff));
if (!v)
res = isl_lp_error;
else if (isl_val_is_nan(v))
res = isl_lp_empty;
else if (!isl_val_is_rat(v))
res = isl_lp_unbounded;
else {
res = isl_lp_ok;
isl_val_get_num_gmp(v, *opt);
}
isl_val_free(v);
isl_aff_free(aff);
isl_basic_set_free(bset);
isl_ctx_free(ctx);
return isl_lp_result2lp_result(res);
}
/* The implementation is based on Section 5.2 of Michael Karr,
* "Affine Relationships Among Variables of a Program",
* except that the echelon form we use starts from the last column
* and that we are dealing with integer coefficients.
*/
static struct isl_basic_set *affine_hull(
struct isl_basic_set *bset1, struct isl_basic_set *bset2)
{
unsigned total;
int col;
int row;
if (!bset1 || !bset2)
goto error;
total = 1 + isl_basic_set_n_dim(bset1);
row = 0;
for (col = total-1; col >= 0; --col) {
int is_zero1 = row >= bset1->n_eq ||
isl_int_is_zero(bset1->eq[row][col]);
int is_zero2 = row >= bset2->n_eq ||
isl_int_is_zero(bset2->eq[row][col]);
if (!is_zero1 && !is_zero2) {
set_common_multiple(bset1, bset2, row, col);
++row;
} else if (!is_zero1 && is_zero2) {
construct_column(bset1, bset2, row, col);
} else if (is_zero1 && !is_zero2) {
construct_column(bset2, bset1, row, col);
} else {
if (transform_column(bset1, bset2, row, col))
--row;
}
}
isl_assert(bset1->ctx, row == bset1->n_eq, goto error);
isl_basic_set_free(bset2);
bset1 = isl_basic_set_normalize_constraints(bset1);
return bset1;
error:
isl_basic_set_free(bset1);
isl_basic_set_free(bset2);
return NULL;
}
/**
* Check whether there is any need for the constraint "upper" on
* "level" to get reduced.
* In case of the isl backend, there should be no need to do so
* if the level corresponds to an existentially quantified variable.
* Moreover, the way reduction is performed does not work for such
* variables since its position might chance during the construction
* of a set for reduction.
*/
int cloog_constraint_needs_reduction(CloogConstraint *upper, int level)
{
isl_basic_set *bset;
isl_constraint *c;
struct cloog_isl_dim dim;
c = cloog_constraint_to_isl(upper);
bset = isl_basic_set_from_constraint(isl_constraint_copy(c));
dim = basic_set_cloog_dim_to_isl_dim(bset, level - 1);
isl_basic_set_free(bset);
return dim.type == isl_dim_set;
}
int main(int argc, char **argv)
{
struct isl_ctx *ctx = isl_ctx_alloc();
struct isl_basic_set *bset;
bset = isl_basic_set_read_from_file(ctx, stdin);
bset = isl_basic_set_detect_equalities(bset);
isl_basic_set_print(bset, stdout, 0, "", "", ISL_FORMAT_POLYLIB);
isl_basic_set_free(bset);
isl_ctx_free(ctx);
return 0;
}
void isl_bset_list_free(isl_bset_list *list)
{
isl_bset_list *node = list;
isl_bset_list *next_node;
while (node != NULL)
{
isl_basic_set_free(node->bset);
next_node = node->next;
free(node);
node = next_node;
}
}
/* Extend an initial (under-)approximation of the affine hull of basic
* set represented by the tableau "tab"
* by looking for points that do not satisfy one of the equalities
* in the current approximation and adding them to that approximation
* until no such points can be found any more.
*
* The caller of this function ensures that "tab" is bounded or
* that tab->basis and tab->n_unbounded have been set appropriately.
*/
static struct isl_basic_set *extend_affine_hull(struct isl_tab *tab,
struct isl_basic_set *hull)
{
int i, j;
unsigned dim;
if (!tab || !hull)
goto error;
dim = tab->n_var;
if (isl_tab_extend_cons(tab, 2 * dim + 1) < 0)
goto error;
for (i = 0; i < dim; ++i) {
struct isl_vec *sample;
struct isl_basic_set *point;
for (j = 0; j < hull->n_eq; ++j) {
sample = outside_point(tab, hull->eq[j], 1);
if (!sample)
goto error;
if (sample->size > 0)
break;
isl_vec_free(sample);
sample = outside_point(tab, hull->eq[j], 0);
if (!sample)
goto error;
if (sample->size > 0)
break;
isl_vec_free(sample);
if (isl_tab_add_eq(tab, hull->eq[j]) < 0)
goto error;
}
if (j == hull->n_eq)
break;
if (tab->samples)
tab = isl_tab_add_sample(tab, isl_vec_copy(sample));
if (!tab)
goto error;
point = isl_basic_set_from_vec(sample);
hull = affine_hull(hull, point);
if (!hull)
return NULL;
}
return hull;
error:
isl_basic_set_free(hull);
return NULL;
}
/* Construct a zero sample of the same dimension as bset.
* As a special case, if bset is zero-dimensional, this
* function creates a zero-dimensional sample point.
*/
static struct isl_vec *zero_sample(struct isl_basic_set *bset)
{
unsigned dim;
struct isl_vec *sample;
dim = isl_basic_set_total_dim(bset);
sample = isl_vec_alloc(bset->ctx, 1 + dim);
if (sample) {
isl_int_set_si(sample->el[0], 1);
isl_seq_clr(sample->el + 1, dim);
}
isl_basic_set_free(bset);
return sample;
}
int main(int argc, char **argv)
{
struct isl_ctx *ctx = isl_ctx_alloc();
struct isl_basic_set *bset;
struct isl_vec *obj;
struct isl_vec *sol;
isl_int opt;
unsigned dim;
enum isl_lp_result res;
isl_printer *p;
isl_int_init(opt);
bset = isl_basic_set_read_from_file(ctx, stdin);
assert(bset);
obj = isl_vec_read_from_file(ctx, stdin);
assert(obj);
dim = isl_basic_set_total_dim(bset);
assert(obj->size >= dim && obj->size <= dim + 1);
if (obj->size != dim + 1)
obj = isl_vec_lin_to_aff(obj);
else
obj = vec_ror(obj);
res = isl_basic_set_solve_ilp(bset, 0, obj->el, &opt, &sol);
switch (res) {
case isl_lp_error:
fprintf(stderr, "error\n");
return -1;
case isl_lp_empty:
fprintf(stdout, "empty\n");
break;
case isl_lp_unbounded:
fprintf(stdout, "unbounded\n");
break;
case isl_lp_ok:
p = isl_printer_to_file(ctx, stdout);
p = isl_printer_print_vec(p, sol);
p = isl_printer_end_line(p);
p = isl_printer_print_isl_int(p, opt);
p = isl_printer_end_line(p);
isl_printer_free(p);
}
isl_basic_set_free(bset);
isl_vec_free(obj);
isl_vec_free(sol);
isl_ctx_free(ctx);
isl_int_clear(opt);
return 0;
}
static int scan_0D(struct isl_basic_set *bset,
struct isl_scan_callback *callback)
{
struct isl_vec *sample;
sample = isl_vec_alloc(bset->ctx, 1);
isl_basic_set_free(bset);
if (!sample)
return -1;
isl_int_set_si(sample->el[0], 1);
return callback->add(callback, sample);
}
struct isl_basic_set *isl_basic_set_remove_equalities(
struct isl_basic_set *bset, struct isl_mat **T, struct isl_mat **T2)
{
if (T)
*T = NULL;
if (T2)
*T2 = NULL;
if (!bset)
return NULL;
isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
bset = isl_basic_set_gauss(bset, NULL);
if (ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY))
return bset;
bset = compress_variables(bset, T, T2);
return bset;
error:
isl_basic_set_free(bset);
*T = NULL;
return NULL;
}
Param_Polyhedron *ISL_P2PP(Polyhedron *P, Polyhedron *C,
struct barvinok_options *options)
{
int i, j;
isl_ctx *ctx = isl_ctx_alloc();
isl_space *dim;
isl_basic_set *bset, *context;
isl_vertices *vertices;
unsigned nparam = C->Dimension;
unsigned nvar = P->Dimension - nparam;
Param_Polyhedron *PP = isl_calloc_type(ctx, Param_Polyhedron);
Param_Vertices **next_V;
struct bv_add_chamber_data data;
dim = isl_space_set_alloc(ctx, nparam, nvar);
bset = isl_basic_set_new_from_polylib(P, dim);
dim = isl_space_set_alloc(ctx, nparam, 0);
context = isl_basic_set_new_from_polylib(C, dim);
bset = isl_basic_set_intersect(bset, context);
vertices = isl_basic_set_compute_vertices(bset);
isl_basic_set_free(bset);
PP->Rays = NULL;
PP->nbV = isl_vertices_get_n_vertices(vertices);
PP->Constraints = Polyhedron2Constraints(P);
next_V = &PP->V;
isl_vertices_foreach_vertex(vertices, &add_vertex, &next_V);
data.next_D = &PP->D;
data.vertex_len = (PP->nbV + INT_BITS - 1)/INT_BITS;
isl_vertices_foreach_cell(vertices, &add_chamber, &data);
isl_vertices_free(vertices);
isl_ctx_free(ctx);
return PP;
}
struct isl_basic_set *isl_basic_set_recession_cone(struct isl_basic_set *bset)
{
int i;
bset = isl_basic_set_cow(bset);
if (!bset)
return NULL;
isl_assert(bset->ctx, bset->n_div == 0, goto error);
for (i = 0; i < bset->n_eq; ++i)
isl_int_set_si(bset->eq[i][0], 0);
for (i = 0; i < bset->n_ineq; ++i)
isl_int_set_si(bset->ineq[i][0], 0);
ISL_F_CLR(bset, ISL_BASIC_SET_NO_IMPLICIT);
return isl_basic_set_implicit_equalities(bset);
error:
isl_basic_set_free(bset);
return NULL;
}
