Universidad Central de Venezuela Facultad de Ciencias Escuela de Computacin Lecturas en Ciencias de la Computacin

ISSN 1316-6239

Introduccin a SimPy
Prof. Eliezer Correa Prof. Sergio Rivas
ND 2010-02

Centro de Investigacin de Operaciones y Modelos Matemticos (CIOMMA) Caracas, Enero 2010.

!"#$%"&'
SimPy1 es un proyecto con licencia de Software Libre escrito en Python para desarrollar simulacin basada en eventos discretos con el enfoque de interaccin de procesos. SimPy permite la simulacin del comportamiento del sistema a travs del tiempo especificando las entidades, sus procesos y las interacciones entre ellas. SimPy contiene distintas clases para su uso en la simulacin de sistemas entre otros: manejar del tiempo basado en eventos discretos, recolectar estadsticos relacionados con la simulacin, simular sistemas de colas. Adems permite realizar trazas de la simulacin, simulacin en tiempo real, despliegue de histogramas, etc. Este trabajo es una introduccin al uso de SimPy como librera basada en Python en Simulacin. Palabras Clave: SimPy, Simulacin basada en eventos discretos, Python, DES. Contactos: Prof. Sergio Rivas (sergio.rivas@ciens.ucv.ve) Prof. Eliezer Correa(eliezer.correa@ciens.ucv.ve)

SimPy: Sitio oficial http://simpy.sourforge.org

()*+)',"'-.&/"&0,.'
!"#$%&'()**+,$ -------------------------------------------------------------------------------------------------------------------------------------------------- !! ."!"#$% ---------------------------------------------------------------------------------------------------------------------------------------------------------------- .!
.-!"/&'*01'1 ------------------------------------------------------------------------------------------------------------------------------------------------------------------2! .-."34*+5+%+01 ------------------------------------------------------------------------------------------------------------------------------------------------------------------6! "#"#$!!"#$%&'&!%&'()*+,'(-. ######################################################################################################################################################/! "#"#"!()*"+"&!%0'1'2(-.##################################################################################################################################################################/! "#"#3!4256,'7'(!%89)+'(-.##########################################################################################################################################################:!

2"#$1%&)**+'$01"781+*41"94&4"05":4$0;'"(0"<+=)54*+,$ ---------------------------------------------------------------------- >! 6":'$+%'&01 ------------------------------------------------------------------------------------------------------------------------------------------------------- ?! @"A;0=95'1"0$"!"#$% --------------------------------------------------------------------------------------------------------------------------------------- ?!

@-!"A;0=95'"!B"C'54":)$(' --------------------------------------------------------------------------------------------------------------------------------------D! @-."A;0=95'".B"3)0E'1"4&%+F+*+4501 -------------------------------------------------------------------------------------------------------------------------- G! @-2"A;0=95'"2B"74$*'"<+=950 -------------------------------------------------------------------------------------------------------------------------------- !H! @-6"A;0=95'"6B"74$*'"*'$"I4J)+5541"K"01%4(L1%+*41 ---------------------------------------------------------------------------------------- !!!

>"M'$*5)1+'$01------------------------------------------------------------------------------------------------------------------------------------------------!6! ?"7+N5+'E&4FL4 --------------------------------------------------------------------------------------------------------------------------------------------------!@!

ii

Notas de SimPy

1'2&/3.,$4405&'
SimPy es un librera para implantar modelos de simulacin basados en eventos discretos orientado a procesos. Dicha librera est escrita en el lenguaje de programacin Python, y este trabajo sirve como manual introductorio al uso de SimPy en la simulacin. A continuacin se presentarn las entidades en SimPy (concepto fundamental en la librera para la simulacin), sus tipos y sus usos en diversos contextos. Finalmente se muestran varios programas ejemplos con sus respectivas salidas que muestran su uso. Aunque para conocer SimPy es necesario conocer el lenguaje Python, sin embargo, este lenguaje es fcil de aprender (sus instrucciones y sintaxis bsica).

Notas de SimPy

