Want more features on Pastebin? Sign Up, it's FREE!
Guest

Untitled

By: a guest on Sep 3rd, 2010  |  syntax: None  |  size: 18.24 KB  |  views: 40  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <float.h>
  4. #include <math.h>
  5. #include <conio.h>
  6.  
  7. #define INFINITO 999
  8.  
  9. /* parametros a cambiar */
  10. #define num_elementos 10
  11. #define tamanio_grupos 5
  12. #define fallos_grupo 4
  13. #define num_servidores 2
  14. #define parametro_servicio 0.001
  15. #define error_relativo 0.1
  16. #define numero_minimo_iteraciones 100
  17.  
  18. /* no olvidar introducir tambien las landas */
  19.  
  20. #define num_acontecimientos num_servidores+num_elementos
  21. #define tamanio_sistema_reparacion num_elementos
  22.  
  23.  
  24. /* [1] */ void inicializacion_estructuras(int sistema[num_elementos], int sistema_reparacion[tamanio_sistema_reparacion],
  25.                                int copia_sistema_reparacion[tamanio_sistema_reparacion], float acontecimientos[num_acontecimientos],
  26.                                                            float tasas_de_fallos[num_elementos], float landas[fallos_grupo]);
  27. /* [2] */ float generar_aleatorio(char aleatorio, float tasas_de_fallos[num_elementos], int que_elemento);
  28. /* [3] */ int primer_acontecimiento(float acontecimientos[num_acontecimientos], int funcionamiento_sistema);
  29. /* [4] */ int colocar_componente(int sistema_reparacion[tamanio_sistema_reparacion], int que_elemento);
  30. /* [5] */ void reducir_acontecimientos(float acontecimientos[num_acontecimientos], float cantidad_a_reducir, int funcionamiento_sistema);
  31. /* [6] */ int comprobar_funcionamiento(int sistema[num_elementos], int posicion);
  32. /* [7] */ int reordenar_sistema_reparacion(int sistema_reparacion[tamanio_sistema_reparacion], int siguiente_acontecimiento);
  33. /* [8] */ void actualiza_landas(float tasas_de_fallos[num_elementos], int sistema[num_elementos], float landas[fallos_grupo]);
  34. /* [9] */ void colocar_cola_prioridades(int sistema_reparacion[tamanio_sistema_reparacion], int copia_sistema_reparacion[tamanio_sistema_reparacion],
  35.                               float tasas_de_fallos[num_elementos], float landas[fallos_grupo]);
  36. /* [10] */void calcula_intervalo_error(float valor, int numero_muestras, float ic_izquierdo, float ic_derecho, float error_relativo);
  37.                                                          
  38.  
  39.  
  40. main () /* PROGRAMA PRINCIPAL */
  41. {
  42.   /* a introducir antes de la simulacion */
  43.   float landas[4] = {0.01,0.012,0.017,0.021};
  44.  
  45.   /* variables */
  46.   int siguiente_acontecimiento, i, j, componentes_reparados, funcionamiento_sistema;
  47.   float reloj, cantidad_a_reducir;
  48.   int que_elemento, que_acontecimiento, posicion;
  49.  
  50.   /* variables para la solucion */
  51.   float indisponibilidad, infiabilidad, error_infiabilidad, error_indisponibilidad;
  52.   float icizq_infiabilidad, icde_infiabilidad, icizq_indisponibilidad, icde_indisponibilidad;
  53.   int numero_muestras, contador_infiabilidad, contador_indisponibilidad, detectado_fallo;
  54.  
  55.   srand(time(NULL)); /* cambia aleatorio */
  56.  
  57.   /* creacion de estructuras*/
  58.   int sistema[num_elementos];
  59.   int sistema_reparacion[tamanio_sistema_reparacion];
  60.   int copia_sistema_reparacion[tamanio_sistema_reparacion];
  61.   float acontecimientos[num_acontecimientos];
  62.   float tasas_de_fallos[num_elementos];
  63.  
  64.   error_infiabilidad = 100;
  65.   numero_muestras = 0; contador_infiabilidad = 0; contador_indisponibilidad = 0;
  66.  
  67.   while (error_infiabilidad > error_relativo) /* Codicion de parada del error */
  68.   {
  69.   numero_muestras++;
  70.   detectado_fallo = 0;
  71.   /* inicializacion de estructuras */
  72.   inicializacion_estructuras(sistema, sistema_reparacion, copia_sistema_reparacion, acontecimientos, tasas_de_fallos, landas);
  73.  
  74.   /* ========================= */
  75.   /* COMIENZO DE LA SIMULACION */
  76.   /* ========================= */
  77.   reloj = 0;
  78.   funcionamiento_sistema = 1; /* (1) El sistema funciona  (0) El sistema no funciona */
  79.   componentes_reparados = 0; /* almacena el numero de componentes que han sido reparados */
  80.  
  81.   while (reloj<100) /* Condicion de parada de cada muestra */
  82.   {  
  83.       siguiente_acontecimiento=primer_acontecimiento(acontecimientos, funcionamiento_sistema); /* vemos que acontecimiento es el siguiente */
  84.  
  85.           if (siguiente_acontecimiento < num_servidores) /* se produce salida de un servidor */
  86.           {      
  87.                   que_elemento = sistema_reparacion[siguiente_acontecimiento];
  88.                   sistema[que_elemento-1] = 1;  /* se pone el componente a funcionando */
  89.                   reloj = reloj + acontecimientos[siguiente_acontecimiento];  /* actualizamos el reloj */
  90.                           actualiza_landas(tasas_de_fallos, sistema, landas);                    
  91.                           cantidad_a_reducir = acontecimientos[siguiente_acontecimiento]; /* almacenamos la cantidad que debemos restar a todos los acontecimientos */
  92.                   componentes_reparados++; /* se incrementan los componentes reparados */
  93.                   reducir_acontecimientos(acontecimientos, cantidad_a_reducir, funcionamiento_sistema); /* se decrementan los acontecimientos */
  94.                   acontecimientos[siguiente_acontecimiento] = INFINITO; /* se pone el servidor de momento a INFINITO */
  95.                       acontecimientos[num_servidores + que_elemento - 1] = generar_aleatorio('e', tasas_de_fallos, que_elemento); /* el componente arreglado empieza a estropearse, tiempo */            
  96.                   if (reordenar_sistema_reparacion(sistema_reparacion, siguiente_acontecimiento) == 1) /* si ha sido ocupado el servidor por otro mcomponente */
  97.                      {acontecimientos[siguiente_acontecimiento] = generar_aleatorio('s', tasas_de_fallos, que_elemento);} /* generamos el tiempo de servicio */
  98.                   if ((funcionamiento_sistema == 0) && (comprobar_funcionamiento(sistema, (que_elemento-1)) == 1)) /* si no funciona y con esa llegada se arregla el sistema */
  99.                      {funcionamiento_sistema = 1;} /* se pone a que funciona */  
  100.           }
  101.          else /* se produce una llegada al sistema de reparacion */
  102.           {      
  103.                           que_elemento = siguiente_acontecimiento-(num_servidores-1);
  104.               sistema[que_elemento-1] = 0;  /* se pone el componente a estropeado, -1 pues empieza en 0 */       
  105.                           actualiza_landas(tasas_de_fallos, sistema, landas); /* a fallado un elemento, cambiamos las tasas de fallos */
  106.                       reloj = reloj + acontecimientos[siguiente_acontecimiento];  /* actualizamos el reloj */
  107.                           cantidad_a_reducir = acontecimientos[siguiente_acontecimiento];
  108.                   reducir_acontecimientos(acontecimientos, cantidad_a_reducir, funcionamiento_sistema); /* reducimos los tiempos */
  109.                   acontecimientos[siguiente_acontecimiento] = INFINITO; /* no puede volver a llegar, esta reparandose */
  110.                   if (comprobar_funcionamiento(sistema, (que_elemento-1)) == 0) /* si con esa llegada se estropea el sistema */
  111.                      {funcionamiento_sistema = 0;
  112.                                   detectado_fallo = 1; /* usado para la infiabilidad */
  113.                                  }
  114.                   posicion = colocar_componente(sistema_reparacion, que_elemento); /* apilarle en el sistema de reparacion */
  115.                   if (posicion < num_servidores) /* se ha colocado en un servidor */
  116.                      {acontecimientos[posicion] = generar_aleatorio('s', tasas_de_fallos, que_elemento);}
  117.                           if (!(sistema_reparacion[num_servidores+1] == 0)) /* si alemnos hay 2 componentesen la cola es necesario colocar por prioridades */
  118.                              {colocar_cola_prioridades(sistema_reparacion, copia_sistema_reparacion, tasas_de_fallos, landas);}
  119.           }
  120.    } /* fin de la muestra */
  121.    
  122.    if (funcionamiento_sistema == 0){contador_indisponibilidad++;} /* en el momento que sale, t=100 */
  123.    if (detectado_fallo == 1){contador_infiabilidad++;} /* si ha fallado en el transcurso de los 100, infiabilidad */
  124.    infiabilidad = contador_infiabilidad / numero_muestras;
  125.    indisponibilidad = contador_indisponibilidad / numero_muestras;
  126.    
  127.    if (numero_muestras > numero_minimo_iteraciones) /* si lleva ya suficiente iteraciones */
  128.    {
  129.        calcula_intervalo_error(infiabilidad, numero_muestras, icizq_infiabilidad, icde_infiabilidad, error_infiabilidad);
  130.            calcula_intervalo_error(indisponibilidad, numero_muestras, icizq_indisponibilidad, icde_indisponibilidad, error_indisponibilidad);
  131.    }
  132.  } /* fin error suficientemente pequeño */
  133.  
  134.  
  135.  /*    RESULTADOS    */
  136. printf("== Infiabilidad == \n");
  137. printf("El valor es: ");printf("%f\n",infiabilidad);
  138. printf("El IC de la infiabilidad es: (");printf("%f",icizq_infiabilidad);printf(" , ");printf("%f\n",icde_infiabilidad);
  139. printf("El error de la infiabilidad es: ");printf("%f\n",error_infiabilidad);
  140. printf("\n");
  141. printf("== Indisponibilidad == \n");
  142. printf("El valor es: ");printf("%f\n",indisponibilidad);
  143. printf("El IC de la indisponibilidad es: (\n");printf("%f",icizq_indisponibilidad);printf(" , ");printf("%f\n",icde_indisponibilidad);
  144. printf("El error de la indisponibilidad es: \n");printf("%f\n",error_indisponibilidad);
  145.  
  146. return(0);
  147. }
  148.  
  149. /* =========================================================== */
  150. /* ======================= FUNCIONES ========================= */
  151. /* =========================================================== */  
  152.  
  153. /* ======================== [ 1 ] ============================= */
  154.  
  155. void inicializacion_estructuras(int sistema[num_elementos], int sistema_reparacion[tamanio_sistema_reparacion],
  156.                                 int copia_sistema_reparacion[tamanio_sistema_reparacion], float acontecimientos[num_acontecimientos],
  157.                                                                 float tasas_de_fallos[num_elementos], float landas[fallos_grupo])                  
  158. {/* funcion que inicializa las principales estructuras del simulador */
  159.    int i, j;
  160.    /* inicializamos a 1 el sistema */
  161.    for (i=0;i<num_elementos;i++){sistema[i] = 1;}
  162.    
  163.    /* inicializamos a 0 el sistema de reparacion */
  164.    for (i=0;i<tamanio_sistema_reparacion;i++)
  165.    {
  166.       sistema_reparacion[i] = 0;
  167.           copia_sistema_reparacion[i] = 0;
  168.    }
  169.    
  170.    /* inicializamos los acontecimientos de servidores */
  171.    for (i=0;i<num_servidores;i++)
  172.    {/* los servidores estan vacios */
  173.      acontecimientos[i] = INFINITO;
  174.    }
  175.    
  176.    /* inicializamos las tasas de fallos de los componentes */
  177.    for (i=0;i<num_elementos;i++)
  178.    {
  179.       tasas_de_fallos[i] = landas[0];
  180.    }
  181.    
  182.    /* inicializamos los acontecimientos de los componentes */
  183.     for (i=num_servidores;i<num_acontecimientos;i++)
  184.    {/* los componentes estan funcionando */
  185.      acontecimientos[i] = generar_aleatorio('e', tasas_de_fallos, 1);
  186.    }
  187.  }
  188.  
  189.  
  190. /* ======================== [ 2 ] ============================= */  
  191.  
  192. float generar_aleatorio(char aleatorio, float tasas_de_fallos[num_elementos], int que_elemento)
  193. { /* funcion que dvuelve un valor aleatorio e llegada s servicio */
  194.    float valor, numero_aleatorio, parametro;
  195.    if (aleatorio == 'e') /* es una llegada o entrada */
  196.    {
  197.        parametro = tasas_de_fallos[que_elemento-1];
  198.        numero_aleatorio = (rand()%100)/100.0; /* numero aleatorio real entre 0 y 1 */
  199.            numero_aleatorio = numero_aleatorio + 0.0001;
  200.        valor = (-1/parametro)*log(numero_aleatorio);
  201.    }
  202.    else /* es un tiempo de servicio */
  203.    {
  204.        numero_aleatorio = (rand()%100)/100.0; /* numero aleatorio real entre 0 y 1 */
  205.            numero_aleatorio = numero_aleatorio + 0.0001;
  206.        valor = (-1/parametro_servicio)*log(numero_aleatorio);  
  207.    }
  208.    return(valor);
  209. }
  210.  
  211.  
  212. /* ======================== [ 3 ] ============================= */  
  213.  
  214. int primer_acontecimiento(float acontecimientos[num_acontecimientos], int funcionamiento_sistema)
  215.  {  /* funcion que determina que valor es el mas pequeño de los acontecimientos */
  216.     float menor_tiempo;
  217.         int minima_posicion, i;
  218.     menor_tiempo = acontecimientos[0];
  219.         minima_posicion = 0;
  220.         for (i=1;i<num_acontecimientos;i++) /* se recorre todos los acontecimiento */
  221.         {  
  222.            if ((funcionamiento_sistema == 1) || (i<num_servidores)) /* si funciona o no funciona pero es un servidor */
  223.            {
  224.               if (acontecimientos[i] < menor_tiempo) /* comparas */
  225.               {  /* actualizas */
  226.                  minima_posicion = i;
  227.                      menor_tiempo = acontecimientos[i];
  228.               }
  229.            }
  230.         }
  231.         return(minima_posicion);
  232.  }
  233.  
  234.  
  235.  
  236. /* ======================== [ 4 ] ============================= */  
  237.  
  238. int colocar_componente(int sistema_reparacion[tamanio_sistema_reparacion], int que_elemento)
  239. { /* funcion que coloca al componente llegado en el sistema de reparacion */ /*hay sitio forzoso, sino no habria llegado */
  240.    int colocado, i;
  241.    colocado = 0;i = 0;
  242.    while(colocado == 0) /* mientras que no se coloque el componente */
  243.    {
  244.       if (sistema_reparacion[i] == 0) /* si esta vacía la posicion */
  245.             {  sistema_reparacion[i] = que_elemento;
  246.                    colocado = 1;
  247.                 }
  248.           else {i++;}
  249.    }
  250.    return(i); /* devuelve la posicion donde ha sido colocado */
  251. }
  252.  
  253.  
  254.  
  255. /* ======================== [ 5 ] ============================= */  
  256.  
  257. void reducir_acontecimientos(float acontecimientos[num_acontecimientos],float cantidad_a_reducir, int funcionamiento_sistema)
  258. { /* al ocurrir un acontecimiento, el resto debe disminuir en tiempo */
  259.   int i;
  260.   if (funcionamiento_sistema == 1) /* si el sistema funciona se reducen todos */
  261.    {
  262.       for (i=0;i<num_acontecimientos;i++)
  263.           { /* reducimos todos menos los que son infinito */
  264.             if (!(acontecimientos[i] == INFINITO)){acontecimientos[i] = acontecimientos[i] - cantidad_a_reducir;}
  265.       }
  266.    }
  267.   else{ /* si el sistema no funciona no se reducen los tiempos de llegadas, solo los tiempos de servicio */
  268.       for (i=0;i<num_servidores;i++)
  269.           {
  270.             if (!(acontecimientos[i] == INFINITO)){acontecimientos[i] = acontecimientos[i] - cantidad_a_reducir;}
  271.       }        
  272.   }
  273. }
  274.  
  275.  
  276.  
  277. /* ======================== [ 6 ] ============================= */  
  278.  
  279. int comprobar_funcionamiento(int sistema[num_elementos], int posicion)
  280. { /* funcion que comprueba si el sistema se ha estropeado */
  281.   int fallos_encontrados, i, j, funcionamiento_sistema;
  282.   funcionamiento_sistema = 1;
  283.   for (i=0;i<tamanio_grupos;i++) /* busca en los x grupos que rodean al elemento fallado */
  284.   {  
  285.       fallos_encontrados = 0; /* funciona si no se demuestra lo contrario */
  286.       for (j=(posicion-i);j<((posicion-i)+tamanio_grupos);j++) /* dentro de un grupo comprueba todas las posiciones */
  287.           {  
  288.               if ((j<num_elementos) && (j>-1)) /* primero mira si esa posición no se sale de los límites normales */
  289.                    {
  290.                        if (sistema[j] == 0){ fallos_encontrados++;} /* se ve si ese componente esta estropeado */
  291.                            if (fallos_encontrados == fallos_grupo) {funcionamiento_sistema = 0;} /* se ha detectado el error */
  292.                    }
  293.           }
  294.  
  295.   }
  296.   return(funcionamiento_sistema);
  297. }
  298.  
  299.  
  300. /* ======================== [ 7 ] ============================= */  
  301.  
  302. int reordenar_sistema_reparacion(int sistema_reparacion[tamanio_sistema_reparacion], int siguiente_acontecimiento)
  303.  { /* devuelve 1 si se ha rellenado el servidor, 0 si no había componentes a colocar en el servidor */
  304.    /* si hay gente en cola es porque todos los demas estan ocupados */
  305.    int reocupado, i;
  306.    reocupado = 0;
  307.                  
  308.    if (!(sistema_reparacion[num_servidores] == 0)) /* si la primera posicion de la cola esta llena */
  309.    {                                                 /* si no hay nadie esperando no hay que recolocar */
  310.       reocupado = 1;
  311.       sistema_reparacion[siguiente_acontecimiento] = sistema_reparacion[num_servidores]; /* se rellena el servidor */
  312.           i = num_servidores; /* vamos a ir adelantando el resto de posiciones */
  313.          
  314.           while (!(sistema_reparacion[i] == 0) && (i < tamanio_sistema_reparacion))
  315.           {
  316.         sistema_reparacion[i] = sistema_reparacion[i+1]; /* el de antes igual al de despues */   
  317.         i++;           
  318.           }
  319.         }
  320.     else /* si no hay nadie en la cola se debe poner a 0 el servidor */
  321.         {    
  322.              sistema_reparacion[siguiente_acontecimiento] = 0; /* se rellena el servidor */
  323.     }
  324.    return(reocupado);
  325.  }
  326.  
  327.  
  328. /* ======================== [8] ============================= */
  329.  
  330. void actualiza_landas(float tasas_de_fallos[num_elementos], int sistema[num_elementos], float landas[fallos_grupo])
  331. {
  332.    int contador,i;
  333.    contador = 0;
  334.    for (i=0;i<num_elementos;i++)
  335.    { /* mira todos los elementos */
  336.       if (sistema[i] == 0){contador++;} /* si el elemento esta fallado incrementamos contador */
  337.           else{ /* si funciona hay que ponerle landa */
  338.                 if (contador < fallos_grupo)
  339.                         {  
  340.                            tasas_de_fallos[i] = landas[contador];
  341.                            contador = 0;
  342.                         }
  343.                         else{tasas_de_fallos[i] = landas[fallos_grupo-1];}
  344.                    }
  345.     }
  346. }
  347.  
  348.  
  349. /* ======================== [9] ============================= */
  350.  
  351. void colocar_cola_prioridades(int sistema_reparacion[tamanio_sistema_reparacion], int copia_sistema_reparacion[tamanio_sistema_reparacion],
  352.            
  353.                    float tasas_de_fallos[num_elementos], float landas[fallos_grupo])
  354. {
  355.     int i, j, elemento, posicion_copia;
  356.     posicion_copia = num_servidores; /* para saber por donde va la copia */
  357.        
  358.     for (i=0;i<fallos_grupo-1;i++) /* se recorre k-1 veces el sistema de reparacion */
  359.         {
  360.            for(j=num_servidores;j<tamanio_sistema_reparacion;j++) /* en cada pasada busca un landa y lo va metiendo a la copia */
  361.            {
  362.                 elemento = sistema_reparacion[j]; /* si el elemento corrspone al landa que estamos recogiendo */
  363.                 if (!(elemento == 0) && (tasas_de_fallos[elemento-1] > landas[fallos_grupo-i-2]))
  364.                 {    /* lo metemos en la copia */
  365.                      copia_sistema_reparacion[posicion_copia] = sistema_reparacion[j];
  366.                          posicion_copia++;
  367.                          sistema_reparacion[j] = 0;
  368.                 }
  369.         }
  370.         }
  371.  
  372.         for(j=num_servidores;j<tamanio_sistema_reparacion;j++) /* en cada pasada busca un landa y lo va metiendo a la copia */
  373.         {
  374.            elemento = sistema_reparacion[j]; /* especial para el landa menor */
  375.            if (!(elemento == 0) && (tasas_de_fallos[elemento-1] > 0))
  376.               {    /* lo metemos en la copia */
  377.                      copia_sistema_reparacion[posicion_copia] = sistema_reparacion[j];
  378.                          posicion_copia++;
  379.                          sistema_reparacion[j] = 0;
  380.               }
  381.     }  
  382.        
  383.         /* hacemos el volcado final */
  384.         for(i=num_servidores;i<tamanio_sistema_reparacion;i++){sistema_reparacion[i] = copia_sistema_reparacion[i];}
  385. }
  386.  
  387.  
  388. /* ======================== [10] ============================= */
  389. void calcula_intervalo_error(float valor, int numero_muestras, float ic_izquierdo, float ic_derecho, float error_relativo)
  390. { /* aplica las fórmulas del intervalo de confianza y error para la proporcion */
  391.   float general, superior, inferior;
  392.  
  393.   inferior = sqrt numero_muestras;   /* parte inferior de la ecuacion */
  394.   superior = sqrt (valor * (1 - valor));  /* parte superior de la ecuacion */
  395.   general = (1.96 * superior) / inferior; /* resultado de la division */
  396.  
  397.   error_relativo = general / valor;
  398.   ic_izquierdo = valor - general;
  399.   ic_derecho = valor + general;  
  400. }
clone this paste RAW Paste Data