Merge branch 'main' of gitea.mintcalc.com:alexander/TUM-Formelsammlungen

src/cheatsheets/Analysis1.typ

@@ -1,5 +1,6 @@
 #import "@preview/mannot:0.3.1"
 
+#import "../lib/ableitungs_tabelle.typ" : *
 #import "../lib/common_rewrite.typ" : *
 #import "../lib/mathExpressions.typ" : *
 
@@ -75,30 +76,19 @@
         *Binomische Formel*\
         $(a + b)^n = sum^(n)_(k=0) binom(n,k) a^(n-k) b^k $ \
       ],
-      [
-        *Bekannte Werte* \
-          $e approx  2.71828$ ($2 < e < 3$) \
-          $pi approx 3.14159$ ($3 < pi < 4$)
-      ],
+
       [
         *Gaußklammer*: \
           $floor(x) = text("floor")(x)$ \
           $ceil(x) = text("ceil")(x)$ \
       ],
       [
-        *Fakultäten* $0! = 1! = 1$ \
       ],
-      [
-        *Mitternachtsformel*
-        $x_(1,2) =  (-b plus.minus sqrt(b^2 + 4a c))/(2a)$
-      ],
-      [
-        *Binomische Formel*\
-        $(a + b)^2 = a^2 + 2a b + b^2$\
-        $(a - b)^2 = a^2 - 2a b + b^2$\
-        $(a + b)(a - b) = a^2 - b^2$\
-      ]
     )
+
+    $bold("Fakultäten") 0! = 1! = 1\
+    e approx  2.71828 quad quad quad pi approx 3.14159
+    $
   ]
 
   // Complex Zahlen
@@ -143,22 +133,17 @@
       gutter: 2mm,
       columns: (auto, auto, auto),
       $cos^2(x) = (1 + cos(2x))/2$,
-      $sin^2(x) = (1 - cos(2x))/2$,
-      $cos(-x) = cos(x)$,
-      $sin(-x) = -sin(x)$,
-      grid.cell(colspan: 2, $cos^2(x) + sin^2(x) = 1$)
+      $sin^2(x) = (1 - cos(2x))/2$
     )
 
-    Subsitution mit Hilfsvariable
+    $tan(x)=sin(x)/cos(x) = -cot(x + pi/2)$
+
+    $cot(x)=cos(x)/sin(x)=-tan(x + pi/2)$
 
     #grid(
       gutter: 5mm,
       row-gutter: 3mm,
       columns: (auto, auto),
-      [$tan(x)=sin(x)/cos(x)$],
-      [$cot(x)=cos(x)/sin(x)$],
-      [$tan(x)=-cot(x + pi/2)$],
-      [$cot(x)=-tan(x + pi/2)$],
       [$cos(x - pi/2) = sin(x)$],
       [$sin(x + pi/2) = cos(x)$],    
     
@@ -178,26 +163,17 @@
     - Beweiße: durch Induktion
     - Beweiße: Hat min. ein konvergent Teilefolge
     - (Beweiße: Ungleichung $abs(a_n) <= k$)
-
-    *Monoton fallend/steigended*
+  
+    *Monoton fallend/steigended $a_(n+1) lt.eq.gt a_(n)$*
     - Beweise: Induktion
-    #grid(columns: (1fr, 1fr),
-      inset: 0.2mm,
-      align(top+center, [*Fallend*]), align(top+center, [*Steigend*]),
-      [$ a_(n+1) <= a_(n), quad a_(n+1) >= a_(n) $],
-      [$ a_(n+1)/a_(n) < 1, quad a_(n+1)/a_(n) > 1 $],
-    )
 
     *Konvergentz Allgemein*
     $lim_(n -> infinity) a_n = a$
 
     $forall epsilon > 0 space exists n_epsilon in NN$ sodass \
     - Konvergent $-> a$: $a_n in [a - epsilon, a + epsilon] $
-    - Divergent $-> infinity$: $a_n in [epsilon, infinity) $
-    - Divergent $-> infinity$: $a_n in (-infinity, epsilon) $
-
-    $space forall n > n_epsilon$
-
+    - unbeschränkt $=>$ Divergent
+  
     *Konvergentz Häufungspunkte*
     - $a_n -> a <=>$ Alle Teilfolgen $-> a$
 
@@ -376,13 +352,13 @@
     
     *Reihendarstellungen*
     #grid(
-      columns: (1fr, 1fr),
+      columns: (1fr),
       gutter: 3mm,
       row-gutter: 3mm,
