update

src/bachelorarbeit.typ

@@ -306,6 +306,8 @@ line((0, 0), (6, 0))
 line((0, -1), (6, -1), stroke: (dash: "dashed"))
 line((0, -2), (6, -2), mark: (symbol: ">"), fill: blue, stroke: blue)
 line((0, -3), (6, -3), mark: (end: ">"), fill: blue, stroke: blue)
+line((0, -4), (6, -4), stroke: green + 5pt)
+line((0, -4), (6, -4), stroke: (dash: "dashed", paint: orange, thickness: 3pt))
 ```], [
 #cetz.canvas({
 import cetz.draw: *
@@ -313,6 +315,8 @@ import cetz.draw: *
   line((0, -1), (6, -1), stroke: (dash: "dashed"))
   line((0, -2), (6, -2), mark: (symbol: ">"), fill: blue, stroke: blue)
   line((0, -3), (6, -3), mark: (end: ">"), fill: blue, stroke: blue)
+  line((0, -3.5), (6, -3.5), stroke: green + 5pt)
+  line((0, -4), (6, -4), stroke: (dash: "dashed", paint: orange, thickness: 3pt))
 })], [```typ
 content((0, 0), [1])
 content((0, -1), [Median = 4])

src/informatik_3.typ

@@ -147,7 +147,7 @@ Für Strings: ```cpp #include <string> ```
 [Auf ein Element zugreifen \ empfohlen option], [```cpp str.at(0); ```],
 [Anzahl Zeichen im str], [```cpp str.length(); ```],
 [Grösse von vom String], [```cpp str.size(); ```],
-[Erstes Zeichen ausgeben], [```cpp str.font(); ```],
+[Erstes Zeichen ausgeben], [```cpp str.front(); ```],
 [Letztes Zeichen ausgeben], [```cpp str.back(); ```],
 [Vom start eine bestimmte länge ausgeben], [```cpp str.substr(start, anzahl_zeichen); ```],
 [Strings zusammensetzen], [```cpp
@@ -156,7 +156,7 @@ str += "world";
 str = str + "!";
 ```],
 [Bereich löschen], [```cpp  str.erase(start, anzahl_zeichen) ```],
-[Text einfügen], [```cpp  str.inset(start, "Hello") ```],
+[Text einfügen], [```cpp  str.insert(start, "Hello") ```],
 [find], [```cpp  size_t pos = str.find("de"); ``` \ ```cpp if (pos == std::string::npos){} ```],
 [Strings vergleichen], [```cpp (str1 == str2) ```],
 )
@@ -399,7 +399,7 @@ Da der Baum sortiert ist, musst du nicht jedes Element prüfen. Bei jedem Schrit
 ==== std::set
 Ein Set (Menge) ist ein Container, der zwei Regeln hat:
 - Einzigartigkeit: Jedes Element darf nur ein einziges Mal vorkommen. Wenn du versuchst, die Zahl 5 doppelt einzufügen, wird das zweite Mal einfach ignoriert.
-- Automatische Sortierung: In einem Standard-Set werden die Elemente immer automatisch sortiert (standardmäßig aufsteigend).
+- Automatische Sortierung: In einem Standard-Set werden die Elemente immer automatisch sortiert (standardmässig aufsteigend).
 
 ==== std::unordered_set
 Ein unordered_set ist im Grunde die "schnellere, aber chaotischere" Version des normalen Sets. Während das normale std::set intern einen Baum nutzt und alles sortiert, basiert das std::unordered_set auf einer Hash Table.
@@ -412,7 +412,7 @@ Eine Hash Table (Hashtabelle) ist eine Datenstruktur, die Daten extrem schnell s
 + Array (Eimer): Die Daten werden an genau diesem Index im Speicher abgelegt.
 
 ==== Big O notation
-Die Big O Notation (Groß-O-Notation) ist ein Maßstab in der Informatik, um die Effizienz eines Algorithmus zu beschreiben. Sie gibt an, wie die Laufzeit oder der Speicherbedarf ansteigt, wenn die Menge der Eingabedaten (n) größer wird.
+Die Big O Notation (Gross-O-Notation) ist ein Massstab in der Informatik, um die Effizienz eines Algorithmus zu beschreiben. Sie gibt an, wie die Laufzeit oder der Speicherbedarf ansteigt, wenn die Menge der Eingabedaten (n) grösser wird.
 #image("../img/informatik_3/Big_O.svg", width: 90%)
 
 #table(columns: (60pt, 80pt, 1fr, 1fr),
@@ -650,7 +650,7 @@ std::cout << a + b + c; // Ergibt 600
 
 int main() {
     // Wenn die Datei nicht existiert, wird sie erstellt.
-    // Wenn sie existiert, wird der Inhalt standardmäßig überschrieben!
+    // Wenn sie existiert, wird der Inhalt standardmässig überschrieben!
     std::ofstream datei("ausgabe.txt");
 
     if (datei.is_open()) {

src/physik_2.typ

@@ -1,4 +1,93 @@
-== Schwingungen und Wellen
+#import "@preview/cetz:0.4.1"
 
 == Elektromagnetismus
+=== Columb-Gesetz
+#grid(columns: (1fr, 1fr), gutter: 10pt, [
+  #align(horizon)[$ F_E eq gamma_E dot frac(Q_1 dot Q_2, r^2) dot accent(r, hat) eq frac(1, 4 dot pi dot epsilon_0) dot frac(Q_1 dot Q_2, r^2) dot accent(r, hat) $]
+], [
+#cetz.canvas({
+  import cetz.draw: *
+  line((0, 0.7), (0, -1.5))
+  line((0, 0), (-2, 0), mark: (end: ">"), fill: blue, stroke: blue + 3pt)
+  circle((0, 0), radius: 0.5, fill: gray)
 
+  line((4, 0), (6, 0), mark: (end: ">"), fill: blue, stroke: blue + 3pt)
+  line((4, 0.7), (4, -1.5))
+  circle((4, 0), radius: 0.5, fill: gray)
+
+  line((0, -1.3), (4, -1.3), mark: (symbol: ">"), fill: black, stroke: black)
+  line((1.5, 0), (2.5, 0), mark: (end: ">"), fill: black, stroke: black + 3pt)
+
+  content((0, 1), [$Q_1$])
+  content((4, 1), [$Q_2$])
+  content((-1.2, 0.5), [$minus bold(F)_E$])
+  content((5.2, 0.5), [$bold(F)_E$])
+  content((2, 0.5), [$accent(r, hat)$])
+  content((2, -1.6), [$r$])
+})
+])
+
+Elektrische Feldkonstante $epsilon_0 eq 8.854 dot 10^(-12) frac(C^2, N m^2)$
+
+
+=== Ampere-Gesetz
+#grid(columns: (1fr, 1fr), gutter: 10pt, [
+  $ F_B eq gamma_B dot frac(2 dot l, r) dot I_1 dot I_2 dot accent(r, hat) eq mu_0 dot frac(l, 2 dot pi dot r) dot I_1 dot I_2 dot accent(r, hat) $
+], [
+  #align(center)[
+    #cetz.canvas({
+      import cetz.draw: *
+      line((0, 0), (0, 3), mark: (start: "<", end: ">"), fill: black, stroke: black)
+      line((4, 0), (4, 3), mark: (start: "<", end: ">"), fill: black, stroke: black)
+      line((0, 1), (4, 1), mark: (symbol: ">"), fill: black, stroke: black)
+      line((0, 0.5), (5, 0.5), stroke: ((dash: "dashed", paint: gray)))
+      line((0, 2.5), (5, 2.5), stroke: ((dash: "dashed", paint: gray)))
+      line((4.7, 0.5), (4.7, 2.5), mark: (symbol: ">"), fill: black, stroke: black)
+      line((0, 2), (1.5, 2), mark: (end: ">"), fill: blue, stroke: blue + 3pt)
+      line((4, 2), (2.5, 2), mark: (end: ">"), fill: blue, stroke: blue + 3pt)
+
+      content((0, 3.3), [$I_1$])
+      content((4, 3.3), [$I_2$])
+      content((0.9, 2.4), [$bold(F)_B$])
+      content((3.1, 2.4), [$minus bold(F)_B$])
+      content((2, 1.3), [$r$])
+      content((5, 1.5), [$l$])
+
+      content((2, 3.4), [$accent(r, hat)$])
+      line((1.5, 3), (2.5, 3), mark: (end: ">"), fill: black, stroke: black + 3pt)
+    })
+  ]
+])
+
+magnetische Feldkonstante $mu_0 eq frac(1, c^2 dot epsilon_0) eq frac(1, c^2 dot 4 dot pi) eq 1.256 dot 10^(-6) frac(N, A^2)$ \
+// Ampère-Konstante $gamma_B eq 10^(-7) frac(N, A^2)$
+
+*Kräfte*
+#grid(columns: (1fr, 1fr), gutter: 10pt, [
+#table(columns: (25pt, 25pt, 100pt),
+[$Q_1$], [$Q_2$], [elektrische Kraft],
+[$plus$], [$plus$], [abstossend],
+[$plus$], [$minus$], [anziehend],
+[$minus$], [$plus$], [anziehend],
+[$minus$], [$minus$], [abstossend],
+)
+], [
+#table(columns: (25pt, 25pt, 100pt),
+[$I_1$], [$I_2$], [magnetische Kraft],
+[$plus$], [$plus$], [abstossend],
+[$plus$], [$minus$], [anziehend],
+[$minus$], [$plus$], [anziehend],
+[$minus$], [$minus$], [abstossend],
+)
+])
+
+=== Maxwell-Relation
+$ frac(gamma_E, gamma_B) eq frac(1, epsilon_0 dot mu_0) eq c^2 $
+
+$gamma_E eq 1$ \
+$gamma_B eq 10^(-7) frac(N, A^2)$
+
+
+
+
+== Schwingungen und Wellen

src/python.typ

@@ -12,6 +12,10 @@
 [Array],                  [```py np.arange(4, 10) ``` \ ```py np.arange(0, 1, 0.2) ```], [\[4 5 6 7 8 9\] \ \[0. 0.2 0.4 0.6 0.8\]],
 [ln],                 [```py np.log(x) ```], [],
 [10er log],           [```py np.log10(x) ```], [],
+[$log_2(x)$],           [```py log(x)/np.log(2) ```], [],
+[$log_x (10)$],           [```py np.log(10)/ np.log(x) ```], [],
+[$integral$ integral],           [```py I = np.trapezoid(y_data, x_data) ``` \ x und y_data sind arrays], [],
+[Daten einlesen],                 [```py data = np.genfromtxt("Daten.txt") ```], [],
 )
 
 
@@ -199,6 +203,8 @@ plt.show()
 *optionen*
 #table(columns: (0.6fr, 0.9fr),
 [Abstand so das nichts überlagert], [```py plt.tight_layout() ```],
+[Abstand mit pad], [```py fig.tight_layout(pad=3.0) ```],
+[Plots in eindimensonalem array \ (re-arrange axes matrix in a vector)], [```py axs = axs.flatten() ```],
 [Abstand zwischen den plots], [```py plt.subplots_adjust(wspace=0.35) ```],
 [Schriftgrösse], [```py ax.set_title(r'$r^2 = 0.9$', fontsize=14) ``` \ ```py ax.legend(fontsize=8) ```],
 [Abstand zwischen den plots], [```py plt.subplots_adjust(wspace=0.35) ```],
@@ -220,3 +226,22 @@ plt.show()  # savefig muss zwingend vor show()!
 [Spezifische auflösung], [```py plt.savefig("test.pdf", dpi=300) ```],
 )
 
+=== ev. interessant
+
+```py
+# Die Achsen in die Mitte schieben
+ax.spines['bottom'].set_position('zero')
+ax.spines['left'].set_position('zero')
+
+# Die Ränder oben und rechts entfernen
+ax.spines['top'].set_visible(False)
+ax.spines['right'].set_visible(False)
+
+# --- DER HAUPTTITEL ---
+fig.suptitle("Signalverarbeitung: Zeit-Transformationen", fontsize=16, fontweight='bold')
+
+# pad: Abstand zum Rand der Figur
+# w_pad: Horizontaler Abstand zwischen den Subplots
+# h_pad: Vertikaler Abstand zwischen den Subplots
+plt.tight_layout(pad=3.0, w_pad=4.0, h_pad=2.0)
+```

src/signalverarbeitung.typ

@@ -1,6 +1,138 @@
+#import "@preview/cetz:0.4.1"
+
 == Basis-Signale
+#cetz.canvas({
+  import cetz.draw: *
+
+  content((1, 1.5), ["Einfaches" System])
+  rect((0, 0), (2, 1))
+  line((-1, 0.5), (0, 0.5), mark: (end: ">"), fill: blue, stroke: blue)
+  line((2, 0.5), (3, 0.5), mark: (end: ">"), fill: blue, stroke: blue)
+  content((1, 0.5), [System])
+  // content((-1, 1.5), [Eingangssignal])
+  // content((3, 1.5), [Ausgangssignal])
+  content((-1.4, 0.5), [#text(fill: red)[x(t)]])
+  content((3.4, 0.5), [#text(fill: red)[y(t)]])
+
+  content((8, 1.5), ["Mehr Eingänge" System])
+  rect((7, -1), (9, 1))
+  line((6, 0.7), (7, 0.7), mark: (end: ">"), fill: blue, stroke: blue)
+  line((6, 0.3), (7, 0.3), mark: (end: ">"), fill: blue, stroke: blue)
+  line((6, -0.7), (7, -0.7), mark: (end: ">"), fill: blue, stroke: blue)
+  line((9, -0.7), (10, -0.7), mark: (end: ">"), fill: blue, stroke: blue)
+  line((9, 0.7), (10, 0.7), mark: (end: ">"), fill: blue, stroke: blue)
+  line((9, 0.3), (10, 0.3), mark: (end: ">"), fill: blue, stroke: blue)
+  content((8, 0.5), [System])
+  content((5.4, 0.7), [#text(fill: red)[$x_1(t)$]])
+  content((5.4, 0.3), [#text(fill: red)[$x_2(t)$]])
+  content((10.5, 0.7), [#text(fill: red)[$y_1(t)$]])
+  content((10.5, 0.3), [#text(fill: red)[$y_2(t)$]])
+  content((5.4, -0.7), [#text(fill: red)[$x_n (t)$]])
+  content((10.5, -0.7), [#text(fill: red)[$y_n (t)$]])
+})
+
+*Signal* \
+Ein Signal ist eine physikalische Grösse, die Informationen überträgt. Es ist eine Funktion, die sich über die Zeit oder den Raum verändert.
+- Beispiele: Schallwellen, elektrische Spannungen oder die Pixelwerte eines Bildes.
+- Zweck: Es trägt die Nachricht oder den Datenwert (z. B. Musik oder Temperatur).
+
+*Das System* \
+Ein System ist eine Anordnung oder ein Algorithmus, der auf ein Signal einwirkt. Es nimmt ein Eingangssignal auf und wandelt es in ein Ausgangssignal um.
+- Beispiele: Ein Verstärker, ein Filter oder ein Computerprogramm.
+- Zweck: Es verändert, analysiert oder überträgt das Signal nach bestimmten Regeln.
+
+*Übertragungsfunktion* \
+$ y(t) eq H(x(t)) $
+#grid(columns: 3, gutter: 10pt,
+[- $x(t)$], [$arrow$], [Das Eingangssignal],
+[- $H$], [$arrow$], [Das System (Transformation)],
+[- $y(t)$], [$arrow$], [Das bearbeitete Ausgangssignal],
+)
+
+== Beschreibung von Systemen
+#table(columns: (1fr, 1fr, 1fr),
+[Reihen von Systemen (Kaskade)], [Parallelschaltung], [Feedback-System  (System mit Rückkopplung)],
+[#image("../img/sigver/Gekoppelte_Systeme_Kaskade.png")],
+[#image("../img/sigver/Gekoppelte_Systeme_Parallelschaltung.png")],
+[#image("../img/sigver/Gekoppelte_Systeme_Feedback-System.png")],
+)
+
+
 == Eigenschaften von Systemen
+#grid(columns: (1fr, 1fr), gutter: 10pt,
+[Es gibt vier Klassen von Signalen
+
+- *Zeitkontinuierlich* \
+  Das Signal ist zu jedem beliebigen Zeitpunkt vorhanden.
+- *Zeitdiskret* (abgetastet) \
+  Das Signal wird nur zu bestimmten Zeitpunkten gemessen.
+- *Amplitudenkontinuierlich* \
+  Das Signal kann jeden beliebigen Wert annehmen (stufenlos)
+- *Amplitudendiskret* (quantisiert) \
+  Es sind nur bestimmte, feste Stufen für die Werte erlaubt. Dies nennt man einen diskreten Wertebereich
+],
+[#image("../img/sigver/signal_klassen.png")],
+)
+
+#table(columns: (64pt, 75pt, 75pt, 1fr),
+fill: (x, y) => if y == 0 {gray.lighten(40%)},
+[Typ], [Zeit], [Amplitude], [Merkmal],
+[Analog], [kontinuierlich], [kontinuierlich], ["Eine klassische, glatte Kurve."],
+[Abgetastet], [diskret], [kontinuierlich], ["Werte nur an festen Zeitpunkten, aber exakte Höhe."],
+[Quantisiert], [kontinuierlich], [diskret], [Treppenstufen-Form über die gesamte Zeit.],
+[Digital], [diskret], [diskret], ["Punkte, die sowohl zeitlich als auch wertmässig festliegen."],
+)
+
+*Linear*
+- Das System reagiert proportional. Wenn du zwei Eingangssignale mischst, ist das Ergebnis die Summe der beiden einzelnen Reaktionen.
+*Zeitinvarianz*
+- Eine zeitliche Verschiebung am Eingang führt zur exakt gleichen Verschiebung am Ausgang. $arrow$ System ist nicht von der Zeit abhänig.
+*LTI-Systeme* (linear time-invariant)
+- Ist die kombination von Linear und Zeitinvarianz. Diese System sind vollständig beschreibbar.
+
+*Überlagerung*
+- Die Reaktion auf die Summe von Signalen entspricht der Summe der Einzelreaktionen.
+*Kausalität*
+- Ein System reagiert nur auf aktuelle oder vergangene Eingangswerte, niemals auf zukünftige.
+*Verstärkung*
+- Dies beschreibt das Verhältnis zwischen Ausgangs- und Eingangsamplitude.
+*Stabilität*
+- Ein System gilt als stabil, wenn es auf kontrollierte Eingaben nicht mit einem unendlichen Anwachsen des Ausgangssignals reagiert.
+
+*BIBO* (Bounded Input, Bounded Output) (begrenzter Eingang, begrenzter Ausgang).
+- Ein System ist BIBO-stabil, wenn jedes begrenzte Eingangssignal ($abs(x(t))<M$) auch zu einem begrenzten Ausgangssignal führt.
+
+=== Klassifizierung von Signalen
+*Zeitverhalten*
+- Kausale Signale: Diese Signale sind für alle Zeiten vor dem Nullpunkt ($t<0$) gleich Null.
+- Periodische Signale: Das Signal wiederholt sich exakt nach einer festen Zeitdauer T.
+- Aperiodische Signale: Diese Signale wiederholen sich nicht; es gibt kein festes T, für das die Gleichung gilt.
+
+*Amplitudenverhalten*
+- Begrenzte Signale: Der Wert des Signals bleibt immer unter einer bestimmten Grenze M.
+- Nichtbegrenzte Signale: Das Signal kann unendlich grosse Werte annehmen.
+
+*Symmetie*
+- Gerade Signale: Sie sind *achsensymmetrisch* zur vertikalen Achse (t=0). Es gilt: $x(t)=x(−t)$.
+- Ungerade Signale: Sie sind *punktsymmetrisch* zum *Ursprung*. Es gilt: $x(t)=−x(−t)$.
+
+=== Zeit-diskrete Basis-Signale
+#grid(columns: (1fr, 1fr), gutter: 10pt, [
+Die Impulsfolge hat nur zu einem einzigen Zeitpunkt (meist t=0) einen Wert ungleich Null und ist ansonsten überall Null.
+
+Die Schrittfolge (Einheitsschritt) springt zum Zeitpunkt t=0 von Null auf Eins und bleibt für alle folgenden Zeiten dauerhaft auf diesem Wert.
+], [#image("../img/sigver/signalverarbeitung_zeit_diskrete_signale.svg")])
+
+=== Periodische zeitdiskreten Signale
+$ N eq frac(k dot 2 pi, Omega) $
+- $N$ Die Periodendauer im Diskreten (muss eine ganze Zahl an Abtastwerten sein).
+- $Omega$ Die normierte digitale Kreisfrequenz des Signals.
+- $k$ Eine beliebige ganze Zahl.
+
 == Transformationen von Signalen
+#image("../img/sigver/signalverarbeitung_zeit-transformationen.svg")
+
+
 == Filtern
 == Zeit-diskrete und zeit-kontinuierlich Modulation
 == Abtasten (Sampling) und Interpolation