/* Extend an initial (under-)approximation of the affine hull of basic * set represented by the tableau "tab" * by looking for points that do not satisfy one of the equalities * in the current approximation and adding them to that approximation * until no such points can be found any more. * * The caller of this function ensures that "tab" is bounded or * that tab->basis and tab->n_unbounded have been set appropriately. */ static struct isl_basic_set *extend_affine_hull(struct isl_tab *tab, struct isl_basic_set *hull) { int i, j; unsigned dim; if (!tab || !hull) goto error; dim = tab->n_var; if (isl_tab_extend_cons(tab, 2 * dim + 1) < 0) goto error; for (i = 0; i < dim; ++i) { struct isl_vec *sample; struct isl_basic_set *point; for (j = 0; j < hull->n_eq; ++j) { sample = outside_point(tab, hull->eq[j], 1); if (!sample) goto error; if (sample->size > 0) break; isl_vec_free(sample); sample = outside_point(tab, hull->eq[j], 0); if (!sample) goto error; if (sample->size > 0) break; isl_vec_free(sample); if (isl_tab_add_eq(tab, hull->eq[j]) < 0) goto error; } if (j == hull->n_eq) break; if (tab->samples) tab = isl_tab_add_sample(tab, isl_vec_copy(sample)); if (!tab) goto error; point = isl_basic_set_from_vec(sample); hull = affine_hull(hull, point); if (!hull) return NULL; } return hull; error: isl_basic_set_free(hull); return NULL; }
/* Add all constraints of bmap to tab. The equalities of bmap * are added as a pair of inequalities. */ static int tab_add_constraints(struct isl_tab *tab, __isl_keep isl_basic_map *bmap, int *div_map) { int i; unsigned dim; unsigned tab_total; unsigned bmap_total; isl_vec *v; if (!tab || !bmap) return -1; tab_total = isl_basic_map_total_dim(tab->bmap); bmap_total = isl_basic_map_total_dim(bmap); dim = isl_space_dim(tab->bmap->dim, isl_dim_all); if (isl_tab_extend_cons(tab, 2 * bmap->n_eq + bmap->n_ineq) < 0) return -1; v = isl_vec_alloc(bmap->ctx, 1 + tab_total); if (!v) return -1; for (i = 0; i < bmap->n_eq; ++i) { expand_constraint(v, dim, bmap->eq[i], div_map, bmap->n_div); if (isl_tab_add_ineq(tab, v->el) < 0) goto error; isl_seq_neg(bmap->eq[i], bmap->eq[i], 1 + bmap_total); expand_constraint(v, dim, bmap->eq[i], div_map, bmap->n_div); if (isl_tab_add_ineq(tab, v->el) < 0) goto error; isl_seq_neg(bmap->eq[i], bmap->eq[i], 1 + bmap_total); if (tab->empty) break; } for (i = 0; i < bmap->n_ineq; ++i) { expand_constraint(v, dim, bmap->ineq[i], div_map, bmap->n_div); if (isl_tab_add_ineq(tab, v->el) < 0) goto error; if (tab->empty) break; } isl_vec_free(v); return 0; error: isl_vec_free(v); return -1; }
/* Find an integer point in the set represented by "tab" * that lies outside of the equality "eq" e(x) = 0. * If "up" is true, look for a point satisfying e(x) - 1 >= 0. * Otherwise, look for a point satisfying -e(x) - 1 >= 0 (i.e., e(x) <= -1). * The point, if found, is returned. * If no point can be found, a zero-length vector is returned. * * Before solving an ILP problem, we first check if simply * adding the normal of the constraint to one of the known * integer points in the basic set represented by "tab" * yields another point inside the basic set. * * The caller of this function ensures that the tableau is bounded or * that tab->basis and tab->n_unbounded have been set appropriately. */ static struct isl_vec *outside_point(struct isl_tab *tab, isl_int *eq, int up) { struct isl_ctx *ctx; struct isl_vec *sample = NULL; struct isl_tab_undo *snap; unsigned dim; if (!tab) return NULL; ctx = tab->mat->ctx; dim = tab->n_var; sample = isl_vec_alloc(ctx, 1 + dim); if (!sample) return NULL; isl_int_set_si(sample->el[0], 1); isl_seq_combine(sample->el + 1, ctx->one, tab->bmap->sample->el + 1, up ? ctx->one : ctx->negone, eq + 1, dim); if (isl_basic_map_contains(tab->bmap, sample)) return sample; isl_vec_free(sample); sample = NULL; snap = isl_tab_snap(tab); if (!up) isl_seq_neg(eq, eq, 1 + dim); isl_int_sub_ui(eq[0], eq[0], 1); if (isl_tab_extend_cons(tab, 1) < 0) goto error; if (isl_tab_add_ineq(tab, eq) < 0) goto error; sample = isl_tab_sample(tab); isl_int_add_ui(eq[0], eq[0], 1); if (!up) isl_seq_neg(eq, eq, 1 + dim); if (sample && isl_tab_rollback(tab, snap) < 0) goto error; return sample; error: isl_vec_free(sample); return NULL; }
/* Look for all integer points in "bset", which is assumed to be bounded, * and call callback->add on each of them. * * We first compute a reduced basis for the set and then scan * the set in the directions of this basis. * We basically perform a depth first search, where in each level i * we compute the range in the i-th basis vector direction, given * fixed values in the directions of the previous basis vector. * We then add an equality to the tableau fixing the value in the * direction of the current basis vector to each value in the range * in turn and then continue to the next level. * * The search is implemented iteratively. "level" identifies the current * basis vector. "init" is true if we want the first value at the current * level and false if we want the next value. * Solutions are added in the leaves of the search tree, i.e., after * we have fixed a value in each direction of the basis. */ int isl_basic_set_scan(struct isl_basic_set *bset, struct isl_scan_callback *callback) { unsigned dim; struct isl_mat *B = NULL; struct isl_tab *tab = NULL; struct isl_vec *min; struct isl_vec *max; struct isl_tab_undo **snap; int level; int init; enum isl_lp_result res; if (!bset) return -1; dim = isl_basic_set_total_dim(bset); if (dim == 0) return scan_0D(bset, callback); min = isl_vec_alloc(bset->ctx, dim); max = isl_vec_alloc(bset->ctx, dim); snap = isl_alloc_array(bset->ctx, struct isl_tab_undo *, dim); if (!min || !max || !snap) goto error; tab = isl_tab_from_basic_set(bset, 0); if (!tab) goto error; if (isl_tab_extend_cons(tab, dim + 1) < 0) goto error; tab->basis = isl_mat_identity(bset->ctx, 1 + dim); if (1) tab = isl_tab_compute_reduced_basis(tab); if (!tab) goto error; B = isl_mat_copy(tab->basis); if (!B) goto error; level = 0; init = 1; while (level >= 0) { int empty = 0; if (init) { res = isl_tab_min(tab, B->row[1 + level], bset->ctx->one, &min->el[level], NULL, 0); if (res == isl_lp_empty) empty = 1; if (res == isl_lp_error || res == isl_lp_unbounded) goto error; isl_seq_neg(B->row[1 + level] + 1, B->row[1 + level] + 1, dim); res = isl_tab_min(tab, B->row[1 + level], bset->ctx->one, &max->el[level], NULL, 0); isl_seq_neg(B->row[1 + level] + 1, B->row[1 + level] + 1, dim); isl_int_neg(max->el[level], max->el[level]); if (res == isl_lp_empty) empty = 1; if (res == isl_lp_error || res == isl_lp_unbounded) goto error; snap[level] = isl_tab_snap(tab); } else isl_int_add_ui(min->el[level], min->el[level], 1); if (empty || isl_int_gt(min->el[level], max->el[level])) { level--; init = 0; if (level >= 0) if (isl_tab_rollback(tab, snap[level]) < 0) goto error; continue; } if (level == dim - 1 && callback->add == increment_counter) { if (increment_range(callback, min->el[level], max->el[level])) goto error; level--; init = 0; if (level >= 0) if (isl_tab_rollback(tab, snap[level]) < 0) goto error; continue; } isl_int_neg(B->row[1 + level][0], min->el[level]); if (isl_tab_add_valid_eq(tab, B->row[1 + level]) < 0) goto error; isl_int_set_si(B->row[1 + level][0], 0); if (level < dim - 1) { ++level; init = 1; continue; } if (add_solution(tab, callback) < 0) goto error; init = 0; if (isl_tab_rollback(tab, snap[level]) < 0) goto error; } isl_tab_free(tab); free(snap); isl_vec_free(min); isl_vec_free(max); isl_basic_set_free(bset); isl_mat_free(B); return 0; error: isl_tab_free(tab); free(snap); isl_vec_free(min); isl_vec_free(max); isl_basic_set_free(bset); isl_mat_free(B); return -1; }