/*
* Copyright 2008-2009 Katholieke Universiteit Leuven
*
- * Use of this software is governed by the GNU LGPLv2.1 license
+ * Use of this software is governed by the MIT license
*
* Written by Sven Verdoolaege, K.U.Leuven, Departement
* Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
*/
-#include "isl_ctx.h"
-#include "isl_seq.h"
-#include "isl_set.h"
-#include "isl_lp.h"
-#include "isl_map.h"
-#include "isl_map_private.h"
+#include <isl_ctx_private.h>
+#include <isl_map_private.h>
+#include <isl/seq.h>
+#include <isl/set.h>
+#include <isl/lp.h>
+#include <isl/map.h>
#include "isl_equalities.h"
#include "isl_sample.h"
#include "isl_tab.h"
+#include <isl_mat_private.h>
struct isl_basic_map *isl_basic_map_implicit_equalities(
struct isl_basic_map *bmap)
if (bmap->n_ineq <= 1)
return bmap;
- tab = isl_tab_from_basic_map(bmap);
+ tab = isl_tab_from_basic_map(bmap, 0);
if (isl_tab_detect_implicit_equalities(tab) < 0)
goto error;
bmap = isl_basic_map_update_from_tab(bmap, tab);
int col;
int row;
+ if (!bset1 || !bset2)
+ goto error;
+
total = 1 + isl_basic_set_n_dim(bset1);
row = 0;
--row;
}
}
- isl_basic_set_free(bset2);
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;
}
if (!up)
isl_seq_neg(eq, eq, 1 + dim);
- if (isl_tab_rollback(tab, snap) < 0)
+ if (sample && isl_tab_rollback(tab, snap) < 0)
goto error;
return sample;
return NULL;
}
+/* Move "sample" to a point that is one up (or down) from the original
+ * point in dimension "pos".
+ */
+static void adjacent_point(__isl_keep isl_vec *sample, int pos, int up)
+{
+ if (up)
+ isl_int_add_ui(sample->el[1 + pos], sample->el[1 + pos], 1);
+ else
+ isl_int_sub_ui(sample->el[1 + pos], sample->el[1 + pos], 1);
+}
+
+/* Check if any points that are adjacent to "sample" also belong to "bset".
+ * If so, add them to "hull" and return the updated hull.
+ *
+ * Before checking whether and adjacent point belongs to "bset", we first
+ * check whether it already belongs to "hull" as this test is typically
+ * much cheaper.
+ */
+static __isl_give isl_basic_set *add_adjacent_points(
+ __isl_take isl_basic_set *hull, __isl_take isl_vec *sample,
+ __isl_keep isl_basic_set *bset)
+{
+ int i, up;
+ int dim;
+
+ if (!sample)
+ goto error;
+
+ dim = isl_basic_set_dim(hull, isl_dim_set);
+
+ for (i = 0; i < dim; ++i) {
+ for (up = 0; up <= 1; ++up) {
+ int contains;
+ isl_basic_set *point;
+
+ adjacent_point(sample, i, up);
+ contains = isl_basic_set_contains(hull, sample);
+ if (contains < 0)
+ goto error;
+ if (contains) {
+ adjacent_point(sample, i, !up);
+ continue;
+ }
+ contains = isl_basic_set_contains(bset, sample);
+ if (contains < 0)
+ goto error;
+ if (contains) {
+ point = isl_basic_set_from_vec(
+ isl_vec_copy(sample));
+ hull = affine_hull(hull, point);
+ }
+ adjacent_point(sample, i, !up);
+ if (contains)
+ break;
+ }
+ }
+
+ isl_vec_free(sample);
+
+ return hull;
+error:
+ isl_vec_free(sample);
+ isl_basic_set_free(hull);
+ return NULL;
+}
+
/* 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
*
* The caller of this function ensures that "tab" is bounded or
* that tab->basis and tab->n_unbounded have been set appropriately.
+ *
+ * "bset" may be either NULL or the basic set represented by "tab".
+ * If "bset" is not NULL, we check for any point we find if any
+ * of its adjacent points also belong to "bset".
*/
-static struct isl_basic_set *extend_affine_hull(struct isl_tab *tab,
- struct isl_basic_set *hull)
+static __isl_give isl_basic_set *extend_affine_hull(struct isl_tab *tab,
+ __isl_take isl_basic_set *hull, __isl_keep isl_basic_set *bset)
{
int i, j;
unsigned dim;
break;
isl_vec_free(sample);
- tab = isl_tab_add_eq(tab, hull->eq[j]);
- if (!tab)
+ if (isl_tab_add_eq(tab, hull->eq[j]) < 0)
goto error;
}
if (j == hull->n_eq)
tab = isl_tab_add_sample(tab, isl_vec_copy(sample));
if (!tab)
goto error;
+ if (bset)
+ hull = add_adjacent_points(hull, isl_vec_copy(sample),
+ bset);
point = isl_basic_set_from_vec(sample);
hull = affine_hull(hull, point);
+ if (!hull)
+ return NULL;
}
return hull;
return NULL;
}
+/* Drop all constraints in bmap that involve any of the dimensions
+ * first to first+n-1.
+ */
+static __isl_give isl_basic_map *isl_basic_map_drop_constraints_involving(
+ __isl_take isl_basic_map *bmap, unsigned first, unsigned n)
+{
+ int i;
+
+ if (n == 0)
+ return bmap;
+
+ bmap = isl_basic_map_cow(bmap);
+
+ if (!bmap)
+ return NULL;
+
+ for (i = bmap->n_eq - 1; i >= 0; --i) {
+ if (isl_seq_first_non_zero(bmap->eq[i] + 1 + first, n) == -1)
+ continue;
+ isl_basic_map_drop_equality(bmap, i);
+ }
+
+ for (i = bmap->n_ineq - 1; i >= 0; --i) {
+ if (isl_seq_first_non_zero(bmap->ineq[i] + 1 + first, n) == -1)
+ continue;
+ isl_basic_map_drop_inequality(bmap, i);
+ }
+
+ return bmap;
+}
+
/* Drop all constraints in bset that involve any of the dimensions
* first to first+n-1.
*/
-static struct isl_basic_set *drop_constraints_involving
- (struct isl_basic_set *bset, unsigned first, unsigned n)
+__isl_give isl_basic_set *isl_basic_set_drop_constraints_involving(
+ __isl_take isl_basic_set *bset, unsigned first, unsigned n)
+{
+ return isl_basic_map_drop_constraints_involving(bset, first, n);
+}
+
+/* Drop all constraints in bmap that do not involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_constraints_not_involving_dims(
+ __isl_take isl_basic_map *bmap,
+ enum isl_dim_type type, unsigned first, unsigned n)
{
int i;
+ unsigned dim;
- if (!bset)
+ if (n == 0)
+ return isl_basic_map_set_to_empty(bmap);
+ bmap = isl_basic_map_cow(bmap);
+ if (!bmap)
return NULL;
- bset = isl_basic_set_cow(bset);
+ dim = isl_basic_map_dim(bmap, type);
+ if (first + n > dim || first + n < first)
+ isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+ "index out of bounds", return isl_basic_map_free(bmap));
+
+ first += isl_basic_map_offset(bmap, type) - 1;
- for (i = bset->n_eq - 1; i >= 0; --i) {
- if (isl_seq_first_non_zero(bset->eq[i] + 1 + first, n) == -1)
+ for (i = bmap->n_eq - 1; i >= 0; --i) {
+ if (isl_seq_first_non_zero(bmap->eq[i] + 1 + first, n) != -1)
continue;
- isl_basic_set_drop_equality(bset, i);
+ isl_basic_map_drop_equality(bmap, i);
}
- for (i = bset->n_ineq - 1; i >= 0; --i) {
- if (isl_seq_first_non_zero(bset->ineq[i] + 1 + first, n) == -1)
+ for (i = bmap->n_ineq - 1; i >= 0; --i) {
+ if (isl_seq_first_non_zero(bmap->ineq[i] + 1 + first, n) != -1)
continue;
- isl_basic_set_drop_inequality(bset, i);
+ isl_basic_map_drop_inequality(bmap, i);
}
- return bset;
+ return bmap;
+}
+
+/* Drop all constraints in bset that do not involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_basic_set *isl_basic_set_drop_constraints_not_involving_dims(
+ __isl_take isl_basic_set *bset,
+ enum isl_dim_type type, unsigned first, unsigned n)
+{
+ return isl_basic_map_drop_constraints_not_involving_dims(bset,
+ type, first, n);
+}
+
+/* Drop all constraints in bmap that involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_constraints_involving_dims(
+ __isl_take isl_basic_map *bmap,
+ enum isl_dim_type type, unsigned first, unsigned n)
+{
+ unsigned dim;
+
+ if (!bmap)
+ return NULL;
+ if (n == 0)
+ return bmap;
+
+ dim = isl_basic_map_dim(bmap, type);
+ if (first + n > dim || first + n < first)
+ isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+ "index out of bounds", return isl_basic_map_free(bmap));
+
+ bmap = isl_basic_map_remove_divs_involving_dims(bmap, type, first, n);
+ first += isl_basic_map_offset(bmap, type) - 1;
+ return isl_basic_map_drop_constraints_involving(bmap, first, n);
+}
+
+/* Drop all constraints in bset that involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_basic_set *isl_basic_set_drop_constraints_involving_dims(
+ __isl_take isl_basic_set *bset,
+ enum isl_dim_type type, unsigned first, unsigned n)
+{
+ return isl_basic_map_drop_constraints_involving_dims(bset,
+ type, first, n);
+}
+
+/* Drop all constraints in map that involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_map *isl_map_drop_constraints_involving_dims(
+ __isl_take isl_map *map,
+ enum isl_dim_type type, unsigned first, unsigned n)
+{
+ int i;
+ unsigned dim;
+
+ if (!map)
+ return NULL;
+ if (n == 0)
+ return map;
+
+ dim = isl_map_dim(map, type);
+ if (first + n > dim || first + n < first)
+ isl_die(isl_map_get_ctx(map), isl_error_invalid,
+ "index out of bounds", return isl_map_free(map));
+
+ map = isl_map_cow(map);
+ if (!map)
+ return NULL;
+
+ for (i = 0; i < map->n; ++i) {
+ map->p[i] = isl_basic_map_drop_constraints_involving_dims(
+ map->p[i], type, first, n);
+ if (!map->p[i])
+ return isl_map_free(map);
+ }
+
+ return map;
+}
+
+/* Drop all constraints in set that involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_set *isl_set_drop_constraints_involving_dims(
+ __isl_take isl_set *set,
+ enum isl_dim_type type, unsigned first, unsigned n)
+{
+ return isl_map_drop_constraints_involving_dims(set, type, first, n);
+}
+
+/* Construct an initial underapproximatino of the hull of "bset"
+ * from "sample" and any of its adjacent points that also belong to "bset".
+ */
+static __isl_give isl_basic_set *initialize_hull(__isl_keep isl_basic_set *bset,
+ __isl_take isl_vec *sample)
+{
+ isl_basic_set *hull;
+
+ hull = isl_basic_set_from_vec(isl_vec_copy(sample));
+ hull = add_adjacent_points(hull, sample, bset);
+
+ return hull;
}
/* Look for all equalities satisfied by the integer points in bset,
struct isl_tab *tab = NULL;
unsigned dim;
- if (isl_basic_set_fast_is_empty(bset))
+ if (isl_basic_set_plain_is_empty(bset))
return bset;
dim = isl_basic_set_n_dim(bset);
}
}
- tab = isl_tab_from_basic_set(bset);
+ tab = isl_tab_from_basic_set(bset, 1);
if (!tab)
goto error;
if (tab->empty) {
isl_vec_free(sample);
return isl_basic_set_set_to_empty(bset);
}
- if (isl_tab_track_bset(tab, isl_basic_set_copy(bset)) < 0)
- goto error;
if (!sample) {
struct isl_tab_undo *snap;
return isl_basic_set_set_to_empty(bset);
}
- hull = isl_basic_set_from_vec(sample);
+ hull = initialize_hull(bset, sample);
+ hull = extend_affine_hull(tab, hull, bset);
isl_basic_set_free(bset);
- hull = extend_affine_hull(tab, hull);
isl_tab_free(tab);
return hull;
}
/* Given an unbounded tableau and an integer point satisfying the tableau,
- * construct an intial affine hull containing the recession cone
+ * construct an initial affine hull containing the recession cone
* shifted to the given point.
*
* The unbounded directions are taken from the last rows of the basis,
* isl_tab_set_initial_basis_with_cone will add some additional
* constraints to the tableau that have to be removed again.
* In this case, we therefore rollback to the state before
- * any constraints were added and then add the eqaulities back in.
+ * any constraints were added and then add the equalities back in.
*/
struct isl_tab *isl_tab_detect_equalities(struct isl_tab *tab,
struct isl_tab *tab_cone)
{
int j;
struct isl_vec *sample;
- struct isl_basic_set *hull;
+ struct isl_basic_set *hull = NULL;
struct isl_tab_undo *snap;
if (!tab || !tab_cone)
isl_vec_free(sample);
- hull = extend_affine_hull(tab, hull);
+ hull = extend_affine_hull(tab, hull, NULL);
if (!hull)
goto error;
if (hull->n_eq > tab->n_zero) {
for (j = 0; j < hull->n_eq; ++j) {
isl_seq_normalize(tab->mat->ctx, hull->eq[j], 1 + tab->n_var);
- tab = isl_tab_add_eq(tab, hull->eq[j]);
+ if (isl_tab_add_eq(tab, hull->eq[j]) < 0)
+ goto error;
}
}
return tab;
error:
+ isl_basic_set_free(hull);
isl_tab_free(tab);
return NULL;
}
total = isl_basic_set_total_dim(cone);
cone_dim = total - cone->n_eq;
- M = isl_mat_sub_alloc(bset->ctx, cone->eq, 0, cone->n_eq, 1, total);
+ 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;
U = isl_mat_lin_to_aff(U);
bset = isl_basic_set_preimage(bset, isl_mat_copy(U));
- bset = drop_constraints_involving(bset, total - cone_dim, cone_dim);
+ 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);
hull = uset_affine_hull_bounded(bset);
- if (!hull)
+ if (!hull) {
+ isl_mat_free(Q);
isl_mat_free(U);
- else {
+ } 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)
else
isl_mat_free(U);
hull = isl_basic_set_preimage(hull, Q);
- isl_vec_free(hull->sample);
- hull->sample = sample;
+ if (hull) {
+ isl_vec_free(hull->sample);
+ hull->sample = sample;
+ } else
+ isl_vec_free(sample);
}
isl_basic_set_free(cone);
{
struct isl_basic_set *cone;
- if (isl_basic_set_fast_is_empty(bset))
+ if (isl_basic_set_plain_is_empty(bset))
return bset;
cone = isl_basic_set_recession_cone(isl_basic_set_copy(bset));
if (!T2)
return hull;
- if (!hull)
+ if (!hull) {
isl_mat_free(T1);
- else {
+ 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);
- isl_vec_free(hull->sample);
- hull->sample = sample;
+ if (hull) {
+ isl_vec_free(hull->sample);
+ hull->sample = sample;
+ } else
+ isl_vec_free(sample);
}
return hull;
error:
+ isl_mat_free(T1);
isl_mat_free(T2);
isl_basic_set_free(bset);
isl_basic_set_free(hull);
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,
+ bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim), 0,
hull->n_eq, 0);
for (i = 0; i < hull->n_eq; ++i) {
j = isl_basic_map_alloc_equality(bmap);
isl_basic_map_detect_equalities((isl_basic_map *)bset);
}
-struct isl_map *isl_map_detect_equalities(struct isl_map *map)
+__isl_give isl_map *isl_map_detect_equalities(__isl_take isl_map *map)
{
- 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 = isl_basic_map_detect_equalities(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;
+ return isl_map_inline_foreach_basic_map(map,
+ &isl_basic_map_detect_equalities);
}
__isl_give isl_set *isl_set_detect_equalities(__isl_take isl_set *set)
{
bmap = isl_basic_map_detect_equalities(bmap);
bmap = isl_basic_map_cow(bmap);
- isl_basic_map_free_inequality(bmap, bmap->n_ineq);
+ if (bmap)
+ isl_basic_map_free_inequality(bmap, bmap->n_ineq);
+ bmap = isl_basic_map_finalize(bmap);
return bmap;
}
isl_basic_map_affine_hull((struct isl_basic_map *)bset);
}
-struct isl_basic_map *isl_map_affine_hull(struct isl_map *map)
+/* Compute the affine hull of each basic map in "map" separately
+ * and call isl_basic_map_gauss on the result.
+ */
+static __isl_give isl_map *isl_map_local_affine_hull(__isl_take isl_map *map)
{
int i;
+
+ map = isl_map_cow(map);
+ if (!map)
+ return NULL;
+
+ for (i = 0; i < map->n; ++i) {
+ map->p[i] = isl_basic_map_affine_hull(map->p[i]);
+ map->p[i] = isl_basic_map_gauss(map->p[i], NULL);
+ if (!map->p[i])
+ return isl_map_free(map);
+ }
+
+ return map;
+}
+
+static __isl_give isl_set *isl_set_local_affine_hull(__isl_take isl_set *set)
+{
+ return isl_map_local_affine_hull(set);
+}
+
+/* Compute the affine hull of "map".
+ *
+ * We first compute the affine hull of each basic map separately.
+ * Then we align the divs and recompute the affine hulls of the basic
+ * maps since some of them may now have extra divs.
+ * In order to avoid performing parametric integer programming to
+ * compute explicit expressions for the divs, possible leading to
+ * an explosion in the number of basic maps, we first drop all unknown
+ * divs before aligning the divs. Note that the divs determined
+ * by an equality will be known since we call isl_basic_set_gauss
+ * from isl_map_local_affine_hull. Calling gauss is also needed
+ * because affine_hull assumes its input has been gaussed, while
+ * isl_map_affine_hull may be called on input that has not been gaussed,
+ * in particular from initial_facet_constraint.
+ * Similarly, align_divs may reorder some divs so that we need to
+ * gauss the result again.
+ * Finally, we combine the individual affine hulls into a single
+ * affine hull.
+ */
+__isl_give isl_basic_map *isl_map_affine_hull(__isl_take isl_map *map)
+{
struct isl_basic_map *model = NULL;
struct isl_basic_map *hull = NULL;
struct isl_set *set;
+ isl_basic_set *bset;
map = isl_map_detect_equalities(map);
+ map = isl_map_local_affine_hull(map);
+ map = isl_map_remove_empty_parts(map);
+ map = isl_map_remove_unknown_divs(map);
map = isl_map_align_divs(map);
if (!map)
model = isl_basic_map_copy(map->p[0]);
set = isl_map_underlying_set(map);
set = isl_set_cow(set);
+ set = isl_set_local_affine_hull(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);
- }
+ while (set->n > 1)
+ set->p[0] = affine_hull(set->p[0], set->p[--set->n]);
+
+ 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);
projects / platform / upstream / isl.git / blobdiff