6'!"#$%'
SimPy es una librera de simulacin manejada por eventos discretos2 orientada a procesos escrito en el lenguaje Python. Esta librera es orientada a objetos y su licencia es abierta del tipo LGPL (gnu.org), siendo la ltima actualizacin (versin 2.0.1) liberada en Abril del 2009. SimPy abstrae el sistema en entidades que interactan entre s. En forma general, existen dos tipos de entidades: las entidades activas y las entidades pasivas. Las entidades activas son las que se mueven en el sistema como: clientes, mensajes, vehculos. (Estas entidades en SimPy deben ser heredadas de la clase Process). Las entidades pasivas llamadas Facilities al contrario de las entidades activas no se mueven en el sistema (por ejemplo: servidores, taquillas, tanques, etc.) y estn en el sistema esperando interactuar con las entidades activas. SimPy trae consigo la implantacin de algunas facilities con comportamiento definido. En SimPy, la simulacin consiste en definir las entidades activas y pasivas, y las actividades que realizan estas. Las actividades de un proceso de una entidad puede ser interrumpida, activada y reactivadas. Adems, las facilities tienen mtodos para poder hacerle solicitudes. La simulacin basada en eventos discretos usa una lista de eventos para el avance del reloj de simulacin. SimPy maneja esta lista de forma implcita, sin embargo es posible manejar los eventos a bajo nivel. SimPy tiene un conjunto de instrucciones para cada una de las necesidades de un desarrollo de simulacin manejada por eventos. A continuacin se describen algunas de esas instrucciones: Instrucciones bsicas de simulacin: Tiene todas las instrucciones de la simulacin, como por ejemplo: iniciar la simulacin, detener la simulacin, etc. Instrucciones de entidades activas: Estas instrucciones son las que permiten intervenir en el comportamiento del seguimiento el proceso una entidad activa, implcitamente planifican eventos en la lista de eventos relacionados con la entidad, como por ejemplo: iniciar o reiniciar

Simulacin basada en eventos discretos: Simulacin del sistema donde el estado del sistema cambia en puntos determinados del tiempo, y el tiempo va saltando entre esos puntos discretos del tiempo. Banks Jerry, C. J. (2005). Discrete Event System Simulation (Cuarta Edicin ed.). Prentice Hall.

Notas de SimPy

(activar), detener temporalmente (hacerlo esperar) o detener (interrumpir) definitivamente un proceso. Instrucciones para las facililies: Instrucciones bsicas para la interaccin de las entidades activas con las facilities, como por ejemplo: solicitar un recurso a una facility. Instrucciones para el monitoreo: Estas instrucciones permiten recolectar y calcular estadsticos de la simulacin, por ejemplo: calcular el promedio de entidades activas que tuvieron que entrar en una cola. Instrucciones para el manejo de eventos: Estas instrucciones permiten interactuar directamente con la lista de eventos discretos, como por ejemplo: agregar un evento a la lista. Adems para realizar una simulacin estocstica, se cuenta con las instrucciones de Python que permiten generar valores de variables aleatorias y nmeros pseudo-aleatorios. Esta librera de simulacin permite implantar un modelo de simulacin en alto nivel, por lo que el desarrollador se puede enfocar ms en las entidades y su comportamiento, y no en los eventos de la simulacin. Por otro lado, el hecho de estar basada en Python se puede usar todo el conjunto de libreras de Python de este lenguaje, como por ejemplo, libreras de interfaz grfica, libreras matemticas, de red, etc., lo cual es una ventaja comparativa considerable respecto a otros lenguajes de simulacin.

&'()$*+,-.+.'
Los procesos definen un conjunto de actividades a realizar por una entidad del sistema. Un sistema en SimPy se puede ver como un conjunto entidades llevando a cabo sus procesos a travs del tiempo. El implementador se enfoca en definir esos procesos y la interaccin de las entidades en el sistema. Para implementar los procesos en SimPy, la entidad que lleva a cabo el proceso debe heredar de la Clase Process; luego, dentro de esa clase debe existir al menos un mtodo del tipo Mtodos de Ejecucin de Procesos (Process Execute Method PEM), estos mtodos PEM son los son la forma de representar procesos y se ejecutan de forma planificada en la lista de eventos con la instruccin activate. Toda entidad activa debe tener por lo menos un mtodo PEM, el cual tiene al menos una

Notas de SimPy

instruccin yield. La instruccin yield, es una instruccin especial que permite ceder el control al manejador de la lista de eventos discretos, y ser explicada en detalle ms adelante.

&'&)/0,"1"2"-.)
Las facilities son clases preconstruidas que permiten al programador emular el comportamiento de servidores, tanques, y otras entidades pasivas en la simulacin. Ellas tienen: mtodos, recolectores de estadsticas y estructuras de colas para la simulacin. Las facilities representan objetos que frecuentemente se encuentran en problemas de simulacin de lnea de espera (colas) e inventario. SimPy tiene 3 tipos de facilities (Recursos, Niveles, Almacenes) los cuales son:

