コード例 #1
0
 def test_exceptions(self):
     self.assertRaises(ValueError, CompleteBipartiteGraphEdgeColoring,
                       Graph(5, directed=True))
     gf = GraphFactory(Graph)
     G = gf.make_bipartite(2, 2, False, 1)
     #G.show()
     G.del_edge(Edge(0, 2))  # nie bedzie pelny dwudzielny
     self.assertRaises(ValueError, CompleteBipartiteGraphEdgeColoring, G)
コード例 #2
0
 def test_exceptions(self):
     self.assertRaises(ValueError, BipartiteGraphEdgeColoring,
                       Graph(5, directed=True))
     gf = GraphFactory(Graph)
     G = gf.make_cyclic(4)
     #G.show()
     G.add_edge(Edge(0, 2))  # nie bedzie dwudzielny
     self.assertRaises(ValueError, BipartiteGraphEdgeColoring, G)
コード例 #3
0
 def test_cyclic_graph(self):
     N = 8
     assert N % 2 == 0
     gf = GraphFactory(Graph)
     G = gf.make_cyclic(N)
     algorithm = BipartiteGraphEdgeColoring(G)
     algorithm.run()
     for edge in G.iteredges():
         self.assertNotEqual(algorithm.color[edge], None)
     for node in G.iternodes():
         color_set = set()
         for edge in G.iteroutedges(node):
             if edge.source > edge.target:
                 color_set.add(algorithm.color[~edge])
             else:
                 color_set.add(algorithm.color[edge])
         self.assertEqual(len(color_set), G.degree(node))
     #print algorithm.color
     #algorithm.show_colors()
     all_colors = set(algorithm.color[edge] for edge in G.iteredges())
     self.assertEqual(len(all_colors), 2)
コード例 #4
0
 def test_Kn_even(self):
     N = 10
     self.assertEqual(N % 2, 0)
     gf = GraphFactory(Graph)
     G = gf.make_complete(N)
     algorithm = CompleteGraphEdgeColoring(G)
     algorithm.run()
     for edge in G.iteredges():
         self.assertNotEqual(algorithm.color[edge], None)
     for node in G.iternodes():
         color_set = set()
         for edge in G.iteroutedges(node):
             if edge.source > edge.target:
                 color_set.add(algorithm.color[~edge])
             else:
                 color_set.add(algorithm.color[edge])
         self.assertEqual(len(color_set), G.degree(node))
     #print algorithm.color
     #algorithm.show_colors()
     all_colors = set(algorithm.color[edge] for edge in G.iteredges())
     self.assertEqual(len(all_colors), N - 1)
コード例 #5
0
 def test_bipartite(self):
     N1 = 10
     N2 = 13
     gf = GraphFactory(Graph)
     G = gf.make_bipartite(N1, N2)
     algorithm = BipartiteGraphEdgeColoring(G)
     algorithm.run()
     for edge in G.iteredges():
         self.assertNotEqual(algorithm.color[edge], None)
     for node in G.iternodes():
         color_set = set()
         for edge in G.iteroutedges(node):
             if edge.source > edge.target:
                 color_set.add(algorithm.color[~edge])
             else:
                 color_set.add(algorithm.color[edge])
         self.assertEqual(len(color_set), G.degree(node))
     #print algorithm.color
     #algorithm.show_colors()
     all_colors = set(algorithm.color[edge] for edge in G.iteredges())
     Delta = max(G.degree(node) for node in G.iternodes())
     self.assertEqual(len(all_colors), Delta)
コード例 #6
0
 def test_Kpq(self):
     N1 = 15
     N2 = 13
     gf = GraphFactory(Graph)
     G = gf.make_bipartite(N1, N2, False, 1)
     self.assertFalse(G.is_directed())
     self.assertEqual(G.v(), N1 + N2)
     self.assertEqual(G.e(), N1 * N2)
     algorithm = BipartiteGraphEdgeColoring(G)
     algorithm.run()
     for edge in G.iteredges():
         self.assertNotEqual(algorithm.color[edge], None)
     for node in G.iternodes():
         color_set = set()
         for edge in G.iteroutedges(node):
             if edge.source > edge.target:
                 color_set.add(algorithm.color[~edge])
             else:
                 color_set.add(algorithm.color[edge])
         self.assertEqual(len(color_set), G.degree(node))
     #print algorithm.color
     #algorithm.show_colors()
     all_colors = set(algorithm.color[edge] for edge in G.iteredges())
     self.assertEqual(len(all_colors), max(N1, N2))
コード例 #7
0
#!/usr/bin/python

import unittest
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.seriesparallel.sptools import make_random_spgraph
from graphtheory.seriesparallel.sptools import find_peo_spgraph1
from graphtheory.seriesparallel.sptools import find_peo_spgraph2

print("Testing random sp-graph ...")
G = make_random_spgraph(15)
#G.show()
print("peo1 {}".format(find_peo_spgraph1(G)))
print("peo2 {}".format(find_peo_spgraph2(G)))

print("Testing complete graph ...")
gf = GraphFactory(Graph)
G = gf.make_complete(4)
#G.show()
#print ( "peo1 {}".format(find_peo_spgraph1(G)) )   # ValueError
#print ( "peo2 {}".format(find_peo_spgraph2(G)) )   # ValueError

print("Testing cyclic graph ...")
G = gf.make_cyclic(10)
#G.show()
print("peo1 {}".format(find_peo_spgraph1(G)))
print("peo2 {}".format(find_peo_spgraph2(G)))

# EOF
コード例 #8
0
#!/usr/bin/python

import math
import random
import timeit
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.hamiltonian.tspbf import BruteForceTSPWithGraph
from graphtheory.hamiltonian.tspnn import NearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tsprnn import RepeatedNearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tspse import SortedEdgeTSPWithGraph

V = 8
graph_factory = GraphFactory(Graph)
G = graph_factory.make_complete(V, False)
E = G.e()
#G.show()

print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()
print "Delta:", max(G.degree(node) for node in G.iternodes())

print "Testing BruteForceTSPWithGraph ..."
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print V, E, t1.timeit(1)            # single run

print "Testing NearestNeighborTSPWithGraph ..."
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
コード例 #9
0
ファイル: test_wheels.py プロジェクト: yjfiejd/graphs-dict
 def setUp(self):
     self.graph_factory = GraphFactory(Graph)
コード例 #10
0
#!/usr/bin/python

import timeit
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.forests.treedset import BorieDominatingSet
from graphtheory.forests.treedset import TreeDominatingSet1
from graphtheory.forests.treedset import TreeDominatingSet2

V = 10
E = V - 1  # tree
graph_factory = GraphFactory(Graph)
G = graph_factory.make_tree(V, False)
#G.show()

print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()

algorithm = BorieDominatingSet(G)
algorithm.run()
print algorithm.dominating_set
print "borie dset", algorithm.cardinality

algorithm = TreeDominatingSet1(G)
algorithm.run()
print algorithm.dominating_set
print "tree dset1", algorithm.cardinality
コード例 #11
0
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet2
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet3
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet4
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet5
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet6
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet7
from graphtheory.independentsets.isetll import LargestLastIndependentSet1
from graphtheory.independentsets.isetll import LargestLastIndependentSet2
from graphtheory.independentsets.isetll import LargestLastIndependentSet3
from graphtheory.independentsets.isetll import LargestLastIndependentSet4
from graphtheory.independentsets.isetll import LargestLastIndependentSet5
from graphtheory.independentsets.isetll import LargestLastIndependentSet6
from graphtheory.independentsets.isetll import LargestLastIndependentSet7

