You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by se...@apache.org on 2015/02/11 11:49:28 UTC

[26/50] [abbrv] flink git commit: [FLINK-1201] [gelly] remove isUndirected flag; methods will always consider the graph as directed

[FLINK-1201] [gelly] remove isUndirected flag; methods will always consider the graph as directed


Project: http://git-wip-us.apache.org/repos/asf/flink/repo
Commit: http://git-wip-us.apache.org/repos/asf/flink/commit/2b98bebc
Tree: http://git-wip-us.apache.org/repos/asf/flink/tree/2b98bebc
Diff: http://git-wip-us.apache.org/repos/asf/flink/diff/2b98bebc

Branch: refs/heads/master
Commit: 2b98bebc28e13b9bd933884961ced757b653936f
Parents: 878118a
Author: vasia <va...@gmail.com>
Authored: Mon Jan 19 16:18:08 2015 +0100
Committer: Stephan Ewen <se...@apache.org>
Committed: Wed Feb 11 10:46:15 2015 +0100

----------------------------------------------------------------------
 .../main/java/org/apache/flink/graph/Graph.java | 469 ++++++++-----------
 1 file changed, 196 insertions(+), 273 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/flink/blob/2b98bebc/flink-staging/flink-gelly/src/main/java/org/apache/flink/graph/Graph.java
----------------------------------------------------------------------
diff --git a/flink-staging/flink-gelly/src/main/java/org/apache/flink/graph/Graph.java b/flink-staging/flink-gelly/src/main/java/org/apache/flink/graph/Graph.java
index 6561803..3caf13d 100644
--- a/flink-staging/flink-gelly/src/main/java/org/apache/flink/graph/Graph.java
+++ b/flink-staging/flink-gelly/src/main/java/org/apache/flink/graph/Graph.java
@@ -72,230 +72,18 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
     private final ExecutionEnvironment context;
 	private final DataSet<Vertex<K, VV>> vertices;
 	private final DataSet<Edge<K, EV>> edges;
-	private boolean isUndirected;
 
 	/**
-	 * Creates a graph from two DataSets: vertices and edges
+	 * Creates a graph from two datasets: vertices and edges and allow setting the undirected property
 	 *
 	 * @param vertices a DataSet of vertices.
 	 * @param edges a DataSet of vertices.
 	 * @param context the flink execution environment.
 	 */
