Para ser vacinado ou não? um projeto de observação da imunidade do rebanho por meio da simulação de doenças: 15 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:39

Visão geral do projeto:

Nosso projeto explora a imunidade do rebanho e espera encorajar as pessoas a se vacinarem para diminuir as taxas de infecção em nossas comunidades. Nosso programa simula como uma doença infecta uma população com diferentes porcentagens de taxas de vacinados e não vacinados. Ele mostra a imunidade do rebanho, mostrando como um aumento no número da população vacinada pode diminuir o número de pessoas afetadas.

Modelamos isso no Matlab usando os conceitos da teoria dos grafos. A teoria dos grafos é uma forma matemática de representar as relações entre os objetos. Na teoria dos grafos, os grafos têm vértices (ou nós) conectados por arestas (ou linhas). Para nosso projeto, os nós são os indivíduos envolvidos e as arestas são suas conexões. Por exemplo, se dois nós estiverem conectados com uma aresta, isso significa que eles são "amigos" ou têm alguma forma de contato um com o outro. Esse contato é uma forma de a doença se espalhar. É por isso que usamos a teoria dos gráficos para modelar nosso conceito, porque queríamos ver como a doença se espalha entre os indivíduos que estão conectados em uma população.

Nosso projeto também envolve o Método Monte Carlo. O método Monte Carlo são algoritmos que criam amostragem aleatória repetida para receber resultados numéricos. Em nosso projeto, usamos esse método para executar nossa simulação várias vezes, alterando a porcentagem de não vacinados iniciais para ver a taxa de infecção das pessoas.

Todo o código do projeto está vinculado na parte inferior!

Crédito para PC:

Link do Matlab para a teoria dos grafos:

Etapa 1: Criar Matriz de Adjacência

Crie um novo script. Vamos chamar o nosso 'InfectionSim.m'.

Vamos criar uma variável 'NUMOFPEOPLE'. Você pode atribuí-lo a qualquer valor inteiro. Isso representará o número de pessoas em sua população.

De agora em diante, vamos assumir que

NUMOFPEOPLE = 20;

Comece usando as funções da teoria dos grafos do Matlab para um gráfico não direcionado.

Se você estiver interessado em aprender mais, aqui está um link para você ler mais a fundo sobre o assunto.

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

Criou uma matriz de adjacência.

adjMatrix = zeros (NUMOFPEOPLE);

Isso criará uma matriz quadrada de 0s. Cada linha da matriz é uma pessoa. Cada coluna da matriz é uma pessoa ou amigo que a pessoa encontra ao longo do dia.

Veja a Figura 100 (acima) para ajudar a visualizar a aparência de adjMatrix para 20 pessoas.

** Deste ponto em diante, assumiremos que NUMOFPEOPLE é igual a 20. **

Você pode tentar representar graficamente essa matriz de adjacência. Aqui estão mais algumas informações sobre como plotar esses tipos de matrizes.

Nota: Como funciona a matriz de adjacência.

Ex:

% fazendo a matriz adjacente

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]% plotagem g = gráfico (a); % usando a função de gráfico (teoria dos gráficos) figura (1); h = plot (g);

Consulte a Figura 1 (acima) para ver como adicionar arestas na matriz de adjacência, usando o código em "Nota".

Etapa 2: Crie relacionamentos

Agora que as pessoas (vértices ou nós) foram criadas, precisamos criar uma rede de relações (linhas ou arestas do grafo). Isso simulará como as pessoas interagem e conhecem outras pessoas ao longo do dia.

Isso pode ser feito de várias maneiras. Uma maneira de concluir essa tarefa é primeiro atribuir um número aleatório a cada pessoa para determinar com quantas pessoas cada pessoa irá interagir em um dia.

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

Isso cria uma matriz de 1 por 20 de inteiros aleatórios que representam o número de interações que cada pessoa tem por dia. As colunas desta matriz seriam o número correspondente a cada pessoa. Por exemplo, se atribuirmos o leastFriendsPersonCanHave = 2 e mostFriendsPersonCanHave = 5, obteríamos valores aleatórios entre 2 e 5.

