bsc und p_k_fehler

P2/main.py

@@ -1,32 +1,34 @@
+import random
+import matplotlib.pyplot as plt
+
+
 # Linear Feedback Shift Register
 class LFSR:
     def __init__(self, poly):
-        self.g = []     # mapping von g g[x] == g_x
-        self.reg = []   # Register mit dem Zustand
+        # LSB -> MSB
+        self.g = []
+        self.reg = []
 
-        for ziffer in poly:
+        '''
+        poly = str(n, n-1, ..., 0) => g = [0, ..., n-1]
+                   0, 1, ..., -1
+
+        [-1:0:-1] = von(inkl.):bis(exkl.):Schritt => [Ende:Anfang[
+        '''
+        for ziffer in poly[-1:0:-1]:
             self.reg.append(0)
             self.g.append(int(ziffer))
 
-        # poly = str(n, n-1, ..., 0) => g = [0, ..., n-1, n]
-        self.g.reverse()
-        self.reg.reverse()
-
-        # Entferne den letzten Eintrag, da dieser den Grad darstellt => Anzahl der Register = len(g) - 1
-        self.g.pop()
-        self.reg.pop()
-
-
     def get_reg_as_string(self):
         reg_string = ""
 
         for i in self.reg:
-            reg_string = reg_string + str(i)
+            reg_string += str(i)  # LSB -> MSB
 
         return reg_string
 
     def shift(self, s_i):
-        reg_old = self.reg.copy()           # alter Zustand, um überschreibungen zu vermeiden
+        reg_old = self.reg.copy()  # alter Zustand, um überschreibungen zu vermeiden
 
         feedback = reg_old[-1] ^ int(s_i)
 
@@ -40,26 +42,73 @@ class LFSR:
                     self.reg[i] = reg_old[i - 1]
 
 
-def CRC_Parity(daten, g):
+def CRC_Parity(s, g):
     schiebe_reg = LFSR(g)
 
-    for s in daten:
-        schiebe_reg.shift(s)
+    # LSB -> MSB => MSB -> LSB
+    for s_i in s[::-1]:
+        schiebe_reg.shift(s_i)
 
     return schiebe_reg.get_reg_as_string()
 
 
 def channel_bsc(p, n):
-    F = 0b0
-    '''
-    berechne Fehlersequenz F
-    Achte auf Bedingung
-    '''
-    return F
+    f = ""
+
+    for i in range(n):
+        p_i = random.random()
+        # p_i <= p ? F += "1" : F += "0"
+        f += "1" if p_i <= p else "0"
+
+    return f
 
 
 def p_k_Fehler(p):
+    # P_k = (nCk) * p^k * (1-p)^(n-k)
     n = 1000
+    p_k = []
+    k_values = list(range(1, n + 1))
+
+    for k in k_values:
+        nCk = 1
+        for i in range(1, k + 1, 1):
+            nCk = nCk * ((n + 1 - i) / i)
+
+        # p_k = (nCk) * p^k * (1-p)^(n-k)
+        p_k.append(nCk * pow(p, k) * pow((1 - p), (n - k)))
+
+    plt.figure(figsize=(12, 8))
+    plt.plot(k_values, p_k)  # plot(x,y)
+
+    # Achsenbeschriftung
+    plt.xlabel('k (Anzahl Fehler)', fontsize=12)
+    plt.ylabel('p_k', fontsize=12)
+    plt.title(f'Fehlerwahrscheinlichkeiten BSC Kanal (p={p}, n={n})', fontsize=14)
+
+    # Grid
+    plt.grid(True, alpha=0.3)
+
+    # Zeige Plot
+    plt.tight_layout()  # Besseres Layout
+    plt.show()
 
 
 def main():
+    p = 0.1
+
+    # LSB -> MSB
+    s = "110011101100101"
+
+    # MSB -> LSB
+    g = "100101"
+
+    prf = CRC_Parity(s, g)
+    print(prf)
+
+    print(channel_bsc(p, 15))
+
+    p_k_Fehler(p)
+
+
+if __name__ == '__main__':
+    main()