Graph

Instance Constructors

new Graph(jgraph: graph.Graph[K, VV, EV])(implicit arg0: TypeInformation[K], arg1: ClassTag[K], arg2: TypeInformation[VV], arg3: ClassTag[VV], arg4: TypeInformation[EV], arg5: ClassTag[EV])

jgraph
the underlying java api Graph.

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def addEdge(source: Vertex[K, VV], target: Vertex[K, VV], edgeValue: EV): Graph[K, VV, EV]

Adds the given edge to the graph.
Adds the given edge to the graph. If the source and target vertices do not exist in the graph, they will also be added.
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
def addEdges(edges: List[Edge[K, EV]]): Graph[K, VV, EV]

Adds the given list edges to the graph.
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.
edges
the data set of edges to be added
returns
a new graph containing the existing edges plus the newly added edges.
def addVertex(vertex: Vertex[K, VV]): Graph[K, VV, EV]

Adds the input vertex to the graph.
Adds the input vertex to the graph. If the vertex already exists in the graph, it will not be added again.
vertex
the vertex to be added
returns
the new graph containing the existing vertices as well as the one just added
def addVertices(vertices: List[Vertex[K, VV]]): Graph[K, VV, EV]

Adds the list of vertices, passed as input, to the graph.
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.
vertices
the list of vertices to add
returns
the new graph containing the existing and newly added vertices
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def difference(graph: Graph[K, VV, EV]): Graph[K, VV, EV]

Performs Difference on the vertex and edge sets of the input graphs removes common vertices and edges.
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
graph
the graph to perform difference with
returns
a new graph where the common vertices and edges have been removed
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def filterOnEdges(edgeFilterFun: (Edge[K, EV]) ⇒ Boolean): Graph[K, VV, EV]

Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the edges.
Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the edges.
edgeFilterFun
the filter function for edges.
returns
the resulting sub-graph.
def filterOnEdges(edgeFilter: FilterFunction[Edge[K, EV]]): Graph[K, VV, EV]

Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the edges.
Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the edges.
edgeFilter
the filter function for edges.
returns
the resulting sub-graph.
def filterOnVertices(vertexFilterFun: (Vertex[K, VV]) ⇒ Boolean): Graph[K, VV, EV]

Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the vertices.
Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the vertices.
vertexFilterFun
the filter function for vertices.
returns
the resulting sub-graph.
def filterOnVertices(vertexFilter: FilterFunction[Vertex[K, VV]]): Graph[K, VV, EV]

Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the vertices.
Apply a filtering function to the graph and return a sub-graph that satisfies the predicates only for the vertices.
vertexFilter
the filter function for vertices.
returns
the resulting sub-graph.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getDegrees(): DataSet[(K, LongValue)]

Return the degree of all vertices in the graph
Return the degree of all vertices in the graph
returns
A DataSet of Tuple2<vertexId, degree>
def getEdgeIds(): DataSet[(K, K)]

returns
The IDs of the edges as DataSet
def getEdges: DataSet[Edge[K, EV]]

returns
the edge DataSet.
def getEdgesAsTuple3(): DataSet[(K, K, EV)]

returns
the edge DataSet as Tuple3.
def getTriplets(): DataSet[Triplet[K, VV, EV]]

returns
a DataSet of Triplets, consisting of (srcVertexId, trgVertexId, srcVertexValue, trgVertexValue, edgeValue)
def getUndirected(): Graph[K, VV, EV]

This operation adds all inverse-direction edges to the graph.
This operation adds all inverse-direction edges to the graph.
returns
the undirected graph.
def getVertexIds(): DataSet[K]

returns
The IDs of the vertices as DataSet
def getVertices: DataSet[Vertex[K, VV]]

returns
the vertex DataSet.
def getVerticesAsTuple2(): DataSet[(K, VV)]

returns
the vertex DataSet as Tuple2.
def groupReduceOnEdges[T](edgesFunction: EdgesFunction[K, EV, T], direction: EdgeDirection)(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): DataSet[T]

Compute an aggregate over the edges of each vertex.
Compute an aggregate over the edges of each vertex. The function applied on the edges has access to the vertex value.
T
the output type
edgesFunction
the function to apply to the neighborhood
direction
the edge direction (in-, out-, all-)
returns
a dataset of a T
def groupReduceOnEdges[T](edgesFunction: EdgesFunctionWithVertexValue[K, VV, EV, T], direction: EdgeDirection)(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): DataSet[T]

