lemon/glpk.cc
changeset 565 7ab97e2a0c33
parent 551 9d0d7e20f76d
child 566 e7017ec2d5cd
equal deleted inserted replaced
6:66c7f843b7e1 7:d654163c3b5e
   531   // GlpkLp members
   531   // GlpkLp members
   532 
   532 
   533   GlpkLp::GlpkLp()
   533   GlpkLp::GlpkLp()
   534     : LpBase(), LpSolver(), GlpkBase() {
   534     : LpBase(), LpSolver(), GlpkBase() {
   535     messageLevel(MESSAGE_NO_OUTPUT);
   535     messageLevel(MESSAGE_NO_OUTPUT);
       
   536     presolver(false);
   536   }
   537   }
   537 
   538 
   538   GlpkLp::GlpkLp(const GlpkLp& other)
   539   GlpkLp::GlpkLp(const GlpkLp& other)
   539     : LpBase(other), LpSolver(other), GlpkBase(other) {
   540     : LpBase(other), LpSolver(other), GlpkBase(other) {
   540     messageLevel(MESSAGE_NO_OUTPUT);
   541     messageLevel(MESSAGE_NO_OUTPUT);
       
   542     presolver(false);
   541   }
   543   }
   542 
   544 
   543   GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; }
   545   GlpkLp* GlpkLp::newSolver() const { return new GlpkLp; }
   544   GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); }
   546   GlpkLp* GlpkLp::cloneSolver() const { return new GlpkLp(*this); }
   545 
   547 
   572       break;
   574       break;
   573     case MESSAGE_FULL_OUTPUT:
   575     case MESSAGE_FULL_OUTPUT:
   574       smcp.msg_lev = GLP_MSG_ALL;
   576       smcp.msg_lev = GLP_MSG_ALL;
   575       break;
   577       break;
   576     }
   578     }
   577 
   579     smcp.presolve = _presolve;
   578     if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
   580 
       
   581     // If the basis is not valid we get an error return value.
       
   582     // In this case we can try to create a new basis.
       
   583     switch (glp_simplex(lp, &smcp)) {
       
   584     case 0:
       
   585       break;
       
   586     case GLP_EBADB:
       
   587     case GLP_ESING:
       
   588     case GLP_ECOND:
       
   589       lpx_set_int_parm(lp, LPX_K_MSGLEV, smcp.msg_lev);
       
   590       glp_adv_basis(lp, 0);
       
   591       if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
       
   592       break;
       
   593     default:
       
   594       return UNSOLVED;
       
   595     }
       
   596 
   579     return SOLVED;
   597     return SOLVED;
   580   }
   598   }
   581 
   599 
   582   GlpkLp::SolveExitStatus GlpkLp::solveDual() {
   600   GlpkLp::SolveExitStatus GlpkLp::solveDual() {
   583     _clear_temporals();
   601     _clear_temporals();
   598     case MESSAGE_FULL_OUTPUT:
   616     case MESSAGE_FULL_OUTPUT:
   599       smcp.msg_lev = GLP_MSG_ALL;
   617       smcp.msg_lev = GLP_MSG_ALL;
   600       break;
   618       break;
   601     }
   619     }
   602     smcp.meth = GLP_DUAL;
   620     smcp.meth = GLP_DUAL;
   603 
   621     smcp.presolve = _presolve;
   604     if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
   622 
       
   623     // If the basis is not valid we get an error return value.
       
   624     // In this case we can try to create a new basis.
       
   625     switch (glp_simplex(lp, &smcp)) {
       
   626     case 0:
       
   627       break;
       
   628     case GLP_EBADB:
       
   629     case GLP_ESING:
       
   630     case GLP_ECOND:
       
   631       lpx_set_int_parm(lp, LPX_K_MSGLEV, smcp.msg_lev);
       
   632       glp_adv_basis(lp, 0);
       
   633       if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
       
   634       break;
       
   635     default:
       
   636       return UNSOLVED;
       
   637     }
   605     return SOLVED;
   638     return SOLVED;
   606   }
   639   }
   607 
   640 
   608   GlpkLp::Value GlpkLp::_getPrimal(int i) const {
   641   GlpkLp::Value GlpkLp::_getPrimal(int i) const {
   609     return glp_get_col_prim(lp, i);
   642     return glp_get_col_prim(lp, i);
   817       LEMON_ASSERT(false, "Wrong primal type");
   850       LEMON_ASSERT(false, "Wrong primal type");
   818       return  GlpkLp::ProblemType();
   851       return  GlpkLp::ProblemType();
   819     }
   852     }
   820   }
   853   }
   821 
   854 
   822   void GlpkLp::presolver(bool b) {
   855   void GlpkLp::presolver(bool presolve) {
   823     lpx_set_int_parm(lp, LPX_K_PRESOL, b ? 1 : 0);
   856     _presolve = presolve;
   824   }
   857   }
   825 
   858 
   826   void GlpkLp::messageLevel(MessageLevel m) {
   859   void GlpkLp::messageLevel(MessageLevel m) {
   827     _message_level = m;
   860     _message_level = m;
   828   }
   861   }
   879       smcp.msg_lev = GLP_MSG_ALL;
   912       smcp.msg_lev = GLP_MSG_ALL;
   880       break;
   913       break;
   881     }
   914     }
   882     smcp.meth = GLP_DUAL;
   915     smcp.meth = GLP_DUAL;
   883 
   916 
   884     if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
   917     // If the basis is not valid we get an error return value.
       
   918     // In this case we can try to create a new basis.
       
   919     switch (glp_simplex(lp, &smcp)) {
       
   920     case 0:
       
   921       break;
       
   922     case GLP_EBADB:
       
   923     case GLP_ESING:
       
   924     case GLP_ECOND:
       
   925       lpx_set_int_parm(lp, LPX_K_MSGLEV, smcp.msg_lev);
       
   926       glp_adv_basis(lp, 0);
       
   927       if (glp_simplex(lp, &smcp) != 0) return UNSOLVED;
       
   928       break;
       
   929     default:
       
   930       return UNSOLVED;
       
   931     }
       
   932 
   885     if (glp_get_status(lp) != GLP_OPT) return SOLVED;
   933     if (glp_get_status(lp) != GLP_OPT) return SOLVED;
   886 
   934 
   887     glp_iocp iocp;
   935     glp_iocp iocp;
   888     glp_init_iocp(&iocp);
   936     glp_init_iocp(&iocp);
   889 
   937