Simulacioncsharp

PONTIFICIA UNIVERSIDAD CATLICA DE CHILE
ESCUELA DE INGENIERA
DEPARTAMENTO DE CIENCIA DE LA COMPUTACIN
Curso: IIC 1102 INTRODUCCIN A LA PROG. ORIENTADA A OBJETO
Profesor: Rodrigo Sandoval U.
Simulacin Computacional con C#
INTRODUCCIN ............................................................................................................................................... 1
MODELO DE SIMULACIN............................................................................................................................ 2
2.1
PARMETROS DE LA SIMULACIN .................................................................................................................. 2
2.2
DATOS O INPUT DE LA SIMULACIN ................................................................................................................ 2
2.2.1
Generacin de Nmeros Aleatorios ....................................................................................................... 2
2.2.2
Carga de Datos Reales desde Archivos.................................................................................................. 4
2.3
EJECUCIN DE LA SIMULACIN....................................................................................................................... 5
2.3.1
El Manejo del Tiempo ............................................................................................................................ 5
2.3.2
Colas en C# ............................................................................................................................................ 7
EJEMPLOS .......................................................................................................................................................... 9
3.1
SIMULACIN DE CADENA DE CORREO ............................................................................................................ 9
3.2
LLEGADA DE CLIENTES A CAJA EN EL BANCO .............................................................................................. 10
3.2.1
Solucin 1.0.......................................................................................................................................... 11
3.2.2
Solucin 2.0.......................................................................................................................................... 13
3.2.3
Solucin 3.0.......................................................................................................................................... 15
3.3
SIMULACIN DE LAS COLAS EN UN SUPERMERCADO .................................................................................... 17
3.3.1
Definicin del Problema ...................................................................................................................... 17
3.3.2
Caractersticas del Modelo .................................................................................................................. 17
3.3.3
Mediciones Requeridas ........................................................................................................................ 17
3.3.4
Solucin................................................................................................................................................ 18
3.4
SIMULACIN DE UNA PLAZA DE PEAJE.......................................................................................................... 24
3.4.1
Definicin del Problema ...................................................................................................................... 24
3.4.2
Solucin................................................................................................................................................ 26
Material preparado por Rodrigo Sandoval U en Agosto 2005, (rsandova@ing.puc.cl)

basado en los apuntes de clase del curso IIC1102, ao 2003, de M. Nussbaum, Marcos Seplveda, et.al.
Rodrigo Sandoval U.
1 Introduccin
La simulacin mediante programas de computador permite el estudio detallado de sistemas complejos,
sobre los que resulta costoso, difcil o peligroso llevar a cabo estudios reales. La simulacin se basa en
analizar el comportamiento de un modelo derivado de una situacin real, de la forma ms equivalente
posible, para obtener resultados de la medicin del comportamiento de este modelo y as sacar
conclusiones.
En otras palabras, un modelo de simulacin intenta recrear de la mejor manera posible las
caractersticas del sistema representado y se comporta de manera similar a como lo hara en la realidad.
La idea es que la ejecucin de la simulacin produzca resultados en la forma de valores estadsticos, o
simplemente permita monitorear el desempeo del sistema durante su funcionamiento.
Modelo de Simulacin
Los modelos de simulacin distinguen en general cuatro elementos esenciales:
A. Parmetros de Funcionamiento. Estos datos, muchas veces valores numricos fijos para una
simulacin, determinan ciertas condiciones de la ejecucin, que tambin se define como el
escenario a analizar. Siempre ser posible cambiar los valores de estos parmetros y como
consecuencia, observar el comportamiento del modelo con esas nuevas condiciones y
eventualmente sacar conclusiones al comparar los resultados de un escenario con los de otro.
B. Datos o Input de la Simulacin. Para representar situaciones del modelo real, se cuenta con
datos de diverso tipo que alimentarn la simulacin completando el escenario a implementar con
este modelo. Estos datos generalmente son de tres tipos: datos fijos, conceptualizados como
promedios constantes; datos aleatorios que le dan un factor de variabilidad y ofrecen un
escenario con elementos impredecibles al modelo; y datos reales, que fueron medidos en una
situacin equivalente en la vida real, y que le aportarn el factor realista directo al modelo.
C. Ejecucin de la Simulacin. Consiste en realizar la simulacin propiamente tal, por medio de la
ejecucin iterativa de pasos que emulan el comportamiento de la situacin modelada. Entre los
elementos que se consideran en esta ejecucin, posiblemente el ms importante es el manejo del
tiempo, en el cual el modelo es capaz de identificar los eventos que ocurren en un instante
relevante de tiempo, y ejecutarlos como parte de la simulacin.
D. Resultados de la Simulacin. Datos medidos durante la ejecucin que permiten obtener una
visin del desempeo del modelo y por ende, sacar conclusiones de la situacin simulada.
Tomando un ejemplo clsico, la simulacin de autos en una interseccin de calles, un parmetro de
entrada sera la duracin de la luz roja y de la verde; datos o input sera la llegada de vehculos en
momentos de la simulacin; la ejecucin considerara el tiempo que toma que los autos se vayan
acumulando en roja y luego salgan en verde; y resultados posibles se consideran el tiempo de espera, o
la probabilidad de que un auto no alcance a cruzar en verde.
IIC 1102
Pgina: 1
Rodrigo Sandoval U.
2 Modelo de Simulacin
2.1
Parmetros de la Simulacin
En estos modelos es de mucha utilidad el uso de parmetros, que permitan de manera simple cambiar
las caractersticas del ambiente o del sistema mismo, de modo que sea posible observar los cambios que
se producen en su operacin. Definen un escenario especfico en el cual se realizar la simulacin.
Normalmente son valores numricos, que se mantienen constantes durante la simulacin completa.
El hecho de mantener estos valores paramtricos, permite a quien analiza la simulacin variarlos y poder
probar distintos escenarios de simulacin. Por ejemplo, parmetros de una simulacin podran ser la
duracin de un semforo en una interseccin, la capacidad de carga de un camin o de otro medio de
transporte, la capacidad de atencin de una caja de banco o de tienda, valores monetarios o tarifas.
2.2
Datos o Input de la Simulacin
Los datos que alimentan el modelo de simulacin pueden ser fijos que usualmente son ms bien
considerados como parmetros de la simulacin o bien generarse en forma aleatoria de acuerdo a
ciertas condiciones de distribucin de estos valores casi siempre numricos, y finalmente es posible
contar con mediciones reales tomadas en terreno, las cuales al quedar almacenadas en archivos, por
ejemplo, permiten su recuperacin durante el proceso de la simulacin, para constituir una fuente realista
de la situacin modelada.
2.2.1 Generacin de Nmeros Aleatorios

La generacin de valores aleatorios le da un grado de incerteza al comportamiento del modelo. Si bien es
posible determinar que ciertos valores que alimentan el modelo se comportan de acuerdo a diferentes
tipos de distribuciones estadsticas, en el gran porcentaje de los casos, el uso de la distribucin uniforme
en la cual todos los nmeros de un rango tienen la misma posibilidad de salir es suficiente para
soportar diferentes modelos.
Para producir estos datos es necesario contar con herramientas que generen nmeros aleatorios en
ciertos intervalos y con cierta distribucin especificada en el modelo.
En C# la generacin de nmeros aleatorios est resuelta por una clase llamada Random, cuyo principal
propsito es generar nmeros aleatorios dentro de un rango especificado. Un programa que utilice
Random para la generacin de nmeros, depende de dos principales declaraciones: el constructor y el
mtodo Next().
2.2.1.1
Constructor de Random
Existen diferentes versiones del constructor, las cuales por sobrecarga reciben distintos parmetros.
El constructor simple no recibe parmetros:
Random num = new Random();
El constructor con semilla permite su inicializacin estableciendo una semilla de aleatoriedad, de manera
que no se repitan las secuencias de nmeros entregados. Para darle un grado de variabilidad a esta
generacin de nmeros, se recomienda el uso de una semilla que en cada llamado al programa tenga un
valor diferente. El usar un nmero fijo o constante, es equivalente funcionalmente al constructor sin
parmetros: la secuencia de nmeros aleatorios ser idntica en cada ejecucin desde cero del
programa. Para la semilla, hay dos alternativas: utilizar un nmero entregado por el usuario, que se
espere vaya variando en cada ejecucin, o utilizar un valor del reloj del computador, el cual se obtiene del
uso de DateTime.Now objeto que se detalla ms adelante en este documento. Este objeto tiene un
campo llamado Millisecond, el cual indica la parte de milisegundos (de 0 a 999) de la hora actual.
Random num = new Random(DateTime.Now.Millisecond);
IIC 1102
Pgina: 2
2.2.1.2
Rodrigo Sandoval U.
Generacin de nmeros con Next
El mtodo Next() tiene varias versiones, las cuales por sobrecarga de mtodos ofrecen
comportamientos levemente diferentes y tiles en situaciones distintas. Las dos versiones principales son
las siguientes, y ambas incluyen un valor que representa el lmite superior no incluido del rango de
valores posibles:
int numero1 = num.Next(11);
// numero1 tendr un valor entre 0 y 10
int numero2 = num.Next(5,11); // numero2 tendr un valor entre 5 y 10

2.2.1.3
Ejemplo Bsico de Random
A continuacin, un ejemplo de un programa que genera 10 nmeros aleatorios entre 1 y 10.

using System;
class MainApp {
static void Main() {
Random rn = new Random(DateTime.Now.Millisecond);
for(int n=0; n<10 ; n++)
Console.WriteLine(Nmero: {0}, rn.Next(1,11)); // Nmeros entre 1 y 10
Console.ReadLine();
}
}
En el ejemplo anterior resulta relevante analizar las siguientes lneas:

