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);
}
/* Check if constraint "c" imposes any stride on dimension data->pos
* and, if so, update the stride information in "data".
*
* In order to impose a stride on the dimension, "c" needs to be an equality
* and it needs to involve the dimension. Note that "c" may also be
* a div constraint and thus an inequality that we cannot use.
*
* Let c be of the form
*
* h(p) + g * v * i + g * stride * f(alpha) = 0
*
* with h(p) an expression in terms of the parameters and other dimensions
* and f(alpha) an expression in terms of the existentially quantified
* variables.
*
* If "stride" is not zero and not one, then it represents a non-trivial stride
* on "i". We compute a and b such that
*
* a v + b stride = 1
*
* We have
*
* g v i = -h(p) + g stride f(alpha)
*
* a g v i = -a h(p) + g stride f(alpha)
*
* a g v i + b g stride i = -a h(p) + g stride * (...)
*
* g i = -a h(p) + g stride * (...)
*
* i = -a h(p)/g + stride * (...)
*
* The expression "-a h(p)/g" can therefore be used as offset.
*/
static isl_stat detect_stride(__isl_take isl_constraint *c, void *user)
{
struct isl_detect_stride_data *data = user;
int i, n_div;
isl_ctx *ctx;
isl_stat r = isl_stat_ok;
isl_val *v, *stride, *m;
isl_bool is_eq, relevant, has_stride;
is_eq = isl_constraint_is_equality(c);
relevant = isl_constraint_involves_dims(c, isl_dim_set, data->pos, 1);
if (is_eq < 0 || relevant < 0)
goto error;
if (!is_eq || !relevant) {
isl_constraint_free(c);
return isl_stat_ok;
}
ctx = isl_constraint_get_ctx(c);
stride = isl_val_zero(ctx);
n_div = isl_constraint_dim(c, isl_dim_div);
for (i = 0; i < n_div; ++i) {
v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);
stride = isl_val_gcd(stride, v);
}
v = isl_constraint_get_coefficient_val(c, isl_dim_set, data->pos);
m = isl_val_gcd(isl_val_copy(stride), isl_val_copy(v));
stride = isl_val_div(stride, isl_val_copy(m));
v = isl_val_div(v, isl_val_copy(m));
has_stride = isl_val_gt_si(stride, 1);
if (has_stride >= 0 && has_stride) {
isl_aff *aff;
isl_val *gcd, *a, *b;
gcd = isl_val_gcdext(v, isl_val_copy(stride), &a, &b);
isl_val_free(gcd);
isl_val_free(b);
aff = isl_constraint_get_aff(c);
for (i = 0; i < n_div; ++i)
aff = isl_aff_set_coefficient_si(aff,
isl_dim_div, i, 0);
aff = isl_aff_set_coefficient_si(aff, isl_dim_in, data->pos, 0);
aff = isl_aff_remove_unused_divs(aff);
a = isl_val_neg(a);
aff = isl_aff_scale_val(aff, a);
aff = isl_aff_scale_down_val(aff, m);
r = set_stride(data, stride, aff);
} else {
isl_val_free(stride);
isl_val_free(m);
isl_val_free(v);
}
isl_constraint_free(c);
if (has_stride < 0)
return isl_stat_error;
return r;
error:
isl_constraint_free(c);
return isl_stat_error;
}
enum order_sign isl_polyhedron_affine_sign(Polyhedron *D, Matrix *T,
struct barvinok_options *options)
{
int i;
isl_ctx *ctx = isl_ctx_alloc();
isl_space *dim;
isl_local_space *ls;
isl_aff *aff;
isl_basic_set *bset;
isl_val *min, *max = NULL;
isl_val *v;
enum order_sign sign = order_undefined;
assert(D->Dimension == T->NbColumns - 1);
dim = isl_space_set_alloc(ctx, 0, D->Dimension);
ls = isl_local_space_from_space(isl_space_copy(dim));
bset = isl_basic_set_new_from_polylib(D, dim);
aff = isl_aff_zero_on_domain(ls);
for (i = 0; i < D->Dimension; ++i) {
v = isl_val_int_from_gmp(ctx, T->p[0][i]);
aff = isl_aff_set_coefficient_val(aff, isl_dim_in, i, v);
}
v = isl_val_int_from_gmp(ctx, T->p[0][D->Dimension]);
aff = isl_aff_set_constant_val(aff, v);
v = isl_val_int_from_gmp(ctx, T->p[1][D->Dimension]);
aff = isl_aff_scale_down_val(aff, v);
min = isl_basic_set_min_lp_val(bset, aff);
min = isl_val_ceil(min);
assert(min);
if (isl_val_is_nan(min))
sign = order_undefined;
else if (isl_val_is_pos(min))
sign = order_gt;
else {
max = isl_basic_set_max_lp_val(bset, aff);
max = isl_val_floor(max);
assert(max);
if (isl_val_is_neg(max))
sign = order_lt;
else if (isl_val_is_zero(min) && isl_val_is_zero(max))
sign = order_eq;
else if (isl_val_is_zero(min))
sign = order_ge;
else if (isl_val_is_zero(max))
sign = order_le;
else
sign = order_unknown;
}
isl_basic_set_free(bset);
isl_aff_free(aff);
isl_val_free(min);
isl_val_free(max);
isl_ctx_free(ctx);
return sign;
}
