COIN-OR::LEMON - Graph Library

About

Downloads

Documentation

Development

Issue Tracker

Browse Tickets

Custom Query

Roadmap

Browse Source

Local Info

Mailing Lists

Search

Changes in / [578:a2e6b1dd487e:574:003367ffe66e] in lemon-main


Ignore:
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • lemon/cbc.cc

    r576 r567  
    5656    _osi_solver = 0;
    5757    _cbc_model = 0;
    58     messageLevel(MESSAGE_NOTHING);
    5958  }
    6059
    6160  CbcMip::CbcMip(const CbcMip& other) {
    6261    _prob = new CoinModel(*other._prob);
    63     _prob->setProblemName("LEMON");
    6462    _osi_solver = 0;
    6563    _cbc_model = 0;
    66     messageLevel(MESSAGE_NOTHING);
    6764  }
    6865
    … …  
    274271    _cbc_model= new CbcModel(*_osi_solver);
    275272
    276     _osi_solver->messageHandler()->setLogLevel(_message_level);
    277     _cbc_model->setLogLevel(_message_level);
     273    switch (_message_level) {
     274    case MESSAGE_NO_OUTPUT:
     275      _osi_solver->messageHandler()->setLogLevel(0);
     276      _cbc_model->setLogLevel(0);
     277      break;
     278    case MESSAGE_ERROR_MESSAGE:
     279      _osi_solver->messageHandler()->setLogLevel(1);
     280      _cbc_model->setLogLevel(1);
     281      break;
     282    case MESSAGE_NORMAL_OUTPUT:
     283      _osi_solver->messageHandler()->setLogLevel(2);
     284      _cbc_model->setLogLevel(2);
     285      break;
     286    case MESSAGE_FULL_OUTPUT:
     287      _osi_solver->messageHandler()->setLogLevel(3);
     288      _cbc_model->setLogLevel(3);
     289      break;
     290    }
    278291
    279292    _cbc_model->initialSolve();
    … …  
    441454  }
    442455
    443   void CbcMip::_messageLevel(MessageLevel level) {
    444     switch (level) {
    445     case MESSAGE_NOTHING:
    446       _message_level = 0;
    447       break;
    448     case MESSAGE_ERROR:
    449       _message_level = 1;
    450       break;
    451     case MESSAGE_WARNING:
    452       _message_level = 1;
    453       break;
    454     case MESSAGE_NORMAL:
    455       _message_level = 2;
    456       break;
    457     case MESSAGE_VERBOSE:
    458       _message_level = 3;
    459       break;
    460     }
     456  void CbcMip::messageLevel(MessageLevel m) {
     457    _message_level = m;
    461458  }
    462459

  • lemon/cbc.h

    r576 r567  
    116116    virtual void _clear();
    117117
    118     virtual void _messageLevel(MessageLevel level);
    119     void _applyMessageLevel();
     118  public:
    120119
    121     int _message_level;
     120    ///Enum for \c messageLevel() parameter
     121    enum MessageLevel {
     122      /// no output (default value)
     123      MESSAGE_NO_OUTPUT = 0,
     124      /// error messages only
     125      MESSAGE_ERROR_MESSAGE = 1,
     126      /// normal output
     127      MESSAGE_NORMAL_OUTPUT = 2,
     128      /// full output (includes informational messages)
     129      MESSAGE_FULL_OUTPUT = 3
     130    };
    122131
    123    
     132  private:
     133
     134    MessageLevel _message_level;
     135
     136  public:
     137
     138    ///Set the verbosity of the messages
     139
     140    ///Set the verbosity of the messages
     141    ///
     142    ///\param m is the level of the messages output by the solver routines.
     143    void messageLevel(MessageLevel m);
     144
    124145
    125146  };

  • lemon/clp.cc

    r576 r540  
    2525    _prob = new ClpSimplex();
    2626    _init_temporals();
    27     messageLevel(MESSAGE_NOTHING);
     27    messageLevel(MESSAGE_NO_OUTPUT);
    2828  }
    2929
    … …  
    3333    cols = other.cols;
    3434    _init_temporals();
    35     messageLevel(MESSAGE_NOTHING);
     35    messageLevel(MESSAGE_NO_OUTPUT);
    3636  }
    3737
    … …  
    431431  }
    432432
    433   void ClpLp::_messageLevel(MessageLevel level) {
    434     switch (level) {
    435     case MESSAGE_NOTHING:
    436       _prob->setLogLevel(0);
    437       break;
    438     case MESSAGE_ERROR:
    439       _prob->setLogLevel(1);
    440       break;
    441     case MESSAGE_WARNING:
    442       _prob->setLogLevel(2);
    443       break;
    444     case MESSAGE_NORMAL:
    445       _prob->setLogLevel(3);
    446       break;
    447     case MESSAGE_VERBOSE:
    448       _prob->setLogLevel(4);
    449       break;
    450     }
     433  void ClpLp::messageLevel(MessageLevel m) {
     434    _prob->setLogLevel(static_cast<int>(m));
    451435  }
    452436

  • lemon/clp.h

    r576 r540  
    137137    virtual void _clear();
    138138
    139     virtual void _messageLevel(MessageLevel);
    140    
    141139  public:
    142140
    … …  
    156154    int clpCol(Col c) const { return cols(id(c)); }
    157155
     156    ///Enum for \c messageLevel() parameter
     157    enum MessageLevel {
     158      /// no output (default value)
     159      MESSAGE_NO_OUTPUT = 0,
     160      /// print final solution
     161      MESSAGE_FINAL_SOLUTION = 1,
     162      /// print factorization
     163      MESSAGE_FACTORIZATION = 2,
     164      /// normal output
     165      MESSAGE_NORMAL_OUTPUT = 3,
     166      /// verbose output
     167      MESSAGE_VERBOSE_OUTPUT = 4
     168    };
     169    ///Set the verbosity of the messages
     170
     171    ///Set the verbosity of the messages
     172    ///
     173    ///\param m is the level of the messages output by the solver routines.
     174    void messageLevel(MessageLevel m);
     175
    158176  };
    159177

  • lemon/cplex.cc

    r576 r551  
    7373    int status;
    7474    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
    75     messageLevel(MESSAGE_NOTHING);
    7675  }
    7776
    … …  
    8079    int status;
    8180    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
    82     messageLevel(MESSAGE_NOTHING);
    8381  }
    8482
    … …  
    8987    rows = cplex.rows;
    9088    cols = cplex.cols;
    91     messageLevel(MESSAGE_NOTHING);
    9289  }
    9390
    … …  
    440437    rows.clear();
    441438    cols.clear();
    442   }
    443 
    444   void CplexBase::_messageLevel(MessageLevel level) {
    445     switch (level) {
    446     case MESSAGE_NOTHING:
    447       _message_enabled = false;
    448       break;
    449     case MESSAGE_ERROR:
    450     case MESSAGE_WARNING:
    451     case MESSAGE_NORMAL:
    452     case MESSAGE_VERBOSE:
    453       _message_enabled = true;
    454       break;
    455     }
    456   }
    457 
    458   void CplexBase::_applyMessageLevel() {
    459     CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
    460                    _message_enabled ? CPX_ON : CPX_OFF);
    461439  }
    462440
    … …  
    530508  CplexLp::SolveExitStatus CplexLp::_solve() {
    531509    _clear_temporals();
    532     _applyMessageLevel();
    533510    return convertStatus(CPXlpopt(cplexEnv(), _prob));
    534511  }
    … …  
    536513  CplexLp::SolveExitStatus CplexLp::solvePrimal() {
    537514    _clear_temporals();
    538     _applyMessageLevel();
    539515    return convertStatus(CPXprimopt(cplexEnv(), _prob));
    540516  }
    … …  
    542518  CplexLp::SolveExitStatus CplexLp::solveDual() {
    543519    _clear_temporals();
    544     _applyMessageLevel();
    545520    return convertStatus(CPXdualopt(cplexEnv(), _prob));
    546521  }
    … …  
    548523  CplexLp::SolveExitStatus CplexLp::solveBarrier() {
    549524    _clear_temporals();
    550     _applyMessageLevel();
    551525    return convertStatus(CPXbaropt(cplexEnv(), _prob));
    552526  }
    … …  
    627601  }
    628602
    629   // Cplex 7.0 status values
     603  //7.5-os cplex statusai (Vigyazat: a 9.0-asei masok!)
    630604  // This table lists the statuses, returned by the CPXgetstat()
    631605  // routine, for solutions to LP problems or mixed integer problems. If
    … …  
    674648  //       User pivot used
    675649  //
    676   // Pending return values
     650  //     Ezeket hova tegyem:
    677651  // ??case CPX_ABORT_DUAL_INFEAS
    678652  // ??case CPX_ABORT_CROSSOVER
    … …  
    745719    statusSwitch(cplexEnv(),stat);
    746720    //CPXgetstat(cplexEnv(), _prob);
     721    //printf("A primal status: %d, CPX_OPTIMAL=%d \n",stat,CPX_OPTIMAL);
    747722    switch (stat) {
    748723    case 0:
    … …  
    777752  }
    778753
    779   // Cplex 9.0 status values
     754  //9.0-as cplex verzio statusai
    780755  // CPX_STAT_ABORT_DUAL_OBJ_LIM
    781756  // CPX_STAT_ABORT_IT_LIM
    … …  
    890865  CplexMip::SolveExitStatus CplexMip::_solve() {
    891866    int status;
    892     _applyMessageLevel();
    893867    status = CPXmipopt (cplexEnv(), _prob);
    894868    if (status==0)

  • lemon/cplex.h

    r576 r551  
    145145    virtual void _clear();
    146146
    147     virtual void _messageLevel(MessageLevel level);
    148     void _applyMessageLevel();
    149 
    150     bool _message_enabled;
    151 
    152147  public:
    153148
    154149    /// Returns the used \c CplexEnv instance
    155150    const CplexEnv& env() const { return _env; }
    156 
    157     /// \brief Returns the const cpxenv pointer
    158151    ///
    159     /// \note The cpxenv might be destructed with the solver.
    160152    const cpxenv* cplexEnv() const { return _env.cplexEnv(); }
    161153
    162     /// \brief Returns the const cpxenv pointer
    163     ///
    164     /// \note The cpxenv might be destructed with the solver.
    165     cpxenv* cplexEnv() { return _env.cplexEnv(); }
    166 
    167     /// Returns the cplex problem object
    168154    cpxlp* cplexLp() { return _prob; }
    169     /// Returns the cplex problem object
    170155    const cpxlp* cplexLp() const { return _prob; }
    171156

  • lemon/glpk.cc

    r576 r566  
    3232    lp = glp_create_prob();
    3333    glp_create_index(lp);
    34     messageLevel(MESSAGE_NOTHING);
    3534  }
    3635
    … …  
    4140    rows = other.rows;
    4241    cols = other.cols;
    43     messageLevel(MESSAGE_NOTHING);
    4442  }
    4543
    … …  
    529527  }
    530528
    531   void GlpkBase::_messageLevel(MessageLevel level) {
    532     switch (level) {
    533     case MESSAGE_NOTHING:
    534       _message_level = GLP_MSG_OFF;
    535       break;
    536     case MESSAGE_ERROR:
    537       _message_level = GLP_MSG_ERR;
    538       break;
    539     case MESSAGE_WARNING:
    540       _message_level = GLP_MSG_ERR;
    541       break;
    542     case MESSAGE_NORMAL:
    543       _message_level = GLP_MSG_ON;
    544       break;
    545     case MESSAGE_VERBOSE:
    546       _message_level = GLP_MSG_ALL;
    547       break;
    548     }
    549   }
    550 
    551529  GlpkBase::FreeEnvHelper GlpkBase::freeEnvHelper;
    552530
    … …  
    555533  GlpkLp::GlpkLp()
    556534    : LpBase(), LpSolver(), GlpkBase() {
     535    messageLevel(MESSAGE_NO_OUTPUT);
    557536    presolver(false);
    558537  }
    … …  
    560539  GlpkLp::GlpkLp(const GlpkLp& other)
    561540    : LpBase(other), LpSolver(other), GlpkBase(other) {
     541    messageLevel(MESSAGE_NO_OUTPUT);
    562542    presolver(false);
    563543  }
    … …  
    583563    glp_init_smcp(&smcp);
    584564
    585     smcp.msg_lev = _message_level;
     565    switch (_message_level) {
     566    case MESSAGE_NO_OUTPUT:
     567      smcp.msg_lev = GLP_MSG_OFF;
     568      break;
     569    case MESSAGE_ERROR_MESSAGE:
     570      smcp.msg_lev = GLP_MSG_ERR;
     571      break;
     572    case MESSAGE_NORMAL_OUTPUT:
     573      smcp.msg_lev = GLP_MSG_ON;
     574      break;
     575    case MESSAGE_FULL_OUTPUT:
     576      smcp.msg_lev = GLP_MSG_ALL;
     577      break;
     578    }
    586579    smcp.presolve = _presolve;
    587580
    … …  
    612605    glp_init_smcp(&smcp);
    613606
    614     smcp.msg_lev = _message_level;
     607    switch (_message_level) {
     608    case MESSAGE_NO_OUTPUT:
     609      smcp.msg_lev = GLP_MSG_OFF;
     610      break;
     611    case MESSAGE_ERROR_MESSAGE:
     612      smcp.msg_lev = GLP_MSG_ERR;
     613      break;
     614    case MESSAGE_NORMAL_OUTPUT:
     615      smcp.msg_lev = GLP_MSG_ON;
     616      break;
     617    case MESSAGE_FULL_OUTPUT:
     618      smcp.msg_lev = GLP_MSG_ALL;
     619      break;
     620    }
    615621    smcp.meth = GLP_DUAL;
    616622    smcp.presolve = _presolve;
    … …  
    853859  }
    854860
     861  void GlpkLp::messageLevel(MessageLevel m) {
     862    _message_level = m;
     863  }
     864
    855865  // GlpkMip members
    856866
    857867  GlpkMip::GlpkMip()
    858868    : LpBase(), MipSolver(), GlpkBase() {
     869    messageLevel(MESSAGE_NO_OUTPUT);
    859870  }
    860871
    861872  GlpkMip::GlpkMip(const GlpkMip& other)
    862873    : LpBase(), MipSolver(), GlpkBase(other) {
     874    messageLevel(MESSAGE_NO_OUTPUT);
    863875  }
    864876
    … …  
    889901    glp_init_smcp(&smcp);
    890902
    891     smcp.msg_lev = _message_level;
     903    switch (_message_level) {
     904    case MESSAGE_NO_OUTPUT:
     905      smcp.msg_lev = GLP_MSG_OFF;
     906      break;
     907    case MESSAGE_ERROR_MESSAGE:
     908      smcp.msg_lev = GLP_MSG_ERR;
     909      break;
     910    case MESSAGE_NORMAL_OUTPUT:
     911      smcp.msg_lev = GLP_MSG_ON;
     912      break;
     913    case MESSAGE_FULL_OUTPUT:
     914      smcp.msg_lev = GLP_MSG_ALL;
     915      break;
     916    }
    892917    smcp.meth = GLP_DUAL;
    893918
    … …  
    914939    glp_init_iocp(&iocp);
    915940
    916     iocp.msg_lev = _message_level;
     941    switch (_message_level) {
     942    case MESSAGE_NO_OUTPUT:
     943      iocp.msg_lev = GLP_MSG_OFF;
     944      break;
     945    case MESSAGE_ERROR_MESSAGE:
     946      iocp.msg_lev = GLP_MSG_ERR;
     947      break;
     948    case MESSAGE_NORMAL_OUTPUT:
     949      iocp.msg_lev = GLP_MSG_ON;
     950      break;
     951    case MESSAGE_FULL_OUTPUT:
     952      iocp.msg_lev = GLP_MSG_ALL;
     953      break;
     954    }
    917955
    918956    if (glp_intopt(lp, &iocp) != 0) return UNSOLVED;
    … …  
    9651003  const char* GlpkMip::_solverName() const { return "GlpkMip"; }
    9661004
     1005  void GlpkMip::messageLevel(MessageLevel m) {
     1006    _message_level = m;
     1007  }
     1008
    9671009} //END OF NAMESPACE LEMON

  • lemon/glpk.h

    r576 r565  
    100100
    101101    virtual void _clear();
    102 
    103     virtual void _messageLevel(MessageLevel level);
    104102
    105103  private:
    … …  
    114112   
    115113    static FreeEnvHelper freeEnvHelper;
    116 
    117   protected:
    118    
    119     int _message_level;
    120114   
    121115  public:
    … …  
    198192    void presolver(bool presolve);
    199193
     194    ///Enum for \c messageLevel() parameter
     195    enum MessageLevel {
     196      /// no output (default value)
     197      MESSAGE_NO_OUTPUT = 0,
     198      /// error messages only
     199      MESSAGE_ERROR_MESSAGE = 1,
     200      /// normal output
     201      MESSAGE_NORMAL_OUTPUT = 2,
     202      /// full output (includes informational messages)
     203      MESSAGE_FULL_OUTPUT = 3
     204    };
     205
     206  private:
     207
     208    MessageLevel _message_level;
     209
     210  public:
     211
     212    ///Set the verbosity of the messages
     213
     214    ///Set the verbosity of the messages
     215    ///
     216    ///\param m is the level of the messages output by the solver routines.
     217    void messageLevel(MessageLevel m);
    200218  };
    201219
    … …  
    227245    virtual Value _getSolValue() const;
    228246
     247    ///Enum for \c messageLevel() parameter
     248    enum MessageLevel {
     249      /// no output (default value)
     250      MESSAGE_NO_OUTPUT = 0,
     251      /// error messages only
     252      MESSAGE_ERROR_MESSAGE = 1,
     253      /// normal output
     254      MESSAGE_NORMAL_OUTPUT = 2,
     255      /// full output (includes informational messages)
     256      MESSAGE_FULL_OUTPUT = 3
     257    };
     258
     259  private:
     260
     261    MessageLevel _message_level;
     262
     263  public:
     264
     265    ///Set the verbosity of the messages
     266
     267    ///Set the verbosity of the messages
     268    ///
     269    ///\param m is the level of the messages output by the solver routines.
     270    void messageLevel(MessageLevel m);
    229271  };
    230272

  • lemon/lp_base.h

    r576 r540  
    6969      MAX
    7070    };
    71 
    72     ///Enum for \c messageLevel() parameter
    73     enum MessageLevel {
    74       /// no output (default value)
    75       MESSAGE_NOTHING,
    76       /// error messages only
    77       MESSAGE_ERROR,
    78       /// warnings
    79       MESSAGE_WARNING,
    80       /// normal output
    81       MESSAGE_NORMAL,
    82       /// verbose output
    83       MESSAGE_VERBOSE
    84     };
    85    
    8671
    8772    ///The floating point type used by the solver
    … …  
    989974    virtual const char* _solverName() const = 0;
    990975
    991     virtual void _messageLevel(MessageLevel level) = 0;
    992 
    993976    //Own protected stuff
    994977
    … …  
    15451528    void clear() { _clear(); }
    15461529
    1547     /// Sets the message level of the solver
    1548     void messageLevel(MessageLevel level) { _messageLevel(level); }
    1549 
    15501530    ///@}
    15511531

  • lemon/lp_skeleton.cc

    r576 r540  
    8585  }
    8686
    87   void SkeletonSolverBase::_messageLevel(MessageLevel) {}
    88 
    8987  LpSkeleton::SolveExitStatus LpSkeleton::_solve() { return SOLVED; }
    9088

  • lemon/lp_skeleton.h

    r576 r541  
    141141    virtual void _clear();
    142142
    143     ///\e
    144     virtual void _messageLevel(MessageLevel);
    145143  };
    146144

  • lemon/soplex.cc

    r576 r540  
    2121
    2222#include <soplex.h>
    23 #include <spxout.h>
    2423
    2524
    … …  
    3029  SoplexLp::SoplexLp() {
    3130    soplex = new soplex::SoPlex;
    32     messageLevel(MESSAGE_NOTHING);
    3331  }
    3432
    … …  
    5048    _row_names_ref = lp._row_names_ref;
    5149
    52     messageLevel(MESSAGE_NOTHING);
    5350  }
    5451
    … …  
    275272
    276273    _clear_temporals();
    277    
    278     _applyMessageLevel();
    279274
    280275    soplex::SPxSolver::Status status = soplex->solve();
    … …  
    425420  }
    426421
    427   void SoplexLp::_messageLevel(MessageLevel level) {
    428     switch (level) {
    429     case MESSAGE_NOTHING:
    430       _message_level = -1;
    431       break;
    432     case MESSAGE_ERROR:
    433       _message_level = soplex::SPxOut::ERROR;
    434       break;
    435     case MESSAGE_WARNING:
    436       _message_level = soplex::SPxOut::WARNING;
    437       break;
    438     case MESSAGE_NORMAL:
    439       _message_level = soplex::SPxOut::INFO2;
    440       break;
    441     case MESSAGE_VERBOSE:
    442       _message_level = soplex::SPxOut::DEBUG;
    443       break;
    444     }
    445   }
    446 
    447   void SoplexLp::_applyMessageLevel() {
    448     soplex::Param::setVerbose(_message_level);
    449   }
    450 
    451422} //namespace lemon
    452423

  • lemon/soplex.h

    r576 r540  
    145145    virtual void _clear();
    146146
    147     void _messageLevel(MessageLevel m);
    148     void _applyMessageLevel();
    149 
    150     int _message_level;
    151 
    152147  };
    153148

  • test/lp_test.cc

    r575 r551  
    396396    cloneTest<CplexLp>();
    397397  } catch (CplexEnv::LicenseError& error) {
     398#ifdef LEMON_FORCE_CPLEX_CHECK
    398399    check(false, error.what());
     400#else
     401    std::cerr << error.what() << std::endl;
     402    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;
     403#endif
    399404  }
    400405#endif

  • test/mip_test.cc

    r575 r567  
    144144    cloneTest<CplexMip>();
    145145  } catch (CplexEnv::LicenseError& error) {
     146#ifdef LEMON_FORCE_CPLEX_CHECK
    146147    check(false, error.what());
     148#else
     149    std::cerr << error.what() << std::endl;
     150    std::cerr << "Cplex license check failed, lp check skipped" << std::endl;
     151#endif
    147152  }
    148153#endif
Note: See TracChangeset for help on using the changeset viewer.