V = 10
graph_factory = GraphFactory(Graph)
G = graph_factory.make_random(V, False, edge_probability=0.5)
E = G.e()
#G.show()

print("Calculate parameters ...")
print("Nodes: {} {}".format(G.v(), V))
print("Edges: {} {}".format(G.e(), E))
print("Directed: {}".format(G.is_directed()))

print("Testing UnorderedSequentialIndependentSet1 ...")
t1 = timeit.Timer(lambda: UnorderedSequentialIndependentSet1(G).run())
print("{} {} {}".format(V, E, t1.timeit(1)))  # single run

print("Testing UnorderedSequentialIndependentSet2 ...")
t1 = timeit.Timer(lambda: UnorderedSequentialIndependentSet2(G).run())
コード例 #12
0
ファイル: timeit_tsp2.py プロジェクト: kgashok/graphs-dict
#!/usr/bin/python

import math
import random
import timeit
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.hamiltonian.tspbf import BruteForceTSPWithGraph
from graphtheory.hamiltonian.tspnn import NearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tsprnn import RepeatedNearestNeighborTSPWithGraph
from graphtheory.hamiltonian.tspse import SortedEdgeTSPWithGraph

V = 8
graph_factory = GraphFactory(Graph)
G = graph_factory.make_complete(V, False)
E = G.e()
#G.show()

print("Calculate parameters ...")
print("Nodes: {} {}".format(G.v(), V))
print("Edges: {} {}".format(G.e(), E))
print("Directed: {}".format(G.is_directed()))
print("Delta: {}".format(max(G.degree(node) for node in G.iternodes())))

print("Testing BruteForceTSPWithGraph ...")
t1 = timeit.Timer(lambda: BruteForceTSPWithGraph(G).run())
print("{} {} {}".format(V, E, t1.timeit(1)))  # single run

print("Testing NearestNeighborTSPWithGraph ...")
t1 = timeit.Timer(lambda: NearestNeighborTSPWithGraph(G).run())
コード例 #13
0
 def setUp(self):
     self.N = 5  # number of nodes
     graph_factory = GraphFactory(Graph)
     self.G = graph_factory.make_complete(self.N, True)
コード例 #14
0
class TestHalinGraph(unittest.TestCase):

    def setUp(self):
        self.graph_factory = GraphFactory(Graph)

    def test_k4(self):    # graf K4 = W4
        G = self.graph_factory.make_complete(n=4, directed=False)
        # Sa 4 mozliwosci narysowania K4 na plaszczyznie bez przeciec.
        algorithm = HalinGraph(G)
        algorithm.run()
        self.assertTrue(algorithm.is_outer_k4())

# 2---3    numeracja wg cyklu Hamiltona
# |\ /|    wheel graph W_5
# | 0 |
# |/ \|
# 1---4
    def test_wheel5(self):
        N = 5
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 3), Edge(0, 4), 
            Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(4, 1)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "wheel5 outer", algorithm.outer
        self.assertEqual(algorithm.outer, set([1, 2, 3, 4]))
        self.assertTrue(algorithm.is_outer_k4())

# 2-------3   numeracja wg cyklu Hamiltona
# |\     /|   3-prism graph
# | 1---4 |   cubic, planar
# |/     \|
# 0-------5
    def test_3prism(self):
        N = 6
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(3, 4), 
            Edge(4, 5), Edge(0, 5), Edge(1, 4), Edge(2, 0), Edge(3, 5)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "3prism outer", algorithm.outer
        #self.assertEqual(algorithm.outer, set([0, 2, 3, 5]))
        self.assertEqual(algorithm.outer, set([0, 1, 4, 5]))
        #self.assertEqual(algorithm.outer, set([1, 2, 3, 4]))
        self.assertTrue(algorithm.is_outer_k4())

#  4-------5   4-prism graph
#  |\     /|   non-Halin graph
#  | 0---1 |   Hamiltonian [0, 1, 2, 3, 7, 6, 5, 4]
#  | |   | |   cubic, planar
#  | 3---2 |
#  |/     \|
#  7-------6
    def test_4prism(self):
        N = 8
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(3, 0), 
            Edge(4, 5), Edge(5, 6), Edge(6, 7), Edge(7, 4), 
            Edge(0, 4), Edge(1, 5), Edge(2, 6), Edge(3, 7)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #G.show()
        algorithm = HalinGraph(G)
        self.assertRaises(ValueError, algorithm.run)

# 2-------3       numeracja wg cyklu Hamiltona
# |\     / \     heptahedral graph 2
# | 1---4---5   http://mathworld.wolfram.com/HalinGraph.html
# |/     \ /
# 0-------6
    def test_halin7(self):
        N = 7
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 6), Edge(1, 2), 
            Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 5), 
            Edge(4, 5), Edge(4, 6), Edge(5, 6)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "halin7 outer", algorithm.outer
        self.assertEqual(algorithm.outer, set([0, 2, 3, 5, 6]))
        self.assertTrue(algorithm.is_outer_k4())

# 0-----7-----6  numeracja wg cyklu Hamiltona
# |\    |    /|
# | 2---3---4 |
# |/         \|
# 1-----------5
    def test_halin8a(self):
        N = 8
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 7), Edge(1, 2), 
            Edge(1, 5), Edge(2, 3), Edge(3, 4), Edge(3, 7), 
            Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "halin8a outer", algorithm.outer
        # Sa dwie mozliwosci narysowania tego grafu.
        self.assertEqual(algorithm.outer, set([0, 1, 5, 6, 7]))
        #self.assertEqual(algorithm.outer, set([1, 2, 3, 4, 5]))
        self.assertTrue(algorithm.is_outer_k4())

#   2-------3      numeracja wg cyklu Hamiltona
#  / \     / \
# 1---7---6---4
#  \ /     \ /
#   0-------5
    def test_halin8b(self):
        N = 8
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 5), Edge(0, 7), Edge(1, 2), 
            Edge(1, 7), Edge(2, 3), Edge(2, 7), Edge(3, 4), 
            Edge(3, 6), Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "halin8b outer", algorithm.outer
        self.assertEqual(algorithm.outer, set([0, 1, 2, 3, 4, 5]))
        self.assertTrue(algorithm.is_outer_k4())

# 1---2---3    numeracja wg cyklu Hamiltona
# |\   \ /|
# | 7---6 |
# |/   / \|
# 0---5---4
    def test_halin8c(self):
        N = 8
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 5), Edge(0, 7), Edge(1, 2), 
            Edge(1, 7), Edge(2, 3), Edge(2, 6), Edge(3, 4), Edge(3, 6), 
            Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "halin8c outer", algorithm.outer
        self.assertEqual(algorithm.outer, set([0, 1, 2, 3, 4, 5]))
        self.assertTrue(algorithm.is_outer_k4())

# 1-----4---5-----8    numeracja wg cyklu Hamiltona
# |\    |   |    /|    graf kubiczny
# | 2---3---6---7 |
# |/             \|
# 0---------------9
    def test_halin10j(self):
        N = 10
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 9), Edge(1, 2), 
            Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 6), 
            Edge(4, 5), Edge(5, 6), Edge(5, 8), Edge(6, 7), 
            Edge(7, 8), Edge(7, 9), Edge(8, 9)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "halin10j outer", algorithm.outer
        self.assertEqual(algorithm.outer, set([0, 1, 4, 5, 8, 9]))
        self.assertTrue(algorithm.is_outer_k4())

