So, ich hatte Ende letzter Woche ja im Prinzip mit dem Thema der Codierung von Zeichen aufgehört,
hatte im Prinzip ja schon die ganz alte,
im Prinzip dann sieben Bett Aski-Darstellung vorgestellt und kurz dann,
also im Prinzip, wenn es auf die sonst,
sagen wir mal so, viel verbreitet in ISO 8859-Kodierung eingegangen.
Wie gesagt, was damit eben immer noch nicht geht,
weil man sich mit diesen Zeichensätzen hier dann ja eigentlich auch immer
auf eine Sprache oder einen Sprachraum festlegen muss, ist,
dass man jetzt wirklich richtig mehrsprachige Texte dann eben mit den entsprechend passenden Zeichen darstellen kann.
Demzufolge ergibt sich dann eigentlich die Motivation für das,
was also heute relativ weit verbreitet ist,
unser Meisters auf den meisten Computern bzw. modernen Betriebssystemen dann also
auch problemlos funktioniert,
nämlich der Unicode
Kann man hat im Prinzip dann eben wirklich eine Kodierungsmöglichkeit,
mit der man also wirklich alle Zeichen beziehungsweise dann eben auch
sehr viele Symbole darstellen kann.
Und ist jetzt nicht also auf eingeschränkte Zeichen,
Satze beziehungsweise angestrichene Zeichensatzkodierung, wieder ISO-Kurz der Fall ist,
angewiesen.
Nicht nur eben
irgendwie sowas mit irgendwelchen Steuerbefehlen
Beispiel zwischen irgendwelchen Isozial-Hinsatzkodierungen umschalten konnte, wurde diskutiert,
konnte sich aber eigentlich auch nicht weiter durchsetzen. Gut,
Unicode, auch als Universal-Character-Setbet bezeichnet, ist eigentlich das,
wo man in Klappen von Schriftdaten beschreiben und darstellen kann.
Wurde 1991 in der letzten Version initialisiert. Inzwischen sind wir also bei Version 9 mit,
also ist jetzt gerade des Jahres, glaube ich,
jetzt standardisiert worden mit, also inzwischen über 128.000 verschiedenen Zeichen,
neben Sprachzeichen, also sprich Buchstaben von allen möglichen Sprachen,
sind dann eben auch diverse Symbole, Pfeile,
technische Symbole mit dargestellt, Bretzeichen und auch aktuell,
also ein plattief umfangreicher Satz von Emojis.
Nicht so, wenn man das hier also auf der entsprechenden Unicode-Seite sich mal ansieht.
Also in der ersten Version sind also hier noch so ein paar,
also inzwischen kann man eigentlich sagen, also alles,
was man so typischerweise auf seinem Smartphone irgendwie mit Drauf hat an Darstellung,
ist dort eben in diesem Unicore-Zeichensatz letztendlich auch schon mit drin,
weil gerade sowas oder so eine Standardisierung ist natürlich eigentlich auch notwendig,
wenn man sagen darf, will.
Also ich habe jetzt irgendeine Textnachrichten, möchte mit jemand anders austauschen,
um jetzt also wirklich Gerede oder eben auch Programm,
unabhängig arbeiten zu können, Nachrichten auszutauschen, ist das dann eben entsprechend wichtig.
Nicht ansonsten, wenn man sich so ansieht,
was dort also letztendlich also auf den Zeichen setzen ist,
also hier sieht man dann also jetzt von dem aktuellen New Indie-Code
die ganzen unterschiedlichen Zeichensätze nicht und man kann dann also quasi jetzt hier für jeder,
zu jeder dieser Sprachen dann,
also hier die entsprechenden Symbole sich ansehen und beispielsweise dann eben auch zeigen lassen.
Gut, ursprünglich war es so,
dass die Unicode-Codierung mit 16 Bit-Prozeichen gestartet ist,
demzufolge konnte man dann natürlich
auch nur maximal 2,16 zeigen
Äh, mit den aktuellen, über 127.000 Zeichen ist man
damit natürlich dann also auch schon drüber. Demzuvor gibt es da dann,
also auch verschiedene Bestimmungen,
die direkte Eingabe von irgendwelchen Zeichen oder Symbolen wird inzwischen eben auch teilweise in den Programmiersprachen,
also beispielsweise hier in Java unterstürzt,
wo man dann eben im Prinzip mit so einem Backslash-U-Unternehmen der
entsprechenden Codierung dann eben auch das zugehörige Zeichen darstellen bzw. eingeben kann,
auch wenn man das jetzt also vielleicht jetzt nicht auf seiner
Tastatur oder sonstig,
also irgendwie direkt zur zur Verfügung hat
Wo Junico dann eigentlich auch entsprechend wichtig ist, ist logischerweise auf Webseiten,
also sprich im HTML-Code. Also da sieht man standardmäßig zu werden,
das ist also zumindest ein bisschen aktuellerer HTML-Seiten sind, dann eben irgendwie sowas,
dass man eben sagt, also Carrasset gleich beispielsweise OTF 8,
was dann eben auf eine der möglichen Unicode-Kodierungen hinweist.
So und was man damit dann eben machen kann,
ich dann also auch selber in ihrem Rechner,
also hier mal zum Beispiel unter Curmate Project ansehen.
Das sind dann nämlich im Prinzip so eine HTML-Seite,
wo man dann also wirklich mal unter OTF8-Sampler dann im Prinzip jetzt aus unterschiedlichen Sprachen,
Sprachfamilien, also von hier irgendwelchen hohen Zeichen hier über russisch-griechisch bis zu eben irgendwelchen entsprechenden anderen Schriftsymbolen, also verschiedene Beispiele hat.
Also hier ist dann zum Beispiel auch so was wie Breycode mit drin oder Breischriften mit drin und da kann man dann also zum Beispiel auch immer ganz gut sehen,
auf seinem Rechner, was dann also gerade an aktuellen Zeichensätzen installiert ist,
also wie man sieht hier bei mir auf dem Laptop,
ist das noch relativ viel, also was sie anscheinend fehlt,
ist also irgendwie sowas wie mongolisch,
wo ich ja jetzt nicht den passenden Zeichensatz habe,
also wie gesagt, wenn sie das bei ihrem Rechner,
beim Wachen wird man dann eben auch sehen, anstellen,
wo der Zeichensatz vom Betriebssystem aus ja nicht verfügbar ist,
sind dann eben irgendwie nur solche Auslastungssymbole angezeigt.
So, und damit kann man dann eben auch,
wie genau jetzt also auf dieser Webseite,
einfach beliebige Sprachen miteinander mischen, weil ich dann eben wirklich jetzt meinen,
meine einheitliche Zeichensatzgudierung für alles dann zur Verfügung habe.
Also wie gesagt, das ist auch immer eine entsprechende Ausschnitt
oder Vergrößerung jetzt, also von dieser Webseite gewesen. Gut,
das, was wir jetzt natürlich meistens nutzen,
sind die Standardzeichen, jetzt also aus dem lateinischen Zeichensatz,
typischerweise das, was man dann als Lettin A bezeichnet,
also was dann im Großen und Ganzen erstmal den Asky-Zeichen entspricht,
dann eben Erweiterungen dann um europäische Umlaute und Sonderzeichen.
Und dann gibt es also ab hier und der Unicode-Grenze,
nicht die sind danach, haben wir jetzt einfach durchbenahmst,
also man kann sich dann hier so die einzelnen Zeichensätze dann
immer jeweils dort von der Webseite dann eben auch entsprechend runterladen,
entsprechend anzeigen lassen.
Und da sieht man dann eben jeweils, welche Zeichen es
dann also ab welcher Stelle in dieser Unicode-Kodierung gibt.
Nicht, dass es so ein PDF ist dann im Prinzip immer das,
was sich also hinter diesen Referenzen von der Seite her
dann verbirgt
So, wie gesagt, also alle möglichen Zeichen,
Sprachsymbole und, und, und, bis zu irgendwelchen Sachen,
die jetzt also zum Beispiel Betriebssystem motiviert sind oder bestimmte Schriftarten motiviert sind,
also im Prinzip Microsoft dann mit dieser Ding-Buds-Schrift,
beziehungsweise mit diesen dicken Bad-Symbolen vielmehr, naja,
also auch das ist inzwischen Unicode standardisiert,
was es dort dann entsprechend an Sachen gibt,
die ganzen Südostasiatischen Sprachen und, und, und.
Andere Möglichkeit, sich also mal anzusehen, welche Zeichen darstellbar sind,
wie die aussehen, wie die kodiert werden, ist beispielsweise auch über die Programmiersprachen gegeben.
Also dieses hier ist ein Applet,
was also im Prinzip eigentlich zu dem Demo-Programm von dem JavaDeballopment-Kids gehört,
also wenn man sich dort, also die Demos bzw. Samples mit installiert,
findet man dann in dem Dateibaum irgendwo in der Tailfe versteckt,
dann dieses von 2D-Test beziehungsweise das Ganze,
also diese entsprechende Ja-Datei habe ich dann also auch nochmal explizit jetzt auf die Webseite getan.
Also auch da findet sich das Ganze dann und ich könnte dann eben beispielsweise
So könnte das dann eben auch entsprechenden Asyl lokal,
wenn ich so nahe so ein Prinzip in Java Runtime irgendwie installiert habe,
also mir hier anzeigen lassen. Ich finde,
da kann man dann eben auch jeweils abhängig davon,
was also auf dem System installiert ist,
hat man dann also hier jetzt also irgendwo seine jeweiligen Schriften
und kann dann eben dann hier auch die entsprechenden Ausschnitte von den Zeichensatzkodierungen sich ansehen.
Ich fasse dann eben auch über griechische Buchstaben Oder sowas
wie tamil wird also hier in dem Areal Zahlensatz dann,
glaube ich, auch schon fehlen.
Aber jedenfalls also dann eben die unterschiedlichen Sachen, also aus diesem Unicorp-Beispielen,
sich dann eben auch nochmal irgendwie so anzeigen lassen.
Gut, das ist jetzt hier eigentlich nur,
um das Ganze nochmal so ein bisschen vorzuführen,
wie das im Prinzip aussieht,
die sollten ausgeschaltet sein
Okay. Also wie gesagt, das ist eigentlich also nur dafür,
dass man sich das also nochmal entsprechend ansehen kann,
wenn man da mal... Interesse hat.
Gut, wie wird Junicode jetzt also rein technisch gesehen codiert?
Ursprünglich war es eben mal so,
dass man, als der Standard rausgekommen ist,
also Anfang der 90er Jahre im Prinzip,
eine 16-Bit-Codierung gemacht hat,
dem zuvor gekommen hat,
damit also bis 65.5536
Zeichen darstellen
Wird teilweise dann eben auch zum Beispiel als in Java einen Datentyp Char benutzt.
Inzwischen ist das aber natürlich also auch nicht mehr so ganz aktuell,
weil eben für die Gesamtanzahl der Zeichen reicht das also auch nicht mehr aus.
Und ab Unicode-Version 3 wurden dann also quasi mehrere solcher Tabellen definiert,
zwischen denen man dann eben entsprechend umschalten kann, beziehungsweise dann eben mit entsprechend größeren Wortbreiten.
Ein Nachteil bei dem ganzen Verfahren ist, wenn ich jetzt sage,
also ich nehme jetzt also für einen Charakter jetzt eben nicht mehr 8-Bit oder 7-Bit,
wie das ja so ursprünglich bei Aski war, sondern jetzt eben beispielsweise 16-Bit oder 32-Bit ist,
dass natürlich also alles, was an Textdateien auf dem Rechner rumliegt,
also auf einmal doppelt oder viermal so groß wird, was man natürlich eigentlich auch nicht haben möchte.
Wenn ich demzufolge, würde es sich dann eigentlich anbieten,
eben auch so eine Codierung zu haben,
wo man dann eben sagt, ähnlich,
wie ich das ja so letzte Woche schon mal so kurz bei dem Morse-Alphabet vorgestellt hatte,
dass man eben für bestimmte Sachen, die man häufig benutzt,
also in Unserem Kreis würde man dann eben typischerweise sagen,
also die lateinischen Buchstaben, die möchte ich mit einer relativ kurzen Codierung darstellen und irgendwelche selten benutzten Emojis,
ja gut, okay, dann ist es halt so,
dass sie dann eben meinetwegen 32 Bit für die Codierung benötigen,
aber die tauchen jetzt eben vergleichsweise nicht so häufig in Texten auf.
Daraus hat sich dann eigentlich dieser Standard bzw. diese Codierung von diesen Junico-Zeichen
ergeben, die also heutzutage dann eben als UTF8 oder UTF16
bezeichnet wird
Die sind eben folgendermaßen aufgebaut,
dass man dort dann ähnlich wie bei so einem Briefix-Code eben sowas hat,
wo man sagt, also Buchstaben, die vergleichsweise häufig vorkommen.
Also sprich jetzt die ganz normalen Buchstaben aus dem Aski-Zeichensatz. Die werden relativ kurz kodiert,
also beispielsweise jetzt hier mit Arnem Byte, irgendwelche Zeichen,
die man jetzt also nicht mehr ganz so häufig hat,
teilweise eben die Umlaute Euro-Zeichen und so weiter,
für die wir dann schon eben zwei Wald spendiert und welche,
die man also vergleichsweise selten benutzt,
einen Violinschlüssel
Für den wird dann eben entsprechend längerer Code gemacht. So,
und damit kann man dann eben erreichen,
dass man also beispielsweise mit diesen UDF8,
mit dieser kurzen Codierung hier mit den 8 Bits,
direkt kompatibel mit dem Aski-Zeichensatz ist und eben dann als zusätzliche Erweiterung diese längeren Codierungen hat.
Das Ganze ist dann im Prinzip aufgebaut, wie so ein Prefix-Code,
Codierung wird dann Im Prinzip im übernächsten Kapitel Thema werden,
wo es dann um Kodierung, Kulierungstheorie geht. Das ist das,
was also hiermit angedeutet ist,
beziehungsweise auf dieser Folie ist es noch ein bisschen besser zu sehen,
wo man sieht,
wenn ich jetzt also quasi nur ein einzelnes biete für die Unicode-Kodierung verwende,
dann fängt das eben immer mit einer Null an und
dann habe ich eben letztendlich noch sieben Bit über,
die entsprechend auch genau
der Askikodierung
Wenn ich jetzt also irgendwas habe,
wo ich dann eben im Prinzip mit zwei Byte kodiere,
dann fängt das eben immer mit 1, 1, 0 an.
Und jedes von diesen Folgen bytes dann eben auch immer mit 1,
0. Und die Anzahl dieser Einzelnen hiervor, sagt,
dass eben noch ein zweites Byte kommt,
dass es dann dieses hier,
in dem Fall würden jetzt eben hier noch zwei weitere und hier noch drei weitere Byte folgen,
nicht und je nachdem,
würde dann eben entsprechend dieser vordere Teil immer kürzer und von diesem Folgebytes habe ich dann immer noch sechs Bit für die Zeichenkodierung über.
Nicht demzufolge kann man dann quasi jetzt in jeder dieser Kodierungsebenen entsprechend viele Zeichen kodieren.
Damit kriegt man das dann eben hin, relativ flexibel zu sein.
Wie gesagt, theoretisch kann das dann eben bis zu sieben vorgebaut gehen.
Damit kommen dann also auf zwar auch 42 Zeichen. Davon ist also auch der aktuelle Unicode-Standard, also noch weit von entfernt. Gut, neben Zeichen oder Zeichensatzkodierungen etwas,
was ihnen dann also auch gerade in der Programmierung immer wieder begegnen wird,
sind dann im Prinzip solche Sachen wie Lokalisierungseinstellungen,
was dann also auch für den Rechnern dann in der Regel immer als Lokale bezeichnet wird,
beziehungsweise in dem Programmiersprache findet sich das dann also häufig unter diesem kurzen Internationalisation,
abgekürzt dann als I, 18N, wird benutzt,
um zum einen sowas wie Sprachen in der Benutzeroberfläche, aber eben auch Tastatur-Layouts,
Belegungen, irgendwelche Codierungs- sagen wir mal, Standards für jetzt also irgendwelche Zahlenformate und so weiter dann eben entsprechend umzuschalten.
Also sprich, inzwischen, also zumindest jetzt seit Versionen,
10 ist oder, ja ich glaube,
also ab Windows 8 ist also auch Windows,
also inzwischen so weit, dass man also im Prinzip,
wenn die Sprachen also entsprechend umschalten kann,
bei Unix-artigen Systemen gibt es das also schon ein bisschen länger und man kann dann im Prinzip sagen,
ich habe also einen Rechner, eine Computerinstallation und kann eben dadurch,
dass im Hintergrund dann eben quasi Bibliotheken ausgetauscht werden,
wo dann also irgendwelche Strinks irgendwelche Fehlermeldungen hinterlegt sind,
eben sagen, ein Benutzer,
der jetzt quasi den Computer in der deutschen Installation benutzt,
sieht das eben alles auf Deutsch,
ich kann das aber eben auch problemlos auf eine andere Sprache umschalten und was weiß ich,
also wir haben das bei uns zum Beispiel mit irgendwelchen Studenten,
die jetzt also irgendwie als Stipendiaten ankommen,
also dass man da sagt,
also das ist immer noch das gleiche Betriebssystem.
Die haben dann aber eben nur eine andere lokale Einstellung und
bei denen spricht das System dann eben Englisch.
Beziehungsweise, je nachdem, was man dort dann also installiert und festgelegt hat.
Das ist also relativ komfortabel und das ist inzwischen eben auch etwas,
was dazu führt,
dass also gerade so bei diesen ganzen Internationalisierungsbemühungen man sich da dann eben auch teilweise das Leben also deutlich einfacher machen kann,
weil es früher eben ursprünglich so war,
dass man eben wirklich sagen konnte, okay,
ich habe jetzt Installationsmedium für mein Betriebssystem und das ist dann eben mit der und der Sprache.
Und wenn jemand eine andere Sprache braucht, dann musste man
also erstmal das entsprechen, also die sprechende Installations-DV, die dafür haben.
Nicht inzwischen kann man das eben relativ gut austauschen,
sofern die Entwickler sich dann eben auch an diese Standards gehalten
haben und dann eben das in ihren Programmen dann eben auch entsprechend berücksichtigt haben.
Gut, wie gesagt, bei, je nachdem, Betriebssystem aussieht,
kann man das dann eben mehr oder minder lokal einstellen.
Teilweise wird das eben jetzt also zum Beispiel bei Java auch
schon direkt in der Programmiersprache über entsprechende Bibliotheken unterstützt.
Nicht mit bei anderen Programmierumgebungen ist das dann eben teilweise auch vorhanden.
Gut, ein Problem, was in dem Zusammenhang dann auch immer noch auftritt.
Ich hatte ja ganz am Ende der letzten Vorlesung,
also sprich am Freitag ja auch schon kurz darauf hingewiesen,
dass also im Prinzip solche Codierung, jetzt nicht nur hinsichtlich der Zeichensätze,
teilweise Betriebssystem abhängig sind, sondern eben auch,
wie jetzt zum Beispiel Zahlenenden kodiert sind.
Also auch dazu gibt es dann immer, je nach Betriebssystem und Umgebung,
also im ganzen Satz von Tools oder Werkzeugen, die das also dann entsprechend umwandeln können.
Also dies sind jetzt also hier welche,
die man also typischerweise so auf Unix-artigen Systemen findet,
also Dos to Unix, Unix to Dos,
wo man dann eben von Asky-Darstellung beispielsweise dann eben eine Textdatei mit Carrath Return Line,
Feeds, wie es dann also im Prinzip aus dem DOS-System kommt,
dann eben quasi in die Unix-Konvention umwandeln kann oder entsprechend wieder zurück.
Man kann dann eben teilweise noch bestimmte Code-Pages sagen, für welche Systeme das gilt,
beziehungsweise noch universeller macht das dieses Tool A-Konf, wo man dann also wirklich zwischen beliebigen Textdateien hin und her konvertieren kann. Wenn man sehen will,
was da alles falsch gehen kann, kann man sich also mal,
oder kann man sich da mal also irgendeine etwas ungewöhnlichere Codierung aussuchen,
Eine Textdatei entsprechend in dieser Kulturdierung dann also mal abspeichern und dann also mit irgendeinem ganz normalen Text in die Tour öffnen,
wo man dann also gerade sogar umlauten, Sonderzeichnen,
also eben auch sehr schnell sieht,
also wie kodierungsabhängig eigentlich das Ganze ist und das,
was wir jetzt eigentlich immer so gewöhnt sind,
man kann also Daten von überall, von jedem System,
in jedes andere System hin und her tauschen,
das läuft problemlos, muss man eben sagen, okay,
das hat sich in den letzten Jahren glücklicherweise so entwickelt, nicht aber bis vor einigen Jahren war das eben aufgrund dieser sehr unterschiedlichen Kodierungsstandards, die es da gegeben hat eben.
Also durchaus nicht so gang und gäbe, dass es das gibt.
So eine andere Sache, wo Zeichensatzkodierung eigentlich auch noch interessant sind,
ist bei der Übertragung von Daten zwischen Rechnern als klassisches Beispiel
habe ich hier mal das SMTP, das ist das Mail-Protokoll genommen.
Wenn Sie jetzt also, egal welches Betriebssystem,
welchen Mail-Client Sie verwenden, eine Mähe rausgeschickt wird.
Und sie haben da jetzt irgendwelche Daten angehängt.
Die werden typischerweise als sieben Bit Asky-Daten eigentlich rausgeschickt und interpretiert,
weil man natürlich jetzt nicht weiß, okay,
sind das jetzt Binärdateien, sind das jetzt also irgendwelche Audiodateien,
also was weiß ich,
also irgendwelche Musike oder sind das irgendwelche Fotos,
die man verschickt,
wo eigentlich beliebige Bitstrings drin vorkommen können
Und um jetzt zu sagen, ich möchte eigentlich, sich diese Nutzinformationen,
die ich da ranhänge, jetzt von dem irgendwelchen Protokollinformationen unterscheiden können,
wurde halt ursprünglich eigentlich mal festgelegt, also das, was als Mehl versandt wird, sind eben nur ganz normale Asky-Dateien. Das,
was eben passiert, ist,
wenn sie jetzt also irgendwie was rausschicken, beziehungsweise eine Mail empfangen,
dass dann also quasi über Konvertierungsroutinen vom, beim Versenden,
wo das Ganze dann also quasi dann über einen Mail-Ausgangsserver läuft,
beziehungsweise auf der anderen Seite,
wenn sie die Mail dann eben erhalten, hin und her konvertiert wird,
sodass man dann hinterher dann also auf ein Zielsystem natürlich dann wieder sagt,
okay, also ich muss mich jetzt nicht mehr mit irgendeiner Base 64 kodierten Datei rumschlagen,
sondern ich sehe dann eben schon quasi das Angehängte JPEG dann eben als Bild,
was mir dann also irgendjemand mal zugeschickt hat oder so.
Gut, das Verfahren, was dort also typischerweise benutzt wird,
Ist zum Beispiel sowas, was ja so Base 64 nennt,
was im Prinzip jetzt also eine mehrstufige Unkodierung ist,
die dann eben aus beliebigen Bits drinks Asky-Symbole generiert,
die werden dann ganz normal mit dem Mail-Protokoll,
war es ja nun also im Prinzip also irgendwo so aus den,
ja, jetzt müsste ich lügen, irgendwie 60er,
70er Jahren sein müsste,
verschickt und dann eben quasi transparent,
wenn wieder zurückkonvertiert
Wie funktioniert diese Konvertierung? Es werden im Prinzip immer drei Bytes,
der zu senden, Nachricht, Information, also unabhängig davon,
also ob das jetzt also irgendein dringende Zeichenkette ist oder also
ob das jetzt da so ein Tal einer MP3-Musikdatei ist.
Also im Prinzip werden auf einmal drei Bytes genommen und in
vier sechs Bit-Zeichen zerlegt. Also das heißt,
da nehme ich jetzt einfach entsprechend 24 Bit,
mache hier also aus den dreien,
also vier Zeichen
Wenn ich jetzt sage, hier sechs Bit,
um sechs Bitsykodi oder mit sechs Bit, kann ich,
wenn ich jetzt einfach binär durchgehe,
im Prinzip 64 verschiedene Zahlen darstellen und dann kommt er quasi im zweiten Schritt,
eine Zuordnung, wo dann einfach zu diesen Zahlen ein Aski-Zeichen zugeordnet wird.
Das heißt, sie zahlen 0 bis 25, sind die Großbuchstaben A bis Z,
26 bis 51 sind dann eben die kleinen Buchstaben.
Nicht dann habe ich hier noch die Ziffer 0 bis 9,
ein Pluszeichen und so ein Slash.
Damit habe ich dann also quasi meine 64 Zeichen,
die vorkommen können
Das hier ist alles ganz normal. Sieben Bett Aski-Zeichensatz. Zusätzlich gibt es dann noch Gleichheitszeichen,
was dann einfach so ein Füllzeichen ist, was benutzt wird,
wenn quasi jetzt hier die Anzahl dieser Bytes dann eben nicht direkt umgewandelt werden kann,
mich um zu zeigen, okay,
das ist jetzt einfach nur Anhängsel, aber ohne weitere Informationen.
Und optional kann man das Ganze dann eben auch
noch quasi dann mit Zahlen umbrüchen durch einen Carge-Return versehen.
Gut, das Ganze passiert automatisch durch das Mail-Programm,
was dann also quasi genau diese Konvertierung in die eine Richtung macht.
Mailseitig würde dann also quasi in so eine Textdatei verschickt,
die dann eben entsprechend dieser Base 64 Codierung genügt.
Und auf der anderen Seite wird das Ganze dann wieder zurückgerechnet
und man erhält dann also sein Originaldaten.
Nicht hier ist das also nochmal für ein Beispiel, wo dann also das Wort
Man hier entsprechend codiert wurde. Nicht wo man dann eben sagt,
okay, ich nehme jetzt also beispielsweise jetzt hier aus dem UTF8-Zeichensatz,
also hier die Kodierung, nicht und zerlege das dann eben jetzt hier in diese vier Blöcke,
erhalte dann also Aphahesser so eine binäre Zahl.
Und entsprechend dieser Zuordnungsvorschrift werden daraus dann eben irgendwelche Base 64 kodierten Buchstaben,
beziehungsweise mal vermuten numerischen Zeichen. Das Ganze wird dann eben übertragen und am Ende entsprechend wieder zurückgerechnet. So was an dem Beispiel dann ja auch sieht,
dadurch, dass ich letztendlich hier dann immer aus drei,
acht Bit Zeichen, also quasi dann vier Buchstaben kodiere,
die dann also letztendlich übertragen werden,
ist das natürlich dann die draus resultierende Datei größer wird als die Originaldatei,
aber auf der anderen Seite, und das ist eben der Riesenvorteil,
man ist eben unabhängig von dem, was eigentlich übertragen werden soll,
also wie gesagt, hier geht es um eine Textdatei,
aber es kann eben auch sein, dass man sagt,
okay, also als, ja,
ausführbares Programm oder als Bild habe ich eben hier irgendwie so einen Bits drin und der wird eben genauso entsprechend eins zu eins umgesetzt.
Also das ist das, was also letztendlich dann tagtäglich bei den E-Mail-Anhängen passiert. Gut,
auch für diese Base 64-Kodierung, hier nur noch ein paar Referenzen,
wo sich sowas im Prinzip findet,
also beispielsweise in Java in den Entwicklungspaketen, ist das mitenthalten,
beziehungsweise es gibt dann eben auch hier über entsprechende Referenzen dann,
so war es froh,
dass also als Beispiel dann also hier in diesen Apache-Commons zum Beispiel dann eben auch mit drin ist,
dass man sich da dann also die den entsprechenden Code passen
dann eben ansehen könnte,
wie das dann dort also entsprechende implementiert wäre
Achso, das ist jetzt hier der entsprechende Kohle.
Und irgendwo waren also hier dann auch die entsprechenden Verweise dann
also auf das die Implementation von solchen Sachen. Gut,
hier sieht man dann eben auch mal so ein Beispiel,
wie das Ganze eben benutzt wird, beziehungsweise damit umgegangen wird.
Nicht also auch das hier,
also aus diesem freien Buch Java ist auch eine Insel,
wo dann im Prinzip dann auch hier so eine Demo mit drin ist,
wo dann im Prinzip genau hier dann eben genau diese klasse Base
64 Decoder letztendlich mal benutzt wird.
Und damit dann also so
einen Testring quasi kodiert und übertragen wird
Gut, das war jetzt eigentlich auch nur als Vorstellung,
was man wissen muss, Zeichensatzkudierung,
dann kommen wir jetzt also wieder zu dem Thema Bits und Bytes,
nachdem wir also vorher, das ist schon Zahndarstellung,
die Atometik, jetzt die Zeichensatzdarstellung vorgestellt hatte,
nochmal so ein bisschen auf den Bereich der Poolschnalgebra,
auch da werde ich, denke ich mal,
also bei vielen Sachen relativ schnell drüber gehen,
war ich auch davon ausgehe,
dass das eigentlich auch so irgendwie aus der Schulmathematik bekannt sein sollte und dann also hier zum Großteil,
also irgendwie dann auch nur irgendwie Wiederholung ist.
Wenn ich Grundidee dabei ist, dann eben auch, dass man sagt,
okay, weswegen brauche ich überhaupt sowas wie ein abstrakter Algebra?
Also dass man damit eben die Möglichkeiten hat,
also bestimmte Eigenschaften solcher Systeme zu definieren und eben,
um dann letztendlich, also mathematische Operationen damit eindeutig festzulegen. Im Prinzip,
was man dann eben auf so einer Algebra macht, ist,
dass man also im Prinzip also sagt, welche Elemente es gibt,
welche Verknüpfungen es gibt und welche Rollen bestimmte Elemente haben,
werde ich dann also nachher im Einzelnen, also auch nochmal vorstellen,
wo es also im Prinzip dann sowas wie neutrale Elemente,
Addition, Multiplikation, inverse Elemente und sowas gibt.
Gut, Bulscha Algebra wurde von George Buhl um 1850 entwickelt,
wo es dann im Prinzip dann also mehr Aussagenlogik ging und nicht,
wo man also im Prinzip dann also Aussagen als war oder
als falsch bezeichnen konnte und dann über entsprechende Verknüpfungen damit argumentieren konnten.
Und das,
was man dann eben so als grundlegende Funktion in der Bullschen Algebra hat, ist,
dass er einmal die Negation und Verknüpfung oder Verknüpfung und dann eben sowas wie so ein,
oder häufig dann eben noch sowas wie so ein Exklusiv-Oder,
je nach Outdoor-Quelle beziehungsweise auch Programmiersprache gibt es dann immer sehr viele sehr unterschiedliche Schreibweisen.
Einige davon habe ich also dann hier immer noch mal irgendwie so aufgelistet,
also bei der Negation in mathematischen Büchern hat man also häufig diesen Negationshaken davor.
Ich habe das dann also hier teilweise in den Beispielen dann immer
mit der mit diesem Strich irgendwie über den Symbolen relativ häufig benutzt,
in Programmiersprachen, da hat man dann im Prinzip so eine Negation über das Tillde-Symbol dann realisiert.
Nicht Unverknüpfung, wie gesagt,
hier dann auch die eher mathematischen Schreibweisen hier dann,
also das, was die dann sicherlich nennen,
also auch schon aus der Programmierung oder Programmiersprachen kennen,
nicht so würde das Ganze dann eben beispielsweise in Java
geschrieben werden
Ja, während es ursprünglich eigentlich immer nur um die Aussagenlogoiking,
wurde das Ganze dann also dadurch dann noch ein bisschen weiter formalisiert,
dass also Claude Channon,
den wir dann also im nächsten Kapitel noch sehr viel genauer begegnen werden,
wo es dann nämlich um die Kodierung geht,
dass der dann also letztendlich erkannt hat oder gesehen hat,
dass man also im Prinzip mit dieser Bulschen Allgebra dann letztendlich das,
was wir jetzt damit benutzen, nämlich also binäre digitale Logik,
realisieren können, wo man dann eben letztendlich sagt,
also die Zuordnung zwischen True und The Falls wird für uns dann eben quasi eins und null.
Nicht die Funktion, hier nochmal seinen üblichen Funktionstabellen, also Negation,
Unverknüpfung von zwei Variablen oder Verknüpfung von zwei Variablen und das Exklusiv oder gut,
wie gesagt, also auch das ist,
sollte eigentlich schon alles längst bekannt sein, also vergleichsweise trivial.
Was hierbei dann eben noch interessiert, ist,
dass man eben sagt, also mit eine Operation beziehungsweise man
braucht ja das auch gar nicht mal alle.
Also Metallen dieser Operationen lassen sich dann letztendlich alle möglichen Funktionen darstellen.
Mathematisch gesehen habe ich dann also hier mit diesen Funktionen eine vollständige Basismenge,
um jetzt eben beliebige Funktionen von mehreren Variablen darzustellen.
Das wird uns dann nämlich beispielsweise dann in Kapitel 10
dann auch
noch weiter begegnen
Gut, zu diesen Funktionen oder Funktionsdarstellungen, etwas,
was dann also auch häufiger immer noch mal gefragt wird oder worum es dann geht,
ist also im Prinzip die Anzahl der Binärenfunktionen dazu,
kann man dann eben auch sagen, okay,
wenn ich jetzt eine einzige Variable habe,
gibt es letztendlich vier unterschiedliche Funktionen mit dieser Variablen,
nämlich also Arme eine Funktion,
die unabhängig vom Wert dieser Variablen immer eine Null liefert,
Arne, die unabhängig vom Wert immer eine Eins liefert,
eine, die diese Variable liefert und eine,
die diese Variablen negiert liefert.
Wenn man zwei Variablen hat,
Beispiel folgt gleich auf der nächsten Seite,
hat man also schon 16 mögliche Funktionen und für En-Variablen gilt eben,
dass ich dann zwei hoch zwei hoch en-Funktionen von En-Variablen habe.
Warum? Ganz einfach, weil ich zwei hoch en-Kombinationen von
den Variablen habe und bei den Funktionen kann ich jetzt ja entsprechend
für jede dieser möglichen Kombinationen dann eben auch wieder zwei Funktionswerte annehmen.
Nicht daraus gibt sich dann das quasi zwei hoch,
zwei hoch en die Anzahl der Funktionen ist,
die ich also jetzt über en variablen und einem einer zweiwertigen Menge letztendlich bilden kann.
Gut, rein praktisch gesehen, hier das Ganze jetzt also für binäre Funktionen mit zwei Variablen.
Hier habe ich also im Prinzip jetzt für X und Y Die jeweiligen Werte,
insgesamt hier jetzt vier mögliche Wertekombinationen, beispielsweise X gleich 0,
Y, Leich 0, X gleich 1, Y, Leich 0 und so weiter und so fort.
Und das wären jetzt also im Prinzip die 16 möglichen Funktionen,
die man damit bilden kann,
nämlich wo ich dann immer jeweils das Ganze immer so zu lesen,
dass ich dann immer hier die entsprechenden Kombinationen habe und hier dann den Funktionswert dazu,
nicht eine Nullfunktion, die liefert halt immer eine Null,
nicht das, was also die Funktion eines End ist,
Also sprich das, was jetzt also hier in dieser Tabelle so aufgezeichnet ist,
kann man hieraus ablesen, liefert genau dann eine Eins, wenn X gleich 1 und Y gleich 1, in allen anderen Fällen in Null.
Die Künstler sind dann eben auch diverse andere Funktionen mit drin.
Hier dann also auch nochmal dargestellt in ihrer mathematischen Notation,
beziehungsweise teilweise, also auch in etwas anderen Alternativennotationen.
Und hier wäre dann also der entsprechende Ausdruck in Programmiersprachen,
Syndax dargestellt
Gut, formal gesehen kann man jetzt immer sagen,
okay, was ist eine Bullschale gebracht?
Nicht der theoretische Informatiker fängt jetzt immer an, wenn wir was definieren.
Wir nehmen ein En-Tubel, in diesem Fall ein Sechst-Tubel.
Das heißt, wir haben eine Menge aus zwei Elementen.
Wir haben zwei Operationen darauf, nämlich eine Operation, die quasi was Additives ist,
in diesem Fall das oder eine Operation über das Multiplik-Dideative Evils ist.
Und dann die Negierung als Kompliment und neutrale Elemente der Addition
bzw. den Multiplikationen, nämlich die Null und die Eins.
Und das sind dann im Prinzip dann also hier die sechs bezeichnenden Eigenschaften,
die dann eben in diesem Fall ist, also sie eine Algebar bilden.
Hier sieht man das Ganze dann eben nochmal im Vergleich zu der Darstellung,
wie verhält sich jetzt die Bulsche Algebar zu den Zahlen.
Wenn ich jetzt also die Zahlen wirklich, also ein Zahlen-System begrenzter Wortbreite nehme,
dann ist das mathematisch gesehen der Ring der ganzen Zahlen.
Wo ich dann eben sagen kann, okay,
ich habe Kommutativität, das ist dann eben quasi sowohl für das.
Oder als auch für das Ohren beziehungsweise Äquivalent dann eben für
Addition und Multiplikation. Ich habe sowas wie eine Astriel-assoziativ gesetzt,
distributiv Gesetz, habe dann eben hier diese Identitäten definiert,
also mit den entsprechenden neutralen Elementen, die Wahls.
Und die und die Eigenschaften gelten dann.
Zusätzlich habe ich dann eben hier bei der Bullschnage,
war dann eben auch noch einige andere Eigenschaften, die dann eben zusätzlich auch noch gelten.
Was man also häufiger braucht, um letztendlich Bullsche Ausdrücke umzurechnen,
beziehungsweise damit zu rechnen, sind dann diese Regeln hier unten. Das wird ihnen dann teilweise auch noch in irgendwelchen Übungsaufgaben begegnen. Zum einen also diese Absorptionsgesetze,
wo ich dann im Prinzip sage,
zum Beispiel A oder A und B entspricht eigentlich letztendlich A,
nicht das Ganze,
könnte man sich dann eben zum Beispiel dann auch über Distributivgesetz dann eben letztendlich ausrechnen und damit begründen,
beziehungsweise beweisen und die im Morgenregeln,
wo ich im Prinzip den Zusammenhang zwischen der und Unter-Oder-Verknüpfung,
jetzt mit der Negation habe,
das ist also auf dieser Folie dann nochmal ein bisschen genauer dargestellt,
wo man dann eben letztendlich sieht, okay,
wenn ich jetzt hier gelten habe,
nicht A oder B,
ist das eben Äquivalent zu nicht A und nicht B. Beziehungsweise hier das Ganze dann eben nicht A und B in Klammern,
ist dann gleich nicht A oder nicht B.
Wenn man das das jetzt beispielsweise wirklich in Form von einer Wertetabelle aufzeichnet,
würde man dann eben entsprechend sehen,
wie das Ganze oder dass das Ganze dann eben so gilt.
Nicht rein praktisch ist das dann eben letztendlich mal diese Umform,
auch wenn ich jetzt also die Funktion jetzt hier durch solche Symbole mir darstellen lasse.
Auch das ist jetzt schon wieder so ein bisschen Vorgriff auf irgendwas,
was uns dann später nochmal begegnen wird,
dass man im Prinzip dann also hier genau diese Negierung,
die dann quasi jetzt hier außerhalb der Klammer ist,
dann eben auch so umsetzen kann,
dass ich dann letztendlich also aus dem Oder einen unten mache und dafür dann eben entsprechend die Eingänge invertiere.
Wie gesagt, das wird uns dann später noch begeben bei
der Minimierung logischer Ausdrücke beziehungsweise dann eben beim Entwurf von Schaltung,
wo ich dann eben entsprechend entweder diese Formel oder
eben hier sowas reingrafisch dann brauchen werde
Gut, das exklusiv oder hatte er letzte Woche,
also auch schon mal ganz kurz angesprochen,
das ist dann im Prinzip dann auch so was,
was man hat, siehe dann also auch nochmal formal fassen kann,
Umgangssprachlich ist das dann eben letztendlich immer so was wie,
dass ich sage, entweder A oder B,
aber eben nicht A und B,
beziehungsweise in der Literatur beziehungsweise von der Bezahlung her findet man das dann eben auch häufig unter dem Begriff der Antivalenz,
nämlich A und Live B, weil die Wertetabelle Hier,
legt das eben schon nah,
wenn die beiden gleich sind, also x gleich 0,
y und gleich 0 habe ich als Ergebnis null,
beziehungsweise wenn beide eins sind, habe ich als Ergebnis null,
nicht, aber wenn x gleich eins ist,
y gleich null, habe ich eben eine Eins,
beziehungsweise hier in dem Fall,
wo das umgekehrt ist.
Das ist dann eben entsprechend
dieser Begriff
Als Symbol wird das dann häufig immer durch so ein Pluszeichen
mit einem Kreis drumherum dann beschrieben in der Mathematik,
also zumindest hier habe ich das jetzt so häufig immer so gemacht.
Steht da in dem Zusammenhang jetzt also immer für das Exklusiv oder?
Gut, Schadalgebrage kann ich das exklusiv oder im Prinzip jetzt also
auch in so eine Form aus und oder und nicht umsetzen.
Entweder als dieser Ausdruck oder als dieser Ausdruck,
die sind letztendlich zueinander äqualent
Gut, wie sieht das jetzt mit den logischen Operationen in Programmiersprachen aus,
weil schließlich ist das jetzt das, was uns das vielleicht irgendwie für die Programmierung oder für die Kodierung interessiert.
Da sieht es jetzt also bei den reinen Funktionen,
also aus der bulschen Logik dann so aus, dass man sagen kann,
in Java gibt es eben wirklich als Datentyp sowas wie Bulien,
womit man dann rechnen kann,
NC ist das immer so ein bisschen Wischiwaschi definiert,
weil da gilt das im Prinzip dann nämlich,
also gibt es keinen expliziten Datentyp,
Bulien, sondern da rechnet man im Prinzip mit Entegers.
Und wenn die Zahl eine Null ist, wird sie ihm
quasi logisch als Falls interpretiert, wenn die Zahlen nicht eine Null ist.
Das heißt, jede andere Enteger-Zahl wird als True oder als A1 interpretiert. So,
und mit den entsprechenden Datentypen gibt es dann eben Vergleichsoperationen,
die logischen Grundoperationen und Was man dann eben sehr, sehr häufig macht,
wozu dann also auch gleich noch die Beispiele folgen werden,
sowas wie Mitweise, logische Operationen,
wo ich dann eben quasi im Gesamten Integer wert von 16 oder von 32 mitnehme und quasi jedes einzelne Bit dann als True oder Falls interpretiere und damit dann eben entsprechend rechnen kann.
Gut, fangen wir jetzt mal mit den Verlagsoperationen an. Wie gesagt,
jetzt, da hat man die üblichen, Gleich,
kodiert also immer durch zwei Reichheitszeichen und gleich größert leicht,
größer, kleiner oder kleinergleich,
die dann also quasi jetzt zum Beispiel dann eben für entsprechende Zahlen oder Zahlendarstellung dann eben war.
Sprich irgendwas in C und leicht null beziehungsweise in Java
würde man dann eben entsprechenden Bulien daraus direkt erhalten.
Wenn ich also auch hier nur nochmal,
also jetzt in Bezug also auf die Programmiersprache ziehe dann also wirklich dieser Hinweis,
das hatte ich also bei den Zahlen oder Zahlenkodierungen in der letzten Woche auch schon kurz vorgestellt.
Also gerade so bei diesen Mischoperationen von Scient und Unscience-Zahlen,
Kodierungen, kann man dort also relativ schnell Fehler einbauen.
Gut, wie gesagt, also Vergleich zweier Zahlenergebnisse, der logische Wert.
Bei Java wird eigentlich immer im Zweier-Kompliment betrachtet und gerechnet.
Da ist es eigentlich letztendlich kein Problem. Wie gesagt,
bei C habe ich dann immer diese Unterscheidung in Sight
oder Unsignt
Zahlen mit allen Problemen, die dabei dann eben letztendlich auftreten können.
So, neben den Vergleichsoperationen gibt es dann im Prinzip drei
logische Operationen. Eine logische Nogatnegation kodiert durch ein Ausrufezeichen,
logisches und und logisches oder,
was dann entsprechend dann jeweils zweimal Kaufmanns und oder zweimal eben
so ein senkrechter Strich sind
Wie gesagt, in C ist es eben so,
der Zahlenwert null entspricht Falls.
Alle anderen Werte sind true. Da muss man dann eben aufpassen,
weil, wie gesagt, das ist natürlich eine etwas,
oder völlig andere Semantik ist, als in der Mathematik.
Und weil das also auch eine andere Funktion hat als das,
was also dann die nachher gleich folgenden Bitweisen Operationen machen.
Unterscheidung zwischen den logischen Operationen und den Bitweisen
Operationen wird dann im Prinzip hier über die Schreibweise
der Operatoren gemacht
Bei den logischen Operatoren habe ich immer diese doppelten Zeichen,
beziehungsweise für die Negation, das Ausrufezeichen, bei den Beatweisen, Operationen.
Ich greife jetzt schon mal vor, das wird dann auch
gleich kommen. Habe ich dann eben eine Tilde,
das einfache Kaufmanns und eben den einfachen Strich.
Gut, da bleiben wir erstmal bei den logischen Operationen.
Was man dann also typischerweise immer hat,
wenn irgendwelche Ausdrücke gebildet werden,
dass man eine verkürzte Auswertung hat
Das heißt, wenn ich in meiner Programmiersprache jetzt,
also hier irgendwie so einen größeren Ausdruck stehen habe,
heißt verkürzte Auswertung, dass wenn ich eben beispielsweise hier vorne schon feststelle,
dass der Wert Truh wird,
also beispielsweise eben die Abfrage A, Größer B,
das liefert schon Truh, dann ist dieses oder hier hinten,
also letztendlich irrelevant, was hier hinten passiert,
weil das Ergebnis ist oder der Ausdruck liefert halt eben in jenem Pfaltruh.
Und dass hier hinten wird dann eben teilweise gar nicht
mehr ausgewertet
Nicht das ist also das, was dann also hier dieser Nachbruch ist.
Es kann Vorteile haben mit dieser verkürzten Auswertung.
Es kann eben auch Nachteile haben. Vorteile können sein,
etwas, was ihr so live zeigen werdet,
dass man damit also im Prinzip bestimmte Ausdrücke schützen kann.
Also ich kann jetzt eben zum Beispiel sagen,
vorneweg x kleiner als null.
Oder meinetwegen 9er andersrum. Also x gleich null
Hätte dann logisches Und und dann eben hier hinten,
also im Prinzip sowas hier und dann eben hier hinten,
also irgendwie sowas, wo ich irgendwas beispielsweise durch x teile
. Und bei der verkürzten Auswertung, wenn ich x gleich null habe,
würde diese verkürzte Auswertung dazu führen, dass dieser hintere Teil gar nicht mehr ausgerechnet wird.
Demzufolge also auch nicht versucht wird, durch null zu teilen,
was man ja also mathematisch dann nicht machen kann, was dann eben entsprechendes Problem gibt.
Also da kann es ganzen Vorteile haben,
Nachteile können aber auch auftreten, weil wenn ich also hiermit Funktionen arbeite,
kann man sich da also auch relativ schnell irgendwelche Seiteneffekte einhanden,
weil teilweise diese Funktionen mal ausgeführt wird,
mal nicht ausgeführt wird und das dann also auch immer ein bisschen schwierig ist.
Gut, da muss man auch mal sagen,
das ist dann eigentlich auch so was, was dann unter guter oder schlechter Programmierstil fällt,
also wie extensiv man jetzt also diese Möglichkeiten ausnutzt,
beziehungsweise was man damit dann letztendlich macht.
Gut, hier in den Beispielen, also wie gesagt,
hier wäre jetzt mal so ein klar dübischer Ausdruck,
der dann eben von links nach rechts ausgewertet wird,
wenn das hier Truh liefert,
würde ich es gar nicht weiter betrachtet,
wenn das False liefert,
fängt man eben an
Diesen Teil hier auszuwerten,
wenn der hier also dann schon null liefert oder Falls,
würde dieser hier gar nicht mehr ausgewertet werden.
Und ansonsten würde das dann eben entsprechend dann also hier noch auf diese Auswertungen auslaufen.
Zur Veranschaulichung der logischen Operationen also hier auch nur noch mal,
was passiert, wenn ich jetzt also hier irgendeinen Ausdruck habe.
Wie gesagt, in C, alles, was ungleich null ist,
wird quasi als wahr interpretiert, als True.
Das heißt,
wenn ich das negiere,
erhalte ich null
Nämlich Falls. Wenn ich eine Null habe, die negiere
, erhalte ich also irgendwas. Wahres, in dem Fall
. Also einfach als Konstante dann eben eins. Nicht und
hier hätte man dann im Prinzip exertizimal 6, 9,
Bitvises und 5, 5, das liefert eine Eins,
beziehungsweise wahr, das liefert auch und wahr,
das Ergebnisses war, wird dann immer als eins kodiert.
Und hier das Ganze eben für eine Oder-Verknüpfung,
beziehungsweise da würde sich das dann also quasi mit der verkürzten
Auswertung,
also hieraus schon ergeben
Hier sieht man dann eben auch nochmal gegenübergestellt, wie gesagt,
das ist jetzt natürlich schon vorgegriffen. Also hier die logischen Operationen,
wo ich dann also hier irgendwelche Ausdrücke habe und dann also hier,
du hast dich da letztendlich daraus ergeben würde.
Hier sind dann im Prinzip diese BIT-weisen-Operationen,
werde ich dann also auch gleich nochmal vorstellen,
wo ich dann eben auch sage,
also ich habe jetzt also irgendeinen Wert für X und für Y
und hätte dann eben hier so ein BIT-weises Und wo dann also,
wie jeweils für wirklich jede einzelne Stelle eben entsprechend die Operation gemacht wird.
Nicht was also hier bei den oberen vier Bits dann
jeweils eine Null liefert und nur an dieser Stelle,
wo X und Y beide eine Eins sind,
ich hier eine Eins erhalte.
Nicht hier ist das Ganze von oder hier werden X und
Y Bitweise negiert und dann eben die entsprechenden Operationen gemacht beziehungsweise
da ein entsprechender Ausdruck gebildet.
Gut, ist aber eigentlich
relativ klar,
Style Forward
Gut, zu der verkürzten Auswertung, also hier auch nur noch mal. So ein Beispiel dafür,
wo man sagen kann, ein Vorteil oder ein Nachteil,
also hier genau dieses eine Beispiel, was ich eben schon gebracht habe, nicht. Also wenn ich quasi verhindern möchte,
dass ich eine Division durch Null mache,
kann ich das in dieser Art und Weise schreiben,
wo ich dann eben sage,
logisch konkordiniert und dann eben meinen eigentlichen Ausdruck habe,
nicht und der wird eben nur ausgebetet, wenn A,
Ungleichnull ist,
nicht womit ich dann also quasi sicher bin,
dass ich hier nicht durch Null teile oder hier ein anderes Beispiel damit man jetzt also nicht einen null Pointer,
der referenziert, wird dann,
also quasi dann dieses Pointer-Variablen und eben auch hier entsprechend genommen und nur wenn die ungleichen null ist,
wird dann also hier letztendlich damit irgendwie was gerechnet oder gemacht.
Dann etwas, was also auch sowohl C-Assass Java mit drin ist,
ist ein sogenannter Ternero-Apparator,
wo ich dann im Prinzip also eine Bedingung habe und abhängig von dieser Bedingung zwei Ausdrücke stehen haben kann,
nämlich entweder einer, der eben war, ausgeführt wird,
wenn also die Bedingung wahr ist, einer,
der ausgeführt wird, wenn die Bedingung false ist.
Damit kann man also relativ elegant zum Beispiel sowas machen,
wie also irgendwie eine Zuweisung von irgendeinem absolut wird,
wo ich dann also quasi dann irgendwie hier stehen hätte.
Also Y ist gleich und anschließend dann eben diesen Ausdruck,
nicht weil wenn X kleiner Null ist,
ist das Ergebnis minus
Wird also quasi positiver Zahl, wenn das Ergebnis größer
gleich null ist, ist es die Zahl selber.
Gut, und damit habe ich dann eben letztendlich von
der Funktionalität her genau den Absolutwert gebildet.
Logische Operationen in Java, das ist jetzt das,
was Sie da natürlich aus SE dann eher kennen.
Da gibt es eben diesen Datentybulien mit False and True.
Das ist dann eigentlich auch derjenige,
mit dem man Nase letztendlich logische Operationen bildet und nicht
wie dann NC,
also irgendwie Integr
dafür missbraucht
Es gibt dann eben auch die üblichen Vergleichsapparatoren.
Es gilt genauso dann eben diese verkürzte Auswertung. Und auch
da gibt es dann eben sowas wie so einen Teernährenoperator,
also letztendlich, aber nichts Neues. Gut, bei den Bittweisen,
logischen Operationen sieht das dann eben so aus, dass man letztendlich die Indiger-Datentypen doppelt benutzt.
Nämlich einmal interpretiere ich sie dann quasi als eine Zahl,
sei das jetzt eine Ganszahl, zweier Komplimentsal oder wie auch immer,
kodierte Zahlen, mit denen ich dann also quasi meine atmetischen Operationen ausführen kann.
Und zum anderen kann ich sie dann aber eben auch interpretieren,
als also quasi ein String aus Nullen und Einsen mit einer bestimmten Wortbreite,
nämlich abhängig von dem Datentyp, dann eben 1632,
64 Bit, wo ich dann eben bittweise auf allen Bits jetzt,
also meine Operationen machen kann, Negation und oder Verknüpfung,
XOV-Verknüpfung und dann eben noch diese zusätzlichen Schiebeoperationen,
die ich dann also gleich am Ende dieses Kapitels noch
mit vorstellen werde
Gut, dazu sind in beiden Programmiersprachen,
also diese vier Operatoren definiert. Diese Negation,
also quasi durch die Stilde, wo dann durch diese Tilde,
wo dann im Prinzip dann also alle einzelnen Bits invertiert werden.
Logisches und, logisches oder beziehungsweise das exklusiv oder,
wenn ich hinter das Ganze dann eben
jeweils für die ASMBits ausgeführt
Hier noch mal ein kurzes Beispiel,
wo das Ganze dann im Prinzip gezeigt ist,
also hier ein String für X und für Y. Hier dann die dieweiligen Strings,
wie das Ganze dann aussehen würde,
wenn ich dann also mitweise Invertierung mache und dann eben hier einige Ausdrücke,
Betweises und Betweises oder Betweises exklusiv oder nicht das,
was man da dann eben typischerweise einfach immer nur macht,
ist dann eben jeweils von den Ausdrücken dann
eben hier bitweise,
dass entsprechende Funktionstabelle sich zu überlegen
Gut, neben diesen Grundoperationen,
die eigentlich so in einem Programmiersprachnamen mit drin sind,
beziehungsweise eben auch entsprechend mathematisch dann immer mit drin sind,
gibt es dann eben noch zusätzliche Schieberoperationen,
die dann häufig also auch noch für die Sprachen definiert werden,
die typischerweise dann eben auch für alle Indie-Daten typisch verfügbar sind.
Und zwar ein Linksschieben, ein Rechtsschieben, beim Rechtsschieben wird er noch unterteilt,
in logisches Synarithmetestes schieben und Rotationsoperation, Rotated Left for Tate Ride,
die man dann eben teilweise auch noch für irgendwelche Befehle beziehungsweise für irgendwelche Algorithmen, also häufig braucht.
Auch solche Operationen sind häufig, wie jetzt also auch irgendwelche arametischen Operationen,
direkt durch entsprechende Hardware-Einheiten realisiert,
lässt sich also vergleichsweise einfach machen und typischerweise sind die dann eben eigentlich auch bei fast allen Prozessortypen,
also direkt über irgendwelche Assembler-Befehle, also quasi auf der untersten Ebene des Befehlsatzes ansprechbar.
Gut, was machen diese Funktionen? Shift Left ist,
dass ich eben sage, ich nehme jetzt hier so ein Intager,
also in diesem Fall ist das jetzt ja so irgendwie so ein 16-Bett-Entager,
also sprich ein String aus 0 und 1 und den kann man dann eben um NBit nach links schieben,
was dann dort passiert, ist,
dass eben die oder die quasi, oder die obersten N-Bits,
die ja also auf der linken Seite stehen,
werden herausgeschoben und von rechts werden ihm entsprechend viele Nullen eingefügt.
Hier sieht man das Ganze dann eben nochmal so ein bisschen visualisiert,
also jetzt für eine Schiebewortbreite von 1. Ich fuhr dann also
quasi diese Null hier rausgeschoben wird.
Alles andere geht dann dementsprechend um eine Stelle weiter und hier wird dann eben eine 1 hineingeschoben.
In Java und NC ist die Slingschieben, also direkt als Operator verfügbar.
Wo ich dann eben mit diesen zwei Kleiner Zeichen,
das ist im Prinzip ansprechen kann. athmetisch gesehen,
weil ich kann das ja so auf allen Entager-Typen machen,
entspricht das dann einer Multiplikation mit zwei Hochähnen.
Weil ich also typischerweise ja Stellenwort-Kodierung oder Stellenwertkodierung habe. Nicht,
wo ich dann eben sage, wo ich dann eben sage,
okay, das ist von der Stellenwertigkeit,
das wäre 2 hoch 0, 2 hoch 1,
2 hoch 2, 2 hoch 3 und so weiter.
Ich finde das jetzt eben um eine Stelle schiebe,
würde die Zahl quasi doppelt so groß werden,
wenn ich es um zwei Stellen schiebe,
viermal so groß und so weiter.
Beim Rechtsschieben hat er gesagt, gibt es zwei Arten.
Zum einen dies Äquivalent zu dem Linksschieben,
das ist dann das logische Rechtsschieben,
wo ich dann im Prinzip jetzt einfach um NBit nach rechts
verschiebe und an den zusätzlichen Stellen dann immer jeweils Nullen einfüge
Auch das ist in Java, als ob er Rator verfügbar,
mit diesen drei größeren Zeichen, NC,
ist das nur für Anzahlentypen definiert,
weil da gibt es nämlich nur einen Operator,
der dann also quasi für Ansign-Typen,
also diesen Rechtsschieben entspricht,
für Sign-Typen gibt es das nicht
Die andere Sache ist dann eben dieses Arrethmetische Schieben. Das ist nämlich genau das,
worum es dann letztendlich geht, wenn man sagt,
also dieses hier ist jetzt also irgendwie eine Engital-Zahl,
die ich jetzt also von der Interpretation her nehme,
als eine Zwei-Komplimentszahl, weil das, was man dann machen müsste,
wenn ich die dann also jetzt entsprechend nach rechts schiebe und die oberste Stelle ist eine Eins,
dass ich eigentlich eine Unterscheidung machen müsste,
ist eine positive Zahl, ist es eine negative Zahl,
bei einer positiven Zahl wäre die oberste Stelle ja eine Null.
Das heißt, da entspricht das dann eben eigentlich,
also auch diesem logischen Schieben, nicht aber im Arenthmetischen Schieben,
wird halt eben immer Folgendes gemacht,
dass man dann also quasi das Höchstwertigste mitnimmt und dann eben entsprechend vervielfacht.
Das heißt,
wenn es eine negative Zahl ist und die wird eben um
eine Stelle oder um mehrere Stellen nach rechts geschoben,
dann bleibt es eben auch letztendlich eine negative Zahl,
weil dann eben hier oben dann
eben lauter Einzelnen auftauchen
In Java, wo das Ganze jetzt ein bisschen sauberer gelöst ist,
gibt es dazu dann eben diesen Operator mit den zwei Fallen,
wo man dann eben auch gleich einfach von der Schreibweise ja sehen kann,
handelt es sich eben um logisches oder um aratmetisches Schieben,
NC ist das Ganze jetzt eben wie eigentlich wieder jetzt nur für,
oder gibt es eigentlich nur einen einzigen Operator,
nämlich dieses mit den Zwahlen größer Zeichen,
der dann aber eben da dann beispielsweise dann eben jetzt nur für Silentypen definiert ist und für Ansign,
Typen, hätte ich dann im Prinzip dann sowas wie ein logisches Schieben,
beziehungsweise rein faktisch gesehen macht das da dann eigentlich keinen Unterschied.
Das, was bei dem Shift Ride, Arridmatic letztendlich passiert,
kann man sich vorstellen, so ähnlich wie eine Division durch zwei hochenden. Also wenn ich bei dem Links schieben,
sage, das ist eine Multiplikation mit zwei hoch,
teile ich hier quasi durch zwei Hochennen, ähnlich deshalb,
weil da, wo das Ganze nämlich nicht gilt,
ist wirklich jetzt bei der Unterscheidung,
ob ich eine positive oder eine negative Zahl habe,
weil ich dauert quasi bei negativen Zahlen oder bei negativen Zahlen,
also eine Rundung zum betragsmäßig größeren Wert machen würde und
das ist eigentlich jetzt umgekehrt zu dem,
wie ich das dann eigentlich bei positiven Zahlen machen würde
Beispiel sieht man also hier nochmal. Ich habe hier jetzt
also ein Schieben um eine Stelle nach rechts und dann
wird also quasi aus dieser Hexe dezimalzahl, wie näher
4307. Letztendlich dieser String hier, wie näher dann 2153,
was dann im Prinzip nichts anderes ist,
als durch zwei geteilt und der Divisionsriss dieser 1 ist dann nämlich das,
was rausgeschoben wird,
was verloren geht
Und bei negativen Zahlen, das ist dann das,
was also hier beispielsweise jetzt angedeutet ist, schieben um drei Stellen,
ist dann quasi sowas wie ein Teilen durch zwei hoch drei,
also durch acht.
Und das aus dieser Zahl, minus 28.460,
wird dann also letztendlich dieser String minus 3.558. Mich war es
dann also ungefähr diesem Durchacht geteilten entspricht.
Wobei dann eben Divisionsrest, also das,
was dann nämlich letztendlich hier dann auch mit rausfällt,
letztendlich verschwunden wird,
ist bloß eben,
dass dann eben
die Rundung anders erfolgt
Dies mit diesem Rundungsmechanismus, das ist also hier nochmal kurz veranschaulicht,
also wenn wir für die Zahlen,
wo ich jetzt also hier im Prinzip eine Minus,
also mit einer Stellenwortbreite von acht Stellen,
das einmal zeige und hier eine Minus 5 Farbe,
um eine Stelle Schiebe, erhalte ich dann eben diesen String,
ist dann eben bei dieser Stellenwortlänge eine Minus 3,
noch ein weiter Minus 2, das,
was man dann eben sieht, ist,
wenn ich es aratometisch jetzt eigentlich richtig teile,
hätte ich dann also hier quasi 2,5,
müsste das dann aber eigentlich zu zwei Runden und nicht
zu drei
Auch da gibt es also Möglichkeiten,
dass dann also über so einen Korrekturfaktor dann quasi,
also dass wir jetzt also der entsprechende C-Code dafür beispielsweise wieder zu kompensieren,
Trick dabei ist,
dass man entsprechend an der niederwärtigsten Stelle,
die noch erhalten bleibt,
im Prinzip dann sowas wie so eine ULP,
also Unit of Least Precision mit hinauf addiert,
dass er dann bei negativen Zahlen
da dann in die richtige Richtung rundet
Kann man sich dann also auch nochmal irgendwie einzeln
an Beispielen überlegen, wie das Ganze funktioniert.
Wie gesagt, ansonsten in dem Buch von Brian oder Blue Hellerin
ist das also auch nochmal dargestellt oder vorgerechnet. Gut,
das sind jetzt eigentlich, sagen wir mal, die üblichen Befehle,
die man dann also in den Programmiersprachen so dann auch immer jeweils mit drin hat.
Das, was dann also schon ein bisschen spezieller ist,
was dann eben wirklich also nur auf unserer Hardware-Ebene gibt oder eben über irgendwelche Zusatzbibliotheken, sind dann also solche Protate-Befehle.
Also auch das eigentlich relativ straightforward. Ich habe eben jetzt also irgendeinen Indiger-Wert,
also in diesem Fall jetzt hier auch erstmal nur 16 Bild nicht und es ist eine Roadtate,
um eine Stelle nach links, würde dann eben machen,
dass das, was links rausgeschoben wird,
dann eben hier quasi auf der anderen Seite wieder reingeschoben wird.
Wie gesagt, in den Sprachen nicht als Operator verfügbar,
was man aber häufig hat, also beispielsweise in Java gibt es
dann eben in der entsprechenden Intellectual-Bibliothek dann eben unter Programmroutine,
die genau sowas macht
Und logischerweise gibt es neben dem Rotate Left auch noch ein Rotate Ride.
Auch das eigentlich relativ klar, was das macht.
Ja. Ja. Die Zahlen, also was die,
die, und das sind Zeitreitritte, und das war 1500,
das steht, wird, wobei diese verschiedenen Rechts,
die einen sind,
die da vorne hinstehen werden,
die gar nicht
Prinzipiell, die Vater, die haben da gezeigt,
weil das müsste ja auch die Zeit bringen,
die Uhrzeit, dann hört sich das.
Gut, also die Frage war jetzt also hier noch mal zu diesem Beispiel,
wo ich also hier dieses arrethmetische Schieben nach rechts habe.
Und dann also im Prinzip dann also hier das Vorzeichen letztendlich verdoppelt wird.
Warum diese Zahl hier jetzt also auf einmal so klein geworden ist,
obwohl er eigentlich hier mit vielen Einsen, die ja irgendwie größer sein müsste.
Und da muss jetzt immer sagen,
das ist immer so ein bisschen das Gemeine eigentlich, bei dem,
was jetzt irgendwie die ganze Woche, beziehungsweise davor gelaufen ist.
Also wir reden hier immer von einer Zweier-Kompliment-Darstellung. Und wir,
ich genauso, neigen immer dazu zu sagen, okay,
eine Zahl, die vorne viele Einsen hat, ist eine große Zahl.
Bei den negativen Zahlen kann man,
oder muss man sich das quasi immer so vorstellen,
da zählen nicht die Einsen, da zählen die Nullen.
Also man kann sich das immer so ein bisschen veranschaulichen, wie gesagt,
also das ist jetzt hier natürlich immer nur so ein sehr,
sehr Das ist, ich gehe das und mache das mal anders.
Also man kann sich das immer so ein bisschen veranschaulichen,
also auch wenn das jetzt hier natürlich ein bisschen Blut ist,
weil das jetzt hier wieder nur vier Bits sind, mit diesem komischen Zahnkreis.
Also wie gesagt,
wir reden hier von zwei Komplimenten nicht und da ist es eben genauso,
also die minus eins,
also die betragsmäßig kleinste,
negative Zahl besteht eben hier nur aus Einsen und die entsprechend größeren Zahlen
haben dann eben bis dann eben zur größten Darstellbaren negativen Zahl der minus 8 dann eben hier eine Eins und dann eben lauter Nullen.
Deswegen ist immer dieses Intuitive,
also da sind lauter Eins und das muss eine große Zahl sein,
also bei so einer Zwei-Kompliment-Darstellung eigentlich falsch.
Aber ich glaube, das erklärt dann also schon.
Und segnet dahinter Zahlen von außen
mal als zwei Wochen
Ja, also die Frage war jetzt also,
ob C dann diese Zahlen auch immer automatisch als Zweier-Kompliment interpretiert.
Also auch da muss man eben sagen, also das ist eben dadurch,
dass das in C alles so ein bisschen unsauber ist.
Letztendlich ist das davon abhängig, wie die Zahl ursprünglich irgendwie mal definiert worden ist.
Also sprich, welches Objekt das ist, welcher Typ. Das,
wo es in C dann aber eben diese Probleme letztendlich gibt,
das war das, was Denke ich mal.
Also es wird ja nicht hier irgendwo auch noch folgen. Sind dann eben hier solche Sachen,
wo ich dann also irgendwie signed und unsigned,
also irgendwie miteinander vermische und dann also auf einmal in der Auswertung,
also irgendwelche Sachen passieren, wo ich dann sage,
also eigentlich ist das hier sowas wie ein Unsigned,
also wenn ich jetzt diesen Literal oder diese Konstante mit dem U dahinter schreibe,
da vergleiche ich jetzt mit dem Sein nicht und dann müsste
er eigentlich gelten,
also minus eins ist kleiner als null
Das, was die Sprache dort aber letztendlich falsch macht,
ist, dass eben bei solchen Ausdrücken,
wenn die gemischt verwendet werden,
die Auswertung als Ansein passiert und eine minus eins jetzt nicht mehr als Science,
sondern als Unside ist dann auf einmal wieder die größte,
nämlich also der String aus lauter Einsen,
die größte darstellbare Zahl und dann ist das aus der
minus eins dann,
also beispielsweise dann bei 16 Bittern
eben eine 65.000 geworden
Also das ist das, wo man dann eben auch gerne
in der Programmierung dann also irgendwelche komischen Fehler einbaut und sich wundert,
warum da also irgendwelche Schleifen nicht so richtig iterieren oder irgendwas ist.
Also da muss man so ein bisschen aufpassen. Wie gesagt,
in Java ist das jetzt nicht so kritisch, weil,
wie gesagt, da tauchen solche Sachen jetzt,
also nicht so auf, aber,
also da ist nur nochmal zu der,
zu diesen Effekten mit der Zahlendarstellung und wenn man damit jetzt eben arbeitet,
was man da dann eben also auch so auf Bit-Ebene
machen kann
So, jetzt war ich hier bei den Ski-Operationen. Gut,
wie gesagt, im Prinzip kann man dann eben sagen,
also mit diesen adathmetischen Schieben,
man kann damit Multiplikationen um zwei Hoch-N beziehungsweise die Vision durch
zwei Hoch-N
quasi dann annähern
Wofür man das ganz gerne nutzt? Ich denke mal,
das ist jetzt so noch mit etwas,
oder würdest du noch mit zu den letzten Sachen, also ich denke mir,
ich werde dieses Kapitel hier nochmal schnell fertig machen, ist,
dass man diese Bit-Schiebereien, beziehungsweise Operationen, dann eigentlich missbraucht,
um teilweise Programmabarbeitungen zu beschleunigen, indem man also beispielsweise sagt,
gut, also wenn ich jetzt das vergleiche,
vom Zeitaufwand, also auf der CPU,
was kostet mich also eine Multiplikation von zwei Zahlen?
Was kostet mich eine Addition oder eine Schieberoperation? Nicht so was
wie Addition oder Schieber-Operation kriegt man eben in der Regel in einem Tag 10,
also Addition meistens schiebe Operationen eigentlich auch. Gutes Sein,
das sind also irgendwelche Barrelshifts, da mit sehr,
sehr, sehr vielen sehr unterschiedlichen Bitbreiten,
aber auch da sind das also wirklich nur ganz wenige Takte bei einer Multiplikation
ist das eben einfach vom Hardwareaufwand schon deutlich aufwendiger und kostet eben einfach mehr Zeit,
was dann dazu führt,
dass in der Regel die CPUs dann eben das so berechnen,
dass man sagt, das dauert dann eben so und so viele Takte.
Wenn man andererseits so was wie Konstanten in seinem Programm mit drin hat,
dann kann man also folgenden Tricks einsetzen,
den also auch relativ,
oder der auch relativ häufig von den Compilern gemacht eingesetzt wird,
dass man im Prinzip diese Konstanten letztendlich so umsetzt oder so umbaut,
dass man also statt Multiplikationen dann also im Prinzip
so was wie Schieben und Additionen
machen kann
Triviales Beispiel, neunmal X,
kann man eben ersetzen als 8 plus einmal X,
8 mal X werden schieben um drei,
drei wird nach links, ist entsprechend dieser Aussage,
welcher sich um drei wird schieben, also mal zwei Uhr,
drei, also mal acht, und Addition von X,
und damit habe ich also quasi aus dieser Multiplikation einmal schieben Addition gemacht,
was dann eben in der Regel deutlich schneller geht.
Das Gute dabei ist,
das sind Sachen, die sind quasi umsonst, sofern,
also jemand, der sich ein bisschen damit auskennt,
also sprich um diese Zahlenkoudierung weiß, Compilerbau gemacht hat.
Nicht, und das machen die Tools eigentlich automatisch,
das heißt, man muss sich nicht als Programmierer darum kümmern,
wie kann ich solche Ausdrücke jetzt selber von Hand zurechtbauen.
Kann man auch machen, würde ich aus eigener Erfahrung nicht empfehlen,
weil man baut da in der Regel nur irgendwelche Fehler ein
Da sind inzwischen die Compiler so gut, dass sie das also machen,
beziehungsweise vielleicht auf der anderen Seite werden sie ja dann
auch irgendwann später mal im Bereich Compiler-Bau was machen.
Ich weiß auch, auch dafür werden Informatiker gebraucht.
Und auch da kann man dann eben genau solche Optimierungen ihm
letztendlich dann einbauen. Gut, damit, wie gesagt,
hier nur noch mal, wofür man also solche Skibauerationen bauen kann,
werde ich ja so jetzt für heute schließen.
Und dann eben solche anderen Beispiele,
beziehungsweise wofür man eben diese Bittweisen-Operation,
gerade so bei Maskierungen immer noch braucht,
dann also quasi am Freitag
dann eben praktisch abschließen