-      $e^x = limits(sum)_(n=0)^infinity (x^n)/(n!)$,
-      $ln(x) = limits(sum)_(n=0)^infinity (-1)^n x^(n+1)$,
-      $sin(x) = limits(sum)_(n=0)^infinity (-1)^n (z^(2n+1))/((2n + 1)!)$,
-      $cos(x) = limits(sum)_(n=0)^infinity (-1)^n (z^(2n))/((2n)!)$
+      $e^x = limits(sum)_(n=0)^m (x^n)/(n!) + O(x^(m+1))$,
+      $ln(x) = limits(sum)_(n=0)^m (-1)^n x^(n+1) + O(x^(m+1))$,
+      $sin(x) = limits(sum)_(n=0)^m (-1)^n (z^(2n+1))/((2n + 1)!) + O(x^(2m + 3))$,
+      $cos(x) = limits(sum)_(n=0)^m (-1)^n (z^(2n))/((2n)!) + O(x^(2m + 2))$
     )
   ]
 
@@ -396,7 +372,7 @@
     $f(x) = f(y) <=> x = y quad$
     
     *Surjectiv (Epimorhismis):* Output space coverered \
-    - $forall x in B : exists x in A : f(x) = y$
+    - $forall y in B : exists x in A : f(x) = y$
 
     *Bijektiv*
 
@@ -445,7 +421,7 @@
     *Allgemein*
     
     $f(x)$ ist stetig wenn: \
-    $ limits(lim)_(x->x_0-) f(x) = limits(lim)_(x->x_0+) f(x) = f(x_0) $ \
+    $limits(lim)_(x->x_0-) f(x) = limits(lim)_(x->x_0+) f(x) = f(x_0)$ \
     $x in DD$ Beachten! Definitionslücken $!=$ unstätig \
     Definition gilt auch für $I subset RR$
 
@@ -486,10 +462,9 @@
     #subHeading(fill: colorAbleitung)[Ableitung]
     *Differenzierbarkeit*
     - $f(x)$ ist an der Stelle $x_0 in DD$ diffbar wenn \
-      #MathAlignLeft($ f'(x_0) = lim_(x->x_0 plus.minus) (f(x_0 + h - f(x_0))/h) $)
+      $f'(x_0) = lim_(x->x_0^plus.minus) (f(x_0 + h) - f(x_0))/h$
     - Tangente an $x_0$: $f(x_0) + f'(x_0)(x - x_0)$
       - Beste #underline([linear]) Annäherung
-      - Tangente $t(x)$ von $f(x)$ an der Stelle $x_0$: $ lim_(x->0) (f(x) - f(x_0))/(x-x_0) -f'(x_0) =0 $
 
     *Ableitung Regeln*
 
@@ -519,47 +494,7 @@
   // Ableitungstabelle
   #block([
     #set text(size: 7pt)
-    #table(
-      align: horizon, 
-      columns: (auto, auto, auto),
-      table.header([*$F(x)$*], [*$f(x)$*], [*$f'(x)$*]),
-      row-gutter: 1mm,
-      inset: 1.4mm,
-      fill: (x, y) => if calc.rem(x, 3) == 0 { color.hsl(180deg, 89.47%, 88.82%) }
-        else if calc.rem(x, 3) == 1 { color.hsl(180deg, 100%, 93.14%) } else 
-          { color.hsl(180deg, 81.82%, 95.69%) },
-      [$1/(q + x) x^(q+1)$], [$x^q$], [$q x^(q-1)$],
-      [$ln abs(x)$], [$1/x$], [$-1/x^2$],
-      [$x ln(a x) - x$], [$ln(a x)$], [$a / x$],
-      [$2/3 sqrt(a x^3)$], [$sqrt(a x)$], [$a/(2 sqrt(a x))$],
-      [$e^x$], [$e^x$], [$e^x$],
-      [$a^x/ln(a)$], [$a^x$], [$a^x ln(a)$],
-      $-cos(x)$, $sin(x)$, $cos(x)$,
-      $sin(x)$, $cos(x)$, $-sin(x)$,
-      $-ln abs(cos(x))$, $tan(x)$, $1/(cos(x)^2)$,
-      $ln abs(sin(x))$, $cot(x)$, $-1/(sin(x)^2)$,
-
-      [$x arcsin(x) + sqrt(1 - x^2)$],
-      [$arcsin(x)$], [$1/sqrt(1 - x^2)$],
-
-      [$x arccos(x) - sqrt(1 - x^2)$],
-      [$arccos(x)$], [$-1/sqrt(1 - x^2)$],
-
-      [$x arctan(x) - 1/2 ln abs(1 + x^2)$],
-      [$arctan(x)$], [$1/(1 + x^2)$],
-
-      [$x op("arccot")(x) + 1/2 ln abs(1 + x^2)$],
-      [$op("arccot")(x)$], [$-1/(1 + x^2)$],
-
-      [$x op("arsinH")(x) + sqrt(1 + x^2)$],
-      [$op("arsinH")(x)$], [$1/sqrt(1 + x^2)$],
-
-      [$x op("arcosH")(x) + sqrt(1 + x^2)$],
-      [$op("arcosH")(x)$], [$1/sqrt(x^2-1)$],
-
-      [$x op("artanH")(x) + 1/2 ln(1 - x^2)$],
-      [$op("artanH")(x)$], [$1/(1 - x^2)$],
-    )
+    #ableitungsTabelle
   ])
 
   // Extremstellen, Krümmung, Monotonie
