Да се ваксинирате или не? проект за наблюдение на имунитета на стадото чрез симулация на болестта: 15 стъпки

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:53

Преглед на проекта:

Нашият проект изследва стадния имунитет и се надява да насърчи хората да се ваксинират, за да намалят процента на инфекция в нашите общности. Нашата програма симулира как болестта заразява население с различни проценти ваксинирани и неваксинирани проценти. Той показва имунитет на стадото, като показва как увеличен брой на ваксинираното население може да намали броя на засегнатите хора.

Ние моделираме това в Matlab, използвайки концепции за теория на графовете. Теорията на графиките е математически начин за представяне на връзките между обектите. В теорията на графовете графиките имат върхове (или възли), свързани с ребра (или линии). За нашия проект възлите са съответните индивиди, а ръбовете са техните връзки. Например, ако два възела са свързани с ръб, това означава, че те са „приятели“или имат някаква форма на контакт помежду си. Този контакт е начин за разпространение на болестта. Ето защо използвахме теорията на графиките, за да моделираме нашата концепция, защото искахме да видим как болестта се разпространява сред индивиди, които са свързани в популация.

Нашият проект включва и метода Монте Карло. Методът Монте Карло са алгоритми, които създават многократни случайни извадки, за да получат числени резултати. В нашия проект ние използваме този метод, за да проведем нашата симулация няколко пъти, променяйки процента на първоначалната неваксинирана, за да видим скоростта, с която хората се заразяват.

Целият код на проекта е свързан в долната част!

Кредит за компютър:

Matlab връзка към теорията на графиките:

Стъпка 1: Създайте матрица на съседство

Създайте нов скрипт. Ще наречем нашата „инфекцияSim.m“.

Ще създадем променлива „NUMOFPEOPLE“. Можете да го присвоите на всяка цяло число. Това ще представлява броя на хората във вашето население.

Отсега нататък ще приемаме, че

NUMOFPEOPLE = 20;

Първо започнете, като използвате функциите на теорията на графиките на Matlab за ненасочена графика.

Ако се интересувате да научите повече, ето линк, за да прочетете по -подробно за него.

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

Създадена е матрица за съседство.

adjMatrix = нули (NUMOFPEOPLE);

Това ще създаде квадратна матрица от 0s. Всеки ред в матрицата е човек. Всяка колона в матрицата е човек или приятел, който лицето среща през целия ден.

Вижте Фигура 100 (по -горе), за да визуализирате как изглежда adjMatrix за 20 души.

** От този момент нататък ще приемем, че NUMOFPEOPLE е равно на 20. **

Можете да опитате да начертаете тази матрица на съседство. Ето малко повече информация за начертаването на този тип матрици.

Забележка: Как работи матрицата на съседство.

Пример:

%създаване на съседната матрица

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] %начертаване g = графика (а); %, използвайки графичната функция (теория на графиките) фигура (1); h = парцел (g);

Вижте Фигура 1 (по -горе), за да видите как да добавите ръбове в матрицата на съседство, като използвате кода в "Забележка".

Стъпка 2: Създайте отношения

Сега, когато хората (върхове или възли) са създадени, трябва да създадем мрежа от отношения (линии или ръбове на графиката). Това ще симулира как хората си взаимодействат и се срещат с други хора през целия ден.

Това може да стане по много начини. Един от начините за изпълнение на тази задача е първо да присвоите произволно число на всеки човек, за да определите с колко хора всеки човек ще взаимодейства за един ден.

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

Това прави матрица 1 на 20 от случайни цели числа, представляващи броя взаимодействия, които всеки човек има на ден. Колоните на тази матрица биха били числото, съответстващо на всеки човек. Например, ако присвоим най -малкоFriendsPersonCanHave = 2 и mostFriendsPersonCanHave = 5, ще получим случайни стойности между 2 и 5.

Имате проблеми с randi ()? В терминала въведете

помогни на Ранди

