public class Analyst extends Destroyable
Destroyable.destroy()
is invoked, all transient data returned by the Analyst gets freed and cannot be used anymore.Modifier and Type  Method and Description 

<V> EdgeProperty<java.lang.Double> 
adamicAdarCounting(PgxGraph graph)
The adamicadar index compares the amount of neighbors shared between vertices, this measure can be used with communities.

<V> EdgeProperty<java.lang.Double> 
adamicAdarCounting(PgxGraph graph,
EdgeProperty<java.lang.Double> aa)
The adamicadar index compares the amount of neighbors shared between vertices, this measure can be used with communities.

PgxFuture<EdgeProperty<java.lang.Double>> 
adamicAdarCountingAsync(PgxGraph graph)
The adamicadar index compares the amount of neighbors shared between vertices, this measure can be used with communities.

PgxFuture<EdgeProperty<java.lang.Double>> 
adamicAdarCountingAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> aa)
The adamicadar index compares the amount of neighbors shared between vertices, this measure can be used with communities.

<ID> org.apache.commons.lang3.tuple.Triple<VertexSet<ID>,EdgeSet,PgxMap<PgxVertex<ID>,java.lang.Integer>> 
allReachableVerticesEdges(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int k)
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.

<ID> PgxFuture<org.apache.commons.lang3.tuple.Triple<VertexSet<ID>,EdgeSet,PgxMap<PgxVertex<ID>,java.lang.Integer>>> 
allReachableVerticesEdgesAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int k)
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.

<ID> org.apache.commons.lang3.tuple.Triple<VertexSet<ID>,EdgeSet,PgxMap<PgxVertex<ID>,java.lang.Integer>> 
allReachableVerticesEdgesFiltered(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int k,
EdgeFilter filter)
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.

<ID> PgxFuture<org.apache.commons.lang3.tuple.Triple<VertexSet<ID>,EdgeSet,PgxMap<PgxVertex<ID>,java.lang.Integer>>> 
allReachableVerticesEdgesFilteredAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int k,
EdgeFilter filter)
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.

<ID> VertexProperty<ID,java.lang.Double> 
approximateVertexBetweennessCentrality(PgxGraph graph,
int k)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information

<ID> VertexProperty<ID,java.lang.Double> 
approximateVertexBetweennessCentrality(PgxGraph graph,
int k,
VertexProperty<ID,java.lang.Double> bc)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
approximateVertexBetweennessCentralityAsync(PgxGraph graph,
int k)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
approximateVertexBetweennessCentralityAsync(PgxGraph graph,
int k,
VertexProperty<ID,java.lang.Double> bc)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information

<ID> VertexProperty<ID,java.lang.Double> 
approximateVertexBetweennessCentralityFromSeeds(PgxGraph graph,
PgxVertex<ID>... seeds)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information

<ID> VertexProperty<ID,java.lang.Double> 
approximateVertexBetweennessCentralityFromSeeds(PgxGraph graph,
VertexProperty<ID,java.lang.Double> bc,
PgxVertex<ID>... seeds)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
approximateVertexBetweennessCentralityFromSeedsAsync(PgxGraph graph,
PgxVertex<ID>... seeds)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
approximateVertexBetweennessCentralityFromSeedsAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> bc,
PgxVertex<ID>... seeds)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information

<ID> VertexProperty<ID,java.lang.Boolean> 
bipartiteCheck(PgxGraph graph,
VertexProperty<ID,java.lang.Boolean> isLeft)
Bipartite check verifies whether are graph is a bipartite graph.

<ID> PgxFuture<VertexProperty<ID,java.lang.Boolean>> 
bipartiteCheckAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Boolean> isLeft)
Bipartite check verifies whether are graph is a bipartite graph.

<ID> VertexSet<ID> 
center(PgxGraph graph)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph

<ID> VertexSet<ID> 
center(PgxGraph graph,
VertexSet<ID> center)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph

<ID> PgxFuture<VertexSet<ID>> 
centerAsync(PgxGraph graph)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph

<ID> PgxFuture<VertexSet<ID>> 
centerAsync(PgxGraph graph,
VertexSet<ID> center)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph

<ID> VertexProperty<ID,java.lang.Double> 
closenessCentralityDoubleLength(PgxGraph graph,
EdgeProperty<java.lang.Double> cost)
Closenness centrality measures the centrality of the vertices based on weighted distances, allowing to find wellconnected vertices

<ID> VertexProperty<ID,java.lang.Double> 
closenessCentralityDoubleLength(PgxGraph graph,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,java.lang.Double> cc)
Closenness centrality measures the centrality of the vertices based on weighted distances, allowing to find wellconnected vertices

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
closenessCentralityDoubleLengthAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> cost)
Closenness centrality measures the centrality of the vertices based on weighted distances, allowing to find wellconnected vertices

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
closenessCentralityDoubleLengthAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,java.lang.Double> cc)
Closenness centrality measures the centrality of the vertices based on weighted distances, allowing to find wellconnected vertices

<ID> VertexProperty<ID,java.lang.Double> 
closenessCentralityUnitLength(PgxGraph graph)
Closenness centrality measures the centrality of the vertices based on distances, allowing to find wellconnected vertices

<ID> VertexProperty<ID,java.lang.Double> 
closenessCentralityUnitLength(PgxGraph graph,
VertexProperty<ID,java.lang.Double> cc)
Closenness centrality measures the centrality of the vertices based on distances, allowing to find wellconnected vertices

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
closenessCentralityUnitLengthAsync(PgxGraph graph)
Closenness centrality measures the centrality of the vertices based on distances, allowing to find wellconnected vertices

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
closenessCentralityUnitLengthAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> cc)
Closenness centrality measures the centrality of the vertices based on distances, allowing to find wellconnected vertices

<ID> Partition<ID> 
communitiesConductanceMinimization(PgxGraph graph)
Soman and Narang can find communities in a graph taking weighted edges into account

<ID> Partition<ID> 
communitiesConductanceMinimization(PgxGraph graph,
int maxIterations)
Soman and Narang can find communities in a graph taking weighted edges into account

<ID> Partition<ID> 
communitiesConductanceMinimization(PgxGraph graph,
int maxIterations,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Soman and Narang can find communities in a graph taking weighted edges into account

<ID> Partition<ID> 
communitiesConductanceMinimization(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Soman and Narang can find communities in a graph taking weighted edges into account

<ID> PgxFuture<Partition<ID>> 
communitiesConductanceMinimizationAsync(PgxGraph graph)
Soman and Narang can find communities in a graph taking weighted edges into account

<ID> PgxFuture<Partition<ID>> 
communitiesConductanceMinimizationAsync(PgxGraph graph,
int max)
Soman and Narang can find communities in a graph taking weighted edges into account

<ID> PgxFuture<Partition<ID>> 
communitiesConductanceMinimizationAsync(PgxGraph graph,
int maxIterations,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Soman and Narang can find communities in a graph taking weighted edges into account

<ID> PgxFuture<Partition<ID>> 
communitiesConductanceMinimizationAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Soman and Narang can find communities in a graph taking weighted edges into account

<ID> Partition<ID> 
communitiesInfomap(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank,
EdgeProperty<java.lang.Double> weight)
Infomap can find high quality communities in a graph.

<ID> Partition<ID> 
communitiesInfomap(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank,
EdgeProperty<java.lang.Double> weight,
double tau,
double tol,
int maxIter)
Infomap can find high quality communities in a graph.

<ID> Partition<ID> 
communitiesInfomap(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank,
EdgeProperty<java.lang.Double> weight,
double tau,
double tol,
int maxIter,
VertexProperty<ID,java.lang.Long> module)
Infomap can find high quality communities in a graph.

<ID> Partition<ID> 
communitiesInfomap(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Long> module)
Infomap can find high quality communities in a graph.

<ID> PgxFuture<Partition<ID>> 
communitiesInfomapAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank,
EdgeProperty<java.lang.Double> weight)
Infomap can find high quality communities in a graph.

<ID> PgxFuture<Partition<ID>> 
communitiesInfomapAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank,
EdgeProperty<java.lang.Double> weight,
double tau,
double tol,
int maxIter)
Infomap can find high quality communities in a graph.

<ID> PgxFuture<Partition<ID>> 
communitiesInfomapAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank,
EdgeProperty<java.lang.Double> weight,
double tau,
double tol,
int maxIter,
VertexProperty<ID,java.lang.Long> module)
Infomap can find high quality communities in a graph.

<ID> PgxFuture<Partition<ID>> 
communitiesInfomapAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Long> module)
Infomap can find high quality communities in a graph.

<ID> Partition<ID> 
communitiesLabelPropagation(PgxGraph graph)
Label propagation can find communities in a graph relatively fast

<ID> Partition<ID> 
communitiesLabelPropagation(PgxGraph graph,
int maxIterations)
Label propagation can find communities in a graph relatively fast

<ID> Partition<ID> 
communitiesLabelPropagation(PgxGraph graph,
int maxIterations,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Label propagation can find communities in a graph relatively fast

<ID> Partition<ID> 
communitiesLabelPropagation(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitonDistribution)
Label propagation can find communities in a graph relatively fast

<ID> PgxFuture<Partition<ID>> 
communitiesLabelPropagationAsync(PgxGraph graph)
Label propagation can find communities in a graph relatively fast

<ID> PgxFuture<Partition<ID>> 
communitiesLabelPropagationAsync(PgxGraph graph,
int maxIterations)
Label propagation can find communities in a graph relatively fast

<ID> PgxFuture<Partition<ID>> 
communitiesLabelPropagationAsync(PgxGraph graph,
int maxIterations,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Label propagation can find communities in a graph relatively fast

<ID> PgxFuture<Partition<ID>> 
communitiesLabelPropagationAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Label propagation can find communities in a graph relatively fast

<ID> Pair<PgxMap<java.lang.Integer,PgxVertex<ID>>,VertexSet<ID>> 
computeHighDegreeVertices(PgxGraph graph,
int k)
Computes the k vertices with the highest degrees in the graph.

<ID> Pair<PgxMap<java.lang.Integer,PgxVertex<ID>>,VertexSet<ID>> 
computeHighDegreeVertices(PgxGraph graph,
int k,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices)
Computes the k vertices with the highest degrees in the graph.

<ID> PgxFuture<Pair<PgxMap<java.lang.Integer,PgxVertex<ID>>,VertexSet<ID>>> 
computeHighDegreeVerticesAsync(PgxGraph graph,
int k)
Computes the k vertices with the highest degrees in the graph.

<ID> PgxFuture<Pair<PgxMap<java.lang.Integer,PgxVertex<ID>>,VertexSet<ID>>> 
computeHighDegreeVerticesAsync(PgxGraph graph,
int k,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices)
Computes the k vertices with the highest degrees in the graph.

<ID> Scalar<java.lang.Double> 
conductance(PgxGraph graph,
Partition<ID> partition,
long partitionIndex)
Conductance assesses the quality of a partition in a graph

<ID> Scalar<java.lang.Double> 
conductance(PgxGraph graph,
Partition<ID> partition,
long partitionIndex,
Scalar<java.lang.Double> conductance)
Conductance assesses the quality of a partition in a graph

<ID> PgxFuture<Scalar<java.lang.Double>> 
conductanceAsync(PgxGraph graph,
Partition<ID> partition,
long partitionIndex)
Conductance assesses the quality of a partition in a graph

<ID> PgxFuture<Scalar<java.lang.Double>> 
conductanceAsync(PgxGraph graph,
Partition<ID> partition,
long partitionIndex,
Scalar<java.lang.Double> conductance)
Conductance assesses the quality of a partition in a graph

long 
countTriangles(PgxGraph graph,
boolean sortVerticesByDegree)
triangle counting gives an overview of the amount of connections between vertices in neighborhoods

PgxFuture<java.lang.Long> 
countTrianglesAsync(PgxGraph graph,
boolean sortVerticesByDegree)
triangle counting gives an overview of the amount of connections between vertices in neighborhoods

<ID> VertexProperty<ID,PgxVect<java.lang.Integer>> 
createDistanceIndex(PgxGraph graph,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices)
Computes an index with distances to each highdegree vertex.

<ID> VertexProperty<ID,PgxVect<java.lang.Integer>> 
createDistanceIndex(PgxGraph graph,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index)
Computes an index with distances to each highdegree vertex.

<ID> PgxFuture<VertexProperty<ID,PgxVect<java.lang.Integer>>> 
createDistanceIndexAsync(PgxGraph graph,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices)
Computes an index with distances to each highdegree vertex.

<ID> PgxFuture<VertexProperty<ID,PgxVect<java.lang.Integer>>> 
createDistanceIndexAsync(PgxGraph graph,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index)
Computes an index with distances to each highdegree vertex.

DeepWalkModelBuilder 
deepWalkModelBuilder()
Builder for Deepwalk model

<ID> VertexProperty<ID,java.lang.Integer> 
degreeCentrality(PgxGraph graph)
Degree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> VertexProperty<ID,java.lang.Integer> 
degreeCentrality(PgxGraph graph,
VertexProperty<ID,java.lang.Integer> dc)
Degree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
degreeCentralityAsync(PgxGraph graph)
Degree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
degreeCentralityAsync(PgxGraph graph,
java.lang.String propertyName) 
<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
degreeCentralityAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Integer> dc)
Degree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>> 
diameter(PgxGraph graph)
Diameter/radius gives an overview of the distances in a graph

<ID> Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>> 
diameter(PgxGraph graph,
Scalar<java.lang.Integer> diameter,
VertexProperty<ID,java.lang.Integer> eccentricity)
Diameter/radius gives an overview of the distances in a graph

<ID> PgxFuture<Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>>> 
diameterAsync(PgxGraph graph)
Diameter/radius gives an overview of the distances in a graph

<ID> PgxFuture<Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>>> 
diameterAsync(PgxGraph graph,
Scalar<java.lang.Integer> diameter,
VertexProperty<ID,java.lang.Integer> eccentricity)
Diameter/radius gives an overview of the distances in a graph

<ID> VertexProperty<ID,java.lang.Double> 
eigenvectorCentrality(PgxGraph graph)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices

<ID> VertexProperty<ID,java.lang.Double> 
eigenvectorCentrality(PgxGraph graph,
int max,
double maxDiff,
boolean useL2Norm,
boolean useInEdge)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices

<ID> VertexProperty<ID,java.lang.Double> 
eigenvectorCentrality(PgxGraph graph,
int max,
double maxDiff,
boolean useL2Norm,
boolean useInEdge,
VertexProperty<ID,java.lang.Double> ec)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices

<ID> VertexProperty<ID,java.lang.Double> 
eigenvectorCentrality(PgxGraph graph,
VertexProperty<ID,java.lang.Double> ec)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
eigenvectorCentralityAsync(PgxGraph graph)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
eigenvectorCentralityAsync(PgxGraph graph,
int max,
double maxDiff,
boolean useL2Norm,
boolean useInEdge)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
eigenvectorCentralityAsync(PgxGraph graph,
int max,
double maxDiff,
boolean useL2Norm,
boolean useInEdge,
VertexProperty<ID,java.lang.Double> ec)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
eigenvectorCentralityAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> ec)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices

<ID> org.apache.commons.lang3.tuple.Triple<ScalarSequence<java.lang.Integer>,VertexSequence<ID>,EdgeSequence> 
enumerateSimplePaths(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int k,
VertexSet verticesOnPath,
EdgeSet edgesOnPath,
PgxMap<PgxVertex<ID>,java.lang.Integer> dist)
Enumerate all simple paths between the source and destination vertex

<ID> PgxFuture<org.apache.commons.lang3.tuple.Triple<ScalarSequence<java.lang.Integer>,VertexSequence<ID>,EdgeSequence>> 
enumerateSimplePathsAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int k,
VertexSet verticesOnPath,
EdgeSet edgesOnPath,
PgxMap<PgxVertex<ID>,java.lang.Integer> dist)
Enumerate all simple paths between the source and destination vertex

<ID> AllPaths<ID> 
fattestPath(PgxGraph graph,
ID rootId,
EdgeProperty<java.lang.Double> capacity)
Convenience wrapper around
fattestPath(PgxGraph, PgxVertex, EdgeProperty) taking a vertex ID instead of a
PgxVertex . 
<ID> AllPaths<ID> 
fattestPath(PgxGraph graph,
ID rootId,
EdgeProperty<java.lang.Double> capacity,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Convenience wrapper around
fattestPath(PgxGraph, PgxVertex, EdgeProperty, VertexProperty,
VertexProperty, VertexProperty) taking a vertex ID instead of a
PgxVertex . 
<ID> AllPaths<ID> 
fattestPath(PgxGraph graph,
PgxVertex<ID> root,
EdgeProperty<java.lang.Double> capacity)
Fattest path is a fast algorithm for finding a shortest path adding constraints for flowing related matters

<ID> AllPaths<ID> 
fattestPath(PgxGraph graph,
PgxVertex<ID> root,
EdgeProperty<java.lang.Double> capacity,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Fattest path is a fast algorithm for finding a shortest path adding constraints for flowing related matters

<ID> PgxFuture<AllPaths<ID>> 
fattestPathAsync(PgxGraph graph,
PgxVertex<ID> root,
EdgeProperty<java.lang.Double> capacity)
Fattest path is a fast algorithm for finding a shortest path adding constraints for flowing related matters

<ID> PgxFuture<AllPaths<ID>> 
fattestPathAsync(PgxGraph graph,
PgxVertex<ID> root,
EdgeProperty<java.lang.Double> capacity,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Fattest path is a fast algorithm for finding a shortest path adding constraints for flowing related matters

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
ID root)
Convenience wrapper around
filteredBfs(PgxGraph, PgxVertex)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
ID root,
int maxDepth)
Convenience wrapper around
filteredBfs(PgxGraph, PgxVertex, int)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator)
Convenience wrapper around
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
boolean initWithInf)
Convenience wrapper around
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
boolean initWithInf,
int maxDepth)
Convenience wrapper around
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, int)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
boolean initWithInf,
int maxDepth,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
Convenience wrapper around
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, int, VertexProperty,
VertexProperty)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
boolean initWithInf,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
Convenience wrapper around
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, VertexProperty,
VertexProperty)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
int maxDepth)
Convenience wrapper around
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, int)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
PgxVertex<ID> root)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
PgxVertex<ID> root,
int maxDepth)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
int maxDepth)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
int maxDepth,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredBfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
int maxDepth)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredBfsAsync(PgxGraph graph,
PgxVertex<ID> root)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredBfsAsync(PgxGraph graph,
PgxVertex<ID> root,
int maxDepth)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredBfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredBfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredBfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
int maxDepth)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredBfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
int maxDepth,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredBfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredBfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
int maxDepth)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
ID root)
Convenience wrapper around
filteredDfs(PgxGraph, PgxVertex)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
ID root,
int maxDepth)
Convenience wrapper around
filteredDfs(PgxGraph, PgxVertex, int)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator)
Convenience wrapper around
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
boolean initWithInf)
Convenience wrapper around
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
boolean initWithInf,
int maxDepth)
Convenience wrapper around
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, int)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
boolean initWithInf,
int maxDepth,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
Convenience wrapper around
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, int, VertexProperty,
VertexProperty)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
boolean initWithInf,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
Convenience wrapper around
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, VertexProperty,
VertexProperty)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
ID root,
VertexFilter filter,
VertexFilter navigator,
int maxDepth)
Convenience wrapper around
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, int)
taking a vertex ID instead of PgxVertex . 
<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
PgxVertex<ID> root)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
PgxVertex<ID> root,
int maxDepth)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
int maxDepth)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
int maxDepth,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> 
filteredDfs(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
int maxDepth)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredDfsAsync(PgxGraph graph,
PgxVertex<ID> root)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredDfsAsync(PgxGraph graph,
PgxVertex<ID> root,
int maxDepth)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredDfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredDfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredDfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
int maxDepth)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredDfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
int maxDepth,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredDfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
boolean initWithInf,
VertexProperty<ID,java.lang.Integer> distance,
VertexProperty<ID,PgxVertex<ID>> parent)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> 
filteredDfsAsync(PgxGraph graph,
PgxVertex<ID> root,
VertexFilter navigator,
int maxDepth)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.

<ID> PgxPath<ID> 
findCycle(PgxGraph graph)
Find cycle looks for any loop in the graph.

<ID> PgxPath<ID> 
findCycle(PgxGraph graph,
PgxVertex<ID> src)
Find cycle looks for any loop in the graph.

<ID> PgxPath<ID> 
findCycle(PgxGraph graph,
PgxVertex<ID> src,
VertexSequence<ID> nodeSeq,
EdgeSequence edgeSeq)
Find cycle looks for any loop in the graph.

<ID> PgxPath<ID> 
findCycle(PgxGraph graph,
VertexSequence<ID> nodeSeq,
EdgeSequence edgeSeq)
Find cycle looks for any loop in the graph.

<ID> PgxFuture<PgxPath<ID>> 
findCycleAsync(PgxGraph graph)
Find cycle looks for any loop in the graph.

<ID> PgxFuture<PgxPath<ID>> 
findCycleAsync(PgxGraph graph,
PgxVertex<ID> src)
Find cycle looks for any loop in the graph.

<ID> PgxFuture<PgxPath<ID>> 
findCycleAsync(PgxGraph graph,
PgxVertex<ID> src,
VertexSequence<ID> nodeSeq,
EdgeSequence edgeSeq)
Find cycle looks for any loop in the graph.

<ID> PgxFuture<PgxPath<ID>> 
findCycleAsync(PgxGraph graph,
VertexSequence<ID> nodeSeq,
EdgeSequence edgeSeq)
Find cycle looks for any loop in the graph.

PgxSession 
getSession()
Gets the session.

GraphWiseConvLayerConfigBuilder 
graphWiseConvLayerConfigBuilder()
Return a SupervisedGraphWiseLayerConfigBuilder used to create a GraphWiseLayerConfig

