示例#1
0
    def test_addCheapestCycle(self):
        n = 10
        graph = WeightedGraph()
        for i in range(n):
            graph.addVertex(i)

        addCheapestCycle(graph, 1)
        self.assertTrue(all(e[2] == 1 for e in graph))
示例#2
0
 def test_get_links_tiny(self):
     graph = WeightedGraph()
     graph.add_direct_link(0, 1, 50)
     graph.add_direct_link(1, 2, 34)
     graph.add_direct_link(1, 3, 42)
     graph.add_direct_link(4, 1, 24)
     links = sorted(graph.get_links(1))
     self.assertEqual(links, [0, 2, 3, 4])
示例#3
0
        self.dist = dist

    def display(self):
        print "Shortest Distance :", self.dist[self.dest]
        print "Shortest Path:"
        print self.src,
        for i in self.path:
            if i != -1:
                print "-->",
                print i,


if __name__ == '__main__':
    V = 6
    wg = WeightedGraph(V)
    node = Node(0, 1, 2)
    wg.addEdge(node)
    node = Node(0, 2, 4)
    wg.addEdge(node)
    node = Node(1, 2, 1)
    wg.addEdge(node)
    node = Node(1, 3, 4)
    wg.addEdge(node)
    node = Node(1, 4, 2)
    wg.addEdge(node)
    node = Node(2, 4, 3)
    wg.addEdge(node)
    node = Node(3, 5, 2)
    wg.addEdge(node)
    node = Node(4, 3, 3)
示例#4
0
    if args['n'] is None and args['i'] is None:
        parser.print_help()
        exit(1)

    seed = args['s']

    vertexCount = 0
    if args['n']:
        vertexCount = args['n']
        graph = genGraph(vertexCount,
                         costMedian=10,
                         costDeviation=5,
                         seed=seed)

    if args['i']:
        graph = Graph.load(args['i'])
        vertexCount = len(graph.vertices())
        setSeed(seed)

    generations = args['g']
    eliteSize = args['e']
    if eliteSize is None:
        eliteSize = int(vertexCount * 0.3)

    mutationRate = args['m']
    if mutationRate is None:
        mutationRate = 10.0 / vertexCount

    startTime = time()
    bestPath, progress, lastGeneration = evolutionaryAlgorithm(
        graph, generations, eliteSize, mutationRate)
示例#5
0
        for edge in self.graph:
            if self.checkCycle(uf,edge):
                self.mst.append(edge)
                uf.union(edge.src,edge.dest)

    def display(self):
        print "Kruskal's Algorithm: "
        print "     U     |     V      |    cost      |"
        print "-----------+------------+--------------+"
        for node in self.mst:
            print "    ",node.src,"    |    ",node.dest,"     |      ",node.cost,"     |"


if __name__=='__main__':
    V = 6
    g = WeightedGraph(V)
    node = Node(0,1,6)
    g.addEdge(node)
    node = Node(0,2,1)
    g.addEdge(node)
    node = Node(0,3,5)
    g.addEdge(node)
    node = Node(1,0,6)
    g.addEdge(node)
    node = Node(1,2,5)
    g.addEdge(node)
    node = Node(1,4,3)
    g.addEdge(node)
    node = Node(2,1,5)
    g.addEdge(node)
    node = Node(2,3,5)
示例#6
0
 def setUp(self):
     self.g = WeightedGraph()
