Python random.expovariate函数代码示例

def fail_simulation(n,s):
    t = 0
    r = 0
    trep = 2**64-1 # officialy INF
    t_list = []
    for _ in xrange(n):
        t_list.append(random.expovariate(1))

    t_list.sort()

    while True:
        # t1 < tmax
        t1 = t_list[0]
        
        if t1 < trep:
            t = t1
            r += 1
            if r == s+1:
                return t
            elif r < s+1:
                x = random.expovariate(1)
                t_list.pop(0)
                t_list.append(t+x)
                t_list.sort()
            if r == 1:
                y = random.expovariate(8)
                trep = t + y
        else:
            t = trep
            r -= 1
            if r > 0:
                y = random.expovariate(8)
                trep = t + y
            elif r == 0:
                trep = 2**64-1

def bankQueue(timeMax = 600): # t in minutes
    ta = 0       # time to next arrival in minutes
    ts = 0       # time to end of next service in minutes
    q = 1        # number of people in the queue
    c = 0        # time on the clock in minutes
    nserved = 0  # total number of people served
    cs = []
    ss = []
    qs = []
    while c < timeMax:
        if q == 0:
            c += ta
            q += 1
            ta = random.expovariate(1./avgArrive)
        elif ta<ts:
            ts -= ta
            c += ta
            q += 1
            ta = random.expovariate(1./avgArrive)
        else:
            ta -= ts
            c += ts
            q -= 1
            ts = random.expovariate(1./avgService)
            nserved += 1
        cs.append(c/60.)
        ss.append(nserved)
        qs.append(q)
    # end while
    p = biggles.FramedPlot()
    c1 = biggles.Curve(cs,ss,color='red')
    c2 = biggles.Curve(cs,qs,color='blue')
    p.add(c1,c2)
    p.show()

 def test_all(self):
     for test in ['', 'a', 'b', 'abc', 'abc'*50, 'hello world']:
         #print test
         #print sha256.sha256(test).hexdigest()
         #print hashlib.sha256(test).hexdigest()
         #print
         assert sha256.sha256(test).hexdigest() == hashlib.sha256(test).hexdigest()
     def random_str(l):
         return ''.join(chr(random.randrange(256)) for i in xrange(l))
     for length in xrange(150):
         test = random_str(length)
         a = sha256.sha256(test).hexdigest()
         b = hashlib.sha256(test).hexdigest()
         #print length, a, b
         if a != b:
             print 'ERROR!'
             raise ValueError()
     for i in xrange(100):
         test = random_str(int(random.expovariate(1/100)))
         test2 = random_str(int(random.expovariate(1/100)))
         
         a = sha256.sha256(test)
         a = a.copy()
         a.update(test2)
         a = a.hexdigest()
         
         b = hashlib.sha256(test)
         b = b.copy()
         b.update(test2)
         b = b.hexdigest()
         #print a, b
         if a != b:
             print 'ERROR!'
             raise ValueError()

def getFalseValue(provided_false_values, bin, lambda_bin_index):
    '''to pick a false value among the set
    The probability to select a false value, already provided, is higher than selecting a new one.
    provided_false_values is used for this reason
    '''
    value = 'null'
    if (len(set(provided_false_values)) < max_false_domain_cardinality) and (random.random() < 0.4): #selection not in VALUES ALREADY PROVIDED
        bin_index = int(random.expovariate(lambda_bin_index))
        while bin_index < 0 or bin_index >= len(bin):
            bin_index = int(random.expovariate(lambda_bin_index))
        if len(bin[bin_index])==0:
            return None
        if (len(bin[bin_index]) == 1):
            value_index = 0
        else:
            value_index = int(random.randint(0, len(bin[bin_index])-1))#Return a random integer N such that a <= N <= b.
        value = (bin[bin_index])[value_index]
    else: #selection among values already provided
        if (len(provided_false_values) > 0):
            if (len(provided_false_values) == 1):
                value_index = 0
            else:
                value_index = random.randint(0, len(provided_false_values)-1)

            value = provided_false_values[value_index]

    provided_false_values.append(value)
    return [value, provided_false_values]

 def get_interstorm_event_duration(self):
     """ This method is the interstorm duration generator
 
 This method takes one argument, the mean_interstorm parameter.
 (In Eagleson (1978), this parameter was called Tb.)
 
 This method is modeled identically to get_precipitation_event_duration()
 
 This method finds a random value for interstorm_duration
 based on the poisson distribution about the mean.
 This is accomplished using the expovariate function
 from the "random" standard library.
 Additionally, it is rounded to contain 4 significant figures, for neatness. 
 
 The if-else statement is very important here. Values of 0
 can exist in the Poission distribution, but it does not make
 sense to have 0 hour interstorm durations.
 To avoid 0 hour interstorm durations, we return a 
 interstorm duration IF it is greater than 0,
 otherwise, recursion is employed to re-call the interstorm
 duration generator function and get a new value.
 
 :returns: interstorm_duration as a float"""
 
     interstorm = round(random.expovariate(1/self.mean_interstorm),2)
     while interstorm == 0:
         interstorm = round(random.expovariate(1/self.mean_interstorm),2)
     self.interstorm_duration = interstorm
     return self.interstorm_duration

