Examples with WeightedPath org.neo4j.graphalgo.WeightedPath used on opensource projects

Example 36 with WeightedPath

use of org.neo4j.graphalgo.WeightedPath in project graphdb by neo4j-attic.

the class DijkstraTest method canGetMultiplePathsInTriangleGraph.

@Test
public void canGetMultiplePathsInTriangleGraph() throws Exception {
    Node nodeA = graph.makeNode("A");
    Node nodeB = graph.makeNode("B");
    Node nodeC = graph.makeNode("C");
    Set<Relationship> expectedFirsts = new HashSet<Relationship>();
    expectedFirsts.add(graph.makeEdge("A", "B", "length", 1d));
    expectedFirsts.add(graph.makeEdge("A", "B", "length", 1d));
    Relationship expectedSecond = graph.makeEdge("B", "C", "length", 2d);
    graph.makeEdge("A", "C", "length", 5d);
    Dijkstra algo = new Dijkstra(Traversal.expanderForAllTypes(), CommonEvaluators.doubleCostEvaluator("length"));
    Iterator<WeightedPath> paths = algo.findAllPaths(nodeA, nodeC).iterator();
    for (int i = 0; i < 2; i++) {
        assertTrue("expected more paths", paths.hasNext());
        Path path = paths.next();
        assertPath(path, nodeA, nodeB, nodeC);
        Iterator<Relationship> relationships = path.relationships().iterator();
        assertTrue("found shorter path than expected", relationships.hasNext());
        assertTrue("path contained unexpected relationship", expectedFirsts.remove(relationships.next()));
        assertTrue("found shorter path than expected", relationships.hasNext());
        assertEquals(expectedSecond, relationships.next());
        assertFalse("found longer path than expected", relationships.hasNext());
    }
    assertFalse("expected at most two paths", paths.hasNext());
}

Example 37 with WeightedPath

use of org.neo4j.graphalgo.WeightedPath in project graphdb by neo4j-attic.

the class TestAStar method canGetMultiplePathsInASmallRoadNetwork.

/**
     * <pre>
     *   012345    A - B:  2
     *  +------>x  A - C:  2.5
     * 0|  C       C - D:  7.3
     * 1|A    F    B - D:  2.5
     * 2| B D      D - E:  3
     * 3|    E     C - E:  5
     *  V          E - F:  5
     *  x          C - F: 12
     *             A - F: 25
     * </pre>
     */
@Ignore("A* doesn't return multiple equal paths")
@Test
public void canGetMultiplePathsInASmallRoadNetwork() throws Exception {
    Node nodeA = graph.makeNode("A", "x", 1d, "y", 0d);
    Node nodeB = graph.makeNode("B", "x", 2d, "y", 1d);
    Node nodeC = graph.makeNode("C", "x", 0d, "y", 2d);
    Node nodeD = graph.makeNode("D", "x", 2d, "y", 3d);
    Node nodeE = graph.makeNode("E", "x", 3d, "y", 4d);
    Node nodeF = graph.makeNode("F", "x", 1d, "y", 5d);
    graph.makeEdge("A", "B", "length", 2d);
    graph.makeEdge("A", "C", "length", 2.5d);
    graph.makeEdge("C", "D", "length", 7.3d);
    graph.makeEdge("B", "D", "length", 2.5d);
    graph.makeEdge("D", "E", "length", 3d);
    graph.makeEdge("C", "E", "length", 5d);
    graph.makeEdge("E", "F", "length", 5d);
    graph.makeEdge("C", "F", "length", 12d);
    graph.makeEdge("A", "F", "length", 25d);
    PathFinder<WeightedPath> algo = newFinder();
    // Try the search in both directions.
    for (Node[] nodes : new Node[][] { { nodeA, nodeF }, { nodeF, nodeA } }) {
        int found = 0;
        Iterator<WeightedPath> paths = algo.findAllPaths(nodes[0], nodes[1]).iterator();
        for (int foundCount = 0; foundCount < 2; foundCount++) {
            assertTrue("expected more paths (found: " + foundCount + ")", paths.hasNext());
            Path path = paths.next();
            if (path.length() != found && path.length() == 3) {
                assertContains(path.nodes(), nodeA, nodeC, nodeE, nodeF);
            } else if (path.length() != found && path.length() == 4) {
                assertContains(path.nodes(), nodeA, nodeB, nodeD, nodeE, nodeF);
            } else {
                fail("unexpected path length: " + path.length());
            }
            found = path.length();
        }
        assertFalse("expected at most two paths", paths.hasNext());
    }
}