# 1-----4---------5    numeracja wg cyklu Hamiltona
# |\    |        /|    graf kubiczny
# | 2---3---8---7 |
# |/        |    \|
# 0---------9-----6
    def test_halin10k(self):
        N = 10
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 9), Edge(1, 2), 
            Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 8), 
            Edge(4, 5), Edge(5, 6), Edge(5, 7), Edge(6, 7), 
            Edge(6, 9), Edge(7, 8), Edge(8, 9)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "halin10k outer", algorithm.outer
        self.assertEqual(algorithm.outer, set([0, 1, 4, 5, 6, 9]))
        self.assertTrue(algorithm.is_outer_k4())

#   --4---5--
#  /   \ /   \
# 0     3     6    numeracja wg cyklu Hamiltona
# |\    |    /|    graf kubiczny
# | 1---2---7 |
# |/         \|
# 9-----------8
    def test_halin10l(self):
        N = 10
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 4), Edge(0, 9), Edge(1, 2), 
            Edge(1, 9), Edge(2, 3), Edge(2, 7), Edge(3, 4), 
            Edge(3, 5), Edge(4, 5), Edge(5, 6), Edge(6, 7), 
            Edge(6, 8), Edge(7, 8), Edge(8, 9)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "halin10l outer", algorithm.outer
        self.assertEqual(algorithm.outer, set([0, 4, 5, 6, 8, 9]))
        self.assertTrue(algorithm.is_outer_k4())

#   -----------11
#  /           / \
# 0-------1--10---9    numeracja wg cyklu Hamiltona
# |       |       |    cubic Frucht graph
# 4---3---2---7---8
#  \ /         \ /
#   5-----------6
    def test_frucht12(self):
        N = 10
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 4), Edge(0, 11), Edge(1, 2), 
            Edge(1, 10), Edge(2, 3), Edge(2, 7), Edge(3, 4), 
            Edge(3, 5), Edge(4, 5), Edge(5, 6), Edge(6, 7), 
            Edge(6, 8), Edge(7, 8), Edge(8, 9), Edge(9, 10), 
            Edge(9, 11), Edge(10, 11)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraph(G)
        algorithm.run()
        #print "frucht12 outer", algorithm.outer
        self.assertEqual(algorithm.outer, set([0, 4, 5, 6, 8, 9, 11]))
        self.assertTrue(algorithm.is_outer_k4())

    def tearDown(self): pass
コード例 #15
0
class TestNodeColoring(unittest.TestCase):
    def setUp(self):
        self.graph_factory = GraphFactory(Graph)

    def test_k4(self):  # graf K4 = W4
        G = self.graph_factory.make_complete(n=4, directed=False)
        # Sa 4 mozliwosci narysowania K4 na plaszczyznie bez przeciec.
        algorithm = HalinNodeColoring(G, outer=set([1, 2, 3]))
        algorithm.run()
        parent = {0: None, 1: 0, 2: 0, 3: 0}
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 4)

# 2---3    numeracja wg cyklu Hamiltona
# |\ /|    wheel graph W_5
# | 0 |
# |/ \|
# 1---4

    def test_wheel5(self):
        N = 5
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 2),
            Edge(0, 3),
            Edge(0, 4),
            Edge(1, 2),
            Edge(2, 3),
            Edge(3, 4),
            Edge(4, 1)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinNodeColoring(G, outer=set([1, 2, 3, 4]))
        algorithm.run()
        #print "wheel5 outer", algorithm.outer
        #print "wheel5 cycle", algorithm.cycle
        parent = {0: None, 1: 0, 2: 0, 3: 0, 4: 0}
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

# 2-------3   numeracja wg cyklu Hamiltona
# |\     /|   3-prism graph
# | 1---4 |   cubic, planar
# |/     \|
# 0-------5

    def test_3prism(self):
        N = 6
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(1, 2),
            Edge(2, 3),
            Edge(3, 4),
            Edge(4, 5),
            Edge(0, 5),
            Edge(1, 4),
            Edge(2, 0),
            Edge(3, 5)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "3prism"
        algorithm = HalinNodeColoring(G, outer=set([0, 2, 3, 5]))
        #algorithm = HalinNodeColoring(G, outer=set([0, 1, 4, 5]))
        #algorithm = HalinNodeColoring(G, outer=set([1, 2, 3, 4]))
        algorithm.run()
        #print "3prism outer", algorithm.outer
        parent = {0: 1, 1: None, 2: 1, 3: 4, 4: 1, 5: 4}
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

# 2-------3       numeracja wg cyklu Hamiltona
# |\     / \     heptahedral graph 2
# | 1---4---5   http://mathworld.wolfram.com/HalinGraph.html
# |/     \ /
# 0-------6

    def test_halin7(self):
        N = 7
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 2),
            Edge(0, 6),
            Edge(1, 2),
            Edge(1, 4),
            Edge(2, 3),
            Edge(3, 4),
            Edge(3, 5),
            Edge(4, 5),
            Edge(4, 6),
            Edge(5, 6)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinNodeColoring(G, outer=set([0, 2, 3, 5, 6]))
        algorithm.run()
        #print "halin7 outer", algorithm.outer
        parent = {0: 1, 1: None, 2: 1, 3: 4, 4: 1, 5: 4, 6: 4}
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

# 0-----7-----6  numeracja wg cyklu Hamiltona
# |\    |    /|
# | 2---3---4 |
# |/         \|
# 1-----------5

    def test_halin8a(self):
        N = 8
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 2),
            Edge(0, 7),
            Edge(1, 2),
            Edge(1, 5),
            Edge(2, 3),
            Edge(3, 4),
            Edge(3, 7),
            Edge(4, 5),
            Edge(4, 6),
            Edge(5, 6),
            Edge(6, 7)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinNodeColoring(G, outer=set([0, 7, 6, 5, 1]))
        algorithm.run()
        #print "halin8a outer", algorithm.outer
        parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 4, 6: 4, 7: 3}
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

#   2-------3      numeracja wg cyklu Hamiltona
#  / \     / \
# 1---7---6---4
#  \ /     \ /
#   0-------5

    def test_halin8b(self):
        N = 8
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 5),
            Edge(0, 7),
            Edge(1, 2),
            Edge(1, 7),
            Edge(2, 3),
            Edge(2, 7),
            Edge(3, 4),
            Edge(3, 6),
            Edge(4, 5),
            Edge(4, 6),
            Edge(5, 6),
            Edge(6, 7)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinNodeColoring(G, outer=set([0, 1, 2, 3, 4, 5]))
        algorithm.run()
        #print "halin8b outer", algorithm.outer
        parent = {0: 7, 1: 7, 2: 7, 3: 6, 4: 6, 5: 6, 6: None, 7: 6}
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

# 1---2---3    numeracja wg cyklu Hamiltona
# |\   \ /|
# | 7---6 |
# |/   / \|
# 0---5---4

    def test_halin8c(self):
        N = 8
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 5),
            Edge(0, 7),
            Edge(1, 2),
            Edge(1, 7),
            Edge(2, 3),
            Edge(2, 6),
            Edge(3, 4),
            Edge(3, 6),
            Edge(4, 5),
            Edge(4, 6),
            Edge(5, 6),
            Edge(6, 7)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinNodeColoring(G, outer=set([0, 1, 2, 3, 4, 5]))
        algorithm.run()
        #print "halin8c outer", algorithm.outer
        parent = {0: 7, 1: 7, 2: 6, 3: 6, 4: 6, 5: 6, 6: None, 7: 6}
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

