Pentru a vă vaccina sau nu? un proiect privind observarea imunității turmei prin simularea bolilor: 15 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:45

Prezentare generală a proiectului:

Proiectul nostru explorează imunitatea turmei și speră să încurajeze oamenii să se vaccineze pentru a reduce ratele de infecție în comunitățile noastre. Programul nostru simulează modul în care o boală infectează o populație cu procente diferite de rate vaccinate și nevaccinate. Acesta arată imunitatea efectivului, arătând cum un număr crescut al populației vaccinate poate reduce numărul persoanelor afectate.

Modelăm acest lucru în Matlab folosind concepte ale teoriei graficelor. Teoria graficelor este un mod matematic de a reprezenta relațiile dintre obiecte. În teoria graficelor, graficele au vârfuri (sau noduri) conectate prin margini (sau linii). Pentru proiectul nostru, nodurile sunt persoanele în cauză, iar marginile sunt conexiunile lor. De exemplu, dacă două noduri sunt conectate cu o margine, atunci înseamnă că sunt „prieteni” sau au o formă de contact între ele. Acest contact este o modalitate de răspândire a bolii. Acesta este motivul pentru care am folosit teoria graficelor pentru a ne modela conceptul, deoarece am vrut să vedem cum se răspândește boala printre indivizii care sunt conectați într-o populație.

Proiectul nostru implică și metoda Monte Carlo. Metoda Monte Carlo sunt algoritmi care creează eșantionări repetate aleatorii pentru a primi rezultate numerice. În proiectul nostru, folosim această metodă pentru a rula simularea de mai multe ori schimbând procentul inițial nevaccinat pentru a vedea rata la care oamenii se infectează.

Tot codul proiectului este legat în partea de jos!

Credit PC:

Link Matlab către Teoria graficelor:

Pasul 1: Creați matricea de adiacență

Creați un nou script. Vom numi al nostru „infectionSim.m”.

Vom crea o variabilă „NUMOFPEOPLE”. Îl puteți atribui oricărei valori întregi. Acesta va reprezenta numărul de persoane din populația dvs.

De acum înainte, vom presupune că

NUMOFPEOPLE = 20;

Mai întâi începeți folosind funcțiile teoriei graficului Matlab pentru un grafic nedirecționat.

Dacă sunteți interesat să aflați mai multe, iată un link pentru a citi mai detaliat despre aceasta.

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

A creat o matrice de adiacență.

adjMatrix = zerouri (NUMOFPEOPLE);

Aceasta va crea o matrice pătrată de 0s. Fiecare rând din matrice este o persoană. Fiecare coloană din matrice este o persoană sau un prieten pe care persoana respectivă îl întâlnește pe tot parcursul zilei.

Vedeți Figura 100 (de mai sus) pentru a vă ajuta să vizualizați cum arată adjMatrix pentru 20 de persoane.

** Din acest moment vom presupune că NUMOFPEOPLE este egal cu 20. **

Puteți încerca să trasați această matrice de adiacență. Iată câteva informații suplimentare despre trasarea acestor tipuri de matrice.

Notă: Cum funcționează matricea de adiacență.

Ex:

% realizând matricea adiacentă

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]% reprezentare grafică g = grafic (a); % folosind funcția graficului (teoria graficelor) figura (1); h = complot (g);

Vedeți Figura 1 (de mai sus) pentru a vedea cum să adăugați margini în matricea de adiacență, utilizând codul din „Notă”.

Pasul 2: Creați relații

Acum că oamenii (vârfuri sau noduri) sunt create, trebuie să creăm o rețea de relații (linii sau margini ale graficului). Aceasta va simula modul în care oamenii interacționează și întâlnesc alți oameni pe parcursul unei zile.

Acest lucru se poate face în mai multe moduri. O modalitate de a finaliza această sarcină este de a atribui mai întâi un număr aleatoriu fiecărei persoane pentru a determina cu câte persoane va interacționa fiecare persoană într-o zi.

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