@@ -634,7 +569,7 @@
   #bgBlock(fill: colorIntegral, [
     #subHeading(fill: colorIntegral, [Integral])
 
-    Wenn $f(x)$ stetig und monoton $=>$ integrierbar
+    Wenn $f(x)$ stetig oder monoton $=>$ integrierbar
 
     Summen: $integral f(x) + g(x) d x = integral f(x) d x + integral g(x)$
 
@@ -652,12 +587,32 @@
 
     *Subsitution*
 
-    $integral_(x_0)^(x_1) f\(underbrace(g(x), "t")\) dot g'(x) d x$
+    $integral_(x_0)^(x_1) f\(underbrace(g(x), "t")\) d x = integral_g(x_0)^g(x_1) f(t) dot <1/(g'(x)) d t$
     
+
+
     1. Ersetzung: $t := g(x)$
     2. Umformen:
-      $(d y)/(d x) = g'(x)$
-    3. $x$-kürzen sich weg
+      $(d t)/(d x) = g'(x)$
+
+    *Weierstrass Subsitution/Brechstange* \
+    Subsitution: $t = tan(x/2)$
+
+    #grid(
+      columns: (1fr, 1fr),
+      row-gutter: 2.8mm,
+      $d x = 2/(1+t^2) d t$,
+      $sin(x) = 2t / (1 + t^2)$,
+      $tan(x) = (2t)/(1-t^2)$,
+      $cos(x) = (1-t^2) / (1 + t^2)$,
+    )
+
+    *Tricks aus der Schule*
+
+    $integral f(a x+b) d x = 1/a F(a x + b) +c \
+    integral (f'(x))/f(x) d x = ln abs(f(x)) \
+    integral f'(x) e^(f(x)) d x = e^(f(x)) +c \
+    $
   ])
 
   #bgBlock(fill: colorIntegral, [
@@ -692,11 +647,10 @@
 
     *Subsitution*
 
-    $integral_(x_0)^(x_1) f\(underbrace(g(x), "t")\) dot 1/(g'(x)) d x$
+    $integral_(x_0)^(x_1) f\(underbrace(g(x), "t")\) dot 1/(g'(x)) d t$
     
-    1. Ersetzung: $ d x := d t dot g'(x)$ und $t := g(x)$
+    1. Ersetzung: $ d x := 1/g'(x) dot d t$ und $t := g(x)$
     2. Grenzen: $t_0 = g(x_0)$, $t_1 = g(x_1)$
-    3. $x$-kürzen sich weg
 
     *Absolute "Konvergenz"* \
     Wenn $g(x)$ konvergent, 
@@ -719,22 +673,27 @@
     5. $A,B,...$ :
       Nst einsetzen, dann Koeffizientenvergleich
     6. *Intergral wiederzusammen setzen $+c$*
-    7. Summen teile Integrieren
+    7. *Summen teile Integrieren*
 
-    $delta = 4a - b^2$
-    #grid(columns: (auto, auto),
-      row-gutter: 2mm,
+    $integral 1/(x-a) d x = ln(x - a) + c\
+    integral 1/(x-a)^n d x = - 1/(n-1) 1/(x - a)^(n-1) + c quad "für" n >= 2 \
+    integral 1/((x - a)^2 + b^2) d x = 1/b arctan((x - a)/b) + c quad "für" n > 0\
+    integral (x - a)/((x-a)^a + b^2) d x  = 1/2 ln((x-a)^2 + b^2) + c \    
+    $
+
+    #grid(
+      columns: (1fr),
       column-gutter: 2mm,
-      $integral 1/(x - x_0)$, $ln abs(x - x_0)$,
-      $integral 1/((x - x_0)^n)$, $-1/((n-1)(x-x_0)^(n-1))$,
-      $integral 1/(x^2 + b x + c)$, $2/sqrt(delta) arctan((2x + b)/sqrt(delta))$,
-      $integral 1/((x^2 + b x + c)^n)$, $(2x + b)/((n-1)(sigma)(x^2+b x +c)^(n-1)) + \
-        (2(2n-3))/((n-1)(delta)) + (C )
-      $,
+      row-gutter: 4mm,
+      $integral 1/x d x = ln abs(x) +c$,
+      $integral 1/x^2 d x = - 1/x + c$,
+      $integral 1/(a + x) d x = ln abs(a + x) + c$,
+      $integral 1/(a + x)^2 d x = - 1/(a + x) + c$,
+      $integral 1/(a - x) d x = - ln abs(a - x) + c$,
+      $integral 1/(a - x)^2 d x = 1/(a - x) + c$
     )
 
 
-
   ])
 
   #bgBlock(fill: colorAllgemein, [