# 1-----4---5-----8    numeracja wg cyklu Hamiltona
# |\    |   |    /|    graf kubiczny
# | 2---3---6---7 |
# |/             \|
# 0---------------9

    def test_halin10j(self):
        N = 10
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 2),
            Edge(0, 9),
            Edge(1, 2),
            Edge(1, 4),
            Edge(2, 3),
            Edge(3, 4),
            Edge(3, 6),
            Edge(4, 5),
            Edge(5, 6),
            Edge(5, 8),
            Edge(6, 7),
            Edge(7, 8),
            Edge(7, 9),
            Edge(8, 9)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinNodeColoring(G, outer=set([0, 1, 4, 5, 8, 9]))
        algorithm.run()
        #print "halin10j outer", algorithm.outer
        parent = {
            0: 2,
            1: 2,
            2: None,
            3: 2,
            4: 3,
            5: 6,
            6: 3,
            7: 6,
            8: 7,
            9: 7
        }
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

# 1-----4---------5    numeracja wg cyklu Hamiltona
# |\    |        /|    graf kubiczny
# | 2---3---8---7 |
# |/        |    \|
# 0---------9-----6

    def test_halin10k(self):
        N = 10
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 2),
            Edge(0, 9),
            Edge(1, 2),
            Edge(1, 4),
            Edge(2, 3),
            Edge(3, 4),
            Edge(3, 8),
            Edge(4, 5),
            Edge(5, 6),
            Edge(5, 7),
            Edge(6, 7),
            Edge(6, 9),
            Edge(7, 8),
            Edge(8, 9)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinNodeColoring(G, outer=set([0, 1, 4, 5, 6, 9]))
        algorithm.run()
        #print "halin10k outer", algorithm.outer
        parent = {
            0: 2,
            1: 2,
            2: None,
            3: 2,
            4: 3,
            5: 7,
            6: 7,
            7: 8,
            8: 3,
            9: 8
        }
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

#   --4---5--
#  /   \ /   \
# 0     3     6    numeracja wg cyklu Hamiltona
# |\    |    /|    graf kubiczny
# | 1---2---7 |
# |/         \|
# 9-----------8

    def test_halin10l(self):
        N = 10
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 4),
            Edge(0, 9),
            Edge(1, 2),
            Edge(1, 9),
            Edge(2, 3),
            Edge(2, 7),
            Edge(3, 4),
            Edge(3, 5),
            Edge(4, 5),
            Edge(5, 6),
            Edge(6, 7),
            Edge(6, 8),
            Edge(7, 8),
            Edge(8, 9)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinNodeColoring(G, outer=set([0, 4, 5, 6, 8, 9]))
        algorithm.run()
        #print "halin10l outer", algorithm.outer
        parent = {
            0: 1,
            1: None,
            2: 1,
            3: 2,
            4: 3,
            5: 3,
            6: 7,
            7: 2,
            8: 7,
            9: 1
        }
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

#    10---8---7     wachlarz nieparzysty
#    /  \ | /  \
#   /     9     \
#  /      |      \
# 0---2---3---4---6
#  \ /         \ /
#   1-----------5

    def test_halin11(self):
        N = 11
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 2),
            Edge(0, 10),
            Edge(1, 2),
            Edge(1, 5),
            Edge(2, 3),
            Edge(3, 4),
            Edge(3, 9),
            Edge(4, 5),
            Edge(4, 6),
            Edge(5, 6),
            Edge(6, 7),
            Edge(7, 8),
            Edge(7, 9),
            Edge(8, 9),
            Edge(8, 10),
            Edge(9, 10)
        ]  # E=17
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinNodeColoring(G, outer=set([0, 1, 5, 6, 7, 8, 10]))
        algorithm.run()
        #print "halin11 outer", algorithm.outer
        parent = {
            0: 2,
            1: 2,
            2: None,
            3: 2,
            4: 3,
            5: 4,
            6: 4,
            7: 9,
            8: 9,
            9: 3,
            10: 9
        }
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

#   -----------11
#  /           / \
# 0-------1--10---9    numeracja wg cyklu Hamiltona
# |       |       |    cubic Frucht graph
# 4---3---2---7---8
#  \ /         \ /
#   5-----------6

    def test_frucht12(self):
        N = 10
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 4),
            Edge(0, 11),
            Edge(1, 2),
            Edge(1, 10),
            Edge(2, 3),
            Edge(2, 7),
            Edge(3, 4),
            Edge(3, 5),
            Edge(4, 5),
            Edge(5, 6),
            Edge(6, 7),
            Edge(6, 8),
            Edge(7, 8),
            Edge(8, 9),
            Edge(9, 10),
            Edge(9, 11),
            Edge(10, 11)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "frucht12"
        algorithm = HalinNodeColoring(G, outer=set([0, 4, 5, 6, 8, 9, 11]))
        algorithm.run()
        #print "frucht12 outer", algorithm.outer
        parent = {
            0: 1,
            1: None,
            2: 1,
            3: 2,
            4: 3,
            5: 3,
            6: 7,
            7: 2,
            8: 7,
            9: 10,
            10: 1,
            11: 10
        }
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)


#   0---------15--------14        cubic
#  / \        |        / \
# 2---1---6---7---8---13--12
#  \     /         \     /
#   3---5           9---11
#    \ /             \ /
#     4---------------10

    def test_halin16(self):
        N = 16
        G = Graph(N, False)
        edges = [
            Edge(0, 1),
            Edge(0, 2),
            Edge(0, 15),
            Edge(1, 2),
            Edge(1, 6),
            Edge(2, 3),
            Edge(3, 4),
            Edge(3, 5),
            Edge(4, 5),
            Edge(4, 10),
            Edge(5, 6),
            Edge(6, 7),
            Edge(7, 8),
            Edge(7, 15),
            Edge(8, 9),
            Edge(8, 13),
            Edge(9, 10),
            Edge(9, 11),
            Edge(10, 11),
            Edge(11, 12),
            Edge(12, 13),
            Edge(12, 14),
            Edge(13, 14),
            Edge(14, 15)
        ]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "halin16"
        algorithm = HalinNodeColoring(G,
                                      outer=set(
                                          [0, 2, 3, 4, 10, 11, 12, 14, 15]))
        algorithm.run()
        #print "halin16 outer", algorithm.outer
        parent = {
            0: 1,
            1: None,
            2: 1,
            3: 5,
            4: 5,
            5: 6,
            6: 1,
            7: 6,
            8: 7,
            9: 8,
            10: 9,
            11: 9,
            12: 13,
            13: 8,
            14: 13,
            15: 7
        }
        self.assertEqual(algorithm.parent, parent)
        for node in G.iternodes():
            self.assertNotEqual(algorithm.color[node], None)
        for edge in G.iteredges():
            self.assertNotEqual(algorithm.color[edge.source],
                                algorithm.color[edge.target])
        all_colors = set(algorithm.color[node] for node in G.iternodes())
        self.assertEqual(len(all_colors), 3)

    def tearDown(self):
        pass
コード例 #16
0
ファイル: timeit_mst.py プロジェクト: yjfiejd/graphs-dict
from graphtheory.connectivity.connected import is_connected
from graphtheory.algorithms.acyclic import is_acyclic
from graphtheory.bipartiteness.bipartite import is_bipartite
from graphtheory.connectivity.cutnodes import is_biconnected
from graphtheory.spanningtrees.boruvka import BoruvkaMST
from graphtheory.spanningtrees.prim import PrimMST
from graphtheory.spanningtrees.prim import PrimMSTWithEdges
from graphtheory.spanningtrees.prim import PrimMatrixMST
from graphtheory.spanningtrees.prim import PrimMatrixMSTWithEdges
from graphtheory.spanningtrees.prim import PrimConnectedMST
from graphtheory.spanningtrees.prim import PrimTrivialMST
from graphtheory.spanningtrees.kruskal import KruskalMST
from graphtheory.spanningtrees.kruskal import KruskalMSTSorted

