Está en la página 1de 39

UNIVERSIDAD NACIONAL DE COLOMBIA

FACULTAD DE INGIERIÍA
SEDE BOGOTÁ

Taller 1 – Grupo 310

Acosta Murillo, Jhon Fredy

Mohseni, Hamed

Moreno Valbuena, Cristian Camilo

Riaño Pineda, Felipe Esteban

Departamento de Ingeniería de Sistemas e Industrial


Modelos y Simulación
2020 - I
Estructura general de los ejercicios
 Enunciado

 Desarrollo de la simulación:
A. Estado del Sistema (variables)
B. Entidades y sus atributos
C. Eventos, Actividades y procesos
D. Contadores y/o acumuladores
E. Medidas de desempeño

 Diagrama de flujo (imagen)

 Análisis

Problema común del mundo real: Aeropuerto


A. Estado del sistema (variables)
● Tiempo de llegada del siguiente avión
● Tiempo de llegada del siguiente cliente
● Número de aviones disponibles
● Número de aviones en el sistema
● Número de usuarios en el aeropuerto

B. Entidades y sus atributos


● Usuario
o Tiempo de espera (desde la realización del pago del pasaje hasta el abordaje del
avión)
o Avión asignado

● Avión
● Número de pasajeros
● Disponibilidad del avión
● Capacidad de pasajeros
● Precio de ruta
● Tiempo de vuelo

C. Eventos, Actividades y procesos


● Eventos
o Llegada de un cliente (se tiene en cuanta la llegada cuando hace el pago del pasaje)
o Llegada de un avión
o Salida de un avión
● Actividades
o Abordar un avión

D. Contadores estadísticos:
● Tiempo de estadía de un pasajero
● Número de aviones disponibles
● Número de aviones en el sistema

E. Medidas de desempeño:
● Tiempo promedio de espera de un cliente para tomar un avión
● Tiempo promedio en reposo de aviones disponibles (pasajeros abordando)
● Porcentaje promedio de número de pasajeros en cada avión

Los datos de entrada requeridos serían:


o Longitud máxima de la cola
o Cuánto puede esperar un pasajero para abordar su avión
o Cantidad máxima de pasajeros por vuelo

1.10
Enunciado
Después del embalaje, un transportador de banda transfiere al inventario los productos acabados en
lotes de 1000 unidades. Los cartones de embalaje se colocan en la banda del transportador
automáticamente, a una distancia de 2.10 m. de centro a centro. Los cartones se descargan a mano y
se retiran de la banda dentro de una distancia de 2.10 m. O sea que el trabajador no puede alcanzar
un cartón que este a más de 1.05 m de él. Cualquier cartón no descargado por el empleado cae
automáticamente de la banda y se debe recuperar en un momento posterior. El tiempo necesario
para descargar un cartón está distribuido normalmente con una media de 15 segundo y una
desviación estándar de 3 segundos.
La distancia del punto de carga al de descarga, medida a lo largo del transportador, es de 30 m. El
transportador puede funcionar a cualquier velocidad que se desee. Sea X el número de cartones
retirados por hora y sea y el número de cartones que deja de descargar el empleado por hora.
a) Mediante la simulación y una técnica apropiada de investigación, determínese la
velocidad del transportador que maximice x – y.
b) Resuélvase el problema anterior, cuando la distancia entre cartones sucesivos tenga una
distribución exponencial con una media de 2.40 m.

Desarrollo de la simulación
A. Estado del Sistema (variables):
 Reloj
 Tiempo de inicio
 Tiempo final
 Velocidad de banda transportadora
 Cartones descargados
 Cartones sin descargar

B. Entidades y sus atributos:


 Cartón: estado de descarga

C. Eventos, actividades y procesos:


Eventos:
o Comienzo de carga del lote
o Carga del cartón
o Fin de carga del lote
Actividades:
o Descarga del trabajador
o No descarga del trabajador
Procesos:
o Recorrido del cartón

D. Contadores y/o acumuladores:


 Cantidad de cajas cargadas
 Cantidad de cajas descargas por el trabajador
 Cantidad de cajas no descargadas por el trabajador
 Tiempo de espera en el abordaje

E. Medidas de desempeño:
 Promedio de descarga
 Total de cartones descargados
 Total de cartones no descargados

Diagrama de flujo
Simulación:
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//Constantes
const int lote = 1000; // Cantidad de cartones
const float aumenDist = 0.7;//Coeficiente de avance para poder avanzar

