def off_3_test():
n1 = ga.Node (4, 16000, 4, 16000, 140, 80)
n2 = ga.Node (4, 8000, 4, 8000, 160, 90)
n3 = ga.Node (6, 10024, 2, 1024, 180, 100)
n4 = ga.Node (6, 6512, 6, 6512, 200, 110)
nodes_info = [n1,n2,n3,n4]
node_ids = [0, 0, 0, 3, 2, 2, 2, 2, 1, 3, 1, 1, 3]
c1 = ga.Container(1, 128, "A")
c2 = ga.Container(1, 128, "A")
c3 = ga.Container(1, 128, "A")
c4 = ga.Container(1, 128, "A")
c5 = ga.Container(1, 128, "D")
c6 = ga.Container(1, 128, "D")
c7 = ga.Container(1, 128, "D")
c8 = ga.Container(1, 128, "D")
c9 = ga.Container(1, 128, "C")
c10 = ga.Container(1, 128, "C")
c11 = ga.Container(1, 128, "B")
c12 = ga.Container(1, 128, "B")
c13 = ga.Container(1, 128, "B")
containers = [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13]
ex1 = ga.Chromosome(node_ids, containers, nodes_info)
n1.containers_list = [c1, c2, c3]
n2.containers_list = [c9, c11, c12]
n3.containers_list = [c5, c6, c7, c8]
n4.containers_list = [c4, c10, c13]
return ex1.get_fitness()
def test_is_root(self):
node1 = main.Node()
node2 = main.Node()
node1.add_child(node2)
# node1
self.assertTrue(node1.is_root())
# node2
self.assertFalse(node2.is_root())
def test_len(self):
a_list = main.LinkedList()
self.assertEqual(a_list.len(), 0)
a_list.add_in_tail(main.Node(1))
a_list.add_in_tail(main.Node(2))
a_list.add_in_tail(main.Node(3))
a_list.add_in_tail(main.Node(4))
a_list.add_in_tail(main.Node(5))
self.assertEqual(a_list.len(), 5)
def test_delete_all(self):
a_list = main.LinkedList()
a_list.add_in_tail(main.Node(1))
a_list.add_in_tail(main.Node(2))
a_list.add_in_tail(main.Node(2))
a_list.add_in_tail(main.Node(3))
self.assertTrue(self.__check_value(a_list, 2))
a_list.delete(2, True)
self.assertFalse(self.__check_value(a_list, 2))
def test_find(self):
a_list = main.LinkedList()
a_list.add_in_tail(main.Node(1))
a_list.add_in_tail(main.Node(2))
a_list.add_in_tail(main.Node(3))
a_list.add_in_tail(main.Node(4))
a_list.add_in_tail(main.Node(5))
self.assertTrue(self.__check_value(a_list, 2))
self.assertEqual(a_list.find(2).value, 2)
def test_get_left_child(self):
node1 = main.Node()
self.assertEqual(node1.get_left_child(), None) # without left child
node2 = main.Node()
node1.add_child(node2)
self.assertEqual(node1.get_left_child(), None) # without left child
node3 = main.Node()
node1.add_child(node3)
self.assertEqual(node1.get_left_child(), node3) # with left child
def test_sum(self):
test1 = main.LinkedList()
test2 = main.LinkedList()
test1.add_in_tail(main.Node(2))
test1.add_in_tail(main.Node(4))
test2.add_in_tail(main.Node(1))
test2.add_in_tail(main.Node(5))
sum_list = main.sum(test1, test2)
self.assertEqual(sum_list.head.value, 3)
self.assertEqual(sum_list.tail.value, 9)
def make_nodes(self): #physical config
nodes_kub = [
] #Will be instantiated as object of kubernetes.Node class
nodes_ga = [
] #same specifications as nodes_ga but instantiated as an object of ga.Node class
id = 0 #first node has id 0, not 1
for i in range(len(self.node_cpu)): #for each kind of node
for j in range(self.per_type): #for each node of its kind
nodes_kub.append(
kubernetes.Node(
self.node_cpu[i],
self.node_mem[i],
id,
calc_max_power(self.node_cpu[i], self.node_mem[i]),
calc_idle_power(self.node_cpu[i], self.node_mem[i]),
))
nodes_ga.append(
ga.Node(
self.node_cpu[i],
self.node_mem[i],
id,
calc_max_power(self.node_cpu[i], self.node_mem[i]),
calc_idle_power(self.node_cpu[i], self.node_mem[i]),
))
id = id + 1
return (nodes_kub, nodes_ga)
def testDPreflected(number):
count = 0
seed = random.randint(110, 140)
print 'seed: ', seed
scrambles = random.randint(30, 50)
nodeexpanse = 0
t = 0
totalheuristics = 0
print 'scrambles: ', scrambles
while count <= number:
count += 1
print 'iterazione numero: ', count
problem = main.PuzzleDPreflected(4, seed, scrambles)
problem.disjointpattern()
h = problem.h(main.Node(problem.initial))
print 'euristica iniziale :', h
totalheuristics += h
t1 = time.time()
solution, counter = searcher(problem)
t2 = time.time()
print 'Nodi espansi', counter
nodeexpanse += counter
print 'Il tempo necessario per trovare la soluzione ottima con Disjoint Pattern reflected 6-6-3 e: ', t2 - t1, 's'
print(' ')
t += (t2 - t1)
seed = random.randint(110, 140)
print 'seed: ', seed
scrambles = random.randint(30, 50)
print 'scrambles: ', scrambles
t /= 100
print "Valore euristiche: ", totalheuristics
print "Tempo d'esecuzione medio: ", t
print "Nodi espansi totali: ", nodeexpanse
print "Nodi espansi al secondo: ", nodeexpanse / t, "nodi/s"
def test_add_child(self):
node1 = main.Node()
node1.add_child(2)
node1.add_child("Node(2)")
self.assertEqual(node1.get_left_child(), None)
self.assertEqual(node1.get_right_child(), None)
node2 = main.Node(2)
node1.add_child(node2)
self.assertEqual(node1.get_right_child(), node2)
self.assertEqual(node1.get_left_child(), None)
node3 = main.Node(3)
node4 = main.Node(4)
node1.add_child(node3)
node1.add_child(node4)
self.assertEqual(node1.get_left_child(), node3)
self.assertEqual(node1.get_right_child().get_right_child(), node4)
def test_calc(self):
tree = main.Tree()
self.assertEqual(tree.calc(2), (None, None, None))
self.assertEqual(tree.calc("Ten"), (None, None, None))
self.assertEqual(tree.calc(None), (None, None, None))
root = main.Node(5)
self.assertEqual(tree.calc(root), (5, 5, 5))
root.add_child(main.Node(7))
self.assertEqual(tree.calc(root), (12, 6, 6))
root.add_child(main.Node(3))
self.assertEqual(tree.calc(root), (15, 5, 5))
root.get_left_child().add_child(main.Node(5))
self.assertEqual(tree.calc(root), (20, 5, 5))
node = main.Node(-10)
root.get_left_child().add_child(node)
self.assertEqual(tree.calc(root), (10, 2, 5))
self.assertEqual(tree.calc(node), (-10, -10, -10))
def test_height(self):
self.assertEqual(main.Tree.height(3), 0)
self.assertEqual(main.Tree.height("five"), 0)
self.assertEqual(main.Tree.height(None), 0)
node1 = main.Node(1)
node2 = main.Node(1)
node3 = main.Node(1)
node4 = main.Node(1)
self.assertEqual(main.Tree.height(node1), 1)
node1.add_child(node2)
self.assertEqual(main.Tree.height(node1), 2)
node1.add_child(node3)
self.assertEqual(main.Tree.height(node1), 2)
node1.add_child(node4)
self.assertEqual(main.Tree.height(node1), 3)
self.assertEqual(main.Tree.height(node2), 2)
self.assertEqual(main.Tree.height(node3), 1)
self.assertEqual(main.Tree.height(node4), 1)
def off_1_test():
n1 = ga.Node (4, 16000, 4, 16000, 140, 80)
n2 = ga.Node (4, 8000, 4, 8000, 160, 90)
n3 = ga.Node (2, 1024, 2, 1024, 180, 100)
n4 = ga.Node (6, 6512, 6, 6512, 200, 110)
nodes_info = [n1,n2,n3,n4]
node_ids = [0, 0, 0, 0, 2, 2, 3, None]
c1 = ga.Container(1, 128, "A")
c2 = ga.Container(1, 128, "B")
c3 = ga.Container(1, 128, "C")
c4 = ga.Container(1, 128, "D")
c5 = ga.Container(1, 128, "E")
c6 = ga.Container(1, 128, "F")
c7 = ga.Container(1, 128, "G")
c8 = ga.Container(1, 128, "H")
containers = [c1, c2, c3, c4, c5, c6, c7, c8]
ex1 = ga.Chromosome(node_ids, containers, nodes_info)
n1.containers_list = [c1, c2, c3, c4]
n3.containers_list = [c5, c6]
n4.containers_list = [c7]
return ex1.get_fitness()
def puzzleDPreflected(seed, scrambles):
problem4 = main.PuzzleDPreflected(4, seed=seed, scrambles=scrambles)
problem4.disjointpattern()
h = problem4.h(main.Node(problem4.initial))
print "euristica iniziale: ", h
t1 = time.time()
solution, counter = searcher(problem4)
t2 = time.time()
path = solution.path()
path.reverse()
print path
print solution.cammino
print 'Il tempo necessario per trovare la soluzione ottima con DP6-6-3 e: ', t2 - t1, 's'
def startGame():
flag = True
while flag != False:
option = menuOption()
optionValidate = optionValidated(option)
if optionValidate == "1":
#main.Tablero().Mostrar()
game = main.Game(15, "H")
main.main_play(game)
root = main.Node(game.initial)
newroot = main.makeTreeMinimax(root,game)
#main.representTree(newroot, game)
if optionValidate == "2":
game = main.Game(15,"H")
main.main_play(game)
root = main.Node(game.initial)
newroot = main.makeTreeAplhaBeta(root,game)
if optionValidate == "3":
flag = False
def test_add_in_tail(self):
a_list = main.LinkedList()
a_list.add_in_tail(main.Node(1))
a_list.add_in_tail(main.Node(2))
a_list.add_in_tail(main.Node(3))
a_list.add_in_tail(main.Node(4))
a_list.add_in_tail(main.Node(5))
self.assertFalse(self.__check_value(a_list, 6))
a_list.add_in_tail(main.Node(6))
self.assertTrue(self.__check_value(a_list, 6))
def test_set_value(self,
value1=-2,
value2=3.8435,
value3=None,
value4="four"):
node1 = main.Node()
# value1
node1.set_value(value1)
self.assertEqual(node1.get_value(), value1)
# value2
node1.set_value(value2)
self.assertEqual(node1.get_value(), 3)
# value3
node1.set_value(value3)
self.assertEqual(node1.get_value(), 0)
# value4
node1.set_value(value4)
self.assertEqual(node1.get_value(), 0)
__author__ = 'deep' import main g1 = main.nimGame(7, 'M') g2 = main.nimGame(15, 'M') g3 = main.nimGame(21, 'M') root1 = main.Node(g1.initial) root2 = main.Node(g2.initial) root3 = main.Node(g3.initial) newroot1 = main.makeTreeMinimax(root1, g1) newroot2 = main.makeTreeMinimax(root2, g2) newroot3 = main.makeTreeMinimax(root3, g3) newroot4 = main.makeTreeAplhaBeta(root1, g1) newroot5 = main.makeTreeAplhaBeta(root2, g2) newroot6 = main.makeTreeAplhaBeta(root3, g3) main.representTree(newroot1, g1) main.representTree(newroot2, g2) main.representTree(newroot3, g3) main.representTreeAlpha(newroot4, g1) main.representTreeAlpha(newroot5, g2) main.representTreeAlpha(newroot6, g3) main.makeMoore(newroot1, g1) main.makeMoore(newroot2, g2)
def test_node_none(self):
node = main.Node(5)
self.assertEqual(node.value, 5)
self.assertIsNone(node.next)
def test_get_right_child(self):
node1 = main.Node()
self.assertEqual(node1.get_right_child(), None) # without right child
node2 = main.Node()
node1.add_child(node2)
self.assertEqual(node1.get_right_child(), node2) # with right child