@@ -742,6 +701,8 @@
     #sinTable
   ])
 
+  /*
+  // Notwending und Hinreichend
   #bgBlock(fill: colorAllgemein, [
     #subHeading(fill: colorAllgemein)[Notwending und Hinreiched]
 
@@ -757,4 +718,62 @@
       $not "hin." arrow.r.double.not "Satz"$,
     )
   ])
+  */
+
+  // Taylor Reihen
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Taylorreihe]
+
+    $T_m (x_0;x) = sum^m_(k=0) (f^((k))(x_0))/(k!) (x-x_0)^k$
+
+    $f(x) = T_m (x_0;x) + R_(m+1)(x_0;x)$
+
+    *Restglied* \
+    $I = (a,b) quad x_0,x in I$
+    
+    $R_(m+1) (x) = 1/(m!) integral_(x_0)^x (x-t)^m f^((m+1))(t) d t$ \
+
+    $forall x in I space space exists xi_x in I "sodass" \
+    R_(m+1)(x_0;x) = (f^((m+1))(xi_x))/((m + 1)!) (x - x_0)^(m+1)\ 
+    = f(x_0 + h) - T_m (x_0; x_0 + h) = o(h^m) = O(h^(m+1))$
+  ]
+
+  // Lamdauer Notation
+  #bgBlock(fill: colorFolgen, [
+    #subHeading(fill: colorFolgen)[Landau Notation]
+
+    $f(x) = o(g(x)) "wenn" lim_(x->a) f(x)/g(x) = 0 \
+      f(x) = O(g(x)) "wenn" abs(f(x)) <= abs(g(g))$
+
+    *Rechen Regelen* \
+    - $f = o(g) => f = O(g)$
+    - $f_1 + f_2 = O\/o(f_1) + O\/o(f_2)$
+    - $f_1 dot f_2 = O\/o(f_1 dot f_2)$
+
+
+  ])
+
+  // Kurven
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Kurven]
+
+    Länge einer Kurve $k(t)$: $L(k) = integral_a^b norm(k'(t)) d t$
+
+    Umparametrisierung: $h(tau)$ *streng monoton steigended* \
+    $h(tau): [a,b] -> [overline(a), overline(b)]$
+
+    $overline(k): [overline(a), overline(b)] -> R^n, quad overline(k) = k(h(tau))$
+
+    Parametriesierung nach Länge: \
+    $s(t) = integral_a^t norm(k'(tau)) d tau quad overline(k)(tau) = k(s^(-1)(tau))$
+
+    Wenn $k$ nach Länge param.: $T(t) =k'(t)$
+
+    Tangentenvektor: $T(t) = (k'(t))/norm(k'(t))$ \
+    Krümmung: $kappa(t) = 1/(s'(t)) norm(T'(t))$
+
+
+    $RR^2: kappa(t) = abs(x'(t)y''(t) - y'(t)x''(t))/((x'(t)^2 + y'(r)^2)^(3/2))$ \
+    Param Länge: $kappa(t) = abs(x'(t)y''(t) - y'(t)x''(t))$
+  ]
 ]

src/cheatsheets/CT.typ

@@ -1,5 +1,6 @@
 #import "../lib/styles.typ" : *
 #import "../lib/common_rewrite.typ" : *
+#import "../lib/bit_fields.typ" : *
 #import "@preview/cetz:0.4.2"
 
 #set page(
@@ -24,8 +25,8 @@
 #let Allgemein = color.hsl(105.13deg, 92.13%, 75.1%)
 #let colorProgramming = color.hsl(330.19deg, 100%, 68.43%)
 #let colorNumberSystems = color.hsl(202.05deg, 92.13%, 75.1%)
-// #let colorVR = color.hsl(280deg, 92.13%, 75.1%)
-// #let colorAbbildungen = color.hsl(356.92deg, 92.13%, 75.1%)
+#let colorMMIX = color.hsl(280deg, 92.13%, 75.1%)
+#let colorRandomShit = color.hsl(356.92deg, 92.13%, 75.1%)
 // #let colorGruppen = color.hsl(34.87deg, 92.13%, 75.1%)
 
 
@@ -48,7 +49,98 @@
   ]
 
   #bgBlock(fill: colorNumberSystems)[
