COIN-OR::LEMON - Graph Library

Changeset 2364:3a5e67bd42d2 in lemon-0.x for lemon/lp_base.h


Ignore:
Timestamp:
02/15/07 20:15:14 (13 years ago)
Author:
Balazs Dezso
Branch:
default
Phase:
public
Convert:
svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@3175
Message:

Lp row and col getter function
lp section reader and writer for lemon IO

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/lp_base.h

    r2363 r2364  
    5050   
    5151  public:
    52 
     52   
    5353    ///Possible outcomes of an LP solving procedure
    5454    enum SolveExitStatus {
     
    123123      friend class LpSolverBase;
    124124      friend class MipSolverBase;
     125      explicit Col(int _id) : id(_id) {}
    125126    public:
    126127      typedef Value ExprValue;
     
    166167      int id;
    167168      friend class LpSolverBase;
     169      explicit Row(int _id) : id(_id) {}
    168170    public:
    169171      typedef Value ExprValue;
     
    178180    };
    179181
     182    class RowIt : public Row {
     183      LpSolverBase *_lp;
     184    public:
     185      RowIt() {}
     186      RowIt(LpSolverBase &lp) : _lp(&lp)
     187      {
     188        _lp->rows.firstFix(id);
     189      }
     190      RowIt(const Invalid&) : Row(INVALID) {}
     191      RowIt &operator++()
     192      {
     193        _lp->rows.nextFix(id);
     194        return *this;
     195      }
     196    };
     197
    180198    static int id(const Row& row) { return row.id; }
    181199
     
    188206    int _lpId(const Row& row) const {
    189207      return rows.floatingId(id(row));
     208    }
     209
     210    Col _item(int id, Col) const {
     211      return Col(cols.fixId(id));
     212    }
     213
     214    Row _item(int id, Row) const {
     215      return Row(rows.fixId(id));
    190216    }
    191217
     
    582608  private:
    583609
    584     template <typename _Base>
    585     class MappedIterator {
     610    template <typename _Expr>
     611    class MappedOutputIterator {
    586612    public:
    587613
    588       typedef _Base Base;
     614      typedef std::insert_iterator<_Expr> Base;
     615
     616      typedef std::output_iterator_tag iterator_category;
     617      typedef void difference_type;
     618      typedef void value_type;
     619      typedef void reference;
     620      typedef void pointer;
     621     
     622      MappedOutputIterator(const Base& _base, const LpSolverBase& _lp)
     623        : base(_base), lp(_lp) {}
     624
     625      MappedOutputIterator& operator*() {
     626        return *this;
     627      }
     628
     629      MappedOutputIterator& operator=(const std::pair<int, Value>& value) {
     630        *base = std::make_pair(lp._item(value.first, typename _Expr::Key()),
     631                               value.second);
     632        return *this;
     633      }
     634
     635      MappedOutputIterator& operator++() {
     636        ++base;
     637        return *this;
     638      }
     639
     640      MappedOutputIterator operator++(int) {
     641        MappedOutputIterator tmp(*this);
     642        ++base;
     643        return tmp;
     644      }
     645
     646      bool operator==(const MappedOutputIterator& it) const {
     647        return base == it.base;
     648      }
     649
     650      bool operator!=(const MappedOutputIterator& it) const {
     651        return base != it.base;
     652      }
     653
     654    private:
     655      Base base;
     656      const LpSolverBase& lp;
     657    };
     658
     659    template <typename Expr>
     660    class MappedInputIterator {
     661    public:
     662
     663      typedef typename Expr::const_iterator Base;
    589664
    590665      typedef typename Base::iterator_category iterator_category;
     
    600675      };
    601676
    602       MappedIterator(const Base& _base, const LpSolverBase& _lp)
     677      MappedInputIterator(const Base& _base, const LpSolverBase& _lp)
    603678        : base(_base), lp(_lp) {}
    604679
     
    611686      }
    612687
    613       MappedIterator& operator++() {
     688      MappedInputIterator& operator++() {
    614689        ++base;
    615690        return *this;
    616691      }
    617692
    618       MappedIterator& operator++(int) {
    619         MappedIterator tmp(*this);
     693      MappedInputIterator operator++(int) {
     694        MappedInputIterator tmp(*this);
    620695        ++base;
    621696        return tmp;
    622697      }
    623698
    624       bool operator==(const MappedIterator& it) const {
     699      bool operator==(const MappedInputIterator& it) const {
    625700        return base == it.base;
    626701      }
    627702
    628       bool operator!=(const MappedIterator& it) const {
     703      bool operator!=(const MappedInputIterator& it) const {
    629704        return base != it.base;
    630705      }
     
    638713
    639714    /// STL compatible iterator for lp col
    640     typedef MappedIterator<Expr::const_iterator> LpRowIterator;
     715    typedef MappedInputIterator<Expr> ConstRowIterator;
    641716    /// STL compatible iterator for lp row
    642     typedef MappedIterator<DualExpr::const_iterator> LpColIterator;
     717    typedef MappedInputIterator<DualExpr> ConstColIterator;
     718
     719    /// STL compatible iterator for lp col
     720    typedef MappedOutputIterator<Expr> RowIterator;
     721    /// STL compatible iterator for lp row
     722    typedef MappedOutputIterator<DualExpr> ColIterator;
    643723
    644724    //Abstract virtual functions
     
    660740    virtual void _getColName(int col, std::string & name) = 0;
    661741    virtual void _setColName(int col, const std::string & name) = 0;
    662     virtual void _setRowCoeffs(int i, LpRowIterator b, LpRowIterator e) = 0;
    663     virtual void _setColCoeffs(int i, LpColIterator b, LpColIterator e) = 0;
     742    virtual void _setRowCoeffs(int i, ConstRowIterator b,
     743                               ConstRowIterator e) = 0;
     744    virtual void _getRowCoeffs(int i, RowIterator b) = 0;
     745    virtual void _setColCoeffs(int i, ConstColIterator b,
     746                               ConstColIterator e) = 0;
     747    virtual void _getColCoeffs(int i, ColIterator b) = 0;
    664748    virtual void _setCoeff(int row, int col, Value value) = 0;
    665749    virtual Value _getCoeff(int row, int col) = 0;
    666 
    667750    virtual void _setColLowerBound(int i, Value value) = 0;
    668751    virtual Value _getColLowerBound(int i) = 0;
     
    787870    void col(Col c,const DualExpr &e) {
    788871      e.simplify();
    789       _setColCoeffs(_lpId(c), LpColIterator(e.begin(), *this),
    790                     LpColIterator(e.end(), *this));
     872      _setColCoeffs(_lpId(c), ConstColIterator(e.begin(), *this),
     873                    ConstColIterator(e.end(), *this));
     874    }
     875
     876    ///Get a column (i.e a dual constraint) of the LP
     877
     878    ///\param r is the column to get
     879    ///\return the dual expression associated to the column
     880    DualExpr col(Col c) {
     881      DualExpr e;
     882      _getColCoeffs(_lpId(c), ColIterator(std::inserter(e, e.end()), *this));
     883      return e;
    791884    }
    792885
     
    884977    void row(Row r, Value l,const Expr &e, Value u) {
    885978      e.simplify();
    886       _setRowCoeffs(_lpId(r), LpRowIterator(e.begin(), *this),
    887                     LpRowIterator(e.end(), *this));
    888        _setRowBounds(_lpId(r),l-e.constComp(),u-e.constComp());
     979      _setRowCoeffs(_lpId(r), ConstRowIterator(e.begin(), *this),
     980                    ConstRowIterator(e.end(), *this));
     981      _setRowBounds(_lpId(r),l-e.constComp(),u-e.constComp());
    889982    }
    890983
     
    896989      row(r, c.lowerBounded()?c.lowerBound():-INF,
    897990          c.expr(), c.upperBounded()?c.upperBound():INF);
     991    }
     992
     993   
     994    ///Get a row (i.e a constraint) of the LP
     995
     996    ///\param r is the row to get
     997    ///\return the expression associated to the row
     998    Expr row(Row r) {
     999      Expr e;
     1000      _getRowCoeffs(_lpId(r), RowIterator(std::inserter(e, e.end()), *this));
     1001      return e;
    8981002    }
    8991003
     
    11781282    }
    11791283
     1284    ///Get the objective function
     1285
     1286    ///\return the objective function as a linear expression of type \ref Expr.
     1287    Expr obj() {
     1288      Expr e;
     1289      for (ColIt it(*this); it != INVALID; ++it) {
     1290        double c = objCoeff(it);
     1291        if (c != 0.0) {
     1292          e.insert(std::make_pair(it, c));
     1293        }
     1294      }
     1295      return e;
     1296    }
     1297   
     1298
    11801299    ///Maximize
    11811300    void max() { _setMax(); }
Note: See TracChangeset for help on using the changeset viewer.