Analyst (Oracle Big Data Spatial and Graph Property Graph)

java.lang.Object
- oracle.pgx.api.Destroyable
- - oracle.pgx.api.Analyst

All Implemented Interfaces:

AutoCloseable
```
public class Analyst
extends Destroyable
```
The Analyst gives access to all built-in algorithms of PGX. Unlike other classes inside this package, the Analyst is not stateless. It creates session-bound transient data to hold the result of algorithms and keeps track of them. Once Destroyable.destroy() is invoked, all transient data returned by the Analyst gets freed and cannot be used anymore.

Method Summary

Methods
Modifier and Type	Method and Description
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`approximateVertexBetweennessCentrality(PgxGraph graph, int k)` Blocking version of `#approximateVertexBetweennessCentralityAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>`	`approximateVertexBetweennessCentralityAsync(PgxGraph graph, int k)` Approximate vertex betweenness centrality (without considering edge length).
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`approximateVertexBetweennessCentralityFromSeeds(PgxGraph graph, PgxVertex<ID>... seeds)` Blocking version of `#approximateVertexBetweennessCentralityFromSeedsAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>`	`approximateVertexBetweennessCentralityFromSeedsAsync(PgxGraph graph, PgxVertex<ID>... seeds)` Approximate vertex betweenness centrality (without considering edge length).
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`closenessCentralityDoubleLength(PgxGraph graph, EdgeProperty<Double> cost)` Blocking version of `#closenessCentralityDoubleLengthAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>`	`closenessCentralityDoubleLengthAsync(PgxGraph graph, EdgeProperty<Double> cost)` Compute closed centrality.
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`closenessCentralityUnitLength(PgxGraph graph)` Blocking version of `#closenessCentralityUnitLengthAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>`	`closenessCentralityUnitLengthAsync(PgxGraph graph)` Compute closed centrality.
`<ID extends Comparable<ID>> Partition<ID>`	`communitiesLabelPropagation(PgxGraph graph)` Blocking version of `#communitiesLabelPropagationAsync()`.
`<ID extends Comparable<ID>> PgxFuture<Partition<ID>>`	`communitiesLabelPropagationAsync(PgxGraph graph)` Detect communities using parallel label propagation.
`long`	`countTriangles(PgxGraph graph, boolean sortVerticesByDegree)` Blocking version of `#countTrianglesAsync()`.
`PgxFuture<Long>`	`countTrianglesAsync(PgxGraph graph, boolean sortVerticesByDegree)` Counts the number of 'triads' in the given undirected graph.
`<ID extends Comparable<ID>> VertexProperty<ID,Integer>`	`degreeCentrality(PgxGraph graph)` Blocking version of `#degreeCentralityAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>>`	`degreeCentralityAsync(PgxGraph graph)` Compute degree centrality.
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`eigenvectorCentrality(PgxGraph graph, int max, double maxDiff, boolean useL2Norm, boolean useInEdge)` Blocking version of `#eigenvectorCentralityAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>`	`eigenvectorCentralityAsync(PgxGraph graph, int max, double maxDiff, boolean useL2Norm, boolean useInEdge)` Compute eigenvector centrality using power iteration (with L1 norm).
`<ID extends Comparable<ID>> AllPaths<ID>`	`fattestPath(PgxGraph graph, ID rootId, EdgeProperty<Double> capacity)` Convenience wrapper around `fattestPath(PgxGraph, PgxVertex, EdgeProperty)` taking a vertex ID instead of a `PgxVertex`.
`<ID extends Comparable<ID>> AllPaths<ID>`	`fattestPath(PgxGraph graph, PgxVertex<ID> root, EdgeProperty<Double> capacity)` Blocking version of `#fattestPathAsync()`.
`<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>`	`fattestPathAsync(PgxGraph graph, PgxVertex<ID> root, EdgeProperty<Double> capacity)` Fattest Tree Algorithm - Computes the fattest path from a source vertex to all vertices in the graph.
`PgxSession`	`getSession()` Gets the session.
`<ID extends Comparable<ID>> Pair<VertexProperty<ID,Double>,VertexProperty<ID,Double>>`	`hits(PgxGraph graph, int max)` Blocking version of `#hitsAsync()`.
`<ID extends Comparable<ID>> PgxFuture<Pair<VertexProperty<ID,Double>,VertexProperty<ID,Double>>>`	`hitsAsync(PgxGraph graph, int max)` Classic HITS algorithm (Hyperlink-Induced Topic Search, aka.
`<ID extends Comparable<ID>> VertexProperty<ID,Integer>`	`inDegreeCentrality(PgxGraph graph)` Blocking version of `#inDegreeCentralityAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>>`	`inDegreeCentralityAsync(PgxGraph graph)` Compute in-degree centrality.
`PgxMap<Integer,Long>`	`inDegreeDistribution(PgxGraph graph)` Blocking version of `#inDegreeDistributionAsync()`.
`PgxFuture<PgxMap<Integer,Long>>`	`inDegreeDistributionAsync(PgxGraph graph)` Computes the indegree distribution of the given graph and stores it in a map.
`<ID extends Comparable<ID>> VertexProperty<ID,Integer>`	`outDegreeCentrality(PgxGraph graph)` Blocking version of `#outDegreeCentralityAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>>`	`outDegreeCentralityAsync(PgxGraph graph)` Compute out-degree centrality.
`PgxMap<Integer,Long>`	`outDegreeDistribution(PgxGraph graph)` Blocking version of `#outDegreeDistributionAsync()`.
`PgxFuture<PgxMap<Integer,Long>>`	`outDegreeDistributionAsync(PgxGraph graph)` Computes the outdegree distribution of the given graph and stores it in a map.
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`pagerank(PgxGraph graph, double e, double d, int max)` Blocking version of `#pagerankAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>`	`pagerankAsync(PgxGraph graph, double e, double d, int max)` Classic pagerank algorithm.
`<ID extends Comparable<ID>> Pair<Scalar<Double>,Scalar<Double>>`	`partitionConductance(PgxGraph graph, Partition<ID> components)` Blocking version of `#partitionConductanceAsync()`.
`<ID extends Comparable<ID>> PgxFuture<Pair<Scalar<Double>,Scalar<Double>>>`	`partitionConductanceAsync(PgxGraph graph, Partition<ID> partition)` Compute the conductance of a partition.
`<ID extends Comparable<ID>> Scalar<Double>`	`partitionModularity(PgxGraph graph, Partition<ID> components)` Blocking version of `#partitionModularityAsync()`.
`<ID extends Comparable<ID>> PgxFuture<Scalar<Double>>`	`partitionModularityAsync(PgxGraph graph, Partition<ID> partition)` Compute the modularity of a partition.
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`personalizedPagerank(PgxGraph graph, ID vertexId, double e, double d, int max)` Convenience wrapper around `personalizedPagerank(PgxGraph, PgxVertex, double, double, int)` taking a vertex ID instead of a `PgxVertex`.
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`personalizedPagerank(PgxGraph graph, PgxVertex<ID> v, double e, double d, int max)` Blocking version of `personalizedPagerankAsync(PgxGraph, PgxVertex, double, double, int)`.
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`personalizedPagerank(PgxGraph graph, VertexSet<ID> vertices, double e, double d, int max)` Blocking version of `personalizedPagerankAsync(PgxGraph, VertexSet, double, double, int)`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>`	`personalizedPagerankAsync(PgxGraph graph, PgxVertex<ID> v, double e, double d, int max)` Personalized pagerank (random walk with restart) evaluates relative importance of vertices in a graph with respect to a given vertex v.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>`	`personalizedPagerankAsync(PgxGraph graph, VertexSet<ID> vertices, double e, double d, int max)` Personalized pagerank (random walk with restart) evaluates relative importance of vertices in a graph with respect to a given set of vertices.
`<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>`	`salsa(BipartiteGraph graph, int k)` Blocking version of `salsaAsync(BipartiteGraph, int)`.
`<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>`	`salsa(BipartiteGraph graph, int k, double maxDiff, double d, int maxIter)` Blocking version of `salsaAsync(BipartiteGraph, int, double, double, int)`.
`<ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>>`	`salsaAsync(BipartiteGraph graph, int k)` Convenience method around `salsaAsync(BipartiteGraph, int, double, double, int)` using maxDiff = 0.01 d = 0.85 maxIter = 1.10
`<ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>>`	`salsaAsync(BipartiteGraph graph, int k, double maxDiff, double d, int maxIter)` SALSA recommendation algorithm.
`<ID extends Comparable<ID>> Partition<ID>`	`sccKosaraju(PgxGraph graph)` Blocking version of `#sccKosarajuAsync()`.
`<ID extends Comparable<ID>> PgxFuture<Partition<ID>>`	`sccKosarajuAsync(PgxGraph graph)` Find strongly connected components using Kosaraju's algorithm.
`<ID extends Comparable<ID>> Partition<ID>`	`sccTarjan(PgxGraph graph)` Blocking version of `#sccTarjanAsync()`.
`<ID extends Comparable<ID>> PgxFuture<Partition<ID>>`	`sccTarjanAsync(PgxGraph graph)` Find strongly connected components using Tarjan's algorithm.
`<ID extends Comparable<ID>> AllPaths<ID>`	`shortestPathBellmanFord(PgxGraph graph, ID srcId, EdgeProperty<Double> cost)` Convenience wrapper around `shortestPathBellmanFord(PgxGraph, PgxVertex, EdgeProperty)` taking a vertex ID instead of `PgxVertex`.
`<ID extends Comparable<ID>> AllPaths<ID>`	`shortestPathBellmanFord(PgxGraph graph, PgxVertex<ID> src, EdgeProperty<Double> cost)` Blocking version of `#shortestPathBellmanFordAsync()`.
`<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>`	`shortestPathBellmanFordAsync(PgxGraph graph, PgxVertex<ID> src, EdgeProperty<Double> cost)` Compute single source shortest paths using Bellman & Ford algorithm time complexity: O(E * D) with E = number of edges, D = number edges in the shortest length
`<ID extends Comparable<ID>> AllPaths<ID>`	`shortestPathBellmanFordReverse(PgxGraph graph, ID srcId, EdgeProperty<Double> cost)` Convenience wrapper around `shortestPathBellmanFordReverse(PgxGraph, PgxVertex, EdgeProperty)` taking a vertex ID instead of `PgxVertex`.
`<ID extends Comparable<ID>> AllPaths<ID>`	`shortestPathBellmanFordReverse(PgxGraph graph, PgxVertex<ID> src, EdgeProperty<Double> cost)` Blocking version of `#shortestPathBellmanFordReverseAsync()`.
`<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>`	`shortestPathBellmanFordReverseAsync(PgxGraph graph, PgxVertex<ID> src, EdgeProperty<Double> cost)` Compute reverse single source shortest paths using Bellman & Ford algorithm time complexity: O(E * D) with E = number of edges, D = number edges in the shortest length
`<ID extends Comparable<ID>> PgxPath<ID>`	`shortestPathDijkstra(PgxGraph graph, ID srcId, ID dstId, EdgeProperty<Double> cost)` Convenience wrapper around `shortestPathDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty)` taking vertex IDs instead of `PgxVertex`.
`<ID extends Comparable<ID>> PgxPath<ID>`	`shortestPathDijkstra(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost)` Blocking version of `#shortestPathDijkstraAsync()`.
`<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>`	`shortestPathDijkstraAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost)` Compute shortest path using Dijkstra's algorithm.
`<ID extends Comparable<ID>> PgxPath<ID>`	`shortestPathDijkstraBidirectional(PgxGraph graph, ID srcId, ID dstId, EdgeProperty<Double> cost)` Convenience wrapper around `shortestPathDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty)` taking vertex IDs instead of `PgxVertex`.
`<ID extends Comparable<ID>> PgxPath<ID>`	`shortestPathDijkstraBidirectional(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost)` Blocking version of `#shortestPathDijkstraBidirectionalAsync()`.
`<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>`	`shortestPathDijkstraBidirectionalAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost)` Compute shortest path using a bi-directional Dijkstra variant.
`<ID extends Comparable<ID>> PgxPath<ID>`	`shortestPathFilteredDijkstra(PgxGraph graph, ID srcId, ID dstId, EdgeProperty<Double> cost, GraphFilter filterExpr)` Convenience wrapper around `shortestPathFilteredDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter)` taking vertex IDs instead of `PgxVertex`.
`<ID extends Comparable<ID>> PgxPath<ID>`	`shortestPathFilteredDijkstra(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, GraphFilter filterExpr)` Blocking version of `#shortestPathFilteredDijkstraAsync()`.
`<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>`	`shortestPathFilteredDijkstraAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, GraphFilter filterExpr)` Compute shortest path using Dijkstra's algorithm on a filtered graph The filter specified by the given filter expression is applied on each edge during traversal of the graph.
`<ID extends Comparable<ID>> PgxPath<ID>`	`shortestPathFilteredDijkstraBidirectional(PgxGraph graph, ID srcId, ID dstId, EdgeProperty<Double> cost, GraphFilter filterExpr)` Convenience wrapper around `shortestPathFilteredDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter)` taking vertex IDs instead of `PgxVertex`.
`<ID extends Comparable<ID>> PgxPath<ID>`	`shortestPathFilteredDijkstraBidirectional(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, GraphFilter filterExpr)` Blocking version of `#shortestPathFilteredDijkstraBidirectionalAsync()`.
`<ID extends Comparable<ID>> PgxFuture<PgxPath<ID>>`	`shortestPathFilteredDijkstraBidirectionalAsync(PgxGraph graph, PgxVertex<ID> src, PgxVertex<ID> dst, EdgeProperty<Double> cost, GraphFilter filterExpr)` Compute shortest path using a bi-directional Dijkstra variant on a filtered graph.
`<ID extends Comparable<ID>> AllPaths<ID>`	`shortestPathHopDist(PgxGraph graph, ID srcId)` Convenience wrapper around `shortestPathHopDist(PgxGraph, PgxVertex)` taking a vertex ID instead of `PgxVertex`.
`<ID extends Comparable<ID>> AllPaths<ID>`	`shortestPathHopDist(PgxGraph graph, PgxVertex<ID> src)` Blocking version of `#shortestPathHopDistAsync()`.
`<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>`	`shortestPathHopDistAsync(PgxGraph graph, PgxVertex<ID> src)` Compute hop-distance from given vertex to every other vertex time complexity: O(E * d) with E = number of edges, d = diameter of graph
`<ID extends Comparable<ID>> AllPaths<ID>`	`shortestPathHopDistReverse(PgxGraph graph, ID srcId)` Convenience wrapper around `shortestPathHopDistReverse(PgxGraph, PgxVertex)` taking a vertex ID instead of `PgxVertex`.
`<ID extends Comparable<ID>> AllPaths<ID>`	`shortestPathHopDistReverse(PgxGraph graph, PgxVertex<ID> src)` Blocking version of `#shortestPathHopDistReverseAsync()`.
`<ID extends Comparable<ID>> PgxFuture<AllPaths<ID>>`	`shortestPathHopDistReverseAsync(PgxGraph graph, PgxVertex<ID> src)` Compute reverse hop-distance from given vertex to every other vertex time complexity: O(E * d) with E = number of edges, d = diameter of graph
`String`	`toString()`
`<ID extends Comparable<ID>> VertexProperty<ID,Double>`	`vertexBetweennessCentrality(PgxGraph graph)` Blocking version of `#vertexBetweennessCentralityAsync()`.
`<ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>>`	`vertexBetweennessCentralityAsync(PgxGraph graph)` Compute vertex betweenness centrality (without considering edge length).
`<ID extends Comparable<ID>> Partition<ID>`	`wcc(PgxGraph graph)` Blocking version of `#wccAsync()`.
`<ID extends Comparable<ID>> PgxFuture<Partition<ID>>`	`wccAsync(PgxGraph graph)` Find weakly connected components through label propagation time complexity: O(E * D) with E = number of edges, D = diameter of the graph
`<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>`	`whomToFollow(PgxGraph graph, ID vertexId, int max)` Convenience wrapper around `whomToFollow(PgxGraph, PgxVertex, int)` taking a vertex ID instead of a `PgxVertex`.
`<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>`	`whomToFollow(PgxGraph graph, ID vertexId, int max, int circleOfTrustSize, int randomWalkSteps, double randomWalkResetProbablitiy, double salsaDampingFactor, int salsaMaxIterations, double salsaMaxDiff)` Convenience wrapper around `whomToFollow(PgxGraph, PgxVertex, int, int, int, double, double, int, double)` taking a vertex ID instead of a `PgxVertex`.
`<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>`	`whomToFollow(PgxGraph graph, PgxVertex<ID> vertex, int max)` Blocking version of `whomToFollowAsync(PgxGraph, PgxVertex, int)`.
`<ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>>`	`whomToFollow(PgxGraph graph, PgxVertex<ID> vertex, int max, int circleOfTrustSize, int randomWalkSteps, double randomWalkResetProbablitiy, double salsaDampingFactor, int salsaMaxIterations, double salsaMaxDiff)` Blocking version of `whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double)`.
`<ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>>`	`whomToFollowAsync(PgxGraph graph, PgxVertex<ID> vertex, int max)` Convenience method around `whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double)` using circleOfTrustSize = 500 randomWalkSteps = 50000 randomWalkResetProbablitiy = 0.15 salsaDampingFactor = 0.85 salsaMaxIterations = 1.10 salsaMaxDiff = 0.01
`<ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>>`	`whomToFollowAsync(PgxGraph graph, PgxVertex<ID> vertex, int max, int circleOfTrustSize, int randomWalkSteps, double randomWalkResetProbablitiy, double salsaDampingFactor, int salsaMaxIterations, double salsaMaxDiff)` The Who to Follow recommendation algorithm by Twitter, Inc.

Methods inherited from class oracle.pgx.api.Destroyable
close, destroy, destroyAsync

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Method Detail

approximateVertexBetweennessCentrality

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Double> approximateVertexBetweennessCentrality(PgxGraph graph,
                                                                                                          int k)
                                                                                        throws ExecutionException,
                                                                                               InterruptedException

Blocking version of #approximateVertexBetweennessCentralityAsync(). Calls #approximateVertexBetweennessCentralityAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

approximateVertexBetweennessCentralityAsync
```
public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> approximateVertexBetweennessCentralityAsync(PgxGraph graph,
                                                                                                           int k)
```
Approximate vertex betweenness centrality (without considering edge length). The algorithm performs a BFS only from randomly selected k seed vertices instead of every vertex. time complexity: O(K * E) with E = number of edges, K is a given constant (# of seed vertices)

Parameters:

graph - graph name

k - how many random selected seed vertices to use

Returns:

VertexProperty holding the result as a double

approximateVertexBetweennessCentralityFromSeeds

@SafeVarargs
@Generated(value="src/python/synchronize.py")
public final <ID extends Comparable<ID>> VertexProperty<ID,Double> approximateVertexBetweennessCentralityFromSeeds(PgxGraph graph,
                                                                                                                               PgxVertex<ID>... seeds)
                                                                                                       throws ExecutionException,
                                                                                                              InterruptedException

Blocking version of #approximateVertexBetweennessCentralityFromSeedsAsync(). Calls #approximateVertexBetweennessCentralityFromSeedsAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

approximateVertexBetweennessCentralityFromSeedsAsync

@SafeVarargs
public final <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> approximateVertexBetweennessCentralityFromSeedsAsync(PgxGraph graph,
                                                                                                                                PgxVertex<ID>... seeds)

Approximate vertex betweenness centrality (without considering edge length). The algorithm performs a BFS only from the given seed vertices instead of every vertex. time complexity: O(K * E) with E = number of edges, K is a given constant (# of seed vertices)

Parameters:: graph - graph; seeds - collection
Returns:: VertexProperty holding the result as a double

closenessCentralityDoubleLength

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Double> closenessCentralityDoubleLength(PgxGraph graph,
                                                                                                   EdgeProperty<Double> cost)
                                                                                 throws ExecutionException,
                                                                                        InterruptedException

Blocking version of #closenessCentralityDoubleLengthAsync(). Calls #closenessCentralityDoubleLengthAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

closenessCentralityDoubleLengthAsync
```
public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> closenessCentralityDoubleLengthAsync(PgxGraph graph,
                                                                                                    EdgeProperty<Double> cost)
```
Compute closed centrality. The algorithm computes bellman-ford from every vertex in the graph, and thus is computationally very expensive. Note: The algorithm is only defined on a strongly connected graph. time complexity: O(N * E * d) with E = number of edges, N = number of vertices, d = path-length diameter of graph

Parameters:

graph - graph

cost - Edge Property of the cost

Returns:

the Vertex Property holding the result as a double

closenessCentralityUnitLength

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Double> closenessCentralityUnitLength(PgxGraph graph)
                                                                               throws ExecutionException,
                                                                                      InterruptedException

Blocking version of #closenessCentralityUnitLengthAsync(). Calls #closenessCentralityUnitLengthAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

closenessCentralityUnitLengthAsync
```
public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> closenessCentralityUnitLengthAsync(PgxGraph graph)
```
Compute closed centrality. The algorithm computes BFS from every vertex in the graph, and thus is computationally very expensive. Note: The algorithm is only defined on a strongly connected graph. time complexity: O(N * E) with E = number of edges, N = number of vertices

Parameters:

graph - graph

Returns:

the Vertex Property holding the result as a double

communitiesLabelPropagation

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Partition<ID> communitiesLabelPropagation(PgxGraph graph)
                                                                 throws ExecutionException,
                                                                        InterruptedException

Blocking version of #communitiesLabelPropagationAsync(). Calls #communitiesLabelPropagationAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

communitiesLabelPropagationAsync
```
public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> communitiesLabelPropagationAsync(PgxGraph graph)
```
Detect communities using parallel label propagation. time complexity: O(E * k) with E = number of edges, k is constant

Parameters:

graph - graph

Returns:

a PgxComponent holding the result

countTriangles
```
@Generated(value="src/python/synchronize.py")
public long countTriangles(PgxGraph graph,
                                 boolean sortVerticesByDegree)
                    throws ExecutionException,
                           InterruptedException
```
Blocking version of #countTrianglesAsync(). Calls #countTrianglesAsync() and waits for the returned PgxFuture to complete.

Throws:

InterruptedException - if the caller thread gets interrupted while waiting for completion.

ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

countTrianglesAsync
```
public PgxFuture<Long> countTrianglesAsync(PgxGraph graph,
                                  boolean sortVerticesByDegree)
```
Counts the number of 'triads' in the given undirected graph. The algorithm is only defined on undirected graphs, this method therefore first creates an undirected copy of the given graph. After Time complexity: O(E * d) with E = number of edges, d = degree of graph

Parameters:

graph - graph

sortVerticesByDegree - if true, the undirected copy of the graph will be sorted by degree. You can use this flag to trade memory for speed. If sorted, the algorithm usually terminates faster, but the peak memory consumption increases.

Returns:

number of triangles

degreeCentrality

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Integer> degreeCentrality(PgxGraph graph)
                                                                   throws ExecutionException,
                                                                          InterruptedException

Blocking version of #degreeCentralityAsync(). Calls #degreeCentralityAsync() and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

degreeCentralityAsync
```
public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>> degreeCentralityAsync(PgxGraph graph)
```
Compute degree centrality. time complexity: O(E) with E = number of edges

Parameters:

graph - graph

Returns:

VertexProperty holding the result as an integer

eigenvectorCentrality

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Double> eigenvectorCentrality(PgxGraph graph,
                                                                                         int max,
                                                                                         double maxDiff,
                                                                                         boolean useL2Norm,
                                                                                         boolean useInEdge)
                                                                       throws ExecutionException,
                                                                              InterruptedException

Blocking version of #eigenvectorCentralityAsync(). Calls #eigenvectorCentralityAsync() and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

eigenvectorCentralityAsync
```
public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> eigenvectorCentralityAsync(PgxGraph graph,
                                                                                          int max,
                                                                                          double maxDiff,
                                                                                          boolean useL2Norm,
                                                                                          boolean useInEdge)
```
Compute eigenvector centrality using power iteration (with L1 norm). This algorithm is similar to Pagerank. time complexity: O(K * E) with E = number of edges, K is a given constant (max iterations)

Type Parameters:

ID - the generic type

Parameters:

graph - graph where used for the algorithm

max - maximum number of iterations

maxDiff - maximum error for terminating the iteration

useL2Norm - true- use L2Norm for normalization. false - use L1Norm

useInEdge - true- compute 'left' eigenvector, false - compute 'right' eigenvector

Returns:

Vertex Property holding the result as a double

fattestPath

public <ID extends Comparable<ID>> AllPaths<ID> fattestPath(PgxGraph graph,
                                                   ID rootId,
                                                   EdgeProperty<Double> capacity)
                                                throws ExecutionException,
                                                       InterruptedException

Convenience wrapper around fattestPath(PgxGraph, PgxVertex, EdgeProperty) taking a vertex ID instead of a PgxVertex.

Throws:: ExecutionException; InterruptedException

fattestPath

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> AllPaths<ID> fattestPath(PgxGraph graph,
                                                                  PgxVertex<ID> root,
                                                                  EdgeProperty<Double> capacity)
                                                throws ExecutionException,
                                                       InterruptedException

Blocking version of #fattestPathAsync(). Calls #fattestPathAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

fattestPathAsync
```
public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> fattestPathAsync(PgxGraph graph,
                                                                   PgxVertex<ID> root,
                                                                   EdgeProperty<Double> capacity)
```
Fattest Tree Algorithm - Computes the fattest path from a source vertex to all vertices in the graph. The fattest path between two vertices is the path with the highest possible minimum edge capacity.

Parameters:

graph - graph

capacity - edge property containing the capacity of each edge. Capacity may be negative. In case of an undirected graph, the capacity of the forward and backward edge should be the same.

root - the starting vertex of the algorithm

Returns:

AllPaths<ID> holds the minimum capacity of the path leading to this vertex. Will be Double.POSITIVE_INFINITY for the root vertex and 0.0 for all vertices not connected to root.

getSession
```
public PgxSession getSession()
```
Gets the session.

Returns:

the PGX session

hits

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Pair<VertexProperty<ID,Double>,VertexProperty<ID,Double>> hits(PgxGraph graph,
                                                                                                        int max)
                                                                                                             throws ExecutionException,
                                                                                                                    InterruptedException

Blocking version of #hitsAsync(). Calls #hitsAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

hitsAsync
```
public <ID extends Comparable<ID>> PgxFuture<Pair<VertexProperty<ID,Double>,VertexProperty<ID,Double>>> hitsAsync(PgxGraph graph,
                                                                                                         int max)
```
Classic HITS algorithm (Hyperlink-Induced Topic Search, aka. Hubs and Authorities). The implementation uses an iterative method. At each iteration step, the hub and the authority values of all the vertices in the graph are computed . time complexity: O(K * E) with E = number of edges, K is a given constant (max iterations)

Parameters:

graph - graph

max - maximum number of iterations

Returns:

Pair of Vertex Properties holding the results as a doubles

inDegreeCentrality

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Integer> inDegreeCentrality(PgxGraph graph)
                                                                     throws ExecutionException,
                                                                            InterruptedException

Blocking version of #inDegreeCentralityAsync(). Calls #inDegreeCentralityAsync() and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

inDegreeCentralityAsync
```
public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>> inDegreeCentralityAsync(PgxGraph graph)
```
Compute in-degree centrality. time complexity: O(E) with E = number of edges

Parameters:

graph - graph

Returns:

VertexProperty holding the result as an integer

inDegreeDistribution
```
@Generated(value="src/python/synchronize.py")
public PgxMap<Integer,Long> inDegreeDistribution(PgxGraph graph)
                                          throws ExecutionException,
                                                 InterruptedException
```
Blocking version of #inDegreeDistributionAsync(). Calls #inDegreeDistributionAsync() and waits for returned PgxFuture to complete.

Throws:

InterruptedException - if the caller thread gets interrupted while waiting for completion.

ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

inDegreeDistributionAsync
```
public PgxFuture<PgxMap<Integer,Long>> inDegreeDistributionAsync(PgxGraph graph)
```
Computes the indegree distribution of the given graph and stores it in a map.

Parameters:

graph - graph

Returns:

map that will hold the mapping indegree -> #vertices with that indegree

outDegreeCentrality

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Integer> outDegreeCentrality(PgxGraph graph)
                                                                      throws ExecutionException,
                                                                             InterruptedException

Blocking version of #outDegreeCentralityAsync(). Calls #outDegreeCentralityAsync() and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

outDegreeCentralityAsync
```
public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Integer>> outDegreeCentralityAsync(PgxGraph graph)
```
Compute out-degree centrality. time complexity: O(E) with E = number of edges

Parameters:

graph - graph

Returns:

VertexProperty holding the result as an integer

outDegreeDistribution
```
@Generated(value="src/python/synchronize.py")
public PgxMap<Integer,Long> outDegreeDistribution(PgxGraph graph)
                                           throws ExecutionException,
                                                  InterruptedException
```
Blocking version of #outDegreeDistributionAsync(). Calls #outDegreeDistributionAsync() and waits for returned PgxFuture to complete.

Throws:

InterruptedException - if the caller thread gets interrupted while waiting for completion.

ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

outDegreeDistributionAsync
```
public PgxFuture<PgxMap<Integer,Long>> outDegreeDistributionAsync(PgxGraph graph)
```
Computes the outdegree distribution of the given graph and stores it in a map.

Parameters:

graph - graph

Returns:

map that will hold the mapping outdegree -> #vertices with that outdegree

pagerank

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Double> pagerank(PgxGraph graph,
                                                                            double e,
                                                                            double d,
                                                                            int max)
                                                          throws ExecutionException,
                                                                 InterruptedException

Blocking version of #pagerankAsync(). Calls #pagerankAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

pagerankAsync

public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> pagerankAsync(PgxGraph graph,
                                                                             double e,
                                                                             double d,
                                                                             int max)

Classic pagerank algorithm. Time complexity: O(E * K) with E = number of edges, K is a given constant (max iterations)

Parameters:: graph - graph; e - maximum error for terminating the iteration; d - damping factor; max - maximum number of iterations
Returns:: Vertex Property holding the result as a double

partitionConductance

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Pair<Scalar<Double>,Scalar<Double>> partitionConductance(PgxGraph graph,
                                                                                                  Partition<ID> components)
                                                         throws ExecutionException,
                                                                InterruptedException

Blocking version of #partitionConductanceAsync(). Calls #partitionConductanceAsync() and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

partitionConductanceAsync

public <ID extends Comparable<ID>> PgxFuture<Pair<Scalar<Double>,Scalar<Double>>> partitionConductanceAsync(PgxGraph graph,
                                                                                                   Partition<ID> partition)

Compute the conductance of a partition.

Parameters:: graph - graph; partition - the partition to analyze
Returns:: a pair holding the average conductance (first scalar value) and the minimum conductance (second scalar value)

partitionModularity

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Scalar<Double> partitionModularity(PgxGraph graph,
                                                                            Partition<ID> components)
                                   throws ExecutionException,
                                          InterruptedException

Blocking version of #partitionModularityAsync(). Calls #partitionModularityAsync() and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

partitionModularityAsync
```
public <ID extends Comparable<ID>> PgxFuture<Scalar<Double>> partitionModularityAsync(PgxGraph graph,
                                                                             Partition<ID> partition)
```
Compute the modularity of a partition.

Parameters:

graph - graph

partition - the partition to analyze

Returns:

scalar (of type double) to hold modularity

See Also:

http://en.wikipedia.org/wiki/Modularity_(networks) Note: this algorithm is in-efficient if numComponents is big (i.e. O(N))

personalizedPagerank

public <ID extends Comparable<ID>> VertexProperty<ID,Double> personalizedPagerank(PgxGraph graph,
                                                                         ID vertexId,
                                                                         double e,
                                                                         double d,
                                                                         int max)
                                                                      throws ExecutionException,
                                                                             InterruptedException

Convenience wrapper around personalizedPagerank(PgxGraph, PgxVertex, double, double, int) taking a vertex ID instead of a PgxVertex.

Throws:: ExecutionException; InterruptedException

personalizedPagerank

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Double> personalizedPagerank(PgxGraph graph,
                                                                                        PgxVertex<ID> v,
                                                                                        double e,
                                                                                        double d,
                                                                                        int max)
                                                                      throws ExecutionException,
                                                                             InterruptedException

Blocking version of personalizedPagerankAsync(PgxGraph, PgxVertex, double, double, int). Calls personalizedPagerankAsync(PgxGraph, PgxVertex, double, double, int) and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

personalizedPagerank

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Double> personalizedPagerank(PgxGraph graph,
                                                                                        VertexSet<ID> vertices,
                                                                                        double e,
                                                                                        double d,
                                                                                        int max)
                                                                      throws ExecutionException,
                                                                             InterruptedException

Blocking version of personalizedPagerankAsync(PgxGraph, VertexSet, double, double, int). Calls personalizedPagerankAsync(PgxGraph, VertexSet, double, double, int) and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

personalizedPagerankAsync
```
public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> personalizedPagerankAsync(PgxGraph graph,
                                                                                         PgxVertex<ID> v,
                                                                                         double e,
                                                                                         double d,
                                                                                         int max)
```
Personalized pagerank (random walk with restart) evaluates relative importance of vertices in a graph with respect to a given vertex v. That is the probability of ending at each vertex u, when performing random walk from the given vertex v with probability of c to restart from the start vertex. The implementation directly emulates random-walk via Monte-Carlo method. time complexity: O(K), K is a given constant (max iterations)

Parameters:

graph - graph

v - vertex

e - maximum error for terminating the iteration

d - damping factor

max - maximum number of iterations

Returns:

Vertex Property holding the result as a double

personalizedPagerankAsync

public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> personalizedPagerankAsync(PgxGraph graph,
                                                                                         VertexSet<ID> vertices,
                                                                                         double e,
                                                                                         double d,
                                                                                         int max)

Personalized pagerank (random walk with restart) evaluates relative importance of vertices in a graph with respect to a given set of vertices.

Parameters:: graph - graph; vertices - input vertices; e - maximum error for terminating the iteration; d - damping factor; max - maximum number of iterations
Returns:: Vertex Property holding the result as a double

salsa

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> salsa(BipartiteGraph graph,
                                                                                           int k)
                                                                                                throws ExecutionException,
                                                                                                       InterruptedException

Blocking version of salsaAsync(BipartiteGraph, int). Calls salsaAsync(BipartiteGraph, int) and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

salsa

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> salsa(BipartiteGraph graph,
                                                                                           int k,
                                                                                           double maxDiff,
                                                                                           double d,
                                                                                           int maxIter)
                                                                                                throws ExecutionException,
                                                                                                       InterruptedException

Blocking version of salsaAsync(BipartiteGraph, int, double, double, int). Calls salsaAsync(BipartiteGraph, int, double, double, int) and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

salsaAsync

public <ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> salsaAsync(BipartiteGraph graph,
                                                                                            int k)

Convenience method around salsaAsync(BipartiteGraph, int, double, double, int) using

maxDiff = 0.01
d = 0.85
maxIter = 1.10

salsaAsync

public <ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> salsaAsync(BipartiteGraph graph,
                                                                                            int k,
                                                                                            double maxDiff,
                                                                                            double d,
                                                                                            int maxIter)

SALSA recommendation algorithm.

Parameters:: graph - a bipartite graph; k - the top K vertices will be returned in hub_recs and auth_recs (so K+K vertices will be returned); maxDiff - the maximum diff; d - damping factor; maxIter - the maximum number of iterations
Returns:: a pair holding the vertex sequence 'hubs' as computed by SALSA as first entry and the vertex sequence 'auth' as computed by SALSA as second entry
See Also:: R. Lempel and S. Moran. SALSA: The Stochastic Approach for Link-Structure Analysis

sccKosaraju

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Partition<ID> sccKosaraju(PgxGraph graph)
                                                 throws ExecutionException,
                                                        InterruptedException

Blocking version of #sccKosarajuAsync(). Calls #sccKosarajuAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

sccKosarajuAsync
```
public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> sccKosarajuAsync(PgxGraph graph)
```
Find strongly connected components using Kosaraju's algorithm. This algorithm is parallelized, however, it has a larger constant factor than Tarjan's algorithm and thus may be slower than Tarjan's with small number of threads. time complexity: O(E) with E = number of edges

Parameters:

graph - graph

Returns:

connected components found

sccTarjan

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Partition<ID> sccTarjan(PgxGraph graph)
                                               throws ExecutionException,
                                                      InterruptedException

Blocking version of #sccTarjanAsync(). Calls #sccTarjanAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

sccTarjanAsync
```
public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> sccTarjanAsync(PgxGraph graph)
```
Find strongly connected components using Tarjan's algorithm. This algorithm is sequential by nature. time complexity: O(E) with E = number of edges

Parameters:

graph - graph

Returns:

strongly connected components found

shortestPathBellmanFord

public <ID extends Comparable<ID>> AllPaths<ID> shortestPathBellmanFord(PgxGraph graph,
                                                               ID srcId,
                                                               EdgeProperty<Double> cost)
                                                            throws ExecutionException,
                                                                   InterruptedException

Convenience wrapper around shortestPathBellmanFord(PgxGraph, PgxVertex, EdgeProperty) taking a vertex ID instead of PgxVertex.

Throws:: ExecutionException; InterruptedException

shortestPathBellmanFord

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> AllPaths<ID> shortestPathBellmanFord(PgxGraph graph,
                                                                              PgxVertex<ID> src,
                                                                              EdgeProperty<Double> cost)
                                                            throws ExecutionException,
                                                                   InterruptedException

Blocking version of #shortestPathBellmanFordAsync(). Calls #shortestPathBellmanFordAsync() and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

shortestPathBellmanFordAsync

public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> shortestPathBellmanFordAsync(PgxGraph graph,
                                                                               PgxVertex<ID> src,
                                                                               EdgeProperty<Double> cost)

Compute single source shortest paths using Bellman & Ford algorithm time complexity: O(E * D) with E = number of edges, D = number edges in the shortest length

Parameters:: graph - graph; cost - edge property (of type double) holding the edge costs of the graph; src - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
Returns:: a AllPaths holding the result

shortestPathBellmanFordReverse

public <ID extends Comparable<ID>> AllPaths<ID> shortestPathBellmanFordReverse(PgxGraph graph,
                                                                      ID srcId,
                                                                      EdgeProperty<Double> cost)
                                                                   throws ExecutionException,
                                                                          InterruptedException

Convenience wrapper around shortestPathBellmanFordReverse(PgxGraph, PgxVertex, EdgeProperty) taking a vertex ID instead of PgxVertex.

Throws:: ExecutionException; InterruptedException

shortestPathBellmanFordReverse

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> AllPaths<ID> shortestPathBellmanFordReverse(PgxGraph graph,
                                                                                     PgxVertex<ID> src,
                                                                                     EdgeProperty<Double> cost)
                                                                   throws ExecutionException,
                                                                          InterruptedException

Blocking version of #shortestPathBellmanFordReverseAsync(). Calls #shortestPathBellmanFordReverseAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

shortestPathBellmanFordReverseAsync

public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> shortestPathBellmanFordReverseAsync(PgxGraph graph,
                                                                                      PgxVertex<ID> src,
                                                                                      EdgeProperty<Double> cost)

Compute reverse single source shortest paths using Bellman & Ford algorithm time complexity: O(E * D) with E = number of edges, D = number edges in the shortest length

Parameters:: graph - graph; cost - edge property (of type double) holding the edge costs of the graph; src - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)

shortestPathDijkstra

public <ID extends Comparable<ID>> PgxPath<ID> shortestPathDijkstra(PgxGraph graph,
                                                           ID srcId,
                                                           ID dstId,
                                                           EdgeProperty<Double> cost)
                                                        throws ExecutionException,
                                                               InterruptedException

Convenience wrapper around shortestPathDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty) taking vertex IDs instead of PgxVertex.

Throws:: ExecutionException; InterruptedException

shortestPathDijkstra

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> PgxPath<ID> shortestPathDijkstra(PgxGraph graph,
                                                                          PgxVertex<ID> src,
                                                                          PgxVertex<ID> dst,
                                                                          EdgeProperty<Double> cost)
                                                        throws ExecutionException,
                                                               InterruptedException

Blocking version of #shortestPathDijkstraAsync(). Calls #shortestPathDijkstraAsync() and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

shortestPathDijkstraAsync

public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> shortestPathDijkstraAsync(PgxGraph graph,
                                                                           PgxVertex<ID> src,
                                                                           PgxVertex<ID> dst,
                                                                           EdgeProperty<Double> cost)

Compute shortest path using Dijkstra's algorithm. Time complexity: O(N log N) with N = number of vertices

Parameters:: graph - graph; src - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph); dst - destination vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph); cost - edge property (of type double) holding the edge costs of the graph
Returns:: a PgxPath holding the result

