lemon-0.x: comparison src/work/marci/lp/lp_solver

equal deleted inserted replaced

-:83ba47e3d0bf
+:5c774b4e1fcd
 //UNCATEGORIZED
 /// \e
 typedef _Value Value;
 /// \e
-typedef IterablePartition<int>::ClassIt RowIt;
+typedef IterablePartition<int>::ClassIt Row;
 /// \e
-typedef IterablePartition<int>::ClassIt ColIt;
+typedef IterablePartition<int>::ClassIt Col;
 public:
 /// \e
 IterablePartition<int> row_iter_map;
 /// \e
 IterablePartition<int> col_iter_map;
 /// \e
-std::vector<RowIt> int_row_map;
+std::vector<Row> int_row_map;
 /// \e
-std::vector<ColIt> int_col_map;
+std::vector<Col> int_col_map;
 /// \e
 const int VALID_CLASS;
 /// \e
 const int INVALID_CLASS;
 /// \e
 virtual void printPrimalStatus(int i) = 0;
 /// \e
 virtual int getDualStatus() = 0;
 /// \e
 virtual void printDualStatus(int i) = 0;
-/// Returns the status of the slack variable assigned to row \c row_it.
+/// Returns the status of the slack variable assigned to row \c row.
-virtual int getRowStat(const RowIt& row_it) = 0;
+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.
+/// Returns the status of the variable assigned to column \c col.
-virtual int getColStat(const ColIt& col_it) = 0;
+virtual int getColStat(const Col& col) = 0;
 /// \e
 virtual void printColStatus(int i) = 0;
 //@}
 public:
 //MATRIX MANIPULATING FUNCTIONS
 /// \e
