def simplified_bruteForce(R, ax=None, aCap=0.20, beta=1.5, warmup=False, anim=False):
	"""
	a simplified algorithm. Still a little bit complex dock, but this is as simple as it gets I think.

	Does not add any edges, only removal. No stochastic elements are involved.

	anim=True creates a movie.
	"""
	R.beta=beta	
	inf = 1e12
	eps=1e-9
	lastAdded=None
	origin=R.origin
	if not origin:
		raise Exception('need info about origin')

	#now, start for real and save away all kind of info about the paths.
	for node in R.nodes(data=True):		
		p1,p2=get_shortest_and_second(R,node)
		node[1]['shortest_path']=p1
		if len(p1)==0: #origin
			assert node[0]==origin
			node[1]['second_shortest']=[]
		else:
			node[1]['second_shortest']=p2
		for p in p1,p2: #now, update edge info for all visited edges
			for edge in R.edges_from_path_gen(p):
				d=R.get_edge_data(*edge)
				if not node in d['visited_from_node']: d['visited_from_node'].append(node) #in order to later see...
	if warmup:
		forcePaths(R)
	remList=[]
	for e in R.edges(data=False): #add to remove list and calc. costs
		e_data=R.get_edge_data(*e)
		e_data['c']=cost(R, e, storeData=True)
		remList.append(e)
	remList=sortRemList(R,remList)

	#all stuff initialized by now.
	while len(remList)>0: #the loop where edges are removed..

		"""
		now, choose the edge with the lowest cost.
		We have a problem since the cost saved is not necessary updated to the correct value.
		Actually, the only way to update it correctly is to scan through all edges for every removal. One could think that it would be possible to only update the ones affected by the removal, i.e. the ones connected by the shortest roads. The problem is that we also need to account for the ones that would take this road if some other arbitrary road was removed. Storing that variable would be possible but very memory inefficient. It could be tried and developed further, but would only be necessary if we add edges because the below alg. works pretty good.
		
		We use the fact that the cost from removing edges can only be bigger, i.e when removing edges it only gets worse.
		
		Thus, if the updated cost is still the smallest in the list, we know that this road is cheapest to remove.
		"""
		if anim: #movietime
			R.movieFlush()
		while True: #two possibilities to break out below..
			e=remList[0]
			e_data=R.get_edge_data(*e)
			e_data['c']=cost(R,e,storeData=False)
			if len(remList)==1:
				break
			#now, look for the other one..
			e2=remList[1]
			e2_data=R.get_edge_data(*e2)
			if e_data['c']<=e2_data['c']:
				break #e is our candidate, we know it's best
			e2_data['c']=cost(R, e2, storeData=False) #update, can only get worse
			for e in e,e2: #check for infinite costs, remove in that case.
				d=R.get_edge_data(*e) #this c has just been updated.
				if d['c']>=inf:
					remList.remove(e)
			remList=sortRemList(R,remList) #sort it, try again..
		#found our candidate
		if e_data['c']>=inf: break #if last in remList and infinite cost..
		remList.remove(e)
		e_data['c']=cost(R,e,storeData=True) #in order to store the new path..
		assert e_data['c']<inf
		#we are outside... will we go over the areaLimit if we remove e?
		if e_data['c']>eps and R.areaCover-go.singleRoadSegmentCoverage(e, R, remove=True)*R.Ainv<aCap:
			assert abs(R.areaCover-go.roadAreaCoverage(R))<eps #compare internal and actual.
			break #we are finished
		assert R.degree(e[0])>2 and R.degree(e[1])>2 #cost func should have given c=inf.
		print "removes edge ",e, e_data['c']
		remove_edge(e, R) #remove from R.
	if anim:
		R.movieFlush(final=True)
	R.cost=cf.totalCost(R)
	print "construction finished."
	print "road area coverage:", R.areaCover
	print "total area:", R.A
	print "number of nodes", len(R.nodes())
	print "total cost:", R.cost
	return R