V = 50
graph_factory = GraphFactory(Graph)
G = graph_factory.make_random(V, False, 0.5)
#G = graph_factory.make_complete(V, False)
#G = graph_factory.make_cyclic(V, False)
E = G.e()
#G.show()

print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()
print "Connected:", is_connected(G)
print "Biconnected:", is_biconnected(G)
print "Acyclic:", is_acyclic(G)
print "Bipartite:", is_bipartite(G)
Delta = max(G.degree(node) for node in G.iternodes())
コード例 #17
0
ファイル: test_halintd.py プロジェクト: ufkapano/graphs-dict
class TestHalinGraphTreeDecomposition(unittest.TestCase):

    def setUp(self):
        self.graph_factory = GraphFactory(Graph)

    def test_k4(self):    # graf K4 = W4
        G = self.graph_factory.make_complete(n=4, directed=False)
        # Sa 4 mozliwosci narysowania K4 na plaszczyznie bez przeciec.
        #print "k4 ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([1, 2, 3]))
        algorithm.run()
        parent = {0: None, 1: 0, 2: 0, 3: 0}
        self.assertEqual(algorithm.parent, parent)
        order = [1, 2, 3, 0]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

# 2---3    numeracja wg cyklu Hamiltona
# |\ /|    wheel graph W_5
# | 0 |
# |/ \|
# 1---4
    def test_wheel5(self):
        N = 5
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 3), Edge(0, 4), 
            Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(4, 1)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "wheel5 ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([1, 2, 3, 4]))
        algorithm.run()
        #print "wheel5 outer", algorithm.outer
        #print "wheel5 cycle", algorithm.cycle
        parent = {0: None, 1: 0, 2: 0, 3: 0, 4: 0}
        self.assertEqual(algorithm.parent, parent)
        order = [1, 2, 3, 4, 0]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

# 2-------3   numeracja wg cyklu Hamiltona
# |\     /|   3-prism graph
# | 1---4 |   cubic, planar
# |/     \|
# 0-------5
    def test_3prism(self):
        N = 6
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(3, 4), 
            Edge(4, 5), Edge(0, 5), Edge(1, 4), Edge(2, 0), Edge(3, 5)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "3prism ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 2, 3, 5]))
        #algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 4, 5]))
        #algorithm = HalinGraphTreeDecomposition(G, outer=set([1, 2, 3, 4]))
        algorithm.run()
        #print "3prism outer", algorithm.outer
        parent = {0: 1, 1: None, 2: 1, 3: 4, 4: 1, 5: 4}
        self.assertEqual(algorithm.parent, parent)
        #order = [1, 0, 2, 3, 5, 4]
        order = [4, 0, 2, 3, 5, 1]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

# 2-------3       numeracja wg cyklu Hamiltona
# |\     / \     heptahedral graph 2
# | 1---4---5   http://mathworld.wolfram.com/HalinGraph.html
# |/     \ /
# 0-------6
    def test_halin7(self):
        N = 7
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 6), Edge(1, 2), 
            Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 5), 
            Edge(4, 5), Edge(4, 6), Edge(5, 6)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "halin7 ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 2, 3, 5, 6]))
        algorithm.run()
        #print "halin7 outer", algorithm.outer
        parent = {0: 1, 1: None, 2: 1, 3: 4, 4: 1, 5: 4, 6: 4}
        self.assertEqual(algorithm.parent, parent)
        #order = [1, 0, 2, 3, 5, 6, 4]
        order = [5, 4, 0, 2, 3, 6, 1]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

# 0-----7-----6  numeracja wg cyklu Hamiltona
# |\    |    /|
# | 2---3---4 |
# |/         \|
# 1-----------5
    def test_halin8a(self):
        N = 8
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 7), Edge(1, 2), 
            Edge(1, 5), Edge(2, 3), Edge(3, 4), Edge(3, 7), 
            Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "halin8a ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 7, 6, 5, 1]))
        algorithm.run()
        #print "halin8a outer", algorithm.outer
        parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 4, 6: 4, 7: 3}
        self.assertEqual(algorithm.parent, parent)
        #order = [2, 4, 0, 1, 5, 6, 7, 3]
        order = [4, 2, 0, 1, 5, 6, 7, 3]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

#   2-------3      numeracja wg cyklu Hamiltona
#  / \     / \
# 1---7---6---4
#  \ /     \ /
#   0-------5
    def test_halin8b(self):
        N = 8
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 5), Edge(0, 7), Edge(1, 2), 
            Edge(1, 7), Edge(2, 3), Edge(2, 7), Edge(3, 4), 
            Edge(3, 6), Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "halin8b ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 2, 3, 4, 5]))
        algorithm.run()
        #print "halin8b outer", algorithm.outer
        parent = {0: 7, 1: 7, 2: 7, 3: 6, 4: 6, 5: 6, 6: None, 7: 6}
        self.assertEqual(algorithm.parent, parent)
        #order = [1, 7, 0, 2, 3, 4, 5, 6]
        order = [4, 6, 0, 1, 2, 3, 5, 7]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

# 1---2---3    numeracja wg cyklu Hamiltona
# |\   \ /|
# | 7---6 |
# |/   / \|
# 0---5---4
    def test_halin8c(self):
        N = 8
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 5), Edge(0, 7), Edge(1, 2), 
            Edge(1, 7), Edge(2, 3), Edge(2, 6), Edge(3, 4), Edge(3, 6), 
            Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "halin8c ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 2, 3, 4, 5]))
        algorithm.run()
        #print "halin8c outer", algorithm.outer
        parent = {0: 7, 1: 7, 2: 6, 3: 6, 4: 6, 5: 6, 6: None, 7: 6}
        self.assertEqual(algorithm.parent, parent)
        #order = [7, 0, 1, 2, 3, 4, 5, 6]   # wersja z indeksami
        order = [3, 4, 6, 0, 1, 2, 5, 7]   # wersja z linkami
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

# 1-----4---5-----8    numeracja wg cyklu Hamiltona
# |\    |   |    /|    graf kubiczny
# | 2---3---6---7 |
# |/             \|
# 0---------------9
    def test_halin10j(self):
        N = 10
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 9), Edge(1, 2), 
            Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 6), 
            Edge(4, 5), Edge(5, 6), Edge(5, 8), Edge(6, 7), 
            Edge(7, 8), Edge(7, 9), Edge(8, 9)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "halin10j ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 4, 5, 8, 9]))
        algorithm.run()
        #print "halin10j outer", algorithm.outer
        parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 6, 6: 3, 7: 6, 8: 7, 9: 7}
        self.assertEqual(algorithm.parent, parent)
        order = [7, 2, 8, 6, 0, 1, 4, 5, 9, 3]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

