def sampleEllipticity(size, sigma_e=0.3):
"""Draw ellipticity samples from the Rayleigh distribution.
Samples from the Rayleigh distribution of width sigma_e, but makes sure
that no ellipticities with |epsilon| >= 1 are created by resampling the
outliers.
The orientation of the sample is uniform in the interval [0 .. pi).
Args:
size: A positive integer.
sigma_e: The width parameter/mode of the Rayleigh distribution
Returns:
A complex numpy array of given size.
"""
e = rayleigh(sigma_e, size)
# make sure no outliers are created
# this effectively tightens the distribution
mask = (e >= 1)
while sum(mask) > 0:
e[mask] = rayleigh(sigma_e, sum(mask))
mask = (e >= 1)
# sample unformly random orientation and create complex ellipticity
phi = pi*random(size)
return e*(cos(2*phi) + 1j * sin(2*phi))
def task_generation(num_intervals, num_periods, num_intervals_periods,
mode_value, l_demands, p_d_short, cf_max):
# generation - demand
demand = r.choice(l_demands)
demand = int(demand * 1000)
# generation - duration
duration = max(1, int(random.rayleigh(mode_value, 1)[0]))
# generation - preferred start time
p_start = max(
int(np.random.choice(a=num_periods, size=1, p=p_d_short)[0]) *
num_intervals_periods +
r.randint(-num_intervals_periods + 1, num_intervals_periods), 0)
p_start = min(p_start, num_intervals - 1)
# generation - earliest starting time
# e_start = r.randint(-duration + 1, p_start)
e_start = 0
# generation - latest finish time
# l_finish = r.randint(p_start + duration, num_intervals - 1 + duration)
l_finish = num_intervals - 1 + duration
# generation - care factor
# care_f = int(r.choice([i for i in range(1, cf_max + 1)]))
care_f = r.randint(1, cf_max + 1)
return demand, duration, p_start, e_start, l_finish, care_f
def rat_path(environment,
t=15,
delta_t=0.1,
d_from_walls=2,
v_scale=1.4,
r_mu=0,
r_std=5.7,
perim_v_reduc=0.25,
perim_r_change=np.pi / 2):
assert environment.agent.radius is not None
assert environment.agent.radius < d_from_walls
assert len(environment.rooms) > 0
n_samples = int(t // delta_t)
v_scale *= delta_t
r_mu *= delta_t
r_std *= delta_t
# Path data to return
positions = np.zeros((n_samples, 2), dtype=np.float32)
directions = np.zeros((n_samples), dtype=np.float32)
movements = np.zeros((n_samples), dtype=np.float32)
rotations = np.zeros((n_samples), dtype=np.float32)
# Initialization
positions[0], directions[0] = start_state(environment, d_from_walls)
random_rotations = normal(r_mu, r_std, size=n_samples)
random_movements = rayleigh(v_scale, size=n_samples)
movement = random_movements[0]
for step in range(1, n_samples):
closest_wall_d, closest_wall_r = closest_wall(environment,
positions[step - 1],
directions[step - 1])
if closest_wall_d < d_from_walls and np.abs(
closest_wall_r) < perim_r_change:
sign = np.sign(closest_wall_r) if closest_wall_r != 0 else 1
rotation = sign * (perim_r_change -
np.abs(closest_wall_r)) + random_rotations[step]
movement = (1 - perim_v_reduc) * movement
else:
rotation = random_rotations[step]
movement = random_movements[step]
direction = dir_angle(directions[step - 1] + rotation)
velocity = movement * np.array([np.cos(direction), np.sin(direction)])
new_pos = positions[step - 1] + velocity
positions[step] = new_pos
directions[step] = direction
movements[step] = movement
rotations[step] = rotation
return {
'positions': positions,
'directions': directions,
'movements': movements,
'rotations': rotations
}
def time_to_mutation_rate(tree):
if not hasattr(GC, "NUMPY_SEEDED"):
from numpy.random import seed as numpy_seed
numpy_seed(seed=GC.random_number_seed)
GC.random_number_seed += 1
GC.NUMPY_SEEDED = True
t = read_tree_newick(tree)
for node in t.traverse_preorder():
if node.edge_length is not None:
node.edge_length *= rayleigh(scale=GC.tree_rate_scale)
return str(t)
def rayleigh_noise(image,var=0.1):
'''
添加瑞利噪声
var : 方差
'''
image = array(image/255, dtype=float)
# 瑞利分布
noise = rayleigh(var ** 0.5, image.shape)
out = image + noise
if out.min() < 0:
low_clip = -1.
else:
low_clip = 0.
out = clip(out, low_clip, 1.0)
out = uint8(out*255)
return out
def noisy_path(environment,
n_samples=20,
m_scale=0.5,
r_scale=5,
min_d_wall=2,
r_from_walls=np.pi / 1.5):
assert environment.agent.radius is not None
assert environment.agent.radius < min_d_wall
assert len(environment.rooms) > 0
p, d = start_state(environment, min_d_wall + 1)
positions = [p]
directions = [d]
movements = [0]
rotations = [0]
for _ in range(1, n_samples):
r = (beta(r_scale, r_scale) - 0.5) * 2 * np.pi
m = rayleigh(m_scale)
d_prop = dir_angle(d + r)
p_prop = p + m * np.array([
np.cos(d_prop), -np.sin(d_prop)
]) # -sin because of lefthand OpenGL coordinates
d_wall, r_wall = closest_wall(environment, p_prop, d_prop)
if d_wall < min_d_wall:
m = 0
sign = np.sign(r_wall) if r_wall != 0 else 1
r = sign * (r_from_walls - np.abs(r_wall))
d = dir_angle(d + r)
else:
d = d_prop
p = p_prop
positions.append(p)
directions.append(d)
movements.append(m)
rotations.append(r)
return {
'positions': np.stack(positions).astype(np.float32),
'directions': np.array(directions, dtype=np.float32),
'movements': np.array(movements, dtype=np.float32),
'rotations': np.array(rotations, dtype=np.float32)
}
x = np.array([x1]) y = np.array([y1]) z = np.array([z1]) vx = np.array([vx1]) vy = np.array([vy1]) vz = np.array([vz1]) mass=np.array([muB*MB]) name=np.array(['S2']) #the central object's name is S1 ####################################################################################################################### # (2) Second stage # Generate a population or orbiting test particles # (2)(a) 1st, generate population of orbital elements #eccentricities e=ran.rayleigh(0.01,N_samples) #inclinations I=ran.rayleigh(0.01*180.0/np.pi,N_samples) #masses (test particles) m=np.zeros(N_samples) #semimajor axes #a=10.0**(ran.random_sample(N_samples)*(np.log10(a_max)-np.log10(a_min)) + np.log10(a_min)) a=10.0**(np.arange(0,1.0,1.0/N_samples)*(np.log10(a_max)-np.log10(a_min)) + np.log10(a_min)) #longitudes or pericenter omega=ran.random_sample(N_samples)*180.0 #longitudes of ascending nodes Omega=ran.random_sample(N_samples)*180.0 #mean anomalies MeanAnom = ran.random_sample(N_samples)*180.0 # (2)(b) 2nd, generate a list of names for the bodies
plt.show()
'''Relation Between Poisson and Exponential Distribution
Poisson distribution deals with number of occurences of an event in a time period whereas
exponential distribution deals with the time between these events.'''
print('Chi Square Distribution')
'''Chi Square distribution is used as a basis to verify the hypothesis.'''
x = random.chisquare(df=2, size=(2, 3))
print(x)
sns.distplot(random.chisquare(df=1, size=1000), hist=False)
plt.show()
print('Rayleigh Distribution')
'''Rayleigh distribution is used in signal processing.'''
x = random.rayleigh(scale=2, size=(2, 3))
print(x)
sns.distplot(random.rayleigh(size=1000), hist=False)
plt.show()
'''Similarity Between Rayleigh and Chi Square Distribution
At unit stddev the and 2 degrees of freedom rayleigh and
chi square represent the same distributions.'''
print('Pareto Distribution')
'''A distribution following Pareto's law
i.e. 80-20 distribution (20% factors cause 80% outcome).'''
sns.distplot(random.pareto(a=2, size=1000), kde=False)
plt.show()
print('Zipf Distribution')
'''Zipf's Law: In a collection the nth common term is 1/n times of the most common term.
E.g. 5th common word in english has occurs nearly 1/5th times as of the most used word.'''
def Rayleigh(scale, size):
Amplitude = npr.rayleigh(scale, size)
return Amplitude
def tasks():
no_intervals = 144
no_tasks = 10
no_intervals_periods = int(no_intervals / 48)
p_d = genfromtxt('probability.csv', delimiter=',').tolist()
sum_t = sum(p_d[0])
p_d_short = [p / sum_t for p in p_d[0]]
period_options = [i for i in range(48)]
l_demands = [1.5, 2.3, 3.5, 6, 0.008, 1.1, 2.4, 0.6, 0.5, 0.004, 0.002, 4, 0.6, 0.1, 0.015, 2.4, 0.05, 0.12, 1.2,
2.2,
0.7, 1.7, 2.1, 0.0015, 0.09, 0.05, 0.01, 0.056, 0.072, 0.65, 2, 1.5, 0.1, 2.4, 1.2, 2.4, 1.2, 1, 0.3,
2.4,
1.2, 0.075, 0.052, 0.015, 0.045, 0.011, 0.0625, 0.15, 1, 0.005, 1.1, 5, 0.55, 0.1, 0.14, 0.038, 0.035,
0.068, 0.072, 0.093, 0.148, 0.7, 0.3, 1, 0.08, 0.12, 0.015, 6, 0.02, 0.075, 0.055, 0.03, 0.13, 0.05,
0.21,
0.1, 0.005, 1, 3.6, 1.2, 0.9, 1.2, 1.2, 0.05, 0.06, 0.9, 0.4, 2.4, 0.35, 2]
# I meant mean value is 40 minutes
mean_value = 40.0 / (24.0 * 60.0 / no_intervals)
mode_value = sqrt(2 / pi) * mean_value
# task details
preferred_starts = []
earliest_starts = []
latest_ends = []
durations = []
demands = []
care_factors = []
predecessors = []
successors = []
prec_delays = []
aggregated_loads = [0] * no_intervals
for counter_j in range(no_tasks):
# job consumption per hour
demand = r.choice(l_demands)
demands.append(int(demand * 1000))
# job duration
duration = int(random.rayleigh(mode_value, 1)[0])
while duration == 0:
duration = int(random.rayleigh(mode_value, 1)[0])
durations.append(duration)
# job preferred start time
middle_point = int(np.random.choice(period_options, 1, p=p_d_short)[0] *
no_intervals_periods + r.randint(0, 3))
p_start = (middle_point - int(duration / 2)) % no_intervals
while p_start + duration - 1 >= no_intervals:
middle_point = int(
np.random.choice(period_options, 1, p=p_d_short)[0] * no_intervals_periods + r.randint(0, 3))
p_start = (middle_point - int(duration / 2)) % no_intervals
preferred_starts.append(p_start)
# job earliest starting time
# e_start = r.choice([i for i in range(-duration + 1, p_start + 1)])
e_start = 0
earliest_starts.append(e_start)
# job latest finish time
# l_finish = r.choice([i for i in range(p_start - duration + 1, num_intervals - 1 + duration)])
l_finish = no_intervals - 1
latest_ends.append(l_finish)
# job care factor
care_f = round(r.random(), 1)
if care_f == 0:
care_f = 0.01
care_factors.append(int(care_f * 10))
if r.choice([True, False]) and counter_j > 0:
successors.append(counter_j + 1)
id_predecessor_set = [i for i in range(counter_j)]
id_predecessor = r.choice(id_predecessor_set)
predecessors.append(id_predecessor + 1)
delay = 0 if durations[id_predecessor] + duration >= no_intervals \
else r.randint(0, no_intervals - durations[id_predecessor] - duration - 1)
# delay = 144
prec_delays.append(delay)
for d in range(duration):
aggregated_loads[p_start + d] += demand
# if p_start + k <= num_intervals - 1:
# aggregated_loads[p_start + k] += demand
# else:
# aggregated_loads[p_start + k - num_intervals] += demand
no_precedences = len(predecessors)
maximum_demand = sum(demands)
return no_intervals, preferred_starts, no_tasks, earliest_starts, latest_ends, durations, demands, care_factors, \
no_precedences, predecessors, successors, prec_delays, maximum_demand, aggregated_loads
def new(self):
t = rn.rayleigh(self.sigma, 1)[0]
while t < 0:
t = rn.rayleigh(self.sigma, 1)[0]
return t
def np_rayleigh_distribution():
x = random.rayleigh(scale=2, size=(2, 3))
print(x)
sns.distplot(random.rayleigh(size=1000), hist=False)
plt.show()
2. Physical sciences: To model wind speed, wave heights and sound/light radiation.
3. Engineering: To measure the lifetime of an object, where the lifetime depends on the object’s age.
For example: resistors, transformers, and capacitors in aircraft radar sets.
4. Medical: Imaging science, to model noise variance in magnetic resonance imaging.
numpy.random.rayleigh() ke arguments:
1. scale: (Standard deviation defualt 1.0) Isse kitna flat distribution hoga ye decide karte hain.
2. size: Matrix or array ka shape kitna rakhoge.
'''
import numpy.random as r
import matplotlib.pyplot as plt
import seaborn as sns
ray = r.rayleigh(size=(10))
# print('\nRay: ',ray)
# seaborn
sns.distplot(r.rayleigh(size=(100)), hist=False, label='1.0')
sns.distplot(r.rayleigh(scale=2.0, size=(100)), hist=False, label='2.0')
sns.distplot(r.rayleigh(scale=3.0, size=(100)), hist=False, label='3.0')
sns.distplot(r.rayleigh(scale=4.0, size=(100)), hist=False, label='4.0')
# plt
plt.xlabel('Rang of x')
# plt.xlim(0, 10)
# plt.ylim(0,0.5)
plt.ylabel('Range of y')
plt.title('Rayleigh Distribution')
plt.show()
# rayleigh distribution used in signal processing. # it has two parameters. # scale - (standard deviation) decides how flat the distribution will be (default 1.0). # size - shape of returned array. from numpy import random import matplotlib.pyplot as plt import seaborn as sns arr1 = random.rayleigh(scale=2, size=10) print(arr1) sns.distplot(arr1, hist=False) plt.show() # at unit standard deviation of rayleigh and df=2 in chi square represents same distribution
def task_generation():
p_d = genfromtxt('inputs/probability.csv', delimiter=',', dtype="float")
p_d_short = [int(p) for p in p_d[0]]
sum_t = sum(p_d_short)
p_d_short = [p / sum_t for p in p_d_short]
l_demands = genfromtxt('inputs/demands_list.csv',
delimiter=',',
dtype="float")
# I meant mean value is 40 minutes
mean_value = 40.0 / (24.0 * 60.0 / no_intervals)
mode_value = sqrt(2 / pi) * mean_value
# task details
preferred_starts = []
earliest_starts = []
latest_ends = []
durations = []
demands = []
care_factors = []
predecessors = []
successors = []
prec_delays = []
aggregated_loads = [0] * no_intervals
for counter_j in range(no_tasks):
# job consumption per hour
demand = r.choice(l_demands)
demand = int(demand * 1000)
demands.append(demand)
# job duration
duration = max(1, int(random.rayleigh(mode_value, 1)[0]))
# while duration == 0:
# duration = int(random.rayleigh(mode_value, 1)[0])
durations.append(duration)
# job preferred start time
p_start = no_intervals + 1
while p_start + duration - 1 >= no_intervals - 1 or p_start < 0:
middle_point = int(
np.random.choice(a=no_periods, size=1, p=p_d_short)[0] *
no_intervals_periods +
np.random.random_integers(low=-2, high=2))
p_start = middle_point - int(duration / 2)
preferred_starts.append(p_start)
# job earliest starting time
e_start = 0
# e_start = r.randint(0, max(p_start - 1, 0))
earliest_starts.append(e_start)
# job latest finish time
l_finish = no_intervals - 1
# l_finish = r.randint(p_start + duration, min(no_intervals - 1, p_start + duration))
latest_ends.append(l_finish)
# job care factor
care_f = int(r.choice([i for i in range(care_f_max + 1)]))
care_factors.append(care_f)
if r.choice([True, False]) and counter_j > 0:
# task predecessor
id_predecessor_set = [i for i in range(counter_j)]
id_predecessor = r.choice(id_predecessor_set)
while preferred_starts[id_predecessor] + durations[id_predecessor] - 1 >= preferred_starts[counter_j] \
and len(id_predecessor_set) > 0:
id_predecessor_set.remove(id_predecessor)
if len(id_predecessor_set) > 0:
id_predecessor = r.choice(id_predecessor_set)
if len(id_predecessor_set) > 0:
predecessors.append(int(id_predecessor))
successors.append(counter_j)
# predecessing delay
delay = 0
if not durations[
id_predecessor] + duration - 1 == no_intervals - 1:
delay = r.choice([
i for i in range(no_intervals + 1 - duration -
durations[id_predecessor])
])
prec_delays.append(int(delay))
for d in range(duration):
aggregated_loads[p_start + d] += demand
no_precedences = len(predecessors)
maximum_demand = max(demands) * max_demand_multiplier
print(" --- Household made ---")
return no_intervals, preferred_starts, no_tasks, earliest_starts, latest_ends, durations, demands, care_factors, \
no_precedences, predecessors, successors, prec_delays, maximum_demand, aggregated_loads
def g(): #constants q = random.rayleigh(12.5) return q
def create():
p_d = P.prob
p_d_short = p_d[1]
l_demands = P.devices
p_d_long = []
for i in list(range(len(p_d_short) - 1)):
for j in list(range(P.interval)):
p_d_long.append(p_d_short[i] +
(p_d_short[i + 1] - p_d_short[i]) / P.interval * j)
# i should be 46 at this time
i = len(p_d_short) - 2 # make sure i is 46
for j in range(P.interval):
p_d_long.append(p_d_short[i + 1] +
(p_d_short[i + 1] - p_d_short[i]) / P.interval * j)
p_d_min = p_d_long[0] - p_d_long[0] / 3
p_d_max = p_d_long[P.no_intervals_day - 1]
# I meant mean value is 40 minutes
mean_value = 40.0 / (24.0 * 60.0 / P.no_intervals_day)
mode_value = sqrt(2 / pi) * mean_value
community = []
attributes = [
"noh", "name", "demand", "estart", "pstart", "lfinish", "dur", "caf",
"astart", "predecessor", "max-succeeding-delay"
]
s_community = str(attributes)[1:-1].replace("'", "").replace(" ",
"") + "\r\n"
for counter_h in range(P.no_houses):
# household instance
# household = H.Household()
# household.name = "household" + str(counter_h)
no_jobs = r.randint(P.no_jobs_min, P.no_jobs_max)
# household.no_jobs = no_jobs + 1
household = []
s_household = ""
for counter_j in range(no_jobs):
job = dict()
# job name
name = str(counter_j)
# job consumption per hour
demand = r.choice(l_demands)
# job duration
seed = r.uniform(p_d_min, p_d_max)
middle_point = bisect.bisect(p_d_long, seed)
duration = int(random.rayleigh(mode_value, 1)[0])
while duration == 0:
duration = int(random.rayleigh(mode_value, 1)[0])
# job preferred start time
p_start = (middle_point - int(duration / 2)) % P.no_intervals_day
# if p_start < 0:
# p_start += P.no_intervals_day - 1
# job earliest starting time
e_start = r.choice([i for i in range(-duration + 1, p_start + 1)])
e_start = 0
# job latest finish time
l_finish = r.choice([
i for i in range(p_start - duration + 1, P.no_intervals_day -
1 + duration)
])
l_finish = P.no_intervals_day - 1
# l_finish = p_start - 2
# job care factor
care_f = round(r.random(), 1)
if care_f == 0:
care_f = 0.01
# care_f = 0
# job instance
job['name'] = name
job['demand'] = demand
job['estart'] = e_start
job['pstart'] = p_start
job['lfinish'] = l_finish
job['dur'] = duration
job['caf'] = care_f
job['astart'] = p_start
s_household += str(counter_h) + "," + name + "," + str(demand) + "," + str(e_start) + "," \
+ str(p_start) + "," + str(l_finish) + "," + str(duration) + "," + str(care_f) + "," \
+ str(p_start)
if r.choice([True, False]) and counter_j > 0:
id_predecessor_set = [i for i in range(counter_j)]
id_predecessor = r.choice(id_predecessor_set)
job['predecessor'] = id_predecessor
s_household += "," + str(id_predecessor)
delay = 0 if household[id_predecessor]['dur'] + job['dur'] >= P.no_intervals_day \
else r.randint(0, P.no_intervals_day - household[id_predecessor]['dur'] - job['dur'] - 1)
# delay = 144
job['max-succeeding-delay'] = delay
s_household += "," + str(delay)
# while household[id_predecessor]['pstart'] - job['pstart']:
# id_predecessor_set.remove(id_predecessor)
# if len(id_predecessor_set) > 0:
# id_predecessor = r.choice(id_predecessor_set)
# else:
# break
#
# if len(id_predecessor_set) > 0:
# job['predecessor'] = id_predecessor
# delay = 0 if household[id_predecessor]['dur'] + job['dur'] >= P.no_intervals_day \
# else r.randint(0, P.no_intervals_day - household[id_predecessor]['dur'] - job['dur'] - 1)
# job['max-succeeding-delay'] = delay
# s_household += "," + str(id_predecessor) + "," + str(delay)
# print (job)
# job added to the household
household.append(job)
s_household += "\r\n"
# household added to the community
community.append(household)
s_community += s_household
# community.aggregated_loads = [x + y for x, y in zip(community.aggregated_loads, household.aggregated_loads)]
with open(P.jobs_file, 'w') as output_file:
output_file.write(s_community)
print("Job data is generated and saved to {}.".format(P.jobs_file))
return community
# create()
def pop3(p1, p2, n):
return ra.rayleigh(p1, n)
from numpy import random import matplotlib.pyplot as plt import seaborn as sns x = random.rayleigh(scale=2, size=(2, 3)) print(x) sns.displot(x, hist=False, label="rayliegh") plt.show()
def next(self):
t = rn.rayleigh(fabs(self.sigma), 1)[0]
while t < 0:
t = rn.rayleigh(fabs(self.sigma), 1)[0]
return t
demands = []
care_factors = []
predecessors = []
successors = []
prec_delays = []
aggregated_loads = [0] * no_intervals
for counter_j in range(no_tasks):
# job consumption per hour
demand = r.choice(l_demands)
demand = int(demand * 1000)
demands.append(demand)
# job duration
duration = max(1, int(random.rayleigh(mode_value, 1)[0]))
durations.append(duration)
# job preferred start time
p_start = no_intervals + 1
while p_start + duration - 1 >= no_intervals - 1 or p_start < 0:
middle_point = int(np.random.choice(a=no_periods, size=1, p=p_d_short)[0]
* no_intervals_periods
+ np.random.random_integers(low=-2, high=2))
p_start = middle_point - int(duration / 2)
preferred_starts.append(p_start)
# job earliest starting time
e_start = 0
earliest_starts.append(e_start)
sigma_distribution = np.subtract(sigma_distribution, sigma_distribution[0])
sigma_distribution = np.divide(sigma_distribution, sigma_distribution[-1])
a_func_sigma = intp.interp1d(sigma_distribution, a_distribution)
midpoints = np.linspace(0., 1., number + 1)
for i in range(number):
midpoints[i] = (midpoints[i] + midpoints[i + 1]) / 2.0
a_to_start_out = a_func_sigma(midpoints)
#s = 'Initial_aes/initial_a_sim1_' + str(number) + '.txt'
#np.savetxt(s,np.transpose(a_to_start_out))
#Now, for the rest of the orbital elements:
eccentricity = rand.rayleigh(scale=e_0, size=number)
inclination = rand.rayleigh(scale=i_0, size=number)
capital_omega = rand.random(number)
capital_omega = np.multiply(capital_omega, 2. * 180.) #np.pi)
omega = rand.random(number)
omega = np.multiply(omega, 2. * 180.) #np.pi)
mean_anomaly = rand.random(number)
mean_anomaly = np.multiply(mean_anomaly, 2. * 180.) #np.pi)
particle_number = 2
f = open('big.in', 'w')
f.write(')O+_06 Big-body initial data\n')
f.write(') seed value: ' + str(seed) + ', cusp: ' + cusp + '\n')
f.write(')----------------------------------------\n')
def rayleigh(size, params):
try:
return random.rayleigh(params['scale'], size)
except ValueError as e:
exit(e)