//variables
int loteActual, tiempoAcu, CajaDisponible, Disponibilidad, x, y;
float velocidad, velMaxX = 0, velMaxY = 0; //(x) Cajas descargadas, (y) Cajas sin descargar
float tiempoAum, tiempoAct,tiempoTrabjador; // El reloj aumenta de a segundos
float cartones[14] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
//Functions
    //Iniciar
    void inicio(){
        tiempoAct = 0;
        CajaDisponible = 0;
        Disponibilidad = 1;
        loteActual = 1000;
        velocidad = 0.0001;
        tiempoTrabjador = 0.001;
        x = 0;
        y = 0;
    }
    
    //Ajustar posicion
    void ajustPosicion(int aux, float sum){
        if(aux <= 14){
            for(int i = 0; i < 14; i++){
                if(i == 13){
                    cartones[i] = sum;
                }else if(cartones[i+1] != 0){
                    cartones[i] = cartones[i+1];
                    cartones[i] += sum;
                }
            }
        }else if(aux >= 987){
            for(int i = 0; i < 14; i++){
                if(i == 13 || cartones[i+1] == 0){
                    cartones[i] = 0;
                }else if(cartones[i+1] == 0){
                    break;
                }else{
                    cartones[i] = cartones[i+1]+sum;
                }
            }
        }else{
            for(int i = 0; i < 14; i++){
                if(i == 13){
                    cartones[i] = sum;
                }else{
                    cartones[i] = cartones[i+1] + sum;
                }
            }
        }
    }
    
    //Sumar por el paso de tiempo
    void sumPar(float sum){
        for(int i = 0; i < 14; i++){
            if(cartones[i] != 0){
                cartones[i] += sum;
            }
        }
    }
    
    //Generador de Tiempo de trabajador aleatorio
    int generarTiempoTrabajador(){
        return rand() % (12-18+1)+12;
    }
    
    //Mayor entre dos flotantes 
    float may(float a, float b){
        if(a >= b){
            return a;
        }else{
            return b;
        }
    }
    
    //Generar velocidad
    void descargaDifVel(){
        //Inicializar variables
        inicio();
        
        //Proceso de maximizar 'x' y 'y', variando la velocidad
        for(int i = 1; velocidad <= 100; i++){
            //Inicializacion tiempos de banda transportadora y el trabajador
            float tiemBand = 0, tiemTrab = 0;
            int auxCon = 0, aux = 1, change = 0;
            int xAux = 0, yAux = 0;
            
            //Cambio de velociddad
            velocidad += 0.01;
            
            //Hallar tiempo que transcurre para que la banda avance 0.7m
            float tiempoBandaTrans = (aumenDist/velocidad), tiempoActual = 0;
            
            //Desplazamiento cada cierto tiempo
            float despla = (velocidad * tiempoBandaTrans), acum = 0;
            
            //Situacion inicial
            Disponibilidad = 1;
            CajaDisponible = 0;
            
            //Variable para ver el desface que tiene el trabajador para poder volver a estar disponible
            float tiempoNuevo = 0;
            
            
            for(int j = 0; aux <= 1000; j++){
                auxCon = 0;
                acum += despla;
                
                //Analisis en el momento que los cartenoes llegan a area de descarga
                if(aux > 14){
                    
                    CajaDisponible = 1;
                    
                    //Trabajador se encuentra disponible
                    if(Disponibilidad == 1){
                        //Descargue por parte del trabajador
                        int rr = generarTiempoTrabajador();
                        float a = (float) rr;
                        //Analisar en que momento el trabajador vuelve a estar diponible
                        if(a > tiempoBandaTrans){
                            for(int w = 0; a > tiempoBandaTrans; w++){
                                a -= tiempoBandaTrans;
                                tiempoNuevo += tiempoBandaTrans;
                            }
                            //Verficar
                            if(change == 1){
                                xAux++;
                            }
                            Disponibilidad = 0;
                        }else{
                            if(change == 1){
                                xAux++;
                            }
                            Disponibilidad = 1;
                        }
                    }else if(Disponibilidad == 0){ //Trabajador no disponibe
                        tiempoNuevo -= tiempoBandaTrans;
                        if(tiempoNuevo == 0){
                            if(change == 1){
                                yAux++;
                            }
                            Disponibilidad = 1;
                        }else{
                            if(change == 1){
                                yAux++;
                            }
                            Disponibilidad = 0;
                        }
                    }
                    CajaDisponible = 0;
                    change = 0;
                }
                
                //Verficar que la caja ya avanzo 2.1m
                int ver = (int)((acum - 2.100000)*10);
                
                //Actualización del arreglo de lugares de la banda
                if(j == 0){
                    cartones[13] += acum;
                }else if(ver == 0){ //Verificar cuando salir la otra caja
                    ajustPosicion(aux,despla);
                    aux++;
                    if(aux > 14){
                        change = 1;
                    }
                    acum = 0;
                }else{
                    sumPar(despla);
                }
                
                //Actualiza tiempo
                tiempoActual += tiempoBandaTrans;
                
            }
            
            //'x' y 'y' maximizandose
            x = may(x, xAux);
            if(x == xAux){
                velMaxX = velocidad;
            };
            y = may(y, yAux);
            if(yAux == y){
                velMaxY = velocidad;
            };
            
            //Actualización del tiempo de la simulación
            tiempoAct += tiempoActual;
            
            //Reincio de los lugares de la banda de transporte
            for(int w = 0; w < 14; w++){
                cartones[w] = 0; 
            }
        }
        
        printf("Maximo numero de x = %i, Velocidad De maximo x =  %f \n", x, velMaxX);
        printf("Maximo numero de y = %i, Velocidad De maximo y =  %f \n", y, velMaxY);
    }