shortestPathDijkstraBidirectional

public <ID extends Comparable<ID>> PgxPath<ID> shortestPathDijkstraBidirectional(PgxGraph graph,
                                                                        ID srcId,
                                                                        ID dstId,
                                                                        EdgeProperty<Double> cost)
                                                                     throws ExecutionException,
                                                                            InterruptedException

Convenience wrapper around shortestPathDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty) taking vertex IDs instead of PgxVertex.

Throws:: ExecutionException; InterruptedException

shortestPathDijkstraBidirectional

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> PgxPath<ID> shortestPathDijkstraBidirectional(PgxGraph graph,
                                                                                       PgxVertex<ID> src,
                                                                                       PgxVertex<ID> dst,
                                                                                       EdgeProperty<Double> cost)
                                                                     throws ExecutionException,
                                                                            InterruptedException

Blocking version of #shortestPathDijkstraBidirectionalAsync(). Calls #shortestPathDijkstraBidirectionalAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

shortestPathDijkstraBidirectionalAsync

public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> shortestPathDijkstraBidirectionalAsync(PgxGraph graph,
                                                                                        PgxVertex<ID> src,
                                                                                        PgxVertex<ID> dst,
                                                                                        EdgeProperty<Double> cost)

Compute shortest path using a bi-directional Dijkstra variant. Bi-directional Dijkstra is faster than Dijkstra by a constant factor. time complexity: O(N log N) with N = number of vertices