-
La instanciacin de un nuevo generador de nmeros aleatorios: Random rn = new Random(...)
Le generacin de un nuevo nmero: rn.Next(1,11);
La primera lnea se refiere a la creacin de un nuevo generador de nmeros aleatorios, instanciado como
rn. Como argumento al constructor, se entrega la semilla de generacin, que en este caso es un nmero
de 0 a 999 (correspondiente a los milisegundos de la hora actual). Este nmero, que segn el instante en
que se ejecute la lnea, tendr uno de 1.000 valores posibles, inicializar el punto de partida de la serie
de generacin de nmeros aleatorios, asegurando que la posibilidad de que se repita una secuencia de
nmeros generados, sea una en mil.
La segunda lnea relevante de conocer es la que entrega un nuevo nmero: rn.Next(1,11),
indicando que los valores posibles van entre el 1 y el 10 (11-1).
2.2.1.4
Generacin de Valores Aleatorios en Otras Escalas
En muchos casos, el uso de valores enteros directamente no es parte del contexto del problema
modelado. Por tal razn, existen estrategias de aprovechamiento del comportamiento de Random
descrito anteriormente, que permiten generar estos nmeros en otras escalas.
Generacin de Verdadero o Falso Aleatoriamente.
La conversin es simple, si se toma la generacin de nmeros enteros aleatorios entre 0 y 1 se puede
tener una conversin en que 0 corresponde a False (o false en C#) y 1 corresponde a Verdadero (true en
C#).
using System;
class MainApp {
for(int n=0; n<10 ; n++)
if( rn.Next(2) == 1 ) // Valores entre 0 y 1
Console.WriteLine(VERDADERO);
else
Console.WriteLine(FALSO);
Console.ReadLine();
}
}
IIC 1102
Pgina: 3
Rodrigo Sandoval U.
Generacin de Valores Reales Aleatoriamente.

La primera decisin que hay que tomar es cuntos decimales son relevantes para el modelo
representado. Si la cantidad de decimales relevantes son 2, entonces, se generan nmeros enteros que
se dividen por 100 (10 elevado a 2).
using System;
class MainApp {
for(int n=0; n<10 ; n++) // 10 nmeros reales aleatorios entre 0.00 y 99.99
Console.WriteLine(Nmero: {0}, rn.Next(1,10001)/100);
Console.ReadLine();
}
}
Generacin con Diferente Probabilidad

Un modelo particular puede plantear algo como la cantidad de personas que entran en cada instante de
tiempo es de 1 con 20% de probabilidad, 2 con 30% y 3 con 50%. Esta situacin una vez ms puede
modelarse con la generacin de nmeros enteros aleatorios, con la adaptacin en funcin de los
porcentajes de probabilidades.
Es decir, si un caso tiene 20% de probabilidades de salir, implica que de 10 nmeros (1 al 10) la
probabilidad de que salga un 1 un 2 es exactamente de 10%+10% = 20%. As, el siguiente 30% se da
cuando salen el 3, 4 5, y el 50% restante con cualquier nmero entre 6 y 10. En ese caso, el ejemplo
podra plantearse en C#.
using System;
class MainApp {
int numero = rn.Next(1,11);
if(numero <= 2) Console.WriteLine(20%);
if(numero>2 && numero<=5) Console.WriteLine(30%);
if(numero>5) Console.WriteLine(50%);
Console.ReadLine();
}
}
2.2.2 Carga de Datos Reales desde Archivos

En muchos casos, ms que asumir comportamientos de acuerdo a una distribucin estadstica, es factible
contar con datos reales, en muchos casos medidos en su generacin real. Por ejemplo, la cantidad de
autos llegados a una interseccin por unidad de tiempo, la cantidad de clientes que llegan a la caja en un
banco, etc.
En estos casos, conociendo el comportamiento de cierto parmetro en forma real, estos datos alimentan
el sistema de simulacin, el cual procesa la informacin entrante segn la lgica.
La informacin se almacena en archivos de datos, cuyo caso ms comn es simplemente el formato de
texto plano, cada lnea del archivo representando un dato puntual. El archivo es ledo antes de comenzar
la simulacin y sus datos son almacenados en una representacin de cola, o alguna estructura que emule
la misma generacin de los datos, secuencialmente en el tiempo.
IIC 1102
Pgina: 4
2.3
Rodrigo Sandoval U.
Ejecucin de la Simulacin
Uno de los aspectos ms importantes en una simulacin es el manejo del tiempo, pues los sistemas
normalmente se desenvuelven de acuerdo a una componente temporal. En este punto, la alternativa ms
simple es emplear una componente de tiempo discreto. Segn este enfoque, el funcionamiento del
sistema se puede predecir dentro de unidades discretas de tiempo (por ejemplo, segundos o minutos, e
incluso das). La eleccin de esta unidad resulta fundamental, pues introducir cierto margen de error en
la simulacin.
Otro aspecto fundamental es la alimentacin de la simulacin con datos de entrada reales. Las
simulaciones usualmente llevan consigo una gran cantidad de trabajo de campo recogiendo valores de
entrada. Por ejemplo, para simular los tacos que se forman en una interseccin ser necesario tomar
datos sobre la afluencia de vehculos por cada calle que concurre a la interseccin.
Existen bases tericas que pueden aplicarse a distintos modelos de simulacin, tal es el caso de la
Teora de Colas para la simulacin de filas en las que usuarios esperan ser atendidos, o Dinmica para
la simulacin de cuerpos en movimiento. En general, una simulacin requerir de algn sustento terico
que guiar el funcionamiento del sistema, y por consiguiente depender de cada caso en particular.
En esta seccin se presenta un modelo de simulacin, junto con su implementacin, que pretende ilustrar
esta importante aplicacin de los computadores. El modelo planteado no hace uso de resultados tericos
importantes, con el objetivo de hacerlo ms fcil de entender. Sin embargo, presenta conceptos de
mucha importancia, como el manejo del tiempo discreto, la representacin de las entidades que forman el
modelo como estructuras de datos del lenguaje de programacin empleado, y el manejo de algunos
parmetros de configuracin.
2.3.1 El Manejo del Tiempo

Tal como se indic, uno de los elementos relevantes de controlar es el tiempo. Ya sea que el contexto de
la simulacin requiere una unidad discreta basada en segundos, minutos, horas, das, semanas, o incluso
meses, siempre es necesario ir registrando el paso del tiempo con un contador. Este registro puede ser
tan simple como utilizar un contador entero que se incrementa de uno en uno, hasta determinar el fin de
la simulacin. En este caso, se usa por convencin el concepto de Tics, refirindose a que cada Tic es un
incremento en el contador de tiempo.
Para esto, dos objetos existentes en el framework de .NET resuelven el manejo del tiempo y lapsos.
2.3.1.1
DateTime
En algunos casos, se requiere un registro del tiempo ms preciso que un simple contador, por lo que se
usa una estructura que almacena los datos referentes al tiempo. En C# se cuenta con tal tipo de
estructura, en la forma de una clase de nombre DateTime.
En particular, existe una propiedad de DateTime, que ofrece todos los datos de la hora actual (al
momento de ser consultada), incluyendo hasta los milisegundos: ao-mes-da-hora-min-seg-miliseg. Esta
es DateTime.Now y se usa como referencia temporal para inicializaciones, o incluso, comparaciones
referenciales.
La instanciacin de un objeto de tipo DateTime aprovecha las facultades del Constructor. Por ejemplo:
using System;
// Nueva instancia DateTime con el 28 del 7 de 1979 a las 10:35:05 PM.
DateTime dateTime = new DateTime(1979, // Ao
07,
// Mes
28,
// Da
22,
// Hora
35,
// Minutos
5,
// Segundos
15);
// Milisegundo
Console.WriteLine("{0:F}", dateTime); // Escribe la fecha
IIC 1102
Pgina: 5
2.3.1.2
Rodrigo Sandoval U.
Propiedades, Mtodos y Operadores principales de DateTime
Propiedades
Date
Day
DayOfWeek
DayOfYear
Hour
Millisecond
Minute
Month
Now
Second
Ticks
TimeOfDay
Today
Obtiene el componente correspondiente a la fecha de esta instancia.

Obtiene el da del mes representado por esta instancia.
Obtiene el da de la semana representado por esta instancia.
Obtiene el da del ao representado por esta instancia.
Obtiene el componente correspondiente a la hora de la fecha representada por esta
instancia.
Obtiene el componente correspondiente a los milisegundos de la fecha representada por
esta instancia.
Obtiene el componente correspondiente a los minutos de la fecha representada por esta
instancia.
Obtiene el componente correspondiente al mes de la fecha representada por esta
instancia.
Obtiene un DateTime que constituye la fecha y hora locales actuales de este equipo.
Obtiene el componente correspondiente a los segundos de la fecha representada por esta
instancia.
UtcNow
Obtiene el nmero de pasos que representan la fecha y hora de esta instancia.

Obtiene la hora del da para esta instancia.
Obtiene la fecha actual.
Obtiene un DateTime que representa la fecha y hora locales actuales de este equipo y que
se expresa en forma de hora universal coordinada (UTC).
Year
Obtiene el componente correspondiente al ao de la fecha representada por esta instancia.
Mtodos
AddDays
AddHours
AddMilliseconds
AddMinutes
AddMonths
AddSeconds
AddTicks
AddYears
Compare
CompareTo
Agrega el nmero de das especificado al valor de esta instancia.

Agrega el nmero de horas especificado al valor de esta instancia.
Agrega el nmero de milisegundos especificado al valor de esta instancia.
Agrega el nmero de minutos especificado al valor de esta instancia.
Agrega el nmero de meses especificado al valor de esta instancia.
Agrega el nmero de segundos especificado al valor de esta instancia.
Agrega el nmero de pasos especificado al valor de esta instancia.
Agrega el nmero de aos especificado al valor de esta instancia.
Compara dos instancias de DateTime y devuelve una indicacin de sus valores
relativos.
Compara esta instancia con un objeto especificado y devuelve una indicacin de los
valores relativos.
Operadores
Suma (+)
Igualdad (==)
Mayor que (> y >=)
Desigualdad (!=)
Menor que (< y <=)
Resta (-)
IIC 1102
Agrega un intervalo de tiempo especificado a una fecha y hora especificadas,

