Logo: Meta: Überblick

Aus Wikibooks

Logo: Meta


In den 60er Jahren hat Seymour Papert die Programmiersprache Logo entwickelt. Als Vorbild diente dabei die Programmiersprache Lisp.

Logo ist eine Interpretersprache, die in einer Umgebung abläuft. Das bedeutet, daß man eine Funktion definieren kann, und solange man die Umgebung nicht beendet, kann man diese Funktion verwenden.

Der Sprung in das kalte Wasser[Bearbeiten]

Die Software[Bearbeiten]

Sie möchten Logo lernen und Programme in Logo schreiben. Dazu besorgen Sie sich am besten eine Logo-Software. Im Internet kann man sich kostenlos die gewünschte Software herunterladen. Zwischen den einzelnen Produkten mag es Unterschiede geben, darum wird hier UCB Logo verwendet, das, abgesehen von einer Unzahl an erweiterten Befehlen, sich wie Standard-Logo verhält.

Download Links siehe Logo: Quellen#Logo-Versionen

Starten der Umgebung[Bearbeiten]

Sie haben sich die Software besorgt und auf dem Computer installiert? Schön, dann kann man sich mit der Umgebung vertraut machen. Starten Sie die Software und gehen Sie in den Vollbildmodus. Sie sehen eine weiße Fläche (kann auch schwarz sein), oben steht eine Statusmeldung und darunter ein Fragezeichen. Das Fragezeichen fordert Sie dazu auf, eine Eingabe zu machen. Geben Sie zum Beispiel Print "Hallo ein und bestätigen Sie mit Enter. Dann sollte Folgendes zu sehen sein:

? print "Hallo
Hallo
?

Probieren Sie es mit Print "Hallo Welt. Dann kommt eine Fehlermeldung:

? print "Hallo Welt
Hallo
I don't know to Welt
?

Der Interpreter sieht Welt als Anweisung an. Da die Anweisung Welt aber nicht existiert, kann er nichts damit anfangen. Schreiben Sie stattdessen Print [Hallo Welt]

? print [Hallo Welt]
Hallo Welt
?

Der Interpreter hat in diesem Fall die beiden Objekte aus Liste [Hallo Welt] ausgegeben. Er hat dabei nicht versucht, die beiden Objekte zu interpretieren.

Man kann die Liste auch auf eine Variable legen:

? make "gruss [Hallo Welt]
? print gruss
Hallo Welt
?

Erstellen Sie jetzt ein kleines Programm, eine Prozedur:

? to hallo
> print [Hallo Welt]
> end
?

Mit dem Aufruf hallo wird die Prozedur gestartet:

? hallo
Hallo Welt
?

Machen sie mal etwas mit der Turtlegraphics. Erstellen Sie eine Prozedur, die eine geometrische Darstellung erstellt:

? to triangle
> fd 80 rt 120 fd 20 rt 120
> fd 80 rt 120 fd 20 rt 120
> fd 80 rt 120 fd 20 rt 120
> end

Mit dem Aufruf Triangle wird ein gleichseitiges Dreieck gezeichnet, an dem drei kleinere gleichseitige Dreiecke hängen. Man hätte die Prozedur auch kürzer schreiben können, und man hätte der Prozedur einen Parameter mitgeben können, mit dem man die Größe des gezeichneten Objekts hätte beeinflussen können. Gehen Sie jetzt mit textscreen wieder in den Textmodus.

Da Sie zwei Prozeduren geschrieben haben, sind sie im Speicher abrufbar. Mit poall werden alle während der Sitzung erstellte, oder dazugeladenen Prozeduren, Funktionen und Variablen angezeigt:

? Poall
to hallo
print [Hallo Welt]
end

to triangle
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
end

make "gruss [Hallo Welt]

?

Möchte man nur die Prozeduren und Funktionen angezeigt bekommen, nicht aber die Variablen, dann gibt es die Anweisung pops:

? pops
to hallo
print [Hallo Welt]
end

to triangle
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
end

?

Mit pots bekommt man nur die Prozedurköpfe:

? pots
to hallo
to triangle

?

Möchte man nur die Variablen sehen, dann benutzt man pons:

? pons
make "gruss [Hallo Welt]

?

Sobald man die Umgebung beendet, werden alle bisher erstellten Prozeduren und Variablen zerstört. Mit save "dateiname lassen sich die Prozeduren und Variablen speichern:

