DSP_RTN_CODE SolverInterfaceCpx::getStatus() {
int cpxstat = CPXgetstat(cpx_->getEnvironmentPtr(), cpx_->getLpPtr(OsiCpxSolverInterface::KEEPCACHED_ALL));
if (cpxstat == CPXMIP_NODE_LIM_FEAS ||
cpxstat == CPXMIP_TIME_LIM_FEAS)
return DSP_STAT_LIM_ITERorTIME;
else if (cpxstat == CPXMIP_NODE_LIM_INFEAS ||
cpxstat == CPXMIP_TIME_LIM_INFEAS)
return DSP_STAT_LIM_INFEAS;
return SolverInterfaceOsi::getStatus();
}
void SSCplex::Solve( void )
{
// the solver
#if( MIP )
status = CPXmipopt (env, lp);
if ( status ) {
stop("Failed to optimize MIP.\n", status);
}
int solstat = CPXgetstat (env, lp);
cout << "Solstat " << solstat << endl;
status = CPXgetmipobjval (env, lp, &objval);
if ( status )
stop("No MIP objective value available. Exiting...\n", status);
// get the best solution
int begin = 0;
int end = begin + NArcs;
status = CPXgetmipx (env, lp, Y, begin, end-1);
int k = 0;
bool found = false;
while( !found && ( k < lev_card ))
if( Y[k] )
{
found = true;
cout << "vf 0 on VM " << k << endl;
}
else
k++;
for( int h = 0; h < h_len - 1; h++ )
{
found = false;
int i = 0;
while( !found && ( i < lev_card ))
{
int j = 0;
int offset = lev_card + h * (lev_card * lev_card) + i * lev_card;
while( !found && ( j < lev_card ))
{
if( Y[offset + j] )
{
found = true;
cout << "vf " << h+1 << " on VM " << j << endl;
}
else
j++;
}
i++;
}
}
#endif
}//END SolveMIP
void ProblemMaster::solve(CEnv env, Prob lp) {
// --------------------------------------------------
// 2. solve linear problem
// --------------------------------------------------
CHECKED_CPX_CALL(CPXlpopt, env, lp);
int stat = CPXgetstat(env, lp);
// --------------------------------------------------
// 3. STOP CONDITION
// --------------------------------------------------
if (stat == CPX_STAT_UNBOUNDED || stat == CPX_STAT_INFEASIBLE) {
cout << endl << " STOP PROBLEM MASTER IS UNBOUNDED OR INFEASIBLE " << endl;
cout << " Iteration number: " << iter << endl;
throw std::runtime_error(" STOP CONDITION STEP 1 ");
}
cout << endl << "PROBLEM MASTER:" << endl;
// --------------------------------------------------
// 4. print solution
// --------------------------------------------------
print_objval(env, lp);
// --------------------------------------------------
// 5. set number and value of variable
// (cur_numcols,varVals) and print these
// --------------------------------------------------
set_var_P(env, lp);
print_var_P(env, lp);
// --------------------------------------------------
// 6. chose the best fractional variable
// --------------------------------------------------
int index = select_fractionar_var();
// --------------------------------------------------------
// 7. if x solution aren't integer create P1 and P2 problem
// --------------------------------------------------------
if (index == -1) {
cout << " Iteration number: " << iter << endl;
throw std::runtime_error(
" The last solution is the best integer solution. STOP CONDITION STEP 4 ");
}
}
double *PartitionedColoringModel::getCurrentSolution() {
int status;
// Chequeamos el estado de la solucion.
int solstat;
char statstring[510];
CPXCHARptr p;
solstat = CPXgetstat(this->cplexEnvironment, this->linearProblem);
p = CPXgetstatstring(this->cplexEnvironment, solstat, statstring);
string statstr(statstring);
//cout << endl << "Resultado de la optimizacion: " << statstring << endl;
if(solstat != CPXMIP_OPTIMAL && solstat != CPXMIP_OPTIMAL_TOL && solstat != CPXMIP_NODE_LIM_FEAS && solstat != CPXMIP_TIME_LIM_FEAS) {
exit(1);
}
double objval;
status = CPXgetobjval(this->cplexEnvironment, this->linearProblem, &objval);
if(status) {
cerr << "Problema obteniendo valor de mejor solucion." << endl;
exit(1);
}
//cout << "Datos de la resolucion: " << "\t" << objval << "\n";
// Tomamos los valores de todas las variables. Estan numeradas de 0 a n-1.
this->clearCurrentSolution();
this->currentSolution = new double[this->amountOfVariables];
status = CPXgetx(this->cplexEnvironment, this->linearProblem, this->currentSolution, 0, this->amountOfVariables - 1);
if(status) {
cerr << "Problema obteniendo la solucion del LP." << endl;
exit(1);
}
return this->currentSolution;
}
bool CplexSolver::isOptimal() const {
return CPXgetstat(_env, _prob) == CPXMIP_OPTIMAL || CPXgetstat(_env, _prob) == CPXMIP_OPTIMAL_TOL || CPXgetstat(_env, _prob) == CPXMIP_POPULATESOL_LIM || CPXgetstat(_env, _prob) == CPXMIP_OPTIMAL_POPULATED
|| CPXgetstat(_env, _prob) == CPXMIP_OPTIMAL_POPULATED_TOL;
}
int main(int argc, char **argv) {
char ejes[100];
char labels[100];
char test[100];
archivoInput = argv[1];
randomness = argv[2];
porcentajeParticiones = atof(argv[3]);
algoritmo = argv[4];
epsilonClique = atof(argv[5]);
epsilonAgujero = atof(argv[6]);
numeroDeModelo = atoi(argv[7]);
RECORRIDO_ARBOL = atoi(argv[8]);
VARIABLE_CORTE = atoi(argv[9]);
semilla = atoi(argv[10]);
srand(semilla);
if(not freopen(archivoInput.c_str(), "r", stdin)){
cout << "No pude abrir archivo: " << archivoInput << endl;
return 1;
}
sprintf(ejes, "ejes.out");
sprintf(labels, "labels.out");
if(randomness == "notrandom") {
sprintf(test, "%s%s", argv[1], argv[2]);
}
else if (randomness == "random") {
sprintf(test, "%s%s", argv[1], argv[3]);
}
else{
cout << "Paramtros mal introducidos" << endl;
return 0;
}
read(randomness); // cada elemento de la particion conformado por un unico nodo
// Le paso por parametro el algoritmo a implementar: bb = branch and bound, cb = cut and branch
if(algoritmo != "bb" && algoritmo != "cb") {
cout << "Error introduciendo parametro de algoritmo a ser aplicado " << endl;
return 0;
}
// ==============================================================================================
// Genero el problema de cplex.
int status;
// Creo el entorno.
CPXENVptr env = CPXopenCPLEX(&status); // Puntero al entorno.
CPXLPptr lp; // Puntero al LP
if (env == NULL) {
cerr << "Error creando el entorno" << endl;
exit(1);
}
///Iniciio el reloj
CPXgettime(env, &inittime);
// Creo el LP.
lp = CPXcreateprob(env, &status, "instancia coloreo de grafo particionado");
if (lp == NULL) {
cerr << "Error creando el LP" << endl;
exit(1);
}
// Definimos las variables. En total, son P + N*P variables ( las W[j] y las X[i][j] )
int cantVariables = P + N*P;
double *ub, *lb, *objfun; // Cota superior, cota inferior, coeficiente de la funcion objetivo.
char *xctype, **colnames; // tipo de la variable , string con el nombre de la variable.
ub = new double[cantVariables];
lb = new double[cantVariables];
objfun = new double[cantVariables];
xctype = new char[cantVariables];
colnames = new char*[cantVariables];
for (int i = 0; i < cantVariables; i++) {
ub[i] = 1.0; // seteo upper y lower bounds de cada variable
lb[i] = 0.0;
if(i < P) { // agrego el costo en la funcion objetivo de cada variables
objfun[i] = 1; // busco minimizar Sum(W_j) para j=0..P (la cantidad de colores utilizados).
}
else {
objfun[i] = 0; // los X[i][j] no contribuyen a la funcion objetivo
}
xctype[i] = 'B'; // 'C' es continua, 'B' binaria, 'I' Entera.
colnames[i] = new char[10];
}
/* Defino el tipo de variable BoolVarMatrix, que sera utilizado en la resolucion
* recordar: X_v_j = 1 sii el color j es asignado al vertice v
* recordar: W_j = 1 si X_v_j = 1 para al menos un vertice v
*/
for(int j=0; j<P; j++) {
sprintf(colnames[j], "W_%d", j);
// cout << colnames[j] << endl;
}
for(int i=0; i<N; i++) {
for(int j=0; j<P; j++) {
sprintf(colnames[xijIndice(i,j)], "X_%d_%d", i, j);
// cout << colnames[xijIndice(i,j)] << endl;
}
}
// ========================== Agrego las columnas. =========================== //
if(algoritmo == "cb"){
// si quiero resolver la relajacion, agregar los cortes y despues resolver el MIP, no agrego xctype
status = CPXnewcols(env, lp, cantVariables, objfun, lb, ub, NULL, colnames);
}
else if (algoritmo == "bb"){
// si quiero hacer MIP, directamente, con brancha and bound, agrego xctype
status = CPXnewcols(env, lp, cantVariables, objfun, lb, ub, xctype, colnames);
}
else {
cout << "Error: parametro de algoritmo bb/cb mal introducido" << endl;
return 0;
}
if (status) {
cerr << "Problema agregando las variables CPXnewcols" << endl;
exit(1);
}
// Libero las estructuras.
for (int i = 0; i < cantVariables; i++) {
delete[] colnames[i];
}
delete[] ub;
delete[] lb;
delete[] objfun;
delete[] xctype;
delete[] colnames;
// CPLEX por defecto minimiza. Le cambiamos el sentido a la funcion objetivo si se quiere maximizar.
// CPXchgobjsen(env, lp, CPX_MAX);
// ================================================================================================ //
// ===================================== Restricciones ============================================ //
// i) Asigno exactamente un color a exactamente un vertice de cada particion ( P restricciones )
// ii) Dos vertices adyacentes no pueden tener el mismo color ( E restricciones )
// iii) Los W_j estan bien armados, en funcion de X_v_j ( 2*P restricciones )
// ccnt = numero nuevo de columnas en las restricciones.
// rcnt = cuantas restricciones se estan agregando.
// nzcnt = # de coeficientes != 0 a ser agregados a la matriz. Solo se pasan los valores que no son cero.
int ccnt = 0;
int rcnt;
if(numeroDeModelo == 0){
rcnt = P + (E*P)/2 + 2*P; // Cota maxima a la cantidad de restricciones
}
else{
rcnt = P + (E*P)/2 + N*P;
}
// (E/2 porque en la entrada se supone que en la entrada me pasan 2 veces cada eje)
int nzcnt = 0; // al ppio es cero (para cada valor q agrego, lo voy a incrementar en 1)
char sense[rcnt]; // Sentido de la desigualdad. 'G' es mayor o igual y 'E' para igualdad, 'L' menor o igual
double *rhs = new double[rcnt]; // Termino independiente de las restricciones.
int *matbeg = new int[rcnt]; //Posicion en la que comienza cada restriccion en matind y matval.
int *matind = new int[rcnt*cantVariables]; // Array con los indices de las variables con coeficientes != 0 en la desigualdad.
double *matval = new double[rcnt*cantVariables]; // Array que en la posicion i tiene coeficiente ( != 0) de la variable matind[i] en la restriccion.
// CPLEX va a leer hasta la cantidad nzcnt que le pasemos.
int cantRestricciones = 0; // r = numero de restriccion
// i) P restricciones - exactamente un color a cada vertice (una restriccion por cada particion)
for(int particion = 0; particion < P; particion++) {
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 1;
sense[cantRestricciones] = 'E';
for(int e = 0; e < S[particion].size(); e++) {
for(int color = 0; color < P; color++) {
matind[nzcnt] = xijIndice(S[particion][e], color);
matval[nzcnt] = 1;
nzcnt++;
}
}
cantRestricciones++;
}
// ii) Cota superior de (E*P)/2 restricciones mas
// Una para cada par de vecinos i j, para cada color pero solo cuando i < j, y estan en distinta particion
for(int i = 0; i < N; i++) {
for(int j = i + 1; j < N; j++) {
if(M[i][j] == 1 and dameParticion(i) != dameParticion(j)){
for(int color = 0; color < P; color++) {
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 1;
sense[cantRestricciones] = 'L';
matind[nzcnt] = xijIndice(i,color);
matval[nzcnt] = 1;
nzcnt++;
matind[nzcnt] = xijIndice(j,color);
matval[nzcnt] = 1;
nzcnt++;
cantRestricciones++;
}
}
}
}
if(numeroDeModelo == 0){
// iii) 2*P restricciones mas
// - P * wj + sigma xij <= 0
for(int k=0; k<P; k++) { // para cada color
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 0;
sense[cantRestricciones] = 'L';
matind[nzcnt] = k;
matval[nzcnt] = -1 * P;
nzcnt++;
for(int i=0; i<N; i++) {
matind[nzcnt] = xijIndice(i,k);
matval[nzcnt] = 1;
nzcnt++;
}
cantRestricciones++;
}
// - wj + sigma xij >= 0
for(int k=0; k<P; k++) {
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 0;
sense[cantRestricciones] = 'G';
matind[nzcnt] = k;
matval[nzcnt] = -1;
nzcnt++;
for(int i=0; i<N; i++) {
matind[nzcnt] = xijIndice(i,k);
matval[nzcnt] = 1;
nzcnt++;
}
cantRestricciones++;
}
}
else{
// iii) N*P restricciones mas
// -wj + xij <= 0
for(int color = 0; color < P; color++) {
for(int i = 0; i < N; i++) {
matbeg[cantRestricciones] = nzcnt;
rhs[cantRestricciones] = 0;
sense[cantRestricciones] = 'L';
matind[nzcnt] = color;
matval[nzcnt] = -1;
nzcnt++;
matind[nzcnt] = xijIndice(i, color);
matval[nzcnt] = 1;
nzcnt++;
cantRestricciones++;
}
}
}
//Actualizo rcnt.
rcnt = cantRestricciones;
// ===================================================================================================
// Agregamos las restricciones al lp.
status = CPXaddrows(env, lp, ccnt, rcnt, nzcnt, rhs, sense, matbeg, matind, matval, NULL, NULL);
if (status) {
cerr << "Problema agregando restricciones." << endl;
exit(1);
}
delete[] rhs;
delete[] matbeg;
delete[] matind;
delete[] matval;
// ============================================================================================== //
// ================================== Optimizamos el problema. ================================== //
// Seteo de algunos parametros.
// Para desactivar la salida poner CPX_OFF.
status = CPXsetintparam(env, CPX_PARAM_SCRIND, CPX_ON);
if (status) {
cerr << "Problema seteando SCRIND" << endl;
exit(1);
}
// Setea el tiempo limite de ejecucion.
status = CPXsetdblparam(env, CPX_PARAM_TILIM, TIEMPO_LIMITE); // setear limite de tiempo en 3600 !!!!!!!
if (status) {
cerr << "Problema seteando el tiempo limite" << endl;
exit(1);
}
// Escribimos el problema a un archivo .lp.
// status = CPXwriteprob(env, lp, "test.lp", NULL);
if (status) {
cerr << "Problema escribiendo modelo" << endl;
exit(1);
}
// Seteamos algunos parametros para resolver con branch and bound
CPXsetintparam(env, CPX_PARAM_MIPSEARCH, CPX_MIPSEARCH_TRADITIONAL);
// Para facilitar la comparación evitamos paralelismo:
CPXsetintparam(env, CPX_PARAM_THREADS, 1);
//Para que no se adicionen planos de corte:
CPXsetintparam(env,CPX_PARAM_EACHCUTLIM, 0);
CPXsetintparam(env, CPX_PARAM_FRACCUTS, -1);
CPXsetintparam(env, CPX_PARAM_LANDPCUTS, -1);
// Para que no haga preprocesamientos
CPXsetintparam(env, CPX_PARAM_PRESLVND, -1);
CPXsetintparam(env, CPX_PARAM_REPEATPRESOLVE, 0);
CPXsetintparam(env, CPX_PARAM_RELAXPREIND, 0);
CPXsetintparam(env, CPX_PARAM_REDUCE, 0);
// Recorrido del arbol
CPXsetintparam(env, CPX_PARAM_NODESEL, RECORRIDO_ARBOL);
// Seleccion de variable
CPXsetintparam(env, CPX_PARAM_VARSEL, VARIABLE_CORTE);
CPXgettime(env, &endtime);
tiempoPreparar = endtime - inittime;
inittime = endtime;
// =========================================================================================================
// resuelvo con cut and branch (con los cortes definidos por nosotros) o con branch and bound (y sin cortes)
// =========================================================================================================
if(algoritmo == "cb") {
// while (algo) ... resolver el lp, chequear si la restr inducida por la clique actual es violada. Seguir
//cout << "antes" << endl;
for(int ciclocb=0; ciclocb<CANT_CICLOS_CB; ciclocb++) {
status = CPXlpopt(env, lp);
//cout << "despues" << endl;
double objval;
status = CPXgetobjval(env, lp, &objval);
// Aca, deberia agregar los cortes requeridos, en funcion de "cliques" y "objval"
// mostrameValores(env, lp);
double *sol = new double[cantVariables];
CPXgetx(env, lp, sol, 0, cantVariables - 1);
//CPXwriteprob (env, lp, "antesDeClique.lp", "LP");
// BUSCAR Y AGREGAR CLIQUE
vector < vector<int> > agregados;
for(int color=0; color<P; color++) {
for(int i=0; i<CANT_RESTR_CLIQUES; i++) {
bool iteracionRandom = (i!=0);
vector<int> clique = dameClique(sol, color, iteracionRandom);
sort(clique.begin(), clique.end());
bool incluido = find(agregados.begin(), agregados.end(), clique) != agregados.end();
if (not incluido and not clique.empty()) {
agregados.push_back(clique);
agregarRestriccionClique(env, lp, clique);
cantidadCortesClique++;
// cout << "AGREGO RESTRICCION DE CLIQUE de random " << iteracionRandom << " y de color #"<< color << ": ";
// for(int j=0; j<clique.size(); j++) {
// cout << clique[j] << " ";
// }
// cout << endl;
}
}
}
// BUSCAR Y AGREGAR AGUJERO
agregados.clear();
for(int color=0; color<P; color++) {
for(int i=0; i<CANT_RESTR_AGUJEROS; i++) {
vector<int> agujero = dameAgujero(sol, color);
bool incluido = find(agregados.begin(), agregados.end(), agujero) != agregados.end();
if (not incluido and not agujero.empty()) {
agregados.push_back(agujero);
agregarRestriccionAgujero(env, lp, agujero);
cantidadCortesAgujero++;
// cout << "AGREGO RESTRICCION DE AGUJERO de color #"<< color << ": ";
// for(int j=0; j<agujero.size(); j++) {
// cout << agujero[j] << " ";
// }
// cout << endl;
}
}
}
delete [] sol;
}
// CPXwriteprob (env, lp, "lpCB.lp", "LP");
///Cuando salimos, pasamos a binaria y corremos un branch and bound
char *ctype = new char[cantVariables];
for (int i = 0; i < cantVariables; i++) {
ctype[i] = 'B';
}
// cout << "Antes cambiar tipo" << endl;
status = CPXcopyctype (env, lp, ctype);
// cout << "Despues cambiar tipo" << endl;
delete[] ctype;
CPXgettime(env, &endtime);
tiempoCutAndBranch = endtime - inittime;
inittime = endtime;
}
///Corremos el BB, ya sea porque esto es lo que queriamos originalemente, o porque terminamos con los planos de corte
// cout << "ANTES" << endl;
//CPXwriteprob (env, lp, "antesDeMip.lp", "LP");
CPXmipopt(env,lp);
// cout << "DESPUES" << endl;
CPXgettime(env, &endtime);
tiempoBranchAndBound = endtime - inittime;
// inittime = endtime;
status = CPXgettime(env, &endtime);
if (status) {
cerr << "Problema optimizando CPLEX" << endl;
exit(1);
}
// Chequeamos el estado de la solucion.
int solstat;
char statstring[510];
CPXCHARptr p;
solstat = CPXgetstat(env, lp);
p = CPXgetstatstring(env, solstat, statstring);
string statstr(statstring);
cout << endl << "Resultado de la optimizacion: " << statstring << endl;
if(solstat!=CPXMIP_OPTIMAL && solstat!=CPXMIP_OPTIMAL_TOL && solstat!=CPXMIP_NODE_LIM_FEAS && solstat!=CPXMIP_TIME_LIM_FEAS){
cout << "No hay solucion" << endl;
}
else{
double objval;
status = CPXgetobjval(env, lp, &objval);
if (status) {
cerr << "Problema obteniendo valor de mejor solucion." << endl;
exit(1);
}
cout << "Datos de la resolucion: " << "\t" << objval << "\t" << tiempoPreparar + tiempoCutAndBranch + tiempoBranchAndBound << endl;
cout << "Tiempo en preparar: " << "\t" << tiempoPreparar << endl;
cout << "Tiempo en CB: " << "\t" << tiempoCutAndBranch << endl;
cout << "Tiempo en BB: " << "\t" << tiempoBranchAndBound << endl;
// Tomamos los valores de todas las variables. Estan numeradas de 0 a n-1.
double *sol = new double[cantVariables];
status = CPXgetx(env, lp, sol, 0, cantVariables - 1);
if (status) {
cerr << "Problema obteniendo la solucion del LP." << endl;
exit(1);
}
impresionModelo(env, lp);
// Solo escribimos las variables distintas de cero (tolerancia, 1E-05).
//solfile << "Status de la solucion: " << statstr << endl;
// for(int j=0; j<P; j++) {
// if(sol[j] > TOL) {
// cout << "W_" << j << " = " << sol[j] << endl;
// }
// }
// for(int i=0; i<N; i++) {
// for(int j=0; j<P; j++) {
// if(sol[P + P*i + j] > TOL) {
// cout << "X_" << i << "_" << j << " = " << sol[P+P*i+j] << endl;
// }
// }
// }
//solfile.close();
// ==================== Devuelvo el grafo resultante coloreado, para graficar! ====================== //
// ofstream streamEjes, streamLabels;
//ofstream streamParticiones;
// Tomamos los valores de la solucion y los escribimos a un archivo.
// streamEjes.open(ejes);
// for(int v1=0; v1<N; v1++) {
// for(int v2=v1+1; v2<N; v2++) {
// if (M[v1][v2] == 1) {
// streamEjes << v1+1 << " " << v2+1 << endl;
// }
// }
// } streamEjes.close();
// cout << ejes << endl;
// streamLabels.open(labels);
// bool estaColoreado;
// for(int v=0; v<N; v++){
// estaColoreado = false;
// for(int j=0; j<P; j++){
// if (sol[P + P*v + j] == 1) {
// streamLabels << v+1 << " " << j+1 << endl;
// estaColoreado = true;
// }
// }
// if(not estaColoreado) {
// streamLabels << v+1 << " " << 0 << endl;
// }
// }
// streamLabels.close();
// delete [] sol;
}
return 0;
}
OptSolutionData* CPLEXRunSolver(int ProbType) {
OptSolutionData* NewSolution = NULL;
int Status = 0;
if (ProbType == LP) {
Status = CPXsetintparam (CPLEXenv, CPX_PARAM_LPMETHOD, CPX_ALG_AUTOMATIC);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
Status = CPXsetintparam (CPLEXenv, CPX_PARAM_SIMDISPLAY, 0);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
Status = CPXchgprobtype(CPLEXenv, CPLEXModel, CPXPROB_LP);
Status = CPXlpopt(CPLEXenv, CPLEXModel);
} else if(ProbType == MILP || ProbType == MIQP) {
//Setting the bound tightening on high
Status = CPXsetintparam (CPLEXenv, CPX_PARAM_BNDSTRENIND, 1);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
//Setting tolerance to 1e-9 instead of 1e-6
double tolerance = atof(GetParameter("Solver tolerance").data());
Status = CPXsetdblparam(CPLEXenv,CPX_PARAM_EPRHS, tolerance);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
Status = CPXsetdblparam(CPLEXenv,CPX_PARAM_EPINT, tolerance);
if (Status) {
FErrorFile() << "Failed to set the optimization method." << endl;
FlushErrorFile();
return NULL;
}
//Deactivates all messages from MIP solver
Status = CPXchgprobtype(CPLEXenv, CPLEXModel, CPXPROB_MILP);
Status = CPXmipopt (CPLEXenv, CPLEXModel);
} else if(ProbType == QP) {
Status = CPXqpopt (CPLEXenv, CPLEXModel);
}
if (Status ) {
cout << "Failed to optimize LP." << endl;
return NULL;
}
int Temp = CPXgetstat (CPLEXenv, CPLEXModel);
NewSolution = new OptSolutionData;
if (Temp == CPX_STAT_UNBOUNDED) {
cout << "Model is unbounded" << endl;
FErrorFile() << "Model is unbounded" << endl;
FlushErrorFile();
NewSolution->Status = UNBOUNDED;
return NewSolution;
} else if (Temp == CPX_STAT_INFEASIBLE) {
cout << "Model is infeasible" << endl;
FErrorFile() << "Model is infeasible" << endl;
FlushErrorFile();
NewSolution->Status = INFEASIBLE;
return NewSolution;
} else if (Temp == CPX_STAT_INForUNBD ) {
cout << "Model is infeasible or unbounded" << endl;
FErrorFile() << "Model is infeasible or unbounded" << endl;
FlushErrorFile();
NewSolution->Status = INFEASIBLE;
return NewSolution;
} else {
NewSolution->Status = SUCCESS;
}
int NumberColumns = CPXgetnumcols (CPLEXenv, CPLEXModel);
int NumberRows = CPXgetnumrows (CPLEXenv, CPLEXModel);
NewSolution->NumVariables = NumberColumns;
NewSolution->SolutionData.resize(NumberColumns);
double* x = new double[NumberColumns];
if (ProbType == MILP || ProbType == MIQP) {
Status = CPXgetmipobjval (CPLEXenv, CPLEXModel, &(NewSolution->Objective));
Status = CPXgetmipx (CPLEXenv, CPLEXModel, x, 0, NumberColumns-1);
} else {
Status = CPXsolution(CPLEXenv,CPLEXModel,NULL,&(NewSolution->Objective),x,NULL,NULL,NULL);
}
if ( Status ) {
cout << "Failed to obtain objective value." << endl;
delete [] x;
NewSolution->Status = INFEASIBLE;
return NewSolution;
}
cout << "Objective value: " << NewSolution->Objective << endl;
/*
string* StrNames = new string[NumberColumns];
char** Names = new char*[NumberColumns];
char* NameStore = new char[7*NumberColumns];
int Surplus = 0;
Status = CPXgetcolname(CPLEXenv, CPLEXModel, Names, NameStore, 7*NumberColumns, &Surplus, 0, NumberColumns-1);
if (Status) {
FErrorFile() << "Failed to get column names." << endl;
FlushErrorFile();
delete [] StrNames;
delete [] Names;
delete [] NameStore;
delete [] x;
delete NewSolution;
return NULL;
}
*/
for (int i=0; i < NumberColumns; i++) {
//StrNames[i].assign(Names[i]);
//StrNames[i] = StrNames[i].substr(1, StrNames[i].length()-1);
//NewSolution->SolutionData[atoi(StrNames[i].data())-1] = x[i];
NewSolution->SolutionData[i] = x[i];
}
/*
delete [] StrNames;
delete [] Names;
delete [] NameStore;
*/
delete [] x;
return NewSolution;
}
int
main (void)
{
int status, solstat;
CPXENVptr env;
CPXLPptr lp;
int i;
double x[NUMCOLS];
double cpi[NUMCOLS];
double rpi[NUMROWS];
double qpi[NUMQS];
double slack[NUMROWS], qslack[NUMQS];
double kktsum[NUMCOLS];
/* ********************************************************************** *
* *
* S E T U P P R O B L E M *
* *
* ********************************************************************** */
/* Create CPLEX environment and enable screen output.
*/
env = CPXopenCPLEX (&status);
if ( status != 0 )
goto TERMINATE;
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status != 0 )
goto TERMINATE;
/* Create the problem object and populate it.
*/
lp = CPXcreateprob (env, &status, "qcpdual");
if ( status != 0 )
goto TERMINATE;
status = CPXnewcols (env, lp, NUMCOLS, obj, lb, ub, NULL, cname);
if ( status != 0 )
goto TERMINATE;
status = CPXaddrows (env, lp, 0, NUMROWS, NUMNZS, rhs, sense,
rmatbeg, rmatind, rmatval, NULL, rname);
if ( status != 0 )
goto TERMINATE;
for (i = 0; i < NUMQS; ++i) {
int const linend = (i == NUMQS - 1) ? NUMLINNZ : linbeg[i + 1];
int const quadend = (i == NUMQS - 1) ? NUMQUADNZ : quadbeg[i + 1];
status = CPXaddqconstr (env, lp, linend - linbeg[i],
quadend - quadbeg[i], qrhs[i], qsense[i],
&linind[linbeg[i]], &linval[linbeg[i]],
&quadrow[quadbeg[i]], &quadcol[quadbeg[i]],
&quadval[quadbeg[i]], qname[i]);
if ( status != 0 )
goto TERMINATE;
}
/* ********************************************************************** *
* *
* O P T I M I Z E P R O B L E M *
* *
* ********************************************************************** */
status = CPXsetdblparam (env, CPXPARAM_Barrier_QCPConvergeTol, 1e-10);
if ( status != 0 )
goto TERMINATE;
/* Solve the problem.
*/
status = CPXbaropt (env, lp);
if ( status != 0 )
goto TERMINATE;
solstat = CPXgetstat (env, lp);
if ( solstat != CPX_STAT_OPTIMAL ) {
fprintf (stderr, "No optimal solution found!\n");
goto TERMINATE;
}
/* ********************************************************************** *
* *
* Q U E R Y S O L U T I O N *
* *
* ********************************************************************** */
/* Optimal solution and slacks for linear and quadratic constraints. */
status = CPXgetx (env, lp, x, 0, NUMCOLS - 1);
if ( status != 0 )
goto TERMINATE;
status = CPXgetslack (env, lp, slack, 0, NUMROWS - 1);
if ( status != 0 )
goto TERMINATE;
status = CPXgetqconstrslack (env, lp, qslack, 0, NUMQS - 1);
if ( status != 0 )
goto TERMINATE;
/* Dual multipliers for linear constraints and bound constraints. */
status = CPXgetdj (env, lp, cpi, 0, NUMCOLS - 1);
if ( status != 0 )
goto TERMINATE;
status = CPXgetpi (env, lp, rpi, 0, NUMROWS - 1);
if ( status != 0 )
goto TERMINATE;
status = getqconstrmultipliers (env, lp, x, qpi, ZEROTOL);
if ( status != 0 )
goto TERMINATE;
/* ********************************************************************** *
* *
* C H E C K K K T C O N D I T I O N S *
* *
* Here we verify that the optimal solution computed by CPLEX (and *
* the qpi[] values computed above) satisfy the KKT conditions. *
* *
* ********************************************************************** */
/* Primal feasibility: This example is about duals so we skip this test. */
/* Dual feasibility: We must verify
* - for <= constraints (linear or quadratic) the dual
* multiplier is non-positive.
* - for >= constraints (linear or quadratic) the dual
* multiplier is non-negative.
*/
for (i = 0; i < NUMROWS; ++i) {
switch (sense[i]) {
case 'E': /* nothing */ break;
case 'R': /* nothing */ break;
case 'L':
if ( rpi[i] > ZEROTOL ) {
fprintf (stderr,
"Dual feasibility test failed for <= row %d: %f\n",
i, rpi[i]);
status = -1;
goto TERMINATE;
}
break;
case 'G':
if ( rpi[i] < -ZEROTOL ) {
fprintf (stderr,
"Dual feasibility test failed for >= row %d: %f\n",
i, rpi[i]);
status = -1;
goto TERMINATE;
}
break;
}
}
for (i = 0; i < NUMQS; ++i) {
switch (qsense[i]) {
case 'E': /* nothing */ break;
case 'L':
if ( qpi[i] > ZEROTOL ) {
fprintf (stderr,
"Dual feasibility test failed for <= quad %d: %f\n",
i, qpi[i]);
status = -1;
goto TERMINATE;
}
break;
case 'G':
if ( qpi[i] < -ZEROTOL ) {
fprintf (stderr,
"Dual feasibility test failed for >= quad %d: %f\n",
i, qpi[i]);
status = -1;
goto TERMINATE;
}
break;
}
}
/* Complementary slackness.
* For any constraint the product of primal slack and dual multiplier
* must be 0.
*/
for (i = 0; i < NUMROWS; ++i) {
if ( sense[i] != 'E' && fabs (slack[i] * rpi[i]) > ZEROTOL ) {
fprintf (stderr,
"Complementary slackness test failed for row %d: %f\n",
i, fabs (slack[i] * rpi[i]));
status = -1;
goto TERMINATE;
}
}
for (i = 0; i < NUMQS; ++i) {
if ( qsense[i] != 'E' && fabs (qslack[i] * qpi[i]) > ZEROTOL ) {
fprintf (stderr,
"Complementary slackness test failed for quad %d: %f\n",
i, fabs (qslack[i] * qpi[i]));
status = -1;
goto TERMINATE;
}
}
for (i = 0; i < NUMCOLS; ++i) {
if ( ub[i] < CPX_INFBOUND ) {
double const slk = ub[i] - x[i];
double const dual = cpi[i] < -ZEROTOL ? cpi[i] : 0.0;
if ( fabs (slk * dual) > ZEROTOL ) {
fprintf (stderr,
"Complementary slackness test failed for ub %d: %f\n",
i, fabs (slk * dual));
status = -1;
goto TERMINATE;
}
}
if ( lb[i] > -CPX_INFBOUND ) {
double const slk = x[i] - lb[i];
double const dual = cpi[i] > ZEROTOL ? cpi[i] : 0.0;
if ( fabs (slk * dual) > ZEROTOL ) {
printf ("lb=%f, x=%f, cpi=%f\n", lb[i], x[i], cpi[i]);
fprintf (stderr,
"Complementary slackness test failed for lb %d: %f\n",
i, fabs (slk * dual));
status = -1;
goto TERMINATE;
}
}
}
/* Stationarity.
* The difference between objective function and gradient at optimal
* solution multiplied by dual multipliers must be 0, i.e., for the
* optimal solution x
* 0 == c
* - sum(r in rows) r'(x)*rpi[r]
* - sum(q in quads) q'(x)*qpi[q]
* - sum(c in cols) b'(x)*cpi[c]
* where r' and q' are the derivatives of a row or quadratic constraint,
* x is the optimal solution and rpi[r] and qpi[q] are the dual
* multipliers for row r and quadratic constraint q.
* b' is the derivative of a bound constraint and cpi[c] the dual bound
* multiplier for column c.
*/
/* Objective function. */
for (i = 0; i < NUMCOLS; ++i)
kktsum[i] = obj[i];
/* Linear constraints.
* The derivative of a linear constraint ax - b (<)= 0 is just a.
*/
for (i = 0; i < NUMROWS; ++i) {
int const end = (i == NUMROWS - 1) ? NUMNZS : rmatbeg[i + 1];
int k;
for (k = rmatbeg[i]; k < end; ++k)
kktsum[rmatind[k]] -= rpi[i] * rmatval[k];
}
/* Quadratic constraints.
* The derivative of a constraint xQx + ax - b <= 0 is
* Qx + Q'x + a.
*/
for (i = 0; i < NUMQS; ++i) {
int j;
int k;
for (j = linbeg[i]; j < linbeg[i] + linnzcnt[i]; ++j)
kktsum[linind[j]] -= qpi[i] * linval[j];
for (k = quadbeg[i]; k < quadbeg[i] + quadnzcnt[i]; ++k) {
kktsum[quadrow[k]] -= qpi[i] * x[quadcol[k]] * quadval[k];
kktsum[quadcol[k]] -= qpi[i] * x[quadrow[k]] * quadval[k];
}
}
/* Bounds.
* The derivative for lower bounds is -1 and that for upper bounds
* is 1.
* CPLEX already returns dj with the appropriate sign so there is
* no need to distinguish between different bound types here.
*/
for (i = 0; i < NUMCOLS; ++i) {
kktsum[i] -= cpi[i];
}
for (i = 0; i < NUMCOLS; ++i) {
if ( fabs (kktsum[i]) > ZEROTOL ) {
fprintf (stderr, "Stationarity test failed at index %d: %f\n",
i, kktsum[i]);
status = -1;
goto TERMINATE;
}
}
/* KKT conditions satisfied. Dump out the optimal solutions and
* the dual values.
*/
printf ("Optimal solution satisfies KKT conditions.\n");
printf (" x[] =");
for (i = 0; i < NUMCOLS; ++i)
printf (" %7.3f", x[i]);
printf ("\n");
printf ("cpi[] =");
for (i = 0; i < NUMCOLS; ++i)
printf (" %7.3f", cpi[i]);
printf ("\n");
printf ("rpi[] =");
for (i = 0; i < NUMROWS; ++i)
printf (" %7.3f", rpi[i]);
printf ("\n");
printf ("qpi[] =");
for (i = 0; i < NUMQS; ++i)
printf (" %7.3f", qpi[i]);
printf ("\n");
TERMINATE:
/* ********************************************************************** *
* *
* C L E A N U P *
* *
* ********************************************************************** */
status = CPXfreeprob (env, &lp);
if ( status != 0 ) {
fprintf (stderr, "WARNING: Failed to free problem: %d\n", status);
}
status = CPXcloseCPLEX (&env);
if ( status != 0 ) {
fprintf (stderr, "WARNING: Failed to close CPLEX: %d\n", status);
}
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,
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 (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 (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[])
{
/* 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 */
//==========================================================================
// This function solves the expected value problem
int
DDSIP_ExpValProb (void)
{
int status, j, mipstatus, nodes_1st = -1;
int wall_hrs, wall_mins,cpu_hrs, cpu_mins;
double objval, bobjval, time_start, time_end, wall_secs, cpu_secs, gap;
char fname[DDSIP_ln_fname];
double *mipx = (double *) DDSIP_Alloc (sizeof (double), (DDSIP_bb->firstvar + DDSIP_bb->secvar),
"mipx(ExpValProb)");
printf ("Solving expected value problem\n");
if (DDSIP_param->outlev)
fprintf (DDSIP_bb->moreoutfile, "Solving expected value problem...\n");
status = DDSIP_ChgProb (-1, 0);
if (status)
{
fprintf (stderr, "ERROR: Failed to change problem \n");
goto TERMINATE;
}
if (DDSIP_param->files > 1)
{
sprintf (fname, "%s/ev%s", DDSIP_outdir, DDSIP_param->coretype);
status = CPXwriteprob (DDSIP_env, DDSIP_lp, fname, NULL);
if (status)
{
fprintf (stderr, "ERROR: Failed to write problem\n");
goto TERMINATE;
}
}
// New cplex parameters
if (DDSIP_param->cpxnoeev)
{
status = DDSIP_SetCpxPara (DDSIP_param->cpxnoeev, DDSIP_param->cpxeevisdbl, DDSIP_param->cpxeevwhich, DDSIP_param->cpxeevwhat);
if (status)
{
fprintf (stderr, "ERROR: Failed to set CPLEX parameters (ExpValProb) \n");
goto TERMINATE;
}
}
time_start = DDSIP_GetCpuTime ();
mipstatus = CPXmipopt (DDSIP_env, DDSIP_lp);
// Reset cplex parameters
if (DDSIP_param->cpxnoeev)
{
status = DDSIP_SetCpxPara (DDSIP_param->cpxno, DDSIP_param->cpxisdbl, DDSIP_param->cpxwhich, DDSIP_param->cpxwhat);
if (status)
{
fprintf (stderr, "ERROR: Failed to reset CPLEX parameters (ExpValProb) \n");
goto TERMINATE;
}
}
if (DDSIP_Error (mipstatus))
{
fprintf (stderr, "ERROR: Failed to optimize EXP\n");
status = mipstatus;
goto TERMINATE;
}
// Error ? (blatant infeasible, scenario problem limit)
if (DDSIP_Infeasible (mipstatus))
{
status = 1;
goto TERMINATE;
}
// No solution found ? (integer infeasible, some limit (node, time))
mipstatus = CPXgetstat (DDSIP_env, DDSIP_lp);
if (DDSIP_NoSolution (mipstatus))
{
status = 1;
goto TERMINATE;
}
status = CPXgetx (DDSIP_env, DDSIP_lp, mipx, 0, DDSIP_bb->firstvar + DDSIP_bb->secvar - 1);
if (status)
{
fprintf (stderr, "ERROR: Failed to get solution \n");
goto TERMINATE;
}
// output of result
if (DDSIP_param->outlev)
{
status = CPXgetobjval (DDSIP_env, DDSIP_lp, &objval);
if (status)
{
fprintf (stderr, "ERROR*: Failed to get best objective value \n");
fprintf (DDSIP_outfile, "ERROR*: Failed to get best objective value \n");
if (DDSIP_param->outlev)
fprintf (DDSIP_bb->moreoutfile, "ERROR*: Failed to get best objective value \n");
goto TERMINATE;
}
if (mipstatus == CPXMIP_OPTIMAL)
{
bobjval = objval;
}
else
{
status = CPXgetbestobjval (DDSIP_env, DDSIP_lp, &bobjval);
if (status)
{
fprintf (stderr, "ERROR: Failed to get value of best remaining node\n");
fprintf (DDSIP_outfile, "ERROR: Failed to get value of best remaining node\n");
if (DDSIP_param->outlev)
fprintf (DDSIP_bb->moreoutfile, "ERROR: Failed to get value of best remaining node\n");
goto TERMINATE;
}
}
gap = 100.0*(objval-bobjval)/(fabs(objval)+1e-4);
nodes_1st = CPXgetnodecnt (DDSIP_env,DDSIP_lp);
time_end = DDSIP_GetCpuTime ();
time_start = time_end-time_start;
time (&DDSIP_bb->cur_time);
DDSIP_translate_time (difftime(DDSIP_bb->cur_time,DDSIP_bb->start_time),&wall_hrs,&wall_mins,&wall_secs);
DDSIP_translate_time (time_end,&cpu_hrs,&cpu_mins,&cpu_secs);
if (mipstatus == CPXMIP_OPTIMAL)
fprintf (DDSIP_bb->moreoutfile,
" exp. val. prob: Best=%-20.14g\tBound=%-20.14g (%9.4g%%) \t %3dh %02d:%02.0f / %3dh %02d:%05.2f (%6.2fs n: %4d)",
objval, bobjval, gap,
wall_hrs,wall_mins,wall_secs,cpu_hrs,cpu_mins,cpu_secs, time_start, nodes_1st);
else if (mipstatus == CPXMIP_OPTIMAL_TOL)
fprintf (DDSIP_bb->moreoutfile,
" exp. val. prob: Best=%-20.14g\tBound=%-20.14g (%9.4g%%) tol.\t %3dh %02d:%02.0f / %3dh %02d:%05.2f (%6.2fs n: %4d)",
objval, bobjval, gap,
wall_hrs,wall_mins,wall_secs,cpu_hrs,cpu_mins,cpu_secs, time_start, nodes_1st);
else if (mipstatus == CPXMIP_TIME_LIM_FEAS)
fprintf (DDSIP_bb->moreoutfile,
" exp. val. prob: Best=%-20.14g\tBound=%-20.14g (%9.4g%%) TIME\t %3dh %02d:%02.0f / %3dh %02d:%05.2f (%6.2fs n: %4d)",
objval, bobjval, gap,
wall_hrs,wall_mins,wall_secs,cpu_hrs,cpu_mins,cpu_secs, time_start, nodes_1st);
else
fprintf (DDSIP_bb->moreoutfile,
" exp. val. prob: Best=%-20.14g\tBound=%-20.14g (%9.4g%%) %-4d\t %3dh %02d:%02.0f / %3dh %02d:%05.2f (%6.2fs n: %4d)",
objval, bobjval, gap, mipstatus,
wall_hrs,wall_mins,wall_secs,cpu_hrs,cpu_mins,cpu_secs, time_start, nodes_1st);
}
// Returns sometimes rubbish, don't know why..
if (!DDSIP_bb->adv_sol)
DDSIP_bb->adv_sol = (double *) DDSIP_Alloc (sizeof (double), DDSIP_bb->firstvar, "DDSIP_bb->adv_sol(sipread)");
for (j = 0; j < DDSIP_bb->firstvar; j++)
{
// Numerical errors ?
if (DDSIP_Equal (mipx[DDSIP_bb->firstindex[j]], 0.0))
mipx[DDSIP_bb->firstindex[j]] = 0.0;
DDSIP_bb->adv_sol[j] = mipx[DDSIP_bb->firstindex[j]];
}
TERMINATE:
DDSIP_Free ((void **) &(mipx));
return status;
}
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 (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;
char *ctype = NULL;
/* Declare and allocate space for the variables and arrays where we will
store the optimization results including the status, objective value,
variable values, and row slacks. */
int solstat;
double objval;
double x[NUMCOLS];
double slack[NUMROWS];
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;
}
/* Fill in the data for the problem. */
status = setproblemdata (&probname, &numcols, &numrows, &objsen, &obj,
&rhs, &sense, &matbeg, &matcnt, &matind, &matval,
&lb, &ub, &ctype);
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;
}
/* Now copy the ctype array */
status = CPXcopyctype (env, lp, ctype);
if ( status ) {
fprintf (stderr, "Failed to copy ctype\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 the output 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\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);
status = CPXgetx (env, lp, x, 0, cur_numcols-1);
if ( status ) {
fprintf (stderr, "Failed to get optimal integer x.\n");
goto TERMINATE;
}
status = CPXgetslack (env, lp, slack, 0, cur_numrows-1);
if ( status ) {
fprintf (stderr, "Failed to get optimal slack values.\n");
goto TERMINATE;
}
for (i = 0; i < cur_numrows; i++) {
printf ("Row %d: Slack = %10f\n", i, slack[i]);
}
for (j = 0; j < cur_numcols; j++) {
printf ("Column %d: Value = %10f\n", j, x[j]);
}
/* Finally, write a copy of the problem to a file. */
status = CPXwriteprob (env, lp, "mipex1.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 **) &ctype);
return (status);
} /* END main */
// solve the current problem
int cplex_solver::solve() {
int nb_objectives = objectives.size();
int mipstat, status;
// Presolving the problem
time_t ptime = time(NULL);
if (CPXpresolve(env, lp, CPX_ALG_NONE)) return 0;
time_t ctime = time(NULL);
_timeCount += difftime(ctime, ptime);
// Solve the objectives in a lexical order
for (int i = first_objective; i < nb_objectives; i++) {
ptime = ctime;
// Solve the mip problem
if (CPXmipopt (env, lp)) return ERROR;
ctime = time(NULL);
_solutionCount += CPXgetsolnpoolnumsolns(env, lp) + CPXgetsolnpoolnumreplaced(env, lp);
_timeCount += difftime(ctime, ptime);
_nodeCount += CPXgetnodecnt(env, lp);
// Get solution status
if ((mipstat = CPXgetstat(env, lp)) == CPXMIP_OPTIMAL) {
if (i < nb_objectives - 1) {
// Get next non empty objective
// (must be done here to avoid conflicting method calls
int previ = i, nexti, nexti_nb_coeffs = 0;
for (; i < nb_objectives - 1; i++) {
nexti = i + 1;
nexti_nb_coeffs = objectives[nexti]->nb_coeffs;
if (nexti_nb_coeffs > 0) break;
}
if (nexti_nb_coeffs > 0) { // there is one more objective to solve
// Set objective constraint value to objval
int index[1];
double values[1];
index[0] = previ;
values[0] = objective_value();
if (verbosity >= DEFAULT)
printf(">>>> Objective value %d = %f\n", previ, values[0]);
{
int status, begin[2];
double rhs[1];
begin[0] = 0;
rhs[0] = values[0]; //ub;
int n = objectives[previ]->nb_coeffs;
begin[1] = n - 1;
status = CPXaddrows(env, lp, 0, 1, n, rhs, "E", begin, objectives[previ]->sindex, objectives[previ]->coefficients, NULL, NULL);
if (status) {
fprintf(stderr, "cplex_solver: end_objective: cannot add %d objective as constraint.\n", i);
exit(-1);
}
}
// Set the new objective value
reset_coeffs();
// Set previous objective coefficients to zero
for (int k = 0; k < objectives[previ]->nb_coeffs; k++) set_coeff(objectives[previ]->sindex[k], 0);
// Set next objective coefficients to their actual values
for (int k = 0; k < nexti_nb_coeffs; k++) set_coeff(objectives[nexti]->sindex[k], objectives[nexti]->coefficients[k]);
// Do set the next objective
status = CPXchgobj(env, lp, nb_coeffs, sindex, coefficients);
if ( status ) {
fprintf (stderr,"Cannot change objective value. Exiting...\n");
exit(-1);
}
// Output model to file (when requested)
if (verbosity >= VERBOSE) {
char buffer[1024];
sprintf(buffer, "cplexpb-%d.lp", i);
writelp(buffer);
}
} else
return OPTIMUM;
} else
return OPTIMUM;
} else if( mipstat == CPXMIP_TIME_LIM_INFEAS ||
mipstat == CPXMIP_TIME_LIM_FEAS) {
return _solutionCount > 0 ? SAT : UNKNOWN;
} else {
if (verbosity >= DEFAULT)
fprintf(stderr, "CPLEX solution status = %d\n", mipstat);
return ERROR;
}
}
return 0;
}
int
main (void)
{
CPXENVptr env;
CPXLPptr lp = NULL;
int *cone = NULL;
int status;
CPXCHANNELptr resc, warnc, errc, logc;
int retval = -1;
/* Initialize CPLEX and get a reference to the output channels.
* If any of this fails immediately terminate the program.
*/
env = CPXopenCPLEX (&status);
if ( env == NULL || status != 0 )
abort ();
status = CPXgetchannels (env, &resc, &warnc, &errc, &logc);
if ( status != 0 )
abort ();
/* CPLEX is fully setup. Enable output.
*/
status = CPXsetintparam (env, CPXPARAM_ScreenOutput, CPX_ON);
if ( status != 0 )
goto TERMINATE;
/* Create model. */
lp = CPXcreateprob (env, &status, "xsocpex1");
if ( lp == NULL || status != 0 )
goto TERMINATE;
if ( !createmodel (env, lp, &cone) )
goto TERMINATE;
/* Solve the problem to optimality. */
CPXmsg (logc, "Optimizing ...\n");
status = CPXsetdblparam (env, CPXPARAM_Barrier_QCPConvergeTol, CONVTOL);
if ( status != 0 )
goto TERMINATE;
if ( (status = CPXhybbaropt (env, lp, CPX_ALG_NONE)) != 0 )
goto TERMINATE;
if ( CPXgetstat (env, lp) != CPX_STAT_OPTIMAL ) {
CPXmsg (errc, "Cannot test KKT conditions on non-optimal solution.\n");
goto TERMINATE;
}
/* Now test KKT conditions on the result. */
if ( !checkkkt (env, lp, cone, TESTTOL) ) {
CPXmsg (logc, "Testing of KKT conditions failed.\n");
CPXmsg (errc, "Testing of KKT conditions failed.\n");
goto TERMINATE;
}
CPXmsg (resc, "KKT conditions are satisfied.\n");
retval = 0;
TERMINATE:
free (cone);
if ( lp != NULL )
CPXfreeprob (env, &lp);
CPXcloseCPLEX (&env);
return retval;
}
long GenModelCplex::SetSol()
{
if(!bcreated)
throw string("SetSol() not available : Problem not created yet");
vars.sol.clear();
vars.sol.resize(vars.n,0);
vars.rc.clear();
vars.rc.resize(vars.n,0);
CplexData* d = (CplexData*)solverdata;
int status = 0;
if(d->x != NULL)
delete[] d->x;
if(d->dual != NULL)
delete[] d->dual;
if(d->rcost != NULL)
delete[] d->rcost;
if(d->slack != NULL)
delete[] d->slack;
d->x = new double[nc];
d->dual = new double[nr];
d->rcost = new double[nc];
d->slack = new double[nr];
int tempstat = CPXgetstat (d->env, d->lp);
int tempfeas;
int tempdualfeas;
int temphassol;
int currmeth = CPXgetmethod(d->env, d->lp);
status = CPXsolninfo(d->env, d->lp, &currmeth, &temphassol, &tempfeas, &tempdualfeas);
if ( status )
return ThrowError(getcplexerror(d->env, status)+string(". ")+string("Failure to set set solution (CPXsolninfo)"));
feasible = static_cast<bool>(tempfeas);
dualfeasible = static_cast<bool>(tempdualfeas);
hassolution= static_cast<bool>(temphassol);
if(!hassolution)
return 1;
if(boolParam.count("mip") > 0 && boolParam["mip"])
status = CPXsolution (d->env, d->lp, &solstat, &objval, d->x, NULL, NULL, NULL);
else
status = CPXsolution (d->env, d->lp, &solstat, &objval, d->x, d->dual, d->slack, d->rcost);
if ( status )
return ThrowError(getcplexerror(d->env, status)+string(". ")+string("Failure to set set solution (CPXsolution)"));
solstat = tempstat;
for(long i = 0; i < long(nc); i++)
{
vars.sol[i] = d->x[i];
vars.rc[i] = d->rcost[i];
}
for(long i = 0; i < long(nr); i++)
{
consts[i].dual = d->dual[i];
consts[i].slack = d->slack[i];
}
if(boolParam.count("print_version") > 0 && boolParam["print_version"])
printf("*********** Genmodel version = %s ***********\n", version.c_str());
return solstat;
}
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;
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[]) {
if(argc < 3){
cerr << "Uso: input_file max_iteraciones" << endl;
exit(1);
}
srand(time(NULL));
string archivo_entrada(argv[1]);
int max_iteraciones = atoi(argv[2]);
//----------------------- PARSEO DE ENTRADA
pair <int, pair<vector<vector<bool> >*, vector<vector<bool> >* > > grafo = parsear_entrada(archivo_entrada);
int cant_ejes = grafo.first;
vector<vector<bool> > *adyacencias = grafo.second.first; // matriz de adyacencia
vector<vector<bool> > *particion = grafo.second.second; // filas: subconjuntos de la particion. columnas: nodos.
// Variables binarias:
// * X_n_j = nodo n pintado con el color j? (son cant_nodos * cant_colores_disp variables)
// * W_j = hay algun nodo pintado con el color j? (son cant_colores_disp variables)
// => TOTAL: (cant_nodos * cant_colores_disp + cant_colores_disp) variables
//
// Orden de las variables:
// X_0_0, X_0_1, ... , X_0_(cant_col_disp), X_1_0, ... , X_(cant_nodos)_(cant_col_disp), W_0, ... , W(cant_col_disp)
int cant_nodos = adyacencias->size();
int cant_subconj_particion = particion->size(); //cant de subconjuntos de la particion
int cant_colores_disp = particion->size(); // cant colores usados <= cant de subconjuntos de la particion
int n = cant_nodos * cant_colores_disp + cant_colores_disp; // n = cant de variables
//----------------------- CARGA DE LP
// Genero el problema de cplex.
int status;
CPXENVptr env; // Puntero al entorno.
CPXLPptr lp; // Puntero al LP
// Creo el entorno.
env = CPXopenCPLEX(&status);
if (env == NULL) {
cerr << "Error creando el entorno" << endl;
exit(1);
}
// Creo el LP.
lp = CPXcreateprob(env, &status, "Coloreo Particionado");
if (lp == NULL) {
cerr << "Error creando el LP" << endl;
exit(1);
}
//TUNNING
//Para que haga Branch & Cut:
CPXsetintparam(env, CPX_PARAM_MIPSEARCH, CPX_MIPSEARCH_TRADITIONAL);
//Para que no se adicionen planos de corte: ( => Branch & Bound)
CPXsetintparam(env,CPX_PARAM_EACHCUTLIM, 0);
CPXsetintparam(env, CPX_PARAM_FRACCUTS, -1);
//Para facilitar la comparación evitamos paralelismo:
CPXsetintparam(env, CPX_PARAM_THREADS, 1);
//Para desactivar preprocesamiento
CPXsetintparam(env, CPX_PARAM_PRESLVND, -1);
CPXsetintparam(env, CPX_PARAM_REPEATPRESOLVE, 0);
CPXsetintparam(env, CPX_PARAM_RELAXPREIND, 0);
CPXsetintparam(env, CPX_PARAM_REDUCE, 0);
CPXsetintparam(env, CPX_PARAM_LANDPCUTS, -1);
//Otros parámetros
// Para desactivar la salida poner CPX_OFF. Para activar: CPX_ON.
status = CPXsetintparam(env, CPX_PARAM_SCRIND, CPX_OFF);
if (status) {
cerr << "Problema seteando SCRIND" << endl;
exit(1);
}
//Setea el tiempo limite de ejecucion.
status = CPXsetdblparam(env, CPX_PARAM_TILIM, 3600);
if (status) {
cerr << "Problema seteando el tiempo limite" << endl;
exit(1);
}
double *ub, *lb, *objfun; // Cota superior, cota inferior, coeficiente de la funcion objetivo.
char *xctype, **colnames; // tipo de la variable (por ahora son siempre continuas), string con el nombre de la variable.
ub = new double[n];
lb = new double[n];
objfun = new double[n];
xctype = new char[n];
colnames = new char*[n];
// Defino las variables X_n_j
for (int i = 0; i < n - cant_colores_disp; i++) {
ub[i] = 1;
lb[i] = 0;
objfun[i] = 0; // Estas var no figuran en la funcion objetivo
xctype[i] = 'C';
colnames[i] = new char[10];
sprintf(colnames[i], "X_%d_%d", i / cant_colores_disp, i % cant_colores_disp);
}
// Defino las variables W_j
for (int i = n - cant_colores_disp; i < n; i++) {
ub[i] = 1;
lb[i] = 0;
objfun[i] = 1;
xctype[i] = 'C';
colnames[i] = new char[10];
sprintf(colnames[i], "W_%d", i - (n - cant_colores_disp));
}
// Agrego las columnas.
status = CPXnewcols(env, lp, n, objfun, lb, ub, NULL, colnames);
if (status) {
cerr << "Problema agregando las variables CPXnewcols" << endl;
exit(1);
}
// Libero las estructuras.
for (int i = 0; i < n; i++) {
delete[] colnames[i];
}
delete[] ub;
delete[] lb;
delete[] objfun;
delete[] xctype;
delete[] colnames;
// Restricciones:
// (1) Nodos adyacentes tienen distinto color (cant_ejes * cant_colores_disp restricciones por <=)
// (2) Cada nodo tiene a lo sumo un color (cant_nodos restricciones por <=)
// (3) Solo un nodo de cada subconj. de la particion tiene color (cant. de subconj. de la particion restricciones por =)
// (4) W_j = 1 sii "X_i_j = 1 para algún i" (cant_colores_disp restricciones por >=)
// (5) W_j >= W_(j+1) (cant_colores_disp - 1 restricciones por >=)
// => TOTAL: (cant_ejes * cant_colores_disp + cant_nodos + cant_subconj_particion + cant_colores_disp + cant_colores_disp - 1) restricciones
int ccnt = 0; //numero nuevo de columnas en las restricciones.
int rcnt = cant_ejes * cant_colores_disp + cant_nodos + cant_subconj_particion + cant_colores_disp + cant_colores_disp - 1; //cuantas restricciones se estan agregando.
int nzcnt = 0; //# de coeficientes != 0 a ser agregados a la matriz. Solo se pasan los valores que no son cero.
char sense[rcnt]; // Sentido de la desigualdad. 'G' es mayor o igual y 'E' para igualdad.
for(unsigned int i = 0; i < cant_ejes * cant_colores_disp; i++)
sense[i] = 'L';
for(unsigned int i = cant_ejes * cant_colores_disp; i < cant_ejes * cant_colores_disp + cant_nodos; i++)
sense[i] = 'L';
for(unsigned int i = cant_ejes * cant_colores_disp + cant_nodos; i < cant_ejes * cant_colores_disp + cant_nodos + cant_subconj_particion; i++)
sense[i] = 'E';
for(unsigned int i = cant_ejes * cant_colores_disp + cant_nodos + cant_subconj_particion; i < rcnt; i++)
sense[i] = 'G';
double *rhs = new double[rcnt]; // Termino independiente de las restricciones.
int *matbeg = new int[rcnt]; //Posicion en la que comienza cada restriccion en matind y matval.
int *matind = new int[rcnt*n]; // Array con los indices de las variables con coeficientes != 0 en la desigualdad.
double *matval = new double[rcnt*n]; // Array que en la posicion i tiene coeficiente ( != 0) de la variable cutind[i] en la restriccion.
//El termino indep. de restr (1), (2) y (3) es 1
for(unsigned int i = 0; i < cant_ejes * cant_colores_disp + cant_nodos + cant_subconj_particion; i++)
rhs[i] = 1;
//El termino indep. de restr (4) y (5) es 0
for(unsigned int i = cant_ejes * cant_colores_disp + cant_nodos + cant_subconj_particion; i < rcnt; i++)
rhs[i] = 0;
unsigned int indice = 0; //numero de restriccion actual
//Restricciones (1)
for(unsigned int i = 0; i < cant_nodos; i++) //itero nodo 1
for(unsigned int j = i+1; j < cant_nodos; j++) //itero nodo 2
if((*adyacencias)[i][j])
for(unsigned int p = 0; p < cant_colores_disp; p++){ //itero color
matbeg[indice] = nzcnt;
indice++;
//cargo una de las variables participantes de la restr.
matind[nzcnt] = cant_colores_disp*i + p; //var1: X_nodo1_color
matval[nzcnt] = 1;
nzcnt++;
//idem con la otra variable
matind[nzcnt] = cant_colores_disp*j + p; //var2: X_nodo2_color
matval[nzcnt] = 1;
nzcnt++;
}
//Restricciones (2)
for(unsigned int i = 0; i < cant_nodos; i++){ //itero nodo
matbeg[indice] = nzcnt;
indice++;
for(unsigned int p = 0; p < cant_colores_disp; p++){ //itero color
matind[nzcnt] = cant_colores_disp*i + p; //var: X_nodo_color
matval[nzcnt] = 1;
nzcnt++;
}
}
//Restricciones (3)
for(unsigned int v = 0; v < cant_subconj_particion; v++){ //itero subconjunto de la particion
matbeg[indice] = nzcnt;
indice++;
for(unsigned int i = 0; i < cant_nodos; i++) //itero nodo
if((*particion)[v][i])
for(unsigned int p = 0; p < cant_colores_disp; p++){ //itero color
matind[nzcnt] = cant_colores_disp*i + p; //var: X_nodo_color
matval[nzcnt] = 1;
nzcnt++;
}
}
//Restricciones (4)
for(unsigned int p = 0; p < cant_colores_disp; p++){ //itero color
matbeg[indice] = nzcnt;
indice++;
matind[nzcnt] = cant_nodos * cant_colores_disp + p; //var: W_color
matval[nzcnt] = cant_nodos;
nzcnt++;
for(unsigned int i = 0; i < cant_nodos; i++){ //itero nodo
matind[nzcnt] = cant_colores_disp*i + p; //var: X_nodo_color
matval[nzcnt] = -1;
nzcnt++;
}
}
//Restricciones (5)
for(unsigned int p = 0; p < cant_colores_disp - 1; p++){ //itero color
matbeg[indice] = nzcnt;
indice++;
matind[nzcnt] = cant_nodos * cant_colores_disp + p; //var: W_color
matval[nzcnt] = 1;
nzcnt++;
matind[nzcnt] = cant_nodos * cant_colores_disp + p + 1; //var: W_(color+1)
matval[nzcnt] = -1;
nzcnt++;
}
// Esta rutina agrega la restriccion al lp.
status = CPXaddrows(env, lp, ccnt, rcnt, nzcnt, rhs, sense, matbeg, matind, matval, NULL, NULL);
if (status) {
cerr << "Problema agregando restricciones." << endl;
exit(1);
}
delete[] rhs;
delete[] matbeg;
delete[] matind;
delete[] matval;
// Escribimos el problema a un archivo .lp
status = CPXwriteprob(env, lp, "output.lp", NULL);
if (status) {
cerr << "Problema escribiendo modelo" << endl;
exit(1);
}
//----------------------- PRIMER ITERACION DE RESOLUCIÓN DEL LP
// Tomamos el tiempo de resolucion utilizando CPXgettime.
double inittime, endtime, fractpart, intpart, opt_anterior, opt_actual;
int cant_iteraciones = 0;
status = CPXgettime(env, &inittime);
bool criterio_de_corte, todas_enteras, hubo_plano = true;
status = CPXlpopt(env, lp);
if (status) {
cerr << "Problema optimizando CPLEX" << endl;
exit(1);
}
status = CPXgetobjval(env, lp, &opt_actual);
if (status) {
cerr << "Problema obteniendo valor de mejor solucion." << endl;
exit(1);
}
cout << "Optimo Inicial: " << opt_actual << endl << endl;
double *sol = new double[n];
status = CPXgetx(env, lp, sol, 0, n - 1);
if (status) {
cerr << "Problema obteniendo la solucion del LP." << endl;
exit(1);
}
// Chequeo si la solución es entera
for (int i = 0; i < n; i++){
fractpart = modf(sol[i] , &intpart);
if (fractpart > TOL){
todas_enteras = false;
break;
}
}
criterio_de_corte = todas_enteras || max_iteraciones==0;
//----------------------- INICIO CICLO DE RESOLUCIÓN DEL LP
while(!criterio_de_corte){
opt_anterior = opt_actual;
hubo_plano = agregar_restricciones_clique(adyacencias, sol, env, lp, cant_colores_disp, n);
hubo_plano = agregar_restricciones_ciclos(adyacencias, sol, env, lp, cant_colores_disp, n) || hubo_plano;
if(hubo_plano){
status = CPXlpopt(env, lp);
if (status) {
cerr << "Problema optimizando CPLEX" << endl;
exit(1);
}
status = CPXgetx(env, lp, sol, 0, n - 1);
if (status) {
cerr << "Problema obteniendo la solucion del LP." << endl;
exit(1);
}
for (int i = 0; i < n; i++){
fractpart = modf(sol[i] , &intpart);
if (fractpart > TOL){
todas_enteras = false;
break;
}
}
}
status = CPXgetobjval(env, lp, &opt_actual);
if (status) {
cerr << "Problema obteniendo valor de mejor solucion." << endl;
exit(1);
}
cant_iteraciones++;
criterio_de_corte = todas_enteras || (cant_iteraciones >= max_iteraciones)
|| !hubo_plano;// || abs(opt_actual - opt_anterior) < TOL;
}
status = CPXgettime(env, &endtime);
//----------------------- FIN CICLO DE RESOLUCIÓN DEL LP
int solstat;
char statstring[510];
CPXCHARptr p;
solstat = CPXgetstat(env, lp);
p = CPXgetstatstring(env, solstat, statstring);
string statstr(statstring);
cout << endl << "Resultado de la optimizacion: " << statstring << endl;
if(solstat!=CPX_STAT_OPTIMAL) exit(1);
double objval;
status = CPXgetobjval(env, lp, &objval);
if (status) {
cerr << "Problema obteniendo valor de mejor solucion." << endl;
exit(1);
}
cout << "Optimo: " << objval << "\t(Time: " << (endtime - inittime) << " sec)" << endl;
// Tomamos los valores de la solucion y los escribimos a un archivo.
std::string outputfile = "output.sol";
ofstream solfile(outputfile.c_str());
// Tomamos los valores de todas las variables. Estan numeradas de 0 a n-1.
status = CPXgetx(env, lp, sol, 0, n - 1);
if (status) {
cerr << "Problema obteniendo la solucion del LP." << endl;
exit(1);
}
// Solo escribimos las variables distintas de cero (tolerancia, 1E-05).
solfile << "Status de la solucion: " << statstr << endl;
// Imprimo var X_n_j
for (int i = 0; i < n - cant_colores_disp; i++) {
if (sol[i] > TOL) {
solfile << "X_" << i / cant_colores_disp << "_" << i % cant_colores_disp << " = " << sol[i] << endl;
}
}
// Imprimo var W_j
for (int i = n - cant_colores_disp; i < n; i++) {
if (sol[i] > TOL) {
solfile << "W_" << i - (n - cant_colores_disp) << " = " << sol[i] << endl;
}
}
solfile.close();
delete [] sol;
delete adyacencias;
delete particion;
return 0;
}
static int CPXPUBLIC
solvecallback (CPXCENVptr env,
void *cbdata,
int wherefrom,
void *userinfo,
int *useraction_p)
{
int status = 0;
int lpstatus = 0;
CPXLPptr nodelp = NULL;
double *prex = NULL;
MYCBptr mycbinfo = (MYCBptr) userinfo;
CPXLPptr mip = mycbinfo->mip;
double *relx = mycbinfo->relx;
int cols;
int prestat;
*useraction_p = CPX_CALLBACK_DEFAULT;
/* Only use callback for solving the root relaxation (node 0) */
if ( mycbinfo->count > 0 ) {
goto TERMINATE;
}
mycbinfo->count++;
/* Extract the LP to be solved */
status = CPXgetcallbacknodelp (env, cbdata, wherefrom, &nodelp);
if ( status ) goto TERMINATE;
cols = CPXgetnumcols (env, nodelp);
prex = (double *) malloc (cols * sizeof (double));
if ( prex == NULL ) {
status = CPXERR_NO_MEMORY;
goto TERMINATE;
}
/* Use MIP presolve to crush the original solution. Note that
MIP presolve can only crush primal solutions */
status = CPXgetprestat (env, mip, &prestat, NULL, NULL, NULL,
NULL);
if ( status ) goto TERMINATE;
/* If a presolved model exists, then relx is crushed down
to prex, the corresponding solution for the presolved
model; otherwise, prex is just a copy of relx */
if ( prestat ) {
status = CPXcrushx (env, mip, relx, prex);
if ( status ) goto TERMINATE;
}
else {
memcpy (prex, relx, cols * sizeof (double));
}
/* Feed the crushed solution into 'nodelp' */
status = CPXcopystart (env, nodelp, NULL, NULL, prex, NULL,
NULL, NULL);
/* Use primal to reoptimize, since we only have a primal
solution */
status = CPXprimopt (env, nodelp);
if ( status ) goto TERMINATE;
lpstatus = CPXgetstat (env, nodelp);
if ( lpstatus == CPX_STAT_OPTIMAL ||
lpstatus == CPX_STAT_OPTIMAL_INFEAS ||
lpstatus == CPX_STAT_INFEASIBLE ) {
*useraction_p = CPX_CALLBACK_SET;
}
TERMINATE:
free_and_null ((char **) &prex);
return (status);
} /* END solvecallback */
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 (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 CSolver:: MipOptimize() {
int rcStatus;
char buff[100];
int bFailed ;
bFailed = 0;
SetProblemType('M'); // sets callback data flags
m_cbData.bMip = true;
CPXsetmipcallbackfunc(m_env,lpcallback, &m_cbData);
//! m_status = CPXmipoptimize(m_env,m_lp);
m_status = CPXmipopt(m_env, m_lp);
if (m_status != 0) {
CPXgeterrorstring(m_env, m_status, m_error);
sprintf(buff, "CPXmipoptimize failed return code = %d", m_status );
Message(buff);
Message(m_error);
bFailed = 1;
return -1;
}
CPXsetmipcallbackfunc(m_env,NULL,NULL);
m_lpstat = CPXgetstat(m_env,m_lp);
if( bFailed == 1) {
sprintf(buff, "CPXgetstat value = %d", m_lpstat);
Message(buff);
}
CreateSolArrays();
// get solution and place into arrays
//! CPXgetmobjval(m_env, m_lp, &m_obj);
CPXgetobjval(m_env, m_lp, &m_obj);
//! rcStatus = CPXgetmx(m_env,m_lp, m_x, 0, m_nObjItems-1 );
rcStatus = CPXgetx(m_env, m_lp, m_x, 0, m_nObjItems - 1);
if ( rcStatus ){
CPXgeterrorstring(m_env, m_status, m_error);
Message(m_error);
return -1;
}
//! rcStatus = CPXgetmslack(m_env, m_lp, m_slack, 0, m_nRhsItems-1 );
rcStatus = CPXgetslack(m_env, m_lp, m_slack, 0, m_nRhsItems - 1);
if ( rcStatus ){
CPXgeterrorstring(m_env, m_status, m_error);
Message(m_error);
return -1;
}
// save the basis to arrays
// m_status = CPXgetbase(m_env, m_lp, m_pCstat, m_pRstat);
// if ( m_status ) {
// Message("Getting basis failed!");
// return -1;
// }
return 0;
}
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;
int colcnt = 0;
double *x = NULL;
CPXENVptr env = NULL;
CPXLPptr lp = NULL;
int status;
int m, p;
/* 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;
}
/* Formulate and solve the problem */
lp = CPXcreateprob (env, &status, "food manufacturing");
/* 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 model */
status = buildmodel (env, lp);
if ( status ) {
fprintf (stderr, "Failed to build model.\n");
goto TERMINATE;
}
/* Write a copy of the problem to a file. */
status = CPXwriteprob (env, lp, "foodmanu.lp", NULL);
if ( status ) {
fprintf (stderr, "Failed to write LP to disk.\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, objective and solution vector 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 (maximum profit) = %f\n\n", objval);
colcnt = NUMVARS*NUMMONTHS*NUMPRODUCTS;
x = (double *) malloc (colcnt * sizeof(double));
if ( x == NULL ) {
status = CPXERR_NO_MEMORY;
fprintf (stderr, "Could not allocate memory for solution.\n");
goto TERMINATE;
}
status = CPXgetx (env, lp, x, 0, colcnt - 1);
if ( status ) {
fprintf (stderr, "Failed to get optimal integer x.\n");
goto TERMINATE;
}
for (m = 0; m < NUMMONTHS; m++) {
printf ("Month %d \n", m);
printf (" . buy ");
for (p = 0; p < NUMPRODUCTS; p++)
printf ("%f\t", x[varindex(m, p, BUY)]);
printf ("\n");
printf (" . use ");
for (p = 0; p < NUMPRODUCTS; p++)
printf ("%f\t", x[varindex (m, p, USE)]);
printf ("\n");
printf (" . store ");
for (p = 0; p < NUMPRODUCTS; p++)
printf ("%f\t", x[varindex (m, p, STORE)]);
printf ("\n");
}
/* Free problem */
status = CPXfreeprob (env, &lp);
if ( status ) {
fprintf (stderr, "CPXfreeprob failed, error code %d.\n", status);
goto TERMINATE;
}
TERMINATE:
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 */
