Nun da wir gesehen haben, wie NetLogo generell funktioniert, lassen Sie uns ein eigenes einfaches Modell erstellen!
Dieses Modell wird darin bestehen, eine Ameise, die sich zufällig bewegt, darzustellen. Das ist alles.
Wir öffnen NetLogo.
Dafür klicke ich wieder auf das NetLogo 5.0.3 Icon
Sie können natürlich auf das der Version von NetLogo, die Sie verwenden, klicken.
Das Erste was wir tun werden ist, die "Setup" und "Go" Schalter [buttons] zu erstellen
dafür müssen wir in diesen Teil des Menüs - Aufschrift "button"- gehen;
Das ist das eigentliche Menü zum Aufbau der Bedienoberfläche [interface]...
...denn mit einem Klick hierauf sehen wir alle möglichen verschiedenen Arten von Objekten, welche für das Interface verwendet werden können.
Ich werde also einen Schalter hinzufügen, indem ich auf das Interface klicke
und ich kann hier bestimmen, dass dieser Schalter für "Setup" stehen soll...OK.
Danach füge ich einen weiteren Schalter hinzu und bestimme diesen hier als "Go".
Jetzt kann ich ihn mit der rechten Maustaste anwählen; Hier ich klicke "Select" und kann ihn dann bewegen
ich kann auf diese Weise auch seine Größe verändern, wenn ich das will
-wenn ich ihn durch "Select" ausgewählt habe-
und kann ihn durch Ziehen verändern und verschieben; Indem ich ihn einfach vor und zurück bewege
und so weiter. Ich kann die Schalter so anpassen, wie ich das will.
Jetzt sind also die "Setup" und "Go" Schalter da.
Noch sind sie rot, weil ihnen kein Code zugordnet wurde,
das heißt, dass sie noch funktionslos sind wenn man sie anklickt.
Deswegen werden wir jetzt einen Code zuordnen.
Lassen Sie uns einen Code für die "Setup" und "Go" Schalter erstellen.
Dies macht man, indem man auf den "Code" Schalter hier klickt...
und die Anweisungen eingibt.
So, die erste, welche wir schreiben werden ist "Setup", also muss es heißen: "to setup".
Hier steht dann, was passieren soll, wenn wir den Schalter [Setup] klicken:
Wir befehlen "clear-all".
"Clear all" ist ein Befehl, um die Welt,
also den Ort an dem man sehen kann, wie die Ameisen -oder was auch immer - agieren,
dieses Fenster frei zu machen und alle Überbleibsel - zum Bsp. aus vorangegangenen Läufen des Programms zu entfernen...
Wir befehlen "reset-ticks",
setzen also die "ticks" oder den Zeitschritt [timestep] auf Null.
Jetzt gehen wir daran, eine Ameise zu erschaffen.
Dazu muss man erst einmal wissen, dass alles- jeder Agent-
in NetLogo als "turtle" bezeichnet wird.
Dies hat historische Gründe,
das kommt aus der ursprünglichen Sprache "Logo" auf der NetLogo basiert
in welcher jeder Agent eine "turtle" war
- eigentlich gab es in Logo tatsächlich nur eine "turtle" [Schildkröte]
während man in NetLogo eigentlich theoretisch viele "turtles" haben kann. Aber hier genügt es uns zu schreiben:
"create-turtles" -wir müssen angeben, wieviele - wir wollen aber jetzt nur eine.
So erstellen wir mit "create-turtles 1" eine.
Als Nächstes müssen wir ihr sagen, was sie zu tun hat, dafür schreiben wir "ask turtle"
Wir werden eine ganze Liste für sie erstellen, eine Liste mit Dingen die sie tun soll und die startet mit der Klammer "["
Die Form legen wir auf "bug" fest [set shape "bug"],
das ist die Standard-Form der Ameisen in NetLogo.
Wir stellen die Größe auf "3" ein [set size 3], das ist eine gute Größe, um die Ameise erkennen zu können.
Ihre Farbe stellen wir auf "rot" ein [set color red]...OK.
Das sollte alles sein, was sie zu "tun" hat; also setzen wir "end" an das Ende.
Nun gibt es diesen schönen "check" Marker hier, durch den der Code auf Fehler überprüft wird.
Da klicken wir jetzt drauf.
Und...er sagt mir, er hat einen Fehler gefunden.
Er sagt mir auch, wo sich der Fehler befindet - nämlich hier...
...und mir fällt auf, dass es eigentlich hätte heißen müssen "ask turtles".
Ich habe hier das "s" vergessen.
Der Grund dafür ist, dass NetLogo generell von einer Population von "turtles" bzw. Agenten ausgeht.
Wenn es um Aufforderungen geht, Befehle werden an Populationen erteilt
-zumindest für diesen Zyklus [loop] - Befehle gehen an ALLE
Tja, hier gibt es nur eine. Das kann man später ändern.
Erstmal erteilen wir jetzt diese Anweisungen ALLEN
OK, nun überprüfen wir nochmals - und kommen zur Benutzeroberfäche zurück. Das heißt, dass alles zu funktionieren scheint.
Wir klicken "Setup" und... sehen unsere Ameise!
Genau in der Mitte.
Der "Go" Schalter ist immernoch rot, was bedeutet, dass für ihn noch kein Code geschrieben wurde.
Lassen Sie uns also die Anweisungen für den Ablauf unter "Go" schreiben.
Wir kehren zunächst zum "Code" - Reiter [tab] zurück. Dort schreiben wir: "to go".
Wir werden wieder per "ask turtles" die "turtles" anweisen, die folgenden Dinge zu tun...
als Erstes werden sie angewiesen, ihre Körper nach rechts zu wenden... um 30°.
Also schreibe ich "right 30".
Danach werden sie angewiesen, sich 4 Schritt nach vorn zu bewegen:
"forward 4". OK.
Dann werden wir...
die Zeitschritte "time steps" um 1 vergrößern. Dazu ist der "tick"-Befehl da.
Erinnern Sie sich, dass wir anfangs über "reset-ticks" den Zeitschritte-Zähler auf 0 gesetzt haben.
Durch "tick" erhöhen wir um 1 und das bei jedem Ablauf, in dem diese Anweisungen ausgeführt werden.
Dann kommt "end". Lassen Sie uns das Ganze nochmals überprüfen - OK, es passt.
Gehen wir also zur Bedienoberfläche...
uund klicken "Go"!
Sie konnten beobachten, dass die "turtle" ihren Körper um 30° gewendet
und sich 4 Schritte vorwärts bewegt hat.
Wir können jetzt den "Go" Schalter wieder anklicken, wieder und wieder immer weiter und sie bewegt sich im Kreis.
Jetzt hätte ich aber gerne, dass sie sich selbstständig immer weiter bewegt, ohne dass ich ständig
den "Go" Schalter dazu drücken muss;
und das kann ich einstellen indem ich mit der rechten Maustaste auf "Go" klicke und auf "Edit..." gehe.
Hier gibt es die Option "Forever", welche ich anwähle, was dazu führt, dass "Go" auf ewig immer weiter wiederholt wird.
Genau das machen wir. Wenn ich die Sache jetzt etwas verlangsame, ein wenig...
kann man sehen,dass die Ameise von alleine weitergeht.
Weiter und weiter immer im Kreis. Durch Klicken auf "Go" stoppe ich sie.
Wenn ich möchte, dass sie wieder startet, klicke ich wieder auf "Go" und es geht weiter,
ich stoppe, wenn ich wieder auf "Go" gehe
oder gehe - falls ich wieder von vorne beginnen möchte - wieder auf "Setup".
Beachten Sie, dass sie durch wiederholtes Klicken von "Setup"
dass sie zwar immer am selben Platz in der Mitte startet,
aber dass sie dabei jedes Mal in eine andere Richtung zeigt.
Das passiert, weil "Setup" die Ameise jedes Mal zentriert starten und dabei in eine zufällige Richtung zeigen lässt.
Jetzt kann das Modell soweit abgespeichert werden,
indem wir unter dem "File" Schalter auf "Save as..." klicken.
Ich werde es als "Ant1" speichern.
Jetzt sehen wir es hier, es erscheint auf dem Desktop: Ant1.nlogo.
Jetzt kann ich ins NetLogo Menü zurückkehren, NetLogo beenden
und wenn ich möchte, dass das Modell startet, muss ich nur hierauf doppelklicken
und NetLogo wird starten und das Modell laden.
Unser Modell hat nur einen Fehler...
nämlich, dass es langweilig ist.
Alles, was die Ameise tut, ist Kreise zu drehen.
Machen wir es also ein wenig interessanter!
Das kann ich machen, indem ich auf "Code" gehe und einen einfachen Befehl hinzufüge:
Nämlich...anstatt nur 30° nach rechts zu drehen [right 30] fügen wir jetzt das Wort "zufällig" [random] hinzu.
Damit wird die Ameise jetzt einen zufälligen Wert zwischen 0 und 30-1 wählen
das ist es, was "random 30" bewirkt.
Die Ameise wird sich um so viele Grad nach rechts drehen; jedes Mal, wenn sie den Prozess durchläuft
wird sie einen anderen Wert auswählen.
Dasselbe können wir auch hier machen: Wir lassen die Ameise forwärts laufen
und zwar eine zufällige Anzahl an Schritten, zwischen 0 und 4-1, bzw. zwischen 0 und 3.
Sehen wir mal, was nun passiert. Ich schaue also zur Bedienoberfläche
gehe auf "Setup" und "Go".
Jetzt kann man sehen, dass die Ameise ... immernoch mehr oder weniger im Kreis geht, aber
dass das Verhalten jetzt aber etwas interessanter wurde.
Eine Sache, die Ihnen vielleicht aufgefallen ist
ist, dass die Ameise durch die Wand zu gehen scheint...an dieser Seite hinein
und auf der anderen Seite heraus.
Aber tatsächlich ist die Welt, dieser schwarze Bereich hier, um die Ränder herum gewickelt.
Die ganze Welt hat also die Form eines Donut oder Torus,
bei der diese Wand - auch wenn sie flach scheint -
tatsächlich um den Rand herum aufgewickelt ist und die andere Wand berührt.
Die Ameise geht also...Mal sehen, ob wir das hier hinkriegen... Jetzt ist sie etwas zu schnell vorbeigelaufen...
die Ameise geht oben durch und kommt am Boden heraus
(hier ist der Boden).
Oder -wenn sie durch die Seite rausgeht - kommt sie auf der anderen Seite wieder heraus.
Das lässt die Sache irgendwie etwas seltsam aussehen,
aber es gibt etwas, das ich tun kann: ich kann...
mit der rechten Maustaste auf die Welt - also auf diese schwarze Fläche hier - klicken
auf "Edit" und...
hier bekomme ich viel Information zum Koordinatensystem, zum Aufbau [setup] dieser Welt
und über die Anzahl der sogenannten "patches", die sozusagen das Gitter [grid] darstellen, in das diese Welt aufgeteilt ist.
Was jetzt aber für uns interessant ist, sind diese voreingestellten Häkchen
"world wraps horzontally" und "vertically", die können wir entfernen: Wir gehen auf "Apply" und auf "OK".
Sehen wir mal, was nun passiert.
Nun bleibt die Ameise - wenn sie den Rand berührt - stecken
und bewegt sich nicht mehr, bevor sie es geschafft hat, sich umzudrehen.
Das lässt die Ameise jetzt etwas realsitischer aussehen.
Aber selbst jetzt, da sich unsere Ameise ein bischen zufällig bewegen kann,
ist es immer noch nicht sehr interessant,
da sie sich immer nur nach rechts drehen kann.
Lassen Sie uns daher einen Code schreiben, welcher es der Ameise erlaubt, zufällig zu entscheiden,
ob sie sich nach rechts oder nach links dreht.
Im Prinzip ist es dazu nötig, eine Münze zu werfen.
Jedes Mal, wenn sich die Ameise bewegt wird sie eine Münze werfen, um zu entscheiden, ob sie sich rechts- oder links herum dreht.
Ich werde nun das Münzwurf-Verfahren implementieren.
Ich nutze dazu einen Befehl, der "to-report" heißt. OK. "Coin flip" [Münzwurf]
Die "report" Anweisung unterscheidet sich von einer "to"- Anweisung
denn sie gibt quasi einen Wert aus.
Diese hier wird "true" oder "false" [wahr oder falsch] ausgeben
in Übereinstimmung mit Kopf oder Zahl.
Jetzt müssen wir hier nur noch "report random 2 = 0" eingeben und dann Ende [end].
OK. Was das bewirkt, ist...
"Random 2" - wie Sie sich erinnern gibt "random" eine ganze Zahl zwischen 0 und dieser Zahl minus 1 aus -
Es [Random 2] wird also in der Hälfte der Fälle 0 und in der anderen Hälfte 1 ausgeben
und das Ganze zufallsgesteuert.
Wenn die Zahl 0 ist,
d.h. wenn "random 2" gleich Null ist, dann ist die Aussage richtig [true]
Falls "random 2" = 0;
Andernfalls ist die Aussage falsch [false].
Die Anweisung berichtet, ob dies richtig oder falsch ist [true or false].
Also wird der Wert dieser "report coinflip" Anweisung in der Hälfte der Fälle richtig [true] und in der anderen Hälfte
falsch [false] sein und das zufällig gemischt.
Dies können wir jetzt hier oben verwenden. Indem wir schreiben
"ifelse coin-flip".
Das bewirkt: Wenn der Münzwurf zu "richtig" [true] geführt hat
tue das erste was ich hier in die Klammern schreibe [right random 30],
andernfalls, wenn er zu falsch [false] geführt hat, tue das zweite, was ich hier in die Klammern schreibe:
"left random 30".
Wenn also Münzwurf = richtig, dann "right random 30", wenn Münzwurf = falsch, dann "left random 30".
Jedes Mal wenn die "Go" Anweisung gestartet wird - für jeden Zeitschritt [timestep]
wird zufallsgesteuert entschieden, ob sich rechts- oder links herum gedreht wird.
Schauen wir mal, wie das funktioniert.
"Setup" und "Go".
Wie Sie sehen, bewegt sie sich in verschiedene Richtungen.
Sie bleibt zwar hängen, aber sie bewegt sich weiter vorwärts, dreht sich nach rechts und nach links;
Das einzige Problem ist jetzt noch, dass sie zu oft hängen bleibt.
Das werden wir beheben.
Etwas besser wird es, wenn wir die 30er in 60er umändern,
dann kann die Ameise sich besser drehen, hat einen größeren Drehradius, dreht sich also jedes Mal etwas mehr.
Versuchen wir es nochmals.
Sehen wir, ob...Ja! Sie steckt jetzt weniger oft fest und es sieht etwas realistischer aus.
Wann immer Sie ein Programm schreiben, ist es immer ratsam, Kommentare festzuhalten.
Ich gehe dazu zum Code zurück.
Ein Kommentar ist ein Stück Text,
dass ins Programm geschrieben, aber vom Computer ignoriert wird,
welches es Menschen aber leichter macht, dieses zu lesen.
In NetLogo ist ein Kommentar einfach irgendein Text, der auf ein Semikolon [;] folgt.
Wenn ich hier ein Semikolon setze kann ich schreiben, was ich will und der Computer wird es ignorieren.
Wir können z.B. schreiben: Gibt zufallsgesteuert "wahr" oder "falsch" aus.
Das ist es ja, was es tut.
Hier können wir einen weiteren Kommentar einfügen:
Wenn Münzwurf "wahr" ergibt, drehe nach rechts,
andernfalls drehe nach links. OK.
Somit haben wir kleine Erinnerungen erzeugt, entweder für uns selbst,
oder für jemand anderen, der unser Programm einmal lesen wird,
kleine Erinnerungen daran, welche Funktionen die verschiedenen Teile genau haben.
Dies ist wirklich sehr hilfreich, wenn Sie ein komplizierteres Programm schreiben
besonders wenn Sie nach einer Unterbrechung von - sagen wir ein paar Tagen - zurückkommen
dann hilft es Ihnen wirklich, sich daran zu erinnern, was genau Sie gemacht haben.
Kommentare sind eine unbedingte Notwendigkeit, selbst wenn niemand außer Ihnen Ihr Programm lesen wird.
Jetzt können wir unser Modell also speichern.
Dazu werde ich ihm zuerst eine Beschriftung verpassen - das ist nur wegen der Ästhetik.
Dazu gehe ich in das Interface Menü und wähle einen Hinweis aus [Note].
Damit werden wir hier oben einen kleinen Text platzieren, nämlich den Namen unseres Modells "Ant 1".
Wir nehmen einen etwas größeren Text...Schriftgröße 18. OK.
Dann kann ich noch dies und dies auswählen und sie zusammen etwas nach unten verschieben, sie zentrieren...
und was auch immer machen, damit es hübscher aussieht.
Jetzt ist es fertig. Wir müssen nur noch abspeichern.
Jetzt können wir NetLogo verlassen und das Modell ist gespeichert.
Ich wollte noch erwähnen, dass der Grund warum ich hier gezeigt habe, wie NetLogo funktioniert
ist, dass ich Ihnen einen Eindruck verschaffen wollte, wie dies alles funktioniert.
Wir werden eine Menge NetLogo - Simulationen im Laufe dieses Kurses verwenden.
Wir werden zwar nicht sehr viele selbst schreiben,
aber ich wollte Ihnen einen Eindruck davon verschaffen,
wie der Code funktioniert, wie das Interface funktioniert und so weiter.
Sie werden selbst wahrscheinlich einige
Modifikationen an einigen der Modellen, die wir uns ansehen, vornehmen
wenn Sie sich ein wenig besser auskennen bzw. motiviert dazu sind, können Sie natürlich auch versuchen,
welche auf eigene Faust zu schreiben.
Als kleine Aufgabe anstelle eines Quiz für diese Lektion, möchte ich von Ihnen,
dass Sie genau das Modell, welches wir hier programmiert haben - Ant 1 - zur Anwendung bringen,
indem Sie genau die Angaben nutzen, welche ich verwendet habe und das Ganze zum Laufen bringen.
Es wird nicht bewertet werden, aber es wird Ihnen helfen;
Helfen festzustellen, ob Sie alles, was ich Ihnen gezeigt habe auch verstanden haben.
Scheuen Sie sich auch nicht, Fragen im Forum zu stellen, falls irgendwelche aufkommen sollten
dafür ist es schließlich da!