# 1-----4---------5    numeracja wg cyklu Hamiltona
# |\    |        /|    graf kubiczny
# | 2---3---8---7 |
# |/        |    \|
# 0---------9-----6
    def test_halin10k(self):
        N = 10
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 9), Edge(1, 2), 
            Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 8), 
            Edge(4, 5), Edge(5, 6), Edge(5, 7), Edge(6, 7), 
            Edge(6, 9), Edge(7, 8), Edge(8, 9)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "halin10k ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 4, 5, 6, 9]))
        algorithm.run()
        #print "halin10k outer", algorithm.outer
        parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 7, 6: 7, 7: 8, 8: 3, 9: 8}
        self.assertEqual(algorithm.parent, parent)
        order = [7, 2, 6, 8, 0, 1, 4, 5, 9, 3]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

#   --4---5--
#  /   \ /   \
# 0     3     6    numeracja wg cyklu Hamiltona
# |\    |    /|    graf kubiczny
# | 1---2---7 |
# |/         \|
# 9-----------8
    def test_halin10l(self):
        N = 10
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 4), Edge(0, 9), Edge(1, 2), 
            Edge(1, 9), Edge(2, 3), Edge(2, 7), Edge(3, 4), 
            Edge(3, 5), Edge(4, 5), Edge(5, 6), Edge(6, 7), 
            Edge(6, 8), Edge(7, 8), Edge(8, 9)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "halin10l ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 4, 5, 6, 8, 9]))
        algorithm.run()
        #print "halin10l outer", algorithm.outer
        parent = {0: 1, 1: None, 2: 1, 3: 2, 4: 3, 5: 3, 6: 7, 7: 2, 8: 7, 9: 1}
        self.assertEqual(algorithm.parent, parent)
        #order = [3, 1, 7, 0, 4, 5, 6, 8, 9, 2]
        order = [3, 7, 1, 0, 4, 5, 6, 8, 9, 2]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

#    10---8---7     wachlarz nieparzysty
#    /  \ | /  \
#   /     9     \
#  /      |      \
# 0---2---3---4---6
#  \ /         \ /
#   1-----------5
    def test_halin11(self):
        N = 11
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 10), Edge(1, 2), 
            Edge(1, 5), Edge(2, 3), Edge(3, 4), Edge(3, 9), 
            Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7), 
            Edge(7, 8), Edge(7, 9), Edge(8, 9), Edge(8, 10),
            Edge(9, 10)]   # E=17
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 1, 5, 6, 7, 8, 10]))
        algorithm.run()
        #print "halin11 ..."
        #print "halin11 outer", algorithm.outer
        parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 4, 6: 4, 7: 9, 8: 9, 9: 3, 10: 9}
        self.assertEqual(algorithm.parent, parent)
        order = [4, 8, 9, 2, 0, 1, 5, 6, 7, 10, 3]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

#   -----------11
#  /           / \
# 0-------1--10---9    numeracja wg cyklu Hamiltona
# |       |       |    cubic Frucht graph
# 4---3---2---7---8
#  \ /         \ /
#   5-----------6
    def test_frucht12(self):
        N = 10
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 4), Edge(0, 11), Edge(1, 2), 
            Edge(1, 10), Edge(2, 3), Edge(2, 7), Edge(3, 4), 
            Edge(3, 5), Edge(4, 5), Edge(5, 6), Edge(6, 7), 
            Edge(6, 8), Edge(7, 8), Edge(8, 9), Edge(9, 10), 
            Edge(9, 11), Edge(10, 11)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "frucht12 ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 4, 5, 6, 8, 9, 11]))
        algorithm.run()
        #print "frucht12 outer", algorithm.outer
        parent = {0: 1, 1: None, 2: 1, 3: 2, 4: 3, 5: 3, 6: 7, 7: 2, 8: 7, 9: 10, 10: 1, 11: 10}
        self.assertEqual(algorithm.parent, parent)
        #order = [10, 3, 7, 11, 1, 0, 4, 5, 6, 8, 9, 2]
        order = [10, 7, 3, 11, 1, 0, 4, 5, 6, 8, 9, 2]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

#   0---------15--------14        cubic
#  / \        |        / \
# 2---1---6---7---8---13--12
#  \     /         \     /
#   3---5           9---11
#    \ /             \ /
#     4---------------10
    def test_halin16(self):
        N = 16
        G = Graph(N, False)
        edges = [Edge(0, 1), Edge(0, 2), Edge(0, 15), Edge(1, 2), 
            Edge(1, 6), Edge(2, 3), Edge(3, 4), Edge(3, 5), 
            Edge(4, 5), Edge(4, 10), Edge(5, 6), Edge(6, 7), 
            Edge(7, 8), Edge(7, 15), Edge(8, 9), Edge(8, 13), 
            Edge(9, 10), Edge(9, 11), Edge(10, 11), Edge(11, 12), 
            Edge(12, 13), Edge(12, 14), Edge(13, 14), Edge(14, 15)]
        for node in range(N):
            G.add_node(node)
        for edge in edges:
            G.add_edge(edge)
        #print "halin16 ..."
        algorithm = HalinGraphTreeDecomposition(G, outer=set([0, 2, 3, 4, 10, 11, 12, 14, 15]))
        algorithm.run()
        #print "halin16 outer", algorithm.outer
        parent = {0: 1, 1: None, 2: 1, 3: 5, 4: 5, 5: 6, 6: 1, 7: 6, 
            8: 7, 9: 8, 10: 9, 11: 9, 12: 13, 13: 8, 14: 13, 15: 7}
        self.assertEqual(algorithm.parent, parent)
        order = [5, 9, 13, 1, 11, 12, 8, 2, 3, 6, 0, 4, 10, 14, 15, 7]
        self.assertEqual(algorithm.order, order)
        self.assertEqual(len(algorithm.cliques), G.v()-3)

    def tearDown(self): pass
コード例 #18
0
ファイル: timeit_isetbt.py プロジェクト: ufkapano/graphs-dict
#!/usr/bin/python

import timeit
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.independentsets.isetbt import BacktrackingIndependentSet

V = 10
graph_factory = GraphFactory(Graph)
probability = 0.5
G = graph_factory.make_random(V, False, probability)
#G = graph_factory.make_cyclic(V, False)
E = G.e()
#G.show()

print ( "Calculate parameters ..." )
print ( "Nodes: {} {}".format( G.v(), V ))
print ( "Edges: {} {}".format( G.e(), E ))
print ( "Directed: {}".format( G.is_directed() ))

print ( "Testing BacktrackingIndependentSet ..." )
t1 = timeit.Timer(lambda: BacktrackingIndependentSet(G).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) )   # single run

# EOF
コード例 #19
0
 def setUp(self):
     self.N = 5           # number of nodes
     graph_factory = GraphFactory(Graph)
     self.G = graph_factory.make_complete(self.N, True)
コード例 #20
0
ファイル: timeit_iset.py プロジェクト: yjfiejd/graphs-dict
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet2
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet3
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet4
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet5
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet6
from graphtheory.independentsets.isetsf import SmallestFirstIndependentSet7
from graphtheory.independentsets.isetll import LargestLastIndependentSet1
from graphtheory.independentsets.isetll import LargestLastIndependentSet2
from graphtheory.independentsets.isetll import LargestLastIndependentSet3
from graphtheory.independentsets.isetll import LargestLastIndependentSet4
from graphtheory.independentsets.isetll import LargestLastIndependentSet5
from graphtheory.independentsets.isetll import LargestLastIndependentSet6
from graphtheory.independentsets.isetll import LargestLastIndependentSet7

V = 100
graph_factory = GraphFactory(Graph)
probability = 0.5
G = graph_factory.make_random(V, False, probability)
E = G.e()
#G.show()

print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()

