So,
ich hatte vorgestern her quasi aufgehört bei dem Bereich,
wo ich jetzt also gesagt habe,
was sind eigentlich nochmal so Anwendungen jetzt für diese Betweisen-Operationen,
also sprich das,
was dann also auf basierend auf der bultischen Algebra dann eigentlich an Rechenoperationen in den Programmiersprachen dann eben auch möglich ist,
wo man ja gesehen hat,
also für Java beziehungsweise 4C gibt es dann eben entsprechende Bultur-Operationen,
wo ich dann also wirklich jetzt
mit den Wahrheitswerten True und Falls
rechnen kann
Was man aber eben auch häufig macht,
da hatte ich also mal so ein kurzes Beispiel gegeben,
sind dann eben wirklich irgendwelche Operationen,
indem ich also quasi jetzt irgendwelche Zahlen quasi als 32-Bit string
interpretiere und dann in diesem Bitstring dann eben entsprechende Operationen mit den Bitweisen logischen Operationen mache.
Und eben so klassische Beispiele sind dann halt eben über solche Maskierungsoperationen,
Teile, einzelne Bits zu setzen bzw. einzelne Bits entsprechend
zu löschen
Wo man das dann eben braucht. Es sind also teilweise Anwendungen,
wo ich also quasi so was wie Statusinformation in so einem gesamten Statuswort packe.
Das wird uns allerdings auch eine Übersicht noch mal später bei dem Thema Assembler-Programmierung begegnen,
wo man zum Beispiel eben sieht,
in Intel XX680 Architekturen gibt es dann eben quasi einen größeren Statusregister
und da sind dann also quasi in diesem einen Status,
wo dann alle möglichen Informationen zu vorhergehenden Operationen durch den Prozess
so quasi abgespeichert
Anderes Beispiel, beziehungsweise drei andere Beispiele folgen jetzt noch gleich,
sind also Sachen,
wo man da also auch irgendwie sowas macht und vertauscht,
also hier auch original Beispiel aus dem Linux-Quellcode, Byteswap,
in Header-Datei, wobei, also inzwischen ist es distributionsabhängig,
sind diese Definitionen meistens woanders abgelegt,
aber letztendlich finden sich da die Verweise, was macht diese Funktion,
also das ist also im Prinzip hier dieser Ausdruck und was passiert,
ich habe also ein Argument X, 32 Bild breit.
Habe also quasi jetzt hier meine Indizes, 31, hier 0,
dann hätte ich hier 8. Blödsinn, 16 und diese wären dann 24, so.
Also im Prinzip sind es 32 Bitwort und was also hier passiert,
ist, dass ich quasi von diesem X einmal,
wie das also jetzt hier in diesem ersten Tal haben gemacht ist,
quasi das,
bitweise für Hunde mit so einer Maske aus FF und dann lauter Nullen,
FF und lauter Nullen heißt,
ich habe quasi hier alles mit eins gesetzt und hier alles mit Nullen gesetzt,
bit vises und heißt,
ich schneide quasi mit diesem Ausdruck
dieses oberste Byte aus
Und dahinter habe ich Lauternollen. So, das wird dann
um 24 Stellen mit einem Rechtsshift verschoben. Das heißt,
dieses Byte, wenn ich jetzt mal also mit 1,
2, 3, 4 durchnummeriere, landet an dieser Stelle,
nämlich ganz rechts.
So, der nächste Teilausdruck, wieder maskieren,
jetzt mit einer Maske, die hier einzeln hat.
Dann habe ich also quasi das zweite Byte ausgeschnitten,
wird um 8 geschoben
Landet demzufolge links davon und so weiter und so fort.
Das heißt, was ich hinterher habe,
ist 4-3-2-1. Das heißt,
diese Barts wurden in ihrer Reihenfolge einmal von links nach rechts quasi hier gespiegelt.
So, jetzt kann man sich natürlich fragen, was soll der Unsinn?
Wofür brauche ich das? Ist also nicht umsonst,
also irgendwo an den Stellen,
wo es dann also um so eine Bibliothek namens nett einnet geht.
Bei der Kommunikation übers Internet ist halt eben eine bestimmte Reihenfolge
in den Zahlendarstellungen vorgegeben
Weil was wir jetzt noch nicht weiter besprochen haben,
was also dann auch später nochmal,
auch nur mal kurz angesprochen wird, in diesem Zusammenhang,
aber was eigentlich so ein bisschen motivieren soll,
wofür man sowas braucht, ist die Tatsache,
wenn ich jetzt sage, okay,
ich habe hier ein 32-Bit-Wort und in der Regel wird bei den Computern irgendwelche,
wenn ich jetzt also irgendwelche Sachen aus dem Speicher adressiere,
passiert diese Adressierung quasi immer beidweise.
Das heißt also, ich kann jetzt wirklich mit einer Adresse immer ein einzelnes weit ansprechen.
Auf der anderen Seite habe ich aber irgendwo die Hardware,
wo ich also Speicherwort habe,
das heißt also im Hauptspeicher irgendwie so ein 32-Bit-String oder rein
technisch gesehen sind das also deutlich längeres Drinks, aber angenommen,
ich hätte jetzt also quasi einen 32-Bit-String im Hauptspeicher abgelegt,
dann ist eigentlich noch nicht klar, wo diese Bytes es auf aufeinanderfolgenden Speicheradressen sind.
Da kann man sagen, okay, es gibt Rechner beziehungsweise Betriebssysteme,
da werden die Speicheradressen quasi eins, zwei, drei,
vier, beziehungsweise dann 0-1,
3-3, In dieser Richtung durchnummeriert.
Und es gibt Rechner bzw. Betriebssysteme, da werden die so durchnummeriert,
dass ich sage, dass das mit der höheren Adresse steht links.
Das heißt, bei Zoom Wort hätte ich dann eigentlich 4-3, 2-1. So,
und wenn ich jetzt aber sage, ich möchte über Internetprotokoll,
also jetzt also irgendwie eine 32-Bit-Zahl, von dem Rechner jetzt hier,
also über irgendein Rautersystem auf irgendeinen Mac verschicken,
dann sollte es jetzt nicht sein,
dass die eine Rechnerarchitektur so rumzielt und die andere Architektur so rumzielt,
weil dann gehen natürlich sämtliche Zahlen und sämtliche Informationen kaputt
Deswegen gibt es da dann also quasi immer hardwarespezifisch, beziehungsweise festgelegt.
Also sowas, was also dann hier unten mit angedeutet ist,
nämlich also etwas, was sich Bite-Order nennt.
Und da gibt es dann die Unterscheidung, Little Andian,
Big Andian, also sprich zähle ich einmal so rum
oder zähle ich das an normal so rum.
Wie gesagt, das will ich später auch noch mal ganz kurz ein bisschen was zu sagen.
Bis innerhalb der Bite werden die dabei, wenn das kompliziert wird.
Die bleiben gleich. Also das ist immer das Gemeine,
dass man eigentlich immer sagt,
einerseits habe ich also irgendwie diese Bit-Reihenfolgen, in dem Wort,
das ist dann meistens technisch gesehen auch immer so festgelegt,
dass das am weitesten links stehende wird,
das höchstwertigste ist und das am weitesten rechts stehende, das niederwärtigste.
Aber wie gesagt, also auch mit dieser Byte-Adressierung,
was eigentlich motiviert ist, also durch die Hauptspeicheradressierung,
gibt es da so zwei unterschiedliche Systeme.
Und dann kann man sagen, das ist einfach irgendwie historisch so gewachsen,
andererseits für einen Datenaustausch, muss das dann irgendwo normiert werden.
Und deswegen gibt es dann eben immer solche Sachen, wo dann,
wenn ich jetzt also das Das ist ja das Schöne,
dass es für mich jetzt wieder transparent ist.
Wenn ich jetzt also hier irgendwelche Informationen, irgendwas übers Internet,
also für Sender auf einen anderen Rechner transferiere,
dann wird das quasi automatisch angepasst. Das heißt,
wenn ich das jetzt hier intern in der einen Reihenfolge quasi falsch sortiert hätte,
dann wird also quasi hier irgendwie sowas aktiv,
dass das quasi dann über so einen Byteswap einmal alles getauscht wird,
dann wird es versendet.
Und beim anderen Rechner wird dann quasi,
wenn die Information ankommt,
eben geguckt, entspricht der dieser Konvention oder muss es da
eben wieder zurückgetauscht werden
Und da müssen wir uns dann glücklicherweise nicht drum kümmern,
aber einfach nur mal, um zu zeigen,
wofür jetzt also zum Beispiel diese Bit-weisen,
Operationen und Maskierungen dann also auch immer ganz gerne genommen werden.
Achso, was ich hier jetzt noch nicht gesagt hatte,
also im Prinzip hier habe ich dann immer noch so ein Bit-vises.
Oder nicht, damit baue ich dann quasi aus diesen
einzelnen Teilen an, wie das Gesamtwort zusammen.
Also rein praktisch macht dieses Bard Swap,
also nichts anderes,
das aus sowas generiert
Anderes Beispiel, Farbbilddarstellung. Auch da macht man es ja oft so,
dass man sagt, na gut,
wenn ich das jetzt also nicht im irgendeinem super HDR-Format machen möchte,
genügen, sagen wir mal,
eigentlich so für normal praktische Anwendung immer Sachen,
dass ich sage, naja gut,
also irgendwie ein Bildpunkt oder ein Pixel in meinem Farbbild wird quasi durch drei Farbwerte,
RGB, rot, grün und Blauanteil quasi kodiert.
Für jeden Farbwert habe ich eben
quasi Intensitäten von 0 bis
Das heißt also, rot, grün und blau sind jeweils acht Bittzahlen.
Teilweise hat man dann noch so was wie transparenter Transparenz dabei.
Das ist dann das, was hier dann als Alpha-Kanal definiert oder beschrieben ist. So,
das heißt, um jetzt also irgendwelche Pixel, zum Beispiel,
also irgendwo in einem Bild, effizient zu speichern,
macht man das dann eben auch typischerweise so,
dass man das alles in 1,32-Bit-Wort verpackt und da jetzt nicht sagt,
ich habe jetzt für rot,
grün,
blau und Alpha
jeweils ein eigenes
Speicherwort, sondern ich habe eine, so eine 32-Bizza,
die interpretiere ich aber quasi als 8-Bit-Alpha-Kanal, 8 bedroht,
8 Grip mit Grün, 8 mit Blau.
Nicht, also das gibt es also relativ häufig,
ist teilweise auch in irgendwelchen Bibliotheken, wie also da unten angedeutet,
wenn ich jetzt in diese Imagebibliothek von Java da dann also auch irgendwie so mit drin vordefiniert und dann also auch mit irgendwelchen schicken Funktionen.
Und wenn ich jetzt also Mir beispielsweise irgendwas machen möchte,
dass ich also einen Rotfilter mache,
also sprich den Rotanteil aus einem Bild,
also sprich diese Barziehung irgendwie rausnehmen möchte,
könnte man das dann eben so machen,
dass ich also im Prinzip das Bild sei jetzt also hier abgespeichert als ein zweidimensionales Array,
das wird also quasi mit diesen zwei ineinander geschachtelten Vorschleifen so zahlenweise durchlaufen und dann lese ich quasi also auf diesen Integer dann also einmal das Pixel an dieser Position,
X und Y, wo ich jetzt quasi gerade bin.
Anschließend wird das dann eben mit so einer entsprechenden Maske einer maskiert,
dass nämlich quasi dieses Rot ausgeblendet wird und dann wird das
eben quasi in irgendein Ausgabestream bzw. irgendeine Datenstruktur für die Ausgabe zugewiesen nicht.
Und damit habe ich dann also auch gezielt,
also an dieser einen Stelle das ausgeblendet.
Und auch das sind da, sagen wir mal,
so klassische Beispiele,
wo man also mit diesen Maskierungen bzw. wird weise eine Operation
dann irgendwie was macht
Ähnliches, Graufilter. Nicht Grundverfahren ist genau das Gleiche.
Ich lese hier so ein Einzelnes, ein einzelnes Pixel raus.
Das ist dann also im Prinzip dieses hier und anschließend werden dann also quasi auch über entsprechende Maskierungen,
Rot, Grün und Blauanteile dann also entsprechend raus gefiltert und mit diesem Schieben erreiche ich dann eben,
dass ich letztendlich dann jeweils für Rot,
Grün und Blau ganz normale Enterger-Zahlen zwischen 0 und 255 habe,
jeweils als 1 und 32, Bit, Wert,
Red Green bzw. Blut dann gespeichert.
Nicht, die werden dann noch einmal gemittelt, also sprich,
was hier in dieser Zeile ist, aufsummieren und durch drei teilen.
Das ist dann quasi mein durchschnittlicher Helligkeitswert. Ja,
und jetzt muss ich daraus quasi wieder irgendeinen Grauwert machen.
Wenn ich jetzt als Bildformat sowas wie RG und B habe,
muss ich also quasi diesen Wert sowohl für Rot, sowohl für Rot,
grün, als auch für Blau, letztendlich irgendwie abspeichern.
Und genau das ist das, was dann also hier in dieser Zeile passiert,
nämlich also einmal dieses hier gar nicht verschoben ist,
dann quasi der Blauanteil,
um acht Bit nach links verschoben wäre dann der Grünanteil,
um 16 Bit nach links verschoben, der Rotanteil.
Und wenn ich also jetzt irgendwie einen Wert von,
meinetwegen 63 ausgerechnet hätte,
würde der dann also quasi sowohl hier hier als auch hier stehen in diesem Ausdruck,
der da gebildet wird und das Ich werde dann also quasi
von der Bildwiedergabe dann eben entsprechend als ein Grau mit der Helligkeit 63 dann eben ausgegeben werden.
Andere Sache, wo man also auch relativ viel mit diesen Biddweisen-Operationen arbeitet,
sind dann solche Sachen, wo, wie hier jetzt also quasi was,
ein Bitcount berechnet wird.
Das sind also jetzt Teile oder Algorithmen, wo ich jetzt sage,
ich habe, also hier sind 32 Bitwort oder überhaupt jetzt irgendein Wort,
also Wortlänge sei erstmal egal.
Und ich möchte in diesem Wort dann also irgendwann errechnen
oder auszählen, wie viele Einsen gesetzt sind.
Das wird uns im nächsten Kapitel dann teilweise noch begegnen,
wenn es dann also um die Codierung, nee,
das wird dann übernächstes Kapitel.
Wenn es dann also im Prinzip um die Codierung geht,
beziehungsweise teilweise ein Algorithmen,
die dann also auch für die Kryptologie benötigt werden,
den sogenannten Hemmingabstand
Da hat man also das relativ häufig, dass ich einfach wissen muss,
in so einem Wort, wie viele Einsen sind da drin.
So, vergleichsweise einfache oder triviale Lösung ist, wäre dann
also dieser Algorithmus, der quasi hier mit drin ist.
Ich habe einen Zähler, der wird mit null initialisiert.
Ich habe eine Schleife, die wird halt so lange durchlaufen,
wie die Zahl x und leicht null ist,
weil wenn die gleich null ist,
dann sind da keine Einsen mehr drin,
dann brauche ich die nicht weiter zu untersuchen.
Und ansonsten wird der Zähler quasi inkrementiert,
beziehungsweise wird zu dem Zähler was hinzugezählt und das,
was hinzugezählt wird, ist quasi x maskiert mit dem Hexer dezimalwert,
der also nur hier an der allerletzten Stelle eine Eins gesetzt hat.
So, wenn in dem X an der Stelle eine Eins ist,
verwundet, habe ich also auch eine Eins.
Als Ergebnis an genau dieser Stelle interpretiert als Zahl,
ist das auch eine Integer-Zahl 1,
die wird dann eben zur Count hinzu addiert.
Nicht deswegen funktioniert hier diese Operation mit dem AFA drauf erzählen.
Wenn ich an dieser Stelle eine Null gehabt habe,
und das wird mit dieser Maske 1 quasi verwundet,
habe ich als Ergebnis eine Null,
dann wird da also
plus Null gerechnet
So, anschließend wird eben die Zahl X um ein Bit nach rechts geschoben,
als logisches Schieben, wie man dann also hier auch sieht.
Das heißt, auf der linken Seite wird eine Null reingeschoben,
egal wie das Vorzeichen aussieht,
mit dem marithmetischen Schieben würde das nicht funktionieren,
weil dann würde ich das Vorzeichen verdoppeln.
So, und dann in der nächsten Iteration der Schleife betrachte ich dann quasi das nächste Bild.
Und so hält man sich da dann also einfach über die
Bits und zählt dann einfach für viele Einzeln daran sind.
So, das ist also relativ,
es straight Forward und wenn man sich ja so ein bisschen
diese Grundidee von diesen Bitweisen-Operationen dann also irgendwie dann so verinnerlicht hat,
denke ich mal aufs Wort, einleuchtend.
Gut, also das ist jetzt die in Anführungszeichen einfache Variante,
so ähnlich würde ich das also auch kodieren,
wenn ich da den Code schreibe.
Wenn man in die Literatur guckt,
Sowas hier will ich jetzt also nicht groß erklären.
Gibt es also relativ viele ausgefuchste Algorithmen, war wie gesagt,
also gerade so für Kryptologie braucht man dieses Spit-Count relativ häufig,
die dann also irgendwelche Tricks da rein machen,
die sich ja so auf den ersten Blick dann nicht so ganz erschließen.
Also irgendwie solche Codes, die Grundideen dabei sind quasi immer,
dass ich also jetzt hier nicht nur einzelne Bits maskiere,
sondern zum Beispiel dann auch Zweiergruppen bilde,
was also hier zum Beispiel mit dieser,
mit dieser Maske,
mit den Dreien
der Fall ist
Nicht, das heißt,
eine 3 in Hexer dezimal ist ja quasi als Bitmuster,
0-0, 1-1. Das heißt,
da habe ich dann immer quasi jeweils zwei bis nebeneinander.
Und damit macht man dann quasi Folgendes,
dass man immer für zwei beziehungsweise mehr Bit nebeneinander quasi berechnet,
wie viele Einsen da drin sind.
Anschließend dann alles geschickt mit Schieben aufsummiert, beziehungsweise mit Modulo-Operation.
Und dadurch kommt man dann quasi zu so einer Art Parallelenbearbeitung.
Das heißt, hier gucke ich eben Hier zwei Bits an,
hier zwei Bits an, hier zwei Bits an.
Hier zwei Bits an, muss das jetzt nicht wie in
einem anderen Fall mit so einer Schleife dann also über 32 Bit,
also erste Reihe nach durch iterieren. Also wie gesagt,
da kriegt man relativ, findet man relativ viel an irgendwelchen Algorithmen,
die eigentlich so alle auf dieser Idee basieren.
Wie gesagt, also hier nur so ein paar Links,
wo ich jetzt also diesen Code teilweise dann auch rausgeklaut habe.
Da findet sich sowas dann. Wie gesagt,
sonst solche Bitcoins-Sachen sind teilweise sogar so richtig in Hardware implementiert bzw. werden dort unterstützt,
weil man das eben wirklich für einige Algorithmen doch häufiger braucht.
Eine andere Sache in dem Zusammenhang,
auch das will ich nur relativ kurz anreißen, die Grundideen,
geht das auch nochmal so ein bisschen so um so Eigenschaften von den Arent Metiken,
die man teilweise für schnelle Operationen benötigt.
Also das, was hier jetzt gemeint sein soll,
also hier mit diesem String, ist,
wenn ich jetzt eine Integer-Zahl habe und ich habe hier vorne irgendwelche Ziffern.
Nullen eins und was auch immer, habe dann eine Null
Dann mehrere Einsen oder auch gar keine, nein, also mindestens eine.
Und dann vielleicht auch wieder mehrere Nullen. Und hierzu soll jetzt irgendwas hinzuaddiert werden. Dann passiert bei der Addition,
wenn ich quasi hier mehrere Einsen habe, also sprich wirklich diesen Fall,
dass hier also wirklich ein paar Einsen stehen, ja,
Folgendes, dass wenn ich also an dieser Stelle,
sei es durch einen Übertrag oder durch das Argument, eine Eins hinzuaddiere,
dass ich dann Überträge habe, die sich quasi durcharbeiten,
ich quasi sicher an dieser Stelle lauter Nullen bekomme,
wegen dieses allen Übertrages.
Und diese Null zu einer Eins wird.
Weil sich das ja quasi dann hier immer,
also wenn ich jetzt hier wirklich plus eins rechne,
dieses hier sind jetzt alles nur Nullen, Ergebnis Null,
Übertrag eins,
wieder die gleiche Situation und das eben so lange bis
aus dieser 011 führt
So, und das kann man teilweise dann also in der Hardware auch wirklich benutzen,
um quasi in nahen Metikbauadditionen schneller zu rechnen,
weil wenn ich eben weiß,
ich habe solche Bit-Folgen und ich habe einen Übertrag an der Stelle,
dann kann ich also gleich sagen,
ich muss jetzt nicht einzeln immer gucken,
was passiert an der Stelle,
dann habe ich einen Übertrag, dann gucke ich wieder,
sondern ich kann also gleich einmal komplett diesen String durch diesen String hier austauschen.
Während solche Sachen Kann man dann eben entsprechend ausnutzen. Und sagen wir mal,
dieser Fall gilt eben für alle Zahlen außer X gleich gleich null
und eben die größte negative Zahl, also minus zwei, zwei hoch B.
Und dann gilt das. So generell kann man dann auch immer sagen,
also für irgendwelche Zahlen X,
die also diesem hier gehorchen, X,
Bittweise invertiert,
also sprich,
dass einer Kompliment wäre also jedes Bit hier vorne invertiert und dann eben aus einer null wird eine Eins,
aus einer Eins wird eine Null,
das ist dieser String
X-minus eins wäre dann eben quasi das Ganze in die Richtung zurückgerechnet.
Das heißt also aus dieser Eins wird eine Null und aus allem,
was sich hier noch an Nullen habe,
wird eine Eins und beziehungsweise ich muss das dann eigentlich hierauf beziehen,
dann noch einen abziehen,
dann erhalte ich also quasi diesen Ausdruck und minus x,
jetzt also ganz normal im Zweier-Compliment,
wie ja dann dieser String.
Generell gilt ja immer minus x
ist gleich
Bitweise invatiert plus eins, nicht? Also dieses hier wäre einer Kompliment.
Dieses hier ist zweier Kompliment. Und das ist dann aber
eben auch gleich diesen x minus eins Bitweise invertiert.
Also wenn ich mir dies hier angucke. So,
und mit diesen vier Ausdrücken kann man dann eben irgendwie auch so,
ja, Maskierung und Tricksereien machen,
wo ich dann also aus den Bits dann also irgendwelche Sachen rausrechne,
damit irgendwie was mache.
Das wird dann teilweise dann eben auch für solche verkürzten
arrentmetrischen Auswertungen bzw. solche Eigenschaften mitbenutzt
Gut, wie gesagt, wen Durs interessieren sollte,
Donald Knuth hat das in The Art of Computer Programming,
alles mal größer beschrieben. Ach so, wie man es sieht,
habe ich das ja auch nicht oft genug durchlaufen lassen.
Da fehlen mir hier noch die Referenz. Das ist nämlich die hier,
Knut 09. Gut, ja, jetzt verlassen wir mal also die,
zumindest an dieser Stelle jetzt die Ebene der Witz und befassen uns jetzt mit Codierungen.
Godierungen haben wir eigentlich schon diverse kennengelernt,
sollen hier auch noch mal ganz kurz wiederholt werden, nämlich,
wie wir ein Zeichen kodiert und wie werden Zahlen kodiert.
In dem Sinne, beziehungsweise mathematisch gesehen, ist das eigentlich eine Kodierung?
Allgemein kann man sagen, Kodierung ist also nichts anderes,
als das Umsetzen einer vorliegenden Repräsentation in irgendeine andere Repräsentation.
Das geht jetzt also wieder so ein bisschen auf das zurück,
was sich ganz am Anfang mal mit diesen Repräsentationen,
bei dem Stichwort Informationsbegriff vorgestellt hatte, wo man dann eben sagt,
also es gibt Informationen, die ist aber in dem Sinne abstrakt,
wird dann irgendwie durch irgendeine Darstellung repräsentiert, in dem Sinne,
Codierung ist dann eben die Art und Weise,
wie so eine Darstellung gebildet wird.
Und was wir jetzt hier natürlich betrachten,
noch so ein bisschen spezieller ist,
dann eben auch die Umsetzung zwischen unterschiedlichen Codierungen,
was wir teilweise dann also auch schon harten Löcher,
also wenn man jetzt denkt, ich habe eine Zahl im einer Kompliment,
ich habe eine Zahl im Zweierkompliment,
ist also nichts anderes als eine Umcodierung.
In dem Fall, dann eben auch beide Repräsentationen liegen in
derselben Abstraktionsebene. Diese Abbildung sollte eindeutig sein und häufig,
beziehungsweise was wir eigentlich dann auch haben wollen, ist umkehrbar eindeutig.
Das heißt, da hat man dann eine Umkodierung.
Suche ich auch noch ein paar Begriffe. Codewörter wären dann eben
quasi die Wörter, die jetzt zur Repräsentation dieses Codes benötigt werden.
Der Code selber umfasst dann also quasi die Menge aller Codewörter.
Und häufig hat man dann eben sogenannte Blockcodes, das heißt,
alle Codewörter haben dieselbe Länge, sprich 32 Bit,
8 Bit,
was auch immer
Was wir dann natürlich immer noch gerne haben möchten, sind Binärcodes.
Das heißt, Binärzeichen hatten wir auch eingangs schon,
Zeichen vor Ort von genau zwei Zeichen,
nicht beziehungsweise typischerweise ein 0 und eins.
Binärwörter, wie gesagt, Codewörter aus Binärzeichen und Binärcode eben,
wenn ich damit dann einen Code bilde.
So, weswegen braucht man jetzt überhaupt solche Codes?
Im Prinzip kann man da jetzt also die oberen drei Punkte nehmen,
also zum einen für irgendwie Darstellung und Verarbeitung von Informationen
Dann für Datenkompression, Daten oder Reduktion von Datenmengen und dann eben das,
was jetzt hier Sicherheitsaspekte genannt habe, alles,
was dann so in Richtung Verschlüsselung, Kryptologie geht.
Gut, das sind jetzt Sachen,
wo ich sagen muss, fehlt leider die Zeit,
auch immer eine sehr interessante Themen,
wenn wir also jetzt hier in Rechnerstrukturen nicht weiter behandeln.
Ich wo es also im Prinzip um diese ganzen Fragestellungen zur Sicherheit geht,
sprich, wie sieht das mit Authentifikationen aus,
wie sieht das mit ID
Identifikation aus, also sprich,
wenn ich jetzt also irgendwelche Daten von A nach B übertrage,
nicht wird geguckt, ist der Absender wirklich der Meda oder ist das irgendjemand anders,
der sich dazwischen gehackt hat, nicht dann die Sache,
wenn ich das also irgendwie nach B übertrage,
darf ich dort irgendwie meine Daten überhaupt ablegen,
solche Sachen nicht, das sind eigentlich diese Sachen,
nicht dann habe ich, also diese ganzen Schiffrierungssachen,
also sprich, dass ich ihm verschlüsselt übertrage,
damit jemand,
der sich da also irgendwie in die Leitung geklingt hat,
das nicht mitlesen kann.
Ja, werden wir leider aber hier alles nicht behandeln
Das, was wir hier noch so ein bisschen betrachten werden,
sind jetzt eigentlich Sachen,
wo es einfach erst mal nur grundsätzlich um die Übertragung geht.
Sprich zum einen, wie man jetzt vielleicht,
wobei das dann auch nur sehr einfache Ideen sein werden,
wie man vielleicht die Datenmenge entsprechend ein bisschen verkleinern kann,
ein bisschen effizienter kodieren kann.
Und dann eben solche Sachen, wo es darum geht,
also quasi jetzt Fehlererkennung und Fehlerkorrektur zu machen vor dem Hintergrund,
dass eben bei der Datenübertragung im Übertragungskanal oder im Medium,
also irgendwelche Störungen auftreten können.
Und ich schicke eben eine Null raus und
eine Eins kommt an
Im Idealfall sollte eben dann der Empfänger, also irgendwie schon
feststellen können, da ist irgendwie was schief gelaufen.
Nicht, dass also dann irgendwie hier bei der,
beim elektronischen Banking dann also irgendwie der Überweisungsbetrag dann also
irgendwie mal irgendwie ein paar Hausnummern zu groß geworden ist.
Nicht deswegen da dann eben auch entsprechende Möglichkeiten, Fehlererkennung,
Fehlerkorrektur zu machen. Das ist das,
was wir jetzt hier noch so ein bisschen betrachten werden
Demzufolge sind daran die Stichworte hier Quellenkudierung,
das heißt also eine Anpassung des Kurs an den Sender,
dann eben Kanalkodierung,
wo ich dann also quasi auf Eigenschaften dieses Übertragungskanals mit eingehen kann.
Und Verarbeitungskudierung ist grob gesagt eigentlich das,
was wir bislang schon kennengelernt haben bei der Zahlendarstellung,
beziehungsweise bei der Darstellung von Zeichen.
Also sprich, wie werden Zahlen oder Zeichen
im Berechner abgelegt
Und da kann man eben sagen, je nachdem,
wo ich das betrachte, habe ich dann eben unterschiedliche Randbedingungen.
Weil wenn ich jetzt also hier, also sagen wir so,
auf so einem normalen Desktop arbeite, dann kann ich sagen,
ja gut, die sind in der Regel hinreichend zuverlässig.
Da muss ich jetzt also nicht irgendwelche Fehlererkennung, Fehlerkorrektur machen.
Wenn ich jetzt also irgendwie sowas wie Server betreibe und irgendwelchen Kunden irgendwelche Dienstleistungen in Auftrag gebe,
dann macht man da also schon deutlich mehr Aufwand.
Das heißt, wenn dann also zum Beispiel schon Andere Speicherbausteine angesetzt,
die dann also zumindest eine Fehlererkennung machen,
was also hier so im Standard-PC in der Regel nicht der Fall ist.
Wenn ich irgendwelche Rechnersysteme habe,
die jetzt also wirklich in lebensnotwendigen Systemen eingesetzt werden,
also sprich der Computer, der mir also irgendwie das Anästhesie gerät,
also in der OP steuert,
dann wird da so ein Riesenaufwand betrieben,
damit da also wirklich hundertprozentig gewährleistet ist,
dass da jetzt nicht mal eben irgendwie so ein Bit kippt
und der Patient also auch dann also irgendwie nie wieder aufwacht
Gut, wie wären solche Codes jetzt erstmal dargestellt?
Zum einen ganz stumpf einfach Tabelle aufschreiben. Da habe ich
in der Zeile dann quasi das Codewort, das nicht skodieren möchte.
Auf der anderen Seite habe ich den entsprechenden Code.
Das ist also relativ straight forward. In der Regel kann man die dann noch irgendwie sortieren,
kann die noch ein bisschen effizienter ablegen im Rechner,
also irgendwie in baumartigen Strukturen, dass man da also irgendwie entsprechend schneller was findet.
Das ist eigentlich das, was man noch häufig hat. Kotbäume,
wie gesagt, ergibt sich teilweise aus den Tabellen,
macht man dann eigentlich immer ganz gerne war man,
wenn man da jetzt also irgendwas schnell suchen will,
ansonsten bei einigen Codes sind Codebäume dann eben auch eine Art und Weise,
wo ich dann also auch gleich die entsprechenden Werte von meinem Code direkt mit ablesen kann,
ein Beispiel dazu hatten wir schon,
das wird auch gleich nochmal wieder folgen,
der allgemein beliebte Morsecode und sonst kann ich kurz aber eben als,
das sind nur die letzten beiden Möglichkeiten,
eben auch formal irgendwie beschreiben,
sah das in Form von irgendwelchen Gleichungen oder in irgendwelchen Agebraschen
Gut, was haben wir bis jetzt kennengelernt? Textcodierung,
wo ich dann eben quasi jetzt meine Zeichen in Aski, Iso,
Unicode, UTF 8, wie auch immer, letztendlich codiere.
Da geht es jetzt natürlich erstmal nur um die Darstellung der Zeichen selber. Das,
womit wir natürlich arbeiten, wenn ich jetzt sage, okay,
ich habe hier irgendwie so ein PDF oder ich habe jetzt eben hier irgendeinen Textverarbeitung,
ist, dass ich da ja dann also nicht nur den eigentlichen Text habe,
weil da würde, sagen wir mal,
auf so einer Folie relativ wenig Spaß machen,
sondern ich habe auch noch irgendwo eine Formatierung,
also wo soll der stehen, in welchen Farben,
mit welchen Schrifttypen und so weiter und so fort.
Das heißt, Diese Information hat man typischerweise dann eben in irgendwelchen Applikationsspezifischen Formaten.
Das heißt also, je nach Textverarbeitung sind das dann eben irgendwelche Binärdateien,
wo dann letztendlich diese Meta-Informationen dann eben auch noch mit drin steckt.
Oder was ja dann ja eben auch teilweise entsprechend verbreitet hat,
sind dann also solche Marktabsprachen, wo ich dann also quasi einmal den eigentlichen Text habe.
Und dann auch in Form von Text beschrieben,
also in irgendwelchen XML-Beschreibungen, dann quasi immer, dass ich sage,
Mit welchen Fronts soll das dargestellt werden, in welcher Farbe und sowas alles.
Eine typische oder typ bekanntestes Beispiel dafür wäre eben HTML,
also sprich das, was man als Darstellung von Webseiten dann ja typischerweise hat.
Gut, das zur Text. Zahn beziehungsweise Ziffern haben wir dann ja teilweise auch schon kennengelernt. Hier auch einfach nochmal so aufgelistet,
Codierungen für Dezimalziffern, das heißt also die Ziffern von 0 bis 9,
nicht das 1, was gesagt hat, also es straight forward,
ist einfach Binary Coded Desimil, BCD, das heißt,
ich kodiere das einfach als Vierbits drin,
benutze halt eben meine Werte von 0 bis 9,
alles andere kommt da, sagen wir erstmal nicht vor.
Dann als nächstes sogenannter Grey Code,
der wird uns gleich noch kurz begegnen,
weil der also ganz interessant ist, wegen einer bestimmten Eigenschaft,
die man also hier im Prinzip dann also auch schon in dem Code sehen kann,
hat jemand von ihnen da Ja, also genau,
also die Antwort war,
also es verändert im Prinzip also von einem Codewort zum anderen jedes Mal nur ein Bit.
Also wenn man sieht, also zwischen 0 und 1,
1 und 2 und so weiter, verändert sich nur ein Bit.
Hat ganz nette Eigenschaften für bestimmte Anwendungen.
Auch dazu kommt dann gleich noch ein kleines Beispiel.
Das habe ich eben bei diesen anderen Codes,
wenn ich jetzt irgendwie was binär durchzähle, ja nicht.
Also wo ich dann also hier zum Beispiel von 7 nach 8,
da kippen hier alle vier Bit und auch bei den anderen Bits habe ich das nicht,
dass sich also immer nur jeweils ein einzelnes Bit verändert.
Gut, dann Access 3,
das ist dann quasi so BCD mit so einem Offset,
Icon, Miquinär 1 aus 10,
2 aus 5. Jetzt kann man sich natürlich fragen, ja,
warum habe ich jetzt hier zum Beispiel wieder so komische Codes wie diesen oder am besten noch den hier,
also irgendwie so mit zehn Stellen.
Nicht der Code selber, sag mal, ist natürlich also relativ einleuchtend.
Also ich habe hier quasi zehn Zeichen zu kodieren,
habe hier einen String von zehn Bit,
nicht und jeweils für das erste Zeichen wird eben dieses Bildgesetz für das zweite Zeichen.
Dieses für das dritte Zeichen. Dieses, wenn ich demzufolge,
wie der Name auch schon sagt, ein Bit von 10 Bit ist gesetzt.
Macht natürlich den Code erstmal deutlich länger. Andererseits habe ich
hier bei solchen Codes zum Beispiel den Vorteil, dass ich sagen kann,
wenn ich also irgendwie eine Abfrage haben möchte, ist irgendwas gleich 5,
muss ich bei allen anderen Codes wirklich alle Codes oder jeweils die entsprechenden Strings für diesen Code komplett betrachten.
Das heißt also beim BCD-Code, um abzufragen, ist es eben gleich fünf,
muss gewährleistet sein. Das erste Bit ist gleich null,
das zweite ist gleich eins, das dritte ist gleich null und das vierte ist gleich eins,
beziehungsweise wenn ich bei BCD bleibe, genügen die unteren drei Bit,
aber nichtsdestotrotz muss ich einfach mehrere Bit betrachten.
Nicht bei diesem 1 aus 10 kann ich sagen,
ich muss also wirklich hier nur dieses sechste wird betrachten und wenn das gleich eins ist,
weiß ich, die Zahl ist gleich 5, wenn das gleich 0 lässt,
ist Yuon gleich 5. Also dafür können dann eben solche Codes teilweise auch interessant sein,
auch wenn die eigentlich länger sind,
von der Darstellung als das, was man hier hat.
So, wenn ich mir diese Eigenschaften von den Codes hier nochmal ansehe,
nicht mit Blockcode und Biniercode und so weiter, gut,
bin ja sowieso,
nicht weil wir jetzt hier also alle mit Zahlen 0 und 1 arbeiten,
Blockcodes auch, weil alle Zahlen haben oder alle Darstellungen haben jetzt hier jeweils die gleiche Länge und ja,
das sind ja so dann hier, sagen wir mal so die typischen Eigenschaften.
Was eigentlich immer noch entscheidend ist und was jedem dann eigentlich auch immer klar sein sollte,
ist, dass man natürlich, wenn ich jetzt irgendwie was kodiere,
auch immer erstmal ansagen muss, um welchen Code es sich handelt,
weil wenn ich ja so im Prinzip ein Bitten musste aus Nullen und Einsen habe,
also das hatte ich ja ganz ah angangs,
also auch schon bei diesem Informationsbegriff erwähnt, ist letztendlich nicht klar,
worum handelt es sich und deswegen ist beispielsweise dann eben auch,
Office war dann zumindest immer jeweils eindeutig in Übungsaufgaben,
wenn es jetzt irgendwie um die Zahlendarstellung ging, dann eben auch immer jeweils mit Dezimalhexer, Dezimal, Binär dann, also immer irgendwie mit so einem Index oder wie auch immer, markiert.
Mit welchem Code jetzt irgendwie was dargestellt ist. Gut,
ansonsten hier nur Anmerkungen, also wie gesagt,
die Zimaldarstellung in Rechnern hatte man früher gemacht, das wird heutzutage logischerweise nicht mehr gemacht.
Da hat man dann also quasi als Zahlendarstellung quasi Scient oder Anscience-Zahlen-Darstellung
einfach mit 32 mit 64 Bit Enteger oder was auch immer
Gut, dann, jetzt noch einige Begriffe zu Binär-Codes.
So, wenn wirklich jetzt alle möglichen Code-Wörter
eine Code-Wortlänge benutzt werden, ist das ein Minimal-Code.
Sprich, wenn ich, dieses hier sind alles keine Minimal-Codes,
weil also quasi mit einer Code-Wortlänge 4 kann ich 16 Wörter kodieren.
Nicht hiervon habe ich in diesem Fall jetzt hier nur 10 benutzt,
angenommen, ich hätte damit jetzt die Zahlen von 0 bis 15,
wäre das also nach dieser Definition dann eben ein
Minimalcode. So ein redundanter Code, das ist das,
was wir gerade eben hier hatten, ist eben,
wenn nicht alle möglichen Codewörter benutzt werden,
dann das Gewicht eines Codes,
ist die Anzahl der Einzelnen in einem Codewort.
Also da begegnet uns nämlich schon wieder diese Sache mit diesem
Einzelzielen, was wir gerade eben gehabt hatten.
Das Kompliment oder ein Code ist komplementär,
wenn es eben zu jedem Codewort ein gültiges Codewort gibt,
wo quasi die Bits alle invertiert worden sind
Einschrittig war also genau diese Eigenschaft, die beispielsweise jetzt eben
da bei dem Greycode uns hier schon begegnet ist.
Das heißt, zwei Aufeinanderfolgende Codewörter setzt voraus.
Ich habe irgendeine Art Ordnungsrelation, aber zwei aufeinanderfolgende Codewörter
unterscheiden sich eben nur an genau einer einzigen Stelle.
Und zyklische Codes sind halt, wenn ich also eine Art Ordnung habe,
dass es Wenn ich also nach dem letzten Element bin und dann wieder weitergehe,
dann lande ich wieder beim Ersten.
So das, was wir eigentlich alles an Zahlendarstellungen kennengelernt haben.
Zwei Kompliment, Einser-Kompliment bzw. Unsigned-Darstellung, wären dann zum Beispiel
auch alles zyklische Codes. Bzw. hier steht es auch
nochmal. Also Dual-Code, ich spreche die üblichen Zahlen.
Alle Code-Wörter werden genutzt. Demzufolge ist es ein Minimal-Code,
zu ihrem Codewort existiert ein komplementäres Codewort
Bei fester Wortbreite bin ich zyklisch, habe dann natürlich teilweise
irgendwelche Überläufe raus, aber ja. Und das sind aber,
wie ich auch eben schon gesagt habe, nicht einschrittige Codes.
So, weswegen sind jetzt einschrittige Codes vielleicht interessant,
dass es also jetzt hier nochmal so ein bisschen verdeutlicht bzw. beschrieben,
wie gesagt, zwei aufeinanderfolgende Codewörter, France gesetzt,
ich habe jetzt eine Ordnungsrelation und unterscheiden sich jetzt eben an genau einer einzigen Stelle.
Zyklisch einschrittig heißt, nach dem letzten Codewort und ein Bit
ändert sich, lande ich dann eben wieder bei dem ersten
So einschrittige kurz sind dann eigentlich immer ganz interessant, wenn ich,
also jetzt wirklich diskret irgendwie Wertewechsel habe und dort keine Fehler drin haben möchte.
So, was macht er jetzt damit? Also rein praktisch stellen wir uns vor,
sowas wie Winkelkodierscheiben, da wird das jetzt nämlich gleich mal ein bisschen beschrieben,
wo man dann eben sehen kann, wenn ich das Dual beschreibe,
habe ich da relativ viele Fehler.
Wenn ich einen einschrittigen Code habe, ist der maximale Fehler eins.
Sowas ist jetzt erstmal hier, also Winkeldrehscheibe, also angenommen,
wir haben jetzt also hier von irgendeinem Sensor,
rotieren eine Achse und möchten jetzt also irgendwie messen, in welcher Stellung befindet die sich. So,
das ist also eine der einfachsten Varianten zu sagen,
okay, ich habe jetzt hier irgendwie so eine Glasscheibe,
da sind eben Sachen entsprechend durchsichtig oder eben dunkel gefärbt,
habe dann also hier irgendwie so einen Satz, Kameras,
LEDs, Fotozellen, wie auch immer,
das also dann technisch aufgebaut ist, wo ich dann eben feststellen kann,
zu einer bestimmten Winkelposition habe ich hier quasi Muster aus hell und dunkel oder rein praktisch ein Wort aus Nullen und Einsen.
So, das ist in diesem Beispiel jetzt quasi für,
ich sag mal, fünf Bit gemacht,
indem ich da also quasi fünf von diesen Codierkreisen da drauf habe,
das kann man dann also auch noch mit Meeren machen oder irgendwie mit Winkeln irgendwie so Zahnrad getrieben,
um das jetzt also noch genauer zu machen,
wenn man das braucht, ist letztendlich dann immer von der Anwendung abhängig,
was man damit machen möchte
So, und wenn ich jetzt also eine Winkeldrehscheibe habe und sage,
okay, ich möchte jetzt also hier meine beispielsweise 360 Grad unterscheiden mit einer hinreichenden Genauigkeit,
dann gucke ich jetzt eben, wie viel Bit habe ich,
brauche ich, um jetzt diese Genauigkeit zu erreichen.
Also beispielsweise, wenn ich jetzt sage, okay,
maximal irgendwas unter einem Grad genau. Gut,
dann würde ich also irgendwie sowas wie neuen Bit nehmen.
Dann habe ich 512 verschiedene Möglichkeiten und könnte dann also quasi
Wenn ich also so ein Bistring mit neuem Bit dort habe,
dann also quasi dann, also auf irgendwas mit 0,6 Grad-Genauigkeit letztendlich das Ganze irgendwie einordnen.
So, jetzt ist aber eben die Frage, wie baue ich diesen Bitstring auf?
Jetzt kann ich natürlich sagen, ja gut, wunderbar,
das zähle ich hier einfach ganz normal Dual durch.
Also sprich, neben meine Zahlen rechnen einfach von null bis 511,
so was passiert dann, wenn ich das Ganze dann also
irgendwie technisch aufbaue und ablese.
Das ist im Prinzip mit dem hier so
ein bisschen mal verdeutlicht
Also dieses hier oben soll jetzt für so einen Durchlauf sein,
das, was also quasi gemessen wird, als Signal,
0,1, nicht 4,0,1, dass wir dann die nächste Stelle,
nicht und das wäre dann also quasi die höchstwertigste Stelle.
Das heißt, ein ganz normaler Dualcode, wo ich dann also quasi hier mein Niederwärtigstes,
hier mein höchstwertigstes Bit habe und hier dann eben entsprechende Stellenwertigkeit, die anderen Stellen. So,
jetzt ist es rein technisch natürlich so,
wenn ich also irgendwie so ein System realisiere,
zum einen Was hier so ein bisschen angedeutet ist,
was uns dann also vielleicht ja doch später in dem Kapitel,
wo es dann also nochmal grob,
also von der Idee her so um Time geht,
ist es auch nochmal beschrieben, muss ich auch mal sagen,
als Informatiker lebt man immer in der idealen Welt.
Nicht, da betrachte ich also irgendwie Werte 0 und 1 und irgendwie dazwischen ist nichts.
Das ist also wirklich rein wie näher. Rein technisch,
wenn ich jetzt natürlich hier irgendeinen Sensor habe,
der also irgendwie eine Helligkeitsverteilung dann also irgendwie in Spannung umsetzt,
dann wird quasi hier von der Spannung 0 zu dem meinetwegen 2,5 Volt,
die dann also hier die Spannung die eins oder als eins interpretiert wird,
das Ganze hier nicht unendlich schnell ansteigen.
Und ich habe also wirklich so einen binären Übergang,
sondern rein technisch, wird das also hier mehr oder minder schnell ansteigen.
Das ist also die eine Sache,
das sieht man da also so ein bisschen an diesen Kurven,
die jetzt also hier nicht mehr so richtig rechteckig aussehen,
sondern also irgendwie so ein bisschen trapezförmig.
Und Die andere Sache, was da auch passiert, ist,
wenn ich sage, ich habe jetzt also irgendwie mehrere Fotos zählen,
die das also irgendwie messen, habe dort irgendwelche Bauteilschwankungen, dann kann es eben sein, die eine misst ein bisschen schneller, die andere ein bisschen langsamer. Das heißt,
wenn ich einen Übergang von meinetwegen einem Zielwert 7 nach 8 habe,
dann ändern sich nicht alle Bits gleichzeitig, auch rein wie näher,
sondern es kann sein, dass das also so wechselt,
dass ich also hier meinetwegen die höchstwertigste Bits sich ändert, kommen,
ein bisschen später, also habe ich zwischenzeitlich mal den Wert,
anschließend kippen diese beiden Bits, nicht dann habe ich hier 1,
0, 1,
0 und irgendwann kommt also auch hier dieses erste Bit und dann habe ich erst den richtigen Wert 1,
0, 0. Das heißt,
zwischenzeitlich kann ich dort beliebig viele falsche Werte auslesen und das ist das,
was also hier unten angedeutet ist, also hier sieht man eigentlich,
sagen wir so treppenförmig, sollte der Wert jetzt immer größer werden,
dadurch,
dass also quasi einmal so ein Kreis durchlaufen wird
Andererseits ist es eben so, dass jetzt quasi,
wenn ich also hier jetzt irgendwie so einen Schnitt durchlegen würde,
beispielsweise dieser Übergang von 0 nach 1 ein bisschen schneller stattfindet,
als also hier irgendwie dieses Abschalten an dieser Stelle.
Das ist also genau jetzt diese Situation,
wodurch ich dann eben zwischenzeitlich falsche Werte habe und
irgendwann wird das dann aber zu dem richtigen Wert sich dann
mal zurecht bewegen
Gut, wenn ich jetzt aber so ein System nehme,
um damit jetzt also irgendwelche Steuerungsregelungsaufgaben zu machen und das sollen wir jetzt also was,
was ich, ja gut,
da macht man sowas nicht,
aber sollen wir jetzt also irgendwie hier im Auto irgendwie das AWS steuern,
dann ist es also einfach ein bisschen blöd,
wenn das Ding zwischenzeitlich völlig falsche Werte hat und sagt,
das Auto schleudern und es muss man mit dem Rad also irgendwie dagegen bremsen.
Einfach nur, weil der Sensor also irgendwie Unsinn liefert. So,
und an der Stelle ist es dann eben ganz interessant,
so was wie einen einschrittigen Code zu haben,
also sprich so ein Grecode, Das ist also das,
was also jetzt hier der Fall ist,
auch mit so ein bisschen Gitter drin.
Das heißt also, die Bits kippen nicht alle gleichzeitig, sondern die sind auch zeitlich miteinander versetzt.
Aber in dem Fall führt das ja nur dazu,
dass sich also quasi den Wert von zwei Aufeinanderfolgenden Bits,
dass ich dir entweder ein bisschen früher oder ein bisschen später ändert,
aber er ändert sich ja auch immer nur um eins.
Das ist also das, was hier letztendlich dann auch zu sehen ist. Also wenn ich hier quasi diesen Übergang von sieben nach acht mache,
also in dieser Kodierung,
dann ändert sich eben nur ein einziges Bit und das,
was dann sein kann, eben aufgrund der irgendwelcher Fertigungsgenauigkeiten,
irgendwelcher Lesefehler oder was weiß ich, in dem Fall ist dann eben,
dass das entweder ein bisschen später stattfindet oder ein bisschen früher stattfindet,
aber es wird eben,
da sich bei diesen beiden Worten ja auch nur dieses eine Bit ändert,
letztendlich nie ein Signifikant falscher Wert ausgelesen,
sondern kann sich eben maximal nur angenommen,
nur würde sich zu spät ändern, kann sich dann eben,
wenn ich hier diesen Zeitpunkt betrachte,
eben maximal um einen daneben liegen.
Das ist also der Grund, weswegen hier dann drin steht, maximaler Ablesefehler.
Beim Dualcode kann das eben zwei hoch im N minus eins sein,
beim einen Schritt den Code dann eben noch als.
Gut, also das jetzt zu diesen einschrittigen Codes bzw. zu den Grecodes.
Jetzt ist natürlich die Frage, wie kann man sich sowas generieren?
Weil wenn ich jetzt also hier irgendwie diesen Curry-Code sehe.
Ich kann mir jetzt natürlich sagen, ja,
kann ich also irgendwie so lange rumprobieren,
bis ich das dann irgendwie habe,
dass ich also auf Auseinanderfolgen Codeforth immer nur ein einzelnes Bit ändert.
Das ist natürlich, würde auch funktionieren,
ist aber ein bisschen mühselig, sondern gibt es dann eben entsprechende Verfahren,
wie man sowas erstellen kann.
Also hier dann nochmal so eine Kurdierscheibe für 10 Bit und
das einfachste Verfahren ist im Prinzip so ein rekursives Verfahren,
nachdem also auch diese Grey-Codes dann immer erstellt worden sind
Angenommen, ich habe einen einschrittigen Code, der bereits N-Code-Wörter beinhaltet,
dann kann ich daraus einen Code erzeugen,
der dann eben doppelt so viele Code-Wörter beinhaltet,
indem ich das so mache, dass ich die Code-Wörter,
die ich habe, der Reihe nach aufschreibe, eine Null vorneweg,
anschließend in umgekehrter Reihenfolge wieder aufschreibe und eine Eins vorne weg.
So, und wenn ich das Ganze jetzt beginnt mit dem Code,
war dann 0 und 1 mache,
kann ich dann rekursiv, also beliebig,
lange,
beziehungsweise komplizierte Grecodes
mir erzeugen
So, hier mal veranschaulicht. Ich starte also mit der Menge mit den beiden Codewater 0
und 1. Die beiden Wörter, also 0 und 1,
nehme ich und schreibe dir in dieser Reihenfolge hin und eine Null davor.
Und ich schreibe dir dann in umgekehrter Reihenfolge hin,
also 1 und 0 und eine 1 davor.
Und der Code mit diesen vier Codewörtern hat jetzt eben auch wieder die Eigenschaft, einschrittig, sogar zyklisch einschrittig und entsprecht dem. So,
und hier jetzt also quasi genau das Gleiche,
also ich erzeuge mir jetzt hier ein Kotwort mit an Code mit acht Codewörtern,
nehme also diese Folge 00, 01,
1-1 und 1-0,
schreibe das hin und eine Null davor und anschließend das Ganze in umgekehrter Reihenfolge,
also 1-0, 1-1,
0-1 und 0-0 und eine Null davor,
eine Blödsinn, eine 1 davor,
dann habe ich den zweiten Teil hiervon und habe nach wie vor dann immer noch so entsprechend einschrittigen Code.
Das ist also die Art und Weise,
wie man so einen Greycode konstruieren kann. So,
und je nachdem, wie viele Codewörter ich brauche,
würde ich dann also dieses Verfahren letztendlich dann immer wieder wiederholen.
Eine andere Möglichkeit, sich einschrittige Codes zu generieren,
ist etwas, was uns dann also später auch noch bei
der Minimierung von Schaltalgebraschen ausdrücken begegnen wird,
grafisches Verfahren,
wo man sogenannte KV bzw. Kanuf-Falschdiagramme benutzt
So ein KV-Diagramm ist im Prinzip so ein zweidimensionales Diagramm mit zwei Hochendfeldern,
beziehungsweise typischerweise hat man dann also in X und Y Richtung irgendwie Anzahl Felder.
Nein, zwei Hochend eigentlich ja nicht,
sondern ich habe dann eben entweder zweimal zwei,
zweimal vier oder viermal vier große Diagramme.
Viermal vier großes Diagramm wäre jetzt also hier so was.
Also ich habe hier vier Variablen.
X3, X2,
X1,
Habe hier jetzt in diesem Diagramm die jeweiligen Belegungen für X1
und X0 beziehungsweise hier an der anderen Achse für X3 und X2.
Und in diesem Diagramm gilt jetzt, dass ich quasi hier
die Indizes quasi aus dem Grecode nehme. Also sprich,
die sind einschrittig, beziehungsweise entsprechend eben im Grecode, also diesem 000111111110. Und damit ist gewährleistet,
wenn ich jetzt hier quasi den Wert, hier einmal reinschreibe,
so wie hier, dass wenn ich ein Feld habe,
wie beispielsweise jetzt dieses Feld, wo jetzt also hier der Cursor sitzt,
was dann also quasi der 15 entspricht,
dann unterscheiden sich alle benachbarten Felder immer um genau ein Bild.
Das heißt, wenn ich von hier aus nach hier gehe,
ändert sich in diesem Fall von 15 nach 7 das Bit X3,
wenn ich von hier nach hier gehe,
ändert sich das Bit X0 von 15 nach 14 Wenn ich nach hier gehe,
ändert sich dann das Bit, X2, also von 15 nach 11.
Und in diese Richtung wäre dann eben die Änderung dieses Beziehers. So,
und damit kann man jetzt sagen, wenn ich so ein KV-Diagramm habe,
kann ich mir jetzt also quasi um einen Grecode einfach dadurch sagen,
dass ich in dieses Diagramm einfach irgendwie einen Pfad reinzeichne.
Vorausgesetzt, ich bewege mich nur horizontal und vertikal. Das heißt,
wenn ich jetzt also hier diesen Pfad nehme,
Und jetzt eben hier diese Folge von diesen Codierungen nehme,
dann wäre das eben ein einschrittiger Code.
Weil sich, also aufgrund der Art und Weise,
wie das hier erzeugt wurde, eben über dieses KV-Diagramm immer zwei benachbarte Felder,
nur um einen wird unterscheiden können. So,
und das muss jetzt nicht über alle 16 Felder gehen,
sondern ich kann hier also auch kürzere Fade bilden,
also beispielsweise 1, 3, 7, 6,
14,
15 und so weiter
Und je nachdem, wie viele Elemente, quasi jetzt mal einschrittiger Code braucht,
kann ich hier dann eben irgendeinen beliebigen, passenden Pfad mir reinzeichnen.
Gut, wenn das ein zyklisch einschrittiger Code wäre,
was also hier im Prinzip überall möglich ist,
dann würde quasi der Endpunkt dieses Pfades dann also wieder neben
dem Anfangspunkt liegen und dann hätte ich sowas wie irgendwie so ein zyklischer einschrittigen Code.
So, und so kann man dann eben auch grafisch solche Grey-Codes erzeugen,
was ja auch noch zu beachten ist,
ist Form einer Eigenschaft, dass ich sagen kann,
dass die Pfade, also quasi nicht nur innerhalb,
wie sie sich dir rahmen sind,
sondern dass ich also quasi das Ganze auch immer außen herum verbunden oder dass man sich das immer noch außen herum verbunden vorstellen kann.
Das heißt, wenn ich also hier diesen Pfad habe und
hier bei der 10 gelandet bin, also als Codierung 1010
und dann quasi hier an dieser Stelle mit der Acht gehe.
Auch da hat sich dann nur ein einziges Bit geändert,
nämlich in diesem Fall dann das Bit X1,
was dann da entsprechend dann geändert ist. Das heißt,
also ich hatte zehn, ist 1-0,
1-0, 8 Werder 1-0, 0,
0, nicht nur noch da habe ich dann jetzt eben hier nur diese eine einzige Änderung in den Bits.
Das heißt also, diese Eigenschaft Zwei benachbarte, zählen,
unterscheiden sich nur um ein Bit, gilt eben quasi auch von hier,
nach hier, beziehungsweise von hier, nach hier.
Das heißt also, ich kann das Ganze dann auch immer noch
so außen herum entsprechend verlängern. Gut, ja, Recode,
wie gesagt, man kann das jetzt irgendwie sich rekusiv erzeugen.
Andererseits Kann ich jetzt eben auch sagen, ich erzeug mich jetzt nicht nur rekursiv,
sondern ich habe jetzt also irgendwie ja schon meine Zahl oder meinen Wert, Dual kodiert.
Wie kann man daraus einen Recode machen? Also auch das ist ein mathematisch oder rein technisch gesehen, also auch relativ einfach möglich. Und zwar,
indem ich da also folgende Vorschriften mal anwende,
dass wenn ich jetzt also hier ein Codewort habe,
dass ich das most significant bitte,
also das ist am weitesten linksstehende, einfach eins zu eins übernehme,
Und dann in meinem zu kodierenden Wort quasi das nächste Bit nehme und dann sage,
wenn es sich nicht ändert,
schreibe ich in dem Grecode eine Null hin,
wenn es sich ändert, schreibe ich in dem Grecode eine Eins hin.
So, das kann man also auch relativ stumpf dann machen. Hier als Beispiel,
wenn ich ja sehe es hier, als Dualwort,
also quasi hier die Drei habe, also 0011,
das Zuhörige Wort in dem Grecode wäre dann 0010,
errechnet sich dadurch,
dass ich sage,
diese 0 wird abgeschrieben
Das ist also das, was hier unter eins steht.
Anschließend betrachte ich dann eben, ändert sich von dieser Stelle
zu dieser Stelle in dem Wort etwas. Nein,
also schreibe ich in dem Greco dann hier eine Null hin,
gucke dann für die nächste Stelle von hier nach hier,
ändert sich von 0 nach 1,
also schreibe ich hier eine eins hin.
Von hier nach hier ändert sich wieder nichts. Also schreibe
ich hier wieder eine Null hin. Und wie gesagt,
diese Änderung geht dann also auch in beide Richtungen.
Also hier sieht man also,
wie also quasi aus dieser Sechs, das entsprechende Gregwort wird,
wo ich dann also quasi von die Null wird abgeschrieben.
Hier ändert sich
das Bit
Ich schreibe hier eine Eins rein. Hier ändert sich
das Bild nicht. Demzufolge wird hier eine Null hingeschrieben.
Hier ändert sich das Bild dann wieder von Eins nach Null
und wieder schreibe ich hier eine Eins. So,
in Software beziehungsweise als so ein Ausdruck,
der das dann also jetzt direkt über solche Bittergewaschen-Sachen ausrechnet,
kann ich dann eben in diesem Fall dann einfach schreiben,
X und dann Bitvises exklusiv oder von X um ein Logisch nach rechts geschoben.
Damit habe ich im Prinzip dann immer genau diese Eigenschaft,
dass ich hier zwei aufeinanderfolgende Bits vergleiche. Wenn die gleich sind,
das heißt 0-0 oder 1-1,
liefert mir das exklusiv oder eine Null. Wenn die unterschiedlich sind,
also entweder 0 und 1 oder 1 und 0,
liefert mir das exklusiv oder eine 1. Das heißt,
einfach durch solche Paarweisen exklusiv oder Operationen kann ich dann so
eine Umrechnung von Dual in Greywood direkt auch durch
entsprechende Hardwareeinheiten machen
Gut, umgekehrt geht das also auch genauso, relativ einfach.
Ich übernehme auch in diesem Fall jetzt wieder,
dass am weitesten links stehende Bit und dann wird einfach eben jetzt wieder geguckt von links nach rechts,
wenn im Grehwort eine Eins steht, wird das Bit,
was dort steht, invertiert, wenn dort eine Null steht,
wird das Bit entsprechend abgeschrieben.
Das heißt, wenn ich jetzt also diesen String nehme,
ich habe hier die Null, die wird abgeschrieben,
anschließend habe ich hier die Null.
Das heißt, es ändert sich nichts. Also wird diese
Null auf diese Stelle hin übertragen. Dann habe ich hier
eine Eins, also wird aus dieser Null hier eine Eins.
Dann habe ich hier wieder eine Null. Das heißt,
diese Eins wird wieder übertragen. Und dieses wäre dann also
hier diese Rückrechnung mit diesen beiden Wechseln.
Und auch das lässt sich dann also direkt in Hardware durch
so eine Kette von exklusiv oder Operationen machen,
wo ich dann in dem Fall dann eben immer von einem
Bit zum nächsten Bit gucke
Was habe ich also in meinem Graywort dann, also an entsprechender Stelle?
Gut, ja, dann kommen wir jetzt zu dem Thema der Quellencodierung. Da geht es eben letztendlich darum zu sagen,
wenn ich sowas wie Zahlen habe und irgendwie so einen Wertebereich,
92-Bit, 64-Bit, was auch immer, dann sage ich jetzt erstmal,
okay, rein mathematischer wird das häufigererweise natürlich so vorkommen,
dass also irgendwie alle Zahlen irgendwie mehr oder männer erst mal live wahrscheinlich sein sollen.
Da muss ich mir da jetzt also irgendwie keine Gedanken machen. Andererseits,
wenn ich jetzt also wirklich sage,
Ich habe sowas wie Codierung von Zeichen oder von Buchstaben oder von Worten,
wo ich dann eben sagen kann,
in einer bestimmten Sprache sind dort eben die Auftretenswahrscheinlichkeiten unterschiedlich groß,
dann verwendet man dann eben sowas,
was dann also hier unter dem Stichwort Quellencodierung genannt wird,
was also im Prinzip dann also auch die Grundidee oder die Basis eben für sowas wie Morsecode ist,
wo man dann eben sagt,
wenn ich mit unterschiedlichen Symbolhäufigkeiten arbeite und meine Codierung daran anpasse,
erreiche ich, dass ich eben Insgesamt mit meinem Code,
wenn ich jetzt also irgendwie mehr Informationen übertrage,
weniger Daten übertragen muss,
als wenn ich das jetzt also quasi mit irgendeinem Blockcode mache,
wo ich dann einfach den beispielsweise jetzt also den Buchstaben eben irgendwelche Zahlen von,
ja, meinetwegen jetzt also irgendwie Asky,
also irgendwie 0 bis 127 oder eben UTF 8 dann,
also irgendwie da,
also irgendwelche festen Wortlängen zuordnen
So war es dann aber im Prinzip, also wie gesagt,
Grundidee, häufige Symbole bekommen kurze Court, Codewörter, seltene Symbole bekommen,
längere Codewörter und unterm Strich erreiche ich aber, dass ich weniger Informationen übertragen muss.
So, Problem bei dem Ganzen ist jetzt natürlich,
dass ich jetzt also bei Blogcodes sagen kann,
wenn ich irgendwas übertrage und ich habe jetzt eine Zahl und ich weiß,
sie ist 32 Bild lang, dann fange ich eben an,
32 Bit abzuerzählen und sage, das ist meine erste Zahl.
Und dann nehme ich die nächsten 32 Bit und sage,
das ist die zweite Zahl,
beziehungsweise wenn ich bei Texten bin und sage,
da kommt jetzt also irgendwie was in meinetwegen Aske-Kodierung,
dann kann ich eben sagen, nach sieben Bit,
das ist das erste Zeichen,
die nächsten sieben Bits sind das zweite Zeichen und so weiter.
Das heißt, da kann ich einfach abzielen.
Bei solchen Kurz mit variablen Längen funktioniert das nicht.
Deswegen muss man also entweder, zwischen den Code,
war dann sowas wie Mager einfügen, also sprich beim Mause-Code,
irgendwann mal so was wie Pausen einbauen,
dass man sagen kann,
okay,
damit ist das
eine Mausezeichen beschrieben
Mhm. Pause. Okay, das nächste Morse-Zeichen. Oder man muss etwas machen,
was dann in der Literatur als Farno-Bedingungen beschrieben ist,
die im Prinzip sagt,
dass kein Wort eines Codeworts eben den Anfang eines anderen Codeworts bildet.
Das ist die sogenannte Codewort-Prefix-Eigenschaft,
wurde von einem italienisch-amerikanischen Mathematiker, Roberto Mario Farno,
1961 postuliert
So, und wenn diese Eigenschaft gegeben ist,
dann ist quasi der Code auch eindeutig dekodierbar. Und das,
was wir bislang gehabt hatten, also quasi die ganz normalen Blockcodes,
die sind formal gesehen Prefixcodes,
weil also quasi jedes Element gleich lang ist und ich eben nur Codierungen mit,
meinetwegen jetzt genau sieben Bit habe und dann eben auch immer weiß,
okay, es kommt danach nichts mehr,
da kann auch kein Nichts jetzt mit Pre-Fix sein.
Ansonsten Pre-Fix-Eigenschaft begegnet uns eigentlich immer bei solchen Sachen wie beispielsweise Telefonnummern.
Also es ist jetzt also hier nicht nur irgendwie so eine Informatik-theoretische Sache,
sondern nicht, das haben wir rein praktisch, nur auch bei vielen Sachen.
Also zum Beispiel sowas wie Notrufnummern sind eben bei uns so geregelt,
dass es also keine Telefonnummer gibt,
die mit 1-1-0 oder 1-1-2 anfängt,
sondern das sind eben feste Nummern und alles andere nicht.
Nicht, was anderes ist dann eben auch zum Beispiel die Sache mit diesen führenden Nullen,
wo man auch sagen kann, okay,
also wenn ich jetzt eine Telefonnummer habe,
die jetzt also mit irgendeiner Zifferungleichnull anfängt, dann ist das eben ein Ortsnetznummer.
Nicht, wenn die mit einer Null anfängt,
dann ist diese eine Null dann quasi der Teil von der Ortsvorwahl,
also diese Folge ist also hier Hamburg.
Und wenn ich ihm von außerhalb oder international anrufe und das
ist nach international und das ist eben mit 2-0,
dann ist die bezeichnet das dann eben das Land.
Dann habe ich dann eben gut bei bei uns ist es eben so kodiert,
dass er dann sagt, okay,
dann kommt als nächstes dann die Ortsvorwahl ohne diese führende Null nicht und dann eben der Rest der Rufnummer.
Das ist dann ein Beispiel für so einen Präfix-Code,
den wir eigentlich so aus dem tiefglichen Leben schon seit so lange kennen.
Gut, Morse-Code, Fahne-Bedingungen hatte ich ja schon gesagt,
da ist sie letztendlich verletzt, also die Folien hatten wir alle schon mal,
also was Morse-Code ist, dass das dann eben nicht eindeutig dekodiert werden kann.
Das heißt, wenn ich jetzt so ein Codewort ohne irgendwelche Pausen habe,
kann ich eben dort letztendlich Nicht unterscheiden, wie das Ganze dann dekodiert werden soll.
Die Kodierung hat ja auch schon kurz angedeutet,
dass es wäre dann eben mal so ein typisches Beispiel dann für das,
was ich vorhin als Codebaum bezeichnet habe. Nicht,
wo ich sage, wenn ich jetzt also hier irgendwelche Morsezeichen empfange,
würde ich jetzt eben gucken, okay,
kommt ein kurzes Signal oder ein langes Signal,
nicht wenn ein kurzes Signal kommt, dann bin ich also erstmal hier an dieser Stelle beim E.
Und wenn dann als nächstes ein langes Signal kommt,
dann hätte ich dann eben würde ich das dann eben als
A lesen und das Ganze mache ich dann eben so lange,
bis dann also hoffentlich eine Pause kommt und dich dann eben auch eindeutig entscheiden kann,
an der Stelle ist dann diese Unterscheidung.
Und darüber kam man dann eben letztendlich von einer Wurzel bis zu
so einem Blatt gelangen und dann eben der entsprechenden Wirt direkt ablesen.
Gut, jetzt habe ich ja gesagt, naja,
also ein Morse-Code, wenn ich da jetzt nicht irgendwie Pausen habe,
verletzt die Fahne-Bedingung, wie man hier sieht.
Trotzdem kann ich natürlich aus dem Morse-Code auch einen eindeutigen
Code machen
Da muss dann der Morse-Code nur noch mal wieder umkodieren.
Ich womit wir also bei der Umkodierung von Code A
in Code B sind. Wenn ich also beispielsweise sage,
der lange Ton wird kodiert als 1-1-0,
der kurze Ton wird kodiert als 1-0 und ein Trendzeichen wird kodiert als nur eine Null.
So, dann kann ich quasi aus diesem hier eindeutig SOS rauslesen,
weil ich fange hier mit 1-0 an,
ist Ein kurzer Ton, hier nochmal 1-0,
allen kurzer Ton,
hier nochmal 1-0 und ein kurzer Ton und dann null ein Trendzeichen.
Wenn ich eine drei kurze Töne, würde ich dann jetzt
wieder also aus der Tabelle quasi rauslesen als 1S. Nicht und entsprechend das hier weiter.
Das heißt also, man kann mit solchen mehrfachen Umschlüsselungen dann
da dann also quasi dann also auch noch sowas zum Beispiel erreichen. Gut,
auch hier nur als Beispiel, nicht,
also es sind beliebig viele andere Umschlüsselungen denkbar,
also hier ist so eine Beschreibung,
wo ich also quasi einen langen Ton mit einer 1,
kurzen Ton mit 0-1, Trendzeichen mit 0-0 kodiere,
auch das wäre ein eindeutiger Code, der quasi die Fahne-Bedingungen dann nicht verletzt.
Gut, wenn ich jetzt also irgendwie sage,
ich habe jetzt also als Voraussetzung irgendwelche Symbole, die zu codieren sind.
Und ich weiß also, deren, ah sorry,
immer... Bitte
Ja, da muss ich jetzt auch, also die Frage war jetzt,
also warum heißt es hier an dieser Stelle,
was Umschlüsselung und nicht Umkodierung?
Da muss man jetzt natürlich immer sagen, müsste jetzt nur mal
in die Definition reingucken. Also ich habe das jetzt natürlich,
also hier erstmal so relativ hemsärmlich als Synonym benutzt.
Formal gesehen ist eine Umschlüsselung dann, glaube ich, bjektiv.
Das heißt, es funktioniert in beide Richtungen. Möchten wir
hier in dem Fall eigentlich auch haben? Und alles,
was ich auch bislang immer sonst an Umkodierung habe,
sind eigentlich mathematisch gesehen an Umschlüsselungen
Aber das hat jetzt hier nichts Besonderes zu sagen,
dass sie hier so nochmal spezielle Eigenschaften auftreten.
Nein, nein. Gut, ja, aber kommen wir
wieder zurück zu dieser Aufgabenstellung. Also ich habe jetzt irgendwie
eine Anzahl von Symbolen, die kodiert werden sollen.
Und ich habe deren Auftretenswahrscheinlichkeiten. Das heißt also,
ich weiß jetzt irgendwie, Apriori, wie häufig kommen die vor?
Also beispielsweise die Buchstaben der deutschen Sprache,
dann könnte ich mir also irgendwie ein Programm schreiben,
wo ich also irgendeine Textdatei durchsage und dann wird eben quasi mitgezielt,
wie oft Wie häufig sind welche Buchstaben?
Und wenn ich das über einen hinreichen, großen Korpus mache,
kann ich dann eben sagen, okay,
Buchstaben der deutschen Sprache sind so mit den und den Wahrscheinlichkeiten dann irgendwie da.
So, jetzt ist eben die Frage,
wie komme ich jetzt von dieser Information? Das heißt,
ich habe meine Zeichen und deren Auftretenswahrscheinlichkeiten zu einem irgendwie gearteten Code,
der jetzt also die Prefix-Eigenschaft erfüllt.
Dazu gibt es zwei Verfahren. Das erste Verfahren ist das,
was also hier auf dieser Folie beschrieben ist,
nach dem Herrn Farno,
beziehungsweise findet man teilweise auch unter Shannon
Farno Kodierung
Dabei funktioniert der Algorithmus so, dass sich die Urwörter anhand
ihrer Wahrscheinlichkeiten in absteigender Reihenfolge sortiere. Das heißt,
das Wahrscheinlichste zuerst, dann das Nächstwahrscheinlichste und so weiter,
bis ich die hier habe. Anschließend in dieser sortierten Liste
bilde ich dann quasi zwei Gruppen oder zwei Mengen mit möglichst gleicher Gesamtwahrscheinlichkeit.
Und in der Kodierung bekommt dann eben die erste Gruppe mal
wegen Die Null zugewiesen, die zweite Gruppe, die eins zugewiesen.
So, und das mache ich jetzt für diese Teilmengen quasi rekursiv wieder,
bis ich in jeder Gruppe nur noch ein einziges Symbol habe.
Das ist also grob skizziert eigentlich das Verfahren. Beispiel werde ich
gleich dazu zeigen. So wie man sich denken kann,
funktioniert das natürlich umso besser,
je größer die Anzahl der Elemente ist,
weil ich das dann also quasi immer entsprechend feiner unterteilen kann
Grundsätzlich kann man auch mal sagen, so eine Kodierung ist
nicht eindeutig. Deswegen kann ich auch immer nur sagen,
dass es also bei der Korrektur von Klausuren dann auch einmal eine ungeliebte Aufgabe,
die zu korrigieren, weil man nicht sagen kann,
das ist die richtige Lösung,
sondern es gibt mehrere richtige Lösungen.
Nicht also ganz einfach, wenn ich hier also irgendwie die Dinger sortiere,
hier steht größer, leicht, zwei Elemente mit gleichen Wahrscheinlichkeiten,
kann ich also beliebig unterschiedlich da einsortieren.
Und die andere Sache ist,
die eine Teilgruppe bekommt null die andere eine eins,
auch das kann man
sich beliebig irgendwie ausdenken
Gut, aber kommen wir jetzt da zum praktischen Beispiel.
Also ich habe jetzt hier die vier Buchstaben, A,
B, C, D,
die Wahrscheinlichkeiten für die Buchstaben wären von 0,45 oder 0,45,
0,1, 0,1,
5 von 0,3. Um das hier so ein bisschen übersichtlich herzuschreiben,
habe ich jetzt also hier quasi das Komma als Trendzeichen und für die das Komma im mathematischen Sinne steht hier ein Punkt.
Nicht nur, dass ich jetzt nicht wundern,
was ist das jetzt hier wieder oder so,
das ist jetzt einfach nur um das hier
irgendwie dann grafisch so ein bisschen übersichtlicher zu machen
Gut, ja, erster Schritt, wie gesagt,
die Zeichen entsprechen ihren Wahrscheinlichkeiten, sortieren in absteigender Reihenfolge,
also A, hat die größte Wahrscheinlichkeit,
die hat die nächst kleinere Wahrscheinlichkeit, C und B,
dann habe ich also hier diese Sortierung.
Anschließend werden die, wird diese sortierte Liste oder diese sortierte Menge
dann quasi unterteilt in zwei Gruppen mit möglichst gleichen Wahrscheinlichkeiten,
in dem Fall ist das eine Teil entsprechend mit A,
hat die Gesamtwahrscheinlichkeit 0,45 und den anderen dann quasi mit D, Gesamtwahrscheinlichkeit 0,55.
So, und jetzt kann ich also eben auch rein willkürlich dann eben sagen,
ah, wird mit einer Null kodiert,
alle anderen erhalten quasi hier einmal eine Eins und anschließend
muss ich dann für diesen Tal das Verfahren dann quasi wiederholen,
solange ich dann eben jetzt nur noch Elemente habe oder bis
ich dann eben nur noch Elemente habe,
die dann also quasi ein Elementegemengen sind
Nicht in diesem Fall, würde ich dann also hier in zweite Unterteilung machen,
die wieder als null kodiert und C und B dann als eins.
Und in einen letzten Tagen dann C als null und B als eins.
Und dann habe ich also quasi als Gesamtcode, ah,
wird durch eine Null kodiert, die durch 1-0,
C durch 1-1-0 und B durch 1-1-1. So,
und wenn man sich jetzt überlegt, mittlere Codewortlänge,
also sprich überhin reichen viele Zeichen, was passiert,
wenn ich diese vier Zeichen mit einem Blogcode kodieren würde,
brauche ich um die vier Zeichen zu unterscheiden,
genau zwei Bit
Was ich hier jetzt bei diesem Code erreicht habe,
ist dieses Zeichen mit der größten Wahrscheinlichkeit, nämlich A,
wird mit einem Bit kodiert, demzufolge,
es gilt dann eben, dessen Auftretenswahrscheinlichkeit mal ein Bit.
Dann habe ich D, dessen Wahrscheinlichkeit mal zwei Bit,
C und B sind jeweils drei Bit lang,
multipliziert mit den Auftretenswahrscheinlichkeiten und wenn ich das dann alles zusammen addiere, erhalte ich 1,8.
Das heißt, die mittlere Codewortlänge ist Kleiner als zwei. Nicht. Das heißt,
das ist eben dann wirklich so ein Zeichen dafür,
dass wenn ich jetzt eben entsprechend viele Daten übertrage, viele Zeichen übertrage ich da dann dementsprechend was gewonnen habe.
Gut, sowas kann man dann eben beispielsweise für entsprechende größere Zeichensätze machen. Also hier als Beispiel Wahrscheinlichkeiten oder Auftretenswahrscheinlichkeiten der deutschen Großbuchstaben,
habe dann also irgendwie so einen ganzen Satz von Wahrscheinlichkeiten,
kann dann eben nach so einem Verfahren dann irgendwie so einen Baum aufbauen und das geht dann eben quasi von Codierung für die häufigen Zeichen,
E-N- und R mit jeweils drei Bit,
dann eben bis zu zwölf Bit für Zeichen,
die also relativ unwahrscheinlich sind, wie Kuh oder X. Gut,
als zweites Verfahren, was man dort einsetzen kann,
ist dann ein Verfahren nach dem Herrn Huffman,
beziehungsweise nennt sie dann Hafenencodierung.
Auch dort habe ich die entsprechend zu kodierenden Zeichen.
Ich habe die Wahrscheinlichkeiten. In diesem Fall,
wenn jetzt hier in aufsteigender Reihenfolge sortiert.
Und der Algorithmus sieht dann eben so aus,
dass also quasi in jedem Schritt die beiden Zeichen mit den Kleinsten Wahrscheinlichkeiten,
also die beiden Linksstehenden einfach genommen werden.
Durch quasi ein neues oder ein Metazeichen ersetzt werden,
was dann quasi die Gesamtsumme der oder der Wahrscheinlichkeiten dieser beiden Zeichen entspricht.
Dies wird dann wieder passend einsortiert und das Ganze wird eben
so lange wiederholt
Dass ich eben nur noch bei einem einzigen,
bei einer Menge mit zwei Wörtern beziehungsweise dann eben nachher,
bei einem letzten Zeichen bin.
Auch dazu kommt jetzt gleich nochmal das Beispiel. Dieses Verfahren nach Huffman,
er gibt eben auch mathematisch beweisbar die kleinstmöglichen, mittleren Codewortlängen,
verglichen mit dem anderen Verfahren von Fano, sind die Unterschiede aber relativ gering.
Also im Prinzip sind beide funktional gut oder entsprechend ganz gut.
Hafman habe ich hier deswegen nochmal explizit also auch noch mit darauf gezielt,
weil das also auch technisch relativ häufig benutzt wird,
also im Prinzip bei diesem ganzen JPEG-Mpact-Standards sind unter anderem auch Hafman-Codierungen mit drin,
um dort also entsprechend Sowas mit reinzubringen.
Gut, wie sieht das hier in dem Beispiel aus?
Also ich habe jetzt hier also auch wieder meine Zeichen AWCD,
die entsprechenden Wahrscheinlichkeiten aufgrund der Sortierung ergibt sich dann diese Reihenfolge.
Die beiden Zeichen mit den Kleinsten Wahrscheinlichkeiten, also B und C
, würde ich zusammenfassen. Es ergibt einen neuen Wert E.
Der wird dann quasi wieder irgendwo passend einsortiert. Anschließend werden dann geguckt,
was führe ich da dann noch zusammen und hätte dann jetzt
im Prinzip anschließend dann noch dieses E und denn wie hat
die denn als wieder nächstes Element und würde das machen und laden dann eben letztendlich hier bei diesem Code ein bisschen anschaulicher,
wird das, wenn ich das jetzt für ein etwas größeres Beispiel mache,
also hier habe ich ein Alphabet aus sechs Buchstaben, diesmal jetzt hier keine Wahrscheinlichkeiten, sondern relative Häufigkeiten.
Und wenn man das jetzt also quasi mal wirklich so als Baum aufbaut,
weil dann wird das ja so, glaube ich,
auch ein bisschen klarer, sieht man,
also ich habe die jetzt also hier in entsprechend aufsteigenden Wahrscheinlichkeiten sortiert,
würde dann eben die beiden Elemente mit den geringsten Wahrscheinlichkeiten nehmen.
Daraus dann also hier dieses neue Element machen,
was dann also quasi der Summe entspricht,
also sprich den sechs, das wird dann eben irgendwo einsortiert,
wie das dann also hier der Fall ist.
Auch hier sieht man, ist nicht eindeutig,
nicht weil also diese sechs kann ich letztendlich hier hinter dem N oder vor dem N einsortieren.
Also auch da keine eindeutige Kodierung in dem Sinne.
Ich würde dann also hier einsortiert und ich fasse dann
eben rekursiv immer jeweils die beiden niedrigsten zusammen,
also im nächsten Schritt jetzt die beiden.
Würde das dann also hier entsprechend an dieser Stelle einsortieren,
anschließen wird dann eben die sechs und das S zusammengefasst
Passend einsortiert und so weiter und so fort, bis ich
dann eben letztendlich aus dem Ganzen diesen Baum aufgebaut habe.
Und dann kann ich jetzt an dieser Stelle,
wenn ich eben hier irgendwie so ein String bekomme,
aus diesem Baum, also aus meinetwegen,
oder hätte ich dann also hier entsprechend die Zuordnung zu den Zeichen.
Und wenn ich dann eben hier irgendwie so ein Bitstring bekomme,
kann ich dann eben aus diesem Baum 1-0,
0-1, das als er sofort lesen,
0-0 als I und so weiter.
Das heißt, das ist dann eben auch so eindeutig
Riese daraus zu dekodieren
Gut, das wäre jetzt mit drei Minuten überzogen Verfahren nach Huffman.
Ja, dann, bevor die Sonne ganz untergeht,
ein schönes Wochenende, beziehungsweise es ist ja noch weitere Vorlesungen.