Changeset 1144:1cfabf245433 in lemon-0.x for src/work/marci/lp/lp_solver_base.h

Timestamp:

02/10/05 19:53:30 (19 years ago)

Author:

marci

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1545

Message:

trying to add constraints of kind 1 <= x[2]+x[3] <= 4

File:

• src/work/marci/lp/lp_solver_base.h (modified) (14 diffs)

src/work/marci/lp/lp_solver_base.h

@@ -194 +194 @@
     typedef _Value Value;
     /// \e
-    typedef IterablePartition<int>::ClassIt RowIt;
-    /// \e
-    typedef IterablePartition<int>::ClassIt ColIt;
+    typedef IterablePartition<int>::ClassIt Row;
+    /// \e
+    typedef IterablePartition<int>::ClassIt Col;
   public:
     /// \e
@@ -203 +203 @@
     IterablePartition<int> col_iter_map;
     /// \e
-    std::vector<RowIt> int_row_map;
-    /// \e
-    std::vector<ColIt> int_col_map;
+    std::vector<Row> int_row_map;
+    /// \e
+    std::vector<Col> int_col_map;
     /// \e
     const int VALID_CLASS;
@@ -272 +272 @@
     /// \e
     virtual void printDualStatus(int i) = 0;
-    /// Returns the status of the slack variable assigned to row \c row_it.
-    virtual int getRowStat(const RowIt& row_it) = 0;
+    /// Returns the status of the slack variable assigned to row \c row.
+    virtual int getRowStat(const Row& row) = 0;
     /// \e
     virtual void printRowStatus(int i) = 0;
-    /// Returns the status of the variable assigned to column \c col_it.
-    virtual int getColStat(const ColIt& col_it) = 0;
+    /// Returns the status of the variable assigned to column \c col.
+    virtual int getColStat(const Col& col) = 0;
     /// \e
     virtual void printColStatus(int i) = 0;
@@ -376 +376 @@
 
     /// \e