print "Testing UnorderedSequentialIndependentSet1 ..."
t1 = timeit.Timer(lambda: UnorderedSequentialIndependentSet1(G).run())
print V, E, t1.timeit(1)            # pojedyncze wykonanie

print "Testing UnorderedSequentialIndependentSet2 ..."
コード例 #21
0
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.connectivity.connected import is_connected
from graphtheory.algorithms.acyclic import is_acyclic
from graphtheory.bipartiteness.bipartite import is_bipartite
from graphtheory.connectivity.cutnodes import is_biconnected
from graphtheory.spanningtrees.boruvka import BoruvkaMST
from graphtheory.spanningtrees.prim import PrimMST
from graphtheory.spanningtrees.prim import PrimMatrixMST
from graphtheory.spanningtrees.prim import PrimTrivialMST
from graphtheory.spanningtrees.kruskal import KruskalMST
from graphtheory.spanningtrees.kruskal import KruskalMSTSorted

V = 10
graph_factory = GraphFactory(Graph)
G = graph_factory.make_random(V, False, 0.5)
#G = graph_factory.make_complete(V, False)
#G = graph_factory.make_cyclic(V, False)
E = G.e()
#G.show()

print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()
print "Connected:", is_connected(G)
print "Biconnected:", is_biconnected(G)
print "Acyclic:", is_acyclic(G)
print "Bipartite:", is_bipartite(G)
Delta = max(G.degree(node) for node in G.iternodes())
コード例 #22
0
#!/usr/bin/python

import timeit
import random
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.planarity.halintd import HalinGraphTreeDecomposition
from graphtheory.planarity.halintools import make_halin_outer
from graphtheory.planarity.halintools import make_halin_cubic_outer

V = 10
graph_factory = GraphFactory(Graph)
G = graph_factory.make_necklace(n=V)   # V even
outer = set(range(0,V,2)) | set([V-1])   # necklace

#G, outer = make_halin_outer(V)
#G, outer = make_halin_cubic_outer(V)   # always finishing with 7-wheel
E = G.e()
#G.show()

print ( "Testing HalinGraphTreeDecomposition ..." )
t1 = timeit.Timer(lambda: HalinGraphTreeDecomposition(G, outer).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) )   # single run

# EOF
コード例 #23
0
ファイル: test_factory.py プロジェクト: kgashok/graphs-dict
 def setUp(self):
     self.N = 10           # number of nodes
     self.graph_factory = GraphFactory(Graph)
コード例 #24
0
#!/usr/bin/python

import unittest
import timeit
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.forests.treecenter import TreeCenter
from graphtheory.structures.factory import GraphFactory

V = 1000   # liczba wierzcholkow
E = V-1      # liczba krawedzi
graph_factory = GraphFactory(Graph)
G = graph_factory.make_tree(V)
#G.show()

print ( "Calculate parameters ..." )
print ( "Nodes: {} {}".format( G.v(), V ))
print ( "Edges: {} {}".format( G.e(), E ))
assert G.v() == V
assert G.e() == E
print ( "Directed: {}".format( G.is_directed() ))
print ( "Delta: {}".format( max(G.degree(node) for node in G.iternodes()) ))

print ( "Testing TreeCenter ..." )
t1 = timeit.Timer(lambda: TreeCenter(G).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) )   # single run

# EOF
コード例 #25
0
ファイル: test_factory.py プロジェクト: kgashok/graphs-dict
class TestGraphFactory(unittest.TestCase):

    def setUp(self):
        self.N = 10           # number of nodes
        self.graph_factory = GraphFactory(Graph)

    def test_complete(self):
        G = self.graph_factory.make_complete(n=self.N, directed=False)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), self.N * (self.N-1) // 2)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))

    def test_complete_directed(self):
        G = self.graph_factory.make_complete(n=self.N, directed=True)
        self.assertTrue(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), self.N * (self.N-1) // 2)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))

    def test_cyclic(self):
        G = self.graph_factory.make_cyclic(n=self.N, directed=False)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), self.N)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))
        self.assertRaises(ValueError, self.graph_factory.make_cyclic, 1)
        self.assertRaises(ValueError, self.graph_factory.make_cyclic, 2)

    def test_cyclic_directed(self):
        G = self.graph_factory.make_cyclic(n=self.N, directed=True)
        self.assertTrue(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), self.N)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))
        self.assertRaises(ValueError, self.graph_factory.make_cyclic, 1)
        self.assertRaises(ValueError, self.graph_factory.make_cyclic, 2)

    def test_sparse(self):
        m_edges = 2 * self.N
        G = self.graph_factory.make_sparse(n=self.N, directed=False, m=m_edges)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), m_edges)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))

    def test_tree(self):
        G = self.graph_factory.make_tree(n=self.N)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), self.N-1)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))

    def test_connected(self):
        m_edges = 2 * self.N
        G = self.graph_factory.make_connected(n=self.N, m=m_edges)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), m_edges)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))

    def test_random(self):
        G = self.graph_factory.make_random(
            n=self.N, directed=False, edge_probability=0.1)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), self.N)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))

    def test_random_directed(self):
        G = self.graph_factory.make_random(
            n=self.N, directed=True, edge_probability=0.1)
        self.assertTrue(G.is_directed())
        self.assertEqual(G.v(), self.N)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))

    def test_bipartite(self):
        N1, N2 = 5, 6
        G = self.graph_factory.make_bipartite(N1, N2, directed=False, edge_probability=0.1)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), N1 + N2)
        aset = set(edge.weight for edge in G.iteredges())
        self.assertEqual(G.e(), len(aset))
        # We use the fact that nodes are in two sets
        # [0 ... N1-1], [N1 ... N1+N2-1].
        for edge in G.iteredges():
            self.assertEqual(edge.source < N1, edge.target >= N1)

    def test_grid(self):
        size = 4
        G = self.graph_factory.make_grid(size)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), size * size)
        self.assertEqual(G.e(), 2 * size * (size-1))
        self.assertRaises(ValueError, self.graph_factory.make_grid, 2)

    def test_grid_periodic(self):
        size = 4
        G = self.graph_factory.make_grid_periodic(size)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), size * size)
        self.assertEqual(G.e(), 2 * size * size)
        self.assertRaises(
            ValueError, self.graph_factory.make_grid_periodic, 2)

    def test_triangle(self):
        size = 4
        G = self.graph_factory.make_triangle(size)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), size * size)
        self.assertEqual(G.e(), 3 * size * size -4 * size + 1)
        self.assertRaises(ValueError, self.graph_factory.make_triangle, 2)

    def test_triangle_periodic(self):
        size = 4
        G = self.graph_factory.make_triangle_periodic(size)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), size * size)
        self.assertEqual(G.e(), 3 * size * size)
        self.assertRaises(
            ValueError, self.graph_factory.make_triangle_periodic, 2)

    def test_ladder(self):
        size = 4
        G = self.graph_factory.make_ladder(size)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), 2 * size)
        self.assertEqual(G.e(), 3 * size -2)
        self.assertRaises(ValueError, self.graph_factory.make_ladder, 2)

    def test_prism(self):
        size = 4
        G = self.graph_factory.make_prism(size)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), 2 * size)
        self.assertEqual(G.e(), 3 * size)
        self.assertRaises(
            ValueError, self.graph_factory.make_prism, 2)

    def test_antiprism(self):
        size = 4
        G = self.graph_factory.make_antiprism(size)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), 2 * size)
        self.assertEqual(G.e(), 4 * size)
        self.assertRaises(
            ValueError, self.graph_factory.make_antiprism, 2)

    def test_flow_network(self):
        G = self.graph_factory.make_flow_network(self.N)
        self.assertTrue(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertTrue(G.e() > self.N - 2)

    def test_necklace(self):
        G = self.graph_factory.make_necklace(n=self.N, directed=False)
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), 3 * self.N // 2)
        self.assertRaises(ValueError, self.graph_factory.make_necklace, 1)
        self.assertRaises(ValueError, self.graph_factory.make_necklace, 2)
        self.assertRaises(ValueError, self.graph_factory.make_necklace, 3)
        self.assertRaises(ValueError, self.graph_factory.make_necklace, 5)
        #G = self.graph_factory.make_necklace(n=6, directed=False)
        #G.show()

    def test_wheel(self):
        G = self.graph_factory.make_wheel(n=self.N, directed=False)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), 2 * self.N - 2)
        self.assertTrue(is_wheel(G))
        self.assertRaises(ValueError, self.graph_factory.make_wheel, 1)
        self.assertRaises(ValueError, self.graph_factory.make_wheel, 2)
        self.assertRaises(ValueError, self.graph_factory.make_wheel, 3)

    def test_fake_wheel(self):
        G = self.graph_factory.make_fake_wheel(n=self.N, directed=False)
        self.assertFalse(G.is_directed())
        self.assertEqual(G.v(), self.N)
        self.assertEqual(G.e(), 2 * self.N - 2)
        self.assertFalse(is_wheel(G))
        self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 1)
        self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 2)
        self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 3)
        self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 4)
        self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 5)
        self.assertRaises(ValueError, self.graph_factory.make_fake_wheel, 6)

    def tearDown(self): pass
