Inhalt · Molekül oder ein Atom plaziert sein könnte, ein Automat sitzt, der alle seine Nachbarplätze regelmäßig in- spiziert und danach entscheidet, ob diese Stelle mit einem

Inhalt

Zelluläre Automaten - Definition 2

Geometrie der Zellanordnung 2

Nachbarschaften 2

Zustände und Übergangsregeln 3

Beispiel 1: eindimensionaler Automat 4

Game of Life 6

Programmlisting 8

Aufgaben 13

Gleiter und Kanonen 14

Beispiele: Weichzeichner, Diffusion 16

Beispiel: Krümelmonster 17

Beispiel: Belousov-Zhabotinski-Reaktion 19

Aufgaben 21

Gekoppelte Automaten 22

Seite 1

Zelluläre Automaten - Inhalt

© Hans-Georg Beckmann 2003Virtuelle Lehrerfortbildung imFach Informatik in Niedersachsen

Zelluläre Automaten

Haben sie sich schon einmal gefragt, wie eine Schneeflocke zu Stande kommt. Wie können die einzelnen

Wassermoleküle "wissen", wie sie sich zu diesem wunderbaren hochsymmetrischen Gebilde verbinden

müssen ?

Noch erstaunlicher ist es beim regelmäßigen Aufbau anderer Kristallstrukturen, wie z.B. dem Diamanten.

Die Wassermoleküle und auch die Kohlenstoffatome tragen keinen Bauplan für die gesamte große Struktur

in sich und dennoch kann diese regelmäßige Struktur entstehen.

Die Muster entspringen allein Wechselwirkungen der einzelnen Atome und Moleküle mit ihren direkten

Nachbarn.

Man kann sich das Entstehen eines regelmäßigen Musters so vorstellen, dass an jedem Platz, an dem ein

Molekül oder ein Atom plaziert sein könnte, ein Automat sitzt, der alle seine Nachbarplätze regelmäßig in-

spiziert und danach entscheidet, ob diese Stelle mit einem Molekül oder Atom besetzt wird oder nicht.

Ein Modell für das Wachstum von Schneeflocken oder Kristallen kann man als zellulären Automaten be-

trachten.

Eine Standarddefinition dieses Begriffes:

Ein zellulärer Automat ist eine regelmäßige Annordnung von Zellen. Jede Zelle kann eine endliche Zahl

von Werten / Zuständen annehmen und hat eine begrenzte Zahl von Nachbarzellen, die sie beeinflussen

können. Das Muster des gesamten zellulären Automaten ändert sich in einzelnen Schritten, die durch eine

Reihe von Übergangsregeln bestimmt werden, die für alle Zellen gelten.

Man kann zelluläre Automaten durch einige Eigenschaften kennzeichnen.

1. Die Geometrie der Zellanordnung

Es könnte eine 2-dimensionale Anordnung von quadratischen Zellen sein, wie sie etwa ein Schachbrett

darstellt. Eine 2-dimensionale hexagonale Zellstruktur könnte z.B. der Schneeflocke entsprechen. Auch

eindimensionale Anordnungen, in denen die Zellen in einer Reihe liegen sind möglich. 3 - oder gar 4-

dimensionale Anordnungen sind denkbar aber nicht in jedem Falle anschaulich darstellbar.

2. Die Nachbarschaft der Zellen

Es muss festgelegt werden, welche Nachbarn eine Zelle haben soll. In einem Quadratgitter könnte man 4

Zellen als Nachbarn angeben, aber auch 8 Zellen als Nachbarn sind möglich.

Seite 2

Zelluläre Automaten - Definition


Der Mathematiker und Informatiker J. von Neumann , der als einer der ersten solche Automaten

untersuchte, gab vier Felder als Nachbarn zu einer Zelle an. Ihm zu Ehren nennt man das eine von -

Neumann-Nachbarschaft. Nimmt man alle acht möglichen angrenzenden Felder in einem zweidimensiona-

len Gitter als Nachbarn, dann spricht man zu Ehren von Edward F. Moore von einer Moore-Nachbarschaft.

3. Die Zustände

Jede Zelle kann eine festgelegt Anzahl von Zuständen einnehmen. Am häufigsten wird man Automaten mit

nur zwei Zuständen vorfinden, die man als 0 oder 1 oder aber "tot" und "lebendig" interpretieren kann.

4. Die Übergangsregeln

Die große Anzahl möglicher zellulärer Automaten entspringt ihren großen Variantenreichtum an Regeln,

die man für das "Zusammenleben" der Zellen angeben könnte.

Wenn eine Zelle z.B. k Zustände hat und jeweils n Nachbarn, dann kann man k mögliche Regeln

formulieren.

Bei einer Mooreschen Nachbarschaft und jeweils 2 Zuständen sind es so schon 10 77 Regeln . Nur ein

kleiner Bruchteil davon konnte bis heute in zellulären Automten untersucht werden.

Beispiel 1: ein 1-dimensionaler zellulärer Automat

Man habe eine unendliche Reihe von qudratischen Zellen, die die Zustände 0 oder 1 haben können. Zu Be-

ginn seine alle Zellen im Zustand 0. Irgend eine der Zellen wird dann in den Zustand 1 versetzt.

In einer graphischen Darstellung könnte das dann wie folgt aussehen:

Seite 3

zelluläre Automaten - Nachbarschaften


kn

Neumann- Nachbarschaft Moore- Nachbarschaft

Zelle im Zustand "1"

Es gelten nun folgende Regel:

Seien mit X,Y und Z drei nebeneinanderliegende Zellen bezeichnet, dann gilt für den Zustand der Zelle Y ,

die zwischen X und Z liegt: Y = ( X + Z ) mod 2.

Das bedeutet anschaulich für eine beliebige Zelle in der Mitte einer Dreiergruppe auf der unendlichen

langen Zeile des Automaten, dass es acht mögliche Übergänge gibt:

Bei jedem Durchlauf ( für jede Generation ) werden alle Zellen des Automaten mit der Übergangsregel

"bearbeitet", so das fessteht, ob sie in der nächsten Generation lebend oder tot sind ( also den Zustand 1

oder den Zustand 0 haben).

Und was kommt dabei nach n Generationen heraus ?

In einem einfachen Javaprogramm können wir das leicht prüfen. Die einzelnen Generationen des zellulä-

ren Automaten stellen wir als Zeilen untereinander dar. Ist der Zustand einer Zelle 0, dann malen wir

nichts. Ist der Zustand 1, malen wir einen kleinen schwarzen Kreis.

Natürlich ist dieser Automat nach links und rechts begrenzt. Daher müssen wir uns für die Randfelder be-

sondere Regeln einfallen lassen, die aber nur der Unzulänglichkeit des Automaten entspringen. Wir been-

