def test_markov(self):
g = Linking.Graph()
g.add_vertex('rainy')
g.add_vertex('sunny')
g.add_edge('rainy', 'sunny', 0.5)
g.add_edge('rainy', 'rainy', 0.5)
g.add_edge('sunny', 'rainy', 0.1)
g.add_edge('sunny', 'sunny', 0.9)
g.get_vertex('rainy').probability = 1 #initial probability
g.get_vertex('sunny').probability = 0 #initial probability
model = g.vert_dict
gg = Linking.Graph()
gg.add_vertex(0)
gg.add_vertex(1)
gg.add_vertex(2)
gg.add_vertex(3)
gg.add_edge(0, 1)
gg.add_edge(1, 2)
gg.add_edge(2, 3)
al = Algorithms.algorithms(gg.vert_dict)
expected = {
0: {
'rainy': 1,
'sunny': 0
},
1: {
'rainy': 0.5,
'sunny': 0.5
},
2: {
'rainy': 0.3,
'sunny': 0.7
},
3: {
'rainy': 0.21999999999999997,
'sunny': 0.78
}
}
self.assertDictEqual(al.markov(model, 0), expected)
expected = {
1: {
'rainy': 1,
'sunny': 0
},
2: {
'rainy': 0.5,
'sunny': 0.5
},
3: {
'rainy': 0.3,
'sunny': 0.7
}
}
self.assertDictEqual(al.markov(model, 1), expected)
def test_g_add_objEdge_vert_connection(self):
g = Linking.Graph()
g.add_vertex(0)
g.add_vertex(1)
g.add_objEdge('a0')
g.add_objEdge_vert_connection('a0', 0, 0.5)
self.assertEqual(g.vert_dict['a0'].neighbor[0], 0.5)
def test_g_get_vertices(self):
g = Linking.Graph()
g.add_vertex(0)
g.add_vertex(1)
self.assertListEqual(g.get_vertices(), [0, 1])
g.add_vertex(2)
self.assertListEqual(g.get_vertices(), [0, 1, 2])
def test_setKnownPT(self):
g = Linking.Graph()
for i in range(5):
g.add_vertex(i)
# 0 1
# \ / \
# 2 3
# /
# 4
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(1, 3)
g.add_edge(2, 4)
al = Algorithms.algorithms(g.vert_dict)
al.generateProbabilityTable()
al.setKnownPT(0, 'T', 0.1)
al.setKnownPT(1, 'T', 0.5)
al.setKnownPT(2, 'TT', 1)
al.setKnownPT(2, 'TF', 1)
al.setKnownPT(2, 'FT', 0.5)
al.setKnownPT(2, 'FF', 0.01)
al.setKnownPT(3, 'T', 0.8)
al.setKnownPT(3, 'F', 0.01)
al.setKnownPT(4, 'T', 0.1)
al.setKnownPT(4, 'F', 0.01)
v = g.get_vertex(2).probabilityTable['TT'][0] #node 2
self.assertTrue(v == 1) #expect v =1
v = g.get_vertex(3).probabilityTable['T'][0] #node 3
self.assertTrue(v == 0.8) #expect v = 0.8
v = g.get_vertex(4).probabilityTable['T'][0] #node 4
self.assertTrue(v == 0.1) #expect v = 0.1
v = g.get_vertex(0).probabilityTable['T'][0] #node 0
self.assertTrue(v == 0.1) #expect v = 0.1
v = g.get_vertex(1).probabilityTable['T'][0] #node 1
self.assertTrue(v == 0.5) #expect v = 0.5
def test_gd_resetAllUtility(self):
gd = Linking.Grid(3, 3)
gd.grid_dict[0].utility = 3
gd.grid_dict[2].utility = 4
gd.resetAllUtility()
self.assertEqual(gd.grid_dict[0].utility, 0)
self.assertEqual(gd.grid_dict[2].utility, 0)
def test_refreshP_simulating(self):
g = Linking.Graph()
for i in range(5):
g.add_vertex(i)
# 0 1
# \ / \
# 2 3
# /
# 4
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(1, 3)
g.add_edge(2, 4)
al = Algorithms.algorithms(g.vert_dict)
al.generateProbabilityTable()
al.setProbabilityTable(0, 'T', 0.1)
al.setProbabilityTable(1, 'T', 0.5)
al.setProbabilityTable(2, 'TT', 1)
al.setProbabilityTable(2, 'TF', 1)
al.setProbabilityTable(2, 'FT', 0.5)
al.setProbabilityTable(2, 'FF', 0.01)
al.setProbabilityTable(3, 'T', 0.8)
al.setProbabilityTable(3, 'F', 0.01)
al.setProbabilityTable(4, 'T', 0.1)
al.setProbabilityTable(4, 'F', 0.01)
al.simulateData(10000)
obs = {3: 'T', 4: 'T'}
self.assertTrue(math.fabs(al.query(obs, 0) - 0.17) <= 0.05)
self.assertTrue(math.fabs(al.query(obs, 1) - 1) <= 0.05)
self.assertTrue(math.fabs(al.query(obs, 2) - 0.92) <= 0.05)
self.assertTrue(math.fabs(al.query(obs, 3) - 1) <= 0.05)
self.assertTrue(math.fabs(al.query(obs, 4) - 1) <= 0.05)
def test_generatePriorProbability(self):
g = Linking.Graph()
for i in range(5):
g.add_vertex(i)
# 0 1
# \ / \
# 2 3
# /
# 4
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(1, 3)
g.add_edge(2, 4)
al = Algorithms.algorithms(g.vert_dict)
al.generateProbabilityTable()
al.setKnownPT(0, 'T', 0.1)
al.setKnownPT(1, 'T', 0.5)
al.setKnownPT(2, 'TT', 1)
al.setKnownPT(2, 'TF', 1)
al.setKnownPT(2, 'FT', 0.5)
al.setKnownPT(2, 'FF', 0.01)
al.setKnownPT(3, 'T', 0.8)
al.setKnownPT(3, 'F', 0.01)
al.setKnownPT(4, 'T', 0.1)
al.setKnownPT(4, 'F', 0.01)
al.generatePriorProbability()
self.assertTrue(g.get_vertex(0).probability == 0.1)
self.assertTrue(g.get_vertex(1).probability == 0.5)
self.assertTrue(g.get_vertex(2).probability == 0.3295)
self.assertTrue(g.get_vertex(3).probability == 0.405)
self.assertTrue(g.get_vertex(4).probability == 0.039655)
def test_g_add_vertex(self):
g = Linking.Graph()
g.add_vertex(0) #add vertex
g.add_vertex(1)
self.assertTrue(str(
g.vert_dict[0].get_id()) == str(0)) #see if the vertex exist
self.assertTrue(str(g.vert_dict[1].get_id()) == str(1))
def test_g_add_edge(self):
g = Linking.Graph()
g.add_vertex(0)
g.add_vertex(1)
g.add_edge(0, 1, 1)
self.assertTrue(1 in g.vert_dict[0].adjacent.keys())
self.assertFalse(2 in g.vert_dict[0].adjacent.keys())
def test_valueIteration(self):
g = Linking.Grid(2, 2)
g.grid_dict[0].reward = -4
g.grid_dict[1].utility = 100
g.grid_dict[1].reward = 100
g.grid_dict[2].utility = -100
g.grid_dict[2].reward = -100
g.setObstacle(3)
al = Algorithms.algorithms(g.grid_dict)
action = {'forward': 0.8, 'left': 0.1, 'right': 0.1}
discount = 0.9
expexted = {0: 64.83478199000001, 1: 100, 2: -100, 3: 0}
# print(al.valueIteration(discount,action,g))
self.assertDictEqual(al.valueIteration(discount, action, g), expexted)
#another test
g = Linking.Grid(4, 3)
for i in g.grid_dict:
if i != 5:
g.grid_dict[i].reward = -4
g.grid_dict[3].utility = 100
g.grid_dict[3].reward = 100
g.grid_dict[7].utility = -100
g.grid_dict[7].reward = -100
g.setObstacle(5)
al = Algorithms.algorithms(g.grid_dict)
action = {'forward': 0.8, 'left': 0.1, 'right': 0.1}
discount = 0.9
expexted = {
0: 50.94115412930875,
1: 64.95855729696827,
2: 79.5362031683467,
3: 100,
4: 39.85041277059019,
5: 0,
6: 48.6439148544741,
7: -100,
8: 29.64382885103273,
9: 25.391792612055916,
10: 34.476553020311734,
11: 12.99228937944113
}
# print(al.valueIteration(discount,action,g))
self.assertDictEqual(al.valueIteration(discount, action, g), expexted)
def test_g_add_objEdge2(
self
): #for adding connection from node(as parent) to action(as chile)
g = Linking.Graph()
g.add_vertex(0)
g.add_objEdge('a0')
g.add_edge(0, 'a0')
self.assertDictEqual(g.vert_dict[0].adjacent, {'a0': 1})
def test_g_resetAllUtility(self):
g = Linking.Graph()
g.add_vertex(0)
g.add_vertex(1)
g.get_vertex(0).utility = 2
g.get_vertex(1).utility = 3
g.resetAllUtility()
self.assertEqual(g.get_vertex(0).utility, 0)
self.assertEqual(g.get_vertex(1).utility, 0)
def test_g_resetAllHeuristic(self):
g = Linking.Graph()
g.add_vertex(0)
g.add_vertex(1)
g.get_vertex(0).heuristic = 1
g.get_vertex(1).heuristic = 2
g.resetAllHeuristic()
self.assertTrue(g.vert_dict[0].heuristic == 0)
self.assertTrue(g.vert_dict[1].heuristic == 0)
def test_gd_setWall(self):
gd = Linking.Grid(3, 3)
self.assertTrue(4 in gd.grid_dict[3].adjacent.keys()
) #before setWall, they are connected to each other
self.assertTrue(3 in gd.grid_dict[4].adjacent.keys())
gd.setWall(3, 4)
self.assertFalse(4 in gd.grid_dict[3].adjacent.keys(
)) #after setWall, they are not connected to each other
self.assertFalse(3 in gd.grid_dict[4].adjacent.keys())
def test_gd_setObstacle(self):
gd = Linking.Grid(3, 3)
for i in [1, 7, 3, 5]: #before setObstacle, 4 is connecting to 1,7,3,5
self.assertTrue(4 in gd.grid_dict[i].adjacent.keys())
self.assertTrue(i in gd.grid_dict[4].adjacent.keys())
gd.setObstacle(4)
for i in [1, 7, 3,
5]: #after setObstacle, they are not connected to each other
self.assertFalse(4 in gd.grid_dict[i].adjacent.keys())
self.assertFalse(i in gd.grid_dict[4].adjacent.keys())
def test_gd_setManhattanDist(self):
gd = Linking.Grid(3, 3)
dict = {0: 1, 1: 0, 2: 1, 3: 2, 4: 1, 5: 2, 6: 3, 7: 2, 8: 3}
gd.setManhattanDist(1)
for i in range(9):
self.assertEqual(gd.grid_dict[i].heuristic, dict[i])
dict = {0: 2, 1: 1, 2: 2, 3: 1, 4: 0, 5: 1, 6: 2, 7: 1, 8: 2}
gd.setManhattanDist(4)
for i in range(9):
self.assertEqual(gd.grid_dict[i].heuristic, dict[i])
def test_g_delete_objEdge_vert_connection(self):
g = Linking.Graph()
g.add_vertex(0)
g.add_vertex(1)
g.add_objEdge('a0')
g.add_objEdge_vert_connection('a0', 0, 0.8)
g.add_edge(0, 1, 3)
g.delete_objEdge_vert_connection('a0', 0)
self.assertDictEqual(g.vert_dict['a0'].neighbor, {}) # empty
self.assertDictEqual(g.vert_dict[0].adjacent, {1: 3})
def test_v_delete_neighbor(self):
v = Linking.Vertex(0)
for i in range(6): # vertex 0 is connected to 0~5
v.adjacent[i] = 1
for i in range(3):
v.delete_neighbor(i)
for i in range(6):
if (i < 3):
self.assertFalse(v.check_connectingTo(i))
else:
self.assertTrue(v.check_connectingTo(i))
def test_g_check_edge_existed(self):
g = Linking.Graph()
g.add_vertex(0)
g.add_vertex(1)
g.add_vertex(2)
g.add_edge(0, 1, 1)
g.add_edge(0, 2, 1)
self.assertTrue(g.check_edge_existed(0, 1))
self.assertTrue(g.check_edge_existed(0, 2))
g.delete_edge(0, 2)
self.assertTrue(g.check_edge_existed(0, 1))
self.assertFalse(g.check_edge_existed(0, 2))
def test_gd_physicalNeighbor(self):
gd = Linking.Grid(3, 3)
self.assertDictEqual(gd.physicalNeighbor(3), {
'upperCell': 0,
'underCell': 6,
'rightCell': 4
})
gd.setWall(3, 4) # the result won't be changed by adding a wall
self.assertDictEqual(gd.physicalNeighbor(3), {
'upperCell': 0,
'underCell': 6,
'rightCell': 4
})
def test_gd_setGridWeight(self):
gd = Linking.Grid(3, 3)
self.assertTrue(
gd.grid_weight[6] == 1) #cost of unit grid6 is 1 (default)
self.assertTrue(
gd.grid_dict[3].adjacent[6] ==
1) #the weight of physical neighbors connecting to it is also 1
self.assertTrue(gd.grid_dict[7].adjacent[6] == 1)
gd.setGridWeight(6, 2) #after setting cost to 2
self.assertTrue(gd.grid_weight[6] == 2) #cost of unit grid6 is 2
self.assertTrue(
gd.grid_dict[3].adjacent[6] ==
2) #the weight of physical neighbors connecting to it is also 2
self.assertTrue(gd.grid_dict[7].adjacent[6] == 2)
def test_g_delete_vertex(self):
g = Linking.Graph()
g.add_vertex(0)
g.add_vertex(1)
g.add_vertex(2)
g.add_edge(0, 1, 1) #0 connect to 1
g.add_edge(0, 2, 1) #0 connect to 2
g.delete_vertex(2) #delete 2
self.assertTrue(
1 in g.vert_dict[0].adjacent.keys()) #0 is connected to 1
self.assertFalse(
2 in g.vert_dict[0].adjacent.keys()) #0 is not connected to 2
self.assertTrue((0 in g.vert_dict.keys())) #vertex 0 exist
self.assertTrue((1 in g.vert_dict.keys())) #vertex 1 exist
self.assertFalse((2 in g.vert_dict.keys())) #vertex 2 not exist
def test_ucsAStar_ucs_dif_Cost(self):
g = Linking.Graph()
for i in range(7):
g.add_vertex(i)
g.add_edge(0, 2, 2)
g.add_edge(0, 1, 1)
g.add_edge(1, 4, 4)
g.add_edge(1, 3, 1)
g.add_edge(2, 6, 1)
g.add_edge(2, 5, 1)
g.add_edge(2, 4, 2)
al = Algorithms.algorithms(g.vert_dict)
self.assertListEqual([0, 2, 4], al.ucsAStar(0, 4, 'UCS'))
expect = [[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 5],
[0, 1, 2, 3, 5, 6], [0, 1, 2, 3, 5, 6, 4]]
self.assertListEqual(expect, al.getVisitedLog())
def randomGraph(self,branch,layer,lowerBound,upperBound):
LK=Linking.Graph()
LK.add_vertex(0)#root
queue=[LK.get_vertex(0).id]
nodeId=1
layerDict={0:0}
while queue:#queue is not empty
parent=queue.pop(0)#pop from head
if layer>layerDict[parent]:
for i in range(branch):
LK.add_vertex(nodeId)
LK.add_edge(parent,nodeId)
layerDict[nodeId]=layerDict[parent]+1
queue.append(nodeId)
nodeId+=1
for n in LK.get_vertices():
if not LK.get_vertex(n).get_connections():
LK.get_vertex(n).utility=random.randint(lowerBound,upperBound)
return LK
# g=randomGenerator().randomGraph(2,2,-2,2)
# g.delete_edge(2,5)
# g.delete_edge(2,6)
# g.add_objEdge('a0')
# g.add_edge(2,'a0')
# g.add_objEdge_vert_connection('a0',5)
# g.add_objEdge_vert_connection('a0',6)
# g.get_vertex(5).probability=0.2
# g.get_vertex(6).probability=0.8
# a=Algorithms.algorithms(g.vert_dict).miniMaxAlphaBeta(0,2,'exMiniMax')
# for n in g:
# if type(n) is Linking.Vertex:
# if not n.get_connections():
# print(str(n.id)+'\'s utility is '+str(n.utility))
# print()
# for e in a:
# print(e)
def test_simulateData(self):
g = Linking.Graph()
for i in range(5):
g.add_vertex(i)
# 0 1
# \ / \
# 2 3
# /
# 4
g.add_edge(0, 2)
g.add_edge(1, 2)
g.add_edge(1, 3)
g.add_edge(2, 4)
al = Algorithms.algorithms(g.vert_dict)
al.generateProbabilityTable()
al.setProbabilityTable(0, 'T', 0.1)
al.setProbabilityTable(1, 'T', 0.5)
al.setProbabilityTable(2, 'TT', 1)
al.setProbabilityTable(2, 'TF', 1)
al.setProbabilityTable(2, 'FT', 0.5)
al.setProbabilityTable(2, 'FF', 0.01)
al.setProbabilityTable(3, 'T', 0.8)
al.setProbabilityTable(3, 'F', 0.01)
al.setProbabilityTable(4, 'T', 0.1)
al.setProbabilityTable(4, 'F', 0.01)
al.simulateData(10000)
v = g.get_vertex(0).probabilityTable['T'][0] #node 0
self.assertAlmostEqual(v, 0.1, 1) #expect v =0.1
v = g.get_vertex(1).probabilityTable['T'][0] #node 1
self.assertAlmostEqual(v, 0.5, 1) #expect v = 0.5
v = g.get_vertex(2).probabilityTable['TT'][0] #node 2
self.assertAlmostEqual(v, 1, 1) #expect v =1
v = g.get_vertex(3).probabilityTable['T'][0] #node 3
self.assertAlmostEqual(v, 0.8, 1) #expect v = 0.8
v = g.get_vertex(4).probabilityTable['T'][0] #node 4
self.assertAlmostEqual(0.1, v, 1) #expect v = 0.1
def test_g_get_vertex(self):
g = Linking.Graph()
v = Linking.Vertex(0) #create a vertex
g.vert_dict[0] = v #store the vertex into vert_dict
self.assertEqual(g.get_vertex(0), v)
def test_v_check_connectingTo(self):
v = Linking.Vertex(6) # vertex 6
for i in range(6): # vertex 6 is connected to 0~5
v.adjacent[i] = 1
for i in range(6): #is vertex 6 connected to 0~5 ?
self.assertTrue(v.check_connectingTo(i))
def test_v_get_weight(self):
v = Linking.Vertex(0)
for i in range(6): # vertex 0 is connected to 0~5
v.adjacent[i] = i
for i in range(6):
self.assertTrue(v.get_weight(i) == i)
def test_v_get_id(self):
v = Linking.Vertex(0)
self.assertTrue(v.get_id() == 0)
v = Linking.Vertex(7)
self.assertTrue(v.get_id() == 7)
def test_v_get_connections(self):
v = Linking.Vertex(0)
for i in range(6): # vertex 0 is connected to 0~5
v.adjacent[i] = 1
self.assertListEqual([0, 1, 2, 3, 4, 5], v.get_connections())
