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 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 gen_lifetime(self, shape, scale):
     '''Generates a random lifetime for the part using Weibull random numbers.
     If 0 < shape < 1, the part exhibits infant mortality (more failures early in parts' life)
     If shape = 0, the part exhibits constant mortality
     If shape > 1, the part exhibits wear-out (more failures late in parts' life)
     '''
     self.lifetime = self.mttf * random.weibullvariate(alpha=scale, beta=shape)

 def valueAt(self, evaluationTime):
     alpha = evaluateAt(self.alpha, evaluationTime)
     beta = evaluateAt(self.beta, evaluationTime)
     while 1:
         value = random.weibullvariate(alpha, beta)
         if value >= 0.0 and value <= 1.0:
             break
     return value

def getIndex(listLength, numOfDigits):
    # index = random.normalvariate(listLength/2, 3)
    index = random.weibullvariate(listLength / 2, numOfDigits * 0.5)
    index = math.ceil(index)
    if index > listLength - 1:
        index = listLength - 1
    if index < 0:
        index = 0
    return int(index)

def weibull():
    WEIBULL_USAGE = '''Usage: /weibull?alpha=<integer>&beta=<integer>[k=<integer>&test=true|false]'''

    func = lambda args: random.weibullvariate(alpha=float(args['alpha']), beta=float(args['beta'])) + float(request.args.get('k'))

    alpha = request.args.get('alpha')
    beta = request.args.get('beta')

    return get_response(request, WEIBULL_USAGE, func, None, alpha=alpha, beta=beta)

def exposure_period():
    
    SCALE_PAR = 1.10
    SHAPE_PAR = 2.21
    OFFSET = 0.5
    
    t = int(round((random.weibullvariate(SCALE_PAR, SHAPE_PAR) + OFFSET)
                  * TIME_TO_TIMESTEP))
    
    return t

    def generate_fire_recurrence(self):

        """ Finds the time to next fire (fire recurrence) based on the scale parameter (63.5% of
        fire Weibull distribution) and the shape parameter (describes the skew of the histogram, shape = 3.5
        represents a normal distribution).

        Rounds the time to next fire to 4 significant figures, for neatness.

        :returns: time_to_next_fire as a float"""

        self.time_to_next_fire = round(weibullvariate(self.scale_parameter, self.shape_parameter),2)
        return self.time_to_next_fire

def random_guessing(fileparse):
    prevs = []
    num = 0
    sort_key = lambda x:int(x[0]) if x[0].isdigit() else (float('inf'),x[0])
    corefs = sorted(fileparse.nps.items(), key = sort_key)
    
    for cid in [k for k,v in corefs if not v.get('ref')]:
        if len(prevs) > num and cid.isdigit():
            choice = min(len(prevs), int(round(random.weibullvariate(1.2,7))) + 1)
            fileparse.nps[cid]['ref'] = prevs[-choice]
        if cid.isdigit():
            prevs.append(cid)

def WeibullDistribution():
	results = []
	k = 2
	lamada = 1

	sampleNum = 6000
	for i in range(sampleNum):
		results.append(random.weibullvariate(lamada,k))
	cdf = Cdf.MakeCdfFromList(results)
	myplot.Clf()
	myplot.Cdf(cdf,complement=True,xscale = 'log',yscale = 'log')
	# myplot.Cdf(cdf)
	myplot.show()

