So, bevor ich jetzt mit den Vorlesungen anfange, noch kurz zwei Informationen in eigener Sache.
Zum einen gab es wohl in Stino irgendwelche falschen Eintragungen hinsichtlich der Praktikumstermine.
Also dass Rechnerstrukturenpraktikum geht erst übernächste Woche los. Das heißt also,
das, was bei uns auf der Webseite ist, beziehungsweise das,
was man an diesem Stundenplan dann da auch immer irgendwie findet,
Nicht, also das heißt, die ersten Kurse,
Montag, 27.11, da haben wir es 18.12.,
also sprich dann eben genau bis zur Woche vor Weihnachten und dann eben hier dieser Januar-Blog und drei Termine,
die dann letztendlich in der vorlesungsfreien Zeit stattfinden.
Gut, ich muss zugeben,
also ich habe das jetzt also auch nicht weiter kontrolliert,
beziehungsweise das Praktikum sehe ich ins Diener auch gar nicht,
aber also das nochmal als Hinweis war also heute wohl
einige Studenten dann dort vorverschlossene Tür standen,
ist natürlich dann ein bisschen doof
Ja, wo wir dann bei genau diesem Thema Stine sind.
Nächste Sache, wenn ich das also jetzt hier mal versuche
irgendwie zu starren. Dann sieht man, da kriegt man
so eine schicke Meldung, Service on a vailable.
Betrifft in diesem Fall jetzt die Vorlesungsfolien und die Übungsaufgaben.
Nein, nein, nein, nein, nein, die wird nicht geschenkt.
Insofern, als dass ich die jetzt also nicht Bastine verlinken konnte.
Also heute Morgen, als ich es versucht habe,
da war Wartung und da hieß es ab 14 Uhr, läuft wieder alles.
Inzwischen funktioniert die Seite schon mal gar nicht. Was ich dadurch erklärt,
dass das regionale Rechenzentrum zur Zeitprobleme Mactive Flaractory hat und da darüber quasi das gesamte Login läuft,
kommt also auch quasi der Steener-Server nicht mehr an seine eigene Datenbank ran,
weil der sich natürlich auch mit irgendeinem Benutzer-Account quasi authentisieren muss.
Deswegen nur noch mal kurz der Hinweis,
also ich habe das Ganze und letztendlich liegen die Seiten ja immer bei uns auf dem Server oder die Unterlagen,
ich habe das Ganze also dann eben auch noch mal da,
wäre es also nicht vielleicht schon mal irgendwie gemacht hat,
Startseite, Informatik, dann findet man hier im Prinzip
Bei Einrichtungen dann jeweils die Arbeitsbereiche, unter anderem dann eben auch Terms.
Und hier findet sich dann eben oder Lectures, aktuelles Semester,
Rechnerstrukturen, wo dann eben unter anderem diese Information hier also auch noch zu finden sind,
wo dann hier unter Unterlagen die Vorlesungsfolien alle liegen,
beziehungsweise das weiß ich noch von irgendwelchen Beispielprogrammen oder sowas,
also auch mit habe.
Also bis einschließlich Kapitel 7 sind die jetzt also auch über Stine zugreifbar,
aber im Prinzip diese letzten beiden Links,
was also jetzt diese Woche betrifft, noch nicht.
Ich werde das also heute Abend nochmal versuchen, aber so. Und die andere Sache,
hier finden sich dann also auch die aktuellen Übungsaufgaben,
also sprich das Aufgabenblatt 5, was es dann also seit heute offiziell letztendlich gibt.
Gut, ja, damit kommen wir jetzt eigentlich wieder zu dem ganz normalen Fortlegungsstoff.
Also ich hatte ja im Prinzip aufgehört, letzte Woche mit dem Thema,
beziehungsweise mit der Erklärung dieser ganzen Zeichensatzkodierung und dann eben gesagt,
na gut, also ursprünglich, solange an seinem lokalen Sprachraum ist,
kam man also im Prinzip mit Asky,
beziehungsweise mit diesen ISO 8 Nation 59 Codierungen immer ganz gut aus.
Spätestens, wenn man irgendwie so multilinguale Dokumente verfassen möchte,
beziehungsweise im Zeitalter der Vernetzung, das wir nun haben,
ist das also auch nicht mehr so ganz zeitgemäß.
Deswegen gibt es dann eben im Prinzip diesen Unicode,
wo dann also quasi sämtliche Zeichensätze von allen möglichen Sprachen letztendlich standardisiert sind,
wo man sich dann eben diese Tabellen dann noch ansehen kann,
beziehungsweise wo man dann also auch über irgendwelche Webseiten,
das hatte ich hier vorher mal gezeigt, sich ansehen kann,
welche Fonds es da gibt, was da teilweise gemacht wird.
Oder es gibt eben auch so,
nicht weil das ist im Prinzip ganz normal bei den Java-Samples mit dabei,
die also quasi dann entsprechend, also softwarere Rechnern installiert sind,
wenn man sich da jetzt die komplette Entwicklungsumgebung installiert hat,
findet sich dann also irgendwo in den Tiefen der Dateibäume auch dieses von 2D-Testpunkt Java und dann kann man dann eben auch mal für seine eigene Rechnerinstallation gucken,
also welche Fonds sind da wie,
wo installiert.
Gut, jetzt kommen wir natürlich zur Frage, wie wird
jetzt also diese Unicode-Kodierung letztendlich auf dem Rechner irgendwie dargestellt?
Da kann man sagen, also ursprünglich war es eben mal so,
dass man also anfing mit 16 Bit für jedes Zeichen.
Damit kommt man also bis zu 35.536 Zeichen.
Inzwischen gibt es also auch da schon deutlich mehr.
Deswegen wurden es auch schon relativ früh in dieser Unicode-Standardisierung dann
eben entsprechend mehrere Zeichen oder mehrere von diesen Unicord-Plans definiert,
wo man dann eben entsprechend jetzt noch mehr Zeichensätze mit hat.
Ursprünglich war das ja quasi eben zwei Byte, die dann
für die Kodierung benutzt wurden, nämlich genau diese 16-Bit.
Das gibt es genauso auch immer noch in der Sprache Java,
also der Datentyp-Character ist dort genau diese Zwei-Wahrheit eben entsprechend groß. Und wie gesagt,
von dem Unicord her, also sprich das, was dort definiert wird,
wenn man jetzt also quasi größere Also letztendlich sind diese Zeichensatztabellen ja dort irgendwo hinterlegt,
wenn man jetzt größere Indizes hat,
die dann eben mehr als 16 Bett brauchen,
würde das dann eben dazu führen,
dass man dann eben entsprechend beispielsweise mit 32 Bit oder eben mit,
oder mehr als 16, eben bis zu 32 Bit seine Zeichen kodiert.
So, das hat jetzt natürlich den Nachteil,
dass wenn ich jetzt also meine Daten oder meine Textdateien von A nach B auch übertragen möchte,
dass ich da so erstmal, je nachdem in welche Textkodierung ich wähle,
auch relativ viel an Daten erzeuge.
Weil wenn ich jetzt sage, okay, also ich kann auf Umlaute verzichten,
dann komme ich also im Prinzip mit Asky, umlauter,
hätte ich dann also auch noch, wenn ich einen ISO 8859-Zeitensatz nehme,
eigentlich aus und kann ein Buchstaben in einem Byte an Daten quasi übertragen.
Nicht, wenn ich das also hier nach diesem Unicode-Standard mache,
dann ist quasi die Textdatei, also schon mal doppelt so groß,
war ich da nämlich 16 Bit benötige.
Und wenn ich jetzt eben solche multilingualen Dokumente habe oder so und
das definiere und ich dann also entsprechend also Unicode-Standards habe,
wo ich dann eben oder Codierungen habe,
wo ich dann eben entsprechend noch mehr Bit benötige,
Hand man dann eben entsprechend große Dateien.
So, dann möchte man natürlich nicht haben.
Demzufolge gibt es da also noch so ein paar andere Mechanismen,
wie man das also vielleicht ein bisschen schlauer oder effizienter hinkriegt.
Grundidee dabei ist eben auch zu sagen, das,
was er eigentlich häufig benutzt wird. Nämlich also sprich,
die der Standardzeichensatz, das, was also ganz früher mal
quasi mit diesem Masky-Zeichensatz gestartet ist, den kodiere ich in einem Byte.
Wenn ich mehr Zeichen brauche, habe ich zwei Byte,
noch mehr Dreibyte und so weiter und so fort.
Und das ist das, was inzwischen eigentlich auf ist der Main
quasi allen Rechnern, beziehungsweise Betriebssystemen, zumindest das,
was wir hier benutzen, auch immer so verfügbar ist.
Das ist dann eben Kodierung nach UTF 16, beziehungsweise nach UTF 8.
Das werde ich jetzt hier gleich nochmal kurz vorstellen.
UTF 8 ist letztendlich nichts anderes, als dass man sagt,
ich nehme jetzt hier den entsprechenden Code aus dieser Unico-Tabelle.
Das können also hier quasi diese ganz normalen Buchstaben sein
Nicht, wo man sieht, okay,
da brauche ich jetzt wirklich von diesen zwei Byte,
also auch nur irgendwie das hintere Byte, um mein Zeichen zu kodieren.
Nicht, wenn ich jetzt also hier irgendwelche anderen Sonderzeichen habe,
also Eurozeichen, dann bräuchte ich jetzt eben hier schon komplett diese zwei Byte.
Und wenn ich dann eben irgendwelche Zeichen habe,
die jetzt noch seltener vorkommen, also eben sowas wie ein Violin-Schlüssel,
dann hätte ich das in Unicode dann eben auch in einer Kodierung,
die dann also schon größer als zwei Byte von der Länge her ist.
So, und um jetzt also aus diesem Unicode OTF8 zu machen,
wird das also quasi an folgendermaßen umgeschlüsselt, dass man sagt,
Ich benutze jetzt hiervon auch wirklich nur die Bits,
die dann also wirklich jetzt für die Informationen des Zeichens benutzt werden.
Also sprich jetzt, dass ich hier bei den normalen Buchstaben,
würde ich dann eben quasi jetzt hier den Aski-Zeichensatz ausblenden,
also sprich die unteren sieben Bitten nehmen und sage,
okay, das ist jetzt also hier genau in Codierung UTF 8.
Wenn ich jetzt für andere Zeichen längere Codierungen brauche,
dann mache ich eben Codierung mit Variablenlängen,
also sprich mit zwei Byte
Mit drei Arbeit oder mit vier Wald, je nachdem wie viele Bits ich,
also jetzt quasi hier in meiner Unicorde-Kodierung benutzen muss.
Nicht. Das heißt also, mit dieser Variablenlänge erreiche ich,
dass eben die Zeichen, die häufig benutzt werden,
auch wieder eine kurze Kodierung haben, vergleichsweise seltene, haben eine längere Kodierung.
Eine Frage? Wo man den Unterschied,
ob jetzt das Zeichen in die Dresden so weit weitergeht,
genau, was ein neues Zeichen ist.
Genau, das war die entscheidende Frage, nämlich,
wo mache ich den Unterschied oder woher kann ich entscheiden,
wenn ich jetzt hier irgendwie so ein Bittmuster habe,
ist das ein Einbaid oder Zweibaid oder Dreibad, Codierung.
Und das läuft dann nämlich im Prinzip nach folgendem Schema ab,
was jetzt also hier ist,
beziehungsweise was also eben auf dieser Folie diese fettgedruckten Zahlen waren.
Da macht man also folgenden Trick, dass man sagt,
okay, wenn ein Wort mit einer Null anfängt,
dann ist das quasi eine Einbadkodierung.
Die Null gehört nicht zu dem Code, aber die sieben Bit dahinter,
also quasi diese sieben Not-Spit, die kann ich eben benutzen.
Das heißt also, diese Einbaidkodierung nach UTF8 dann letztendlich 128
mögliche Zeichen und entspricht eigentlich eins zu eins dann dem,
was man also im Asky-Code drin hat.
Nämlich genau diese sieben Nuts-Bits und vorne dann eben nur diese führende Null. So,
wenn ich jetzt Codierungen habe, die jetzt über mehrere Wahrheit gehen,
dann wird die Anzahl der Wahrheit quasi dadurch kodiert,
dass ich hier vorne eine Menge von,
also jetzt quasi meinen Worten mit einer Eins anfange und
die Anzahl der Einsen gibt dann eben an,
wie viele von den Worten genutzt werden
Das heißt, mit diesem Prefix 1-1-0,
dann habe ich 5 Nutzbits und die 2-1en sagen eben,
es gibt noch ein zweites Bite, das ist dann auch festgelegt,
das beginnt dann immer mit 1-0,
also diese Folge Bites fangen immer mit 1-0 an und dann kann ich dort noch sechs Nutzbits unterbringen.
Das heißt, bei diesen UTF-8-Kodierungen, die zwei Bite lang sind,
habe ich sechs plus 5 Bit,
die dann quasi meinem Zeichen entsprechen oder mein Zeichen darstellen können,
nicht damit kriegt man 1.920 Zeichen, beziehungsweise 1.920 Zeichen werden benutzt,
also man kriegt mehr hin, das stimmt ja so nicht.
So, solche Dreibyte-Kodierungen fangen dann eben logischerweise mit drei Einsen an,
dann kommt die Null, die trennt dann nämlich quasi ab,
ab jetzt kommen nur noch Nutzbits,
nicht um jetzt eben zu unterscheiden,
ab wann die Nutzbits losgehen,
wird es eben immer diese Null benötigt und dann kommen eben in diesem Fall jetzt also zwei von denen hinterher,
beziehungsweise bei diesen Vierbyte-Kodierungen sieht das Ganze so aus.
So, das heißt, damit kriegt man das dann also
letztendlich hin, also reichen viele Zeichen zu kodieren.
Wie gesagt, zurzeit werden davon also auch noch nicht alle benutzt.
Also man ist jetzt in so einem dem,
was man dann also hier mit diesen Vielbalt-Kodierungen machen kann.
Im Prinzip kann ich hier natürlich jetzt also mit entsprechend noch mehr Einsen sagen,
es soll dann eben immer noch jeweils deutlich mehr von diesen Folgegruppen geben,
eben bis zu sechs Stück.
Ich hätte dann dem zufolge sechs mal sechs Notswits und okay,
hier würde dann eben letztendlich dann nichts mehr stehen.
Aber damit kann man im Prinzip also jetzt erstmal alles,
was also ein Unicorn möglich ist,
Gut, also das zu dieser OTF8-Kodierung dazu gibt es jetzt
aktuell auch gerade eine Übungsaufgabe, wo das nochmal vorkommt.
Ansonsten ist es in den Übungsaufgaben aber eigentlich immer nur Stoff,
der dann also schon letzte Woche komplett stattgefunden hat.
Gut, dann auch nur nochmal eine Information,
weil das also auch immer irgendwie was Interessantes ist,
wo wir sagen, ja gut,
das nehmen wir immer alles so als Gott gegeben hin.
Wenn wir also hier in unserem Rechner sitzen und arbeiten,
andererseits fände ich jetzt eben wirklich Rechner miteinander sich unterhalten lassen und ich habe irgendwelchen Datenaustausch,
dann spielen eben diese ganzen sogenannten Lokalisierung oder Spracheeinstellungen dann eben noch eine Rolle.
Unter diesem Begriff Lokale sind dann also im Prinzip Sachen immer zusammengefasst,
wo es also darum geht,
wie jetzt in unterschiedlichen Sprachen im Sprachstandard zum Beispiel Zahlen oder Zeichen geschrieben werden,
wie man mit Zeit- und Datumsformaten umgeht und sowas alles.
Also werden Sie kennen,
wenn man jetzt also entweder bei Windows das also irgendwie entsprechend einstellt,
Lokalisierung, also die Formate oder eben entsprechend beim Linux-Rechner
hat man
das alles
Wo man dann eben sagen kann, ich schalte damit eben um,
wenn ich jetzt also quasi Rechneruhr sagt, aktuelles Datum ist,
also irgendwie jetzt heute, was haben wir jetzt,
den 15., 15., 11., 2017 nicht,
dann würde ich, dass das im Deutschen,
also quasi in dieser Reihenfolge schreiben,
wenn ich das im englischsprachigen Raum mache,
dann würde ich also die 11 vor die 15 schreiben und dann eben auch nicht mitpunkten,
sondern mit schrägstrichen Tränen.
Nicht also einfach solche Sachen wie solche Informationen letztendlich dargestellt wird und kodiert wird.
Nicht im Englischen hätte ich dann eben auch die Zeitangaben dann
mit AEM und PM und würde dann eben nicht über 12 Uhr hinaus zählen.
Nicht das sind alles solche Sachen, die sowas betrifft.
In der Regel hat man damit natürlich nicht so viel zu tun.
Es gibt aber teilweise wirklich so interessante Effekte. Ich kann
mich also auch nur aus eigener Leid voller Erfahrung sagen.
Also wir hatten also mal das schöne Beispiel,
dass wir also für so Software, die wir haben,
ist es häufig so, dass also quasi ein Rechner zentral,
also wenn die jetzt miteinander vernetzt sind,
also Lizenzserver darstellt
War also im Rechenzentrum also irgendwie eine zentrale Maschine.
Da liefen jetzt also alle möglichen Serverdienste. Und der Arbeitsplatz rechnet, die Workstation,
was auch immer, wenn ich diese Software benutzen wollte,
fragt dann quasi bei diesem Lizenz-Server an, wie viele Lizenzen sind dort freigegeben,
darf der die auschecken, was darf der davon benutzen.
Irgendwann ging das nicht mehr. Da fängt man also wirklich an,
also alles mögliche zu debuggen, also irgendwas in der Installation schiefgelaufen und dieses und jenes.
In dem Fall war also Quintessenz, dass bei den Client-Trechnern,
das waren also jetzt irgendwie Linux-Maschinen,
die sagen Ansatzkodierung und die Lokale dann mal irgendwann mal umgestellt wurde auf eine andere Kodierung.
Der Lizenzserver lief noch mit einem Solaris-Betriebssystem,
hatte dann als Lokalisierung im Prinzip die englischen Datumsformate in diesem Fall eingeschaltet.
Und die Anfrage von dem Client an den Server,
ich möchte die und die Lizenz auschecken, ist deswegen dann schief gelaufen,
weil eben quasi beim Umschalten zwischen Monat und Tag letztendlich,
also dort, also als Datumsformat ein String angekommen ist,
wo er gesagt hat,
ist ungültig
Lizenz gibt es nicht, nicht, und irgendwo auf Clients Seite,
da hat man also alles Mögliche probiert und gemacht.
Also das war dann wirklich so, also mit das Ärgerlichste,
was immer passiert ist, was auf einigen Rechnern ging das,
auf anderen ging das nicht, nicht je nachdem,
welche Betriebssystemversion die dann hatten. Nicht,
also das ist das im Prinzip über diese Lokale mitgeregelt,
teilweise kann man damit auch dann sowas wie Benutzeroberflächen umschalten,
ich sag mal, bei Windows geht das jetzt also ab der Windows 10-Version,
dass man also einen Rechner sowohl deutsch als auch Englisch machen kann,
wenn ich also bei unixartigen Betriebssystemen geht das schon ein bisschen länger.
Und da kann ich eben wirklich sagen,
ich habe einen Rechner, habe da so eine Installation.
Und wenn sich also irgendwie hier der Gastprofessor irgendwo aus,
was weiß ich, woher USA einloggt,
dann kann der eben quasi den Rechner haben,
wo dann also auch sämtliche Menüs dann auf Englisch sind,
wenn ich mich einlogge, habe ich dann dementsprechend die deutschen Menüs.
Also all das kann man im Prinzip über diese gesamte Lokalisierung dann umschalten.
Also hier bei den Linux-Rechnern, also hier sieht dann das immer so,
wenn man da also Lokale eingibt, dann sieht man,
was da alles im Prinzip abgefragt wird.
Und hier gibt es dann im Prinzip also dann sowas wie lang.
Also man sieht, also ich bin jetzt hier deutschsprachig,
die Zeichensatzkodierung wird, also irgendwie sowas wie ODF 8 sein,
sollte irgendwas nicht in Deutsch verfügbar sein,
wird es also anschließend in Englisch dargestellt und so weiter und so fort.
Und wenn ich also anfange, hier teilweise diese Sachen zu ändern,
hätte ich dann beispielsweise jetzt also hier in meinem Terminal dann hier oben,
also auf einmal dann englischsprachige Menüs und so weiter.
Also das kann man damit relativ komfortabel inzwischen alles,
dynamisch hin und her schalten
Gut, teilweise, um sowas zu machen, gibt es das dann also auch entsprechend um Programmiersprachenunterstützung,
dass man dort sowas abfragen kann. Und was also auch relativ smart ist,
gerade dann eben auch für die Programmierung, ist etwas,
was dann eben immer oft unter diesem Kürzel I18N läuft,
steht für Internationalisation, ein I18 Buchstaben, anschließend ein N,
nein, also dahinter stehen dann im Prinzip Bibliotheken,
wo ich dann eben sagen kann,
in meinem Programm sage ich dem Programm beispielsweise jetzt,
es soll irgendwie einen Button gezeichnet werden und da soll meinetwegen jetzt mit irgendwie öffnen,
beschriftet werden.
Und dahinter ist dann nachher der Dialog, wo ich jetzt also irgendwie eine Datei,
die ich öffnen möchte, irgendwie auswähle. So,
und wenn ich das über diese Bibliotheken mache,
dann steht also letztendlich dieses Öffnen, nicht in den Programmcode,
sondern kommt also aus so einer Bibliothek und ich kann eben genau das gleiche Programm dann eben auf einem Rechner laufen lassen,
der dann eben diese Internationalisierung dann entsprechend passend eingerichtet hat und wenn ich dann eben diese Lokale,
also auf Englisch umgeschaltet habe,
habe ich dann eben auch entsprechend die englische Beschriftung dazu.
Und ich muss mich als Programmierer selber nicht darum kümmern.
Das war so relativ komfortable Sache auch, wo man sowas
dann also eben auch rein praktisch mitbenutzt. Gut,
andere Sache, was ich also auch schon kurz gezeigt habe,
du hast dich also auch so ein bisschen historischer gegeben hat,
also unterschiedliche Codierungen für Zahlen nennens,
also jetzt in ganz normalen Textdateien zwischen verschiedenen Betriebssystemen.
Nicht typischerweise kann man sowas dann eben auch mit irgendwelchen Programmen
von der einen Codierung in irgendeine andere Codierung dann eben irgendwie umsetzen,
beziehungsweise gut die wie die Programme heißen.
Nur, dass man weiß, man könnte es irgendwo mal nachschlagen.
Also das ist etwas oder das Komfortables ist in dieses E-Conf.
Nicht, wo ich dann eben sagen kann,
von irgendeiner beliebigen Kodierung in irgendeine andere Kodierung.
Und damit kann ich dann eben sagen,
wenn ich eine Datei habe,
die in Zeichensatzkodierung ISO 8,
1859-1 gemacht ist und ich möchte daraus jetzt eine UTF-8-Datei generiert haben,
kann man das eben hier mit so einer
etwas länglichen Kommandozeile
beispielsweise machen
Gut, was jetzt als letzter Punkt dann noch dazu kommt,
ist dann noch die sogenannte Base 64-Kodierung.
Da geht es jetzt also speziell um den Datenaustausch zwischen Rechnern,
weil das, was man jetzt hier schon ein bisschen gesehen hat,
also je nachdem, auf welche Rechner Hardware oder Betriebssystemvariante ich arbeite,
habe ich also bei Textdateien, also am Ende schon mal
irgendwie unterschiedliche Zahlen enden. Ich habe dann irgendwo meine Zeichensatzkodierung und jetzt habe ich also beispielsweise das Problem,
dass ich also jetzt wirklich Daten von einem rechne in irgendeinen anderen Rechner übertragen will,
wo also vielleicht also auch noch teilweise auch noch andere Konventionen
ein bisschen anders sind und um dort also quasi ein eindeutiges
Verfahren zu haben,
wie ich jetzt also
diese Daten übertragen kann
Hat sich da, also die sogenannte Base 64-Kodierung eigentlich etabliert.
Da geht es nämlich auch darum, dass also das,
was wir benutzen, wenn wir jetzt im Internet Mails empfangen bzw. versenden,
also sprich dieses Mail-Protokoll, SMTP, was dahinter steht,
muss man eben sagen, das ist alles schon ein bisschen älter.
Da hatte man jetzt also noch nicht irgendwie an unterschiedliche Zeichensatzkodierungen und vielleicht dann also irgendwie Unicode,
wo ich also irgendwie einen Violinschlüssel als Zeichen irgendwo von A nach B bringen muss,
gedacht, da wird eben grundsätzlich erstmal alles in 7 BitAski kodiert.
So, jetzt habe ich aber meine Dateien,
die ich von Meine Mail, die ich von A nach B übertragen möchte.
Ich habe in der Mail jetzt aber nicht nur Takes,
sondern heutzutage habe ich in der Mail, also irgendwelche PDFs,
ich habe irgendwelche Bilder, ich kann bösartig natürlich,
also irgendwelche ausführbaren Programme verschicken, die jemand anders,
also unvorsichtig anklegt und sich damit also irgendwie den Rechner schrottet oder was weiß ich.
Das heißt, eigentlich habe ich also wirklich beliebige Daten,
die ich ja so irgendwie jetzt versenden möchte.
Das basiert aber eben noch in der Historie,
also irgendwie auf den 70er Jahren, also irgendwie in so einem 7-Bet-Aski-Protokoll,
denn die Frage ist eben, wie kriegt man das hin?
So, und dafür gibt es eben Diese Base 64-Kodierungen,
die also letztendlich nichts anderes macht als eine Umkodierung von beliebigen Daten in irgendwas,
was sich dann also mit so einem Aski-Zeichensatz quasi von A nach B transportieren kann.
Dazu wird folgendes Verfahren gemacht. Ich habe also hier einen
quasi Quelldratenstrom und von dem nehme ich drei Byte. Das können,
kann jetzt irgendeine Zeichensatzkodierung sein, also egal welche,
das können aber auch irgendwelche Nutzdaten sein von irgendeinem Foto,
was ich also jetzt als JPEG, also irgendwo als Mail an Hannover schicke.
So, davon nehme ich drei Byte und die werden quasi
umgesetzt in vier Zeichen beziehungsweise erst mal als vier Zahn interpretiert,
wo ich dann eben letztendlich sage, okay,
also dreimal acht entspricht eben sechsmal vier Bit und einmal
habe ich eben diese Codierung in die Richtung.
Einmal habe ich die Codierung in die Richtung und wenn ich jetzt also quasi bei der Encoder-Seite bin,
nehme ich eben diese drei Byte, sage,
dass wir ihn jetzt vier Zeichen die dann eben jeweils sechs Bit breit sind.
Mit diesen sechs Bild, wenn ich die jetzt als Zahlen interpretiere,
kriege ich quasi Zahlen von null bis 63 hin.
Nicht damit benutzt man dann im Prinzip von den 128 möglichen Asky-Symbolen, genau 64 Stück.
Und da passiert dann eben so eine Zuordnung über so eine feste Tabelle.
Wenn ich also quasi jetzt hier irgendeinen Bitstring habe,
dann eben jetzt hier diese sechs Bit rausschneide, das interpretiere ich jetzt als Zahl, meinetwegen 25.
Dann würde ich also quasi zählen in dieser Tabelle nachgucken,
wie wird diese Zahl 25 in Asky oder welchem Asky-Zeichen wird die zugeordnet?
In diesem Fall im großen Z. Und dieses große Set wird dann quasi in Asky dann nach dem SMTV-Protokoll übertragen. So,
und hier ist jetzt einfach eine willkürliche Zuordnung,
das heißt, die ersten 25 sind die Großbuchstaben,
die nächsten 25 sind die kleinen Buchstaben,
dann habe ich noch die zehn Ziffern,
nicht dann für die beiden noch fehlenden Stellen,
62 und 63 ist ja einfach willkürlich festgelegt, plus Zeichen,
beziehungsweise slash und dann gibt es eben noch ein Füllzeichen,
um dafür zu sorgen,
dass wir jetzt also in eine Datei hier irgendwo zu Ende ist,
ich aber jetzt keine drei Bike mehr habe,
dass dann also quasi an diesen entsprechenden Stellen dann eben jetzt noch irgendwie solche Füllzeichen,
also sprich der Gleichheitszeichen gesetzt werden.
Und es gibt dann noch optional sowas wie ein Zahlenumbruch,
wo man dann einfach in dieser Textdatei, die er dann übertragen wird,
das Ganze, dann also auch noch so ein bisschen blockweise formatieren kann.
Gut, hier ein praktisches Beispiel, also wenn ich jetzt als Text nehme,
Groß-MAN-Man, das wäre dann also jetzt hier der entsprechende Asky-Code von dem ganzen. Man nimmt dann also hier quasi dieses die entsprechenden Zugehörigen Wittmuster,
denen würde dann eben sagen, okay,
ich nehme jetzt also hier nicht acht Bit,
sondern also hier diese sechs Bit, nicht und das,
was dann dort quasi beschrieben ist,
wäre dann also quasi die Zahl 19,
muss sie in dieser Tabelle nachgucken,
welcher Buchstabe wird dann quasi mit der 19 kodiert,
nicht in diesem Fall landet man dann beim großen Tee und
hat da dann eben eine Zuordnung von eben entweder Textzeichen oder eben beliebigen Bittmustern,
die dann also quasi nach dieser Kodierung dann in solche sieben
Bit-Werte übertragen werden
Gut, das ist also im Prinzip jetzt die Art und Weise,
wie diese Base 64-Kodierung funktioniert,
wird teilweise dann eben auch entsprechend in den Programmiersprachen unterstützt durch entsprechende Bibliotheken beziehungsweise gut rein praktisch,
sehen wir davon jetzt immer relativ wenig,
wenn wir ein Mail-Programm benutzen,
weil da ist das eben entsprechend mit eingebaut,
also sprich diese ganzen Protokolle und eben diese Umschlüsselung des Textes nicht,
aber wenn man jetzt also wirklich mal binär reingucken würde,
was ich also zum Beispiel jetzt in Form von Mail anhängen erhalte,
da hat man dann eben wirklich noch irgendwie so ein Buchstabensalat,
der dann auch in Base 64
kodiert ist
Hier auch nur so ein Buchbeispiel, also aus diesem Buch,
ja, war es auch eine Insel.
Jetzt ist ja auch nicht mehr die ganz aktuelle Version,
aber da ist das auch nochmal so ein bisschen was.
Also das ist hier nur so ein Beispiel,
wo das dann also letztendlich dann also hier auch als Space
64 N-Coder beziehungsweise Decoder dann eben aus irgendwelchen Bibliotheken benutzt wird.
Gut,
damit sind wir jetzt eigentlich bei diesem Teil Zeichen und Text
durch und kommen jetzt also nochmal wieder zu den Witz zurück und landen in diesem Fall jetzt bei der Bulschnalgebar,
beziehungsweise bei dem, was dann eigentlich noch so an logischen Operationen da danach auch noch mit drin sind.
Gut, weswegen überhaupt sowas wie so eine abstrakte Algebar,
also ein Vorteil von dem Ganzen ist eben, dass ich mit so einem,
vielleicht zur sauberen mathematischen Konstrukt relativ viel zeigen, beweisen kann,
beziehungsweise auch rechnen kann, was also beispielsweise bei der Kodierungstheorie benötigt wird,
wo man dann also bestimmt auch so Sachen,
was so teilweise auch in der Arithmetik haben,
Abgeschlossenheiten von Operationen oder so weiter,
wird da darüber dann eigentlich letztendlich auch beschrieben.
Ansonsten, was verbirgt sich jetzt hinter diesem Begriff der Argebrauer beziehungsweise der Bulschen Allgebar,
mag es vielleicht am Anfang jetzt mal ein bisschen langweilig sein,
weil ich weiß nicht,
inwieweit das also auch schon im Rahmen der Schulmathematik irgendwo schon mal aufgetaucht ist,
aber wie gesagt, ich werde das jetzt hier nur noch mal kurz wiederholen.
Gul Schage war, geht im Prinzip zurück auf George Buhl,
der 1850 im Prinzip Aussagenlogik betrieben hat. Das heißt,
ich habe jetzt also Aussagen, die können entweder wahr sein oder
falsch sein, nachher sprich True und Falls. Das,
was wir damit jetzt natürlich immer gleich verbinden,
werden wir jetzt das dann in Informatik und Bulsche Algebar und True und Falls denken,
ist natürlich dann wieder 0 und 1,
nicht und so wird das Ganze nachher natürlich
auch irgendwie dann rein praktisch umgesetzt und implementiert
Formal gesehen, passt hier dann eben Forgeles,
dass man dort eigentlich eine Allgebar definiert mit True und False,
auf der ich dann im Prinzip vier Funktionen habe.
Also einmal die Negation und Verknüpfung oder Verknüpfung und dann eben noch so was wie so ein,
beziehungsweise in diesem Fall jetzt hier erstmal,
was hier noch war, aber das nachher noch brauchen,
Exklusiv oder typische Schreibweise für die Negation ist.
Ich habe meistens immer also irgendwie einen Ausdruck und dann also
irgendwie so eine Regierung, also so ein Strich darüber.
Häufig findet man also auch noch so einen Haken für
so eine Nord
Dies mit dieser Till, der ist danach eigentlich schon wieder an Programmiersprachen angelehnt,
weil man das dort dann entsprechend häufig so schreibt. Und sagen wir mal so,
vom Mathematischen Ausdrücken, also das spricht das,
was sich dann da so häufig oder in der Regel hier auf den Folien habe,
beziehungsweise was für den Übungslaufgruppen auch,
Übungsaufgaben auftaucht,
wird und dann also quasi dann eben entsprechend hier durch diesen Operator oder exklusiv oder durch diesen Operator beschrieben,
Programmiersprachlich motiviert,
komme ich auch nachher noch kurz zu,
hat man dann eigentlich immer diese Schreibweise mit dem Kaufmanns und
dem senkrechten Strich bzw. für das Exklusiv oder dann diese Dachfunktion
Gut. Das, was dann eigentlich dann auch noch das Entscheidende war,
was dann also auch schon relativ früh,
also beziehungsweise jetzt ja noch aus der 37 passierte, dass der Herr Schenn,
der uns dann also später noch im Rahmen der Codierungstheorie weiter begegnen wird,
dann eben letztendlich festgestellt hat oder gemacht hat,
dass er im Prinzip diese Aussagenlogik, also die Butsche Algebra,
dann eben quasi mit Schaltfunktionen realisieren kann,
also sprich als binäre digitale Logik.
Und das ist eigentlich das, was wir heutzutage mit Bullshit-Argebar verbinden,
nämlich, dass man mit den Nullen und den Einzelnen dann eben
quasi mit Fords und True dann eben auch irgendwie dann seine Aussagenlogik machen kann.
Gut, die Grohnverknüpfung sind logischerweise Negierung, Nord, nicht, also Null mache ich eine Einzelne umgekehrt. Und es wird etwas zu,
wenn genau X und Y war, sind,
nur dann ist eben die Unverknüpfung war beim Oder,
genügt es, wenn eben ein einziger von den beiden eins ist,
wenn beide null ist,
dann habe ich als Ergebnis null und dieses Exklusiv-Oder entspricht dann eben quasi dem,
was eigentlich mathematischer so eine Antivalenz ist, also sprich,
wenn ich Kombination habe von 1 und 0,
ist das Ergebnis eine 1, Kombination von 0 und 1,
dann ist das Ergebnis eine 1. Wenn beide null sind oder beide eins sind, ist das Ergebnis eine null, also so sind wir diese Tabellen dann ja auch immer zu lesen.
So und alles,
was man sich jetzt als logische Operation bzw. später dann auch als sogenannte Schaltfunktion,
wird uns das dann nämlich noch begegnen, darstellen kann,
kann man dann eben quasi aus diesen Grundfunktionalitäten beziehungsweise man braucht teilweise noch weniger,
als jetzt alle geführt, gleichzeitig dann eben darstellen.
Und das heißt also, mit diesen Funktionen habe ich dann sowas für so eine vollständige Basismenge,
mit der ich dann eben quasi alle möglichen Funktionen,
die sich irgendjemand ausdenkt, quasi zusammensetzen kann.
So, wie viele mögliche Funktionen gibt es überhaupt,
beziehungsweise das ist dann hier beschrieben als Anzahl der minären Funktionen,
und da kann man jetzt erstmal sagen, na gut,
wenn ich jetzt Meine Bullshit-Variable X habe und jetzt gucke,
welche Funktionen gibt es, die jetzt mit dieser bultschen Variablen X irgendwie was machen.
Da kann man sagen, wenn ich nur eine einzige habe,
dann kann ich das auch genau letztendlich nie,
also irgendwie vier Funktionen definieren, nämlich eine,
die unabhängig von X immer eine Null liefert, eine,
die unabhängig von X immer eine 1 liefert und entweder dann als dritter eine,
die dann eben quasi den Wert von X direkt zurückliefert und dann eben eine,
die negiert,
So, Funktion von einer Variablen, trivial interessiert eigentlich nicht weiter,
wie viele Funktionen von zwei Variablen kriege ich hin.
Das ist also letztendlich auf dieser Folie hier dargestellt. Hier oben ist immer,
also es ist so zu lesen, hier oben habe ich,
also meine Kombination von X und Y. Nicht,
die können jeweils 0 und 1 sein,
demzufolge habe ich also vier mögliche Kombinationen,
was also hier durch diese Spalten dargestellt ist.
So, und in den Zeilen sind jetzt also die Funktionen, die ich haben kann.
Das heißt also, die Nullfunktion also nichts anderes,
dass sie jetzt hier für jede Kombination von X und Y als Ergebniswert eine Null liefert.
So ist das zu lesen, dass und,
was sie also gerade eben in dieser Würfelförmigen Tabelle hatte,
ist also dann, dass ich eben nur genau dann eine Eins erhalte,
wenn also X und Y beide Eins sind, in allen anderen Fällen eine Null.
Nicht hier habe ich dann zum Beispiel das oder und das Exklusiv
oder wäre dann eben beispielsweise hier und dann kann man sich dann eben noch beliebige andere Funktionen,
nein, nicht beliebiger, also noch genau,
entsprechend die hier an dargestellten anderen Funktionen ausdenken,
wenn nicht, dass wir dann also quasi das,
was an dem so an Beschreibungen spricht,
die man damit dann also aufbauen kann.
Also hier hätte man dann immer sowas wie so eine Art mathematische Notation von dem Ganzen,
dies wäre dann eben das, wie man das letztendlich jetzt, also irgendwie in einer Programmiersprache machen könnte. Gut,
Quintessenz von dem Ganzen ist, wenn ich jetzt eben frage,
wie viele Funktionen mit in Variablen gibt es,
dass man sich jetzt eben einfach überlegt, ich habe,
wenn ich in Variablen habe,
zwei hoch en mögliche Kombinationen für X und Y. Ich hatte gesagt,
hier habe ich mit zwei Variablen vier mögliche Kombinationen für X und Y. Und jetzt kann ich von diesen vier möglichen Kombinationen jetzt eben an jeder Stelle auch noch entweder,
wenn ich jetzt diese Schaltfunktion alle aufzählen würde,
eine Null oder eine Eins haben.
Demzufolge wäre dann eben die allgemeine Formel,
um jetzt zu sagen, wenn ich in Variablen habe,
gibt es zwei hoch,
zwei hochennen
Funktionen mit N-Variablen. Gut, aber kommen wir jetzt also
wieder also auf die Bulsche Argebat zurück.
Der Informatiker hat ja immer gerne so eine etwas formalisierte Darstellung,
wird ihn dann zumindest in der theoretischen Informatik dann auch immer noch begegnen.
Wenn man fragt, ja, was ist das und das?
Danach haben wir sagen, das wird beschrieben als ein End-Toople.
In diesem Fall kann man sagen,
die Bulsche Argebat ist ein Sechst-Toople,
wo ich eben im Prinzip eine Menge mit den zwei Elementen habe,
mit zwei Elementen habe,
nämlich den 0 unter 1,
beziehungsweise Äquivalent dann eben
Falls and True
Dann diesen beiden Funktionen oder,
und, und,
die jetzt quasi sowas wie eine Art Addition oder für das oder beziehungsweise eine Multiplikation für das Unterentsprechen,
dann habe ich die Negierung,
das Kompliment und dann gibt es eben noch zwei ausgewählte Elemente,
nämlich ein Null-Element der Addition und ein Einzelement der Multiplikation und damit gelten dann entsprechende mathematische Eigenschaften,
nämlich sowas wie Kommodativgesetz assoziativ gesetzt ist,
Kommotivgesetz,
nicht jemals dann hier für die einzelnen Operationen
Diese ganzen Identitätsregeln und so weiter. Wie gesagt,
das gilt hier für die Bulsche Algebra, ähnliches oder vergleichbares,
würde zum Beispiel dann eben auch gelten,
jetzt für die ganzen Zahlen, beziehungsweise der Ring der ganzen Zahlen,
das ist eben im Prinzip unter diesen beiden Operationen,
Addition und Multiplikation, dann möchte quasi das,
was hier gilt.
Da sieht man eben schon, dass da so eine
gewisse Abbildbarkeit dort im Prinzip möglich ist. Gut,
das ist also das, was jetzt also das Herz eines Mathematikers erfreut.
Man hat also im Prinzip seine entsprechenden Eigenschaften,
kann damit jetzt also bestimmte Weise führen und so weiter und so fort.
Gut, uns wird das Ganze nachher noch begegnen,
wenn es eigentlich jetzt darum geht,
also jetzt beliebige Schaltfunktionen aufzubauen und zu realisieren,
weil die kann man dann nämlich quasi immer auf diese Operation
Und, oder, also wenn ich jetzt eben sage,
diese Vollständigkeit, Algebar und, oder, und nicht letztendlich zurückführen,
nicht, und dann, wenn ich das entsprechend machen kann,
kann ich eben auch sagen, also alles,
was dort dann eben an den entsprechenden Gesetzen gilt,
ist da dann möglich.
Hier ganz unten auf der Folie ist auch noch etwas aufgetaucht,
was sich dann immer dem Morgenregeln nennt,
wird also jetzt auf der nächsten Folie also auch nochmal kurz wiederholt.
Nicht ansonsten, das wird uns dann im nächsten, übernächsten Kapitel dann begegnen,
wo dann teilweise mit der Bulschen Algebar also rumgerechnet werden soll, also auch in Übungsaufgaben.
Da empfiehlt es sich dann also immer mal so ein bisschen,
also auf diese Folie hier zu gucken und zumindest also hier diese Regeln,
also irgendwie so Absorptionen,
wo ich dann also zum Beispiel diese Variablen B irgendwie so rausschmeißen kann,
beziehungsweise eben hier solche Umformungen nach diesen den Morgenregeln,
machen sich dann immer ganz gut,
wenn ich jetzt also irgendwie Algebrage ausdrücke,
umforme oder ineinander umrechnen soll.
Gut, diese Morgenregeln ist im Prinzip Sowas, wo man sagt,
es werden von der Funktionalität her sowas wie und, und,
oder gegeneinander ausgetauscht. Zumindest in dem Fall, wenn jetzt
also noch irgendwelche Negierungen im Spiel sind. Das heißt,
wenn ich einen Ausdruck habe, wo ich jetzt sage,
nicht und dann in Klammern A oder B,
dann ist das genau das Gleiche wie nicht A und nicht B.
Das heißt also, aus diesem Oder hier wird dann hier quasi ein
Und und hier habe ich den Ausdruck am Ende negiert.
Hier habe ich jemanden am Anfang negiert. Das,
was hier so als grafische Darstellung dargestellt ist, das sind dann diese sogenannten Schalssymbole,
das wird uns dann auch noch im übernächsten Kapitel genauer begegnen.
Also von daher jetzt keine Angst, wenn Sie sagen, kenne ich noch nicht.
Wird dann also wirklich noch genauer eingeführt werden. Aber das ist dann das,
wie das Ganze dann eben auch teilweise oder geht dann letztendlich darauf zurück,
dass man für irgendwelche von diesen Ausdrücken das dann eben auch
quasi einfach stumpf eins zu eins in solche Symbole umsetzen kann.
Und diese Symbole kann man dann aber auch wieder relativ stumpf
eins zu eins in irgendwelche Hardware-Einheiten umsetzen. Das heißt,
wenn ich jetzt also eine bestimmte bulsche Funktion habe bzw. eine Funktionalität,
die ich in der Symbolschen Agebra ausdrücken kann,
dann kann ich das auch so in Hardware bauen.
Und das ist also zum Beispiel das, was ich nachher
im Rechner irgendwo als Recheneinheit habe. Wenn ich sage,
ich habe eine Ado, die kann also zwei Zahlen addieren,
wird die dann eben irgendwie nachher dann aus irgendwelchen Bausteinen aufgebaut,
die dann also irgendwie von der Funktionalität her Pulschenausdrücken entsprechen.
Dafür ist das Ganze eigentlich ganz interessant. Gut,
also die Morgenregeln austauschen von und und oder gegeneinander und einmal
eben eine Geerung des ganzen Ausdrucks und einmal eine Regierung von den Einzeltermen
gilt in einer anderen Richtung auch so,
dass ich also quasi aus diesem nicht A und B mache,
nicht A oder nicht B. So, ja, warum gilt das?
Da kann man jetzt natürlich sagen, Übungsaufgabe würde ich aber,
glaube ich, dann nicht abfragen, kann man sich aber relativ einfach überlegen,
wenn man also wirklich jetzt hier die Funktion nimmt,
sich das also wirklich mal an der Hand einer Wertetabelle aufschreibt.
Nicht bei zwei Variablen A und B, habe ich also in zwölf noch vier Kombinationen.
Das kriegt man also auch noch relativ einfach hin,
was das ist. Und dann wird man eben sehen,
wenn man das jetzt wirklich mal sich überlegt und von der Logik her.
Und da zeichnet das eben entsprechend diese Rechenregel dann auch wirklich
so eins zu eins gilt. Gut, wie gesagt,
gebraucht wird das dann bei der Also Minimierung,
also Umformung von logischen Ausdrücken und dann eben ein technischer nachher beim Entwurf von Schaltung.
Wie gesagt, in den späteren Abschnitten zu Schaltfunktionen schalten hetzen wird,
ist es noch genauer begegnen. Gut, die ist exklusiv,
oder hatte ich also auch schon ganz kurz irgendwo so angesprochen,
beziehungsweise in dieser Wertetabelle, wird oder entspricht eigentlich auch dem,
was man also häufig im Umgangssprachlichen mit dem oder verbindet.
Nämlich also ein Ausschlag, abschließendes oder, wo ich dann sage,
entweder das oder das, aber nicht beides gleichzeitig.
Das ist dann eigentlich das Exklusiv-Oder. Nicht während von der Aussagenlogik bzw. der Bulschen Algebar,
wenn ich dort ein Oder habe und ich sage das oder das nicht,
dann kann man immer noch sagen, ja,
das ist aber auch genau dann wahr,
wenn beide Einzelaussagen wahr sind.
Also sprich, wenn man nicht sich nicht entscheiden muss,
sondern einfach sagt, okay, ich nehme beides.
Das ist eigentlich der Unterschied zwischen dem, wie wir umgangssprachlich das Oder benutzen.
Da ist nämlich eigentlich Von der Funktion her,
mehr so ein Exklusiv-Oder oder eben dem,
was es also dann mit Oda und Exklusiv oder in wirklichen Unterscheidungen jetzt hier in der Bulschnagelbar gibt.
Gut, dies exklusiv oder diese Funktionalität kann man dann eben
auch umschreiben in Symbolschen-Ausdruck mit den und und oder-Funktionen nicht.
Das heißt, also wenn ich jetzt A exklusiv oder B habe,
entspricht das eben, dass ich sage,
nicht A und B oder A und Nicht B,
Und okay, was passiert dort?
Okay, jetzt würde ich also doch mal so eine Tabelle
hier irgendwie an die Tafel werfen.
Also ich habe hier A und B, habe jetzt hier meine Kombination.
Nicht und das, was jetzt hier steht,
nicht A und B, erzeugt genau in diesem Fall hier
eine Eins
Oder A und Nicht-B,
das ist erzeugt in en genau diesem Fall hier eine Eins und alles andere ist null und nicht,
und das ist dann eben entsprechend hier meine Exklusiv- oder Funktion,
wo ich dann eben sagen kann,
A exklusiv- oder B ist dann dementsprechend dieser Ausdruck A nicht und B oder A und B nicht.
Ach ja, im Prinzip das, was auf der Folie ist.
Oder man kann es auch anders schreiben, quasi als so einen Term,
wo ich das dann eben hier entsprechend anders codiert habe.
Gut, das zu dem Exklusiv-Oder. Dann wird das jetzt aber
mal wieder ein bisschen an Kalön doch ein bisschen anschaulicher. Das heißt,
jetzt verlassen wir jetzt mal wieder die Bulschalgebraut,
landen da sitzt wieder bei dem,
was wir jetzt in der Programmierung machen,
also sprich bei irgendwelchen Operationen in irgendwelchen Programmiersprachen,
in diesem Fall,
wie sieht das dort also jetzt mit den logischen Operationen in Programmiersprachen,
in diesem Fall
jetzt hier mal als Beispiel Java und C
In der, als Datentyp, um jetzt also
quasi mit der bultischen Logik zu rechnen, gibt es,
da sind Java expliziten Datentypolien mit den Werten True and Falls.
In C, wo man also mit den Datentypen,
also sagen wir mal, so ein bisschen legerer umgeht,
rechne ich eigentlich mit Integers, also mit Zahlen,
interpretiere die aber als True oder Falls.
Würde ich gleich noch ein bisschen genauer beschreiben,
was damit möglich ist. Gut, und wie gesagt,
hier für diese beiden Programmiersprachen will ich schon mal
ein bisschen was sagen zu den Vergleichsoperationen,
zur logischen Grundoperation
Und dann zu mitweisen, Operationen,
die man teilweise braucht und etwas,
was es auch immer noch begegnen wird, sogenannte Außerwertungsreihenfolgen,
wo ich dann eben sagen kann,
wie mache ich das mit der Auswertung, typischerweise,
nicht also in einigen Fällen gibt es Operatorprioritäten hier in den Programmiersprachen,
nicht,
typischerweise macht man da dann immer eine Auswertung von links nach rechts mit optionaler Klammerung,
auch dazu folgen dann eigentlich noch genaue Beispiele.
Gut, was hat man an Vergleichsoperationen zur Verfügung?
Einmal das übliche gleich und
leicht größer gleich
Größer, kleiner und kleiner gleich. Und diese Vergleichsoperationen arbeiten jetzt
eben letztendlich auf irgendwelchen Intager, beziehungsweise teilweise auch Flow-Datentypen,
und liefern dann eben einen Bulschenwert zurück.
Das heißt, es ist für gleiche Zahlen,
erhalte dann eben so einen logischen Wert. In welche Zahlen,
wenn ich jetzt also jetzt mal Floating-Point-Aren-Meeting erst nochmal außen vor lasse,
welche Zahlen, kann man damit beackern.
Also in Java gibt es sowieso nur Vorzeichen,
behaftete Zahlen, das heißt, da arbeite ich immer am Zweierkompliment
In See gibt es dann immer diese Unterscheidung mit diesen Sign- und Unsigned-Typen,
wobei, das hatte ich ja auch schon in den Magen,
Beispiel mit diesen Vergleichs-Operatoren, in See gezeigt,
da kann man also relativ schnell in irgendwelche Fallen reinlaufen,
wenn man das jetzt irgendwie gemischt benutzt,
weil dann also auf einmal aufgrund der Zahlendarstellung dann irgendwie was
schief läuft und man dann also im falschen Zahlenbereich lawy ist.
Gut, in der Sprache C, was gibt es dann neben den Vergleichsoperatoren noch?
Da gibt es zum einen eine sogenannte Jetzt wirklich logische Operationen,
nämlich Negation und, und, oder, die dann eben entweder durch ein Ausrufezeichen,
doppeltes Kaufmannsort, beziehungsweise die doppelten Striche definiert sind.
Und was man dann eben wissen muss,
sie hat ja gesagt, also in C ist es so,
dass es kein extra Datentyp für Bullschewerte gibt,
sondern da arbeite ich mit ganz normalen Zahlen,
die dann aber folgendermaßen interpretiert werden, wenn diese Zahl gleich null ist,
dann ist sie
Als Bulsha-Wert dann eben auch null bzw. Falls. Wenn diese Zahl
irgendeinen anderen Zahlenwert tat. Ungleich null. Dann wird das
in der entsprechenden Bullshen-Logik dann einfach als Eins bzw. als True interpretiert.
Egal was in der Zahl drinsteht. Hört sich jetzt natürlich auch irgendwie immer so ein bisschen abstrus an,
wo das aber teilweise benutzt wird,
ist bei den Rückgabewerten von irgendwelchen Funktionsaufrufen, die typischerweise so sind,
dass sie quasi, oder die eigentliche Funktion arbeitet,
also zum Beispiel dann durch irgendwelche Seiteneffekte,
beziehungsweise das irgendwie anders mit den Argumenten arbeitet,
dass sie dann aber im Prinzip sowas wie einen Rückgabewert hat,
der den Status angibt, wo diese Funktion erfolgreich ausgeführt.
Wenn die erfolgreich ausgeführt wurde, ist die Rückgabe wert null.
Wenn die nicht erfolgreich ausgeführt wurde,
dann wird da halt eben irgendeine Zahl zurückgegeben,
wo ich dann eben in irgendwelchen Programmierhandbüchern oder sonstig nachgucken kann,
welchem Status das entspricht,
beziehungsweise was dann die Fehlermeldung ist,
wenn ich das jetzt weiter bearbeite
Nee, da wird sowas eben ausgenutzt, dass man sagt,
okay, solange ich als Returnwert eben eine Null habe,
hat alles geklappt. Wenn ich als Returnwert irgendwas Ungleichnull habe,
dann ist also bei einem Aufruf irgendwas schief gegangen und
ich muss mich da dann also nicht weiter,
oder müsste das dann eben entsprechend weiter behandeln oder damit noch irgendwie was machen.
Gut, aber wie gesagt, wo man dann nur aufpassen muss,
weil ich da im Prinzip mit ganz normalen Enager-Werten rechne,
weil das ist dann eben von der Semantik her was ganz anderes,
als jetzt irgendwie das,
was so in der Mathematik gewohnt sind
Gut, wie werden diese logischen Operatoren dann eben ausgewählt,
typischerweise dann auch in so einer Art für kürzen Auswertung von links und nach rechts.
Das heißt, wenn ich irgendwo in Ausdruck habe,
dann nehme ich einfach jedes Beispiel, wenn ich sage,
hier A, Größer B oder dann hier nochmal geklammert,
B und Leicht C und B, Klarnet
Leicht D. Nicht wenn dieses hier schon den Wert tru liefert,
das heißt irgendwas ungleich null, als Returnwert,
dann wird dieser Ausdruck hier gar nicht weiter ausgewertet,
weil Truh oder irgendwas anderes, also eins oder irgendwas liefert,
also auch immer eins zurück.
Da muss ich hier gar nichts mehr machen.
Also hier sieht man das also auch nochmal als Beispiel,
wenn ich jetzt also hier irgendeinen Hexer dezimalwert habe,
ungleich null, den quasi jetzt mit diesem Ausrufezeichen negiere,
erhade ich dann eben als Returnwert null.
Wenn ich null habe, das negiere,
erhalte ich dann also als Returnwert 1,
also irgendwas Ungleich null
Irgendwas zweimaligiert. Oder null, zweimaligiert landet dann wieder
bei null. Hier ist dann eben eine Bulshow-Operation,
das heißt also eine Zahl und Gleichnull, also als eins interpretiert.
Und eine andere Zahl ungleich null als eins interpretiert.
Würde dann im Fall der Unberechnung dann eben ein Trut zurückliefern.
Das heißt, der Ergebniswert wäre dann eben in diesem Fall dann die Eins.
Nicht beim Oder, in diesem Fall dann auch eine Eins.
Also das ist die Art und Weise,
wie jetzt also quasi Bulsche Alge war dann jetzt bei diesen
werden mit den Entegers, also in der Programmiersprache, C rechnet.
Dann muss er auch immer noch so ein bisschen unterscheiden zwischen logischen Operationen,
Bitweisen-Operationen, weil da gibt es dann nämlich auch noch unterschiedliche Schreibweisen,
Bitweisen-Operationen, wenn das dann später auch gleich noch begegnen.
Wie gesagt, wenn ich jetzt nur Bulschalgeber mache,
Zahlen werden null, ist False, alles andere ist eins.
Nicht dann habe ich eigentlich Das,
was also hier irgendwie so auf der rechten Seite dargestellt ist,
also entspricht genau dem, was sich eben auch vorher schon auf der Folie hatte.
Wenn ich jetzt hier zwei Zahlen habe,
die jetzt beide irgendwelche Werte ungleich null enthalten,
mich dann entspricht quasi X und Y jeweils einem polshen True,
also irgendwie einem Wert 1.
Ich will nicht die mit dem Ohnverknüpfe, halte ich eins,
wenn ich die mit dem Oder verknüpfe, halte ich eins.
Und wenn ich jetzt eben hier irgendwelche Ausdrücke bilde,
müsste ich das dann dementsprechend in reichen Regeln in Bulschnagelbau ausrechnen
und können dann eben sagen,
ich erhalte daraus dann eins oder null
Was anderes sind dann diese Bitweisen-Operationen. Da betrachte ich dann
also wirklich so eine Zahl als irgendeinen Bits dringen.
Das heißt also, ich habe jetzt also hier für
meine Zahl 66 dann also entsprechend den entsprechenden Bits dringen.
Und wenn ich daran eben diese Operationen ausführe,
was dann also quasi sowas wie so ein Bitweises und beziehungsweise
hier ein Bitweises oder ist,
wird dann eben wirklich für jede einzelne Stelle die logische Operation
ausgeführt und jede Stelle dann eben unabhängig von irgendeiner anderen Stelle
neu berechnet
Gut, diese Mitweise-Noperation würde ich dann also auch gleich nochmal kurz wieder aufgreifen,
da nur nochmal um jetzt die Bullschalke bereits,
also in C oder Rebullschen-Operationen in C dann abzuschließen. Wie gesagt,
das, was man dort häufig hat, ist eben diese Auserwertungsreihenfolge,
hat ja schon gesagt, von links nach rechts,
entsprechender Klammern und es gibt dann eben diese verkürzte Auswertung,
kann in der Programmierung Nachteile haben, wird aber häufig ganz gerne benutzt,
was dann also wirklich vorteilhaft ist, in solchen Beispielen wie dem,
was hier quasi mal angedeutet ist.
Also wenn ich jetzt schreibe, a, logisches und,
und dann 5 durch, damit ist das quasi eine Absicherung damit,
dass ich keine Division durch null mache.
Nicht weil, wenn A gleich null ist, Bulches Falls,
würde dieser Ausdruck hierhin nicht mehr ausgewertet werden.
Und ich würde also nicht 5 durch nultalien,
was dann also letztendlich ein Fehler generiert
Gleiches gilt dann eben auch zum Beispiel,
wenn ich sowas wie Nullporter-Zugriffe vermeiden möchte,
also Pointer ist ein Verweis irgendwo auf eine Speicheradresse oder irgendein anderes Objekt im Speicher,
nicht in das, was man haben muss, ist dann dort,
also letztendlich sowas wie eine gültige Referenz und jetzt eben nichts,
was also auf Null verweist,
weil das ist dann also quasi immer der, in Anführungszeichen,
Fehlerfall bei diesen Pointern und auch da kann man dann also quasi hier über solche Ausdrücke quasi sicherstellen, dass das Ding und Live-Null ist.
Nicht, also dafür kann man sowas dann in Cem missbrauchen,
ob der Co. damit, also sag mal jetzt irgendwie,
gut lesbar ist und dann eben auch für andere nachvollziehbar ist,
dass sei mal dahingestellt,
also als Best Practice würde ich das nicht bezeichnen,
sondern würde ich das dann,
also vielleicht zumindest noch Kommentare oder es eben wirklich vernünftig über entsprechende IF-Up-Fragen nachvollziehbarer machen,
aber im Prinzip gerade weil wirklich ausgeknautschten Sachen findet man dann eben teilweise solche Tricksereien.
Gut, dann was
die Programmierspanner teilweise auch noch haben
Ja, sind dann ja auch häufig, also beide,
Programmiersparen sind dann solche terrnäheren Operatoren,
wo ich also quasi eine Bedingung habe.
Und wenn die wahr ist, wird halt eben dieser Ausdruck ausgeführt,
wenn die nicht wahr ist, wird dieser Ausdruck ausgeführt.
Nicht nur miteinander, also relativ kompakt beispielsweise schreiben kann.
Ich möchte ihn absolut wert von X haben. Nicht,
dass es dann quasi diese Zeile jetzt,
die dieses Operators nicht, wo ich dann sage,
wenn X-Kleiner 0 ist,
dann ist das Ergebnis minus X
Und wenn X größer gleich null ist, ist das Ergebnis
X. Das heißt, damit habe ich den Absolut wert.
Das heißt, wenn ich irgendwo jetzt eben schreibe,
Y ist gleich und dann eben diesen Tal dahinter,
habe ich eben quasi bei dieser Zuweisung,
dass dann eben entsprechend passend ausgewertet.
Gut, wie sieht das in Java aus? Da gibt
es eben wirklich einen eigenen Datentypolien mit False on True.
Mit denen kann man dann eben entsprechend seine bulschen Operationen ausführen
Sowas, was also in C, der jetzt also irgendwie
so ein bisschen luschig gemacht ist mit dieser Mischung,
mit den Integer-Werten, gibt es dort eben nicht.
Vergleichsoperatoren sind auch die üblichen. Auch dort gilt eigentlich wie in
C. Ich habe diese verkürzte Auswertung und es gibt also auch in Java so einen Kernnähern-Operator.
Gut, dann kommen wir zu den Bittweisen-logischen Operationen. Das ist eben das,
was also eben auf der einen Folie,
also in diesem C-Beispiel, schon mal kurz angedeutet wurde,
dass man sagt,
also ich benutze die Integer-Datentypen jetzt nicht nur um Zahlen darzustellen
Als Unsigned oder Science-Zahlen,
sondern ich benutze die jetzt eben auch, um zu sagen,
okay, ich habe damit, meinetwegen jetzt,
32 Stellen, wo ich 0 und 1 unterbringe,
die dann im Prinzip jetzt einzelne Bits, so eines Binärwortes darstellen.
Und auf diesen einzelnen Witz kann ich dann eben genauso auch meine Bulschen-Verknüpfung ausführen,
die dann eben entsprechend auch Bitweise auf allen Witz dieses Worts
ausgeführt werden und definiert sind da dann eben im Prinzip Region und oder und X-Or,
also das, was jetzt also quasi den Butschen-Operationen entspricht.
Und dann gibt es noch so einige andere Operationen,
Schien rotieren, werde ich also auch gleich noch kurz vorstellen.
Gut, Bittweise, Operation,
wie gesagt, ich interpretiere jetzt also meinen Intager-Wert,
das ist eine Folge von Bits,
sind für beide Programmiersprachen mit Negation,
mit dieser Tilde
Dem einfachen Kaufmanns und dem Einfachhand senkrechten Strich bzw. mit diesem
Dachsymbol dann quasi gekennzeichnet. Und ich habe dann eben hier
Inventierung Alabits, logisches und logisches oder logisches Exklusiv-Oder.
Und das gilt dann eben quasi jetzt für den gesamten Bits
oder für die gesamte Verknüpfung von diesen beiden Bitstrings.
So, das wird uns dann eben auch noch begegnen,
wenn wir jetzt also quasi dann so größere Funktionen nachher dann
entsprechend zusammensetzen
Gut, hier jetzt das Beispiel dazu. Also ich habe jetzt hier
meine Zahlen X und Y. Einfach jetzt mal irgendwie als Bitstring und interpretiere die jetzt mal nicht als irgendeine Zweier-Komplimentzahl oder was auch immer. Dann wäre dann eben dieses,
diese Negation, dass wirklich die entsprechenden Bits einzeln invertiert werden,
so ein Bitweises und wäre dann eben,
müsste man sich dann eben hier jetzt immer entsprechender überlegen,
die Bildweise Verknüpfung, hier das oder und hier dann eben das Exklusiv-Oder,
wo man dann eben sieht, in den Fällen,
wo ich 0 und 1 in Kombination habe,
also hier dann mal dem Bett,
bei dem Bett erhalte ich eine 1 in den Fällen,
wo ich 0-0 und 1-1 habe,
halte ich eine Null,
nicht und hier wird das dann eben entsprechend genauso ausgerechnet.
Gut, neben diesen Bulschen-Operationen und den Bittweisen-Operationen,
die ich dann also quasi auf Vintage ausführe,
hat man dann also bei diesen AT-Jap Argumenten dann eben auch noch häufig solche Schieberoperationen,
die dann eben auch für die entsprechenden Datentypen verfügbar sind,
fünf Stück zu unterscheiden.
Links schieben, in den Programmiersprachnern immer abgekürzt als SHL, Shift Left.
Rechts schieben und dann Rotate Left und Rotate Ride und beim Rechtsschieben
wird er noch unterschieden zwischen logischem Schieben und Arrathmetischen schieben.
Werde ich gleich am Beispiel zeigen, was da die Unterschiede sind,
was man damit macht. So diese Schieberoperationen sind Auch wenn
ich dann also quasi nachher so in die einen Aufbau von Rechenwerken auch einsteige,
dann eben auch vergleichsweise einfach oder trivial in Hardware zu realisieren
und werden eigentlich auch von allen Prozessoren direkt irgendwo mit speziellen Assemblerbefehlen so eins zu eins unterstützt,
weil die werden also auch ganz gerne dann teilweise für irgendwelche mathematischen Operationen,
beziehungsweise eben auch für andere Operationen noch mitbenutzt.
Auch dazu kommen gleich noch ein paar kleine Beispiele und Tricks.
So, Shift Left, was passiert?
Ich habe hier quasi ein String X, der wird,
wenn ich dann jemals zweites Argument sowas wie ein N habe,
um Nbit nach links geschoben. Alles, was ich quasi hier rausschiebe,
Nicht in diesem Fall, hier ist End gleich eins,
also das am weitesten links stehende Bit geht verloren und rechts
werden dann quasi entsprechend Nullen reingeschoben und alles andere wandert um eine Stelle nach links.
Das ist eben in Java on C Directors Operator verfügbar,
also quasi jetzt mit diesen beiden größer Zeichen hintereinander und mathematisch gesehen,
wenn ich das jetzt also hier also nicht mehr als Bits trinke,
sondern wieder als Zahl interpretiere,
entspricht dann eben so ein Schiff,
Left um Endbit,
einer Multiplikation mit zwei Hochähnen
Nicht, weil das ist ja nichts anderes, ist,
dass ich sage, die Stellen oder Stellenwertigkeit geht genau jetzt einen höher.
Hinten kommt eine Null rein. Das ist dann also in dem Fall jetzt,
wenn ich das jetzt hier mit einem Bett mache,
genau mal zwei, beziehungsweise wenn ich das dann eben mit N-Bit mache,
hätte ich dann mal zwei Hochenden.
Sodass logische Rechtsschieben ist quasi genau das Gleiche in die andere Richtung.
Das heißt, von links wird eine Null hereingeschoben. Und das,
was ich auf der rechten Seite von meinem Witzstring habe,
wäre dann eben entsprechend N-Bit quasi weggeworfen, verschwinden.
Und ich habe dann hier entsprechend mein Ergebnis.
In Java ist das Direkt als Operator verfügbar,
also dann eben mit diesen drei Größerzeichen,
in C ist das logische Rechtsschieben jetzt wieder nur für Unsigned.
Typen definiert, für Zahlentypen gibt es das nicht,
sondern da gibt es da nur ein arathmetisches Schieben,
folgt es mich gleich noch. Unsigned-Typen in dem Sinne,
weil wodurch unterscheiden sich seind und ansigned beim einer Science-Zahl hätte ich,
wenn die negativ ist, quasi hier als oberstes Bit,
eine Eins.
Wenn ich die jetzt quasi um ein Bit nach rechts
schiebe mit diesem Befehl, würde die hier lernen.
Ich schiebe dann aber eine Null rein und dann habe ich
im Prinzip dann aus dieser Science-Zahl eine Anscience-Zahl gemacht und das
möchte man in dem Fall jetzt also nicht gemacht haben.
Demzufolge ist es da dann eben nur für Unsigned-Typen definiert.
Wobei auch man, da kann man jetzt wieder mit
irgendwelchen expliziten Typecasts so ein bisschen drumherum tricksen
Aber so. Arithmeter zu schieben, das ist das,
was ich also letzte Woche dann also schon kurz gesagt habe,
was passiert ist eigentlich, wenn ich jetzt unterschiedliche Wortbereiten in
meinen Zahlendarstellungen habe und mit größeren Wortbreiten weiterarbeiten möchte.
Wo ich gesagt habe, na gut,
also wenn ich jetzt also aus einer 188 Bit zahlen,
Zahlen eine 16 bezahlen möchte,
muss ich mir eben quasi das Vorzeichen nehmen und entsprechend oft verdoppeln.
Genau das passiert dann eben beim Arithmetischen Rechtsschieben,
also im Unterschied zu dem logischen Rechtsschieben, logischen Schieben wird einfach stumpf eine Null reingeschoben.
Beim arathmetischen Schieben gucke ich,
wie sie das Vorzeichen aus und das wird eben entsprechend,
wie jetzt hier einfach, wenn ich um eins schiebe,
wenn ich um eins schiebe, dann eben einfach hintereinander geschrieben.
Und wenn das Vorzeichen eine Null ist,
habe ich hier lauter Nullen stehen, wenn das Vorzeichen eine Eins ist,
habe ich hier lauter Einsen stehen.
Das heißt also, wenn ich eine vorher eine positive Zahl habe,
dann ist es nach dem arathmetischen Schieben immer auch immer eine positive Zahl.
Wenn ich eine negative Zahl habe,
ist es nach dem arathmetischen Schieben auch immer eine negative Zahl,
weil dann die Eins entsprechend vervielfältigt wird.
Dass eben genau dieser Unterschied, weswegen man da dann eben
auch von diesem arathmetischen Schieben spricht
Gut, in Java, gibt es das? Ist dann eben
quasi im Gegensatz zu dem logischen Schieben dann mit zwei Feiern gekennzeichnet,
in See, auch zwei Feiern nach rechts,
gilt da dann aber jetzt wieder nur fürs Silentypen.
Das arrathmetische Schieben kann man sich so ähnlich vorstellen wie eine Division
durch zwei hoch enden. Also ich hatte hier gesagt,
also links schieben ist sowas wie eine Multiplikation mit zwei hoch ennen.
Er hat Metese schieben, ja,
ist eigentlich eine Division mit durch zwei hoch ennen,
bis auf die Tatsache,
dass ich bei negativen Zahlen in die falsche Richtung runde
Begegnen wir uns also dann hier gleich, beziehungsweise im nächsten Beispiel nicht. Also hier sieht man mal,
in diesem Fall ist also hier eine positive Zahl,
also der Hexer dezimalstring 1, 0D3. Nicht um einen Wind nach rechts schieben,
wird dann eben zu 08, 6, 9,
beziehungsweise wenn ich das dann jetzt hier in Dezimalschreibweise hätte,
würde dann eben 4.307 hinterher halte ich dann eins dringend,
den ich also als in einer Zahndarstellung unternehmen 2.153.
Das heißt, da bin ich dann eben quasi dann durch zwei.
Hier wäre das dann eben Um 3 Bett nach rechts schieben,
als Zahl interpretiert werden,
dass dann eben minus 28.40460 und hinterher hätte ich dann eben quasi umtreiben,
nach rechts schieben, also quasi geteilt durch 2 hoch 3,
also quasi sowas ähnliches wie diese Zahl durch 8 zu teilen,
wäre dann eben letztendlich hier dieses Ergebnis.
Das hatte ich gesagt,
ist eben ähnlich, weil das, was passiert ist,
dass bei negativen Werten das Ergebnis quasi jetzt immer in Richtung des Betrags gerundet wird,
während die eigentliche Rundungsrichtung, wenn man das mathematisch sieht,
eigentlich immer in Richtung der Null gehen müsste.
Das heißt, wenn ich hier so eine Zahl habe,
beispielsweise jetzt eine Minus 5 in so einer 8-Bit-Kodierung oder 8 Bezahlenkodierung für mehr,
nicht hinter das zum einen nach Rechtsschiebe,
wäre das dann quasi als Zahl minus 3,
beziehungsweise an eben minus Vader minus 1,
mathematisch gesehen müsste das aber eigentlich zu einer Minus 2 werden
War also die 0,5, müsste ich dann eigentlich in
meine Richtung eine Null runden in dem Fall. Gut,
auch das, wie gesagt,
wenn man jetzt entsprechend die Division überhaupt durch sowas realisiert,
kann man dann mit in entsprechenden Bitweisen, Tricks da rein,
also auch wieder so ein bisschen Ausgleichen,
soll uns aber hier jetzt nicht weiter beschäftigen.
Gut, diese Rotations... Ach so, sorry, eine Frage.
Was passiert, wenn ich in die Skovaza geschiefe?
Geht das überhaupt
Nee, also diese Schieberoperatoren sind jetzt immer wirklich nur auf Inager-Zahlen-Darstellungen. Das heißt also sowas wie,
also für sowas wie Fleecekomma ist das also nicht definiert,
sondern da ist also wirklich mit diesem Zahlenformat also letztendlich festgelegt,
okay, wenn ich diesen Bits trinke als Fleecekomma-Zahl,
beispielsweise dann eben als Float interpretiere,
da darf ich dann eben diese Operatoren auch gar nicht anwenden.
Das geht wirklich nur für,
also in Java letztendlich dann eben quasi für normale Inager-Zahlen,
was also immer eine Anzahl-Darstellung ist und in C dann
eben fürs Sign bzw. Ansign
als Datentypen
Ja, also beim Fließkomma würde es insofern also auch immer keinen Sinn machen,
weil ich dann ja wirklich diese Zuordnung zwischen Mantis und Exponent
dann also beliebig irgendwie verhunzen würde.
Und von daher, da passt das nicht. So,
Rotationsoperation ist, wie der Name an anderen Leuten,
nichts anderes als das, was man links rausschiebt, wandert rechts wieder rein.
Gibt jetzt in den Programmiersprachen, also jetzt nicht als expliziten Operator,
teilweise zum Beispiel in Java habe ich das dann aber über
solche Bibliotheksfunktionen zur Verfügung, um so was zu machen.
Protate, left, rotate, right, ist eigentlich,
ich sag mal, selbsterklärend, was das Ganze macht.
Das heißt, ich nehme jetzt wirklich immer diesen Bit-String und permutiere das.
Interessant sind solche Sachen, jetzt fragt man sich immer,
warum überhaupt dieses komische Geschiebe und Rotieren und sonstiges, wofür braucht man das? Interessant wird,
dass also dann hier folgen jetzt nur ein paar ganz kleine Beispiele,
aber dann eigentlich, wenn ich also sowas wie Kodierung anwende,
wo man teilweise dann in, oder für die Kodierung der Daten,
also solche Operationen braucht, um dann also quasi einzelne Bits irgendwo rauszufischen,
beziehungsweise um dort irgendwas zu machen.
Und ganz am Ende dieses Kapitels kommen dann also auch noch ein paar Beispiele,
die sehen also auch erstmal relativ abschreckend aus,
die werden also auch nicht in der Prüfung abgefragt,
aber da sind da so ein paar Tricks da rein,
wo im Prinzip dann solche Eigenschaften von den Zahlen,
Kodierungen auch mit benutzt werden,
beispielsweise jetzt für schnellere metische Operationen
Auch das etwas, was uns dann also ein bisschen später dann auch erst beschäftigen wird.
Aber wenn ich jetzt so im Prinzip Zahlen agiere,
in Binärdarstellung, kann ich mit Eigenschaften,
die ich quasi jetzt also aus solchen Bittweisen oder Betrachtung als Bitstrinks mache,
dafür sorgen, dass diese Operation deutlich schneller läuft,
als wenn ich das jetzt wirklich einzeln stelle für Stelle mache,
so wie ich das jetzt auf dem Papier oder auf der Tafel irgendwie machen würde.
Dafür braucht man teilweise eben genau diese Operation. Gut,
ja, was Letztendlich aber ja so aus diesen Schieberoperationen
ja schon so ein bisschen rausgekommen ist.
Ich kann damit eigentlich sowas wie eine, ich sag jetzt mal,
billige Multiplikation machen, solange ich nur um Zweierpotenten mit zwei Potenzen multipliziere.
Ich aber damit kann man das also schon machen.
Und gerade so auf Prozessoren, die jetzt also nicht spezielle Multiplikationsrechenwerke haben,
kann man damit dann eben auch entsprechend seine gesamte Multiplikation machen.
Und das teilweise eben auch noch ein bisschen beschleunigen,
weil, sagen wir mal so was wie Addition und Subtraktion
kriegt man eben Vergleiche
In Hardware umgesetzt, eben vergleichsweise schnell hin. Also hier
mal als Beispiel gesagt, einfach mal in einem Tag.
Stimmt, nicht ganz, aber gut.
Jedenfalls, das kriegt man also vergleichsweise schnell hin.
Schiebeoperationen eigentlich genauso. Multiplikation ist vergleichsweise aufwendig in Hardware.
Also auch da würden uns im Kapitel 9 dann also noch irgendwie,
nee, 9 kann das nicht sein, also 10,
11, 12 müsste das sein. In Kapitel 12,
also noch irgendwie so ein paar Wahlspiele begegnen,
wo man dann also sieht,
wie man also im Prinzip dann auch irgendwie so Multiplikationen mit
irgendwelcher Spezial-Hardware machen kann,
aber das sind also schon
relativ aufwendige Sachen
So, und das, was man dann,
also als Trickserei machen kann, ist,
dass man eben wirklich so eine Multiplikation durch Schieben und Addition von Konstanten relativ willig sich erkaufen kann,
solange man also vergleichsweise einfache Werte und Zahnwerte hat.
Also Beispiel, wenn ich also jetzt hier irgendwie rechnen möchte,
neunmal X, kann ich da einfach sagen, okay,
das ist acht plus einmal X, achtmal X ist also nichts anderes,
als es X um drei wird nach links schieben und dann bleibt noch plus einmal X.
Ja, das ist dann also nichts anderes als plus X. Nicht das heißt,
also ich kann diese Multiplikation die jetzt in Hardware,
sei es mal, meinetwegen 16 Takte braucht,
hier in so einen Ausdruck umsetzen,
der sich zwar vor uns jetzt mal umständlicher liest,
der aber letztendlich mit zwei Operationen,
nämlich diesem Schieben und dieser Addition möglich ist,
die dann also wirklich in jeweils einem Tag nur gemacht werden.
So, das Gute ist,
wir müssen uns als Programmierer da also glücklicherweise nicht so richtig drum kümmern,
sondern dafür gibt es eine schlaue Compiler,
die das also entsprechend von sich auseinander,
also auch schon teilweise einbauen in den Code
Vorbei. Also auch nur als Anmerkung, aber das wollte eigentlich auch selbstverständlich sein.
Das Ganze funktioniert natürlich nur, wenn ich hier auch irgendwelche Konstanten habe.
Aber eben wirklich irgendwie sowas wie Multiplikation mit Konstant,
teilweise eben auch die Visionen durch Konstant können,
dann eben mit so ein bisschen mathematischer Umfang dann eben in
so ein Schieben und Addition von irgendwelchen Talthermen,
also umgesetzt werden.
Und gerade Performance-mäßig kann das also doch wirklich
deutlich was bringen
Gut, etwas, was dann auch relativ häufig braucht,
was uns dann also auch später dann bei dieser ganzen Sache
der Codierung von Informationen dann nochmal weiter begegnen wird, sind Operationen,
wenn ich jetzt also quasi einen Entager-Wert habe und den ich interpretiere als 32 einzelne Nullen und Einzelnen.
Dass man in diesem Bitstring, den es ja eigentlich darstellt,
wirklich an einer bestimmten Stelle ein einzelnes Bit beispielsweise
setzen möchte oder löschen möchte
Nee, jetzt kann ich natürlich anfangen, dass das in irgendeinem relativ komplizierten mathematischen Ausdruck zu fassen, wie ich da also überhaupt jetzt rankomme. Dafür sind aber eben ganz gut solche,
eben diese Schieberoperationen, wo ich eben sage,
ich nehme eine Eins, eins ist quasi im Witzstring,
0-0, 0,
wenn ich jetzt so hier bei acht Bett bin,
meinetwegen, und der eine Eins, so,
und die schiebe ich jetzt, um einen Wert weh,
beziehungsweise irgendwas von null, dann habe ich genau diese Stelle maximal eben,
wenn ich eine Wortbreite von W habe,
dann eben um wie minus eins stellen.
Und damit erhalte ich dann im Prinzip sonst drin,
der aus lauter Nullen und hier einer Eins an dieser Stelle W entspricht.
So, und das kann ich jetzt mit dem Bett weisen oder verknüpfen. Das heißt also,
ich habe jetzt meine Eins meinetwegen hierhin geschoben,
würde das jetzt mit irgendeinem Ausdruck Bitweise verodern und das,
was ich als Ergebnis erhalte, ist ja dann also nichts anderes,
als dass ich hier den Originalausdruck habe,
weil da habe ich irgendwas oder null.
Dann heißt also das, was ich als irgendwas stehen habe
, wird einfach nur abgeschrieben. Und an der Stelle,
wo ich hier in meiner Maske diese Eins gesetzt habe,
wird eben, egal was hier steht, eine Eins gesetzt.
Damit kann man jetzt wirklich an einer gezielten Stelle
ein einzelnes Bit setzen.
Genau das Gleiche funktioniert eben auch
Wenn ich ein einzelnes Bitte löschen möchte, mit diesem Ausdruck hier unten,
wo ich mir quasi eine Maske erzeuge aus lauter Einsen und
einer einzigen Null an einer bestimmten Stelle, wird erzeugt,
indem ich auch hier wieder anfange mit einer Eins,
die um die Position quasi verschiebe, anschließend nicht.
Das heißt, dann habe ich also diesen Ausdruck,
anschließend biddweise negiere. Das ist also diese Tilde.
Dann habe ich genau diese Maske. Und wenn ich das
jetzt mit dem Bittweisen und mit irgendeinem String verknüpfe,
wird eben quasi an genau dieser Stelle,
wo die Null sitzt,
dieses einzelne Bitt gelöscht
Und diese Tatsache, dass man jetzt also quasi so ein Entager-Wert missbraucht,
um da jetzt quasi Bitvisor irgendwelche einzelnen Bits zu setzen oder zu löschen,
also das wird beispielsweise relativ häufig genutzt bei irgendwie so
Informationen über Statuszustände oder sowas. Also beispielsweise,
wenn ich jetzt sage, ich habe hier meine X-86-Architektur,
habe also irgendwo innen drin einen Prozess,
also was wie ein Fleckregister, also ein Statusregister,
wo eben drinsteht von irgendwelchen Operationen wurden die erfolgreich ausgeführt,
wurde bei der letzten Allo-Operation ist ein Overflow aufgetreten,
ist das Ergebnis gleich, null,
ist es kleiner null und so war es.
Das wird dann eben quasi in einem einzigen Wort alles abgespeichert
und ich weiß dann eben an der und der Stelle dieses Bit
dokumentiert mir eben die Eigenschaft an der und der Stelle dieses Bit dokumentiert mir die Eigenschaft.
Nicht das heißt, damit kann ich dann also quasi 32
Statusinformationen in einem einzelnen Wort unterbringen und muss dafür jetzt nicht 32 unterschiedliche Worte abspeichern.
Also das ist einfach, um Platz zu sparen,
weswegen man dann da dann also beispielsweise an solche Kodierungen wählt
Gut, hierzu folgen dann noch ein paar weitere Beispiele,
werde ich dann aber, weil ich sehe also heute nicht weiter strapazieren werde,
am Freitag noch kurz machen, aber damit ist dann eigentlich dieses Kapitel letztendlich inhaltlich,
beziehungsweise von dem, was jetzt an Neuigkeiten kommt und eigentlich auch schon abgeschlossen.
Wie gesagt, am Freitag nochmal ein bisschen Motivation dazu,
also auch nochmal Beispiele,
wo sowas rein praktisch benutzt wird und dann wird es im nächsten Kapitel dann eben um das Thema der Codierung von Daten gehen,
Codierung jetzt nicht im Sinne,
wie kodiere ich Zahlen oder wie kodiere ich Zeichen und Text,
sondern wie kodiere ich meine Informationen,
wenn ich sie von A nach B übertragen will,
um das besonders effizient zu machen oder um Übertragungsfehler auszugleichen.
So, ja,
das erstmal als Teaser für Freitag und ansonsten einen schönen Abend
und das soll es
für heute gewesen sein