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,32 +332,33 @@
         #subHeading(fill: colorMatrixVerfahren)[Diagonalisierung]
         $A = R D R^(-1)$
 
-        #grid(
-            columns: (1fr, 1fr),
-            $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
-            )$
-        ) \
-
         *Rezept Diagonalisierung*
 
-        1. *EW* bestimmen
+        1. EW bestimmen: $det(A - lambda I) = 0$  \
-        2. $chi_A$ bestimmen und in $(lambda_0 - lambda)^(n_0) dot (lambda_1 - lambda)^(n_1) ...$ Form bringen \
+            $=> chi_A = (lambda_1 - lambda)^(m 1) (lambda_2 - lambda)^(m 2) ...$ 
-            $chi_A$ nicht vollstandig zerfällt (in $RR$), $=>$ NICHT diagonalisierbar
+        2. EV bestimmen: $spann(kern(A - lambda_i I))$: $r_0, r_1, ...$
-        3. *EV* bestimmen
+        3. \
-        4. $R = mat( bar, bar, ..; v_(lambda 0), v_(lambda 1), ...; bar, bar, ...)$
+            #grid(columns: (1fr, 1fr),
-        5. $R^(-1)$ bestimmen 
+            [
-    ]
+                Diagnoalmatrix: $D$
+                $mat(
+                        lambda_1, 0, 0,...;
+                        0, lambda_1, 0, ...;
+                        0, 0, lambda_2, ...;
+                        dots.v, dots.v, dots.v, dots.down
+                    )
+                $
+            ],
+            [
+                Basiswechselmatrix: $R$
+                $mat(
+                    |, | , ..., |;
+                    r_0, r_1, ..., r_n;
+                    |, |, ..., |
+                )$
+            ]
+        )
+     ]
 
 
     #bgBlock(fill: colorMatrixVerfahren)[
@@ -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 \
+        $L in RR^(m times m)$ Orthogonal \
-        $Sigma in RR^(m times n)$ Diagonal \
+        $S in RR^(m times n)$ Diagonal \
-        $V in RR^(n times n)$ Orthogonal
+        $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$ \
+        2. $A A^T$ diagonalisieren in $R$, $D$
-            $lambda_0, lambda_1 ... lambda_k$ nach Größe sortieren \
-            Singulärewerte: $sigma_i = sqrt(lambda_i)$
 
-        3. Eigenvekoren von $A^T A$ bestimmen und *Normalisieren*
+        3. Singulärwere berechen: $sigma_i = sqrt(lambda_i) $
-            $v_(lambda 0), v_(lambda 1), ... v_(lambda k)$ 
         
-        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; |, |, ..., |)$ \
+        5. $S in RR^(n times m)$ (wie $A$): \
-            (Evt. zu ONB ergenze mit Gram-Schmit/Kreuzprodukt)
-
-        6. $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"
 
@@ -371,16 +373,354 @@
   #bgBlock(fill: colorEineTore)[
     #subHeading(fill: colorEineTore)[Bauelemente]
      #table(
-      columns: (1fr, 1fr, 1fr),
+      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"]$],
+      [Scheinleitsung], [$S = abs(P)$], [$["VA"]$],
-      [Wirkleistung], [$(P_w =) space P = "Re"{} $], [$["W"]$],
+      [Wirkleistung], [$P_w = "Re"{P} $], [$["W"]$],
-      [Blindleistung], [$(P_b =) space Q = "Im"{}$], [$["var"]$]
+      [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,192 +1352,303 @@
 
 #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(
+#bgBlock(fill: colorEigenschaften, width: 100%)[
-  bottom, float: true, scope: "parent",
+  #subHeading(fill: colorEigenschaften)[Tor Eigenschaften]
-  bgBlock(fill: colorEigenschaften, width: 100%)[
+
-    #subHeading(fill: colorEigenschaften)[Tor Eigenschaften]
+  #table(
+    columns: (auto, auto, auto, auto),
+    inset: 2mm,
+    align: horizon,
+    fill: (x, y) => if calc.rem(y, 2) == 1 { rgb("#c5c5c5") } else { white },
+
+    table.header([], [*Ein-Tor*], [*Zwei-Tor*], [*Reaktive Elemente*]),
+    [*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$]
+  )
+]
+
+#bgBlock(fill: colorZweiTore)[
+  #set text(size: 10pt)
+
+  #subHeading(fill: colorZweiTore)[Umrechnung Zweitormatrizen]
+    #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 },
+
+      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)$,
+      $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)$,
+      $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)$,
+      $1/a_12 mat(a_22, -det(bold(A)); -1, a_11)$,
+      $1/a'_12 mat(a'_11, -1; -det(bold(A')), a'_22)$,
+
+      $bold(H)$,
+      $1/r_22 mat(det(bold(R)), r_12; -r_21, 1)$,
+      $1/g_11 mat(1, -g_12; g_21, det(bold(G)))$,
+      $mat(h_11, h_12; h_21, h_22)$,
+      $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)$,
+      $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)$,
+
+      $bold(A)$,
+      $1/r_21 mat(r_11, det(bold(R)); 1, r_22)$,
+      $1/g_21 mat(-g_22, -1; -det(bold(G)), -g_11)$,
+      $1/h_21 mat(-det(bold(H)), -h_11; -h_22, -1)$,
+      $1/h'_21 mat(1, h'_22; h'_11, det(bold(H')))$,
+      $mat(a_11, a_12; a_21, a_22)$,
+      $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)$,
+      $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: (auto, auto, auto, auto),
+      columns: (12mm, 1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
-      inset: 2mm,
+      align: center,
-      align: horizon,
+      inset: (bottom: 4mm, top: 4mm),
-      fill: (x, y) => if calc.rem(y, 2) == 1 { rgb("#c5c5c5") } else { white },
+      gutter: 0.1mm,
+      fill: (x, y) => if x != 0 and calc.rem(x, 2) == 0 { rgb("#c5c5c5") } else { white },
 
-      table.header([], [*Ein-Tor*], [*Zwei-Tor*], [*Reaktive Elemente*]),
-      [*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$   
-      ],
       [],
+      $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)$,
     
-      [*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)[
-    #set text(size: 10pt)
-
-    #subHeading(fill: colorZweiTore)[Umrechnung Zweitormatrizen]
-      #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 },
-
-        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)$,
-        $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)$,
-        $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)$,
-        $1/a_12 mat(a_22, -det(bold(A)); -1, a_11)$,
-        $1/a'_12 mat(a'_11, -1; -det(bold(A')), a'_22)$,
-
-        $bold(H)$,
-        $1/r_22 mat(det(bold(R)), r_12; -r_21, 1)$,
-        $1/g_11 mat(1, -g_12; g_21, det(bold(G)))$,
-        $mat(h_11, h_12; h_21, h_22)$,
-        $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)$,
-        $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)$,
-
-        $bold(A)$,
-        $1/r_21 mat(r_11, det(bold(R)); 1, r_22)$,
-        $1/g_21 mat(-g_22, -1; -det(bold(G)), -g_11)$,
-        $1/h_21 mat(-det(bold(H)), -h_11; -h_22, -1)$,
-        $1/h'_21 mat(1, h'_22; h'_11, det(bold(H')))$,
-        $mat(a_11, a_12; a_21, a_22)$,
-        $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)$,
-        $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)$,
-      
-      )
-  ]
 ]

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 a >= 0,
-    - arccos(a/r) space : space b < 0,
+    - arccos(a/r) space : space a < 0,
   )$
 ]