Index: src/demo/sub_graph_wrapper_demo.cc
===================================================================
--- src/demo/sub_graph_wrapper_demo.cc	(revision 871)
+++ src/demo/sub_graph_wrapper_demo.cc	(revision 888)
@@ -15,5 +15,5 @@
 #include <hugo/dimacs.h>
 #include <hugo/preflow.h>
-#include <tight_edge_filter_map.h>
+#include <hugo/tight_edge_filter_map.h>
 
 using namespace hugo;
Index: c/demo/tight_edge_filter_map.h
===================================================================
--- src/demo/tight_edge_filter_map.h	(revision 868)
+++ 	(revision )
@@ -1,46 +1,0 @@
-// -*- C++ -*-
-#ifndef HUGO_TIGHT_EDGE_FILTER_MAP_H
-#define HUGO_TIGHT_EDGE_FILTER_MAP_H
-
-// /// \file
-// /// \brief Maximum flow algorithms.
-// /// \ingroup galgs
-
-namespace hugo {
-
-  /// \brief A map for filtering the edge-set to those edges 
-  /// which are tight w.r.t. some node_potential map and 
-  /// edge_distance map.
-  ///
-  /// A node-map node_potential is said to be a potential w.r.t. 
-  /// an edge-map edge_distance 
-  /// if and only if for each edge e, node_potential[g.head(e)] 
-  /// <= edge_distance[e]+node_potential[g.tail(e)] 
-  /// (or the reverse inequality holds for each edge).
-  /// An edge is said to be tight if this inequality holds with equality, 
-  /// and the map returns true exactly for those edges.
-  /// To avoid rounding errors, it is recommended to use this class with exact 
-  /// types, e.g. with int.
-  template<typename Graph, 
-	   typename NodePotentialMap, typename EdgeDistanceMap>
-  class TightEdgeFilterMap {
-  protected:
-    const Graph* g;
-    NodePotentialMap* node_potential;
-    EdgeDistanceMap* edge_distance;
-  public:
-    TightEdgeFilterMap(Graph& _g, NodePotentialMap& _node_potential, 
-		       EdgeDistanceMap& _edge_distance) : 
-      g(&_g), node_potential(&_node_potential), 
-      edge_distance(&_edge_distance) { }
-    bool operator[](const typename Graph::Edge& e) const {
-      return ((*node_potential)[g->head(e)] == 
-	      (*edge_distance)[e]+(*node_potential)[g->tail(e)]);
-    }
-  };
-
-} //namespace hugo
-
-#endif //HUGO_TIGHT_EDGE_FILTER_MAP_H
-
-
Index: src/hugo/graph_wrapper.h
===================================================================
--- src/hugo/graph_wrapper.h	(revision 879)
+++ src/hugo/graph_wrapper.h	(revision 888)
@@ -1097,6 +1097,6 @@
       typedef Number ValueType;
       typedef Edge KeyType;