int main(){
    descargaDifVel();
    printf("\nTiempo que dura la simulacion de 10000 velocidades para\n\t fue: %.2f segundos",
tiempoAct);
}

Análisis
En la simulación anterior, se tuvo que proceder a la realización de iteraciones, que dependían de la
cantidad de cartones que había en un lote.

Con el fin de poder analizar y maximizar tanto las variables ‘x’ y ‘y’ dependiendo de la velocidad
de la banda, tenía que realizar bucles iterando el valor de la velocidad con saber en qué momento y
con qué velocidad x toma su máximo valor o y toma su máximo valor.

Lo mismo se realizó pera el segundo punto, pero se tendría que hallar valores aleatorios de una
distribución exponencial, teniendo en cuenta que la media que planteo el docente correspondía a
2.4, con ese valor entregado se podía hallar λ (lambda), y poder usar la fórmula:
−1
x= ln ( 1−u ) ; u=U (0,1)
λ

1.11

Enunciado
Personas llegan a un paradero de bus a la tasa de uno cada 20 ± 15 segundos. Ellos esperan por el
bus a menos que la cola tenga 10 personas, en cuyo caso se alejan. El bus llega cada 5 ± 1 minuto.
Las personas abordan el bus uno a la vez, tomando 5 segundos cada uno. El bus espera por lo
menos 20 segundos, de lo contrario sale tan pronto como las personas terminen de subir. Simular 10
autobuses llenos de personas. (Utilice flujos de números aleatorios para representar personas y
buses y de prioridad a las personas).
Desarrollo de la simulación

A. Estado del Sistema (variables):


 Reloj
 Tiempo entre llegada de pasajeros
 Tiempo de espera en la cola
 Tiempo entre llegada de buses
 Tiempo de subida de pasajeros

B. Entidades y sus atributos:


 Pasajeros: Tiempo de llegada
 Buses: Tiempo de llegada

C. Eventos, actividades y procesos:


Eventos:
o Llegada de un pasajero
o llegada de un Bus
o Subida de un pasajero al bus
o Salida del Bus
Actividades:
o Espera del bus
o Espera del bus cuando suben pasajeros
Procesos:
o Llegada de un pasajero hasta abordar el bus

D. Contadores y/o acumuladores:


 Total de personas que llegan la parada
 Total de personas que abordan el bus
 Tiempo de espera en la fila
 Tiempo de espera en el abordaje

E. Medidas de desempeño:
 Promedio de espera en la cola
 Total de personas que llegaron
 Total de personas que abordaron
 Promedio de abordaje
 Promedio de pasajeros en el bus

Diagrama de flujo
Simulación

#include <stdio.h>
#include <stdlib.h>
#include "lcgrand.h"

#define FOR(n) for(int i=0;i<n;i++)
#define FOREX(i,n,in) for(i;i<n;i+=in)
#define Q_LIMIT 10
#define T_BUSES 10
#define ABORDAJE 5
#define ESPERA_BUS 20
#define ON 1
#define OFF 0
int tipo_siguiente_evento, fila, bus_estado, llegada_persona, abordaje_perso
na,buses,eventos, persona_no_abordar, personas_espera, eventos;

float clock, ultimo_evento, area_personas_cola, tiempo_abordaje, tiempo_espe
ra_total, tiempo_espera_bus,
      tiempo_sig_evento[5], tiempo_llegada_pasajeros[Q_LIMIT], llegada_buses
[T_BUSES], pro_llegada_p, pro_llegada_b;

void iniciar(void);
void tiempo(void);
void actualizar_var_pro(void);
void llegada_p(void);
void llegada_b(void);
void abordar(void);
void salida_b(void);
void reportar(void);

int main()
{
     iniciar();

    while (buses<T_BUSES){

        tiempo();
        actualizar_var_pro();
        switch (tipo_siguiente_evento) {
            case 1:
                llegada_p();
                break;
            case 2:
                llegada_b();
                break;
            case 3:
                abordar();
                break;
            case 4:
                salida_b();
                break;
        }
    }

    reportar();
}