den den Durchlauf durch die Generationen, wenn im zweiten Feld ( von links ) oder im vorletzten Feld

( von rechts ) eine "1" auftritt.

// Zellautomat1.java// Hans-Georg Beckmann on Sat May 31 2003.// Ein eindimensionaler zellulärer Automtat. Zustandsmenge {0,1}// Am Anfang sei eine Zelle auf Zustand 1 alle anderen auf 0// Übergangsregel: Eine Zelle Y zwischen X und Z wird in der nächsten// Generation zu Y = ( X + Z ) mod 2

import java.awt.*;import java.applet.*;

public class Zellautomat1 extends Applet{ Label Titel = new Label("Eindimensionaler zellulärer Automat",Label.CENTER); int[] Automat = new int[150]; // der zelluläre Automat am Bildschirm int[] Automatneu= new int[150]; // für die nächste Generation public void init() { setLayout (null); Titel.setBounds(180,10,140,25); add(Titel); for ( int i=0; i<150;i++) {Automat[i]=0;Automatneu[i]=0;}

Seite 4

zelluläre Automaten - Beispiel 1


0 0 0 0 0 1 0 0 1 0 1 0

1 0 0 1 1 1 0 1 0 1 1 1

1 1 1 0

0 0 1 1

Automat[75]=1; // Startwert } public void paint (Graphics g) { g.fillOval(5+300,36,3,3); for (int GenCount=1;GenCount<75;GenCount++) { for(int i=1;i<149;i++) // Feld ganz links und ganz rechts nicht ändern {Automatneu[i]=(Automat[i-1]+Automat[i+1]) %2;}

for(int i=0;i<150;i++) // Nun Automatneu --> Automat für die Darstellung {Automat[i]=Automatneu[i];} for(int i=0;i<150;i++) {if(Automat[i]==1) g.fillOval(5+i*4,35+GenCount*4,3,3);} }// ende von for GenCount }// ende von paint}// Ende vom Applet

Knapper gehts kaum noch und das Ergebnis ist uns aus anderen Zusammenhängen wohlbekannt. Man

könnte meinen, das es mit dem Sierpinskidreieck etwas unheimlich ist, da es immer wieder in unerwarteter

Weise auftaucht.

Allerdings sieht das Ergebnis ja vielleicht ganz anders aus, wenn sie die Anfangsgeneration anders setzen.

Probieren sie es aus !

Seite 5

zelluläre Automaten - Beispiel 1


Ein berühmtes Beispiel "Das Spiel des Lebens"

Das Spiel hat seinen Hintergrund in der Biologie. Es wurde 1970 von John Horton Convay erfunden und

wird auf einem Quadratgitter gespielt. Es ist seit dem in unzählbaren Büchern und Zeitschriften beschrie-

ben und erörtert worden, daher darf es auch hier nicht fehlen.

Zellen auf diesem Gitter werden geboren, bleiben am Leben oder sterben ab in Abhängigkeit der

Bevölkerungsdichte in ihrer Nachbarschaft ( gemeint ist die Moore-Nachbarschaft) . Damit haben die Zel-

len wieder nur zwei mögliche Zustände 0 oder 1. (0 = tot und 1 = lebend )

Die Regeln sind einfach:

Eine lebende Zelle bleibt für die nächste Generation am Leben,

wenn sie zwei oder drei lebende Nachbarn hat.

Eine lebende Zelle stirbt an Vereinsamung ( und ist in der

nächsten Generation leer ), wenn sie weniger als zwei lebende

Nachbarn hat..

Eine lebende Zelle stirbt wegen Überbevölkerung, wenn sie

mehr als 3 lebende Nachbarn hat.

Eine tote Zelle wird neugeboren, wenn sie genau drei Nachbarn hat.

Es ist schnell einzusehen, dass eine Startkonfiguration geben muss, da auf einem vollkommen leeren

Zellgitter keine Leben von selbst entstehen kann.

Bevor wir uns daran machen ein Computerprogramm zu entwerfen oder mit einem Programm zu arbeiten,

müssen die Regeln "zu Fuß" veranschaulicht werden.

Dazu ein Beispiel: Die grünen Felder sind in der Startgeneration lebendig. In den Feldern ist jeweils einge-

tragen, wieviele lebendige Nachbarn es gibt. Daraus ergibt sich die zweite Generation.

Seite 6

zelluläre Automaten - Spiel des Lebens


Zustand Nachbarzahl Folgezustand01

33

11

010

1

< 2 oder > 3< 2 oder > 3

00

2

20

1

A B C D E F G H I J K123456

001

1 123

24

1 033

12

789

11

11

42

21

21

Generation 1


11

1 221

34

2 123

23

789

1 1 31

11

21

Generation 2

D5 , E7,E6 bleiben am LebenD6, C7 sterbenC6 , E5 werden lebendig

Es ergeben sich neue Nachbar-schaftszahlen.

Für ganz fleißige Schülerinnen und Schüler wäre es bestimmt eine netter Zeitvertreib auf Papier mit

Rechenkästen verschiedene Startbevölkerungen und ihr Wachstum oder ihr Absterben zu untersuchen.

Aber zur gründlicheren Untersuchung dieses Automaten kommt nur ein Computerprogramm in Frage.

Es muss im Prinzip so aussehen, wie das Programm für den eindimensionalen Automaten.

Für dieses "Game of Life" findet man Beispielprogramme in Hülle und Fülle. Manche sehr elegant und

viele sehr funktionstüchtig aber schwer zu durchschauen. Besonders im Internet finden Schülerinnen und

Schüler Programmlistings, die sich dank fehlender Erläuterung kaum zum Nachprogrammieren eignen. Im

nachfolgenden Programm wurde daher nur wenig Mühe auf Eleganz und raffinierte Methoden zur Ermitt-

lung der Anzahl der Nachbarn verwendet, und dafür hoffentlich eine übersichtliche und nachvollziehbare

Lösung gefunden.

Das Programm soll ...

- die Eingabe der Startkonfiguration mit der Maus ermöglichen

- auf Knopfdruck die nächste Generation am Bildschirm zeigen

Seite 7



D5 , E5,E6 bleiben am LebenC6, E7 sterbenD7 , F6 werden lebendig



1 212

24

2 134

32

11

789

11

11

31

2 1

Generation 3

D5 , E5, F6 bleiben am LebenC7, E6 sterbenF5 , E7 werden lebendig



1 211

13

3 235

23

122

789

11

11

21

1

Generation 4

E5 , F5, F6 bleiben am LebenD5, E7 sterbenD6, E4 werden lebendig

Das ist die Anfangsfigur um ei-nen Schritt in der Diagonalenverschoben.

A B C D E F G H I J K123456789

Generation 5

- die aktuelle Anzahl lebender Zellen angeben

- einen Reset-Button haben, um neu starten zu können.

Es wird mit zwei zweidimensionalen Feldern gearbeitet- Automat und Automatneu. Das erste enthält die

aktuelle Generation, das zweite wird die zukünftige Generation enthalten. Dieses zweite Feld wird bei vor

Abarbeitung des aktuellen Automaten zuerst leer gemacht wird. Dann wird es durch die Übergangsregeln

aus dem aktuellen Feld heraus gefüllt. Am Ende wird das Feld "Automatneu" in das Feld "Automat" ko-

piert und als neue Generation am Bildschirm gezeigt. Die Felder sollen boolsche Werte enthalten ( man

hätte aber auch wieder 0 und 1 nehmen können ).

Im nachfolgenden Beispiel ist das Speilfeld fest auf 40 x 40 Felder gesetzt.

Das Listing:

// Life1.java// Life1//// Created by Hans-Georg Beckmann on Tue May 20 2003.// Copyright (c) 2003 __MyCompanyName__. All rights reserved.// A simple Java applet//

import java.awt.*;import java.applet.*;import java.awt.event.*;

public class Life1 extends Applet implements MouseListener,ActionListener{ Button NewGen = new Button("Nächste Generation"); Button MyReset= new Button("Reset"); TextField Anzahl= new TextField(); TextField Genzahl = new TextField(); Label GenCountLabel= new Label("Generation :"); Label LifeCountLabel= new Label("Lebende Zellen:"); Label Titel= new Label("Game of life",Label.CENTER); boolean[][] Automat= new boolean[40][40]; // der Automat am Bildschirm boolean[][] Automatneu= new boolean[40][40]; // die nächste Generation int GenCount=1; // für die Startgeneration ist es 1 int LifeCount=0; // noch keine Zelle zum Leben erweckt int nachbarn; public void init() { setLayout (null); addMouseListener(this); for(int i=0;i<40;i++) for(int j=0;j<40;j++) { Automat[i][j]=false; // Alle Zellen im Automaten erzeugt alle tot Automatneu[i][j]=false; // Auch den zweiten Automaten erzeugt } NewGen.setBounds(60,500,140,25); NewGen.addActionListener(this);

Seite 8



MyReset.setBounds(320,500,140,25); MyReset.addActionListener(this); add(NewGen); add(MyReset); Titel.setBounds(200,20,140,25); add(Titel); LifeCountLabel.setBounds(120,540,90,25); add(LifeCountLabel); Anzahl.setBounds(240,540,60,25); add(Anzahl); GenCountLabel.setBounds(120,570,90,25); add(GenCountLabel); Genzahl.setBounds(240,570,60,25); add(Genzahl); }//***************************************************************// Die paint-Methode stellt die einzelnen Zellen in einem Gitter // dar oder löscht eine Zelle, wenn sie nicht mehr lebt//*************************************************************** public void paint (Graphics g) { //********************************* zuerst das Liniengitter *************** g.setColor(Color.black); for(int i=0;i<41;i++) { g.drawLine(60+i*10,60,60+i*10,460); } for(int j=0;j<41;j++) { g.drawLine(60,60+j*10,460,60+j*10); }// Ende der Gitterdarstellung //********************************* nun die Zellen ***************************** for(int i=0;i<40;i++) for(int j=0;j<40;j++) { if(Automat[i][j]==true) { g.setColor(Color.black); // falls Leben, dann schwarzer Kreis g.fillOval(60+i*10+1,60+j*10+1,8,8); }// Ende von if lebend /* else { Hier Platz lassen für Versionen, in denen man auch

die toten Zellen irgendwie darstellen möchte } */ }// Ende von for i,j }// Ende von paint //**********************************************************************************// Nun werden Nachbarn gezählt. Dieser Methode wird eine Zeilen - und eine// Spaltennummer übergeben. Dann werden in drei Zeilen und drei Spalten die// Felder abgesucht. Liegen die koordinaten der Felder außerhalb des zulässigen// Bereichs , wird nicht gesucht. Am Ende wird das Feld, um dessen Nachbarn es geht,// wieder aus der Zählung herausgenommen//********************************************************************************* public int countNachbarn(int zeile, int spalte) { nachbarn=0; for(int z=zeile-1;z<zeile+2;z++) // 3 Zeilen for(int s=spalte-1;s<spalte+2;s++) // 3 Spalten

