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(
+        *Rezept Diagonalisierung*
-            columns: (1fr, 1fr),
+
-            $D = mat(
+        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, ...;
+                Basiswechselmatrix: $R$
-                0, 0, lambda_2^n, ...;
+                $mat(
-                dots.v, dots.v, dots.v, dots.down
+                    |, | , ..., |;
+                    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 \
+        $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

@@ -1226,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")$
     ],
     [
@@ -1288,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*]
 
@@ -1296,9 +1320,9 @@
     #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$

src/lib/common_rewrite.typ

@@ -67,7 +67,7 @@
   $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,
   )$
 ]