GraphWisePredictionLayerConfigBuilder 
graphWisePredictionLayerConfigBuilder()
Return a GraphWisePredictionLayerConfigBuilder used to create a GraphWiseLayerConfig

<ID> Pair<VertexProperty<ID,java.lang.Double>,VertexProperty<ID,java.lang.Double>> 
hits(PgxGraph graph)
HITS assigns ranking scores to the vertices, aimed to assess the quality of information and references in linked structures

<ID> Pair<VertexProperty<ID,java.lang.Double>,VertexProperty<ID,java.lang.Double>> 
hits(PgxGraph graph,
int max)
HITS assigns ranking scores to the vertices, aimed to assess the quality of information and references in linked structures

<ID> Pair<VertexProperty<ID,java.lang.Double>,VertexProperty<ID,java.lang.Double>> 
hits(PgxGraph graph,
int max,
VertexProperty<ID,java.lang.Double> auth,
VertexProperty<ID,java.lang.Double> hubs)
HITS assigns ranking scores to the vertices, aimed to assess the quality of information and references in linked structures

<ID> Pair<VertexProperty<ID,java.lang.Double>,VertexProperty<ID,java.lang.Double>> 
hits(PgxGraph graph,
VertexProperty<ID,java.lang.Double> auth,
VertexProperty<ID,java.lang.Double> hubs)
HITS assigns ranking scores to the vertices, aimed to assess the quality of information and references in linked structures

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Double>,VertexProperty<ID,java.lang.Double>>> 
hitsAsync(PgxGraph graph)
HITS assigns ranking scores to the vertices, aimed to assess the quality of information and references in linked structures

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Double>,VertexProperty<ID,java.lang.Double>>> 
hitsAsync(PgxGraph graph,
int max)
HITS assigns ranking scores to the vertices, aimed to assess the quality of information and references in linked structures

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Double>,VertexProperty<ID,java.lang.Double>>> 
hitsAsync(PgxGraph graph,
int max,
VertexProperty<ID,java.lang.Double> auth,
VertexProperty<ID,java.lang.Double> hubs)
HITS assigns ranking scores to the vertices, aimed to assess the quality of information and references in linked structures

<ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Double>,VertexProperty<ID,java.lang.Double>>> 
hitsAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> auth,
VertexProperty<ID,java.lang.Double> hubs)
HITS assigns ranking scores to the vertices, aimed to assess the quality of information and references in linked structures

<ID> VertexProperty<ID,java.lang.Integer> 
inDegreeCentrality(PgxGraph graph)
Indegree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> VertexProperty<ID,java.lang.Integer> 
inDegreeCentrality(PgxGraph graph,
VertexProperty<ID,java.lang.Integer> dc)
Indegree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
inDegreeCentralityAsync(PgxGraph graph)
Indegree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
inDegreeCentralityAsync(PgxGraph graph,
java.lang.String propertyName) 
<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
inDegreeCentralityAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Integer> dc)
Indegree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

PgxMap<java.lang.Integer,java.lang.Long> 
inDegreeDistribution(PgxGraph graph)
Indegree distribution gives information about the incoming flows in a graph

PgxMap<java.lang.Integer,java.lang.Long> 
inDegreeDistribution(PgxGraph graph,
PgxMap<java.lang.Integer,java.lang.Long> distribution)
Indegree distribution gives information about the incoming flows in a graph

PgxFuture<PgxMap<java.lang.Integer,java.lang.Long>> 
inDegreeDistributionAsync(PgxGraph graph)
Indegree distribution gives information about the incoming flows in a graph

PgxFuture<PgxMap<java.lang.Integer,java.lang.Long>> 
inDegreeDistributionAsync(PgxGraph graph,
PgxMap<java.lang.Integer,java.lang.Long> distribution)
Indegree distribution gives information about the incoming flows in a graph

<ID> Pair<Scalar<java.lang.Long>,VertexProperty<ID,java.lang.Long>> 
kcore(PgxGraph graph)
kcore decomposes a graph into layers revealing subgraphs with particular properties

<ID> Pair<Scalar<java.lang.Long>,VertexProperty<ID,java.lang.Long>> 
kcore(PgxGraph graph,
int minCore,
int maxCore)
kcore decomposes a graph into layers revealing subgraphs with particular properties

<ID> Pair<Scalar<java.lang.Long>,VertexProperty<ID,java.lang.Long>> 
kcore(PgxGraph graph,
int minCore,
int maxCore,
Scalar<java.lang.Long> maxKCore,
VertexProperty<ID,java.lang.Long> kcore)
kcore decomposes a graph into layers revealing subgraphs with particular properties

<ID> Pair<Scalar<java.lang.Long>,VertexProperty<ID,java.lang.Long>> 
kcore(PgxGraph graph,
Scalar<java.lang.Long> maxKCore,
VertexProperty<ID,java.lang.Long> kcore)
kcore decomposes a graph into layers revealing subgraphs with particular properties

<ID> PgxFuture<Pair<Scalar<java.lang.Long>,VertexProperty<ID,java.lang.Long>>> 
kcoreAsync(PgxGraph graph)
kcore decomposes a graph into layers revealing subgraphs with particular properties

<ID> PgxFuture<Pair<Scalar<java.lang.Long>,VertexProperty<ID,java.lang.Long>>> 
kcoreAsync(PgxGraph graph,
int minCore,
int maxCore)
kcore decomposes a graph into layers revealing subgraphs with particular properties

<ID> PgxFuture<Pair<Scalar<java.lang.Long>,VertexProperty<ID,java.lang.Long>>> 
kcoreAsync(PgxGraph graph,
int minCore,
int maxCore,
Scalar<java.lang.Long> maxKCore,
VertexProperty<ID,java.lang.Long> kcore)
kcore decomposes a graph into layers revealing subgraphs with particular properties

<ID> PgxFuture<Pair<Scalar<java.lang.Long>,VertexProperty<ID,java.lang.Long>>> 
kcoreAsync(PgxGraph graph,
Scalar<java.lang.Long> maxKCore,
VertexProperty<ID,java.lang.Long> kcore)
kcore decomposes a graph into layers revealing subgraphs with particular properties

<ID> Pair<VertexSequence<ID>,EdgeSequence> 
limitedShortestPathHopDist(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int maxHops,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index)
Computes the khop limited shortest path between two vertices.

<ID> Pair<VertexSequence<ID>,EdgeSequence> 
limitedShortestPathHopDist(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int maxHops,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index,
VertexSequence<ID> pathVertices,
EdgeSequence pathEdges)
Computes the khop limited shortest path between two vertices.

<ID> PgxFuture<Pair<VertexSequence<ID>,EdgeSequence>> 
limitedShortestPathHopDistAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int maxHops,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index)
Computes the khop limited shortest path between two vertices.

<ID> PgxFuture<Pair<VertexSequence<ID>,EdgeSequence>> 
limitedShortestPathHopDistAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int maxHops,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index,
VertexSequence<ID> pathVertices,
EdgeSequence pathEdges)
Computes the khop limited shortest path between two vertices.

<ID> Pair<VertexSequence<ID>,EdgeSequence> 
limitedShortestPathHopDistFiltered(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int maxHops,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index,
EdgeFilter filter)
Computes the khop limited shortest path between two vertices.

<ID> Pair<VertexSequence<ID>,EdgeSequence> 
limitedShortestPathHopDistFiltered(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int maxHops,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index,
EdgeFilter filter,
VertexSequence<ID> pathVertices,
EdgeSequence pathEdges)
Computes the khop limited shortest path between two vertices.

<ID> PgxFuture<Pair<VertexSequence<ID>,EdgeSequence>> 
limitedShortestPathHopDistFilteredAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int maxHops,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index,
EdgeFilter filter)
Computes the khop limited shortest path between two vertices.

<ID> PgxFuture<Pair<VertexSequence<ID>,EdgeSequence>> 
limitedShortestPathHopDistFilteredAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
int maxHops,
PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping,
VertexSet<ID> highDegreeVertices,
VertexProperty<ID,PgxVect<java.lang.Integer>> index,
EdgeFilter filter,
VertexSequence<ID> pathVertices,
EdgeSequence pathEdges)
Computes the khop limited shortest path between two vertices.

DeepWalkModel 
loadDeepWalkModel(java.lang.String path,
java.lang.String key)
Loads an encrypted Deepwalk model

Pg2vecModel 
loadPg2vecModel(java.lang.String path,
java.lang.String key)
Loads an encrypted pg2vec model

SupervisedGraphWiseModel 
loadSupervisedGraphWiseModel(java.lang.String path,
java.lang.String key)
Loads an encrypted GraphWise model

<ID> VertexProperty<ID,java.lang.Double> 
localClusteringCoefficient(PgxGraph graph)
LCC gives information about potential clustering options in a graph

<ID> VertexProperty<ID,java.lang.Double> 
localClusteringCoefficient(PgxGraph graph,
VertexProperty<ID,java.lang.Double> lcc)
LCC gives information about potential clustering options in a graph

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
localClusteringCoefficientAsync(PgxGraph graph)
LCC gives information about potential clustering options in a graph

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
localClusteringCoefficientAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> lcc)
LCC gives information about potential clustering options in a graph

<ID> VertexProperty<ID,java.lang.Long> 
louvain(PgxGraph graph,
EdgeProperty<java.lang.Double> weight)
Louvain can detect communities in a large graph relatively fast.

<ID> VertexProperty<ID,java.lang.Long> 
louvain(PgxGraph graph,
EdgeProperty<java.lang.Double> weight,
int maxIter)
Louvain can detect communities in a large graph relatively fast.

<ID> VertexProperty<ID,java.lang.Long> 
louvain(PgxGraph graph,
EdgeProperty<java.lang.Double> weight,
int maxIter,
int nbrPass,
double tol,
VertexProperty<ID,java.lang.Long> community)
Louvain can detect communities in a large graph relatively fast.

<ID> PgxFuture<VertexProperty<ID,java.lang.Long>> 
louvainAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> weight)
Louvain can detect communities in a large graph relatively fast.

<ID> PgxFuture<VertexProperty<ID,java.lang.Long>> 
louvainAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> weight,
int maxIter)
Louvain can detect communities in a large graph relatively fast.

<ID> PgxFuture<VertexProperty<ID,java.lang.Long>> 
louvainAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> weight,
int maxIter,
int nbrPass,
double tol,
VertexProperty<ID,java.lang.Long> community)
Louvain can detect communities in a large graph relatively fast.

<ID> MatrixFactorizationModel<ID> 
matrixFactorizationGradientDescent(BipartiteGraph graph,
EdgeProperty<java.lang.Double> weight)
Matrix factorization can be used as a recommendation algorithm for bipartite graphs

<ID> MatrixFactorizationModel<ID> 
matrixFactorizationGradientDescent(BipartiteGraph graph,
EdgeProperty<java.lang.Double> weight,
double learningRate,
double changePerStep,
double lambda,
int maxStep,
int vectorLength)
Matrix factorization can be used as a recommendation algorithm for bipartite graphs

<ID> MatrixFactorizationModel<ID> 
matrixFactorizationGradientDescent(BipartiteGraph graph,
EdgeProperty<java.lang.Double> weight,
double learningRate,
double changePerStep,
double lambda,
int maxStep,
int vectorLength,
VertexProperty<ID,PgxVect<java.lang.Double>> features)
Matrix factorization can be used as a recommendation algorithm for bipartite graphs

<ID> MatrixFactorizationModel<ID> 
matrixFactorizationGradientDescent(BipartiteGraph graph,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,PgxVect<java.lang.Double>> features)
Matrix factorization can be used as a recommendation algorithm for bipartite graphs

<ID> PgxFuture<MatrixFactorizationModel<ID>> 
matrixFactorizationGradientDescentAsync(BipartiteGraph graph,
EdgeProperty<java.lang.Double> weight)
Matrix factorization can be used as a recommendation algorithm for bipartite graphs

<ID> PgxFuture<MatrixFactorizationModel<ID>> 
matrixFactorizationGradientDescentAsync(BipartiteGraph graph,
EdgeProperty<java.lang.Double> weight,
double learningRate,
double changePerStep,
double lambda,
int maxStep,
int vectorLength)
Matrix factorization can be used as a recommendation algorithm for bipartite graphs

<ID> PgxFuture<MatrixFactorizationModel<ID>> 
matrixFactorizationGradientDescentAsync(BipartiteGraph graph,
EdgeProperty<java.lang.Double> weight,
double learningRate,
double changePerStep,
double lambda,
int maxStep,
int vectorLength,
VertexProperty<ID,PgxVect<java.lang.Double>> features)
Matrix factorization can be used as a recommendation algorithm for bipartite graphs

<ID> PgxFuture<MatrixFactorizationModel<ID>> 
matrixFactorizationGradientDescentAsync(BipartiteGraph graph,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,PgxVect<java.lang.Double>> features)
Matrix factorization can be used as a recommendation algorithm for bipartite graphs

<ID> VertexProperty<ID,java.lang.Double> 
matrixFactorizationRecommendations(BipartiteGraph graph,
ID user,
int vectorLength,
VertexProperty<ID,PgxVect<java.lang.Double>> feature,
VertexProperty<ID,java.lang.Double> estimatedRating)
Convenience wrapper around
matrixFactorizationRecommendations(BipartiteGraph, PgxVertex, int,
VertexProperty, VertexProperty) taking a vertex ID instead of a PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
matrixFactorizationRecommendations(BipartiteGraph graph,
PgxVertex<ID> user,
int vectorLength,
VertexProperty<ID,PgxVect<java.lang.Double>> feature,
VertexProperty<ID,java.lang.Double> estimatedRating)
Estimate rating can be used as a prediction algorithm for bipartite graphs

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
matrixFactorizationRecommendationsAsync(BipartiteGraph graph,
PgxVertex<ID> user,
int vectorLength,
VertexProperty<ID,PgxVect<java.lang.Double>> feature,
VertexProperty<ID,java.lang.Double> estimatedRating)
Estimate rating can be used as a prediction algorithm for bipartite graphs

<ID> VertexProperty<ID,java.lang.Integer> 
outDegreeCentrality(PgxGraph graph)
Outdegree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> VertexProperty<ID,java.lang.Integer> 
outDegreeCentrality(PgxGraph graph,
VertexProperty<ID,java.lang.Integer> dc)
Outdegree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
outDegreeCentralityAsync(PgxGraph graph)
Outdegree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
outDegreeCentralityAsync(PgxGraph graph,
java.lang.String propertyName) 
<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
outDegreeCentralityAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Integer> dc)
Outdegree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood

PgxMap<java.lang.Integer,java.lang.Long> 
outDegreeDistribution(PgxGraph graph)
Outdegree distribution gives information about the outgoing flows in a graph

PgxMap<java.lang.Integer,java.lang.Long> 
outDegreeDistribution(PgxGraph graph,
PgxMap<java.lang.Integer,java.lang.Long> distribution)
Outdegree distribution gives information about the outgoing flows in a graph

PgxFuture<PgxMap<java.lang.Integer,java.lang.Long>> 
outDegreeDistributionAsync(PgxGraph graph)
Outdegree distribution gives information about the outgoing flows in a graph

PgxFuture<PgxMap<java.lang.Integer,java.lang.Long>> 
outDegreeDistributionAsync(PgxGraph graph,
PgxMap<java.lang.Integer,java.lang.Long> distribution)
Outdegree distribution gives information about the outgoing flows in a graph

<ID> VertexProperty<ID,java.lang.Double> 
pagerank(PgxGraph graph)
PageRank computes ranking scores based on the edges in a graph.

<ID> VertexProperty<ID,java.lang.Double> 
pagerank(PgxGraph graph,
boolean norm)
PageRank computes ranking scores based on the edges in a graph.

