added complex komonent list

.gitea/workflows/build-script.yaml

@@ -43,6 +43,11 @@ jobs:
         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: Create Gitea Release
         continue-on-error: true
         uses: akkuman/gitea-release-action@v1

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/LinearAlgebra.typ

@@ -332,31 +332,32 @@
         #subHeading(fill: colorMatrixVerfahren)[Diagonalisierung]
         $A = R D R^(-1)$
 
-        #grid(
-            columns: (1fr, 1fr),
-            $D = mat(
+        *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
-            )$,
-
-            $D^n = mat(
-                lambda_1^n, 0, 0,...;
-                0, lambda_1^n, 0, ...;
-                0, 0, lambda_2^n, ...;
-                dots.v, dots.v, dots.v, dots.down
+                    )
+                $
+            ],
+            [
+                Basiswechselmatrix: $R$
+                $mat(
+                    |, | , ..., |;
+                    r_0, r_1, ..., r_n;
+                    |, |, ..., |
                 )$
-        ) \
-
-        *Rezept Diagonalisierung*
-
-        1. *EW* bestimmen
-        2. $chi_A$ bestimmen und in $(lambda_0 - lambda)^(n_0) dot (lambda_1 - lambda)^(n_1) ...$ Form bringen \
-            $chi_A$ nicht vollstandig zerfällt (in $RR$), $=>$ NICHT diagonalisierbar
-        3. *EV* bestimmen
-        4. $R = mat( bar, bar, ..; v_(lambda 0), v_(lambda 1), ...; bar, bar, ...)$
-        5. $R^(-1)$ bestimmen 
+            ]
+        )
      ]
 
 
@@ -368,31 +369,24 @@
     #bgBlock(fill: colorMatrixVerfahren)[
         #subHeading(fill: colorMatrixVerfahren)[SVD]
 
-        $A in RR^(m times n)$ zerlegbar in $A = U Sigma V^T$ \
+        $A in RR^(m times n)$ zerlegbar in $A = L S R^T$ \
 
 
-        $U in RR^(m times m)$ Orthogonal \
-        $Sigma in RR^(m times n)$ Diagonal \
-        $V in RR^(n times n)$ Orthogonal
+        $L in RR^(m times m)$ Orthogonal \
+        $S in RR^(m times n)$ Diagonal \
+        $R in RR^(n times n)$ Orthogonal
 
 
-        1. $A^T A$ berechnen $A^T A in RR^(k times k), k = min(n, m)$
+        1. $A A^T$ berechnen $A A^T in RR^(m times m)$
 
-        2. Eigenwerte bestimmen $det(A^T A - E lambda) = 0$ \
-            $lambda_0, lambda_1 ... lambda_k$ nach Größe sortieren \
-            Singulärewerte: $sigma_i = sqrt(lambda_i)$
+        2. $A A^T$ diagonalisieren in $R$, $D$
 
-        3. Eigenvekoren von $A^T A$ bestimmen und *Normalisieren*
-            $v_(lambda 0), v_(lambda 1), ... v_(lambda k)$ 
+        3. Singulärwere berechen: $sigma_i = sqrt(lambda_i) $
         
-        4. $V = mat( |, |, ..., |; v_0, v_1, ..., v_n; |, |, ..., |) --> V^T$ \
+        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. $u_i = 1/sigma_i A v_(lambda i) quad quad L = mat( |, |, ..., |; u_0, u_1, ..., u_m; |, |, ..., |)$ \
-            (Evt. zu ONB ergenze mit Gram-Schmit/Kreuzprodukt)
-
-        6. $S in RR^(n times m)$ (wie $A$):
-
+        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)$
     ]
 

src/cheatsheets/Schaltungstheorie.typ

@@ -1,6 +1,8 @@
 #import "@preview/mannot:0.3.1"
 #import "@preview/zap:0.5.0"
-#import "@preview/cetz:0.4.2"
+#import "@preview/cetz:0.4.2" :*
+#import "@preview/cetz-plot:0.1.3"
+#import "../lib/circuit.typ" : *
 #import "@preview/unify:0.7.1": num,qty,unit
 #import "@preview/cetz-plot:0.1.3"
 
@@ -372,15 +374,353 @@
     #subHeading(fill: colorEineTore)[Bauelemente]
      #table(
       columns: (1fr, 1fr, 1fr ),
+      stroke: none,
       align: center,
       table.header([*Zeichen*],[*Gleichung*], [*Abbildung*]),
 