generando una fecha y hora nuevas.
Determina si dos instancias especificadas de DateTime son iguales.
Determina si un DateTime especificado es mayor que otro DateTime
especificado.
Determina si dos instancias especificadas de DateTime no son iguales.
Determina si un DateTime especificado es menor que otro DateTime
especificado.
Sobrecargado. Resta un DateTime especificado de un DateTime especificado.
Pgina: 6
Rodrigo Sandoval U.
Ejemplos prcticos del uso de DateTime como parte de los datos de una clase utilizada en una
simulacin se ven en la siguiente seccin de ejemplos.
2.3.1.3
TimeSpan
Por su parte, el manejo de lapsos o intervalos de tiempo se resuelve con TimeSpan. Esencialmente ste
representa el objeto resultante de la diferencia entre dos objetos de tipo DateTime, y es el que se usa
para representar los Tics o unidades de tiempo relevante.
Existen varias versiones del constructor de TimeSpan, las que varan principalmente en la cantidad de
enteros que reciben como parmetro, lo cual determina la cantidad de tiempo que incluye el intervalo de
tiempo. Algunas de estas diferentes versiones se demuestran en los siguientes ejemplos.
using System;
TimeSpan t1 = new TimeSpan(0, 1, 0); // 0 horas, 1 minuto, 0 segundos
TimeSpan t2 = new TimeSpan(1, 0, 0, 0); // 1 da, 0 horas, 0 min, 0 seg
TimeSpan t3 = new TimeSpan(0, 0, 0, 0, 1); // 1 dd, 0 hh, 0 mm, 0 s, 1 mseg.
A continuacin se muestra un ejemplo prctico del uso de TimeSpan y DateTIme juntos en una
simulacin. En este caso, el reloj de control de la simulacin deber comenzar a las 13:30. Como
referencia de fecha, se utiliza la fecha actual por medio de DateTime.Now que corresponde a un objeto
de tipo DateTime asignado a la fecha del computador en el momento en que se invoca.
using System;
. . .
// Declaracin del reloj que llevar la cuenta de tiempo de simulacin
DateTime reloj = DateTime.Now; // Reloj puesto a la fecha y hora actual
// Se ajusta el reloj a la hora de inicio de la simulacin
reloj.Hour = 13; reloj.Minute = 30; reloj.Second = 0; reloj.Millisecond = 0;
// Declaracin de la hora de fin -> 30 minutos despus del inicio.
DateTime fin = reloj + new TimeSpan(0,30,0);
// Declaracin de la unidad significativa de tiempo -> 1 minuto
TimeSpan tick = new TimeSpan(0, 1, 0); // 0 horas, 1 minuto, 0 segundos
. . .
while(reloj <= fin) { // Mientras el reloj no sea igual a la hora de fin
. . .
Reloj += tick; // Se incrementa el contador de tiempo en un tick
}
. . .
2.3.2 Colas en C#
El uso de colas en simulacin permite representar la llegada de objetos (personas, autos, rdenes de
compra, etc.) en el tiempo y que sern atendidos como parte del proceso de simulacin. El uso de colas
es un concepto tradicionalmente referido en simulacin computacional.
En el caso del lenguaje C# y del framework de .NET, reconociendo las colas como una estructura
frecuentemente requerida, se ha incluido su definicin completa en un objeto denominado Queue, que
ofrece el comportamiento tradicional de una cola, en la cual los elementos nuevos ingresan slo al final y
se sacan elementos slo por adelante. Esta clase est disponible dentro del Namespace
System.Collections.
IIC 1102
Pgina: 7
Rodrigo Sandoval U.
Esta clase Queue puede almacenar objetos de cualquier tipo, ya que su elemento base es Object, que es
el objeto base del cual derivan absolutamente todos los objetos definidos por los desarrolladores. De esa
manera, se pueden crear fcilmente colas para almacenar elementos bsicos como nmeros (int, double,
etc.) o cualquier otro elemento definido en una clase del programa.
Las operaciones estndar de una cola son: Agregar un Elemento (que lo ubica al final de la cola de
elementos ya agregados); Sacar el Primero (slo se sacan elementos por el inicio de la cola); Ver el
Primero (slo se puede ver el elemento que est en primer lugar sin sacarlo de la cola); y ver el Largo de
la lista (para determinar la cantidad de elementos que estn en la cola).
Formalmente, los elementos de la clase Queue son los siguientes:
Mtodos
void Enqueue(Object)
Este mtodo encola un elemento derivado de la clase Object.

Saca el primer elemento de la cola, retornndolo para ser utilizado. Este
mtodo no verifica si la cola cuenta con elementos, por lo que es
conveniente agregar una clusula condicional verificando que existan
elementos antes de retirar el primero, o bien aprovechar un bloque de control
de excepciones try-catch.
Funciona equivalentemente a Dequeue(), con la diferencia de que el objeto
en primer lugar de la cola no es retirado, sino que permanece.
Object Dequeue()
Object Peek()
Propiedades
int Count
Propiedad que retorna un nmero mayor o igual a cero, indicando la cantidad de

elementos de la cola.
Peek()
Dequeue()
Count
Enqueue()
La siguiente seccin incluye diferentes ejemplos que hacen uso exhaustivo de la definicin de Queue, de
modo de ilustrar el comportamiento de cada uno de estos mtodos y propiedad, as como dar una nocin
de la manera de utilizar esta clase para apoyar el proceso de simulacin.
IIC 1102
Pgina: 8
Rodrigo Sandoval U.
3 Ejemplos
Entre los ejemplos que ilustran la simulacin conceptual, se distinguen diversos tipos de complejidad. A
medida que los ejemplos van involucrando ms elementos de simulacin y de resultados, se van
programando y utilizando objetos ms complejos.
3.1
Simulacin de Cadena de Correo
Las cadenas enviadas por correo (originalmente en cartas de papel, hoy por e-mail), son seguidas por
muchos y odiadas por otros tantos. En este ejemplo se pretende ver el comportamiento de una nueva
cadena por correo, la cual cuenta con ciertas caractersticas que definen su funcionamiento. Esta cadena
en particular indica que para ser continuada, cada receptor deber re-enviar a 4 nuevas personas. Para
efectos del ejemplo se han tomado ciertas simplificaciones a un caso realista, de modo de concentrar el
modelamiento en los conceptos vistos en este documento.
La forma de funcionamiento es la siguiente:
De las 4 personas a quienes se reenva, existe un 66% de probabilidad de que la persona

receptora no lo tome en cuenta y corte su parte de la cadena.
El periodo que se toma en leer y reenviar es de 24 horas.
Este programa de simulacin analiza el comportamiento de una cadena, en la medida en que se van
agregando nuevas personas, por un periodo de 30 das.
Al final de la simulacin, se indicarn en pantalla cuntas personas en total recibieron la cadena y
cuntas efectivamente la reenviaron.
Solucin
Esta solucin se implementa en forma directa, sin mayores estructuras especiales. En particular, el
manejo del tiempo, al no requerirse en fechas absolutas, se maneja en forma relativa con un simple
contador de tipo entero, avanzando por un loop o ciclo de 30 iteraciones (representando los 30 das de
simulacin).
Cdigo Fuente Solucin
using System;
class MainApp {
int enviaron = 1, recibieron = 0, recibieronant = 1; // Se parte con 1 sola persona
for(int i=0; i<30 ; i++) { // loop para 30 das
int rec = 0, env = 0;
Console.Write("Da {0}: ", i+1);
for(int j=0; j<recibieronant; j++) { // p/todos los receptores da anterior
for(int k=0; k<4; k++) {
// c/u de los anteriores, envi a 4
rec++;
if( rn.Next(0,3) > 1 ) // Posibilidad de que lo reenve
env++;
}
}
Console.WriteLine(" de:{0} rec:{1} y env:{2}", recibieronant, rec, env);
recibieronant = env;
recibieron += rec;
enviaron += env;
}
Console.WriteLine("En un periodo de simulacin de 30 das:");
Console.WriteLine("Recibieron: {0} personas", recibieron);
Console.WriteLine("Enviaron: {0} personas", enviaron);
Console.ReadLine();
}
}
IIC 1102
Pgina: 9
Rodrigo Sandoval U.
Ejemplo de ejecucin y resultados:

Da 1: de:1 rec:4 y env:3
Da 7: de:28 rec:112 y env:32
Da 8: de:32 rec:128 y env:41
Da 9: de:41 rec:164 y env:56
Da 10: de:56 rec:224 y env:70
Da 11: de:70 rec:280 y env:85
Da 12: de:85 rec:340 y env:100
Da 13: de:100 rec:400 y env:140
Da 14: de:140 rec:560 y env:192
Da 15: de:192 rec:768 y env:251
Da 16: de:251 rec:1004 y env:332
Da 17: de:332 rec:1328 y env:450
Da 18: de:450 rec:1800 y env:596
Da 19: de:596 rec:2384 y env:805
Da 20: de:805 rec:3220 y env:1027
Da 21: de:1027 rec:4108 y env:1389
Da 22: de:1389 rec:5556 y env:1803
Da 23: de:1803 rec:7212 y env:2430
Da 24: de:2430 rec:9720 y env:3337
Da 25: de:3337 rec:13348 y env:4488
Da 26: de:4488 rec:17952 y env:5960
Da 27: de:5960 rec:23840 y env:7777
Da 28: de:7777 rec:31108 y env:10201
Da 29: de:10201 rec:40804 y env:13572
Da 30: de:13572 rec:54288 y env:18036
En un periodo de simulacin de 30 das:
Recibieron: 220856 personas
Enviaron: 73250 personas
3.2
Llegada de Clientes a Caja en el Banco
Este ejemplo muestra el simple proceso de la llegada de clientes a una caja de banco y cmo son
atendidos.
En particular se busca mostrar distintas versiones de un mismo ejemplo, agregando ciertos elementos o
simplificando algunas condiciones para ilustrar el uso de los diferentes elementos que tanto la teora,
como la librera de clases del Microsoft .NET framework ofrecen para facilitar estas implementaciones.
Se toman las siguientes condiciones:
El periodo de simulacin es de 30 minutos.
Se conoce el momento de llegada de los clientes a la cola, datos que vienen almacenados en un
archivo de datos. Puede llegar ms de un cliente por minuto.
En un archivo de entrada, clientes.dat, vendr como nico dato por cada lnea, el instante en
que lleg el cliente N (con N: lnea del archivo). Es posible que ms de una lnea contenga el
mismo nmero, representando que ms de un cliente lleg en el mismo instante de tiempo.
IIC 1102
Se asume que todos los clientes tienen en promedio la misma cantidad de trmites que realizar,
por lo que se demorarn lo mismo.
Pgina: 10
Rodrigo Sandoval U.
Se sabe que el nico cajero atendiendo, procesa 1 cliente por minuto. Por esta razn se utilizar
1 minuto como unidad de tiempo significativa.
Instante 1
Instante 2
Instante 3
Instante 4
Atiende 1
cliente por
minuto
1
Orden de Llegada
Al finalizar la simulacin interesa conocer:
El total de clientes atendidos por el cajero.
La espera mxima en la cola en minutos.
3.2.1 Solucin 1.0

