int main(int argc, char **argv) { int termcode; mpp_problem *mpp; sym_environment *env = sym_open_environment(); sym_version(); CALL_FUNCTION( sym_get_user_data(env, (void **)&mpp) ); CALL_FUNCTION( sym_parse_command_line(env, argc, argv) ); if(mpp->par.test){ mpp_test(env); } else { CALL_FUNCTION( sym_load_problem(env) ); CALL_FUNCTION( sym_find_initial_bounds(env) ); CALL_FUNCTION( sym_solve(env) ); } CALL_FUNCTION( sym_close_environment(env) ); return(0); }
int main(int argc, char **argv) { sym_environment *env = sym_open_environment(); sym_parse_command_line(env, argc, argv); sym_load_problem(env); sym_set_int_param(env, "sensitivity_analysis", TRUE); sym_solve(env); int ind[2]; double val[2]; ind[0] = 4; val[0] = 0; ind[1] = 7; val[1] = 0; double lb = 0.0, ub =0.0; sym_get_lb_for_new_rhs(env, 2, ind, val, &lb); // sym_get_ub_for_new_rhs(env, 2, ind, val, &ub); printf("\nBounds for the new rhs:\n lb: %f\n ub: %f \n\n", lb, ub); sym_close_environment(env); return(0); }
int main(int argc, char **argv) { sym_environment *env = sym_open_environment(); sym_parse_command_line(env, argc, argv); sym_load_problem(env); sym_set_int_param(env, "keep_warm_start", true); sym_set_int_param(env, "find_first_feasible", true); /* set node selection rule to DEPTH_FIRST_SEARCH */ sym_set_int_param(env, "node_selection_rule", 3); sym_solve(env); sym_set_int_param(env, "find_first_feasible", true); /* set node selection rule to BEST_FIRST_SEARCH */ sym_set_int_param(env, "node_selection_rule", 4); sym_warm_solve(env); sym_close_environment(env); return(0); }
int main(int argc, char **argv) { int num_solutions, num_cols, i; double *sol, objval; sym_environment *env = sym_open_environment(); sym_parse_command_line(env, argc, argv); sym_load_problem(env); sym_solve(env); sym_get_num_cols(env, &num_cols); sym_get_sp_size(env, &num_solutions); sol = (double *) malloc(num_cols*sizeof(double)); for (i = 0; i < num_solutions; i++){ sym_get_sp_solution(env, i, sol, &objval); printf("Solution of value %f found\n", objval); } free(sol); sym_close_environment(env); return(0); }
int main(int argc, char **argv) { sym_environment *env = sym_open_environment(); warm_start_desc * ws; sym_parse_command_line(env, argc, argv); sym_load_problem(env); sym_set_int_param(env, "keep_warm_start", TRUE); sym_set_int_param(env, "node_limit", -1); sym_set_int_param(env, "do_reduced_cost_fixing", 0); sym_solve(env); ws = sym_get_warm_start(env, true); sym_set_int_param(env, "node_limit", 1000); sym_warm_solve(env); sym_set_obj_coeff(env, 0, 1); sym_set_obj_coeff(env, 200, 150); sym_set_warm_start(env, ws); sym_warm_solve(env); sym_close_environment(env); return(0); }
int mpp_test(sym_environment *env) { int termcode, i, file_num = 1; char input_files[2][MAX_FILE_NAME_LENGTH +1] = {"sample.mpp"}; double sol[1] = {70.00}; char *input_dir = (char*)malloc(CSIZE*(MAX_FILE_NAME_LENGTH+1)); char *infile = (char*)malloc(CSIZE*(MAX_FILE_NAME_LENGTH+1)); double *obj_val = (double *)calloc(DSIZE,file_num); double tol = 1e-03; mpp_problem *mpp = (mpp_problem *) env->user; if (strcmp(mpp->par.test_dir, "") == 0){ strcpy(input_dir, "."); } else{ strcpy(input_dir, mpp->par.test_dir); } sym_set_int_param(env, "verbosity", -10); for(i = 0; i<file_num; i++){ strcpy(infile, ""); sprintf(infile, "%s%s%s", input_dir, "/", input_files[i]); strcpy(mpp->par.infile, infile); CALL_FUNCTION( sym_load_problem(env) ); printf("Solving %s...\n", input_files[i]); CALL_FUNCTION( sym_solve(env) ); sym_get_obj_val(env, &obj_val[i]); if((obj_val[i] < sol[i] + tol) && (obj_val[i] > sol[i] - tol)){ printf("Success!\n"); } else { printf("Failure!(%f, %f) \n", obj_val[i], sol[i]); } if(env->mip->n && i + 1 < file_num){ free_master_u(env); strcpy(env->par.infile, ""); env->mip = (MIPdesc *) calloc(1, sizeof(MIPdesc)); } } mpp->par.test = FALSE; FREE(input_dir); FREE(infile); FREE(obj_val); return(0); }
int main(int argc, char **argv) { sym_environment *env = sym_open_environment(); sym_parse_command_line(env, argc, argv); sym_load_problem(env); sym_set_obj2_coeff(env, 1, -1); sym_mc_solve(env); sym_close_environment(env); return(0); }
int main(int argc, char **argv) { #if USE_VRPH // A few things required by VRPH int i; double best_sol=VRP_INFINITY; int best_sol_buff[500]; #endif vrp_problem *vrp; sym_environment *env = sym_open_environment(); version(); sym_parse_command_line(env, argc, argv); sym_get_user_data(env, (void**)&vrp); #if USE_VRPH // Get the size of the problem in the input file int n=VRPGetDimension(vrp->par.infile); // Declare a VRP object of size n VRP V(n); // Declare a ClarkeWright object of size n ClarkeWright CW(n); // Populate the VRP object with the input file V.read_TSPLIB_file(vrp->par.infile); // Now create NUM_VRPH_SOLUTIONS solutions using VRPH and set the // upper bound to the best solution discovered for(i=0;i<NUM_VRPH_SOLUTIONS;i++) { // Create default routes - each customer on its own route V.create_default_routes(); // Create a new random feasible solution with Clarke Wright CW.Construct(&V, .5+ lcgrand(1),false); // Improve it with the RTR heuristic V.RTR_solve(ONE_POINT_MOVE+TWO_POINT_MOVE+TWO_OPT+THREE_OPT, 30,5,1,.01,25,VRPH_LI_PERTURB,VRPH_BEST_ACCEPT,false); if(V.get_total_route_length()-V.get_total_service_time()<best_sol) { best_sol=V.get_total_route_length()-V.get_total_service_time(); V.export_canonical_solution_buff(best_sol_buff); } // Reset VRPH's internal data structures V.reset(); } // Import the best solution and display it - if SYMPHONY claims an infeasibility // because the VRPH solution is optimal, we wouldn't see it otherwise! printf("VRPH set SYMPHONY upper bound to %f based on solution:\n",best_sol); V.import_solution_buff(best_sol_buff); V.summary(); // Set the upper bound using VRPH solution by accessing SYMPHONY's // internal data structures env->has_ub=1; env->ub=best_sol ; #if 0 // Note that this might be incorrect if the VRPH solution is not optimal // So the # of trucks still needs to be passed in on the command line! vrp->numroutes=V.get_total_number_of_routes(); #endif #endif // Now just let SYMPHONY do its thing. If an infeasibility is encountered, // then this certifies that the solution found by VRPH is indeed optimal // Note that the par.test will not work as we have processed only a single // file. Thus, we changed the following line // if (vrp->par.test){ if (0 && vrp->par.test){ vrp_test(env, argc, argv); } else { sym_load_problem(env); sym_find_initial_bounds(env); sym_set_str_param(env, "lp_executable_name", "vrp_lp_cg"); sym_set_str_param(env, "cp_executable_name", "vrp_cp"); sym_set_int_param(env, "generate_cgl_cuts", FALSE); sym_solve(env); } sym_close_environment(env); return(0); }
int vrp_test(sym_environment *env, int argc, char **argv) { int termcode, i, file_num = 34; char input_files[34][MAX_FILE_NAME_LENGTH +1] = {"A/A-n34-k5", "A/A-n32-k5", "A/A-n33-k5", "E/E-n13-k4", "E/E-n22-k4", "E/E-n23-k3", "E/E-n30-k3", "E/E-n33-k4", "V/att-n48-k4", "E/E-n51-k5", "A/A-n33-k6", "A/A-n36-k5", "A/A-n37-k5", "A/A-n38-k5", "A/A-n39-k5", "A/A-n39-k6", "A/A-n45-k6", "A/A-n46-k7", "B/B-n31-k5", "B/B-n34-k5", "B/B-n35-k5", "B/B-n38-k6", "B/B-n39-k5", "B/B-n41-k6", "B/B-n43-k6", "B/B-n44-k7", "B/B-n45-k5", "B/B-n50-k7", "B/B-n51-k7", "B/B-n52-k7", "B/B-n56-k7", "B/B-n64-k9", "A/A-n48-k7", "A/A-n53-k7"}; double sol[34] = {778, 784, 661, 247, 375, 569, 534, 835, 40002, 521, 742, 799, 669, 730, 822, 831, 944, 914, 672, 788, 955, 805, 549, 829, 742, 909, 751, 741, 1032, 747, 707, 861, 1073, 1010}; char *input_dir = (char*)malloc(CSIZE*(MAX_FILE_NAME_LENGTH+1)); char *infile = (char*)malloc(CSIZE*(MAX_FILE_NAME_LENGTH+1)); char *sgfile = (char*)malloc(CSIZE*(MAX_FILE_NAME_LENGTH+1)); double *obj_val = (double *)calloc(DSIZE,file_num); double tol = 1e-06, ub; vrp_problem *vrp = (vrp_problem *) env->user; if (strcmp(vrp->par.test_dir, "") == 0){ strcpy(input_dir, "../../../VRPLIB"); } else{ strcpy(input_dir, vrp->par.test_dir); } for(i = 0; i<file_num; i++){ strcpy(infile, ""); strcpy(sgfile, ""); sprintf(infile, "%s%s%s%s", input_dir, "/", input_files[i], ".vrp"); sprintf(sgfile, "%s%s%s", "./small_graph/", input_files[i], ".sg"); strcpy(vrp->par.infile, infile); strcpy(vrp->par.small_graph_file, sgfile); vrp->par.use_small_graph = LOAD_SMALL_GRAPH; sym_load_problem(env); sym_find_initial_bounds(env); printf("Solving %s...\n", input_files[i]); sym_solve(env); sym_get_obj_val(env, &obj_val[i]); if((obj_val[i] < sol[i] + tol) && (obj_val[i] > sol[i] - tol)){ printf("Success!\n"); } else { printf("Failure!(%f, %f) \n", obj_val[i], sol[i]); } if(i+1 < file_num){ sym_close_environment(env); env = sym_open_environment(); sym_parse_command_line(env, argc, argv); } } return (0); }