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); }