Esta primera versin del ejemplo se modela y soluciona de la forma ms simple, tomando algunas
suposiciones de la operacin real y utilizando los elementos bsicos del lenguaje C#.
Solucin
Se implementar una cola de clientes, registrando el instante de llegada de cada uno de ellos, de modo
de procesar los momentos de llegada en sincronizacin con el manejo del tiempo de la simulacin,
mientras que se utilizan los instantes de llegada para medir el tiempo de espera de cada cliente, al
compararlo con el momento en que son atendidos.
El proceso general tomar un reloj de tipo nmero entero, funcionando como contador (cronmetro de
minutos), que ir aumentando en 1, cuando haya clientes en cola, o se adelantar hasta el instante en
que llega el siguiente cliente. Es decir, no es necesario una contabilizacin exhaustiva de cada unidad de
tiempo de simulacin, sino que se puede simplificar el proceso computacional involucrado al procesar
slo los instantes en que ocurren eventos relevantes dentro del proceso, como es la atencin de clientes,
mientras que se saltan los instantes en que no hay clientes en la cola.
using System;
using System.IO;
// ---------------------------------------------------------------// Clase Cliente
// Representa un cliente, con su instante de llegada
// ---------------------------------------------------------------class Cliente {
int llegada;
public Cliente(int l) { llegada = l; }
public int Llegada { get { return(llegada); } }
}
IIC 1102
Pgina: 11
Rodrigo Sandoval U.
// ---------------------------------------------------------------// Clase Cola

// Representa la cola que se forma frente a la caja. Almacena todos
// los clientes ingresados con su respectivo instante de llegada
// ---------------------------------------------------------------class Cola {
const int MAX = 30;
Cliente[] clientes;
int cantidad = 0;
string archivo = "clientes.dat";
public Cola() {
clientes = new Cliente[MAX];
// Dimensionamiento
StreamReader sr;
try { sr = new StreamReader(archivo); }
catch (Exception e) {
Console.WriteLine("Error al abrir \"{0}\"\n{1}", archivo, e.ToString());
return;
}
string linea = sr.ReadLine();
while(linea != null) {
Agregar(int.Parse(linea));
linea = sr.ReadLine();
}
sr.Close();
}
// Agregar(): dado un instante de llegada 'l', lo agrega a la cola
public void Agregar(int l) { if(cantidad<MAX) clientes[cantidad++] = new Cliente(l); }
// Primero(): devuelve el primer cliente en la cola
public Cliente Primero() {
if(cantidad>0) return(clientes[0]);
else {
Cliente vacio = new Cliente(0);
return(vacio);
}
}
// Atender(): atiende al primer cliente de la cola, sacndolo de ella
public void Atender() {
if(cantidad>0) {
for(int i=1; i<cantidad ; i++)
clientes[i-1] = clientes[i];
cantidad--;
}
}
public int Cantidad { get { return(cantidad); } }
}
// ---------------------------------------------------------------// Clase Principal

// ---------------------------------------------------------------class Principal {
int reloj = 0; // reloj contador de minutos
Cola cola = new Cola(); // Instancia la cola de clientes
int esperamax = 0;
int cantclientes = cola.Cantidad; // Se registra la cantidad total de clientes
Console.WriteLine("Procesando...");
// Proceso simulacin involucra 30 min o hasta que se acaben los clientes
while(reloj<=30 && cola.Cantidad>0) {
Cliente c = cola.Primero();
if(reloj<c.Llegada) reloj = c.Llegada; // Se avanza reloj al primero
IIC 1102
Pgina: 12
Rodrigo Sandoval U.
else reloj++;
Console.Write(" {0}", reloj);
if( reloj-c.Llegada > esperamax ) esperamax = reloj-c.Llegada;
cola.Atender();
}
// Al final, indica los valores registrados
Console.WriteLine("\nPersonas atendidas: {0}", cantclientes);
Console.WriteLine("Espera mxima: {0}", esperamax);
Console.Write("Presione ENTER..."); Console.ReadLine();
}
}
Ejemplo de Ejecucin
Archivo clientes.dat:
1
1
1
3
6
7
9
11
11
15
16
17
19
19
19
21
22
23
24
26
28
Salida en Pantalla:
Procesando...
1 2 3 4 6 7 9 11 12 15 16 17 19 20 21 22 23 24 25 26 28
Personas atendidas: 21
Espera mxima: 2
Presione ENTER...
3.2.2 Solucin 2.0

Evolucionando un poco el ejemplo anterior, esta segunda versin profundiza un poco en el uso de la
clase Queue como apoyo al modelamiento de la cola de clientes que llegan al banco, de manera que la
implementacin de la cola de clientes se muestra ms simple en cdigo.
Particularmente, el enfoque de esta solucin, implementa la clase Cola, heredando de Queue,
complementando algunos mtodos especiales para el contexto de este problema, en particular el
constructor.
IIC 1102
Pgina: 13
Rodrigo Sandoval U.
Cdigo Fuente
using System;
using System.IO;
using System.Collections;
// ---------------------------------------------------------------// Clase Cliente

// ---------------------------------------------------------------class Cliente {
int llegada;
public Cliente(int l) { llegada = l; }
public int Llegada { get { return(llegada); } }
}
// ---------------------------------------------------------------// Clase Cola (Hereda de Queue)

// Representa la cola que se forma frente a la caja. Almacena todos
// los clientes ingresados con su respectivo instante de llegada
// ---------------------------------------------------------------class Cola : Queue {
string archivo = "clientes.dat";
public Cola() {
StreamReader sr;
try { sr = new StreamReader(archivo); }
catch (Exception e) {
Console.WriteLine("Error al abrir \"{0}\"\n{1}", archivo, e.ToString());
return;
}
while(linea != null) {
Enqueue(new Cliente(int.Parse(linea)));
}
sr.Close();
}
// Primero(): devuelve el primer cliente en la cola
public Cliente Primero() {
if(Count>0) return( (Cliente) Peek() );
else return(new Cliente(0));
}
// Atender(): atiende al primer cliente de la cola, sacndolo de ella
if(Count>0) Dequeue(); }
public int Cantidad { get { return(Count); } }
}
// ---------------------------------------------------------------// Clase Simulacion

// ---------------------------------------------------------------class Simulacion {
int atendidos = 0;
int esperamax = 0;
int encola = 0;
public void Simular(int tiempo) {
int reloj = 1; // reloj contador de minutos
Cola cola = new Cola(); // Instancia la cola de clientes
Console.WriteLine("Procesando...");
encola = cola.Cantidad;
IIC 1102
Pgina: 14
Rodrigo Sandoval U.
// Proceso dura 30 minutos o hasta que se acaben los clientes

while(reloj<=tiempo && cola.Cantidad>0) {
Cliente c = cola.Primero();
if(reloj<c.Llegada) reloj = c.Llegada; // Se avanza reloj al primero
else reloj++;
Console.Write(" {0}", reloj);
if( reloj-c.Llegada > esperamax ) esperamax = reloj-c.Llegada;
cola.Atender(); atendidos++;
encola = cola.Cantidad;
}
}
public int Atendidos { get { return(atendidos); } }
public int EsperaMax { get { return(esperamax); } }
public int EnCola { get { return(encola); } }
}
// ---------------------------------------------------------------// Clase Principal
// ---------------------------------------------------------------class Principal {
Simulacion s = new Simulacion();
s.Simular(30); // Efecta el proceso completo de simulacin
// Al final, indica los valores registrados
Console.WriteLine("\nPersonas atendidas: {0}", s.Atendidos);
Console.WriteLine("Espera mxima: {0}", s.EsperaMax);
Console.WriteLine("Personas en Cola: {0}", s.EnCola);
}
}
3.2.3 Solucin 3.0

En esta tercera versin del mismo caso de simulacin ofrece algunas diferencias al problema original. En
primer lugar, la llegada de los clientes se mide en horas absolutas (hh:mm) y no en una referencia relativa
de minutos. Por otro lado, la llegada de los clientes no se conoce y se determina en forma aleatoria. En
cada instante de simulacin podrn llegar entre 0 y 2 clientes. La tercera diferencia, relacionada con la
implementacin, es que se simplifica la definicin de la cola de clientes (utilizando directamente la clase
Queue).
Dado el uso de minutos en la forma hh:mm, se aprovechar la clase DateTime, identificando para cada
cliente el instante de llegada. A la vez, el control de la evolucin del tiempo de la simulacin, tambin
tomar el mismo tipo de objeto para ir contabilizando los minutos en la forma hh:mm. Para representar la
unidad relevante de tiempo se utilizar un objeto de tipo TimeSpan, como un tick.
Cdigo Fuente
using System;
using System.IO;
// ---------------------------------------------------------------// Clase Cliente
// ---------------------------------------------------------------class Cliente {
DateTime horallegada;
public Cliente(DateTime hl) { horallegada = hl; }
public DateTime HoraLlegada { get { return(horallegada); } }
}
IIC 1102
Pgina: 15
Rodrigo Sandoval U.
// ---------------------------------------------------------------// Clase Simulacion

