Haideţi să creăm un al doilea model pe baza primului.

Primul lucru pe care îl facem este să creăm o copie a primului model.

Facem click dreapta pe iconiţa lui, alegem (Copy).

După care (Cmd - V sau Ctrl - V) în funcţie de felul în care sistemul vostru de operare copiază fişiere şi facem o copie.

Îi dau un nou nume: "ant2.nlogo"

Fac dublu click pe copie şi o deschid.

Modificăm eticheta. Facem click dreapta pe "etichetă". Selectăm (edit) şi în fereastră scriem "Ant 2".

Avem o furnică mişcătoare. Haideţi să îi dăm ceva de mâncare.

Mergem în fereastra de limbaj (Code) şi vom crea ceva de mâncare pentru furnică.

Ne ducem la (Setup), scriem (grow-food).

Acum trebuie să îi spunem programului cum să "creeze mâncarea".

Deci scriem o nouă secţiune de comenzi (to grow-food).

Vom scrie: ask patches [set pcolor green]. Apoi încheiem cu (end).

Să vă explic puţin. Ne ducem înapoi la interfaţă. Aceasta "lumea", zona neagră, facem click dreapta şi apoi (edit).

Fereastra care se deschide arată sistemul de coordonate.

S-ar putea să vă fie greu să o vedeţi pe ecran dar vă puteţi duce să deschideţi programul ca să aruncaţi o privire.

Coordonata 0 este exact la mijloc apoi pe ambele axe puteţi vedea valori de la -16 la +16.

Deci suprafaţa este compusă dintr-o grilă formată 33x33 de pătrate denumite "patches".

Fiecare "patch" este format din 13 pixel-i.

Fiecare "patch" are anumite proprietăţi, cum este culoarea.

Dacă mă întorc în fereastra de limbaj (Code) observ că am cerut ca toate "patches" (pcolor = culoarea patch) să fie verzi.

Haideţi să vedem ce se întâmplă dacă apăs pe (Setup).

Într-adevăr întreaga suprafaţă a devenit verde.

Deci putem spune că avem un model virtual cu o furnică care trăieşte în iarbă.

Să ne intoarcem în fereastra de limbaj (Code) ca să scriem comenzi prin care să determinăm furnicile să mănânce iarba.

Vom scrie: (if pcolor = green)

După care adaug o notă care spune că dacă un agent (turtle) se află pe un patch verede (fiecare agent se află pe un anume patch) va executa o comandă.

Va mânca iarba din locul respectiv şi culoarea va deveni neagră: (set pcolor black)

Va ţine cont de câtă mâncare a consumat set food-eaten (food-eaten +1)

După care îi vom cere să mai facă ceva: să apară o etichetă pe corpul furnicii prin care programul să ne spună câtă mâncare a consumat.

Comanda: set label (food-eaten)

Deci aceste lucruri le cerem să le facă agenţii noştrii (turtles) şi punem paranteza ] aici.

Mut textul mai în faţă cu Tab şi voi avea toate comenzile pe care le cerem să le execute (turtles) între paranteze.

Le cerem să se întoarcă la dreapta sau la stânga,

să meargă înainte patru paşi,

să verifice pe ce patch se află şi dacă culoarea lui e verde să o transforme în negru

să crească cantitatea de mîncare consumată cu 1

şi să aibă o etichetă care să ne spună câtă mâncare a consumat furnica.

Mai avem un sigur lucru de făcut.

Trebuie să setăm cantitatea de mâncare consumată.

Agenţii (turtles) trebuie să aibă o variabilă asociată privind mâncarea consumată.

Vă puteţi imagina că este ca un fel de "stomac" care ţine cont de mâncarea consumată.

Şi agenţii (turtles) nu digeră nimic în acest moment în model deci ca să remediem acest lucru creăm o comandă.

Scriem turtles-own [food-eaten]

Comanda crează o variabilă numită "mâncare consumată" (food-eaten) specifică fiecărui agent (turtle).

Fiecare (turtle) are variabila sa specifică. Deci fiecare va avea o valoare diferită.