示例#7
0
class GraphTest(unittest.TestCase):
    def setUp(self):
        self.g = WeightedGraph()

    def test_addVertex(self):
        self.g.addVertex('a')
        self.g.addVertex('a')
        self.g.addVertex('b')

        self.assertEqual(2, len(self.g.vertices()))

    def test_addEdge(self):
        self.g.addEdge('a', 'b', 2)
        self.g.addEdge('a', 'c', 3)
        self.g.addEdge('a', 'b', 5)

        self.assertEqual(3, len(self.g.vertices()))

    def test_iter(self):
        self.g.addEdge('a', 'd', 2)
        self.g.addEdge('b', 'c', 3)
        self.g.addEdge('a', 'b', 5)
        self.g.addEdge('a', 'b', 3)

        self.assertTrue(('a', 'd', 2) in self.g)
        self.assertTrue(('b', 'c', 3) in self.g)
        self.assertFalse(('a', 'b', 3) in self.g)
        self.assertEqual(3, len(list(self.g)) // 2)

    def test_getItem(self):
        self.g.addEdge('a', 'b', 1000)
        self.g.addEdge('x', 'y', 2)
        self.assertEqual(1000, self.g[('a', 'b')])
        self.assertEqual(2, self.g['x', 'y'])
        self.assertEqual(None, self.g['a', 'x'])
示例#8
0
 def test_MST_small(self):
     graph = WeightedGraph()
     graph.add_direct_link(0, 1, 2)
     graph.add_direct_link(2, 1, 3)
     graph.add_direct_link(2, 5, 4)
     graph.add_direct_link(2, 4, 1)
     graph.add_direct_link(2, 6, 5)
     graph.add_direct_link(3, 7, 13)
     graph.add_direct_link(4, 7, 6)
     graph.add_direct_link(5, 8, 7)
     graph.add_direct_link(8, 9, 8)
     graph.add_direct_link(8, 10, 9)
     graph.add_direct_link(10, 11, 10)
     graph.add_direct_link(12, 11, 11)
     graph.add_direct_link(13, 11, 12)
     graph.add_direct_link(0, 11, 54)
     graph.add_direct_link(0, 12, 64)
     graph.add_direct_link(0, 7, 42)
     graph.add_direct_link(0, 2, 6)
     graph.add_direct_link(1, 3, 63)
     graph.add_direct_link(1, 9, 99)
     graph.add_direct_link(5, 6, 42)
     graph.add_direct_link(5, 9, 87)
     graph.add_direct_link(8, 12, 46)
     mst = graph.min_tree()
     self.assertEqual(sorted(mst.get_links(0)), [1])
     self.assertEqual(sorted(mst.get_links(1)), [0, 2])
     self.assertEqual(sorted(mst.get_links(2)), [1, 4, 5, 6])
     self.assertEqual(sorted(mst.get_links(3)), [7])
     self.assertEqual(sorted(mst.get_links(4)), [2, 7])
     self.assertEqual(sorted(mst.get_links(5)), [2, 8])
     self.assertEqual(sorted(mst.get_links(6)), [2])
     self.assertEqual(sorted(mst.get_links(7)), [3, 4])
     self.assertEqual(sorted(mst.get_links(8)), [5, 9, 10])
     self.assertEqual(sorted(mst.get_links(9)), [8])
     self.assertEqual(sorted(mst.get_links(10)), [8, 11])
     self.assertEqual(sorted(mst.get_links(11)), [10, 12, 13])
     self.assertEqual(sorted(mst.get_links(12)), [11])
     self.assertEqual(sorted(mst.get_links(13)), [11])
示例#9
0
 def test_MST_tiny(self):
     graph = WeightedGraph()
     graph.add_direct_link(1, 3, 15)
     graph.add_direct_link(1, 2, 1)
     graph.add_direct_link(1, 4, 10)
     graph.add_direct_link(2, 4, 15)
     graph.add_direct_link(2, 3, 16)
     graph.add_direct_link(2, 0, 4)
     graph.add_direct_link(3, 0, 2)
     graph.add_direct_link(4, 0, 3)
     mst = graph.min_tree()
     self.assertEqual(sorted(mst.get_links(0)), [2, 3, 4])
     self.assertEqual(sorted(mst.get_links(1)), [2])
     self.assertEqual(sorted(mst.get_links(2)), [0, 1])
     self.assertEqual(sorted(mst.get_links(3)), [0])
     self.assertEqual(sorted(mst.get_links(4)), [0])
示例#10
0
 def test_get_links_small(self):
     graph = WeightedGraph()
     graph.add_direct_link(0, 5, 1)
     graph.add_direct_link(0, 1, 1)
     graph.add_direct_link(0, 2, 1)
     graph.add_direct_link(1, 5, 1)
     graph.add_direct_link(2, 5, 1)
     graph.add_direct_link(2, 3, 1)
     graph.add_direct_link(3, 4, 1)
     graph.add_direct_link(3, 5, 1)
     graph.add_direct_link(5, 6, 1)
     graph.add_direct_link(5, 7, 1)
     graph.add_direct_link(6, 9, 1)
     graph.add_direct_link(7, 11, 1)
     graph.add_direct_link(8, 9, 1)
     graph.add_direct_link(9, 10, 1)
     graph.add_direct_link(9, 11, 1)
     links = sorted(graph.get_links(1))
     self.assertEqual(links, [0, 5])
     links = sorted(graph.get_links(3))
     self.assertEqual(links, [2, 4, 5])
     links = sorted(graph.get_links(5))
     self.assertEqual(links, [0, 1, 2, 3, 6, 7])
     links = sorted(graph.get_links(11))
     self.assertEqual(links, [7, 9])
示例#11
0
class AiUtilsTest(unittest.TestCase):
    def setUp(self):
        self.g = WeightedGraph()

    def test_calcDistance(self):
        self.g.addEdge('a', 'b', 12)
        self.g.addEdge('a', 'c', 3)
        self.g.addEdge('b', 'd', 5)
        self.g.addEdge('b', 'c', 6)
        self.g.addEdge('b', 'd', 4)

        path = random.sample(self.g.vertices(), len(self.g.vertices()))
        pathDist = AiUtils.calcDistance(self.g, path)
        self.assertEqual(-1, pathDist)

        self.g.addEdge('c', 'd', 7)
        self.g.addEdge('d', 'a', 8)
        pathDist = AiUtils.calcDistance(self.g, path)
        self.assertTrue(pathDist > 0)

    def test_calcFitness(self):
        self.g.addEdge('a', 'b', 10)
        self.g.addEdge('c', 'a', 3)

        path = AiUtils.genPath(self.g.vertices())
        fitness = AiUtils.calcFitness(self.g, path)
        self.assertEqual(-1, fitness)

        self.g.addEdge('b', 'c', 5)
        path = AiUtils.genPath(self.g.vertices())
        fitness = AiUtils.calcFitness(self.g, path)
        self.assertTrue(fitness == 1.0/18)

    def test_rankPaths(self):
        self.g = genGraph(100, 0.9)

        population = AiUtils.initPopulation(50, self.g.vertices())
        ranked = AiUtils.rankPaths(self.g, population)
        self.assertEqual(50, len(ranked))
        for _, fitness in ranked:
            self.assertTrue(fitness > 0 or fitness == -1)

    def test_selection(self):
        self.g = genGraph(100, 1)

        population = AiUtils.initPopulation(100, self.g.vertices())
        ranked = AiUtils.rankPaths(self.g, population)

        with self.assertRaises(Exception) as context:
            AiUtils.selection(ranked, 30, selectionSize=1.1)

            self.assertTrue('Selection size must be in [0 .. 1]' in context.exception)

    def test_breed(self):
        parent1 = list(range(10))
        parent2 = parent1[:]
        random.shuffle(parent2)

        self.assertTrue(len(parent1) == len(parent2))

        child1, child2 = AiUtils.breed(parent1, parent2)

        self.assertTrue(len(child1) == len(child2))
        self.assertTrue(len(child1) == len(parent1))
        self.assertTrue(len(child1) == len(set(child1)))
        self.assertTrue(len(child2) == len(set(child2)))

    def test_mutate(self):
        self.g = genGraph(10, 1)
        population = AiUtils.initPopulation(100, self.g.vertices())

        mutated = AiUtils.mutatePopulation(population, 1, 1)

        self.assertTrue(all(x not in population for x in mutated))