¿Vacunarse o no? un proyecto sobre la observación de la inmunidad de la manada mediante la simulación de enfermedades: 15 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Descripción general del proyecto:

Nuestro proyecto explora la inmunidad colectiva y espera alentar a las personas a vacunarse para disminuir las tasas de infección en nuestras comunidades. Nuestro programa simula cómo una enfermedad infecta a una población con diferentes porcentajes de tasas vacunados y no vacunados. Muestra la inmunidad colectiva al mostrar cómo un mayor número de la población vacunada puede disminuir el número de personas afectadas.

Modelamos esto en Matlab usando conceptos de teoría de grafos. La teoría de grafos es una forma matemática de representar las relaciones entre objetos. En la teoría de grafos, los gráficos tienen vértices (o nodos) conectados por aristas (o líneas). Para nuestro proyecto, los nodos son los individuos afectados y los bordes son sus conexiones. Por ejemplo, si dos nodos están conectados con un borde, significa que son "amigos" o tienen alguna forma de contacto entre sí. Este contacto es una forma de propagación de la enfermedad. Es por eso que usamos la teoría de grafos para modelar nuestro concepto porque queríamos ver cómo se propaga la enfermedad entre los individuos que están conectados en una población.

Nuestro proyecto también involucra el Método Monte Carlo. El método de Monte Carlo son algoritmos que crean un muestreo aleatorio repetido para recibir resultados numéricos. En nuestro proyecto, usamos este método para ejecutar nuestra simulación varias veces cambiando el porcentaje inicial de personas no vacunadas para ver la tasa a la que las personas se infectan.

¡Todo el código del proyecto está vinculado en la parte inferior!

Crédito para PC:

Enlace de Matlab a la teoría de grafos:

Paso 1: crear una matriz de adyacencia

Crea una nueva secuencia de comandos. Vamos a llamar al nuestro 'InfectionSim.m'.

Vamos a crear una variable 'NUMOFPEOPLE'. Puede asignarlo a cualquier valor entero. Esto representará el número de personas de su población.

A partir de ahora asumiremos que

NUMOF PERSONAS = 20;

Primero, comience usando las funciones de la teoría de grafos de Matlab para un grafo no dirigido.

Si está interesado en aprender más, aquí hay un enlace para que lea más en profundidad al respecto.

www.mathworks.com/help/matlab/math/directed-and-undirected-graphs.html

Creó una matriz de adyacencia.

adjMatrix = ceros (NUMOFPEOPLE);

Esto creará una matriz cuadrada de ceros. Cada fila de la matriz es una persona. Cada columna de la matriz es una persona o amigo que la persona conoce a lo largo del día.

Consulte la Figura 100 (arriba) para ayudar a visualizar cómo se ve adjMatrix para 20 personas.

** A partir de este punto asumiremos que NUMOFPEOPLE es igual a 20. **

Puede intentar trazar esta matriz de adyacencia. Aquí hay un poco más de información sobre cómo trazar este tipo de matrices.

Nota: Cómo funciona la matriz de adyacencia.

Ex:

% haciendo la matriz adyacente

a = [0, 1, 0, 0, 0; 1, 0, 1, 1, 1; 0, 1, 0, 0, 0; 0, 1, 0, 0, 0; 0, 1, 0, 0, 0]% trazando g = gráfico (a); % usando la función gráfica (teoría de grafos) figura (1); h = gráfico (g);

Consulte la Figura 1 (arriba) para ver cómo agregar bordes en la matriz de adyacencia, usando el código en "Nota".

Paso 2: crear relaciones

Ahora que se crean las personas (vértices o nodos), necesitamos crear una red de relaciones (líneas o bordes del gráfico). Esto simulará cómo las personas interactúan y se encuentran con otras personas a lo largo del día.

Esto se puede hacer de muchas formas. Una forma de completar esta tarea es asignar primero un número aleatorio a cada persona para determinar con cuántas personas interactuará cada persona en un día.

numOfFriendsMatrix = randi ([LessFriendsPersonCanHave, mostFriendsPersonCanHave], 1, NUMOFPEOPLE);

Esto hace una matriz de 1 por 20 de números enteros aleatorios que representan el número de interacciones que cada persona tiene al día. Las columnas de esta matriz serían el número correspondiente a cada persona. Por ejemplo, si asignamos menosFriendsPersonCanHave = 2 y mostFriendsPersonCanHave = 5, obtendríamos valores aleatorios entre 2 y 5.