-    ColIt addCol() {
+    Col addCol() {
       int i=_addCol();  
-      ColIt col_it;
-      col_iter_map.first(col_it, INVALID_CLASS);
-      if (col_iter_map.valid(col_it)) { //van hasznalhato hely
-        col_iter_map.set(col_it, INVALID_CLASS, VALID_CLASS);
-        col_iter_map[col_it]=i;
+      Col col;
+      col_iter_map.first(col, INVALID_CLASS);
+      if (col_iter_map.valid(col)) { //van hasznalhato hely
+        col_iter_map.set(col, INVALID_CLASS, VALID_CLASS);
+        col_iter_map[col]=i;
       } else { //a cucc vegere kell inzertalni mert nincs szabad hely
-        col_it=col_iter_map.push_back(i, VALID_CLASS);
-      }
-      int_col_map.push_back(col_it);
-      return col_it;
-    }
-    /// \e
-    RowIt addRow() {
+        col=col_iter_map.push_back(i, VALID_CLASS);
+      }
+      int_col_map.push_back(col);
+      return col;
+    }
+    /// \e
+    Row addRow() {
       int i=_addRow();
-      RowIt row_it;
-      row_iter_map.first(row_it, INVALID_CLASS);
-      if (row_iter_map.valid(row_it)) { //van hasznalhato hely
-        row_iter_map.set(row_it, INVALID_CLASS, VALID_CLASS);
-        row_iter_map[row_it]=i;
+      Row row;
+      row_iter_map.first(row, INVALID_CLASS);
+      if (row_iter_map.valid(row)) { //van hasznalhato hely
+        row_iter_map.set(row, INVALID_CLASS, VALID_CLASS);
+        row_iter_map[row]=i;
       } else { //a cucc vegere kell inzertalni mert nincs szabad hely
-        row_it=row_iter_map.push_back(i, VALID_CLASS);
-      }
-      int_row_map.push_back(row_it);
-      return row_it;
-    }
-    /// \e
-    void eraseCol(const ColIt& col_it) {
-      col_iter_map.set(col_it, VALID_CLASS, INVALID_CLASS);
+        row=row_iter_map.push_back(i, VALID_CLASS);
+      }
+      int_row_map.push_back(row);
+      return row;
+    }
+    /// \e
+    void eraseCol(const Col& col) {
+      col_iter_map.set(col, VALID_CLASS, INVALID_CLASS);
       int cols[2];
-      cols[1]=col_iter_map[col_it];
+      cols[1]=col_iter_map[col];
       _eraseCol(cols[1]);
-      col_iter_map[col_it]=0; //glpk specifikus, de kell ez??
-      ColIt it;
+      col_iter_map[col]=0; //glpk specifikus, de kell ez??
+      Col it;
       for (col_iter_map.first(it, VALID_CLASS); 
            col_iter_map.valid(it); col_iter_map.next(it)) {
@@ -418 +418 @@
     }
     /// \e
-    void eraseRow(const RowIt& row_it) {
-      row_iter_map.set(row_it, VALID_CLASS, INVALID_CLASS);
+    void eraseRow(const Row& row) {
+      row_iter_map.set(row, VALID_CLASS, INVALID_CLASS);
       int rows[2];
-      rows[1]=row_iter_map[row_it];
+      rows[1]=row_iter_map[row];
       _eraseRow(rows[1]);
-      row_iter_map[row_it]=0; //glpk specifikus, de kell ez??
-      RowIt it;
+      row_iter_map[row]=0; //glpk specifikus, de kell ez??
+      Row it;
       for (row_iter_map.first(it, VALID_CLASS); 
            row_iter_map.valid(it); row_iter_map.next(it)) {
@@ -432 +432 @@
     }
     /// \e
-    template <typename Begin, typename End>
-    void setRowCoeffs(RowIt row_it, Begin begin, End end) {
-      std::vector<std::pair<int, double> > coeffs;
-      for ( ; begin!=end; ++begin) {
-        coeffs.push_back(std::
-                         make_pair(col_iter_map[begin->first], begin->second));
-      }
-      _setRowCoeffs(row_iter_map[row_it], coeffs);
-    }
-    /// \e
-    template <typename Begin, typename End>
-    void setColCoeffs(ColIt col_it, Begin begin, End end) {
-      std::vector<std::pair<int, double> > coeffs;
-      for ( ; begin!=end; ++begin) {
-        coeffs.push_back(std::
-                         make_pair(row_iter_map[begin->first], begin->second));
-      }
-      _setColCoeffs(col_iter_map[col_it], coeffs);
-    }
-    /// \e
-    void setColLowerBound(ColIt col_it, _Value lo) {
-      _setColLowerBound(col_iter_map[col_it], lo);
-    }
-    /// \e
-    _Value getColLowerBound(ColIt col_it) {
-      return _getColLowerBound(col_iter_map[col_it]);
-    }
-    /// \e
-    void setColUpperBound(ColIt col_it, _Value up) {
-      _setColUpperBound(col_iter_map[col_it], up);
-    }
-    /// \e
-    _Value getColUpperBound(ColIt col_it) {      
-      return _getColUpperBound(col_iter_map[col_it]);
-    }
-    /// \e
-    void setRowLowerBound(RowIt row_it, _Value lo) {
-      _setRowLowerBound(row_iter_map[row_it], lo);
-    }
-    /// \e
-    _Value getRowLowerBound(RowIt row_it) {
-      return _getRowLowerBound(row_iter_map[row_it]);
-    }
-    /// \e
-    void setRowUpperBound(RowIt row_it, _Value up) {
-      _setRowUpperBound(row_iter_map[row_it], up);
-    }
-    /// \e
-    _Value getRowUpperBound(RowIt row_it) {      
-      return _getRowUpperBound(row_iter_map[row_it]);
-    }
-    /// \e
-    void setObjCoef(const ColIt& col_it, _Value obj_coef) {
-      _setObjCoef(col_iter_map[col_it], obj_coef);
-    }
-    /// \e
-    _Value getObjCoef(const ColIt& col_it) {
-      return _getObjCoef(col_iter_map[col_it]);
+    void setColLowerBound(Col col, _Value lo) {
+      _setColLowerBound(col_iter_map[col], lo);
+    }
+    /// \e
+    _Value getColLowerBound(Col col) {
+      return _getColLowerBound(col_iter_map[col]);
+    }
+    /// \e
+    void setColUpperBound(Col col, _Value up) {
+      _setColUpperBound(col_iter_map[col], up);
+    }
+    /// \e
+    _Value getColUpperBound(Col col) {      
+      return _getColUpperBound(col_iter_map[col]);
+    }
+    /// \e
+    void setRowLowerBound(Row row, _Value lo) {
+      _setRowLowerBound(row_iter_map[row], lo);
+    }
+    /// \e
+    _Value getRowLowerBound(Row row) {
+      return _getRowLowerBound(row_iter_map[row]);
+    }
+    /// \e
+    void setRowUpperBound(Row row, _Value up) {
+      _setRowUpperBound(row_iter_map[row], up);
+    }
+    /// \e
+    _Value getRowUpperBound(Row row) {      
+      return _getRowUpperBound(row_iter_map[row]);
+    }
+    /// \e
+    void setObjCoef(const Col& col, _Value obj_coef) {
+      _setObjCoef(col_iter_map[col], obj_coef);
+    }
+    /// \e
+    _Value getObjCoef(const Col& col) {
+      return _getObjCoef(col_iter_map[col]);
     }
 
@@ -495 +475 @@
 
     /// \e
-    _Value getPrimal(const ColIt& col_it) {
-      return _getPrimal(col_iter_map[col_it]);
+    _Value getPrimal(const Col& col) {
+      return _getPrimal(col_iter_map[col]);
     }    
 
@@ -509 +489 @@
 
     /// \e
-    typedef Expr<ColIt, _Value> Expression;
-    /// \e
-    typedef Expr<RowIt, _Value> DualExpression;
+    typedef Expr<Col, _Value> Expression;
+    /// \e
+    typedef Expr<Row, _Value> DualExpression;
+    /// \e
+    typedef Constr<Col, _Value> Constraint;
 
     //MATRIX MANIPULATING FUNCTIONS
 
     /// \e
-    void setRowCoeffs(RowIt row_it, const Expression& expr) {
+    void setRowCoeffs(Row row, const Expression& expr) {
       std::vector<std::pair<int, _Value> > row_coeffs;
       for(typename Expression::Data::const_iterator i=expr.data.begin(); 
@@ -523 +505 @@
                              (col_iter_map[(*i).first], (*i).second));
       }
-      _setRowCoeffs(row_iter_map[row_it], row_coeffs);
+      _setRowCoeffs(row_iter_map[row], row_coeffs);
+    }
+    /// \e 
+    void setRow(Row row, const Constraint& constr) {
+      setRowCoeffs(row, constr.expr);
+      setRowLowerBound(row, constr.lo);
+      setRowUpperBound(row, constr.up);
+    }
+    /// \e 
+    Row addRow(const Constraint& constr) {
+      Row row=addRow();
+      setRowCoeffs(row, constr.expr);
+      setRowLowerBound(row, constr.lo);
+      setRowUpperBound(row, constr.up);
+      return row;
     }
     /// \e
     /// This routine modifies \c expr by only adding to it.
-    void getRowCoeffs(RowIt row_it, Expression& expr) {
+    void getRowCoeffs(Row row, Expression& expr) {
       std::vector<std::pair<int, _Value> > row_coeffs;
-      _getRowCoeffs(row_iter_map[row_it], row_coeffs);
+      _getRowCoeffs(row_iter_map[row], row_coeffs);
       for(typename std::vector<std::pair<int, _Value> >::const_iterator 
             i=row_coeffs.begin(); i!=row_coeffs.end(); ++i) {
@@ -536 +532 @@
     }
     /// \e
-    void setColCoeffs(ColIt col_it, const DualExpression& expr) {
+    void setColCoeffs(Col col, const DualExpression& expr) {
       std::vector<std::pair<int, _Value> > col_coeffs;
       for(typename DualExpression::Data::const_iterator i=expr.data.begin(); 
@@ -543 +539 @@
                              (row_iter_map[(*i).first], (*i).second));
       }
-      _setColCoeffs(col_iter_map[col_it], col_coeffs);
+      _setColCoeffs(col_iter_map[col], col_coeffs);
     }
     /// \e
     /// This routine modifies \c expr by only adding to it.
-    void getColCoeffs(ColIt col_it, DualExpression& expr) {
+    void getColCoeffs(Col col, DualExpression& expr) {
       std::vector<std::pair<int, _Value> > col_coeffs;
-      _getColCoeffs(col_iter_map[col_it], col_coeffs);
+      _getColCoeffs(col_iter_map[col], col_coeffs);
       for(typename std::vector<std::pair<int, _Value> >::const_iterator 
             i=col_coeffs.begin(); i!=col_coeffs.end(); ++i) {
@@ -590 +586 @@
     LPGLPK() : Parent(), 
                         lp(lpx_create_prob()) {
-      int_row_map.push_back(RowIt());
-      int_col_map.push_back(ColIt());
+      int_row_map.push_back(Row());
+      int_col_map.push_back(Col());
       lpx_set_int_parm(lp, LPX_K_DUAL, 1);
     }
@@ -992 +988 @@
       }
     }
-    /// Returns the status of the slack variable assigned to row \c row_it.
-    int getRowStat(const RowIt& row_it) { 
-      return lpx_get_row_stat(lp, row_iter_map[row_it]); 
+    /// Returns the status of the slack variable assigned to row \c row.
+    int getRowStat(const Row& row) { 
+      return lpx_get_row_stat(lp, row_iter_map[row]); 
     }
     /// \e
@@ -1006 +1002 @@
       }
     }
-    /// Returns the status of the variable assigned to column \c col_it.
-    int getColStat(const ColIt& col_it) { 
-      return lpx_get_col_stat(lp, col_iter_map[col_it]); 
+    /// Returns the status of the variable assigned to column \c col.
+    int getColStat(const Col& col) { 
+      return lpx_get_col_stat(lp, col_iter_map[col]); 
     }
     /// \e