コード例 #26
0
ファイル: test_wheels.py プロジェクト: yjfiejd/graphs-dict
class TestWheel(unittest.TestCase):

    def setUp(self):
        self.graph_factory = GraphFactory(Graph)

    def test_k4(self):    # complete graph K4 = W4
        G = self.graph_factory.make_complete(n=4, directed=False)
        self.assertTrue(is_wheel(G))
        algorithm = WheelGraph(G)
        algorithm.run()
        self.assertEqual(algorithm.hub, 0)

    def test_wheel_true(self):
        v = 10
        G = Graph(v, False)
        for node in range(v):
            G.add_node(node)
        hub = 0
        for node in range(1, v):
            G.add_edge(Edge(hub, node))
            G.add_edge(Edge(node, node+1 if node < v-1 else 1))
        self.assertTrue(is_wheel(G))
        algorithm = WheelGraph(G)
        algorithm.run()
        self.assertEqual(algorithm.hub, hub)

    def test_is_wheel(self):
        G = self.graph_factory.make_complete(n=3, directed=False)
        self.assertFalse(is_wheel(G))
        self.assertRaises(ValueError, lambda: WheelGraph(G).run())

    def test_wheel_false(self):
        # 0---+   +---5   windmill graph
        # |\   \ /   /|   https://en.wikipedia.org/wiki/Windmill_graph
        # | 1---3---4 |
        # |/   / \   \|
        # 2---+   +---6
        v = 7
        G = Graph(v, False)
        for node in range(v):
            G.add_node(node)
        edges = [
            Edge(0, 1), Edge(1, 2), Edge(0, 2), Edge(4, 5), 
            Edge(5, 6), Edge(4, 6), Edge(0, 3), Edge(1, 3), 
            Edge(2, 3), Edge(3, 5), Edge(3, 4), Edge(3, 6)]
        for edge in edges:
            G.add_edge(edge)
        self.assertFalse(is_wheel(G))
        self.assertRaises(ValueError, lambda: WheelGraph(G).run())

    def test_wheel_false2(self):
        # 1---2   missing Edge(0, 3) or Edge(1, 3)
        # |\ /|
        # | 0 |
        # |/  |
        # 4---3
        v = 5
        G = Graph(v, False)
        for node in range(v):
            G.add_node(node)
        edges = [
            Edge(0, 1), Edge(0, 2), Edge(0, 4), 
            Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(1, 4)]
        for edge in edges:
            G.add_edge(edge)
        G.add_edge(Edge(2, 4))   # bad edge
        self.assertFalse(is_wheel(G))
        self.assertRaises(ValueError, lambda: WheelGraph(G).run())

    def tearDown(self): pass
コード例 #27
0
ファイル: timeit_halin.py プロジェクト: kgashok/graphs-dict
#!/usr/bin/python

import timeit
import random
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.planarity.halin import HalinGraph
from graphtheory.planarity.halintools import make_halin_outer
from graphtheory.planarity.halintools import make_halin_cubic_outer

V = 10
graph_factory = GraphFactory(Graph)
G = graph_factory.make_necklace(n=V)   # V even
outer = set(range(0,V,2)) | set([V-1])   # necklace

#G, outer = make_halin_outer(V)
#G, outer = make_halin_cubic_outer(V)   # always finishing with 7-wheel
E = G.e()
#G.show()

print ( "Testing HalinGraph ..." )
t1 = timeit.Timer(lambda: HalinGraph(G).run())
print ( "{} {} {}".format(V, E, t1.timeit(1)) )   # single run

# EOF
コード例 #28
0
ファイル: timeit_iset.py プロジェクト: ufkapano/graphs-dict
#!/usr/bin/python

import timeit
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.forests.treeiset import BorieIndependentSet
from graphtheory.forests.treeiset import TreeIndependentSet1
from graphtheory.forests.treeiset import TreeIndependentSet2

V = 10
E = V-1   # tree
graph_factory = GraphFactory(Graph)
G = graph_factory.make_tree(V, False)
#G.show()

print ( "Calculate parameters ..." )
print ( "Nodes: {} {}".format( G.v(), V ))
print ( "Edges: {} {}".format( G.e(), E ))
print ( "Directed: {}".format( G.is_directed() ))

algorithm = BorieIndependentSet(G)
algorithm.run()
print ( algorithm.independent_set )
print ( "borie iset []".format( algorithm.cardinality ))

algorithm = TreeIndependentSet1(G)
algorithm.run()
print ( algorithm.independent_set )
print ( "tree iset1 []".format( algorithm.cardinality ))
コード例 #29
0
ファイル: timeit_flow.py プロジェクト: AbuKhulaif/graphs-dict
#!/usr/bin/python

import timeit
from graphtheory.structures.edges import Edge
from graphtheory.structures.graphs import Graph
from graphtheory.structures.factory import GraphFactory
from graphtheory.flow.fordfulkerson import FordFulkerson
from graphtheory.flow.fordfulkerson import FordFulkersonSparse
from graphtheory.flow.fordfulkerson import FordFulkersonWithEdges
from graphtheory.flow.fordfulkerson import FordFulkersonRecursive  # very slow
from graphtheory.flow.edmondskarp import EdmondsKarp
from graphtheory.flow.edmondskarp import EdmondsKarpSparse

V = 20
graph_factory = GraphFactory(Graph)
G = graph_factory.make_flow_network(V)
E = G.e()
#G.show()

print "Calculate parameters ..."
print "Nodes:", G.v(), V
print "Edges:", G.e(), E
print "Directed:", G.is_directed()

print "Testing FordFulkerson ..."
t1 = timeit.Timer(lambda: FordFulkerson(G).run(0, V - 1))
print V, E, t1.timeit(1)  # single run

print "Testing FordFulkersonSparse ..."
t1 = timeit.Timer(lambda: FordFulkersonSparse(G).run(0, V - 1))
print V, E, t1.timeit(1)  # single run