Seite 9



{ if((z>0)&&(z<39)&&(s>0)&&(s<39)) // Koordinaten zulässig ? { if(Automat[z][s]==true) nachbarn++; // wenn ja, lebende Zelle ? } } if(Automat[zeile][spalte]==true) nachbarn--; // eventuell wieder abziehen return nachbarn;

}// Ende von countnachbarn //*************************************************************************** // Die Methoden vom MouseListener, die sein müssen//*************************************************************************** public void mousePressed(MouseEvent e) {} public void mouseReleased(MouseEvent e) {} public void mouseEntered(MouseEvent e) {} public void mouseExited(MouseEvent e) {}//*************************************************************// ein Mausklick soll auf dem Spielfeld eine Zelle an - und// abschalten können. Dabei muss beachtet werden, dass der// Klick auch im Spielfeld stattfindet, um die Zeile und// die Spalte feststellen zu können und Indexfehler zu vermeiden//************************************************************** public void mouseClicked(MouseEvent e) { int x,y,i,j; x=e.getX(); y=e.getY(); //*********************************************************************** // Ermittle aus der x und y Position der Maus die Zelle des Automaten, // in die geklickt wurde und ändere ihren Zustand //*********************************************************************** i=(x-60)/10; j=(y-60)/10; if((i>=0)&&(i<40)&&(j>=0)&&(j<40))// Nur wenn im Spielfeld geklickt wurde { if(Automat[i][j]==true) { Automat[i][j]=false; LifeCount=LifeCount-1; Anzahl.setText(""+LifeCount); } else { Automat[i][j]=true; LifeCount=LifeCount+1; Anzahl.setText(""+LifeCount); } repaint(); } }

Seite 10



//*************************************************************************** // Dann die Methode vom ActionListener//*************************************************************************** public void actionPerformed(ActionEvent e) { Object welcher; welcher=e.getSource(); if(welcher==NewGen) // der Button für die nächsteGeneration { for(int i=0;i<40;i++) for(int j=0;j<40;j++) { Automatneu[i][j]=false;// Automatneu für nächsten Durchgang wieder löschen }

