COIN-OR::LEMON - Graph Library

source: lemon-0.x/src/lemon/lp_base.h @ 1397:30828157ae80

Last change on this file since 1397:30828157ae80 was 1397:30828157ae80, checked in by Alpar Juttner, 19 years ago

For the sake of cygwin...

File size: 24.9 KB
RevLine 
[1247]1/* -*- C++ -*-
[1253]2 * src/lemon/lp_base.h - Part of LEMON, a generic C++ optimization library
[1247]3 *
4 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
[1359]5 * (Egervary Research Group on Combinatorial Optimization, EGRES).
[1247]6 *
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.
10 *
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
13 * purpose.
14 *
15 */
16
[1246]17#ifndef LEMON_LP_BASE_H
18#define LEMON_LP_BASE_H
19
[1253]20#include<vector>
[1272]21#include<map>
[1256]22#include<limits>
[1397]23#include<cmath>
[1253]24
[1256]25#include<lemon/utility.h>
[1253]26#include<lemon/error.h>
[1256]27#include<lemon/invalid.h>
[1253]28
[1272]29//#include"lin_expr.h"
30
[1246]31///\file
32///\brief The interface of the LP solver interface.
[1328]33///\ingroup gen_opt_group
[1246]34namespace lemon {
[1253]35 
36  ///Internal data structure to convert floating id's to fix one's
37   
[1279]38  ///\todo This might be implemented to be also usable in other places.
[1253]39  class _FixId
40  {
41    std::vector<int> index;
42    std::vector<int> cross;
43    int first_free;
44  public:
45    _FixId() : first_free(-1) {};
46    ///Convert a floating id to a fix one
47
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
52
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.
57
58    ///\param n is a floating id
59    ///\return the fix id of the new value
60    ///\todo Multiple additions should also be handled.
61    int insert(int n)
62    {
63      if(n>=int(cross.size())) {
64        cross.resize(n+1);
65        if(first_free==-1) {
66          cross[n]=index.size();
67          index.push_back(n);
68        }
69        else {
70          cross[n]=first_free;
71          int next=index[first_free];
72          index[first_free]=n;
73          first_free=next;
74        }
[1256]75        return cross[n];
[1253]76      }
[1273]77      ///\todo Create an own exception type.
[1253]78      else throw LogicError(); //floatingId-s must form a continuous range;
79    }
80    ///Remove a fix id.
81
82    ///\param n is a fix id
83    ///
84    void erase(int n)
85    {
86      int fl=index[n];
87      index[n]=first_free;
88      first_free=n;
89      for(int i=fl+1;i<int(cross.size());++i) {
90        cross[i-1]=cross[i];
91        index[cross[i]]--;
92      }
93      cross.pop_back();
94    }
95    ///An upper bound on the largest fix id.
96
97    ///\todo Do we need this?
98    ///
99    std::size_t maxFixId() { return cross.size()-1; }
100 
101  };
102   
103  ///Common base class for LP solvers
[1328]104 
105  ///\todo Much more docs
106  ///\ingroup gen_opt_group
[1246]107  class LpSolverBase {
[1323]108
[1247]109  public:
110
[1263]111    ///\e
[1303]112    enum SolveExitStatus {
[1263]113      ///\e
[1293]114      SOLVED = 0,
[1263]115      ///\e
[1293]116      UNSOLVED = 1
[1291]117    };
118     
119    ///\e
[1303]120    enum SolutionStatus {
[1295]121      ///Feasible solution has'n been found (but may exist).
122
123      ///\todo NOTFOUND might be a better name.
124      ///
[1293]125      UNDEFINED = 0,
[1295]126      ///The problem has no feasible solution
[1293]127      INFEASIBLE = 1,
[1295]128      ///Feasible solution found
[1293]129      FEASIBLE = 2,
[1295]130      ///Optimal solution exists and found
131      OPTIMAL = 3,
132      ///The cost function is unbounded
133
134      ///\todo Give a feasible solution and an infinite ray (and the
135      ///corresponding bases)
136      INFINITE = 4
[1263]137    };
138     
[1256]139    ///The floating point type used by the solver
[1247]140    typedef double Value;
[1256]141    ///The infinity constant
[1247]142    static const Value INF;
[1264]143    ///The not a number constant
144    static const Value NaN;
[1253]145   
[1256]146    ///Refer to a column of the LP.
147
148    ///This type is used to refer to a column of the LP.
149    ///
150    ///Its value remains valid and correct even after the addition or erase of
[1273]151    ///other columns.
[1256]152    ///
153    ///\todo Document what can one do with a Col (INVALID, comparing,
154    ///it is similar to Node/Edge)
155    class Col {
156    protected:
157      int id;
158      friend class LpSolverBase;
159    public:
[1259]160      typedef Value ExprValue;
[1256]161      typedef True LpSolverCol;
162      Col() {}
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;}
167    };
168
169    ///Refer to a row of the LP.
170
171    ///This type is used to refer to a row of the LP.
172    ///
173    ///Its value remains valid and correct even after the addition or erase of
[1273]174    ///other rows.
[1256]175    ///
176    ///\todo Document what can one do with a Row (INVALID, comparing,
177    ///it is similar to Node/Edge)
178    class Row {
179    protected:
180      int id;
181      friend class LpSolverBase;
182    public:
[1259]183      typedef Value ExprValue;
[1256]184      typedef True LpSolverRow;
185      Row() {}
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;}
191   };
[1259]192   
[1279]193    ///Linear expression of variables and a constant component
194   
195    ///This data structure strores a linear expression of the variables
196    ///(\ref Col "Col"s) and also has a constant component.
197    ///
198    ///There are several ways to access and modify the contents of this
199    ///container.
200    ///- Its it fully compatible with \c std::map<Col,double>, so for expamle
[1364]201    ///if \c e is an Expr and \c v and \c w are of type \ref Col, then you can
[1279]202    ///read and modify the coefficients like
203    ///these.
204    ///\code
205    ///e[v]=5;
206    ///e[v]+=12;
207    ///e.erase(v);
208    ///\endcode
209    ///or you can also iterate through its elements.
210    ///\code
211    ///double s=0;
212    ///for(LpSolverBase::Expr::iterator i=e.begin();i!=e.end();++i)
213    ///  s+=i->second;
214    ///\endcode
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 
219    ///\code
220    ///v+w
221    ///2*v-3.12*(v-w/2)+2
222    ///v*2.1+(3*v+(v*12+w+6)*3)/2
223    ///\endcode
[1328]224    ///are valid \ref Expr "Expr"essions.
225    ///The usual assignment operations are also defined.
[1279]226    ///\code
227    ///e=v+w;
228    ///e+=2*v-3.12*(v-w/2)+2;
229    ///e*=3.4;
230    ///e/=5;
231    ///\endcode
232    ///- The constant member can be set and read by \ref constComp()
233    ///\code
234    ///e.constComp()=12;
235    ///double c=e.constComp();
236    ///\endcode
237    ///
[1328]238    ///\note \ref clear() not only sets all coefficients to 0 but also
[1279]239    ///clears the constant components.
[1328]240    ///
241    ///\sa Constr
242    ///
[1273]243    class Expr : public std::map<Col,Value>
[1272]244    {
245    public:
[1273]246      typedef LpSolverBase::Col Key;
247      typedef LpSolverBase::Value Value;
[1272]248     
249    protected:
[1273]250      typedef std::map<Col,Value> Base;
[1272]251     
[1273]252      Value const_comp;
[1272]253  public:
254      typedef True IsLinExpression;
255      ///\e
256      Expr() : Base(), const_comp(0) { }
257      ///\e
[1273]258      Expr(const Key &v) : const_comp(0) {
[1272]259        Base::insert(std::make_pair(v, 1));
260      }
261      ///\e
[1273]262      Expr(const Value &v) : const_comp(v) {}
[1272]263      ///\e
[1273]264      void set(const Key &v,const Value &c) {
[1272]265        Base::insert(std::make_pair(v, c));
266      }
267      ///\e
[1273]268      Value &constComp() { return const_comp; }
[1272]269      ///\e
[1273]270      const Value &constComp() const { return const_comp; }
[1272]271     
272      ///Removes the components with zero coefficient.
273      void simplify() {
274        for (Base::iterator i=Base::begin(); i!=Base::end();) {
275          Base::iterator j=i;
276          ++j;
277          if ((*i).second==0) Base::erase(i);
278          j=i;
279        }
280      }
[1273]281
282      ///Sets all coefficients and the constant component to 0.
283      void clear() {
284        Base::clear();
285        const_comp=0;
286      }
287
[1272]288      ///\e
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;
294        return *this;
295      }
296      ///\e
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;
301        return *this;
302      }
303      ///\e
[1273]304      Expr &operator*=(const Value &c) {
[1272]305        for (Base::iterator j=Base::begin(); j!=Base::end(); ++j)
306          j->second*=c;
307        const_comp*=c;
308        return *this;
309      }
310      ///\e
[1273]311      Expr &operator/=(const Value &c) {
[1272]312        for (Base::iterator j=Base::begin(); j!=Base::end(); ++j)
313          j->second/=c;
314        const_comp/=c;
315        return *this;
316      }
317    };
318   
[1264]319    ///Linear constraint
[1328]320
[1364]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(),
325    ///respectively.
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
334    ///  it makes sense.
335    ///  \code
336    ///  e<=s
337    ///  e<=f
338    ///  s<=e<=t
339    ///  e>=t
340    ///  \endcode
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.
[1272]344    class Constr
345    {
346    public:
347      typedef LpSolverBase::Expr Expr;
[1273]348      typedef Expr::Key Key;
349      typedef Expr::Value Value;
[1272]350     
[1364]351//       static const Value INF;
352//       static const Value NaN;
353
[1273]354    protected:
355      Expr _expr;
356      Value _lb,_ub;
357    public:
358      ///\e
359      Constr() : _expr(), _lb(NaN), _ub(NaN) {}
360      ///\e
361      Constr(Value lb,const Expr &e,Value ub) :
362        _expr(e), _lb(lb), _ub(ub) {}
363      ///\e
364      Constr(const Expr &e,Value ub) :
365        _expr(e), _lb(NaN), _ub(ub) {}
366      ///\e
367      Constr(Value lb,const Expr &e) :
368        _expr(e), _lb(lb), _ub(NaN) {}
369      ///\e
[1272]370      Constr(const Expr &e) :
[1273]371        _expr(e), _lb(NaN), _ub(NaN) {}
372      ///\e
373      void clear()
374      {
375        _expr.clear();
376        _lb=_ub=NaN;
377      }
[1364]378
379      ///Reference to the linear expression
[1273]380      Expr &expr() { return _expr; }
[1364]381      ///Cont reference to the linear expression
[1273]382      const Expr &expr() const { return _expr; }
[1364]383      ///Reference to the lower bound.
384
385      ///\return
386      ///- -\ref INF: the constraint is lower unbounded.
387      ///- -\ref NaN: lower bound has not been set.
388      ///- finite number: the lower bound
[1273]389      Value &lowerBound() { return _lb; }
[1364]390      ///The const version of \ref lowerBound()
[1273]391      const Value &lowerBound() const { return _lb; }
[1364]392      ///Reference to the upper bound.
393
394      ///\return
395      ///- -\ref INF: the constraint is upper unbounded.
396      ///- -\ref NaN: upper bound has not been set.
397      ///- finite number: the upper bound
[1273]398      Value &upperBound() { return _ub; }
[1364]399      ///The const version of \ref upperBound()
[1273]400      const Value &upperBound() const { return _ub; }
[1364]401      ///Is the constraint lower bounded?
[1295]402      bool lowerBounded() const {
403        using namespace std;
[1397]404        return finite(_lb);
[1295]405      }
[1364]406      ///Is the constraint upper bounded?
[1295]407      bool upperBounded() const {
408        using namespace std;
[1397]409        return finite(_ub);
[1295]410      }
[1272]411    };
412   
[1253]413
414  protected:
415    _FixId rows;
416    _FixId cols;
[1246]417
[1323]418    //Abstract virtual functions
[1364]419    virtual LpSolverBase &_newLp() = 0;
420    virtual LpSolverBase &_copyLp() = 0;
421
[1246]422    virtual int _addCol() = 0;
423    virtual int _addRow() = 0;
424    virtual void _setRowCoeffs(int i,
[1251]425                               int length,
[1247]426                               int  const * indices,
427                               Value  const * values ) = 0;
[1246]428    virtual void _setColCoeffs(int i,
[1251]429                               int length,
[1247]430                               int  const * indices,
431                               Value  const * values ) = 0;
[1294]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;
[1379]436    virtual void _setRowBounds(int i, Value lower, Value upper) = 0;
[1294]437    virtual void _setObjCoeff(int i, Value obj_coef) = 0;
[1377]438    virtual void _clearObj()=0;
439//     virtual void _setObj(int length,
440//                          int  const * indices,
441//                          Value  const * values ) = 0;
[1303]442    virtual SolveExitStatus _solve() = 0;
[1294]443    virtual Value _getPrimal(int i) = 0;
[1312]444    virtual Value _getPrimalValue() = 0;
445    virtual SolutionStatus _getPrimalStatus() = 0;
446    virtual void _setMax() = 0;
447    virtual void _setMin() = 0;
448   
[1323]449    //Own protected stuff
450   
451    //Constant component of the objective function
452    Value obj_const_comp;
453   
[1377]454
455
[1323]456   
[1253]457  public:
458
[1323]459    ///\e
460    LpSolverBase() : obj_const_comp(0) {}
[1253]461
462    ///\e
463    virtual ~LpSolverBase() {}
464
[1364]465    ///Creates a new LP problem
466    LpSolverBase &newLp() {return _newLp();}
[1381]467    ///Makes a copy of the LP problem
[1364]468    LpSolverBase &copyLp() {return _copyLp();}
469   
[1294]470    ///\name Build up and modify of the LP
[1263]471
472    ///@{
473
[1253]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;}
[1263]476
[1294]477    ///\brief Adds several new columns
478    ///(i.e a variables) at once
[1256]479    ///
[1273]480    ///This magic function takes a container as its argument
[1256]481    ///and fills its elements
482    ///with new columns (i.e. variables)
[1273]483    ///\param t can be
484    ///- a standard STL compatible iterable container with
485    ///\ref Col as its \c values_type
486    ///like
487    ///\code
488    ///std::vector<LpSolverBase::Col>
489    ///std::list<LpSolverBase::Col>
490    ///\endcode
491    ///- a standard STL compatible iterable container with
492    ///\ref Col as its \c mapped_type
493    ///like
494    ///\code
[1364]495    ///std::map<AnyType,LpSolverBase::Col>
[1273]496    ///\endcode
497    ///- an iterable lemon \ref concept::WriteMap "write map" like
498    ///\code
499    ///ListGraph::NodeMap<LpSolverBase::Col>
500    ///ListGraph::EdgeMap<LpSolverBase::Col>
501    ///\endcode
[1256]502    ///\return The number of the created column.
503#ifdef DOXYGEN
504    template<class T>
505    int addColSet(T &t) { return 0;}
506#else
507    template<class T>
508    typename enable_if<typename T::value_type::LpSolverCol,int>::type
509    addColSet(T &t,dummy<0> = 0) {
510      int s=0;
511      for(typename T::iterator i=t.begin();i!=t.end();++i) {*i=addCol();s++;}
512      return s;
513    }
514    template<class T>
515    typename enable_if<typename T::value_type::second_type::LpSolverCol,
516                       int>::type
517    addColSet(T &t,dummy<1> = 1) {
518      int s=0;
519      for(typename T::iterator i=t.begin();i!=t.end();++i) {
520        i->second=addCol();
521        s++;
522      }
523      return s;
524    }
[1272]525    template<class T>
526    typename enable_if<typename T::ValueSet::value_type::LpSolverCol,
527                       int>::type
528    addColSet(T &t,dummy<2> = 2) {
529      ///\bug <tt>return addColSet(t.valueSet());</tt> should also work.
530      int s=0;
531      for(typename T::ValueSet::iterator i=t.valueSet().begin();
532          i!=t.valueSet().end();
533          ++i)
534        {
535          *i=addCol();
536          s++;
537        }
538      return s;
539    }
[1256]540#endif
[1263]541
[1253]542    ///Add a new empty row (i.e a new constaint) to the LP
[1258]543
544    ///This function adds a new empty row (i.e a new constaint) to the LP.
545    ///\return The created row
[1253]546    Row addRow() { Row r; r.id=rows.insert(_addRow()); return r;}
547
[1258]548    ///Set a row (i.e a constaint) of the LP
[1253]549
[1258]550    ///\param r is the row to be modified
[1259]551    ///\param l is lower bound (-\ref INF means no bound)
[1258]552    ///\param e is a linear expression (see \ref Expr)
[1259]553    ///\param u is the upper bound (\ref INF means no bound)
[1253]554    ///\bug This is a temportary function. The interface will change to
555    ///a better one.
[1328]556    ///\todo Option to control whether a constraint with a single variable is
557    ///added or not.
[1258]558    void setRow(Row r, Value l,const Expr &e, Value u) {
[1253]559      std::vector<int> indices;
560      std::vector<Value> values;
561      indices.push_back(0);
562      values.push_back(0);
[1258]563      for(Expr::const_iterator i=e.begin(); i!=e.end(); ++i)
[1256]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);
567        }
[1253]568      _setRowCoeffs(rows.floatingId(r.id),indices.size()-1,
569                    &indices[0],&values[0]);
[1256]570      _setRowLowerBound(rows.floatingId(r.id),l-e.constComp());
571      _setRowUpperBound(rows.floatingId(r.id),u-e.constComp());
[1258]572    }
573
[1264]574    ///Set a row (i.e a constaint) of the LP
575
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) {
[1273]579      setRow(r,
[1275]580             c.lowerBounded()?c.lowerBound():-INF,
[1273]581             c.expr(),
[1275]582             c.upperBounded()?c.upperBound():INF);
[1264]583    }
584
[1258]585    ///Add a new row (i.e a new constaint) to the LP
586
[1259]587    ///\param l is the lower bound (-\ref INF means no bound)
[1258]588    ///\param e is a linear expression (see \ref Expr)
[1259]589    ///\param u is the upper bound (\ref INF means no bound)
[1258]590    ///\return The created row.
591    ///\bug This is a temportary function. The interface will change to
592    ///a better one.
593    Row addRow(Value l,const Expr &e, Value u) {
594      Row r=addRow();
595      setRow(r,l,e,u);
[1253]596      return r;
597    }
598
[1264]599    ///Add a new row (i.e a new constaint) to the LP
600
601    ///\param c is a linear expression (see \ref Constr)
602    ///\return The created row.
603    Row addRow(const Constr &c) {
604      Row r=addRow();
605      setRow(r,c);
606      return r;
607    }
608
[1253]609    /// Set the lower bound of a column (i.e a variable)
610
[1293]611    /// The upper bound of a variable (column) has to be given by an
[1253]612    /// extended number of type Value, i.e. a finite number of type
[1259]613    /// Value or -\ref INF.
[1293]614    void colLowerBound(Col c, Value value) {
[1253]615      _setColLowerBound(cols.floatingId(c.id),value);
616    }
617    /// Set the upper bound of a column (i.e a variable)
618
[1293]619    /// The upper bound of a variable (column) has to be given by an
[1253]620    /// extended number of type Value, i.e. a finite number of type
[1259]621    /// Value or \ref INF.
[1293]622    void colUpperBound(Col c, Value value) {
[1253]623      _setColUpperBound(cols.floatingId(c.id),value);
624    };
[1293]625    /// Set the lower and the upper bounds of a column (i.e a variable)
626
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);
634    }
635   
[1253]636    /// Set the lower bound of a row (i.e a constraint)
637
[1293]638    /// The lower bound of a linear expression (row) has to be given by an
[1253]639    /// extended number of type Value, i.e. a finite number of type
[1259]640    /// Value or -\ref INF.
[1293]641    void rowLowerBound(Row r, Value value) {
[1253]642      _setRowLowerBound(rows.floatingId(r.id),value);
643    };
644    /// Set the upper bound of a row (i.e a constraint)
645
[1293]646    /// The upper bound of a linear expression (row) has to be given by an
[1253]647    /// extended number of type Value, i.e. a finite number of type
[1259]648    /// Value or \ref INF.
[1293]649    void rowUpperBound(Row r, Value value) {
[1253]650      _setRowUpperBound(rows.floatingId(r.id),value);
651    };
[1293]652    /// Set the lower and the upper bounds of a row (i.e a variable)
653
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) {
[1379]659      _setRowBounds(rows.floatingId(c.id),lower, upper);
660      // _setRowUpperBound(rows.floatingId(c.id),upper);
[1293]661    }
662   
[1253]663    ///Set an element of the objective function
[1293]664    void objCoeff(Col c, Value v) {_setObjCoeff(cols.floatingId(c.id),v); };
[1253]665    ///Set the objective function
666   
667    ///\param e is a linear expression of type \ref Expr.
[1323]668    ///\bug The previous objective function is not cleared!
[1253]669    void setObj(Expr e) {
[1377]670      _clearObj();
[1253]671      for (Expr::iterator i=e.begin(); i!=e.end(); ++i)
[1293]672        objCoeff((*i).first,(*i).second);
[1323]673      obj_const_comp=e.constComp();
[1253]674    }
[1263]675
[1312]676    ///Maximize
677    void max() { _setMax(); }
678    ///Minimize
679    void min() { _setMin(); }
680
681   
[1263]682    ///@}
683
684
[1294]685    ///\name Solve the LP
[1263]686
687    ///@{
688
689    ///\e
[1303]690    SolveExitStatus solve() { return _solve(); }
[1263]691   
692    ///@}
693   
[1294]694    ///\name Obtain the solution
[1263]695
696    ///@{
697
698    ///\e
[1312]699    SolutionStatus primalStatus() {
700      return _getPrimalStatus();
[1294]701    }
702
703    ///\e
[1293]704    Value primal(Col c) { return _getPrimal(cols.floatingId(c.id)); }
[1263]705
[1312]706    ///\e
707
708    ///\return
709    ///- \ref INF or -\ref INF means either infeasibility or unboundedness
710    /// of the primal problem, depending on whether we minimize or maximize.
[1364]711    ///- \ref NaN if no primal solution is found.
[1312]712    ///- The (finite) objective value if an optimal solution is found.
[1323]713    Value primalValue() { return _getPrimalValue()+obj_const_comp;}
[1263]714    ///@}
[1253]715   
[1248]716  }; 
[1246]717
[1272]718  ///\e
719 
720  ///\relates LpSolverBase::Expr
721  ///
722  inline LpSolverBase::Expr operator+(const LpSolverBase::Expr &a,
723                                      const LpSolverBase::Expr &b)
724  {
725    LpSolverBase::Expr tmp(a);
[1364]726    tmp+=b; ///\todo Doesn't STL have some special 'merge' algorithm?
[1272]727    return tmp;
728  }
729  ///\e
730 
731  ///\relates LpSolverBase::Expr
732  ///
733  inline LpSolverBase::Expr operator-(const LpSolverBase::Expr &a,
734                                      const LpSolverBase::Expr &b)
735  {
736    LpSolverBase::Expr tmp(a);
[1364]737    tmp-=b; ///\todo Doesn't STL have some special 'merge' algorithm?
[1272]738    return tmp;
739  }
740  ///\e
741 
742  ///\relates LpSolverBase::Expr
743  ///
744  inline LpSolverBase::Expr operator*(const LpSolverBase::Expr &a,
[1273]745                                      const LpSolverBase::Value &b)
[1272]746  {
747    LpSolverBase::Expr tmp(a);
[1364]748    tmp*=b; ///\todo Doesn't STL have some special 'merge' algorithm?
[1272]749    return tmp;
750  }
751 
752  ///\e
753 
754  ///\relates LpSolverBase::Expr
755  ///
[1273]756  inline LpSolverBase::Expr operator*(const LpSolverBase::Value &a,
[1272]757                                      const LpSolverBase::Expr &b)
758  {
759    LpSolverBase::Expr tmp(b);
[1364]760    tmp*=a; ///\todo Doesn't STL have some special 'merge' algorithm?
[1272]761    return tmp;
762  }
763  ///\e
764 
765  ///\relates LpSolverBase::Expr
766  ///
767  inline LpSolverBase::Expr operator/(const LpSolverBase::Expr &a,
[1273]768                                      const LpSolverBase::Value &b)
[1272]769  {
770    LpSolverBase::Expr tmp(a);
[1364]771    tmp/=b; ///\todo Doesn't STL have some special 'merge' algorithm?
[1272]772    return tmp;
773  }
774 
775  ///\e
776 
777  ///\relates LpSolverBase::Constr
778  ///
779  inline LpSolverBase::Constr operator<=(const LpSolverBase::Expr &e,
780                                         const LpSolverBase::Expr &f)
781  {
782    return LpSolverBase::Constr(-LpSolverBase::INF,e-f,0);
783  }
784
785  ///\e
786 
787  ///\relates LpSolverBase::Constr
788  ///
[1273]789  inline LpSolverBase::Constr operator<=(const LpSolverBase::Value &e,
[1272]790                                         const LpSolverBase::Expr &f)
791  {
792    return LpSolverBase::Constr(e,f);
793  }
794
795  ///\e
796 
797  ///\relates LpSolverBase::Constr
798  ///
799  inline LpSolverBase::Constr operator<=(const LpSolverBase::Expr &e,
[1273]800                                         const LpSolverBase::Value &f)
[1272]801  {
802    return LpSolverBase::Constr(e,f);
803  }
804
805  ///\e
806 
807  ///\relates LpSolverBase::Constr
808  ///
809  inline LpSolverBase::Constr operator>=(const LpSolverBase::Expr &e,
810                                         const LpSolverBase::Expr &f)
811  {
812    return LpSolverBase::Constr(-LpSolverBase::INF,f-e,0);
813  }
814
815
816  ///\e
817 
818  ///\relates LpSolverBase::Constr
819  ///
[1273]820  inline LpSolverBase::Constr operator>=(const LpSolverBase::Value &e,
[1272]821                                         const LpSolverBase::Expr &f)
822  {
823    return LpSolverBase::Constr(f,e);
824  }
825
826
827  ///\e
828 
829  ///\relates LpSolverBase::Constr
830  ///
831  inline LpSolverBase::Constr operator>=(const LpSolverBase::Expr &e,
[1273]832                                         const LpSolverBase::Value &f)
[1272]833  {
834    return LpSolverBase::Constr(f,e);
835  }
836
837  ///\e
838 
839  ///\relates LpSolverBase::Constr
840  ///
841  inline LpSolverBase::Constr operator==(const LpSolverBase::Expr &e,
842                                         const LpSolverBase::Expr &f)
843  {
844    return LpSolverBase::Constr(0,e-f,0);
845  }
846
847  ///\e
848 
849  ///\relates LpSolverBase::Constr
850  ///
[1273]851  inline LpSolverBase::Constr operator<=(const LpSolverBase::Value &n,
[1272]852                                         const LpSolverBase::Constr&c)
853  {
854    LpSolverBase::Constr tmp(c);
[1273]855    ///\todo Create an own exception type.
856    if(!isnan(tmp.lowerBound())) throw LogicError();
857    else tmp.lowerBound()=n;
[1272]858    return tmp;
859  }
860  ///\e
861 
862  ///\relates LpSolverBase::Constr
863  ///
864  inline LpSolverBase::Constr operator<=(const LpSolverBase::Constr& c,
[1273]865                                         const LpSolverBase::Value &n)
[1272]866  {
867    LpSolverBase::Constr tmp(c);
[1273]868    ///\todo Create an own exception type.
869    if(!isnan(tmp.upperBound())) throw LogicError();
870    else tmp.upperBound()=n;
[1272]871    return tmp;
872  }
873
874  ///\e
875 
876  ///\relates LpSolverBase::Constr
877  ///
[1273]878  inline LpSolverBase::Constr operator>=(const LpSolverBase::Value &n,
[1272]879                                         const LpSolverBase::Constr&c)
880  {
881    LpSolverBase::Constr tmp(c);
[1273]882    ///\todo Create an own exception type.
883    if(!isnan(tmp.upperBound())) throw LogicError();
884    else tmp.upperBound()=n;
[1272]885    return tmp;
886  }
887  ///\e
888 
889  ///\relates LpSolverBase::Constr
890  ///
891  inline LpSolverBase::Constr operator>=(const LpSolverBase::Constr& c,
[1273]892                                         const LpSolverBase::Value &n)
[1272]893  {
894    LpSolverBase::Constr tmp(c);
[1273]895    ///\todo Create an own exception type.
896    if(!isnan(tmp.lowerBound())) throw LogicError();
897    else tmp.lowerBound()=n;
[1272]898    return tmp;
899  }
900
901
[1246]902} //namespace lemon
903
904#endif //LEMON_LP_BASE_H
Note: See TracBrowser for help on using the repository browser.