int main() { const int d = 10; // change this in order to experiment const int n = 100000; // change this in order to experiment // generate n random d-dimensional points in [0,1]^d CGAL::Random rd; std::vector<Point_d> points; for (int j =0; j<n; ++j) { std::vector<double> coords; for (int i=0; i<d; ++i) coords.push_back(rd.get_double()); points.push_back (Point_d (d, coords.begin(), coords.end())); } // benchmark all pricing strategies in turn CGAL::Quadratic_program_pricing_strategy strategy[] = { CGAL::QP_CHOOSE_DEFAULT, // QP_PARTIAL_FILTERED_DANTZIG CGAL::QP_DANTZIG, // Dantzig's pivot rule... CGAL::QP_PARTIAL_DANTZIG, // ... with partial pricing CGAL::QP_BLAND, // Bland's pivot rule CGAL::QP_FILTERED_DANTZIG, // Dantzig's filtered pivot rule... CGAL::QP_PARTIAL_FILTERED_DANTZIG // ... with partial pricing }; CGAL::Timer t; for (int i=0; i<6; ++i) { // test strategy i CGAL::Quadratic_program_options options; options.set_pricing_strategy (strategy[i]); t.reset(); t.start(); // is origin in convex hull of the points? (most likely, not) solve_convex_hull_containment_lp (Point_d (d, CGAL::ORIGIN), points.begin(), points.end(), ET(0), options); t.stop(); std::cout << "Time (s) = " << t.time() << std::endl; } return 0; }
void testcase() { int h, t; cin >> h >> t; vector<vector<vector<ET> > > powers; for (int j=0; j < h+t; j++) { vector<vector<ET> > var; for (int i=0; i < 3; i++) { vector<ET> row(31, -1); var.push_back(row); } powers.push_back(var); } for (int i=0; i < h; i++) { int x, y, z; cin >> x >> y >> z; powers[i][0][1] = x; powers[i][1][1] = y; powers[i][2][1] = z; } for (int i=0; i < t; i++) { int x, y, z; cin >> x >> y >> z; powers[h+i][0][1] = x; powers[h+i][1][1] = y; powers[h+i][2][1] = z; } if (t == 0 || h == 0) { cout << "0\n"; return; } int d; for (d=0; d <= 30; d += 5) { //cout << "try " << d << endl; Program qp (CGAL::LARGER, false, 0, false, 0); int var_ind = 0; for (int i=0; i < h; i++) { add_polynom(qp, d, i, powers); qp.set_b( i, -1); qp.set_r( i, CGAL::SMALLER); } for (int i=0; i < t; i++) { add_polynom(qp, d, h+i, powers); qp.set_b( h+i, 1); qp.set_r( h+i, CGAL::LARGER); } CGAL::Quadratic_program_options options; options.set_pricing_strategy(CGAL::QP_BLAND); Solution s = CGAL::solve_linear_program(qp, ET(), options); // Solution s = CGAL::solve_quadratic_program(qp, ET()); assert (s.solves_linear_program(qp)); if (s.status() != CGAL::QP_INFEASIBLE) { break; } } if (d <= 30) { for (; d >= 0; d--) { Program qp (CGAL::LARGER, false, 0, false, 0); int var_ind = 0; for (int i=0; i < h; i++) { add_polynom(qp, d, i, powers); qp.set_b( i, -1); qp.set_r( i, CGAL::SMALLER); } for (int i=0; i < t; i++) { add_polynom(qp, d, h+i, powers); qp.set_b( h+i, 1); qp.set_r( h+i, CGAL::LARGER); } CGAL::Quadratic_program_options options; options.set_pricing_strategy(CGAL::QP_BLAND); Solution s = CGAL::solve_linear_program(qp, ET(), options); // Solution s = CGAL::solve_quadratic_program(qp, ET()); assert (s.solves_linear_program(qp)); if (s.status() == CGAL::QP_INFEASIBLE) { cout << d+1 << endl; return; } } } cout << "Impossible!\n"; }
int main() { // print seed std::cout << "Random seed: " << rd.get_seed() << std::endl; // options CGAL::Quadratic_program_options options; options.set_auto_validation(true); // generate a set of small random qp's for (int i=0; i<tries; ++i) { // first choose dimensions int n = rd.get_int(1,max_dim); int m = rd.get_int(1,max_dim); // construct matrix D as C^T C, for C randomly chosen with n columns int k = rd.get_int (1, 2*n); // number of rows of C std::vector<std::vector<int> > C (k, std::vector<int>(n, 0)); for (int j=0; j<k+n; ++j) // sparse C C[rd.get_int(0, k)][rd.get_int(0,n)] = rd.get_int(-max_entry, max_entry); // now fill the program Program p; // A for (int j=0; j<n+m; ++j) p.set_a (rd.get_int(0,n), rd.get_int(0,m), rd.get_double()); // b, r for (int i=0; i<m/2; ++i) { p.set_b (rd.get_int(0,m), rd.get_double()); p.set_r (rd.get_int(0,m), random_rel()); } // fl, l, fu, u for (int j=0; j<n; ++j) { double l = rd.get_double(); double u = rd.get_double(); if (l > u) std::swap (l, u); p.set_l(j, rd.get_bool(), l); p.set_u(j, rd.get_bool(), u); } // D for (int i=0; i<n; ++i) for (int j=0; j<=i; ++j) { double entry = 0; for (int l=0; l<k; ++l) entry += C[l][i] * C[l][j]; p.set_d(i, j, entry); } // c for (int j=0; j<n/2; ++j) p.set_c (rd.get_int(0, n), rd.get_double()); // c0 p.set_c0(rd.get_double()); // solve it Solution s = CGAL::solve_quadratic_program (p, ET(), options); assert(s.is_valid()); statistics (s, qp_optimal, qp_infeasible, qp_unbounded); // also solve it as nqp, lp, nlp s = CGAL::solve_nonnegative_quadratic_program (p, ET(), options); assert(s.is_valid()); statistics (s, nqp_optimal, nqp_infeasible, nqp_unbounded); s = CGAL::solve_linear_program (p, ET(), options); assert(s.is_valid()); statistics (s, lp_optimal, lp_infeasible, lp_unbounded); s = CGAL::solve_nonnegative_linear_program (p, ET(), options); assert(s.is_valid()); statistics (s, nlp_optimal, nlp_infeasible, nlp_unbounded); } // output statistics std::cout << "Solved " << tries << " random QP / NQP / LP / NLP .\n" << " Optimal: " << qp_optimal << " / " << nqp_optimal << " / " << lp_optimal << " / " << nlp_optimal << "\n" << " Infeasible: " << qp_infeasible << " / " << nqp_infeasible << " / " << lp_infeasible << " / " << nlp_infeasible << "\n" << " Unbounded: " << qp_unbounded << " / " << nqp_unbounded << " / " << lp_unbounded << " / " << nlp_unbounded << std::endl; return 0; }
int main() { // print seed std::cout << "Random seed: " << rd.get_seed() << std::endl; // options CGAL::Quadratic_program_options options; options.set_auto_validation(true); // generate a set of small random qp's for (int i=0; i<tries; ++i) { int Ax[] = {random_signed(), random_signed()}; int Ay[] = {random_signed(), random_signed()}; int* A[] = {Ax, Ay}; int b[] = {random_signed(), random_signed()}; CGAL::Comparison_result r[] = {random_rel(), random_rel()}; bool fl[] = {rd.get_bool(), rd.get_bool()}; int l[] = {random_signed(),random_signed()}; bool fu[] = {rd.get_bool(), rd.get_bool()}; int u[] = {random_signed(),random_signed()}; // make sure that l<=u if (l[0] > u[0]) {int h = l[0]; l[0] = u[0]; u[0] = h;} if (l[1] > u[1]) {int h = l[1]; l[1] = u[1]; u[1] = h;} int D1[] = {random_unsigned()}; int D2[] = {0, random_unsigned()}; // can still change D_21 as long as D remains positive-semidefinite if (D1[0] < D2[1]) D2[0] = rd.get_int(-D1[0], D1[0]+1); else D2[0] = rd.get_int(-D2[1], D2[1]+1); assert(D1[0] * D2[1] >= D2[0] * D2[0]); int* D[] = {D1, D2}; int c[] = {random_signed(), random_signed()}; int c0 = random_signed(); // now construct the quadratic program; the first two parameters are // the number of variables and the number of constraints (rows of A) Program qp (2, 2, A, b, r, fl, l, fu, u, D, c, c0); // write/read it and check equality std::stringstream inout; CGAL::print_quadratic_program (inout, qp); CGAL::Quadratic_program_from_mps<int> qp2 (inout); assert(CGAL::QP_functions_detail::are_equal_qp (qp, qp2)); // solve it Solution s = CGAL::solve_quadratic_program (qp, ET(), options); assert(s.is_valid()); statistics (s, qp_optimal, qp_infeasible, qp_unbounded); // also solve it as nqp, lp, nlp s = CGAL::solve_nonnegative_quadratic_program (qp, ET(), options); assert(s.is_valid()); statistics (s, nqp_optimal, nqp_infeasible, nqp_unbounded); s = CGAL::solve_linear_program (qp, ET(), options); assert(s.is_valid()); statistics (s, lp_optimal, lp_infeasible, lp_unbounded); s = CGAL::solve_nonnegative_linear_program (qp, ET(), options); assert(s.is_valid()); statistics (s, nlp_optimal, nlp_infeasible, nlp_unbounded); } // output statistics std::cout << "Solved " << tries << " random QP / NQP / LP / NLP .\n" << " Optimal: " << qp_optimal << " / " << nqp_optimal << " / " << lp_optimal << " / " << nlp_optimal << "\n" << " Infeasible: " << qp_infeasible << " / " << nqp_infeasible << " / " << lp_infeasible << " / " << nlp_infeasible << "\n" << " Unbounded: " << qp_unbounded << " / " << nqp_unbounded << " / " << lp_unbounded << " / " << nlp_unbounded << std::endl; return 0; }
void algo() { int h,t; cin >> h >> t; vector<Cell> cells; cells.reserve(h + t); for (int i = 0; i < h + t; ++i) { int x,y,z; cin >> x >> y >> z; cells.PB(Cell(x,y,z)); } const int gamma = 0; bool sol = false; int var = gamma + 1; Program lp (CGAL::SMALLER, false, 0, false, 0); lp.set_u(gamma, true, 1); lp.set_c(gamma, -1); for(int i = 0; i < h + t; ++i) { lp.set_a(gamma, i, 1); } int degree = -1; while(degree < 9 && !sol) { ++degree; int varI = var; for(int he = 0; he < max(h,t); ++he) { var = varI; for(int i = 0; i <= degree; ++i) { for(int j = 0; j <= degree - i; ++j) { int l = degree - i - j; assert(l + i + j == degree); if(he < h) { double result = pow(cells[he].x, i) * pow(cells[he].y, j)* pow(cells[he].z, l); lp.set_a(var, he, result); } if(he < t) { double result = pow(cells[he + h].x, i) * pow(cells[he + h].y, j)* pow(cells[he + h].z, l); lp.set_a(var, he + h, -result); } ++var; } } } varI = var; CGAL::Quadratic_program_options options; options.set_pricing_strategy(CGAL::QP_BLAND); Solution s = CGAL::solve_linear_program(lp, ET(), options); assert (s.solves_linear_program(lp)); if(s.is_optimal() && s.objective_value() < 0) { sol = true; } } if(!sol) { int min_degree = degree = 10; int max_degree = 30; while(min_degree <= max_degree) { int d = (min_degree + max_degree) / 2; Program lp (CGAL::SMALLER, false, 0, false, 0); lp.set_u(gamma, true, 1); lp.set_c(gamma, -1); for(int i = 0; i < h + t; ++i) { lp.set_a(gamma, i, 1); } int varI = var; for(int he = 0; he < max(h,t); ++he) { var = 1; for(int k = 0; k <= d; ++k) { for(int i = 0; i <= k; ++i) { for(int j = 0; j <= k - i; ++j) { int l = k - i - j; assert(l + i + j == k); if(he < h) { double result = pow(cells[he].x, i) * pow(cells[he].y, j)* pow(cells[he].z, l); lp.set_a(var, he, result); } if(he < t) { double result = pow(cells[he + h].x, i) * pow(cells[he + h].y, j)* pow(cells[he + h].z, l); lp.set_a(var, he + h, -result); } ++var; } } } } // varI = var; CGAL::Quadratic_program_options options; options.set_pricing_strategy(CGAL::QP_BLAND); Solution s = CGAL::solve_linear_program(lp, ET(), options); assert (s.solves_linear_program(lp)); // cout << "Min degree " << min_degree << endl ; // cout << "Current degree " << d << " Min degree " << min_degree << endl; if(s.is_optimal() && s.objective_value() < 0) { sol = true; max_degree = d - 1; degree = d; } else { min_degree = d + 1; } } } if(!sol) { cout << "Impossible!\n"; } else { cout << degree << "\n"; } }