//************************** Nachbarn zählen für alle Zellen *********************// Hier sind die Regeln versteckt, die für die nächste Generation gelten sollen// Tot und 3 lebende Nachbarn --> Leben// Leben und < 2 oder >3 lebende Nachbarn --> Tot// Zustand unverändert bei 2 lebenden Nachbarn//******************************************************************************** for(int i=0;i<40;i++) for(int j=0;j<40;j++) { // Zähle Nachbarn if((countNachbarn(i,j)< 2)||(countNachbarn(i,j)>3)) {Automatneu[i][j]=false;} if(countNachbarn(i,j)==3) {Automatneu[i][j]=true;} if(countNachbarn(i,j)==2) {Automatneu[i][j]=Automat[i][j];} } // ende von for i und j//********************************************************************************// Nun muss Automatneu, der ja nur das Zwischenergebnis festhält wieder in Automat// zurückkopiert werden, um dann mit repaint() sichtbar gemacht zu werden.// eine direkte Zuweisung der beiden Arrays klappt nicht, das muss stückweise sein! //******************************************************************************** for(int i=0;i<40;i++) for(int j=0;j<40;j++) { if(Automatneu[i][j]==true) Automat[i][j]=true; else Automat[i][j]=false; } //******************* die Lebenden zählen *********************** LifeCount=0; for(int i=0;i<40;i++) for(int j=0;j<40;j++) { if(Automat[i][j]==true) LifeCount=LifeCount+1; } Anzahl.setText(""+LifeCount); GenCount++; Genzahl.setText(""+GenCount); repaint(); } // Ende von NewGen //*************************** Nun Resetknopf ********************************** if (welcher==MyReset) { for(int i=0;i<40;i++) for(int j=0;j<40;j++)

Seite 11



{ Automat[i][j]=false; // Alle Zellen im Automaten tot Automatneu[i][j]=false; }// Ende von for i und j LifeCount=0; Anzahl.setText("0"); GenCount=1; Genzahl.setText(""+GenCount); repaint(); } // Ende von MyReset }// Ende von action Performed }//Ende von Applet

Das Programm kann beliebig verändert und erweitert werden. Schreibt man eine eigene Klasse "Zelle" ,

die das Malen und Löschen individuell für eine Zelle ermöglicht, ohne mit repaint arbeiten zu müssen,

dann wird der Programmablauf beschleunigt.

Man kann auch recht einfach dafür sorgen, dass die Generationen nicht immer nur durch ein Klick auf den

entsprechenden Knopf erzeugt werden sondern das Spiel bis zu einer bestimmten Abbruchbedingung

selbstständig abläuft.

Wie verhält sich eine willkürlich gesetzte Anfangspopulation ?

Es ist nicht möglich sofort vorherzusagen, was mit dieser Konfiguration geschehen wird.

Bleibt sie am Leben ?

Vermehren sich die Zellen bis zu einer

stabilen Bevölkerungszahl ?

Entsteht ein symmetrisches Bild ?

Nach wievielen Generationen ist mögli-

cherwesie keine Leben mehr auf dem Spiel-

feld ?

Probieren sie z.B. das nebenstehende Start-

bild. Es besteht aus 8 Zellen.

Nach einigen Generationen kann das Bild

schon ganz anders aussehen:

Seite 12



Hier ein Bild aus der 12. Generation.

Glauben sie etwa, dass dieses sehr symmetrische

Bild aus der oben gezeigten Startaufstellung hervor-

gehen kann ?

Wenn sie ein wenig Erfahrung mit dem Game of

Life gesammelt haben, können sie aber vielleicht er-

ahnen, wie es mit diesen vier Dreiergruppen wohl

weitergehen wird .

Aufgabe:

Untersuchen sie das Verhalten verschiedener selbstgewählter Anfangskonfigurationen mit dem Programm

Life1. Versuche sie Startbilder mit möglichst wenigen lebenden Zellen zu finden, die zu einer stabilen

"Bevölkerung " führen oder gar zu einem ungebremsten Wachstum ( wenn man von der Begrenzung des

Spielfeldes einmal absieht ).

Seite 13

zelluläre Automaten - Aufgaben, Gleiter und Kanonen


Gleiter und Kanonen

Schon kurz nach Erfindung des Spiels

Game of Life fand Conway eine Konfigu-

ration mit eines seltsamen Eigenschaft.

Nach vier Generationen hat sie wieder

ihre Anfangskonfiguration eingenommen

und sich dabei auf dem Spielfeld um je ei-

nen Schritt entlang der x - und y- Achse

bewegt ( also entlang der Diagonalen ).

Er nannte dieses Lebewesen Gleiter, weil

es über das Spielfeld gleitet. Es ist die

schon oben genau beschriebene Konfigu-

ration aus nur 5 Zellen.

Ein Jahr später fanden dann Studenten des

MIT eine Gleiterkanone, die unablässig

nach je 20 Generationen neue Gleiter er-

zeugt, die dann über das Spielfeld wan-

dern. Damit war dann die Frage beantwor-

tet, ob es möglich wäre, eine Konfigurati-

on zu finden, die im Prinzip unendlich

wachsen kann. Auch wenn unsere Gleiter

vom Bildschirm verschwinden, so existie-

ren sie doch im Spiel weiter, da das Spiel-

feld unendlich groß ist. Jeder neue Gleiter

vergrößert also die Anzahl lebender Zel-

len.

Probieren sie die Gleiterkanone aus.

Seite 14

Gleiter und Kanonen


Gleiterkanone

Gleiterkanone nach 91 Generationen

Solche Gleiterkanonen lassen sich auch um 90 Grad (180 Grad , 270 Grad ) gedreht am Bildschirm plazie-

ren. Hat man eine Kanone am oberen Rand und eine andere am linken Rand, dann müssen die Gleiter auf-

einander treffen. Was passiert in so einem Fall ? Wenn die Kanonen passend stehen, können sich die abge-

schossenen Gleiter gegenseitig auslöschen.

Das kann man als einen logischen Baustein interpretieren. Wenn an einer Position im Gitter ein Gleiter

existiert dann sei das logisch "1". Wenn an der Position kein Gleiter existiert, dann sei es logisch "0".

Eine Gleiterkanone am oberen Rand unseres Spielfeldes produziert also unablässig eine Folge von Glei-

tern. Eine Dualzahl, die eine Folge von 0 und 1 ist , wird durch Gleiter im Gitter so kodiert, dass sich diese

Gleiter senkrecht auf den Strom der aus der Gleiterkanone kommt richten. Da sich zwei Gleiter vernichten,

wird aus einer 1 im Datenstrom eine Null und wenn der Datenstrom eine 0 enthält ( also keinen Gleiter )

dann kommt die 1 aus dem kontinuierlichen Datenstrom durch.

Zugegeben, man kann sich einfachere Arten der Realisierung einer NOT-Schaltung vorstellen. Interessant

ist aber, dass das NOT-Gatter keine Struktur besitzt, denn es besteht nur aus einem Bereich im Gitter, in

dem Gleiter aufeinandertreffen. Es wurden unterdessen auch schon NAND- , UND - und ODER-Gatter

konstruiert. Damit könnte das Spiel zu einer Rechenmaschine werden. Und tatsächlich wurde 1974 die so-

genannte Berechnungsuniversalität des Spiel Life bewiesen.

Ein System heißt berechnungsuniversell, wenn es formal gleichwertig zu einer Turingmaschine ist, was be-

deuten würde, dass jedes Programm, dass auf einer Turingmaschine möglich ist, auch in diesem System

möglich ist.

Aufgabe:

a)Ändern Sie das Spiel so ab, dass man die Gleiterkanone auf Buttondruck als Startkonfiguration erhält.

