def test18():
for j in range(2):
print('---')
r=random.Random(-1)
r1=random.Random(-1)
d=sim.Exponential(3,r1)
sim.Environment(random_seed=-1)
for i in range(3):
print(sim.Exponential(3,r).sample())
print(sim.Exponential(3).sample())
print(d.sample())
def process(self):
timeStart = self.model.env.now()
yield self.hold(sim.Exponential(self.model.procTime).sample())
self.release()
timeEnd = self.model.env.now()
self.model.procTimeList.append(timeEnd-timeStart)
self.model.numDep += 1
def process(self):
while True:
if not waiting_clients:
yield self.wait(work_to_do)
this_client = waiting_clients.pop()
yield self.hold(sim.Exponential(server_time).sample())
this_client.activate()
def process(self):
while True:
passive_condition = True
for i in self.wline_idx:
passive_condition = passive_condition and len(
WaitingLines[i].queue) == 0
if passive_condition == True:
yield self.passivate()
# Pick the call waiting for the longest time:
wlines = []
for i in self.wline_idx:
if len(WaitingLines[i].queue) != 0:
wlines.append(WaitingLines[i])
min_wline = min(wlines, key=lambda x: x.queue[0].arrival_time)
self.job = min_wline.queue.pop()
processing_time = sim.Exponential(1).sample() + truncated_normal(
proc_mean, proc_sd)
# Update the active time:
if processing_time + env.now() <= run_time:
self.active_time += processing_time
else:
self.active_time += run_time - env.now()
yield self.hold(processing_time)
self.calls_completed[self.job.language] += 1
self.job.activate()
def process(self):
while True:
yield self.hold(sim.Exponential(iat).sample())
ship = Ship(name=sidename(self.side) + 'ship.')
ship.side = self.side
ship.length = meanlength * sim.Uniform(2 / 3, 4 / 3).sample()
if lock.mode() == 'Idle':
lock.activate()
def process(self):
while True:
if not waiting_clients:
self.atwork.set('gray')
yield self.wait(work_to_do)
this_client = waiting_clients.pop()
self.atwork.set(this_client.sequence_number())
yield self.hold(sim.Exponential(server_time).sample())
this_client.activate()
def process(self):
while True: # Infinite loop to generate ships
yield self.hold(sim.Exponential(iat).sample())
ship = Ship(name=sidename(self.side) +
"ship.") # The name os the ship is lship.# of rship.#
ship.side = self.side
ship.length = meanlength * sim.Uniform(2.0 / 3, 4.0 / 3).sample()
if lock.mode() == "Idle": # If lock is idle then activate it
lock.activate()
def process(self, waitTime):
for i in range(1,2*BULKFLOWS,2):
bulkPacketGenerator(pid=i,interTime=((QUANTUM/BANDWIDTH)-(1.0/BANDWIDTH)),distribution="uniform")
yield self.hold((BULKFLOWS*QUANTUM)/BANDWIDTH)
for i in range(0,2*SPARSEFLOWS,2):
sparsePacketGenerator(pid=i,interTime=waitTime*INTERARRIVALMULTIPLIER, distribution="uniform")
yield self.hold(sim.Exponential(waitTime/SPARSEFLOWS).sample())
def process(self):
while True:
timeStart = self.model.env.now()
yield self.hold(sim.Exponential(self.model.intArrTime).sample())
timeEnd = self.model.env.now()
self.model.arrTimeList.append(timeEnd-timeStart)
customer = self.model.createEntity()
customer.model = self.model
customer.queue = self.model.queue
customer.server = self.model.server
self.model.customerArrList.append(customer)
self.model.numArr += 1
def process(self):
if self.model.maxLen > 0:
if len(self.model.server.requesters()) >= self.model.maxLen:
self.model.number_balked += 1
self.model.env.print_trace("", "", "balked")
yield self.cancel()
yield self.request(self.model.server)
timeStart = self.model.env.now()
yield self.hold(sim.Exponential(self.model.procTime).sample())
self.release()
timeEnd = self.model.env.now()
self.model.procTimeList.append(timeEnd-timeStart)
self.model.numDep += 1
def process(self,pid, interTime, distribution="uniform"):
if distribution is "uniform":
while True:
packet(name='bpacket-' + str(pid), pid=pid, size=QUANTUM)
yield self.hold(interTime)
elif distribution is "exponential":
while True:
packet(name='bpacket-' + str(pid), pid=pid, size=QUANTUM)
yield self.hold(sim.Exponential(interTime).sample())
else:
print("INVALID DISTRIBUTION")
yield self.cancel
def process(self):
env.print_trace('', self.name(), 'arrrived')
patience = sim.Uniform(MIN_PATIENCE, MAX_PATIENCE).sample()
yield self.request(counter, fail_delay=patience)
wait = env.now() - self.creation_time()
if self.failed():
# We reneged
env.print_trace('', self.name(),
'RENEGED after {:6.3f}'.format(wait))
else:
# We got to the counter
env.print_trace('', self.name(), 'waited for {:6.3f}'.format(wait))
yield self.hold(sim.Exponential(TIME_IN_BANK).sample())
env.print_trace('', self.name(), 'finished')
def process(self,pid, interTime, distribution="uniform"):
spSize = 0
if int(SPARSESIZE) == -1 * 8:
spSize = QUANTUM/2
else:
spSize = SPARSESIZE
if distribution is "uniform":
while True:
packet(name='spacket-' + str(pid), pid=pid, size = spSize )
yield self.hold(interTime)
elif distribution is "exponential":
while True:
packet(name='spacket-' + str(pid), pid=pid, size = spSize)
yield self.hold(sim.Exponential(interTime).sample())
else:
print("INVALID DISTRIBUTION")
yield self.cancel
def process(self):
i = lang_idx[self.language]
self.enter(WaitingLines[i].queue)
# The call will be taken by the employee who is available, speaks the same language and has the least active time:
avl_employees = []
for Employee in Employees:
if self.language in Employee.languages and Employee.ispassive():
avl_employees.append(Employee)
if len(avl_employees) > 0:
min_employee = min(avl_employees, key=lambda x: x.active_time)
min_employee.activate()
# The patient hangs up after waiting for some time:
yield self.hold(7 + sim.Exponential(2).sample())
if self in WaitingLines[i].queue:
self.leave(WaitingLines[i].queue)
num_reneged[i] += 1
else:
yield self.passivate()
def test43():
def test(d):
d.print_info()
print('mean=', d.mean())
l=[d() for i in range(10000)]
print('one sample', d())
print('mean sampled =', sum(l)/(len(l)+1))
print('-' * 79)
env=sim.Environment()
test(sim.IntUniform(1,6))
test(sim.Weibull(2,1))
test(sim.Gamma(5,9))
test(sim.Erlang(2,scale=3))
test(sim.Exponential(rate=2))
test(sim.Beta(32,300))
test(sim.Normal(5,7))
test(sim.Normal(5,7,use_gauss=True))
test(sim.Distribution('Exponential(rate=2)'))
test(sim.Normal(5,5))
def setup(self, inter_arrival_time_dist, number_of_tasks_dist, group_dist, duration_dist):
self.inter_arrival_time_dist = sim.Exponential(8)
self.number_of_tasks_dist = sim.IntUniform(1, 9)
self.group_dist = group_dist
self.duration_dist = duration_dist
def process(self):
while True:
yield self.hold(sim.Exponential(1)())
Car()
def process(self):
while True:
yield self.hold(sim.Exponential(rate=0.83)())
env.count += 1
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.distr = sim.Bounded(sim.Exponential(30.9012), upperbound=200)
def test7():
print('test7')
class X1(sim.Component):
def process(self):
yield self.request(r1,5,r2,2,greedy=True,fail_at=5)
yield self.passivate()
class X2(sim.Component):
def process(self):
yield self.request(r1,8,r2)
yield self.passivate()
class X3(sim.Component):
def process(self):
yield self.request(r1,7)
yield self.passivate()
de=sim.Environment(trace=True)
x1=X1()
x2=X2()
x3=X3()
X4=sim.Component()
r1=sim.Resource(capacity=10,anonymous=True)
r2=sim.Resource()
r3=sim.Resource()
q={}
for i in range(1,5):
q[i]=sim.Queue()
x1.enter(q[1])
x1.enter(q[2])
x1.enter(q[3])
x2.enter(q[1])
x3.enter(q[1])
env.run(10)
r2.capacity(2)
env.run(20)
print(sim.default_env)
print(x1)
print(x2)
print(x3)
print (q[1])
print (q[2])
print (q[3])
print (q[4])
print(r1)
print(r2)
print(r3)
d=sim.Exponential(10)
print(d)
print(sim.Uniform(1,2))
print(sim.Triangular(40,150,55))
print(sim.Distribution('Constant(5)'))
yield self.hold(driving_duration)
self.x = order.customer.x
self.y = order.customer.y
order.leave() # leave all (two) queues the order is in
env = sim.Environment(trace=True, random_seed=1021021)
x_min = 25
y_min = 25
x_max = 1000
y_max = 550
n_drivers = 3
n_restaurants = 5
n_customers = 25
v = 10
inter_arrival_time = sim.Exponential(1000)
env.x_dis = sim.Uniform(x_min, x_max)
env.y_dis = sim.Uniform(y_min, y_max)
env.customers = [Customer(inter_arrival_time=inter_arrival_time) for _ in range(n_customers)]
env.drivers = [Driver(v=v) for _ in range(n_drivers)]
env.restaurants = [Restaurant() for _ in range(n_restaurants)]
env.orders=sim.Queue('all orders')
env.run(100)
env.trace(False)
env.run(till=100000)
env.orders.print_histograms()
def process(self):
while True:
i = np.random.choice(len(self.languages), 1, p=self.lang_dist)[0]
Call(self.languages[i])
self.calls_generated += 1
yield self.hold(sim.Exponential(arr_mean).sample())
def process(self):
while True:
yield self.hold(int(sim.Exponential(40).sample(
))) # every 10-20 years there's a new heir of the throne
Prince()
import salabim as sim
class ClientGenerator(sim.Component):
def process(self):
while True:
yield self.hold(inter_arrival_time_dis.sample())
Client()
class Client(sim.Component):
def process(self):
yield self.request(clerks)
yield self.hold(service_duration_dis.sample())
env = sim.Environment(trace=True)
number_of_clerks = 5
inter_arrival_time_dis = sim.Exponential(1)
service_duration_dis = sim.Exponential(4)
clerks = sim.Resource(name="clerks", capacity=number_of_clerks)
ClientGenerator()
env.run()
def process(self):
while True:
yield self.hold(sim.Exponential(iat).sample())
Client()
def process(self):
self.enter(system)
yield self.request(servers)
yield self.hold(sim.Exponential(server_time).sample())
self.leave()
def process(self):
yield self.request(servers)
yield self.hold(sim.Exponential(server_time).sample())
def process(self):
for i in range(NEW_CUSTOMERS):
Customer()
yield self.hold(sim.Exponential(INTERVAL_CUSTOMERS).sample())
# OK, now wait to get out onto the street; every time a new car
# arrives in cross traffic, it will signal us to check the new
# next arrival time
while env.now() + time_to_exit >= street.nextarrival:
yield self.wait(wakeup, mode='wait for wakeup')
yield self.hold(time_to_exit, mode='exit')
self.release(bufferfront)
self.release(buffer)
class CarWash(sim.Component):
def process(self):
while True:
yield self.hold(wash_iat.sample())
Car()
env = sim.Environment(trace=True)
wakeup = sim.State(name='wakeup')
wash_time = sim.Pdf((1.0, 0.7, 2.0, 0.3))
street_iat = sim.Exponential(1)
wash_iat = sim.Exponential(1)
buffer = sim.Resource(capacity=4)
bufferfront = sim.Resource()
bay = sim.Resource()
time_to_exit = 1
CarWash()
street = Street()
env.run(500)