-	private Graph(DataSet<Vertex<K, VV>> vertices, DataSet<Edge<K, EV>> edges, ExecutionEnvironment context) {
-
-		/** a graph is directed by default */
-		this(vertices, edges, context, false);
-	}
-
-	/**
-	 * Creates a graph from two DataSets: vertices and edges and allow setting the undirected property
-	 *
-	 * @param vertices a DataSet of vertices.
-	 * @param edges a DataSet of vertices.
-	 * @param context the flink execution environment.
-	 * @param undirected whether this is an undirected graph
-	 */
-	private Graph(DataSet<Vertex<K, VV>> vertices, DataSet<Edge<K, EV>> edges, ExecutionEnvironment context,
-			boolean undirected) {
+	public Graph(DataSet<Vertex<K, VV>> vertices, DataSet<Edge<K, EV>> edges, ExecutionEnvironment context) {
 		this.vertices = vertices;
 		this.edges = edges;
         this.context = context;
-		this.isUndirected = undirected;
-	}
-
-	/**
-	 * Creates a graph from a Collection of vertices and a Collection of edges.
-	 * @param vertices a Collection of vertices.
-	 * @param edges a Collection of vertices.
-	 * @param context the flink execution environment.
-	 * @return the newly created graph.
-	 */
-	public static <K extends Comparable<K> & Serializable, VV extends Serializable, EV extends Serializable>
-		Graph<K, VV, EV> fromCollection (Collection<Vertex<K,VV>> vertices,
-										 Collection<Edge<K,EV>> edges,
-										 ExecutionEnvironment context) {
-
-		return fromDataSet(context.fromCollection(vertices), context.fromCollection(edges), context);
-	}
-
-	/**
-	 * Creates a graph from a Collection of edges, vertices are induced from the edges.
-	 * Vertices are created automatically and their values are set to NullValue.
-	 * @param edges a Collection of vertices.
-	 * @param context the flink execution environment.
-	 * @return the newly created graph.
-	 */
-	public static <K extends Comparable<K> & Serializable, EV extends Serializable>
-		Graph<K, NullValue, EV> fromCollection (Collection<Edge<K,EV>> edges, ExecutionEnvironment context) {
-
-		return fromDataSet(context.fromCollection(edges), context);
-	}
-
-	/**
-	 * Creates a graph from a Collection of edges, vertices are induced from the edges and
-	 * vertex values are calculated by a mapper function.
-	 * Vertices are created automatically and their values are set
-	 * by applying the provided map function to the vertex ids.
-	 * @param edges a Collection of vertices.
-	 * @param mapper the mapper function.
-	 * @param context the flink execution environment.
-	 * @return the newly created graph.
-	 */
-	public static <K extends Comparable<K> & Serializable, VV extends Serializable, EV extends Serializable>
-		Graph<K, VV, EV> fromCollection (Collection<Edge<K,EV>> edges,
-										 final MapFunction<K, VV> mapper,
-										 ExecutionEnvironment context) {
-
-		return fromDataSet(context.fromCollection(edges), mapper, context);
-	}
-
-	/**
-	 * Creates a graph from a DataSet of vertices and a DataSet of edges.
-	 * @param vertices a DataSet of vertices.
-	 * @param edges a DataSet of vertices.
-	 * @param context the flink execution environment.
-	 * @return the newly created graph.
-	 */
-	public static <K extends Comparable<K> & Serializable, VV extends Serializable, EV extends Serializable>
-		Graph<K, VV, EV> fromDataSet (DataSet<Vertex<K,VV>> vertices,
-									  DataSet<Edge<K,EV>> edges,
-									  ExecutionEnvironment context) {
-
-		return new Graph<K, VV, EV>(vertices, edges, context);
-	}
-
-	/**
-	 * Creates a graph from a DataSet of edges, vertices are induced from the edges.
-	 * Vertices are created automatically and their values are set to NullValue.
-	 * @param edges a DataSet of vertices.
-	 * @param context the flink execution environment.
-	 * @return the newly created graph.
-	 */
-	public static <K extends Comparable<K> & Serializable, EV extends Serializable>
-		Graph<K, NullValue, EV> fromDataSet (DataSet<Edge<K,EV>> edges,
-											 ExecutionEnvironment context) {
-
-		DataSet<Vertex<K, NullValue>> vertices =
-				edges.flatMap(new EmitSrcAndTarget<K, EV>()).distinct();
-
-		return new Graph<K, NullValue, EV>(vertices, edges, context);
-	}
-
-	private static final class EmitSrcAndTarget<K extends Comparable<K> & Serializable, EV extends Serializable>
-			implements FlatMapFunction<Edge<K, EV>, Vertex<K, NullValue>> {
-
-		public void flatMap(Edge<K, EV> edge, Collector<Vertex<K, NullValue>> out) {
-			out.collect(new Vertex<K, NullValue>(edge.f0, NullValue.getInstance()));
-			out.collect(new Vertex<K, NullValue>(edge.f1, NullValue.getInstance()));
-		}
-	}
-
-	/**
-	 * Creates a graph from a DataSet of edges, vertices are induced from the edges and
-	 * vertex values are calculated by a mapper function.
-	 * Vertices are created automatically and their values are set
-	 * by applying the provided map function to the vertex ids.
-	 * @param edges a DataSet of vertices.
-	 * @param mapper the mapper function.
-	 * @param context the flink execution environment.
-	 * @return the newly created graph.
-	 */
-	public static <K extends Comparable<K> & Serializable, VV extends Serializable, EV extends Serializable>
-		Graph<K, VV, EV> fromDataSet (DataSet<Edge<K,EV>> edges,
-									  final MapFunction<K, VV> mapper,
-									  ExecutionEnvironment context) {
-
-		TypeInformation<K> keyType = ((TupleTypeInfo<?>) edges.getType()).getTypeAt(0);
-
-		TypeInformation<VV> valueType = TypeExtractor
-				.createTypeInfo(MapFunction.class, mapper.getClass(), 1, null, null);
-
-		@SuppressWarnings({ "unchecked", "rawtypes" })
-		TypeInformation<Vertex<K, VV>> returnType = (TypeInformation<Vertex<K, VV>>)
-				new TupleTypeInfo(Vertex.class, keyType, valueType);
-
-		DataSet<Vertex<K, VV>> vertices =
-				edges.flatMap(new EmitSrcAndTargetAsTuple1<K, EV>())
-				     .distinct()
-				     .map(new MapFunction<Tuple1<K>, Vertex<K, VV>>() {
-						 public Vertex<K, VV> map(Tuple1<K> value) throws Exception {
-							 return new Vertex<K, VV>(value.f0, mapper.map(value.f0));
-						 }
-					 })
-				     .returns(returnType);
-
-		return new Graph<K, VV, EV>(vertices, edges, context);
-	}
-
-	private static final class EmitSrcAndTargetAsTuple1<K extends Comparable<K> & Serializable,
-			EV extends Serializable> implements FlatMapFunction<Edge<K, EV>, Tuple1<K>> {
-
-		public void flatMap(Edge<K, EV> edge, Collector<Tuple1<K>> out) {
-			out.collect(new Tuple1<K>(edge.f0));
-			out.collect(new Tuple1<K>(edge.f1));
-		}
-	}
-
-	/**
-	 * Creates a graph from a DataSet of Tuple objects for vertices and edges.
-	 *
-	 * Vertices with value are created from Tuple2,
-	 * Edges with value are created from Tuple3.
-	 *
-	 * @param vertices a DataSet of vertices.
-	 * @param edges a DataSet of vertices.
-	 * @param context the flink execution environment.
-	 * @return the newly created graph.
-	 */
-	@SuppressWarnings({ "unchecked" })
-	public static <K extends Comparable<K> & Serializable, VV extends Serializable, EV extends Serializable>
-		Graph<K, VV, EV> fromTupleDataSet (DataSet<Tuple2<K, VV>> vertices,
-										   DataSet<Tuple3<K, K, EV>> edges,
-										   ExecutionEnvironment context) {
-
-		DataSet<Vertex<K, VV>> vertexDataSet = (DataSet<Vertex<K, VV>>) (DataSet<?>) vertices;
-		DataSet<Edge<K, EV>> edgeDataSet = (DataSet<Edge<K, EV>>) (DataSet<?>) edges;
-		return fromDataSet(vertexDataSet, edgeDataSet, context);
-	}
-
-	/**
-	 * Creates a graph from a DataSet of Tuple objects for edges, vertices are induced from the edges.
-	 *
-	 * Edges with value are created from Tuple3.
-	 * Vertices are created automatically and their values are set to NullValue.
-	 *
-	 * @param edges a DataSet of vertices.
-	 * @param context the flink execution environment.
-	 * @return the newly created graph.
-	 */
-	@SuppressWarnings({ "unchecked" })
-	public static <K extends Comparable<K> & Serializable, EV extends Serializable>
-		Graph<K, NullValue, EV> fromTupleDataSet (DataSet<Tuple3<K, K, EV>> edges,
-												  ExecutionEnvironment context) {
-
-		DataSet<Edge<K, EV>> edgeDataSet = (DataSet<Edge<K, EV>>) (DataSet<?>) edges;
-		return fromDataSet(edgeDataSet, context);
-	}
-
-	/**
-	 * Creates a graph from a DataSet of Tuple objects for edges, vertices are induced from the edges and
-	 * vertex values are calculated by a mapper function.
-	 * Edges with value are created from Tuple3.
-	 * Vertices are created automatically and their values are set
-	 * by applying the provided map function to the vertex ids.
-	 * @param edges a DataSet of vertices.
-	 * @param mapper the mapper function.
-	 * @param context the flink execution environment.
-	 * @return the newly created graph.
-	 */
-	@SuppressWarnings({ "unchecked" })
-	public static <K extends Comparable<K> & Serializable, VV extends Serializable, EV extends Serializable>
-	Graph<K, VV, EV> fromTupleDataSet (DataSet<Tuple3<K, K, EV>> edges,
-									   final MapFunction<K, VV> mapper,
-									   ExecutionEnvironment context) {
-
-		DataSet<Edge<K, EV>> edgeDataSet = (DataSet<Edge<K, EV>>) (DataSet<?>) edges;
-		return fromDataSet(edgeDataSet, mapper, context);
 	}
 
 	/**
@@ -314,35 +102,19 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 	}
 
 	/**
-	 * @return the vertex DataSet.
+	 * @return the vertex dataset.
 	 */
 	public DataSet<Vertex<K, VV>> getVertices() {
 		return vertices;
 	}
 
 	/**
-	 * @return the edge DataSet.
+	 * @return the edge dataset.
 	 */
 	public DataSet<Edge<K, EV>> getEdges() {
 		return edges;
 	}
 
-	/**
-	 * @return the vertex DataSet as Tuple2.
-	 */
-	@SuppressWarnings({ "unchecked" })
-	public DataSet<Tuple2<K, VV>> getVerticesAsTuple2() {
-		return (DataSet<Tuple2<K, VV>>) (DataSet<?>) vertices;
-	}
-
-	/**
-	 * @return the edge DataSet as Tuple3.
-	 */
-	@SuppressWarnings({ "unchecked" })
-	public DataSet<Tuple3<K, K, EV>> getEdgesAsTuple3() {
-		return (DataSet<Tuple3<K, K, EV>>) (DataSet<?>) edges;
-	}
-
     /**
      * Apply a function to the attribute of each vertex in the graph.
      * @param mapper the map function to apply.
@@ -367,7 +139,7 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 				})
     			.returns(returnType);
 
-        return new Graph<K, NV, EV>(mappedVertices, this.edges, this.context);
+        return new Graph<K, NV, EV>(mappedVertices, this.getEdges(), this.context);
     }
 
     /**
@@ -408,7 +180,7 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 		DataSet<Vertex<K, VV>> resultedVertices = this.getVertices()
 				.coGroup(inputDataSet).where(0).equalTo(0)
 				.with(new ApplyCoGroupToVertexValues<K, VV, T>(mapper));
-		return new Graph(resultedVertices, this.edges, this.context);
+		return Graph.create(resultedVertices, this.getEdges(), this.getContext());
 	}
 
 	private static final class ApplyCoGroupToVertexValues<K extends Comparable<K> & Serializable,
@@ -454,7 +226,7 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 		DataSet<Edge<K, EV>> resultedEdges = this.getEdges()
 				.coGroup(inputDataSet).where(0,1).equalTo(0,1)
 				.with(new ApplyCoGroupToEdgeValues<K, EV, T>(mapper));
-		return new Graph(this.vertices, resultedEdges, this.context);
+		return Graph.create(this.getVertices(), resultedEdges, this.getContext());
 	}
 
 	private static final class ApplyCoGroupToEdgeValues<K extends Comparable<K> & Serializable,
@@ -503,7 +275,7 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 				.coGroup(inputDataSet).where(0).equalTo(0)
 				.with(new ApplyCoGroupToEdgeValuesOnEitherSourceOrTarget<K, EV, T>(mapper));
 
-		return new Graph(this.vertices, resultedEdges, this.context);
+		return Graph.create(this.getVertices(), resultedEdges, this.getContext());
 	}
 
 	private static final class ApplyCoGroupToEdgeValuesOnEitherSourceOrTarget<K extends Comparable<K> & Serializable,
@@ -555,7 +327,7 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 				.coGroup(inputDataSet).where(1).equalTo(0)
 				.with(new ApplyCoGroupToEdgeValuesOnEitherSourceOrTarget<K, EV, T>(mapper));
 
-		return new Graph(this.vertices, resultedEdges, this.context);
+		return Graph.create(this.getVertices(), resultedEdges, this.getContext());
 	}
 
 	/**
@@ -667,19 +439,14 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 	}
 
 	/**
-	 * Convert the directed graph into an undirected graph
-	 * by adding all inverse-direction edges.
+	 * This operation adds all inverse-direction edges
+	 * to the graph.
 	 * @return the undirected graph.
 	 */
 	public Graph<K, VV, EV> getUndirected() throws UnsupportedOperationException {
-		if (this.isUndirected) {
-			throw new UnsupportedOperationException("The graph is already undirected.");
-		}
-		else {
 			DataSet<Edge<K, EV>> undirectedEdges =
 					edges.union(edges.map(new ReverseEdgesMap<K, EV>()));
-			return new Graph<K, VV, EV>(vertices, undirectedEdges, this.context, true);
-			}
+			return new Graph<K, VV, EV>(vertices, undirectedEdges, this.context);
 	}
 	
 	/**
@@ -878,13 +645,122 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 	 * @throws UnsupportedOperationException
 	 */
 	public Graph<K, VV, EV> reverse() throws UnsupportedOperationException {
-		if (this.isUndirected) {
-			throw new UnsupportedOperationException("The graph is already undirected.");
-		}
-		else {
-			DataSet<Edge<K, EV>> undirectedEdges = edges.map(new ReverseEdgesMap<K, EV>());
-			return new Graph<K, VV, EV>(this.vertices, undirectedEdges, this.context, true);
-		}
+		DataSet<Edge<K, EV>> reversedEdges = edges.map(new ReverseEdgesMap<K, EV>());
+		return new Graph<K, VV, EV>(vertices, reversedEdges, this.context);
+	}
+
+	/**
+	 * Creates a graph from a dataset of vertices and a dataset of edges
+	 * @param vertices a DataSet of vertices.
+	 * @param edges a DataSet of vertices.
+	 * @param context the flink execution environment.
+	 * @return the newly created graph
+	 */
+	public static <K extends Comparable<K> & Serializable, VV extends Serializable,
+		EV extends Serializable> Graph<K, VV, EV>
+		create(DataSet<Vertex<K, VV>> vertices, DataSet<Edge<K, EV>> edges, 
+				ExecutionEnvironment context) {
+		return new Graph<K, VV, EV>(vertices, edges, context);
+	}
+	
+	/**
+	 * Creates a graph from a DataSet of edges.
+	 * Vertices are created automatically and their values are set to NullValue.
+	 * @param edges a DataSet of vertices.
+	 * @param context the flink execution environment.
+	 * @return the newly created graph
+	 */
+	public static <K extends Comparable<K> & Serializable, EV extends Serializable> 
+		Graph<K, NullValue, EV> create(DataSet<Edge<K, EV>> edges, ExecutionEnvironment context) {
+		DataSet<Vertex<K, NullValue>> vertices = 
+				edges.flatMap(new EmitSrcAndTarget<K, EV>()).distinct(); 
+		return new Graph<K, NullValue, EV>(vertices, edges, context);
+	}
+	
+	/**
+	 * Creates a graph from a DataSet of edges.
+	 * Vertices are created automatically and their values are set
+	 * by applying the provided map function to the vertex ids.
+	 * @param edges the input edges
+	 * @param mapper the map function to set the initial vertex value
+	 * @return the newly created graph
+	 */
+	public static <K extends Comparable<K> & Serializable, VV extends Serializable,	EV extends Serializable> 
+		Graph<K, VV, EV> create(DataSet<Edge<K, EV>> edges, final MapFunction<K, VV> mapper, 
+				ExecutionEnvironment context) {
+		TypeInformation<K> keyType = ((TupleTypeInfo<?>) edges.getType()).getTypeAt(0);
+
+		TypeInformation<VV> valueType = TypeExtractor
+				.createTypeInfo(MapFunction.class, mapper.getClass(), 1, null, null);
+
+		@SuppressWarnings({ "unchecked", "rawtypes" })
+		TypeInformation<Vertex<K, VV>> returnType = (TypeInformation<Vertex<K, VV>>)
+				new TupleTypeInfo(Vertex.class, keyType, valueType);
+
+		DataSet<Vertex<K, VV>> vertices = 
+				edges.flatMap(new EmitSrcAndTargetAsTuple1<K, EV>())
+				.distinct().map(new MapFunction<Tuple1<K>, Vertex<K, VV>>(){
+					public Vertex<K, VV> map(Tuple1<K> value) throws Exception {
+						return new Vertex<K, VV>(value.f0, mapper.map(value.f0));
+					}
+				}).returns(returnType);
+		return new Graph<K, VV, EV>(vertices, edges, context);
+	}
+
+	private static final class EmitSrcAndTarget<K extends Comparable<K> & Serializable, EV extends Serializable>
+		implements FlatMapFunction<Edge<K, EV>, Vertex<K, NullValue>> {
+		public void flatMap(Edge<K, EV> edge,
+				Collector<Vertex<K, NullValue>> out) {
+
+				out.collect(new Vertex<K, NullValue>(edge.f0, NullValue.getInstance()));
+				out.collect(new Vertex<K, NullValue>(edge.f1, NullValue.getInstance()));
+		}	
+	}
+
+	private static final class EmitSrcAndTargetAsTuple1<K extends Comparable<K> & Serializable, 
+		EV extends Serializable> implements FlatMapFunction<Edge<K, EV>, Tuple1<K>> {
+		public void flatMap(Edge<K, EV> edge, Collector<Tuple1<K>> out) {
+
+			out.collect(new Tuple1<K>(edge.f0));
+			out.collect(new Tuple1<K>(edge.f1));
+		}	
+	}
+
+	/**
+	 * Read and create the graph vertex Tuple2 DataSet from a csv file
+	 *
+	 * The CSV file should be of the following format:
+	 *
+	 * <vertexID><delimiter><vertexValue>
+	 *
+	 * For example, with space delimiter:
+	 *
+	 * 1 57
+	 * 2 45
+	 * 3 77
+	 * 4 12
+	 *
+	 * @param context the flink execution environment.
+	 * @param filePath the path to the CSV file.
+	 * @param delimiter the CSV delimiter.
+	 * @param Tuple2IdClass The class to use for Vertex IDs
+	 * @param Tuple2ValueClass The class to use for Vertex Values
+	 * @return a set of vertices and their values.
+	 */
+	public static <K extends Comparable<K> & Serializable, VV extends Serializable>
+		DataSet<Tuple2<K, VV>>
+		readTuple2CsvFile(ExecutionEnvironment context, String filePath,
+			char delimiter, Class<K> Tuple2IdClass, Class<VV> Tuple2ValueClass) {
+
+		CsvReader reader = new CsvReader(filePath, context);
+		DataSet<Tuple2<K, VV>> vertices = reader.fieldDelimiter(delimiter).types(Tuple2IdClass, Tuple2ValueClass)
+		.map(new MapFunction<Tuple2<K, VV>, Tuple2<K, VV>>() {
+
+			public Tuple2<K, VV> map(Tuple2<K, VV> value) throws Exception {
+				return (Tuple2<K, VV>)value;
+			}
+		});
+		return vertices;
 	}
 
 	/**
@@ -937,17 +813,10 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 	 * @return true if the graph is weakly connected.
 	 */
 	public DataSet<Boolean> isWeaklyConnected (int maxIterations) {
-		Graph<K, VV, EV> graph;
-		
-		if (!(this.isUndirected)) {
-			// first, convert to an undirected graph
-			graph = this.getUndirected();
-		}
-		else {
-			graph = this;
-		}
+		// first, convert to an undirected graph
+		Graph<K, VV, EV> graph = this.getUndirected();
 
-        DataSet<K> vertexIds = graph.getVertexIds();
+		DataSet<K> vertexIds = graph.getVertexIds();
         DataSet<Tuple2<K,K>> verticesWithInitialIds = vertexIds
                 .map(new DuplicateVertexIDMapper<K>());
 
@@ -1011,6 +880,14 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
         }
 	}
 	
