X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=isl_map.c;h=815437189cba44243b2df003b2ab1053fe37df08;hb=225c7e232df74cf93c7b0c1f945bbdf7581cc455;hp=4446106a7e1709de47c419a8078c3b0821450bcf;hpb=90a4005498c1abf5784bcaef652564acb1d71430;p=platform%2Fupstream%2Fisl.git

diff --git a/isl_map.c b/isl_map.c
index 4446106..8154371 100644
--- a/isl_map.c
+++ b/isl_map.c
@@ -1,13 +1,15 @@
 /*
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2010      INRIA Saclay
+ * Copyright 2012      Ecole Normale Superieure
  *
- * 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
  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France 
+ * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
  */
 
 #include <string.h>
@@ -30,6 +32,7 @@
 #include <isl_dim_map.h>
 #include <isl_local_space_private.h>
 #include <isl_aff_private.h>
+#include <isl_options_private.h>
 
 static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type)
 {
@@ -121,6 +124,8 @@ unsigned isl_basic_set_n_param(__isl_keep isl_basic_set *bset)
 
 unsigned isl_basic_set_total_dim(const struct isl_basic_set *bset)
 {
+	if (!bset)
+		return 0;
 	return isl_space_dim(bset->dim, isl_dim_all) + bset->n_div;
 }
 
@@ -254,25 +259,42 @@ __isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_set *bset)
 	return isl_space_copy(bset->dim);
 }
 
-__isl_give isl_local_space *isl_basic_map_get_local_space(
-	__isl_keep isl_basic_map *bmap)
+/* Extract the divs in "bmap" as a matrix.
+ */
+__isl_give isl_mat *isl_basic_map_get_divs(__isl_keep isl_basic_map *bmap)
 {
 	int i;
-	isl_local_space *ls;
+	isl_ctx *ctx;
+	isl_mat *div;
 	unsigned total;
+	unsigned cols;
 
 	if (!bmap)
 		return NULL;
 
-	total = isl_basic_map_total_dim(bmap);
-	ls = isl_local_space_alloc(isl_space_copy(bmap->dim), bmap->n_div);
-	if (!ls)
+	ctx = isl_basic_map_get_ctx(bmap);
+	total = isl_space_dim(bmap->dim, isl_dim_all);
+	cols = 1 + 1 + total + bmap->n_div;
+	div = isl_mat_alloc(ctx, bmap->n_div, cols);
+	if (!div)
 		return NULL;
 
 	for (i = 0; i < bmap->n_div; ++i)
-		isl_seq_cpy(ls->div->row[i], bmap->div[i], 2 + total);
+		isl_seq_cpy(div->row[i], bmap->div[i], cols);
+
+	return div;
+}
+
+__isl_give isl_local_space *isl_basic_map_get_local_space(
+	__isl_keep isl_basic_map *bmap)
+{
+	isl_mat *div;
 
-	return ls;
+	if (!bmap)
+		return NULL;
+
+	div = isl_basic_map_get_divs(bmap);
+	return isl_local_space_alloc_div(isl_space_copy(bmap->dim), div);
 }
 
 __isl_give isl_local_space *isl_basic_set_get_local_space(
@@ -386,6 +408,13 @@ error:
 	return NULL;
 }
 
+/* Does the input or output tuple have a name?
+ */
+int isl_map_has_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type)
+{
+	return map ? isl_space_has_tuple_name(map->dim, type) : -1;
+}
+
 const char *isl_map_get_tuple_name(__isl_keep isl_map *map,
 	enum isl_dim_type type)
 {
@@ -454,6 +483,14 @@ __isl_give isl_id *isl_set_get_tuple_id(__isl_keep isl_set *set)
 	return isl_map_get_tuple_id(set, isl_dim_set);
 }
 
+/* Does the set tuple have a name?
+ */
+int isl_set_has_tuple_name(__isl_keep isl_set *set)
+{
+	return set ? isl_space_has_tuple_name(set->dim, isl_dim_set) : -1;
+}
+
+
 const char *isl_basic_set_get_tuple_name(__isl_keep isl_basic_set *bset)
 {
 	return bset ? isl_space_get_tuple_name(bset->dim, isl_dim_set) : NULL;
@@ -476,6 +513,14 @@ const char *isl_basic_set_get_dim_name(__isl_keep isl_basic_set *bset,
 	return bset ? isl_space_get_dim_name(bset->dim, type, pos) : NULL;
 }
 
+/* Does the given dimension have a name?
+ */
+int isl_map_has_dim_name(__isl_keep isl_map *map,
+	enum isl_dim_type type, unsigned pos)
+{
+	return map ? isl_space_has_dim_name(map->dim, type, pos) : -1;
+}
+
 const char *isl_map_get_dim_name(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos)
 {
@@ -488,6 +533,14 @@ const char *isl_set_get_dim_name(__isl_keep isl_set *set,
 	return set ? isl_space_get_dim_name(set->dim, type, pos) : NULL;
 }
 
+/* Does the given dimension have a name?
+ */
+int isl_set_has_dim_name(__isl_keep isl_set *set,
+	enum isl_dim_type type, unsigned pos)
+{
+	return set ? isl_space_has_dim_name(set->dim, type, pos) : -1;
+}
+
 __isl_give isl_basic_map *isl_basic_map_set_dim_name(
 	__isl_take isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos, const char *s)
@@ -498,7 +551,7 @@ __isl_give isl_basic_map *isl_basic_map_set_dim_name(
 	bmap->dim = isl_space_set_dim_name(bmap->dim, type, pos, s);
 	if (!bmap->dim)
 		goto error;
-	return bmap;
+	return isl_basic_map_finalize(bmap);
 error:
 	isl_basic_map_free(bmap);
 	return NULL;
@@ -549,6 +602,12 @@ int isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
 	return bmap ? isl_space_has_dim_id(bmap->dim, type, pos) : -1;
 }
 
+__isl_give isl_id *isl_basic_set_get_dim_id(__isl_keep isl_basic_set *bset,
+	enum isl_dim_type type, unsigned pos)
+{
+	return bset ? isl_space_get_dim_id(bset->dim, type, pos) : NULL;
+}
+
 int isl_map_has_dim_id(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos)
 {
@@ -613,6 +672,12 @@ int isl_map_find_dim_by_name(__isl_keep isl_map *map, enum isl_dim_type type,
 	return isl_space_find_dim_by_name(map->dim, type, name);
 }
 
+int isl_set_find_dim_by_name(__isl_keep isl_set *set, enum isl_dim_type type,
+	const char *name)
+{
+	return isl_map_find_dim_by_name(set, type, name);
+}
+
 int isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
@@ -625,6 +690,76 @@ int isl_basic_set_is_rational(__isl_keep isl_basic_set *bset)
 	return isl_basic_map_is_rational(bset);
 }
 
+/* Does "bmap" contain any rational points?
+ *
+ * If "bmap" has an equality for each dimension, equating the dimension
+ * to an integer constant, then it has no rational points, even if it
+ * is marked as rational.
+ */
+int isl_basic_map_has_rational(__isl_keep isl_basic_map *bmap)
+{
+	int has_rational = 1;
+	unsigned total;
+
+	if (!bmap)
+		return -1;
+	if (isl_basic_map_plain_is_empty(bmap))
+		return 0;
+	if (!isl_basic_map_is_rational(bmap))
+		return 0;
+	bmap = isl_basic_map_copy(bmap);
+	bmap = isl_basic_map_implicit_equalities(bmap);
+	if (!bmap)
+		return -1;
+	total = isl_basic_map_total_dim(bmap);
+	if (bmap->n_eq == total) {
+		int i, j;
+		for (i = 0; i < bmap->n_eq; ++i) {
+			j = isl_seq_first_non_zero(bmap->eq[i] + 1, total);
+			if (j < 0)
+				break;
+			if (!isl_int_is_one(bmap->eq[i][1 + j]) &&
+			    !isl_int_is_negone(bmap->eq[i][1 + j]))
+				break;
+			j = isl_seq_first_non_zero(bmap->eq[i] + 1 + j + 1,
+						    total - j - 1);
+			if (j >= 0)
+				break;
+		}
+		if (i == bmap->n_eq)
+			has_rational = 0;
+	}
+	isl_basic_map_free(bmap);
+
+	return has_rational;
+}
+
+/* Does "map" contain any rational points?
+ */
+int isl_map_has_rational(__isl_keep isl_map *map)
+{
+	int i;
+	int has_rational;
+
+	if (!map)
+		return -1;
+	for (i = 0; i < map->n; ++i) {
+		has_rational = isl_basic_map_has_rational(map->p[i]);
+		if (has_rational < 0)
+			return -1;
+		if (has_rational)
+			return 1;
+	}
+	return 0;
+}
+
+/* Does "set" contain any rational points?
+ */
+int isl_set_has_rational(__isl_keep isl_set *set)
+{
+	return isl_map_has_rational(set);
+}
+
 /* Is this basic set a parameter domain?
  */
 int isl_basic_set_is_params(__isl_keep isl_basic_set *bset)
@@ -861,13 +996,13 @@ struct isl_map *isl_map_copy(struct isl_map *map)
 	return map;
 }
 
-void isl_basic_map_free(struct isl_basic_map *bmap)
+void *isl_basic_map_free(__isl_take isl_basic_map *bmap)
 {
 	if (!bmap)
-		return;
+		return NULL;
 
 	if (--bmap->ref > 0)
-		return;
+		return NULL;
 
 	isl_ctx_deref(bmap->ctx);
 	free(bmap->div);
@@ -877,11 +1012,13 @@ void isl_basic_map_free(struct isl_basic_map *bmap)
 	isl_vec_free(bmap->sample);
 	isl_space_free(bmap->dim);
 	free(bmap);
+
+	return NULL;
 }
 
-void isl_basic_set_free(struct isl_basic_set *bset)
+void *isl_basic_set_free(struct isl_basic_set *bset)
 {
-	isl_basic_map_free((struct isl_basic_map *)bset);
+	return isl_basic_map_free((struct isl_basic_map *)bset);
 }
 
 static int room_for_con(struct isl_basic_map *bmap, unsigned n)
@@ -1546,8 +1683,8 @@ void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b)
 }
 
 /* Eliminate the specified n dimensions starting at first from the
- * constraints using Fourier-Motzkin.  The dimensions themselves
- * are not removed.
+ * constraints, without removing the dimensions from the space.
+ * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
  */
 __isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned first, unsigned n)
@@ -1559,6 +1696,10 @@ __isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map,
 	if (n == 0)
 		return map;
 