-    #subHeading(fill: colorNumberSystems)[Einer-Kompilment, Zweier-Kompliment, Float (IEEE 754)]
+    #subHeading(fill: colorNumberSystems)[Fixed Point]
+
+    #table(
+      columns: 17,
+      fill: (x, y) => if calc.rem(x, 2) == 1 { tableFillLow } else { tableFillHigh },
+
+      .. for i in range(0,17) {
+        ([$2^#i$],)
+      },
+      .. for i in range(0,17) {
+        ($#calc.pow(2,i)$,)
+      }
+    )
+
+    #columns(2, [
+      *Vorzeichen und Betrag:*
+
+      #grid(
+        columns: (2fr, 1fr),
+        [
+          $x = (-1)^"sign-bit" dot "Betrag"$
+
+          $0 -> "positiv", 1 -> "negativ"$
+
+          Range: \ $(-2^(n-1) - 1) dot 2^r$ bis $(2^(n-1) - 1) dot 2^r$
+
+          Achtung: $plus.minus 0$
+        ],
+        image("../images/ct/betragUndVorzeich.png", width: 2cm)
+      )
+
+      #line(length: 100%, stroke: (thickness: 0.2mm))
+
+      *Einer-Komplement*
+      
+      #grid(
+        columns: (2fr, 1fr),
+        [
+          $x = (-1)^"sign-bit" dot "Betrag"$
+
+          $0 -> "positiv normaler Betrag"$
+
+          $1 -> "negativ INVERT. Betrag"$
+
+          Range: \ 
+          $(-2^(n-1) - 1) dot 2^r$ bis $(2^(n-1) - 1) dot 2^r$
+
+          Achtung: $plus.minus 0$
+        ],
+        image("../images/ct/einerKomplement.png", width: 2cm)
+      )
+      #colbreak()
+
+      *Zweier-Komplement*
+
+      #grid(
+        columns: (2fr, 1fr),
+        [
+          $x = (-1)^"sign-bit" dot "Betrag"$
+
+          $0 -> "positiv"$
+
+          $1 -> "negativ"$
+
+          Range: \ $(-2^(n-1)) dot 2^r$ bis $(2^(n-1) - 1) dot 2^r$
+
+          Positiv: Normal Binär Kodierung
+
+          Negativ: #raw("Invertiert(Binär) + 1")
+
+        ],
+        image("../images/ct/zweierKomplement.png", width: 2cm)
+      )
+
+      #line(length: 100%, stroke: (thickness: 0.2mm))
+      
+      *Radix / Fixed Point*
+
+      $r = 0$ Normal Falle, nix änder sich
+
+      $r > 0$ : Komma nach Rechts und Nullen auffüllen \
+      Bsp. $r = 3 quad ->$  #raw("xxxxxxx000.")
+
+      $r < 0$ : Komma nach Links verschieben \
+      Bsp: $r = -4 quad ->$ #raw("xxxxx.xxxx")
+
+    ])
+  ]
+
+  #colbreak()
+  #bgBlock(fill: colorNumberSystems)[
+    #subHeading(fill: colorNumberSystems)[Float (IEEE 754)]
 
     *Float (IEEE 754)*
 
@@ -133,11 +225,46 @@
 
       content((cell_size*(total_bits), -0.2), anchor: "south", raw(str(0)), angle: 90deg)
     })
+
+    $x = (-1)^"sign" dot #raw("1.[mantisse]")  dot 2^(("exponent" - k))$
+
+    #grid(
+      columns: (auto, auto),
+      column-gutter: 5mm,
+      row-gutter: 2mm,
+      $"float32"&, k = 127 &= #raw("    111 1111") "(7 x Einser)" \
+       "float64"&, k = 1023 &= #raw("11 1111 1111") "(10 x Einser)"$
+    )
+
+    *Spezial Cases* 
+    #table(
+      columns: (auto, auto),
+      [$0$], [exponent = 0 \ mantisse = 0],
+      [$plus.minus infinity$], [exponent = alle 1 \ mantisse = 0],
+      [NaN], [exponent = alle 1 \ mantisse > 0],
+      [denormalisierte Float], [exponent = 0 \ mantisse > 0],
+      [normalisierter Float], [0 < exponent < 255/2047]
+    )
   ]
 
   #bgBlock(fill: colorProgramming)[
     #subHeading(fill: colorProgramming)[C]
 