La (setup) setez valoarea la 0 (set food-eaten 0).

Ca să fim siguri că se începe de la 0 şi pe măsură ce rulează modelul fiecare furnică va acumula ce cantitate de mâncare a consumat.

Verificăm. Pare în regulă.

Ne întoarcem la interfaţă. Reducem viteza puţin ca să vedem furnica mâncând iarba.

Furnica merge prin "lume" şi când ajunge pe o suprafaţă (patch) verde mănâncă mâncarea.

De fiecare dată va face (0 - 3) paşi de fiecare dată şi mănîncă mâncarea după ce a făcut numărul de paşi.

Putem să mărim viteza.

Pe ecran s-ar putea să nu se vadă dar furnica are o etichetă care ne spune câtă mâncare a consumat.

E cam multă mâncare pentru o furnică mică.

Deci următorul lucru pe care îl facem este să creăm o colonie de furnici.

Adăugăm mai multe furnici.

Creăm o "populaţie".

Şi în primul rând vom face posibil ca utilizatorul modelului nostru să poată seta el însuşi mărimea populaţiei.

Mă duc la meniul interfeţei şi aleg (Slider).

În câmpul (Global variable) scriu (population).

Valoarea minimă (Minimum) o pun 1.

Valoarea maximă (Maximum) o pun 200.

Le permitem utilizatorilor să mărească (Increment) cu 1.

Numărul iniţial de indivizi (Initial value) este 50.

Apăsăm (Apply) şi (OK).

Mutăm slider-ul mai sus.

Acum trebuie să specificăm în limbaj (Code) ce trebuie să facă programul cu această variabilă.

Ne ducem în fereastra de limbaj (Code).

La (create-turtles 1) schimb si scriu (create-turtles population).

Deci utilizatorul va seta numărul de indivizi care formează populaţia şi programul va crea numărul respectiv de (turtles).

Să vedem ce se întâmplă cănd facem click pe (Setup).

Acum avem toate furnicile pe mijloc (toate cele 50).

Apăsăm pe (Go). Le puteţi vedea acum mişcându-se.

Toate fac cam acelaşi lucru.

Dar având în vedere că fiecare alege la întâmplare ce să facă vedeţi că nu par să se mişte la fel.

Dacă mărim viteza vedem că seamănă în comportament cu furnicile adevărate care se mişcă şi mănâncă.

Să creştem populaţia la 130. Oh, acum sunt chiar îngrămădite.

Să mergem înapoi la fereastra de limbaj (Code) să le facem puţin mai mici.

Setăm mărimea la 1 (set size 1).

Ne ducem înapoi în interfaţă şi facem click pe (Setup).

Acum sunt mai mici. Poate că nu le vedeţi prea bine dar au mai mult loc.

Fiecare furnică are o etichetă care arată câtă mâncare a consumat dar e cam mică ca să o puteţi vedea pe ecran.

Am vrea să ştim câtă mâncare a consumat întreaga colonie.

Adăugăm un grafic care să arate câtă mâncare a fost consumată într-o perioadă de timp.

Ne ducem la meniul interfeţei şi alegem (Plot).

Îl plasam aici jos.

În fereastră completăm o serie de câmpuri.

În câmpul (Name) scriem (Total Food Eaten)

Lăsăm valorile minime şi maxime ale axelor să se ajusteze automat.

În câmpul (X axis label) scriem (Total Food Eaten)

În câmpul (Y axis label) scriem (Time)

Culoarea din câmpul (Color) o lăsăm neagră.

În câmpul (Pen name) scriem (total-food-eaten). Acest lucru nu este foarte necesar.

Îi dau o comandă în câmpul (Pen update commands). Scriu plot sum [food-eaten] of turtles.

Graficul va face calculul total al mâncării consumate de fiecare furnică în timp.

Facem click pe (Apply).

Oh, (Total Food Eaten) trebuia să fie pe axa Y iar (Time) trebuia să fie pe axa X.

Facem schimbarea în câmpuri. Acum este corect.

Selectăm graficul cu click dreapta.