Parameters:: graph - graph; cost - the edge property (of type double) holding the edge costs of the graph; src - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph); dst - destination vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)
Returns:: a PgxPath holding the result

shortestPathFilteredDijkstra

public <ID extends Comparable<ID>> PgxPath<ID> shortestPathFilteredDijkstra(PgxGraph graph,
                                                                   ID srcId,
                                                                   ID dstId,
                                                                   EdgeProperty<Double> cost,
                                                                   GraphFilter filterExpr)
                                                                throws ExecutionException,
                                                                       InterruptedException

Convenience wrapper around shortestPathFilteredDijkstra(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter) taking vertex IDs instead of PgxVertex.

Throws:: ExecutionException; InterruptedException

shortestPathFilteredDijkstra

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> PgxPath<ID> shortestPathFilteredDijkstra(PgxGraph graph,
                                                                                  PgxVertex<ID> src,
                                                                                  PgxVertex<ID> dst,
                                                                                  EdgeProperty<Double> cost,
                                                                                  GraphFilter filterExpr)
                                                                throws ExecutionException,
                                                                       InterruptedException

Blocking version of #shortestPathFilteredDijkstraAsync(). Calls #shortestPathFilteredDijkstraAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

shortestPathFilteredDijkstraAsync

public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> shortestPathFilteredDijkstraAsync(PgxGraph graph,
                                                                                   PgxVertex<ID> src,
                                                                                   PgxVertex<ID> dst,
                                                                                   EdgeProperty<Double> cost,
                                                                                   GraphFilter filterExpr)

