Changeset 462:9b082b3fb33f in lemon-1.2 for lemon
- Timestamp:
- 01/12/09 13:26:02 (16 years ago)
- Branch:
- default
- Phase:
- public
- Location:
- lemon
- Files:
-
- 9 edited
Legend:
- Unmodified
- Added
- Removed
-
lemon/clp.cc
r461 r462 22 22 namespace lemon { 23 23 24 LpClp::LpClp() {24 ClpLp::ClpLp() { 25 25 _prob = new ClpSimplex(); 26 26 _init_temporals(); … … 28 28 } 29 29 30 LpClp::LpClp(const LpClp& other) {30 ClpLp::ClpLp(const ClpLp& other) { 31 31 _prob = new ClpSimplex(*other._prob); 32 32 rows = other.rows; … … 36 36 } 37 37 38 LpClp::~LpClp() {38 ClpLp::~ClpLp() { 39 39 delete _prob; 40 40 _clear_temporals(); 41 41 } 42 42 43 void LpClp::_init_temporals() {43 void ClpLp::_init_temporals() { 44 44 _primal_ray = 0; 45 45 _dual_ray = 0; 46 46 } 47 47 48 void LpClp::_clear_temporals() {48 void ClpLp::_clear_temporals() { 49 49 if (_primal_ray) { 50 50 delete[] _primal_ray; … … 57 57 } 58 58 59 LpClp* LpClp::_newSolver() const {60 LpClp* newlp = new LpClp;59 ClpLp* ClpLp::_newSolver() const { 60 ClpLp* newlp = new ClpLp; 61 61 return newlp; 62 62 } 63 63 64 LpClp* LpClp::_cloneSolver() const {65 LpClp* copylp = new LpClp(*this);64 ClpLp* ClpLp::_cloneSolver() const { 65 ClpLp* copylp = new ClpLp(*this); 66 66 return copylp; 67 67 } 68 68 69 const char* LpClp::_solverName() const { return "LpClp"; }70 71 int LpClp::_addCol() {69 const char* ClpLp::_solverName() const { return "ClpLp"; } 70 71 int ClpLp::_addCol() { 72 72 _prob->addColumn(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX, 0.0); 73 73 return _prob->numberColumns() - 1; 74 74 } 75 75 76 int LpClp::_addRow() {76 int ClpLp::_addRow() { 77 77 _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX); 78 78 return _prob->numberRows() - 1; … … 80 80 81 81 82 void LpClp::_eraseCol(int c) {82 void ClpLp::_eraseCol(int c) { 83 83 _col_names_ref.erase(_prob->getColumnName(c)); 84 84 _prob->deleteColumns(1, &c); 85 85 } 86 86 87 void LpClp::_eraseRow(int r) {87 void ClpLp::_eraseRow(int r) { 88 88 _row_names_ref.erase(_prob->getRowName(r)); 89 89 _prob->deleteRows(1, &r); 90 90 } 91 91 92 void LpClp::_eraseColId(int i) {92 void ClpLp::_eraseColId(int i) { 93 93 cols.eraseIndex(i); 94 94 cols.shiftIndices(i); 95 95 } 96 96 97 void LpClp::_eraseRowId(int i) {97 void ClpLp::_eraseRowId(int i) { 98 98 rows.eraseIndex(i); 99 99 rows.shiftIndices(i); 100 100 } 101 101 102 void LpClp::_getColName(int c, std::string& name) const {102 void ClpLp::_getColName(int c, std::string& name) const { 103 103 name = _prob->getColumnName(c); 104 104 } 105 105 106 void LpClp::_setColName(int c, const std::string& name) {106 void ClpLp::_setColName(int c, const std::string& name) { 107 107 _prob->setColumnName(c, const_cast<std::string&>(name)); 108 108 _col_names_ref[name] = c; 109 109 } 110 110 111 int LpClp::_colByName(const std::string& name) const {111 int ClpLp::_colByName(const std::string& name) const { 112 112 std::map<std::string, int>::const_iterator it = _col_names_ref.find(name); 113 113 return it != _col_names_ref.end() ? it->second : -1; 114 114 } 115 115 116 void LpClp::_getRowName(int r, std::string& name) const {116 void ClpLp::_getRowName(int r, std::string& name) const { 117 117 name = _prob->getRowName(r); 118 118 } 119 119 120 void LpClp::_setRowName(int r, const std::string& name) {120 void ClpLp::_setRowName(int r, const std::string& name) { 121 121 _prob->setRowName(r, const_cast<std::string&>(name)); 122 122 _row_names_ref[name] = r; 123 123 } 124 124 125 int LpClp::_rowByName(const std::string& name) const {125 int ClpLp::_rowByName(const std::string& name) const { 126 126 std::map<std::string, int>::const_iterator it = _row_names_ref.find(name); 127 127 return it != _row_names_ref.end() ? it->second : -1; … … 129 129 130 130 131 void LpClp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) {131 void ClpLp::_setRowCoeffs(int ix, ExprIterator b, ExprIterator e) { 132 132 std::map<int, Value> coeffs; 133 133 … … 157 157 } 158 158 159 void LpClp::_getRowCoeffs(int ix, InsertIterator b) const {159 void ClpLp::_getRowCoeffs(int ix, InsertIterator b) const { 160 160 int n = _prob->clpMatrix()->getNumCols(); 161 161 … … 174 174 } 175 175 176 void LpClp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) {176 void ClpLp::_setColCoeffs(int ix, ExprIterator b, ExprIterator e) { 177 177 std::map<int, Value> coeffs; 178 178 … … 197 197 } 198 198 199 void LpClp::_getColCoeffs(int ix, InsertIterator b) const {199 void ClpLp::_getColCoeffs(int ix, InsertIterator b) const { 200 200 CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix]; 201 201 CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix]; … … 210 210 } 211 211 212 void LpClp::_setCoeff(int ix, int jx, Value value) {212 void ClpLp::_setCoeff(int ix, int jx, Value value) { 213 213 _prob->modifyCoefficient(ix, jx, value); 214 214 } 215 215 216 LpClp::Value LpClp::_getCoeff(int ix, int jx) const {216 ClpLp::Value ClpLp::_getCoeff(int ix, int jx) const { 217 217 CoinBigIndex begin = _prob->clpMatrix()->getVectorStarts()[ix]; 218 218 CoinBigIndex end = begin + _prob->clpMatrix()->getVectorLengths()[ix]; … … 229 229 } 230 230 231 void LpClp::_setColLowerBound(int i, Value lo) {231 void ClpLp::_setColLowerBound(int i, Value lo) { 232 232 _prob->setColumnLower(i, lo == - INF ? - COIN_DBL_MAX : lo); 233 233 } 234 234 235 LpClp::Value LpClp::_getColLowerBound(int i) const {235 ClpLp::Value ClpLp::_getColLowerBound(int i) const { 236 236 double val = _prob->getColLower()[i]; 237 237 return val == - COIN_DBL_MAX ? - INF : val; 238 238 } 239 239 240 void LpClp::_setColUpperBound(int i, Value up) {240 void ClpLp::_setColUpperBound(int i, Value up) { 241 241 _prob->setColumnUpper(i, up == INF ? COIN_DBL_MAX : up); 242 242 } 243 243 244 LpClp::Value LpClp::_getColUpperBound(int i) const {244 ClpLp::Value ClpLp::_getColUpperBound(int i) const { 245 245 double val = _prob->getColUpper()[i]; 246 246 return val == COIN_DBL_MAX ? INF : val; 247 247 } 248 248 249 void LpClp::_setRowLowerBound(int i, Value lo) {249 void ClpLp::_setRowLowerBound(int i, Value lo) { 250 250 _prob->setRowLower(i, lo == - INF ? - COIN_DBL_MAX : lo); 251 251 } 252 252 253 LpClp::Value LpClp::_getRowLowerBound(int i) const {253 ClpLp::Value ClpLp::_getRowLowerBound(int i) const { 254 254 double val = _prob->getRowLower()[i]; 255 255 return val == - COIN_DBL_MAX ? - INF : val; 256 256 } 257 257 258 void LpClp::_setRowUpperBound(int i, Value up) {258 void ClpLp::_setRowUpperBound(int i, Value up) { 259 259 _prob->setRowUpper(i, up == INF ? COIN_DBL_MAX : up); 260 260 } 261 261 262 LpClp::Value LpClp::_getRowUpperBound(int i) const {262 ClpLp::Value ClpLp::_getRowUpperBound(int i) const { 263 263 double val = _prob->getRowUpper()[i]; 264 264 return val == COIN_DBL_MAX ? INF : val; 265 265 } 266 266 267 void LpClp::_setObjCoeffs(ExprIterator b, ExprIterator e) {267 void ClpLp::_setObjCoeffs(ExprIterator b, ExprIterator e) { 268 268 int num = _prob->clpMatrix()->getNumCols(); 269 269 for (int i = 0; i < num; ++i) { … … 275 275 } 276 276 277 void LpClp::_getObjCoeffs(InsertIterator b) const {277 void ClpLp::_getObjCoeffs(InsertIterator b) const { 278 278 int num = _prob->clpMatrix()->getNumCols(); 279 279 for (int i = 0; i < num; ++i) { … … 286 286 } 287 287 288 void LpClp::_setObjCoeff(int i, Value obj_coef) {288 void ClpLp::_setObjCoeff(int i, Value obj_coef) { 289 289 _prob->setObjectiveCoefficient(i, obj_coef); 290 290 } 291 291 292 LpClp::Value LpClp::_getObjCoeff(int i) const {292 ClpLp::Value ClpLp::_getObjCoeff(int i) const { 293 293 return _prob->getObjCoefficients()[i]; 294 294 } 295 295 296 LpClp::SolveExitStatus LpClp::_solve() {296 ClpLp::SolveExitStatus ClpLp::_solve() { 297 297 return _prob->primal() >= 0 ? SOLVED : UNSOLVED; 298 298 } 299 299 300 LpClp::SolveExitStatus LpClp::solvePrimal() {300 ClpLp::SolveExitStatus ClpLp::solvePrimal() { 301 301 return _prob->primal() >= 0 ? SOLVED : UNSOLVED; 302 302 } 303 303 304 LpClp::SolveExitStatus LpClp::solveDual() {304 ClpLp::SolveExitStatus ClpLp::solveDual() { 305 305 return _prob->dual() >= 0 ? SOLVED : UNSOLVED; 306 306 } 307 307 308 LpClp::SolveExitStatus LpClp::solveBarrier() {308 ClpLp::SolveExitStatus ClpLp::solveBarrier() { 309 309 return _prob->barrier() >= 0 ? SOLVED : UNSOLVED; 310 310 } 311 311 312 LpClp::Value LpClp::_getPrimal(int i) const {312 ClpLp::Value ClpLp::_getPrimal(int i) const { 313 313 return _prob->primalColumnSolution()[i]; 314 314 } 315 LpClp::Value LpClp::_getPrimalValue() const {315 ClpLp::Value ClpLp::_getPrimalValue() const { 316 316 return _prob->objectiveValue(); 317 317 } 318 318 319 LpClp::Value LpClp::_getDual(int i) const {319 ClpLp::Value ClpLp::_getDual(int i) const { 320 320 return _prob->dualRowSolution()[i]; 321 321 } 322 322 323 LpClp::Value LpClp::_getPrimalRay(int i) const {323 ClpLp::Value ClpLp::_getPrimalRay(int i) const { 324 324 if (!_primal_ray) { 325 325 _primal_ray = _prob->unboundedRay(); … … 329 329 } 330 330 331 LpClp::Value LpClp::_getDualRay(int i) const {331 ClpLp::Value ClpLp::_getDualRay(int i) const { 332 332 if (!_dual_ray) { 333 333 _dual_ray = _prob->infeasibilityRay(); … … 337 337 } 338 338 339 LpClp::VarStatus LpClp::_getColStatus(int i) const {339 ClpLp::VarStatus ClpLp::_getColStatus(int i) const { 340 340 switch (_prob->getColumnStatus(i)) { 341 341 case ClpSimplex::basic: … … 357 357 } 358 358 359 LpClp::VarStatus LpClp::_getRowStatus(int i) const {359 ClpLp::VarStatus ClpLp::_getRowStatus(int i) const { 360 360 switch (_prob->getColumnStatus(i)) { 361 361 case ClpSimplex::basic: … … 378 378 379 379 380 LpClp::ProblemType LpClp::_getPrimalType() const {380 ClpLp::ProblemType ClpLp::_getPrimalType() const { 381 381 if (_prob->isProvenOptimal()) { 382 382 return OPTIMAL; … … 390 390 } 391 391 392 LpClp::ProblemType LpClp::_getDualType() const {392 ClpLp::ProblemType ClpLp::_getDualType() const { 393 393 if (_prob->isProvenOptimal()) { 394 394 return OPTIMAL; … … 402 402 } 403 403 404 void LpClp::_setSense(LpClp::Sense sense) {404 void ClpLp::_setSense(ClpLp::Sense sense) { 405 405 switch (sense) { 406 406 case MIN: … … 413 413 } 414 414 415 LpClp::Sense LpClp::_getSense() const {415 ClpLp::Sense ClpLp::_getSense() const { 416 416 double dir = _prob->optimizationDirection(); 417 417 if (dir > 0.0) { … … 422 422 } 423 423 424 void LpClp::_clear() {424 void ClpLp::_clear() { 425 425 delete _prob; 426 426 _prob = new ClpSimplex(); … … 431 431 } 432 432 433 void LpClp::messageLevel(MessageLevel m) {433 void ClpLp::messageLevel(MessageLevel m) { 434 434 _prob->setLogLevel(static_cast<int>(m)); 435 435 } -
lemon/clp.h
r461 r462 40 40 /// the IBM. The CLP is part of the COIN-OR package and it can be 41 41 /// used with Common Public License. 42 class LpClp : public LpSolver {42 class ClpLp : public LpSolver { 43 43 protected: 44 44 … … 51 51 52 52 /// \e 53 LpClp();53 ClpLp(); 54 54 /// \e 55 LpClp(const LpClp&);55 ClpLp(const ClpLp&); 56 56 /// \e 57 ~ LpClp();57 ~ClpLp(); 58 58 59 59 protected: … … 67 67 protected: 68 68 69 virtual LpClp* _newSolver() const;70 virtual LpClp* _cloneSolver() const;69 virtual ClpLp* _newSolver() const; 70 virtual ClpLp* _cloneSolver() const; 71 71 72 72 virtual const char* _solverName() const; -
lemon/cplex.cc
r461 r462 439 439 } 440 440 441 // LpCplexmembers442 443 LpCplex::LpCplex()441 // CplexLp members 442 443 CplexLp::CplexLp() 444 444 : LpBase(), CplexBase(), LpSolver() {} 445 445 446 LpCplex::LpCplex(const CplexEnv& env)446 CplexLp::CplexLp(const CplexEnv& env) 447 447 : LpBase(), CplexBase(env), LpSolver() {} 448 448 449 LpCplex::LpCplex(const LpCplex& other)449 CplexLp::CplexLp(const CplexLp& other) 450 450 : LpBase(), CplexBase(other), LpSolver() {} 451 451 452 LpCplex::~LpCplex() {}453 454 LpCplex* LpCplex::_newSolver() const { return new LpCplex; }455 LpCplex* LpCplex::_cloneSolver() const {return new LpCplex(*this); }456 457 const char* LpCplex::_solverName() const { return "LpCplex"; }458 459 void LpCplex::_clear_temporals() {452 CplexLp::~CplexLp() {} 453 454 CplexLp* CplexLp::_newSolver() const { return new CplexLp; } 455 CplexLp* CplexLp::_cloneSolver() const {return new CplexLp(*this); } 456 457 const char* CplexLp::_solverName() const { return "CplexLp"; } 458 459 void CplexLp::_clear_temporals() { 460 460 _col_status.clear(); 461 461 _row_status.clear(); … … 473 473 // routines CPXsolninfo, CPXgetstat, and CPXsolution to obtain 474 474 // further information about the status of the optimization. 475 LpCplex::SolveExitStatus LpCplex::convertStatus(int status) {475 CplexLp::SolveExitStatus CplexLp::convertStatus(int status) { 476 476 #if CPX_VERSION >= 800 477 477 if (status == 0) { … … 506 506 } 507 507 508 LpCplex::SolveExitStatus LpCplex::_solve() {508 CplexLp::SolveExitStatus CplexLp::_solve() { 509 509 _clear_temporals(); 510 510 return convertStatus(CPXlpopt(cplexEnv(), _prob)); 511 511 } 512 512 513 LpCplex::SolveExitStatus LpCplex::solvePrimal() {513 CplexLp::SolveExitStatus CplexLp::solvePrimal() { 514 514 _clear_temporals(); 515 515 return convertStatus(CPXprimopt(cplexEnv(), _prob)); 516 516 } 517 517 518 LpCplex::SolveExitStatus LpCplex::solveDual() {518 CplexLp::SolveExitStatus CplexLp::solveDual() { 519 519 _clear_temporals(); 520 520 return convertStatus(CPXdualopt(cplexEnv(), _prob)); 521 521 } 522 522 523 LpCplex::SolveExitStatus LpCplex::solveBarrier() {523 CplexLp::SolveExitStatus CplexLp::solveBarrier() { 524 524 _clear_temporals(); 525 525 return convertStatus(CPXbaropt(cplexEnv(), _prob)); 526 526 } 527 527 528 LpCplex::Value LpCplex::_getPrimal(int i) const {528 CplexLp::Value CplexLp::_getPrimal(int i) const { 529 529 Value x; 530 530 CPXgetx(cplexEnv(), _prob, &x, i, i); … … 532 532 } 533 533 534 LpCplex::Value LpCplex::_getDual(int i) const {534 CplexLp::Value CplexLp::_getDual(int i) const { 535 535 Value y; 536 536 CPXgetpi(cplexEnv(), _prob, &y, i, i); … … 538 538 } 539 539 540 LpCplex::Value LpCplex::_getPrimalValue() const {540 CplexLp::Value CplexLp::_getPrimalValue() const { 541 541 Value objval; 542 542 CPXgetobjval(cplexEnv(), _prob, &objval); … … 544 544 } 545 545 546 LpCplex::VarStatus LpCplex::_getColStatus(int i) const {546 CplexLp::VarStatus CplexLp::_getColStatus(int i) const { 547 547 if (_col_status.empty()) { 548 548 _col_status.resize(CPXgetnumcols(cplexEnv(), _prob)); … … 560 560 default: 561 561 LEMON_ASSERT(false, "Wrong column status"); 562 return LpCplex::VarStatus();563 } 564 } 565 566 LpCplex::VarStatus LpCplex::_getRowStatus(int i) const {562 return CplexLp::VarStatus(); 563 } 564 } 565 566 CplexLp::VarStatus CplexLp::_getRowStatus(int i) const { 567 567 if (_row_status.empty()) { 568 568 _row_status.resize(CPXgetnumrows(cplexEnv(), _prob)); … … 582 582 default: 583 583 LEMON_ASSERT(false, "Wrong row status"); 584 return LpCplex::VarStatus();585 } 586 } 587 588 LpCplex::Value LpCplex::_getPrimalRay(int i) const {584 return CplexLp::VarStatus(); 585 } 586 } 587 588 CplexLp::Value CplexLp::_getPrimalRay(int i) const { 589 589 if (_primal_ray.empty()) { 590 590 _primal_ray.resize(CPXgetnumcols(cplexEnv(), _prob)); … … 594 594 } 595 595 596 LpCplex::Value LpCplex::_getDualRay(int i) const {596 CplexLp::Value CplexLp::_getDualRay(int i) const { 597 597 if (_dual_ray.empty()) { 598 598 … … 687 687 #endif 688 688 689 LpCplex::ProblemType LpCplex::_getPrimalType() const {689 CplexLp::ProblemType CplexLp::_getPrimalType() const { 690 690 // Unboundedness not treated well: the following is from cplex 9.0 doc 691 691 // About Unboundedness … … 769 769 // CPX_STAT_UNBOUNDED 770 770 771 LpCplex::ProblemType LpCplex::_getDualType() const {771 CplexLp::ProblemType CplexLp::_getDualType() const { 772 772 int stat = CPXgetstat(cplexEnv(), _prob); 773 773 #if CPX_VERSION >= 800 … … 796 796 } 797 797 798 // MipCplexmembers799 800 MipCplex::MipCplex()798 // CplexMip members 799 800 CplexMip::CplexMip() 801 801 : LpBase(), CplexBase(), MipSolver() { 802 802 … … 808 808 } 809 809 810 MipCplex::MipCplex(const CplexEnv& env)810 CplexMip::CplexMip(const CplexEnv& env) 811 811 : LpBase(), CplexBase(env), MipSolver() { 812 812 … … 819 819 } 820 820 821 MipCplex::MipCplex(const MipCplex& other)821 CplexMip::CplexMip(const CplexMip& other) 822 822 : LpBase(), CplexBase(other), MipSolver() {} 823 823 824 MipCplex::~MipCplex() {}825 826 MipCplex* MipCplex::_newSolver() const { return new MipCplex; }827 MipCplex* MipCplex::_cloneSolver() const {return new MipCplex(*this); }828 829 const char* MipCplex::_solverName() const { return "MipCplex"; }830 831 void MipCplex::_setColType(int i, MipCplex::ColTypes col_type) {824 CplexMip::~CplexMip() {} 825 826 CplexMip* CplexMip::_newSolver() const { return new CplexMip; } 827 CplexMip* CplexMip::_cloneSolver() const {return new CplexMip(*this); } 828 829 const char* CplexMip::_solverName() const { return "CplexMip"; } 830 831 void CplexMip::_setColType(int i, CplexMip::ColTypes col_type) { 832 832 833 833 // Note If a variable is to be changed to binary, a call to CPXchgbds … … 848 848 } 849 849 850 MipCplex::ColTypes MipCplex::_getColType(int i) const {850 CplexMip::ColTypes CplexMip::_getColType(int i) const { 851 851 char t; 852 852 CPXgetctype (cplexEnv(), _prob, &t, i, i); … … 863 863 } 864 864 865 MipCplex::SolveExitStatus MipCplex::_solve() {865 CplexMip::SolveExitStatus CplexMip::_solve() { 866 866 int status; 867 867 status = CPXmipopt (cplexEnv(), _prob); … … 874 874 875 875 876 MipCplex::ProblemType MipCplex::_getType() const {876 CplexMip::ProblemType CplexMip::_getType() const { 877 877 878 878 int stat = CPXgetstat(cplexEnv(), _prob); … … 910 910 } 911 911 912 MipCplex::Value MipCplex::_getSol(int i) const {912 CplexMip::Value CplexMip::_getSol(int i) const { 913 913 Value x; 914 914 CPXgetmipx(cplexEnv(), _prob, &x, i, i); … … 916 916 } 917 917 918 MipCplex::Value MipCplex::_getSolValue() const {918 CplexMip::Value CplexMip::_getSolValue() const { 919 919 Value objval; 920 920 CPXgetmipobjval(cplexEnv(), _prob, &objval); -
lemon/cplex.h
r461 r462 161 161 /// This class implements an interface for the CPLEX LP solver. 162 162 ///\ingroup lp_group 163 class LpCplex: public CplexBase, public LpSolver {164 public: 165 /// \e 166 LpCplex();167 /// \e 168 LpCplex(const CplexEnv&);169 /// \e 170 LpCplex(const LpCplex&);171 /// \e 172 virtual ~ LpCplex();163 class CplexLp : public CplexBase, public LpSolver { 164 public: 165 /// \e 166 CplexLp(); 167 /// \e 168 CplexLp(const CplexEnv&); 169 /// \e 170 CplexLp(const CplexLp&); 171 /// \e 172 virtual ~CplexLp(); 173 173 174 174 private: … … 187 187 protected: 188 188 189 virtual LpCplex* _cloneSolver() const;190 virtual LpCplex* _newSolver() const;189 virtual CplexLp* _cloneSolver() const; 190 virtual CplexLp* _newSolver() const; 191 191 192 192 virtual const char* _solverName() const; … … 223 223 /// This class implements an interface for the CPLEX MIP solver. 224 224 ///\ingroup lp_group 225 class MipCplex: public CplexBase, public MipSolver {226 public: 227 /// \e 228 MipCplex();229 /// \e 230 MipCplex(const CplexEnv&);231 /// \e 232 MipCplex(const MipCplex&);233 /// \e 234 virtual ~ MipCplex();235 236 protected: 237 238 virtual MipCplex* _cloneSolver() const;239 virtual MipCplex* _newSolver() const;225 class CplexMip : public CplexBase, public MipSolver { 226 public: 227 /// \e 228 CplexMip(); 229 /// \e 230 CplexMip(const CplexEnv&); 231 /// \e 232 CplexMip(const CplexMip&); 233 /// \e 234 virtual ~CplexMip(); 235 236 protected: 237 238 virtual CplexMip* _cloneSolver() const; 239 virtual CplexMip* _newSolver() const; 240 240 241 241 virtual const char* _solverName() const; -
lemon/glpk.cc
r461 r462 523 523 } 524 524 525 // LpGlpkmembers526 527 LpGlpk::LpGlpk()525 // GlpkLp members 526 527 GlpkLp::GlpkLp() 528 528 : LpBase(), GlpkBase(), LpSolver() { 529 529 messageLevel(MESSAGE_NO_OUTPUT); 530 530 } 531 531 532 LpGlpk::LpGlpk(const LpGlpk& other)532 GlpkLp::GlpkLp(const GlpkLp& other) 533 533 : LpBase(other), GlpkBase(other), LpSolver(other) { 534 534 messageLevel(MESSAGE_NO_OUTPUT); 535 535 } 536 536 537 LpGlpk* LpGlpk::_newSolver() const { return new LpGlpk; }538 LpGlpk* LpGlpk::_cloneSolver() const { return new LpGlpk(*this); }539 540 const char* LpGlpk::_solverName() const { return "LpGlpk"; }541 542 void LpGlpk::_clear_temporals() {537 GlpkLp* GlpkLp::_newSolver() const { return new GlpkLp; } 538 GlpkLp* GlpkLp::_cloneSolver() const { return new GlpkLp(*this); } 539 540 const char* GlpkLp::_solverName() const { return "GlpkLp"; } 541 542 void GlpkLp::_clear_temporals() { 543 543 _primal_ray.clear(); 544 544 _dual_ray.clear(); 545 545 } 546 546 547 LpGlpk::SolveExitStatus LpGlpk::_solve() {547 GlpkLp::SolveExitStatus GlpkLp::_solve() { 548 548 return solvePrimal(); 549 549 } 550 550 551 LpGlpk::SolveExitStatus LpGlpk::solvePrimal() {551 GlpkLp::SolveExitStatus GlpkLp::solvePrimal() { 552 552 _clear_temporals(); 553 553 … … 574 574 } 575 575 576 LpGlpk::SolveExitStatus LpGlpk::solveDual() {576 GlpkLp::SolveExitStatus GlpkLp::solveDual() { 577 577 _clear_temporals(); 578 578 … … 600 600 } 601 601 602 LpGlpk::Value LpGlpk::_getPrimal(int i) const {602 GlpkLp::Value GlpkLp::_getPrimal(int i) const { 603 603 return glp_get_col_prim(lp, i); 604 604 } 605 605 606 LpGlpk::Value LpGlpk::_getDual(int i) const {606 GlpkLp::Value GlpkLp::_getDual(int i) const { 607 607 return glp_get_row_dual(lp, i); 608 608 } 609 609 610 LpGlpk::Value LpGlpk::_getPrimalValue() const {610 GlpkLp::Value GlpkLp::_getPrimalValue() const { 611 611 return glp_get_obj_val(lp); 612 612 } 613 613 614 LpGlpk::VarStatus LpGlpk::_getColStatus(int i) const {614 GlpkLp::VarStatus GlpkLp::_getColStatus(int i) const { 615 615 switch (glp_get_col_stat(lp, i)) { 616 616 case GLP_BS: … … 626 626 default: 627 627 LEMON_ASSERT(false, "Wrong column status"); 628 return LpGlpk::VarStatus();629 } 630 } 631 632 LpGlpk::VarStatus LpGlpk::_getRowStatus(int i) const {628 return GlpkLp::VarStatus(); 629 } 630 } 631 632 GlpkLp::VarStatus GlpkLp::_getRowStatus(int i) const { 633 633 switch (glp_get_row_stat(lp, i)) { 634 634 case GLP_BS: … … 644 644 default: 645 645 LEMON_ASSERT(false, "Wrong row status"); 646 return LpGlpk::VarStatus();647 } 648 } 649 650 LpGlpk::Value LpGlpk::_getPrimalRay(int i) const {646 return GlpkLp::VarStatus(); 647 } 648 } 649 650 GlpkLp::Value GlpkLp::_getPrimalRay(int i) const { 651 651 if (_primal_ray.empty()) { 652 652 int row_num = glp_get_num_rows(lp); … … 700 700 } 701 701 702 LpGlpk::Value LpGlpk::_getDualRay(int i) const {702 GlpkLp::Value GlpkLp::_getDualRay(int i) const { 703 703 if (_dual_ray.empty()) { 704 704 int row_num = glp_get_num_rows(lp); … … 772 772 } 773 773 774 LpGlpk::ProblemType LpGlpk::_getPrimalType() const {774 GlpkLp::ProblemType GlpkLp::_getPrimalType() const { 775 775 if (glp_get_status(lp) == GLP_OPT) 776 776 return OPTIMAL; … … 789 789 default: 790 790 LEMON_ASSERT(false, "Wrong primal type"); 791 return LpGlpk::ProblemType();792 } 793 } 794 795 LpGlpk::ProblemType LpGlpk::_getDualType() const {791 return GlpkLp::ProblemType(); 792 } 793 } 794 795 GlpkLp::ProblemType GlpkLp::_getDualType() const { 796 796 if (glp_get_status(lp) == GLP_OPT) 797 797 return OPTIMAL; … … 810 810 default: 811 811 LEMON_ASSERT(false, "Wrong primal type"); 812 return LpGlpk::ProblemType();813 } 814 } 815 816 void LpGlpk::presolver(bool b) {812 return GlpkLp::ProblemType(); 813 } 814 } 815 816 void GlpkLp::presolver(bool b) { 817 817 lpx_set_int_parm(lp, LPX_K_PRESOL, b ? 1 : 0); 818 818 } 819 819 820 void LpGlpk::messageLevel(MessageLevel m) {820 void GlpkLp::messageLevel(MessageLevel m) { 821 821 _message_level = m; 822 822 } 823 823 824 // MipGlpkmembers825 826 MipGlpk::MipGlpk()824 // GlpkMip members 825 826 GlpkMip::GlpkMip() 827 827 : LpBase(), GlpkBase(), MipSolver() { 828 828 messageLevel(MESSAGE_NO_OUTPUT); 829 829 } 830 830 831 MipGlpk::MipGlpk(const MipGlpk& other)831 GlpkMip::GlpkMip(const GlpkMip& other) 832 832 : LpBase(), GlpkBase(other), MipSolver() { 833 833 messageLevel(MESSAGE_NO_OUTPUT); 834 834 } 835 835 836 void MipGlpk::_setColType(int i, MipGlpk::ColTypes col_type) {836 void GlpkMip::_setColType(int i, GlpkMip::ColTypes col_type) { 837 837 switch (col_type) { 838 838 case INTEGER: … … 845 845 } 846 846 847 MipGlpk::ColTypes MipGlpk::_getColType(int i) const {847 GlpkMip::ColTypes GlpkMip::_getColType(int i) const { 848 848 switch (glp_get_col_kind(lp, i)) { 849 849 case GLP_IV: … … 856 856 } 857 857 858 MipGlpk::SolveExitStatus MipGlpk::_solve() {858 GlpkMip::SolveExitStatus GlpkMip::_solve() { 859 859 glp_smcp smcp; 860 860 glp_init_smcp(&smcp); … … 902 902 903 903 904 MipGlpk::ProblemType MipGlpk::_getType() const {904 GlpkMip::ProblemType GlpkMip::_getType() const { 905 905 switch (glp_get_status(lp)) { 906 906 case GLP_OPT: … … 916 916 default: 917 917 LEMON_ASSERT(false, "Wrong problem type."); 918 return MipGlpk::ProblemType();918 return GlpkMip::ProblemType(); 919 919 } 920 920 case GLP_NOFEAS: … … 929 929 default: 930 930 LEMON_ASSERT(false, "Wrong problem type."); 931 return MipGlpk::ProblemType();932 } 933 } 934 935 MipGlpk::Value MipGlpk::_getSol(int i) const {931 return GlpkMip::ProblemType(); 932 } 933 } 934 935 GlpkMip::Value GlpkMip::_getSol(int i) const { 936 936 return glp_mip_col_val(lp, i); 937 937 } 938 938 939 MipGlpk::Value MipGlpk::_getSolValue() const {939 GlpkMip::Value GlpkMip::_getSolValue() const { 940 940 return glp_mip_obj_val(lp); 941 941 } 942 942 943 MipGlpk* MipGlpk::_newSolver() const { return new MipGlpk; }944 MipGlpk* MipGlpk::_cloneSolver() const {return new MipGlpk(*this); }945 946 const char* MipGlpk::_solverName() const { return "MipGlpk"; }947 948 void MipGlpk::messageLevel(MessageLevel m) {943 GlpkMip* GlpkMip::_newSolver() const { return new GlpkMip; } 944 GlpkMip* GlpkMip::_cloneSolver() const {return new GlpkMip(*this); } 945 946 const char* GlpkMip::_solverName() const { return "GlpkMip"; } 947 948 void GlpkMip::messageLevel(MessageLevel m) { 949 949 _message_level = m; 950 950 } -
lemon/glpk.h
r461 r462 120 120 /// This class implements an interface for the GLPK LP solver. 121 121 ///\ingroup lp_group 122 class LpGlpk: public GlpkBase, public LpSolver {123 public: 124 125 ///\e 126 LpGlpk();127 ///\e 128 LpGlpk(const LpGlpk&);122 class GlpkLp : public GlpkBase, public LpSolver { 123 public: 124 125 ///\e 126 GlpkLp(); 127 ///\e 128 GlpkLp(const GlpkLp&); 129 129 130 130 private: … … 137 137 protected: 138 138 139 virtual LpGlpk* _cloneSolver() const;140 virtual LpGlpk* _newSolver() const;139 virtual GlpkLp* _cloneSolver() const; 140 virtual GlpkLp* _newSolver() const; 141 141 142 142 virtual const char* _solverName() const; … … 204 204 /// This class implements an interface for the GLPK MIP solver. 205 205 ///\ingroup lp_group 206 class MipGlpk: public GlpkBase, public MipSolver {207 public: 208 209 ///\e 210 MipGlpk();211 ///\e 212 MipGlpk(const MipGlpk&);213 214 protected: 215 216 virtual MipGlpk* _cloneSolver() const;217 virtual MipGlpk* _newSolver() const;206 class GlpkMip : public GlpkBase, public MipSolver { 207 public: 208 209 ///\e 210 GlpkMip(); 211 ///\e 212 GlpkMip(const GlpkMip&); 213 214 protected: 215 216 virtual GlpkMip* _cloneSolver() const; 217 virtual GlpkMip* _newSolver() const; 218 218 219 219 virtual const char* _solverName() const; -
lemon/lp.h
r461 r462 52 52 ///\ingroup lp_group 53 53 /// 54 ///Currently, it is either \c LpGlpk, \c LpCplex, \c LpSoplex or \c LpClp55 typedef LpGlpkLp;54 ///Currently, it is either \c GlpkLp, \c CplexLp, \c SoplexLp or \c ClpLp 55 typedef GlpkLp Lp; 56 56 57 57 ///The default MIP solver identifier … … 67 67 ///\ingroup lp_group 68 68 /// 69 ///Currently, it is either \c MipGlpk or \c MipCplex70 typedef MipGlpkMip;69 ///Currently, it is either \c GlpkMip or \c CplexMip 70 typedef GlpkMip Mip; 71 71 #else 72 72 #ifdef HAVE_GLPK 73 73 # define LEMON_DEFAULT_LP GLPK 74 typedef LpGlpkLp;74 typedef GlpkLp Lp; 75 75 # define LEMON_DEFAULT_MIP GLPK 76 typedef MipGlpkMip;76 typedef GlpkMip Mip; 77 77 #elif HAVE_CPLEX 78 78 # define LEMON_DEFAULT_LP CPLEX 79 typedef LpCplexLp;79 typedef CplexLp Lp; 80 80 # define LEMON_DEFAULT_MIP CPLEX 81 typedef MipCplexMip;81 typedef CplexMip Mip; 82 82 #elif HAVE_SOPLEX 83 83 # define DEFAULT_LP SOPLEX 84 typedef LpSoplexLp;84 typedef SoplexLp Lp; 85 85 #elif HAVE_CLP 86 86 # define DEFAULT_LP CLP 87 typedef LpClp Lp;87 typedef ClpLp Lp; 88 88 #endif 89 89 #endif -
lemon/soplex.cc
r461 r462 27 27 namespace lemon { 28 28 29 LpSoplex::LpSoplex() {29 SoplexLp::SoplexLp() { 30 30 soplex = new soplex::SoPlex; 31 31 } 32 32 33 LpSoplex::~LpSoplex() {33 SoplexLp::~SoplexLp() { 34 34 delete soplex; 35 35 } 36 36 37 LpSoplex::LpSoplex(const LpSoplex& lp) {37 SoplexLp::SoplexLp(const SoplexLp& lp) { 38 38 rows = lp.rows; 39 39 cols = lp.cols; … … 50 50 } 51 51 52 void LpSoplex::_clear_temporals() {52 void SoplexLp::_clear_temporals() { 53 53 _primal_values.clear(); 54 54 _dual_values.clear(); 55 55 } 56 56 57 LpSoplex* LpSoplex::_newSolver() const {58 LpSoplex* newlp = new LpSoplex();57 SoplexLp* SoplexLp::_newSolver() const { 58 SoplexLp* newlp = new SoplexLp(); 59 59 return newlp; 60 60 } 61 61 62 LpSoplex* LpSoplex::_cloneSolver() const {63 LpSoplex* newlp = new LpSoplex(*this);62 SoplexLp* SoplexLp::_cloneSolver() const { 63 SoplexLp* newlp = new SoplexLp(*this); 64 64 return newlp; 65 65 } 66 66 67 const char* LpSoplex::_solverName() const { return "LpSoplex"; }68 69 int LpSoplex::_addCol() {67 const char* SoplexLp::_solverName() const { return "SoplexLp"; } 68 69 int SoplexLp::_addCol() { 70 70 soplex::LPCol c; 71 71 c.setLower(-soplex::infinity); … … 78 78 } 79 79 80 int LpSoplex::_addRow() {80 int SoplexLp::_addRow() { 81 81 soplex::LPRow r; 82 82 r.setLhs(-soplex::infinity); … … 90 90 91 91 92 void LpSoplex::_eraseCol(int i) {92 void SoplexLp::_eraseCol(int i) { 93 93 soplex->removeCol(i); 94 94 _col_names_ref.erase(_col_names[i]); … … 98 98 } 99 99 100 void LpSoplex::_eraseRow(int i) {100 void SoplexLp::_eraseRow(int i) { 101 101 soplex->removeRow(i); 102 102 _row_names_ref.erase(_row_names[i]); … … 106 106 } 107 107 108 void LpSoplex::_eraseColId(int i) {108 void SoplexLp::_eraseColId(int i) { 109 109 cols.eraseIndex(i); 110 110 cols.relocateIndex(i, cols.maxIndex()); 111 111 } 112 void LpSoplex::_eraseRowId(int i) {112 void SoplexLp::_eraseRowId(int i) { 113 113 rows.eraseIndex(i); 114 114 rows.relocateIndex(i, rows.maxIndex()); 115 115 } 116 116 117 void LpSoplex::_getColName(int c, std::string &name) const {117 void SoplexLp::_getColName(int c, std::string &name) const { 118 118 name = _col_names[c]; 119 119 } 120 120 121 void LpSoplex::_setColName(int c, const std::string &name) {121 void SoplexLp::_setColName(int c, const std::string &name) { 122 122 _col_names_ref.erase(_col_names[c]); 123 123 _col_names[c] = name; … … 127 127 } 128 128 129 int LpSoplex::_colByName(const std::string& name) const {129 int SoplexLp::_colByName(const std::string& name) const { 130 130 std::map<std::string, int>::const_iterator it = 131 131 _col_names_ref.find(name); … … 137 137 } 138 138 139 void LpSoplex::_getRowName(int r, std::string &name) const {139 void SoplexLp::_getRowName(int r, std::string &name) const { 140 140 name = _row_names[r]; 141 141 } 142 142 143 void LpSoplex::_setRowName(int r, const std::string &name) {143 void SoplexLp::_setRowName(int r, const std::string &name) { 144 144 _row_names_ref.erase(_row_names[r]); 145 145 _row_names[r] = name; … … 149 149 } 150 150 151 int LpSoplex::_rowByName(const std::string& name) const {151 int SoplexLp::_rowByName(const std::string& name) const { 152 152 std::map<std::string, int>::const_iterator it = 153 153 _row_names_ref.find(name); … … 160 160 161 161 162 void LpSoplex::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) {162 void SoplexLp::_setRowCoeffs(int i, ExprIterator b, ExprIterator e) { 163 163 for (int j = 0; j < soplex->nCols(); ++j) { 164 164 soplex->changeElement(i, j, 0.0); … … 169 169 } 170 170 171 void LpSoplex::_getRowCoeffs(int i, InsertIterator b) const {171 void SoplexLp::_getRowCoeffs(int i, InsertIterator b) const { 172 172 const soplex::SVector& vec = soplex->rowVector(i); 173 173 for (int k = 0; k < vec.size(); ++k) { … … 177 177 } 178 178 179 void LpSoplex::_setColCoeffs(int j, ExprIterator b, ExprIterator e) {179 void SoplexLp::_setColCoeffs(int j, ExprIterator b, ExprIterator e) { 180 180 for (int i = 0; i < soplex->nRows(); ++i) { 181 181 soplex->changeElement(i, j, 0.0); … … 186 186 } 187 187 188 void LpSoplex::_getColCoeffs(int i, InsertIterator b) const {188 void SoplexLp::_getColCoeffs(int i, InsertIterator b) const { 189 189 const soplex::SVector& vec = soplex->colVector(i); 190 190 for (int k = 0; k < vec.size(); ++k) { … … 194 194 } 195 195 196 void LpSoplex::_setCoeff(int i, int j, Value value) {196 void SoplexLp::_setCoeff(int i, int j, Value value) { 197 197 soplex->changeElement(i, j, value); 198 198 } 199 199 200 LpSoplex::Value LpSoplex::_getCoeff(int i, int j) const {200 SoplexLp::Value SoplexLp::_getCoeff(int i, int j) const { 201 201 return soplex->rowVector(i)[j]; 202 202 } 203 203 204 void LpSoplex::_setColLowerBound(int i, Value value) {204 void SoplexLp::_setColLowerBound(int i, Value value) { 205 205 LEMON_ASSERT(value != INF, "Invalid bound"); 206 206 soplex->changeLower(i, value != -INF ? value : -soplex::infinity); 207 207 } 208 208 209 LpSoplex::Value LpSoplex::_getColLowerBound(int i) const {209 SoplexLp::Value SoplexLp::_getColLowerBound(int i) const { 210 210 double value = soplex->lower(i); 211 211 return value != -soplex::infinity ? value : -INF; 212 212 } 213 213 214 void LpSoplex::_setColUpperBound(int i, Value value) {214 void SoplexLp::_setColUpperBound(int i, Value value) { 215 215 LEMON_ASSERT(value != -INF, "Invalid bound"); 216 216 soplex->changeUpper(i, value != INF ? value : soplex::infinity); 217 217 } 218 218 219 LpSoplex::Value LpSoplex::_getColUpperBound(int i) const {219 SoplexLp::Value SoplexLp::_getColUpperBound(int i) const { 220 220 double value = soplex->upper(i); 221 221 return value != soplex::infinity ? value : INF; 222 222 } 223 223 224 void LpSoplex::_setRowLowerBound(int i, Value lb) {224 void SoplexLp::_setRowLowerBound(int i, Value lb) { 225 225 LEMON_ASSERT(lb != INF, "Invalid bound"); 226 226 soplex->changeRange(i, lb != -INF ? lb : -soplex::infinity, soplex->rhs(i)); 227 227 } 228 228 229 LpSoplex::Value LpSoplex::_getRowLowerBound(int i) const {229 SoplexLp::Value SoplexLp::_getRowLowerBound(int i) const { 230 230 double res = soplex->lhs(i); 231 231 return res == -soplex::infinity ? -INF : res; 232 232 } 233 233 234 void LpSoplex::_setRowUpperBound(int i, Value ub) {234 void SoplexLp::_setRowUpperBound(int i, Value ub) { 235 235 LEMON_ASSERT(ub != -INF, "Invalid bound"); 236 236 soplex->changeRange(i, soplex->lhs(i), ub != INF ? ub : soplex::infinity); 237 237 } 238 238 239 LpSoplex::Value LpSoplex::_getRowUpperBound(int i) const {239 SoplexLp::Value SoplexLp::_getRowUpperBound(int i) const { 240 240 double res = soplex->rhs(i); 241 241 return res == soplex::infinity ? INF : res; 242 242 } 243 243 244 void LpSoplex::_setObjCoeffs(ExprIterator b, ExprIterator e) {244 void SoplexLp::_setObjCoeffs(ExprIterator b, ExprIterator e) { 245 245 for (int j = 0; j < soplex->nCols(); ++j) { 246 246 soplex->changeObj(j, 0.0); … … 251 251 } 252 252 253 void LpSoplex::_getObjCoeffs(InsertIterator b) const {253 void SoplexLp::_getObjCoeffs(InsertIterator b) const { 254 254 for (int j = 0; j < soplex->nCols(); ++j) { 255 255 Value coef = soplex->obj(j); … … 261 261 } 262 262 263 void LpSoplex::_setObjCoeff(int i, Value obj_coef) {263 void SoplexLp::_setObjCoeff(int i, Value obj_coef) { 264 264 soplex->changeObj(i, obj_coef); 265 265 } 266 266 267 LpSoplex::Value LpSoplex::_getObjCoeff(int i) const {267 SoplexLp::Value SoplexLp::_getObjCoeff(int i) const { 268 268 return soplex->obj(i); 269 269 } 270 270 271 LpSoplex::SolveExitStatus LpSoplex::_solve() {271 SoplexLp::SolveExitStatus SoplexLp::_solve() { 272 272 273 273 _clear_temporals(); … … 285 285 } 286 286 287 LpSoplex::Value LpSoplex::_getPrimal(int i) const {287 SoplexLp::Value SoplexLp::_getPrimal(int i) const { 288 288 if (_primal_values.empty()) { 289 289 _primal_values.resize(soplex->nCols()); … … 294 294 } 295 295 296 LpSoplex::Value LpSoplex::_getDual(int i) const {296 SoplexLp::Value SoplexLp::_getDual(int i) const { 297 297 if (_dual_values.empty()) { 298 298 _dual_values.resize(soplex->nRows()); … … 303 303 } 304 304 305 LpSoplex::Value LpSoplex::_getPrimalValue() const {305 SoplexLp::Value SoplexLp::_getPrimalValue() const { 306 306 return soplex->objValue(); 307 307 } 308 308 309 LpSoplex::VarStatus LpSoplex::_getColStatus(int i) const {309 SoplexLp::VarStatus SoplexLp::_getColStatus(int i) const { 310 310 switch (soplex->getBasisColStatus(i)) { 311 311 case soplex::SPxSolver::BASIC: … … 325 325 } 326 326 327 LpSoplex::VarStatus LpSoplex::_getRowStatus(int i) const {327 SoplexLp::VarStatus SoplexLp::_getRowStatus(int i) const { 328 328 switch (soplex->getBasisRowStatus(i)) { 329 329 case soplex::SPxSolver::BASIC: … … 343 343 } 344 344 345 LpSoplex::Value LpSoplex::_getPrimalRay(int i) const {345 SoplexLp::Value SoplexLp::_getPrimalRay(int i) const { 346 346 if (_primal_ray.empty()) { 347 347 _primal_ray.resize(soplex->nCols()); … … 352 352 } 353 353 354 LpSoplex::Value LpSoplex::_getDualRay(int i) const {354 SoplexLp::Value SoplexLp::_getDualRay(int i) const { 355 355 if (_dual_ray.empty()) { 356 356 _dual_ray.resize(soplex->nRows()); … … 361 361 } 362 362 363 LpSoplex::ProblemType LpSoplex::_getPrimalType() const {363 SoplexLp::ProblemType SoplexLp::_getPrimalType() const { 364 364 switch (soplex->status()) { 365 365 case soplex::SPxSolver::OPTIMAL: … … 374 374 } 375 375 376 LpSoplex::ProblemType LpSoplex::_getDualType() const {376 SoplexLp::ProblemType SoplexLp::_getDualType() const { 377 377 switch (soplex->status()) { 378 378 case soplex::SPxSolver::OPTIMAL: … … 387 387 } 388 388 389 void LpSoplex::_setSense(Sense sense) {389 void SoplexLp::_setSense(Sense sense) { 390 390 switch (sense) { 391 391 case MIN: … … 397 397 } 398 398 399 LpSoplex::Sense LpSoplex::_getSense() const {399 SoplexLp::Sense SoplexLp::_getSense() const { 400 400 switch (soplex->spxSense()) { 401 401 case soplex::SPxSolver::MAXIMIZE: … … 405 405 default: 406 406 LEMON_ASSERT(false, "Wrong sense."); 407 return LpSoplex::Sense();408 } 409 } 410 411 void LpSoplex::_clear() {407 return SoplexLp::Sense(); 408 } 409 } 410 411 void SoplexLp::_clear() { 412 412 soplex->clear(); 413 413 _col_names.clear(); -
lemon/soplex.h
r461 r462 44 44 /// Berlin (ZIB). You can find detailed information about it at the 45 45 /// <tt>http://soplex.zib.de</tt> address. 46 class LpSoplex: public LpSolver {46 class SoplexLp : public LpSolver { 47 47 private: 48 48 … … 69 69 70 70 /// \e 71 LpSoplex();71 SoplexLp(); 72 72 /// \e 73 LpSoplex(const LpSoplex&);73 SoplexLp(const SoplexLp&); 74 74 /// \e 75 ~ LpSoplex();75 ~SoplexLp(); 76 76 77 77 protected: 78 78 79 virtual LpSoplex* _newSolver() const;80 virtual LpSoplex* _cloneSolver() const;79 virtual SoplexLp* _newSolver() const; 80 virtual SoplexLp* _cloneSolver() const; 81 81 82 82 virtual const char* _solverName() const;
Note: See TracChangeset
for help on using the changeset viewer.