def train(net_params, optimizer, pool):
noise_seed = rng().integers(0, 2**32 - 1, size=POP_SIZE // 2).repeat(2)
jobs = [
pool.apply_async(get_reward,
(net_params, env, [noise_seed[k_id], k_id]))
for k_id in range(POP_SIZE)
]
rewards = np.array([j.get() for j in jobs])
gradients = optimizer.gradients(rewards, noise_seed)
return net_params + LR * gradients, rewards
def __init__(self, update_port, update_rate=0.01, sync_port, num_params):
# Init TCP server
self.upd_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sync_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.update_port = update_port
self.sync_port = sync_port
self.update_rate = update_rate
self.params = rng(size=num_params) * 1e-2
def evolve(env, genotype, opt, pool):
seeds = rng().integers(0, 2 ** 32 - 1, size=POP_SIZE//2).repeat(2)
jobs = [
pool.apply_async(eval_mutant, (env, genotype, m_id, seeds[m_id]))
for m_id in range(POP_SIZE)
]
rewards = np.array([j.get() for j in jobs])
grad = opt.get_gradient(seeds, rewards)
genotype += LR * grad
def randNS(detector,redshiftSampler):
cosTh=rng()*2 -1
Theta=np.arccos(cosTh)
Phi=2*np.pi*rng()
cosIo=rng()*2 -1
Iota=np.arccos(cosIo)
Psi=2*np.pi*rng()
M=randMass()
randomZ=redshiftSampler()
Dl=D_L(randomZ)
if(detector=='AdLigoDesign'):
A=AdLigoDesign(M*(1+randomZ))
elif(detector=='AdLigoH1'):
A=AdLigoH1(M*(1+randomZ))
elif(detector=='ET'):
A=ET(M*(1+randomZ))
else:
print('zly detector:', detector)
return 0
return (SNR(Dl,Theta,Phi,Psi,Iota,A) ,Dl,M,randomZ,Theta,Phi,Psi,Iota)
def Random_Walk(number_steps): # our function that does all the work
# you could say this is the workhorse of the program
# it takes the random walks for us so we don't have to and can stay inside, never to walk again
# our random walk generates arrays of positions, not arrays of steps
# this is important and means that we do not need to sum over slices of an array later to generate paths
x = np.zeros(number_steps) # create a null array for x positions
y = np.zeros(number_steps) # create a null array for y positions
x_samples = rng(
number_steps) # generate 1000 random floats between 0 and 1
y_samples = rng(
number_steps) # generate 1000 random floats between 0 and 1
x_sum = 0 # set the final x position to zero
# x_sum will be the sum of all movements in the x direction so that the end result is the final x value
y_sum = 0 # set the final y position to zero
# y_sum will be the sum of all movements in the y direction so that the end result is the final y value
for i in range(
1, number_steps
): # we use a parameter for the range so we can change it easier
if x_samples[
i] < 0.5: # if x_samples[i] is heads, move +1 in x direction
x[i] = x[i - 1] + 1 # move +1 in the x direction
x_sum += 1 # I add one to the sum of x movements
else: # if x_samples[i] is tails, move -1 in the x direction
x[i] = x[i - 1] - 1 # move -1 in the x direction
x_sum -= 1 # I subtract one from the sum of the x movements
if y_samples[
i] < 0.5: # if y_samples[i] is heads move +1 in the y direction
y[i] = y[i - 1] + 1 # move +1 in the y direction
y_sum += 1 # I add one to the sum of the y movements
else: # if y_samples[i] is tails move -1 in the y direction
y[i] = y[i - 1] - 1 # move -1 in the y direction
y_sum -= 1 # I subtract one from the sum of the y movements
distance = np.sqrt(
x_sum**2 +
y_sum**2) # find the displacement from the origin for the walk
return x, y, distance # return the x positions, y positions, and displacement
def write_fox(qs=qNom, name=None, directory=FOX_DIR, fox_file='SEC_neutrons_WF_14m_v1.fox'):
# how many magnets to set
input_len = len(qs)
# if less than qNom, use qNom values (0) for remainder
if (len(qNom)-input_len>0):
for i in range(len(qNom)-input_len):
qs = append(qs,qNom[i+input_len])
# get rand number for the temporary file
if name==None:
rand = rng()
else:
rand = name
# get the fox file for the simulation and change the qvalues
cosy_input = FOX_DIR + fox_file
text = None
with open(cosy_input, 'r') as f:
text = f.readlines()
start_line = 0
# find where in the file to change
for i in range(len(text)):
# dummy text line in the fox file that the code searches for to find the qvalue setting
if "SET MAGNETS" in text[i]:
start_line = i+1
# print(text[i], text[start_line])
# change the q setttings
for i in range(len(qs)):
text[i+start_line] = "Q{0}_SC:= {1};\n".format(i+1,qs[i])
# temporary output file
cosyFilename = directory + 'pygmoCosy'+str(rand)+'.fox'
# if by some ridiculous chance we pick the same number as another iteration, find new number
while os.path.exists(cosyFilename):
rand = rng()
cosyFilename = directory + 'pygmoCosy'+str(rand)+'.fox'
lisFilename = directory + 'pygmoCosy'+str(rand)+'.lis'
# write out the fox file
with open(cosyFilename, 'w') as f:
f.writelines(text)
# return filenames for cosy to find
return cosyFilename, lisFilename
def generate_patch_info(self, shape_type, sizx, sizy, ori):
max_s = int(2*max(sizx, sizy))
patch = np.zeros((max_s, max_s))
patch_0 = None
if shape_type == 'ellipse':
center = (patch.shape[0]//2, patch.shape[1]//2)
radius = (sizy/2, sizx/2)
rr, cc = ellipse(center[0], center[1], radius[0], radius[1], shape=patch.shape)
patch[rr, cc] = 255
elif shape_type == 'rectangle':
start = (int(max_s - sizy//2, int(max_s - sizx)//2))
extent = (int(sizy), int(sizx))
rr, cc = rectangle(start=start, extent=extent, shape=patch.shape)
patch[rr, cc] = 255
if shape_type == 'vernier':
patch_0 = np.zeros((max_s, max_s)) # patch with zero offset
v_siz_w = rng().uniform(1 + sizx//6, 1 + sizx//2)
v_siz_h = rng().uniform(1 + sizy//4, 1 + sizy//2)
v_off_w = rng().uniform(1, 1 + (sizx - v_siz_w)//2)*2
v_off_h = rng().uniform(1 + v_siz_h//2, 1 + (sizy - v_siz_h)//2)*2
start1 = (int((max_s - v_off_h - v_siz_h)//2), int((max_s - v_off_w - v_siz_w)//2))
start2 = (int((max_s + v_off_h - v_siz_h)//2), int((max_s + v_off_w - v_siz_w)//2))
start01 = (int((max_s - v_off_h - v_siz_h)//2), int((max_s - 0 - v_siz_w)//2))
start02 = (int((max_s + v_off_h - v_siz_h)//2), int((max_s + 0 - v_siz_w)//2))
extent = (int(v_siz_h), int(v_siz_w))
rr1, cc1 = rectangle(start=start1, extent=extent, shape=patch.shape)
rr2, cc2 = rectangle(start=start2, extent=extent, shape=patch.shape)
rr01, cc01 = rectangle(start=start01, extent=extent, shape=patch.shape)
rr02, cc02 = rectangle(start=start02, extent=extent, shape=patch.shape)
patch[ rr1, cc1 ] = 255
patch[ rr2, cc2 ] = 255
patch_0[rr01, cc01] = 255
patch_0[rr02, cc02] = 255
patch = rotate(patch, ori).astype(int)
patch_info = [patch, np.fliplr(patch), patch_0]
return patch_info
def Initialize():
x0 = [XPOS0, VX0]
y0 = [YPOS0, VY0]
PvCB = rand.choice([0,1]) #0 = paper, 1 = cardboard
theta = ((rng(1)[0]+0.001)*3.14)/9 #theta varies between approximately
#0 degrees and 10 degrees
if PvCB == 0: #If paper
i = (rng(1)[0]+0.1)*.594 #i ranges between 0.0594m and 0.594m
j = (rng(1)[0]+0.1)*.841 #j ranges between 0.0841m and 0.841m
area = i*j #Area of the paper
s= np.sqrt(i*i+j*j) #Diagonal of the paper
height = .000005 #Height of paper is 0.05mm
mass = DENSITY_PAPER * height * area
#Numerically integrate XAccel and YAccel to find x(t) and y_p(t)
x = odeint(XAccel, x0, t, args=(mass, area, PvCB, theta))
y_p = odeint(YAccel_p, y0, t, args=(mass, area, s, PvCB, theta))
return [x, y_p, PvCB]
else: #If cardboard
i = (rng(1)[0]+0.001)*1.219 #i ranges between 0.1219m and 1.219m
j = (rng(1)[0]+0.001)*.457 #j ranges between 0.0457m and 0.457m
area = i*j #Area of the cardboard
s= np.sqrt(i*i+j*j) #Diagonal of the cardboard
height = ((rng(1)[0]* 0.0045) + 0.0015) #Height of cardboard ranges
#between 0.0015m and 0.006m
mass = DENSITY_CB * height * area
#Numerically integrate XAccle and YAccel to find x(t) and y_c(t)
x = odeint(XAccel, x0, t, args=(mass, area, PvCB, theta))
y_c = odeint(YAccel_c, y0, t, args=(mass, area, s, PvCB, theta))
return [x, y_c, PvCB]
def diffusion_confined_space(num_steps, num_walkers):
"""
Generating the random walk data, for statistically
independent random variables. This for a 2D random walk.
The two arrays, x_coord and y_coord,
contain only the particles in the
specified coordinates: contrained to -100 to 100 for both axes
(i.e 200X200 coordinate system--square lattice).
"""
# to store x position for all the walkers
x_coord = np.zeros((num_walkers, num_steps))
# to store y position for all the walkers
y_coord = np.zeros((num_walkers, num_steps))
for j in range(num_walkers):
# generate random steps +/- 1
x = (2 * (rng(num_steps) > 0.5) - 1).cumsum()
# generate random steps +/- 1
y = (2 * (rng(num_steps) > 0.5) - 1).cumsum()
#store data
x_coord[j, :] = x
#store data
y_coord[j, :] = y
#fills all values outside boundary with np.nan
for i in range(num_walkers):
for j in range(num_steps):
if 100<x_coord[i,j] or x_coord[i,j]<-100 or\
100<y_coord[i,j] or y_coord[i,j]<-100:
x_coord[i, j] = np.nan
y_coord[i, j] = np.nan
#return variables for plotting
return x_coord, y_coord, num_steps, num_walkers
def move_random(self):
"""Literaly move in a random formation"""
from numpy.random import randint as rng
direction = ["up", "down", "left", "right"]
direction_choice = direction[int(rng(low = 0, high = len(direction)))]
if direction_choice == "up":
self.move_up()
elif direction_choice == "down":
self.move_down()
elif direction_choice == "right":
self.move_right()
else:
self.move_left()
def get_trajectory(num_steps):
x_steps = np.ones(num_steps)
y_steps = np.ones(num_steps)
for i in range(0, num_steps):
if (rng() < 0.5):
x_steps[i] = -1
else:
x_steps[i] = 1
if (rng() < 0.5):
y_steps[i] = -1
else:
y_steps[i] = 1
# 累加前k项
X_steps = np.cumsum(x_steps)
Y_steps = np.cumsum(y_steps)
plt.figure()
ax = plt.gca()
ax.set_title("bulangyundong", size=24, weight='bold')
ax.set_xlabel("X")
ax.set_ylabel("Y")
plt.axis('equal')
plt.plot(X_steps, Y_steps)
plt.show()
def __init__(self, set_type, objects, batch_s, scl, n_frames, c, wn_w, wn_h, grav, pop_t=0, random_start_pos=False, random_start_speed=False, random_size=False):
super().__init__(objects, batch_s, scl, n_frames, wn_w, wn_h, grav, random_start_pos, random_start_speed, random_size)
# Select object static and dynamic properties
choices = ['vernier'] # type of object that appears in frames
self.ori = np.ones((1, batch_s))*0.0 # orientation (rotation)
self.colr = np.ones((c, batch_s), dtype=int)*255 # color
self.pop_t = np.ones((1, batch_s), dtype=int)*pop_t # frame where object appears and seed offset takes place
self.shape = rng().choice(choices, (1, batch_s))
self.side = rng().randint(0, 2, (1, batch_s)) if len(objects) == 0 else objects[0].side
self.side_ = 1*self.side # evolving value for sqm (deep copy)
self.popped = np.array([[False]*batch_s]) # display stimulus or not
self.sizx[self.shape == 'vernier'] /= 1.5 # verniers look better if not too wide
self.sizy[self.shape == 'vernier'] *= 2.0 # verniers appear smaller than other shapes
self.pos = np.vstack((self.x, self.y))
self.vel = np.vstack((self.vx, self.vy))
self.acc = np.array([[0.00]*batch_s, [grav]*batch_s])
# Generate patches to draw the shapes efficiently
self.patches = []
for b in range(batch_s):
patch_info = self.generate_patch_info(self.sizx[0, b], self.sizy[0, b], self.ori[0, b])
self.patches.append(patch_info)
def __init__(self, set_type, objects, batch_s, scl, n_frames, c, wn_w, wn_h, grav, random_start_pos=False, random_start_speed=False, random_size=False):
super().__init__(objects, batch_s, scl, n_frames, wn_w, wn_h, grav, random_start_pos, random_start_speed, random_size)
# Select object static and dynamic properties
choices = ['rectangle', 'ellipse', 'vernier']
self.ori = rng().uniform(0, 2*np.pi, (1, batch_s))
self.colr = rng().randint(100, 255, (c, batch_s))
self.pop_t = rng().randint(0, n_frames//2, (1, batch_s))
self.shape = rng().choice(choices, (1, batch_s))
self.side = rng().randint(0, 2, (1, batch_s)) if len(objects) == 0 else objects[0].side
self.side_ = 1*self.side # evolving value for sqm (deep copy)
self.popped = np.array([[False]*batch_s]) # display stimulus or not
self.sizx[self.shape == 'vernier'] /= 1.5 # verniers look better if not too wide
self.sizy[self.shape == 'vernier'] *= 2.0 # verniers appear smaller than other shapes
self.pos = np.vstack((self.x, self.y))
self.vel = np.vstack((self.vx, self.vy))
self.acc = np.array([[0.00]*batch_s, [grav]*batch_s])
# Generate patches to draw the shapes efficiently
self.patches = []
for b in range(batch_s):
patch_info = self.generate_patch_info(self.shape[0, b], self.sizx[0, b], self.sizy[0, b], self.ori[0, b])
self.patches.append(patch_info)
def init_batch(self):
# Background window and objects inside it
self.batch = []
self.objects = []
self.window = 127 * np.ones(
(self.batch_s, self.wn_h, self.wn_w, self.n_chans), dtype=int)
for _ in range(self.n_objects):
self.objects.append(
self.Object(self.set_type, self.objects, self.batch_s,
self.scale, self.n_frames, self.n_chans, self.wn_h,
self.wn_w, self.gravity))
self.bg_color = rng().randint(
0, 80, (self.batch_s, self.n_chans)
) # if set_type == 'recons' else 40*np.ones((self.batch_s, self.n_chans))
for b in range(self.batch_s):
for c in range(self.n_chans):
self.window[b, :, :, c] = self.bg_color[b, c]
# Occluding walls in the frontground
n_occl = rng().randint(0, self.n_max_occl + 1, (
self.batch_s)) if self.set_type == 'recons' else [0] * self.batch_s
self.frnt_grd = np.zeros(self.window.shape, dtype=bool)
for b in range(self.batch_s):
for _ in range(n_occl[b]):
if rng().rand() > 0.5:
pos = rng().randint(0, self.wn_h)
height = rng().randint(2, self.wn_h // 10)
self.frnt_grd[b,
max(0, pos -
height):min(self.wn_h, pos +
height), :, :] = True
else:
pos = rng().randint(0, self.wn_w)
height = rng().randint(2, self.wn_w // 10)
self.frnt_grd[b, :,
max(0, pos -
height):min(self.wn_w, pos +
height), :] = True
def __init__(self, objects, batch_s, scl, n_frames, wn_w, wn_h, grav, random_start_pos, random_start_speed, random_size):
"""
Parameters
----------
objects: int
batch_s: int
scl: float
n_frames: int
wn_w: int
wn_h: int
"""
self.batch_s = batch_s
# vx and vy denote the starting velocity of the vernier
if random_start_speed:
self.vx = rng().uniform(-3*scl, 3*scl, (1, self.batch_s))
self.vy = rng().uniform(-3*scl, 3*scl, (1, batch_s))
else:
flow = (len(objects)%2 - 0.5)*4*scl**2
self.vx = np.ones((1, self.batch_s))*flow
self.vy = np.ones((1, self.batch_s))*0.0
# sizx and sizy denote the size of half a vernier
if random_size:
self.sizx = rng().uniform(wn_w/10, wn_w/2, (1, self.batch_s)) # max: /4
self.sizy = rng().uniform(wn_h/10, wn_h/2, (1, self.batch_s)) # max: /4
else:
self.sizx = np.ones((1, self.batch_s))*wn_w/5
self.sizy = np.ones((1, self.batch_s))*wn_w/4
# x and y denote the starting position of the center of the vernier
if random_start_pos:
x_margin = n_frames * abs(self.vx) + self.sizx
y_margin = self.sizy + 4
self.x = rng().uniform(x_margin, wn_w - x_margin, (1, self.batch_s))
self.y = rng().uniform(y_margin, wn_h - y_margin, (1, self.batch_s))
else:
self.x = np.ones((1, self.batch_s)) * wn_w//2
self.y = np.ones((1, self.batch_s)) * wn_h//2
def triangle_lattice_random_walk(num_steps, num_walkers):
"""
Generating the random walk data, for statistically
independent random variables. This is for a 2D random walk
on a triangular lattice.
The two arrays, x_arrray and y_array,
contain the coordinates of the random walker and the r_sqaured_normal array
contains the averge displacement of all the walker
at each time (step number).
"""
#store distance squared for each walker
r_squared = np.zeros(num_steps)
#array to store analytical solutions for the diffusion constant
diffusion_constant = np.zeros(num_steps)
# specify all step numbers-- for consistent plotting purposes
step_num = np.arange(1, num_steps + 1)
#becuase triangular lattice has locations it can move
#(non-binary arguments).
#So, creating arrays to store coordinates of the walks
x_array = np.zeros(num_steps)
y_array = np.zeros(num_steps)
plt.figure()
ax = plt.gca()
plt.xlabel("x")
plt.ylabel("y")
plt.axis('equal')
ax.set_title('2D Triangular Lattice: Random Walk\n\
%s Steps For Each Walker' %(num_steps),\
family='monospace',size=12, weight='bold')
ax.legend("", title='# of Walks= %s' % (num_walkers), loc=1, fontsize=9)
for j in range(num_walkers):
#evenly distributed values from (0,1]
theta_step = (rng(num_steps))
# generate random steps
#6 possible movement locations for each step
#So, each condition (excluding the error condition)
#represents the movement possiblites.
#AAND the probability that the walk moves in a direction
#is the same for all six possibilites
for i in range(num_steps):
if 0 <= theta_step[i] < 1 / 6:
x_array[i] = 1
y_array[i] = 0
elif 1 / 6 <= theta_step[i] < 2 / 6:
x_array[i] = 0.5
y_array[i] = 1
elif 2 / 6 <= theta_step[i] < 3 / 6:
x_array[i] = -0.5
y_array[i] = 1
elif 3 / 6 <= theta_step[i] < 4 / 6:
x_array[i] = -1
y_array[i] = 0
elif 4 / 6 <= theta_step[i] < 5 / 6:
x_array[i] = -0.5
y_array[i] = -1
elif 5 / 6 <= theta_step[i] < 1:
x_array[i] = 0.5
y_array[i] = -1
else:
print("Something went wrong")
cum_x = np.cumsum(x_array)
cum_y = np.cumsum(y_array)
#to get distance_sqaured for each walker
r_squared_temp = np.add(cum_x**2, cum_y**2)
# add the distance squared of current walker to last walker
#this is done for the collection of 2d walks.
r_squared = r_squared + r_squared_temp
plt.plot(cum_x, cum_y)
#normalizes the r_squared data
normal_r_sqaured = r_squared / num_walkers
#analytically solve for the diffuion
#all solutions are output in the interactive kernel.
for i in range(num_steps):
diffusion_constant[i] = normal_r_sqaured[i] / (2 * (i + 1))
print("At Step Number", i + 1, ":")
print("Diffusion Constant =", diffusion_constant[i], "\n")
plt.show()
plt.figure()
ax = plt.gca()
plt.plot(step_num, normal_r_sqaured, '.')
plt.xlabel("step number = (time)")
plt.ylabel("<r$^2$>")
ax.set_title('2D Triangular Lattice:\n\
The Average of The Sqaure of the Displacement:\n\
%s Steps For Each Walker' %(num_steps),\
family='monospace',size=12, weight='bold')
ax.legend("",
title='# of Walks Averaged= %s' % (num_walkers),
loc=2,
fontsize=9)
plt.show()
return diffusion_constant, normal_r_sqaured
def random_walk(num_steps, num_walkers):
"""
Generating the random walk data, for statistically
independent random variables. This for a 2D random walk.
The two arrays, x and y,
contain the coordinates of the random walker and the r_sqaured_normal array
contains the averge displacement of all the walker
at each time (step number).
"""
#store distance squared for each walker
r_squared = np.zeros(num_steps)
#array to store analytical solutions for the diffusion constant
diffusion_constant = np.zeros(num_steps)
# specify all step numbers-- for consistent plotting purposes
step_num = np.arange(1, num_steps + 1)
plt.figure()
ax = plt.gca()
plt.xlabel("x")
plt.ylabel("y")
plt.axis('equal')
ax.set_title('2D Random Walk:\n\
%s Steps For Each Walker' %(num_steps),\
family='monospace',size=12, weight='bold')
ax.legend("", title='# of Walks= %s' % (num_walkers), loc=1, fontsize=9)
for j in range(num_walkers):
# generate random steps +/- 1
x = (2 * (rng(num_steps) > 0.5) - 1).cumsum()
# generate random steps +/- 1
y = (2 * (rng(num_steps) > 0.5) -
1).cumsum() # generate random steps +/- 1
#to get distance_sqaured for each walker
r_squared_temp = np.add(x**2, y**2)
# add the distance squared of current walker to last walker
#this is done for the collection of 2d walks.
r_squared = r_squared + r_squared_temp
#plot the coodinates of the random walker after each
#is generated
plt.plot(x, y)
#normalizes the r_squared data
normal_r_sqaured = r_squared / num_walkers
#analytically solve for the diffuion
#all solutions are output in the interactive kernel.
for i in range(num_steps):
diffusion_constant[i] = normal_r_sqaured[i] / (2 * (i + 1))
print("At Step Number", i + 1, ":")
print("Diffusion Constant =", diffusion_constant[i], "\n")
plt.show()
plt.figure()
ax = plt.gca()
plt.plot(step_num, normal_r_sqaured, '.')
plt.xlabel("step number = (time)")
plt.ylabel("<r$^2$>")
ax.set_title('2D Random Walk:\n\
The Average of The Sqaure of the Displacement\n\
and %s Steps For Each Walker' %(num_steps),\
family='monospace',size=12, weight='bold')
ax.legend("",
title='# of Walks Averaged= %s' % (num_walkers),
loc=2,
fontsize=9)
plt.show()
return diffusion_constant, normal_r_sqaured
pickup= int(input("\nHow many pickup locations do you want? (26 and under): "))
os.system("rm TempDat* -f")
##############################################################################
################ Creating Rider File ###################
##############################################################################
riders_file = 'TempDatRiders.csv'
riders_name = []
for i in range(riders):
riders_name.append(chr(i+97))
riders_x = 10*rng(riders)
riders_y = 10*rng(riders)
for i in range(riders):
newline = 'echo '+str(riders_name[i])+','+str(riders_x[i])+','+str(riders_y[i])+' >> '+riders_file
os.system(newline)
##############################################################################
################ Creating Pickup File ###################
##############################################################################
pickup_file = 'TempDatPickup.csv'
pickup_name = []
def flat_linear(n_in, n_out):
w = rng().standard_normal(n_in * n_out) * 0.1
b = rng().standard_normal(n_out) * 0.1
return np.concatenate([w, b])
"""
Created on Tue Oct 6 00:19:34 2020
@author: w'm'h
"""
import numpy as np
import matplotlib.pyplot as plt
# 随机数和模拟
# 模拟抛硬币
from numpy.random import random as rng
samples = np.zeros(100)
for i in range(0, 100):
samples[i] = rng()
flips = (samples < 0.5)
print(np.sum(flips))
# 布朗运动轨迹线
def get_trajectory(num_steps):
x_steps = np.ones(num_steps)
y_steps = np.ones(num_steps)
for i in range(0, num_steps):
if (rng() < 0.5):
x_steps[i] = -1
else:
x_steps[i] = 1
if (rng() < 0.5):
y_steps[i] = -1
def reset(self):
self._random = rng(self._seed)
self._data_index = 0
self._epochs_completed = 0
#%% Initialized given code
n = np.zeros((lattice_size, lattice_size))
b = np.zeros((lattice_size, lattice_size))
prob = (1 + p) / sizer
occupancy = int(prob * (lattice_size - 2) * (lattice_size - 2))
clust = np.zeros(lattice_size * lattice_size)
d = np.zeros((lattice_size, lattice_size))
#%% Given Code
# cluster count
x = 0
counter = 0
for count in range(occupancy):
counter = counter + 1
i = int((lattice_size - 2) * rng()) + 1
j = int((lattice_size - 2) * rng()) + 1
while n[i, j] > 0:
i = int((lattice_size - 2) * rng()) + 1
j = int((lattice_size - 2) * rng()) + 1
x = x + 1
n[i, j] = 1
d[i, j] = x
clust[x] = x
if (n[i - 1, j] != 0):
ind = d[i - 1, j]
ind = clust[int(ind)]
while ind < 0:
ind = clust[int(-1 * ind)]
from numpy.random import random as rng import matplotlib.pyplot as plt import numpy as np ######## Makes sure input is an integer between a certain range[] ############ ######################################################################### # Following Creates User Specified N number of Uniformly Dist. Points # N = (1, 100, 250, 500, 1000, 10000,100000) approx = np.zeros(len(N)) for j in range(len(N)): x_arr = rng(N[j])*2 y_arr = rng(N[j])*2 hyp = np.square(x_arr-1) + np.square(y_arr-1) usr_num = N count = 0 for i in range(1,usr_num[j]): if hyp[i] <= 1: count+=1 piapprox = (4*count)/ usr_num[j] approx[j] = piapprox array_approx = (abs(approx-np.pi)/np.pi) * 100
def get_epsilon(seed, m_id):
sign = -1.0 if m_id % 2 == 0 else 1.0
return sign * rng(seed).standard_normal(PARAM_SIZE)
def __init__(self, set_type, objects, batch_s, scl, n_frames, c, wn_h,
wn_w, grav):
# Select object static and dynamic properties
if set_type in ['recons', 'decode']:
choices = ['rectangle', 'ellipse', 'vernier'
] if set_type == 'recons' else ['vernier']
x = rng().uniform(0, wn_w, (1, batch_s))
y = rng().uniform(0, wn_h, (1, batch_s))
vx = rng().uniform(-5 * scl, 5 * scl, (1, batch_s))
vy = rng().uniform(-5 * scl, 5 * scl, (1, batch_s))
self.ori = rng().uniform(0, 2 * np.pi, (1, batch_s))
self.sizx = rng().uniform(wn_w / 10, wn_w / 2,
(1, batch_s)) # max: /4
self.sizy = rng().uniform(wn_w / 10, wn_w / 2,
(1, batch_s)) # max: /4
self.colr = rng().randint(100, 255, (c, batch_s))
self.pop_t = rng().randint(0, n_frames // 2, (1, batch_s))
if set_type == 'sqm':
choices = ['vernier']
flow = (len(objects) % 2 - 0.5) * 8 * scl**2
x = np.ones((1, batch_s)) * wn_w // 2
y = np.ones((1, batch_s)) * wn_h // 2
vx = np.ones((1, batch_s)) * flow
vy = np.ones((1, batch_s)) * 0.0
self.ori = np.ones((1, batch_s)) * 0.0
self.sizx = np.ones((1, batch_s)) * wn_w / 5
self.sizy = np.ones((1, batch_s)) * wn_w / 4
self.colr = np.ones((c, batch_s), dtype=int) * 255
self.pop_t = np.ones((1, batch_s), dtype=int) * 3
self.shape = rng().choice(choices, (1, batch_s))
self.side = rng().randint(
0, 2, (1, batch_s)) if len(objects) == 0 else objects[0].side
self.side_ = 1 * self.side # evolving value for sqm (deep copy)
self.popped = np.array([[False] * batch_s]) # display stimulus or not
self.sizx[self.shape ==
'vernier'] /= 1.5 # verniers look better if not too wide
self.sizy[
self.shape ==
'vernier'] *= 2.0 # verniers appear smaller than other shapes
self.pos = np.vstack((x, y))
self.vel = np.vstack((vx, vy))
self.acc = np.array([[0.00] * batch_s, [grav] * batch_s])
# Generate patches to draw the shapes efficiently
self.patches = []
for b in range(batch_s):
max_s = int(2 * max(self.sizx[0, b], self.sizy[0, b]))
patch = np.zeros((max_s, max_s))
patch_0 = None
if self.shape[0, b] == 'ellipse':
center = (patch.shape[0] // 2, patch.shape[1] // 2)
radius = (self.sizy[0, b] / 2, self.sizx[0, b] / 2)
rr, cc = ellipse(center[0],
center[1],
radius[0],
radius[1],
shape=patch.shape)
patch[rr, cc] = 255
elif self.shape[0, b] == 'rectangle':
start = (int(max_s - self.sizy[0, b]) // 2,
int(max_s - self.sizx[0, b]) // 2)
extent = (int(self.sizy[0, b]), int(self.sizx[0, b]))
rr, cc = rectangle(start=start,
extent=extent,
shape=patch.shape)
patch[rr, cc] = 255
if self.shape[0, b] == 'vernier':
patch_0 = np.zeros((max_s, max_s)) # patch with zero offset
if set_type == 'sqm':
side = self.side[0, b]
v_siz_w = 1 + self.sizx[0, b] // 4
v_siz_h = 1 + self.sizy[0, b] // 3
v_off_w = (1 + (self.sizx[0, b] - v_siz_w) // 3) * 2
v_off_h = (
1 +
(self.sizy[0, b] - v_siz_h) // 6) * 2 + v_siz_h // 2
else:
side = rng().randint(
0, 2) if set_type == 'recons' else self.side[0, b]
v_siz_w = rng().uniform(1 + self.sizx[0, b] // 6,
1 + self.sizx[0, b] // 2)
v_siz_h = rng().uniform(1 + self.sizy[0, b] // 4,
1 + self.sizy[0, b] // 2)
v_off_w = rng().uniform(
1, 1 + (self.sizx[0, b] - v_siz_w) // 2) * 2
v_off_h = rng().uniform(
1 + v_siz_h // 2, 1 +
(self.sizy[0, b] - v_siz_h) // 2) * 2
if len(objects) > 0 and set_type == 'decode':
v_off_w = 0.0 # only one vernier (the first in the list) has an offset in decode mode
start1 = (int((max_s - v_off_h - v_siz_h) // 2),
int((max_s - v_off_w - v_siz_w) // 2))
start2 = (int((max_s + v_off_h - v_siz_h) // 2),
int((max_s + v_off_w - v_siz_w) // 2))
start01 = (int((max_s - v_off_h - v_siz_h) // 2),
int((max_s - 0 - v_siz_w) // 2))
start02 = (int((max_s + v_off_h - v_siz_h) // 2),
int((max_s + 0 - v_siz_w) // 2))
extent = (int(v_siz_h), int(v_siz_w))
rr1, cc1 = rectangle(start=start1,
extent=extent,
shape=patch.shape)
rr2, cc2 = rectangle(start=start2,
extent=extent,
shape=patch.shape)
rr01, cc01 = rectangle(start=start01,
extent=extent,
shape=patch.shape)
rr02, cc02 = rectangle(start=start02,
extent=extent,
shape=patch.shape)
patch[rr1, cc1] = 255
patch[rr2, cc2] = 255
patch_0[rr01, cc01] = 255
patch_0[rr02, cc02] = 255
patch = rotate(patch, self.ori[0, b]).astype(int)
to_add = [patch, np.fliplr(patch), patch_0]
self.patches.append(to_add)
try:
usr_num = int(usr_num)
if usr_num < 0:
raise ValueError()
except ValueError:
print("Your input was not an integer or between 4 and 10 Try Again.\n", file= sys.stderr)
else:
break
#########################################################################
# Following Creates User Specified N number of Uniformly Dist. Points #
arr_x = (rng(usr_num)*2)
arr_y = (rng(usr_num)*2)
hyp =(np.square(arr_x-1) + np.square(arr_y-1))
count = 0
for i in range(0,usr_num):
if hyp[i] <= 1:
count +=1
print("The approximation of pi with %d points is:" % usr_num)
#%%
plt.figure()
plt.title("Random Walk")
plt.xlabel("x")
plt.ylabel("y")
r2ave=np.zeros(num_steps)
x=np.zeros(num_steps)
y=np.zeros(num_steps)
for j in range(num_walkers):
i=0
while(i<num_steps-1):
x_step=rng()
y_step=rng()
x_step=2*(x_step>0.5)-1
y_step=2*(y_step>0.5)-1
x1=x[i]+x_step
y1=y[i]+y_step
print(x1,y1)
plt.plot(x,y)
plt.figure()
plt.title("Random Walk in Two Dimensions")
plt.xlabel("step number")
plt.ylabel("<r.r>")
# random_walk.py
# -------------------------------------------------------------------------
# Monte Carlo simulation of a two-dimensional random walk.
# -------------------------------------------------------------------------
import numpy as np
import matplotlib.pyplot as plt
from numpy.random import random as rng
num_steps = 500
x_step = rng(num_steps) > 0.5
y_step = rng(num_steps) > 0.5
x_step = 2 * x_step - 1
y_step = 2 * y_step - 1
x_position = np.cumsum(x_step)
y_position = np.cumsum(y_step)
plt.figure()
plt.plot(x_position, y_position)
plt.axis('equal')
# A more succinct alternative:
x = (2 * (rng(num_steps) > 0.5) - 1).cumsum()
y = (2 * (rng(num_steps) > 0.5) - 1).cumsum()
plt.figure()
plt.plot(x, y)
plt.axis('equal')
plt.show()
#%%Declaring constants
num_steps = 500
num_walkers = 1000
endpoints = np.zeros(num_walkers)
temp = np.zeros(num_walkers)
#%%Plotting
def plot2d():
plt.figure(title)
plt.xlabel('Distance in the x - direction')
plt.ylabel('Distance in the y - direction')
#%%Code for 1D
for j in range(num_walkers):
#initialization for number of elements in each step
x_step = rng(num_walkers); y_step = rng(num_walkers)
#Initialize the steps to be either zero or one
x_step = 2 * (x_step > 0.5) - 1
y_step = 2 * (y_step > 0.5) - 1
#Sum of each step
x = np.cumsum(x_step)
y = np.cumsum(y_step)
#Plotting of all steps in all direction
plot = x; title = "Ramdom walks in 1D"
plot2d(); plt.plot(plot, y)
#Calculations to plot the average
r2 = x**2 + y**2
Author: %(username)s (Python 3.4)
Created: 2018
Author: Stephan Goldberg
Description:
Random walk with step_size number of steps in x- and y-direction with the numpy random-function.
"""
import matplotlib.pyplot as plt
import numpy as np
from numpy.random import random as rng
num_steps = 10000
x_step = rng((num_steps, )) # array with num_steps elements between 0 and 1
y_step = rng((num_steps, ))
x_step[
x_step >= 0.5] = 1 # assigning the value 1 for numbers between 0.5 and 1
x_step[
x_step < 0.5] = -1 # assigning the value -1 for numbers between 0 and 0.5
y_step[y_step >= 0.5] = 1
y_step[y_step < 0.5] = -1
plt.plot(np.cumsum(x_step), np.cumsum(y_step))
ax = plt.gca()
ax.set_title(str(num_steps) + " random steps in x- and y-direction ", size=16)