// ---------------------------------------------------------------class Simulacion {
int atendidos = 0;
int maxespera = 0;
public void Procesar() {
DateTime reloj = new DateTime(2000,1,1,13,30,0,0);
DateTime horafin = new DateTime(2000,1,1,14,00,0,0);
TimeSpan tick = new TimeSpan(0,1,0);
Queue cola = new Queue();
while( reloj <= horafin ) {
int clientes = rn.Next(0,3);
for(int i=0; i<clientes; i++)
cola.Enqueue(new Cliente(reloj));
Console.WriteLine("{0}:{1}, llegaron {2} clientes a una cola con {3}",
reloj.Hour, reloj.Minute, clientes, cola.Count);
if(cola.Count>0) { // Siempre verificar largo de la cola antes de procesar.
Cliente sale = (Cliente) cola.Dequeue();
atendidos++;
if(maxespera < (reloj.Minute - sale.HoraLlegada.Minute))
maxespera = (reloj.Minute - sale.HoraLlegada.Minute);
}
reloj += tick;
}
}
public int Atendidos { get { return(atendidos); } }
public int MaxEspera { get { return(maxespera); } }
}
// ---------------------------------------------------------------// Clase Principal
// ---------------------------------------------------------------class Principal {
Simulacion sim = new Simulacion();
sim.Procesar();
Console.WriteLine("Cliente atendidos: {0}", sim.Atendidos);
Console.WriteLine("Mxima espera: {0}", sim.MaxEspera);
}
}
IIC 1102
Pgina: 16
3.3
Rodrigo Sandoval U.
Simulacin de las Colas en un Supermercado
En este ejemplo se muestra una simulacin que modela las colas que se forman en las cajas de un
supermercado. El desarrollo de este ejemplo es informal, en el sentido de que no se basa en formalismos
tericos para desarrollar el modelo.
3.3.1 Definicin del Problema

Un supermercado recibe una cantidad regular de clientes diariamente, los cuales traen consigo una lista
de los productos que van a comprar. Los clientes buscan sus productos en los estantes y pasan de
inmediato a la caja que ms les convenga (en la que deban esperar menos en la fila). Una vez que han
pagado se retiran del local.
Para determinar cul es la caja ms conveniente, los clientes miran las compras que llevan los clientes en
la cola, y eligen aquella caja con menos productos delante de ellos (como es natural).
3.3.2 Caractersticas del Modelo

El modelo de simulacin que se emplear hace ciertas suposiciones sobre el comportamiento del
sistema:
Los clientes llegan al supermercado segn una tasa regular todos los das, y siguiendo un
comportamiento de compras tambin regular.
Un cliente se demora un tiempo constante en ubicar cada uno de los productos que comprar.
Las cajeras pasan por el lector de barras los productos a un ritmo constante, es decir, una
determinada cantidad de productos por minuto.
Una vez que un cliente elige una caja en la que har fila, no se mover a otra.
Se considera despreciable el tiempo que le toma al cliente pagar por sus compras y recibir su
vuelto.
La unidad de tiempo discreto que se emplear en la simulacin es equivalente a un minuto,

descartando las tareas que puedan llevarse a cabo en fracciones restantes. Por ejemplo, si a un
cajero le toma 10 segundos pasar los artculos de un cliente, el resto de ese minuto lo
desperdiciar y no lo emplear atendiendo a otro cliente.
El modelo se centrar en la simulacin del tiempo, ejecutando en cada unidad discreta de tiempo las
actividades propias del supermercado y los clientes:
Se verificar cules clientes han terminado de buscar sus productos y se les colocar en la fila de
la caja.
Cada cajera atender al primer cliente en la fila, y le pasar tantos productos como pueda en una
unidad de tiempo.
3.3.3 Mediciones Requeridas

Con fines estadsticos, es necesario guardar la visin que tuvo cada cliente al llegar a la caja, es decir,
cuntos productos tienen los clientes que estn delante de l, y cuntos son estos clientes. Esto se
llevar a cabo en forma acumulativa con ayuda de la clase, de manera que sea posible obtener
promedios al final de la simulacin. Adems, resulta valioso almacenar los valores mximos, tanto para el
tiempo de espera como para el largo de cola en cada caja.
IIC 1102
Pgina: 17
Rodrigo Sandoval U.
3.3.4 Solucin
Los clientes del supermercado se representarn mediante una clase Cola, en donde cada
elemento corresponder con un cliente. Para cada cliente se almacenar:
o
Hora de llegada al supermercado.
Cantidad de productos que pretende comprar (generado aleatoriamente).

hh:mm 1
compras1
hh:mm 2
compras2
hh:mm 3
compras3
hh:mm 4
compras4
Orden de Llegada
Las cajas se representarn tambin como una clase, el cual ofrece en su interfaz funciones de mucha
utilidad, como determinar la caja con menos productos para que un cliente se pueda ubicar en ella. El
nico dato que es necesario almacenar es la cantidad de productos que lleva cada uno de los clientes
que hacen fila en las cajas.
compras1
comprasN
compras2
...
Caja1
compras1
comprasN
compras2
...
Caja2
compras1
comprasN
compras2
...
CajaN
IIC 1102
Pgina: 18
Rodrigo Sandoval U.
Por otra parte, ser necesario llevar constancia del tiempo actual (hora), para saber en qu momento los
clientes pasarn a las cajas y cmo irn evolucionando las colas al cumplirse cada unidad de tiempo.
De los resultados arrojados por estas estadsticas dependern los posibles cambios de configuracin que
deban llevar a cabo los administradores del negocio. Por ejemplo, el aumento o disminucin de cajas
disponibles, la reubicacin de los productos para que los clientes pasen menos tiempo ubicndolos, la
capacitacin de las cajeras para que pasen ms productos por minuto por el lector de barras, etc.
Entradas del Programa
Los datos de los clientes se leen desde un archivo de entrada, llamado clientes.txt.
El archivo tiene un formato riguroso. En la primera lnea se indica el nmero de clientes que concurrir al
supermercado en el da, seguido de una lnea por cada uno de estos clientes.
Cada una de las lneas de clientes est compuesta por dos enteros que indican la hora de llegada al
supermercado (hora y minutos).
A modo de ejemplo se incluye aqu un archivo de entrada, que considera 25 clientes.
25
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
10
01
05
05
05
05
05
05
07
08
08
10
12
15
20
22
22
22
22
22
22
35
45
50
50
55
El nmero de cajas que se desea emplear se pregunta como primer paso dentro del programa.
Desarrollo de la solucin
Para esta solucin, los objetos relevantes son:
-
Cliente. Representado por una clase cuyos atributos son: la hora de llegada (de tipo DateTime)
y la cantidad de compras (int). Estos valores son pasados como parmetros al constructor y
adicionalmente se definen las propiedades que dan acceso a los dos atributos privados del
objeto Cliente.
Cajas. Un objeto ms complejo, que maneja un arreglo de colas de caja y ofrece una serie de
mtodos que resuelven las preguntas ms requeridas, como cul es la caja con la cola ms
corta? cuntos productos hay en la caja N? adems de procesar cada cola en una unidad de
tiempo de simulacin.
IIC 1102
Pgina: 19
Rodrigo Sandoval U.
Estadstica. Un objeto que guarda los valores numricos que se van obteniendo por el proceso
de atencin de las cajas y que finalmente sirve para mostrar en pantalla los resultados
estadsticos medidos durante la simulacin.
La cola de llegada de los clientes al supermercado se maneja como un objeto de tipo Queue y
se incluye la lgica de inicializacin de esta cola al leer los datos que vienen en el archivo de
llegadas. El procesamiento de este archivo va creando objetos de tipo cliente, tomando la hora y
minutos que indica la lnea respectiva del archivo y tambin generando un nmero aleatorio de
productos a comprar, por medio de la clase Random.