void iniciar(void){

  clock = 0.0;
  bus_estado = OFF;
  fila = 0;
  llegada_persona=0;
  abordaje_persona=0;
  buses=0;
  area_personas_cola=0.0;
  eventos=4;
  persona_no_abordar=0;
  personas_espera=0;
  ultimo_evento=0.0;
  tiempo_abordaje=0.0;
  tiempo_espera_total=0.0;
  tiempo_espera_bus=0.0;
  pro_llegada_p=rand () % 31 + 5;
  pro_llegada_b=rand () % 121 + 240;
  tiempo_sig_evento[1]= clock + lcgrand(pro_llegada_p);
  tiempo_sig_evento[2]= clock + lcgrand(pro_llegada_b);
  tiempo_sig_evento[3]= 1.0e+30;
  tiempo_sig_evento[4]=1.0e+30;
}

void tiempo(void)
{
    float min_time_next_event = 1.0e+29;
    tipo_siguiente_evento = 0;
    FOR(eventos){
        if (tiempo_sig_evento[i+1] < min_time_next_event) {
            min_time_next_event = tiempo_sig_evento[i+1];
            tipo_siguiente_evento = i+1;
        }
    }
    clock = min_time_next_event;
}

void llegada_p(void)
{

    float delay;
    tiempo_sig_evento[1]= clock + lcgrand(pro_llegada_p);
    ++llegada_persona;
    if(fila == 0 && bus_estado== ON){

        delay=0.0;
        tiempo_espera_total+=delay;
        ++personas_espera;
        tiempo_sig_evento[2]=1.0e+30;
        tiempo_sig_evento[3]=clock  +ABORDAJE;
    }else if (fila < Q_LIMIT)
    {

        ++fila;
        tiempo_llegada_pasajeros[fila] = clock;
        tiempo_sig_evento[2]=clock +  lcgrand(pro_llegada_b);

    }else if (Q_LIMIT > fila){
        ++persona_no_abordar;
    }
}

void llegada_b(void){

  tiempo_sig_evento[2] = clock+lcgrand(pro_llegada_b);
  bus_estado=ON;
  if(fila > 0){
    tiempo_sig_evento[3] = clock + ABORDAJE;

  }else{
    tiempo_sig_evento[4] = clock + ESPERA_BUS;
    tiempo_espera_bus=clock + ESPERA_BUS;
  }
}