Acest lucru face ca o matrice de 1 cu 20 de numere întregi aleatorii să reprezinte numărul de interacțiuni pe care fiecare persoană le are pe zi. Coloanele acestei matrice ar fi numărul corespunzător fiecărei persoane. De exemplu, dacă atribuim minimumFriendsPersonCanHave = 2 și mostFriendsPersonCanHave = 5, am obține valori aleatorii între 2 și 5.

Aveți probleme cu randi ()? În terminal, tastați

ajuta randi

Apoi, realizăm o matrice randomizată (numită „allFriendsmatrix”) a modului în care fiecare persoană din populație este conectată / interacționează în cadrul populației.

tempMatrix = ;

număr = 0; allFriendsMatrix = ; pentru k = 1: NUMOFPEOPLE în timp ce lungimea (tempMatrix) ~ = numOfFriendsMatrix (k) count = count +1; temp = randi ([1, NUMOFPEOPLE]); tempMatrix (count) = temp; end clear each while length (tempMatrix) ~ = 9 tempMatrix = [tempMatrix, NaN]; end allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; număr = 0; Sfârșit

Explicație aprofundată a codului:

Mai întâi creăm o matrice temporară goală pentru a păstra lista prietenilor / interacțiunii fiecărei persoane. De asemenea, inițializăm numărătoarea, care ține doar evidența locului unde să lipească noua conexiune aleatorie în tempMatrix. Buclele pentru rulează de 20 de ori, astfel încât acest lucru să se întâmple pentru fiecare persoană din populație. Prima buclă while rulează până când tempMatrix-ul fiecărei persoane are aceeași lungime a numărului de interacțiuni atribuit aleatoriu. În această buclă, un număr aleatoriu corespunzător persoanei din populație este generat și plasat în tempMatrix. Deoarece lungimile fiecăruia dintre tempMatrixes sunt diferite, a trebuit să creăm unele valori NaN, astfel încât să putem concatena toate aceste tempMaticies toate într-o singură matrice („allFriendsMatrix”). A doua buclă while rezolvă această problemă adăugând NaN în fiecare tempMatrix. Bucla while a fost setată să ruleze de 9 ori, deoarece este un număr mai mare de 5, care era limita superioară a prietenilor cărora li se poate atribui o persoană. Valoarea „9” este variabilă și poate / trebuie modificată atunci când „mostFriendsPersonCanHave” este mai mare de 9. Ultimele trei linii de cod (cu excepția sfârșitului) adaugă tempMatrix în următorul rând al „allFriendsMatrix”. Apoi, șterge tempMatrix și contează pentru următoarea persoană.

Ieșire

Așa ar trebui să arate ieșirea pentru prima rundă prin bucla for (înainte de ultimele trei linii).

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

Apoi, adăugați aceste relații la adjMatrix.

pentru fiecare rând = 1: NUMOFPEOPLE

for eachCol = 1: 9 if isnan (allFriendsMatrix (eachRow, eachCol)) == 0 adjMatrix (eachRow, allFriendsMatrix (eachRow, eachCol)) = 1; adjMatrix (allFriendsMatrix (eachRow, eachCol), eachRow) = 1; sfârșit sfârșit sfârșit

Explicarea codului

Această buclă dublă pentru trece prin fiecare rând și coloană din „allFriendsMatrix”. Instrucțiunea if va rula pentru toate valorile care nu sunt „NaN”. Practic va crea marginile sau liniile graficului. Așadar, prima linie pe care o va face este persoana 1 la persoana 16 și persoana 16 la persoana 1. Deoarece nu este direcționată, trebuie schimbată 1 pentru ambele! Nu putem avea doar marginea 1 la 16 și nu 16 la 1. Ele trebuie să fie simetrice pentru ca aceasta să ruleze corect în Matlab.

În simularea noastră, am stabilit că oamenii nu pot interacționa cu ei înșiși. Când am randomizat valorile, există o șansă ca matricea noastră adiacentă să aibă aceste erori.

Să remediem acest lucru cu următorul cod:

pentru fiecare = 1: NUMOFPEOPLE

