org.apache.flink.graph.scala

Class Graph<K,VV,EV>

java.lang.Object

org.apache.flink.graph.scala.Graph<K,VV,EV>

public final class Graph<K,VV,EV>
extends Object

Represents a graph consisting of edges and vertices.

See Also:

Edge, Vertex

Constructor Summary

Constructors

Constructor and Description
Graph(Graph<K,VV,EV> jgraph, TypeInformation<K> evidence$61, scala.reflect.ClassTag<K> evidence$62, TypeInformation<VV> evidence$63, scala.reflect.ClassTag<VV> evidence$64, TypeInformation<EV> evidence$65, scala.reflect.ClassTag<EV> evidence$66)

Method Summary

Modifier and Type	Method and Description
Graph<K,VV,EV>	addEdge(Vertex<K,VV> source, Vertex<K,VV> target, EV edgeValue) Adds the given edge to the graph.
Graph<K,VV,EV>	addEdges(scala.collection.immutable.List<Edge<K,EV>> edges) Adds the given list edges to the graph.
Graph<K,VV,EV>	addVertex(Vertex<K,VV> vertex) Adds the input vertex to the graph.
Graph<K,VV,EV>	addVertices(scala.collection.immutable.List<Vertex<K,VV>> vertices) Adds the list of vertices, passed as input, to the graph.
<F> F	clean(F f, boolean checkSerializable)
Graph<K,VV,EV>	difference(Graph<K,VV,EV> graph) Performs Difference on the vertex and edge sets of the input graphs removes common vertices and edges.
Graph<K,VV,EV>	filterOnEdges(FilterFunction<Edge<K,EV>> edgeFilter) Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the edges.
Graph<K,VV,EV>	filterOnEdges(scala.Function1<Edge<K,EV>,Object> edgeFilterFun) Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the edges.
Graph<K,VV,EV>	filterOnVertices(FilterFunction<Vertex<K,VV>> vertexFilter) Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the vertices.
Graph<K,VV,EV>	filterOnVertices(scala.Function1<Vertex<K,VV>,Object> vertexFilterFun) Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the vertices.
static <K,EV> Graph<K,NullValue,EV>	fromCollection(scala.collection.Seq<Edge<K,EV>> edges, ExecutionEnvironment env, TypeInformation<K> evidence$23, scala.reflect.ClassTag<K> evidence$24, TypeInformation<EV> evidence$25, scala.reflect.ClassTag<EV> evidence$26) Creates a Graph from a Seq of edges.
static <K,VV,EV> Graph<K,VV,EV>	fromCollection(scala.collection.Seq<Edge<K,EV>> edges, MapFunction<K,VV> vertexValueInitializer, ExecutionEnvironment env, TypeInformation<K> evidence$27, scala.reflect.ClassTag<K> evidence$28, TypeInformation<VV> evidence$29, scala.reflect.ClassTag<VV> evidence$30, TypeInformation<EV> evidence$31, scala.reflect.ClassTag<EV> evidence$32) Creates a graph from a Seq of edges.
static <K,VV,EV> Graph<K,VV,EV>	fromCollection(scala.collection.Seq<Vertex<K,VV>> vertices, scala.collection.Seq<Edge<K,EV>> edges, ExecutionEnvironment env, TypeInformation<K> evidence$17, scala.reflect.ClassTag<K> evidence$18, TypeInformation<VV> evidence$19, scala.reflect.ClassTag<VV> evidence$20, TypeInformation<EV> evidence$21, scala.reflect.ClassTag<EV> evidence$22) Creates a Graph from a Seq of vertices and a Seq of edges.
static <K,VV,EV> Graph<K,VV,EV>	fromCsvReader(ExecutionEnvironment env, String pathEdges, String pathVertices, String lineDelimiterVertices, String fieldDelimiterVertices, Character quoteCharacterVertices, boolean ignoreFirstLineVertices, String ignoreCommentsVertices, boolean lenientVertices, int[] includedFieldsVertices, String lineDelimiterEdges, String fieldDelimiterEdges, Character quoteCharacterEdges, boolean ignoreFirstLineEdges, String ignoreCommentsEdges, boolean lenientEdges, int[] includedFieldsEdges, MapFunction<K,VV> vertexValueInitializer, TypeInformation<K> evidence$55, scala.reflect.ClassTag<K> evidence$56, TypeInformation<VV> evidence$57, scala.reflect.ClassTag<VV> evidence$58, TypeInformation<EV> evidence$59, scala.reflect.ClassTag<EV> evidence$60) Creates a Graph from a CSV file of edges.
static <K,EV> Graph<K,NullValue,EV>	fromDataSet(DataSet<Edge<K,EV>> edges, ExecutionEnvironment env, TypeInformation<K> evidence$7, scala.reflect.ClassTag<K> evidence$8, TypeInformation<EV> evidence$9, scala.reflect.ClassTag<EV> evidence$10) Creates a Graph from a DataSet of edges.
static <K,VV,EV> Graph<K,VV,EV>	fromDataSet(DataSet<Edge<K,EV>> edges, MapFunction<K,VV> vertexValueInitializer, ExecutionEnvironment env, TypeInformation<K> evidence$11, scala.reflect.ClassTag<K> evidence$12, TypeInformation<VV> evidence$13, scala.reflect.ClassTag<VV> evidence$14, TypeInformation<EV> evidence$15, scala.reflect.ClassTag<EV> evidence$16) Creates a graph from a DataSet of edges.
static <K,VV,EV> Graph<K,VV,EV>	fromDataSet(DataSet<Vertex<K,VV>> vertices, DataSet<Edge<K,EV>> edges, ExecutionEnvironment env, TypeInformation<K> evidence$1, scala.reflect.ClassTag<K> evidence$2, TypeInformation<VV> evidence$3, scala.reflect.ClassTag<VV> evidence$4, TypeInformation<EV> evidence$5, scala.reflect.ClassTag<EV> evidence$6) Creates a Graph from a DataSet of vertices and a DataSet of edges.
static <K> Graph<K,NullValue,NullValue>	fromTuple2DataSet(DataSet<scala.Tuple2<K,K>> edges, ExecutionEnvironment env, TypeInformation<K> evidence$49, scala.reflect.ClassTag<K> evidence$50) Creates a Graph from a DataSet of Tuple2's representing the edges.
static <K,VV> Graph<K,VV,NullValue>	fromTuple2DataSet(DataSet<scala.Tuple2<K,K>> edges, MapFunction<K,VV> vertexValueInitializer, ExecutionEnvironment env, TypeInformation<K> evidence$51, scala.reflect.ClassTag<K> evidence$52, TypeInformation<VV> evidence$53, scala.reflect.ClassTag<VV> evidence$54) Creates a Graph from a DataSet of Tuple2's representing the edges.
static <K,VV,EV> Graph<K,VV,EV>	fromTupleDataSet(DataSet<scala.Tuple2<K,VV>> vertices, DataSet<scala.Tuple3<K,K,EV>> edges, ExecutionEnvironment env, TypeInformation<K> evidence$33, scala.reflect.ClassTag<K> evidence$34, TypeInformation<VV> evidence$35, scala.reflect.ClassTag<VV> evidence$36, TypeInformation<EV> evidence$37, scala.reflect.ClassTag<EV> evidence$38) Creates a graph from DataSets of tuples for vertices and for edges.
static <K,EV> Graph<K,NullValue,EV>	fromTupleDataSet(DataSet<scala.Tuple3<K,K,EV>> edges, ExecutionEnvironment env, TypeInformation<K> evidence$39, scala.reflect.ClassTag<K> evidence$40, TypeInformation<EV> evidence$41, scala.reflect.ClassTag<EV> evidence$42) Creates a Graph from a DataSet of Tuples representing the edges.
static <K,VV,EV> Graph<K,VV,EV>	fromTupleDataSet(DataSet<scala.Tuple3<K,K,EV>> edges, MapFunction<K,VV> vertexValueInitializer, ExecutionEnvironment env, TypeInformation<K> evidence$43, scala.reflect.ClassTag<K> evidence$44, TypeInformation<VV> evidence$45, scala.reflect.ClassTag<VV> evidence$46, TypeInformation<EV> evidence$47, scala.reflect.ClassTag<EV> evidence$48) Creates a Graph from a DataSet of Tuples representing the edges.
DataSet<scala.Tuple2<K,Object>>	getDegrees() Return the degree of all vertices in the graph
DataSet<scala.Tuple2<K,K>>	getEdgeIds()
DataSet<Edge<K,EV>>	getEdges()
DataSet<scala.Tuple3<K,K,EV>>	getEdgesAsTuple3()
DataSet<Triplet<K,VV,EV>>	getTriplets()
Graph<K,VV,EV>	getUndirected() This operation adds all inverse-direction edges to the graph.
DataSet<K>	getVertexIds()
DataSet<Vertex<K,VV>>	getVertices()
DataSet<scala.Tuple2<K,VV>>	getVerticesAsTuple2()
Graph<K,VV,EV>	getWrappedGraph()
<T> DataSet<T>	groupReduceOnEdges(EdgesFunction<K,EV,T> edgesFunction, EdgeDirection direction, TypeInformation<T> evidence$85, scala.reflect.ClassTag<T> evidence$86) Compute an aggregate over the edges of each vertex.
<T> DataSet<T>	groupReduceOnEdges(EdgesFunctionWithVertexValue<K,VV,EV,T> edgesFunction, EdgeDirection direction, TypeInformation<T> evidence$83, scala.reflect.ClassTag<T> evidence$84) Compute an aggregate over the edges of each vertex.
<T> DataSet<T>	groupReduceOnNeighbors(NeighborsFunction<K,VV,EV,T> neighborsFunction, EdgeDirection direction, TypeInformation<T> evidence$89, scala.reflect.ClassTag<T> evidence$90) Compute an aggregate over the neighbors (edges and vertices) of each vertex.
<T> DataSet<T>	groupReduceOnNeighbors(NeighborsFunctionWithVertexValue<K,VV,EV,T> neighborsFunction, EdgeDirection direction, TypeInformation<T> evidence$87, scala.reflect.ClassTag<T> evidence$88) Compute an aggregate over the neighbors (edges and vertices) of each vertex.
DataSet<scala.Tuple2<K,Object>>	inDegrees() Return the in-degree of all vertices in the graph
Graph<K,NullValue,EV>	intersect(Graph<K,VV,EV> graph, boolean distinctEdges) Performs intersect on the edge sets of the input graphs.
<T> Graph<K,VV,EV>	joinWithEdges(DataSet<scala.Tuple3<K,K,T>> inputDataSet, EdgeJoinFunction<EV,T> edgeJoinFunction, TypeInformation<T> evidence$77) Joins the edge DataSet with an input DataSet on the composite key of both source and target IDs and applies a user-defined transformation on the values of the matched records.
<T> Graph<K,VV,EV>	joinWithEdges(DataSet<scala.Tuple3<K,K,T>> inputDataSet, scala.Function2<EV,T,EV> fun, TypeInformation<T> evidence$78) Joins the edge DataSet with an input DataSet on the composite key of both source and target IDs and applies a user-defined transformation on the values of the matched records.
<T> Graph<K,VV,EV>	joinWithEdgesOnSource(DataSet<scala.Tuple2<K,T>> inputDataSet, EdgeJoinFunction<EV,T> edgeJoinFunction, TypeInformation<T> evidence$79) Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
<T> Graph<K,VV,EV>	joinWithEdgesOnSource(DataSet<scala.Tuple2<K,T>> inputDataSet, scala.Function2<EV,T,EV> fun, TypeInformation<T> evidence$80) Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
<T> Graph<K,VV,EV>	joinWithEdgesOnTarget(DataSet<scala.Tuple2<K,T>> inputDataSet, EdgeJoinFunction<EV,T> edgeJoinFunction, TypeInformation<T> evidence$81) Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
<T> Graph<K,VV,EV>	joinWithEdgesOnTarget(DataSet<scala.Tuple2<K,T>> inputDataSet, scala.Function2<EV,T,EV> fun, TypeInformation<T> evidence$82) Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
<T> Graph<K,VV,EV>	joinWithVertices(DataSet<scala.Tuple2<K,T>> inputDataSet, scala.Function2<VV,T,VV> fun, TypeInformation<T> evidence$76) Joins the vertex DataSet of this graph with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
<T> Graph<K,VV,EV>	joinWithVertices(DataSet<scala.Tuple2<K,T>> inputDataSet, VertexJoinFunction<VV,T> vertexJoinFunction, TypeInformation<T> evidence$75) Joins the vertex DataSet of this graph with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
<NV> Graph<K,VV,NV>	mapEdges(scala.Function1<Edge<K,EV>,NV> fun, TypeInformation<NV> evidence$73, scala.reflect.ClassTag<NV> evidence$74) Apply a function to the attribute of each edge in the graph.
<NV> Graph<K,VV,NV>	mapEdges(MapFunction<Edge<K,EV>,NV> mapper, TypeInformation<NV> evidence$71, scala.reflect.ClassTag<NV> evidence$72) Apply a function to the attribute of each edge in the graph.
<NV> Graph<K,NV,EV>	mapVertices(scala.Function1<Vertex<K,VV>,NV> fun, TypeInformation<NV> evidence$69, scala.reflect.ClassTag<NV> evidence$70) Apply a function to the attribute of each vertex in the graph.
<NV> Graph<K,NV,EV>	mapVertices(MapFunction<Vertex<K,VV>,NV> mapper, TypeInformation<NV> evidence$67, scala.reflect.ClassTag<NV> evidence$68) Apply a function to the attribute of each vertex in the graph.
long	numberOfEdges()
long	numberOfVertices()
DataSet<scala.Tuple2<K,Object>>	outDegrees() Return the out-degree of all vertices in the graph
DataSet<scala.Tuple2<K,EV>>	reduceOnEdges(ReduceEdgesFunction<EV> reduceEdgesFunction, EdgeDirection direction) Compute a reduce transformation over the neighbors' vertex values of each vertex.
DataSet<scala.Tuple2<K,VV>>	reduceOnNeighbors(ReduceNeighborsFunction<VV> reduceNeighborsFunction, EdgeDirection direction) Compute a reduce transformation over the neighbors' vertex values of each vertex.
Graph<K,VV,EV>	removeEdge(Edge<K,EV> edge) Removes all edges that match the given edge from the graph.
Graph<K,VV,EV>	removeEdges(scala.collection.immutable.List<Edge<K,EV>> edges) Removes all the edges that match the edges in the given data set from the graph.
Graph<K,VV,EV>	removeVertex(Vertex<K,VV> vertex) Removes the given vertex and its edges from the graph.
Graph<K,VV,EV>	removeVertices(scala.collection.immutable.List<Vertex<K,VV>> vertices) Removes the given vertex and its edges from the graph.
Graph<K,VV,EV>	reverse() Reverse the direction of the edges in the graph
<T> T	run(GraphAlgorithm<K,VV,EV,T> algorithm, TypeInformation<T> evidence$91, scala.reflect.ClassTag<T> evidence$92)
<M> Graph<K,VV,EV>	runGatherSumApplyIteration(GatherFunction<VV,EV,M> gatherFunction, SumFunction<VV,EV,M> sumFunction, ApplyFunction<K,VV,M> applyFunction, int maxIterations) Runs a Gather-Sum-Apply iteration on the graph.
<M> Graph<K,VV,EV>	runGatherSumApplyIteration(GatherFunction<VV,EV,M> gatherFunction, SumFunction<VV,EV,M> sumFunction, ApplyFunction<K,VV,M> applyFunction, int maxIterations, GSAConfiguration parameters) Runs a Gather-Sum-Apply iteration on the graph with configuration options.
<M> Graph<K,VV,EV>	runScatterGatherIteration(VertexUpdateFunction<K,VV,M> vertexUpdateFunction, MessagingFunction<K,VV,M,EV> messagingFunction, int maxIterations) Runs a scatter-gather iteration on the graph.
<M> Graph<K,VV,EV>	runScatterGatherIteration(VertexUpdateFunction<K,VV,M> vertexUpdateFunction, MessagingFunction<K,VV,M,EV> messagingFunction, int maxIterations, ScatterGatherConfiguration parameters) Runs a scatter-gather iteration on the graph with configuration options.
Graph<K,VV,EV>	subgraph(FilterFunction<Vertex<K,VV>> vertexFilter, FilterFunction<Edge<K,EV>> edgeFilter) Apply filtering functions to the graph and return a sub-graph that satisfies the predicates for both vertices and edges.
Graph<K,VV,EV>	subgraph(scala.Function1<Vertex<K,VV>,Object> vertexFilterFun, scala.Function1<Edge<K,EV>,Object> edgeFilterFun) Apply filtering functions to the graph and return a sub-graph that satisfies the predicates for both vertices and edges.
Graph<K,VV,EV>	union(Graph<K,VV,EV> graph) Performs union on the vertices and edges sets of the input graphs removing duplicate vertices but maintaining duplicate edges.
boolean	validate(GraphValidator<K,VV,EV> validator)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Graph

