Merge branch 'main' of gitea.mintcalc.com:alexander/TUM-Formelsammlungen

src/cheatsheets/Analysis1.typ

@@ -4,6 +4,8 @@
 #show math.integral: it => math.limits(math.integral)
 #show math.sum: it => math.limits(math.sum)
 
+#set text(7pt)
+
 #set page(
   paper: "a4", 
   margin: (

src/cheatsheets/Digitaltechnik.typ

@@ -0,0 +1,206 @@
+#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)
+
+#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]
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Timing]
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Latches und Register]
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Pipeline/Parallele Verarbeitungseinheiten]
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Zustandsautomaten]
+  ]
+]

src/cheatsheets/Schaltungstheorie.typ

@@ -4,6 +4,7 @@
 
 #set math.mat(delim: "[") 
 #show math.equation.where(block: true): it => math.inline(it)
+#set math.mat(delim: "[") 
 
 #set page(
   paper: "a4", 
@@ -66,7 +67,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(
@@ -81,6 +82,9 @@
 
       a in {-1, 0, 1}
     $
+
+    $-1$: In Knoten rein \
+    $1$: Aus Knoten raus \
     
     #line(length: 100%, stroke: (thickness: 0.2mm))
     
@@ -104,6 +108,9 @@
       b in {-1, 0, 1}
     $
 
+    $-1$: Gegen Maschenrichtung
+    $1$: In Maschenrichtung
+
     #line(length: 100%, stroke: (thickness: 0.2mm))
 
     *KCL und KVL* \
@@ -121,6 +128,10 @@
 
   #bgBlock(fill: colorAnalyseVerfahren)[
     #subHeading(fill: colorAnalyseVerfahren)[Baumkonzept]
+    KCLs: $n-1$\
+    KVLs: $b-(n-1)$
+    
+    Baum einzeichnen (Keine Schleifen!)
   ]
 
   #bgBlock(fill: colorAnalyseVerfahren)[
@@ -130,8 +141,6 @@
   #bgBlock(fill: colorAnalyseVerfahren)[
     #subHeading(fill: colorAnalyseVerfahren)[Reduzierte Knotenpotenzial-Analyse]
   ]
-
-  
 ]
 
 #pagebreak()