using System;
using System.IO;
class Cliente {
private DateTime dt;
private int compras;
public Cliente(int hora, int minuto) {
dt = new DateTime(DateTime.Now.Year,DateTime.Now.Month,DateTime.Now.Day,
hora,minuto,0,0);
compras = 0;
}
public void Imprimir() { Console.WriteLine("Hora: {0} - compras: {1}",dt,compras); }
public DateTime HoraRegistro { get { return dt; } }
public bool registro_vacio {
get{
if(compras == 0) return true;
else
return false;
}
}
public int registro_compra {
get { return compras; }
set { compras = value; }
}
}
class Cajas {
private int [,] cajas;
private int num, max_caja;
public Cajas(int num_cajas, int max_clientes_caja) {
num = num_cajas;
max_caja = max_clientes_caja;
cajas = new int[num_cajas,max_clientes_caja];
}
public void Insertar(int prod) {
int i;
for(i = 0; i < num && cajas[MejorCaja(),i] != 0; i++);
cajas[MejorCaja(),i] = prod;
}
public int MejorCaja() {
int cant_aux = 0, cant = Int32.MaxValue, mejor = 0;
for(int i = 0; i < num; i++) {
for(int j = 0; j < max_caja; j++)
cant_aux += cajas[i,j];
if(cant_aux < cant)
{
mejor = i;
cant = cant_aux;
IIC 1102
Pgina: 20
Rodrigo Sandoval U.
}
cant_aux = 0;
}
return mejor;
}
public int ProductosEnCaja(int caja) {
int num_prod = 0;
for(int i = 0; i < max_caja; i++) num_prod += cajas[caja,i];
return num_prod;
}
public int ColaCaja(int caja) {
int num_clientes = 0;
for(int i = 0; i < max_caja; i++)
if(cajas[caja,i] != 0)
num_clientes++;
return
num_clientes;
}
public int ProdsPrimerCliente(int caja) { return cajas[caja,0]; }
public void Cobrar(int caja, int prod) { cajas[caja,0] -= prod; }
public void SacarCaja(int caja) {
for(int i = 1; i < max_caja; i++)
cajas[caja,i-1] = cajas[caja,i];
}
public bool QuedanClientes() {
for(int i = 0; i < num; i++)
if(cajas[i,j] > 0) return true;
return false;
}
public void Imprimir() {
for(int i = 0; i < num; i++) {
Console.Write("\n\t Caja n {0}: ",i);
if(cajas[i,j] != 0)
Console.WriteLine(" {0}",cajas[i,j]);
}
Console.WriteLine("");
}
int caja, cobrados;
for( caja = 0; caja < num; caja++)
{
if(ProductosEnCaja(caja) > 0)
{
if(ProdsPrimerCliente(caja) < 3)
cobrados = ProdsPrimerCliente(caja);
else cobrados = 3;
Cobrar(caja,cobrados);
if(ProdsPrimerCliente(caja) == 0)
SacarCaja(caja);
}
}
}
}
class Estadistica {
private int LargoTotal;
private int LargoMax;
public Estadistica()
IIC 1102
{ LargoTotal = 0; LargoMax
= 0; }
Pgina: 21
Rodrigo Sandoval U.
public int LargoT {

get { return LargoTotal; }
set { LargoTotal = value; }
}
public int LargoM {
get { return LargoMax; }
set { LargoMax = value; }
}
}
class CMain {
public static void Main() {
DateTime dt = new DateTime(DateTime.Now.Year,DateTime.Now.Month,DateTime.Now.Day,
9,0,0,0);
int NumClientes = 0, EsperaTotal = 0, EsperaMax
= 0;
int cajas = 0;
Console.WriteLine("SIMULACION DE SUPERMERCADO");
Console.Write("Indique la cantidad de cajas atendiendo: ");
cajas = int.Parse(Console.ReadLine());
Queue Clientes
= new Queue();
Cajas Cajas
= new Cajas(cajas,10);
Estadistica [] estadistica = new Estadistica[cajas];
for(int i = 0; i < Estadistica.Length; i++)
estadistica[i] = new Estadistica();
try {
StreamReader sr = new StreamReader("clientes.txt");
Console.WriteLine("Leyendo datos de entrada");
NumClientes = int.Parse(sr.ReadLine());
string str;
System.Random rn = new System.Random(System.DateTime.Now.Millisecond);
for(int i = 0; (str = sr.ReadLine()) != null; i++) {
string[] hh_mm = str.Split(' ');
Cliente cr = new Cliente (int.Parse(hh_mm[0]),
int.Parse(hh_mm[1]));
cr.registro_compra = rn.Next(0,99);
Clientes.Enqueue(cr);
}
sr.Close();
} catch(Exception e) {
Console.WriteLine("No se abre archivo clientes.txt: {0}",e.Message);
return;
}
while(Clientes.Count > 0 || Cajas.QuedanClientes()) {
if(Clientes.Count == 0) break;
CRegistro cli = (CRegistro)Clientes.Peek();
while(cli.HoraRegistro == dt)
{
int prodsCajas = Cajas.ProductosEnCaja(Cajas.MejorCaja());
int colaCaja = Cajas.ColaCaja(Cajas.MejorCaja());
EsperaTotal += prodsCajas;
if(prodsCajas > EsperaMax) EsperaMax = prodsCajas;
Estadistica[Cajas.MejorCaja()].LargoT += colaCaja;
if(colaCaja > Estadistica[Cajas.MejorCaja()].LargoM)
Estadistica[Cajas.MejorCaja()].LargoM = colaCaja;
if(Clientes.Count == 0) break;
cli = (CRegistro)Clientes.Dequeue();
Cajas.Insertar(cli.registro_compra);
}
Cajas.Atender();
IIC 1102
Pgina: 22
Rodrigo Sandoval U.
DateTime d = dt.AddMinutes(1);
dt = d;
}
Console.WriteLine("\n\n\t\t-=Estadistica=-\n\n");
int valor
= (EsperaTotal / 3) / NumClientes;
int
min
= valor;
int
seg
= ((valor-min)*60);
Console.WriteLine("\tTiempo de espera Promedio (mm:ss) -> {0}:{1}",min,seg);
valor = (EsperaMax / 3);
min
= (int)valor;
seg
= (int) ((valor-min)*60);
Console.WriteLine("\tTiempo de Espera Maximo
(mm:ss) -> {0}:{1}",min,seg);
Console.WriteLine("\tLargo de la Cola en las Cajas (Promedio/Maximo):");

for(int i=0 ; i<cajas ; i++)
Console.WriteLine("\t\tCaja n{0}: {1} / {2}",i,
Estadistica[i].LargoT,Estadistica[i].LargoM);
Console.Write("Presione ENTER ..."); Console.ReadLine();
}
}
Ejemplos de ejecucin (varias configuraciones)

Con 1 caja:
-=Estadistica=-
Tiempo de espera Promedio (mm:ss) -> 29:0

Tiempo de Espera Maximo
(mm:ss) -> 52:0
Largo de la Cola en las Cajas (Promedio/Maximo):
Caja n0: 44 / 2
Con 2 cajas:
-=Estadistica=-

(mm:ss) -> 57:0
Caja n0: 6 / 2
Caja n1: 50 / 3
Con 4 cajas:
-=Estadistica=-

(mm:ss) -> 46:0
Caja n0: 12 / 4
Caja n1: 12 / 3
Caja n2: 12 / 4
Caja n3: 15 / 4
Modificaciones propuestas
IIC 1102
Pgina: 23
Rodrigo Sandoval U.
Como se puede ver en los ejemplos de ejecucin, la simulacin arroja algunos valores estadsticos que
pueden ser de utilidad para el administrador del supermercado: tiempos de espera de los clientes y largos
de cola en las cajas. Sin embargo, la experimentacin es an algo engorrosa, pues cada vez que se
quieren ver los resultados para una determinada configuracin, es necesario ejecutar de nuevo el
programa y registrar los resultados.
Una posible modificacin al programa planteado es hacer que por s mismo busque la mejor
configuracin, de acuerdo a parmetros dados por el usuario. Por ejemplo, Cuntas cajas son
necesarias para que los clientes no deban esperar ms de 1 minuto?. Para lograr esto, el cuerpo de la
simulacin se debe convertir en un mtodo o funcin que reciba como argumento el nmero de cajas y
retorne el tiempo de espera promedio (actualmente se enva por la consola). El algoritmo principal (Main)
har llamados sucesivos a esta nueva funcin (mediante un ciclo), pasndole como argumento distintos
valores para el nmero de cajas en forma incremental (primero 2, luego 3, etc.), hasta que se llegue al
tiempo de espera propuesto por el usuario (1 minuto).
Otra caracterstica que podra resultar muy til es permitir la simulacin por perodos distintos al da
completo. Por ejemplo, es bien sabido que las horas de mayor saturacin en el supermercado se dan al
final de la tarde. Sera til que el administrador del supermercado pudiera determinar cuntas cajas
requiere para cada perodo del da en forma independiente. Actualmente los datos de las horas de muy
alta y muy baja afluencia estn alterando los promedios arrojados. Para lograr esto el programa debera
pedir un rango de horas y ejecutar la simulacin nicamente con los datos de entrada que correspondan
con el rango especificado. Adems, dependiendo de la hora del da el nmero de productos que llevan
los clientes podra variar. Para lograr esto bastara con cambiar la generacin aleatoria de la cantidad de
productos para que dependiera de la hora en la que se est comprando.
Finalmente, podra ser interesante lograr que la hora de llegada de los clientes se genere en forma
aleatoria, de modo que podamos suprimir el archivo de entrada y lo nico que deba dar el usuario es el
nmero de clientes y la cantidad de cajas que debern emplearse para la simulacin.
La planificacin y la implementacin de estas modificaciones se dejan como ejercicio al estudiante.
3.4
Simulacin de una Plaza de Peaje
Este ejemplo en particular se present como trabajo personal dentro de un curso. Cada alumno, contando
slo con ejemplos como los anteriores y la explicacin que se indica a continuacin.
Este ejemplo se centra en implementar una plaza de peaje de la carretera, donde se tienen distintas
casetas abiertas para atencin y en el tiempo van llegando autos a ser atendidos.
Una plaza de peaje est compuesta de distintas casetas que atienden a los autos que llegan por cada
lado de la carretera. Los autos deben pagar una tarifa que depende de la hora, y segn esa tarifa, la tasa
de atencin de la caseta puede aumentar o disminuir.
El propsito del programa es determinar la cantidad ptima de casetas abiertas y atendiendo para dar
un servicio adecuado a los vehculos al menor costo.
Esta particularidad le impone un factor especial al ejemplo, ya que ms que slo ejecutar una simulacin
del funcionamiento de la plaza de peaje, se toman los datos obtenidos de una simulacin completa y se
usan para cambiar los parmetros que determinan el escenario de la siguiente simulacin (en particular la
cantidad de casetas abiertas). De tal manera, se evalan diferentes escenarios y se determina cul de
ellos ofrece la mejor relacin costo/ingreso. Este proceso informal de optimizacin se refleja en el
algoritmo principal (Main).
3.4.1 Definicin del Problema

En detalle el funcionamiento de la simulacin considera lo siguiente:
IIC 1102
Pgina: 24
3.4.1.1
3.4.1.2
3.4.1.3
3.4.1.4
Rodrigo Sandoval U.
El Tiempo de Simulacin
El periodo a simular consta de dos horas, desde las 17:00 a las 19:00 de un da viernes.
Cada unidad de tiempo de simulacin es de 1 minuto.
A las 18:00 - la mitad del tiempo de simulacin - se cambia la tarifa de peaje, con lo cual tambin
cambia la tasa de atencin. Estos dos valores se explican ms adelante.
Las Casetas
Hay un total de 20 casetas construidas, de las cuales en una simulacin dada, el total de ellas o
slo una parte estarn atendiendo (al menos dos casetas siempre, una para cada direccin).
De las abiertas, la mitad est atendiendo a los autos que llegan por el sur y las otras a los que
llegan por el norte. La cantidad de casetas que atienden a cada lado tambin es fijo para cada
simulacin, pero es el parmetro a ir ajustando para determinar la cantidad ptima.
El costo fijo de atencin por caseta es de $50.000 por cada periodo de simulacin, lo que permite
calcular los costos.
En cada caseta siempre habr una cola que tiene 0 ms autos.
Cada auto que llegue a la plaza de peaje, por cualquier direccin, seleccionar la caseta cuya
cola sea la ms corta, o bien la primera si todas son iguales.
Tarifa de peaje: en la primera hora la tarifa es de $1.200 por vehculo, y en la segunda hora es de
$2.000.
La tasa de atencin en la caseta es de:
o 2 autos por minuto cuando la tarifa es baja (ya que se cuenta el tiempo para dar vuelto en
monedas).
o 4 autos por minuto cuando la tarifa es alta (ya que no se requiere dar vuelto en
monedas).
o En cualquiera de los dos casos se atender a la cantidad de autos correspondiente a la
tasa del horario actual, y si quedan menos autos, slo se atender a los que haya.
Los Vehculos
Existe un registro de los autos que llegan por el sur y por el norte respectivamente, identificando
la hora (en hh y mm) y la cantidad de autos que llegan en ese minuto.
Los del norte vienen en el archivo norte.txt y los del sur en sur.txt. Estos archivos asumen
conocidos y para este ejemplo se pueden inventar datos.
En cada archivo se registra una lnea por minuto de datos, la cual tiene en orden:
hh mm cantidadautos.
Si en un minuto dado no se registraron autos (cantidadautos=0), esa lnea no viene en el archivo.
En la correccin de la tarea se pueden utilizar otros archivos, por lo que no asuma que esos
sern siempre los archivos.
El Proceso de Optimizacin
El proceso de optimizacin no se enfoca en las tcnicas formales de optimizacin matemtica, ya que

ese enfoque no forma parte de este documento. Sin embargo, se busca lograr un punto denominad
ptimo por medio de la evaluacin de los resultados tomando distintos escenarios de simulacin. Al
comparar progresivamente los escenarios en torno a los costos e ingresos, se puede llegar a una
combinacin ideal de casetas abiertas que logren un nivel aceptable de tasa de atencin por vehculo.
Para ello, el procedimiento (algoritmo) es el siguiente:
IIC 1102
Se comienza con el mnimo: 1 caseta abierta para los vehculos del norte y 1 para los del sur.
Se efecta la simulacin completa y se miden los siguientes datos que deben mostrarse en
pantalla.
Pgina: 25
Rodrigo Sandoval U.
o Cantidad de cajas abiertas por cada lado.

o Cantidad de autos atendidos por cada lado.
o $ ingreso (cobro de peaje).
o $ costos (casetas x costo fijo).
o Mxima espera en minutos.
Se aumenta en uno la cantidad de casetas abiertas por cada lado y se vuelve a simular.
Las condiciones de trmino del proceso de optimizacin (que a su vez ejecuta varias
simulaciones) son:
o El Tiempo Mximo de espera por atencin debe ser menor que un valor en minutos dado
por el usuario al comienzo de todo el proceso.
o Se analiza si la utilidad (ingresos-costos) disminuye o aumenta. Dentro de la restriccin
de Tiempo de Espera Mxima, se busca el menor costo posible (el mnimo de casetas
abiertas).
o El mximo de casetas es el de la cantidad construida: 20 en total (10 para cada lado).
3.4.2 Solucin
Cdigo Fuente
using System;
using System.IO;
//-----------------------------------------------------------------------------------// Clase: Auto

// Representa un auto cuyos datos relevantes son nicamente los de la hora de llegada
//-----------------------------------------------------------------------------------class Auto {
DateTime horallegada; // Atributo relevante: la hora de llegada.
public Auto(int hh, int mm) {
// Transforma la hora y minutos de llegada en un tipo DateTime
horallegada = new DateTime(DateTime.Now.Year, DateTime.Now.Month,
DateTime.Now.Day, hh, mm, 0, 0);
}
public DateTime HoraLlegada { get { return(horallegada); } }
public int Hora { get { return(horallegada.Hour); } }
public int Minutos { get { return(horallegada.Minute); } }
// Al imprimir una instancia de Auto, se imprime la hora de llegada
public override string ToString() {
return(horallegada.ToString());
}
}
//-----------------------------------------------------------------------------------// Clase: Caseta