+    public Graph<K, VV, EV> fromCollection (Collection<Vertex<K,VV>> vertices, Collection<Edge<K,EV>> edges) {
+
+		DataSet<Vertex<K, VV>> v = context.fromCollection(vertices);
+		DataSet<Edge<K, EV>> e = context.fromCollection(edges);
+
+		return new Graph<K, VV, EV>(v, e, context);
+	}
+
 	/**
 	 * Adds the input vertex and edges to the graph.
 	 * If the vertex already exists in the graph, it will not be added again,
@@ -1025,14 +902,14 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
 
     	// Take care of empty edge set
     	if (edges.isEmpty()) {
-    		return new Graph(this.vertices.union(newVertex).distinct(), this.edges, this.context);
+    		return Graph.create(getVertices().union(newVertex).distinct(), getEdges(), context);
     	}
 
     	// Add the vertex and its edges
-    	DataSet<Vertex<K, VV>> newVertices = this.vertices.union(newVertex).distinct();
-    	DataSet<Edge<K, EV>> newEdges = this.edges.union(context.fromCollection(edges));
+    	DataSet<Vertex<K, VV>> newVertices = getVertices().union(newVertex).distinct();
+    	DataSet<Edge<K, EV>> newEdges = getEdges().union(context.fromCollection(edges));
 
-    	return new Graph(newVertices, newEdges, this.context);
+    	return Graph.create(newVertices, newEdges, context);
     }
 
     /**
@@ -1045,11 +922,8 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
      * @return the new graph containing the existing vertices and edges plus the newly added edge
      */
     public Graph<K, VV, EV> addEdge (Vertex<K,VV> source, Vertex<K,VV> target, EV edgeValue) {
-    	Graph<K,VV,EV> partialGraph = fromCollection(
-				Arrays.asList(source, target),
-				Arrays.asList(new Edge<K, EV>(source.f0, target.f0, edgeValue)),
-				this.context
-		);
+    	Graph<K,VV,EV> partialGraph = this.fromCollection(Arrays.asList(source, target),
+				Arrays.asList(new Edge<K, EV>(source.f0, target.f0, edgeValue)));
         return this.union(partialGraph);
     }
 
