Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.neo4j.graphalgo
Class GraphAlgoFactory

    java.lang.Object
      org.neo4j.graphalgo.GraphAlgoFactory

    public abstract class GraphAlgoFactory

extends Object

Static factory methods for the recommended implementations of common graph algorithms for Neo4j.

Author:
  Mattias Persson

Constructor Summary
`GraphAlgoFactory()`

Method Summary
`static PathFinder<Path>` | `allPaths(RelationshipExpander expander, int maxDepth)` Returns an algorithm which can find all available paths between two nodes.
`static PathFinder<Path>` | `allSimplePaths(RelationshipExpander expander, int maxDepth)` Returns an algorithm which can find all simple paths between two nodes.
`static PathFinder<WeightedPath>` | `aStar(RelationshipExpander expander, CostEvaluator<Double> lengthEvaluator, EstimateEvaluator<Double> estimateEvaluator)` Returns an `PathFinder` which uses the A* algorithm to find the cheapest path between two nodes.
`static PathFinder<WeightedPath>` | `dijkstra(RelationshipExpander expander, CostEvaluator<Double> costEvaluator)` Returns an `PathFinder` which uses the Dijkstra algorithm to find the cheapest path between two nodes.
`static PathFinder<Path>` | `shortestPath(RelationshipExpander expander, int maxDepth)` Returns an algorithm which can find all shortest paths (that is paths with as short `Path.length()` as possible) between two nodes.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### GraphAlgoFactory

    public GraphAlgoFactory()

Method Detail

### allPaths

    public static PathFinder<Path> allPaths(RelationshipExpander expander,
                                            int maxDepth)

  Returns an algorithm which can find all available paths between two nodes. These returned paths can contain loops (i.e. a node can occur more than once in any returned path).

  Parameters:
    `expander` - the `RelationshipExpander` to use for expanding `Relationship`s for each `Node`.
    `maxDepth` - the max `Path.length()` returned paths are allowed to have.
  Returns:
    an algorithm which finds all paths between two nodes.
  See Also:
    `AllPaths`

### allSimplePaths

    public static PathFinder<Path> allSimplePaths(RelationshipExpander expander,
                                                  int maxDepth)

  Returns an algorithm which can find all simple paths between two nodes. These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).

  Parameters:
    `expander` - the `RelationshipExpander` to use for expanding `Relationship`s for each `Node`.
    `maxDepth` - the max `Path.length()` returned paths are allowed to have.
  Returns:
    an algorithm which finds simple paths between two nodes.
  See Also:
    `AllSimplePaths`

### shortestPath

    public static PathFinder<Path> shortestPath(RelationshipExpander expander,
                                                int maxDepth)

  Returns an algorithm which can find all shortest paths (that is paths with as short `Path.length()` as possible) between two nodes. These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path).

  Parameters:
    `expander` - the `RelationshipExpander` to use for expanding `Relationship`s for each `Node`.
    `maxDepth` - the max `Path.length()` returned paths are allowed to have.
  Returns:
    an algorithm which finds shortest paths between two nodes.
  See Also:
    `ShortestPath`

### aStar

    public static PathFinder<WeightedPath> aStar(RelationshipExpander expander,
                                                 CostEvaluator<Double> lengthEvaluator,
                                                 EstimateEvaluator<Double> estimateEvaluator)

  Returns an `PathFinder` which uses the A* algorithm to find the cheapest path between two nodes. The definition of "cheap" is the lowest possible cost to get from the start node to the end node, where the cost is returned from `lengthEvaluator` and `estimateEvaluator`. These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path). See http://en.wikipedia.org/wiki/A*_search_algorithm for more information.

  Parameters:
    `expander` - the `RelationshipExpander` to use for expanding `Relationship`s for each `Node`.
    `lengthEvaluator` - evaluator that can return the cost represented by each relationship the algorithm traverses.
    `estimateEvaluator` - evaluator that returns an (optimistic) estimation of the cost to get from the current node (in the traversal) to the end node.
  Returns:
    an algorithm which finds the cheapest path between two nodes using the A* algorithm.
  See Also:
    `AStar`

### dijkstra

    public static PathFinder<WeightedPath> dijkstra(RelationshipExpander expander,
                                                    CostEvaluator<Double> costEvaluator)

  Returns an `PathFinder` which uses the Dijkstra algorithm to find the cheapest path between two nodes. The definition of "cheap" is the lowest possible cost to get from the start node to the end node, where the cost is returned from `costEvaluator`. These returned paths cannot contain loops (i.e. a node cannot occur more than once in any returned path). See http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm for more information.

  Parameters:
    `expander` - the `RelationshipExpander` to use for expanding `Relationship`s for each `Node`.
    `costEvaluator` - evaluator that can return the cost represented by each relationship the algorithm traverses.
  Returns:
    an algorithm which finds the cheapest path between two nodes using the Dijkstra algorithm.
  See Also:
    `Dijkstra`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2010 Neo4j. All Rights Reserved.