67671'3-,4*.+.'8!"#.$34"#9:''

'

Los recursos son facilities que poseen una o ms unidades de un mismo tipo. Las entidades activas pueden pedir slo una de esas unidades a la vez, ocuparla el tiempo que la necesite y luego liberarla. La cantidad de unidades que almacena un recurso es definida en la creacin del recurso. Cuando un entidad activa solicita una unidad de un recurso dado y no existen disponibles, la entidad se bloquea y se encola en una lista de espera por alguna unidad del recurso disponible a futuro. Luego cuando otra entidad libera una unidad del recurso, el recurso activa la prxima a entidad encolada que le corresponda acceder a esa unidad recin liberada. Adicionalmente el recurso tiene otra cola que contiene las entidades que actualmente estn usando alguna unidad del recurso. Un ejemplo de recurso puede ser un sistema de cajeros o taquillas con una sola cola, y las entidades son los clientes que solicitan el servicio en la taquilla.

67676'5"6-1-.'8;"<"+#9:''
Los niveles son facilities que poseen una o ms unidades de un mismo tipo. Las entidades activas pueden pedir varias unidades simultneamente, ocuparlas el tiempo que sea necesario y luego liberarlas. La cantidad de unidades que almacena (capacidad) un nivel es definida en la creacin del mismo. Las entidades pueden solicitar o colocar unidades en el nivel. Un ejemplo de nivel sera un tanque de gasolina, donde las entidades son carros (consumidores de unidades del nivel) y gandolas (consumidoras/proveedoras de unidades del nivel). Cuando un entidad activa solicita unidades de un nivel dado y no existen suficientes

Notas de SimPy

disponibles, la entidad se bloquea y se encola en una lista a la espera de suficientes unidades de ese nivel. Luego cuando otra entidad coloca unidades en el nivel, este activa la prxima entidad encolada que le corresponda acceder a esas unidades, de ser suficiente. Cuando un entidad activa coloca unidades de un nivel dado y no existe capacidad suficiente de almacenarlas, la entidad se bloquea y se encola en una lista a la espera de suficientes espacio para colocar sus unidades de ese nivel. Luego cuando otra entidad solicita unidades en el nivel, este activa la prxima entidad encolada que le corresponda colocar unidades, de existir espacio suficiente. Adicionalmente el nivel tiene otra cola que contiene las entidades que actualmente estn usando unidades del nivel. La diferencia ms resaltante entre un nivel y un recurso es que en el nivel se pueden solicitar una o ms unidades mientras que en el recurso solo se puede solicitar una unidad al sumo.

6767='>+%)4"&"#'8?/.3"#9:''
Los almacenes son facilities que poseen una o ms unidades de un distintos tipo. Las entidades activas pueden pedir varias unidades de distinto tipo simultneamente, ocuparlas el tiempo que sea necesario y luego liberarlas. La cantidad de unidades y tipos que almacena (capacidades por tipo) un almacn es definida en la creacin del mismo. Las entidades pueden solicitar o colocar unidades en el almacn. Un ejemplo de almacn a sera un tienda por departamentos, donde las entidades son cliente (consumidores de unidades del almacn) y proveedores de unidades del almacn. Cuando un entidad activa solicita unidades de un almacn dado y no existen suficientes disponibles de los tipos correspondiente, la entidad se bloquea y se encola en una lista a la espera de suficientes unidades de ese almacn. Luego cuando otra entidad coloca unidades en el almacn, este activa la prxima entidad encolada que le corresponda acceder a esas unidades, de ser suficiente. Cuando un entidad activa coloca unidades de un almacn dado y no existe capacidad suficiente de almacenarlas por tipo, la entidad se bloquea y se encola en una lista a la espera de suficientes espacio para colocar sus unidades de ese almacn. Luego cuando otra entidad solicita unidades en el almacn, este activa la prxima entidad encolada que le corresponda colocar unidades, de existir espacio suficiente. Adicionalmente el almacn tiene otra cola que contiene las entidades que actualmente estn usando unidades del almacn. Cada una de estas facilities antes introducidas tienen otros atributos como los recolectores

Notas de SimPy