? save "erste_sitzung
?

Nun kann man mit erall den gesamten Speicher löschen. Die Prozeduren und Variablen sind verschwunden:

? erall
? poall
?

Mir load "dateiname kann man das gespeicherte wieder in die Sitzung laden:

? load "erste_sitzung
? poall
to hallo
print [Hallo Welt]
end

to triangle
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
fd 80 rt 120 fd 20 rt 120
end

make "gruss [Hallo Welt]

?

Mit bye können Sie die Sitzung beenden.

Konstrukte[Bearbeiten]

Zuweisungen werden mit make realisiert

make "index 1

Initialisierung einer leeren Liste

make "buecher []

Schleife

repeat Anzahl der wiederholungen [ Anweisungsfolge ]

Ausgabe

print

selbstdefinierte Prozeduren und Funktionen[Bearbeiten]

Prozedur[Bearbeiten]

Die Funktion ist ein wichtiger Bestandteil der Programmiersprache Logo. Man kann natürlich unter Logo jede Anweisung einzeln ausführen, aber das wird umständlich. Am Beispiel zur Darstellung eines Sechsecks lässt sich das deutlich zeigen:

"Zu Fuß" muss man folgende Anweisungen eingeben:
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
Als Funktion definiert sieht das Ganze dann so aus:
to sechseck
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
end
Um das Sechseck darzustellen muss man nur noch das eingeben:
sechseck
Das ganze hat aber noch mehrere Nachteile:
  1. Es ist zu lang
  2. Es ist zu starr
  3. Es ist zu unflexibel
Statt
to sechseck
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
fd 40
rt 60
end
lässt sich auch
to sechseck
repeat 6 [ fd 40 rt 60 ]
end
schreiben
Man kann eine variable Seitenlänge einfügen:


to sechseck :laenge
repeat 6 [ fd :laenge rt 60 ]
end
Man kann eine variable Eckenanzahl einfügen, so das auch andere regelmäßige Polyeder dargestellt werden können:
to polyeder :ecken :laenge
repeat :ecken [ fd :laenge rt 360 / :ecken ]
end

Turtle-Grafik[Bearbeiten]

Das Prinzip der grafischen Darstellung unter der Programmiersprache Logo unterscheidet sich grundsätzlich erstmal von der anderer Programmiersprachen, die mit Koordinaten arbeiten. In Logo hat man eine virtuelle Schildkröte (engl. turtle), die einen Stift hinter sich herzieht und so bei Bedarf einen farbigen Strich zeichnet. Es gilt, diese Schilkröte mit gezielten Anweisungen fernzusteuern. Dies geht mit den nachfolgenden Anweisungen:

  • Um Grafik darstellen zu können, sollte man in den Grafikmodus gehen. Das geht mit fullscreen oder auch kurz fs.


forward länge fd länge Die Schildkröte bewegt sich um eine bestimmte Anzahl von Einheiten nach vorne
back länge  bk länge Die Schildkröte bewegt sich um eine bestimmte Anzahl von Einheiten zurück
right winkel rt winkel Die Schildkröte dreht sich um einen bestimmten Winkel nach rechts
left winkel lt winkel Die Schildkröte dreht sich um einen bestimmten Winkel nach links
setpencolor farbewert setpc farbwert Der Schildkröte wird eine Zeichenfarbe zugewiesen
pendown  pd  Der Stift wird auf die Zeichenfläche gesetzt
penup pu  Der Stift wird von der Zeichenfläche genommen
textscreen || ts || Text-Modus
home ||    Die Schildkröte bewegt sich zur Mitte des Bildschirms mit Ausrichtung nach oben (0°)
clean ||  Der Bildschirm wird gelöscht, die Position der Schildkröte ändert sich nicht
cleanscreen || cs || home und clean zusammen
hideturtle || ht || Die Schildkröte wird unsichtbar
showturtle || st || Die Schildkröte wird sichtbar

Grafik mit Koordinaten[Bearbeiten]

Es gibt aber auch in der Programmiersprache Logo die Möglichkeit, koordinatenbezogene Grafik zu erzeugen. Die geht mit der Anweisung setpos [x y]