def generate_site_mutations(tree, position, mu, site_table, mutation_table,
                            multiple_per_node=True):
    """
    Generates mutations for the site at the specified position on the specified
    tree. Mutations happen at rate mu along each branch. The site and mutation
    information are recorded in the specified tables.  Note that this records
    more than one mutation per edge.
    """
    assert tree.interval[0] <= position < tree.interval[1]
    states = {"A", "C", "G", "T"}
    state = random.choice(list(states))
    site_table.add_row(position, state)
    site = site_table.num_rows - 1
    stack = [(tree.root, state, msprime.NULL_MUTATION)]
    while len(stack) != 0:
        u, state, parent = stack.pop()
        if u != tree.root:
            branch_length = tree.branch_length(u)
            x = random.expovariate(mu)
            new_state = state
            while x < branch_length:
                new_state = random.choice(list(states - set(state)))
                if multiple_per_node and (state != new_state):
                    mutation_table.add_row(site, u, new_state, parent)
                    parent = mutation_table.num_rows - 1
                    state = new_state
                x += random.expovariate(mu)
            else:
                if (not multiple_per_node) and (state != new_state):
                    mutation_table.add_row(site, u, new_state, parent)
                    parent = mutation_table.num_rows - 1
                    state = new_state
        stack.extend(reversed([(v, state, parent) for v in tree.children(u)]))

 def zombie_interval(self):
     if (datetime.now() - self.start_time).total_seconds() > 200:
         interval = random.expovariate(1/250)
     else:
         interval = 1000 - 50*self.kills
         interval = random.expovariate(1/max(interval, 500))
     self.timer.setInterval(interval)

    def generate(self, service):
        index = 0
        global buffer_size 
        global dropped_packets
        buffer_size = 10
        print ('Buffer Size is %d' %(buffer_size))
        while index < 6 :
                for x in range(1, total_packets):
			        arrivalTime = random.expovariate(lambda_list[index])
			        packet = Packet(env, arrivalTime, x, service)
			        yield env.timeout(arrivalTime)
                print ('Lambda: %f : Packet Loss Probability: %f'  %(lambda_list[index],dropped_packets *1.0/total_packets))
                dropped_packets = 0
                index = index + 1
        index = 0
        buffer_size = 50
        print ('Buffer Size is %d' %(buffer_size))
        while index < 6 :
                for x in range(1, total_packets):
                        arrivalTime = random.expovariate(lambda_list[index])
                        packet = Packet(env, arrivalTime, x, service)
                        yield env.timeout(arrivalTime)
                print ('Lambda: %f : Packet Loss Probability: %f'  %(lambda_list[index],dropped_packets *1.0/total_packets))
                dropped_packets = 0
                index = index + 1

    def simulate_once(self):
        """Simulate once.

        Return
        ------
            This will return the amount of operational loss simulated for the
            given time period.

        Example:
        r=OpRiskModel(stor4)
        lower, mu, upper = r.simulate_many()
        print "Bootstrap: ",lower,mu,upper

        Output:
        0.68% between 127760271.155 and 162467836.895
        0.8% between 122874286.419 and 167353821.63
        0.9% between 116569621.33 and 173658486.72
        0.95% between 111101264.604 and 179126843.445
        0.98% between 104743118.138 and 185484989.911
        0.99% between 100413671.581 and 189814436.469
        0.995% between 96401399.4999 and 193826708.549
        0.998% between 91486833.5654 and 198741274.484
        0.999% between 88010967.5982 and 202217140.451
        0.9999% between 77597567.1919 and 212630540.857
        0.99999% between 68459385.7079 and 221768722.341
        Bootstrap:  138714608.714 145114054.025 150873917.501 
        """
        t=random.expovariate(self.params.lamb)
        loss=0.0
        while t<self.params.days:
            t+=random.expovariate(self.params.lamb)
            amount=self.params.xm*random.paretovariate(self.params.alpha)
            loss+=amount
        return loss

def main():
    # initialize defaults
    meanoff = 1.0 # default mean off is 1 second
    meanon = 20.0 # default mean on is 20 seconds
    
    opts, args = getopt.getopt(sys.argv[1:], 'h', ['mean-off=', 'mean-on='])
    name = None
    for o, a in opts:
        if o == '-h': 
            print usage()
            sys.exit(0)
        elif o == '--mean-off': 
            meanoff = float(a)
        elif o == '--mean-on': 
            meanon = float(a)
        else: 
            print "Error parsing command-line option: unknown/unrecognized option %s" % o 
            #print >> sys.stderr, usage()
            sys.exit(1)
    if len(args):
        print "Error parsing command-line arguments: no arguments allowed" 
        #print >> sys.stderr, usage()
        sys.exit(2)
        
    seed()
    
    while 1:
        print time()
        system("cnistnet -a 10.2.34.150 192.168.5.10 --drop 0%; cnistnet -a 192.168.5.10 10.2.34.150 --drop 0%")
        sleep(expovariate(1.0/meanon))
        print time()
        system("cnistnet -a 10.2.34.150 192.168.5.10 --drop 100%; cnistnet -a 192.168.5.10 10.2.34.150 --drop 100%")
        sleep(expovariate(1.0/meanoff))

