功能表

1 "gds.allShortestPaths.dijkstra.mutate" "The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph." "gds.allShortestPaths.dijkstra.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)"

2

 "gds.allShortestPaths.dijkstra.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.allShortestPaths.dijkstra.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

3

 "gds.allShortestPaths.dijkstra.stream" "The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph." "gds.allShortestPaths.dijkstra.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (index :: INTEGER?, sourceNode :: INTEGER?, targetNode :: INTEGER?, totalCost :: FLOAT?, nodeIds :: LIST? OF INTEGER?, costs :: LIST? OF FLOAT?, path :: PATH?)" "procedure"

4

 "gds.allShortestPaths.dijkstra.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.allShortestPaths.dijkstra.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

5

 "gds.allShortestPaths.dijkstra.write" "The Dijkstra shortest path algorithm computes the shortest (weighted) path between one node and any other node in the graph." "gds.allShortestPaths.dijkstra.write(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

6

 "gds.allShortestPaths.dijkstra.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.allShortestPaths.dijkstra.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

7

 "gds.alpha.allShortestPaths.stream" "The All Pairs Shortest Path (APSP) calculates the shortest (weighted) path between all pairs of nodes." "gds.alpha.allShortestPaths.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (sourceNodeId :: INTEGER?, targetNodeId :: INTEGER?, distance :: FLOAT?)" "procedure"

8

 "gds.alpha.bfs.stream" "BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level." "gds.alpha.bfs.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (startNodeId :: INTEGER?, nodeIds :: LIST? OF INTEGER?, path :: PATH?)" "procedure"

9

 "gds.alpha.closeness.harmonic.stream" "Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph." "gds.alpha.closeness.harmonic.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, centrality :: FLOAT?)" "procedure"

10

 "gds.alpha.closeness.harmonic.write" "Harmonic centrality is a way of detecting nodes that are able to spread information very efficiently through a graph." "gds.alpha.closeness.harmonic.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, writeProperty :: STRING?, centralityDistribution :: MAP?)" "procedure"

11

 "gds.alpha.closeness.stream" "Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph." "gds.alpha.closeness.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, centrality :: FLOAT?)" "procedure"

12

 "gds.alpha.closeness.write" "Closeness centrality is a way of detecting nodes that are able to spread information very efficiently through a graph." "gds.alpha.closeness.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, writeProperty :: STRING?, centralityDistribution :: MAP?)" "procedure"

13

 "gds.alpha.collapsePath.mutate" "" "gds.alpha.collapsePath.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, mutateMillis :: INTEGER?, relationshipsWritten :: INTEGER?, configuration :: MAP?)" "procedure"

14

 "gds.alpha.dfs.stream" "BFS is a traversal algorithm, which explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level." "gds.alpha.dfs.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (startNodeId :: INTEGER?, nodeIds :: LIST? OF INTEGER?, path :: PATH?)" "procedure"

15

 "gds.alpha.hits.mutate" "Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes" "gds.alpha.hits.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

16

 "gds.alpha.hits.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.alpha.hits.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

17

 "gds.alpha.hits.stats" "Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes" "gds.alpha.hits.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (ranIterations :: INTEGER?, didConverge :: BOOLEAN?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

18

 "gds.alpha.hits.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.alpha.hits.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

19

 "gds.alpha.hits.stream" "Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes" "gds.alpha.hits.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, values :: MAP?)" "procedure"

20

 "gds.alpha.hits.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.alpha.hits.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

21

 "gds.alpha.hits.write" "Hyperlink-Induced Topic Search (HITS) is a link analysis algorithm that rates nodes" "gds.alpha.hits.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

22

 "gds.alpha.hits.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.alpha.hits.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

23

 "gds.alpha.influenceMaximization.celf.stream" "The Cost Effective Lazy Forward (CELF) algorithm aims to find k nodes that maximize the expected spread of influence in the network." "gds.alpha.influenceMaximization.celf.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, spread :: FLOAT?)" "procedure"

24

 "gds.alpha.influenceMaximization.greedy.stream" "The Greedy algorithm aims to find k nodes that maximize the expected spread of influence in the network." "gds.alpha.influenceMaximization.greedy.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, spread :: FLOAT?)" "procedure"

25

 "gds.alpha.ml.ann.stream" "The Approximate Nearest Neighbors algorithm constructs a k-Nearest Neighbors graph for a set of objects based on a provided similarity function." "gds.alpha.ml.ann.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (item1 :: INTEGER?, item2 :: INTEGER?, count1 :: INTEGER?, count2 :: INTEGER?, intersection :: INTEGER?, similarity :: FLOAT?, bidirectional :: BOOLEAN?, reversed :: BOOLEAN?)" "procedure"

26

 "gds.alpha.ml.ann.write" "The Approximate Nearest Neighbors algorithm constructs a k-Nearest Neighbors graph for a set of objects based on a provided similarity function." "gds.alpha.ml.ann.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, similarityPairs :: INTEGER?, computations :: INTEGER?, writeRelationshipType :: STRING?, writeProperty :: STRING?, min :: FLOAT?, max :: FLOAT?, mean :: FLOAT?, stdDev :: FLOAT?, p25 :: FLOAT?, p50 :: FLOAT?, p75 :: FLOAT?, p90 :: FLOAT?, p95 :: FLOAT?, p99 :: FLOAT?, p999 :: FLOAT?, p100 :: FLOAT?, iterations :: INTEGER?, scanRate :: FLOAT?)" "procedure"

27

 "gds.alpha.ml.linkPrediction.predict.mutate" "Predicts relationships for all node pairs based on a previously trained link prediction model." "gds.alpha.ml.linkPrediction.predict.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

28

 "gds.alpha.ml.linkPrediction.predict.mutate.estimate" "Estimates memory for applying a linkPrediction model" "gds.alpha.ml.linkPrediction.predict.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

29

 "gds.alpha.ml.linkPrediction.predict.stream" "Predicts relationships for all node pairs based on a previously trained link prediction model." "gds.alpha.ml.linkPrediction.predict.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (node1 :: INTEGER?, node2 :: INTEGER?, probability :: FLOAT?)" "procedure"

30

 "gds.alpha.ml.linkPrediction.predict.stream.estimate" "Estimates memory for applying a linkPrediction model" "gds.alpha.ml.linkPrediction.predict.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

31

 "gds.alpha.ml.linkPrediction.predict.write" "Predicts relationships for all node pairs based on a previously trained link prediction model." "gds.alpha.ml.linkPrediction.predict.write(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

32

 "gds.alpha.ml.linkPrediction.predict.write.estimate" "Estimates memory for applying a linkPrediction model" "gds.alpha.ml.linkPrediction.predict.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

33

 "gds.alpha.ml.linkPrediction.train" "Trains a link prediction model" "gds.alpha.ml.linkPrediction.train(graphName :: ANY?, configuration = {} :: MAP?) :: (trainMillis :: INTEGER?, modelInfo :: MAP?, configuration :: MAP?)" "procedure"

34

 "gds.alpha.ml.linkPrediction.train.estimate" "Estimates memory for training a link prediction model" "gds.alpha.ml.linkPrediction.train.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

35

 "gds.alpha.ml.nodeClassification.predict.mutate" "Predicts classes for all nodes based on a previously trained model" "gds.alpha.ml.nodeClassification.predict.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

36

 "gds.alpha.ml.nodeClassification.predict.mutate.estimate" "Predicts classes for all nodes based on a previously trained model" "gds.alpha.ml.nodeClassification.predict.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

37

 "gds.alpha.ml.nodeClassification.predict.stream" "Predicts classes for all nodes based on a previously trained model" "gds.alpha.ml.nodeClassification.predict.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, predictedClass :: INTEGER?, predictedProbabilities :: LIST? OF FLOAT?)" "procedure"

38

 "gds.alpha.ml.nodeClassification.predict.stream.estimate" "Predicts classes for all nodes based on a previously trained model" "gds.alpha.ml.nodeClassification.predict.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

39

 "gds.alpha.ml.nodeClassification.predict.write" "Predicts classes for all nodes based on a previously trained model" "gds.alpha.ml.nodeClassification.predict.write(graphName :: ANY?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

40

 "gds.alpha.ml.nodeClassification.predict.write.estimate" "Predicts classes for all nodes based on a previously trained model" "gds.alpha.ml.nodeClassification.predict.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

41

 "gds.alpha.ml.nodeClassification.train" "Trains a node classification model" "gds.alpha.ml.nodeClassification.train(graphName :: ANY?, configuration = {} :: MAP?) :: (trainMillis :: INTEGER?, modelInfo :: MAP?, configuration :: MAP?)" "procedure"

