Merge branch 'master' of https://github.com/wieerwill/Informatik

Automaten, Sprachen und Komplexität.md

@@ -172,3 +172,84 @@ Bemerkung:
 
 > Satz: Es gibt einen Algorithmus, der als Eingabe eine Typ-1-Grammatik G und ein Wort w bekommst und nach endlicher Zeit entscheidet ob $w\in L(G)$ gilt.
 
+
+# Rechtslineare Sprachen
+werden durch Typ 3 erzeugt
+
+## endliche Automaten (Maschinen)
+anderer blickwinkel für rechtslineare Sprachen (ohne Speichereinheit)
+Eingabe: Folge von " Buchstaben"
+
+> Definition: ein deterministischer endlicher Automat M ist ein 5-Tupel $M=(Z, \sum, z_0, \delta, E)$
+- $Z$ eine endliche Menge von Zuständen
+- $\sum$ das Eingabealphabet (mit $Z\cap\sum = \varemtpy$)
+- $z_0\inZ$ der Start/Anfangszustand
+- $\delta: Z \times \sum \rightarrow Z$ die Überführungs/Übergangsfunktion
+- $E\subseteq Z$ die Menge der Endzustände
+
+Abkürzung: DFA (deterministic finite automaton)
+
+Bsp:
+- $Z={0,1}$
+- $\sum={a,b$}
+- $z_0=0$
+- $\delta(0,a)=\delta(1,b)=1, \delta(1,a)=\delta(0,b)=0$
+- $E={0}$
+- 
+in DFA darf es nur einen einzigen Startzustand geben!
+im Graphendiagramm: jeder Knoten hat die anzahl der alphabete als kanten
+
+die (einmal lesende) $\delta$ Funktion wird verallgemeinert: $\roof{\delta}$, die die Übergänge für ganze Wörter ermittelt
+
+> Definition: Zu einem gegebenen DFA definieren wir die Funktion $\roof{\delta}: Z \times \sum^* \rightarrow Z$ induktiv wie folgt, wobei $z\in Z$, $w\in\sum^+$ und $a\in \sum$:
+- $\roof{\delta}(z, \epsilon) = z$
+- $\roof{\delta}(z,aw)= $\roof{\delta}(\delta(z,a),w)$
+
+Der Zustand $\rrof{\delta)$ ergibt sich indem man vom Zustand z aus dem Pfad folgt der mit w beschriftet ist.
+
+> Definition: die von einem DFA **akzeptierte Sprache** ist: $L(M)={w\in\sum^* | \roof{\delta}(z_0,w)\in E}$
+
+d.h. wenn der Pfad der im Anfangszuststand beginnt nach den Übergangen durch w-markierte Pfade in einem Endzustand endet
+
+> Definition: EIne Sprache $L \supseteq \sum^*$ ist regulär, wenn es einen DFA #####################################
+(wird von einem DFA akzeptiert)
+
+
+> Proposition: Jede reguläre Sprache ist rechtslinear
+Beweis: sei M ein DFA, definiere eine Typ-3 Grammatik G wie folgt:
+- $V=Z$
+- $S=z_0$
+- $P={z\rightarrow a \delta(z,a) | z\in Z, a\in \sum} \cup {z\rightarrow \epsilon | z\in E}$ (Regeln abgeleitet aus Graphen mit Kanten; letzte Regel um ENdzustand in ein Terminal zu wandeln).
+
+Behauptung: für alle $z,z'\inZ$ und $w\in \sum^*$ gilt: $z\Rightarrow^*_G wz' \Leftrightarrow \roof{\delta} (z,w)=z'$. Beweis durch Induktion über $|w|$.
+Für $w\in\sum^*$ gilt dann $w\in L(G) \Leftrightarrow \exist z\in V: z_0\Rightarrow^*_G wz \Rightarrow_G w \Leftrightarrow \exists z\in Z:\roof{\delta}(z_o, w)=z$ und $Zz\rightarrow \epsilon)\in P \leftrightarrow \roof{\delta}(z_0, w)\in E \leftrightarrow w\in L(M)$
+
+ALso ist $L(M)=L(G)$ und damit rechtslinear
+
+DFAs sind deterministisch, Grammatiken nichtdeterministisch
+
+erweiterte DFA um Nichtdeterminismus zu NFAs (nichtdeterministic finite automaton)
+
+> Definition: ein nichtdeterministischer endlicher Automat M ist ein 5-Tupel $M=(Z,\sum,S,\delta,E)$ mit
+- $Z$ ist eine endliche Menge von Zuständen
+- $\sum$ ist das Eingabealphabet
+- $S\subseteq Z$ die Menge der Startzustände (können mehrere sein)
+- $\delta: Z \times \sum \rightarrow P(Z)$ ist die (Menge der) Überführungs/Übergangsfunktion
+- $E\subseteq Z$ die Menge der Endzustände
+
+$P(Z)={Y | Y \subseteq Z}$ ist die Potenzmenge von Z (die Menge aller Teilmengen von Z). Diese Menge wird manchmal auch mit "2^Z$ bezeichnet
+
+Bsp
+- $\delta={2,3}$ heißt aus einem Zustand gibt es zwei mögliche Wege mit gleicher belegung
+- $\delta=\varemtpy$ heißt es gibt keinen Weg aus dem Zustand
+
+> Definition: Zu einem gegebenen NFA M definieren wir die Funktion $\roof{\delta}:P(Z)\times \sum^* \rightarrow P(Z)$ induktiv wie folgt, woebei $Y \subseteq Z$, $w\in \sum^*$ und $a\in\sum$: $\roof{\delta}(Y,\epsilon)=Y$, $\roof{\delta}(Y,aw)=\roof{delta}(\bigcup \delta(z,a),w)$
+
+> Definition: die von einem NFA M akzeptierte Sprache ist $L(M)={w\in \sum^* | \roof{\delta}(S,w)\cap E \not = \varemtpy}$
+( Das Wort wird akzeptiert wenn es mindestens einen Pfad vom anfangs in den endzustand gibt)
+
+> Proposition: Jede von einem NFA akzeptierte Sprache ist regulär
+Zustände des DFA sind Mengen von Zuständen des NFA, daher auch Potzenmengenkonstruktion
+
+$w\in L(M') \leftrightarrow \roof\gamma (S,w)\in F \leftrightarrow \roof\delta(S,w)ßcap E\not = \varempty \leftrightarrow w\in L(M)$ und damit $l(M')=L(M)$
+

