COIN-OR::LEMON - Graph Library

Ticket #203: e4554cd6b2bf.patch

File e4554cd6b2bf.patch, 8.9 KB (added by Balazs Dezso, 10 years ago)

The patch is remaked

  • lemon/cbc.cc

    # HG changeset patch
    # User Balazs Dezso <deba@inf.elte.hu>
    # Date 1254608922 -7200
    # Node ID e4554cd6b2bf7d7efc98c123fcf39d6f0de74354
    # Parent  68792fb2870f54f66104b3cc20eba1e6e6ca5255
    Faster add row operation (#203)
    
    One virtual function call instead of more
    
    diff -r 68792fb2870f -r e4554cd6b2bf lemon/cbc.cc
    a b  
    9494    return _prob->numberRows() - 1;
    9595  }
    9696
     97  int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
     98    std::vector<int> indexes;
     99    std::vector<Value> values;
     100
     101    for(ExprIterator it = b; it != e; ++it) {
     102      indexes.push_back(it->first);
     103      values.push_back(it->second);
     104    }
     105
     106    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
     107    return _prob->numberRows() - 1;
     108  }
    97109
    98110  void CbcMip::_eraseCol(int i) {
    99111    _prob->deleteColumn(i);
  • lemon/cbc.h

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/cbc.h
    a b  
    6262
    6363    virtual int _addCol();
    6464    virtual int _addRow();
     65    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
    6566
    6667    virtual void _eraseCol(int i);
    6768    virtual void _eraseRow(int i);
  • lemon/clp.cc

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/clp.cc
    a b  
    7878    return _prob->numberRows() - 1;
    7979  }
    8080
     81  int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
     82    std::vector<int> indexes;
     83    std::vector<Value> values;
     84
     85    for(ExprIterator it = b; it != e; ++it) {
     86      indexes.push_back(it->first);
     87      values.push_back(it->second);
     88    }
     89
     90    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
     91    return _prob->numberRows() - 1;
     92  }
     93
    8194
    8295  void ClpLp::_eraseCol(int c) {
    8396    _col_names_ref.erase(_prob->getColumnName(c));
  • lemon/clp.h

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/clp.h
    a b  
    7575
    7676    virtual int _addCol();
    7777    virtual int _addRow();
     78    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
    7879
    7980    virtual void _eraseCol(int i);
    8081    virtual void _eraseRow(int i);
  • lemon/cplex.cc

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/cplex.cc
    a b  
    111111    return i;
    112112  }
    113113
     114  int CplexBase::_addRow(Value lb, ExprIterator b,
     115                         ExprIterator e, Value ub) {
     116    int i = CPXgetnumrows(cplexEnv(), _prob);
     117    if (lb == -INF) {
     118      const char s = 'L';
     119      CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
     120    } else if (ub == INF) {
     121      const char s = 'G';
     122      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
     123    } else if (lb == ub){
     124      const char s = 'E';
     125      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
     126    } else {
     127      const char s = 'R';
     128      double len = ub - lb;
     129      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0);
     130    }
     131
     132    std::vector<int> indices;
     133    std::vector<int> rowlist;
     134    std::vector<Value> values;
     135
     136    for(ExprIterator it=b; it!=e; ++it) {
     137      indices.push_back(it->first);
     138      values.push_back(it->second);
     139      rowlist.push_back(i);
     140    }
     141
     142    CPXchgcoeflist(cplexEnv(), _prob, values.size(),
     143                   &rowlist.front(), &indices.front(), &values.front());
     144
     145    return i;
     146  }
    114147
    115148  void CplexBase::_eraseCol(int i) {
    116149    CPXdelcols(cplexEnv(), _prob, i, i);
  • lemon/cplex.h

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/cplex.h
    a b  
    9393
    9494    virtual int _addCol();
    9595    virtual int _addRow();
     96    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
    9697
    9798    virtual void _eraseCol(int i);
    9899    virtual void _eraseRow(int i);
  • lemon/glpk.cc

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/glpk.cc
    a b  
    5959    return i;
    6060  }
    6161
     62  int GlpkBase::_addRow(Value lo, ExprIterator b,
     63                        ExprIterator e, Value up) {
     64    int i = glp_add_rows(lp, 1);
     65
     66    if (lo == -INF) {
     67      if (up == INF) {
     68        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
     69      } else {
     70        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
     71      }   
     72    } else {
     73      if (up == INF) {
     74        glp_set_row_bnds(lp, i, GLP_LO, lo, up);
     75      } else if (lo != up) {       
     76        glp_set_row_bnds(lp, i, GLP_DB, lo, up);
     77      } else {
     78        glp_set_row_bnds(lp, i, GLP_FX, lo, up);
     79      }
     80    }
     81
     82    std::vector<int> indexes;
     83    std::vector<Value> values;
     84
     85    indexes.push_back(0);
     86    values.push_back(0);
     87
     88    for(ExprIterator it = b; it != e; ++it) {
     89      indexes.push_back(it->first);
     90      values.push_back(it->second);
     91    }
     92
     93    glp_set_mat_row(lp, i, values.size() - 1,
     94                    &indexes.front(), &values.front());
     95    return i;
     96  }
     97
    6298  void GlpkBase::_eraseCol(int i) {
    6399    int ca[2];
    64100    ca[1] = i;
  • lemon/glpk.h

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/glpk.h
    a b  
    5454
    5555    virtual int _addCol();
    5656    virtual int _addRow();
     57    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
    5758
    5859    virtual void _eraseCol(int i);
    5960    virtual void _eraseRow(int i);
  • lemon/lp_base.h

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/lp_base.h
    a b  
    943943    virtual int _addCol() = 0;
    944944    virtual int _addRow() = 0;
    945945
     946    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
     947      int row = _addRow();
     948      _setRowCoeffs(row, b, e);
     949      _setRowLowerBound(row, l);
     950      _setRowUpperBound(row, u);
     951      return row;
     952    }
     953
    946954    virtual void _eraseCol(int col) = 0;
    947955    virtual void _eraseRow(int row) = 0;
    948956
     
    12071215    ///\param u is the upper bound (\ref INF means no bound)
    12081216    ///\return The created row.
    12091217    Row addRow(Value l,const Expr &e, Value u) {
    1210       Row r=addRow();
    1211       row(r,l,e,u);
     1218      Row r;
     1219      e.simplify();
     1220      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
     1221                                ExprIterator(e.comps.end(), cols), u - *e));
    12121222      return r;
    12131223    }
    12141224
     
    12171227    ///\param c is a linear expression (see \ref Constr)
    12181228    ///\return The created row.
    12191229    Row addRow(const Constr &c) {
    1220       Row r=addRow();
    1221       row(r,c);
     1230      Row r;
     1231      c.expr().simplify();
     1232      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound():-INF,
     1233                                ExprIterator(c.expr().comps.begin(), cols),
     1234                                ExprIterator(c.expr().comps.end(), cols),
     1235                                c.upperBounded()?c.upperBound():INF));
    12221236      return r;
    12231237    }
    12241238    ///Erase a column (i.e a variable) from the LP
  • lemon/lp_skeleton.cc

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/lp_skeleton.cc
    a b  
    3232    return ++row_num;
    3333  }
    3434
     35  int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value)
     36  {
     37    return ++row_num;
     38  }
     39
    3540  void SkeletonSolverBase::_eraseCol(int) {}
    3641  void SkeletonSolverBase::_eraseRow(int) {}
    3742
  • lemon/lp_skeleton.h

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/lp_skeleton.h
    a b  
    4545    /// \e
    4646    virtual int _addRow();
    4747    /// \e
     48    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
     49    /// \e
    4850    virtual void _eraseCol(int i);
    4951    /// \e
    5052    virtual void _eraseRow(int i);
  • lemon/soplex.cc

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/soplex.cc
    a b  
    9191    return soplex->nRows() - 1;
    9292  }
    9393
     94  int SoplexLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
     95    soplex::DSVector v;
     96    for (ExprIterator it = b; it != e; ++it) {
     97      v.add(it->first, it->second);
     98    }
     99    soplex::LPRow r(l, v, u);
     100    soplex->addRow(r);
     101
     102    _row_names.push_back(std::string());
     103
     104    return soplex->nRows() - 1;
     105  }
     106
    94107
    95108  void SoplexLp::_eraseCol(int i) {
    96109    soplex->removeCol(i);
  • lemon/soplex.h

    diff -r 68792fb2870f -r e4554cd6b2bf lemon/soplex.h
    a b  
    8484
    8585    virtual int _addCol();
    8686    virtual int _addRow();
     87    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
    8788
    8889    virtual void _eraseCol(int i);
    8990    virtual void _eraseRow(int i);