void CplexAdapterBase::Reset() { /* Free up the problem as allocated by CPXNETcreateprob, if necessary */ if ( net_ != NULL ) { status_ = CPXNETfreeprob (env_, &net_); if ( status_ ) { fprintf (stderr, "CPXNETfreeprob failed, error code %d.\n", status_); } } /* Free up the CPLEX environment, if necessary */ if ( env_ != NULL ) { status_ = CPXcloseCPLEX (&env_); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPX_PARAM_SCRIND indicator is set to CPX_ON. */ if ( status_ ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env_, status_, errmsg); fprintf (stderr, "%s", errmsg); } } }
void IPTerminate() { int status; /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { printf ("CPXfreeprob failed, error code %d.\n", status); getch(); exit(-1); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; printf ("Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); printf ("%s", errmsg); getch(); exit(-1); } } }
void cleanup(void) { mexPrintf("MEX-file (lp_cplex_MEX.c) is terminating, clearing memory\n"); CPXfreeprob(env,&lp); CPXcloseCPLEX(&env); initialized = 0; }
void CplexSolver::freeLp() { if (_env != NULL) { CPXcloseCPLEX(&_env); _env = NULL; } if (_prob != NULL) { CPXfreeprob(_env, &_prob); _prob = NULL; } }
//******************************************************************* CSolver:: ~CSolver() { FreeSolutionArrays(); if ( m_bCreated ) { CPXflushstdchannels(m_env); CPXfreeprob(m_env,&m_lp); char buff[30]; m_log.getTimeStamp(buff); CPXmsg(m_cpxlog, "\n%s : %s", "*** End Log ***", buff ); CPXfclose( m_cpxFile ); CPXcloseCPLEX(&m_env); //m_log.write("In destructor"); } }
long CplexData::Delete() { if(lp != NULL) { CPXfreeprob(env, &lp); } if(env != NULL) { CPXcloseCPLEX(&env); } if(cpxfileptr != NULL) { CPXfclose(cpxfileptr); } ClearStructure(); return 0; }
int CPLEXCleanup() { int Status = 0; if (CPLEXModel != NULL) { if (CPLEXClearSolver() != SUCCESS) { return FAIL; } } if (CPLEXenv != NULL) { Status = CPXcloseCPLEX (&CPLEXenv); if (Status) { FErrorFile() << "Could not close CPLEX environment." << endl; FlushErrorFile(); return FAIL; } } return SUCCESS; }
int main (void) { char probname[16]; /* Problem name is max 16 characters */ /* Declare and allocate space for the variables and arrays where we will store the optimization results including the status, objective value, variable values, dual values, row slacks and variable reduced costs. */ int solstat; double objval; double x[NUMCOLS]; double pi[NUMROWS]; double slack[NUMROWS]; double dj[NUMCOLS]; CPXENVptr env = NULL; CPXLPptr lp = NULL; int status; int i, j; int cur_numrows, cur_numcols; /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. The error message will be printed at the end of the program. */ if ( env == NULL ) { fprintf (stderr, "Could not open CPLEX environment.\n"); goto TERMINATE; } /* Turn *off* output to the screen since we'll be producing it via the callback function. This also means we won't see any CPLEX generated errors, but we'll handle that at the end of the program. */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_OFF); if ( status ) { fprintf (stderr, "Failure to turn off screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem. */ strcpy (probname, "example"); lp = CPXcreateprob (env, &status, probname); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, we wouldn't see an error message from CPXcreateprob since we turned off the CPXPARAM_ScreenOutput parameter above. The only way to see this message would be to use the CPLEX message handler, but that clutters up the simplicity of this example, which has a point of illustrating the CPLEX callback functionality. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now populate the problem with the data. */ status = populatebycolumn (env, lp); if ( status ) { fprintf (stderr, "Failed to populate problem data.\n"); goto TERMINATE; } status = CPXsetlpcallbackfunc (env, mycallback, NULL); if ( status ) { fprintf (stderr, "Failed to set callback function.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ status = CPXsetintparam (env, CPXPARAM_LPMethod, CPX_ALG_PRIMAL); if ( status ) { fprintf (stderr, "Failed to set the optimization method, error %d.\n", status); goto TERMINATE; } status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize LP.\n"); goto TERMINATE; } /* Turn off the callback function. This isn't strictly necessary, but is good practice. Note that the cast in front of NULL is only necessary for some compilers. */ status = CPXsetlpcallbackfunc (env, (int (CPXPUBLIC *)(CPXCENVptr, void *, int, void *)) NULL, NULL); if ( status ) { fprintf (stderr, "Failed to turn off callback function.\n"); goto TERMINATE; } status = CPXsolution (env, lp, &solstat, &objval, x, pi, slack, dj); if ( status ) { fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write the output to the screen. */ printf ("\nSolution status = %d\n", solstat); printf ("Solution value = %f\n\n", objval); /* The size of the problem should be obtained by asking CPLEX what the actual size is, rather than using sizes from when the problem was built. cur_numrows and cur_numcols store the current number of rows and columns, respectively. */ cur_numrows = CPXgetnumrows (env, lp); cur_numcols = CPXgetnumcols (env, lp); for (i = 0; i < cur_numrows; i++) { printf ("Row %d: Slack = %10f Pi = %10f\n", i, slack[i], pi[i]); } for (j = 0; j < cur_numcols; j++) { printf ("Column %d: Value = %10f Reduced cost = %10f\n", j, x[j], dj[j]); } /* Finally, write a copy of the problem to a file. */ status = CPXwriteprob (env, lp, "lpex4.lp", NULL); if ( status ) { fprintf (stderr, "Failed to write LP to disk.\n"); goto TERMINATE; } TERMINATE: /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { int frstatus; frstatus = CPXfreeprob (env, &lp); if ( frstatus ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", frstatus); if (( !status ) && frstatus ) status = frstatus; } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { int clstatus; clstatus = CPXcloseCPLEX (&env); if ( clstatus ) { fprintf (stderr, "CPXcloseCPLEX failed, error code %d.\n", clstatus); if (( !status ) && clstatus ) status = clstatus; } } if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; /* Note that since we have turned off the CPLEX screen indicator, we'll need to print the error message ourselves. */ CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } return (status); } /* END main */
extern int solve_allocation(int nodeSize, int windowSize, int timeout, sched_nodeinfo_t *node_array, solver_job_list_t *job_array) { solver_job_list_t *solver_job_ptr; int solstat; int n = windowSize, m = nodeSize; double objval; double *x = NULL; double *pi = NULL; double *slack = NULL; double *dj = NULL; double *obj = NULL; int NUMCOLS = n * (2 * m + 2); CPXENVptr env = NULL; CPXLPptr lp = NULL; int status = 0; int i, j, k; int cur_numrows, cur_numcols; char envstr[256] = "ILOG_LICENSE_FILE=/home/seren/ILOG/CPLEX_Studio_AcademicResearch122/licenses/access.ilm"; if ( envstr != NULL ) { CPXputenv (envstr); } env = CPXopenCPLEX (&status); if ( env == NULL ) { char errmsg[1024]; CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } status = CPXsetintparam (env, CPX_PARAM_SCRIND, CPX_ON); if ( status ) { goto TERMINATE; } status = CPXsetintparam (env, CPX_PARAM_DATACHECK, CPX_ON); if ( status ) { goto TERMINATE; } lp = CPXcreateprob (env, &status, "lpex1"); if ( lp == NULL ) { goto TERMINATE; } obj = (double*)malloc(NUMCOLS * sizeof(double)); status = CPXsetdblparam(env,CPX_PARAM_TILIM,5); status = populatebynonzero (env, lp, nodeSize, windowSize, timeout, node_array, job_array); if ( status ) { fprintf (stderr, "Failed to populate problem."); goto TERMINATE; } status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize LP."); goto TERMINATE; } cur_numrows = CPXgetnumrows (env, lp); cur_numcols = CPXgetnumcols (env, lp); x = (double *) malloc (cur_numcols * sizeof(double)); slack = (double *) malloc (cur_numrows * sizeof(double)); dj = (double *) malloc (cur_numcols * sizeof(double)); pi = (double *) malloc (cur_numrows * sizeof(double)); if ( x == NULL || slack == NULL || dj == NULL || pi == NULL ) { status = CPXERR_NO_MEMORY; goto TERMINATE; } status = CPXsolution (env, lp, &solstat, &objval, x, pi, slack, dj); if ( status ) { goto TERMINATE; } /*debug3("\nSolution status = %d\n", solstat);*/ printf("Solution value = %f\n\n", objval); /* for (i = 0; i < cur_numrows; i++) { printf ("Row %d: Slack = %10f Pi = %10f\n", i, slack[i], pi[i]); } for (j = 0; j < cur_numcols; j++) { printf ("Column %d: Value = %10f Reduced cost = %10f\n", j, x[j], dj[j]); } */ /*debug3("sending solution results to slurm");*/ /* for (j = 0; j < windowSize; j++) { if (x[j] > 0) { solver_job_ptr = &job_array[j]; solver_job_ptr->node_bitmap = (bitstr_t *) bit_alloc (node_record_count); solver_job_ptr->job_ptr->details->req_node_bitmap = (bitstr_t *) bit_alloc (node_record_count); solver_job_ptr->onnodes = (int *) xmalloc (sizeof(int)*node_record_count); solver_job_ptr->job_ptr->details->req_node_layout = (int *)xmalloc(sizeof(int) * node_record_count); solver_job_ptr->job_ptr->details->req_node_bitmap = (bitstr_t *) bit_alloc (node_record_count); for (i = 0; i < nodeSize; i++) { k = (1 + i) * windowSize + j; if (x[k] > 0) { bit_set (solver_job_ptr->node_bitmap, (bitoff_t) (i)); bit_set (solver_job_ptr->job_ptr->details->req_node_bitmap, (bitoff_t) (i)); node_array[i].rem_cpus -= x[k]; node_array[i].rem_gpus -= solver_job_ptr->gpu; solver_job_ptr->onnodes[i] = x[k]; solver_job_ptr->job_ptr->details->req_node_layout[i] = solver_job_ptr->onnodes[i]; solver_job_ptr->alloc_total += x[k]; } } } else job_array[j].alloc_total = 0; } */ /* status = CPXwriteprob (env, lp, "lpex1.lp", NULL); if ( status ) { fprintf (stderr, "Failed to write LP to disk."); goto TERMINATE; } */ TERMINATE: free_and_null ((char **) &x); free_and_null ((char **) &slack); free_and_null ((char **) &dj); free_and_null ((char **) &pi); if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.", status); } } if ( env != NULL ) { status = CPXcloseCPLEX (&env); if ( status ) { char errmsg[1024]; fprintf (stderr, "Could not close CPLEX environment."); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); }
int main (int argc, char **argv) { int status = 0; int nfoods; int nnutr; double *cost = NULL; double *lb = NULL; double *ub = NULL; double *nutrmin = NULL; double *nutrmax = NULL; double **nutrper = NULL; double *x = NULL; double objval; int solstat; /* Declare and allocate space for the variables and arrays where we will store the optimization results including the status, objective value, variable values, dual values, row slacks and variable reduced costs. */ CPXENVptr env = NULL; CPXLPptr lp = NULL; int i, j; /* Check the command line arguments */ if (( argc != 3 ) || ( argv[1][0] != '-' ) || ( strchr ("rc", argv[1][1]) == NULL ) ) { usage (argv[0]); goto TERMINATE; } status = readdata(argv[2], &nfoods, &cost, &lb, &ub, &nnutr, &nutrmin, &nutrmax, &nutrper); if ( status ) goto TERMINATE; /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Turn on data checking */ status = CPXsetintparam (env, CPXPARAM_Read_DataCheck, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on data checking, error %d.\n", status); goto TERMINATE; } /* Create the problem. */ lp = CPXcreateprob (env, &status, "diet"); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now populate the problem with the data. For building large problems, consider setting the row, column and nonzero growth parameters before performing this task. */ switch (argv[1][1]) { case 'r': status = populatebyrow (env, lp, nfoods, cost, lb, ub, nnutr, nutrmin, nutrmax, nutrper); break; case 'c': status = populatebycolumn (env, lp, nfoods, cost, lb, ub, nnutr, nutrmin, nutrmax, nutrper); break; } if ( status ) { fprintf (stderr, "Failed to populate problem.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize LP.\n"); goto TERMINATE; } x = (double *) malloc (nfoods * sizeof(double)); if ( x == NULL ) { status = CPXERR_NO_MEMORY; fprintf (stderr, "Could not allocate memory for solution.\n"); goto TERMINATE; } status = CPXsolution (env, lp, &solstat, &objval, x, NULL, NULL, NULL); if ( status ) { fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write the output to the screen. */ printf ("\nSolution status = %d\n", solstat); printf ("Solution value = %f\n\n", objval); for (j = 0; j < nfoods; j++) { printf ("Food %d: Buy = %10f\n", j, x[j]); } /* Finally, write a copy of the problem to a file. */ status = CPXwriteprob (env, lp, "diet.lp", NULL); if ( status ) { fprintf (stderr, "Failed to write LP to disk.\n"); goto TERMINATE; } TERMINATE: /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status > 0 ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } if ( nutrper != NULL ) { for (i = 0; i < nnutr; ++i) { free_and_null ((char **) &(nutrper[i])); } } free_and_null ((char **) &nutrper); free_and_null ((char **) &cost); free_and_null ((char **) &cost); free_and_null ((char **) &lb); free_and_null ((char **) &ub); free_and_null ((char **) &nutrmin); free_and_null ((char **) &nutrmax); free_and_null ((char **) &x); return (status); } /* END main */
extern int solve_allocation(int nodeSize, int windowSize, int timeout, sched_nodeinfo_t *node_array, solver_job_list_t *job_array) { solver_job_list_t *sjob_ptr; struct job_details *job_det_ptr; int solstat; int n = windowSize, m = nodeSize; double objval; double *x = NULL; double *pi = NULL; double *slack = NULL; double *dj = NULL; CPXENVptr env = NULL; CPXLPptr lp = NULL; int status = 0; int i, j, k; int cur_numrows, cur_numcols; char envstr[256]; sprintf(envstr,"ILOG_LICENSE_FILE=%s",get_cplex_license_address()); if ( envstr != NULL ) { CPXputenv (envstr); } env = CPXopenCPLEX (&status); if ( env == NULL ) { char errmsg[1024]; fatal ("Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } status = CPXsetintparam (env, CPX_PARAM_SCRIND, CPX_ON); if (status) { fatal("Failure to turn on screen indicator, error %d.",status); goto TERMINATE; } status = CPXsetintparam (env, CPX_PARAM_DATACHECK, CPX_ON); if (status) { fatal("Failure to turn on data checking, error %d.", status); goto TERMINATE; } lp = CPXcreateprob (env, &status, "lpex1"); if (lp == NULL) { fatal("Failed to create LP."); goto TERMINATE; } status = CPXsetdblparam(env,CPX_PARAM_TILIM,timeout); status = populatebynonzero (env, lp, m, n, timeout, node_array, job_array); if ( status ) { fprintf (stderr, "Failed to populate problem."); goto TERMINATE; } status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize LP."); goto TERMINATE; } cur_numrows = CPXgetnumrows (env, lp); cur_numcols = CPXgetnumcols (env, lp); x = (double *) malloc (cur_numcols * sizeof(double)); slack = (double *) malloc (cur_numrows * sizeof(double)); dj = (double *) malloc (cur_numcols * sizeof(double)); pi = (double *) malloc (cur_numrows * sizeof(double)); if ( x == NULL || slack == NULL || dj == NULL || pi == NULL ) { status = CPXERR_NO_MEMORY; fatal ("Could not allocate memory for solution."); goto TERMINATE; } status = CPXsolution (env, lp, &solstat, &objval, x, pi, slack, dj); if ( status ) { fatal ("Failed to obtain solution."); goto TERMINATE; } for (j = 0; j < windowSize; j++) { if (x[j] > 0) { sjob_ptr = &job_array[j]; job_det_ptr = sjob_ptr->job_ptr->details; sjob_ptr->node_bitmap = (bitstr_t *) bit_alloc (node_record_count); job_det_ptr->req_node_bitmap = (bitstr_t *) bit_alloc (node_record_count); sjob_ptr->onnodes = (uint32_t *) xmalloc (sizeof(uint32_t) * node_record_count); job_det_ptr->req_node_layout = (uint16_t *) xmalloc (sizeof(uint16_t) * node_record_count); job_det_ptr->req_node_bitmap = (bitstr_t *) bit_alloc (node_record_count); for (i = 0; i < nodeSize; i++) { k = (1 + i) * windowSize + j; if (x[k] > 0) { bit_set (sjob_ptr->node_bitmap, (bitoff_t) (i)); bit_set (job_det_ptr->req_node_bitmap, (bitoff_t) (i)); node_array[i].rem_cpus -= x[k]; node_array[i].rem_gpus -= sjob_ptr->gpu; sjob_ptr->onnodes[i] = x[k]; job_det_ptr->req_node_layout[i] = sjob_ptr->onnodes[i]; sjob_ptr->alloc_total += x[k]; } } } else job_array[j].alloc_total = 0; } TERMINATE: free_and_null ((char **) &x); free_and_null ((char **) &slack); free_and_null ((char **) &dj); free_and_null ((char **) &pi); if (lp != NULL) { status = CPXfreeprob (env, &lp); if (status) { fatal("CPXfreeprob failed, error code %d.", status); } } if (env != NULL) { status = CPXcloseCPLEX (&env); if (status) { char errmsg[1024]; fatal("Could not close CPLEX environment."); CPXgeterrorstring (env, status, errmsg); fatal("%s", errmsg); } } return (status); }
int main (int argc, char *argv[]) { /* Declare and allocate space for the variables and arrays where we will store the optimization results including the status, objective value, maximum bound violation, variable values, and basis. */ int solnstat, solnmethod, solntype; double objval, maxviol; double *x = NULL; int *cstat = NULL; int *rstat = NULL; CPXENVptr env = NULL; CPXLPptr lp = NULL; int status = 0; int j; int cur_numrows, cur_numcols; char *basismsg; /* Check the command line arguments */ if (( argc != 3 ) || ( strchr ("cfg", argv[2][0]) == NULL ) ) { usage (argv[0]); goto TERMINATE; } /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem, using the filename as the problem name */ lp = CPXcreateprob (env, &status, argv[1]); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. Note that most CPLEX routines return an error code to indicate the reason for failure. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now read the file, and copy the data into the created lp */ status = CPXreadcopyprob (env, lp, argv[1], NULL); if ( status ) { fprintf (stderr, "Failed to read and copy the problem data.\n"); goto TERMINATE; } if ( CPXgetprobtype (env, lp) != CPXPROB_QP ) { fprintf (stderr, "Input file is not a QP. Exiting.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ switch (argv[2][0]) { case 'c': status = CPXsetintparam (env, CPXPARAM_SolutionTarget, CPX_SOLUTIONTARGET_OPTIMALCONVEX); if ( status ) goto TERMINATE; status = CPXqpopt (env, lp); if ( status ) { if ( status == CPXERR_Q_NOT_POS_DEF ) printf ("Problem is not convex. Use argument f to get local optimum " "or g to get global optimum.\n"); else fprintf (stderr, "Failed to optimize QP.\n"); goto TERMINATE; } break; case 'f': status = CPXsetintparam (env, CPXPARAM_SolutionTarget, CPX_SOLUTIONTARGET_FIRSTORDER); if ( status ) goto TERMINATE; status = CPXqpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize QP.\n"); goto TERMINATE; } break; case 'g': status = CPXsetintparam (env, CPXPARAM_SolutionTarget, CPX_SOLUTIONTARGET_OPTIMALGLOBAL); if ( status ) goto TERMINATE; status = CPXqpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize noncvonex QP.\n"); goto TERMINATE; } break; default: break; } solnstat = CPXgetstat (env, lp); if ( solnstat == CPXMIP_UNBOUNDED || solnstat == CPX_STAT_UNBOUNDED ) { printf ("Model is unbounded\n"); goto TERMINATE; } else if ( solnstat == CPXMIP_INFEASIBLE || solnstat == CPX_STAT_INFEASIBLE ) { printf ("Model is infeasible\n"); goto TERMINATE; } else if ( solnstat == CPX_STAT_INForUNBD ) { printf ("Model is infeasible or unbounded\n"); goto TERMINATE; } status = CPXsolninfo (env, lp, &solnmethod, &solntype, NULL, NULL); if ( status ) { fprintf (stderr, "Failed to obtain solution info.\n"); goto TERMINATE; } printf ("Solution status %d, solution method %d\n", solnstat, solnmethod); if ( solntype == CPX_NO_SOLN ) { fprintf (stderr, "Solution not available.\n"); goto TERMINATE; } status = CPXgetobjval (env, lp, &objval); if ( status ) { fprintf (stderr, "Failed to obtain objective value.\n"); goto TERMINATE; } printf ("Objective value %.10g.\n", objval); /* The size of the problem should be obtained by asking CPLEX what the actual size is. cur_numrows and cur_numcols store the current number of rows and columns, respectively. */ cur_numcols = CPXgetnumcols (env, lp); cur_numrows = CPXgetnumrows (env, lp); /* Retrieve basis, if one is available */ if ( solntype == CPX_BASIC_SOLN ) { cstat = (int *) malloc (cur_numcols*sizeof(int)); rstat = (int *) malloc (cur_numrows*sizeof(int)); if ( cstat == NULL || rstat == NULL ) { fprintf (stderr, "No memory for basis statuses.\n"); goto TERMINATE; } status = CPXgetbase (env, lp, cstat, rstat); if ( status ) { fprintf (stderr, "Failed to get basis; error %d.\n", status); goto TERMINATE; } } else { printf ("No basis available\n"); } /* Retrieve solution vector */ x = (double *) malloc (cur_numcols*sizeof(double)); if ( x == NULL ) { fprintf (stderr, "No memory for solution.\n"); goto TERMINATE; } status = CPXgetx (env, lp, x, 0, cur_numcols-1); if ( status ) { fprintf (stderr, "Failed to obtain primal solution.\n"); goto TERMINATE; } /* Write out the solution */ for (j = 0; j < cur_numcols; j++) { printf ( "Column %d: Value = %17.10g", j, x[j]); if ( cstat != NULL ) { switch (cstat[j]) { case CPX_AT_LOWER: basismsg = "Nonbasic at lower bound"; break; case CPX_BASIC: basismsg = "Basic"; break; case CPX_AT_UPPER: basismsg = "Nonbasic at upper bound"; break; case CPX_FREE_SUPER: basismsg = "Superbasic, or free variable at zero"; break; default: basismsg = "Bad basis status"; break; } printf (" %s",basismsg); } printf ("\n"); } /* Display the maximum bound violation. */ status = CPXgetdblquality (env, lp, &maxviol, CPX_MAX_PRIMAL_INFEAS); if ( status ) { fprintf (stderr, "Failed to obtain bound violation.\n"); goto TERMINATE; } printf ("Maximum bound violation = %17.10g\n", maxviol); TERMINATE: /* Free up the basis and solution */ free_and_null ((char **) &cstat); free_and_null ((char **) &rstat); free_and_null ((char **) &x); /* Free up the problem, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
int main (void) { /* Declare variables and arrays where we will store the optimization results including the status, objective value, and variable values. */ int solstat; double objval; double x[2*NUMEDGES]; /* One flow variable and one fixed charge indicator for each edge */ CPXENVptr env = NULL; CPXLPptr lp = NULL; int status; int j; /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem. */ lp = CPXcreateprob (env, &status, "fixnet"); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Build the fixed-charge network flow model using indicator constraints. */ status = buildnetwork (env, lp); if ( status ) { fprintf (stderr, "Failed to build network.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ status = CPXmipopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize MIP.\n"); goto TERMINATE; } solstat = CPXgetstat (env, lp); /* Write solution status and objective to the screen. */ printf ("\nSolution status = %d\n", solstat); status = CPXgetobjval (env, lp, &objval); if ( status ) { fprintf (stderr, "No MIP objective value available. Exiting...\n"); goto TERMINATE; } printf ("Solution value = %f\n", objval); printf ("Solution vector:\n"); dumpx (env, lp); status = CPXgetx (env, lp, x, 0, 2*NUMEDGES-1); if ( status ) { fprintf (stderr, "Failed to get optimal integer x.\n"); goto TERMINATE; } /* Make sure flow satisfies fixed-charge constraints */ for (j = 0; j < NUMEDGES; j++) { if ( x[j] > 0.0001 && x[NUMEDGES+j] < 0.9999 ) { printf ("WARNING : Edge from %d to %d has non-zero flow %.3f\n", orig[j], dest[j], x[j]); printf (" : fixed-charge indicator has value %.6f.\n", x[NUMEDGES+j]); } } printf("\n"); /* Finally, write a copy of the problem to a file. */ status = CPXwriteprob (env, lp, "fixnet.lp", NULL); if ( status ) { fprintf (stderr, "Failed to write LP to disk.\n"); goto TERMINATE; } /* Free problem */ status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); goto TERMINATE; } TERMINATE: /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
int main (int argc, char *argv[]) { /* Declare and allocate space for the variables and arrays where we will store the optimization results including the status, objective value, maximum bound violation, variable values, and basis. */ int solnstat, solnmethod, solntype; double objval, maxviol; double *x = NULL; int *cstat = NULL; int *rstat = NULL; CPXENVptr env = NULL; CPXLPptr lp = NULL; int status = 0; int j; int cur_numrows, cur_numcols; char **cur_colname = NULL; char *cur_colnamestore = NULL; int cur_colnamespace; int surplus; int method; char *basismsg; /* Check the command line arguments */ if (( argc != 3 ) || ( strchr ("podhbnsc", argv[2][0]) == NULL ) ) { usage (argv[0]); goto TERMINATE; } /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem, using the filename as the problem name */ lp = CPXcreateprob (env, &status, argv[1]); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. Note that most CPLEX routines return an error code to indicate the reason for failure. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now read the file, and copy the data into the created lp */ status = CPXreadcopyprob (env, lp, argv[1], NULL); if ( status ) { fprintf (stderr, "Failed to read and copy the problem data.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ switch (argv[2][0]) { case 'o': method = CPX_ALG_AUTOMATIC; break; case 'p': method = CPX_ALG_PRIMAL; break; case 'd': method = CPX_ALG_DUAL; break; case 'n': method = CPX_ALG_NET; break; case 'h': method = CPX_ALG_BARRIER; break; case 'b': method = CPX_ALG_BARRIER; status = CPXsetintparam (env, CPXPARAM_Barrier_Crossover, CPX_ALG_NONE); if ( status ) { fprintf (stderr, "Failed to set the crossover method, error %d.\n", status); goto TERMINATE; } break; case 's': method = CPX_ALG_SIFTING; break; case 'c': method = CPX_ALG_CONCURRENT; break; default: method = CPX_ALG_NONE; break; } status = CPXsetintparam (env, CPXPARAM_LPMethod, method); if ( status ) { fprintf (stderr, "Failed to set the optimization method, error %d.\n", status); goto TERMINATE; } status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize LP.\n"); goto TERMINATE; } solnstat = CPXgetstat (env, lp); if ( solnstat == CPX_STAT_UNBOUNDED ) { printf ("Model is unbounded\n"); goto TERMINATE; } else if ( solnstat == CPX_STAT_INFEASIBLE ) { printf ("Model is infeasible\n"); goto TERMINATE; } else if ( solnstat == CPX_STAT_INForUNBD ) { printf ("Model is infeasible or unbounded\n"); goto TERMINATE; } status = CPXsolninfo (env, lp, &solnmethod, &solntype, NULL, NULL); if ( status ) { fprintf (stderr, "Failed to obtain solution info.\n"); goto TERMINATE; } printf ("Solution status %d, solution method %d\n", solnstat, solnmethod); if ( solntype == CPX_NO_SOLN ) { fprintf (stderr, "Solution not available.\n"); goto TERMINATE; } status = CPXgetobjval (env, lp, &objval); if ( status ) { fprintf (stderr, "Failed to obtain objective value.\n"); goto TERMINATE; } printf ("Objective value %.10g.\n", objval); /* The size of the problem should be obtained by asking CPLEX what the actual size is. cur_numrows and cur_numcols store the current number of rows and columns, respectively. */ cur_numcols = CPXgetnumcols (env, lp); cur_numrows = CPXgetnumrows (env, lp); /* Retrieve basis, if one is available */ if ( solntype == CPX_BASIC_SOLN ) { cstat = (int *) malloc (cur_numcols*sizeof(int)); rstat = (int *) malloc (cur_numrows*sizeof(int)); if ( cstat == NULL || rstat == NULL ) { fprintf (stderr, "No memory for basis statuses.\n"); goto TERMINATE; } status = CPXgetbase (env, lp, cstat, rstat); if ( status ) { fprintf (stderr, "Failed to get basis; error %d.\n", status); goto TERMINATE; } } else { printf ("No basis available\n"); } /* Retrieve solution vector */ x = (double *) malloc (cur_numcols*sizeof(double)); if ( x == NULL ) { fprintf (stderr, "No memory for solution.\n"); goto TERMINATE; } status = CPXgetx (env, lp, x, 0, cur_numcols-1); if ( status ) { fprintf (stderr, "Failed to obtain primal solution.\n"); goto TERMINATE; } /* Now get the column names for the problem. First we determine how much space is used to hold the names, and then do the allocation. Then we call CPXgetcolname() to get the actual names. */ status = CPXgetcolname (env, lp, NULL, NULL, 0, &surplus, 0, cur_numcols-1); if (( status != CPXERR_NEGATIVE_SURPLUS ) && ( status != 0 ) ) { fprintf (stderr, "Could not determine amount of space for column names.\n"); goto TERMINATE; } cur_colnamespace = - surplus; if ( cur_colnamespace > 0 ) { cur_colname = (char **) malloc (sizeof(char *)*cur_numcols); cur_colnamestore = (char *) malloc (cur_colnamespace); if ( cur_colname == NULL || cur_colnamestore == NULL ) { fprintf (stderr, "Failed to get memory for column names.\n"); status = -1; goto TERMINATE; } status = CPXgetcolname (env, lp, cur_colname, cur_colnamestore, cur_colnamespace, &surplus, 0, cur_numcols-1); if ( status ) { fprintf (stderr, "CPXgetcolname failed.\n"); goto TERMINATE; } } else { printf ("No names associated with problem. Using Fake names.\n"); } /* Write out the solution */ for (j = 0; j < cur_numcols; j++) { if ( cur_colnamespace > 0 ) { printf ("%-16s: ", cur_colname[j]); } else { printf ("Fake%-6.6d : ", j);; } printf ("%17.10g", x[j]); if ( cstat != NULL ) { switch (cstat[j]) { case CPX_AT_LOWER: basismsg = "Nonbasic at lower bound"; break; case CPX_BASIC: basismsg = "Basic"; break; case CPX_AT_UPPER: basismsg = "Nonbasic at upper bound"; break; case CPX_FREE_SUPER: basismsg = "Superbasic, or free variable at zero"; break; default: basismsg = "Bad basis status"; break; } printf (" %s",basismsg); } printf ("\n"); } /* Display the maximum bound violation. */ status = CPXgetdblquality (env, lp, &maxviol, CPX_MAX_PRIMAL_INFEAS); if ( status ) { fprintf (stderr, "Failed to obtain bound violation.\n"); goto TERMINATE; } printf ("Maximum bound violation = %17.10g\n", maxviol); TERMINATE: /* Free up the basis and solution */ free_and_null ((char **) &cstat); free_and_null ((char **) &rstat); free_and_null ((char **) &x); free_and_null ((char **) &cur_colname); free_and_null ((char **) &cur_colnamestore); /* Free up the problem, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
int CplexSolver::solve(CplexConverter& converter) { /* Declare variables and arrays for retrieving problem data and solution information later on. */ // cout << "lp solver" << endl; int narcs; int nnodes; int solstat; double objval; CPXENVptr env = NULL; CPXNETptr net = NULL; int status; int status1; int i, j; int cnt = 0; /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPX_PARAM_SCRIND, CPX_OFF); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem. */ net = CPXNETcreateprob (env, &status, "netex1"); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. */ if ( net == NULL ) { fprintf (stderr, "Failed to create network object.\n"); goto TERMINATE; } /* Fill in the data for the problem. Note that since the space for the data already exists in local variables, we pass the arrays directly to the routine to fill in the data structures. */ status = buildNetwork (env, net, converter.widgetNet, converter.nnodes, converter.narcs, converter.supply, converter.head, converter.tail, converter.obj, converter.ub, converter.lb); // if(supply != NULL){ // cout << "before not clear" << endl; // } if ( status ) { fprintf (stderr, "Failed to build network problem.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ status = CPXNETprimopt (env, net); if ( status ) { fprintf (stderr, "Failed to optimize network.\n"); goto TERMINATE; } /* get network dimensions */ narcs = CPXNETgetnumarcs (env, net); nnodes = CPXNETgetnumnodes (env, net); status = CPXNETsolution (env, net, &solstat, &objval, converter.x, converter.pi, converter.slack, converter.dj); // cout << "status: " << status << endl; if ( status ) { // fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write the output to the screen. */ // printf ("\nSolution status = %d\n", solstat); if (solstat != 1 && solstat != 6 && solstat != 14) { // cout << "status" << solstat << endl; status1 = -1; goto TERMINATE; } // printf ("Solution value = %f\n\n", objval); status1 = 0; TERMINATE: /* Free up the problem as allocated by CPXNETcreateprob, if necessary */ if ( net != NULL ) { status = CPXNETfreeprob (env, &net); if ( status ) { fprintf (stderr, "CPXNETfreeprob failed, error code %d.\n", status); } } if ( env != NULL ) { status = CPXcloseCPLEX (&env); if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status1); }
int main (void) { /* Declare pointers for the variables and arrays that will contain the data which define the LP problem. The setproblemdata() routine allocates space for the problem data. */ char *probname = NULL; int numcols; int numrows; int objsen; double *obj = NULL; double *rhs = NULL; char *sense = NULL; int *matbeg = NULL; int *matcnt = NULL; int *matind = NULL; double *matval = NULL; double *lb = NULL; double *ub = NULL; int *qmatbeg = NULL; int *qmatcnt = NULL; int *qmatind = NULL; double *qmatval = NULL; /* Declare pointers for the variables that will contain the data for the constraint that cuts off certain local optima. */ int numrows_extra; int numnnz_extra; double *rhs_extra = NULL; char *sense_extra = NULL; int *rmatbeg = NULL; int *rmatind = NULL; double *rmatval = NULL; int rowind[1]; /* Declare and allocate space for the variables and arrays where we will store the optimization results including the status, objective value, variable values, dual values, row slacks and variable reduced costs. */ int solstat; double objval; CPXENVptr env = NULL; CPXLPptr lp = NULL; int status; /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Fill in the data for the problem. */ status = setproblemdata (&probname, &numcols, &numrows, &objsen, &obj, &rhs, &sense, &matbeg, &matcnt, &matind, &matval, &lb, &ub, &qmatbeg, &qmatcnt, &qmatind, &qmatval, &numrows_extra, &numnnz_extra, &rhs_extra, &sense_extra, &rmatbeg, &rmatind, &rmatval); if ( status ) { fprintf (stderr, "Failed to build problem data arrays.\n"); goto TERMINATE; } /* Create the problem. */ lp = CPXcreateprob (env, &status, probname); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create problem.\n"); goto TERMINATE; } /* Now copy the LP part of the problem data into the lp */ status = CPXcopylp (env, lp, numcols, numrows, objsen, obj, rhs, sense, matbeg, matcnt, matind, matval, lb, ub, NULL); if ( status ) { fprintf (stderr, "Failed to copy problem data.\n"); goto TERMINATE; } status = CPXcopyquad (env, lp, qmatbeg, qmatcnt, qmatind, qmatval); if ( status ) { fprintf (stderr, "Failed to copy quadratic matrix.\n"); goto TERMINATE; } /* When a non-convex objective function is present, CPLEX will return error CPXERR_Q_NOT_POS_DEF unless the parameter CPXPARAM_OptimalityTarget is set to accept first-order optimal solutions. */ status = CPXsetintparam (env, CPXPARAM_OptimalityTarget, CPX_OPTIMALITYTARGET_FIRSTORDER); if ( status ) goto TERMINATE; /* Optimize the problem and obtain solution. */ status = optimize_and_report(env, lp, &solstat, &objval); if ( status ) goto TERMINATE; /* Add a constraint to cut off the solution at (-1, 1) */ status = CPXaddrows (env, lp, 0, numrows_extra, numnnz_extra, rhs_extra, sense_extra, rmatbeg, rmatind, rmatval, NULL, NULL); if ( status ) goto TERMINATE; status = optimize_and_report(env, lp, &solstat, &objval); if ( status ) goto TERMINATE; /* Reverse the sense of the new constraint to cut off the solution at (1, 1) */ rowind[0] = CPXgetnumrows (env, lp) - 1; status = CPXchgsense (env, lp, 1, rowind, "L"); if ( status ) goto TERMINATE; status = optimize_and_report(env, lp, &solstat, &objval); if ( status ) goto TERMINATE; /* Finally, write a copy of the problem to a file. */ status = CPXwriteprob (env, lp, "indefqpex1.lp", NULL); if ( status ) { fprintf (stderr, "Failed to write LP to disk.\n"); goto TERMINATE; } TERMINATE: /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } /* Free up the problem data arrays, if necessary. */ free_and_null ((char **) &probname); free_and_null ((char **) &obj); free_and_null ((char **) &rhs); free_and_null ((char **) &sense); free_and_null ((char **) &matbeg); free_and_null ((char **) &matcnt); free_and_null ((char **) &matind); free_and_null ((char **) &matval); free_and_null ((char **) &lb); free_and_null ((char **) &ub); free_and_null ((char **) &qmatbeg); free_and_null ((char **) &qmatcnt); free_and_null ((char **) &qmatind); free_and_null ((char **) &qmatval); free_and_null ((char **) &rhs_extra); free_and_null ((char **) &sense_extra); free_and_null ((char **) &rmatbeg); free_and_null ((char **) &rmatind); free_and_null ((char **) &rmatval); return (status); } /* END main */
int main (int argc, char *argv[]) { int status = 0; /* Declare and allocate space for the variables and arrays where we will store the optimization results, including the status, objective value, and variable values */ int solstat; double objval; double *x = NULL; CPXENVptr env = NULL; CPXLPptr lp = NULL; int j; int cur_numcols; const char * datadir = argc <= 1 ? "../../../examples/data" : argv[1]; char *noswot = NULL; noswot = (char *) malloc (strlen (datadir) + 1 + strlen("noswot.mps") + 1); sprintf (noswot, "%s/noswot.mps", datadir); /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status != 0 ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } CPXsetintparam (env, CPXPARAM_MIP_Interval, 1000); /* Create the problem, using the filename as the problem name */ lp = CPXcreateprob (env, &status, "noswot"); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. Note that most CPLEX routines return an error code to indicate the reason for failure */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now read the file, and copy the data into the created lp */ status = CPXreadcopyprob (env, lp, noswot, NULL); if ( status ) { fprintf (stderr, "Failed to read and copy the problem data.\n"); goto TERMINATE; } /* Set parameters */ /* Assure linear mappings between the presolved and original models */ status = CPXsetintparam (env, CPXPARAM_Preprocessing_Linear, 0); if ( status ) goto TERMINATE; /* Create user cuts for noswot problem */ status = addusercuts (env, lp); if ( status ) goto TERMINATE; /* Optimize the problem and obtain solution */ status = CPXmipopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize MIP.\n"); goto TERMINATE; } solstat = CPXgetstat (env, lp); printf ("Solution status %d.\n", solstat); status = CPXgetobjval (env, lp, &objval); if ( status ) { fprintf (stderr,"Failed to obtain objective value.\n"); goto TERMINATE; } printf ("Objective value %.10g\n", objval); cur_numcols = CPXgetnumcols (env, lp); /* Allocate space for solution */ x = (double *) malloc (cur_numcols * sizeof (double)); if ( x == NULL ) { fprintf (stderr, "No memory for solution values.\n"); goto TERMINATE; } status = CPXgetx (env, lp, x, 0, cur_numcols-1); if ( status ) { fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write out the solution */ for (j = 0; j < cur_numcols; j++) { if ( fabs (x[j]) > 1e-10 ) { printf ("Column %d: Value = %17.10g\n", j, x[j]); } } TERMINATE: /* Free the filename */ free_and_null ((char **) &noswot); /* Free the solution vector */ free_and_null ((char **) &x); /* Free the problem as allocated by CPXcreateprob and CPXreadcopyprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
int main (int argc, char **argv) { /* Declare and allocate space for the variables and arrays where we will store the optimization results including the status, objective value, variable values, dual values, row slacks and variable reduced costs. */ int solstat; double objval; double *x = NULL; double *pi = NULL; double *slack = NULL; double *dj = NULL; CPXENVptr env = NULL; CPXLPptr lp = NULL; int status = 0; int i, j; int cur_numrows, cur_numcols; /* Check the command line arguments */ if (( argc != 2 ) || ( argv[1][0] != '-' ) || ( strchr ("rcn", argv[1][1]) == NULL ) ) { usage (argv[0]); goto TERMINATE; } /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Turn on data checking */ status = CPXsetintparam (env, CPXPARAM_Read_DataCheck, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on data checking, error %d.\n", status); goto TERMINATE; } /* Create the problem. */ lp = CPXcreateprob (env, &status, "lpex1"); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now populate the problem with the data. For building large problems, consider setting the row, column and nonzero growth parameters before performing this task. */ switch (argv[1][1]) { case 'r': status = populatebyrow (env, lp); break; case 'c': status = populatebycolumn (env, lp); break; case 'n': status = populatebynonzero (env, lp); break; } if ( status ) { fprintf (stderr, "Failed to populate problem.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize LP.\n"); goto TERMINATE; } /* The size of the problem should be obtained by asking CPLEX what the actual size is, rather than using sizes from when the problem was built. cur_numrows and cur_numcols store the current number of rows and columns, respectively. */ cur_numrows = CPXgetnumrows (env, lp); cur_numcols = CPXgetnumcols (env, lp); x = (double *) malloc (cur_numcols * sizeof(double)); slack = (double *) malloc (cur_numrows * sizeof(double)); dj = (double *) malloc (cur_numcols * sizeof(double)); pi = (double *) malloc (cur_numrows * sizeof(double)); if ( x == NULL || slack == NULL || dj == NULL || pi == NULL ) { status = CPXERR_NO_MEMORY; fprintf (stderr, "Could not allocate memory for solution.\n"); goto TERMINATE; } status = CPXsolution (env, lp, &solstat, &objval, x, pi, slack, dj); if ( status ) { fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write the output to the screen. */ printf ("\nSolution status = %d\n", solstat); printf ("Solution value = %f\n\n", objval); for (i = 0; i < cur_numrows; i++) { printf ("Row %d: Slack = %10f Pi = %10f\n", i, slack[i], pi[i]); } for (j = 0; j < cur_numcols; j++) { printf ("Column %d: Value = %10f Reduced cost = %10f\n", j, x[j], dj[j]); } /* Finally, write a copy of the problem to a file. */ status = CPXwriteprob (env, lp, "lpex1.lp", NULL); if ( status ) { fprintf (stderr, "Failed to write LP to disk.\n"); goto TERMINATE; } TERMINATE: /* Free up the solution */ free_and_null ((char **) &x); free_and_null ((char **) &slack); free_and_null ((char **) &dj); free_and_null ((char **) &pi); /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { /* MATLAB memory structures */ const mxArray *c,*A,*b,*l,*u,*le,*ge,*maxIterPtr; /* Return arguments */ double *matlpstat,*objval,*x,*pi,*cstat,*itcnt; /* Other declarations */ char *sense,errorMsg[255]; int rows,cols,maxIter,*matbeg,*matcnt,*matind; double *c_ptr,*b_ptr,*matval,*l_ptr,*u_ptr,*slack,*dj; int matrixSize,status,i,j,le_size,ge_size,m,n; double *le_ptr = NULL,*ge_ptr = NULL; int *istat,lpstat; //CPXENVptr env; //CPXLPptr lp = NULL; /* Assign pointers to MATLAB memory stuctures */ c = prhs[C_IN]; A = prhs[A_IN]; b = prhs[B_IN]; l = prhs[L_IN]; u = prhs[U_IN]; c_ptr = mxGetPr(c); b_ptr = mxGetPr(b); l_ptr = mxGetPr(l); u_ptr = mxGetPr(u); rows = mxGetM(b); cols = mxGetM(c); /* Build the matrix of coefficients, taking sparsity into account. */ if (mxIsSparse(A)){ /* Sparse */ matbeg = mxGetJc(A); /* beginnings of each column */ matcnt = (int*)mxCalloc(cols,sizeof(int)); /* # of entries in each col */ for (i = 0; i < cols; i++) matcnt[i] = matbeg[i+1] - matbeg[i]; matind = mxGetIr(A); /* row locations */ matval = mxGetPr(A); /* actual coefficients */ } else { /* Dense */ m = mxGetM(A); n = mxGetN(A); matbeg = (int*)mxCalloc(n,sizeof(int)); matcnt = (int*)mxCalloc(n,sizeof(int)); matind = (int*)mxCalloc(m*n,sizeof(int)); matval = mxGetPr(A); for (j = 0; j < n; j++) { matbeg[j] = j*m; for (i = 0; i < m; i++) matind[j*m + i] = i; matcnt[j] = m; } } /* Initialize all constraints to be equality constraints (default). */ sense = (char*)mxCalloc(rows,sizeof(char)); for(i = 0; i < rows; i++) sense[i] = 'E'; /* If "<=" constraints given, set them up. */ if(nrhs > MANDATORY_ARGS){ le = prhs[LE_IN]; le_ptr = mxGetPr(le); le_size = mxGetM(le); for(i = 0; i < le_size; i++) sense[(int)(le_ptr[i]-1)] = 'L'; } /* If ">=" constraints given, set them up. */ if(nrhs > MANDATORY_ARGS + 1){ ge = prhs[GE_IN]; ge_ptr = mxGetPr(ge); ge_size = mxGetM(ge); for(i = 0; i < ge_size; i++) sense[(int)(ge_ptr[i]-1)] = 'G'; } /* Set up maximum number of iterations */ if (nrhs > MANDATORY_ARGS + 2) { maxIterPtr = prhs[MI_IN]; maxIter = (int)mxGetScalar(maxIterPtr); } else maxIter = MAX_ITER_DEFAULT; /* Output to MATLAB */ plhs[OBJ_OUT] = mxCreateDoubleMatrix(1,1,mxREAL); plhs[X_OUT] = mxCreateDoubleMatrix(cols,1,mxREAL); plhs[PI_OUT] = mxCreateDoubleMatrix(rows,1,mxREAL); plhs[STAT_OUT] = mxCreateDoubleMatrix(1,1,mxREAL); plhs[CSTAT_OUT] = mxCreateDoubleMatrix(cols,1,mxREAL); plhs[ITER_OUT] = mxCreateDoubleMatrix(1,1,mxREAL); objval = mxGetPr(plhs[OBJ_OUT]); x = mxGetPr(plhs[X_OUT]); pi = mxGetPr(plhs[PI_OUT]); matlpstat = mxGetPr(plhs[STAT_OUT]); cstat = mxGetPr(plhs[CSTAT_OUT]); istat = (int*)mxCalloc(cols,sizeof(int)); itcnt = mxGetPr(plhs[ITER_OUT]); if (!initialized) { mexPrintf("MEX-file: lp_cplex_mex opening cplex environment\n"); /* Open CPLEX environment */ env = CPXopenCPLEXdevelop(&status); if (!env) { printf(CPXgeterrorstring(env,status,errorMsg)); mexErrMsgTxt("\nCould not open CPLEX environment."); } /* Create CPLEX problem space */ lp = CPXcreateprob(env, &status, "matlab"); if (!lp) { printf(CPXgeterrorstring(env,status,errorMsg)); CPXcloseCPLEX(&env); mexErrMsgTxt("\nCould not create CPLEX problem."); } mexAtExit(cleanup); initialized = 1; } /* Copy LP into CPLEX environment */ status = CPXcopylp(env, lp, cols, rows, MINIMIZE, c_ptr, b_ptr, sense, matbeg, matcnt, matind, matval, l_ptr, u_ptr, NULL); if (status) { printf(CPXgeterrorstring(env,status,errorMsg)); //CPXfreeprob(env,&lp); //CPXcloseCPLEX(&env); mexErrMsgTxt("\nCould not copy CPLEX problem."); } /* Set iteration limit. */ status = CPXsetintparam(env, CPX_PARAM_ITLIM, maxIter); if (status) { printf(CPXgeterrorstring(env,status,errorMsg)); //CPXfreeprob(env,&lp); //CPXcloseCPLEX(&env); mexErrMsgTxt("\nCould not set number of iterations."); } /* Perform optimization */ status = CPXprimopt(env,lp); if (status) { printf(CPXgeterrorstring(env,status,errorMsg)); //CPXfreeprob(env,&lp); //CPXcloseCPLEX(&env); mexErrMsgTxt("\nOptimization error."); } /* Obtain solution */ status = CPXsolution(env, lp, &lpstat, objval, x, pi, NULL, NULL); *matlpstat = lpstat; if (status) { printf(CPXgeterrorstring(env,status,errorMsg)); //CPXfreeprob(env,&lp); //CPXcloseCPLEX(&env); mexErrMsgTxt("\nFailure when retrieving solution."); } /* Get status of columns */ status = CPXgetbase(env, lp, istat, NULL); if (status) { printf(CPXgeterrorstring(env,status,errorMsg)); //CPXfreeprob(env,&lp); //CPXcloseCPLEX(&env); mexErrMsgTxt("\nUnable to get basis status."); } /* Copy int column values to double column values */ for (i=0; i < cols; i++) cstat[i] = istat[i]; /* Get iteration count */ *itcnt = (double)CPXgetitcnt(env,lp); /* Clean up problem */ //CPXfreeprob(env,&lp); //CPXcloseCPLEX(&env); }
void tsp_cplex_end(TSP tsp, CPLEX cplex, Solution solution) { // Close CPLEX and free all memory associated with it CPXcloseCPLEX(&cplex.env); free(tsp.distances); free(tsp.pairs); }
int main (int argc, char *argv[]) { int uselogcallback = 0; LOGINFO myloginfo; int usetimelimcallback = 0; TIMELIMINFO mytimeliminfo; int useterminate = 0; volatile int terminator; CPXENVptr env = NULL; CPXLPptr lp = NULL; int solstat; int status = 0; /* Check the command line arguments */ if (( argc != 3 ) || ( strchr ("lta", argv[2][0]) == NULL ) ) { usage (argv[0]); goto TERMINATE; } switch (argv[2][0]) { case 'l': uselogcallback = 1; break; case 't': usetimelimcallback = 1; break; case 'a': useterminate = 1; break; default: break; } /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem, using the filename as the problem name */ lp = CPXcreateprob (env, &status, argv[1]); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. Note that most CPLEX routines return an error code to indicate the reason for failure. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now read the file, and copy the data into the created lp */ status = CPXreadcopyprob (env, lp, argv[1], NULL); if ( status ) { fprintf (stderr, "Failed to read and copy the problem data.\n"); goto TERMINATE; } if ( usetimelimcallback ) { double t; status = CPXgettime (env, &t); if ( status ) { fprintf (stderr, "Failed to initialize timer.\n"); goto TERMINATE; } mytimeliminfo.acceptablegap = 10.0; mytimeliminfo.aborted = 0; mytimeliminfo.timestart = t; mytimeliminfo.timelim = 1.0; status = CPXsetinfocallbackfunc (env, timelimcallback, &mytimeliminfo); if ( status ) { fprintf (stderr, "Failed to set time limit callback function.\n"); goto TERMINATE; } } else if ( uselogcallback ) { /* Set overall node limit in case callback conditions are not met */ status = CPXsetintparam (env, CPXPARAM_MIP_Limits_Nodes, 5000); if ( status ) goto TERMINATE; status = CPXgettime (env, &myloginfo.timestart); if ( status ) { fprintf (stderr, "Failed to query time.\n"); goto TERMINATE; } status = CPXgetdettime (env, &myloginfo.dettimestart); if ( status ) { fprintf (stderr, "Failed to query deterministic time.\n"); goto TERMINATE; } myloginfo.numcols = CPXgetnumcols (env, lp); myloginfo.lastincumbent = CPXgetobjsen (env, lp) * 1e+35; myloginfo.lastlog = -10000; status = CPXsetinfocallbackfunc (env, logcallback, &myloginfo); if ( status ) { fprintf (stderr, "Failed to set logging callback function.\n"); goto TERMINATE; } /* Turn off CPLEX logging */ status = CPXsetintparam (env, CPXPARAM_MIP_Display, 0); if ( status ) goto TERMINATE; } else if ( useterminate) { status = CPXsetterminate (env, &terminator); if ( status ) { fprintf (stderr, "Failed to set terminator.\n"); goto TERMINATE; } /* Typically, you would pass the terminator variable to another thread or pass it to an interrupt handler, and monitor for some event to occur. When it does, set terminator to a non-zero value. To illustrate its use without creating a thread or an interrupt handler, terminate immediately by setting terminator before the solve. */ terminator = 1; } /* Optimize the problem and obtain solution. */ status = CPXmipopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize MIP.\n"); goto TERMINATE; } solstat = CPXgetstat (env, lp); printf ("Solution status %d.\n", solstat); TERMINATE: /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { int xstatus = CPXfreeprob (env, &lp); if ( xstatus ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", xstatus); status = xstatus; } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { int xstatus = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); status = xstatus; } } return (status); } /* END main */
int main (int argc, char *argv[]) { int status = 0; /* Declare and allocate space for the variables and arrays where we will store the optimization results, including the status, objective value, and variable values */ int solstat; double objval, relobj; double *x = NULL; MYCB info; CPXENVptr env = NULL; CPXLPptr lp = NULL; CPXLPptr lpclone = NULL; int j; int cur_numcols; /* Check the command line arguments */ if ( argc != 2 ) { usage (argv[0]); goto TERMINATE; } /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Turn on traditional search for use with control callbacks */ status = CPXsetintparam (env, CPXPARAM_MIP_Strategy_Search, CPX_MIPSEARCH_TRADITIONAL); if ( status ) goto TERMINATE; /* Create the problem, using the filename as the problem name */ lp = CPXcreateprob (env, &status, argv[1]); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. Note that most CPLEX routines return an error code to indicate the reason for failure */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now read the file, and copy the data into the created lp */ status = CPXreadcopyprob (env, lp, argv[1], NULL); if ( status ) { fprintf (stderr, "Failed to read and copy the problem data.\n"); goto TERMINATE; } /* We transfer a problem with semi-continuous or semi-integer variables to a MIP problem by adding variables and constraints. So in MIP callbacks, the size of the problem is changed and this example won't work for such problems */ if ( CPXgetnumsemicont (env, lp) + CPXgetnumsemiint (env, lp) ) { fprintf (stderr, "Not for problems with semi-continuous or semi-integer variables.\n"); goto TERMINATE; } /* The size of the problem should be obtained by asking CPLEX what the actual size is. cur_numcols store the current number of columns */ cur_numcols = CPXgetnumcols (env, lp); x = (double *) malloc (cur_numcols * sizeof (double)); if ( x == NULL ) { fprintf (stderr, "Memory allocation failed.\n"); goto TERMINATE; } /* Solve relaxation of MIP */ /* Clone original model */ lpclone = CPXcloneprob (env, lp, &status); if ( status ) { fprintf (stderr, "Failed to clone problem.\n"); goto TERMINATE; } /* Relax */ status = CPXchgprobtype (env, lpclone, CPXPROB_LP); if ( status ) { fprintf (stderr, "Failed to relax problem.\n"); goto TERMINATE; } /* Solve LP relaxation of original model using "default" LP solver */ status = CPXlpopt (env, lpclone); if ( status ) { fprintf (stderr, "Failed to solve relaxation.\n"); goto TERMINATE; } status = CPXsolution (env, lpclone, NULL, &relobj, x, NULL, NULL, NULL); if ( status ) { fprintf (stderr, "Failed to extract solution.\n"); goto TERMINATE; } printf ("Solution status = %d", CPXgetstat(env,lpclone)); printf ("\nLP relaxation objective: %.4e\n\n", relobj); /* Set up solve callback */ info.count = 0; info.mip = lp; info.relx = x; status = CPXsetsolvecallbackfunc (env, &solvecallback, (void *) &info); if ( status ) { fprintf (stderr, "Failed to set solve callback.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution */ status = CPXmipopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize MIP.\n"); goto TERMINATE; } solstat = CPXgetstat (env, lp); status = CPXgetobjval (env, lp, &objval); if ( status ) { fprintf (stderr,"Failed to obtain objective value.\n"); goto TERMINATE; } printf ("Solution status %d.\n", solstat); printf ("Objective value %.10g\n", objval); status = CPXgetx (env, lp, x, 0, cur_numcols-1); if ( status ) { fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write out the solution */ for (j = 0; j < cur_numcols; j++) { if ( fabs (x[j]) > 1e-10 ) { printf ( "Column %d: Value = %17.10g\n", j, x[j]); } } TERMINATE: /* Free the solution vector */ free_and_null ((char **) &x); /* Free the problem as allocated by CPXcreateprob and CPXreadcopyprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free the cloned lp as allocated by CPXcloneprob, if necessary */ if ( lpclone != NULL ) { status = CPXfreeprob (env, &lpclone); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
int main (int argc, char *argv[]) { int status = 0; /* Declare and allocate space for the variables and arrays where we will store the optimization results, including the status, objective value, and variable values */ int solstat; double objval; double *x = NULL; CPXENVptr env = NULL; CPXLPptr lp = NULL; int j; int cur_numcols; int wantorig = 1; int nameind = 1; /* Check the command line arguments */ if ( argc != 2 ) { if ( argc != 3 || argv[1][0] != '-' || argv[1][1] != 'r' ) { usage (argv[0]); goto TERMINATE; } wantorig = 0; nameind = 2; } /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status != 0 ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem, using the filename as the problem name */ lp = CPXcreateprob (env, &status, argv[nameind]); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. Note that most CPLEX routines return an error code to indicate the reason for failure */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now read the file, and copy the data into the created lp */ status = CPXreadcopyprob (env, lp, argv[nameind], NULL); if ( status ) { fprintf (stderr, "Failed to read and copy the problem data.\n"); goto TERMINATE; } if ( CPXgetnumcols (env, lp) != CPXgetnumbin (env, lp) ) { fprintf (stderr, "Problem contains non-binary variables, exiting\n"); goto TERMINATE; } /* Set parameters */ if ( wantorig ) { /* Assure linear mappings between the presolved and original models */ status = CPXsetintparam (env, CPXPARAM_Preprocessing_Linear, 0); if ( status ) goto TERMINATE; /* Let MIP callbacks work on the original model */ status = CPXsetintparam (env, CPXPARAM_MIP_Strategy_CallbackReducedLP, CPX_OFF); if ( status ) goto TERMINATE; } status = CPXsetdblparam (env, CPXPARAM_MIP_Tolerances_MIPGap, (double) 1e-6); if ( status ) goto TERMINATE; /* Turn on traditional search for use with control callbacks */ status = CPXsetintparam (env, CPXPARAM_MIP_Strategy_Search, CPX_MIPSEARCH_TRADITIONAL); if ( status ) goto TERMINATE; /* Set up to use MIP callback */ status = CPXsetheuristiccallbackfunc (env, rounddownheur, NULL); if ( status ) goto TERMINATE; /* Optimize the problem and obtain solution */ status = CPXmipopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize MIP.\n"); goto TERMINATE; } solstat = CPXgetstat (env, lp); printf ("Solution status %d.\n", solstat); status = CPXgetobjval (env, lp, &objval); if ( status ) { fprintf (stderr, "Failed to obtain objective value.\n"); goto TERMINATE; } printf ("Objective value %.10g\n", objval); cur_numcols = CPXgetnumcols (env, lp); /* Allocate space for solution */ x = (double *) malloc (cur_numcols * sizeof (double)); if ( x == NULL ) { fprintf (stderr, "No memory for solution values.\n"); goto TERMINATE; } status = CPXgetx (env, lp, x, 0, cur_numcols-1); if ( status ) { fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write out the solution */ for (j = 0; j < cur_numcols; j++) { if ( fabs (x[j]) > 1e-10 ) { printf ( "Column %d: Value = %17.10g\n", j, x[j]); } } TERMINATE: /* Free the solution vector */ free_and_null ((char **) &x); /* Free the problem as allocated by CPXcreateprob and CPXreadcopyprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput parameter is set to CPX_ON */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
int main (void) { char probname[16]; /* Problem name is max 16 characters */ int cstat[NUMCOLS]; int rstat[NUMROWS]; /* Declare and allocate space for the variables and arrays where we will store the optimization results including the status, objective value, variable values, dual values, row slacks and variable reduced costs. */ int solstat; double objval; double x[NUMCOLS]; double pi[NUMROWS]; double slack[NUMROWS]; double dj[NUMCOLS]; CPXENVptr env = NULL; CPXLPptr lp = NULL; int status; int i, j; int cur_numrows, cur_numcols; /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem. */ strcpy (probname, "example"); lp = CPXcreateprob (env, &status, probname); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now populate the problem with the data. */ status = populatebycolumn (env, lp); if ( status ) { fprintf (stderr, "Failed to populate problem data.\n"); goto TERMINATE; } /* We assume we know the optimal basis. Variables 1 and 2 are basic, while variable 0 is at its upper bound */ cstat[0] = CPX_AT_UPPER; cstat[1] = CPX_BASIC; cstat[2] = CPX_BASIC; /* The row statuses are all nonbasic for this problem */ rstat[0] = CPX_AT_LOWER; rstat[1] = CPX_AT_LOWER; /* Now copy the basis */ status = CPXcopybase (env, lp, cstat, rstat); if ( status ) { fprintf (stderr, "Failed to copy the basis.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize LP.\n"); goto TERMINATE; } status = CPXsolution (env, lp, &solstat, &objval, x, pi, slack, dj); if ( status ) { fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write the output to the screen. */ printf ("\nSolution status = %d\n", solstat); printf ("Solution value = %f\n", objval); printf ("Iteration count = %d\n\n", CPXgetitcnt (env, lp)); /* The size of the problem should be obtained by asking CPLEX what the actual size is, rather than using sizes from when the problem was built. cur_numrows and cur_numcols store the current number of rows and columns, respectively. */ cur_numrows = CPXgetnumrows (env, lp); cur_numcols = CPXgetnumcols (env, lp); for (i = 0; i < cur_numrows; i++) { printf ("Row %d: Slack = %10f Pi = %10f\n", i, slack[i], pi[i]); } for (j = 0; j < cur_numcols; j++) { printf ("Column %d: Value = %10f Reduced cost = %10f\n", j, x[j], dj[j]); } /* Finally, write a copy of the problem to a file. */ status = CPXwriteprob (env, lp, "lpex6.sav", NULL); if ( status ) { fprintf (stderr, "Failed to write LP to disk.\n"); goto TERMINATE; } TERMINATE: /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
int main (int argc, char *argv[]) { CPXENVptr env = NULL; CPXLPptr lp = NULL; int status = 0; int j; int numcols; double totinv; int solstat; double objval; double *x = NULL; double rrhs[1]; char rsense[1]; int rmatbeg[1]; int *indices = NULL; double *values = NULL; char *namestore = NULL; char **nameptr = NULL; int surplus, storespace; const char * datadir = argc <= 1 ? "../../../examples/data" : argv[1]; char *prod = NULL; prod = (char *) malloc (strlen (datadir) + 1 + strlen("prod.lp") + 1); sprintf (prod, "%s/prod.lp", datadir); /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem, using the filename as the problem name */ lp = CPXcreateprob (env, &status, "prod.lp"); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. Note that most CPLEX routines return an error code to indicate the reason for failure. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now read the file, and copy the data into the created lp */ status = CPXreadcopyprob (env, lp, prod, NULL); if ( status ) { fprintf (stderr, "Failed to read and copy the problem data.\n"); goto TERMINATE; } /* Tell presolve to do only primal reductions, turn off simplex logging */ status = CPXsetintparam (env, CPXPARAM_Preprocessing_Reduce, 1); if ( status ) { fprintf (stderr, "Failed to set CPXPARAM_Preprocessing_Reduce: %d\n", status); goto TERMINATE; } status = CPXsetintparam (env, CPXPARAM_Simplex_Display, 0); if ( status ) { fprintf (stderr, "Failed to set CPXPARAM_Simplex_Display: %d\n", status); goto TERMINATE; } if ( status ) { fprintf (stderr, "Failure to set parameters\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize profit LP.\n"); goto TERMINATE; } solstat = CPXgetstat (env, lp); status = CPXgetobjval (env, lp, &objval); if ( status || solstat != CPX_STAT_OPTIMAL ) { fprintf (stderr, "Solution failed. Status %d, solstat %d.\n", status, solstat); goto TERMINATE; } printf ("Profit objective value is %g\n", objval); /* Allocate space for column names */ numcols = CPXgetnumcols (env, lp); if ( !numcols ) { fprintf (stderr, "No columns in problem\n"); goto TERMINATE; } CPXgetcolname (env, lp, NULL, NULL, 0, &surplus, 0, numcols-1); storespace = - surplus; namestore = (char *) malloc (storespace * sizeof(char)); nameptr = (char **) malloc (numcols * sizeof(char *)); if ( namestore == NULL || nameptr == NULL ) { fprintf (stderr, "No memory for column names\n"); goto TERMINATE; } status = CPXgetcolname (env, lp, nameptr, namestore, storespace, &surplus, 0, numcols-1); if ( status ) { fprintf (stderr, "Failed to get column names\n"); goto TERMINATE; } /* Allocate space for solution */ x = (double *) malloc (numcols * sizeof(double)); if ( x == NULL ) { fprintf (stderr,"No memory for solution.\n"); goto TERMINATE; } status = CPXgetx (env, lp, x, 0, numcols-1); if ( status ) { fprintf (stderr, "Failed to obtain primal solution.\n"); goto TERMINATE; } totinv = 0; for (j = 0; j < numcols; j++) { if ( !strncmp (nameptr[j], "inv", 3) ) totinv += x[j]; } printf ("Inventory level under profit objective is %g\n", totinv); /* Allocate space for a constraint */ indices = (int *) malloc (numcols * sizeof (int)); values = (double *) malloc (numcols * sizeof (double)); if ( indices == NULL || values == NULL ) { fprintf (stderr, "No memory for constraint\n"); goto TERMINATE; } /* Get profit objective and add it as a constraint */ status = CPXgetobj (env, lp, values, 0, numcols-1); if ( status ) { fprintf (stderr, "Failed to get profit objective. Status %d\n", status); goto TERMINATE; } for (j = 0; j < numcols; j++) { indices[j] = j; } rrhs[0] = objval - fabs (objval) * 1e-6; rsense[0] = 'G'; rmatbeg[0] = 0; status = CPXpreaddrows (env, lp, 1, numcols, rrhs, rsense, rmatbeg, indices, values, NULL); if ( status ) { fprintf (stderr, "Failed to add objective as constraint. Status %d\n", status); goto TERMINATE; } /* Set up objective to maximize negative of sum of inventory */ totinv = 0; for (j = 0; j < numcols; j++) { if ( strncmp (nameptr[j], "inv", 3) ) { values[j] = 0.0; } else { values[j] = - 1.0; } } status = CPXprechgobj (env, lp, numcols, indices, values); if ( status ) { fprintf (stderr, "Failed to change to inventory objective. Status %d\n", status); goto TERMINATE; } status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Optimization on inventory level failed. Status %d.\n", status); goto TERMINATE; } solstat = CPXgetstat (env, lp); status = CPXgetobjval (env, lp, &objval); if ( status || solstat != CPX_STAT_OPTIMAL ) { fprintf (stderr, "Solution failed. Status %d, solstat %d.\n", status, solstat); goto TERMINATE; } printf("Solution status %d.\n", solstat); printf ("Inventory level after optimization is %g\n", -objval); status = CPXgetx (env, lp, x, 0, numcols-1); if ( status ) { fprintf (stderr, "Failed to obtain primal solution.\n"); goto TERMINATE; } printf("Found solution"); /* Write out the solution */ printf ("\n"); for (j = 0; j < numcols; j++) { printf ( "%s: Value = %17.10g\n", nameptr[j], x[j]); } TERMINATE: /* Free the filename */ free_and_null ((char **) &prod); /* Free up the basis and solution */ free_and_null ((char **) &indices); free_and_null ((char **) &values); free_and_null ((char **) &nameptr); free_and_null ((char **) &namestore); free_and_null ((char **) &x); /* Free up the problem, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
//========================================================================== int main (int argc, char * argv[]) { // Temporary variables struct stat filestat; char astring[DDSIP_ln_fname]; int status = 0, cont, boundstat, comb, i; // guarantee minimal stacksize limit const rlim_t kStackSize = 128 * 1024 * 1024; // min stack size = 128 MB struct rlimit rl; int result; unsigned long cur_limit; result = getrlimit(RLIMIT_STACK, &rl); if (result == 0) { cur_limit = rl.rlim_cur; printf ("original stacksize limit %lu\n", cur_limit); if (rl.rlim_cur < kStackSize) { rl.rlim_cur = kStackSize; result = setrlimit(RLIMIT_STACK, &rl); if (result != 0) { fprintf(stderr, "setrlimit returned result = %d\n", result); } result = getrlimit(RLIMIT_STACK, &rl); if (result == 0) { cur_limit = rl.rlim_cur; printf ("changed stacksize limit %lu\n", cur_limit); } } } i = argc; // // Welcome printf ("#######################################################################################\n"); printf ("######### D D S I P -- Dual Decomposition In Stochastic Integer Programming #########\n"); printf ("######### %-66s #########\n", DDSIP_version); printf ("For copyright, license agreements, help, comments, requests, ... "); printf ("see\n\thttp://www.uni-duisburg-essen.de/~hn215go/ddsip.shtml\n"); printf ("\thttp://www.www.github.com/RalfGollmer/ddsip\n"); /* printf (" Copyright (C) to University of Duisburg-Essen \n\n"); */ /* printf(" This program is free software; you can redistribute it and/or\n"); */ /* printf (" modify it under the terms of the GNU General Public License\n"); */ /* printf(" as published by the Free Software Foundation; either version 2\n"); */ /* printf (" of the License, or (at your option) any later version.\n\n"); */ /* printf (" This program is distributed in the hope that it will be useful,\n"); */ /* printf(" but WITHOUT ANY WARRANTY; without even the implied warranty of\n"); */ /* printf (" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"); */ /* printf (" GNU General Public License for more details.\n\n"); */ /* printf (" You should have received a copy of the GNU General Public License\n"); */ /* printf(" along with this program; if not, write to the Free Software\n"); */ /* printf (" Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n"); */ /* printf ("==============================================================================\n\n"); */ // These four structures shall carry the whole problem data DDSIP_param = NULL; DDSIP_bb = NULL; DDSIP_data = NULL; DDSIP_node = NULL; // In DDSIP some signals are handled seperatly DDSIP_RegisterSignalHandlers (); // Create output directory if it doesn't already exist if (stat (DDSIP_outdir, &filestat) == -1) { sprintf (astring, "mkdir %s\n", DDSIP_outdir); i = system (astring); printf ("Creating subdirectory %s ...\n", DDSIP_outdir); } // remove possibly existing output file sprintf (astring, "rm -f %s\n", DDSIP_outfname); i = system (astring); // Open output file if ((DDSIP_outfile = fopen (DDSIP_outfname, "a")) == NULL) { fprintf (stderr, "ERROR: Cannot open '%s'. \n", DDSIP_outfname); status = 107; goto TERMINATE; } setbuf (DDSIP_outfile, 0); fprintf (DDSIP_outfile, "%s\n", argv[0]); fprintf (DDSIP_outfile, "-----------------------------------------------------------\n"); fprintf (DDSIP_outfile, "current system time: "); fflush (DDSIP_outfile); #ifndef _WIN32 i = system ("date"); // Print time to output file sprintf (astring, "date >> %s\n", DDSIP_outfname); i = system (astring); fprintf (DDSIP_outfile, "host : "); sprintf (astring, "hostname >> %s; cat /proc/cpuinfo | sed '/processor.*: 0/,/^$/!d' |grep -E 'vendor|cpu |model|stepping|MHz|cache |cores' >> %s\n", DDSIP_outfname, DDSIP_outfname); for (i = 0; i < 100; i++) exp(1.11*(-i-2)); i = system (astring); #else sprintf (astring, "date /T >> %s & time /T >> %s\n", DDSIP_outfname,DDSIP_outfname); i = system (astring); #endif fprintf (DDSIP_outfile, "\nDDSIP %s\n", DDSIP_version); fprintf (DDSIP_outfile, "-----------------------------------------------------------\n"); // Open cplex environment DDSIP_env = CPXopenCPLEX (&status); if (DDSIP_env == NULL) { fprintf (stderr, "ERROR: Failed to open cplex environment, CPLEX error code %d.\n",status); fprintf (DDSIP_outfile, "ERROR: Failed to open cplex environment, CPLEX error code %d.\n",status); return status; } sprintf (astring, "%s", CPXversion (DDSIP_env)); printf ("CPLEX version is %s\n", astring); fprintf (DDSIP_outfile, "CPLEX version is %s\n\n", astring); // Allocate the structures to hold the information on the problem DDSIP_param = (para_t *) DDSIP_Alloc (sizeof (para_t), 1, "param(Main)"); DDSIP_bb = (bb_t *) DDSIP_Alloc (sizeof (bb_t), 1, "bb(Main)"); DDSIP_data = (data_t *) DDSIP_Alloc (sizeof (data_t), 1, "data(Main)"); // Read model (lp) file if ((status = DDSIP_ReadModel ())) goto TERMINATE; // Read specification file if ((status = DDSIP_ReadSpec ())) goto TERMINATE; // Set specified CPLEX parameters if ((status = DDSIP_InitCpxPara ())) goto TERMINATE; // if a Benders annotation file is given, read it if (DDSIP_param->annotationFile) { status = CPXreadcopyannotations (DDSIP_env, DDSIP_lp, DDSIP_param->annotationFile); if ( status ) { fprintf (stderr, "ERROR: Failed to read and copy the annotation data from file %s.\n", DDSIP_param->annotationFile); fprintf (DDSIP_outfile, "ERROR: Failed to read and copy the annotation data from file %s.\n", DDSIP_param->annotationFile); goto TERMINATE; } } // data->cost contains: stoch. costs for all scenarios, followed by the original costs DDSIP_data->cost = (double *) DDSIP_Alloc (sizeof (double), DDSIP_param->scenarios * DDSIP_param->stoccost + DDSIP_data->novar, "cost (ReadData)"); // Store original objective coefficients status = CPXgetobj (DDSIP_env, DDSIP_lp, DDSIP_data->cost + DDSIP_param->scenarios * DDSIP_param->stoccost, 0, DDSIP_data->novar - 1); if (status) { fprintf (stderr, "ERROR: Failed to get objective coefficients\n"); fprintf (DDSIP_outfile, "ERROR: Failed to get objective coefficients\n"); goto TERMINATE; } DDSIP_bb->moreoutfile = NULL; if (DDSIP_param->outlev) { // Open debug output file if ((DDSIP_bb->moreoutfile = fopen (DDSIP_moreoutfname, "a")) == NULL) { fprintf (stderr, "ERROR: Cannot open '%s'. \n", DDSIP_moreoutfname); fprintf (DDSIP_outfile, "ERROR: Cannot open '%s'. \n", DDSIP_moreoutfname); status = 109; goto TERMINATE; } if (DDSIP_param->outlev > 10) { // Buffer size = 0 setbuf (stdout, 0); if (DDSIP_param->outlev > 20) setbuf (DDSIP_bb->moreoutfile, 0); } #ifndef _WIN32 // Print time to output file sprintf (astring, "date > %s\n", DDSIP_moreoutfname); i = system (astring); #else sprintf (astring, "date /T > %s & time /T >> %s\n", DDSIP_moreoutfname,DDSIP_moreoutfname); i = system (astring); #endif fprintf (DDSIP_bb->moreoutfile, "--------------------------------------------------------------"); fprintf (DDSIP_bb->moreoutfile, "---------\nThis is an additional output file of DDSIP. The "); fprintf (DDSIP_bb->moreoutfile, "actual amount of output\nis controlled by the parameter "); fprintf (DDSIP_bb->moreoutfile, "OUTLEV in the specification file.\n---------"); fprintf (DDSIP_bb->moreoutfile, "--------------------------------------------------------------\n\n"); } DDSIP_node = (node_t **) DDSIP_Alloc (sizeof (node_t *), DDSIP_param->nodelim + 3, "node(Main)"); DDSIP_node[0] = (node_t *) DDSIP_Alloc (sizeof (node_t), 1, "node[0](Main)"); DDSIP_node[0]->first_sol = (double **) DDSIP_Alloc (sizeof (double *), DDSIP_param->scenarios, "node[0]->first_sol(Main)"); DDSIP_node[0]->cursubsol = (double *) DDSIP_Alloc (sizeof (double), DDSIP_param->scenarios, "node[0]->cursubsol(Main)"); DDSIP_node[0]->subbound = (double *) DDSIP_Alloc (sizeof (double), DDSIP_param->scenarios, "node[0]->subbound(Main)"); if (DDSIP_param->cb) { DDSIP_node[0]->scenBoundsNoLag = (double *) DDSIP_Alloc (sizeof (double), DDSIP_param->scenarios, "node[0]->scenBoundsNoLag(Main)"); DDSIP_node[0]->BoundNoLag = -DDSIP_infty; } DDSIP_node[0]->mipstatus = (int *) DDSIP_Alloc (sizeof (int), DDSIP_param->scenarios, "node[0]->mipstatus(Main)"); DDSIP_node[0]->ref_scenobj = (double *) DDSIP_Alloc (sizeof (double), DDSIP_param->scenarios, "node[0]->ref_scenobj(Main)"); // Prepare first and second stage variables if ((status = DDSIP_InitStages ())) { fprintf (stderr, "ERROR: Failed to initialize stages\n"); fprintf (DDSIP_outfile, "ERROR: Failed to initialize stages\n"); goto TERMINATE; } // Read data file(s) if ((status = DDSIP_ReadData ())) goto TERMINATE; // Read order file if specified if (DDSIP_param->cpxorder) { status = CPXsetintparam (DDSIP_env, CPX_PARAM_MIPORDIND, 1); if (status) { fprintf (stderr, "ERROR: Failed to set cplex parameter CPX_PARAM_MIPORDIND.\n"); return status; } if (DDSIP_ReadCPLEXOrder ()) goto TERMINATE; } // Detect first and second stage constraints if ((status = DDSIP_DetectStageRows ())) { fprintf (stderr, "ERROR: Failed detection of row stages (BbInit)\n"); fprintf (DDSIP_outfile, "ERROR: Failed detection of row stages (BbInit)\n"); goto TERMINATE; } DDSIP_bb->DDSIP_step = solve; #ifdef CONIC_BUNDLE if (DDSIP_param->cb) { status = DDSIP_NonAnt (); if (status) goto TERMINATE; } #endif if (DDSIP_param->outlev) { printf ("\t Total initialization time: %4.2f seconds.\n", DDSIP_GetCpuTime ()); fprintf (DDSIP_bb->moreoutfile, " Total initialization time: %4.2f seconds.\n", DDSIP_GetCpuTime ()); } #ifndef _WIN32 sprintf (astring, "grep 'MHz' /proc/cpuinfo|sort -r|head -1 >> %s\n", DDSIP_outfname); i = system (astring); #endif // at the start there is no solution status = CPXsetintparam (DDSIP_env, CPX_PARAM_ADVIND, 0); if (status) { fprintf (stderr, "ERROR: Failed to set cplex parameter CPX_PARAM_ADVIND.\n"); fprintf (DDSIP_outfile, "ERROR: Failed to set cplex parameter CPX_PARAM_ADVIND.\n"); return status; } #ifndef NEOS // Write deterministic equivalent (only expectation-based cases) if (DDSIP_param->write_detequ) DDSIP_DetEqu (); #endif if (DDSIP_param->riskmod < 0) { fprintf (stderr, " pure risk models are disabled for now, exiting.\n"); fprintf (DDSIP_outfile, " pure risk models are disabled for now, exiting.\n"); goto TERMINATE; } if (DDSIP_param->stoccost && DDSIP_param->riskmod) { fprintf (DDSIP_outfile, "XXX Error: Risk optimization not implemented for stochastic cost coefficients.\n"); fprintf (stderr, "XXX Error: Risk optimization not implemented for stochastic cost coefficients.\n"); goto TERMINATE; } // Read advanced starting info if (DDSIP_param->advstart) { DDSIP_node[DDSIP_bb->curnode]->step = DDSIP_bb->DDSIP_step = adv; if ((status = DDSIP_AdvStart ())) goto TERMINATE; // Solution provided? if (DDSIP_param->advstart == 2) { DDSIP_bb->curnode = 0; DDSIP_bb->sug[DDSIP_param->nodelim + 2] = (struct sug_l *)DDSIP_Alloc (sizeof (sug_t), 1, "sug[0](Advanced start solution)"); (DDSIP_bb->sug[DDSIP_param->nodelim + 2])->firstval = (double *) DDSIP_Alloc (sizeof (double), DDSIP_bb->firstvar, "sug[0]->firstval(adv start)"); for (i = 0; i < (DDSIP_bb->firstvar); i++) (DDSIP_bb->sug[DDSIP_param->nodelim + 2]->firstval)[i] = DDSIP_bb->adv_sol[i]; (DDSIP_bb->sug[DDSIP_param->nodelim + 2])->next = NULL; if ((status = DDSIP_UpperBound (DDSIP_param->scenarios, 0)) && status < 100000) goto TERMINATE; } // Only weak consistency check: if ((DDSIP_node[0]->bound) > DDSIP_bb->bestvalue) { status = 121; goto TERMINATE; } fprintf (DDSIP_outfile, "-----------------------------------------------------------\n\n"); } // Solve EV and EEV if specified if (DDSIP_param->expected) { DDSIP_node[DDSIP_bb->curnode]->step = DDSIP_bb->DDSIP_step = eev; // status = 1 -> ExpValProb infeasible if ((status = DDSIP_ExpValProb ()) == 1) { if (DDSIP_param->outlev) fprintf (DDSIP_bb->moreoutfile, " exp. val. prob: INFEASIBLE\n"); fprintf (DDSIP_outfile, " exp. val. prob: INFEASIBLE\n"); } if (!status) { DDSIP_bb->curnode = 0; DDSIP_bb->sug[DDSIP_param->nodelim + 2] = (struct sug_l *)DDSIP_Alloc (sizeof (sug_t), 1, "sug[0](Advanced start solution)"); DDSIP_bb->sug[DDSIP_param->nodelim + 2]->firstval = (double *) DDSIP_Alloc (sizeof (double), DDSIP_bb->firstvar, "sug[i]->firstval(Heuristic)"); for (i = 0; i < DDSIP_bb->firstvar; i++) (DDSIP_bb->sug[DDSIP_param->nodelim + 2]->firstval)[i] = DDSIP_bb->adv_sol[i]; DDSIP_bb->sug[DDSIP_param->nodelim + 2]->next = NULL; if ((status = DDSIP_UpperBound (DDSIP_param->scenarios, 0)) && status < 100000) goto TERMINATE; } if (fabs (DDSIP_bb->expbest) < DDSIP_infty) { if (DDSIP_param->outlev) printf ("\t\t EEV: %13.7f\n", DDSIP_bb->expbest); fprintf (DDSIP_outfile, "-EEV: %13.7f\n", DDSIP_bb->expbest); } else { if (DDSIP_param->outlev) printf ("\t\t EEV: No solution found.\n"); fprintf (DDSIP_outfile, "-EEV: No solution found.\n"); } } // END if (EV) // stop here if NODELIM is zero if (!(DDSIP_param->nodelim)) goto TERMINATE; // Print cplex log to debugfile if (DDSIP_param->outlev > 51) { #ifdef CPLEX_12_8 if ((status = CPXsetlogfilename (DDSIP_env, DDSIP_moreoutfname, "a"))) goto TERMINATE; #else if ((status = CPXsetlogfile (DDSIP_env, DDSIP_bb->moreoutfile))) goto TERMINATE; #endif } // No of DDSIP iterations DDSIP_bb->noiter = 0; // cont = 1 if no stop criteria is fullfilled cont = 1; // comb tells in case of a combined heuristic, which one to apply (3 = RoundNear) comb = 3; if (DDSIP_param->outlev) printf ("Starting branch-and-bound algorithm.\n"); fprintf (DDSIP_outfile, "----------------------------------------------------------------------------------------\n"); while (cont) { // the cuts from the root node are contained in every following node model, there is no need to check their violation // for the scenario solutions. But the rounding heuristics could violate a cut, so keep them. #ifdef CONIC_BUNDLE #ifdef DEBUG //////////////////////////////////////////// if (DDSIP_bb->curnode && DDSIP_param->outlev) { if((DDSIP_node[DDSIP_bb->curnode-1])->step == dual) fprintf(DDSIP_bb->moreoutfile, "######## last node %d step=dual, leaf= %d, dualdescitcnt = %d, DDSIP_bb->cutoff= %d\n",DDSIP_bb->curnode-1,(DDSIP_node[DDSIP_bb->curnode-1])->leaf,DDSIP_bb->dualdescitcnt,DDSIP_bb->cutoff); } //////////////////////////////////////////// #endif if (DDSIP_param->outlev > 20 && DDSIP_bb->curnode && DDSIP_node[DDSIP_node[DDSIP_bb->curnode]->father]->cbReturn32) fprintf (DDSIP_bb->moreoutfile, "########## DDSIP_node[%d >father]->cbReturn32 = 1\n", DDSIP_bb->curnode); // Dual method if ((!DDSIP_bb->curnode || !DDSIP_node[DDSIP_node[DDSIP_bb->curnode]->father]->cbReturn32) && ((DDSIP_param->cb > 0 && (!(DDSIP_bb->noiter % abs(DDSIP_param->cb))) && (abs(DDSIP_param->riskmod) != 4 || DDSIP_bb->noiter)) || (DDSIP_param->cb < 0 && (((DDSIP_node[DDSIP_bb->curnode]->depth <= DDSIP_param->cb_depth) && abs(DDSIP_param->riskmod) != 4) || (abs(DDSIP_param->riskmod) == 5 && DDSIP_node[DDSIP_bb->curnode]->depth == 8) || (DDSIP_bb->noiter > DDSIP_param->cbBreakIters && ((!(DDSIP_bb->noiter % abs(DDSIP_param->cb))) || (!((DDSIP_bb->noiter+1) % -DDSIP_param->cb)) || (DDSIP_bb->noiter%200 > 199 - DDSIP_param->cbContinuous) || (DDSIP_bb->noiter < DDSIP_param->cbContinuous + DDSIP_param->cbBreakIters) || ((DDSIP_bb->noiter >= 2*DDSIP_param->cbBreakIters) && (DDSIP_bb->noiter < DDSIP_param->cbContinuous + 2*DDSIP_param->cbBreakIters)) || ((DDSIP_bb->cutoff > 6) && (((DDSIP_bb->no_reduced_front < 51) && (DDSIP_bb->noiter % -DDSIP_param->cb) < DDSIP_param->cbContinuous) || (((DDSIP_node[DDSIP_bb->curnode-1])->step == dual) && (DDSIP_node[DDSIP_bb->curnode-1])->leaf /*&& (DDSIP_bb->dualdescitcnt < 11)*/) ) ) ) ) || (abs(DDSIP_param->riskmod) != 5 && DDSIP_bb->noiter <= DDSIP_param->cbBreakIters && DDSIP_bb->noiter > DDSIP_param->cbBreakIters*.5 && (CBFORALL || (DDSIP_node[DDSIP_bb->curnode]->numInheritedSols > (DDSIP_Imin(DDSIP_param->scenarios/20,2)+(DDSIP_param->scenarios+1)/2)))) ) ) ) ) { DDSIP_bb->DDSIP_step = DDSIP_node[DDSIP_bb->curnode]->step = dual; if ((status = DDSIP_DualOpt ())) { if (!DDSIP_bb->curnode) goto TERMINATE; else { DDSIP_bb->skip = 1; DDSIP_node[DDSIP_bb->curnode]->bound = DDSIP_infty; } } } else { DDSIP_node[DDSIP_bb->curnode]->step = DDSIP_bb->DDSIP_step = solve; // status=1 means there was no solution found to a scenario problem if ((status = DDSIP_LowerBound ())) goto TERMINATE; } #else DDSIP_node[DDSIP_bb->curnode]->step = DDSIP_bb->DDSIP_step = solve; // status=1 means there was no solution found to a subproblem if ((status = LowerBound ())) goto TERMINATE; #endif if (!DDSIP_bb->skip || DDSIP_bb->skip == -1) { double old_bound; int cntr, maxCntr; DDSIP_bb->cutAdded = 0; DDSIP_EvaluateScenarioSolutions (&comb); cntr = 0; if (DDSIP_node[DDSIP_bb->curnode]->step != dual) maxCntr = DDSIP_param->numberReinits; else maxCntr = 0; old_bound = DDSIP_node[DDSIP_bb->curnode]->bound; boundstat = DDSIP_Bound (); if (!DDSIP_bb->curnode) { int cnt, j; double lhs; cutpool_t *currentCut; DDSIP_PrintState (DDSIP_bb->noiter); if (DDSIP_bb->cutAdded && DDSIP_param->outlev) { fprintf (DDSIP_outfile, " %6d%101d cuts\n", DDSIP_bb->curnode, DDSIP_bb->cutAdded); } while ((DDSIP_bb->cutAdded || DDSIP_node[0]->step == dual) && cntr < maxCntr) { old_bound = DDSIP_node[0]->bound; // Free the solutions from former LowerBound for (i = 0; i < DDSIP_param->scenarios; i++) { if (((DDSIP_node[0])->first_sol)[i]) { if (DDSIP_node[0]->step == solve) { currentCut = DDSIP_bb->cutpool; while (currentCut) { lhs = 0.; for (j = 0; j < DDSIP_bb->firstvar; j++) { lhs += (DDSIP_node[0])->first_sol[i][j] * currentCut->matval[j]; } if (lhs < currentCut->rhs - 1.e-7) { #ifdef DEBUG if (DDSIP_param->outlev > 50) fprintf (DDSIP_bb->moreoutfile, "scen %d solution violates cut %d.\n", i+1, currentCut->number); #endif if ((cnt = (int) ((((DDSIP_node[0])->first_sol)[i])[DDSIP_bb->firstvar] - 0.9))) for (j = i + 1; cnt && j < DDSIP_param->scenarios; j++) { { if (((DDSIP_node[0])->first_sol)[j] && ((DDSIP_node[0])->first_sol)[i] == ((DDSIP_node[0])->first_sol)[j]) { ((DDSIP_node[0])->first_sol)[j] = NULL; cnt--; } } } DDSIP_Free ((void **) &(((DDSIP_node[0])->first_sol)[i])); break; } currentCut = currentCut->prev; } } else { if ((cnt = (int) ((((DDSIP_node[0])->first_sol)[i])[DDSIP_bb->firstvar] - 0.9))) for (j = i + 1; cnt && j < DDSIP_param->scenarios; j++) { { if (((DDSIP_node[0])->first_sol)[j] && ((DDSIP_node[0])->first_sol)[i] == ((DDSIP_node[0])->first_sol)[j]) { ((DDSIP_node[0])->first_sol)[j] = NULL; cnt--; } } } DDSIP_Free ((void **) &(((DDSIP_node[0])->first_sol)[i])); } } } DDSIP_node[0]->step = DDSIP_bb->DDSIP_step = solve; // status=1 means there was no solution found to a scenario problem if ((status = DDSIP_LowerBound ())) goto TERMINATE; DDSIP_bb->cutAdded = 0; DDSIP_EvaluateScenarioSolutions (&comb); cntr++; DDSIP_bb->bestbound = DDSIP_node[0]->bound; DDSIP_bb->noiter++; DDSIP_PrintState (1); if (DDSIP_bb->cutAdded && DDSIP_param->outlev) { fprintf (DDSIP_outfile, " %6d %82d. reinit: %8d cuts\n", 0, cntr, DDSIP_bb->cutAdded); } if ((DDSIP_node[0]->bound - old_bound)/(fabs(old_bound) + 1e-16) < 1.e-7 || (DDSIP_bb->bestvalue - DDSIP_node[0]->bound)/(fabs(DDSIP_bb->bestvalue) + 1e-16) < 0.5*DDSIP_param->relgap) break; } if (DDSIP_param->deleteRedundantCuts) DDSIP_CheckRedundancy(1); } else { // Print a line of output at the first, the last and each `ith' node if (!DDSIP_bb->noiter || (!((DDSIP_bb->noiter + 1) % DDSIP_param->logfreq)) || (DDSIP_param->outlev && (DDSIP_node[DDSIP_bb->curnode])->step == dual)) DDSIP_PrintState (DDSIP_bb->noiter); if (DDSIP_bb->cutAdded && DDSIP_param->outlev > 1) { fprintf (DDSIP_outfile, " %6d%101d cuts\n", DDSIP_bb->curnode, DDSIP_bb->cutAdded); } } } else { boundstat = DDSIP_Bound (); // Print a line of output at the first, the last and each `ith' node if (!DDSIP_bb->noiter || (!((DDSIP_bb->noiter + 1) % DDSIP_param->logfreq)) || (DDSIP_param->outlev && (DDSIP_node[DDSIP_bb->curnode])->step == dual)) DDSIP_PrintState (DDSIP_bb->noiter); } if (!DDSIP_bb->curnode) DDSIP_bb->cutCntr0 = DDSIP_bb->cutNumber; else if (DDSIP_param->alwaysBendersCuts) { if (DDSIP_bb->curnode == 24) { if (DDSIP_bb->cutCntr0 == DDSIP_bb->cutNumber) { if (DDSIP_param->outlev > 20) fprintf (DDSIP_bb->moreoutfile, "### setting alwaysBendersCuts to 0\n"); DDSIP_param->alwaysBendersCuts = 0; } else DDSIP_bb->cutCntr0 = DDSIP_bb->cutNumber; } else if (DDSIP_bb->curnode == 49) { if (DDSIP_bb->cutCntr0 == DDSIP_bb->cutNumber) { if (DDSIP_param->outlev > 20) fprintf (DDSIP_bb->moreoutfile, "### setting alwaysBendersCuts to 0\n"); DDSIP_param->alwaysBendersCuts = 0; } else DDSIP_bb->cutCntr0 = DDSIP_bb->cutNumber; } else if (DDSIP_bb->curnode == 99) { if (DDSIP_bb->cutCntr0 == DDSIP_bb->cutNumber) { if (DDSIP_param->outlev > 20) fprintf (DDSIP_bb->moreoutfile, "### setting alwaysBendersCuts to 0\n"); DDSIP_param->alwaysBendersCuts = 0; } } } // DDSIP_bb->skip > 0 indicates that UpperBound calls have been skipped // DDSIP_bb->heurval contains the objective value of the heuristic solution // Reset to initial values DDSIP_bb->heurval = DDSIP_infty; DDSIP_bb->skip = 0; cont = DDSIP_Continue (&DDSIP_bb->noiter, &boundstat); if (!cont) { status = boundstat; goto TERMINATE; } if ((status = DDSIP_Branch ())) goto TERMINATE; if (DDSIP_param->deleteRedundantCuts && !(DDSIP_bb->curnode % 10)) DDSIP_CheckRedundancy(1); } // Termination TERMINATE: DDSIP_PrintErrorMsg (status); printf ("\nOutput files in directory `%s'.\n", DDSIP_outdir); // Free up problem as allocated above // if (DDSIP_node != NULL) { DDSIP_FreeFrontNodes (); for (i = 0; i < DDSIP_bb->nonode; i++) DDSIP_Free ((void **) &(DDSIP_node[i])); DDSIP_Free ((void **) &(DDSIP_node)); } if (DDSIP_data != NULL) { DDSIP_FreeData (); DDSIP_Free ((void **) &(DDSIP_data)); } // Free up the problem as allocated by CPXcreateprob, if necessary if (DDSIP_lp != NULL) { status = CPXfreeprob (DDSIP_env, &DDSIP_lp); if (status) fprintf (stderr, "ERROR: CPXfreeprob failed, error code %d\n", status); } // Free up the CPLEX environment if (DDSIP_env != NULL) { status = CPXcloseCPLEX (&DDSIP_env); if (status) { char errmsg[1024]; fprintf (stderr, "ERROR: Failed to close CPLEX environment.\n"); CPXgeterrorstring (DDSIP_env, status, errmsg); fprintf (stderr, "%s\n", errmsg); } } if (DDSIP_bb != NULL) { DDSIP_FreeBb (); DDSIP_Free ((void **) &(DDSIP_bb)); } if (DDSIP_param->outlev) printf ("Terminating DDSIP.\n"); if (DDSIP_param != NULL) { DDSIP_FreeParam (); DDSIP_Free ((void **) &(DDSIP_param)); } fprintf (DDSIP_outfile, "Current system time: "); #ifndef _WIN32 i = system ("date"); // Print time to output file sprintf (astring, "date >> %s\n", DDSIP_outfname); i = system (astring); #else sprintf (astring, "date /T >> %s & time /T >> %s\n", DDSIP_outfname,DDSIP_outfname); i = system (astring); #endif if (DDSIP_outfile != NULL) fclose (DDSIP_outfile); return 0; }
~IPimpl() { if (lp_) CPXfreeprob(env_, &lp_); if (env_) CPXcloseCPLEX(&env_); }
int main (int argc, char *argv[]) { /* Declare and allocate space for the variables and arrays where we will store the optimization results including the status, objective value, and variable values. */ int solstat; double objval; double *x = NULL; CPXENVptr env = NULL; CPXLPptr lp = NULL; int status; int j; int cur_numcols; /* Check the command line arguments */ if ( argc != 2 ) { usage (argv[0]); goto TERMINATE; } /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Create the problem, using the filename as the problem name */ lp = CPXcreateprob (env, &status, argv[1]); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. Note that most CPLEX routines return an error code to indicate the reason for failure. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now read the file, and copy the data into the created lp */ status = CPXreadcopyprob (env, lp, argv[1], NULL); if ( status ) { fprintf (stderr, "Failed to read and copy the problem data.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ status = CPXmipopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize MIP.\n"); goto TERMINATE; } solstat = CPXgetstat (env, lp); printf ("Solution status %d.\n", solstat); status = CPXgetobjval (env, lp, &objval); if ( status ) { fprintf (stderr,"Failed to obtain objective value.\n"); goto TERMINATE; } printf ("Objective value %.10g\n", objval); /* The size of the problem should be obtained by asking CPLEX what the actual size is. cur_numcols stores the current number of columns. */ cur_numcols = CPXgetnumcols (env, lp); /* Allocate space for solution */ x = (double *) malloc (cur_numcols*sizeof(double)); if ( x == NULL ) { fprintf (stderr, "No memory for solution values.\n"); goto TERMINATE; } status = CPXgetx (env, lp, x, 0, cur_numcols-1); if ( status ) { fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write out the solution */ for (j = 0; j < cur_numcols; j++) { printf ( "Column %d: Value = %17.10g\n", j, x[j]); } TERMINATE: /* Free up the solution */ free_and_null ((char **) &x); /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } return (status); } /* END main */
int main (void) { /* Declare pointers for the variables and arrays that will contain the data which define the LP problem. The setproblemdata() routine allocates space for the problem data. */ char *probname = NULL; int numcols; int numrows; int objsen; double *obj = NULL; double *rhs = NULL; char *sense = NULL; int *matbeg = NULL; int *matcnt = NULL; int *matind = NULL; double *matval = NULL; double *lb = NULL; double *ub = NULL; /* Declare and allocate space for the variables and arrays where we will store the optimization results including the status, objective value, variable values, dual values, row slacks and variable reduced costs. */ int solstat; double objval; double x[NUMCOLS]; double pi[NUMROWS]; double slack[NUMROWS]; double dj[NUMCOLS]; CPXENVptr env = NULL; CPXLPptr lp = NULL; int status; int i, j; int cur_numrows, cur_numcols; /* Initialize the CPLEX environment */ env = CPXopenCPLEX (&status); /* If an error occurs, the status value indicates the reason for failure. A call to CPXgeterrorstring will produce the text of the error message. Note that CPXopenCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( env == NULL ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not open CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); goto TERMINATE; } /* Turn on output to the screen */ status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON); if ( status ) { fprintf (stderr, "Failure to turn on screen indicator, error %d.\n", status); goto TERMINATE; } /* Allocate memory and fill in the data for the problem. */ status = setproblemdata (&probname, &numcols, &numrows, &objsen, &obj, &rhs, &sense, &matbeg, &matcnt, &matind, &matval, &lb, &ub); if ( status ) { fprintf (stderr, "Failed to build problem data arrays.\n"); goto TERMINATE; } /* Create the problem. */ lp = CPXcreateprob (env, &status, probname); /* A returned pointer of NULL may mean that not enough memory was available or there was some other problem. In the case of failure, an error message will have been written to the error channel from inside CPLEX. In this example, the setting of the parameter CPXPARAM_ScreenOutput causes the error message to appear on stdout. */ if ( lp == NULL ) { fprintf (stderr, "Failed to create LP.\n"); goto TERMINATE; } /* Now copy the problem data into the lp */ status = CPXcopylp (env, lp, numcols, numrows, objsen, obj, rhs, sense, matbeg, matcnt, matind, matval, lb, ub, NULL); if ( status ) { fprintf (stderr, "Failed to copy problem data.\n"); goto TERMINATE; } /* Optimize the problem and obtain solution. */ status = CPXlpopt (env, lp); if ( status ) { fprintf (stderr, "Failed to optimize LP.\n"); goto TERMINATE; } status = CPXsolution (env, lp, &solstat, &objval, x, pi, slack, dj); if ( status ) { fprintf (stderr, "Failed to obtain solution.\n"); goto TERMINATE; } /* Write the output to the screen. */ printf ("\nSolution status = %d\n", solstat); printf ("Solution value = %f\n\n", objval); /* The size of the problem should be obtained by asking CPLEX what the actual size is, rather than using what was passed to CPXcopylp. cur_numrows and cur_numcols store the current number of rows and columns, respectively. */ cur_numrows = CPXgetnumrows (env, lp); cur_numcols = CPXgetnumcols (env, lp); for (i = 0; i < cur_numrows; i++) { printf ("Row %d: Slack = %10f Pi = %10f\n", i, slack[i], pi[i]); } for (j = 0; j < cur_numcols; j++) { printf ("Column %d: Value = %10f Reduced cost = %10f\n", j, x[j], dj[j]); } /* Finally, write a copy of the problem to a file. */ status = CPXwriteprob (env, lp, "lpex1.lp", NULL); if ( status ) { fprintf (stderr, "Failed to write LP to disk.\n"); goto TERMINATE; } TERMINATE: /* Free up the problem as allocated by CPXcreateprob, if necessary */ if ( lp != NULL ) { status = CPXfreeprob (env, &lp); if ( status ) { fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status); } } /* Free up the CPLEX environment, if necessary */ if ( env != NULL ) { status = CPXcloseCPLEX (&env); /* Note that CPXcloseCPLEX produces no output, so the only way to see the cause of the error is to use CPXgeterrorstring. For other CPLEX routines, the errors will be seen if the CPXPARAM_ScreenOutput indicator is set to CPX_ON. */ if ( status ) { char errmsg[CPXMESSAGEBUFSIZE]; fprintf (stderr, "Could not close CPLEX environment.\n"); CPXgeterrorstring (env, status, errmsg); fprintf (stderr, "%s", errmsg); } } /* Free up the problem data arrays, if necessary. */ free_and_null ((char **) &probname); free_and_null ((char **) &obj); free_and_null ((char **) &rhs); free_and_null ((char **) &sense); free_and_null ((char **) &matbeg); free_and_null ((char **) &matcnt); free_and_null ((char **) &matind); free_and_null ((char **) &matval); free_and_null ((char **) &lb); free_and_null ((char **) &ub); return (status); } /* END main */
int TSPSolver::resolve(string dataFile, string problemFile, string resultFile) { int result = -1; std::chrono::time_point<std::chrono::system_clock> start; std::chrono::time_point<std::chrono::system_clock> end; if(resultFile != "") { try { //Read the problem datas from a .dat files this->readProblemDatas(dataFile); //Environment initialization DECL_ENV(env); DECL_PROB(env, lp); //Setup the objective function this->setObjectiveFunction(env, lp); //Setup the problem constraints this->setConstraint_1(env, lp); this->setConstraint_2(env, lp); this->setConstraint_3(env, lp); this->setConstraint_4(env, lp); this->setConstraint_5(env, lp); if(problemFile != "") { //Print the file with the problem CHECKED_CPX_CALL(CPXwriteprob, env, lp, problemFile.c_str(), NULL); } //Save the time before the problem is resolved start = std::chrono::system_clock::now(); //Resolve the problem CHECKED_CPX_CALL(CPXmipopt, env, lp); //Save the time after the problem is solved end = std::chrono::system_clock::now(); if(resultFile != "") { //Print the file with the result of the problem CHECKED_CPX_CALL(CPXsolwrite, env, lp, resultFile.c_str()); } //Environment finalization CPXfreeprob(env, &lp); CPXcloseCPLEX(&env); //Print the time spent in search of the solution this->printTime(start, end); result = 0; } catch(exception &ex) { cout << "EXCEPTION -> " << ex.what() << endl; result = -1; } } return result; }