Betriebssysteme.md

@@ -78,9 +78,124 @@ Wie - mit welchen speziellen weiteren Eigenschaften sollen die funktionalen Eige
   - in Fahrzeugen, Kaffeemaschinen, Telefonen...
   - z.T. Spezialaufgaben
 
-# Grundbegriffe 
+## Grundbegriffe 
 - Wo sind Betriebssysteme zu finden?
 - Welches Spektrum decken sie ab?
 - Welche Arten von Betriebssystemen gibt es?
 - Welche funktionalen und nichtfunktionalen Eigenschaften spielen dabei eine Rolle?
 
+# Prozessormanagement: Prozesse und Threads
+## Grundsätzliches
+1. Computer bearbeiten Aufgaben in wohldefinierten Arbeitsabläufen (beschrieben durch Programme/Algorithmen)
+2. bei abarbeitung von Programmen entstehen oft Wartesituationen
+3. Wartezeiten sind ~ relativ zur Prozessorgeschwindigkeit ~ gigantisch (1 Sek ~ 10 Milliarden Prozessorzyklen)
+4. statt zu warten, lässt sich besseres tun (parallele Ausführung mehrerer Aufgaben)
+5. Parallelität geht nicht immer (vorraussetzung Nebenläufigkeit)
+
+Begriffe
+1. Aktivitäten heißen nebenläufig, wenn zwischen ihnen keine kausalen abhängigkeiten bestehen
+2. Aktivitäten heißen parallel, wenn sie zeitlich überlappend druchgeführt werden
+
+
+> Definition Prozess: Ein Prozess ist eine Abstraktion zur vollständigen Beschreibung einer sequenziell ablaufenden Aktivität
+
+parallele Aktivitäten werden repräsentiert durch parallele Prozesse
+
+> Prozess = betriebssystem-Abstraktion zur Ausführung von programmen
+
+> Prozessmodelle: definieren konkrete Prozesseigenschaften
+
+> Prozessmanagement: Komponente eines Betriebssystems, die Prozessmodell dieses Betriebssystems implementiert
+
+> Aufgabe: präzise Definition der Betriebssystem-Abstraktion "Prozess"
+(definiert durch Semantik und nichtfunktionale Eigenschaften; implementiert durch Datenstrukturen/Algorithmen)
+
+> Prozesserzeugung: Erzeugen einer Programmablaufumgebung
+
+## Prozesserzeugung
+### Was geschieht bei der Prozesserzeugung
+1. Prüfen notwendiger Vorraussetzungen (Rechte, Ressoucenverfügbarkeit,...)
+2. Namensvergabe und "Stammbaumpflege"
+3. Allokation von Ressourcen (Arbeitsspeicher, Prozessorzeit)
+4. Anlegen von Managementstrukturen (belegte Ressourcen, Laufzetmanagement)
+
+### Prozesserzeugung: notwenige Vorraussetzungen
+1. Rechte: zur Prozesserzeugung und Ressourcenallokation (Kontingente)
+2. Ressourcenverfügbarkeit (Arbeitsspeicher, Rechenzeit, Kommunikation)
+3. Sicherheit (Authentizität und Integrität des auszuführenden Programms)
+4. bei Echtzeitbetriebssystem
+    - Erfüllung von Ressourcenanforderung
+    - Einhaltung gegebener Garantien
+5. Fairness (Quoten)
+6. robustheit/Überlastvermeidung (Lastsituation)
+
+### Prozesserzeugung: Namensvergabe
+Identifikation ist positive ganze Zahl durch Vergabe Algorithmus. Kann nach Terminierung eines Prozesses erneut vergeben werden
+- eindeutig: zu einem Zeitpunkt bzgl aller existierenden Prozesse
+- nicht unbedingt eindeutig: für zeitlich nicht überlappende Prozesse
+- erst recht nicht eindeutig: über Systemgrenze hinweg
+
+### Prozesserzeugung: Stammbaumpflege
+Abstammungsbeziehung: definieren Eltern/Kind Hierarchie
+1. Prozess erzeugt weitere Prozesse: Kinder
+2. diese wiederum erzeugen weitere Prozesse usw
+-> baumartige Abstammungshierarchie
+Nutzung: Rechte und Verantwortlichkeiten
+
+Verwaiste Prozesse -> Adoption (durch Urprozess)
+
+### Prozesserzeugung: Allokation (Zuordnung) von Ressourcen
+1. Arbeitsspeicher
+   1. Größe: Wie viel Arbeitsspeicher benötigt der Prozess?
+   2. Zeitpunkt: zu welchem Zeitpunkt? Echtzeiteigenschaften (Planbarkeit) oder Performanz (proaktivität)?
+   3. Isolation: wie ist er geschützt? (Robustheit, Sicherheit, Korrektheit)
+2. Prozessorzeit
+   1. in Prozessmodellen echtzeitfähiger Systeme: Größe und Zeitpunkt
+   2. in Prozessmodellen ohne diese Eigenschaften: dynamisches ad-hoc-Scheduling
+
+für richtige Initialisierung: präzise Formatvereinbarung zwischen
+- Linker (Programmdatei-Produzent)
+- Prozessmanagement des BS (Programmdatei Nutzer)
+
+1. das a.out-Format (veraltet; ursprünglich Unix Format)
+2. das Mach Object File Format (Mach-O; heutiger Standard für OS X, iOS)
+3. das Executable and Link(age/able) Format (ELF; heutiger Linux standard)
+
+### Prozesserzeugung: Management Datenstrukturen
+Buchführung über sämtliche zum management notwendigen Informationen
+- Prozessidentifikation
+- Rechtemanagement
+- Speichermanagement
+- Prozessormanagement
+- Kommunikationsmanagement
+
+a. Prozessdeskriptor (process control block ~ PCB)
+b. Prozessdeskriptortabelle: Deskriptioren sämtlicher Prozesse
+
+| Prozessormanagement | |
+| Identifikation | eindeutige Prozessbezeichnung; einordnung in Abstammungshierarchie |
+| Scheduling | Informationen für Schedulingalgorithmen |
+| Prozessorkontext | gesichert bei Verdrängung des Prozesses, restauriert bei Reaktivierung |
+| Ereignismanagement | what if... |
+| Accounting (Kontoführung) | zur Prioritätsbestimmung, Statisik, kostenberechnung |
+| Virtueller Adressraum | Beschreibung des Speicherlayouts | 
+| Kernel Stack | Prozedurmanagement innerhalb des BS | 
+| Rechtemanagement | |
+| Allgemeines Ressourcenmanagement | Filedeskriptoren, Socketdeskriptoren,... |
+
+### Aktionen des Prozessmanagements
+- Prüfen notweniger Vorraussetzungen
+- Namensvergabe und Stammbaum
+- Allokation von Ressourcen
+- Anlegen von Managementdatenstrukturen (Prozessdeskriptor)
+
+### Prozessterminierung
+durch
+- Aufgabe erledigt
+- Fehler aufgetreten
+- durch Nutzer/Eigentümer geschlossen
+- ...
+
+1. Freigabe der Ressourcen
+2. Benachrichtigung der "Eltern"
+3. Adoption der "Kinder"

