Python random.lognormvariate函数代码示例

    def random_year(self):
        s = random.lognormvariate(self.stocks_mean, self.stocks_stddev) - 1
        s = Decimal(s)

        b = random.lognormvariate(self.bonds_mean, self.bonds_stddev) - 1
        b = Decimal(b)
        return AnnualChange(year=self.year, stocks=s, bonds=b, inflation=Decimal(0))

 def sample(self):
     result = self._scale * random.lognormvariate(self._mu, self._sigma)
     if self._maximum is not None and result > self._maximum:
         for _ignore in range(10):
             result = self._scale * random.lognormvariate(self._mu, self._sigma)
             if result <= self._maximum:
                 break
         else:
             raise ValueError("Unable to generate LogNormalDistribution sample within required range")
     return result

	def produceReads(self,readDensity = 1,read_length = 50):
		"""
		Produces uniform reads by walking iteratively over self.regions
		"""
		
		mRNA = self.getTotalmRNA()
		spanning_length = self.getRegionSpanningLength()
		n = spanning_length['total'] - read_length + 1
		
		j = 0
		k = 0
		
		for i in range(n):
			#  "alpha is playing the role of k and beta is playing the role of theta"
			dd = max(0,int(round(random.lognormvariate(math.log(readDensity),0.5))))# Notice this is NOT a binomial distribution!!
			
			for d in range(dd):
				sequence = mRNA[i:i+read_length]
				
				if(random.randint(0,1) == 0):
					strand = 0
				else:
					strand = 16
				flag = strand + 0
				
				print "read_"+str(j)+"."+str(i)+"."+str(d)+"\t"+str(flag)+"\t"+self.chromosome+"\t"+str(self.regions[j].start + k)+"\t60\t"+self.getMappingString(read_length,j,k)+"\t*\t0\t0\t"+str(sequence.upper())+"\t*"
			
			spanning_length['iter'][j] -= 1
			if(k >= self.regions[j].getSpanningLength()-1):
				j += 1
				k = 0
			else:
				k += 1

    async def create_server(self, worker, protocol_factory, address=None,
                            sockets=None, idx=0):
        '''Create the Server which will listen for requests.

        :return: a :class:`.TcpServer`.
        '''
        cfg = self.cfg
        max_requests = cfg.max_requests
        if max_requests:
            max_requests = int(lognormvariate(log(max_requests), 0.2))
        server = self.server_factory(
            protocol_factory,
            loop=worker._loop,
            max_requests=max_requests,
            keep_alive=cfg.keep_alive,
            name=self.name,
            logger=self.logger,
            server_software=cfg.server_software,
            cfg=cfg,
            idx=idx
        )
        for event in ('connection_made', 'pre_request', 'post_request',
                      'connection_lost'):
            callback = getattr(cfg, event)
            if callback != pass_through:
                server.event(event).bind(callback)
        await server.start_serving(
            sockets=sockets,
            address=address,
            backlog=cfg.backlog,
            sslcontext=self.sslcontext()
        )
        return server

    def test_lognormal(self):
        """Statistics.lognormal test"""
        import random
        import Biskit.gnuplot as gnuplot
        import Biskit.hist as H

        cr = []
        for i in range( 10000 ):
            ## Some random values drawn from the same lognormal distribution 

            alpha = 1.5
            beta = .7
            x = 10.

            R = [ random.lognormvariate( alpha, beta ) for j in range( 10 ) ]

            cr += [ logConfidence( x, R )[0] ]


        ca = logArea( x, alpha, beta )

        if self.local:
            gnuplot.plot( H.density( N.array(cr) - ca, 100 ) )

            globals().update( locals() )

        self.assertAlmostEqual( ca,  0.86877651432955771, 7)

 def find_distributions(self, n, c, source):
     """
     Finds distribution functions
     """
     if source[c][n] == 'NoArrivals':
         return lambda : 'Inf'
     if source[c][n][0] == 'Uniform':
         return lambda : uniform(source[c][n][1], source[c][n][2])
     if source[c][n][0] == 'Deterministic':
         return lambda : source[c][n][1]
     if source[c][n][0] == 'Triangular':
         return lambda : triangular(source[c][n][1], source[c][n][2], source[c][n][3])
     if source[c][n][0] == 'Exponential':
         return lambda : expovariate(source[c][n][1])
     if source[c][n][0] == 'Gamma':
         return lambda : gammavariate(source[c][n][1], source[c][n][2])
     if source[c][n][0] == 'Lognormal':
         return lambda : lognormvariate(source[c][n][1], source[c][n][2])
     if source[c][n][0] == 'Weibull':
         return lambda : weibullvariate(source[c][n][1], source[c][n][2])
     if source[c][n][0] == 'Custom':
         P, V = zip(*self.parameters[source[c][n][1]])
         probs = list(P)
         cum_probs = [sum(probs[0:i+1]) for i in range(len(probs))]
         values = list(V)
         return lambda : self.custom_pdf(cum_probs, values)
     if source[c][n][0] == 'Empirical':
         if isinstance(source[c][n][1], str):
             empirical_dist = self.import_empirical_dist(source[c][n][1])
             return lambda : choice(empirical_dist)
         return lambda : choice(source[c][n][1])
     return False

    def _trigger_func(self, stream_id):

        while True:

            length = random.randint(1,20)

            c = [random.uniform(0.0,75.0)  for i in xrange(length)]

            t = [random.uniform(-1.7, 21.0) for i in xrange(length)]

            p = [random.lognormvariate(1,2) for i in xrange(length)]

            lat = [random.uniform(-90.0, 90.0) for i in xrange(length)]

            lon = [random.uniform(0.0, 360.0) for i in xrange(length)]

            tvar = [self.last_time + i for i in xrange(1,length+1)]

            self.last_time = max(tvar)

            ctd_packet = ctd_stream_packet(stream_id=stream_id,
                c=c, t=t, p=p, lat=lat, lon=lon, time=tvar)

            log.warn('SimpleCtdPublisher sending %d values!' % length)
            self.publisher.publish(ctd_packet)

            time.sleep(2.0)