42

 "gds.alpha.ml.nodeClassification.train.estimate" "Trains a node classification model" "gds.alpha.ml.nodeClassification.train.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

43

 "gds.alpha.ml.splitRelationships.mutate" "Splits a graph into holdout and remaining relationship types and adds them to the in-memory graph." "gds.alpha.ml.splitRelationships.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, mutateMillis :: INTEGER?, relationshipsWritten :: INTEGER?, configuration :: MAP?)" "procedure"

44

 "gds.alpha.model.delete" "Deletes a stored model from disk." "gds.alpha.model.delete(modelName :: STRING?) :: (modelName :: STRING?, deleteMillis :: INTEGER?)" "procedure"

45

 "gds.alpha.model.load" "Load a stored model into main memory." "gds.alpha.model.load(modelName :: STRING?) :: (modelName :: STRING?, loadMillis :: INTEGER?)" "procedure"

46

 "gds.alpha.model.publish" "Make a trained model accessible by all users" "gds.alpha.model.publish(modelName :: STRING?) :: (modelInfo :: MAP?, trainConfig :: MAP?, graphSchema :: MAP?, loaded :: BOOLEAN?, stored :: BOOLEAN?, creationTime :: DATETIME?, shared :: BOOLEAN?)" "procedure"

47

 "gds.alpha.model.store" "Store the selected model to disk." "gds.alpha.model.store(modelName :: STRING?) :: (modelName :: STRING?, storeMillis :: INTEGER?)" "procedure"

48

 "gds.alpha.randomWalk.stream" "Random Walk is an algorithm that provides random paths in a graph. It’s similar to how a drunk person traverses a city." "gds.alpha.randomWalk.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (startNodeId :: INTEGER?, nodeIds :: LIST? OF INTEGER?, path :: PATH?)" "procedure"

49

 "gds.alpha.scaleProperties.mutate" "Scale node properties" "gds.alpha.scaleProperties.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

50

 "gds.alpha.scaleProperties.stream" "Scale node properties" "gds.alpha.scaleProperties.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, scaledProperty :: LIST? OF FLOAT?)" "procedure"

51

 "gds.alpha.scc.stream" "The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component." "gds.alpha.scc.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, componentId :: INTEGER?)" "procedure"

52

 "gds.alpha.scc.write" "The SCC algorithm finds sets of connected nodes in an directed graph, where all nodes in the same set form a connected component." "gds.alpha.scc.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, nodes :: INTEGER?, communityCount :: INTEGER?, setCount :: INTEGER?, minSetSize :: INTEGER?, maxSetSize :: INTEGER?, p1 :: INTEGER?, p5 :: INTEGER?, p10 :: INTEGER?, p25 :: INTEGER?, p50 :: INTEGER?, p75 :: INTEGER?, p90 :: INTEGER?, p95 :: INTEGER?, p99 :: INTEGER?, p100 :: INTEGER?, writeProperty :: STRING?)" "procedure"

53

 "gds.alpha.shortestPath.deltaStepping.stream" "Delta-Stepping is a non-negative single source shortest paths (NSSSP) algorithm." "gds.alpha.shortestPath.deltaStepping.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, distance :: FLOAT?)" "procedure"

54

 "gds.alpha.shortestPath.deltaStepping.write" "Delta-Stepping is a non-negative single source shortest paths (NSSSP) algorithm." "gds.alpha.shortestPath.deltaStepping.write(graphName :: ANY?, configuration = {} :: MAP?) :: (loadDuration :: INTEGER?, evalDuration :: INTEGER?, writeDuration :: INTEGER?, nodeCount :: INTEGER?)" "procedure"

55

 "gds.alpha.similarity.cosine.stats" "Cosine-similarity is an algorithm for finding similar nodes based on the cosine similarity metric." "gds.alpha.similarity.cosine.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, sourceNodes :: INTEGER?, targetNodes :: INTEGER?, similarityPairs :: INTEGER?, computations :: INTEGER?, min :: FLOAT?, max :: FLOAT?, mean :: FLOAT?, stdDev :: FLOAT?, p25 :: FLOAT?, p50 :: FLOAT?, p75 :: FLOAT?, p90 :: FLOAT?, p95 :: FLOAT?, p99 :: FLOAT?, p999 :: FLOAT?, p100 :: FLOAT?)" "procedure"

56

 "gds.alpha.similarity.cosine.stream" "Cosine-similarity is an algorithm for finding similar nodes based on the cosine similarity metric." "gds.alpha.similarity.cosine.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (item1 :: INTEGER?, item2 :: INTEGER?, count1 :: INTEGER?, count2 :: INTEGER?, intersection :: INTEGER?, similarity :: FLOAT?, bidirectional :: BOOLEAN?, reversed :: BOOLEAN?)" "procedure"

57

 "gds.alpha.similarity.cosine.write" "Cosine-similarity is an algorithm for finding similar nodes based on the cosine similarity metric." "gds.alpha.similarity.cosine.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, sourceNodes :: INTEGER?, targetNodes :: INTEGER?, similarityPairs :: INTEGER?, computations :: INTEGER?, writeRelationshipType :: STRING?, writeProperty :: STRING?, min :: FLOAT?, max :: FLOAT?, mean :: FLOAT?, stdDev :: FLOAT?, p25 :: FLOAT?, p50 :: FLOAT?, p75 :: FLOAT?, p90 :: FLOAT?, p95 :: FLOAT?, p99 :: FLOAT?, p999 :: FLOAT?, p100 :: FLOAT?)" "procedure"

58

 "gds.alpha.similarity.euclidean.stats" "Euclidean-similarity is an algorithm for finding similar nodes based on the euclidean distance." "gds.alpha.similarity.euclidean.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, sourceNodes :: INTEGER?, targetNodes :: INTEGER?, similarityPairs :: INTEGER?, computations :: INTEGER?, min :: FLOAT?, max :: FLOAT?, mean :: FLOAT?, stdDev :: FLOAT?, p25 :: FLOAT?, p50 :: FLOAT?, p75 :: FLOAT?, p90 :: FLOAT?, p95 :: FLOAT?, p99 :: FLOAT?, p999 :: FLOAT?, p100 :: FLOAT?)" "procedure"

59

 "gds.alpha.similarity.euclidean.stream" "Euclidean-similarity is an algorithm for finding similar nodes based on the euclidean distance." "gds.alpha.similarity.euclidean.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (item1 :: INTEGER?, item2 :: INTEGER?, count1 :: INTEGER?, count2 :: INTEGER?, intersection :: INTEGER?, similarity :: FLOAT?, bidirectional :: BOOLEAN?, reversed :: BOOLEAN?)" "procedure"

60

 "gds.alpha.similarity.euclidean.write" "Euclidean-similarity is an algorithm for finding similar nodes based on the euclidean distance." "gds.alpha.similarity.euclidean.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, sourceNodes :: INTEGER?, targetNodes :: INTEGER?, similarityPairs :: INTEGER?, computations :: INTEGER?, writeRelationshipType :: STRING?, writeProperty :: STRING?, min :: FLOAT?, max :: FLOAT?, mean :: FLOAT?, stdDev :: FLOAT?, p25 :: FLOAT?, p50 :: FLOAT?, p75 :: FLOAT?, p90 :: FLOAT?, p95 :: FLOAT?, p99 :: FLOAT?, p999 :: FLOAT?, p100 :: FLOAT?)" "procedure"

61

 "gds.alpha.similarity.overlap.stats" "Overlap-similarity is an algorithm for finding similar nodes based on the overlap coefficient." "gds.alpha.similarity.overlap.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, sourceNodes :: INTEGER?, targetNodes :: INTEGER?, similarityPairs :: INTEGER?, computations :: INTEGER?, min :: FLOAT?, max :: FLOAT?, mean :: FLOAT?, stdDev :: FLOAT?, p25 :: FLOAT?, p50 :: FLOAT?, p75 :: FLOAT?, p90 :: FLOAT?, p95 :: FLOAT?, p99 :: FLOAT?, p999 :: FLOAT?, p100 :: FLOAT?)" "procedure"

62

 "gds.alpha.similarity.overlap.stream" "Overlap-similarity is an algorithm for finding similar nodes based on the overlap coefficient." "gds.alpha.similarity.overlap.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (item1 :: INTEGER?, item2 :: INTEGER?, count1 :: INTEGER?, count2 :: INTEGER?, intersection :: INTEGER?, similarity :: FLOAT?, bidirectional :: BOOLEAN?, reversed :: BOOLEAN?)" "procedure"

