RhodeCode

      e.simplify();

      _setRowCoeffs(rows(id(r)), ExprIterator(e.comps.begin(), cols),

                    ExprIterator(e.comps.end(), cols));

      _setRowLowerBound(rows(id(r)),l - *e);

      _setRowUpperBound(rows(id(r)),u - *e);

    }

    ///Set a row (i.e a constraint) of the LP

    ///\param r is the row to be modified

    ///\param c is a linear expression (see \ref Constr)

    void row(Row r, const Constr &c) {

      row(r, c.lowerBounded()?c.lowerBound():-INF,

          c.expr(), c.upperBounded()?c.upperBound():INF);

    }

    ///Get a row (i.e a constraint) of the LP

    ///\param r is the row to get

    ///\return the expression associated to the row

    Expr row(Row r) const {

      Expr e;

      _getRowCoeffs(rows(id(r)), InsertIterator(e.comps, cols));

      return e;

    }

    ///Add a new row (i.e a new constraint) to the LP

    ///\param l is the lower bound (-\ref INF means no bound)

    ///\param e is a linear expression (see \ref Expr)

    ///\param u is the upper bound (\ref INF means no bound)

    ///\return The created row.

    Row addRow(Value l,const Expr &e, Value u) {

      Row r;

      e.simplify();

      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),

                                ExprIterator(e.comps.end(), cols), u - *e));

      return r;

    }

    ///Add a new row (i.e a new constraint) to the LP

    ///\param c is a linear expression (see \ref Constr)

    ///\return The created row.

    Row addRow(const Constr &c) {

      Row r;

      c.expr().simplify();

                                ExprIterator(c.expr().comps.begin(), cols),

                                ExprIterator(c.expr().comps.end(), cols),

      return r;

    }

    ///Erase a column (i.e a variable) from the LP

    ///\param c is the column to be deleted

    void erase(Col c) {

      _eraseCol(cols(id(c)));

      _eraseColId(cols(id(c)));

    }

    ///Erase a row (i.e a constraint) from the LP

    ///\param r is the row to be deleted

    void erase(Row r) {

      _eraseRow(rows(id(r)));

      _eraseRowId(rows(id(r)));

    }

    /// Get the name of a column

    ///\param c is the coresponding column

    ///\return The name of the colunm

    std::string colName(Col c) const {

      std::string name;

      _getColName(cols(id(c)), name);

      return name;

    }

    /// Set the name of a column

    ///\param c is the coresponding column

    ///\param name The name to be given

    void colName(Col c, const std::string& name) {

      _setColName(cols(id(c)), name);

    }

    /// Get the column by its name

    ///\param name The name of the column

    ///\return the proper column or \c INVALID

    Col colByName(const std::string& name) const {

      int k = _colByName(name);

      return k != -1 ? Col(cols[k]) : Col(INVALID);

    }

    /// Get the name of a row

    ///\param r is the coresponding row

    ///\return The name of the row