Example 38 with WeightedPath

use of org.neo4j.graphalgo.WeightedPath in project graphdb by neo4j-attic.

the class TestAStar method canGetMultiplePathsInTriangleGraph.

/**
     * <pre>
     *   01234567
     *  +-------->x  A - C: 10
     * 0|A      C    A - B:  2 (x2)
     * 1|  B         B - C:  6
     *  V
     *  y
     * </pre>
     */
@Ignore("A* doesn't return multiple equal paths")
@Test
public void canGetMultiplePathsInTriangleGraph() throws Exception {
    Node nodeA = graph.makeNode("A", "x", 0d, "y", 0d);
    Node nodeB = graph.makeNode("B", "x", 2d, "y", 1d);
    Node nodeC = graph.makeNode("C", "x", 7d, "y", 0d);
    Set<Relationship> expectedFirsts = new HashSet<Relationship>();
    expectedFirsts.add(graph.makeEdge("A", "B", "length", 2d));
    expectedFirsts.add(graph.makeEdge("A", "B", "length", 2d));
    Relationship expectedSecond = graph.makeEdge("B", "C", "length", 6d);
    graph.makeEdge("A", "C", "length", 10d);
    PathFinder<WeightedPath> algo = newFinder();
    Iterator<WeightedPath> paths = algo.findAllPaths(nodeA, nodeC).iterator();
    for (int foundCount = 0; foundCount < 2; foundCount++) {
        assertTrue("expected more paths (found: " + foundCount + ")", paths.hasNext());
        Path path = paths.next();
        assertPath(path, nodeA, nodeB, nodeC);
        Iterator<Relationship> relationships = path.relationships().iterator();
        assertTrue("found shorter path than expected", relationships.hasNext());
        assertTrue("path contained unexpected relationship", expectedFirsts.remove(relationships.next()));
        assertTrue("found shorter path than expected", relationships.hasNext());
        assertEquals(expectedSecond, relationships.next());
        assertFalse("found longer path than expected", relationships.hasNext());
    }
    assertFalse("expected at most two paths", paths.hasNext());
}

Example 39 with WeightedPath

use of org.neo4j.graphalgo.WeightedPath in project graphdb by neo4j-attic.

the class TestDijkstra method testSmallGraph.

@Test
public void testSmallGraph() {
    Relationship shortCTOXRelationship = createGraph(true);
    PathFinder<WeightedPath> finder = GraphAlgoFactory.dijkstra(Traversal.expanderForTypes(MyRelTypes.R1, Direction.OUTGOING), "cost");
    PathFinder<WeightedPath> finder2 = GraphAlgoFactory.dijkstra(Traversal.expanderForTypes(MyRelTypes.R1, Direction.OUTGOING), CommonEvaluators.doubleCostEvaluator("cost"));
    // Assert that there are two matching paths
    Node startNode = graph.getNode("start");
    Node endNode = graph.getNode("x");
    assertPaths(finder.findAllPaths(startNode, endNode), "start,a,b,c,x", "start,a,b,c,d,e,x");
    assertPaths(finder2.findAllPaths(startNode, endNode), "start,a,b,c,x", "start,a,b,c,d,e,x");
    // of the two from (c) --> (x)
    for (WeightedPath path : finder.findAllPaths(startNode, endNode)) {
        if (getPathDef(path).equals("start,a,b,c,x")) {
            assertContainsRelationship(path, shortCTOXRelationship);
        }
    }
}

Example 40 with WeightedPath

use of org.neo4j.graphalgo.WeightedPath in project graphdb by neo4j-attic.

the class TestDijkstra method testSmallGraphWithDefaults.

@Test
public void testSmallGraphWithDefaults() {
    Relationship shortCTOXRelationship = createGraph(true);
    PathFinder<WeightedPath> finder = GraphAlgoFactory.dijkstra(Traversal.expanderForTypes(MyRelTypes.R1, Direction.OUTGOING), CommonEvaluators.doubleCostEvaluator("cost", 1.0d));
    // Assert that there are two matching paths
    Node startNode = graph.getNode("start");
    Node endNode = graph.getNode("x");
    assertPaths(finder.findAllPaths(startNode, endNode), "start,a,b,c,x", "start,a,b,c,d,e,x");
    // of the two from (c) --> (x)
    for (WeightedPath path : finder.findAllPaths(startNode, endNode)) {
        if (getPathDef(path).equals("start,a,b,c,x")) {
            assertContainsRelationship(path, shortCTOXRelationship);
        }
    }
}