def randomXValue(tag, params):
    if tag == "normal":
        mu = number(params.get("mu", 0.0))
        sigma = number(params.get("sigma", 1.0))
        return XValue(lambda: random.normalvariate(mu, sigma))
    if tag == "pnormal":
        mu = number(params.get("mu", 0.0))
        sigma = number(params.get("sigma", 1.0))
        return XValue(lambda: max(random.normalvariate(mu, sigma), 0.0))        
    elif tag == "uniform":
        mn = number(params.get("min", 0.0)) 
        mx = number(params.get("max", 1.0))
        return XValue(lambda: random.uniform(mn, mx))
    elif tag == "triangular":
        low = number(params.get("low", 0.0)) 
        high = number(params.get("high", 1.0))
        mode = number(params.get("mode", 1.0))
        return XValue(lambda: random.triangular(low, high, mode))
    elif tag == "beta":
        alpha = number(params.get("alpha", 0.0)) 
        beta = number(params.get("beta", 1.0))
        return XValue(lambda: random.betavariate(alpha, beta))
    elif tag == "gamma":
        alpha = number(params.get("alpha", 0.0)) 
        beta = number(params.get("beta", 1.0))
        return XValue(lambda: random.gammavariate(alpha, beta))
    elif tag == "lognormal":
        mu = number(params.get("mu", 0.0))
        sigma = number(params.get("sigma", 1.0))
        return XValue(lambda: random.lognormvariate(mu, sigma))
    elif tag == "vonmises":
        mu = number(params.get("mu", 0.0))
        kappa = number(params.get("kappa", 1.0))
        return XValue(lambda: random.vonmisesvariate(mu, kappa))
    elif tag == "pareto":
        alpha = number(params.get("alpha", 0.0))
        return XValue(lambda: random.paretovariate(alpha))
    elif tag == "weibull":
        alpha = number(params.get("alpha", 0.0)) 
        beta = number(params.get("beta", 1.0))
        return XValue(lambda: random.weibullvariate(alpha, beta))
    elif tag == "exponential":
        lamda = number(params.get("lambda", 1.0))
        return XValue(lambda: random.expovariate(lamda))
    else:
        raise InvalidXMLException("unsupported attribute value")

 def visit_screener(self):
     """
         After cleaning
         
         Aggregated:
         
         Lognormal with:
             logarithmic mean: -2.125
             logarithmic std dev: 0.428
         
         Weibull with:
             shape = 2.29  (beta in python)
             scale = 0.142 (alpha in python)
         
         Separated:
         Medical Screening -> Gamma distribution with
                              shape: 4.876
                              rate: 32.55
         Ciprofloxacin Screening -> Gamma distribution with
                              shape: 6.258
                              rate: 47.165
         Doxycycline Screening -> Lognormal distribution with
                             logarithmic mean: -2.165
                             logarithmic std dev: 0.413
     """       
     name = 'screener'
     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=-2.125, sigma=0.428)
     time = random.weibullvariate(alpha=0.142, beta=2.29)
     tib = self.numberOfForms * time
     yield simpy.hold,self,tib
     yield simpy.release, self, self.resources[name]
     
     
     if 'MEDIC' in self.forms:
         for i in self.visit_medic():
             yield i
     else:
         for i in self.visit_dispenser():
             yield i

 def find_distributions(self, n, c, kind):
     """
     Finds distribution functions
     """
     if self.source(c, n, kind) == 'NoArrivals':
         return lambda : float('Inf')
     if self.source(c, n, kind)[0] == 'Uniform':
         return lambda : uniform(self.source(c, n, kind)[1],
                                 self.source(c, n, kind)[2])
     if self.source(c, n, kind)[0] == 'Deterministic':
         return lambda : self.source(c, n, kind)[1]
     if self.source(c, n, kind)[0] == 'Triangular':
         return lambda : triangular(self.source(c, n, kind)[1],
                                    self.source(c, n, kind)[2],
                                    self.source(c, n, kind)[3])
     if self.source(c, n, kind)[0] == 'Exponential':
         return lambda : expovariate(self.source(c, n, kind)[1])
     if self.source(c, n, kind)[0] == 'Gamma':
         return lambda : gammavariate(self.source(c, n, kind)[1],
                                      self.source(c, n, kind)[2])
     if self.source(c, n, kind)[0] == 'Lognormal':
         return lambda : lognormvariate(self.source(c, n, kind)[1],
                                        self.source(c, n, kind)[2])
     if self.source(c, n, kind)[0] == 'Weibull':
         return lambda : weibullvariate(self.source(c, n, kind)[1],
                                        self.source(c, n, kind)[2])
     if self.source(c, n, kind)[0] == 'Normal':
         return lambda : truncated_normal(self.source(c, n, kind)[1],
                                          self.source(c, n, kind)[2])
     if self.source(c, n, kind)[0] == 'Custom':
         values = self.source(c, n, kind)[1]
         probs = self.source(c, n, kind)[2]
         return lambda : random_choice(values, probs)
     if self.source(c, n, kind)[0] == 'UserDefined':
         return lambda : self.check_userdef_dist(self.source(c, n, kind)[1])
     if self.source(c, n, kind)[0] == 'Empirical':
         if isinstance(self.source(c, n, kind)[1], str):
             empirical_dist = self.import_empirical(self.source(c, n, kind)[1])
             return lambda : random_choice(empirical_dist)
         return lambda : random_choice(self.source(c, n, kind)[1])
     if self.source(c, n, kind)[0] == 'TimeDependent':
         return lambda t : self.check_timedependent_dist(self.source(c, n, kind)[1], t)
     if self.source(c, n, kind)[0] == 'Sequential':
         return lambda : next(self.generators[kind][n][c])