Îl mutăm. Îl facem mai lung ca să-l vedem.

Şi acum facem click pe (Setup) şi apoi pe (Go).

Vedeţi că graficul se ajustează singur. Numerele se schimbă în continuu.

Şi arată cât de repede se consumă mâncarea.

Dacă modificăm mărimea populaţiei veţi vedea cum afectează această variabilă viteza cu care este consumată mâncarea.

Ca să finalizăm modelul haideţi să adăugăm alte variabile pe care le pot modifica utilizatorii în legătură cu furnicile.

Punem un (Slider) care să îi permită utilizatorului să seteze numărul maxim de paşi şi unghiul de întoarcere.

Selectăm graficul şi îl mutăm mai jos ca să facem loc pentru încă 2 slider-e.

Merg în meniu. Selectez (Slider)

În câmpul (Global variable) scriu (max-step-size).

În câmpul (Minimum) scriu (1).

În câmpul (Maximum) scriu (10).

În câmpul (Value) scriu (4).

Facem click pe (OK).

Îl mutăm sub celălalt slider.

Le selectăm pe amăndouă şi le mutăm mai sus.

Adăugăm un nou slider.

În câmpul (Global variable) scriu (max-turn-angle).

În câmpul (Minimum) scriu (1).

În câmpul (Maximum) scriu (180).

În câmpul (Value) scriu (60) conform comenzilor scrise de noi în fereastra de limbaj (Code).

Facem click pe (Apply) şi apoi pe (OK).

Îl selectăm şi îl mutăm.

Acum trebuie să adăugăm aceste variable în limbaj (Code).

În fereastă în loc de 60 scriem (max-turn-angle) pentru ambele cazuri.

Acum avem [right random max-turn-angle] şi [left random max-turn-angle]

Acum comanda (random) va da o valoare între 0 şi noua comandă scrisă de noi - 1.

max-turn-angle - 1

max-turn-angle este un termen puţin cam impropriu folosit. Dar nu îmi fac griji în legătură cu asta.

Voi face acelaşi lucru şi în legătură cu numărul de paşi.

În loc de 4 voi scrie (max-step-size).

Verificăm.

Mi-am dat seama că s-ar putea să nu vedeţi foarte bine comenzile pe care le-am scris pe ecran.

Şi am upload-at modelul pe pagina care conţine materiale legate de curs sub numele de "Ant2.nlogo".

Deci il puteţi download-a ca să vă puteţi uita la el.

Veţi folosi modelul ca să vă faceţi tema.

Acum să vedem dacă funcţionează, din nou.

Pare să funcţioneze.

Ce vreau să vă spun este că uneori NetLogo se mai blochează.

Chiar dacă faceţi click pe (Go) nu se opreşte pentru că execută multe comenzi.

În meniul (Tools) există comanda (Halt) care opreşte programul întotdeauna.

E bine să ştiţi acest lucru în cazul în care programul rămâne blocat.

Haideţi să facem un experiment.

Creştem valoarea numărului de paşi (max-step-size) la 10. Şi hai să vedem ce se întâmplă.

Acum mai multe furnici par să rămână blocate pe margini.

Puteţi modifica aceste 3 variabile ca să vedeţi în cât timp se consumă toată mâncarea.

Dar vrem ca modelul să se oprească atunci când nu mai este mâncare ca să vedem cât timp a durat (ticks).

Pentru asta scriu o nouă comandă.

Mă duc la secţiunea (to go).

Aceasta este comanda de oprire: if not any? patches with [pcolor = green] [stop]

Acesta este tipul de sintaxă folosit de NetLogo.

Puteţi folosi not şi any? referindu-vă la patches cu anumite proprietăţi apoi adaugaţi [stop].

Setăm populaţia la 200, numărul de paşi la 4 şi unghiul de întoarcere la 60 şi să vedem cât de repede mănâncă furnicile mâncarea.

Au terminat în doar 105 ticks.

Salvăm modelul.

Ne ducem la meniul (File) şi facem click pe (Save)

Am terminat al doilea model.