-      scale(x: 100%, y: 100%,
+      // Dioden ://
+      // 
+      // ideale Diode
+      [      
+      ideale Diode
+      #scale(x: 100%, y: 100%,
         zap.circuit({
           import zap : *
           import cetz.draw : line, content
-            diode("b1", (0, 0), (1., 0)) 
-      })),
+            diode("b1", (0, 0), (1., 0), stroke: black, fill: white) 
+
+      }))      
+      ],
+      [      
+        $u=0$ falls $i>0$
+        $i=0$ falls $u<0$
+      ],
+      [
+      /*
+      #scale(x: 50%, y: 50%,  
+        cetz.canvas({
+          import cetz.draw: *
+            line((-1.5, 0), (1.5, 0), mark: (end: "straight"))
+            line((0, -1.5), (0, 1.5), mark: (end: "straight"))
+
+            content( (1.55, 0), $u$, anchor: "west")
+            content( (0.15, 1.4), $i$, anchor: "west")
+
+            line((-1.5, 0), (0, 0), stroke: red)      // u = 0
+            line((0, 0), (0, 1.35), stroke: red)      // i = 0  
+
+      }))
+      */
+        #scale(x: 75%, y: 75%,  
+        cetz.canvas({
+          import cetz.draw: *
+          import cetz-plot: *
+
+          let opts = (x-tick-step: none, y-tick-step: none, size: (2,1), x-label: [u], y-label: [i])
+
+          plot.plot(axis-style: "school-book", ..opts, name: "plot",
+          {
+            plot.add(((-1,0), (0,0),), style: (stroke: red))
+            plot.add(((0,0), (0,1),), style: (stroke: red))
+          }
+          )
+      }))
+      ],
+      //table.hline(start: 1, end: 2),
+      
+      // reale/pn Diode
+      [      
+      reale/pn Diode
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+            diode("b1", (0, 0), (1., 0), stroke: black, fill: black) 
+
+      }))      
+      ],
+
+      [      
+        $u_D = u_T*ln((i_D/I_S)+1)$
+        $i_D = I_S*(e^(u_D/U_T)-1)$ 
+      ],
+      [
+      #scale(x: 75%, y: 75%,  
+        cetz.canvas({
+          import cetz.draw: *
+          import cetz-plot: *
+
+          let opts = (x-tick-step: none, y-tick-step: none, size: (2,1), x-label: [u], y-label: [i])
+          let data = plot.add(x => calc.exp(x)-1, 
+             domain: (-2, 2), style: (stroke: red))
+
+          plot.plot(axis-style: "school-book", ..opts, data, name: "plot")
+      }))
+      ],
+
+      // Photodiode
+      [      
+      Photodiode
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+            photodiode("b1", (0, 0), (1., 0), stroke: black, fill: black) 
+      }))      
+      ],
+      [      
+        $i = I_S*(e^(u_D/U_T)-1)- i_L$ 
+      ],
+      [
+      #scale(x: 75%, y: 75%,  
+        cetz.canvas({
+          import cetz.draw: *
+          import cetz-plot: *
+
+          let opts = (x-tick-step: none, y-tick-step: none, size: (2,1), x-label: [u], y-label: [i])
+
+          plot.plot(axis-style: "school-book", ..opts, name: "plot",
+          {
+            plot.add(x => calc.exp(x)-1, 
+             domain: (-2, 2), style: (stroke: red))
+            
+            plot.add(x => calc.exp(x)-2, 
+             domain: (-2, 2), style: (stroke: red))
+             
+            plot.add(x => calc.exp(x)-3, 
+             domain: (-2, 2), style: (stroke: red))
+             }
+
+          )
+      }))
+      ],
+
+      // Zenerdiode
+      [      
+      Zenerdiode
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  zener("b1", (0, 0), (1., 0), stroke: black, fill: black) 
+      }))      
+      ],
+      [      
+        Durchbruch bei $u=U_Z$ :
+        $u<=U_Z$ stark leitend
+      ],
+      [      
+        
+      ],
+
+      // Tunneldiode
+      [      
+      Tunneldiode
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  tunnel("b1", (0, 0), (1., 0), stroke: black, fill: black) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
+      // Quellen: //
+      // Spannungs-quelle
+      [
+        Spannungs-quelle
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  vsource(
+                    "b1", 
+                  (0, 0), 
+                  (1.75, 0)
+                  ) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
+      // Strom-quelle
+      [
+        Strom-quelle
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  isource(
+                    "b1", 
+                  (0, 0), 
+                  (1.75, 0)
+                  ) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
+      // Wiederstand
+      [
+      Wiederstand
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  resistor(
+                    "b1", 
+                  (0, 0), 
+                  (2, 0)
+                  ) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
+      // Induktivität
+      [
+      Induktivität
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  inductor(
+                    "b1", 
+                  (0, 0), 
+                  (2, 0),
+                  variant: "ieee"
+                  ) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
+      // Kapazität
+      [
+      Kapazität
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  capacitor(
+                    "b1", 
+                  (0, 0), 
+                  (2, 0)
+                  ) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
+      // Kurzschluss
+      [
+      Kurzschluss
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  capacitor(
+                    "b1", 
+                  (0, 0), 
+                  (2, 0)
+                  ) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
+      // Leerlauf
+      [
+      Leerlauf
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  capacitor(
+                    "b1", 
+                  (0, 0), 
+                  (2, 0)
+                  ) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
+      // Nullator
+      [
+      Nullator
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  capacitor(
+                    "b1", 
+                  (0, 0), 
+                  (2, 0)
+                  ) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
+      // Norator
+      [
+      Norator
+      #scale(x: 100%, y: 100%,
+        zap.circuit({
+          import zap : *
+          import cetz.draw : line, content
+                  capacitor(
+                    "b1", 
+                  (0, 0), 
+                  (2, 0)
+                  ) 
+      }))      
+      ],
+      [
+
+      ],
+      [
+        
+      ],
+
 
     );
     
@@ -886,7 +1226,7 @@
     [],
     [
       $Phi(t) = L dot i(t)$\
-      $u(t) = C dot (d i)/(d t)$\
+      $u(t) = L dot (d i)/(d t)$\
       $[L] = H = unit("V s") / unit("A")$
     ],
     [
@@ -920,11 +1260,6 @@
     )
   ]
 
-  #bgBlock(fill: colorAllgemein)[
-    #subHeading(fill: colorAllgemein)[Complex Zahlen]
-
-  ]
-
   // Complex AC
   #bgBlock(fill: colorComplexAC)[
     #subHeading(fill: colorComplexAC)[Komplex Wechselstrom Rechnnung]
@@ -953,6 +1288,30 @@
     $
   ]
 
+  // AC Components
+  #bgBlock(fill: colorComplexAC)[
+    #subHeading(fill: colorComplexAC)[Komplexe Komponent]
+    #table(
+      columns: (1fr, 2fr, 2fr, 2fr),
+      fill: (x, y) => if calc.rem(y, 2) == 1 { tableFillLow } else { tableFillHigh },
+      [], [*$Y = U/I$*], [*$Z = I/U$*], [*$phi$*],
+      [], [*$Omega$*], [*$S$*], [*rad*],
+      zap.circuit({
+        import zap : *
+        resistor("R", (0, 0), (0.6, 0), width: 3mm, height: 2mm, fill: none)
+      }), $R$, $1/G = R$, $0$,
+
+      zap.circuit({
+        import zap : *
+        capacitor("R", (0, 0), (0.6, 0), width: 4mm, height: 6mm, fill: none)
+      }), $1/(j w C)$, $j w C$, $-pi/2$,
+      zap.circuit({
+        import zap : *
+        inductor("R", (0, 0), (0.6, 0), width: 4mm, height: 2mm, fill: none, variant: "ieee")
+      }), $j w L$, $1/(j w L)$, $pi/2$
+    )
+  ]
+
   #bgBlock(fill: colorComplexAC)[
     #subHeading(fill: colorComplexAC)[*Levi's Lustig Leistung*]
 
@@ -961,15 +1320,17 @@
     #table(
       columns: (auto, 1fr, auto),
       fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else { tableFillHigh },
-      [Scheinleitsung], [$(P_s =) space abs(underline(S))$], [$["VA"]$],
-      [Wirkleistung], [$(P_w =) space P = "Re"{} $], [$["W"]$],
-      [Blindleistung], [$(P_b =) space Q = "Im"{}$], [$["var"]$]
+      [Scheinleitsung], [$S = abs(P)$], [$["VA"]$],
+      [Wirkleistung], [$P_w = "Re"{P} $], [$["W"]$],
+      [Blindleistung], [$P_b = "Im"{P}$], [$["var"]$]
     )
 
     Bei Wiederstand: $R$
 
     $P_w = U_m^2 / 2R = (I_m^2 R)/2$
 
+    $P = 1/2 U I^* = 1/2 abs(U)^2 Y^* = 1/2 abs(I)^2 Z^*$
+
     $U_"eff" = U_m/sqrt(2), I_"eff" = I_m / sqrt(2)$
   ]
 