void abordar(void)
{
    tiempo_sig_evento[3] = clock + ABORDAJE;
    tiempo_abordaje += ABORDAJE;
  tiempo_espera_total += tiempo_llegada_pasajeros[1];
  --fila;
  ++abordaje_persona;
  for(int i = 0; i < Q_LIMIT-1; i++){
    tiempo_llegada_pasajeros[i] = tiempo_llegada_pasajeros[i+1];
  }
  if(fila > 0){
    tiempo_sig_evento[4] = clock + ABORDAJE;

  }
  else {
    tiempo_sig_evento[3] = clock+lcgrand(pro_llegada_b);

  }
}
void salida_b(void)
{

        bus_estado = OFF;
        tiempo_sig_evento[2] =clock + ABORDAJE ;
        ++buses;

void reportar(void){
    printf( "\n\nDemora Promedio de personas: %11.3f \n\n",
            tiempo_espera_total /personas_espera);
    printf( "\n\nDemora Promedio de buses: %11.3f \n\n",
            tiempo_espera_bus / buses);
    printf( "Numero promedio de personas en cola: %10.3f\n\n",
            area_personas_cola / clock);
    printf( "Personas que no abordaron: %d\n\n",
            persona_no_abordar);
    printf( "Numero de personas atendidas: %d",
            personas_espera);
}

void actualizar_var_pro(void){

  float desde_ultimo_evento = clock - ultimo_evento;
  ultimo_evento = clock;

  area_personas_cola += fila * desde_ultimo_evento;

}
Análisis
 La estación de buses no suele tener cola ya que el flujo de personas no supera el flujo
de buses en la estación.
 Asimismo, la demora promedio de un usuario es 0 al igual que la cantidad de personas
que no alcanzan a abordar un bus.

1.12

Enunciado

Un sistema de colas con cuatro canales en serie funciona con las características siguientes:
• Llegadas de Poisson, ʎ = 0.04
• Tasas de servicio µ1= 0.05, µ2 = 0.06, µ3 = 0.05 y µ4= 0.07 todas con distribución
exponencial
• Longitud de las colas NQ1 = 100, NQ2= 10, NQ3 = 20 y NQ4 = 30
• Solo el 60% entran en la instalación 2. Las otras van con igual probabilidad a las
instalaciones 3 o 4
Analice este sistema durante un periodo de 30 días de tiempo simulado, Qué ocurriría si
sólo el 20% de las unidades entraran al canal 2 y las otras fueran con las mismas
probabilidades a los canales 3 y 4?

Desarrollo de la simulación

A. Estado del Sistema (variables):


 Reloj
 Número de servidores
 Numero de colas
 Tiempo de llegada

B. Entidades y sus atributos:


 Personas: Tiempo de llegada
 Servidores: Tiempo de llegada

C. Eventos, actividades y procesos:


Eventos:
o Llegada de un pasajero
o Salida de un pasajero
o Fin de la simulación

D. Contadores y/o acumuladores:


 Cola y Servidor
 Cola máxima por servidor
 Numero de servicios por servidor

E. Medidas de desempeño:
 La utilización promedio
 Demora promedio en la cola
 La cola más larga
 Los trabajos hechos por los servidores
 Promedio de pasajeros en el bus
Diagrama de flujo

Simulación
Cabe aclarar las que toca poner las tres librerías de simlib como, simlib.h, simlib.c, simlibdefs.h

#include "simlib.h"
 
//eventos
#define EVENT_ARRIVAL        1  /* llegadas. */
#define EVENT_DEPARTURE      2  /* terminacion de servicio */
#define EVENT_END_SIMULATION 3  /* Fin de la simulacion*/
 
//semillas
#define STREAM_SERVICE_1     1  /* serie de numeros aleatorios para tiempo de servicio. *
/
#define STREAM_SERVICE_2     2  /* serie de numeros aleatorios para tiempo de servicio. *
/
#define STREAM_SERVICE_3     3  /* serie de numeros aleatorios para tiempo de servicio. *
/
#define STREAM_SERVICE_4     4  /* serie de numeros aleatorios para tiempo de servicio. *
/
//esto asi para garantizar mayor independencia pues cada servicio tiene una media distint
a
#define STREAM_INTERARRIVAL  5  /* serie de numeros aleatorios interllegadas.           */
#define STREAM_NEXT          6  /* serie de numeros aleatorios para la siguiente tarea. */
 
#define MAX_NUM_SERVERS      4
//listas
 
#define SERVER_ONE 1
#define SERVER_TWO 2
#define SERVER_THREE 3
#define SERVER_FOUR 4
 
#define QUEUE_ONE 5
#define QUEUE_TWO 6
#define QUEUE_THREE 7
#define QUEUE_FOUR 8
//lista de eventos     25
 
/* Declaracion de variables goblales no-simlib. */
int num_stations, i, queues[MAX_NUM_SERVERS+1], maxQ[MAX_NUM_SERVERS+1], com
pleted[MAX_NUM_SERVERS +1]; //el i sirve de iterador
double lambda_interarrival, prob_distrib_prox_task[4], mean_service[MAX_NUM_SERVER
S +1];
double length_simulation;
FILE  *infile, *outfile;
 
/* Declaracion funciones no-simlib. */
 
void  arrive(int new);
void  depart(int channel);
void  report(FILE *file);
void  intit_model();
 
main(){
    //abrir archivos
    FILE *infile , *outfile;
    infile = freopen("model_in.txt","r",stdin);
    outfile =freopen("model_out.txt","w",stdout);
    //leer parametros
    if(infile == NULL||outfile ==NULL){
        printf("no se pudo abrir archivos");
        exit(0);
    }
 
    //lee el numero de estaciones
    fscanf(infile, "%d %lf %lf ", &num_stations, &lambda_interarrival,&length_simulation);
    //lee las medias de servicio
    for (i = 1; i <= num_stations; ++i)
        fscanf(infile, "%lf", &mean_service[i] );
    //lee las colas
    for (i = 1; i <= num_stations; ++i)
        fscanf(infile, "%d", &queues[i] );
 
    //lee la escalera que define la salida del modulo 1
    prob_distrib_prox_task[0]=0;
    for (i = 1; i <= num_stations -1; ++i)
        fscanf(infile, "%lf", &prob_distrib_prox_task[i] );
 
        /*Reportar parametros de simulacion*/
 
        fprintf(outfile, " MODELO DE CANALES EN SERIE usando simlib\n\n");
        fprintf(outfile, "La media de llegadas corresponde a poisson de  lambda: %1.5f\n",lam
bda_interarrival);
        fprintf(outfile,"El numero de servidores(canales): %d\n",num_stations);
 
        fprintf(outfile, "\nMedia de servicio por canal:        ");
        for (i = 1; i <= num_stations; ++i)
            fprintf(outfile, "%8.3lf    ", mean_service[i]);
 
        fprintf(outfile, "\nEl tama�o de cola por servidor es:  ");
        for (i = 1; i <= num_stations; ++i)
            fprintf(outfile, "%8.3d ", queues[i]);
 
        fprintf(outfile, "\n\nSe va a simular por: %20.1lf horas\n\n\n", length_simulation);
 
        //inicializar
        init_model();
 
        do{//mientras no se de el evento tipo 3
 
            //mover el tiempo
            timing();
                    //evento 1,2 3
 
            switch(next_event_type){
                case EVENT_ARRIVAL:
                    //--llamar funcion de llegada
                    arrive(transfer[3]);
                    break;
                case EVENT_DEPARTURE:
                    //---llamar f de salida
 
                    depart(transfer[3]);
                    break;
                case EVENT_END_SIMULATION:
                    //---llamar reporte
                    report(outfile);
                    break;
 
            }
        }while(next_event_type < EVENT_END_SIMULATION);
 
    fclose(infile);
    fclose(outfile);
 
}
 
init_model(){
    init_simlib(); //prepara listas, reloj = 0, estadisiticos = 0
    maxatr = 4;  /* Kelton recomienda minimo usar 4. */
 
    //programar evento fin de la simulacion.
    event_schedule(length_simulation,EVENT_END_SIMULATION);
 
    //programa una llegada
    transfer[3] = SERVER_ONE;
    event_schedule(sim_time + expon(lambda_interarrival,STREAM_INTERARRIVAL) ,EVENT
_ARRIVAL);
 
    // inicializar variables no simlib
    for(i=1;i<=MAX_NUM_SERVERS+1; i++)
        maxQ[i]=0;
        completed[i] = 0;
    }
 
void  arrive(int server){
 
    if(server ==1){
        //programa una proxima llegada al sistema(servidor uno)
        //ojo son llegadas exponenciales  porque el tiempo (continuo) entre eventos poisson(
discreto) se modela estadisiticamente con una gamma (1,lambda)
        transfer[3]= SERVER_ONE;
        event_schedule(sim_time + expon(lambda_interarrival,STREAM_INTERARRIVAL) ,EVE
NT_ARRIVAL);
    }
 
    // esta el servidor libre?
        if(list_size[server]==0){
            //completo demora
            sampst(0.0,server);
            //asigna al servidor
            list_file(FIRST,server);
            //programa el fin del servicio
            transfer[3]= server;
            event_schedule(sim_time + expon(mean_service[server], server), EVENT_DEPARTU
RE); /*cada servidor tiene su stream homologo*/
            return;//termina la rutina
        }
    //no quedo en servicio asi que se une a la fila.
    transfer[1]=sim_time;
    list_file(LAST,MAX_NUM_SERVERS + server);
 
    if(maxQ[server] < list_size[MAX_NUM_SERVERS + server]){
        maxQ[server]++;
    }
 
}
void  depart(int channel){
    //se identificia la salida del canal channel
 
    //Esta la cola libre para este canal?
    if(list_size[MAX_NUM_SERVERS + channel] == 0){
        //SI!, maerque libre
        list_remove(FIRST,channel);
    }else{
        //no! pase el siguiente
        list_remove(FIRST,MAX_NUM_SERVERS + channel);
        //completo demora En trasnfer 1 esta la llegada a esta lista
        sampst(sim_time-transfer[1],channel);
        //programa fin de servicio
         transfer[3]=channel;
         event_schedule(sim_time + expon(mean_service[channel], channel), EVENT_DEPART
URE);/*cada servidor tiene su stream homologo*/
    }
 
    completed[channel]++;
    //el que se va donde viene?
    switch(channel){
        case SERVER_ONE: //channel 1, pasa a canal 2, 3 o 4 segun probabilidad
            arrive(random_integer(prob_distrib_prox_task, STREAM_NEXT) + 1);
            break;
        case SERVER_TWO://channel 2,  pasa a canal 3
            arrive(SERVER_THREE);
            break;
        case SERVER_THREE://channel 3, pasa a canal 4
            arrive(SERVER_FOUR);
            break;
        case SERVER_FOUR://chanel 4 termin�!
            break;
 
    }
 
}
 