¿Tiene problemas con randi ()? En terminal, escriba

ayuda a randi

A continuación, hacemos una matriz aleatoria (llamada "allFriendsmatrix") de cómo cada persona de la población está conectada / interactúa dentro de la población.

tempMatrix = ;

cuenta = 0; allFriendsMatrix = ; para k = 1: NUMOFPEOPLE while length (tempMatrix) ~ = numOfFriendsMatrix (k) count = count +1; temp = randi ([1, NUMOFPEOPLE]); tempMatrix (recuento) = temp; end clear each while length (tempMatrix) ~ = 9 tempMatrix = [tempMatrix, NaN]; end allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; cuenta = 0; fin

Explicación detallada del código:

Primero creamos una matriz temporal vacía para contener la lista de amigos / interacción de cada persona. También inicializamos el recuento, que solo realiza un seguimiento de dónde colocar la nueva conexión aleatoria en tempMatrix. Los ciclos for se ejecutan 20 veces para que esto suceda para cada persona individual de la población. El primer ciclo while se ejecuta hasta que la matriz temporal de cada persona tiene la misma longitud que el número de interacciones asignado al azar. En este ciclo, se genera un número aleatorio correspondiente a la persona en la población y se coloca en tempMatrix. Debido a que las longitudes de cada uno de los tempMatrixes son diferentes, necesitábamos crear algunos valores NaN para poder concatenar todos estos tempMaticies en una sola matriz ('allFriendsMatrix'). El segundo ciclo while resuelve este problema agregando NaN en cada tempMatrix. El ciclo while se configuró para ejecutarse 9 veces porque es un número mayor que 5, que es el límite superior de amigos que se le puede asignar a una persona. El valor '9' es variable y puede / debe cambiarse cuando 'mostFriendsPersonCanHave' es mayor que 9. Las últimas tres líneas de código (excluyendo el final) agregan tempMatrix en la siguiente fila de 'allFriendsMatrix'. Luego borra tempMatrix y cuenta para la siguiente persona.

Producción

Así es como debería verse la salida para la primera ejecución a través del ciclo for (antes de las últimas tres líneas).

tempMatrix = 16 8 17 16 13 NaN NaN NaN NaN

allFriendsMatrix =

16 8 17 16 13 NaN NaN NaN NaN 8 8 2 7 11 NaN NaN NaN NaN 10 13 NaN NaN NaN NaN NaN NaN NaN 11 17 2 NaN NaN NaN NaN NaN NaN 10 12 NaN NaN NaN NaN NaN NaN NaN 4 13 2 12 NaN NaN NaN NaN NaN 17 10 9 3 1 NaN NaN NaN NaN 16 16 6 NaN NaN NaN NaN NaN NaN 3 8 17 17 14 NaN NaN NaN NaN 20 19 3 NaN NaN NaN NaN NaN NaN 13 10 NaN NaN NaN NaN NaN NaN NaN NaN 2 18 10 16 NaN NaN NaN NaN NaN 2 6 14 3 13 NaN NaN NaN NaN 8 16 14 8 NaN NaN NaN NaN NaN 7 7 NaN NaN NaN NaN NaN NaN NaN 19 10 9 NaN NaN NaN NaN NaN NaN 10 19 NaN NaN NaN NaN NaN NaN NaN 5 18 NaN NaN NaN NaN NaN NaN NaN 1 7 NaN NaN NaN NaN NaN NaN NaN 16 7 13 10 1 NaN NaN NaN NaN

A continuación, agregue estas relaciones a adjMatrix.

para cada fila = 1: NUMOFPEOPLE

for eachCol = 1: 9 if isnan (everyFriendsMatrix (eachRow, eachCol)) == 0 adjMatrix (eachRow, allFriendsMatrix (eachRow, eachCol)) = 1; adjMatrix (allFriendsMatrix (eachRow, eachCol), eachRow) = 1; fin fin fin

Explicación del código

Este bucle for doble pasa por cada fila y columna de 'allFriendsMatrix'. La instrucción if se ejecutará para todos los valores que no sean 'NaN'. Básicamente creará los bordes o líneas del gráfico. Entonces, la primera línea que esto hará es la persona 1 a la persona 16 y la persona 16 a la persona 1. ¡Debido a que no está dirigida, se debe cambiar 1 para ambas! No podemos simplemente tener el borde 1 a 16 y no 16 a 1. Deben ser simétricos para que se ejecute correctamente en Matlab.