-ColIt addCol() {
+Col addCol() {
 int i=_addCol();
-ColIt col_it;
+Col col;
-col_iter_map.first(col_it, INVALID_CLASS);
+col_iter_map.first(col, INVALID_CLASS);
-if (col_iter_map.valid(col_it)) { //van hasznalhato hely
+if (col_iter_map.valid(col)) { //van hasznalhato hely
-	col_iter_map.set(col_it, INVALID_CLASS, VALID_CLASS);
+	col_iter_map.set(col, INVALID_CLASS, VALID_CLASS);
-	col_iter_map[col_it]=i;
+	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);
+	col=col_iter_map.push_back(i, VALID_CLASS);
 }
-int_col_map.push_back(col_it);
+int_col_map.push_back(col);
-return col_it;
+return col;
 }
 /// \e
-RowIt addRow() {
+Row addRow() {
 int i=_addRow();
-RowIt row_it;
+Row row;
-row_iter_map.first(row_it, INVALID_CLASS);
+row_iter_map.first(row, INVALID_CLASS);
-if (row_iter_map.valid(row_it)) { //van hasznalhato hely
+if (row_iter_map.valid(row)) { //van hasznalhato hely
-	row_iter_map.set(row_it, INVALID_CLASS, VALID_CLASS);
+	row_iter_map.set(row, INVALID_CLASS, VALID_CLASS);
-	row_iter_map[row_it]=i;
+	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);
+	row=row_iter_map.push_back(i, VALID_CLASS);
 }
-int_row_map.push_back(row_it);
+int_row_map.push_back(row);
-return row_it;
+return row;
 }
 /// \e
-void eraseCol(const ColIt& col_it) {
+void eraseCol(const Col& col) {
-col_iter_map.set(col_it, VALID_CLASS, INVALID_CLASS);
+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??
+col_iter_map[col]=0; //glpk specifikus, de kell ez??
-ColIt it;
+Col it;
 for (col_iter_map.first(it, VALID_CLASS);
 	   col_iter_map.valid(it); col_iter_map.next(it)) {
 	if (col_iter_map[it]>cols[1]) --col_iter_map[it];
 }
 int_col_map.erase(int_col_map.begin()+cols[1]);
 }
 /// \e
-void eraseRow(const RowIt& row_it) {
+void eraseRow(const Row& row) {
-row_iter_map.set(row_it, VALID_CLASS, INVALID_CLASS);
+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??
+row_iter_map[row]=0; //glpk specifikus, de kell ez??
-RowIt it;
+Row it;
 for (row_iter_map.first(it, VALID_CLASS);
 	   row_iter_map.valid(it); row_iter_map.next(it)) {
 	if (row_iter_map[it]>rows[1]) --row_iter_map[it];
 }
 int_row_map.erase(int_row_map.begin()+rows[1]);
 }
 /// \e
-template <typename Begin, typename End>
+void setColLowerBound(Col col, _Value lo) {
-void setRowCoeffs(RowIt row_it, Begin begin, End end) {
+_setColLowerBound(col_iter_map[col], lo);
-std::vector<std::pair<int, double> > coeffs;
+}
-for ( ; begin!=end; ++begin) {
+/// \e
-	coeffs.push_back(std::
+_Value getColLowerBound(Col col) {
-			 make_pair(col_iter_map[begin->first], begin->second));
+return _getColLowerBound(col_iter_map[col]);
 }
-_setRowCoeffs(row_iter_map[row_it], coeffs);
+/// \e
-}
+void setColUpperBound(Col col, _Value up) {
-/// \e
+_setColUpperBound(col_iter_map[col], up);
-template <typename Begin, typename End>
+}
-void setColCoeffs(ColIt col_it, Begin begin, End end) {
+/// \e
-std::vector<std::pair<int, double> > coeffs;
+_Value getColUpperBound(Col col) {
-for ( ; begin!=end; ++begin) {
+return _getColUpperBound(col_iter_map[col]);
-	coeffs.push_back(std::
+}
-			 make_pair(row_iter_map[begin->first], begin->second));
+/// \e
-}
+void setRowLowerBound(Row row, _Value lo) {
-_setColCoeffs(col_iter_map[col_it], coeffs);
+_setRowLowerBound(row_iter_map[row], lo);
 }
 /// \e
-void setColLowerBound(ColIt col_it, _Value lo) {
+_Value getRowLowerBound(Row row) {
-_setColLowerBound(col_iter_map[col_it], lo);
+return _getRowLowerBound(row_iter_map[row]);
 }
 /// \e
-_Value getColLowerBound(ColIt col_it) {
+void setRowUpperBound(Row row, _Value up) {
-return _getColLowerBound(col_iter_map[col_it]);
+_setRowUpperBound(row_iter_map[row], up);
 }
 /// \e
-void setColUpperBound(ColIt col_it, _Value up) {
+_Value getRowUpperBound(Row row) {
-_setColUpperBound(col_iter_map[col_it], up);
+return _getRowUpperBound(row_iter_map[row]);
 }
 /// \e
-_Value getColUpperBound(ColIt col_it) {
+void setObjCoef(const Col& col, _Value obj_coef) {
-return _getColUpperBound(col_iter_map[col_it]);
+_setObjCoef(col_iter_map[col], obj_coef);
 }
 /// \e
-void setRowLowerBound(RowIt row_it, _Value lo) {
+_Value getObjCoef(const Col& col) {
-_setRowLowerBound(row_iter_map[row_it], lo);
+return _getObjCoef(col_iter_map[col]);
-}
-/// \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]);
 }
 //SOLUTION RETRIEVING FUNCTIONS
 /// \e
-_Value getPrimal(const ColIt& col_it) {
+_Value getPrimal(const Col& col) {
-return _getPrimal(col_iter_map[col_it]);
+return _getPrimal(col_iter_map[col]);
 }
 //@}
 /*! @name User friend interface
 //@{
 //EXPRESSION TYPES
 /// \e
-typedef Expr<ColIt, _Value> Expression;
+typedef Expr<Col, _Value> Expression;
 /// \e
-typedef Expr<RowIt, _Value> DualExpression;
+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();
 	  i!=expr.data.end(); ++i) {
 	row_coeffs.push_back(std::make_pair
 			     (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) {
 	expr+= (*i).second*int_col_map[(*i).first];
 }
 }
 /// \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();
 	  i!=expr.data.end(); ++i) {
 	col_coeffs.push_back(std::make_pair
 			     (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) {
 	expr+= (*i).second*int_row_map[(*i).first];
 }
 }
 public:
 /// \e
 LPGLPK() : Parent(),
 			lp(lpx_create_prob()) {
-int_row_map.push_back(RowIt());
+int_row_map.push_back(Row());
-int_col_map.push_back(ColIt());
+int_col_map.push_back(Col());
 lpx_set_int_parm(lp, LPX_K_DUAL, 1);
 }
 /// \e
 ~LPGLPK() {
 lpx_delete_prob(lp);
 case LPX_D_FEAS: cout << "LPX_D_FEAS" << endl; break;
 case LPX_D_INFEAS: cout << "LPX_D_INFEAS" << endl; break;
 case LPX_D_NOFEAS: cout << "LPX_D_NOFEAS" << endl; break;
 }
 }
-/// Returns the status of the slack variable assigned to row \c row_it.
+/// Returns the status of the slack variable assigned to row \c row.
-int getRowStat(const RowIt& row_it) {
+int getRowStat(const Row& row) {
-return lpx_get_row_stat(lp, row_iter_map[row_it]);
+return lpx_get_row_stat(lp, row_iter_map[row]);
 }
 /// \e
 void printRowStatus(int i) {
 switch (i) {
 case LPX_BS: cout << "LPX_BS" << endl; break;
 case LPX_NU: cout << "LPX_NU" << endl; break;
 case LPX_NF: cout << "LPX_NF" << endl; break;
 case LPX_NS: cout << "LPX_NS" << endl; break;
 }
 }
-/// Returns the status of the variable assigned to column \c col_it.
+/// Returns the status of the variable assigned to column \c col.
-int getColStat(const ColIt& col_it) {
+int getColStat(const Col& col) {
-return lpx_get_col_stat(lp, col_iter_map[col_it]);
+return lpx_get_col_stat(lp, col_iter_map[col]);
 }
 /// \e
 void printColStatus(int i) {
 switch (i) {
 case LPX_BS: cout << "LPX_BS" << endl; break;

changeset 1151	b217fc69f913
parent 1143	4fb22cfa5759
child 1152	1765ff9fefa1