estadsticos de la variacin de la longitud de las colas y distintas polticas configurables para las colas asociadas (LIFO, FIFO o por Prioridad).

='2&#/3$440.&"#'@A#04)#'B)3)'"+'C)&"D.',"'?0%$+)405&'
En el manejo de simulacin es necesario algunas instrucciones para llevar el control de la simulaciones; las ms importantes se listan a continuacin con sus parmetros bsicos: initialize() simulate(until=endtime) Coloca la el reloj de simulacin en 0, e inicializa la corrida. Inicia la corrida de la simulacin, y la finaliza hasta lo indicado por endtime. Tiene otros parmetros para hacer simulacin por pasos o por trazas. stopSimulation() now() activate(entidad, entidad.PEM(args)) Termina la simulacin de inmediato. Retorna la hora del reloj de simulacin. Inicia la corrida asncrona del mtodo PEM en el momento actual. Tiene otros parmetros opcionales como por ejemplo: indicar otro instante de activacin diferente al instante en el que se ejecuta esta instruccin y prioridad de activacin. yield hold,<obj>,<tiempo> yield request,<obj>,<rec> Bloquea a la entidad <obj> durante el tiempo <tiempo> Hace que la entidad <obj> solicite el recurso <rec>. Si el recurso no tiene unidades lo bloquea, de lo contrario le brinda la unidad del recurso solicitado. yield release, <obj>,<rec> Hace que la entidad <obj> libere el recurso <rec>. Si existen entidades esperando por el recurso, toma el prximo y lo libera. yield put,<obj>,<niv>,<cant> Hace que la entidad <obj> ponga <cant> unidades en el nivel <niv>. Si existen entidades bloqueadas por la espera de unidades se desbloquean de aplicar. yield get,<obj>,<niv>,<cant> Hace que la entidad <obj> obtenga <cant> unidades del nivel <niv>. Si existen entidades esperando por poner unidades, toma el prximo y lo libera.

Notas de SimPy

yield put,<obj>,<alm>,<lis>

Hace que la entidad <obj> ponga la lista de cantidades a colocar <lis> en el almacn <alm>. Si existen entidades bloqueadas por la espera de unidades se desbloquean de aplicar.

yield get,<obj>,<alm>,<lis>

Hace que la entidad <obj> obtenga la lista de cantidades solicitadas <lis> del almacn <alm>. Si existen entidades esperando por poner unidades, toma el prximo y lo libera.

E'C.&0/.3"#'
Un monitor es una clase encargada de recolectar observaciones de cambios de variables en el tiempo de inters (por ejemplo: cantidad de clientes en el sistema) con el fin de tomar medidas estadsticas de la simulacin. La clase Monitor tiene un mtodo observe(x) la cual almacena el valor observado x en un instante dado, para luego poder obtener indicadores estadsticos acerca de valores observados en diferentes instantes del tiempo. Los mtodos ms importantes del monitor son: mean(): retorna promedio de los valores observados. var(): retorna varianza muestral de los valores observados. count(): retorna cantidad de valores observados. yseries(): retorna arreglo de los valores observados. tseries(): retorna los tiempo en los cuales se observ cada valor segn el reloj de simulacin. timeAverage(): retorna el promedio pesado por el tiempo de los valores observados. Es importante mencionar que las facilities antes mencionadas tienen monitores (si se activan), los monitores observan el tamao de las colas. Para activar los monitores en la creacin de la instalacin se debe especificar monitored=True, y para acceder a los monitores se usa facility.waitMon (monitor de la cola de espera) y facility.activeMon (monitor de los que estn usando la instalacin).

F'GD"%B+.#'"&'!"#$%'
A continuacin se mostrarn ejemplos documentados acerca del funcionamiento de SimPy.

Notas de SimPy

7'()89-#:1+)(;)<+10)=4>?+)
Este modelo simula a una persona que entra a un restaurante tarda un tiempo distribuido uniformemente entre 15 y 25 minutos para comer y luego se va. Se resalta lo siguiente: Se importar la librera de SimPy. Se importar la librera random de Python para usar el generador de valores aleatorios. Se define la clase Persona la cual es una entidad activa y hereda de la clase Process que provee SimPy. Dentro de la clase se define un mtodo PEM con nombre comer el cual representa el proceso de comer de la Persona. Se usa el mtodo yield, hold, t para esperar el tiempo uniforme. Se usa el mtodo now() para obtener el reloj del simulacin. El programa principal consiste en instanciar a una Persona, inicializar la simulacin, planificar la activacin del proceso comer de la Persona, e iniciar la simulacin hasta 400 unidades de tiempo.
from SimPy.Simulation import * #libreria de SymPy from random import * #Generadores de valores aleatorios # Componentes del modelo class Persona(Process): def comer(self): """Metodo PEM que representa la actividad de comer """ print "%7.4f: Llegada "%(now()) t = uniform(15.0,25.0) # se genera un valor uniforme yield hold,self,t #Se espera el tiempo t como el tiempo de la visita print "%7.4f: Salida"%(now())

