Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 2324)
+++ lemon/lp_base.h	(revision 2328)
@@ -707,8 +707,12 @@
 
     virtual void _setColLowerBound(int i, Value value) = 0;
+    virtual Value _getColLowerBound(int i) = 0;
     virtual void _setColUpperBound(int i, Value value) = 0;
+    virtual Value _getColUpperBound(int i) = 0;
 //     virtual void _setRowLowerBound(int i, Value value) = 0;
 //     virtual void _setRowUpperBound(int i, Value value) = 0;
     virtual void _setRowBounds(int i, Value lower, Value upper) = 0;
+    virtual void _getRowBounds(int i, Value &lower, Value &upper)=0;
+
     virtual void _setObjCoeff(int i, Value obj_coef) = 0;
     virtual Value _getObjCoeff(int i) = 0;
@@ -1025,4 +1029,13 @@
       _setColLowerBound(_lpId(c),value);
     }
+
+    /// Get the lower bound of a column (i.e a variable)
+
+    /// This function returns the lower bound for column (variable) \t c
+    /// (this might be -\ref INF as well).  
+    ///\return The lower bound for coloumn \t c
+    Value colLowerBound(Col c) {
+      return _getColLowerBound(_lpId(c));
+    }
     
     ///\brief Set the lower bound of  several columns
@@ -1072,5 +1085,14 @@
     };
 
-    ///\brief Set the lower bound of  several columns
+    /// Get the upper bound of a column (i.e a variable)
+
+    /// This function returns the upper bound for column (variable) \t c
+    /// (this might be \ref INF as well).  
+    ///\return The upper bound for coloumn \t c
+    Value colUpperBound(Col c) {
+      return _getColUpperBound(_lpId(c));
+    }
+
+    ///\brief Set the upper bound of  several columns
     ///(i.e a variables) at once
     ///
@@ -1177,13 +1199,28 @@
     /// Set the lower and the upper bounds of a row (i.e a constraint)
 
-    /// The lower and the upper bounds of
+    /// The lower and the upper bound of
     /// a constraint (row) have to be given by an 
     /// extended number of type Value, i.e. a finite number of type 
-    /// Value, -\ref INF or \ref INF.
+    /// Value, -\ref INF or \ref INF. There is no separate function for the 
+    /// lower and the upper bound because that would have been hard to implement 
+    /// for CPLEX.
     void rowBounds(Row c, Value lower, Value upper) {
       _setRowBounds(_lpId(c),lower, upper);
-      // _setRowUpperBound(_lpId(c),upper);
-    }
-    
+    }
+    
+    /// Get the lower and the upper bounds of a row (i.e a constraint)
+
+    /// The lower and the upper bound of
+    /// a constraint (row) are  
+    /// extended numbers of type Value, i.e.  finite numbers of type 
+    /// Value, -\ref INF or \ref INF. 
+    /// \todo There is no separate function for the 
+    /// lower and the upper bound because we had problems with the 
+    /// implementation of the setting functions for CPLEX:  
+    /// check out whether this can be done for these functions.
+    void getRowBounds(Row c, Value &lower, Value &upper) {
+      _getRowBounds(_lpId(c),lower, upper);
+    }
+
     ///Set an element of the objective function
     void objCoeff(Col c, Value v) {_setObjCoeff(_lpId(c),v); };
Index: lemon/lp_cplex.cc
===================================================================
--- lemon/lp_cplex.cc	(revision 2312)
+++ lemon/lp_cplex.cc	(revision 2328)
@@ -44,4 +44,5 @@
 
   LpSolverBase &LpCplex::_copyLp() {
+    ///\bug FixID data is not copied!
     //The first approach opens a new environment
     LpCplex* newlp=new LpCplex();
Index: lemon/lp_glpk.cc
===================================================================
--- lemon/lp_glpk.cc	(revision 2326)
+++ lemon/lp_glpk.cc	(revision 2328)
@@ -214,8 +214,23 @@
   }
 
-  LpGlpk::Value LpGlpk::_getCoeff(int, int)
-  {
-    ///\todo This is not yet implemented!!!
+  LpGlpk::Value LpGlpk::_getCoeff(int row, int col)
+  {
+
+    int length=lpx_get_mat_row(lp, row, 0, 0);
+    
+    std::vector<int> indices(length + 2);
+    std::vector<Value> values(length + 2);
+    
+    lpx_get_mat_row(lp, row, &indices[0], &values[0]);
+    
+    //The following code does not suppose that the elements of the
+    //array indices are sorted
+    for (int i = 1; i <= length; ++i) {
+      if (indices[i]==col){
+	return values[i];
+      }
+    }
     return 0;
+
   }
 
@@ -263,4 +278,17 @@
 
   }
+
+  LpGlpk::Value LpGlpk::_getColLowerBound(int i)
+  {
+    int b=lpx_get_col_type(lp, i);
+      switch (b) {
+      case LPX_LO:
+      case LPX_DB:
+      case LPX_FX:
+	return lpx_get_col_lb(lp, i);	
+      default: ;
+	return -INF;
+      }
+  }
   
   void LpGlpk::_setColUpperBound(int i, Value up)
