def shortest_path(self, origin, destination, weighted_poly):
"""Find and return shortest path between origin and destination.
Will return in-order list of Points of the shortest path found. If
origin or destination are not in the visibility graph, their respective
visibility edges will be found, but only kept temporarily for finding
the shortest path.
"""
origin_exists = origin in self.visgraph
dest_exists = destination in self.visgraph
if origin_exists and dest_exists:
return shortest_path(self.visgraph, origin, destination,
weighted_poly)
orgn = None if origin_exists else origin
dest = None if dest_exists else destination
add_to_visg = Graph([])
if not origin_exists:
for v in visible_vertices(origin, self.graph, destination=dest):
add_to_visg.add_edge(Edge(origin, v))
if not dest_exists:
for v in visible_vertices(destination, self.graph, origin=orgn):
add_to_visg.add_edge(Edge(destination, v))
return shortest_path(self.visgraph, origin, destination, weighted_poly,
add_to_visg)
def traverse(player, destination):
#find a path to the destination
path = shortest_path(player.current_room, destination, player.abilities)
print(f'{player.name} is traveling to room {destination}')
print(f"{player.name}'s path: {path}")
while path is not None:
#must be faster to teleport to the beginning
if path[0] is 'recall' and 'recall' in player.abilities:
room_info = player.recall()
print(f'{player.name} recalled to room {room_info["room_id"]}')
elif 'dash' in player.abilities and len(
path) > 1 and path[0][1] == path[1][1]:
room_ids = []
current_direction = path[0][1]
for room in path:
if room[1] == current_direction: room_ids.append(room[0])
else: break
room_info = player.dash_to(current_direction, room_ids)
print(
f'{player.name} dashed through {room_ids} to room {room_ids[-1]}'
)
else:
room_info = player.move_to(path[0][1], path[0][0])
print(f'{player.name} moved {path[0][1]} to room {path[0][0]}')
path = shortest_path(player.current_room, destination,
player.abilities)
print(f'{player.name} has arrived at room {destination}.')
def calculateGraphDiameter(self):
connected=self.__graph.isConnected()
if connected==1:
diameter={}
for s in self.__switch:
self.__sp[s]=priority_dict.priority_dict()
diameter[s]=0
sp=shortest_path.shortest_path(self.__switch,self.__edges)
dist=sp.shortestPath(s)
self.__sp[s]=dist.copy()
while (dist and dist[dist.smallest()]!=999999999999):
diameter[s]=dist[dist.smallest()]
dist.pop_smallest()
i=0
max_d=0
for k,v in diameter.iteritems():
if i==0:
max_d=diameter[k]
else:
if (diameter[k]>max_d):
max_d=diameter[k]
i=i+1
self.__graphDiameter=max_d
def timeToDeliver(self, path_str):
start, end, graph = self.create_graph(path_str)
path = shortest_path(graph, start, end)
dist = shortest_distance(graph, start, end)
instructions = self.get_min_moves(path)
cost = self.get_cost(instructions)
return path, dist, instructions, cost
def timeToDeliver(self, path_str):
start, end, graph = self.create_graph(path_str)
path = shortest_path(graph, start, end)
dist = shortest_distance(graph, start, end)
instructions = self.get_min_moves(path)
cost = self.get_cost(instructions)
return path, dist, instructions, cost
def __init__(self, color, pos):
self.color = color
self.head = block(pos)
self.body.append(self.head)
self.directionX = 0
self.directionY = 1
self.human = human()
self.shortest = shortest_path()
self.longest = longest_path()
self.hamilton = hamilton()
def lowest(self, harmful_areas, deadly_areas):
matrix = list()
for row in range(0, size):
row = list()
matrix.append(row)
for col in range(0, size):
row.append(safe)
for h in harmful_areas:
x1, y1, x2, y2 = [int(n) for n in h.split()]
for i in range(min(x1, x2), max(x1, x2) + 1):
for j in range(min(y1, y2), max(y1, y2) + 1):
matrix[i][j] = harmful
for d in deadly_areas:
x1, y1, x2, y2 = [int(n) for n in d.split()]
for i in range(min(x1, x2), max(x1, x2) + 1):
for j in range(min(y1, y2), max(y1, y2) + 1):
matrix[i][j] = deadly
graph = {}
for i in range(0, size):
for j in range(0, size):
state = matrix[i][j]
if (state == deadly and not (i == 0 and j == 0)):
continue
node = (i, j)
neighbours = list()
if i > 0 and matrix[i - 1][j] != deadly :
neighbours.append(((i - 1, j), matrix[i - 1][j]))
if i < size - 1 and matrix[i + 1][j] != deadly :
neighbours.append(((i + 1, j), matrix[i + 1][j]))
if j > 0 and matrix[i][j - 1] != deadly :
neighbours.append(((i, j - 1), matrix[i][j - 1]))
if j < size - 1 and matrix[i][j + 1] != deadly :
neighbours.append(((i, j + 1), matrix[i][j + 1]))
graph[node] = neighbours
matrix = None
min_path = shortest_path(graph, (0, 0), (size - 1, size - 1))
min_dist = shortest_distance(graph, (0, 0), (size - 1, size - 1))
return min_dist
def reset(self, pos):
self.head = block(pos)
self.body = []
self.body.append(self.head)
self.turns = {}
self.directionX = 0
self.directionY = 1
self.human = human()
self.shortest = shortest_path()
self.longest = longest_path()
self.hamilton = hamilton()
def getMaxControlDist(self,controller): maxDist=0 sp=shortest_path.shortest_path(self.__switch,self.__edges) for s in self.__switch: dist=sp.shortestPath(s) while (dist and dist[dist.smallest()]!=999999999999): if dist.smallest() in controller: if dist[dist.smallest()]>maxDist: maxDist=dist[dist.smallest()] dist.pop_smallest() return maxDist
def __init__(self,ng,ca,d,theta,ctr,mu): self.__ng=ng self.__switch=self.__ng.getSwitch() self.__edge=self.__ng.getGraph() self.__controller=ctr self.__ca=ca self.__d=d self.__theta=theta self.__sp=shortest_path.shortest_path(self.__switch,self.__edge) self.__nf=priority_dict.priority_dict() self.__minFreq=dict() self.__avgFreq=dict() self.__res=dict() for k in self.__controller: self.__res[k]=mu self.__cost=[] self.__initialSet=dict() self.__ctrCover=dict() self.__mu=mu
def graphReconstruct(self): edge=self.__ng.getGraph() edge_new=dict() switch=self.__ng.getSwitch() sp=shortest_path.shortest_path(switch,edge) self.__geoCord=self.__gi.getGeoCord() for s in switch: dist=sp.shortestPath(s) if s not in edge_new: edge_new[s]=priority_dict.priority_dict() edge_new[s]=dist self.__newGraph=edge_new for k,v in self.__geoCord.iteritems(): lat=v[0] longi=v[1] if v[1]<0: longi=180+abs(v[1]) self.__geoCord[k]=(float(lat),float(longi))
# This is a short test file, given to you to ensure that our grading scripts can grade your file.
# Please do not modify it.
# You should only submit "graph_adjacency_list.py", "graph_edge_list.py", and "shortest_path.py".
# This tests the simplest case: adding a single edge to the graph and checking the shortest path from one node to the other.
from graph_adjacency_list import Graph as AdjacencyGraph
from graph_edge_list import Graph as EdgeGraph
from shortest_path import shortest_path
import sys
try:
print("Testing with adjacency list graph...")
adjacency_graph = AdjacencyGraph()
adjacency_graph.add_edge('a', 'b', 1)
if shortest_path(adjacency_graph, 'a', 'b') != (['a', 'b'], 1):
print(
"Your code ran, but did NOT output the shortest distance from 'a' to 'b' when your adjacency list graph had the edge ('a', 'b', 1) added."
)
else:
print(
"Your code ran, and it correctly output the shortest distance from 'a' to 'b' when your adjacency list graph had the edge ('a', 'b', 1) added."
)
except:
print(
"Your code produced this error when adding edge ('a', 'b', 1) to the adjacency list graph or getting the shortest path from 'a' to 'b'."
)
print(sys.exc_info()[0])
try:
print("Testing with edge list graph...")
# Please do not modify it.
# You should only submit "graph_adjacency_list.py", "graph_edge_list.py", and "shortest_path.py".
# This tests the simplest case: adding a single edge to the graph and checking the shortest path from one node to the other.
from graph_adjacency_list import Graph as AdjacencyGraph
from graph_edge_list import Graph as EdgeGraph
from shortest_path import shortest_path
import sys
try:
print("Testing with adjacency list graph...")
adjacency_graph = AdjacencyGraph()
adjacency_graph.add_edge('a', 'b', 1)
if shortest_path(adjacency_graph, 'a', 'b') != (['a', 'b'], 1):
print "Your code ran, but did NOT output the shortest distance from 'a' to 'b' when your adjacency list graph had the edge ('a', 'b', 1) added."
else:
print "Your code ran, and it correctly output the shortest distance from 'a' to 'b' when your adjacency list graph had the edge ('a', 'b', 1) added."
except:
print "Your code produced this error when adding edge ('a', 'b', 1) to the adjacency list graph or getting the shortest path from 'a' to 'b'."
print sys.exc_info()[0]
try:
print("Testing with edge list graph...")
edge_graph = EdgeGraph()
edge_graph.add_edge('a', 'b', 1)
edge_graph.add_edge('b', 'c', 2)
edge_graph.add_edge('c', 'd', 3)
edge_graph.add_edge('a', 'f', 1)
edge_graph.add_edge('f', 'd', 1)
run_mst( w_ugraph, 1 ) #run kruskal
print("-------")
run_mst( w_ugraph, 0) #run prim
print("------------------- running shortest path --------------------- ")
w_dgraph = weight_direct_graph(len(l))
set_weight_direct_graph(w_dgraph)
check_graph_properties(w_dgraph, l)
print("Entire graph")
for e in w_dgraph.edges():
print(e)
print("-------")
print("Dijkstra")
sp = shortest_path(w_dgraph,0)
for v in range(w_dgraph.V()):
if sp.exist_path(v):
print("Dist path from 0 to ", v, " is =", sp.get_dist(v))
print("Path is ")
for e in sp.get_path(v):
print(e)
print("-------")
print("Bellaman Ford")
set_negative_weight_direct_graph(w_dgraph)
check_graph_properties(w_dgraph, l)
print("Entire graph")
for e in w_dgraph.edges():
fo=open(demandPath+".txt","r+")
for s in switch:
line=fo.readline()
d[str(s)]=float(line[:-2])
fo.close()
s=ng.getSwitch()
n_ctr=len(s)
c=ng.getController()
mapping=dict()
ctr=[]
sp=shortest_path.shortest_path(s,edge)
node_dist=dict()
for n in s:
node_dist[n]=sp.shortestPath(n)
ctr_cnt=0
while s:
node_asg={}
nodehp=priority_dict.priority_dict()
for ele in c:
#print node_dist[ele]
node_asg[ele]=[]
neighbour=[]
cnt=0
ca=queuing.queuing(mu)
# print(shortest_path(adjacency_graph, '1', '7'))
# if shortest_path(adjacency_graph, 'a', 'b') != (['a','b'], 1):
# print "Your code ran, but did NOT output the shortest distance from 'a' to 'b' when your adjacency list graph had the edge ('a', 'b', 1) added."
# else:
# print "Your code ran, and it correctly output the shortest distance from 'a' to 'b' when your adjacency list graph had the edge ('a', 'b', 1) added."
# except:
# print "Your code produced this error when adding edge ('a', 'b', 1) to the adjacency list graph or getting the shortest path from 'a' to 'b'."
# print sys.exc_info()[0]
try:
print("Testing with edge list graph...")
edge_graph = EdgeGraph()
edge_graph.add_edge('s', 'a', 3)
edge_graph.add_edge('s', 'b', 4)
edge_graph.add_edge('a', 'c', 2)
edge_graph.add_edge('a', 'f', 7)
edge_graph.add_edge('a', 'b', 6)
edge_graph.add_edge('b', 'f', 5)
edge_graph.add_edge('c', 'f', 1)
edge_graph.add_edge('c', 't', 8)
edge_graph.add_edge('f', 't', 4)
print(shortest_path(edge_graph, 's', 't'))
if shortest_path(edge_graph, 's', 't') != (['a', 'b', 'c', 'd'], 11):
print "Your code ran, but did NOT output the shortest distance from 'a' to 'b' when your edge list graph had the edge ('a', 'b', 1) added."
else:
print "Your code ran, and it correctly output the shortest distance from 'a' to 'b' when your edge list graph had the edge ('a', 'b', 1) added."
except AttributeError:
print "Your code produced this error when adding edge ('a', 'b', 1) to the edge list graph or getting the shortest path from 'a' to 'b'."
print sys.exc_info()[0]
traceback.print_exc()
def test_shortest_path(target_node, expected_distance):
graph = {0: [1, 4], 1: [0, 4, 2, 3], 2: [1, 3], 3: [1, 4, 2], 4: [3, 0, 1]}
actual = shortest_path(graph, target_node)
assert actual == expected_distance
from ast import literal_eval
with open("test.txt", 'r') as testfile:
L = testfile.readlines()
num_tests_run = 0
for l in L:
(testname, g, s, t, expected_output) = l.strip().split(";")
num_tests_run += 1
# Parse the graph
edge_graph = EdgeGraph()
edge_graph.graph = literal_eval(g)
# testcase = (g,s,t)
test_result = str(shortest_path(edge_graph, s, t))
if test_result == expected_output:
# print("Passed test with name %s" % testname)
print(test_result)
continue
elif test_result != expected_output:
print("Failed test with name %s" % testname)
print(test_result)
print(expected_output)
break
print("Correctly ran %d tests" % num_tests_run)
def greedySelection(self,mu,theta,d_dict):
s=list(self.__switch)
c=list(self.__switch)
switch=self.__ng.getSwitch()
edge=self.__ng.getGraph()
sp=shortest_path.shortest_path(switch,edge)
node_dist=dict()
for n in s:
node_dist[n]=sp.shortestPath(n)
ctr_cnt=0
ctr=[]
ns=dict()
while s:
node_asg={}
nodehp=priority_dict.priority_dict()
for ele in c:
node_asg[ele]=[]
neighbour=[]
cnt=0
ca=queuing.queuing(mu)
for n,dist in node_dist[ele].iteritems():
if n in s:
if n!=ele:
d=d_dict[n]
t=2*dist/300000000+ca.queuingTime(n,ele,d)
if t<=theta:
ca.updateAssignment(n,ele,d)
neighbour.append(n)
cnt=cnt+1
nodehp[ele]=cnt
node_asg[ele]=neighbour
largest=""
c_node=""
while nodehp:
c_node=nodehp.smallest()
nodehp.pop_smallest()
ctr.append(c_node)
ns[c_node]=node_asg[c_node]
ctr_cnt=ctr_cnt+1
s.remove(c_node)
c.remove(c_node)
for node in node_asg[c_node]:
if node in s:
s.remove(node)
if node in c:
c.remove(node)
#print ns
#print ctr
for k,v in ns.iteritems():
ns[k].append(k)
self.__ns=ns
return ctr_cnt
# else:
# break
# if shortest_path(adjacency_graph, 's', 't') != (test_function[0], test_function[3]):
# print("pass adjacency_graph")
# else:
# break
####################### TEST 0
try:
adjacency_graph = AdjacencyGraph()
adjacency_graph.add_edge('s', 'a', 4)
adjacency_graph.add_edge('a', 't', 3)
adjacency_graph.add_edge('s', 'b', 5)
adjacency_graph.add_edge('b', 't', 5)
if shortest_path(adjacency_graph, 's', 't') != (['s', 'a', 't'], 7):
print("ERROR: TEST 0A, WRONG DISTANCE")
else:
print("pass test 0A")
except:
print("ERROR: TEST 0A, ADDING EDGE")
print(sys.exc_info()[0])
try:
edge_graph = EdgeGraph()
edge_graph.add_edge('s', 'a', 4)
edge_graph.add_edge('a', 't', 3)
if shortest_path(edge_graph, 's', 't') != (['s', 'a', 't'], 7):
print("ERROR: TEST 0B, WRONG DISTANCE")
else:
print("pass test 0B")
def run(self):
print "Running PTAS"
epsilon=0.1
beta=0.3
d=self.__d
light_speed=3*math.pow(10,8)
u=30000
mu=30000
numCluster=self.__numController
controllers=self.__km.initialCluster(numCluster/2)
maxControlDist=self.__ng.getMaxControlDist(controllers)
theta=maxControlDist*2/light_speed+5/1000
self.__B=theta
controllers=self.__km.initialCluster(numCluster)
self.__controllers=controllers
print controllers
edge=self.__ng.getGraph()
switch=self.__ng.getSwitch()
ds=self.__ds
adj={}
for s1 in switch:
adj[s1]={}
for s2 in self.__controllers:
adj[s1][s2]=0
d_node={}
count=0
for node in adj:
d_node[str(node)]=0
count=count+1
x=math.pow(1+count*epsilon,(1-epsilon)/epsilon)
x=1/x
y=math.pow((1-epsilon)/(count*(count-1)),1/epsilon)
gamma=x*y
curCost=float(0)
bv1=0
while (curCost<theta*len(switch)):
print "Current budget is: {}".format(theta*len(switch))
u_edge={}
phi={}
flow={}
cost={}
path={}
ca=queuing.queuing(mu)
for node,edge in adj.iteritems():
if node not in u_edge:
u_edge[str(node)]={}
if node not in flow:
flow[str(node)]={}
if node not in phi:
phi[str(node)]={}
for k,v in edge.iteritems():
if k not in u_edge:
u_edge[str(k)]={}
if k not in flow:
flow[str(k)]={}
if k not in phi:
phi[str(k)]={}
if node!=k:
phi[str(node)][str(k)]=gamma/self.__B
u_edge[str(node)][str(k)]=3*d[str(node)]
flow[str(node)][str(k)]=0
phi[str(k)][str(k)]=gamma/self.__B
u_edge[str(k)][str(k)]=u
flow[str(k)][str(k)]=0
cost[node]=0
mg=MCFGraph.MCFGraph(adj,u_edge,phi,flow,cost)
mg.graphUpdate(gamma,ca,ds,d)
adj_mcf=mg.getGraph()
sp=shortest_path.shortest_path(switch,adj_mcf)
node_dist=priority_dict.priority_dict()
for c in controllers:
d_node[str(c)]=d_node[str(c)]+beta*d[str(c)]
mg.updateFlow(str(c),str(c),d_node[str(c)])
path[c]=str(c)
dist=0
ca.updateAssignment(c,str(c),d_node)
t=ca.queuingTime(str(c))
rtt=t
cur_demand=d_node[str(c)]
mg.updateCost(c,rtt)
mg.relaxation(epsilon,self.__B,cur_demand,c,str(c),ca,ds)
adj_mcf=mg.getGraph()
sp=shortest_path.shortest_path(switch,adj_mcf)
totalDemand=0
for s in switch:
if s not in controllers:
if bv1==0:
d_node[str(s)]=d[str(s)]
totalDemand=totalDemand+d_node[str(s)]
cur_demand=d_node[str(s)]
u_edge=mg.getCapacity()
flow=mg.getFlow()
node_dist[s]=sp.shortestPath(s)
c_found=node_dist[s].smallest()
while (flow[str(c_found)][str(c_found)]+cur_demand>u_edge[str(c_found)][str(c_found)]):
node_dist[s].pop_smallest()
if len(node_dist[s])>0:
if node_dist[s].smallest() in self.__controllers:
c_found=node_dist[s].smallest()
else:
bv1=1
break
if bv1==0:
c_found=node_dist[s].smallest()
mg.updateFlow(str(s),str(c_found),cur_demand)
path[s]=str(c_found)
dist=ds[s][str(c_found)]
ca.updateAssignment(s,str(c_found),d_node)
t=ca.queuingTime(str(c_found))
rtt=dist*2/light_speed+t
mg.updateCost(s,rtt)
mg.relaxation(epsilon,self.__B,cur_demand,s,str(c_found),ca,ds)
adj_mcf=mg.getGraph()
sp=shortest_path.shortest_path(switch,adj_mcf)
totalCost=mg.calculateCost()
curCost=float(totalCost)
print "Total demand is {}.".format(totalDemand)
print "Cost is {}, K is {}.".format(curCost,len(controllers))
self.__path=path
self.__cost=curCost
if bv1==0:
numCluster=numCluster-1
else:
numCluster=numCluster+1
bv1=0
controllers=self.__km.initialCluster(numCluster)
self.__controllers=controllers
adj={}
for s1 in switch:
adj[s1]={}
for s2 in self.__controllers:
adj[s1][s2]=0
print controllers
print "Iteration ends."
def path_to_descendant(x,y): inverse = invert_options_func.invert_options_func(y,lambda x: x.those_can_be_within()) result = shortest_path.shortest_path(x,y,inverse) return result
def main():
# Create ROS node
rospy.init_node('marker_test', anonymous=False)
# Publish markers to 'marker_test' topic
pub_node = rospy.Publisher('visualization_marker_array', MarkerArray, queue_size=10)
# Initialize MarkerArray
marker_arr = MarkerArray()
marker_cnt = 0
# Marker for growing obstacles
# marker1 = initialize_marker('red')
from grow_obstacles import grow_obstacles
obstacles, _ = grow_obstacles()
for obstacle in obstacles:
# Create a new marker for each obstacle
marker = initialize_marker(marker_cnt, 'strip', 'red')
marker_cnt += 1
points = []
for point in obstacle:
pt = Point(point[0] * .01, point[1] * .01, 0)
# print(pt)
points.append(pt)
points.append(points[0]) # to make lines connect
marker.points = points
marker_arr.markers.append(marker)
# Marker for visibility graph
from gene_vgraph import gene_vgraph
edges, _ = gene_vgraph(obstacles_file, goal_file)
# Create a new marker for edges
marker = initialize_marker(marker_cnt, 'list', 'blue', alpha=.3)
marker_cnt += 1
points = []
for edge in edges:
pt1 = Point(edge[0][0] * .01, edge[0][1] * .01, 0)
pt2 = Point(edge[1][0] * .01, edge[1][1] * .01, 0)
points.append(pt1)
points.append(pt2)
marker.points = points
marker_arr.markers.append(marker)
# Marker for shortest path
from shortest_path import shortest_path
path, _ = shortest_path(obstacles_file, goal_file)
# Create a new marker for shortest path
marker = initialize_marker(marker_cnt, 'strip', 'green')
marker_cnt += 1
points = []
for point in path:
pt = Point(point[0] * .01, point[1] * .01, 0)
points.append(pt)
marker.points = points
marker_arr.markers.append(marker)
# Create points
# points = []
# pt1 = Point(1, 1, 1)
# pt2 = Point(2, 2, 2)
# points.append(pt1)
# points.append(pt2)
# marker.points = points
# marker_arr.markers.append(marker)
# Draw markers
while not rospy.is_shutdown():
pub_node.publish(marker_arr)
rospy.Rate(30).sleep()
from graph_adjacency_list import Graph as AdjacencyGraph
from graph_edge_list import Graph as EdgeGraph
from shortest_path import shortest_path
import sys
try:
print("Testing with adjacency list graph...")
adjacency_graph = AdjacencyGraph()
adjacency_graph.add_edge('a', 'b', 1)
adjacency_graph.add_edge('a', 'c', 2)
adjacency_graph.add_edge('b', 'd', 3)
adjacency_graph.add_edge('c', 'e', 5)
adjacency_graph.add_edge('d', 'e', 2)
adjacency_graph.add_edge('d', 'f', 4)
adjacency_graph.add_edge('e', 'f', 1)
if shortest_path(adjacency_graph, 'a', 'f') != (['a', 'b', 'd', 'e', 'f'
], 7):
print(
"Your code ran, but did NOT output the shortest distance from 'a' to 'f' when your adjacency list graph had the edge ('e', 'f', 1) added."
)
else:
print(
"Your code ran, and it correctly output the shortest distance from 'a' to 'f' when your adjacency list graph had the edge ('e', 'f', 1) added."
)
except:
print(
"Your code produced this error when adding edge ('a', 'b', 1) to the adjacency list graph or getting the shortest path from 'a' to 'b'."
)
print(sys.exc_info()[0])
try:
def run(self):
epsilon=0.1
beta=0.3
alpha=self.__alpha
d={}
light_speed=3*math.pow(10,5)
u=30000
d_lower=1500
d_upper=3000
mu=30000
self.__gi.graphParser()
edge=self.__gi.getGraph()
switch=self.__gi.getSwitch()
controller=self.__gi.getController()
ds=self.__ds
adj={}
for s1 in switch:
adj[s1]={}
d[s1]=0
for s2 in switch:
if s2!=s1:
adj[s1][s2]=0
#print adj
d_node={}
r_node={}
count=0
for node in adj:
d_node[node]=0
r_node[node]=0
count=count+1
x=math.pow(1+count*epsilon,(1-epsilon)/epsilon)
x=1/x
y=math.pow((1-epsilon)/(count*(count-1)),1/epsilon)
gamma=x*y
totalCost=4
for s in switch:
d[s]=d_lower+random.random()*(d_upper-d_lower)
path={}
while (totalCost<self.__B):
print "Current cost is: {}".format(totalCost)
u_edge={}
phi={}
flow={}
cost={}
ca=queuing.queuing(d,mu)
for node in d_node:
d_node[node]=d_node[node]+beta*d[node]
for node,edge in adj.iteritems():
if node not in u_edge:
u_edge[node]={}
if node not in flow:
flow[node]={}
for k,v in edge.iteritems():
if k not in u_edge:
u_edge[k]={}
if k not in flow:
flow[k]={}
phi[k]=gamma/self.__B
u_edge[node][k]=d_node[node]
u_edge[k][k]=u
flow[node][k]=0
flow[k][k]=0
cost[k]=0
mg=MCFGraph.MCFGraph(adj,u_edge,phi,flow,cost)
mg.graphUpdate(gamma)
adj_mcf=mg.getGraph()
path={}
sp=shortest_path.shortest_path(switch,adj_mcf)
#print adj_mcf
node_dist=priority_dict.priority_dict()
for s in switch:
print len(switch), totalCost
cur_demand=d_node[s]
u_edge=mg.getCapacity()
flow=mg.getFlow()
node_dist[s]=sp.shortestPath(s)
#print node_dist[s]
c_found=node_dist[s].smallest()
while (flow[c_found][c_found]+cur_demand>u_edge[c_found][c_found]):
node_dist[s].pop_smallest()
c_found=node_dist[s].smallest()
mg.updateFlow(s,c_found,cur_demand)
mg.updateCost(c_found)
path[s]=c_found
dist=ds[s][c_found]
#print s, c_found, node_dist[s][c_found]
ca.updateAssignment(s,c_found)
t=ca.queuingTime(s,c_found)
rtt=dist/light_speed*2+t
r_node[s]=cur_demand/d[s]+alpha*(self.__theta-rtt)
print rtt, self.__theta
self.__sub.append(self.__theta-rtt)
mg.relaxation(epsilon,self.__B,cur_demand,s,c_found)
adj_mcf=mg.getGraph()
sp=shortest_path.shortest_path(switch,adj_mcf)
totalCost=mg.calculateCost()
print len(switch), totalCost
#print "Current path is: {}".format(path)
i=0
min_obj=0
x=math.log((1+epsilon)/gamma,1+epsilon)
for node in r_node:
if (i==0):
r_node[node]=r_node[node]/x
min_obj=r_node[node]
else:
r_node[node]=r_node[node]/x
if (r_node[node]<min_obj):
min_obj=r_node[node]
i=i+1
self.__path=path
return min_obj
# This is a short test file, given to you to ensure that our grading scripts can grade your file.
# Please do not modify it.
# You should only submit "graph_adjacency_list.py", "graph_edge_list.py", and "shortest_path.py".
# This tests the simplest case: adding a single edge to the graph and checking the shortest path from one node to the other.
from graph_adjacency_list import Graph as AdjacencyGraph
from graph_edge_list import Graph as EdgeGraph
from shortest_path import shortest_path
import sys
try:
print("Testing with adjacency list graph...")
adjacency_graph = AdjacencyGraph()
adjacency_graph.add_edge('a', 'b', 1)
if shortest_path(adjacency_graph, 'a', 'b') != (['a', 'b'], 1):
print(
"Your code ran, but did NOT output the shortest distance from 'a' to 'b' when your adjacency list graph had the edge ('a', 'b', 1) added."
)
else:
print(
"Your code ran, and it correctly output the shortest distance from 'a' to 'b' when your adjacency list graph had the edge ('a', 'b', 1) added."
)
except:
print(
"Your code produced this error when adding edge ('a', 'b', 1) to the adjacency list graph or getting the shortest path from 'a' to 'b'."
)
print(sys.exc_info()[0])
try:
print("Testing with edge list graph...")