63

 "gds.alpha.similarity.overlap.write" "Overlap-similarity is an algorithm for finding similar nodes based on the overlap coefficient." "gds.alpha.similarity.overlap.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, sourceNodes :: INTEGER?, targetNodes :: INTEGER?, similarityPairs :: INTEGER?, computations :: INTEGER?, writeRelationshipType :: STRING?, writeProperty :: STRING?, min :: FLOAT?, max :: FLOAT?, mean :: FLOAT?, stdDev :: FLOAT?, p25 :: FLOAT?, p50 :: FLOAT?, p75 :: FLOAT?, p90 :: FLOAT?, p95 :: FLOAT?, p99 :: FLOAT?, p999 :: FLOAT?, p100 :: FLOAT?)" "procedure"

64

 "gds.alpha.similarity.pearson.stats" "Pearson-similarity is an algorithm for finding similar nodes based on the pearson correlation coefficient." "gds.alpha.similarity.pearson.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, sourceNodes :: INTEGER?, targetNodes :: INTEGER?, similarityPairs :: INTEGER?, computations :: INTEGER?, min :: FLOAT?, max :: FLOAT?, mean :: FLOAT?, stdDev :: FLOAT?, p25 :: FLOAT?, p50 :: FLOAT?, p75 :: FLOAT?, p90 :: FLOAT?, p95 :: FLOAT?, p99 :: FLOAT?, p999 :: FLOAT?, p100 :: FLOAT?)" "procedure"

65

 "gds.alpha.similarity.pearson.stream" "Pearson-similarity is an algorithm for finding similar nodes based on the pearson correlation coefficient." "gds.alpha.similarity.pearson.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (item1 :: INTEGER?, item2 :: INTEGER?, count1 :: INTEGER?, count2 :: INTEGER?, intersection :: INTEGER?, similarity :: FLOAT?, bidirectional :: BOOLEAN?, reversed :: BOOLEAN?)" "procedure"

66

 "gds.alpha.similarity.pearson.write" "Pearson-similarity is an algorithm for finding similar nodes based on the pearson correlation coefficient." "gds.alpha.similarity.pearson.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodes :: INTEGER?, sourceNodes :: INTEGER?, targetNodes :: INTEGER?, similarityPairs :: INTEGER?, computations :: INTEGER?, writeRelationshipType :: STRING?, writeProperty :: STRING?, min :: FLOAT?, max :: FLOAT?, mean :: FLOAT?, stdDev :: FLOAT?, p25 :: FLOAT?, p50 :: FLOAT?, p75 :: FLOAT?, p90 :: FLOAT?, p95 :: FLOAT?, p99 :: FLOAT?, p999 :: FLOAT?, p100 :: FLOAT?)" "procedure"

67

 "gds.alpha.sllpa.mutate" "The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph." "gds.alpha.sllpa.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

68

 "gds.alpha.sllpa.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.alpha.sllpa.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

69

 "gds.alpha.sllpa.stats" "The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph." "gds.alpha.sllpa.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (ranIterations :: INTEGER?, didConverge :: BOOLEAN?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

70

 "gds.alpha.sllpa.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.alpha.sllpa.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

71

 "gds.alpha.sllpa.stream" "The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph." "gds.alpha.sllpa.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, values :: MAP?)" "procedure"

72

 "gds.alpha.sllpa.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.alpha.sllpa.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

73

 "gds.alpha.sllpa.write" "The Speaker Listener Label Propagation algorithm is a fast algorithm for finding overlapping communities in a graph." "gds.alpha.sllpa.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

74

 "gds.alpha.sllpa.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.alpha.sllpa.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

75

 "gds.alpha.spanningTree.kmax.write" "The maximum weight spanning tree (MST) starts from a given node, and finds all its reachable nodes and the set of relationships that connect the nodes together with the maximum possible weight." "gds.alpha.spanningTree.kmax.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, effectiveNodeCount :: INTEGER?)" "procedure"

76

 "gds.alpha.spanningTree.kmin.write" "The minimum weight spanning tree (MST) starts from a given node, and finds all its reachable nodes and the set of relationships that connect the nodes together with the minimum possible weight." "gds.alpha.spanningTree.kmin.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, effectiveNodeCount :: INTEGER?)" "procedure"

77

 "gds.alpha.spanningTree.maximum.write" "Maximum weight spanning tree visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is maximized." "gds.alpha.spanningTree.maximum.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, effectiveNodeCount :: INTEGER?)" "procedure"

78

 "gds.alpha.spanningTree.minimum.write" "Minimum weight spanning tree visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is minimized." "gds.alpha.spanningTree.minimum.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, effectiveNodeCount :: INTEGER?)" "procedure"

79

 "gds.alpha.spanningTree.write" "Minimum weight spanning tree visits all nodes that are in the same connected component as the starting node, and returns a spanning tree of all nodes in the component where the total weight of the relationships is minimized." "gds.alpha.spanningTree.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, effectiveNodeCount :: INTEGER?)" "procedure"

80

 "gds.alpha.triangles" "Triangles streams the nodeIds of each triangle in the graph." "gds.alpha.triangles(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeA :: INTEGER?, nodeB :: INTEGER?, nodeC :: INTEGER?)" "procedure"

81

 "gds.articleRank.mutate" "Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes." "gds.articleRank.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (mutateMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

82

 "gds.articleRank.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.articleRank.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

83

 "gds.articleRank.stats" "Executes the algorithm and returns result statistics without writing the result to Neo4j." "gds.articleRank.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (ranIterations :: INTEGER?, didConverge :: BOOLEAN?, centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

84

 "gds.articleRank.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.articleRank.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

85

 "gds.articleRank.stream" "Article Rank is a variant of the Page Rank algorithm, which measures the transitive influence or connectivity of nodes." "gds.articleRank.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, score :: FLOAT?)" "procedure"

86

 "gds.articleRank.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.articleRank.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

87

 "gds.articleRank.write" "Page Rank is an algorithm that measures the transitive influence or connectivity of nodes." "gds.articleRank.write(graphName :: ANY?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

88

 "gds.articleRank.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.articleRank.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

89

 "gds.beta.fastRPExtended.mutate" "The FastRPExtended algorithm produces node embeddings via random projection of nodes and their properties" "gds.beta.fastRPExtended.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, mutateMillis :: INTEGER?, nodeCount :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

90

 "gds.beta.fastRPExtended.mutate.estimate" "The FastRPExtended algorithm produces node embeddings via random projection of nodes and their properties" "gds.beta.fastRPExtended.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

91

 "gds.beta.fastRPExtended.stats" "The FastRPExtended algorithm produces node embeddings via random projection of nodes and their properties" "gds.beta.fastRPExtended.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeCount :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

92

 "gds.beta.fastRPExtended.stats.estimate" "The FastRPExtended algorithm produces node embeddings via random projection of nodes and their properties" "gds.beta.fastRPExtended.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

93

 "gds.beta.fastRPExtended.stream" "The FastRPExtended algorithm produces node embeddings via random projection of nodes and their properties" "gds.beta.fastRPExtended.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, embedding :: LIST? OF NUMBER?)" "procedure"

94

 "gds.beta.fastRPExtended.stream.estimate" "The FastRPExtended algorithm produces node embeddings via random projection of nodes and their properties" "gds.beta.fastRPExtended.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

95

 "gds.beta.fastRPExtended.write" "The FastRPExtended algorithm produces node embeddings via random projection of nodes and their properties" "gds.beta.fastRPExtended.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeCount :: INTEGER?, nodePropertiesWritten :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

96

 "gds.beta.fastRPExtended.write.estimate" "The FastRPExtended algorithm produces node embeddings via random projection of nodes and their properties" "gds.beta.fastRPExtended.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

97

 "gds.beta.graph.create.subgraph" "Creates a named graph in the catalog for use by algorithms." "gds.beta.graph.create.subgraph(graphName :: STRING?, fromGraphName :: STRING?, nodeFilter :: STRING?, relationshipFilter :: STRING?, configuration = {} :: MAP?) :: (fromGraphName :: STRING?, nodeFilter :: STRING?, relationshipFilter :: STRING?, graphName :: STRING?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, createMillis :: INTEGER?)" "procedure"

98

 "gds.beta.graph.export.csv" "Exports a named graph to CSV files." "gds.beta.graph.export.csv(graphName :: STRING?, configuration = {} :: MAP?) :: (exportName :: STRING?, graphName :: STRING?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, relationshipTypeCount :: INTEGER?, nodePropertyCount :: INTEGER?, relationshipPropertyCount :: INTEGER?, writeMillis :: INTEGER?)" "procedure"