public Graph(Graph<K,VV,EV> jgraph,
             TypeInformation<K> evidence$61,
             scala.reflect.ClassTag<K> evidence$62,
             TypeInformation<VV> evidence$63,
             scala.reflect.ClassTag<VV> evidence$64,
             TypeInformation<EV> evidence$65,
             scala.reflect.ClassTag<EV> evidence$66)

Method Detail

fromDataSet

public static <K,VV,EV> Graph<K,VV,EV> fromDataSet(DataSet<Vertex<K,VV>> vertices,
                                                   DataSet<Edge<K,EV>> edges,
                                                   ExecutionEnvironment env,
                                                   TypeInformation<K> evidence$1,
                                                   scala.reflect.ClassTag<K> evidence$2,
                                                   TypeInformation<VV> evidence$3,
                                                   scala.reflect.ClassTag<VV> evidence$4,
                                                   TypeInformation<EV> evidence$5,
                                                   scala.reflect.ClassTag<EV> evidence$6)

Creates a Graph from a DataSet of vertices and a DataSet of edges.

fromDataSet

public static <K,EV> Graph<K,NullValue,EV> fromDataSet(DataSet<Edge<K,EV>> edges,
                                                       ExecutionEnvironment env,
                                                       TypeInformation<K> evidence$7,
                                                       scala.reflect.ClassTag<K> evidence$8,
                                                       TypeInformation<EV> evidence$9,
                                                       scala.reflect.ClassTag<EV> evidence$10)

