def AdvanceTime(TimeList,ObservableList):
PTrans, PAnnih, PSpawn, Norm, TranslateableLinks, AnnihilateableLinks, SpawnableLinks = Probabilities()
r = random.rand()
DeltaTau = (-1./Norm)*log(r)
if (r < PTrans):
RandLink = random.randint(len(TranslateableLinks))
LinkCoords = TranslateableLinks[RandLink]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
MyLattice.TranslateExcitation(MyLattice.ReturnExcitationIndex(LinkCoords[0]%MyLattice.Dimension,LinkCoords[1]%MyLattice.Dimension), XDisplacement, YDisplacement)
if (r >= PTrans and r < PTrans + PAnnih):
RandLink = random.randint(len(AnnihilateableLinks))
LinkCoords = AnnihilateableLinks[RandLink]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
#if(LinkCoords[2]==MyLattice.Dimension or LinkCoords[0] == MyLattice.Dimension - 1):
#print str(LinkCoords[2]) + "\t" + str(LinkCoords[0])
#print str(LinkCoords[3]) + "\t" + str(LinkCoords[1])
MyLattice.AnnihilateExcitation(LinkCoords[0]%MyLattice.Dimension,LinkCoords[1]%MyLattice.Dimension)
MyLattice.AnnihilateExcitation(LinkCoords[2]%MyLattice.Dimension,LinkCoords[3]%MyLattice.Dimension)
MyLattice.CheckSector(LinkCoords[0]%MyLattice.Dimension,LinkCoords[1]%MyLattice.Dimension, XDisplacement, YDisplacement)
if (r >= PTrans + PAnnih):
RandLink = random.randint(len(SpawnableLinks))
LinkCoords = SpawnableLinks[RandLink]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
#if(LinkCoords[2]==MyLattice.Dimension or LinkCoords[0] == MyLattice.Dimension - 1):
RandLink = random.randint(len(AnnihilateableLinks))
LinkCoords = AnnihilateableLinks[RandLink]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
#if(LinkCoords[2]==MyLattice.Dimension or LinkCoords[0] == MyLattice.Dimension - 1):
#print str(LinkCoords[2]) + "\t" + str(LinkCoords[0])
#print str(LinkCoords[3]) + "\t" + str(LinkCoords[1])
MyLattice.AnnihilateExcitation(LinkCoords[0]%MyLattice.Dimension,LinkCoords[1]%MyLattice.Dimension)
MyLattice.AnnihilateExcitation(LinkCoords[2]%MyLattice.Dimension,LinkCoords[3]%MyLattice.Dimension)
MyLattice.CheckSector(LinkCoords[0]%MyLattice.Dimension,LinkCoords[1]%MyLattice.Dimension, XDisplacement, YDisplacement)
if (r >= PTrans + PAnnih):
RandLink = random.randint(len(SpawnableLinks))
LinkCoords = SpawnableLinks[RandLink]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
#if(LinkCoords[2]==MyLattice.Dimension or LinkCoords[0] == MyLattice.Dimension - 1):
#print str(LinkCoords[2]) + "\t" + str(LinkCoords[0])
#print str(LinkCoords[3]) + "\t" + str(LinkCoords[1])
MyLattice.SpawnExcitation(LinkCoords[0]%MyLattice.Dimension,LinkCoords[1]%MyLattice.Dimension)
MyLattice.SpawnExcitation(LinkCoords[2]%MyLattice.Dimension,LinkCoords[3]%MyLattice.Dimension)
MyLattice.CheckSector(LinkCoords[0]%MyLattice.Dimension,LinkCoords[1]%MyLattice.Dimension, XDisplacement, YDisplacement)
return DeltaTau, MyLattice.Sector
def gen_bounds():
'''
Get bounds for master gen
'''
x_l = random.randint(10, 90)
x_h = random.randint(x_l + 30, x_l + 50)
y_l = random.randint(10, 90)
y_h = random.randint(y_l + 30, y_l + 50)
return x_l, x_h, y_l, y_h
def AdvanceTime(TimeList,ObservableList):
TranslateableLinks = MyLattice.TranslateableList
AnnihilateableLinks = MyLattice.AnnihilateableList
Norm = len(TranslateableLinks)*TranslateRate + len(AnnihilateableLinks)*AnnihilationRate + \
((2*(MyLattice.Dimension)**2) - len(AnnihilateableLinks) - len(TranslateableLinks))*SpawnRate
PTrans = len(TranslateableLinks)*TranslateRate/Norm
PAnnih = len(AnnihilateableLinks)*AnnihilationRate/Norm
PSpawn = ((2*(MyLattice.Dimension)**2) - len(AnnihilateableLinks) - len(TranslateableLinks))*SpawnRate/Norm
r = random.rand()
DeltaTau = (-1./Norm)*log(r)
if (r < PTrans):
RandLink = random.randint(len(TranslateableLinks))
LinkCoords = [TranslateableLinks[RandLink].x1,TranslateableLinks[RandLink].y1,TranslateableLinks[RandLink].x2,TranslateableLinks[RandLink].y2]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
MyLattice.TranslateExcitations(MyLattice.ReturnExcitationIndex(LinkCoords[0],LinkCoords[1]), XDisplacement, YDisplacement)
if (r >= PTrans and r < PTrans + PAnnih):
RandLink = random.randint(len(AnnihilateableLinks))
LinkCoords = [AnnihilateableLinks[RandLink].x1,AnnihilateableLinks[RandLink].y1,AnnihilateableLinks[RandLink].x2,AnnihilateableLinks[RandLink].y2]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
MyLattice.AnnihilateExcitations(LinkCoords[0],LinkCoords[1],LinkCoords[2],LinkCoords[3])
if (r >= PTrans + PAnnih):
Occupancies = MyLattice.ReturnOccupancies()
FoundCreatableLink = False
RandX = 0
RandY = 0
RandDir = 0
while FoundCreatableLink == False:
RandX = random.randint(MyLattice.Dimension)
RandY = random.randint(MyLattice.Dimension)
RandDir = random.randint(2)
if(Occupancies[RandX,RandY]==0 and \
Occupancies[(RandX + RandDir)%MyLattice.Dimension,(RandY + (1-RandDir))%MyLattice.Dimension] == 0):
FoundCreatableLink = True
LinkCoords = [RandX,RandY,RandX + RandDir, RandY + (1-RandDir)]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
MyLattice.CreateExcitations(LinkCoords[0],LinkCoords[1],LinkCoords[2],LinkCoords[3])
return DeltaTau, MyLattice.Sector, len(MyLattice.ExcitationList)
def TrialMove(InitLat):
InitialLattice = deepcopy(InitLat)
InitialEnergy = 2*Je*len(InitialLattice.ExcitationList)
i = 0
ListLength = len(InitialLattice.ExcitationList)
while i < ListLength:
RandomDirection = random.randint(0,5)
if InitialLattice.MoveExcitation(i,RandomDirection) == False:
#if there was a collision, and this collision killed all the excitations
#exit the loop
if len(InitialLattice.ExcitationList) == 0:
i = 1
#else, you've just popped the excitation under consideration, so now i is
#point to something else
else:
i = i
#if you didn't collide with anything, continue iterating over excitations
else:
i += 1
#The number of excitations may have gone down, so we need to keep track of that:
ListLength = len(InitialLattice.ExcitationList)
for x in xrange(InitialLattice.Dimension):
for y in xrange(InitialLattice.Dimension):
SpawnPairUpDown = random.randint(0,2)
SpawnPairLeftRight = random.randint(0,2)
if SpawnPairUpDown == 1:
InitialLattice.SpawnExcitation(x,y)
InitialLattice.SpawnExcitation(x,(y+1)%InitialLattice.Dimension)
InitialLattice.CheckSector(x,y,0,1)
if SpawnPairLeftRight == 1:
InitialLattice.SpawnExcitation(x,y)
InitialLattice.SpawnExcitation((x+1)%InitialLattice.Dimension,y)
InitialLattice.CheckSector(x,y,1,0)
FinalEnergy = 2*Je*len(InitialLattice.ExcitationList)
if(FinalEnergy <= InitialEnergy):
return InitialLattice
else:
r = random.rand()
print(exp(-(FinalEnergy-InitialEnergy)/Temperature))
if r < exp(-(FinalEnergy-InitialEnergy)/Temperature):
return InitialLattice
else:
return InitLat
def generate_batch(batch_size, num_skips, skip_window):
"""
生成训练样本
args:
batch_size: 每一批训练样本的数量
num_skips: 每个单词生成多少个样本，不能大于skip_window的两倍，batch_size必须是num_skip的整数倍，确保每个batch包含一个词汇对应的所有样本
skip_window: 单词最远可以联系的距离
"""
global data_index
assert batch_size % num_skips == 0
assert num_skips <= 2 * skip_window
batch = np.ndarray(shape=(batch_size), dtype=np.int32)
labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)
span = 2 * skip_window + 1
buffer = collections.deque(maxlen=span) #deque使用append添加变量时，只保留最后插入的那个变量
for _ in range(span):
buffer.append(data[data_index])
data_index = (data_index + 1) % len(data)
for i in range(batch_size // num_skips):
target = skip_window
target_to_aviod = [skip_window]
for j in range(num_skips):
while target in target_to_aviod:
target = random.randint(0, span - 1)
target_to_aviod.append(target)
batch[i * num_skips + j] = buffer[skip_window]
labels[i * num_skips + j, 0] = buffer[target]
buffer.append(data[data_index])
data_index = (data_index + 1) % len(data)
return batch, labels
def forceAngleOutward(self,n_pts,runs=100):
p = self.disperseRand(n_pts)
f,eOld = self.forceVectors(p)
count = 0
number = [len(p)*runs]
randIndxs = random.randint(0,len(p),[len(p)*runs])
for r in range(0,runs):
for i in range(0,len(p)):
#for q in range(0,len(p)):
#print q*(r+1)
# i = randIndxs[q*(r+1)]
#print i
magnitude = self.distance(f[i])
dirForce = [f[i][0]/magnitude,f[i][1]/magnitude,f[i][2]/magnitude]
angle = arccos((p[i][0]*dirForce[0])+(p[i][1]*dirForce[1])+(p[i][2]*dirForce[2]))
if angle>0.01:
p[i] = dirForce
count +=1
self.window.update(p)
self.window.updateGL()
self.window.show()
self.window.raise_()
f,e = self.forceVectors(p)
#print eOld,count
print angle, e
self.window.lines=[]
self.drawEdges(p)
print count
def MEStep(alpha,
rfac,
Aw,
temp,
Ker,
sxt,
Gt,
model,
f0,
Asteps,
itt,
reset=True):
if (reset):
temp = 0.001
rfac = 0.05
print 'Restarting maxent with rfac=', rfac, 'alpha=', alpha
iseed = random.randint(0, maxint)
me.maxent(Aw, rfac, alpha, temp, Ker, sxt, Gt, model, f0, Asteps,
iseed)
S = me.entropy(Aw, model, f0)
Trc = me.lambdac(alpha, Aw, omega, dlda)
ratio = -2 * S * alpha / Trc
print 'Finished maxent with alpha=', alpha, '-2*alpha*S=', -2 * alpha * S, 'Trace=', Trc
print ' ratio=', ratio
savetxt('dos_' + str(itt), vstack((omega, Aw)).transpose())
return ratio
def save_data(image, x, y, type_id=0, samples=11):
global sample_count
img_data = extract_data(image, x, y)
writer.write(img_data)
label_writer.write(numpy.array(type_id, dtype=numpy.uint8))
sample_count += 1
for index in range(1, samples):
img_data = extract_data(image, x, y)
for index_point in range(0, 20):
point = random.randint(0, img_data.size)
min_val = max(img_data[point] - 20, 0)
max_val = min(img_data[point] + 20, 255)
img_data[point] = random.randint(min_val, max_val)
writer.write(img_data)
label_writer.write(numpy.array(type_id, dtype=numpy.uint8))
sample_count += 1
def newEpisode(self):
if self.learning:
params = ravel(self.explorationlayer.module.params)
target = ravel(sum(self.history.getSequence(self.history.getNumSequences()-1)[2]) / 500)
if target != 0.0:
self.gp.addSample(params, target)
if len(self.gp.trainx) > 20:
self.gp.trainx = self.gp.trainx[-20:, :]
self.gp.trainy = self.gp.trainy[-20:]
self.gp.noise = self.gp.noise[-20:]
self.gp._calculate()
# get new parameters where mean was highest
max_cov = diag(self.gp.pred_cov).max()
indices = where(diag(self.gp.pred_cov) == max_cov)[0]
pick = indices[random.randint(len(indices))]
new_param = self.gp.testx[pick]
# check if that one exists already in gp training set
if len(where(self.gp.trainx == new_param)[0]) > 0:
# add some normal noise to it
new_param += random.normal(0, 1, len(new_param))
self.explorationlayer.module._setParameters(new_param)
else:
self.explorationlayer.drawRandomWeights()
# don't call StateDependentAgent.newEpisode() because it randomizes the params
LearningAgent.newEpisode(self)
def _row(self, sim=None, slide_id=1):
"""
Produce a simburst table row for this waveform.
Parameters
----------
sim : table
The table which the row should be made for.
If this is left empty the table is assumed to be a
sim_burst_table.
slide_id : int
The timeslide id. Defaults to 1.
"""
if not sim: sim = self.sim
row = sim.RowType()
for a in lsctables.SimBurstTable.validcolumns.keys():
setattr(row, a, self.params[a])
row.waveform = self.waveform
# Fill in the time
row.set_time_geocent(GPS(float(self.time)))
# Get the sky locations
row.ra, row.dec, row.psi = self.sky_dist()
row.simulation_id = sim.get_next_id()
row.waveform_number = random.randint(0,int(2**32)-1)
### !! This needs to be updated.
row.process_id = "process:process_id:0" #procrow.process_id
row.time_slide_id = ilwd.ilwdchar("time_slide:time_slide_id:%d" % slide_id)
return row
def find_conservative_MPPS(self, n_MPP=2, n_MPP_tries=100, err_g_max=0.2):
"""
Search for MPPs
Input:
n_MPP - try to find this number of MPP's
n_MPP_tries - max number of tries in search for new MPP
err_g_max - convergence criterion in MPP search
"""
k = 0
U_MPP = []
for i in range(n_MPP_tries):
u0 = random.normal(size=(self.X_dist.dim))
self.e = self.E_conservative[random.randint(
len(self.E_conservative))]
conv, u_MPP = self.MPP_search(u0=u0,
N_max=100,
err_g_max=err_g_max)
if conv:
k += 1
U_MPP.append(u_MPP)
if k >= n_MPP: break
return np.array(U_MPP)
def perturbation(self):
# generates a uniform difference vector with the given epsilon
deltas = (random.randint(0, 2, self.numParameters) * 2 - 1) * self.epsilon
# reduce epsilon by factor gamma
# as another simplification we let the exploration just decay with gamma.
# Is similar to the decreasing exploration in SPSA but simpler.
self.epsilon *= self.gamma
return deltas
def perturbation(self):
# generates a uniform difference vector with the given epsilon
deltas = (random.randint(0, 2, self.numParameters) * 2 - 1) * self.epsilon
# reduce epsilon by factor gamma
# as another simplification we let the exploration just decay with gamma.
# Is similar to the decreasing exploration in SPSA but simpler.
self.epsilon *= self.gamma
return deltas
def gen_master(x_l, x_h, y_l, y_h):
'''
Decide exponential or uniform
'''
if random.randint(1, 2, 1) > 1:
return gen_exponential(random.uniform(x_l, x_h),
random.uniform(y_l, y_h))
else:
return gen_uniform(x_l, x_h, y_l, y_h)
def sample(self, N):
"""
Generate N samples
"""
# Standard normal samples
U = random.normal(size=(N, self.dim))
# Sample random means with equal probability
random_means = self.means[list(random.randint(self.m, size=N)), :]
return U + random_means
def chaos_game(polygon, seed, N, f):
nDim = np.size(polygon, 0)
nVerts = np.size(polygon, 1)
fractal = np.zeros([nDim, N])
current_point = seed
for idx in xrange(0, N):
ndx = rnd.randint(0, nVerts)
vert = polygon[:, ndx]
next_point = current_point + f*(vert-current_point)
fractal[:,idx] = next_point
current_point = next_point
return fractal
def test_random(self):
for n_row in [1,2,3,10,100,200]:
for n_col in [1,2,3,4,5]:
s = arange(n_row*n_col).reshape((n_row,n_col))
for n_searches in [1,2,3,n_row,2*n_row]:
expected = random.randint(0,n_row,n_searches)
v = s[expected,:]
result = simplex_array_searchsorted(s,v)
assert_equal(result,expected)
def _forwardImplementation(self, inbuf, outbuf):
""" Draws a random number between 0 and 1. If the number is less
than epsilon, a random action is chosen. If it is equal or
larger than epsilon, the greedy action is returned.
"""
assert self.module
if random.random() < self.epsilon:
outbuf[:] = array([random.randint(self.module.numActions)])
else:
outbuf[:] = inbuf
self.epsilon *= self.decay
def _forwardImplementation(self, inbuf, outbuf):
""" Draws a random number between 0 and 1. If the number is less
than epsilon, a random action is chosen. If it is equal or
larger than epsilon, the greedy action is returned.
"""
assert self.module
if random.random() < self.epsilon:
outbuf[:] = array([random.randint(self.module.numActions)])
else:
outbuf[:] = inbuf
self.epsilon *= self.decay
def getAction(self):
""" activates the module with the last observation and stores the result as last action. """
# get greedy action
action = LearningAgent.getAction(self)
# explore by chance
if random.random() < self.epsilon:
action = array([random.randint(self.module.numActions)])
# reduce epsilon
self.epsilon *= self.epsilondecay
return action
def random_values(self, n):
probability = absolute(self.vector)**2
probability = probability * 10000 # 有効数字を3ケタ以上取るために10000倍する
probability_naturalized = probability.astype(int)
target = []
for i in range(self.mesh.x_num):
weight = probability_naturalized[i]
if not weight == 0:
weight_array = i * ones(weight, dtype=int)
target.extend(weight_array.tolist())
max_random = len(target)
target_index = random.randint(0, max_random, n)
random_index = array(target)[target_index]
return self.mesh.x_vector[random_index]
def prune(self, include_list, default_values, N_max):
"""
Input:
include_list - boolean list of length N_warmup
default_values - array of length N_warmup with default values
Creates a reduced sample of size <= N_max as follows:
1. Remove samples where include_list = False
2. If the number of remaining samples is > N_max, generate N_max subsamples
"""
# The samples to include
self.samples_pruned = self.samples_warmup[include_list]
self.pdf_pruned = self.pdf_warmup[include_list]
self.N_pruned = self.samples_pruned.shape[0]
self.ratio_pruned = self.N_pruned / self.N_warmup
# Downsample if necessary
if self.N_pruned > N_max:
idx = list(random.randint(self.N_pruned, size=N_max))
self.samples_pruned = self.samples_pruned[idx, :]
self.pdf_pruned = self.pdf_pruned[idx]
self.N_pruned = N_max
# When MCIS is run on the pruned subset, we must also include
# the assumed expectation on the left-out samples
# The excluded samples
exclude_list = np.logical_not(include_list)
samples_excluded = self.samples_warmup[exclude_list]
pdf_excluded = self.pdf_warmup[exclude_list]
default_excluded = default_values[exclude_list]
normal_pdf_excluded = np.prod(stats.norm.pdf(samples_excluded), 1)
q_excluded = normal_pdf_excluded / pdf_excluded
if len(default_excluded) == 0:
self.expectation_excluded = 0
else:
self.expectation_excluded = (default_excluded * q_excluded).mean(
) # The assumed expectation of excluded samples
# The density of each pruned sample in the standard normal space
self.normal_pdf_pruned = np.prod(stats.norm.pdf(self.samples_pruned),
1)
# The density fractions used in MCIS
self.q_pruned = self.normal_pdf_pruned / self.pdf_pruned
def disperseRand(self,n): a=[] c=[] i=0 while i<n: xy=[random.uniform(-1,1),random.uniform(-1,1)] if (xy[0]**2+xy[1]**2)<=1: a.append(xy) i+=1 for i in range(0,len(a)): c.append([a[i][0],a[i][1],sqrt(1-(a[i][0]**2+a[i][1]**2))]) for i in range(0,len(c)): #randomly change sign of the z coord if random.randint(0,1): c[i][2]=c[i][2]*-1 return c
def animate(self, *fargs):
# Randomly generate some data to plot
for queue in self.backend.queues:
length = len(queue) - 1
for j in range(1, 11):
queue.append((random.randint(0, 1000), queue[length][1] + j))
# queue.append((queue[length][1] + j, queue[length][1] + j))
# print (queue)
# print (self.backend.queues[0][-10:])
# Only graph if we are on the mission control tab
if self.notebook.index(self.notebook.select()) == 0:
self.update_graphs()
elif self.notebook.index(self.notebook.select()) == 1:
self.update_log_displays()
def disperseRand(self, n):
a = []
c = []
i = 0
while i < n:
xy = [random.uniform(-1, 1), random.uniform(-1, 1)]
if (xy[0]**2 + xy[1]**2) <= 1:
a.append(xy)
i += 1
for i in range(0, len(a)):
c.append([a[i][0], a[i][1], sqrt(1 - (a[i][0]**2 + a[i][1]**2))])
for i in range(0, len(c)): #randomly change sign of the z coord
if random.randint(0, 1):
c[i][2] = c[i][2] * -1
return c
def generate_data(num_dims, n_components):
X = np.empty([0, num_dims])
all_means = []
for i in range(n_components):
# Con esto aseguramos de generar matriz positiva semi definida
cov = random.rand(num_dims, num_dims)
cov = np.dot(cov, cov.transpose())
means = []
for j in range(num_dims):
# Medias aleatorias
means.append(random.uniform(-5, 5))
new_data = np.random.multivariate_normal(means, cov,
random.randint(100, 400))
X = np.concatenate((X, new_data))
all_means.append(means)
return X
def mCarlo(self, n_pts, runs=100):
p = self.disperseRand(n_pts)
#eOld = energySystem(p)
f, eOld = self.forceVectors(p)
count = 0
angle = 1.0
number = [len(p) * runs]
randIndxs = random.randint(0, len(p), [len(p) * runs])
# print len(randIndxs)
while angle > 0.01:
for r in range(0, runs):
#for i in range(0,len(p)):
for q in range(0, len(p)):
#print q*(r+1)
i = randIndxs[q * (r + 1)]
#print i
magnitude = self.distance(f[i])
dirForce = [
f[i][0] / magnitude, f[i][1] / magnitude,
f[i][2] / magnitude
]
nangle = angle / sqrt(count + 1)
pOld = p[i]
p[i] = self.rotateBy(p[i], dirForce, -1 * angle)
eNew = self.energySystem(p)
if eNew > eOld: #revert back
p[i] = pOld
count += 1
else:
eOld = eNew
self.window.update(p)
self.window.updateGL()
self.window.show()
self.window.raise_()
f, e = self.forceVectors(p)
#print eOld,count
angle = angle / 2
print angle, eOld
self.window.lines = []
self.drawEdges(p)
print count
def randomlist(self,mode=1,size=1000,low=0,high=100):
"generate a list followed given distribution"
"IN:distribution model code which refer to randomlist method; sequence size; sequence range"
"OUT:a sequence followed distribution like"
x = []
if mode == 1:
x = random.randint(low,high,size=size)
if mode == 2:
x = map(float,random.normal(loc=(low+high)/2.0, scale=(high-low)/6.0, size=size))
if mode == 3:
x = map(long,random.exponential(scale=1, size=size)+low)
if mode == 4:
x = map(long,random.pareto(1,size=size)+low)
if mode == 5:
x = map(long,random.poisson(lam=(low+high)/2.0, size=size))
# x = random.choice(x,size=100)
return x
def rand_arrange(c,fle='names.xls'):
"""n= Number of Students in a batch \n
c= number of students in a group\n
fle = name of students in excel csv format"""
a=[]
dic = {}
namereader = ow(fle)
# namereader = csv.reader(namedata)
i = 1
# rand_dic= {}
s = namereader.sheets()[0]
# for s in namereader.sheets():
for rows in range(1,s.nrows):
val=[]
for cols in range(s.ncols):
val.append(s.cell(rows,cols).value)
dic[i]=val
a.append(i)
i+=1
b=[]
i=0
# namewriter = csv.DictWriter(fle,fieldnames=['Sr.No.','names'])
# writing in xls
book = Workbook()
sheet1 = book.add_sheet('result')
sheet1.row(0).write(0,'Sr.no.')
sheet1.row(0).write(1,'Roll No')
sheet1.row(0).write(2,'Name')
sheet1.row(0).write(3,'Group No.')
sheet1.col(0).width = 2000
sheet1.col(1).width = 4000
sheet1.col(2).width = 5750
sheet1.col(3).width = 2750
while len(a)!=0:
b.append(a.pop(rd.randint(len(a))))
d=0
for val in dic[b[i]]:
sheet1.row(i+1).write(d,val)
d += 1
if i%c==0:
e=i/c+1
# sheet1.row(i+1).write(d,'Group %d'%(e))
sheet1.row(i+1).write(d,e)
i += 1
book.save('result.xls')
def calc_levels(self,data,fraction=(0.1,0.9),nbins=500,samples=None):
""" fraction is a tuple with (low, high) in the range of 0 to 1
nbins is the number of bins for the histogram resolution
if samples: draw this number of samples (random inds) for faster
calculation
"""
if samples:
data = data.flatten()[random.randint(sp.prod(data.shape),size=samples)]
else:
data = data.flatten()
y,x = sp.histogram(data,bins=nbins)
cy = sp.cumsum(y).astype('float32')
cy = cy / cy.max()
minInd = sp.argmin(sp.absolute(cy - fraction[0]))
maxInd = sp.argmin(sp.absolute(cy - fraction[1]))
levels = (x[minInd],x[maxInd])
return levels
def calc_levels(self, data, fraction=(0.1, 0.9), nbins=500, samples=None):
""" fraction is a tuple with (low, high) in the range of 0 to 1
nbins is the number of bins for the histogram resolution
if samples: draw this number of samples (random inds) for faster
calculation
"""
if samples:
data = data.flatten()[random.randint(sp.prod(data.shape),
size=samples)]
else:
data = data.flatten()
y, x = sp.histogram(data, bins=nbins)
cy = sp.cumsum(y).astype('float32')
cy = cy / cy.max()
minInd = sp.argmin(sp.absolute(cy - fraction[0]))
maxInd = sp.argmin(sp.absolute(cy - fraction[1]))
levels = (x[minInd], x[maxInd])
return levels
def mCarlo(self,n_pts,runs=100): p = self.disperseRand(n_pts) #eOld = energySystem(p) f,eOld = self.forceVectors(p) count = 0 angle = 1.0 number = [len(p)*runs] randIndxs = random.randint(0,len(p),[len(p)*runs]) # print len(randIndxs) while angle > 0.01 : for r in range(0,runs): #for i in range(0,len(p)): for q in range(0,len(p)): #print q*(r+1) i = randIndxs[q*(r+1)] #print i magnitude = self.distance(f[i]) dirForce = [f[i][0]/magnitude,f[i][1]/magnitude,f[i][2]/magnitude] nangle = angle/sqrt(count+1) pOld = p[i] p[i] = self.rotateBy(p[i],dirForce,-1*angle) eNew = self.energySystem(p) if eNew > eOld: #revert back p[i] = pOld count +=1 else: eOld = eNew self.window.update(p) self.window.updateGL() self.window.show() self.window.raise_() f,e = self.forceVectors(p) #print eOld,count angle = angle / 2 print angle, eOld self.window.lines=[] self.drawEdges(p) print count
def getObservation(self):
""" a filtered mapping to getSample of the underlying environment. """
sensors = self.env.getSensors()
sensSort = []
#Angle and angleVelocity
for i in range(32):
sensSort.append(sensors[i])
#Angles wanted (old action)
for i in self.oldAction:
sensSort.append(i)
#Hand position
for i in range(3):
sensSort.append((sensors[38 + i] + sensors[41 + i]) / 2)
#Hand orientation (Hack - make correkt!!!!)
sensSort.append((sensors[38] - sensors[41]) / 2 - sensors[35]) #pitch
sensSort.append(
(sensors[38 + 1] - sensors[41 + 1]) / 2 - sensors[35 + 1]) #yaw
sensSort.append((sensors[38 + 1] - sensors[41 + 1])) #roll
#Target position
for i in range(3):
sensSort.append(self.target[i])
#Target orientation
for i in range(3):
sensSort.append(0.0)
#Object type (start with random)
sensSort.append(float(random.randint(-1, 1))) #roll
#normalisation
if self.sensor_limits:
sensors = self.normalize(sensors)
sens = []
for i in range(32):
sens.append(sensors[i])
for i in range(29):
sens.append(sensSort[i + 32])
#calc dist to target
self.dist = array([(sens[54] - sens[48]) * 10.0,
(sens[55] - sens[49]) * 10.0,
(sens[56] - sens[50]) * 10.0, sens[51], sens[52],
sens[53], 1.0 + sens[15]])
return sens
def rollDice(n):
# Rolls n amount of dice and stores the results in a dictionary of each
# possible outcome tagged with their number of occurrences.
hand = []
for i in range(n):
hand.append(random.randint(1, 6))
occurrences = dict((x, hand.count(x)) for x in set(hand))
keys_seen = [1, 2, 3, 4, 5, 6]
for key in occurrences.keys(): #loop through each dictionary's keys
if key not in keys_seen: #if we haven't seen this key before, then...
keys_seen.append(key) #add it to the list of keys seen
for key in keys_seen: #loop through the list of keys that we've seen
if key not in occurrences: #if the dictionary is missing that key, then...
occurrences[key] = 0 #add it and set it to 0
return occurrences
def get_noise_sample(idx=None, size=None, filename=None):
"""get some noise from a recording of maquaque prefrontal cortex"""
# inits and checks
if filename is None:
filename = '/home/phil/monkey-data/Louis/L011/L0110985.xpd'
if size is None:
size = 10000
# load data
from common.datafile import XpdFile
data = XpdFile(filename).get_data(item=15)
# return
if size >= data.shape[0]:
size = data.shape[0] - 1
idx = 0
if idx is None:
idx = NR.randint(data.shape[0] - size)
return data[idx:idx + size].copy()
def get_noise_sample(idx=None, size=None, filename=None):
"""get some noise from a recording of maquaque prefrontal cortex"""
# inits and checks
if filename is None:
filename = '/home/phil/monkey-data/Louis/L011/L0110985.xpd'
if size is None:
size = 10000
# load data
from common.datafile import XpdFile
data = XpdFile(filename).get_data(item=15)
# return
if size >= data.shape[0]:
size = data.shape[0] - 1
idx = 0
if idx is None:
idx = NR.randint(data.shape[0] - size)
return data[idx:idx + size].copy()
def mask_data(data): thids = [d.header["TARGETID"] for d in data.data.values()] thids = sp.unique(thids) thid_map = dict() for th in thids: old_th = str(th) new_th = '' for (i,oth) in enumerate(old_th): aux = random.randint(9) if aux==0 and i==0:aux=1 new_th = new_th+str(aux) thid_map[th]=int(new_th) plates = [d.header["BOSS_PLATE"] for d in data.data.values()] plates = sp.unique(plates) print plates plate_map = dict() for (i,p) in enumerate(plates): plate_map[p]=i data.plates = plate_map.values() for d in data.data.values(): d.header["OBJTYPE"] = "HIDDEN" d.header["TARGETCAT"]="HIDDEN" d.header["TARGETID"] = thid_map[d.header["TARGETID"]] d.header["MAG"]=23 d.header["SPECTROID"] = d.header["TARGETID"] d.header["FIBERID"]=0 d.header["RA_TARGET"]=3.14 d.header["DEC_TARGET"]=3.14 d.header["RA_OBS"]=3.14 d.header["DEC_OBS"]=3.14 d.header["BOSS_CLASS"]="HIDDEN" d.header["BOSS_SUBCLASS"]="HIDDEN" d.header["BOSS_Z"]=42 d.header["BOSS_PLATE"]=plate_map[d.header["BOSS_PLATE"]] d.header["BOSS_MJD"] = 43689 d.header["BOSS_ZWARNINGNOQSO"]=4 return thid_map,plate_map
def mask_data(data):
thids = [d.header["TARGETID"] for d in data.data.values()]
thids = sp.unique(thids)
thid_map = dict()
for th in thids:
old_th = str(th)
new_th = ''
for (i, oth) in enumerate(old_th):
aux = random.randint(9)
if aux == 0 and i == 0: aux = 1
new_th = new_th + str(aux)
thid_map[th] = int(new_th)
plates = [d.header["BOSS_PLATE"] for d in data.data.values()]
plates = sp.unique(plates)
print plates
plate_map = dict()
for (i, p) in enumerate(plates):
plate_map[p] = i
data.plates = plate_map.values()
for d in data.data.values():
d.header["OBJTYPE"] = "HIDDEN"
d.header["TARGETCAT"] = "HIDDEN"
d.header["TARGETID"] = thid_map[d.header["TARGETID"]]
d.header["MAG"] = 23
d.header["SPECTROID"] = d.header["TARGETID"]
d.header["FIBERID"] = 0
d.header["RA_TARGET"] = 3.14
d.header["DEC_TARGET"] = 3.14
d.header["RA_OBS"] = 3.14
d.header["DEC_OBS"] = 3.14
d.header["BOSS_CLASS"] = "HIDDEN"
d.header["BOSS_SUBCLASS"] = "HIDDEN"
d.header["BOSS_Z"] = 42
d.header["BOSS_PLATE"] = plate_map[d.header["BOSS_PLATE"]]
d.header["BOSS_MJD"] = 43689
d.header["BOSS_ZWARNINGNOQSO"] = 4
return thid_map, plate_map
def Advance(xPos,yPos,xDistance,yDistance,SectorX,SectorY,lifetime):
MoveX,MoveY = Directions[random.randint(0,4)]
xDistance+=MoveX
yDistance+=MoveY
lifetime+=1
if xPos == WindingAxisX and MoveX == -1:
SectorX = (SectorX + 1)%2
if xPos == WindingAxisX - 1 and MoveX == 1:
SectorX = (SectorX + 1)%2
if yPos == WindingAxisY and MoveY == -1:
SectorY = (SectorY + 1)%2
if yPos == WindingAxisY - 1 and MoveY == 1:
SectorY = (SectorY + 1)%2
xPos = (xPos + MoveX)%Dimx
yPos = (yPos + MoveY)%Dimy
return xPos,yPos,xDistance,yDistance,SectorX,SectorY,lifetime
def categorize(categories, data, words):
nnodes = sqrt(categories)
# make a kohonen map
som = KohonenMap(len(data[1])-1, nnodes)
# train the network
for i in range(25000):
# one forward and one backward (training) pass on a random line
som.activate(data[random.randint(1, len(data)-1)][1:])
som.backward()
# run on the data
if not words:
for point in data[1:-1]:
#find the category for a point of data
print(point[0] + ',' + str(som.activate(point[1:])))
#make wordlist output similar to ICA for use in GAs
if words:
results = [[] for i in range(categories)]
for point in data[1:-1]:
# find the cluster for this word and add in the word's data
result = som.activate(point[1:])
results[int(result[0]*nnodes + result[1])].append(point)
# print out the clusters
for i in range(NWORDS):
# TODO: This is super inefficient
for cluster in results:
if len(cluster) == 0:
sys.stdout.write('EMPTY')
continue
for j in range(len(cluster)):
for k in range(1, len(cluster[j])):
cluster[j][k] = float(cluster[j][k])
tempCluster = sorted(cluster, key=lambda point: -sum(point[1:]))
sys.stdout.write(str(tempCluster[i%len(cluster)][0]) + ',')
sys.stdout.write('\n')
def getObservation(self):
""" a filtered mapping to getSample of the underlying environment. """
sensors = self.env.getSensors()
sensSort = []
#Angle and angleVelocity
for i in range(32):
sensSort.append(sensors[i])
#Angles wanted (old action)
for i in self.oldAction:
sensSort.append(i)
#Hand position
for i in range(3):
sensSort.append((sensors[38 + i] + sensors[41 + i]) / 2)
#Hand orientation (Hack - make correkt!!!!)
sensSort.append((sensors[38] - sensors[41]) / 2 - sensors[35]) #pitch
sensSort.append((sensors[38 + 1] - sensors[41 + 1]) / 2 - sensors[35 + 1]) #yaw
sensSort.append((sensors[38 + 1] - sensors[41 + 1])) #roll
#Target position
for i in range(3):
sensSort.append(self.target[i])
#Target orientation
for i in range(3):
sensSort.append(0.0)
#Object type (start with random)
sensSort.append(float(random.randint(-1, 1))) #roll
#normalisation
if self.sensor_limits:
sensors = self.normalize(sensors)
sens = []
for i in range(32):
sens.append(sensors[i])
for i in range(29):
sens.append(sensSort[i + 32])
#calc dist to target
self.dist = array([(sens[54] - sens[48]) * 10.0, (sens[55] - sens[49]) * 10.0, (sens[56] - sens[50]) * 10.0, sens[51], sens[52], sens[53], 1.0 + sens[15]])
return sens
def kinit(X, k):
'init k seeds according to kmeans++'
n = X.shape[0]
'choose the 1st seed randomly, and store D(x)^2 in D[]'
centers = [X[random.randint(n)]]
D = [norm(x - centers[0]) ** 2 for x in X]
for _ in range(k - 1):
bestDsum = bestIdx = -1
for i in range(n):
'Dsum = sum_{x in X} min(D(x)^2,||x-xi||^2)'
Dsum = reduce(lambda x, y:x + y,
(min(D[j], norm(X[j] - X[i]) ** 2) for j in xrange(n)))
if bestDsum < 0 or Dsum < bestDsum:
bestDsum, bestIdx = Dsum, i
centers.append (X[bestIdx])
D = [min(D[i], norm(X[i] - X[bestIdx]) ** 2) for i in xrange(n)]
return array (centers)
def kinit(X, k):
'init k seeds according to kmeans++'
n = X.shape[0]
'choose the 1st seed randomly, and store D(x)^2 in D[]'
centers = [X[random.randint(n)]]
D = [norm(x - centers[0]) ** 2 for x in X]
for _ in range(k - 1):
bestDsum = bestIdx = -1
for i in range(n):
'Dsum = sum_{x in X} min(D(x)^2,||x-xi||^2)'
Dsum = reduce(lambda x, y:x + y,
(min(D[j], norm(X[j] - X[i]) ** 2) for j in xrange(n)))
if bestDsum < 0 or Dsum < bestDsum:
bestDsum, bestIdx = Dsum, i
centers.append (X[bestIdx])
D = [min(D[i], norm(X[i] - X[bestIdx]) ** 2) for i in xrange(n)]
return array (centers)
def TrialMove2(InitLat):
InitialLattice = deepcopy(InitLat)
InitialEnergy = 2*Je*len(InitialLattice.ExcitationList)
if(len(InitialLattice.ExcitationList)!=0):
RandomExcitation = random.randint(len(InitialLattice.ExcitationList))
RandomDirection = random.randint(0,5)
InitialLattice.MoveExcitation(RandomExcitation,RandomDirection)
SpawnOrientation = random.randint(0,3) #0 don't do anything, 1 updown, 2 leftright
if(SpawnOrientation == 1):
RandomX = random.randint(0,InitialLattice.Dimension)
RandomY = random.randint(0,InitialLattice.Dimension)
InitialLattice.SpawnExcitation(RandomX,RandomY)
InitialLattice.SpawnExcitation(RandomX,(RandomY+1)%InitialLattice.Dimension)
InitialLattice.CheckSector(RandomX,RandomY,0,1)
if(SpawnOrientation == 2):
RandomX = random.randint(0,InitialLattice.Dimension)
RandomY = random.randint(0,InitialLattice.Dimension)
InitialLattice.SpawnExcitation(RandomX,RandomY)
InitialLattice.SpawnExcitation((RandomX+1)%InitialLattice.Dimension,RandomY)
InitialLattice.CheckSector(RandomX,RandomY,1,0)
FinalEnergy = 2*Je*len(InitialLattice.ExcitationList)
if(FinalEnergy <= InitialEnergy):
return InitialLattice
else:
r = random.rand()
#print(exp(-(FinalEnergy-InitialEnergy)/Temperature))
if r < exp(-(FinalEnergy-InitialEnergy)/Temperature):
return InitialLattice
else:
return InitLat
def forceAngleOutward(self, n_pts, runs=100):
p = self.disperseRand(n_pts)
f, eOld = self.forceVectors(p)
count = 0
number = [len(p) * runs]
randIndxs = random.randint(0, len(p), [len(p) * runs])
for r in range(0, runs):
for i in range(0, len(p)):
#for q in range(0,len(p)):
#print q*(r+1)
# i = randIndxs[q*(r+1)]
#print i
magnitude = self.distance(f[i])
dirForce = [
f[i][0] / magnitude, f[i][1] / magnitude,
f[i][2] / magnitude
]
angle = arccos((p[i][0] * dirForce[0]) +
(p[i][1] * dirForce[1]) +
(p[i][2] * dirForce[2]))
if angle > 0.01:
p[i] = dirForce
count += 1
self.window.update(p)
self.window.updateGL()
self.window.show()
self.window.raise_()
f, e = self.forceVectors(p)
#print eOld,count
print angle, e
self.window.lines = []
self.drawEdges(p)
print count
def get_distance(Quad, offset, Leader):
Sigma = np.zeros((n, n))
data = loadmat('error_data_jelena_NLOS_LOS.mat')
data1 = data['error_LOS_truncated']
Var = np.std(data1)
dis = np.zeros((n, n))
Sigma = np.zeros((n, n))
for i in np.arange(start=0, stop=n, step=1):
if i == Leader:
X = np.array([Quad[i].X, Quad[i].Y]) + offset
else:
X = np.array([Quad[i].X, Quad[i].Y])
for jj in np.arange(start=i, stop=n, step=1):
Y = np.array([Quad[jj].X, Quad[jj].Y])
value_i = random.randint(0, 20000)
dis[i, jj] = np.linalg.norm(X - Y)
Sigma[i, jj] = Var
Sigma[jj, i] = Var
dis[i, jj] = dis[i, jj] + (data1[value_i] - 0.16) / 5
dis[jj, i] = dis[i, jj]
return dis, Sigma
from scipy.linalg import expm, expm2, expm3
from expf import expf
from time import time
s = range(3, 100)
t = zeros(size(s))
t2 = zeros(size(s))
t3 = zeros(size(s))
t4 = zeros(size(s))
tt = 0
for i in s:
print "Matrix size %d" %(i)
m = zeros((i,i), float64)
half = int(round(i*i/2))+1
r = random.randint(0,i, (half*2, ))
n = random.random((half, ))
for z in range(0, half*2, 2):
m[r[z], r[z+1]] = n[z/2]
start = time()
expm(m)
t[tt] = time() - start
start = time()
expm2(m)
t2[tt] = time() - start
start = time()
expm3(m)
t3[tt] = time() - start
def genDifVect(self):
# generates a uniform difference vector with the given epsilon
self.deltas = (random.randint(0, 2, self.numOParas) * 2 -
1) * self.epsilon
def is_prime(pn):
for m in range(1,100):
random_int = random.randint(1,pn)
if not (pow(random_int, int(pn-1), int(pn)) == 1):
return False
return True
def uniform_time(tstart, tstop, number):
"""
Get a set of randomized (integer) event times.
"""
return random.randint(tstart, tstop, number) + random.rand(number)
filenames = []
testset = []
indir = 'train'
for file in os.listdir(indir):
if(file.endswith('.jpg')):
filenames.append(file)
testdir = 'test'
for file in os.listdir(testdir):
if(file.endswith('.jpg')):
testset.append(file)
for i in xrange(len(whales)):
if(labelsDict[whales[i]] == -1):
labelsDict[whales[i]] = []
labelsDict[whales[i]].append(images[i])
testset = [int(re.search("w_(\\d+)\.jpg", x).group(1)) for x in testset]
for w in set(whales):
allExamplesForW = labelsDict[w]
allExamplesForW = [x for x in allExamplesForW if x not in testset]
allExamplesForW = random.permutation(allExamplesForW)
for i in allExamplesForW[0:(len(allExamplesForW)/2)+(random.randint(0,(len(allExamplesForW))%2+1))]:
print("copying %d\n"%i)
os.rename(("%s/w_%d.jpg") % (indir, i), ("%s/w_%d.jpg") %(validationDir, i))
'rates_sweep_result.csv')
Results.to_csv(outpath)
# ██████ ██ ██████ ████████ ████████ ██ ███ ██ ██████
# ██ ██ ██ ██ ██ ██ ██ ██ ████ ██ ██
# ██████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ███
# ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
# ██ ███████ ██████ ██ ██ ██ ██ ████ ██████
Results = pd.read_csv(
os.path.join(exp_name + '_results', 'benchmark', 'rates_sweep_result.csv'))
colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
# %% randomly inspect single sorting results
rand_inds = random.randint(len(Blk.segments), size=5)
for i, seg in enumerate([Blk.segments[ind] for ind in rand_inds]):
outpath = os.path.join(exp_name + '_results', 'benchmark',
'segment_' + str(rand_inds[i]))
figures = plot_TM_result(seg, Config, zoom=0.25 * pq.s, save=outpath)
for j, unit in enumerate(unit_names):
fig = figures[unit]
for k, unit_ in enumerate(unit_names):
st, = select_by_dict(seg.spiketrains, unit=unit_, kind='truth')
for ax in fig.axes:
plot_SpikeTrain(st,
ax=ax,
lw=3,
color=colors[k],
zorder=-10,
def AdvanceTime(TimeList,ObservableList):
#Norm = len(Trans)*TranslateRate + len(Annih)*AnnihilationRate + ((2*(MyLattice.Dimension)**2) - len(Annih) - len(Trans))*SpawnRate
#print "Advancing time!"
TranslateableLinks = MyLattice.TranslateableList
AnnihilateableLinks = MyLattice.AnnihilateableList
#print "Translateable: " + str(len(TranslateableLinks)) + str(TranslateableLinks)
#print "Annihilateable: " + str(len(AnnihilateableLinks)) + str(AnnihilateableLinks)
Norm = len(TranslateableLinks)*TranslateRate + len(AnnihilateableLinks)*AnnihilationRate + \
((2*(MyLattice.Dimension)**2) - len(AnnihilateableLinks) - len(TranslateableLinks))*SpawnRate
PTrans = len(TranslateableLinks)*TranslateRate/Norm
PAnnih = len(AnnihilateableLinks)*AnnihilationRate/Norm
PSpawn = ((2*(MyLattice.Dimension)**2) - len(AnnihilateableLinks) - len(TranslateableLinks))*SpawnRate/Norm
r = random.rand()
DeltaTau = (-1./Norm)*log(r)
if (r < PTrans):
#print "Translating!"
#MyLattice.PrintState()
RandLink = random.randint(len(TranslateableLinks))
LinkCoords = [TranslateableLinks[RandLink].x1,TranslateableLinks[RandLink].y1,TranslateableLinks[RandLink].x2,TranslateableLinks[RandLink].y2]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
MyLattice.TranslateExcitations(MyLattice.ReturnExcitationIndex(LinkCoords[0],LinkCoords[1]), XDisplacement, YDisplacement)
if (r >= PTrans and r < PTrans + PAnnih):
#print "Annihilating!"
RandLink = random.randint(len(AnnihilateableLinks))
LinkCoords = [AnnihilateableLinks[RandLink].x1,AnnihilateableLinks[RandLink].y1,AnnihilateableLinks[RandLink].x2,AnnihilateableLinks[RandLink].y2]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
#if(LinkCoords[2]==MyLattice.Dimension or LinkCoords[0] == MyLattice.Dimension - 1):
#print str(LinkCoords[2]) + "\t" + str(LinkCoords[0])
#print str(LinkCoords[3]) + "\t" + str(LinkCoords[1])
MyLattice.AnnihilateExcitations(LinkCoords[0],LinkCoords[1],LinkCoords[2],LinkCoords[3])
#MyLattice.CheckSector(LinkCoords[0]%MyLattice.Dimension,LinkCoords[1]%MyLattice.Dimension, XDisplacement, YDisplacement)
if (r >= PTrans + PAnnih):
#print "Creating!"
Occupancies = MyLattice.ReturnOccupancies()
FoundCreatableLink = False
RandX = 0
RandY = 0
RandDir = 0
while FoundCreatableLink == False:
RandX = random.randint(MyLattice.Dimension)
RandY = random.randint(MyLattice.Dimension)
RandDir = random.randint(2)
if(Occupancies[RandX,RandY]==0 and \
Occupancies[(RandX + RandDir)%MyLattice.Dimension,(RandY + (1-RandDir))%MyLattice.Dimension] == 0):
FoundCreatableLink = True
LinkCoords = [RandX,RandY,RandX + RandDir, RandY + (1-RandDir)]
XDisplacement = LinkCoords[2] - LinkCoords[0]
YDisplacement = LinkCoords[3] - LinkCoords[1]
#if(LinkCoords[2]==MyLattice.Dimension or LinkCoords[0] == MyLattice.Dimension - 1):
#print str(LinkCoords[2]) + "\t" + str(LinkCoords[0])
#print str(LinkCoords[3]) + "\t" + str(LinkCoords[1])
MyLattice.CreateExcitations(LinkCoords[0],LinkCoords[1],LinkCoords[2],LinkCoords[3])
#MyLattice.CheckSector(LinkCoords[0]%MyLattice.Dimension,LinkCoords[1]%MyLattice.Dimension, XDisplacement, YDisplacement)
return DeltaTau, MyLattice.Sector, len(MyLattice.ExcitationList)
def runProblem1():
x = random.randint(-5,5,(3))
basin(x)
def genDifVect(self):
# generates a uniform difference vector with the given epsilon
self.deltas = (random.randint(0,2,self.numOParas)*2-1)*self.epsilon
def SingleRun(Dimx,Dimy):
def mapped(x,y):
return ((x%Dimx),(y%Dimy))
#For the calculation we want to perform, the dynamics look like a pair of random walkers appearing on a lattice in cells adjacent to one another.
#The dynamics of these walkers allow them to randomly wiggle around the lattice, or annihilate each other (if they happen to be next to each other,
#and if they happen to decide to annihilate--they don't necessarily annihilate if they are next to each other (although it is incredibly likely
#they will annihilate one another if they're next to each other)).
#This set of starting positions mimics the situation of a pair of walkers appearing and *NOT* immediately annihilating. Thus, one of the walkers
#moves either left, right, or up (you can see this by plotting the three starting positions). If your lattice size was 10x10, (-1%Dimx) would
#yield 9.
StartingPositions = []
StartingPositions.append(mapped(0,2))
StartingPositions.append(mapped(0,-2))
StartingPositions.append(mapped(2,0))
StartingPositions.append(mapped(-2,0))
StartingPositions.append(mapped(1,1))
StartingPositions.append(mapped(-1,-1))
StartingPositions.append(mapped(-1,1))
StartingPositions.append(mapped(1,-1))
StartingPositions.append(mapped(1,1))
StartingPositions.append(mapped(-1,-1))
StartingPositions.append(mapped(-1,1))
StartingPositions.append(mapped(1,-1))
#StartingPositions.append(((-1%Dimx),1))
#We want to randomly sample from these three starting positions as they are all equally likely
xPos,yPos = StartingPositions[random.randint(0,11)]
#These are just some variables I care about for the simulation.
xDistance,yDistance = 0,0
lifetime = 0
SectorX = 0
SectorY = 0
WindingAxisX = math.floor(Dimx/2.)
WindingAxisY = math.floor(Dimy/2.)
#A simple output statement to check that the random walker code works.
def PrintState():
for i in xrange(Dimx):
print "\n"
for j in xrange(Dimy):
if (i,j) == (xPos,yPos):
print "1",
else: print "0",
print "\n"
#This code advances everything I care about. It takes the current position of the walker, and some other variables, and iterates them as necessary
def Advance(xPos,yPos,xDistance,yDistance,SectorX,SectorY,lifetime):
MoveX,MoveY = Directions[random.randint(0,4)]
xDistance+=MoveX
yDistance+=MoveY
lifetime+=1
if xPos == WindingAxisX and MoveX == -1:
SectorX = (SectorX + 1)%2
if xPos == WindingAxisX - 1 and MoveX == 1:
SectorX = (SectorX + 1)%2
if yPos == WindingAxisY and MoveY == -1:
SectorY = (SectorY + 1)%2
if yPos == WindingAxisY - 1 and MoveY == 1:
SectorY = (SectorY + 1)%2
xPos = (xPos + MoveX)%Dimx
yPos = (yPos + MoveY)%Dimy
return xPos,yPos,xDistance,yDistance,SectorX,SectorY,lifetime
#This is the end condition for the random walk. If the random walker comes within 1 unit of (0,0), the program ends because
#it's overwhelming more likely for the random walkers to self-annihilate than they are to keep random walking. Note that only one of the random
#walkers is actually randomly walking in this simulation--one of them is pinned at 0,0. This is valid because 2 random walkers walking on a lattice
#can be thought of as just one random walker walking around, where we fix the origin on the other random walker.
def CheckEnd(xPos,yPos):
if ((xPos,yPos) == (1,0) or (xPos,yPos) == (0,1) or (xPos,yPos) == (Dimx-1,0) or (xPos,yPos) == (0,Dimy-1)):
return True
else:
return False
#This loop makes the random walker wiggle until the end condition
while(CheckEnd(xPos,yPos)==False):
xPos, yPos, xDistance, yDistance, SectorX,SectorY, lifetime = Advance(xPos,yPos,xDistance,yDistance,SectorX,SectorY,lifetime)
return SectorX,SectorY, lifetime, xDistance, yDistance
def MaximumEntropy(p, tau, Gt):
beta = tau[-1]
random.seed(1) # seed for random numbers
omega = linspace(-p['L'], p['L'], 2 * p['Nw'] + 1)
f0, f1, f2 = me.initf0(omega)
fsg = 1
if p['statistics'] == 'fermi':
Gt = -Gt
fsg = -1
normalization = Gt[0] + Gt[-1]
Ker = me.initker_fermion(omega, beta, tau)
elif p['statistics'] == 'bose':
normalization = integrate.trapz(Gt, x=tau)
Ker = me.initker_boson(omega, beta, tau)
print 'beta=', beta
print 'normalization=', normalization
# Set error
if p['idg']:
sxt = ones(len(tau)) / (p['deltag']**2)
else:
sxt = Gt * p['deltag']
for i in range(len(sxt)):
if sxt[i] < 1e-5: sxt[i] = 1e-5
sxt = 1. / sxt**2
# Set model
if p['iflat'] == 0:
model = normalization * ones(len(omega)) / sum(f0)
elif p['iflat'] == 1:
model = exp(-omega**2 / p['gwidth'])
model *= normalization / dot(model, f0)
else:
dat = loadtxt('model.dat').transpose()
fm = interpolate.interp1d(dat[0], dat[1])
model = fm(omega)
model *= normalization / dot(model, f0)
#savetxt('brisi_test', vstack((tau, fsg*dot(model,Ker))).transpose())
print 'Model normalization=', dot(model, f0)
# Set starting Aw(omega)
Aw = random.rand(len(omega))
Aw = Aw * (normalization / dot(Aw, f0))
print 'Aw normalization=', dot(Aw, f0)
dlda = me.initdlda(omega, Ker, sxt)
temp = 10.
rfac = 1.
alpha = p['alpha0']
for itt in range(p['Nitt']):
print itt, 'Restarting maxent with rfac=', rfac, 'alpha=', alpha
iseed = random.randint(0, maxint)
me.maxent(Aw, rfac, alpha, temp, Ker, sxt, Gt, model, f0, p['Asteps'],
iseed)
S = me.entropy(Aw, model, f0)
Trc = me.lambdac(alpha, Aw, omega, dlda)
ratio = -2 * S * alpha / Trc
print 'Finished maxent with alpha=', alpha, '-2*alpha*S=', -2 * alpha * S, 'Trace=', Trc
print ' ratio=', ratio
savetxt('dos_' + str(itt), vstack((omega, Aw)).transpose())
temp = 0.001
rfac = 0.05
if abs(ratio - 1) < p['min_ratio']: break
if (abs(ratio) < 0.05):
alpha *= 0.5
else:
alpha *= (1. + 0.001 * (random.rand() - 0.5)) / ratio
for itt in range(p['Nr']):
print 'Smoothing itt ', itt
Aw = Broad(p['bwdth'], omega, Aw)
Aw *= (normalization / dot(Aw, f0)) # Normalizing Aw
savetxt('dos_' + str(p['Nitt']), vstack((omega, Aw)).transpose())
temp = 0.005
rfac = 0.005
iseed = random.randint(0, maxint)
me.maxent(Aw, rfac, alpha, temp, Ker, sxt, Gt, model, f0, p['Asteps'],
iseed)
S = me.entropy(Aw, model, f0)
Trc = me.lambdac(alpha, Aw, omega, dlda)
ratio = -2 * S * alpha / Trc
print 'Finished smoothing run with alpha=', alpha, '-2*alpha*S=', -2 * alpha * S, 'Trace=', Trc
print ' ratio=', ratio
savetxt('gtn', vstack((tau, fsg * dot(Aw, Ker))).transpose())
Aw = Broad(p['bwdth'], omega, Aw)
savetxt('dos.out', vstack((omega, Aw)).transpose())
return (Aw, omega)