adjMatrix (fiecare, fiecare) = 0; Sfârșit

Explicarea codului

Aceasta pentru buclă asigură faptul că persoana 1 nu este conectată la persoana 1, persoana 2 nu este conectată la persoana 2, etc, făcându-le pe toate 0. După cum puteți vedea mai jos în secțiunea de ieșire, avem diagonala pătratului matricea din stânga sus în dreapta jos sunt toate 0.

Ieșire

Aceasta este ultima matrice adjMatrix pentru această simulare curentă. Aceasta reprezintă toate liniile din grafic (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

Vedeți Figura 2 pentru a vedea graficul „adjMatrix”.

Pasul 3: Adăugați statistici de boală

Acum că programul dvs. poate crea un grafic cu un set de persoane aleatorii și poate crea relații aleatorii, trebuie să introducem informațiile sau statisticile bolii pentru a vedea cum aceste interacțiuni dintr-o populație pot crește sau reduce infecția.

Creați aceste variabile:

unvacc% tip: dublu; procent de șanse ca persoanele nevaccinate să nu se îmbolnăvească

vacc% tip: dublu; procentaj de șanse ca persoanele vaccinate să nu primească boala unvacc_perc% tip: dublu; procentul populației nevaccinate init_infect% tip: int; procentul populației vaccinate

În continuare trebuie să facem câteva calcule.

Vom face un „infectionMat” care este o matrice 3 * NUMOFPEOPLE.

vacc_perc = 1-unvacc_perc;

infectionMat = nan (3, NUMOFPEOPLE); număr = rundă (vacc_perc * NUMOFPEOPLE); infectionMat (1, 1: număr) = vacc; infectionMat (1, număr + 1: sfârșit) = unvacc; infectionMat (2, 1: end) = 0; infectionMat (2, 1: init_infect) = 1;

Explicarea codului

linia 1: Procentul populației nevaccinate calculate

linia 2: creați o matrice de 3 * N de persoane

linia 3: aflați numărul de persoane vaccinate din procentul vaccinat

linia 4: pentru persoanele vaccinate, acordați-le o imunitate asociată cu administrarea vaccinului. Această valoare este atribuită pe baza cercetărilor despre boală.

linia 5: pentru restul populației (persoane nevaccinate), acordați-le procentul de imunitate. Această valoare este atribuită pe baza cercetărilor despre boală.

linia 6: setați inițial toți oamenii ca neinfectați.

linia 7: pentru numărul de persoane infectate inițial, completați primele două coloane în consecință.

Acum, că am stabilit toți parametrii pentru simularea bolii, vom identifica șansa dacă persoana (atât vaccinată, cât și nevaccinată) se infectează. Acest lucru se face în pasul următor prin atribuirea de valori aleatorii între 0 și 1 fiecărei persoane din al treilea rând al acestui „infectionMat”.

Pasul 4: Randomizați șansa ca o persoană vaccinată și nevaccinată să se poată infecta

Apoi, atribuiți fiecărei persoane un număr aleatoriu, acesta va fi folosit mai târziu pentru a determina dacă persoana respectivă se infectează sau nu.

pentru w = 1: lungime (infectionMat)

infectionMat (3, w) = rand; Sfârșit

Explicarea codului

Aceasta pentru buclă se ocupă de al treilea rând al „infectionMat” creat în ultimul pas. „rand” atribuie o valoare între 0 și 1 fiecărui index al rândului 3.

Ieșire

infectionMat este acum complet! Acest lucru sa întâmplat cu o populație cu 100% vaccinare și 1 persoană infectată inițial.

infectionMat =

Coloane de la 1 la 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.835 000 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

rândul 1: Procent de șanse să NU se îmbolnăvească de boală

rândul 2: infectat sau neinfectat (valoare booleană)

rândul 3: numărul utilizat pentru a verifica dacă o persoană care nu este infectată se infectează dacă întâlnește o persoană infectată. Dacă persoana neinfectată întâlnește persoana infectată, acest număr este mai mare decât numărul din rândul 1 (pentru aceeași coloană), atunci acestea sunt infectate. Vom codifica această funcționalitate la pasul 7.

Pasul 5: Creați matrici ale persoanelor care sunt nevaccinate și infectate din informațiile inițiale

Creați 2 matrice numite „matrixUnvacc” și „matrixInfected” care stochează toate persoanele infectate din infectionMat. Aceasta va fi utilizată astfel încât să putem codifica graficul celor care sunt infectați, nevaccinați sau vaccinați, contribuind la vizualizarea impactului persoanelor nevaccinate versus vaccinate.

clar fiecare

matrixInfected = ; matrixUnvacc = ; pentru h = 1: lungime (infectionMat) dacă infectionMat (1, h) == unvacc matrixUnvacc = [matrixUnvacc, h]; end end for person = 1: NUMOFPEOPLE if infectionMat (2, person) == 1 matrixInfected = [matrixInfected, person]; sfârșit sfârșit

Explicarea codului

Creați două matrice goale pentru a stoca numărul persoanelor care sunt nevaccinate și respectiv infectate. Ambele pentru bucle rulează de 20 de ori și dacă instrucțiunea if este îndeplinită, atunci numărul este adăugat la matricea corectă.

Ieșire

matrixUnvacc =

matrixInfected =

[1]

Pasul 6: Complotați graficul inițial

Urmează să trasăm matricea de adiacență.

g = grafic (adjMatrix);

figura (1) p = grafic (g, 'NodeColor', 'b', 'MarkerSize', 7); highlight (p, matrixUnvacc, 'NodeColor', 'g') highlight (p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc * 100; title (['Procentul de persoane nevaccinate:', num2str (title_unvacc), '%']); pauză (viteză)

Explicarea codului

Teoria graficelor în Matlab a încorporat funcții. Când folosim funcția graph (), putem traduce „adjMatrix” într-un grafic real nedirecționat. Apoi, trebuie să creăm un complot folosind funcția plot () pentru a vedea de fapt cum arată. Am setat acest grafic () la o variabilă, astfel încât să putem manipula și schimba culorile graficului mai ușor pe parcursul simulării. Toate persoanele (sau nodurile) sunt setate inițial la culoarea „albastru”. Apoi, toate persoanele nevaccinate sunt setate la culoarea „verde”. Persoanele infectate sunt apoi setate la culoarea „roșu”. Titlul este stabilit în funcție de valoarea procentuală a persoanelor nevaccinate care sunt testate. Funcția pause () oprește temporar executarea MatLab. Trecem prin viteza variabilă care este răspândită, care este calculată în secunde.

Vedeți imaginea (de mai sus) pentru a vedea un grafic aleatoriu codat în culori.

Aflați mai multe despre funcția de evidențiere () în MatLab.

Pasul 7: Simulați progresia infecției

În continuare, trebuie să ne dăm seama cine se infectează după interacțiuni (înregistrate în adjMatrix) și să actualizăm graficul atunci când cineva se infectează.

Utilizați adjMatrix pentru a determina ce persoane sunt infectate după interacțiunile lor cu oamenii într-o zi.

pentru fiecare rând = 1: lungime (adjMatrix)

if infectionMat (2, eachRow) == 1 for eachCol = 1: length (adjMatrix) if adjMatrix (eachRow, eachCol) == 1% eachRow = persoana% eachCol = prietenul său% prietenul fiecărei persoane și vezi dacă sunt infectați. if infectionMat (3, eachCol)> infectionMat (1, eachCol) infectionMat (2, eachCol) = 1; evidențiați (p, fiecareCol, „NodeColor”, „r”) pauză (viteză) capăt sfârșit

Bucla pentru bucle prin fiecare persoană. Se verifică dacă persoana este infectată, va verifica fiecare dintre persoanele / prietenul cu care a interacționat și va verifica dacă nivelul de imunitate al prietenului a fost mai mare decât puterea bolii. Aici intră în joc „infectionMat” pe care l-am creat mai devreme. Primul și al treilea rând al fiecărei coloane ale prietenului sunt comparate și dacă al treilea rând este mai mare, înseamnă că prietenul nu avea o imunitate suficient de mare pentru a scăpa de boală și, în cele din urmă, se infectează. De asemenea, schimbăm culoarea folosind highlight () în roșu dacă se infectează.

Acum, codul dvs. pentru simulare ar trebui să funcționeze! și pentru orice dimensiune a populației, schimbați NUMOFPEOPLE!

Pasul 8: Utilizați teoria Monte Carlo

Pentru a face acest pas mai departe și pentru a extrage date din simulatorul nostru („infectionSim.m”), am dorit să calculăm și să reprezentăm grafic tendința în procente de persoane nevaccinate care s-au infectat și procentul persoanelor vaccinate care s-au infectat. Ipotezăm că procentul persoanelor vaccinate care s-au infectat ar trebui să fie mult mai mic decât procentul persoanelor nevaccinate care s-au infectat.

Pasul 9: Faceți fișierul („infectionSim.m”) cu simularea într-o funcție

Pentru a rula Monte Carlo, am dori să rulăm simularea de mai multe ori și să acumulăm date, astfel încât să o putem folosi pentru a grafica procentele de persoane care s-au infectat.

Funcția ar putea fi configurată astfel:

ieșire funcție = infectionSim (unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect, speed)

Comentează variabilele din simulare, deoarece acum le trimiți prin fișierul principal (vom începe să scriem acest lucru la pasul 12):

unvacc, vacc, NUMOFPEOPLE, unvacc_perc, init_infect

Noua variabilă

viteză

va fi atribuit în fișierul principal (Monte_Carlo.m).

Notă: Nu uitați sfârșitul din partea de jos a fișierului funcției pentru a termina funcția!

Pasul 10: Calculați procentajul persoanelor nevaccinate și vaccinate care s-au infectat

Acesta calculează procentul de persoane nevaccinate care s-au infectat. Acest cod se află în partea de jos a fișierului „infectionSim.m”.

number_of_unvacc = 0;

number_of_infec_unvacc = 0; % calculează procentul de persoane nevaccinate care s-au infectat pentru x = 1: lungime (infectionMat) dacă infectionMat (1, x) == unvacc number_of_unvacc = number_of_unvacc + 1; încheie dacă 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;

Explicarea codului

În bucla for, aceasta se va bucla de NUMOFPEOPLE ori. De fiecare dată când numărul din infectionMat corespunde numărului unvacc (adică 0,95 == 0,95), atunci numărul persoanelor nevaccinate va crește cu 1. De fiecare dată numărul din infectionMat corespunde numărului unvacc și sunt infectați, numărul persoanelor infectate și nevaccinate crește cu 1. Ultima linie împarte numărul persoanelor infectate, nevaccinate la numărul total de persoane nevaccinate. Apoi procentul este calculat din aceasta.

Provocare:

Încercați să calculați procentul de persoane vaccinate vaccinate! (Sugestie: este foarte similar cu acest cod de mai sus, cu toate acestea unele variabile sunt modificate și numele sunt ajustate.)

În continuare se calculează procentul de persoane infectate pe baza populației totale:

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

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

Explicarea codului

Suma cumulativă este calculată folosind al doilea rând al infectionMat, care stochează 1 și 0, în funcție de persoana respectivă sau nu. Deoarece funcția cumsum () redă o matrice, luăm ultima valoare din matrice ('pre_per_infect (1, NUMOFPEOPLE)'), care ar trebui să fie suma reală a tuturor valorilor din 'infectionMat (2,:)'. Împărțind suma la NUMOFPEOPLE și înmulțind-o cu 100, obținem procentul final de infectați din populația totală.

Pasul 11: Creați o variabilă de ieșire în funcția dvs. „infectionSim.m”

output = [per_infect, percent_of_unvacc_and_infec, percent_of_vacc_and_infec];

Explicarea codului

Stocați aceste informații în ieșire, care vor fi trimise înapoi în main (Monte_Carlo.m) atunci când funcția este apelată și se execută. Aceste date sunt utilizate pentru a grafica punctele procentuale din persoanele infectate dintre cei care sunt vaccinați și nevaccinați.

Funcția dvs. „infectionSim.m” ar trebui să fie realizată acum! Cu toate acestea, nu va rula pentru că mai trebuie să scriem principalul!

Pasul 12: Creați un meniu pentru a obține condițiile inițiale ale simulării de la utilizator

Amintiți-vă cum am spus variabila

viteză

ar fi creat și trecut prin funcția principală? Trebuie să obținem valorile pentru a trece la funcție. Rețineți, ordinea valorilor la apelarea funcției contează!

Începeți prin a cere utilizatorului să introducă câteva răspunsuri în terminal.

> Alegeți o boală. Rețineți că este diferențiat de majuscule și minuscule >> Pertusis >> Gripă >> Rujeolă >> Boală aleasă: Gripă >> Alegeți dimensiunea populației. >> 20 >> 200 >> Populația aleasă: 20 >> Alegeți viteza de simulare. >> Rapid >> Lent >> Viteza aleasă: Rapid

Acest cod de mai jos îl întreabă pe utilizator în ce boală dorește să se uite.

disp („Alegeți o boală. Rețineți că este sensibil la majuscule”)

fprintf ('Pertussis / nFlu / nMeasles) boala = input (' Boala aleasă: ',' s '); dacă este inegal (boală, „pertussis”) vacc =.85; % 15 la sută șanse de îmbolnăvire a bolii = 0,20; % 80 la sută șanse de îmbolnăvire altfel dacă vaccinul este inegal (boală, „gripă”) =.75; % 25 la sută șanse de îmbolnăvire a bolii = 0,31; % 69 la sută șanse de îmbolnăvire altfel dacă vaccinul este inegal (boală, „Rujeolă”) =.97; % 3 la sută șanse de îmbolnăvire a bolii = 0,10; % 90 la sută șanse de a lua sfârșitul bolii

Explicarea codului:

Funcția disp () imprimă declarația pe ecran și tipărește, de asemenea, diferitele opțiuni. Boala va fi atribuită în consecință. În prezent, această versiune nu ia în considerare intrările nevalide. Intrarea nevalidă va produce o eroare și va opri complet programul. Fiecare boală are valori de vaccin și unvacc asociate cu aceasta. Aceste valori NU sunt aleatorii. Aceste valori le-am obținut din cercetarea statisticilor despre boli.

În continuare, trebuie să întrebăm utilizatorul dacă dorește să testeze o populație mare sau mică pentru boala aleasă.

disp („Alegeți dimensiunea populației.”)

fprintf ('20 / n200 / n ') speed = input (' Populația aleasă: ',' s '); dacă este egal (viteză, '20') populație-dimensiune = 20; elseif isequal (speed, '200') population_size = 200; Sfârșit

Explicarea codului

Acest lucru imprimă o declarație către utilizator și îi cere utilizatorului să introducă ce dimensiune a populației dorește să testeze. În prezent, această versiune nu ia în considerare intrările nevalide. Intrarea nevalidă va produce o eroare și va opri complet programul. 20 a fost ales deoarece este o dimensiune mică a eșantionului, care oferă încă o idee bună despre modul în care infecția se răspândește într-o populație mică. 200 de persoane au fost alese ca opțiunea mai mare, deoarece 200 de puncte trasate pe grafic abia aveau suprapuneri de puncte, astfel încât totul putea fi ușor văzut și distins unul de celălalt.

Apoi, trebuie să găsim viteza simulării.

disp („Alegeți viteza de simulare.”)

fprintf ('Fast / nLent / n') speed = input ('Viteza aleasă:', 's'); dacă este egal (viteză, 'Rapid') sim_speed = 0; elseif isequal (speed, 'Slow') sim_speed = 0.25; Sfârșit

Explicarea codului

Acest proces a fost același cu obținerea tipului de boală și a dimensiunii populației. Pentru repede, nu va exista nicio pauză. iar pentru lent, va exista un decalaj de 0,25 secunde în bucla for atunci când rulați simularea.

Grozav! Acum avem toate intrările de la utilizatorul de care avem nevoie! Să trecem la colectarea datelor pentru diferite procente de persoane nevaccinate.

Pasul 13: alegeți un procent de persoane nevaccinate și calculați media persoanelor nevaccinate și infectate pentru procentajul ales

Acest cod este pentru 0% dintre persoanele nevaccinate.

% -------% 0 nevaccinat ------------

per_infect_av_0 = ; procent_de_unvacc_ și_infec_av_0 = ; pentru i = 1:20 out = infectionSim (unvacc, vacc, population_size, 0, 1, sim_speed); 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)]; end average_infected_0 = medie (per_infect_av_0); average_unvacc_and_infected_0 = medie (procent_de_unvacc_and_infec_av_0);

Explicarea codului:

Bucla for este rulată de 20 de ori. Ieșirea din funcție, infectionSim (), este stocată în afară. De fiecare dată când bucla for rulează, procentul de infectați din populația totală este adăugat la matrice, „per_infect_av_0”. În plus, procentul de nevaccinați și infectați este, de asemenea, adăugat de fiecare dată în matricea „percentual_of_unvacc_and_infec_av_0”. În ultimele două linii, aceste două matrice menționate mai sus sunt apoi mediate și stocate în variabile. Pentru a rezuma, procentele sunt stocate pentru fiecare simulare, mediată și grafică. Monte Carlo este folosit pentru a arăta valoarea medie a rularii unei simulări și a rezultatului. În scopurile noastre experimentale, alegem să rulăm simularea de 20 de ori și să mediam aceste valori.

Provocare:

Repetați pentru toate procentele pe care doriți să le testați! Acest lucru se poate face prin schimbarea numelor variabilelor în funcție de numerele procentuale. Am testat pentru 0%, 5%, 10%, 20%, 30% și 50%.

Aluzie:

Singura linie care trebuie modificată în codul real este

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

Schimbați zero la procent în formă zecimală. De exemplu, pentru 5% simulare nevaccinată, 0 ar trebui înlocuit cu 0,5.

Pasul 14: Grafic: „Tendința infecției în Vs. nevaccinate. Vaccinat pentru boala specificată"

Acesta este codul pentru a face un grafic al tendinței infecției la persoanele nevaccinate față de persoanele nevaccinate.

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]; panta = (mediu_infectat_5-mediu_infectat_0) / 5; line_y = [average_infected_0, (panta * 50) + average_infected_0]; line_x = [0, 50]; figura (2) grafic (graph_mat_x, graph_mat_y); line (line_x, line_y, 'Color', 'red', 'LineStyle', '-'); titlu ([„Tendință în nevaccinare pentru”, boală]); xlabel („Procentul inițialului nevaccinat”); ylabel („Procentaj de infectate finale”)

Explicarea codului

linia 1: valori atribuite y mediilor procentului de infectați

linia 2: valori atribuite x procentului procentului inițial nevaccinat

linia 3: calculați panta de 0% și 5%

linia 4: stocați valorile y ale liniei. Aceasta este o continuare a secțiunii de la 0% la 5%.

linia 5: stocați valorile y ale liniei. Această linie se întinde pe lungimea graficului.

linia 6: creați figura

linia 7: trasați graficul valorile x și y ale procentului de infectați, care nu sunt vaccinați.

linia 8: trasați linia. Acesta este folosit pentru a arăta că nu crește liniar, ci exponențial.

linia 9: Setați titlul pentru grafic.

linia 10-11: Setați etichetele x și y pentru grafic.

Acum ar trebui să puteți vedea că, cu cât procentul mai mare al populației nevaccinate, cu atât este mai mare cantitatea de infecție. Veți vedea, de asemenea, că majoritatea punctelor care devin roșii sunt puncte verzi, arătând că vaccinul ajută într-o oarecare măsură! Sper că ți-a plăcut acest tutorial. Comentează dacă ai întrebări!

Pasul 15: Produsul final: Cum arată Simularea

Tot codul poate fi găsit aici