Creates a Graph from a DataSet of edges. Vertices are created automatically and their values are set to NullValue.

fromDataSet

public static <K,VV,EV> Graph<K,VV,EV> fromDataSet(DataSet<Edge<K,EV>> edges,
                                                   MapFunction<K,VV> vertexValueInitializer,
                                                   ExecutionEnvironment env,
                                                   TypeInformation<K> evidence$11,
                                                   scala.reflect.ClassTag<K> evidence$12,
                                                   TypeInformation<VV> evidence$13,
                                                   scala.reflect.ClassTag<VV> evidence$14,
                                                   TypeInformation<EV> evidence$15,
                                                   scala.reflect.ClassTag<EV> evidence$16)

Creates a graph from a DataSet of edges. Vertices are created automatically and their values are set by applying the provided vertexValueInitializer map function to the vertex ids.

fromCollection

public static <K,VV,EV> Graph<K,VV,EV> fromCollection(scala.collection.Seq<Vertex<K,VV>> vertices,
                                                      scala.collection.Seq<Edge<K,EV>> edges,
                                                      ExecutionEnvironment env,
                                                      TypeInformation<K> evidence$17,
                                                      scala.reflect.ClassTag<K> evidence$18,
                                                      TypeInformation<VV> evidence$19,
                                                      scala.reflect.ClassTag<VV> evidence$20,
                                                      TypeInformation<EV> evidence$21,
                                                      scala.reflect.ClassTag<EV> evidence$22)

