taralino

Simulationsanalyse

Wie du beim Experimentieren mit der Simulation im Abschnitt zuvor vielleicht bereits bemerkt hast, ergeben sich mit der Zeit durchaus interessante Strukturen:

Von Schritt zu Schritt bleiben statische Strukturen unverändert.
Strukturen, die sich zwar verändert, aber alle zwei (oder mehr) Schritte wieder in ihrer Startkonfiguration vorliegen, werden oszillierende Strukturen genannt.
Zudem entstehen dynamische Strukturen, auch Gleiter genannt. Auch dies sind Strukturen, die sich nach einer bestimmten Anzahl von Schritten wiederholen, allerdings nicht an der gleichen Stelle wie zuvor.

Um derartige Strukturen genauer zu analysieren, betrachte den folgenden Quellcode und bearbeite die anschließende Aufgabe.

Quellcode

In diesem Beispiel wird die Startkonfiguration explizit im Quellcode definiert.

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <script src="taralino.js"></script>
</head>
<body>
<script>

/*******************************
  Startkonfiguration
*******************************/

var M = [
  [0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 1, 1, 0, 0, 0, 0],
  [0, 0, 1, 1, 0, 0, 0, 0],
  [0, 0, 0, 0, 1, 1, 0, 0],
  [0, 0, 0, 0, 1, 1, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0],
  [0, 0, 0, 0, 0, 0, 0, 0]
];


/*******************************
  Globale Variablen
*******************************/

// Spielfeld (Anzahl der Zeilen und Spalten):
var s = Math.min(M.length, M[0].length);

// Anzahl der Individuen in der Nachbarschaft (zweidimensionales Datenfeld):
var N = [];
for (var i = 0; i < s; i++) N.push([]);
for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) N[i].push(0);


/*******************************
  calculate_N()
*******************************/

// Der Befehl calculate_N() bestimmt fuer alle Zellen
// die Anzahl der Individuen in der jeweiligen Nachbarschaft.

function calculate_N() {
  for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) {
    N[i][j] = -M[i][j];
    for (var r = -1; r <= 1; r++) for (var q = -1; q <= 1; q++) {
      N[i][j] = N[i][j] + M[(i+r+s)%s][(j+q+s)%s];
    };
  };
};


/*******************************
  calculate_M()
*******************************/

// Der Befehl calculate_M() bestimmt das neue Spielfeld unter
// Verwendung der aktuellen Belegung sowie der jeweiligen Nachbarschaft.

function f(m, n) {
  var h = 0;
  if ((m == 1) && (n == 2)) h = 1;
  if ((m == 1) && (n == 3)) h = 1;
  if ((m == 0) && (n == 3)) h = 1;
  return h;
};

function calculate_M() {
  for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) {
    M[i][j] = f(M[i][j], N[i][j]);
  };
};


/*******************************
  grid()
*******************************/

// Der Befehl zeichnet das Spielfeld.

function grid() {
  Grid.clear();
  for (var i = 0; i < s; i++) for (var j = 0; j < s; j++) {
    if (M[i][j] == 1) Grid.pixel(j, s-i-1, "blue");
  };
  Grid.draw();
};


/*******************************
  setup()
*******************************/

// Der Befehl setup() wird jeweils beim Start einmalig ausgefuehrt.

function setup() {
  // Gitternetz zur Darstellung des Spielfeldes initialisieren
  var z = Math.max(1, Math.floor(320/s));
  Grid.init(s, s, {background:"lightgrey", style:"canvas", zoom:z});

  // Darstellung des Spielfeldes
  grid();

  // Simulationsgeschwindigket durch Anzahl der Schritte pro Sekunde (fps)
  Animation.init({fps:4});
};


/*******************************
  loop()
*******************************/

// Der Befehl loop() wird wird automatisch immer wieder aufgerufen.

function loop() {
  calculate_N();
  calculate_M();
  grid();
};



</script>
</body>
</html>

Vorschau Download Kopie speichern

Codingaufgabe

Nutze den Quellcode zuvor, um auch die folgenden Startkonfiguration zu analysieren.

Wobei handelt es sich um statische bzw. oszillierende Strukturen? Sind auch Gleiter unter den Beispielen?