target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void testUndirectedTwoEdges() { final long seed = 5; GraphGenerator<Integer, DefaultEdge, Integer> gen = new LinearizedChordDiagramGraphGenerator<>(20, 2, seed); Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(), null); assertEquals(20, g.... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVertex(vt)) { throw new IllegalArgumentException("Invalid vertex factory"); }... | LinearizedChordDiagramGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVer... | LinearizedChordDiagramGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVer... | LinearizedChordDiagramGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVer... | LinearizedChordDiagramGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVer... |
@Test public void testDirected() { final long seed = 5; GraphGenerator<Integer, DefaultEdge, Integer> gen = new LinearizedChordDiagramGraphGenerator<>(20, 1, seed); Graph<Integer, DefaultEdge> g = new DirectedPseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(), null); assertEquals(20, g.ve... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVertex(vt)) { throw new IllegalArgumentException("Invalid vertex factory"); }... | LinearizedChordDiagramGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVer... | LinearizedChordDiagramGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVer... | LinearizedChordDiagramGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVer... | LinearizedChordDiagramGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { List<V> nodes = new ArrayList<>(2 * n * m); for (int t = 0; t < n; t++) { V vt = vertexFactory.createVertex(); if (!target.addVer... |
@Test public void testDoyleGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.doyleGraph(); this.validateBasics(g, 27, 54, 3, 3, 5); assertTrue(GraphTests.isEulerian(g)); } | public static Graph<Integer, DefaultEdge> doyleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoyleGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> doyleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoyleGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> doyleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoyleGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> doyleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoyleGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static G... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> doyleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoyleGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static G... |
@Test public void testBullGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.bullGraph(); this.validateBasics(g, 5, 5, 2, 3, 3); } | public static Graph<Integer, DefaultEdge> bullGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBullGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> bullGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBullGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> bullGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBullGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> bullGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBullGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static Gra... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> bullGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBullGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static Gra... |
@Test public void testClawGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.clawGraph(); this.validateBasics(g, 4, 3, 1, 2, Integer.MAX_VALUE); assertTrue(GraphTests.isBipartite(g)); } | public static Graph<Integer, DefaultEdge> clawGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClawGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> clawGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClawGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> clawGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClawGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> clawGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClawGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static Gra... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> clawGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClawGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static Gra... |
@Test public void testBuckyBallGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.buckyBallGraph(); this.validateBasics(g, 60, 90, 9, 9, 5); assertTrue(GraphTests.isCubic(g)); } | public static Graph<Integer, DefaultEdge> buckyBallGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBuckyBallGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> buckyBallGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBuckyBallGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> buckyBallGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBuckyBallGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> buckyBallGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBuckyBallGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> buckyBallGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBuckyBallGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); ... |
@Test public void testClebschGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.clebschGraph(); this.validateBasics(g, 16, 40, 2, 2, 4); } | public static Graph<Integer, DefaultEdge> clebschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClebschGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> clebschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClebschGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> clebschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClebschGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> clebschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClebschGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> clebschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateClebschGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... |
@Test public void testAttributesSupport() throws ImportException { String input = "graph [\n" + " comment \"Sample Graph\"\n" + " directed 1\n" + " edge [\n" + " source 1\n" + " target 2\n" + " label \"Edge 1-2\"" + " name \"Name 12\"" + " ]\n" + " edge [\n" + " source 3\n" + " target 1\n" + " label \"Edge 3-1\"" + " n... | @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErrorListeners(); lexer.addErrorListener(errorListener); GmlParser parser = new Gml... | GmlImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErr... | GmlImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErr... | GmlImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErr... | GmlImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErr... |
@Test public void testGrötzschGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.grötzschGraph(); this.validateBasics(g, 11, 20, 2, 2, 4); } | public static Graph<Integer, DefaultEdge> grötzschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGrötzschGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> grötzschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGrötzschGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> grötzschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGrötzschGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> grötzschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGrötzschGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); st... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> grötzschGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGrötzschGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); st... |
@Test public void testBidiakisCubeGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.bidiakisCubeGraph(); this.validateBasics(g, 12, 18, 3, 3, 4); assertTrue(GraphTests.isCubic(g)); } | public static Graph<Integer, DefaultEdge> bidiakisCubeGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBidiakisCubeGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> bidiakisCubeGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBidiakisCubeGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> bidiakisCubeGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBidiakisCubeGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFact... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> bidiakisCubeGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBidiakisCubeGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFact... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> bidiakisCubeGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBidiakisCubeGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFact... |
@Test public void testBlanusaFirstSnarkGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.blanusaFirstSnarkGraph(); this.validateBasics(g, 18, 27, 4, 4, 5); assertTrue(GraphTests.isCubic(g)); } | public static Graph<Integer, DefaultEdge> blanusaFirstSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaFirstSnarkGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> blanusaFirstSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaFirstSnarkGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> blanusaFirstSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaFirstSnarkGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> blanusaFirstSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaFirstSnarkGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> blanusaFirstSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaFirstSnarkGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> ... |
@Test public void testBlanusaSecondSnarkGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.blanusaSecondSnarkGraph(); this.validateBasics(g, 18, 27, 4, 4, 5); assertTrue(GraphTests.isCubic(g)); } | public static Graph<Integer, DefaultEdge> blanusaSecondSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaSecondSnarkGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> blanusaSecondSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaSecondSnarkGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> blanusaSecondSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaSecondSnarkGraph(g); return g; } NamedGraphGenerator(VertexFactory<V... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> blanusaSecondSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaSecondSnarkGraph(g); return g; } NamedGraphGenerator(VertexFactory<V... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> blanusaSecondSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBlanusaSecondSnarkGraph(g); return g; } NamedGraphGenerator(VertexFactory<V... |
@Test public void testDoubleStarSnarkGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.doubleStarSnarkGraph(); this.validateBasics(g, 30, 45, 4, 4, 6); } | public static Graph<Integer, DefaultEdge> doubleStarSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoubleStarSnarkGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> doubleStarSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoubleStarSnarkGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> doubleStarSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoubleStarSnarkGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vert... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> doubleStarSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoubleStarSnarkGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vert... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> doubleStarSnarkGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateDoubleStarSnarkGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vert... |
@Test public void testBrinkmannGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.brinkmannGraph(); this.validateBasics(g, 21, 42, 3, 3, 5); assertTrue(GraphTests.isEulerian(g)); } | public static Graph<Integer, DefaultEdge> brinkmannGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBrinkmannGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> brinkmannGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBrinkmannGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> brinkmannGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBrinkmannGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> brinkmannGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBrinkmannGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> brinkmannGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateBrinkmannGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); ... |
@Test public void testGossetGraphGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.gossetGraph(); this.validateBasics(g, 56, 756, 3, 3, 3); } | public static Graph<Integer, DefaultEdge> gossetGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGossetGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> gossetGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGossetGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> gossetGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGossetGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> gossetGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGossetGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> gossetGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGossetGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static... |
@Test public void testChvatalGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.chvatalGraph(); this.validateBasics(g, 12, 24, 2, 2, 4); assertTrue(GraphTests.isEulerian(g)); } | public static Graph<Integer, DefaultEdge> chvatalGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateChvatalGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> chvatalGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateChvatalGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> chvatalGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateChvatalGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> chvatalGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateChvatalGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> chvatalGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateChvatalGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... |
@Test public void testKittellGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.kittellGraph(); this.validateBasics(g, 23, 63, 3, 4, 3); } | public static Graph<Integer, DefaultEdge> kittellGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKittellGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> kittellGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKittellGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> kittellGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKittellGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> kittellGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKittellGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> kittellGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKittellGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... |
@Test public void testCoxeterGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.coxeterGraph(); this.validateBasics(g, 28, 42, 4, 4, 7); assertTrue(GraphTests.isCubic(g)); } | public static Graph<Integer, DefaultEdge> coxeterGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateCoxeterGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> coxeterGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateCoxeterGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> coxeterGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateCoxeterGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> coxeterGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateCoxeterGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> coxeterGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateCoxeterGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... |
@Test public void testCustomNumberAttributesSupport() throws ImportException { String input = "graph [\n" + " comment \"Sample Graph\"\n" + " directed 1\n" + " edge [\n" + " source 1\n" + " target 2\n" + " frequency 6\n" + " customweight 7.5\n" + " ]\n" + " node [\n" + " id 1\n" + " frequency 2\n" + " customweight 1.2\... | @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErrorListeners(); lexer.addErrorListener(errorListener); GmlParser parser = new Gml... | GmlImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErr... | GmlImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErr... | GmlImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErr... | GmlImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { ThrowingErrorListener errorListener = new ThrowingErrorListener(); GmlLexer lexer = new GmlLexer(new ANTLRInputStream(input)); lexer.removeErr... |
@Test public void testEllinghamHorton54Graph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.ellinghamHorton54Graph(); this.validateBasics(g, 54, 81, 9, 10, 6); assertTrue(GraphTests.isCubic(g)); assertTrue(GraphTests.isBipartite(g)); } | public static Graph<Integer, DefaultEdge> ellinghamHorton54Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton54Graph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> ellinghamHorton54Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton54Graph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> ellinghamHorton54Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton54Graph(g); return g; } NamedGraphGenerator(VertexFactory<V> ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> ellinghamHorton54Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton54Graph(g); return g; } NamedGraphGenerator(VertexFactory<V> ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> ellinghamHorton54Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton54Graph(g); return g; } NamedGraphGenerator(VertexFactory<V> ... |
@Test public void testEllinghamHorton78Graph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.ellinghamHorton78Graph(); this.validateBasics(g, 78, 117, 7, 13, 6); assertTrue(GraphTests.isCubic(g)); assertTrue(GraphTests.isBipartite(g)); } | public static Graph<Integer, DefaultEdge> ellinghamHorton78Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton78Graph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> ellinghamHorton78Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton78Graph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> ellinghamHorton78Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton78Graph(g); return g; } NamedGraphGenerator(VertexFactory<V> ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> ellinghamHorton78Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton78Graph(g); return g; } NamedGraphGenerator(VertexFactory<V> ... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> ellinghamHorton78Graph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateEllinghamHorton78Graph(g); return g; } NamedGraphGenerator(VertexFactory<V> ... |
@Test public void testErreraGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.erreraGraph(); this.validateBasics(g, 17, 45, 3, 4, 3); } | public static Graph<Integer, DefaultEdge> erreraGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateErreraGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> erreraGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateErreraGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> erreraGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateErreraGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> erreraGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateErreraGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> erreraGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateErreraGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static... |
@Test public void testFranklinGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.franklinGraph(); this.validateBasics(g, 12, 18, 3, 3, 4); assertTrue(GraphTests.isCubic(g)); assertTrue(GraphTests.isBipartite(g)); } | public static Graph<Integer, DefaultEdge> franklinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFranklinGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> franklinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFranklinGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> franklinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFranklinGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> franklinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFranklinGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); st... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> franklinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFranklinGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); st... |
@Test public void testFrughtGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.fruchtGraph(); this.validateBasics(g, 12, 18, 3, 4, 3); assertTrue(GraphTests.isCubic(g)); } | public static Graph<Integer, DefaultEdge> fruchtGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFruchtGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> fruchtGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFruchtGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> fruchtGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFruchtGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> fruchtGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFruchtGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> fruchtGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateFruchtGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); static... |
@Test public void testGoldnerHararyGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.goldnerHararyGraph(); this.validateBasics(g, 11, 27, 2, 2, 3); } | public static Graph<Integer, DefaultEdge> goldnerHararyGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGoldnerHararyGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> goldnerHararyGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGoldnerHararyGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> goldnerHararyGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGoldnerHararyGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFa... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> goldnerHararyGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGoldnerHararyGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFa... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> goldnerHararyGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateGoldnerHararyGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFa... |
@Test public void testHeawoodGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.heawoodGraph(); this.validateBasics(g, 14, 21, 3, 3, 6); assertTrue(GraphTests.isCubic(g)); assertTrue(GraphTests.isBipartite(g)); } | public static Graph<Integer, DefaultEdge> heawoodGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHeawoodGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> heawoodGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHeawoodGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> heawoodGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHeawoodGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> heawoodGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHeawoodGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> heawoodGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHeawoodGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... |
@Test public void testHerschelGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.herschelGraph(); this.validateBasics(g, 11, 18, 3, 4, 4); assertTrue(GraphTests.isBipartite(g)); } | public static Graph<Integer, DefaultEdge> herschelGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHerschelGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> herschelGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHerschelGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> herschelGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHerschelGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> herschelGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHerschelGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); st... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> herschelGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHerschelGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); st... |
@Test public void testHoffmanGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.hoffmanGraph(); this.validateBasics(g, 16, 32, 3, 4, 4); assertTrue(GraphTests.isBipartite(g)); } | public static Graph<Integer, DefaultEdge> hoffmanGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHoffmanGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> hoffmanGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHoffmanGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> hoffmanGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHoffmanGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> hoffmanGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHoffmanGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> hoffmanGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateHoffmanGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... |
@Test public void testKrackhardtKiteGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.krackhardtKiteGraph(); this.validateBasics(g, 10, 18, 2, 4, 3); } | public static Graph<Integer, DefaultEdge> krackhardtKiteGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKrackhardtKiteGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> krackhardtKiteGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKrackhardtKiteGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> krackhardtKiteGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKrackhardtKiteGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertex... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> krackhardtKiteGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKrackhardtKiteGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertex... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> krackhardtKiteGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKrackhardtKiteGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertex... |
@Test public void testFromFile() throws ImportException, IOException { InputStream fstream = getClass().getClassLoader().getResourceAsStream("ellinghamHorton78Graph.s6"); Graph<Integer, DefaultEdge> g= new Pseudograph<>(DefaultEdge.class); Graph6Sparse6Importer<Integer, DefaultEdge> importer = new Graph6Sparse6Importer... | @Override public void importGraph(Graph<V, E> g, Reader input) throws ImportException { BufferedReader in; if (input instanceof BufferedReader) { in = (BufferedReader) input; } else { in = new BufferedReader(input); } String g6=""; try { g6=in.readLine(); } catch (IOException e) { e.printStackTrace(); } if(g6.isEmpty()... | Graph6Sparse6Importer extends AbstractBaseImporter<V,E> implements GraphImporter<V,E> { @Override public void importGraph(Graph<V, E> g, Reader input) throws ImportException { BufferedReader in; if (input instanceof BufferedReader) { in = (BufferedReader) input; } else { in = new BufferedReader(input); } String g6=""; ... | Graph6Sparse6Importer extends AbstractBaseImporter<V,E> implements GraphImporter<V,E> { @Override public void importGraph(Graph<V, E> g, Reader input) throws ImportException { BufferedReader in; if (input instanceof BufferedReader) { in = (BufferedReader) input; } else { in = new BufferedReader(input); } String g6=""; ... | Graph6Sparse6Importer extends AbstractBaseImporter<V,E> implements GraphImporter<V,E> { @Override public void importGraph(Graph<V, E> g, Reader input) throws ImportException { BufferedReader in; if (input instanceof BufferedReader) { in = (BufferedReader) input; } else { in = new BufferedReader(input); } String g6=""; ... | Graph6Sparse6Importer extends AbstractBaseImporter<V,E> implements GraphImporter<V,E> { @Override public void importGraph(Graph<V, E> g, Reader input) throws ImportException { BufferedReader in; if (input instanceof BufferedReader) { in = (BufferedReader) input; } else { in = new BufferedReader(input); } String g6=""; ... |
@Test public void testKlein3RegularGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.klein3RegularGraph(); this.validateBasics(g, 56, 84, 6, 6, 7); assertTrue(GraphTests.isCubic(g)); } | public static Graph<Integer, DefaultEdge> klein3RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein3RegularGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> klein3RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein3RegularGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> klein3RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein3RegularGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFa... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> klein3RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein3RegularGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFa... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> klein3RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein3RegularGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFa... |
@Test public void testKlein7RegularGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.klein7RegularGraph(); this.validateBasics(g, 24, 84, 3, 3, 3); } | public static Graph<Integer, DefaultEdge> klein7RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein7RegularGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> klein7RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein7RegularGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> klein7RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein7RegularGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFa... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> klein7RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein7RegularGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFa... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> klein7RegularGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateKlein7RegularGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFa... |
@Test public void testMoserSpindleGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.moserSpindleGraph(); this.validateBasics(g, 7, 11, 2, 2, 3); } | public static Graph<Integer, DefaultEdge> moserSpindleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateMoserSpindleGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> moserSpindleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateMoserSpindleGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> moserSpindleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateMoserSpindleGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFact... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> moserSpindleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateMoserSpindleGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFact... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> moserSpindleGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateMoserSpindleGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFact... |
@Test public void testPoussinGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.poussinGraph(); this.validateBasics(g, 15, 39, 3, 3, 3); } | public static Graph<Integer, DefaultEdge> poussinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generatePoussinGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> poussinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generatePoussinGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> poussinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generatePoussinGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> poussinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generatePoussinGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> poussinGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generatePoussinGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... |
@Test public void testSchläfliGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.schläfliGraph(); this.validateBasics(g, 27, 216, 2, 2, 3); } | public static Graph<Integer, DefaultEdge> schläfliGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateSchläfliGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> schläfliGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateSchläfliGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> schläfliGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateSchläfliGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> schläfliGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateSchläfliGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); st... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> schläfliGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateSchläfliGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); st... |
@Test public void testThomsenGraph() { Graph<Integer, DefaultEdge> g = NamedGraphGenerator.thomsenGraph(); this.validateBasics(g, 6, 9, 2, 2, 4); assertTrue(GraphTests.isBipartite(g)); } | public static Graph<Integer, DefaultEdge> thomsenGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateThomsenGraph(g); return g; } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> thomsenGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateThomsenGraph(g); return g; } } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> thomsenGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateThomsenGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); } | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> thomsenGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateThomsenGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... | NamedGraphGenerator { public static Graph<Integer, DefaultEdge> thomsenGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new NamedGraphGenerator<Integer, DefaultEdge>(new IntegerVertexFactory()) .generateThomsenGraph(g); return g; } NamedGraphGenerator(VertexFactory<V> vertexFactory); stat... |
@Test public void testUndirected() { final long seed = 5; GraphGenerator<Integer, DefaultEdge, Integer> gen = new BarabasiAlbertGraphGenerator<>(3, 2, 10, seed); Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(), null); assertEquals(10, g.vertexSet().s... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGraph(target, vertexFactory, resultMap); target.vertexSet().stream().f... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... |
@Test public void testUndirectedWithOneInitialNode() { final long seed = 7; GraphGenerator<Integer, DefaultEdge, Integer> gen = new BarabasiAlbertGraphGenerator<>(1, 1, 20, seed); Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(), null); assertEquals(2... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGraph(target, vertexFactory, resultMap); target.vertexSet().stream().f... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... |
@Test public void testDirected() { final long seed = 5; GraphGenerator<Integer, DefaultEdge, Integer> gen = new BarabasiAlbertGraphGenerator<>(3, 2, 10, seed); Graph<Integer, DefaultEdge> g = new SimpleDirectedGraph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(), null); assertEquals(10, g.vertexS... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGraph(target, vertexFactory, resultMap); target.vertexSet().stream().f... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... |
@Test public void testDirectedWithOneInitialNode() { final long seed = 13; GraphGenerator<Integer, DefaultEdge, Integer> gen = new BarabasiAlbertGraphGenerator<>(1, 1, 20, seed); Graph<Integer, DefaultEdge> g = new SimpleDirectedGraph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(), null); assertE... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGraph(target, vertexFactory, resultMap); target.vertexSet().stream().f... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... |
@Test public void addOutgoingEdges() { DefaultDirectedGraph<String, TestEdge> graph = new DefaultDirectedGraph<String, TestEdge>(TestEdge.class); String a = "A"; String b = "B"; String c = "C"; graph.addVertex(b); Graph<String, TestEdge> expectedGraph = new DefaultDirectedGraph<String, TestEdge>(TestEdge.class); expect... | public static <V, E> void addOutgoingEdges(Graph<V, E> graph, V source, Iterable<V> targets) { if (!graph.containsVertex(source)) { graph.addVertex(source); } for (V target : targets) { if (!graph.containsVertex(target)) { graph.addVertex(target); } graph.addEdge(source, target); } } | Graphs { public static <V, E> void addOutgoingEdges(Graph<V, E> graph, V source, Iterable<V> targets) { if (!graph.containsVertex(source)) { graph.addVertex(source); } for (V target : targets) { if (!graph.containsVertex(target)) { graph.addVertex(target); } graph.addEdge(source, target); } } } | Graphs { public static <V, E> void addOutgoingEdges(Graph<V, E> graph, V source, Iterable<V> targets) { if (!graph.containsVertex(source)) { graph.addVertex(source); } for (V target : targets) { if (!graph.containsVertex(target)) { graph.addVertex(target); } graph.addEdge(source, target); } } } | Graphs { public static <V, E> void addOutgoingEdges(Graph<V, E> graph, V source, Iterable<V> targets) { if (!graph.containsVertex(source)) { graph.addVertex(source); } for (V target : targets) { if (!graph.containsVertex(target)) { graph.addVertex(target); } graph.addEdge(source, target); } } static E addEdge(Graph<V,... | Graphs { public static <V, E> void addOutgoingEdges(Graph<V, E> graph, V source, Iterable<V> targets) { if (!graph.containsVertex(source)) { graph.addVertex(source); } for (V target : targets) { if (!graph.containsVertex(target)) { graph.addVertex(target); } graph.addEdge(source, target); } } static E addEdge(Graph<V,... |
@Test public void testUndirectedWithGraphWhichAlreadyHasSomeVertices() { final long seed = 5; GraphGenerator<Integer, DefaultEdge, Integer> gen = new BarabasiAlbertGraphGenerator<>(3, 2, 10, seed); Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); g.addVertex(1000); gen.generateGraph(g, new IntegerV... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGraph(target, vertexFactory, resultMap); target.vertexSet().stream().f... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... | BarabasiAlbertGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { Set<V> oldNodes = new HashSet<>(target.vertexSet()); Set<V> newNodes = new HashSet<>(); new CompleteGraphGenerator<V, E>(m0).generateGrap... |
@Test public void testEmptyGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); Graphs.addAllVertices(g, Arrays.asList(0, 1, 2, 3)); ComplementGraphGenerator<Integer, DefaultEdge> cgg = new ComplementGraphGenerator<>(g); Graph<Integer, DefaultEdge> target = new SimpleWeightedGraph<>(DefaultEd... | public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); void generateGraph(Graph<V, E> target); @Override ... | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); void generateGraph(Graph<V, E> target); @Override ... |
@Test public void testUndirectedGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); Graphs.addAllVertices(g, Arrays.asList(0, 1, 2, 3)); g.addEdge(0, 1); g.addEdge(1, 2); g.addEdge(0, 2); ComplementGraphGenerator<Integer, DefaultEdge> cgg = new ComplementGraphGenerator<>(g); Graph<Integer, D... | public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); void generateGraph(Graph<V, E> target); @Override ... | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); void generateGraph(Graph<V, E> target); @Override ... |
@Test public void testDirectedGraph() { Graph<Integer, DefaultEdge> g = new SimpleDirectedGraph<>(DefaultEdge.class); Graphs.addAllVertices(g, Arrays.asList(0, 1, 2)); g.addEdge(0, 1); g.addEdge(1, 2); g.addEdge(0, 2); ComplementGraphGenerator<Integer, DefaultEdge> cgg = new ComplementGraphGenerator<>(g); Graph<Integer... | public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); void generateGraph(Graph<V, E> target); @Override ... | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); void generateGraph(Graph<V, E> target); @Override ... |
@Test public void testGraphWithSelfLoops() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); Graphs.addAllVertices(g, Arrays.asList(0, 1, 2)); g.addEdge(0, 1); g.addEdge(1, 2); g.addEdge(0, 2); ComplementGraphGenerator<Integer, DefaultEdge> cgg = new ComplementGraphGenerator<>(g, true); Graph<Inte... | public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); } | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); void generateGraph(Graph<V, E> target); @Override ... | ComplementGraphGenerator implements GraphGenerator<V, E, V> { public void generateGraph(Graph<V, E> target) { this.generateGraph(target, null, null); } ComplementGraphGenerator(Graph<V, E> graph); ComplementGraphGenerator(Graph<V, E> graph, boolean generateSelfLoops); void generateGraph(Graph<V, E> target); @Override ... |
@Test public void testCubicalGraph() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); GeneralizedPetersenGraphGenerator<Integer, DefaultEdge> gpgg = new GeneralizedPetersenGraphGenerator<>(4, 1); gpgg.generateGraph(g, new IntegerVertexFactory(), null); this.validateBasics(g, 8, 12, 3, 3, 4); asse... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (int i = 0; i < m; i++) { sub.clear(); sub.add(center); for (int... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... |
@Test public void testGraph1a() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new WindmillGraphsGenerator<Integer, DefaultEdge>( WindmillGraphsGenerator.Mode.WINDMILL, 3, 4) .generateGraph(g, new IntegerVertexFactory(), null); assertEquals(10, g.vertexSet().size()); assertEquals(18, g.edgeSet(... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (int i = 0; i < m; i++) { sub.clear(); sub.add(center); for (int... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... |
@Test public void testGraph2a() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new WindmillGraphsGenerator<Integer, DefaultEdge>( WindmillGraphsGenerator.Mode.WINDMILL, 4, 3) .generateGraph(g, new IntegerVertexFactory(), null); assertEquals(9, g.vertexSet().size()); assertEquals(12, g.edgeSet()... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (int i = 0; i < m; i++) { sub.clear(); sub.add(center); for (int... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... |
@Test public void testGraph3a() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new WindmillGraphsGenerator<Integer, DefaultEdge>( WindmillGraphsGenerator.Mode.WINDMILL, 3, 5) .generateGraph(g, new IntegerVertexFactory(), null); assertEquals(13, g.vertexSet().size()); assertEquals(30, g.edgeSet(... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (int i = 0; i < m; i++) { sub.clear(); sub.add(center); for (int... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... |
@Test public void testGraph2b() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new WindmillGraphsGenerator<Integer, DefaultEdge>( WindmillGraphsGenerator.Mode.DUTCHWINDMILL, 4, 3) .generateGraph(g, new IntegerVertexFactory(), null); assertEquals(9, g.vertexSet().size()); assertEquals(12, g.edge... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (int i = 0; i < m; i++) { sub.clear(); sub.add(center); for (int... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... |
@Test public void addIncomingEdges() { DefaultDirectedGraph<String, TestEdge> graph = new DefaultDirectedGraph<String, TestEdge>(TestEdge.class); String a = "A"; String b = "B"; String c = "C"; graph.addVertex(b); Graph<String, TestEdge> expectedGraph = new DefaultDirectedGraph<String, TestEdge>(TestEdge.class); expect... | public static <V, E> void addIncomingEdges(Graph<V, E> graph, V target, Iterable<V> sources) { if (!graph.containsVertex(target)) { graph.addVertex(target); } for (V source : sources) { if (!graph.containsVertex(source)) { graph.addVertex(source); } graph.addEdge(source, target); } } | Graphs { public static <V, E> void addIncomingEdges(Graph<V, E> graph, V target, Iterable<V> sources) { if (!graph.containsVertex(target)) { graph.addVertex(target); } for (V source : sources) { if (!graph.containsVertex(source)) { graph.addVertex(source); } graph.addEdge(source, target); } } } | Graphs { public static <V, E> void addIncomingEdges(Graph<V, E> graph, V target, Iterable<V> sources) { if (!graph.containsVertex(target)) { graph.addVertex(target); } for (V source : sources) { if (!graph.containsVertex(source)) { graph.addVertex(source); } graph.addEdge(source, target); } } } | Graphs { public static <V, E> void addIncomingEdges(Graph<V, E> graph, V target, Iterable<V> sources) { if (!graph.containsVertex(target)) { graph.addVertex(target); } for (V source : sources) { if (!graph.containsVertex(source)) { graph.addVertex(source); } graph.addEdge(source, target); } } static E addEdge(Graph<V,... | Graphs { public static <V, E> void addIncomingEdges(Graph<V, E> graph, V target, Iterable<V> sources) { if (!graph.containsVertex(target)) { graph.addVertex(target); } for (V source : sources) { if (!graph.containsVertex(source)) { graph.addVertex(source); } graph.addEdge(source, target); } } static E addEdge(Graph<V,... |
@Test public void testUnsupportedGraph() throws ImportException { String input = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + NL + "<graphml xmlns=\"http: "xmlns:xsi=\"http: "xsi:schemaLocation=\"http: "http: "<graph id=\"G\" edgedefault=\"undirected\">" + NL + "<node id=\"1\"/>" + NL + "<node id=\"2\"/>" + NL + "<no... | @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { XMLReader xmlReader = createXMLReader(); GraphMLHandler handler = new GraphMLHandler(); xmlReader.setContentHandler(handler); xmlReader.setErrorHandler(handler); xmlReader.parse(new InputSource(input)); handler.updateGraph... | GraphMLImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { XMLReader xmlReader = createXMLReader(); GraphMLHandler handler = new GraphMLHandler(); xmlReader.setContentHandler(handler); xmlReader.se... | GraphMLImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { XMLReader xmlReader = createXMLReader(); GraphMLHandler handler = new GraphMLHandler(); xmlReader.setContentHandler(handler); xmlReader.se... | GraphMLImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { XMLReader xmlReader = createXMLReader(); GraphMLHandler handler = new GraphMLHandler(); xmlReader.setContentHandler(handler); xmlReader.se... | GraphMLImporter extends AbstractBaseImporter<V, E> implements GraphImporter<V, E> { @Override public void importGraph(Graph<V, E> graph, Reader input) throws ImportException { try { XMLReader xmlReader = createXMLReader(); GraphMLHandler handler = new GraphMLHandler(); xmlReader.setContentHandler(handler); xmlReader.se... |
@Test public void testGraph3b() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); new WindmillGraphsGenerator<Integer, DefaultEdge>( WindmillGraphsGenerator.Mode.DUTCHWINDMILL, 3, 5) .generateGraph(g, new IntegerVertexFactory(), null); assertEquals(13, g.vertexSet().size()); assertEquals(15, g.edg... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (int i = 0; i < m; i++) { sub.clear(); sub.add(center); for (int... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... | WindmillGraphsGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { V center = vertexFactory.createVertex(); target.addVertex(center); List<V> sub = new ArrayList<>(n); if (mode == Mode.DUTCHWINDMILL) { for (in... |
@Test public void testZeroNodes() { GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(0, 1d); Graph<Integer, DefaultEdge> g = new DirectedPseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(1), null); assertEquals(0, g.edgeSet().size()); assertEquals(0, g.vert... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, E> abg = (AbstractBaseGraph<V, E>) target; if (!abg.isAllowin... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... |
@Test public void testDirectedGraphGnp1() { GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(6, 0.5, SEED); Graph<Integer, DefaultEdge> g = new DirectedPseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(1), null); assertEquals(6, g.vertexSet().size()); asser... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, E> abg = (AbstractBaseGraph<V, E>) target; if (!abg.isAllowin... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... |
@Test public void testDirectedGraphGnp2() { GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(6, 1.0, SEED); Graph<Integer, DefaultEdge> g = new DirectedPseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(1), null); assertEquals(6, g.vertexSet().size()); asser... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, E> abg = (AbstractBaseGraph<V, E>) target; if (!abg.isAllowin... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... |
@Test public void testDirectedGraphGnp3() { GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(6, 0.1, SEED); Graph<Integer, DefaultEdge> g = new DirectedPseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(1), null); assertEquals(6, g.vertexSet().size()); asser... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, E> abg = (AbstractBaseGraph<V, E>) target; if (!abg.isAllowin... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... |
@Test public void testDirectedGraphGnp4WithLoops() { final boolean allowLoops = true; GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(6, 0.2, SEED, allowLoops); Graph<Integer, DefaultEdge> g = new DirectedPseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(1... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, E> abg = (AbstractBaseGraph<V, E>) target; if (!abg.isAllowin... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... |
@Test public void testUndirectedGraphGnp1() { GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(6, 0.5, SEED); Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(1), null); assertEquals(6, g.vertexSet().size()); assertTrue(... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, E> abg = (AbstractBaseGraph<V, E>) target; if (!abg.isAllowin... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... |
@Test public void testUndirectedGraphGnp2() { GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(6, 1.0, SEED); Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(1), null); assertEquals(6, g.vertexSet().size()); assertTrue(... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, E> abg = (AbstractBaseGraph<V, E>) target; if (!abg.isAllowin... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... |
@Test public void testUndirectedGraphGnp3() { GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(6, 0.3, SEED); Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(1), null); assertEquals(6, g.vertexSet().size()); assertTrue(... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, E> abg = (AbstractBaseGraph<V, E>) target; if (!abg.isAllowin... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... |
@Test public void testUndirectedGraphGnp4WithLoops() { final boolean allowLoops = true; GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(6, 0.3, SEED, allowLoops); Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(1), nul... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, E> abg = (AbstractBaseGraph<V, E>) target; if (!abg.isAllowin... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... | GnpRandomGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } boolean createLoops = loops; if (createLoops) { if (target instanceof AbstractBaseGraph<?, ?>) { AbstractBaseGraph<V, ... |
@Test public void testGraphDiameter() { Graph<Integer, DefaultWeightedEdge> g = new SimpleDirectedWeightedGraph<>(DefaultWeightedEdge.class); Graphs.addEdgeWithVertices(g, 0, 1, 10); Graphs.addEdgeWithVertices(g, 1, 0, 12); double diameter = GraphMetrics.getDiameter(g); assertEquals(12.0, diameter, EPSILON); } | public static <V, E> double getDiameter(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getDiameter(); } | GraphMetrics { public static <V, E> double getDiameter(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getDiameter(); } } | GraphMetrics { public static <V, E> double getDiameter(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getDiameter(); } } | GraphMetrics { public static <V, E> double getDiameter(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getDiameter(); } static double getDiameter(Graph<V, E> graph); static double getRadius(Graph<V, E> graph); static int getGirth(Graph<V, E> graph); } | GraphMetrics { public static <V, E> double getDiameter(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getDiameter(); } static double getDiameter(Graph<V, E> graph); static double getRadius(Graph<V, E> graph); static int getGirth(Graph<V, E> graph); } |
@Test public void testUndirected() { final long seed = 5; GraphGenerator<Integer, DefaultEdge, Integer> gen = new KleinbergSmallWorldGraphGenerator<>(5, 2, 3, 2, seed); Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(), null); assertEquals(25, g.vertex... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUndirected(target); boolean isDirected = target.getType().isDirected(); Li... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... |
@Test public void testDirected() { final long seed = 5; GraphGenerator<Integer, DefaultEdge, Integer> gen = new KleinbergSmallWorldGraphGenerator<>(5, 2, 3, 2, seed); Graph<Integer, DefaultEdge> g = new SimpleDirectedGraph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(), null); assertEquals(25, g.... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUndirected(target); boolean isDirected = target.getType().isDirected(); Li... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... |
@Test public void testDirectedWithUniform() { final long seed = 5; GraphGenerator<Integer, DefaultEdge, Integer> gen = new KleinbergSmallWorldGraphGenerator<>(5, 2, 3, 0, seed); Graph<Integer, DefaultEdge> g = new SimpleDirectedGraph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(), null); assertEq... | @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUndirected(target); boolean isDirected = target.getType().isDirected(); Li... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... | KleinbergSmallWorldGraphGenerator implements GraphGenerator<V, E, V> { @Override public void generateGraph( Graph<V, E> target, VertexFactory<V> vertexFactory, Map<String, V> resultMap) { if (n == 0) { return; } else if (n == 1) { target.addVertex(vertexFactory.createVertex()); return; } GraphTests.requireDirectedOrUnd... |
@Test public void testIsEmpty() { Graph<Integer, DefaultEdge> g = new DefaultDirectedGraph<>(DefaultEdge.class); assertTrue(GraphTests.isEmpty(g)); g.addVertex(1); assertTrue(GraphTests.isEmpty(g)); g.addVertex(2); assertTrue(GraphTests.isEmpty(g)); DefaultEdge e = g.addEdge(1, 2); assertFalse(GraphTests.isEmpty(g)); g... | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testIsCompleteUndirected() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); assertTrue(GraphTests.isComplete(g)); g.addVertex(1); assertTrue(GraphTests.isComplete(g)); g.addVertex(2); assertFalse(GraphTests.isComplete(g)); g.addEdge(1, 2); assertTrue(GraphTests.isComplete(g)); g... | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testIsConnectedUndirected() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); assertFalse(GraphTests.isConnected(g)); g.addVertex(1); assertTrue(GraphTests.isConnected(g)); g.addVertex(2); assertFalse(GraphTests.isConnected(g)); g.addEdge(1, 2); assertTrue(GraphTests.isConnected(... | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testIsConnectedDirected() { Graph<Integer, DefaultEdge> g = new SimpleDirectedGraph<>(DefaultEdge.class); assertFalse(GraphTests.isWeaklyConnected(g)); assertFalse(GraphTests.isStronglyConnected(g)); g.addVertex(1); assertTrue(GraphTests.isWeaklyConnected(g)); assertTrue(GraphTests.isStronglyConnected... | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testIsTree() { Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); assertFalse(GraphTests.isTree(g)); g.addVertex(1); assertTrue(GraphTests.isTree(g)); g.addVertex(2); assertFalse(GraphTests.isTree(g)); g.addEdge(1, 2); assertTrue(GraphTests.isTree(g)); g.addVertex(3); assertFalse(Gr... | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testIsForest1() { Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); assertFalse(GraphTests.isForest(g)); g.addVertex(1); assertTrue(GraphTests.isForest(g)); g.addVertex(2); assertTrue(GraphTests.isForest(g)); g.addEdge(1, 2); assertTrue(GraphTests.isForest(g)); g.addEdge(1, 2); ass... | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void isSplit2() { Random rand = new Random(0); CompleteGraphGenerator<Integer, DefaultEdge> gen = new CompleteGraphGenerator<>(6); for (int inst = 0; inst < 5; inst++) { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); gen.generateGraph(g, new IntegerVertexFactory(0), null); for (int j... | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testGraphRadius() { Graph<Integer, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); double radius = GraphMetrics.getRadius(g); assertEquals(0.0, radius, EPSILON); } | public static <V, E> double getRadius(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getRadius(); } | GraphMetrics { public static <V, E> double getRadius(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getRadius(); } } | GraphMetrics { public static <V, E> double getRadius(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getRadius(); } } | GraphMetrics { public static <V, E> double getRadius(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getRadius(); } static double getDiameter(Graph<V, E> graph); static double getRadius(Graph<V, E> graph); static int getGirth(Graph<V, E> graph); } | GraphMetrics { public static <V, E> double getRadius(Graph<V, E> graph) { return new GraphMeasurer<>(graph).getRadius(); } static double getDiameter(Graph<V, E> graph); static double getRadius(Graph<V, E> graph); static int getGirth(Graph<V, E> graph); } |
@Test public void testBipartite1() { Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); assertTrue(GraphTests.isBipartite(g)); g.addVertex(1); assertTrue(GraphTests.isBipartite(g)); g.addVertex(2); assertTrue(GraphTests.isBipartite(g)); g.addEdge(1, 2); assertTrue(GraphTests.isBipartite(g)); g.addVer... | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testBipartite2() { Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); for (int i = 0; i < 100; i++) { g.addVertex(i); if (i > 0) { g.addEdge(i, i - 1); } } g.addEdge(99, 0); assertTrue(GraphTests.isBipartite(g)); } | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testBipartite3() { Graph<Integer, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); for (int i = 0; i < 101; i++) { g.addVertex(i); if (i > 0) { g.addEdge(i, i - 1); } } g.addEdge(100, 0); assertFalse(GraphTests.isBipartite(g)); } | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testBipartite4() { Graph<Integer, DefaultEdge> g = new DirectedPseudograph<>(DefaultEdge.class); for (int i = 0; i < 101; i++) { g.addVertex(i); if (i > 0) { g.addEdge(i, i - 1); } } g.addEdge(100, 0); assertFalse(GraphTests.isBipartite(g)); } | public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } } | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... | Graphs { public static <V, E> E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight) { EdgeFactory<V, E> ef = g.getEdgeFactory(); E e = ef.createEdge(sourceVertex, targetVertex); g.setEdgeWeight(e, weight); return g.addEdge(sourceVertex, targetVertex, e) ? e : null; } static E addEdge(Graph<V, E> g, V... |
@Test public void testIsCubic() { assertTrue(GraphTests.isCubic(NamedGraphGenerator.petersenGraph())); Graph<Integer, DefaultEdge> triangle = new SimpleGraph<>(DefaultEdge.class); Graphs.addEdgeWithVertices(triangle, 1, 2); Graphs.addEdgeWithVertices(triangle, 2, 3); Graphs.addEdgeWithVertices(triangle, 3, 1); assertFa... | public static <V, E> E addEdgeWithVertices(Graph<V, E> g, V sourceVertex, V targetVertex) { g.addVertex(sourceVertex); g.addVertex(targetVertex); return g.addEdge(sourceVertex, targetVertex); } | Graphs { public static <V, E> E addEdgeWithVertices(Graph<V, E> g, V sourceVertex, V targetVertex) { g.addVertex(sourceVertex); g.addVertex(targetVertex); return g.addEdge(sourceVertex, targetVertex); } } | Graphs { public static <V, E> E addEdgeWithVertices(Graph<V, E> g, V sourceVertex, V targetVertex) { g.addVertex(sourceVertex); g.addVertex(targetVertex); return g.addEdge(sourceVertex, targetVertex); } } | Graphs { public static <V, E> E addEdgeWithVertices(Graph<V, E> g, V sourceVertex, V targetVertex) { g.addVertex(sourceVertex); g.addVertex(targetVertex); return g.addEdge(sourceVertex, targetVertex); } static E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight); static E addEdgeWithVertices(Graph<V... | Graphs { public static <V, E> E addEdgeWithVertices(Graph<V, E> g, V sourceVertex, V targetVertex) { g.addVertex(sourceVertex); g.addVertex(targetVertex); return g.addEdge(sourceVertex, targetVertex); } static E addEdge(Graph<V, E> g, V sourceVertex, V targetVertex, double weight); static E addEdgeWithVertices(Graph<V... |
@Test public void testEmptyGraph() { Graph<String, DefaultEdge> graph = new DefaultDirectedGraph<>(DefaultEdge.class); Iterator<String> iter = new TopologicalOrderIterator<>(graph); assertFalse(iter.hasNext()); } | @Override public boolean hasNext() { if (cur != null) { return true; } cur = advance(); if (cur != null && nListeners != 0) { fireVertexTraversed(createVertexTraversalEvent(cur)); } return cur != null; } | TopologicalOrderIterator extends AbstractGraphIterator<V, E> { @Override public boolean hasNext() { if (cur != null) { return true; } cur = advance(); if (cur != null && nListeners != 0) { fireVertexTraversed(createVertexTraversalEvent(cur)); } return cur != null; } } | TopologicalOrderIterator extends AbstractGraphIterator<V, E> { @Override public boolean hasNext() { if (cur != null) { return true; } cur = advance(); if (cur != null && nListeners != 0) { fireVertexTraversed(createVertexTraversalEvent(cur)); } return cur != null; } TopologicalOrderIterator(Graph<V, E> graph); @Depreca... | TopologicalOrderIterator extends AbstractGraphIterator<V, E> { @Override public boolean hasNext() { if (cur != null) { return true; } cur = advance(); if (cur != null && nListeners != 0) { fireVertexTraversed(createVertexTraversalEvent(cur)); } return cur != null; } TopologicalOrderIterator(Graph<V, E> graph); @Depreca... | TopologicalOrderIterator extends AbstractGraphIterator<V, E> { @Override public boolean hasNext() { if (cur != null) { return true; } cur = advance(); if (cur != null && nListeners != 0) { fireVertexTraversed(createVertexTraversalEvent(cur)); } return cur != null; } TopologicalOrderIterator(Graph<V, E> graph); @Depreca... |
@Test(expected = IllegalArgumentException.class) public void testTryToDisableCrossComponent() { Graph<Integer, DefaultEdge> graph = new DirectedPseudograph<>(DefaultEdge.class); new TopologicalOrderIterator<>(graph).setCrossComponentTraversal(false); } | @Override public void setCrossComponentTraversal(boolean crossComponentTraversal) { if (!crossComponentTraversal) { throw new IllegalArgumentException("Iterator is always cross-component"); } } | TopologicalOrderIterator extends AbstractGraphIterator<V, E> { @Override public void setCrossComponentTraversal(boolean crossComponentTraversal) { if (!crossComponentTraversal) { throw new IllegalArgumentException("Iterator is always cross-component"); } } } | TopologicalOrderIterator extends AbstractGraphIterator<V, E> { @Override public void setCrossComponentTraversal(boolean crossComponentTraversal) { if (!crossComponentTraversal) { throw new IllegalArgumentException("Iterator is always cross-component"); } } TopologicalOrderIterator(Graph<V, E> graph); @Deprecated Topol... | TopologicalOrderIterator extends AbstractGraphIterator<V, E> { @Override public void setCrossComponentTraversal(boolean crossComponentTraversal) { if (!crossComponentTraversal) { throw new IllegalArgumentException("Iterator is always cross-component"); } } TopologicalOrderIterator(Graph<V, E> graph); @Deprecated Topol... | TopologicalOrderIterator extends AbstractGraphIterator<V, E> { @Override public void setCrossComponentTraversal(boolean crossComponentTraversal) { if (!crossComponentTraversal) { throw new IllegalArgumentException("Iterator is always cross-component"); } } TopologicalOrderIterator(Graph<V, E> graph); @Deprecated Topol... |
@Test public void testGraphGirthAcyclic() { Graph<Integer, DefaultEdge> tree = new SimpleGraph<>(DefaultEdge.class); Graphs.addAllVertices(tree, Arrays.asList(0, 1, 2, 3, 4, 5)); tree.addEdge(0, 1); tree.addEdge(0, 4); tree.addEdge(0, 5); tree.addEdge(1, 2); tree.addEdge(1, 3); assertEquals(Integer.MAX_VALUE, GraphMetr... | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testGraphDirectedAcyclic() { Graph<Integer, DefaultEdge> tree = new SimpleDirectedGraph<>(DefaultEdge.class); Graphs.addAllVertices(tree, Arrays.asList(0, 1, 2, 3)); tree.addEdge(0, 1); tree.addEdge(0, 2); tree.addEdge(1, 3); tree.addEdge(2, 3); assertEquals(Integer.MAX_VALUE, GraphMetrics.getGirth(tr... | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testGraphDirectedCyclic() { Graph<Integer, DefaultEdge> tree = new SimpleDirectedGraph<>(DefaultEdge.class); Graphs.addAllVertices(tree, Arrays.asList(0, 1, 2, 3)); tree.addEdge(0, 1); tree.addEdge(1, 2); tree.addEdge(2, 3); tree.addEdge(3, 0); assertEquals(4, GraphMetrics.getGirth(tree)); } | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testGraphDirectedCyclic2() { Graph<Integer, DefaultEdge> tree = new SimpleDirectedGraph<>(DefaultEdge.class); Graphs.addAllVertices(tree, Arrays.asList(0, 1)); tree.addEdge(0, 1); tree.addEdge(1, 0); assertEquals(2, GraphMetrics.getGirth(tree)); } | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testGraphGirthGridGraph() { Graph<Integer, DefaultEdge> grid = new SimpleGraph<>(DefaultEdge.class); GraphGenerator<Integer, DefaultEdge, Integer> gen = new GridGraphGenerator<>(3, 4); gen.generateGraph(grid, new IntegerVertexFactory(), null); assertEquals(4, GraphMetrics.getGirth(grid)); } | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testGraphGirthRingGraphEven() { Graph<Integer, DefaultEdge> ring = new SimpleGraph<>(DefaultEdge.class); GraphGenerator<Integer, DefaultEdge, Integer> gen = new RingGraphGenerator<>(10); gen.generateGraph(ring, new IntegerVertexFactory(), null); assertEquals(10, GraphMetrics.getGirth(ring)); } | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testGraphGirthRingGraphOdd() { Graph<Integer, DefaultEdge> ring = new SimpleGraph<>(DefaultEdge.class); GraphGenerator<Integer, DefaultEdge, Integer> gen = new RingGraphGenerator<>(9); gen.generateGraph(ring, new IntegerVertexFactory(), null); assertEquals(9, GraphMetrics.getGirth(ring)); } | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testGraphGirthWheelGraph() { Graph<Integer, DefaultEdge> grid = new SimpleGraph<>(DefaultEdge.class); GraphGenerator<Integer, DefaultEdge, Integer> gen = new WheelGraphGenerator<>(5); gen.generateGraph(grid, new IntegerVertexFactory(), null); assertEquals(3, GraphMetrics.getGirth(grid)); } | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testEmptyGraph() throws UnsupportedEncodingException, ExportException { Graph<Integer, DefaultEdge> orig = new SimpleGraph<>(DefaultEdge.class); String res = exportGraph(orig, Graph6Sparse6Exporter.Format.SPARSE6); assertEquals(":?", res); } | @Override public void exportGraph(Graph<V, E> g, Writer writer) throws ExportException { GraphTests.requireUndirected(g); if(format == Format.GRAPH6 && !GraphTests.isSimple(g)) throw new ExportException("Graphs exported in graph6 format cannot contain loops or multiple edges."); List<V> vertices = new ArrayList<>(g.ver... | Graph6Sparse6Exporter implements GraphExporter<V, E> { @Override public void exportGraph(Graph<V, E> g, Writer writer) throws ExportException { GraphTests.requireUndirected(g); if(format == Format.GRAPH6 && !GraphTests.isSimple(g)) throw new ExportException("Graphs exported in graph6 format cannot contain loops or mult... | Graph6Sparse6Exporter implements GraphExporter<V, E> { @Override public void exportGraph(Graph<V, E> g, Writer writer) throws ExportException { GraphTests.requireUndirected(g); if(format == Format.GRAPH6 && !GraphTests.isSimple(g)) throw new ExportException("Graphs exported in graph6 format cannot contain loops or mult... | Graph6Sparse6Exporter implements GraphExporter<V, E> { @Override public void exportGraph(Graph<V, E> g, Writer writer) throws ExportException { GraphTests.requireUndirected(g); if(format == Format.GRAPH6 && !GraphTests.isSimple(g)) throw new ExportException("Graphs exported in graph6 format cannot contain loops or mult... | Graph6Sparse6Exporter implements GraphExporter<V, E> { @Override public void exportGraph(Graph<V, E> g, Writer writer) throws ExportException { GraphTests.requireUndirected(g); if(format == Format.GRAPH6 && !GraphTests.isSimple(g)) throw new ExportException("Graphs exported in graph6 format cannot contain loops or mult... |
@Test public void testGraphDirected1() { Graph<Integer, DefaultEdge> graph = new SimpleDirectedGraph<>(DefaultEdge.class); Graphs.addAllVertices(graph, Arrays.asList(0, 1, 2, 3)); graph.addEdge(1, 0); graph.addEdge(3, 0); graph.addEdge(1, 2); graph.addEdge(2, 3); graph.addEdge(3, 2); assertEquals(2, GraphMetrics.getGir... | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testPseudoGraphUndirected() { Graph<Integer, DefaultEdge> graph = new Pseudograph<>(DefaultEdge.class); Graphs.addAllVertices(graph, Arrays.asList(0, 1, 2, 3)); graph.addEdge(0, 1); graph.addEdge(0, 1); graph.addEdge(1, 2); graph.addEdge(2, 2); graph.addEdge(2, 3); graph.addEdge(3, 0); assertEquals(1,... | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testPseudoGraphDirected() { Graph<Integer, DefaultEdge> graph = new DirectedPseudograph<>(DefaultEdge.class); Graphs.addAllVertices(graph, Arrays.asList(0, 1, 2, 3)); graph.addEdge(0, 1); graph.addEdge(0, 1); graph.addEdge(1, 2); graph.addEdge(2, 2); graph.addEdge(2, 3); graph.addEdge(3, 0); assertEqu... | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testMultiGraphUndirected() { Graph<Integer, DefaultEdge> graph = new Multigraph<>(DefaultEdge.class); Graphs.addAllVertices(graph, Arrays.asList(0, 1, 2, 3)); graph.addEdge(0, 1); graph.addEdge(0, 1); graph.addEdge(1, 2); graph.addEdge(2, 3); graph.addEdge(3, 0); assertEquals(2, GraphMetrics.getGirth(... | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testMultiGraphDirected() { Graph<Integer, DefaultEdge> graph = new DirectedMultigraph<>(DefaultEdge.class); Graphs.addAllVertices(graph, Arrays.asList(0, 1, 2, 3)); graph.addEdge(0, 1); graph.addEdge(0, 1); graph.addEdge(1, 2); graph.addEdge(2, 3); graph.addEdge(3, 0); assertEquals(4, GraphMetrics.get... | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testDirectedGraphs() { GraphGenerator<Integer, DefaultEdge, Integer> gen = new GnpRandomGraphGenerator<>(10, .55, 0); for (int i = 0; i < 10; i++) { Graph<Integer, DefaultEdge> graph = new SimpleDirectedGraph<>(DefaultEdge.class); gen.generateGraph(graph, new IntegerVertexFactory(), null); TarjanSimpl... | public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexMap.put(vertices... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... | GraphMetrics { public static <V, E> int getGirth(Graph<V, E> graph) { final int NIL = -1; final boolean isAllowingMultipleEdges = graph.getType().isAllowingMultipleEdges(); List<V> vertices = new ArrayList<>(graph.vertexSet()); Map<V, Integer> indexMap = new HashMap<>(); for (int i = 0; i < vertices.size(); i++) indexM... |
@Test public void testFindBiggest() { SimpleGraph<String, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); createGraph(g); BaseBronKerboschCliqueFinder<String, DefaultEdge> finder = createFinder1(g); Collection<Set<String>> cliques = new HashSet<>(); finder.maximumIterator().forEachRemaining(cliques::add); assert... | public Iterator<Set<V>> maximumIterator() { lazyRun(); return allMaximalCliques.stream().filter(c -> c.size() == maxSize).iterator(); } | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { public Iterator<Set<V>> maximumIterator() { lazyRun(); return allMaximalCliques.stream().filter(c -> c.size() == maxSize).iterator(); } } | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { public Iterator<Set<V>> maximumIterator() { lazyRun(); return allMaximalCliques.stream().filter(c -> c.size() == maxSize).iterator(); } BaseBronKerboschCliqueFinder(Graph<V, E> graph, long timeout, TimeUnit unit); } | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { public Iterator<Set<V>> maximumIterator() { lazyRun(); return allMaximalCliques.stream().filter(c -> c.size() == maxSize).iterator(); } BaseBronKerboschCliqueFinder(Graph<V, E> graph, long timeout, TimeUnit unit); @Override Iterator<Set<V... | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { public Iterator<Set<V>> maximumIterator() { lazyRun(); return allMaximalCliques.stream().filter(c -> c.size() == maxSize).iterator(); } BaseBronKerboschCliqueFinder(Graph<V, E> graph, long timeout, TimeUnit unit); @Override Iterator<Set<V... |
@Test public void testFindAll() { SimpleGraph<String, DefaultEdge> g = new SimpleGraph<>(DefaultEdge.class); createGraph(g); MaximalCliqueEnumerationAlgorithm<String, DefaultEdge> finder = createFinder1(g); Collection<Set<String>> cliques = new HashSet<>(); finder.iterator().forEachRemaining(cliques::add); assertEquals... | @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } } | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } BaseBronKerboschCliqueFinder(Graph<V, E> graph, long timeout, TimeUnit unit); } | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } BaseBronKerboschCliqueFinder(Graph<V, E> graph, long timeout, TimeUnit unit); @Override Iterator<Set<V>> iterator(); Iterator<Set<V>> maximum... | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } BaseBronKerboschCliqueFinder(Graph<V, E> graph, long timeout, TimeUnit unit); @Override Iterator<Set<V>> iterator(); Iterator<Set<V>> maximum... |
@Test(expected = IllegalArgumentException.class) public void testNonSimple() { Graph<String, DefaultEdge> g = new Pseudograph<>(DefaultEdge.class); g.addVertex("1"); g.addVertex("2"); g.addEdge("1", "2"); g.addEdge("1", "2"); MaximalCliqueEnumerationAlgorithm<String, DefaultEdge> finder = createFinder1(g); Iterator<Set... | @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } } | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } BaseBronKerboschCliqueFinder(Graph<V, E> graph, long timeout, TimeUnit unit); } | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } BaseBronKerboschCliqueFinder(Graph<V, E> graph, long timeout, TimeUnit unit); @Override Iterator<Set<V>> iterator(); Iterator<Set<V>> maximum... | BaseBronKerboschCliqueFinder implements MaximalCliqueEnumerationAlgorithm<V, E> { @Override public Iterator<Set<V>> iterator() { lazyRun(); return allMaximalCliques.iterator(); } BaseBronKerboschCliqueFinder(Graph<V, E> graph, long timeout, TimeUnit unit); @Override Iterator<Set<V>> iterator(); Iterator<Set<V>> maximum... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.