En nuestra simulación, establecimos que las personas no pueden interactuar consigo mismas. Cuando aleatorizamos los valores, existe la posibilidad de que nuestra matriz adyacente tenga estos errores.

Arreglemos esto con el siguiente código:

para cada uno = 1: NUMOFPEOPLE

adjMatrix (cada uno, cada uno) = 0; fin

Explicación del código

Este bucle for asegura que la persona 1 no esté conectada a la persona 1, la persona 2 no esté conectada a la persona 2, etc.haciendo que todas sean 0. Como puede ver a continuación en la sección de salida, tenemos la diagonal del cuadrado La matriz de arriba a la izquierda a abajo a la derecha son todos ceros.

Producción

Esta es la matriz adjunta final para esta simulación actual. Esto representa todas las líneas del gráfico (Figura 2).

adjMatrix =

0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 1 1 0 1 1 0 0 0 1 0 1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0 1 0 1 0 1 1 1 1 0 0 0 1 0 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0 1 1 0 0 0 0 0 1 0 1 1 0 0 0 0 0 1 0 1 0 1 0 0 0 1 1 0 0 0 1 1 0 1 1 0 1 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 1 1 0 0 0 1 0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 1 0 1 0 0 0 0 1 1 1 0 0 1 0 0 1 0 1 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 1 0 0 0 0

Consulte la Figura 2 para ver el gráfico de 'adjMatrix'.

Paso 3: agregar estadísticas de enfermedades

Ahora que su programa puede crear un gráfico con un conjunto de personas al azar y crear relaciones aleatorias, debemos ingresar la información o las estadísticas de la enfermedad para ver cómo estas interacciones dentro de una población pueden aumentar o disminuir la infección.

Crea estas variables:

unvacc% tipo: doble; porcentaje de probabilidad de que las personas no vacunadas no contraigan la enfermedad

tipo de% de vacuna: doble; porcentaje de probabilidad de que las personas vacunadas no contraigan la enfermedad unvacc_perc% type: double; porcentaje de población no vacunada init_infect% type: int; porcentaje de población vacunada

A continuación, necesitamos hacer algunos cálculos.

Vamos a hacer una 'InfecciónMat' que es una matriz de 3 * NUMOFPEOPLE.

vacuna_perc = 1-unvacc_perc;

InfecciónMat = nan (3, NUMOFPEOPLE); número = ronda (vacuna_perc * NUMOF PERSONAS); InfecciónMat (1, 1: número) = vacuna; InfecciónMat (1, número + 1: final) = unvacc; InfecciónMat (2, 1: final) = 0; InfecciónMat (2, 1: init_infect) = 1;

Explicación del código

línea 1: Porcentaje de población no vacunada calculado

línea 2: cree una matriz de número de personas 3 * N

línea 3: averigüe el número de personas vacunadas del porcentaje vacunado

línea 4: para las personas vacunadas, darles una inmunidad asociada con la vacuna. Este valor se asigna en función de la investigación sobre la enfermedad.

línea 5: para el resto de la población (personas no vacunadas), darles el porcentaje de inmunidad. Este valor se asigna en función de la investigación sobre la enfermedad.

línea 6: establezca inicialmente a todas las personas como no infectadas.

línea 7: para el número de personas inicialmente infectadas, complete las primeras columnas en consecuencia.

Ahora que hemos establecido todos los parámetros para la simulación de la enfermedad, vamos a aleatorizar la posibilidad de que la persona (tanto vacunada como no vacunada) se infecte. Esto se hace en el siguiente paso asignando valores aleatorios entre 0 y 1 a cada persona en la tercera fila de esta 'InfecciónMat'.

Paso 4: Aleatorice la posibilidad de que una persona vacunada y no vacunada se infecte

A continuación, asigne a cada persona un número aleatorio, que se utilizará más adelante para determinar si la persona se infecta o no.

para w = 1: longitud (InfecciónMat)

InfecciónMat (3, w) = rand; fin

Explicación del código

Este bucle for se ocupa de la tercera fila del 'InfectionMat' creado en el último paso. 'rand' asigna un valor entre 0 y 1 a cada índice de la fila 3.

Producción