Creates a Graph from a Seq of vertices and a Seq of edges.

fromCollection

public static <K,EV> Graph<K,NullValue,EV> fromCollection(scala.collection.Seq<Edge<K,EV>> edges,
                                                          ExecutionEnvironment env,
                                                          TypeInformation<K> evidence$23,
                                                          scala.reflect.ClassTag<K> evidence$24,
                                                          TypeInformation<EV> evidence$25,
                                                          scala.reflect.ClassTag<EV> evidence$26)

Creates a Graph from a Seq of edges. Vertices are created automatically and their values are set to NullValue.

fromCollection

public static <K,VV,EV> Graph<K,VV,EV> fromCollection(scala.collection.Seq<Edge<K,EV>> edges,
                                                      MapFunction<K,VV> vertexValueInitializer,
                                                      ExecutionEnvironment env,
                                                      TypeInformation<K> evidence$27,
                                                      scala.reflect.ClassTag<K> evidence$28,
                                                      TypeInformation<VV> evidence$29,
                                                      scala.reflect.ClassTag<VV> evidence$30,
                                                      TypeInformation<EV> evidence$31,
                                                      scala.reflect.ClassTag<EV> evidence$32)

Creates a graph from a Seq of edges. Vertices are created automatically and their values are set by applying the provided vertexValueInitializer map function to the vertex ids.

fromTupleDataSet

public static <K,VV,EV> Graph<K,VV,EV> fromTupleDataSet(DataSet<scala.Tuple2<K,VV>> vertices,
                                                        DataSet<scala.Tuple3<K,K,EV>> edges,
                                                        ExecutionEnvironment env,
                                                        TypeInformation<K> evidence$33,
                                                        scala.reflect.ClassTag<K> evidence$34,
                                                        TypeInformation<VV> evidence$35,
                                                        scala.reflect.ClassTag<VV> evidence$36,
                                                        TypeInformation<EV> evidence$37,
                                                        scala.reflect.ClassTag<EV> evidence$38)

Creates a graph from DataSets of tuples for vertices and for edges. The first field of the Tuple2 vertex object will become the vertex ID and the second field will become the vertex value. The first field of the Tuple3 object for edges will become the source ID, the second field will become the target ID, and the third field will become the edge value.

fromTupleDataSet

public static <K,EV> Graph<K,NullValue,EV> fromTupleDataSet(DataSet<scala.Tuple3<K,K,EV>> edges,
                                                            ExecutionEnvironment env,
                                                            TypeInformation<K> evidence$39,
                                                            scala.reflect.ClassTag<K> evidence$40,
                                                            TypeInformation<EV> evidence$41,
                                                            scala.reflect.ClassTag<EV> evidence$42)

Creates a Graph from a DataSet of Tuples representing the edges. The first field of the Tuple3 object for edges will become the source ID, the second field will become the target ID, and the third field will become the edge value. Vertices are created automatically and their values are set to NullValue.

fromTupleDataSet

public static <K,VV,EV> Graph<K,VV,EV> fromTupleDataSet(DataSet<scala.Tuple3<K,K,EV>> edges,
                                                        MapFunction<K,VV> vertexValueInitializer,
                                                        ExecutionEnvironment env,
                                                        TypeInformation<K> evidence$43,
                                                        scala.reflect.ClassTag<K> evidence$44,
                                                        TypeInformation<VV> evidence$45,
                                                        scala.reflect.ClassTag<VV> evidence$46,
                                                        TypeInformation<EV> evidence$47,
                                                        scala.reflect.ClassTag<EV> evidence$48)

Creates a Graph from a DataSet of Tuples representing the edges. The first field of the Tuple3 object for edges will become the source ID, the second field will become the target ID, and the third field will become the edge value. Vertices are created automatically and their values are set by applying the provided vertexValueInitializer map function to the vertex ids.

fromTuple2DataSet

public static <K> Graph<K,NullValue,NullValue> fromTuple2DataSet(DataSet<scala.Tuple2<K,K>> edges,
                                                                 ExecutionEnvironment env,
                                                                 TypeInformation<K> evidence$49,
                                                                 scala.reflect.ClassTag<K> evidence$50)

Creates a Graph from a DataSet of Tuple2's representing the edges. The first field of the Tuple2 object for edges will become the source ID, the second field will become the target ID. The edge value will be set to NullValue. Vertices are created automatically and their values are set to NullValue.

fromTuple2DataSet

public static <K,VV> Graph<K,VV,NullValue> fromTuple2DataSet(DataSet<scala.Tuple2<K,K>> edges,
                                                             MapFunction<K,VV> vertexValueInitializer,
                                                             ExecutionEnvironment env,
                                                             TypeInformation<K> evidence$51,
                                                             scala.reflect.ClassTag<K> evidence$52,
                                                             TypeInformation<VV> evidence$53,
                                                             scala.reflect.ClassTag<VV> evidence$54)

Creates a Graph from a DataSet of Tuple2's representing the edges. The first field of the Tuple2 object for edges will become the source ID, the second field will become the target ID. The edge value will be set to NullValue. Vertices are created automatically and their values are set by applying the provided vertexValueInitializer map function to the vertex IDs.

fromCsvReader

