/* Compute the affine hull of "bset", where "cone" is the recession cone * of "bset". * * We first compute a unimodular transformation that puts the unbounded * directions in the last dimensions. In particular, we take a transformation * that maps all equalities to equalities (in HNF) on the first dimensions. * Let x be the original dimensions and y the transformed, with y_1 bounded * and y_2 unbounded. * * [ y_1 ] [ y_1 ] [ Q_1 ] * x = U [ y_2 ] [ y_2 ] = [ Q_2 ] x * * Let's call the input basic set S. We compute S' = preimage(S, U) * and drop the final dimensions including any constraints involving them. * This results in set S''. * Then we compute the affine hull A'' of S''. * Let F y_1 >= g be the constraint system of A''. In the transformed * space the y_2 are unbounded, so we can add them back without any constraints, * resulting in * * [ y_1 ] * [ F 0 ] [ y_2 ] >= g * or * [ Q_1 ] * [ F 0 ] [ Q_2 ] x >= g * or * F Q_1 x >= g * * The affine hull in the original space is then obtained as * A = preimage(A'', Q_1). */ static struct isl_basic_set *affine_hull_with_cone(struct isl_basic_set *bset, struct isl_basic_set *cone) { unsigned total; unsigned cone_dim; struct isl_basic_set *hull; struct isl_mat *M, *U, *Q; if (!bset || !cone) goto error; total = isl_basic_set_total_dim(cone); cone_dim = total - cone->n_eq; M = isl_mat_sub_alloc6(bset->ctx, cone->eq, 0, cone->n_eq, 1, total); M = isl_mat_left_hermite(M, 0, &U, &Q); if (!M) goto error; isl_mat_free(M); U = isl_mat_lin_to_aff(U); bset = isl_basic_set_preimage(bset, isl_mat_copy(U)); bset = isl_basic_set_drop_constraints_involving(bset, total - cone_dim, cone_dim); bset = isl_basic_set_drop_dims(bset, total - cone_dim, cone_dim); Q = isl_mat_lin_to_aff(Q); Q = isl_mat_drop_rows(Q, 1 + total - cone_dim, cone_dim); if (bset && bset->sample && bset->sample->size == 1 + total) bset->sample = isl_mat_vec_product(isl_mat_copy(Q), bset->sample); hull = uset_affine_hull_bounded(bset); if (!hull) isl_mat_free(U); else { struct isl_vec *sample = isl_vec_copy(hull->sample); U = isl_mat_drop_cols(U, 1 + total - cone_dim, cone_dim); if (sample && sample->size > 0) sample = isl_mat_vec_product(U, sample); else isl_mat_free(U); hull = isl_basic_set_preimage(hull, Q); if (hull) { isl_vec_free(hull->sample); hull->sample = sample; } else isl_vec_free(sample); } isl_basic_set_free(cone); return hull; error: isl_basic_set_free(bset); isl_basic_set_free(cone); return NULL; }
/* Given a set of equalities * * B(y) + A x = 0 (*) * * compute and return an affine transformation T, * * y = T y' * * that bijectively maps the integer vectors y' to integer * vectors y that satisfy the modulo constraints for some value of x. * * Let [H 0] be the Hermite Normal Form of A, i.e., * * A = [H 0] Q * * Then y is a solution of (*) iff * * H^-1 B(y) (= - [I 0] Q x) * * is an integer vector. Let d be the common denominator of H^-1. * We impose * * d H^-1 B(y) = 0 mod d * * and compute the solution using isl_mat_parameter_compression. */ __isl_give isl_mat *isl_mat_parameter_compression_ext(__isl_take isl_mat *B, __isl_take isl_mat *A) { isl_ctx *ctx; isl_vec *d; int n_row, n_col; if (!A) return isl_mat_free(B); ctx = isl_mat_get_ctx(A); n_row = A->n_row; n_col = A->n_col; A = isl_mat_left_hermite(A, 0, NULL, NULL); A = isl_mat_drop_cols(A, n_row, n_col - n_row); A = isl_mat_lin_to_aff(A); A = isl_mat_right_inverse(A); d = isl_vec_alloc(ctx, n_row); if (A) d = isl_vec_set(d, A->row[0][0]); A = isl_mat_drop_rows(A, 0, 1); A = isl_mat_drop_cols(A, 0, 1); B = isl_mat_product(A, B); return isl_mat_parameter_compression(B, d); }
/* Construct a parameter compression for "bset". * We basically just call isl_mat_parameter_compression with the right input * and then extend the resulting matrix to include the variables. * * Let the equalities be given as * * B(p) + A x = 0 * * and let [H 0] be the Hermite Normal Form of A, then * * H^-1 B(p) * * needs to be integer, so we impose that each row is divisible by * the denominator. */ __isl_give isl_morph *isl_basic_set_parameter_compression( __isl_keep isl_basic_set *bset) { unsigned nparam; unsigned nvar; int n_eq; isl_mat *H, *B; isl_vec *d; isl_mat *map, *inv; isl_basic_set *dom, *ran; if (!bset) return NULL; if (isl_basic_set_plain_is_empty(bset)) return isl_morph_empty(bset); if (bset->n_eq == 0) return isl_morph_identity(bset); isl_assert(bset->ctx, bset->n_div == 0, return NULL); n_eq = bset->n_eq; nparam = isl_basic_set_dim(bset, isl_dim_param); nvar = isl_basic_set_dim(bset, isl_dim_set); isl_assert(bset->ctx, n_eq <= nvar, return NULL); d = isl_vec_alloc(bset->ctx, n_eq); B = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, n_eq, 0, 1 + nparam); H = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, n_eq, 1 + nparam, nvar); H = isl_mat_left_hermite(H, 0, NULL, NULL); H = isl_mat_drop_cols(H, n_eq, nvar - n_eq); H = isl_mat_lin_to_aff(H); H = isl_mat_right_inverse(H); if (!H || !d) goto error; isl_seq_set(d->el, H->row[0][0], d->size); H = isl_mat_drop_rows(H, 0, 1); H = isl_mat_drop_cols(H, 0, 1); B = isl_mat_product(H, B); inv = isl_mat_parameter_compression(B, d); inv = isl_mat_diagonal(inv, isl_mat_identity(bset->ctx, nvar)); map = isl_mat_right_inverse(isl_mat_copy(inv)); dom = isl_basic_set_universe(isl_space_copy(bset->dim)); ran = isl_basic_set_universe(isl_space_copy(bset->dim)); return isl_morph_alloc(dom, ran, map, inv); error: isl_mat_free(H); isl_mat_free(B); isl_vec_free(d); return NULL; }
/* Compute a common lattice of solutions to the linear modulo * constraints specified by B and d. * See also the documentation of isl_mat_parameter_compression. * We put the matrix * * A = [ L_1^{-T} L_2^{-T} ... L_k^{-T} ] * * on a common denominator. This denominator D is the lcm of modulos d. * Since L_i = U_i^{-1} diag(d_i, 1, ... 1), we have * L_i^{-T} = U_i^T diag(d_i, 1, ... 1)^{-T} = U_i^T diag(1/d_i, 1, ..., 1). * Putting this on the common denominator, we have * D * L_i^{-T} = U_i^T diag(D/d_i, D, ..., D). */ static struct isl_mat *parameter_compression_multi( struct isl_mat *B, struct isl_vec *d) { int i, j, k; isl_int D; struct isl_mat *A = NULL, *U = NULL; struct isl_mat *T; unsigned size; isl_int_init(D); isl_vec_lcm(d, &D); size = B->n_col - 1; A = isl_mat_alloc(B->ctx, size, B->n_row * size); U = isl_mat_alloc(B->ctx, size, size); if (!U || !A) goto error; for (i = 0; i < B->n_row; ++i) { isl_seq_cpy(U->row[0], B->row[i] + 1, size); U = isl_mat_unimodular_complete(U, 1); if (!U) goto error; isl_int_divexact(D, D, d->block.data[i]); for (k = 0; k < U->n_col; ++k) isl_int_mul(A->row[k][i*size+0], D, U->row[0][k]); isl_int_mul(D, D, d->block.data[i]); for (j = 1; j < U->n_row; ++j) for (k = 0; k < U->n_col; ++k) isl_int_mul(A->row[k][i*size+j], D, U->row[j][k]); } A = isl_mat_left_hermite(A, 0, NULL, NULL); T = isl_mat_sub_alloc(A, 0, A->n_row, 0, A->n_row); T = isl_mat_lin_to_aff(T); if (!T) goto error; isl_int_set(T->row[0][0], D); T = isl_mat_right_inverse(T); if (!T) goto error; isl_assert(T->ctx, isl_int_is_one(T->row[0][0]), goto error); T = isl_mat_transpose(T); isl_mat_free(A); isl_mat_free(U); isl_int_clear(D); return T; error: isl_mat_free(A); isl_mat_free(U); isl_int_clear(D); return NULL; }
/* Given a set of modulo constraints * * c + A y = 0 mod d * * this function computes a particular solution y_0 * * The input is given as a matrix B = [ c A ] and a vector d. * * The output is matrix containing the solution y_0 or * a zero-column matrix if the constraints admit no integer solution. * * The given set of constrains is equivalent to * * c + A y = -D x * * with D = diag d and x a fresh set of variables. * Reducing both c and A modulo d does not change the * value of y in the solution and may lead to smaller coefficients. * Let M = [ D A ] and [ H 0 ] = M U, the Hermite normal form of M. * Then * [ x ] * M [ y ] = - c * and so * [ x ] * [ H 0 ] U^{-1} [ y ] = - c * Let * [ A ] [ x ] * [ B ] = U^{-1} [ y ] * then * H A + 0 B = -c * * so B may be chosen arbitrarily, e.g., B = 0, and then * * [ x ] = [ -c ] * U^{-1} [ y ] = [ 0 ] * or * [ x ] [ -c ] * [ y ] = U [ 0 ] * specifically, * * y = U_{2,1} (-c) * * If any of the coordinates of this y are non-integer * then the constraints admit no integer solution and * a zero-column matrix is returned. */ static struct isl_mat *particular_solution(struct isl_mat *B, struct isl_vec *d) { int i, j; struct isl_mat *M = NULL; struct isl_mat *C = NULL; struct isl_mat *U = NULL; struct isl_mat *H = NULL; struct isl_mat *cst = NULL; struct isl_mat *T = NULL; M = isl_mat_alloc(B->ctx, B->n_row, B->n_row + B->n_col - 1); C = isl_mat_alloc(B->ctx, 1 + B->n_row, 1); if (!M || !C) goto error; isl_int_set_si(C->row[0][0], 1); for (i = 0; i < B->n_row; ++i) { isl_seq_clr(M->row[i], B->n_row); isl_int_set(M->row[i][i], d->block.data[i]); isl_int_neg(C->row[1 + i][0], B->row[i][0]); isl_int_fdiv_r(C->row[1+i][0], C->row[1+i][0], M->row[i][i]); for (j = 0; j < B->n_col - 1; ++j) isl_int_fdiv_r(M->row[i][B->n_row + j], B->row[i][1 + j], M->row[i][i]); } M = isl_mat_left_hermite(M, 0, &U, NULL); if (!M || !U) goto error; H = isl_mat_sub_alloc(M, 0, B->n_row, 0, B->n_row); H = isl_mat_lin_to_aff(H); C = isl_mat_inverse_product(H, C); if (!C) goto error; for (i = 0; i < B->n_row; ++i) { if (!isl_int_is_divisible_by(C->row[1+i][0], C->row[0][0])) break; isl_int_divexact(C->row[1+i][0], C->row[1+i][0], C->row[0][0]); } if (i < B->n_row) cst = isl_mat_alloc(B->ctx, B->n_row, 0); else cst = isl_mat_sub_alloc(C, 1, B->n_row, 0, 1); T = isl_mat_sub_alloc(U, B->n_row, B->n_col - 1, 0, B->n_row); cst = isl_mat_product(T, cst); isl_mat_free(M); isl_mat_free(C); isl_mat_free(U); return cst; error: isl_mat_free(M); isl_mat_free(C); isl_mat_free(U); return NULL; }
/* Compute and return the matrix * * U_1^{-1} diag(d_1, 1, ..., 1) * * with U_1 the unimodular completion of the first (and only) row of B. * The columns of this matrix generate the lattice that satisfies * the single (linear) modulo constraint. */ static struct isl_mat *parameter_compression_1( struct isl_mat *B, struct isl_vec *d) { struct isl_mat *U; U = isl_mat_alloc(B->ctx, B->n_col - 1, B->n_col - 1); if (!U) return NULL; isl_seq_cpy(U->row[0], B->row[0] + 1, B->n_col - 1); U = isl_mat_unimodular_complete(U, 1); U = isl_mat_right_inverse(U); if (!U) return NULL; isl_mat_col_mul(U, 0, d->block.data[0], 0); U = isl_mat_lin_to_aff(U); return U; }
/* Given a basic set, exploit the equalties in the a basic set to construct * a morphishm that maps the basic set to a lower-dimensional space. * Specifically, the morphism reduces the number of dimensions of type "type". * * This function is a slight generalization of isl_mat_variable_compression * in that it allows the input to be parametric and that it allows for the * compression of either parameters or set variables. * * We first select the equalities of interest, that is those that involve * variables of type "type" and no later variables. * Denote those equalities as * * -C(p) + M x = 0 * * where C(p) depends on the parameters if type == isl_dim_set and * is a constant if type == isl_dim_param. * * First compute the (left) Hermite normal form of M, * * M [U1 U2] = M U = H = [H1 0] * or * M = H Q = [H1 0] [Q1] * [Q2] * * with U, Q unimodular, Q = U^{-1} (and H lower triangular). * Define the transformed variables as * * x = [U1 U2] [ x1' ] = [U1 U2] [Q1] x * [ x2' ] [Q2] * * The equalities then become * * -C(p) + H1 x1' = 0 or x1' = H1^{-1} C(p) = C'(p) * * If the denominator of the constant term does not divide the * the common denominator of the parametric terms, then every * integer point is mapped to a non-integer point and then the original set has no * integer solutions (since the x' are a unimodular transformation * of the x). In this case, an empty morphism is returned. * Otherwise, the transformation is given by * * x = U1 H1^{-1} C(p) + U2 x2' * * The inverse transformation is simply * * x2' = Q2 x * * Both matrices are extended to map the full original space to the full * compressed space. */ __isl_give isl_morph *isl_basic_set_variable_compression( __isl_keep isl_basic_set *bset, enum isl_dim_type type) { unsigned otype; unsigned ntype; unsigned orest; unsigned nrest; int f_eq, n_eq; isl_space *dim; isl_mat *H, *U, *Q, *C = NULL, *H1, *U1, *U2; isl_basic_set *dom, *ran; if (!bset) return NULL; if (isl_basic_set_plain_is_empty(bset)) return isl_morph_empty(bset); isl_assert(bset->ctx, bset->n_div == 0, return NULL); otype = 1 + isl_space_offset(bset->dim, type); ntype = isl_basic_set_dim(bset, type); orest = otype + ntype; nrest = isl_basic_set_total_dim(bset) - (orest - 1); for (f_eq = 0; f_eq < bset->n_eq; ++f_eq) if (isl_seq_first_non_zero(bset->eq[f_eq] + orest, nrest) == -1) break; for (n_eq = 0; f_eq + n_eq < bset->n_eq; ++n_eq) if (isl_seq_first_non_zero(bset->eq[f_eq + n_eq] + otype, ntype) == -1) break; if (n_eq == 0) return isl_morph_identity(bset); H = isl_mat_sub_alloc6(bset->ctx, bset->eq, f_eq, n_eq, otype, ntype); H = isl_mat_left_hermite(H, 0, &U, &Q); if (!H || !U || !Q) goto error; Q = isl_mat_drop_rows(Q, 0, n_eq); Q = isl_mat_diagonal(isl_mat_identity(bset->ctx, otype), Q); Q = isl_mat_diagonal(Q, isl_mat_identity(bset->ctx, nrest)); C = isl_mat_alloc(bset->ctx, 1 + n_eq, otype); if (!C) goto error; isl_int_set_si(C->row[0][0], 1); isl_seq_clr(C->row[0] + 1, otype - 1); isl_mat_sub_neg(C->ctx, C->row + 1, bset->eq + f_eq, n_eq, 0, 0, otype); 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); if (!C) goto error; isl_mat_free(H); if (!isl_int_is_one(C->row[0][0])) { int i; isl_int g; isl_int_init(g); for (i = 0; i < n_eq; ++i) { isl_seq_gcd(C->row[1 + i] + 1, otype - 1, &g); isl_int_gcd(g, g, C->row[0][0]); if (!isl_int_is_divisible_by(C->row[1 + i][0], g)) break; } isl_int_clear(g); if (i < n_eq) { isl_mat_free(C); isl_mat_free(U); isl_mat_free(Q); return isl_morph_empty(bset); } C = isl_mat_normalize(C); } U1 = isl_mat_sub_alloc(U, 0, U->n_row, 0, n_eq); U1 = isl_mat_lin_to_aff(U1); U2 = isl_mat_sub_alloc(U, 0, U->n_row, n_eq, U->n_row - n_eq); U2 = isl_mat_lin_to_aff(U2); isl_mat_free(U); C = isl_mat_product(U1, C); C = isl_mat_aff_direct_sum(C, U2); C = insert_parameter_rows(C, otype - 1); C = isl_mat_diagonal(C, isl_mat_identity(bset->ctx, nrest)); dim = isl_space_copy(bset->dim); dim = isl_space_drop_dims(dim, type, 0, ntype); dim = isl_space_add_dims(dim, type, ntype - n_eq); ran = isl_basic_set_universe(dim); dom = copy_equalities(bset, f_eq, n_eq); return isl_morph_alloc(dom, ran, Q, C); error: isl_mat_free(C); isl_mat_free(H); isl_mat_free(U); isl_mat_free(Q); 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; }
/* Given a set of equalities * * M x - c = 0 * * this function computes a unimodular transformation from a lower-dimensional * space to the original space that bijectively maps the integer points x' * in the lower-dimensional space to the integer points x in the original * space that satisfy the equalities. * * The input is given as a matrix B = [ -c M ] and the output is a * matrix that maps [1 x'] to [1 x]. * If T2 is not NULL, then *T2 is set to a matrix mapping [1 x] to [1 x']. * * First compute the (left) Hermite normal form of M, * * M [U1 U2] = M U = H = [H1 0] * or * M = H Q = [H1 0] [Q1] * [Q2] * * with U, Q unimodular, Q = U^{-1} (and H lower triangular). * Define the transformed variables as * * x = [U1 U2] [ x1' ] = [U1 U2] [Q1] x * [ x2' ] [Q2] * * The equalities then become * * H1 x1' - c = 0 or x1' = H1^{-1} c = c' * * If any of the c' is non-integer, then the original set has no * integer solutions (since the x' are a unimodular transformation * of the x) and a zero-column matrix is returned. * Otherwise, the transformation is given by * * x = U1 H1^{-1} c + U2 x2' * * The inverse transformation is simply * * x2' = Q2 x */ __isl_give isl_mat *isl_mat_variable_compression(__isl_take isl_mat *B, __isl_give isl_mat **T2) { int i; struct isl_mat *H = NULL, *C = NULL, *H1, *U = NULL, *U1, *U2, *TC; unsigned dim; if (T2) *T2 = NULL; if (!B) goto error; dim = B->n_col - 1; H = isl_mat_sub_alloc(B, 0, B->n_row, 1, dim); H = isl_mat_left_hermite(H, 0, &U, T2); if (!H || !U || (T2 && !*T2)) goto error; if (T2) { *T2 = isl_mat_drop_rows(*T2, 0, B->n_row); *T2 = isl_mat_lin_to_aff(*T2); if (!*T2) goto error; } C = isl_mat_alloc(B->ctx, 1+B->n_row, 1); if (!C) goto error; isl_int_set_si(C->row[0][0], 1); isl_mat_sub_neg(C->ctx, C->row+1, B->row, B->n_row, 0, 0, 1); H1 = isl_mat_sub_alloc(H, 0, H->n_row, 0, H->n_row); H1 = isl_mat_lin_to_aff(H1); TC = isl_mat_inverse_product(H1, C); if (!TC) goto error; isl_mat_free(H); if (!isl_int_is_one(TC->row[0][0])) { for (i = 0; i < B->n_row; ++i) { if (!isl_int_is_divisible_by(TC->row[1+i][0], TC->row[0][0])) { struct isl_ctx *ctx = B->ctx; isl_mat_free(B); isl_mat_free(TC); isl_mat_free(U); if (T2) { isl_mat_free(*T2); *T2 = NULL; } return isl_mat_alloc(ctx, 1 + dim, 0); } isl_seq_scale_down(TC->row[1+i], TC->row[1+i], TC->row[0][0], 1); } isl_int_set_si(TC->row[0][0], 1); } U1 = isl_mat_sub_alloc(U, 0, U->n_row, 0, B->n_row); U1 = isl_mat_lin_to_aff(U1); U2 = isl_mat_sub_alloc(U, 0, U->n_row, B->n_row, U->n_row - B->n_row); U2 = isl_mat_lin_to_aff(U2); isl_mat_free(U); TC = isl_mat_product(U1, TC); TC = isl_mat_aff_direct_sum(TC, U2); isl_mat_free(B); return TC; error: isl_mat_free(B); isl_mat_free(H); isl_mat_free(U); if (T2) { isl_mat_free(*T2); *T2 = NULL; } return NULL; }