def mergeSort(myList):
'''Sort list with ascending order using merging sort algorithm'''
from math import floor as flr
N = len(myList)
if N==1 :
return myList
else:
# Divide into two parts
subList_1 = myList[0:flr(N/2)]
subList_2 = myList[flr(N/2):N]
# Recursion to sort sublists
mergeSort(subList_1)
mergeSort(subList_2)
# Merge two sublists
pointer_1 = 0
pointer_2 = 0
max_max = max(subList_1[-1],subList_2[-1]) + 1.0
for i in range(N):
# set pointer for sublist 1
if pointer_1 < len(subList_1):
value_1 = subList_1[pointer_1]
else:
value_1 = max_max
# set pointer for sublist 2
if pointer_2 < len(subList_2):
value_2 = subList_2[pointer_2]
else:
value_2 = max_max
myList[i]=min(value_1,value_2)
# Move pointer based on sorted sublists
if value_1 < value_2:
pointer_1+=1
else:
pointer_2+=1
return myList
def day(day, month, year):
from math import floor as flr
x = year - 1 if month < 3 else year
c, y = divmod(x, 100)
d = day
m = (month - 2) % 12
return (d + flr(2.6 * m - 0.2) + y + flr(y / 4) + flr(c / 4) - 2 * c) % 7
def INIGENOME(Ngen,tesfrac,rk,C,Kh,tessij):
from math import floor as flr
import numpy as np
import newhost
go={}
seed=123456789
ix=0
for k in range(Ngen):
genex=[]
u=1.0*rk.uniform_pos()
if u<tesfrac:
genex.append("TE")
l=8000.0*rk.uniform_pos()
genex.append(flr(l))
genex.append(tessij)
else:
genex.append("EFFON")
l=500.0*rk.uniform_pos()
genex.append(flr(l))
adk=[]
##############################################
rk2=np.random.RandomState(seed-ix).binomial(Kh,C)
ix+=1
#print rk2
adkx=[]
adkx=newhost.NEWHOST(rk2,Kh,rk)
#print adkx
#raw_input()
##############################################
####
#kr=1+rk.uniform_int(tmax)
#mix=0
#while mix<=kr:
# zx=1+rk.uniform_int(Kh)
# if zx not in adk:
# adk.append(zx)
# mix+=1
##
adkx.sort()
Sk={}
for i in adkx:
Sk[i]=tessij
genex.append(adkx)
genex.append(Sk)
go[k]=genex
return go
def INIGENOME(Ngen, tesfrac, rk, C, Kh, tessij):
from math import floor as flr
import numpy as np
import newhost
go = {}
seed = 123456789
ix = 0
for k in range(Ngen):
genex = []
u = 1.0 * rk.uniform_pos()
if u < tesfrac:
genex.append("TE")
l = 8000.0 * rk.uniform_pos()
genex.append(flr(l))
genex.append(tessij)
else:
genex.append("EFFON")
l = 500.0 * rk.uniform_pos()
genex.append(flr(l))
adk = []
##############################################
rk2 = np.random.RandomState(seed - ix).binomial(Kh, C)
ix += 1
#print rk2
adkx = []
adkx = newhost.NEWHOST(rk2, Kh, rk)
#print adkx
#raw_input()
##############################################
####
#kr=1+rk.uniform_int(tmax)
#mix=0
#while mix<=kr:
# zx=1+rk.uniform_int(Kh)
# if zx not in adk:
# adk.append(zx)
# mix+=1
##
adkx.sort()
Sk = {}
for i in adkx:
Sk[i] = tessij
genex.append(adkx)
genex.append(Sk)
go[k] = genex
return go
def SweepTileSize():
file_path='%s\\tempkernel.h' % (location_to_batch)
defstr="#define %s %d\n"
#This is real dumb
while tilecount["Tr"]<len(tiles_to_test["Tr"]):
tilecount["Tc"]=0
while tilecount["Tc"]<len(tiles_to_test["Tc"]):
tilecount["Tm"]=0
while tilecount["Tm"]<len(tiles_to_test["Tm"]):
tilecount["Tn"]=0
while tilecount["Tn"]<len(tiles_to_test["Tn"]):
with open(file_path, "w+") as hfile:
for key in tiles_to_test.keys():
hfile.write(defstr % (key, tiles_to_test[key][tilecount[key]]))
subprocess.call("vivado_hls -f %s" % (tclselect), shell=True)
tilestr=CreateTileSizeString()
parsed=GrabJSONResults()
outputs.write("%s\n%s\n%s %s\n"%(tilestr,str(args), parsed[0],parsed[2][1]))
outputs.write(",".join(str(s) for s in parsed[3]))
outputs.write("\n")
outputs.write(",".join(str(s) for s in parsed[1]))
outputs.write("\n")
# Just assume DSP is the bottleneck
actual_utils=[0,0,0,0]
actual_utils[0]=100*(parsed[1][0]/432)
actual_utils[1]=100*(parsed[1][1]/360)
actual_utils[2]=100*(parsed[1][2]/141120)
actual_utils[3]=100*(parsed[1][3]/70560)
max_util=max(actual_utils)
resindex=actual_utils.index(max_util)
multiplier=flr(80/max_util)
if( multiplier==0):
multiplier=1
l_f=50
for key in tiles_to_test.keys():
l_f=l_f*tiles_to_test[key][tilecount[key]]
factor=(l_f/parsed[0])*multiplier
util=""
for useage in parsed[1]:
if (useage==0):
util+="0,"
else:
util+=str(factor/useage)+","
outputs.write("%s\n%s (x%d)\nLimited by: %s\nClock: %d\n\n" % (util, (factor/(.000000001*current_clock))/1000000000,multiplier,resourceNames[resindex],current_clock))
outputs.flush()
#UpdateSolutionName("Tile")
tilecount["Tn"]=tilecount["Tn"]+1
tilecount["Tm"]=tilecount["Tm"]+1
tilecount["Tc"]=tilecount["Tc"]+1
tilecount["Tr"]=tilecount["Tr"]+1
def step(self,seconds): """Returns true if calling step with the given value had any perceptible effect. """ if seconds == 0: return False # Save the old values last_secs = self.total_seconds last_beat = flr(self.bps()*self.total_seconds) # Set the new values self.seconds_in_step = seconds self.total_seconds += seconds this_beat = flr(self.bps()*self.total_seconds) # If we went through a beat if last_beat < this_beat: self.beats_in_step = this_beat - last_beat self.total_beats = this_beat else: self.beats_in_step = 0 # No beats occurred this time return True
def NUTEGNOME(TBL,NRCT,Gk,H,hll,hllb,rk,Kh,tesij):
#TBL yes/no "number"
#NRCT transformation to be applied
#Gk
#H
#hll
#hllb
#rk random number generation handle
from math import floor as flr
import copy as lcp
Gnmod={} #New genome
#print("GEN: %d\n"%ng)
mu=0
for i in TBL.keys():
nugen=[]
if TBL[i]==0:
for jk in Gk[i]:
nugen.append(jk)
Gnmod[mu]=nugen
mu+=1
if TBL[i]==1:
rn=NRCT[i]
###########################
if rn==0:
sigl=0.01 ####this is a std for the scores move s'=s+ds !!!!
skx=Gk[i][3]
sijn={}
for sj in skx.keys():
if skx[sj]==0.0:
sijn[sj]=0.0
if skx[sj]!=0.0:
dsj=rk.gaussian(sigl)
if (skx[sj]+dsj)>0:
sijn[sj]=skx[sj]+dsj
if (skx[sj]+dsj)<=0:
sijn[sj]=0.00001
nugen.append(Gk[i][0])
#nugen.append(Gk[ng][1])
ql=rk.uniform_pos()
dlen=10.0
if ql<=0.5:
qq=rk.uniform_pos()
nlen=Gk[i][1]+dlen*qq
if ql>0.5:
qq=rk.uniform_pos()
nlen=Gk[i][1]-dlen*qq
if nlen<0.0:
nlen=0.0
nugen.append(flr(nlen))
nugen.append(Gk[i][2])
nugen.append(sijn)
lij=nlen
import calcwijtes
wijm=calcwijtes.CALCWIJTES(sijn,H,hll,lij,hllb)
nugen.append(wijm)
Gnmod[mu]=nugen
mu+=1
##########################
if rn==1:
nugen.append(Gk[i][0])
nugen.append(Gk[i][1])
nlk=len(Gk[i][2])
fx=0
nlklst=[]
nlklst=lcp.deepcopy(Gk[i][2])
while fx==0:
nk=1+rk.uniform_int(Kh)
if (nk not in Gk[i][2]) and (nk<=Kh):
nlklst.append(nk)
fx=1
nlklst.sort()
snu={}
wnu={}
for zi in nlklst:
if zi in Gk[i][3].keys():
snu[zi]=Gk[i][3][zi]
if zi not in Gk[i][3].keys():
snu[zi]=0.5
import calcwijtes
wnu=calcwijtes.CALCWIJTES(snu,H,hll,nugen[1],hllb)
nugen.append(nlklst)
nugen.append(snu)
nugen.append(wnu)
Gnmod[mu]=nugen
mu+=1 #raw_input()
##################################################################
if rn==2:
nugen.append(Gk[i][0])
nugen.append(Gk[i][1])
nlklst=lcp.deepcopy(Gk[i][2])
nlk=len(Gk[i][2])
fx=0
while fx==0:
jo=rk.uniform_int(nlk)
nk=1+rk.uniform_int(Kh)
if (nk not in Gk[i][2]) and (nk<=Kh):
nlklst[jo]=nk
fx=1
nlklst.sort()
snu={}
wnu={}
for zi in nlklst:
if zi in Gk[i][3].keys():
snu[zi]=Gk[i][3][zi]
if zi not in Gk[i][3].keys():
snu[zi]=0.5
import calcwijtes
wnu=calcwijtes.CALCWIJTES(snu,H,hll,nugen[1],hllb)
nugen.append(nlklst)
nugen.append(snu)
nugen.append(wnu)
Gnmod[mu]=nugen
mu+=1
##################################################################
if rn==3:
nugen.append(Gk[i][0])
nugen.append(Gk[i][1])
nlklst=[]
nlklst=lcp.deepcopy(Gk[i][2])
nlk=len(Gk[i][2])
if nlk>1:
jo=rk.uniform_int(nlk)
nj=nlklst[jo]
nlklst.remove(nj)
nusij={}
for ki in nlklst:
nusij[ki]=Gk[i][3][ki]
wnu={}
import calcwijtes
wnu=calcwijtes.CALCWIJTES(nusij,H,hll,nugen[1],hllb)
nugen.append(nlklst)
nugen.append(nusij)
nugen.append(wnu)
Gnmod[mu]=nugen
mu+=1
if nlk==1:
nugen.append("TE")
nugen.append(Gk[i][1])
nugen.append(tesij)
import calcwijtes
wnu=calcwijtes.CALCWIJTES(tesij,H,hll,nugen[1],hllb)
nugen.append(wnu)
Gnmod[mu]=nugen
mu+=1
##################################################################
if rn==4:
Gnmod[mu]=Gk[i]
Gnmod[mu+1]=Gk[i]
mu=mu+2
##################################################################
if rn==5:
x=1
#Do nothing!
##################################################################
if rn==6:
Gnmod[mu]=Gk[i]
Gnmod[mu+1]=Gk[i]
mu=mu+2
##################################################################
if rn==7:
x=0
#Do nothing
##################################################################
if rn==8: #HGT-NOT YET INCLUDED
lte=8000.0*rk.uniform_pos()
nugen.append("TE")
nugen.append(flr(lte))
nugen.append(tesij)
import calcwijtes
wnu=calcwijtes.CALCWIJTES(tesij,H,hll,nugen[1],hllb)
nugen.append(wnu)
Gnmod[mu]=nugen
mu+=1
return Gnmod
def GENETRANSTE(ng,nt,Gk,H,hll,hllb,rk,Kh,tesij):
#ng gene "number"
#nt transformation number
#Gk
#H
#hll
#hllb
#rk random number generation handle
from math import floor as flr
import copy as lcp
Gnmod={} #New genome
#print("GEN: %d\n"%ng)
if nt==0: #A
for i in Gk.keys():
if((i<ng) or (i>ng)):
Gnmod[i]=Gk[i]
if i==ng:
sigl=0.01 ####this is a std for the scores move s'=s+ds !!!!
skx=Gk[ng][3]
sijn={}
for sj in skx.keys():
if skx[sj]==0.0:
sijn[sj]=0.0
if skx[sj]!=0.0:
dsj=rk.gaussian(sigl)
if (skx[sj]+dsj)>0:
sijn[sj]=skx[sj]+dsj
if (skx[sj]+dsj)<=0:
sijn[sj]=0.00001
nugen=[]
nugen.append(Gk[ng][0])
#nugen.append(Gk[ng][1])
ql=rk.uniform_pos()
dlen=10.0
if ql<=0.5:
qq=rk.uniform_pos()
nlen=Gk[ng][1]+dlen*qq
if ql>0.5:
qq=rk.uniform_pos()
nlen=Gk[ng][1]-dlen*qq
if nlen<0.0:
nlen=0.0
nugen.append(flr(nlen))
nugen.append(Gk[ng][2])
nugen.append(sijn)
lij=nlen
import calcwijtes
wijm=calcwijtes.CALCWIJTES(sijn,H,hll,lij,hllb)
nugen.append(wijm)
Gnmod[ng]=nugen
#return Gnmod
if nt==1: #B
for i in Gk.keys():
if (i!=ng):
Gnmod[i]=Gk[i]
if i==ng:
nugen=[]
nugen.append(Gk[i][0])
nugen.append(Gk[i][1])
nlk=len(Gk[i][2])
fx=0
nlklst=[]
nlklst=lcp.deepcopy(Gk[i][2])
#print Gk[i][2]
#raw_input()
while fx==0:
#jo=rk.uniform_int(nlk)
#nk=nlklst[jo]+1
nk=1+rk.uniform_int(Kh)
if (nk not in Gk[i][2]) and (nk<=Kh):
nlklst.append(nk)
fx=1
nlklst.sort()
print nlklst
snu={}
wnu={}
for zi in nlklst:
if zi in Gk[i][3].keys():
snu[zi]=Gk[i][3][zi]
if zi not in Gk[i][3].keys():
snu[zi]=0.5
import calcwijtes
wnu=calcwijtes.CALCWIJTES(snu,H,hll,nugen[1],hllb)
nugen.append(nlklst)
nugen.append(snu)
nugen.append(wnu)
Gnmod[ng]=nugen
#raw_input()
if nt==2: #C
for i in Gk.keys():
if (i!=ng):
Gnmod[i]=Gk[i]
if i==ng:
nugen=[]
nugen.append(Gk[i][0])
nugen.append(Gk[i][1])
nlklst=[]
nlklst=lcp.deepcopy(Gk[i][2])
nlk=len(Gk[i][2])
#print Gk[i][2]
#print nlk
#raw_input()
if nlk>1:
jo=rk.uniform_int(nlk)
nj=nlklst[jo]
nlklst.remove(nj)
nusij={}
for ki in nlklst:
nusij[ki]=Gk[i][3][ki]
wnu={}
import calcwijtes
wnu=calcwijtes.CALCWIJTES(nusij,H,hll,nugen[1],hllb)
nugen.append(nlklst)
nugen.append(nusij)
nugen.append(wnu)
Gnmod[ng]=nugen
if nlk==1:
#print("HOLA")
nugen=[]
nugen.append("TE")
nugen.append(Gk[i][1])
nugen.append(tesij)
import calcwijtes
wnu=calcwijtes.CALCWIJTES(tesij,H,hll,nugen[1],hllb)
nugen.append(wnu)
Gnmod[ng]=nugen
if nt==3: #D
for i in Gk.keys():
if (i!=ng):
Gnmod[i]=Gk[i]
if i==ng:
nugen=[]
nugen.append(Gk[i][0])
nugen.append(Gk[i][1])
nlklst=lcp.deepcopy(Gk[i][2])
nlk=len(Gk[i][2])
fx=0
while fx==0:
jo=rk.uniform_int(nlk)
#nk=nlklst[jo]+1
nk=1+rk.uniform_int(Kh)
if (nk not in Gk[i][2]) and (nk<=Kh):
nlklst[jo]=nk
#nlklst.append(nk)
fx=1
nlklst.sort()
snu={}
wnu={}
for zi in nlklst:
if zi in Gk[i][3].keys():
snu[zi]=Gk[i][3][zi]
if zi not in Gk[i][3].keys():
snu[zi]=0.5
import calcwijtes
wnu=calcwijtes.CALCWIJTES(snu,H,hll,nugen[1],hllb)
nugen.append(nlklst)
nugen.append(snu)
nugen.append(wnu)
Gnmod[ng]=nugen
if nt==4: #E
for i in Gk.keys():
if i<ng:
Gnmod[i]=Gk[i]
if i==ng:
Gnmod[ng]=Gk[ng]
Gnmod[ng+1]=Gk[ng]
if i>ng:
Gnmod[i+2]=Gk[i]
if nt==5: #F
mu=0
for i in Gk.keys():
if i<ng:
Gnmod[i]=Gk[i]
if i>ng:
Gnmod[i-1]=Gk[i]
if nt==6: #G
for i in Gk.keys():
if i<ng:
Gnmod[i]=Gk[i]
if i==ng:
Gnmod[ng]=Gk[ng]
Gnmod[ng+1]=Gk[ng]
if i>ng:
Gnmod[i+2]=Gk[i]
if nt==7: #H
for i in Gk.keys():
Gnmod[i]=Gk[i]
ngn=len(Gk.keys())
#print ngn, max(Gk.keys())
nugen=[]
lte=8000.0*rk.uniform_pos()
nugen.append("TE")
nugen.append(flr(lte))
nugen.append(tesij)
import calcwijtes
wnu=calcwijtes.CALCWIJTES(tesij,H,hll,nugen[1],hllb)
nugen.append(wnu)
Gnmod[ngn]=nugen
return Gnmod
def NUTEGNOME(TBL, NRCT, Gk, H, hll, hllb, rk, Kh, tesij):
#TBL yes/no "number"
#NRCT transformation to be applied
#Gk
#H
#hll
#hllb
#rk random number generation handle
from math import floor as flr
import copy as lcp
Gnmod = {} #New genome
#print("GEN: %d\n"%ng)
mu = 0
for i in TBL.keys():
nugen = []
if TBL[i] == 0:
for jk in Gk[i]:
nugen.append(jk)
Gnmod[mu] = nugen
mu += 1
if TBL[i] == 1:
rn = NRCT[i]
###########################
if rn == 0:
sigl = 0.01 ####this is a std for the scores move s'=s+ds !!!!
skx = Gk[i][3]
sijn = {}
for sj in skx.keys():
if skx[sj] == 0.0:
sijn[sj] = 0.0
if skx[sj] != 0.0:
dsj = rk.gaussian(sigl)
if (skx[sj] + dsj) > 0:
sijn[sj] = skx[sj] + dsj
if (skx[sj] + dsj) <= 0:
sijn[sj] = 0.00001
nugen.append(Gk[i][0])
#nugen.append(Gk[ng][1])
ql = rk.uniform_pos()
dlen = 10.0
if ql <= 0.5:
qq = rk.uniform_pos()
nlen = Gk[i][1] + dlen * qq
if ql > 0.5:
qq = rk.uniform_pos()
nlen = Gk[i][1] - dlen * qq
if nlen < 0.0:
nlen = 0.0
nugen.append(flr(nlen))
nugen.append(Gk[i][2])
nugen.append(sijn)
lij = nlen
import calcwijtes
wijm = calcwijtes.CALCWIJTES(sijn, H, hll, lij, hllb)
nugen.append(wijm)
Gnmod[mu] = nugen
mu += 1
##########################
if rn == 1:
nugen.append(Gk[i][0])
nugen.append(Gk[i][1])
nlk = len(Gk[i][2])
fx = 0
nlklst = []
nlklst = lcp.deepcopy(Gk[i][2])
while fx == 0:
nk = 1 + rk.uniform_int(Kh)
if (nk not in Gk[i][2]) and (nk <= Kh):
nlklst.append(nk)
fx = 1
nlklst.sort()
snu = {}
wnu = {}
for zi in nlklst:
if zi in Gk[i][3].keys():
snu[zi] = Gk[i][3][zi]
if zi not in Gk[i][3].keys():
snu[zi] = 0.5
import calcwijtes
wnu = calcwijtes.CALCWIJTES(snu, H, hll, nugen[1], hllb)
nugen.append(nlklst)
nugen.append(snu)
nugen.append(wnu)
Gnmod[mu] = nugen
mu += 1 #raw_input()
##################################################################
if rn == 2:
nugen.append(Gk[i][0])
nugen.append(Gk[i][1])
nlklst = lcp.deepcopy(Gk[i][2])
nlk = len(Gk[i][2])
fx = 0
while fx == 0:
jo = rk.uniform_int(nlk)
nk = 1 + rk.uniform_int(Kh)
if (nk not in Gk[i][2]) and (nk <= Kh):
nlklst[jo] = nk
fx = 1
nlklst.sort()
snu = {}
wnu = {}
for zi in nlklst:
if zi in Gk[i][3].keys():
snu[zi] = Gk[i][3][zi]
if zi not in Gk[i][3].keys():
snu[zi] = 0.5
import calcwijtes
wnu = calcwijtes.CALCWIJTES(snu, H, hll, nugen[1], hllb)
nugen.append(nlklst)
nugen.append(snu)
nugen.append(wnu)
Gnmod[mu] = nugen
mu += 1
##################################################################
if rn == 3:
nugen.append(Gk[i][0])
nugen.append(Gk[i][1])
nlklst = []
nlklst = lcp.deepcopy(Gk[i][2])
nlk = len(Gk[i][2])
if nlk > 1:
jo = rk.uniform_int(nlk)
nj = nlklst[jo]
nlklst.remove(nj)
nusij = {}
for ki in nlklst:
nusij[ki] = Gk[i][3][ki]
wnu = {}
import calcwijtes
wnu = calcwijtes.CALCWIJTES(nusij, H, hll, nugen[1], hllb)
nugen.append(nlklst)
nugen.append(nusij)
nugen.append(wnu)
Gnmod[mu] = nugen
mu += 1
if nlk == 1:
nugen.append("TE")
nugen.append(Gk[i][1])
nugen.append(tesij)
import calcwijtes
wnu = calcwijtes.CALCWIJTES(tesij, H, hll, nugen[1], hllb)
nugen.append(wnu)
Gnmod[mu] = nugen
mu += 1
##################################################################
if rn == 4:
Gnmod[mu] = Gk[i]
Gnmod[mu + 1] = Gk[i]
mu = mu + 2
##################################################################
if rn == 5:
x = 1
#Do nothing!
##################################################################
if rn == 6:
Gnmod[mu] = Gk[i]
Gnmod[mu + 1] = Gk[i]
mu = mu + 2
##################################################################
if rn == 7:
x = 0
#Do nothing
##################################################################
if rn == 8: #HGT-NOT YET INCLUDED
lte = 8000.0 * rk.uniform_pos()
nugen.append("TE")
nugen.append(flr(lte))
nugen.append(tesij)
import calcwijtes
wnu = calcwijtes.CALCWIJTES(tesij, H, hll, nugen[1], hllb)
nugen.append(wnu)
Gnmod[mu] = nugen
mu += 1
return Gnmod