public static <K,VV,EV> Graph<K,VV,EV> fromCsvReader(ExecutionEnvironment env,
                                                     String pathEdges,
                                                     String pathVertices,
                                                     String lineDelimiterVertices,
                                                     String fieldDelimiterVertices,
                                                     Character quoteCharacterVertices,
                                                     boolean ignoreFirstLineVertices,
                                                     String ignoreCommentsVertices,
                                                     boolean lenientVertices,
                                                     int[] includedFieldsVertices,
                                                     String lineDelimiterEdges,
                                                     String fieldDelimiterEdges,
                                                     Character quoteCharacterEdges,
                                                     boolean ignoreFirstLineEdges,
                                                     String ignoreCommentsEdges,
                                                     boolean lenientEdges,
                                                     int[] includedFieldsEdges,
                                                     MapFunction<K,VV> vertexValueInitializer,
                                                     TypeInformation<K> evidence$55,
                                                     scala.reflect.ClassTag<K> evidence$56,
                                                     TypeInformation<VV> evidence$57,
                                                     scala.reflect.ClassTag<VV> evidence$58,
                                                     TypeInformation<EV> evidence$59,
                                                     scala.reflect.ClassTag<EV> evidence$60)

Creates a Graph from a CSV file of edges.

The edge value is read from the CSV file if EV is not of type NullValue. Otherwise the edge value is set to NullValue.

If the vertex value type VV is specified (unequal NullValue), then the vertex values are read from the file specified by pathVertices. If the path has not been specified then the vertexValueInitializer is used to initialize the vertex values of the vertices extracted from the set of edges. If the vertexValueInitializer has not been set either, then the method fails.

Parameters:

env - The Execution Environment.

pathEdges - The file path containing the edges.

pathVertices - The file path containing the vertices.

lineDelimiterVertices - The string that separates lines in the vertices file. It defaults to newline.

fieldDelimiterVertices - The string that separates vertex Ids from vertex values in the vertices file.

quoteCharacterVertices - The character to use for quoted String parsing in the vertices file. Disabled by default.

ignoreFirstLineVertices - Whether the first line in the vertices file should be ignored.

ignoreCommentsVertices - Lines that start with the given String in the vertices file are ignored, disabled by default.

lenientVertices - Whether the parser should silently ignore malformed lines in the vertices file.

includedFieldsVertices - The fields in the vertices file that should be read. By default all fields are read.

lineDelimiterEdges - The string that separates lines in the edges file. It defaults to newline.

fieldDelimiterEdges - The string that separates fields in the edges file.

quoteCharacterEdges - The character to use for quoted String parsing in the edges file. Disabled by default.

ignoreFirstLineEdges - Whether the first line in the vertices file should be ignored.

ignoreCommentsEdges - Lines that start with the given String in the edges file are ignored, disabled by default.

lenientEdges - Whether the parser should silently ignore malformed lines in the edges file.

includedFieldsEdges - The fields in the edges file that should be read. By default all fields are read.

vertexValueInitializer - If no vertex values are provided, this mapper can be used to initialize them, by applying a map transformation on the vertex IDs.

Returns:

Graph with vertices and edges read from the given files.

getWrappedGraph

public Graph<K,VV,EV> getWrappedGraph()

clean

public <F> F clean(F f,
                   boolean checkSerializable)

getVertices

public DataSet<Vertex<K,VV>> getVertices()

Returns:

the vertex DataSet.

getEdges

public DataSet<Edge<K,EV>> getEdges()

Returns:

the edge DataSet.

getVerticesAsTuple2

public DataSet<scala.Tuple2<K,VV>> getVerticesAsTuple2()

Returns:

the vertex DataSet as Tuple2.

getEdgesAsTuple3

public DataSet<scala.Tuple3<K,K,EV>> getEdgesAsTuple3()

Returns:

the edge DataSet as Tuple3.

getTriplets

public DataSet<Triplet<K,VV,EV>> getTriplets()

Returns:

a DataSet of Triplets, consisting of (srcVertexId, trgVertexId, srcVertexValue, trgVertexValue, edgeValue)

mapVertices

public <NV> Graph<K,NV,EV> mapVertices(MapFunction<Vertex<K,VV>,NV> mapper,
                                       TypeInformation<NV> evidence$67,
                                       scala.reflect.ClassTag<NV> evidence$68)

Apply a function to the attribute of each vertex in the graph.

Parameters:

mapper - the map function to apply.

Returns:

a new graph

mapVertices

public <NV> Graph<K,NV,EV> mapVertices(scala.Function1<Vertex<K,VV>,NV> fun,
                                       TypeInformation<NV> evidence$69,
                                       scala.reflect.ClassTag<NV> evidence$70)

Apply a function to the attribute of each vertex in the graph.

Parameters:

fun - the map function to apply.

Returns:

a new graph

mapEdges

public <NV> Graph<K,VV,NV> mapEdges(MapFunction<Edge<K,EV>,NV> mapper,
                                    TypeInformation<NV> evidence$71,
                                    scala.reflect.ClassTag<NV> evidence$72)

Apply a function to the attribute of each edge in the graph.

Parameters:

mapper - the map function to apply.

Returns:

a new graph

mapEdges

public <NV> Graph<K,VV,NV> mapEdges(scala.Function1<Edge<K,EV>,NV> fun,
                                    TypeInformation<NV> evidence$73,
                                    scala.reflect.ClassTag<NV> evidence$74)

Apply a function to the attribute of each edge in the graph.

Parameters:

fun - the map function to apply.

Returns:

a new graph

joinWithVertices

public <T> Graph<K,VV,EV> joinWithVertices(DataSet<scala.Tuple2<K,T>> inputDataSet,
                                           VertexJoinFunction<VV,T> vertexJoinFunction,
                                           TypeInformation<T> evidence$75)

Joins the vertex DataSet of this graph with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records. The vertex ID and the first field of the Tuple2 DataSet are used as the join keys.

Parameters:

inputDataSet - the Tuple2 DataSet to join with. The first field of the Tuple2 is used as the join key and the second field is passed as a parameter to the transformation function.

vertexJoinFunction - the transformation function to apply. The first parameter is the current vertex value and the second parameter is the value of the matched Tuple2 from the input DataSet.

Returns:

a new Graph, where the vertex values have been updated according to the result of the vertexJoinFunction.

joinWithVertices

public <T> Graph<K,VV,EV> joinWithVertices(DataSet<scala.Tuple2<K,T>> inputDataSet,
                                           scala.Function2<VV,T,VV> fun,
                                           TypeInformation<T> evidence$76)

