RhodeCode

    virtual void _clear() = 0;

    virtual const char* _solverName() const = 0;

    //Own protected stuff

    //Constant component of the objective function

    Value obj_const_comp;

    LpBase() : rows(), cols(), obj_const_comp(0) {}

  public:

    /// Virtual destructor

    virtual ~LpBase() {}

    ///Creates a new LP problem

    LpBase* newSolver() {return _newSolver();}

    ///Makes a copy of the LP problem

    LpBase* cloneSolver() {return _cloneSolver();}

    ///Gives back the name of the solver.

    const char* solverName() const {return _solverName();}

    ///\name Build up and modify the LP

    ///@{

    ///Add a new empty column (i.e a new variable) to the LP

    Col addCol() { Col c; c._id = _addColId(_addCol()); return c;}

    ///\brief Adds several new columns (i.e variables) at once

    ///

    ///This magic function takes a container as its argument and fills

    ///its elements with new columns (i.e. variables)

    ///\param t can be

    ///- a standard STL compatible iterable container with

    ///\ref Col as its \c values_type like

    ///\code

    ///std::vector<LpBase::Col>

    ///std::list<LpBase::Col>

    ///\endcode

    ///- a standard STL compatible iterable container with

    ///\ref Col as its \c mapped_type like

    ///\code

    ///std::map<AnyType,LpBase::Col>

    ///\endcode

    ///- an iterable lemon \ref concepts::WriteMap "write map" like

    ///\code

    ///ListGraph::NodeMap<LpBase::Col>

    ///ListGraph::ArcMap<LpBase::Col>

    ///\endcode

    ///\return The number of the created column.

#ifdef DOXYGEN

    template<class T>

    int addColSet(T &t) { return 0;}

#else

    template<class T>

    typename enable_if<typename T::value_type::LpCol,int>::type

    addColSet(T &t,dummy<0> = 0) {

      int s=0;

      for(typename T::iterator i=t.begin();i!=t.end();++i) {*i=addCol();s++;}

      return s;

    }

    template<class T>

    typename enable_if<typename T::value_type::second_type::LpCol,

                       int>::type

    addColSet(T &t,dummy<1> = 1) {

      int s=0;

      for(typename T::iterator i=t.begin();i!=t.end();++i) {

        i->second=addCol();

        s++;

      }

      return s;

    }

    template<class T>

    typename enable_if<typename T::MapIt::Value::LpCol,

                       int>::type

    addColSet(T &t,dummy<2> = 2) {

      int s=0;

      for(typename T::MapIt i(t); i!=INVALID; ++i)

        {

          i.set(addCol());

          s++;

        }

      return s;

    }

#endif

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

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

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

    ///a better one.

    void col(Col c, const DualExpr &e) {

      e.simplify();

    }

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

    ///\param c is the column to get

    ///\return the dual expression associated to the column

    DualExpr col(Col c) const {

      DualExpr e;

      _getColCoeffs(cols(id(c)), InsertIterator(e.comps, rows));

      return e;

    }

    ///Add a new column to the LP

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

    ///\param o is the corresponding component of the objective

    ///function. It is 0 by default.

    ///\return The created column.

    Col addCol(const DualExpr &e, Value o = 0) {

      Col c=addCol();

      col(c,e);

      objCoeff(c,o);

      return c;

    }

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

    ///This function adds a new empty row (i.e a new constraint) to the LP.

    ///\return The created row

    Row addRow() { Row r; r._id = _addRowId(_addRow()); return r;}

    ///\brief Add several new rows (i.e constraints) at once

    ///

    ///This magic function takes a container as its argument and fills

    ///its elements with new row (i.e. variables)

    ///\param t can be

    ///- a standard STL compatible iterable container with

    ///\ref Row as its \c values_type like

    ///\code

    ///std::vector<LpBase::Row>

    ///std::list<LpBase::Row>

    ///\endcode

    ///- a standard STL compatible iterable container with

    ///\ref Row as its \c mapped_type like

    ///\code

    ///std::map<AnyType,LpBase::Row>

    ///\endcode

    ///- an iterable lemon \ref concepts::WriteMap "write map" like

    ///\code

    ///ListGraph::NodeMap<LpBase::Row>

    ///ListGraph::ArcMap<LpBase::Row>

    ///\endcode

    ///\return The number of rows created.

#ifdef DOXYGEN

    template<class T>

    int addRowSet(T &t) { return 0;}

#else

    template<class T>

    typename enable_if<typename T::value_type::LpRow,int>::type

    addRowSet(T &t, dummy<0> = 0) {

      int s=0;

      for(typename T::iterator i=t.begin();i!=t.end();++i) {*i=addRow();s++;}

      return s;

    }

    template<class T>

    typename enable_if<typename T::value_type::second_type::LpRow, int>::type

    addRowSet(T &t, dummy<1> = 1) {

      int s=0;

      for(typename T::iterator i=t.begin();i!=t.end();++i) {

        i->second=addRow();

        s++;

      }

      return s;

    }

    template<class T>

    typename enable_if<typename T::MapIt::Value::LpRow, int>::type

    addRowSet(T &t, dummy<2> = 2) {

      int s=0;

      for(typename T::MapIt i(t); i!=INVALID; ++i)

        {

          i.set(addRow());

          s++;

        }

      return s;

    }

#endif

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

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

    ///\param l is 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)

    void row(Row r, Value l, const Expr &e, Value u) {

      e.simplify();

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