Python Random.gauss方法代码示例

# 需要导入模块: 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 ()

# 需要导入模块: 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))

# 需要导入模块: 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

# 需要导入模块: 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))

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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

# 需要导入模块: 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)

# 需要导入模块: 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

# 需要导入模块: 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()

# 需要导入模块: 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)])

# 需要导入模块: 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)

# 需要导入模块: 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 ()