added complex komonent list

.gitea/workflows/build-script.yaml

@@ -7,16 +7,13 @@ on:
   pull_request:
     branches: [ "**" ]
 
-env:
-  TYPST_SOURCE_DIR: src
-  BUILD_DIR: build
-
 jobs:
   build-typst:
     runs-on: ubuntu-latest
 
     # Run the whole job inside a Docker container that has Typst installed
     steps:
+      - uses: typst-community/setup-typst@v4
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -27,38 +24,38 @@ jobs:
       - name: Debug Ls
         run: ls -la "$PWD" && echo "$PWD && echo ${{ github.workspace }}"
 
-      - name: Build Typst builder image
+      - name: Make build directory
-        uses: docker/build-push-action@v2
+        run: mkdir -p build
-        with:
-          tags: typst-builder-image:latest
-          push: false
 
-      - name: Compile all .typ files
+      - name: Compile Analysis1
-        uses: addnab/docker-run-action@v3
+        continue-on-error: true
-        env:
+        run: typst compile --root src src/cheatsheets/Analysis1.typ "build/sem1-Analysis_1.pdf"
-          TYPST_SOURCE_DIR: ${{ env.TYPST_SOURCE_DIR }}
+
-          BUILD_DIR: ${{ env.BUILD_DIR }}
+      - name: Compile Schaltungstheorie
-        with:
+        continue-on-error: true
-          image: typst-builder-image:latest
+        run: typst compile --root src src/cheatsheets/Schaltungstheorie.typ "build/sem1-Schaltungstheorie.pdf"
-          options: --volumes-from=${{ env.JOB_CONTAINER_NAME }}
+
-          cwd: ${{ github.workspace }}
+      - name: Compile LinAlg
-          run: "cd ${{ github.workspace }} && TYPST_SOURCE_DIR=${{ env.TYPST_SOURCE_DIR }} BUILD_DIR=${{ env.BUILD_DIR }} bash -c ./compile-all.bash"
+        continue-on-error: true
+        run: typst compile --root src src/cheatsheets/LinearAlgebra.typ "build/sem1-Lineare-algebra.pdf"
+
+      - name: Compile Digtaltechnik
+        continue-on-error: true
+        run: typst compile --root src src/cheatsheets/Digitaltechnik.typ "build/sem1-Digitaltechnik.pdf"
+
+      - name: Compile CT
+        continue-on-error: true
+        run: typst compile --root src src/cheatsheets/CT.typ "build/sem1-Computertechnik.pdf"
 
