So. Ja, ich hatte am Freitag ja quasi aufgehört mit der Einführung zum Fließkomma-Formaten und hatte dort ja eigentlich nochmal kurz beschrieben,
insgesamt, wie jetzt im Fließkomma-Format,
prinzipiell eben erstmal aussieht, beziehungsweise das,
was wir dann eigentlich auch als typisches Fließkomma-Format kennenlernen werden,
also das I-Trip, die 754-Format,
was sich dann also im Einzelnen heute noch genau vorstellen werde,
nicht dass das dann eben auch in der Art und Weise aufgebaut ist,
dass man sagt, es gibt eben ein Vorzeichenbit,
dann eben eine Mantesse, Zahlenbasis und eben einen entsprechenden Exponenten.
Und das Ganze ist eben in den Formaten,
wie wir sie dann live benutzen werden, dann eben entsprechend festgelegt,
wie dann also auch die jeweiligen Zahlenkodierung aussehen, weil,
wie gesagt, die Darstellung sie dann eben so aus,
dass also der Exponent dann beispielsweise in so einer Access-Kudierung dargestellt wird und die anderen Zahnsprüche.
Gut, die letzte Folie, die ich also am Freitag aufliegen hatte,
war also hier nochmal diese Unterscheidung jetzt mit den Zahnbereichen,
dass man eben sagen kann, gut,
negative und positive Bereiche, dadurch,
dass ich ein explizites Vorzeichenbild habe, sind logischerweise identisch.
Dann habe ich eben ausgewiesen die Null, darstellbare, negative Zahlen,
darstellbare, positive Zahlen und dann gibt es eben sowohl ein Überlauf in Richtung der sehr großen Zahlen,
die ich also nicht mehr darstellen kann, war einfach die Bits im Exponent nicht ausreichen.
Und es gibt dann eben ein Unterlauf, also sprich,
wenn ich nah genug an die Null rangehe,
weil ich da dann eben auch nicht genügend Stellen zur Verfügung habe.
Gut, was dabei dann auch immer noch wichtig ist,
ist eine irgendwie normalisierte Darstellung,
weil bislang ist es immer so, wenn ich sage,
ich habe jetzt also hier irgendwie mein Vorzeichen-Bit, Mantis und Exponent,
beispielsweise jetzt also im Dezimalsystem, dann kann ich sagen,
also die Zahl 123 lässt sich eben beschreiben,
als 123 mal 10 und null.
Ich kann aber eben auch schreiben, 12,3 mal 10 Uhr 1,
1,2 rein mal 10 Uhr 2 und so weiter und so fort,
beziehungsweise ich könnte auch 1230 mal 10 und minus eins schreiben.
Die normalisierte Darstellung ist jetzt eben, dass man sagt,
okay, für eine bestimmte Zahl oder eine bestimmte Zahlengröße wird eben ein entsprechend passendes Format gewählt.
Und das, was man da dann eben typischerweise macht,
ist, dass man sagt, der Exponent wird eben so angepasst,
dass die Mantise im Bereich zwischen eins und eben quasi einer Zahl kleiner der Basis liegt.
Diese Darstellung ist dann eindeutig, in diesem Fall wäre das dann
also hier in dem Bezimalsystem die 1,2, 3x 10 hoch
2. Wenn ich im Dualsystem bin, wird das Ganze vergleichsweise einfach,
dann wird nämlich hier dieses vorderste Bittermantise,
was dann also zwischen eins Also größer,
gleich eins ist und kleiner als die Basis, also kleiner als zwei, dann nämlich genau zu eins.
Das heißt, das erste Vorkommabit ist automatisch eigentlich immer eins.
Diesen Trick macht man sich nämlich zu Nutze und sagt,
dieses Bild wird dann eben auch nicht explizit in der Zahl gespeichert,
sondern bei allen normalisierten Zahlen.
Es wird dann auch noch darauf zu sprechen kommen,
es gibt ja auch noch nicht normalisierte Zahlen,
aber bei allen normalisierten Zahlen gibt es dann eben vorneweg noch
diese explizite
Nicht normalisierte Zahlen, wie gesagt, sind dann eben Zahlen mit entsprechend sehr kleinwerten.
Die sind dann auch noch möglich in dieser Kodierung,
Beispiele dazu wählen, also im Einzelnen noch Folgen,
beziehungsweise sind dann ja auch Teil der noch folgenden Übungsaufgaben.
Gut, das, was wir jetzt eigentlich kennenlernen werden,
und das, was ich jetzt auch vorstelle, ist,
sagen wir mal, der, in Anführungszeichen, übliche Standard für Fließkommazahlen,
der als Eye-Triple-I 754 standardisiert ist, Das Ganze seit 1985.
Dazu muss man eben sagen,
bevor es diesen Standard gab, war es eben so,
dass wirklich jeder Hersteller von irgendwelchen Rechnersystemen da sein eigenes Fließkomma-Format
hatte mit unterschiedlichen Anzahlen von Bits in Mantis und Exponent mit unterschiedlichen Arten,
wie jetzt also dieses Vorzeichen letztendlich implementiert wurde.
Exponenten waren dann eben auch nicht nur zur Basis 2,
sondern auch 10 oder auch 16 genommen.
Und was dann eben auch entscheidend war,
für jedes Format hatten die Hersteller dann eben auch quasi ihre eigenen Rundungsalgorithmen letztendlich implementiert,
was dann eben dazu führte,
dass wenn ich ein Programm schreibe und es von einer Maschine auf die andere portiere,
auf einmal völlig unterschiedliche Ergebnisse bei herauskommen können.
Das sah es dann eben letztendlich,
dass wirklich numerische Algorithmen eben dadurch nicht portabel waren. Gut,
seit 1985 gibt es dann eben letztendlich diesen Standard mit klaren
Regeln für eine eindeutige Zahlenkodierung und eben auch mit festgelegten Regeln für Rundungsoperation,
beziehungsweise dann eben auch mit Regeln hinsichtlich der Genauigkeit.
Inzwischen kann man sagen, die SA-Trip,
die 754-Format ist quasi der universelle Standard für Fließkomma-Formate und wird eben
auch von den gängigen Programmiersprachen letztendlich so umgesetzt, beziehungsweise so implementiert.
Hier nur als ergänzender Hinweis dann auch,
habe ich jetzt gerade vorhin noch in die Folie mit aufgenommen,
seit 2008 gibt es da dann also auch noch einen erweiterten Standard,
wo dann also auch noch kürzere, beziehungsweise noch längere Zahlenformate definiert sind.
Das ist aber jetzt eben hier nur die Vollständigkeit halber erwähnt.
Da werde ich dann also auch nicht weiter darauf eingehen,
weil das ist dann nämlich auch schon wieder eine Sache,
wo man dann also letztendlich gucken muss, wird das von meiner Programmiersprache,
wird das von meiner Compiler-Umgebung entsprechend überhaupt unterstützt.
Eine Frage. Also die Frage war,
also ob es auch schon irgendwie Standards für irgendwelche Quantentheoretisch oder Quantencomputer-Berechnungen gibt,
wo man dann also jetzt ja nicht nur eine zweiwertige,
sondern eben eine dreiwertige oder noch mehrwertige Logik hat,
muss ich jetzt zugeben, müsste ich jetzt erst mal passen,
soweit mir bekannt, nein, aber das will in dem Fall also nicht sein.
Nee, also ich meine nicht. Gut,
wie gesagt, das, was ich jetzt vorstelle,
sind sagen wir mal so die üblichen Formate,
wo man davon ausgehen kann, also in Java,
Python, C, C plus Plus, C, Sharp,
was auch immer, habe ich die eigentlich auch in dieser Form genau zur Verfügung.
Sind diese Art Triple E-Formate, die sich dann float für Gleitkomma zahlen,
mit einer 32-Bit-Darstellung und Double für Gleitkomma-Zahlen mit einer 64-Bit-Darstellung,
etabliert haben, sieht dann eigentlich immer,
wenn man das jetzt mitweise aufteilt, dann folgendermaßen aus,
dass ich sage,
ich habe eben ein Vorzeichen-Bit bei einem 32-Bit-Format dann 8-Bit für den Exponenten,
23-Bit für die Mantise, beim 64-Bit-Format Elf Bit für einen Exponenten und 52 Bit für die Mantesse.
Zusätzlich gibt es dann also für in diesem I-Triple-I-Standard dann also auch noch quasi erweiterte Genauigkeiten,
wo dann also festgelegt wird,
was also Mindestlängen für Exponent beziehungsweise Mantesse drin sind,
aber auch das ist dann wieder etwas,
wo man dann also wirklich letztendlich sagen muss,
erst mal nachschauen, wie das implementiert ist,
wo das dann auch teilweise dann benutzt wird, unterstützt wird.
Da würde ich dann eigentlich auch eher dazu raten,
wenn man höhere Genauigkeiten braucht, vielleicht dann also nachzugucken,
wie das also mit diesem 2008 Standard mit 128-Bit-Wortlängen aussieht.
Gut, in dem Format, wie sind die Zahlen dort kodiert? Die Mateste ist im Prinzip eine normalisierte Dualzahl,
also sprich größer gleich 1, kleiner 2, die dann hier drin ist,
implizit ist dann also quasi dieses eine Vorkommabit, automatisch mit drin,
das ist also in diesen 23 bzw. diesen 22 Stellen nicht enthalten,
das, was man hier quasi sieht,
sind dann immer die Nachkommastellen,
die dann also von der Zahlen noch überbleiben.
Die Exponenten werden dargestellt in einer Exzess 127 bzw. Exzess 1023-Kodierung.
Das heißt, man nennt mal den jeweiligen Binärwert und muss dann eben
die 127 oder 1023 abziehen. Und für die Exponenten gilt,
dazu komme ich dann also später auch noch, wenn ich das,
oder wenn ich dort dann also auch nochmal die etwas spezielleren Werte erläutere,
die Kombination lauter Nullen, beziehungsweise lauter Einsen sind dann eigentlich von den,
in Anführungszeichen, normalen Zahlen dann eben auch erst mal rausgeschlossen.
Also die Frage war jetzt, also noch mal,
war es jetzt also mit dieser normalisierten DualSar gemeint ist,
dass es im Prinzip dieses hier,
also hier ist das Ganze jetzt nur für ein Dezimalsystem,
dass sich ja also unterschiedliche Vor- und Nachkommastellen wie jetzt also
immer nehmen kann und dann eben nur entsprechend dann also hier im Exponenten das anpassen muss.
Und diese Normalisierung sagt jetzt eben,
dass das Ganze dann eben passend so geschoben wird,
bis ich quasi eine Vorkommastelle habe und dann dementsprechend viele Nachkommastellen
und dieses wäre dann eben hier entsprechend der normalisierte Wert.
Gut, zusätzlich gibt es dann eben noch Sonderkodierung für die Null,
für Ungültige Werte, N-A-N steht für Nord-and-Namber und für unendlich groß.
Beispiele dazu folgen dann eigentlich auch noch. Gleich kurz. Gut,
hier nun mal grobs in der Abschätzung, wie die Zahlenbereiche eigentlich aussehen.
Also bei der einfachen Genauigkeit, also sprich 32-Bit-Wortlänge,
hört man dann demzufolge dann einen Exponentenbereich bei so einer Exzess,
127-Kudierung von minus 126 bis plus 127.
Nicht bei der doppelten Genauigkeit von minus 122 bis plus
Die kleinste, normalisierte Zahl liegt dann eben im Bereich von 2,
minus 126, beziehungsweise 2, minus 1022,
die größte normalisierte Zahl ungefähr im Bereich, zwar auch 128 beziehungsweise
2024. So, wenn ich das, Pima Daumen jetzt,
also im Dezimalbereich, umrechne,
habe ich damit dann also eben irgendwie so einen Stellenbereich von 10 und minus 38 bis 10 oder 38,
dann bei der einfachen Genauigkeit und von 10 und minus 308 bis 10 hoch 308 bei der doppelten Genauigkeit.
So, und wenn ich entsprechend größere Zahlen brauche,
beziehungsweise hier dann eben kleinere Zahlen als das, was ich hier mit darstellen kann,
müsste man dann eben eine entsprechend andere Zahlen kodierung benutzen. Gut,
hier auf diesen folgenden Folien ist also das Ganze dann also nur noch mal für so ein Beispiel dargestellt,
dass es eben auch aus so einem Madlab-Skript, was ich jetzt da,
ich also jetzt hier mit dem Rechner wieder nicht irgendwie an den Madlab-Lizenzen rankomme oder es ein bisschen schwierig ist,
jetzt also nicht praktisch vorstellen werde, andererseits,
wenn man also irgendwie ein bisschen Suchmaschine bemüht oder im Internet mal guckt.
Es gibt also beliebig viele Java-App-Plats, beziehungsweise Webseiten,
wo im Prinzip genau sowas eigentlich implementiert ist,
beziehungsweise was sich nachher auch noch kurz vorstellen werde,
ist also wirklich eigener Code,
den man sich selber neben übersetzen kann, laufen lassen kann,
wo dann also im Prinzip dann mal diese Umrechnung auch passiert.
Also was man hier dann eben eigentlich immer nur sieht,
dass sich dann eben letztendlich hier meine Zahl habe, Vorzeichen, Exponent, Mantise.
Nicht in das, was hier quasi grau eingezeichnet ist,
ist dann eben diese implizite Vorkommastelle,
die dann also bei der normalisierten Darstellung letztendlich vorhanden ist.
Und das gibt es dann also eben sowohl für das 32-Bit,
als auch für das 64-Bit-Format. Nicht Genauigkeiten,
wie gesagt, sind hier dann auch nochmal,
beziehungsweise hier ist eben auch nochmal ungefähr so der Vergleich, wie vielen Dezimalstellen das entspricht.
Also auch das kann man mit ein bisschen Mathematik,
dann einfach so Pima Daumen umrechnen, dass ich sage,
beziehungsweise das hatte ich letzte Woche auch schon kurz erwähnt,
dass man also jetzt für die Zahlendarstellung von,
oder bei einer Binärkodierung dann eben ungefähr dreimal so viel Stellen braucht,
beziehungsweise hier ist es dann also quasi genau 3,322 und dann geht das noch ein bisschen weiter.
Mal so viele Stellen wie Dezimalsystem. Gut,
um jetzt wirklich nochmal ein bisschen praktisch zu veranschaulichen,
Also jetzt aus so einem komischen Bits dringend die Zahl aufgebaut wird,
folgen jetzt hier nochmal einige Beispiele,
die jetzt also alle hier mit dem etwas kürzeren 32-Bit-Format drin sind,
also hier nur nochmal zur Erinnerung.
Ich habe eben hier mein Vorzeichen-Bit, was dann also quasi entspricht,
minus eins, hoch es, sprich Anna 0,
habe ich als Ergebnis eins, da ändert sich nichts.
Bei einer Eins habe ich minus eins, also eine negative Zahl.
Exponent wäre dann eben entsprechend diese acht Stellen Exzess 127 Codierungen,
müsste ich also quasi den Wert nehmen.
127 davon abziehen. Und die 23 Bittermantise sind quasi die Nachkommastellen,
die nach so einer expliziten 1, irgendwas letztendlich folgen.
So, wenn ich jetzt also irgendeine Zahl nehme,
beispielsweise jetzt also hier diese 32 Bit,
hier schon also entsprechend so ein bisschen unterteilt,
wäre diese Zahl dann also quasi Vorzeichende 1,
also eine negative Zahl
Diese 8-Bett sind 128, also 2 hoch 128, minus 127.
Ich bin ja mit dieser Access-Codierung zugange. Also minus 1
mal 2. Und hier habe ich dann eben die implizite 1.
Die 0,5 ist quasi hier die erste Nachkommastelle.
Die zweite Nachkommastelle ist 0,25. Die dritte Nachkommastelle ist 0,1,
2, 500 Folgen, letztendlich nur noch Nullen.
Das heißt, wenn ich das Ganze dann hier ausrechne,
wäre dann die Zahl, minus 3,75. Anderes Beispiel,
sein wird es null, eine positive Zahl.
Hier, wie neakodiert, 254, minus 127,
muss ich dann ja eben mit der Access-Kudierung noch ausrechnen,
also zwei hoch 127,
mal die implizite
Dann habe ich hier quasi zwei minus eins, zwei minus zwei,
zwei minus drei. Dann hier als Stelle mit einer 1,
2 minus vier, also eins, plus zwei minus vier,
fünf und sechs sind wieder null.
Dann habe ich jetzt zwar minus sieben und an dieser Stelle
zwei minus acht. Das ist dieses hier und wenn man
das Ganze dementsprechend numerisch ausrechnet, wären,
wäre diese Zahl dann eben zwar 107 mal 1,074,
2,18875 und dann
entsprechend dezimal umgerechnet
Da die passende Zahl. Hier eben noch mal zwei weitere Beispiele.
Negative Zahl. Zwei hoch eins, minus 127,
also minus zwei hoch, minus 126. Hier hinten habe ich
nur Nullen, demzufolge eben nur diese eine implizite eins.
Und diese Zahl quasi dann minus 1,1 755 matzen 10 hoch,
minus 38 wäre dann nämlich letztendlich die kleinste negative,
normalisierte Zahl, die man also in diesem Zahlenformat darstellen kann.
Hier eben nochmal ein anderes Beispiel, wieder eine positive Zahl,
Science Bit ist null, 127. Das heißt,
hieraus kriege ich dann also letztendlich nur eine Eins und hätte dann eben 1,
und hier hinten eine Eins, also eins plus 2 minus 23,
war es dann eben entsprechend diese Zahl entspricht
Gut, und damit kann man sich dann alle entsprechend
diesen Rechenregeln eigentlich relativ einfach seine Fließkommerzahn entsprechend umsetzen.
Gut, als Beispiel, wie sowas dann programmiertechnisch umzusetzen ist,
habe ich dann also hier auch noch ein kleines Java-Programm.
Das Ganze ist also auch auf der,
zumindest jetzt bei uns auf der Webseite, also nicht auf der Steene-Webseite,
aber bei uns auf der Webseite zum Download verfügbar.
Kann man sich dann eben entsprechend AFA jetzt mit den Java-Werkzeugen dann zum Laufen bringen. Wie gesagt,
das ist jetzt vielleicht schon vorgreifend und ich weiß es eben auch nicht,
wie bei ihnen da die Erfahrung sind,
ob sie mit dem Code schon was anfangen können,
beziehungsweise ob dann also der Umgang mit den Werkzeugen bekannt ist.
Wie gesagt, da wird jetzt hier nichts vorausgesetzt,
aber das ist einfach ein normales Ergänzendes Beispiel. Letztendlich das,
was hier passiert ist, dass ich hier aus diesem Argument,
was also quasi als Dring übergeben wird,
also beispielsweise dann, also hier so eine Zahl,
die über entsprechende Maskierungsopper und Schieberoperationen daraus quasi jetzt,
also hier die einzelnen Teile, nämlich Vorzeichen,
Exponent und Mantes überrechne.
Und beziehungsweise das ist, also jetzt hier quasi genau das andere,
wo das also hier quasi umgekehrt jetzt zusammengesetzt wird.
Und dann aus diesen Werten quasi eine Zahl genommen wird,
das dann entsprechend aufgerufen wird,
beziehungsweise hier bei dieser Darm-Operation wird das dann eben entsprechend ausgegeben.
So, wenn ich das jetzt hier für Diese Werte beispielsweise machen würde. Nicht,
dass ein Wehren das dann also jetzt hier mal in diesem 32-Bit-Fluting-Point-Format
quasi die jeweiligen Bit-Vektoren und dieses dann also hier die entsprechenden Werte.
Und hier tauchen dann eben auch schon Werte für unendlich minus
endlich beziehungsweise Kodierung für diese, die es Nordde Number auf,
wie die genau kodiert sind.
Wie gesagt, das werde ich dann nachher auch gleich noch
kurz vorstellen
So, wie sieht jetzt bei den entsprechenden Glatkomma-Formaten im Prinzip
die Berechnung von irgendwelchen arathmetischen Ausdrücken aus?
Also erstmal als einfachstes Addition, Subtraktion, Addition von zwei Gleitkommazahlen.
Idee ist, dass man im Prinzip den betragsmäßig kleineren Summaten,
also erstmal passend skaliert, dass letztendlich dann also die beiden Exponenten identisch sind
Bei dem Skalieren passiert jetzt eben genau das,
was quasi jetzt eigentlich hier bei dieser Normalisierung dann nämlich der Fall ist.
Sprich, ich muss jetzt hier also diesen Exponenten irgendwo anpassen.
Demzufolge wird dann also die Mantesse entweder nach links oder nach rechts verschoben,
beziehungsweise das Komma wird verschoben, die Zahl entsprechend größer oder kleiner.
Was dabei dann natürlich passieren kann,
also gerade wenn ich nach rechts schiebe,
das dann also letztendlich Stellen wegfallen, nicht deswegen Hier auch die Anmerkung,
dass sich da eben beim kleineren Sumanten,
also quasi die effektive Gnauigkeit verringert, weil vielleicht also irgendwelche signifikanten Stellen wegfallen.
So anschließend kann man dann eben die Marthissen addieren,
beziehungsweise subtrahieren. Dabei kann es dann eben wieder vorkommen,
dass das Ergebnis wieder eine nicht normalisierte Zahl ist und
gegebenenfalls muss man die dann eben auch noch wieder anpassen
So, jetzt heißt es hier so schöne Beispiele,
da zu folgen in den Übungen.
Beispiele bezogen auf die entsprechenden Binärformate, hier aber nochmal zur Veranschaulichung,
wie das Ganze jetzt in dezimal aussieht. Also sprich,
stinke einfache Schulmathematik, die wir eigentlich schon alle kennen sollen.
Also ich habe jetzt hier meine Zahl, 9,725 mal 10.07 Uhr.
Und als zweiten somannten 3,01 6 mal 10.06 möchte ich
eben entsprechend addieren
Demzufolge muss jetzt erst mal die Exponenten angleichen. Das heißt,
ich nehme jetzt also hier die betragsmäßig oder die entsprechend kleinere Zahl,
passt die dann eben entsprechend an,
bis sich da auch die 10 Uhr 7 habe.
Das heißt also hier einen nach rechts schieben.
Anschließend kann man dann eben quasi mathematisch gesehen einfach per Destributivgesetz,
die 10 Uhr 7 Mors ziehen, hat dann eben die Addition der Mannschaft.
Wissen führt dann eben zu diesem Ergebnis. Und was man jetzt eben hier sieht,
ist, dass quasi das Ergebnis der Manthesse hier ist eine nicht normalisierte Zahl ist,
weil die ist jetzt eben in diesem Fall Größert leicht sehen.
Demzufolge muss ich da dann eben nochmal wieder normalisieren.
Das heißt, also einen nach rechts schieben.
Hätte dann eben 1,002 6, 6 mal 10.8 Uhr.
Und was dann eben auch noch mit reinkommen kann, ist,
wenn ich jetzt also mit einem festen Format arbeite, also beispielsweise,
wenn ich sage, ich habe hier entsprechend drei Nachkommastellen,
das dann eben in diesem Fall dann eben auch noch gegebenenfalls eine Rundung stattfindet.
Das führt dann eigentlich wieder auf das zurück,
was sich in dem Kapitel zur Den Begriffen, Information, Nachrichten gebracht hatte.
In der Regel ist dann nämlich diese Operation nicht Informationstreu,
sprich durch solche Rundungseffekte, die dann also letztendlich Informationen in diesen Folgen, also Genauigkeit verloren.
Was man bei den arathmetischen Berechnungen bei Glattkomma Zahlen dann eben
auch entsprechend oft hat, sind eben wirklich auch irgendwelche Auslöschungseffekte.
Also gerade bei der Subtraktion von Glattkomma Zahlen kann es dann immer relativ schnell dazu kommen,
Typische Fälle wären also zum einen,
wenn ich also jetzt wirklich sehr stark unterschiedliche Exponenten habe,
was ja also nach diesem Algorithmus dann eben heißt,
die kleinere Zahl wird eben entsprechend skaliert,
um jetzt also die Exponenten anzupassen.
Dadurch wären jetzt natürlich dann gegebenenfalls sehr viele Stellen außer Mantesse vielleicht weggeschoben,
verschwinden und es kann dann eben dazu führen,
dass er eigentlich kaum noch gultige Bits übrig bleiben.
Demzufolge habe ich dann eben Entweder ein ungenaues Ergebnis oder ein Worst Cases
ist es ihm wirklich so, dass die kleinere Zahl verloren geht.
Dieses Beispiel hatte ich ja auch in diesem Kapitel mit der Information schon drin stehen,
wo ich dann sage,
ich habe also jetzt eine vergleichsweise große Zahl,
also 1,0 mal 10,20 Uhr plus dann hier also irgendwie so ein angedeutetes Pi,
3,14,159, nicht in das Ergebnis,
weil wenn ich hier raus dann eben auch erstmal eine 10,20 Uhr mache,
gehen eigentlich hier alle signifikanten Stellen verloren und das Ergebnis ist
dann eigentlich nur die erste Zahl
Der zweite Fall ist, wenn ich Effekte habe,
wo also bei der Subtraktion zum Beispiel sowas habe,
wie gleiche Exponenten und fast gleiche Mantissen,
dass ich dann dementsprechend die Bits gegebenenfalls auslöschen.
Und gerade wenn jetzt also quasi die ersten oder die Hörwerte
ihren Bits identisch sind,
bleiben dann eben nur noch wirklich sehr wenige Nachkommastellen über und
das Ergebnis hat dann eben auch nur noch eine
sehr geringe Genauigkeit
Solche Effekte sind dann eigentlich immer gerade auch dafür verantwortlich,
dass man also bei irgendwelchen mathematischen Operationen eben über entsprechende Bibliotheken beziehungsweise indem
man sich dann also vielleicht auch selber ein bisschen die Größenordnung der Zahlen dann also irgendwie vergegenwärtigt,
bei der Programmierung eben auch stark unterschiedliche Ergebnisse hat,
je nachdem ob ich in welcher Reihenfolge ich irgendwelche Überrechnungen durchführe.
Nicht weil es kann eben sein, dass ich also im Worst Case,
also hier irgendwie solche oder solche Auslöschungseffekte habe und dann eben mit diesen stark ungenauen Ergebnissen weiterrechne,
hinterher aber quasi in einer Größenordnung wieder lande,
wo eigentlich die Ausgangszahlen gelegen haben.
Und man dann, also wenn man beispielsweise die Bereiche mathematischen Berechnungen
in anderen Reihenfolgen gemacht hätte, man eigentlich eine höhere Genauigkeit erreicht hätte.
Ich glaube, das ist dann eben eigentlich auch wieder so eine Korns,
wo man sagen muss, das ist etwas,
wo wir dann als Programmierer auch so ein bisschen gefordert sind,
dass man sich einfach erstmal nur für gegenwärtigt
Also irgendwie so Fließkommazahn und so ein Computer, der rechnet nicht
unendlich genau. Und man muss sich da eben schon so
ein bisschen überlegen, was dort eigentlich alles schiefgehen kann.
Und gebenefalls, wie man das dementsprechend dann auch berücksichtigt.
Gut, das war jetzt zu dem Thema Addition und Subtraktion
, wie sieht das aus bei Multiplikation und Division?
Da sieht das eigentlich so aus, dass ich die Mantissen und
die Vorzeichen quasi multipliziere. Bisschenweise, man muss jetzt sagen,
beim Vorzeichen ist es jetzt eigentlich keine Multiplikation,
sondern das Vorzeichen ist ja immer dargestellt als minus 1 hoch das Bild.
Und das Vorzeichen des Ergebnisses ist dann letztendlich nichts anderes,
als also hier so eine relativ einfache logische Operation,
nämlich also exklusiv oder wo ich dann also im Prinzip jetzt eine sage,
wenn beide positive oder beide negative Vorzeichen haben, Nicht,
dann ist das Ergebnis auch wieder ein positives Vorzeichen.
Und wenn beide unterschiedliche Vorzeichen haben,
dann ist das Ergebnis eben auch wieder ein negatives Vorzeichen.
Und das entsprechen dann mathematisch oder mathematisch logisch, dann eigentlich
genau dieser Exklusiv- oder Funktion. Gut, also wie gesagt,
Multiplikation des Vorzeichens eigentlich als sowas. Multiplikation im Mantissen,
das ist dann eben wirklich eine ganz normale Multiplikation von Dualzahlen
und für die Exponenten gilt dann eben entsprechende Additionen und auch hier wieder gegebenenfalls eine Normalisierung.
Das Ganze ist formelmäßig, sondern also letztendlich dann durch sowas dargestellt.
So war der Division eben entsprechend. Das heißt,
hier werden einfach dann die Exponenten voneinander subtrahiert,
die Mantissen geteilt und auch für das Vorzeichen gilt letztendlich dann
diese Regeln
Gut, dann hatte ich ja gesagt, es gibt,
um jetzt in mathematischen Operationen dann eben also auch noch zu berücksichtigen,
dass sie also auf einmal irgendwie den Zahlenbereich verlasse oder dass ich vielleicht also irgendwas beschrieben oder kodiert habe,
was mathematisch Unsinn ist, auch noch entsprechende spezielle Kodierung,
nämlich einmal für Infinity, unendlich,
in der N,
not an number und dann eben für die Null.
Nicht damit kann man dann eben auch in irgendwelchen Ausdrücken oder einen mathematischen Operationen
Letztendlich auch mit diesen Werten erst mal rechnen und weiterrechnen
und muss jetzt nicht nach jeder Teiloperation an also irgendwelche Abfragen machen,
ist das Ergebnis null oder habe ich da jetzt also irgendwie einen ungültigen Start,
dass Müller es auf einmal irgendwo im Unendlichen gelandet.
Gut, Infinity, unendlich, wie gesagt,
ein spezieller Wert für entsprechend sehr groß oder sehr kleine Werte,
die man letztendlich erreichen kann.
Not a number ist sowas wie eine Codierung jetzt für irgendwelche
Operationen, die mathematisch unsinnig sind. Also sprich,
die Wurzel aus negativen Zahlen war,
solange ich da jetzt also nicht irgendwie zu komplexen Zahlen übergehe,
wo sowas dann natürlich wieder funktioniert hervorragend.
Sondern also jetzt hier bei ganz normalen Fließkommazahn bleibe,
ist eben nicht definiert und eben andere Funktionen letztendlich auch,
also was weiß ich,
Arosinus von der Zahl größer als eins und so weiter und so fort.
So,
wie wird das Ganze kodiert
Das ist eigentlich jetzt hier noch mal dargestellt,
die in Anführungszeichen normale, normalisierte Darstellung sieht ja immer so aus,
ich habe hier mal ein Vorzeichenbitt,
dann für den Exponenten ein Wert größer als null und kleiner als die Maximaldarstellbare Zahl.
Das heißt, beispielsweise jetzt beim Datenformat Flot,
alles zwischen 1 und 254 Also,
inklusive, nicht mal die Randbereiche,
wenn es null und bei acht wird dann eben die 255 und hätte dann eben hier hinten,
also im Exponenten und hätte dann eben hier hinten in der Mantesse dann eben irgendwie ein beliebiges Bittmuster.
So, diese Denormalisierten Zahlen sind jetzt dadurch kodiert,
dass der Exponent null ist und ich hier hinten an eben
irgendein Bittmuster Ungleichnull habe.
Damit kann man dann eben noch entsprechend
kleine Zahlen darstellen
Für die dann eben implizit gilt, dass diese implizite Eins,
die sonst eigentlich immer vorhanden ist,
dann auf einmal nicht mehr da ist,
sondern ich dann eben wirklich mit einer entsprechenden kleinen Zahl oder eben hier den jeweiligen Nachkommastellen rechnen würde.
Eine Null wird dadurch kodiert,
dass sowohl Exponenz als auch Mantisse mit Null kodiert sind.
Unendlich hätte ich dann eben hier komplett alles mit Einzeln belegt,
also sprich den jeweils größten Wert,
der dann also für einen Exponenten möglich ist, also sprich 255 bzw. 1023.
Und hier hinten eben für die Mantesse ein Bittenmuster aus
lauter Nullen und die ist not a number,
wäre dann eben hier den lauter Einzeln und hier hinten irgendwas und Leichenanol.
Wie auch immer das aussieht, das ist eigentlich erst mal völlig egal.
Und damit, also mit diesen speziellen Werten kann man dann
eben auch entsprechend teilweise rechnen, was dann manchmal,
also auch wieder dann zu normalen Werten führt.
Also wenn ich jetzt diese irgendwo erst durch unendlich teile,
würde ich dann eben letztendlich hier als Ergebnis null rausbekommen.
Ich muss also nicht zwingend null teilen. Wenn ich mit
Not a Number rechne oder weiter rechne mit irgendwelchen arenomedischen Operationen,
dann wird das Ergebnis eben immer dieses Not a Number bleiben
Auch dazu gibt es dann so ein kleines Beispielprogramm,
den Code habe ich jetzt also hier nicht mit drauf,
aber auch das ist dann eben entsprechend auf der Webseite verfügbar,
womit man dann rechnet, wo dann einige Ergebnisse kommen.
Eine Frage. Gut,
also die Frage war jetzt hier zur zweiten,
beziehungsweise an zur dritten Zeile,
wo ich dann also irgendwas jetzt hier durch null teile,
das Ergebnis ist unendlich
Gut, kann ich jetzt immer nur sagen,
das ist halt im, normal aus dem Mathematik,
kennen wir also irgendwas durch Nullteilen, ist nicht, geht nicht.
In dem Datenformat, also diesem Art-Triple-I 754, ist es eben so definiert,
dass wenn ich irgendwas durch Null teile, ist das Ergebnis unendlich.
Ob ich damit dann also glücklich werde und damit weiterrechnen kann, sei mal dahingestellt. Nicht jedenfalls,
Von daher verhält sich das also,
da war die Frage natürlich richtig dann,
also schon so ein bisschen anders, als wir das jetzt,
also vielleicht so aus der Mathematik gewohnt sind, beziehungsweise,
dass man sagt, okay, also ich bin hier eigentlich,
also bei irgendwie so einem Grenz,
so einer Grenzwertbetrachtung und deswegen hat man gesagt,
also da kommt jetzt nicht Not a Number,
sondern unendlich
raus.
Also, die erste Frage war, oder zwei Fragen,
also die erste Frage war jetzt, was passiert,
wenn ich Infinity durch Infinity teile?
Da würde ich jetzt mal schwer vermuten,
dass dann auch einfach Infinity wieder rauskommt.
Kann man sich auch immer drüber streiten, ob das Sinn macht.
Zugegebenermaßen, also ich müsste es jetzt auch ausprobieren.
Ich würde das einfach jetzt aufgrund dieser, dieses Beispiels hier,
wo ich Infinity durch nicht,
durch Minus-Infinity-Recht und das Ergebnis ist Minus Infinity,
erstmal vermuten
Ansonsten denke ich mal, ja gut,
kann man das vielleicht, also sonst wirklich gleich mal.
Not a number, ja. Gut. Gut. Zwei. Überall auch,
das war gar kein Recht, was wir,
jetzt war 1, 2, 7 Sekunden,
das ist ein Seefrucht, eine Million,
oder so da,
oder da ist eine Effekte
Ähm... Gut, die Frage war jetzt, was würde passieren,
wenn ich also im Prinzip so einen Überlauf habe?
Das heißt, in Zahlenbereich in Richtung große Zahlen verlasse.
Und das, was dann eben passieren würde,
ist letztendlich das Infinity dabei rauskommt. Nicht, das ist,
also wenn ich das hier auf diesen Zahlenstrahl abbilde,
nicht, dann habe ich hier letztendlich positiver Überlauf,
dann also meine Infinity,
hier diese
Unterläufe werden dann also quasi gerundet, letztendlich zu Null.
Und hier wäre dann eben Minus Infinity. Gut,
jetzt bin ich gerade hier natürlich nochmal ein bisschen am Überlegen,
ob wir hier die Zeit haben, weil im Prinzip habe ich den,
also kann ich sonst nachher vielleicht gleich nochmal kurz zeigen.
Also wie gesagt, also das wäre jetzt hier also ein Beispiel,
was jetzt also hier aus dem Programm eben rauskommt,
wo dann eben letztendlich mal dargestellt ist,
wenn es also hier bestimmte arathmetische Operationen stattfinden, was dann das Ergebnis ist,
wo hier eigentlich nur als Anmerkung nochmal eben gesagt ist,
wo man also letztendlich aufpassen muss, ist bei irgendwelchen Vergleichsoperatoren.
Also hier bei dem Arathmetischen, okay, da kann man sich immer streiten,
also wenn ich durch Null teile, lasse ich das überhaupt zu.
Gut, der Standard sagt dann eben,
da kommt ein Infinity raus, beziehungsweise minus Infinity,
Hier bei diesem Vergleichsoperatoren ist es dann aber eben so,
dass ich, wenn ich abfrage, Norddern Number gleich,
Norddern Number, dass daraus eben nicht zwingend too wird,
sondern das Ergebnis kann dann eben falls sein.
Und Infinity größer als Norddern Number. Auch da kann man
eben sagen, auch da wird das Ergebnis falls.
Eine Frage. Norddern Number gleich aus den Numbers,
da gibt es dann wirklich Filme auf Klimatrisse
drauf an
Ob die denn gleich werden. Auch da,
also die Frage war jetzt, also hat jemand mitgedacht?
Nordde Number ist ja im Prinzip etwas, wo ich sage,
ich habe hier ein Vorzeichen-Bit. Ich habe hier für den Exponenten
eine Folge von Eisen und hier irgendein beliebiges Bitmuster und leicht lautern holen.
So, und jetzt ist natürlich die Frage,
wie ist das dann also irgendwie im Standard festgelegt,
beziehungsweise wie ist das dann technisch implementiert? Jetzt kann ich natürlich sagen,
wenn ich also letztendlich diesen Vergleich als wirklichen Identitäts- oder Bitweisevergleich mache,
kann ich natürlich sagen, ja gut, insofern dieses Bitmuster identisch ist,
kann ich hier also auch auf Armatu haben.
Also auch da müsste ich jetzt zugeben,
also auch das wäre eigentlich eine Sache,
die müsste man sich wirklich mal also im Code selber zurechtbauen und überprüfen,
weil auch da kann ich jetzt wieder nur sagen,
also habe ich nur doch immer zu wenig jetzt selber aktiv,
also mit Java und den entsprechenden Tools zu tun,
um zu sagen,
okay,
da passiert immer das und das
Gut, bitte ich, nachsichtig zu sein, weil,
gut, das müsste man ihm wirklich mal ausprobieren. Gut,
ich denke mir,
ich würde das sonst vielleicht nochmal kurz oder dann fürs nächste Mal vorbereiten,
dann also nochmal nachreichen, dann nochmal was zeigen,
beziehungsweise wenn er heute noch sehr weit, sehr weit kommt,
würde ich das, also die letzten zehn Minuten vielleicht mal versuchen,
irgendwie zum Fliegen zu kriegen.
Gut, stellen wir das also erstmal nach hinten.
Dann als Begriff, ULP, Unit and the Last Place.
Das ist im Prinzip ein Maß für die Genauigkeit,
die man eigentlich darstellen kann. Ein praktisch entspricht das eigentlich,
wenn ich also jetzt irgendwie so ein Fließkummer-Format habe,
der niederwärtigsten Darstellungen oder im niederwärtigsten Bit,
was ich letztendlich jetzt in der Mantiste für die Codierung
zur Verfügung habe
Formal gesehen, kann ich eben sagen,
also Unit in the Last Place ist im Prinzip die Differenz zwischen den Buy and Light-Kommerzzahlen,
die jetzt also irgendwo einer gegebenen Zahl am nächsten liegt,
weil das,
was man sich dann ja auch immer vergegenwärtigen muss, ist,
dass ich also mit den Zahlenformaten ja nicht alle beliebigen Werte letztendlich kontinuierlich darstellen kann,
sondern eben auch einschweigende Kodierung eben nur diskrete Werte habe und zwischen zwei darstellbaren Zahlen können eben auch noch beliebig viele nicht darstellbare liegen,
nicht nur mit diesem Unit in the Last Places dann eben gesagt,
letztendlich wie weitweichig damit eigentlich ab.
Nicht rein faktisch ist es aber eben so was wie
das Least Significant Bit, also das niederwärtigste Bittermantis.
So, A-Treppe-I, 754 Format, wird da jetzt eben
quasi eine Genauigkeit von 0,5 ULP für die normalen Operationen gefordert.
Das heißt, wenn ich jetzt Adiresubtariere multipliziere,
dividiere und eine Quadratwurzel berechne, hinterher mein Ergebnis halte,
dass dieses Ergebnis eben um nicht mehr als 0,5 ULP von dem mathematisch richtigen Wert abweicht.
Das heißt im rein praktisch, ich komme gleich auf die Frage zurück. Das heißt dann rein praktisch,
dass wenn ich im Prinzip hier irgendwie so eine Berechnung mache,
dafür gesorgt werden muss, also quasi in den arathmetischen Recheneinheiten,
dass intern teilweise dann auch mit höheren Genauigkeiten gerechnet wird,
weil ich hier, wie man hier zum Beispiel auch sieht,
dann also gegebenenfalls noch wieder irgendeine Normalisierungsschritt machen muss.
Und ich dann also gegebenenfalls, wenn ich zu früh Runde
Stellen wegschneide, daran zu falschen Ergebnissen komme.
Das ist eigentlich das, was die Aussage ist. Hier in diesem Beispiel,
wo das das jetzt im Prinzip ja für ein Dezimalsystem dargestellt ist,
taucht sowas im Prinzip eigentlich auch schon mit auf,
weil hier bei der Angleichung des Exponenten,
hier habe ich die Zahlen mit 3 Nachkommastellen,
hier auch entsprechend auf 3 Nachkommastellen gerundet.
Hier werde angleichendes Exponenten, habe ich hier dann schon eine vierte Nachkommastelle,
mit der ich erstmal quasi so weiterrechne, nicht und irgendwann,
wenn die Exponent, seien wir jetzt zu stark unterschiedlich wären,
müsste ich mich daran eben vielleicht auch noch irgendwo auf eine bestimmte Größenordnung beschränken.
Und anschließend habe ich eben durch die Normalisierung dann eben nochmal so einen zusätzlichen Effekt,
was also in diesem Fall jetzt eben hier ist,
dass ich also hier gut bei den relativ geringen Abweichungen,
also von jetzt hier nur einer Stelle,
dass also hier erstmal mathematisch korrekt durchrechne und hinterher dann eben runde und gut,
also auch im Dualsystem treten dann eben derartige Effekte auf und um jetzt eben diese Genauigkeit von 0,5 ULP zu erreichen,
müssen letztendlich die Rechenwerke dann intern
In den CPUs dann teilweise eben auch noch mehr Stellen für die Mantessen zur Verfügung stellen.
Also es müssen jetzt nicht unendlich viele sein, also ich behaupte mal,
so entsprechende Effekte sollten da eigentlich zwei Stellen genügen,
die da noch irgendwie auftreten können,
aber letztendlich Muss man sich da dann eben auch noch sagen, okay,
also das ist eben das, was sie mit diesen ULP dann gemeint ist.
Gut, also das ist etwas, warum müssen wir uns da nicht kümmern?
Das ist im Standard glücklicherweise irgendwie vorgegeben. Und ich kann jetzt eben sagen,
wenn ich jetzt also quasi solche Fließkommazahlen miteinander verrechne,
kriege ich dann eben auch ein Ergebnis raus,
was hinsichtlich der Genauigkeit, also wirklich das ist,
was ich,
wo dann also nicht vorher schon durch irgendwelche Rundungseffekte was weggegangen ist.
So, jetzt hatte ich noch zwei Zwischenfragen,
eine da hinten
Ich sage, wie die Hälfte von den Terrassentexten,
ist das Wohl nachgeboren. Die zwei. Also wirklich
die letztendlich, die letzte niederwärtigste Stelle der Manteste,
die man dann darstellen kann.
Also die
Naja, die... Also diese 0,5 geht es ja nur darum,
dass, wenn ich,
also letztendlich bei der aratometischen Berechnung irgendwo zwischen zwei Zahlen lande,
dass ich da dann eben eigentlich auch zur richtigen Seite hin nachher gerundet habe.
Also dafür ist das dann eigentlich eine Aussage. Also die
0,5 sind ja dann eigentlich auch immer, also ja,
Unit in the Last Place dann eigentlich auch noch quasi zu skalieren,
mit der Wertigkeit der jeweiligen Stelle in der Mante ist.
Das heißt also beim Float-Format wären das 0,5 mal 2 hoch minus 23.
Bei 23 Stellen, die ich dann quasi nachkomme habe.
Das heißt also letztendlich,
dass ich einfach in einer arthmetischen Operation dort dann zwischenzeitlich
eben noch mit mindestens einer Stelle mehr gerechnet habe,
um da dann richtig diese letzte Stelle richtig runden zu können
Also das ist mit diesen 0,5 ULP gemeint. Das ist jetzt nicht
der arathmetische Wert von 0,5, sondern mit der entsprechenden Wertigkeit noch zu rechnen.
Gut, hier vorne war noch eine Frage, oder hat sich ergeben? Gut. Gut, also wie gesagt, das ist das, was das in dem Standard gefordert wird. Teilweise,
wenn man jetzt also entsprechende mathematischen Pakete nimmt bzw. irgendwelche Bibliotheken,
dann werden eben auch einigermaßen,
zumindest wenn die also richtig gut implementiert sind,
dann eben auch Werte von unter einem ULP eben auch für andere Funktionen mit gewährleistet,
weil das ist ja nun auch immer so eine Sache,
wenn ich jetzt also im Prinzip irgendwo aus einer mathematischen Bibliothek sage,
also ich rechne den Sinus von irgendwas und kriege also irgendwie in die Zahl raus,
das ist immer die Frage, wie genau ist das eigentlich,
weil dieser Sinus dann ja auch durch entsprechende mathematische Nährungsverfahren berechnet wird,
beziehungsweise gut, also bei es sind letztendlich von der Rechnerarchitektur wieder abhängig bei einfachen Sachen,
würde man das über eine Log-Up-Tabelle machen, aber gut,
da kann man dann eben auch sagen.
Also auch für andere Funktionen soll das dann hinreichend genauer sein.
Sowas kann man dann auch teilweise in den Programmiersprachen abfragen,
beziehungsweise da gibt es dann eben auch eben auch diese ohne entsprechende Unterstützung,
also in Java gibt es dann eben auch irgendwie unter Java Lang-Mart-ULP dann eben einen entsprechenden Double-Wert,
der mir da den entsprechenden Wert ausgibt.
Gut, Rundungsfehler, das ist eigentlich das,
was jetzt eben mit diesem ULP einhergeht
Nicht, was dann ja eben auch in der Sprache
oder im Sprachstandard definiert ist. Wie sieht es dann mit
der Rundung von irgendwelchen Ergebnissen bzw. zwischen Ergebnissen aus?
Und ich hoffe, das konnte ich zumindest ein bisschen durch
die Beispiele motivieren. Da ist es eben wirklich essentiell,
dass man da also zwischenzeitlich, also die passenden Genauigkeiten hart,
also sprechen entsprechend viele Stellen bereitstellt und dass man dann eben auch richtig rundet.
Nicht deswegen teilweise Berechnungen mit zusätzlichen Schutzstellen,
hatte ich schon erwähnt. Dadurch kriegt man eben
solche Genauigkeiten hin
Rein mathematisch ist das dann immer alles nicht so ganz trivial.
Deswegen also hier nur als Anmerkung ziemlich komplexe Sache. Nicht glücklicherweise können wir uns dann,
also wir bei vielen anderen Sachen auch erstmal drauf verlassen,
dass es also dann irgendwas ist,
was sie also hoffentlich also aus einer Bibliothek nehme,
was Leute gemacht haben,
die mathematisch entsprechend versiert sind und mich da also jetzt erstmal nicht um wirklich einzelne Details kümmern muss.
Das wird dann eben nur genau dann interessant,
wenn man selber anfangen muss,
also solche Bibliotheken zu entwickeln
Gut, wie sieht das jetzt in der Praxis auf,
Rechnung und auf Computern aus mit den entsprechenden Datentypen dabei,
das, was man ja meistens hat, ist, dass man sagt,
also die Rechner sind also irgendwie für eine bestimmte Wortlänge hin optimiert,
nicht dem zuvorgespricht man eben von 32 Bild, 64 Bit,
16 Bit-Maschinen, was dann letztendlich den elementaren Datentypen bzw. Adressierungsmodi entspricht,
nicht typischerweise, es ist eigentlich irgendwie so die Länge von Entager-Werten,
beziehungsweise dann auch die Art und Weise,
wie Speicher adressiert wird.
Also darauf werde ich dann also in einem Kapitel 13 zum
Assembler dann also auch noch ein bisschen genauer drauf eingehen,
weil da wird uns das Ganze dann eben auch noch ansprechend begegnen.
Gut, sag mal, hier unten steht derzeit Übergang auf
64 Bit-Rechner, das hätte ich auch nochmal ändern sollen.
Also das haben wir inzwischen natürlich schon länger vollzogen. Naja,
sagen wir mal so bis vor fünf Jahren ist man eigentlich
so im Bereich von 32 Bit-Architekturen noch gewesen.
Das heißt also, irgendein Entager-Wert ist eigentlich erstmal irgendwie normal 32 Bit breit.
Und wenn ich dann also irgendwie größere Wortlängen brauche,
gab es dann eben talweise je nach Programmierspar dann eben auch noch entsprechende Datentypen,
die dann das entsprechend bereitstellen konnte.
Was man da dann eben auch hatte, also aufgrund dieser Wortbringe,
dass dann eben eine aggressierbare Speicher 2 hoch 32 weit groß ist.
Typischerweise wird also Hauptspeicher so auf PC oder auf Rechnersystem quasi beidweise adressiert.
Das heißt, da ist dann bei vier GB Schluss.
Nicht inzwischen kann man sagen, na gut,
also die normalen Standardrechner, wenn man sie günstig kauft,
sind mit vier GB Speicher ausgestartet.
Nicht, wenn man also nur nicht das Allereinfachste Schnäppchen Angebot nimmt,
dann sind also eigentlich acht oder noch mehr auch schon Standard.
Nicht deswegen bei 64 Bit Architekturen bzw. Prozessoren und Adressierungsmodi
sind wage ich schon inzwischen,
also schon seit einigen Jahren dabei
Hier nochmal als Anmerkung, ja,
warum ist es hier 1908 mit und 16 mit und sowas alles mit drin,
wo ich typischerweise noch kleinere Wortbreiten habe, ist jetzt eben bei irgendwelchen Embedded-Systemen,
nicht also sprich irgendwelche ganz kleinen Steuerrechner, Mobilgeräte.
Damit meine ich jetzt also nicht das iPhone 6 Plus,
sondern also im Prinzip irgendein anderes kleinen,
was weiß ich, MP3-Player oder so,
gut für MP3-Dekulierung brauche ich dann auch schon ein bisschen mehr Rechenleistung,
aber im Prinzip also irgendwelche ganz einfachen primitiven Geräte,
nicht wo man sagt, okay,
also für die Steuerung der Waschmaschine brauche ich jetzt also kein mehr Kern 64-Bit-Prozesse,
sondern da reicht also irgendwie ein ganz klarer Mikrocontroller,
um da jetzt also quasi die fertigen Sachen abzuarbeiten.
Gut, Datentypen auf Maschinenebene, wenn man sich jetzt anguckt,
was für Datentypen werden jetzt eigentlich irgendwie unterstützt, dann eben auch teilweise noch von welchen Programmiersprachen. Da ist es eben leider so,
dass man auch sagen kann,
Wie ich das eigentlich auch eingangs ja schon sowieso bei diesem A-Triple Y 754-Format gesagt habe,
es ist eben nicht, ich meine,
wir kennen jetzt eigentlich aus der Programmierung für typischerweise natürlich nur so PC-Architekturen,
aber es ist eben nicht gottgegeben und Standard,
dass man sagt,
also der Datentyp ist mit so und so viel Bit kodiert,
sondern das ist dann eben wie diese,
beziehungsweise auch gerade die nächste Folie jetzt sagen wird,
dann eben auch noch sehr stark
Von der Rechnerarchitektur, also sprich von dem Prozessor und des Nähersteller abhängig,
beziehungsweise teilweise sind da also auch noch Abhängigkeiten hinsichtlich Betriebssystem und Compiler mit drin.
Und das ist natürlich also etwas, wo man also besonders schnell reinfahren kann. Also hier nur noch mal aufgezeigt,
also quasi in der Programmiersprache C,
wenn ich also als Datentyp hier habe, Intager,
Long-Intager, Character, Short, Float, Double,
Long-Double und Void, also das ist im Prinzip ein Pointer,
also verweist man die Speicheradresse und dann also hier,
wie viele Bytes das belegt, Deck Alpha,
das war im Prinzip ein Rechner,
der also Anfang der 90er Jahre rausgekommen ist,
also die erste 64-Bit-Architektur implementiert hatte.
Ich bei typischen 32-Bit-Rechnern,
beziehungsweise bei der IA32-Architektur von intern, also das,
was in Anführungszeichen älteren X86-Rechner sind,
habe ich dann eben hier auch nochmal die entsprechenden Werte mit
drauf und da sieht man eben schon,
dass es da teilweise doch Unterschiede gibt
Nicht, also wie lang ist eben ein Long-Entager,
also sprich, in diesem Fall sind das also hier 64 Bit,
hier sind das also ja eben auch erstmal nur 32 Bit.
Und wie sind da die Unterschiede? So,
wenn man das noch ein bisschen genauer aufschlüsselt,
das ist also ein Ausschnitt aus dem ganzen Foliensatz,
den man sich da runterladen kann,
wo das also mal so geschrieben ist.
Und da sieht man eben schon, das ist nämlich jetzt eigentlich das Traurige,
es gibt also da wirklich Abhängigkeiten hinsichtlich des Prozesses hinsichtlich des Betriebssystems und hinsichtlich des Compile Lars.
Und man sieht jetzt eben hier, für 16 Bit,
32 Bit und 64 Bit-Architekturen. Unterschiedliche Compiler,
beziehungsweise damit dann meistens auch oder häufig auch einhergehend unterschiedliche Betriebssysteme und
dann also jetzt hier für die Datentypen, wie viele Bardy umfassen.
Und da sieht man eben teilweise auch schon,
dass es also wirklich einige Fälle gibt,
wo ich dann also sagen kann, okay,
also zum Beispiel jetzt hier beim 64-Bit-Architektur Ja, also im Prinzip Data-Member-Pointer,
dass die also jetzt eben zum Beispiel in der Windows-Welt und in der Linux-Welt,
also schon mal unterschiedlich behandelt werden, teilweise nicht.
Das heißt, wenn es also Wiederabhängigkeiten vom Betriebssystem mit drin,
und, und, und. Also da gibt es relativ viel an Sachen,
wo man sagen kann, also da sollte man eben wirklich erstmal genau nachgucken,
wie es bestimmte Datentypen deren Ober- und Untergrenzen definiert sind,
nicht nur nicht umsonst gibt es dann ja also zu dem,
was wir als Programmierumgebung benutzen.
Also es spricht zu den Compilern und irgendwas, dann also dann eine relativ aufwendige Dokumentation. Nicht,
weil sie früher waren,
dass da irgendwelche Schränke voll mit Büchern, nicht heute,
hat man dann also irgendwo sein 40 Megabyte PDF mit 6000 Seiten,
wo es dann also das Reference Manual für irgendwas ist,
wo dann also wirklich genau beschrieben ist,
wie was implementiert und umgesetzt wird
Gut, das hier eigentlich auch nur noch mal so als
Anmerkung, dass man eben dann aussehen muss.
Also die Sachen sind also nicht Gott gegeben.
Damit ist jetzt eigentlich dieser Teil zu den Zahlendarstellungen soweit beendet.
Und ich würde jetzt also noch mal anfangen,
ein bisschen was zur Art Metik vorzustellen,
beziehungsweise es ist also auch noch mal etwas Wiederholung vom letzten Mal
Wie gesagt, die Folie hatten wir also schon darauf.
Nicht das, womit wir jetzt hier letztendlich erarbeiten.
Stellenwertsystem, so eine Radixdarstellung. Das heißt, ich habe dann
eben hier typischerweise Dualsystem bzw. die Zimalsystem 10 bzw. 2 als Basis.
Und Zahlen werden dann quasi eben alles entsprechende Summe dargestellt.
Jetzt hierfür positive Zahlen, wenn ich jetzt eben Festkomma-Darstellung habe,
hätte ich dann eben hier auch noch irgendwo negative Exponenten mit drin
Gut, wie sieht das dann mit den Datentypen aus,
typischerweise jetzt mal für die Programmiersprachen C, beziehungsweise Java nur kurz aufgelistet,
also bei C kann man, also jetzt zum Beispiel bei Linux-Systemen,
sich das also dann auch immer auf den jeweiligen rechnen, also aus so einer Header-Datei rauslesen.
Das heißt beispielsweise Hahaha. Wenn ich da stehen jetzt also hier zum Beispiel dann eben solche Werte drin,
wie jetzt also sein Charakter minen mag es an seinen Charakter und dann eben für die entsprechenden jeweiligen Datentypen die größten und kleinsten Zahlen entsprechend drin sind,
hier ist ist dann eben beispielsweise auch,
wie man hier dann also sieht,
in so einer Verzwagung sowas mit drin,
ob ich dann quasi auf dem 64-Bit oder auf den 32-Bit-System rechne,
wo dann also quasi jetzt wieder irgendwo woanders in irgendwelchen Systemdateien letztendlich festgelegt wird,
also um was für eine Implementation es sich daran handelt.
Gut, da werden dann also, wird dann,
sag mal, so ein ganzer Wert von irgendwelchen konstanten letztendlich definiert,
was dieses hier also ist,
was man dann also in Sein Programm beispielsweise dann benutzen könnte,
um jetzt eben irgendwie solche Werte abzufragen oder damit also irgendwie entsprechend was zu machen.
Und wie schon gesagt, also das ist dann eben
letztendlich plattformabhängig, weil 32-Pits-System, 64-Pits-System.
Und wenn ich jetzt eben bei irgendeinem Kleinen eingebettet rechne,
also irgendwie zum Beispiel übrigens im Arduino was machen würde,
dann hätte ich da dann eben auch entsprechend wieder ganz andere Werte.
Bei Java ist es ein bisschen einheitlicher,
weil da eben die Zahlenformat dann eben wirklich auch in der Sprache im Sprachstandard,
fix mit vorgegeben sind, was also bei C nämlich nicht der Fall ist.
Und da gibt es dann eben im Prinzip als Werte 16,
32 und 64 Bild.
Zahlendarstellung, dann eben auch typischerweise auch immer als Zweier-Komplimentszahlen.
Und es gibt dann eben noch so was wie Freiparkklassen,
um jetzt also quasi entsprechend kurze Zahlen darzustellen.
Also beispielsweise acht Bit-Unsigned, was dann also sowas
wie von 0 bis 255 wären
Nicht, wo man dann eben sowas hat wie Short,
Entager oder mit Long dann eben also auch entsprechend noch längere Werte hat.
Und dann kann ich dann eben auch über solche Abfragen,
letztendlich das, was also bei CS,
also zum Beispiel in so einer Header-Datei da eben drin war,
dann also jetzt hier mit dem Mittel von Java,
eben hier größte oder kleinste Werte von irgendwelchen Datentypen beispielsweise mir ausgeben lassen.
Und das ist eben bei Java dann anders als in C
letztendlich fest in der Sprache definiert
Gut, hier auch nur noch mal als Wiederholung,
Addition, wie gesagt,
Addition im Dualsystem funktioniert letztendlich genau wie im Dezimalsystem,
Matrix und hier eben dieses entsprechende Beispiel,
das hatte ich also auch vor einer Woche schon lang und bald vorgestellt,
werde ich, also deswegen ist er sich auch nicht mehr genauer machen.
Wenn ich mir jetzt angucke, für einen festen Wertebereich,
was erhalte ich, wenn ich jetzt eben entsprechend innerhalb
dieses Wertebereichs rechne und dann eben eine Addition, Subtraktion,
beziehungsweise mathematische Operationen mache.
Das ist jetzt im Prinzip hier auf dieser Folie beziehungsweise auf
den nächsten Folien dann, also auch nochmal so ein bisschen visualisiert.
Und zwar hier am Beispiel an entsprechend Kleinwortbreite,
nämlich also
vier Bit
Zahlenbereich der Operanten, wenn ich jetzt also Unside-Zahlen habe,
wäre dann eben von null bis zwei RoW minus eins.
Also in diesem Fall dann von null bis 15,
was man dann also hier auch unschwer unten an diesen Skalierung
für X und Y sehen kann. Nicht in das,
was dann also rein mathematischer Ostfolk,
also den größten Wert, den ich erhalten kann,
also beim Ergebnis ist dann zweimal die größte Zahl,
also zweimal zwei hoch wie minus eins,
was dann zwei hoch W plus eins,
minus zwei
letztendlich ist
Bei Unscience-Zahlen, beziehungsweise was man hier dann auch schon sieht,
ist das dann also hier dann letztendlich,
also auch schon die Wortbreite größer geworden ist beim Ergebnis,
nicht vorstellen, also von wie, auf wie Plus As letztendlich gegangen kann.
Ich finde, da stellt sich dann eben schon mal die Frage,
was passiert, wenn ich jetzt eben eine feste Wortbreite habe und das Ganze dann also quasi ab dem Wert 15 abschneide,
dann kann ich sagen, gut, also die einzigen Zahlen,
die ich eigentlich überhaupt noch addieren kann,
ist dann eben,
wären dann eben maximal dann 7 plus 7 hier in dem Ergebnis.
Das heißt, da müssten dann die Operanten dann eben hinreichen,
klar in sein, damit das Ganze dann eben hier noch in einem festen Wertebereich reinpasst.
Und ansonsten hätte ich dann eben auch wieder einen Effekt,
wie man ihn ja noch deutlicher jetzt bei der Unsilent-Arathmetik sieht,
wo ich dann sage,
ich beschränke jetzt nämlich hier die wortbereitete Operanten und auch
die Wortbereitschaft des Resultats
Auf das W, das heißt, solange,
sobald das Resultat eben größer ist,
zwar auch wie minus eins ist,
geht das oberste Bild verloren und das,
was sich hier hinten quasi an Ergebnissen habe,
da fehlt mir nämlich eigentlich dieses eine einzelne Bit,
was dann eigentlich verschwunden ist
Hier, also wie gesagt, diese Grafiken hier waren also aus dem Buch von Brand und Orelleren.
Das hier ist jetzt aus dem, ich wollte gerade sagen,
Kernbaum, nee, das ist also aus irgendeinem anderen Buch.
Hier ist das Ganze aber eben auch nochmal im Prinzip dargestellt,
was letztendlich, also mit diesem Überlauf passiert ist,
dass wenn ich also jetzt mit einer festen Wortbreite wie arbeite,
wie gesagt, Zahnbereich der Operanten ist 0 bis zwar auch wie minus 1,
Resultat kann eben 0 bis 2 auch wie plus 1, minus 2 sein.
Das Ganze wird jetzt aber eben in diesem Wort Wertebereich der Operanten wieder abgebildet,
in das, was dann eben passiert ist, ist,
wenn das Resultat zu groß wird, das Resultat zu groß wird,
dass sich dann eben diesen Überlauf habe und letztendlich dann aber hier wieder in diesem Wertebereich lande,
nicht was im Prinzip dann hier eigentlich dieser Tal hintere Teil hier dieser Grafik letztendlich dann ist,
wenn man das Ganze dann wirklich mal so zweidimensional aufzeichnet.
Gut, das war eigentlich jetzt zur Arathmetik der Addition,
dass man da dann eben sagen muss, okay,
bei einer festen Wortbreite kann ich eben Überlauf haben, Überlauf heißt,
ich habe also auf einmal wieder eine vergleichsweise kleine Zahl,
die aber dann eben nicht mal im Ergebnis entspricht.
Was kann bei der Subtraktion passieren
So praxt so ein Dualsystem. Also auch dieses hier ist quasi einfach analog zur Addition,
wie wir das also auch jetzt beispielsweise dann im Dezimalsystem machen,
ist, dass ich dann eben AVK auch stellenweise die Werte abziehen würde.
Entsprechend Überträge berücksichtige. Das heißt, wenn ich also hier die Zahl 1099 habe,
hier die Zahl 57, die davon abziehen würde,
dass ich dann eben auch hier ganz normal rechnen würde,
wie wir das also eigentlich aus der Schulmathematik im letzten Mar-System haben,
also 1, minus 0 ist null.
1, minus 1 ist null, 1,
minus 0 ist 1 und hier in den Fällen, wie hier,
wo ich dann rechnen müsste, 0, minus 1,
dann ist es dann eben entsprechend 1 und ich habe hier einen Übertrag,
den ich dann also hier nochmal berücksichtigen müsste.
Das wäre jetzt die Überrechnung,
wie wir das eigentlich so an der Tafel auf dem Papier
wie auch immer
machen würden
Art und Weise, wie Computer rechnen, ist jetzt eben genau durch das,
was sich da jetzt eigentlich am Freitag nur vorgestellt habe,
nämlich diese ominösen Einer- und Zweierkomplimente. Das heißt,
da hatte ich also auch schon mal soweit kurz skizziert,
dass man eben sagen kann, also statt zu subtrahieren,
was also dann eigentlich mathematisch diesen Schritten entspricht,
kann ich eben das B-Kompliment addieren,
nicht weil es gilt ja eben immer bei dieser,
oder bei der Bildung, die ist B-Kompliments,
dass ich eben sage,
das Kompliment einer Zahl plus die Zahl ist dann eben gleich
wie hoch en bei einer festen Wortbreite von en Stellen ist eben B hoch en genau nicht mehr mit Endstellen darstellbar.
Das heißt, es ist dann eigentlich genau dieser eine Übertrag,
der vorne rausfällt und das Ergebnis wäre dann letztendlich null.
Dadurch kann ich dann eben dieses B-Kompliment der Zahl
dann als negativen Wert dieser Zahl interpretieren
Nicht, das ist eigentlich der entscheidende Schritt oder die
entscheidende Idee jetzt, also bei diesem B-Kompliment.
Und damit kann ich dann eben rechnen,
wenn ich also rechnen will, also x-minus y,
dass ich dann einfach x plus Zweier-Kompliment von Y rechne.
Ich war es dann eben dazu führt,
dass vorne ich einen Übertrag habe,
der fällt raus an das,
was hinten dann letztendlich überbleibt,
das ist dann
genau mein richtiges Ergebnis
Das ist eigentlich das, was das in diesem Zwei-Kompliment ist.
Beim einer Kompliment habe ich dann eben noch als Offset dieses Plus 1 mit drin.
Macht man sich dann als Trick eigentlich jetzt wieder für die
Bildung des Zweier-Kompliments zunutze, dass ich sage, okay,
B-Kompliment und B-1-Kompliment unterscheiden sich jetzt eben genau um diese eine Stelle.
Also darauf will ich nochmal kurz zu sprechen kommen,
wenn es dann eigentlich um entsprechende technische Realisierung, also sprich,
wie wird ein Additionsschaltnetz technisch aufgebaut, beziehungsweise wenn ich ein Alu habe,
die addieren und subtrahieren soll, baue ich das eben dadurch,
dass ich quasi sowas habe wie eine Alu,
die letztendlich immer nur addieren muss.
Und für die Subtraktion kann man eben sehr einfach
dieses Eins-Kompliment bilden und die plus eins dann dort auch noch
mitgenerieren und dann rechne ich eigentlich immer die ganze Zeit,
also mit diesem B-Kompliment.
Also da werde ich das im Prinzip dann auch nochmal
kurz vorstellen
Gut,
wie sieht das da jetzt bei den Wertebereichen aus,
wenn ich jetzt also wirklich mit Zahlen Zahlen rechne,
also auch hier ist das Ganze jetzt nochmal so ein bisschen visualisiert,
also diese Falls, also auch hier für das Zweier-Kompliment,
weil das ist also in der Regel auch das,
was wir also immer als Zahlen-Darstellung im Computer zu sehen bekommen.
Auch dieses jetzt hier also für dieses Beispiel 4Bit Wortbreite.
Der Zahnbereich der Operanten geht dann eben von minus 2W
Bis 2 auf W-minus 1, minus 1. Das heißt,
bei Feebit Wortbreite hätte ich Zahlen von minus 8 bis plus 7. Also.
Und das Ergebnis kann dann eben sein,
zweimal die größte negative Zahl wäre also minus 2 auch W-minus 1,
plus minus 2 auf W-minus 1,
ist minus 2 auf
Im negativen Bereich, im positiven Bereich zweimal diese Zahl ist zwar auch wie minus zwei.
Wenn ich auch hier jetzt wieder eine feste Wortbreite ansetze,
habe ich demzufolge die Möglichkeit,
also einmal hier sowas wie einen positiven Überlauf zu haben,
weil das kann ich letztendlich nicht mehr darstellen,
wenn ich in meinem Wort Wertebereich bleibe und ich habe eben
genauso gut hier dann eben auch einen negativen Überlauf,
weil ich da
auch nichts
Darstellen kann. Das heißt also,
hier in dieser Grafik dargestellt ist dann eben letztendlich das,
wo ich sage, also hier in diesem mittleren Bereich,
das sind jetzt eben die normalen Zahlen,
mit denen ich also jetzt arathmetisch rechnen kann und da war den Wertebereich nicht verlasse.
Nicht, wenn ich zwei zu große positive Zahlen addiere,
habe ich auf einmal eine Zahl,
die ich nicht mehr darstellen kann.
Dann habe ich dann eben hier einen positiven Überlauf,
wenn ich zwei zu große negative Zahlen addiere,
hätte ich eben einen negativen Überlauf.
Das ist dann eben das,
was hiermit dargestellt wird
Nicht auch das hier nur noch mal in einer anderen Darstellung,
ohne wo ich dann eben auch sage, okay,
also hier in diesem mittleren Bereich abgebildet wird,
dass er eben wieder auf diesen Bereich hinsichtlich dieser Wortbreite und hier habe ich jetzt dann eben auf Arme einen negativen Überlauf und das,
was dort dann passiert ist,
dass sie also auf einmal als Ergebnis eine positive Zahl erhalte,
beziehungsweise wenn ich einen positiven Überlauf habe,
das heißt also meinetwegen jetzt bei Vierbit-Darstellung rechnen würde,
7 plus 7, Arathmetisches Ergehergebnisses 14,
kann ich in dieser Zahlenkodierung dann mit 4-Bit Scient nicht mehr darstellen.
Es ist auf einmal eine negative Zahl. Das heißt,
da landet dieser positive Überlauf hier auf einmal in den negativen Zahlen.
Das ist das, was mit diesen gekreuzten Dunkel beziehungsweise hellgrauen
fallen dann eigentlich damit veranschaulicht ist. Gut,
wie kann man den Überlauf erkennen,
Rein praktisch könnte ich dann eigentlich jetzt also immer,
oder müsste ich da dann eben wirklich unterscheiden und abfragen,
wie verhalten sich die Vorzeichen der Zahlen vor und nach der harametischen Operation.
Das heißt, wenn beide Operanten das gleiche Vorzeichen haben und
ich stelle das auf einmal ein Ergebnis habe, was ein anderes Vorzeichen hat.
Das ist nämlich genau dieser Fall. Ich habe hier also
irgendwie positive Werte, bin hier auf einmal zu groß geworden. Das,
was sich als Ergebnis erhalte, ist der Interpretation der Zahlenkodierung eine negative Zahl,
beziehungsweise umgekehrt, ich hätte jetzt hier zwei negative Zahlen,
die ich addiere und erhalte dann also auf einmal als Ergebnis eine positive Zahl.
Das ist eben das, wie man dann also einen Überlauf erkennen würde.
In der Programmiersprache Java würde ich das beispielsweise dadurch machen,
dass ich dann eben im Prinzip so rechne,
A plus B, Ergebnisergebnisse, also quasi mal eine Summe.
Das sind also jetzt die jeweils Scient Zahlen, 32 Bittbreit.
Und ihm dieser bulte Wert für den Überlauf würde sich quasi aus diesem Ausdruck heraus ergeben,
wo ich dann nämlich quasi hier mit dem vorderen Teil Abfrage,
ob beide Operanten das Gleiche Vorzeichen haben,
nämlich dass Aquana null ist, beziehungsweise B-Klanur,
dem zuvor hätte ich dann also hier Bulsche Werte,
Kombinationen, die ich dann also abfrage,
entweder sind beide negativ oder beide positiv und mit dieser Abfrage hätte ich dann eben quasi eine Bulsche Bedingung,
wo ich dann eben rausbekomme.
Beide haben das gleiche Vorzeichen und das Ergebnis hat jetzt hier
also auf einmal ein anderes Vorzeichen als Einer der beiden Operanten,
welche auch immer, in diesem Fall SA genommen worden.
Und wenn dieser Ausdruck wahr wird, hätte ich dann eben hier
einen entsprechenden Überlauf erkannt. Also auch das kann man dann
einfach mal an Beispielen machen bzw. kodieren. Denken wir,
dazu werden sie dann später auch noch ein bisschen was sehen.
Gut, damit werde ich dann für heute Schluss machen.
Und ja,
das passt ganz gut
Nächstes Mal, also sprich am Freitag,
würde ich dann also nochmal kleine praktische Demos zu diesem North
and Number Beispiel vorbereitet haben und dann entsprechend mit
den Unterlagen weitermachen