Setpos [x y] setzt die Schildkröte genau an die Koordinaten, die in der Liste [x y] stehen. Zwischen dem Punkt, wo die Schildkröte vor Ausführung des Setpos war, und der neuen Koordinate hat die Schildkröte einen Strich gezeichnet. Um das gezielt unter Kontrolle zu halten, kann man sich der Anweisungen pu und pd bedienen.

Eine Anweisung Linie :x1 :y1 :x2 :y2 :farbwert würde so aussehen:

to linie :x1 :y1 :x2 :y2 :farbwert
make "koo1 []
make "koo2 []
make "koo1 lput :x1 :koo1
make "koo1 lput :y1 :koo1
make "koo2 lput :x2 :koo2
make "koo2 lput :y2 :koo2
setpc :farbwert
pu
setpos :koo1
pd
setpos :koo2
pu
end

Eine Anweisung box :x1 :y1 :x2 :y2 :farbwert entsprechend so:

to box :x1 :y1 :x2 :y2 :farbwert
make "koo1 []
make "koo2 []
make "koo3 []
make "koo4 []
make "koo1 lput :x1 :koo1
make "koo1 lput :y1 :koo1
make "koo2 lput :x1 :koo2
make "koo2 lput :y2 :koo2
make "koo3 lput :x2 :koo3
make "koo3 lput :y2 :koo3
make "koo4 lput :x2 :koo2
make "koo4 lput :y1 :koo2
setpc :farbwert
pu
setpos :koo1
pd
setpos :koo2
setpos :koo3
setpos :koo4
setpos :koo1
pu
end

Listen[Bearbeiten]

Neben der Turtle-Grafik spielen die Listen in Logo eine gewisse Rolle, zumal Lisp der Pate für Logo ist.

Was ist eine Liste?[Bearbeiten]

In Logo ist eine Liste ein Konstrukt, bei der Elemente innerhalb einer eckigen Klammer stehen. Beispiel für Listen:

[ rot gelb gruen cyan blau magenta ]
[ Dies ist ein Satz in einer Liste]
[ 1 3 6 10 15 21 ]

Eine Liste kann wiederum auch Listen enthalten:

[ [ Brot Butter ] [ Milch Kase ] ]

Eine Liste kann auch leer sein:

[]

Überhaupt hat eine Liste viel Ähnlichkeit mit einer Menge.

Wie bekommt man Elemente in eine Liste?[Bearbeiten]

Man kann eine Liste schon vordefinieren:

MAKE "Wochentage [Montag Dienstag Mittwoch Donnerstag Freitag]

Man kann auch ein Element in eine Liste hinzufügen:

MAKE "Tiere LPUT Katze :Tiere

Wenn die Liste Tiere vorher so aussah: [Hund Meerschweinchen Schildkröte], dann enthält sie danach: [Hund Meerschweinchen Schildkröte Katze].

Wie läßt sich feststellen, ob ein Element in einer Liste enthalten ist?[Bearbeiten]

Das läßt sich mit der logischen Funktion MEMBERP Element Liste erreichen.


Sieb des Erastothenes[Bearbeiten]

Als Beispiel für ein Programm mit Listen soll das Sieb des Eratothenes dienen. Das Sieb des Eratosthenes ermittelt aus einem Intervall der natürlichen Zahlen, von 2 bis zu einer fest vorgegebenen Obergrenze, alle Primzahlen durch heraussieben. Normalerweise wird so etwas mit einem Array realisiert. Man gibt vor, alle Zahlen von 2 bis zur Obergrenze seien Primzahlen, und entfernt dann alle Vielfachen von einer Primzahl angefangen mit der 2.

Da es keine Arrays in Logo gibt, muss man das Ganze etwas anders realisieren. Man nimmt zwei Listen, nämlich P (liste aller Primzahlen) und NP (Liste aller Nichtprimzahlen). Die Liste der Nichtprimzahlen ist hier besonders wichtig. Beide Listen sind zu Beginn leer. Wie wird nun vorgegangen? Genau umgekehrt; man geht davon aus, alle Zahlen seien keine Primzahl. Man beginnt mit der 2, und schaut nach, ob 2 in NP einthalten ist. Das ist nicht der Fall, also ist 2 eine Primzahl. Also wird 2 zur Liste P hinzugefügt, und alle Vielfachen von 2, bis zu einer gewissen Grenze, NP hinzugefügt. Danach kommt der nächste Primzahlkandidat.

