struct isl_basic_map *isl_map_affine_hull(struct isl_map *map)
{
int i;
struct isl_basic_map *model = NULL;
struct isl_basic_map *hull = NULL;
struct isl_set *set;
map = isl_map_detect_equalities(map);
map = isl_map_align_divs(map);
if (!map)
return NULL;
if (map->n == 0) {
hull = isl_basic_map_empty_like_map(map);
isl_map_free(map);
return hull;
}
model = isl_basic_map_copy(map->p[0]);
set = isl_map_underlying_set(map);
set = isl_set_cow(set);
if (!set)
goto error;
for (i = 0; i < set->n; ++i) {
set->p[i] = isl_basic_set_cow(set->p[i]);
set->p[i] = isl_basic_set_affine_hull(set->p[i]);
set->p[i] = isl_basic_set_gauss(set->p[i], NULL);
if (!set->p[i])
goto error;
}
set = isl_set_remove_empty_parts(set);
if (set->n == 0) {
hull = isl_basic_map_empty_like(model);
isl_basic_map_free(model);
} else {
struct isl_basic_set *bset;
while (set->n > 1) {
set->p[0] = affine_hull(set->p[0], set->p[--set->n]);
if (!set->p[0])
goto error;
}
bset = isl_basic_set_copy(set->p[0]);
hull = isl_basic_map_overlying_set(bset, model);
}
isl_set_free(set);
hull = isl_basic_map_simplify(hull);
return isl_basic_map_finalize(hull);
error:
isl_basic_map_free(model);
isl_set_free(set);
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;
}
__isl_give isl_map *isl_map_inline_foreach_basic_map(__isl_take isl_map *map,
__isl_give isl_basic_map *(*fn)(__isl_take isl_basic_map *bmap))
{
struct isl_basic_map *bmap;
int i;
if (!map)
return NULL;
for (i = 0; i < map->n; ++i) {
bmap = isl_basic_map_copy(map->p[i]);
bmap = fn(bmap);
if (!bmap)
goto error;
isl_basic_map_free(map->p[i]);
map->p[i] = bmap;
}
return map;
error:
isl_map_free(map);
return NULL;
}
/**
* Reduce the modulo guard expressed by "constraints" using equalities
* found in outer nesting levels (stored in "equal").
* The modulo guard may be an equality or a pair of inequalities.
* In case of a pair of inequalities, *bound contains the bound on the
* corresponding modulo expression. If any reduction is performed
* then this bound is recomputed.
*
* "level" may not correspond to an existentially quantified variable.
*
* We first check if there are any equalities we can use. If not,
* there is again nothing to reduce.
* For the actual reduction, we use isl_basic_set_gist, but this
* function will only perform the reduction we want here if the
* the variable that imposes the modulo constraint has been projected
* out (i.e., turned into an existentially quantified variable).
* After the call to isl_basic_set_gist, we need to move the
* existential variable back into the position where the calling
* function expects it (assuming there are any constraints left).
* We do this by adding an equality between the given dimension and
* the existentially quantified variable.
*
* If there are no existentially quantified variables left, then
* we don't need to add this equality.
* If, on the other hand, the resulting basic set involves more
* than one existentially quantified variable, then the caller
* will not be able to handle the result, so we just return the
* original input instead.
*/
CloogConstraintSet *cloog_constraint_set_reduce(CloogConstraintSet *constraints,
int level, CloogEqualities *equal, int nb_par, cloog_int_t *bound)
{
int j;
isl_space *idim;
struct isl_basic_set *eq;
struct isl_basic_map *id;
struct cloog_isl_dim dim;
struct isl_constraint *c;
unsigned constraints_dim;
unsigned n_div;
isl_basic_set *bset, *orig;
bset = cloog_constraints_set_to_isl(constraints);
orig = isl_basic_set_copy(bset);
dim = set_cloog_dim_to_isl_dim(constraints, level - 1);
assert(dim.type == isl_dim_set);
eq = NULL;
for (j = 0; j < level - 1; ++j) {
isl_basic_set *bset_j;
if (equal->types[j] != EQTYPE_EXAFFINE)
continue;
bset_j = equality_to_basic_set(equal, j);
if (!eq)
eq = bset_j;
else
eq = isl_basic_set_intersect(eq, bset_j);
}
if (!eq) {
isl_basic_set_free(orig);
return cloog_constraint_set_from_isl_basic_set(bset);
}
idim = isl_space_map_from_set(isl_basic_set_get_space(bset));
id = isl_basic_map_identity(idim);
id = isl_basic_map_remove_dims(id, isl_dim_out, dim.pos, 1);
bset = isl_basic_set_apply(bset, isl_basic_map_copy(id));
bset = isl_basic_set_apply(bset, isl_basic_map_reverse(id));
constraints_dim = isl_basic_set_dim(bset, isl_dim_set);
eq = isl_basic_set_remove_dims(eq, isl_dim_set, constraints_dim,
isl_basic_set_dim(eq, isl_dim_set) - constraints_dim);
bset = isl_basic_set_gist(bset, eq);
n_div = isl_basic_set_dim(bset, isl_dim_div);
if (n_div > 1) {
isl_basic_set_free(bset);
return cloog_constraint_set_from_isl_basic_set(orig);
}
if (n_div < 1) {
isl_basic_set_free(orig);
return cloog_constraint_set_from_isl_basic_set(bset);
}
c = isl_equality_alloc(isl_basic_set_get_local_space(bset));
c = isl_constraint_set_coefficient_si(c, isl_dim_div, 0, 1);
c = isl_constraint_set_coefficient_si(c, isl_dim_set, dim.pos, -1);
bset = isl_basic_set_add_constraint(bset, c);
isl_int_set_si(*bound, 0);
constraints = cloog_constraint_set_from_isl_basic_set(bset);
cloog_constraint_set_foreach_constraint(constraints,
add_constant_term, bound);
isl_basic_set_free(orig);
return cloog_constraint_set_from_isl_basic_set(bset);
}