+    #table(
+      columns: (auto, auto, auto),
+      fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else { tableFillHigh },
+
+      [*C-Type*], [*min size*], [*typ. size*],
+      raw("char"), raw("1 byte"), raw("1 byte"),
+      raw("short (int)"), raw("2 byte"), raw("2 byte"),
+      raw("int"), raw("2 byte"), raw("4 byte"),
+      raw("long (int)"), raw("4 byte"), raw("8 byte"),
+      raw("long long"), raw("4 byte"), raw("8 byte"),
+      raw("float"), raw("4 byte"), raw("4 byte"),
+      raw("double"), raw("8 byte"), raw("8 byte"),
+
+    )
+
     #table(
       columns: (auto, 1fr),
       fill: white,
@@ -151,4 +278,166 @@
       ]
     )
   ]
+
+  #bgBlock(fill: colorProgramming)[
+    #subHeading(fill: colorProgramming)[#raw("scanf/printf") Format Specifier]
+
+    #columns(2)[
+      *printf* 
+      #table(
+        columns: (auto, auto),
+        fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else { tableFillHigh },
+        raw("%s"), [*String*],
+        raw("%d"), [*Decimal: #raw("int/short/long"))*],
+        raw("%f"), [*Float*],
+        raw("%f"), [*Float*],
+        raw("%lf"), [*Double*],
+        raw("%x"), [* Hexdecimal #raw("int/short/long")*],
+      )
+
+      Allgemeiner Syntax: #raw("%[flags][width][.precision]type")
+
+      Flags:
+      - #raw("0") Prepend With left aligned
+      - #raw("-") Left-aligned
+
+      #table(columns: (auto, auto),
+        fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else {  tableFillHigh },
+        raw("\\n"), [New Line],
+        raw("\\t"), [Tab],
+        raw("\\0"), [Null Terminator],
+        raw("\\\\"), [#raw("\\")],
+        raw("\\\""), [#raw("\"")],
+      )
+
+      #colbreak()
+
+      *scanf*
+      #table(
+        columns: (auto, auto),
+        fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else { tableFillHigh },
+        raw("%[size of String]s"), [*String* \ Size of String (without the #raw("\\0")) \ Terminates with Whitespace],
+        raw("%i"), [*#raw("int")*],
+        raw("%f"), [*#raw("float")*],
+        raw("%lf"), [*#raw("double")*],
+        raw("%x"), [*#raw("int")* als Hexadezimal],
+        raw("%c"), [*#raw("char")* ],
+      )
+
+      #raw("fgets(char * s, int count, stdin)")
+    ]
+  ]
+
+  #bgBlock(fill: colorMMIX)[
+    #subHeading(fill: colorMMIX)[MMIX]
+    - $32$ Speziel Register
+    - $256$ Allzwickregister
+    - $2^64$ Speicher
+
+    Wort: $64$ Bit
+    
+    *Calling Convensions*
+
+    #cetz.canvas({
+      import cetz.draw : *
+
+      let cellHeight = 0.4
+      let cellWidth = 2
+
+      let c(y, c, x: 0, number: "") = {
+        rect((x, cellHeight*y), (x + cellWidth,  cellHeight*(y+1)), fill: white)
+        content((x+ cellWidth/2, cellHeight*(y+0.5)), c)
+        content((x - 0.2, cellHeight*(y+0.5)), number, anchor: "mid-east")
+      }
+
+      c(0, "3.Param", number: raw("0x3FFFFFFFFFFFFFF8"))
+      c(1, "2.Param", number: raw("0x3FFFFFFFFFFFFFF0"))
+      c(2, "1.Param", number: raw("0x3FFFFFFFFFFFFFE8"))
+      c(3, "Sicherung $1", number: raw("0x3FFFFFFFFFFFFFE0"))
+      c(4, "Sicherung $2", number: raw("0x3FFFFFFFFFFFFFD8"))
+
+      c(0, "Rückgabe wert", x: cellWidth)
+    })
+
+    #colbreak()
+
+#text(rgb("#1a00aa"))[
+*1. (Aufrufer) Parameter auf Stack ablegen*\
+#raw("SUB :SP,:SP,n*8
+STO $x0,:SP,0*8
+STO $x1,:SP,1*8
+...
+STO $xn,:SP,n*8")
+
+*2. (Aufrufer) Funktions Aufruf*\
+#raw("GO $0,:Fkt")
+]
+
+#text(rgb("#aa0000"))[
+*3. (Funktion) Sicherung der Register*\
+#raw("SUB :SP,:SP,n*8
+STO $y0,:SP,0*8
+STO $y1,:SP,1*8
+...
+STO $yn,:SP,n*8")
+
+*4. (Funktion) Funktions Code*\
+
+*5. (Funktion) Schreiben des Rückgabewerts*\
+#raw("
+STO $r,:SP,m*8
+")
+
+*6. (Funktion) Wiederherstellung der Register*\
+#raw("LDO $x0,:SP, 0*8 + k
+LDO $x1,:SP, 1*8 + k
+...
+LDO $xn,:SP, n*8 + k
+")
+
+*7. (Funktion) Rücksprung*\
+]
+
+#text(rgb("#1a00aa"))[
+*8. (Aufrufer) Lesen des Rückgabewerts*\
+
+
+]
+]
+
+  #bgBlock(fill: colorRandomShit)[
+    #subHeading(fill: colorRandomShit)[Register Register Magista]
+
+    *Zwei-Address-Maschine:* $quad X <-- X dot.o Y$, Parameter: $(X,Y)$ \
+    *Drei-Address-Maschine:* $quad X <-- Y dot.o Z$, Parameter: $(X,Y,Z)$ \
+    *Ein-Address-Maschine:* $quad "ACC" <-- X$, Parameter: $(X)$
+
+    *Register-Speicher-Architekture:* \
+    Operanden können Register und Addressen sein
+    
+    *Register-Register-Archiektur/Load-Store-Architektur* \
+    Operanden nur Register. Extra Befehle fürs Laden aus Speicher
+
+
+    *CISC*: Complex Instruction Set Architecture
+    - Eine Befehl kann viel $->$ Wenige Befehle
+    - Befehlslänge Variable (meistens)
+    - z.B. x86
+
+    *RISC*: Reduced Instruction Set Architecture
+    - Eine Befehl kann wenig $->$ Viel Befehle
+    - Befehlslänge fix (meistens)
+    - z.B. Arm, RISC, MMIX
+
+    *Universal Rechner*
+    
+    - M1: Ergebnis Qulle
+      - Input a,b,c oder ALU
+    - M2: ALU Operation 
+    - M3,M4: Operanden
+      - R0-R7
+    - D: Ergebnis Register
+      - R0-R7
+    - K: Konstante für Operanden 
+  ]
 ]

