// Init void init_solver (void) { context = isl_ctx_alloc (); isl_space * vars = isl_space_set_alloc (context, 0, v_nb ()); ls = isl_local_space_from_space (isl_space_copy (vars)); solutions = isl_set_universe (vars); solution = 0; next_max_var = 0; }
Param_Polyhedron *ISL_P2PP(Polyhedron *P, Polyhedron *C, struct barvinok_options *options) { int i, j; isl_ctx *ctx = isl_ctx_alloc(); isl_space *dim; isl_basic_set *bset, *context; isl_vertices *vertices; unsigned nparam = C->Dimension; unsigned nvar = P->Dimension - nparam; Param_Polyhedron *PP = isl_calloc_type(ctx, Param_Polyhedron); Param_Vertices **next_V; struct bv_add_chamber_data data; dim = isl_space_set_alloc(ctx, nparam, nvar); bset = isl_basic_set_new_from_polylib(P, dim); dim = isl_space_set_alloc(ctx, nparam, 0); context = isl_basic_set_new_from_polylib(C, dim); bset = isl_basic_set_intersect(bset, context); vertices = isl_basic_set_compute_vertices(bset); isl_basic_set_free(bset); PP->Rays = NULL; PP->nbV = isl_vertices_get_n_vertices(vertices); PP->Constraints = Polyhedron2Constraints(P); next_V = &PP->V; isl_vertices_foreach_vertex(vertices, &add_vertex, &next_V); data.next_D = &PP->D; data.vertex_len = (PP->nbV + INT_BITS - 1)/INT_BITS; isl_vertices_foreach_cell(vertices, &add_chamber, &data); isl_vertices_free(vertices); isl_ctx_free(ctx); return PP; }
enum lp_result isl_constraints_opt(Matrix *C, Value *obj, Value denom, enum lp_dir dir, Value *opt) { int i; isl_ctx *ctx = isl_ctx_alloc(); isl_space *dim; isl_local_space *ls; isl_mat *eq, *ineq; isl_basic_set *bset; isl_aff *aff; isl_val *v; enum isl_lp_result res; int max = dir == lp_max; eq = extract_equalities(ctx, C); ineq = extract_inequalities(ctx, C); dim = isl_space_set_alloc(ctx, 0, C->NbColumns - 2); ls = isl_local_space_from_space(isl_space_copy(dim)); bset = isl_basic_set_from_constraint_matrices(dim, eq, ineq, isl_dim_set, isl_dim_div, isl_dim_param, isl_dim_cst); aff = isl_aff_zero_on_domain(ls); for (i = 0; i < C->NbColumns - 2; ++i) { v = isl_val_int_from_gmp(ctx, obj[i]); aff = isl_aff_set_coefficient_val(aff, isl_dim_in, i, v); } v = isl_val_int_from_gmp(ctx, obj[C->NbColumns - 2]); aff = isl_aff_set_constant_val(aff, v); v = isl_val_int_from_gmp(ctx, denom); aff = isl_aff_scale_down_val(aff, v); if (max) v = isl_val_floor(isl_basic_set_max_lp_val(bset, aff)); else v = isl_val_ceil(isl_basic_set_min_lp_val(bset, aff)); if (!v) res = isl_lp_error; else if (isl_val_is_nan(v)) res = isl_lp_empty; else if (!isl_val_is_rat(v)) res = isl_lp_unbounded; else { res = isl_lp_ok; isl_val_get_num_gmp(v, *opt); } isl_val_free(v); isl_aff_free(aff); isl_basic_set_free(bset); isl_ctx_free(ctx); return isl_lp_result2lp_result(res); }
static isl_map* build_schedule (scoplib_scop_p scop, scoplib_statement_p s, isl_space* sp, isl_ctx* ctxt) { // Set up the space. isl_space* space_in = isl_space_domain (isl_space_copy (sp)); int dout = s->schedule->NbRows; isl_space* space_out = isl_space_set_alloc(ctxt, scop->nb_parameters, dout); int i; char buffer[32]; char* name; for (i = 0; i < dout; ++i) { sprintf (buffer, "t%d", i); name = strdup (buffer); space_out = isl_space_set_dim_name (space_out, isl_dim_set, i, name); } for (i = 0; i < scop->nb_parameters; ++i) { name = strdup (((SgVariableSymbol*)(scop->parameters[i]))->get_name().str()); space_out = isl_space_set_dim_name (space_out, isl_dim_param, i, name); } isl_space* space = isl_space_map_from_domain_and_range (isl_space_copy (space_in), isl_space_copy (space_out)); isl_map* ret = isl_map_universe (isl_space_copy (space)); isl_val* tmp = isl_val_int_from_si (ctxt, 0); scoplib_matrix_p m = s->schedule; for (i = 0; i < m->NbRows; ++i) { isl_local_space* ls = isl_local_space_from_space (isl_space_copy (space)); isl_constraint* cst; if (SCOPVAL_get_si(m->p[i][0]) == 0) cst = isl_equality_alloc (isl_local_space_copy (ls)); else cst = isl_inequality_alloc (isl_local_space_copy (ls)); // Set input dimensions. int k; for (k = 0; k < s->nb_iterators; ++k) { tmp = isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][k+1])); cst = isl_constraint_set_coefficient_val (cst, isl_dim_in, k, isl_val_copy (tmp)); } for (k = 0; k < scop->nb_parameters; ++k) { tmp = isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][k+1+s->nb_iterators])); cst = isl_constraint_set_coefficient_val (cst, isl_dim_param, k, isl_val_copy (tmp)); } tmp = isl_val_set_si (tmp, SCOPVAL_get_si(m->p[i][m->NbColumns - 1])); cst = isl_constraint_set_constant_val (cst, isl_val_copy (tmp)); // Set output dimension. tmp = isl_val_set_si (tmp, -1); isl_constraint_set_coefficient_val (cst, isl_dim_out, i, isl_val_copy (tmp)); // Insert constraint. ret = isl_map_add_constraint (ret, cst); } isl_val_free (tmp); return ret; }
enum order_sign isl_polyhedron_affine_sign(Polyhedron *D, Matrix *T, struct barvinok_options *options) { int i; isl_ctx *ctx = isl_ctx_alloc(); isl_space *dim; isl_local_space *ls; isl_aff *aff; isl_basic_set *bset; isl_val *min, *max = NULL; isl_val *v; enum order_sign sign = order_undefined; assert(D->Dimension == T->NbColumns - 1); dim = isl_space_set_alloc(ctx, 0, D->Dimension); ls = isl_local_space_from_space(isl_space_copy(dim)); bset = isl_basic_set_new_from_polylib(D, dim); aff = isl_aff_zero_on_domain(ls); for (i = 0; i < D->Dimension; ++i) { v = isl_val_int_from_gmp(ctx, T->p[0][i]); aff = isl_aff_set_coefficient_val(aff, isl_dim_in, i, v); } v = isl_val_int_from_gmp(ctx, T->p[0][D->Dimension]); aff = isl_aff_set_constant_val(aff, v); v = isl_val_int_from_gmp(ctx, T->p[1][D->Dimension]); aff = isl_aff_scale_down_val(aff, v); min = isl_basic_set_min_lp_val(bset, aff); min = isl_val_ceil(min); assert(min); if (isl_val_is_nan(min)) sign = order_undefined; else if (isl_val_is_pos(min)) sign = order_gt; else { max = isl_basic_set_max_lp_val(bset, aff); max = isl_val_floor(max); assert(max); if (isl_val_is_neg(max)) sign = order_lt; else if (isl_val_is_zero(min) && isl_val_is_zero(max)) sign = order_eq; else if (isl_val_is_zero(min)) sign = order_ge; else if (isl_val_is_zero(max)) sign = order_le; else sign = order_unknown; } isl_basic_set_free(bset); isl_aff_free(aff); isl_val_free(min); isl_val_free(max); isl_ctx_free(ctx); return sign; }
int main(int argc, char **argv) { isl_ctx *ctx; int i, nbPol, nbVec, nbMat, func, j, n; Polyhedron *A, *B, *C, *D, *E, *F, *G; char s[128]; struct barvinok_options *options = barvinok_options_new_with_defaults(); argc = barvinok_options_parse(options, argc, argv, ISL_ARG_ALL); ctx = isl_ctx_alloc_with_options(&barvinok_options_args, options); nbPol = nbVec = nbMat = 0; fgets(s, 128, stdin); while ((*s=='#') || ((sscanf(s, "D %d", &nbPol) < 1) && (sscanf(s, "V %d", &nbVec) < 1) && (sscanf(s, "M %d", &nbMat) < 1))) fgets(s, 128, stdin); for (i = 0; i < nbPol; ++i) { Matrix *M = Matrix_Read(); A = Constraints2Polyhedron(M, options->MaxRays); Matrix_Free(M); fgets(s, 128, stdin); while ((*s=='#') || (sscanf(s, "F %d", &func)<1)) fgets(s, 128, stdin); switch(func) { case 0: { Value cb, ck; value_init(cb); value_init(ck); fgets(s, 128, stdin); /* workaround for apparent bug in older gmps */ *strchr(s, '\n') = '\0'; while ((*s=='#') || (value_read(ck, s) != 0)) { fgets(s, 128, stdin); /* workaround for apparent bug in older gmps */ *strchr(s, '\n') = '\0'; } barvinok_count_with_options(A, &cb, options); if (value_ne(cb, ck)) return -1; value_clear(cb); value_clear(ck); break; } case 1: Polyhedron_Print(stdout, P_VALUE_FMT, A); B = Polyhedron_Polar(A, options->MaxRays); Polyhedron_Print(stdout, P_VALUE_FMT, B); C = Polyhedron_Polar(B, options->MaxRays); Polyhedron_Print(stdout, P_VALUE_FMT, C); Polyhedron_Free(C); Polyhedron_Free(B); break; case 2: Polyhedron_Print(stdout, P_VALUE_FMT, A); for (j = 0; j < A->NbRays; ++j) { B = supporting_cone(A, j); Polyhedron_Print(stdout, P_VALUE_FMT, B); Polyhedron_Free(B); } break; case 3: Polyhedron_Print(stdout, P_VALUE_FMT, A); C = B = NULL; barvinok_decompose(A,&B,&C); puts("Pos:"); Polyhedron_Print(stdout, P_VALUE_FMT, B); puts("Neg:"); Polyhedron_Print(stdout, P_VALUE_FMT, C); Domain_Free(B); Domain_Free(C); break; case 4: { Value cm, cb; struct tms tms_before, tms_between, tms_after; value_init(cm); value_init(cb); Polyhedron_Print(stdout, P_VALUE_FMT, A); times(&tms_before); manual_count(A, &cm); times(&tms_between); barvinok_count(A, &cb, 100); times(&tms_after); printf("manual: "); value_print(stdout, P_VALUE_FMT, cm); puts(""); time_diff(&tms_before, &tms_between); printf("Barvinok: "); value_print(stdout, P_VALUE_FMT, cb); puts(""); time_diff(&tms_between, &tms_after); value_clear(cm); value_clear(cb); break; } case 5: Polyhedron_Print(stdout, P_VALUE_FMT, A); B = triangulate_cone(A, 100); Polyhedron_Print(stdout, P_VALUE_FMT, B); check_triangulization(A, B); Domain_Free(B); break; case 6: Polyhedron_Print(stdout, P_VALUE_FMT, A); B = remove_equalities(A, options->MaxRays); Polyhedron_Print(stdout, P_VALUE_FMT, B); Polyhedron_Free(B); break; case 8: { evalue *EP; Matrix *M = Matrix_Read(); const char **param_name; C = Constraints2Polyhedron(M, options->MaxRays); Matrix_Free(M); Polyhedron_Print(stdout, P_VALUE_FMT, A); Polyhedron_Print(stdout, P_VALUE_FMT, C); EP = barvinok_enumerate_with_options(A, C, options); param_name = Read_ParamNames(stdin, C->Dimension); print_evalue(stdout, EP, (const char**)param_name); evalue_free(EP); Polyhedron_Free(C); } case 9: Polyhedron_Print(stdout, P_VALUE_FMT, A); Polyhedron_Polarize(A); C = B = NULL; barvinok_decompose(A,&B,&C); for (D = B; D; D = D->next) Polyhedron_Polarize(D); for (D = C; D; D = D->next) Polyhedron_Polarize(D); puts("Pos:"); Polyhedron_Print(stdout, P_VALUE_FMT, B); puts("Neg:"); Polyhedron_Print(stdout, P_VALUE_FMT, C); Domain_Free(B); Domain_Free(C); break; case 10: { evalue *EP; Value cb, ck; value_init(cb); value_init(ck); fgets(s, 128, stdin); sscanf(s, "%d", &n); for (j = 0; j < n; ++j) { Polyhedron *P; M = Matrix_Read(); P = Constraints2Polyhedron(M, options->MaxRays); Matrix_Free(M); A = DomainConcat(P, A); } fgets(s, 128, stdin); /* workaround for apparent bug in older gmps */ *strchr(s, '\n') = '\0'; while ((*s=='#') || (value_read(ck, s) != 0)) { fgets(s, 128, stdin); /* workaround for apparent bug in older gmps */ *strchr(s, '\n') = '\0'; } C = Universe_Polyhedron(0); EP = barvinok_enumerate_union(A, C, options->MaxRays); value_set_double(cb, compute_evalue(EP, &ck)+.25); if (value_ne(cb, ck)) return -1; Domain_Free(C); value_clear(cb); value_clear(ck); evalue_free(EP); break; } case 11: { isl_space *dim; isl_basic_set *bset; isl_pw_qpolynomial *expected, *computed; unsigned nparam; expected = isl_pw_qpolynomial_read_from_file(ctx, stdin); nparam = isl_pw_qpolynomial_dim(expected, isl_dim_param); dim = isl_space_set_alloc(ctx, nparam, A->Dimension - nparam); bset = isl_basic_set_new_from_polylib(A, dim); computed = isl_basic_set_lattice_width(bset); computed = isl_pw_qpolynomial_sub(computed, expected); if (!isl_pw_qpolynomial_is_zero(computed)) return -1; isl_pw_qpolynomial_free(computed); break; } case 12: { Vector *sample; int has_sample; fgets(s, 128, stdin); sscanf(s, "%d", &has_sample); sample = Polyhedron_Sample(A, options); if (!sample && has_sample) return -1; if (sample && !has_sample) return -1; if (sample && !in_domain(A, sample->p)) return -1; Vector_Free(sample); } } Domain_Free(A); } for (i = 0; i < nbVec; ++i) { int ok; Vector *V = Vector_Read(); Matrix *M = Matrix_Alloc(V->Size, V->Size); Vector_Copy(V->p, M->p[0], V->Size); ok = unimodular_complete(M, 1); assert(ok); Matrix_Print(stdout, P_VALUE_FMT, M); Matrix_Free(M); Vector_Free(V); } for (i = 0; i < nbMat; ++i) { Matrix *U, *V, *S; Matrix *M = Matrix_Read(); Smith(M, &U, &V, &S); Matrix_Print(stdout, P_VALUE_FMT, U); Matrix_Print(stdout, P_VALUE_FMT, V); Matrix_Print(stdout, P_VALUE_FMT, S); Matrix_Free(M); Matrix_Free(U); Matrix_Free(V); Matrix_Free(S); } isl_ctx_free(ctx); return 0; }