enum isl_lp_result isl_pip_solve_lp(struct isl_basic_map *bmap, int maximize, isl_int *f, isl_int denom, isl_int *opt, isl_int *opt_denom, struct isl_vec **vec) { enum isl_lp_result res = isl_lp_ok; PipMatrix *domain = NULL; PipOptions *options; PipQuast *sol; unsigned total; total = isl_basic_map_total_dim(bmap); domain = isl_basic_map_to_pip(bmap, 0, 1, 0); if (!domain) goto error; entier_set_si(domain->p[0][1], -1); isl_int_set(domain->p[0][domain->NbColumns - 1], f[0]); isl_seq_cpy_to_pip(domain->p[0]+2, f+1, total); options = pip_options_init(); if (!options) goto error; options->Urs_unknowns = -1; options->Maximize = maximize; options->Nq = 0; sol = pip_solve(domain, NULL, -1, options); pip_options_free(options); if (!sol) goto error; if (vec) { isl_ctx *ctx = isl_basic_map_get_ctx(bmap); *vec = isl_vec_alloc(ctx, 1 + total); } if (vec && !*vec) res = isl_lp_error; else if (!sol->list) res = isl_lp_empty; else if (entier_zero_p(sol->list->vector->the_deno[0])) res = isl_lp_unbounded; else copy_solution(*vec, maximize, opt, opt_denom, sol); pip_matrix_free(domain); pip_quast_free(sol); return res; error: if (domain) pip_matrix_free(domain); return isl_lp_error; }
static PipOptions *options_read(FILE *f) { char s[1024]; PipOptions *options = pip_options_init(); while (fgets(s, 1024, f)) { if (strncasecmp(s, "Maximize", 8) == 0) options->Maximize = 1; if (strncasecmp(s, "Urs_parms", 9) == 0) options->Urs_parms = 1; if (strncasecmp(s, "Urs_unknowns", 12) == 0) options->Urs_unknowns = 1; if (strncasecmp(s, "Rational", 8) == 0) options->Nq = 0; if (strncasecmp(s, "Dual", 4) == 0) options->Compute_dual = 1; } return options; }
int pip_has_rational_point(osl_relation_p system, osl_relation_p context, int conservative) { // FIXME : compatibility with osl //#ifdef CANDL_HAS_PIPLIB_HYBRID // return piplib_hybrid_has_rational_point(system, context, conservative); //#else PipOptions* options; int ret = 0; options = pip_options_init (); options->Simplify = 1; options->Urs_parms = -1; options->Urs_unknowns = -1; options->Nq = 0; PipQuast* solution = pip_solve_osl(system, context, -1, options); if ((solution != NULL) && ((solution->list != NULL) || (solution->condition != NULL))) ret = 1; pip_options_free(options); pip_quast_free(solution); return ret; //#endif }
int pip_has_rational_point(PipMatrix* system, PipMatrix* context, int conservative) { #ifdef CANDL_HAS_PIPLIB_HYBRID return piplib_hybrid_has_rational_point(system, context, conservative); #else PipOptions* options; int ret = 0; options = pip_options_init (); options->Simplify = 1; options->Urs_parms = -1; options->Urs_unknowns = -1; options->Nq = 0; PipQuast* solution = pip_solve (system, context, -1, options); if ((solution != NULL) && ((solution->list != NULL) || (solution->condition != NULL))) ret = 1; pip_options_free (options); pip_quast_free (solution); return ret; #endif }
/** * candl_ddv_constant_val: returns true iff all possible values of the * minimization of the first variable of the system is a scalar constant * (not parametric), and has the same value for all conditions of the QUAST. * The scalar constant is put in the 'val' argument. * */ static int candl_ddv_constant_val(CandlMatrix* system, int* val, int nb_par) { PipOptions * options; PipQuast * solution; int is_constant_val = 1; int cst; int cst_base = 42; int first = 1; int i, j; // 1- Comute the lexmin of the system, to get a QUAST. options = pip_options_init(); options->Simplify = 1; options->Urs_parms = -1; options->Urs_unknowns = -1; options->Nq = 0; CandlMatrix* context = candl_matrix_malloc(0, nb_par + 2); solution = pip_solve(system, context, -1, options); if ((solution != NULL) && ((solution->list != NULL) || (solution->condition != NULL))) { // 2- Traverse all leaves, ensure they have the same value. int nb_leaves = count_quast_leaves(solution); PipList* leaveslist[nb_leaves + 1]; for (i = 0; i < nb_leaves + 1; ++i) leaveslist[i] = NULL; get_quast_leaves(solution, leaveslist); for (i = 0; i < nb_leaves; ++i) { PipList* list = leaveslist[i]; if (list && list->vector) { PipVector* vect = list->vector; for (j = 0; j < nb_par; ++j) if (CANDL_get_si(vect->the_vector[j]) != 0) { is_constant_val = 0; break; } if (is_constant_val) { cst = CANDL_get_si(vect->the_vector[vect->nb_elements - 1]); if (first) { first = 0; cst_base = cst; } else if (! first && cst != cst_base) { is_constant_val = 0; break; } } else break; } } } pip_quast_free(solution); pip_options_free(options); candl_matrix_free(context); if (is_constant_val) *val = cst_base; return is_constant_val; }