Está tendo problemas com randi ()? No terminal, digite

ajuda randi

Em seguida, fazemos uma matriz aleatória (chamada "allFriendsmatrix") de como cada pessoa na população está conectada / interage com a população.

tempMatrix = ;

contagem = 0; allFriendsMatrix = ; para k = 1: NUMOFPEOPLE enquanto comprimento (tempMatrix) ~ = numOfFriendsMatrix (k) contagem = contagem +1; temp = randi ([1, NUMOFPEOPLE]); tempMatrix (contagem) = temp; end clear each while length (tempMatrix) ~ = 9 tempMatrix = [tempMatrix, NaN]; end allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; contagem = 0; fim

Explicação detalhada do código:

Primeiro, criamos uma matriz temporária vazia para conter a lista de amigos / interação de cada pessoa. Também inicializamos a contagem, que apenas mantém o controle de onde colocar a nova conexão aleatória na tempMatrix. Os loops for são executados 20 vezes, de modo que isso aconteça para cada pessoa na população. O primeiro loop while é executado até que a tempMatrix de cada pessoa tenha o mesmo comprimento do número de interações atribuído aleatoriamente. Neste loop, um número aleatório correspondente à pessoa na população é gerado e colocado na tempMatrix. Como os comprimentos de cada uma das tempMatrixes são diferentes, precisamos criar alguns valores NaN para que possamos concatenar todas essas tempMaticies em uma matriz ('allFriendsMatrix'). O segundo loop while resolve esse problema adicionando NaNs em cada tempMatrix. O loop while foi configurado para ser executado 9 vezes porque é um número maior que 5, que era o limite superior de amigos que uma pessoa pode ser atribuída. O valor '9' é variável e pode / deve ser alterado quando 'mostFriendsPersonCanHave' for maior que 9. As últimas três linhas de código (excluindo o final) adicionam tempMatrix na próxima linha de 'allFriendsMatrix'. Em seguida, ele limpa a tempMatrix e conta para a próxima pessoa.

Saída

Esta é a aparência da saída para a primeira execução do loop for (antes das três últimas linhas).

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

Em seguida, adicione esses relacionamentos ao adjMatrix.

para cada linha = 1: NUMOFPEOPLE

para eachCol = 1: 9 se isnan (allFriendsMatrix (eachRow, eachCol)) == 0 adjMatrix (eachRow, allFriendsMatrix (eachRow, eachCol)) = 1; adjMatrix (allFriendsMatrix (eachRow, eachCol), eachRow) = 1; fim fim fim

Explicação do código

Este duplo loop for passa por cada linha e coluna de 'allFriendsMatrix'. A instrução if será executada para todos os valores que não são 'NaN'. Basicamente, ele criará as bordas ou linhas do gráfico. Portanto, a primeira linha que isso fará é pessoa 1 para pessoa 16 e pessoa 16 para pessoa 1. Como não é direcionado, 1 deve ser alterado para ambos! Não podemos apenas ter a borda de 1 a 16 e não de 16 a 1. Eles devem ser simétricos para que funcionem corretamente no Matlab.

Em nossa simulação, estabelecemos que as pessoas não podem interagir com elas mesmas. Quando randomizamos os valores, há uma chance de que nossa matriz adjacente tenha esses erros.

Vamos corrigir isso com o seguinte código:

para cada = 1: NUMOFPEOPLE

adjMatrix (cada, cada) = 0; fim

Explicação do código

Este loop for garante que a pessoa 1 não esteja conectada à pessoa 1, a pessoa 2 não esteja conectada à pessoa 2, etc, tornando todas elas 0. Como você pode ver abaixo na seção de saída, temos a diagonal do quadrado matriz do canto superior esquerdo ao inferior direito são todos os 0's.

Saída