TO PRIMZAHL :OBERGRENZE
MAKE "WERT 1
REPEAT :OBERGRENZE  MAKE "WERT :WERT + 1 IF NOT MEMBERP :WERT :NP  PRINT :WERT UNTERPRIM :OBERGRENZE :WERT
END
TO UNTERPRIM :OBERGRENZE :WERT
MAKE "ADDER :WERT
MAKE "P LPUT :WERT :P
REPEAT :OBERGRENZE / :WERT  MAKE "ADDER :ADDER + :WERT UNTERUNTERPRIM :ADDER :WERT
END
TO UNTERUNTERPRIM :ADDER :WERT
MAKE "NP LPUT :ADDER :NP
END
TO LOESCHEN
MAKE "P
MAKE "NP  1
END

vorgegebene Prozeduren und Funktionen[Bearbeiten]

Logo: vorgegebene Prozeduren und Funktionen

Beispiele[Bearbeiten]

Turtle-Grafik[Bearbeiten]

  • mn_eck

to n_eck :ecken :laenge
repeat :seiten [rt 360 / :ecken fd :laenge]
end
to mn_eck :ecken :laenge
repeat :ecken [rt 360 / :ecken n_eck :ecken :laenge]
end
  • Zufallslinien
to line
make "ll1 []
make "ll2 []
make "x1 ((random 400) - 200)
make "y1 ((random 400) - 200)
make "x2 ((random 400) - 200)
make "y2 ((random 400) - 200)
make "ll1 lput :x1 :ll1
make "ll1 lput :y1 :ll1
make "ll2 lput :x2 :ll2
make "ll2 lput :y2 :ll2
make "colr random 8
setpc :colr
pu
setpos :ll1
pd
setpos :ll2
end
to lines
repeat 512 [line]
end


Fraktale[Bearbeiten]

  • Kock-Kurve und kochsche Schneeflocke
Kochsche Schneeflocke
Kochsche Schneeflocke
to kurve :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 3
if :stufe > 0 [kurve :stufe :laenge rt 60 kurve :stufe :laenge lt 120 kurve :stufe :laenge rt 60 kurve :stufe :laenge]
if :stufe = 0 [fd :laenge rt 60 fd :laenge lt 120 fd :laenge rt 60 fd :laenge]
end
to flocke :stufe :laenge
repeat 3 [kurve :stufe :laenge lt 120]
end


  • Drachenkurve
Drachenkurve
Drachenkurve
to dragon :stufe :laenge
dcr :stufe :laenge
end
to dcr :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 1.41421
if :stufe > 0 [rt 45 dcr :stufe :laenge lt 90 dcl :stufe :laenge rt 45]
if :stufe = 0 [rt 45 fd :laenge lt 90 fd :laenge rt 45]
end
to dcl :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 1.41421
if :stufe > 0 [lt 45 dcr :stufe :laenge rt 90 dcl :stufe :laenge lt 45]
if :stufe = 0 [lt 45 fd :laenge rt 90 fd :laenge lt 45]
end


  • Gosperkurve
Gosper-Kurve
Gosper-Kurve
to rg :st :ln
make "st :st - 1
make "ln :ln / 2.6457
if :st > 0 [rg :st :ln rt 60 gl :st :ln  rt 120 gl :st :ln lt 60 rg :st :ln lt 120 rg :st :ln rg :st :ln lt 60 gl :st :ln rt 60]
if :st = 0 [fd :ln rt 60 fd :ln rt 120 fd :ln lt 60 fd :ln lt 120 fd :ln fd :ln lt 60 fd :ln rt 60]
end
to gl :st :ln
make "st :st - 1
make "ln :ln / 2.6457
if :st > 0 [lt 60 rg :st :ln rt 60 gl :st :ln gl :st :ln rt 120 gl :st :ln rt 60 rg :st :ln lt 120 rg :st :ln lt 60 gl :st :ln]
if :st = 0 [lt 60 fd :ln rt 60 fd :ln fd :ln rt 120 fd :ln rt 60 fd :ln lt 120 fd :ln lt 60 fd :ln]
end


  • Pfeilspitze
