/* Use the n equalities of bset to unimodularly transform the * variables x such that n transformed variables x1' have a constant value * and rewrite the constraints of bset in terms of the remaining * transformed variables x2'. The matrix pointed to by T maps * the new variables x2' back to the original variables x, while T2 * maps the original variables to the new variables. */ static struct isl_basic_set *compress_variables( struct isl_basic_set *bset, struct isl_mat **T, struct isl_mat **T2) { struct isl_mat *B, *TC; unsigned dim; if (T) *T = NULL; if (T2) *T2 = NULL; if (!bset) goto error; isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error); isl_assert(bset->ctx, bset->n_div == 0, goto error); dim = isl_basic_set_n_dim(bset); isl_assert(bset->ctx, bset->n_eq <= dim, goto error); if (bset->n_eq == 0) return bset; B = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, bset->n_eq, 0, 1 + dim); TC = isl_mat_variable_compression(B, T2); if (!TC) goto error; if (TC->n_col == 0) { isl_mat_free(TC); if (T2) { isl_mat_free(*T2); *T2 = NULL; } return isl_basic_set_set_to_empty(bset); } bset = isl_basic_set_preimage(bset, T ? isl_mat_copy(TC) : TC); if (T) *T = TC; return bset; error: isl_basic_set_free(bset); return NULL; }
/* Check if dimension dim belongs to a residue class * i_dim \equiv r mod m * with m != 1 and if so return m in *modulo and r in *residue. * As a special case, when i_dim has a fixed value v, then * *modulo is set to 0 and *residue to v. * * If i_dim does not belong to such a residue class, then *modulo * is set to 1 and *residue is set to 0. */ int isl_basic_set_dim_residue_class(struct isl_basic_set *bset, int pos, isl_int *modulo, isl_int *residue) { struct isl_ctx *ctx; struct isl_mat *H = NULL, *U = NULL, *C, *H1, *U1; unsigned total; unsigned nparam; if (!bset || !modulo || !residue) return -1; if (isl_basic_set_plain_dim_is_fixed(bset, pos, residue)) { isl_int_set_si(*modulo, 0); return 0; } ctx = isl_basic_set_get_ctx(bset); total = isl_basic_set_total_dim(bset); nparam = isl_basic_set_n_param(bset); H = isl_mat_sub_alloc6(ctx, bset->eq, 0, bset->n_eq, 1, total); H = isl_mat_left_hermite(H, 0, &U, NULL); if (!H) return -1; isl_seq_gcd(U->row[nparam + pos]+bset->n_eq, total-bset->n_eq, modulo); if (isl_int_is_zero(*modulo)) isl_int_set_si(*modulo, 1); if (isl_int_is_one(*modulo)) { isl_int_set_si(*residue, 0); isl_mat_free(H); isl_mat_free(U); return 0; } C = isl_mat_alloc(ctx, 1 + bset->n_eq, 1); if (!C) goto error; isl_int_set_si(C->row[0][0], 1); isl_mat_sub_neg(ctx, C->row + 1, bset->eq, bset->n_eq, 0, 0, 1); H1 = isl_mat_sub_alloc(H, 0, H->n_row, 0, H->n_row); H1 = isl_mat_lin_to_aff(H1); C = isl_mat_inverse_product(H1, C); isl_mat_free(H); U1 = isl_mat_sub_alloc(U, nparam+pos, 1, 0, bset->n_eq); U1 = isl_mat_lin_to_aff(U1); isl_mat_free(U); C = isl_mat_product(U1, C); if (!C) return -1; if (!isl_int_is_divisible_by(C->row[1][0], C->row[0][0])) { bset = isl_basic_set_copy(bset); bset = isl_basic_set_set_to_empty(bset); isl_basic_set_free(bset); isl_int_set_si(*modulo, 1); isl_int_set_si(*residue, 0); return 0; } isl_int_divexact(*residue, C->row[1][0], C->row[0][0]); isl_int_fdiv_r(*residue, *residue, *modulo); isl_mat_free(C); return 0; error: isl_mat_free(H); isl_mat_free(U); return -1; }
/* Look for all equalities satisfied by the integer points in bset, * which is assumed to be bounded. * * The equalities are obtained by successively looking for * a point that is affinely independent of the points found so far. * In particular, for each equality satisfied by the points so far, * we check if there is any point on a hyperplane parallel to the * corresponding hyperplane shifted by at least one (in either direction). */ static struct isl_basic_set *uset_affine_hull_bounded(struct isl_basic_set *bset) { struct isl_vec *sample = NULL; struct isl_basic_set *hull; struct isl_tab *tab = NULL; unsigned dim; if (isl_basic_set_plain_is_empty(bset)) return bset; dim = isl_basic_set_n_dim(bset); if (bset->sample && bset->sample->size == 1 + dim) { int contains = isl_basic_set_contains(bset, bset->sample); if (contains < 0) goto error; if (contains) { if (dim == 0) return bset; sample = isl_vec_copy(bset->sample); } else { isl_vec_free(bset->sample); bset->sample = NULL; } } tab = isl_tab_from_basic_set(bset); if (!tab) goto error; if (tab->empty) { isl_tab_free(tab); isl_vec_free(sample); return isl_basic_set_set_to_empty(bset); } if (isl_tab_track_bset(tab, isl_basic_set_copy(bset)) < 0) goto error; if (!sample) { struct isl_tab_undo *snap; snap = isl_tab_snap(tab); sample = isl_tab_sample(tab); if (isl_tab_rollback(tab, snap) < 0) goto error; isl_vec_free(tab->bmap->sample); tab->bmap->sample = isl_vec_copy(sample); } if (!sample) goto error; if (sample->size == 0) { isl_tab_free(tab); isl_vec_free(sample); return isl_basic_set_set_to_empty(bset); } hull = isl_basic_set_from_vec(sample); isl_basic_set_free(bset); hull = extend_affine_hull(tab, hull); isl_tab_free(tab); return hull; error: isl_vec_free(sample); isl_tab_free(tab); isl_basic_set_free(bset); return NULL; }