@@ -1112,7 +986,7 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
     public Graph<K, VV, EV> removeEdge (Edge<K, EV> edge) {
 		DataSet<Edge<K, EV>> newEdges = getEdges().filter(
 				new EdgeRemovalEdgeFilter<K, EV>(edge));
-        return new Graph<K, VV, EV>(this.vertices, newEdges, this.context);
+        return new Graph<K, VV, EV>(this.getVertices(), newEdges, this.context);
     }
     
     private static final class EdgeRemovalEdgeFilter<K extends Comparable<K> & Serializable, 
@@ -1154,9 +1028,58 @@ public class Graph<K extends Comparable<K> & Serializable, VV extends Serializab
     	DataSet<Vertex<K, VV>> newVertices = vertices.runOperation(
     	                     VertexCentricIteration.withEdges(edges,
 						vertexUpdateFunction, messagingFunction, maximumNumberOfIterations));
-		return new Graph<K, VV, EV>(newVertices, this.edges, this.context);
+		return new Graph<K, VV, EV>(newVertices, edges, context);
     }
 
+	/**
+	 * Creates a graph from the given vertex and edge collections
+	 * @param context the flink execution environment.
+	 * @param v the collection of vertices
+	 * @param e the collection of edges
+	 * @return a new graph formed from the set of edges and vertices
+	 */
+	public static <K extends Comparable<K> & Serializable, VV extends Serializable,
+			EV extends Serializable> Graph<K, VV, EV>
+		fromCollection(ExecutionEnvironment context, Collection<Vertex<K, VV>> v,
+					   Collection<Edge<K, EV>> e) throws Exception {
+
+		DataSet<Vertex<K, VV>> vertices = context.fromCollection(v);
+		DataSet<Edge<K, EV>> edges = context.fromCollection(e);
+
+		return Graph.create(vertices, edges, context);
+	}
+
+	/**
+	 * Vertices may not have a value attached or may receive a value as a result of running the algorithm.
+	 * @param context the flink execution environment.
+	 * @param e the collection of edges
+	 * @return a new graph formed from the edges, with no value for the vertices
+	 */
+	public static <K extends Comparable<K> & Serializable, VV extends Serializable,
+			EV extends Serializable> Graph<K, NullValue, EV>
+		fromCollection(ExecutionEnvironment context, Collection<Edge<K, EV>> e) {
+
+		DataSet<Edge<K, EV>> edges = context.fromCollection(e);
+
+		return Graph.create(edges, context);
+	}
+
+	/**
+	 * Vertices may have an initial value defined by a function.
+	 * @param context the flink execution environment.
+	 * @param e the collection of edges
+	 * @return a new graph formed from the edges, with a custom value for the vertices,
+	 * determined by the mapping function
+	 */
+	public static <K extends Comparable<K> & Serializable, VV extends Serializable,
+			EV extends Serializable> Graph<K, VV, EV>
+		fromCollection(ExecutionEnvironment context, Collection<Edge<K, EV>> e,
+					   final MapFunction<K, VV> mapper) {
+
+		DataSet<Edge<K, EV>> edges = context.fromCollection(e);
+		return Graph.create(edges, mapper, context);
+	}
+
 	public Graph<K, VV, EV> run (GraphAlgorithm<K, VV, EV> algorithm) {
 		return algorithm.run(this);
 	}