Exemple #2
0
def stochastic(R, ax=None, aCap=0.20, beta=1.5, anim=False, probListGen=None):
	"""
	a simplified algorithm. Still a little bit complex dock, but this is as simple as it gets I think.

	Does not add any edges, only removal. No stochastic elements are involved.

	anim=True creates a movie.

	probListGen can be given. That is a class of type ProbListGen that defines a specific
	distribution that is used by the stochastic parts.
	"""
	if probListGen==None: #use default, 0.5^i
		probListGen=ProbListGen(0.5,15)
	R.beta=beta	
	inf = 1e15
	eps=1e-9
	choiceMax=15 #we will not randomly choose something bigger than this.
	lastAdded=None
	origin=R.origin
	for e in R.edges(data=True): assert e[2]['weight']>=0
	if not origin: raise Exception('need info about origin')

	#now, start for real and save away all kind of info about the paths.
	for node in R.nodes(data=True):		
		p1,p2=get_shortest_and_second(R,node)
		node[1]['shortest_path']=p1
		if len(p1)==0: #origin
			assert node[0]==origin
			node[1]['second_shortest']=[]
		else:
			node[1]['second_shortest']=p2
		for p in p1,p2: #now, update edge info for all visited edges
			for edge in R.edges_from_path_gen(p):
				d=R.get_edge_data(*edge)
				if not node in d['visited_from_node']:
					d['visited_from_node'].append(node) #in order to later see...

	remList=[]
	for e in R.edges(data=False): #add to remove list and calc. costs
		e_data=R.get_edge_data(*e)
		e_data['c']=cost(R, e, storeData=True)
		remList.append(e)
	remList=sortRemList(R,remList)
	choices=[0]*15 #for statistics areound the stochastics.
	while len(remList)>0: #the loop where edges are removed..

		"""
		We have a problem since the cost saved is not necessary updated to the correct value.
		Actually, the only way to update it correctly is to scan through all edges for every removal. One could think that it would be possible to only update the ones affected by the removal, i.e. the ones connected by the shortest roads. The problem is that we also need to account for the ones that would take this road if some other arbitrary road was removed. Storing that variable would be possible but very memory inefficient. It could be tried and developed further, but would only be necessary if we add edges because the below alg. works pretty good.
		
		We use the fact that the cost from removing edges can only be bigger, i.e when removing edges it only gets worse.
		
		Thus, if the updated cost is still the smallest in the list, we know that this road is cheapest to remove.
		"""
		probList=probListGen.getList(N=len(remList))
		if anim: #it's showtime..
			R.movieFlush()
		r=random.uniform(0,1)
		choice=choiceMax
		for i,p in enumerate(probList): #time to make the choice..
			if r<p:
				choice=i #usually 0.. 50% prob of that.
				break
		updated=[] #store edges that we have updated the cost for..
		done=False
		while not done: #two possibilities to break out below..
			done=True
			for i in range(choice+2): #loop over all necessary edges
				try:
					e=remList[i]
				except IndexError: #remList is too short.. we are done here...
					done=True
					break #breaks out of for-loop, not while loop
				e_data=R.get_edge_data(*e)
				if not e in updated: #saves us some calculations
					done=False #have to iterate once more.
					e_data['c']=cost(R,e,storeData=False)
					updated.append(e)
					if e_data['c']>=inf:
						remList.remove(e)
					break #otherwise we "jump over" one in the list. new for loop
				if e_data['c']>=inf:
					remList.remove(e)
				remList=sortRemList(R,remList) #sort it..
			remList=sortRemList(R,remList) #last time.. may be a double sort but who cares?
		#sorting remList and updating cost procedure is now done.
		if len(remList)==0: break #we are done
		if choice>=len(remList): #may happen if edges have been removed due to inf. cost
			choice=int(floor(random.uniform(0,len(remList)))) #take a random one..
			print "choice:", choice
		e=remList[choice]
		e_data=R.get_edge_data(*e)
		remList.remove(e)
		e_data['c']=cost(R,e,storeData=True) #in order to store the new path..
		assert e_data['c']<inf
		#following lines just to check, not used... remove later..
		if __debug__ and choice != -1 and len(remList)>choice+1: 
			e2=remList[choice+1]
			e2_data=R.get_edge_data(*e2)
			assert e_data['c']<=e2_data['c']

		#we are outside... will we go over the areaLimit if we remove e?
		if e_data['c']>eps and R.areaCover-go.singleRoadSegmentCoverage(e, R, remove=True)*R.Ainv<aCap:
			assert abs(R.areaCover-go.roadAreaCoverage(R))<eps #compare internal and actual.
			break #we are finished
		print "removes edge ",e, e_data['c'], cost(R,e)
		assert R.degree(e[0])>2 and R.degree(e[1])>2 #cost func should have given c=inf.
		remove_edge(e, R) #remove from R.
		choices[choice]+=1
	if anim:
		R.movieFlush(final=True)
	print "construction finished."
	print "road area coverage:", R.areaCover
	print "total area:", R.A
	print "choices:", choices
	R.cost=cf.totalCost(R)
	print "total cost:", R.cost
	return R