// Hereda de Queue, por lo cual la misma caseta representa una cola de vehculos que
// se atienden en dicha caseta. Adems, registra el tiempo mximo de espera durante
// toda la operacin de la caseta, contabiliza los autos atendidos, y va sumando
// el cobro de peajes segn tarifa por auto atendido.
//-----------------------------------------------------------------------------------class Caseta : Queue {
int maxespera = 0;
int procesados = 0;
int ingresos = 0;
// AtenderPrimero(): toma al primero de la cola, y si est en la
//
lo atiende, registrando su tiempo de espera
public int AtenderPrimero(DateTime lahora, int valorpeaje) {
if(Count<=0) return(-1);
// Si no hay autos en cola,
Auto a = (Auto) Peek();
// Se mira el primero de la
IIC 1102
hora adecuada
y contabilizndolo
no se atiende a nadie.
cola
Pgina: 26
Rodrigo Sandoval U.
if( a.HoraLlegada<=lahora ) {// Si lleg antes de la hora actual

TimeSpan ts = lahora - a.HoraLlegada; // Tiempo de espera
Dequeue();
// Se saca de la cola
procesados++;
// Se contabiliza
ingresos += valorpeaje;
// Suma el pago por el peaje al total acum.
return(ts.Hours*60 + ts.Minutes); // Retorna el valor total de minutos
}
return(-1); // Si no se atendi ninguno, retorna <0 para no contabilizar.
}
// Dos versiones para Agregar Auto a la cola (Queue) de la caseta.
public void AgregarAuto(int hh, int mm) { Enqueue((Object) new Auto(hh,mm));
public void AgregarAuto(Auto a) { Enqueue((Object) a); }
// Propiedades de Caseta
public int CantidadAutos { get { return(Count); } }
public int AutosProcesados { get { return(procesados); } }
public int Ingresos { get { return(ingresos); } }
public int MaxEspera {
get { return(maxespera); }
set { if(value>maxespera) maxespera = value; }
}
// PrimerAuto: revisa el primer auto sin sacarlo de la cola
public Auto PrimerAuto { get { return( (Auto) Peek()); } }
}
//-----------------------------------------------------------------------------------// Clase: Plaza

// Representa una coleccin de casetas o plaza de peaje, atendiendo DIR colas de
// autos que llegan. Si bien el ejemplo habla de dos extremos por los que llegan
// autos, se maneja un tributo DIR que representa la cantidad de extremos en forma
// genrica, permitiendo al ejemplo el potencial de ser extendido.
// El valor de casetasenuso se maneja referenciando una nica direccin. Si se abren
// dos casetas por cada direccin, entonces ese valor es 2, totalizando 4 casetas abiertas.
//-----------------------------------------------------------------------------------class Plaza {
const int DIR = 2; // Dos direcciones: Norte y Sur
Caseta[,] casetas; // Matriz de casetas. N casetas por M direcciones (2 dir: N y S).
int casetasenuso;
// Constructor, prepara la plaza indicando cuntas casetas se utilizarn.
// No requiere validar un mximo de casetas en uso, ya que es indiferente a este nivel
public Plaza(int enuso) {
casetas = new Caseta[enuso,DIR];
// Dimensiona la matriz de casetas
for(int dir=0; dir<DIR; dir++)
for(int i=0; i<casetas.GetLength(0); i++)
casetas[i,dir] = new Caseta(); // Instancia c/celda de la matriz.
casetasenuso = enuso;
}
// MejorCaseta(): segn la direccin dada (0: norte; 1: sur)
//
: indica cul es la caseta con la fila ms corta
public Caseta MejorCaseta(int direccion) {
int mincola = casetas[0,direccion].CantidadAutos;
int mincaseta = 0;
for(int i=0; i<casetasenuso; i++)
if( mincola > casetas[i,direccion].CantidadAutos ) {
mincola = casetas[i,direccion].CantidadAutos;
mincaseta = i;
}
return( casetas[mincaseta,direccion] ); // Retorna la caseta elegida.
}
public int CasetasEnuso {
get { return(casetasenuso); }
set { if( value >= 1 ) casetasenuso = value; } // Mnimo de 1 caseta
}
// ProcesarMinuto(): atiende autos en las casetas que alcanzan en el minuto actual,
IIC 1102
Pgina: 27
Rodrigo Sandoval U.
//
: de acuerdo a tasa dada, tomando valor del peaje en ese minuto.
public void ProcesarMinuto(DateTime lahora, int tasa, int valorpeaje) {
// Para ambas direcciones (norte y sur).
// Para todas las casetas abiertas.
for(int j=0; j<tasa; j++)
// Los autos que alcanzan en un min.
if(casetas[i,dir].CantidadAutos>0) {
// Calcula espera del atendido. Si no hay nadie en la cola
// no se atiende a nadie, la espera es -1,
// que no es asignada a MaxEspera.
// Validaciones estn en AtenderPrimero() y de MaxEspera.
int espera = casetas[i,dir].AtenderPrimero(lahora, valorpeaje);
casetas[i,dir].MaxEspera = espera;
}
}
// EsperaMax: Calcula la Mxima espera registrada en las cajas.
public int EsperaMax {
get {
int max=0;
if(max<casetas[i,dir].MaxEspera) max = casetas[i,dir].MaxEspera;
return(max);
}
}
public int TotalIngresos {
get {
int total = 0;
total += casetas[i,dir].Ingresos;
return(total);
}
}
public int TotalAutos {
get {
int total = 0;
total += casetas[i,dir].AutosProcesados;
return(total);
}
}
public int AutosEnCola {
get {
int total = 0;
total += casetas[i,dir].CantidadAutos;
return(total);
}
}
public void Encabezado() {
Console.Write("{0}.{1} ", dir+1, i+1);
Console.WriteLine();
}
public void MostrarResumen() {
Console.Write("{0,3} ", casetas[i,dir].CantidadAutos);
Console.WriteLine();
}
}
IIC 1102
Pgina: 28
Rodrigo Sandoval U.
//-----------------------------------------------------------------------------------// Clase: ColaLlegada