Computergrafik.md

@@ -213,8 +213,72 @@ Richtungsvektoren können als Differenz zweier Ortsvektoren hergeleitet werden.
 
 Eine Translations-Matrix wirkt sich nur auf Ortsvektoren aus. Richtungsvekoren bleiben bei Translation unverändert. Da bei der Berechnung nicht zwischen Orts- und Richtungsvektoren unterschiedenwerden lassen sich verknüpfte Transformationen effizient berechnen.
 
-### Zusammenfassung
+### Zusammenfassung bisher
 - durch den "Kunstgriff" werden Transformationen vereinheitlicht und damit vereinfacht
 - 2D kartesische Vektoren werden im 3D homogenen Vektorraum dargestellt
 - wichtige Transformationen können einheitlich durch 3x3 Matrizen dargestellt werden
-- Orts- und Richtungsvektoren werden unterschiedlich dargestellt aber mit der selben Transformationsmatrix automatisch korrekt und effizient transformiert.
+- Orts- und Richtungsvektoren werden unterschiedlich dargestellt aber mit der selben Transformationsmatrix automatisch korrekt und effizient transformiert.
+
+## Homogene Transformation in 3D
+Analog zum 2D Fall wird der Vektorraum um eine zusätzliche Dimension erweitert (Koordinate w).
+
+3 Dimensionale kartesische koordinaten werden durch eine 4-dimensionale homogeen Vektorraum repräsentiert; er wird als 4-Tupel dargestellt. In vielen Anwendungsfällen wir w=1 gewählt (karteische Hyperebene).
+
+Affine Abbildungen lassen die w-Koordinate unverändert
+
+### Ebenen
+- lassen sich grundsätzlich auch als Referenzpunkt und Richtung speichern
+- für Berechnungen ist folgende Repräsentation sinnvoll: (a,b,c,d) wobei (a,b,c)=(nx,ny,nz) und d der Abstand der Ebene zum Ursprung. Dann ist für einen in der Ebene enthaltenen Punkt das Skalarprodukt aus Ebene und Punkt gleich 0
+
+1. Ebene definiert durch 3 Punkte
+   $$\begin{pmatrix}
+    x_1 & x_2 & x_3 & 0\\
+    y_1 & y_2 & y_3 & 0\\ 
+    z_1 & z_2 & z_3 & 0\\
+    1 & 1 & 1 & 1
+    \end{pmatrix}$$
+2. Translation um Vektor $(\Delta x, \Delta y,\Delta z)$
+   $$\begin{pmatrix}
+    1 & 0 & 0 & \Delta x\\
+    0 & 1 & 0 & \Delta y\\ 
+    0 & 0 & 1 & \Delta z\\
+    0 & 0 & 0 & 1
+    \end{pmatrix}$$
+3. Skalierung um Faktor $F_x,F_y,F_z$
+   $$\begin{pmatrix}
+    F_y & 0 & 0 & 0\\
+    0 & F_y & 0 & 0\\ 
+    0 & 0 & F_z & 0\\
+    0 & 0 & 0 & 1
+    \end{pmatrix}$$
+4. Rotation um z-Achse
+   $$\begin{pmatrix}
+    cos(\theta) & -sin(\theta) & 0 & 0\\
+    sin(\theta) & \cos(\theta) & 0 & 0\\ 
+    0 & 0 & 1 & 0\\
+    0 & 0 & 0 & 1
+    \end{pmatrix}$$
+5. Rotation um die x-Achse
+   $$\begin{pmatrix}
+    1 & 0 & 0 & 0\\
+    0 & cos(\theta) & -sin(\theta) & 0\\ 
+    0 & sin(\theta) & cos(\theta) & 0\\
+    0 & 0 & 0 & 1
+    \end{pmatrix}$$
+6. Rotation um die y-Achse
+   $$\begin{pmatrix}
+    cos(\theta) & 0 & sin(\theta) & 0\\
+    0 & 1 & 0 & 0\\ 
+    -sin(\theta) & 0 & cos(\theta) & 0\\
+    0 & 0 & 0 & 1
+    \end{pmatrix}$$
+
+### Kommutativität
+allgemein sind Transformationen nicht kommutativ; außnahme bilden zwei Rotationen um die selbe Achse
+
+### Kameratransformation
+Kamera ist definiert durch
+- Lage des Augpunktes E (in Weltkoordinaten)
+- Blickrichtung D
+- Oben-Vektor U ("view up vector", senkrecht zu D)
+