Joins the vertex DataSet of this graph with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records. The vertex ID and the first field of the Tuple2 DataSet are used as the join keys.

Parameters:

inputDataSet - the Tuple2 DataSet to join with. The first field of the Tuple2 is used as the join key and the second field is passed as a parameter to the transformation function.

fun - the transformation function to apply. The first parameter is the current vertex value and the second parameter is the value of the matched Tuple2 from the input DataSet.

Returns:

a new Graph, where the vertex values have been updated according to the result of the vertexJoinFunction.

joinWithEdges

public <T> Graph<K,VV,EV> joinWithEdges(DataSet<scala.Tuple3<K,K,T>> inputDataSet,
                                        EdgeJoinFunction<EV,T> edgeJoinFunction,
                                        TypeInformation<T> evidence$77)

Joins the edge DataSet with an input DataSet on the composite key of both source and target IDs and applies a user-defined transformation on the values of the matched records. The first two fields of the input DataSet are used as join keys.

Parameters:

inputDataSet - the DataSet to join with. The first two fields of the Tuple3 are used as the composite join key and the third field is passed as a parameter to the transformation function.

edgeJoinFunction - the transformation function to apply. The first parameter is the current edge value and the second parameter is the value of the matched Tuple3 from the input DataSet.

Returns:

a new Graph, where the edge values have been updated according to the result of the edgeJoinFunction.

joinWithEdges

public <T> Graph<K,VV,EV> joinWithEdges(DataSet<scala.Tuple3<K,K,T>> inputDataSet,
                                        scala.Function2<EV,T,EV> fun,
                                        TypeInformation<T> evidence$78)

Joins the edge DataSet with an input DataSet on the composite key of both source and target IDs and applies a user-defined transformation on the values of the matched records. The first two fields of the input DataSet are used as join keys.

Parameters:

inputDataSet - the DataSet to join with. The first two fields of the Tuple3 are used as the composite join key and the third field is passed as a parameter to the transformation function.

fun - the transformation function to apply. The first parameter is the current edge value and the second parameter is the value of the matched Tuple3 from the input DataSet.

Returns:

a new Graph, where the edge values have been updated according to the result of the edgeJoinFunction.

joinWithEdgesOnSource

public <T> Graph<K,VV,EV> joinWithEdgesOnSource(DataSet<scala.Tuple2<K,T>> inputDataSet,
                                                EdgeJoinFunction<EV,T> edgeJoinFunction,
                                                TypeInformation<T> evidence$79)

Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records. The source ID of the edges input and the first field of the input DataSet are used as join keys.

Parameters:

inputDataSet - the DataSet to join with. The first field of the Tuple2 is used as the join key and the second field is passed as a parameter to the transformation function.

edgeJoinFunction - the transformation function to apply. The first parameter is the current edge value and the second parameter is the value of the matched Tuple2 from the input DataSet.

Returns:

a new Graph, where the edge values have been updated according to the result of the edgeJoinFunction.

joinWithEdgesOnSource

public <T> Graph<K,VV,EV> joinWithEdgesOnSource(DataSet<scala.Tuple2<K,T>> inputDataSet,
                                                scala.Function2<EV,T,EV> fun,
                                                TypeInformation<T> evidence$80)

Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records. The source ID of the edges input and the first field of the input DataSet are used as join keys.

Parameters:

inputDataSet - the DataSet to join with. The first field of the Tuple2 is used as the join key and the second field is passed as a parameter to the transformation function.

fun - the transformation function to apply. The first parameter is the current edge value and the second parameter is the value of the matched Tuple2 from the input DataSet.

Returns:

a new Graph, where the edge values have been updated according to the result of the edgeJoinFunction.

joinWithEdgesOnTarget

public <T> Graph<K,VV,EV> joinWithEdgesOnTarget(DataSet<scala.Tuple2<K,T>> inputDataSet,
                                                EdgeJoinFunction<EV,T> edgeJoinFunction,
                                                TypeInformation<T> evidence$81)

Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records. The target ID of the edges input and the first field of the input DataSet are used as join keys.

Parameters:

inputDataSet - the DataSet to join with. The first field of the Tuple2 is used as the join key and the second field is passed as a parameter to the transformation function.

edgeJoinFunction - the transformation function to apply. The first parameter is the current edge value and the second parameter is the value of the matched Tuple2 from the input DataSet.

Returns:

a new Graph, where the edge values have been updated according to the result of the edgeJoinFunction.

joinWithEdgesOnTarget

public <T> Graph<K,VV,EV> joinWithEdgesOnTarget(DataSet<scala.Tuple2<K,T>> inputDataSet,
                                                scala.Function2<EV,T,EV> fun,
                                                TypeInformation<T> evidence$82)

Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records. The target ID of the edges input and the first field of the input DataSet are used as join keys.

Parameters:

inputDataSet - the DataSet to join with. The first field of the Tuple2 is used as the join key and the second field is passed as a parameter to the transformation function.

fun - the transformation function to apply. The first parameter is the current edge value and the second parameter is the value of the matched Tuple2 from the input DataSet.

Returns:

a new Graph, where the edge values have been updated according to the result of the edgeJoinFunction.

subgraph

public Graph<K,VV,EV> subgraph(FilterFunction<Vertex<K,VV>> vertexFilter,
                               FilterFunction<Edge<K,EV>> edgeFilter)

Apply filtering functions to the graph and return a sub-graph that satisfies the predicates for both vertices and edges.

Parameters:

vertexFilter - the filter function for vertices.

edgeFilter - the filter function for edges.

Returns:

the resulting sub-graph.

subgraph

public Graph<K,VV,EV> subgraph(scala.Function1<Vertex<K,VV>,Object> vertexFilterFun,
                               scala.Function1<Edge<K,EV>,Object> edgeFilterFun)

Apply filtering functions to the graph and return a sub-graph that satisfies the predicates for both vertices and edges.

Parameters:

vertexFilterFun - the filter function for vertices.

edgeFilterFun - the filter function for edges.

Returns:

the resulting sub-graph.

filterOnVertices

public Graph<K,VV,EV> filterOnVertices(FilterFunction<Vertex<K,VV>> vertexFilter)

Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the vertices.

Parameters:

vertexFilter - the filter function for vertices.

Returns:

the resulting sub-graph.

filterOnVertices

public Graph<K,VV,EV> filterOnVertices(scala.Function1<Vertex<K,VV>,Object> vertexFilterFun)

Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the vertices.