@@ -991,10 +1352,124 @@
 
 #pagebreak()
 
+#bgBlock(fill: colorZweiTore, width: 100%)[
+  #subHeading(fill: colorZweiTore)[Zwei-Tor-Übersichts]
+
+  #table(
+    fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillHigh } else { tableFillLow },
+    columns: (auto, auto, auto, 1fr, 1fr, 1fr),
+    [*Name*],
+    [*Schaltbild*], 
+    [*Ersatz-Schaltbild*], 
+    [*Eigenschaften*], 
+    [*Beschreibung*], 
+    [*Knotenspannungs Analyse*],
+    
+    [Nullor],
+    [],
+    [],
+    [],
+    [$A = mat(0, 0; 0, 0)$],
+    [],
+
+    [OpAmp \ lin],
+    [],
+    [],
+    [],
+    [],
+    [],
+
+    [OpAmp \ $U_"sat+"$],
+    [],
+    [],
+    [],
+    [],
+    [],
+
+    [OpAmp \ $U_"sat-"$],
+    [],
+    [],
+    [],
+    [],
+    [],
+
+    [VCVS],
+    [],
+    [],
+    [],
+    [$H' = mat(0, 0; mu, 0) quad A = mat(1/mu 0; 0, 0)$],
+    [],
+
+    [VCCS],
+    [],
+    [],
+    [], 
+    [$G = mat(0, 0; g, 0) quad A = mat(0, -1/g; 0, 0)$],
+    [],
+
+    [CCVS],
+    [],
+    [],
+    [],
+    [$R = mat(0, 0, r, 0) quad A = mat(0, 0; 1/r, 0)$],
+    [],
+
+    [CCCS],
+    [],
+    [],
+    [],
+    [$H = mat(0, 0; beta, 0) quad A = mat(0, 0; 0, -1/beta)$],
+    [],
+
+    [Übertrager],
+    [],
+    [],
+    [],
+    [],
+    [],
+
+    [Gyrator],
+    [],
+    [],
+    [
+      - Antireziprok, Antisymetrisch
+      - Auch Positiv-Immitanz-Inverter
+    ],
+    [$R = mat(0, -R_d; R_d, 0) quad G = mat(0, G_d; -G_d, 0) \ A = mat(0, R_d; 1/R_d, 0) quad A' = mat(0, -R_d; -1/R_d, 0)$],
+    [],
+
+    [NIK],
+    [],
+    [],
+    [],
+    [
+      - Akitv
+      - Antireziprok
+      - Symetrisch für $abs(k) = 1$
+    ],
+    [$H = mat(0, -k; -k, 0) quad H' = mat(0, -1/k; -1/k, 0); A = mat(-k, 0; 0, 1/k) quad A'= mat(-1/k, 0; 0, k)$],
+
+    [T-Glied],
+    [],
+    [],
+    [],
+    [
+
+    ],
+    [],
+
+    [$pi$-Glied],
+    [],
+    [],
+    [
+
+    ]
+  )
+]
+
+
 // Tor Eigenschaften
