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#

1 2

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.

Simulacin Computacional con C#

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

Simulacin Computacional con C#

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

Simulacin Computacional con C#

Rodrigo Sandoval U.

2.2.1.2

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 { static void Main() { Random rn = new Random(DateTime.Now.Millisecond); 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

Simulacin Computacional con C#

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 { static void Main() { Random rn = new Random(DateTime.Now.Millisecond); 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 { static void Main() { Random rn = new Random(DateTime.Now.Millisecond); 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

Simulacin Computacional con C#

Rodrigo Sandoval U.

2.3

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

Simulacin Computacional con C#

Rodrigo Sandoval U.

2.3.1.2

Propiedades, Mtodos y Operadores principales de DateTime

Propiedades Date Day DayOfWeek DayOfYear Hour Millisecond Minute Month Now Second Ticks TimeOfDay Today UtcNow Year Mtodos AddDays AddHours AddMilliseconds AddMinutes AddMonths AddSeconds AddTicks AddYears Compare CompareTo Operadores Suma (+) Igualdad (==) Mayor que (> y >=) Desigualdad (!=) Menor que (< y <=) Resta (-) 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. 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. 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. 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). Obtiene el componente correspondiente al ao de la fecha representada por esta instancia.

IIC 1102

Pgina: 6

Simulacin Computacional con C#

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

Simulacin Computacional con C#

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()

Count

Dequeue()

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

Simulacin Computacional con C#

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 { static void Main() { Random rn = new Random(DateTime.Now.Millisecond); 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

Simulacin Computacional con C#

Rodrigo Sandoval U.

Ejemplo de ejecucin y resultados: Da 1: de:1 rec:4 y env:3 Da 2: de:3 rec:12 y env:3 Da 3: de:3 rec:12 y env:9 Da 4: de:9 rec:36 y env:14 Da 5: de:14 rec:56 y env:22 Da 6: de:22 rec:88 y env:28 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. Se asume que todos los clientes tienen en promedio la misma cantidad de trmites que realizar, por lo que se demorarn lo mismo.

IIC 1102

Pgina: 10

Simulacin Computacional con C#

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

Al finalizar la simulacin interesa conocer: El total de clientes atendidos por el cajero. La espera mxima en la cola en minutos.

Orden de Llegada

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. Cdigo Fuente Solucin
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

Simulacin Computacional con C#

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 { static void Main() { 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

Simulacin Computacional con C#

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

Simulacin Computacional con C#

Rodrigo Sandoval U.

Cdigo Fuente
using System; using System.IO; using System.Collections;

// ---------------------------------------------------------------// 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); } } }

// ---------------------------------------------------------------// 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; } string linea = sr.ReadLine(); while(linea != null) { Enqueue(new Cliente(int.Parse(linea))); linea = sr.ReadLine(); } 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 public void Atender() { 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

Simulacin Computacional con C#

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 { static void Main() { 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); Console.Write("Presione ENTER..."); Console.ReadLine(); } }

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; using System.Collections; // ---------------------------------------------------------------// Clase Cliente // Representa un cliente, con su instante de llegada // ---------------------------------------------------------------class Cliente { DateTime horallegada; public Cliente(DateTime hl) { horallegada = hl; } public DateTime HoraLlegada { get { return(horallegada); } } }

IIC 1102

Pgina: 15

Simulacin Computacional con C#

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); Random rn = new Random(DateTime.Now.Millisecond); 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 { static void Main() { Simulacion sim = new Simulacion(); sim.Procesar(); Console.WriteLine("Cliente atendidos: {0}", sim.Atendidos); Console.WriteLine("Mxima espera: {0}", sim.MaxEspera); Console.Write("Presione ENTER..."); Console.ReadLine(); } }

IIC 1102

Pgina: 16

Simulacin Computacional con C#

Rodrigo Sandoval U.

3.3

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

Simulacin Computacional con C#

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 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 compras2 comprasN

...
Caja1

compras1

compras2

comprasN

...
Caja2

compras1

compras2

comprasN

...
CajaN

IIC 1102

Pgina: 18

Simulacin Computacional con C#

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

Simulacin Computacional con C#

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.

Cdigo Fuente Solucin

using System; using System.IO; using System.Collections; 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

Simulacin Computacional con C#

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 } 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++) for(int j = 0; j < max_caja; j++) 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); for(int j = 0; j < max_caja; j++) if(cajas[i,j] != 0) Console.WriteLine(" {0}",cajas[i,j]); } Console.WriteLine(""); } public void Atender() { 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() { LargoTotal = 0; LargoMax = 0; } num_clientes;

IIC 1102

Pgina: 21

Simulacin Computacional con C#

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

Simulacin Computacional con C#

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=-

Tiempo de espera Promedio (mm:ss) -> 29:0 Tiempo de Espera Maximo (mm:ss) -> 57:0 Largo de la Cola en las Cajas (Promedio/Maximo): Caja n0: 6 / 2 Caja n1: 50 / 3 Con 4 cajas: -=Estadistica=-

Tiempo de espera Promedio (mm:ss) -> 26:0 Tiempo de Espera Maximo (mm:ss) -> 46:0 Largo de la Cola en las Cajas (Promedio/Maximo): Caja n0: 12 / 4 Caja n1: 12 / 3 Caja n2: 12 / 4 Caja n3: 15 / 4 Modificaciones propuestas

IIC 1102

Pgina: 23

Simulacin Computacional con C#

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

Simulacin Computacional con C#

Rodrigo Sandoval U.

3.4.1.1

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

3.4.1.2

3.4.1.3

3.4.1.4

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: 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.

IIC 1102

Pgina: 25

Simulacin Computacional con C#

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; using System.Collections;

//-----------------------------------------------------------------------------------// 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 hora adecuada y contabilizndolo no se atiende a nadie. cola

IIC 1102

Pgina: 26

Simulacin Computacional con C#

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

Simulacin Computacional con C#

Rodrigo Sandoval U.

// : de acuerdo a tasa dada, tomando valor del peaje en ese minuto. public void ProcesarMinuto(DateTime lahora, int tasa, int valorpeaje) { for(int dir=0; dir<DIR; dir++) // Para ambas direcciones (norte y sur). for(int i=0; i<casetasenuso; i++) // 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; for(int dir=0; dir<DIR; dir++) for(int i=0; i<casetasenuso; i++) if(max<casetas[i,dir].MaxEspera) max = casetas[i,dir].MaxEspera; return(max); } } public int TotalIngresos { get { int total = 0; for(int dir=0; dir<DIR; dir++) for(int i=0; i<casetasenuso; i++) total += casetas[i,dir].Ingresos; return(total); } } public int TotalAutos { get { int total = 0; for(int dir=0; dir<DIR; dir++) for(int i=0; i<casetasenuso; i++) total += casetas[i,dir].AutosProcesados; return(total); } } public int AutosEnCola { get { int total = 0; for(int dir=0; dir<DIR; dir++) for(int i=0; i<casetasenuso; i++) total += casetas[i,dir].CantidadAutos; return(total); } } public void Encabezado() { for(int dir=0; dir<DIR; dir++) for(int i=0; i<casetasenuso; i++) Console.Write("{0}.{1} ", dir+1, i+1); Console.WriteLine(); } public void MostrarResumen() { for(int dir=0; dir<DIR; dir++) for(int i=0; i<casetasenuso; i++) Console.Write("{0,3} ", casetas[i,dir].CantidadAutos); Console.WriteLine(); } }

IIC 1102

Pgina: 28

Simulacin Computacional con C#

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; } string linea = sr.ReadLine(); 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]))); linea = sr.ReadLine(); } 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

Simulacin Computacional con C#

Rodrigo Sandoval U.

DateTime.Now.Day, 17, 0, 0, 0); DateTime HoraCambio = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 18, 0, 0, 0); DateTime HoraFinal = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, 19, 0, 0, 0); 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

Simulacin Computacional con C#

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