+	if (first + n > isl_map_dim(map, type) || first + n < first)
+		isl_die(map->ctx, isl_error_invalid,
+			"index out of bounds", goto error);
+
 	map = isl_map_cow(map);
 	if (!map)
 		return NULL;
@@ -1575,8 +1716,8 @@ error:
 }
 
 /* Eliminate the specified n dimensions starting at first from the
- * constraints using Fourier-Motzkin.  The dimensions themselves
- * are not removed.
+ * constraints, without removing the dimensions from the space.
+ * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
  */
 __isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned first, unsigned n)
@@ -1585,8 +1726,8 @@ __isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set,
 }
 
 /* Eliminate the specified n dimensions starting at first from the
- * constraints using Fourier-Motzkin.  The dimensions themselves
- * are not removed.
+ * constraints, without removing the dimensions from the space.
+ * If the set is rational, the dimensions are eliminated using Fourier-Motzkin.
  */
 __isl_give isl_set *isl_set_eliminate_dims(__isl_take isl_set *set,
 	unsigned first, unsigned n)
@@ -1689,6 +1830,196 @@ static int div_involves_vars(__isl_keep isl_basic_map *bmap, int div,
 	return 0;
 }
 
+/* Try and add a lower and/or upper bound on "div" to "bmap"
+ * based on inequality "i".
+ * "total" is the total number of variables (excluding the divs).
+ * "v" is a temporary object that can be used during the calculations.
+ * If "lb" is set, then a lower bound should be constructed.
+ * If "ub" is set, then an upper bound should be constructed.
+ *
+ * The calling function has already checked that the inequality does not
+ * reference "div", but we still need to check that the inequality is
+ * of the right form.  We'll consider the case where we want to construct
+ * a lower bound.  The construction of upper bounds is similar.
+ *
+ * Let "div" be of the form
+ *
+ *	q = floor((a + f(x))/d)
+ *
+ * We essentially check if constraint "i" is of the form
+ *
+ *	b + f(x) >= 0
+ *
+ * so that we can use it to derive a lower bound on "div".
+ * However, we allow a slightly more general form
+ *
+ *	b + g(x) >= 0
+ *
+ * with the condition that the coefficients of g(x) - f(x) are all
+ * divisible by d.
+ * Rewriting this constraint as
+ *
+ *	0 >= -b - g(x)
+ *
+ * adding a + f(x) to both sides and dividing by d, we obtain
+ *
+ *	(a + f(x))/d >= (a-b)/d + (f(x)-g(x))/d
+ *
+ * Taking the floor on both sides, we obtain
+ *
+ *	q >= floor((a-b)/d) + (f(x)-g(x))/d
+ *
+ * or
+ *
+ *	(g(x)-f(x))/d + ceil((b-a)/d) + q >= 0
+ *
+ * In the case of an upper bound, we construct the constraint
+ *
+ *	(g(x)+f(x))/d + floor((b+a)/d) - q >= 0
+ *
+ */
+static __isl_give isl_basic_map *insert_bounds_on_div_from_ineq(
+	__isl_take isl_basic_map *bmap, int div, int i,
+	unsigned total, isl_int v, int lb, int ub)
+{
+	int j;
+
+	for (j = 0; (lb || ub) && j < total + bmap->n_div; ++j) {
+		if (lb) {
+			isl_int_sub(v, bmap->ineq[i][1 + j],
+					bmap->div[div][1 + 1 + j]);
+			lb = isl_int_is_divisible_by(v, bmap->div[div][0]);
+		}
+		if (ub) {
+			isl_int_add(v, bmap->ineq[i][1 + j],
+					bmap->div[div][1 + 1 + j]);
+			ub = isl_int_is_divisible_by(v, bmap->div[div][0]);
+		}
+	}
+	if (!lb && !ub)
+		return bmap;
+
+	bmap = isl_basic_map_extend_constraints(bmap, 0, lb + ub);
+	if (lb) {
+		int k = isl_basic_map_alloc_inequality(bmap);
+		if (k < 0)
+			goto error;
+		for (j = 0; j < 1 + total + bmap->n_div; ++j) {
+			isl_int_sub(bmap->ineq[k][j], bmap->ineq[i][j],
+					bmap->div[div][1 + j]);
+			isl_int_cdiv_q(bmap->ineq[k][j],
+					bmap->ineq[k][j], bmap->div[div][0]);
+		}
+		isl_int_set_si(bmap->ineq[k][1 + total + div], 1);
+	}
+	if (ub) {
+		int k = isl_basic_map_alloc_inequality(bmap);
+		if (k < 0)
+			goto error;
+		for (j = 0; j < 1 + total + bmap->n_div; ++j) {
+			isl_int_add(bmap->ineq[k][j], bmap->ineq[i][j],
+					bmap->div[div][1 + j]);
+			isl_int_fdiv_q(bmap->ineq[k][j],
+					bmap->ineq[k][j], bmap->div[div][0]);
+		}
+		isl_int_set_si(bmap->ineq[k][1 + total + div], -1);
+	}
+
+	return bmap;
+error:
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* This function is called right before "div" is eliminated from "bmap"
+ * using Fourier-Motzkin.
+ * Look through the constraints of "bmap" for constraints on the argument
+ * of the integer division and use them to construct constraints on the
+ * integer division itself.  These constraints can then be combined
+ * during the Fourier-Motzkin elimination.
+ * Note that it is only useful to introduce lower bounds on "div"
+ * if "bmap" already contains upper bounds on "div" as the newly
+ * introduce lower bounds can then be combined with the pre-existing
+ * upper bounds.  Similarly for upper bounds.
+ * We therefore first check if "bmap" contains any lower and/or upper bounds
+ * on "div".
+ *
+ * It is interesting to note that the introduction of these constraints
+ * can indeed lead to more accurate results, even when compared to
+ * deriving constraints on the argument of "div" from constraints on "div".
+ * Consider, for example, the set
+ *
+ *	{ [i,j,k] : 3 + i + 2j >= 0 and 2 * [(i+2j)/4] <= k }
+ *
+ * The second constraint can be rewritten as
+ *
+ *	2 * [(-i-2j+3)/4] + k >= 0
+ *
+ * from which we can derive
+ *
+ *	-i - 2j + 3 >= -2k
+ *
+ * or
+ *
+ *	i + 2j <= 3 + 2k
+ *
+ * Combined with the first constraint, we obtain
+ *
+ *	-3 <= 3 + 2k	or	k >= -3
+ *
+ * If, on the other hand we derive a constraint on [(i+2j)/4] from
+ * the first constraint, we obtain
+ *
+ *	[(i + 2j)/4] >= [-3/4] = -1
+ *
+ * Combining this constraint with the second constraint, we obtain
+ *
+ *	k >= -2
+ */
+static __isl_give isl_basic_map *insert_bounds_on_div(
+	__isl_take isl_basic_map *bmap, int div)
+{
+	int i;
+	int check_lb, check_ub;
+	isl_int v;
+	unsigned total;
+
+	if (!bmap)
+		return NULL;
+
+	if (isl_int_is_zero(bmap->div[div][0]))
+		return bmap;
+
+	total = isl_space_dim(bmap->dim, isl_dim_all);
+
+	check_lb = 0;
+	check_ub = 0;
+	for (i = 0; (!check_lb || !check_ub) && i < bmap->n_ineq; ++i) {
+		int s = isl_int_sgn(bmap->ineq[i][1 + total + div]);
+		if (s > 0)
+			check_ub = 1;
+		if (s < 0)
+			check_lb = 1;
+	}
+
+	if (!check_lb && !check_ub)
+		return bmap;
+
+	isl_int_init(v);
+
+	for (i = 0; bmap && i < bmap->n_ineq; ++i) {
+		if (!isl_int_is_zero(bmap->ineq[i][1 + total + div]))
+			continue;
+
+		bmap = insert_bounds_on_div_from_ineq(bmap, div, i, total, v,
+							check_lb, check_ub);
+	}
+
+	isl_int_clear(v);
+
+	return bmap;
+}
+
 /* Remove all divs (recursively) involving any of the given dimensions
  * in their definitions.
  */
@@ -1707,6 +2038,7 @@ __isl_give isl_basic_map *isl_basic_map_remove_divs_involving_dims(
 	for (i = bmap->n_div - 1; i >= 0; --i) {
 		if (!div_involves_vars(bmap, i, first, n))
 			continue;
+		bmap = insert_bounds_on_div(bmap, i);
 		bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
 		if (!bmap)
 			return NULL;
@@ -1719,6 +2051,13 @@ error:
 	return NULL;
 }
 
+__isl_give isl_basic_set *isl_basic_set_remove_divs_involving_dims(
+	__isl_take isl_basic_set *bset,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return isl_basic_map_remove_divs_involving_dims(bset, type, first, n);
+}
+
 __isl_give isl_map *isl_map_remove_divs_involving_dims(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
@@ -1752,6 +2091,12 @@ __isl_give isl_set *isl_set_remove_divs_involving_dims(__isl_take isl_set *set,
 							      type, first, n);
 }
 
+/* Does the desciption of "bmap" depend on the specified dimensions?
+ * We also check whether the dimensions appear in any of the div definitions.
+ * In principle there is no need for this check.  If the dimensions appear
+ * in a div definition, they also appear in the defining constraints of that
+ * div.
+ */
 int isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
@@ -1771,6 +2116,12 @@ int isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
 	for (i = 0; i < bmap->n_ineq; ++i)
 		if (isl_seq_first_non_zero(bmap->ineq[i] + first, n) >= 0)
 			return 1;
+	for (i = 0; i < bmap->n_div; ++i) {
+		if (isl_int_is_zero(bmap->div[i][0]))
+			continue;
+		if (isl_seq_first_non_zero(bmap->div[i] + 1 + first, n) >= 0)
+			return 1;
+	}
 
 	return 0;
 }
@@ -1844,11 +2195,22 @@ __isl_give isl_basic_map *isl_basic_map_remove_unknown_divs(
 		if (!div_is_unknown(bmap, i))
 			continue;
 		bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
+		if (!bmap)
+			return NULL;
+		i = bmap->n_div;
 	}
 
 	return bmap;
 }
 
+/* Remove all divs that are unknown or defined in terms of unknown divs.
+ */
+__isl_give isl_basic_set *isl_basic_set_remove_unknown_divs(
+	__isl_take isl_basic_set *bset)
+{
+	return isl_basic_map_remove_unknown_divs(bset);
+}
+
 __isl_give isl_map *isl_map_remove_unknown_divs(__isl_take isl_map *map)
 {
 	int i;
@@ -2203,21 +2565,23 @@ __isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set,
 						(struct isl_basic_map *)bset);
 }
 
