72 lines
2.9 KiB
Plaintext
72 lines
2.9 KiB
Plaintext
###############################################################################
|
|
########################## README Datei zu packen.tri ############################
|
|
###############################################################################
|
|
|
|
Inhalt
|
|
======
|
|
|
|
1. Autor des Programmes
|
|
|
|
2. Funktion des Programmes
|
|
|
|
3. Bedienung des Programmes
|
|
|
|
4. Ablauf des Programmes
|
|
|
|
###############################################################################
|
|
|
|
1. Autor: Fabian Marx
|
|
|
|
###############################################################################
|
|
|
|
2. Funktion des Programms
|
|
|
|
Meine Idee war es ein kleines Packprogramm zu schreiben. Dies war allerdings
|
|
schwieriger als gedacht. Insbesondere musste ich in Triangle nicht vorhandene
|
|
Funktionen nachbauen (z.B. Bitströme). Herausgekommen ist ein Programm,
|
|
dass eine beliebig lange Datei (blockweise) einlesen kann, diese verarbeitet
|
|
und das Ergebnis in die Ausgabe schreibt.
|
|
|
|
###############################################################################
|
|
|
|
3. Bedienung des Programms
|
|
|
|
java TAM.Interpreter packen.tri < readme.txt > out.txt
|
|
|
|
|
|
################################################################################
|
|
|
|
4. Ablauf des Programms
|
|
|
|
Für die Eingabe-Datei steht ein Char-Array zur Verfügung,
|
|
in das 245 Byte eingelesen werden. Die Berechnung basiert auf 4-Bit-Codewörtern,
|
|
die aus den Chars mit low und high extrahiert werden.
|
|
|
|
Nur für den ersten Block wird dann folgendes ausgeführt:
|
|
1. Es werden alle 4-Bit-Codewörter gezählt. Dies war ursprünglich für die Berechnung
|
|
eines optimalen Huffmann-Codes gedacht. Der autmoatische Aufbau dieses Codes erwies
|
|
sich allerdings als zu kompliziert, so dass ich nun einen statischen Code benutze.
|
|
Diesen habe ich auf einem Blatt Papier erzeugt und die hier gezählten Häufigkeiten
|
|
der Codewörter (für verschiedene Dateien) als Basis genommen.
|
|
|
|
2. Um dennoch eine Optimierung in der Ausgabe zu erreichen, werden die Häufigkeiten
|
|
sortiert und es entsteht eine Abbildung eines Codewortes auf den statischen
|
|
Huffmann-Code (schließlich im array code). So wird ein optimaler Huffmann-Code
|
|
approximiert.
|
|
|
|
3. Diese Abbildung wird nun als erstes in die Ausgabe geschrieben.
|
|
|
|
Nun beginnt die Verarbeitung jedes Eingabeblocks, indem die Code-Wörter jedes Chars
|
|
mit low und high ausgelesen werden und mit writeBits der entsprechende Huffmann-code
|
|
geschrieben wird. Zu bemerken ist dabei, dass die Prozedur putBit wie ein Bit-Buffer
|
|
aggiert und ein char mittels put schreibt, sobald sich 8 Bit angesammelt haben.
|
|
|
|
Mittels einer while-Schleife wird der Vorgang wiederholt, bis eof erreicht ist.
|
|
Die gesamte Eingabe-Datei wurde so blockweise verarbeitet.
|
|
|
|
Das Ergebniss der ganzen Prozedur hängt aber sehr stark von der Eingabedatei ab.
|
|
Am besten funktionieren natürlich Textdateien.
|
|
|
|
Nähere Beschreibungen finden sich in den Kommentierungen des Quelltextes.
|
|
|
|
########################################################################## |