Compute an aggregate over the edges of each vertex.
Compute an aggregate over the edges of each vertex. The function applied on the edges has access to the vertex value.
T
the output type
edgesFunction
the function to apply to the neighborhood
direction
the edge direction (in-, out-, all-)
returns
a dataset of a T
def groupReduceOnNeighbors[T](neighborsFunction: NeighborsFunction[K, VV, EV, T], direction: EdgeDirection)(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): DataSet[T]

Compute an aggregate over the neighbors (edges and vertices) of each vertex.
Compute an aggregate over the neighbors (edges and vertices) of each vertex.
T
the output type
neighborsFunction
the function to apply to the neighborhood
direction
the edge direction (in-, out-, all-)
returns
a dataset of a T
def groupReduceOnNeighbors[T](neighborsFunction: NeighborsFunctionWithVertexValue[K, VV, EV, T], direction: EdgeDirection)(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): DataSet[T]

Compute an aggregate over the neighbors (edges and vertices) of each vertex.
Compute an aggregate over the neighbors (edges and vertices) of each vertex. The function applied on the neighbors has access to the vertex value.
T
the output type
neighborsFunction
the function to apply to the neighborhood
direction
the edge direction (in-, out-, all-)
returns
a dataset of a T
def hashCode(): Int

Definition Classes
AnyRef → Any
def inDegrees(): DataSet[(K, LongValue)]

Return the in-degree of all vertices in the graph
Return the in-degree of all vertices in the graph
returns
A DataSet of Tuple2<vertexId, inDegree>
def intersect(graph: Graph[K, VV, EV], distinctEdges: Boolean): Graph[K, NullValue, EV]