Exemple #3
0
def bruteForce(R, G=None, ax=None, aCap=0.25, beta=1.5, add=True):
	"""
	works with cycles instead of shortest paths

	VERY computationally complex. The earlier algorithms could handle much bigger systems.
	
	modifies G into R:... this is a strange procedure and should be changed.
	"""
	R.beta=beta	
	if not G: G=copy.deepcopy(R)

	inf = 1e12
	eps=1e-9
	lastAdded=None
	origin=G.origin
	if not origin: raise Exception('need info about origin')
	#first, modify the weight of the edges a couple of times. Warmup
	warmUp(R)
	paths=nx.algorithms.shortest_paths.weighted.single_source_dijkstra(R, origin)
	#now, start for real and save away all kind of info about the paths.
	for node in R.nodes(data=True):
		p1=paths[1][node[0]]
		p1.reverse()
		node[1]['shortest_path']=p1
		if len (p1)<=1:
			node[1]['second_shortest']=p1
		else:
			e=[p1[0], p1[1]] #edge closest to point
			e.append(R.get_edge_data(e[0], e[1]))
			R.remove_edge(e[0], e[1]) #temporary remove to get loop
			p2=nx.dijkstra_path(R,origin, node[0])
			node[1]['second_shortest']=p2
			R.add_edges_from([tuple(e)]) #reset road
			#ax=testRoads(R, p1, p2, ax) #used for debugging
			for path in p1,p2:
				last=None
				for nTmp in path:
					if last:
						d=R.get_edge_data(*(last, nTmp)) #should always exist if designed properly
						d['visits']+=1
						if not node in d['visited_from_node']: d['visited_from_node'].append(node)
					last=nTmp
	remList=[]
	addList=[]
	for eTmp in R.edges(data=False):
		e=copy.copy(eTmp) #copy, so we can remove them and then add them and so on.
		e2=R.get_edge_data(*e) #not a copy, reference to real dict.
		e=list(e)
		e.append(e2)
		e[2]['origin_dist']=distToOrigin(e,R)
		e[2]['c']=routingCost(R, e, storeData=False)
		remList.append(e)
	i=1
	#at this point, the visited thing should be updated
	for edge in R.edges(data=True):
		modifyEdge(edge,R,reset=True) #reset to real weight.
	while len(remList)>0:
		i=i+1
		print "start"
		first=True
		e1=False
		assert len([e for e in R.edges(data=True) if e[2]['weight']<0])==0
		while first or e[0:2]!=e1[0:2]:
			e1=remList[0] #takes the last item in the list.
			e1[2]=R.get_edge_data(e1[0], e1[1]) #edgelist is a copy, this is not.
			c=routingCost(R, e1, storeData=True) #also updates e[2]['c']
			#e1[2]=R.get_edge_data(e1[0], e1[1])
			e1[2]['c']=c #-e1[2]['origin_dist']*0.1 #origin dist just to experiment.
			if c>=inf:
				remList.remove(remList[0]) #cannot be empty at this time
				if len(remList)==0: break
			remList=sorted(remList, key=lambda edge: edge[2]['c'])#+edge[2]['visits'])#-edge[2]['origin_dist']*0.1) #first sort
			e=remList[0] # could be the same..
			if first: first=False
		e[2]=R.get_edge_data(*e) # Update again, to get "new second shortest"
		if add and random.uniform(0,1)<0.33:
			print "adds"
			added, addList, remList, lastAdded=addListProcedure(addList,remList,R,e[2]['c'],i,lastAdded)
			if added: continue #go up to while again
		if len(remList)==0: break
		#print "will remove:", remList[0][0:2]
		remList.remove(remList[0]) #we know now that no edge is added this "round"
		#print "is it still there?"
		#for r in remList:
		#	print r[0:2]
		#print "removed, next", remList[0][0:2]
		print e[2]['c']
		if e[2]['c']>eps and aCap and R.areaCover-go.singleRoadSegmentCoverage(e, R, remove=True)*G.Ainv<aCap:
			print "tries to exit", e[0:2], "ec:", e[2]['c']
			if add:
				added, addList, remList, lastAdded=addListProcedure(addList,remList,R,e[2]['c'],i,lastAdded)
				if added:
					remList.append(e) #since we just removed it and didn't remove it from graph
					continue
			break #we are finished
		if R.degree(e[0])>2 and R.degree(e[1])>2 and c<inf: #loop condition, at least degree 3
			print "removes edge ",e[0:2]
			remove_edge(e, R) #remove from R.
			addList.append(e) #add to lists for potential adding again.
			e[2]['c']*=-1 #reverse, we now gain c by adding it again.
			assert e[2]['c']<=0
			e[2]['i_added']=i
			#this procedure can most certainly be speeded up, expensive operations.
			update_after_mod(e,R)
	for e in R.edges(data=True):
		modifyEdge(e, R, reset=True)
	R.cost=cf.totalCost(R)
	print "construction finished."
	print "total number of nodes:", len(R.nodes())
	print "road area coverage:", R.areaCover
	print "total area:", G.A
	print "total cost:", R.cost
	return R