protected:

   public:

     const int VALID_ID;

     const int VALID_CLASS;

     /// \e

     /// \e

     const int INVALID_ID;

     const int INVALID_CLASS;

 		     VALID_ID(0), INVALID_ID(1) { }

 		     VALID_CLASS(0), INVALID_CLASS(1) { }

     /// \e

   protected:

     virtual RowIt addRow() = 0;

     /// \e

     /// \e

     virtual int _addRow() = 0;

     virtual ColIt addCol() = 0;

     /// \e

     /// temporally, glpk style indexing

     virtual int _addCol() = 0;

     virtual void setRowCoeffs(RowIt row_it, int num, 

   public:

 			      int* indices, _Value* doubles) = 0;

     /// \e

     //pair<RowIt, _Value>-bol kell megadni egy std range-et

     RowIt addRow() {

       int i=_addRow(); 

       RowIt row_it;

       row_iter_map.first(row_it, INVALID_CLASS);

       if (row_iter_map.valid(row_it)) { //van hasznalhato hely

 	row_iter_map.set(row_it, INVALID_CLASS, VALID_CLASS);

 	row_iter_map[row_it]=i;

       } else { //a cucc vegere kell inzertalni mert nincs szabad hely

 	row_it=row_iter_map.push_back(i, VALID_CLASS);

       }

       return row_it;

     }

     /// \e

     ColIt addCol() {

       int i=_addCol();  

       ColIt col_it;

       col_iter_map.first(col_it, INVALID_CLASS);

       if (col_iter_map.valid(col_it)) { //van hasznalhato hely

 	col_iter_map.set(col_it, INVALID_CLASS, VALID_CLASS);

 	col_iter_map[col_it]=i;

       } else { //a cucc vegere kell inzertalni mert nincs szabad hely

 	col_it=col_iter_map.push_back(i, VALID_CLASS);

       }

       return col_it;

     }

     /// \e

     virtual void setRowCoeffs(int i, 

 			      std::vector<std::pair<int, double> > coeffs) = 0;

     /// \e

     virtual void setColCoeffs(int i, 

 			      std::vector<std::pair<int, double> > coeffs) = 0;

       int mem_length=1+colNum();

       std::vector<std::pair<int, double> > coeffs;

       int* indices = new int[mem_length];

       _Value* doubles = new _Value[mem_length];

       int length=0;

 	++length;

 	coeffs.push_back(std::

 	indices[length]=col_iter_map[begin->first];

 			 make_pair(col_iter_map[begin->first], begin->second));

 	doubles[length]=begin->second;

       }

       }

       setRowCoeffs(row_iter_map[row_it], coeffs);

       setRowCoeffs(row_it, length, indices, doubles);

     }

       delete [] indices;

       delete [] doubles;

     }

     /// temporally, glpk style indexing

     virtual void setColCoeffs(ColIt col_it, int num, 

 			      int* indices, _Value* doubles) = 0;

     //pair<ColIt, _Value>-bol kell megadni egy std range-et

       int mem_length=1+rowNum();

       std::vector<std::pair<int, double> > coeffs;

       int* indices = new int[mem_length];

       _Value* doubles = new _Value[mem_length];

       int length=0;

 	++length;

 	coeffs.push_back(std::

 	indices[length]=row_iter_map[begin->first];

 			 make_pair(row_iter_map[begin->first], begin->second));

 	doubles[length]=begin->second;

       }

       }

       setColCoeffs(col_iter_map[col_it], coeffs);

       setColCoeffs(col_it, length, indices, doubles);

     }

       delete [] indices;

     /// temporally, glpk style indexing

       delete [] doubles;

     //virtual void setRowCoeffs(RowIt row_it, int num, 

     }

     //		      int* indices, _Value* doubles) = 0;

     /// \e

     //pair<RowIt, _Value>-bol kell megadni egy std range-et

     virtual void eraseCol(const ColIt& col_it) = 0;

     /// \e

     /// \e

     //    virtual void seColCoeffs(int i, 

     virtual void eraseRow(const RowIt& row_it) = 0;

     //			      std::vector<std::pair<int, double> > coeffs) = 0;

     /// \e

 //     template <typename Begin, typename End>

 //     void setRowCoeffs(RowIt row_it, Begin begin, End end) {

 //       int mem_length=1+colNum();

 //       int* indices = new int[mem_length];

 //       _Value* doubles = new _Value[mem_length];

 //       int length=0;

 //       for ( ; begin!=end; ++begin) {

 // 	++length;

 // 	indices[length]=col_iter_map[begin->first];

 // 	doubles[length]=begin->second;

 //       }

 //       setRowCoeffs(row_it, length, indices, doubles);

 //       delete [] indices;

 //       delete [] doubles;

 //     } 

     /// temporally, glpk style indexing

     //virtual void setColCoeffs(ColIt col_it, int num, 

     //			      int* indices, _Value* doubles) = 0;

     //pair<ColIt, _Value>-bol kell megadni egy std range-et

     /// \e

 //     template <typename Begin, typename End>

 //     void setColCoeffs(ColIt col_it, Begin begin, End end) {

 //       int mem_length=1+rowNum();

 //       int* indices = new int[mem_length];

 //       _Value* doubles = new _Value[mem_length];

 //       int length=0;

 //       for ( ; begin!=end; ++begin) {

 // 	++length;

 // 	indices[length]=row_iter_map[begin->first];

 // 	doubles[length]=begin->second;

 //       }

 //       setColCoeffs(col_it, length, indices, doubles);

 //       delete [] indices;

 //       delete [] doubles;

 //     }

   protected:

     /// \e

     virtual void _eraseCol(int i) = 0;

     /// \e

     virtual void _eraseRow(int i) = 0;

   public:

     /// \e

     void eraseCol(const ColIt& col_it) {

       col_iter_map.set(col_it, VALID_CLASS, INVALID_CLASS);

       int cols[2];

       cols[1]=col_iter_map[col_it];

       _eraseCol(cols[1]);

       col_iter_map[col_it]=0; //glpk specifikus, de kell ez??

       ColIt it;

       for (col_iter_map.first(it, VALID_CLASS); 

 	   col_iter_map.valid(it); col_iter_map.next(it)) {

 	if (col_iter_map[it]>cols[1]) --col_iter_map[it];

       }

     }

     /// \e

     void eraseRow(const RowIt& row_it) {

       row_iter_map.set(row_it, VALID_CLASS, INVALID_CLASS);

       int rows[2];

       rows[1]=row_iter_map[row_it];

       _eraseRow(rows[1]);

       row_iter_map[row_it]=0; //glpk specifikus, de kell ez??

       RowIt it;

       for (row_iter_map.first(it, VALID_CLASS); 

 	   row_iter_map.valid(it); row_iter_map.next(it)) {

 	if (row_iter_map[it]>rows[1]) --row_iter_map[it];

       }

     }

     /// \e

   protected:

     ColIt addCol() {

     /// \e

       int i=lpx_add_cols(lp, 1);  

     int _addCol() { 

       ColIt col_it;

       return lpx_add_cols(lp, 1);

       col_iter_map.first(col_it, INVALID_ID);

     }

       if (col_iter_map.valid(col_it)) { //van hasznalhato hely

     /// \e

 	col_iter_map.set(col_it, INVALID_ID, VALID_ID);

     int _addRow() { 

 	col_iter_map[col_it]=i;

       return lpx_add_rows(lp, 1);

 	//col_id_to_lp_col_id[col_iter_map[col_it]]=i;

     }

       } else { //a cucc vegere kell inzertalni mert nincs szabad hely

   public:

 	//col_id_to_lp_col_id.push_back(i);

 	//int j=col_id_to_lp_col_id.size()-1;

 	col_it=col_iter_map.push_back(i, VALID_ID);

       }

       //    edge_index_map.set(e, i);

       //    lpx_set_col_bnds(lp, i, LPX_DB, 0.0, 1.0);

       //    lpx_set_obj_coef(lp, i, cost[e]);    

       return col_it;

     }

     /// \e

     RowIt addRow() {

       int i=lpx_add_rows(lp, 1);  

       RowIt row_it;

       row_iter_map.first(row_it, INVALID_ID);

       if (row_iter_map.valid(row_it)) { //van hasznalhato hely

 	row_iter_map.set(row_it, INVALID_ID, VALID_ID);

 	row_iter_map[row_it]=i;

       } else { //a cucc vegere kell inzertalni mert nincs szabad hely

 	row_it=row_iter_map.push_back(i, VALID_ID);

       }

       return row_it;

     }

     void setRowCoeffs(RowIt row_it, int length, 

     /// \e

 		      int* indices, double* doubles) {

     virtual void setRowCoeffs(int i, 

       lpx_set_mat_row(lp, row_iter_map[row_it], length, indices, doubles);

 			      std::vector<std::pair<int, double> > coeffs) {

     }

       int mem_length=1+colNum();

     using Parent::setColCoeffs;

       int* indices = new int[mem_length];

     void setColCoeffs(ColIt col_it, int length, 

       double* doubles = new double[mem_length];

 		      int* indices, double* doubles) {

       int length=0;

       lpx_set_mat_col(lp, col_iter_map[col_it], length, indices, doubles);

       for (std::vector<std::pair<int, double> >::

     }

 	     const_iterator it=coeffs.begin(); it!=coeffs.end(); ++it) {

 	++length;

 	indices[length]=it->first;

 	doubles[length]=it->second;

 	std::cout << "  " << indices[length] << " " 

 		  << doubles[length] << std::endl;

       }

       std::cout << i << " " << length << std::endl;

       lpx_set_mat_row(lp, i, length, indices, doubles);

       delete [] indices;

       delete [] doubles;

     }

     /// \e

     virtual void setColCoeffs(int i, 

 			      std::vector<std::pair<int, double> > coeffs) {

       int mem_length=1+rowNum();

       int* indices = new int[mem_length];

       double* doubles = new double[mem_length];

       int length=0;

       for (std::vector<std::pair<int, double> >::

 	     const_iterator it=coeffs.begin(); it!=coeffs.end(); ++it) {

 	++length;

 	indices[length]=it->first;

 	doubles[length]=it->second;

       }

       lpx_set_mat_col(lp, i, length, indices, doubles);

       delete [] indices;

       delete [] doubles;

     }

 //     /// \e

 //     /// temporally, glpk style indexing

 //     virtual void setRowCoeffs(RowIt row_it, int num, 

 // 			      int* indices, _Value* doubles) = 0;

 //     //pair<RowIt, _Value>-bol kell megadni egy std range-et

 //     /// \e

 //     template <typename Begin, typename End>

 //     void setRowCoeffs(RowIt row_it, Begin begin, End end) {

 //       int mem_length=1+colNum();

 //       int* indices = new int[mem_length];

 //       _Value* doubles = new _Value[mem_length];

 //       int length=0;

 //       for ( ; begin!=end; ++begin) {

 // 	++length;

 // 	indices[length]=col_iter_map[begin->first];

 // 	doubles[length]=begin->second;

 //       }

 //       setRowCoeffs(row_it, length, indices, doubles);

 //       delete [] indices;

 //       delete [] doubles;

 //     }

 //     void setRowCoeffs(RowIt row_it, int length, 

 // 		      int* indices, double* doubles) {

 //       lpx_set_mat_row(lp, row_iter_map[row_it], length, indices, doubles);

 //     }

 //     using Parent::setColCoeffs;

 //     void setColCoeffs(ColIt col_it, int length, 

 // 		      int* indices, double* doubles) {

 //       lpx_set_mat_col(lp, col_iter_map[col_it], length, indices, doubles);

 //     }

     void eraseCol(const ColIt& col_it) {

   protected:

       col_iter_map.set(col_it, VALID_ID, INVALID_ID);

     virtual void _eraseCol(int i) {

       cols[1]=col_iter_map[col_it];

       cols[1]=i;

       col_iter_map[col_it]=0; //glpk specifikus

     }

       ColIt it;

     virtual void _eraseRow(int i) {

       for (col_iter_map.first(it, VALID_ID); 

 	   col_iter_map.valid(it); col_iter_map.next(it)) {

 	if (col_iter_map[it]>cols[1]) --col_iter_map[it];

       }

     }

     /// \e

     void eraseRow(const RowIt& row_it) {

       row_iter_map.set(row_it, VALID_ID, INVALID_ID);

       rows[1]=row_iter_map[row_it];

       rows[1]=i;

       row_iter_map[row_it]=0; //glpk specifikus

     }

       RowIt it;

   public:

       for (row_iter_map.first(it, VALID_ID); 

 	   row_iter_map.valid(it); row_iter_map.next(it)) {

 	if (row_iter_map[it]>rows[1]) --row_iter_map[it];

       }

     }