[JS]
[DE]
[PLUGIN] ../../build/popup.plugin
[PLUGIN] ../../build/ca.plugin
[PLUGIN] ../../build/file.plugin
[PLUGIN] ../../build/image.plugin
[PLUGIN] ../../build/math.plugin
[TITLE] Zelluläre Automaten (Multiagentensysteme)
[AUTHOR] Stefan Bosse
[VERSION] 5.2020
[FUN]
```
function jsexec (text,stdout,stderr) {
  var oldprint=print;
  print=stdout;
  try {
    stdout(eval(text)||'Ok.');
  } catch (e) {
    stderr(e.toString())
  }
  print=oldprint;
}
```

Hinweise

- Dieses interaktive Notebook enthält statische Inhalte und Code Snippets die direkt im Notebook ausgeführt werden können 
- In Code Snippets: Linker Play Knopf startet die Ausführung des Codes. Der rechte Knopf ermöglicht das Löschen der Ausgabe!
- Bei Animationen gibt es es noch einen Stop Knopf der zur unmittelbaren Terminierung der Animation führt.
- Der Code kann verändert werden!
- Alle editierbaren Inhalte können gespeichert werden: Rechts oben (Save Notebook) Knopf
- Alle editierbaren Inhalte können wieder geladen werden und überschreiben Inhalte: Links oben (Load Notebook) Knopf
- Es können Notizen in Markdown Syntax gemacht werden, die auch gespeichert werden (Oben, Stift Knopf)
- Der Code ist in JavaScript - eine Einführung gibt es hier [tutorial6.html](http://edu-9.de/lehre/tutorial6.html)

# Zelluläre Automaten

## Einführung

- Ein zellulärer Automat besteht aus einer Menge von zustandsbasierten Zellen *ZA*={*z*~1~,*z*~2~,..,*z*~n~}.

- Eine Zelle besitzt eine Anzahl von Zellenvariablen die den veränderlichen (Daten) Zustand *S* bestimmen: *S*(*z*~i~)={*x*~1~,..,*x*~k~}

- Der nächste Zustand der Zellen wird über eine *activity* Funktion berechnet.

- Der Zustandsübergang einer Zelle erfolgt i.A. in der *before* oder *after* Funktion.

- Ein Scheduler führt die einzelnen Berechnungsfunktionen einer Zelle sequenziell in drei Phasen aus (obwohl ein ZA ein parelleles System ist!):
  1. *before*
  2. *activity*
  3. *after*

## Architektur und Grundprinzip

- Der Zelluläre Automat ist hier ein Simulationswerkzeug der ein künstliche zweidimensionale Welt aus Entitäten repräsentiert!
- Zur Visualisierung bekommt jede Zelle eine Farbe aus einer definierten Farbpalette

![#loops width=50%](images/ca01B.png)
*Zellulärer Automat als Netzwerk aus einfachen kommunizierenden Berechnungseinheiten*

## Nachbarschaft

- Nachbarschaftsrelationen sind auch bei Agenten wichtige Eigenschaft

![#loops width=50%](images/ca02.png)
*Verschiedene Nachbarschaftsrelationen*

- Im nachfolgenden Codebeispielen werden die Nachbarn einer Zelle (*x*,*y*) automatisch berechnet und als Array gegeben:

```
neighbors(x,y) = [
  { x:x-1,y:y-1, ... },
  { x:x  ,y:y-1, ... },
  { x:x+1,y:y-1, ... },
  { x:x-1,y:y,   ... },
  { x:x+1,y:y,   ... },
  { x:x-1,y:y+1, ... },
  { x:x  ,y:y+1, ... },
  { x:x+1,y:y+1, ... },
]

+-----> (x)
  |
  |
  v
  (y)

0 1 2 
  3 X 4
  5 6 7   (index in array)
```

## Zellen

- Jede Zelle des Zellulären Automaten (unserer künstlichen Welt!) repräserntiert eine Entität:
  + Baum
  + Mensch
  + Fahrzeug
  + Leerraum!
  + Mauer
  + Haus
  + Ameise
  + Wasser
  + Hohlraum (mit Wasser)
  + ..

## Mobilität

- Die Zellen besitzen einen unveränderlichen räumlichen Ort und auch ihre Nachbarschaft ist unveränderlich
- Mobile Zellen müssen durch Wanderung des Zustandes einer Zelle zu einer benachbarten Zelle realisiert werden

# Experimente

## Beispiel: Strukturbildung

- Hier werden binäre Zellen verwendet, d.h. sie können nur den Zustand 0 oder 1 annehmen

- Der Zellenzustand repräsentiert die Modelierung einer Höhlenstruktur (0: offen, 1: geschlossen)

- Durch die Nachbarschaftsrelation (*surrounding count*) ändert sich der Zustand 0 → 1 oder 1 → 0
  + Es findet eine Gruppenbildung statt (es bilden sich Hohlräume)

[CA] Beispiel Cave { id:ca1 }
```js
{
  rows: 100,
  columns : 100,
  neighbors : 8,
  palette : ['white','red'],
  parameter : {
    DENSITY: 0.4,
    OPEN1:   4,
    OPEN0:   6
  },
  cell : {
    name : 'wall',
    size : 4,
    // Die Zustandsvariablen einer Zelle
    state : { open:0, wasOpen:0 },
    // Phase 1: Zustandsübergang ohne Berechnung!
    before : function () {
      this.wasOpen = this.open;
    },
    // Phase 2: Brechnen des nächsten Zustandes
    activity : function (neighbors,x,y) {
      var surrounding = this.ask(neighbors, 'count', 'wasOpen');
      this.open = (this.wasOpen && surrounding >= this.OPEN1) || 
                  surrounding >= this.OPEN0;
    },
    // Phase 0: Einmalige Initialisierung der Zelle
    init : function (x,y) {
      this.open = this.data[y][x] > this.DENSITY;
    },
    // Farbe aus Palette (Index) in Abhaengigkeit vom Zustand
    color : function () { return this.open ?  0:1 },
  },
  // Initialisierung mit Pseudozufallszahlen [0,1)
  data : Math.Matrix.Random(100,100).data,
  steps: 100,
  start :  [{ name: 'wall', distribution: 100 }],
}
```

[EXERCISE] A
[QUESTION] A1
Wie hängt die Hohlraumentstehung (Höhlenbildung) von dem Parameter *DENSITY*={0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9] ab?

[INPUT]

[QUESTION] A2
Wie hängt die Hohlraumentstehung (Höhlenbildung) von den Parametern *OPEN0* und *OPEN1* bei *DENSITY*=0.5 ab?

[INPUT]

[EXERCISE]

## Beispiel: Ausbreitungsdynamik

- Hier kommt ein Beispiel eines mehrwertigen Zellensystems (ins. 12 Zustände)

- Eine Zelle repräsentiert:
  1. Freie Fläche (weiß);
  2. Belegung durch einen wachsenden Baum;
  3. Feuer (des Baumes)

- Erste räumliche Dynamik durhc Feuerausbreitung

[CA] Beispiel Forest Fire { id:ca2 }
```js
{
  rows: 100,
  columns : 100,
  neighbors : 8,
  palette : [
		'208, 70, 72, 0',
		'208, 70, 72, ' + 1/9,
		'208, 70, 72, ' + 2/9,
		'208, 70, 72, ' + 3/9,
		'208, 70, 72, ' + 4/9,
		'208, 70, 72, ' + 5/9,
		'208, 70, 72, ' + 6/9,
		'208, 70, 72, ' + 7/9,
		'208, 70, 72, ' + 8/9,
		'208, 70, 72, 1',
		'52, 101, 36, 1',
		'255, 255, 255, 1'
	],
  parameter : {
      CHANCE_TO_IGNITE : 0.0001,
      CHANCE_TO_GROW : 0.01,
  },
  cell : {
    name : 'tree',
    size : 4,
    // Modellparameter
    // Die Zustandsvariablen einer Zelle
    state : { alive:false, burning:0, wasBurning:0 },
    // Phase 1: Zustandsübergang ohne Berechnung!
    before : function () {
      this.wasBurning = this.burning !== 0;
    },
    // Phase 2: Brechnen des nächsten Zustandes
    activity : function (neighbors,x,y) {
      if (this.wasBurning) {
        this.burning-=3;
      }
      else if (this.alive) {
        var surrounding = this.ask(neighbors, 'count', 'wasBurning');
        if (surrounding) {
          this.burning = 9;
          this.alive = false;
        }
        else if (Math.random() < this.CHANCE_TO_IGNITE ) {
          this.burning = 9;
          this.alive = false;
        }
      }
      else if (Math.random() < this.CHANCE_TO_GROW ) {
        this.alive = true;
      }
    },
    // Phase 0: Einmalige Initialisierung der Zelle
    init : function (x,y) {},
    // Farbe aus Palette (Index) in Abhaengigkeit vom Zustand
    color : function () { 
      return this.burning ? this.burning : 
                            (this.alive ? 10 : 11) 
    },
  },
  steps : 100,
  start :  [{ name: 'tree', distribution: 100 }],
}
```

[EXERCISE] B
[QUESTION] B1
Wie hängt die Wahrscheinlichkeit der Feuerentstehung von den Parametern *CHANCE_TO_GROW* und *CHANCE_TO_IGNITE* ab?

[INPUT]

[QUESTION] B2
Verändere das Modell so dass ein Feuer erst bei älteren Bäumen auftreten kann. D.h. fügre einen Lebenszeitzähler *age* zum Zustand hinzu. Dieser wird in der *activity* Funktion jeweils um eins erhöht. Erst wenn *age* > *CANBURN* kann ein Feuer entstehen. Wie ändert sich das dynamische Verhalten?

[INPUT]

[EXERCISE]

### Beispiel: Mobilität

- Hier wird die räumliche Mobilität von Entitäten durch eine Zustandswanderung durch das Netz gezeigt

- Der Zustand einer Zelle inklusive einer indivduellen Identität (Nummer!)  kann zu einer Nachbarzelle migrieren wenn diese frei ist

[CA] Beispiel Wanderung { id:ca3 }
```js
{
  rows: 100,
  columns : 100,
  neighbors : 8,
  palette : ['white','red','blue'],
  parameter : {
      CHANCE_TO_ḾOVE : 0.1,
      DENSITY_RED : 0.05,
      DENSITY_BLUE : 0.02,
  },
  cell : {
    name : 'place',
    size : 4,
    // Modellparameter
    // Die Zustandsvariablen einer Zelle
    state : { occupation:0, occupation0:0, id:0 },
    // Phase 1: Zustandsübergang ohne Berechnung!
    before : function () {
      this.occupation0 = this.occupation;
    },
    // Phase 2: Brechnen des nächsten Zustandes
    activity : function (neighbors,x,y) {
      var free = neighbors.filter(function (cell) {
        return cell && cell.occupation0==0;
      })
      if (this.occupation0 && 
          Math.random()<this.CHANCE_TO_ḾOVE*this.occupation0) {
        var next = Math.random.select(free);
        next.id=this.id;
        next.occupation=this.occupation;
        this.id=null;
        this.occupation=0;
      }
    },
    // Phase 0: Einmalige Initialisierung der Zelle
    init : function (x,y) {
      if (Math.random()<this.DENSITY_RED) this.occupation=1; 
        // red population
      else if (Math.random()<this.DENSITY_BLUE) this.occupation=2; 
        // blue population
      else this.occupation=0;
      if (this.occupation) this.id=this.data.counter++;
    },
    // Farbe aus Palette (Index) in Abhaengigkeit vom Zustand
    color : function () { 
      return this.occupation0; 
    },
  },
  data : { counter:0 },
  steps : 1000,
  start :  [{ name: 'place', distribution: 100 }],
}
```

# Experimente

## Krankheitsausbreitung

[CA] Krankheitsausbreitung { id:ca4 }
```js
{
  // TODO
}
```

1. Erstelle ein ZA Simulationsmodell mit dem die einfache Ausbreitung von Krankheiten simuliert werden kann.
2. Dazu kann jede Zelle durch einen gesunden oder kranken Menschen besetzt sein. 
3. Zunächst bewegen sich die "Menschen" nicht
4. Wenn sich ein Kranker nahe einem Gesunden (Nachbarschaft) befinde steckt er diesen mit der Wahrscheinlichkeit *INFLU* an.
5. Es gibt eine Inkubationszeit von einigen Simulationsschritten. Erst danach wird der Mensch krank und kann andere anstecken 
6. Es gibt also weitere Zustandsvariablen *health* und *virus*. Die Variable *virus* wenn sie > 0 ist verdoppelt sich dann in jedem Simulationsschritt. Wenn *virus* > *VICUSICK* ist, ändert sich der Gesundheitszustand 1 → 0
7. Führe zusätzlich Mobilität der Menschen ein (*CHANCE_TO_ḾOVE*)! Wenn sie krank sind mit geringer Geschwindigkeit (*CHANCE_TO_ḾOVE_SICK* < *CHANCE_TO_ḾOVE*).

[EXERCISE] C
[QUESTION] C1
Wie hängt die Ausbreitung von dem Paremeter *INFLU* ab?

[INPUT]

[QUESTION] C2
Wie hängt die Ausbreitung von den Paremetern *CHANCE_TO_ḾOVE* und *CHANCE_TO_ḾOVE_SICK* ab?

[INPUT]

[EXERCISE]

Hinweise

Dieses interaktive Notebook enthält statische Inhalte und Code Snippets die direkt im Notebook ausgeführt werden können
In Code Snippets: Linker Play Knopf startet die Ausführung des Codes. Der rechte Knopf ermöglicht das Löschen der Ausgabe!
Bei Animationen gibt es es noch einen Stop Knopf der zur unmittelbaren Terminierung der Animation führt.
Der Code kann verändert werden!
Alle editierbaren Inhalte können gespeichert werden: Rechts oben (Save Notebook) Knopf
Alle editierbaren Inhalte können wieder geladen werden und überschreiben Inhalte: Links oben (Load Notebook) Knopf
Es können Notizen in Markdown Syntax gemacht werden, die auch gespeichert werden (Oben, Stift Knopf)
Der Code ist in JavaScript - eine Einführung gibt es hier tutorial6.html

Zelluläre Automaten

Einführung

Ein zellulärer Automat besteht aus einer Menge von zustandsbasierten Zellen ZA={z₁,z₂,..,z_n}.
Eine Zelle besitzt eine Anzahl von Zellenvariablen die den veränderlichen (Daten) Zustand S bestimmen: S(z_i)={x₁,..,x_k}
Der nächste Zustand der Zellen wird über eine activity Funktion berechnet.
Der Zustandsübergang einer Zelle erfolgt i.A. in der before oder after Funktion.
Ein Scheduler führt die einzelnen Berechnungsfunktionen einer Zelle sequenziell in drei Phasen aus (obwohl ein ZA ein parelleles System ist!):
1. before
2. activity
3. after

Architektur und Grundprinzip

Der Zelluläre Automat ist hier ein Simulationswerkzeug der ein künstliche zweidimensionale Welt aus Entitäten repräsentiert!
Zur Visualisierung bekommt jede Zelle eine Farbe aus einer definierten Farbpalette

#loops
Zellulärer Automat als Netzwerk aus einfachen kommunizierenden Berechnungseinheiten

Nachbarschaft

Nachbarschaftsrelationen sind auch bei Agenten wichtige Eigenschaft

#loops
Verschiedene Nachbarschaftsrelationen

Im nachfolgenden Codebeispielen werden die Nachbarn einer Zelle (x,y) automatisch berechnet und als Array gegeben:

neighbors(x,y) = [
  { x:x-1,y:y-1, ... },
  { x:x  ,y:y-1, ... },
  { x:x+1,y:y-1, ... },
  { x:x-1,y:y,   ... },
  { x:x+1,y:y,   ... },
  { x:x-1,y:y+1, ... },
  { x:x  ,y:y+1, ... },
  { x:x+1,y:y+1, ... },
]

  +-----> (x)
  |
  |
  v
  (y)

  0 1 2 
  3 X 4
  5 6 7   (index in array)

Zellen

Jede Zelle des Zellulären Automaten (unserer künstlichen Welt!) repräserntiert eine Entität:
- Baum
- Mensch
- Fahrzeug
- Leerraum!
- Mauer
- Haus
- Ameise
- Wasser
- Hohlraum (mit Wasser)
- ..

Mobilität

Die Zellen besitzen einen unveränderlichen räumlichen Ort und auch ihre Nachbarschaft ist unveränderlich
Mobile Zellen müssen durch Wanderung des Zustandes einer Zelle zu einer benachbarten Zelle realisiert werden

Experimente

Beispiel: Strukturbildung

Hier werden binäre Zellen verwendet, d.h. sie können nur den Zustand 0 oder 1 annehmen
Der Zellenzustand repräsentiert die Modelierung einer Höhlenstruktur (0: offen, 1: geschlossen)
Durch die Nachbarschaftsrelation (surrounding count) ändert sich der Zustand 0 → 1 oder 1 → 0
- Es findet eine Gruppenbildung statt (es bilden sich Hohlräume)

Beispiel Cave [ca1]

{
  rows: 100,
  columns : 100,
  neighbors : 8,
  palette : ['white','red'],
  parameter : {
    DENSITY: 0.4,
    OPEN1:   4,
    OPEN0:   6
  },
  cell : {
    name : 'wall',
    size : 4,
    // Die Zustandsvariablen einer Zelle
    state : { open:0, wasOpen:0 },
    // Phase 1: Zustandsübergang ohne Berechnung!
    before : function () {
      this.wasOpen = this.open;
    },
    // Phase 2: Brechnen des nächsten Zustandes
    activity : function (neighbors,x,y) {
      var surrounding = this.ask(neighbors, 'count', 'wasOpen');
      this.open = (this.wasOpen && surrounding >= this.OPEN1) || 
                  surrounding >= this.OPEN0;
    },
    // Phase 0: Einmalige Initialisierung der Zelle
    init : function (x,y) {
      this.open = this.data[y][x] > this.DENSITY;
    },
    // Farbe aus Palette (Index) in Abhaengigkeit vom Zustand
    color : function () { return this.open ?  0:1 },
  },
  // Initialisierung mit Pseudozufallszahlen [0,1)
  data : Math.Matrix.Random(100,100).data,
  steps: 100,
  start :  [{ name: 'wall', distribution: 100 }],
}

▸

◼

✗

Aufgabe. A

Frage. A1 Wie hängt die Hohlraumentstehung (Höhlenbildung) von dem Parameter DENSITY={0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9] ab?

Frage. A2 Wie hängt die Hohlraumentstehung (Höhlenbildung) von den Parametern OPEN0 und OPEN1 bei DENSITY=0.5 ab?

Beispiel: Ausbreitungsdynamik

Hier kommt ein Beispiel eines mehrwertigen Zellensystems (ins. 12 Zustände)
Eine Zelle repräsentiert:
1. Freie Fläche (weiß);
2. Belegung durch einen wachsenden Baum;
3. Feuer (des Baumes)
Erste räumliche Dynamik durhc Feuerausbreitung

Beispiel Forest Fire [ca2]

{
  rows: 100,
  columns : 100,
  neighbors : 8,
  palette : [
		'208, 70, 72, 0',
		'208, 70, 72, ' + 1/9,
		'208, 70, 72, ' + 2/9,
		'208, 70, 72, ' + 3/9,
		'208, 70, 72, ' + 4/9,
		'208, 70, 72, ' + 5/9,
		'208, 70, 72, ' + 6/9,
		'208, 70, 72, ' + 7/9,
		'208, 70, 72, ' + 8/9,
		'208, 70, 72, 1',
		'52, 101, 36, 1',
		'255, 255, 255, 1'
	],
  parameter : {
      CHANCE_TO_IGNITE : 0.0001,
      CHANCE_TO_GROW : 0.01,
  },
  cell : {
    name : 'tree',
    size : 4,
    // Modellparameter
    // Die Zustandsvariablen einer Zelle
    state : { alive:false, burning:0, wasBurning:0 },
    // Phase 1: Zustandsübergang ohne Berechnung!
    before : function () {
      this.wasBurning = this.burning !== 0;
    },
    // Phase 2: Brechnen des nächsten Zustandes
    activity : function (neighbors,x,y) {
      if (this.wasBurning) {
        this.burning-=3;
      }
      else if (this.alive) {
        var surrounding = this.ask(neighbors, 'count', 'wasBurning');
        if (surrounding) {
          this.burning = 9;
          this.alive = false;
        }
        else if (Math.random() < this.CHANCE_TO_IGNITE ) {
          this.burning = 9;
          this.alive = false;
        }
      }
      else if (Math.random() < this.CHANCE_TO_GROW ) {
        this.alive = true;
      }
    },
    // Phase 0: Einmalige Initialisierung der Zelle
    init : function (x,y) {},
    // Farbe aus Palette (Index) in Abhaengigkeit vom Zustand
    color : function () { 
      return this.burning ? this.burning : 
                            (this.alive ? 10 : 11) 
    },
  },
  steps : 100,
  start :  [{ name: 'tree', distribution: 100 }],
}

▸

◼

✗

Aufgabe. B

Frage. B1 Wie hängt die Wahrscheinlichkeit der Feuerentstehung von den Parametern CHANCE_TO_GROW und CHANCE_TO_IGNITE ab?

Frage. B2 Verändere das Modell so dass ein Feuer erst bei älteren Bäumen auftreten kann. D.h. fügre einen Lebenszeitzähler age zum Zustand hinzu. Dieser wird in der activity Funktion jeweils um eins erhöht. Erst wenn age > CANBURN kann ein Feuer entstehen. Wie ändert sich das dynamische Verhalten?

Beispiel: Mobilität

Hier wird die räumliche Mobilität von Entitäten durch eine Zustandswanderung durch das Netz gezeigt
Der Zustand einer Zelle inklusive einer indivduellen Identität (Nummer!) kann zu einer Nachbarzelle migrieren wenn diese frei ist

Beispiel Wanderung [ca3]

{
  rows: 100,
  columns : 100,
  neighbors : 8,
  palette : ['white','red','blue'],
  parameter : {
      CHANCE_TO_ḾOVE : 0.1,
      DENSITY_RED : 0.05,
      DENSITY_BLUE : 0.02,
  },
  cell : {
    name : 'place',
    size : 4,
    // Modellparameter
    // Die Zustandsvariablen einer Zelle
    state : { occupation:0, occupation0:0, id:0 },
    // Phase 1: Zustandsübergang ohne Berechnung!
    before : function () {
      this.occupation0 = this.occupation;
    },
    // Phase 2: Brechnen des nächsten Zustandes
    activity : function (neighbors,x,y) {
      var free = neighbors.filter(function (cell) {
        return cell && cell.occupation0==0;
      })
      if (this.occupation0 && 
          Math.random()<this.CHANCE_TO_ḾOVE*this.occupation0) {
        var next = Math.random.select(free);
        next.id=this.id;
        next.occupation=this.occupation;
        this.id=null;
        this.occupation=0;
      }
    },
    // Phase 0: Einmalige Initialisierung der Zelle
    init : function (x,y) {
      if (Math.random()<this.DENSITY_RED) this.occupation=1; 
        // red population
      else if (Math.random()<this.DENSITY_BLUE) this.occupation=2; 
        // blue population
      else this.occupation=0;
      if (this.occupation) this.id=this.data.counter++;
    },
    // Farbe aus Palette (Index) in Abhaengigkeit vom Zustand
    color : function () { 
      return this.occupation0; 
    },
  },
  data : { counter:0 },
  steps : 1000,
  start :  [{ name: 'place', distribution: 100 }],
}

▸

◼

✗

Experimente

Krankheitsausbreitung

Krankheitsausbreitung [ca4]

{
  // TODO
}

▸

◼

✗

Erstelle ein ZA Simulationsmodell mit dem die einfache Ausbreitung von Krankheiten simuliert werden kann.
Dazu kann jede Zelle durch einen gesunden oder kranken Menschen besetzt sein.
Zunächst bewegen sich die "Menschen" nicht
Wenn sich ein Kranker nahe einem Gesunden (Nachbarschaft) befinde steckt er diesen mit der Wahrscheinlichkeit INFLU an.
Es gibt eine Inkubationszeit von einigen Simulationsschritten. Erst danach wird der Mensch krank und kann andere anstecken
Es gibt also weitere Zustandsvariablen health und virus. Die Variable virus wenn sie > 0 ist verdoppelt sich dann in jedem Simulationsschritt. Wenn virus > VICUSICK ist, ändert sich der Gesundheitszustand 1 → 0
Führe zusätzlich Mobilität der Menschen ein (CHANCE_TO_ḾOVE)! Wenn sie krank sind mit geringer Geschwindigkeit (CHANCE_TO_ḾOVE_SICK < CHANCE_TO_ḾOVE).

Aufgabe. C

Frage. C1 Wie hängt die Ausbreitung von dem Paremeter INFLU ab?

Frage. C2 Wie hängt die Ausbreitung von den Paremetern CHANCE_TO_ḾOVE und CHANCE_TO_ḾOVE_SICK ab?

Created by the NoteBook Compiler Ver. 1.2.5 (c) Dr. Stefan Bosse