Mathesis Wiki

# -*- coding: utf8 -*-
from __future__ import division, print_function
 
import scipy, scipy.stats
import numpy as np
 
from GraphFunctions import *
from MapFunctions import *
 
def optimize(karte=None, money=9000):
	if karte==None:
		karte = load("Graph.save")
 
	#karte.inodes=karte.loadNodeList("inodes.dat")
	#karte.vinodes=karte.loadNodeList("vinodes.dat")
	karte.defineINodesRandom(100)
	karte.defineVINodesRandom(5)
	Exp=loadExpenses()
 
	optBackbone(karte, 0.5*money)
	#0.5 das beste???
 
def optBackbone(karte, money):
	explist=loadExpenses()
	while money>0:
		print(money)
 
		karte.clearEdges()
		print(rateGraph(karte, False, karte.vinodes, karte.vinodes))
		iedges=karte.mostNImportantNMEdges(2000)
		bedges=findNBuildEdges(iedges, 600, explist)
		for e in bedges:
			money-=build(e[0], e[0].typ+1, explist)
 
 
def splitGraph(karte=None, startnode=None, maxEntf=500):
	if karte==None:
		print("Loading Graph...")
		karte = load("Graph.save")
		print("Graph loaded")
	if startnode==None:
		startnode=karte.nodes[0]
	print("Building new Graph...")
	newMap=	Graph()
	startnode.dist=0
	nrvisited=1
	tovisit=Queue.PriorityQueue(len(karte.nodes))
 
	tovisit.put((0,startnode))
 
	lastdist=0
 
	while(not tovisit.empty() and lastdist<maxEntf):
		node=tovisit.get()[1]
		if(not node.unvisited):
			continue
		node.unvisited=False
		for t in node.findNeighbors():
			if node.dist+t[0].dist<t[1].dist:
				t[1].dist=node.dist+t[0].dist
				t[1].ancestor=node
				tovisit.put((t[1].dist, t[1]))
				newMap.addNodeSafe(t[1].name, t[1].gnb, t[1].gel)
		newnode=newMap.addNodeSafe(node.name, node.gnb, node.gel)
 
		for nedge in node.cEdges:
			if not newMap.existEdge(nedge):
				newMap.addEdge(newnode, newMap.findNode(nedge.getSecondNode(node).name), nedge.typ)
		lastdist=node.dist
	printMap(newMap, "splitted.osm")
	karte.clearNodes()
	return newMap
 
def build(edge, typ, expenses):
	oldtype=edge.typ
	edge.typ=typ
	edge.dist=edge.entf/typ
	back=0
	for i in expenses:
		if i[0]<=oldtype:
			back=edge.entf*i[1]
	for i in expenses:
		if i[0]>=typ:
			return edge.entf*i[1]-back
 
def findNBuildEdges(elist, n=1, expenses=None):
	if expenses==None:
		expenses=loadExpenses()
	es = []
	for i in range(0, n):
		es.append((Edge(None, None, None, 1, 0, -1), 0))
	for e in elist:
		if(upgradeGoodness(e) > es[-1][1]):
			i = 0
			while(es[i][1] > upgradeGoodness(e, expenses)):
				i = i + 1
			shiftList(es, i)
			es[i] = (e, upgradeGoodness(e, expenses))
	return es
 
def rateGraph(g=None, undefined=True, inodes=None, vinodes=None):
 
	if g==None:
		g = ModMap.load("Graph.save")
 
	if undefined:
		g.defineINodesRandom(1000)
		g.defineVINodesRandom(50)
 
	if inodes==None:
		inodes=g.inodes
 
	if vinodes==None:
		vinodes=g.vinodes
 
	distsum=0
	distprod=1
 
	numList =[]
	dist=[]
	counter=0
	for snode in vinodes:
		dist.append(dijkstra(g, snode, inodes))
		g.clearNodes()
		counter+=1
		print(counter)
 
	counter=0
	if dist!=None:
		for i in dist:
			if i!=None:
				for numb in i:
					if numb != -1:
						numList.append(numb)
 
	arithmetic=np.mean(numList)
	geometric=scipy.stats.mstats.gmean(numList)
	g.saveAllNodeLists()
	g.saverate()
	return (geometric, arithmetic)
 
if __name__ == "__main__":	
	optimize()