From 61eefa8fe09982393c83beb48b487509c4135b13 Mon Sep 17 00:00:00 2001 From: Sven Verdoolaege Date: Thu, 16 Jul 2009 19:16:06 +0200 Subject: [PATCH] isl_mat: keep track of isl_ctx --- basis_reduction_templ.c | 4 +- isl_affine_hull.c | 4 +- isl_convex_hull.c | 127 +++++++++++------------- isl_equalities.c | 210 ++++++++++++++++++++-------------------- isl_equalities.h | 4 +- isl_map_piplib.c | 28 +++--- isl_map_simplify.c | 32 +++---- isl_mat.c | 250 +++++++++++++++++++++++------------------------- isl_mat.h | 57 +++++------ isl_sample.c | 86 ++++++++--------- isl_tab.c | 10 +- 11 files changed, 388 insertions(+), 424 deletions(-) diff --git a/basis_reduction_templ.c b/basis_reduction_templ.c index 8aeb6c46..ecb191fc 100644 --- a/basis_reduction_templ.c +++ b/basis_reduction_templ.c @@ -162,7 +162,7 @@ struct isl_mat *isl_basic_set_reduced_basis(struct isl_basic_set *bset) GBR_set_ui(mu_F[1], 3); GBR_mul(mu_F[1], mu_F[1], F_old); if (GBR_lt(mu_F[0], mu_F[1])) { - basis = isl_mat_swap_rows(bset->ctx, basis, i, i + 1); + basis = isl_mat_swap_rows(basis, i, i + 1); if (i > 0) { use_saved = 1; GBR_set(F_saved, F_new); @@ -182,7 +182,7 @@ struct isl_mat *isl_basic_set_reduced_basis(struct isl_basic_set *bset) if (0) { error: - isl_mat_free(bset->ctx, basis); + isl_mat_free(basis); basis = NULL; } diff --git a/isl_affine_hull.c b/isl_affine_hull.c index 4b354b93..956ba169 100644 --- a/isl_affine_hull.c +++ b/isl_affine_hull.c @@ -459,9 +459,7 @@ static struct isl_basic_set *equalities_in_underlying_set( struct isl_mat *T2 = NULL; struct isl_basic_set *bset = NULL; struct isl_basic_set *hull = NULL; - struct isl_ctx *ctx; - ctx = bmap->ctx; bset = isl_basic_map_underlying_set(bmap); bset = isl_basic_set_remove_equalities(bset, NULL, &T2); if (!bset) @@ -473,7 +471,7 @@ static struct isl_basic_set *equalities_in_underlying_set( return hull; error: - isl_mat_free(ctx, T2); + isl_mat_free(T2); isl_basic_set_free(bset); isl_basic_set_free(hull); return NULL; diff --git a/isl_convex_hull.c b/isl_convex_hull.c index caa1c0b2..8e594da1 100644 --- a/isl_convex_hull.c +++ b/isl_convex_hull.c @@ -112,8 +112,7 @@ struct isl_basic_set *isl_basic_set_convex_hull(struct isl_basic_set *bset) * constraint c and if so, set the constant term such that the * resulting constraint is a bounding constraint for the set. */ -static int uset_is_bound(struct isl_ctx *ctx, struct isl_set *set, - isl_int *c, unsigned len) +static int uset_is_bound(struct isl_set *set, isl_int *c, unsigned len) { int first; int j; @@ -130,7 +129,7 @@ static int uset_is_bound(struct isl_ctx *ctx, struct isl_set *set, continue; res = isl_solve_lp((struct isl_basic_map*)set->p[j], - 0, c, ctx->one, &opt, &opt_denom); + 0, c, set->ctx->one, &opt, &opt_denom); if (res == isl_lp_unbounded) break; if (res == isl_lp_error) @@ -163,8 +162,7 @@ error: * hyperplane (but not necessarily a facet). * Assumes set "set" is bounded. */ -static int is_independent_bound(struct isl_ctx *ctx, - struct isl_set *set, isl_int *c, +static int is_independent_bound(struct isl_set *set, isl_int *c, struct isl_mat *dirs, int n) { int is_bound; @@ -190,7 +188,7 @@ static int is_independent_bound(struct isl_ctx *ctx, } } - is_bound = uset_is_bound(ctx, set, dirs->row[n], dirs->n_col); + is_bound = uset_is_bound(set, dirs->row[n], dirs->n_col); if (is_bound != 1) return is_bound; if (i < n) { @@ -207,14 +205,13 @@ static int is_independent_bound(struct isl_ctx *ctx, * on the set "set", based on the constraints of the basic sets * in "set". */ -static struct isl_mat *independent_bounds(struct isl_ctx *ctx, - struct isl_set *set) +static struct isl_mat *independent_bounds(struct isl_set *set) { int i, j, n; struct isl_mat *dirs = NULL; unsigned dim = isl_set_n_dim(set); - dirs = isl_mat_alloc(ctx, dim, 1+dim); + dirs = isl_mat_alloc(set->ctx, dim, 1+dim); if (!dirs) goto error; @@ -224,16 +221,14 @@ static struct isl_mat *independent_bounds(struct isl_ctx *ctx, struct isl_basic_set *bset = set->p[i]; for (j = 0; n < dim && j < bset->n_eq; ++j) { - f = is_independent_bound(ctx, set, bset->eq[j], - dirs, n); + f = is_independent_bound(set, bset->eq[j], dirs, n); if (f < 0) goto error; if (f) ++n; } for (j = 0; n < dim && j < bset->n_ineq; ++j) { - f = is_independent_bound(ctx, set, bset->ineq[j], - dirs, n); + f = is_independent_bound(set, bset->ineq[j], dirs, n); if (f < 0) goto error; if (f) @@ -243,7 +238,7 @@ static struct isl_mat *independent_bounds(struct isl_ctx *ctx, dirs->n_row = n; return dirs; error: - isl_mat_free(ctx, dirs); + isl_mat_free(dirs); return NULL; } @@ -283,7 +278,7 @@ error: return NULL; } -static struct isl_basic_set *isl_basic_set_add_equality(struct isl_ctx *ctx, +static struct isl_basic_set *isl_basic_set_add_equality( struct isl_basic_set *bset, isl_int *c) { int i; @@ -308,8 +303,7 @@ error: return NULL; } -static struct isl_set *isl_set_add_equality(struct isl_ctx *ctx, - struct isl_set *set, isl_int *c) +static struct isl_set *isl_set_add_equality(struct isl_set *set, isl_int *c) { int i; @@ -317,7 +311,7 @@ static struct isl_set *isl_set_add_equality(struct isl_ctx *ctx, if (!set) return NULL; for (i = 0; i < set->n; ++i) { - set->p[i] = isl_basic_set_add_equality(ctx, set->p[i], c); + set->p[i] = isl_basic_set_add_equality(set->p[i], c); if (!set->p[i]) goto error; } @@ -471,7 +465,7 @@ static isl_int *wrap_facet(struct isl_set *set, isl_int *facet, isl_int *ridge) isl_seq_clr(T->row[0]+1, dim - 1); isl_seq_cpy(T->row[1], facet, dim); isl_seq_cpy(T->row[2], ridge, dim); - T = isl_mat_right_inverse(set->ctx, T); + T = isl_mat_right_inverse(T); set = isl_set_preimage(set, T); T = NULL; if (!set) @@ -503,7 +497,7 @@ static isl_int *wrap_facet(struct isl_set *set, isl_int *facet, isl_int *ridge) return facet; error: isl_basic_set_free(lp); - isl_mat_free(set->ctx, T); + isl_mat_free(T); isl_set_free(set); return NULL; } @@ -520,8 +514,8 @@ error: * The resulting linear combination of the bounding constraints will * correspond to a facet of the convex hull. */ -static struct isl_mat *initial_facet_constraint(struct isl_ctx *ctx, - struct isl_set *set, struct isl_mat *bounds) +static struct isl_mat *initial_facet_constraint(struct isl_set *set, + struct isl_mat *bounds) { struct isl_set *slice = NULL; struct isl_basic_set *face = NULL; @@ -534,7 +528,7 @@ static struct isl_mat *initial_facet_constraint(struct isl_ctx *ctx, while (bounds->n_row > 1) { slice = isl_set_copy(set); - slice = isl_set_add_equality(ctx, slice, bounds->row[0]); + slice = isl_set_add_equality(slice, bounds->row[0]); face = isl_set_affine_hull(slice); if (!face) goto error; @@ -542,23 +536,21 @@ static struct isl_mat *initial_facet_constraint(struct isl_ctx *ctx, isl_basic_set_free(face); break; } - m = isl_mat_alloc(ctx, 1 + face->n_eq, 1 + dim); + m = isl_mat_alloc(set->ctx, 1 + face->n_eq, 1 + dim); if (!m) goto error; isl_int_set_si(m->row[0][0], 1); isl_seq_clr(m->row[0]+1, dim); for (i = 0; i < face->n_eq; ++i) isl_seq_cpy(m->row[1 + i], face->eq[i], 1 + dim); - U = isl_mat_right_inverse(ctx, m); - Q = isl_mat_right_inverse(ctx, isl_mat_copy(ctx, U)); - U = isl_mat_drop_cols(ctx, U, 1 + face->n_eq, - dim - face->n_eq); - Q = isl_mat_drop_rows(ctx, Q, 1 + face->n_eq, - dim - face->n_eq); - U = isl_mat_drop_cols(ctx, U, 0, 1); - Q = isl_mat_drop_rows(ctx, Q, 0, 1); - bounds = isl_mat_product(ctx, bounds, U); - bounds = isl_mat_product(ctx, bounds, Q); + U = isl_mat_right_inverse(m); + Q = isl_mat_right_inverse(isl_mat_copy(U)); + U = isl_mat_drop_cols(U, 1 + face->n_eq, dim - face->n_eq); + Q = isl_mat_drop_rows(Q, 1 + face->n_eq, dim - face->n_eq); + U = isl_mat_drop_cols(U, 0, 1); + Q = isl_mat_drop_rows(Q, 0, 1); + bounds = isl_mat_product(bounds, U); + bounds = isl_mat_product(bounds, Q); while (isl_seq_first_non_zero(bounds->row[bounds->n_row-1], bounds->n_col) == -1) { bounds->n_row--; @@ -573,7 +565,7 @@ static struct isl_mat *initial_facet_constraint(struct isl_ctx *ctx, return bounds; error: isl_basic_set_free(face); - isl_mat_free(ctx, bounds); + isl_mat_free(bounds); return NULL; } @@ -632,10 +624,10 @@ static struct isl_basic_set *compute_facet(struct isl_set *set, isl_int *c) isl_int_set_si(m->row[0][0], 1); isl_seq_clr(m->row[0]+1, dim); isl_seq_cpy(m->row[1], c, 1+dim); - U = isl_mat_right_inverse(set->ctx, m); - Q = isl_mat_right_inverse(set->ctx, isl_mat_copy(set->ctx, U)); - U = isl_mat_drop_cols(set->ctx, U, 1, 1); - Q = isl_mat_drop_rows(set->ctx, Q, 1, 1); + U = isl_mat_right_inverse(m); + Q = isl_mat_right_inverse(isl_mat_copy(U)); + U = isl_mat_drop_cols(U, 1, 1); + Q = isl_mat_drop_rows(Q, 1, 1); set = isl_set_preimage(set, U); facet = uset_convex_hull_wrap_bounded(set); facet = isl_basic_set_preimage(facet, Q); @@ -684,11 +676,11 @@ static struct isl_basic_set *extend(struct isl_basic_set *hull, for (i = 0; i < hull->n_ineq; ++i) { facet = compute_facet(set, hull->ineq[i]); - facet = isl_basic_set_add_equality(facet->ctx, facet, hull->ineq[i]); + facet = isl_basic_set_add_equality(facet, hull->ineq[i]); facet = isl_basic_set_gauss(facet, NULL); facet = isl_basic_set_normalize_constraints(facet); hull_facet = isl_basic_set_copy(hull); - hull_facet = isl_basic_set_add_equality(hull_facet->ctx, hull_facet, hull->ineq[i]); + hull_facet = isl_basic_set_add_equality(hull_facet, hull->ineq[i]); hull_facet = isl_basic_set_gauss(hull_facet, NULL); hull_facet = isl_basic_set_normalize_constraints(hull_facet); if (!facet) @@ -727,8 +719,7 @@ error: * We simply collect the lower and upper bounds of each basic set * and the biggest of those. */ -static struct isl_basic_set *convex_hull_1d(struct isl_ctx *ctx, - struct isl_set *set) +static struct isl_basic_set *convex_hull_1d(struct isl_set *set) { struct isl_mat *c = NULL; isl_int *lower = NULL; @@ -745,13 +736,13 @@ static struct isl_basic_set *convex_hull_1d(struct isl_ctx *ctx, set = isl_set_remove_empty_parts(set); if (!set) goto error; - isl_assert(ctx, set->n > 0, goto error); - c = isl_mat_alloc(ctx, 2, 2); + isl_assert(set->ctx, set->n > 0, goto error); + c = isl_mat_alloc(set->ctx, 2, 2); if (!c) goto error; if (set->p[0]->n_eq > 0) { - isl_assert(ctx, set->p[0]->n_eq == 1, goto error); + isl_assert(set->ctx, set->p[0]->n_eq == 1, goto error); lower = c->row[0]; upper = c->row[1]; if (isl_int_is_pos(set->p[0]->eq[0][1])) { @@ -826,7 +817,7 @@ static struct isl_basic_set *convex_hull_1d(struct isl_ctx *ctx, isl_int_clear(a); isl_int_clear(b); - hull = isl_basic_set_alloc(ctx, 0, 1, 0, 0, 2); + hull = isl_basic_set_alloc(set->ctx, 0, 1, 0, 0, 2); hull = isl_basic_set_set_rational(hull); if (!hull) goto error; @@ -840,11 +831,11 @@ static struct isl_basic_set *convex_hull_1d(struct isl_ctx *ctx, } hull = isl_basic_set_finalize(hull); isl_set_free(set); - isl_mat_free(ctx, c); + isl_mat_free(c); return hull; error: isl_set_free(set); - isl_mat_free(ctx, c); + isl_mat_free(c); return NULL; } @@ -1062,16 +1053,16 @@ static struct isl_basic_set *modulo_lineality(struct isl_set *set, goto error; lin_dim = total - lin->n_eq; M = isl_mat_sub_alloc(set->ctx, lin->eq, 0, lin->n_eq, 1, total); - M = isl_mat_left_hermite(set->ctx, M, 0, &U, &Q); + M = isl_mat_left_hermite(M, 0, &U, &Q); if (!M) goto error; - isl_mat_free(set->ctx, M); + isl_mat_free(M); isl_basic_set_free(lin); - Q = isl_mat_drop_rows(set->ctx, Q, Q->n_row - lin_dim, lin_dim); + Q = isl_mat_drop_rows(Q, Q->n_row - lin_dim, lin_dim); - U = isl_mat_lin_to_aff(set->ctx, U); - Q = isl_mat_lin_to_aff(set->ctx, Q); + U = isl_mat_lin_to_aff(U); + Q = isl_mat_lin_to_aff(Q); set = isl_set_preimage(set, U); set = isl_set_remove_dims(set, total - lin_dim, lin_dim); @@ -1241,12 +1232,10 @@ error: static struct isl_basic_set *homogeneous_map(struct isl_basic_set *bset, struct isl_mat *T) { - struct isl_ctx *ctx = NULL; int k; if (!bset) goto error; - ctx = bset->ctx; bset = isl_basic_set_extend_constraints(bset, 0, 1); k = isl_basic_set_alloc_inequality(bset); if (k < 0) @@ -1256,7 +1245,7 @@ static struct isl_basic_set *homogeneous_map(struct isl_basic_set *bset, bset = isl_basic_set_preimage(bset, T); return bset; error: - isl_mat_free(ctx, T); + isl_mat_free(T); isl_basic_set_free(bset); return NULL; } @@ -1341,10 +1330,10 @@ static struct isl_basic_set *convex_hull_pair_pointed( if (!T) goto error; isl_seq_cpy(T->row[0], dir->block.data, dir->size); - T = isl_mat_unimodular_complete(ctx, T, 1); - T2 = isl_mat_right_inverse(ctx, isl_mat_copy(ctx, T)); + T = isl_mat_unimodular_complete(T, 1); + T2 = isl_mat_right_inverse(isl_mat_copy(T)); - bset1 = homogeneous_map(bset1, isl_mat_copy(ctx, T2)); + bset1 = homogeneous_map(bset1, isl_mat_copy(T2)); bset2 = homogeneous_map(bset2, T2); set = isl_set_alloc_dim(isl_basic_set_get_dim(bset1), 2, 0); set = isl_set_add(set, bset1); @@ -1539,11 +1528,11 @@ static struct isl_basic_set *initial_hull(struct isl_basic_set *hull, if (!hull) goto error; - bounds = independent_bounds(set->ctx, set); + bounds = independent_bounds(set); if (!bounds) goto error; isl_assert(set->ctx, bounds->n_row == isl_set_n_dim(set), goto error); - bounds = initial_facet_constraint(set->ctx, set, bounds); + bounds = initial_facet_constraint(set, bounds); if (!bounds) goto error; k = isl_basic_set_alloc_inequality(hull); @@ -1552,12 +1541,12 @@ static struct isl_basic_set *initial_hull(struct isl_basic_set *hull, dim = isl_set_n_dim(set); isl_assert(set->ctx, 1 + dim == bounds->n_col, goto error); isl_seq_cpy(hull->ineq[k], bounds->row[0], bounds->n_col); - isl_mat_free(set->ctx, bounds); + isl_mat_free(bounds); return hull; error: isl_basic_set_free(hull); - isl_mat_free(set->ctx, bounds); + isl_mat_free(bounds); return NULL; } @@ -1600,7 +1589,7 @@ static void update_constraint(struct isl_ctx *ctx, struct isl_hash_table *table, c->ineq = ineq; return; } - c->c = isl_mat_cow(ctx, c->c); + c->c = isl_mat_cow(c->c); isl_int_set(c->c->row[0][0], con[0]); c->ineq = ineq; } @@ -1740,7 +1729,7 @@ static struct isl_basic_set *common_constraints(struct isl_basic_set *hull, isl_hash_table_clear(table); for (i = 0; i < min_constraints; ++i) - isl_mat_free(hull->ctx, constraints[i].c); + isl_mat_free(constraints[i].c); free(constraints); free(table); return hull; @@ -1749,7 +1738,7 @@ error: free(table); if (constraints) for (i = 0; i < min_constraints; ++i) - isl_mat_free(hull->ctx, constraints[i].c); + isl_mat_free(constraints[i].c); free(constraints); return hull; } @@ -1820,7 +1809,7 @@ static struct isl_basic_set *uset_convex_hull(struct isl_set *set) return convex_hull; } if (isl_set_n_dim(set) == 1) - return convex_hull_1d(set->ctx, set); + return convex_hull_1d(set); if (isl_set_is_bounded(set)) return uset_convex_hull_wrap(set); @@ -1872,7 +1861,7 @@ static struct isl_basic_set *uset_convex_hull_wrap_bounded(struct isl_set *set) return convex_hull; } if (isl_set_n_dim(set) == 1) - return convex_hull_1d(set->ctx, set); + return convex_hull_1d(set); return uset_convex_hull_wrap(set); error: diff --git a/isl_equalities.c b/isl_equalities.c index f13ca6ab..1b517b6b 100644 --- a/isl_equalities.c +++ b/isl_equalities.c @@ -49,8 +49,7 @@ * then the constraints admit no integer solution and * a zero-column matrix is returned. */ -static struct isl_mat *particular_solution(struct isl_ctx *ctx, - struct isl_mat *B, struct isl_vec *d) +static struct isl_mat *particular_solution(struct isl_mat *B, struct isl_vec *d) { int i, j; struct isl_mat *M = NULL; @@ -60,8 +59,8 @@ static struct isl_mat *particular_solution(struct isl_ctx *ctx, struct isl_mat *cst = NULL; struct isl_mat *T = NULL; - M = isl_mat_alloc(ctx, B->n_row, B->n_row + B->n_col - 1); - C = isl_mat_alloc(ctx, 1 + B->n_row, 1); + 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); @@ -74,12 +73,12 @@ static struct isl_mat *particular_solution(struct isl_ctx *ctx, 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(ctx, M, 0, &U, NULL); + M = isl_mat_left_hermite(M, 0, &U, NULL); if (!M || !U) goto error; - H = isl_mat_sub_alloc(ctx, M->row, 0, B->n_row, 0, B->n_row); - H = isl_mat_lin_to_aff(ctx, H); - C = isl_mat_inverse_product(ctx, H, C); + H = isl_mat_sub_alloc(B->ctx, M->row, 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) { @@ -88,19 +87,19 @@ static struct isl_mat *particular_solution(struct isl_ctx *ctx, 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(ctx, B->n_row, 0); + cst = isl_mat_alloc(B->ctx, B->n_row, 0); else - cst = isl_mat_sub_alloc(ctx, C->row, 1, B->n_row, 0, 1); - T = isl_mat_sub_alloc(ctx, U->row, B->n_row, B->n_col - 1, 0, B->n_row); - cst = isl_mat_product(ctx, T, cst); - isl_mat_free(ctx, M); - isl_mat_free(ctx, C); - isl_mat_free(ctx, U); + cst = isl_mat_sub_alloc(C->ctx, C->row, 1, B->n_row, 0, 1); + T = isl_mat_sub_alloc(U->ctx, U->row, 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(ctx, M); - isl_mat_free(ctx, C); - isl_mat_free(ctx, U); + isl_mat_free(M); + isl_mat_free(C); + isl_mat_free(U); return NULL; } @@ -112,24 +111,24 @@ error: * The columns of this matrix generate the lattice that satisfies * the single (linear) modulo constraint. */ -static struct isl_mat *parameter_compression_1(struct isl_ctx *ctx, +static struct isl_mat *parameter_compression_1( struct isl_mat *B, struct isl_vec *d) { struct isl_mat *U; - U = isl_mat_alloc(ctx, B->n_col - 1, B->n_col - 1); + 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(ctx, U, 1); - U = isl_mat_right_inverse(ctx, U); + 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(ctx, U); + U = isl_mat_lin_to_aff(U); return U; error: - isl_mat_free(ctx, U); + isl_mat_free(U); return NULL; } @@ -146,7 +145,7 @@ error: * 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_ctx *ctx, +static struct isl_mat *parameter_compression_multi( struct isl_mat *B, struct isl_vec *d) { int i, j, k; @@ -161,13 +160,13 @@ static struct isl_mat *parameter_compression_multi(struct isl_ctx *ctx, isl_vec_lcm(d, &D); size = B->n_col - 1; - A = isl_mat_alloc(ctx, size, B->n_row * size); - U = isl_mat_alloc(ctx, size, size); + 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(ctx, U, 1); + U = isl_mat_unimodular_complete(U, 1); if (!U) goto error; isl_int_divexact(D, D, d->block.data[i]); @@ -179,21 +178,21 @@ static struct isl_mat *parameter_compression_multi(struct isl_ctx *ctx, isl_int_mul(A->row[k][i*size+j], D, U->row[j][k]); } - A = isl_mat_left_hermite(ctx, A, 0, NULL, NULL); - T = isl_mat_sub_alloc(ctx, A->row, 0, A->n_row, 0, A->n_row); - T = isl_mat_lin_to_aff(ctx, T); + A = isl_mat_left_hermite(A, 0, NULL, NULL); + T = isl_mat_sub_alloc(A->ctx, A->row, 0, A->n_row, 0, A->n_row); + T = isl_mat_lin_to_aff(T); isl_int_set(T->row[0][0], D); - T = isl_mat_right_inverse(ctx, T); + T = isl_mat_right_inverse(T); isl_assert(ctx, isl_int_is_one(T->row[0][0]), goto error); - T = isl_mat_transpose(ctx, T); - isl_mat_free(ctx, A); - isl_mat_free(ctx, U); + T = isl_mat_transpose(T); + isl_mat_free(A); + isl_mat_free(U); isl_int_clear(D); return T; error: - isl_mat_free(ctx, A); - isl_mat_free(ctx, U); + isl_mat_free(A); + isl_mat_free(U); isl_int_clear(D); return NULL; } @@ -292,7 +291,7 @@ error: * as any y = y_0 + G y' with y' integer is a solution to the original * modulo constraints. */ -struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx, +struct isl_mat *isl_mat_parameter_compression( struct isl_mat *B, struct isl_vec *d) { int i; @@ -303,13 +302,13 @@ struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx, if (!B || !d) goto error; isl_assert(ctx, B->n_row == d->size, goto error); - cst = particular_solution(ctx, B, d); + cst = particular_solution(B, d); if (!cst) goto error; if (cst->n_col == 0) { - T = isl_mat_alloc(ctx, B->n_col, 0); - isl_mat_free(ctx, cst); - isl_mat_free(ctx, B); + T = isl_mat_alloc(B->ctx, B->n_col, 0); + isl_mat_free(cst); + isl_mat_free(B); isl_vec_free(d); return T; } @@ -320,7 +319,7 @@ struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx, if (isl_int_is_one(D)) continue; if (isl_int_is_zero(D)) { - B = isl_mat_drop_rows(ctx, B, i, 1); + B = isl_mat_drop_rows(B, i, 1); d = isl_vec_cow(d); if (!B || !d) goto error2; @@ -330,7 +329,7 @@ struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx, i--; continue; } - B = isl_mat_cow(ctx, B); + B = isl_mat_cow(B); if (!B) goto error2; isl_seq_scale_down(B->row[i] + 1, B->row[i] + 1, D, B->n_col-1); @@ -342,24 +341,24 @@ struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx, } isl_int_clear(D); if (B->n_row == 0) - T = isl_mat_identity(ctx, B->n_col); + T = isl_mat_identity(B->ctx, B->n_col); else if (B->n_row == 1) - T = parameter_compression_1(ctx, B, d); + T = parameter_compression_1(B, d); else - T = parameter_compression_multi(ctx, B, d); - T = isl_mat_left_hermite(ctx, T, 0, NULL, NULL); + T = parameter_compression_multi(B, d); + T = isl_mat_left_hermite(T, 0, NULL, NULL); if (!T) goto error; - isl_mat_sub_copy(ctx, T->row + 1, cst->row, cst->n_row, 0, 0, 1); - isl_mat_free(ctx, cst); - isl_mat_free(ctx, B); + isl_mat_sub_copy(T->ctx, T->row + 1, cst->row, cst->n_row, 0, 0, 1); + isl_mat_free(cst); + isl_mat_free(B); isl_vec_free(d); return T; error2: isl_int_clear(D); error: - isl_mat_free(ctx, cst); - isl_mat_free(ctx, B); + isl_mat_free(cst); + isl_mat_free(B); isl_vec_free(d); return NULL; } @@ -405,8 +404,8 @@ error: * * x2' = Q2 x */ -struct isl_mat *isl_mat_variable_compression(struct isl_ctx *ctx, - struct isl_mat *B, struct isl_mat **T2) +struct isl_mat *isl_mat_variable_compression(struct isl_mat *B, + struct isl_mat **T2) { int i; struct isl_mat *H = NULL, *C = NULL, *H1, *U = NULL, *U1, *U2, *TC; @@ -418,35 +417,36 @@ struct isl_mat *isl_mat_variable_compression(struct isl_ctx *ctx, goto error; dim = B->n_col - 1; - H = isl_mat_sub_alloc(ctx, B->row, 0, B->n_row, 1, dim); - H = isl_mat_left_hermite(ctx, H, 0, &U, T2); + H = isl_mat_sub_alloc(B->ctx, B->row, 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(ctx, *T2, 0, B->n_row); - *T2 = isl_mat_lin_to_aff(ctx, *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(ctx, 1+B->n_row, 1); + 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(ctx, C->row+1, B->row, B->n_row, 0, 0, 1); - H1 = isl_mat_sub_alloc(ctx, H->row, 0, H->n_row, 0, H->n_row); - H1 = isl_mat_lin_to_aff(ctx, H1); - TC = isl_mat_inverse_product(ctx, H1, C); + isl_mat_sub_neg(C->ctx, C->row+1, B->row, B->n_row, 0, 0, 1); + H1 = isl_mat_sub_alloc(H->ctx, H->row, 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(ctx, H); + 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])) { - isl_mat_free(ctx, B); - isl_mat_free(ctx, TC); - isl_mat_free(ctx, U); + struct isl_ctx *ctx = B->ctx; + isl_mat_free(B); + isl_mat_free(TC); + isl_mat_free(U); if (T2) { - isl_mat_free(ctx, *T2); + isl_mat_free(*T2); *T2 = NULL; } return isl_mat_alloc(ctx, 1 + dim, 0); @@ -455,24 +455,24 @@ struct isl_mat *isl_mat_variable_compression(struct isl_ctx *ctx, } isl_int_set_si(TC->row[0][0], 1); } - U1 = isl_mat_sub_alloc(ctx, U->row, 0, U->n_row, 0, B->n_row); - U1 = isl_mat_lin_to_aff(ctx, U1); - U2 = isl_mat_sub_alloc(ctx, U->row, 0, U->n_row, + U1 = isl_mat_sub_alloc(U->ctx, U->row, 0, U->n_row, 0, B->n_row); + U1 = isl_mat_lin_to_aff(U1); + U2 = isl_mat_sub_alloc(U->ctx, U->row, 0, U->n_row, B->n_row, U->n_row - B->n_row); - U2 = isl_mat_lin_to_aff(ctx, U2); - isl_mat_free(ctx, U); - TC = isl_mat_product(ctx, U1, TC); - TC = isl_mat_aff_direct_sum(ctx, TC, U2); + 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(ctx, B); + isl_mat_free(B); return TC; error: - isl_mat_free(ctx, B); - isl_mat_free(ctx, H); - isl_mat_free(ctx, U); + isl_mat_free(B); + isl_mat_free(H); + isl_mat_free(U); if (T2) { - isl_mat_free(ctx, *T2); + isl_mat_free(*T2); *T2 = NULL; } return NULL; @@ -485,7 +485,7 @@ error: * 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_ctx *ctx, +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; @@ -504,20 +504,20 @@ static struct isl_basic_set *compress_variables(struct isl_ctx *ctx, if (bset->n_eq == 0) return bset; - B = isl_mat_sub_alloc(ctx, bset->eq, 0, bset->n_eq, 0, 1 + dim); - TC = isl_mat_variable_compression(ctx, B, T2); + B = isl_mat_sub_alloc(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(ctx, TC); + isl_mat_free(TC); if (T2) { - isl_mat_free(ctx, *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(ctx, TC) : TC); + bset = isl_basic_set_preimage(bset, T ? isl_mat_copy(TC) : TC); if (T) *T = TC; return bset; @@ -539,7 +539,7 @@ struct isl_basic_set *isl_basic_set_remove_equalities( bset = isl_basic_set_gauss(bset, NULL); if (ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY)) return bset; - bset = compress_variables(bset->ctx, bset, T, T2); + bset = compress_variables(bset, T, T2); return bset; error: isl_basic_set_free(bset); @@ -565,8 +565,8 @@ int isl_basic_set_dim_residue_class(struct isl_basic_set *bset, ctx = bset->ctx; total = isl_basic_set_total_dim(bset); nparam = isl_basic_set_n_param(bset); - H = isl_mat_sub_alloc(ctx, bset->eq, 0, bset->n_eq, 1, total); - H = isl_mat_left_hermite(ctx, H, 0, &U, NULL); + H = isl_mat_sub_alloc(bset->ctx, bset->eq, 0, bset->n_eq, 1, total); + H = isl_mat_left_hermite(H, 0, &U, NULL); if (!H) return -1; @@ -574,24 +574,24 @@ int isl_basic_set_dim_residue_class(struct isl_basic_set *bset, total-bset->n_eq, modulo); if (isl_int_is_zero(*modulo) || isl_int_is_one(*modulo)) { isl_int_set_si(*residue, 0); - isl_mat_free(ctx, H); - isl_mat_free(ctx, U); + isl_mat_free(H); + isl_mat_free(U); return 0; } - C = isl_mat_alloc(ctx, 1+bset->n_eq, 1); + C = isl_mat_alloc(bset->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(ctx, H->row, 0, H->n_row, 0, H->n_row); - H1 = isl_mat_lin_to_aff(ctx, H1); - C = isl_mat_inverse_product(ctx, H1, C); - isl_mat_free(ctx, H); - U1 = isl_mat_sub_alloc(ctx, U->row, nparam+pos, 1, 0, bset->n_eq); - U1 = isl_mat_lin_to_aff(ctx, U1); - isl_mat_free(ctx, U); - C = isl_mat_product(ctx, U1, C); + isl_mat_sub_neg(C->ctx, C->row+1, bset->eq, bset->n_eq, 0, 0, 1); + H1 = isl_mat_sub_alloc(H->ctx, H->row, 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->ctx, U->row, 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) goto error; if (!isl_int_is_divisible_by(C->row[1][0], C->row[0][0])) { @@ -604,10 +604,10 @@ int isl_basic_set_dim_residue_class(struct isl_basic_set *bset, } isl_int_divexact(*residue, C->row[1][0], C->row[0][0]); isl_int_fdiv_r(*residue, *residue, *modulo); - isl_mat_free(ctx, C); + isl_mat_free(C); return 0; error: - isl_mat_free(ctx, H); - isl_mat_free(ctx, U); + isl_mat_free(H); + isl_mat_free(U); return -1; } diff --git a/isl_equalities.h b/isl_equalities.h index d892e47b..87d4672f 100644 --- a/isl_equalities.h +++ b/isl_equalities.h @@ -8,9 +8,9 @@ extern "C" { #endif -struct isl_mat *isl_mat_variable_compression(struct isl_ctx *ctx, +struct isl_mat *isl_mat_variable_compression( struct isl_mat *B, struct isl_mat **T2); -struct isl_mat *isl_mat_parameter_compression(struct isl_ctx *ctx, +struct isl_mat *isl_mat_parameter_compression( struct isl_mat *B, struct isl_vec *d); struct isl_basic_set *isl_basic_set_remove_equalities( struct isl_basic_set *bset, struct isl_mat **T, struct isl_mat **T2); diff --git a/isl_map_piplib.c b/isl_map_piplib.c index c5bacc15..6fbecb7b 100644 --- a/isl_map_piplib.c +++ b/isl_map_piplib.c @@ -575,15 +575,14 @@ static struct isl_set *isl_set_reset_dim(struct isl_set *set, * * where I is an n x n identity matrix. */ -static struct isl_mat *append_identity(struct isl_ctx *ctx, - struct isl_mat *mat, unsigned size) +static struct isl_mat *append_identity(struct isl_mat *mat, unsigned size) { int i; unsigned n_row, n_col; n_row = mat->n_row; n_col = mat->n_col; - mat = isl_mat_extend(ctx, mat, n_row + size, n_col + size); + mat = isl_mat_extend(mat, n_row + size, n_col + size); if (!mat) return NULL; for (i = 0; i < n_row; ++i) @@ -614,7 +613,7 @@ static struct isl_basic_set *basic_set_parameter_preimage( isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error); - mat = append_identity(bset->ctx, mat, n_out); + mat = append_identity(mat, n_out); if (!mat) goto error; @@ -627,7 +626,7 @@ static struct isl_basic_set *basic_set_parameter_preimage( } return bset; error: - isl_mat_free(bset ? bset->ctx : NULL, mat); + isl_mat_free(mat); isl_basic_set_free(bset); return NULL; } @@ -653,7 +652,7 @@ static struct isl_set *set_parameter_preimage( isl_assert(set->ctx, mat->n_row == 1 + nparam, goto error); - mat = append_identity(set->ctx, mat, n_out); + mat = append_identity(mat, n_out); if (!mat) goto error; @@ -673,7 +672,7 @@ static struct isl_set *set_parameter_preimage( return set; error: isl_dim_free(dim); - isl_mat_free(set ? set->ctx : NULL, mat); + isl_mat_free(mat); error2: isl_set_free(set); return NULL; @@ -704,11 +703,11 @@ static struct isl_basic_set *basic_set_append_equalities( isl_seq_cpy(bset->eq[k], eq->row[i], eq->n_col); isl_seq_clr(bset->eq[k] + eq->n_col, len - eq->n_col); } - isl_mat_free(bset->ctx, eq); + isl_mat_free(eq); return bset; error: - isl_mat_free(bset ? bset->ctx : NULL, eq); + isl_mat_free(eq); isl_basic_set_free(bset); return NULL; } @@ -726,14 +725,14 @@ static struct isl_set *set_append_equalities(struct isl_set *set, for (i = 0; i < set->n; ++i) { set->p[i] = basic_set_append_equalities(set->p[i], - isl_mat_copy(set->ctx, eq)); + isl_mat_copy(eq)); if (!set->p[i]) goto error; } - isl_mat_free(set->ctx, eq); + isl_mat_free(eq); return set; error: - isl_mat_free(set ? set->ctx : NULL, eq); + isl_mat_free(eq); isl_set_free(set); return NULL; } @@ -779,9 +778,8 @@ static struct isl_set *compute_divs(struct isl_basic_set *bset) eq = isl_mat_sub_alloc(bset->ctx, bset->eq, i, bset->n_eq - i, 0, 1 + nparam); - eq = isl_mat_cow(bset->ctx, eq); - T = isl_mat_variable_compression(bset->ctx, - isl_mat_copy(bset->ctx, eq), &T2); + eq = isl_mat_cow(eq); + T = isl_mat_variable_compression(isl_mat_copy(eq), &T2); bset = basic_set_parameter_preimage(bset, T); set = compute_divs_no_eq(bset); diff --git a/isl_map_simplify.c b/isl_map_simplify.c index b797b5ed..750199d6 100644 --- a/isl_map_simplify.c +++ b/isl_map_simplify.c @@ -760,13 +760,13 @@ static struct isl_basic_map *normalize_divs( if (div_eq < bmap->n_eq) { B = isl_mat_sub_alloc(bmap->ctx, bmap->eq, div_eq, bmap->n_eq - div_eq, 0, 1 + total); - C = isl_mat_variable_compression(bmap->ctx, B, &C2); + C = isl_mat_variable_compression(B, &C2); if (!C || !C2) goto error; if (C->n_col == 0) { bmap = isl_basic_map_set_to_empty(bmap); - isl_mat_free(bmap->ctx, C); - isl_mat_free(bmap->ctx, C2); + isl_mat_free(C); + isl_mat_free(C2); goto done; } } @@ -782,17 +782,17 @@ static struct isl_basic_map *normalize_divs( B = isl_mat_sub_alloc(bmap->ctx, bmap->eq, 0, div_eq, 0, 1 + total); if (C) { - B = isl_mat_product(bmap->ctx, B, C); + B = isl_mat_product(B, C); C = NULL; } - T = isl_mat_parameter_compression(bmap->ctx, B, d); + T = isl_mat_parameter_compression(B, d); if (!T) goto error; if (T->n_col == 0) { bmap = isl_basic_map_set_to_empty(bmap); - isl_mat_free(bmap->ctx, C2); - isl_mat_free(bmap->ctx, T); + isl_mat_free(C2); + isl_mat_free(T); goto done; } isl_int_init(v); @@ -856,8 +856,8 @@ static struct isl_basic_map *normalize_divs( isl_int_set(bmap->eq[j][pos[i]], bmap->div[k][0]); } free(pos); - isl_mat_free(bmap->ctx, C2); - isl_mat_free(bmap->ctx, T); + isl_mat_free(C2); + isl_mat_free(T); if (progress) *progress = 1; @@ -866,9 +866,9 @@ done: return bmap; error: - isl_mat_free(bmap->ctx, C); - isl_mat_free(bmap->ctx, C2); - isl_mat_free(bmap->ctx, T); + isl_mat_free(C); + isl_mat_free(C2); + isl_mat_free(T); return bmap; } @@ -1477,16 +1477,16 @@ static struct isl_basic_set *normalize_constraints_in_compressed_space( total = isl_basic_set_total_dim(bset); B = isl_mat_sub_alloc(bset->ctx, bset->eq, 0, bset->n_eq, 0, 1 + total); - C = isl_mat_variable_compression(bset->ctx, B, NULL); + C = isl_mat_variable_compression(B, NULL); if (!C) return bset; if (C->n_col == 0) { - isl_mat_free(bset->ctx, C); + isl_mat_free(C); return isl_basic_set_set_to_empty(bset); } B = isl_mat_sub_alloc(bset->ctx, bset->ineq, 0, bset->n_ineq, 0, 1 + total); - C = isl_mat_product(bset->ctx, B, C); + C = isl_mat_product(B, C); if (!C) return bset; @@ -1500,7 +1500,7 @@ static struct isl_basic_set *normalize_constraints_in_compressed_space( } isl_int_clear(gcd); - isl_mat_free(bset->ctx, C); + isl_mat_free(C); return bset; } diff --git a/isl_mat.c b/isl_mat.c index d72d929f..5c925aeb 100644 --- a/isl_mat.c +++ b/isl_mat.c @@ -24,6 +24,8 @@ struct isl_mat *isl_mat_alloc(struct isl_ctx *ctx, for (i = 0; i < n_row; ++i) mat->row[i] = mat->block.data + i * n_col; + mat->ctx = ctx; + isl_ctx_ref(ctx); mat->ref = 1; mat->n_row = n_row; mat->n_col = n_col; @@ -36,7 +38,7 @@ error: return NULL; } -struct isl_mat *isl_mat_extend(struct isl_ctx *ctx, struct isl_mat *mat, +struct isl_mat *isl_mat_extend(struct isl_mat *mat, unsigned n_row, unsigned n_col) { int i; @@ -51,25 +53,25 @@ struct isl_mat *isl_mat_extend(struct isl_ctx *ctx, struct isl_mat *mat, if (mat->n_col < n_col) { struct isl_mat *new_mat; - new_mat = isl_mat_alloc(ctx, n_row, n_col); + new_mat = isl_mat_alloc(mat->ctx, n_row, n_col); if (!new_mat) goto error; for (i = 0; i < mat->n_row; ++i) isl_seq_cpy(new_mat->row[i], mat->row[i], mat->n_col); - isl_mat_free(ctx, mat); + isl_mat_free(mat); return new_mat; } - mat = isl_mat_cow(ctx, mat); + mat = isl_mat_cow(mat); if (!mat) goto error; assert(mat->ref == 1); old = mat->block.data; - mat->block = isl_blk_extend(ctx, mat->block, n_row * mat->n_col); + mat->block = isl_blk_extend(mat->ctx, mat->block, n_row * mat->n_col); if (isl_blk_is_error(mat->block)) goto error; - mat->row = isl_realloc_array(ctx, mat->row, isl_int *, n_row); + mat->row = isl_realloc_array(mat->ctx, mat->row, isl_int *, n_row); if (!mat->row) goto error; @@ -81,7 +83,7 @@ struct isl_mat *isl_mat_extend(struct isl_ctx *ctx, struct isl_mat *mat, return mat; error: - isl_mat_free(ctx, mat); + isl_mat_free(mat); return NULL; } @@ -99,6 +101,8 @@ struct isl_mat *isl_mat_sub_alloc(struct isl_ctx *ctx, isl_int **row, goto error; for (i = 0; i < n_row; ++i) mat->row[i] = row[first_row+i] + first_col; + mat->ctx = ctx; + isl_ctx_ref(ctx); mat->ref = 1; mat->n_row = n_row; mat->n_col = n_col; @@ -128,7 +132,7 @@ void isl_mat_sub_neg(struct isl_ctx *ctx, isl_int **dst, isl_int **src, isl_seq_neg(dst[i]+dst_col, src[i]+src_col, n_col); } -struct isl_mat *isl_mat_copy(struct isl_ctx *ctx, struct isl_mat *mat) +struct isl_mat *isl_mat_copy(struct isl_mat *mat) { if (!mat) return NULL; @@ -137,14 +141,14 @@ struct isl_mat *isl_mat_copy(struct isl_ctx *ctx, struct isl_mat *mat) return mat; } -struct isl_mat *isl_mat_dup(struct isl_ctx *ctx, struct isl_mat *mat) +struct isl_mat *isl_mat_dup(struct isl_mat *mat) { int i; struct isl_mat *mat2; if (!mat) return NULL; - mat2 = isl_mat_alloc(ctx, mat->n_row, mat->n_col); + mat2 = isl_mat_alloc(mat->ctx, mat->n_row, mat->n_col); if (!mat2) return NULL; for (i = 0; i < mat->n_row; ++i) @@ -152,7 +156,7 @@ struct isl_mat *isl_mat_dup(struct isl_ctx *ctx, struct isl_mat *mat) return mat2; } -struct isl_mat *isl_mat_cow(struct isl_ctx *ctx, struct isl_mat *mat) +struct isl_mat *isl_mat_cow(struct isl_mat *mat) { struct isl_mat *mat2; if (!mat) @@ -161,12 +165,12 @@ struct isl_mat *isl_mat_cow(struct isl_ctx *ctx, struct isl_mat *mat) if (mat->ref == 1 && !ISL_F_ISSET(mat, ISL_MAT_BORROWED)) return mat; - mat2 = isl_mat_dup(ctx, mat); - isl_mat_free(ctx, mat); + mat2 = isl_mat_dup(mat); + isl_mat_free(mat); return mat2; } -void isl_mat_free(struct isl_ctx *ctx, struct isl_mat *mat) +void isl_mat_free(struct isl_mat *mat) { if (!mat) return; @@ -175,7 +179,8 @@ void isl_mat_free(struct isl_ctx *ctx, struct isl_mat *mat) return; if (!ISL_F_ISSET(mat, ISL_MAT_BORROWED)) - isl_blk_free(ctx, mat->block); + isl_blk_free(mat->ctx, mat->block); + isl_ctx_deref(mat->ctx); free(mat->row); free(mat); } @@ -197,8 +202,7 @@ struct isl_mat *isl_mat_identity(struct isl_ctx *ctx, unsigned n_row) return mat; } -struct isl_vec *isl_mat_vec_product(struct isl_ctx *ctx, - struct isl_mat *mat, struct isl_vec *vec) +struct isl_vec *isl_mat_vec_product(struct isl_mat *mat, struct isl_vec *vec) { int i; struct isl_vec *prod; @@ -208,24 +212,24 @@ struct isl_vec *isl_mat_vec_product(struct isl_ctx *ctx, isl_assert(ctx, mat->n_col == vec->size, goto error); - prod = isl_vec_alloc(ctx, mat->n_row); + prod = isl_vec_alloc(mat->ctx, mat->n_row); if (!prod) goto error; for (i = 0; i < prod->size; ++i) isl_seq_inner_product(mat->row[i], vec->el, vec->size, &prod->block.data[i]); - isl_mat_free(ctx, mat); + isl_mat_free(mat); isl_vec_free(vec); return prod; error: - isl_mat_free(ctx, mat); + isl_mat_free(mat); isl_vec_free(vec); return NULL; } -struct isl_mat *isl_mat_aff_direct_sum(struct isl_ctx *ctx, - struct isl_mat *left, struct isl_mat *right) +struct isl_mat *isl_mat_aff_direct_sum(struct isl_mat *left, + struct isl_mat *right) { int i; struct isl_mat *sum; @@ -244,7 +248,7 @@ struct isl_mat *isl_mat_aff_direct_sum(struct isl_ctx *ctx, isl_seq_first_non_zero(right->row[0]+1, right->n_col-1) == -1, goto error); - sum = isl_mat_alloc(ctx, left->n_row, left->n_col + right->n_col - 1); + sum = isl_mat_alloc(left->ctx, left->n_row, left->n_col + right->n_col - 1); if (!sum) goto error; isl_int_lcm(sum->row[0][0], left->row[0][0], right->row[0][0]); @@ -265,16 +269,16 @@ struct isl_mat *isl_mat_aff_direct_sum(struct isl_ctx *ctx, isl_int_divexact(left->row[0][0], sum->row[0][0], left->row[0][0]); isl_int_divexact(right->row[0][0], sum->row[0][0], right->row[0][0]); - isl_mat_free(ctx, left); - isl_mat_free(ctx, right); + isl_mat_free(left); + isl_mat_free(right); return sum; error: - isl_mat_free(ctx, left); - isl_mat_free(ctx, right); + isl_mat_free(left); + isl_mat_free(right); return NULL; } -static void exchange(struct isl_ctx *ctx, struct isl_mat *M, struct isl_mat **U, +static void exchange(struct isl_mat *M, struct isl_mat **U, struct isl_mat **Q, unsigned row, unsigned i, unsigned j) { int r; @@ -285,7 +289,7 @@ static void exchange(struct isl_ctx *ctx, struct isl_mat *M, struct isl_mat **U, isl_int_swap((*U)->row[r][i], (*U)->row[r][j]); } if (Q) - isl_mat_swap_rows(ctx, *Q, i, j); + isl_mat_swap_rows(*Q, i, j); } static void subtract(struct isl_mat *M, struct isl_mat **U, @@ -304,7 +308,7 @@ static void subtract(struct isl_mat *M, struct isl_mat **U, } } -static void oppose(struct isl_ctx *ctx, struct isl_mat *M, struct isl_mat **U, +static void oppose(struct isl_mat *M, struct isl_mat **U, struct isl_mat **Q, unsigned row, unsigned col) { int r; @@ -330,8 +334,8 @@ static void oppose(struct isl_ctx *ctx, struct isl_mat *M, struct isl_mat **U, * column. * If U or Q are NULL, then these matrices are not computed. */ -struct isl_mat *isl_mat_left_hermite(struct isl_ctx *ctx, - struct isl_mat *M, int neg, struct isl_mat **U, struct isl_mat **Q) +struct isl_mat *isl_mat_left_hermite(struct isl_mat *M, int neg, + struct isl_mat **U, struct isl_mat **Q) { isl_int c; int row, col; @@ -342,16 +346,16 @@ struct isl_mat *isl_mat_left_hermite(struct isl_ctx *ctx, *Q = NULL; if (!M) goto error; - M = isl_mat_cow(ctx, M); + M = isl_mat_cow(M); if (!M) goto error; if (U) { - *U = isl_mat_identity(ctx, M->n_col); + *U = isl_mat_identity(M->ctx, M->n_col); if (!*U) goto error; } if (Q) { - *Q = isl_mat_identity(ctx, M->n_col); + *Q = isl_mat_identity(M->ctx, M->n_col); if (!*Q) goto error; } @@ -365,9 +369,9 @@ struct isl_mat *isl_mat_left_hermite(struct isl_ctx *ctx, continue; first += col; if (first != col) - exchange(ctx, M, U, Q, row, first, col); + exchange(M, U, Q, row, first, col); if (isl_int_is_neg(M->row[row][col])) - oppose(ctx, M, U, Q, row, col); + oppose(M, U, Q, row, col); first = col+1; while ((off = isl_seq_first_non_zero(M->row[row]+first, M->n_col-first)) != -1) { @@ -375,7 +379,7 @@ struct isl_mat *isl_mat_left_hermite(struct isl_ctx *ctx, isl_int_fdiv_q(c, M->row[row][first], M->row[row][col]); subtract(M, U, Q, row, col, first, c); if (!isl_int_is_zero(M->row[row][first])) - exchange(ctx, M, U, Q, row, first, col); + exchange(M, U, Q, row, first, col); else ++first; } @@ -397,23 +401,23 @@ struct isl_mat *isl_mat_left_hermite(struct isl_ctx *ctx, return M; error: if (Q) { - isl_mat_free(ctx, *Q); + isl_mat_free(*Q); *Q = NULL; } if (U) { - isl_mat_free(ctx, *U); + isl_mat_free(*U); *U = NULL; } return NULL; } -struct isl_mat *isl_mat_right_kernel(struct isl_ctx *ctx, struct isl_mat *mat) +struct isl_mat *isl_mat_right_kernel(struct isl_mat *mat) { int i, rank; struct isl_mat *U = NULL; struct isl_mat *K; - mat = isl_mat_left_hermite(ctx, mat, 0, &U, NULL); + mat = isl_mat_left_hermite(mat, 0, &U, NULL); if (!mat || !U) goto error; @@ -423,27 +427,27 @@ struct isl_mat *isl_mat_right_kernel(struct isl_ctx *ctx, struct isl_mat *mat) if (i >= mat->n_row) break; } - K = isl_mat_alloc(ctx, U->n_row, U->n_col - rank); + K = isl_mat_alloc(U->ctx, U->n_row, U->n_col - rank); if (!K) goto error; - isl_mat_sub_copy(ctx, K->row, U->row, U->n_row, 0, rank, U->n_col-rank); - isl_mat_free(ctx, mat); - isl_mat_free(ctx, U); + isl_mat_sub_copy(K->ctx, K->row, U->row, U->n_row, 0, rank, U->n_col-rank); + isl_mat_free(mat); + isl_mat_free(U); return K; error: - isl_mat_free(ctx, mat); - isl_mat_free(ctx, U); + isl_mat_free(mat); + isl_mat_free(U); return NULL; } -struct isl_mat *isl_mat_lin_to_aff(struct isl_ctx *ctx, struct isl_mat *mat) +struct isl_mat *isl_mat_lin_to_aff(struct isl_mat *mat) { int i; struct isl_mat *mat2; if (!mat) return NULL; - mat2 = isl_mat_alloc(ctx, 1+mat->n_row, 1+mat->n_col); + mat2 = isl_mat_alloc(mat->ctx, 1+mat->n_row, 1+mat->n_col); if (!mat2) return NULL; isl_int_set_si(mat2->row[0][0], 1); @@ -452,7 +456,7 @@ struct isl_mat *isl_mat_lin_to_aff(struct isl_ctx *ctx, struct isl_mat *mat) isl_int_set_si(mat2->row[1+i][0], 0); isl_seq_cpy(mat2->row[1+i]+1, mat->row[i], mat->n_col); } - isl_mat_free(ctx, mat); + isl_mat_free(mat); return mat2; } @@ -480,38 +484,36 @@ static int row_abs_min_non_zero(isl_int **row, unsigned n_row, unsigned col) return min; } -static void inv_exchange(struct isl_ctx *ctx, - struct isl_mat *left, struct isl_mat *right, +static void inv_exchange(struct isl_mat *left, struct isl_mat *right, unsigned i, unsigned j) { - left = isl_mat_swap_rows(ctx, left, i, j); - right = isl_mat_swap_rows(ctx, right, i, j); + left = isl_mat_swap_rows(left, i, j); + right = isl_mat_swap_rows(right, i, j); } -static void inv_oppose(struct isl_ctx *ctx, +static void inv_oppose( struct isl_mat *left, struct isl_mat *right, unsigned row) { isl_seq_neg(left->row[row]+row, left->row[row]+row, left->n_col-row); isl_seq_neg(right->row[row], right->row[row], right->n_col); } -static void inv_subtract(struct isl_ctx *ctx, - struct isl_mat *left, struct isl_mat *right, +static void inv_subtract(struct isl_mat *left, struct isl_mat *right, unsigned row, unsigned i, isl_int m) { isl_int_neg(m, m); isl_seq_combine(left->row[i]+row, - ctx->one, left->row[i]+row, + left->ctx->one, left->row[i]+row, m, left->row[row]+row, left->n_col-row); - isl_seq_combine(right->row[i], ctx->one, right->row[i], + isl_seq_combine(right->row[i], right->ctx->one, right->row[i], m, right->row[row], right->n_col); } /* Compute inv(left)*right */ -struct isl_mat *isl_mat_inverse_product(struct isl_ctx *ctx, - struct isl_mat *left, struct isl_mat *right) +struct isl_mat *isl_mat_inverse_product(struct isl_mat *left, + struct isl_mat *right) { int row; isl_int a, b; @@ -519,16 +521,16 @@ struct isl_mat *isl_mat_inverse_product(struct isl_ctx *ctx, if (!left || !right) goto error; - isl_assert(ctx, left->n_row == left->n_col, goto error); - isl_assert(ctx, left->n_row == right->n_row, goto error); + isl_assert(left->ctx, left->n_row == left->n_col, goto error); + isl_assert(left->ctx, left->n_row == right->n_row, goto error); if (left->n_row == 0) { - isl_mat_free(ctx, left); + isl_mat_free(left); return right; } - left = isl_mat_cow(ctx, left); - right = isl_mat_cow(ctx, right); + left = isl_mat_cow(left); + right = isl_mat_cow(right); if (!left || !right) goto error; @@ -544,18 +546,18 @@ struct isl_mat *isl_mat_inverse_product(struct isl_ctx *ctx, } pivot += row; if (pivot != row) - inv_exchange(ctx, left, right, pivot, row); + inv_exchange(left, right, pivot, row); if (isl_int_is_neg(left->row[row][row])) - inv_oppose(ctx, left, right, row); + inv_oppose(left, right, row); first = row+1; while ((off = row_first_non_zero(left->row+first, left->n_row-first, row)) != -1) { first += off; isl_int_fdiv_q(a, left->row[first][row], left->row[row][row]); - inv_subtract(ctx, left, right, row, first, a); + inv_subtract(left, right, row, first, a); if (!isl_int_is_zero(left->row[first][row])) - inv_exchange(ctx, left, right, row, first); + inv_exchange(left, right, row, first); else ++first; } @@ -592,11 +594,11 @@ struct isl_mat *isl_mat_inverse_product(struct isl_ctx *ctx, } isl_int_clear(a); - isl_mat_free(ctx, left); + isl_mat_free(left); return right; error: - isl_mat_free(ctx, left); - isl_mat_free(ctx, right); + isl_mat_free(left); + isl_mat_free(right); return NULL; } @@ -623,19 +625,18 @@ void isl_mat_col_combine(struct isl_mat *mat, unsigned dst, isl_int_clear(tmp); } -struct isl_mat *isl_mat_right_inverse(struct isl_ctx *ctx, - struct isl_mat *mat) +struct isl_mat *isl_mat_right_inverse(struct isl_mat *mat) { struct isl_mat *inv; int row; isl_int a, b; - mat = isl_mat_cow(ctx, mat); + mat = isl_mat_cow(mat); if (!mat) return NULL; - inv = isl_mat_identity(ctx, mat->n_col); - inv = isl_mat_cow(ctx, inv); + inv = isl_mat_identity(mat->ctx, mat->n_col); + inv = isl_mat_cow(inv); if (!inv) goto error; @@ -651,9 +652,9 @@ struct isl_mat *isl_mat_right_inverse(struct isl_ctx *ctx, } pivot += row; if (pivot != row) - exchange(ctx, mat, &inv, NULL, row, pivot, row); + exchange(mat, &inv, NULL, row, pivot, row); if (isl_int_is_neg(mat->row[row][row])) - oppose(ctx, mat, &inv, NULL, row, row); + oppose(mat, &inv, NULL, row, row); first = row+1; while ((off = isl_seq_first_non_zero(mat->row[row]+first, mat->n_col-first)) != -1) { @@ -662,7 +663,7 @@ struct isl_mat *isl_mat_right_inverse(struct isl_ctx *ctx, mat->row[row][row]); subtract(mat, &inv, NULL, row, row, first, a); if (!isl_int_is_zero(mat->row[row][first])) - exchange(ctx, mat, &inv, NULL, row, row, first); + exchange(mat, &inv, NULL, row, row, first); else ++first; } @@ -694,21 +695,21 @@ struct isl_mat *isl_mat_right_inverse(struct isl_ctx *ctx, } isl_int_clear(a); - isl_mat_free(ctx, mat); + isl_mat_free(mat); return inv; error: - isl_mat_free(ctx, mat); + isl_mat_free(mat); return NULL; } -struct isl_mat *isl_mat_transpose(struct isl_ctx *ctx, struct isl_mat *mat) +struct isl_mat *isl_mat_transpose(struct isl_mat *mat) { struct isl_mat *transpose = NULL; int i, j; if (mat->n_col == mat->n_row) { - mat = isl_mat_cow(ctx, mat); + mat = isl_mat_cow(mat); if (!mat) return NULL; for (i = 0; i < mat->n_row; ++i) @@ -716,25 +717,24 @@ struct isl_mat *isl_mat_transpose(struct isl_ctx *ctx, struct isl_mat *mat) isl_int_swap(mat->row[i][j], mat->row[j][i]); return mat; } - transpose = isl_mat_alloc(ctx, mat->n_col, mat->n_row); + transpose = isl_mat_alloc(mat->ctx, mat->n_col, mat->n_row); if (!transpose) goto error; for (i = 0; i < mat->n_row; ++i) for (j = 0; j < mat->n_col; ++j) isl_int_set(transpose->row[j][i], mat->row[i][j]); - isl_mat_free(ctx, mat); + isl_mat_free(mat); return transpose; error: - isl_mat_free(ctx, mat); + isl_mat_free(mat); return NULL; } -struct isl_mat *isl_mat_swap_cols(struct isl_ctx *ctx, - struct isl_mat *mat, unsigned i, unsigned j) +struct isl_mat *isl_mat_swap_cols(struct isl_mat *mat, unsigned i, unsigned j) { int r; - mat = isl_mat_cow(ctx, mat); + mat = isl_mat_cow(mat); if (!mat) return NULL; isl_assert(ctx, i < mat->n_col, goto error); @@ -744,18 +744,17 @@ struct isl_mat *isl_mat_swap_cols(struct isl_ctx *ctx, isl_int_swap(mat->row[r][i], mat->row[r][j]); return mat; error: - isl_mat_free(ctx, mat); + isl_mat_free(mat); return NULL; } -struct isl_mat *isl_mat_swap_rows(struct isl_ctx *ctx, - struct isl_mat *mat, unsigned i, unsigned j) +struct isl_mat *isl_mat_swap_rows(struct isl_mat *mat, unsigned i, unsigned j) { isl_int *t; if (!mat) return NULL; - mat = isl_mat_cow(ctx, mat); + mat = isl_mat_cow(mat); if (!mat) return NULL; t = mat->row[i]; @@ -764,8 +763,7 @@ struct isl_mat *isl_mat_swap_rows(struct isl_ctx *ctx, return mat; } -struct isl_mat *isl_mat_product(struct isl_ctx *ctx, - struct isl_mat *left, struct isl_mat *right) +struct isl_mat *isl_mat_product(struct isl_mat *left, struct isl_mat *right) { int i, j, k; struct isl_mat *prod; @@ -773,7 +771,7 @@ struct isl_mat *isl_mat_product(struct isl_ctx *ctx, if (!left || !right) goto error; isl_assert(ctx, left->n_col == right->n_row, goto error); - prod = isl_mat_alloc(ctx, left->n_row, right->n_col); + prod = isl_mat_alloc(left->ctx, left->n_row, right->n_col); if (!prod) goto error; if (left->n_col == 0) { @@ -790,12 +788,12 @@ struct isl_mat *isl_mat_product(struct isl_ctx *ctx, left->row[i][k], right->row[k][j]); } } - isl_mat_free(ctx, left); - isl_mat_free(ctx, right); + isl_mat_free(left); + isl_mat_free(right); return prod; error: - isl_mat_free(ctx, left); - isl_mat_free(ctx, right); + isl_mat_free(left); + isl_mat_free(right); return NULL; } @@ -824,8 +822,8 @@ static int preimage(struct isl_ctx *ctx, isl_int **q, unsigned n, if (has_div) for (i = 0; i < n; ++i) isl_int_mul(q[i][0], q[i][0], mat->row[0][0]); - t = isl_mat_sub_alloc(ctx, q, 0, n, has_div, mat->n_row); - t = isl_mat_product(ctx, t, mat); + t = isl_mat_sub_alloc(mat->ctx, q, 0, n, has_div, mat->n_row); + t = isl_mat_product(t, mat); if (!t) return -1; for (i = 0; i < n; ++i) { @@ -834,7 +832,7 @@ static int preimage(struct isl_ctx *ctx, isl_int **q, unsigned n, q[i] + has_div + t->n_col + e, n_div); isl_seq_clr(q[i] + has_div + t->n_col + n_div, e); } - isl_mat_free(ctx, t); + isl_mat_free(t); return 0; } @@ -875,11 +873,11 @@ struct isl_basic_set *isl_basic_set_preimage(struct isl_basic_set *bset, } if (preimage(ctx, bset->eq, bset->n_eq, bset->n_div, 0, - isl_mat_copy(ctx, mat)) < 0) + isl_mat_copy(mat)) < 0) goto error; if (preimage(ctx, bset->ineq, bset->n_ineq, bset->n_div, 0, - isl_mat_copy(ctx, mat)) < 0) + isl_mat_copy(mat)) < 0) goto error; if (preimage(ctx, bset->div, bset->n_div, bset->n_div, 1, mat) < 0) @@ -896,7 +894,7 @@ struct isl_basic_set *isl_basic_set_preimage(struct isl_basic_set *bset, return bset; error: - isl_mat_free(ctx, mat); + isl_mat_free(mat); error2: isl_basic_set_free(bset); return NULL; @@ -914,7 +912,7 @@ struct isl_set *isl_set_preimage(struct isl_set *set, struct isl_mat *mat) ctx = set->ctx; for (i = 0; i < set->n; ++i) { set->p[i] = isl_basic_set_preimage(set->p[i], - isl_mat_copy(ctx, mat)); + isl_mat_copy(mat)); if (!set->p[i]) goto error; } @@ -925,17 +923,16 @@ struct isl_set *isl_set_preimage(struct isl_set *set, struct isl_mat *mat) set->dim->n_out += mat->n_col; set->dim->n_out -= mat->n_row; } - isl_mat_free(ctx, mat); + isl_mat_free(mat); ISL_F_CLR(set, ISL_SET_NORMALIZED); return set; error: isl_set_free(set); - isl_mat_free(ctx, mat); + isl_mat_free(mat); return NULL; } -void isl_mat_dump(struct isl_ctx *ctx, struct isl_mat *mat, - FILE *out, int indent) +void isl_mat_dump(struct isl_mat *mat, FILE *out, int indent) { int i, j; @@ -964,12 +961,11 @@ void isl_mat_dump(struct isl_ctx *ctx, struct isl_mat *mat, } } -struct isl_mat *isl_mat_drop_cols(struct isl_ctx *ctx, struct isl_mat *mat, - unsigned col, unsigned n) +struct isl_mat *isl_mat_drop_cols(struct isl_mat *mat, unsigned col, unsigned n) { int r; - mat = isl_mat_cow(ctx, mat); + mat = isl_mat_cow(mat); if (!mat) return NULL; @@ -982,12 +978,11 @@ struct isl_mat *isl_mat_drop_cols(struct isl_ctx *ctx, struct isl_mat *mat, return mat; } -struct isl_mat *isl_mat_drop_rows(struct isl_ctx *ctx, struct isl_mat *mat, - unsigned row, unsigned n) +struct isl_mat *isl_mat_drop_rows(struct isl_mat *mat, unsigned row, unsigned n) { int r; - mat = isl_mat_cow(ctx, mat); + mat = isl_mat_cow(mat); if (!mat) return NULL; @@ -1015,15 +1010,14 @@ void isl_mat_col_mul(struct isl_mat *mat, int dst_col, isl_int f, int src_col) isl_int_mul(mat->row[i][dst_col], f, mat->row[i][src_col]); } -struct isl_mat *isl_mat_unimodular_complete(struct isl_ctx *ctx, - struct isl_mat *M, int row) +struct isl_mat *isl_mat_unimodular_complete(struct isl_mat *M, int row) { int r; struct isl_mat *H = NULL, *Q = NULL; isl_assert(ctx, M->n_row == M->n_col, goto error); M->n_row = row; - H = isl_mat_left_hermite(ctx, isl_mat_copy(ctx, M), 0, NULL, &Q); + H = isl_mat_left_hermite(isl_mat_copy(M), 0, NULL, &Q); M->n_row = M->n_col; if (!H) goto error; @@ -1031,12 +1025,12 @@ struct isl_mat *isl_mat_unimodular_complete(struct isl_ctx *ctx, isl_assert(ctx, isl_int_is_one(H->row[r][r]), goto error); for (r = row; r < M->n_row; ++r) isl_seq_cpy(M->row[r], Q->row[r], M->n_col); - isl_mat_free(ctx, H); - isl_mat_free(ctx, Q); + isl_mat_free(H); + isl_mat_free(Q); return M; error: - isl_mat_free(ctx, H); - isl_mat_free(ctx, Q); - isl_mat_free(ctx, M); + isl_mat_free(H); + isl_mat_free(Q); + isl_mat_free(M); return NULL; } diff --git a/isl_mat.h b/isl_mat.h index 97cc1073..6d1431ac 100644 --- a/isl_mat.h +++ b/isl_mat.h @@ -16,6 +16,8 @@ extern "C" { struct isl_mat { int ref; + struct isl_ctx *ctx; + #define ISL_MAT_BORROWED (1 << 0) unsigned flags; @@ -29,12 +31,12 @@ struct isl_mat { struct isl_mat *isl_mat_alloc(struct isl_ctx *ctx, unsigned n_row, unsigned n_col); -struct isl_mat *isl_mat_extend(struct isl_ctx *ctx, struct isl_mat *mat, +struct isl_mat *isl_mat_extend(struct isl_mat *mat, unsigned n_row, unsigned n_col); struct isl_mat *isl_mat_identity(struct isl_ctx *ctx, unsigned n_row); -struct isl_mat *isl_mat_copy(struct isl_ctx *ctx, struct isl_mat *mat); -struct isl_mat *isl_mat_cow(struct isl_ctx *ctx, struct isl_mat *mat); -void isl_mat_free(struct isl_ctx *ctx, struct isl_mat *mat); +struct isl_mat *isl_mat_copy(struct isl_mat *mat); +struct isl_mat *isl_mat_cow(struct isl_mat *mat); +void isl_mat_free(struct isl_mat *mat); struct isl_mat *isl_mat_sub_alloc(struct isl_ctx *ctx, isl_int **row, unsigned first_row, unsigned n_row, unsigned first_col, unsigned n_col); @@ -43,30 +45,25 @@ void isl_mat_sub_copy(struct isl_ctx *ctx, isl_int **dst, isl_int **src, void isl_mat_sub_neg(struct isl_ctx *ctx, isl_int **dst, isl_int **src, unsigned n_row, unsigned dst_col, unsigned src_col, unsigned n_col); -struct isl_mat *isl_mat_swap_cols(struct isl_ctx *ctx, - struct isl_mat *mat, unsigned i, unsigned j); -struct isl_mat *isl_mat_swap_rows(struct isl_ctx *ctx, - struct isl_mat *mat, unsigned i, unsigned j); - -struct isl_vec *isl_mat_vec_product(struct isl_ctx *ctx, - struct isl_mat *mat, struct isl_vec *vec); -struct isl_mat *isl_mat_aff_direct_sum(struct isl_ctx *ctx, - struct isl_mat *left, struct isl_mat *right); -struct isl_mat *isl_mat_left_hermite(struct isl_ctx *ctx, - struct isl_mat *M, int neg, struct isl_mat **U, struct isl_mat **Q); -struct isl_mat *isl_mat_lin_to_aff(struct isl_ctx *ctx, struct isl_mat *mat); -struct isl_mat *isl_mat_inverse_product(struct isl_ctx *ctx, - struct isl_mat *left, struct isl_mat *right); -struct isl_mat *isl_mat_product(struct isl_ctx *ctx, - struct isl_mat *left, struct isl_mat *right); -struct isl_mat *isl_mat_transpose(struct isl_ctx *ctx, struct isl_mat *mat); -struct isl_mat *isl_mat_right_inverse(struct isl_ctx *ctx, - struct isl_mat *mat); -struct isl_mat *isl_mat_right_kernel(struct isl_ctx *ctx, struct isl_mat *mat); - -struct isl_mat *isl_mat_drop_cols(struct isl_ctx *ctx, struct isl_mat *mat, +struct isl_mat *isl_mat_swap_cols(struct isl_mat *mat, unsigned i, unsigned j); +struct isl_mat *isl_mat_swap_rows(struct isl_mat *mat, unsigned i, unsigned j); + +struct isl_vec *isl_mat_vec_product(struct isl_mat *mat, struct isl_vec *vec); +struct isl_mat *isl_mat_aff_direct_sum(struct isl_mat *left, + struct isl_mat *right); +struct isl_mat *isl_mat_left_hermite(struct isl_mat *M, + int neg, struct isl_mat **U, struct isl_mat **Q); +struct isl_mat *isl_mat_lin_to_aff(struct isl_mat *mat); +struct isl_mat *isl_mat_inverse_product(struct isl_mat *left, + struct isl_mat *right); +struct isl_mat *isl_mat_product(struct isl_mat *left, struct isl_mat *right); +struct isl_mat *isl_mat_transpose(struct isl_mat *mat); +struct isl_mat *isl_mat_right_inverse(struct isl_mat *mat); +struct isl_mat *isl_mat_right_kernel(struct isl_mat *mat); + +struct isl_mat *isl_mat_drop_cols(struct isl_mat *mat, unsigned col, unsigned n); -struct isl_mat *isl_mat_drop_rows(struct isl_ctx *ctx, struct isl_mat *mat, +struct isl_mat *isl_mat_drop_rows(struct isl_mat *mat, unsigned row, unsigned n); void isl_mat_col_mul(struct isl_mat *mat, int dst_col, isl_int f, int src_col); @@ -77,11 +74,9 @@ struct isl_basic_set *isl_basic_set_preimage(struct isl_basic_set *bset, struct isl_mat *mat); struct isl_set *isl_set_preimage(struct isl_set *set, struct isl_mat *mat); -struct isl_mat *isl_mat_unimodular_complete(struct isl_ctx *ctx, - struct isl_mat *M, int row); +struct isl_mat *isl_mat_unimodular_complete(struct isl_mat *M, int row); -void isl_mat_dump(struct isl_ctx *ctx, struct isl_mat *mat, - FILE *out, int indent); +void isl_mat_dump(struct isl_mat *mat, FILE *out, int indent); #if defined(__cplusplus) } diff --git a/isl_sample.c b/isl_sample.c index 746bd5c4..a9feb64d 100644 --- a/isl_sample.c +++ b/isl_sample.c @@ -92,8 +92,7 @@ error: return NULL; } -static struct isl_mat *independent_bounds(struct isl_ctx *ctx, - struct isl_basic_set *bset) +static struct isl_mat *independent_bounds(struct isl_basic_set *bset) { int i, j, n; struct isl_mat *dirs = NULL; @@ -104,7 +103,7 @@ static struct isl_mat *independent_bounds(struct isl_ctx *ctx, return NULL; dim = isl_basic_set_n_dim(bset); - bounds = isl_mat_alloc(ctx, 1+dim, 1+dim); + bounds = isl_mat_alloc(bset->ctx, 1+dim, 1+dim); if (!bounds) return NULL; @@ -115,9 +114,9 @@ static struct isl_mat *independent_bounds(struct isl_ctx *ctx, if (bset->n_ineq == 0) return bounds; - dirs = isl_mat_alloc(ctx, dim, dim); + dirs = isl_mat_alloc(bset->ctx, dim, dim); if (!dirs) { - isl_mat_free(ctx, bounds); + isl_mat_free(bounds); return NULL; } isl_seq_cpy(dirs->row[0], bset->ineq[0]+1, dirs->n_col); @@ -155,7 +154,7 @@ static struct isl_mat *independent_bounds(struct isl_ctx *ctx, ++n; isl_seq_cpy(bounds->row[n], bset->ineq[j], bounds->n_col); } - isl_mat_free(ctx, dirs); + isl_mat_free(dirs); bounds->n_row = 1+n; return bounds; } @@ -190,16 +189,14 @@ static struct isl_basic_set *isl_basic_set_skew_to_positive_orthant( struct isl_mat *bounds = NULL; int i, j; unsigned old_dim, new_dim; - struct isl_ctx *ctx; *T = NULL; if (!bset) return NULL; - ctx = bset->ctx; - isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error); - isl_assert(ctx, bset->n_div == 0, goto error); - isl_assert(ctx, bset->n_eq == 0, 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); + isl_assert(bset->ctx, bset->n_eq == 0, goto error); old_dim = isl_basic_set_n_dim(bset); /* Try to move (multiples of) unit rows up. */ @@ -214,23 +211,23 @@ static struct isl_basic_set *isl_basic_set_skew_to_positive_orthant( swap_inequality(bset, i, j); ++j; } - bounds = independent_bounds(ctx, bset); + bounds = independent_bounds(bset); if (!bounds) goto error; new_dim = bounds->n_row - 1; - bounds = isl_mat_left_hermite(ctx, bounds, 1, &U, NULL); + bounds = isl_mat_left_hermite(bounds, 1, &U, NULL); if (!bounds) goto error; - U = isl_mat_drop_cols(ctx, U, 1 + new_dim, old_dim - new_dim); - bset = isl_basic_set_preimage(bset, isl_mat_copy(ctx, U)); + U = isl_mat_drop_cols(U, 1 + new_dim, old_dim - new_dim); + bset = isl_basic_set_preimage(bset, isl_mat_copy(U)); if (!bset) goto error; *T = U; - isl_mat_free(ctx, bounds); + isl_mat_free(bounds); return bset; error: - isl_mat_free(ctx, bounds); - isl_mat_free(ctx, U); + isl_mat_free(bounds); + isl_mat_free(U); isl_basic_set_free(bset); return NULL; } @@ -247,18 +244,16 @@ static struct isl_vec *sample_eq(struct isl_basic_set *bset, { struct isl_mat *T; struct isl_vec *sample; - struct isl_ctx *ctx; if (!bset) return NULL; - ctx = bset->ctx; bset = isl_basic_set_remove_equalities(bset, &T, NULL); sample = recurse(bset); if (!sample || sample->size == 0) - isl_mat_free(ctx, T); + isl_mat_free(T); else - sample = isl_mat_vec_product(ctx, T, sample); + sample = isl_mat_vec_product(T, sample); return sample; } @@ -326,30 +321,27 @@ error: static struct isl_basic_set *basic_set_reduced(struct isl_basic_set *bset, struct isl_mat **T) { - struct isl_ctx *ctx; unsigned gbr_only_first; *T = NULL; if (!bset) return NULL; - ctx = bset->ctx; - - gbr_only_first = ctx->gbr_only_first; - ctx->gbr_only_first = 1; + gbr_only_first = bset->ctx->gbr_only_first; + bset->ctx->gbr_only_first = 1; *T = isl_basic_set_reduced_basis(bset); - ctx->gbr_only_first = gbr_only_first; + bset->ctx->gbr_only_first = gbr_only_first; - *T = isl_mat_lin_to_aff(bset->ctx, *T); - *T = isl_mat_right_inverse(bset->ctx, *T); + *T = isl_mat_lin_to_aff(*T); + *T = isl_mat_right_inverse(*T); - bset = isl_basic_set_preimage(bset, isl_mat_copy(bset->ctx, *T)); + bset = isl_basic_set_preimage(bset, isl_mat_copy(*T)); if (!bset) goto error; return bset; error: - isl_mat_free(ctx, *T); + isl_mat_free(*T); *T = NULL; return NULL; } @@ -426,7 +418,6 @@ error: static struct isl_vec *sample_bounded(struct isl_basic_set *bset) { unsigned dim; - struct isl_ctx *ctx; struct isl_vec *sample; struct isl_vec *obj = NULL; struct isl_mat *T = NULL; @@ -439,7 +430,6 @@ static struct isl_vec *sample_bounded(struct isl_basic_set *bset) if (isl_basic_set_fast_is_empty(bset)) return empty_sample(bset); - ctx = bset->ctx; dim = isl_basic_set_total_dim(bset); if (dim == 0) return zero_sample(bset); @@ -494,16 +484,16 @@ static struct isl_vec *sample_bounded(struct isl_basic_set *bset) out: if (T) { if (!sample || sample->size == 0) - isl_mat_free(ctx, T); + isl_mat_free(T); else - sample = isl_mat_vec_product(ctx, T, sample); + sample = isl_mat_vec_product(T, sample); } isl_vec_free(obj); isl_int_clear(min); isl_int_clear(max); return sample; error: - isl_mat_free(ctx, T); + isl_mat_free(T); isl_basic_set_free(bset); isl_vec_free(obj); isl_int_clear(min); @@ -695,7 +685,7 @@ static struct isl_vec *round_up_in_cone(struct isl_vec *vec, isl_assert(vec->ctx, vec->size != 0, goto error); if (isl_int_is_one(vec->el[0])) { - isl_mat_free(vec->ctx, U); + isl_mat_free(U); isl_basic_set_free(cone); return vec; } @@ -710,7 +700,7 @@ static struct isl_vec *round_up_in_cone(struct isl_vec *vec, vec = isl_vec_ceil(vec); return vec; error: - isl_mat_free(vec ? vec->ctx : cone ? cone->ctx : NULL, U); + isl_mat_free(U); isl_vec_free(vec); isl_basic_set_free(cone); return NULL; @@ -825,13 +815,13 @@ static struct isl_vec *sample_with_cone(struct isl_basic_set *bset, cone_dim = total - cone->n_eq; M = isl_mat_sub_alloc(bset->ctx, cone->eq, 0, cone->n_eq, 1, total); - M = isl_mat_left_hermite(bset->ctx, M, 0, &U, NULL); + M = isl_mat_left_hermite(M, 0, &U, NULL); if (!M) goto error; - isl_mat_free(bset->ctx, M); + isl_mat_free(M); - U = isl_mat_lin_to_aff(bset->ctx, U); - bset = isl_basic_set_preimage(bset, isl_mat_copy(bset->ctx, U)); + U = isl_mat_lin_to_aff(U); + bset = isl_basic_set_preimage(bset, isl_mat_copy(U)); bounded = isl_basic_set_copy(bset); bounded = drop_constraints_involving(bounded, total - cone_dim, cone_dim); @@ -840,14 +830,14 @@ static struct isl_vec *sample_with_cone(struct isl_basic_set *bset, if (!sample || sample->size == 0) { isl_basic_set_free(bset); isl_basic_set_free(cone); - isl_mat_free(ctx, U); + isl_mat_free(U); return sample; } bset = plug_in(bset, isl_vec_copy(sample)); cone_sample = rational_sample(bset); - cone_sample = round_up_in_cone(cone_sample, cone, isl_mat_copy(ctx, U)); + cone_sample = round_up_in_cone(cone_sample, cone, isl_mat_copy(U)); sample = vec_concat(sample, cone_sample); - sample = isl_mat_vec_product(ctx, U, sample); + sample = isl_mat_vec_product(U, sample); return sample; error: isl_basic_set_free(cone); @@ -891,9 +881,9 @@ static struct isl_vec *pip_sample(struct isl_basic_set *bset) sample = isl_pip_basic_set_sample(bset); if (sample && sample->size != 0) - sample = isl_mat_vec_product(ctx, T, sample); + sample = isl_mat_vec_product(T, sample); else - isl_mat_free(ctx, T); + isl_mat_free(T); return sample; } diff --git a/isl_tab.c b/isl_tab.c index cb520a6c..c1af7f35 100644 --- a/isl_tab.c +++ b/isl_tab.c @@ -76,7 +76,7 @@ static int extend_cons(struct isl_ctx *ctx, struct isl_tab *tab, unsigned n_new) if (tab->mat->n_row < tab->n_row + n_new) { int *row_var; - tab->mat = isl_mat_extend(ctx, tab->mat, + tab->mat = isl_mat_extend(tab->mat, tab->n_row + n_new, tab->n_col); if (!tab->mat) return -1; @@ -115,7 +115,7 @@ void isl_tab_free(struct isl_ctx *ctx, struct isl_tab *tab) if (!tab) return; free_undo(ctx, tab); - isl_mat_free(ctx, tab->mat); + isl_mat_free(tab->mat); isl_vec_free(tab->dual); free(tab->var); free(tab->con); @@ -318,7 +318,7 @@ static void swap_rows(struct isl_ctx *ctx, tab->row_var[row2] = t; var_from_row(ctx, tab, row1)->index = row1; var_from_row(ctx, tab, row2)->index = row2; - tab->mat = isl_mat_swap_rows(ctx, tab->mat, row1, row2); + tab->mat = isl_mat_swap_rows(tab->mat, row1, row2); } static void push(struct isl_ctx *ctx, struct isl_tab *tab, @@ -757,7 +757,7 @@ static void swap_cols(struct isl_ctx *ctx, tab->col_var[col2] = t; var_from_col(ctx, tab, col1)->index = col1; var_from_col(ctx, tab, col2)->index = col2; - tab->mat = isl_mat_swap_cols(ctx, tab->mat, 2 + col1, 2 + col2); + tab->mat = isl_mat_swap_cols(tab->mat, 2 + col1, 2 + col2); } /* Mark column with index "col" as representing a zero variable. @@ -1870,7 +1870,7 @@ void isl_tab_dump(struct isl_ctx *ctx, struct isl_tab *tab, tab->mat->n_row = tab->n_row; c = tab->mat->n_col; tab->mat->n_col = 2 + tab->n_col; - isl_mat_dump(ctx, tab->mat, out, indent); + isl_mat_dump(tab->mat, out, indent); tab->mat->n_row = r; tab->mat->n_col = c; } -- 2.11.4.GIT