-      - name: Upload PDFs
-        if: always()
-        uses: actions/upload-artifact@v3
-        with:
-          name: typst-pdfs
-          path: ${{ env.BUILD_DIR }}/*.pdf
-          if-no-files-found: warn
 
       - name: Create Gitea Release
-        uses: softprops/action-gh-release@v1
+        continue-on-error: true
+        uses: akkuman/gitea-release-action@v1
         with:
-          tag_name: ${{ steps.tag.outputs.tag }}
+          name: "Formelsammlungen PDFs"
-          name: Typst PDFs ${{ steps.tag.outputs.tag }}
+          tag_name: "latest"
-          body: |
+          files: build/*.pdf
-            Automated release of Typst-generated PDFs.
 
-            Commit: ${{ github.sha }}
+      - name: Trigger 
-          files: ${{ env.BUILD_DIR }}/*.pdf
+        continue-on-error: true
+        run: curl -u trigger:${{ secrets.TRIGGER_PASSWORD }} -X POST https://trigger.typst4ei.de/trigger/all

.gitignore

@@ -5,3 +5,5 @@ __pycache__/
 
 package-lock.json
 package.json
+
+*.pdf

compile-all.bash

@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-SRC_DIR="${TYPST_SOURCE_DIR}"
-OUT_DIR="${BUILD_DIR}"
-
-if [[ ! -d "$SRC_DIR" ]]; then
-    echo "Source directory '$SRC_DIR' does not exist."
-    exit 1
-fi
-
-mkdir -p "$OUT_DIR"
-
-
-# Find all .typ files under $SRC_DIR (excluding hidden dirs)
-mapfile -d '' files < <(printf '%s\0' "$SRC_DIR"/*.typ 2>/dev/null)
-
-if [[ ${#files[@]} -eq 0 ]]; then
-    echo "No .typ files found in '$SRC_DIR'."
-    exit 0
-fi
-
-for f in "${files[@]}"; do
-    # Trim leading ./ if present
-    rel="${f#./}"
-    # Destination path: build/<same-subdirs>/<filename>.pdf
-    dest_pdf="${OUT_DIR}/$(basename "${rel%.typ}").pdf"
-
-    echo "Compiling: $f  ->  $dest_pdf"
-    typst compile "$f" "$dest_pdf"
-done

src/Schaltungstheorie/Schaltungstheorie.typ

@@ -1,208 +0,0 @@
-#import "../lib/common_rewrite.typ" : *
-#import "@preview/mannot:0.3.1"
-#import "@preview/zap:0.5.0"
-
-#show math.equation.where(block: true): it => math.inline(it)
-
-#set page(
-  paper: "a4", 
-  margin: (
-    bottom: 10mm,
-    top: 5mm,
-    left: 5mm,
-    right: 5mm
-  ),
-  flipped:true,
-  footer: context [
-    #grid(
-      align: center,
-      columns: (1fr, 1fr, 1fr),
-      [#align(left, datetime.today().display("[day].[month].[year]"))], 
-      [#align(center, counter(page).display("- 1 -"))], 
-      [#align(right, image("../images/cc0.png", height: 5mm,))]
-    )
-  ],
-)
-
-#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
-#let colorEineTore = color.hsl(202.05deg, 92.13%, 75.1%)
-#let colorZweiTore = color.hsl(235.9deg, 92.13%, 75.1%)
-#let colorAnalyseVerfahren = color.hsl(280deg, 92.13%, 75.1%)
-#let colorComplexAC = color.hsl(356.92deg, 92.13%, 75.1%)
-#let colorMathe = color.hsl(34.87deg, 92.13%, 75.1%)
-
-#place(top+center, scope: "parent", float: true, heading(
-  [Schaltungstheorie]
-))
-
-
-#columns(4, gutter: 2mm)[
-  #bgBlock(fill: colorEineTore)[
-    #subHeading(fill: colorEineTore)[Quelle Wandlung]
-
-    #zap.circuit({
-      import zap: *
-      set-style(scale: (x: 0.75, y:0.75), fill: none)
-      resistor("R1", (-2, 0), (0, 0))
-      vsource("V1", (-2, 0), (-2, -2))
-      wire((-2, -2), (0, -2))
-      node("n1", (0, 0), label: "1")
-      node("n2", (0, -2), label: "2")
-    })
-  ]
-
-  #bgBlock(fill: colorAnalyseVerfahren)[
-    #subHeading(fill: colorAnalyseVerfahren)[Graphen und Matrizen]
-
-    $bold(i_b)$ (oder $bold(i)$): Zweigstrom-Vektor \
-    $bold(u_b)$ (oder $bold(u)$): Zweigspannungs-Vektor \
-    $bold(i_m)$ : Maschenstrom-Vektor \
-      #text(rgb(20%, 20%, 20%))[(Strom in einer viruellen Masche)] \
-    $bold(u_k)$ : Kontenspannungs-Vektor \
-      #text(rgb(20%, 20%, 20%))[(Spannung zwischen Referenzknoten und Knoten k)] \
-
-    #line(length: 100%, stroke: (thickness: 0.2mm))
-
-    Knotenzidenzmatrix $bold(A)$
-
-    $bold(A) : bold(i_k) -> text("Knotenstrombianz") = 0$ \
-    $bold(A^T) : bold(u_b)-> bold(u_k)$
-    $ 
-      bold(A) = quad mannot.mark(mat(
-        a_11, a_12, ..., a_(1m);
-        a_21, a_22, ..., a_(2m);
-        dots.v, dots.v, dots.down, dots.v;
-        a_(n 1), a_(n 2), ..., a_(n m)
-      ), tag: #<1>)
-
-      #mannot.annot(<1>, pos:left, text(rgb("#404296"))[#rotate(-90deg)[$<-$ Knoten]], dx: 5mm)
-      #mannot.annot(<1>, pos:bottom, text(rgb("#404296"))[Zweige $->$], dy: -0.5mm)
-
-      a in {-1, 0, 1}
-    $
-    
-    #line(length: 100%, stroke: (thickness: 0.2mm))
-    
-    Mascheninsidenz Matrix $bold(B)$\
-
-
-    $bold(B) : bold(u_b) -> text("Zweigspannungsbilanz") = 0$ \
-    $bold(B^T) : bold(i_m) -> i_b$
-
-    $ 
-      bold(B) = quad mannot.mark(mat(
-        b_11, b_12, ..., b_(1m);
-        b_21, b_22, ..., b_(2m);
-        dots.v, dots.v, dots.down, dots.v;
-        b_(n 1), b_(n 2), ..., b_(n m)
-      ), tag: #<1>)
-
-      #mannot.annot(<1>, pos:left, text(rgb("#404296"))[#rotate(-90deg)[$<-$ Maschen]], dx: 6mm)
-      #mannot.annot(<1>, pos:bottom, text(rgb("#404296"))[Zweige $->$], dy: -0.5mm)
-
-      b in {-1, 0, 1}
-    $
-
-    #line(length: 100%, stroke: (thickness: 0.2mm))
-
-    *KCL und KVL* \
-
-    KCL in Nullraum: $ bold(A) bold(i_b) = bold(0)$ \
-    KVL in Bildraum: $ bold(A^T) bold(u_k) = bold(u_b)$
-
-    KVL in Nullraum: $bold(B) bold(u_b) = bold(0)$ \
-    KCL in Bildraum: $bold(B^T) bold(i_m) = bold(i_b)$ \
-
-    *Tellegen'sche Satz* \
-    $bold(A B^T) = bold(B^T A) = 0$ \
-    $bold(u_b^T i_b) = 0$
-  ]
-
-  #bgBlock(fill: colorAnalyseVerfahren)[
-    #subHeading(fill: colorAnalyseVerfahren)[Baumkonzept]
-  ]
-
-  #bgBlock(fill: colorAnalyseVerfahren)[
-    #subHeading(fill: colorAnalyseVerfahren)[Machenstrom-/Knotenpotenzial-Analyse]
-  ]
-
-  #bgBlock(fill: colorAnalyseVerfahren)[
-    #subHeading(fill: colorAnalyseVerfahren)[Reduzierte Knotenpotenzial-Analyse]
-  ]
-
-  
-]
-
-#pagebreak()
-#place(bottom+left, scope: "parent", float: true)[
-  #bgBlock(fill: colorZweiTore)[
-    #subHeading(fill: colorZweiTore)[Umrechnung Zweitormatrizen]
-      #show table.cell: it => pad(),
-
-      #table(
-        columns: (auto, 1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
-        align: center,
-        gutter: 0.1mm,
-        [In $->$], $bold(R)$, $bold(G)$, $bold(H)$, $bold(H')$, $bold(A)$, $bold(A')$,
-        
-        $bold(R)$,
-        $mat(r_11, r_12; r_21, r_22)$,
-        $1/det(bold(G)) mat(g_22, -g_12; -g_21, g_11)$,
-        $1/h_22 mat(det(bold(H)), h_12; -h_21, 1)$,
-        $1/h'_11 mat(1, -h'_12; h'_21, det(bold(H')))$,
-        $1/a_21 mat(a_11, det(bold(A)); 1, a_22)$,
-        $1/a'_21 mat(a'_22, 1; det(bold(A')), a'_11)$,
-
-        $bold(G)$,
-        $1/det(bold(R)) mat(r_22, -r_12; -r_21, r_11)$,
-        $mat(g_11, g_12; g_21, g_22)$,
-        $1/h_11 mat(1, -h_12; h_21, det(bold(H)))$,
-        $1/h'_22 mat(det(bold(H')), h'_12; -h'_21, 1)$,
-        $1/a_12 mat(a_22, -det(bold(A)); -1, a_11)$,
-        $1/a'_12 mat(a'_11, -1; -det(bold(A')), a'_22)$,
-
-        $bold(H)$,
-        $1/r_22 mat(det(bold(R)), r_12; -r_21, 1)$,
-        $1/g_11 mat(1, -g_12; g_21, det(bold(G)))$,
-        $mat(h_11, h_12; h_21, h_22)$,
-        $1/det(bold(H')) mat(h'_22, -h'_12; -h'_21, h'_11)$,
-        $1/a_22 mat(a_12, det(bold(A)); -1, a_21)$,
-        $1/a'_11 mat(a'_12, 1; -det(bold(A')), a'_21)$,
-
-        $bold(H')$,
-        $1/r_11 mat(1, -r_12; r_21, det(bold(R)))$,
-        $1/g_22 mat(det(bold(G)), g_12; -g_21, 1)$,
-        $1/det(bold(H)) mat(h_22, -h_12; -h_21, h_11)$,
-        $mat(h'_11, h'_12; h'_21, h'_22)$,
-        $1/a_11 mat(a_21, -det(bold(A)); 1, a_12)$,
-        $1/a'_22 mat(a'_21, -1; det(bold(A')), a'_12)$,
-
-        $bold(A)$,
-        $1/r_21 mat(r_11, det(bold(R)); 1, r_22)$,
-        $1/g_21 mat(-g_22, -1; -det(bold(G)), -g_11)$,
-        $1/h_21 mat(-det(bold(H)), -h_11; -h_22, -1)$,
-        $1/h'_21 mat(1, h'_22; h'_11, det(bold(H')))$,
-        $mat(a_11, a_12; a_21, a_22)$,
-        $1/det(bold(A')) mat(a'_22, a'_12; a'_21, a'_11)$,
-
-        $bold(A')$,
-        $1/r_12 mat(r_22, det(bold(R)); 1, r_11)$,
-        $1/g_12 mat(-g_11, -1; -det(bold(G)), -g_22)$,
-        $1/h_12 mat(1, h_11; h_22, det(bold(H)))$,
-        $1/h'_12 mat(-det(bold(H')), -h'_22; -h'_11, -1)$,
-        $1/det(bold(A)) mat(a_22, a_12; a_21, a_11)$,
-        $mat(a'_11, a'_12; a'_21, a'_22)$,
-      )
-  ]
-]
-
-
-
-
-#place(bottom+left, scope: "parent", float: true)[
-  #bgBlock(fill: colorAllgemein, [
-    #subHeading(fill: colorAllgemein, [Sin-Table])
-    #sinTable
-  ])
-]
-

src/cheatsheets/Analysis1.typ

@@ -1,6 +1,10 @@
-#import "../lib/common_rewrite.typ" : *
 #import "@preview/mannot:0.3.1"
 
+#import "../lib/common_rewrite.typ" : *
+#import "../lib/mathExpressions.typ" : *
+
+#set text(7.5pt)
+
 #set page(
   paper: "a4", 
   margin: (
@@ -37,81 +41,112 @@
 #let colorIntegral = color.hsl(34.87deg, 92.13%, 75.1%)
 
 
-#columns(4, gutter: 2mm)[
+#columns(5, gutter: 2mm)[
+
+  // Allgemeiner Shit
   #bgBlock(fill: colorAllgemein)[
     #subHeading(fill: colorAllgemein)[Allgemeins]
-    #grid(
-      columns: (auto, auto),
-      row-gutter: 2mm,
-      column-gutter: 3mm,
-      [Dreiecksungleichung], [
-        $abs(x + y) <= abs(x) + abs(y)$ \
-        $abs(abs(x) - abs(y)) <=  abs(x - y)$
-      ],
-      [Cauchy-Schwarz-Ungleichung], [
-        $abs(x dot y) <= abs(abs(x) dot abs(y))$
-      ],
-      [Geometrische Summenformel], [
-        #MathAlignLeft($ limits(sum)_(k=1)^(n) k = (n(n+1))/2 $)
-      ],
-      [Bernoulli-Ungleichung ], [
-        $(1 + a)^n x in RR >= 1 + n a$
-      ],
-      [Binomialkoeffizient], [
-        $binom(n, k) = (n!)/(k!(n-k)!)$
-      ],
-      [Binomische Formel], [
-        #MathAlignLeft($ (a + b)^n = sum^(n)_(k=0) binom(n,k) a^(n-k) b^k $)
-      ],
-      [Fakultäten], [$ 0! = 1! = 1 $],
 
-      [Gausklammer], [
+    #grid(
-        $floor(x) = text("floor")(x)$ \
+      columns: (1fr, 1fr),
-        $ceil(x) = text("ceil")(x)$
+      inset: 0mm,
+      gutter: 2mm,
+      [
+        *Dreiecksungleichung* \
+        $abs(x + y) <= abs(x) + abs(y)$ \
+        $abs(abs(x) - abs(y)) <=  abs(x - y)$ \
       ],
-      [Bekannte Werte], [
+      [
-        $e approx  2.71828$ ($2 < e < 3$) \
+        *Cauchy-Schwarz-Ungleichung*\
-        $pi approx 3.14159$ ($3 < pi < 4$)
+        $abs(x dot y) <= abs(abs(x) dot abs(y))$ \
+      ],
+      [
+        *Geometrische Summenformel*\
+        $sum_(k=1)^(n) k = (n(n+1))/2$ \
+      ],
+      [
+        *Bernoulli-Ungleichung* \
+        $(1 + a)^n x in RR >= 1 + n a$ \
+      ],
+      [
+        *Binomialkoeffizient* $binom(n, k) = (n!)/(k!(n-k)!)$
+      ],
+      [
+        *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$\
       ]
     )
   ]
 
+  // Complex Zahlen
   #bgBlock(fill: colorAllgemein)[
     #subHeading(fill: colorAllgemein)[Complexe Zahlen]
-    $z = r dot e^(phi i) = r (cos(phi) + i sin(phi))$
 
-    $z^n = r^n dot e^(phi i dot n) = r^n (cos(n phi) + i sin(n phi))$
+    #ComplexNumbersSection()
 
     #grid(
       columns: (1fr, 1fr),
+      row-gutter: 2mm,
       [$ sin(x) = (e^(i x) - e^(-i x))/(2i) $],
-      [$ cos(x) = (e^(i x) + e^(-i x))/(2) $]
+      [$ cos(x) = (e^(i x) + e^(-i x))/(2) $],
+      grid.cell(
+        colspan: 1,
+        align: center,
+        $ tan(x) = 1/2i ln((1+i x)/(1-i x)) $
+      ),
+      grid.cell(
+        colspan: 1,
+        align: center,
+        $ arctan(x) = 1/2i ln((1+i x)/(1-i x)) $
+      )
+        
     )
     #subHeading(fill: colorAllgemein)[Trigonmetrie]
     *Additionstheorem* \
     $sin(x+y) = cos(x)sin(y) + sin(x)cos(y)$ \
     $cos(x+y) = cos(x)cos(y) - sin(x)sin(y)$ \
-    $tan(x) + tan(y) = (tan(a) + tan(b))/(1 - tan(a) tan(b))$ \
+    $tan(x +y) = (tan(a) + tan(b))/(1 - tan(a) tan(b))$ \
     $arctan(x) + arctan(y) = arctan((x+y)/(1 - x y))$ \
+    $arctan(1/x) + arctan(x) = cases(
+      x > 0 : pi/2,
+      x < 0 : -pi/2
+    )$
 
     *Doppelwinkel Formel* \
     $cos(2x) = cos^2(x) - sin^2(x)$ \
     $sin(2x) = 2sin(x)cos(x)$
 
     #grid(
-      gutter: 5mm,
+      gutter: 2mm,
-      columns: (auto, auto),
+      columns: (auto, auto, auto),
-      [$cos^2(x) = (1 + cos(2x))/2$],
+      $cos^2(x) = (1 + cos(2x))/2$,
-      [$sin^2(x) = (1 - cos(2x))/2$]
+      $sin^2(x) = (1 - cos(2x))/2$,
-    )
+      $cos(-x) = cos(x)$,
-
+      $sin(-x) = -sin(x)$,
-    $cos^2(x) + sin^2(x) = 1$
+      grid.cell(colspan: 2, $cos^2(x) + sin^2(x) = 1$)
-    git config pull.rebase falsegit config pull.rebase false
-    #grid(
-      gutter: 5mm,
-      columns: (auto, auto),
-      [$cos(-x) = cos(x)$],
-      [$sin(-x) = -sin(x)$],
     )
 
     Subsitution mit Hilfsvariable
@@ -126,6 +161,7 @@
       [$cot(x)=-tan(x + pi/2)$],
       [$cos(x - pi/2) = sin(x)$],
       [$sin(x + pi/2) = cos(x)$],    
+    
     )
     $sin(x)cos(y) = 1/2sin(x - y) + 1/2sin(x + y)$
 
@@ -134,9 +170,9 @@
     $arccos(x) = -arcsin(x) + pi/2 in [0, pi]$
   ]
 
+  // Folgen Allgemein
   #bgBlock(fill: colorFolgen)[
     #subHeading(fill: colorFolgen)[Folgen]
-    $ lim_(x -> infinity) a_n $
 
     *Beschränkt:* $exists k in RR$ sodass $abs(a_n) <= k$
     - Beweiße: durch Induktion
@@ -146,17 +182,14 @@
     *Monoton fallend/steigended*
     - Beweise: Induktion
     #grid(columns: (1fr, 1fr),
-      gutter: 1mm,
+      inset: 0.2mm,
-      row-gutter: 2mm,
       align(top+center, [*Fallend*]), align(top+center, [*Steigend*]),
-      [$ a_(n+1) <= a_(n) $],
+      [$ a_(n+1) <= a_(n), quad a_(n+1) >= a_(n) $],
-      [$ a_(n+1) >= a_(n) $],
+      [$ a_(n+1)/a_(n) < 1, quad a_(n+1)/a_(n) > 1 $],
-      [$ a_(n+1)/a_(n) < 1 $],
-      [$ a_(n+1)/a_(n) > 1 $],
     )
 
     *Konvergentz Allgemein*
-    $ lim_(n -> infinity) a_n = a $
+    $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] $
@@ -168,31 +201,59 @@
     *Konvergentz Häufungspunkte*
     - $a_n -> a <=>$ Alle Teilfolgen $-> a$
 
-    *Konvergenz Beweißen*
+    *Folgen in $CC$* (Alle Regeln von $RR$ gelten)\
-    - Monoton UND Beschränkt $=>$ Konvergenz
+    - $z_n in CC : lim z_n <=> lim abs(z_n) = 0$
-      NICHT Umgekehert
+    - Zerlegen in $a + b i$ oder $abs(z) dot e^(i phi)$
-    - (Cauchyfolge \
+  ]
-      $forall epsilon > 0 space exists n_epsilon in NN space$ sodass \
-      $forall m,n >= n_epsilon : abs(a_n - a_m) < epsilon$ \
-      Cauchyfolge $=>$ Konvergenz)
-    - $a_n$ unbeschränkt $=>$ divergenz
 
-    *Konvergent Grenzwert finden*
+  // Folgen Strat
+  #bgBlock(fill: colorFolgen)[
+    #subHeading(fill: colorFolgen)[Folgen Konvergenz Strategien]
     - Von Bekannten Ausdrücken aufbauen
+    - *Monoton UND Beschränkt $=>$ Konvergenz*
     - Fixpunk Gleichung: $a = f(a)$ \
       für rekusive $a_(n+1) = f(a_n)$ (Zu erst machen!)
     - Bernoulli-Ungleichung Folgen der Art $(a_n)^n$: \
       $(1 + a)^n >= 1 + n a$
     - Sandwitchtheorem:\
       $b_n -> x$: $a_n <= b_n <= c_n$, wenn $a_n -> x$ und $c_n -> x$ \
-      $b_n -> -infinity$: $b_n <= c_n$, wenn $c_n -> -infinity$ \
-      $b_n -> +infinity$: $c_n <= b_n $, wenn $a_n -> +infinity$
     - Zwerlegen in Konvergente Teil folgen \
       (Vorallem bei $(-1)^n dot a_n$)
+    - (Cauchyfolge \
+      $forall epsilon > 0 space exists n_epsilon in NN space$ sodass \
+      $forall m,n >= n_epsilon : abs(a_n - a_m) < epsilon$ \
+      Cauchyfolge $=>$ Konvergenz)
+
+
+    *Divergenz*
+    - $a_n$ unbeschränkt $=>$ divergenz
+    - Vergleichskriterium: \
+      $b_n -> -infinity$: $b_n <= c_n$, wenn $c_n -> -infinity$ \
+      $b_n -> +infinity$: $c_n <= b_n $, wenn $a_n -> +infinity$
   ]
 
+  // L'Hospital
   #bgBlock(fill: colorFolgen)[
-    #subHeading(fill: colorFolgen)[Konvergent Folge Regeln]
+    #subHeading(fill: colorFolgen)[L'Hospital]
+    $x in (a,b): limits(lim)_(x->b)f(x)/g(x)$
+
+    (Konvergenz gegen $b$, beliebiges $a$)
+
+    Bendingungen:
+    1. $limits(lim)_(x->b)f(x) = limits(lim)_(x->b)g(x)= 0 "oder" infinity$
+    2. $g'(x) != 0, x in (a,b)$
+    3. $limits(lim)_(x->b) (f'(x))/(g'(x))$ konveriert
+
+    $=> limits(lim)_(x->b) (f'(x))/(g'(x)) = limits(lim)_(x->b) (f(x))/(g(x))$
+
+    Kann auch Reksuive angewendet werden!
+
+    Bei "$infinity dot 0$" mit $f(x)g(x) = f(x)/(1/g(x))$
+  ]
+
+  // Bekannte Folgen
+  #bgBlock(fill: colorFolgen)[
+    #subHeading(fill: colorFolgen)[Bekannte Folgen]
     #grid(
       columns: (auto, auto),
       align: bottom,
@@ -207,20 +268,16 @@
       MathAlignLeft($ lim_(n->infinity) abs(a_n) = abs(a) $),
       MathAlignLeft($ lim_(n->infinity) c dot a_n = c dot lim_(n->infinity) a_n $),
     )
-  ]
     
-  #bgBlock(fill: colorFolgen)[
-    #subHeading(fill: colorFolgen)[Bekannte Folgen]
     #grid(
-      columns: (auto, auto, auto),
+      columns: (auto, auto),
       column-gutter: 4mm,
       row-gutter: 2mm,
       align: bottom,
       MathAlignLeft($ lim_(n->infinity) 1/n = 0 $),
-      [],
-      MathAlignLeft($ lim_(n->infinity) k = k, k in RR $),
-      grid.cell(colspan: 2, MathAlignLeft($ exp(x) =  e^x = lim_(n->infinity) (1 + x/n)^n $)), 
       MathAlignLeft($ lim_(n->infinity) sqrt(n) = + infinity $),
+      MathAlignLeft($ lim_(n->infinity) k = k, k in RR $), 
+      MathAlignLeft($ e^x = lim_(n->infinity) (1 + x/n)^n $),
       grid.cell(colspan: 2, MathAlignLeft($ lim_(n->infinity) q^n = cases(
         0 &abs(q),
         1 &q = 1,
@@ -230,6 +287,7 @@
     )
   ]
 
+  // Teilfolgen
   #bgBlock(fill: colorFolgen)[
     #subHeading(fill: colorFolgen)[Teilfolgen]
     $ a_k subset a_n space (text("z.B") k= 2n + 1) $
@@ -239,6 +297,7 @@
     - Wenn alle $a_k$ gegen #underline([genau eine]) Häufungspunk konverigiert $<=> a_n$ konvergent 
   ]
 
+  // Reihen
   #bgBlock(fill: colorReihen)[
     #subHeading(fill: colorReihen)[Reihen]
     $limits(lim)_(n->infinity) a_n != 0 => limits(sum)_(n=1)^infinity a_n$ konverigiert NICHT \
@@ -246,8 +305,6 @@
     - *Absolute Konvergenz* \
       $limits(sum)_(n=1)^infinity abs(a_n) = a => limits(sum)_(n=1)^infinity a_n$ konvergent 
     
-
-
     - *Partialsummen* \
       ALLE Partialsummen von $limits(sum)_(k=1)^infinity abs(a)$ beschränkt\
       $=>$ _Absolute Konvergent_
@@ -279,24 +336,34 @@
       
       divergent: $rho > 1$, keine Aussage $rho = 1$, konvergent $rho < 1$
 
-    - *Geometrische Reihe* 
+    *Reihen in $CC$*
-      $limits(sum)_(n=0)^infinity q^n$
+    - Alles 
-      - konvergent $abs(q) < 1$, divergent  $abs(q) >= 1$
-      - Grenzwert: (Muss $n=0$) $=1/(1-q)$
-    - *Harmonische Reihe* $limits(sum)_(n=0)^infinity 1/n = +infinity$
-
-    - *Reihendarstellungen*
-      1. $e^x = limits(sum)_(n=0)^infinity (x^n)/(n!)$
-      2. $ln(x) = limits(sum)_(n=0)^infinity (-1)^n x^(n+1)$
-      3. $sin(x) = limits(sum)_(n=0)^infinity $
-      4. $cos(x) = limits(sum)_(n=0)^infinity $
-
   ]
 
+  // Potenzreihen
   #bgBlock(fill: colorReihen)[
     #subHeading(fill: colorReihen)[Potenzreihen]
+    $P(z) = sum_(n=0)^infinity a_n dot (z- z_0)^n quad z,z_0 in CC$
+
+    #grid(
+      columns: (auto, auto),
+      column-gutter: 5mm,
+      row-gutter: 1.5mm,
+    
+      [*Konvergenzradius*], [$|z - z_0| < R : $ absolute Konvergenz],
+      [], [$|z - z_0| = R : $ Keine Aussage],
+      [], [$|z - z_0| > R : $ Divergent]
+    )
+
+    #grid(
+      columns: (1fr, 1fr),
+      $R = lim_(n->infinity) abs(a_n/(a_(n+1))) = 1/(lim_(n->infinity) root(n, abs(a_n)))$,
+      $R = limits(liminf)_(n->infinity) abs(a_n/(a_(n+1))) = 1/(limits(limsup)_(n->infinity) root(n, abs(a_n)))$
+    )
+
   ]
 
+  // Bekannte Reihen
   #bgBlock(fill: colorReihen)[
     #subHeading(fill: colorReihen)[Bekannte Reihen]
     *Geometrische Reihe:* $sum_(n=0)^infinity q^n$
@@ -305,34 +372,74 @@
 
     *Harmonische Reihe:* $sum_(n=0)^infinity 1/n = +infinity$
 
-    *Andere*
+    *Binomische Reihe:* 
-    - $e^x = limits(sum)_(n=0)^infinity (x^n)/(n!)$
+    
-    - $ln(x) = limits(sum)_(n=0)^infinity (-1)^n x^(n+1)$
+    *Reihendarstellungen*
+    #grid(
+      columns: (1fr, 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)!)$
+    )
   ]
 
-  #colbreak()
+  // Ableitung
-
   #bgBlock(fill: colorAbleitung)[
     #subHeading(fill: colorAbleitung)[Funktionen]
-    Sei $f : [a,b] -> RR$, stetig auf $x in [a,b]$
-    - *Zwischenwertsatz* \
-      $=> forall y in [f(a), f(b)] exists text("min. ein") x in [a,b] : f(x) = y$ \
-      _Beweiß für mindest. n Nst_
-    - *Satze von Rolle* \
-      diffbar $x in (a,b)$\
-      $f(a) = f(b) => exists text("min. ein") x_0 in (a,b) : f'(x_0) = 0$
-      _Beweiß für max. n Nst, durchWiederspruchsbweiß mit $f(a)=f(b)=0$ und Wiederholte Ableitung_
 
-    - *Mittelwertsatz*
+    $f(x) = y, f : A -> B$
-      diffbar $x in (a,b)$ \
-      $=> exists x_0 : f'(x_0)=(f(b) - f(a))/(a-b)$
 
-    - *Monotonie* \
+    *Injectiv (Monomorphismus):* one to one\ 
-      $x in I : f'(x) < 0$: Streng monoton steigended \
+    $f(x) = f(y) <=> x = y quad$
-      $x_0,x_1 in I,  x_0 < x_1 => f(x_0) < f(x_1)$ \
+    
-      (Analog bei (streng ) steigned/fallended)
+    *Surjectiv (Epimorhismis):* Output space coverered \
+    - $forall x in B : exists x in A : f(x) = y$
+
+    *Bijektiv*
+
+    injektiv UND Surjectiv $<=>$ Umkehrbar
   ]
 
+  // Funktions Sätze
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Funktionen Sätze]
+    $f(x)$ diff'bar $=> f(x)$ stetig
+
+    $f(x)$ stetig diff'bar $=> f(x)$ diff'bar, stetig UND $f'(x)$ stetig
+
+    #line(length: 100%, stroke: 0.3mm)
+
+    Sei $f : I =[a,b] -> RR$, stetig auf $x in I$
+
+
+    - *Zwischenwertsatz* \
+      $=> forall y in ["min", "max"] space exists text("min. ein") x in [a,b] : f(x) = y$ \
+      _Beweiß für mindest. n Nst_
+
+    - *Mittelwertsatz der Diff'rechnung* \
+      diff'bar $x in (a,b)$ \
+      $=> exists x_0 : f'(x_0)=(f(b) - f(a))/(a-b)$
+
+    - *Mittelwertsatz der Integralrechnung*\
+      $g -> RR "integrierbar," g(x)>= 0 forall x in [a,b]$\
+      $exists xi in [a,b] : integral_a^b  f(x)g(x) d x = f(xi) integral_a^b g(x) d x$
+
+    - *Satze von Rolle* \
+      diffbar $x in (a,b)$\
+      $f(a) = f(b) => exists text("min. ein") x_0 in (a,b) : f'(x_0) = 0$\
+      _Beweiß für max. n Nst, durchWiederspruchsbweiß mit $f(a)=f(b)=0$ und Wiederholte Ableitung_
+
+    - *Hauptsatz der Integralrechung*
+      Sei $f: [a,b] -> RR$ stetig
+
+      $F(x) = integral_a^x f(t) d t, x in [a,b]$\
+      $=> F'(x) = f(x) forall x in [a,b]$
+  ]
+
+  // Stetigkeit
   #bgBlock(fill: colorAbleitung)[
     #subHeading(fill: colorAbleitung)[Stetigkeit]
     *Allgemein*
@@ -374,12 +481,12 @@
     )
   ]
 
+  // Ableitung
   #bgBlock(fill: colorAbleitung)[
     #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)$ diffbar $=>$ $f(x)$ stetig
     - 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 $
@@ -409,22 +516,28 @@
     - Kettenregel: $f(g(x)) : f'(g(x)) dot g'(x)$
   ],
 
+  // Ableitungstabelle
   #block([
-    #set text(size: 10pt)
+    #set text(size: 7pt)
     #table(
       align: horizon, 
-      columns: (1fr, 1fr, 1fr),
+      columns: (auto, auto, auto),
       table.header([*$F(x)$*], [*$f(x)$*], [*$f'(x)$*]),
       row-gutter: 1mm,
-      fill: (x, y) => if x == 0 { color.hsl(180deg, 89.47%, 88.82%) }
+      inset: 1.4mm,
-        else if x == 1 { color.hsl(180deg, 100%, 93.14%) } else 
+      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)$], [$1 / x$],
+      [$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)$],
@@ -435,112 +548,213 @@
       [$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)$],
+      [$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)$],
+      [$x op("arsinH")(x) + sqrt(1 + x^2)$],
       [$op("arsinH")(x)$], [$1/sqrt(1 + x^2)$],
 
-      [$x op("arcosH")(x) + \ 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)$],
+      [$x op("artanH")(x) + 1/2 ln(1 - x^2)$],
       [$op("artanH")(x)$], [$1/(1 - x^2)$],
     )
   ])
 
+  // Extremstellen, Krümmung, Monotonie
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Extremstellen, Krümmung, Monotonie]
 
+    *Monotonie* $forall x_0,x_1 in I, x_0 < x_1 <=> f(x_0) <= f(x_1)$
+
+    Hinreichende: $f'(x) >= 0$ \
+    Konstante Funktion bei $f'(x) = 0$ 
+
+    *Streng Monoton*
+    $forall x_0,x_1 in I, x_0 < x_1 <=> f(x_0) < f(x_1)$ \
+    
+    Notwendig: $f'(x) >= 0$ (Aber nicht hinreichend)
+
+    *Extremstellen Kandiaten*
+    1. $f'(x) = 0$
+    2. Definitionslücken
+    3. Randstellen von $DD$
+
+    #grid(columns: (1fr, 1fr),
+      gutter: 2mm,
+      [
+        *Minima*\
+        $x_0,x in I : f(x_0) < f(x)$ \
+        $f''(x) > 0 $ \
+        $f'(x) : - space 0 space +$ 
+      ],
+      [
+        *Maxima*\
+        $x_0,x in I : f(x_0) > f(x)$ \
+        $f''(x) < 0$ \
+        $f'(x) : + space 0 space -$
+      ],
+      [
+        *Wendepunkt*\
+        $f''(x) = 0$ \
+        $f'(x) : plus.minus space ? space plus.minus$
+      ],
+      [
+        *Stattelpunkt/Terrasenpunkt* \
+        $f'''(x) != 0$
+        $f''(x) = 0$ UND $f'(x) = 0$ \
+        $f'(x) : plus.minus space 0 space plus.minus$ \
+      ],
+      [
+        *Extremstelle* \
+        $f'(x) = 0$
+      ]
+    )
+
+    #grid(columns: (1fr, 1fr),
+      gutter: 2mm,
+      [
+        *konkav* $f''(x) <= 0$ \ rechtsgekrümmt \
+        Sekante liegt unter $f(x)$ \
+        (eingebäult, von $y= -infinity$ aus)
+      ],
+      [
+        *konvex* $f''(x) >= 0$ \ linksgekrümmt \
+        Sekante liegt über $f(x)$ \
+        (ausgebaucht, von $y= -infinity$ aus)
+      ]
+    )
+
+    *Strange Konkav/Konvex* \
+    Notwendig $f''(x) lt.gt 0$
+  ]
+
+  // Integral
   #bgBlock(fill: colorIntegral, [
     #subHeading(fill: colorIntegral, [Integral])
 
+    Wenn $f(x)$ stetig und monoton $=>$ integrierbar
+
     Summen: $integral f(x) + g(x) d x = integral f(x) d x + integral g(x)$
 
     Vorfaktoren: $integral lambda f(x) d x = lambda f(x) d x$
 
+    *Ungleichung:* \
+    $f(x) <= q(x) forall x in [a,b] => integral_a^b f(x) d x <= integral_a^b g(x) d x$ \
+    $abs(integral_a^b f(x) d x) <= integral_a^b abs(f(x)) d x$
+
+    *Partial Integration*
+    
+    $integral u(x) dot v'(x) d x = u(x)v(x) - integral u'(x) dot v(x)$
+
+    $integral_a^b u(x) dot v'(x) d x = [u(x)v(x)]_a^b - integral_a^b u'(x) dot v(x)$
+
+    *Subsitution*
+
+    $integral_(x_0)^(x_1) f\(underbrace(g(x), "t")\) dot g'(x) d x$
+    
+    1. Ersetzung: $t := g(x)$
+    2. Umformen:
+      $(d y)/(d x) = g'(x)$
+    3. $x$-kürzen sich weg
+  ])
+
+  #bgBlock(fill: colorIntegral, [
+    #subHeading(fill: colorIntegral, [Integral])
+
+    *Riemann Integral*\
+    $limits(sum)_(x=a)^(b) f(i)(x_())$
+
+    Summen: $integral f(x) + g(x) d x = integral f(x) d x + integral g(x)$
+
+    Vorfaktoren: $integral lambda f(x) d x = lambda f(x) d x$
+
+    *Integral Type*\
+    - Eigentliches Int.: $integral_a^b f(x) d x$ 
+    - Uneigentliches Int.: \ 
+      $limits(lim)_(epsilon -> 0) integral_a^(b + epsilon) f(x) d x$ \
+      $limits(lim)_(epsilon -> plus.minus infinity) integral_a^(epsilon) f(x) d x$
+    - Unbestimmtes Int.: $integral f(x) d x = F(x) + c, c in RR$- Uneigentliches Int.: 
+    
+    *Cauchy-Hauptwert*
+
+    $integral_(-infinity)^(+infinity) f(x)$ \
+    NUR konvergent wenn: \
+    $limits(lim)_(R -> -infinity) integral_(R)^(a) f(x) d x$ und $limits(lim)_(R -> infinity) integral_(a)^(R) f(x) d x$ konvergent für $a in RR$
+
+    $integral_(-infinity)^(infinity) f(x) d x$ existiert \
+    $=> lim_(M -> infinity) integral_(-M)^(M) f(x) d x = integral_(-infinity)^(infinity) f(x) d x$ 
+
     *Partial Integration*
     
     $integral u(x) dot v'(x) d x = u(x)v(x) - integral u'(x) dot v(x)$
 
     *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")\) dot 1/(g'(x)) d x$
     
-    1. Ersetzung: $ d x := d t dot 1/(g'(x))$ und $t := g(x)$
+    1. Ersetzung: $ d x := d t dot g'(x)$ 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, 
+    $abs(f(x)) <= g(x) => $ $f(x)$ konvergent
   ])
 
+  #bgBlock(fill: colorIntegral, [
+    #subHeading(fill: colorIntegral)[Partial-Bruch-Zerlegung]
+    Form: $integral "Zähler Polynom"/"Nenner Polynom"$,
+    $deg("Nenner") < deg("Zähler")$
+    1. $deg("Zähler") >= deg("Nenner") ->$ *Polynomdivision*
+    2. *Faktorisieren des Nenners (Nst finden)*, \
+      Polynomdivision, Raten, Binomische Formel \
+      Resulat: $N = (x - x_0)^(n_0+)(x - x_1)^(n_1)... (x^2+b x + c)^(m_1)$
+    3. *Ansatz:* $A$\
+      $(x-x_0)^n -> A/((x - x_0)^n) + B/((x - x_0)^(n-1)) ... + C/(x - x_0)$\
+      $(x^2 + b x + c)^n -> (A x + B)/((x^2 + b x + c)^n) ... + (C x + D)/((x^2 + b x + c)^1) $
+
+    4. *Durchmul.* $"Ansatz" dot 1/("Fakt. Nenner") = "Zähler"$
+    5. $A,B,...$ :
+      Nst einsetzen, dann Koeffizientenvergleich
+    6. *Intergral wiederzusammen setzen $+c$*
+    7. Summen teile Integrieren
+
+    $delta = 4a - b^2$
+    #grid(columns: (auto, auto),
+      row-gutter: 2mm,
+      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 )
+      $,
+    )
+
+
+
+  ])
+
+  #bgBlock(fill: colorAllgemein, [
+    #subHeading(fill: colorAllgemein, [Sin-Table])
+    #sinTable
+  ])
+
+  #bgBlock(fill: colorAllgemein, [
+    #subHeading(fill: colorAllgemein)[Notwending und Hinreiched]
+
+    #grid(columns: (1fr, 1fr),
+      gutter: 2mm,
+      inset: (left: 2mm, right: 2mm),
+      $not "not." => not "Satz"$,
+      $"hin." => "Satz"$,
+      $"Satz" => forall "not." $,
+      $not "Satz" => forall not "hin." $,
+
+      $"not." arrow.r.double.not "Satz"$,
+      $not "hin." arrow.r.double.not "Satz"$,
+    )
+  ])
 ]
-
-#bgBlock(fill: colorAllgemein, [
-  #subHeading(fill: colorAllgemein, [Sin-Table])
-  #sinTable
-])
-
-#pagebreak()
-
-== Folgen in $CC$
-
-$z_n in C: lim z_n  <=> lim abs(z_n -> infinity) = 0$
-
-Alle folgen regelen gelten
-
-Complexe Folge kann man in Realteil und Imag zerlegen
-
-z.B.
-
-$z_n = z^n z in CC$
-
-$z = abs(z) dot e^(i phi) = abs(z)^n$
-
-== Reihen in $CC$
-
-Fast alles gilt auch.
-
-Bis auf Leibnitzkriterium weil es keine Monotonie gibt
-
-Geometrische Reihe gilt.
-
-Exponential funktion
-
-#MathAlignLeft($ e^z = lim_(n -> infinity) (1 + z/n)^n = sum_(n=0)^infinity (z^n)/(n!) space z in CC $)
-
-Vorsicht: $(b^a)^n = b^(a dot c)$
-
-Potenzreihen: Eine Fn der form:
-
-#MathAlignLeft($ P(z) = sum^(infinity)_(n=0) a_n dot (z - z_0)^n space z, z_0 in CC $)
-
-=== Satz
-
-Konvergenz Radius $R = [0, infinity)$$$
-
-1. $R = 0$ Konvergiet nur bei $z = 0$
-
-2. $R in R : cases(
-  z in CC &abs(z - z_0) < R &: "abs Konvergent",
-  z in CC &abs(z - z_0) = R &: "keine Ahnung",
-  z in CC &abs(z - z_0) > R &: "Divergent"
-)$
-
-$ R = limsup_(n -> infinity) $
-  #bgBlock(fill: colorIntegral, [
-    #subHeading(fill: colorIntegral, [Integral])
-
-    Summen: $integral f(x) + g(x) d x = integral f(x) d x + integral g(x)$
-
-    Vorfaktoren: $integral lambda f(x) d x = lambda f(x) d x$
-
-    *Partial Integration*
-    
-    $integral u(x) dot v'(x) d x = u(x)v(x) - integral u'(x) dot v(x)$
-
-    *Subsitution*
-
-    $integral_(x_0)^(x_1) f\(underbrace(g(x), "t")\) dot g'(x) d x$
-    
-    1. Ersetzung: $ d x := d t dot 1/(g'(x))$ und $t := g(x)$
-    2. Grenzen: $t_0 = g(x_0)$, $t_1 = g(x_1)$
-    3. $x$-kürzen sich weg
-  ])
-

src/cheatsheets/CT.typ

@@ -0,0 +1,154 @@
+#import "../lib/styles.typ" : *
+#import "../lib/common_rewrite.typ" : *
+#import "@preview/cetz:0.4.2"
+
+#set page(
+  paper: "a4", 
+  margin: (
+    bottom: 10mm,
+    top: 5mm,
+    left: 5mm,
+    right: 5mm
+  ),
+  flipped:true,
+  numbering: "— 1 —",
+  number-align: center
+)
+
+#set text(size: 8pt)
+
+#place(top+center, scope: "parent", float: true, heading(
+  [Computer Technik/Programmierpraktikum EI]
+))
+
+#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 colorGruppen = color.hsl(34.87deg, 92.13%, 75.1%)
+
+
+#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
+#let MathAlignLeft(e) = {
+  align(left, block(e))
+}
+#columns(2, gutter: 2mm)[
+  #bgBlock(fill: colorNumberSystems)[
+    #subHeading(fill: colorNumberSystems)[ASCII Ranges]
+
+    #table(
+      columns: (1fr, 1fr, 1fr),
+      [Range], [Hex], [Bits],
+      [Upper Case], raw("0x41-0x5A"), [#raw("010XXXXX") (bit 6)],
+      [Lower Case], raw("0x61-0x7A"), [#raw("011XXXXX") (bit 6)],
+      [Numbers (0-9)], raw("0x30-0x39"), [#raw("0011XXXX")],
+      [Ganz ASCII], raw("0x00-0x7F"), [#raw("0XXXXXXX")],
+    )
+  ]
+
+  #bgBlock(fill: colorNumberSystems)[
+    #subHeading(fill: colorNumberSystems)[Einer-Kompilment, Zweier-Kompliment, Float (IEEE 754)]
+
+    *Float (IEEE 754)*
+
+    #cetz.canvas({
+      import cetz.draw : *
+      let cell_size = 0.3;
+      
+      let manntise_stop = 22;
+      let exponent_start = 23;
+      let exponent_stop = 30;
+      let sign_bit = 31;
+      let total_bits = sign_bit + 1;
+
+
+      for i in range(total_bits) {
+        let bit = 31 - i;
+
+        rect((i*cell_size, 0), (i*cell_size+cell_size, 0.5),
+          fill: if bit == sign_bit { rgb("#8fff57") } else { 
+            if ( bit >= exponent_start and bit <= exponent_stop) { rgb("#ffe057") } else { if (bit <= manntise_stop) {rgb("#57a5ff")} else { white } }
+          },
+          stroke: (thickness: 0.2mm)
+        )
+  
+        content((i*cell_size + 0.5*cell_size, 0.25), raw(str(0)))
+      }
+
+      content((cell_size, 0.7), [sign], anchor: "east")
+      content((5*cell_size, 0.7), [Exponent (#str(exponent_stop - exponent_start + 1) bit)])
+      content((20*cell_size, 0.7), [Mantisse/Wert (#str(manntise_stop+1) bit)])
+
+      rect((0,0), (32*cell_size, 0.5))
+
+      content((cell_size*(total_bits - sign_bit), -0.2), anchor: "south", raw(str(sign_bit)), angle: 90deg)
+
+      content((cell_size*(total_bits - exponent_stop), -0.2), anchor: "south", raw(str(exponent_stop)), angle: 90deg)
+
+      content((cell_size*(total_bits - exponent_start), -0.2), anchor: "south", raw(str(exponent_start)), angle: 90deg)
+
+      content((cell_size*(total_bits - manntise_stop), -0.2), anchor: "south", raw(str(manntise_stop)), angle: 90deg)
+
+      content((cell_size*(total_bits), -0.2), anchor: "south", raw(str(0)), angle: 90deg)
+    })
+
+    #cetz.canvas({
+      import cetz.draw : *
+      let cell_size = 0.21;
+      
+      let manntise_stop = 51;
+      let exponent_start = 52;
+      let exponent_stop = 62;
+      let sign_bit = 63;
+      let total_bits = sign_bit + 1;
+
+
+      for i in range(total_bits) {
+        let bit = sign_bit - i;
+
+        rect((i*cell_size, 0), (i*cell_size+cell_size, 0.5),
+          fill: if bit == sign_bit { rgb("#8fff57") } else { 
+            if ( bit >= exponent_start and bit <= exponent_stop) { rgb("#ffe057") } else { if (bit <= manntise_stop) {rgb("#57a5ff")} else { white } }
+          },
+          stroke: (thickness: 0.2mm)
+        )
+  
+        content((i*cell_size + 0.5*cell_size, 0.25), raw(str(0)))
+      }
+
+      content((cell_size, 0.7), [sign], anchor: "east")
+      content((7*cell_size, 0.7), [Exponent (#str(exponent_stop - exponent_start + 1) bit)])
+      content((20*cell_size, 0.7), [Mantisse/Wert (#str(manntise_stop+1) bit)])
+
+      rect((0,0), (total_bits*cell_size, 0.5))
+
+      content((cell_size*(total_bits - sign_bit), -0.2), anchor: "south", raw(str(sign_bit)), angle: 90deg)
+
+      content((cell_size*(total_bits - exponent_stop), -0.2), anchor: "south", raw(str(exponent_stop)), angle: 90deg)
+
+      content((cell_size*(total_bits - exponent_start), -0.2), anchor: "south", raw(str(exponent_start)), angle: 90deg)
+
+      content((cell_size*(total_bits - manntise_stop), -0.2), anchor: "south", raw(str(manntise_stop)), angle: 90deg)
+
+      content((cell_size*(total_bits), -0.2), anchor: "south", raw(str(0)), angle: 90deg)
+    })
+  ]
+
+  #bgBlock(fill: colorProgramming)[
+    #subHeading(fill: colorProgramming)[C]
+
+    #table(
+      columns: (auto, 1fr),
+      fill: white,
+      raw("restrict", lang: "c"), [
+        Funktions Argument modifier
+
+        Gibt compiler den hint, das eine Pointer nur in der Funktion verwedent wird. Kann besser optimiert werden
+      ],
+      raw("volatile", lang: "c"), [
+        Zwingt Compiler den Funktion/Variable nicht wegzuoptimieren
+      ]
+    )
+  ]
+]

src/cheatsheets/Digitaltechnik.typ

@@ -0,0 +1,625 @@
+#import "@preview/mannot:0.3.1"
+#import "@preview/cetz:0.4.2"
+#import "@preview/zap:0.5.0"
+
+#import "../lib/common_rewrite.typ" : *
+#import "../lib/truthtable.typ" : *
+#import "../lib/fetModel.typ" : *
+
+#show math.integral: it => math.limits(math.integral)
+#show math.sum: it => math.limits(math.sum)
+
+#set page(
+  paper: "a4", 
+  margin: (
+    bottom: 10mm,
+    top: 5mm,
+    left: 5mm,
+    right: 5mm
+  ),
+  flipped:true,
+  footer: context [
+    #grid(
+      align: center,
+      columns: (1fr, 1fr, 1fr),
+      [#align(left, datetime.today().display("[day].[month].[year]"))], 
+      [#align(center, counter(page).display("- 1 -"))], 
+      [Thanks to Daniel for the circuit Symbols],
+      [#align(right, image("../images/cc0.png", height: 5mm,))]
+    )
+  ],
+)
+
+#let pTypeFill = rgb("#dd5959").lighten(10%);
+#let nTypeFill = rgb("#5997dd").lighten(10%);
+
+#place(top+center, scope: "parent", float: true, heading(
+  [Digitaltechnik]
+))
+
+#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
+#let MathAlignLeft(e) = {
+  align(left, block(e))
+}
+
+#let colorBoolscheLogic = color.hsl(105.13deg, 92.13%, 75.1%)
+#let colorOptimierung = color.hsl(202.05deg, 92.13%, 75.1%)
+#let colorRealsierung = color.hsl(280deg, 92.13%, 75.1%)
+#let colorState = color.hsl(356.92deg, 92.13%, 75.1%)
+//#let colorIntegral = color.hsl(34.87deg, 92.13%, 75.1%)
+
+#let LNot(x) = math.op($overline(#x)$)
+
+#columns(4, gutter: 2mm)[
+  #bgBlock(fill: colorBoolscheLogic)[
+    #subHeading(fill: colorBoolscheLogic)[Allgemein]
+    *Moorsches Gesetz:* 2x der Anzahl der Transistoren pro Fläche (in 2 Jahren)
+
+    Flächenskalierung eines Transistors: $1/sqrt(2)$
+
+    *Kombinatorisch:* Kein Gedächtnis
+
+    *(Synchrone) sequenentielle:* Mit Gedächtnis
+
+    *Fan-In:* Anzahl der Inputs eines Gatters
+
+    *Fan-Out:* Anzahl der Output Verbindungen eines Gatters
+  ]
+
+  #bgBlock(fill: colorBoolscheLogic)[
+    #subHeading(fill: colorBoolscheLogic)[Boolsche Algebra]
+
+    *Dualität*
+    $LNot(0) = 1$, $LNot(1) = 0$
+
+    *Äquivalenz* $LNot((LNot(A)))=A$\
+    $A dot A = A$, $A + 0 = A$ \
+
+    *Konstanz*
+    $A dot 1 = A$ $A + 1 = 1$
+
+    *Komplementärgesetz* \
+    $A dot LNot(A) = 0$, $A + LNot(A) = 1$
+
+    *Kommutativgesetz* \
+    $A dot B = B dot A$, $A + B = B + A$
+
+    *Assoziativgesetz*\
+    $A dot (B dot C) = (A dot B) dot C$\
+    $A + (B + C) = (A + B) + C$
+
+    *Distributivgesetz*\
+    $A dot (B + C) = A dot B + A dot C$ \
+    $A + (B dot C) = (A + B) dot (A + C)$
+
+    *De Morgan*\
+    $LNot((A + B)) = LNot(A) dot LNot(B)$\
+    $LNot((A dot B)) = LNot(A) + LNot(B)$
+
+    *Absorptionsgesetz*\
+    $A + (A dot B) = A$\
+    $A dot (A + B) = A$
+
+    *Resolutionsgesetz (allgemein)*\
+    $X dot A + LNot(X) + B = X dot A + LNot(X) dot B + bold(A dot B)$
+
+    *Resolutionsgesetz (speziell)*\
+    $X dot A + LNot(X) dot A = A$\
+    $(X + A) dot (LNot(X) + A) = A$
+  ]
+
+  #bgBlock(fill: colorBoolscheLogic)[
+    #subHeading(fill: colorBoolscheLogic)[Boolsche Funktionen]
+
+    $f: {0,1}^n -> {0,1}$
+
+    Variablenmenge: ${x_0, x_1, ..., x_n}$\
+    Literalmenge: ${x_0, ..., x_n, LNot(x_0), ... LNot(x_n)}$ \
+    Einsmenge: $F = {underline(v) in {0,1}^n | f(underline(v)) = 1}$
+    Nullmenge: $overline(F) = {underline(v) in {0,1}^n | f(underline(v)) = 0}$
+    Don't-Care-Set: ${underline(v) in {0,1}^n | f(underline(v)) = *}$
+
+    Funktionsbündel: $underline(y)  = underline(f)(underline(x))$ \
+    $underline(f): {0,1}^n -> {0,1}^m$
+
+    *Kofaktoren* aka Bit $n$ fixen\ 
+    $x_i : f_x_i = f(x_1, ..., 1, ..., x_n)$\
+    $overline(x)_i : f_overline(x)_i = f(x_1, ..., 0, ..., x_n)$
+  
+    *Substitutionsregel*
+
+    $x_i dot f = x_i dot f_x_i$
+
+    $overline(x)_i dot f = overline(x)_i dot f_overline(x)_i$
+
+    $x_i + f = x_i + f_overline(x)_i$
+
+    $overline(x)_i + f = overline(x)_i + f_x_i$
+
+    *Boolsche Expansion*\
+    $f(underline(x)) = x_i dot f_x_i + overline(x)_i dot f_overline(x)_i$
+
+    $f(underline(x)) = (x_i + f_overline(x)_i) dot (overline(x)_i + f_x_i)$
+
+    $overline(f(underline(x))) = overline(x)_i dot overline(f_overline(x)_i) + x_i dot overline(f_x_i)$
+
+    $overline(f(underline(x))) = (overline(x)_i + overline(f_x_i)) dot (x_i + overline(f_overline(x)_i)) $
+
+    *Eigentschaften:*
+
+    tautologisch: $f(underline(x)) = 1, forall underline(x) in {0,1}^n$\
+    kontradiktorisch: $f(underline(x)) = 0, forall underline(x) in {0,1}^n$\
+    unabhängig von $x_i <=> f_x_i  = f_overline(x)_i$\
+    abhängig von $x_i <=> f_x_i  != f_overline(x)_i$\
+  ]
+
+  #bgBlock(fill: colorOptimierung)[
+    #subHeading(fill: colorOptimierung)[Hauptsatz der Schaltalgebra]
+    Jede $f(x_0, ...,x_n)$ kann als...
+    - *Minterme $m$:* $ = LNot(x)_0 dot x_1 dot ...$\
+      VerODERungen von VerUNDungen\
+      $f(underline(x)) = m_0 + m_1 + ... + m_n$
+
+    - *Maxterme $M$:* $ = LNot(x)_0 + x_1 ü ...$\
+      VerUNDungen von VerODERungen\
+      $f(underline(x)) = m_0 dot m_1 dot ... dot m_n$
+
+    ... dargestellt werden
+
+    *DNF:* Disjunktive Normalform, *Minterme*
+    - Term $tilde.equiv$ $1$-Zeile
+    - $LNot(x)_0 dot x_1 + x_0 dot x_1 +...$\
+    - $1 tilde.equiv x_0$, $0 tilde.equiv overline(x_0)$
+  
+    *KNF:* Konjunktive Normalform, *Maxterme*
+    - Term $tilde.equiv$ $0$-Zeile
+    - $(LNot(x)_0 + LNot(x)_1) dot (x_0 + x_1) dot...$\
+    - $1 tilde.equiv overline(x_0)$, $0 tilde.equiv x_0$
+  
+    Kanonische: In jedem Term müssen alle enthalten sein.
+
+    *KDNF:* Kanonische DNF\
+    *KKNF:* Kanonische KNF
+
+    *DMF:* Disjunktive #underline("Minimal")-Form: \ 
+    $ --> LNot(x_0)x_1 + LNot(x_1)$\
+
+    *KMF:* Konjunktive #underline("Minimal")-Form: \
+    $ --> (LNot(x_0) + x_1) dot LNot(x_1)$
+
+    $f(underline(x)) -->$ *KKNF* / *KDNF* mit Boolsche Expansion
+
+  ]
+
+  // Dotierung
+  #bgBlock(fill: colorRealsierung)[
+    #table(
+      columns: (auto, 1fr),
+      [N-Type],
+      [
+        - Dotierung: Phosphor (V)
+        - Negative Ladgunsträger ($e^-$)
+        - mehr Elektron als Si
+      ],
+      [P-Type],
+      [
+        - Dotierung:  Bor (III)
+        - Postive Landsträger (Löcher)
+        - mehr Löcher als Si
+      ]
+    )
+
+
+    #zap.circuit({
+      import cetz.draw : *
+      import zap : *
+
+      diode("A", (0,1.7), (3,1.7), fill: black, i: (content: $i_d$, anchor: "south"))
+
+
+      rect((0,0),(1,1), fill: pTypeFill, stroke: none)
+      rect((2,0),(3,1), fill: nTypeFill, stroke: none)
+      rect((1,0), (1.5,1), fill: color.lighten(pTypeFill, 50%), stroke: none)
+      rect((1.5,0), (2,1), fill: color.lighten(nTypeFill, 50%), stroke: none)
+      line((2, 0), (2, 1), stroke: (dash: "dotted"))
+      line((1, 0), (1, 1), stroke: (dash: "dotted"))
+      line((1.5, 0), (1.5, 1), stroke: (dash: "densely-dotted"))
+
+      cetz.decorations.brace((2,-0.1),(1,-0.1))
+      content((1.5, -0.6), "RLZ")
+      content((2.5, 0.5), "N")
+      content((0.5, 0.5), "P")
+      content((1.25, 0.5), "-")
+      content((1.75, 0.5), "+")
+    })
+
+    #grid(
+      columns: (1fr, 1fr),
+      column-gutter: 6mm,
+      align: center,
+      [#align(center)[*NMOS*]], [#align(center)[*PMOS*]],
+      grid.cell(inset: 2mm,
+        align(center, 
+          zap.circuit({
+            import "../lib/circuit.typ" : *
+
+            registerAllCustom();
+            fet("T", (0,0), type: "N", scale: 150%);
+          })
+        )
+      ),
+      grid.cell(inset: 2mm,
+        align(center, 
+          zap.circuit({
+            import "../lib/circuit.typ" : *
+
+            registerAllCustom();
+            fet("T", (0,0), type: "P", scale: 150%);
+          }),
+        )
+      ),
+      scale(
+        x: 75%, y: 75%,
+        zap.circuit({
+          import cetz.draw : *
+          import zap : *
+          rect((1.5,0),(4-1.5, 0.1), fill: rgb("#535353"), stroke: none)
+          rect((0,0),(4,-1), fill: pTypeFill, stroke: none)
+          rect((0.5,-0),(1.5, -0.5), fill: nTypeFill, stroke: none)
+          rect((4 - 1.5,-0),(4-0.5, -0.5), fill: nTypeFill, stroke: none)
+          rect((1.5,-0),(2.5, -0.5), fill: none, stroke: (paint: black, dash: "dotted", thickness: 0.06))
+
+          line((3, 0.3), (3, 0))
+          line((1, 0.3), (1, 0))
+          line((2, 0.3), (2, 0.1))
+
+          cetz.decorations.brace((2.5,-0.6),(1.5,-0.6))
+          content((2, -1.3), "Channel")
+          content((3, -0.25), $"n"^+$)
+          content((1, -0.25), $"n"^+$)
+          content((0.5, -0.75), "p")
+
+          content((3, 0.5), "S")
+          content((1, 0.5), "D")
+          content((2, 0.5), "G")
+        })
+      ),
+      scale(
+        x: 75%, y: 75%,
+        zap.circuit({
+          import cetz.draw : *
+          import zap : *
+          rect((1.5,0),(4-1.5, 0.1), fill: rgb("#535353"), stroke: none)
+          rect((0,0),(4,-1), fill: nTypeFill, stroke: none)
+          rect((0.5,-0),(1.5, -0.5), fill: pTypeFill, stroke: none)
+          rect((4 - 1.5,-0),(4-0.5, -0.5), fill: pTypeFill, stroke: none)
+          rect((1.5,-0),(2.5, -0.5), fill: none, stroke: (paint: black, dash: "dotted", thickness: 0.06))
+
+          line((3, 0.3), (3, 0))
+          line((1, 0.3), (1, 0))
+          line((2, 0.3), (2, 0.1))
+
+          cetz.decorations.brace((2.5,-0.6),(1.5,-0.6))
+          content((2, -1.3), "Channel")
+          content((3, -0.25), $"p"^+$)
+          content((1, -0.25), $"p"^+$)
+          content((0.5, -0.75), "n")
+
+          content((3, 0.5), "S")
+          content((1, 0.5), "D")
+          content((2, 0.5), "G")
+        })
+      ),
+    )
+
+    *Drain Strom:*
+
+    NMOS: $I_"Dn" = cases(
+        gap: #0.6em,
+        0 & 0 < U_"GS" < U_t,
+        beta_n (U_"GS" - U_t - U_"DS" / 2) U_"DS" quad & cases(delim: #none, U_"GS" >= U_t, 0 < U_"DS" < U_"GS" - U_t),
+        beta_n/2 (U_"GS" - U_"th")^2 & cases(delim: #none, U_"GS" >= U_t, U_"DS" > U_"GS" - U_t)
+      )$
+
+    PMOS: $I_"Dp" = cases(
+        gap: #0.6em,
+        0 & 0 > U_"GS" > U_t,
+        beta_p (U_"GS" - U_t - U_"DS" / 2) U_"DS" quad & cases(delim: #none, U_"GS" <= U_t, 0 > U_"DS" > U_"GS" - U_t),
+        beta_p/2 (U_"GS" - U_"th")^2 & cases(delim: #none, U_"GS" <= U_t, U_"DS" < U_"GS" - U_t)
+      )
+    $
+  ]
+
+  // Quine McCluskey
+  #bgBlock(fill: colorOptimierung)[
+    #subHeading(fill: colorOptimierung)[Quine McCluskey]
+  ]
+
+  // NMOS/PMOS
+  #bgBlock(fill: colorRealsierung)[
+    #subHeading(fill: colorRealsierung)[CMOS]
+    $hat(=)$ Complemntary MOS
+
+    #table(
+      columns: (1fr, 1fr),
+      zap.circuit({
+        import zap : *
+        import cetz.draw : content
+        import "../lib/circuit.typ" : *
+
+        set-style(wire: (stroke: (thickness: 0.025)))
+
+        registerAllCustom();
+        fet("N0", (0,0), type: "N", angle: 90deg);
+        fet("P0", (0,1), type: "P", angle: 90deg);
+        wire("N0.G", (rel: (-0.1, 0)), (horizontal: (), vertical: "P0.G"), "P0.G")
+
+        node("outNode", (0,0.5))
+        node("inNode", (-0.6,0.5))
+        wire((-1, 0.5), "inNode")
+        wire((0.2, 0.5), "outNode")
+
+        node("N2", (0,-0.5))
+        node("N2", (0,1.5))
+
+        wire((-1, -0.5), (0.5, -0.5))
+        wire((-1, 1.5), (0.5, 1.5))
+
+        content((-1, 0.5), scale($"X"$, 60%), anchor: "east")
+        content((0.45, 0.5), scale($overline("X")$, 60%), anchor: "east")
+        content((-0.9, 1.5), scale($"U"_"DD"$, 60%), anchor: "east")
+        content((-0.9, -0.5), scale($"GND"$, 60%), anchor: "east")
+      }),
+
+      [
+        *Inverter*
+        
+        $overline(X)$
+      ],
+
+      zap.circuit({
+        import zap : *
+        import cetz.draw : content
+        import "../lib/circuit.typ" : *
+
+        set-style(wire: (stroke: (thickness: 0.025)))
+
+        registerAllCustom();
+        fet("P0", (0.5,0.25), type: "P", angle: 90deg);
+        fet("P1", (0.5,1.25), type: "P", angle: 90deg);
+        fet("N0", (0,-1), type: "N", angle: 90deg);
+        fet("N1", (1,-1), type: "N", angle: 90deg);
+
+        content((-0.7, 1.75), scale($"V"_"DD"$, 60%), anchor: "east")
+        content((-0.7, -1.5), scale($"GND"$, 60%), anchor: "east")
+
+        content("N0.G", scale($"B"$, 60%), anchor: "east")
+        content("P0.G", scale($"B"$, 60%), anchor: "east")
+        content("N1.G", scale($"A"$, 60%), anchor: "east")
+        content("P1.G", scale($"A"$, 60%), anchor: "east")
+
+        wire((-0.75, -1.5), (1.5, -1.5))
+        wire((-0.75, 1.75), (1.5, 1.75))
+
+        wire("N0.S", "N1.S")
+        node("N2", "P0.D")
+        wire("N2", (horizontal: (), vertical: "N0.S"))
+        node("N3", "N0.D")
+        node("N4", "N1.D")
+        node("N5", "P1.S")
+        node("N6", (horizontal: (), vertical: "N0.S"))
+
+        wire("N2", (horizontal: (rel: (0.5, 0)), vertical: "N2"))
+        
+        content((horizontal: (rel: (0.65, 0)), vertical: "N2"), scale($"Y"$, 60%))
+      }),
+
+      [
+        *NOR*
+
+        $overline(A +B) = Y$
+      ],
+
+      zap.circuit({
+        import zap : *
+        import cetz.draw : content
+        import "../lib/circuit.typ" : *
+
+        set-style(wire: (stroke: (thickness: 0.025)))
+
+        registerAllCustom();
+        content((-0.7,  0.5), scale($"V"_"DD"$, 60%), anchor: "east")
+        content((-0.7, -2.75), scale($"GND"$, 60%), anchor: "east")
+
+        fet("P0", (0, 0), type: "P", angle: 90deg);
+        fet("P1", (1, 0), type: "P", angle: 90deg);
+        fet("N0", (0.5,-1.25), type: "N", angle: 90deg);
+        fet("N1", (0.5,-2.25), type: "N", angle: 90deg);
+
+        wire((-0.75, 0.5), (1.5, 0.5))
+        wire((-0.75, -2.75), (1.5, -2.75))
+        wire("P0.D", "P1.D")
+
+        node("N2", (horizontal: "N1.D", vertical: "P0.D"))
+        node("N3", "N0.S")
+        wire("N2", "N3")
+        wire("N3", (rel: (0.5, 0)))
+
+        content((horizontal: (rel: (0.65, 0)), vertical: "N3"), scale($"Z"$, 60%))
+        node("4", "P0.S")
+        node("4", "P1.S")
+        node("4", "N1.D")
+
+        content("N0.G", scale($"B"$, 60%), anchor: "east")
+        content("P0.G", scale($"B"$, 60%), anchor: "east")
+        content("N1.G", scale($"A"$, 60%), anchor: "east")
+        content("P1.G", scale($"A"$, 60%), anchor: "east")
+      }),
+
+      [
+        *NAND*
+
+        $overline(A dot B) = Z$
+      ],
+    )
+  ]
+
+  // CMOS
+  #bgBlock(fill: colorRealsierung)[
+    #subHeading(fill: colorRealsierung)[CMOS Verzögerung]
+
+    *Inverter*\
+    $t_("p"/"nLH") ~ (C_"L" t_"ox" L_"p/n")/(W_"p/n" mu_"p/n" epsilon(V_"DD" - abs(V_"Tpn"))) $
+
+    #grid(
+      columns: (1fr, 1fr),
+      [
+        *Steigend mit*
+        - Last $C_L$
+        - Oxyddicke $T_"ox"$
+        - Kandlalänge $L_"p/n"$
+        - Schwellspannung $V_"Tp/n"$ 
+      ],
+      [
+        *Sinkend mit*
+        - Kanalweite
+        - Landsträger Veweglichkeit $mu_"p/n"$
+      ],
+
+    )
+
+    $t_p ~ C_L/(beta(V_"DD" - abs(V_"T")))$
+
+    $t_p ~ C_L/(W(V_"DD" - abs(V_"T")))$
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Latches, Flipflops und Register]
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Timing]
+
+    *Register Bedinungen*
+
+    #cetz.canvas(length: 0.5mm, {
+      import cetz.draw: *
+
+
+      let cycle_time = 38
+      let cycle_start = cycle_time*0.8
+      let cycle_end = cycle_time*4
+      let signal_hight = 10
+      let switch_offset = cycle_time/13
+      let signal_storke = (paint: rgb("#2e2e2e"), thickness: 0.3mm)
+
+      let t_c2q = 0.6
+      let t_setup = 0.6
+      let t_hold = 0.4
+
+      // clk1
+      line((1*cycle_time + switch_offset/2, signal_hight + 1), (1*cycle_time + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+      // q change
+      line((cycle_time*(t_c2q + 1) + switch_offset/2, -15 + signal_hight + 1), (cycle_time*(t_c2q + 1) + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+      // d change
+      line((cycle_time*(t_setup + 2) + switch_offset/2, -30 + signal_hight + 1), (cycle_time*(t_setup + 2) + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+      // clk
+      line((cycle_time*3 + switch_offset/2, signal_hight + 1), (cycle_time*3 + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+      // hold time
+      line((cycle_time*(3+t_hold) + switch_offset/2, -30 + signal_hight + 1), (cycle_time*(3+t_hold) + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+
+      content(( cycle_start -7, 5), "clk")
+
+      line((cycle_start,0), (cycle_time,0), (cycle_time + switch_offset,signal_hight), (cycle_time*2, signal_hight), (cycle_time*2 + switch_offset, 0), (cycle_time*3, 0), (cycle_time*3 + switch_offset, 10), (cycle_end, signal_hight), stroke: signal_storke)
+
+      translate((0, -15))
+      content((cycle_start -7, 5), "Q")
+
+      line(
+        (cycle_start,0), (cycle_time*(t_c2q + 1), 0), 
+        (cycle_time*(t_c2q + 1) + switch_offset, signal_hight), 
+        (cycle_time*(t_c2q + 3),signal_hight), (cycle_time*(t_c2q + 3) + switch_offset, 0), 
+        (cycle_end + switch_offset, 0),
+        stroke: signal_storke
+      )
+      line(
+        (cycle_start,signal_hight), (cycle_time*(t_c2q + 1), signal_hight), 
+        (cycle_time*(t_c2q + 1) + switch_offset, 0), 
+        (cycle_time*(t_c2q + 3),0), (cycle_time*(t_c2q + 3) + switch_offset, signal_hight),
+        (cycle_end + switch_offset, signal_hight),
+        stroke: signal_storke
+      )
+
+      translate((0, -15))
+      content((cycle_start -7, 5), "D")
+
+      line(
+        (cycle_start,0), (cycle_time*(t_setup + 2), 0), 
+        (cycle_time*(t_setup + 2) + switch_offset, signal_hight), (cycle_end + switch_offset, signal_hight), stroke: signal_storke
+        
+      )
+      line(
+        (cycle_start,signal_hight), (cycle_time*(t_setup + 2), signal_hight), 
+        (cycle_time*(t_setup + 2) + switch_offset, 0), (cycle_end + switch_offset, 0), stroke: signal_storke
+      )
+    })
+  ]
+
+
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Pipeline/Parallele Verarbeitungseinheiten]
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Zustandsautomaten]
+  ]
+
+  #colbreak()
+  #bgBlock(fill: colorRealsierung)[
+    #subHeading(fill: colorRealsierung)[Verlustleistung/Verzögerung]
+    
+    $t_p ~ C_L / (V_"DD" - V_"Tn")$
+
+    $P_"stat" ~ e^(-V_T)$
+
+    $P_"dyn"~ V_"DD"^2$
+
+    *Dynamisch:* Bei Schlaten \
+    - Quer/Kurzschluss Strom $i_q$ \
+      $P_"short" = a_01 f beta_n tau (V_"DD" - 2 V_"Tn")^3$ \
+      $tau$: Kurzschluss/Schaltzeit
+    - Lade Strome des $C_L$ $i_c$
+      $P_"cap" = alpha_01 f C_L V_"DD"^2$
+    *Statisch:* Konstant
+    - Leckstom (weil Diode)
+    - Gatestrom 
+
+    *Schaltrate*
+
+    $alpha_"clk" = 100%$
+
+    $alpha_"logic" = 50%$
+
+  ]
+]
+
+#place(bottom,
+  truth-table(
+    outputs: (
+      ("NAND", (1, 1, 1, 0)),
+      ("NOR",  (1, 0, 0, 0)),
+      ("XNOR", (1, 0, 0, 1)),
+      ("XOR",  (0, 1, 1, 0)),
+      ("AND",  (0, 0, 0, 1)),
+      ("OR",   (0, 1, 1, 1)),
+    ),
+    inputs: ("A", "B")
+  ),
+  float: true
+)

src/cheatsheets/LinearAlgebra.typ

@@ -0,0 +1,430 @@
+#import "@preview/biceps:0.0.1" : *
+#import "@preview/mannot:0.3.1"
+#import "@preview/fletcher:0.5.8"
+#import "@preview/cetz:0.4.2"
+
+#import "../lib/styles.typ" : *
+#import "../lib/common_rewrite.typ" : *
+#import "../lib/mathExpressions.typ" : *
+
+#set page(
+  paper: "a4", 
+  margin: (
+    bottom: 10mm,
+    top: 5mm,
+    left: 5mm,
+    right: 5mm
+  ),
+  flipped:true,
+  numbering: "— 1 —",
+  number-align: center
+)
+
+#set text(size: 8pt)
+
+#place(top+center, scope: "parent", float: true, heading(
+  [Linear Algebra EI]
+))
+
+#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
+#let colorMatrixVerfahren = color.hsl(330.19deg, 100%, 68.43%)
+#let colorMatrix = 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 colorGruppen = color.hsl(34.87deg, 92.13%, 75.1%)
+
+
+#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
+#let MathAlignLeft(e) = {
+  align(left, block(e))
+}
+#columns(4, gutter: 2mm)[
+    #bgBlock(fill: colorAllgemein)[
+        #subHeading(fill: colorAllgemein)[Komplexe Zahlen]
+        
+        #ComplexNumbersSection()
+        
+        #sinTable
+    ]
+
+    #bgBlock(fill: colorGruppen)[
+         #subHeading(fill: colorGruppen)[Gruppen]
+
+        *Halbgruppe:* $(M, compose): M times M arrow M$
+        - Assoziativgesetz: $a dot (b dot c) = (a dot b) dot c$
+        *Monoid* Halbgruppe $M$ mit:
+        - Identitätselment: $e in M : a e = e a = a$
+        *Kommutativ/abelsch:* Halbgruppe/Monoid mit
+        - Kommutativgesetz; $a dot b = b dot a$
+
+        #SeperatorLine
+
+        *Gruppe:* Monoid mit
+        - Inverse: $forall a in G : exists space a a^(-1) = a^(-1)a = e$
+        - Eindeutig Lösung für Gleichungen 
+        Zusatz:
+        - Inverseregel: $(a dot b)^(-1) = b^(-1) dot a^(-1)$
+        *Untergruppe:*
+        - Gruppe: $(G, dot)$, $U subset G$
+        - $a,b in U <=> a dot b in U$
+        - $a in U <=> a^(-1) in U$
+        - $e in U$ (Neutrales Element)
+
+        *Direktes Produkt:*\
+        $(G_1,dot_1) times (G_2,dot_2) times ... $ \
+        $(a_1,b_1,...)(a_2,b_2,...)= (a_1 dot_1 b_1, a_2 dot_2 b_2, ...)$
+
+
+        #SeperatorLine
+
+        *Ring:* (auch Schiefkörper) Menge $R$ mit:
+        - $(R, +)$ kommutativ Gruppe
+        - $(R, dot)$ Halbgruppe
+        - $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
+
+        *Körper:* Menge $K$ mit:
+        - $(K, +), (K without {0} , dot)$ kommutativ Gruppe \
+            ($0$ ist Neutrales Element von $+$)
+        - $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
+        _Beweiß durch Überprüfung der Eigneschaften_
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Vektorräume (VR)]
+        $(V, plus.o, dot.o)$ ist ein über Körper $K$
+        - $+: V times V -> V, (v,w) -> v + w$
+        - $dot: K times V -> V, (lambda,v) -> lambda v$
+        Es gilt: $lambda,mu in K, space v,w in V$ 
+        - $(lambda mu)v = lambda (mu v)$
+        - $lambda(v + w) = lambda v + lambda w$\
+            $(lambda + mu)v = lambda v + lambda mu$
+        - $1v = v$, $arrow(0) in V$
+        Bsp: $KK^n$ ($RR^n, CC^n$)
+
+        *Untervektorraum:* $U subset V$ \
+        $v,w in U, lambda in K$ \
+        $ <=> v + w in U$, $arrow(0) in U$ UND $lambda v in U$
+        - $(U inter W) subset V$
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Basis und Dim]
+        *Linear Abbildung:* $Phi: V -> V$ 
+        - $Phi(0) = 0$
+        - $Phi(lambda v + w) = lambda Phi(v) + Phi(w)$
+        - Menge aller linearen Abbildung: $L(V,W)$
+
+        *Basis:*\
+        linear unabhänige Menge $B$ an $v in V$, sodass $op("spann")(v_1, ..., v_n) = op("spann")(V)$
+        - $B$ ist Erzeugerssystem von $V$
+        - Endliche Erzeugerssystem: $abs(B_1)=abs(B_2)...$
+
+        *Linear unabhänige:*
+        Linearkombintation in welcher $lambda_0 = 0, ..., lambda_n = 0$ die EINZIEGE Lösung für $lambda_0 v_0 + ... + lambda_1 v_1 = 0$
+
+        *Basisergänzungssatz:* \
+        Sei ${v_1, ... v_n}$ lin. unabhänig und $M$ kein Basis. Dann $exists v_(n+1)$ sodass ${v_1, ... v_n, v_(n+1)}$ lin unabhänig (aber evt. eine Basis ist)
+
+        *Dimension:* $dim V = \#$Vektoren der Basis
+        - $dim V = infinity$, wenn $V$ nicht endlich erzeugt ist
+    ]
+
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading([Abbildungen], fill: colorAbbildungen)
+        
+        $f(x)=y, f: A -> B$
+
+        *Injectiv (Monomorphismus):*\
+        _one to one_ \
+        $f(x) = f(y) <=> x = y$
+
+        *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$
+        NICHT surjektiv wenn $abs(a) < abs(b)$
+
+        *Bijektiv (Isomorphismus):* \
+        _Injectiv und Surjectiv_ \
+        - In einer Gruppe ist $f(x) = x c$ für $c,x in G$ bijektiv
+        - isomorph: $V,W$ VRs, $f$ bijektiv $f(V) = W => V tilde.equiv W$
+
+        Beweiß durch Wiederspruch \
+        für Gegenbeweiß
+
+        *Endomorphismus:* $A -> B$ mit $A, B subset.eq C$ 
+
+        *Automorphismus:* Endomorphismus und Bijektiv (Isomorphismus)
+        
+        *Vektorraum-Homomorphismus:* linear Abbildung zwischen VR
+    ]
+
+    // Spann und Bild, Kern
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading(fill: colorAbbildungen)[Spann und Bild]
+        *Spann:* 
+        - Vektorraum $V : op("spann")(V) = limits(inter)_(M subset V) U$
+        - $B : op("spann")(U) = {lambda_0 v_0 + ... + lambda_n v_n, lambda_0, ... lambda_n in K}$
+        - $op("spann")(Phi(M)) = Phi(op("spann")(M))$
+
+        *Urbild:* $f^(-1)(I subset B) subset.eq A$
+
+        *Bild:* Wertemenge $WW$ 
+        - $f(I subset A) = B$ (Oft $I = A$)
+        - Basis $B : op("spann")(B)$
+        - $op("Bild") Phi := {Phi in W | v in V}$
+
+        *Nullraum/Kern:* \
+        $op("Kern") Phi := {v in V | Phi(v) = 0}$
+
+        *Rang*
+        $op("Rang") f := dim op("Bild") f$
+
+        *Dimensionssatz:* Sei $A$ lineare Abbildung \
+        $dim(V) = dim(kern(A)) + dim(Bild(A))$ \
+        $dim(V) = dim(kern(A)) + Rang(A)$ \
+
+        $dim(V) = dim(Bild(A)) "oder" dim(kern(A)) = 0 \ <=> A "bijektiv" <=> "invertierbar"$
+    ]
+
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading(fill: colorAbbildungen)[Determinate und Bilinearform]
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Eukldische Vektorräume]
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Unitair Vektorräume ]
+    ]
+
+
+    // Matrix Typem
+    #bgBlock(fill: colorMatrix)[
+        #let colred(x) = text(fill: red, $#x$)
+        #let colblue(x) = text(fill: blue, $#x$)
+
+        #subHeading(fill: colorMatrix)[Matrix Typen]
+        #align(center, scale($colred(m "Zeilen") colblue(n "Splate")\ A in KK^(colred(m) times colblue(n))$, 120%)) #grid(columns: (1fr, 1fr),
+        $quad mat(
+                a_11, a_12, ..., a_(1n);
+                a_21, a_22, ..., a_(2n);
+                dots.v, dots.v, dots.down, dots.v;
+                a_(m 1), a_(m 2), ..., a_(m n)
+            )
+        $,
+            
+            cetz.canvas({
+                    import cetz.draw : *
+
+                    rect((0, 0), (1, 1), fill: rgb("#9292926b"))
+
+                    set-style(mark: (end: (symbol: "straight")))
+                    line((0, -0.2), (1, -0.2), stroke: (paint: blue, thickness: 0.3mm))
+                    line((-0.2, 1), (-0.2, 0), stroke: (paint: red, thickness: 0.3mm))
+
+                    content((-0.45, 0.5), $colred(bold(m))$)
+                    content((0.5, -0.35), $colblue(bold(n))$)
+                    content((0.5, 0.5), $A$)
+                })
+        )
+
+        #table(
+            columns: (auto, 1fr),
+            inset: 2mm,
+            fill: (x, y) => if (calc.rem(y, 2) == 0) { tableFillLow } else { tableFillHigh },
+            [*Einheits Matrix*\ $I,E$], [],
+            [*Diagonalmatrix* \ $Sigma,D$], [
+                Nur Einträger auf Hauptdiagonalen \
+                $det(D) = d_00 dot d_11 dot d_22 dot ...$
+            ],
+            [*Symetrisch*\ $S$], [
+                $S = S^T$, $S in KK^(n times n)$\
+                $A A^T$, $A^T A$ ist symetrisch \
+                $S$ immer diagonaliserbar \
+                EW immer $in RR$, EV orthogonal
+            ],
+            [*Invertierbar*], [
+                $exists A^(-1) : A A^(-1) = A^(-1) A = E$ \
+
+                *Invertierbar wenn:* \
+                $A$ bijektiv, $det(A) = 0$ \
+                $"Spalten Vekoren lin. unabhänig"$ \
+                $det(A) = 0$ \                
+
+                *Nicht Invertierbar wenn:*\
+                $exists$ EW $!= 0 => not "invertierbar"$
+                Keine Qudratische Matrix
+            ],
+            [*Orthogonal*\ $O$], [
+                $O^T = O^(-1)$ \
+                $ip(O v, O w) = ip(v, w)$
+            ],
+            [*Unitair*], [
+                $V^* )$
+            ],
+            [*Diagonaliserbar*], [
+                $exists A = B D B^(-1)$, $D$ diagonal,
+
+                $B$: Splaten sind EV von $A$
+
+                - Selbst-Adujunkte diagonalisierbar
+                - Symetrisch Matrix
+                - $A in KK^(n times n) "AND" alg(lambda) = geo(lambda)$
+            ],
+            [*postiv-semi-definit*], [
+                $forall$ EW $>= 0$
+            ],
+        )
+    ]
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+
+        #subHeading(fill: colorMatrixVerfahren)[Eigenwert und Eigenvektoren ]
+
+        $A in CC^(n times n):$ $n$ Complexe Eigenwerte \
+        $A in RR^(n times n)$
+
+        *1. Eigentwete bestimmen*
+        
+        $A v = lambda v => det(A-E lambda) = 0$
+
+        $0 = det mat(#mannot.markhl($x_11 - lambda_1$, color: red), x_12, ..., x_(1n);
+            x_21, #mannot.markhl($x_22 - lambda_2$, color: red), ..., x_(2n);
+            dots.v, dots.v, dots.down,  dots.v;
+            x_(n 1), x_(n 2), ..., #mannot.markhl($x_(n n) -lambda_n$, color: red)
+        )$
+
+        $--> chi_A = (lambda_0 - lambda)^(n_0) dot (lambda_1 - lambda)^(n_1) ... $
+
+
+        $lambda_0, lambda_1, ... = $ Nst von $chi_A$
+
+
+        *2. Eigenvektor bestimmen*
+        
+        $Eig(lambda_k) = kern(A - lambda_k E)$
+        
+        $mat(#mannot.markhl($x_11 - lambda_k$, color: red), x_12, ..., x_(1n);
+            x_21, #mannot.markhl($x_22 - lambda_k$, color: red), ..., x_(2n);
+            dots.v, dots.v, dots.down,  dots.v;
+            x_(n 1), x_(n 2), ..., #mannot.markhl($x_(n n) -lambda_k$, color: red)
+        ) vec(v_1, v_2, dots.v, v_n) = vec(0, 0, dots.v, 0)$
+
+
+
+        *Algebrasche Vielfacheit:* $alg(lambda) = n_0 + n_1 + ...$ \
+        *Geometrische Vielfacheit:* $geo(lambda) = dim("Eig"_A (lambda))$ \
+
+        $1 <= geo(lambda) <= alg(lambda)$
+
+    ]
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+        #subHeading(fill: colorMatrixVerfahren)[Gram-Schmit ONB]
+
+
+
+    ]
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+        #subHeading(fill: colorMatrixVerfahren)[Diagonalisierung]
+        $A = R D R^(-1)$
+
+        *Rezept Diagonalisierung*
+
+        1. EW bestimmen: $det(A - lambda I) = 0$  \
+            $=> chi_A = (lambda_1 - lambda)^(m 1) (lambda_2 - lambda)^(m 2) ...$ 
+        2. EV bestimmen: $spann(kern(A - lambda_i I))$: $r_0, r_1, ...$
+        3. \
+            #grid(columns: (1fr, 1fr),
+            [
+                Diagnoalmatrix: $D$
+                $mat(
+                        lambda_1, 0, 0,...;
+                        0, lambda_1, 0, ...;
+                        0, 0, lambda_2, ...;
+                        dots.v, dots.v, dots.v, dots.down
+                    )
+                $
+            ],
+            [
+                Basiswechselmatrix: $R$
+                $mat(
+                    |, | , ..., |;
+                    r_0, r_1, ..., r_n;
+                    |, |, ..., |
+                )$
+            ]
+        )
+     ]
+
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+        #subHeading(fill: colorMatrixVerfahren)[Schur-Zerlegung]
+        immer anwendbar; 
+    ]
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+        #subHeading(fill: colorMatrixVerfahren)[SVD]
+
+        $A in RR^(m times n)$ zerlegbar in $A = L S R^T$ \
+
+
+        $L in RR^(m times m)$ Orthogonal \
+        $S in RR^(m times n)$ Diagonal \
+        $R in RR^(n times n)$ Orthogonal
+
+
+        1. $A A^T$ berechnen $A A^T in RR^(m times m)$
+
+        2. $A A^T$ diagonalisieren in $R$, $D$
+
+        3. Singulärwere berechen: $sigma_i = sqrt(lambda_i) $
+        
+        4. $l_i = 1/sigma_i A v_(lambda i) quad quad L = mat( |, |, ..., |; l_0, l_1, ..., l_m; |, |, ..., |)$ \
+            (Evt. zu ONB ergenze mit Gram-Schmit/Kreuzprodukt)
+
+        5. $S in RR^(n times m)$ (wie $A$): \
+            $S = mat(sigma_0, 0; 0, sigma_1; dots.v, dots.v; 0, 0) quad quad quad S = mat(sigma_0, 0, dots, 0; 0, sigma_1, ..., 0)$
+    ]
+
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Matrix Normen]
+
+        $|| dot ||_M$ Matrix Norm, $|| dot ||_V$ Vektornorm
+
+        Generisch Vektor Norm: $|| v ||_p = root(p, sum_(k=1)^n (x_k)^p)$
+
+        - submultiplikativ: $||A B||_"M" <= ||A||||B||$
+        - verträglich mit einer Vektornorm: $||A v||_"V" <= ||A||_"M" ||v||_"V"$
+
+        *Frobenius-Norm* $||A||_"M" = sqrt(sum_(i=1)^m sum_(j=1)^n a_(m n)^2)$
+
+        *Induzierte Norm* $||A||_"M" = sup_(v in V without {0}) (||A v||_V)/(||v||_V)$\
+        $ = sup_(||v|| = 1) (||A v||_V)/(||v||_V)$
+            - submultiplikativ
+            - verträglich mit einer Vektornorm $||dot||_V$
+
+        *maximale Spaltensumme* $||A||_r = max_(1<= i <= n) sum_(j=1)^n |a_(j)|$
+    ]
+
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Rekursive Folgen]
+
+        E.g: $a_1 x_(n-1) + a_2 x_(n) = x_(n+1)$
+
+        1. Als Matrix Schreiben $F: vec(x_(n-1), x_(n)) = vec(x_n, x_(n+1))$ \
+            $F s_(n-1) = s_(n)$
+
+        2. Diagonaliseren: $F = R D R^(-1) $ \
+        3. Wiederholte Anwendung: $F^n = R D^n R^(-1)$
+
+    ]
+
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Differenzialgleichungen]
+    ]
+]
+

src/lib/circuit.typ

@@ -0,0 +1,156 @@
+#import "@preview/cetz:0.4.2" as cetz
+#import "@preview/zap:0.5.0" as zap
+#import zap: interface
+
+#let registerAllCustom() = {
+  cetz.draw.set-ctx(ctx => {
+    ctx.zap.style.insert("zweiTor", (
+      scale: auto,
+      fill: none,
+      height: 10mm,
+      width: 10mm,
+    ))
+
+    ctx.zap.style.insert("einTor", (
+      scale: auto,
+      fill: none,
+      height: 3mm,
+      width: 6mm,
+    ))
+
+    ctx.zap.style.insert("fet", (
+      scale: auto,
+      fill: none,
+      height: 5mm,
+      width: 10mm,
+    ))
+
+
+    for it in ("lnot", "land", "lnand", "lor", "lnor", "lxor", "lxnor") {
+        ctx.zap.style.insert(it, (
+          width: 0.7,
+          min-height: 0.9,
+          spacing: 0.4,
+          padding: 0.25,
+          fill: white,
+          stroke: auto,
+        )
+      )
+    }
+
+    ctx
+  })
+
+
+
+}
+
+#let einTor(name, node, flip: false, ..params) = {
+  import cetz.draw: rect
+  import zap: component
+
+
+  // Drawing function
+  let draw(ctx, position, style) = {
+    rect(
+      (-style.width/2, -style.height/2),
+      (style.width/2, style.height/2),
+      fill: style.fill
+    )
+
+    if(flip) {
+      rect(
+        ((style.width*0.7)/2, -(style.height)/2),
+        (style.width/2, style.height/2),
+        fill: black
+      )
+    } else {
+      rect(
+        (-(style.width)/2, -style.height/2),
+        (-(style.width*0.6)/2, style.height/2),
+        fill: black
+      )
+    }
+
+    interface((-style.width / 2, -style.height / 2), (style.width / 2, style.height / 2), io: position.len() < 2)
+  }
+
+  // Component call
+  component("einTor", name, node, draw: draw, ..params)
+}
+
+#let zweiTor(name, node, label, ..params) = {
+  import cetz.draw: rect, anchor, content
+  import zap: component
+
+
+  // Drawing function
+  let draw(ctx, position, style) = {
+    rect(
+      (-style.width/2, -style.height/2),
+      (style.width/2, style.height/2),
+      fill: style.fill
+    )
+
+    content((0,0), label)
+
+    anchor("in0", (-style.width/2, -style.height*0.5/2))
+    anchor("in1", (-style.width/2, style.height*0.5/2))
+    anchor("out0", (style.width/2, -style.height*0.5/2))
+    anchor("out1", (style.width/2, style.height*0.5/2))
+
+    interface((-style.width / 2, -style.height / 2), (style.width / 2, style.height / 2), io: false)
+  }
+
+  // Component call
+  component("zweiTor", name, node, draw: draw, ..params)
+}
+
+#let fet(name, node, type: "N", scale: 1, angle: 0, thickness: 0.5pt, ..params) = {
+  import cetz.draw: line, circle, anchor, rotate
+  import zap: component
+  
+  // Drawing function
+  let draw(ctx, position, style) = {
+    let zap-style = ctx.zap.style
+
+    let height = style.height * scale;
+    let width = style.width * scale;
+
+    let wireThink = ctx.zap.style.wire.stroke.thickness;
+
+    rotate(angle);
+
+    if(type == "N") {
+      line((0, height), (0, height*(1-0.45)), stroke: (thickness: wireThink))
+    } else { 
+      line((0, height), (0, height*(1-0.2)), stroke: (thickness: wireThink))
+      circle((0, height*(1-0.3) - thickness/2), radius: (height/2)*0.2, stroke: (thickness: wireThink))
+    }
+
+    line(
+      (width/2, 0), 
+      (width*0.4/2, 0),
+      (width*0.4/2, 0), 
+      (width*0.4/2, height*(1-0.6)),
+      (-width*0.4/2, height*(1-0.6)),
+      (-width*0.4/2, 0),
+      (-width/2, 0), stroke: (thickness: wireThink)
+    )
+
+    line(
+      (width*0.42/2, height*(1-0.45)),
+      (-width*0.42/2, height*(1-0.45)),
+      stroke: (thickness: wireThink)
+    )
+
+    anchor("G", (0, height))
+    anchor("D", (-width/2, 0))
+    anchor("S", (width/2, 0))
+
+    interface((-width / 2, -height / 2), (width / 2, height / 2), io: true)
+  }
+
+  // Component call
+  component("fet", name, node, draw: draw, ..params)
+}

src/lib/common_rewrite.typ

@@ -1,4 +1,4 @@
-#let bgBlock(body, fill: color) = block(body, fill:fill.lighten(80%), width: 100%, inset: (bottom: 2mm))
+#let bgBlock(body, fill: color, width: 100%) = block(body, fill:fill.lighten(80%), width: width, inset: (bottom: 2mm, left: 2mm, right: 2mm,))
 
 #let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
 #let MathAlignLeft(e) = {
@@ -6,40 +6,68 @@
 }
 
 #let subHeading(body, fill: color) = {
-  box(
+  move(dx: -2mm, dy: 0mm, box(
     align(
       top+center,
       text(
         body,
-        size: 10pt,
+        size: 8pt,
-        weight: "regular",
+        weight: "bold",
         style: "italic",
       )
     ),
     fill: fill,
-    width: 100%,
+    width: 100% + 4mm,
     inset: 1mm,
     height: auto
-  )
+  ))
 }
 
 #let MathAlignLeft(e) = {
   align(left, block(e))
 }
 
+#let tableFillHigh = white
+#let tableFillLow = color.lighten(gray, 50%)
+
 #let sinTable = [
   #let data = json("../sintable.json")
   #table(
-    columns: data.at("x").len() + 1,
+    columns: data.len(),
     rows: data.keys().len(),
     stroke: none,
     table.hline(stroke: (thickness: 0.3mm)),
-    fill: (x, y) => if (calc.rem(y, 2) == 0) { color.lighten(gray, 50%) } else { white },
+    fill: (x, y) => if (calc.rem(y, 2) == 0) { tableFillLow } else { tableFillHigh },
-      ..for (label) in data.keys() {
+
-      ([*#eval(label, mode: "math")*], table.hline(stroke: (thickness: 0.3mm)), )
+    table.vline(),
-      for i in data.at(label) {
+    ..for (i, label) in data.keys().enumerate() {
-        (eval(i, mode: "math"),)
+      ([*#eval(label, mode: "math")*], if i > 0 { table.vline() } else { table.vline(stroke: none) })
+    },
+
+    table.hline(stroke: (thickness: 0.3mm)),
+  
+    ..for (i, v) in data.at("x").enumerate() {
+    for (col) in data.keys() {
+        (eval(data.at(col).at(i), mode: "math"),)
       }
-    }
+    },
+    table.hline(stroke: (thickness: 0.3mm)),
   )
 ]
+
+#let ComplexNumbersSection(i: $i$) = [
+  $1/#i = #i^(-1) = -#i quad quad #i^2=-1 quad quad sqrt(#i) = 1/sqrt(2) + 1/sqrt(2)#i$
+
+  $z in CC = a + b #i quad quad quad z = r dot e^(#i phi)$ \
+  $z_0 + z_1 = (a_0 + a_1) + (b_0 + b_1) #i$\
+  $z_0 dot z_1 = (a_1 a_2 - b_1 b_2) + #i (a_1b_2 + a_2 b_1) = r_0 r_1 e^(#i (phi_0 + phi_1))$\
+  $z^x = r^x dot e^(phi #i dot x) quad x in RR$ \
+  $z_0/z_1 = r_0/r_1 e^(#i (phi_0 - phi_1)) quad quad quad$ 
+
+  $z^* = a - #i b = r e^(-#i phi)$
+
+  $r = abs(z) quad phi = cases(
+    + arccos(a/r) space : space a >= 0,
+    - arccos(a/r) space : space a < 0,
+  )$
+]

src/lib/fetModel.typ

@@ -0,0 +1,290 @@
+#import "@preview/zap:0.5.0"
+#import "@preview/cetz-plot:0.1.3"
+
+
+#set page(width: auto, height: auto)
+
+#let FetModelSubstrate = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+})
+
+#let FetModel1 = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  rect((2.75, 3), (5.25, 4), fill: rgb("#61ff9f"), name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: rgb("#61ff9f"), name: "kanal2", radius: (
+    south: 0.2,
+  ))
+
+  content("kanal1", [n+], anchor: "center", padding: 0.2)
+  content("kanal2", [n+], anchor: "center", padding: 0.2)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+})
+
+#let FetModel2 = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  rect((2.75, 3), (5.25, 4), fill: rgb("#61ff9f"), name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: rgb("#61ff9f"), name: "kanal2", radius: (
+    south: 0.2,
+  ))
+
+  content("kanal1", [n+], anchor: "center", padding: 0.2)
+  content("kanal2", [n+], anchor: "center", padding: 0.2)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+
+
+  rect((0, 4), (12, 4.5), fill: rgb("#fffc61"), name: "isolator")
+  content("isolator.west", [Isolator ($"SiO"_2$)], anchor: "west", padding: .2)
+})
+
+#let FetModel3 = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  rect((2.75, 3), (5.25, 4), fill: rgb("#61ff9f"), name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: rgb("#61ff9f"), name: "kanal2", radius: (
+    south: 0.2,
+  ))
+
+  content("kanal1", [n+], anchor: "center", padding: 0.2)
+  content("kanal2", [n+], anchor: "center", padding: 0.2)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+
+
+  rect((0, 4), (3, 4.5), fill: rgb("#fffc61"), name: "isolator2")
+  rect((5, 4), (7, 4.5), fill: rgb("#fffc61"))
+  rect((9, 4), (12, 4.5), fill: rgb("#fffc61"), name: "isolator")
+
+  rect((3, 4), (5, 4.25), fill: gray)
+  rect((7, 4), (9, 4.25), fill: gray)
+  rect((5.1, 4.5), (6.9, 4.75), fill: gray)
+
+  content("isolator", [$"SiO"_2$])
+  content("isolator2", [Isolator])
+})
+
+#let FetModel(type: "N", s: 100%) = zap.circuit({
+  import zap: *
+  import cetz.draw: rect, content
+
+  cetz.draw.scale(s)
+
+  let pTypeFill = rgb("#ffb1b1");
+  let pTypeFill = rgb("#ffb1b1");
+  let nTypeFill = rgb("#61ff9f")
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: if(type == "N") { pTypeFill } else { nTypeFill },
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  wire((13, 5.5), (13, 0), mark: (end: ">"))
+  node("n-r1", (13, 5.75))
+
+  wire((6, 4.5), (6, 5.75))
+  node("n-g1", (6, 5.75))
+  wire("n-g1", "n-r1")
+
+  node("n-s1", (4, 5))
+  wire("n-s1", (4, 4.25))
+
+  node("n-d1", (8, 5))
+  wire("n-d1", (8, 4.25))
+
+  rect((0, 4), (3, 4.5), fill: rgb("#fffc61"), name: "isolator2")
+  rect((5, 4), (7, 4.5), fill: rgb("#fffc61"))
+  rect((9, 4), (12, 4.5), fill: rgb("#fffc61"), name: "isolator")
+
+  rect((3, 4), (5, 4.25), fill: gray)
+  rect((7, 4), (9, 4.25), fill: gray)
+  rect((5.1, 4.5), (6.9, 4.75), fill: gray)
+
+  content("n-g1", [*G*\ate], anchor: "south", padding: 0.2, auto-scale: true)
+  content("n-s1", [*S*\ource], anchor: "south", padding: 0.2)
+  content("n-d1", [*D*\rain], anchor: "south", padding: 0.2, auto-scale: true)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2, auto-scale: true)
+  content("p", if type == "N" [p] else [n], auto-scale: true)
+  content("isolator", [$"SiO"_2$], auto-scale: true)
+
+  content("isolator2", [Isolator], auto-scale: true)
+
+  rect((2.75, 3), (5.25, 4), fill: if(type == "N") { nTypeFill }  else { pTypeFill }, name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: if(type == "N") { nTypeFill } else { pTypeFill }, name: "kanal2", radius: (
+    south: 0.2,
+  ))
+
+  content("kanal1", if type == "N" [n+] else [p+], anchor: "center", padding: 0.2, auto-scale: true)
+  content("kanal2", if type == "N" [n+] else [p+], anchor: "center", padding: 0.2, auto-scale: true)
+})
+
+#let FetModelConducting = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  wire((13, 5.5), (13, 0), mark: (end: ">"))
+  node("n-r1", (13, 5.75))
+
+  wire((6, 4.5), (6, 5.75))
+  node("n-g1", (6, 5.75))
+  wire("n-g1", "n-r1")
+
+  node("n-s1", (4, 5))
+  wire("n-s1", (4, 4.25))
+
+  node("n-d1", (8, 5))
+  wire("n-d1", (8, 4.25))
+
+  rect((0, 4), (3, 4.5), fill: rgb("#fffc61"), name: "isolator2")
+  rect((5, 4), (7, 4.5), fill: rgb("#fffc61"))
+  rect((9, 4), (12, 4.5), fill: rgb("#fffc61"), name: "isolator")
+
+  rect((3, 4), (5, 4.25), fill: gray)
+  rect((7, 4), (9, 4.25), fill: gray)
+  rect((5.1, 4.5), (6.9, 4.75), fill: gray)
+
+  content("n-g1", [*G*\ate], anchor: "south", padding: 0.2)
+  content("n-s1", [*S*\ource], anchor: "south", padding: 0.2)
+  content("n-d1", [*D*\rain], anchor: "south", padding: 0.2)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+  content("p", [p])
+  content("isolator", [$"SiO"_2$])
+  content("isolator2", [Isolator])
+
+  rect((2.75, 3), (5.25, 4), fill: rgb("#61ff9f"), name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: rgb("#61ff9f"), name: "kanal2", radius: (
+    south: 0.2,
+  ))
+  rect((5.20, 3.99), (6.8, 3.9), fill: rgb("#61ff9f"), stroke: none)
+
+  content("kanal1", [n+], anchor: "center", padding: 0.2)
+  content("kanal2", [n+], anchor: "center", padding: 0.2)
+
+  rect((0.5, -1), (1, -0.70), fill: gray, stroke: none, name: "metal")
+  content("metal", [metal], anchor: "west", padding: 0.3)
+
+  rect((0.5, -1.2), (1, -1.5), fill: rgb("#61ff9f"), stroke: none, name: "n")
+  content("n", [n+], anchor: "west", padding: 0.3)
+
+  rect(
+    (2.5, -1),
+    (3, -0.7),
+    fill: rgb("#ffb1b1"),
+    stroke: none,
+    name: "p-substrate",
+  )
+  content("p-substrate", [p], anchor: "west", padding: 0.3)
+
+  rect((2.5, -1.2), (3, -1.5), fill: rgb("#fffc61"), stroke: none, name: "siO2")
+  content("siO2", [oxide], anchor: "west", padding: 0.3)
+})
+
+#let FetPlot() = {
+  let u_gs = 1
+  let beta = 1
+
+  cetz.canvas({
+    import cetz-plot: plot
+    import cetz: draw.content
+
+    cetz.draw.set-style(axes: (
+      shared-zero: false,
+      overshoot: 0.2,
+      x: (mark: (end: ">", fill: black, scale: 0.6)),
+      y: (mark: (end: ">", fill: black, scale: 0.6)),
+    ))
+
+    plot.plot(
+      size: (2, 2),
+      name: "plot",
+      axis-style: "school-book",
+      x-min: 0,
+      x-tick-step: none,
+      y-tick-step: none,
+      x-label: $U_"GS"$,
+      y-label: $U_"DS"$,
+      {
+        plot.add-fill-between(domain: (1, 6), ((1, 0), (1, 5)), u_gs => u_gs - u_t)
+
+        plot.add(domain: (0, 5), fill: true, axes: ("y", "x"), _ => 1)
+
+        plot.add(domain: (1, 6), fill: true, u_gs => u_gs - u_t)
+
+        plot.add-anchor("I", (0.5, 2.5))
+        plot.add-anchor("II", (4.5, 1.5))
+        plot.add-anchor("III", (2.5, 3.5))
+
+        plot.add-anchor("ut", (u_t, 0))
+      }
+    )
+    content("plot.ut", $U_t$, anchor: "north", padding: 0.1)
+
+    content("plot.I", [I])
+    content("plot.II", [II])
+    content("plot.III", [III])
+  })
+}

src/lib/logic.typ

@@ -0,0 +1,62 @@
+#import "@preview/zap:0.5.0": *
+#import "@preview/cetz:0.4.2": (
+  draw.anchor, draw.arc-through, draw.circle, draw.content, draw.line, draw.rect, draw.rotate, draw.get-ctx, draw.bezier
+)
+
+#let logic(name, node, text: $"&"$, invert: false, mirror: false, invert-inputs: (), angle: 0deg, inputs: 2, ..params) = {
+  assert(inputs >= 1, message: "logic supports minimum one inputs")
+
+  let style = (
+    width: 0.7,
+    min-height: 0.9,
+    spacing: 0.4,
+    padding: 0.25,
+    fill: white,
+    stroke: auto,
+  )
+
+  // Drawing function
+  let draw(ctx, position, _) = {
+    rotate(angle)
+
+    let height = calc.max(style.min-height, (inputs - 1) * style.spacing + 2 * style.padding)
+    let width = style.width * if mirror { -1 } else { 1 }
+
+    interface((-width / 2, -height / 2), (width / 2, height / 2), io: false)
+
+    rect((-width / 2, -height / 2), (rel: (width, height)), fill: style.fill, stroke: style.stroke)
+    content((0, height / 2 - style.padding / 2), text, anchor: "north", angle: angle)
+
+    let ball-radius = calc.min(height, width) * 0.1
+
+    for input in range(1, inputs + 1) {
+      let pad = (height - (inputs - 1) * style.spacing) / 2
+      let y = height / 2 - pad - (input - 1) * style.spacing;
+
+      if input in invert-inputs {
+        circle((-width / 2 - ball-radius, y), radius: ball-radius, stroke: style.stroke, fill: style.fill)
+        anchor("in" + str(input), (-width / 2, y))
+      } else {
+        anchor("in" + str(input), (-width / 2, y))
+      }
+    }
+
+    if invert {
+      circle((width / 2 + ball-radius, 0), radius: ball-radius, stroke: style.stroke, fill: style.fill)
+      anchor("out", (width / 2, 0))
+    } else {
+      anchor("out", (width / 2, 0))
+    }
+  }
+
+  // Component call
+  component("logic", name, node, draw: draw, ..params)
+}
+
+#let lnot(name, node, ..params) = logic(name, node, ..params, text: $1$, invert: true)
+#let land(name, node, ..params) = logic(name, node, ..params, text: $"&"$)
+#let lnand(name, node, ..params) = logic(name, node, ..params, text: $"&"$, invert: true)
+#let lor(name, node, ..params) = logic(name, node, ..params, text: $>=1$)
+#let lnor(name, node, ..params) = logic(name, node, ..params, text: $>=1$, invert: true)
+#let lxor(name, node, ..params) = logic(name, node, ..params, text: $=1$)
+#let lxnor(name, node, ..params) = logic(name, node, ..params, text: $=1$, invert: true)

src/lib/mathExpressions.typ

@@ -0,0 +1,13 @@
+// Math macors
+#let kern(x) = $op("kern")(#x)$
+#let alg(x) = $op("alg")(#x)$
+#let geo(x) = $op("geo")(#x)$
+#let spann(x) = $op("spann")(#x)$
+#let Bild(x) = $op("Bild")(#x)$
+#let Rang(x) = $op("Rang")(#x)$
+#let Eig(x) = $op("Eig")(#x)$
+#let lim = $limits("lim")$
+#let ip(x, y) = $lr(angle.l #x, #y angle.r)$
+
+#show math.integral: it => math.limits(math.integral)
+#show math.sum: it => math.limits(math.sum)

src/lib/table.typ

@@ -0,0 +1,80 @@
+#import "@preview/zap:0.5.0"
+#import "logic.typ"
+
+#let circuit(body) = zap.circuit({
+  import zap: *
+
+  set-style(
+    node: (
+      radius: 0.04,
+    )
+  )
+
+  body
+})
+
+#table(
+  columns: (1fr, 1fr),
+  align: center + horizon,
+  stroke: (x, y) => (
+    left: if x > 0 { 0.5pt },
+    top: if y == 1 { 1pt } else if y > 0 { 0.5pt },
+  ),
+  table.header([DNF], [KNF]),
+  circuit({
+    import zap: *
+
+    logic.land("A1", (0, 0.75), invert-inputs: (1,))
+    logic.land("A2", (0, -0.75), invert-inputs: (2,))
+
+    logic.lor("O1", (1.25, 0))
+
+    zwire("A1.out", "O1.in1", ratio: 50%)
+    zwire("A2.out", "O1.in2", ratio: 50%)
+
+    wire((-1, 1.25), (-1, -1.25), name: "A")
+    wire((-0.75, 1.25), (-0.75, -1.25), name: "B")
+
+    cetz.draw.content("A.in", [a], anchor: "south", padding: 2pt)
+    cetz.draw.content("B.in", [b], anchor: "south", padding: 2pt)
+
+    node("N4", ("A1.in1", "-|", "A.in"))
+    wire("A1.in1", "N4")
+    node("N3", ("A1.in2", "-|", "B.in"))
+    wire("A1.in2", "N3")
+    node("N2", ("A2.in1", "-|", "A.in"))
+    wire("A2.in1", "N2")
+    node("N1", ("A2.in2", "-|", "B.in"))
+    wire("A2.in2", "N1")
+
+    wire("O1.out", (rel: (0.3, 0)))
+  }),
+  circuit({
+    import zap: *
+
+    logic.lor("A1", (0, 0.75))
+    logic.lor("A2", (0, -0.75), invert-inputs: (1,2))
+
+    logic.land("O1", (1.25, 0))
+
+    zwire("A1.out", "O1.in1", ratio: 50%)
+    zwire("A2.out", "O1.in2", ratio: 50%)
+
+    wire((-1, 1.25), (-1, -1.25), name: "A")
+    wire((-0.75, 1.25), (-0.75, -1.25), name: "B")
+
+    cetz.draw.content("A.in", [a], anchor: "south", padding: 2pt)
+    cetz.draw.content("B.in", [b], anchor: "south", padding: 2pt)
+
+    node("N4", ("A1.in1", "-|", "A.in"))
+    wire("A1.in1", "N4")
+    node("N3", ("A1.in2", "-|", "B.in"))
+    wire("A1.in2", "N3")
+    node("N2", ("A2.in1", "-|", "A.in"))
+    wire("A2.in1", "N2")
+    node("N1", ("A2.in2", "-|", "B.in"))
+    wire("A2.in2", "N1")
+
+    wire("O1.out", (rel: (0.3, 0)))
+  })
+)

src/lib/truthtable.typ

@@ -0,0 +1,35 @@
+#let truth-table(outputs: (), inputs: none) = {
+  let variables = calc.max(..outputs.map(output => calc.ceil(calc.log(output.at(1).len()) / calc.log(2))))
+
+  if inputs == none {
+    inputs = ($a$, $b$, $c$, $d$).slice(0, variables)
+  }
+
+  assert(outputs.len() >= 1, message: "There has to be at least one output")
+  assert(inputs.len() == variables, message: "There aren't enough variables to label")
+
+  let num-to-bin(x, digits) = {
+    let bits = ()
+
+    while x != 0 {
+      bits.push(calc.rem(x, 2))
+
+      x = calc.floor(x / 2)
+    }
+
+    range(digits).map(x => bits.at(digits - x - 1, default: 0))
+  }
+
+  table(
+    columns: (auto,) * (variables + outputs.len()),
+    stroke: (x, y) => (
+      left: if x == variables { 1pt } else if x > 0 { 0.5pt },
+      top: if y == 1 { 1pt } else if y > 0 { 0.5pt },
+    ),
+    inset: 4pt,
+    if inputs != none { table.header(..inputs.map(x => [#x]), ..outputs.map(((x, _)) => [#x])) },
+    ..range(calc.pow(2, variables))
+      .map(x => (..num-to-bin(x, variables).map(y => [#y]), ..outputs.map(((_, y)) => [#y.at(x, default: [])])))
+      .flatten()
+  )
+}

src/linAlg/LinearAlgebra.typ

@@ -1,177 +0,0 @@
-#import "@preview/biceps:0.0.1" : *
-#import "@preview/mannot:0.3.1"
-#import "lib/styles.typ" : *
-#import "lib/common_rewrite.typ" : *
-
-#set page(
-  paper: "a4", 
-  margin: (
-    bottom: 10mm,
-    top: 5mm,
-    left: 5mm,
-    right: 5mm
-  ),
-  flipped:true,
-  numbering: "— 1 —",
-  number-align: center
-)
-
-#place(top+center, scope: "parent", float: true, heading(
-  [Linear Algebra EI]
-))
-
-#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
-#let colorFolgen = color.hsl(202.05deg, 92.13%, 75.1%)
-#let colorReihen = color.hsl(280deg, 92.13%, 75.1%)
-#let colorAbbildungen = color.hsl(356.92deg, 92.13%, 75.1%)
-#let colorGruppen = color.hsl(34.87deg, 92.13%, 75.1%)
-
-
-#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
-#let MathAlignLeft(e) = {
-  align(left, block(e))
-}
-#columns(4, gutter: 2mm)[
-    #bgBlock(fill: colorAllgemein)[
-        #subHeading(fill: colorAllgemein)[Notation]
-        
-
-    ]
-
-    #bgBlock(fill: colorGruppen)[
-         #subHeading(fill: colorGruppen)[Gruppen]
-
-        *Halbgruppe:* $(M, compose): M times M arrow M$
-        - Assoziativgesetz: $a dot (b dot c) = (a dot b) dot c$
-        *Monoid* Halbgruppe $M$ mit:
-        - Identitätselment: $e in M : a e = e a = a$
-        *Kommutativ/abelsch:* Halbgruppe/Monoid mit
-        - Kommutativgesetz; $a dot b = b dot a$
-
-        #SeperatorLine
-
-        *Gruppe:* Monoid mit
-        - Inverse: $forall a in G : exists space a a^(-1) = a^(-1)a = e$
-        - Eindeutig Lösung für Gleichungen 
-        Zusatz:
-        - Inverseregel: $(a dot b)^(-1) = b^(-1) dot a^(-1)$
-        *Untergruppe:*
-        - Gruppe: $(G, dot)$, $U subset G$
-        - $a,b in U <=> a dot b in U$
-        - $a in U <=> a^(-1) in U$
-        - $e in U$ (Neutrales Element)
-
-        *Direktes Produkt:*\
-        $(G_1,dot_1) times (G_2,dot_2) times ... $ \
-        $(a_1,b_1,...)(a_2,b_2,...)= (a_1 dot_1 b_1, a_2 dot_2 b_2, ...)$
-
-
-        #SeperatorLine
-
-        *Ring:* (auch Schiefkörper) Menge $R$ mit:
-        - $(R, +)$ kommutativ Gruppe
-        - $(R, dot)$ Halbgruppe
-        - $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
-
-        #colbreak()
-
-        *Körper:* Menge $K$ mit:
-        - $(K, +), (K without {0} , dot)$ kommutativ Gruppe \
-            ($0$ ist Neutrales Element von $+$)
-        - $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
-        _Beweiß durch Überprüfung der Eigneschaften_
-    ]
-
-    #bgBlock(fill: colorReihen)[
-        #subHeading(fill: colorReihen)[Vektorräume (VR)]
-        $(V, plus.o, dot.o)$ ist ein über Körper $K$
-        - $+: V times V -> V, (v,w) -> v + w$
-        - $dot: K times V -> V, (lambda,v) -> lambda v$
-        Es gilt: $lambda,mu in K, space v,w in V$ 
-        - $(lambda mu)v = lambda (mu v)$
-        - $lambda(v + w) = lambda v + lambda w$\
-            $(lambda + mu)v = lambda v + lambda mu$
-        - $1v = v$, $arrow(0) in V$
-        Bsp: $KK^n$ ($RR^n, CC^n$)
-
-        *Untervektorraum:* $U subset V$ \
-        $v,w in U, lambda in K$ \
-        $ <=> v + w in U$, $arrow(0) in U$ UND $lambda v in U$
-        - $(U inter W) subset V$
-    ]
-
-    #bgBlock(fill: colorReihen)[
-        #subHeading(fill: colorReihen)[Basis und Dim]
-        *Linear Abbildung:* $Phi: V -> V$ 
-        - $Phi(0) = 0$
-        - $Phi(lambda v + w) = lambda Phi(v) + Phi(w)$
-        - Menge aller linearen Abbildung: $L(V,W)$
-
-        *Basis:*\
-        linear unabhänige Menge $B$ an $v in V$, sodass $op("spann")(v_1, ..., v_n) = op("spann")(V)$
-        - $B$ ist Erzeugerssystem von $V$
-        - Endliche Erzeugerssystem: $abs(B_1)=abs(B_2)...$
-
-        *Linear unabhänige:*
-        Linearkombintation in welcher $lambda_0 = 0, ..., lambda_n = 0$ die EINZIEGE Lösung für $lambda_0 v_0 + ... + lambda_1 v_1 = 0$
-
-        *Basisergänzungssatz:* \
-        Sei ${v_1, ... v_n}$ lin. unabhänig und $M$ kein Basis. Dann $exists v_(n+1)$ sodass ${v_1, ... v_n, v_(n+1)}$ lin unabhänig (aber evt. eine Basis ist)
-
-        *Dimension:* $dim V = \#$Vektoren der Basis
-        - $dim V = infinity$, wenn $V$ nicht endlich erzeugt ist
-    ]
-
-    #bgBlock(fill: colorAbbildungen)[
-        #subHeading([Abbildungen], fill: colorAbbildungen)
-        
-        $f(x)=y, f: A -> B$
-
-        *Injectiv (Monomorphismus):*\
-        _one to one_ \
-        $f(x) = f(y) <=> x = y$
-
-        *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$
-        NICHT surjektiv wenn $abs(a) < abs(b)$
-
-        *Bijektiv (Isomorphismus):* \
-        _Injectiv und Surjectiv_ \
-        - In einer Gruppe ist $f(x) = x c$ für $c,x in G$ bijektiv
-        - isomorph: $V,W$ VRs, $f$ bijektiv $f(V) = W => V tilde.equiv W$
-
-        Beweiß durch Wiederspruch \
-        für Gegenbeweiß
-
-        *Endomorphismus:* $A -> B$ mit $A, B subset.eq C$ 
-
-        *Automorphismus:* Endomorphismus und Bijektiv (Isomorphismus)
-        
-        *Vektorraum-Homomorphismus:* linear Abbildung zwischen VR
-    ]
-
-    #bgBlock(fill: colorAbbildungen)[
-        #subHeading(fill: colorAbbildungen)[Spann und Bild]
-        *Spann:* 
-        - Vektorraum $V : op("spann")(V) = limits(inter)_(M subset V) U$
-        - $B : op("spann")(U) = {lambda_0 v_0 + ... + lambda_n v_n, lambda_0, ... lambda_n in K}$
-        - $op("spann")(Phi(M)) = Phi(op("spann")(M))$
-
-        *Urbild:* $f^(-1)(I subset B) subset.eq A$
-
-        *Bild:* Wertemenge $WW$ 
-        - $f(I subset A) = B$ (Oft $I = A$)
-        - Basis $B : op("spann")(B)$
-        - $op("Bild") Phi := {Phi in W | v in V}$
-
-        *Nullraum/Kern:* \
-        $op("Kern") Phi := {v in V | Phi(v) = 0}$
-
-        *Rang*
-        $op("Rang") f := dim op("Bild") f$
-    ]
-
-]
-