-      ResCap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& _res_graph) : 
-	res_graph(&_res_graph) { }
+      ResCap(const ResGraphWrapper<Graph, Number, CapacityMap, FlowMap>& 
+	     _res_graph) : res_graph(&_res_graph) { }
       Number operator[](const Edge& e) const { 
 	if (res_graph->forward(e)) 
Index: src/hugo/tight_edge_filter_map.h
===================================================================
--- src/hugo/tight_edge_filter_map.h	(revision 888)
+++ src/hugo/tight_edge_filter_map.h	(revision 888)
@@ -0,0 +1,46 @@
+// -*- C++ -*-
+#ifndef HUGO_TIGHT_EDGE_FILTER_MAP_H
+#define HUGO_TIGHT_EDGE_FILTER_MAP_H
+
+// /// \file
+// /// \brief Maximum flow algorithms.
+// /// \ingroup galgs
+
+namespace hugo {
+
+  /// \brief A map for filtering the edge-set to those edges 
+  /// which are tight w.r.t. some node_potential map and 
+  /// edge_distance map.
+  ///
+  /// A node-map node_potential is said to be a potential w.r.t. 
+  /// an edge-map edge_distance 
+  /// if and only if for each edge e, node_potential[g.head(e)] 
+  /// <= edge_distance[e]+node_potential[g.tail(e)] 
+  /// (or the reverse inequality holds for each edge).
+  /// An edge is said to be tight if this inequality holds with equality, 
+  /// and the map returns true exactly for those edges.
+  /// To avoid rounding errors, it is recommended to use this class with exact 
+  /// types, e.g. with int.
+  template<typename Graph, 
+	   typename NodePotentialMap, typename EdgeDistanceMap>
+  class TightEdgeFilterMap {
+  protected:
+    const Graph* g;
+    NodePotentialMap* node_potential;
+    EdgeDistanceMap* edge_distance;
+  public:
+    TightEdgeFilterMap(Graph& _g, NodePotentialMap& _node_potential, 
+		       EdgeDistanceMap& _edge_distance) : 
+      g(&_g), node_potential(&_node_potential), 
+      edge_distance(&_edge_distance) { }
+    bool operator[](const typename Graph::Edge& e) const {
+      return ((*node_potential)[g->head(e)] == 
+	      (*edge_distance)[e]+(*node_potential)[g->tail(e)]);
+    }
+  };
+
+} //namespace hugo
+
+#endif //HUGO_TIGHT_EDGE_FILTER_MAP_H
+
+
Index: src/work/marci/augmenting_flow.h
===================================================================
--- src/work/marci/augmenting_flow.h	(revision 863)
+++ src/work/marci/augmenting_flow.h	(revision 888)
@@ -10,5 +10,5 @@
 #include <hugo/invalid.h>
 #include <hugo/maps.h>
-#include <tight_edge_filter_map.h>
+#include <hugo/tight_edge_filter_map.h>
 
 /// \file
@@ -248,4 +248,6 @@
   {
     ResGW res_graph(*g, *capacity, *flow);
+    typename ResGW::ResCap res_cap(res_graph);
+
     bool _augment=false;
 
@@ -268,7 +270,7 @@
 	pred.set(w, e);
 	if (pred[v]!=INVALID) {
-	  free.set(w, std::min(free[v], res_graph.resCap(e)));
+	  free.set(w, std::min(free[v], res_cap[e]));
 	} else {
-	  free.set(w, res_graph.resCap(e));
+	  free.set(w, res_cap[e]);
 	}
 	if (res_graph.head(e)==t) { _augment=true; break; }
@@ -296,4 +298,6 @@
   {
     ResGW res_graph(*g, *capacity, *flow);
+    typename ResGW::ResCap res_cap(res_graph);
+
     bool _augment=false;
 
@@ -325,7 +329,7 @@
 	pred.set(w, e);
 	if (pred[v]!=INVALID) {
-	  free.set(w, std::min(free[v], res_graph.resCap(e)));
+	  free.set(w, std::min(free[v], res_cap[e]));
 	} else {
-	  free.set(w, res_graph.resCap(e));
+	  free.set(w, res_cap[e]);
 	}
 	if (res_graph.head(e)==t) { _augment=true; break; }
@@ -358,4 +362,5 @@
 
     ResGW res_graph(*g, *capacity, *flow);
+    typename ResGW::ResCap res_cap(res_graph);
 
     //bfs for distances on the residual graph
@@ -393,5 +398,5 @@
 	  original_edge.set(f, e);
 	  //residual_capacity.update();
-	  residual_capacity.set(f, res_graph.resCap(e));
+	  residual_capacity.set(f, res_cap[e]);
 	} else {
 	  if (dist[res_graph.head(e)]==(dist[res_graph.tail(e)]+1)) {
@@ -401,5 +406,5 @@
 	    original_edge.set(f, e);
 	    //residual_capacity.update();
-	    residual_capacity.set(f, res_graph.resCap(e));
+	    residual_capacity.set(f, res_cap[e]);
 	  }
 	}
@@ -473,4 +478,5 @@
 
     ResGW res_graph(*g, *capacity, *flow);
+    typename ResGW::ResCap res_cap(res_graph);
 
     //Potential map, for distances from s
@@ -550,10 +556,10 @@
 	    if (pred[v]!=INVALID) {
 	      free1.set
-		(w, std::min(free1[v], res_graph.resCap
-			     (typename ErasingResGW::Edge(dfs))));
+		(w, std::min(free1[v], res_cap
+			     [typename ErasingResGW::Edge(dfs)]));
 	    } else {
 	      free1.set
-		(w, res_graph.resCap
-		 (typename ErasingResGW::Edge(dfs)));
+		(w, res_cap
+		 [typename ErasingResGW::Edge(dfs)]);
 	    }
 
@@ -577,5 +583,5 @@
 	  res_graph.augment(e, augment_value);
 	  n=erasing_res_graph.tail(e);
-	  if (res_graph.resCap(e)==0)
+	  if (res_cap[e]==0)
 	    erasing_res_graph.erase(e);
 	}
Index: src/work/marci/lp/lp_solver_wrapper.h
===================================================================
--- src/work/marci/lp/lp_solver_wrapper.h	(revision 768)
+++ src/work/marci/lp/lp_solver_wrapper.h	(revision 888)
@@ -340,7 +340,8 @@
       lpx_set_row_bnds(lp, row_iter_map[row_it], bound_type, lo, up);
     }
-//   void setObjCoef(const RowIt& row_it, double obj_coef) { 
-//     lpx_set_obj_coef(lp, row_iter_map[row_it], obj_coef);
-//   }
+    ///.
+    void setObjCoef(const ColIt& col_it, double obj_coef) { 
+      lpx_set_obj_coef(lp, col_iter_map[col_it], obj_coef);
+    }
     ///.
     void solveSimplex() { lpx_simplex(lp); }