@@ -306,4 +334,17 @@
       }
     }
+  }
+
+  LpGlpk::Value LpGlpk::_getColUpperBound(int i)
+  {
+    int b=lpx_get_col_type(lp, i);
+      switch (b) {
+      case LPX_UP:
+      case LPX_DB:
+      case LPX_FX:
+	return lpx_get_col_ub(lp, i);	
+      default: ;
+	return INF;
+      }
   }
   
@@ -424,4 +465,28 @@
     }
 
+  }
+
+  void LpGlpk::_getRowBounds(int i, Value &lb, Value &ub)
+  {
+
+    int b=lpx_get_row_type(lp, i);
+    switch (b) {
+    case LPX_FR:
+    case LPX_UP:
+      lb = -INF;
+	break;
+    default: 
+      lb=lpx_get_row_lb(lp, i);
+    }
+
+    switch (b) {
+    case LPX_FR:
+    case LPX_LO:
+      ub = INF;
+	break;
+    default: 
+      ub=lpx_get_row_ub(lp, i);
+    }
+    
   }
   
Index: lemon/lp_glpk.h
===================================================================
--- lemon/lp_glpk.h	(revision 2324)
+++ lemon/lp_glpk.h	(revision 2328)
@@ -64,8 +64,12 @@
 
     virtual void _setColLowerBound(int i, Value value);
+    virtual Value _getColLowerBound(int i);
     virtual void _setColUpperBound(int i, Value value);
+    virtual Value _getColUpperBound(int i);
+
 //     virtual void _setRowLowerBound(int i, Value value);
 //     virtual void _setRowUpperBound(int i, Value value);
     virtual void _setRowBounds(int i, Value lower, Value upper);
+    virtual void _getRowBounds(int i, Value &lb, Value &ub);
     virtual void _setObjCoeff(int i, Value obj_coef);
     virtual Value _getObjCoeff(int i);
Index: lemon/lp_skeleton.cc
===================================================================
--- lemon/lp_skeleton.cc	(revision 2326)
+++ lemon/lp_skeleton.cc	(revision 2328)
@@ -79,6 +79,16 @@
   }
   
+  LpSkeleton::Value LpSkeleton::_getColLowerBound(int)
+  {
+    return 0;
+  }
+  
   void LpSkeleton::_setColUpperBound(int, Value)
   {
+  }
+
+  LpSkeleton::Value LpSkeleton::_getColUpperBound(int)
+  {
+    return 0;
   }
   
@@ -92,4 +102,8 @@
 
   void LpSkeleton::_setRowBounds(int, Value, Value)
+  {
+  }
+
+  void LpSkeleton::_getRowBounds(int, Value&, Value&)
   {
   }
Index: lemon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 2324)
+++ lemon/lp_skeleton.h	(revision 2328)
@@ -65,4 +65,9 @@
     /// \e
 
+    /// The lower bound of a variable (column) is an 
+    /// extended number of type Value, i.e. a finite number of type 
+    /// Value or -\ref INF.
+    virtual Value _getColLowerBound(int i);
+
     /// The upper bound of a variable (column) have to be given by an 
     /// extended number of type Value, i.e. a finite number of type 
@@ -70,4 +75,9 @@
     virtual void _setColUpperBound(int i, Value value);
     /// \e
+
+    /// The upper bound of a variable (column) is an 
+    /// extended number of type Value, i.e. a finite number of type 
+    /// Value or \ref INF.
+    virtual Value _getColUpperBound(int i);
 
 //     /// The lower bound of a linear expression (row) have to be given by an 
@@ -87,4 +97,12 @@
     /// Value or +/-\ref INF.
     virtual void _setRowBounds(int i, Value lb, Value ub);
+    /// \e
+
+
+    /// The lower and the upper bound of
+    /// a constraint (row) are  
+    /// extended numbers of type Value, i.e.  finite numbers of type 
+    /// Value, -\ref INF or \ref INF. 
+    virtual void _getRowBounds(int i, Value &lb, Value &ub);
     /// \e
 
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 2325)
+++ test/lp_test.cc	(revision 2328)
@@ -298,5 +298,12 @@
   check(lp.objCoeff(x1)==1,"First term should be 1 in the obj function!");
   check(lp.is_max(),"This is a maximization!");
-  check(lp.coeff(upright,x1)==0,"The coefficient in question is 1!");
+  check(lp.coeff(upright,x1)==1,"The coefficient in question is 1!");
+  //  std::cout<<lp.colLowerBound(x1)<<std::endl;
+  check(  lp.colLowerBound(x1)==0,"The lower bound for variable x1 should be 0.");
+  check(  lp.colUpperBound(x1)==LpSolverBase::INF,"The upper bound for variable x1 should be infty.");
+  LpSolverBase::Value lb,ub;
+  lp.getRowBounds(upright,lb,ub);
+  check(  lb==-LpSolverBase::INF,"The lower bound for the first row should be -infty.");
+  check(  ub==1,"The upper bound for the first row should be 1.");
 
 