99

 "gds.beta.graph.export.csv.estimate" "Estimate the required disk space for exporting a named graph to CSV files." "gds.beta.graph.export.csv.estimate(graphName :: STRING?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

100

 "gds.beta.graph.generate" "" "gds.beta.graph.generate(graphName :: STRING?, nodeCount :: INTEGER?, averageDegree :: INTEGER?, configuration = {} :: MAP?) :: (name :: STRING?, nodes :: INTEGER?, relationships :: INTEGER?, generateMillis :: INTEGER?, relationshipSeed :: INTEGER?, averageDegree :: FLOAT?, relationshipDistribution :: ANY?, relationshipProperty :: ANY?)" "procedure"

101

 "gds.beta.graphSage.mutate" "The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods." "gds.beta.graphSage.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, mutateMillis :: INTEGER?, nodeCount :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

102

 "gds.beta.graphSage.mutate.estimate" "The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods." "gds.beta.graphSage.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

103

 "gds.beta.graphSage.stream" "The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods." "gds.beta.graphSage.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, embedding :: LIST? OF FLOAT?)" "procedure"

104

 "gds.beta.graphSage.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.graphSage.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

105

 "gds.beta.graphSage.train" "The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods." "gds.beta.graphSage.train(graphName :: ANY?, configuration = {} :: MAP?) :: (graphName :: STRING?, graphCreateConfig :: MAP?, modelInfo :: MAP?, configuration :: MAP?, trainMillis :: INTEGER?)" "procedure"

106

 "gds.beta.graphSage.train.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.graphSage.train.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

107

 "gds.beta.graphSage.write" "The GraphSage algorithm inductively computes embeddings for nodes based on a their features and neighborhoods." "gds.beta.graphSage.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeCount :: INTEGER?, nodePropertiesWritten :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

108

 "gds.beta.graphSage.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.graphSage.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

109

 "gds.beta.k1coloring.mutate" "The K-1 Coloring algorithm assigns a color to every node in the graph." "gds.beta.k1coloring.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, mutateMillis :: INTEGER?, nodeCount :: INTEGER?, colorCount :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, configuration :: MAP?)" "procedure"

110

 "gds.beta.k1coloring.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.k1coloring.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

111

 "gds.beta.k1coloring.stats" "The K-1 Coloring algorithm assigns a color to every node in the graph." "gds.beta.k1coloring.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, nodeCount :: INTEGER?, colorCount :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, configuration :: MAP?)" "procedure"

112

 "gds.beta.k1coloring.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.k1coloring.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

113

 "gds.beta.k1coloring.stream" "The K-1 Coloring algorithm assigns a color to every node in the graph." "gds.beta.k1coloring.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, color :: INTEGER?)" "procedure"

114

 "gds.beta.k1coloring.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.k1coloring.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

115

 "gds.beta.k1coloring.write" "The K-1 Coloring algorithm assigns a color to every node in the graph." "gds.beta.k1coloring.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, nodeCount :: INTEGER?, colorCount :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, configuration :: MAP?)" "procedure"

116

 "gds.beta.k1coloring.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.k1coloring.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

117

 "gds.beta.knn.mutate" "The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes.KNN computes distances based on the similarity of node properties" "gds.beta.knn.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, nodesCompared :: INTEGER?, relationshipsWritten :: INTEGER?, similarityDistribution :: MAP?, configuration :: MAP?)" "procedure"

118

 "gds.beta.knn.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.knn.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

119

 "gds.beta.knn.stats" "Executes the algorithm and returns result statistics without writing the result to Neo4j." "gds.beta.knn.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, nodesCompared :: INTEGER?, similarityPairs :: INTEGER?, similarityDistribution :: MAP?, configuration :: MAP?)" "procedure"

120

 "gds.beta.knn.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.knn.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

121

 "gds.beta.knn.stream" "The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes.KNN computes distances based on the similarity of node properties" "gds.beta.knn.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (node1 :: INTEGER?, node2 :: INTEGER?, similarity :: FLOAT?)" "procedure"

122

 "gds.beta.knn.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.knn.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

123

 "gds.beta.knn.write" "The k-nearest neighbor graph algorithm constructs relationships between nodes if the distance between two nodes is among the k nearest distances compared to other nodes.KNN computes distances based on the similarity of node properties" "gds.beta.knn.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, nodesCompared :: INTEGER?, relationshipsWritten :: INTEGER?, similarityDistribution :: MAP?, configuration :: MAP?)" "procedure"

124

 "gds.beta.knn.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.knn.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

125

 "gds.beta.listProgress" "" "gds.beta.listProgress() :: (id :: STRING?, taskName :: STRING?, message :: STRING?)" "procedure"

126

 "gds.beta.model.drop" "Drops a loaded model and frees up the resources it occupies." "gds.beta.model.drop(modelName :: STRING?) :: (modelInfo :: MAP?, trainConfig :: MAP?, graphSchema :: MAP?, loaded :: BOOLEAN?, stored :: BOOLEAN?, creationTime :: DATETIME?, shared :: BOOLEAN?)" "procedure"

127

 "gds.beta.model.exists" "Checks if a given model exists in the model catalog." "gds.beta.model.exists(modelName :: STRING?) :: (modelName :: STRING?, modelType :: STRING?, exists :: BOOLEAN?)" "procedure"

128

 "gds.beta.model.list" "Lists all models contained in the model catalog." "gds.beta.model.list(modelName = __NO_VALUE :: STRING?) :: (modelInfo :: MAP?, trainConfig :: MAP?, graphSchema :: MAP?, loaded :: BOOLEAN?, stored :: BOOLEAN?, creationTime :: DATETIME?, shared :: BOOLEAN?)" "procedure"

129

 "gds.beta.modularityOptimization.mutate" "The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity." "gds.beta.modularityOptimization.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, nodes :: INTEGER?, didConverge :: BOOLEAN?, ranIterations :: INTEGER?, modularity :: FLOAT?, communityCount :: INTEGER?, communityDistribution :: MAP?, configuration :: MAP?)" "procedure"

130

 "gds.beta.modularityOptimization.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.modularityOptimization.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

131

 "gds.beta.modularityOptimization.stream" "The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity." "gds.beta.modularityOptimization.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, communityId :: INTEGER?)" "procedure"

132

 "gds.beta.modularityOptimization.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.modularityOptimization.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

133

 "gds.beta.modularityOptimization.write" "The Modularity Optimization algorithm groups the nodes in the graph by optimizing the graphs modularity." "gds.beta.modularityOptimization.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, nodes :: INTEGER?, didConverge :: BOOLEAN?, ranIterations :: INTEGER?, modularity :: FLOAT?, communityCount :: INTEGER?, communityDistribution :: MAP?, configuration :: MAP?)" "procedure"

134

 "gds.beta.modularityOptimization.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.modularityOptimization.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

135

 "gds.beta.node2vec.mutate" "The Node2Vec algorithm computes embeddings for nodes based on random walks." "gds.beta.node2vec.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeCount :: INTEGER?, nodePropertiesWritten :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

136

 "gds.beta.node2vec.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.node2vec.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

137

 "gds.beta.node2vec.stream" "The Node2Vec algorithm computes embeddings for nodes based on random walks." "gds.beta.node2vec.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, embedding :: LIST? OF FLOAT?)" "procedure"

138

 "gds.beta.node2vec.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.node2vec.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

139

 "gds.beta.node2vec.write" "The Node2Vec algorithm computes embeddings for nodes based on random walks." "gds.beta.node2vec.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeCount :: INTEGER?, nodePropertiesWritten :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

140

 "gds.beta.node2vec.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.beta.node2vec.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

141

 "gds.betweenness.mutate" "Betweenness centrality measures the relative information flow that passes through a node." "gds.betweenness.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, mutateMillis :: INTEGER?, centralityDistribution :: MAP?, minimumScore :: FLOAT?, maximumScore :: FLOAT?, scoreSum :: FLOAT?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

142

 "gds.betweenness.mutate.estimate" "Betweenness centrality measures the relative information flow that passes through a node." "gds.betweenness.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

143

 "gds.betweenness.stats" "Betweenness centrality measures the relative information flow that passes through a node." "gds.betweenness.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (centralityDistribution :: MAP?, minimumScore :: FLOAT?, maximumScore :: FLOAT?, scoreSum :: FLOAT?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