<ID> VertexProperty<ID,java.lang.Double> 
pagerank(PgxGraph graph,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
PageRank computes ranking scores based on the edges in a graph.

<ID> VertexProperty<ID,java.lang.Double> 
pagerank(PgxGraph graph,
double e,
double d,
int max)
PageRank computes ranking scores based on the edges in a graph.

<ID> VertexProperty<ID,java.lang.Double> 
pagerank(PgxGraph graph,
double e,
double d,
int max,
boolean norm)
PageRank computes ranking scores based on the edges in a graph.

<ID> VertexProperty<ID,java.lang.Double> 
pagerank(PgxGraph graph,
double e,
double d,
int max,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
PageRank computes ranking scores based on the edges in a graph.

<ID> VertexProperty<ID,java.lang.Double> 
pagerank(PgxGraph graph,
double e,
double d,
int max,
VertexProperty<ID,java.lang.Double> rank)
PageRank computes ranking scores based on the edges in a graph.

<ID> VertexProperty<ID,java.lang.Double> 
pagerank(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank)
PageRank computes ranking scores based on the edges in a graph.

<ID> VertexProperty<ID,java.lang.Double> 
pagerankApproximate(PgxGraph graph)
Faster, but less accurate than pagerank.

<ID> VertexProperty<ID,java.lang.Double> 
pagerankApproximate(PgxGraph graph,
double e,
double d,
int max)
Faster, but less accurate than pagerank.

<ID> VertexProperty<ID,java.lang.Double> 
pagerankApproximate(PgxGraph graph,
double e,
double d,
int max,
VertexProperty<ID,java.lang.Double> rank)
Faster, but less accurate than pagerank.

<ID> VertexProperty<ID,java.lang.Double> 
pagerankApproximate(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank)
Faster, but less accurate than pagerank.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankApproximateAsync(PgxGraph graph)
Faster, but less accurate than pagerank.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankApproximateAsync(PgxGraph graph,
double e,
double d,
int max)
Faster, but less accurate than pagerank.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankApproximateAsync(PgxGraph graph,
double e,
double d,
int max,
VertexProperty<ID,java.lang.Double> rank)
Faster, but less accurate than pagerank.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankApproximateAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank)
Faster, but less accurate than pagerank.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankAsync(PgxGraph graph)
PageRank computes ranking scores based on the edges in a graph.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankAsync(PgxGraph graph,
boolean norm)
PageRank computes ranking scores based on the edges in a graph.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankAsync(PgxGraph graph,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
PageRank computes ranking scores based on the edges in a graph.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankAsync(PgxGraph graph,
double e,
double d,
int max)
PageRank computes ranking scores based on the edges in a graph.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankAsync(PgxGraph graph,
double e,
double d,
int max,
boolean norm)
PageRank computes ranking scores based on the edges in a graph.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankAsync(PgxGraph graph,
double e,
double d,
int max,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
PageRank computes ranking scores based on the edges in a graph.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankAsync(PgxGraph graph,
double e,
double d,
int max,
VertexProperty<ID,java.lang.Double> rank)
PageRank computes ranking scores based on the edges in a graph.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
pagerankAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> rank)
PageRank computes ranking scores based on the edges in a graph.

<ID> Pair<Scalar<java.lang.Double>,Scalar<java.lang.Double>> 
partitionConductance(PgxGraph graph,
Partition<ID> partition)
Partition conductance assesses the quality of many partitions in a graph

<ID> Pair<Scalar<java.lang.Double>,Scalar<java.lang.Double>> 
partitionConductance(PgxGraph graph,
Partition<ID> partition,
Scalar<java.lang.Double> avgConductance,
Scalar<java.lang.Double> minConductance)
Partition conductance assesses the quality of many partitions in a graph

<ID> PgxFuture<Pair<Scalar<java.lang.Double>,Scalar<java.lang.Double>>> 
partitionConductanceAsync(PgxGraph graph,
Partition<ID> partition)
Partition conductance assesses the quality of many partitions in a graph

<ID> PgxFuture<Pair<Scalar<java.lang.Double>,Scalar<java.lang.Double>>> 
partitionConductanceAsync(PgxGraph graph,
Partition<ID> partition,
Scalar<java.lang.Double> avgConductance,
Scalar<java.lang.Double> minConductance)
Partition conductance assesses the quality of many partitions in a graph

<ID> Scalar<java.lang.Double> 
partitionModularity(PgxGraph graph,
Partition<ID> partition)
Modularity summarizes information about the quality of components in a graph

<ID> Scalar<java.lang.Double> 
partitionModularity(PgxGraph graph,
Partition<ID> partition,
Scalar<java.lang.Double> modularity)
Modularity summarizes information about the quality of components in a graph

<ID> PgxFuture<Scalar<java.lang.Double>> 
partitionModularityAsync(PgxGraph graph,
Partition<ID> partition)
Modularity summarizes information about the quality of components in a graph

<ID> PgxFuture<Scalar<java.lang.Double>> 
partitionModularityAsync(PgxGraph graph,
Partition<ID> partition,
Scalar<java.lang.Double> modularity)
Modularity summarizes information about the quality of components in a graph

<ID> PgxFuture<Scalar<java.lang.Double>> 
partitionModularityAsync(PgxGraph graph,
Partition<ID> partition,
java.lang.String modularityName) 
<ID> VertexSet<ID> 
periphery(PgxGraph graph)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph

<ID> VertexSet<ID> 
periphery(PgxGraph graph,
VertexSet<ID> periphery)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph

<ID> PgxFuture<VertexSet<ID>> 
peripheryAsync(PgxGraph graph)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph

<ID> PgxFuture<VertexSet<ID>> 
peripheryAsync(PgxGraph graph,
VertexSet<ID> periphery)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
ID vertexId,
java.math.BigDecimal e,
java.math.BigDecimal d,
int max)
Convenience wrapper around
personalizedPagerank(PgxGraph, PgxVertex, BigDecimal, BigDecimal, int,)
taking a vertex ID instead of a PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
ID vertexId,
java.math.BigDecimal e,
java.math.BigDecimal d,
int max,
boolean norm)
Convenience wrapper around
personalizedPagerank(PgxGraph, PgxVertex, BigDecimal, BigDecimal, int,
boolean) taking a vertex ID instead of a PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
ID vertexId,
java.math.BigDecimal e,
java.math.BigDecimal d,
int max,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
Convenience wrapper around
#personalizedPagerank(PgxGraph, PgxVertex, BigDecimal, BigDecimal, int, boolean,
VertexProperty taking a vertex ID instead of a PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
ID vertexId,
java.math.BigDecimal e,
java.math.BigDecimal d,
int max,
VertexProperty<ID,java.lang.Double> rank)
Convenience wrapper around
#personalizedPagerank(PgxGraph, PgxVertex, BigDecimal, BigDecimal, int,
VertexProperty taking a vertex ID instead of a PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
PgxVertex<ID> v)
Personalized PageRank for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
PgxVertex<ID> v,
boolean norm)
Personalized PageRank for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
PgxVertex<ID> v,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max)
Personalized PageRank for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
boolean norm)
Personalized PageRank for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
PgxVertex<ID> v,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
VertexSet<ID> vertices)
Personalized PageRank for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
boolean norm)
Personalized PageRank for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max)
Personalized PageRank for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
boolean norm)
Personalized PageRank for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v)
Personalized PageRank for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
boolean norm)
Personalized PageRank for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max)
Personalized PageRank for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
boolean norm)
Personalized PageRank for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices)
Personalized PageRank for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
boolean norm)
Personalized PageRank for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max)
Personalized PageRank for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
boolean norm)
Personalized PageRank for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
boolean norm,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
VertexProperty<ID,java.lang.Double> rank)
Personalized PageRank for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
ID v,
java.math.BigDecimal d,
int maxIterations,
java.math.BigDecimal maxDiff)
Convenience wrapper around
personalizedSalsa(BipartiteGraph, PgxVertex, BigDecimal, int, BigDecimal)
taking a vertex ID instead of PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
ID v,
java.math.BigDecimal d,
int maxIterations,
java.math.BigDecimal maxDiff,
VertexProperty<ID,java.lang.Double> salsaRank)
Convenience wrapper around
#personalizedSalsa(BipartiteGraph, PgxVertex, BigDecimal, int, BigDecimal, VertexProperty
taking a vertex ID instead of PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
PgxVertex<ID> v)
Personalized salsa for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
PgxVertex<ID> v,
double d,
int maxIter,
double maxDiff)
Personalized salsa for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
PgxVertex<ID> v,
double d,
int maxIter,
double maxDiff,
VertexProperty<ID,java.lang.Double> salsaRank)
Personalized salsa for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
PgxVertex<ID> v,
VertexProperty<ID,java.lang.Double> salsaRank)
Personalized salsa for a vertex of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
VertexSet<ID> vertices)
Personalized salsa for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
VertexSet<ID> vertices,
double d,
int maxIter,
double maxDiff)
Personalized salsa for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
VertexSet<ID> vertices,
double d,
int maxIter,
double maxDiff,
VertexProperty<ID,java.lang.Double> salsaRank)
Personalized salsa for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedSalsa(BipartiteGraph graph,
VertexSet<ID> vertices,
VertexProperty<ID,java.lang.Double> salsaRank)
Personalized salsa for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedSalsaAsync(BipartiteGraph graph,
PgxVertex<ID> v)
Personalized salsa for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedSalsaAsync(BipartiteGraph graph,
PgxVertex<ID> v,
double d,
int maxIter,
double maxDiff)
Personalized salsa for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedSalsaAsync(BipartiteGraph graph,
PgxVertex<ID> v,
double d,
int maxIter,
double maxDiff,
VertexProperty<ID,java.lang.Double> salsaRank)
Personalized salsa for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedSalsaAsync(BipartiteGraph graph,
PgxVertex<ID> v,
VertexProperty<ID,java.lang.Double> salsaRank)
Personalized salsa for a vertex of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedSalsaAsync(BipartiteGraph graph,
VertexSet<ID> vertices)
Personalized salsa for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedSalsaAsync(BipartiteGraph graph,
VertexSet<ID> vertices,
double d,
int maxIter,
double maxDiff)
Personalized salsa for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedSalsaAsync(BipartiteGraph graph,
VertexSet<ID> vertices,
double d,
int maxIter,
double maxDiff,
VertexProperty<ID,java.lang.Double> salsaRank)
Personalized salsa for a set of vertices of interest.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedSalsaAsync(BipartiteGraph graph,
VertexSet<ID> vertices,
VertexProperty<ID,java.lang.Double> salsaRank)
Personalized salsa for a set of vertices of interest.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
ID vertexId,
java.math.BigDecimal e,
java.math.BigDecimal d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight)
Convenience wrapper around
personalizedWeightedPagerank(PgxGraph, PgxVertex, BigDecimal, BigDecimal, int,
boolean, EdgeProperty) taking a vertex ID instead of a PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
ID vertexId,
java.math.BigDecimal e,
java.math.BigDecimal d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Convenience wrapper around
#personalizedWeightedPagerank(PgxGraph, PgxVertex, BigDecimal, BigDecimal, int, boolean, EdgeProperty,
VertexProperty taking a vertex ID instead of a PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
ID vertexId,
java.math.BigDecimal e,
java.math.BigDecimal d,
int max,
EdgeProperty<java.lang.Double> weight)
Convenience wrapper around
personalizedWeightedPagerank(PgxGraph, PgxVertex, BigDecimal, BigDecimal, int,
EdgeProperty) taking a vertex ID instead of a PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
ID vertexId,
java.math.BigDecimal e,
java.math.BigDecimal d,
int max,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Convenience wrapper around
#personalizedWeightedPagerank(PgxGraph, PgxVertex, BigDecimal, BigDecimal, int, EdgeProperty,
VertexProperty taking a vertex ID instead of a PgxVertex . 
<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
PgxVertex<ID> v,
boolean norm,
EdgeProperty<java.lang.Double> weight)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
PgxVertex<ID> v,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
PgxVertex<ID> v,
EdgeProperty<java.lang.Double> weight)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
PgxVertex<ID> v,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
boolean norm,
EdgeProperty<java.lang.Double> weight)
Personalized pagerank for a set of vertices and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized pagerank for a set of vertices and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight)
Personalized pagerank for a set of vertices and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized pagerank for a set of vertices and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight)
Personalized pagerank for a set of vertices and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized pagerank for a set of vertices and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
EdgeProperty<java.lang.Double> weight)
Personalized pagerank for a set of vertices and weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
personalizedWeightedPagerank(PgxGraph graph,
VertexSet<ID> vertices,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized pagerank for a set of vertices and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
boolean norm,
EdgeProperty<java.lang.Double> weight)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
EdgeProperty<java.lang.Double> weight)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
PgxVertex<ID> v,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized weighted pagerank for a vertex and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
boolean norm,
EdgeProperty<java.lang.Double> weight)
Personalized pagerank for a set of vertices and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized pagerank for a set of vertices and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight)
Personalized pagerank for a set of vertices and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized pagerank for a set of vertices and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight)
Personalized pagerank for a set of vertices and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized pagerank for a set of vertices and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
EdgeProperty<java.lang.Double> weight)
Personalized pagerank for a set of vertices and weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
personalizedWeightedPagerankAsync(PgxGraph graph,
VertexSet<ID> vertices,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
Personalized pagerank for a set of vertices and weighted edges.

Pg2vecModelBuilder 
pg2vecModelBuilder()
Builds a pg2vec model

EdgeProperty<java.lang.Boolean> 
prim(PgxGraph graph,
EdgeProperty<java.lang.Double> weight)
prim reveals tree structures with shortest paths in a graph

EdgeProperty<java.lang.Boolean> 
prim(PgxGraph graph,
EdgeProperty<java.lang.Double> weight,
EdgeProperty<java.lang.Boolean> mst)
prim reveals tree structures with shortest paths in a graph

EdgeProperty<java.lang.Boolean> 
prim(PgxGraph graph,
EdgeProperty<java.lang.Double> weight,
java.lang.String mstName)
Convenience wrapper around
prim(PgxGraph, EdgeProperty, String) 
PgxFuture<EdgeProperty<java.lang.Boolean>> 
primAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> weight)
prim reveals tree structures with shortest paths in a graph

PgxFuture<EdgeProperty<java.lang.Boolean>> 
primAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> weight,
EdgeProperty<java.lang.Boolean> mst)
prim reveals tree structures with shortest paths in a graph

<ID> Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>> 
radius(PgxGraph graph)
Diameter/radius gives an overview of the distances in a graph

<ID> Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>> 
radius(PgxGraph graph,
Scalar<java.lang.Integer> radius,
VertexProperty<ID,java.lang.Integer> eccentricity)
Diameter/radius gives an overview of the distances in a graph

<ID> PgxFuture<Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>>> 
radiusAsync(PgxGraph graph)
Diameter/radius gives an overview of the distances in a graph

<ID> PgxFuture<Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>>> 
radiusAsync(PgxGraph graph,
Scalar<java.lang.Integer> radius,
VertexProperty<ID,java.lang.Integer> eccentricity)
Diameter/radius gives an overview of the distances in a graph

<ID> PgxMap<PgxVertex<ID>,java.lang.Integer> 
randomWalkWithRestart(PgxGraph graph,
ID source,
int length,
java.math.BigDecimal resetProb,
PgxMap<PgxVertex<ID>,java.lang.Integer> visitCount)
Convenience wrapper around
randomWalkWithRestart(PgxGraph, PgxVertex, int, double,
PgxMap) taking a vertex ID instead of a PgxVertex . 
<ID> PgxMap<PgxVertex<ID>,java.lang.Integer> 
randomWalkWithRestart(PgxGraph graph,
PgxVertex<ID> source,
int length,
double resetProb,
PgxMap<PgxVertex<ID>,java.lang.Integer> visitCount)
random walk with restart does the what its name says, it can find approximate stationary distributions

<ID> PgxFuture<PgxMap<PgxVertex<ID>,java.lang.Integer>> 
randomWalkWithRestartAsync(PgxGraph graph,
PgxVertex<ID> source,
int length,
double resetProb,
PgxMap<PgxVertex<ID>,java.lang.Integer> visitCount)
random walk with restart does the what its name says, it can find approximate stationary distributions

<ID> java.lang.Integer 
reachability(PgxGraph graph,
PgxVertex<ID> source,
PgxVertex<ID> dest,
int maxHops,
boolean ignoreEdgeDirection)
Reachability is a fast way to check if two vertices are reachable from each other.

<ID> PgxFuture<java.lang.Integer> 
reachabilityAsync(PgxGraph graph,
PgxVertex<ID> source,
PgxVertex<ID> dest,
int maxHops,
boolean ignoreEdgeDirection)
Reachability is a fast way to check if two vertices are reachable from each other.

<ID> VertexProperty<ID,java.lang.Double> 
salsa(BipartiteGraph graph)
SALSA computes ranking scores.

<ID> VertexProperty<ID,java.lang.Double> 
salsa(BipartiteGraph graph,
double maxDiff,
int maxIter)
SALSA computes ranking scores.

<ID> VertexProperty<ID,java.lang.Double> 
salsa(BipartiteGraph graph,
double maxDiff,
int maxIter,
VertexProperty<ID,java.lang.Double> salsaRank)
SALSA computes ranking scores.

<ID> VertexProperty<ID,java.lang.Double> 
salsa(BipartiteGraph graph,
VertexProperty<ID,java.lang.Double> salsaRank)
SALSA computes ranking scores.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
salsaAsync(BipartiteGraph graph)
SALSA computes ranking scores.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
salsaAsync(BipartiteGraph graph,
double maxDiff,
int maxIter)
SALSA computes ranking scores.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
salsaAsync(BipartiteGraph graph,
double maxDiff,
int maxIter,
VertexProperty<ID,java.lang.Double> salsaRank)
SALSA computes ranking scores.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
salsaAsync(BipartiteGraph graph,
VertexProperty<ID,java.lang.Double> salsaRank)
SALSA computes ranking scores.

<ID> Partition<ID> 
sccKosaraju(PgxGraph graph)
Kosaraju finds strongly connected components in a graph