Compute shortest path using Dijkstra's algorithm on a filtered graph The filter specified by the given filter expression is applied on each edge during traversal of the graph. If it evaluates to false, the edge is skipped. time complexity: O(N log N) with N = number of vertices

Parameters:: graph - graph; cost - edge property (of type double) holding the edge costs of the graph; src - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph); dst - destination vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph); filterExpr - filter expression that is evaluated during traversal
Returns:: a PgxPath holding the result

shortestPathFilteredDijkstraBidirectional

public <ID extends Comparable<ID>> PgxPath<ID> shortestPathFilteredDijkstraBidirectional(PgxGraph graph,
                                                                                ID srcId,
                                                                                ID dstId,
                                                                                EdgeProperty<Double> cost,
                                                                                GraphFilter filterExpr)
                                                                             throws ExecutionException,
                                                                                    InterruptedException

Convenience wrapper around shortestPathFilteredDijkstraBidirectional(PgxGraph, PgxVertex, PgxVertex, EdgeProperty, GraphFilter) taking vertex IDs instead of PgxVertex.

Throws:: ExecutionException; InterruptedException

shortestPathFilteredDijkstraBidirectional

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> PgxPath<ID> shortestPathFilteredDijkstraBidirectional(PgxGraph graph,
                                                                                               PgxVertex<ID> src,
                                                                                               PgxVertex<ID> dst,
                                                                                               EdgeProperty<Double> cost,
                                                                                               GraphFilter filterExpr)
                                                                             throws ExecutionException,
                                                                                    InterruptedException