b) Ändern Sie das Spiel so ab, dass man zwei Generationen "zurückblättern" kann.

Seite 15

Gleiter und Kanonen


1

0

0 1

1

1

1

0

1

1

1

0

1

Von der Kanone kommenderStrom aus Gleitern (Einsen )

Dualzahl aus Gleitern undNichtgleitern ( 0 und 1 )

Ausgabedaten aus Gleiternund Nichtgleitern ( 0 und 1)

Position des Aufeinandertreffens

Das Spiel Life und das dazu gehörende Javaprogramm sind Grundlage für weitere Automaten, die sich nur

wenig von Life unterscheiden aber zu ganz anderen Ergebnissen führen. Es reicht aus, die Übergangsre-

geln zu ändern.

Ein weiteres Beispiel: Weichzeichnen als zellulärer Automat

Stellen sie sich ein Gitter vor, in dem einige Zellen Farbig sind - etwa rot, und andere Zellen bleiben weiß.

Für die nächste Generation werden die Rotfarbwerte aller Nachbarzellen addiert und durch 8 dividiert, was

dem durchschnittlichen Farbwert aller Nachbarzellen entspricht. Das Ergebnis der Rechnung wird der neu-

ne Rotfarbwert der Zelle.

In den Gebieten des Automaten, in dem alle Zellen und ihre Nachbarzellen den gleichen Farbwert haben,

wird nichts passieren. was aber geschieht am Rand ?

Man muss das Javaprogramm für Game of Life nur ein wenig verändern. An Stelle von countNachbarn tritt

z.B.

public int getNachbarfarbe(int zeile, int spalte)

{

farbwert=0;

int anzahl=0;

for(int z=zeile-1;z<zeile+2;z++)

for (int s=spalte-1;s<spalte+2;s++)

{

if((z>0)&&(z<39)&&(s>0)&&(s<39)) // irgendwo in der Mitte

{

farbwert=farbwert+Automat[z][s];

anzahl++;

}

}

return farbwert/anzahl;

}// ende von getNachbarfarbe

Ob sie nun mit dem Farbwert tatsächlich eine Farbe setzen oder aber nur einen Graustufenwert ist nicht

wichtig. Es entsteht ein Weichzeichnungseffekt. Mit jeder Generation wird dieser Effekt stärker, bis sich

die Anfangskonfiguration nahezu aufgelöst hat.

Seite 16

Beispiele und Aufgaben


Aufgabe: Realisieren Sie den Weichzeichnerautomat.

Ein Diffusionsautomat

Eine weitere einfache Änderung der Übergangsre-

geln besteht darin, per Zufall eine Zelle mit einer ih-

rer Nachbarzellen tauschen zu lassen. Es entsteht

eine "Diffusion" der Zellen, die am Anfang gesetzt

sind in den unbesetzten Raum hinein. Bleibt man

bei dem groben Gitter aus dem Programm Life,

dann sieht das nicht so aus, wie man es sich wünscht.

Aufgabe:

Realisieren sie den Automaten und lassen sie dabei

die Zellgröße auf 2 x 2 Punkte schrumpfen.

Der Anfangszustand sollte dabei nicht mehr punkt-

weise mit Mausklicks gesetzt werden, sondern als

ein großes gefülltes Rechteck erscheinen.

Ein Krümelmonsterautomat

(Spektrum der Wissenschaft, Sonderheft 10, Computerkurzweil IV , S.86 ff )

David Griffeath von der Universität in Wisconsin hat einen zellulären Automaten entworfen, der selbst

wieder ein ganzes Universum an möglichen Variationen öffnet.

Die Zellen im 2- dimensionalen Raster haben n Zustände die von 0 bis n–1 durchnummeriert sind.

Hat nun eine Zelle den Zustand k aus der Menge {0,1,2,.....,n–1} dann ändert sich dieser Zustand nach fol-

gender Übergangsregel:

Seite 17



Hat eine Zelle in der von Neumann-Nachbarschaft genau den Zustand k+1, dann nimmt auch die Zelle

diesen Zustand ein. Obwohl immer alle 4 Nachbarn abgefragt werden, kann dennoch eine Zelle in einem

Durchgang nur einmal ihren Zustand ändern auch wenn mehrere Nachbarzellen den Zustand k + 1 haben.

Hat eine Zelle z.B. den Zustand 3 und ist von Nachbarn mit den Zuständen 2, 4, 5 und 1 umgeben, dann

wird die Zelle zuerst den Zustand 4 einnehmen, erst in der nächsten Generation dann den Zustand 5 anneh-

men und sich danach nicht mehr ändern, wenn sich nicht die Nachbarn ändern. Man könnte sagen, dass

erst die Zelle 4 die Zelle im Zentrum "gefressen" hat und dann die Zelle mit dem Zustand 5 das noch ein-

mal wiederholt.

Es sollen noch einige Sonderregeln gelten: Sowohl die Zustandsmenge als auch das Automatengitter sind

zyklisch. Hat eine Zelle den Zustand (n–1), dann gilt als nächst größerer Zustand wieder 0. Das bedeutet

nur, dass die Übergangsregel lautet: Hat eine Zelle den Zustand k und eine Nachbarzelle genau den Zu-

stand (k+1) mod n, dann nimmt die Zelle diesen Zustand an. Für das Gitter gilt Gleiches.

Hat ein Gitter x mal y Zellen, mit den Nummern 0....x – 1 bzw. 0 .... y – 1 dann wäre die Zellnummer x

wieder 0 und auch die Zellnummer y entspricht 0. Anschaulich ist also die Gitterebene zu einem Torus ge-

worden.

Zu Beginn soll das Gitter mit Zufallswerten gefüllt sein und dann geht es los. Die kosmische Uhr tickt ein-

mal und das Fressen und Gefressenwerden geht los. Es gibt keinen Rand und es gibt keinen größten und

kleinsten Zustand. Was wird passieren ?

Die am Anfang wie Krümel versteuten Farbflecken werden größer werden, Strukturen bilden und Nachbar-

krümel aufressen ?

Sie sollten es selbst probieren. Stellen sie die Zustände als unterschiedliche Farben dar. Es sollten hinrei-