-void isl_set_free(struct isl_set *set)
+void *isl_set_free(__isl_take isl_set *set)
 {
 	int i;
 
 	if (!set)
-		return;
+		return NULL;
 
 	if (--set->ref > 0)
-		return;
+		return NULL;
 
 	isl_ctx_deref(set->ctx);
 	for (i = 0; i < set->n; ++i)
 		isl_basic_set_free(set->p[i]);
 	isl_space_free(set->dim);
 	free(set);
+
+	return NULL;
 }
 
 void isl_set_print_internal(struct isl_set *set, FILE *out, int indent)
@@ -2500,12 +2864,14 @@ static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1,
 	if (!map1 || !map2)
 		goto error;
 
-	if (isl_map_plain_is_empty(map1) &&
+	if ((isl_map_plain_is_empty(map1) ||
+	     isl_map_plain_is_universe(map2)) &&
 	    isl_space_is_equal(map1->dim, map2->dim)) {
 		isl_map_free(map2);
 		return map1;
 	}
-	if (isl_map_plain_is_empty(map2) &&
+	if ((isl_map_plain_is_empty(map2) ||
+	     isl_map_plain_is_universe(map1)) &&
 	    isl_space_is_equal(map1->dim, map2->dim)) {
 		isl_map_free(map1);
 		return map2;
@@ -2537,10 +2903,9 @@ static __isl_give isl_map *map_intersect_internal(__isl_take isl_map *map1,
 			part = isl_basic_map_intersect(
 				    isl_basic_map_copy(map1->p[i]),
 				    isl_basic_map_copy(map2->p[j]));
-			if (isl_basic_map_is_empty(part))
-				isl_basic_map_free(part);
-			else
-				result = isl_map_add_basic_map(result, part);
+			if (isl_basic_map_is_empty(part) < 0)
+				goto error;
+			result = isl_map_add_basic_map(result, part);
 			if (!result)
 				goto error;
 		}
@@ -2634,8 +2999,9 @@ static __isl_give isl_basic_map *basic_map_space_reset(
 	return bmap;
 }
 
-__isl_give isl_basic_map *isl_basic_map_insert(__isl_take isl_basic_map *bmap,
-		enum isl_dim_type type, unsigned pos, unsigned n)
+__isl_give isl_basic_map *isl_basic_map_insert_dims(
+	__isl_take isl_basic_map *bmap, enum isl_dim_type type,
+	unsigned pos, unsigned n)
 {
 	isl_space *res_dim;
 	struct isl_basic_map *res;
@@ -2672,16 +3038,27 @@ __isl_give isl_basic_map *isl_basic_map_insert(__isl_take isl_basic_map *bmap,
 			bmap->n_div, bmap->n_eq, bmap->n_ineq);
 	if (isl_basic_map_is_rational(bmap))
 		res = isl_basic_map_set_rational(res);
+	if (isl_basic_map_plain_is_empty(bmap)) {
+		isl_basic_map_free(bmap);
+		return isl_basic_map_set_to_empty(res);
+	}
 	res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
 	return isl_basic_map_finalize(res);
 }
 
+__isl_give isl_basic_set *isl_basic_set_insert_dims(
+	__isl_take isl_basic_set *bset,
+	enum isl_dim_type type, unsigned pos, unsigned n)
+{
+	return isl_basic_map_insert_dims(bset, type, pos, n);
+}
+
 __isl_give isl_basic_map *isl_basic_map_add(__isl_take isl_basic_map *bmap,
 		enum isl_dim_type type, unsigned n)
 {
 	if (!bmap)
 		return NULL;
-	return isl_basic_map_insert(bmap, type,
+	return isl_basic_map_insert_dims(bmap, type,
 					isl_basic_map_dim(bmap, type), n);
 }
 
@@ -2702,7 +3079,7 @@ static __isl_give isl_map *map_space_reset(__isl_take isl_map *map,
 {
 	isl_space *space;
 
-	if (!isl_space_is_named_or_nested(map->dim, type))
+	if (!map || !isl_space_is_named_or_nested(map->dim, type))
 		return map;
 
 	space = isl_map_get_space(map);
@@ -2728,7 +3105,7 @@ __isl_give isl_map *isl_map_insert_dims(__isl_take isl_map *map,
 		goto error;
 
 	for (i = 0; i < map->n; ++i) {
-		map->p[i] = isl_basic_map_insert(map->p[i], type, pos, n);
+		map->p[i] = isl_basic_map_insert_dims(map->p[i], type, pos, n);
 		if (!map->p[i])
 			goto error;
 	}
@@ -2976,7 +3353,7 @@ __isl_give isl_basic_map *isl_basic_map_project_out(
 	isl_int *old;
 
 	if (n == 0)
-		return bmap;
+		return basic_map_space_reset(bmap, type);
 
 	if (!bmap)
 		return NULL;
@@ -3046,7 +3423,7 @@ __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
 		return NULL;
 
 	if (n == 0)
-		return map;
+		return map_space_reset(map, type);
 
 	isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
 
@@ -3883,6 +4260,11 @@ int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
 							bmap->div[div]);
 }
 
+int isl_basic_set_add_div_constraints(struct isl_basic_set *bset, unsigned div)
+{
+	return isl_basic_map_add_div_constraints(bset, div);
+}
+
 struct isl_basic_set *isl_basic_map_underlying_set(
 		struct isl_basic_map *bmap)
 {
@@ -4762,21 +5144,23 @@ error:
 	return NULL;
 }
 
-void isl_map_free(struct isl_map *map)
+void *isl_map_free(struct isl_map *map)
 {
 	int i;
 
 	if (!map)
-		return;
+		return NULL;
 
 	if (--map->ref > 0)
-		return;
+		return NULL;
 
 	isl_ctx_deref(map->ctx);
 	for (i = 0; i < map->n; ++i)
 		isl_basic_map_free(map->p[i]);
 	isl_space_free(map->dim);
 	free(map);
+
+	return NULL;
 }
 
 struct isl_map *isl_map_extend(struct isl_map *base,
@@ -4906,6 +5290,25 @@ struct isl_basic_set *isl_basic_set_fix_dim_si(struct isl_basic_set *bset,
 					isl_dim_set, dim, value);
 }
 
+static int remove_if_empty(__isl_keep isl_map *map, int i)
+{
+	int empty = isl_basic_map_plain_is_empty(map->p[i]);
+
+	if (empty < 0)
+		return -1;
+	if (!empty)
+		return 0;
+
+	isl_basic_map_free(map->p[i]);
+	if (i != map->n - 1) {
+		ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+		map->p[i] = map->p[map->n - 1];
+	}
+	map->n--;
+
+	return 0;
+}
+
 struct isl_map *isl_map_fix_si(struct isl_map *map,
 		enum isl_dim_type type, unsigned pos, int value)
 {
@@ -4916,9 +5319,9 @@ struct isl_map *isl_map_fix_si(struct isl_map *map,
 		return NULL;
 
 	isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
-	for (i = 0; i < map->n; ++i) {
+	for (i = map->n - 1; i >= 0; --i) {
 		map->p[i] = isl_basic_map_fix_si(map->p[i], type, pos, value);
-		if (!map->p[i])
+		if (remove_if_empty(map, i) < 0)
 			goto error;
 	}
 	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
@@ -4975,9 +5378,9 @@ struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value)
 		isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value);
 }
 
-__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
-		__isl_take isl_basic_map *bmap,
-		enum isl_dim_type type, unsigned pos, int value)
+static __isl_give isl_basic_map *basic_map_bound_si(
+	__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned pos, int value, int upper)
 {
 	int j;
 
@@ -4991,8 +5394,13 @@ __isl_give isl_basic_map *isl_basic_map_lower_bound_si(
 	if (j < 0)
 		goto error;
 	isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
-	isl_int_set_si(bmap->ineq[j][pos], 1);
-	isl_int_set_si(bmap->ineq[j][0], -value);
+	if (upper) {
+		isl_int_set_si(bmap->ineq[j][pos], -1);
+		isl_int_set_si(bmap->ineq[j][0], value);
+	} else {
+		isl_int_set_si(bmap->ineq[j][pos], 1);
+		isl_int_set_si(bmap->ineq[j][0], -value);
+	}
 	bmap = isl_basic_map_simplify(bmap);
 	return isl_basic_map_finalize(bmap);
 error:
@@ -5000,8 +5408,24 @@ error:
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset,
-	unsigned dim, isl_int value)
+__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
+	__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned pos, int value)
+{
+	return basic_map_bound_si(bmap, type, pos, value, 0);
+}
+
+/* Constrain the values of the given dimension to be no greater than "value".
+ */
+__isl_give isl_basic_map *isl_basic_map_upper_bound_si(
+	__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned pos, int value)
+{
+	return basic_map_bound_si(bmap, type, pos, value, 1);
+}
+
+struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset,
+	unsigned dim, isl_int value)
 {
 	int j;
 
@@ -5020,8 +5444,8 @@ error:
 	return NULL;
 }
 
-__isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
-		enum isl_dim_type type, unsigned pos, int value)
+static __isl_give isl_map *map_bound_si(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned pos, int value, int upper)
 {
 	int i;
 
@@ -5031,8 +5455,8 @@ __isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
 
 	isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
 	for (i = 0; i < map->n; ++i) {
-		map->p[i] = isl_basic_map_lower_bound_si(map->p[i],
-							 type, pos, value);
+		map->p[i] = basic_map_bound_si(map->p[i],
+						 type, pos, value, upper);
 		if (!map->p[i])
 			goto error;
 	}
@@ -5043,6 +5467,18 @@ error:
 	return NULL;
 }
 
+__isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned pos, int value)
+{
+	return map_bound_si(map, type, pos, value, 0);
+}
+
+__isl_give isl_map *isl_map_upper_bound_si(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned pos, int value)
+{
+	return map_bound_si(map, type, pos, value, 1);
+}
+
 __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos, int value)
 {
@@ -5050,6 +5486,98 @@ __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
 		isl_map_lower_bound_si((struct isl_map *)set, type, pos, value);
 }
 
+__isl_give isl_set *isl_set_upper_bound_si(__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned pos, int value)
+{
+	return isl_map_upper_bound_si(set, type, pos, value);
+}
+
+/* Bound the given variable of "bmap" from below (or above is "upper"
+ * is set) to "value".
+ */
+static __isl_give isl_basic_map *basic_map_bound(
+	__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned pos, isl_int value, int upper)
+{
+	int j;
+
+	if (!bmap)
+		return NULL;
+	if (pos >= isl_basic_map_dim(bmap, type))
+		isl_die(bmap->ctx, isl_error_invalid,
+			"index out of bounds", goto error);
+	pos += isl_basic_map_offset(bmap, type);
+	bmap = isl_basic_map_cow(bmap);
+	bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
+	j = isl_basic_map_alloc_inequality(bmap);
+	if (j < 0)
+		goto error;
+	isl_seq_clr(bmap->ineq[j], 1 + isl_basic_map_total_dim(bmap));
+	if (upper) {
+		isl_int_set_si(bmap->ineq[j][pos], -1);
+		isl_int_set(bmap->ineq[j][0], value);
+	} else {
+		isl_int_set_si(bmap->ineq[j][pos], 1);
+		isl_int_neg(bmap->ineq[j][0], value);
+	}
+	bmap = isl_basic_map_simplify(bmap);
+	return isl_basic_map_finalize(bmap);
+error:
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Bound the given variable of "map" from below (or above is "upper"
+ * is set) to "value".
+ */
+static __isl_give isl_map *map_bound(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned pos, isl_int value, int upper)
+{
+	int i;
+
+	map = isl_map_cow(map);
+	if (!map)
+		return NULL;
+
+	if (pos >= isl_map_dim(map, type))
+		isl_die(map->ctx, isl_error_invalid,
+			"index out of bounds", goto error);
+	for (i = map->n - 1; i >= 0; --i) {
+		map->p[i] = basic_map_bound(map->p[i], type, pos, value, upper);
+		if (remove_if_empty(map, i) < 0)
+			goto error;
+	}
+	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	return map;
+error:
+	isl_map_free(map);
+	return NULL;
+}
+
+__isl_give isl_map *isl_map_lower_bound(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned pos, isl_int value)
+{
+	return map_bound(map, type, pos, value, 0);
+}
+
+__isl_give isl_map *isl_map_upper_bound(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned pos, isl_int value)
+{
+	return map_bound(map, type, pos, value, 1);
+}
+
+__isl_give isl_set *isl_set_lower_bound(__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned pos, isl_int value)
+{
+	return isl_map_lower_bound(set, type, pos, value);
+}
+
+__isl_give isl_set *isl_set_upper_bound(__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned pos, isl_int value)
+{
+	return isl_map_upper_bound(set, type, pos, value);
+}
+
 struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim,
 					isl_int value)
 {
@@ -5194,58 +5722,93 @@ __isl_give isl_pw_multi_aff *isl_basic_map_lexmin_pw_multi_aff(
 	return isl_basic_map_lexopt_pw_multi_aff(bmap, 0);
 }
 
-/* Given a basic map "bmap", compute the lexicographically minimal
- * (or maximal) image element for each domain element in dom.
+#undef TYPE
+#define TYPE	isl_pw_multi_aff
+#undef SUFFIX
+#define SUFFIX	_pw_multi_aff
+#undef EMPTY
+#define EMPTY	isl_pw_multi_aff_empty
+#undef ADD
+#define ADD	isl_pw_multi_aff_union_add
+#include "isl_map_lexopt_templ.c"
+
+/* Given a map "map", compute the lexicographically minimal
+ * (or maximal) image element for each domain element in dom,
+ * in the form of an isl_pw_multi_aff.
  * Set *empty to those elements in dom that do not have an image element.
  *
- * We first make sure the basic sets in dom are disjoint and then
- * simply collect the results over each of the basic sets separately.
- * We could probably improve the efficiency a bit by moving the union
- * domain down into the parametric integer programming.
+ * We first compute the lexicographically minimal or maximal element
+ * in the first basic map.  This results in a partial solution "res"
+ * and a subset "todo" of dom that still need to be handled.
+ * We then consider each of the remaining maps in "map" and successively
+ * update both "res" and "todo".
  */
-static __isl_give isl_map *basic_map_partial_lexopt(
-		__isl_take isl_basic_map *bmap, __isl_take isl_set *dom,
-		__isl_give isl_set **empty, int max)
+static __isl_give isl_pw_multi_aff *isl_map_partial_lexopt_aligned_pw_multi_aff(
+	__isl_take isl_map *map, __isl_take isl_set *dom,
+	__isl_give isl_set **empty, int max)
 {
 	int i;
-	struct isl_map *res;
+	isl_pw_multi_aff *res;
+	isl_set *todo;
 
-	dom = isl_set_make_disjoint(dom);
-	if (!dom)
+	if (!map || !dom)
 		goto error;
 
-	if (isl_set_plain_is_empty(dom)) {
-		res = isl_map_empty_like_basic_map(bmap);
-		*empty = isl_set_empty_like(dom);
-		isl_set_free(dom);
-		isl_basic_map_free(bmap);
-		return res;
+	if (isl_map_plain_is_empty(map)) {
+		if (empty)
+			*empty = dom;
+		else
+			isl_set_free(dom);
+		return isl_pw_multi_aff_from_map(map);
 	}
 
-	res = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
-			isl_basic_set_copy(dom->p[0]), empty, max);
-		
-	for (i = 1; i < dom->n; ++i) {
-		struct isl_map *res_i;
-		struct isl_set *empty_i;
+	res = basic_map_partial_lexopt_pw_multi_aff(
+					    isl_basic_map_copy(map->p[0]),
+					    isl_set_copy(dom), &todo, max);
 
-		res_i = isl_basic_map_partial_lexopt(isl_basic_map_copy(bmap),
-				isl_basic_set_copy(dom->p[i]), &empty_i, max);
+	for (i = 1; i < map->n; ++i) {
+		isl_pw_multi_aff *res_i;
+		isl_set *todo_i;
 
-		res = isl_map_union_disjoint(res, res_i);
-		*empty = isl_set_union_disjoint(*empty, empty_i);
+		res_i = basic_map_partial_lexopt_pw_multi_aff(
+					    isl_basic_map_copy(map->p[i]),
+					    isl_set_copy(dom), &todo_i, max);
+
+		if (max)
+			res = isl_pw_multi_aff_union_lexmax(res, res_i);
+		else
+			res = isl_pw_multi_aff_union_lexmin(res, res_i);
+
+		todo = isl_set_intersect(todo, todo_i);
 	}
 
 	isl_set_free(dom);
-	isl_basic_map_free(bmap);
+	isl_map_free(map);
+
+	if (empty)
+		*empty = todo;
+	else
+		isl_set_free(todo);
+
 	return res;
 error:
-	*empty = NULL;
+	if (empty)
+		*empty = NULL;
 	isl_set_free(dom);
-	isl_basic_map_free(bmap);
+	isl_map_free(map);
 	return NULL;
 }
 
+#undef TYPE
+#define TYPE	isl_map
+#undef SUFFIX
+#define SUFFIX
+#undef EMPTY
+#define EMPTY	isl_map_empty
+#undef ADD
+#define ADD	isl_map_union_disjoint
+#include "isl_map_lexopt_templ.c"
+
 /* Given a map "map", compute the lexicographically minimal
  * (or maximal) image element for each domain element in dom.
  * Set *empty to those elements in dom that do not have an image element.
@@ -5254,7 +5817,7 @@ error:
  * in the first basic map.  This results in a partial solution "res"
  * and a subset "todo" of dom that still need to be handled.
  * We then consider each of the remaining maps in "map" and successively
- * improve both "res" and "todo".
+ * update both "res" and "todo".
  *
  * Let res^k and todo^k be the results after k steps and let i = k + 1.
  * Assume we are computing the lexicographical maximum.
@@ -5373,35 +5936,6 @@ error:
 	return NULL;
 }
 
-/* Given a map "map", compute the lexicographically minimal
- * (or maximal) image element for each domain element in dom.
- * Set *empty to those elements in dom that do not have an image element.
- *
- * Align parameters if needed and then call isl_map_partial_lexopt_aligned.
- */
-static __isl_give isl_map *isl_map_partial_lexopt(
-		__isl_take isl_map *map, __isl_take isl_set *dom,
-		__isl_give isl_set **empty, int max)
-{
-	if (!map || !dom)
-		goto error;
-	if (isl_space_match(map->dim, isl_dim_param, dom->dim, isl_dim_param))
-		return isl_map_partial_lexopt_aligned(map, dom, empty, max);
-	if (!isl_space_has_named_params(map->dim) ||
-	    !isl_space_has_named_params(dom->dim))
-		isl_die(map->ctx, isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
-	map = isl_map_align_params(map, isl_map_get_space(dom));
-	dom = isl_map_align_params(dom, isl_map_get_space(map));
-	return isl_map_partial_lexopt_aligned(map, dom, empty, max);
-error:
-	if (empty)
-		*empty = NULL;
-	isl_set_free(dom);
-	isl_map_free(map);
-	return NULL;
-}
-
 __isl_give isl_map *isl_map_partial_lexmax(
 		__isl_take isl_map *map, __isl_take isl_set *dom,
 		__isl_give isl_set **empty)
@@ -5469,31 +6003,6 @@ __isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset)
 	return (isl_set *)isl_basic_map_lexmax((isl_basic_map *)bset);
 }
 
-__isl_give isl_map *isl_map_lexopt(__isl_take isl_map *map, int max)
-{
-	struct isl_set *dom = NULL;
-	isl_space *dom_dim;
-
-	if (!map)
-		goto error;
-	dom_dim = isl_space_domain(isl_space_copy(map->dim));
-	dom = isl_set_universe(dom_dim);
-	return isl_map_partial_lexopt(map, dom, NULL, max);
-error:
-	isl_map_free(map);
-	return NULL;
-}
-
-__isl_give isl_map *isl_map_lexmin(__isl_take isl_map *map)
-{
-	return isl_map_lexopt(map, 0);
-}
-
-__isl_give isl_map *isl_map_lexmax(__isl_take isl_map *map)
-{
-	return isl_map_lexopt(map, 1);
-}
-
 __isl_give isl_set *isl_set_lexmin(__isl_take isl_set *set)
 {
 	return (isl_set *)isl_map_lexmin((isl_map *)set);
@@ -6012,12 +6521,23 @@ error:
 	return NULL;
 }
 
+/* Return the union of "map1" and "map2", where we assume for now that
+ * "map1" and "map2" are disjoint.  Note that the basic maps inside
+ * "map1" or "map2" may not be disjoint from each other.
+ * Also note that this function is also called from isl_map_union,
+ * which takes care of handling the situation where "map1" and "map2"
+ * may not be disjoint.
+ *
+ * If one of the inputs is empty, we can simply return the other input.
+ * Similarly, if one of the inputs is universal, then it is equal to the union.
+ */
 static __isl_give isl_map *map_union_disjoint(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
 	int i;
 	unsigned flags = 0;
 	struct isl_map *map = NULL;
+	int is_universe;
 
 	if (!map1 || !map2)
 		goto error;
@@ -6031,6 +6551,22 @@ static __isl_give isl_map *map_union_disjoint(__isl_take isl_map *map1,
 		return map1;
 	}
 
+	is_universe = isl_map_plain_is_universe(map1);
+	if (is_universe < 0)
+		goto error;
+	if (is_universe) {
+		isl_map_free(map2);
+		return map1;
+	}
+
+	is_universe = isl_map_plain_is_universe(map2);
+	if (is_universe < 0)
+		goto error;
+	if (is_universe) {
+		isl_map_free(map1);
+		return map2;
+	}
+
 	isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error);
 
 	if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
@@ -6093,25 +6629,20 @@ struct isl_set *isl_set_union(struct isl_set *set1, struct isl_set *set2)
 		isl_map_union((struct isl_map *)set1, (struct isl_map *)set2);
 }
 
-static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map,
-	__isl_take isl_set *set)
+/* Apply "fn" to pairs of elements from "map" and "set" and collect
+ * the results.
+ *
+ * "map" and "set" are assumed to be compatible and non-NULL.
+ */
+static __isl_give isl_map *map_intersect_set(__isl_take isl_map *map,
+	__isl_take isl_set *set,
+	__isl_give isl_basic_map *fn(__isl_take isl_basic_map *bmap,
+		__isl_take isl_basic_set *bset))
 {
 	unsigned flags = 0;
 	struct isl_map *result;
 	int i, j;
 
-	if (!map || !set)
-		goto error;
-
-	if (!isl_space_match(map->dim, isl_dim_param, set->dim, isl_dim_param))
-		isl_die(set->ctx, isl_error_invalid,
-			"parameters don't match", goto error);
-
-	if (isl_space_dim(set->dim, isl_dim_set) != 0 &&
-	    !isl_map_compatible_range(map, set))
-		isl_die(set->ctx, isl_error_invalid,
-			"incompatible spaces", goto error);
-
 	if (isl_set_plain_is_universe(set)) {
 		isl_set_free(set);
 		return map;
@@ -6123,20 +6654,31 @@ static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map,
 
 	result = isl_map_alloc_space(isl_space_copy(map->dim),
 					map->n * set->n, flags);
-	if (!result)
-		goto error;
-	for (i = 0; i < map->n; ++i)
+	for (i = 0; result && i < map->n; ++i)
 		for (j = 0; j < set->n; ++j) {
 			result = isl_map_add_basic_map(result,
-			    isl_basic_map_intersect_range(
-				isl_basic_map_copy(map->p[i]),
-				isl_basic_set_copy(set->p[j])));
+					fn(isl_basic_map_copy(map->p[i]),
+					    isl_basic_set_copy(set->p[j])));
 			if (!result)
-				goto error;
+				break;
 		}
+
 	isl_map_free(map);
 	isl_set_free(set);
 	return result;
+}
+
+static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map,
+	__isl_take isl_set *set)
+{
+	if (!map || !set)
+		goto error;
+
+	if (!isl_map_compatible_range(map, set))
+		isl_die(set->ctx, isl_error_invalid,
+			"incompatible spaces", goto error);
+
+	return map_intersect_set(map, set, &isl_basic_map_intersect_range);
 error:
 	isl_map_free(map);
 	isl_set_free(set);
@@ -6149,11 +6691,28 @@ __isl_give isl_map *isl_map_intersect_range(__isl_take isl_map *map,
 	return isl_map_align_params_map_map_and(map, set, &map_intersect_range);
 }
 
-struct isl_map *isl_map_intersect_domain(
-		struct isl_map *map, struct isl_set *set)
+static __isl_give isl_map *map_intersect_domain(__isl_take isl_map *map,
+	__isl_take isl_set *set)
+{
+	if (!map || !set)
+		goto error;
+
+	if (!isl_map_compatible_domain(map, set))
+		isl_die(set->ctx, isl_error_invalid,
+			"incompatible spaces", goto error);
+
+	return map_intersect_set(map, set, &isl_basic_map_intersect_domain);
+error:
+	isl_map_free(map);
+	isl_set_free(set);
+	return NULL;
+}
+
+__isl_give isl_map *isl_map_intersect_domain(__isl_take isl_map *map,
+	__isl_take isl_set *set)
 {
-	return isl_map_reverse(
-		isl_map_intersect_range(isl_map_reverse(map), set));
+	return isl_map_align_params_map_map_and(map, set,
+						&map_intersect_domain);
 }
 
 static __isl_give isl_map *map_apply_domain(__isl_take isl_map *map1,
@@ -6264,7 +6823,7 @@ error:
 /*
  * returns range - domain
  */
-struct isl_set *isl_map_deltas(struct isl_map *map)
+__isl_give isl_set *isl_map_deltas(__isl_take isl_map *map)
 {
 	int i;
 	isl_space *dim;
@@ -6372,7 +6931,7 @@ error:
 	return NULL;
 }
 
-__isl_give struct isl_basic_map *basic_map_identity(__isl_take isl_space *dims)
+static __isl_give isl_basic_map *basic_map_identity(__isl_take isl_space *dims)
 {
 	struct isl_basic_map *bmap;
 	unsigned nparam;
@@ -6642,6 +7201,12 @@ int isl_basic_map_is_subset(
 	return is_subset;
 }
 
+int isl_basic_set_is_subset(__isl_keep isl_basic_set *bset1,
+	__isl_keep isl_basic_set *bset2)
+{
+	return isl_basic_map_is_subset(bset1, bset2);
+}
+
 int isl_basic_map_is_equal(
 		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
 {
@@ -6828,6 +7393,9 @@ int isl_basic_map_is_empty(struct isl_basic_map *bmap)
 	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
 		return 1;
 
+	if (isl_basic_map_is_universe(bmap))
+		return 0;
+
 	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
 		struct isl_basic_map *copy = isl_basic_map_copy(bmap);
 		copy = isl_basic_map_remove_redundancies(copy);
@@ -6895,7 +7463,7 @@ struct isl_map *isl_basic_map_union(
 {
 	struct isl_map *map;
 	if (!bmap1 || !bmap2)
-		return NULL;
+		goto error;
 
 	isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim), goto error);
 
@@ -7043,7 +7611,7 @@ struct isl_basic_map *isl_basic_map_align_divs(
 		struct isl_basic_map *dst, struct isl_basic_map *src)
 {
 	int i;
-	unsigned total = isl_space_dim(src->dim, isl_dim_all);
+	unsigned total;
 
 	if (!dst || !src)
 		goto error;
@@ -7060,6 +7628,7 @@ struct isl_basic_map *isl_basic_map_align_divs(
 			src->n_div, 0, 2 * src->n_div);
 	if (!dst)
 		return NULL;
+	total = isl_space_dim(src->dim, isl_dim_all);
 	for (i = 0; i < src->n_div; ++i) {
 		int j = find_div(dst, src, i);
 		if (j < 0) {
@@ -7145,16 +7714,8 @@ struct isl_map *isl_map_remove_empty_parts(struct isl_map *map)
 	if (!map)
 		return NULL;
 
-	for (i = map->n-1; i >= 0; --i) {
-		if (!ISL_F_ISSET(map->p[i], ISL_BASIC_MAP_EMPTY))
-			continue;
-		isl_basic_map_free(map->p[i]);
-		if (i != map->n-1) {
-			ISL_F_CLR(map, ISL_MAP_NORMALIZED);
-			map->p[i] = map->p[map->n-1];
-		}
-		map->n--;
-	}
+	for (i = map->n - 1; i >= 0; --i)
+		remove_if_empty(map, i);
 
 	return map;
 }
@@ -7721,8 +8282,7 @@ int isl_basic_set_plain_cmp(const __isl_keep isl_basic_set *bset1,
 	return isl_basic_map_plain_cmp(bset1, bset2);
 }
 
-int isl_set_plain_cmp(const __isl_keep isl_set *set1,
-	const __isl_keep isl_set *set2)
+int isl_set_plain_cmp(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
 {
 	int i, cmp;
 
@@ -8055,6 +8615,11 @@ __isl_give isl_basic_map *isl_basic_map_range_product(
 	if (!bmap1 || !bmap2)
 		goto error;
 
+	if (!isl_space_match(bmap1->dim, isl_dim_param,
+			    bmap2->dim, isl_dim_param))
+		isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
+			"parameters don't match", goto error);
+
 	dim_result = isl_space_range_product(isl_space_copy(bmap1->dim),
 					   isl_space_copy(bmap2->dim));
 
@@ -8622,7 +9187,7 @@ int isl_set_dim_is_bounded(__isl_keep isl_set *set,
 	return isl_map_dim_is_bounded((isl_map *)set, type, pos);
 }
 
-static int has_bound(__isl_keep isl_map *map,
+static int has_any_bound(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos,
 	int (*fn)(__isl_keep isl_basic_map *bmap,
 		  enum isl_dim_type type, unsigned pos))
@@ -8644,18 +9209,20 @@ static int has_bound(__isl_keep isl_map *map,
 
 /* Return 1 if the specified dim is involved in any lower bound.
  */
-int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
+int isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos)
 {
-	return has_bound(set, type, pos, &isl_basic_map_dim_has_lower_bound);
+	return has_any_bound(set, type, pos,
+				&isl_basic_map_dim_has_lower_bound);
 }
 
 /* Return 1 if the specified dim is involved in any upper bound.
  */
-int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
+int isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos)
 {
-	return has_bound(set, type, pos, &isl_basic_map_dim_has_upper_bound);
+	return has_any_bound(set, type, pos,
+				&isl_basic_map_dim_has_upper_bound);
 }
 
 /* For each of the "n" variables starting at "first", determine
@@ -8678,7 +9245,7 @@ int isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
 		return -1;
 
 	bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset));
-	tab = isl_tab_from_basic_set(bset);
+	tab = isl_tab_from_basic_set(bset, 0);
 	if (!bound || !tab)
 		goto error;
 
@@ -8768,6 +9335,39 @@ int isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap)
 	return 1;
 }
 
+/* Check if the given basic map is single-valued.
+ * We simply compute
+ *
+ *	M \circ M^-1
+ *
+ * and check if the result is a subset of the identity mapping.
+ */
+int isl_basic_map_is_single_valued(__isl_keep isl_basic_map *bmap)
+{
+	isl_space *space;
+	isl_basic_map *test;
+	isl_basic_map *id;
+	int sv;
+
+	sv = isl_basic_map_plain_is_single_valued(bmap);
+	if (sv < 0 || sv)
+		return sv;
+
+	test = isl_basic_map_reverse(isl_basic_map_copy(bmap));
+	test = isl_basic_map_apply_range(test, isl_basic_map_copy(bmap));
+
+	space = isl_basic_map_get_space(bmap);
+	space = isl_space_map_from_set(isl_space_range(space));
+	id = isl_basic_map_identity(space);
+
+	sv = isl_basic_map_is_subset(test, id);
+
+	isl_basic_map_free(test);
+	isl_basic_map_free(id);
+
+	return sv;
+}
+
 /* Check if the given map is obviously single-valued.
  */
 int isl_map_plain_is_single_valued(__isl_keep isl_map *map)
@@ -9281,14 +9881,21 @@ __isl_give isl_basic_map *isl_basic_map_realign(__isl_take isl_basic_map *bmap,
 	__isl_take isl_space *dim, __isl_take struct isl_dim_map *dim_map)
 {
 	isl_basic_map *res;
+	unsigned flags;
 
 	bmap = isl_basic_map_cow(bmap);
 	if (!bmap || !dim || !dim_map)
 		goto error;
 
+	flags = bmap->flags;
+	ISL_FL_CLR(flags, ISL_BASIC_MAP_FINAL);
+	ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED);
+	ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED_DIVS);
 	res = isl_basic_map_alloc_space(dim,
 			bmap->n_div, bmap->n_eq, bmap->n_ineq);
 	res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
+	if (res)
+		res->flags = flags;
 	res = isl_basic_map_finalize(res);
 	return res;
 error:
@@ -9382,7 +9989,61 @@ __isl_give isl_set *isl_set_align_params(__isl_take isl_set *set,
 	return isl_map_align_params(set, model);
 }
 
-__isl_give isl_mat *isl_basic_map_equalities_matrix(
+/* Align the parameters of "bmap" to those of "model", introducing
+ * additional parameters if needed.
+ */
+__isl_give isl_basic_map *isl_basic_map_align_params(
+	__isl_take isl_basic_map *bmap, __isl_take isl_space *model)
+{
+	isl_ctx *ctx;
+
+	if (!bmap || !model)
+		goto error;
+
+	ctx = isl_space_get_ctx(model);
+	if (!isl_space_has_named_params(model))
+		isl_die(ctx, isl_error_invalid,
+			"model has unnamed parameters", goto error);
+	if (!isl_space_has_named_params(bmap->dim))
+		isl_die(ctx, isl_error_invalid,
+			"relation has unnamed parameters", goto error);
+	if (!isl_space_match(bmap->dim, isl_dim_param, model, isl_dim_param)) {
+		isl_reordering *exp;
+		struct isl_dim_map *dim_map;
+
+		model = isl_space_drop_dims(model, isl_dim_in,
+					0, isl_space_dim(model, isl_dim_in));
+		model = isl_space_drop_dims(model, isl_dim_out,
+					0, isl_space_dim(model, isl_dim_out));
+		exp = isl_parameter_alignment_reordering(bmap->dim, model);
+		exp = isl_reordering_extend_space(exp,
+					isl_basic_map_get_space(bmap));
+		dim_map = isl_dim_map_from_reordering(exp);
+		bmap = isl_basic_map_realign(bmap,
+				    exp ? isl_space_copy(exp->dim) : NULL,
+				    isl_dim_map_extend(dim_map, bmap));
+		isl_reordering_free(exp);
+		free(dim_map);
+	}
+
+	isl_space_free(model);
+	return bmap;
+error:
+	isl_space_free(model);
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Align the parameters of "bset" to those of "model", introducing
+ * additional parameters if needed.
+ */
+__isl_give isl_basic_set *isl_basic_set_align_params(
+	__isl_take isl_basic_set *bset, __isl_take isl_space *model)
+{
+	return isl_basic_map_align_params(bset, model);
+}
+
+__isl_give isl_mat *isl_basic_map_equalities_matrix(
 		__isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
 		enum isl_dim_type c2, enum isl_dim_type c3,
 		enum isl_dim_type c4, enum isl_dim_type c5)
@@ -9579,6 +10240,7 @@ __isl_give isl_basic_map *isl_basic_map_zip(__isl_take isl_basic_map *bmap)
 		isl_space_dim(bmap->dim->nested[0], isl_dim_in);
 	n1 = isl_space_dim(bmap->dim->nested[0], isl_dim_out);
 	n2 = isl_space_dim(bmap->dim->nested[1], isl_dim_in);
+	bmap = isl_basic_map_cow(bmap);
 	bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2);
 	if (!bmap)
 		return NULL;
@@ -9625,6 +10287,155 @@ error:
 	return NULL;
 }
 
+/* Can we apply isl_basic_map_curry to "bmap"?
+ * That is, does it have a nested relation in its domain?
+ */
+int isl_basic_map_can_curry(__isl_keep isl_basic_map *bmap)
+{
+	if (!bmap)
+		return -1;
+
+	return isl_space_can_curry(bmap->dim);
+}
+
+/* Can we apply isl_map_curry to "map"?
+ * That is, does it have a nested relation in its domain?
+ */
+int isl_map_can_curry(__isl_keep isl_map *map)
+{
+	if (!map)
+		return -1;
+
+	return isl_space_can_curry(map->dim);
+}
+
+/* Given a basic map (A -> B) -> C, return the corresponding basic map
+ * A -> (B -> C).
+ */
+__isl_give isl_basic_map *isl_basic_map_curry(__isl_take isl_basic_map *bmap)
+{
+
+	if (!bmap)
+		return NULL;
+
+	if (!isl_basic_map_can_curry(bmap))
+		isl_die(bmap->ctx, isl_error_invalid,
+			"basic map cannot be curried", goto error);
+	bmap->dim = isl_space_curry(bmap->dim);
+	if (!bmap->dim)
+		goto error;
+	return bmap;
+error:
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Given a map (A -> B) -> C, return the corresponding map
+ * A -> (B -> C).
+ */
+__isl_give isl_map *isl_map_curry(__isl_take isl_map *map)
+{
+	int i;
+
+	if (!map)
+		return NULL;
+
+	if (!isl_map_can_curry(map))
+		isl_die(map->ctx, isl_error_invalid, "map cannot be curried",
+			goto error);
+
+	map = isl_map_cow(map);
+	if (!map)
+		return NULL;
+
+	for (i = 0; i < map->n; ++i) {
+		map->p[i] = isl_basic_map_curry(map->p[i]);
+		if (!map->p[i])
+			goto error;
+	}
+
+	map->dim = isl_space_curry(map->dim);
+	if (!map->dim)
+		goto error;
+
+	return map;
+error:
+	isl_map_free(map);
+	return NULL;
+}
+
+/* Can we apply isl_basic_map_uncurry to "bmap"?
+ * That is, does it have a nested relation in its domain?
+ */
+int isl_basic_map_can_uncurry(__isl_keep isl_basic_map *bmap)
+{
+	if (!bmap)
+		return -1;
+
+	return isl_space_can_uncurry(bmap->dim);
+}
+
+/* Can we apply isl_map_uncurry to "map"?
+ * That is, does it have a nested relation in its domain?
+ */
+int isl_map_can_uncurry(__isl_keep isl_map *map)
+{
+	if (!map)
+		return -1;
+
+	return isl_space_can_uncurry(map->dim);
+}
+
+/* Given a basic map A -> (B -> C), return the corresponding basic map
+ * (A -> B) -> C.
+ */
+__isl_give isl_basic_map *isl_basic_map_uncurry(__isl_take isl_basic_map *bmap)
+{
+
+	if (!bmap)
+		return NULL;
+
+	if (!isl_basic_map_can_uncurry(bmap))
+		isl_die(bmap->ctx, isl_error_invalid,
+			"basic map cannot be uncurried",
+			return isl_basic_map_free(bmap));
+	bmap->dim = isl_space_uncurry(bmap->dim);
+	if (!bmap->dim)
+		return isl_basic_map_free(bmap);
+	return bmap;
+}
+
+/* Given a map A -> (B -> C), return the corresponding map
+ * (A -> B) -> C.
+ */
+__isl_give isl_map *isl_map_uncurry(__isl_take isl_map *map)
+{
+	int i;
+
+	if (!map)
+		return NULL;
+
+	if (!isl_map_can_uncurry(map))
+		isl_die(map->ctx, isl_error_invalid, "map cannot be uncurried",
+			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_uncurry(map->p[i]);
+		if (!map->p[i])
+			return isl_map_free(map);
+	}
+
+	map->dim = isl_space_uncurry(map->dim);
+	if (!map->dim)
+		return isl_map_free(map);
+
+	return map;
+}
+
 /* Construct a basic map mapping the domain of the affine expression
  * to a one-dimensional range prescribed by the affine expression.
  */
@@ -9660,6 +10471,17 @@ error:
 	return NULL;
 }
 
+/* Construct a map mapping the domain of the affine expression
+ * to a one-dimensional range prescribed by the affine expression.
+ */
+__isl_give isl_map *isl_map_from_aff(__isl_take isl_aff *aff)
+{
+	isl_basic_map *bmap;
+
+	bmap = isl_basic_map_from_aff(aff);
+	return isl_map_from_basic_map(bmap);
+}
+
 /* Construct a basic map mapping the domain the multi-affine expression
  * to its range, with each dimension in the range equated to the
  * corresponding affine expression.
@@ -9697,6 +10519,18 @@ __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
 	return bmap;
 }
 
+/* Construct a map mapping the domain the multi-affine expression
+ * to its range, with each dimension in the range equated to the
+ * corresponding affine expression.
+ */
+__isl_give isl_map *isl_map_from_multi_aff(__isl_take isl_multi_aff *maff)
+{
+	isl_basic_map *bmap;
+
+	bmap = isl_basic_map_from_multi_aff(maff);
+	return isl_map_from_basic_map(bmap);
+}
+
 /* Construct a basic map mapping a domain in the given space to
  * to an n-dimensional range, with n the number of elements in the list,
  * where each coordinate in the range is prescribed by the
@@ -9737,11 +10571,78 @@ __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
 	return isl_map_equate(set, type1, pos1, type2, pos2);
 }
 
+/* Construct a basic map where the given dimensions are equal to each other.
+ */
+static __isl_give isl_basic_map *equator(__isl_take isl_space *space,
+	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
+{
+	isl_basic_map *bmap = NULL;
+	int i;
+
+	if (!space)
+		return NULL;
+
+	if (pos1 >= isl_space_dim(space, type1))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"index out of bounds", goto error);
+	if (pos2 >= isl_space_dim(space, type2))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"index out of bounds", goto error);
+
+	if (type1 == type2 && pos1 == pos2)
+		return isl_basic_map_universe(space);
+
+	bmap = isl_basic_map_alloc_space(isl_space_copy(space), 0, 1, 0);
+	i = isl_basic_map_alloc_equality(bmap);
+	if (i < 0)
+		goto error;
+	isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
+	pos1 += isl_basic_map_offset(bmap, type1);
+	pos2 += isl_basic_map_offset(bmap, type2);
+	isl_int_set_si(bmap->eq[i][pos1], -1);
+	isl_int_set_si(bmap->eq[i][pos2], 1);
+	bmap = isl_basic_map_finalize(bmap);
+	isl_space_free(space);
+	return bmap;
+error:
+	isl_space_free(space);
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Add a constraint imposing that the given two dimensions are equal.
+ */
+__isl_give isl_basic_map *isl_basic_map_equate(__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
+{
+	isl_basic_map *eq;
+
+	eq = equator(isl_basic_map_get_space(bmap), type1, pos1, type2, pos2);
+
+	bmap = isl_basic_map_intersect(bmap, eq);
+
+	return bmap;
+}
+
 /* Add a constraint imposing that the given two dimensions are equal.
  */
 __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
 	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
 {
+	isl_basic_map *bmap;
+
+	bmap = equator(isl_map_get_space(map), type1, pos1, type2, pos2);
+
+	map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
+
+	return map;
+}
+
+/* Add a constraint imposing that the given two dimensions have opposite values.
+ */
+__isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
+	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
+{
 	isl_basic_map *bmap = NULL;
 	int i;
 
@@ -9762,7 +10663,7 @@ __isl_give isl_map *isl_map_equate(__isl_take isl_map *map,
 	isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
 	pos1 += isl_basic_map_offset(bmap, type1);
 	pos2 += isl_basic_map_offset(bmap, type2);
-	isl_int_set_si(bmap->eq[i][pos1], -1);
+	isl_int_set_si(bmap->eq[i][pos1], 1);
 	isl_int_set_si(bmap->eq[i][pos2], 1);
 	bmap = isl_basic_map_finalize(bmap);
 
@@ -9775,9 +10676,41 @@ error:
 	return NULL;
 }
 
-/* Add a constraint imposing that the given two dimensions have opposite values.
+/* Add a constraint imposing that the value of the first dimension is
+ * greater than or equal to that of the second.
  */
-__isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
+__isl_give isl_basic_map *isl_basic_map_order_ge(__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
+{
+	isl_constraint *c;
+	isl_local_space *ls;
+
+	if (!bmap)
+		return NULL;
+
+	if (pos1 >= isl_basic_map_dim(bmap, type1))
+		isl_die(bmap->ctx, isl_error_invalid,
+			"index out of bounds", return isl_basic_map_free(bmap));
+	if (pos2 >= isl_basic_map_dim(bmap, type2))
+		isl_die(bmap->ctx, isl_error_invalid,
+			"index out of bounds", return isl_basic_map_free(bmap));
+
+	if (type1 == type2 && pos1 == pos2)
+		return bmap;
+
+	ls = isl_local_space_from_space(isl_basic_map_get_space(bmap));
+	c = isl_inequality_alloc(ls);
+	c = isl_constraint_set_coefficient_si(c, type1, pos1, 1);
+	c = isl_constraint_set_coefficient_si(c, type2, pos2, -1);
+	bmap = isl_basic_map_add_constraint(bmap, c);
+
+	return bmap;
+}
+
+/* Add a constraint imposing that the value of the first dimension is
+ * greater than that of the second.
+ */
+__isl_give isl_map *isl_map_order_gt(__isl_take isl_map *map,
 	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
 {
 	isl_basic_map *bmap = NULL;
@@ -9793,15 +10726,22 @@ __isl_give isl_map *isl_map_oppose(__isl_take isl_map *map,
 		isl_die(map->ctx, isl_error_invalid,
 			"index out of bounds", goto error);
 
-	bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 1, 0);
-	i = isl_basic_map_alloc_equality(bmap);
+	if (type1 == type2 && pos1 == pos2) {
+		isl_space *space = isl_map_get_space(map);
+		isl_map_free(map);
+		return isl_map_empty(space);
+	}
+
+	bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 0, 1);
+	i = isl_basic_map_alloc_inequality(bmap);
 	if (i < 0)
 		goto error;
-	isl_seq_clr(bmap->eq[i], 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->ineq[i], 1 + isl_basic_map_total_dim(bmap));
 	pos1 += isl_basic_map_offset(bmap, type1);
 	pos2 += isl_basic_map_offset(bmap, type2);
-	isl_int_set_si(bmap->eq[i][pos1], 1);
-	isl_int_set_si(bmap->eq[i][pos2], 1);
+	isl_int_set_si(bmap->ineq[i][pos1], 1);
+	isl_int_set_si(bmap->ineq[i][pos2], -1);
+	isl_int_set_si(bmap->ineq[i][0], -1);
 	bmap = isl_basic_map_finalize(bmap);
 
 	map = isl_map_intersect(map, isl_map_from_basic_map(bmap));
@@ -9813,6 +10753,15 @@ error:
 	return NULL;
 }
 
+/* Add a constraint imposing that the value of the first dimension is
+ * smaller than that of the second.
+ */
+__isl_give isl_map *isl_map_order_lt(__isl_take isl_map *map,
+	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2)
+{
+	return isl_map_order_gt(map, type2, pos2, type1, pos1);
+}
+
 __isl_give isl_aff *isl_basic_map_get_div(__isl_keep isl_basic_map *bmap,
 	int pos)
 {
@@ -9860,6 +10809,10 @@ __isl_give isl_aff *isl_basic_set_get_div(__isl_keep isl_basic_set *bset,
  * are replaced by
  *
  *	a f + d g
+ *
+ * We currently require that "subs" is an integral expression.
+ * Handling rational expressions may require us to add stride constraints
+ * as we do in isl_basic_set_preimage_multi_aff.
  */
 __isl_give isl_basic_set *isl_basic_set_substitute(
 	__isl_take isl_basic_set *bset,
@@ -9883,6 +10836,9 @@ __isl_give isl_basic_set *isl_basic_set_substitute(
 	if (isl_local_space_dim(subs->ls, isl_dim_div) != 0)
 		isl_die(ctx, isl_error_unsupported,
 			"cannot handle divs yet", goto error);
+	if (!isl_int_is_one(subs->v->el[0]))
+		isl_die(ctx, isl_error_invalid,
+			"can only substitute integer expressions", goto error);
 
 	pos += isl_basic_set_offset(bset, type);
 
@@ -9942,18 +10898,387 @@ __isl_give isl_set *isl_set_substitute(__isl_take isl_set *set,
 
 	for (i = set->n - 1; i >= 0; --i) {
 		set->p[i] = isl_basic_set_substitute(set->p[i], type, pos, subs);
-		if (!set->p[i])
+		if (remove_if_empty(set, i) < 0)
+			goto error;
+	}
+
+	return set;
+error:
+	isl_set_free(set);
+	return NULL;
+}
+
+/* Check if the range of "ma" is compatible with "space".
+ * Return -1 if anything is wrong.
+ */
+static int check_space_compatible_range_multi_aff(
+	__isl_keep isl_space *space, __isl_keep isl_multi_aff *ma)
+{
+	int m;
+	isl_space *ma_space;
+
+	ma_space = isl_multi_aff_get_space(ma);
+	m = isl_space_is_range_internal(space, ma_space);
+	isl_space_free(ma_space);
+	if (m >= 0 && !m)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"spaces don't match", return -1);
+	return m;
+}
+
+/* Check if the range of "ma" is compatible with "bset".
+ * Return -1 if anything is wrong.
+ */
+static int check_basic_set_compatible_range_multi_aff(
+	__isl_keep isl_basic_set *bset, __isl_keep isl_multi_aff *ma)
+{
+	return check_space_compatible_range_multi_aff(bset->dim, ma);
+}
+
+/* Copy the divs from "ma" to "bset", adding zeros for the coefficients
+ * of the other divs in "bset".
+ */
+static int set_ma_divs(__isl_keep isl_basic_set *bset,
+	__isl_keep isl_multi_aff *ma, int n_div)
+{
+	int i;
+	isl_local_space *ls;
+
+	if (n_div == 0)
+		return 0;
+
+	ls = isl_aff_get_domain_local_space(ma->p[0]);
+	if (!ls)
+		return -1;
+
+	for (i = 0; i < n_div; ++i) {
+		isl_seq_cpy(bset->div[i], ls->div->row[i], ls->div->n_col);
+		isl_seq_clr(bset->div[i] + ls->div->n_col, bset->n_div - n_div);
+		if (isl_basic_set_add_div_constraints(bset, i) < 0)
 			goto error;
-		if (isl_basic_set_plain_is_empty(set->p[i])) {
-			isl_basic_set_free(set->p[i]);
-			if (i != set->n - 1)
-				set->p[i] = set->p[set->n - 1];
-			set->n--;
+	}
+
+	isl_local_space_free(ls);
+	return 0;
+error:
+	isl_local_space_free(ls);
+	return -1;
+}
+
+/* How many stride constraints does "ma" enforce?
+ * That is, how many of the affine expressions have a denominator
+ * different from one?
+ */
+static int multi_aff_strides(__isl_keep isl_multi_aff *ma)
+{
+	int i;
+	int strides = 0;
+
+	for (i = 0; i < ma->n; ++i)
+		if (!isl_int_is_one(ma->p[i]->v->el[0]))
+			strides++;
+
+	return strides;
+}
+
+/* For each affine expression in ma of the form
+ *
+ *	x_i = (f_i y + h_i)/m_i
+ *
+ * with m_i different from one, add a constraint to "bset"
+ * of the form
+ *
+ *	f_i y + h_i = m_i alpha_i
+ *
+ * with alpha_i an additional existentially quantified variable.
+ */
+static __isl_give isl_basic_set *add_ma_strides(
+	__isl_take isl_basic_set *bset, __isl_keep isl_multi_aff *ma)
+{
+	int i, k;
+	int div;
+	int total;
+
+	total = isl_basic_set_total_dim(bset);
+	for (i = 0; i < ma->n; ++i) {
+		int len;
+
+		if (isl_int_is_one(ma->p[i]->v->el[0]))
+			continue;
+		div = isl_basic_set_alloc_div(bset);
+		k = isl_basic_set_alloc_equality(bset);
+		if (div < 0 || k < 0)
+			goto error;
+		isl_int_set_si(bset->div[div][0], 0);
+		len = ma->p[i]->v->size;
+		isl_seq_cpy(bset->eq[k], ma->p[i]->v->el + 1, len - 1);
+		isl_seq_clr(bset->eq[k] + len - 1, 1 + total - (len - 1));
+		isl_int_neg(bset->eq[k][1 + total], ma->p[i]->v->el[0]);
+		total++;
+	}
+
+	return bset;
+error:
+	isl_basic_set_free(bset);
+	return NULL;
+}
+
+/* Compute the preimage of "bset" under the function represented by "ma".
+ * In other words, plug in "ma" in "bset".  The result is a basic set
+ * that lives in the domain space of "ma".
+ *
+ * If bset is represented by
+ *
+ *	A(p) + B x + C(divs) >= 0
+ *
+ * and ma is represented by
+ *
+ *	x = D(p) + F(y) + G(divs')
+ *
+ * then the result is
+ *
+ *	A(p) + B D(p) + B F(y) + B G(divs') + C(divs) >= 0
+ *
+ * The divs in the input set are similarly adjusted.
+ * In particular
+ *
+ *	floor((a_i(p) + b_i x + c_i(divs))/n_i)
+ *
+ * becomes
+ *
+ *	floor((a_i(p) + b_i D(p) + b_i F(y) + B_i G(divs') + c_i(divs))/n_i)
+ *
+ * If bset is not a rational set and if F(y) involves any denominators
+ *
+ *	x_i = (f_i y + h_i)/m_i
+ *
+ * the additional constraints are added to ensure that we only
+ * map back integer points.  That is we enforce
+ *
+ *	f_i y + h_i = m_i alpha_i
+ *
+ * with alpha_i an additional existentially quantified variable.
+ *
+ * We first copy over the divs from "ma".
+ * Then we add the modified constraints and divs from "bset".
+ * Finally, we add the stride constraints, if needed.
+ */
+__isl_give isl_basic_set *isl_basic_set_preimage_multi_aff(
+	__isl_take isl_basic_set *bset, __isl_take isl_multi_aff *ma)
+{
+	int i, k;
+	isl_space *space;
+	isl_basic_set *res = NULL;
+	int n_div_bset, n_div_ma;
+	isl_int f, c1, c2, g;
+	int rational, strides;
+
+	isl_int_init(f);
+	isl_int_init(c1);
+	isl_int_init(c2);
+	isl_int_init(g);
+
+	ma = isl_multi_aff_align_divs(ma);
+	if (!bset || !ma)
+		goto error;
+	if (check_basic_set_compatible_range_multi_aff(bset, ma) < 0)
+		goto error;
+
+	n_div_bset = isl_basic_set_dim(bset, isl_dim_div);
+	n_div_ma = ma->n ? isl_aff_dim(ma->p[0], isl_dim_div) : 0;
+
+	space = isl_space_domain(isl_multi_aff_get_space(ma));
+	rational = isl_basic_set_is_rational(bset);
+	strides = rational ? 0 : multi_aff_strides(ma);
+	res = isl_basic_set_alloc_space(space, n_div_ma + n_div_bset + strides,
+			    bset->n_eq + strides, bset->n_ineq + 2 * n_div_ma);
+	if (rational)
+		res = isl_basic_set_set_rational(res);
+
+	for (i = 0; i < n_div_ma + n_div_bset; ++i)
+		if (isl_basic_set_alloc_div(res) < 0)
+			goto error;
+
+	if (set_ma_divs(res, ma, n_div_ma) < 0)
+		goto error;
+
+	for (i = 0; i < bset->n_eq; ++i) {
+		k = isl_basic_set_alloc_equality(res);
+		if (k < 0)
+			goto error;
+		isl_seq_preimage(res->eq[k], bset->eq[i], ma, n_div_ma,
+					n_div_bset, f, c1, c2, g, 0);
+	}
+
+	for (i = 0; i < bset->n_ineq; ++i) {
+		k = isl_basic_set_alloc_inequality(res);
+		if (k < 0)
+			goto error;
+		isl_seq_preimage(res->ineq[k], bset->ineq[i], ma, n_div_ma,
+					n_div_bset, f, c1, c2, g, 0);
+	}
+
+	for (i = 0; i < bset->n_div; ++i) {
+		if (isl_int_is_zero(bset->div[i][0])) {
+			isl_int_set_si(res->div[n_div_ma + i][0], 0);
+			continue;
 		}
+		isl_seq_preimage(res->div[n_div_ma + i], bset->div[i],
+				    ma, n_div_ma, n_div_bset, f, c1, c2, g, 1);
 	}
 
+	if (strides)
+		res = add_ma_strides(res, ma);
+
+	isl_int_clear(f);
+	isl_int_clear(c1);
+	isl_int_clear(c2);
+	isl_int_clear(g);
+	isl_basic_set_free(bset);
+	isl_multi_aff_free(ma);
+	res = isl_basic_set_simplify(res);
+	return isl_basic_set_finalize(res);
+error:
+	isl_int_clear(f);
+	isl_int_clear(c1);
+	isl_int_clear(c2);
+	isl_int_clear(g);
+	isl_basic_set_free(bset);
+	isl_multi_aff_free(ma);
+	isl_basic_set_free(res);
+	return NULL;
+}
+
+/* Check if the range of "ma" is compatible with "set".
+ * Return -1 if anything is wrong.
+ */
+static int check_set_compatible_range_multi_aff(
+	__isl_keep isl_set *set, __isl_keep isl_multi_aff *ma)
+{
+	return check_space_compatible_range_multi_aff(set->dim, ma);
+}
+
+/* Compute the preimage of "set" under the function represented by "ma".
+ * In other words, plug in "ma" in "set.  The result is a set
+ * that lives in the domain space of "ma".
+ */
+static __isl_give isl_set *set_preimage_multi_aff(__isl_take isl_set *set,
+	__isl_take isl_multi_aff *ma)
+{
+	int i;
+
+	set = isl_set_cow(set);
+	ma = isl_multi_aff_align_divs(ma);
+	if (!set || !ma)
+		goto error;
+	if (check_set_compatible_range_multi_aff(set, ma) < 0)
+		goto error;
+
+	for (i = 0; i < set->n; ++i) {
+		set->p[i] = isl_basic_set_preimage_multi_aff(set->p[i],
+							isl_multi_aff_copy(ma));
+		if (!set->p[i])
+			goto error;
+	}
+
+	isl_space_free(set->dim);
+	set->dim = isl_multi_aff_get_domain_space(ma);
+	if (!set->dim)
+		goto error;
+
+	isl_multi_aff_free(ma);
+	if (set->n > 1)
+		ISL_F_CLR(set, ISL_MAP_DISJOINT);
+	ISL_F_CLR(set, ISL_SET_NORMALIZED);
 	return set;
 error:
+	isl_multi_aff_free(ma);
+	isl_set_free(set);
+	return NULL;
+}
+
+__isl_give isl_set *isl_set_preimage_multi_aff(__isl_take isl_set *set,
+	__isl_take isl_multi_aff *ma)
+{
+	if (!set || !ma)
+		goto error;
+
+	if (isl_space_match(set->dim, isl_dim_param, ma->space, isl_dim_param))
+		return set_preimage_multi_aff(set, ma);
+
+	if (!isl_space_has_named_params(set->dim) ||
+	    !isl_space_has_named_params(ma->space))
+		isl_die(set->ctx, isl_error_invalid,
+			"unaligned unnamed parameters", goto error);
+	set = isl_set_align_params(set, isl_multi_aff_get_space(ma));
+	ma = isl_multi_aff_align_params(ma, isl_set_get_space(set));
+
+	return set_preimage_multi_aff(set, ma);
+error:
+	isl_multi_aff_free(ma);
+	return isl_set_free(set);
+}
+
+/* Compute the preimage of "set" under the function represented by "pma".
+ * In other words, plug in "pma" in "set.  The result is a set
+ * that lives in the domain space of "pma".
+ */
+static __isl_give isl_set *set_preimage_pw_multi_aff(__isl_take isl_set *set,
+	__isl_take isl_pw_multi_aff *pma)
+{
+	int i;
+	isl_set *res;
+
+	if (!pma)
+		goto error;
+
+	if (pma->n == 0) {
+		isl_pw_multi_aff_free(pma);
+		res = isl_set_empty(isl_set_get_space(set));
+		isl_set_free(set);
+		return res;
+	}
+
+	res = isl_set_preimage_multi_aff(isl_set_copy(set),
+					isl_multi_aff_copy(pma->p[0].maff));
+	res = isl_set_intersect(res, isl_set_copy(pma->p[0].set));
+
+	for (i = 1; i < pma->n; ++i) {
+		isl_set *res_i;
+
+		res_i = isl_set_preimage_multi_aff(isl_set_copy(set),
+					isl_multi_aff_copy(pma->p[i].maff));
+		res_i = isl_set_intersect(res_i, isl_set_copy(pma->p[i].set));
+		res = isl_set_union(res, res_i);
+	}
+
+	isl_pw_multi_aff_free(pma);
+	isl_set_free(set);
+	return res;
+error:
+	isl_pw_multi_aff_free(pma);
 	isl_set_free(set);
 	return NULL;
 }
+
+__isl_give isl_set *isl_set_preimage_pw_multi_aff(__isl_take isl_set *set,
+	__isl_take isl_pw_multi_aff *pma)
+{
+	if (!set || !pma)
+		goto error;
+
+	if (isl_space_match(set->dim, isl_dim_param, pma->dim, isl_dim_param))
+		return set_preimage_pw_multi_aff(set, pma);
+
+	if (!isl_space_has_named_params(set->dim) ||
+	    !isl_space_has_named_params(pma->dim))
+		isl_die(set->ctx, isl_error_invalid,
+			"unaligned unnamed parameters", goto error);
+	set = isl_set_align_params(set, isl_pw_multi_aff_get_space(pma));
+	pma = isl_pw_multi_aff_align_params(pma, isl_set_get_space(set));
+
+	return set_preimage_pw_multi_aff(set, pma);
+error:
+	isl_pw_multi_aff_free(pma);
+	return isl_set_free(set);
+}