# Programa principal p = Persona() #instanciando a la persona initialize() #inicializa el reloj de simulacion activate(p,p.comer()) #invocando a comer simulate(until=400.0) #inicio de la simulacion hasta el tiempo 400

Salida:
0.0000: Llegada

Notas de SimPy
17.7301: Salida

7'&)89-#:1+)&;)/4-@+.)0*2"A","01-.)
Un lanzador lanza 3 cohetes secuencialmente, donde cada cohete explota despus de tiempo que sigue una variable aleatoria con distribucin normal con media 15 segundos y desviacin estndar 5 segundos, el lanzador tarda 3 segundos en encender cada cohete, por cada cohete se imprime cuando explota. Se resalta lo siguiente: Se definen las clases Lanzador y Cohete, esta ltima es una entidad activa y hereda de la clase Process que provee SimPy. Dentro de la clase Cohete se define un mtodo PEM con nombre lanzamiento el cual representa el proceso de lanzamiento del Cohete. Se usa el mtodo normalvariate para generar valores de una variable aleatoria normal. En el mtodo activate se especifica el parmetro at, el cual expresa cuando debe activarse segn el reloj de simulacin
from SimPy.Simulation import * #libreria de SymPy from random import * #Generadores # Componentes del modelo class Lanzador: def iniciar(self): """Metodo que lanza los 3 cohetes """ c1=Cohete(name="Cohete 1") #se le coloca nombre heredado de Process activate(c1,c1.lanzamiento()) c2=Cohete(name="Cohete 2") activate(c2,c2.lanzamiento(),at=3.0) c3=Cohete(name="Cohete 3") activate(c3,c3.lanzamiento(),at=6.0)

class Cohete(Process): def lanzamiento(self): """Metodo PEM que representa la actividad de lanzar el cohete """ t = normalvariate(15.0,5.0) # se genera un valor yield hold,self,t #Se espera el tiempo t

Notas de SimPy
print "%7.4f: Exploto %s"%(now(),self.name)

# Programa principal l = Lanzador() #instanciando al lanzador initialize() #inicializa el reloj de simulacion l.iniciar() simulate(until=400.0) #inicio de la simulacion hasta el tiempo 400

Salida:
13.3386: Exploto Cohete 1 17.9835: Exploto Cohete 3 20.8891: Exploto Cohete 2 3.3 Ejemplo 3: Banco Sencillo

7'B)89-#:1+)B;)C0>,+)!"#:1-)
Modelo del banco sencillo con una taquilla. Al banco llegan 5 clientes con tiempo interarribo promedio de 10min distribuidos exponencialmente, cada cliente consume un tiempo de 12min y se simula hasta que el reloj tenga 400min. Al final de la simulacin se imprime la llegada y salida de un cliente. Se resalta lo siguiente: Se definen las clases Generador y Cliente. Ambas son entidades activas y heredan de la clase Process que provee SimPy. Se usa el mtodo expovariate para generar valores de una variable aleatoria exponencial.

from SimPy.Simulation import * #libreria de SymPy from random import * #Generadores # Componentes del modelo class Generador(Process): """ Representa al generador de clientes """

def generar(self,cantidad,interarribo): """ Metodo PEM que genera los clientes """

10

Notas de SimPy
for i in range(cantidad): c = Cliente(name = "Cliente%02d"%(i,)) activate(c,c.servirse(t=12.0)) #Se envia al cliente generado a servirse t = expovariate(1.0/interarribo) yield hold,self,t #Se espera el tiempo t como tiempo entre clientes

class Cliente(Process): def servirse(self,t): """Metodo PEM que representa la actividad de visitar """ print "%7.4f %s: Llegando "%(now(),self.name) yield hold,self,t #Se espera el tiempo t como el tiempo de la visita print "%7.4f %s: Saliendo "%(now(),self.name) # Programa principal initialize() #inicializa el reloj de simulacion g = Generador() #instanciando a un generador activate(g,g.generar(cantidad=5,interarribo=10.0),at=0.0) #invocando al generador simulate(until=400.0) #inicio de la simulacion hasta el tiempo 400