¡InfectionMat ya está completo! Esto fue con una población con 100% de vacunación y 1 persona inicialmente infectada.

InfecciónMat =

Columnas 1 a 12 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 1.0000 0 0 0 0 0 0 0 0 0 0 0.0869 0.5489 0.3177 0.9927 0.7236 0.5721 0.7172 0.9766 0.4270 0.9130 0.8973 0.8352 Columnas 13 a 20 0.7500 0.7500 0.7500 0.7500 0.7500 0.7500 0,7500 0,7500 0 0 0 0 0 0 0 0 0,0480 0,3593 0,2958 0,6291 0,1362 0,3740 0,8648 0,2503

fila 1: porcentaje de probabilidad de NO contraer la enfermedad

fila 2: Infectado o no infectado (valor booleano)

fila 3: Número utilizado para verificar si una persona que no está infectada se infecta si se encuentra con una persona infectada. Si una persona no infectada se encuentra con una persona infectada, este número es mayor que el número en la fila 1 (para la misma columna), entonces están infectados. Codificaremos esta funcionalidad en el paso 7.

Paso 5: crear matrices de personas no vacunadas e infectadas a partir de la información inicial

Cree 2 matrices llamadas "matrixUnvacc" y "matrixInfected" que almacene a todas las personas infectadas de InfectionMat. Esto se utilizará para que podamos codificar por colores el gráfico de los que están infectados, no vacunados o vacunados, lo que ayudará a visualizar el impacto de los individuos no vacunados frente a los vacunados.

limpiar cada uno

matrixInfected = ; matrixUnvacc = ; para h = 1: longitud (InfecciónMat) si InfecciónMat (1, h) == unvacc matrixUnvacc = [matrixUnvacc, h]; end end for person = 1: NUMOFPEOPLE if InfectionMat (2, person) == 1 matrixInfected = [matrixInfected, person]; fin fin

Explicación del código

Cree dos matrices vacías para almacenar el número de personas no vacunadas e infectadas, respectivamente. Ambos bucles for se ejecutan 20 veces y si se cumple la instrucción if, el número se agrega a la matriz correcta.

Producción

matrixUnvacc =

matrixInfected =

[1]

Paso 6: Trace el gráfico inicial

A continuación, trazaremos la matriz de adyacencia.

g = gráfico (adjMatrix);

