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 __init__(self, env, orderWindow, paymentWindow, pickupWindow):
self.env = env
self.orderWindow = orderWindow
self.paymentWindow = paymentWindow
self.pickupWindow = pickupWindow
Car.carNumber += 1
self.name = Car.carNumber
self.orderTime = random.weibullvariate(3, 1.5)
self.paymentTime = random.weibullvariate(2, 1.5)
self.foodPrepTime = random.weibullvariate(6, 2.0)
self.pickupTime = random.weibullvariate(2, 1.5)
self.foodPrep = self.env.timeout(self.foodPrepTime)
self.totalTime = 0
def calculateDegreeDistribution(self, shape, other=float(0)):
for node in range(0, self.nodeCount):
if self.graphType == 1:
degree = abs(int(random.expovariate(1/other)))
elif self.graphType == 2:
degree = abs(int(random.expovariate(1/other)))
elif self.graphType == 3:
degree = abs(int(random.weibullvariate(shape, other)))
print "Node: Degree ", node, degree
self.nodeDict[node] = degree
if (degree == 0) or (degree == 1):
self.zeroNodes.append(node)
# if self.graphType == 3:
# sortedDict = sorted(self.nodeDict.items(), key=operator.itemgetter(1), reverse=False)
# print "Sorted Dict", sortedDict
# for node in range(0, int(self.nodeCount * .27338129)): # .27338129 is the percentage of nodes with 0 or 1 in real graph
# key = sortedDict[node][0]
# value = random.random()
# if value <= .86842015:
# self.nodeDict[key] = 0
# else:
# self.nodeDict[key] = 1
for node in self.zeroNodes:
chance = random.uniform(0,1)
if chance <= 0.50:
self.nodeDict[node] = 2
else:
self.nodeDict[node] = 3
print "New NodeDict items", sorted(self.nodeDict.items(), key=operator.itemgetter(1), reverse=False)
def my_Funh():
random.seed()
print('random = ', random.random())
print('getstate = ', random.getstate())
state = random.getstate()
random.setstate(state)
print('setstate = ',random.random())
print('getrandbits = ',random.getrandbits(6))
print('randrange = ',random.randrange(3, 9))
print('randint = ',random.randint(3, 9))
x = 2,1,3,5,4,6,7,8,9,10,6
print('choice = ',random.choice(x) + random.choice(x)+random.choice(x))
mylist = [1, 2, 3,4,5,6,7,8,9,0]
random.shuffle(mylist)
print('shuffle =',*mylist)
print("sample:", *random.sample(x, 8))
print('uniform = ', random.uniform(20, 60))
print('triangular = ',random.triangular(20, 60, 30))
print('betavariate =',random.betavariate(5, 10))
print('expovariate = ',random.expovariate(1.5))
print('gammavariate =',random.gammavariate(100, 2))
print('gauss =',random.gauss(100, 50))
print('lognormvariate =',random.lognormvariate(0, 0.25))
print('normalvariate =',random.normalvariate(0, 0.25))
print('vonmisesvariate = ',random.vonmisesvariate(0,4))
print('paretovariate = ',random.paretovariate(3))
print('weibullvariate = ',random.weibullvariate(1, 1.5))
b = input('New ? (y / n) = ')
if b == 'y':
my_Funh()
def _execute(self, sources, alignment_stream, interval):
if alignment_stream is None:
raise ToolExecutionError("Alignment stream expected")
for ti, _ in alignment_stream.window(interval, force_calculation=True):
yield StreamInstance(
ti, random.weibullvariate(alpha=self.alpha, beta=self.beta))
def GenerarViento(viento):
maximo_fi = 360
minimo_fi = 0.01
delta_angulo = round(normalvariate(2, 0.7) * 10, 2)
if viento['estado']:
if viento['direccion'] + delta_angulo >= maximo_fi:
viento['estado'] = False
viento['direccion'] -= delta_angulo
else:
viento['direccion'] += delta_angulo
else:
if viento['direccion'] - delta_angulo <= minimo_fi:
viento['estado'] = True
viento['direccion'] += delta_angulo
else:
viento['direccion'] -= delta_angulo
# Para trampear la velocidad del viento y que meta algunos valores excesivos
# para llenar la tabla de desconexiones hago que:
# Haya un 30 % de probabilidades de añadir 15 a la velocidad media de la zona
loteria = randint(1, 10)
if loteria < 3:
extra = 15
else:
extra = 0
viento['velocidad'] = round(weibullvariate(viento['velmedia'] + extra, 2),
2)
return
def waitTillFailure(proc): global gvStartTime, gvDone, gvStatsLock, gvTotalFL # Calculate when the next failure should take place nextFailure = int(round(random.weibullvariate(WEIBULL_SCALE, WEIBULL_SHAPE))) time.sleep(nextFailure) # Caluclate the time which the app ran for during this instance timeDiff = time.time() - gvStartTime process = psutil.Process(proc.pid) for child in process.children(recursive=True): child.kill() os.killpg(os.getpgid(proc.pid), signal.SIGKILL); print(os.path.basename(__file__) + ": Failure at " + str(timeDiff + gvStartTime)) # Acquire the lock on calculate stats gvStatsLock.acquire() # No need to calculate if the entire run has already ended if (gvDone is False): calculateStats(timeDiff) gvTotalFL += 1 # Release the lock on calculate stats gvStatsLock.release()
async def random_weibull_variate_command(self, ctx, alpha: float,
beta: float):
"""Alpha is the scale parameter, beta is the shape."""
try:
await ctx.send(random.weibullvariate(alpha, beta))
except Exception as ex:
await self._error(ctx, ex)
def distribuicoesChegadas(env):
dist = 0
valores = [0.1, 0.3, 0.5, 0.7, 0.9, 1.1, 1.3, 1.5, 1.7, 1.9, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 11.5,
12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5, 19.5, 20.5, 21.5, 22.5, 23.5, 24.5, 25.5, 26.5, 27.5, 28.5,
29.5,
30.5, 31.5, 32.5, 33.5, 34.5, 35.5, 36.5, 37.5, 38.5, 39.5, 40.5, 61, 87.5]
probabilidades = [0.085, 0.211, 0.106, 0, 0.010, 0, 0, 0, 0, 0.010, 0.031, 0.010, 0.053, 0.010, 0, 0.031, 0.031,
0.021, 0.031, 0.010, 0.021, 0.021, 0.021, 0.031, 0, 0.010, 0.010, 0, 0.010, 0.010, 0.031, 0.021,
0, 0,
0.031, 0, 0.031, 0.010, 0, 0.010, 0, 0.021, 0, 0.010, 0, 0.010, 0, 0, 0.010, 0.021, 0.010]
if (env.now >= 14400) and (env.now < 23400): # Horário de almoco entre 11h e 13h30
x = random.gammavariate(0.315, 1)
y = random.gammavariate(2.08, 1)
dist = 108 * x / (x + y)
elif (env.now >= 7200) and (env.now < 9000): # Intervalo da manha entre 9h e 9h30
dist = random.lognormvariate(1.5287, -1.528)
elif ((env.now >= 27600) and (env.now < 28800)) or ((env.now >= 34200) and (env.now < 35400)) or \
((env.now >= 39600) and (
env.now < 43200)): # Intervalos da tarde de 14h40 a 15h, de 16h30 a 16h50 e de 18h às 19h
dist = numpy.random.choice(valores, 1, p=probabilidades)
elif ((env.now >= 0) and (env.now < 7200)) or ((env.now >= 9000) and (env.now < 14400)) or (
(env.now >= 23400) and (env.now < 27600)) \
or ((env.now >= 28800) and (env.now < 34200)) or ((env.now >= 35400) and (env.now < 39600)) or (
(env.now >= 43200) and (env.now < 50400)): # Demais intervalos
dist = random.weibullvariate(22.8, 0.755)
return dist
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 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, values = list(P), list(V)
return lambda: nprandom.choice(values, p=probs)
if source[c][n][0] == 'UserDefined':
return lambda: self.check_userdef_dist(source[c][n][1])
if source[c][n][0] == 'Empirical':
if isinstance(source[c][n][1], str):
empirical_dist = self.import_empirical(source[c][n][1])
return lambda: choice(empirical_dist)
return lambda: choice(source[c][n][1])
def intf_DISTWEIBULL(E):
"""Takes VALs from v1 and v2, and returns a value randomly generated
by a function that produces values which are distributed in a Weibull
distribution. This is often used to model processes related to failure
rates, survival analysis, and reliability. The v2 VAL is Lambda which is
the scale parameter for this kind of distribution. The v1 VAL is k which is
the shape parameter. Both must be greater than zero. If k is 1 this is
equivalent to the exponential distribution. If k is 2 it is equivalent to
the Rayleigh distribution. A value of k < 1 indicates that the failure rate
decreases over time. This happens if there is significant "infant
mortality", or defective items failing early and the failure rate
decreasing over time as the defective items are weeded out of the
population. A value of k = 1 indicates that the failure rate is constant
over time. This might suggest random external events are causing mortality,
or failure. A value of k > 1 indicates that the failure rate increases with
time. This happens if there is an "aging" process, or parts that are more
likely to fail as time goes on.
|[.75 1 distweibull::!] 100000 repeat 100000 2list mean -> 0.751247734665
"""
if not inc.VAL(E, 1) or not inc.VAL(E, 2):
print("Input Error: distweibull")
print(intf_DISTWEIBULL.__doc__)
return # Without doing much of anything.
v1 = E.The.StackPop().val # k, beta, shape
v2 = E.The.StackPop().val # Lambda, alpha, scale
import random
out = random.weibullvariate(v2, v1)
out = objectifier.StackOB_VAL(out)
E.The.StackPush(out)
def distribuicoesChegadas(env):
dist = 0
valores = [
0.1, 0.3, 0.5, 0.7, 0.9, 1.1, 1.3, 1.5, 1.7, 1.9, 2.5, 3.5, 4.5, 5.5,
6.5, 7.5, 8.5, 9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5, 16.5, 17.5,
18.5, 19.5, 20.5, 21.5, 22.5, 23.5, 24.5, 25.5, 26.5, 27.5, 28.5, 29.5,
30.5, 31.5, 32.5, 33.5, 34.5, 35.5, 36.5, 37.5, 38.5, 39.5, 40.5, 61,
87.5
]
probabilidades = [
0.085, 0.211, 0.106, 0, 0.010, 0, 0, 0, 0, 0.010, 0.031, 0.010, 0.053,
0.010, 0, 0.031, 0.031, 0.021, 0.031, 0.010, 0.021, 0.021, 0.021,
0.031, 0, 0.010, 0.010, 0, 0.010, 0.010, 0.031, 0.021, 0, 0, 0.031, 0,
0.031, 0.010, 0, 0.010, 0, 0.021, 0, 0.010, 0, 0.010, 0, 0, 0.010,
0.021, 0.010
]
if (env.now >= 14400) and (env.now < 23400):
x = random.gammavariate(0.315, 1)
y = random.gammavariate(2.08, 1)
dist = 108 * x / (x + y)
elif (env.now >= 7200) and (env.now < 9000):
dist = random.lognormvariate(1.5287, -1.528)
elif ((env.now >= 27600) and (env.now < 28800)) or ((env.now >= 34200) and (env.now < 35400)) or \
((env.now >= 39600) and (env.now < 43200)):
dist = numpy.random.choice(valores, 1, p=probabilidades)
elif ((env.now >= 0) and (env.now < 7200)) or ((env.now >= 9000) and (env.now < 14400)) or ((env.now >= 23400) and (env.now < 27600)) \
or ((env.now >= 28800) and (env.now < 34200)) or ((env.now >= 35400) and (env.now < 39600)) or ((env.now >= 43200) and (env.now < 50400)):
dist = random.weibullvariate(22.8, 0.755)
return dist
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 generate_random_number(f):
"""ランダム値を1000個生成
各関数のパラメータは適当に決め打ち。
"""
if f == 'random':
return [random.random() for n in range(1000)]
elif f == 'uniform':
return [random.uniform(10, 20) for n in range(1000)]
elif f == 'triangular':
return [random.triangular(0, 1) for n in range(1000)]
elif f == 'betabariate':
return [random.betavariate(4, 7) for n in range(1000)]
elif f == 'expovariate':
return [random.expovariate(1 / 0.5) for n in range(1000)]
elif f == 'gammavariate':
return [random.gammavariate(4, 7) for n in range(1000)]
elif f == 'gauss':
return [random.gauss(1, 0.2) for n in range(1000)]
elif f == 'gauss':
return [random.gauss(1, 0.2) for n in range(1000)]
elif f == 'lognormvariate':
return [random.lognormvariate(1, 0.2) for n in range(1000)]
elif f == 'normalvariate':
return [random.normalvariate(1, 0.2) for n in range(1000)]
elif f == 'vonmisesvariate':
return [random.vonmisesvariate(math.pi / 2, 5) for n in range(1000)]
elif f == 'paretovariate':
return [random.paretovariate(100) for n in range(1000)]
elif f == 'weibullvariate':
return [random.weibullvariate(4, 2) for n in range(1000)]
def _generate_numbers(distribution, length):
"""
Generate random numbers of length according to the distribution.
:param distribution: A list which holds information about a distribution and its parameters,
first element is always the name, the rest depends on the distribution.
Ex: exponential distribution = distribution = ['EXP', lambda]
:param length: The length of random numbers to be generated
:return: A list of random numbers
"""
name, *parameters = distribution
random_numbers = []
if name == 'EXP':
lambda_, = parameters
for i in range(length):
num = random.expovariate(lambda_)
random_numbers.append(num)
if name == 'WEIBULL':
scale_, shape_ = parameters
for i in range(length):
num = random.weibullvariate(scale_, shape_)
random_numbers.append(num)
if name == 'LOGNORM':
mu_, sigma_ = parameters
for i in range(length):
num = random.lognormvariate(mu_, sigma_)
random_numbers.append(num)
if name == 'NORMAL':
mu_, sigma_ = parameters
for i in range(length):
num = random.normalvariate(mu_, sigma_)
random_numbers.append(num)
return random_numbers
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 get_incubation_period(num_ppl):
# The time from exposure until symptoms appear (i.e., the incubation period) is
# drawn from a Weibull distribution with a mean of 6.4 days and a standard deviation of 2.3
# days (Backer et al. 2020)
k = (2.3 / 6.4)**(-1.086)
l = 6.4 / (math.gamma(1 + 1 / k))
return np.around([random.weibullvariate(l, k)
for _ in np.arange(num_ppl)]).astype(np.int32)
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 create_daystosymptoms_column(num_ppl):
# The time from exposure until symptoms appear (i.e., the incubation period) is
# drawn from a Weibull distribution with a mean of 6.4 days and a standard deviation of 2.3
# days (Backer et al. 2020)
k = (2.3 / 6.4)**(-1.086)
L = 6.4 / (math.gamma(1 + 1 / k))
return np.array(
[random.weibullvariate(L, k) for ppl in np.arange(num_ppl)])
def waitTillFailure(proc, failureTime):
global gvStartTime, gvDone, gvStatsLock, gvCurrentApp, gvTotalFL
# Calculate when the next failure should take place
nextFailure = failureTime
if failureTime == 0:
nextFailure = int(random.weibullvariate(WEIBULL_SCALE, WEIBULL_SHAPE))
# Holds the reason for exisitng the while loop below
switch = False
# Loop until its time to inject a failure
while ((time.time() - gvStartTime) <= nextFailure):
# Every iteration, poll the currently running DMTCP process
# to learn if it has died. If it has, that means it is time
# to switch to the HW app.
if (proc.poll() is not None):
# Set the reason for quitting the loop as switch and break
switch = True
break
# Caluclate the time which the app ran for during this instance
timeDiff = time.time() - gvStartTime
# Kill the process if failure is the reason for quitting the loop
if switch is False:
# --kill may block while the application is ckpting
#subprocess.call(DMTCP_COMMAND + ' --kill', shell=True)
proc.send_signal(9)
nextFailure = 0
else:
nextFailure = nextFailure - timeDiff
# Acquire the lock on calculate stats
gvStatsLock.acquire()
# No need to calculate if the entire run has already ended
if (gvDone is False):
calculateStats(timeDiff)
# If switching, move on to the HW app
# Else had a failure, so run the LW app
# And increment the number of failures
if switch is False:
gvTotalFL[gvCurrentApp] += 1
if (gvCurrentApp == (NUM_APPS - 1)):
gvCurrentApp = 0
else:
gvCurrentApp += 1
gvStartTime = time.time()
# Release the lock on calculate stats
gvStatsLock.release()
return nextFailure
def add_instances(unique_words, labels, words, num_to_word, pictures):
print("Started add_instances")
num_low = 0
num_high = 0
maxi = 0
labels = list(labels)
words = list(words)
# There is probably a faster way of doing this
"""
# This was taking far too long to justify doing each time. Uncomment if the data gets switched
# Find the word with the highest frequency ('the' in our case, 5826 instances)
# We scale the other frequencies up relative to their distance from this value
for item in range(unique_words):
count = labels.count(item)
if count > maxi:
maxi = count
print("Got the maximum frequency")
"""
maxi = 5826
for item in range(unique_words):
# locations of the pictures of this word
indices = [i for i, x in enumerate(labels) if x == item]
count = len(indices)
num_to_add = int(math.sqrt(math.sqrt(maxi - count)))
word = num_to_word[item]
# we want to sample from however many different images we ahve as much as we can
cur_pic = 0
for _ in range(num_to_add):
im = pictures[indices[cur_pic]]
# mess with the image a little
off1, off2, off3, off4 = [random.randint(0, 4) for _ in range(4)]
im = im.transform(
(im.size[0], im.size[1]), Image.EXTENT,
(0 + off1, 0 + off2, im.size[0] - off3, im.size[1] - off4))
roll_to_rotate = random.randint(1, 6)
if roll_to_rotate > 2:
amount_to_rotate = random.weibullvariate(1, 1.5)
im.rotate(amount_to_rotate)
# add the image to out set
words.append(
normalize_grayscale(np.array(im, dtype=np.float32).flatten()))
labels.append(item)
# advance to a new image if there is one
cur_pic += 1
if cur_pic == count:
cur_pic = 0
print(maxi)
return (np.array(words), np.array(labels))
def ejercicio02(n):
"""
Esperanza con Distribucion Weibull.
"""
a = 0
for _ in xrange(n):
a += random.weibullvariate(1, 1)
return a/float(n)
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 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 procCounter(self): # This slot takes no params
for j in range(1, 10):
random_time = random.weibullvariate(1, 2)
time.sleep(random_time)
self.intReady.emit(j, self.idd)
print('Worker {0} in thread {1}'.format(self.idd,
self.thread().idd))
self.finished.emit(self.idd)
def facturacion(personas):
global dt
global a
R = random.random() #obtener numero aleatorio
#tiempo=np.random.weibull(a , 7.76)
tiempo = int(random.weibullvariate(3.91, 7.76))
yield env.timeout(tiempo) #deja correr el tiempo n minutos
print("\o/ Facturacion lista a %s en %.2f minutos" % (personas, tiempo))
dt = dt + tiempo #acumula los tiempos
def windSpeed(
self, timeofday
): #source: http://www.wind-power-program.com/wind_statistics.htm
self.currWindSpeed += (
random.random() -
0.5) * 2 * self.windVariance * random.weibullvariate(
1, 0.5 + random.random())
if self.currWindSpeed < 0:
self.currWindSpeed = 0
return self.currWindSpeed
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_weibull(self, scale, shape):
count = 0
tasks = list()
while count < self.__amount:
weight = random.weibullvariate(scale, shape)
t = Task(count, weight, randint(1, 4),
(weight * randint(1, scale)))
tasks.append(t)
count += 1
return tasks
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 step(self, action):
air_mass = self.map * CYL_VOLUME * AIR_DENSITY # mg
#fuel_mass = 25.0 * (action[0] + 1.0) # mg
fuel_mass = 25 + 25.0 * action[0] # mg
#fuel_mass = action[0] * 100.0 # mg
#fuel_mass = action[0] # mg
#self.afr = min(max(air_mass/(fuel_mass+1.0), MIN_AFR), MAX_AFR)
self.far = min(max(fuel_mass / air_mass, MIN_FAR), MAX_FAR)
self.steps += 1
done = (self.steps % 10 == 0)
#done = True
# MAP random walk
#if (self.steps % 10 == 0):
# self.map = min(max(self.map + random.uniform(-0.2, 0.2), MIN_MAP), MAX_MAP)
#reward = 0.0 - ((self.afr - AFR_TARGET)**2)
#reward = 0.0 - (abs(self.afr - AFR_TARGET))
# help it to find the right AFR
#predicted_afr = air_mass/(fuel_mass+1.0)
predicted_far = fuel_mass / air_mass
#reward = 0.0 - ((self.afr - AFR_TARGET)**2) - ((predicted_afr - AFR_TARGET)**2)
#reward = 0.0 - 100.0 * ((self.far - FAR_TARGET)**2) - 100.0 * ((predicted_far - FAR_TARGET)**2)
#reward = 0.0 - 100.0 * (abs(self.far - FAR_TARGET)) - 100.0 * (abs(predicted_far - FAR_TARGET))
#reward = 0.0 - 1000.0 * ((self.far - FAR_TARGET)**2)
#reward = 0.0 - 10000.0 * abs(self.far - FAR_TARGET)
#reward = max(0.0 - 10000.0 * abs(self.far - FAR_TARGET), -200) # clamp the reward
#reward = 0.0 - 10000.0 * ((self.far - FAR_TARGET)**2)
reward = max(0.0 - 10000.0 * ((self.far - FAR_TARGET)**2),
-5) # clamp the reward
if (self.steps % 100 == 0):
#if (self.steps % 1 == 0):
afr = 1 / (self.far + 0.000001)
afr_err = afr - AFR_TARGET
far_err = self.far - FAR_TARGET
print(
f'step:{self.steps:8d} action:{action[0]:8.3f} map:{self.map:8.3f} air_mass:{air_mass:8.3f} fuel_mass:{fuel_mass:8.3f} far:{self.far:8.4f} far_err:{far_err:8.4f} afr:{afr:8.3f} afr_err:{afr_err:8.3f} rew:{reward:8.4f}'
)
# maybe change throttle position
#if (self.steps % 100 == 0):
#if self.map < 0.5:
# self.map = MAX_MAP
#else:
# self.map = MIN_MAP
#self.map = min(max(self.map + random.uniform(-0.2, 0.2), MIN_MAP), MAX_MAP)
# scale, shape
map_dot = (-1 if (self.steps % 2 == 0) else 1) * random.weibullvariate(
0.05, 1.0)
#print(f'map_dot:{map_dot:8.3f}')
self.map = min(max(self.map + map_dot, MIN_MAP), MAX_MAP)
return self.observation(), reward, done, {}
def time_to_failure():
"""Return time until next failure for a machine."""
if not useWeibull:
nextFailure = int(random.expovariate(BREAK_MEAN))
else:
# The Weibull distr. generates many errors.
#nextFailure = int(np.random.weibull(WEIBULL_K)*98.0) # Gives MTBF to be 200
#nextFailure = int(exponweib.rvs(1.0, WEIBULL_SHAPE, scale=WEIBULL_SCALE))
nextFailure = int(random.weibullvariate(WEIBULL_SCALE, WEIBULL_SHAPE))
#print("WEIBULL SCALE: %f, SHAPE: %f, nextFailure: %d" %(WEIBULL_SCALE, WEIBULL_SHAPE, nextFailure))
return nextFailure
def generate_currency_conv():
def daterange(start_date, end_date):
for n in range(int((end_date - start_date).days)):
yield start_date + datetime.timedelta(n)
while True:
root_value = random.weibullvariate(1, 3)
for cur_day in daterange(low_date, high_date):
yield {"day_value": cur_day, "to_aud": root_value}
root_value += random.gauss(0, root_value / 100)
def node_event_append(self):
num_node = self.nodeperrack*self.numrack
#print "num_node", num_node
for nodeid in range (num_node):
fail_flag=random.random()
if fail_flag>0.0:
#for tmp in range (self.diskpernode):
fail_time = random.weibullvariate(2890.8, 1.0)
#disk_id = tmp+nodeid*self.diskpernode
if fail_time <= self.mission_time:
self.events_queue.append((fail_time, nodeid, 1))
for nodeid in range(num_node):
#for tmp in range (self.diskpernode):
fail_flag=random.random()
if fail_flag>0.0:
fail_time = random.weibullvariate(91250., 1.0)
#disk_id = tmp+nodeid*self.diskpernode
if fail_time <= self.mission_time:
self.events_queue.append((fail_time, nodeid, 2))
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 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 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 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 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 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 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 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 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])
def xnoiseRythmSequence(self, parameters, barLength ):
rythmSequence = []
onsetTime = None
randomParamScaler = parameters.rythmRegularity[trackId] * 2 + 0.5
whichRandomGenerator = random.randint(0, 4)
maximumNumberOfNotes = int( (parameters.density[trackId]) * GenerationConstants.MAX_NOTES_PER_BAR)
for i in range(maximumNumberOfNotes):
while onsetTime in rythmSequence:
if whichRandomGenerator == 0:
onsetTime = random.expovariate(GenerationConstants.RANDOM_EXPO_PARAM * randomParamScaler)
elif whichRandomGenerator == 1:
onsetTime = 1 - random.expovariate(GenerationConstants.RANDOM_EXPO_PARAM * randomParamScaler)
elif whichRandomGenerator == 2:
onsetTime = random.gauss(GenerationConstants.RANDOM_GAUSS_PARAM1,
GenerationConstants.RANDOM_GAUSS_PARAM2 * (3 - randomParamScaler))
elif whichRandomGenerator == 3:
onsetTime = random.betavariate(GenerationConstants.RANDOM_BETA_PARAM * randomParamScaler,
GenerationConstants.RANDOM_BETA_PARAM * randomParamScaler)
elif whichRandomGenerator == 4:
onsetTime = random.weibullvariate(GenerationConstants.RANDOM_WEIBULL_PARAM1,
GenerationConstants.RANDOM_WEIBULL_PARAM2 * randomParamScaler)
onsetTime = int(onsetTime * (int(( barLength - 1) / GenerationConstants.DOUBLE_TICK_DUR))) * GenerationConstants.DOUBLE_TICK_DUR
if onsetTime < 0:
onsetTime = 0
elif onsetTime > ( barLength - GenerationConstants.DOUBLE_TICK_DUR):
onsetTime = ( barLength - GenerationConstants.DOUBLE_TICK_DUR)
else:
onsetTime = onsetTime
rythmSequence.append(onsetTime)
rythmSequence.sort()
return rythmSequence
def next(self):
return 1000 * (random.weibullvariate(0.1, 0.345))
def weibull(alpha, beta):
return lambda: random.weibullvariate(alpha, beta)
def make_word(words=None):
if words is None:
words = int(random.weibullvariate(8, 3))
return random.choice(loremipsum.words)
def make_sentence(words=None):
if words is None:
words = int(random.weibullvariate(8, 3))
return ' '.join(random.choice(loremipsum.words) for _ in range(words))
def sample(self):
return {self.value: random.weibullvariate(self.alpha, self.beta)}
def draw(self):
v = random.weibullvariate(self.scale, self.shape)
if v < self.location:
return self.location
return v
def FPP(log=Logger.logger(0), N = 10000, dt = 1./24000, distributionParameter = [30], plotAll = True, efield = False):
#check if rate file or rate is present
if len(distributionParameter) == 1:
try:
data = np.loadtxt(distributionParameter[0],delimiter = ' ')
log.info("Rate data loaded")
BGsim = True
STNdata = []
tick = []
for n in data:
STNdata.append(n[1])
tick.append(n[0])
Ratetime = pylab.cumsum(tick)
BGdt = tick[1]
timeSteps = int(Ratetime[-1]/dt)
except:
float(distributionParameter[0])
Ratetime = 1.
timeSteps = int(Ratetime/dt)
BGsim = False
else:
Ratetime = 1.
BGsim = False
timeSteps = int(Ratetime/dt)
maxrate = 1./0.009
times = []
for n in range(timeSteps):
times.append(dt*n)
# check for current file, if none present use impules
try:
It = np.loadtxt('C:\\Users\\Kristian\\Dropbox\\phd\\Data\\apcurrent24k.dat',delimiter = ',')
#/home/uqkweegi/Documents/Data/apcurrent24k.dat',delimiter = ',')
except:
log.error('no current file present')
It = np.array(1)
log.info('Current loaded')
It = np.multiply(np.true_divide(It,It.min()),250e-9) #normalize
currentLength = len(It)
#calculate extracellular effects
epsilon = 8.85e-12 #Permitivity of free space
rho = 10.**5 * 10.**6 #density of neurons in STN m^-3
r = np.power(np.multiply(3./4*N/(np.pi*rho),np.array([random.uniform(0,1) for _ in range(N)])),1./3) #create a power law distribution of neuron radii
r.sort()
if efield:
rijk = [[random.uniform(0,1)-0.5 for _ in range(N)],[random.uniform(0,1)-0.5 for _ in range(N)],[random.uniform(0,1)-0.5 for _ in range(N)]] #create vector direction of field
#if plotAll:
# vi = pylab.plot(rijk[0])
# vj = pylab.plot(rijk[1])
# vk = pylab.plot(rijk[2])
# pylab.show()
R3 = 0.96e3
C3 = 2.22e-6
C2 = 9.38e-9
C3 = 1.56e-6
C2 = 9.38e-9
R4 = 100.e6
R2N = np.multiply(1./(4*np.pi*epsilon),r)
R1 = 2100.;
t_impulse = np.array([dt*n for n in range(100)])
log.info('initialization complete')
Vt = pylab.zeros(len(times))
Vi = Vt
Vj = Vt
Vk = Vt
# start simulation
#-------------------------------------------------------------------------------#
for neuron in range(N):
R2 = R2N[neuron]
ppwave = pylab.zeros(len(times))
if BGsim:
absoluteTimes = np.random.exponential(1./(maxrate*STNdata[0]),1)
else:
if len(distributionParameter) == 1:
absoluteTimes = np.random.exponential(1./(distributionParameter[0]),1)
else:
absoluteTimes = [random.weibullvariate(distributionParameter[0],distributionParameter[1])]
while absoluteTimes[-1] < times[-1]-currentLength*dt:
wave_start = int(absoluteTimes[-1]/dt)
wave_end = wave_start+currentLength
if wave_end > len(times):
break
ppwave[wave_start:wave_end] = np.add(ppwave[wave_start:wave_end],It)
if BGsim:
isi = np.random.exponential(1./(maxrate*STNdata[int(absoluteTimes[-1]/BGdt)]),1)
else:
if len(distributionParameter) == 1:
isi = np.random.exponential(1./(distributionParameter[0]),1)
else:
isi = random.weibullvariate(distributionParameter[0],distributionParameter[1])
absoluteTimes = np.append(absoluteTimes,[absoluteTimes[-1]+isi])
# calculate neuron contribution
#------------------------------------------------------------------------------#
extracellular_impulse_response = np.multiply(np.multiply(np.exp(np.multiply(t_impulse,-20*17*((C2*R1*R2 + C2*R1*R3 + C2*R1*R4 - C3*R1*R3 + C3*R2*R3 + C3*R3*R4))/(2*C2*C3*R1*R3*(R2 + R4)))),(np.add(np.cosh(np.multiply(t_impulse,(C2**2*R1**2*R2**2 + 2*C2**2*R1**2*R2*R3 + 2*C2**2*R1**2*R2*R4 + C2**2*R1**2*R3**2 + 2*C2**2*R1**2*R3*R4 + C2**2*R1**2*R4**2 + 2*C2*C3*R1**2*R2*R3 - 2*C2*C3*R1**2*R3**2 + 2*C2*C3*R1**2*R3*R4 - 2*C2*C3*R1*R2**2*R3 - 2*C2*C3*R1*R2*R3**2 - 4*C2*C3*R1*R2*R3*R4 - 2*C2*C3*R1*R3**2*R4 - 2*C2*C3*R1*R3*R4**2 + C3**2*R1**2*R3**2 - 2*C3**2*R1*R2*R3**2 - 2*C3**2*R1*R3**2*R4 + C3**2*R2**2*R3**2 + 2*C3**2*R2*R3**2*R4 + C3**2*R3**2*R4**2)**(1/2)/(2*C2*C3*R1*R3*(R2 + R4)))),np.divide(np.sinh(np.multiply(t_impulse,(C2**2*R1**2*R2**2 + 2*C2**2*R1**2*R2*R3 + 2*C2**2*R1**2*R2*R4 + C2**2*R1**2*R3**2 + 2*C2**2*R1**2*R3*R4 + C2**2*R1**2*R4**2 + 2*C2*C3*R1**2*R2*R3 - 2*C2*C3*R1**2*R3**2 + 2*C2*C3*R1**2*R3*R4 - 2*C2*C3*R1*R2**2*R3 - 2*C2*C3*R1*R2*R3**2 - 4*C2*C3*R1*R2*R3*R4 - 2*C2*C3*R1*R3**2*R4 - 2*C2*C3*R1*R3*R4**2 + C3**2*R1**2*R3**2 - 2*C3**2*R1*R2*R3**2 - 2*C3**2*R1*R3**2*R4 + C3**2*R2**2*R3**2 + 2*C3**2*R2*R3**2*R4 + C3**2*R3**2*R4**2)**(1/2)/(2*C2*C3*R1*R3*(R2 + R4))))*(C2*R1*R2 - C2*R1*R3 + C2*R1*R4 + C3*R1*R3 - C3*R2*R3 - C3*R3*R4),(C2**2*R1**2*R2**2 + 2*C2**2*R1**2*R2*R3 + 2*C2**2*R1**2*R2*R4 + C2**2*R1**2*R3**2 + 2*C2**2*R1**2*R3*R4 + C2**2*R1**2*R4**2 + 2*C2*C3*R1**2*R2*R3 - 2*C2*C3*R1**2*R3**2 + 2*C2*C3*R1**2*R3*R4 - 2*C2*C3*R1*R2**2*R3 - 2*C2*C3*R1*R2*R3**2 - 4*C2*C3*R1*R2*R3*R4 - 2*C2*C3*R1*R3**2*R4 - 2*C2*C3*R1*R3*R4**2 + C3**2*R1**2*R3**2 - 2*C3**2*R1*R2*R3**2 - 2*C3**2*R1*R3**2*R4 + C3**2*R2**2*R3**2 + 2*C3**2*R2*R3**2*R4 + C3**2*R3**2*R4**2)**(1/2))))),-R4/(C2*(R2 + R4)));
electrode_ppwave = np.convolve(ppwave,extracellular_impulse_response,'same');
if efield: #add fields
amp = 1/np.sqrt((np.square(rijk[0][neuron])+np.square(rijk[1][neuron])+np.square(rijk[2][neuron])))
rijk[0][neuron] = rijk[0][neuron]*amp
rijk[1][neuron] = rijk[1][neuron]*amp
rijk[2][neuron] = rijk[2][neuron]*amp
Vi = np.add(Vi,np.multiply(electrode_ppwave,rijk[0][neuron]))
Vj = np.add(Vj,np.multiply(electrode_ppwave,rijk[1][neuron]))
Vk = np.add(Vk,np.multiply(electrode_ppwave,rijk[2][neuron]))
else: #add scalar
Vt = np.add(Vt,electrode_ppwave)
if np.mod(neuron,1000) == 999:
log.info(str(neuron+1)+" neurons calculated")
#------------------------------------------------------------------------------#
# end simulation
log.info('neuron contribution to MER complete')
#remove bias
if efield:
Vt = np.sqrt(np.add(np.square(Vi),np.square(Vj),np.square(Vk)))
Vt = np.subtract(Vt,np.mean(Vt))
#apply hardware filters
flow = 5500*2.
fhigh = 500.
b,a = signal.butter(18,flow*dt,'low')
Vt = signal.lfilter(b, a, Vt)
b,a = signal.butter(1,fhigh*dt,'high')
Vt = signal.lfilter(b, a, Vt)
#produce plots
if plotAll:
volts = pylab.plot(times,Vt)
if BGsim:
stnrate = pylab.plot(Ratetime,np.multiply(STNdata,200))
pylab.show()
nfft=2**int(math.log(len(Vt),2))+1
sr = 1/dt
Pxi,freqs=pylab.psd(x=Vt,Fs=sr,NFFT=nfft/10,window=pylab.window_none, noverlap=100)
pylab.show()
return freqs, Pxi
psd = pylab.loglog(freqs, Pxi)
pylab.show()
return Vt, times
def sample(self):
return weibullvariate(self.alpha,self.beta)
random.getrandbits(20)
state = random.getstate()
x1 = random.random()
random.setstate(state)
x2 = random.random()
assert x1==x2
tries = 8000
stat = [0,0,0,0,0,0]
for i in range(tries):
dice = random.randint(1,6)
stat[dice-1] += 1
print("STATISTICS ON {0} DICE THROWS".format(tries))
print("-----------------------------")
for i in range(0, 6):
percent = (float(stat[i]) * 100.) / float(tries)
print("{0} : {1} ({2:.1f}%)".format(i+1, stat[i], percent))
random.triangular(10,20,17)
random.normalvariate(10, 4)
random.lognormvariate(3, 1.6)
random.expovariate(3)
random.vonmisesvariate(2, 1)
random.gauss(10,4)
random.betavariate(10,4)
random.paretovariate(5)
random.weibullvariate(10,6)