144

 "gds.betweenness.stats.estimate" "Betweenness centrality measures the relative information flow that passes through a node." "gds.betweenness.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

145

 "gds.betweenness.stream" "Betweenness centrality measures the relative information flow that passes through a node." "gds.betweenness.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, score :: FLOAT?)" "procedure"

146

 "gds.betweenness.stream.estimate" "Betweenness centrality measures the relative information flow that passes through a node." "gds.betweenness.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

147

 "gds.betweenness.write" "Betweenness centrality measures the relative information flow that passes through a node." "gds.betweenness.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, writeMillis :: INTEGER?, centralityDistribution :: MAP?, minimumScore :: FLOAT?, maximumScore :: FLOAT?, scoreSum :: FLOAT?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

148

 "gds.betweenness.write.estimate" "Betweenness centrality measures the relative information flow that passes through a node." "gds.betweenness.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

149

 "gds.debug.sysInfo" "" "gds.debug.sysInfo() :: (key :: STRING?, value :: ANY?)" "procedure"

150

 "gds.degree.mutate" "Degree centrality measures the number of incoming and outgoing relationships from a node." "gds.degree.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, centralityDistribution :: MAP?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

151

 "gds.degree.mutate.estimate" "Degree centrality measures the number of incoming and outgoing relationships from a node." "gds.degree.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

152

 "gds.degree.stats" "Degree centrality measures the number of incoming and outgoing relationships from a node." "gds.degree.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

153

 "gds.degree.stats.estimate" "Degree centrality measures the number of incoming and outgoing relationships from a node." "gds.degree.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

154

 "gds.degree.stream" "Degree centrality measures the number of incoming and outgoing relationships from a node." "gds.degree.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, score :: FLOAT?)" "procedure"

155

 "gds.degree.stream.estimate" "Degree centrality measures the number of incoming and outgoing relationships from a node." "gds.degree.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

156

 "gds.degree.write" "Degree centrality measures the number of incoming and outgoing relationships from a node." "gds.degree.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, centralityDistribution :: MAP?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

157

 "gds.degree.write.estimate" "Degree centrality measures the number of incoming and outgoing relationships from a node." "gds.degree.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

158

 "gds.eigenvector.mutate" "Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes." "gds.eigenvector.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (mutateMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

159

 "gds.eigenvector.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.eigenvector.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

160

 "gds.eigenvector.stats" "Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes." "gds.eigenvector.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (ranIterations :: INTEGER?, didConverge :: BOOLEAN?, centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

161

 "gds.eigenvector.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.eigenvector.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

162

 "gds.eigenvector.stream" "Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes." "gds.eigenvector.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, score :: FLOAT?)" "procedure"

163

 "gds.eigenvector.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.eigenvector.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

164

 "gds.eigenvector.write" "Eigenvector Centrality is an algorithm that measures the transitive influence or connectivity of nodes." "gds.eigenvector.write(graphName :: ANY?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

165

 "gds.eigenvector.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.eigenvector.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

166

 "gds.fastRP.mutate" "Random Projection produces node embeddings via the fastrp algorithm" "gds.fastRP.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (nodePropertiesWritten :: INTEGER?, mutateMillis :: INTEGER?, nodeCount :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

167

 "gds.fastRP.mutate.estimate" "Random Projection produces node embeddings via the fastrp algorithm" "gds.fastRP.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

168

 "gds.fastRP.stats" "Random Projection produces node embeddings via the fastrp algorithm" "gds.fastRP.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeCount :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

169

 "gds.fastRP.stats.estimate" "Random Projection produces node embeddings via the fastrp algorithm" "gds.fastRP.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

170

 "gds.fastRP.stream" "Random Projection produces node embeddings via the fastrp algorithm" "gds.fastRP.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, embedding :: LIST? OF FLOAT?)" "procedure"

171

 "gds.fastRP.stream.estimate" "Random Projection produces node embeddings via the fastrp algorithm" "gds.fastRP.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

172

 "gds.fastRP.write" "Random Projection produces node embeddings via the fastrp algorithm" "gds.fastRP.write(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeCount :: INTEGER?, nodePropertiesWritten :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

173

 "gds.fastRP.write.estimate" "Random Projection produces node embeddings via the fastrp algorithm" "gds.fastRP.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

174

 "gds.graph.create" "Creates a named graph in the catalog for use by algorithms." "gds.graph.create(graphName :: STRING?, nodeProjection :: ANY?, relationshipProjection :: ANY?, configuration = {} :: MAP?) :: (nodeProjection :: MAP?, relationshipProjection :: MAP?, graphName :: STRING?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, createMillis :: INTEGER?)" "procedure"

175

 "gds.graph.create.cypher" "Creates a named graph in the catalog for use by algorithms." "gds.graph.create.cypher(graphName :: STRING?, nodeQuery :: STRING?, relationshipQuery :: STRING?, configuration = {} :: MAP?) :: (nodeQuery :: STRING?, relationshipQuery :: STRING?, graphName :: STRING?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, createMillis :: INTEGER?)" "procedure"

176

 "gds.graph.create.cypher.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.graph.create.cypher.estimate(nodeQuery :: STRING?, relationshipQuery :: STRING?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

177

 "gds.graph.create.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.graph.create.estimate(nodeProjection :: ANY?, relationshipProjection :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

178

 "gds.graph.deleteRelationships" "" "gds.graph.deleteRelationships(graphName :: STRING?, relationshipType :: STRING?) :: (graphName :: STRING?, relationshipType :: STRING?, deletedRelationships :: INTEGER?, deletedProperties :: MAP?)" "procedure"

179

 "gds.graph.drop" "Drops a named graph from the catalog and frees up the resources it occupies." "gds.graph.drop(graphName :: ANY?, failIfMissing = true :: BOOLEAN?, dbName = :: STRING?, username = :: STRING?) :: (graphName :: STRING?, database :: STRING?, memoryUsage :: STRING?, sizeInBytes :: INTEGER?, nodeProjection :: MAP?, relationshipProjection :: MAP?, nodeQuery :: STRING?, relationshipQuery :: STRING?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, nodeFilter :: STRING?, relationshipFilter :: STRING?, density :: FLOAT?, creationTime :: DATETIME?, modificationTime :: DATETIME?, schema :: MAP?)" "procedure"

180

 "gds.graph.exists" "Checks if a graph exists in the catalog." "gds.graph.exists(graphName :: STRING?) :: (graphName :: STRING?, exists :: BOOLEAN?)" "procedure"

181

 "gds.graph.export" "Exports a named graph into a new offline Neo4j database." "gds.graph.export(graphName :: STRING?, configuration = {} :: MAP?) :: (dbName :: STRING?, graphName :: STRING?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, relationshipTypeCount :: INTEGER?, nodePropertyCount :: INTEGER?, relationshipPropertyCount :: INTEGER?, writeMillis :: INTEGER?)" "procedure"

182

 "gds.graph.list" "Lists information about named graphs stored in the catalog." "gds.graph.list(graphName = __NO_VALUE :: STRING?) :: (degreeDistribution :: MAP?, graphName :: STRING?, database :: STRING?, memoryUsage :: STRING?, sizeInBytes :: INTEGER?, nodeProjection :: MAP?, relationshipProjection :: MAP?, nodeQuery :: STRING?, relationshipQuery :: STRING?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, nodeFilter :: STRING?, relationshipFilter :: STRING?, density :: FLOAT?, creationTime :: DATETIME?, modificationTime :: DATETIME?, schema :: MAP?)" "procedure"

183

 "gds.graph.removeNodeProperties" "Removes node properties from an in-memory graph." "gds.graph.removeNodeProperties(graphName :: STRING?, nodeProperties :: LIST? OF STRING?, nodeLabels = [*] :: LIST? OF STRING?, configuration = {} :: MAP?) :: (graphName :: STRING?, nodeProperties :: LIST? OF STRING?, propertiesRemoved :: INTEGER?)" "procedure"

184

 "gds.graph.streamNodeProperties" "Streams the given node properties." "gds.graph.streamNodeProperties(graphName :: STRING?, nodeProperties :: LIST? OF STRING?, nodeLabels = [*] :: LIST? OF STRING?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, nodeProperty :: STRING?, propertyValue :: ANY?)" "procedure"

185

 "gds.graph.streamNodeProperty" "Streams the given node property." "gds.graph.streamNodeProperty(graphName :: STRING?, nodeProperties :: STRING?, nodeLabels = [*] :: LIST? OF STRING?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, propertyValue :: ANY?)" "procedure"

