/**
* cloog_constraint_equal_type function :
* This function returns the type of the equality in the constraint (line) of
* (constraints) for the element (level). An equality is 'constant' iff all
* other factors are null except the constant one. It is a 'pure item' iff
* it is equal or opposite to a single variable or parameter.
* Otherwise it is an 'affine expression'.
* For instance:
* i = -13 is constant, i = j, j = -M are pure items,
* j = 2*M, i = j+1, 2*j = M are affine expressions.
*
* - constraints is the matrix of constraints,
* - level is the column number in equal of the element which is 'equal to',
*/
static int cloog_constraint_equal_type(CloogConstraint *cc, int level)
{
int i;
isl_int c;
int type = EQTYPE_NONE;
struct isl_constraint *constraint = cloog_constraint_to_isl(cc);
isl_int_init(c);
isl_constraint_get_constant(constraint, &c);
if (!isl_int_is_zero(c))
type = EQTYPE_CONSTANT;
isl_constraint_get_coefficient(constraint, isl_dim_set, level - 1, &c);
if (!isl_int_is_one(c) && !isl_int_is_negone(c))
type = EQTYPE_EXAFFINE;
for (i = 0; i < isl_constraint_dim(constraint, isl_dim_param); ++i) {
isl_constraint_get_coefficient(constraint, isl_dim_param, i, &c);
if (isl_int_is_zero(c))
continue;
if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
type != EQTYPE_NONE) {
type = EQTYPE_EXAFFINE;
break;
}
type = EQTYPE_PUREITEM;
}
for (i = 0; i < isl_constraint_dim(constraint, isl_dim_set); ++i) {
if (i == level - 1)
continue;
isl_constraint_get_coefficient(constraint, isl_dim_set, i, &c);
if (isl_int_is_zero(c))
continue;
if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
type != EQTYPE_NONE) {
type = EQTYPE_EXAFFINE;
break;
}
type = EQTYPE_PUREITEM;
}
for (i = 0; i < isl_constraint_dim(constraint, isl_dim_div); ++i) {
isl_constraint_get_coefficient(constraint, isl_dim_div, i, &c);
if (isl_int_is_zero(c))
continue;
if ((!isl_int_is_one(c) && !isl_int_is_negone(c)) ||
type != EQTYPE_NONE) {
type = EQTYPE_EXAFFINE;
break;
}
type = EQTYPE_PUREITEM;
}
isl_int_clear(c);
if (type == EQTYPE_NONE)
type = EQTYPE_CONSTANT;
return type;
}
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;
}
/// Add an isl constraint to an ScopLib matrix.
///
/// @param user The matrix
/// @param c The constraint
int ScopLib::accessToMatrix_constraint(isl_constraint *c, void *user) {
scoplib_matrix_p m = (scoplib_matrix_p) user;
int nb_params = isl_constraint_dim(c, isl_dim_param);
int nb_in = isl_constraint_dim(c, isl_dim_in);
int nb_div = isl_constraint_dim(c, isl_dim_div);
assert(!nb_div && "Existentially quantified variables not yet supported");
scoplib_vector_p vec =
scoplib_vector_malloc(nb_params + nb_in + 2);
isl_int v;
isl_int_init(v);
// The access dimension has to be one.
isl_constraint_get_coefficient(c, isl_dim_out, 0, &v);
assert((isl_int_is_one(v) || isl_int_is_negone(v))
&& "Access relations not supported in scoplib");
bool inverse = isl_int_is_one(v);
// Assign variables
for (int i = 0; i < nb_in; ++i) {
isl_constraint_get_coefficient(c, isl_dim_in, i, &v);
if (inverse) isl_int_neg(v,v);
isl_int_set(vec->p[i + 1], v);
}
// Assign parameters
for (int i = 0; i < nb_params; ++i) {
isl_constraint_get_coefficient(c, isl_dim_param, i, &v);
if (inverse) isl_int_neg(v,v);
isl_int_set(vec->p[nb_in + i + 1], v);
}
// Assign constant
isl_constraint_get_constant(c, &v);
if (inverse) isl_int_neg(v,v);
isl_int_set(vec->p[nb_in + nb_params + 1], v);
scoplib_matrix_insert_vector(m, vec, m->NbRows);
isl_constraint_free(c);
isl_int_clear(v);
return 0;
}
static int bound_is_integer(__isl_take isl_constraint *bound, unsigned pos)
{
isl_int c;
int is_int;
if (!bound)
return 1;
isl_int_init(c);
isl_constraint_get_coefficient(bound, isl_dim_set, pos, &c);
is_int = isl_int_is_one(c) || isl_int_is_negone(c);
isl_int_clear(c);
return is_int;
}
