本文整理汇总了Python中random.Random.gauss方法的典型用法代码示例。如果您正苦于以下问题:Python Random.gauss方法的具体用法?Python Random.gauss怎么用?Python Random.gauss使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类random.Random
的用法示例。
在下文中一共展示了Random.gauss方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: run_statistical_batch_simulation
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def run_statistical_batch_simulation (sensitivity_test_levels):
r = Random ()
debugging.current_debug = debugging.error
debugging.tracing = False
boarding_functions = (reverse_block_loader, rotating_block_loader, random_loader, reverse_pyramid_loader, outside_in_loader)
planes = (S2, S1, M1, M2, L1, L2)
#adapters = (identity_adapter, even_odd_adapter, staggered_adapter)
adapters = [identity_adapter]
adjustable_parameters = (4.0, 15.0, 3.0, 7.0)
possibilities = [[1.0, 1.0, 1.0, d] for d in sensitivity_test_levels.keys ()] + [[1.0, 1.0, c, 1.0] for c in sensitivity_test_levels.keys ()] + \
[[1.0, b, 1.0, 1.0] for b in sensitivity_test_levels.keys ()] + [[a, 1.0, 1.0, 1.0] for a in sensitivity_test_levels.keys ()]
sensitivity_test_levels[1.0] = 'n'
possibility_description = lambda p: sensitivity_test_levels[p[0]] + sensitivity_test_levels[p[1]] + \
sensitivity_test_levels[p[2]] + sensitivity_test_levels[p[3]]
trials_per_configuration = 25
time_step = 1
for plane in planes:
for possibility in possibilities:
if len (possibilities) > 1:
current_file = file (plane.name + possibility_description (possibility), 'w')
else:
current_file = file (plane.name, 'w')
for a in adapters:
for b in boarding_functions:
current_file.write ("%s_%s\t" % (a.name, b.name))
stderr.write ("%s_%s\n" % (a.name, b.name))
current_file.write ("\n")
for trial in range (trials_per_configuration):
for a in adapters:
for b in boarding_functions:
immediate_result = str (simulation ( \
plane = plane_generator (plane, r, \
adjustable_parameters [0] * possibility [0], adjustable_parameters [0] * possibility [0] * 0.75, \
adjustable_parameters [1] * possibility [1], adjustable_parameters [2] * possibility [2]), \
boarding_function = a (b)).run ( \
passenger_selector_function = lambda passenger: True, \
boarding_delay_function = lambda: \
r.gauss (adjustable_parameters [3] * possibility [3], 1.0 * possibility [3]), \
time_step = time_step))
current_file.write (immediate_result + "\t")
stderr.write (immediate_result + "\n")
current_file.write ("\n")
current_file.flush ()
stderr.write ("\n")
current_file.close ()
示例2: run_single_simulation
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def run_single_simulation ():
r = Random ()
debugging.current_debug = debugging.very_verbose
debugging.tracing = True
debug (debugging.status, lambda: "Building aircraft model and passenger list...")
debug (debugging.output, lambda: "Simulation: boarding took %s units of time." % \
simulation (plane_generator (S2, r, \
lambda: r.gauss (7.0, 2.0), \
lambda: r.gauss (3.0, 0.8), \
lambda: r.gauss (3.5, 0.4), \
lambda: r.gauss (2.0, 0.3), \
3.0), \
boarding_function = staggered_adapter (reverse_block_loader)).run ( \
passenger_selector_function = lambda passenger: True, \
boarding_delay_function = lambda: r.gauss (7.0, 1.0), \
time_step = 0.5))
示例3: RandomUnitary
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def RandomUnitary(dim, seed=None):
'''Return a Haar unitary random matrix
dim : number of dimensions
seed : (optional) seed for rng
return : numpy array containing a Haar random unitary matrix'''
rng = Random(seed)
# Generate a random Gaussian matrix
M = numpy.zeros((dim,dim), dtype=complex)
for i in range(dim):
for j in range(dim):
M[i,j] = complex(rng.gauss(0,1), rng.gauss(0,1))
# Gram-Schmidt orthogonalisation
for i in range(dim):
v = M[:,i]
v /= vecnorm(v)
for j in range(i+1, dim):
u = M[:,j]
u -= proj(v,u)
return M
示例4: __init__
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def __init__(self, seed_):
self.seed = seed_
init_rand = Random(self.seed)
self.length = 1 + self.gauss(
init_rand.gauss(0, 1),
self.AVERAGE_LENGTH
)
self.mutation_rate = self.gauss(
init_rand.gauss(0, 1),
self.AVERAGE_MUTATION_RATE,
float
)
self.seeds = deque(maxlen=self.length)
self.genes = deque(maxlen=self.length)
for s in range(self.length):
self.seeds.append(init_rand.getrandbits(64))
self.genes.append(Random(self.seeds[-1]))
def __str__(self):
return str(id(self))
示例5: __init__
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
class Vizhash:
def __init__(self, data, square_size=16, n=16):
self.square_size = square_size
self.n = n
# Use the sha256 digest of the data to avoid collision on the
# random generator
seed = hashlib.sha256(data.encode("utf-8")).hexdigest()
self.random = Random(seed)
def explore(self, i, j, cases, colors):
"""Maze generation algorithm"""
cases[i][j] = True
cells = [(i - 1, j), (i, j + 1), (i + 1, j), (i, j - 1)]
self.random.shuffle(cells)
for (x, y) in cells:
if cases[x][y]: continue
color = copy.copy(colors[i][j])
for k in range(3):
color[k] += self.random.gauss(0, self.random.randint(3,20))
color[k] = int(max(0, min(color[k], 255)))
colors[x][y] = color
self.explore(x, y, cases, colors)
def identicon(self):
n = self.n
size = (self.square_size * n, self.square_size * n)
im = Image.new('RGB',size)
d = ImageDraw.Draw(im)
cases = [[False] * n + [True] for _ in range(n)] + [[True] * (n + 1)]
colors = [[None] * n for _ in range(n)]
i, j = self.random.randrange(n), self.random.randrange(n)
colors[i][j] = [
self.random.randint(0, 255),
self.random.randint(0, 255),
self.random.randint(0,255)
]
self.explore(i, j, cases, colors)
for i in range(n):
for j in range(n):
coordinates = [
i * self.square_size,
j * self.square_size,
(i + 1) * self.square_size,
(j + 1) * self.square_size
]
d.rectangle(coordinates, tuple(colors[i][j]))
return im
示例6: perturb
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def perturb(self,dtheta,seed=None):
'''Perturb the unitary by applying the sort of errors that we
may experience in a Reck scheme realisation.
Shifts each phase by a random amount drawn from a Gaussian with
width dtheta.
dtheta : amplitude of error in phase.
seed : (optional) seed for rng
return : None'''
rng=Random(seed)
for i in range(self.dim):
for j in range(self.dim):
d=rng.gauss(0,dtheta)
self.params[i,j]+=d
pass
示例7: RandomHamiltonian
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def RandomHamiltonian(dim, mu=0.5, sigma=0.05, seed=None):
'''Generate a random tridiagonal Hamiltonian. Diagonal terms are zero,
off-diagonal (coupling) terms have the mean and standard deviation
specified.
dim : number of dimensions
mu : mean of disorder (default 0.5)
sigma : standard deviation of disorder (default 0.05)
seed : (optional) random seed for rng
return : dim x dim complex array containing a randomised Hamiltonian'''
H=numpy.zeros((dim,dim),dtype=complex)
rng=Random(seed)
for i in range(dim-1):
x=rng.gauss(mu,sigma)
y=rng.gauss(mu,sigma)
H[i,i+1]=complex(x,y)
H[i+1,i]=complex(x,-y)
return H
示例8: RandomNumber
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
class RandomNumber(Feature):
""" Computes a random floating point feature value. """
def __init__(self, seed = None, mean = 0., std = 1.):
self.tag = None
seed = seed or time()
self.mean = mean
self.std = std
self.rng = Random(seed)
def compute(self, doc, chain, candidate, state):
""" Returns a random feature value """
return self.rng.gauss(self.mean, self.std)
@classmethod
def add_arguments(cls, p):
p.set_defaults(featurecls=cls)
return p
示例9: PowerMeterNoise
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def PowerMeterNoise(U,eps,losses=None,seed=None):
'''Return a unitary with noise applied as +-eps on power meter readings
but ideal phases. The total power in each column (i.e. input) is 1.
U : unitary to apply noise to
eps : error on power meter readings
losses : input and output losses
seed : (optional) seed for rng
return : (numpy array) unitary with noise applied'''
dim=U.shape[0] # assume square
amps=hamiltomo.abs2(U)
rng=Random(seed)
if losses is None:
losses=numpy.ones((2,dim))
V=numpy.zeros_like(U)
for i in range(dim):
for j in range(dim):
amp=numpy.sqrt(max(amps[i,j]*losses[0,j]*losses[1,i]+rng.gauss(0,eps),0))
phase=U[i,j]/abs(U[i,j])
V[i,j]=amp*phase
pre,V,post=hamiltomo.Normalise(V,eps=1e-10,maxiter=200)
return V
示例10: GaussianRandom
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
class GaussianRandom(ParameterGenerator):
"""Generate gaussian-distributed random numbers."""
@register_name
def __init__(self, center, width, seed=None):
"""Create a new gaussian random number generator.
Will generate random numbers about center with standard deviation width.
Args:
center: the centroid of the generated number cloud
width: the standard deviation of the generated number cloud
seed (optional): specify the seed for this random number generator.
"""
self.center = center
self.width = width
self.gen = Random()
if seed is not None:
self.gen.seed(seed)
def get(self):
"""Generate the next random value."""
return self.gen.gauss(self.center, self.width)
示例11: SimulatedSensor
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
class SimulatedSensor(Entity):
"""Class for simulated sensor."""
def __init__(self, name, unit, amp, mean, period, phase, fwhm, seed,
relative_to_epoch):
"""Init the class."""
self._name = name
self._unit = unit
self._amp = amp
self._mean = mean
self._period = period
self._phase = phase # phase in degrees
self._fwhm = fwhm
self._seed = seed
self._random = Random(seed) # A local seeded Random
self._start_time = (
datetime(1970, 1, 1, tzinfo=dt_util.UTC) if relative_to_epoch
else dt_util.utcnow()
)
self._relative_to_epoch = relative_to_epoch
self._state = None
def time_delta(self):
"""Return the time delta."""
dt0 = self._start_time
dt1 = dt_util.utcnow()
return dt1 - dt0
def signal_calc(self):
"""Calculate the signal."""
mean = self._mean
amp = self._amp
time_delta = self.time_delta().total_seconds()*1e6 # to milliseconds
period = self._period*1e6 # to milliseconds
fwhm = self._fwhm/2
phase = math.radians(self._phase)
if period == 0:
periodic = 0
else:
periodic = amp * (math.sin((2*math.pi*time_delta/period) + phase))
noise = self._random.gauss(mu=0, sigma=fwhm)
return round(mean + periodic + noise, 3)
async def async_update(self):
"""Update the sensor."""
self._state = self.signal_calc()
@property
def name(self):
"""Return the name of the sensor."""
return self._name
@property
def state(self):
"""Return the state of the sensor."""
return self._state
@property
def icon(self):
"""Icon to use in the frontend, if any."""
return ICON
@property
def unit_of_measurement(self):
"""Return the unit this state is expressed in."""
return self._unit
@property
def device_state_attributes(self):
"""Return other details about the sensor state."""
attr = {
'amplitude': self._amp,
'mean': self._mean,
'period': self._period,
'phase': self._phase,
'spread': self._fwhm,
'seed': self._seed,
'relative_to_epoch': self._relative_to_epoch,
}
return attr
示例12: noise
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def noise(self, sigma):
rand = Random()
self.vertices = [tuple(rand.gauss(x, sigma) for x in vertex) for vertex in self.vertices]
self.gen_list()
示例13: FileData
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def FileData(self, file):
from random import Random
r = Random(file)
length = abs(int(r.gauss(self.fileSize, self.fileSize/3)))
return bytes([r.randrange(256) for _ in range(length)])
示例14: Simulation
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
#.........这里部分代码省略.........
candidates = []
while not candidates:
tgt_age = int(sample_table(self.fertility_age_probs[index], self.rng)[0])
tgt_prev_min = 0; tgt_prev_max = 100
if self.params['use_parity']:
tgt_prev_min = int(sample_table(
self.fertility_parity_probs[(tgt_age-15)/5], self.rng)[0])
# effectively transform 5 into 5+
tgt_prev_max = tgt_prev_min if tgt_prev_min < 5 else 20
tgt_set = self.P.individuals_by_age(tgt_age, tgt_age)
candidates = [x
for x in tgt_set \
if x.sex == 1 \
and x.can_birth() \
and not x.with_parents \
and tgt_prev_min <= len(x.children) <= tgt_prev_max
]
return self.rng.choice(candidates)
def choose_partner(self, ind):
"""
Choose a partner for i_id, subject to parameter constraints.
:param ind: the first partner in the couple.
:type ind: Individual
:returns: partner if successful, otherwise None.
"""
mean_age = ind.age+self.params['partner_age_diff'] \
if ind.sex == 0 else ind.age-self.params['partner_age_diff']
tgt_age = 0
while tgt_age < self.params['min_partner_age']:
tgt_age = int(self.rng.gauss(mean_age, self.params['partner_age_sd']))
tgt_set = self.P.individuals_by_age(tgt_age, tgt_age)
candidates = [x \
for x in tgt_set \
if not x.partner \
and x.sex != ind.sex \
and x not in self.P.hh_members(ind)
]
# abort if no eligible partner exists
return None if candidates == [] else self.rng.choice(candidates)
def update_death_birth(self, t, ind, mother):
"""
Replace a dying individual with a newborn. If no individual to die
is passed, only a birth occurs; if no mother is passed, only a death
occurs.
:param t: the current time step.
:type t: int
:param ind: the individual to die.
:type ind: Individual
:returns: the new individual.
"""
if ind:
orphans = self.P.death(t, ind)
self.P.process_orphans(t, orphans, self.params['age_cutoffs'][-2], self.rng)
if mother:
sex = self.rng.randint(0, 1)
示例15: run_statistical_batch_simulation
# 需要导入模块: from random import Random [as 别名]
# 或者: from random.Random import gauss [as 别名]
def run_statistical_batch_simulation (planes, sensitivity_test_levels, how_many_adapters = 1, trial_count = 200):
r = Random ()
debugging.current_debug = debugging.error
debugging.tracing = False
boarding_functions = (reverse_block_loader, rotating_block_loader, random_loader, reverse_pyramid_loader, outside_in_loader)
adapters = [identity_adapter, even_odd_adapter, staggered_adapter][:how_many_adapters]
adjustable_parameters = (7.0, 3.0, 3.5, 2.0, 2.0, 0.8, 0.4, 0.3, 2.0, 7.0)
possibilities = [[1.0, 1.0, 1.0, 1.0, 1.0, d] for d in sensitivity_test_levels.keys ()] + \
[[1.0, 1.0, 1.0, 1.0, c, 1.0] for c in sensitivity_test_levels.keys ()] + \
[[1.0, 1.0, 1.0, b, 1.0, 1.0] for b in sensitivity_test_levels.keys ()] + \
[[1.0, 1.0, a, 1.0, 1.0, 1.0] for a in sensitivity_test_levels.keys ()] + \
[[1.0, x, 1.0, 1.0, 1.0, 1.0] for x in sensitivity_test_levels.keys ()] + \
[[y, 1.0, 1.0, 1.0, 1.0, 1.0] for y in sensitivity_test_levels.keys ()]
if len (possibilities) == 0:
possibilities = [[1.0] * 6]
sensitivity_test_levels = {1.0: 'n'}
else:
sensitivity_test_levels[1.0] = 'n'
possibility_description = lambda p: sensitivity_test_levels[p[0]] + sensitivity_test_levels[p[1]] + \
sensitivity_test_levels[p[2]] + sensitivity_test_levels[p[3]] + \
sensitivity_test_levels[p[4]] + sensitivity_test_levels[p[5]]
trials_per_configuration = trial_count
time_step = 1
for plane in planes:
for possibility in possibilities:
if len (possibilities) > 1:
current_file = file (plane.name + possibility_description (possibility), 'w')
else:
current_file = file (plane.name, 'w')
for a in adapters:
for b in boarding_functions:
current_file.write ("%s_%s\t" % (a.name, b.name))
debug (debugging.status, lambda: "%s_%s\n" % (a.name, b.name))
current_file.write ("\n")
for trial in range (trials_per_configuration):
for a in adapters:
for b in boarding_functions:
immediate_result = str (simulation ( \
plane = plane_generator (plane, r, \
lambda: r.gauss (adjustable_parameters [0] * possibility [0], adjustable_parameters [4] * possibility [0]), \
lambda: r.gauss (adjustable_parameters [1] * possibility [1], adjustable_parameters [5] * possibility [1]), \
lambda: r.gauss (adjustable_parameters [2] * possibility [2], adjustable_parameters [6] * possibility [2]), \
lambda: r.gauss (adjustable_parameters [3] * possibility [3], adjustable_parameters [7] * possibility [3]), \
adjustable_parameters [8] * possibility [4]), \
boarding_function = a (b)).run ( \
passenger_selector_function = lambda passenger: True, \
boarding_delay_function = lambda: \
r.gauss (adjustable_parameters [9] * possibility [5], possibility [5]), \
time_step = time_step))
current_file.write (immediate_result + "\t")
debug (debugging.status, lambda: immediate_result + "\n")
current_file.write ("\n")
current_file.flush ()
debug (debugging.status, lambda: "\n")
current_file.close ()