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)

def lognormal(mean=None, sigma=None, n=1, minimum=None, maximum=None):
    """
    Generate a list with a lognormal distribution.
    Option - setting mininum and maximum rejects and regenerates
    any value outside the truncation range.
    Setting minimum and maximum to None or 'None' makes the range
    unbounded.
    """
    if minimum is None or minimum is 'None':
        minimum = None
    else:
        minimum = float(minimum)

    if maximum is None or maximum is 'None':
        maximum = None
    else:
        maximum = float(maximum)

    mean = float(mean)
    sigma = float(sigma)

    answer = []
    while len(answer) < n:
        x = random.lognormvariate(mu=mean, sigma=sigma)
        if x > minimum and (x < maximum or (maximum is None)):
            answer.append(x)
    return answer