/* 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;
}
/* 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;
}
/* 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;
}
/* Create a(n identity) morphism between empty sets of the same dimension
* a "bset".
*/
__isl_give isl_morph *isl_morph_empty(__isl_keep isl_basic_set *bset)
{
isl_mat *id;
isl_basic_set *empty;
unsigned total;
if (!bset)
return NULL;
total = isl_basic_set_total_dim(bset);
id = isl_mat_identity(bset->ctx, 1 + total);
empty = isl_basic_set_empty(isl_space_copy(bset->dim));
return isl_morph_alloc(empty, isl_basic_set_copy(empty),
id, isl_mat_copy(id));
}
__isl_give isl_morph *isl_morph_identity(__isl_keep isl_basic_set *bset)
{
isl_mat *id;
isl_basic_set *universe;
unsigned total;
if (!bset)
return NULL;
total = isl_basic_set_total_dim(bset);
id = isl_mat_identity(bset->ctx, 1 + total);
universe = isl_basic_set_universe(isl_space_copy(bset->dim));
return isl_morph_alloc(universe, isl_basic_set_copy(universe),
id, isl_mat_copy(id));
}
/* 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;
}
static struct isl_mat *isl_basic_set_scan_samples(struct isl_basic_set *bset)
{
isl_ctx *ctx;
unsigned dim;
struct scan_samples ss;
ctx = isl_basic_set_get_ctx(bset);
dim = isl_basic_set_total_dim(bset);
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;
}
/* Given a basic set, exploit the equalties in the a basic set to construct
* a morphishm that maps the basic set to a lower-dimensional space.
* Specifically, the morphism reduces the number of dimensions of type "type".
*
* This function is a slight generalization of isl_mat_variable_compression
* in that it allows the input to be parametric and that it allows for the
* compression of either parameters or set variables.
*
* We first select the equalities of interest, that is those that involve
* variables of type "type" and no later variables.
* Denote those equalities as
*
* -C(p) + M x = 0
*
* where C(p) depends on the parameters if type == isl_dim_set and
* is a constant if type == isl_dim_param.
*
* First compute the (left) Hermite normal form of M,
*
* M [U1 U2] = M U = H = [H1 0]
* or
* M = H Q = [H1 0] [Q1]
* [Q2]
*
* with U, Q unimodular, Q = U^{-1} (and H lower triangular).
* Define the transformed variables as
*
* x = [U1 U2] [ x1' ] = [U1 U2] [Q1] x
* [ x2' ] [Q2]
*
* The equalities then become
*
* -C(p) + H1 x1' = 0 or x1' = H1^{-1} C(p) = C'(p)
*
* If the denominator of the constant term does not divide the
* the common denominator of the parametric terms, then every
* integer point is mapped to a non-integer point and then the original set has no
* integer solutions (since the x' are a unimodular transformation
* of the x). In this case, an empty morphism is returned.
* Otherwise, the transformation is given by
*
* x = U1 H1^{-1} C(p) + U2 x2'
*
* The inverse transformation is simply
*
* x2' = Q2 x
*
* Both matrices are extended to map the full original space to the full
* compressed space.
*/
__isl_give isl_morph *isl_basic_set_variable_compression(
__isl_keep isl_basic_set *bset, enum isl_dim_type type)
{
unsigned otype;
unsigned ntype;
unsigned orest;
unsigned nrest;
int f_eq, n_eq;
isl_space *dim;
isl_mat *H, *U, *Q, *C = NULL, *H1, *U1, *U2;
isl_basic_set *dom, *ran;
if (!bset)
return NULL;
if (isl_basic_set_plain_is_empty(bset))
return isl_morph_empty(bset);
isl_assert(bset->ctx, bset->n_div == 0, return NULL);
otype = 1 + isl_space_offset(bset->dim, type);
ntype = isl_basic_set_dim(bset, type);
orest = otype + ntype;
nrest = isl_basic_set_total_dim(bset) - (orest - 1);
for (f_eq = 0; f_eq < bset->n_eq; ++f_eq)
if (isl_seq_first_non_zero(bset->eq[f_eq] + orest, nrest) == -1)
break;
for (n_eq = 0; f_eq + n_eq < bset->n_eq; ++n_eq)
if (isl_seq_first_non_zero(bset->eq[f_eq + n_eq] + otype, ntype) == -1)
break;
if (n_eq == 0)
return isl_morph_identity(bset);
H = isl_mat_sub_alloc6(bset->ctx, bset->eq, f_eq, n_eq, otype, ntype);
H = isl_mat_left_hermite(H, 0, &U, &Q);
if (!H || !U || !Q)
goto error;
Q = isl_mat_drop_rows(Q, 0, n_eq);
Q = isl_mat_diagonal(isl_mat_identity(bset->ctx, otype), Q);
Q = isl_mat_diagonal(Q, isl_mat_identity(bset->ctx, nrest));
C = isl_mat_alloc(bset->ctx, 1 + n_eq, otype);
if (!C)
goto error;
isl_int_set_si(C->row[0][0], 1);
isl_seq_clr(C->row[0] + 1, otype - 1);
isl_mat_sub_neg(C->ctx, C->row + 1, bset->eq + f_eq, n_eq, 0, 0, otype);
H1 = isl_mat_sub_alloc(H, 0, H->n_row, 0, H->n_row);
H1 = isl_mat_lin_to_aff(H1);
C = isl_mat_inverse_product(H1, C);
if (!C)
goto error;
isl_mat_free(H);
if (!isl_int_is_one(C->row[0][0])) {
int i;
isl_int g;
isl_int_init(g);
for (i = 0; i < n_eq; ++i) {
isl_seq_gcd(C->row[1 + i] + 1, otype - 1, &g);
isl_int_gcd(g, g, C->row[0][0]);
if (!isl_int_is_divisible_by(C->row[1 + i][0], g))
break;
}
isl_int_clear(g);
if (i < n_eq) {
isl_mat_free(C);
isl_mat_free(U);
isl_mat_free(Q);
return isl_morph_empty(bset);
}
C = isl_mat_normalize(C);
}
U1 = isl_mat_sub_alloc(U, 0, U->n_row, 0, n_eq);
U1 = isl_mat_lin_to_aff(U1);
U2 = isl_mat_sub_alloc(U, 0, U->n_row, n_eq, U->n_row - n_eq);
U2 = isl_mat_lin_to_aff(U2);
isl_mat_free(U);
C = isl_mat_product(U1, C);
C = isl_mat_aff_direct_sum(C, U2);
C = insert_parameter_rows(C, otype - 1);
C = isl_mat_diagonal(C, isl_mat_identity(bset->ctx, nrest));
dim = isl_space_copy(bset->dim);
dim = isl_space_drop_dims(dim, type, 0, ntype);
dim = isl_space_add_dims(dim, type, ntype - n_eq);
ran = isl_basic_set_universe(dim);
dom = copy_equalities(bset, f_eq, n_eq);
return isl_morph_alloc(dom, ran, Q, C);
error:
isl_mat_free(C);
isl_mat_free(H);
isl_mat_free(U);
isl_mat_free(Q);
return NULL;
}
/* Check if dimension dim belongs to a residue class
* i_dim \equiv r mod m
* with m != 1 and if so return m in *modulo and r in *residue.
* As a special case, when i_dim has a fixed value v, then
* *modulo is set to 0 and *residue to v.
*
* If i_dim does not belong to such a residue class, then *modulo
* is set to 1 and *residue is set to 0.
*/
int isl_basic_set_dim_residue_class(struct isl_basic_set *bset,
int pos, isl_int *modulo, isl_int *residue)
{
struct isl_ctx *ctx;
struct isl_mat *H = NULL, *U = NULL, *C, *H1, *U1;
unsigned total;
unsigned nparam;
if (!bset || !modulo || !residue)
return -1;
if (isl_basic_set_plain_dim_is_fixed(bset, pos, residue)) {
isl_int_set_si(*modulo, 0);
return 0;
}
ctx = isl_basic_set_get_ctx(bset);
total = isl_basic_set_total_dim(bset);
nparam = isl_basic_set_n_param(bset);
H = isl_mat_sub_alloc6(ctx, bset->eq, 0, bset->n_eq, 1, total);
H = isl_mat_left_hermite(H, 0, &U, NULL);
if (!H)
return -1;
isl_seq_gcd(U->row[nparam + pos]+bset->n_eq,
total-bset->n_eq, modulo);
if (isl_int_is_zero(*modulo))
isl_int_set_si(*modulo, 1);
if (isl_int_is_one(*modulo)) {
isl_int_set_si(*residue, 0);
isl_mat_free(H);
isl_mat_free(U);
return 0;
}
C = isl_mat_alloc(ctx, 1 + bset->n_eq, 1);
if (!C)
goto error;
isl_int_set_si(C->row[0][0], 1);
isl_mat_sub_neg(ctx, C->row + 1, bset->eq, bset->n_eq, 0, 0, 1);
H1 = isl_mat_sub_alloc(H, 0, H->n_row, 0, H->n_row);
H1 = isl_mat_lin_to_aff(H1);
C = isl_mat_inverse_product(H1, C);
isl_mat_free(H);
U1 = isl_mat_sub_alloc(U, nparam+pos, 1, 0, bset->n_eq);
U1 = isl_mat_lin_to_aff(U1);
isl_mat_free(U);
C = isl_mat_product(U1, C);
if (!C)
return -1;
if (!isl_int_is_divisible_by(C->row[1][0], C->row[0][0])) {
bset = isl_basic_set_copy(bset);
bset = isl_basic_set_set_to_empty(bset);
isl_basic_set_free(bset);
isl_int_set_si(*modulo, 1);
isl_int_set_si(*residue, 0);
return 0;
}
isl_int_divexact(*residue, C->row[1][0], C->row[0][0]);
isl_int_fdiv_r(*residue, *residue, *modulo);
isl_mat_free(C);
return 0;
error:
isl_mat_free(H);
isl_mat_free(U);
return -1;
}
int cloog_constraint_set_total_dimension(CloogConstraintSet *constraints)
{
isl_basic_set *bset;
bset = cloog_constraints_set_to_isl(constraints);
return isl_basic_set_total_dim(bset);
}
/* Look for all integer points in "bset", which is assumed to be bounded,
* and call callback->add on each of them.
*
* We first compute a reduced basis for the set and then scan
* the set in the directions of this basis.
* We basically perform a depth first search, where in each level i
* we compute the range in the i-th basis vector direction, given
* fixed values in the directions of the previous basis vector.
* We then add an equality to the tableau fixing the value in the
* direction of the current basis vector to each value in the range
* in turn and then continue to the next level.
*
* The search is implemented iteratively. "level" identifies the current
* basis vector. "init" is true if we want the first value at the current
* level and false if we want the next value.
* Solutions are added in the leaves of the search tree, i.e., after
* we have fixed a value in each direction of the basis.
*/
int isl_basic_set_scan(struct isl_basic_set *bset,
struct isl_scan_callback *callback)
{
unsigned dim;
struct isl_mat *B = NULL;
struct isl_tab *tab = NULL;
struct isl_vec *min;
struct isl_vec *max;
struct isl_tab_undo **snap;
int level;
int init;
enum isl_lp_result res;
if (!bset)
return -1;
dim = isl_basic_set_total_dim(bset);
if (dim == 0)
return scan_0D(bset, callback);
min = isl_vec_alloc(bset->ctx, dim);
max = isl_vec_alloc(bset->ctx, dim);
snap = isl_alloc_array(bset->ctx, struct isl_tab_undo *, dim);
if (!min || !max || !snap)
goto error;
tab = isl_tab_from_basic_set(bset, 0);
if (!tab)
goto error;
if (isl_tab_extend_cons(tab, dim + 1) < 0)
goto error;
tab->basis = isl_mat_identity(bset->ctx, 1 + dim);
if (1)
tab = isl_tab_compute_reduced_basis(tab);
if (!tab)
goto error;
B = isl_mat_copy(tab->basis);
if (!B)
goto error;
level = 0;
init = 1;
while (level >= 0) {
int empty = 0;
if (init) {
res = isl_tab_min(tab, B->row[1 + level],
bset->ctx->one, &min->el[level], NULL, 0);
if (res == isl_lp_empty)
empty = 1;
if (res == isl_lp_error || res == isl_lp_unbounded)
goto error;
isl_seq_neg(B->row[1 + level] + 1,
B->row[1 + level] + 1, dim);
res = isl_tab_min(tab, B->row[1 + level],
bset->ctx->one, &max->el[level], NULL, 0);
isl_seq_neg(B->row[1 + level] + 1,
B->row[1 + level] + 1, dim);
isl_int_neg(max->el[level], max->el[level]);
if (res == isl_lp_empty)
empty = 1;
if (res == isl_lp_error || res == isl_lp_unbounded)
goto error;
snap[level] = isl_tab_snap(tab);
} else
isl_int_add_ui(min->el[level], min->el[level], 1);
if (empty || isl_int_gt(min->el[level], max->el[level])) {
level--;
init = 0;
if (level >= 0)
if (isl_tab_rollback(tab, snap[level]) < 0)
goto error;
continue;
}
if (level == dim - 1 && callback->add == increment_counter) {
if (increment_range(callback,
min->el[level], max->el[level]))
goto error;
level--;
init = 0;
if (level >= 0)
if (isl_tab_rollback(tab, snap[level]) < 0)
goto error;
continue;
}
isl_int_neg(B->row[1 + level][0], min->el[level]);
if (isl_tab_add_valid_eq(tab, B->row[1 + level]) < 0)
goto error;
isl_int_set_si(B->row[1 + level][0], 0);
if (level < dim - 1) {
++level;
init = 1;
continue;
}
if (add_solution(tab, callback) < 0)
goto error;
init = 0;
if (isl_tab_rollback(tab, snap[level]) < 0)
goto error;
}
isl_tab_free(tab);
free(snap);
isl_vec_free(min);
isl_vec_free(max);
isl_basic_set_free(bset);
isl_mat_free(B);
return 0;
error:
isl_tab_free(tab);
free(snap);
isl_vec_free(min);
isl_vec_free(max);
isl_basic_set_free(bset);
isl_mat_free(B);
return -1;
}