// Representa la cola de autos de llegada por una direccin especfica.
//-----------------------------------------------------------------------------------class ColaLlegada : Queue {
StreamReader sr;
// Constructor: Abre archivo. Lee todos registrndolos en una cola de autos de llegada
public ColaLlegada(string filename) {
try { sr = new StreamReader(filename);
} catch(Exception e) {
Console.WriteLine("Error al abrir {0}\n{1}",
filename, e.ToString()); return;
}
int contador = 0;
while(linea!=null) { // Procesa el archivo completo
contador++;
string[] datos = linea.Split();
if(datos.Length != 3) { // Si no vienen 3 datos, avisa y termina el proceso
Console.WriteLine("Error en formato del archivo de entrada:
+ lnea N {0} no tiene 3 datos", contador);
sr.Close();
return;
}
int cant = int.Parse(datos[2]); // Lee cantidad de autos en min. en proceso
for(int i=0; i<cant; i++) // Registra 1 elem. x c/auto en el min. en proc.
Enqueue( (Object) new Auto(int.Parse(datos[0]),
int.Parse(datos[1])));
}
sr.Close(); // Se cierra el archivo con datos.
}
// Propiedades bsicas de la Cola de Llegada --> Se basan en los mtodos de Queue
public Auto PrimerAuto { get { return( (Auto) Peek()); } }
public int CantidadAutos { get { return(Count); } }
// Mtodos pblicos de la Cola de Llegada
public void SacarPrimerAuto() { if(Count>0) Dequeue(); }
}
//-----------------------------------------------------------------------------------// Clase: SimuladorPlaza

// Se encarga de hacer una simulacin completa en un escenario dado por
// las colas de los autos en llegada y de una cantidad determinada de casetas abiertas
//-----------------------------------------------------------------------------------class SimuladorPlaza {
Plaza p;
ColaLlegada c1;
ColaLlegada c2;
const int TARIFA1 = 1200;
const int TARIFA2 = 2000;
const int TASA1 = 2;
const int TASA2 = 4;
const int COSTO = 50000;
public SimuladorPlaza(string file1, string file2, int casetas) {
p = new Plaza(casetas);
c1 = new ColaLlegada(file1);
c2 = new ColaLlegada(file2);
}
// Procesar(): Mtodo principal de la clase, que realiza (ejecuta) la simulacin
public void Procesar() {
// Se procesa el loop de simulacin principal
DateTime HoraActual = new DateTime(DateTime.Now.Year, DateTime.Now.Month,
IIC 1102
Pgina: 29
Rodrigo Sandoval U.
DateTime.Now.Day, 17, 0, 0, 0);

DateTime HoraCambio = new DateTime(DateTime.Now.Year, DateTime.Now.Month,
DateTime HoraFinal = new DateTime(DateTime.Now.Year, DateTime.Now.Month,
TimeSpan UnTick = new TimeSpan(0,1,0);
// Para ver en pantalla avance del proceso: Console.Write("Llegan "); p.Encabezado();
while( HoraActual<=HoraFinal ) {
// Console.WriteLine(HoraActual);
// Procesa los autos de la hora de llegada actual -> Norte
int llegaron1 = 0;
int llegaron2 = 0;
while( (c1.CantidadAutos>0) && (c1.PrimerAuto.HoraLlegada<=HoraActual) ) {
Caseta cas = p.MejorCaseta(0);
cas.AgregarAuto(c1.PrimerAuto);
c1.SacarPrimerAuto(); llegaron1++;
}
// Procesa los autos de la hora de llegada actual -> Sur
while( (c2.CantidadAutos>0) && (c2.PrimerAuto.HoraLlegada<=HoraActual) ) {
Caseta cas = p.MejorCaseta(1);
cas.AgregarAuto(c2.PrimerAuto);
c2.SacarPrimerAuto(); llegaron2++;
}
// Ahora procesa las colas
int tasa = TASA2;
int tarifa = TARIFA2;
if( HoraActual < HoraCambio ) { tasa = TASA1; tarifa = TARIFA1; }
Console.Write("{0,2} {1,2} ", llegaron1, llegaron2);
p.MostrarResumen(); // OJO: En simulacin larga esto muestra demasiada info
p.ProcesarMinuto(HoraActual, tasa, tarifa);
//
//
//
//
Console.Write("
", llegaron1, llegaron2);
p.MostrarResumen(); // OJO: En simulacin larga esto muestra demasiada info
HoraActual += UnTick; // Aumenta en un instante de simulacin
}
}
public int Costos { get { return(COSTO*p.CasetasEnuso*2); } }
public int Ingresos { get { return(p.TotalIngresos); } }
public int Resultado { get { return(Ingresos - Costos); } }
public int MaxEspera { get { return(p.EsperaMax); } }
public int AutosAtendidos { get { return(p.TotalAutos); } }
class CMain {
public static void Main() {
int casetasenuso = 0;
int resultado = 0;
Console.Write("Ingrese tiempo de espera mximo razonable en minutos: ");
int esperamax = int.Parse(Console.ReadLine());
int espera = 0;
int minespera = 100;
int optimocasetas = 2;
int maxresultado = 0;
//
//
//
//
do
Loop principal: realiza simulaciones y tiene la lgica de optimizacin.

En cada iteracin aumenta la cantidad de casetas en uso.
Ojo que se maneja un nmero de casetas por lado.
Los datos resultantes de cada simulacin de los pregunta al SimuladorPlaza.
{
casetasenuso++; // Cantidad de casetas abiertas por lado
SimuladorPlaza sp =
new SimuladorPlaza("norte.txt","sur.txt", casetasenuso);
Console.WriteLine("\n==============================);
IIC 1102
Pgina: 30
Rodrigo Sandoval U.
Console.WriteLine("Nueva Simulacin\n==============================");
sp.Procesar();
resultado = sp.Resultado;
espera = sp.MaxEspera;
// Se imprimen en pantalla los datos pedidos:
Console.WriteLine("\nResultados de la Simulacin);
Console.WriteLine("==============================");
Console.WriteLine("Casetas : {0}\nAutos Atendidos: {1}\nMx. Espera: {2}",
casetasenuso*2, sp.AutosAtendidos, espera);
Console.WriteLine("Ingresos: {0:C}\nCostos: -{1:C}\nResultado: {2:C}",
sp.Ingresos, sp.Costos, resultado);
// Registra el punto con espera menor que el mnimo dado.
// Dado que siempre ser el de menor cantidad de casetas abiertas
// este punto tambin es el de mayores ingresos.
if( espera<=esperamax ) {
minespera = espera;
optimocasetas = casetasenuso;
maxresultado = resultado;
break;
}
} while(casetasenuso<10);
Console.WriteLine("\nEl punto Optimo);
Console.WriteLine(==========================\n);
Console.WriteLine(Casetas: {0} - Resultado: {1:C}", optimocasetas*2, resultado);
Console.Write("Presione ENTER ..."); Console.ReadLine();
}
}
IIC 1102
Pgina: 31

Simulacioncsharp

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Simulacioncsharp

Cargado por

Copyright:

Formatos disponibles

PONTIFICIA UNIVERSIDAD CATLICA DE CHILE

Simulacin Computacional con C#

Material preparado por Rodrigo Sandoval U en Agosto 2005, (rsandova@ing.puc.cl)

Simulacin Computacional con C#

Simulacin Computacional con C#

Datos o Input de la Simulacin

2.2.1 Generacin de Nmeros Aleatorios

Simulacin Computacional con C#

Generacin de nmeros con Next

// numero1 tendr un valor entre 0 y 10

int numero2 = num.Next(5,11); // numero2 tendr un valor entre 5 y 10

Ejemplo Bsico de Random

A continuacin, un ejemplo de un programa que genera 10 nmeros aleatorios entre 1 y 10.

En el ejemplo anterior resulta relevante analizar las siguientes lneas:

La instanciacin de un nuevo generador de nmeros aleatorios: Random rn = new Random(...)

Le generacin de un nuevo nmero: rn.Next(1,11);

Generacin de Valores Aleatorios en Otras Escalas

Simulacin Computacional con C#

Generacin de Valores Reales Aleatoriamente.

Generacin con Diferente Probabilidad

2.2.2 Carga de Datos Reales desde Archivos

Simulacin Computacional con C#

2.3.1 El Manejo del Tiempo

Simulacin Computacional con C#

Propiedades, Mtodos y Operadores principales de DateTime

Obtiene el componente correspondiente a la fecha de esta instancia.

Obtiene el nmero de pasos que representan la fecha y hora de esta instancia.

Obtiene el componente correspondiente al ao de la fecha representada por esta instancia.

Agrega el nmero de das especificado al valor de esta instancia.

Agrega un intervalo de tiempo especificado a una fecha y hora especificadas,

Simulacin Computacional con C#

Simulacin Computacional con C#

Este mtodo encola un elemento derivado de la clase Object.

Propiedad que retorna un nmero mayor o igual a cero, indicando la cantidad de

Simulacin Computacional con C#

Simulacin de Cadena de Correo

De las 4 personas a quienes se reenva, existe un 66% de probabilidad de que la persona

El periodo que se toma en leer y reenviar es de 24 horas.

Simulacin Computacional con C#

Ejemplo de ejecucin y resultados:

Llegada de Clientes a Caja en el Banco

El periodo de simulacin es de 30 minutos.

Simulacin Computacional con C#

Al finalizar la simulacin interesa conocer:

El total de clientes atendidos por el cajero.

La espera mxima en la cola en minutos.

3.2.1 Solucin 1.0

Simulacin Computacional con C#

// ---------------------------------------------------------------// Clase Cola

// ---------------------------------------------------------------// Clase Principal

Simulacin Computacional con C#

3.2.2 Solucin 2.0

Simulacin Computacional con C#

// ---------------------------------------------------------------// Clase Cliente

// ---------------------------------------------------------------// Clase Cola (Hereda de Queue)

// ---------------------------------------------------------------// Clase Simulacion

Simulacin Computacional con C#

// Proceso dura 30 minutos o hasta que se acaben los clientes

3.2.3 Solucin 3.0

Simulacin Computacional con C#

// ---------------------------------------------------------------// Clase Simulacion

Simulacin Computacional con C#

Simulacin de las Colas en un Supermercado