Parameters:

vertexFilterFun - the filter function for vertices.

Returns:

the resulting sub-graph.

filterOnEdges

public Graph<K,VV,EV> filterOnEdges(FilterFunction<Edge<K,EV>> edgeFilter)

Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the edges.

Parameters:

edgeFilter - the filter function for edges.

Returns:

the resulting sub-graph.

filterOnEdges

public Graph<K,VV,EV> filterOnEdges(scala.Function1<Edge<K,EV>,Object> edgeFilterFun)

Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the edges.

Parameters:

edgeFilterFun - the filter function for edges.

Returns:

the resulting sub-graph.

inDegrees

public DataSet<scala.Tuple2<K,Object>> inDegrees()

Return the in-degree of all vertices in the graph

Returns:

A DataSet of Tuple2

outDegrees

public DataSet<scala.Tuple2<K,Object>> outDegrees()

Return the out-degree of all vertices in the graph

Returns:

A DataSet of Tuple2

getDegrees

public DataSet<scala.Tuple2<K,Object>> getDegrees()

Return the degree of all vertices in the graph

Returns:

A DataSet of Tuple2

getUndirected

public Graph<K,VV,EV> getUndirected()

This operation adds all inverse-direction edges to the graph.

Returns:

the undirected graph.

reverse

public Graph<K,VV,EV> reverse()

Reverse the direction of the edges in the graph

Returns:

a new graph with all edges reversed

Throws:

UnsupportedOperationException

groupReduceOnEdges

public <T> DataSet<T> groupReduceOnEdges(EdgesFunctionWithVertexValue<K,VV,EV,T> edgesFunction,
                                         EdgeDirection direction,
                                         TypeInformation<T> evidence$83,
                                         scala.reflect.ClassTag<T> evidence$84)

Compute an aggregate over the edges of each vertex. The function applied on the edges has access to the vertex value.

Parameters:

edgesFunction - the function to apply to the neighborhood

direction - the edge direction (in-, out-, all-)

Returns:

a dataset of a T

groupReduceOnEdges

public <T> DataSet<T> groupReduceOnEdges(EdgesFunction<K,EV,T> edgesFunction,
                                         EdgeDirection direction,
                                         TypeInformation<T> evidence$85,
                                         scala.reflect.ClassTag<T> evidence$86)

Compute an aggregate over the edges of each vertex. The function applied on the edges has access to the vertex value.

Parameters:

edgesFunction - the function to apply to the neighborhood

direction - the edge direction (in-, out-, all-)

Returns:

a dataset of a T

groupReduceOnNeighbors

public <T> DataSet<T> groupReduceOnNeighbors(NeighborsFunctionWithVertexValue<K,VV,EV,T> neighborsFunction,
                                             EdgeDirection direction,
                                             TypeInformation<T> evidence$87,
                                             scala.reflect.ClassTag<T> evidence$88)

Compute an aggregate over the neighbors (edges and vertices) of each vertex. The function applied on the neighbors has access to the vertex value.

Parameters:

neighborsFunction - the function to apply to the neighborhood

direction - the edge direction (in-, out-, all-)

Returns:

a dataset of a T

groupReduceOnNeighbors

public <T> DataSet<T> groupReduceOnNeighbors(NeighborsFunction<K,VV,EV,T> neighborsFunction,
                                             EdgeDirection direction,
                                             TypeInformation<T> evidence$89,
                                             scala.reflect.ClassTag<T> evidence$90)

Compute an aggregate over the neighbors (edges and vertices) of each vertex.

Parameters:

neighborsFunction - the function to apply to the neighborhood

direction - the edge direction (in-, out-, all-)

Returns:

a dataset of a T

numberOfVertices

public long numberOfVertices()

Returns:

a long integer representing the number of vertices

numberOfEdges

public long numberOfEdges()

Returns:

a long integer representing the number of edges

getVertexIds

public DataSet<K> getVertexIds()

Returns:

The IDs of the vertices as DataSet

getEdgeIds

public DataSet<scala.Tuple2<K,K>> getEdgeIds()

Returns:

The IDs of the edges as DataSet

addVertex

public Graph<K,VV,EV> addVertex(Vertex<K,VV> vertex)

Adds the input vertex to the graph. If the vertex already exists in the graph, it will not be added again.

Parameters:

vertex - the vertex to be added

Returns:

the new graph containing the existing vertices as well as the one just added

addVertices

public Graph<K,VV,EV> addVertices(scala.collection.immutable.List<Vertex<K,VV>> vertices)

Adds the list of vertices, passed as input, to the graph. If the vertices already exist in the graph, they will not be added once more.

Parameters:

vertices - the list of vertices to add

Returns:

the new graph containing the existing and newly added vertices

addEdges

public Graph<K,VV,EV> addEdges(scala.collection.immutable.List<Edge<K,EV>> edges)

Adds the given list edges to the graph.

When adding an edge for a non-existing set of vertices, the edge is considered invalid and ignored.

Parameters:

edges - the data set of edges to be added

Returns:

a new graph containing the existing edges plus the newly added edges.

addEdge

public Graph<K,VV,EV> addEdge(Vertex<K,VV> source,
                              Vertex<K,VV> target,
                              EV edgeValue)

Adds the given edge to the graph. If the source and target vertices do not exist in the graph, they will also be added.

Parameters:

source - the source vertex of the edge

target - the target vertex of the edge

edgeValue - the edge value

Returns:

the new graph containing the existing vertices and edges plus the newly added edge

removeVertex

public Graph<K,VV,EV> removeVertex(Vertex<K,VV> vertex)

Removes the given vertex and its edges from the graph.

Parameters:

vertex - the vertex to remove

Returns:

the new graph containing the existing vertices and edges without the removed vertex and its edges

removeVertices

public Graph<K,VV,EV> removeVertices(scala.collection.immutable.List<Vertex<K,VV>> vertices)

Removes the given vertex and its edges from the graph.

Parameters:

vertices - list of vertices to remove

Returns:

the new graph containing the existing vertices and edges without the removed vertex and its edges

removeEdge

public Graph<K,VV,EV> removeEdge(Edge<K,EV> edge)

Removes all edges that match the given edge from the graph.

Parameters:

edge - the edge to remove

Returns:

the new graph containing the existing vertices and edges without the removed edges

removeEdges

public Graph<K,VV,EV> removeEdges(scala.collection.immutable.List<Edge<K,EV>> edges)