src/cheatsheets/LinearAlgebra.typ

@@ -141,7 +141,7 @@
         *Surjectiv (Epimorhismis):* \
         _Output space coverered_ \
         - Zeigen das $f(f^(-1)(x)) = x$ für $x in DD$
-        - $forall x in B: exists x in A : f(x) = y$
+        - $forall y in B: exists x in A : f(x) = y$
         NICHT surjektiv wenn $abs(a) < abs(b)$
 
         *Bijektiv (Isomorphismus):* \

src/lib/ableitungs_tabelle.typ

@@ -0,0 +1,42 @@
+
+#let ableitungsTabelle = table(
+  align: horizon, 
+  columns: (auto, auto, auto),
+  table.header([*$F(x)$*], [*$f(x)$*], [*$f'(x)$*]),
+  row-gutter: 1mm,
+  inset: 1.4mm,
+  fill: (x, y) => if calc.rem(x, 3) == 0 { color.hsl(180deg, 89.47%, 88.82%) }
+    else if calc.rem(x, 3) == 1 { color.hsl(180deg, 100%, 93.14%) } else 
+      { color.hsl(180deg, 81.82%, 95.69%) },
+  [$1/(q + 1) x^(q+1)$], [$x^q$], [$q x^(q-1)$],
+  [$ln abs(x)$], [$1/x$], [$-1/x^2$],
+  [$x ln(a x) - x$], [$ln(a x)$], [$a / x$],
+  [$2/3 sqrt(a x^3)$], [$sqrt(a x)$], [$a/(2 sqrt(a x))$],
+  [$e^x$], [$e^x$], [$e^x$],
+  [$a^x/ln(a)$], [$a^x$], [$a^x ln(a)$],
+  $-cos(x)$, $sin(x)$, $cos(x)$,
+  $sin(x)$, $cos(x)$, $-sin(x)$,
+  $-ln abs(cos(x))$, $tan(x)$, $1/(cos(x)^2)$,
+  $ln abs(sin(x))$, $cot(x)$, $-1/(sin(x)^2)$,
+
+  [$x arcsin(x) + sqrt(1 - x^2)$],
+  [$arcsin(x)$], [$1/sqrt(1 - x^2)$],
+
+  [$x arccos(x) - sqrt(1 - x^2)$],
+  [$arccos(x)$], [$-1/sqrt(1 - x^2)$],
+
+  [$x arctan(x) - 1/2 ln abs(1 + x^2)$],
+  [$arctan(x)$], [$1/(1 + x^2)$],
+
+  [$x op("arccot")(x) + 1/2 ln abs(1 + x^2)$],
+  [$op("arccot")(x)$], [$-1/(1 + x^2)$],
+
+  [$x op("arsinH")(x) + sqrt(1 + x^2)$],
+  [$op("arsinH")(x)$], [$1/sqrt(1 + x^2)$],
+
+  [$x op("arcosH")(x) + sqrt(1 + x^2)$],
+  [$op("arcosH")(x)$], [$1/sqrt(x^2-1)$],
+
+  [$x op("artanH")(x) + 1/2 ln(1 - x^2)$],
+  [$op("artanH")(x)$], [$1/(1 - x^2)$],
+)

src/lib/bit_fields.typ

@@ -0,0 +1,40 @@
+#import "@preview/cetz:0.4.2"
+
+#let bitFieldField(name, color, total) = {
+  (name: name, color: color, total: total)
+}
+
+#let bitFieldGreen = rgb("#8fff57")
+#let bitFieldYellow = rgb("#ffe057")
+#let bitFieldBlue = rgb("#57a5ff")
+#let bitFieldRed = rgb("#ff5757")
+
+#let bitField(fields: (), BitHeight: 0.5, BitWidth: 0.25) = {
+  cetz.canvas({
+    import cetz.draw : *
+    let pos = 0;
+
+    let total = 0;
+
+    for f in fields {
+      total += f.at("total")
+    }
+
+    for f in fields {
+      content(((pos + 0.5)*BitWidth, -0.1), raw(str(total - pos - 1)), angle: 90deg, anchor: "east")
+
+      for i in range(f.at("total")) {
+        rect(((pos + i)*BitWidth, 0), ((pos+i+1)*BitWidth, BitHeight), fill: f.at("color", default: bitFieldBlue))
+        content(((pos+i+0.5)*BitWidth, BitHeight*0.5), raw("0"))
+      }
+
+      content(((pos*BitWidth + f.at("total")*BitWidth*0.5), BitHeight + 0.2), f.at("name"), anchor: f.at("anchor", default: "mid"))
+
+      pos += f.at("total")
+
+      content(((pos - 0.5)*BitWidth, -0.1), raw(str(total - pos)), angle: 90deg, anchor: "east")
+
+    }
+  })
+}
+

