Changeset 1895:5b01801efbc0 in lemon-0.x for lemon/lp_base.h

Timestamp:

01/14/06 09:44:59 (18 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

• colName() added (untested on CPLEX)
• possibility to set lower/upper bounds of several cols at once
• setObj() -> obj()
• setRow() -> row()

File:

• lemon/lp_base.h (modified) (11 diffs)

lemon/lp_base.h

@@ -573 +573 @@
     virtual void _eraseCol(int col) = 0;
     virtual void _eraseRow(int row) = 0;
+    virtual void _getColName(int col,       std::string & name) = 0;
+    virtual void _setColName(int col, const std::string & name) = 0;
     virtual void _setRowCoeffs(int i, 
                                int length,
@@ -809 +811 @@
     ///\todo Option to control whether a constraint with a single variable is
     ///added or not.
-    void setRow(Row r, Value l,const Expr &e, Value u) {
+    void row(Row r, Value l,const Expr &e, Value u) {
       std::vector<int> indices;
       std::vector<Value> values;
@@ -830 +832 @@
     ///\param r is the row to be modified
     ///\param c is a linear expression (see \ref Constr)
-    void setRow(Row r, const Constr &c) {
-      setRow(r,
+    void row(Row r, const Constr &c) {
+      row(r,
              c.lowerBounded()?c.lowerBound():-INF,
              c.expr(),
@@ -847 +849 @@
     Row addRow(Value l,const Expr &e, Value u) {
       Row r=addRow();
-      setRow(r,l,e,u);
+      row(r,l,e,u);
       return r;
     }
@@ -857 +859 @@
     Row addRow(const Constr &c) {
       Row r=addRow();
-      setRow(r,c);
+      row(r,c);
       return r;
     }
@@ -877 +879 @@
     }
 
-    ///Set an element of the coefficient matrix of the LP
+    /// Get the name of a column
+    
+    ///\param c is the coresponding coloumn 
+    ///\return The name of the colunm
+    std::string ColName(Col c){
+      std::string name;
+      _getColName(cols.floatingId(c.id), name);
+      return name;
+    }
+    
+    /// Set the name of a column
+    
+    ///\param c is the coresponding coloumn 
+    ///\param name The name to be given
+    void ColName(Col c, const std::string & name){
+      _setColName(cols.floatingId(c.id), name);
+    }
+    
+    /// Set an element of the coefficient matrix of the LP
 
     ///\param r is the row of the element to be modified
     ///\param c is the coloumn of the element to be modified
     ///\param val is the new value of the coefficient
-    void setCoeff(Row r, Col c, Value val){
+
+    void Coeff(Row r, Col c, Value val){
       _setCoeff(rows.floatingId(r.id),cols.floatingId(c.id), val);
     }
@@ -888 +909 @@
     /// Set the lower bound of a column (i.e a variable)
 
-    /// The upper bound of a variable (column) has to be given by an 
+    /// The lower bound of a variable (column) has to be given by an 
     /// extended number of type Value, i.e. a finite number of type 
     /// Value or -\ref INF.
@@ -894 +915 @@
       _setColLowerBound(cols.floatingId(c.id),value);
     }
+    
+    ///\brief Set the lower bound of  several columns
+    ///(i.e a variables) at once
+    ///
+    ///This magic function takes a container as its argument
+    ///and applies the function on all of its elements.
+    /// The lower bound of a variable (column) has to be given by an 
+    /// extended number of type Value, i.e. a finite number of type 
+    /// Value or -\ref INF.
+#ifdef DOXYGEN
+    template<class T>
+    void colLowerBound(T &t, Value value) { return 0;} 
+#else
+    template<class T>
+    typename enable_if<typename T::value_type::LpSolverCol,void>::type
+    colLowerBound(T &t, Value value,dummy<0> = 0) {
+      for(typename T::iterator i=t.begin();i!=t.end();++i) {
+        colLowerBound(*i, value);
+      }
+    }
+    template<class T>
+    typename enable_if<typename T::value_type::second_type::LpSolverCol,
+                       void>::type
+    colLowerBound(T &t, Value value,dummy<1> = 1) { 
+      for(typename T::iterator i=t.begin();i!=t.end();++i) {
+        colLowerBound(i->second, value);
+      }
+    }
+    template<class T>
+    typename enable_if<typename T::MapIt::Value::LpSolverCol,
+                       void>::type
+    colLowerBound(T &t, Value value,dummy<2> = 2) { 
+      for(typename T::MapIt i(t); i!=INVALID; ++i){
+        colLowerBound(*i, value);
+      }
+    }
+#endif
+    
     /// Set the upper bound of a column (i.e a variable)
 
@@ -902 +961 @@
       _setColUpperBound(cols.floatingId(c.id),value);
     };
+
+    ///\brief Set the lower bound of  several columns
+    ///(i.e a variables) at once
+    ///
+    ///This magic function takes a container as its argument
+    ///and applies the function on all of its elements.
+    /// The upper bound of a variable (column) has to be given by an 
+    /// extended number of type Value, i.e. a finite number of type 
+    /// Value or \ref INF.
+#ifdef DOXYGEN
+    template<class T>
+    void colUpperBound(T &t, Value value) { return 0;} 
+#else
+    template<class T>
+    typename enable_if<typename T::value_type::LpSolverCol,void>::type
+    colUpperBound(T &t, Value value,dummy<0> = 0) {
+      for(typename T::iterator i=t.begin();i!=t.end();++i) {
+        colUpperBound(*i, value);
+      }
+    }
+    template<class T>
+    typename enable_if<typename T::value_type::second_type::LpSolverCol,
+                       void>::type
+    colUpperBound(T &t, Value value,dummy<1> = 1) { 
+      for(typename T::iterator i=t.begin();i!=t.end();++i) {
+        colUpperBound(i->second, value);
+      }
+    }
+    template<class T>
+    typename enable_if<typename T::MapIt::Value::LpSolverCol,
+                       void>::type
+    colUpperBound(T &t, Value value,dummy<2> = 2) { 
+      for(typename T::MapIt i(t); i!=INVALID; ++i){
+        colUpperBound(*i, value);
+      }
+    }
+#endif
+
     /// Set the lower and the upper bounds of a column (i.e a variable)
 
@@ -913 +1010 @@
     }
     
+    ///\brief Set the lower and the upper bound of several columns
+    ///(i.e a variables) at once
+    ///
+    ///This magic function takes a container as its argument
+    ///and applies the function on all of its elements.
+    /// The lower and the upper bounds of
+    /// a variable (column) have to be given by an 
+    /// extended number of type Value, i.e. a finite number of type 
+    /// Value, -\ref INF or \ref INF.
+#ifdef DOXYGEN
+    template<class T>
+    void colBounds(T &t, Value lower, Value upper) { return 0;} 
+#else
+    template<class T>
+    typename enable_if<typename T::value_type::LpSolverCol,void>::type
+    colBounds(T &t, Value lower, Value upper,dummy<0> = 0) {
+      for(typename T::iterator i=t.begin();i!=t.end();++i) {
+        colBounds(*i, lower, upper);
+      }
+    }
+    template<class T>
+    typename enable_if<typename T::value_type::second_type::LpSolverCol,
+                       void>::type
+    colBounds(T &t, Value lower, Value upper,dummy<1> = 1) { 
+      for(typename T::iterator i=t.begin();i!=t.end();++i) {
+        colBounds(i->second, lower, upper);
+      }
+    }
+    template<class T>
+    typename enable_if<typename T::MapIt::Value::LpSolverCol,
+                       void>::type
+    colBounds(T &t, Value lower, Value upper,dummy<2> = 2) { 
+      for(typename T::MapIt i(t); i!=INVALID; ++i){
+        colBounds(*i, lower, upper);
+      }
+    }
+#endif
+    
 //     /// Set the lower bound of a row (i.e a constraint)
 
@@ -946 +1081 @@
     
     ///\param e is a linear expression of type \ref Expr.
+    ///\bug Is should be called obj()
     void setObj(Expr e) {
       _clearObj();