-#place(
-  bottom, float: true, scope: "parent",
-  bgBlock(fill: colorEigenschaften, width: 100%)[
+#bgBlock(fill: colorEigenschaften, width: 100%)[
   #subHeading(fill: colorEigenschaften)[Tor Eigenschaften]
 
   #table(
@@ -1082,9 +1557,7 @@
     [$det(M) != 0$, Alle Eintrag $!= 0$]
   )
 ]
-)
 
-#place(bottom+left, scope: "parent", float: true)[
 #bgBlock(fill: colorZweiTore)[
   #set text(size: 10pt)
 
@@ -1179,4 +1652,3 @@
     
     )
 ]
-]

src/lib/common_rewrite.typ

@@ -1,4 +1,4 @@
-#let bgBlock(body, fill: color, width: 100%) = block(body, fill:fill.lighten(80%), width: width, 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,7 +6,7 @@
 }
 
 #let subHeading(body, fill: color) = {
-  box(
+  move(dx: -2mm, dy: 0mm, box(
     align(
       top+center,
       text(
@@ -17,10 +17,10 @@
       )
     ),
     fill: fill,
-    width: 100%,
+    width: 100% + 4mm,
     inset: 1mm,
     height: auto
-  )
+  ))
 }
 
 #let MathAlignLeft(e) = {
@@ -58,14 +58,16 @@
 #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^(phi #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 b >= 0,
-    - arccos(a/r) space : space b < 0,
+    + arccos(a/r) space : space a >= 0,
+    - arccos(a/r) space : space a < 0,
   )$
 ]