271 lines
6.3 KiB
Python
271 lines
6.3 KiB
Python
# --- Aus P1 ---
|
|
import math
|
|
|
|
ELEMENTS = []
|
|
N = 50 # länge eines Codeworts
|
|
EOF = "$"
|
|
|
|
|
|
class Element:
|
|
id = ""
|
|
count = 0
|
|
p_x_i = 0
|
|
I_x_i = 0
|
|
|
|
def __init__(self, id):
|
|
self.id = id
|
|
self.count = 1
|
|
|
|
|
|
def find_element(list, target_it):
|
|
for i, element in enumerate(list):
|
|
if element.id == target_it:
|
|
return i, element
|
|
return None, None
|
|
|
|
|
|
def read_text_file():
|
|
path = './text.txt'
|
|
|
|
with open(path, 'r', encoding='utf-8') as file:
|
|
content = file.read()
|
|
return content
|
|
|
|
|
|
def Z_statistik(message):
|
|
global ELEMENTS
|
|
m = len(message)
|
|
|
|
for char in message:
|
|
i, entry = find_element(ELEMENTS, char)
|
|
if entry is not None:
|
|
entry.count += 1
|
|
else:
|
|
ELEMENTS.append(Element(char))
|
|
|
|
h = 0
|
|
for element in ELEMENTS:
|
|
element.p_x_i = element.count / m
|
|
element.I_x_i = -1 * math.log2(element.p_x_i)
|
|
h += element.p_x_i * element.I_x_i
|
|
|
|
# Ausgabe
|
|
ELEMENTS.sort(key=lambda element: element.count, reverse=True)
|
|
|
|
|
|
# --- Aus P1 ---
|
|
|
|
def binary_to_decimal(nkst_bits):
|
|
result = 0.0
|
|
for i, bit in enumerate(nkst_bits):
|
|
if bit == '1':
|
|
result += 2 ** (-(i + 1))
|
|
return result
|
|
|
|
|
|
def decimal_to_binary(decimal_val, n_bits, min_val, max_val):
|
|
nkst_bits = []
|
|
val = decimal_val
|
|
|
|
for _ in range(n_bits):
|
|
val *= 2
|
|
if val >= 1:
|
|
nkst_bits.append('1')
|
|
val -= 1
|
|
else:
|
|
nkst_bits.append('0')
|
|
|
|
converted_val = binary_to_decimal(nkst_bits)
|
|
|
|
# !!! Führt bei zu kleinen Intervallen zu Ungenauigkeiten
|
|
if not (min_val <= converted_val < max_val):
|
|
if nkst_bits[-1] == '1':
|
|
nkst_bits[-1] = '0'
|
|
else:
|
|
nkst_bits[-1] = '1'
|
|
|
|
return "".join(nkst_bits)
|
|
|
|
|
|
def calc_bit_count(block):
|
|
p = 1
|
|
for char in block:
|
|
i, element = find_element(ELEMENTS, char)
|
|
p *= element.p_x_i
|
|
|
|
N = math.ceil(-math.log(p, 2))
|
|
return N
|
|
|
|
|
|
def calc_intervalls():
|
|
global INTERVALLS
|
|
current_limit = 0
|
|
for element in ELEMENTS:
|
|
new_limit = current_limit + element.p_x_i
|
|
current_limit = new_limit
|
|
INTERVALLS.append(new_limit)
|
|
|
|
|
|
def calc_block_size():
|
|
last_element = ELEMENTS[-2]
|
|
block = []
|
|
|
|
while True:
|
|
tmp = block.copy()
|
|
tmp.append(last_element.id)
|
|
if calc_bit_count(tmp) <= N:
|
|
block.append(last_element.id)
|
|
else:
|
|
break
|
|
|
|
return len(block)
|
|
|
|
|
|
def create_blocks(message):
|
|
blocks = []
|
|
block = []
|
|
block_size = calc_block_size()
|
|
|
|
for i in range(0, len(message), block_size):
|
|
block = message[i:i + block_size]
|
|
blocks.append(block)
|
|
|
|
return blocks
|
|
|
|
|
|
def create_code_word(block, verbose=False):
|
|
current_low = 0.0
|
|
current_high = 1.0
|
|
|
|
for position, char in enumerate(block):
|
|
target_element = find_element(ELEMENTS, char)
|
|
|
|
if target_element is None:
|
|
return None
|
|
|
|
# Erstelle Intervalle für aktuelle Position
|
|
char_intervals = []
|
|
current_range = current_high - current_low
|
|
low = current_low
|
|
|
|
for element in ELEMENTS:
|
|
# Intervall für dieses Zeichen: [low, high)
|
|
high = low + current_range * element.p_x_i
|
|
char_intervals.append((element.id, (low, high)))
|
|
low = high
|
|
|
|
# Finde das Intervall für das aktuelle Zeichen
|
|
found_interval = None
|
|
for element_char, interval in char_intervals:
|
|
if element_char == char:
|
|
found_interval = interval
|
|
break
|
|
|
|
if found_interval is None:
|
|
return None
|
|
|
|
interval_low, interval_high = found_interval
|
|
current_low = interval_low
|
|
current_high = interval_high
|
|
|
|
final_value = current_low + (current_high - current_low) / 2
|
|
binary_representation = decimal_to_binary(final_value, N, current_low, current_high)
|
|
|
|
return binary_representation
|
|
|
|
|
|
def decode_single_block(decimal_value, max_chars=N):
|
|
if not ELEMENTS:
|
|
return None
|
|
|
|
decoded_chars = []
|
|
current_value = decimal_value
|
|
|
|
for position in range(max_chars):
|
|
char_intervals = []
|
|
low = 0.0
|
|
|
|
for element in ELEMENTS:
|
|
high = low + element.p_x_i
|
|
char_intervals.append((element.id, (low, high)))
|
|
low = high
|
|
|
|
found_char = None
|
|
found_interval = None
|
|
|
|
for char, interval in char_intervals:
|
|
interval_low, interval_high = interval
|
|
if interval_low <= current_value < interval_high:
|
|
found_char = char
|
|
found_interval = interval
|
|
break
|
|
|
|
# Spezialfall: Wert liegt genau auf der oberen Grenze des letzten Intervalls
|
|
if found_char is None and current_value == 1.0:
|
|
found_char = char_intervals[-1][0]
|
|
found_interval = char_intervals[-1][1]
|
|
|
|
if found_char is None or found_char == EOF:
|
|
break
|
|
|
|
decoded_chars.append(found_char)
|
|
|
|
interval_low, interval_high = found_interval
|
|
interval_range = interval_high - interval_low
|
|
|
|
if interval_range == 0:
|
|
break
|
|
|
|
# Normalisierung: Transformiere den Wert vom aktuellen Intervall auf [0, 1)
|
|
current_value = (current_value - interval_low) / interval_range
|
|
|
|
return ''.join(decoded_chars)
|
|
|
|
|
|
def AC_Decoder(code):
|
|
decoded = ""
|
|
l = calc_block_size()
|
|
|
|
for i in range(0, len(code), N):
|
|
if i + N > len(code):
|
|
block = code[i:]
|
|
else:
|
|
block = code[i:i + N]
|
|
|
|
decoded += decode_single_block(binary_to_decimal(block), l)
|
|
|
|
return decoded
|
|
|
|
|
|
def AC_Encoder(message):
|
|
Z_statistik(message)
|
|
|
|
blocks = create_blocks(message)
|
|
|
|
code = ""
|
|
|
|
for block in blocks:
|
|
code += create_code_word(block)
|
|
|
|
return code
|
|
|
|
|
|
def main():
|
|
message = read_text_file()
|
|
|
|
encoded = AC_Encoder(message)
|
|
decoded = AC_Decoder(encoded)
|
|
|
|
print(decoded)
|
|
|
|
print(f"Original: {len(message)} Zeichen = {len(message) * 8} Bits")
|
|
print(f"Komprimiert: {len(encoded)} Bits")
|
|
print(f"Maximale Blockgröße: {calc_block_size()}")
|
|
print(f"Anzahl verschiedener Zeichen: {len(ELEMENTS)}")
|
|
print(f"Zweitseltenste: '{ELEMENTS[-2].id}' kommt {ELEMENTS[-2].count}x vor")
|
|
|
|
print(f"\nIst die Nachricht richtig en- & dekodiert worden? {message[:-1] == decoded}")
|
|
|
|
|
|
main()
|