186

 "gds.graph.streamRelationshipProperties" "Streams the given relationship properties." "gds.graph.streamRelationshipProperties(graphName :: STRING?, relationshipProperties :: LIST? OF STRING?, relationshipTypes = [*] :: LIST? OF STRING?, configuration = {} :: MAP?) :: (sourceNodeId :: INTEGER?, targetNodeId :: INTEGER?, relationshipType :: STRING?, relationshipProperty :: STRING?, propertyValue :: NUMBER?)" "procedure"

187

 "gds.graph.streamRelationshipProperty" "Streams the given relationship property." "gds.graph.streamRelationshipProperty(graphName :: STRING?, relationshipProperties :: STRING?, relationshipTypes = [*] :: LIST? OF STRING?, configuration = {} :: MAP?) :: (sourceNodeId :: INTEGER?, targetNodeId :: INTEGER?, relationshipType :: STRING?, propertyValue :: NUMBER?)" "procedure"

188

 "gds.graph.writeNodeProperties" "Writes the given node properties to an online Neo4j database." "gds.graph.writeNodeProperties(graphName :: STRING?, nodeProperties :: LIST? OF STRING?, nodeLabels = [*] :: LIST? OF STRING?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, graphName :: STRING?, nodeProperties :: LIST? OF STRING?, propertiesWritten :: INTEGER?)" "procedure"

189

 "gds.graph.writeRelationship" "Writes the given relationship and an optional relationship property to an online Neo4j database." "gds.graph.writeRelationship(graphName :: STRING?, relationshipType :: STRING?, relationshipProperty = :: STRING?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, graphName :: STRING?, relationshipType :: STRING?, relationshipProperty :: STRING?, relationshipsWritten :: INTEGER?, propertiesWritten :: INTEGER?)" "procedure"

190

 "gds.labelPropagation.mutate" "The Label Propagation algorithm is a fast algorithm for finding communities in a graph." "gds.labelPropagation.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (mutateMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, communityCount :: INTEGER?, communityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

191

 "gds.labelPropagation.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.labelPropagation.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

192

 "gds.labelPropagation.stats" "Executes the algorithm and returns result statistics without writing the result to Neo4j." "gds.labelPropagation.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (ranIterations :: INTEGER?, didConverge :: BOOLEAN?, communityCount :: INTEGER?, communityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

193

 "gds.labelPropagation.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.labelPropagation.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

194

 "gds.labelPropagation.stream" "The Label Propagation algorithm is a fast algorithm for finding communities in a graph." "gds.labelPropagation.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, communityId :: INTEGER?)" "procedure"

195

 "gds.labelPropagation.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.labelPropagation.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

196

 "gds.labelPropagation.write" "The Label Propagation algorithm is a fast algorithm for finding communities in a graph." "gds.labelPropagation.write(graphName :: ANY?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, communityCount :: INTEGER?, communityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

197

 "gds.labelPropagation.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.labelPropagation.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

198

 "gds.localClusteringCoefficient.mutate" "" "gds.localClusteringCoefficient.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (mutateMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, averageClusteringCoefficient :: FLOAT?, nodeCount :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

199

 "gds.localClusteringCoefficient.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.localClusteringCoefficient.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

200

 "gds.localClusteringCoefficient.stats" "Executes the algorithm and returns result statistics without writing the result to Neo4j." "gds.localClusteringCoefficient.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (averageClusteringCoefficient :: FLOAT?, nodeCount :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

201

 "gds.localClusteringCoefficient.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.localClusteringCoefficient.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

202

 "gds.localClusteringCoefficient.stream" "" "gds.localClusteringCoefficient.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, localClusteringCoefficient :: FLOAT?)" "procedure"

203

 "gds.localClusteringCoefficient.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.localClusteringCoefficient.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

204

 "gds.localClusteringCoefficient.write" "Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph." "gds.localClusteringCoefficient.write(graphName :: ANY?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, averageClusteringCoefficient :: FLOAT?, nodeCount :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

205

 "gds.localClusteringCoefficient.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.localClusteringCoefficient.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

206

 "gds.louvain.mutate" "The Louvain method for community detection is an algorithm for detecting communities in networks." "gds.louvain.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (mutateMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, modularity :: FLOAT?, modularities :: LIST? OF FLOAT?, ranLevels :: INTEGER?, communityCount :: INTEGER?, communityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

207

 "gds.louvain.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.louvain.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

208

 "gds.louvain.stats" "Executes the algorithm and returns result statistics without writing the result to Neo4j." "gds.louvain.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (modularity :: FLOAT?, modularities :: LIST? OF FLOAT?, ranLevels :: INTEGER?, communityCount :: INTEGER?, communityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

209

 "gds.louvain.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.louvain.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

210

 "gds.louvain.stream" "The Louvain method for community detection is an algorithm for detecting communities in networks." "gds.louvain.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, communityId :: INTEGER?, intermediateCommunityIds :: LIST? OF INTEGER?)" "procedure"

211

 "gds.louvain.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.louvain.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

212

 "gds.louvain.write" "The Louvain method for community detection is an algorithm for detecting communities in networks." "gds.louvain.write(graphName :: ANY?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, modularity :: FLOAT?, modularities :: LIST? OF FLOAT?, ranLevels :: INTEGER?, communityCount :: INTEGER?, communityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

213

 "gds.louvain.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.louvain.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

214

 "gds.nodeSimilarity.mutate" "The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric." "gds.nodeSimilarity.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, nodesCompared :: INTEGER?, relationshipsWritten :: INTEGER?, similarityDistribution :: MAP?, configuration :: MAP?)" "procedure"

215

 "gds.nodeSimilarity.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.nodeSimilarity.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

216

 "gds.nodeSimilarity.stats" "Executes the algorithm and returns result statistics without writing the result to Neo4j." "gds.nodeSimilarity.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, nodesCompared :: INTEGER?, similarityPairs :: INTEGER?, similarityDistribution :: MAP?, configuration :: MAP?)" "procedure"

217

 "gds.nodeSimilarity.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.nodeSimilarity.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

218

 "gds.nodeSimilarity.stream" "The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric." "gds.nodeSimilarity.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (node1 :: INTEGER?, node2 :: INTEGER?, similarity :: FLOAT?)" "procedure"

219

 "gds.nodeSimilarity.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.nodeSimilarity.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

220

 "gds.nodeSimilarity.write" "The Node Similarity algorithm compares a set of nodes based on the nodes they are connected to. Two nodes are considered similar if they share many of the same neighbors. Node Similarity computes pair-wise similarities based on the Jaccard metric." "gds.nodeSimilarity.write(graphName :: ANY?, configuration = {} :: MAP?) :: (createMillis :: INTEGER?, computeMillis :: INTEGER?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, nodesCompared :: INTEGER?, relationshipsWritten :: INTEGER?, similarityDistribution :: MAP?, configuration :: MAP?)" "procedure"

221

 "gds.nodeSimilarity.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.nodeSimilarity.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

222

 "gds.pageRank.mutate" "Page Rank is an algorithm that measures the transitive influence or connectivity of nodes." "gds.pageRank.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (mutateMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

223

 "gds.pageRank.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.pageRank.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

224

 "gds.pageRank.stats" "Executes the algorithm and returns result statistics without writing the result to Neo4j." "gds.pageRank.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (ranIterations :: INTEGER?, didConverge :: BOOLEAN?, centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

225

 "gds.pageRank.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.pageRank.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

226

 "gds.pageRank.stream" "Page Rank is an algorithm that measures the transitive influence or connectivity of nodes." "gds.pageRank.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, score :: FLOAT?)" "procedure"

227

 "gds.pageRank.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.pageRank.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

228

 "gds.pageRank.write" "Page Rank is an algorithm that measures the transitive influence or connectivity of nodes." "gds.pageRank.write(graphName :: ANY?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, ranIterations :: INTEGER?, didConverge :: BOOLEAN?, centralityDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

229

 "gds.pageRank.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.pageRank.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

230

 "gds.shortestPath.astar.mutate" "The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster." "gds.shortestPath.astar.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

231

 "gds.shortestPath.astar.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.shortestPath.astar.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

232

 "gds.shortestPath.astar.stream" "The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster." "gds.shortestPath.astar.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (index :: INTEGER?, sourceNode :: INTEGER?, targetNode :: INTEGER?, totalCost :: FLOAT?, nodeIds :: LIST? OF INTEGER?, costs :: LIST? OF FLOAT?, path :: PATH?)" "procedure"

233

 "gds.shortestPath.astar.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.shortestPath.astar.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

