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 / [574:003367ffe66e:578:a2e6b1dd487e] in lemon-main


Ignore:
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • lemon/cbc.cc

    r567 r576  
    5656    _osi_solver = 0;
    5757    _cbc_model = 0;
     58    messageLevel(MESSAGE_NOTHING);
    5859  }
    5960
    6061  CbcMip::CbcMip(const CbcMip& other) {
    6162    _prob = new CoinModel(*other._prob);
     63    _prob->setProblemName("LEMON");
    6264    _osi_solver = 0;
    6365    _cbc_model = 0;
     66    messageLevel(MESSAGE_NOTHING);
    6467  }
    6568
    … …  
    271274    _cbc_model= new CbcModel(*_osi_solver);
    272275
    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     }
     276    _osi_solver->messageHandler()->setLogLevel(_message_level);
     277    _cbc_model->setLogLevel(_message_level);
    291278
    292279    _cbc_model->initialSolve();
    … …  
    454441  }
    455442
    456   void CbcMip::messageLevel(MessageLevel m) {
    457     _message_level = m;
     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    }
    458461  }
    459462

  • lemon/cbc.h

    r567 r576  
    116116    virtual void _clear();
    117117
    118   public:
     118    virtual void _messageLevel(MessageLevel level);
     119    void _applyMessageLevel();
    119120
    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     };
     121    int _message_level;
    131122
    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 
     123   
    145124
    146125  };

  • lemon/clp.cc

    r540 r576  
    2525    _prob = new ClpSimplex();
    2626    _init_temporals();
    27     messageLevel(MESSAGE_NO_OUTPUT);
     27    messageLevel(MESSAGE_NOTHING);
    2828  }
    2929
    … …  
    3333    cols = other.cols;
    3434    _init_temporals();
    35     messageLevel(MESSAGE_NO_OUTPUT);
     35    messageLevel(MESSAGE_NOTHING);
    3636  }
    3737
    … …  
    431431  }
    432432
    433   void ClpLp::messageLevel(MessageLevel m) {
    434     _prob->setLogLevel(static_cast<int>(m));
     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    }
    435451  }
    436452

  • lemon/clp.h

    r540 r576  
    137137    virtual void _clear();
    138138
     139    virtual void _messageLevel(MessageLevel);
     140   
    139141  public:
    140142
    … …  
    154156    int clpCol(Col c) const { return cols(id(c)); }
    155157
    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 
    176158  };
    177159

  • lemon/cplex.cc

    r551 r576  
    7373    int status;
    7474    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
     75    messageLevel(MESSAGE_NOTHING);
    7576  }
    7677
    … …  
    7980    int status;
    8081    _prob = CPXcreateprob(cplexEnv(), &status, "Cplex problem");
     82    messageLevel(MESSAGE_NOTHING);
    8183  }
    8284
    … …  
    8789    rows = cplex.rows;
    8890    cols = cplex.cols;
     91    messageLevel(MESSAGE_NOTHING);
    8992  }
    9093
    … …  
    437440    rows.clear();
    438441    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);
    439461  }
    440462
    … …  
    508530  CplexLp::SolveExitStatus CplexLp::_solve() {
    509531    _clear_temporals();
     532    _applyMessageLevel();
    510533    return convertStatus(CPXlpopt(cplexEnv(), _prob));
    511534  }
    … …  
    513536  CplexLp::SolveExitStatus CplexLp::solvePrimal() {
    514537    _clear_temporals();
     538    _applyMessageLevel();
    515539    return convertStatus(CPXprimopt(cplexEnv(), _prob));
    516540  }
    … …  
    518542  CplexLp::SolveExitStatus CplexLp::solveDual() {
    519543    _clear_temporals();
     544    _applyMessageLevel();
    520545    return convertStatus(CPXdualopt(cplexEnv(), _prob));
    521546  }
    … …  
    523548  CplexLp::SolveExitStatus CplexLp::solveBarrier() {
    524549    _clear_temporals();
     550    _applyMessageLevel();
    525551    return convertStatus(CPXbaropt(cplexEnv(), _prob));
    526552  }
    … …  
    601627  }
    602628
    603   //7.5-os cplex statusai (Vigyazat: a 9.0-asei masok!)
     629  // Cplex 7.0 status values
    604630  // This table lists the statuses, returned by the CPXgetstat()
    605631  // routine, for solutions to LP problems or mixed integer problems. If
    … …  
    648674  //       User pivot used
    649675  //
    650   //     Ezeket hova tegyem:
     676  // Pending return values
    651677  // ??case CPX_ABORT_DUAL_INFEAS
    652678  // ??case CPX_ABORT_CROSSOVER
    … …  
    719745    statusSwitch(cplexEnv(),stat);
    720746    //CPXgetstat(cplexEnv(), _prob);
    721     //printf("A primal status: %d, CPX_OPTIMAL=%d \n",stat,CPX_OPTIMAL);
    722747    switch (stat) {
    723748    case 0:
    … …  
    752777  }
    753778
    754   //9.0-as cplex verzio statusai
     779  // Cplex 9.0 status values
    755780  // CPX_STAT_ABORT_DUAL_OBJ_LIM
    756781  // CPX_STAT_ABORT_IT_LIM
    … …  
    865890  CplexMip::SolveExitStatus CplexMip::_solve() {
    866891    int status;
     892    _applyMessageLevel();
    867893    status = CPXmipopt (cplexEnv(), _prob);
    868894    if (status==0)

  • lemon/cplex.h

    r551 r576  
    145145    virtual void _clear();
    146146
     147    virtual void _messageLevel(MessageLevel level);
     148    void _applyMessageLevel();
     149
     150    bool _message_enabled;
     151
    147152  public:
    148153
    149154    /// Returns the used \c CplexEnv instance
    150155    const CplexEnv& env() const { return _env; }
     156
     157    /// \brief Returns the const cpxenv pointer
    151158    ///
     159    /// \note The cpxenv might be destructed with the solver.
    152160    const cpxenv* cplexEnv() const { return _env.cplexEnv(); }
    153161
     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
    154168    cpxlp* cplexLp() { return _prob; }
     169    /// Returns the cplex problem object
    155170    const cpxlp* cplexLp() const { return _prob; }
    156171

  • lemon/glpk.cc

    r566 r576  
    3232    lp = glp_create_prob();
    3333    glp_create_index(lp);
     34    messageLevel(MESSAGE_NOTHING);
    3435  }
    3536
    … …  
    4041    rows = other.rows;
    4142    cols = other.cols;
     43    messageLevel(MESSAGE_NOTHING);
    4244  }
    4345
    … …  
    527529  }
    528530
     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
    529551  GlpkBase::FreeEnvHelper GlpkBase::freeEnvHelper;
    530552
    … …  
    533555  GlpkLp::GlpkLp()
    534556    : LpBase(), LpSolver(), GlpkBase() {
    535     messageLevel(MESSAGE_NO_OUTPUT);
    536557    presolver(false);
    537558  }
    … …  
    539560  GlpkLp::GlpkLp(const GlpkLp& other)
    540561    : LpBase(other), LpSolver(other), GlpkBase(other) {
    541     messageLevel(MESSAGE_NO_OUTPUT);
    542562    presolver(false);
    543563  }
    … …  
    563583    glp_init_smcp(&smcp);
    564584
    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     }
     585    smcp.msg_lev = _message_level;
    579586    smcp.presolve = _presolve;
    580587
    … …  
    605612    glp_init_smcp(&smcp);
    606613
    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     }
     614    smcp.msg_lev = _message_level;
    621615    smcp.meth = GLP_DUAL;
    622616    smcp.presolve = _presolve;
    … …  
    859853  }
    860854
    861   void GlpkLp::messageLevel(MessageLevel m) {
    862     _message_level = m;
    863   }
    864 
    865855  // GlpkMip members
    866856
    867857  GlpkMip::GlpkMip()
    868858    : LpBase(), MipSolver(), GlpkBase() {
    869     messageLevel(MESSAGE_NO_OUTPUT);
    870859  }
    871860
    872861  GlpkMip::GlpkMip(const GlpkMip& other)
    873862    : LpBase(), MipSolver(), GlpkBase(other) {
    874     messageLevel(MESSAGE_NO_OUTPUT);
    875863  }
    876864
    … …  
    901889    glp_init_smcp(&smcp);
    902890
    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     }
     891    smcp.msg_lev = _message_level;
    917892    smcp.meth = GLP_DUAL;
    918893
    … …  
    939914    glp_init_iocp(&iocp);
    940915
    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     }
     916    iocp.msg_lev = _message_level;
    955917
    956918    if (glp_intopt(lp, &iocp) != 0) return UNSOLVED;
    … …  
    1003965  const char* GlpkMip::_solverName() const { return "GlpkMip"; }
    1004966
    1005   void GlpkMip::messageLevel(MessageLevel m) {
    1006     _message_level = m;
    1007   }
    1008 
    1009967} //END OF NAMESPACE LEMON

  • lemon/glpk.h

    r565 r576  
    100100
    101101    virtual void _clear();
     102
     103    virtual void _messageLevel(MessageLevel level);
    102104
    103105  private:
    … …  
    112114   
    113115    static FreeEnvHelper freeEnvHelper;
     116
     117  protected:
     118   
     119    int _message_level;
    114120   
    115121  public:
    … …  
    192198    void presolver(bool presolve);
    193199
    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);
    218200  };
    219201
    … …  
    245227    virtual Value _getSolValue() const;
    246228
    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);
    271229  };
    272230

  • lemon/lp_base.h

    r540 r576  
    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   
    7186
    7287    ///The floating point type used by the solver
    … …  
    974989    virtual const char* _solverName() const = 0;
    975990
     991    virtual void _messageLevel(MessageLevel level) = 0;
     992
    976993    //Own protected stuff
    977994
    … …  
    15281545    void clear() { _clear(); }
    15291546
     1547    /// Sets the message level of the solver
     1548    void messageLevel(MessageLevel level) { _messageLevel(level); }
     1549
    15301550    ///@}
    15311551

  • lemon/lp_skeleton.cc

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

  • lemon/lp_skeleton.h

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

  • lemon/soplex.cc

    r540 r576  
    2121
    2222#include <soplex.h>
     23#include <spxout.h>
    2324
    2425
    … …  
    2930  SoplexLp::SoplexLp() {
    3031    soplex = new soplex::SoPlex;
     32    messageLevel(MESSAGE_NOTHING);
    3133  }
    3234
    … …  
    4850    _row_names_ref = lp._row_names_ref;
    4951
     52    messageLevel(MESSAGE_NOTHING);
    5053  }
    5154
    … …  
    272275
    273276    _clear_temporals();
     277   
     278    _applyMessageLevel();
    274279
    275280    soplex::SPxSolver::Status status = soplex->solve();
    … …  
    420425  }
    421426
     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
    422451} //namespace lemon
    423452

  • lemon/soplex.h

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

  • test/lp_test.cc

    r551 r575  
    396396    cloneTest<CplexLp>();
    397397  } catch (CplexEnv::LicenseError& error) {
    398 #ifdef LEMON_FORCE_CPLEX_CHECK
    399398    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
    404399  }
    405400#endif

  • test/mip_test.cc

    r567 r575  
    144144    cloneTest<CplexMip>();
    145145  } catch (CplexEnv::LicenseError& error) {
    146 #ifdef LEMON_FORCE_CPLEX_CHECK
    147146    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
    152147  }
    153148#endif
Note: See TracChangeset for help on using the changeset viewer.