Se faire vacciner ou pas ? un projet sur l'observation de l'immunité des troupeaux grâce à la simulation de la maladie : 15 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:09

Aperçu du projet:

Notre projet explore l'immunité collective et espère encourager les gens à se faire vacciner pour réduire les taux d'infection dans nos communautés. Notre programme simule comment une maladie infecte une population avec différents pourcentages de taux de vaccinés et de non vaccinés. Il montre l'immunité collective en montrant comment un nombre accru de la population vaccinée peut réduire le nombre de personnes touchées.

Nous modélisons cela dans Matlab en utilisant les concepts de la théorie des graphes. La théorie des graphes est une façon mathématique de représenter les relations entre les objets. En théorie des graphes, les graphes ont des sommets (ou nœuds) reliés par des arêtes (ou des lignes). Pour notre projet, les nœuds sont les individus concernés et les arêtes sont leurs connexions. Par exemple, si deux nœuds sont connectés avec une arête, cela signifie qu'ils sont « amis » ou qu'ils ont une forme de contact l'un avec l'autre. Ce contact est un moyen pour la maladie de se propager. C'est pourquoi nous avons utilisé la théorie des graphes pour modéliser notre concept car nous voulions voir comment la maladie se propage parmi les individus qui sont connectés dans une population.

Notre projet implique également la Méthode Monte Carlo. La méthode Monte Carlo sont des algorithmes qui créent un échantillonnage aléatoire répété pour recevoir des résultats numériques. Dans notre projet, nous utilisons cette méthode pour exécuter notre simulation plusieurs fois en changeant le pourcentage de non vaccinés initiaux pour voir le taux d'infection des personnes.

Tout le code du projet est lié en bas !

Crédit PC:

Lien Matlab vers la théorie des graphes:

Étape 1: Créer une matrice de contiguïté

Créez un nouveau script. Nous allons appeler le nôtre 'infectionSim.m'.

Nous allons créer une variable 'NUMOFPEOPLE'. Vous pouvez l'affecter à n'importe quelle valeur entière. Cela représentera le nombre de personnes dans votre population.

Dorénavant, nous supposerons que

NOMBRE DE PERSONNES = 20;

Commencez par utiliser les fonctions de théorie des graphes de Matlab pour un graphe non orienté.

Si vous souhaitez en savoir plus, voici un lien pour en savoir plus à ce sujet.

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

Création d'une matrice d'adjacence.

adjMatrice = zéros(NOMBRE DE PERSONNES);

Cela créera une matrice carrée de 0. Chaque ligne de la matrice est une personne. Chaque colonne de la matrice est une personne ou un ami que la personne rencontre tout au long de la journée.

Voir la figure 100 (ci-dessus) pour vous aider à visualiser à quoi ressemble adjMatrix pour 20 personnes.

**À partir de ce point, nous supposerons que NUMOFPEOPLE est égal à 20.**

Vous pouvez essayer de tracer cette matrice de contiguïté. Voici un peu plus d'informations sur le tracé de ces types de matrices.

Remarque: Comment fonctionne la matrice de contiguïté.

Ex:

%créer la matrice 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] % tracé g = graphique(a); %à l'aide de la fonction graphique (théorie des graphes) figure(1); h = tracé(g);

Voir la figure 1 (ci-dessus) pour voir comment ajouter des arêtes dans la matrice d'adjacence, en utilisant le code dans "Note".

Étape 2: Créer des relations

Maintenant que les personnes (sommets ou nœuds) sont créées, nous devons créer un réseau de relations (lignes ou arêtes du graphe). Cela simulera la façon dont les gens interagissent et rencontrent d'autres personnes tout au long d'une journée.

Cela peut être fait de plusieurs manières. Une façon d'accomplir cette tâche est d'attribuer d'abord un nombre aléatoire à chaque personne pour déterminer avec combien de personnes chaque personne interagira dans une journée.

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

Cela fait une matrice de 1 par 20 d'entiers aléatoires représentant le nombre d'interactions que chaque personne a par jour. Les colonnes de cette matrice seraient le nombre correspondant à chaque personne. Par exemple, si nous attribuons les moinsFriendsPersonCanHave = 2 et mostFriendsPersonCanHave = 5, nous obtiendrons des valeurs aléatoires entre 2 et 5.