Blocking version of #shortestPathFilteredDijkstraBidirectionalAsync(). Calls #shortestPathFilteredDijkstraBidirectionalAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

shortestPathFilteredDijkstraBidirectionalAsync

public <ID extends Comparable<ID>> PgxFuture<PgxPath<ID>> shortestPathFilteredDijkstraBidirectionalAsync(PgxGraph graph,
                                                                                                PgxVertex<ID> src,
                                                                                                PgxVertex<ID> dst,
                                                                                                EdgeProperty<Double> cost,
                                                                                                GraphFilter filterExpr)

Compute shortest path using a bi-directional Dijkstra variant on a filtered graph. Bi-directional Dijkstra is faster than Dijkstra by a constant factor. time complexity: O(N log N) with N = number of vertices

Parameters:: graph - graph; cost - the edge property (of type double) holding the edge costs of the graph; src - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph); dst - destination vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph); filterExpr - filter expression that is evaluated during traversal
Returns:: a PgxPath holding the result

shortestPathHopDist

public <ID extends Comparable<ID>> AllPaths<ID> shortestPathHopDist(PgxGraph graph,
                                                           ID srcId)
                                                        throws ExecutionException,
                                                               InterruptedException

Convenience wrapper around shortestPathHopDist(PgxGraph, PgxVertex) taking a vertex ID instead of PgxVertex.