def generateLogNormalRVs(mu, sigma, count, histDelta):

    rVec = numpy.zeros(count)
    rMax = 0.
    for ii in range(count):
        rVec[ii] = random.lognormvariate(mu, sigma)
        if (rMax < rVec[ii]):
            rMax = rVec[ii]

    # build the histogram ...
    deltaR = histDelta
    rMinHist = 0.
    rMaxHist = rMax + 2. * deltaR
    numBins = (rMaxHist - rMinHist) / deltaR
    numBins = int(numBins) + 2

    rHist = numpy.zeros(numBins)

    # print ' making histogram ... ', deltaR, rMaxHist
    for ii in range(count):
        iBin = int((rVec[ii] - rMinHist) / deltaR + 0.0001)
        rHist[iBin] += 1

    for iBin in range(numBins):
        rHist[iBin] /= float(count)

    return (rVec, rHist)

    def find_service_time(self, n, c):
        """
        Finds the service time function
        """

        if self.mu[c][n][0] == 'Uniform':
            return lambda : uniform(self.mu[c][n][1], self.mu[c][n][2])
        if self.mu[c][n][0] == 'Deterministic':
            return lambda : self.mu[c][n][1]
        if self.mu[c][n][0] == 'Triangular':
            return lambda : triangular(self.mu[c][n][1], self.mu[c][n][2], self.mu[c][n][3])
        if self.mu[c][n][0] == 'Exponential':
            return lambda : expovariate(self.mu[c][n][1])
        if self.mu[c][n][0] == 'Gamma':
            return lambda : gammavariate(self.mu[c][n][1], self.mu[c][n][2])
        if self.mu[c][n][0] == 'Normal':
            return lambda : gauss(self.mu[c][n][1], self.mu[c][n][2])
        if self.mu[c][n][0] == 'Lognormal':
            return lambda : lognormvariate(self.mu[c][n][1], self.mu[c][n][2])
        if self.mu[c][n][0] == 'Weibull':
            return lambda : weibullvariate(self.mu[c][n][1], self.mu[c][n][2])
        if self.mu[c][n][0] == 'Custom':
            P, V = zip(*self.parameters[self.mu[c][n][1]])
            probs = list(P)
            cum_probs = [sum(probs[0:i+1]) for i in range(len(probs))]
            values = list(V)
            return lambda : self.custom_pdf(cum_probs, values)
        return False

 def random(self, start, minVal, maxVal, candidate = None):
   for z in xrange(config.rand_retries):
     v=int(start*random.lognormvariate(0,1)+.5)
     #logging.debug("lognorm: start=%d, v=%d", start, v)
     if v>=minVal and v<=maxVal and start!=v:
       return v
   raise MutateFailed("lognorm random gen failed")

 def visit_medic(self):
     """
         Lognormal with :
         logarithmic mean: 1.024
         logarithmic std dev: 0.788
     """       
     name = 'medic'
     if self.debug:
         print self.name, "at ",name, simpy.now()
     
     arrive = simpy.now()
     yield simpy.request, self, self.resources[name]
     wait = simpy.now() - arrive
     self.monitors[name].observe(wait)
     time = random.lognormvariate(mu=1.024, sigma=0.788) 
     tib = self.numberOfForms * time 
     yield simpy.hold,self,tib
     yield simpy.release, self, self.resources[name]
 
     p = random.random()
     if p < 0.99:
         for i in self.visit_dispenser():
             yield i
     else:
         for i in self.visit_exit():
             yield i

 def next(self):
   change = random.lognormvariate(0, self.sigma)
   if self.current + change > 0 and random.choice((True, False)):
     change = -change
   self.current += change
   delay()
   yield self.current

    def _get_new_ctd_packet(self, length):

        rdt = RecordDictionaryTool(stream_definition_id=self.stream_def._id)
        #Explicitly make these numpy arrays...
        c = numpy.array([random.uniform(0.0,75.0)  for i in xrange(length)]) 
        t = numpy.array([random.uniform(-1.7, 21.0) for i in xrange(length)]) 
        p = numpy.array([random.lognormvariate(1,2) for i in xrange(length)])
        lat = numpy.array([random.uniform(-90.0, 90.0) for i in xrange(length)]) 
        lon = numpy.array([random.uniform(0.0, 360.0) for i in xrange(length)]) 
        h = numpy.array([random.uniform(0.0, 360.0) for i in xrange(length)])

        start_time = ntplib.system_to_ntp_time(time.time()) - (length + 1)
        tvar = numpy.array([start_time + i for i in xrange(1,length+1)])


        rdt['time'] = tvar
        rdt['lat'] = lat
        rdt['lon'] = lon
        rdt['temp'] = t
        rdt['conductivity'] = c
        rdt['pressure'] = p