След това правим рандомизирана матрица (наречена "allFriendsmatrix") за това как всеки човек от популацията е свързан/взаимодейства в рамките на популацията.

tempMatrix = ;

брой = 0; allFriendsMatrix = ; for k = 1: NUMOFPEOPLE while length (tempMatrix) ~ = numOfFriendsMatrix (k) count = count +1; temp = randi ([1, NUMOFPEOPLE]); tempMatrix (брой) = temp; край изчистване на всеки докато length (tempMatrix) ~ = 9 tempMatrix = [tempMatrix, NaN]; край allFriendsMatrix = [allFriendsMatrix; tempMatrix]; tempMatrix = ; брой = 0; край

Подробно обяснение на кода:

Първо създаваме празна временна матрица, която да съдържа списък с приятели/взаимодействие на всеки човек. Ние също инициализираме count, който просто следи къде да поставите новата произволна връзка в tempMatrix. Циклите for се изпълняват 20 пъти, така че това се случва за всеки отделен човек в популацията. Първият цикъл while работи, докато tempMatrix на всеки човек е същата дължина на произволно зададения брой взаимодействия. В този цикъл се генерира случайно число, съответстващо на човек в популацията, и се поставя в tempMatrix. Тъй като дължините на всяка от tempMatrixes са различни, трябваше да създадем някои NaN стойности, така че да можем да обединим всички тези tempMaticies в една матрица ('allFriendsMatrix'). Вторият цикъл while решава този проблем, като добавя NaN във всяка tempMatrix. Цикълът while беше настроен да работи 9 пъти, защото е число, по -голямо от 5, което беше горната граница на приятели, на които човек може да бъде присвоен. Стойността „9“е променлива и може/трябва да се промени, когато „mostFriendsPersonCanHave“е по -голямо от 9. Последните три реда код (с изключение на края) добавят tempMatrix в следващия ред на „allFriendsMatrix“. След това изчиства tempMatrix и брои за следващия човек.

Изход

Ето как трябва да изглежда изходът за първото изпълнение през цикъла for (преди последните три реда).

tempMatrix = 16 8 17 16 13 NaN NaN NaN NaN

allFriendsMatrix =

16 8 17 16 13 NaN NaN NaN NaN NaN 8 8 2 7 11 NaN NaN NaN NaN 10 13 NaN NaN NaN NaN NaN NaN NaN NaN 11 17 2 NaN NaN NaN NaN NaN NaN NaN 10 12 NaN NaN 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 NaN 3 8 17 17 14 NaN NaN NaN NaN NaN 20 19 3 NaN 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 NaN 2 6 14 3 13 NaN NaN NaN NaN 8 16 14 8 NaN NaN NaN NaN NaN NaN 7 7 NaN NaN NaN NaN NaN NaN NaN NaN 19 10 9 NaN 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 NaN 1 7 NaN NaN NaN NaN NaN NaN NaN NaN 16 7 13 10 1 NaN NaN NaN NaN NaN

След това добавете тези отношения към adjMatrix.

за всеки ред = 1: NUMOFPEOPLE

for eachCol = 1: 9 if isnan (allFriendsMatrix (eachRow, eachCol)) == 0 adjMatrix (eachRow, allFriendsMatrix (eachRow, eachCol)) = 1; adjMatrix (allFriendsMatrix (eachRow, eachCol), eachRow) = 1; край край край

Код Обяснение

Този цикъл двойно for преминава през всеки ред и колона на 'allFriendsMatrix'. Операторът if ще се изпълнява за всички стойности, които не са „NaN“. По принцип той ще създаде ръбовете или линиите на графиката. Така че първият ред, който ще направим, е човек 1 на човек 16 и човек 16 на човек 1. Тъй като не е насочен, 1 трябва да се промени и за двамата! Не можем просто да имаме ръба 1 до 16, а не 16 към 1. Те трябва да са симетрични, за да работи правилно в Matlab.

В нашата симулация установихме, че хората не могат да си взаимодействат. Когато рандомизираме стойностите, има вероятност съседната ни матрица да има тези грешки.

