This way it works also when both GLPK and CPLEX are enabled.
2 * src/lemon/lp_base.h - Part of LEMON, a generic C++ optimization library
4 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
5 * (Egervary Research Group on Combinatorial Optimization, EGRES).
7 * Permission to use, modify and distribute this software is granted
8 * provided that this copyright notice appears in all copies. For
9 * precise terms see the accompanying LICENSE file.
11 * This software is provided "AS IS" with no warranty of any kind,
12 * express or implied, and with no claim as to its suitability for any
17 #ifndef LEMON_LP_BASE_H
18 #define LEMON_LP_BASE_H
25 #include<lemon/utility.h>
26 #include<lemon/error.h>
27 #include<lemon/invalid.h>
29 //#include"lin_expr.h"
32 ///\brief The interface of the LP solver interface.
33 ///\ingroup gen_opt_group
36 ///Internal data structure to convert floating id's to fix one's
38 ///\todo This might be implemented to be also usable in other places.
41 std::vector<int> index;
42 std::vector<int> cross;
45 _FixId() : first_free(-1) {};
46 ///Convert a floating id to a fix one
48 ///\param n is a floating id
49 ///\return the corresponding fix id
50 int fixId(int n) {return cross[n];}
51 ///Convert a fix id to a floating one
53 ///\param n is a fix id
54 ///\return the corresponding floating id
55 int floatingId(int n) { return index[n];}
56 ///Add a new floating id.
58 ///\param n is a floating id
59 ///\return the fix id of the new value
60 ///\todo Multiple additions should also be handled.
63 if(n>=int(cross.size())) {
66 cross[n]=index.size();
71 int next=index[first_free];
77 ///\todo Create an own exception type.
78 else throw LogicError(); //floatingId-s must form a continuous range;
82 ///\param n is a fix id
89 for(int i=fl+1;i<int(cross.size());++i) {
95 ///An upper bound on the largest fix id.
97 ///\todo Do we need this?
99 std::size_t maxFixId() { return cross.size()-1; }
103 ///Common base class for LP solvers
105 ///\todo Much more docs
106 ///\ingroup gen_opt_group
112 enum SolveExitStatus {
120 enum SolutionStatus {
121 ///Feasible solution has'n been found (but may exist).
123 ///\todo NOTFOUND might be a better name.
126 ///The problem has no feasible solution
128 ///Feasible solution found
130 ///Optimal solution exists and found
132 ///The cost function is unbounded
134 ///\todo Give a feasible solution and an infinite ray (and the
135 ///corresponding bases)
139 ///The floating point type used by the solver
140 typedef double Value;
141 ///The infinity constant
142 static const Value INF;
143 ///The not a number constant
144 static const Value NaN;
146 ///Refer to a column of the LP.
148 ///This type is used to refer to a column of the LP.
150 ///Its value remains valid and correct even after the addition or erase of
153 ///\todo Document what can one do with a Col (INVALID, comparing,
154 ///it is similar to Node/Edge)
158 friend class LpSolverBase;
160 typedef Value ExprValue;
161 typedef True LpSolverCol;
163 Col(const Invalid&) : id(-1) {}
164 bool operator<(Col c) const {return id<c.id;}
165 bool operator==(Col c) const {return id==c.id;}
166 bool operator!=(Col c) const {return id==c.id;}
169 ///Refer to a row of the LP.
171 ///This type is used to refer to a row of the LP.
173 ///Its value remains valid and correct even after the addition or erase of
176 ///\todo Document what can one do with a Row (INVALID, comparing,
177 ///it is similar to Node/Edge)
181 friend class LpSolverBase;
183 typedef Value ExprValue;
184 typedef True LpSolverRow;
186 Row(const Invalid&) : id(-1) {}
187 typedef True LpSolverRow;
188 bool operator<(Row c) const {return id<c.id;}
189 bool operator==(Row c) const {return id==c.id;}
190 bool operator!=(Row c) const {return id==c.id;}
193 ///Linear expression of variables and a constant component
195 ///This data structure strores a linear expression of the variables
196 ///(\ref Col "Col"s) and also has a constant component.
198 ///There are several ways to access and modify the contents of this
200 ///- Its it fully compatible with \c std::map<Col,double>, so for expamle
201 ///if \c e is an Expr and \c v and \c w are of type \ref Col, then you can
202 ///read and modify the coefficients like
209 ///or you can also iterate through its elements.
212 ///for(LpSolverBase::Expr::iterator i=e.begin();i!=e.end();++i)
215 ///(This code computes the sum of all coefficients).
216 ///- Numbers (<tt>double</tt>'s)
217 ///and variables (\ref Col "Col"s) directly convert to an
218 ///\ref Expr and the usual linear operations are defined so
221 ///2*v-3.12*(v-w/2)+2
222 ///v*2.1+(3*v+(v*12+w+6)*3)/2
224 ///are valid \ref Expr "Expr"essions.
225 ///The usual assignment operations are also defined.
228 ///e+=2*v-3.12*(v-w/2)+2;
232 ///- The constant member can be set and read by \ref constComp()
235 ///double c=e.constComp();
238 ///\note \ref clear() not only sets all coefficients to 0 but also
239 ///clears the constant components.
243 class Expr : public std::map<Col,Value>
246 typedef LpSolverBase::Col Key;
247 typedef LpSolverBase::Value Value;
250 typedef std::map<Col,Value> Base;
254 typedef True IsLinExpression;
256 Expr() : Base(), const_comp(0) { }
258 Expr(const Key &v) : const_comp(0) {
259 Base::insert(std::make_pair(v, 1));
262 Expr(const Value &v) : const_comp(v) {}
264 void set(const Key &v,const Value &c) {
265 Base::insert(std::make_pair(v, c));
268 Value &constComp() { return const_comp; }
270 const Value &constComp() const { return const_comp; }
272 ///Removes the components with zero coefficient.
274 for (Base::iterator i=Base::begin(); i!=Base::end();) {
277 if ((*i).second==0) Base::erase(i);
282 ///Sets all coefficients and the constant component to 0.
289 Expr &operator+=(const Expr &e) {
290 for (Base::const_iterator j=e.begin(); j!=e.end(); ++j)
291 (*this)[j->first]+=j->second;
292 ///\todo it might be speeded up using "hints"
293 const_comp+=e.const_comp;
297 Expr &operator-=(const Expr &e) {
298 for (Base::const_iterator j=e.begin(); j!=e.end(); ++j)
299 (*this)[j->first]-=j->second;
300 const_comp-=e.const_comp;
304 Expr &operator*=(const Value &c) {
305 for (Base::iterator j=Base::begin(); j!=Base::end(); ++j)
311 Expr &operator/=(const Value &c) {
312 for (Base::iterator j=Base::begin(); j!=Base::end(); ++j)
321 ///This data stucture represents a linear constraint in the LP.
322 ///Basically it is a linear expression with a lower or an upper bound
323 ///(or both). These parts of the constraint can be obtained by the member
324 ///functions \ref expr(), \ref lowerBound() and \ref upperBound(),
326 ///There are two ways to construct a constraint.
327 ///- You can set the linear expression and the bounds directly
328 /// by the functions above.
329 ///- The operators <tt>\<=</tt>, <tt>==</tt> and <tt>\>=</tt>
330 /// are defined between expressions, or even between constraints whenever
331 /// it makes sense. Therefore if \c e and \c f are linear expressions and
332 /// \c s and \c t are numbers, then the followings are valid expressions
333 /// and thus they can be used directly e.g. in \ref addRow() whenever
341 ///\warning The validity of a constraint is checked only at run time, so
342 ///e.g. \ref addRow(<tt>x[1]\<=x[2]<=5</tt>) will compile, but will throw a
343 ///\ref LogicError exception.
347 typedef LpSolverBase::Expr Expr;
348 typedef Expr::Key Key;
349 typedef Expr::Value Value;
351 // static const Value INF;
352 // static const Value NaN;
359 Constr() : _expr(), _lb(NaN), _ub(NaN) {}
361 Constr(Value lb,const Expr &e,Value ub) :
362 _expr(e), _lb(lb), _ub(ub) {}
364 Constr(const Expr &e,Value ub) :
365 _expr(e), _lb(NaN), _ub(ub) {}
367 Constr(Value lb,const Expr &e) :
368 _expr(e), _lb(lb), _ub(NaN) {}
370 Constr(const Expr &e) :
371 _expr(e), _lb(NaN), _ub(NaN) {}
379 ///Reference to the linear expression
380 Expr &expr() { return _expr; }
381 ///Cont reference to the linear expression
382 const Expr &expr() const { return _expr; }
383 ///Reference to the lower bound.
386 ///- -\ref INF: the constraint is lower unbounded.
387 ///- -\ref NaN: lower bound has not been set.
388 ///- finite number: the lower bound
389 Value &lowerBound() { return _lb; }
390 ///The const version of \ref lowerBound()
391 const Value &lowerBound() const { return _lb; }
392 ///Reference to the upper bound.
395 ///- -\ref INF: the constraint is upper unbounded.
396 ///- -\ref NaN: upper bound has not been set.
397 ///- finite number: the upper bound
398 Value &upperBound() { return _ub; }
399 ///The const version of \ref upperBound()
400 const Value &upperBound() const { return _ub; }
401 ///Is the constraint lower bounded?
402 bool lowerBounded() const {
404 return isfinite(_lb);
406 ///Is the constraint upper bounded?
407 bool upperBounded() const {
409 return isfinite(_ub);
418 //Abstract virtual functions
419 virtual LpSolverBase &_newLp() = 0;
420 virtual LpSolverBase &_copyLp() = 0;
422 virtual int _addCol() = 0;
423 virtual int _addRow() = 0;
424 virtual void _setRowCoeffs(int i,
427 Value const * values ) = 0;
428 virtual void _setColCoeffs(int i,
431 Value const * values ) = 0;
432 virtual void _setColLowerBound(int i, Value value) = 0;
433 virtual void _setColUpperBound(int i, Value value) = 0;
434 virtual void _setRowLowerBound(int i, Value value) = 0;
435 virtual void _setRowUpperBound(int i, Value value) = 0;
436 virtual void _setRowBounds(int i, Value lower, Value upper) = 0;
437 virtual void _setObjCoeff(int i, Value obj_coef) = 0;
438 virtual void _clearObj()=0;
439 // virtual void _setObj(int length,
440 // int const * indices,
441 // Value const * values ) = 0;
442 virtual SolveExitStatus _solve() = 0;
443 virtual Value _getPrimal(int i) = 0;
444 virtual Value _getPrimalValue() = 0;
445 virtual SolutionStatus _getPrimalStatus() = 0;
446 virtual void _setMax() = 0;
447 virtual void _setMin() = 0;
449 //Own protected stuff
451 //Constant component of the objective function
452 Value obj_const_comp;
460 LpSolverBase() : obj_const_comp(0) {}
463 virtual ~LpSolverBase() {}
465 ///Creates a new LP problem
466 LpSolverBase &newLp() {return _newLp();}
467 ///Makes a copy of the LP problem
468 LpSolverBase ©Lp() {return _copyLp();}
470 ///\name Build up and modify of the LP
474 ///Add a new empty column (i.e a new variable) to the LP
475 Col addCol() { Col c; c.id=cols.insert(_addCol()); return c;}
477 ///\brief Adds several new columns
478 ///(i.e a variables) at once
480 ///This magic function takes a container as its argument
481 ///and fills its elements
482 ///with new columns (i.e. variables)
484 ///- a standard STL compatible iterable container with
485 ///\ref Col as its \c values_type
488 ///std::vector<LpSolverBase::Col>
489 ///std::list<LpSolverBase::Col>
491 ///- a standard STL compatible iterable container with
492 ///\ref Col as its \c mapped_type
495 ///std::map<AnyType,LpSolverBase::Col>
497 ///- an iterable lemon \ref concept::WriteMap "write map" like
499 ///ListGraph::NodeMap<LpSolverBase::Col>
500 ///ListGraph::EdgeMap<LpSolverBase::Col>
502 ///\return The number of the created column.
505 int addColSet(T &t) { return 0;}
508 typename enable_if<typename T::value_type::LpSolverCol,int>::type
509 addColSet(T &t,dummy<0> = 0) {
511 for(typename T::iterator i=t.begin();i!=t.end();++i) {*i=addCol();s++;}
515 typename enable_if<typename T::value_type::second_type::LpSolverCol,
517 addColSet(T &t,dummy<1> = 1) {
519 for(typename T::iterator i=t.begin();i!=t.end();++i) {
526 typename enable_if<typename T::ValueSet::value_type::LpSolverCol,
528 addColSet(T &t,dummy<2> = 2) {
529 ///\bug <tt>return addColSet(t.valueSet());</tt> should also work.
531 for(typename T::ValueSet::iterator i=t.valueSet().begin();
532 i!=t.valueSet().end();
542 ///Add a new empty row (i.e a new constaint) to the LP
544 ///This function adds a new empty row (i.e a new constaint) to the LP.
545 ///\return The created row
546 Row addRow() { Row r; r.id=rows.insert(_addRow()); return r;}
548 ///Set a row (i.e a constaint) of the LP
550 ///\param r is the row to be modified
551 ///\param l is lower bound (-\ref INF means no bound)
552 ///\param e is a linear expression (see \ref Expr)
553 ///\param u is the upper bound (\ref INF means no bound)
554 ///\bug This is a temportary function. The interface will change to
556 ///\todo Option to control whether a constraint with a single variable is
558 void setRow(Row r, Value l,const Expr &e, Value u) {
559 std::vector<int> indices;
560 std::vector<Value> values;
561 indices.push_back(0);
563 for(Expr::const_iterator i=e.begin(); i!=e.end(); ++i)
564 if((*i).second!=0) { ///\bug EPSILON would be necessary here!!!
565 indices.push_back(cols.floatingId((*i).first.id));
566 values.push_back((*i).second);
568 _setRowCoeffs(rows.floatingId(r.id),indices.size()-1,
569 &indices[0],&values[0]);
570 _setRowLowerBound(rows.floatingId(r.id),l-e.constComp());
571 _setRowUpperBound(rows.floatingId(r.id),u-e.constComp());
574 ///Set a row (i.e a constaint) of the LP
576 ///\param r is the row to be modified
577 ///\param c is a linear expression (see \ref Constr)
578 void setRow(Row r, const Constr &c) {
580 c.lowerBounded()?c.lowerBound():-INF,
582 c.upperBounded()?c.upperBound():INF);
585 ///Add a new row (i.e a new constaint) to the LP
587 ///\param l is the lower bound (-\ref INF means no bound)
588 ///\param e is a linear expression (see \ref Expr)
589 ///\param u is the upper bound (\ref INF means no bound)
590 ///\return The created row.
591 ///\bug This is a temportary function. The interface will change to
593 Row addRow(Value l,const Expr &e, Value u) {
599 ///Add a new row (i.e a new constaint) to the LP
601 ///\param c is a linear expression (see \ref Constr)
602 ///\return The created row.
603 Row addRow(const Constr &c) {
609 /// Set the lower bound of a column (i.e a variable)
611 /// The upper bound of a variable (column) has to be given by an
612 /// extended number of type Value, i.e. a finite number of type
613 /// Value or -\ref INF.
614 void colLowerBound(Col c, Value value) {
615 _setColLowerBound(cols.floatingId(c.id),value);
617 /// Set the upper bound of a column (i.e a variable)
619 /// The upper bound of a variable (column) has to be given by an
620 /// extended number of type Value, i.e. a finite number of type
621 /// Value or \ref INF.
622 void colUpperBound(Col c, Value value) {
623 _setColUpperBound(cols.floatingId(c.id),value);
625 /// Set the lower and the upper bounds of a column (i.e a variable)
627 /// The lower and the upper bounds of
628 /// a variable (column) have to be given by an
629 /// extended number of type Value, i.e. a finite number of type
630 /// Value, -\ref INF or \ref INF.
631 void colBounds(Col c, Value lower, Value upper) {
632 _setColLowerBound(cols.floatingId(c.id),lower);
633 _setColUpperBound(cols.floatingId(c.id),upper);
636 /// Set the lower bound of a row (i.e a constraint)
638 /// The lower bound of a linear expression (row) has to be given by an
639 /// extended number of type Value, i.e. a finite number of type
640 /// Value or -\ref INF.
641 void rowLowerBound(Row r, Value value) {
642 _setRowLowerBound(rows.floatingId(r.id),value);
644 /// Set the upper bound of a row (i.e a constraint)
646 /// The upper bound of a linear expression (row) has to be given by an
647 /// extended number of type Value, i.e. a finite number of type
648 /// Value or \ref INF.
649 void rowUpperBound(Row r, Value value) {
650 _setRowUpperBound(rows.floatingId(r.id),value);
652 /// Set the lower and the upper bounds of a row (i.e a variable)
654 /// The lower and the upper bounds of
655 /// a constraint (row) have to be given by an
656 /// extended number of type Value, i.e. a finite number of type
657 /// Value, -\ref INF or \ref INF.
658 void rowBounds(Row c, Value lower, Value upper) {
659 _setRowBounds(rows.floatingId(c.id),lower, upper);
660 // _setRowUpperBound(rows.floatingId(c.id),upper);
663 ///Set an element of the objective function
664 void objCoeff(Col c, Value v) {_setObjCoeff(cols.floatingId(c.id),v); };
665 ///Set the objective function
667 ///\param e is a linear expression of type \ref Expr.
668 ///\bug The previous objective function is not cleared!
669 void setObj(Expr e) {
671 for (Expr::iterator i=e.begin(); i!=e.end(); ++i)
672 objCoeff((*i).first,(*i).second);
673 obj_const_comp=e.constComp();
677 void max() { _setMax(); }
679 void min() { _setMin(); }
685 ///\name Solve the LP
690 SolveExitStatus solve() { return _solve(); }
694 ///\name Obtain the solution
699 SolutionStatus primalStatus() {
700 return _getPrimalStatus();
704 Value primal(Col c) { return _getPrimal(cols.floatingId(c.id)); }
709 ///- \ref INF or -\ref INF means either infeasibility or unboundedness
710 /// of the primal problem, depending on whether we minimize or maximize.
711 ///- \ref NaN if no primal solution is found.
712 ///- The (finite) objective value if an optimal solution is found.
713 Value primalValue() { return _getPrimalValue()+obj_const_comp;}
720 ///\relates LpSolverBase::Expr
722 inline LpSolverBase::Expr operator+(const LpSolverBase::Expr &a,
723 const LpSolverBase::Expr &b)
725 LpSolverBase::Expr tmp(a);
726 tmp+=b; ///\todo Doesn't STL have some special 'merge' algorithm?
731 ///\relates LpSolverBase::Expr
733 inline LpSolverBase::Expr operator-(const LpSolverBase::Expr &a,
734 const LpSolverBase::Expr &b)
736 LpSolverBase::Expr tmp(a);
737 tmp-=b; ///\todo Doesn't STL have some special 'merge' algorithm?
742 ///\relates LpSolverBase::Expr
744 inline LpSolverBase::Expr operator*(const LpSolverBase::Expr &a,
745 const LpSolverBase::Value &b)
747 LpSolverBase::Expr tmp(a);
748 tmp*=b; ///\todo Doesn't STL have some special 'merge' algorithm?
754 ///\relates LpSolverBase::Expr
756 inline LpSolverBase::Expr operator*(const LpSolverBase::Value &a,
757 const LpSolverBase::Expr &b)
759 LpSolverBase::Expr tmp(b);
760 tmp*=a; ///\todo Doesn't STL have some special 'merge' algorithm?
765 ///\relates LpSolverBase::Expr
767 inline LpSolverBase::Expr operator/(const LpSolverBase::Expr &a,
768 const LpSolverBase::Value &b)
770 LpSolverBase::Expr tmp(a);
771 tmp/=b; ///\todo Doesn't STL have some special 'merge' algorithm?
777 ///\relates LpSolverBase::Constr
779 inline LpSolverBase::Constr operator<=(const LpSolverBase::Expr &e,
780 const LpSolverBase::Expr &f)
782 return LpSolverBase::Constr(-LpSolverBase::INF,e-f,0);
787 ///\relates LpSolverBase::Constr
789 inline LpSolverBase::Constr operator<=(const LpSolverBase::Value &e,
790 const LpSolverBase::Expr &f)
792 return LpSolverBase::Constr(e,f);
797 ///\relates LpSolverBase::Constr
799 inline LpSolverBase::Constr operator<=(const LpSolverBase::Expr &e,
800 const LpSolverBase::Value &f)
802 return LpSolverBase::Constr(e,f);
807 ///\relates LpSolverBase::Constr
809 inline LpSolverBase::Constr operator>=(const LpSolverBase::Expr &e,
810 const LpSolverBase::Expr &f)
812 return LpSolverBase::Constr(-LpSolverBase::INF,f-e,0);
818 ///\relates LpSolverBase::Constr
820 inline LpSolverBase::Constr operator>=(const LpSolverBase::Value &e,
821 const LpSolverBase::Expr &f)
823 return LpSolverBase::Constr(f,e);
829 ///\relates LpSolverBase::Constr
831 inline LpSolverBase::Constr operator>=(const LpSolverBase::Expr &e,
832 const LpSolverBase::Value &f)
834 return LpSolverBase::Constr(f,e);
839 ///\relates LpSolverBase::Constr
841 inline LpSolverBase::Constr operator==(const LpSolverBase::Expr &e,
842 const LpSolverBase::Expr &f)
844 return LpSolverBase::Constr(0,e-f,0);
849 ///\relates LpSolverBase::Constr
851 inline LpSolverBase::Constr operator<=(const LpSolverBase::Value &n,
852 const LpSolverBase::Constr&c)
854 LpSolverBase::Constr tmp(c);
855 ///\todo Create an own exception type.
856 if(!isnan(tmp.lowerBound())) throw LogicError();
857 else tmp.lowerBound()=n;
862 ///\relates LpSolverBase::Constr
864 inline LpSolverBase::Constr operator<=(const LpSolverBase::Constr& c,
865 const LpSolverBase::Value &n)
867 LpSolverBase::Constr tmp(c);
868 ///\todo Create an own exception type.
869 if(!isnan(tmp.upperBound())) throw LogicError();
870 else tmp.upperBound()=n;
876 ///\relates LpSolverBase::Constr
878 inline LpSolverBase::Constr operator>=(const LpSolverBase::Value &n,
879 const LpSolverBase::Constr&c)
881 LpSolverBase::Constr tmp(c);
882 ///\todo Create an own exception type.
883 if(!isnan(tmp.upperBound())) throw LogicError();
884 else tmp.upperBound()=n;
889 ///\relates LpSolverBase::Constr
891 inline LpSolverBase::Constr operator>=(const LpSolverBase::Constr& c,
892 const LpSolverBase::Value &n)
894 LpSolverBase::Constr tmp(c);
895 ///\todo Create an own exception type.
896 if(!isnan(tmp.lowerBound())) throw LogicError();
897 else tmp.lowerBound()=n;
904 #endif //LEMON_LP_BASE_H