Salida:
0.0000 Cliente00: Llegando 0.0057 Cliente01: Llegando 2.2897 Cliente02: Llegando 4.0111 Cliente03: Llegando 12.0000 Cliente00: Saliendo 12.0057 Cliente01: Saliendo 12.4169 Cliente04: Llegando 14.2897 Cliente02: Saliendo 16.0111 Cliente03: Saliendo 24.4169 Cliente04: Saliendo

7'D)89-#:1+)D;)C0>,+),+>)E0F4"110.)%)-.20?G.2",0.))
Modelar el banco con 3 taquillas. Al banco llegan clientes con tiempo interarribo promedio de 3min distribuidos exponencialmente. Si al llegar un cliente, ste consigue las 3 taquillas ocupadas ser encolado. Luego, cuando le llegue su turno consumir un tiempo sirvindose de 12min en la taquilla.

11

Notas de SimPy

Se simula hasta que el reloj tenga 400min. Durante la simulacin se imprime tamao de la cola promedio de clientes. Se resaltan los siguientes aspectos: Se definen las clases Generador y Cliente. Ambas son entidades activas y heredan de la clase Process que provee SimPy. Se define el banco como un recurso con capacidad 3 y se activan los monitores. Cada cliente hace una peticin del recurso, lo usa y luego lo libera. El recurso se encarga de encolarlo si aplica, as como tambin, desencolarlo para darle la taquilla cuando le corresponda. Se usan los monitores del recurso (banco) para calcular el tamao de la cola promedio pesado por el tiempo.
from SimPy.Simulation import * #libreria de SymPy from random import * #Generadores # Componentes del modelo class Generador(Process): """ Representa al generador de clientes """

def generar(self,interarribo): """ Metodo PEM que genera los clientes """ i=1 while True: c = Cliente(name = "Cliente%02d"%(i,)) activate(c,c.servirse(t=12.0)) #Se envia al cliente generado a servirse t = expovariate(1.0/interarribo) yield hold,self,t #Se espera el tiempo t como tiempo entre clientes i=i+1

class Cliente(Process): def servirse(self,t): """Metodo PEM que representa la actividad de visitar """ yield request,self, banco #solicitando una taquilla (de no obtenerla se quedara esperando en la cola hasta que le toque) yield hold,self,t #Se espera el tiempo t como el tiempo de la visita yield release,self, banco #liberando una taquilla, (de existir clientes en la cola, activa el prximo)

12

Notas de SimPy

#Modelo def simular_banco(): """Ejecutar el modelo """ initialize() #inicializa el reloj de simulacion g = Generador() #instanciando a un generador activate(g,g.generar(interarribo=3.0)) #invocando al generador simulate(until=400.0) #inicio de la simulacion hasta el tiempo 400

def imprimir_resultados(): print "Tamano de la cola promedio %.4f"%(banco.waitMon.timeAverage())

#Programa principal banco=Resource(capacity=3,monitored=True) #Instancia y define el banco con las 3 taquillas y activa los monitores simular_banco() #Ejecuta el proceso de llegadas y servicios de los clientes en el banco imprimir_resultados()

Salida:
Tamano de la cola promedio 16.1473

13

Notas de SimPy

H'-.&4+$#0.&"#'
Las instrucciones de la librera permiten que un desarrollador que no tenga mucha experiencia en el manejo de eventos pueda simular sin tener en cuenta los detalles que el manejo de eventos amerita. SimPy impone que toda clase que tenga un proceso (PEM) debe heredar de Process. Esto hace que el dominio de la aplicacin se vea afectado. La librera de Python de generacin de valores aleatorios es una librera que se puede usar en los problemas generales de simulacin. Los monitores son una herramienta til para recolectar estadsticos de la simulacin.

14

I'@0*+0.J3)KL)'
[SIMPY] SimPy Developer Team, Sitio Web SimPy. http://SimPy.sourceforge.net/index.html. 2009 [LGPL] gnu.org, GNU Lesser General Public License. http://www.gnu.org/licenses/lgpl.html. 2007 [BANKS96] Banks J., Carson J., Barry N., Discrete Event System Simulation. 1996.