updated schaltungstheorie

.gitea/workflows/build-script.yaml

@@ -29,15 +29,19 @@ jobs:
 
       - name: Compile Analysis1
         continue-on-error: true
-        run: typst compile --root src src/cheatsheets/Analysis1.typ build/Analysis1.pdf
+        run: typst compile --root src src/cheatsheets/Analysis1.typ "build/sem1-Analysis_1.pdf"
 
       - name: Compile Schaltungstheorie
         continue-on-error: true
-        run: typst compile --root src src/cheatsheets/Schaltungstheorie.typ build/Schaltungstheorie.pdf
+        run: typst compile --root src src/cheatsheets/Schaltungstheorie.typ "build/sem1-Schaltungstheorie.pdf"
 
       - name: Compile LinAlg
         continue-on-error: true
-        run: typst compile --root src src/cheatsheets/LinearAlgebra.typ build/LinearAlgebra.pdf
+        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: Create Gitea Release
         continue-on-error: true
@@ -45,4 +49,8 @@ jobs:
         with:
           name: "Formelsammlungen PDFs"
           tag_name: "latest"
-          files: build/*.pdf
+          files: build/*.pdf
+
+      - name: Trigger 
+        continue-on-error: true
+        run: curl -u trigger:${{ secrets.TRIGGER_PASSWORD }} -X POST https://trigger.typst4ei.de/trigger/all

.gitignore

@@ -4,4 +4,6 @@ node_modules
 __pycache__/
 
 package-lock.json
-package.json
+package.json
+
+*.pdf

src/cheatsheets/Analysis1.typ

@@ -1,6 +1,12 @@
 #import "../lib/common_rewrite.typ" : *
 #import "@preview/mannot:0.3.1"
 
+#show math.integral: it => math.limits(math.integral)
+#show math.sum: it => math.limits(math.sum)
+#let lim = $limits("lim")$
+
+#set text(7.5pt)
+
 #set page(
   paper: "a4", 
   margin: (
@@ -37,45 +43,67 @@
 #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))$
@@ -84,34 +112,44 @@
 
     #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
@@ -125,7 +163,8 @@
       [$tan(x)=-cot(x + pi/2)$],
       [$cot(x)=-tan(x + pi/2)$],
       [$cos(x - pi/2) = sin(x)$],
-      [$sin(x + pi/2) = cos(x)$],
+      [$sin(x + pi/2) = cos(x)$],    
+    
     )
     $sin(x)cos(y) = 1/2sin(x - y) + 1/2sin(x + y)$
 
@@ -134,9 +173,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 +185,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 +204,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 +271,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 +290,7 @@
     )
   ]
 
+  // Teilfolgen
   #bgBlock(fill: colorFolgen)[
     #subHeading(fill: colorFolgen)[Teilfolgen]
     $ a_k subset a_n space (text("z.B") k= 2n + 1) $
@@ -239,6 +300,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 +308,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 +339,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$
@@ -304,35 +374,75 @@
     - Grenzwert: (Muss $n=0$) $=1/(1-q)$
 
     *Harmonische Reihe:* $sum_(n=0)^infinity 1/n = +infinity$
+
+    *Binomische Reihe:* 
     
-    *Andere*
+    *Reihendarstellungen*
-    - $e^x = limits(sum)_(n=0)^infinity (x^n)/(n!)$
+    #grid(
-    - $ln(x) = limits(sum)_(n=0)^infinity (-1)^n x^(n+1)$
+      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 +484,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 +519,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 +551,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/Digitaltechnik.typ

@@ -0,0 +1,336 @@
+#import "../lib/common_rewrite.typ" : *
+#import "@preview/mannot:0.3.1"
+#import "@preview/cetz:0.4.2"
+
+#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 -"))], 
+      [#align(right, image("../images/cc0.png", height: 5mm,))]
+    )
+  ],
+)
+
+#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
+
+    $f(underline(x)) -->$ *KKNF* / *KDNF* mit Boolsche Expansion
+
+  ]
+
+  #bgBlock(fill: colorOptimierung)[
+    #subHeading(fill: colorOptimierung)[Quine McCluskey]
+  ]
+
+  #bgBlock(fill: colorRealsierung)[
+    #subHeading(fill: colorRealsierung)[NMOS/PMOS]
+  ]
+
+  #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%$
+
+  ]
+]

src/cheatsheets/LinearAlgebra.typ

@@ -16,12 +16,14 @@
   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 colorFolgen = color.hsl(202.05deg, 92.13%, 75.1%)
+#let colorMatrix = 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%)
@@ -173,5 +175,129 @@
         $op("Rang") f := dim op("Bild") f$
     ]
 
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Matrix Typen]
+
+        *Einheits Matrix* $I,E$
+
+        *Diagonalmatrix*
+
+        *Symetrisch* $S$: \
+        $A A^T$ ist symetrisch
+        
+        *Orthogonal* $O$:
+
+        *Unitair:*
+
+        *postiv-semi-definit* \
+        $forall$ Eigenwerte $>= 0$
+    ]
+
+    #colbreak()
+
+    #bgBlock(fill: colorMatrix)[
+
+        #subHeading(fill: colorMatrix)[Eigenwert und Eigenvektoren ]
+
+        $A in CC^(n times n):$ $n$ Complexe Eigenwerte \
+        $A in RR^(n times n)$
+
+        *Eigentwete bestimmen*
+        
+        $A v = lambda v$
+
+        Lösen: $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)
+        )$
+
+        Charakteristisches Polynom: $chi_(A)$
+
+
+        *Eigenvektor bestimmen*
+        
+        Eigentwerte einsetzen: $lambda in {lambda_1, lambda_2, ... lambda}$
+
+
+        *Algebrasche Vielfacheit:* \
+        $sum$ Häufikeit der Nsts von $chi_A$
+
+        *Geometrische Vielfacheit:*\
+        $dim(op("spann")(v_lambda_1, v_lambda_2 ..., v_lambda_n))$ \
+
+        Anzahl der linearunabhänige $v_lambda_i$ 
+
+        $"Geometrische" <= "Algebrasche"$
+
+    ]
+
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Diagonalisierung]
+
+        $A = R D R^T$
+
+        $D$: Diagonalmatrix
+    ]
+
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Schur-Zerlegung]
+        immer anwendbar;
+
+        $A in RR^(n times n)\/CC^(n times n)$ zerlegbar in $O^T R O$
+    
+        Orthogonal $O,O^T$, Dreiecksmatrix $R$
+
+        $R = mat(lambda_1, *, *,..., *;
+            0, lambda_2, *, ..., *;
+            0, 0, lambda_3, ..., *;
+            dots.v, dots.v, dots.v, dots.down, dots.v;
+            0, 0, 0, ..., lambda_n;
+        )$
+
+        1. Eigenwerte bestimmen $lambda_1, lambda_2, ... lambda_n$
+        2. Eigenvektor $v_lambda_1, v_lambda_2 ..., v_lambda_n$
+        3. 
+    ]
+
+    #colbreak()
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[SVD]
+
+        $A in RR^(n times m)$ zerlegbar in $A = L S R^T$ \
+        $L$ Orthogonal, $S$ Diagonalmatrix, $R$ Orthogonal \
+        $A^T = R S^T L^T$
+
+ 
+        *1. $A A^T$ berechnen* $A A^T in RR^(n times n) $
+
+        *2. Eigenwerte von $A A^T$ bestimmen* $lambda_1, lambda_2, ... lambda_n$
+
+        *3. $S$ aufstellen* ($S$ hat gleiche Form wie $A$)
+        
+        $sigma_i = sqrt(lambda_i) =  S in RR^(n x m) =\ mat(
+            sigma_1, 0, 0, ..., 0, 0, ..., 0;
+            0, sigma_2, 0, ..., 0, 0, ..., 0;
+            0, 0, sigma_3, ..., 0, 0, ..., 0;
+            dots.v, dots.v, dots.v, dots.down, dots.v, dots.v, dots.down, dots.v;
+            0, 0, 0, ..., sigma_m, 0, ... , 0
+        )$
+
+        *4. $R$ bestimmen*
+
+        $op("Eig")(lambda_i) = op("kern")(A A^T - lambda_i) ->$
+
+        $A A^T - lambda_i = 0$ (Gaußverfahren)
+
+        $R = 1/sqrt(lambda_i)$
+
+        *5. $L$ bestimmen*
+        
+        $L = 1/sqrt(lambda_i) $
+    ]
+
+
+
+
 ]
 

src/cheatsheets/Schaltungstheorie.typ

@@ -1,8 +1,17 @@
 #import "../lib/common_rewrite.typ" : *
 #import "@preview/mannot:0.3.1"
 #import "@preview/zap:0.5.0"
+#import "@preview/cetz:0.4.2"
+#import "../lib/circuit.typ" : *
+#import "@preview/unify:0.7.1": num,qty,unit
 
+#set math.mat(delim: "[") 
 #show math.equation.where(block: true): it => math.inline(it)
+#set math.mat(delim: "[") 
+#show math.integral: it => math.limits(math.integral)
+#show math.sum: it => math.limits(math.sum)
+#let jVec(x) = $bold(underline(#x))$
+#let jMat(x) = $bold(#x)$
 
 #set page(
   paper: "a4", 
@@ -18,13 +27,14 @@
       align: center,
       columns: (1fr, 1fr, 1fr),
       [#align(left, datetime.today().display("[day].[month].[year]"))], 
-      [#align(center, counter(page).display("- 1 -"))], 
+      [#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 colorEigenschaften = color.hsl(145.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%)
@@ -35,22 +45,184 @@
   [Schaltungstheorie]
 ))
 
-
 #columns(4, gutter: 2mm)[
+  // Allgemein
+  #bgBlock(fill: colorAllgemein)[
+    #subHeading(fill: colorAllgemein)[Allgemeine]
+    *Konzentriertheitshypotese*\
+    $lambda >> d quad quad lambda = c/f quad quad c approx 3.10dot 10^8 m/s$
+
+    d: größe Bauteil Dimension
+
+    f: Maximal Frequenze
+
+    *Kirchhoff*
+
+    #grid(columns: (1fr, 1fr), row-gutter: 5mm, [
+      KCL: $sum_(k=1)^n i_k =0$ (Knotenregel)      
+    ], [
+      #cetz.canvas(length: 8mm, {
+        import cetz.draw: *
+
+        circle((0, 0),radius: 1)
+
+        line((angle: 0deg, radius: 0.2), (angle: 0deg, radius: 1.5), stroke: red)
+        line((angle: 120deg, radius: 1.5), (angle: 120deg, radius: 0.2), stroke: red)
+        line((angle: 240deg, radius: 1.5), (angle: 240deg, radius: 0.2), stroke: red)
+
+        set-style(mark: (end: ("straight")))
+        line((angle: 0deg, radius: 0.2), (angle: 0deg, radius: 0.8), stroke: red)
+        line((angle: 120deg, radius: 1.2), (angle: 120deg, radius: 0.4), stroke: red)
+        line((angle: 240deg, radius: 1.2), (angle: 240deg, radius: 0.4), stroke: red)
+      })
+    ], [
+      KVL: $sum_(k=1)^n u_k =0$ (Maschenregel)
+    ], [
+      #zap.circuit({
+        import zap: wire
+        import cetz.draw: * 
+
+        registerAllCustom();
+
+        einTor("F1", (0, -1), (0, 1))
+        einTor("F2", (1.5, 0), (1.5, 1), flip: true)
+        einTor("F3", (1.5, 0), (1.5, -1), flip: true)
+        wire((0, -1), (1.5, -1))
+        wire((0, 1), (1.5, 1))
+
+        translate((0.75, 0))
+        circle((0, 0), radius: 4mm, stroke: blue)
+        translate((0, 1mm))
+        mark((angle: 180deg, radius: 4mm), 90deg, symbol: "straight", stroke: blue, scale: 0.75)
+        translate((0, -2mm))
+        mark((angle: 0deg, radius: 4mm), 270deg, symbol: "straight", stroke: blue, scale: 0.75)
+      })
+    ])
+
+    $u dot i > 0$: Nimmt Energie auf\
+    $u dot i = 0$: Verlustlos\
+    $u dot i < 0$: Gibt Energie ab\
+  ]
+
+
+  #bgBlock(fill: colorAllgemein)[
+    #subHeading(fill: colorAllgemein)[Verschaltung]
+
+
+  ]
+
+  // Quell Wandlung
+  #bgBlock(fill: colorEineTore)[
+    #subHeading(fill: colorEineTore)[Ein-Tor]
+
+    #grid(
+      columns: (auto, auto),
+      column-gutter: 3mm,
+      zap.circuit({
+        import zap: *
+        registerAllCustom();
+        einTor("F1", (0,0), (2,0), i: (content: $i_(cal(F),1)$, anchor: "south-east", label-distance: -10pt), 
+          u: $u_1$
+        )
+        einTor("F1", (0,0), (2,0), i: (content: $i_(cal(F),2)$, anchor: "west", label-distance: -10pt, invert: true))
+      }),
+      [
+        Tor-Bedinung:\
+        $i_(cal(F),2) = i_(cal(F),1)$
+      ],
+    )
+  ]
+
+  #colbreak()
+
+  // Quell Wandlung
   #bgBlock(fill: colorEineTore)[
     #subHeading(fill: colorEineTore)[Quelle Wandlung]
 
-    #zap.circuit({
+    #grid(
-      import zap: *
+      columns: (1fr, 1fr),
-      set-style(scale: (x: 0.75, y:0.75), fill: none)
+      align: center,
-      resistor("R1", (-2, 0), (0, 0))
+      scale(x: 65%, y: 65%,
-      vsource("V1", (-2, 0), (-2, -2))
+        zap.circuit({
-      wire((-2, -2), (0, -2))
+          import zap : *
-      node("n1", (0, 0), label: "1")
+          import cetz.draw : line, content
-      node("n2", (0, -2), label: "2")
+
-    })
+          vsource("U0", (0, 1.5), (0, -1.5), fill: none)
+
+          node("n2", (3.5,1.5), fill: false)
+          node("n3", (3.5,-1.5), fill: false)
+
+          resistor("R0", "U0.in", "n2", fill: none, label: (content: $R_i$, anchor: "south", distance: 0.1))
+          wire("U0.out", "n3")
+
+          wire((2.49,1.5), "n2", i: (content: $i$, anchor: "south", invert: true))
+
+          set-style(mark: (end: ">", fill: black))
+          line((3.5, 1.2), (3.5, -1.2), stroke: 0.5pt)
+          content((3.9, 0), $u$)
+
+          line((0.7, 0.5), (0.7, -0.5), stroke: 0.5pt)
+          content((1.7, 0), $U_0 = I_0 / G_i$)
+      })),
+      scale(x: 65%, y: 65%,
+      zap.circuit({
+        import zap : *
+        import cetz.draw : line, content
+
+        isource("I0", (0, 1.5), (0, -1.5), fill: none)
+        node("n0", (2,1.5))
+        node("n1", (2,-1.5))
+
+        node("n2", (3.5,1.5), fill: false)
+        node("n3", (3.5,-1.5), fill: false)
+
+        resistor("g0", "n1", "n0", fill: none, label: (content: $G_i$, anchor: "south", distance: 0.2))
+        wire("I0.in", "n0", "n2")
+        wire("I0.out", "n1", "n3")
+        wire("n0", "n2", i: (content: $i$, anchor: "south", invert: true))
+        wire((0,0.6), "I0.in", i: (content: $I_0 = U_0 / R_i$, anchor: "east", invert: false, distance: 0.2))
+
+        set-style(mark: (end: ">", fill: black))
+        line((3.5, 1.2), (3.5, -1.2), stroke: 0.5pt)
+        content((3.9, 0), $u$)
+      })),
+      [
+        $U_0 = I_0 R_i$
+        
+        $R_i=1/G_i$
+
+        $r(i) = R_i i + U_0$
+      ],
+      [
+        $I_0 = U_0 G_i$
+
+        $G_i=1/R_i$
+
+        $g(u) = G_i u + I_0$
+      ]
+    );
+  ]
+  // Bauelemente
+  #bgBlock(fill: colorEineTore)[
+    #subHeading(fill: colorEineTore)[Bauelemente]
+     #table(
+      columns: (1fr, 1fr, 1fr),
+      align: center,
+      table.header([*Zeichen*],[*Gleichung*], [*Abbildung*]),
+      
+      scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+            diode("b1", (0, 0), (1., 0)) 
+      })),
+      
+    );
+  
+  
   ]
 
+  // Graphen und Matrizen
   #bgBlock(fill: colorAnalyseVerfahren)[
     #subHeading(fill: colorAnalyseVerfahren)[Graphen und Matrizen]
 
@@ -65,7 +237,7 @@
 
     Knotenzidenzmatrix $bold(A)$
 
-    $bold(A) : bold(i_k) -> text("Knotenstrombianz") = 0$ \
+    $bold(A) : bold(i_k) -> text("Knotenstrombilanz") = 0$ \
     $bold(A^T) : bold(u_b)-> bold(u_k)$
     $ 
       bold(A) = quad mannot.mark(mat(
@@ -80,6 +252,9 @@
 
       a in {-1, 0, 1}
     $
+
+    $-1$: In Knoten rein \
+    $1$: Aus Knoten raus \
     
     #line(length: 100%, stroke: (thickness: 0.2mm))
     
@@ -103,6 +278,9 @@
       b in {-1, 0, 1}
     $
 
+    $-1$: Gegen Maschenrichtung
+    $1$: In Maschenrichtung
+
     #line(length: 100%, stroke: (thickness: 0.2mm))
 
     *KCL und KVL* \
@@ -118,43 +296,634 @@
     $bold(u_b^T i_b) = 0$
   ]
 
+  // Baumkonzept
   #bgBlock(fill: colorAnalyseVerfahren)[
     #subHeading(fill: colorAnalyseVerfahren)[Baumkonzept]
+    KCLs: $n-1$\
+    KVLs: $b-(n-1)$
+    
+    Baum einzeichnen (Keine Schleifen!)
   ]
 
+  // Tablauematrix
+  #bgBlock(fill: colorAnalyseVerfahren)[
+    #subHeading(fill: colorAnalyseVerfahren)[Tablauematrix]
+  ]
+  // Machenstrom-/Knotenpotenzial-Analyse
   #bgBlock(fill: colorAnalyseVerfahren)[
     #subHeading(fill: colorAnalyseVerfahren)[Machenstrom-/Knotenpotenzial-Analyse]
   ]
 
+  // Reduziert Knotenpotenzial
   #bgBlock(fill: colorAnalyseVerfahren)[
     #subHeading(fill: colorAnalyseVerfahren)[Reduzierte Knotenpotenzial-Analyse]
   ]
 
+  // ZweiTor Verschaltung
+  #bgBlock(fill: colorZweiTore)[
+    #subHeading(fill: colorZweiTore)[Zweitor Verschaltung]
+    #grid(
+      columns: (auto, auto),
+      gutter: 5mm,
+      [
+        Parallel-Parallel \
+        $jMat(G)_"ges" = jMat(G_1) + jMat(G_2)$
+      ],
+      [
+        #zap.circuit({
+          import zap : *
+
+          registerAllCustom();
+          zweiTor("G1", (0,-6mm), $jMat(G_1)$)
+          zweiTor("G2", (0,6mm), $jMat(G_2)$)
+
+          zwire("G1.in1", (-8mm, -3.5mm), (-8mm, 8.5mm), "G2.in1")
+          zwire("G1.in0", (-10mm, -8.5mm), (-10mm, 3.5mm), "G2.in0")
+          node("n0", (13mm, 8.5mm), fill: false)
+          node("n1", (13mm, -8.5mm), fill: false)
+          node("n00", (10mm, 8.5mm))
+          node("n11", (8mm, -8.5mm))
+          wire("n0", "n00")
+          wire("n1", "n11")
+
+          zwire("G1.out1", (10mm, -3.5mm), (10mm, 8.5mm), "G2.out1")
+          zwire("G1.out0", (8mm, -8.5mm), (8mm, 3.5mm), "G2.out0")
+          node("n2", (-13mm, 8.5mm), fill: false)
+          node("n3", (-13mm, -8.5mm), fill: false)
+          node("n22", (-8mm, 8.5mm))
+          node("n33", (-10mm, -8.5mm))
+          wire("n2", "n22")
+          wire("n3", "n33")
+        })
+      ],
+      [
+        Seriel-Seriel \
+        $jMat(G)_"ges" = jMat(G_1) + jMat(G_2)$
+      ],
+      [
+        #zap.circuit({
+          import zap : *
+
+          registerAllCustom();
+          zweiTor("G1", (0,-6mm), $jMat(R_1)$)
+          zweiTor("G2", (0,6mm), $jMat(R_2)$)
+
+          node("n0", (13mm, 8.5mm), fill: false)
+          node("n1", (13mm, -8.5mm), fill: false)
+
+          node("n2", (-13mm, 8.5mm), fill: false)
+          node("n3", (-13mm, -8.5mm), fill: false)
+
+          zwire("G1.in1", (-8mm, -3.5mm), (-8mm, 3.5mm), "G2.in0")
+          zwire("G1.out1", (8mm, -3.5mm), (8mm, 3.5mm), "G2.out0")
+
+          zwire("G1.in0", "n3")
+          zwire("G1.out0", "n1")
+          zwire("G2.out1", "n0")
+          zwire("G2.in1", "n2")
+        })
+      ],
+      [
+        Seriel-Parallel \
+        $jMat(H)_"ges" = jMat(H_1) + jMat(H_2)$
+      ],
+      [
+        #zap.circuit({
+          import zap : *
+
+          registerAllCustom();
+          zweiTor("G1", (0,-6mm), $jMat(H_1)$)
+          zweiTor("G2", (0,6mm), $jMat(H_2)$)
+
+          node("n0", (13mm, 8.5mm), fill: false)
+          node("n1", (13mm, -8.5mm), fill: false)
+
+          node("n2", (-13mm, 8.5mm), fill: false)
+          node("n3", (-13mm, -8.5mm), fill: false)
+
+          zwire("G1.in1", (-8mm, -3.5mm), (-8mm, 3.5mm), "G2.in0")
+
+          zwire("G1.in0", "n3")
+          zwire("G2.in1", "n2")
+
+          zwire("G1.out1", (10mm, -3.5mm), (10mm, 8.5mm), "G2.out1")
+          zwire("G1.out0", (8mm, -8.5mm), (8mm, 3.5mm), "G2.out0")
+          node("n00", (10mm, 8.5mm))
+          node("n11", (8mm, -8.5mm))
+          wire("n0", "n00")
+          wire("n1", "n11")
+        })
+      ],
+      [
+        Parallel-Seriel \
+        $jMat(H')_"ges" = jMat(H'_1) + jMat(H'_2)$
+      ],
+      [
+        #zap.circuit({
+          import zap : *
+
+          registerAllCustom();
+          zweiTor("G1", (0,-6mm), $jMat(H'_1)$)
+          zweiTor("G2", (0,6mm), $jMat(H'_2)$)
+
+          node("n0", (13mm, 8.5mm), fill: false)
+          node("n1", (13mm, -8.5mm), fill: false)
+
+          node("n2", (-13mm, 8.5mm), fill: false)
+          node("n3", (-13mm, -8.5mm), fill: false)
+
+          zwire("G1.out1", (8mm, -3.5mm), (8mm, 3.5mm), "G2.out0")
+
+          zwire("G1.out0", "n1")
+          zwire("G2.out1", "n0")
+
+          zwire("G1.in1", (-8mm, -3.5mm), (-8mm, 8.5mm), "G2.in1")
+          zwire("G1.in0", (-10mm, -8.5mm), (-10mm, 3.5mm), "G2.in0")
+          node("n22", (-8mm, 8.5mm))
+          node("n33", (-10mm, -8.5mm))
+          wire("n2", "n22")
+          wire("n3", "n33")
+        })
+      ],
+      [
+        Kette normal \
+        $jMat(A)_"ges" = jMat(A_1) dot jMat(A_2)$
+      ],
+      [
+        #zap.circuit({
+          import zap : *
+
+          registerAllCustom();
+          zweiTor("A2", (6mm, 0), $jMat(A_2)$, height: 8mm, width: 8mm)
+          zweiTor("A1", (-6mm, 0), $jMat(A_1)$, height: 8mm, width: 8mm)
+
+          node("n0", (-13mm, 2mm), fill: false)
+          node("n1", (-13mm, -2mm), fill: false)
+          node("n2", (13mm, 2mm), fill: false)
+          node("n3", (13mm, -2mm), fill: false)
+
+          wire((-13mm, 2mm),  "A1.in1")
+          wire((-13mm, -2mm), "A1.in0")
+          wire((13mm, 2mm),   "A2.out1")
+          wire((13mm, -2mm),  "A2.out0")
+          wire("A2.in1", "A1.out1")
+          wire("A2.in0", "A1.out0")
+        })
+      ],
+      [
+        Kette invers \
+        $jMat(A')_"ges" = jMat(A'_2) dot jMat(A'_1)$
+      ],
+      [
+        #zap.circuit({
+          import zap : *
+
+          registerAllCustom();
+          zweiTor("A2", (6mm, 0), $jMat(A'_2)$, height: 8mm, width: 8mm)
+          zweiTor("A1", (-6mm, 0), $jMat(A'_1)$, height: 8mm, width: 8mm)
+
+          node("n0", (-13mm, 2mm), fill: false)
+          node("n1", (-13mm, -2mm), fill: false)
+          node("n2", (13mm, 2mm), fill: false)
+          node("n3", (13mm, -2mm), fill: false)
+
+          wire((-13mm, 2mm),  "A1.in1")
+          wire((-13mm, -2mm), "A1.in0")
+          wire((13mm, 2mm),   "A2.out1")
+          wire((13mm, -2mm),  "A2.out0")
+          wire("A2.in1", "A1.out1")
+          wire("A2.in0", "A1.out0")
+        })
+      ]
+    )
+  ],
+
+  // Linearsierung
+  #bgBlock(fill: colorEineTore)[
+    #subHeading(fill: colorEineTore)[Linearisierung (Ein-Tore)]
+
+    1. Arbeitspunkt bestimmen \ $"AP" =(u_"AP", i_"AP")$
+    
+    2. Ableitung $g_cal(F)(u)$/$r_cal(F)(i)$ bilden \ $g'_cal(F)(u)$/$r'_cal(F)(i)$
+
+    *Stromgesteuert $r(i) = u$*
+
+    Groß-Signal:
+
+    $i_"lin" = g_"lin" (u) = g'_cal(F)(u_"AP")(u-u_"AP") + i_"AP" = \
+       g'_cal(F)(u_"AP")u - g'_cal(F)(u_"AP")u_"AP" + i_"AP"
+    $
+
+    $I_0 = i_"AP" - g'_cal(F)(u_"AP")u_"AP"$
+
+    $g_0 = g'_cal(F)(u_"AP")u$
+
+    #block(
+      height: 20mm,
+      scale(x: 75%, y: 75%,
+      zap.circuit({
+        import zap : *
+        import cetz.draw : line, content
+
+        isource("I0", (0, 1.5), (0, -1.5), fill: none)
+        node("n0", (2,1.5))
+        node("n1", (2,-1.5))
+
+        node("n2", (3.5,1.5), fill: false)
+        node("n3", (3.5,-1.5), fill: false)
+
+        resistor("g0", "n1", "n0", fill: none, label: (content: $g_0$, anchor: "south", distance: 0.2))
+        wire("I0.in", "n0", "n2")
+        wire("I0.out", "n1", "n3")
+        wire("n0", "n2", i: (content: $i_"lin"$, anchor: "south", invert: true))
+        wire((0,0.6), "I0.in", i: (content: $I_0$, anchor: "east", invert: true))
+
+        set-style(mark: (end: ">", fill: black))
+        line((3.5, 1.2), (3.5, -1.2), stroke: 0.5pt)
+        content((3.9, 0), $u$)
+      })
+    ));
+
+    #linebreak()
+
+    Klein-Signal:$i_"lin" = g_"lin" (u) = g'(u_"AP")u$
+
+    *Spannungsgesteuert $g(u) = i$*
+    
+    $u_"lin" = r_"lin" (i) = r'(i_"AP")(i-i_"AP") + u_"AP"$
+
+    $U_0 = u_"AP" - r'(i_"AP") i_"AP"$
+
+    #block(
+      height: 25mm,
+      scale(x: 75%, y: 75%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+
+          vsource("U0", (0, 1.5), (0, -1.5), fill: none)
+
+          node("n2", (3.5,1.5), fill: false)
+          node("n3", (3.5,-1.5), fill: false)
+
+          resistor("R0", "U0.in", "n2", fill: none, label: (content: $r_0$, anchor: "south", distance: 0.1))
+          wire("U0.out", "n3")
+
+          wire((2.49,1.5), "n2", i: (content: $i$, anchor: "south", invert: true))
+
+          set-style(mark: (end: ">", fill: black))
+          line((3.5, 1.2), (3.5, -1.2), stroke: 0.5pt)
+          content((3.9, 0), $u_"lin"$)
+
+          line((0.7, 0.5), (0.7, -0.5), stroke: 0.5pt)
+          content((1.2, 0), $U_0$)
+        })
+    ));
+    Klein-Signal: $u_"lin" = r_"lin" (i) = r'(i_"AP")i$
+  ]
+  #colbreak()
+
+  // Linearsierung (N-Tore)
+  #bgBlock(fill: colorZweiTore)[
+    #subHeading(fill: colorZweiTore)[Linearisierung (N-Tore)]
+
+    1. Arbeitspunk bestimmen $vec(jVec(u)_"AP", jVec(i)_"AP") hat(=) vec(jVec(x)_"AP", jVec(y)_"AP")$
+
+    $f_1(x_1, x_2, ... x_n) &= y_1\
+    f_2(x_1, x_2, ... x_n) &= y_2\
+    &dots.v \
+    f_n (x_1, x_2, ... x_n) &= y_n
+    $
+
+    $bold(f)(jVec(x))=jVec(y)$
+
+    2. Ableitung: Jacobi-Matrix
+
+    $jMat(J) = mat(
+      #mannot.mark($delta y_1$, color: red)/(#mannot.mark($delta x_1$, color: red)), #mannot.mark($delta y_1$, color: red)/(#mannot.mark($delta x_2$, color: purple)), ..., #mannot.mark($delta y_1$, color: red)/(#mannot.mark($delta x_n$, color: blue));
+      #mannot.mark($delta y_2$, color: purple)/(#mannot.mark($delta x_1$, color: red)), #mannot.mark($delta y_2$, color: purple)/(#mannot.mark($delta x_2$, color: purple)), ..., #mannot.mark($delta y_2$, color: purple)/(#mannot.mark($delta x_n$, color: blue));
+      dots.v,  dots.v, dots.down,  dots.v;
+      #mannot.mark($delta y_n$, color: blue)/(#mannot.mark($delta x_1$, color: red)), #mannot.mark($delta y_n$, color: blue)/(#mannot.mark($delta x_2$, color: purple)), ..., #mannot.mark($delta y_n$, color: blue)/(#mannot.mark($delta x_n$, color: blue));
+    )$
+
+    *Großsignal Beschreibung:* \
+    $jVec(y)_"lin" = jMat(J)|_(jVec(x)_"AP") (jVec(x)_"lin" - jVec(x)_"AP") + jVec(y)_"AP"$
+
+    *Kleinsingal Beschreibung:* \
+    $jVec(y)_"lin" = jMat(J)|_(jVec(x)_"AP") jVec(x)_"lin"$
+  ]
+
+  // Newton-Raphson
+  #bgBlock(fill: colorEineTore)[
+    #subHeading(fill: colorEineTore)[Newton-Raphson (Eine-Tor)] 
+    $x_(n+1) = x_n - f(x_n)/(f'(x_n))$
+  ]
   
+  // Netwen-Raphson N-Tore
+  #bgBlock(fill: colorZweiTore)[
+    #subHeading(fill: colorZweiTore)[Newton-Raphson (N-Tore)] 
+    Nicht lineare Beschreibung in Nullraum/Impliziter Darstellung:
+    $f(jVec(x)) = jVec(0)$\ 
+
+    $jVec(x)_(n+1) = jVec(x)_n - (jMat(J)|_(jVec(x)_"AP"))^(-1) f(jVec(x))$
+  ]
+
+
+  // Reaktive Elemeten
+  #colbreak()
+  #bgBlock(fill: colorComplexAC)[
+    #subHeading(fill: colorComplexAC)[Reaktive Element]
+
+    *Zustandsgrößen*\
+
+    #grid(columns: (1fr, 0pt, 1fr),
+      row-gutter: 10mm,
+      column-gutter: 2mm,
+    [
+      $[i(t)] = unit("A")$\
+      $[q(t)] = unit("A s") = unit("C")$\
+    ],
+    grid.vline(stroke: 0.75pt),
+    [],
+    [
+      $[u(t)] = unit("V")$ \
+      $[Phi(t)] = unit("A s") = unit("W b") $ \
+    ],
+    
+
+    [
+      $q(t) = integral_(-infinity)^(t) i(tau) d tau = \
+        q(0) + integral_(0)^(t) i(tau) d tau
+      $ \
+
+      $i(t) = (d q)/(d t) = dot(q(t))$
+    ],
+    [],
+    [
+      $Phi(t) = integral_(-infinity)^(t) u(tau) d tau = \
+        Phi(0) + integral_(0)^(t) u(tau) d tau
+      $ \ 
+
+      $u(t) = (d Phi)/(d t) dot(Phi(t))$
+    ])
+
+    $W(t_1, t_2) = integral_(t_1)^(t_2) P(tau) d tau = integral_(t_1)^(t_2) u(tau) i(tau) d tau$
+
+    $W(t_1, t_2) > 0$: Nimmt Energie auf\
+    $W(t_1, t_2) = 0$: Verlustlos\
+    $W(t_1, t_2) < 0$: Gibt Energie ab\
+  ]
+
+  #bgBlock(fill: colorComplexAC)[
+    #subHeading(fill: colorComplexAC)[Reaktive Bauelemente]
+    #grid(columns: (1fr, 0pt, 1fr),
+      row-gutter: 4mm,
+      column-gutter: 2mm,
+    [
+      *Kapazitiv*
+    ],
+    grid.vline(stroke: 0.75pt),
+    [],
+    [
+      *Induktivität*
+    ],
+    [
+      $q = c(u) \ chi(q) = u$\
+    ],
+    [],
+    [
+      $Phi = l(i) \ i = lambda(Phi)$
+    ],
+
+    [$u,q$ stetig und beschränkt],
+    [],
+    [$i,Phi$ stetig und beschränkt],
+    []
+    )
+
+    #align(center, [*Lineare Bauelemente*])
+    #grid(columns: (1fr, 0pt, 1fr),
+      row-gutter: 4mm,
+      column-gutter: 2mm,
+    [
+      *Kapazitiv*
+    ],
+    grid.vline(stroke: 0.75pt),
+    [],
+    [
+      *Induktivität*
+    ],
+    [
+      $q(t) = C dot u(t)$\
+      $i(t) = C dot (d u)/(d t)$\
+      $[C] = F = unit("A s")/unit("V")$
+    ],
+    [],
+    [
+      $Phi(t) = L dot i(t)$\
+      $u(t) = C dot (d i)/(d t)$\
+      $[L] = H = unit("V s") / unit("A")$
+    ],
+    [
+      $E_C = q^2 / 2C = C/2 u^2$
+    ],
+    [],
+    [
+      $E_L = Phi^2/2L = (L i^2)/2$
+    ],
+    [
+      $C$: Admetanze $hat(=) G$
+    ], [],
+    [
+      $L$: Impedanz $hat(=) R$
+    ]
+    )
+  ]
+
+  // Reaktive Dual Wandlung
+  #bgBlock(fill: colorComplexAC)[
+    #subHeading(fill: colorComplexAC)[Reaktive Dualwandlung]
+
+    #grid(columns: (1fr, 1fr), 
+      row-gutter: 4mm,
+      $u --> R_d i^d$, $i --> u^d/R_d$,
+      $q --> Phi^d / R_d$, $Phi --> q^d R_d$
+    )
+  ]
+
+  #bgBlock(fill: colorAllgemein)[
+    #subHeading(fill: colorAllgemein)[Complex Zahlen]
+
+  ]
+
+  // Complex AC
+  #bgBlock(fill: colorComplexAC)[
+    #subHeading(fill: colorComplexAC)[Komplex Wechselstrom Rechnnung]
+    Im Eingeschwungenem Zustand
+
+    $u(t) = U_m cos(omega t + alpha)$ \ 
+    $i(t) = I_m cos(omega t + beta)$ 
+
+    $(d u)/(d t) = A_m$
+    
+    Kreisfrequenz: $omega = 2 pi f$ \
+    Amplitude: $A_m$ \
+    Phaseverschieben: $alpha$
+
+    *Ohm:* $u(t) = R I_m  cos(omega t + beta) = omega A_m cos(omega)$)
+
+    *Serienschaltung*\
+    $u_1(t) = U_1 cos(omega t)$\
+    $u_2(t) = U_2 cos(omega t + phi)$
+
+    $u(t)_"ges" = u_1(t) + u_2(t) = \
+      U_"ges"^2 = U_1^2 + 2 U_1 U_2 + U_2^2 \
+      tan(phi) = (U_2 sin(phi))/(U_1 + U_2 cos(phi))
+    $
+
+    **
+
+  ]
+
+  // SinTable
+  #bgBlock(fill: colorAllgemein, [
+    #subHeading(fill: colorAllgemein, [Sin-Table])
+    #sinTable
+  ])
 ]
 
 #pagebreak()
+
+// Tor Eigenschaften
+#place(
+  bottom, float: true, scope: "parent",
+  bgBlock(fill: colorEigenschaften, width: 100%)[
+    #subHeading(fill: colorEigenschaften)[Tor Eigenschaften]
+
+    #table(
+      columns: (auto, auto, auto, auto),
+      inset: 2mm,
+      align: horizon,
+      table.header([], [*Ein-Tor*], [*Zwei-Tor*], [*Complex AC*]),
+      [*passiv*\ (nimmt Energie auf)\ $not$aktiv],
+      [$forall (u,i) in cal(F): u dot i >= 0$],
+      [
+        $jMat(U)^T jMat(I) + jMat(I)^T jMat(U)$\
+        $forall vec(jVec(u),jVec(v)) in cal(F) : jVec(u)^T jVec(i) >=0$   
+      ],
+      [],
+
+      [*verlustlos*],
+      [
+        $forall (u,i) in cal(F): u dot i = 0$\
+
+        Kennline nur $u\/i$-Achsen
+      ],
+      [$forall vec(jVec(u),jVec(v)) in cal(F) : jVec(u)^T jVec(i) = 0$],
+      [
+        $u\/q$-Plot: Wenn keine Schleifen \
+        $i\/Phi$-Plot: Wenn keine Schleifen \
+        $u\/i$-Plot: Wenn Auf Achse \
+        $Phi\/q$-Plot: Wenn auf Achse \
+      ],
+
+
+      [*linear*],
+      [Kennline ist Gerade],
+      [
+        Darstellbar: Matrix $+$ Aufpunkt\
+        $lambda_1 vec(jVec(u)_1, jVec(i)_1) + lambda_2 vec(jVec(u)_2, jVec(i)_2) in cal(F)$
+      ],
+      [],
+
+      [*quellenfrei*],
+      [$(qty("0", "A"), qty("0", "V")) in cal(F)$],
+      [$(qty("0", "A"), qty("0", "V")) in cal(F)$],
+      [$(qty("0", "A"), qty("0", "V")) in cal(F)$],
+
+      [*streng linear*],
+      [linear UND quellenfrei],
+      [linear UND quellenfrei\ Darstellbar: Nur Matrix],
+      [],
+
+      
+      [*ungepolt* \ (Punkt sym.)],
+      [$(u,i) in cal(F) <=> (-u, -i) in cal(F)\
+        g(u) = i, r(i) = u
+      $],
+      [
+        N/A
+      ],
+      [],
+
+      [*symetrisch*\ $<=>$ Umkehrbar],
+      [N/A],
+      [
+        $jMat(A) = jMat(A')$\
+        $jMat(G) = jMat(P) jMat(G) jMat(P), space jMat(R) = jMat(P) jMat(R) jMat(P), quad jMat(P) = mat(0, 1; 1, 0) \
+        det(H) = 1, $
+
+      ],
+      [],
+
+      [*Reziprok*],
+      [Immer Reziprok],
+      [
+        $cal(F)$ symetrisch $=> cal(F)$ reziprok
+
+        $jMat(U)^T jMat(I) - jMat(I)^T jMat(U) = 0 \
+        jMat(R)^T = jMat(R), quad jMat(G)^T = jMat(G) quad h_21 = -h_12 \ det(jMat(A)) = 1 quad det(jMat(A')) = 1 quad h'_21 = -h'_12$],
+      [],
+     
+      [*$x$-gesteudert*], [Existiert $r(i) = u \/g(u) = i$], [Existiert die Matrix? siehe Tabelle],
+      [],
+      
+      [Alle Beschreibung],
+      [Klar],
+      [$det(M) != 0$, Alle Eintrag $!= 0$]
+    )
+  ]
+)
+
 #place(bottom+left, scope: "parent", float: true)[
   #bgBlock(fill: colorZweiTore)[
-    #subHeading(fill: colorZweiTore)[Umrechnung Zweitormatrizen]
+    #set text(size: 10pt)
-      #show table.cell: it => pad(),
 
+    #subHeading(fill: colorZweiTore)[Umrechnung Zweitormatrizen]
       #table(
-        columns: (auto, 1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
+        columns: (12mm, 1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
         align: center,
+        inset: (bottom: 4mm, top: 4mm),
         gutter: 0.1mm,
-        [In $->$], $bold(R)$, $bold(G)$, $bold(H)$, $bold(H')$, $bold(A)$, $bold(A')$,
+        fill: (x, y) => if x != 0 and calc.rem(x, 2) == 0 { rgb("#c5c5c5") } else { white },
+
+        table.cell(
+          inset: 0mm,
+          [
+          #cetz.canvas(length: 12mm,{
+            import cetz.draw : *
+            line((1,0), (0,1))
+            content((0.309, 0.25), "Out")
+            content((0.75, 0.75), "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)$,
+        $jMat(G^(-1) =) 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)$,
+        $jMat(R^(-1) =) 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)$,
@@ -165,14 +934,14 @@
         $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)$,
+        $jMat(H')^(-1)= 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)$,
+        $jMat(H^(-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)$,
@@ -183,26 +952,32 @@
         $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)$,
+        $jMat(A'^(-1))= 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)$,
+        $jMat(A^(-1))= 1/det(bold(A)) mat(a_22, a_12; a_21, a_11)$,
         $mat(a'_11, a'_12; a'_21, a'_22)$,
       )
+
+      #table(
+        columns: (12mm, 1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
+        align: center,
+        inset: (bottom: 4mm, top: 4mm),
+        gutter: 0.1mm,
+        fill: (x, y) => if x != 0 and calc.rem(x, 2) == 0 { rgb("#c5c5c5") } else { white },
+
+        [],
+        $bold(R) jVec(i) = jVec(u)$, 
+        $bold(G) jVec(u) = jVec(i)$, 
+        $bold(H) vec(i_1, u_2) = vec(u_1, i_2)$, 
+        $bold(H') vec(u_1, i_2) = vec(i_1, u_2)$, 
+        $bold(A) vec(u_2, -i_2) = vec(i_1, u_1)$, 
+        $bold(A') vec(u_1, -i_1) = vec(i_2, u_2)$,
+      
+      )
   ]
 ]
-
-
-
-
-#place(bottom+left, scope: "parent", float: true)[
-  #bgBlock(fill: colorAllgemein, [
-    #subHeading(fill: colorAllgemein, [Sin-Table])
-    #sinTable
-  ])
-]
-

src/lib/circuit.typ

@@ -0,0 +1,86 @@
+#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("einTor", (
+      scale: auto,
+      fill: auto,
+      height: 3mm,
+      width: 6mm,
+    ))
+    ctx
+  })
+
+  cetz.draw.set-ctx(ctx => {
+    ctx.zap.style.insert("zweiTor", (
+      scale: auto,
+      fill: none,
+      height: 10mm,
+      width: 10mm,
+    ))
+    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)
+}

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))
 
 #let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
 #let MathAlignLeft(e) = {
@@ -11,8 +11,8 @@
       top+center,
       text(
         body,
-        size: 10pt,
+        size: 8pt,
-        weight: "regular",
+        weight: "bold",
         style: "italic",
       )
     ),
@@ -30,15 +30,21 @@
 #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 },
-      ..for (label) in data.keys() {
+
-      ([*#eval(label, mode: "math")*], table.hline(stroke: (thickness: 0.3mm)), )
+    ..for (label) in data.keys() {
-      for i in data.at(label) {
+      ([*#eval(label, mode: "math")*], )
-        (eval(i, mode: "math"),)
+    },
+
+    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"),)
       }
     }
   )