234

 "gds.shortestPath.astar.write" "The A* shortest path algorithm computes the shortest path between a pair of nodes. It uses the relationship weight property to compare path lengths. In addition, this implementation uses the haversine distance as a heuristic to converge faster." "gds.shortestPath.astar.write(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

235

 "gds.shortestPath.astar.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.shortestPath.astar.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

236

 "gds.shortestPath.dijkstra.mutate" "The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes." "gds.shortestPath.dijkstra.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

237

 "gds.shortestPath.dijkstra.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.shortestPath.dijkstra.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

238

 "gds.shortestPath.dijkstra.stream" "The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes." "gds.shortestPath.dijkstra.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (index :: INTEGER?, sourceNode :: INTEGER?, targetNode :: INTEGER?, totalCost :: FLOAT?, nodeIds :: LIST? OF INTEGER?, costs :: LIST? OF FLOAT?, path :: PATH?)" "procedure"

239

 "gds.shortestPath.dijkstra.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.shortestPath.dijkstra.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

240

 "gds.shortestPath.dijkstra.write" "The Dijkstra shortest path algorithm computes the shortest (weighted) path between a pair of nodes." "gds.shortestPath.dijkstra.write(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

241

 "gds.shortestPath.dijkstra.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.shortestPath.dijkstra.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

242

 "gds.shortestPath.yens.mutate" "The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes." "gds.shortestPath.yens.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, mutateMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

243

 "gds.shortestPath.yens.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.shortestPath.yens.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

244

 "gds.shortestPath.yens.stream" "The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes." "gds.shortestPath.yens.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (index :: INTEGER?, sourceNode :: INTEGER?, targetNode :: INTEGER?, totalCost :: FLOAT?, nodeIds :: LIST? OF INTEGER?, costs :: LIST? OF FLOAT?, path :: PATH?)" "procedure"

245

 "gds.shortestPath.yens.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.shortestPath.yens.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

246

 "gds.shortestPath.yens.write" "The Yen's shortest path algorithm computes the k shortest (weighted) paths between a pair of nodes." "gds.shortestPath.yens.write(graphName :: ANY?, configuration = {} :: MAP?) :: (relationshipsWritten :: INTEGER?, writeMillis :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

247

 "gds.shortestPath.yens.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.shortestPath.yens.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

248

 "gds.triangleCount.mutate" "" "gds.triangleCount.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (mutateMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, globalTriangleCount :: INTEGER?, nodeCount :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

249

 "gds.triangleCount.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.triangleCount.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

250

 "gds.triangleCount.stats" "Executes the algorithm and returns result statistics without writing the result to Neo4j." "gds.triangleCount.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (globalTriangleCount :: INTEGER?, nodeCount :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

251

 "gds.triangleCount.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.triangleCount.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

252

 "gds.triangleCount.stream" "Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph." "gds.triangleCount.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, triangleCount :: INTEGER?)" "procedure"

253

 "gds.triangleCount.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.triangleCount.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

254

 "gds.triangleCount.write" "Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph." "gds.triangleCount.write(graphName :: ANY?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, globalTriangleCount :: INTEGER?, nodeCount :: INTEGER?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

255

 "gds.triangleCount.write.estimate" "Triangle counting is a community detection graph algorithm that is used to determine the number of triangles passing through each node in the graph." "gds.triangleCount.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

256

 "gds.wcc.mutate" "The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component." "gds.wcc.mutate(graphName :: ANY?, configuration = {} :: MAP?) :: (mutateMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, componentCount :: INTEGER?, componentDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

257

 "gds.wcc.mutate.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.wcc.mutate.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

258

 "gds.wcc.stats" "Executes the algorithm and returns result statistics without writing the result to Neo4j." "gds.wcc.stats(graphName :: ANY?, configuration = {} :: MAP?) :: (componentCount :: INTEGER?, componentDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

259

 "gds.wcc.stats.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.wcc.stats.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

260

 "gds.wcc.stream" "The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component." "gds.wcc.stream(graphName :: ANY?, configuration = {} :: MAP?) :: (nodeId :: INTEGER?, componentId :: INTEGER?)" "procedure"

261

 "gds.wcc.stream.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.wcc.stream.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

262

 "gds.wcc.write" "The WCC algorithm finds sets of connected nodes in an undirected graph, where all nodes in the same set form a connected component." "gds.wcc.write(graphName :: ANY?, configuration = {} :: MAP?) :: (writeMillis :: INTEGER?, nodePropertiesWritten :: INTEGER?, componentCount :: INTEGER?, componentDistribution :: MAP?, postProcessingMillis :: INTEGER?, createMillis :: INTEGER?, computeMillis :: INTEGER?, configuration :: MAP?)" "procedure"

263

 "gds.wcc.write.estimate" "Returns an estimation of the memory consumption for that procedure." "gds.wcc.write.estimate(graphName :: ANY?, configuration = {} :: MAP?) :: (requiredMemory :: STRING?, treeView :: STRING?, mapView :: MAP?, bytesMin :: INTEGER?, bytesMax :: INTEGER?, nodeCount :: INTEGER?, relationshipCount :: INTEGER?, heapPercentageMin :: FLOAT?, heapPercentageMax :: FLOAT?)" "procedure"

264

 "gds.alpha.linkprediction.adamicAdar" "Given two nodes, calculate Adamic Adar similarity" "gds.alpha.linkprediction.adamicAdar(node1 :: NODE?, node2 :: NODE?, config = {} :: MAP?) :: (FLOAT?)" "function"

265

 "gds.alpha.linkprediction.commonNeighbors" "Given two nodes, returns the number of common neighbors" "gds.alpha.linkprediction.commonNeighbors(node1 :: NODE?, node2 :: NODE?, config = {} :: MAP?) :: (FLOAT?)" "function"

266

 "gds.alpha.linkprediction.preferentialAttachment" "Given two nodes, calculate Preferential Attachment" "gds.alpha.linkprediction.preferentialAttachment(node1 :: NODE?, node2 :: NODE?, config = {} :: MAP?) :: (FLOAT?)" "function"

267

 "gds.alpha.linkprediction.resourceAllocation" "Given two nodes, calculate Resource Allocation similarity" "gds.alpha.linkprediction.resourceAllocation(node1 :: NODE?, node2 :: NODE?, config = {} :: MAP?) :: (FLOAT?)" "function"

268

 "gds.alpha.linkprediction.sameCommunity" "Given two nodes, indicates if they have the same community" "gds.alpha.linkprediction.sameCommunity(node1 :: NODE?, node2 :: NODE?, communityProperty = community :: STRING?) :: (FLOAT?)" "function"

269

 "gds.alpha.linkprediction.totalNeighbors" "Given two nodes, calculate Total Neighbors" "gds.alpha.linkprediction.totalNeighbors(node1 :: NODE?, node2 :: NODE?, config = {} :: MAP?) :: (FLOAT?)" "function"

270

 "gds.alpha.ml.oneHotEncoding" "RETURN gds.alpha.ml.oneHotEncoding(availableValues, selectedValues) - return a list of selected values in a one hot encoding format." "gds.alpha.ml.oneHotEncoding(availableValues :: LIST? OF ANY?, selectedValues :: LIST? OF ANY?) :: (LIST? OF ANY?)" "function"

271

 "gds.alpha.similarity.asVector" "RETURN gds.alpha.similarity.asVector(map) - Builds a vector of maps containing items and weights" "gds.alpha.similarity.asVector(node :: NODE?, weight :: FLOAT?) :: (LIST? OF ANY?)" "function"

272

 "gds.alpha.similarity.cosine" "RETURN gds.alpha.similarity.cosine(vector1, vector2) - Given two collection vectors, calculate cosine similarity" "gds.alpha.similarity.cosine(vector1 :: LIST? OF NUMBER?, vector2 :: LIST? OF NUMBER?) :: (FLOAT?)" "function"

273

 "gds.alpha.similarity.euclidean" "RETURN gds.alpha.similarity.euclidean(vector1, vector2) - Given two collection vectors, calculate similarity based on euclidean distance" "gds.alpha.similarity.euclidean(vector1 :: LIST? OF NUMBER?, vector2 :: LIST? OF NUMBER?) :: (FLOAT?)" "function"

274

 "gds.alpha.similarity.euclideanDistance" "RETURN gds.alpha.similarity.euclideanDistance(vector1, vector2) - Given two collection vectors, calculate the euclidean distance (square root of the sum of the squared differences)" "gds.alpha.similarity.euclideanDistance(vector1 :: LIST? OF NUMBER?, vector2 :: LIST? OF NUMBER?) :: (FLOAT?)" "function"

