105 lines
3.2 KiB
Python
105 lines
3.2 KiB
Python
import math
|
|
|
|
|
|
def Q_statistik():
|
|
with open('Text.txt', 'r', encoding='utf-8') as file:
|
|
text = file.read()
|
|
|
|
freq = {}
|
|
for char in text:
|
|
if char in freq:
|
|
freq[char] += 1
|
|
else:
|
|
freq[char] = 1
|
|
|
|
total_chars = sum(freq.values())
|
|
|
|
prob = {}
|
|
info_content = {}
|
|
entropy = 0
|
|
|
|
for char, count in freq.items():
|
|
prob[char] = count / total_chars
|
|
info_content[char] = -math.log2(prob[char])
|
|
entropy += prob[char] * info_content[char]
|
|
|
|
return freq, prob, info_content, entropy
|
|
|
|
|
|
def fano_encoder(probabilities):
|
|
# Key = probability im Dictionary
|
|
sorted_probs = sorted(probabilities.items(), key=lambda x: x[1], reverse=True)
|
|
|
|
def fano_recursive(symbols):
|
|
if len(symbols) == 1: # Keine neuen Teilmengen möglich
|
|
return {symbols[0][0]: ""}
|
|
|
|
total = sum([symbol[1] for symbol in symbols])
|
|
acc = 0
|
|
split_index = 0
|
|
for i in range(len(symbols)):
|
|
acc += symbols[i][1]
|
|
if acc >= total / 2:
|
|
split_index = i
|
|
break
|
|
|
|
left_symbols = symbols[:split_index + 1]
|
|
right_symbols = symbols[split_index + 1:]
|
|
|
|
left_codes = fano_recursive(left_symbols)
|
|
right_codes = fano_recursive(right_symbols)
|
|
|
|
for key in left_codes:
|
|
left_codes[key] = '0' + left_codes[key]
|
|
for key in right_codes:
|
|
right_codes[key] = '1' + right_codes[key]
|
|
|
|
left_codes.update(right_codes)
|
|
return left_codes
|
|
|
|
return fano_recursive(sorted_probs)
|
|
|
|
|
|
def Q_Fanoencoder(input_path='Text.txt', output_path='EncodedText.txt'):
|
|
_, probabilities, _, _ = Q_statistik()
|
|
fano_codes = fano_encoder(probabilities)
|
|
|
|
with open(input_path, 'r', encoding='utf-8') as file:
|
|
text = file.read()
|
|
|
|
encoded_text = ''.join([fano_codes[char] for char in text])
|
|
|
|
with open(output_path, 'w', encoding='utf-8') as file:
|
|
file.write(encoded_text)
|
|
|
|
return text, encoded_text, fano_codes
|
|
|
|
|
|
def calculate_compression_rate(original_text, encoded_text, fano_codes):
|
|
original_length_bits = len(original_text) * 8
|
|
encoded_length_bits = len(encoded_text)
|
|
code_table_bits = sum([len(code) for code in fano_codes.values()]) * 8 + len(fano_codes) * 8
|
|
total_encoded_bits = encoded_length_bits + code_table_bits
|
|
compression_rate = (original_length_bits - total_encoded_bits) / original_length_bits * 100
|
|
|
|
return original_length_bits, total_encoded_bits, compression_rate
|
|
|
|
|
|
def main():
|
|
frequencies, probabilities, information_content, entropy = Q_statistik()
|
|
print("Häufigkeiten:", frequencies)
|
|
print("Wahrscheinlichkeiten:", probabilities)
|
|
print("Informationsgehalt:", information_content)
|
|
print("Entropie:", entropy)
|
|
original_text, encoded_text, fano_codes = Q_Fanoencoder()
|
|
original_length_bits, total_encoded_bits, compression_rate = (
|
|
calculate_compression_rate(original_text, encoded_text, fano_codes)
|
|
)
|
|
print(f"Originale Länge in Bits: {original_length_bits}")
|
|
print(f"Gesamte codierte Länge in Bits (inkl. Codetabelle): {total_encoded_bits}")
|
|
print(f"Kompressionsrate: {compression_rate:.2f}%")
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|