figura (1) p = plot (g, 'NodeColor', 'b', 'MarkerSize', 7); resaltar (p, matrixUnvacc, 'NodeColor', 'g') resaltar (p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc * 100; title (['Porcentaje de personas no vacunadas:', num2str (title_unvacc), '%']); pausa (velocidad)

Explicación del código

La teoría de grafos en Matlab tiene funciones integradas. Cuando usamos la función graph (), podemos traducir el 'adjMatrix' en un gráfico real no dirigido. Luego tenemos que crear un gráfico usando la función plot () para ver realmente cómo se ve. Establecemos esta gráfica () en una variable para que podamos manipular y cambiar los colores de la gráfica más fácilmente a lo largo de la simulación. Todas las personas (o nodos) se establecen inicialmente en el color 'azul'. A continuación, todas las personas no vacunadas se establecen en el color "verde". A continuación, se pone a las personas infectadas en el color "rojo". El título se establece de acuerdo con cierto valor porcentual de personas no vacunadas que se someten a la prueba. La función pause () detiene temporalmente la ejecución de MatLab. Pasamos por la velocidad variable que se esparce y que se calcula en segundos.

Consulte la imagen (arriba) para ver un gráfico codificado por colores aleatorios.

Obtenga más información sobre la función resaltar () en MatLab.

Paso 7: simule la progresión de la infección

A continuación, debemos averiguar quién se infecta después de las interacciones (registradas en adjMatrix) y actualizar el gráfico cuando alguien se infecta.

Utilice adjMatrix para determinar qué personas están infectadas después de sus interacciones con las personas en un día.

para cada fila = 1: longitud (adjMatrix)

if InfectionMat (2, eachRow) == 1 for eachCol = 1: length (adjMatrix) if adjMatrix (eachRow, eachCol) == 1% eachRow = la persona% cadaCol = su amigo% el amigo de cada persona y ver si están infectados. si InfecciónMat (3, cadaCol)> InfecciónMat (1, cadaCol) InfecciónMat (2, cadaCol) = 1; resaltar (p, eachCol, 'NodeColor', 'r') pausa (velocidad) final final final final final

El bucle for recorre a cada persona. Verifica que si la persona está infectada, verificará a cada una de las personas / amigos con los que interactuó y verificará si el nivel de inmunidad del amigo era mayor que la fuerza de la enfermedad. Aquí es donde entra en juego el 'InfectionMat' que creamos anteriormente. Se compara la primera y la tercera fila de cada columna del amigo y si la tercera fila es mayor, significa que el amigo no tenía una inmunidad lo suficientemente alta para escapar de la enfermedad y finalmente se infecta. También cambiamos de color usando resaltado () a rojo si se infectan.

¡Ahora su código para la simulación debería funcionar! y para cualquier tamaño de población, ¡simplemente cambie NUMOFPEOPLE!

Paso 8: use la teoría de Montecarlo

Para llevar esto un paso más allá y extraer datos de nuestro simulador ('InfectionSim.m'), queríamos calcular y graficar la tendencia en el porcentaje de personas no vacunadas que se infectaron y el porcentaje de personas vacunadas que se infectaron. Suponemos que el porcentaje de personas vacunadas que se infectaron debería ser mucho menor que el porcentaje de personas no vacunadas que se infectaron.

Paso 9: Convierta el archivo ('InfectionSim.m') con la simulación en una función

Para ejecutar Monte Carlo, querríamos ejecutar la simulación varias veces y acumular datos para poder usarlos para graficar los porcentajes de personas que se infectaron.

La función podría configurarse así:

salida de la función = InfecciónSim (unvacc, vacuna, NUMOFPEOPLE, unvacc_perc, init_infect, velocidad)

Comente las variables en su simulación, ya que ahora las está pasando a través del archivo principal (comenzaremos a escribir esto en el paso 12):

unvacc, vac, NUMOFPEOPLE, unvacc_perc, init_infect

La nueva variable

velocidad

se asignará en el archivo principal (Monte_Carlo.m).

Nota: ¡No olvide el final al final del archivo de función para finalizar la función!

Paso 10: Calcule el porcentaje de personas no vacunadas y vacunadas que se infectaron

Esto calcula el porcentaje de personas no vacunadas que se infectaron. Este código se encuentra en la parte inferior del archivo 'InfectionSim.m'.

número_de_unvacc = 0;

número_de_infec_unvacc = 0; % calcula el porcentaje de personas no vacunadas que se infectaron para x = 1: longitud (InfecciónMat) si InfecciónMat (1, x) == unvacc number_of_unvacc = number_of_unvacc + 1; finalizar si la infecciónMat (1, x) == unvacc y la infecciónMat (2, x) == 1 número_de_infec_unvacc = número_de_infec_unvacc +1; end end percent_of_unvacc_and_infec = (número_de_infec_unvacc / número_of_unvacc) * 100;

Explicación del código

En el ciclo for, se repetirá NUMOFPEOPLE veces. Cada vez que el número de la infecciónMat corresponde al número de no vacunados (es decir, 0,95 == 0,95), el número de personas no vacunadas aumentará en 1. Cada vez que el número de la infecciónMat corresponde al número de no vacunados y están infectados, el el número de infectados y no vacunados aumenta en 1. La última línea divide el número de personas infectadas y no vacunadas por el número total de personas no vacunadas. Luego, el porcentaje se calcula a partir de esto.

Desafío:

¡Intente calcular el porcentaje de personas vacunadas que se infectaron! (Sugerencia: es muy similar al código anterior, sin embargo, algunas variables se cambian y los nombres se ajustan).

A continuación, se calcula el porcentaje de personas infectadas en función de la población total:

pre_per_infect = cumsum (InfecciónMat (2,:));

per_infect = (pre_per_infect (1, NUMOFPEOPLE) / NUMOFPEOPLE) * 100;

Explicación del código

La suma acumulada se calcula utilizando la segunda fila del InfectionMat, que almacena 1 y 0 dependiendo de si la persona está infectada o no. Dado que la función cumsum () devuelve una matriz, tomamos el último valor de la matriz ('pre_per_infect (1, NUMOFPEOPLE)'), que debería ser la suma real de todos los valores de 'InfecciónMat (2,:)'. Al dividir la suma por NUMOFPEOPLE y multiplicarla por 100, obtenemos el porcentaje final de infectados en la población total.

Paso 11: Cree una variable de salida en su función 'InfectionSim.m'

salida = [por_infección, porcentaje_de_unvacc_y_infec, porcentaje_de_vacc_and_infec];

Explicación del código

Almacene esta información en la salida, que se enviará de vuelta a main (Monte_Carlo.m) cuando se llame y termine de ejecutarse la función. Estos datos se utilizan para graficar los puntos de porcentaje de infectados de los que están vacunados y no vacunados.

¡Su función 'InfectionSim.m' debería estar lista ahora! Sin embargo, no se ejecutará porque todavía necesitamos escribir el archivo principal.

Paso 12: Cree un menú para obtener las condiciones iniciales de la simulación del usuario

Recuerda como dijimos la variable

velocidad

se crearía y pasaría a través de la función principal? Necesitamos obtener los valores para pasar a la función. Tenga en cuenta que el orden de los valores al llamar a la función es importante.

Comience pidiendo al usuario que escriba algunas respuestas en la terminal.

> Elija una enfermedad. Tenga en cuenta que distingue entre mayúsculas y minúsculas >> Tos ferina >> Gripe >> Sarampión >> Enfermedad elegida: Gripe >> Elija el tamaño de la población. >> 20 >> 200 >> Población elegida: 20 >> Elija la velocidad de simulación. >> Rápido >> Lento >> Velocidad elegida: Rápido

Este código a continuación pregunta al usuario qué enfermedad desea investigar.

disp ('Elija una enfermedad. Tenga en cuenta que distingue entre mayúsculas y minúsculas')

fprintf ('Tos ferina / nFlu / nSarampión / n') enfermedad = input ('Enfermedad elegida:', 's'); si es igual (enfermedad, 'tos ferina') vacuna =.85; % 15 por ciento de probabilidad de contraer la enfermedad sin vacunar =.20; % 80 por ciento de probabilidad de contraer la enfermedad si no es igual (enfermedad, 'gripe') vacuna =.75; % 25 por ciento de probabilidad de contraer la enfermedad sin vacunar =.31; % 69 por ciento de probabilidad de contraer la enfermedad si no es igual (enfermedad, 'Sarampión') vacuna =.97; % 3 por ciento de probabilidad de contraer la enfermedad sin vacunar =.10; % 90 por ciento de posibilidades de que la enfermedad termine

Explicación del código:

La función disp () imprime la declaración en la pantalla y también imprime las diferentes opciones. La enfermedad se asignará en consecuencia. Actualmente, esta versión no tiene en cuenta la entrada no válida. Una entrada no válida producirá un error y detendrá el programa por completo. Cada enfermedad tiene asociados valores vacunados y no vacunados. Estos valores NO son aleatorios. Obtuvimos estos valores de la investigación de estadísticas sobre las enfermedades.

A continuación, debemos preguntarle al usuario si desea probar un tamaño de población grande o pequeño para la enfermedad que eligió.

disp ('Elija el tamaño de la población.')

fprintf ('20 / n200 / n ') speed = input (' Población elegida: ',' s '); if isequal (velocidad, '20') tamaño_población = 20; elseif isequal (velocidad, '200') tamaño_población = 200; fin

Explicación del código

Esto imprime una declaración al usuario y le pide que ingrese el tamaño de población que desea probar. Actualmente, esta versión no tiene en cuenta la entrada no válida. Una entrada no válida producirá un error y detendrá el programa por completo. Se eligió 20 porque es un tamaño de muestra pequeño que aún da una buena idea de cómo se propaga la infección en una población pequeña. Se eligió a 200 personas como la opción más grande porque 200 puntos trazados en el gráfico apenas tenían superposición de puntos, por lo que todo se podía ver y distinguir fácilmente entre sí.

A continuación, necesitamos encontrar la velocidad de la simulación.

disp ('Elija la velocidad de la simulación.')

fprintf ('Fast / nSlow / n') speed = input ('Velocidad elegida:', 's'); if isequal (velocidad, 'Rápido') sim_speed = 0; elseif isequal (velocidad, 'Lento') sim_speed = 0.25; fin

Explicación del código

Este proceso fue el mismo que obtener el tipo de enfermedad y el tamaño de la población. Para rápido, no habrá pausa. y para lento, habrá un retraso de 0,25 segundos en el bucle for al ejecutar la simulación.

¡Excelente! ¡Ahora tenemos todas las entradas del usuario que necesitamos! Pasemos a la recopilación de datos para diferentes porcentajes de personas no vacunadas.

Paso 13: Elija un% de personas no vacunadas y calcule el promedio de personas no vacunadas e infectadas para el porcentaje elegido

Este código es para el 0% de las personas no vacunadas.

% -------% 0 No vacunados ------------

per_infect_av_0 = ; porcentaje_de_unvacc_y_infec_av_0 = ; para i = 1:20 out = InfecciónSim (unvacc, vacuna, tamaño_población, 0, 1, velocidad_im); per_infect_av_0 = [per_infect_av_0, out (1, 1)]; percent_of_unvacc_and_infec_av_0 = [porcentaje_of_unvacc_and_infec_av_0, out (1, 2)]; end average_infected_0 = mean (per_infect_av_0); average_unvacc_and_infected_0 = mean (porcentaje_de_unvacc_and_infec_av_0);

Explicación del código:

El bucle for se ejecuta 20 veces. La salida de la función, InfectionSim (), se almacena en out. Cada vez que se ejecuta el ciclo for, el porcentaje de infectados en la población total se agrega a la matriz, 'per_infect_av_0'. Además, el porcentaje de no vacunados e infectados también se agrega cada vez a la matriz 'percent_of_unvacc_and_infec_av_0'. En las dos últimas líneas, estas dos matrices mencionadas anteriormente se promedian y almacenan en variables. En resumen, los porcentajes se almacenan para cada simulación, se promedian y se grafican. Monte Carlo se utiliza para mostrar el valor medio de ejecutar una simulación y mostrar el resultado. Para nuestros propósitos experimentales, elegimos ejecutar la simulación 20 veces y promediar esos valores.

Desafío:

¡Repita para todos los porcentajes que desee probar! Esto se puede hacer cambiando los nombres de las variables de acuerdo con los números de porcentaje. Probamos para 0%, 5%, 10%, 20%, 30% y 50%.

Insinuación:

La única línea que debe cambiarse en el código real es

out = InfecciónSim (unvacc, vacuna, tamaño_población, 0, 1, velocidad_im);

Cambie el cero al porcentaje en forma decimal. Por ejemplo, para una simulación sin vacunar al 5%, el 0 debe reemplazarse por 0.5.

Paso 14: Gráfico: 'La tendencia de la infección en no vacunados vs. Vacunado para una enfermedad específica '

Este es el código para hacer un gráfico de la tendencia de infección en personas no vacunadas frente a personas no vacunadas.

graph_mat_y = [average_infected_0, average_infected_5, average_infected_10, average_infected_20, average_infected_30, average_infected_50];

graph_mat_x = [0, 5, 10, 20, 30, 50]; pendiente = (promedio_infectado_5-promedio_infectado_0) / 5; line_y = [average_infected_0, (pendiente * 50) + average_infected_0]; line_x = [0, 50]; figura (2) gráfico (graph_mat_x, graph_mat_y); line (line_x, line_y, 'Color', 'rojo', 'LineStyle', '-'); título (['Tendencia en la no vacunación para', enfermedad]); xlabel ('Porcentaje de no vacunados iniciales'); ylabel ('Porcentaje de infectados finales')

Explicación del código

línea 1: asignó valores y a los promedios del porcentaje de infectados

línea 2: valores de x asignados al porcentaje del porcentaje inicial de no vacunados

línea 3: calcule la pendiente de 0% y 5%

línea 4: almacena los valores y de la línea. Ésta es una continuación de la sección de 0% a 5%.

línea 5: almacena los valores y de la línea. Esta línea abarca la longitud del gráfico.

línea 6: crear figura

línea 7: grafica los valores xey del porcentaje de infectados que no están vacunados.

línea 8: trace la línea. Esto se usa para mostrar que no aumenta linealmente, sino exponencialmente.

línea 9: establezca el título del gráfico.

línea 10-11: Establecer etiquetas xey para el gráfico.

Ahora debería poder ver que a mayor porcentaje de población no vacunada, mayor cantidad de infección. También verá que la mayoría de los puntos que se vuelven rojos son puntos verdes, ¡lo que muestra que la vacuna ayuda hasta cierto punto! Espero que les haya gustado este tutorial. ¡Comenta si tienes alguna duda!

Paso 15: Producto final: aspecto de la simulación

Todo el código se puede encontrar aquí.