275

 "gds.alpha.similarity.jaccard" "RETURN gds.alpha.similarity.jaccard(vector1, vector2) - Given two collection vectors, calculate Jaccard similarity" "gds.alpha.similarity.jaccard(vector1 :: LIST? OF NUMBER?, vector2 :: LIST? OF NUMBER?) :: (FLOAT?)" "function"

276

 "gds.alpha.similarity.overlap" "RETURN gds.alpha.similarity.overlap(vector1, vector2) - Given two collection vectors, calculate overlap similarity" "gds.alpha.similarity.overlap(vector1 :: LIST? OF NUMBER?, vector2 :: LIST? OF NUMBER?) :: (FLOAT?)" "function"

277

 "gds.alpha.similarity.pearson" "RETURN gds.alpha.similarity.pearson(vector1, vector2) - Given two collection vectors, calculate pearson similarity" "gds.alpha.similarity.pearson(vector1 :: ANY?, vector2 :: ANY?, config = {} :: MAP?) :: (FLOAT?)" "function"

278

 "gds.graph.exists" "Checks if a graph exists in the catalog." "gds.graph.exists(graphName :: STRING?) :: (BOOLEAN?)" "function"

279

 "gds.util.NaN" "RETURN gds.util.NaN() - Returns NaN as a Cypher value." "gds.util.NaN() :: (FLOAT?)" "function"

280

 "gds.util.asNode" "RETURN gds.util.asNode(nodeId) - Return the node objects for the given node id or null if none exists." "gds.util.asNode(nodeId :: NUMBER?) :: (NODE?)" "function"

281

 "gds.util.asNodes" "RETURN gds.util.asNodes(nodeIds) - Return the node objects for the given node ids or an empty list if none exists." "gds.util.asNodes(nodeIds :: LIST? OF NUMBER?) :: (LIST? OF ANY?)" "function"

282

 "gds.util.infinity" "RETURN gds.util.infinity() - Return infinity as a Cypher value." "gds.util.infinity() :: (FLOAT?)" "function"

283

 "gds.util.isFinite" "RETURN gds.util.isFinite(value) - Return true iff the given argument is a finite value (not ±Infinity, NaN, or null)." "gds.util.isFinite(value :: NUMBER?) :: (BOOLEAN?)" "function"

284

 "gds.util.isInfinite" "RETURN gds.util.isInfinite(value) - Return true iff the given argument is not a finite value (not ±Infinity, NaN, or null)." "gds.util.isInfinite(value :: NUMBER?) :: (BOOLEAN?)" "function"

285

 "gds.util.nodeProperty" "Returns a node property value from a named in-memory graph." "gds.util.nodeProperty(graphName :: STRING?, nodeId :: NUMBER?, propertyKey :: STRING?, nodeLabel = * :: STRING?) :: (ANY?)" "function"

286

 "gds.version" "RETURN gds.version() | Return the installed graph data science library version." "gds.version() :: (STRING?)"

GDS List内容详情相关推荐

  1. WEB前后端交互原型通用元件库、常用组件、信息输出、信息输入、信息反馈、综合系列、页面交互、首页、分类页、内容详情、用户中心、注册登录、找回密码、元件库、web元件库、rplib、axure

    WEB前后端交互原型通用元件库.常用组件.信息输出.信息输入.信息反馈.综合系列.页面交互.首页.分类页.内容详情.用户中心.注册登录.找回密码.元件库.web元件库.rplib.axure原型 we ...

  2. 列表页详情页html源码,UI布局欣赏：文章列表与内容详情页设计

    UI布局欣赏:文章列表与内容详情页设计 3月 23, 2017 评论 Sponsor 信息内容几乎是每个新闻.博客.摄影.社区等类型媒体常用的功能,所以他们一般都会拥有信息的列表页和内容详情页面的设计 ...

  3. 一梦江湖网页提交问题服务器错误,一梦江湖4月3日更新内容详情一览

    一梦江湖4月3日更新内容详情一览 更新时间:2020-04-05 作者:shaoshao 一梦江湖在今日进行了又一轮更新,海上行是浮生星旅玩法的新篇章,还更新了一些其他的活动,进行了一些相关的优化与调 ...

  4. php图片点击查看大图,jQuery点击小图看大图，大图查看内容详情所有图片

    jQuery点击小图看大图,大图查看内容详情所有图片: html代码如下: × < > CSS代码如下: * { margin:0; padding:0; } body { overflo ...

  5. java波斯王子时之沙_我的世界Java版21w07a版本更新内容详情

    修复的漏洞 SPX 自动翻译™ 由以下志愿者提供支持:Dianliang233.Light Beacon.Ricolove.SPGoding.WuGuangYao.lakejason0.xuan_su ...

  6. 我的世界java版最新版多少_我的世界JAVA版1.16.5正式版更新内容详情

    我的世界JAVA版的1.16.5正式版于2021年1月15日更新,此次更新都有哪些内容呢?下面就给大家带来我的世界JAVA版1.16.5正式版更新内容详情,以供玩家参考. Happy Friday! ...

  7. 天地劫幽城再临服务器维护,天地劫幽城再临3月25日更新公告 天地劫幽城再临3月25日更新内容详情_手心游戏...

    天地劫幽城再临在今天也就是3月25日进行了一次更新,很多小伙伴都很想知道本次更新具体有哪些内容,今天小编就为大家带来天地劫幽城再临本次更新内容详情,感兴趣的小伙伴快来一起看一下吧. 天地劫幽城再临3月 ...

  8. java怪物猎人_我的世界Java版21w08a版本更新内容详情

    我的世界Java版的21w08a版本已经更新,本次更新的内容都有什么呢?下面就给大家带来我的世界Java版21w08a版本更新内容详情,以供玩家参考. 在本快照中,我们亲爱的新型石头遭受了阴沉的命运, ...

  9. 命运2服务器维护2021,《命运2》3.0.2版本更新内容详情 2021年1月20日更新公告

    战斗收起战斗活动奖励综合 命运2于2021年1月20日进行了更新,此次更新都有哪些内容呢?下面就给大家带来<命运2>3.0.2版本更新内容详情,以供玩家参考. 战斗 技能 修复了突围者法则 ...

  10. python爬取B站动态的评论总数(不含用户评论内容详情)

    目录 前言 需求 方案分析 方案一 方案二 接口分析 请求流程 抓包演示 请求接口 接口说明 接口测试 代码 前言 想看接口分析和代码的,可跳过前言. 更新,最核心的代码已删除,思路和其他代码保留. ...

最新文章

  1. Swift3中数组创建方法
  2. [转] Difference between Abstract classes and Interfaces
  3. System.IO命名空间
  4. 【SDOI 2009】学校食堂 Dining
  5. nginx静态代理设置一：静态文件在本机
  6. matlab二极管伏安特性,基于Matlab对Spice二极管特性受温度影响的研究
  7. 知道一点怎么设直线方程_两点直线方程怎么求
  8. 在电路中，耦合是什么？有哪些方式？
  9. 深圳百元赠送话费11月20日前启动充
  10. Java面试题-JVM 和服务器性能评估
  11. 路由设置代理ip的作用
  12. （已解决）ubuntu16.04 Nvidia驱动安装成功却无法检测到外接显示器
  13. Unity学习笔记(二) 碰撞检测与触发检测
  14. Linux Mysql 数据库基础
  15. 基于Unity的软光栅实现(3)：基于Job system的多核加速光栅化
  16. python培训费用大概多少-Python培训学费需要多少钱？
  17. 【python安全攻防】python简易端口扫描器
  18. C语言 1~100之间3的倍数
  19. 10个有用的HTML文件上传技巧
  20. 计算机组成原理——操作数寻址方式

热门文章

  1. 校园招聘-2017美团后台开发内推笔试编程题
  2. 模仿百思不得姐项目开发总结
  3. Excel 2010 VBA 入门 071 工作表事件之Worksheet_Change
  4. python，用pycharm写的评分系统
  5. matlab出现问题：TRANSPOSE 不支持 N 维数组。请使用 PAGETRANSPOSE/PAGECTRANSPOSE 转置页，或使用 PERMUTE 重新排列 N 维数组的维度。
  6. 光栅(Raster)性能优化
  7. js 迅雷 批量下载
  8. Java程序员“金三银四“就一定要出去面试吗？
  9. 豆瓣电影Top250信息爬取并保存到excel文件中！
  10. 庄懂着色器_L19_顶点动画