X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=isl_constraint.c;h=1b12a1960a564a211391146ee564d1714821d118;hb=19596bc4e5cd282b2e75d17077b1aaaeacbfd6f9;hp=c3c3526bdd0ab6e254af1bff75eeb400b12e7b85;hpb=14102905bbd16f8e0a8342a4dd6e1433a7abacaf;p=platform%2Fupstream%2Fisl.git

diff --git a/isl_constraint.c b/isl_constraint.c
index c3c3526..1b12a19 100644
--- a/isl_constraint.c
+++ b/isl_constraint.c
@@ -2,7 +2,7 @@
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2010      INRIA Saclay
  *
- * 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
@@ -12,38 +12,43 @@
 
 #include <isl_map_private.h>
 #include <isl_constraint_private.h>
-#include <isl_dim_private.h>
-#include <isl_div_private.h>
+#include <isl_space_private.h>
 #include <isl/seq.h>
 #include <isl_aff_private.h>
 #include <isl_local_space_private.h>
+#include <isl_val_private.h>
+
+#undef BASE
+#define BASE constraint
+
+#include <isl_list_templ.c>
 
 isl_ctx *isl_constraint_get_ctx(__isl_keep isl_constraint *c)
 {
-	return c ? isl_aff_get_ctx(c->aff) : NULL;
+	return c ? isl_local_space_get_ctx(c->ls) : NULL;
 }
 
 static unsigned n(struct isl_constraint *c, enum isl_dim_type type)
 {
-	return isl_aff_dim(c->aff, type);
+	return isl_local_space_dim(c->ls, type);
 }
 
 static unsigned offset(struct isl_constraint *c, enum isl_dim_type type)
 {
-	return isl_local_space_offset(c->aff->ls, type);
+	return isl_local_space_offset(c->ls, type);
 }
 
 static unsigned basic_map_offset(__isl_keep isl_basic_map *bmap,
 							enum isl_dim_type type)
 {
-	return type == isl_dim_div ? 1 + isl_dim_total(bmap->dim)
-				   : 1 + isl_dim_offset(bmap->dim, type);
+	return type == isl_dim_div ? 1 + isl_space_dim(bmap->dim, isl_dim_all)
+				   : 1 + isl_space_offset(bmap->dim, type);
 }
 
 static unsigned basic_set_offset(struct isl_basic_set *bset,
 							enum isl_dim_type type)
 {
-	struct isl_dim *dim = bset->dim;
+	isl_space *dim = bset->dim;
 	switch (type) {
 	case isl_dim_param:	return 1;
 	case isl_dim_in:	return 1 + dim->nparam;
@@ -53,33 +58,52 @@ static unsigned basic_set_offset(struct isl_basic_set *bset,
 	}
 }
 
-__isl_give isl_constraint *isl_constraint_alloc(int eq, __isl_take isl_aff *aff)
+__isl_give isl_constraint *isl_constraint_alloc_vec(int eq,
+	__isl_take isl_local_space *ls, __isl_take isl_vec *v)
 {
 	isl_constraint *constraint;
 
-	if (!aff)
-		return NULL;
+	if (!ls || !v)
+		goto error;
 
-	constraint = isl_alloc_type(isl_aff_get_ctx(aff), isl_constraint);
+	constraint = isl_alloc_type(isl_vec_get_ctx(v), isl_constraint);
 	if (!constraint)
 		goto error;
 
 	constraint->ref = 1;
 	constraint->eq = eq;
-	constraint->aff = aff;
+	constraint->ls = ls;
+	constraint->v = v;
 
 	return constraint;
 error:
-	isl_aff_free(aff);
+	isl_local_space_free(ls);
+	isl_vec_free(v);
 	return NULL;
 }
 
+__isl_give isl_constraint *isl_constraint_alloc(int eq,
+	__isl_take isl_local_space *ls)
+{
+	isl_ctx *ctx;
+	isl_vec *v;
+
+	if (!ls)
+		return NULL;
+
+	ctx = isl_local_space_get_ctx(ls);
+	v = isl_vec_alloc(ctx, 1 + isl_local_space_dim(ls, isl_dim_all));
+	v = isl_vec_clr(v);
+	return isl_constraint_alloc_vec(eq, ls, v);
+}
+
 struct isl_constraint *isl_basic_map_constraint(struct isl_basic_map *bmap,
 	isl_int **line)
 {
 	int eq;
-	isl_aff *aff;
-	isl_local_space *ls;
+	isl_ctx *ctx;
+	isl_vec *v;
+	isl_local_space *ls = NULL;
 	isl_constraint *constraint;
 
 	if (!bmap || !line)
@@ -87,17 +111,18 @@ struct isl_constraint *isl_basic_map_constraint(struct isl_basic_map *bmap,
 
 	eq = line >= bmap->eq;
 
+	ctx = isl_basic_map_get_ctx(bmap);
 	ls = isl_basic_map_get_local_space(bmap);
-	aff = isl_aff_alloc(ls);
-	if (!aff)
+	v = isl_vec_alloc(ctx, 1 + isl_local_space_dim(ls, isl_dim_all));
+	if (!v)
 		goto error;
-	isl_int_set_si(aff->v->el[0], 1);
-	isl_seq_cpy(aff->v->el + 1, line[0], aff->v->size - 1);
-	constraint = isl_constraint_alloc(eq, aff);
+	isl_seq_cpy(v->el, line[0], v->size);
+	constraint = isl_constraint_alloc_vec(eq, ls, v);
 
 	isl_basic_map_free(bmap);
 	return constraint;
 error:
+	isl_local_space_free(ls);
 	isl_basic_map_free(bmap);
 	return NULL;
 }
@@ -108,36 +133,14 @@ struct isl_constraint *isl_basic_set_constraint(struct isl_basic_set *bset,
 	return isl_basic_map_constraint((struct isl_basic_map *)bset, line);
 }
 
-struct isl_constraint *isl_equality_alloc(struct isl_dim *dim)
+__isl_give isl_constraint *isl_equality_alloc(__isl_take isl_local_space *ls)
 {
-	struct isl_basic_map *bmap;
-
-	if (!dim)
-		return NULL;
-
-	bmap = isl_basic_map_alloc_dim(dim, 0, 1, 0);
-	if (!bmap)
-		return NULL;
-
-	isl_basic_map_alloc_equality(bmap);
-	isl_seq_clr(bmap->eq[0], 1 + isl_basic_map_total_dim(bmap));
-	return isl_basic_map_constraint(bmap, &bmap->eq[0]);
+	return isl_constraint_alloc(1, ls);
 }
 
-struct isl_constraint *isl_inequality_alloc(struct isl_dim *dim)
+__isl_give isl_constraint *isl_inequality_alloc(__isl_take isl_local_space *ls)
 {
-	struct isl_basic_map *bmap;
-
-	if (!dim)
-		return NULL;
-
-	bmap = isl_basic_map_alloc_dim(dim, 0, 0, 1);
-	if (!bmap)
-		return NULL;
-
-	isl_basic_map_alloc_inequality(bmap);
-	isl_seq_clr(bmap->ineq[0], 1 + isl_basic_map_total_dim(bmap));
-	return isl_basic_map_constraint(bmap, &bmap->ineq[0]);
+	return isl_constraint_alloc(0, ls);
 }
 
 struct isl_constraint *isl_constraint_dup(struct isl_constraint *c)
@@ -145,7 +148,8 @@ struct isl_constraint *isl_constraint_dup(struct isl_constraint *c)
 	if (!c)
 		return NULL;
 
-	return isl_constraint_alloc(c->eq, isl_aff_copy(c->aff));
+	return isl_constraint_alloc_vec(c->eq, isl_local_space_copy(c->ls),
+						isl_vec_copy(c->v));
 }
 
 struct isl_constraint *isl_constraint_cow(struct isl_constraint *c)
@@ -176,12 +180,25 @@ void *isl_constraint_free(struct isl_constraint *c)
 	if (--c->ref > 0)
 		return NULL;
 
-	isl_aff_free(c->aff);
+	isl_local_space_free(c->ls);
+	isl_vec_free(c->v);
 	free(c);
 
 	return NULL;
 }
 
