Organisation

This commit is contained in:
DotNaos committed 2025-04-17 13:18:15 +02:00
1 parent 7dd5d22f5d
commit 600ee485eb
15 files changed
+1175

No files matched your search

@@ -0,0 +1,9 @@
{
"nodes":[
{"id":"84d9d96eb52919d0","type":"text","text":"# Supercomputer\nDurchsatz: \nRendering\n\nAntwortzeit:\n\nProblemgröße:\nLLM\n\n## Parallelisierung\n\nSpeed-Up\n\n\n$$\nS(p) = \\frac{T(1)}{T(p)} mit \\ 1 \\le S(p) < p\n$$\n\n","x":-125,"y":-30,"width":485,"height":450},
{"id":"c6b9d92b788b5a27","x":-1,"y":829,"width":250,"height":60,"type":"text","text":"Netwerke"}
],
"edges":[
{"id":"64e90736383ab549","fromNode":"84d9d96eb52919d0","fromSide":"bottom","toNode":"c6b9d92b788b5a27","toSide":"top"}
]
}
@@ -0,0 +1,40 @@
## Speicherung von Geometrie
- Vertecies
- Edges
- Faces
> VEF Graph
## Eulersche Formel
$$
n_V - n_E + n_F = 2
$$
Gleiches für Dreiecke
### Speicherung als Matrix
- Einscannen der Vertecies durch z.B. LiDar
Vertex:
- Koordinaten
Kanten:
- V1 und v2\
Fläche:
- e1, e2, e3
## Darstellungsformen des Volumenmodells
Primitive:
- Würfel, Tetraeder ...
## Spacetrees
- Rekursives runterbrechen von Voxels
- Die die Auf dem Rand liegen werden fortgeführt
### Reihenfolge
links unten nach rechts unten, dann nach oben links dann oben rechts
@@ -0,0 +1,6 @@
# Organisatorisches
## Projekte
- Verkehrssimulation
## Leistungsnachweis
- 100% Prüfung
@@ -0,0 +1,6 @@
## Codierung von Spacetrees
1 für Elternknoten
0 für Blätter
0 für Außen
1 für auf Geometrie
@@ -0,0 +1,88 @@
# Simulationspipeline
## 1. Modellierung
- Model erstellen, das auf eine niedrige Abstrakte Ebene heruntergebrochen wurde.
- Verienfachung / Formale Abstraktion der Realität -> Dimension wegnehmen
### Model Erstellen
Eine Annahme z.B. eine Formel
3D - Modell
### Mathematische Modellierung
Eine Szenario auf einer Karte -> Graphen
#### Graphen
Problem: Jeder Pfad auf einem Graphen einmal verwenden. Funktioniert nur bei gerader Anzahl der Pfade an einem Knoten. Bei ungerade Anzahl -> Keine Weg zurück
#### Herleitung
- Welche Größen sind wichtig
- Wie beeinflussen sie sich?
- Was ist die Aufgabe ?
#### Analyse
- Existens und Eindeutigkeit: Gibt es eine Lösung? Welche Lösung ist richtig?
- Wie beinflussen Ausgangswerte das Ergebnis?
- Wie genau ist das Modell? Mehrere Modelle sind möglich.
## 2. Numerische Behandlung
### Diskretisierung
Aus Unendlich wird endlich also z.B. 10 Werte.
h : (Gitterabstand) Abstand zwischen den Punkten.
![[diskretion.png]]
### Algorithmen Entwicklung
- Genauer Ablauf entwickeln
### Klassifikation von Modellen
- Diskrete und kontinuierliche Modelle
#### diskrete Modelle
- Basieren auf diskrete oder kombinatorischen Beschreibungen
- z.B. Graphen, (endliche) Automaten
#### kontinuierliche Modelle
- basieren auf stetigen Beschreibung
- in der Regel Gleichungen
#### Deterministische und Stochastische Modelle
- Beispiel 1: Würfel
- Stochastisches Modell
- Beispiel 2: Crashtest
- deterministisches Phänomen
#### Skalen und Hierarchien
- Wahl der Skala in Abhängigkeit von
- Ergebnis
- kosten der Berechnung und Zeit
- Auflösung der Abstraction: Mensch oder Atom
#### Inverse Probleme
- Forward Problem
- Wetter
- Inverse Problem
- Lösung kennt man: Wie kommt man da hin?
## 3. Implementierung
- Softwareentwicklung, Parallelisierung
## 4. Visualisierung
- An Zielgruppe anpassen
- Ergenisse Zeigen
## 5. Validierung
- Fehlerbetrachtung
- Was kann es?
## 6. Einbettung
- Verkauf und Vertrieb
@@ -0,0 +1,23 @@
## Numerische Behandlung: Diskretisierung
> Auflösung des Problems
Lösung nur an diskreten Stellen
- Differenzenquotient
### Zeitaufwand
$$
Rechenoperationen / Taktfrequenz = Zeit in sek
$$
# Implementierung
- Sprache egal
- Bibliotheken verwenden wo geht
- Parallelisierung
# Visualisierung
-
# Geometrische Modellierung
- Keine Offene Fläche (nicht verbundene Vertecies)
- Keine Durchdringende Geometrie
-
@@ -0,0 +1,4 @@
{
"nodes":[],
"edges":[]
}
@@ -0,0 +1,226 @@
import sys
import numpy as np
import cupy as cp
import pygame
# Minimaler, GPU-beschleunigter 2D-Fluid-Solver mit persistenter Flüssigkeit und Gravitation.
# Installation:
# pip install cupy-cudaXX pygame numpy
# XX = passende CUDA-Version, z.B. cupy-cuda112 für CUDA 11.2
# ==============================
# EINSTELLUNGEN
# ==============================
N = 64 # Gittergröße (N x N)
ITER = 2 # Iterationen; verringern für Geschwindigkeit
DT = 0.1 # Zeitschritt
DIFF = 0.0001 # Diffusionskoeffizient (klein, aber nicht null für Stabilität)
VISC = 0.0001 # Viskosität (klein, aber nicht null für Stabilität)
ZOOM = 8 # Pixel pro Gitterzelle in der Anzeige
GRAVITY = 0.1 # Gravitationskraft (anpassbar)
WIDTH, HEIGHT = N * ZOOM, N * ZOOM
# ==============================
# HILFSFUNKTIONEN
# ==============================
def set_bnd(b, x):
"""
Randbehandlung für die Simulation.
b = 0: Dichte
b = 1: u-Geschwindigkeit
b = 2: v-Geschwindigkeit
"""
if b == 1:
# u-Geschwindigkeit: links und rechts auf 0 setzen (Wände)
x[0, 1:-1] = 0
x[-1, 1:-1] = 0
elif b == 2:
# v-Geschwindigkeit: oben und unten auf 0 setzen (Wände)
x[1:-1, 0] = 0
x[1:-1, -1] = 0
else:
# Dichte: Spiegeln an den Rändern
x[1:-1, 0] = x[1:-1, 1]
x[1:-1, -1] = x[1:-1, -2]
x[0, 1:-1] = x[1, 1:-1]
x[-1, 1:-1] = x[-2, 1:-1]
# Ecken setzen
x[0, 0] = 0.5 * (x[1, 0] + x[0, 1])
x[0, -1] = 0.5 * (x[1, -1] + x[0, -2])
x[-1, 0] = 0.5 * (x[-2, 0] + x[-1, 1])
x[-1, -1] = 0.5 * (x[-2, -1] + x[-1, -2])
def add_source(x, s):
"""
Fügt eine Quelle zur Simulation hinzu.
"""
x += DT * s
def diffuse(b, x, x0, diff):
"""
Diffusionsschritt der Simulation.
"""
a = DT * diff * (N - 2) * (N - 2)
for _ in range(ITER):
x[1:-1, 1:-1] = (x0[1:-1, 1:-1] + a * (
x[0:-2, 1:-1] + x[2:, 1:-1] +
x[1:-1, 0:-2] + x[1:-1, 2:]
)) / (1 + 4*a)
set_bnd(b, x)
def advect(b, d, d0, u, v):
"""
Advektionsschritt der Simulation.
"""
dt0 = DT * (N - 2)
# Rückverfolgte Position berechnen
X, Y = cp.meshgrid(cp.arange(N), cp.arange(N), indexing='ij')
X = X[1:-1, 1:-1] - dt0 * u[1:-1, 1:-1]
Y = Y[1:-1, 1:-1] - dt0 * v[1:-1, 1:-1]
X = cp.clip(X, 0.5, N - 1.5)
Y = cp.clip(Y, 0.5, N - 1.5)
i0 = X.astype(int)
i1 = i0 + 1
j0 = Y.astype(int)
j1 = j0 + 1
s1 = X - i0
s0 = 1 - s1
t1 = Y - j0
t0 = 1 - t1
d_new = (s0 * (t0 * d0[i0, j0] + t1 * d0[i0, j1]) +
s1 * (t0 * d0[i1, j0] + t1 * d0[i1, j1]))
d[1:-1, 1:-1] = d_new
set_bnd(b, d)
def project(u, v, p, div):
"""
Projektionsschritt zur Inkompressibilität der Flüssigkeit.
"""
# Divergenz berechnen
div[1:-1,1:-1] = -0.5 * (
(u[2:,1:-1] - u[0:-2,1:-1]) +
(v[1:-1,2:] - v[1:-1,0:-2])
) / N
p.fill(0)
set_bnd(0, div)
set_bnd(0, p)
# Poisson-Gleichung lösen
for _ in range(ITER):
p[1:-1,1:-1] = (div[1:-1,1:-1] + p[0:-2,1:-1] + p[2:,1:-1] +
p[1:-1,0:-2] + p[1:-1,2:]) / 4
set_bnd(0, p)
# Geschwindigkeiten aktualisieren
u[1:-1,1:-1] -= 0.5 * (p[2:,1:-1] - p[0:-2,1:-1]) * N
v[1:-1,1:-1] -= 0.5 * (p[1:-1,2:] - p[1:-1,0:-2]) * N
set_bnd(1, u)
set_bnd(2, v)
# ==============================
# FLUID-KLASSE
# ==============================
class Fluid:
def __init__(self):
self.dens = cp.zeros((N, N), dtype=cp.float32)
self.dens_prev = cp.zeros((N, N), dtype=cp.float32)
self.u = cp.zeros((N, N), dtype=cp.float32)
self.u_prev = cp.zeros((N, N), dtype=cp.float32)
self.v = cp.zeros((N, N), dtype=cp.float32)
self.v_prev = cp.zeros((N, N), dtype=cp.float32)
def step(self, gravity):
"""
Führt einen Simulationsschritt durch, einschließlich der Anwendung von Gravitation.
"""
# Gravitation hinzufügen (nur zur v-Komponente)
self.v_prev += gravity * DT
# Dichte
add_source(self.dens, self.dens_prev)
diffuse(0, self.dens, self.dens_prev, DIFF)
advect(0, self.dens, self.dens_prev, self.u, self.v)
# Geschwindigkeit
add_source(self.u, self.u_prev)
add_source(self.v, self.v_prev)
diffuse(1, self.u, self.u_prev, VISC)
diffuse(2, self.v, self.v_prev, VISC)
project(self.u, self.v, self.u_prev, self.v_prev)
advect(1, self.u, self.u_prev, self.u, self.v)
advect(2, self.v, self.v_prev, self.u, self.v)
project(self.u, self.v, self.u_prev, self.v_prev)
# Quellen zurücksetzen
self.dens_prev.fill(0)
self.u_prev.fill(0)
self.v_prev.fill(0)
# ==============================
# HAUPTPROGRAMM
# ==============================
def main():
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("GPU Fluid Simulation mit Gravitation")
clock = pygame.time.Clock()
fluid = Fluid()
# Zentrum für kontinuierliche Dichtequelle
center = (N//2, N//2)
running = True
while running:
clock.tick(60) # 60 FPS anvisiert
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Mausinteraktion: Linke Maustaste fügt Dichte und zufällige Velocity hinzu
if pygame.mouse.get_pressed()[0]:
mx, my = pygame.mouse.get_pos()
i = int(mx // ZOOM)
j = int(my // ZOOM)
if 1 <= i < N-1 and 1 <= j < N-1:
fluid.dens_prev[j, i] += 100
fluid.u_prev[j, i] += cp.random.uniform(-2, 2)
fluid.v_prev[j, i] += cp.random.uniform(-2, 2)
# Immer ein klein wenig Dichte in der Mitte
fluid.dens_prev[center[1], center[0]] += 10 # Hinweis: [j, i] entspricht [y, x]
# Ein Schritt Fluid-Simulation mit Gravitation
fluid.step(GRAVITY)
# Dichte von GPU holen für Pygame
dens_host = cp.asnumpy(fluid.dens)
# In Graustufen umwandeln und skalieren
dens_normalized = np.clip(dens_host * 255, 0, 255).astype(np.uint8)
color_img = np.stack((dens_normalized, dens_normalized, dens_normalized), axis=-1)
# Skalieren des Bildes auf die Bildschirmgröße
color_img_scaled = np.repeat(np.repeat(color_img, ZOOM, axis=0), ZOOM, axis=1)
# Erstellen eines Pygame-Surfaces aus dem Array
surface = pygame.surfarray.make_surface(color_img_scaled.swapaxes(0, 1))
# Blitten der Surface auf den Bildschirm
screen.blit(surface, (0, 0))
pygame.display.flip()
pygame.quit()
sys.exit()
if __name__ == "__main__":
main()
@@ -0,0 +1,279 @@
# 1. Einführung
## Modellbildung
- **Modell**: Vereinfachte Darstellung eines Systems
- **Simulation**: Virtuelles Experiment
## Mathematische Modellierung
- Features, Größen ( Objekte z.B. Staub, Wandposter ; Parameter z.B. Temperatur, Druck)
- Wechselwirkungen (Temperatur auf Personen im Raum; Druck und Staub)
- Eindeutige Lösung: Existiert eine Lösung und ist sie eindeutig?
- Abhängigkeit von Initialwerten: Je nachdem wo man in einem Shooter startet, sind die Überlebenschancen unterschiedlich gut.
- Genauigkeit / Auflösung: Personenströme als Flüssigkeit modellieren, kann nicht eine einzelne Person darstellen.
## Modellarten
- **Diskret**: In Schritten Simuliert
- **Kontinuierlich**: In Echtzeit / stetig
Simuliert
- **Deterministisch**: Immer das gleiche Ergebnis, mit den gleichen Anfangsbedingungen
- **Stochastisch**: Zufällige Ergebnisse, auch mit den gleichen Anfangsbedingungen (z.B. Würfel)
- **Inverse**: Ausgangsbedingungen aus Ergebnissen bestimmen oder Ergebnisse aus Ausgangsbedingungen bestimmen
### Skalen
- 1D, 2D, 3D, so einfach wie möglich, so komplex wie nötig
- Abstraktionsebene: Menschen, Zellen oder Moleküle, oder gar Atome
## Diskretitierung
- Gitterbreite h (delta zwischen punkten)
# 2. Geometrische Modellierung
## Rigid Body Anforderungen
- keine losen Teile (Zusammenhängend)
- keine 1D-Teile (z.B Linie, Punkt)
- Es muss ein Innen und Außen geben (Volumen)
- keine Löcher
- keine Überlappungen
- Orientierbar (Außen und Innen unterscheidbar)
- Manigfaltig möglich (Zwei körper teilen sich eine Kante)
![alt text](image.png)
## Darstellungsformen (Speicherung)
- Vertecies (Ecken), Edges (Kanten), Faces (Flächen)
- $n_{v} - n_{e} + n_{f} = 2$ (Euler-Formel) -> Gilt für Rechtecke und Dreiecke
### vef-Graph
> Es werden nur die Koordinaten der **Eckpunkte** gespeichert, Kanten und Flächen speichern referenzen. Dadurch werden änderungen an den Eckpunkten automatisch in den Kanten und Flächen übernommen. \
> Eine **Kante** wird durch zwei Eckpunkte definiert. \
> Eine **Fläche** durch drei Kanten. \
![alt text](image-1.png)
## Volumenmodell
![alt text](image-3.png)
### Spacetree
- **Balanzierung**: Jeder Knoten entweder **0** oder **4** Kinder (Eine Fläche 2 hat Angrezende Flächen)
![alt text](image-7.png)
![alt text](image-4.png)
#### Codierung
![alt text](image-10.png)
#### Linearisierung
![alt text](image-11.png)
# 3. Spieltheorie
## Definition
- **Gewissheit**: Konsequenzen zu Aktionen bekannt
- **Risiko**: Wahrscheinlichkeit von Konsequenz zu Aktion teilweise bekannt
- **Unsicherheit**:keine Konsequenz zu Aktion bekannt
**Modellierung**
- Numbers of Players $N=\{1,2, \ldots, n\}$
- Anzahl Aktionen (Strategien)$A_i\qquad i\in \mathbb{N}$
- Menge Aktionsprofile (Strategieprofile) $A=\{\left( a_i \right)_{i\in \mathbb{N}}, a_i\in A_i, i\in\mathbb{N} \}$
- Auszahlungsfunktion $u_i: A\rightarrow\mathbb{R}$
## Unterteilung
- **Kooperation**
- **kooperative Spiele**: Spieler kooperieren müssen um zu gewinnen.
- **nicht-kooperative Spiele**: Spieler konkurrieren um zu gewinnen / spielen gegeneinander. (z.B. nur einer kann gewinnen)
- **Serie**
- **simultane Spiele**: In einem Durchlauf treffen alle für sich gleichzeitig die Wahl.
- **sequentielle Spiele**: Regeln wer wann Entscheiden darf.Sequenzielle Abfolge.
## Darstellung
- Bimatrixform / Normalform
- Gewinn wird angezeigt ($u_i$, $u_i$)
![bimatrix](image-12.png)
## Reine Strategien
### Gefangenen-Dilema
- Zwei Subjects $A_1\textrm{ und }A_2$
- Mögliche Aktionen
- **Leugnen L**: Niedrigere Strafe (2 Jahre)
- **Gestehen G**: Volle Strafe 5 (Kronzeuge) oder 8 Jahre
### Nash-Gleichgewicht
> Ist das Optimale Ergebnis für **alle** Spieler
- Wenn ein Spieler durch Ändern seiner Strategie, seinen Gewinn erhöhen kann, ist der aktuelle Zustand nicht im Nash-Gleichgewicht.
**Vorsicht!**:
- Jede Zelle muss einzeln betrachtet werden
- WICHTIG: Nicht mit der gleichen Strategie vergleichen
- Nash-Gleichgewicht muss für BEIDE Spieler gelten
![nash](image-14.png)
#### Dominante Strategien
> Eine Strategie die besser oder gleich gut ist wie alle anderen Strategien (>=)
**Beispiel:**
Sicht von S1:
- S2 nimmt Leugnen: Nimmt S1 Gestehen = 8, nimmt S1 Leugnen = 6. 8 >= 6
- S2 nimmt Gestehen: Nimmt S1 Gestehen = 3, nimmt S1 Leugnen = 0. 3 >= 0
- Kreuzen sich Dominante Strategien, ist dort das Nash-Gleichgewicht (aber nicht umgekehrt)
#### Stark Dominante Strategien
> Eine Strategie die echt besser ist als alle anderen Strategien (>)
#### Falke-Taube-Spiel
#### Zwei-Personen-Nullsummenspiel
- Spieler 2 will gewinn maximieren, Spieler 1 will verlust minimieren
- nicht jedes 2PNS in reinen Strategien hat ein Nash-Gleichgewicht.
- **Gewinnfunktion**: $u_2 = -u_1$
- Matrixform
![bimatrix_und_matrix](image-13.png)
##### Konservative Strategien
- Wenn die Konservate Strategie beider Spieler gleich ist, ist dort ein Nash-Gleichgewicht.
**MinMax-Strategie**
Was sollte ich höchstens verlieren?
> 1. Mache eine liste mit dem jeweils größten Verlust
> 2. Daraus wähle den kleinsten Verlust
$$U_{-} = \min_{i}(\max_{j}(a_{ij}) )$$
**MaxMin-Strategie**
Was sollte ich mindestens gewinnen?
> 1. Mache eine liste mit dem minimalen gewinn
> 2. Daraus wähle den größten Gewinn
$$U_{+} = \max_{j}(\min_{i}(a_{ij}) )$$
**Sattelpunkt**
> Nash-Gleichgewicht, wenn die Untergrenze und Obergrenze übereinstimmen. Dort ist auch der Sattelpunkt.
$$U_{-} = a_{i^* j^*} = U_{+}$$
![alt text](image-15.png)
## Gemischte Strategien
> Spieler entscheidet zufällig zwischen Strategien
- Jede Strategie hat eine Wahrscheinlichkeit. $p_i$
- Alle Wahrscheinlichkeiten addieren sich zu 1: $\sum_{i} p_i = 1$
- Minimum 2 Strategien
**Beispiel Spieler 1:**
$$p_1 = 70\%$$
$$p_2 = 1-p_1 = 30\%$$
**Beispiel Spieler 2:**
$$q_1 = 60\%$$
$$q_2 = 1-q_1 = 40\%$$
>Summe aus allen Zellen, eine Zelle wird mit der Wahrscheinlichkeit von Zeile und Spalte Multipliziert.
**ACHTUNG KANN MAN NUR GRAPHISCH LÖSEN**
![alt text](image-19.png)
### Lösen von Gemischten Strategien
> **Tip**: Beim Vereinfachen nicht die Klammern ausmultiplizeren, weil man einfach kürzen kann.
1. Setze Erwartungswerte gleich von Beiden Strategien für Beide Spieler
**Berechnen von q aus Sicht von Spieler 1**
$$\mu_{S_{11}} = \mu_{S_{12}}$$
**Berechnung von p aus Sicht von Spieler 2**
$$\mu_{S_{21}} = \mu_{S_{22}}$$
2. Einsetzen der Erwartungswerte und U- und U+ ausrechnen
3. Wenn U- und U+ gleich sind, ist das Nash-Gleichgewicht
> **INFO**: Wenn eine Freie Variable in der Gleichung ist, die gleichung in abhängigkeit von der freien Variable umstellen, nash-gleichgewicht ist dann von z.B. s abhängig.
![alt text](image-20.png)
![alt text](image-22.png)
## Gruppenentscheidungen
- Menge an Auswahlmöglichkeiten
- Jeder Möglichkeit wird eine Zahl ( $k \isin \N$ ) zugeordnet ( Rang )
- Rangabbildung ist Surjetiv (Jede Möglichkeit hat einen Rang. Ein Rang kann aber mehrmals auftreten )
### Relationen
$$r(x) < r(y): \text{x ist besser als y}$$
$$x \ R \ y: \text{x steht in Relation zu y}$$
>reflexiv schließt asymetrisch aus und umgekehrt
- **transitiv**: $x \ R \ y \ und \ y \ R \ z \Rightarrow x \ R \ z$
- $\text{Wenn 2 < 3 und 3 < 4, dann auch 2 < 4}$
- **reflexiv**: $x \ R \ x$
- $\text{2 <= 2}$
- **asymetrisch**: $x \ R \ y \And y \ R \ x \Rightarrow False$
- $\text{2 < 3, aber nicht 3 < 2}$
### Präferenzen
![](image-23.png)
![alt text](image-24.png)
>*Lesen*: Von links starten dann relation dann rechts
![](image-26.png)
### Extern/Intern Diktator
![alt text](image-27.png)
### Rangaddition
>Jede Wahlmöglichkeit wird mit der Summe der Ränge bewertet. Die Wahlmöglichkeit mit der niedrigsten Summe ist die beste.
![alt text](image-29.png)
![](image-30.png)
### Condorcet-Verfahren (BEI MINUTE 40:00 bis 1:10:00)
![alt text](image-32.png)
![](image-33.png)
### Einstimmigkeit
![alt text](image-34.png)
![alt text](image-37.png)
- I.e. Irrelevante Änderungen hinten in der Reihenfolge, dürfen nicht vorne in der Reihenfolge etwas ändern.
![](image-38.png)
![alt text](image-39.png)
# 4. Automaten
- **Forderung**: Simulation schneller als Echtzeit
## Bestandteile
- **Zellraum**: Spielfeld, i.d.R. eine Matrix in der jedes Element einer Zelle entspricht
- **Zustandsmenge**: Menge aller möglichen ( diskrete ) Zustände einer Zelle -> State Machine
- **Nachbarschaftsbeziehung**: Zustände der Nachbarzellen werden berücksichtigt
- **diskrete Zeit**: Zustandsänderung eines ZA erfolgt in diskreten Zeitschritten $\delta t$ (z.B. 1s)
- **lokale übergangsfunktion**: Berechnet den Zustand $Z_{t+\delta t}$ einer Zelle aus dem aktuellen Zustand $Z_t$ und den Zuständen der Nachbarzellen
## Nachbarzellen (im 2D und Schachbrett )
- **Moore-Nachbarschaft**: 8 Zellen um die Zelle
- **Von-Neumann-Nachbarschaft**: 4 Zellen um die Zelle
## Übergangsfunktion ( Beispiel Conways Game of Life)
```python
def transition_function(cell, neighbors):
if cell == 0 and sum(neighbors) == 3: # Wenn Zelle tot und 3 Nachbarn lebendig
return 1 # Dann wird die Zelle wiederbelebt
elif cell == 1 and sum(neighbors) in [2, 3]: # Wenn Zelle lebendig und 2 oder 3 Nachbarn lebendig
return 1
else:
return 0
```
## Game of Life
Start mit 2D-Gitter.
Jede Zelle ist entweder lebendig oder tot und ändert ihren Zustand gemäß der Nachbarzellen: \
Eine lebende Zelle mit 2 oder 3 lebenden Nachbarn bleibt am Leben, sonst stirbt sie.
Eine tote Zelle mit genau 3 lebenden Nachbarn wird lebendig.
Es werden ALLE Zellen mit dem aktuellen Zustand und den Nachbarzellen betrachtet, daraus wird der nächste Zustand berechnet, damit die Zellen parallel aktualisiert werden.
**Kurzfassung**:
- Grid anlegen (2D-Liste)
- Jede Runde Nachbarn zählen
- Nach obigen Regeln neue Zustände berechnen
- Endlos aktualisieren und ausgeben.
# Mathe schriftlich rechnen
## Dividieren
![alt text](image-16.png)
## Multiplizieren
![alt text](image-18.png)
@@ -0,0 +1,8 @@
![[Pasted image 20250131123257.png]]
![[Pasted image 20250131123144.png]]
![[Pasted image 20250131123158.png]]
![[Pasted image 20250131123224.png]]
![[Pasted image 20250131123251.png]]