So, Mittwoch hatte ich ja aufgehört, beziehungsweise bin ich ja
so relativ schnell hier durch die Bulschärge war und die logischen Operationen durchgegangen. Wie gesagt,
das war es, man davon eigentlich wissen sollte,
was hängen bleiben sollte, neben der Bulschen Algebra logischerweise,
wovon ich aber davon ausgehe, dass sie das eigentlich kennen,
sind halt eben die Schieber-Operationen,
beziehungsweise da eben die Unterscheidung beim Rechtsschiften zwischen logischem und arathmetischen
Schieben und eben die entsprechenden Rotationsoperationen
Als letzte Folie hatte ich ja im Prinzip,
wenn diese hier aufliegen, wo es also im Prinzip darum ging,
dass man teilweise sowas wie Multiplikationen eben beispielsweise dadurch ersetzen kann,
dass man Schiebeoperationen und Additionen nutzt,
wobei das dann eben letztendlich automatisch durch die Compiler passiert nicht,
aber das heißt,
wenn man in seiner Programmiersprache eben irgendwelche Ausdrücke hat,
wo eben teilweise mit konstanten multipliziert wird,
beziehungsweise eben auch noch in einigen anderen Fällen,
bauen die Compardern eben solche Mechanismen ein, weil,
wenn das zumindest ein vernünftiges Tool ist,
das dann eben entsprechend schon weiß,
also Multipligation dauert so und so viele Takte und eine Addition beziehungsweise Schieberoperation dann eben in der Regel einen Takt und dadurch kann man dann eben noch einiges an Performance gewinnen.
Gut, weitere Anwendungsbeispiele, wofür man das braucht,
also es wird uns also dann später auch noch in anderen Sachen begegnen,
aber hier nochmal so kurz zusammengefasst, sind halt eben Sachen,
die man also auch immer häufig macht,
wo man ein ganzen Indigers drin oder eben so ein entsprechendes Indiger-Wort,
quasi als Folge oder Menge einzelner Bits letztendlich versteht.
Also häufig ist das zum Beispiel bei sowas wie,
also hier im Prozessor X86,
da gibt es eben irgendwie so ein Flag-Register,
das ist also letztendlich ein einziges großes Register,
da stehlen eben so ein String drin und jedes der einzelnen Bits hat dann eben eine bestimmte Bedeutung,
die sich also jetzt also beispielsweise dann eben aus irgendwelchen arathmetischen Operationen oder irgendwelchen anderen internen Prozessezustände heraus ergeben.
So, um jetzt in so einem Wort beispielsweise einzelne Bits zu setzen oder einzelne Bits zu löschen,
ist sie also zum Beispiel eben mal so ein Sample-Code demonstriert,
dass ich ein Jahr war, wo man dann eben sieht,
das, was man dort dann immer macht,
ist dann nämlich genau diese Sache mit der Schieberoperation.
Man nimmt im Prinzip eine Eins, Eins kodiert,
hat eben an der niederwärtigsten Stelle die Eins, wird um P-Stelle nach links geschoben.
Das heißt, man hat dann im Prinzip so einen Ausdruck,
wo ich dann eben abhängig von dieser Position eben Hier eine Maske mir erzeugt habe mit diesem Ausdruck,
der dann eben aus lauter Nullen besteht,
an der Peten, beziehungsweise hier als Argument, Positionsstelle,
ist dann eben eine einzelne Eins und dann wieder Nullen.
Und wenn ich das jetzt eben mit einem Integer-Wert,
mit einem Bittweisen oder Verknöpfe,
wird eben genau an dieser Stelle Position das einzelne Bit gesetzt,
wenn es vorher nicht gesetzt war, wenn es vorgesetzt war,
okay,
dann bleibt das eben Gesetz.
Alle anderen Bits werden dementsprechend übernommen
So ein einzelnes Bit löschen, wäre dann beispielsweise an dieser Ausdruck.
Auch hier wird im Prinzip erst diese Maske erzeugt.
Dann mit dieser Tildo-Operation ein Bittweise Negation gemacht. Nicht dem
zuvor habe ich dann als Maske lauter einzeln und an der einen Petenstellern eben eine Null.
Nicht und wenn ich das jetzt bittweise für Hunde mit einem Ausdruck,
heißt das eben rein technisch gesehen alles,
was also hier an diesen Stellen gesetzt ist,
wenn es eine Eins ist, bleibt es erhalten.
Wenn es eine Null ist, bleibt die erhalten.
Aber an dieser einen Stelle eben explizit wird,
egal was da dann auch war,
hinterher eine Null stehen
Eine andere Sache,
wo sowas dann also auch immer noch genutzt wird,
also mit solchen Schiebeoperationen, mit solchen Mitweisen, Operationen,
ist eben in Zusammenhängen, wo es darum geht,
dann auch wieder irgendwelche Teile von irgendwelchen Werten aus zu maskieren,
vielleicht gegeneinander zu tauschen.
Also dieses Sieg ist also Ausschnitt aus dem Standardquellcode,
den man, also sag mal jetzt so,
auf irgendwelchen Linux-Systemen, egal ob das Open Souse,
Ubuntu,
was weiß ich ist,
mehr oder minder findet
Insofern man da so ein bisschen Entwicklungsumgebung installiert hat, wo es darum geht,
also im Prinzip in einem 32-Bit-Wort, die einzelnen Bytes gegeneinander auszutauschen.
Kann ich. Ich immer kurz. Versuche mit Kreide zu demonstrieren. Nicht,
also das, was dort letztendlich dann passiert ist,
dass man sagt, ich habe hier 1,
32 Bitwort, also quasi Menge einzelner Bits,
habe jetzt hier jeweils meine vier Bite und das war es dann diese Funktion oder dieser,
ja so ein Precompiler-Ausdruck in C, ist das eigentlich technisch gesehen,
das was der dann eben macht, ist,
dass er dieses Teil hierhin sortiert, dieses hierhin,
dieses hierhin Und dieses hierhin und ich stand eben wieder 1,
32 Bitwort habe.
Rein technisch gesehen passiert das jetzt eben dadurch, dass man sagt,
also ich habe hier immer irgendwie die einzelnen Masken,
die also jetzt quasi hier von diesen 32 Bild,
also mit dieser konstanten,
mit FF dann immer zum Beispiel jetzt also in diesem Fall dann,
also hier diesen Teil ausmaskieren würden.
Alles andere wird auf null gesetzt,
das Ganze wird dann um 24 Bit
logisch nach rechts geschoben
Das heißt, das Ergebnis landet dann 24 Bit weiter unten,
nämlich genau an dieser Stelle,
analog dazu ist dann eben das Vorgehen bei den anderen Sachen,
wo dann eben hier um 8 Bit geschoben wird,
hier nach links und hier auch nach links.
Das sind dann diese unteren beiden Ausdrücke. Und das Ganze wird dann wieder bittweise verodert.
Und dann hat man im Prinzip genau diese Operation gemacht.
So, jetzt kann man sich natürlich fragen, wofür braucht man solchen Unsinn?
Außer um die Leute jetzt in den Vorlesungen zu langweilen.
Dahinter steht dann etwas, was uns also dann deutlich später noch begegnen wird,
weil das ja so im Prinzip so ein Speicherorganisation geht.
Und zwar geht es da dann also um diesen Begriff der Indianess.
Nicht deswegen wird dann hier irgendwie sowas mit Little-Andien abgefragt.
Und zwar verbirgt sich dahinter also im Prinzip das Problem oder die Idee,
dass man sagt, okay,
wenn ich jetzt einen Hauptspeicher habe in meinem Hauptspeicher,
jetzt also irgendwelche,
meinetwegen jetzt 32 Bitbreiten Worte in Form von Indian-Zahlen irgendwo abgelegt habe.
Und ich kann diesen Hauptspeicher beidweise adressieren
Das ist also das, was,
also beispielsweise jetzt bei X86-Rechnern typischerweise der Fall ist,
dass man da jetzt also nicht irgendwie ein ganzes Speicherwort adressiert,
sondern wirklich die einzelnen Bytes im Speichern.
Die sind jetzt aber in einem längeren String irgendwo abgelegt.
Und jetzt ist eben die Frage, wenn ich also ein 32-Bit-Indiger nehme,
im Speicher, wo fange ich an zu zählen?
Ist das Adresse 01, 2,
3 oder zähle ich andersrum 01, 2, 3?
Das heißt, fange ich mit den höchstwertigsten Bits eines Indigest-Drings
an oder fange ich mit den niederwärtigsten Bits an
So, und da ist es halt eben so,
dass auch historisch gesehen, also die eine Art von Rechnern,
das also in der einen Art kodiert hat,
die andere Art von Rechner ist in der anderen Art kodiert hat. Stört erstmal nicht weiter.
Schlecht wird es, wenn man Daten austauschen möchte,
weil dann quasi ganz andere Zahlen bei rauskommen.
So, und genau dieses Austauschen von Daten findet statt über das Internet.
Deswegen findet sich dieses dann eben auch hier in dieser Bibliothek Lip INET,
wo es nämlich darum geht,
im Prinzip dann also quasi Kommunikation nach außen zu machen.
Und da gibt es eben eine festgelegte Reihenfolge, wie die Daten abgelegt werden.
Und je nachdem, ob der Rechner nun PC ist oder
eben irgendein IBM-Großrechner oder irgendein Mac wird dann abhängig davon,
wie das Betriebssystem bzw. den Rechenarchitekt-Thru das handhabt,
dann eben entweder das Ganze noch umgebaut oder nicht umgebaut.
Das ist das, was ich letztendlich technisch gesehen dahinter verbirgt
Nicht, aber das ist dann eben auch so ein Beispiel für etwas,
wo man also im Prinzip diese Maskierung, diese logischen Operationen braucht.
Und ich denke mir, also wenn die dann also in der Programmierung,
in irgendwelchen Programmieraufgaben sind und teilweise dann eben auch sogar so
ein bisschen Hardware näher dann auch irgendwo arbeiten mit irgendwelchen Sensoren,
mit irgendwelchen Schnittstellen, kommt man also öfter mal in die Verlegenheit dann sowas,
also irgendwie anwenden zu müssen.
Anderes Beispiel, Farbbilder, nicht also typischerweise,
ich habe jetzt also irgendwie so ein zweidimensionales Bild mit
x mal Y
Breite, mal Bildtühe, Bildpunkte. In so einer Standard
additiven Farbmischung bzw. Farbkuddyon, also Rot, Grün und Blau.
Nicht jetzt noch nicht sonderlich hoch aufgelöst. Dann kann ich sagen,
okay, also für jede Farbe spendiere ich acht Bit,
habe dann also quasi 255 verschiedene Werte,
die man da unterscheiden kann und einen Bildpunkt wird dann typischerweise dann eben durch ein 32 Bit Integer Wert repräsentiert.
Und Man hat dort dann eben im Prinzip jeweils acht Bit, rot,
grün und blau und entweder bleiben die Ohren bis leer oder
wenn man da jetzt noch so was wie Transparenz mit drin hat,
dann hat man da dann eben noch so benutzt,
die dann eben für diese Transparenz, also sprich den Alpha-Kanal.
Also das wird teilweise dann auch noch einen entsprechenden Bibliotheken von den Programmiersprachen,
also beispielsweise hier in Java dann irgendwie mitbenutzt oder unterstützt.
Und damit könnte man jetzt eben zum Beispiel sowas machen,
dass man sagt, okay,
wenn ich jetzt also hier irgendein Bild habe,
das habe ich als Datenstruktur quasi hier als gespeichertes Image irgendwo vorliegen.
Und ich möchte davon, also jetzt den Rotkanal rausziehen,
also einen Rotfilter bilden. Nicht würde man das dann eben typischerweise so,
erstmal jetzt also trivialerweise so schreiben, dass man dann eben sagt,
okay, ich laufe einfach durch das Bild.
Zahlenweise, spaltenweise entsprechend durch, hole mir dann also
quasi meinen RGB-Wert von der entsprechenden Position.
Ich mache dann eben hier mit so einer Maskierung den,
nehme den Rotanteil raus und schreibe denen also beispielsweise jetzt
in mein Ausgangsbild
Beziehungsweise hier wäre ja das Ganze dann also für so einen einfachen Grauwertfilter,
wo man also im Prinzip dann also aus so einer Darstellung ein Grauwertbild macht,
ist letztendlich das gleiche Verfahren, einmal über sämtliche Bildpunkte iterieren,
den RGB-Wert quasi lesen, dann rot, grün und blau Kanal,
also dann jeweils durch diese Maskierung aus diesem Wort rausholen.
Dann habe ich hier wieder dies logische Rechtsschieben,
damit ich alle drei Werte dann quasi jetzt wirklich als Zahlen habe,
wo ich dann eben hier unten irgendwelche Werte zwischen 0 und 255 erhalte,
für das Grauwertbild wird das jetzt eben noch alles gemittelt.
Das heißt,
sie werden hier einmal aufsummiert durch drei geteilt und ich erhalte dann
den entsprechenden Wert hier und wenn ich dieses Grauwertbild jetzt aber auch wieder in so einem 32-Bit-Format machen möchte,
muss ich daraus dann eben Folgendes machen,
dass ich eben diesen Wert nehme,
und sowohl für den Blauen als auch für den Grünen,
als auch für den roten Farbkanal quasi setze.
Das ist das, was dieser Ausdruck nämlich macht,
dass ich hier den Wert nehme,
ihn dann hier nochmal um acht Bett, nach links schifte,
dann ist man also genau hier in diesem Bereich oder um 16 Bett,
dann ist man in diesem Bereich,
das Ganze wird dann wieder mitweise verodert und dann hätte man dann eben wieder so ein entsprechendes RGB-Bild als Ausgang,
was dann aber in diesem Fall dann jetzt also im Prinzip dann Grauwerten entspricht.
Eine andere Sache, wo man das also auch häufig braucht,
ist dann etwas, was dann hier als Algorithmus mal so als Bitcount beschrieben wird.
Oder da geht es dann um eine Aufgabenstellung,
die wird uns dann also im nächsten Kapitel bei der Kodierung dann nämlich interessieren.
Wo man sagt, ich habe ein Wort in dem Wort oder in dem Manager Wort,
möchte ich wissen, wie viele Einsen vorkommen.
Das heißt, ich zähle jetzt einfach für alle Stellen die Einsen durch.
Kann man jetzt relativ einfach dadurch letztendlich programmieren, dass man sagt,
Hab hier meine Zielvariable, die wird mit null initialisiert.
Hier iteriere ich eben so lange durch, bis das Ergebnis gleich null ist.
Ich weil, dann kommen keine Einsen mehr. Und das eigentliche Zielen findet dadurch statt,
dass ich also quasi jetzt den bisherigen Wert nehme und eben drauf addiere, diesen Ausdruck,
wo ich dann eben im Prinzip also von dem X,
das ohneste Bit ausmaskiere, Das heißt, ich erhalte dann eben wirklich arathmetisch gesehen nur eine Null oder eine Eins.
Und die wird dann eben hinzugezählt und damit das Ganze überhaupt erstmal sowas wie eine Iteration macht,
würde ich, dann schiebe ich anschließend,
dass X dann auch wieder mit einem logischen Schieben um eine Stelle nach rechts.
Und so wird dann immer jeweils auf der untersten Stelle das Bit letztendlich verglichen und geguckt. So,
das ist eigentlich, sagen wir mal so,
der naive oder der Standardalgorithmus,
wie man das jetzt also irgendwie programmieren würde mit so einer Schleife,
ist natürlich vergleichsweise langsam, weil ich dann ja also maximal 32 Schritte brauche jetzt für ein 32-Bit-Engiger, um das zu berechnen.
Es gibt also auch noch diverse, tricksigere Algorithmen, die sowas machen. Also hier sind nun mal zwei aufgezählt,
die will ich jetzt also gar nicht im Einzelnen genau vorstellen,
weil auch da kann man nur sagen,
also wenn man sich hier mal im Netz umguckt,
findet man da also relativ viel und es gibt also relativ viel von diesen Bitcount-Algorithmen,
was also daran liegt, dass diese Aufgabenstellung eben für viele andere Sachen gebraucht werden.
Das, was hier dem zugrunde liegt, von der Idee her,
ist, dass man im Prinzip so eine baumartige Parallele Berechnung macht.
Das heißt, wenn man Dort jetzt also irgendwie sein Bit-Vactor hat,
dass man im Prinzip immer jeweils in einer Stufe oder in
der ersten Stufe quasi jetzt zwei übernachbarte Bits miteinander vergleicht oder zusammen addiert.
Das heißt, also hier kann ich dann eben 0-1 oder 2 stehen haben.
In 2 Bit codiert das Ganze passiert dann eben anschließend für
4 Bit-Blöcke und so weiter und damit kriegt man dann also
quasi dann mit einer Stufe von 4 Let's nehmen in der Stufe von 5 dann eben letztendlich diese Summe hin.
Und das ist das, was ich dann,
also sag mal, hinter diesen Ausdrücken verbirgt,
müsste man dann, aber also jetzt um das wirklich genau nachzuvollziehen,
dann also wirklich genau einzeln aufschreiben und dann eben gucken,
wie das funktioniert, weil das erschließt sich dann so ganz einfach immer nicht.
Nicht aber Grundidee ist immer hier, dass man,
also was man hier sieht, also ich habe immer Maskierungen mit solchen Mustern,
dass ich hiermit also quasi immer einzelne Bits ausblende bzw. diese Gruppenbilde,
also zum Beispiel 3, 3, Hexa de Zimal ist halt eben zum Beispiel
0,011. Das heißt, damit habe ich eben genau immer zwei
benachbarte Bits maskiert und zwar dann wieder nicht maskiert.
Und mit entsprechend anderen Mustern,
also hier mit der 5 habe ich 0-1,
0-1, nicht also das ist immer das,
was dort dann eigentlich daran unter anderem an mit dahintersteht.
Wie gesagt, also dies mit diesen Bitcounts,
da gibt es also relativ viele sehr, sehr tricksige Algorithmen.
Teilweise haben sogar, also gerade so bei Signalprozessoren,
aber auch jetzt in den neueren Befehlssätzen die Prozessoren sogar einen
eigenen Bitcount-Befehl
Braucht man eben, wie gesagt, häufig für bestimmte Kryptographie-Algorithmen
beziehungsweise für einige andere Sachen in der Datenübertragung.
Also wie gesagt, das mit der Anzahl der gesetzten Bits
wird uns dann also gleich noch am nächsten Kapitel kurz begegnen.
Gut, hier auch nur aus der Literatur, auch nichts,
was er jetzt irgendwie zwingend selber nachzuprogrammieren ist.
Also wie gesagt, von Donald Knut,
The Art of Computer Programming
Auch noch so ein paar Tricks da rein,
wo auch über Bittweise Invertierung bzw. einfache Bit-Operationen im Prinzip in sowas wie Komplimentbildung berechnet wird,
beziehungsweise ein bestimmter anderer athmetische Eigenschaften berechnet werden.
Wobei ich das dann eben jetzt nicht über ehrenmetische Funktionen mache,
sondern eben wirklich über irgendwelche Bit-Operationen und Maskierungen. Und zwar,
das, was hier im Prinzip jetzt mal so dahinter steht,
ist, also wenn ich sage,
ich habe ein Ende der X,
der ist jetzt beschrieben
als irgendein String
Den ich also vorne stehen habe, dann eine Null,
eine beliebige Anzahl von Einsen. Kann auch Null sein,
dann genau eine Eins und dann eben eine beliebige Anzahl von Nullen.
Auch das kann letztendlich Null sein. Dann hat man im Prinzip außer
den beiden Sonderfällen x gleich Null, wo ich nur Nullen habe.
Damit ist dann diese Bedingung verletzt oder x gleich minus zwei hoch B,
also quasi die größte negative Zahl,
wo ich also nur eins entstehen habe, damit ist diese Bedingung verletzt,
also gilt dieses im Prinzip eigentlich für alle Zahlen.
So, und jetzt kann man sich überlegen,
wenn dir das jetzt meine Zahl X ist, X negiert,
ist halt eben hier jeweils einfach die Stellen,
nicht also null und A eins jeweils entsprechend vertauscht.
Nicht das entspricht an dem Eins-Kompliment. Dann Wenn ich jetzt diesen,
oder wenn ich jetzt sage, also x,
minus eins, was wäre das dann?
Nicht, das wäre im Prinzip folgendes, dass ich hier
aus den Nullen überall Einsen machen würde und hier diese Eins zu einer Null wird.
Nicht, das ist nämlich genau das,
wenn ich im Prinzip jetzt also irgendeinen aratmetischen Ausdruck habe,
wo ich sage, also ich habe hier eine Eins und irgendwie hier lauter Nullen,
wie viel auch immer davor.
Ich rechne minus eins, nicht in das, was rauskommt,
ist Genau, null. Und hier lauter Einsen. Nicht,
das ist also das, was im Prinzip von hier,
nach hier passiert und der Rest bleibt so erhalten.
So, und minus X wäre, ist ja quasi dann,
also das Zweierkompliment wäre dann also quasi das einer Kompliment plus eins.
Das ist dann nämlich genau wieder das Umgekehrte,
dass ich sage, ich habe hier hinten lauter Einsen,
da eine Null, addieren eine Eins drauf.
Das heißt, von X zu minus X habe ich hier
jeweils eine Mittweise in Vertierung und Ähm. Letztendlich bis zur,
am weitesten rechts stehenden Eins bleibt das dringend dann eben genauso erhalten.
Denn damit kann man dann eben noch so diverse andere Sachen oder Ausdrücke bilden.
Wie gesagt, das darf, kann, muss aber nicht
jeder selber nachvollziehen. Wo man dann also sagen kann,
also wenn ich jetzt also hier quasi so meine Zahlen habe,
ich möchte jetzt also irgendwie die Am weitesten rechts stehende Eins entfernt,
ich könnte ich das übel, diese Operation, also hier draus generieren,
die am weitesten stehende Eins möchte ich extrahiert haben.
Das heißt also, bis auf genau diese Eins soll alles auf Null gesetzt werden,
lässt sich das also hier mit den Operationen machen.
Ich kann dann, also hier ist eine Eins nach links verschmieren,
ich kann die entfernen, den Rest verschmieren und so weiter.
Also wie gesagt, damit kann man so einige Sachen machen,
wo man also quasi aus diesen Bitstrinks damit dann irgendwie was macht,
was man dann also vielleicht auch für bestimmte mittweisen,
Operationen, Maskierungsoperationen, also gelegentlich benötigt.
Gut, das war jetzt eigentlich so das,
was Beispiele zu den logischen Operationen waren.
Dann kommen wir jetzt eigentlich wieder zu den Sachen,
wo es also jetzt wieder mal so ein bisschen neueres Terrain ist,
was sie also vielleicht dann also auch noch nicht zwingt aus der Schule kennt.
Nächer sei es anders als Arrath Metik,
Zeichnerstellung oder eben hier Gutsche Algebra
Wo ich jetzt also einige Begriffe der Codierung und Codierungen vorstellen werde,
beziehungsweise einiges von den Codierungen haben wir letztendlich also auch schon rein praktisch gesehen.
Im dritten, vierten Kapitel war dann ja vieles Kapitel,
war dann also im Prinzip so ein bisschen schon mal
was zur Informationstheorie,
also da ist ja im Prinzip schon diese Sache
mit der Repräsentation aufgetaucht
Das ist eigentlich das,
was dann also letztendlich hier der Codierung zugrunde liegt,
dass man eben sagt, ich habe eine bestimmte Repräsentation,
wo ich irgendwelche Informationen sei, das ist eine Zahl,
sah, das ist ein Buchstabe,
was weiß ich auch immer irgendwie kodiert habe durch den Bitstring.
Das setze ich in einen anderen Bitstring oder eine andere Art der Codierung letztendlich um.
Kann in unterschiedlichen Abstraktionsebenen stattfinden. In der Regel findet das in der Leichenabstraktionsebene statt,
also das, was wir immer haben,
dass man sagt, okay,
ich habe letztendlich sowas wie eine Zahl als Information,
ich kodiere die nur anders,
weil ich da
eben bestimmte Eigenschaften jetzt irgendwie mit erreichen möchte
Was dann natürlich klar sein sollte, ist also,
dass letztendlich sowas wie eine Eindeutigkeit in der Interpretation gegeben sein muss.
Und wenn das umkehrbar eindeutig ist, was er meistens auch haben,
dann kann man eben von einer Unkodierung sprechen.
Dann ist es letztendlich eine Bier tiefe Abbildung. Hier dann auch nur trivial einige Begriffe,
Codewörter sind dann eben letztendlich alle Wörter,
die jetzt meinem Code gehören,
beziehungsweise der Code ist dann die Menge der Codewörter,
Blogcodes liegen genau dann vor,
wenn alle Codewörter
genau die Leichelänge haben
Und das, womit wir hier natürlich arbeiten,
ist dann eben, dass man binär arbeitet,
das heißt mit einem Zeichen vor Ort von genau zwei Zeichen,
wie Nährwörter beziehungsweise Binärkot stehen dann letztendlich dahinter.
Gut, weswegen braucht man überhaupt so was wie Kodierung? Verschiedene Gründe. Zum einen,
um jetzt überhaupt erstmal die Informationen darzustellen und zu verarbeiten,
nicht letztendlich die Zahlendarstellung im Rechner, ist, so rum gesehen,
ja auch nur eine bestimmte Kodierung, dann für die Daten Kompression,
beziehungsweise Reduktion von Daten gibt es dann eben verschiedene Kodierungsverfahren.
Bei der Datenübertragung braucht man relativ viel an Codierung, aus unterschiedlichsten Gründen.
Zum einen eben auch vor diesem Hintergrund der Kompression, dass man also die zu übertragene Datenmenge verringern möchte. Zum anderen,
ich hatte ja in diesem vierten Kapitel,
wo es ja so im Prinzip um die Information ging,
also ja schon gesagt, also wenn Informationen von A nach B übertragen wird,
kann es dabei eben zu Störungen kommen, um Diese Störung letztendlich ausgleichen zu können, kann man dann eben viele Korrekturen, beziehungsweise überhaupt erstmal Fehlerkennung, aufsetzen. Und aktuelles Thema,
wo dann Coudierung eben auch benötigt wird,
ist dann eben bei der Schiffrierung, also sprich in der Kryptologie,
wo man dann eben quasi die übertragene Daten, also so darstellt,
dass jemand, der das jetzt also irgendwie mitliest,
damit in der Regel erstmal nichts anfangen können soll,
beziehungsweise in dem Zusammenhang dann eben auch noch um Stichwort Identifikation,
Authentifikation, wo es dann also auch darum geht,
also jetzt nicht nur die Übertragung der Daten zu sichern,
sondern eben auch noch zu sichern,
wenn ich eine Information von der A nach B schicke,
dass ich weiß, wer ist B,
ist das auch der richtige Rechner, beziehungsweise der,
wenn der was entgegennimmt,
dass da Absender eben der richtige ist, das sind,
also das ist im Prinzip das,
was mit diesen beiden Stichworten dann nämlich gemeint ist.
Und für all das sind jetzt eben sehr viele unterschiedliche Codierungsschiffrierungsverfahren, möglich.
Hier werde ich jetzt also nur kurz so ein bisschen Einblick
in einige von den Sachen oder von den Ideen geben.
Also hauptsächlich, also in dem Bereich der Übertragung,
also diese ganzen kryptografischen Verfahren, denken wir,
würden ihn dann später im Studium noch entsprechend anderer Stelle begegnen.
Gut, wenn man jetzt guckt bei der Codierung, wofür brauche ich das?
Dem zuvor gibt es dann immer diese Unterscheidung zwischen der Quellenkodierung,
da wird halt die Information an das Ausgangsmaterial oder die Artikodierung erstmal an das Ausgangsmaterial angepasst.
Beispiel wird gleich folgen, wo man dann eben sagt,
wenn ich zum Beispiel sowas wie Buchstaben kodieren möchte,
wo ich dann weiß,
in Englisch oder in deutscher Sprache sind bestimmte Zeichen deutlich häufiger als andere,
dann lohnt sich jetzt eben sowas wie ein Aski-Code,
also erstmal nicht, wo ich alle Buchstaben die Leiche Blocklänge bekommen,
sondern eben welche, die häufiger sind, kriegen entsprechend kürzere Codes.
Das ist ja genau das,
was sie also auch schon mal Morsecode angesprochen hatte,
wird uns eher sicher auch gleich nochmal zum Beispiel begegnen.
Das ist also das, was quasi Quellencodierung ist. Kanalcodierung,
das ist eben das, wo es darum geht, zu sagen,
okay, ich habe jetzt beispielsweise auf meiner Funkstrecke von hier
zum Rechenzentrum eben vielleicht irgendwelche Störungen drauf, Informationen kann verfälscht werden.
Wie kriegt man da jetzt eben eine Fehlererklärung bzw. beziehungsweise Fehlerkorrektur hin?
Und dann eben Verarbeitungscodierung, das ist eigentlich das,
was wir zumindest teilweise schon implizit mit drin hatten,
wo es nämlich darum geht, wie wird die Information direkt im Rechner dargestellt?
Wie wird dann da da mitgearbeitet? Also da wären dann eigentlich Stichworte
genau das, was in den vorigen Kapiteln dran gewesen ist.
Sprich Zahlen, Darstellung, also sprich die Art Metiken und Zeichen,
Darstellung, also sprich die Husky ISO 1881,
59 bzw. OTF8-Kodierung
Gut, wie kann man kurz jetzt darstellen? Einfachste Idee ist im Prinzip,
also sowas wie eine Tabelle zu machen, wo ich dann sage,
okay, das ist also die Information, die ich kodieren möchte und so wird das dann entsprechend abgebildet.
Kann man natürlich vergleichsweise einfach realisieren,
nicht um das Ganze dann eben noch ein bisschen effizienter zu machen,
würden die dann eben typischerweise sortiert, beziehungsweise das,
was man dann meistens findet,
sind dann also keine tabellenartigen Baumdarstellung, sondern also baumartige Darstellung,
wo man dann eben entsprechend sehr einfach Also gerade,
wenn man jetzt also mit binären Bäumen arbeitet,
dann eben entsprechend verzweigen kann und eben gucken kann,
worum geht es da?
Daneben kann ich kurz natürlich dann also auch über sowas wie
logische Ausdrücke, beziehungsweise Arge Branche ausdrücke, beschreiben.
Gut, Kodierung von Text, hat ja schon gesagt,
war eigentlich soweit schon selber mit dran. Hinzu kommt jetzt natürlich, wenn man jetzt also irgendwie direkt noch Informationen text, weiter übermittelt. Also das eine ist natürlich der nackte,
die nackte Information über die Buchstaben,
dann kann man jetzt natürlich sagen, okay,
wenn ich jetzt sowas hier wie so eine Folie nehme,
habe ich eigentlich nur noch Metainformation, nämlich,
also sprich die Art der Formatierung, also sprich,
welche Schriftarten werden verwendet, welche Farben werden verwendet,
an welcher Position findet sich der Text wieder,
das wird dann eben auch entsprechend irgendwo noch reingeschrieben,
typischerweise, dass dann eben irgendwelche Applikationsspezifischen Formate, nicht,
also sprich mit welche,
je nach Textverarbeitung wird dann also neben dem Text dann eben auch noch gesagt,
okay, das ist eben irgendwo so ein Text, Blog,
der befindet sich an der und der Stelle mit der und der Schriftart und einer bestimmten Farbe,
beziehungsweise wo das eben noch einigermaßen standardisiert ist,
ist dann eben bei irgendwelchen Marktabsprachen,
also sprich SGML oder HTML.
Kodierung von Zahlen,
früher oder ursprünglich hatte man also erstmal so die Aufgabenstellung,
dass man gesagt hat, also ich möchte erstmal nur ganz normal die Dezimalziffern kodieren,
das heißt also sie ziffern von null bis 9,
das war eigentlich auch das, wo also die ersten Computer letztendlich mit gerechnet haben.
Kann man eben damit typischerweise machen, dass man sagt,
also ich mache das also im Prinzip einmal über so eine BCD-Darstellung,
steht dann immer als Abkürzung oder das Akronym für Bine Recorded Desermital.
Nicht, wo ich dann eben einfach quasi mit vier Bit
von 0 bis 9 die Ziffer entsprechend direkt kodiere.
Eine andere Darstellung ist die sogenannte Greikodierung,
die wird uns also gleich noch begegnen,
weil die also einige Nette Eigenschaften hat,
die man also hier vielleicht schon sieht,
wenn man also hier die Ziffern der Reihe nach durchgeht.
Ich weiß nicht, ob ihnen das auffällt.
Hat jemand eine Idee, was, also ich sag mal,
BCD und Greycode eigentlich so erstmal grundsätzlich voneinander unterscheidet
Also die Antwort war jetzt, also die Bits beim Greycode
werden immer irgendwie gespiegelt und das nächst höhere Bits 1 gesetzt.
Ja, teilweise. Da war jetzt also die Aussage,
im Greycode wird immer nur ein Bit geändert.
Also das ist letztendlich, also sagen wir mal,
der Algorithmus geht so ein bisschen in die Richtung,
aber das ist eigentlich das, was also da das Entscheidende ist.
Also dies ist ein sogenannter einschrittiger Code,
komme ich also gleich auch noch darauf zu sprechen.
Also wenn man zwei aufeinanderfolgende Code war,
dann miteinander vergleicht, ändert sich hier immer nur jeweils
ein einzelnes Bild
Ganzen normalen Zweierkompliment oder eben Zahlendarstellung, die dem her zugrunde liegt,
habe ich eben zum Beispiel typischerweise dann eben beim Übergang von 7 nach 8, dass ich dann eben hier letztendlich, also wirklich alle Bits einzeln ändern. Gut,
andere Codes, die man sich dann eben ausdenken kann,
sowas wie Access3-Code, das war sehr Access, das war das,
was er war, da Zahldarstellung von Fließkummerzahlen hatten,
wo also im Prinzip ja der Exponent,
also als Dann beispielsweise Access 1023 oder Access 127 kodiert ist,
Access 3 ist halt eben einfach die Zahl,
in diesem Fall dann eben Plus 3, nicht, das heißt,
die Null wird dann eben hier durch die 3 kodiert,
die 1 durch die 4 und so weiter.
Acon Code ist auch ein Code, der lange Zeit verbreitet war,
kommt auch früher aus der Fernschreibertechnik,
dann kann man sich hier sowas ausdenken, wie bigvinär,
wo also hier immer nur irgendwelche einzelnen witzig immer hin und her wandern und hier dann noch unterschieden werden,
beziehungsweise direkt am deutlichsten ist es dann zu sehen,
bei so einem 1 aus 10 Code, wo ich dann sage,
okay, ich habe jetzt zwar nicht minimal wenig Bits,
was 4 wären, sondern ich benutze 10 Bit.
Von diesen 10 Bit ist bei der Codierung aber eben immer nur genau ein einzelnes Gesetz und ich kann dann eben sehr einfach zum Beispiel abfragen,
habe ich irgendwo einen Wert null oder habe ich einen Wert X,
weil ich muss einfach immer nur also das entsprechende Bit direkt abfragen und kann eben mit dem Vergleich mit einem Bit feststellen,
habe ich einen Wert null, nämlich genau dann,
wenn er das niederwärtigste Bittner 1 ist.
Bei allen anderen Codes,
hier müsste ich eben in diesem Fall dann eben wirklich Vier-Bit quasi als in arathmetischen Ausdruck irgendwo reinpacken,
okay, das ist jetzt,
also vergleichsweise auch noch vergleichsweise einfach mit einem Uda-Gatter zu machen,
beziehungsweise mit einem Land-Cutter, aber wie gesagt,
das sind also die Gründe,
weswegen teilweise eben auch solche Codes manchmal Vorteile haben können.
Also später in den beim Entwurf von Schalt-Netzen bzw. Schalt merken würden,
ist das also auch noch begegnen,
wo dann also auch so Beispiele folgen,
wo im Prinzip, ja,
Zustände unterschiedlich kodiert sind und welche Auswirkungen das dann eben auch für die spätere Praxis haben wird.
Gut, hier dann eben so ein anderes Beispiel, auch zwei aus fünf.
Gut, letztendlich all das sind jetzt irgendwelche Codes,
wo man sagen kann, okay,
damit werden dann also im Prinzip die zehn Ziffern irgendwie kodiert.
Alle Codes sind logischerweise Binärcodes, sind Blockcodes,
das heißt,
alle Codewörter sind gleich lang
Boah. Ansonsten kann man dazu nur sagen, dadurch,
dass inzwischen sowas wie Dezimaldarstellung in Rechnern unüblich sind, werden die also kaum noch verwendet.
Also früher hatte man sowas zum Beispiel auch bei Taschenrechnern irgendwie, dass die also B-CD-Arathmetik direkt gemacht haben. Gut,
inzwischen ist das eben nicht mehr der Fall und Rechner oder Computer rechnen eben in der Regel dann mit Zwahlkompliment oder Fließkomma-Arathmetik,
aber jetzt nicht mit irgendeiner BCD-Arathmetik, also war halt,
okay, das entspricht zwar dem, wie wir jetzt,
also auf dem Papier rechnen würden, nicht an so,
wo er das, also ursprünglich dann,
also auch mal in technische Systeme übertragen, aber inzwischen ist es eigentlich kaum noch.
Wichtig ist hierbei eigentlich nur etwas,
was ja so auch schon eingangs zu dem Thema der Information gesagt hatte,
dass, wenn ich jetzt eben erstmal nur irgendwo so einen Zahnstring sehe,
letztendlich, also diese Meta-Information zur Kodierung vorhanden sein muss,
um welchen Code handelt es sich,
weil ich quasi jetzt also irgendwie aus so einem Vierbit Code hier,
wenn ich also irgendein Codewort erhalte, also nicht weiß,
ist das BCD,
ist das Grey?
Ist es Access 3 oder ist es Acon codiert?
Und je nachdem sind das dann eben doch sehr unterschiedliche Werte.
Gut, anschließend hier noch einige Begriffe zu Binärcodes,
Minimalcode ist ein Code, bei dem wirklich alle Codewörter ausgenutzt werden sind,
die möglich sind
Ein redundanter Code ist einer, bei dem eben nicht alle
möglichen Codewörter ausgenutzt wurden. Also hier in den Beispielen,
das sind letztendlich alles keine Minimalcodes, weil,
also sag mal,
mit vier Bit kann ich natürlich 16 Werte kodieren und hier wurden aber nur zehn benötigt und gerade hier also bei diesem Codes habe ich dann also entsprechend sehr viel Redundanz,
weil nicht, also hier in jedem Code fort ja nur eine einzige Eins jeweils gesetzt ist,
auf der anderen Seite kann man damit dann eben auch sehr einfach sehen,
wenn also irgendwie sowas übertragen wird,
es kommt zu einer Verfälschung aus
einer Von den Nullen hier wird irgendwie noch eine zweite Eins,
dann kann man eben auch gleich sagen, okay, das,
was ich da draus erhalten habe als Empfänger der Nachricht ist,
ist kein gültiges Kotwort, da ist irgendwas schief gegangen bei der Übertragung.
Nicht bei diesem Kots, wo ich jetzt eben entsprechend wenig
Redundanz habe, wird das dann eben schon schwieriger.
Gewicht, das Gewicht eines Kotworts, das ist eben genau das,
wofür man dieses komische Bitcount braucht, die Anzahl der Einsen.
Dann gibt es komplementäre Kots, das ist genau dann der Fall,
wenn es eben sieben Kotwort ein Codewort gibt,
wo die Bits alle invertiert worden sind.
Das ist dann auch ein gültiges Codewort ist. Bei dieser
Tabelle war das zum Beispiel bei diesem Acon-Code der Fall.
Dann habe ich hier sowas wie Einschrittige Codes,
aufeinander folgende Codewörter unterscheiden sich an, genau nur einer einzigen Stelle.
Das war das, wo ich also bei dem Gregcode schon
drauf hingewiesen habe. Und dann gibt es eben zyklische Codes,
wenn ich auf diesem Code war,
dann sowas wie eine Ordnung definieren kann
Dass sich der Code quasi nach dem letzten wiederholt.
Gut, also das, was wir jetzt bei der Zahlendarstellung
letztendlich schon hatten, ist ja der ganz normale Dualcode.
Also das hier inzwischen, also die Schreibweise, glaube ich,
also mindestens zum dritten Mal, also auf irgendwelchen Folien,
ist typischerweise dadurch, dass alle Codewörter genutzt werden,
eben ein Minimalcode,
CM Codewort existiert ein komplementäres Codewort
Und wenn ich eben eine feste Wortbreite habe, ist es ein zyklischer Code.
Das heißt also, wenn man dann wieder einen weitergeht,
landet man letztendlich am Anfang. Das ist also das,
was immer in dieser Darstellung, in diesem Zahlenkreis letztendlich skizziert ist.
Und was ich ja eben auch schon gezeigt habe,
das ist nicht einschrittig. So, weswegen macht es jetzt
überhaupt Sinn, mit diesen komischen Einschrittigen kurz zu arbeiten?
Wo, wie gesagt, hier nochmal die Definition,
die Codewörter unterscheiden sich an genau einer einzigen Stelle.
Weswegen macht das überhaupt Sinn,
damit zu arbeiten
Dazu kommen wir jetzt, also hier nochmal entsprechende Beispiele und zwar,
wenn es darum geht, Informationen aus den Codewörtern quasi abzulesen,
wenn sich diese Codewörter ändern,
beziehungsweise wenn sich dort die Bits entsprechend ändern können.
Das ist ja so häufig bei irgendwelchen technischen Verfahren der Fall,
wenn irgendwelche Informationen übertragen wird, passiert im Prinzip aber genauso auch,
wenn ich jetzt also nicht seriell, sondern parallel,
also sprich über so ein gesamtes Code-Wort irgendwelche Informationen im Rechner übertrage und nicht alle Bits sich wirklich gleichzeitig ändern.
Also auch dann kommt es eben zu solchen Sachen,
wo einschrittige Codes teilweise eben entsprechende Vorteile haben können. Gut,
Kino von der Definition oder Vollständigkeit halber zyklisch einschrittlich ist dann
eben genau wie bei zyklischem Codes,
also das erste und letzte Code-Wort unterscheiden sich dann eben
auch nur in genau einer einzigen Stelle,
nicht dass es das Ganze dann eben entsprechend zusammengefasst
Gut, weswegen, also hier so ein praktisches Beispiel,
also wie gesagt, da sind ja die Matlab-Demo jetzt,
also hier irgendwie so ein bisschen schlecht funktioniert,
habe ich jetzt hier gleich die Screenshots, was man dort machen würde.
Also wir stellen uns hier einfach mal vor, wir haben folgende Sache, also beispielsweise was
wie so ein Winkeldrehgeber, also sprich irgendein Messgerät,
sage ich jetzt erstmal doof, irgendwo auf einer Achse quasi Winkelposition feststellen soll.
So je nachdem, wie genau ich das jetzt mache,
also ob jetzt 1 Grad oder 10 Grad oder 60 Grad,
brauche ich dann eben entsprechend viele feine Unterteilungen.
Kann man eben dann technisch gesehen dadurch machen, dass du sagst,
okay, ich habe da so irgendwie so eine Plexiglasscheibe,
wo ich dann also im Prinzip mit LEDs quasi einfach irgendwie durchgehe,
habe dort dann so ein entsprechendes Muster drauf und kann dann eben quasi hier ablesen,
aufgrund dieses Musters, in welchem Segment ich mich gerade befinde.
Und wenn ich das jetzt also hier mit höheren Genauigkeiten mache,
okay, dann brauche ich dann eben entweder deutlich feine Unterteilung,
als jetzt also hier diese hier angedeuteten fünf LEDs oder man kann sowas,
also auch mehr Stufe hier mit irgendwelchen Zahnrad getrieben machen,
wie auch immer, aber das ist also etwas,
was sich dann eben auch entsprechend häufig in irgendwo technischen Systemen also findet,
wo es also darum geht,
also festzustellen,
also ein Motor soll zum Beispiel jetzt irgendwo was drehen,
an welcher Stelle befinde ich mich jetzt gerade
Oder so, oder es soll irgendwas entsprechendes gemessen werden. So,
wenn ich jetzt sowas mache und das Ganze jetzt also im Prinzip bei einem nicht einschrittigen Code mache,
das heißt also auf diesen Winkelunterteilung würde jetzt also quasi einfach binär durchkodiert drinstehen,
0,1,2,3 und so weiter, kann das eben dazu führen,
dass man bei sowas wie Dualcode eben wirklich einen maximal großen Ablesefehler bekommt,
der dann eben wirklich bis zu zwei Hochend-minus eins gehen kann.
Das heißt, wenn ich also sowas mache,
wie jetzt also hier irgendwie diesen Übergang von 1.000 nach null und eins,
das eben bis auf ein Bit hier also letztendlich alles falsch abgelesen wird.
Bei einschrittigen Codes, dadurch, dass sich dann eben immer nur ein einzelnes Bit ändert,
kann eben dieser Ablesefehler dann eben auch wirklich jeweils nur Mark maximal eins sein. So,
und das, was man dann nämlich hier sieht,
ist dann,
also das wäre jetzt also quasi der Screenshot von diesem Madler-Programm,
dass man sagt, also angenommen,
ich habe jetzt also hier sowas wie so ein 6-Bit-Binär-Signal,
war es jetzt also hier in diesem Fall einfach erstmal binär raufzählt von 0-0,
0-0,
bis 1-1. Gut,
also hier fehlt noch irgendwie die Flanke 1-1-
1-1-
Und was hier eigentlich schon so ein bisschen angedeutet ist,
das sieht man jetzt hier nur bedingt gut, ist,
dass dieses jetzt eben eigentlich also auch schon so ein bisschen mehr dem entspricht,
wie Informationen ja nun auch irgendwie dann rein technisch übertragen werden.
Also ich sage ja auch immer,
ich bin Informatiker und lebe in der heilen Welt aus Nullen und Einsen
und wenn ich so einen Übergang von 0 nach 1 habe,
dann ist das, also wenn ich das in so einen Impulsdiagramm tue,
also irgendwie so ein schönes Rechteck, was also unendlich steil raufgeht.
Rein technisch gesehen ist das natürlich also immer irgendwie so
ein langsamer, mehr oder minder langsameres rauf und runter.
Und was da dann eben auch noch mit reinkommt, ist,
was man dann eben hier so, also hier oben zumindest ein bisschen sieht,
dass die Signal dann eben teilweise dann zeitlich auch so ein bisschen verschliffen sind.
Das heißt also hier die Hai beziehungsweise diese Low-Phasen sind eben nicht alle immer gleich breit,
sondern das kann sich eben schon mal so ein bisschen nach hinten verschieben.
Also hier oben, der kommt, ist eben hier ein bisschen länger, als als dieses Bild hier. So,
wenn ich jetzt aber im Prinzip so ein gesamtes Datenwort quasi hier immer abtaste,
also sprich, also hier einfach zu einer bestimmten Zeit,
hier so ein Schnittdurchlege und gucke,
welcher Indija-Wert kommt dabei raus, dann passiert also das,
was also hier unten angedeutet ist,
dass ich eben hier zwar schon von null bis zum maximal möglich darstellbaren Wert,
also irgendwie dann so treppenförmig rauflaufe,
aufgrund dieser Flankenverschiebung sieht man dann aber immer hier,
dass also auf warmer da also irgendwelche Peaks sind,
weil also eben hier ein meinetwegen ist höherwertiges Bit,
sich schon schneller geändert hat,
als die Nihillwertigeren Witz nicht und man dann zwischendurch dann eben völlig falsche Werte abliest.
Und das führt dann eben zu diesen Ausreißern bzw. dem,
was dann eben hier diese maximale Ablesefehler letztendlich sein kann.
Gut, wenn ich das bei einem einschrittigen Quoten mache,
dass wir dann also hier das Ganze jetzt als einschrittiger Code,
dann sieht man, wie das also hier wirklich schön von 0 nach 1 geht.
Auch da habe ich natürlich Ablesefehler.
Das heißt, man hat eben zwischenzeitlich vielleicht falsche Werte.
Sie sind aber eben nur maximal eins. Das heißt,
das, was dort einfach passiert,
das sieht man also hier so ein bisschen, ist,
dass eben diese Treppenstufen, sag ich jetzt mal,
unterschiedlich breit sind, nicht.
Also mal kippt das eine Bit hier ein bisschen später,
dann ist entsprechend also hier diese Stufe länger.
Dann kippt es ein bisschen früher, dann ist diese Stufe eben deutlich kürzer.
Nicht, aber man hat dann eben wirklich nur maximal eins
als möglichen Fehler dort mitrennen. Das heißt also bei solchen Sachen,
Codierung von zum Beispiel solchen Inkrementalwinkelgebern oder sowas,
macht also Binärkot eben überhaupt keinen Sinn,
sondern also da würde man dann eben rein technisch gesehen dann eben schon irgendwie sowas Entsprechendes machen.
Gut, hier ist das Ganze eben auch nochmal so grafisch aufgezeichnet,
also sprich so eine Fünf-Bit-Kodierscheibe, nicht und das,
was man jetzt hier sieht, also das sind jetzt eben hier jetzt,
also diese Segmente, die dann also,
je nachdem wie viel Genauigkeit man hat,
also dann größer oder kleiner sind.
Hier eben der Übergang von der Codierung der Sieben-Zirkudierung der Acht.
Mich wurde es dann eben genau nur hier an dieser einen Stelle ein Wit ändert und das,
was dann eben maximal nur sagen kann, ist,
dass dies eben ein bisschen früher oder ein bisschen später,
also irgendwie detektiert wird.
Aber man hat dann eben eigentlich nur minimalen Ablösefehler.
Gut, hier das Ganze dann eben mal für 10
wird dargestellt als Greycode lässt sich,
also dann beliebig weitertreiben
Gut, wie erzeugt man solche einschrättigen Codes?
Ich war das Fan auch ganz gut zu sagen, okay,
also da hat sich jetzt also irgendwie einhergerädert, also irgendwie was ausgedacht.
Ist aber relativ einfach. Dazu gibt es ein rekursives Verfahren. Und zwar,
wenn man sagt, ich habe einen einschrittigen Code mit N-Code-Wörtern,
N ist logischerweise eine Zweierpotenz,
dann kann man eben einen Code mit bis zu zwei Endcode,
war dann dadurch erzeugen, dass ich meinen bestehenden Code nehme,
den hinschreibe, davor eine Null schreibe und ihn anschließend in umgekehrter Reihen vorgenommen,
mal hinschreiben und davor eine Eins schreibe.
Würde folgendermaßen aussehen, also ich fange an mit dem trivialen Einschritt,
den Code aus den beiden Wörtern 0 und Eins.
Nehmen wir den und sagen, okay,
also ich schreibe jetzt 0 und Eins hierhin,
0 und 1 und in umgekehrter Reihenfolge
Mit 1 und 0. Nochmal und vor die ersten beiden schreibe ich eine Null.
Für die anderen beiden schreibe ich eine 1, dann habe ich diese vier Codewörter.
Und wie man also unschwer sieht von einem zum nächsten Codewort,
ändert sich immer jeweils nur ein Bits.
Ein Bit, das Ganze ist auch zyklisch einschrittig,
das heißt von dem letzten zur Null ändert sich dann auch wieder nur genau ein Bit.
Genau das Ganze kann ich dann eben entsprechend rekursiv weitertreiben,
also diese 0-0, 0-1,
1-1, 1-0 schreibe ich hier wieder hin,
eine Null vorneweg und in umgekehrter Reihenfolge 1, 0,
1-1, 0-1,
0-
Dann für diesen zweiten Bereich und dann eine Eins vorne weg und
dann habe ich also hier die Anzahl der Code-Worte dann dementsprechend dort dann wieder verdoppelt.
Das ist also genau das, was also letztendlich der Grey-Code ist,
beziehungsweise wie man den berechnet. Eine andere Möglichkeit,
einschrittige Codes zu generieren, ist durch Fahre in diesen sogenannten Kanow-Witch-Diagramm,
die werden uns dann im nächsten Kapitel, wo es dann um Schaltnetze geht,
also beziehungsweise schalten als Minimierung auch noch zuhauf begegnen.
Von der Idee her ist es folgendes. Ich habe also ein zweidimensionales Diagramm mit zwei Hoch-N-Feldern,
die dann also quasi immer in X beziehungsweise Y-Richtung dann quasi entsprechend nochmal irgendwo unterteilt sind,
typischerweise hat man also entweder ein Diagramm mit zweimal zwei,
also mit vier Feldern, zweimal vier oder das,
was wir hier sehen,
sind also diese Diagramme mit viermal vier Feldern
Größere, werden dadurch gebildet, dass man dann eben mehrere von diesen hier wieder nimmt. So,
und das, was jetzt hier passiert, ist, dass man sagt,
okay, ich habe jetzt hier quasi meine vier Indizes,
um jetzt also diese 16 Felder zu kodieren,
also jetzt als ganz normale Stellenwertigkeit geschriebenen, also X-3,
X, 2, X, 0,
und habe die jetzt also hier in der Beschriftung dann eben in einem einschrittigen bzw. im Greycode.
Das heißt also, es liest sich dann immer folgendermaßen,
also dieses Feld, was dann quasi der Binärzahl.
Also hier ist es immer der jeweils dezimale Wert eingetragen,
was eine der, Entschuldigung, der Dezimalzahl 7 entsprechen würde,
ist dann eben zu lesen als X0 ist gleich 1,
X1 ist gleich 1, X2 ist gleich 1 und X3 ist gleich 0.
Also indem ich dann einfach hier die Werte direkt,
also auszahlen bzw. Spaltenbeschriftung rausnehme und das ist dann eben der
Wert bzw. hier sieht man das Ganze dann eben nochmal,
jetzt nicht in Dezimal, sondern in der entsprechenden Binären oder Dualkodierung.
So, nee, und was man dann eben hier sieht,
ist, dass sich zwischen zwei Feldern,
was ja eben genau hier durch diese Indizes erreicht wird,
zwischen zwei Feldern eben quasi die,
wie näher dargestellten Worte eben auch immer nur um jeweils ein einzelnes Bit unterscheiden.
Also das heißt,
wenn ich jetzt also hier die nehme und eben hier den Übergang von diesem Feld,
zu diesem Feld habe,
da würde sich dann eben genau dieses höchstwürdigste Bit in diesem Fall,
also X3,
unterscheiden,
weil ich da eben von 0-1 nach 1
-1 gehe
So, wenn ich jetzt so ein Diagramm habe,
kann ich also einen einschrittigen Code eben einfach dadurch erzeugen,
dass ich also hier, je nachdem, wie viele Kotwörter ich brauche,
ich da einfach irgendwie einen beliebigen Pfad reinlege. Das heißt,
dass ich auf der linken Seite 0-1, 3,
2, 6, 7, 5, 13, 15, 14,
10, 11 und so weiter und wenn, so,
dass wir dann eben hier der eine Fahrt und hier,
wenn ich jetzt also beispielsweise irgendwas bräuchte,
wo ich ja zwölf Kotwörter habe, könnte ich mir also hier irgendwie diesen Pfadrau aussuchen.
So,
jeder Pfad entspricht dann eben letztendlich im einschrittigen Code,
wenn die Pfade so wie hier quasi mit dem Ende in dem Feld neben meinem Startpunkt landen,
dann ist das eben auch ein zyklisch einschrittiger Code,
weil dann könnte ich dann eben anschließend hier wieder von 4 nach 0 gehen und das würde sich dann eben in diesem Fall dann letztendlich das Bit X2 ändern.
Beziehungsweise hier habe ich das dann eben genauso. Auch noch zu
diesem KV-Diagramm Was dort dann auch immer noch mit auftaucht,
die linke und die rechte Spalte unterscheiden sich jeweils um,
nur ein Bett, beziehungsweise die obere und die untere Zeile.
Das heißt, man kann sich das immer so vorstellen,
als ob das also zyklisch außenrum dann eben vervollständigt werden kann.
Das heißt, ich kann eben auch Pfade bilden,
wie dieses hier, wo ich dann eben vier, fünf,
13, 15, 7, 6, 14, 10,
und nach der 10 habe ich dann eben hier die acht Dann die zwölf.
Nicht, dass man dann also quasi hier einmal außenrum letztendlich springt,
nämlich von dieser Stelle 1-0, 1-0,
was die zehn ist, zu 1-0,
0-0, was also dann die acht ist.
Und auch dort hat sich, wie man also hier sieht,
von hier nach hier genau dieses eine Bett geändert.
Gut, hier ist ein anderes Beispiel.
Ich formuliere also eben hier auch irgendwie so ein Pfad hat
Nein, schrittlich. Gut, das heißt also,
um einschrittige kurz zu generieren,
kann man das eben entweder mit einem Gray-Quoten machen,
den man also quasi so konstruieren kann.
Oder eben in so einem KV-Diagramm,
in dem ich dort also entsprechend mir einen Pfad reinlege.
Technisch gesehen, wie kann man jetzt, wenn ich also
irgendeinen beliebigen Dualstring habe, den zugehörigen Graystring generieren.
Das geht vergleichsweise sehr einfach, indem man eben sagt,
man nimmt das
Seien es drin, liest den von links nach rechts,
fängt also beim höchstwertigsten Bit an. Und das,
was nun macht, ist, dass das höchstwertigste Bit des Graywortes,
gleich dem höchstwertigsten Bit des Dualwortes wird, also MSB,
sollte klar sein, steht Akronym,
hatte ich jetzt aber nicht aufgezählt, Most Significant Bit,
also genau das höchstwertigste oder spricht das am weitesten linksstehende Bit.
Und dann geht man eben von links nach rechts eben einfach immer vor und jeweils,
wenn sich Das Bett ändert, also sprich von 0 nach 1,
dann wird in dem Grayword eine 1 geschrieben,
beziehungsweise wenn es sich von 1 nach 0 ändert,
wenn es sich nicht ändert.
Das heißt, es war aufeinanderfolgende Bits 0-0 sind oder 1
-1, wird das mit einer Null kodiert. Beispiele,
also ich habe jetzt hier den Dualstring von der 3,
also 0-0-1-1,
um da draus jetzt quasi das Grayword zu machen,
würde ich das dann eben von links nach rechts nehmen.
Das MSB bleibt erhalten. Das heißt, hier habe ich
erstmal eine Null
Das nächste Bit ist auch eine Null, das heißt,
es ändert sich nichts, demzufolge wird hier eine Null hingeschrieben.
Anschließend ändert sich das Bit von 0 nach 1,
deswegen wird hier eine Einzelne geschrieben, jeweils eine Änderung,
wird immer durch eine Eins kodiert und dann habe ich aber
hier wieder keine Änderung, die ihm zuvor steht,
hier dann wieder eine Null.
Das heißt also, das Graywort zu diesem Dualwort wäre dann dieses hier.
Gut, hier genau das Gleiche jetzt eben von entsprechend anderes Wort,
also Hexadezimali, wo ich dann eben sage,
most significant
bit übernehmen
Dann diese beiden Bits sind gleich, es ändert sich nichts,
also schreibe ich eine Null. An nächster Stelle,
auch hier ändert sich nichts, es wird eine Null geschrieben,
das Bit kippt und das wird dann wieder mit einer Eins kodiert. So,
rein technisch kann man das dann sehr einfach realisieren,
beziehungsweise auch als Ausdruck in der Programmiersprache, in diesem Fall Java,
kann ich das also einfach dadurch machen,
dass ich also quasi mein Bitstring nehme und den mit einem Exklusiv- oder Verknüpfe mit einem Bits dringen,
der jetzt also genau um einen nach rechts geschoben ist.
Das ist das, was also dieser Ausdruck in Java letztendlich ist,
beziehungsweise technisch gesehen geht das eben dann sehr einfach,
dass man sagt, okay,
ich habe hier immer so ein Bit und verknüpfe das jetzt mit dem Exklusiv-Oder,
mit dem um einen geschobenen Bit, was man dann eben auch sehr einfach machen kann.
Dazu also auch schon mal kurz vorneweg in Ausblick auf das nächste Kapitel gezeigt,
weil da werden wir das ja noch häufig benutzen.
Und zwar dieses, so hier erstmal wieder alles.
Abnecken. Dieses Werkzeug, Harde steht dann für Heimburg Designsystem,
ist im Prinzip sowas wie so ein Eingabemöglichkeit für logische Schaltung,
jetzt also aus beispielsweise einfachen Gattern.
Das ist also dieses hier, das soll dann sowas wie ein Exklusiv-Oder darstellen.
Und das ist dann eben nicht nur so ein Zeichenprogramm,
um jetzt sowas, also entsprechend zu zeichnen, sondern es eben auch ein Simulator, wenn ich das hier unten läuft, also irgendwelche simulierte Zeit mit. Und das,
was man hier hat oder hier jetzt also veranschaulicht ist,
ist jetzt also hier quasi eben genau das,
was letztendlich dann in diesem Ausdruck drin stand, nämlich,
dass man sagt, okay, ich nehme jetzt,
dass ich hier mehr hier was,
das Bit und das nächste Bit verknüpfe,
die mit so einem Exklusiv-Oder und das ist dann eben genau mein entsprechend kodiertes Bit,
um das Ganze ein bisschen zu visualisieren bzw. einstellen zu können,
habe ich dann also hier quasi jetzt für die vier,
wird sowas wie so eine Eingabemöglichkeit, hätte dann hier mein Binärwort,
nicht, dass dann eben die entsprechende Schaltung,
also in diesem Fall jetzt also aus drei von diesen Exklusiv-Odergattern und hier dann eben das entsprechende Graywort und wenn ich das jetzt also mal für dieses Super schwierige Beispiele mache,
was ich gerade eben gemacht hatte.
Nicht, wenn wir also die drei, wie näher,
kodiert durch 0011. Und der entsprechende Greycode ist dann 0010. Und
das sollte dann eben auch hoffentlich dem hier entsprechen.
Oder eben als anderes Beispiel, wenn ich jetzt also hier
die Sechs nehme und würde dann eben im Greycode 01, 01 raus.
Also auch das kann man dann hier einmal schnell so validieren,
dass das eben auch entsprechend jeweils passt. Gut,
also wie gesagt, das, wie man das bedient,
was man damit macht, wird uns dann also später noch zuhauf begegnen.
Also wie gesagt, das ist aber jetzt nicht nur mal so ein bisschen Veranschaulichung,
wie dann eben auch wirklich durch entsprechende Hardware-Einheiten das Ganze dann gemacht oder unterstützt werden kann,
weil wie gesagt, also dieser Ausdruck mit dem XXO, geschobenen Ausdruck.
Das ist dann das, wie man das in der Programmierung
machen würde. Aber ich hatte ja schon gesagt,
also häufig haben die Prozessoren dann eben auch schon neben arathmetischen Recheneinheiten,
dann also auch schon entsprechende andere Recheneinheiten mit drin,
um eben beispielsweise sowas schnell zu machen oder eben um dieses Bitcoin zu realisieren oder was auch immer noch.
Gut, zurückrechnen, Umwandlung von Grey in Dualcode.
Auch das passiert dann eben wirklich analog dazu,
immer nur durch Bitweisebetrachtung der Werte. Wenn ich hier jetzt mein Greywort habe,
also null, null, 1-0,
ich übernehme das höchstwertigste Bit und anschließend bei der nächsten Stelle wurde dann Halke gemacht,
wenn ich eine Null stehen habe, wird das,
was ich also quasi in meinem Dualwort stehen habe, abgeschrieben.
Also in diesem Fall wird diese Null dann abgeschrieben,
da ändert sich nichts. An der nächsten Stelle,
wenn ich eine 1 stehen habe, wird das entsprechende vorhergehende Bit invertiert,
den zufolge wird hier aus dieser Null hier eine Eins und dann eben wieder,
wenn ich eine Null stehen habe, ändert sich nichts,
es wird abgeschrieben, deswegen wird diese Eins dann hier entsprechend abbeschrieben.
So, das heißt,
das ist also im Prinzip genau das,
die Rückrechnung von dem hier,
beziehungsweise dann eben hier auch noch für die anderen beiden Beispiele,
also da geht es dann eben auch vergleichsweise einfach und
auch das kann man also über entsprechende Hardware mit solchen Exklusiv-Odergattern
also relativ einfach oder direkt realisieren
Gut, das also erstmal zu den einschrittigen Codes.
Jetzt hatte ich ja schon gesagt, wofür auch noch Codes eben vielleicht auch noch.
Und als Beispiel ja schon sowas wie Buchstabenhäufigkeiten genannt,
was dann eben eigentlich ein typisches Beispiel ist für das,
was also diese Quellencodierung sind. Also das heißt,
wenn ich sage, ich habe in meinen Symbolen,
die ich codieren möchte, unterschiedliche Häufigkeiten oder unterschiedliche Auftretenswahrscheinlichkeiten,
wie auch immer ich das dann nennen mag.
Kann man im Prinzip die zu übertragene Datenmenge dadurch reduzieren,
dass man eben die Teile, die häufiger vorkommen mit entsprechend kürzeren Kodierungen versieht.
Was dann natürlich notwendig ist, ist, dass die kurzbestimmte Eigenschaften haben,
damit ich also unterscheiden kann, wann beginnt ein neues Codewort.
Nicht bei Blockcodes, also sprich bei der Binärkodierung,
bei diesen ganzen BCD-Kodierung, was auch immer, weiß ich ein Codewort ist,
Vierbit oder 32 mit oder wie viel auch immer lang.
Das heißt, ich zähle einfach mit und sage, zack,
wenn ich einen Datensturm bekomme, das ist mein erstes Codewort, das ist mein zweites.
Bei diesem Codes mit variabler Länge geht genau das eben nicht und das nennt sich dann eben,
dass man entweder sagt, ich muss eine bestimmte Bedienung Bedingungen einhalten,
die ein Fano, der in Amerika geliebt und gelehrt hat,
aber eigentlich italienische Abstammung ist, letztendlich aufgestellt hat.
Oder ich muss eben nochmal spezielle Markierungen haben,
um die Codewriter irgendwie voneinander abgrenzen zu können. So,
diese Fano-Bedingungen erlaubt es jetzt eben im Prinzip kurz mit
variabler Wortlänge eindeutig zu dekodieren und die besagt eben,
dass kein Wort aus einem Code den Anfang eines anderen Codes oder eines anderen Codeworts bildet.
Das Ganze nennt sich dann immer auch Prefix-Eigenschaft,
nicht also Prefix, eben in dem Sinne,
wenn ein Wort Prefix eines anderen Wortes wäre,
sprich in dem enthalten ist, dann ist es eben kein Fano-Code.
Das heißt, ein Code der Prefix frei ist,
wäre dann entsprechend oder würde dann eben dieser Fahne-Bedingung genügen.
So, und wenn ich jetzt eben so ein Prefix Code habe,
beziehungsweise also eigentlich also ein Prefix freien Code,
dann ist der eben letztendlich eindeutig dekodierbar
Gut, Block-Codes sind natürlich solche Brefix-Codes. Ansonsten,
das, wo wir das also kennen, typischerweise,
auch wenn jetzt also alle mit Smartphone telefonieren,
ursprünglich einen alten Aufbau von Telefonnummern, wo man sagt,
okay, es gibt also was wie 110, 1112,
116 oder sowas,
da sind ein paar spezielle Nummern,
die irgendwie noch gekennzeichnet sind und ansonsten habe ich eben irgendwo immer so eine Art Codierung,
wo ich dann sage,
also hier zumindest in Deutschland
Ich habe hier meine Nummer und es gibt eben keine Telefonnummern,
die mit Null beginnen. Dann bin ich eben im Ortsnetz. Nicht,
wenn ich dann also irgendwie mit einer einzelnen Null was vorhabe,
dann ist es eben eine Vorwahl,
um national jetzt eben in unterschiedliche Städte irgendwie zu telefonieren.
Und wenn ich dann eben international unterwegs bin,
dann beginne in Deutschland, also zumindest die Nummern,
alle mit 2-0 vorne weg.
Und dadurch kann man dann eben entsprechend,
also die jetzt irgendwie eine Telefonnummer dann eben entsprechend unterscheiden,
wo die sind.
Und all das sind dann eben Sachen,
wo man sagt, okay,
das würde dann eben
der Fano-Bedingung genügen
Beispiel, wo das nicht gilt, wo ich das,
was er ja schon gesagt hat, also sowas wie Morsekot,
wo eben genau das verletzt ist,
nicht wo ich dann eben sage, okay,
also sowas wie ein E als ein kurzer Ton würde hier dann eben auch als Prefix von dem A auftauchen.
Und das ist dann eben nicht eindeutig entscheidbar. Nicht also Beispiel,
also hier kann man sich alles Mögliche rausdenken,
das hatte ich ja auch schon entsprechend aufliegen, diese Folie.
Nicht, was man aber eben beim Morsekot ganz gut sieht,
ist, dass eben die Buchstaben, die entsprechend häufiger sind,
kürzere Kodierung haben
Wenn ich also hier dann auch nochmal dieser Baum,
nicht wo man sagt, also die Symbole sind entsprechend entweder
Knoten in dem Baum oder eben irgendwelche Blätter in dem Baum.
Und wenn es eben Knoten sind, dann heißt es
rein technisch gesehen, sie verletzen eben die Fahnebedingungen.
Nicht weil das E dann eben Pre-Fix von hier irgendwelchen anderen
Codierungen ist. Nichtsdestotrotz kann ich also auch sowas wie so
einen Morse-Code nehmen und daraus im Prinzip was machen,
was eindeutig dekodierbar ist
War es dann aber in dem Fall dann eigentlich jetzt wieder eine andere Ebene ist,
indem ich dann nämlich sage, okay,
also ich kodiere diese Zeichen hier oben und ich baue noch zusätzlich sowas wie ein Trennzeichen ein.
Und wenn ich jetzt also sage,
meinetwegen der lange Ton wird durch 1-1 und eine Null kodiert,
der kurze Ton durch nur eine 1 und eine 0 und das Trennzeichen ist eben nur die Null,
dann kann ich eben hier so ein String,
also eindeutig als SOS,
dekodieren,
nicht weil ich dann eben hier quasi lese 1-
Ein kurzer Ton, dann wieder 1-0,
nochmal ein kurzer Ton, wieder 1-0,
ein kurzer Ton, dann das Trennzeichen,
also habe ich jetzt die drei kurze Töne,
ist laut Morser-Alphabet dann eben das S,
nicht und so weiter und so fort.
Gut, über solche Mechanismen kann man sich dann da eben
auch letztendlich beliebig viele unterschiedliche Kodierungen ausdenken,
also eine andere ist dann also unten,
auch das würde entsprechend jetzt
der Fahnebedingungen genügen
Gut, wie kann man jetzt solche Codierungen,
von denen ich ja gesagt habe, na gut,
also ich möchte jetzt so irgendwie sowas wie so ein präfixfreien Code haben,
wie kann man die jetzt also irgendwie mehr oder minder systematisch erzeugen?
Weil ich kann jetzt natürlich sagen, okay,
ich rate mir da irgendwie was zurecht und hoffe, dass das irgendwie hinhaut.
Nein, es gibt also auch da schöne Verfahren,
wie man das also entsprechend mathematisch korrekt erzeugen kann,
beziehungsweise auch eindeutig erzeugen kann,
was dann natürlich demzufolge dann das auch immer genutzt wird
Zwei Verfahren. Zum einen von dem Herrn Fano,
beziehungsweise eigentlich von der heißen, von Channel und Fano gemacht,
aber das läuft meistens in der Literatur immer nur als Farno-Code.
Also gegeben habe ich eine Anzahl von Symbolen oder Wörtern,
also hier jetzt Urwörter genannt, AI, mit ihren Auftretenswahrscheinlichkeiten.
So, und das, was man dann macht, in diesem Verfahren ist,
dass sich die Wörter anhand ihrer Wahrscheinlichkeiten quasi in absteigender Reihenfolge sortiere.
Nicht, das heißt, das ist am weitesten linksstehende,
ist jetzt das Verscheinlichste, dann eben hier bist du dem Unwahrscheinlichsten.
Und dass ich dann also quasi in dieser Sortierung irgendwo
eine Trennung mache, und zwar möglichst so,
dass ich zwei Gruppen erhalte mit leicht großen Wahrscheinlichkeiten.
Also jetzt Gesamtwahrscheinlichkeiten. So,
und in der Kodierung bekommen dann eben die eine Gruppe,
beispielsweise das, was jetzt hier links steht,
eine Null kodiert,
die andere Gruppe,
nahe ins kodiert
So, und jetzt für jede dieser Teilmengen,
wenn ich dieses ganze Verfahren an dementsprechende rekursiv ahne.
Das heißt, es wird dann wieder in dieser Gruppe,
wo ich ja immer noch diese Sortierung habe,
dann eben wieder geguckt, wie fahre ich dort weiter vor.
Gehe ich dort weiter vor? Und das Ganze macht man dann eben entsprechend iterativ so lange,
bis man letztendlich in jeder Gruppe nur noch ein einzelnes Element enthält.
So wie man sich da schon denken kann,
funktioniert das Ganze natürlich, also möglichst gut.
Nur wenn ich also sehr viele zu kodierende Urwörter, ich habe.
Und darauf werde ich dann also nachher noch mal kurz hinweisen,
wo das Verfahren natürlich sinngemäß ist, also auch nicht so gut funktioniert,
ist, wenn ich jetzt also irgendwie ein Urwort habe,
was also extrem wahrscheinlich ist.
Also größer als 0,5 nicht. Also wenn ich jetzt also irgendwie was hätte,
was, wenn der Wahrscheinlichkeit von 0,9 auftaucht und dann also
noch irgendwie diverse andere mit sehr kleinen Wahrscheinlichkeiten,
dann habe ich hier jetzt natürlich eine entsprechend schlechte Verteilung wird dann generiert.
Gut, da gibt es dann andere Kollierungsverfahren, die dann also dort besser wären.
Gut, aber bleiben wir erst mal bei der Fahne-Kuldierung.
Hier also ein passendes Beispiel. Ich habe jetzt also hier
eine unwahrscheinlich große Menge von vier Buchstaben mit entsprechenden Wahrscheinlichkeiten.
Hier beziehungsweise im folgenden, also auch nur als Hinweis,
habe ich das also jetzt mit der Notation immer so,
dass ich jetzt hier für die Dezimalstellen jetzt also immer kein Komma,
sondern ein Punkt verwende,
einfach nur um das jetzt also hier von solchen Aufzählungslisten zu unterscheiden.
Also das heißt, Wahrscheinlichkeit von As dann eben 0,45 von
B 0,1 und so weiter. So, diese Sortierung,
entsprechende Wahrscheinlichkeiten, er gibt dann quasi genau diese Unterteilung,
A, D, C,
B. Ich wusste dann eben von einer größten bis zur kleinsten Wahrscheinlichkeit gehe.
So, das wird dann eben in zwei möglichst gleich große Gruppen unterteilt.
In diesem Fall in A mit der Wahrscheinlichkeit 0,45
und die drei anderen mit der Wahrscheinlichkeit 0,5
als Summe
Ja, und da kann ich eben beispielsweise sagen, der Akku,
die ist mit einer Null und alle anderen fangen erstmal mit
einer Eins an und entsprechend dann noch irgendwelchen weiteren Zeichen.
Gut, und dann läuft das Ganze eben entsprechend rekursiv weiter,
das heißt, also ich nehme jetzt diese drei Symbole unterteile,
das dann eben in die beiden Mengen D und C und B,
nicht wobei D,
dann eben die Wahrscheinlichkeit von 0,3 hat und die anderen beiden
zusammen dann
Und im letzten Schritt würde ich die beiden unterteilen und erhalte dann
eben anschließend alles zusammen, dann eben letztendlich diesen Code hier.
So, und wenn man jetzt guckt,
wie Co. gut ist dieser Code jetzt im Vergleich zum Blockcode,
dann kann man eben sagen, okay,
also sowas wie so eine mittlere Codewortlänge,
kann ich dadurch berechnen,
dass ich im Prinzip für jedes Zeichen seine Auftretenswahrscheinlichkeit mit
der Länge des Codeworts multipliziere
Was dann in dem Fall also 0,45 mal eins,
nicht weil ich eher hier genau nur ein Bit brauche,
0,3 mal zwei, das ist dann nämlich die Kodierung von
dem D und 0,1 5 mal 3 plus 0,1 mal 3,
das sind dann eben hier entsprechend Dekodierungen.
So, damit erhalte ich also hierfür als mittlere Codewortlänge 1,8,
wenn ich die vier Zeichen jetzt einfach binär kodieren würde,
dann würde man sagen, okay,
baue ich zu vier Zeichen,
zwei Bit,
mittlere Codewortlänge,
Das heißt, da sieht man eben schon, wenn ich jetzt also entsprechend viel Information übertrage,
dass also in dieser Kodierung mache, wird die kodierte Information kleiner. Gut,
das Ganze kann man dann eben beispielsweise so für die größere Mengen machen,
wie also hier zum Beispiel deutsche Großbuchstaben,
also hier mit irgendwelchen Wahrscheinlichkeiten und dann eben hier irgendwie den Buchstaben,
wo man sagt,
so E und En sind immer noch vergleichsweise sehr wahrscheinlich,
nicht sowas wie ein X ist vergleichsweise unwahrscheinlich und dann kriegt man eben entsprechend so eine ganze Tabelle,
wo ich dann also letztendlich mit Drei Bit irgendwo starte für die kürzesten Codierungen und eben bei den unwahrscheinlichen Zeichnern,
also irgendwo bei zwölf Bit auch führe.
Gut, das zweite Verfahren, was jetzt im Prinzip für so
eine Codierung genutzt werden kann, ist von dem Herrn Huffman.
Im Prinzip ähnlich, auch hier wie gesagt,
gehe ich erst mal davon aus, ich kenne die Urwörter und ihre Wahrscheinlichkeiten.
Hier werden die jetzt also quasi in umgekehrter Reihenfolge notiert.
Das heißt also von der Kleinsten zur größten Wahrscheinlichkeit. Und das,
was man jetzt macht, ist,
dass man in jedem Schritt die zwei Wörter mit der kleinsten Wahrscheinlichkeit
zusammenfasst und daraus ein neues Symbol generiert und dieses dann eben entsprechend wieder einsortiert.
Und das wird eben so lange wiederholt,
bis sich eben eine Menge mit nur noch zwei Elementen habe.
Und das führt letztendlich dazu, dass man damit also
einen gesamten Baum aufbaut
So, mathematisch gesehen, Beweis dazu, folgt dann noch,
ich denke mal allerdings dann nächstes Mal, wird oder ergibt sich daraus dann im Prinzip die kleinstmögliche mittlere Code-Fortlänge, das heißt also ein Halfman-Code ist mathematisch gesehen optimal. Wie gesagt,
wird jetzt anders konstruiert, als dieses Fahnhof-Verfahren,
die Abweichung sind aber vergleichsweise gering, also das nimmt sich,
also nicht viel, die sind auch beide eigentlich ähnlich gut,
Halfman ist insofern noch ein bisschen interessanter,
weil die Kodierung eigentlich bei relativ vielen Kodierverfahren,
die wir jetzt also auch so kennen, unter anderem mitbenutzt werden,
also im Prinzip so bei den ganzen JPEG oder MPEG-Komprimierung,
wobei also da noch sehr viele andere Verfahren mit reinspielen,
aber unter anderem ist dann eben auch auf unterster Ebene sowas wie so ein Halfman-Code da mit bei.
Gut, letzte Folie für heute, auch nochmal das
entsprechende Beispiel, wie das Ganze letztendlich aussehen würde.
Also ich habe hier meine Urbildmenge und die entsprechenden Wahrscheinlichkeiten in der Sortierung
, erhalte ich also BCDA. Zusammenfassend von B&C,
nämlich den Badensymbolen mit den geringsten Wahrscheinlichkeiten,
erhalte ich ein neues Wort E. Das hat die Wahrscheinlichkeit von 0,25 und wird dann letztendlich hier dann auch wieder einsortiert.
Das heißt, hinterher habe ich dann also sowas wie ED und A.
Und dann wird das verfahren, ist bei den weiter iteriert.
Also ich nehme jetzt E&D, er zeugt daraus ein
neues Wort
Mit der Wahrscheinlichkeit von 0,55, das wird dann entsprechend einsortiert.
Und dann habe ich hinterher dann noch stehen A und F.
Und damit bin ich dann eigentlich auch schon fertig und habe
hier also meine Kodierung aufgebaut und erhalte hier diese vier Kotwörter.
Gut, und in dem Fall,
da das also hier so ein kleines Beispiel ist,
sieht man also da in der Bittlänge unterscheidet sich das also nicht von dem Farno-Code.
Das ist dann eben jetzt nur einfach aufgrund der Konstruktionsvorschrift,
also ein anderer Code geworden.
Aber letztendlich für beide gilt, dass sie dann jeweils
diese Prefix-Eigenschaft erfüllen
Gut, damit werde ich jetzt für heute Schluss machen.
Ich wünsche Ihnen ein schönes Wochenende und dann nächsten Mittwoch
geht es weiter