def generate_order(env, res, order, patID, data):
    tfactor = 60  # Minutes to seconds
    while True:
        # Generate some really random processes
        if order == 'food':
            lamb = 5 + 20*(patID % 6)  # In minutes
            k = 3  # Hunger increases over time
            delay = random.weibullvariate(lamb*tfactor, k)
        else:
            a, b = 10, 20+20*(patID % 6)
            mu = random.randint(a, b)  # Random mean in minutes
            sd = 10  # Standard deviation in minutes
            delay = abs(random.normalvariate(mu*tfactor, sd*tfactor))
        yield env.timeout(delay)  # Interarival time
        # Delay is complete, order arrived
        # Start process and return queue time and process time
        (t_arrival, qtime, ptime) = yield env.process(process_order(env,res,order,patID))
        # Update data
        data.append((patID, order, clockTime(t_arrival), round(qtime,3), round(ptime,3)))

 def run(self, res, sto, pri):
     while True:
         ttf = weibullvariate(alpha, beta)   # time until failure
         yield hold, self, ttf
         failure = now()                     # failure time
         HardDrive.numFailed += 1
         HardDrive.downTime.observe(HardDrive.numFailed)
         if HardDrive.numFailed == critLevel:
             critical.signal()
             HardDrive.numFailed = 0
             HardDrive.downTime.observe(HardDrive.numFailed)
         else:
             yield waitevent, self, critical
         yield get, self, sto, 1
         yield request, self, res, pri
         self.size = self.got[0].capacity
         ttr = meanTtr + expovariate(1.0 / meanTtr)
         yield hold, self, ttr
         yield release, self, res

    def gen_failure_list(self, scale, shape, startdate, enddate):
        '''generate a synthetic failure time list based on weibull distribution
         and start/end date time'''
        failure_moments = []
        ttf_list = []

        start = date_to_sec(startdate)
        end = date_to_sec(enddate)

        cur_failure = start

        while True:
            ttf = random.weibullvariate(scale,shape)
            cur_failure += ttf
            if cur_failure < end:
                ttf_list.append(ttf)
                failure_moments.append(sec_to_date(cur_failure))
            else:
                break
        return failure_moments, ttf_list

def generateRandomNumber( distribution, duration ):
    randomNumber = -1 

    if distribution == "Lognormal":
        mu = 4
        sigma = 1
        randomNumber = random.lognormvariate(mu, sigma)
    elif distribution == "Exponential":
        lam = 0.02
        randomNumber = random.expovariate(lam)
    elif distribution == "Poisson":
        lam = 10
        randomNumber = numpy.random.poisson(lam)
    elif distribution == "Weibull":
        scale = 4
        shape = 0.6
        randomNumber = random.weibullvariate(scale, shape)


    return int(randomNumber)

    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])
        return False

 def visit_dispenser(self):
     """
         Best fit obtained after cleaning the data:
         Weibull Distribution with:
             shape: 1     (beta in python)
             scale: 0.311 (alpha in python)
     """       
     name = 'dispenser'
     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.weibullvariate(alpha=0.311, beta=1)
     tib = self.numberOfForms * time
     yield simpy.hold,self,tib
     yield simpy.release, self, self.resources[name]
     
     for i in self.visit_exit():
         yield i

 def find_distributions(self, n, c, kind):
     """
     Finds distribution functions
     """
     if self.source(c, n, kind) == 'NoArrivals':
         return lambda : float('Inf')
     if self.source(c, n, kind)[0] == 'Uniform':
         return lambda : uniform(self.source(c, n, kind)[1],
                                 self.source(c, n, kind)[2])
     if self.source(c, n, kind)[0] == 'Deterministic':
         return lambda : self.source(c, n, kind)[1]
     if self.source(c, n, kind)[0] == 'Triangular':
         return lambda : triangular(self.source(c, n, kind)[1],
                                    self.source(c, n, kind)[2],
                                    self.source(c, n, kind)[3])
     if self.source(c, n, kind)[0] == 'Exponential':
         return lambda : expovariate(self.source(c, n, kind)[1])
     if self.source(c, n, kind)[0] == 'Gamma':
         return lambda : gammavariate(self.source(c, n, kind)[1],
                                      self.source(c, n, kind)[2])
     if self.source(c, n, kind)[0] == 'Lognormal':
         return lambda : lognormvariate(self.source(c, n, kind)[1],
                                        self.source(c, n, kind)[2])
     if self.source(c, n, kind)[0] == 'Weibull':
         return lambda : weibullvariate(self.source(c, n, kind)[1],
                                        self.source(c, n, kind)[2])
     if self.source(c, n, kind)[0] == 'Custom':
         P, V = zip(*self.source(c, n, kind)[1])
         probs, values = list(P), list(V)
         return lambda : nprandom.choice(values, p=probs)
     if self.source(c, n, kind)[0] == 'UserDefined':
         return lambda : self.check_userdef_dist(self.source(c, n, kind)[1])
     if self.source(c, n, kind)[0] == 'Empirical':
         if isinstance(self.source(c, n, kind)[1], str):
             empirical_dist = self.import_empirical(self.source(c, n, kind)[1])
             return lambda : nprandom.choice(empirical_dist)
         return lambda : nprandom.choice(self.source(c, n, kind)[1])