Throws:: ExecutionException; InterruptedException

shortestPathHopDist

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> AllPaths<ID> shortestPathHopDist(PgxGraph graph,
                                                                          PgxVertex<ID> src)
                                                        throws ExecutionException,
                                                               InterruptedException

Blocking version of #shortestPathHopDistAsync(). Calls #shortestPathHopDistAsync() and waits for returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

shortestPathHopDistAsync
```
public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> shortestPathHopDistAsync(PgxGraph graph,
                                                                           PgxVertex<ID> src)
```
Compute hop-distance from given vertex to every other vertex time complexity: O(E * d) with E = number of edges, d = diameter of graph

Parameters:

graph - graph

src - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)

Returns:

a AllPaths holding the result

shortestPathHopDistReverse

public <ID extends Comparable<ID>> AllPaths<ID> shortestPathHopDistReverse(PgxGraph graph,
                                                                  ID srcId)
                                                               throws ExecutionException,
                                                                      InterruptedException

Convenience wrapper around shortestPathHopDistReverse(PgxGraph, PgxVertex) taking a vertex ID instead of PgxVertex.

Throws:: ExecutionException; InterruptedException

shortestPathHopDistReverse

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> AllPaths<ID> shortestPathHopDistReverse(PgxGraph graph,
                                                                                 PgxVertex<ID> src)
                                                               throws ExecutionException,
                                                                      InterruptedException