Removes all the edges that match the edges in the given data set from the graph.

Parameters:

edges - the list of edges to be removed

Returns:

a new graph where the edges have been removed and in which the vertices remained intact

union

public Graph<K,VV,EV> union(Graph<K,VV,EV> graph)

Performs union on the vertices and edges sets of the input graphs removing duplicate vertices but maintaining duplicate edges.

Parameters:

graph - the graph to perform union with

Returns:

a new graph

difference

public Graph<K,VV,EV> difference(Graph<K,VV,EV> graph)

Performs Difference on the vertex and edge sets of the input graphs removes common vertices and edges. If a source/target vertex is removed, its corresponding edge will also be removed

Parameters:

graph - the graph to perform difference with

Returns:

a new graph where the common vertices and edges have been removed

intersect

public Graph<K,NullValue,EV> intersect(Graph<K,VV,EV> graph,
                                       boolean distinctEdges)

Performs intersect on the edge sets of the input graphs. Edges are considered equal, if they have the same source identifier, target identifier and edge value.

The method computes pairs of equal edges from the input graphs. If the same edge occurs multiple times in the input graphs, there will be multiple edge pairs to be considered. Each edge instance can only be part of one pair. If the given parameter distinctEdges is set to true, there will be exactly one edge in the output graph representing all pairs of equal edges. If the parameter is set to false, both edges of each pair will be in the output.

Vertices in the output graph will have no vertex values.

Parameters:

graph - the graph to perform intersect with

distinctEdges - if set to { @code true}, there will be exactly one edge in the output graph representing all pairs of equal edges, otherwise, for each pair, both edges will be in the output graph

Returns:

a new graph which contains only common vertices and edges from the input graphs

reduceOnNeighbors

public DataSet<scala.Tuple2<K,VV>> reduceOnNeighbors(ReduceNeighborsFunction<VV> reduceNeighborsFunction,
                                                     EdgeDirection direction)

Compute a reduce transformation over the neighbors' vertex values of each vertex. For each vertex, the transformation consecutively calls a ReduceNeighborsFunction until only a single value for each vertex remains. The ReduceNeighborsFunction combines a pair of neighbor vertex values into one new value of the same type.

Parameters:

reduceNeighborsFunction - the reduce function to apply to the neighbors of each vertex.

direction - the edge direction (in-, out-, all-)

Returns:

a Dataset of Tuple2, with one tuple per vertex. The first field of the Tuple2 is the vertex ID and the second field is the aggregate value computed by the provided ReduceNeighborsFunction.

reduceOnEdges

public DataSet<scala.Tuple2<K,EV>> reduceOnEdges(ReduceEdgesFunction<EV> reduceEdgesFunction,
                                                 EdgeDirection direction)

Compute a reduce transformation over the neighbors' vertex values of each vertex. For each vertex, the transformation consecutively calls a ReduceNeighborsFunction until only a single value for each vertex remains. The ReduceNeighborsFunction combines a pair of neighbor vertex values into one new value of the same type.

Parameters:

reduceEdgesFunction - the reduce function to apply to the edges of each vertex.

direction - the edge direction (in-, out-, all-)

Returns:

a Dataset of Tuple2, with one tuple per vertex. The first field of the Tuple2 is the vertex ID and the second field is the aggregate value computed by the provided ReduceNeighborsFunction.

run

public <T> T run(GraphAlgorithm<K,VV,EV,T> algorithm,
                 TypeInformation<T> evidence$91,
                 scala.reflect.ClassTag<T> evidence$92)

runScatterGatherIteration

public <M> Graph<K,VV,EV> runScatterGatherIteration(VertexUpdateFunction<K,VV,M> vertexUpdateFunction,
                                                    MessagingFunction<K,VV,M,EV> messagingFunction,
                                                    int maxIterations)

Runs a scatter-gather iteration on the graph. No configuration options are provided.

Parameters:

vertexUpdateFunction - the vertex update function

messagingFunction - the messaging function

maxIterations - maximum number of iterations to perform

Returns:

the updated Graph after the scatter-gather iteration has converged or after maximumNumberOfIterations.

runScatterGatherIteration

public <M> Graph<K,VV,EV> runScatterGatherIteration(VertexUpdateFunction<K,VV,M> vertexUpdateFunction,
                                                    MessagingFunction<K,VV,M,EV> messagingFunction,
                                                    int maxIterations,
                                                    ScatterGatherConfiguration parameters)

Runs a scatter-gather iteration on the graph with configuration options.

Parameters:

vertexUpdateFunction - the vertex update function

messagingFunction - the messaging function

maxIterations - maximum number of iterations to perform

parameters - the iteration configuration parameters

Returns:

the updated Graph after the scatter-gather iteration has converged or after maximumNumberOfIterations.

runGatherSumApplyIteration

public <M> Graph<K,VV,EV> runGatherSumApplyIteration(GatherFunction<VV,EV,M> gatherFunction,
                                                     SumFunction<VV,EV,M> sumFunction,
                                                     ApplyFunction<K,VV,M> applyFunction,
                                                     int maxIterations)

Runs a Gather-Sum-Apply iteration on the graph. No configuration options are provided.

Parameters:

gatherFunction - the gather function collects information about adjacent vertices and edges

sumFunction - the sum function aggregates the gathered information

applyFunction - the apply function updates the vertex values with the aggregates

maxIterations - maximum number of iterations to perform

Returns:

the updated Graph after the gather-sum-apply iteration has converged or after maximumNumberOfIterations.

runGatherSumApplyIteration

public <M> Graph<K,VV,EV> runGatherSumApplyIteration(GatherFunction<VV,EV,M> gatherFunction,
                                                     SumFunction<VV,EV,M> sumFunction,
                                                     ApplyFunction<K,VV,M> applyFunction,
                                                     int maxIterations,
                                                     GSAConfiguration parameters)

Runs a Gather-Sum-Apply iteration on the graph with configuration options.

Parameters:

gatherFunction - the gather function collects information about adjacent vertices and edges

sumFunction - the sum function aggregates the gathered information

applyFunction - the apply function updates the vertex values with the aggregates

maxIterations - maximum number of iterations to perform

parameters - the iteration configuration parameters

Returns:

the updated Graph after the gather-sum-apply iteration has converged or after maximumNumberOfIterations.

validate

public boolean validate(GraphValidator<K,VV,EV> validator)