src/lib/common_rewrite.typ

@@ -69,9 +69,14 @@
   $z^* = a - #i b = r e^(-#i phi)$
 
   Konjungiert Erweitern:\
-  $(a + b #i)/(c + d #i) = ((a + b #i)(c - d #i))/(c^2 + d² )$
+  #grid(columns: (1fr, 1fr), 
+    $(a + b #i)/(c + d #i) = ((a + b #i)(c - d #i))/(c^2 + d² )$,
+    $1/(a + j b) = (a - j b)/(a^2 + b^2)$
+  )
 
-  $r = abs(z) quad phi = cases(
+  
+
+  $r = abs(z) = sqrt(a + #i b) = sqrt(z z^*) quad phi = cases(
     + arccos(a/r) space : space a >= 0,
     - arccos(a/r) space : space a < 0,
   )$

src/lib/schaltungstheorie/opampTable.typ

@@ -267,5 +267,11 @@
   $u_"out" = - R_0/R_1 u_"in"$,
   $u_"out" = (1 + R_0 / R_1) u_"in"$,
   $$,
-  $u_"in" = -R_L i_"in"$
+  $u_"in" = -R_L i_"in"$,
+  [],
+  [VCVS],
+  [VCVS],
+  [VCVS],
+  [],
+  [CCVS]
 )

src/lib/schaltungstheorie/tumCustomSymbols.typ

@@ -259,7 +259,7 @@
   let custom-style = (
     width: 5 * scale,
     height: 5 * scale,
-    length: 0.5 * scale,
+    length: 0,
   )
 
   let draw(ctx, position, style) = {
@@ -428,3 +428,29 @@
   voltage(from, to, anchor: anchor, distance: if anchor in ("east", "north") { -distance } else { distance }, label)
 }
 
+
+#let labeledNode(s, center, color: rgb("#00000000"), scale_t: 1, ..style) = {
+  
+  (
+    ctx => {
+      // Define a default style
+      let def-style = (n: 5, inner-radius: .5, radius: 1, stroke: auto, fill: auto)
+      
+      // Resolve center to a vector
+      let (ctx, center) = cetz.coordinate.resolve(ctx, center)
+      
+      // Resolve the current style ("star")
+      let style = cetz.styles.resolve(ctx.style, merge: style.named(), base: def-style, root: "star")
+      
+      let paths = (
+        cetz.drawable.ellipse(center.at(0), center.at(1), 0, scale_t*0.15, scale_t*0.15, fill: color, stroke: (paint: black, thickness: scale_t
+        *0.25mm)),
+        cetz.drawable.content((center.at(0),center.at(1)+0.03), 1, 1, none, text(size: 7pt * scale_t, s)),
+      )
+      (
+        ctx: ctx, 
+        drawables: cetz.drawable.apply-transform(ctx.transform, paths)
+      )
+    },
+  )
+}