void  report(FILE *file){
     int   j;
 
    //probabilidades para la segunda tarea "tipo de trabajo"
    fprintf(file, "\n servidor    probabilidad de pasar despues del tarea 1");
    for(j=1;j<=3;j++)
        fprintf(file, "\n %4d           %17.3f", j+1,prob_distrib_prox_task[j] );

    fprintf(file, "\n\n\n servidor      utilizacion        cola mas       Demora promedio        trabajo
s");
    fprintf(file,     "\n (canal)         promedio           larga            en cola            atendidos");
    for (j = 1; j <= num_stations; ++j){
 
        fprintf(file, "\n\n%4d%17.3f                %4d   %17.3f            %4d", j, filest(j), maxQ[j], sam
pst(0.0, -j),  completed[j]);
 
    }
 
}
 

Resultados y Análisis
Aquí podemos ver, después de simular las dos características que nos plantea el problema siempre
la cola 1 tiene los mismos datos dado que la probabilidad que nos plantea el problema no cambia.
En lo más resaltable es que la cola 4 es donde siempre atienden la mayor cantidad de trabajos y la
suele ser la cola más larga precisamente por esto y la distribución Poisson que nos proponen desde
el principio del problema. El tiempo que también nos propone el problema también influye porque
nos da a entender mejor cómo funciona el sistema con datos más grandes. 

1.13
Enunciado
Considere una facilidad de servicio con s servidores en paralelo (s>= 1) Suponga que los tiempos
entre llegadas de los clientes son variables aleatorias exponenciales con media E(A) y que los
tiempos de servicio de los clientes (independiente del servidor) son variables aleatorias
idénticamente distribuidas e independientes con media E(S). Si un cliente llega y encuentra uno o
más servicios libres, el cliente inicia servicio inmediatamente. De lo contrario, el cliente se une al
final de una cola FIFO (COLA M/M/s). Escriba un programa general para simular el sistema con el
cual evaluar demora promedio en la cola, número promedio de clientes en la cola y la utilización
promedio de los servidores con condición de terminación de completar n demoras. Corra el modelo
con los parámetros s = 5, E(A)=1, E(S)=4, y n = 1000

Desarrollo de la simulación
A. Estado del Sistema (variables)
 Reloj
 Tiempo entre llegada de clientes
 Tiempo de espera en la cola
 Tiempo de servicio en los servidores

B. Entidades y sus atributos:


 Clientes: Tiempo de llegada, demora en la cola
 Servidores: Ocupados, Libres, Tiempo de servicio

C. Eventos, actividades y procesos:


Eventos:

 Llegada de un cliente
 Salida del Cliente
Actividades:

 Clientes en espera
Procesos:

 Llegada de un cliente hasta que lo atienda un servidor

D. Contadores y/o acumuladores:


 Total de personas que se atienden
 Total de servidores en servicio
 Tiempo de espera en la fila
E. Medidas de desempeño:
 Promedio de espera en la cola
 Utilización promedio del servidor
 Numero promedio de clientes en la cola

Diagrama de flujo
Simulación
#include <stdio.h>
#include <stdbool.h>
#include <math.h>
#define MODLUS 2147483647
#define MULT1       24112
#define MULT2       26143
#define Q_LIMIT 10000
#define BUSY 1
#define IDLE 0

static long zrng[] =
{         1,
 1973272912, 281629770,  20006270,1280689831,2096730329,1933576050,
  913566091, 246780520,1363774876, 604901985,1511192140,1259851944,
  824064364, 150493284, 242708531,  75253171,1964472944,1202299975,
  233217322,1911216000, 726370533, 403498145, 993232223,1103205531,
  762430696,1922803170,1385516923,  76271663, 413682397, 726466604,
  336157058,1432650381,1120463904, 595778810, 877722890,1046574445,
   68911991,2088367019, 748545416, 622401386,2122378830, 640690903,
 1774806513,2132545692,2079249579,  78130110, 852776735,1187867272,
 1351423507,1645973084,1997049139, 922510944,2045512870, 898585771,
  243649545,1004818771, 773686062, 403188473, 372279877,1901633463,
  498067494,2087759558, 493157915, 597104727,1530940798,1814496276,
  536444882,1663153658, 855503735,  67784357,1432404475, 619691088,
  119025595, 880802310, 176192644,1116780070, 277854671,1366580350,
 1142483975,2026948561,1053920743, 786262391,1792203830,1494667770,
 1923011392,1433700034,1244184613,1147297105, 539712780,1545929719,
  190641742,1645390429, 264907697, 620389253,1502074852, 927711160,
  364849192,2049576050, 638580085, 547070247 };

int next_event_type, num_custs_delayed, num_delays_required,
    num_events, num_in_q, num_servidores,servidores[];
float area_num_in_q, area_server_status, mean_interarrival,
    mean_service, time, time_arrival[Q_LIMIT+1], time_last_event,
    time_next_event[3], total_of_delays;

FILE *infile, *outfile;
void initialize(void);
void timing(void);
void arrive(void);
void depart(void);
void report(void);
void update_time_avg_stats(void);
float expon(float mean);
float lcgrand(int stream);
void lcgrandst (long zset, int stream);
long lcgrandgt (int stream);

main(){

infile = fopen("reporte.in", "r");
outfile = fopen("reporte.out", "w");

num_events=2;

fscanf(infile, "%d %f %f %d",&num_servidores, &mean_interarrival, &mean_serv
ice,
        &num_delays_required);

fprintf(outfile, "Sistema de cola multi-servidor\n\n");
fprintf(outfile, "Numero de servidores%14d\n\n",
        num_servidores);
fprintf(outfile, "Tiempo medio de llegadas%11.3f minutes\n\n",
            mean_interarrival);
fprintf(outfile, "Tiempo medio de servicios%16.3f minutes\n\n",
            mean_service);
fprintf(outfile, "Numero de clientes%14d\n\n",
         num_delays_required);

initialize();

while (num_custs_delayed < num_delays_required){
    timing();

    update_time_avg_stats();

    switch(next_event_type){
        case 1:
            arrive();
            break;
        case 2:
            depart();
            break;
    }
}

report();

fclose(infile);
fclose(outfile);

return 0;
}

void initialize(void){
    int i;

    time=0.0;

    num_in_q=0;
    time_last_event=0.0;

    num_custs_delayed=0;
    total_of_delays=0.0;
    area_num_in_q=0.0;
    area_server_status=0.0;

    time_next_event[1] = time + expon(mean_interarrival);
    time_next_event[2] = 1.0e+30;
    for(i=1;i<=num_servidores;i++){
        servidores[num_servidores]= IDLE;
    }

void timing(void){
    int i;
    float min_time_next_event = 1.0e+29;

    next_event_type=0;
    for (i=1;i <= num_events; ++i) {
        if (time_next_event[i] < min_time_next_event) {
                min_time_next_event = time_next_event[i];
                next_event_type = i;

        }
    }
    if(next_event_type == 0){
        fprintf(outfile, "\nEvent list empty at time %f", time);
        exit(1);
}
    time = min_time_next_event;
}

void arrive(void){

    int i;
    int aux=0;
    float delay;

    time_next_event[1] = time + expon(mean_interarrival);

    for(i=1;i<= num_servidores;i++){
        if(servidores[num_servidores] == BUSY){
                    aux=aux+1;
            if(aux==num_servidores){
                ++num_in_q;
            }
        }
    }
    time_arrival[num_in_q] = time;
    if(num_in_q > Q_LIMIT){
            fprintf(outfile, "\nOverflow of the array time_arrival at");
            fprintf(outfile, " time %f", time);
            exit(2);
        }
    if(aux<num_servidores){
        delay =0.0;
        total_of_delays += delay;

        ++num_custs_delayed;
        for(i=1;i<=num_servidores;i++){
                if(servidores[num_servidores]== IDLE){
                    servidores[num_servidores]=BUSY;
                    i=num_servidores+1;
            }
        }
        time_next_event[2] = time + expon(mean_service);
        }
}
void depart(void){

    int i;
    float delay;
    if (num_in_q == 0){
        for(i=1;i<=num_servidores;i++){
            servidores[num_servidores] = IDLE;
        }
        time_next_event[2]=1.0+29;
    }else{
        --num_in_q;

        delay = time - time_arrival[1];
        total_of_delays += delay;

        ++num_custs_delayed;
        servidores[num_servidores]=IDLE;
        time_next_event[2] = time + expon(mean_service);

        for(i=1;i<= num_in_q; ++i){
            time_arrival[i]= time_arrival[i+1];

        }
    }
}

void report(void){
    float aux, aux1,aux2;
    aux=area_server_status / time;
    aux1=area_num_in_q / time;
    aux2=total_of_delays / num_custs_delayed;
    fprintf(outfile, "\n\nPromedio retraso en cola: %11.3f\n\n",
            aux2/num_servidores);
    fprintf(outfile, "Numero promedio en cola: %10.3f\n\n",
            aux1/num_servidores);
    fprintf(outfile, "Utilizacion de los servidores: %15.3f\n\n",
            aux/num_servidores);
    fprintf(outfile, "Tiempo de simulacion: %12.3f", time);
}

void update_time_avg_stats(void){
    float time_since_last_event;
    int i;
    time_since_last_event = time - time_last_event;
    time_last_event = time;

    area_num_in_q += num_in_q * time_since_last_event;
    for(i=1;i<=num_servidores;i++){
        area_server_status +=  servidores[num_servidores]* time_since_last_e
vent;
    }
}

float expon(float mean){
    return -mean*log(lcgrand(1));
}

float lcgrand(int stream){
    long zi, lowprd, hi31;

    zi     = zrng[stream];
    lowprd = (zi & 65535) * MULT1;
    hi31   = (zi >> 16) * MULT1 + (lowprd >> 16);
    zi     = ((lowprd & 65535) - MODLUS) +
             ((hi31 & 32767) << 16) + (hi31 >> 15);
    if (zi < 0) zi += MODLUS;
    lowprd = (zi & 65535) * MULT2;
    hi31   = (zi >> 16) * MULT2 + (lowprd >> 16);
    zi     = ((lowprd & 65535) - MODLUS) +
             ((hi31 & 32767) << 16) + (hi31 >> 15);
    if (zi < 0) zi += MODLUS;
    zrng[stream] = zi;
    return (zi >> 7 | 1) / 16777216.0;
}

void lcgrandst (long zset, int stream){
    zrng[stream] = zset;
}

long lcgrandgt (int stream){
    return zrng[stream];
}

Entrada:
Salida:

Análisis
 Se tiene que el uso de la bomba de gasolina es casi del 100%, en este caso se tendría que
utilizar otra bomba para evitar que esta se use tanto generando un desgaste apresurado o se
cree una cola que podría ser exageradamente larga
 La demora promedio de los carros particulares es muy superior a la de los carros policiacos,
psicológicamente esto podría causar muchas renuncias por parte de los carros particulares y
así reducir las ventas de la estación de gasolina al ver la prioridad que tienen los del otro
tipo.
 El promedio de carros en la cola es muy grande y la espera promedio de los vehículos
particulares es mucha, el uso de un solo recurso genera esto. La espera podría bajar
considerablemente si se tiene en cuenta la creación de otra bomba.