import random, time, sys
from decimal import *
class Konto:
def __init__(self, nr):
self.resetKonto(nr)
def resetKonto(self, nr):
self.__nr = nr
self.__seinKontoStand = Decimal('0')
self.__letzteAktivitaetSekunde = 0
self.__seineWahlRAUM = -1
self.__seineWahlZEIT = -1
self.__nrInklBerechnetNachListeBis = len(liste) - 2
def anmelden(self, s):
self.__letzteAktivitaetSekunde = s
def findeOpfer(self, s):
global t_LfdSummeInT, anzAlive
lg(str(self.__letzteAktivitaetSekunde) + "__Hallo, hier ist findeOpfer!findeOpfer!findeOpfer!findeOpfer!__" + str(self.__nr))
lg("anzAlive = " + str(anzAlive))
if (anzAlive > 1):
nrImKontoFeldToCheck = random.randint(0, anzAlive - 1)
while (nrImKontoFeldToCheck == indexFeld[self.__nr]):
nrImKontoFeldToCheck = random.randint(0, anzAlive - 1)
if (s - konto[nrImKontoFeldToCheck].__letzteAktivitaetSekunde > ANZ_MAXSEKUNDEN_OHNE_AKTIVITAET):
lg(str(self.__nr) + " hat entdeckt: Inaktiv seit " + str(s - konto[nrImKontoFeldToCheck].__letzteAktivitaetSekunde) + " Sekunden, nrImKontoFeldToCheck =" + str(nrImKontoFeldToCheck) + ", entdeckteKtoNr = " + str(konto[nrImKontoFeldToCheck].__nr))
wahlenZEIT[konto[nrImKontoFeldToCheck].__seineWahlZEIT] -= 1
wahlenRAUM[konto[nrImKontoFeldToCheck].__seineWahlRAUM] -= 1
t_LfdSummeInT += konto[nrImKontoFeldToCheck].getKontoStand()
anzAlive -= 1
lg("jetzt ist anzAlive = " + str(anzAlive))
indexFeld[konto[anzAlive].__nr] = indexFeld[konto[nrImKontoFeldToCheck].__nr]
indexFeld[konto[nrImKontoFeldToCheck].__nr] = -1
konto[nrImKontoFeldToCheck].__nr = konto[anzAlive].__nr
konto[nrImKontoFeldToCheck].__seinKontoStand = konto[anzAlive].__seinKontoStand
konto[nrImKontoFeldToCheck].__letzteAktivitaetSekunde = konto[anzAlive].__letzteAktivitaetSekunde
konto[nrImKontoFeldToCheck].__seineWahlRAUM = konto[anzAlive].__seineWahlRAUM
konto[nrImKontoFeldToCheck].__seineWahlZEIT = konto[anzAlive].__seineWahlZEIT
konto[nrImKontoFeldToCheck].__nrInklBerechnetNachListeBis = konto[anzAlive].__nrInklBerechnetNachListeBis
warte(8)
def getKontoStand(self):
lenListeMinus2 = len(liste) - 2
while (self.__nrInklBerechnetNachListeBis < lenListeMinus2):
self.__nrInklBerechnetNachListeBis += 1
self.__seinKontoStand = self.__seinKontoStand + liste[self.__nrInklBerechnetNachListeBis][1] + liste[self.__nrInklBerechnetNachListeBis][3]
#alt seineZuZahlendeULG = self.__seinKontoStand * Decimal(liste[self.__nrInklBerechnetNachListeBis][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** (liste[self.__nrInklBerechnetNachListeBis + 1][0] - liste[self.__nrInklBerechnetNachListeBis][0])) / 100
#alt seineZuZahlendeULG = (self.__seinKontoStand * Decimal(liste[self.__nrInklBerechnetNachListeBis][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** (liste[self.__nrInklBerechnetNachListeBis + 1][0] - liste[self.__nrInklBerechnetNachListeBis][0])) / 100).quantize(nachKommaStellen)
if (random.randint(0, 1) == 0):
seineZuZahlendeULG = (self.__seinKontoStand * Decimal(liste[self.__nrInklBerechnetNachListeBis][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** (liste[self.__nrInklBerechnetNachListeBis + 1][0] - liste[self.__nrInklBerechnetNachListeBis][0])) / 100).quantize(nachKommaStellen, rounding=ROUND_DOWN)
else:
seineZuZahlendeULG = (self.__seinKontoStand * Decimal(liste[self.__nrInklBerechnetNachListeBis][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** (liste[self.__nrInklBerechnetNachListeBis + 1][0] - liste[self.__nrInklBerechnetNachListeBis][0])) / 100).quantize(nachKommaStellen, rounding=ROUND_UP)
self.__seinKontoStand = self.__seinKontoStand - seineZuZahlendeULG + liste[self.__nrInklBerechnetNachListeBis + 1][2]
return self.__seinKontoStand
def rein(self, x): # x muß ganzzahlig! stimmt nicht, rest kommt auch rein!
# log("Hier ist konto.rein() mit reinkommt x=" + str(x) + ", vorher self.seinKontoStand=" + str(self.__seinKontoStand))
self.__seinKontoStand = self.getKontoStand() + x
# log("Ende konto.rein(), jetzt self.seinKontoStand=" + str(self.__seinKontoStand))
def raus(self, x, zielKtoNr, e, medianRAUM): # x muß ganzzahlig!
__entfernungsGebuehr = Decimal('-1')
if (zielKtoNr == -1):
if (x < self.getKontoStand()):
self.__seinKontoStand -= x
bank.kontoStand_raus(x)
__entfernungsGebuehr = Decimal('0')
else:
#alt __entfernungsGebuehr = x * e * Decimal('' + str(medianRAUM)) / Decimal('' + str(2000000))
#alt __entfernungsGebuehr = (x * e * Decimal('' + str(medianRAUM)) / Decimal('' + str(2000000))).quantize(nachKommaStellen)
if (random.randint(0, 1) == 0):
__entfernungsGebuehr = (x * e * Decimal('' + str(medianRAUM)) / Decimal('' + str(2000000))).quantize(nachKommaStellen, rounding=ROUND_DOWN)
else:
__entfernungsGebuehr = (x * e * Decimal('' + str(medianRAUM)) / Decimal('' + str(2000000))).quantize(nachKommaStellen, rounding=ROUND_UP)
if (self.getKontoStand() >= (x + __entfernungsGebuehr)):
self.__seinKontoStand -= (x + __entfernungsGebuehr)
# müßte hier anmelden??
konto[zielKtoNr].getKontoStand()
konto[zielKtoNr].rein(x) # falsch! mußdu warteschlange
log("INTERN: " + str(self.__nr) + " überwies soeben an " + str(konto[zielKtoNr].__nr) + ": " + str(x) + " E bei " + str(e) + " km und median " + str(medianRAUM) + " und zahlte g=" + str(__entfernungsGebuehr))
return __entfernungsGebuehr
def waehle(self, was):
seineWahl=random.randint(0, 100)
if (was == 'R'):
if (self.__seineWahlRAUM > -1):
wahlenRAUM[self.__seineWahlRAUM] -= 1
self.__seineWahlRAUM = seineWahl
wahlenRAUM[seineWahl] += 1
else:
if (self.__seineWahlZEIT > -1):
wahlenZEIT[self.__seineWahlZEIT] -= 1
self.__seineWahlZEIT = seineWahl
wahlenZEIT[seineWahl] += 1
return seineWahl
def getSeineWahlRAUM(self):
return self.__seineWahlRAUM
def getSeineWahlZEIT(self):
return self.__seineWahlZEIT
def debugTmpGetNR(self):
return self.__nr
def debugTmpGetSeinKontoStand(self):
return self.__seinKontoStand
def debugAusgabeKontoAlles(self):
log("--")
log("ktoNr = " + str(self.__nr))
log("seinKontoStand = " + str(self.__seinKontoStand))
log("letzteAktivitaetSekunde = " + str(self.__letzteAktivitaetSekunde))
log("seineWahlRAUM = " + str(self.__seineWahlRAUM))
log("seineWahlZEIT = " + str(self.__seineWahlZEIT))
log("nrInklBerechnetNachListeBis = " + str(self.__nrInklBerechnetNachListeBis))
def debugGetKontoStand(self):
lenListeMinus2 = len(liste) - 2
tmpNrInklBerechnetNachListeBis = self.__nrInklBerechnetNachListeBis
tmpSeinKontoStand = self.__seinKontoStand
while (tmpNrInklBerechnetNachListeBis < lenListeMinus2):
tmpNrInklBerechnetNachListeBis += 1
tmpSeinKontoStand = tmpSeinKontoStand + liste[tmpNrInklBerechnetNachListeBis][1] + liste[tmpNrInklBerechnetNachListeBis][3]
#alt tmpSeineZuZahlendeULG = tmpSeinKontoStand * Decimal(liste[tmpNrInklBerechnetNachListeBis][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** (liste[tmpNrInklBerechnetNachListeBis + 1][0] - liste[tmpNrInklBerechnetNachListeBis][0])) / 100
#alt tmpSeineZuZahlendeULG = (tmpSeinKontoStand * Decimal(liste[tmpNrInklBerechnetNachListeBis][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** (liste[tmpNrInklBerechnetNachListeBis + 1][0] - liste[tmpNrInklBerechnetNachListeBis][0])) / 100).quantize(nachKommaStellen)
if (random.randint(0, 1) == 0):
tmpSeineZuZahlendeULG = (tmpSeinKontoStand * Decimal(liste[tmpNrInklBerechnetNachListeBis][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** (liste[tmpNrInklBerechnetNachListeBis + 1][0] - liste[tmpNrInklBerechnetNachListeBis][0])) / 100).quantize(nachKommaStellen, rounding=ROUND_DOWN)
else:
tmpSeineZuZahlendeULG = (tmpSeinKontoStand * Decimal(liste[tmpNrInklBerechnetNachListeBis][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** (liste[tmpNrInklBerechnetNachListeBis + 1][0] - liste[tmpNrInklBerechnetNachListeBis][0])) / 100).quantize(nachKommaStellen, rounding=ROUND_UP)
tmpSeinKontoStand = tmpSeinKontoStand - tmpSeineZuZahlendeULG + liste[tmpNrInklBerechnetNachListeBis + 1][2]
return tmpSeinKontoStand
class Bank:
def __init__(self):
self.__kontoStand = Decimal('0')
def kontoStand_raus(self, x):
self.__kontoStand -= x
def kontoStand_rein(self, x):
self.__kontoStand += x
def getKontoStand(self):
return self.__kontoStand
#---------------------------------------------------------------------
def getMedianRAUM():
# return random.randint(1,200) / 2
haelfteAnzAlive = anzAlive // 2
if (anzAlive % 2 == 1):
haelfteAnzAlive+=1
i = 0
sum = 0
while 1:
sum += wahlenRAUM[i]
if (sum >= haelfteAnzAlive):
break
i+=1
if ((sum > haelfteAnzAlive) or (anzAlive % 2 == 1)):
return i
j = i + 1
while wahlenRAUM[j] == 0:
j+=1
return (i + j) / 2
def getMedianZEIT():
# return random.randint(1,200) / 2
haelfteAnzAlive = anzAlive // 2
if (anzAlive % 2 == 1):
haelfteAnzAlive+=1
i = 0
sum = 0
while 1:
sum += wahlenZEIT[i]
if (sum >= haelfteAnzAlive):
break
i+=1
if ((sum > haelfteAnzAlive) or (anzAlive % 2 == 1)):
return i
j = i + 1
while wahlenZEIT[j] == 0:
j+=1
return (i + j) / 2
def erweitereEvtListe(jetztSek):
global g_LfdSummeInT, t_LfdSummeInT
# log("Hier ist evt! g_LfdSummeInT = " + str(g_LfdSummeInT))
rest = Decimal('0')
if (jetztSek != liste[-1][0]):
anzSekundenVergangenerZeitraum = jetztSek - liste[-1][0]
if not g_LfdSummeInT.is_zero():
# log("g_LfdSummeInT is not zero:")
#alt gProAlive = (g_LfdSummeInT / anzAlive)
#alt gProAlive = (g_LfdSummeInT / anzAlive).quantize(nachKommaStellen)
if (random.randint(0, 1) == 0):
gProAlive = (g_LfdSummeInT / anzAlive).quantize(nachKommaStellen, rounding=ROUND_DOWN)
else:
gProAlive = (g_LfdSummeInT / anzAlive).quantize(nachKommaStellen, rounding=ROUND_UP)
liste[-1][1] = gProAlive
log("LISTE aufgenommen: gProAlive = " + str(gProAlive))
rest = g_LfdSummeInT - gProAlive * anzAlive
# log("rest = g_LfdSummeInT - gProAlive * anzAlive = " + str(rest))
g_LfdSummeInT = Decimal('0')
if not t_LfdSummeInT.is_zero():
#alt tProAlive = (t_LfdSummeInT / anzAlive)
#alt tProAlive = (t_LfdSummeInT / anzAlive).quantize(nachKommaStellen)
if (random.randint(0, 1) == 0):
tProAlive = (t_LfdSummeInT / anzAlive).quantize(nachKommaStellen, rounding=ROUND_DOWN)
else:
tProAlive = (t_LfdSummeInT / anzAlive).quantize(nachKommaStellen, rounding=ROUND_UP)
liste[-1][3] = tProAlive
log("LISTE aufgenommen: tProAlive = " + str(tProAlive))
rest += t_LfdSummeInT - tProAlive * anzAlive
t_LfdSummeInT = Decimal('0')
liste[-1][4] = getMedianZEIT()
#alt uZuTMinus1 = bank.getKontoStand() * Decimal(liste[-1][4]) * (1- SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** anzSekundenVergangenerZeitraum) / 100 / anzAlive
#alt uZuTMinus1 = (bank.getKontoStand() * Decimal(liste[-1][4]) * (1- SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** anzSekundenVergangenerZeitraum) / 100 / anzAlive).quantize(nachKommaStellen)
if (random.randint(0, 1) == 0):
uZuTMinus1 = (bank.getKontoStand() * Decimal(liste[-1][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** anzSekundenVergangenerZeitraum) / 100 / anzAlive).quantize(nachKommaStellen, rounding=ROUND_DOWN)
else:
uZuTMinus1 = (bank.getKontoStand() * Decimal(liste[-1][4]) * (1 - SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE ** anzSekundenVergangenerZeitraum) / 100 / anzAlive).quantize(nachKommaStellen, rounding=ROUND_UP)
liste.append([jetztSek, g_LfdSummeInT, uZuTMinus1, t_LfdSummeInT, 255])
# if not rest.is_zero():
# konto[wer].rein(rest) # hallo, hat er die ulg jetzt schon berechnet? glaube nicht! vorher muß er selbst noch alles bei sich ausrechnen
if not rest.is_zero():
log("rest not zero!")
log("rest = " + str(rest))
warte(5)
return rest
def warte(s):
return
lg("warte(" + str(s) + ")")
time.sleep(s)
def log(text):
print(text)
return
logDatei = open("log_simulation.htm", "a")
logDatei.write(text + "
")
logDatei.close()
def lg(text):
return
def berechneFehler(kSum):
global lfdErgebnis, min_Ergebnis, max_Ergebnis
fehlerDecimal = kSum - bank.getKontoStand()
if abs(fehlerDecimal) > Decimal('.1'):
print("ERROR111 fehlerDecimal ist " + str(fehlerDecimal))
time.sleep(86400)
if fehlerDecimal < Decimal('0'):
k = bank.getKontoStand() - kSum + 1
ii = str(k).index('.') + 1
ergebnis = -int(str(k)[ii:])
else:
if not fehlerDecimal.is_zero():
k = kSum
ii = str(k).index('.') + 1
ergebnis = int(str(k)[ii:])
else:
ergebnis = 0
logDatei = open("log_simulation.htm", "a")
logDatei.write(str(ergebnis) + "
")
logDatei.close()
log("berechneFehler: ergebnis =" + str(ergebnis))
lfdErgebnis += ergebnis
print("lfdErgebnis = " + str(lfdErgebnis))
if (ergebnis < min_Ergebnis):
min_Ergebnis = ergebnis
if (ergebnis > max_Ergebnis):
max_Ergebnis = ergebnis
log("lfdErgebnis =" + str(lfdErgebnis) + ", min_Ergebnis =" + str(min_Ergebnis) + ", max_Ergebnis =" + str(max_Ergebnis))
return
#-------------------------------------------------------------
#-------------------------------------------------------------
#-------------------------------------------------------------
logDatei = open("log_simulation.htm", "w")
logDatei.close()
getcontext().prec = 50
SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE = Decimal('0.999999998066148989700027968088116596355888304000336285236002827478495245100174870143906581983839427379')
#SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE = Decimal('1')
#SCHRUMPFUNGSFAKTOR_PRO_SEKUNDE = Decimal('0.99')
getcontext().rounding = ROUND_HALF_UP
nachKommaStellen=Decimal('0.00000000000000000001') #20
#nachKommaStellen=Decimal('0.0000000001')
#for i in range(0, 200):
# print(str(i) + ", " + str(Decimal(i).quantize(nachKommaStellen)) + "___" +str(i / 2) + ", " + str(Decimal(i / 2).quantize(nachKommaStellen)))
ANZ_EREIGNISSEKUNDEN = 200000
MAX_ANZ_Alive = 3
#ANZ_MAXSEKUNDEN_OHNE_AKTIVITAET = 157680000 # 5 Jahre
ANZ_MAXSEKUNDEN_OHNE_AKTIVITAET = 19416800 # test
#ANZ_MAXSEKUNDEN_OHNE_AKTIVITAET = 5 # test
lfdErgebnis = 0
min_Ergebnis =0
max_Ergebnis =0
pSekunde = 600000
pSchautNach = 0
pWaehltRaum = 10
pWaehltZeit = 10
pZugang = 3 * MAX_ANZ_Alive
pIntern = 30
pKM = 20000
pRaus = 20
pRein = 20
pKontrolle = 1000
wahlenRAUM = [0 for _ in range(101)]
wahlenZEIT = [0 for _ in range(101)]
jetztSekunde = 0
anzAlive = 0
bank=Bank()
konto = []
indexFeld = []
liste=[]
g_LfdSummeInT = Decimal('0')
t_LfdSummeInT = Decimal('0')
#xxx
for nrEreignisSekunde in range(ANZ_EREIGNISSEKUNDEN):
jetztSekunde += random.randint(1, pSekunde)
# jetztSekunde += 1
anzEreignisseInDerJetztSekunde = 0
log(str(jetztSekunde) + "__(" + str(nrEreignisSekunde) + "):-----------------------------------------------------------------")
if (nrEreignisSekunde % pKontrolle == 0) and (anzAlive > 0):
# if (pKontrolle >= random.randint(1, 30000)) and (anzAlive > 0):
log("====== Kontrolle! ======")
seinRest = Decimal('-999')
if (liste):
if (jetztSekunde == liste[1][0]):
break
seinRest = erweitereEvtListe(jetztSekunde)
log("seinRest = " + str(seinRest))
log("Konto[0] vor rein(seinRest):")
konto[0].debugAusgabeKontoAlles()
konto[0].anmelden(jetztSekunde)
konto[0].rein(seinRest)
log("Konto[0] nach anmelden und rein(seinRest):")
konto[0].debugAusgabeKontoAlles()
kontrollSum = g_LfdSummeInT + t_LfdSummeInT
for i in range(anzAlive):
tmpKontoStand = konto[i].debugGetKontoStand()
kontrollSum += tmpKontoStand
log(str(konto[i].debugTmpGetNR()) + " hat " + str(tmpKontoStand))
if (tmpKontoStand < Decimal('0')):
log("!!! " + str(i) + " hat " + str(tmpKontoStand))
log("NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!")
time.sleep(86400)
break
log("g_LfdSummeInT = " + str(g_LfdSummeInT))
log("t_LfdSummeInT = " + str(t_LfdSummeInT))
log("seinRest = " + str(seinRest))
log("kontrollSum = " + str(kontrollSum))
log("bank.ktoStand = " + str(bank.getKontoStand()))
berechneFehler(kontrollSum)
log("----")
for i in range(anzAlive):
konto[i].debugAusgabeKontoAlles()
time.sleep(30)
while anzEreignisseInDerJetztSekunde == 0:
#Zugang:
while 1:
if (anzAlive == 1) and (jetztSekunde == liste[1][0]): # ??? == liste[-1][0]
break
if ((MAX_ANZ_Alive - anzAlive) <= random.randint(0, pZugang)):
break
log("BEGINN ZUGANG!")
if (len(liste) == 0):
liste.append([0, Decimal('0'), Decimal('0'), Decimal('0'), 0])
liste.append([jetztSekunde, Decimal('0'), Decimal('0'), Decimal('0'), 254])
seinRest = Decimal('0')
else:
seinRest = erweitereEvtListe(jetztSekunde)
#konto[indexFeld[ktoNr]].anmelden(jetztSekunde)
#seinRest = erweitereEvtListe(jetztSekunde)
#konto[indexFeld[ktoNr]].rein(seinRest)
#konto[indexFeld[ktoNr]].findeOpfer(jetztSekunde)
#konto[indexFeld[ktoNr]].waehle('R')
#esWarEinEreignisInDerJetztSekunde = True
ktoNr = len(indexFeld)
log("Neue ktoNr = len(indexFeld) = " + str(ktoNr))
log("len(konto) = " + str(len(konto)) + ", anzAlive = " + str(anzAlive))
if anzAlive == len(konto):
konto.append(Konto(ktoNr))
log("konto.appended mit neuer ktoNr " + str(ktoNr))
else:
log("alte debugTmpGetNR von konto[" + str(anzAlive) + "] = " + str(konto[anzAlive].debugTmpGetNR()))
log("versuch konto[" + str(anzAlive) + "].resetKonto(" + str(ktoNr) + ")")
warte(4)
konto[anzAlive].resetKonto(ktoNr)
indexFeld.append(anzAlive)
anzAlive += 1
log("anzAlive ist jetzt: " + str(anzAlive))
# for i in range(anzAlive):
# konto[i].debugAusgabeKontoAlles()
lg(">> indexFeld: <<")
lg("len(indexFeld) = " + str(len(indexFeld)))
# for i in range(len(indexFeld)):
# lg(str(i) + ": " + str(indexFeld[i]))
lg(">><<")
lg("---")
lg("---")
konto[indexFeld[ktoNr]].anmelden(jetztSekunde)
betrag = random.randint(1, 1000)
konto[indexFeld[ktoNr]].rein(betrag)
bank.kontoStand_rein(betrag)
konto[indexFeld[ktoNr]].rein(seinRest)
konto[indexFeld[ktoNr]].findeOpfer(jetztSekunde)
konto[indexFeld[ktoNr]].waehle('R')
konto[indexFeld[ktoNr]].waehle('Z')
if (jetztSekunde == liste[1][0]):
liste[0][4] = getMedianZEIT()
anzEreignisseInDerJetztSekunde += 1
log("ZUGANG: anzAlive=" + str(anzAlive) + ", ktoNr=" + str(ktoNr) + ", bank.KtoStand=" + str(bank.getKontoStand()) + ", medRAUM=" + str(getMedianRAUM()) + ", medZEIT=" + str(getMedianZEIT()))
if (anzAlive > 0):
#SCHAUT_NACH:
while 1:
if (pSchautNach < random.randint(1, 100)):
break
r = random.randint(0, anzAlive - 1)
lg("r =" + str(r))
ktoNr=konto[r].debugTmpGetNR()
if (indexFeld[ktoNr] == -1):
log("error1")
time.sleep(86400)
anzEreignisseInDerJetztSekunde += 1
log("SCHAUT_NACH: ktoNr=" + str(ktoNr))
#WAEHLT_RAUM:
while 1:
if (pWaehltRaum < random.randint(1, 100)):
break
r = random.randint(0, anzAlive - 1)
lg("r =" + str(r))
ktoNr=konto[r].debugTmpGetNR()
if (indexFeld[ktoNr] == -1):
log("error2")
time.sleep(86400)
konto[indexFeld[ktoNr]].anmelden(jetztSekunde)
seinRest = erweitereEvtListe(jetztSekunde)
konto[indexFeld[ktoNr]].rein(seinRest)
konto[indexFeld[ktoNr]].findeOpfer(jetztSekunde)
konto[indexFeld[ktoNr]].waehle('R')
anzEreignisseInDerJetztSekunde += 1
log("WAEHLT_RAUM: ktoNr=" + str(ktoNr) + ", getSeineWahlRAUM=" + str(konto[indexFeld[ktoNr]].getSeineWahlRAUM()))
#WAEHLT_ZEIT:
while 1:
if (pWaehltZeit < random.randint(1, 100)):
break
r = random.randint(0, anzAlive - 1)
lg("r =" + str(r))
ktoNr=konto[r].debugTmpGetNR()
if (indexFeld[ktoNr] == -1):
log("error3")
time.sleep(86400)
konto[indexFeld[ktoNr]].anmelden(jetztSekunde)
seinRest = erweitereEvtListe(jetztSekunde)
konto[indexFeld[ktoNr]].rein(seinRest)
konto[indexFeld[ktoNr]].findeOpfer(jetztSekunde)
konto[indexFeld[ktoNr]].waehle('Z')
anzEreignisseInDerJetztSekunde += 1
log("WAEHLT_ZEIT: ktoNr=" + str(ktoNr) + ", getSeineWahlZEIT=" + str(konto[indexFeld[ktoNr]].getSeineWahlZEIT()))
#Raus:
while 1:
if (pRaus < random.randint(1, 100)):
break
r = random.randint(0, anzAlive - 1)
lg("r =" + str(r))
ktoNr=konto[r].debugTmpGetNR()
if (indexFeld[ktoNr] == -1):
log("error4")
time.sleep(86400)
konto[indexFeld[ktoNr]].anmelden(jetztSekunde)
seinRest = erweitereEvtListe(jetztSekunde)
konto[indexFeld[ktoNr]].rein(seinRest)
konto[indexFeld[ktoNr]].findeOpfer(jetztSekunde)
tmpKontoStand = konto[indexFeld[ktoNr]].getKontoStand()
verfuegbar=abs(int(tmpKontoStand))
if (verfuegbar > 10):
betrag = random.randint(1, verfuegbar)
konto[indexFeld[ktoNr]].raus(betrag, -1, -1, -1)
anzEreignisseInDerJetztSekunde += 1
log("RAUS: ktoNr=" + str(ktoNr) + ", betrag=" + str(betrag) + ", bank.KtoStand=" + str(bank.getKontoStand()))
#Rein:
while 1:
if (pRein < random.randint(1, 100)):
break
r = random.randint(0, anzAlive - 1)
lg("r =" + str(r))
ktoNr=konto[r].debugTmpGetNR()
if (indexFeld[ktoNr] == -1):
log("error5")
time.sleep(86400)
konto[indexFeld[ktoNr]].anmelden(jetztSekunde)
seinRest = erweitereEvtListe(jetztSekunde)
konto[indexFeld[ktoNr]].rein(seinRest)
konto[indexFeld[ktoNr]].findeOpfer(jetztSekunde)
betrag = random.randint(1, 1000)
konto[indexFeld[ktoNr]].rein(betrag)
bank.kontoStand_rein(betrag)
anzEreignisseInDerJetztSekunde += 1
log("REIN: ktoNr=" + str(ktoNr) + ", betrag=" + str(betrag) + ", bank.KtoStand=" + str(bank.getKontoStand()))
#Intern:
if (anzAlive > 1):
while 1:
if (pIntern < random.randint(1, 100)):
break
# log("Hier ist INTERN!!!!!!")
r = random.randint(0, anzAlive - 1)
lg("r =" + str(r))
quellKtoNr=konto[r].debugTmpGetNR()
if (indexFeld[quellKtoNr] == -1):
log("error6")
time.sleep(86400)
konto[indexFeld[quellKtoNr]].anmelden(jetztSekunde)
# log("jetzt kommt aufruf von seinRest = erweitereevtliste, jetztSekunde = " + str(jetztSekunde))
seinRest = erweitereEvtListe(jetztSekunde)
# log("jetzt kommt konto[quellKtoNr].rein(seinRest). Vorher noch info debugTmpGetSeinKontoStand(self):" + str(konto[quellKtoNr].debugTmpGetSeinKontoStand()))
konto[indexFeld[quellKtoNr]].rein(seinRest)
konto[indexFeld[quellKtoNr]].findeOpfer(jetztSekunde)
# log("zurückgekommen. seinRest = " + str(seinRest))
# log("zurückgekommen! seinRest = " + str(seinRest) + ", debugTmpGetSeinKontoStand = " + str(konto[quellKtoNr].debugTmpGetSeinKontoStand()))
# if not seinRest.is_zero():
# warte(8888)
if (anzAlive > 1):
zielKtoNr = quellKtoNr
while (zielKtoNr == quellKtoNr):
r = random.randint(0, anzAlive - 1)
lg("r =" + str(r))
zielKtoNr=konto[r].debugTmpGetNR()
if (indexFeld[zielKtoNr] == -1):
log("error7")
time.sleep(86400)
log("von " + str(quellKtoNr) + " zu " + str(zielKtoNr))
tmpKontoStand = konto[indexFeld[quellKtoNr]].getKontoStand()
verfuegbar=abs(int(tmpKontoStand / 2))
if (verfuegbar > 10):
betrag = random.randint(1, verfuegbar)
km=random.randint(1, pKM)
# log("km=" + str(km) + ", jetzt kommt g = konto[quellKtoNr].raus(betrag,...)")
g = konto[indexFeld[quellKtoNr]].raus(betrag, indexFeld[zielKtoNr], km, getMedianRAUM())
# log("Zurück, g=" + str(g))
if g != Decimal('-1'):
# log("g=" + str(g))
g_LfdSummeInT += g
anzEreignisseInDerJetztSekunde += 1
# log("INTERN: " + str(quellKtoNr) + " an " + str(zielKtoNr) + ", betrag=" + str(betrag) + ", km=" + str(km) + ", g=" + str(g) + ", g_LfdSummeInT=" + str(g_LfdSummeInT))
else:
# log("INTERN: " + str(quellKtoNr) + " an " + str(zielKtoNr) + ", betrag=" + str(betrag) + ", km=" + str(km) + ", ktoStandVonQuelle=" + str(konto[quellKtoNr].getKontoStand()))
# log("g ist nicht!!!!")
log("g=" + str(g)) # -1
time.sleep(86400)
else:
log("WARNUNG1: vorher waren es noch mehr als 1, jetzt sind es nur noch anzAlive=1, exit INTERN")
time.sleep(10)
break
log("E n d e____d e r_____E r e i g n i s S e k u n d e ! ! ! !")
log("anzEreignisseInDerJetztSekunde = " + str(anzEreignisseInDerJetztSekunde))
log("anzAlive ist jetzt: " + str(anzAlive))
warte(2)
lg(">> indexFeld: <<")
lg("len(indexFeld) = " + str(len(indexFeld)))
# for i in range(len(indexFeld)):
# lg(str(i) + ": " + str(indexFeld[i]))
lg("---------")
lg(">>>>>>>>>>> konto: <<<<<<<<<<<<<<")
# for i in range(anzAlive):
# konto[i].debugAusgabeKontoAlles()
lg("---------")
lg(">>>>>>>>>>> liste: <<<<<<<<<<<<<<")
lg("len(liste) = " + str(len(liste)))
# for i in range(len(liste)):
# lg(str(i) + ": " + str(liste[i][0]) + ", " + str(liste[i][1]) + ", " + str(liste[i][2]) + ", " + str(liste[i][3]) + ", " + str(liste[i][4]))
lg("---------")
warte(3)
log("=====================KONTROLLE!=======================\n")
seinRest = erweitereEvtListe(jetztSekunde)
log("seinRest = " + str(seinRest))
kontrollSum = Decimal('0')
for i in range(anzAlive):
tmpKontoStand = konto[i].getKontoStand()
kontrollSum += tmpKontoStand
log(str(i) + " hat " + str(tmpKontoStand))
if (tmpKontoStand < Decimal('0')):
log("NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!NEGATIV!")
break
kontrollSum += g_LfdSummeInT
log("INFO: g_LfdSummeInT = " + str(g_LfdSummeInT))
log("bank.getKontoStand() = " + str(bank.getKontoStand()) + ", kontrollSum = " + str(kontrollSum))
if (kontrollSum != bank.getKontoStand()):
log("FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!")
# break
else:
log("PAßTPAßT")
log("anzAlive =" + str(anzAlive))
warte(5)
for x in liste:
# if not x[1].is_zero():
print(x)
print(wahlenRAUM)
print(wahlenZEIT)
"""
kontrollSum = Decimal('0')
for i in range(anzAlive):
tmp=konto[i].getKontoStand()
print("Konto[" + str(i) + "] hat " + str(tmp) + " " + str(type(tmp)))
kontrollSum += konto[i].getKontoStand()
print("bank.KtoStand=" + str(bank.getKontoStand()) + " " + str(type(bank.getKontoStand())))
g = Decimal('0')
for x in liste:
g += x[1]
print("bbGesamtSumme von g über alle Sekunden = " + str(g))
kontrollSum += g
print("kontrollSum = " + str(kontrollSum))
print(wahlenRAUM)
print(wahlenZEIT)
if (kontrollSum == bank.getKontoStand()):
print("PAßT!")
else:
print("FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!FEHLER!")
warte(5)
print("anzAlive=" + str(anzAlive))
print(str(getsizeof(wahlenRAUM)))
print(str(getsizeof(wahlenZEIT)))
print(str(getsizeof(konto)))
print(str(getsizeof(bank)))
print(liste)
print(str(getsizeof(liste)))
"""
log("ENDE\n