Este é o adjMatrix final para esta simulação atual. Isso representa todas as linhas do 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 a Figura 2 para ver o gráfico de 'adjMatrix'.

Etapa 3: adicionar estatísticas de doenças

Agora que seu programa pode criar um gráfico com um conjunto de pessoas aleatórias e criar relacionamentos aleatórios, precisamos inserir as informações ou estatísticas da doença para ver como essas interações dentro de uma população podem aumentar ou diminuir a infecção.

Crie essas variáveis:

tipo% unvacc: duplo; porcentagem de chance de pessoas não vacinadas não pegarem a doença

vac% type: double; porcentagem de chance de pessoas vacinadas não contraírem a doença unvacc_perc% type: duplo; porcentagem da população não vacinada init_infect% type: int; porcentagem da população vacinada

Em seguida, precisamos fazer alguns cálculos.

Vamos fazer um'infecçãoMat 'que é uma matriz 3 * NUMOFPEOPLE.

vac_perc = 1-unvacc_perc;

infecçãoMat = nan (3, NUMOFPEOPLE); número = rodada (vac_perc * NUMOFPEOPLE); infecçãoMat (1, 1: número) = vac; infecçãoMat (1, número + 1: fim) = não vacc; infecçãoMat (2, 1: fim) = 0; infecçãoMat (2, 1: init_infect) = 1;

Explicação do código

linha 1: Porcentagem da população não vacinada calculada

linha 2: crie uma matriz 3 * N de número de pessoas

linha 3: descubra o número de pessoas vacinadas a partir da porcentagem vacinada

linha 4: para as pessoas vacinadas, dar-lhes imunidade associada à vacinação. Este valor é atribuído com base em pesquisas sobre a doença.

linha 5: para o resto da população (pessoas não vacinadas), dê-lhes a imunidade percentual. Este valor é atribuído com base em pesquisas sobre a doença.

linha 6: inicialmente defina todas as pessoas como não infectadas.

linha 7: para o número de pessoas inicialmente infectadas, preencha as primeiras duas colunas de acordo.

Agora que definimos todos os parâmetros para a simulação da doença, vamos randomizar a chance de a pessoa (vacinada e não vacinada) ser infectada. Isso é feito na próxima etapa, atribuindo valores aleatórios entre 0 e 1 para cada pessoa na terceira linha deste 'infectMat'.

Etapa 4: Randomize a chance de uma pessoa vacinada e não vacinada ficar infectada

Em seguida, atribua a cada pessoa um número aleatório, que será usado posteriormente para determinar se a pessoa foi infectada ou não.

para w = 1: comprimento (infecçãoMat)

infecçãoMat (3, w) = rand; fim

Explicação do código

Este loop for lida com a terceira linha do'infecçãoMat 'criada na última etapa. 'rand' atribui um valor entre 0 e 1 para cada índice da linha 3.

Saída

InfecçãoMat agora está completo! Isso ocorreu com uma população com 100% de vacinação e 1 pessoa inicialmente infectada.

infecçãoMat =

Colunas de 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 0,0869 0,5489 0,3177 0,9927 0,7236 0,5721 0,7172 0,9766 0,4270 0,9130 0.8973 0,8352 colunas 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

linha 1: porcentagem de chance de NÃO pegar a doença

linha 2: infectado ou não infectado (valor booleano)

linha 3: Número usado para verificar se uma pessoa que não está infectada foi infectada se encontrar uma pessoa infectada. Se uma pessoa não infectada encontrar uma pessoa infectada, esse número for maior que o número na linha 1 (para a mesma coluna), então ela está infectada. Vamos codificar essa funcionalidade na etapa 7.

Etapa 5: Criar matrizes de pessoas não vacinadas e infectadas a partir das informações iniciais

Crie 2 matrizes denominadas "matrixUnvacc" e "matrixInfected" que armazenam todas as pessoas infectadas do infecçãoMat. Isso será usado para que possamos codificar com cores o gráfico daqueles que estão infectados, não vacinados ou vacinados, ajudando a visualizar o impacto de indivíduos não vacinados versus vacinados.