Blocking version of #shortestPathHopDistReverseAsync(). Calls #shortestPathHopDistReverseAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

shortestPathHopDistReverseAsync
```
public <ID extends Comparable<ID>> PgxFuture<AllPaths<ID>> shortestPathHopDistReverseAsync(PgxGraph graph,
                                                                                  PgxVertex<ID> src)
```
Compute reverse hop-distance from given vertex to every other vertex time complexity: O(E * d) with E = number of edges, d = diameter of graph

Parameters:

graph - graph

src - source vertex (has to be of type 'PgxVertex<ID>' as specified in loader config of graph)

Returns:

a AllPaths holding the result

toString
```
public String toString()
```
Overrides:

toString in class Object

vertexBetweennessCentrality

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> VertexProperty<ID,Double> vertexBetweennessCentrality(PgxGraph graph)
                                                                             throws ExecutionException,
                                                                                    InterruptedException

Blocking version of #vertexBetweennessCentralityAsync(). Calls #vertexBetweennessCentralityAsync() and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

vertexBetweennessCentralityAsync
```
public <ID extends Comparable<ID>> PgxFuture<VertexProperty<ID,Double>> vertexBetweennessCentralityAsync(PgxGraph graph)
```
Compute vertex betweenness centrality (without considering edge length). The algorithm is implemented by performing BFS from every vertex in the graph. This can be expensive for large graphs. time complexity: O(N * E) with E = number of edges

Parameters:

graph - graph

Returns:

VertexProperty holding the result as a double

wcc
```
@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Partition<ID> wcc(PgxGraph graph)
                                         throws ExecutionException,
                                                InterruptedException
```
Blocking version of #wccAsync(). Calls #wccAsync() and waits for the returned PgxFuture to complete.

Throws:

InterruptedException - if the caller thread gets interrupted while waiting for completion.

ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

wccAsync
```
public <ID extends Comparable<ID>> PgxFuture<Partition<ID>> wccAsync(PgxGraph graph)
```
Find weakly connected components through label propagation time complexity: O(E * D) with E = number of edges, D = diameter of the graph