chend viele Zustände sein. Bedenken sie aber, wenn es z.B. 20 Zustände gibt ( 0 bis 19 ) und eine Zelle hat

etwa den Zustand k=9, dann können ihr nur Nachbarzellen mit dem Zustandswert 10 direkt gefährlich wer-

den. Wie groß ist bei 20 Zuständen und vier Nachbarn die Wahrscheinlichkeit, dass das auch vorkommt ?

Wohl sehr klein. Gäbe es aber nur 4 Zustände, dann wäre das Spiel wohl recht langweilig, weil schnell am

Seite 18



4

5

3 8

1

4

5

4 8

1

4

5

5 8

1

Ende. Wählen sie zwischen 8 und 16 Zuständen ( Farben ). Wählen sie weiterhin ein Spielfeld von 200 x

200 Zellen Größe. Wenn sie die Generationen mit einem Buttonklick erzeugen wollen, könnte es sein,

dass Veränderungen sehr langsam sichtbar werden. Um ihnen Schmerzen im Handgelenk zu ersparen soll-

ten sie dann pro Buttonklick gleich 10 Generationen rechnen lassen. Sie haben jeden Freiraum zum Expe-

rimentieren. Die Ergebnisse sind erstaunlich und werfen viele neue Fragen auf.

Hier einige Momentaufnahmen aus den ersten 100 Generationen bei 8 Zuständen:

Aufgabe: Schreiben sie ein "Krümelmonsterapplet"

Simulation einer chemischen Reaktion (Belousov - Zhabotinski- Reaktion)

1951 wurden oszillierende chemische Reaktionen entdeckt in denen Zhabotinski später periodische Muster

feststellen konnte. Diese Reaktionen lassen sich durch einen zellulären Automaten simulieren.

Die Zellen im 2-dimensionalen Gitter haben n Zustände, die mit 1 bis n durchnummeriert sind.

Als Übergangsregeln werden formuliert : Ist x der Zustand einer Zelle, dann gilt:

x = 1 ––––> x = a/k1 + b/ k2 im Folgezustand

mit a = Anzahl der Nachbarn im Zustand x mit 1< x < n

und b= Anzahl der Nachbarn im Zustand n

und k1 und k2 frei wählbare Parameter

x = n ––––> x = 1

1 < x < n ––––> x = s/(a + b + 1 ) + g

mit s = Summe der Zustände der Zelle und ihrer Nachbarn

Seite 19



daher: s/(a + b + 1) ein "Durchschnittszustand" von Zelle und

ihrer Umgebung. Ist das Ergebnis > n , dann wird x = n

Der Anfangszustand kann per Zufall gesetzt sein. Die Parameter sind so zu wählen, dass nicht ein Zustand

erzeugt wird, der größer als n oder kleiner als 1 ist. Die Zustandswerte lassen sich wieder als Farben dar-

stellen. Als mögliche Regel für die Farbwahl ist es denkbar, für x=1 die Farbe Schwarz zu wählen und für

x = n Weiß. Die Zustände 1 < x < n kann man direkt einer Farbe zuornden oder aber durch den Modulo-

Operator in wenige Farben aufteilen lassen.

In einem Javaapplet wird dann zuerst eine Anfganskonfiguration per Zufall gesetzt.

Hier für einen 200 x200 Felder großen Automat:

for(int x =0;x<200;x++)

for(int y =0;y<200;y++)

{

Automat[x][y]=zufall(250)+1; // Zahlen zwischen 1 und 250

Automatneu[x][y]=Automat[x][y];

}

Im Beispiel sind also 250 mögliche Zustände für den Automaten möglich. Die Methode zufall ist selbst ge-

schrieben und liefert Zahlen zwischen 0 und 250.

Zwei Automaten werden wieder gebraucht, weil die Änderungen im Zustand einer Zelle erst in der Nach-

folgegeneration wieder eine Rolle spielen sollen. Für die Ausgabe des Automaten am Bildschirm kann man

in der paint-Methode setzen:

for(int i=0;i<200;i++) for(int j=0;j<200;j++) { farbwert=Automat[i][j]; if(farbwert==1) g.setColor(Color.black); else if(farbwert==250) g.setColor(Color.red); else { farbwert=1+farbwert%249; g.setColor(new Color(farbwert,80,80)); // ein rot } g.fillRect(60+i*2+1,60+j*2+1,2,2);

}

Eine Methode zum "Reagieren" mit den Nachbarzellen kann genau so geschrieben werden, wie es schon

im Weichzeichner und im Krümelmonsterautomat gemacht wurde.

Als geeignete Werte für die Parameter k1, k2 und g kann man es z.B. mit folgenden Werten probieren:k1=3 und k2=3 ( die Werte für diese Parameter sollten zwischen 1 und 8 liegen )g=28 oder g=35 ( der Wert für g sollte zwischen 1 und 100 liegen )

Seite 20



Man muss schon viele Generationen abwarten, bevor gute Ergebnisse zu sehen sind. Lassen sie daher nichtnur eine Generation pro Buttonklick rechnen , sondern gleich 500 Generationen.

Dieser Automat ruft nach Verschönerungen. Schreiben sie das Applet und fügen sie folgende Eigenschaf-ten hinzu: - Man soll die Anzahl der Zustände eingeben/wählen können ( mindestens 4 maximal 255 )- Man soll die Anzahl der Generationen pro Buttonklick angeben/wählen können- Man soll die Anzahl der Farben wählen können ( vielleicht auch eine "Farbtafel" )- Man soll die Werte für k1, k2 und g angeben / wählen können.

Seite 21



k1=k2=3 und g=28; Generation 1000; Farben 16 k1=k2=3 und g=28; Generation 6000; Farben 16

k1=k2=3 und g=35; Generation 0; Farben 250 k1=k2=3 und g=35; Generation 2000; Farbe 250

Zum Abschluss noch ein Auszug aus einem Vortrag über gekoppelte Automaten von Eckart Modrow(München, 2003)Ein Beispiel: Gekoppelte AutomatenDas überraschende Verhalten gekoppelter Systeme kann mit zellulären Automaten sehr gut demonstriert werden. Einerseits nutztman hier ziemlich einfache endliche Automaten, so dass die Benutzung der entsprechenden Beschreibungsmittel geübt werdenkann, andererseits sind die Resultate so vielfältig, dass die Arbeit trotz dieser Einfachheit alles andere als langweilig ist. Mankann leicht Systeme modellieren, deren Verhalten sich kaum aus dem Simulationsprogramm selbst erschließen lässt. Die Anord-nung der Elementarautomaten in Gittern liefert ein exzellentes Beispiel für den Umgang mit zweidimensionalen Feldern. Ver-teilt man die Funktionalität auf geeignete Objektklassen, dann kann die Darstellung der Ergebnisse standardisiert werden, sodass Experimente an den Automaten ohne großen Programmieraufwand zu realisieren sind. Die Unterrichtseinheit ist je nachder Fortschrittlichkeit der eingesetzten Programmiertechniken im Unterricht der Sek. II anzusetzen. Der erforderliche Zeitbedarfwird wesentlich dadurch bestimmt, ob – und wenn, welche – Teile des Simulationsprogramms vorgegeben werden.

Wir wollen einen zellulären Automaten bauen, der auf dem Gefangenendilemma aufbaut, aber etwas abgewandelt auf den Han-del im Internet. Das Verhalten der Handelspartner wird durch endliche Automaten simuliert, die auf einem in beiden Dimensio-nen abgeschlossenen Gitter sitzen und innerhalb einer Moore-Nachbarschaft Handel mit den Partnern treiben. Sie tauschen –wie im Internet üblich – Waren gegen Geld. Dabei gibt es unterschiedliche Arten von Geschäftpartnern:

• Naive kooperieren immer, liefern also den korrekten Gegenwert.• Betrüger kooperieren nie.• Gewitzte kooperieren anfangs und reagieren danach so,wie der Partner zuletzt.

Hier ist die Idee des Zustands und seiner Wechsel zentral. Des Weiteren spielt aber auch die Idee der Berechenbarkeit in ihremprognostischen Aspekt eine Rolle, da sich die Frage stellt, ob Voraussagen über das Verhalten des Systems möglich sind, ohne esvollständig zu realisieren, also wirklich „laufen zu lassen“. Die Implementierung über Objekte liefert Beispiele für strukturierteZerlegungen und einfache Programmierkonzepte.

Wir können dieses Verhalten der Handelspartner durch Zustands-diagramme beschreiben. Entsprechende, zufällig erzeugte Auto-maten ordnen wir in einem Gitter an und färben sie entsprechendihrem Zustand (schwarz als Betrüger, weiß als Naiver und grauals Gewitzter): (K: „kooperieren“, B: „betrügen“)

Der weitere Ablauf ist einfach: Zuerst handeln alle Partner einmal mit ihren Nachbarn aus der Moore-Nachbarschaft. Dabei isteiniges an Orientierung im Gitter (als Array) vonnöten: es wechselt die „Blickrichtung“ (Stellung in der Nachbarschaft), und anden Rändern muss man auch überlegen. Danach bewerten alle Partner den Erfolg ihrer Nachbarn. Als Opportunistenübernehmen sie den Zustand des erfolgreichsten Nachbarn oder behalten ihren Zustand bei, wenn sie selbst besser waren. ImBeispiel wird eine Automatenklasse in einer eigenen Delphi-Unit vereinbart und darauf aufbauend eine „Welt“ (auch in einerUnit), die mit einem Gitter aus Automaten hantiert. Beides wird von der Programmoberfläche des zellulären Automatengesteuert. Die Abläufe zwischen diesen Klassen sind zwar nicht ganz trivial, dafür aber nur einmal zu lösen. Danach können dieAutomaten in ihrer Unit bzw. die „Welt“ in der anderen getrennt und ohne direkte Beeinflussung manipuliert werden. Man kann„schön einfach“ experimentieren.

Seite 22

Beispiel: Gekoppelte Automaten


K,K v B,K

K

Der „Naive“

K,B v B,B

B

Der „Betrüger“

B,K

K,K

KK,B

B,B

B

Der "Gewitzte" Der Automat

In den ersten Generationen setzen sich meist „die Bösen“ durch. Danach bilden sich Cluster aus „Guten“ bzw. „Gewitzten“, unddann beginnt eine wilde „Schlacht“. Zwar werden die „Guten“ hart von den „Betrügern“ bedrängt, sie halten sich aber in Grup-pen.

Die „Gewitzten“ setzen sich gegenüber den „Betrügern“ meist durch und kooperieren mit den „Guten“. Am Ende siegen meistdie „Gewitzten“ – aber eben nicht immer.

Entwicklung des Gitterautomaten

Das Beispiel ist als Vorbereitung auf die Automatentheorie eher schlicht. Es bietet aber eine extreme Bandbreite von sowohlprogrammiertechnischen wie inhaltlichen Variationen und legt sozialwissenschaftliche bzw. naturwissenschaftliche Interpreta-tionen nahe. In dieser Beziehung wird der Modellcharakter besonders deutlich.

Seite 23



Bleiben wir zuerst bei den Variationen: Das Verhalten der „Partner“ kann leicht durch veränderte Strategien ergänzt werden.„Wettbewerbe“ zwischen verschiedenen Strategien werden möglich, wobei Statistiken geführt werden müssen, da der Einzelfallnicht viel über das Gesamtverhalten aussagt. Schon hier ist systematisches Arbeiten gefragt. Die „Welt“ kann verändert werdendurch veränderte Nachbarschaften (von-Neumann-Nachbarschaft, andere Reichweiten, …), andere Abläufe, ... Statt des zweidi-mensionalen Gitters kann die zeitliche Entwicklung linearer Automaten in der üblichen Weise dargestellt werden, wobei chaoti-sche Vorgänge auftreten . Bei beidem können sowohl die Art der Automaten wie das Steuerprogramm völlig ignoriert werden.Die Gewichtungsfaktoren, die den Gewinn bei unterschiedlichen Vorgängen bestimmen, sind veränderbar. Auch hier sind dieanderen Größen irrelevant. Das Steuerprogramm kann verbessert werden, z. B. um während des Programmlaufs die unterschied-lichen Faktoren zu verändern. Dafür sind „Oberflächenprogrammierer“ gefragt. Die Eigenschaften der Gitterautomaten solltenauch per Mausklick gesetzt werden können (einige „Gewitzte“ in einer Welt aus „Bösen“, …), um das Verhalten bestimmterKonfigurationen gezielt untersuchen zu können.

Es kann aber auch versucht werden, die beobachteten Vorgänge systematisch zu bewerten. Dazu sind globale Größen geeignet(„Bruttosozialprodukt“ als Summe aller „Handelspunkte“). Der Einfluss der Parameter auf das Erreichen und die Art des ggf. er-reichten Endzustands kann abgeschätzt werden. Lineare Automaten lassen sich entsprechend klassifizieren . Es können Be-schränkungen eingeführt werden („Anzahl der handelbaren Güter“, „Geldmenge“, …), und die Verteilung der Größen auf dieGruppen sowie deren zeitliche Entwicklung ist darstellbar.

Die Beobachtung der manchmal überraschenden Abläufe liefert Ansatzpunkte zur Diskussion ethischer Fragen. Auch wenn dasBeispiel natürlich nicht direkt auf gesellschaftliche Systeme übertragbar ist, so haben wir doch ein für die meisten neuartiges Ar-gument für kooperatives, soziales Verhalten gefunden, das nicht aus transzendenten oder philosophischen Überlegungen gewon-nen wird, sondern aus Effizienzbetrachtungen. Es steht darin in klarem Gegensatz zur Egozentrik des Primitivdarwinismus, deroft die öffentliche Diskussion in dieser Hinsicht beherrscht.

Unsere zellulären Automaten sollten den Handel im Internet simulieren. Das erhaltene Modell ist aber auch ganz anders inter-pretierbar: Betrachten wir den „Handel“ als Energieaustausch benachbarter Teilchen, dann kommen wir recht schnell zum Ising-Modell für Spingitter . Die globalen Größen „Temperatur“ und „Magnetisierung“ liefern Bewertungsmaßstäbe zur Beurteilungdes Systems. Relativ kleine Änderungen führen auf Strukturbildungsprozesse und/oder Modelle für biologische und chemischeSysteme .

Die Interpretation desselben Modells in unterschiedlichem Kontext, die (teilweise) Unvorhersagbarkeit der Ergebnisse, das dy-namische Verhalten und sein Bezug zu nichtlinearen Systemen liefert Erfahrungen mit Modellen, Simulationen, deren Mächtig-keit und deren Grenzen – und das fast ohne Mathematik. Die Visualisierungsmöglichkeiten der Computer machen so einerseitsder Schule völlig neue Gebiete zugänglich und verdeutlichen andererseits den von der Mathematik unterschiedenen Charakterder Informatik als „Prognosesystem“. Nebenbei ist das Thema eine unerschöpfliche Quelle von „Facharbeiten“ der Schülerinnenund Schüler.

Haben wir als Lerngruppe z. B. den ersten Leistungskurs der Stufe 12, dann sollte der mit der elementaren Algorithmik, primiti-ven Datentypen und einfacher Computergrafik halbwegs vertraut sein. Beginnen wir also eine Unterrichtseinheit über „Visuali-sierung großer Datenmengen“, dann steht uns einerseits das weite Feld der Falschfarbendarstellungen von astronomischen, geo-grafischen oder medizinischen Daten mit ihren Interpretationsmöglichkeiten offen (z. B. aus dem Projekt „Hands-On Universe“,Satellitenbildern oder NMR-Daten der Tomografie), andererseits bilden Gitterautomaten ein interessantes Arbeitsgebiet, das hierbetrachtet wird. Repräsentieren wir die Teilautomaten durch Objekte, dann können die entsprechenden Klassen aus grafischenKomponenten der GUI abgeleitet werden. Wir haben damit neben einem elementaren Zugang zu endlichen Automaten auch ei-nen einfachen Einstieg in OOP-Methoden gefunden. In der angegebenen Form erfordert die Nutzung der Transitionsgraphenkaum Zeit: Bei einer Diskussion unterschiedlicher Strategien, z. B. der des „Langmütigen“, wird diese Notationsform nebenbeieingeführt und gefestigt. Erheblich mehr Zeit benötigt eine eingehende Analyse der Abläufe, die daraus folgende Verteilung derInformationen und ihre Repräsentation. Wird hier nicht sorgfältig gearbeitet, dann kann es später erhebliche Probleme geben.Sind die Alternativen und deren Konsequenzen betrachtet und die wesentlichen Entscheidungen getroffen, dann werden die Teil-probleme angegangen:

• Eine Automatenklasse mit den erforderlichen Methoden wird vereinbart, implementiert und an einzelnen Objekten getestet.• Ein Gitter solcher Automaten wird als Array definiert.• Die Aktionen im Gitter werden realisiert.

Seite 24



Ziel des Unterrichts ist es, bei der Implementierung eines relativ einfachen Modells elementare informatische Techniken ken-nen zu lernen, sowie sich mit Simulationen zu beschäftigen, deren Ergebnisse kaum prognostizierbar sind und die zu Diskus-sionen anregen. Unter diesen Voraussetzungen wird eine anfängliche eingehende Erörterung der Problematik im Unterrichts-gespräch unbedingt erforderlich sein. Aus dieser sollten sich dann die zu lösenden Teilprobleme ergeben, und aus diesen fol-gen die erforderlichen Programmiertechniken. Die Vereinbarung einer Tochterklasse z. B. von GUI-Panels, die mit Automa-teneigenschaften ausgestattet wird, sollte ebenfalls gemeinsam durchgeführt werden, wobei der Neuigkeitswert nicht bei denin Methoden auftretenden Algorithmen, sondern in den Zugriffstechniken liegt. So etwas lässt sich schnell abhandeln, dienotwendigen Erfahrungen werden bei der Anwendung gewonnen. Sind zweidimensionale Felder schon bekannt, dann könnendi L d d Z i l d A lb li i Di d b i ö li h F hl ll k d k i

die Lernenden das Zusammenspiel der Automaten selbst realisieren. Die dabei möglichen Fehler sollten erkannt und korri-giert werden. Als Hilfe wurde in der durchgeführten Unterrichtseinheit nur das zufällige Erzeugen einer Anfangsbelegung desFeldes vorgegeben. Danach wurde das Modell wie beschrieben variiert und erprobt.

Ziel des Unterrichts ist es, bei der Implementierung eines relativ einfachen Modells elementare informatische Techniken kennenzu lernen, sowie sich mit Simulationen zu beschäftigen, deren Ergebnisse kaum prognostizierbar sind und die zu Diskussionenanregen. Unter diesen Voraussetzungen wird eine anfängliche eingehende Erörterung der Problematik im Unterrichtsgesprächunbedingt erforderlich sein. Aus dieser sollten sich dann die zu lösenden Teilprobleme ergeben, und aus diesen folgen die erfor-derlichen Programmiertechniken. Die Vereinbarung einer Tochterklasse z. B. von GUI-Panels, die mit Automateneigenschaftenausgestattet wird, sollte ebenfalls gemeinsam durchgeführt werden, wobei der Neuigkeitswert nicht bei den in Methoden auftre-tenden Algorithmen, sondern in den Zugriffstechniken liegt. So etwas lässt sich schnell abhandeln, die notwendigen Erfahrun-gen werden bei der Anwendung gewonnen. Sind zweidimensionale Felder schon bekannt, dann können die Lernenden das Zu-sammenspiel der Automaten selbst realisieren. Die dabei möglichen Fehler sollten erkannt und korrigiert werden. Als Hilfe wur-de in der durchgeführten Unterrichtseinheit nur das zufällige Erzeugen einer Anfangsbelegung des Feldes vorgegeben. Danachwurde das Modell wie beschrieben variiert und erprobt.

Seite 25



Documents

Inhalt · Molekül oder ein Atom plaziert sein könnte, ein Automat sitzt, der alle seine Nachbarplätze regelmäßig in- spiziert und danach entscheidet, ob diese Stelle mit einem