<ID> Partition<ID> 
sccKosaraju(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Kosaraju finds strongly connected components in a graph

<ID> PgxFuture<Partition<ID>> 
sccKosarajuAsync(PgxGraph graph)
Kosaraju finds strongly connected components in a graph

<ID> PgxFuture<Partition<ID>> 
sccKosarajuAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Kosaraju finds strongly connected components in a graph

<ID> Partition<ID> 
sccTarjan(PgxGraph graph)
Tarjan finds strongly connected components in a graph

<ID> Partition<ID> 
sccTarjan(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Tarjan finds strongly connected components in a graph

<ID> PgxFuture<Partition<ID>> 
sccTarjanAsync(PgxGraph graph)
Tarjan finds strongly connected components in a graph

<ID> PgxFuture<Partition<ID>> 
sccTarjanAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitonDistribution)
Tarjan finds strongly connected components in a graph

<ID> AllPaths<ID> 
shortestPathBellmanFord(PgxGraph graph,
ID srcId,
EdgeProperty<java.lang.Double> cost)
Convenience wrapper around
shortestPathBellmanFord(PgxGraph, PgxVertex, EdgeProperty) taking a vertex ID
instead of PgxVertex . 
<ID> AllPaths<ID> 
shortestPathBellmanFord(PgxGraph graph,
ID srcId,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Convenience wrapper around
shortestPathBellmanFord(PgxGraph, PgxVertex, EdgeProperty, VertexProperty,
VertexProperty, VertexProperty) taking a vertex ID
instead of PgxVertex . 
<ID> AllPaths<ID> 
shortestPathBellmanFord(PgxGraph graph,
PgxVertex<ID> src,
EdgeProperty<java.lang.Double> cost)
Bellmanford finds multiple shortest paths at the same time

<ID> AllPaths<ID> 
shortestPathBellmanFord(PgxGraph graph,
PgxVertex<ID> src,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Bellmanford finds multiple shortest paths at the same time

<ID> PgxFuture<AllPaths<ID>> 
shortestPathBellmanFordAsync(PgxGraph graph,
PgxVertex<ID> src,
EdgeProperty<java.lang.Double> cost)
Bellmanford finds multiple shortest paths at the same time

<ID> PgxFuture<AllPaths<ID>> 
shortestPathBellmanFordAsync(PgxGraph graph,
PgxVertex<ID> src,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Bellmanford finds multiple shortest paths at the same time

<ID> AllPaths<ID> 
shortestPathBellmanFordReverse(PgxGraph graph,
ID srcId,
EdgeProperty<java.lang.Double> cost)
Convenience wrapper around
shortestPathBellmanFordReverse(PgxGraph, PgxVertex, EdgeProperty) taking a
vertex ID instead of PgxVertex . 
<ID> AllPaths<ID> 
shortestPathBellmanFordReverse(PgxGraph graph,
ID srcId,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Convenience wrapper around
shortestPathBellmanFordReverse(PgxGraph, PgxVertex, EdgeProperty,
VertexProperty, VertexProperty, VertexProperty) taking a
vertex ID instead of PgxVertex . 
<ID> AllPaths<ID> 
shortestPathBellmanFordReverse(PgxGraph graph,
PgxVertex<ID> src,
EdgeProperty<java.lang.Double> cost)
Reversed bellmanford finds multiple shortest paths at the same time

<ID> AllPaths<ID> 
shortestPathBellmanFordReverse(PgxGraph graph,
PgxVertex<ID> src,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Reversed bellmanford finds multiple shortest paths at the same time

<ID> PgxFuture<AllPaths<ID>> 
shortestPathBellmanFordReverseAsync(PgxGraph graph,
PgxVertex<ID> src,
EdgeProperty<java.lang.Double> cost)
Reversed bellmanford finds multiple shortest paths at the same time

<ID> PgxFuture<AllPaths<ID>> 
shortestPathBellmanFordReverseAsync(PgxGraph graph,
PgxVertex<ID> src,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Reversed bellmanford finds multiple shortest paths at the same time

<ID> PgxPath<ID> 
shortestPathDijkstra(PgxGraph graph,
ID srcId,
ID dstId,
EdgeProperty<java.lang.Double> cost)
Convenience wrapper around
shortestPathDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty) taking
vertex IDs instead of PgxVertex . 
<ID> PgxPath<ID> 
shortestPathDijkstra(PgxGraph graph,
ID srcId,
ID dstId,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Convenience wrapper around
shortestPathDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty) taking
vertex IDs instead of PgxVertex . 
<ID> PgxPath<ID> 
shortestPathDijkstra(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost)
Dijkstra is a fast algorithm for finding a shortest path in a graph

<ID> PgxPath<ID> 
shortestPathDijkstra(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Dijkstra is a fast algorithm for finding a shortest path in a graph

<ID> PgxFuture<PgxPath<ID>> 
shortestPathDijkstraAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost)
Dijkstra is a fast algorithm for finding a shortest path in a graph

<ID> PgxFuture<PgxPath<ID>> 
shortestPathDijkstraAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Dijkstra is a fast algorithm for finding a shortest path in a graph

<ID> PgxPath<ID> 
shortestPathDijkstraBidirectional(PgxGraph graph,
ID srcId,
ID dstId,
EdgeProperty<java.lang.Double> cost)
Convenience wrapper around
shortestPathDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty)
taking vertex IDs instead of PgxVertex . 
<ID> PgxPath<ID> 
shortestPathDijkstraBidirectional(PgxGraph graph,
ID srcId,
ID dstId,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Convenience wrapper around
shortestPathDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty)
taking vertex IDs instead of PgxVertex . 
<ID> PgxPath<ID> 
shortestPathDijkstraBidirectional(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost)
Bidirectional dijkstra is a fast algorithm for finding a shortest path in a graph

<ID> PgxPath<ID> 
shortestPathDijkstraBidirectional(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Bidirectional dijkstra is a fast algorithm for finding a shortest path in a graph

<ID> PgxFuture<PgxPath<ID>> 
shortestPathDijkstraBidirectionalAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost)
Bidirectional dijkstra is a fast algorithm for finding a shortest path in a graph

<ID> PgxFuture<PgxPath<ID>> 
shortestPathDijkstraBidirectionalAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
java.lang.String parentName,
java.lang.String parentEdgeName) 
<ID> PgxFuture<PgxPath<ID>> 
shortestPathDijkstraBidirectionalAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Bidirectional dijkstra is a fast algorithm for finding a shortest path in a graph

<ID> PgxPath<ID> 
shortestPathFilteredDijkstra(PgxGraph graph,
ID srcId,
ID dstId,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr)
Convenience wrapper around
shortestPathFilteredDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter) taking vertex IDs
instead of PgxVertex . 
<ID> PgxPath<ID> 
shortestPathFilteredDijkstra(PgxGraph graph,
ID srcId,
ID dstId,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Convenience wrapper around
shortestPathFilteredDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter) taking vertex IDs
instead of PgxVertex . 
<ID> PgxPath<ID> 
shortestPathFilteredDijkstra(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr)
Filtered Dijkstra is a fast algorithm for finding a shortest path while also filtering edges

<ID> PgxPath<ID> 
shortestPathFilteredDijkstra(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Filtered Dijkstra is a fast algorithm for finding a shortest path while also filtering edges

<ID> PgxFuture<PgxPath<ID>> 
shortestPathFilteredDijkstraAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr)
Filtered Dijkstra is a fast algorithm for finding a shortest path while also filtering edges

<ID> PgxFuture<PgxPath<ID>> 
shortestPathFilteredDijkstraAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Filtered Dijkstra is a fast algorithm for finding a shortest path while also filtering edges

<ID> PgxPath<ID> 
shortestPathFilteredDijkstraBidirectional(PgxGraph graph,
ID srcId,
ID dstId,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr)
Convenience wrapper around
shortestPathFilteredDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter)
taking vertex IDs instead of PgxVertex . 
<ID> PgxPath<ID> 
shortestPathFilteredDijkstraBidirectional(PgxGraph graph,
ID srcId,
ID dstId,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Convenience wrapper around
shortestPathFilteredDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter)
taking vertex IDs instead of PgxVertex . 
<ID> PgxPath<ID> 
shortestPathFilteredDijkstraBidirectional(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr)
Bidirectional dijkstra is a fast algorithm for finding a shortest path while also filtering edges

<ID> PgxPath<ID> 
shortestPathFilteredDijkstraBidirectional(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Bidirectional dijkstra is a fast algorithm for finding a shortest path while also filtering edges

<ID> PgxFuture<PgxPath<ID>> 
shortestPathFilteredDijkstraBidirectionalAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr)
Bidirectional dijkstra is a fast algorithm for finding a shortest path while also filtering edges

<ID> PgxFuture<PgxPath<ID>> 
shortestPathFilteredDijkstraBidirectionalAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr,
java.lang.String parentName,
java.lang.String parentEdgeName) 
<ID> PgxFuture<PgxPath<ID>> 
shortestPathFilteredDijkstraBidirectionalAsync(PgxGraph graph,
PgxVertex<ID> src,
PgxVertex<ID> dst,
EdgeProperty<java.lang.Double> cost,
GraphFilter filterExpr,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Bidirectional dijkstra is a fast algorithm for finding a shortest path while also filtering edges

<ID> AllPaths<ID> 
shortestPathHopDist(PgxGraph graph,
ID srcId)
Convenience wrapper around
shortestPathHopDist(PgxGraph, PgxVertex) taking a vertex ID instead of
PgxVertex . 
<ID> AllPaths<ID> 
shortestPathHopDist(PgxGraph graph,
ID srcId,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Convenience wrapper around
shortestPathHopDist(PgxGraph, PgxVertex, VertexProperty, VertexProperty,
VertexProperty) taking a vertex ID instead of
PgxVertex . 
<ID> AllPaths<ID> 
shortestPathHopDist(PgxGraph graph,
PgxVertex<ID> src)
Hop distance can give a relatively fast insight on the distances in a graph

<ID> AllPaths<ID> 
shortestPathHopDist(PgxGraph graph,
PgxVertex<ID> src,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Hop distance can give a relatively fast insight on the distances in a graph

<ID> PgxFuture<AllPaths<ID>> 
shortestPathHopDistAsync(PgxGraph graph,
PgxVertex<ID> src)
Hop distance can give a relatively fast insight on the distances in a graph

<ID> PgxFuture<AllPaths<ID>> 
shortestPathHopDistAsync(PgxGraph graph,
PgxVertex<ID> src,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Hop distance can give a relatively fast insight on the distances in a graph

<ID> AllPaths<ID> 
shortestPathHopDistReverse(PgxGraph graph,
ID srcId)
Convenience wrapper around
shortestPathHopDistReverse(PgxGraph, PgxVertex) taking a vertex ID instead of
PgxVertex . 
<ID> AllPaths<ID> 
shortestPathHopDistReverse(PgxGraph graph,
ID srcId,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Convenience wrapper around
shortestPathHopDistReverse(PgxGraph, PgxVertex, VertexProperty, VertexProperty,
VertexProperty) taking a vertex ID instead of
PgxVertex . 
<ID> AllPaths<ID> 
shortestPathHopDistReverse(PgxGraph graph,
PgxVertex<ID> src)
Backwards hop distance can give a relatively fast insight on the distances in a graph

<ID> AllPaths<ID> 
shortestPathHopDistReverse(PgxGraph graph,
PgxVertex<ID> src,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Backwards hop distance can give a relatively fast insight on the distances in a graph

<ID> PgxFuture<AllPaths<ID>> 
shortestPathHopDistReverseAsync(PgxGraph graph,
PgxVertex<ID> src)
Backwards hop distance can give a relatively fast insight on the distances in a graph

<ID> PgxFuture<AllPaths<ID>> 
shortestPathHopDistReverseAsync(PgxGraph graph,
PgxVertex<ID> src,
VertexProperty<ID,java.lang.Double> distance,
VertexProperty<ID,PgxVertex<ID>> parent,
VertexProperty<ID,PgxEdge> parentEdge)
Backwards hop distance can give a relatively fast insight on the distances in a graph

SupervisedGraphWiseModelBuilder 
supervisedGraphWiseModelBuilder()
Return a SupervisedGraphWise model builder that can be used to set the configuration of the model and then create
it.

<ID> VertexProperty<ID,java.lang.Integer> 
topologicalSchedule(PgxGraph graph,
VertexSet<ID> source)
Topological schedule gives an order of visit for the reachable vertices from the source

<ID> VertexProperty<ID,java.lang.Integer> 
topologicalSchedule(PgxGraph graph,
VertexSet<ID> source,
VertexProperty<ID,java.lang.Integer> topoSched)
Topological sort gives an order of visit for vertices in directed acyclic graphs

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
topologicalScheduleAsync(PgxGraph graph,
VertexSet<ID> source)
Topological schedule gives an order of visit for the reachable vertices from the source

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
topologicalScheduleAsync(PgxGraph graph,
VertexSet<ID> source,
VertexProperty<ID,java.lang.Integer> topoSched)
Topological schedule gives an order of visit for the reachable vertices from the source

<ID> VertexProperty<ID,java.lang.Integer> 
topologicalSort(PgxGraph graph)
Topological sort gives an order of visit for vertices in directed acyclic graphs

<ID> VertexProperty<ID,java.lang.Integer> 
topologicalSort(PgxGraph graph,
VertexProperty<ID,java.lang.Integer> topoSort)
Topological sort gives an order of visit for vertices in directed acyclic graphs

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
topologicalSortAsync(PgxGraph graph)
Topological sort gives an order of visit for vertices in directed acyclic graphs

<ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> 
topologicalSortAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Integer> topoSort)
Topological sort gives an order of visit for vertices in directed acyclic graphs

java.lang.String 
toString() 
<ID> VertexProperty<ID,java.lang.Double> 
vertexBetweennessCentrality(PgxGraph graph)
Betweenness centrality measures the centrality of the vertices to identify important vertices for the flow of information

<ID> VertexProperty<ID,java.lang.Double> 
vertexBetweennessCentrality(PgxGraph graph,
VertexProperty<ID,java.lang.Double> bc)
Betweenness centrality measures the centrality of the vertices to identify important vertices for the flow of information

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
vertexBetweennessCentralityAsync(PgxGraph graph)
Betweenness centrality measures the centrality of the vertices to identify important vertices for the flow of information

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
vertexBetweennessCentralityAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Double> bc)
Betweenness centrality measures the centrality of the vertices to identify important vertices for the flow of information

<ID> Partition<ID> 
wcc(PgxGraph graph)
Identifying weakly connected components can be useful for clustering graph data

<ID> Partition<ID> 
wcc(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Identifying weakly connected components can be useful for clustering graph data

<ID> PgxFuture<Partition<ID>> 
wccAsync(PgxGraph graph)
Identifying weakly connected components can be useful for clustering graph data

<ID> PgxFuture<Partition<ID>> 
wccAsync(PgxGraph graph,
java.lang.String partitonDistributionName) 
<ID> PgxFuture<Partition<ID>> 
wccAsync(PgxGraph graph,
VertexProperty<ID,java.lang.Long> partitionDistribution)
Identifying weakly connected components can be useful for clustering graph data

<ID> VertexProperty<ID,java.lang.Double> 
weightedPagerank(PgxGraph graph,
boolean norm,
EdgeProperty<java.lang.Double> weight)
PageRank on weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
weightedPagerank(PgxGraph graph,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
PageRank on weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
weightedPagerank(PgxGraph graph,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight)
PageRank on weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
weightedPagerank(PgxGraph graph,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
PageRank on weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
weightedPagerank(PgxGraph graph,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight)
PageRank on weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
weightedPagerank(PgxGraph graph,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
PageRank on weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
weightedPagerank(PgxGraph graph,
EdgeProperty<java.lang.Double> weight)
PageRank on weighted edges.

<ID> VertexProperty<ID,java.lang.Double> 
weightedPagerank(PgxGraph graph,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
PageRank on weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
weightedPagerankAsync(PgxGraph graph,
boolean norm,
EdgeProperty<java.lang.Double> weight)
PageRank on weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
weightedPagerankAsync(PgxGraph graph,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
PageRank on weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
weightedPagerankAsync(PgxGraph graph,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight)
PageRank on weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
weightedPagerankAsync(PgxGraph graph,
double e,
double d,
int max,
boolean norm,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
PageRank on weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
weightedPagerankAsync(PgxGraph graph,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight)
PageRank on weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
weightedPagerankAsync(PgxGraph graph,
double e,
double d,
int max,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
PageRank on weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
weightedPagerankAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> weight)
PageRank on weighted edges.

<ID> PgxFuture<VertexProperty<ID,java.lang.Double>> 
weightedPagerankAsync(PgxGraph graph,
EdgeProperty<java.lang.Double> weight,
VertexProperty<ID,java.lang.Double> rank)
PageRank on weighted edges.

<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
ID vertexId,
int topK)
Convenience wrapper around
whomToFollow(PgxGraph, PgxVertex, int) taking a vertex ID instead of a
PgxVertex . 
<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
ID vertexId,
int topK,
int sizeCircleOfTrust)
Convenience wrapper around
whomToFollow(PgxGraph, PgxVertex, int, int) taking a vertex ID instead of a
PgxVertex . 
<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
ID vertexId,
int topK,
int sizeCircleOfTrust,
int maxIter,
java.math.BigDecimal tol,
java.math.BigDecimal dampingFactor,
int salsaMaxIter,
java.math.BigDecimal salsaTol)
Convenience wrapper around
whomToFollow(PgxGraph, PgxVertex, int, int, int, BigDecimal, BigDecimal, int, BigDecimal)
taking a vertex ID instead of a PgxVertex . 
<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
ID vertexId,
int topK,
int sizeCircleOfTrust,
int maxIter,
java.math.BigDecimal tol,
java.math.BigDecimal dampingFactor,
int salsaMaxIter,
java.math.BigDecimal salsaTol,
VertexSequence<ID> hubs,
VertexSequence<ID> authorities)
Convenience wrapper around
whomToFollow(PgxGraph, PgxVertex, int, int, int, BigDecimal, BigDecimal, int, BigDecimal, VertexSequence,
VertexSequence)
taking a vertex ID instead of a PgxVertex . 
<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
PgxVertex<ID> vertex)
WTF is a recommendation algorithm.

<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
PgxVertex<ID> vertex,
int topK)
WTF is a recommendation algorithm.

<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
int sizeCircleOfTrust)
WTF is a recommendation algorithm.

<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
int sizeCircleOfTrust,
int maxIter,
double tol,
double dampingFactor,
int salsaMaxIter,
double salsaTol)
WTF is a recommendation algorithm.

<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
int sizeCircleOfTrust,
int maxIter,
double tol,
double dampingFactor,
int salsaMaxIter,
double salsaTol,
VertexSequence<ID> hubs,
VertexSequence<ID> authorities)
WTF is a recommendation algorithm.

<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
int sizeCircleOfTrust,
VertexSequence<ID> hubs,
VertexSequence<ID> authorities)
WTF is a recommendation algorithm.

<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
VertexSequence<ID> hubs,
VertexSequence<ID> authorities)
WTF is a recommendation algorithm.

<ID> Pair<VertexSequence<ID>,VertexSequence<ID>> 
whomToFollow(PgxGraph graph,
PgxVertex<ID> vertex,
VertexSequence<ID> hubs,
VertexSequence<ID> authorities)
WTF is a recommendation algorithm.

<ID> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> 
whomToFollowAsync(PgxGraph graph,
PgxVertex<ID> vertex)
WTF is a recommendation algorithm.

<ID> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> 
whomToFollowAsync(PgxGraph graph,
PgxVertex<ID> vertex,
int topK)
WTF is a recommendation algorithm.

<ID> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> 
whomToFollowAsync(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
int sizeCircleOfTrust)
WTF is a recommendation algorithm.

<ID> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> 
whomToFollowAsync(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
int sizeCircleOfTrust,
int maxIter,
double tol,
double dampingFactor,
int salsaMaxIter,
double salsaTol)
WTF is a recommendation algorithm.

<ID> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> 
whomToFollowAsync(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
int sizeCircleOfTrust,
int maxIter,
double tol,
double dampingFactor,
int salsaMaxIter,
double salsaTol,
VertexSequence<ID> hubs,
VertexSequence<ID> authorities)
WTF is a recommendation algorithm.

<ID> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> 
whomToFollowAsync(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
int sizeCircleOfTrust,
VertexSequence<ID> hubs,
VertexSequence<ID> authorities)
WTF is a recommendation algorithm.

<ID> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> 
whomToFollowAsync(PgxGraph graph,
PgxVertex<ID> vertex,
int topK,
VertexSequence<ID> hubs,
VertexSequence<ID> authorities)
WTF is a recommendation algorithm.

<ID> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> 
whomToFollowAsync(PgxGraph graph,
PgxVertex<ID> vertex,
VertexSequence<ID> hubs,
VertexSequence<ID> authorities)
WTF is a recommendation algorithm.

close, destroy, destroyAsync
public <V> EdgeProperty<java.lang.Double> adamicAdarCounting(PgxGraph graph) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
The adamicadar index compares the amount of neighbors shared between vertices, this measure can be used with communities.
The AdamicAdar index is meant for undirected graphs, since it is computed using the degree of the shared neighbors by two vertices in the graph. This implementation computes the index for every pair of vertices connected by an edge and associates it with that edge.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(E) with E = number of edges
O(E) with E = number of edges
graph
 the graph.
PgxGraph graph = ...;
EdgeProperty<Double> adamicAdar = analyst.adamicAdarCounting(graph);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + adamicAdar.getName() + " MATCH (x) ORDER BY x." + adamicAdar.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <V> EdgeProperty<java.lang.Double> adamicAdarCounting(PgxGraph graph, EdgeProperty<java.lang.Double> aa) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
The adamicadar index compares the amount of neighbors shared between vertices, this measure can be used with communities.
The AdamicAdar index is meant for undirected graphs, since it is computed using the degree of the shared neighbors by two vertices in the graph. This implementation computes the index for every pair of vertices connected by an edge and associates it with that edge.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(E) with E = number of edges
O(E) with E = number of edges
graph
 the graph.aa
 (out argument)
edge property holding the AdamicAdar index of each edge in the graph.
PgxGraph graph = ...;
EdgeProperty<Double> aa = graph.createEdgeProperty(PropertyType.DOUBLE);
EdgeProperty<Double> adamicAdar = analyst.adamicAdarCounting(graph, aa);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + adamicAdar.getName() + " MATCH (x) ORDER BY x." + adamicAdar.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public PgxFuture<EdgeProperty<java.lang.Double>> adamicAdarCountingAsync(PgxGraph graph)
The adamicadar index compares the amount of neighbors shared between vertices, this measure can be used with communities.
The AdamicAdar index is meant for undirected graphs, since it is computed using the degree of the shared neighbors by two vertices in the graph. This implementation computes the index for every pair of vertices connected by an edge and associates it with that edge.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(E) with E = number of edges
O(E) with E = number of edges
graph
 the graph.
PgxGraph graph = ...;
PgxFuture<EdgeProperty<Double>> promise = analyst.adamicAdarCountingAsync(graph);
promise.thenCompose(adamicAdar > graph.queryPgqlAsync(
"SELECT x, x." + adamicAdar.getName() + " MATCH (x) ORDER BY x." + adamicAdar.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public PgxFuture<EdgeProperty<java.lang.Double>> adamicAdarCountingAsync(PgxGraph graph, EdgeProperty<java.lang.Double> aa)
The adamicadar index compares the amount of neighbors shared between vertices, this measure can be used with communities.
The AdamicAdar index is meant for undirected graphs, since it is computed using the degree of the shared neighbors by two vertices in the graph. This implementation computes the index for every pair of vertices connected by an edge and associates it with that edge.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(E) with E = number of edges
O(E) with E = number of edges
graph
 the graph.aa
 (out argument)
edge property holding the AdamicAdar index of each edge in the graph.
PgxGraph graph = ...;
EdgeProperty<Double> aa = graph.createEdgeProperty(PropertyType.DOUBLE);
PgxFuture<EdgeProperty<Double>> promise = analyst.adamicAdarCountingAsync(graph, aa);
promise.thenCompose(adamicAdar > graph.queryPgqlAsync(
"SELECT x, x." + adamicAdar.getName() + " MATCH (x) ORDER BY x." + adamicAdar.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> org.apache.commons.lang3.tuple.Triple<VertexSet<ID>,EdgeSet,PgxMap<PgxVertex<ID>,java.lang.Integer>> allReachableVerticesEdges(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, int k) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.
null
O(E) with E = number of edges
O(V) with V = number of vertices
graph
 the graph.src
 the source vertex.dst
 the destination vertex.k
 the dimension of the distances property; i.e. number of highdegree vertices.Triple
containing a vertexset with the vertices on the path, an edgeset with the edges on
the path and a map containing the distances from the source vertex for each vertex on the pathjava.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<org.apache.commons.lang3.tuple.Triple<VertexSet<ID>,EdgeSet,PgxMap<PgxVertex<ID>,java.lang.Integer>>> allReachableVerticesEdgesAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, int k)
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.
null
O(E) with E = number of edges
O(V) with V = number of vertices
graph
 the graph.src
 the source vertex.dst
 the destination vertex.k
 the dimension of the distances property; i.e. number of highdegree vertices.Triple
containing a vertexset with the vertices on the path, an edgeset with the edges on
the path and a map containing the distances from the source vertex for each vertex on the pathpublic <ID> org.apache.commons.lang3.tuple.Triple<VertexSet<ID>,EdgeSet,PgxMap<PgxVertex<ID>,java.lang.Integer>> allReachableVerticesEdgesFiltered(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, int k, EdgeFilter filter) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.
null
O(E) with E = number of edges
O(V) with V = number of vertices
graph
 the graph.src
 the source vertex.dst
 the destination vertex.k
 the dimension of the distances property; i.e. number of highdegree vertices.filter
 the filter to be used on edges when searching for a path.Triple
containing a vertexset with the vertices on the path, an edgeset with the edges on
the path and a map containing the distances from the source vertex for each vertex on the pathjava.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<org.apache.commons.lang3.tuple.Triple<VertexSet<ID>,EdgeSet,PgxMap<PgxVertex<ID>,java.lang.Integer>>> allReachableVerticesEdgesFilteredAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, int k, EdgeFilter filter)
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.
Finds all the vertices and edges on a path between the src and target of length smaller or equal to k.
null
O(E) with E = number of edges
O(V) with V = number of vertices
graph
 the graph.src
 the source vertex.dst
 the destination vertex.k
 the dimension of the distances property; i.e. number of highdegree vertices.filter
 the filter to be used on edges when searching for a path.Triple
containing a vertexset with the vertices on the path, an edgeset with the edges on
the path and a map containing the distances from the source vertex for each vertex on the pathpublic <ID> VertexProperty<ID,java.lang.Double> approximateVertexBetweennessCentrality(PgxGraph graph, int k) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information
This variant of betweenness centrality approximates the centrality of the vertices by just using k random vertices as starting points for the BFS traversals of the graph, instead of computing the exact value by using all the vertices in the graph.
The implementation of this algorithm uses a builtin BFS method for the graph traversals. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.k
 number of random vertices to be used to compute the approximated betweenness centrality coeficients.
PgxGraph graph = ...;
VertexProperty<Integer, Double> betweenness = analyst.approximateVertexBetweennessCentrality(graph, 100);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + betweenness.getName() + " MATCH (x) ORDER BY x." + betweenness.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> VertexProperty<ID,java.lang.Double> approximateVertexBetweennessCentrality(PgxGraph graph, int k, VertexProperty<ID,java.lang.Double> bc) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information
This variant of betweenness centrality approximates the centrality of the vertices by just using k random vertices as starting points for the BFS traversals of the graph, instead of computing the exact value by using all the vertices in the graph.
The implementation of this algorithm uses a builtin BFS method for the graph traversals. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.k
 number of random vertices to be used to compute the approximated betweenness centrality coeficients.bc
 (out argument)
vertex property holding the betweenness centrality value for each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Double> bc = graph.createVertexProperty(PropertyType.DOUBLE);
VertexProperty<Integer, Double> betweenness = analyst.approximateVertexBetweennessCentrality(graph, 100, bc);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + betweenness.getName() + " MATCH (x) ORDER BY x." + betweenness.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> approximateVertexBetweennessCentralityAsync(PgxGraph graph, int k)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information
This variant of betweenness centrality approximates the centrality of the vertices by just using k random vertices as starting points for the BFS traversals of the graph, instead of computing the exact value by using all the vertices in the graph.
The implementation of this algorithm uses a builtin BFS method for the graph traversals. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.k
 number of random vertices to be used to compute the approximated betweenness centrality coeficients.
PgxGraph graph = ...;
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.approximateVertexBetweennessCentralityAsync(
graph, 100);
promise.thenCompose(betweenness > graph.queryPgqlAsync(
"SELECT x, x." + betweenness.getName() + " MATCH (x) ORDER BY x." + betweenness.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> approximateVertexBetweennessCentralityAsync(PgxGraph graph, int k, VertexProperty<ID,java.lang.Double> bc)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information
This variant of betweenness centrality approximates the centrality of the vertices by just using k random vertices as starting points for the BFS traversals of the graph, instead of computing the exact value by using all the vertices in the graph.
The implementation of this algorithm uses a builtin BFS method for the graph traversals. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.k
 number of random vertices to be used to compute the approximated betweenness centrality coeficients.bc
 (out argument)
vertex property holding the betweenness centrality value for each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Double> bc = graph.createVertexProperty(PropertyType.DOUBLE);
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.approximateVertexBetweennessCentralityAsync(
graph, 100, bc);
promise.thenCompose(betweenness > graph.queryPgqlAsync(
"SELECT x, x." + betweenness.getName() + " MATCH (x) ORDER BY x." + betweenness.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
@SafeVarargs public final <ID> VertexProperty<ID,java.lang.Double> approximateVertexBetweennessCentralityFromSeeds(PgxGraph graph, PgxVertex<ID>... seeds) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information
This variant of betweenness centrality approximates the centrality of the vertices by just using the vertices from the given sequence as starting points for the BFS traversals of the graph, instead of computing the exact value by using all the vertices in the graph.
The implementation of this algorithm uses a builtin BFS method for the graph traversals. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.seeds
 the (unique) chosen nodes to be used to compute the approximated betweenness centrality coeficients.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexProperty<Integer, Double> betweenness =
analyst.approximateVertexBetweennessCentralityFromSeeds(graph, vertex);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + betweenness.getName() + " MATCH (x) ORDER BY x." + betweenness.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
@SafeVarargs public final <ID> VertexProperty<ID,java.lang.Double> approximateVertexBetweennessCentralityFromSeeds(PgxGraph graph, VertexProperty<ID,java.lang.Double> bc, PgxVertex<ID>... seeds) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information
This variant of betweenness centrality approximates the centrality of the vertices by just using the vertices from the given sequence as starting points for the BFS traversals of the graph, instead of computing the exact value by using all the vertices in the graph.
The implementation of this algorithm uses a builtin BFS method for the graph traversals. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.bc
 (out argument)
vertex property holding the betweenness centrality value for each vertex.seeds
 the (unique) chosen nodes to be used to compute the approximated betweenness centrality coeficients.
PgxGraph graph = ...;
VertexProperty<Integer, Double> bc = graph.createVertexProperty(PropertyType.DOUBLE);
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexProperty<Integer, Double> betweenness =
analyst.approximateVertexBetweennessCentralityFromSeeds(graph, bc, vertex);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + betweenness.getName() + " MATCH (x) ORDER BY x." + betweenness.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
@SafeVarargs public final <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> approximateVertexBetweennessCentralityFromSeedsAsync(PgxGraph graph, PgxVertex<ID>... seeds)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information
This variant of betweenness centrality approximates the centrality of the vertices by just using the vertices from the given sequence as starting points for the BFS traversals of the graph, instead of computing the exact value by using all the vertices in the graph.
The implementation of this algorithm uses a builtin BFS method for the graph traversals. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.seeds
 the (unique) chosen nodes to be used to compute the approximated betweenness centrality coeficients.
PgxGraph graph = ...;
PgxVertex<Integer> v1 = graph.getVertex(128);
PgxVertex<Integer> v2 = graph.getVertex(333);
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.approximateVertexBetweennessCentralityFromSeedsAsync(
graph, v1, v2);
promise.thenCompose(betweenness > graph.queryPgqlAsync(
"SELECT x, x." + betweenness.getName() + " MATCH (x) ORDER BY x." + betweenness.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
@SafeVarargs public final <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> approximateVertexBetweennessCentralityFromSeedsAsync(PgxGraph graph, VertexProperty<ID,java.lang.Double> bc, PgxVertex<ID>... seeds)
Faster, but less accurate than betweenness centrality, it identifies important vertices for the flow of information
This variant of betweenness centrality approximates the centrality of the vertices by just using the vertices from the given sequence as starting points for the BFS traversals of the graph, instead of computing the exact value by using all the vertices in the graph.
The implementation of this algorithm uses a builtin BFS method for the graph traversals. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.bc
 (out argument)
vertex property holding the betweenness centrality value for each vertex.seeds
 the (unique) chosen nodes to be used to compute the approximated betweenness centrality coeficients.
PgxGraph graph = ...;
VertexProperty<Integer, Double> bc = graph.createVertexProperty(PropertyType.DOUBLE);
PgxVertex<Integer> v1 = graph.getVertex(128);
PgxVertex<Integer> v2 = graph.getVertex(333);
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.approximateVertexBetweennessCentralityFromSeedsAsync(
graph, bc, v1, v2);
promise.thenCompose(betweenness > graph.queryPgqlAsync(
"SELECT x, x." + betweenness.getName() + " MATCH (x) ORDER BY x." + betweenness.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> VertexProperty<ID,java.lang.Boolean> bipartiteCheck(PgxGraph graph, VertexProperty<ID,java.lang.Boolean> isLeft) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Bipartite check verifies whether are graph is a bipartite graph.
This algorithm checks whether the given directed graph is bipartite. It assumes that all the edges are going in the same direction since the method relies on BFS traversals of the graph. If the graph is bipartite the algorithm will return the side of each vertex in the graph with the is_left vertex property.
The implementation of this algorithm uses a builtin BFS method for the graph traversals.
O(E) with E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.isLeft
 vertex property holding the side of each vertex in a bipartite graph (true for left, false for right).
PgxGraph graph = ...;
VertexProperty<Integer, Boolean> isLeft = graph.createVertexProperty(PropertyType.BOOLEAN);
VertexProperty<Integer, Boolean> bipartite = analyst.BipartiteCheck(graph, isLeft);
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<VertexProperty<ID,java.lang.Boolean>> bipartiteCheckAsync(PgxGraph graph, VertexProperty<ID,java.lang.Boolean> isLeft)
Bipartite check verifies whether are graph is a bipartite graph.
This algorithm checks whether the given directed graph is bipartite. It assumes that all the edges are going in the same direction since the method relies on BFS traversals of the graph. If the graph is bipartite the algorithm will return the side of each vertex in the graph with the is_left vertex property.
The implementation of this algorithm uses a builtin BFS method for the graph traversals.
O(E) with E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.isLeft
 vertex property holding the side of each vertex in a bipartite graph (true for left, false for right).
PgxGraph graph = ...;
VertexProperty<Integer, Boolean> isLeft = graph.createVertexProperty(PropertyType.BOOLEAN);
PgxFuture<VertexProperty<Integer, Boolean>> promise = analyst.BipartiteCheck(graph, isLeft);
public <ID> VertexSet<ID> center(PgxGraph graph) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph
The periphery of a graph is the set of vertices that have an eccentricity value equal to the diameter of the graph. Similarly, the center is comprised by the set of vertices with eccentricity equal to the radius of the graph. The diameter of a graph is the maximal value of eccentricity of all the vertices in the graph, while the radius is the minimum graph eccentricity. The eccentricity of a vertex is the maximum distance via shortests paths to any other vertex in the graph. This algorithm will return the set of vertices from the periphery or the center of the graph, depending on the request. The algorithm will return a set with all the vertices for graphs with more than one strongly connected component.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortests paths. It still is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
VertexSet<Integer> center = analyst.center(graph);
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> VertexSet<ID> center(PgxGraph graph, VertexSet<ID> center) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph
The periphery of a graph is the set of vertices that have an eccentricity value equal to the diameter of the graph. Similarly, the center is comprised by the set of vertices with eccentricity equal to the radius of the graph. The diameter of a graph is the maximal value of eccentricity of all the vertices in the graph, while the radius is the minimum graph eccentricity. The eccentricity of a vertex is the maximum distance via shortests paths to any other vertex in the graph. This algorithm will return the set of vertices from the periphery or the center of the graph, depending on the request. The algorithm will return a set with all the vertices for graphs with more than one strongly connected component.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortests paths. It still is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.center
 (out argument) vertex set holding the vertices from the periphery or center of the graph.
PgxGraph graph = ...;
VertexSet<Integer> vertices = graph.createVertexSet();
VertexSet<Integer> center = analyst.center(graph, vertices);
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<VertexSet<ID>> centerAsync(PgxGraph graph)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph
The periphery of a graph is the set of vertices that have an eccentricity value equal to the diameter of the graph. Similarly, the center is comprised by the set of vertices with eccentricity equal to the radius of the graph. The diameter of a graph is the maximal value of eccentricity of all the vertices in the graph, while the radius is the minimum graph eccentricity. The eccentricity of a vertex is the maximum distance via shortests paths to any other vertex in the graph. This algorithm will return the set of vertices from the periphery or the center of the graph, depending on the request. The algorithm will return a set with all the vertices for graphs with more than one strongly connected component.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortests paths. It still is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
PgxFuture<VertexSet<Integer>> promise = analyst.centerAsync(graph);
promise.thenAccept(center > {
...;
});
public <ID> PgxFuture<VertexSet<ID>> centerAsync(PgxGraph graph, VertexSet<ID> center)
Periphery/center gives an overview of the extreme distances and the corresponding vertices in a graph
The periphery of a graph is the set of vertices that have an eccentricity value equal to the diameter of the graph. Similarly, the center is comprised by the set of vertices with eccentricity equal to the radius of the graph. The diameter of a graph is the maximal value of eccentricity of all the vertices in the graph, while the radius is the minimum graph eccentricity. The eccentricity of a vertex is the maximum distance via shortests paths to any other vertex in the graph. This algorithm will return the set of vertices from the periphery or the center of the graph, depending on the request. The algorithm will return a set with all the vertices for graphs with more than one strongly connected component.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortests paths. It still is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.center
 (out argument) vertex set holding the vertices from the periphery or center of the graph.
PgxGraph graph = ...;
VertexSet<Integer> vertices = graph.createVertexSet();
PgxFuture<VertexSet<Integer>> promise = analyst.centerAsync(graph, vertices);
promise.thenAccept(center > {
...;
});
public <ID> VertexProperty<ID,java.lang.Double> closenessCentralityDoubleLength(PgxGraph graph, EdgeProperty<java.lang.Double> cost) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Closenness centrality measures the centrality of the vertices based on weighted distances, allowing to find wellconnected vertices
This variant of Closeness Centrality takes into account the weights from the edges when computing the reciprocal of the sum of all the distances from the possible shortests paths starting from the vertex V, for every vertex in the graph. The weights of the edges must be positive values greater than 0.
The implementation of is more expensive to compute than the normal closeness centrality because of the inclusion of the weights in the edges which influence the selection of edges for the shortest paths. It is an expensive algorithm to run on large graphs.
O(V * E * d) with E = number of edges, V = number of vertices, d = diameter of the graph
O(5 * V) with V = number of vertices
graph
 the graph.cost
 edge property holding the weight of each edge in the graph.
PgxGraph graph = ...;
EdgeProperty<Double> cost = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> closeness = analyst.closenessCentralityDoubleLength(graph, cost);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + closeness.getName() + " MATCH (x) ORDER BY x." + closeness.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> VertexProperty<ID,java.lang.Double> closenessCentralityDoubleLength(PgxGraph graph, EdgeProperty<java.lang.Double> cost, VertexProperty<ID,java.lang.Double> cc) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Closenness centrality measures the centrality of the vertices based on weighted distances, allowing to find wellconnected vertices
This variant of Closeness Centrality takes into account the weights from the edges when computing the reciprocal of the sum of all the distances from the possible shortests paths starting from the vertex V, for every vertex in the graph. The weights of the edges must be positive values greater than 0.
The implementation of is more expensive to compute than the normal closeness centrality because of the inclusion of the weights in the edges which influence the selection of edges for the shortest paths. It is an expensive algorithm to run on large graphs.
O(V * E * d) with E = number of edges, V = number of vertices, d = diameter of the graph
O(5 * V) with V = number of vertices
graph
 the graph.cost
 edge property holding the weight of each edge in the graph.cc
 (out argument)
vertex property holding the closeness centrality value for each vertex.
PgxGraph graph = ...;
EdgeProperty<Double> cost = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> cc = graph.createVertexProperty(PropertyType.DOUBLE);
VertexProperty<Integer, Double> closeness = analyst.closenessCentralityDoubleLength(graph, cost, cc);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + closeness.getName() + " MATCH (x) ORDER BY x." + closeness.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> closenessCentralityDoubleLengthAsync(PgxGraph graph, EdgeProperty<java.lang.Double> cost)
Closenness centrality measures the centrality of the vertices based on weighted distances, allowing to find wellconnected vertices
This variant of Closeness Centrality takes into account the weights from the edges when computing the reciprocal of the sum of all the distances from the possible shortests paths starting from the vertex V, for every vertex in the graph. The weights of the edges must be positive values greater than 0.
The implementation of is more expensive to compute than the normal closeness centrality because of the inclusion of the weights in the edges which influence the selection of edges for the shortest paths. It is an expensive algorithm to run on large graphs.
O(V * E * d) with E = number of edges, V = number of vertices, d = diameter of the graph
O(5 * V) with V = number of vertices
graph
 the graph.cost
 edge property holding the weight of each edge in the graph.
PgxGraph graph = ...;
EdgeProperty<Double> cost = graph.getEdgeProperty("cost");
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.closenessCentralityDoubleLengthAsync(graph, cost);
promise.thenCompose(closeness > graph.queryPgqlAsync(
"SELECT x, x." + closeness.getName() + " MATCH (x) ORDER BY x." + closeness.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> closenessCentralityDoubleLengthAsync(PgxGraph graph, EdgeProperty<java.lang.Double> cost, VertexProperty<ID,java.lang.Double> cc)
Closenness centrality measures the centrality of the vertices based on weighted distances, allowing to find wellconnected vertices
This variant of Closeness Centrality takes into account the weights from the edges when computing the reciprocal of the sum of all the distances from the possible shortests paths starting from the vertex V, for every vertex in the graph. The weights of the edges must be positive values greater than 0.
The implementation of is more expensive to compute than the normal closeness centrality because of the inclusion of the weights in the edges which influence the selection of edges for the shortest paths. It is an expensive algorithm to run on large graphs.
O(V * E * d) with E = number of edges, V = number of vertices, d = diameter of the graph
O(5 * V) with V = number of vertices
graph
 the graph.cost
 edge property holding the weight of each edge in the graph.cc
 (out argument)
vertex property holding the closeness centrality value for each vertex.
PgxGraph graph = ...;
EdgeProperty<Double> cost = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> cc = graph.createVertexProperty(PropertyType.DOUBLE);
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.closenessCentralityDoubleLengthAsync(graph, cost, cc);
promise.thenCompose(closeness > graph.queryPgqlAsync(
"SELECT x, x." + closeness.getName() + " MATCH (x) ORDER BY x." + closeness.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> VertexProperty<ID,java.lang.Double> closenessCentralityUnitLength(PgxGraph graph) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Closenness centrality measures the centrality of the vertices based on distances, allowing to find wellconnected vertices
The Closeness Centrality of a node V is the reciprocal of the sum of all the distances from the possible shortests paths starting from V. Thus the higher the centrality value of V, the closer it is to all the other vertices in the graph. This implementation is meant for undirected graphs.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortests paths. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
VertexProperty<Integer, Double> closeness = analyst.closenessCentralityUnitLength(graph);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + closeness.getName() + " MATCH (x) ORDER BY x." + closeness.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> VertexProperty<ID,java.lang.Double> closenessCentralityUnitLength(PgxGraph graph, VertexProperty<ID,java.lang.Double> cc) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Closenness centrality measures the centrality of the vertices based on distances, allowing to find wellconnected vertices
The Closeness Centrality of a node V is the reciprocal of the sum of all the distances from the possible shortests paths starting from V. Thus the higher the centrality value of V, the closer it is to all the other vertices in the graph. This implementation is meant for undirected graphs.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortests paths. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.cc
 (out argument)
node property holding the closeness centrality value for each node.
PgxGraph graph = ...;
VertexProperty<Integer, Double> cc = graph.createVertexProperty(PropertyType.DOUBLE);
VertexProperty<Integer, Double> closeness = analyst.closenessCentralityUnitLength(graph, cc);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + closeness.getName() + " MATCH (x) ORDER BY x." + closeness.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> closenessCentralityUnitLengthAsync(PgxGraph graph)
Closenness centrality measures the centrality of the vertices based on distances, allowing to find wellconnected vertices
The Closeness Centrality of a node V is the reciprocal of the sum of all the distances from the possible shortests paths starting from V. Thus the higher the centrality value of V, the closer it is to all the other vertices in the graph. This implementation is meant for undirected graphs.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortests paths. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.closenessCentralityUnitLengthAsync(graph);
promise.thenCompose(closeness > graph.queryPgqlAsync(
"SELECT x, x." + closeness.getName() + " MATCH (x) ORDER BY x." + closeness.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> closenessCentralityUnitLengthAsync(PgxGraph graph, VertexProperty<ID,java.lang.Double> cc)
Closenness centrality measures the centrality of the vertices based on distances, allowing to find wellconnected vertices
The Closeness Centrality of a node V is the reciprocal of the sum of all the distances from the possible shortests paths starting from V. Thus the higher the centrality value of V, the closer it is to all the other vertices in the graph. This implementation is meant for undirected graphs.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortests paths. It is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.cc
 (out argument)
node property holding the closeness centrality value for each node.
PgxGraph graph = ...;
VertexProperty<Integer, Double> cc = graph.createVertexProperty(PropertyType.DOUBLE);
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.closenessCentralityUnitLengthAsync(graph, cc);
promise.thenCompose(closeness > graph.queryPgqlAsync(
"SELECT x, x." + closeness.getName() + " MATCH (x) ORDER BY x." + closeness.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> Partition<ID> communitiesConductanceMinimization(PgxGraph graph) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Soman and Narang can find communities in a graph taking weighted edges into account
The algorithm proposed by Soman and Narang to find community structures in a graph can be regarded as a variant of the label propagation algorithm, since it takes into account weights over the edges when looking for the community assignments. This implementation generates the weight of the edges by using the triangles in the graph, and just like label propagation, it assigns a unique community label to each vertex in the graph at the beginning, which is then updated on each iteration by looking and choosing the most frequent label from the labels of their neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. Also note that there is a possibility of constant vertex swapping. For example, if you have two vertices A and B in your graph. It can happen that A will acquire the community of B but at the same time B will acquire the community of A. That is why you should set a maximum number of iterations.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(5 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the graph.
PgxGraph graph = ...;
Partition<Integer> conductance = analyst.communitiesConductanceMinimization(graph);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Partition<ID> communitiesConductanceMinimization(PgxGraph graph, int maxIterations) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Soman and Narang can find communities in a graph taking weighted edges into account
The algorithm proposed by Soman and Narang to find community structures in a graph can be regarded as a variant of the label propagation algorithm, since it takes into account weights over the edges when looking for the community assignments. This implementation generates the weight of the edges by using the triangles in the graph, and just like label propagation, it assigns a unique community label to each vertex in the graph at the beginning, which is then updated on each iteration by looking and choosing the most frequent label from the labels of their neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. Also note that there is a possibility of constant vertex swapping. For example, if you have two vertices A and B in your graph. It can happen that A will acquire the community of B but at the same time B will acquire the community of A. That is why you should set a maximum number of iterations.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(5 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the graph.maxIterations
 maximum number of iterations that will be performed. For most graphs, a maximum of 100 iterations should be enough.
PgxGraph graph = ...;
Partition<Integer> conductance = analyst.communitiesConductanceMinimization(graph, 100);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Partition<ID> communitiesConductanceMinimization(PgxGraph graph, int maxIterations, VertexProperty<ID,java.lang.Long> partitionDistribution) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Soman and Narang can find communities in a graph taking weighted edges into account
The algorithm proposed by Soman and Narang to find community structures in a graph can be regarded as a variant of the label propagation algorithm, since it takes into account weights over the edges when looking for the community assignments. This implementation generates the weight of the edges by using the triangles in the graph, and just like label propagation, it assigns a unique community label to each vertex in the graph at the beginning, which is then updated on each iteration by looking and choosing the most frequent label from the labels of their neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. Also note that there is a possibility of constant vertex swapping. For example, if you have two vertices A and B in your graph. It can happen that A will acquire the community of B but at the same time B will acquire the community of A. That is why you should set a maximum number of iterations.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(5 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the graph.maxIterations
 maximum number of iterations that will be performed. For most graphs, a maximum of 100 iterations should be enough.partitionDistribution
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Long> pd = graph.createVertexProperty(PropertyType.LONG);
Partition<Integer> conductance = analyst.communitiesConductanceMinimization(graph, 100, pd);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Partition<ID> communitiesConductanceMinimization(PgxGraph graph, VertexProperty<ID,java.lang.Long> partitionDistribution) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Soman and Narang can find communities in a graph taking weighted edges into account
The algorithm proposed by Soman and Narang to find community structures in a graph can be regarded as a variant of the label propagation algorithm, since it takes into account weights over the edges when looking for the community assignments. This implementation generates the weight of the edges by using the triangles in the graph, and just like label propagation, it assigns a unique community label to each vertex in the graph at the beginning, which is then updated on each iteration by looking and choosing the most frequent label from the labels of their neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. Also note that there is a possibility of constant vertex swapping. For example, if you have two vertices A and B in your graph. It can happen that A will acquire the community of B but at the same time B will acquire the community of A. That is why you should set a maximum number of iterations.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(5 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the graph.partitionDistribution
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Long> pd = graph.createVertexProperty(PropertyType.LONG);
Partition<Integer> conductance = analyst.communitiesConductanceMinimization(graph, pd);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<Partition<ID>> communitiesConductanceMinimizationAsync(PgxGraph graph)
Soman and Narang can find communities in a graph taking weighted edges into account
The algorithm proposed by Soman and Narang to find community structures in a graph can be regarded as a variant of the label propagation algorithm, since it takes into account weights over the edges when looking for the community assignments. This implementation generates the weight of the edges by using the triangles in the graph, and just like label propagation, it assigns a unique community label to each vertex in the graph at the beginning, which is then updated on each iteration by looking and choosing the most frequent label from the labels of their neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. Also note that there is a possibility of constant vertex swapping. For example, if you have two vertices A and B in your graph. It can happen that A will acquire the community of B but at the same time B will acquire the community of A. That is why you should set a maximum number of iterations.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(5 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the graph.
PgxGraph graph = ...;
PgxFuture<Partition<Integer>> promise = analyst.communitiesConductanceMinimizationAsync(graph);
promise.thenCompose(conductance > graph.queryPgqlAsync(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Partition<ID>> communitiesConductanceMinimizationAsync(PgxGraph graph, int max)
Soman and Narang can find communities in a graph taking weighted edges into account
The algorithm proposed by Soman and Narang to find community structures in a graph can be regarded as a variant of the label propagation algorithm, since it takes into account weights over the edges when looking for the community assignments. This implementation generates the weight of the edges by using the triangles in the graph, and just like label propagation, it assigns a unique community label to each vertex in the graph at the beginning, which is then updated on each iteration by looking and choosing the most frequent label from the labels of their neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. Also note that there is a possibility of constant vertex swapping. For example, if you have two vertices A and B in your graph. It can happen that A will acquire the community of B but at the same time B will acquire the community of A. That is why you should set a maximum number of iterations.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(5 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the graph.max
 maximum number of iterations that will be performed. For most graphs, a maximum of 100 iterations should be enough.
PgxGraph graph = ...;
PgxFuture<Partition<Integer>> promise = analyst.communitiesConductanceMinimizationAsync(graph, 100);
promise.thenCompose(conductance > graph.queryPgqlAsync(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Partition<ID>> communitiesConductanceMinimizationAsync(PgxGraph graph, int maxIterations, VertexProperty<ID,java.lang.Long> partitionDistribution)
Soman and Narang can find communities in a graph taking weighted edges into account
The algorithm proposed by Soman and Narang to find community structures in a graph can be regarded as a variant of the label propagation algorithm, since it takes into account weights over the edges when looking for the community assignments. This implementation generates the weight of the edges by using the triangles in the graph, and just like label propagation, it assigns a unique community label to each vertex in the graph at the beginning, which is then updated on each iteration by looking and choosing the most frequent label from the labels of their neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. Also note that there is a possibility of constant vertex swapping. For example, if you have two vertices A and B in your graph. It can happen that A will acquire the community of B but at the same time B will acquire the community of A. That is why you should set a maximum number of iterations.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(5 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the graph.maxIterations
 maximum number of iterations that will be performed. For most graphs, a maximum of 100 iterations should be enough.partitionDistribution
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Long> pd = graph.createVertexProperty(PropertyType.LONG);
PgxFuture<Partition<Integer>> promise = analyst.communitiesConductanceMinimizationAsync(graph, 100, pd);
promise.thenCompose(conductance > graph.queryPgqlAsync(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Partition<ID>> communitiesConductanceMinimizationAsync(PgxGraph graph, VertexProperty<ID,java.lang.Long> partitionDistribution)
Soman and Narang can find communities in a graph taking weighted edges into account
The algorithm proposed by Soman and Narang to find community structures in a graph can be regarded as a variant of the label propagation algorithm, since it takes into account weights over the edges when looking for the community assignments. This implementation generates the weight of the edges by using the triangles in the graph, and just like label propagation, it assigns a unique community label to each vertex in the graph at the beginning, which is then updated on each iteration by looking and choosing the most frequent label from the labels of their neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. Also note that there is a possibility of constant vertex swapping. For example, if you have two vertices A and B in your graph. It can happen that A will acquire the community of B but at the same time B will acquire the community of A. That is why you should set a maximum number of iterations.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(5 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the graph.partitionDistribution
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Long> pd = graph.createVertexProperty(PropertyType.LONG);
PgxFuture<Partition<Integer>> promise = analyst.communitiesConductanceMinimizationAsync(graph, pd);
promise.thenCompose(conductance > graph.queryPgqlAsync(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> Partition<ID> communitiesInfomap(PgxGraph graph, VertexProperty<ID,java.lang.Double> rank, EdgeProperty<java.lang.Double> weight) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Infomap can find high quality communities in a graph.
Infomap is a robust algorithm designed to find community structures in a graph that requires some preprocessing steps. This implementation needs a reciprocated or an undirected graph, as well as the ranking score from the normalized weighted version of the Pagerank algorithm. It will assign a unique module (or community) label to each vertex in the graph based on their Pagerank score, edge weights and the labels of their neighbors. It is an iterative algorithm that updates the labels of the vertices in random order on each iteration using the previous factors, converging once there are no further changes in the vertex labels, or once the maximum number of iterations is reached. The algorithm is nondeterministic because of the random order for visiting and updating the vertex labels, thus the communities found might be different each time the algorithm is run.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. It is an expensive algorithm to run on large graphs.
O((k ^ 2) * E) with E = number of edges, k <= maximum number of iterations
O(10 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the undirected graph.rank
 vertex property holding the normalized (weighted) PageRank value for each vertex (a value between 0 and 1).weight
 edge property holding the weight of each edge in the graph.
PgxGraph graph = ...;
EdgeProperty<Double> weight = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> rank = analyst.weightedPagerank(graph, 1e16, 0.85, 1000, true, weight);
VertexProperty<Integer, Long> module = graph.createVertexProperty(PropertyType.LONG);
Partition<Integer> promise = analyst.communitiesInfomap(graph, rank, weight);
first_component = promise.getPartitionByIndex(0)
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Partition<ID> communitiesInfomap(PgxGraph graph, VertexProperty<ID,java.lang.Double> rank, EdgeProperty<java.lang.Double> weight, double tau, double tol, int maxIter) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Infomap can find high quality communities in a graph.
Infomap is a robust algorithm designed to find community structures in a graph that requires some preprocessing steps. This implementation needs a reciprocated or an undirected graph, as well as the ranking score from the normalized weighted version of the Pagerank algorithm. It will assign a unique module (or community) label to each vertex in the graph based on their Pagerank score, edge weights and the labels of their neighbors. It is an iterative algorithm that updates the labels of the vertices in random order on each iteration using the previous factors, converging once there are no further changes in the vertex labels, or once the maximum number of iterations is reached. The algorithm is nondeterministic because of the random order for visiting and updating the vertex labels, thus the communities found might be different each time the algorithm is run.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. It is an expensive algorithm to run on large graphs.
O((k ^ 2) * E) with E = number of edges, k <= maximum number of iterations
O(10 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the undirected graph.rank
 vertex property holding the normalized (weighted) PageRank value for each vertex (a value between 0 and 1).weight
 edge property holding the weight of each edge in the graph.tau
 damping factor.tol
 maximum tolerated error value. The algorithm will stop once the sum of the error values of all vertices becomes smaller than this value.maxIter
 maximum number of iterations that will be performed.
PgxGraph graph = ...;
EdgeProperty<Double> weight = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> rank = analyst.weightedPagerank(graph, 1e16, 0.85, 1000, true, weight);
VertexProperty<Integer, Long> module = graph.createVertexProperty(PropertyType.LONG);
Partition<Integer> promise = analyst.communitiesInfomap(graph, rank, weight, 0.15, 0.0001, 10);
first_component = promise.getPartitionByIndex(0)
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Partition<ID> communitiesInfomap(PgxGraph graph, VertexProperty<ID,java.lang.Double> rank, EdgeProperty<java.lang.Double> weight, double tau, double tol, int maxIter, VertexProperty<ID,java.lang.Long> module) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Infomap can find high quality communities in a graph.
Infomap is a robust algorithm designed to find community structures in a graph that requires some preprocessing steps. This implementation needs a reciprocated or an undirected graph, as well as the ranking score from the normalized weighted version of the Pagerank algorithm. It will assign a unique module (or community) label to each vertex in the graph based on their Pagerank score, edge weights and the labels of their neighbors. It is an iterative algorithm that updates the labels of the vertices in random order on each iteration using the previous factors, converging once there are no further changes in the vertex labels, or once the maximum number of iterations is reached. The algorithm is nondeterministic because of the random order for visiting and updating the vertex labels, thus the communities found might be different each time the algorithm is run.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. It is an expensive algorithm to run on large graphs.
O((k ^ 2) * E) with E = number of edges, k <= maximum number of iterations
O(10 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the undirected graph.rank
 vertex property holding the normalized (weighted) PageRank value for each vertex (a value between 0 and 1).weight
 edge property holding the weight of each edge in the graph.tau
 damping factor.tol
 maximum tolerated error value. The algorithm will stop once the sum of the error values of all vertices becomes smaller than this value.maxIter
 maximum number of iterations that will be performed.module
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
EdgeProperty<Double> weight = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> rank = analyst.weightedPagerank(graph, 1e16, 0.85, 1000, true, weight);
VertexProperty<Integer, Long> module = graph.createVertexProperty(PropertyType.LONG);
Partition<Integer> promise = analyst.communitiesInfomap(graph, rank, weight, 0.15, 0.0001, 10, module);
first_component = promise.getPartitionByIndex(0)
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Partition<ID> communitiesInfomap(PgxGraph graph, VertexProperty<ID,java.lang.Double> rank, EdgeProperty<java.lang.Double> weight, VertexProperty<ID,java.lang.Long> module) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Infomap can find high quality communities in a graph.
Infomap is a robust algorithm designed to find community structures in a graph that requires some preprocessing steps. This implementation needs a reciprocated or an undirected graph, as well as the ranking score from the normalized weighted version of the Pagerank algorithm. It will assign a unique module (or community) label to each vertex in the graph based on their Pagerank score, edge weights and the labels of their neighbors. It is an iterative algorithm that updates the labels of the vertices in random order on each iteration using the previous factors, converging once there are no further changes in the vertex labels, or once the maximum number of iterations is reached. The algorithm is nondeterministic because of the random order for visiting and updating the vertex labels, thus the communities found might be different each time the algorithm is run.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. It is an expensive algorithm to run on large graphs.
O((k ^ 2) * E) with E = number of edges, k <= maximum number of iterations
O(10 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the undirected graph.rank
 vertex property holding the normalized (weighted) PageRank value for each vertex (a value between 0 and 1).weight
 edge property holding the weight of each edge in the graph.module
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
EdgeProperty<Double> weight = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> rank = analyst.weightedPagerank(graph, 1e16, 0.85, 1000, true, weight);
VertexProperty<Integer, Long> module = graph.createVertexProperty(PropertyType.LONG);
Partition<Integer> promise = analyst.communitiesInfomap(graph, rank, weight, module);
first_component = promise.getPartitionByIndex(0)
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<Partition<ID>> communitiesInfomapAsync(PgxGraph graph, VertexProperty<ID,java.lang.Double> rank, EdgeProperty<java.lang.Double> weight)
Infomap can find high quality communities in a graph.
Infomap is a robust algorithm designed to find community structures in a graph that requires some preprocessing steps. This implementation needs a reciprocated or an undirected graph, as well as the ranking score from the normalized weighted version of the Pagerank algorithm. It will assign a unique module (or community) label to each vertex in the graph based on their Pagerank score, edge weights and the labels of their neighbors. It is an iterative algorithm that updates the labels of the vertices in random order on each iteration using the previous factors, converging once there are no further changes in the vertex labels, or once the maximum number of iterations is reached. The algorithm is nondeterministic because of the random order for visiting and updating the vertex labels, thus the communities found might be different each time the algorithm is run.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. It is an expensive algorithm to run on large graphs.
O((k ^ 2) * E) with E = number of edges, k <= maximum number of iterations
O(10 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the undirected graph.rank
 vertex property holding the normalized (weighted) PageRank value for each vertex (a value between 0 and 1).weight
 edge property holding the weight of each edge in the graph.
PgxGraph graph = ...;
EdgeProperty<Double> weight = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> rank = analyst.weightedPagerank(graph, 1e16, 0.85, 1000, true, weight);
VertexProperty<Integer, Long> module = graph.createVertexProperty(PropertyType.LONG);
PgxFuture<Partition<Integer>> promise = analyst.communitiesInfomapAsync(graph, rank, weight);
partition = promise.get()
first_component = partition.getPartitionByIndex(0)
public <ID> PgxFuture<Partition<ID>> communitiesInfomapAsync(PgxGraph graph, VertexProperty<ID,java.lang.Double> rank, EdgeProperty<java.lang.Double> weight, double tau, double tol, int maxIter)
Infomap can find high quality communities in a graph.
Infomap is a robust algorithm designed to find community structures in a graph that requires some preprocessing steps. This implementation needs a reciprocated or an undirected graph, as well as the ranking score from the normalized weighted version of the Pagerank algorithm. It will assign a unique module (or community) label to each vertex in the graph based on their Pagerank score, edge weights and the labels of their neighbors. It is an iterative algorithm that updates the labels of the vertices in random order on each iteration using the previous factors, converging once there are no further changes in the vertex labels, or once the maximum number of iterations is reached. The algorithm is nondeterministic because of the random order for visiting and updating the vertex labels, thus the communities found might be different each time the algorithm is run.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. It is an expensive algorithm to run on large graphs.
O((k ^ 2) * E) with E = number of edges, k <= maximum number of iterations
O(10 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the undirected graph.rank
 vertex property holding the normalized (weighted) PageRank value for each vertex (a value between 0 and 1).weight
 edge property holding the weight of each edge in the graph.tau
 damping factor.tol
 maximum tolerated error value. The algorithm will stop once the sum of the error values of all vertices becomes smaller than this value.maxIter
 maximum number of iterations that will be performed.
PgxGraph graph = ...;
EdgeProperty<Double> weight = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> rank = analyst.weightedPagerank(graph, 1e16, 0.85, 1000, true, weight);
VertexProperty<Integer, Long> module = graph.createVertexProperty(PropertyType.LONG);
PgxFuture<Partition<Integer>> promise = analyst.communitiesInfomapAsync(graph, rank, weight, 0.15, 0.0001, 10);
partition = promise.get()
first_component = partition.getPartitionByIndex(0)
public <ID> PgxFuture<Partition<ID>> communitiesInfomapAsync(PgxGraph graph, VertexProperty<ID,java.lang.Double> rank, EdgeProperty<java.lang.Double> weight, double tau, double tol, int maxIter, VertexProperty<ID,java.lang.Long> module)
Infomap can find high quality communities in a graph.
Infomap is a robust algorithm designed to find community structures in a graph that requires some preprocessing steps. This implementation needs a reciprocated or an undirected graph, as well as the ranking score from the normalized weighted version of the Pagerank algorithm. It will assign a unique module (or community) label to each vertex in the graph based on their Pagerank score, edge weights and the labels of their neighbors. It is an iterative algorithm that updates the labels of the vertices in random order on each iteration using the previous factors, converging once there are no further changes in the vertex labels, or once the maximum number of iterations is reached. The algorithm is nondeterministic because of the random order for visiting and updating the vertex labels, thus the communities found might be different each time the algorithm is run.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. It is an expensive algorithm to run on large graphs.
O((k ^ 2) * E) with E = number of edges, k <= maximum number of iterations
O(10 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the undirected graph.rank
 vertex property holding the normalized (weighted) PageRank value for each vertex (a value between 0 and 1).weight
 edge property holding the weight of each edge in the graph.tau
 damping factor.tol
 maximum tolerated error value. The algorithm will stop once the sum of the error values of all vertices becomes smaller than this value.maxIter
 maximum number of iterations that will be performed.module
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
EdgeProperty<Double> weight = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> rank = analyst.weightedPagerank(graph, 1e16, 0.85, 1000, true, weight);
VertexProperty<Integer, Long> module = graph.createVertexProperty(PropertyType.LONG);
PgxFuture<Partition<Integer>> promise = analyst.communitiesInfomapAsync(graph, rank, weight, 0.15, 0.0001,
10, module);
partition = promise.get()
first_component = partition.getPartitionByIndex(0)
public <ID> PgxFuture<Partition<ID>> communitiesInfomapAsync(PgxGraph graph, VertexProperty<ID,java.lang.Double> rank, EdgeProperty<java.lang.Double> weight, VertexProperty<ID,java.lang.Long> module)
Infomap can find high quality communities in a graph.
Infomap is a robust algorithm designed to find community structures in a graph that requires some preprocessing steps. This implementation needs a reciprocated or an undirected graph, as well as the ranking score from the normalized weighted version of the Pagerank algorithm. It will assign a unique module (or community) label to each vertex in the graph based on their Pagerank score, edge weights and the labels of their neighbors. It is an iterative algorithm that updates the labels of the vertices in random order on each iteration using the previous factors, converging once there are no further changes in the vertex labels, or once the maximum number of iterations is reached. The algorithm is nondeterministic because of the random order for visiting and updating the vertex labels, thus the communities found might be different each time the algorithm is run.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic. It is an expensive algorithm to run on large graphs.
O((k ^ 2) * E) with E = number of edges, k <= maximum number of iterations
O(10 * V + 2 * E) with V = number of vertices, E = number of edges
graph
 the undirected graph.rank
 vertex property holding the normalized (weighted) PageRank value for each vertex (a value between 0 and 1).weight
 edge property holding the weight of each edge in the graph.module
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
EdgeProperty<Double> weight = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> rank = analyst.weightedPagerank(graph, 1e16, 0.85, 1000, true, weight);
VertexProperty<Integer, Long> module = graph.createVertexProperty(PropertyType.LONG);
PgxFuture<Partition<Integer>> promise = analyst.communitiesInfomapAsync(graph, rank, weight, module);
partition = promise.get()
first_component = partition.getPartitionByIndex(0)
public <ID> Partition<ID> communitiesLabelPropagation(PgxGraph graph) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Label propagation can find communities in a graph relatively fast
Label Propagation is an algorithm designed to find community structures in a graph. It assigns a unique community label to each vertex in the graph, which then is updated on each iteration by looking and choosing the most frequent label amongst those from its neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
Partition<Integer> conductance = analyst.communitiesLabelPropagation(graph);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Partition<ID> communitiesLabelPropagation(PgxGraph graph, int maxIterations) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Label propagation can find communities in a graph relatively fast
Label Propagation is an algorithm designed to find community structures in a graph. It assigns a unique community label to each vertex in the graph, which then is updated on each iteration by looking and choosing the most frequent label amongst those from its neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.maxIterations
 maximum number of iterations that will be performed.
PgxGraph graph = ...;
Partition<Integer> conductance = analyst.communitiesLabelPropagation(graph, 100);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Partition<ID> communitiesLabelPropagation(PgxGraph graph, int maxIterations, VertexProperty<ID,java.lang.Long> partitionDistribution) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Label propagation can find communities in a graph relatively fast
Label Propagation is an algorithm designed to find community structures in a graph. It assigns a unique community label to each vertex in the graph, which then is updated on each iteration by looking and choosing the most frequent label amongst those from its neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.maxIterations
 maximum number of iterations that will be performed.partitionDistribution
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Long> pd = graph.createVertexProperty(PropertyType.LONG);
Partition<Integer> conductance = analyst.communitiesLabelPropagation(graph, 100, pd);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Partition<ID> communitiesLabelPropagation(PgxGraph graph, VertexProperty<ID,java.lang.Long> partitonDistribution) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Label propagation can find communities in a graph relatively fast
Label Propagation is an algorithm designed to find community structures in a graph. It assigns a unique community label to each vertex in the graph, which then is updated on each iteration by looking and choosing the most frequent label amongst those from its neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.partitonDistribution
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Long> pd = graph.createVertexProperty(PropertyType.LONG);
Partition<Integer> conductance = analyst.communitiesLabelPropagation(graph, pd);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<Partition<ID>> communitiesLabelPropagationAsync(PgxGraph graph)
Label propagation can find communities in a graph relatively fast
Label Propagation is an algorithm designed to find community structures in a graph. It assigns a unique community label to each vertex in the graph, which then is updated on each iteration by looking and choosing the most frequent label amongst those from its neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
PgxFuture<Partition<Integer>> promise = analyst.communitiesLabelPropagationAsync(graph);
promise.thenCompose(conductance > graph.queryPgqlAsync(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Partition<ID>> communitiesLabelPropagationAsync(PgxGraph graph, int maxIterations)
Label propagation can find communities in a graph relatively fast
Label Propagation is an algorithm designed to find community structures in a graph. It assigns a unique community label to each vertex in the graph, which then is updated on each iteration by looking and choosing the most frequent label amongst those from its neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.maxIterations
 maximum number of iterations that will be performed.
PgxGraph graph = ...;
PgxFuture<Partition<Integer>> promise = analyst.communitiesLabelPropagationAsync(graph, 100);
promise.thenCompose(conductance > graph.queryPgqlAsync(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Partition<ID>> communitiesLabelPropagationAsync(PgxGraph graph, int maxIterations, VertexProperty<ID,java.lang.Long> partitionDistribution)
Label propagation can find communities in a graph relatively fast
Label Propagation is an algorithm designed to find community structures in a graph. It assigns a unique community label to each vertex in the graph, which then is updated on each iteration by looking and choosing the most frequent label amongst those from its neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.maxIterations
 maximum number of iterations that will be performed.partitionDistribution
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Long> pd = graph.createVertexProperty(PropertyType.LONG);
PgxFuture<Partition<Integer>> promise = analyst.communitiesLabelPropagationAsync(graph, 100, pd);
promise.thenCompose(conductance > graph.queryPgqlAsync(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Partition<ID>> communitiesLabelPropagationAsync(PgxGraph graph, VertexProperty<ID,java.lang.Long> partitionDistribution)
Label propagation can find communities in a graph relatively fast
Label Propagation is an algorithm designed to find community structures in a graph. It assigns a unique community label to each vertex in the graph, which then is updated on each iteration by looking and choosing the most frequent label amongst those from its neighbors. Convergence is achieved once the label of each vertex is the same as the most frequent one amongst its neighbors, i.e. when there are no changes in the communities assigned to the vertices in one iteration.
The implementation of this algorithm uses an iterative method. Since the algorithm visits the vertices in a random order on each iteration it is nondeterministic.
O(E * k) with E = number of edges, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.partitionDistribution
 vertex property holding the label of the community assigned to each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Long> pd = graph.createVertexProperty(PropertyType.LONG);
PgxFuture<Partition<Integer>> promise = analyst.communitiesLabelPropagationAsync(graph, pd);
promise.thenCompose(conductance > graph.queryPgqlAsync(
"SELECT x, x." + conductance.getPropertyName() + " MATCH (x) ORDER BY x." + conductance.getPropertyName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> Pair<PgxMap<java.lang.Integer,PgxVertex<ID>>,VertexSet<ID>> computeHighDegreeVertices(PgxGraph graph, int k) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Computes the k vertices with the highest degrees in the graph.
Computes the k vertices with the highest degrees in the graph. The resulting map will contain a mapping with the sorted index to the highdegree vertex with the index.
null
O(N log N) with N = number of vertices
O(k) with V = number of vertices
graph
 the graph.k
 number of highdegree vertices to be computed.k
highdegree vertices and their indices and a second
vertex set containing the same vertices.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<PgxMap<java.lang.Integer,PgxVertex<ID>>,VertexSet<ID>> computeHighDegreeVertices(PgxGraph graph, int k, PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping, VertexSet<ID> highDegreeVertices) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Computes the k vertices with the highest degrees in the graph.
Computes the k vertices with the highest degrees in the graph. The resulting map will contain a mapping with the sorted index to the highdegree vertex with the index.
null
O(N log N) with N = number of vertices
O(k) with V = number of vertices
graph
 the graph.k
 number of highdegree vertices to be computed.highDegreeVertexMapping
 (out argument)
the highdegree vertices.highDegreeVertices
 (out argument)
the highdegree vertices.k
highdegree vertices and their indices and a
second vertex set containing the same vertices.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<Pair<PgxMap<java.lang.Integer,PgxVertex<ID>>,VertexSet<ID>>> computeHighDegreeVerticesAsync(PgxGraph graph, int k)
Computes the k vertices with the highest degrees in the graph.
Computes the k vertices with the highest degrees in the graph. The resulting map will contain a mapping with the sorted index to the highdegree vertex with the index.
null
O(N log N) with N = number of vertices
O(k) with V = number of vertices
graph
 the graph.k
 number of highdegree vertices to be computed.k
highdegree vertices and their indices and a second
vertex set containing the same vertices.public <ID> PgxFuture<Pair<PgxMap<java.lang.Integer,PgxVertex<ID>>,VertexSet<ID>>> computeHighDegreeVerticesAsync(PgxGraph graph, int k, PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping, VertexSet<ID> highDegreeVertices)
Computes the k vertices with the highest degrees in the graph.
Computes the k vertices with the highest degrees in the graph. The resulting map will contain a mapping with the sorted index to the highdegree vertex with the index.
null
O(N log N) with N = number of vertices
O(k) with V = number of vertices
graph
 the graph.k
 number of highdegree vertices to be computed.highDegreeVertexMapping
 (outargument)
the highdegree vertices.highDegreeVertices
 (outargument)
the highdegree vertices.k
highdegree vertices and their indices and a second
vertex set containing the same vertices.public <ID> Scalar<java.lang.Double> conductance(PgxGraph graph, Partition<ID> partition, long partitionIndex) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Conductance assesses the quality of a partition in a graph
Conductance in a graph is computed for a specific cut of it. A cut is a partition of the graph into two subsets (components), disconnecting the graph if the edges from the cut are removed. Thus the algorithm requires a labeling for the vertices in the different subsets of the graph, then the conductance is computed by the ratio of the edges belonging to the given cut (i.e. the edges that split the graph into disconnected components) and the edges belonging to each of these subsets. If there is more than one cut (or partition), this implementation will take the given component number as reference to compute the conductance associated with that particular cut.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(V) with V = number of vertices
O(1)
graph
 the graph.partition
 Partition of the graph with the corresponding node collections.partitionIndex
 number of the component to be used for computing its conductance.
PgxGraph graph = ...;
Partition<Integer> partition = analyst.communitiesConductanceMinimization(graph);
Scalar<Double> conductance = analyst.conductance(graph, partition, 0);
conductance.get();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Scalar<java.lang.Double> conductance(PgxGraph graph, Partition<ID> partition, long partitionIndex, Scalar<java.lang.Double> conductance) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Conductance assesses the quality of a partition in a graph
Conductance in a graph is computed for a specific cut of it. A cut is a partition of the graph into two subsets (components), disconnecting the graph if the edges from the cut are removed. Thus the algorithm requires a labeling for the vertices in the different subsets of the graph, then the conductance is computed by the ratio of the edges belonging to the given cut (i.e. the edges that split the graph into disconnected components) and the edges belonging to each of these subsets. If there is more than one cut (or partition), this implementation will take the given component number as reference to compute the conductance associated with that particular cut.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(V) with V = number of vertices
O(1)
graph
 the graph.partition
 Partition of the graph with the corresponding node collections.partitionIndex
 number of the component to be used for computing its conductance.conductance
 Scalar (double) to store the conductance value of the given cut.
PgxGraph graph = ...;
Partition<Integer> partition = analyst.communitiesConductanceMinimization(graph);
Scalar<Double> scalar = graph.createScalar(PropertyType.DOUBLE);
Scalar<Double> conductance = analyst.conductance(graph, partition, 0, scalar);
conductance.get();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<Scalar<java.lang.Double>> conductanceAsync(PgxGraph graph, Partition<ID> partition, long partitionIndex)
Conductance assesses the quality of a partition in a graph
Conductance in a graph is computed for a specific cut of it. A cut is a partition of the graph into two subsets (components), disconnecting the graph if the edges from the cut are removed. Thus the algorithm requires a labeling for the vertices in the different subsets of the graph, then the conductance is computed by the ratio of the edges belonging to the given cut (i.e. the edges that split the graph into disconnected components) and the edges belonging to each of these subsets. If there is more than one cut (or partition), this implementation will take the given component number as reference to compute the conductance associated with that particular cut.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(V) with V = number of vertices
O(1)
graph
 the graph.partition
 Partition of the graph with the corresponding node collections.partitionIndex
 number of the component to be used for computing its conductance.
PgxGraph graph = ...;
Partition<Integer> partition = analyst.communitiesConductanceMinimization(graph);
PgxFuture<Scalar<Double>> promise = analyst.conductanceAsync(graph, partition, 0);
promise.thenAccept(conductance > {
conductance.get();
});
public <ID> PgxFuture<Scalar<java.lang.Double>> conductanceAsync(PgxGraph graph, Partition<ID> partition, long partitionIndex, Scalar<java.lang.Double> conductance)
Conductance assesses the quality of a partition in a graph
Conductance in a graph is computed for a specific cut of it. A cut is a partition of the graph into two subsets (components), disconnecting the graph if the edges from the cut are removed. Thus the algorithm requires a labeling for the vertices in the different subsets of the graph, then the conductance is computed by the ratio of the edges belonging to the given cut (i.e. the edges that split the graph into disconnected components) and the edges belonging to each of these subsets. If there is more than one cut (or partition), this implementation will take the given component number as reference to compute the conductance associated with that particular cut.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(V) with V = number of vertices
O(1)
graph
 the graph.partition
 Partition of the graph with the corresponding node collections.partitionIndex
 number of the component to be used for computing its conductance.conductance
 Scalar (double) to store the conductance value of the given cut.
PgxGraph graph = ...;
Scalar<Double> scalar = graph.createScalar(PropertyType.DOUBLE);
Partition<Integer> partition = analyst.communitiesConductanceMinimization(graph);
PgxFuture<Scalar<Double>> promise = analyst.conductanceAsync(graph, partition, 0, scalar);
promise.thenAccept(conductance > {
conductance.get();
});
public long countTriangles(PgxGraph graph, boolean sortVerticesByDegree) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
triangle counting gives an overview of the amount of connections between vertices in neighborhoods
This algorithm is intended for directed graphs and will count all the existing triangles on it. To run the algorithm on undirected graphs, use the undirected version.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(E ^ 1.5) with E = number of edges
O(V) with V = number of vertices
graph
 the graph.sortVerticesByDegree
 boolean flag for sorting the nodes by their degree as preprocessing step.
PgxGraph graph = ...;
long result = analyst.countTriangles(graph, true);
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public PgxFuture<java.lang.Long> countTrianglesAsync(PgxGraph graph, boolean sortVerticesByDegree)
triangle counting gives an overview of the amount of connections between vertices in neighborhoods
This algorithm is intended for directed graphs and will count all the existing triangles on it. To run the algorithm on undirected graphs, use the undirected version.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(E ^ 1.5) with E = number of edges
O(V) with V = number of vertices
graph
 the graph.sortVerticesByDegree
 boolean flag for sorting the nodes by their degree as preprocessing step.
PgxGraph graph = ...;
PgxFuture<Long> promise = analyst.countTrianglesAsync(graph, true);
promise.thenAccept(result > {
...;
});
public <ID> VertexProperty<ID,PgxVect<java.lang.Integer>> createDistanceIndex(PgxGraph graph, PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping, VertexSet<ID> highDegreeVertices) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Computes an index with distances to each highdegree vertex.
Computes an index which contains the distance to the given highdegree vertices for every node in the graph.
null
O(E * k) with E = number of edges, k <= number of highdegree vertices
O(V * k) with V = number of vertices
graph
 the graph.highDegreeVertexMapping
 map containing the highdegree vertices as values and indices from 0 to k as keys.highDegreeVertices
 a set containing the highdegree vertices.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> VertexProperty<ID,PgxVect<java.lang.Integer>> createDistanceIndex(PgxGraph graph, PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping, VertexSet<ID> highDegreeVertices, VertexProperty<ID,PgxVect<java.lang.Integer>> index) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Computes an index with distances to each highdegree vertex.
Computes an index which contains the distance to the given highdegree vertices for every node in the graph.
null
O(E * k) with E = number of edges, k <= number of highdegree vertices
O(V * k) with V = number of vertices
graph
 the graph.highDegreeVertexMapping
 map containing the highdegree vertices as values and indices from 0 to k as keys.highDegreeVertices
 a set containing the highdegree vertices.index
 (outargument)
the index containing the distances to each highdegree vertex for all vertices.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<VertexProperty<ID,PgxVect<java.lang.Integer>>> createDistanceIndexAsync(PgxGraph graph, PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping, VertexSet<ID> highDegreeVertices)
Computes an index with distances to each highdegree vertex.
Computes an index which contains the distance to the given highdegree vertices for every node in the graph.
null
O(E * k) with E = number of edges, k <= number of highdegree vertices
O(V * k) with V = number of vertices
graph
 the graph.highDegreeVertexMapping
 map containing the highdegree vertices as values and indices from 0 to k as keys.highDegreeVertices
 a set containing the highdegree vertices.public <ID> PgxFuture<VertexProperty<ID,PgxVect<java.lang.Integer>>> createDistanceIndexAsync(PgxGraph graph, PgxMap<java.lang.Integer,PgxVertex<ID>> highDegreeVertexMapping, VertexSet<ID> highDegreeVertices, VertexProperty<ID,PgxVect<java.lang.Integer>> index)
Computes an index with distances to each highdegree vertex.
Computes an index which contains the distance to the given highdegree vertices for every node in the graph.
null
O(E * k) with E = number of edges, k <= number of highdegree vertices
O(V * k) with V = number of vertices
graph
 the graph.highDegreeVertexMapping
 map containing the highdegree vertices as values and indices from 0 to k as keys.highDegreeVertices
 a set containing the highdegree vertices.index
 (outargument)
the index containing the distances to each highdegree vertex for all vertices.public DeepWalkModelBuilder deepWalkModelBuilder()
public <ID> VertexProperty<ID,java.lang.Integer> degreeCentrality(PgxGraph graph) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Degree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood
Degree centrality counts the number of outgoing and incoming edges for each vertex in the graph.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(V) with V = number of vertices
O(V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
VertexProperty<Integer, Integer> degree = analyst.degreeCentrality(graph);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + degree.getName() + " MATCH (x) ORDER BY x." + degree.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> VertexProperty<ID,java.lang.Integer> degreeCentrality(PgxGraph graph, VertexProperty<ID,java.lang.Integer> dc) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Degree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood
Degree centrality counts the number of outgoing and incoming edges for each vertex in the graph.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(V) with V = number of vertices
O(V) with V = number of vertices
graph
 the graph.dc
 (out argument)
vertex property holding the degree centrality value for each vertex in the graph.
PgxGraph graph = ...;
VertexProperty<Integer, Integer> dc = graph.createVertexProperty(PropertyType.INTEGER);
VertexProperty<Integer, Integer> degree = analyst.degreeCentrality(graph, dc);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + degree.getName() + " MATCH (x) ORDER BY x." + degree.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> degreeCentralityAsync(PgxGraph graph)
Degree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood
Degree centrality counts the number of outgoing and incoming edges for each vertex in the graph.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(V) with V = number of vertices
O(V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
PgxFuture<VertexProperty<Integer, Integer>> promise = analyst.degreeCentralityAsync(graph);
promise.thenCompose(degree > graph.queryPgqlAsync(
"SELECT x, x." + degree.getName() + " MATCH (x) ORDER BY x." + degree.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> degreeCentralityAsync(PgxGraph graph, java.lang.String propertyName)
public <ID> PgxFuture<VertexProperty<ID,java.lang.Integer>> degreeCentralityAsync(PgxGraph graph, VertexProperty<ID,java.lang.Integer> dc)
Degree centrality measures the centrality of the vertices based on its degree, letting you see how a vertex influences its neighborhood
Degree centrality counts the number of outgoing and incoming edges for each vertex in the graph.
This algorithm is designed to run in parallel given its high degree of parallelization.
O(V) with V = number of vertices
O(V) with V = number of vertices
graph
 the graph.dc
 (out argument)
vertex property holding the degree centrality value for each vertex in the graph.
PgxGraph graph = ...;
VertexProperty<Integer, Integer> dc = graph.createVertexProperty(PropertyType.INTEGER);
PgxFuture<VertexProperty<Integer, Integer>> promise = analyst.degreeCentralityAsync(graph, dc);
promise.thenCompose(degree > graph.queryPgqlAsync(
"SELECT x, x." + degree.getName() + " MATCH (x) ORDER BY x." + degree.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>> diameter(PgxGraph graph) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Diameter/radius gives an overview of the distances in a graph
The diameter of a graph is the maximal value of eccentricity of all the vertices in the graph, while the radius is the minimum graph eccentricity. The eccentricity of a vertex is the maximum distance via shortest paths to any other vertex in the graph. This algorithm will compute the eccentricity of all the vertices and will also return the diameter or radius value depending on the request. The algorithm will return an INF eccentricity and diameter/radius, for graphs with more than one strongly connected component.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortest paths. It still is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
Pair<Scalar<Integer>, VertexProperty<Integer, Integer>> diameter = analyst.diameter(graph);
diameter.getFirst().get();
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + diameter.getSecond().getName() + " MATCH (x) ORDER BY x." + diameter.getSecond().getName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>> diameter(PgxGraph graph, Scalar<java.lang.Integer> diameter, VertexProperty<ID,java.lang.Integer> eccentricity) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Diameter/radius gives an overview of the distances in a graph
The diameter of a graph is the maximal value of eccentricity of all the vertices in the graph, while the radius is the minimum graph eccentricity. The eccentricity of a vertex is the maximum distance via shortest paths to any other vertex in the graph. This algorithm will compute the eccentricity of all the vertices and will also return the diameter or radius value depending on the request. The algorithm will return an INF eccentricity and diameter/radius, for graphs with more than one strongly connected component.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortest paths. It still is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.diameter
 Scalar (integer) for holding the value of the diameter of the graph.eccentricity
 (out argument) vertex property holding the eccentricity value for each vertex.
PgxGraph graph = ...;
Scalar<Integer> scalar = graph.createScalar(PropertyType.INTEGER);
VertexProperty<Integer, Integer> prop = graph.CreateVertexProperty(PropertyType.INTEGER);
Pair<Scalar<Integer>, VertexProperty<Integer, Integer>> diameter = analyst.diameter(graph, scalar, prop);
diameter.getFirst().get();
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + diameter.getSecond().getName() + " MATCH (x) ORDER BY x." + diameter.getSecond().getName() +
" DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>>> diameterAsync(PgxGraph graph)
Diameter/radius gives an overview of the distances in a graph
The diameter of a graph is the maximal value of eccentricity of all the vertices in the graph, while the radius is the minimum graph eccentricity. The eccentricity of a vertex is the maximum distance via shortest paths to any other vertex in the graph. This algorithm will compute the eccentricity of all the vertices and will also return the diameter or radius value depending on the request. The algorithm will return an INF eccentricity and diameter/radius, for graphs with more than one strongly connected component.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortest paths. It still is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
PgxFuture<Pair<Scalar<Integer>, VertexProperty<Integer, Integer>>> promise = analyst.diameterAsync(graph);
promise.thenCompose(diameter > {
diameter.getFirst().get();
graph.queryPgqlAsync(
"SELECT x, x." + diameter.getSecond().getName() + " MATCH (x) ORDER BY x." + diameter.getSecond().getName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
});
public <ID> PgxFuture<Pair<Scalar<java.lang.Integer>,VertexProperty<ID,java.lang.Integer>>> diameterAsync(PgxGraph graph, Scalar<java.lang.Integer> diameter, VertexProperty<ID,java.lang.Integer> eccentricity)
Diameter/radius gives an overview of the distances in a graph
The diameter of a graph is the maximal value of eccentricity of all the vertices in the graph, while the radius is the minimum graph eccentricity. The eccentricity of a vertex is the maximum distance via shortest paths to any other vertex in the graph. This algorithm will compute the eccentricity of all the vertices and will also return the diameter or radius value depending on the request. The algorithm will return an INF eccentricity and diameter/radius, for graphs with more than one strongly connected component.
The implementation of this algorithm uses a parallel BFS method called MultiSource BFS (MSBSF) for a faster and more efficient search of the shortest paths. It still is an expensive algorithm to run on large graphs.
O(V * E) with V = number of vertices, E = number of edges
O(V) with V = number of vertices
graph
 the graph.diameter
 Scalar (integer) for holding the value of the diameter of the graph.eccentricity
 (out argument) vertex property holding the eccentricity value for each vertex.
PgxGraph graph = ...;
Scalar<Integer> scalar = graph.createScalar(PropertyType.INTEGER);
VertexProperty<Integer, Integer> prop = graph.createVertexProperty(PropertyType.INTEGER);
PgxFuture<Pair<Scalar<Integer>, VertexProperty<Integer, Integer>>> promise = analyst.diameterAsync(
graph, scalar, prop);
promise.thenCompose(diameter > {
diameter.getFirst().get();
graph.queryPgqlAsync(
"SELECT x, x." + diameter.getSecond().getName() + " MATCH (x) ORDER BY x." + diameter.getSecond().getName() +
" DESC"))
.thenAccept(PgqlResultSet::print);
});
public <ID> VertexProperty<ID,java.lang.Double> eigenvectorCentrality(PgxGraph graph) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices
The Eigenvector Centrality determines the centrality of a vertex by adding and weighting the centrality of its neighbors. Using outgoing or incoming edges when computing the eigenvector centrality will be equivalent to do so with the normal or the transpose adjacency matrix, respectively leading to the "right" and "left" eigenvectors.
The implementation of this algorithm uses the power iteration method.
O(V * k) with V = number of vertices, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
VertexProperty<Integer, Double> eigenvector = analyst.eigenvectorCentrality(graph);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + eigenvector.getName() + " MATCH (x) ORDER BY x." + eigenvector.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> VertexProperty<ID,java.lang.Double> eigenvectorCentrality(PgxGraph graph, int max, double maxDiff, boolean useL2Norm, boolean useInEdge) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices
The Eigenvector Centrality determines the centrality of a vertex by adding and weighting the centrality of its neighbors. Using outgoing or incoming edges when computing the eigenvector centrality will be equivalent to do so with the normal or the transpose adjacency matrix, respectively leading to the "right" and "left" eigenvectors.
The implementation of this algorithm uses the power iteration method.
O(V * k) with V = number of vertices, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.max
 maximum number of iterations that will be performed.maxDiff
 maximum tolerated error value. The algorithm will stop once the sum of the error values of all vertices becomes smaller than this value.useL2Norm
 boolean flag to determine whether the algorithm will use the l2 norm (Euclidean norm) or the l1 norm (absolute value) to normalize the centrality scores.useInEdge
 boolean flag to determine whether the algorithm will use the incoming or the outgoing edges in the graph for the computations.
PgxGraph graph = ...;
VertexProperty<Integer, Double> eigenvector = analyst.eigenvectorCentrality(graph, 100, 0.001, false, false);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + eigenvector.getName() + " MATCH (x) ORDER BY x." + eigenvector.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> VertexProperty<ID,java.lang.Double> eigenvectorCentrality(PgxGraph graph, int max, double maxDiff, boolean useL2Norm, boolean useInEdge, VertexProperty<ID,java.lang.Double> ec) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices
The Eigenvector Centrality determines the centrality of a vertex by adding and weighting the centrality of its neighbors. Using outgoing or incoming edges when computing the eigenvector centrality will be equivalent to do so with the normal or the transpose adjacency matrix, respectively leading to the "right" and "left" eigenvectors.
The implementation of this algorithm uses the power iteration method.
O(V * k) with V = number of vertices, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.max
 maximum number of iterations that will be performed.maxDiff
 maximum tolerated error value. The algorithm will stop once the sum of the error values of all vertices becomes smaller than this value.useL2Norm
 boolean flag to determine whether the algorithm will use the l2 norm (Euclidean norm) or the l1 norm (absolute value) to normalize the centrality scores.useInEdge
 boolean flag to determine whether the algorithm will use the incoming or the outgoing edges in the graph for the computations.ec
 (out argument)
vertex property holding the normalized centrality value for each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Double> ec = graph.createVertexProperty(PropertyType.DOUBLE);
VertexProperty<Integer, Double> eigenvector = analyst.eigenvectorCentrality(graph, 100, 0.001, false, false, ec);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + eigenvector.getName() + " MATCH (x) ORDER BY x." + eigenvector.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> VertexProperty<ID,java.lang.Double> eigenvectorCentrality(PgxGraph graph, VertexProperty<ID,java.lang.Double> ec) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices
The Eigenvector Centrality determines the centrality of a vertex by adding and weighting the centrality of its neighbors. Using outgoing or incoming edges when computing the eigenvector centrality will be equivalent to do so with the normal or the transpose adjacency matrix, respectively leading to the "right" and "left" eigenvectors.
The implementation of this algorithm uses the power iteration method.
O(V * k) with V = number of vertices, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.ec
 (out argument)
vertex property holding the normalized centrality value for each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Double> ec = graph.createVertexProperty(PropertyType.DOUBLE);
VertexProperty<Integer, Double> eigenvector = analyst.eigenvectorCentrality(graph, ec);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + eigenvector.getName() + " MATCH (x) ORDER BY x." + eigenvector.getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> eigenvectorCentralityAsync(PgxGraph graph)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices
The Eigenvector Centrality determines the centrality of a vertex by adding and weighting the centrality of its neighbors. Using outgoing or incoming edges when computing the eigenvector centrality will be equivalent to do so with the normal or the transpose adjacency matrix, respectively leading to the "right" and "left" eigenvectors.
The implementation of this algorithm uses the power iteration method.
O(V * k) with V = number of vertices, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.
PgxGraph graph = ...;
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.eigenvectorCentralityAsync(graph);
promise.thenCompose(eigenvector > graph.queryPgqlAsync(
"SELECT x, x." + eigenvector.getName() + " MATCH (x) ORDER BY x." + eigenvector.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> eigenvectorCentralityAsync(PgxGraph graph, int max, double maxDiff, boolean useL2Norm, boolean useInEdge)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices
The Eigenvector Centrality determines the centrality of a vertex by adding and weighting the centrality of its neighbors. Using outgoing or incoming edges when computing the eigenvector centrality will be equivalent to do so with the normal or the transpose adjacency matrix, respectively leading to the "right" and "left" eigenvectors.
The implementation of this algorithm uses the power iteration method.
O(V * k) with V = number of vertices, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.max
 maximum number of iterations that will be performed.maxDiff
 maximum tolerated error value. The algorithm will stop once the sum of the error values of all vertices becomes smaller than this value.useL2Norm
 boolean flag to determine whether the algorithm will use the l2 norm (Euclidean norm) or the l1 norm (absolute value) to normalize the centrality scores.useInEdge
 boolean flag to determine whether the algorithm will use the incoming or the outgoing edges in the graph for the computations.
PgxGraph graph = ...;
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.eigenvectorCentralityAsync(
graph, 100, 0.001, false, false);
promise.thenCompose(eigenvector > graph.queryPgqlAsync(
"SELECT x, x." + eigenvector.getName() + " MATCH (x) ORDER BY x." + eigenvector.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> eigenvectorCentralityAsync(PgxGraph graph, int max, double maxDiff, boolean useL2Norm, boolean useInEdge, VertexProperty<ID,java.lang.Double> ec)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices
The Eigenvector Centrality determines the centrality of a vertex by adding and weighting the centrality of its neighbors. Using outgoing or incoming edges when computing the eigenvector centrality will be equivalent to do so with the normal or the transpose adjacency matrix, respectively leading to the "right" and "left" eigenvectors.
The implementation of this algorithm uses the power iteration method.
O(V * k) with V = number of vertices, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.max
 maximum number of iterations that will be performed.maxDiff
 maximum tolerated error value. The algorithm will stop once the sum of the error values of all vertices becomes smaller than this value.useL2Norm
 boolean flag to determine whether the algorithm will use the l2 norm (Euclidean norm) or the l1 norm (absolute value) to normalize the centrality scores.useInEdge
 boolean flag to determine whether the algorithm will use the incoming or the outgoing edges in the graph for the computations.ec
 (out argument)
vertex property holding the normalized centrality value for each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Double> ec = graph.createVertexProperty(PropertyType.DOUBLE);
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.eigenvectorCentralityAsync(
graph, 100, 0.001, false, false, ec);
promise.thenCompose(eigenvector > graph.queryPgqlAsync(
"SELECT x, x." + eigenvector.getName() + " MATCH (x) ORDER BY x." + eigenvector.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<VertexProperty<ID,java.lang.Double>> eigenvectorCentralityAsync(PgxGraph graph, VertexProperty<ID,java.lang.Double> ec)
Eigenvector centrality gets the centrality of the vertices in an intrincated way using neighbors, allowing to find wellconnected vertices
The Eigenvector Centrality determines the centrality of a vertex by adding and weighting the centrality of its neighbors. Using outgoing or incoming edges when computing the eigenvector centrality will be equivalent to do so with the normal or the transpose adjacency matrix, respectively leading to the "right" and "left" eigenvectors.
The implementation of this algorithm uses the power iteration method.
O(V * k) with V = number of vertices, k <= maximum number of iterations
O(2 * V) with V = number of vertices
graph
 the graph.ec
 (out argument)
vertex property holding the normalized centrality value for each vertex.
PgxGraph graph = ...;
VertexProperty<Integer, Double> ec = graph.createVertexProperty(PropertyType.DOUBLE);
PgxFuture<VertexProperty<Integer, Double>> promise = analyst.eigenvectorCentralityAsync(graph, ec);
promise.thenCompose(eigenvector > graph.queryPgqlAsync(
"SELECT x, x." + eigenvector.getName() + " MATCH (x) ORDER BY x." + eigenvector.getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> org.apache.commons.lang3.tuple.Triple<ScalarSequence<java.lang.Integer>,VertexSequence<ID>,EdgeSequence> enumerateSimplePaths(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, int k, VertexSet verticesOnPath, EdgeSet edgesOnPath, PgxMap<PgxVertex<ID>,java.lang.Integer> dist) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Enumerate all simple paths between the source and destination vertex
Enumerate all simple paths between the source and destination vertex
null
O(E * k) with E = number of edges, k <= maximum number of iterations
O(V) with V = number of vertices
graph
 the graph.src
 the source vertex.dst
 the destination vertex.k
 the dimension of the distances property; i.e. number of highdegree vertices.verticesOnPath
 the vertices on the path.edgesOnPath
 the edges on the path.dist
 map containing the distance from the source vertex for each vertex on a path.Triple
containing a sequence containing the path lengths, a vertexsequence containing the
vertices on the paths and an edgesequence containing the edges on the pathsjava.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<org.apache.commons.lang3.tuple.Triple<ScalarSequence<java.lang.Integer>,VertexSequence<ID>,EdgeSequence>> enumerateSimplePathsAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, int k, VertexSet verticesOnPath, EdgeSet edgesOnPath, PgxMap<PgxVertex<ID>,java.lang.Integer> dist)
Enumerate all simple paths between the source and destination vertex
Enumerate all simple paths between the source and destination vertex
null
O(E * k) with E = number of edges, k <= maximum number of iterations
O(V) with V = number of vertices
graph
 the graph.src
 the source vertex.dst
 the destination vertex.k
 the dimension of the distances property; i.e. number of highdegree vertices.verticesOnPath
 the vertices on the path.edgesOnPath
 the edges on the path.dist
 map containing the distance from the source vertex for each vertex on a path.Triple
containing a sequence containing the path lengths, a vertexsequence containing the
vertices on the paths and an edgesequence containing the edges on the pathspublic <ID> AllPaths<ID> fattestPath(PgxGraph graph, ID rootId, EdgeProperty<java.lang.Double> capacity) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
fattestPath(PgxGraph, PgxVertex, EdgeProperty)
taking a vertex ID instead of a
PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> AllPaths<ID> fattestPath(PgxGraph graph, ID rootId, EdgeProperty<java.lang.Double> capacity, VertexProperty<ID,java.lang.Double> distance, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
fattestPath(PgxGraph, PgxVertex, EdgeProperty, VertexProperty,
VertexProperty, VertexProperty)
taking a vertex ID instead of a
PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> AllPaths<ID> fattestPath(PgxGraph graph, PgxVertex<ID> root, EdgeProperty<java.lang.Double> capacity) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Fattest path is a fast algorithm for finding a shortest path adding constraints for flowing related matters
The Fattest path algorithm can be regarded as a variant of Dijkstra's algorithm, it tries to find the fattest path between the given source and all the reachable vertices in the graph. The fatness of a path is equal to the minimum value of the capacity from the edges that take part in the path, thus a fattest path is conformed by the edges with the largest possible capacity.
This algorithm runs in a sequential way.
O(E + V log V) with V = number of vertices, E = number of edges
O(4 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.capacity
 edge property holding the capacity of each edge in the graph.
PgxGraph graph = ...;
PgxVertex<Integer> root = graph.getVertex(128);
EdgeProperty<Double> cost = graph.getEdgeProperty("cost");
AllPaths<Integer> fattestPath = analyst.fattestPath(graph, root, cost);
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> AllPaths<ID> fattestPath(PgxGraph graph, PgxVertex<ID> root, EdgeProperty<java.lang.Double> capacity, VertexProperty<ID,java.lang.Double> distance, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Fattest path is a fast algorithm for finding a shortest path adding constraints for flowing related matters
The Fattest path algorithm can be regarded as a variant of Dijkstra's algorithm, it tries to find the fattest path between the given source and all the reachable vertices in the graph. The fatness of a path is equal to the minimum value of the capacity from the edges that take part in the path, thus a fattest path is conformed by the edges with the largest possible capacity.
This algorithm runs in a sequential way.
O(E + V log V) with V = number of vertices, E = number of edges
O(4 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.capacity
 edge property holding the capacity of each edge in the graph.distance
 (out argument) vertex property holding the capacity value of the fattest path up to the current vertex. The fatness value for the source vertex will be INF, while it will be 0 for all the vertices that are not reachable from the source.parent
 (out argument) vertex property holding the parent vertex of the each vertex in the fattest path.parentEdge
 (out argument) vertex property holding the edge ID linking the current vertex in the path with the previous vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> root = graph.getVertex(128);
EdgeProperty<Double> cost = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> distance = graph.createVertexProperty(PropertyType.DOUBLE);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
VertexProperty<Integer, PgxEdge> parentEdge = graph.createVertexProperty(PropertyType.EDGE);
AllPaths<Integer> fattestPath = analyst.fattestPath(graph, root, cost, distance, parent, parentEdge);
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<AllPaths<ID>> fattestPathAsync(PgxGraph graph, PgxVertex<ID> root, EdgeProperty<java.lang.Double> capacity)
Fattest path is a fast algorithm for finding a shortest path adding constraints for flowing related matters
The Fattest path algorithm can be regarded as a variant of Dijkstra's algorithm, it tries to find the fattest path between the given source and all the reachable vertices in the graph. The fatness of a path is equal to the minimum value of the capacity from the edges that take part in the path, thus a fattest path is conformed by the edges with the largest possible capacity.
This algorithm runs in a sequential way.
O(E + V log V) with V = number of vertices, E = number of edges
O(4 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.capacity
 edge property holding the capacity of each edge in the graph.
PgxGraph graph = ...;
PgxVertex<Integer> root = graph.getVertex(128);
EdgeProperty<Double> cost = graph.getEdgeProperty("cost");
PgxFuture<AllPaths<Integer>> promise = analyst.fattestPathAsync(graph, root, cost);
promise.thenAccept(paths > {
...;
});
public <ID> PgxFuture<AllPaths<ID>> fattestPathAsync(PgxGraph graph, PgxVertex<ID> root, EdgeProperty<java.lang.Double> capacity, VertexProperty<ID,java.lang.Double> distance, VertexProperty<ID,PgxVertex<ID>> parent, VertexProperty<ID,PgxEdge> parentEdge)
Fattest path is a fast algorithm for finding a shortest path adding constraints for flowing related matters
The Fattest path algorithm can be regarded as a variant of Dijkstra's algorithm, it tries to find the fattest path between the given source and all the reachable vertices in the graph. The fatness of a path is equal to the minimum value of the capacity from the edges that take part in the path, thus a fattest path is conformed by the edges with the largest possible capacity.
This algorithm runs in a sequential way.
O(E + V log V) with V = number of vertices, E = number of edges
O(4 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.capacity
 edge property holding the capacity of each edge in the graph.distance
 (out argument) vertex property holding the capacity value of the fattest path up to the current vertex. The fatness value for the source vertex will be INF, while it will be 0 for all the vertices that are not reachable from the source.parent
 (out argument) vertex property holding the parent vertex of the each vertex in the fattest path.parentEdge
 (out argument) vertex property holding the edge ID linking the current vertex in the path with the previous vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> root = graph.getVertex(128);
EdgeProperty<Double> cost = graph.getEdgeProperty("cost");
VertexProperty<Integer, Double> distance = graph.createVertexProperty(PropertyType.DOUBLE);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
VertexProperty<Integer, PgxEdge> parentEdge = graph.createVertexProperty(PropertyType.EDGE);
PgxFuture<AllPaths<Integer>> promise = analyst.fattestPathAsync(graph, root, cost, distance, parent, parentEdge);
promise.thenAccept(paths > {
...;
});
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, ID root) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredBfs(PgxGraph, PgxVertex)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, ID root, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredBfs(PgxGraph, PgxVertex, int)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, boolean initWithInf) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, boolean initWithInf, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, int)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, boolean initWithInf, int maxDepth, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, int, VertexProperty,
VertexProperty)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, boolean initWithInf, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, VertexProperty,
VertexProperty)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredBfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, int)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, PgxVertex<ID> root) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> bfs =
analyst.filteredBfs(graph, vertex);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, PgxVertex<ID> root, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> bfs =
analyst.filteredBfs(graph, vertex, 2);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> bfs =
analyst.filteredBfs(graph, vertex, navigator);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> bfs =
analyst.filteredBfs(graph, vertex, navigator, true);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> bfs =
analyst.filteredBfs(graph, vertex, navigator, true, 2);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, int maxDepth, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.maxDepth
 maximum depth limit for the BFS traversal.distance
 (out argument) vertex property holding the hop distance for each reachable vertex in the graph.parent
 (out argument) vertex property holding the parent vertex of the each reachable vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
VertexProperty<Integer, Integer> distance = graph.createVertexProperty(PropertyType.INTEGER);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> bfs =
analyst.filteredBfs(graph, vertex, navigator, true, distance, parent);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.distance
 (out argument) vertex property holding the hop distance for each reachable vertex in the graph.parent
 (out argument) vertex property holding the parent vertex of the each reachable vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
VertexProperty<Integer, Integer> distance = graph.createVertexProperty(PropertyType.INTEGER);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> bfs =
analyst.filteredBfs(graph, vertex, navigator, true, distance, parent);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredBfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> bfs =
analyst.filteredBfs(graph, vertex, navigator, 2);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredBfsAsync(PgxGraph graph, PgxVertex<ID> root)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredBfsAsync(graph, vertex);
promise.thenCompose(bfs > graph.queryPgqlAsync(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredBfsAsync(PgxGraph graph, PgxVertex<ID> root, int maxDepth)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredBfsAsync(graph, vertex, 2);
promise.thenCompose(bfs > graph.queryPgqlAsync(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredBfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredBfsAsync(graph, vertex, navigator);
promise.thenCompose(bfs > graph.queryPgqlAsync(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredBfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredBfsAsync(graph, vertex, filter, navigator, true);
promise.thenCompose(bfs > graph.queryPgqlAsync(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredBfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, int maxDepth)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredBfsAsync(graph, vertex, navigator, true, 2);
promise.thenCompose(bfs > graph.queryPgqlAsync(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredBfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, int maxDepth, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.maxDepth
 maximum depth limit for the BFS traversal.distance
 (out argument) vertex property holding the hop distance for each reachable vertex in the graph.parent
 (out argument) vertex property holding the parent vertex of the each reachable vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
VertexProperty<Integer, Integer> distance = graph.createVertexProperty(PropertyType.INTEGER);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredBfsAsync(graph, vertex, navigator, true, 2, distance, parent);
promise.thenCompose(bfs > graph.queryPgqlAsync(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredBfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.distance
 (out argument) vertex property holding the hop distance for each reachable vertex in the graph.parent
 (out argument) vertex property holding the parent vertex of the each reachable vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
VertexProperty<Integer, Integer> distance = graph.createVertexProperty(PropertyType.INTEGER);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredBfsAsync(graph, vertex, navigator, true, distance, parent);
promise.thenCompose(bfs > graph.queryPgqlAsync(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredBfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, int maxDepth)
A BreadthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the BFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin BFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(2 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredBfsAsync(graph, vertex, navigator, 2);
promise.thenCompose(bfs > graph.queryPgqlAsync(
"SELECT x, x." + bfs.getFirst().getName() + ", x." + bfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
bfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, ID root) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredDfs(PgxGraph, PgxVertex)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, ID root, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredDfs(PgxGraph, PgxVertex, int)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, boolean initWithInf) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, boolean initWithInf, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, int)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, boolean initWithInf, int maxDepth, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, int, VertexProperty,
VertexProperty)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, boolean initWithInf, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, boolean, VertexProperty,
VertexProperty)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, ID root, VertexFilter filter, VertexFilter navigator, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
filteredDfs(PgxGraph, PgxVertex, VertexFilter, VertexFilter, int)
taking a vertex ID instead of PgxVertex
.java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, PgxVertex<ID> root) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> dfs =
analyst.filteredDfs(graph, vertex);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, PgxVertex<ID> root, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> dfs =
analyst.filteredDfs(graph, vertex, 2);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> dfs =
analyst.filteredDfs(graph, vertex, navigator);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> dfs =
analyst.filteredDfs(graph, vertex, navigator, true);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> dfs =
analyst.filteredDfs(graph, vertex, navigator, true, 2);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, int maxDepth, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.maxDepth
 maximum depth limit for the BFS traversal.distance
 (out argument) vertex property holding the hop distance for each reachable vertex in the graph.parent
 (out argument) vertex property holding the parent vertex of the each reachable vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
VertexProperty<Integer, Integer> distance = graph.createVertexProperty(PropertyType.INTEGER);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> dfs =
analyst.filteredDfs(graph, vertex, navigator, true, distance, parent);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.distance
 (out argument) vertex property holding the hop distance for each reachable vertex in the graph.parent
 (out argument) vertex property holding the parent vertex of the each reachable vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
VertexProperty<Integer, Integer> distance = graph.createVertexProperty(PropertyType.INTEGER);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> dfs =
analyst.filteredDfs(graph, vertex, navigator, true, distance, parent);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>> filteredDfs(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, int maxDepth) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>> dfs =
analyst.filteredDfs(graph, vertex, navigator, 2);
PgqlResultSet rs = graph.queryPgql(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC");
rs.print();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredDfsAsync(PgxGraph graph, PgxVertex<ID> root)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredDfsAsync(graph, vertex);
promise.thenCompose(dfs > graph.queryPgqlAsync(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredDfsAsync(PgxGraph graph, PgxVertex<ID> root, int maxDepth)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredDfsAsync(graph, vertex, 2);
promise.thenCompose(dfs > graph.queryPgqlAsync(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredDfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredDfsAsync(graph, vertex, filter, navigator);
promise.thenCompose(dfs > graph.queryPgqlAsync(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredDfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredDfsAsync(graph, vertex, filter, navigator, true);
promise.thenCompose(dfs > graph.queryPgqlAsync(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredDfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, int maxDepth)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredDfsAsync(graph, vertex, filter, navigator, true, 2);
promise.thenCompose(dfs > graph.queryPgqlAsync(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredDfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, int maxDepth, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.maxDepth
 maximum depth limit for the BFS traversal.distance
 (out argument) vertex property holding the hop distance for each reachable vertex in the graph.parent
 (out argument) vertex property holding the parent vertex of the each reachable vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
VertexProperty<Integer, Integer> distance = graph.createVertexProperty(PropertyType.INTEGER);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredDfsAsync(graph, vertex, filter, navigator, true, 2, distance, parent);
promise.thenCompose(dfs > graph.queryPgqlAsync(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredDfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, boolean initWithInf, VertexProperty<ID,java.lang.Integer> distance, VertexProperty<ID,PgxVertex<ID>> parent)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.initWithInf
 boolean flag to set the initial distance values of the vertices. If set to true, it will initialize the distances as INF, and 1 otherwise.distance
 (out argument) vertex property holding the hop distance for each reachable vertex in the graph.parent
 (out argument) vertex property holding the parent vertex of the each reachable vertex in the path.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter navigator = VertexFilter.ALL;
VertexProperty<Integer, Integer> distance = graph.createVertexProperty(PropertyType.INTEGER);
VertexProperty<Integer, PgxVertex<Integer>> parent = graph.createVertexProperty(PropertyType.VERTEX);
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredDfsAsync(graph, vertex, filter, navigator, true, distance, parent);
promise.thenCompose(dfs > graph.queryPgqlAsync(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxFuture<Pair<VertexProperty<ID,java.lang.Integer>,VertexProperty<ID,PgxVertex<ID>>>> filteredDfsAsync(PgxGraph graph, PgxVertex<ID> root, VertexFilter navigator, int maxDepth)
A DepthFirst Search implementation with an option to filter edges during the traversal of the graph.
This filtered version of the DFS algorithm allows to use a filter and a navigator expression to be evaluated over the vertices during the traversal and discriminate them according to the desired criteria. It will return the distance to the source vertex and the corresponding parent vertex for all the filtered vertices.
The implementation of this algorithm uses the builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(3 * V) with V = number of vertices
graph
 the graph.root
 the source vertex from the graph for the path.navigator
 navigator expression to be evaluated on the vertices during the graph traversal.maxDepth
 maximum depth limit for the BFS traversal.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
VertexFilter filter = VertexFilter.ALL;
VertexFilter navigator = VertexFilter.ALL;
PgxFuture<Pair<VertexProperty<Integer, Integer>, VertexProperty<Integer, PgxVertex<Integer>>>> promise =
analyst.filteredDfsAsync(graph, vertex, filter, navigator, 2);
promise.thenCompose(dfs > graph.queryPgqlAsync(
"SELECT x, x." + dfs.getFirst().getName() + ", x." + dfs.getSecond().getName() + " MATCH (x) ORDER BY x." +
dfs.getFirst().getName() + " DESC"))
.thenAccept(PgqlResultSet::print);
public <ID> PgxPath<ID> findCycle(PgxGraph graph) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Find cycle looks for any loop in the graph.
This algorithm tries to find a cycle in a directed graph using DFS traversals and will return the first cycle found, if there is one. In such case, the vertices and edges involved in the cycle will be returned in the order of visit. The algorithm is expensive because it will perform DFS traversals using different vertices as starting points until it explores the whole graph (worstcase scenario), or until it finds a cycle.
The implementation of this algorithm uses a builtin DFS feature. It is an expensive algorithm to run on large graphs.
O(V * (V + E)) with V = number of vertices, E = number of edges
O(5 * V + E) with V = number of vertices, E = number of edges
graph
 the graph.
PgxGraph graph = ...;
PgxPath<Integer> cycle = analyst.findCycle(graph);
cycle.getPathLengthWithCost();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxPath<ID> findCycle(PgxGraph graph, PgxVertex<ID> src) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Find cycle looks for any loop in the graph.
This implementation tries to find a cycle in a directed graph using the given vertex as starting point for the DFS traversal and will return the first cycle found, if there is one. In such case, the vertices and edges involved in the cycle will be returned in the order of visit. Restricting the DFS traversal to a single starting point means that some parts of the graph may not get explored.
The implementation of this algorithm uses a builtin DFS feature.
O(V + E) with V = number of vertices, E = number of edges
O(4 * V + E) with V = number of vertices, E = number of edges
graph
 the graph.src
 source vertex for the search.
PgxGraph graph = ...;
PgxVertex<Integer> vertex = graph.getVertex(128);
PgxPath<Integer> cycle = analyst.findCycle(graph, vertex);
cycle.getPathLengthWithCost();
java.util.concurrent.ExecutionException
java.lang.InterruptedException
public <ID> PgxPath<ID> findCycle(PgxGraph graph, PgxVertex<ID> src, VertexSequence<ID> nodeSeq, EdgeSequence edgeSeq) throws java.util.concurrent.ExecutionException, java.lang.InterruptedException
Find cycle looks for any loop in the graph.
This implementation tries to find a cycle in a directed graph using the given vertex as starting point for the DFS traversal and will return the first cycle found, if there is one. In such case, the vertices and edges involved in the cycle will be returned in the order of visit. Restricting the DFS traversal to a single starting point means that some parts of the graph may not get explored.
The implementation of this algorithm uses a builtin DFS feature.