Parameters:

graph - graph

Returns:

weakly connected components found

whomToFollow

public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> whomToFollow(PgxGraph graph,
                                                                                   ID vertexId,
                                                                                   int max)
                                                                                                       throws ExecutionException,
                                                                                                              InterruptedException

Convenience wrapper around whomToFollow(PgxGraph, PgxVertex, int) taking a vertex ID instead of a PgxVertex.

Throws:: ExecutionException; InterruptedException

whomToFollow

public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> whomToFollow(PgxGraph graph,
                                                                                   ID vertexId,
                                                                                   int max,
                                                                                   int circleOfTrustSize,
                                                                                   int randomWalkSteps,
                                                                                   double randomWalkResetProbablitiy,
                                                                                   double salsaDampingFactor,
                                                                                   int salsaMaxIterations,
                                                                                   double salsaMaxDiff)
                                                                                                       throws ExecutionException,
                                                                                                              InterruptedException

Convenience wrapper around whomToFollow(PgxGraph, PgxVertex, int, int, int, double, double, int, double) taking a vertex ID instead of a PgxVertex.

Throws:: ExecutionException; InterruptedException

whomToFollow

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> whomToFollow(PgxGraph graph,
                                                                                                  PgxVertex<ID> vertex,
                                                                                                  int max)
                                                                                                       throws ExecutionException,
                                                                                                              InterruptedException

Blocking version of whomToFollowAsync(PgxGraph, PgxVertex, int). Calls whomToFollowAsync(PgxGraph, PgxVertex, int) and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

whomToFollow

@Generated(value="src/python/synchronize.py")
public <ID extends Comparable<ID>> Pair<VertexSequence<ID>,VertexSequence<ID>> whomToFollow(PgxGraph graph,
                                                                                                  PgxVertex<ID> vertex,
                                                                                                  int max,
                                                                                                  int circleOfTrustSize,
                                                                                                  int randomWalkSteps,
                                                                                                  double randomWalkResetProbablitiy,
                                                                                                  double salsaDampingFactor,
                                                                                                  int salsaMaxIterations,
                                                                                                  double salsaMaxDiff)
                                                                                                       throws ExecutionException,
                                                                                                              InterruptedException

Blocking version of whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double). Calls whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double) and waits for the returned PgxFuture to complete.

Throws:: InterruptedException - if the caller thread gets interrupted while waiting for completion.; ExecutionException - if any exception occurred during asynchronous execution. The actual exception will be nested.

whomToFollowAsync
```
public <ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> whomToFollowAsync(PgxGraph graph,
                                                                                                   PgxVertex<ID> vertex,
                                                                                                   int max)
```
Convenience method around whomToFollowAsync(PgxGraph, PgxVertex, int, int, int, double, double, int, double) using
- circleOfTrustSize = 500
- randomWalkSteps = 50000
- randomWalkResetProbablitiy = 0.15
- salsaDampingFactor = 0.85
- salsaMaxIterations = 1.10
- salsaMaxDiff = 0.01
Parameters:

graph - the graph

vertex - the vertex

max - maximum amount of recommendations to return

Returns:

a pair holding the vertex sequence 'hubs' as computed by SALSA as first entry and the vertex sequence 'auth' as computed by SALSA as second entry.

whomToFollowAsync

public <ID extends Comparable<ID>> PgxFuture<Pair<VertexSequence<ID>,VertexSequence<ID>>> whomToFollowAsync(PgxGraph graph,
                                                                                                   PgxVertex<ID> vertex,
                                                                                                   int max,
                                                                                                   int circleOfTrustSize,
                                                                                                   int randomWalkSteps,
                                                                                                   double randomWalkResetProbablitiy,
                                                                                                   double salsaDampingFactor,
                                                                                                   int salsaMaxIterations,
                                                                                                   double salsaMaxDiff)

The Who to Follow recommendation algorithm by Twitter, Inc. This algorithm performs a random walk from v and extracts the top visited vertices to determine the circle of trust. It then creates a BipartiteGraph with the circle of trust as left set and runs the salsaAsync(BipartiteGraph, int, double, double, int) recommendation algorithm on that graph to compute the hubs and authorities.

Parameters:: graph - the graph; vertex - the vertex; max - maximum amount of recommendations to return; circleOfTrustSize - maximum size of the circle of trust; randomWalkSteps - the amount of random walk steps; randomWalkResetProbablitiy - likeliness of reset during the random walk (must be between 0.0 and 1.1); salsaDampingFactor - the damping factor for the SALSA algorithm; salsaMaxIterations - the maximum amount of iterations for the SALSA algorithm; salsaMaxDiff - the maximum diff value for the SALSA algorithm
Returns:: a pair holding the vertex sequence 'hubs' as computed by SALSA as first entry and the vertex sequence 'auth' as computed by SALSA as second entry.
See Also:: stanford.edu/~rezab/papers/wtf_overview.pdf

Class Analyst

Method Summary

Methods inherited from class oracle.pgx.api.Destroyable

Methods inherited from class java.lang.Object

Method Detail

approximateVertexBetweennessCentrality

approximateVertexBetweennessCentralityAsync

approximateVertexBetweennessCentralityFromSeeds

approximateVertexBetweennessCentralityFromSeedsAsync

closenessCentralityDoubleLength

closenessCentralityDoubleLengthAsync

closenessCentralityUnitLength

closenessCentralityUnitLengthAsync

communitiesLabelPropagation

communitiesLabelPropagationAsync

countTriangles

countTrianglesAsync

degreeCentrality

degreeCentralityAsync

eigenvectorCentrality

eigenvectorCentralityAsync

fattestPath

fattestPath

fattestPathAsync

getSession

hits

hitsAsync

inDegreeCentrality

inDegreeCentralityAsync

inDegreeDistribution

inDegreeDistributionAsync

outDegreeCentrality

outDegreeCentralityAsync

outDegreeDistribution

outDegreeDistributionAsync

pagerank

pagerankAsync

partitionConductance

partitionConductanceAsync

partitionModularity

partitionModularityAsync

personalizedPagerank

personalizedPagerank

personalizedPagerank

personalizedPagerankAsync

personalizedPagerankAsync

salsa

salsa

salsaAsync

salsaAsync

sccKosaraju

sccKosarajuAsync

sccTarjan

sccTarjanAsync

shortestPathBellmanFord

shortestPathBellmanFord

shortestPathBellmanFordAsync

shortestPathBellmanFordReverse

shortestPathBellmanFordReverse

shortestPathBellmanFordReverseAsync

shortestPathDijkstra

shortestPathDijkstra

shortestPathDijkstraAsync

shortestPathDijkstraBidirectional

shortestPathDijkstraBidirectional

shortestPathDijkstraBidirectionalAsync

shortestPathFilteredDijkstra

shortestPathFilteredDijkstra

shortestPathFilteredDijkstraAsync

shortestPathFilteredDijkstraBidirectional

shortestPathFilteredDijkstraBidirectional

shortestPathFilteredDijkstraBidirectionalAsync

shortestPathHopDist

shortestPathHopDist

shortestPathHopDistAsync

shortestPathHopDistReverse

shortestPathHopDistReverse

shortestPathHopDistReverseAsync

toString

vertexBetweennessCentrality