Vous avez des problèmes avec randi() ? Dans le terminal, tapez

aide randi

Ensuite, nous créons une matrice aléatoire (appelée "allFriendsmatrix") de la façon dont chaque personne de la population est connectée/interagit au sein de la population.

Matrice temp = ;

compte = 0; allFriendsMatrix = ; pour k = 1:NUMOFPEOPLE tandis que length(tempMatrix) ~= numOfFriendsMatrix(k) count = count +1; temp = randi([1, NOMBRE DE PERSONNES]); tempMatrix(count) = temp; end clear each while length(tempMatrix) ~= 9 tempMatrix = [tempMatrix, NaN]; end allFriendsMatrix = [allFriendsMatrix; tempMatrice]; Matrice temp = ; compte = 0; finir

Explication détaillée du code:

D'abord, nous créons une matrice temporaire vide pour contenir la liste d'amis/d'interaction de chaque personne. Nous initialisons également count, qui garde juste une trace de l'endroit où coller la nouvelle connexion aléatoire dans le tempMatrix. Les boucles for sont exécutées 20 fois afin que cela se produise pour chaque personne de la population. La première boucle while s'exécute jusqu'à ce que la tempMatrix de chaque personne ait la même longueur que le nombre d'interactions attribué au hasard. Dans cette boucle, un nombre aléatoire correspondant à la personne dans la population est généré et placé dans le tempMatrix. Étant donné que les longueurs de chacune des tempMatrixes sont différentes, nous devions créer des valeurs NaN afin de pouvoir concaténer toutes ces tempMatrixes en une seule matrice ('allFriendsMatrix'). La deuxième boucle while résout ce problème en ajoutant des NaN dans chaque tempMatrix. La boucle while a été configurée pour s'exécuter 9 fois car il s'agit d'un nombre supérieur à 5, qui était la limite supérieure d'amis qu'une personne peut se voir attribuer. La valeur « 9 » est variable et peut/doit être modifiée lorsque « mostFriendsPersonCanHave » est supérieur à 9. Les trois dernières lignes de code (à l'exception de la fin) ajoutent le tempMatrix dans la ligne suivante du « allFriendsMatrix ». Ensuite, il efface tempMatrix et compte pour la personne suivante.

Sortir

Voici à quoi devrait ressembler la sortie pour la première exécution de la boucle for (avant les trois dernières lignes).

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

Ensuite, ajoutez ces relations à adjMatrix.

pour chaque ligne = 1: NOMBRE DE PERSONNES

pour chaqueCol = 1:9 if isnan(allFriendsMatrix(eachRow, eachCol)) == 0 adjMatrix(eachRow, allFriendsMatrix(eachRow, eachCol)) = 1; adjMatrix(allFriendsMatrix(chaqueLigne, chaqueCol), chaqueLigne) = 1; fin fin fin

Explication du code

Cette double boucle for parcourt chaque ligne et colonne de « allFriendsMatrix ». L'instruction if s'exécutera pour toutes les valeurs qui ne sont pas « NaN ». Fondamentalement, cela créera les bords ou les lignes du graphique. Donc, la première ligne que cela fera est la personne 1 à la personne 16 et la personne 16 à la personne 1. Parce qu'elle n'est pas dirigée, 1 doit être changé pour les deux ! Nous ne pouvons pas simplement avoir le bord 1 à 16 et non 16 à 1. Ils doivent être symétriques pour que cela fonctionne correctement dans Matlab.

Dans notre simulation, nous avons établi que les gens ne peuvent pas interagir avec eux-mêmes. Lorsque nous avons randomisé les valeurs, il est possible que notre matrice adjacente contienne ces erreurs.

Corrigeons cela avec le code suivant:

pour chaque = 1: NOMBRE DE PERSONNES

adjMatrix(chacun, chacun) = 0; finir

Explication du code

Cette boucle for garantit que la personne 1 n'est pas connectée à la personne 1, la personne 2 n'est pas connectée à la personne 2, etc. matrice du haut à gauche vers le bas à droite sont tous des 0.

Sortir

Il s'agit de la dernière adjMatrix pour cette simulation actuelle. Cela représente toutes les lignes du graphique (Figure 2).

adjMatrice =

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

Voir la figure 2 pour voir le graphique de 'adjMatrix'.

Étape 3: Ajouter des statistiques sur la maladie

Maintenant que votre programme peut créer un graphique avec un ensemble de personnes aléatoires et créer des relations aléatoires, nous devons saisir les informations ou les statistiques de la maladie pour voir comment ces interactions au sein d'une population peuvent augmenter ou diminuer l'infection.

Créez ces variables:

unvacc %type: double; pourcentage de chance que des personnes non vaccinées ne contractent pas la maladie

type de vacc: double; pourcentage de chance que les personnes vaccinées ne contractent pas la maladie unvacc_perc %type: double; pourcentage de la population non vaccinée init_infect %type: int; pourcentage de la population vaccinée

Ensuite, nous devons faire quelques calculs.

Nous allons créer un 'infectionMat' qui est une matrice 3*NUMOFPEOPLE.

vacc_perc = 1-unvacc_perc;

infectionMat = nan(3, NOMBRE DE PERSONNES); nombre = rond(vacc_perc * NUMOFPEOPLE); infectionMat(1, 1:nombre) = vacc; infectionMat(1, nombre+1:fin) = unvacc; infectionMat(2, 1:end) = 0; infectionMat(2, 1: init_infect) = 1;

Explication du code

ligne 1: pourcentage de la population non vaccinée calculé

ligne 2: créer une matrice de nombre de personnes 3*N

ligne 3: connaître le nombre de personnes vaccinées à partir du pourcentage vacciné

ligne 4: pour les personnes vaccinées, leur donner une immunité associée au fait de se faire vacciner. Cette valeur est attribuée en fonction de la recherche sur la maladie.

ligne 5: pour le reste de la population (personnes non vaccinées), donnez-leur le pourcentage d'immunité. Cette valeur est attribuée en fonction de la recherche sur la maladie.

ligne 6: définissez initialement toutes les personnes sur non infectées.

ligne 7: pour le nombre de personnes initialement infectées, remplissez les premières colonnes en conséquence.

Maintenant que nous avons défini tous les paramètres pour la simulation de la maladie, nous allons randomiser le risque d'infection de la personne (à la fois vaccinée et non vaccinée). Cela se fait à l'étape suivante en attribuant des valeurs aléatoires entre 0 et 1 à chaque personne de la troisième rangée de ce « infectionMat ».

Étape 4: Randomiser le risque qu'une personne vaccinée et non vaccinée puisse être infectée

Ensuite, attribuez à chaque personne un numéro aléatoire, cela sera utilisé plus tard pour déterminer si la personne est infectée ou non.

pour w = 1: longueur(infectionMat)

infectionMat(3, w) = rand; finir

Explication du code

Cette boucle for traite la troisième ligne du 'infectionMat' créé à la dernière étape. 'rand' attribue une valeur comprise entre 0 et 1 à chaque index de la ligne 3.

Sortir

infectionMat est maintenant terminé ! Il s'agissait d'une population avec 100 % de vaccination et 1 personne initialement infectée.

infectionMat =

Colonnes 1 à 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 20 0,800 0,7352 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

ligne 1: Pourcentage de chances de ne PAS contracter la maladie

ligne 2: Infecté ou non infecté (valeur booléenne)

ligne 3: Numéro utilisé pour vérifier si une personne qui n'est pas infectée est infectée si elle rencontre une personne infectée. Si une personne non infectée rencontre une personne infectée, ce nombre est supérieur au nombre de la ligne 1 (pour la même colonne), alors ils sont infectés. Nous allons coder cette fonctionnalité à l'étape 7.

Étape 5: Créez des matrices de personnes non vaccinées et infectées à partir des informations initiales

Créez 2 matrices appelées "matrixUnvacc" et "matrixInfected" qui stockent toutes les personnes infectées d'infectionMat. Cela sera utilisé pour que nous puissions coder en couleur le graphique des personnes infectées, non vaccinées ou vaccinées, aidant à visualiser l'impact des personnes non vaccinées par rapport aux personnes vaccinées.

effacer chaque

matriceInfectée = ; matriceUnvacc = ; pour h= 1: longueur(infectionMat) if infectionMat(1, h) == unvacc matriceUnvacc = [matriceUnvacc, h]; end end for person = 1:NUMOFPEOPLE if infectionMat(2, person) == 1 matrixInfected = [matrixInfected, person]; fin fin

Explication du code

Créez deux matrices vides pour stocker les nombres de personnes non vaccinées et infectées, respectivement. Les deux boucles for sont exécutées 20 fois et si l'instruction if est satisfaite, le nombre est ajouté à la matrice correcte.

Sortir

matriceUnvacc =

matriceInfectée =

[1]

Étape 6: Tracez le graphique initial

Ensuite, nous allons tracer la matrice d'adjacence.

g = graph(adjMatrix);

figure(1) p = plot(g, 'NodeColor', 'b', 'MarkerSize', 7); Highlight(p, matrixUnvacc, 'NodeColor', 'g') Highlight(p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc*100; title(['Pourcentage de personnes non vaccinées: ', num2str(title_unvacc), '%']); pause (vitesse)

Explication du code

La théorie des graphes dans Matlab a des fonctions intégrées. Lorsque nous utilisons la fonction graph(), nous sommes capables de traduire la « adjMatrix » en un graphique non orienté réel. Nous devons ensuite créer un tracé en utilisant la fonction plot() pour voir à quoi il ressemble. Nous définissons ce plot() sur une variable afin de pouvoir manipuler et modifier les couleurs du tracé plus facilement tout au long de la simulation. Toutes les personnes (ou nœuds) sont initialement définies sur la couleur « bleu ». Ensuite, toutes les personnes non vaccinées sont définies sur la couleur « vert ». Les personnes infectées sont alors définies sur la couleur « rouge ». Le titre est fixé en fonction d'un certain pourcentage de personnes non vaccinées testées. La fonction pause() arrête temporairement l'exécution de MatLab. On passe par la vitesse variable qui s'étale qui se calcule en secondes.

Voir l'image (ci-dessus) pour voir un graphique codé par couleur aléatoire.

En savoir plus sur la fonction Highlight() dans MatLab.

Étape 7: Simuler la progression de l'infection

Ensuite, nous devons déterminer qui est infecté après les interactions (enregistrées dans adjMatrix) et mettre à jour le graphique lorsqu'une personne est infectée.

Utilisez adjMatrix pour déterminer quelles personnes sont infectées après leurs interactions avec les autres au cours d'une journée.

pour chaque ligne = 1: longueur (adjMatrix)

if infectionMat(2, eachRow) == 1 pour eachCol = 1:length(adjMatrix) if adjMatrix(eachRow, EachCol) == 1 % eachRow = la personne % eachCol = son ami % l'ami de chaque personne et voyez si elles sont infectées. si infectionMat(3, eachCol) > infectionMat(1, eachCol) infectionMat(2, eachCol) = 1; Highlight(p, eachCol, 'NodeColor', 'r') pause(speed) end end end end end end

La boucle for parcourt chaque personne. Il vérifie que si la personne est infectée, il vérifiera chacune des personnes/amis avec lesquels ils ont interagi et vérifiera si le niveau d'immunité de l'ami était supérieur à la force de la maladie. C'est là que le « infectionMat » que nous avons créé précédemment entre en jeu. La 1ère et la 3ème ligne de chaque colonne de l'ami sont comparées et si la 3ème ligne est plus grande, cela signifie que l'ami n'avait pas une immunité suffisamment élevée pour échapper à la maladie et finalement s'infecter. Nous changeons également de couleur en utilisant Highlight() en rouge s'ils sont infectés.

Maintenant, votre code pour la simulation devrait fonctionner ! et pour n'importe quelle taille de population, changez juste NUMOFEPEOPLE !

Étape 8: Utilisez la théorie de Monte Carlo

Pour aller plus loin et extraire les données de notre simulateur (« infectionSim.m »), nous voulions calculer et représenter graphiquement la tendance en pourcentage de personnes non vaccinées infectées et en pourcentage de personnes vaccinées infectées. Nous émettons l'hypothèse que le pourcentage de personnes vaccinées qui ont été infectées devrait être bien inférieur au pourcentage de personnes non vaccinées qui ont été infectées.

Étape 9: Transformez le fichier ('infectionSim.m') avec la simulation en fonction

Pour exécuter Monte Carlo, nous voudrions exécuter la simulation plusieurs fois et accumuler des données afin de pouvoir les utiliser pour représenter graphiquement les pourcentages de personnes infectées.

La fonction pourrait être configurée comme ceci:

sortie de la fonction = infectionSim(unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect, speed)

Commentez les variables dans votre simulation puisque maintenant vous les transmettez via le fichier principal (nous commencerons à écrire cela à l'étape 12):

unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect

La nouvelle variable

la vitesse

sera affecté dans le fichier principal (Monte_Carlo.m).

Remarque: N'oubliez pas la fin en bas du fichier de fonction pour terminer la fonction !

Étape 10: Calculez le pourcentage de personnes non vaccinées et vaccinées qui ont été infectées

Cela calcule le pourcentage de personnes non vaccinées qui ont été infectées. Ce code va au bas du fichier 'infectionSim.m'.

nombre_de_unvacc = 0;

nombre_de_infec_unvacc = 0; %calcule le pourcentage de personnes non vaccinées qui ont été infectées pour x = 1: longueur(infectionMat) si infectionMat(1, x) == unvacc number_of_unvacc = number_of_unvacc+1; end if infectionMat(1, x) == unvacc & infectionMat(2, x) == 1 number_of_infec_unvacc = number_of_infec_unvacc +1; end end percent_of_unvacc_and_infec = (number_of_infec_unvacc / number_of_unvacc)*100;

Explication du code

Dans la boucle for, il bouclera sur NUMOFPEOPLE fois. Chaque fois que le nombre dans l'infectionMat correspond au nombre non vacciné (c'est-à-dire 0.95 == 0.95), alors le nombre de personnes non vaccinées sera augmenté de 1. Chaque fois que le nombre dans l'infectionMat correspond au nombre non vacciné et qu'elles sont infectées, le le nombre de personnes infectées et non vaccinées augmente de 1. La dernière ligne divise le nombre de personnes infectées et non vaccinées par le nombre total de personnes non vaccinées. Ensuite, le pourcentage est calculé à partir de cela.

Défi:

Essayez de calculer le pourcentage de personnes vaccinées parmi les personnes infectées ! (Indice: il est très similaire à ce code ci-dessus, mais certaines variables sont modifiées et les noms sont ajustés.)

Ensuite, le pourcentage de personnes infectées sur la base de la population totale est calculé:

pre_per_infect = cumsum(infectionMat(2,:));

per_infect = (pre_per_infect (1, NOMBRE DE PERSONNES)/NOMBRE DE PERSONNES)*100;

Explication du code

La somme cumulée est calculée à l'aide de la deuxième ligne de l'infectionMat, qui stocke des 1 et des 0 selon que la personne est infectée ou non. Puisque la fonction cumsum() renvoie une matrice, nous prenons la dernière valeur de la matrice ('pre_per_infect(1, NUMOFPEOPLE)'), qui devrait être la somme réelle de toutes les valeurs de 'infectionMat(2,:)'. En divisant la somme par le NOMBRE DE PERSONNES et en la multipliant par 100, nous obtenons le pourcentage final d'infectés dans la population totale.

Étape 11: créez une variable de sortie dans votre fonction 'infectionSim.m'

sortie = [par_infect, pourcentage_de_unvacc_et_infec, pourcentage_de_vacc_et_infec];

Explication du code

Stockez ces informations en sortie, qui seront renvoyées dans main (Monte_Carlo.m) lorsque la fonction est appelée et terminée. Ces données sont utilisées pour représenter graphiquement les points de pourcentage d'infectés parmi ceux qui sont vaccinés et non vaccinés.

Votre fonction 'infectionSim.m' devrait être terminée maintenant ! Cependant, il ne fonctionnera pas car nous devons encore écrire le principal !

Étape 12: Créez un menu pour obtenir les conditions initiales de la simulation de l'utilisateur

Rappelez-vous comment nous avons dit la variable

la vitesse

serait créé et transmis par la fonction principale ? Nous devons obtenir les valeurs à passer à la fonction. Notez que l'ordre des valeurs lors de l'appel de la fonction est important !

Commencez par demander à l'utilisateur de saisir des réponses dans le terminal.

> Choisissez une maladie. Notez qu'il est sensible à la casse>> Coqueluche >> Grippe >> Rougeole >> Maladie choisie: Grippe >> Choisissez la taille de la population. >> 20 >> 200 >> Population choisie: 20 >> Choisissez la vitesse de simulation. >> Rapide >> Lente >> Vitesse choisie: Rapide

Ce code ci-dessous demande à l'utilisateur quelle maladie il souhaite examiner.

disp('Choisissez une maladie. Notez qu'elle est sensible à la casse')

fprintf('Coqueluche\nGrippe\nRougeole\n') maladie = input('Maladie choisie: ', 's'); si est égal (maladie, 'Coqueluche') vacc =.85; %15 % de chance de contracter la maladie non vaccinée = 0,20; % 80 % de chance de contracter la maladie sinon si est égal (maladie, « grippe ») vaccin = 0,75; %25 % de chance de contracter la maladie non vaccinée = 0,31; %69 % de chance de contracter la maladie sinon si c'est égal (maladie, « rougeole ») vaccin = 0,97; %3 % de chance de contracter la maladie non vaccinée = 0,10; %90 % de chances de mettre fin à la maladie

Explication du code:

La fonction disp() imprime la déclaration à l'écran et elle imprime également les différentes options. La maladie sera attribuée en conséquence. Cette version ne prend actuellement pas en compte les entrées invalides. Une entrée non valide produira une erreur et arrêtera complètement le programme. Chaque maladie est associée à des valeurs vacc et unvacc. Ces valeurs ne sont PAS aléatoires. Nous avons obtenu ces valeurs en recherchant des statistiques sur les maladies.

Ensuite, nous devons demander à l'utilisateur s'il souhaite tester une population grande ou petite pour la maladie qu'il a choisie.

disp('Choisir la taille de la population.')

fprintf('20\n200\n') speed = input('Population choisie: ', 's'); if isequal(speed, '20') population_size = 20; elseif isequal(speed, '200') population_size = 200; finir

Explication du code

Cela imprime une déclaration à l'utilisateur et lui demande d'entrer la taille de la population qu'il souhaite tester. Cette version ne prend actuellement pas en compte les entrées invalides. Une entrée non valide produira une erreur et arrêtera complètement le programme. 20 a été choisi car il s'agit d'un échantillon de petite taille qui donne toujours une bonne idée de la façon dont l'infection se propage dans une petite population. 200 personnes ont été choisies comme option la plus large car 200 points tracés sur le graphique avaient à peine un chevauchement de points, de sorte que tout pouvait facilement être vu et distingué les uns des autres.

Ensuite, nous devons trouver la vitesse de la simulation.

disp('Choisir la vitesse de la simulation.')

fprintf('Rapide\nLente\n') speed = input('Vitesse choisie: ', 's'); if isequal(speed, 'Fast') sim_speed = 0; elseif isequal(speed, 'Slow') sim_speed = 0.25; finir

Explication du code

Ce processus était le même que pour obtenir le type de maladie et la taille de la population. Pour rapide, il n'y aura pas de pause. et pour lent, il y aura un décalage de 0,25 seconde dans la boucle for lors de l'exécution de la simulation.

Super! Maintenant, nous avons toutes les entrées de l'utilisateur dont nous avons besoin ! Passons à la collecte de données pour différents pourcentages de personnes non vaccinées.

Étape 13: Choisissez un % de personnes non vaccinées et calculez la moyenne des personnes non vaccinées et infectées pour le pourcentage choisi

Ce code est pour 0% des personnes non vaccinées.

% ------- %0 Non vaccinés ------------

per_infect_av_0 = ; pourcentage_of_unvacc_and_infec_av_0 = ; pour i = 1:20 out = infectionSim(unvacc, vacc, population_size, 0, 1, sim_speed); per_infect_av_0 = [per_infect_av_0, out(1, 1)]; pourcentage_of_unvacc_and_infec_av_0 = [percentage_of_unvacc_and_infec_av_0, out(1, 2)]; fin moyenne_infectée_0 = moyenne(per_infect_av_0); moyenne_unvacc_and_infec_0 = moyenne(percentage_of_unvacc_and_infec_av_0);

Explication du code:

La boucle for est exécutée 20 fois. La sortie de la fonction, infectionSim(), est stockée dans out. Chaque fois que la boucle for s'exécute, le pourcentage d'infectés dans la population totale est ajouté à la matrice, 'per_infect_av_0'. De plus, le pourcentage de non vaccinés et infectés est également ajouté à chaque fois dans la matrice « percentage_of_unvacc_and_infec_av_0 ». Dans les deux dernières lignes, ces deux matrices mentionnées ci-dessus sont ensuite moyennées et stockées dans des variables. Pour résumer, les pourcentages sont stockés pour chaque simulation, moyennés et représentés graphiquement. Monte Carlo est utilisé pour afficher la valeur moyenne de l'exécution d'une simulation et afficher le résultat. Pour nos besoins expérimentaux, nous choisissons d'exécuter la simulation 20 fois et de faire la moyenne de ces valeurs.

Défi:

Répétez l'opération pour tous les pourcentages que vous souhaitez tester ! Cela peut être fait en changeant les noms des variables en fonction des nombres de pourcentage. Nous avons testé 0 %, 5 %, 10 %, 20 %, 30 % et 50 %.

Indice:

La seule ligne qui doit être modifiée dans le code réel est

out = infectionSim(unvacc, vacc, population_size, 0, 1, sim_speed);

Remplacez le zéro par le pourcentage sous forme décimale. Par exemple, pour une simulation à 5 % de non vaccinés, le 0 doit être remplacé par 0,5.

Étape 14: Graphique: « La tendance de l'infection chez les non vaccinés vs. Vacciné pour une maladie spécifiée'

Il s'agit du code permettant de tracer un graphique de la tendance de l'infection chez les personnes non vaccinées par rapport aux personnes non vaccinées.

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]; pente = (average_infected_5-average_infected_0)/5; line_y = [average_infected_0, (pente*50)+average_infected_0]; ligne_x = [0, 50]; figure(2) plot(graph_mat_x, graph_mat_y); line(line_x, line_y, 'Couleur', 'rouge', 'LineStyle', '--'); title(['Tendance de la non-vaccination pour ', maladie]); xlabel('Pourcentage de non vaccinés initiaux'); ylabel('Pourcentage d'Infectés Final')

Explication du code

ligne 1: valeurs y attribuées aux moyennes des pourcentages d'infection

ligne 2: attribuer des valeurs x au pourcentage de pourcentage initial de non vaccinés

ligne 3: calculer la pente de 0% et 5%

ligne 4: stocker les valeurs y de la ligne. Il s'agit d'une continuation de la section 0 % à 5 %.

ligne 5: stocker les valeurs y de la ligne. Cette ligne s'étend sur toute la longueur du graphique.

ligne 6: créer une figure

ligne 7: tracer le graphique des valeurs x et y du pourcentage d'infectés, qui ne sont pas vaccinés.

ligne 8: tracer la ligne. Ceci est utilisé pour montrer qu'il n'augmente pas linéairement, mais exponentiellement.

ligne 9: Définir le titre du graphique.

ligne 10-11: Définir les étiquettes x et y pour le graphique.

Maintenant, vous devriez être en mesure de voir que plus le pourcentage de la population non vaccinée est élevé, plus le nombre d'infections est élevé. Vous verrez également que la plupart des points qui deviennent rouges sont des points verts, ce qui montre que le vaccin aide dans une certaine mesure ! J'espère que vous avez aimé ce tutoriel. Commentez si vous avez des questions !

Étape 15: Produit final: à quoi ressemble la simulation

Tout le code se trouve ici