#        rdt['coordinates'] = rdt0
#        rdt['data'] = rdt1

        g = rdt.to_granule(data_producer_id=self.id)

        return g

    def _get_new_ctd_packet(self, stream_id, length):

        rdt = RecordDictionaryTool(taxonomy=tx)

        #Explicitly make these numpy arrays...
        c = numpy.array([random.uniform(0.0,75.0)  for i in xrange(length)]) 
        t = numpy.array([random.uniform(-1.7, 21.0) for i in xrange(length)]) 
        p = numpy.array([random.lognormvariate(1,2) for i in xrange(length)]) 
        lat = numpy.array([random.uniform(-90.0, 90.0) for i in xrange(length)]) 
        lon = numpy.array([random.uniform(0.0, 360.0) for i in xrange(length)]) 
        h = numpy.array([random.uniform(0.0, 360.0) for i in xrange(length)]) 
        tvar = numpy.array([self.last_time + i for i in xrange(1,length+1)]) 
        self.last_time = max(tvar)

        log.warn('Got time: %s' % str(tvar))
        log.warn('Got t: %s' % str(t))

        rdt['time'] = tvar
        rdt['lat'] = lat
        rdt['lon'] = lon
        rdt['height'] = h
        rdt['temp'] = t
        rdt['cond'] = c
        rdt['pres'] = p

#        rdt['coordinates'] = rdt0
#        rdt['data'] = rdt1

        g = build_granule(data_producer_id=stream_id, taxonomy=tx, record_dictionary=rdt)

        return g

	def initRandomParticle(self, systemRadius, maxSize, systemCenter):
		position = [random.randrange(systemCenter[0],systemRadius),random.randrange(systemCenter[1],systemRadius)]  #this creates a square system
		velocity = [random.randrange(-50,50),random.randrange(-50,50)]					  	  
		mass     = random.lognormvariate(1,6)
		radius   = math.pow(mass,0.25) 
		color    = (random.randrange(0,255),random.randrange(0,255),random.randrange(0,255),0)
		return self(position,velocity,radius,mass,color)