to pfeilspitze :stufe :laenge
rpfeil :stufe :laenge
end
to rpfeil :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 2
if :stufe > 0 [rt 60 lpfeil :stufe :laenge lt 60 rpfeil :stufe :laenge lt 60 lpfeil :stufe :laenge rt 60]
if :stufe = 0 [rt 60 fd :laenge lt 60 fd :laenge lt 60 fd :laenge rt 60]
end
to lpfeil :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 2
if :stufe > 0 [lt 60 rpfeil :stufe :laenge rt 60 lpfeil :stufe :laenge rt 60 rpfeil :stufe :laenge lt 60]
if :stufe = 0 [lt 60 fd :laenge rt 60 fd :laenge rt 60 fd :laenge lt 60]
end
  • Pentaplexity
Penta Plexity
Penta Plexity
to pepl :stufe :laenge
make "stufe :stufe - 1
make "laenge :laenge / 2.618
if :stufe > 0 [pepl :stufe :laenge rt 72 pepl :stufe :laenge rt 72 pepl :stufe :laenge rt 180 pepl :stufe :laenge lt 36 pepl :stufe :laenge rt 72 pepl :stufe :laenge]
if :stufe = 0 [fd :laenge rt 72 fd :laenge rt 72 fd :laenge rt 180 fd :laenge lt 36 fd :laenge rt 72 fd :laenge]
end
to pp :stufe :laenge
repeat 4 [pepl :stufe :laenge rt 72]
pepl :stufe :laenge
end

Befehlsumfang[Bearbeiten]

Systembefehle[Bearbeiten]

Systembefehle
Befehl Wirkung
poall Auflisten aller Prozeduren und Variablen
pops Auflisten aller Prozeduren
pots Auflisten aller Prozedurenköpfe
pons Auflisten aller Variablen
save "dateiname
load "dateiname
erall Löschen des Speichers
erps Löschen aller Prozeduren
erns Löschen aller Variablen
bye Beenden der Logo-Sitzung

Turtle-Graphics[Bearbeiten]

Die wichtigsten Turtlegraphics-Befehle in LOGO
Befehl Kurzform Beschreibung
textscreen ts Text-Modus
fullscreen fs Graphik-Modus
home Die Schildkröte bewegt sich zur Mitte des Bildschirms mit Ausrichtung nach oben (0°)
clean Der Bildschirm wird gelöscht, die Position der Schildkröte ändert sich nicht
cleanscreen cs home und clean zusammen
hideturtle ht Die Schildkröte wird unsichtbar
showturtle st Die Schildkröte wird sichtbar
setpencolor farbewert setpc farbwert Der Schildkröte wird eine Zeichenfarbe zugewiesen
setbackground farbwert setbg farbwert Dem Hintergrund wird eine Zeichenfarbe zugewiesen
penup pu Der Stift wird von der Zeichenfläche genommen
pendown pd Der Stift wird auf die Zeichenfläche gesetzt
right winkel rt winkel Die Schildkröte dreht sich um einen bestimmten Winkel nach Rechts
left winkel lt winkel Die Schildkröte dreht sich um einen bestimmten Winkel nach Links
forward länge fd länge Die Schildkröte bewegt sich um eine bestimmte Anzahl von Einheiten nach vorne
back länge bk länge Die Schildkröte bewegt sich um eine bestimmte Anzahl von Einheiten zurück

Listen[Bearbeiten]

Befehle die Listen betreffen
Befehl Kurzform Beschreibung
first liste liefert das erste Element, das in der Liste enthalten ist
last liste liefert das letzte Element, das in der Liste enthalten ist
butfirst liste bf liste liefert alles was in der Liste enthalten ist ohne das erste Element
butlast liste bl liste liefert alles was in der Liste enthalten ist ohne das letzte Element
fput element liste fput fügt ein Element an die erste Stelle in der Liste ein
lput element liste lput fügt ein Element an die letzte Stelle in der Liste ein
memberp element liste logische Funktion, die ermittelt, ob element in liste enthalten ist
count liste liefert die Anzahl der in liste enthaltenen Elemente zurück

Quellen[Bearbeiten]

Logo-Versionen[Bearbeiten]

UCB Logo (Windows, Linux)
ACSLogo For Mac OS X (Mac 10.4 PPC, läuft auf 10.5 Intel )

Literatur[Bearbeiten]

Weblinks[Bearbeiten]

Wikipedia hat einen Artikel zum Thema: