From db216bfa48b476d58a1d476030ca665cc2900e20 Mon Sep 17 00:00:00 2001 From: MuedeHydra Date: Thu, 2 Oct 2025 16:17:45 +0200 Subject: [PATCH] add info 3 --- photonics.typ | 126 ++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 123 insertions(+), 3 deletions(-) diff --git a/photonics.typ b/photonics.typ index 7dc8f5a..adea93a 100644 --- a/photonics.typ +++ b/photonics.typ @@ -1,3 +1,6 @@ +// fill: (x, y) => if y == 0 {gray.lighten(40%)}, +// + // {{{ #set text(lang: "de", hyphenate: true) #set par(justify: true) // Blocksatz @@ -237,11 +240,12 @@ Definition // }}} = Lineare Algebra // {{{ -== linalg 3 #pagebreak() -= Mathematik 3 +// }}} += Mathematik 3 (Analysis 3) +// {{{ == Differentialgleichungen === Abkürzungen #table(columns: (0.5fr, 1fr, 1fr), @@ -283,6 +287,10 @@ fill: (x, y) => if y == 0 {gray.lighten(40%)}, ], ) +// }}} += Mathematik 3 (Lineare Algebra 3) +// {{{ + #pagebreak() // }}} @@ -628,7 +636,7 @@ class Vec3 { public: ... double x; - private: + private: double y; double z; }; @@ -676,7 +684,119 @@ class Foo { }; ```] +==== constructor +==== decounstructor + +=== overloading + +=== std -> Namespace + +=== std::string +Für Strings: ```cpp #include ``` +#table(columns: (1fr, 1fr), +[String einer Variable Zuweisen], [```cpp std::string str = "Hello"; ```], +[Auf ein Element zugreifen \ (Nicht empfohlen da zugriff auch ausserhalb des str möglich)!], [```cpp str[0]; ```], +[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(); ```], +[Letztes Zeichen ausgeben], [```cpp str.back(); ```], +[Vom start eine bestimmte länge ausgeben], [```cpp str.substr(start, anzahl_zeichen); ```], +[Strings zusammensetzen], [```cpp +str = "Hello"; +str += "world"; +str = str + "!"; +```], +[Bereich löschen], [```cpp str.erase(start, anzahl_zeichen) ```], +[Text einfügen], [```cpp str.inset(start, "Hello") ```], +[find], [```cpp size_t pos = str.find("de"); ``` \ ```cpp if (pos == std::string::npos){} ```], +[Strings vergleichen], [```cpp (str1 == str2) ```], +) +=== container +container sind arrays welche daten enthalten und nicht selbst mit array handeling (malloc, speicher freigeben) zu tun haben. +==== std::vector +Beim vector wird im hintergrund ein Speicherbereich reserviert. Falls der user etwas ergenzen möchte wird noch etwas mehr reserviert als benötigt wird. Sollte viel mehr ergäntz werden, so muss ein neuer Speicherbereich reserviert werden die daten rüber kopiert werden und der alte Speicherbereich wieder freigeben werden. +#table(columns: (1fr, 1fr), +fill: (x, y) => if y == 0 {gray.lighten(40%)}, +[Vorteile], [Nachteile], +[Schnelle zugriffszeit], [Wird der vector um viele elemente erweitert so muss der speicher neu zugewiessen werden.], +[Geringerer Speicher-Overhead pro Element.], [Langsame Einfüge- und Löschvorgänge in der Mitte] +) +#cetz.canvas({ + import cetz.draw: * + rect((0, 0), (8, 1), fill: rgb(0, 0, 255, 60)) + grid((0, 0), (8, 1), step: 1) + content((0.5, 0.5), [1]) + content((1.5, 0.5), [2]) + content((2.5, 0.5), [3]) + content((3.5, 0.5), [4]) + content((4.5, 0.5), [5]) +}) +Zum verwenden eines Vectors: ```cpp #include ``` \ +Vektoren können verschieden Datentypen haben. +#table(columns: (0.6fr, 1fr), +[Vektor initialisieren], [```cpp std::vector states; ``` \ ```cpp std::vector numbers{1, 2, 3}; ``` \ ```cpp std::vector strings; ``` \ ```cpp std::vector players; ```], +[Auf ein Element zugreifen], [```cpp v[0]; ```], +[Grösse von vom vector], [```cpp v.size(); ```], +[Erstes Zeichen ausgeben], [```cpp v.font(); ```], +[Letztes Zeichen ausgeben], [```cpp v.back(); ```], +[Element am Ende anhängen], [```cpp v.push_back(number); ```], +[Element am Anfang einfügen], [```cpp v.inset(v.begin(), number); ```], +[Element en stelle X einfügen], [```cpp v.inset(pos, number); ```], +[Zwei Vektoren Zusammenhang], [```cpp v1.inset(v1.end(), v2.begin(), v2.end()); ```], +[Element löschen], [```cpp v.erase(pos); ```], +[Bereich löschen], [```cpp v.erase(start, stop); ```], +[Bereich extrahieren \ v1 ist der ursprüngliche vektor. v2 ist der auschnit von v1. im Beispiel rechts ist: \ v2 = {2, 3, 4}], [```cpp +std::vector v1{ 1, 2, 3, 4, 5 }; +std::vector::iterator first = v1.begin() + 1; +std::vector::iterator last = v1.begin() + 4; +std::vector v2(first, last); +```], +[Conteiner ineinander packen \ (Nesting) \ können normal wie 2D array's behandelt werden: v[i][j]], [```cpp +std::vector> v{{ 0, 1 }, + { -1, 0, 2 }}; ```], +) +==== std::list +Listen sind verkettete Daten. Listen sollten verwendet werden wenn häufig elemente in der mitte hinzugefügt oder enternt werden. +#table(columns: (1fr, 1fr), +fill: (x, y) => if y == 0 {gray.lighten(40%)}, +[Vorteile], [Nachteile], +[Schnelles Einfügen und Löschen an jeder Position], [Kein schneller Direktzugriff], +[], [Hoher Speicher-Overhead durch die Zeiger], +[], [Schlechte Cache-Performance aufgrund des nicht-kontinuierlichen Speichers.] +) +#cetz.canvas({ + import cetz.draw: * + content((-2, 1.5), [node\*]) + line((-1.5, 1.5), (0, 1.5), mark: (end: ">"), fill: blue, stroke: blue) + for i in range(0, 4){ + rect((i * 3, 0), (i * 3 + 1, 2), fill: rgb(0, 0, 255, 60)) + line((i * 3, 1), (i * 3 + 1, 1)) + } + for i in range(0, 3){ + line((i * 3 + 1, 0.5), (i * 3 + 3, 1.5), mark: (end: ">"), fill: blue, stroke: blue) + } + content((0.5, 1.5), [1]) + content((0.5, 0.5), [0x80]) + content((3.5, 1.5), [3]) + content((3.5, 0.5), [0x84]) + content((6.5, 1.5), [5]) + content((6.5, 0.5), [0x66]) + content((9.5, 1.5), [13]) + content((9.5, 0.5), [0x49]) +}) + +==== std::array +==== std::map + +=== testing +```cpp +#include + +assert(funktion_1 == "hello"); +assert("hell" == "hello"); +``` #pagebreak()