Performs intersect on the edge sets of the input graphs.
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.
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
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def joinWithEdges[T](inputDataSet: DataSet[(K, K, T)], fun: (EV, T) ⇒ EV)(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

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.
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.
T
the type of the third field of the input Tuple3 DataSet.
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.
def joinWithEdges[T](inputDataSet: DataSet[(K, K, T)], edgeJoinFunction: EdgeJoinFunction[EV, T])(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

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.
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.
T
the type of the third field of the input Tuple3 DataSet.
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.
def joinWithEdgesOnSource[T](inputDataSet: DataSet[(K, T)], fun: (EV, T) ⇒ EV)(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
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.
T
the type of the second field of the input Tuple2 DataSet.
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.
def joinWithEdgesOnSource[T](inputDataSet: DataSet[(K, T)], edgeJoinFunction: EdgeJoinFunction[EV, T])(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
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.
T
the type of the second field of the input Tuple2 DataSet.
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.
def joinWithEdgesOnTarget[T](inputDataSet: DataSet[(K, T)], fun: (EV, T) ⇒ EV)(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
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.
T
the type of the second field of the input Tuple2 DataSet.
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.
def joinWithEdgesOnTarget[T](inputDataSet: DataSet[(K, T)], edgeJoinFunction: EdgeJoinFunction[EV, T])(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

Joins the edge DataSet with an input Tuple2 DataSet and applies a user-defined transformation on the values of the matched records.
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.
T
the type of the second field of the input Tuple2 DataSet.
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.
def joinWithVertices[T](inputDataSet: DataSet[(K, T)], fun: (VV, T) ⇒ VV)(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

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.
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.
T
the type of the second field of the input Tuple2 DataSet.
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.
def joinWithVertices[T](inputDataSet: DataSet[(K, T)], vertexJoinFunction: VertexJoinFunction[VV, T])(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

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.
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.
T
the type of the second field of the input Tuple2 DataSet.
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.
def mapEdges[NV](fun: (Edge[K, EV]) ⇒ NV)(implicit arg0: TypeInformation[NV], arg1: ClassTag[NV]): Graph[K, VV, NV]

Apply a function to the attribute of each edge in the graph.
Apply a function to the attribute of each edge in the graph.
fun
the map function to apply.
returns
a new graph
def mapEdges[NV](mapper: MapFunction[Edge[K, EV], NV])(implicit arg0: TypeInformation[NV], arg1: ClassTag[NV]): Graph[K, VV, NV]

Apply a function to the attribute of each edge in the graph.
Apply a function to the attribute of each edge in the graph.
mapper
the map function to apply.
returns
a new graph
def mapVertices[NV](fun: (Vertex[K, VV]) ⇒ NV)(implicit arg0: TypeInformation[NV], arg1: ClassTag[NV]): Graph[K, NV, EV]

Apply a function to the attribute of each vertex in the graph.
Apply a function to the attribute of each vertex in the graph.
fun
the map function to apply.
returns
a new graph
def mapVertices[NV](mapper: MapFunction[Vertex[K, VV], NV])(implicit arg0: TypeInformation[NV], arg1: ClassTag[NV]): Graph[K, NV, EV]

Apply a function to the attribute of each vertex in the graph.
Apply a function to the attribute of each vertex in the graph.
mapper
the map function to apply.
returns
a new graph
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def numberOfEdges(): Long

returns
a long integer representing the number of edges
def numberOfVertices(): Long

returns
a long integer representing the number of vertices
def outDegrees(): DataSet[(K, LongValue)]

Return the out-degree of all vertices in the graph
Return the out-degree of all vertices in the graph
returns
A DataSet of Tuple2<vertexId, outDegree>
def reduceOnEdges(reduceEdgesFunction: ReduceEdgesFunction[EV], direction: EdgeDirection): DataSet[(K, EV)]

Compute a reduce transformation over the neighbors' vertex values of each vertex.
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.
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.
def reduceOnNeighbors(reduceNeighborsFunction: ReduceNeighborsFunction[VV], direction: EdgeDirection): DataSet[(K, VV)]

Compute a reduce transformation over the neighbors' vertex values of each vertex.
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.
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.
def removeEdge(edge: Edge[K, EV]): Graph[K, VV, EV]

Removes all edges that match the given edge from the graph.
Removes all edges that match the given edge from the graph.
edge
the edge to remove
returns
the new graph containing the existing vertices and edges without the removed edges
def removeEdges(edges: List[Edge[K, EV]]): Graph[K, VV, EV]

Removes all the edges that match the edges in the given data set from the graph.
Removes all the edges that match the edges in the given data set from the graph.
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
def removeVertex(vertex: Vertex[K, VV]): Graph[K, VV, EV]

Removes the given vertex and its edges from the graph.
Removes the given vertex and its edges from the graph.
vertex
the vertex to remove
returns
the new graph containing the existing vertices and edges without the removed vertex and its edges
def removeVertices(vertices: List[Vertex[K, VV]]): Graph[K, VV, EV]

Removes the given vertex and its edges from the graph.
Removes the given vertex and its edges from the graph.
vertices
list of vertices to remove
returns
the new graph containing the existing vertices and edges without the removed vertex and its edges
def reverse(): Graph[K, VV, EV]

Reverse the direction of the edges in the graph
Reverse the direction of the edges in the graph
returns
a new graph with all edges reversed

Exceptions thrown
def run[T](analytic: GraphAnalytic[K, VV, EV, T])(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): GraphAnalytic[K, VV, EV, T]

A GraphAnalytic is similar to a GraphAlgorithm but is terminal and results are retrieved via accumulators.
A GraphAnalytic is similar to a GraphAlgorithm but is terminal and results are retrieved via accumulators. A Flink program has a single point of execution. A GraphAnalytic defers execution to the user to allow composing multiple analytics and algorithms into a single program.
analytic
the analytic to run on the Graph
def run[T](algorithm: GraphAlgorithm[K, VV, EV, T])(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): T

algorithm
the algorithm to run on the Graph
returns
the result of the graph algorithm
def runGatherSumApplyIteration[M](gatherFunction: GatherFunction[VV, EV, M], sumFunction: SumFunction[VV, EV, M], applyFunction: ApplyFunction[K, VV, M], maxIterations: Int, parameters: GSAConfiguration): Graph[K, VV, EV]

Runs a Gather-Sum-Apply iteration on the graph with configuration options.
Runs a Gather-Sum-Apply iteration on the graph with configuration options.
M
the intermediate type used between gather, sum and apply
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.
def runGatherSumApplyIteration[M](gatherFunction: GatherFunction[VV, EV, M], sumFunction: SumFunction[VV, EV, M], applyFunction: ApplyFunction[K, VV, M], maxIterations: Int): Graph[K, VV, EV]

Runs a Gather-Sum-Apply iteration on the graph.
Runs a Gather-Sum-Apply iteration on the graph. No configuration options are provided.
M
the intermediate type used between gather, sum and apply
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.
def runScatterGatherIteration[M](scatterFunction: ScatterFunction[K, VV, M, EV], gatherFunction: GatherFunction[K, VV, M], maxIterations: Int, parameters: ScatterGatherConfiguration): Graph[K, VV, EV]

Runs a scatter-gather iteration on the graph with configuration options.
Runs a scatter-gather iteration on the graph with configuration options.
scatterFunction
the scatter function
gatherFunction
the gather 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.
def runScatterGatherIteration[M](scatterFunction: ScatterFunction[K, VV, M, EV], gatherFunction: GatherFunction[K, VV, M], maxIterations: Int): Graph[K, VV, EV]

Runs a scatter-gather iteration on the graph.
Runs a scatter-gather iteration on the graph. No configuration options are provided.
scatterFunction
the scatter function
gatherFunction
the gather function
maxIterations
maximum number of iterations to perform
returns
the updated Graph after the scatter-gather iteration has converged or after maximumNumberOfIterations.
def runVertexCentricIteration[M](computeFunction: ComputeFunction[K, VV, EV, M], combineFunction: MessageCombiner[K, M], maxIterations: Int, parameters: VertexCentricConfiguration): Graph[K, VV, EV]

Runs a vertex-centric iteration on the graph with configuration options.
Runs a vertex-centric iteration on the graph with configuration options.
computeFunction
the compute function
combineFunction
the optional message combiner function
maxIterations
maximum number of iterations to perform
parameters
the iteration configuration parameters
returns
the updated Graph after the vertex-centric iteration has converged or after maximumNumberOfIterations.
def runVertexCentricIteration[M](computeFunction: ComputeFunction[K, VV, EV, M], combineFunction: MessageCombiner[K, M], maxIterations: Int): Graph[K, VV, EV]

Runs a vertex-centric iteration on the graph.
Runs a vertex-centric iteration on the graph. No configuration options are provided.
computeFunction
the compute function
combineFunction
the optional message combiner function
maxIterations
maximum number of iterations to perform
returns
the updated Graph after the vertex-centric iteration has converged or after maximumNumberOfIterations.
def subgraph(vertexFilterFun: (Vertex[K, VV]) ⇒ Boolean, edgeFilterFun: (Edge[K, EV]) ⇒ Boolean): Graph[K, VV, EV]

Apply filtering functions to the graph and return a sub-graph that satisfies the predicates for both vertices and edges.
Apply filtering functions to the graph and return a sub-graph that satisfies the predicates for both vertices and edges.
vertexFilterFun
the filter function for vertices.
edgeFilterFun
the filter function for edges.
returns
the resulting sub-graph.
def subgraph(vertexFilter: FilterFunction[Vertex[K, VV]], edgeFilter: FilterFunction[Edge[K, EV]]): Graph[K, VV, EV]

Apply filtering functions to the graph and return a sub-graph that satisfies the predicates for both vertices and edges.
Apply filtering functions to the graph and return a sub-graph that satisfies the predicates for both vertices and edges.
vertexFilter
the filter function for vertices.
edgeFilter
the filter function for edges.
returns
the resulting sub-graph.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def translateEdgeValues[NEW](fun: (EV, NEW) ⇒ NEW)(implicit arg0: TypeInformation[NEW], arg1: ClassTag[NEW]): Graph[K, VV, NEW]

Translate edge values using the given function.
Translate edge values using the given function.
fun
implements conversion from EV to NEW
returns
graph with translated edge values
def translateEdgeValues[NEW](translator: TranslateFunction[EV, NEW])(implicit arg0: TypeInformation[NEW], arg1: ClassTag[NEW]): Graph[K, VV, NEW]

Translate edge values using the given MapFunction.
Translate edge values using the given MapFunction.
translator
implements conversion from EV to NEW
returns
graph with translated edge values
def translateGraphIds[NEW](fun: (K, NEW) ⇒ NEW)(implicit arg0: TypeInformation[NEW], arg1: ClassTag[NEW]): Graph[NEW, VV, EV]

Translate vertex and edge IDs using the given function.
Translate vertex and edge IDs using the given function.
fun
implements conversion from K to NEW
returns
graph with translated vertex and edge IDs
def translateGraphIds[NEW](translator: TranslateFunction[K, NEW])(implicit arg0: TypeInformation[NEW], arg1: ClassTag[NEW]): Graph[NEW, VV, EV]

Translate vertex and edge IDs using the given MapFunction.
Translate vertex and edge IDs using the given MapFunction.
translator
implements conversion from K to NEW
returns
graph with translated vertex and edge IDs
def translateVertexValues[NEW](fun: (VV, NEW) ⇒ NEW)(implicit arg0: TypeInformation[NEW], arg1: ClassTag[NEW]): Graph[K, NEW, EV]

Translate vertex values using the given function.
Translate vertex values using the given function.
fun
implements conversion from VV to NEW
returns
graph with translated vertex values
def translateVertexValues[NEW](translator: TranslateFunction[VV, NEW])(implicit arg0: TypeInformation[NEW], arg1: ClassTag[NEW]): Graph[K, NEW, EV]

Translate vertex values using the given MapFunction.
Translate vertex values using the given MapFunction.
translator
implements conversion from VV to NEW
returns
graph with translated vertex values
def union(graph: Graph[K, VV, EV]): Graph[K, VV, EV]

Performs union on the vertices and edges sets of the input graphs removing duplicate vertices but maintaining duplicate edges.
Performs union on the vertices and edges sets of the input graphs removing duplicate vertices but maintaining duplicate edges.
graph
the graph to perform union with
returns
a new graph
def validate(validator: GraphValidator[K, VV, EV]): Boolean
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object Graph | package scala

final class Graph[K, VV, EV] extends AnyRef

Instance Constructors

new Graph(jgraph: graph.Graph[K, VV, EV])(implicit arg0: TypeInformation[K], arg1: ClassTag[K], arg2: TypeInformation[VV], arg3: ClassTag[VV], arg4: TypeInformation[EV], arg5: ClassTag[EV])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addEdge(source: Vertex[K, VV], target: Vertex[K, VV], edgeValue: EV): Graph[K, VV, EV]

def addEdges(edges: List[Edge[K, EV]]): Graph[K, VV, EV]

def addVertex(vertex: Vertex[K, VV]): Graph[K, VV, EV]

def addVertices(vertices: List[Vertex[K, VV]]): Graph[K, VV, EV]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def difference(graph: Graph[K, VV, EV]): Graph[K, VV, EV]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filterOnEdges(edgeFilterFun: (Edge[K, EV]) ⇒ Boolean): Graph[K, VV, EV]

def filterOnEdges(edgeFilter: FilterFunction[Edge[K, EV]]): Graph[K, VV, EV]

def filterOnVertices(vertexFilterFun: (Vertex[K, VV]) ⇒ Boolean): Graph[K, VV, EV]

def filterOnVertices(vertexFilter: FilterFunction[Vertex[K, VV]]): Graph[K, VV, EV]

def finalize(): Unit

final def getClass(): Class[_]

def getDegrees(): DataSet[(K, LongValue)]

def getEdgeIds(): DataSet[(K, K)]

def getEdges: DataSet[Edge[K, EV]]

def getEdgesAsTuple3(): DataSet[(K, K, EV)]

def getTriplets(): DataSet[Triplet[K, VV, EV]]

def getUndirected(): Graph[K, VV, EV]

def getVertexIds(): DataSet[K]

def getVertices: DataSet[Vertex[K, VV]]

def getVerticesAsTuple2(): DataSet[(K, VV)]

def groupReduceOnEdges[T](edgesFunction: EdgesFunction[K, EV, T], direction: EdgeDirection)(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): DataSet[T]

def groupReduceOnEdges[T](edgesFunction: EdgesFunctionWithVertexValue[K, VV, EV, T], direction: EdgeDirection)(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): DataSet[T]

def groupReduceOnNeighbors[T](neighborsFunction: NeighborsFunction[K, VV, EV, T], direction: EdgeDirection)(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): DataSet[T]

def groupReduceOnNeighbors[T](neighborsFunction: NeighborsFunctionWithVertexValue[K, VV, EV, T], direction: EdgeDirection)(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): DataSet[T]

def hashCode(): Int

def inDegrees(): DataSet[(K, LongValue)]

def intersect(graph: Graph[K, VV, EV], distinctEdges: Boolean): Graph[K, NullValue, EV]

final def isInstanceOf[T0]: Boolean

def joinWithEdges[T](inputDataSet: DataSet[(K, K, T)], fun: (EV, T) ⇒ EV)(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

def joinWithEdges[T](inputDataSet: DataSet[(K, K, T)], edgeJoinFunction: EdgeJoinFunction[EV, T])(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

def joinWithEdgesOnSource[T](inputDataSet: DataSet[(K, T)], fun: (EV, T) ⇒ EV)(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

def joinWithEdgesOnSource[T](inputDataSet: DataSet[(K, T)], edgeJoinFunction: EdgeJoinFunction[EV, T])(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

def joinWithEdgesOnTarget[T](inputDataSet: DataSet[(K, T)], fun: (EV, T) ⇒ EV)(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

def joinWithEdgesOnTarget[T](inputDataSet: DataSet[(K, T)], edgeJoinFunction: EdgeJoinFunction[EV, T])(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

def joinWithVertices[T](inputDataSet: DataSet[(K, T)], fun: (VV, T) ⇒ VV)(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

def joinWithVertices[T](inputDataSet: DataSet[(K, T)], vertexJoinFunction: VertexJoinFunction[VV, T])(implicit arg0: TypeInformation[T]): Graph[K, VV, EV]

def mapEdges[NV](fun: (Edge[K, EV]) ⇒ NV)(implicit arg0: TypeInformation[NV], arg1: ClassTag[NV]): Graph[K, VV, NV]

def mapEdges[NV](mapper: MapFunction[Edge[K, EV], NV])(implicit arg0: TypeInformation[NV], arg1: ClassTag[NV]): Graph[K, VV, NV]

def mapVertices[NV](fun: (Vertex[K, VV]) ⇒ NV)(implicit arg0: TypeInformation[NV], arg1: ClassTag[NV]): Graph[K, NV, EV]

def mapVertices[NV](mapper: MapFunction[Vertex[K, VV], NV])(implicit arg0: TypeInformation[NV], arg1: ClassTag[NV]): Graph[K, NV, EV]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numberOfEdges(): Long

def numberOfVertices(): Long

def outDegrees(): DataSet[(K, LongValue)]

def reduceOnEdges(reduceEdgesFunction: ReduceEdgesFunction[EV], direction: EdgeDirection): DataSet[(K, EV)]

def reduceOnNeighbors(reduceNeighborsFunction: ReduceNeighborsFunction[VV], direction: EdgeDirection): DataSet[(K, VV)]

def removeEdge(edge: Edge[K, EV]): Graph[K, VV, EV]

def removeEdges(edges: List[Edge[K, EV]]): Graph[K, VV, EV]

def removeVertex(vertex: Vertex[K, VV]): Graph[K, VV, EV]

def removeVertices(vertices: List[Vertex[K, VV]]): Graph[K, VV, EV]

def reverse(): Graph[K, VV, EV]

def run[T](analytic: GraphAnalytic[K, VV, EV, T])(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): GraphAnalytic[K, VV, EV, T]

def run[T](algorithm: GraphAlgorithm[K, VV, EV, T])(implicit arg0: TypeInformation[T], arg1: ClassTag[T]): T

def runGatherSumApplyIteration[M](gatherFunction: GatherFunction[VV, EV, M], sumFunction: SumFunction[VV, EV, M], applyFunction: ApplyFunction[K, VV, M], maxIterations: Int, parameters: GSAConfiguration): Graph[K, VV, EV]

def runGatherSumApplyIteration[M](gatherFunction: GatherFunction[VV, EV, M], sumFunction: SumFunction[VV, EV, M], applyFunction: ApplyFunction[K, VV, M], maxIterations: Int): Graph[K, VV, EV]

def runScatterGatherIteration[M](scatterFunction: ScatterFunction[K, VV, M, EV], gatherFunction: GatherFunction[K, VV, M], maxIterations: Int, parameters: ScatterGatherConfiguration): Graph[K, VV, EV]

def runScatterGatherIteration[M](scatterFunction: ScatterFunction[K, VV, M, EV], gatherFunction: GatherFunction[K, VV, M], maxIterations: Int): Graph[K, VV, EV]

def runVertexCentricIteration[M](computeFunction: ComputeFunction[K, VV, EV, M], combineFunction: MessageCombiner[K, M], maxIterations: Int, parameters: VertexCentricConfiguration): Graph[K, VV, EV]

def runVertexCentricIteration[M](computeFunction: ComputeFunction[K, VV, EV, M], combineFunction: MessageCombiner[K, M], maxIterations: Int): Graph[K, VV, EV]

def subgraph(vertexFilterFun: (Vertex[K, VV]) ⇒ Boolean, edgeFilterFun: (Edge[K, EV]) ⇒ Boolean): Graph[K, VV, EV]

def subgraph(vertexFilter: FilterFunction[Vertex[K, VV]], edgeFilter: FilterFunction[Edge[K, EV]]): Graph[K, VV, EV]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def translateEdgeValues[NEW](fun: (EV, NEW) ⇒ NEW)(implicit arg0: TypeInformation[NEW], arg1: ClassTag[NEW]): Graph[K, VV, NEW]

def translateEdgeValues[NEW](translator: TranslateFunction[EV, NEW])(implicit arg0: TypeInformation[NEW], arg1: ClassTag[NEW]): Graph[K, VV, NEW]