+/* Return the number of constraints in "bset", i.e., the
+ * number of times isl_basic_set_foreach_constraint will
+ * call the callback.
+ */
+int isl_basic_set_n_constraint(__isl_keep isl_basic_set *bset)
+{
+	if (!bset)
+		return -1;
+
+	return bset->n_eq + bset->n_ineq;
+}
+
 int isl_basic_map_foreach_constraint(__isl_keep isl_basic_map *bmap,
 	int (*fn)(__isl_take isl_constraint *c, void *user), void *user)
 {
@@ -224,27 +241,33 @@ int isl_basic_set_foreach_constraint(__isl_keep isl_basic_set *bset,
 int isl_constraint_is_equal(struct isl_constraint *constraint1,
 	struct isl_constraint *constraint2)
 {
+	int equal;
+
 	if (!constraint1 || !constraint2)
 		return 0;
-	return constraint1->eq == constraint2->eq &&
-		isl_aff_plain_is_equal(constraint1->aff, constraint2->aff);
+	if (constraint1->eq != constraint2->eq)
+		return 0;
+	equal = isl_local_space_is_equal(constraint1->ls, constraint2->ls);
+	if (equal < 0 || !equal)
+		return equal;
+	return isl_vec_is_equal(constraint1->v, constraint2->v);
 }
 
 struct isl_basic_map *isl_basic_map_add_constraint(
 	struct isl_basic_map *bmap, struct isl_constraint *constraint)
 {
 	isl_ctx *ctx;
-	isl_dim *dim;
-	int equal_dim;
+	isl_space *dim;
+	int equal_space;
 
 	if (!bmap || !constraint)
 		goto error;
 
 	ctx = isl_constraint_get_ctx(constraint);
-	dim = isl_constraint_get_dim(constraint);
-	equal_dim = isl_dim_equal(bmap->dim, dim);
-	isl_dim_free(dim);
-	isl_assert(ctx, equal_dim, goto error);
+	dim = isl_constraint_get_space(constraint);
+	equal_space = isl_space_is_equal(bmap->dim, dim);
+	isl_space_free(dim);
+	isl_assert(ctx, equal_space, goto error);
 
 	bmap = isl_basic_map_intersect(bmap,
 				isl_basic_map_from_constraint(constraint));
@@ -280,10 +303,16 @@ __isl_give isl_set *isl_set_add_constraint(__isl_take isl_set *set,
 	return isl_map_add_constraint(set, constraint);
 }
 
-__isl_give isl_dim *isl_constraint_get_dim(
+__isl_give isl_space *isl_constraint_get_space(
+	__isl_keep isl_constraint *constraint)
+{
+	return constraint ? isl_local_space_get_space(constraint->ls) : NULL;
+}
+
+__isl_give isl_local_space *isl_constraint_get_local_space(
 	__isl_keep isl_constraint *constraint)
 {
-	return constraint ? isl_aff_get_dim(constraint->aff) : NULL;
+	return constraint ? isl_local_space_copy(constraint->ls) : NULL;
 }
 
 int isl_constraint_dim(struct isl_constraint *constraint,
@@ -297,24 +326,101 @@ int isl_constraint_dim(struct isl_constraint *constraint,
 int isl_constraint_involves_dims(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
+	int i;
+	isl_ctx *ctx;
+	int *active = NULL;
+	int involves = 0;
+
+	if (!constraint)
+		return -1;
+	if (n == 0)
+		return 0;
+
+	ctx = isl_constraint_get_ctx(constraint);
+	if (first + n > isl_constraint_dim(constraint, type))
+		isl_die(ctx, isl_error_invalid,
+			"range out of bounds", return -1);
+
+	active = isl_local_space_get_active(constraint->ls,
+					    constraint->v->el + 1);
+	if (!active)
+		goto error;
+
+	first += isl_local_space_offset(constraint->ls, type) - 1;
+	for (i = 0; i < n; ++i)
+		if (active[first + i]) {
+			involves = 1;
+			break;
+		}
+
+	free(active);
+
+	return involves;
+error:
+	free(active);
+	return -1;
+}
+
+/* Does the given constraint represent a lower bound on the given
+ * dimension?
+ */
+int isl_constraint_is_lower_bound(__isl_keep isl_constraint *constraint,
+	enum isl_dim_type type, unsigned pos)
+{
 	if (!constraint)
 		return -1;
 
-	return isl_aff_involves_dims(constraint->aff, type, first, n);
+	if (pos >= isl_local_space_dim(constraint->ls, type))
+		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
+			"position out of bounds", return -1);
+
+	pos += isl_local_space_offset(constraint->ls, type);
+	return isl_int_is_pos(constraint->v->el[pos]);
+}
+
+/* Does the given constraint represent an upper bound on the given
+ * dimension?
+ */
+int isl_constraint_is_upper_bound(__isl_keep isl_constraint *constraint,
+	enum isl_dim_type type, unsigned pos)
+{
+	if (!constraint)
+		return -1;
+
+	if (pos >= isl_local_space_dim(constraint->ls, type))
+		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
+			"position out of bounds", return -1);
+
+	pos += isl_local_space_offset(constraint->ls, type);
+	return isl_int_is_neg(constraint->v->el[pos]);
 }
 
 const char *isl_constraint_get_dim_name(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type, unsigned pos)
 {
 	return constraint ?
-	    isl_aff_get_dim_name(constraint->aff, type, pos) : NULL;
+	    isl_local_space_get_dim_name(constraint->ls, type, pos) : NULL;
 }
 
 void isl_constraint_get_constant(struct isl_constraint *constraint, isl_int *v)
 {
 	if (!constraint)
 		return;
-	isl_aff_get_constant(constraint->aff, v);
+	isl_int_set(*v, constraint->v->el[0]);
+}
+
+/* Return the constant term of "constraint".
+ */
+__isl_give isl_val *isl_constraint_get_constant_val(
+	__isl_keep isl_constraint *constraint)
+{
+	isl_ctx *ctx;
+
+	if (!constraint)
+		return NULL;
+
+	ctx = isl_constraint_get_ctx(constraint);
+	return isl_val_int_from_isl_int(ctx, constraint->v->el[0]);
 }
 
 void isl_constraint_get_coefficient(struct isl_constraint *constraint,
@@ -323,15 +429,41 @@ void isl_constraint_get_coefficient(struct isl_constraint *constraint,
 	if (!constraint)
 		return;
 
-	isl_aff_get_coefficient(constraint->aff, type, pos, v);
+	if (pos >= isl_local_space_dim(constraint->ls, type))
+		isl_die(constraint->v->ctx, isl_error_invalid,
+			"position out of bounds", return);
+
+	pos += isl_local_space_offset(constraint->ls, type);
+	isl_int_set(*v, constraint->v->el[pos]);
+}
+
+/* Return the coefficient of the variable of type "type" at position "pos"
+ * of "constraint".
+ */
+__isl_give isl_val *isl_constraint_get_coefficient_val(
+	__isl_keep isl_constraint *constraint, enum isl_dim_type type, int pos)
+{
+	isl_ctx *ctx;
+
+	if (!constraint)
+		return NULL;
+
+	ctx = isl_constraint_get_ctx(constraint);
+	if (pos < 0 || pos >= isl_local_space_dim(constraint->ls, type))
+		isl_die(ctx, isl_error_invalid,
+			"position out of bounds", return NULL);
+
+	pos += isl_local_space_offset(constraint->ls, type);
+	return isl_val_int_from_isl_int(ctx, constraint->v->el[pos]);
 }
 
-struct isl_div *isl_constraint_div(struct isl_constraint *constraint, int pos)
+__isl_give isl_aff *isl_constraint_get_div(__isl_keep isl_constraint *constraint,
+	int pos)
 {
 	if (!constraint)
 		return NULL;
 
-	return isl_aff_get_div(constraint->aff, pos);
+	return isl_local_space_get_div(constraint->ls, pos);
 }
 
 __isl_give isl_constraint *isl_constraint_set_constant(
@@ -340,21 +472,47 @@ __isl_give isl_constraint *isl_constraint_set_constant(
 	constraint = isl_constraint_cow(constraint);
 	if (!constraint)
 		return NULL;
-	constraint->aff = isl_aff_set_constant(constraint->aff, v);
-	if (!constraint->aff)
+
+	constraint->v = isl_vec_cow(constraint->v);
+	if (!constraint->v)
 		return isl_constraint_free(constraint);
+
+	isl_int_set(constraint->v->el[0], v);
 	return constraint;
 }
 
+/* Replace the constant term of "constraint" by "v".
+ */
+__isl_give isl_constraint *isl_constraint_set_constant_val(
+	__isl_take isl_constraint *constraint, __isl_take isl_val *v)
+{
+	constraint = isl_constraint_cow(constraint);
+	if (!constraint || !v)
+		goto error;
+	if (!isl_val_is_int(v))
+		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
+			"expecting integer value", goto error);
+	constraint->v = isl_vec_set_element_val(constraint->v, 0, v);
+	if (!constraint->v)
+		constraint = isl_constraint_free(constraint);
+	return constraint;
+error:
+	isl_val_free(v);
+	return isl_constraint_free(constraint);
+}
+
 __isl_give isl_constraint *isl_constraint_set_constant_si(
 	__isl_take isl_constraint *constraint, int v)
 {
 	constraint = isl_constraint_cow(constraint);
 	if (!constraint)
 		return NULL;
-	constraint->aff = isl_aff_set_constant_si(constraint->aff, v);
-	if (!constraint->aff)
+
+	constraint->v = isl_vec_cow(constraint->v);
+	if (!constraint->v)
 		return isl_constraint_free(constraint);
+
+	isl_int_set_si(constraint->v->el[0], v);
 	return constraint;
 }
 
@@ -365,11 +523,52 @@ __isl_give isl_constraint *isl_constraint_set_coefficient(
 	constraint = isl_constraint_cow(constraint);
 	if (!constraint)
 		return NULL;
-	constraint->aff = isl_aff_set_coefficient(constraint->aff,
-							type, pos, v);
-	if (!constraint->aff)
+
+	if (pos >= isl_local_space_dim(constraint->ls, type))
+		isl_die(constraint->v->ctx, isl_error_invalid,
+			"position out of bounds",
+			return isl_constraint_free(constraint));
+
+	constraint = isl_constraint_cow(constraint);
+	if (!constraint)
+		return NULL;
+
+	constraint->v = isl_vec_cow(constraint->v);
+	if (!constraint->v)
 		return isl_constraint_free(constraint);
+
+	pos += isl_local_space_offset(constraint->ls, type);
+	isl_int_set(constraint->v->el[pos], v);
+
+	return constraint;
+}
+
+/* Replace the coefficient of the variable of type "type" at position "pos"
+ * of "constraint" by "v".
+ */
+__isl_give isl_constraint *isl_constraint_set_coefficient_val(
+	__isl_take isl_constraint *constraint,
+	enum isl_dim_type type, int pos, isl_val *v)
+{
+	constraint = isl_constraint_cow(constraint);
+	if (!constraint || !v)
+		goto error;
+	if (!isl_val_is_int(v))
+		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
+			"expecting integer value", goto error);
+
+	if (pos >= isl_local_space_dim(constraint->ls, type))
+		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
+			"position out of bounds", goto error);
+
+	pos += isl_local_space_offset(constraint->ls, type);
+	constraint->v = isl_vec_set_element_val(constraint->v, pos, v);
+	if (!constraint->v)
+		constraint = isl_constraint_free(constraint);
 	return constraint;
+error:
+	isl_val_free(v);
+	return isl_constraint_free(constraint);
 }
 
 __isl_give isl_constraint *isl_constraint_set_coefficient_si(
@@ -379,10 +578,23 @@ __isl_give isl_constraint *isl_constraint_set_coefficient_si(
 	constraint = isl_constraint_cow(constraint);
 	if (!constraint)
 		return NULL;
-	constraint->aff = isl_aff_set_coefficient_si(constraint->aff,
-							type, pos, v);
-	if (!constraint->aff)
+
+	if (pos >= isl_local_space_dim(constraint->ls, type))
+		isl_die(constraint->v->ctx, isl_error_invalid,
+			"position out of bounds",
+			return isl_constraint_free(constraint));
+
+	constraint = isl_constraint_cow(constraint);
+	if (!constraint)
+		return NULL;
+
+	constraint->v = isl_vec_cow(constraint->v);
+	if (!constraint->v)
 		return isl_constraint_free(constraint);
+
+	pos += isl_local_space_offset(constraint->ls, type);
+	isl_int_set_si(constraint->v->el[pos], v);
+
 	return constraint;
 }
 
@@ -403,17 +615,15 @@ __isl_give isl_basic_set *isl_basic_set_drop_constraint(
 	unsigned n;
 	isl_int **row;
 	unsigned total;
-	isl_local_space *ls1, *ls2;
+	isl_local_space *ls1;
 	int equal;
 
 	if (!bset || !constraint)
 		goto error;
 
 	ls1 = isl_basic_set_get_local_space(bset);
-	ls2 = isl_aff_get_local_space(constraint->aff);
-	equal = isl_local_space_is_equal(ls1, ls2);
+	equal = isl_local_space_is_equal(ls1, constraint->ls);
 	isl_local_space_free(ls1);
-	isl_local_space_free(ls2);
 	if (equal < 0)
 		goto error;
 	if (!equal) {
@@ -429,9 +639,9 @@ __isl_give isl_basic_set *isl_basic_set_drop_constraint(
 		row = bset->ineq;
 	}
 
-	total = isl_aff_dim(constraint->aff, isl_dim_all);
+	total = isl_constraint_dim(constraint, isl_dim_all);
 	for (i = 0; i < n; ++i)
-		if (isl_seq_eq(row[i], constraint->aff->v->el + 1, 1 + total))
+		if (isl_seq_eq(row[i], constraint->v->el, 1 + total))
 			isl_seq_clr(row[i], 1 + total);
 			
 	isl_constraint_free(constraint);
@@ -454,10 +664,11 @@ struct isl_constraint *isl_constraint_negate(struct isl_constraint *constraint)
 	if (isl_constraint_is_equality(constraint))
 		isl_die(ctx, isl_error_invalid, "cannot negate equality",
 			return isl_constraint_free(constraint));
-	constraint->aff = isl_aff_neg(constraint->aff);
-	constraint->aff = isl_aff_add_constant_si(constraint->aff, -1);
-	if (!constraint->aff)
+	constraint->v = isl_vec_neg(constraint->v);
+	constraint->v = isl_vec_cow(constraint->v);
+	if (!constraint->v)
 		return isl_constraint_free(constraint);
+	isl_int_sub_ui(constraint->v->el[0], constraint->v->el[0], 1);
 	return constraint;
 }
 
@@ -477,10 +688,10 @@ int isl_constraint_is_div_constraint(__isl_keep isl_constraint *constraint)
 		return -1;
 	if (isl_constraint_is_equality(constraint))
 		return 0;
-	n_div = isl_aff_dim(constraint->aff, isl_dim_div);
+	n_div = isl_constraint_dim(constraint, isl_dim_div);
 	for (i = 0; i < n_div; ++i) {
-		if (isl_local_space_is_div_constraint(constraint->aff->ls,
-					constraint->aff->v->el + 1, i))
+		if (isl_local_space_is_div_constraint(constraint->ls,
+							constraint->v->el, i))
 			return 1;
 	}
 
@@ -504,7 +715,7 @@ __isl_give isl_basic_map *isl_basic_map_from_constraint(
 	if (!constraint)
 		return NULL;
 
-	ls = isl_aff_get_local_space(constraint->aff);
+	ls = isl_local_space_copy(constraint->ls);
 	bmap = isl_basic_map_from_local_space(ls);
 	bmap = isl_basic_map_extend_constraints(bmap, 1, 1);
 	if (isl_constraint_is_equality(constraint)) {
@@ -520,7 +731,7 @@ __isl_give isl_basic_map *isl_basic_map_from_constraint(
 		c = bmap->ineq[k];
 	}
 	total = isl_basic_map_total_dim(bmap);
-	isl_seq_cpy(c, constraint->aff->v->el + 1, 1 + total);
+	isl_seq_cpy(c, constraint->v->el, 1 + total);
 	isl_constraint_free(constraint);
 	if (bmap)
 		ISL_F_SET(bmap, ISL_BASIC_SET_FINAL);
@@ -981,7 +1192,6 @@ __isl_give isl_aff *isl_constraint_get_bound(
 {
 	isl_aff *aff;
 	isl_ctx *ctx;
-	isl_local_space *ls;
 
 	if (!constraint)
 		return NULL;
@@ -994,24 +1204,21 @@ __isl_give isl_aff *isl_constraint_get_bound(
 			"not a set constraint", return NULL);
 
 	pos += offset(constraint, type);
-	if (isl_int_is_zero(constraint->aff->v->el[1 + pos]))
+	if (isl_int_is_zero(constraint->v->el[pos]))
 		isl_die(ctx, isl_error_invalid,
 			"constraint does not define a bound on given dimension",
 			return NULL);
 
-	ls = isl_aff_get_local_space(constraint->aff);
-	aff = isl_aff_alloc(ls);
+	aff = isl_aff_alloc(isl_local_space_copy(constraint->ls));
 	if (!aff)
 		return NULL;
 
-	if (isl_int_is_neg(constraint->aff->v->el[1 + pos]))
-		isl_seq_cpy(aff->v->el + 1, constraint->aff->v->el + 1,
-			    aff->v->size - 1);
+	if (isl_int_is_neg(constraint->v->el[pos]))
+		isl_seq_cpy(aff->v->el + 1, constraint->v->el, aff->v->size - 1);
 	else
-		isl_seq_neg(aff->v->el + 1, constraint->aff->v->el + 1,
-			    aff->v->size - 1);
+		isl_seq_neg(aff->v->el + 1, constraint->v->el, aff->v->size - 1);
 	isl_int_set_si(aff->v->el[1 + pos], 0);
-	isl_int_abs(aff->v->el[0], constraint->aff->v->el[1 + pos]);
+	isl_int_abs(aff->v->el[0], constraint->v->el[pos]);
 
 	return aff;
 }
@@ -1029,37 +1236,47 @@ __isl_give isl_aff *isl_constraint_get_bound(
 __isl_give isl_aff *isl_constraint_get_aff(
 	__isl_keep isl_constraint *constraint)
 {
+	isl_aff *aff;
+
 	if (!constraint)
 		return NULL;
 
-	return isl_aff_copy(constraint->aff);
+	aff = isl_aff_alloc(isl_local_space_copy(constraint->ls));
+	if (!aff)
+		return NULL;
+
+	isl_seq_cpy(aff->v->el + 1, constraint->v->el, aff->v->size - 1);
+	isl_int_set_si(aff->v->el[0], 1);
+
+	return aff;
 }
 
-/* Construct an equality constraint equating the given affine expression
- * to zero.
+/* Construct an inequality (eq = 0) or equality (eq = 1) constraint from "aff".
+ * In particular, construct aff >= 0 or aff = 0.
+ *
+ * The denominator of "aff" can be ignored.
  */
-__isl_give isl_constraint *isl_equality_from_aff(__isl_take isl_aff *aff)
+static __isl_give isl_constraint *isl_constraint_alloc_aff(int eq,
+	__isl_take isl_aff *aff)
 {
-	int k;
-	isl_basic_set *bset;
+	isl_local_space *ls;
+	isl_vec *v;
 
 	if (!aff)
 		return NULL;
-
-	bset = isl_basic_set_from_local_space(isl_aff_get_local_space(aff));
-	bset = isl_basic_set_extend_constraints(bset, 1, 0);
-	k = isl_basic_set_alloc_equality(bset);
-	if (k < 0)
-		goto error;
-
-	isl_seq_cpy(bset->eq[k], aff->v->el + 1, aff->v->size - 1);
+	ls = isl_aff_get_domain_local_space(aff);
+	v = isl_vec_drop_els(isl_vec_copy(aff->v), 0, 1);
 	isl_aff_free(aff);
 
-	return isl_basic_set_constraint(bset, &bset->eq[k]);
-error:
-	isl_aff_free(aff);
-	isl_basic_set_free(bset);
-	return NULL;
+	return isl_constraint_alloc_vec(eq, ls, v);
+}
+
+/* Construct an equality constraint equating the given affine expression
+ * to zero.
+ */
+__isl_give isl_constraint *isl_equality_from_aff(__isl_take isl_aff *aff)
+{
+	return isl_constraint_alloc_aff(1, aff);
 }
 
 /* Construct an inequality constraint enforcing the given affine expression
@@ -1067,24 +1284,5 @@ error:
  */
 __isl_give isl_constraint *isl_inequality_from_aff(__isl_take isl_aff *aff)
 {
-	int k;
-	isl_basic_set *bset;
-
-	if (!aff)
-		return NULL;
-
-	bset = isl_basic_set_from_local_space(isl_aff_get_local_space(aff));
-	bset = isl_basic_set_extend_constraints(bset, 0, 1);
-	k = isl_basic_set_alloc_inequality(bset);
-	if (k < 0)
-		goto error;
-
-	isl_seq_cpy(bset->ineq[k], aff->v->el + 1, aff->v->size - 1);
-	isl_aff_free(aff);
-
-	return isl_basic_set_constraint(bset, &bset->ineq[k]);
-error:
-	isl_aff_free(aff);
-	isl_basic_set_free(bset);
-	return NULL;
+	return isl_constraint_alloc_aff(0, aff);
 }