Нека поправим това със следния код:

за всеки = 1: NUMOFPEOPLE

adjMatrix (всеки, всеки) = 0; край

Код Обяснение

Този цикъл for гарантира, че човек 1 не е свързан с човек 1, човек 2 не е свързан с човек 2 и т.н., като ги прави всички 0. Както можете да видите по -долу в раздела за изход, имаме диагонала на квадрата матрицата от горния ляв до долния десен ъгъл са всички 0.

Изход

Това е последният adjMatrix за настоящата симулация. Това отчита всички линии в графиката (Фигура 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

Вижте Фигура 2, за да видите графиката на 'adjMatrix'.

Стъпка 3: Добавете статистика за заболяванията

Сега, когато вашата програма може да създаде графика с набор от случайни хора и да създаде случайни връзки, трябва да въведем информацията или статистиката за болестта, за да видим как тези взаимодействия в рамките на популация могат да увеличат или намалят инфекцията.

Създайте тези променливи:

unvacc %тип: двойно; процент шанс неваксинираните хора да не получат болестта

ваксина %тип: двойна; процент шанс ваксинираните хора да не получат болестта unvacc_perc %тип: двойно; процент не ваксинирано население init_infect %тип: int; процент от ваксинираното население

След това трябва да направим някои изчисления.

Ще направим „infectionMat“, който е 3*NUMOFPEOPLE матрица.

vacu_perc = 1-unvacc_perc;

инфекцияMat = nan (3, NUMOFPEOPLE); номер = кръг (ваксина_перс * NUMOFPEOPLE); инфекцияMat (1, 1: число) = ваксина; инфекцияMat (1, число+1: край) = unvacc; инфекцияMat (2, 1: край) = 0; инфекцияMat (2, 1: init_infect) = 1;

Код Обяснение

ред 1: Изчислява се процентът на неваксинираното население

ред 2: създайте матрица с 3*N брой хора

ред 3: разберете броя на хората, ваксинирани от процента ваксинирани

ред 4: за ваксинираните хора им дайте имунитет, свързан с поставянето на ваксината. Тази стойност се определя въз основа на изследвания за болестта.

ред 5: за останалата част от населението (неваксинирани лица) им дайте процента имунитет. Тази стойност се определя въз основа на изследвания за болестта.

ред 6: първоначално настройте всички хора да не са заразени.

ред 7: за броя на първоначално заразените хора попълнете съответно първите няколко колони.

Сега, след като сме задали всички параметри за симулация на болестта, ще разпределим на случаен принцип шанса дали лицето (и ваксинирано, и неваксинирано) да се зарази. Това се прави в следващата стъпка чрез присвояване на случайни стойности между 0 и 1 на всеки човек в третия ред на тази „инфекцияMat“.

Стъпка 4: Рандомизирайте шанса ваксиниран и неваксиниран човек да бъде заразен

След това задайте на всеки човек произволно число, което ще бъде използвано по -късно, за да се определи дали лицето се заразява или не.

за w = 1: дължина (инфекцияMat)

инфекцияMat (3, w) = rand; край

Обяснение на кода

Този цикъл for се занимава с третия ред на „инфекциятаMat“, създаден в последната стъпка. 'rand' присвоява стойност между 0 и 1 на всеки индекс на ред 3.

Изход

инфекциятаMat вече е завършена! Това беше при популация със 100% ваксинация и 1 човек първоначално заразен.

инфекцияMat =

Колони от 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.0869 0.5489 0.3177 0.9927 0.7236 0.7172 0.9766 0.4270 0.9130 0.8973 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

ред 1: Процент шанс да НЕ получи болестта

ред 2: Заразени или незаразени (логическа стойност)

ред 3: Номер, използван за проверка дали човек, който не е заразен, се заразява, ако срещне заразен човек. Ако незаразено лице срещне заразено лице, това число е по -голямо от числото в ред 1 (за същата колона), тогава то е заразено. Ще кодираме тази функционалност в стъпка 7.

Стъпка 5: Създайте матрици на хора, които са неваксинирани и заразени от първоначалната информация

Създайте 2 матрици, наречени "matrixUnvacc" и "matrixInfected", които съхраняват всички заразени хора от инфекцияMat. Това ще бъде използвано, за да можем да оцветим цветно графиката на тези, които са заразени, неваксинирани или ваксинирани, което помага да се визуализира въздействието на неваксинираните спрямо ваксинираните индивиди.

изчисти всеки

matrixInfected = ; matrixUnvacc = ; за h = 1: дължина (инфекцияMat), ако инфекцияMat (1, h) == unvacc matrixUnvacc = [matrixUnvacc, h]; краен край за човек = 1: NUMOFPEOPLE, ако инфекцияMat (2, човек) == 1 matrixInfected = [matrixInfected, лице]; край край

Код Обяснение

Създайте две празни матрици, за да съхранявате съответно броя на неваксинираните и заразените хора. И двата цикъла се изпълняват 20 пъти и ако операторът if е изпълнен, тогава номерът се добавя към правилната матрица.

Изход

matrixUnvacc =

matrixInfected =

[1]

Стъпка 6: Начертайте началната графика

След това ще начертаем матрицата на съседство.

g = графика (adjMatrix);

фигура (1) p = график (g, 'NodeColor', 'b', 'MarkerSize', 7); highlight (p, matrixUnvacc, 'NodeColor', 'g') highlight (p, matrixInfected, 'NodeColor', 'r') title_unvacc = unvacc_perc*100; заглавие (['Процент на хората, които не са ваксинирани:', num2str (title_unvacc), '%']); пауза (скорост)

Обяснение на кода

Теорията на графите в Matlab има вградени функции. Когато използваме функцията graph (), можем да преобразуваме „adjMatrix“в действителна ненасочена графика. След това трябва да създадем график, използвайки функцията plot (), за да видим всъщност как изглежда. Ние задаваме този plot () на променлива, за да можем по -лесно да манипулираме и променяме цветовете на графиката по време на симулацията. Всички хора (или възли) първоначално са настроени на цвят „син“. След това всички неваксинирани хора се настройват на цвят „зелен“. След това заразените хора се настройват на цвят „червен“. Заглавието се определя според определената процентна стойност на неваксинираните хора, които се тестват. Функцията pause () временно спира изпълнението на MatLab. Преминаваме през променливата скорост, която се разпространява и се изчислява за секунди.

Вижте снимката (по -горе), за да видите произволно цветно кодирана графика.

Научете повече за функцията highlight () в MatLab.

Стъпка 7: Симулирайте прогресията на инфекцията

След това трябва да разберем кой се заразява след взаимодействията (записани в adjMatrix) и да актуализираме графиката, когато някой се зарази.

Използвайте adjMatrix, за да определите кои хора са заразени след взаимодействието им с хора за един ден.

за всекиRow = 1: дължина (adjMatrix)

if инфекцияMat (2, eachRow) == 1 за eachCol = 1: дължина (adjMatrix), ако adjMatrix (eachRow, eachCol) == 1 % eachRow = човекът % eachCol = негов приятел % приятел на всеки човек и вижте дали са заразени. ако инфекцияMat (3, eachCol)> инфекцияMat (1, eachCol) инфекцияMat (2, eachCol) = 1; подчертаване (p, eachCol, 'NodeColor', 'r') пауза (скорост) край край край край край

Цикълът for циклично преминава през всеки човек. Той проверява, че ако човекът е заразен, той ще провери всеки от хората/приятелите, с които са общували, и ще провери дали имунитетът на приятеля е по -голям от силата на болестта. Тук се появява създадената по -рано „инфекцияMat“. Първият и третият ред на всяка колона на приятеля се сравняват и ако третият ред е по -голям, това означава, че приятелят не е имал достатъчно висок имунитет, за да избяга от болестта и в крайна сметка се заразява. Променяме и цвета, като използваме highlight () към червено, ако се заразят.

Сега вашият код за симулацията трябва да работи! и за всеки размер на населението, просто променете NUMOFPEOPLE!

Стъпка 8: Използвайте теорията на Монте Карло

За да направим тази крачка по -далеч и да извлечем данни от нашия симулатор ('инфекцияSim.m'), ние искахме да изчислим и начертаем тенденцията в процента на неваксинираните хора, които са се заразили, и процента на ваксинираните хора, които са се заразили. Предполагаме, че процентът на заразените ваксинирани хора трябва да бъде много по -нисък от процента на неваксинираните хора, които са се заразили.

Стъпка 9: Направете файла ('инфекцияSim.m') със симулацията във функция

За да стартираме Монте Карло, бихме искали да стартираме симулацията няколко пъти и да натрупаме данни, така че да можем да ги използваме, за да начертаем процентите на заразените хора.

Функцията може да бъде настроена по следния начин:

функция изход = инфекцияSim (unvacc, ваксина, NUMOFPEOPLE, unvacc_perc, init_infect, скорост)

Коментирайте променливите във вашата симулация, тъй като сега ги прехвърляте през основния файл (ще започнем да записваме това в стъпка 12):

unvacc, ваксина, NUMOFPEOPLE, unvacc_perc, init_infect

Новата променлива

скорост

ще бъде присвоен в основния файл (Monte_Carlo.m).

Забележка: Не забравяйте края в долната част на функционалния файл, за да прекратите функцията!

Стъпка 10: Изчислете процента на неваксинирани и ваксинирани хора, които са заразени

Това изчислява процента на неваксинираните хора, които са се заразили. Този код се намира в долната част на файла 'инфекцияSim.m'.

number_of_unvacc = 0;

number_of_infec_unvacc = 0; %изчислява процента на неваксинираните хора, заразени за x = 1: дължина (инфекцияMat), ако инфекцияMat (1, x) == unvacc number_of_unvacc = number_of_unvacc+1; край, ако инфекцияMat (1, x) == unvacc & инфекцияMat (2, x) == 1 number_of_infec_unvacc = number_of_infec_unvacc +1; процент краен край_на_инвакк_и_инфекция = (номер_на_инфекция_вънвакк / номер_на_ванвач)*100;

Обяснение на кода

В цикъла for той ще циклира повече от NUMOFPEOPLE пъти. Всеки път, когато броят в инфекциятаMat съответства на неваксинираното число (т.е. 0,95 == 0,95), тогава броят на неваксинираните хора ще се увеличи с 1. Всеки път, когато броят в инфекциятаMat съответства на неваксинирания брой и те са заразени, броят на заразените и неваксинираните се увеличава с 1. Последният ред разделя броя на заразените, неваксинирани хора на общия брой неваксинирани хора. След това процентът се изчислява от това.

Предизвикателство:

Опитайте се да изчислите процента на ваксинираните от заразените хора! (Съвет: много е подобен на този код по -горе, но някои променливи се променят и имената се коригират.)

След това се изчислява процентът на заразените хора въз основа на общото население:

pre_per_infect = cumsum (инфекцияMat (2,:));

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

Обяснение на кода

Кумулативната сума се изчислява с помощта на втория ред на infectionMat, който съхранява 1s и 0s в зависимост дали човекът е заразен или не. Тъй като функцията cumsum () връща матрица, ние вземаме последната стойност в матрицата ('pre_per_infect (1, NUMOFPEOPLE)'), която трябва да бъде действителната сума на всички стойности от 'инфекцияMat (2,:)'. Като разделим сумата на NUMOFPEOPLE и я умножим по 100, получаваме крайния процент на заразените в общата популация.

Стъпка 11: Създайте изходна променлива във вашата функция 'инфекцияSim.m'

изход = [per_infect, процент_of_unvacc_and_infec, процент_of_vacc_and_infec];

Обяснение на кода

Съхранявайте тази информация в изход, който ще бъде изпратен обратно в главната (Monte_Carlo.m), когато функцията е извикана и изпълнена. Тези данни се използват за изчисляване на точките от процента на заразените от тези, които са ваксинирани и неваксинирани.

Вашата функция 'инфекцияSim.m' трябва да бъде направена сега! Той обаче няма да работи, защото все още трябва да напишем основното!

Стъпка 12: Създайте меню, за да получите първоначалните условия на симулацията от потребителя

Спомнете си как казахме променливата

скорост

ще бъде създаден и преминат през основната функция? Трябва да получим стойностите, за да преминем към функцията. Забележете, редът на стойностите при извикване на функцията има значение!

Започнете, като помолите потребителя да въведе някои отговори в терминала.

> Изберете болест. Обърнете внимание, че е чувствителен към регистъра >> Коклюш >> Грип >> Морбили >> Избрана болест: Грип >> Изберете размер на популацията. >> 20 >> 200 >> Избрано население: 20 >> Изберете скорост на симулация. >> Бързо >> Бавно >> Избрана скорост: Бърза

Този код по -долу пита потребителя каква болест иска да проучи.

disp ('Изберете болест. Обърнете внимание, че има чувствителност към регистъра')

fprintf ('Коклюш / n Грип / nМорбили / n') болест = вход ('Избрана болест:', 's'); ако е еднаква (болест, „коклюш“) ваксина = 0,85; %15 %шанс да се разболее болестта unvacc =.20; %80 %шанс да се разболеете иначе, ако е еднаква (болест, „грип“) ваксина =, 75; %25 %шанс да се разболее болестта unvacc =.31; %69 %шанс да се разболеете иначе, ако е еднаква (болест, „морбили“) ваксина =, 97; %3 %шанс да се разболее болестта unvacc =.10; %90 %шанс за прекратяване на заболяването

Обяснение на кода:

Функцията disp () отпечатва изявлението на екрана и отпечатва и различните опции. Заболяването ще бъде назначено съответно. Тази версия понастоящем не отчита невалидно въвеждане. Невалидният вход ще доведе до грешка и ще спре програмата напълно. Всяко заболяване има свързани с него стойности на ваксина и unvacc. Тези стойности НЕ са случайни. Получихме тези стойности от проучване на статистически данни за болестите.

След това трябва да попитаме потребителя дали иска да тества голяма или малка популация за избраната от тях болест.

disp ('Изберете размер на населението.')

fprintf ('20 / n200 / n ') скорост = вход (' Избрано население: ',' s '); ако е равно (скорост, '20') population_size = 20; elseif isequal (скорост, '200') population_size = 200; край

Обяснение на кода

Това отпечатва изявление на потребителя и моли потребителя да въведе размера на населението, което иска да тества. Тази версия понастоящем не отчита невалидно въвеждане. Невалидният вход ще доведе до грешка и ще спре програмата напълно. 20 бяха избрани, защото това е малък размер на извадката, който все още дава добра представа за това как инфекцията се разпространява в малка популация. 200 души бяха избрани като по -голямата опция, тъй като 200 точки, нанесени на графиката, почти нямаха припокриване на точки, така че всичко лесно можеше да се види и разграничи един от друг.

След това трябва да намерим скоростта на симулацията.

disp ('Изберете скорост на симулация.')

fprintf ('Fast / nSlow / n') speed = input ('Избрана скорост:', 's'); if isequal (speed, 'Fast') sim_speed = 0; elseif е равно (скорост, „бавно“) sim_speed = 0,25; край

Обяснение на кода

Този процес беше същият като получаване на вида на заболяването и размера на населението. За бързо няма да има пауза. и за бавно, ще има закъснение от 0,25 секунди във цикъла for при стартиране на симулацията.

Страхотен! Сега имаме всички данни от потребителя, от които се нуждаем! Нека преминем към събирането на данни за различни проценти неваксинирани хора.

Стъпка 13: Изберете % от неваксинираните хора и изчислете средната стойност на неваксинираните и заразените за избрания процент

Този код е за 0% от неваксинираните хора.

% ------- % 0 Неваксинирани ------------

per_infect_av_0 = ; процент_на_непроникване_и_инфекция_ав_0 = ; за i = 1:20 out = инфекцияSim (unvacc, ваксина, размер на населението, 0, 1, sim_speed); per_infect_av_0 = [per_infect_av_0, out (1, 1)]; процент_на_ванвач_и_инфекция_ав_0 = [процент_на_непроникване_и_инфекция_ав_0, вън (1, 2)]; крайна средна_инфектирана_0 = средна стойност (на_инфекция_ав_0); средно_unvacc_and_infected_0 = средна стойност (процент_of_unvacc_and_infec_av_0);

Обяснение на кода:

Цикълът for се изпълнява 20 пъти. Изходът от функцията, инфекцияSim (), се съхранява в out. Всеки път, когато цикълът for се изпълнява, тогава процентът на заразените в общата популация се добавя към матрицата „per_infect_av_0“. Освен това, процентът на неваксинираните и заразените също се добавя всеки път в матрицата 'процент_на_ванвач_и_инфекция_ав_0'. В последните два реда тези две гореспоменати матрици се осредняват и съхраняват в променливи. В обобщение, процентите се съхраняват за всяка симулация, осредняват се и се графират. Монте Карло се използва за показване на средната стойност на провеждане на симулация и показване на резултата. За нашите експериментални цели ние избираме да стартираме симулацията 20 пъти и да усредним тези стойности.

Предизвикателство:

Повторете за всички проценти, които искате да тествате! Това може да стане чрез промяна на имената на променливите според процентните числа. Тествахме за 0%, 5%, 10%, 20%, 30%и 50%.

Съвет:

Единственият ред, който трябва да бъде променен в действителния код, е

out = инфекцияSim (unvacc, ваксина, размер на населението, 0, 1, sim_speed);

Променете нулата на процента в десетична форма. Например, за 5% неваксинирана симулация, 0 трябва да се замени с 0,5.

Стъпка 14: Графика: „Тенденцията на инфекцията при неваксинирани Vs. Ваксинирани за конкретно заболяване '

Това е кодът за създаване на графика на тенденцията на инфекция при неваксинирани лица спрямо неваксинирани лица.

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]; наклон = (средно_инфектиран_5-средно_инфектиран_0)/5; ред_у = [средно_заразено_0, (наклон*50)+средно_заразено_0]; ред_х = [0, 50]; фигура (2) график (graph_mat_x, graph_mat_y); ред (line_x, line_y, 'Color', 'red', 'LineStyle', '-'); заглавие (['Тенденция при неваксиниране за', болест]); xlabel ('Процент на първоначално неваксинирани'); ylabel ('Процент на окончателно заразен')

Обяснение на кода

ред 1: присвоени стойности на y към средните проценти на заразените

ред 2: присвоени стойности на x към процента на първоначалния процент неваксинирани

ред 3: изчислете наклона от 0% и 5%

ред 4: съхранява y стойности на ред. Това е продължение на раздела от 0% до 5%.

ред 5: съхранява y стойности на ред. Тази линия обхваща дължината на графиката.

ред 6: създайте фигура

ред 7: начертайте графиките x и y стойностите на процента заразени, които са неваксинирани.

ред 8: начертайте линията. Това се използва, за да покаже, че не се увеличава линейно, а експоненциално.

ред 9: Задайте заглавие на графиката.

ред 10-11: Задайте етикети x и y за графика.

Сега трябва да можете да видите, че колкото по -голям е процентът на неваксинираното население, толкова по -големи са инфекциите. Ще видите също, че повечето от червените точки са зелени, което показва, че ваксината помага до известна степен! Надявам се този урок да ви е харесал. Коментирайте, ако имате въпроси!

Стъпка 15: Краен продукт: Как изглежда симулацията

Целият код може да бъде намерен тук