COIN-OR::LEMON - Graph Library

Changeset 2366:bfbdded3763a in lemon-0.x


Ignore:
Timestamp:
02/16/07 20:11:31 (12 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3181
Message:

Using const in lp interface
colByName functionality

Location:
lemon
Files:
13 edited

Legend:

Unmodified
Added
Removed
  • lemon/lp_base.h

    r2364 r2366  
    136136
    137137    class ColIt : public Col {
    138       LpSolverBase *_lp;
     138      const LpSolverBase *_lp;
    139139    public:
    140140      ColIt() {}
    141       ColIt(LpSolverBase &lp) : _lp(&lp)
     141      ColIt(const LpSolverBase &lp) : _lp(&lp)
    142142      {
    143143        _lp->cols.firstFix(id);
     
    181181
    182182    class RowIt : public Row {
    183       LpSolverBase *_lp;
     183      const LpSolverBase *_lp;
    184184    public:
    185185      RowIt() {}
    186       RowIt(LpSolverBase &lp) : _lp(&lp)
     186      RowIt(const LpSolverBase &lp) : _lp(&lp)
    187187      {
    188188        _lp->rows.firstFix(id);
     
    736736    virtual int _addCol() = 0;
    737737    virtual int _addRow() = 0;
     738
    738739    virtual void _eraseCol(int col) = 0;
    739740    virtual void _eraseRow(int row) = 0;
    740     virtual void _getColName(int col, std::string & name) = 0;
     741
     742    virtual void _getColName(int col, std::string & name) const = 0;
    741743    virtual void _setColName(int col, const std::string & name) = 0;
     744    virtual int _colByName(const std::string& name) const = 0;
     745
    742746    virtual void _setRowCoeffs(int i, ConstRowIterator b,
    743747                               ConstRowIterator e) = 0;
    744     virtual void _getRowCoeffs(int i, RowIterator b) = 0;
     748    virtual void _getRowCoeffs(int i, RowIterator b) const = 0;
    745749    virtual void _setColCoeffs(int i, ConstColIterator b,
    746750                               ConstColIterator e) = 0;
    747     virtual void _getColCoeffs(int i, ColIterator b) = 0;
     751    virtual void _getColCoeffs(int i, ColIterator b) const = 0;
    748752    virtual void _setCoeff(int row, int col, Value value) = 0;
    749     virtual Value _getCoeff(int row, int col) = 0;
     753    virtual Value _getCoeff(int row, int col) const = 0;
    750754    virtual void _setColLowerBound(int i, Value value) = 0;
    751     virtual Value _getColLowerBound(int i) = 0;
     755    virtual Value _getColLowerBound(int i) const = 0;
    752756    virtual void _setColUpperBound(int i, Value value) = 0;
    753     virtual Value _getColUpperBound(int i) = 0;
     757    virtual Value _getColUpperBound(int i) const = 0;
    754758    virtual void _setRowBounds(int i, Value lower, Value upper) = 0;
    755     virtual void _getRowBounds(int i, Value &lower, Value &upper)=0;
     759    virtual void _getRowBounds(int i, Value &lower, Value &upper) const = 0;
    756760
    757761    virtual void _setObjCoeff(int i, Value obj_coef) = 0;
    758     virtual Value _getObjCoeff(int i) = 0;
     762    virtual Value _getObjCoeff(int i) const = 0;
    759763    virtual void _clearObj()=0;
    760764
    761765    virtual SolveExitStatus _solve() = 0;
    762     virtual Value _getPrimal(int i) = 0;
    763     virtual Value _getDual(int i) = 0;
    764     virtual Value _getPrimalValue() = 0;
    765     virtual bool _isBasicCol(int i) = 0;
    766     virtual SolutionStatus _getPrimalStatus() = 0;
    767     virtual SolutionStatus _getDualStatus() = 0;
    768     ///\todo This could be implemented here, too, using _getPrimalStatus() and
    769     ///_getDualStatus()
    770     virtual ProblemTypes _getProblemType() = 0;
     766    virtual Value _getPrimal(int i) const = 0;
     767    virtual Value _getDual(int i) const = 0;
     768    virtual Value _getPrimalValue() const = 0;
     769    virtual bool _isBasicCol(int i) const = 0;
     770    virtual SolutionStatus _getPrimalStatus() const = 0;
     771    virtual SolutionStatus _getDualStatus() const = 0;
     772    virtual ProblemTypes _getProblemType() const = 0;
    771773
    772774    virtual void _setMax() = 0;
     
    774776   
    775777
    776     virtual bool _isMax() = 0;
     778    virtual bool _isMax() const = 0;
    777779
    778780    //Own protected stuff
     
    878880    ///\param r is the column to get
    879881    ///\return the dual expression associated to the column
    880     DualExpr col(Col c) {
     882    DualExpr col(Col c) const {
    881883      DualExpr e;
    882884      _getColCoeffs(_lpId(c), ColIterator(std::inserter(e, e.end()), *this));
     
    975977    ///\todo Option to control whether a constraint with a single variable is
    976978    ///added or not.
    977     void row(Row r, Value l,const Expr &e, Value u) {
     979    void row(Row r, Value l, const Expr &e, Value u) {
    978980      e.simplify();
    979981      _setRowCoeffs(_lpId(r), ConstRowIterator(e.begin(), *this),
     
    996998    ///\param r is the row to get
    997999    ///\return the expression associated to the row
    998     Expr row(Row r) {
     1000    Expr row(Row r) const {
    9991001      Expr e;
    10001002      _getRowCoeffs(_lpId(r), RowIterator(std::inserter(e, e.end()), *this));
     
    10461048    ///\param c is the coresponding coloumn
    10471049    ///\return The name of the colunm
    1048     std::string colName(Col c){
     1050    std::string colName(Col c) const {
    10491051      std::string name;
    10501052      _getColName(_lpId(c), name);
     
    10561058    ///\param c is the coresponding coloumn
    10571059    ///\param name The name to be given
    1058     void colName(Col c, const std::string& name){
     1060    void colName(Col c, const std::string& name) {
    10591061      _setColName(_lpId(c), name);
    10601062    }
     
    10661068    ///\param val is the new value of the coefficient
    10671069
    1068     void coeff(Row r, Col c, Value val){
     1070    void coeff(Row r, Col c, Value val) {
    10691071      _setCoeff(_lpId(r),_lpId(c), val);
    10701072    }
     
    10761078    ///\return the corresponding coefficient
    10771079
    1078     Value coeff(Row r, Col c){
     1080    Value coeff(Row r, Col c) const {
    10791081      return _getCoeff(_lpId(r),_lpId(c));
    10801082    }
     
    10941096    /// (this might be -\ref INF as well). 
    10951097    ///\return The lower bound for coloumn \t c
    1096     Value colLowerBound(Col c) {
     1098    Value colLowerBound(Col c) const {
    10971099      return _getColLowerBound(_lpId(c));
    10981100    }
     
    11491151    /// (this might be \ref INF as well). 
    11501152    ///\return The upper bound for coloumn \t c
    1151     Value colUpperBound(Col c) {
     1153    Value colUpperBound(Col c) const {
    11521154      return _getColUpperBound(_lpId(c));
    11531155    }
     
    12611263    /// implementation of the setting functions for CPLEX: 
    12621264    /// check out whether this can be done for these functions.
    1263     void getRowBounds(Row c, Value &lower, Value &upper) {
     1265    void getRowBounds(Row c, Value &lower, Value &upper) const {
    12641266      _getRowBounds(_lpId(c),lower, upper);
    12651267    }
     
    12691271
    12701272    ///Get an element of the objective function
    1271     Value objCoeff(Col c) {return _getObjCoeff(_lpId(c)); };
     1273    Value objCoeff(Col c) const { return _getObjCoeff(_lpId(c)); };
    12721274
    12731275    ///Set the objective function
     
    12851287
    12861288    ///\return the objective function as a linear expression of type \ref Expr.
    1287     Expr obj() {
     1289    Expr obj() const {
    12881290      Expr e;
    12891291      for (ColIt it(*this); it != INVALID; ++it) {
     
    13031305
    13041306    ///Query function: is this a maximization problem?
    1305     bool is_max() {return _isMax(); }
     1307    bool is_max() const {return _isMax(); }
    13061308
    13071309    ///Query function: is this a minimization problem?
    1308     bool is_min() {return !is_max(); }
     1310    bool is_min() const {return !is_max(); }
    13091311   
    13101312    ///@}
     
    13311333
    13321334    /// The status of the primal problem (the original LP problem)
    1333     SolutionStatus primalStatus() {
     1335    SolutionStatus primalStatus() const {
    13341336      return _getPrimalStatus();
    13351337    }
    13361338
    13371339    /// The status of the dual (of the original LP) problem
    1338     SolutionStatus dualStatus() {
     1340    SolutionStatus dualStatus() const {
    13391341      return _getDualStatus();
    13401342    }
    13411343
    13421344    ///The type of the original LP problem
    1343     ProblemTypes problemType() {
     1345    ProblemTypes problemType() const {
    13441346      return _getProblemType();
    13451347    }
    13461348
    13471349    ///\e
    1348     Value primal(Col c) { return _getPrimal(_lpId(c)); }
     1350    Value primal(Col c) const { return _getPrimal(_lpId(c)); }
    13491351
    13501352    ///\e
    1351     Value dual(Row r) { return _getDual(_lpId(r)); }
     1353    Value dual(Row r) const { return _getDual(_lpId(r)); }
    13521354
    13531355    ///\e
    1354     bool isBasicCol(Col c) { return _isBasicCol(_lpId(c)); }
     1356    bool isBasicCol(Col c) const { return _isBasicCol(_lpId(c)); }
    13551357
    13561358    ///\e
     
    13611363    ///- \ref NaN if no primal solution is found.
    13621364    ///- The (finite) objective value if an optimal solution is found.
    1363     Value primalValue() { return _getPrimalValue()+obj_const_comp;}
     1365    Value primalValue() const { return _getPrimalValue()+obj_const_comp;}
    13641366    ///@}
    13651367   
     
    13951397    ///
    13961398    ///Gives back the type of the column.
    1397     ColTypes colType(Col c){
     1399    ColTypes colType(Col c) const {
    13981400      return _colType(_lpId(c));
    13991401    }
     
    14131415    ///Gives back the type of the column.
    14141416    ///\return true if the column has integer type and false if not.
    1415     bool integer(Col c){
     1417    bool integer(Col c) const {
    14161418      return (colType(c)==INT);
    14171419    }
    14181420
    14191421    /// The status of the MIP problem
    1420     SolutionStatus mipStatus() {
     1422    SolutionStatus mipStatus() const {
    14211423      return _getMipStatus();
    14221424    }
     
    14241426  protected:
    14251427
    1426     virtual ColTypes _colType(int col) = 0;
     1428    virtual ColTypes _colType(int col) const = 0;
    14271429    virtual void _colType(int col, ColTypes col_type) = 0;
    1428     virtual SolutionStatus _getMipStatus()=0;
     1430    virtual SolutionStatus _getMipStatus() const = 0;
    14291431
    14301432  };
  • lemon/lp_cplex.cc

    r2364 r2366  
    8585  }
    8686 
    87   void LpCplex::_getColName(int col, std::string &name)
     87  void LpCplex::_getColName(int col, std::string &name) const
    8888  {
    8989    ///\bug Untested
     
    108108    CPXchgcolname(env, lp, 1, &col, names);   
    109109  }
     110
     111  int LpCplex::_colByName(const std::string& name) const
     112  {
     113    int index;
     114    if (CPXgetcolindex(env, lp,
     115                       const_cast<char*>(name.c_str()), &index) == 0) {
     116      return index;
     117    }
     118    return -1;
     119  }
    110120 
    111121  ///\warning Data at index 0 is ignored in the arrays.
     
    126136  }
    127137
    128   void LpSoplex::_getRowCoeffs(int i, RowIterator b) {
     138  void LpSoplex::_getRowCoeffs(int i, RowIterator b) const {
    129139    /// \todo implement
    130140  }
     
    146156  }
    147157
    148   void LpSoplex::_getColCoeffs(int i, ColIterator b) {
     158  void LpSoplex::_getColCoeffs(int i, ColIterator b) const {
    149159    /// \todo implement
    150160  }
     
    155165  }
    156166
    157   LpCplex::Value LpCplex::_getCoeff(int row, int col)
     167  LpCplex::Value LpCplex::_getCoeff(int row, int col) const
    158168  {
    159169    LpCplex::Value value;
     
    174184  }
    175185
    176   LpCplex::Value LpCplex::_getColLowerBound(int i)
     186  LpCplex::Value LpCplex::_getColLowerBound(int i) const
    177187  {
    178188    LpCplex::Value x;
     
    192202  }
    193203
    194   LpCplex::Value LpCplex::_getColUpperBound(int i)
     204  LpCplex::Value LpCplex::_getColUpperBound(int i) const
    195205  {
    196206    LpCplex::Value x;
     
    271281//   }
    272282 
    273   void LpCplex::_getRowBounds(int i, Value &lb, Value &ub)
     283  void LpCplex::_getRowBounds(int i, Value &lb, Value &ub) const
    274284  {
    275285    char sense;
     
    303313  }
    304314
    305   LpCplex::Value LpCplex::_getObjCoeff(int i)
     315  LpCplex::Value LpCplex::_getObjCoeff(int i) const
    306316  {
    307317    Value x;
     
    368378  }
    369379
    370   LpCplex::Value LpCplex::_getPrimal(int i)
     380  LpCplex::Value LpCplex::_getPrimal(int i) const
    371381  {
    372382    Value x;
     
    375385  }
    376386
    377   LpCplex::Value LpCplex::_getDual(int i)
     387  LpCplex::Value LpCplex::_getDual(int i) const
    378388  {
    379389    Value y;
     
    382392  }
    383393 
    384   LpCplex::Value LpCplex::_getPrimalValue()
     394  LpCplex::Value LpCplex::_getPrimalValue() const
    385395  {
    386396    Value objval;
     
    391401    return objval;
    392402  }
    393   bool LpCplex::_isBasicCol(int i) {
     403  bool LpCplex::_isBasicCol(int i) const
     404  {
    394405    int cstat[CPXgetnumcols(env, lp)];
    395406    CPXgetbase(env, lp, cstat, NULL);
     
    459470// Description: Method for linear optimization.
    460471// Determines which algorithm is used when CPXlpopt() (or "optimize" in the Interactive Optimizer) is called. Currently the behavior of the "Automatic" setting is that CPLEX simply invokes the dual simplex method, but this capability may be expanded in the future so that CPLEX chooses the method based on problem characteristics
    461   //Hulye cplex
    462472  void statusSwitch(CPXENVptr env,int& stat){
    463473#if CPX_VERSION < 900
     
    476486  }
    477487
    478   LpCplex::SolutionStatus LpCplex::_getPrimalStatus()
     488  LpCplex::SolutionStatus LpCplex::_getPrimalStatus() const
    479489  {
    480490    //Unboundedness not treated well: the following is from cplex 9.0 doc
     
    559569// CPX_STAT_UNBOUNDED
    560570
    561   LpCplex::SolutionStatus LpCplex::_getDualStatus()
     571  LpCplex::SolutionStatus LpCplex::_getDualStatus() const
    562572  {
    563573    int stat = CPXgetstat(env, lp);
     
    588598  }
    589599
    590   LpCplex::ProblemTypes LpCplex::_getProblemType()
     600  LpCplex::ProblemTypes LpCplex::_getProblemType() const
    591601  {
    592602    int stat = CPXgetstat(env, lp);
     
    628638   }
    629639
    630   bool LpCplex::_isMax()
     640  bool LpCplex::_isMax() const
    631641  {
    632642    if (CPXgetobjsen(env, lp)==CPX_MAX)
  • lemon/lp_cplex.h

    r2364 r2366  
    6161    virtual void _eraseCol(int i);
    6262    virtual void _eraseRow(int i);
    63     virtual void _getColName(int col,       std::string & name);
     63    virtual void _getColName(int col, std::string & name) const;
    6464    virtual void _setColName(int col, const std::string & name);
     65    virtual int _colByName(const std::string& name) const;
    6566    virtual void _setRowCoeffs(int i, ConstRowIterator b, ConstRowIterator e);
    66     virtual void _getRowCoeffs(int i, RowIterator b);
     67    virtual void _getRowCoeffs(int i, RowIterator b) const;
    6768    virtual void _setColCoeffs(int i, ConstColIterator b, ConstColIterator e);
    68     virtual void _getColCoeffs(int i, ColIterator b);
     69    virtual void _getColCoeffs(int i, ColIterator b) const;
    6970    virtual void _setCoeff(int row, int col, Value value);
    70     virtual Value _getCoeff(int row, int col);
     71    virtual Value _getCoeff(int row, int col) const;
    7172
    7273    virtual void _setColLowerBound(int i, Value value);
    73     virtual Value _getColLowerBound(int i);
     74    virtual Value _getColLowerBound(int i) const;
    7475    virtual void _setColUpperBound(int i, Value value);
    75     virtual Value _getColUpperBound(int i);
     76    virtual Value _getColUpperBound(int i) const;
    7677
    7778//     virtual void _setRowLowerBound(int i, Value value);
    7879//     virtual void _setRowUpperBound(int i, Value value);
    7980    virtual void _setRowBounds(int i, Value lower, Value upper);
    80     virtual void _getRowBounds(int i, Value &lb, Value &ub);
     81    virtual void _getRowBounds(int i, Value &lb, Value &ub) const;
    8182    virtual void _setObjCoeff(int i, Value obj_coef);
    82     virtual Value _getObjCoeff(int i);
     83    virtual Value _getObjCoeff(int i) const;
    8384    virtual void _clearObj();
    8485
    8586   
    8687    virtual SolveExitStatus _solve();
    87     virtual Value _getPrimal(int i);
    88     virtual Value _getDual(int i);
    89     virtual Value _getPrimalValue();
    90     virtual bool _isBasicCol(int i);
     88    virtual Value _getPrimal(int i) const;
     89    virtual Value _getDual(int i) const;
     90    virtual Value _getPrimalValue() const;
     91    virtual bool _isBasicCol(int i) const;
    9192   
    92     virtual SolutionStatus _getPrimalStatus();
    93     virtual SolutionStatus _getDualStatus();
    94     virtual ProblemTypes _getProblemType();
     93    virtual SolutionStatus _getPrimalStatus() const;
     94    virtual SolutionStatus _getDualStatus() const;
     95    virtual ProblemTypes _getProblemType() const;
    9596
    9697   
     
    9899    virtual void _setMin();
    99100
    100     virtual bool _isMax();
     101    virtual bool _isMax() const;
    101102
    102103  };
  • lemon/lp_glpk.cc

    r2364 r2366  
    3838    cols = _lp_bits::LpId(1);
    3939    lp = lpx_create_prob();
     40    lpx_create_index(lp);
    4041    ///\todo control function for this:
    4142    lpx_set_int_parm(lp, LPX_K_DUAL, 1);
     
    113114  }
    114115
    115   void LpGlpk::_getColName(int col, std::string & name)
     116  void LpGlpk::_getColName(int col, std::string & name) const
    116117  {
    117118   
     
    126127
    127128  }
     129
     130  int LpGlpk::_colByName(const std::string& name) const
     131  {
     132    int k = lpx_find_col(lp, const_cast<char*>(name.c_str()));
     133    return k > 0 ? k : -1;
     134  }
     135
    128136 
    129137  void LpGlpk::_setRowCoeffs(int i, ConstRowIterator b, ConstRowIterator e)
     
    143151  }
    144152
    145   void LpGlpk::_getRowCoeffs(int i, RowIterator b)
     153  void LpGlpk::_getRowCoeffs(int i, RowIterator b) const
    146154  {
    147155    int length = lpx_get_mat_row(lp, i, 0, 0);
     
    174182  }
    175183
    176   void LpGlpk::_getColCoeffs(int i, ColIterator b)
     184  void LpGlpk::_getColCoeffs(int i, ColIterator b) const
    177185  {
    178186    int length = lpx_get_mat_col(lp, i, 0, 0);
     
    248256  }
    249257
    250   LpGlpk::Value LpGlpk::_getCoeff(int row, int col)
     258  LpGlpk::Value LpGlpk::_getCoeff(int row, int col) const
    251259  {
    252260
     
    313321  }
    314322
    315   LpGlpk::Value LpGlpk::_getColLowerBound(int i)
     323  LpGlpk::Value LpGlpk::_getColLowerBound(int i) const
    316324  {
    317325    int b=lpx_get_col_type(lp, i);
     
    370378  }
    371379
    372   LpGlpk::Value LpGlpk::_getColUpperBound(int i)
     380  LpGlpk::Value LpGlpk::_getColUpperBound(int i) const
    373381  {
    374382    int b=lpx_get_col_type(lp, i);
     
    415423  }
    416424
    417   void LpGlpk::_getRowBounds(int i, Value &lb, Value &ub)
     425  void LpGlpk::_getRowBounds(int i, Value &lb, Value &ub) const
    418426  {
    419427
     
    445453  }
    446454
    447   LpGlpk::Value LpGlpk::_getObjCoeff(int i){
     455  LpGlpk::Value LpGlpk::_getObjCoeff(int i) const {
    448456    //i=0 means the constant term (shift)
    449457    return lpx_get_obj_coef(lp, i);
     
    473481  }
    474482
    475   LpGlpk::Value LpGlpk::_getPrimal(int i)
     483  LpGlpk::Value LpGlpk::_getPrimal(int i) const
    476484  {
    477485    return lpx_get_col_prim(lp,i);
    478486  }
    479487
    480   LpGlpk::Value LpGlpk::_getDual(int i)
     488  LpGlpk::Value LpGlpk::_getDual(int i) const
    481489  {
    482490    return lpx_get_row_dual(lp,i);
    483491  }
    484492 
    485   LpGlpk::Value LpGlpk::_getPrimalValue()
     493  LpGlpk::Value LpGlpk::_getPrimalValue() const
    486494  {
    487495    return lpx_get_obj_val(lp);
    488496  }
    489   bool LpGlpk::_isBasicCol(int i) {
     497  bool LpGlpk::_isBasicCol(int i) const
     498  {
    490499    return (lpx_get_col_stat(lp, i)==LPX_BS);
    491500  }
    492501 
    493502 
    494   LpGlpk::SolutionStatus LpGlpk::_getPrimalStatus()
     503  LpGlpk::SolutionStatus LpGlpk::_getPrimalStatus() const
    495504  {
    496505    int stat=  lpx_get_status(lp);
     
    513522  }
    514523
    515   LpGlpk::SolutionStatus LpGlpk::_getDualStatus()
    516   {
    517 //     std::cout<<"Itt megy: "<<lpx_get_dual_stat(lp)<<std::endl;
    518 //     std::cout<<"Itt a primal: "<<lpx_get_prim_stat(lp)<<std::endl;
    519 
     524  LpGlpk::SolutionStatus LpGlpk::_getDualStatus() const
     525  {
    520526    switch (lpx_get_dual_stat(lp)) {
    521527    case LPX_D_UNDEF://Undefined (no solve has been run yet)
     
    539545  }
    540546
    541   LpGlpk::ProblemTypes LpGlpk::_getProblemType()
     547  LpGlpk::ProblemTypes LpGlpk::_getProblemType() const
    542548  {
    543549      //int stat=  lpx_get_status(lp);
     
    566572  }
    567573
    568   bool LpGlpk::_isMax()
     574  bool LpGlpk::_isMax() const
    569575  {
    570576    return (lpx_get_obj_dir(lp)==LPX_MAX);
  • lemon/lp_glpk.h

    r2364 r2366  
    5656    virtual void _eraseCol(int i);
    5757    virtual void _eraseRow(int i);
    58     virtual void _getColName(int col,       std::string & name);
     58    virtual void _getColName(int col, std::string & name) const;
    5959    virtual void _setColName(int col, const std::string & name);
     60    virtual int _colByName(const std::string& name) const;
    6061    virtual void _setRowCoeffs(int i, ConstRowIterator b, ConstRowIterator e);
    61     virtual void _getRowCoeffs(int i, RowIterator b);
     62    virtual void _getRowCoeffs(int i, RowIterator b) const;
    6263    virtual void _setColCoeffs(int i, ConstColIterator b, ConstColIterator e);
    63     virtual void _getColCoeffs(int i, ColIterator b);
     64    virtual void _getColCoeffs(int i, ColIterator b) const;
    6465    virtual void _setCoeff(int row, int col, Value value);
    65     virtual Value _getCoeff(int row, int col);
     66    virtual Value _getCoeff(int row, int col) const;
    6667
    6768    virtual void _setColLowerBound(int i, Value value);
    68     virtual Value _getColLowerBound(int i);
     69    virtual Value _getColLowerBound(int i) const;
    6970    virtual void _setColUpperBound(int i, Value value);
    70     virtual Value _getColUpperBound(int i);
     71    virtual Value _getColUpperBound(int i) const;
    7172
    72 //     virtual void _setRowLowerBound(int i, Value value);
    73 //     virtual void _setRowUpperBound(int i, Value value);
    7473    virtual void _setRowBounds(int i, Value lower, Value upper);
    75     virtual void _getRowBounds(int i, Value &lb, Value &ub);
     74    virtual void _getRowBounds(int i, Value &lb, Value &ub) const;
    7675    virtual void _setObjCoeff(int i, Value obj_coef);
    77     virtual Value _getObjCoeff(int i);
     76    virtual Value _getObjCoeff(int i) const;
    7877    virtual void _clearObj();
    79 //     virtual void _setObj(int length,
    80 //                          int  const * indices,
    81 //                          Value  const * values ) = 0;
    8278
    8379    ///\e
     
    8682    ///
    8783    virtual SolveExitStatus _solve();
    88     virtual Value _getPrimal(int i);
    89     virtual Value _getDual(int i);
    90     virtual Value _getPrimalValue();
    91     virtual bool _isBasicCol(int i);
     84    virtual Value _getPrimal(int i) const;
     85    virtual Value _getDual(int i) const;
     86    virtual Value _getPrimalValue() const;
     87    virtual bool _isBasicCol(int i) const;
    9288    ///\e
    9389   
    9490    ///\todo It should be clarified
    9591    ///
    96     virtual SolutionStatus _getPrimalStatus();
    97     virtual SolutionStatus _getDualStatus();
    98     virtual ProblemTypes _getProblemType();
     92    virtual SolutionStatus _getPrimalStatus() const;
     93    virtual SolutionStatus _getDualStatus() const;
     94    virtual ProblemTypes _getProblemType() const;
    9995
    10096    virtual void _setMax();
    10197    virtual void _setMin();
    10298
    103     virtual bool _isMax();
     99    virtual bool _isMax() const;
    104100
    105101  public:
  • lemon/lp_skeleton.cc

    r2364 r2366  
    5151  }
    5252
    53   void LpSkeleton::_getColName(int, std::string &) {
     53  void LpSkeleton::_getColName(int, std::string &) const {
    5454  }
    5555 
     
    5757  void LpSkeleton::_setColName(int, const std::string &) {
    5858  }
     59
     60  int LpSkeleton::_colByName(const std::string&) const { return -1; }
    5961 
    6062 
     
    6264  }
    6365
    64   void LpSkeleton::_getRowCoeffs(int, RowIterator) {
     66  void LpSkeleton::_getRowCoeffs(int, RowIterator) const {
    6567  }
    6668 
     
    6870  }
    6971
    70   void LpSkeleton::_getColCoeffs(int, ColIterator) {
     72  void LpSkeleton::_getColCoeffs(int, ColIterator) const {
    7173  }
    7274
     
    7577  }
    7678
    77   LpSkeleton::Value LpSkeleton::_getCoeff(int, int)
     79  LpSkeleton::Value LpSkeleton::_getCoeff(int, int) const
    7880  {
    7981    return 0;
     
    8587  }
    8688 
    87   LpSkeleton::Value LpSkeleton::_getColLowerBound(int)
     89  LpSkeleton::Value LpSkeleton::_getColLowerBound(int) const
    8890  {
    8991    return 0;
     
    9496  }
    9597
    96   LpSkeleton::Value LpSkeleton::_getColUpperBound(int)
     98  LpSkeleton::Value LpSkeleton::_getColUpperBound(int) const
    9799  {
    98100    return 0;
     
    111113  }
    112114
    113   void LpSkeleton::_getRowBounds(int, Value&, Value&)
     115  void LpSkeleton::_getRowBounds(int, Value&, Value&) const
    114116  {
    115117  }
     
    119121  }
    120122
    121   LpSkeleton::Value LpSkeleton::_getObjCoeff(int){
     123  LpSkeleton::Value LpSkeleton::_getObjCoeff(int) const
     124  {
    122125    return 0;
    123126  }
     
    131134  }
    132135
    133   bool LpSkeleton::_isMax()
     136  bool LpSkeleton::_isMax() const
    134137  {
    135138    return true;
     
    146149  }
    147150
    148   LpSkeleton::Value LpSkeleton::_getPrimal(int)
     151  LpSkeleton::Value LpSkeleton::_getPrimal(int) const
    149152  {
    150153    return 0;
    151154  }
    152155 
    153   LpSkeleton::Value LpSkeleton::_getDual(int)
     156  LpSkeleton::Value LpSkeleton::_getDual(int) const
    154157  {
    155158    return 0;
    156159  }
    157160 
    158   LpSkeleton::Value LpSkeleton::_getPrimalValue()
     161  LpSkeleton::Value LpSkeleton::_getPrimalValue() const
    159162  {
    160163    return 0;
    161164  }
    162165 
    163   LpSkeleton::SolutionStatus LpSkeleton::_getPrimalStatus()
     166  LpSkeleton::SolutionStatus LpSkeleton::_getPrimalStatus() const
    164167  {
    165168    return UNDEFINED;
    166169  }
    167170
    168   LpSkeleton::SolutionStatus LpSkeleton::_getDualStatus()
     171  LpSkeleton::SolutionStatus LpSkeleton::_getDualStatus() const
    169172  {
    170173    return UNDEFINED;
    171174  }
    172175
    173   LpSkeleton::ProblemTypes LpSkeleton::_getProblemType()
     176  LpSkeleton::ProblemTypes LpSkeleton::_getProblemType() const
    174177  {
    175178    return UNKNOWN;
    176179  }
    177180
    178   bool LpSkeleton::_isBasicCol(int)
     181  bool LpSkeleton::_isBasicCol(int) const
    179182  {
    180183    return true;
  • lemon/lp_skeleton.h

    r2364 r2366  
    4545    virtual void _eraseRow(int i);
    4646    /// \e
    47     virtual void _getColName(int col, std::string & name);
     47    virtual void _getColName(int col, std::string & name) const;
    4848    /// \e
    4949    virtual void _setColName(int col, const std::string & name);
     50    /// \e
     51    virtual int _colByName(const std::string& name) const;
    5052
    5153    /// \e
    5254    virtual void _setRowCoeffs(int i, ConstRowIterator b, ConstRowIterator e);
    5355    /// \e
    54     virtual void _getRowCoeffs(int i, RowIterator b);
     56    virtual void _getRowCoeffs(int i, RowIterator b) const;
    5557    /// \e
    5658    virtual void _setColCoeffs(int i, ConstColIterator b, ConstColIterator e);
    5759    /// \e
    58     virtual void _getColCoeffs(int i, ColIterator b);
     60    virtual void _getColCoeffs(int i, ColIterator b) const;
    5961   
    6062    /// Set one element of the coefficient matrix
     
    6264
    6365    /// Get one element of the coefficient matrix
    64     virtual Value _getCoeff(int row, int col);
     66    virtual Value _getCoeff(int row, int col) const;
    6567
    6668    /// The lower bound of a variable (column) have to be given by an
     
    7375    /// extended number of type Value, i.e. a finite number of type
    7476    /// Value or -\ref INF.
    75     virtual Value _getColLowerBound(int i);
     77    virtual Value _getColLowerBound(int i) const;
    7678
    7779    /// The upper bound of a variable (column) have to be given by an
     
    8486    /// extended number of type Value, i.e. a finite number of type
    8587    /// Value or \ref INF.
    86     virtual Value _getColUpperBound(int i);
     88    virtual Value _getColUpperBound(int i) const;
    8789
    8890//     /// The lower bound of a linear expression (row) have to be given by an
     
    109111    /// extended numbers of type Value, i.e.  finite numbers of type
    110112    /// Value, -\ref INF or \ref INF.
    111     virtual void _getRowBounds(int i, Value &lb, Value &ub);
     113    virtual void _getRowBounds(int i, Value &lb, Value &ub) const;
    112114    /// \e
    113115
     
    119121
    120122    /// \e
    121     virtual Value _getObjCoeff(int i);
     123    virtual Value _getObjCoeff(int i) const;
    122124
    123125    ///\e
     
    131133    ///\bug Wrong interface
    132134    ///
    133     virtual Value _getPrimal(int i);
     135    virtual Value _getPrimal(int i) const;
    134136
    135137    ///\e
     
    137139    ///\bug Wrong interface
    138140    ///
    139     virtual Value _getDual(int i);
     141    virtual Value _getDual(int i) const;
    140142
    141143    ///\e
     
    143145    ///\bug Wrong interface
    144146    ///
    145     virtual Value _getPrimalValue();
     147    virtual Value _getPrimalValue() const;
    146148
    147149    ///\e
     
    149151    ///\bug Wrong interface
    150152    ///
    151     virtual SolutionStatus _getPrimalStatus();
     153    virtual SolutionStatus _getPrimalStatus() const;
    152154
    153155    ////e
    154     virtual SolutionStatus _getDualStatus();
     156    virtual SolutionStatus _getDualStatus() const;
    155157
    156158
    157159    ///\e
    158     virtual ProblemTypes _getProblemType();
     160    virtual ProblemTypes _getProblemType() const;
    159161
    160162    ///\e
     
    164166
    165167    ///\e
    166     virtual bool _isMax();
     168    virtual bool _isMax() const;
    167169
    168170
    169171
    170172    ///\e
    171     virtual bool _isBasicCol(int i);
     173    virtual bool _isBasicCol(int i) const;
    172174
    173175   
  • lemon/lp_soplex.cc

    r2364 r2366  
    9191  }
    9292 
    93   void LpSoplex::_getColName(int col, std::string &name) {
     93  void LpSoplex::_getColName(int col, std::string &name) const {
    9494    name = colNames[col];
    9595  }
    9696 
    9797  void LpSoplex::_setColName(int col, const std::string &name) {
     98    invColNames.erase(colNames[col]);
    9899    colNames[col] = name;
     100    if (!name.empty()) {
     101      invColNames.insert(std::make_pair(name, col));
     102    }
     103  }
     104
     105  int LpSoplex::_colByName(const std::string& name) const {
     106    std::map<std::string, int>::const_iterator it =
     107      invColNames.find(name);
     108    if (it != invColNames.end()) {
     109      return it->second;
     110    } else {
     111      return -1;
     112    }
    99113  }
    100114 
     
    110124  }
    111125
    112   void LpSoplex::_getRowCoeffs(int i, RowIterator b) {
     126  void LpSoplex::_getRowCoeffs(int i, RowIterator b) const {
    113127    const soplex::SVector& vec = soplex->rowVector(i);
    114128    for (int k = 0; k < vec.size(); ++k) {
     
    128142  }
    129143
    130   void LpSoplex::_getColCoeffs(int i, ColIterator b) {
     144  void LpSoplex::_getColCoeffs(int i, ColIterator b) const {
    131145    const soplex::SVector& vec = soplex->colVector(i);
    132146    for (int k = 0; k < vec.size(); ++k) {
     
    141155  }
    142156
    143   LpSoplex::Value LpSoplex::_getCoeff(int i, int j) {
     157  LpSoplex::Value LpSoplex::_getCoeff(int i, int j) const {
    144158    return soplex->rowVector(i)[j];
    145159  }
     
    150164  }
    151165 
    152   LpSoplex::Value LpSoplex::_getColLowerBound(int i) {
     166  LpSoplex::Value LpSoplex::_getColLowerBound(int i) const {
    153167    double value = soplex->lower(i);
    154168    return value != -soplex::infinity ? value : -INF;
     
    160174  }
    161175
    162   LpSoplex::Value LpSoplex::_getColUpperBound(int i) {
     176  LpSoplex::Value LpSoplex::_getColUpperBound(int i) const {
    163177    double value = soplex->upper(i);
    164178    return value != soplex::infinity ? value : INF;
     
    170184    solved = false;
    171185  }
    172   void LpSoplex::_getRowBounds(int i, Value &lower, Value &upper) {
     186  void LpSoplex::_getRowBounds(int i, Value &lower, Value &upper) const {
    173187    lower = soplex->lhs(i);
    174188    if (lower == -soplex::infinity) lower = -INF;
     
    182196  }
    183197
    184   LpSoplex::Value LpSoplex::_getObjCoeff(int i) {
     198  LpSoplex::Value LpSoplex::_getObjCoeff(int i) const {
    185199    return soplex->obj(i);
    186200  }
     
    213227  }
    214228
    215   LpSoplex::Value LpSoplex::_getPrimal(int i) {
     229  LpSoplex::Value LpSoplex::_getPrimal(int i) const {
    216230    return primal_value[i];
    217231  }
    218232
    219   LpSoplex::Value LpSoplex::_getDual(int i) {
     233  LpSoplex::Value LpSoplex::_getDual(int i) const {
    220234    return dual_value[i];
    221235  }
    222236 
    223   LpSoplex::Value LpSoplex::_getPrimalValue() {
     237  LpSoplex::Value LpSoplex::_getPrimalValue() const {
    224238    return soplex->objValue();
    225239  }
    226240
    227   bool LpSoplex::_isBasicCol(int i) {
     241  bool LpSoplex::_isBasicCol(int i) const {
    228242    return soplex->getBasisColStatus(i) == soplex::SPxSolver::BASIC;
    229243  } 
    230244
    231   LpSoplex::SolutionStatus LpSoplex::_getPrimalStatus() {
     245  LpSoplex::SolutionStatus LpSoplex::_getPrimalStatus() const {
    232246    if (!solved) return UNDEFINED;
    233247    switch (soplex->status()) {
     
    243257  }
    244258
    245   LpSoplex::SolutionStatus LpSoplex::_getDualStatus() {
     259  LpSoplex::SolutionStatus LpSoplex::_getDualStatus() const {
    246260    if (!solved) return UNDEFINED;
    247261    switch (soplex->status()) {
     
    255269  }
    256270
    257   LpSoplex::ProblemTypes LpSoplex::_getProblemType() {
     271  LpSoplex::ProblemTypes LpSoplex::_getProblemType() const {
    258272    if (!solved) return UNKNOWN;
    259273    switch (soplex->status()) {
     
    275289    solved = false;
    276290  }
    277   bool LpSoplex::_isMax() {
     291  bool LpSoplex::_isMax() const {
    278292    return soplex->spxSense() == soplex::SPxSolver::MAXIMIZE;
    279293  }
  • lemon/lp_soplex.h

    r2364 r2366  
    3535namespace lemon {
    3636
     37  /// \ingroup gen_opt_group
     38  ///
    3739  /// \brief Interface for the SOPLEX solver
    3840  ///
    39   /// This class implements an interface for the SOPLEX LP solver.
     41  /// This class implements an interface for the SoPlex LP solver.
     42  /// The SoPlex library is an object oriented lp solver library
     43  /// developed at the Konrad-Zuse-Zentrum für Informationstechnik
     44  /// Berlin (ZIB). You can find detailed information about it at the
     45  /// <tt>http://soplex.zib.de</tt> address.
    4046  class LpSoplex :virtual public LpSolverBase {
    4147  protected:
     
    4753
    4854    std::vector<std::string> colNames;
     55    std::map<std::string, int> invColNames;
    4956
    5057    std::vector<Value> primal_value;
     
    7178    virtual void _eraseCol(int i);
    7279    virtual void _eraseRow(int i);
    73     virtual void _getColName(int col, std::string & name);
     80    virtual void _getColName(int col, std::string & name) const;
    7481    virtual void _setColName(int col, const std::string & name);
     82    virtual int _colByName(const std::string& name) const;
    7583    virtual void _setRowCoeffs(int i, ConstRowIterator b, ConstRowIterator e);
    76     virtual void _getRowCoeffs(int i, RowIterator b);
     84    virtual void _getRowCoeffs(int i, RowIterator b) const;
    7785    virtual void _setColCoeffs(int i, ConstColIterator b, ConstColIterator e);
    78     virtual void _getColCoeffs(int i, ColIterator b);
     86    virtual void _getColCoeffs(int i, ColIterator b) const;
    7987    virtual void _setCoeff(int row, int col, Value value);
    80     virtual Value _getCoeff(int row, int col);
     88    virtual Value _getCoeff(int row, int col) const;
    8189    virtual void _setColLowerBound(int i, Value value);
    82     virtual Value _getColLowerBound(int i);
     90    virtual Value _getColLowerBound(int i) const;
    8391    virtual void _setColUpperBound(int i, Value value);
    84     virtual Value _getColUpperBound(int i);
     92    virtual Value _getColUpperBound(int i) const;
    8593    virtual void _setRowBounds(int i, Value lower, Value upper);
    86     virtual void _getRowBounds(int i, Value &lower, Value &upper);
     94    virtual void _getRowBounds(int i, Value &lower, Value &upper) const;
    8795    virtual void _setObjCoeff(int i, Value obj_coef);
    88     virtual Value _getObjCoeff(int i);
     96    virtual Value _getObjCoeff(int i) const;
    8997    virtual void _clearObj();
    9098   
    9199    virtual SolveExitStatus _solve();
    92     virtual Value _getPrimal(int i);
    93     virtual Value _getDual(int i);
    94     virtual Value _getPrimalValue();
    95     virtual bool _isBasicCol(int i);
     100    virtual Value _getPrimal(int i) const;
     101    virtual Value _getDual(int i) const;
     102    virtual Value _getPrimalValue() const;
     103    virtual bool _isBasicCol(int i) const;
    96104   
    97     virtual SolutionStatus _getPrimalStatus();
    98     virtual SolutionStatus _getDualStatus();
    99     virtual ProblemTypes _getProblemType();
     105    virtual SolutionStatus _getPrimalStatus() const;
     106    virtual SolutionStatus _getDualStatus() const;
     107    virtual ProblemTypes _getProblemType() const;
    100108
    101109   
    102110    virtual void _setMax();
    103111    virtual void _setMin();
    104     virtual bool _isMax();
     112    virtual bool _isMax() const;
    105113
    106114  };
  • lemon/mip_cplex.cc

    r2267 r2366  
    5959  }
    6060 
    61   MipCplex::ColTypes MipCplex::_colType(int i){
     61  MipCplex::ColTypes MipCplex::_colType(int i) const {
    6262   
    6363    char ctype[1];
     
    8686
    8787
    88   LpCplex::SolutionStatus MipCplex::_getMipStatus(){
     88  LpCplex::SolutionStatus MipCplex::_getMipStatus() const {
    8989
    9090    int stat = CPXgetstat(env, lp);
     
    120120  } 
    121121
    122   MipCplex::Value MipCplex::_getPrimal(int i){
     122  MipCplex::Value MipCplex::_getPrimal(int i) const {
    123123    Value x;
    124124    CPXgetmipx(env, lp, &x, i, i);
     
    126126  }
    127127 
    128   MipCplex::Value MipCplex::_getPrimalValue(){
     128  MipCplex::Value MipCplex::_getPrimalValue() const {
    129129    Value objval;
    130130    status = CPXgetmipobjval(env, lp, &objval);
  • lemon/mip_cplex.h

    r2219 r2366  
    4848  protected:
    4949 
    50     virtual ColTypes _colType(int col);
     50    virtual ColTypes _colType(int col) const;
    5151    virtual void _colType(int col, ColTypes col_type);
    5252   
    5353    virtual LpCplex::SolveExitStatus _solve();
    54     virtual LpCplex::SolutionStatus _getMipStatus();
    55     virtual ParentLp::Value _getPrimal(int i);
    56     virtual ParentLp::Value _getPrimalValue();
     54    virtual LpCplex::SolutionStatus _getMipStatus() const;
     55    virtual ParentLp::Value _getPrimal(int i) const;
     56    virtual ParentLp::Value _getPrimalValue() const;
    5757  };
    5858
  • lemon/mip_glpk.cc

    r2267 r2366  
    4141  }
    4242 
    43   MipGlpk::ColTypes MipGlpk::_colType(int i){
     43  MipGlpk::ColTypes MipGlpk::_colType(int i) const {
    4444    switch (lpx_get_col_kind(lp,i)){
    4545    case LPX_IV:
     
    5353  }
    5454 
    55   LpGlpk::SolveExitStatus MipGlpk::_solve(){
     55  LpGlpk::SolveExitStatus MipGlpk::_solve() {
    5656    int result = lpx_simplex(lp);
    5757    //
     
    7272
    7373
    74   LpGlpk::SolutionStatus MipGlpk::_getMipStatus(){
     74  LpGlpk::SolutionStatus MipGlpk::_getMipStatus() const {
    7575
    7676    if (lpx_get_status(lp)==LPX_OPT){
     
    101101  } 
    102102
    103   MipGlpk::Value MipGlpk::_getPrimal(int i){
     103  MipGlpk::Value MipGlpk::_getPrimal(int i) const {
    104104    return lpx_mip_col_val(lp,i);
    105105  }
    106106 
    107   MipGlpk::Value MipGlpk::_getPrimalValue(){
     107  MipGlpk::Value MipGlpk::_getPrimalValue() const {
    108108    return lpx_mip_obj_val(lp);
    109109  }
  • lemon/mip_glpk.h

    r2218 r2366  
    4646  protected:
    4747 
    48     virtual ColTypes _colType(int col);
     48    virtual ColTypes _colType(int col) const;
    4949    virtual void _colType(int col, ColTypes col_type);
    5050   
    5151    virtual LpGlpk::SolveExitStatus _solve();
    52     virtual LpGlpk::SolutionStatus _getMipStatus();
    53     virtual ParentLp::Value _getPrimal(int i);
    54     virtual ParentLp::Value _getPrimalValue();
     52    virtual LpGlpk::SolutionStatus _getMipStatus() const;
     53    virtual ParentLp::Value _getPrimal(int i) const;
     54    virtual ParentLp::Value _getPrimalValue() const;
    5555  };
    5656
Note: See TracChangeset for help on using the changeset viewer.