def req_generator(topology, n_contents, alpha, seed, rate=12.0, duration_warmup=9000, duration_real=36000):
    """This function generates events on the fly, i.e. instead of creating an 
    event schedule to be kept in memory, returns an iterator that generates
    events when needed.
    
    This is useful for running large schedules of events where RAM is limited
    as its memory impact is considerably lower.
    """
    random.seed(seed)
    
    rate = 4.0
    warmup = 0
    duration = 25000000
    
    receivers = [v for v in topology.nodes_iter() if topology.node[v]['stack'][0] == 'receiver']
    zipf = ZipfDistribution(alpha, n_contents)
    
    t_event = (expovariate(rate))
    while t_event < warmup + duration:
        recv = choice(receivers)
        content = int(zipf.rand_val())
        log = (t_event > warmup)
        event = {'receiver': recv, 'content': content, 'log': log}
        yield (t_event, event)
        t_event += (expovariate(rate))
    raise StopIteration()

    def random_gen(self, filepath="random.replay", avgTransmit=30.0, avgWait=0, totalTime=1800.0):
        f = open(filepath, "w")
        replay = list()
        count = 0
        port = 1234

        for cl in self.clients:
            curTime = 0
            port = 1234
            while True:
                if avgWait == 0:
                    startTime = 0
                else:
                    startTime = random.expovariate(1 / avgWait)

                txTime = random.expovariate(1 / avgTransmit)

                # Generate traffic until total time
                if curTime + startTime + txTime > totalTime:
                    break
                else:
                    replay.append((curTime + startTime, cl.IP() + ":" + str(port), curTime + startTime + txTime))
                    port += 1
                    curTime += startTime + txTime

        # Write replay to file sorted by timestamp
        replay.sort()
        count = 0
        port = 1234
        for startTime, dstIP, endTime in replay:
            srcIP = self.servers[count % len(self.servers)].IP() + ":" + str(port + count)
            f.write("%f %s %s %f\n" % (startTime, srcIP, dstIP, endTime))
            count += 1
        f.close()

def sample_rate_matrix(fs, Q_mut):
    nstates = len(Q_mut)
    # sample the selection parameters
    if fs.really_low_var:
        v = 0.04
    elif fs.low_var:
        v = 0.2
    elif fs.medium_var:
        v = 1
    elif fs.high_var:
        v = 5.0
    elif fs.really_high_var:
        v = 25.0
    s = math.sqrt(v)
    if fs.neg_skew:
        sels = [-random.expovariate(1/s) for i in range(nstates)]
    elif fs.no_skew:
        sels = [random.gauss(0, s) for i in range(nstates)]
    elif fs.pos_skew:
        sels = [random.expovariate(1/s) for i in range(nstates)]
    # define the mutation-selection rate matrix using Halpern-Bruno
    Q = np.zeros_like(Q_mut)
    for i in range(nstates):
        for j in range(nstates):
            if i != j:
                tau = math.exp(-(sels[j] - sels[i]))
                coeff = math.log(tau) / (1 - 1/tau)
                Q[i, j] = Q_mut[i, j] * coeff
    for i in range(nstates):
        Q[i, i] = -np.sum(Q[i])
    return Q

def poisson_train(start, end, rate):
    newspike = start+rnd.expovariate(rate)
    strain = []
    while newspike < end:
        strain.append(newspike)
        newspike += rnd.expovariate(rate)
    return strain

def similar_items(num_resources, min_fill, base_item, dev=.05, minr=MIN_RES, maxr=MAX_RES):
    """
    Generates a bin. Bin capacities are not correlated.
    All items are similar to the given base item
    base*dev is the standard deviation
    """
    mf = min(min_fill, 1-1e-15) # helps getting rid of numerical instabilities
    
    base = random.randint(minr,maxr)
    mean = base*dev
    lbd = 1.0/mean
    bin_cap = base_item.requirements[:]
    for i,v in enumerate(bin_cap):
        base = 5*v
        mean = base*dev
        lbd = 1.0/mean        
        bin_cap[i] = max(0,int(round(base+(random.expovariate(lbd)-mean))))
    
    b = Bin(bin_cap)
    item_vol = 0.0
    items = []
    vl = 0
    while item_vol < mf:
        for tr in xrange(MAX_TRY):
            it_res = base_item.requirements[:]
            for i,base in enumerate(it_res):
                mean = base*dev
                lbd = 1.0/mean
                it_res[i] = max(0,int(round(base+(random.expovariate(lbd)-mean))))
            vl = update(items, it_res, b, item_vol)
            if vl : break
        item_vol = vl
        if not item_vol: break

    return items, b