Solution LpsolveAdaptator::getSolution(lprec * lp) {
Solution sol = Solution();
REAL row[get_Norig_columns(lp)];
#ifdef DEBUG
set_verbose(lp, NORMAL);
write_LP(lp, stdout);
#else
set_verbose(lp, CRITICAL);
#endif
solve(lp);
// WARNING possible conversion failure from double to float
sol.setZ(get_objective(lp));
get_variables(lp, row);
#ifdef DEBUG
for(int j = 0; j < get_Norig_columns(lp); j++) {
printf("%s: %f\n", get_col_name(lp, j + 1), row[j]);
}
#endif
for (int i = 0; i < get_Norig_columns(lp); i++) {
double var_value = (double)row[i];
sol.addVariable(var_value);
}
delete_lp(lp);
return sol;
}
int main(int argc, char *argv[])
{
lprec *lp;
FILE *fpin, *fpout;
int i;
for (i = 1; i < argc; i++)
if (argv[i][0] == '-') {
printf("mps to lp file converter\n");
printf("Usage: mps2lp [inputfile.mps [outputfile.lp]] [<inputfile.mps] [>outputfile.lp]\n");
return(1);
}
if (argc >= 2) {
fpin = fopen(argv[1], "r");
if (fpin == NULL) {
fprintf(stderr, "Unable to open input file %s\n", argv[1]);
return(2);
}
}
else
fpin = stdin;
if (argc >= 3) {
fpout = fopen(argv[2], "w");
if (fpout == NULL) {
fprintf(stderr, "Unable to open output file %s\n", argv[2]);
return(3);
}
}
else
fpout = stdout;
fprintf(stderr,"reading mps file\n");
lp = read_mps(fpin, FALSE);
if (fpin != stdin)
fclose(fpin);
if (lp == NULL) {
fprintf(stderr, "Unable to read mps file\n");
return(4);
}
else {
fprintf(stderr,"writing lp file\n");
if (!write_LP(lp, fpout)) {
fprintf(stderr, "Unable to write lp file\n");
return(5);
}
}
if (fpout != stdout)
fclose(fpout);
return(0);
}
//Execute function
int LPSolveClass::Execute()
{
/*
std::cout << "---------------------------------\n";
std::cout << "objective function\n";
for (unsigned int i = 0; i < coefficients.size(); i++)
std::cout << coefficients[i] << "\t";
std::cout << "\nConstant Value = " << obj_const << std::endl;
std::cout << "---------------------------------\n";
std::cout << "Equality Constraints\n";
for (unsigned int i = 0; i < A_equ.size(); i++){
//std::cout << "Row index = " << i << "\t\t";
for (unsigned int j = 0; j < A_equ[i].size(); j++)
std::cout << A_equ[i][j] << "\t";
std::cout << "\n";
}
std::cout << "b\n";
for (unsigned int i = 0; i < b_equ.size(); i++)
std::cout << b_equ[i] << "\t";
std::cout << "\n";
std::cout << "---------------------------------\n";
std::cout << "InEquality Constraints\n";
for (unsigned int i = 0; i < A_inequ.size(); i++){
//std::cout << "Row index = " << i << "\t\t";
for (unsigned int j = 0; j < A_inequ[i].size(); j++)
std::cout << A_inequ[i][j] << "\t";
std::cout << "\n";
}
std::cout << "b\n";
for (unsigned int i = 0; i < b_inequ.size(); i++)
std::cout << b_inequ[i] << "\t";
std::cout << "\n";
*/
lprec *lp;
int Ncol = coefficients.size(), *colno = NULL, j, ret = 0;
REAL *row = NULL;
/* We will build the model row by row
So we start with creating a model with 0 rows and n columns */
lp = make_lp(0, Ncol);
if (lp == NULL)
ret = 1;/* couldn't construct a new model... */
if (ret == 0){
//let us name our variables
std::string s = "x";
for (int i = 0; i < Ncol; i++){
std::stringstream out;
out << i;
s = s + out.str();
char *cpy = new char[s.size()+1] ;
strcpy(cpy, s.c_str());
set_col_name(lp, i+1, cpy);
}
/* create space large enough for one row */
colno = (int *) malloc(Ncol * sizeof(*colno));
row = (REAL *) malloc(Ncol * sizeof(*row));
if ((colno == NULL) || (row == NULL))
ret = 2;
}
set_add_rowmode(lp, TRUE);
//add the equation constraints
if (ret == 0){
/* makes building the model faster if it is done rows by row */
if (A_equ.size() > 0){
for (unsigned int i = 0; i < A_equ.size(); i++){//loop over the rows of equality constraints
for (unsigned int j = 0; j < A_equ[i].size(); j++){//loop over the columns of equality constraints
colno[j] = j+1;//add the j-th column to lpsolve
row[j] = A_equ[i][j];
}
/* add the row to lpsolve */
if(!add_constraintex(lp, A_equ[i].size(), row, colno, EQ, b_equ[i]))
ret = 2;
}
}
}
//add the inequality constraints
if (ret == 0){
/* makes building the model faster if it is done rows by row */
if (A_inequ.size() > 0){
for (unsigned int i = 0; i < A_inequ.size(); i++){//loop over the rows of inequality constraints
for (unsigned int j = 0; j < A_inequ[i].size(); j++){//loop over the columns of inequality constraints
colno[j] = j+1;//add the j-th column to lpsolve
row[j] = A_inequ[i][j];
}
/* add the row to lpsolve */
if(!add_constraintex(lp, A_inequ[i].size(), row, colno, LE, b_inequ[i]))
ret = 3;
}
}
}
//add the const constraint
if (ret == 0){
if (b_const.size()>0){
for (unsigned int i = 0; i < b_const.size(); i++){
if (b_const[i] > 0){
for (unsigned int j = 0; j < b_const.size(); j++){
if (i == j){
colno[j] = j+1;//add the j-th column to lpsolve
row[j] = 1.0;
}
else{
colno[j] = j+1;//add the j-th column to lpsolve
row[j] = 0.0;
}
}
if(!add_constraintex(lp, b_const.size(), row, colno, EQ, b_const[i]))
ret = 4;
}
}
}
}
//set the variables to be integer
if (ret == 0){
for (int i = 0; i < Ncol; i++)
set_int(lp, i+1, TRUE);
}
/* rowmode should be turned off again when done building the model */
set_add_rowmode(lp, FALSE);
//add the objective function
if (ret == 0){
//set the objective function
for (unsigned int i = 0; i < coefficients.size(); i++){
colno[i] = i+1;
row[i] = coefficients[i];
}
//set the objective in lpsolve
if(!set_obj_fnex(lp, coefficients.size(), row, colno))
ret = 4;
}
//set the objective to minimize
if (ret == 0){
set_minim(lp);
/* just out of curioucity, now show the model in lp format on screen */
/* this only works if this is a console application. If not, use write_lp and a filename */
write_LP(lp, stdout);
/* I only want to see important messages on screen while solving */
set_verbose(lp, IMPORTANT);
/* Now let lpsolve calculate a solution */
ret = solve(lp);
if(ret == OPTIMAL)
ret = 0;
else
ret = 5;
}
//get some results
if (ret == 0){
/* a solution is calculated, now lets get some results */
/* objective value */
std::cout << "Objective value: " << get_objective(lp) << std::endl;
/* variable values */
get_variables(lp, row);
/* variable values */
variables.resize(Ncol);
for(j = 0; j < Ncol; j++)
variables[j] = row[j];
/* we are done now */
}
else{
std::cout << "The optimal value can't be solved for linear programming, please check the constraints!!\n";
exit(1);
}
std::cout << "print the result\t # of line segments is \n";
for (int i = 0; i < Ncol; i++)
std::cout << "index = " << i << "\t# = " << variables[i] << std::endl;
/* free allocated memory */
if(row != NULL)
free(row);
if(colno != NULL)
free(colno);
/* clean up such that all used memory by lpsolve is freed */
if (lp != NULL)
delete_lp(lp);
return ret;
}
double solve_constraints(int this_task)
{
lprec *lp;
int numVar = 0, *var = NULL, ret = 0, i, j, k, var_count;
double *coeff = NULL, lhs,rhs, obj;
char col_name[10];
/* Creating a model */
for(i = 1;i < this_task; i++)
numVar+=i;
lp = make_lp(0, numVar);
if(lp == NULL)
ret = 1; /* Couldn't construct a new model */
if(ret == 0) {
var_count = 1;
for(i = 1 ; i < this_task; i++){
for(j = i+1 ; j <= this_task; j++)
{
sprintf(col_name, "%dNNP%d_%d", this_task, i, j);
set_col_name(lp, var_count, col_name);
var_count++;
}
}
/* create space large enough for one row(i.e. equation) */
var = (int *) malloc(numVar * sizeof(*var));
coeff = (double *) malloc(numVar * sizeof(*coeff));
if((var == NULL) || (coeff == NULL))
ret = 2;
}
/* add the equations to lpsolve */
if(ret == 0) {
set_add_rowmode(lp, TRUE);
/* --------------------adding EQN-D-------------------- */
for(j = 2;j <= this_task;j++){
var_count = 0;
for(i = 1; i < j; i++){
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[var_count] = get_nameindex(lp, col_name, FALSE);
coeff[var_count] = 1;
var_count++;
}
lhs= 0;
for(i = 1; i < j; i++)
lhs+= nnp_min[i][j];
lhs*= floor(R[this_task]/task[j].p);
rhs = 0;
for(i = 1; i < j; i++)
rhs += nnp_max[i][j];
rhs *= ceil(R[this_task]/task[j].p);
if(!add_constraintex(lp, var_count, coeff, var, GE, lhs))
ret = 3;
if(!add_constraintex(lp, var_count, coeff, var, LE, rhs))
ret = 3;
}
}
if(ret == 0) {
/* --------------------adding EQN-E-------------------- */
for(k = 2;k <= this_task;k++)
{
var_count = 0;
for(j = 2; j <= k; j++){
for(i = 1; i < j; i++){
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[var_count] = get_nameindex(lp, col_name, FALSE);
coeff[var_count] = 1;
var_count++;
}
}
rhs = 0;
for(i = 1; i < k; i++)
rhs += ceil(R[this_task]/task[i].p);
if(!add_constraintex(lp, var_count, coeff, var, LE,rhs))
ret = 3;
}
}
if(ret == 0) {
/* ------------------adding EQN-G & H------------------ */
for(j = 2; j <= this_task ; j++){
for(i = 1; i < j; i++){
lhs= floor(R[this_task]/task[j].p) * nnp_min[i][j];
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[0] = get_nameindex(lp, col_name, FALSE);
coeff[0] = 1;
if(!add_constraintex(lp, 1, coeff, var, GE, lhs))
ret = 3;
rhs = min(ceil(R[this_task]/task[i].p), ceil(R[this_task]/task[j].p) * ceil(R[j]/task[i].p), ceil(R[this_task]/task[j].p) * nnp_max[i][j]);
if(!add_constraintex(lp, 1, coeff, var, LE,rhs))
ret = 3;
}
}
}
if(ret == 0) {
/* --------------------adding EQN-I-------------------- */
for(i = 1; i < this_task; i++){
var_count = 0;
for(j = i+1; j <= this_task; j++){
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[var_count] = get_nameindex(lp, col_name, FALSE);
coeff[var_count] = 1;
var_count++;
}
rhs = ceil(R[this_task]/task[i].p);
if(!add_constraintex(lp, var_count, coeff, var, LE,rhs))
ret = 3;
}
}
set_add_rowmode(lp, FALSE);
if(ret == 0) {
/* -----------------set the objective----------------- */
var_count = 0;
for(i = 1 ; i < this_task; i++){
for(j = i+1 ; j<= this_task; j++){
sprintf(col_name,"%dNNP%d_%d",this_task, i, j);
var[var_count] = get_nameindex(lp, col_name, FALSE);
coeff[var_count] = get_f(this_task, i, j);
var_count++;
}
}
if(!set_obj_fnex(lp, var_count, coeff, var))
ret = 4;
set_maxim(lp);
write_LP(lp, stdout);
set_verbose(lp, IMPORTANT);
ret = solve(lp);
if(ret == OPTIMAL)
ret = 0;
else
ret = 5;
}
if(ret == 0) {
obj = get_objective(lp);
/* Displaying calculated values */
/* variable values */
printf("\nVariable values:\n");
get_variables(lp, coeff);
printf("\n");
for(j = 0; j < numVar; j++)
printf("%s: %f\n", get_col_name(lp, j + 1), coeff[j]);
/* objective value */
printf("\nObjective value: %f\n\n", obj);
}
printf("LP ERROR = %d\n\n", ret);
/* free allocated memory */
if(coeff != NULL)
free(coeff);
if(var != NULL)
free(var);
if(lp != NULL)
delete_lp(lp);
return ret == 0 ? obj : 0;
}
int calculate (IN int nCols /* variables in the model */,
IN int nRows,
IN double** rows,
IN double* rights,
IN double* objectives,
OUT int* answer,
IN int verbose)
{
lprec *lp;
int result = 0;
char *str = NULL;
int *colno = NULL;
double *row = NULL;
/* We will build the model row by row
* So we start with creating a model
* with 0 rows and 2 columns
*/
if ( !(lp = make_lp (0, nCols)) )
{
/* couldn't construct a new model... */
result = 1;
goto RESULT;
}
if ( !(str = (char*) malloc ((log10 (nCols) + 10) * sizeof (*str))) )
{
result = 2;
goto RESULT;
}
/* let us name our variables. Not required,
* but can be useful for debugging
*/
for ( int i = 1; i <= nCols; ++i )
{
str[0] = 't';
_itoa (i, str + 1, 10);
set_col_name (lp, i, str);
// set_int (lp, i, TRUE);
}
/* create space large enough for one row */
colno = (int *) malloc (nCols * sizeof (*colno));
row = (double*) malloc (nCols * sizeof (*row));
if ( (colno == NULL) || (row == NULL) )
{
result = 2;
goto RESULT;
}
for ( int j = 0; j < nCols; ++j )
{ colno[j] = j + 1; /* (j + 1) column */ }
/* makes building the model faster if it is done rows by row */
set_add_rowmode (lp, TRUE);
for ( int i = 0; i < nRows; ++i )
{
// /* construct j row */
// for ( int j = 0; j < nCols; ++j )
// { row[j] = ??? ; }
/* (210 * t2 + 156 * t3 == 0.0178) */
/* (230 * t2 + 160 * t3 == 0.0176) */
/* add the row to lp_solve */
if ( !add_constraintex (lp, nCols, rows[i], colno, EQ, rights[i]) )
{
result = 3;
goto RESULT;
}
}
/* rowmode should be turned off again when done building the model */
set_add_rowmode (lp, FALSE);
// /* set the objective function */
// for ( int j = 0; j < nCols; ++j )
// { row[j] = objectives[j]; }
/* (t1 + t2 + t3 + t4) */
/* set the objective in lp_solve */
if ( !set_obj_fnex (lp, nCols, objectives, colno) )
{
result = 4;
goto RESULT;
}
/* set the object direction to maximize */
set_minim (lp);
if ( verbose )
{
/* just out of curioucity, now show the model in lp format on screen */
/* this only works if this is a console application. If not, use write_lp and a filename */
write_LP (lp, stdout);
/* write_lp(lp, "model.lp"); */
}
/* I only want to see important messages on screen while solving */
set_verbose (lp, IMPORTANT);
/* Now let lpsolve calculate a solution */
result = solve (lp);
if ( result == OPTIMAL )
{ result = 0; }
else
{
result = 5;
goto RESULT;
}
/* a solution is calculated,
* now lets get some results
*/
if ( verbose )
{
/* objective value */
printf ("Objective value: %f\n", get_objective (lp));
}
/* variable values */
get_variables (lp, row);
for ( int j = 0; j < nCols; j++ )
{
if ( verbose )
printf ("%s: %f\n", get_col_name (lp, j + 1), row[j]);
answer[j] = row[j];
}
/* we are done now */
RESULT:;
/* free allocated memory */
if ( str != NULL )free (str);
if ( row != NULL ) free (row);
if ( colno != NULL ) free (colno);
if ( lp != NULL )
{
/* clean up such that all used memory by lpsolve is freed */
delete_lp (lp);
}
return result;
}
int demo()
{
lprec *lp;
int Ncol, *colno = NULL, j, ret = 0;
REAL *row = NULL;
/* We will build the model row by row
So we start with creating a model with 0 rows and 2 columns */
Ncol = 2; /* there are two variables in the model */
lp = make_lp(0, Ncol);
if(lp == NULL)
ret = 1; /* couldn't construct a new model... */
if(ret == 0) {
/* let us name our variables. Not required, but can be useful for debugging */
set_col_name(lp, 1, "x");
set_col_name(lp, 2, "y");
/* create space large enough for one row */
colno = (int *) malloc(Ncol * sizeof(*colno));
row = (REAL *) malloc(Ncol * sizeof(*row));
if((colno == NULL) || (row == NULL))
ret = 2;
}
if(ret == 0) {
set_add_rowmode(lp, TRUE); /* makes building the model faster if it is done rows by row */
/* construct first row (120 x + 210 y <= 15000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 120;
colno[j] = 2; /* second column */
row[j++] = 210;
/* add the row to lpsolve */
if(!add_constraintex(lp, j, row, colno, LE, 15000))
ret = 3;
}
if(ret == 0) {
/* construct second row (110 x + 30 y <= 4000) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 110;
colno[j] = 2; /* second column */
row[j++] = 30;
/* add the row to lpsolve */
if(!add_constraintex(lp, j, row, colno, LE, 4000))
ret = 3;
}
if(ret == 0) {
/* construct third row (x + y <= 75) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 1;
colno[j] = 2; /* second column */
row[j++] = 1;
/* add the row to lpsolve */
if(!add_constraintex(lp, j, row, colno, LE, 75))
ret = 3;
}
if(ret == 0) {
set_add_rowmode(lp, FALSE); /* rowmode should be turned off again when done building the model */
/* set the objective function (143 x + 60 y) */
j = 0;
colno[j] = 1; /* first column */
row[j++] = 143;
colno[j] = 2; /* second column */
row[j++] = 60;
/* set the objective in lpsolve */
if(!set_obj_fnex(lp, j, row, colno))
ret = 4;
}
if(ret == 0) {
/* set the object direction to maximize */
set_maxim(lp);
/* just out of curioucity, now show the model in lp format on screen */
/* this only works if this is a console application. If not, use write_lp and a filename */
write_LP(lp, stdout);
/* write_lp(lp, "model.lp"); */
/* I only want to see important messages on screen while solving */
set_verbose(lp, IMPORTANT);
/* Now let lpsolve calculate a solution */
ret = solve(lp);
if(ret == OPTIMAL)
ret = 0;
else
ret = 5;
}
if(ret == 0) {
/* a solution is calculated, now lets get some results */
/* objective value */
printf("Objective value: %f\n", get_objective(lp));
/* variable values */
get_variables(lp, row);
for(j = 0; j < Ncol; j++)
printf("%s: %f\n", get_col_name(lp, j + 1), row[j]);
/* we are done now */
}
/* free allocated memory */
if(row != NULL)
free(row);
if(colno != NULL)
free(colno);
if(lp != NULL) {
/* clean up such that all used memory by lpsolve is freed */
delete_lp(lp);
}
return(ret);
}
