Organisation
This commit is contained in:
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)
|
||||
|
||||

|
||||
|
||||
## 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. \
|
||||
|
||||

|
||||
|
||||
## Volumenmodell
|
||||

|
||||
|
||||
### Spacetree
|
||||
- **Balanzierung**: Jeder Knoten entweder **0** oder **4** Kinder (Eine Fläche 2 hat Angrezende Flächen)
|
||||

|
||||
|
||||

|
||||
|
||||
#### Codierung
|
||||

|
||||
|
||||
#### Linearisierung
|
||||

|
||||
|
||||
# 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$)
|
||||

|
||||
|
||||
## 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
|
||||
|
||||

|
||||
|
||||
#### 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
|
||||

|
||||
|
||||
##### 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_{+}$$
|
||||
|
||||

|
||||
## 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**
|
||||

|
||||
|
||||
### 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.
|
||||
|
||||

|
||||

|
||||
|
||||
## 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
|
||||

|
||||

|
||||
>*Lesen*: Von links starten dann relation dann rechts
|
||||

|
||||
|
||||
### Extern/Intern Diktator
|
||||

|
||||
|
||||
### Rangaddition
|
||||
>Jede Wahlmöglichkeit wird mit der Summe der Ränge bewertet. Die Wahlmöglichkeit mit der niedrigsten Summe ist die beste.
|
||||

|
||||

|
||||
|
||||
### Condorcet-Verfahren (BEI MINUTE 40:00 bis 1:10:00)
|
||||

|
||||

|
||||
|
||||
### Einstimmigkeit
|
||||

|
||||
|
||||

|
||||
- I.e. Irrelevante Änderungen hinten in der Reihenfolge, dürfen nicht vorne in der Reihenfolge etwas ändern.
|
||||
|
||||

|
||||

|
||||
|
||||
# 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
|
||||

|
||||
|
||||
## Multiplizieren
|
||||

|
||||
Binary file not shown.
@@ -0,0 +1,8 @@
|
||||
![[Pasted image 20250131123257.png]]
|
||||
|
||||
![[Pasted image 20250131123144.png]]
|
||||
![[Pasted image 20250131123158.png]]
|
||||
![[Pasted image 20250131123224.png]]
|
||||
![[Pasted image 20250131123251.png]]
|
||||
|
||||
|
||||
Reference in new issue
Block a user