So, bevor ich jetzt mit dem Stoff, also in diesem Fall jetzt mit Gleitkommazahlen weitermache, nochmal eine kurze Information beziehungsweise Ansage. Und zwar haben wir,
oder gibt es, also jetzt neben dem Tutorium,
ich weiß jetzt nicht, inwieweit das von Ihnen jetzt angenommen oder nachgefragt wird,
was ja so im Prinzip immer Donnerstagabend letztendlich stattfindet,
noch eine zweite Möglichkeit, wenn jetzt irgendwelcher Stoff außer Vorlesung Und klar ist,
vielleicht nochmal nachgefragt werden soll,
wofür es in den Übungsgruppen keine Zeit ist oder wenn es jetzt eben auch um weitere Inhalte aus den Übungsgruppen oder in Übungsaufgaben gibt,
eben noch eine weitere Möglichkeit, dass einem dort geholfen wird,
beziehungsweise in diesem Fall jetzt speziell für die Erstsemester.
Und zwar hat die Fachschaft eine sogenannte Post-OE-Orientierungseinheit ausgerufen.
Und wenn man das also entsprechend also auf den Fachschaftsseiten sich ansieht,
sind dort dann also nochmal entsprechende Termine angegeben,
beziehungsweise Links und Mail-Adressen und man kann sich dann eben direkt auch noch mal an die Fahrschaft wenden.
Das heißt, wenn jetzt eben noch mal irgendwelche weitere Unterstützung benötigt wird. Gut,
also wie gesagt, das jetzt auch noch mal als zusätzliche Information,
speziell Angebot jetzt eben für Erstsemesterstudenten, dass man dort dann eben noch was weiteres hat.
Gut, ansonsten, ich hatte ja letzten Freitag im Prinzip
aufgehört mit der Vorstellung von Gleitkommazahlen, wofür man das überhaupt braucht.
Und kurz skizziert, wie im Prinzip solche Gleitkommazahlen aufgebaut sind,
also sprich, es ist eine halblogarhythmische Darstellung,
wo man halt eben sagt, ich habe eine Mantise,
das heißt also jetzt irgendwie eine normale Zahl mit Komma und irgendwie einen begrenzten Stellenbereich.
Und dann habe ich dann eben hier noch deswegen jetzt eben Halblogger,
und da stand eben noch Basishochexponent, dann eben die Möglichkeit,
diesen Zahlenbereich dann eben entsprechend wieder in Richtung sehr großer oder sehr kleiner Zahlen zu erweitern.
Und in den üblichen Zahlen Formaten sieht das dann eben so aus,
dass man das Vorzeichen extra kodiert. Das heißt also,
anders bei dem, was sich jetzt also vorvorgestellt hatte,
wo es jetzt im Prinzip bei ganz zahligen Zahlenbereichen,
wo man dann typischerweise B oder B minus Eins-Kompliment verwendet,
hat man hier dann eben so eine explizite Codierung des Vorzeichens.
Gut, die Folie hatte ich also auch als letztes dann soweit noch aufgelegt,
dass es quasi die Art und Weise,
wie man sich so eine Zahl dann vorstellt,
Schreibweise, nicht typischerweise, das ist also das,
was man so aus der Schulmathematik kennt,
jetzt also für das Dezilmalsystem.
Und entsprechend hat man jetzt also in den Programmiersprachen dann eben auch diese übliche Schreibweise,
also irgendwas Vorkommerstellen, Punkt, dann eben irgendwelche Nahkommastellen.
Und dann eben in diesem Fall zur Basis 10 hoch irgendwas.
Das ist also die Art und Weise,
wie man jetzt eben entsprechend in Programmiersprachen Klarkommastellen eingibt.
Intern bei der internen Repräsentation im Computer Sind diese Zahlen dann
logischerweise natürlich nicht mehr zur Basisszene, sondern werden dann also irgendwie anders zur Basis 2 abgebildet.
Das wurde dann also gleich im Folgenden noch vorgestellt. Generell,
wenn ich jetzt also quasi jetzt im Dezimasystem bleibe,
sieht man also hier nochmal, wie sich eigentlich so die Zahlenbereiche verändern,
abhängig von der Anzahl der Stellen für die Mantiste bzw. für den Exponenten.
Negative Zahlen, wie gesagt, werden durch ein explizites Vorzeichen,
unabhängig davon gekennzeichnet. Da kann man eben sagen, wenn ich jetzt,
dass ich jetzt zum Beispiel drei Stellen für die Mantise,
ein für einen Exponenten habe,
hätte ich jetzt also ein Dezimalsystem quasi als größten Exponenten,
den ich angeben kann, dann letztendlich, also 10.09 Uhr,
nämlich genau diese eine Stelle.
Wenn ich zwei Stellen habe, 10.99 Uhr und so weiter und so fort,
in Richtung auf die Null hin,
hat man dann eben im Prinzip dann bis 10 Uhr minus
eins und dann eben die Anzahl erstellen und hinzu kommen dann eben noch entsprechend der Stellenanzahl in der Martiste, dann zusätzliche Stellen.
Ja, und so sieht man,
wie jetzt also quasi für so ein Dezimarsystem entsprechend die Zahlenbereiche aussehen würden,
wo man dann eben sagen kann, also je nachdem,
wie viele Stellen ich dann hier habe,
habe ich dann eben zum einen unterschiedlich große Zahlenbereiche und ansonsten war es jetzt also hier nicht explizit draufsteht,
was aber eigentlich also aus der Art und Weise,
wie Leitkommer-Zahlen gebildet wäre, natürlich klar wird,
die Genauigkeit ist dann natürlich von den Stellen der Mantise abhängig,
nicht.
Das heißt, je mehr Stellen ich dort darstellen kann,
umso genauer werden meine Zahlen. Und quasi über den Exponenten
skaliere ich dann eben letztendlich nochmal den Wertebereich in der Breite.
Hier auch nochmal kurz gesagt, Gleitkomma-Historie, wie hat sich das entwickelt? Also im Prinzip der erste,
damals ja noch mit Relais betriebene Rechner von Konrad Zuse,
hat also im Prinzip schon sowas wie so eine Art 22-Bitgleitkomma-Datenformat in den 50er Jahren hatten dann die Hersteller der damaligen Großrechnern,
also sehr viele sehr unterschiedliche Zahlenformate bzw. Zahlendarstellungen für Gleitkommaberechnungen,
dann quasi mit dem Aufkommen des PCs,
das hatte ich also auch schon kurz bei diesem historischen Einblick angesprochen,
war es halt so,
dass ursprünglich die Prozessoren eben noch keine Glatkomma-Rechnungen machen konnten.
Das heißt, man konnte natürlich in seinem Programm irgendwie sowas wie Gleitkomma benutzen,
wurde dann aber hardwaremäßig letztendlich über, ich sag jetzt mal,
Bibliotheken unter Programm Aufruferoutinen dann eben auf der Endager-Einheit gerechnet.
1980 gab es dann quasi für den 80,
86 noch so einen Co-Proprozessor-Chip. Das heißt,
da hatte man damals auf den Motherboards dann eben noch so einen zusätzlichen freien Sorkel,
wo man dann also jetzt eben neben der CPU dann auch diesen Co-Prozessor reinsetzen konnte.
Das hat sich dann im Prinzip bis zum 80,
3, 86 Prozesse immer genauso durchgezogen.
1989 mit dem 4,86 sind dann im Prinzip die Gleitkomma-Recheneinheit dann
eben auch wirklich in den eigentlichen Prozessen mit reingewandert
Wenn ich damals so das Erste,
was man da so hatte, wie gesagt, 45.000 Transistoren,
das sind also irgendwie so Dimensionen, wo man sagt,
na gut, also das können wir heute mit irgendwelchen kleinen,
programmierbaren Bausteinen in irgendwelchen Studentenprojekten,
also innerhalb von ein paar Übungsaufgaben letztendlich machen, sowas zu entwerfen,
von der Komplexität her, nicht Leitkomma, Rechenleistung,
wird häufig dann nochmal angegeben in diesen berühmten Floating Point Operations per Seconds,
nicht 50 Kilo Flops, gut, da muss man sagen,
also inzwischen sind die High-End, Großrechner,
also ich hatte ja diese Top 500 Liste mal da liegen,
also irgendwie so im Bereich von mehreren Petter-Flops, nicht das,
was dann also hier irgendwie so Terraflop ist,
zumindest bei Einfachergenauigkeit, das machen heute die, ich sag mal,
so etwas besseren Grafikkarten von der fließkommerrechen Leistung nicht,
also da sieht man schon, wie sich das entwickelt hat,
also wo ich sage, okay,
also heute so eine etwas schickere Grafikkarte ist man also deutlich über der Rechenleistung,
was also 1996 quasi der Top-1-Rechner der Welt war,
nämlich mit 9.152 Prozessoren.
Das ist dann also auch nochmal so ein Beispiel,
wie sich da eigentlich so entsprechend Moore Slaw das Ganze entwickelt hat.
Gut, aber jetzt wieder zurück auf diese Zahlenbereiche. Generell sieht das immer so,
Entschuldigung, sieht das immer so aus,
dass man sich das eigentlich vorstellen muss,
wie das also hier also auf diesem Strahl,
also der jetzt also aus dem Buch von Tarnbaum rausgenommen ist,
aufgebaut ist.
Letztendlich symmetrisch zur Null, hier negative, hier positive Zahlenbereiche.
Ich habe irgendwo die Null. Ich habe einen Bereich
darstellbarer Zahlen. Irgendwann verlasse ich diesen Bereich,
dann habe ich sowas wie einen positiven Überlauf und irgendwann,
wenn ich nah genug an die Null rangehe,
kann ich das eben auch nicht darstellen.
Da nennt sich das dann eben positiver Unterlauf und genau das Gleiche dann eben auch für die negativen Zahlen.
Was hier auch so ein bisschen angedeutet ist, ist,
dass die Zahlenbereiche bei Fließkommazahlen oder bei Fließkommazahlendarstellungen.
Immer so sind, dass der relative Abstand benachbarter Zahlen zueinander immer gleich ist. Bei Integration-Zahlen gilt das nicht,
wenn ich sage,
also zwischen 0 und 1 habe ich einen Unterschied von 1,
zwischen 2 und 3 habe ich einen Unterschied von 1. Zwischen 65.5035 und 65.506,
da habe ich auch einen Unterschied von 1. Relativ gesehen,
das heißt,
wenn ich das jetzt immer durch die Zahl teile,
habe ich hier einen sehr kleinen Unterschied und hier einen
vergleichsweise großen
Bei Gleitkomma zahlen sie das eben anders aus,
heißt aber auch im Umkehrschluss, das,
was also hier so ein bisschen angedeutet ist, durch diese gepunkteten Linien,
dass man natürlich bei entsprechend großen positiven Zahlen einfach dadurch,
dass sich dann ja zum Beispiel als Zahl dann also irgendwie sowas habe wie 6,02,
3 mal 10 oder 23 mit irgendeiner begrenzten Anzahl von Nachkommastellen,
dann eben auch einen ganzen Satz von Zahlen habe,
den ich einfach in dieser Genauigkeit nicht mehr darstellen kann.
Das heißt, zwischen den einzelnen Zahlen,
wenn ich die jetzt also quasi mäßig abzählen würde,
als ganze Zahlen, gibt es dann eben immer größer werdende Lücken.
Das ist im Prinzip das, was also hier mit
dieser Grafik so ein bisschen visualisiert sein soll.
Gut, was man da noch braucht für die Gleitkommandardarstellung,
ist also der Begriff der normalisierten Darstellung,
weil generell kann man erst mal sagen, ist so eine Darstellung nicht eindeutig.
Ich kann also schreiben, 123 mal 10 hoch 0,
ist 123. Ich kann auch schreiben,
12,3 mal 10 hoch 1 oder 1,23 mal 10 hoch 2,
also mal 100 und so weiter und so fort
Normalisierte Darstellung heißt, eine Darstellung,
wo die Exponenten so angepasst werden,
also sprich die Zahl so verschoben wird,
dass die Mantise im Bereich von 1 bis zur Basis liegt.
Dann habe ich im Prinzip eine eindeutige Darstellung,
rein praktisch kann man sagen, ich habe eine einzige Vorkommerstelle.
Sprich, die normalisierte Darstellung in diesem Fall wäre hier,
die 1,23,
mal 10 noch
Im Dezimalsystem, bei Basis 10,
würde das dann eben quasi gehen bis 9,9 und dann irgendwas.
Nicht, wenn ich eine 10 hätte,
würde ich die entsprechend schieben und hätte dann wieder eins,
komm mal irgendwas. So, im Dualsystem,
und da kommt jetzt also noch ein Trick bei der Darstellung oder Fleiß,
der Fließkommazahlen hinzu, habe ich bei normalisierten Zahlen,
weil ich ja quasi nur 0 oder eins habe,
vorm Komma immer
Ich weil jede Zahl wird einfach so lange nach links und nach rechts verschoben,
bis ich eben eine einzelne eins habe,
die dann letztendlich vorm Komma ist.
Bei den Standardzahlen-Darstellungen gibt es dann eben noch zusätzlich sehr kleine,
nicht normalisierte Zahlen, wird nachher also auch noch ein bisschen vorgestellt,
wie, sagen wir mal so,
die Standard genormte Zahlendarstellung in Computersystemen aussehen wird.
Stichwort dazu ist A-Triple
Kann man sich unter anderem, also in irgendwelchen Wikipedia-Artikeln ansehen.
Und was also auch immer noch ein guter Tipp ist,
was ich hier dann also auch auf der Literaturliste habe,
von dem Herrn Goldberg,
was man sich dann nämlich als PDF und umsonst runterladen kann,
whatevery computer scientist,
should know about floating point.
Also ein
relativ bekannter Artikel,
1991 geschrieben
Es ist, sagen wir jetzt also nicht so,
dass man das jetzt mal eben schnell durchliest,
weil das sind also auch irgendwie knapp 100 Seiten.
Ist aber eigentlich ganz gut, weil wirklich die Art und Weise,
wie die Zahndarstellung funktionieren, wie Zahlen repräsentiert werden,
welche Probleme es geben kann. Also hinsichtlich Stellenauslöschung, atmetischen Ungenauigkeiten,
wie letztendlich Rundungsverfahren funktionieren wird, dort also relativ genau dargestellt.
Also ich werde das jetzt hier nur mal kurz immer mal mit ein,
zwei Beispielen beleuchten, was es da im Prinzip geben kann,
aber nicht weiter ins Detail gehen. Ich weiß auch nicht,
in Wörter ist jetzt also bei der Softwareentwicklung dann vielleicht noch ein bisschen weiter vertieft wird,
aber das sind eben nur nochmal Sachen,
wo ich jetzt sagen würde, nur als Tipp,
da kann man dann eben nochmal entsprechend nachgucken.
Gut, wie gesagt, bis das Ganze quasi international standardisiert wurde,
war es eben so, dass es im Prinzip Eine sehr große Anzahl von unterschiedlichen Darstellungsformaten gab,
mit unterschiedlichen Anzahl von Bits innerhalb der Mantise oder des Exponenten.
Die Exponenten hatten dann auch sehr viele sehr unterschiedliche Zahlenbasen,
also 2 oder 16, okay, das ist jetzt das, womit wir typischerweise arbeiten.
Früher war es häufig so, dass in der Computerrhythmetik eigentlich dadurch,
dass das letztendlich vom menschlichen Rechnen abgeleitet wurde,
dann häufig also irgendwie Zahlen zur Basis 10 dann also auch noch irgendwie genommen wurden.
Daher kommen dann also auch immer noch so einige Sachen,
was nachher also auch noch in einigen Beispielen in einem anderen Kontext dann auftaucht,
wo man dann also quasi Zahlendarstellungen auch immer so als Bahnrecorded Desimal,
also PCD-Darstellungen hat,
wo ich dann also quasi dann immer die Werte von 0 bis 9 kodiere und dann sage,
das ist dann eben eine Stelle in so einem Dezimalsystem.
Ja, dann gab es sehr viele sehr unterschiedliche Algorithmen zur
Rundung und letztendlich hatte dann also jeder Hersteller von Computersystemen,
sei das IBM, sei das wer auch immer gewesen,
AT&T und so weiter, also dann sehr, sehr, sehr unterschiedliche erfahren.
Nachteil von dem Ganzen war dann eben,
dass wenn man jetzt also quasi einen Algorithmus geschrieben oder programmiert hatte,
der lief auf einem System,
man hat quasi jetzt den Code genommen auf ein anderes System portiert,
dort übersetzt, wollte es dort laufen lassen, das Ding rechnete anders.
Das sind eben Sachen, wo wir sagen,
na gut, also inzwischen sind wir das gewohnt,
es gibt so einen Standard und die Rechner halten sich im Großen und Ganzen dran,
wobei ich da also auch gleich noch kurz darauf eingehen werde,
dass also auch immer ein bisschen mit Vorsicht zu genießen ist
Das war früher eben wirklich überhaupt nicht so. Gut,
seinen 1985 gibt es eben diesen Art-Triple-E 754-Standard,
wo dann eben letztendlich festgelegt ist, wie Fließkomma-Formate aussehen,
wie gerundet werden kann und so weiter.
Inzwischen gibt es dort also auch noch sehr viele weitere Standardisierungen für Fließkomma-Formate,
also das, was ich jetzt kurz vorstelle,
sind für 32 Bit und für 64 Bit-Wortlänge
Inzwischen international standardisiert gibt es eben auch noch kürzere,
beziehungsweise längere Zahlen,
beziehungsweise es gibt ja dann jetzt also auch noch ein anderer Bereich,
also gerade jetzt so im Bereich Parallelcomputing und Deep Learning hat man teilweise sowas wie irgendwelche 8-Bit-Fließkomma-Formate,
weil man da also nur eine relativ geringe Genauigkeit braucht.
Also auch da gibt es Sachen für größere Geneuigkeiten bis 256-Bit
gibt es da also auch was. Wie gesagt,
das kann man sich dann also hier zum Beispiel,
also irgendwo in der Wikipedia entsprechend nachsehen,
wo das Ganze dann eben entsprechend beschrieben ist,
die unterschiedlichen Formate,
wie die aufgebaut sind,
welche Rundungen es da gibt und so weiter und so
Gut, hier die Standardformate nur grob vorgestellt. 32-Bit-Format,
auch im Englischen immer Single Precision genannt, beziehungsweise als Standarddatentyp
in C wäre das dann sowas wie ein Float im Deutschen.
Einfache Genauigkeit, die 32-Bit sind eben so unterteilt,
dass ich ein Bit für das Vorzeichen habe,
8-Bit für einen Exponenten und 23-Bit bleiben dann eben noch von Limantisse.
Bei doppelter Genauigkeit, 1964 bedaten Wort, hat man elf Bit von Exponenten,
52 Bit für die Mantesse und wie gesagt an das Vorzeichenbett.
Die Mattise wird dann eben als normalisierte Dualzahl dargestellt,
wobei man da dann eben auch noch den Trinken macht,
wird ich gleich noch zeigen,
dass man eben diese eine erste 1 vor dem Komma
dort auch nicht mitkodiert,
dadurch gewinnt man dann nämlich auch nochmal
eine zusätzliche Stelle
Der Exponent ist dann in so einer Access-Darstellung dargestellt,
Access 1927, beziehungsweise bei 64 Bit, Access 1023. Das heißt,
man hat eine Enteger-Zahl und muss dann die 127 abziehen,
um dann quasi jetzt bei einer Flot-Zahl dann letztendlich zum Exponenten zu kommen.
So, und dann gibt es eben auch noch
spezielle Kodierungen für die Null und für die beiden Werte
Not a Number und Infinity
Wie die aussehen,
wie man damit dann zum Beispiel auch rechnen würde,
was das dann also auch teilweise für Auswirkungen hat,
werde ich also heute sicherlich auch mal vorstellen.
Gut, hier für die beiden Art Rebely-Zahlen, Fließkommazahlen,
die entsprechenden Zahlenbereiche. Ich also hier noch Marco zusammengefasst,
Exponentensystem, der Exponentenbereich ist dann festgelegt bei der einfachen Geneuigkeit von minus 126 plus 127.
Hier eben von minus 1022 bis plus 123. Dann habe ich
hier die jeweils kleinste darstellbare Zahl jetzt in normalisierter Form.
Dann gibt es noch sogenannte nicht normalisierte Zahlen, wie die aussehen.
Werde ich dann nämlich auch gleich zeigen. Sprich,
wenn man dann nämlich den einen maximal größten Exponenten hat,
weil hier sieht man also im Prinzip,
fällt dann nämlich da noch was weg
Hier dann so ungefähr ungerechnet,
dann also letztendlich der entsprechende Bereich,
wenn ich das jetzt in Dezimalstellen umsetzen würde,
das heißt also mit einer einfachen Geneuigkeit kommt man also bis maximal so in den Bereich 10 hoch,
38, beziehungsweise 10 Uhr minus 38 ist dann das,
wo man dann quasi noch als kleinste Zahl an die Null ungefähr rankommt.
Gut, bei nicht normalisierten Zahlen geht das Ganze dann eben noch entsprechend weiter,
in diesem Fall dann also quasi um 23 Stellen,
wodurch sich dann also die zusätzlichen,
der Zusätzlichebereich dann ergibt
Gut, wie sehen solche Zahlen aus? Ist hier jetzt mal gezeigt,
dass es im Prinzip also auch aus dem Material war es also mal geschrieben wurde,
um jetzt also quasi ein interaktives Lehrmedium zu machen,
setzt in dem Fall jetzt also auf Madlab auf,
was ich jetzt also hier nicht installiert und laufen habe.
Deswegen werde ich das jetzt also hier nicht live vorführen,
sagen wir ansonsten ähnliche Teile oder irgendwas Äquivalentes, findet man aber auch,
wenn man also im Prinzip ein bisschen sucht, im Internet,
wo man sich sowas mal so ein bisschen ansehen kann.
Grundidee ist,
dass man eben hier letztendlich sagt,
also ich kann hier sowas wie irgendwie eine Zahl eingeben und
kriege dann eben in diesem I-Tripley-Format entweder jetzt für eine 32-Bit
oder für eine 64-Bit-Darstellung dann eben die entsprechenden Wert und hier
sind dann eben die einzelnen Felder der Zahl und was hier dann eben auch schon quasi mit angedeutet ist, ist,
dass diese Vorkommer 1, wenn ich jetzt eine normalisierte Zahl habe, letztendlich ja immer da ist.
Deswegen wird die dann eben quasi nicht mitkodiert in der Mantise und die 23 Bit,
die ich also hier jetzt für die Mantise noch übrig habe,
wären dann also quasi komplett für Nachkommastellen verwendet.
Gut, Leiches kann man dann eben auch entsprechend für doppelte Genauigkeit machen,
also 64 Bezahlen, wo man dann eben sagen kann,
also ich habe hier quasi meine entsprechenden Genauigkeiten,
also quasi die 52 Bitch für die Nachkommastellen, dieses implizite zusätzliche Bit.
Das entspricht dann eben ungefähr einer Genauigkeit von 16 Dezimalstellen.
Wenn ich jetzt also quasi in dezimal rechnen würde. So,
woraus ergibt sich jetzt diese Zuordnung, dass ich sage,
also hier diese 53 Bit entsprechen ungefähr 16 Dezimalstellen?
Einfach, wenn ich jetzt also über die Zahnsysteme das Ganze umrechne,
also ich muss jetzt quasi sagen, also hier Logarithmus,
du alles von
Ist ungefähr 3,32, 2. Das heißt, wenn ich hier 53
dadurch teile, erhalte ich eben sowas um 16 beziehungsweise umgekehrt.
Also dadurch ergibt sich dann letztendlich diese Aussage. Gut,
wie sehen jetzt solche Zahlen aus? Hier jetzt also wirklich
nochmal so ein bisschen im Beispiel gezeigt. Ich war,
wie gesagt, also das Verständnis dieser Zahlen ist dann eben
auch was, was dann also beispielsweise dann auch nochmals,
also für die aktuellen Übungsaufgaben mitkommen soll.
In diesem Fall jetzt für 32 Bitfloats
Hier nochmal dargestellt, wie die Zahl letztendlich aussieht, sein wird.
Acht Bit für den Exponenten, da das so eine Exzess
127 Darstellung ist, gilt quasi zwei hoch Exponent minus 127.
Und für die Mantissa habe ich dann eben 1, und dann eben die 23 Stellen,
die sich dann also quasi dort dann als Nachkommastellen ergeben.
So, das heißt, wenn ich jetzt also diese diesen String
aus 32 Bit nehme und sage, okay, welcher Zahl würde das entsprechen?
Muss man jetzt eben einfach ganz stumpf frechen und sagen,
okay, also das ist am weitesten links stehende Bitch,
das Vorzeichen, was weiß ich,
schon so ein bisschen durch so eine Lücke abgetrennt ist,
ist jetzt eben ein Vorzeichen in diesem Fall,
also wenn da eine Eins steht, negatives Vorzeichen,
dann habe ich hier als Binärzahl in den Achtbit 128 War eine Exzessin 127 Darstellung demzufolge,
bleibt dann da eine Eins über, also zwei Hocheins,
also minus eins,
mal zwei.
Und dann habe ich hier meine explizite Eins und dann eben an Nachkommastellen,
zwei Uhr minus eins, zwei, minus zwei,
zwei, hominus drei, also eins plus 0,5 plus 0,0,
2,5 plus 0,01,
2,5 und der Rest ist dann also hier lauter Nullen.
Das heißt,
diese Zahl ist eine minus
Also das ist die Art und Weise,
wie man jetzt aus so einem Witz dringend A-Triple,
i754 Darstellung letztendlich die Engaged-Zahl wieder rausrechnen würde.
Zweites Beispiel. Hier, null, eine positive Zahl.
Hier habe ich jetzt 254, minus 127. Das heißt,
der Exponent wäre 2 hoch 127, mal die 1,
die ich quasi jetzt immer über die Normalisierung habe und dann,
minus 1,
minus 2,
minus 3,
plus 2 hoch minus
Plus 2, minus 7 plus 2, minus 8 wäre dann zusammengerechnet.
Indezimaldarstellung dann eben diese 1,95 und so weiter,
damals hier noch 38. Gut, hier nochmal zwei weitere Beispiele,
hier ist mir ihm eine sehr kleine Zahl,
Exponent 1, minus 127, also 2,
humminus 126 mal die explizite 1,
hier nur lauter Nullen
Wäre dann also 2 hoch minus 126. Ich finde,
wenn man das jetzt also irgendwie endezimal umrechnet, würde man da eben ungefähr jetzt,
also gut abhängig von der Genauigkeit, dann eben irgendwie was Entsprechendes rauskriegen. Gut,
das ist also die Art und Weise,
wie man jetzt also aus dieser Kodierung den entsprechenden Dezimalzahlenwert ausrechnet,
beziehungsweise andersrum, wenn sie es also quasi in irgendeinem Programm schreiben,
6,023 mal 10 hoch 23, was der Compiler dann draus macht,
um das Ganze dann eben quasi jetzt intern irgendwo im Rechner darzustellen,
wäre dann eben quasi der umgekehrte Schritt,
der dann eben aus so einer Darstellung letztendlich dann eben den einfach oder doppelt genauen Fließkummerwerte macht.
Gut, hier, also das auch nochmal so ein bisschen vorneweggenommen,
ich weiß nicht, inwieweit ist also Java, Java,
Coach und dran war.
Das ist also auch nur so ein kleines Beispiel,
wie man jetzt im Prinzip sowas,
also auch selber programmieren könnte,
wenn man damit so ein bisschen rumspielen möchte
Naja, also da gibt es also letztendlich hier so was wie eine Funktion,
die quasi jetzt hier drei Argumente bekommt, Signbit-Exponent und Mantiste,
das sind dann eben jeweils quasi entsprechend lange Bits drinks.
Daraus wird dann eben das Ganze in ein indiger Wert,
also ein 32-Bit-Wert kodiert, dadurch, dass man sagt,
okay, ich nehme jetzt also hier diesen Dies oberste Bit
oder dies Bit für das Sign Bit.
Ich mag die, maskiere das, also quasi jetzt,
also dass ich eben nur genau diesen einen Wert habe,
schiebe das um 31 Stellen nach links.
Wie gesagt, also mit diesen Operationen wird dann,
insofern das nicht bekannt ist, dann,
also denke ich mal, noch in der Softwareentwicklung genau vorgestellt.
Also hiermit ist eigentlich gemeint, dass man also irgendwie solche Pits
drinks hat und die dann entsprechend diesen Fall jetzt nach links um eine Anzahl von Stellen verschieben kann.
Und letztendlich würde das jetzt dazu führen, dass eben quasi das,
was hier drin steht, Hals Null oder als Eins,
als am weitesten links stehendes Bit einer Entager-Zahl quasi dasteht und alle anderen Bits dahinter sind bei dieser Operation in diesem Fall dann Nullen.
So ähnlich wird dann quasi der Exponenz zerlegt,
also auch da wird, ob es dieses Argument genommen,
auf Zwei-Bett quasi beschnitten über so eine Maskierungsoperation,
das ist ein bisschen blöd,
weil also auch das kommt dann erst später noch und um drei 23 Bild verschoben,
dass man das dann,
also wenn ich jetzt hier quasi von so einem String ausgehe,
dann eben quasi an genau diesen Stellen in so einem 32 Bitwatch stehen hat.
Und gleich mache ich dann eben hier für die Mantise.
Nicht anschließend wären die dann also miteinander verknüpft.
Das heißt also letztendlich dieser Teil, plus dieser Teil,
plus dieser Teil in ein einziges Wort zusammengebracht.
Und das wird dann als Fließkommazahl interpretiert und ausgegeben beziehungsweise hier mit dieser Operation
wird dann quasi von diesem zusammengebauten Entager-Wert das Ganze ausgegeben,
hindern würde man dann eben entsprechend sehen,
wie diese Zahl dann umgerechnet aussieht.
Wie gesagt, das Ganze auch nur als Beispiel
findet sich auch so als Kotausschnitt auf der Webseite,
die man sich runterladen kann,
wo man sich den Code
mal ansehen kann
Ja, und was ich dann letztendlich laufen lassen kann,
in diesem Fall ist es jetzt also für einen ganzen Satz von unterschiedlichen Argumenten oder Zahlen gemacht,
wo ich dann also quasi hier als Bitstring einmal was kodiert habe,
was dann eine minus eins ist,
was dann also hier entsprechend so aussieht und dann eben für verschiedene unterschiedliche Zahlen.
Na hier,
das wäre dann also quasi nochmal die Ausgabe, das,
was sie
gerade eben live vorgeführt habe
Gut, wie sieht das bei den Formaten jetzt mit arthmetischen Operationen aus?
Addition und Subtraktion. Bei Gleitkommazahn macht man das also folgendermaßen,
dass man also quasi den Betragsmäßig kleineren, so manten,
so umbaut, dass die Exponenten angeglichen werden.
Das heißt, der wird eben entsprechend verschoben,
bis er dann eben den gleichen Exponenten hat, wie die betragsmäßig größere Zahl,
führt eben dazu, dass quasi die Mantesse Dann von 1,0,
also den 23 Stellen dann eben immer weitergeschoben wird.
Was dann eben auch dazu führt, dass bei dieser kleineren Zahl
sich dann eben die effektive Genauigkeit natürlich deutlich verringert oder verringern kann. Das heißt,
wenn ich, weiß nicht, ob ich immer irgendwie ein schickes Beispiel,
wo man das jetzt mal so direkt sieht, Gut,
also es ist hier nicht so,
aber also wenn ich jetzt also hier diese Zahl nehmen würde und hier jetzt den,
naja, das ist jetzt auch blöd, weil da habe ich schon 227, wo ich jetzt also wenig schieben kann.
Gut nehmen, also hier dieses Beispiel,
wo ich also hier als Exponenten 1 habe,
wenn ich das jetzt verrechnen würde mit einer Zahl,
die es in entsprechend größeren Exponenten hat, wird diese Zahl hier letztendlich
Der Exponent, angepasst, was eben heißt, diese 1,
1, 1, 1 und dann hier diese ganzen Nullen werden nach rechts geschoben.
Das heißt, diese Bits waren dann hierüber und das,
was ich hier unten, gut,
in diesem Fall bei dieser Zahl nicht, aber das,
was sich da unten letztendlich noch an irgendwelchen gesetzten Bits habe,
anstellen, verschwindet.
So, und was man dann eben sieht,
wenn der Exponente sich jetzt mehr als 23 unterscheidet, Ähm,
verschwinden hier quasi letztendlich der Reihe nach wirklich alle Bits.
Und ich habe dann eigentlich nichts mehr nach. Und das,
was ich dazu addiere, wird dann eben letztendlich zu null.
Das ist also das, was da jetzt mit dieser effektiven Genauigkeit gemahnt ist.
Nicht, wenn sich die Exponenten jetzt nun wenig unterscheiden,
dann verliert man teilweise Genauigkeit, wenn sie sich sehr stark unterscheiden.
Verliert man entsprechend sehr viel. Beispiele dazu kommen.
Auch gleich. So, hier sieht man
das Ganze
Wie das also letztendlich, also jetzt hier nicht im Dual,
sondern im Dezima-System aussehen würde.
Also ich habe hier eine Zahl A, 9,7255x10 und 707,
eine Zahl B, 3,016x10.6 möchte die addieren.
Das, was man macht, ist, dass quasi hier
also für diese Zahl B dann eben auch der Exponent 10 hoch 7 wird.
Das heißt, wird jetzt eben hier um einen nach rechts verschoben.
In diesem Beispiel wird die genau ich oder bleibt die Genauigkeit erhalten,
weil ich dann also hier von dreien Nachkommastellen,
also hier auf einmal auf vier Nachkommastellen übergehe,
wenn ich das jetzt irgendwo in der Computer-Hardware mache und nicht auf dem Papier mit einer begrenzten Genauigkeit,
wo dann eben dieses niederwärtigste oder niederwärtigste Stelle dann eben verschwinden.
Gut, hier wird das jetzt eben entsprechend angeglichen,
anschließend kann man also aufgrund des Defcerotivgesetzes eben den Exponenten rausziehen
und muss dann eben letztendlich nur noch rechnen,
diese 9,777725 plus 0, 3016. Dann habe ich hier wieder
einen neuen Wert. Was dann eben passieren kann, ist,
dass ich durch die Addition eine zusätzliche Stelle vorne gewinne.
In diesem Fall wird daraus dann eben eine 10, irgendwas.
Und was man dann eben machen müsste, ist,
dass man das Ergebnis dann eben auch wieder normalisiert.
Das heißt eben, in diesem Fall jetzt eben noch einen weiter schiebt,
bis ich dann also zu diesem Ergebnis komme. So,
und was dann passiert oder passieren kann, ist,
dass wenn ich jetzt eben eine bestimmte Stellenanzahl fest habe,
man dann eben hier jetzt irgendeine Rundung machen muss
Ich meine, je nachdem, wie man das ansetzt,
kann man sagen, also die Rundung findet hier schon statt.
Das wäre jetzt natürlich schlecht, weil da verliere ich dann
also schon mal relativ viel an Genauigkeit.
Meistens werden immer hier noch ein bisschen ein paar Stellen mitgeführt
und irgendwann am Ende wird dann gerundet. So,
das führt eigentlich zurück auf diese Aussage, die ich mal hatte,
als ich diese Begriffe mit der Informationstheorie hatte, Informationstreu,
dass eben genau diese Addition oder das für die Addition bei Fließkommazahlen eben letztendlich nicht gilt.
Das heißt, dadurch, dass ich hier aufgrund Diese arathmetischen Gegebenheiten,
wo ich dann eben was abschneiden muss, letztendlich Stellen verliere,
verliere ich dann eben auch entsprechende Informationen.
Gut, hier auch noch mal aufgestellt, eben letztendlich diese Probleme,
die sich bei der Subtraktion ergeben können. Zum einen eben,
wenn die Exponenten stark unterschiedlich sind, was sie eben schon gesagt hatte,
dann wird eben die kleinere Zahl so weit skaliert,
dass eigentlich keine gültigen Bits mehr übrig bleiben.
Das heißt, Die geht also quasi letztendlich gänzlich unter oder
das Ergebnisse sehr stark ungenau.
Dieses eine Beispiel hatte ja auch schon gebracht.
Nicht also 1,0 mal 10.20 Uhr plus irgendwas,
was so ein bisschen sowas in Richtung P aussieht.
Und als Ergebnis erhält man an 1,0 mal 10.20 Uhr.
Anderes Problem, was auftreten kann, ist,
dass wenn die Exponenten gleich sind und die Mantissen fast gleich sind,
dass sich fast alle Bits in der Mantisse auslöschen
Und das Resultat dann eben nur noch sehr wenige Bits an
effektiver Genauigkeit aufweist. Wenn ich also beispielsweise nehmen wir jetzt,
also ich hätte, wenn wir mal sehen können,
was Sie hinkriegen.
Also ich hätte jetzt irgendwie sowas wie zwei Zahlen
Also 1,01, 01, mal 2 hoch 100 irgendwas.
Oder nein, 2 hoch 1,00. Sollte jetzt
rechnen minus 1,01, 0. Null, mal 2 hoch 1,00.
Nicht das, was jetzt passiert
Ähm, ja, kann ich also mal kurzfristig machen für mein scheußliches Beispiel.
Einen Moment, zack. Hör so. So, ähm
, sieht man da jetzt ein bisschen mehr? Gut,
also wie gesagt, die Zahlen im Großen und Ganzen
gleich unterscheiden sich jetzt hier wirklich nur an irgendwelchen wenigen Stellen.
Ich rechne in diesem Fall, also eine Subtraktion war,
also dann kriegt man, kriege ich den Effekt jetzt also hier noch irgendwie einigermaßen schnell hin.
Gleicher Exponent. Ich und das, was man dann ja einfach rechnet,
ist, also hier wird quasi eine Null draus,
hier löscht sich alles aus und irgendwie so an der niederwärtigsten Stelle bleibt also quasi noch ein einzelnes Bit über.
So, und das, wie gesagt,
war es jetzt, also hier gemeint ist,
das Resultat hat nur noch wenige Bit effektiver Genauigkeit ist,
eben durch diese Auslöschung fahren also hier erst mal sämtliche Stellen weg.
Das Ganze wird normalisiert. Ich habe aber jetzt in
diesem Fall hierhin nur noch eine einzige Stelle gehabt.
Alles, was dahinter ist, ist ja dann also
irgendwie bei der begrenzten Wortlänge der Mante ist verschwunden.
So und anschließend habe ich hier dann eben wieder irgendwie eine Normalisierung.
Das heißt, habe dann eben 1,
und dann eben hier lauter Nullen und der würde dann eben hier entsprechend vergrößert werden,
dass sich da dann eben entsprechend anderen Exponenten habe oder einen angepassten Exponenten habe.
Also das ist das, was eben gemeint ist, Jetzt mit dieser effektiven Genauigkeit,
dass also quasi das, was dann als Ergebnis überbleibt,
sich eigentlich nur aus einigen wenigen Stellen eine Mantisse heraus ergibt.
Na gut, kann man so auch lesen, dann lasse ich das Licht jetzt einfach an.
Gut, wie sieht das bei Multiplikation und Divisionen aus?
Dort macht man typischerweise dann eigentlich immer Fondses Vorgehen, dass man sagt,
okay, Dadurch, dass das Vorzeichen explizit kodiert ist,
kann ich im Prinzip dann auch einfach aus den beiden Vorzeichen das Vorzeichen des Ergebnisses bestimmen,
rein technisch würde man dort dann einfach so was wie so eine Exklusiv- oder Berechnung machen. Ich hoffe auch,
weil ich da jetzt also auch schon wieder vorgreife,
also exklusiv oder wäre, wenn ich im Prinzip Folgende Wertetabelle habe,
ich habe hier meine Bits 0 und 1 und in dem Fall in dem Fall,
dass beide ich nur genau eine einzige 1 habe,
das heißt eins, exklusiv oder 0 ist eine 1,
hier entsprechend Äquivalent dazu und wenn ich eben den Fall habe,
null, X or 0 ist null und 1,
X or 1 ist eben auch eine Null,
nicht dass das quasi der Unterschied höher zu dem normalen logischen oder,
wo ich an dieser Stelle eine Eins hätte.
Gut, also damit kann man dann eben sehr einfach das Vorzeichen bestimmen,
sprich positive und negative Zahl miteinander verrechnet ist, negativ,
wenn beide positiv sind, ist das Ergebnis priositiv in beide negativ sind,
ist das Ergebnis negativ auch positiv,
das ist dann nämlich genau dieser Fall.
So, die Exponenten werden addiert Die Mantisen miteinander multipliziert und
gegebenenfalls muss dann eben das Resultat noch normalisieren.
Das heißt also für die Multiplikation fördern eben letztendlich so eine
Operation stattfinden. Bei der Division eben entsprechend,
also auch da kann man entsprechend einfach bzw. die Falls also
durch so einen XOR das Vorzeichen bestimmen,
die Mantisen durcheinander teilen und die Exponenten voneinander subtrahieren
Gut, das, was man da noch braucht bei der,
diesen Zahlendarstellung, ich hatte ja also auch schon gesagt,
sind dann eben noch spezielle Werte für unendlich.
Sowas wie Nord an Number, nicht darstellbar,
beziehungsweise dann eben für die Null, was man dann eben auch braucht,
um beispielsweise in irgendwelchen arathmetischen Zwischenberechnungen relativ einfach weiterarbeiten zu können.
Ich froh dann letztendlich dann klar wird,
ich habe Ja null, ich habe irgendwas,
womit ich nicht mehr weiterrechnen kann oder ich habe eben irgendwie einen unendlich großen Wert.
Wenn ich unendlich, wie gesagt,
sie ist ein spezieller Wert, sowohl positiv,
also negativ möglich, wenn ich jetzt eben irgendwelche Werte habe,
die jetzt also mit den normalen Zahndarstellungen.
So, sie nicht geben können. Letztendlich asymptotisch ging unendlich
gehen. Nord the number ist jetzt eben für ungültige Operationen,
also sprich Wurzel aus einer negativen Zahl und solange ich da
jetzt also nicht zu komplexen Zahlen übergehe,
kann ich das also im Reellen nicht darstellen
Nicht, wenn ich hier jetzt irgendwie mit sowas mache,
wie unendlich, durch, unendlich, würde eben zum Beispiel
auch sowas wie Northern Number rauskommen bei den aratmetischen Systemen.
Und eben bei so ein paar anderen Operationen auch. Gut,
wir sehen jetzt generell diese Zahlendarstellungen aus dem Artraple E754 Format.
Das, was ich bislang immer gezeigt hatte, sind also diese normalisierten Zahlen.
Das heißt, immer mit dieser 1, implizit vor der Mantisse.
Das heißt, ich habe mal ein Vorzeichen. Ich habe
einen Exponenten, der ist größer als null. Und kleiner als der Maximalwert,
der sich jetzt also bei so einem,
wenn ich jetzt zum Beispiel bei 32 Bit integr bleibe,
acht Bit, wäre der Maximalwert also quasi die 128,
nämlich 255 minus 127, der ist dann eben auch nicht zugelassen,
nicht dem zuvor gewährt, also so eine Kodierung,
wo ich also im Exponenten lauter Einsen habe,
dann eben auch keine normalisierte Zahl mehr.
So, und dann habe ich eben hier quasi jetzt für die Mantesse mein Bittmuster,
wo ich dann eben implizit diese Eins habe und als Bittmuster dann eben entsprechend die Nachkomma stellen.
Denomalisierte Zahlen sind dann eben entsprechend sehr kleine,
wo Man sagt, ich habe explizit,
was ja hier also als Grenze auch nicht zulässig war,
einen Exponenten von null, sprich zwei, hoch minus 127 bei 32 Bit.
Und dann aber hier eben irgendein Wittenmuster,
was dann quasi so interpretiert wird,
dass ich hier jetzt eben nicht mehr 1,
irgendwas habe,
sondern eine Null und dann eben noch irgendwelche Stellen dahinter
eben bis zu den maximal noch bei 23 späte
Und das Ganze mit dem Exponenten von zwei hoch, minus 127 dann.
Die Null wird eben kodiert, als Exponent Null und Mantissel Null. Und mit Exponent,
gleich 255, das heißt also lauter Einsen,
jetzt beispielsweise bei der zwei 32 Bit Fließkomma-Darstellung,
kodiert man dann eben diese Werte für Infinity und Nord- und Number,
Infinity lauter Einsen und hier dann eben als Matisse eine Null oder nur Nullen,
Nord- und Number, hier lauter Einsen und eben hier irgendein beliebiges Bitmuster,
was dann eben mindestens einer Eins enthält.
Gut, teilweise kann man eben mit den so kodierten Werten jetzt,
also für Infinity oder Nord- und Number,
also auch noch so ein bisschen rechnen,
also sprich null durch unendlich würde Null ergeben, nicht,
das heißt, damit kann man also zumindest noch weiterrechnen,
wie gesagt, Nord- und Number ist dann eben für irgendwie solche undefinierten Werte,
also Wurzel aus, oder Quadratwurzlaus, einer negativen Zahl,
Axin von 2,0 und so weiter.
So, und Operationen mit Norton Number liefern dann eben
auch immer als Ergebnis irgendwie Norton Number.
Weiß ich jetzt nicht, vermute ich mal. Also letztendlich,
da geht es nur darum, dass die Mantesse nicht null ist,
sondern eben nur irgendwo einer eins.
Da wird aber eigentlich noch nicht weit jetzt geguckt oder interpretiert,
also wie dieses Bitmuster aussieht, also was sich damit tut.
Muss ich zugeben, also ich habe jetzt also auch noch irgendwie kein Fließkomma-Rechenwerk,
also wirklich jetzt selber entworfen. Also es kann sein,
dass sich die Splitmuster vielleicht noch ändert, also einfach,
weil man das jetzt also aus der Art und Weise,
wie das dann also quasi durch die Schadungslogik vielleicht noch verarbeitet wird,
dass man dort entsprechend was macht,
aber letztendlich,
also von der logischen Funktionalität wird also hier jetzt nicht weiter unterscheiden,
was sich dort noch irgendwie tut
Gut, auch dazu gibt es dann so ein kleines Java-Programm,
was man dann also ausführen lassen könnte,
wo dann einfach mal hier so bestimmte arithmetische Ausdrücke genommen werden,
berechnet werden, das Ergebnis wird ausgegeben oder eben als Norton Number beziehungsweise Infinity dann eben entsprechend jetzt zeigt,
also hier sieht man dann quasi die Ausgabe von dem Programm,
sprich was kommt jetzt eben aus,
wenn ich zum Beispiel 0 durch 0 teile,
dann also in diesem Fall Norton Number,
nicht wenn ich eins durch 0 teile,
infinity minus eins durch 0 würde, negativ unendlich ergeben.
Eins durch unendlich, wo dann eben 0,0 ergeben.
Hier dann eben auch noch so ein paar Rechnungen,
die sich also mit diesem Infinity ergeben, wo man ein bisschen aufpassen muss,
ist dann in Bezug auf Vergleiche, beziehungsweise generell Vergleichsoperationen.
Wenn ich also quasi hier einen Vergleich habe und frage
Nord and Number ist gleich Nord and Number.
Das würde eben Nicht Tschuh, sondern Falls liefern. Das heißt,
es ist jetzt also nicht so was wie jetzt,
also ich betrachte ein String und das eine ist keine Zahl,
das andere ist keine Zahl, sondern da ist halt einfach vordefiniert,
es kommt immer Falls raus.
Und Vergleich von Infinity und Not a Number wurde in
diesem Fall dann also auch ein Falls liefern.
Also auch das ist etwas,
was sie ja so jetzt vielleicht nicht ganz so der Logik erschließt,
was dann aber irgendwo in diesem Sprachstandard erstmal so definiert ist
Also das gehörte eben zu den Sachen, muss man sagen
, ist festgelegt. Gibt es dann also. Gut,
ansonsten hinsichtlich der Rechnung oder dieser Rechenregeln,
worauf ich jetzt also noch gar nicht weiter eingegangen bin,
ist jetzt eben die Art und Weise, wie gerundet wird.
Auch dazu findet man eine Literatur bzw. eine entsprechenden Beschreibung von den Bibliotheken,
was, wie das also letztendlich gehandhabt werden kann.
Also da gibt es dann eben auch mehrere Arten und Weisen,
wie man jetzt also quasi mit Rundungsregeln umgeht
Fragt man sich natürlich,
okay, wofür brauche ich das, warum unterschiedliche Runden,
nicht wenn ich also hier irgendwie was habe und ich habe Nachkommastellen im Dezimalsystem,
nicht dann würde ich jetzt zum Beispiel auch sagen,
wenn ich da so irgendwie 1,49 habe,
dass auf eine Nachkommastelle Runde, nicht dann gucke ich,
was ist also die eine Stelle dahinter,
also die 1,9 und dann wird also von 5 bis 9 aufgerundet und von 0 bis 4 abgerundet,
einfach weggeschnitten.
Bisschen schwieriger wird das jetzt eben bei Sachen, wenn ich
negative Zahlen zulasse, Kann ich dann auch einfach abschneiden.
Dann würde ich quasi in Richtung der nächstgröße oder eigentlich nichts kleineren,
also betragsmäßig größeren Zahlrunden oder rundig in Richtung der Null.
Das heißt, da ergeben sich dann eben teilweise unterschiedliche Interpretationsmöglichkeiten.
Und bei sehr kleinen Zahlen, auch in beiden Richtungen,
gibt es dann eben auch ähnliche Effekte.
In dem Zufolge kann man da dann eben auch unterscheiden.
Also wie gesagt, also beispielsweise in diesem Wikipedia-Artikel ist das
also auch nochmal ganz kurz angerissen
In Bezug auf die Rundung, auch nur kurz erwähnt,
gibt es dann eben auch noch diesen Begriff der ULP,
Unit in the Last Place,
das ist dann quasi immer die Genauigkeit oder die Wertigkeit einer letzten Stelle.
Also im Dezimasystem ist die Wertigkeit in der letzten Stelle eins.
Ich war, oder nein, für Angels der Zahlen,
vielmessy Wertigkeit der letzten Stelle eins,
nicht weil quasi mit einer Erhöhung der Stelle gehe ich
eben immer
einen weiter
Fließkommazan kann ich jetzt eben letztendlich sagen, abhängig,
mit welchem Exponent ich arbeite, kann eben dieses ULP,
sprich die niederwertigste Stelle der Mantise,
ein sehr großer Bereich sein,
wenn ich das jetzt in Engineer übersetze,
wenn ich da also sage,
mal 10 hoch 23,
dann ist eben
quasi die vierte Stelle dahinter eben schon 10 hoch
Wenn ich jetzt der kleine, negative Zahlen oder sehr kleine Zahlen habe,
dann ist eben die letzte Stelle dann eben auch ein entsprechend kleiner Wert.
Das ist also auch genau das, was an diesem Zahlenstrahl
da mit diesen unterschiedlichen Abständen so ein bisschen angedeutet war.
Gut, formal bezeichnet kann man jetzt eben immer sagen,
niederwärtigste Stelle oder niederwärtigstes Bit, das ist eben letztendlich das,
was also da als ULP gemeint ist,
nicht rein praktisch Wertigkeit, das liest significant bitter.
Also das heißt, wenn ihr werdet diesen Stelle der Mante ist.
Das ist dann eben auch ein Maß für die erreichbare Genauigkeit.
Und die Frage ist jetzt eben bei diesen Rechenoperationen,
wenn ich jetzt eben sowas wie Addition mache wie Multiplikation, wie genau rechnen die?
Und da wird eben quasi in dem Standard gesagt,
also für die üblichen Operationen, arbeitet man da eben mit einer Genauigkeit von 0,5 ULP.
Das heißt, der Bestmögliche wert, das heißt,
bei diesen Operationen wird eigentlich ähnlich,
wie ich das also jetzt hier im Dezimalsystem gemacht habe,
eben zwischenzeitlich hier nochmal während der Operation quasi die Wortbreite vergrößert,
dass sich dann eben hier hinten auch noch so was wie eine zusätzliche Stelle habe,
um eben zu entscheiden, wird auf oder abgerundet.
Das heißt, es wird eben nicht schon vorher an
dieser Stelle gerundet. Nicht, das ist das,
womit ich also hier quasi diese 0,5 ULP erreiche
Bei anderen Programmen oder anderen Bibliotheken oder eben auch Mathematiksoftwareen,
also irgendwie sowas mit Mattlab macht oder rechnet,
da werden eben auch entsprechende Genauigkeiten, also für weitere Funktionen,
also gerade jetzt irgendwelche weiteren Trigonometrische Funktionen,
eben auch noch mit angegeben.
Und teilweise, wenn man jetzt eben entsprechende Genauigkeiten braucht,
gibt es das dann eben auch noch in Form von Programmiersprachenunterstützung beispielsweise über entsprechende Klassen,
die dann also irgendwie sowas mit angeben,
wo man das dann also abfragen, beziehungsweise dann handhaben kann.
Wenn ich aber letztendlich, was sie eben schon kurz angedeutet hatte,
rundungsfehler bei Fließkomazahlen treten, eben letztendlich. Immer auf,
einfach aufgrund der begrenzten Stellen Wortanzahl, wo ich dann eben sagen muss,
irgendwann habe ich jetzt nicht mehr Stellen in der Mantesse,
muss abschneiden.
Nicht zwischenzeitlich um die Berechnung eben hinreichend genauer zu machen,
kann man dann eben noch mehr Stellen haben,
aber irgendwann wird es
eben abgeschnitten
Gut, wird jetzt hier weiter nicht vorgestellt, ist aber eben teilweise interessant,
wenn man jetzt wirklich also solche arathmetischen Sachen macht,
beziehungsweise wenn man mit den Zahlen rechnet,
dann sollte man sich da entsprechend im Sprachstandard,
also nochmal ein Ansehen, wie das jetzt gehandhabt wird,
wobei da eben so ein bisschen das Problem ist,
etwas, was sie jetzt also auch noch kurz ansprechen würde,
es ist also schwierig allgemeine Aussagen zu treffen,
weil also sowas wie Zahlendarstellung, arathmetische Systeme,
Genauigkeiten hängen, eben sehr stark davon ab,
mit welchem Computer ich arbeite,
welche Hardware dahinter steht.
Teilweise mit welcher Programmiersprache ich arbeite, teilweise mit welchem Compiler ich arbeite.
Demzufolge ist es auch jetzt teilweise immer noch so,
dass man sagen kann, okay, ich habe einen Algorithmus,
beispielsweise ein C irgendwie oder ein C plus programmiert.
Ich lasse ihn also irgendwie auf der einen Architektur laufen,
übersetzt ihn, also von einer ansprechenden anderer Hardware und der
kann sich dann eben teilweise anders verhalten,
zumindest bei der Berechnung,
mit Fließkomma zahlen
Gut, dazu, hier jetzt also auch schon mal kurz ein bisschen was angedeutet,
auf das, was man dann also dann nachher auch noch sehen werden, Datentypen im Rechner,
das heißt, wir werden die Daten dort irgendwo kodiert,
typischerweise hier dann immer als Maschinenworte, wo man dann eben sagt,
in dem Rechner habe ich eine bestimmte Wortlänge.
Gut, inzwischen können wir sagen, gut,
bei den aktuellen PCs, Max, was auch immer,
ist man da eigentlich so bei 64 Bit-Rechnern, vor einiger Zeit war das.
Also im PC-Bereich dann auch irgendwie 32-Bit,
wenn nicht irgendwie sowas wie kleiner, eingebettete Systeme habe,
die haben deutlich kleinere Wortbreiten, weil man das dann vielleicht noch nicht braucht,
wenn man vielleicht sowieso auch gar nicht jetzt zwingt,
überhaupt so was wie eine Fließkomma-Berechnung macht oder genauer machen muss,
nicht,
weil man dauert dann also quasi mit irgendwelchen Festpunktdarstellungen vielleicht
also auch auskommt
Gut, Maschinenwort trotzdem, also irgendwie sowas nehmen wir jetzt hier,
also einfach mal irgendwie 64 Pitt oder 32 Pitt eben,
der typische Wert eines Entager-Wertes und meistens auch das,
was man jetzt quasi als Speicheradresse letztendlich hat.
Gut. Bis vor einigen Jahren waren das eben 32 Pitt-Rechner,
das heißt die Wortlänge von Entager ist 32 Bit,
der hat dabei mit adressierbare Speicher weil die Speicheradressierung dann meistens immer,
jetzt nicht auf Worte, sondern auf einzelne Bytes geht,
wäre dann also 2 hoch 32 Bytes,
also 4 Geebybyte.
Gut, inzwischen ist man mit den Speichergrößen,
Asien und auch darüber hinaus,
hat aber jetzt eigentlich auch seit mehreren Jahren in der Architektur
dann also sowieso 64 Bit Architekturen
Gut, hier auch noch mal kurz angedeutet,
welche Datentypen dann nehmen teilweise von den Prozessoren unterstützt werden,
die dann also auch jeweils in den entsprechenden Programmiersprachen,
also ich habe hier meistens im AC oder Java-Beispiele dann entsprechend beschrieben werden,
hier auch noch mal vorneweg gegriffen,
denke mir wird aber aus der Programmierung also vielleicht auch schon bekannt sein,
nicht NC habe ich dann noch irgendwie sowas wie so ein Zeigertyp,
entweder auf ein Objekt oder einfach nur generell auf eine Speicheradresse,
also irgendwie sind es Zeiger of Word.
Nicht, dass wir dann eben auch ein entsprechendes Wort oder ein entsprechendes Element,
wo man dann eben im Prinzip ein einzelnes Speicherworte ansprechen kann.
Gut, hier auch so ein bisschen historisch zu sehen,
Beispiele für die Anzahl der Bytes. Gut, ich denke mir
jetzt wird in Softwareentwicklung ja, glaube ich, auch immer Java gemacht
Ja, gut. Da hat man nämlich den Vorteil,
dass da ist das alles in der Sprache festgelegt, in anderen Programmiersprachen,
also hier ist in dem Fall dann also Negativbeispiel in C,
würde das dann nämlich so aussehen,
dass also quasi es zwar vordefinierte Datentypen gibt, Integer,
Long Entager, Character, Shortfloat, Double,
also 32 Bit oder 64 Bit,
Fließkomma Long Double Ward,
sowas wie ein Speichertyp
Wieder zu interpretieren ist, ist dann aber eigentlich vom Prozessor in diesem Fall jetzt abhängig.
Also wenn man jetzt irgendwie so ein 64-Bit-Prozessor nimmt,
gut, die gibt es inzwischen auch nicht mehr,
aber der erste war im Prinzip von Dector Alpha,
hätte ich dann eben typischerweise sowas bei Zagertypen dann eben acht Byte,
nämlich genau die 64-Bit,
die dann also quasi ein Speicherwort als Adresse darstellen.
Wenn ich eine 32-Bit-Architektur habe oder das,
was eben früher in den Intel-Architekturen, also ihr 32 ist,
dann ist eben so ein Voyzeiger Vierbyte groß, Genau eine Speicheradresse.
Und so ergeben sich dann eben Unterschiede und gerade dann eben bei den Fließkomma-Formaten.
Also Float und Double ist dann eigentlich noch vereinheitlicht.
Bei Long Double gibt es dann aber teilweise dann eben auch noch was,
wo man dann also sagt, naja gut,
also hier ist man dann also quasi auf Intel-Architekturen dann also
schon so in dem Bereich von drei Speicherworten gegangen,
um nochmal eine zusätzliche Neuigkeit zu haben.
So, noch schlimmer ist das,
wenn man das also jetzt hier die eine Tabelle,
die ich ja sich aus diesem Paper hier gezogen habe,
ansieht, wo jetzt also quasi gezeigt ist für Unterschiedliche Speicherwortbreiten,
also 16, okay, das ist im Großen und Ganzen historisch zu sehen.
Das haben wir nun heute eigentlich nicht mehr, aber 32 Bit oder 64 Bit,
wo im Prinzip jetzt also ein C-Programm genommen wurde und mit unterschiedlichen Compilern beziehungsweise unter unterschiedlichen Betriebssystemen übersetzt wurde.
Und da fällt dann eben auf,
dass also quasi auf so einer 32-Bit-Architektur der Microsoft-Compiler,
letztendlich diesen Typ Long-Double zu achtbart, der Intel Windows-Compiler,
das zu zwölf Bad gemacht hat, der auch der Compiler von Intel,
aber unter Linux oder nahezu 16 Bad,
hat er also zwölf Bad draus gemacht.
Das heißt, es ist also erst mal mehr oder
minder erratisch, wie dann eigentlich solche Datentypen aufgelöst werden.
Also das heißt, da sieht man schon,
welche Probleme dann vielleicht auch auftauchen können,
also gerade hinsichtlich der randmedischen Genauigkeiten
Es da sehr, sehr viele unterschiedliche Einflussmöglichkeiten gibt. Wie gesagt,
also hier kann man eben grob unterscheiden, so ein bisschen vom Betriebssystem,
aber auch innerhalb eines Betriebssystems schon verwenden, ein Compiler abhängig.
Gut, bei Java, wie gesagt, haben wir das,
dieses Problem glücklicherweise nicht. Aber ja. Gut, damit,
während ich jetzt eigentlich mit diesem Bereich Ziffern und Zahlen fertig,
würde jetzt nahtlos übergehen zu einem Wasser eigentlich auch schon mit vorgestellt wurde,
wo es nämlich um noch,
oder zum großen oder zum Teil ja auch schon behandelt wurde,
wo es ja nämlich eigentlich nochmal um die Aratmetik geht.
In diesem Fall Aratmetik nochmal so ein bisschen vor dem Hintergrund,
wie mit den Zahlen gerechnet wird,
jetzt innerhalb der Zahlendarstellung gerade hinsichtlich begrenzter Wortlängen.
Was sich dort also letztendlich ergeben kann. Ein paar Sachen wiederholen sich,
da werde ich dann also entsprechend schnell über die Folien rübergehen.
Hier, wie gesagt, nochmal so ein paar Folien zur Wiederholung.
Also wir arbeiten ja also irgendwie mit einem Stellenwertsystem,
Radexdarstellungen haben eben immer generell diese Summe koeffizient mal
B hochi bei uns
Typischerweise in der Rechnarienmetik, im Dualsystem, so das,
was wir eigentlich aus der Schulmathematik kennenlernen, im ganz normalen Dezimalsystem.
So, die Folie hatte ich ja,
so war es schon, hier jetzt nochmal zu dem,
was ich jetzt also gerade eben auch schon kurz angesprochen hatte,
wo es also letztendlich darum geht, wie sehen die Zahlenbereiche aus,
wie gesagt, bei Java gibt es 16,
32 und 64 bis 2 Compliments zahlen.
Es gibt dann also quasi als Freiparkklassen Short in the Joint Long,
womit sich dann als entsprechenden die Wortbreiten ergeben.
Und ich kann dann eben Short Max Value, Intager-Min-Value,
NHM Max Value, Long, Min Value und so weiter.
Mir entsprechend dann also irgendwie anzeigen lassen. Und das ist also
letztendlich in der Sprache fest definiert. In der Sprache C,
wie gesagt, Formbetriebssystem von anderen Sachen abhängig,
wo sich das Ganze eben entsprechend unterscheiden kann, in Bezug auf
Die ganzen Darstellungen von Zahlen gibt es im Prinzip entweder unsigned,
was dann eben eine ganze Zahl ist von typischerweise vier oder acht Byte und dann eben Zweier-Komplimentzahlen, die dann quasi Science sind.
Da dann aber eben Plattformabhängig beispielsweise unter Linux kann man sich da dann also sowas, also aus so einer Header-Datei irgendwo rauslesen. Das heißt also,
da kann ich einfach irgendwie jetzt sagen, Echt,
da gibt es dann also hier auf dem System,
wenn ich jetzt also irgendwie einen Compiler installiert habe,
also hier irgendwo diese Datei, nicht und dort sind dann,
hier jetzt also entsprechend maximal und Minimalwerte mit drin,
wobei das hier jetzt also auch dann wieder so ein bisschen zusätzlich nochmal Trickserei ist,
wo dann nämlich eigentlich noch über eine andere Bibliothek und andere Inkludenmechanismen dann hier wieder unterschieden wird,
ob ich also auf dem 32 oder auf dem 64-Bit-System
letztendlich arbeite
Gut, jetzt haben wir beschränkte Arathmetik, Addition im Dualsystem.
Auch diese Folie ist nicht sonderlich neu und nicht sonderlich tiefschürfend,
lag also alles schon mal drauf,
also wie die Addition letztendlich generell funktioniert,
ist eigentlich klar.
Was passiert dabei jetzt? Hinsichtlich der Zahlen- oder Zahlenbereiche.
Hier also aus einer Grafik,
aus Brian und O'Haloran
Entsprechend visualisiert. Ich habe Ihnen eine Wortbreite für die Operanten
von 4Bit, das heißt also irgendwelche Zahlen von 0 bis 15.
Und wenn ich die ebenentsprechend aufaddiere, komme ich dann eben
maximal bis zu allem Ergebnis von 30. Der Zahlenbereich der Operanten ist demzufolge,
oder generell jetzt also bei dieser begrenzten Wortbreite von 0 bis 2 hoch W minus 1,
für das Resultat habe ich 0 bis Zwei hoch W plus 1,
minus 2, nämlich wenn ich quasi zweimal hier jeweils größte Zahlen miteinander addiere.
So, funktioniert hier natürlich alles wunderbar, wenn ich
das Ergebnis jetzt mit einer größeren Wortbreite aufschreiben kann. Wenn ich jetzt aber eine begrenzte Wortbreite habe,
beispielsweise jetzt also bei vier Bit bleibe,
das heißt also auch das Resultat hat eine Wortbreite von vier Bit,
habe ich eben den Effekt des Überlaufs,
was also quasi dann wenn man das dann also hier in so eine Grafik bringt,
sich dann eben dadurch zeigt,
dass er so quasi nach der 15 ich dann also hier irgendwas habe,
was dann eben wieder auf einmal entsprechend kleine Werte sind.
Und dieser Überlauf ist dann eben genau in den Fällen,
wenn das Resultat größer als der größte darstellbare Wert,
also zwar auch wie Minus 1 ist,
rein praktisch kann man einfach sagen, das oberste Bit,
was ich benötigen würde, geht verloren.
So, dann habe ich irgendwie eine Zahl,
die dann aber auf einmal
deutlich kleiner ist
Hier sieht man dann eben auch nochmal angedeutet,
was sich dort dann letztendlich tun würde. Ich habe hier
meine Zahlen, solange ich also den Wertebereich nicht verlasse,
wird das eben quasi hier also auf das Ergebnis entsprechend abgebildet.
Wenn ich also hier den Wertebereich verlasse, einen Überlauf,
würde ich dann eben hier wieder in dem Ergebnis landen.
Gut, hier ist das Ganze neben auch nochmal
entsprechend Pack-Stail beschrieben
Gut, in Bezug auf den Überlauf beziehungsweise die radmetischen Operationen
dazu kommen wir jetzt eben zu der Art und Weise,
wie man Zahlen subtrahiert. Generell kann ich sagen, okay,
Dualsystem würde ich jetzt ja so irgendwie ganz normal stellenweise arbeiten,
also was weiß ich, dann eben 107,79, minus 57,
jeweils immer hier entsprechend abziehen, habe hier mal ein Ergebnis.
Genau das Gleiche kann ich eigentlich auch eins zu eins so im Dualsystem machen,
wo ich dann sage, hier eins, minus eins ist 0,
1 minus 0 ist eins. So,
dann habe ich hier 0 minus eins und genau wie das im Dezimalsystem dann eben machen würde,
würde ich dann eben schreiben, eins und habe hier einen Überlauf,
wo ich das das nächste Mal hier mit berechnen würde,
dann eins, minus eins, minus eins und dadurch hat man dann eben hier immer weiter irgendwelche Überläufe.
So, das führt jetzt eben dazu, dass also hier
diese Rechnung war es jetzt erstmal einigermaßen umständlich ist. So,
und da kommen wir jetzt eigentlich zu dem Trick,
weswegen man also überhaupt diese B-1 bzw. B-Komplimente braucht,
dass man nämlich sagt, bei einer begrenzten Stellenwortbreite brauche ich keine Subtraktion,
sondern ich kann stattdessen eine Addition mit dem B-Kompliment machen
Wieso? Wenn wir jetzt also noch mal in die letzte Woche zurückgucken,
dann war das B-Kompliment ja einer Zahl so definiert,
dass also die Sp-Kompliment der Zahl plus der Zahl gleich B hoch N ist.
Wenn ich jetzt eine feste Stellenwortlänge von N habe, kann ich
in N stellen B hoch N genau nicht mehr darstellen,
sondern das ist dann quasi das eine zusätzliche Bit,
was ich dann eigentlich noch bräuchte
Oder die eine zusätzliche Stelle, vielmehr, die ich dann eigentlich noch bräuchte.
Das heißt, bei der begrenzten Wortbreite mit Endstellen
wird eben dieses Ergebnis B hoch N zu Null.
Nämlich genau die eine höchste Stelle und hinten lauter Nullen
. Wenn ich diesen Ausdruck nehme,
kann ich dann aber sagen, na gut,
dann ist das B-Kompliment einer Zahl nichts anderes als die negative Zahl,
weil die Zahl plus der negativen Zahl
liefert als Ergebnis
die Null
Demzufolge kann ich dann eben auch sagen, wenn ich jetzt zwei Zahlen voneinander abziehen will,
brauche ich jetzt nicht irgendwie noch eine andere Operation, Subtraktion,
sondern ich rechne das einfach mit einer ganz normalen Addition.
Und addiere dann eben das B-Kompliment dieser Zahl. Entsprechender Definition kann ich dann eben auch noch sagen, x-minus y, B-minus-1-Kompliment plus 1. Das ist etwas,
was uns dann in Kapitel 11, glaube ich,
begegnen wird, wo es also quasi darum geht,
wie solche Einheiten oder Recheneinheiten, also eigentlich rein technisch logisch aufgebaut werden,
wo man dann eben auch sagen kann, also in Alus,
also in den Recheneinheiten, der Prozessoren,
brauche ich jetzt quasi keine Unterscheidung, eine Aludi-Addierten,
Aludi-Subtrahir, sondern ich muss nur die Addition haben,
dass Big minus 1 Kompliment kann ich sehr einfach erzeugen.
Das war das, was ich letzte Woche vorgestellt habe,
wo ich einfach sage, wenn ich eine Zahl habe,
werden einfach die Bits vertauscht.
Aus der Null wird eine 1, aus der 1 wird eine Null.
Und dieses Plus 1 kann ich sehr einfach machen,
indem ich dann quasi bei der Addition an der niederwärtigsten Stelle noch ein Bit hinzufüge,
was quasi auch umsonst ist,
weil wenn ich sowas wie so eine Additionslogik habe,
muss ich ja immer irgendwelche Überläufe berücksichtigen.
Der kann beim Dualsystem oder generell mit zwei Zahlen an eben
quasi immer nur eine einzelne 1 sein
An der niederwärtigsten Stelle brauche ich keinen Überlauf,
wenn ich da jetzt aber auch einen Überlauf spendiere, kann ich damit diese plus eins rechnen.
Gut. Das wären wir dann später eben auch noch sehen,
weswegen das dann eben auch entsprechend elegant so zu rechnen ist.
Technisch gesehen. Gut, was kann jetzt aber bei der Addition,
wie gesagt, bislang hatte ich jetzt hier Ansign-Zahlen,
was kann jetzt bei der Addition von Vorzeichen behafteten Zahlen eben noch passieren,
wenn ich jetzt also beispielsweise Zahlen im Zweierkompliment nehme, Wortbreite der Operanten,
sei es hier also auch beispielsweise mal auf 4-Bit begrenzt.
Der Zahlenbereich der Operanten geht dann eben von minus 2 hochwortbreite
minus 1 bis 2 hochfortbreite minus 1 minus 1. Sprich,
8-Bit-2en-Darstellung, wenn ich jetzt nur positive Zahlen hätte,
hätte ich
von 0 bis
Wenn ich acht Bezahlen, Darstellung, Zweier-Kompliment habe von minus 128 bis plus 127.
Echt, das ist das, was hier da steht.
Gut, wenn ich damit jetzt rechne,
für das Ergebnis von zwei Zahlen kann sich ergeben,
die zweimal diese Zahl wäre dann minus zwei UW,
beziehungsweise zweimal die größte Zahl addiert.
Es war auch wie minus ein,
ja zwei UW minus zwei
So, hier ist das Ganze dann eben schon entsprechend visualisiert. Das heißt,
bei einer begrenzten Wortbreite hat man dann eben ein Überlaufen beider Richtung,
weil ich ja quasi immer den kleinsten Wert beziehungsweise den größten darstellbaren Wert hier verlasse.
Also der kleinste darstellbare Wert bei einer festen Wortbreite,
minus zwar auch wie minus eins, als Ergebnis kann ich
mal minus zwar auch wie hier haben und hier ebenentsprechend.
Das heißt, man hat also hier irgendwie so einen Bereich
mit gültigen Zahlen, hier einen positiven Überlauf und andersrum gesehen
einen negativen Überlauf
Gut,
hier ist das Ganze dann eben auch nochmal entsprechend visualisiert,
wo ich dann eben sagen kann,
also hier habe ich jetzt, also entsprechend meine Wertebereiche,
wenn ich das jetzt in Richtung eines positiven Überlaufs quasi verlassen würde,
wird das Ergebnis innerhalb der begrenzten Wortbreite,
also auf einmal statt einer sehr großen positiven Zahl eine entsprechend kleine negative Zahl und andersrum,
dass man eben aus einer betragsmäßig großen,
negativen Zahl dann eben auf einmal eine entsprechende positive Zahl bekommt.
Nicht, das ist das, was dann eben in beiden Fällen
in Form von Überläufen auftreten kann. Gut, ja,
abschließend würde ich jetzt, also diese Folie noch kurz vorstellen,
ansonsten kommen dann nachher noch ein paar praktische Beispiele dazu,
damit würde ich dann am Freitag weitermachen.
Gut, wie kann man
Überläufe letztendlich erkennen
Rein praktisch kann ich sagen, wenn ich jetzt also innerhalb
meiner Programmierung in einem Zahlensystem bin, ich bin beide Operanen,
das gleiche Vorzeichen haben und sie das Vorzeichen des Resultats davon unterscheidet.
Nicht, das heißt, ich rechne eine positive Zahl plus in einer positiven Zahl,
erhalte etwas, was, wenn ich das jetzt also mit irgendeiner Printausgabe ausgeben würde,
auf einmal als negative Zahl dasteht.
Oder umgekehrt. Als Code könnte man das dann eben beispielsweise so codieren,
wo ich dann eben letztendlich hier in diesem Fall jetzt in Java dann eben sage,
gut, also ich rechne hier Summe von A plus B und Überlauf habe ich,
wenn die entsprechend unterschiedliche Vorzeichen haben,
nein,
wenn die entsprechend gleiche Vorzeichen haben und das beim Ergebnis dann eben quasi die Summe ein anderes Vorzeichen als eben einer dieser beiden Operanten hätte.
Also dass wir dann eine Art und Weise,
wie man also Beispiel dann eben programmiersprachlich sowas mit abfangen könnte.
Gut, damit soll es für heute genug sein und
am Freitag, jetzt haben wir daran wenig weiter