limpar cada

matrixInfected = ; matrixUnvacc = ; para h = 1: comprimento (InfecçãoMat) se InfecçãoMat (1, h) == unvacc matrizUnvacc = [matrizUnvacc, h]; fim final para pessoa = 1: NUMOFPEOPLE se infecçãoMat (2, pessoa) == 1 matrixInfected = [matrixInfected, person]; fim fim

Explicação do código

Crie duas matrizes vazias para armazenar os números das pessoas não vacinadas e infectadas, respectivamente. Ambos os loops for são executados 20 vezes e, se a instrução if for satisfeita, o número é adicionado à matriz correta.

Saída

matrixUnvacc =

matrixInfected =

[1]

Etapa 6: traçar o gráfico inicial

A seguir, vamos representar graficamente a matriz de adjacência.

g = gráfico (adjMatrix);

figura (1) p = plot (g, 'NodeColor', 'b', 'MarkerSize', 7); destaque (p, matrixUnvacc, 'NodeColor', 'g') destaque (p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc * 100; title (['Porcentagem de pessoas não vacinadas:', num2str (title_unvacc), '%']); pausa (velocidade)

Explicação do código

A teoria dos grafos no Matlab possui funções integradas. Quando usamos a função graph (), somos capazes de traduzir 'adjMatrix' em um gráfico não direcionado real. Em seguida, temos que criar um gráfico usando a função plot () para realmente ver como ele se parece. Definimos este plot () como uma variável para que possamos manipular e alterar as cores do gráfico mais facilmente ao longo da simulação. Todas as pessoas (ou nós) são inicialmente definidas com a cor 'azul'. Em seguida, todas as pessoas não vacinadas são definidas com a cor 'verde'. As pessoas infectadas são então definidas com a cor 'vermelha'. O título é definido de acordo com um determinado valor percentual de pessoas não vacinadas sendo testadas. A função pause () interrompe temporariamente a execução do MatLab. Passamos pela velocidade variável que é espalhada que é calculada em segundos.

Veja a imagem (acima) para ver um gráfico codificado por cores aleatórias.

Saiba mais sobre a função destaque () no MatLab.

Etapa 7: Simule a progressão da infecção

Em seguida, precisamos descobrir quem é infectado após as interações (registradas no adjMatrix) e atualizar o gráfico quando alguém é infectado.

Use adjMatrix para determinar quais pessoas são infectadas após suas interações com outras pessoas em um dia.

para cada linha = 1: comprimento (adjMatrix)

ifinfecçãoMat (2, eachRow) == 1 for eachCol = 1: length (adjMatrix) if adjMatrix (eachRow, eachCol) == 1% eachRow = the person% eachCol = its friend% each person's friend and see if they are get infectado. se infecçãoMat (3, cadaCol)> infecçãoMat (1, cadaCol) infecçãoMat (2, eachCol) = 1; destaque (p, eachCol, 'NodeColor', 'r') pausa (velocidade) fim fim fim fim fim

O loop for percorre cada pessoa. Ele verifica que se a pessoa está infectada, irá verificar cada uma das pessoas / amigos com quem eles interagiram e verificar se o nível de imunidade do amigo era maior do que a força da doença. É aqui que entra em ação o'infecçãoMat 'que criamos anteriormente. A 1ª e 3ª linha de cada coluna do amigo são comparadas e se a 3ª linha for maior, significa que o amigo não tinha imunidade alta o suficiente para escapar da doença e acabou se infectando. Também mudamos para a cor usando destaque () para vermelho se eles forem infectados.

Agora seu código para a simulação deve funcionar! e para qualquer tamanho de população, basta alterar NUMOFPEOPLE!

Etapa 8: Use a Teoria de Monte Carlo

Para dar um passo adiante e extrair dados de nosso simulador ('InfecçãoSim.m'), queríamos calcular e representar graficamente a tendência em porcentagem de pessoas não vacinadas que foram infectadas e a porcentagem de pessoas vacinadas que foram infectadas. Nossa hipótese é que a porcentagem de pessoas vacinadas que foram infectadas deveria ser muito menor do que a porcentagem de pessoas não vacinadas que foram infectadas.

Etapa 9: Transforme o arquivo ('infecçãoSim.m') com a simulação em uma função

Para executar o Monte Carlo, gostaríamos de executar a simulação várias vezes e acumular dados para que possamos usá-los para representar graficamente as porcentagens de pessoas que foram infectadas.

A função pode ser configurada assim:

saída de função = infecçãoSim (unvacc, vac, NUMOFPEOPLE, unvacc_perc, init_infect, velocidade)

Comente as variáveis em sua simulação, pois agora você está passando-as pelo arquivo principal (começaremos a escrever isso na etapa 12):

unvacc, vac, NUMOFPEOPLE, unvacc_perc, init_infect

A nova variável

Rapidez

será atribuído no arquivo principal (Monte_Carlo.m).

Nota: Não se esqueça do final na parte inferior do arquivo de função para encerrar a função!

Etapa 10: Calcular a porcentagem de pessoas não vacinadas e vacinadas que foram infectadas

Isso calcula a porcentagem de pessoas não vacinadas que foram infectadas. Esse código vai na parte inferior do arquivo 'InfectionSim.m'.

numero_de_unvacc = 0;

number_of_infec_unvacc = 0; % calcula a porcentagem de pessoas não vacinadas que foram infectadas por x = 1: comprimento (infecçãoMat) se infecçãoMat (1, x) == número não vacinal_de_unvacc = número_de_unvacc + 1; finalizar se infecçãoMat (1, x) == unvacc & InfecçãoMat (2, x) == 1 número_de_infec_unvacc = número_de_infec_unvacc +1; fim fim porcentagem_de_unvacc_and_infec = (numero_de_infec_unvacc / numero_de_unvacc) * 100;

Explicação do código

No loop for, ele repetirá NUMOFPEOPLE vezes. Cada vez que o número na infecçãoMat corresponde ao número não vacc (ou seja, 0,95 == 0,95), então o número de pessoas não vacinadas aumentará em 1. Cada vez que o número na infecçãoMat corresponde ao número não vacc e eles estão infectados, o o número de infectados e não vacinados aumenta em 1. A última linha divide o número de pessoas infectadas e não vacinadas pelo número total de pessoas não vacinadas. Em seguida, a porcentagem é calculada a partir disso.

Desafio:

Tente calcular a porcentagem de pessoas vacinadas que foram infectadas! (Dica: é muito semelhante a este código acima, no entanto, algumas das variáveis são alteradas e os nomes são ajustados.)

Em seguida, a porcentagem de pessoas infectadas com base na população total é calculada:

pre_per_infect = cumsum (infecçãoMat (2,:));

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

Explicação do código

A soma cumulativa é calculada usando a segunda linha do infectMat, que armazena 1s e 0s dependendo se a pessoa está infectada ou não. Uma vez que a função cumsum () retorna uma matriz, pegamos o último valor na matriz ('pre_per_infect (1, NUMOFPEOPLE)'), que deve ser a soma real de todos os valores de 'troubleMat (2,:)'. Dividindo a soma pelo NUMOFPEOPLE e multiplicando por 100, obtemos a porcentagem final de infectados na população total.

Etapa 11: crie uma variável de saída em sua função 'infecçãoSim.m'

output = [per_infect, percent_of_unvacc_and_infec, percent_of_vacc_and_infec];

Explicação do código

Armazene essas informações na saída, que será enviada de volta ao main (Monte_Carlo.m) quando a função for chamada e concluída a execução. Esses dados são usados para representar graficamente os pontos percentuais de infectados daqueles que foram vacinados e não vacinados.

Sua função 'InfecçãoSim.m' deve ser concluída agora! No entanto, ele não será executado porque ainda precisamos escrever o principal!

Etapa 12: Crie um menu para obter as condições iniciais da simulação do usuário

Lembre-se de como dissemos a variável

Rapidez

seria criado e passado pela função principal? Precisamos obter os valores para passar para a função. Observe que a ordem dos valores ao chamar a função é importante!

Comece pedindo ao usuário para digitar algumas respostas no terminal.

> Escolha uma doença. Observe que diferencia maiúsculas de minúsculas >> Coqueluche >> Gripe >> Sarampo >> Doença Escolhida: Gripe >> Escolha o tamanho da população. >> 20 >> 200 >> População escolhida: 20 >> Escolha a velocidade da simulação. >> Rápido >> Lento >> Velocidade escolhida: Rápido

O código abaixo pergunta ao usuário qual doença ele deseja investigar.

disp ('Escolha uma doença. Observe que diferencia maiúsculas de minúsculas')

fprintf ('Coqueluche / nFlu / nMeasles / n') doença = input ('Doença escolhida:', 's'); se for igual (doença, 'Coqueluche') vac = 0,85; % 15 por cento de chance de contrair a doença não vacc = 0,20; % 80 por cento de chance de contrair a doença elseif isequal (doença, 'Gripe') vac = 0,75; % 25 por cento de chance de contrair a doença não vacinal = 0,31; % 69 por cento de chance de contrair doença elseif isequal (doença, 'Sarampo') vac = 0,97; % 3 por cento de chance de obter a doença não vacc = 0,10; % 90 por cento de chance de acabar com a doença

Explicação do código:

A função disp () imprime a instrução na tela e também imprime as diferentes opções. A doença será atribuída em conformidade. Esta versão atualmente não leva em conta a entrada inválida. Uma entrada inválida produzirá um erro e interromperá o programa completamente. Cada doença tem valores vac e unvacc associados a ela. Esses valores NÃO são aleatórios. Obtemos esses valores pesquisando estatísticas sobre as doenças.

Em seguida, precisamos perguntar ao usuário se ele deseja testar uma população grande ou pequena para a doença escolhida.

disp ('Escolha o tamanho da população.')

fprintf ('20 / n200 / n ') speed = input (' População escolhida: ',' s '); se for igual (velocidade, '20') tamanho_da_população = 20; elseif isequal (velocidade, '200') tamanho_da_população = 200; fim

Explicação do código

Isso imprime uma instrução para o usuário e pede que ele insira o tamanho da população que deseja testar. Esta versão não leva em conta entrada inválida. Uma entrada inválida produzirá um erro e interromperá o programa completamente. 20 foi escolhido porque é uma amostra pequena que ainda dá uma boa ideia de como a infecção se espalha por uma pequena população. 200 pessoas foram escolhidas como a opção maior porque 200 pontos plotados no gráfico quase não tinham qualquer sobreposição de pontos, então tudo poderia ser facilmente visto e diferenciado um do outro.

Em seguida, precisamos encontrar a velocidade da simulação.

disp ('Escolha a velocidade da simulação.')

fprintf ('Fast / nSlow / n') speed = input ('Velocidade escolhida:', 's'); if isequal (speed, 'Fast') sim_speed = 0; elseif isequal (velocidade, 'Lento') sim_speed = 0,25; fim

Explicação do código

Esse processo era o mesmo que pegar o tipo de doença e o tamanho da população. Para rápido, não haverá pausa. e para lento, haverá um atraso de 0,25 segundo no loop for ao executar a simulação.

Excelente! Agora temos todas as entradas do usuário de que precisamos! Vamos prosseguir com a coleta de dados para diferentes porcentagens de pessoas não vacinadas.

Etapa 13: Escolha uma% de pessoas não vacinadas e calcule a média de não vacinadas e infectadas para a porcentagem escolhida

Este código é para 0% das pessoas não vacinadas.

% -------% 0 não vacinado ------------

per_infect_av_0 = ; porcentagem_of_unvacc_and_infec_av_0 = ; para i = 1:20 out = infecçãoSim (unvacc, vac, tamanho_da_população, 0, 1, velocidade_im); per_infect_av_0 = [per_infect_av_0, out (1, 1)]; percent_of_unvacc_and_infec_av_0 = [percent_of_unvacc_and_infec_av_0, out (1, 2)]; final média_infectada_0 = média (per_infect_av_0); media_unvacc_and_infected_0 = média (porcentagem_de_unvacc_and_infec_av_0);

Explicação do código:

O loop for é executado 20 vezes. A saída da função, infecçãoSim (), é armazenada em out. Cada vez que o loop for é executado, a porcentagem de infectados na população total é adicionada à matriz, 'per_infect_av_0'. Além disso, a porcentagem de não vacinados e infectados também é adicionada a cada vez na matriz 'percent_of_unvacc_and_infec_av_0'. Nas duas últimas linhas, essas duas matrizes mencionadas acima são calculadas e armazenadas em variáveis. Para resumir, as porcentagens são armazenadas para cada simulação, calculadas e representadas graficamente. Monte Carlo é usado para mostrar o valor médio de execução de uma simulação e mostrar o resultado. Para nossos propósitos experimentais, escolhemos rodar a simulação 20 vezes e calcular a média desses valores.

Desafio:

Repita para todas as porcentagens que deseja testar! Isso pode ser feito alterando os nomes das variáveis de acordo com os números percentuais. Testamos 0%, 5%, 10%, 20%, 30% e 50%.

Dica:

A única linha que deve ser alterada no código real é

out = infecçãoSim (unvacc, vac, tamanho_da_população, 0, 1, velocidade_im);

Altere o zero para a porcentagem na forma decimal. Por exemplo, para 5% de simulação não vacinada, o 0 deve ser substituído por 0,5.

Etapa 14: Gráfico: 'A tendência de infecção em não vacinados vs. Vacinado para Doença Especificada '

Este é o código para fazer um gráfico da tendência de infecção em pessoas não vacinadas vs. pessoas não vacinadas.

graph_mat_y = [média_infetada_0, média_infetada_5, média_infetada_10, média_infetada_20, média_infetada_30, média_infetada_50];

graph_mat_x = [0, 5, 10, 20, 30, 50]; declive = (média_infetada_5-média_infetada_0) / 5; line_y = [média_infetada_0, (declive * 50) + média_infetada_0]; linha_x = [0, 50]; figura (2) plot (graph_mat_x, graph_mat_y); line (line_x, line_y, 'Color', 'red', 'LineStyle', '-'); título (['Tendência em não vacinação para', doença]); xlabel ('Porcentagem de não vacinados iniciais'); ylabel ('Porcentagem do final infectado')

Explicação do código

linha 1: valores de y atribuídos às médias da porcentagem de infectados

linha 2: valores x atribuídos à porcentagem da porcentagem inicial não vacinada

linha 3: calcule a inclinação de 0% e 5%

linha 4: armazene os valores y da linha. Esta é uma continuação da seção de 0% a 5%.

linha 5: armazene os valores y da linha. Esta linha abrange o comprimento do gráfico.

linha 6: criar figura

linha 7: traçar o gráfico dos valores xey da porcentagem de infectados, que não foram vacinados.

linha 8: trace a linha. Isso é usado para mostrar que não aumenta linearmente, mas exponencialmente.

linha 9: Defina o título do gráfico.

linha 10-11: Defina os rótulos xey para o gráfico.

Agora você deve ser capaz de ver que quanto maior a porcentagem da população não vacinada, maior a quantidade de infecção. Você também verá que a maioria dos pontos que ficam vermelhos são verdes, mostrando que a vacina ajuda em algum grau! Espero que tenha gostado deste tutorial. Comente se você tiver alguma dúvida!

Etapa 15: Produto final: Qual é a aparência da simulação

Todo o código pode ser encontrado aqui